Rechercher
SupportConsoleDéveloppeursCommencer un essaiContact

3.2. Inspection de l'état interne de l'application avec GDB

download PDF

Pour savoir pourquoi une application ne fonctionne pas correctement, il faut contrôler son exécution et examiner son état interne à l'aide d'un débogueur. Cette section décrit comment utiliser le débogueur GNU (GDB) pour cette tâche.

3.2.1. Débogueur GNU (GDB)

Red Hat Enterprise Linux contient le débogueur GNU (GDB) qui vous permet d'examiner ce qui se passe à l'intérieur d'un programme par le biais d'une interface utilisateur en ligne de commande.

Capacités de GDB

Une seule session GDB peut déboguer les types de programmes suivants :

  • Programmes multithreads et forkings
  • Plusieurs programmes à la fois
  • Programmes sur des machines distantes ou dans des conteneurs avec l'utilitaire gdbserver connecté via une connexion réseau TCP/IP

Exigences en matière de débogage

Pour déboguer un code exécutable, GDB a besoin d'informations de débogage pour ce code particulier :

  • Pour les programmes que vous avez développés, vous pouvez créer les informations de débogage pendant la construction du code.
  • Pour les programmes système installés à partir de paquets, vous devez installer leurs paquets debuginfo.

3.2.2. Attacher GDB à un processus

Afin d'examiner un processus, GDB doit se trouver à l'adresse attached.

Conditions préalables

  • GDB doit être installé sur le système

Démarrer un programme avec GDB

Lorsque le programme n'est pas exécuté en tant que processus, démarrez-le avec GDB : 

$ gdb program

Remplacez program par un nom de fichier ou un chemin d'accès au programme.

GDB se met en place pour démarrer l'exécution du programme. Vous pouvez configurer les points d'arrêt et l'environnement gdb avant de commencer l'exécution du processus à l'aide de la commande run.

Attacher GDB à un processus déjà en cours d'exécution

Pour attacher GDB à un programme déjà en cours d'exécution en tant que processus :

  1. Recherchez l'ID du processus (pid) à l'aide de la commande ps: 

    $ ps -C program -o pid h
 pid

    Remplacez program par un nom de fichier ou un chemin d'accès au programme.

  2. Attachez la GDB à ce processus : 

    $ gdb -p pid

    Remplacer pid par un numéro d'identification de processus réel provenant de la sortie ps.

Attacher une GDB déjà en cours d'exécution à un processus déjà en cours d'exécution

Pour attacher une GDB déjà en cours d'exécution à un programme déjà en cours d'exécution :

  1. Utilisez la commande GDB shell pour exécuter la commande ps et trouver l'ID du processus du programme (pid) : 

    (gdb) shell ps -C program -o pid h
 pid

    Remplacez program par un nom de fichier ou un chemin d'accès au programme.

  2. Utilisez la commande attach pour attacher GDB au programme : 

    (gdb) attacher pid

    Remplacer pid par un numéro d'identification de processus réel provenant de la sortie ps.

Note

Dans certains cas, GDB peut ne pas être en mesure de trouver le fichier exécutable correspondant. Utilisez la commande file pour spécifier le chemin d'accès : 

(gdb) path/to/program

Ressources supplémentaires

3.2.3. Parcourir le code d'un programme avec GDB

Une fois que le débogueur GDB est connecté à un programme, vous pouvez utiliser un certain nombre de commandes pour contrôler l'exécution du programme.

Conditions préalables

  • Vous devez disposer des informations de débogage nécessaires :

    • Le programme est compilé et construit avec des informations de débogage, ou
    • Les paquets debuginfo pertinents sont installés
  • GDB doit être attaché au programme à déboguer

Commandes GDB pour parcourir le code

r (courir)
Lance l'exécution du programme. Si run est exécuté avec des arguments, ceux-ci sont transmis à l'exécutable comme si le programme avait été lancé normalement. Les utilisateurs lancent normalement cette commande après avoir défini des points d'arrêt.
start
Lancer l'exécution du programme mais s'arrêter au début de la fonction principale du programme. Si start est exécuté avec des arguments, ceux-ci sont transmis à l'exécutable comme si le programme avait été lancé normalement.
c (suite)

Poursuivre l'exécution du programme à partir de l'état actuel. L'exécution du programme se poursuivra jusqu'à ce que l'une des conditions suivantes soit remplie :

  • Un point d'arrêt est atteint.
  • Une condition spécifiée est remplie.
  • Un signal est reçu par le programme.
  • Une erreur s'est produite.
  • Le programme se termine.
n (suite)

Poursuivre l'exécution du programme à partir de l'état actuel, jusqu'à ce que la ligne de code suivante dans le fichier source actuel soit atteinte. L'exécution du programme se poursuivra jusqu'à ce que l'une des conditions suivantes soit remplie :

  • Un point d'arrêt est atteint.
  • Une condition spécifiée est remplie.
  • Un signal est reçu par le programme.
  • Une erreur s'est produite.
  • Le programme se termine.
