Débugger un programme ou une application :


Pour permettre de trouver le problème rencontré il faut (dans l’idéal) créer une trace détaillée : source https://en.opensuse.org/openSUSE:Bugreport_application_crashed

Installer les paquets -debuginfo : exemple : https://en.opensuse.org/Package_repositories#Debug
Debug
Debuginfo packages. Advanced users only.
Version: Tumbleweed http://download.opensuse.org/debug/tumbleweed/repo/oss/
Version: Leap 15.1 http://download.opensuse.org/debug/distribution/leap/15.1/repo/oss/ and updates http://download.opensuse.org/debug/update/leap/15.1/oss/
Version: Leap 15.0 http://download.opensuse.org/debug/distribution/leap/15.0/repo/oss/ and updates http://download.opensuse.org/debug/update/leap/15.0/oss/
Version: Leap 42.3 http://download.opensuse.org/debug/distribution/leap/42.3/repo/oss/ and updates http://download.opensuse.org/debug/update/leap/42.3/oss/


Utiliser GDB :

Le debugger Gnu s’appelle GDB, il sert à trouver des erreurs souvent liées à la corruption de la mémoire.
On peut l’utiliser pour créer une trace du problème rencontré par le programme utilisé (/usr/bin/programme).
Pour créer une trace d’un programme qui provoque des erreurs de segmentation quand il se lance il faut utiliser la commande suivante :

  $ gdb /usr/bin/programme
  GNU gdb 6.5
  ...
  (gdb)

GDB est lancé. Si des paquets -debuginfo manquent gdb montrera quelque chose de similaire :

   Missing separate debuginfo for /lib64/libm.so.6
   Try : zypper install -C "debuginfo(build-id)=35d35d9ce781be3a140a34242d998498615b021f"
   Missing separate debuginfo for /lib64/libpthread.so.0
   Try: zypper install -C "debuginfo(build-id)=522229c2dde70aaa8e4295ecb7b6643c810f758f"
   Missing separate debuginfo for /lib64/libc.so.6
   Try: zypper install -C "debuginfo(build-id)=c3e668c7a2e7ae513e801d34a968a43510b29b52"

Copier les commandes zypper dans un terminal pour installer les paquets manquants.
Quitter Gdb et le relancer.
Depuis gdb taper run et attendre que le programme plante (crash).

  (gdb) run
  Starting program: /usr/bin/brokenprogram

  Program received signal SIGSEGV, Segmentation fault.
  0x08048394 in brokenfunc () at brokenprogram.c:4
  4	    *i = 2;
  (gdb)

Autre option : si le programme est lancé à la connection, est démarré par un script init ou autre chose similaire on peut récupérer le processus et continuer son exécution pour attendre que se produise l’erreur :

  $ pidof brokenprogram
  12345
  $ gdb /usr/bin/brokenprogram 12345
  (gdb) continue
  Continuing.
  Program received signal SIGSEGV, Segmentation fault.
  0x08048394 in brokenfunc () at broken.c:4
  4	    *i = 2;
  (gdb)

Ci-dessus on est de retour au prompt de GDB :
- Autoriser l’écriture de la sauvegarde : set logging on.
- Puis créer la trace de l’erreur avec : thread apply all backtrace full.

  (gdb) set logging on
  Copying output to gdb.txt.
  (gdb) thread apply all backtrace full
  [New Thread 0x7ffff6d0b700 (LWP 4520)]

   Thread 2 (Thread 0x7ffff750c700 (LWP 4519)):
   #0  0x00007ffff7542849 in __GI_raise (sig=sig@entry=6) at ../nptl/sysdeps/unix/sysv/linux/raise.c:56
           resultvar = 0
           pid = 4515
           selftid = 4519
   #1  0x00007ffff7543cd8 in __GI_abort () at abort.c:89
           save_stage = 2
           act = {__sigaction_handler = {sa_handler = 0x6466203030303030, sa_sigaction = 0x6466203030303030}, sa_mask = {__val = {3906931166148702266, 2314885530818459703, 2314885530818453536,
                 3395749441387372576, 7596498572764408172, 3330465998920576354, 7378697628689264499, 3256155514972955191, 7233967814408037943, 3255307721929404514, 3472891250476064880, 3616454703663034416,
                 2321666313920262688, 2314885530818453536, 2314885530818453536, 8096}}, sa_flags = 89, sa_restorer = 0x7ffff750bed0}
           sigs = {__val = {32, 0 <repeats 15 times>}}
   #2  0x00007ffff7581114 in __libc_message (do_abort=do_abort@entry=2, fmt=fmt@entry=0x7ffff76770e0 "*** Error in `%s': %s: 0x%s ***\n") at ../sysdeps/posix/libc_fatal.c:175
           ap = Template:Gp offset = 40, fp offset = 0, overflow arg area = 0x7ffff750bee0, reg save area = 0x7ffff750be70
           fd = 3
           on_2 = <optimized out>
           list = <optimized out>
           nlist = <optimized out>
           cp = <optimized out>
           written = <optimized out>
   #3  0x00007ffff758696e in malloc_printerr (action=3, str=0x7ffff767317b "free(): invalid pointer", ptr=<optimized out>) at malloc.c:4916
           buf = '0' <repeats 11 times>, "12345"
           cp = <optimized out>
   #4  0x0000000000400a88 in work (t=0x0) at brokenprogram.c:18
           i = 10
           tid = 0
           result = -4.943676956758269
   #5  0x00007ffff78c40db in start_thread (arg=0x7ffff750c700) at pthread_create.c:309
           __res = <optimized out>
           pd = 0x7ffff750c700
           now = <optimized out>
           unwind_buf = {cancel_jmp_buf = {{jmp_buf = {140737342654208, 3582659488515194238, 1, 140737354125312, 0, 140737342654208, -3582675678410998402, -3582676406767878786}, mask_was_saved = 0}}, priv = {
               pad = {0x0, 0x0, 0x0, 0x0}, data = {prev = 0x0, cleanup = 0x0, canceltype = 0}}}
           not_first_call = <optimized out>
           pagesize_m1 = <optimized out>
           pd = 0x7ffff750c700
           now = <optimized out>
           unwind_buf = {cancel_jmp_buf = {{jmp_buf = {140737342654208, 3582659488515194238, 1, 140737354125312, 0, 140737342654208, -3582675678410998402, -3582676406767878786}, mask_was_saved = 0}}, priv = {
               pad = {0x0, 0x0, 0x0, 0x0}, data = {prev = 0x0, cleanup = 0x0, canceltype = 0}}}
           not_first_call = <optimized out>
           pagesize_m1 = <optimized out>
           sp = <optimized out>
           freesize = <optimized out>
           __PRETTY_FUNCTION__ = "start_thread"
   #6  0x00007ffff75f47cd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111
   No locals.

   Thread 1 (Thread 0x7ffff7fe1700 (LWP 4515)):
   [...]
   (gdb)


Quitter Gdb en tapant quit
La sauvegarde sera créée dans le fichier gdb.txt du répertoire en cours d’utilisation.

Si le programme se plante uniquement avec un paramètre spécifique ( par exemple –crash, on doit ajouter ce paramètre à la commande run :

  (gdb) run --crash
  Starting program: /usr/bin/brokenprogram --crash

Dmesg :
Dmesg affiche ou contrôle le buffer du noyau. Il faut l’utiliser si on des soucis avec le noyau lui même, les applications liées au noyau (modules, démarrage à chaud)

Strace :
Les programmes utilisent souvent des fichiers pour récupérer des information de configuration, accéder au matériel, ou écrire des sauvegardes.
Parfois un programme essaie d’atteindre ces fichiers de façon erronée.
Strace est un outil de diagnostic et de débogage qui peut aider.
Strace retrace les appels systèmes, d’où son nom, ce qui inclus les appels utilisant la mémoire et les fichiers.
Dans un cas simple Strace lance la commande spécifiée jusqu’à qu’elle se termine.
 Il intercepte et enregistre les appels systèmes qui sont effectués par un processus et les signaux reçus par ce processus. Le nom des appels système, les arguments et la valeur de retour sont envoyés sur l’erreur standard, ou dans le fichier spécifié par l’option -o.

Exemple pour la commande  cat /dev/null :
  strace -f -ttt -o strace.log cat /dev/null
Cela créée un fichier strace.log dans le répertoire en cours d’utilisation.
Exemples :
  open("/dev/null", O_RDONLY) = 3
Les erreurs (valeur de retour typique -1) fournissent le symbole errno, et l’erreur correspondante :
  open("/foo/bar", O_RDONLY) = -1 ENOENT (No such file or directory)

Donc Strace est un bon moyen de débugger des applications qui se plantent au démarrage, ou se ferment lorsque l’on ouvre ou sauvegarde des fichiers.