s (étape)
La commande step arrête également l'exécution à chaque ligne séquentielle de code dans le fichier source actuel. Cependant, si l'exécution est actuellement arrêtée à une ligne de source contenant un function call, GDB arrête l'exécution après avoir entré l'appel de fonction (au lieu de l'exécuter).
until location
L'exécution se poursuit jusqu'à ce que l'emplacement du code spécifié par l'option location soit atteint.
fini (finition)

Reprendre l'exécution du programme et s'arrêter lorsque l'exécution revient d'une fonction. L'exécution du programme se poursuit jusqu'à ce que l'une des conditions suivantes soit remplie :

  • Un point d'arrêt est atteint.
  • Une condition spécifiée est remplie.
  • Un signal est reçu par le programme.
  • Une erreur s'est produite.
  • Le programme se termine.
q (quitter)
Termine l'exécution et quitte GDB.

Ressources supplémentaires

3.2.4. Afficher les valeurs internes du programme avec GDB

L'affichage des valeurs des variables internes d'un programme est important pour comprendre ce que fait le programme. GDB propose plusieurs commandes que vous pouvez utiliser pour inspecter les variables internes. Les commandes suivantes sont les plus utiles :

p (en caractères d'imprimerie)

Affiche la valeur de l'argument donné. En général, l'argument est le nom d'une variable de toute complexité, d'une simple valeur unique à une structure. Un argument peut également être une expression valide dans le langage courant, y compris l'utilisation de variables de programme et de fonctions de bibliothèque, ou de fonctions définies dans le programme testé.

Il est possible d'étendre GDB avec pretty-printer Python ou Guile scripts pour un affichage personnalisé des structures de données (telles que les classes, les structures) en utilisant la commande print.

bt (backtrace)

Affiche la chaîne d'appels de fonctions utilisée pour atteindre le point d'exécution actuel, ou la chaîne de fonctions utilisée jusqu'à la fin de l'exécution. Cette fonction est utile pour enquêter sur des bogues graves (tels que les erreurs de segmentation) dont les causes sont difficiles à cerner.

L'ajout de l'option full à la commande backtrace permet également d'afficher les variables locales.

Il est possible d'étendre GDB avec des scripts Python frame filter pour un affichage personnalisé des données affichées à l'aide des commandes bt et info frame. Le terme frame fait référence aux données associées à un seul appel de fonction.

info

La commande info est une commande générique qui permet de fournir des informations sur divers éléments. Elle prend une option spécifiant l'élément à décrire.

  • La commande info args affiche les options de l'appel de fonction correspondant au cadre sélectionné.
  • La commande info locals affiche les variables locales dans le cadre sélectionné.

Pour obtenir une liste des éléments possibles, exécutez la commande help info dans une session GDB : 

(gdb) help info
l (liste)
Affiche la ligne du code source où le programme s'est arrêté. Cette commande n'est disponible que lorsque l'exécution du programme est arrêtée. Bien qu'il ne s'agisse pas à proprement parler d'une commande permettant d'afficher l'état interne, list aide l'utilisateur à comprendre les changements qui seront apportés à l'état interne lors de la prochaine étape de l'exécution du programme.

Ressources supplémentaires

3.2.5. Utilisation des points d'arrêt GDB pour arrêter l'exécution à des endroits définis du code

Souvent, seules de petites portions de code sont étudiées. Les points d'arrêt sont des marqueurs qui indiquent à GDB d'arrêter l'exécution d'un programme à un certain endroit du code. Les points d'arrêt sont le plus souvent associés à des lignes de code source. Dans ce cas, pour placer un point d'arrêt, il faut spécifier le fichier source et le numéro de ligne.

  • Pour place a breakpoint:

    • Spécifiez le nom du code source file et le line dans ce fichier : 

      (gdb) br file:line

    • Si file n'est pas présent, le nom du fichier source au point d'exécution actuel est utilisé : 

      (gdb) br line

    • Vous pouvez également utiliser le nom d'une fonction pour placer le point d'arrêt au début de celle-ci : 

      (gdb) br function_name

  • Un programme peut rencontrer une erreur après un certain nombre d'itérations d'une tâche. Pour spécifier un condition supplémentaire pour arrêter l'exécution : 

    (gdb) br file:line si condition

    Remplacez condition par une condition en langage C ou C. La signification de file et line est la même que ci-dessus.

  • Pour inspect l'état de tous les points d'arrêt et de surveillance : 

    (gdb) info br

  • Pour remove un point d'arrêt en utilisant son number comme affiché dans la sortie de info br: 

    (gdb) supprimer number

  • Pour remove un point d'arrêt à un endroit donné : 

    (gdb) effacer file:line

Ressources supplémentaires

3.2.6. Utilisation des points de contrôle GDB pour arrêter l'exécution lors de l'accès aux données et de leur modification

Dans de nombreux cas, il est avantageux de laisser le programme s'exécuter jusqu'à ce que certaines données soient modifiées ou consultées. Les exemples suivants représentent les cas d'utilisation les plus courants.

Conditions préalables

  • Comprendre GDB

Utilisation de points de contrôle dans GDB

Les points de contrôle sont des marqueurs qui indiquent à GDB d'arrêter l'exécution d'un programme. Les points de surveillance sont associés à des données : pour placer un point de surveillance, il faut spécifier une expression décrivant une variable, plusieurs variables ou une adresse mémoire.

  • Pour place un point de surveillance pour les données change (écriture) : 

    (gdb) veille expression

    Remplacez expression par une expression qui décrit ce que vous voulez regarder. Pour les variables, expression est égal au nom de la variable.

  • Pour place un point de surveillance pour les données access (lecture) : 

    (gdb) rwatch expression

  • Pour place un point de surveillance pour any l'accès aux données (lecture et écriture) : 

    (gdb) awatch expression

  • Pour inspect l'état de tous les points de contrôle et d'arrêt : 

    (gdb) info br

  • Pour remove un point de surveillance : 

    (gdb) supprimer num

    Remplacer l'option num par le numéro indiqué par la commande info br.

Ressources supplémentaires

3.2.7. Déboguer des programmes à fourche ou à threads avec GDB

Certains programmes utilisent le forking ou les threads pour obtenir une exécution parallèle du code. Le débogage de plusieurs chemins d'exécution simultanés nécessite des considérations particulières.

Conditions préalables

  • Vous devez comprendre les concepts de processus de bifurcation et de threads.

Déboguer des programmes forkés avec GDB

La bifurcation est une situation dans laquelle un programme (parent) crée une copie indépendante de lui-même (child). Les paramètres et commandes suivants permettent d'influencer l'action de GDB en cas de bifurcation :

  • Le paramètre follow-fork-mode détermine si GDB suit le parent ou l'enfant après la fourche.

    set follow-fork-mode parent
    Après un fork, déboguer le processus parent. C'est l'option par défaut.
    set follow-fork-mode child
    Après un fork, déboguer le processus enfant.
    show follow-fork-mode
    Affichage du réglage actuel de follow-fork-mode.

  • Le paramètre set detach-on-fork détermine si la GDB garde le contrôle de l'autre processus (non suivi) ou le laisse s'exécuter.

    set detach-on-fork on
    Le processus qui n'est pas suivi (en fonction de la valeur de follow-fork-mode) est détaché et s'exécute de manière indépendante. Il s'agit de la valeur par défaut.
    set detach-on-fork off
    GDB garde le contrôle des deux processus. Le processus qui est suivi (en fonction de la valeur de follow-fork-mode) est débogué comme d'habitude, tandis que l'autre est suspendu.
    show detach-on-fork
    Affichage du réglage actuel de detach-on-fork.

Débogage de programmes threadés avec GDB

GDB a la capacité de déboguer des threads individuels, de les manipuler et de les examiner indépendamment. Pour que GDB n'arrête que le thread examiné, utilisez les commandes set non-stop on et set target-async on. Vous pouvez ajouter ces commandes au fichier .gdbinit. Une fois cette fonctionnalité activée, GDB est prêt à procéder au débogage des threads.

GDB utilise le concept de current thread. Par défaut, les commandes ne s'appliquent qu'au thread en cours.

info threads
Affiche une liste de fils de discussion avec leurs numéros id et gid, indiquant le fil de discussion en cours.
thread id
Définit le fil d'exécution avec l'adresse id spécifiée comme le fil d'exécution actuel.
thread apply ids command
Appliquer la commande command à tous les threads listés par ids. L'option ids est une liste d'identifiants de threads séparés par des espaces. La valeur spéciale all applique la commande à tous les threads.
break location thread id if condition
Définir un point d'arrêt à un certain location avec un certain condition uniquement pour le numéro de thread id.
watch expression thread id
Fixer un point de surveillance défini par expression uniquement pour le numéro de thread id.
command&
Exécutez la commande command et revenez immédiatement à l'invite gdb (gdb), en poursuivant l'exécution du code en arrière-plan.
interrupt
Arrêter l'exécution en arrière-plan.

Ressources supplémentaires

Red Hat logoGithubRedditYoutubeTwitter

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Nous aidons les utilisateurs de Red Hat à innover et à atteindre leurs objectifs grâce à nos produits et services avec un contenu auquel ils peuvent faire confiance.

Rendre l’open source plus inclusif

Red Hat s'engage à remplacer le langage problématique dans notre code, notre documentation et nos propriétés Web. Pour plus de détails, consultez leBlog Red Hat.

À propos de Red Hat

Nous proposons des solutions renforcées qui facilitent le travail des entreprises sur plusieurs plates-formes et environnements, du centre de données central à la périphérie du réseau.

© 2024 Red Hat, Inc.