Débogage en direct du noyau Linux, comment cela se passe-t-il et quels outils sont utilisés ?

Une autre option consiste à utiliser le contrôleur ICE/JTAG et GDB. Cette solution 'hardware' est surtout utilisée avec les systèmes embarqués,

mais par exemple Qemu propose des fonctionnalités similaires :

démarrer qemu avec un stub gdb 'remote' qui écoute sur 'localhost:1234' :qemu -s ... ,
puis avec GDB vous ouvrez le fichier noyau vmlinux compilé avec des informations de débogage (vous pouvez consulter ce fil de discussion de la liste de diffusion où ils discutent de la non-optimisation du noyau).
connecter GDB et Qemu :target remote localhost:1234

voir votre live noyau :

(gdb) where
#0  cpu_v7_do_idle () at arch/arm/mm/proc-v7.S:77
#1  0xc0029728 in arch_idle () atarm/mach-realview/include/mach/system.h:36
#2  default_idle () at arm/kernel/process.c:166
#3  0xc00298a8 in cpu_idle () at arch/arm/kernel/process.c:199
#4  0xc00089c0 in start_kernel () at init/main.c:713

malheureusement, le débogage de l'espace utilisateur n'est pas possible jusqu'à présent avec GDB (pas d'informations sur la liste des tâches, pas de reprogrammation MMU pour voir différents contextes de processus, ...), mais si vous restez dans l'espace noyau, c'est assez pratique.

info threads vous donnera la liste et les états des différents CPU

MODIF :

Vous pouvez obtenir plus de détails sur la procédure dans ce PDF :

Débogage des systèmes Linux à l'aide de GDB et QEMU.

Lors du débogage du noyau Linux, nous pouvons utiliser plusieurs outils, par exemple, les débogueurs (KDB, KGDB), le vidage en cas de plantage (LKCD), la boîte à outils de traçage (LTT, LTTV, LTTng), les instruments de noyau personnalisés (dprobes, kprobes). Dans la section suivante, j'ai essayé de résumer la plupart d'entre eux, j'espère que cela vous aidera.

LKCD (Linux Kernel Crash Dump) permet au système Linux d'écrire le contenu de sa mémoire lorsqu'un crash se produit. Ces journaux peuvent être analysés plus en détail pour déterminer la cause première du crash. Ressources concernant LKCD

http://www-01.ibm.com/support/knowledgecenter/linuxonibm/liaax/lkcd.pdf
https://www.novell.com/coolsolutions/feature/15284.html
https://www.novell.com/support/kb/doc.php?id=3044267

Oups lorsque le noyau détecte un problème, il affiche un message Oups. Un tel message est généré par des instructions printk dans le gestionnaire d'erreurs (arch/*/kernel/traps.c). Un tampon en anneau dédié dans le noyau utilisé par les instructions printk. Oops contient des informations telles que le CPU sur lequel le Oops s'est produit, le contenu des registres du CPU, le nombre de Oops, la description, la trace de retour de pile et autres. Ressources concernant le noyau Oops

https://www.kernel.org/doc/Documentation/oops-tracing.txt
http://madwifi-project.org/wiki/DevDocs/KernelOops
https://wiki.ubuntu.com/DebuggingKernelOops

Sondes dynamiques est l'un des outils de débogage populaires pour Linux développé par IBM. Cet outil permet de placer une "sonde" à presque n'importe quel endroit du système, à la fois dans l'espace utilisateur et dans l'espace noyau. La sonde consiste en un code (écrit dans un langage spécialisé orienté pile) qui est exécuté lorsque le contrôle atteint le point donné. Ressources concernant Dynamic Probe listées ci-dessous

http://www-01.ibm.com/support/knowledgecenter/linuxonibm/liaax/dprobesltt.pdf
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.107.6212&rep=rep1&type=pdf

Boîte à outils Linux Trace est un correctif du noyau et un ensemble d'utilitaires associés qui permettent le traçage des événements dans le noyau. La trace inclut des informations temporelles et peut créer une image raisonnablement complète de ce qui s'est passé sur une période de temps donnée. Ressources de LTT, LTT Viewer et LTT Next Generation

http://elinux.org/Linux_Trace_Toolkit
http://www.linuxjournal.com/article/3829
http://multivax.blogspot.com/2010/11/introduction-to-linux-tracing-toolkit.html

MEMWATCH est un outil de détection d'erreur de mémoire open source. Cela fonctionne en définissant MEMWATCH dans l'instruction gcc et en ajoutant un fichier d'en-tête à notre code. Grâce à cela, nous pouvons suivre les fuites de mémoire et les corruptions de mémoire. Ressources concernant MEMWATCH

http://www.linuxjournal.com/article/6059

ftrace est un bon framework de traçage pour le noyau Linux. ftrace trace les opérations internes du noyau. Cet outil inclus dans le noyau Linux en 2.6.27. Avec ses différents plug-ins de traceur, ftrace peut être ciblé sur différents points de trace statiques, tels que la planification d'événements, les interruptions, les E/S mappées en mémoire, les transitions d'état d'alimentation du processeur et les opérations liées aux systèmes de fichiers et à la virtualisation. En outre, le suivi dynamique des appels de fonction du noyau est disponible, éventuellement restreint à un sous-ensemble de fonctions à l'aide de globs, et avec la possibilité de générer des graphiques d'appel et de fournir l'utilisation de la pile. Vous pouvez trouver un bon tutoriel de ftrace sur https://events.linuxfoundation.org/slides/2010/linuxcon_japan/linuxcon_jp2010_rostedt.pdf

ltrace est un utilitaire de débogage sous Linux, utilisé pour afficher les appels qu'une application de l'espace utilisateur fait aux bibliothèques partagées. Cet outil peut être utilisé pour tracer tout appel de fonction de bibliothèque dynamique. Il intercepte et enregistre les appels de bibliothèque dynamiques qui sont appelés par le processus exécuté et les signaux qui sont reçus par ce processus. Il peut également intercepter et imprimer les appels système exécutés par le programme.

http://www.ellexus.com/getting-started-with-ltrace-how-does-it-do-that/?doing_wp_cron=1425295977.1327838897705078125000
http://developerblog.redhat.com/2014/07/10/ltrace-for-rhel-6-and-7/

KDB est le débogueur intégré au noyau Linux. KDB suit une interface simpliste de style shell. Nous pouvons l'utiliser pour inspecter la mémoire, les registres, les listes de processus, dmesg et même définir des points d'arrêt pour s'arrêter à un certain emplacement. Grâce à KDB, nous pouvons définir des points d'arrêt et exécuter un contrôle d'exécution de base du noyau (Bien que KDB ne soit pas un débogueur au niveau de la source ). Plusieurs ressources pratiques concernant KDB

http://www.drdobbs.com/open-source/linux-kernel-debugging/184406318
http://elinux.org/KDB
http://dev.man-online.org/man1/kdb/
https://www.kernel.org/pub/linux/kernel/people/jwessel/kdb/usingKDB.html

KGDB est destiné à être utilisé comme débogueur au niveau source pour le noyau Linux. Il est utilisé avec gdb pour déboguer un noyau Linux. Deux machines sont nécessaires pour utiliser kgdb. L'une de ces machines est une machine de développement et l'autre est la machine cible. Le noyau à déboguer s'exécute sur la machine cible. On s'attend à ce que gdb puisse être utilisé pour "entrer" dans le noyau pour inspecter la mémoire, les variables et parcourir les informations de la pile d'appels de la même manière qu'un développeur d'applications utiliserait gdb pour déboguer une application. Il est possible de placer des points d'arrêt dans le code du noyau et d'effectuer des étapes d'exécution limitées. Plusieurs ressources pratiques concernant KGDB

http://landley.net/kdocs/Documentation/DocBook/xhtml-nochunks/kgdb.html

Selon le wiki, kgdb a été fusionné dans le noyau en 2.6.26 c'est-à-dire au cours des dernières années. kgdb est un débogueur distant, vous l'activez donc dans votre noyau, puis vous y attachez gdb d'une manière ou d'une autre. Je dis en quelque sorte car il semble y avoir beaucoup d'options - voir connecter gdb. Étant donné que kgdb est maintenant dans l'arborescence des sources, je dirais qu'à l'avenir, c'est ce que vous voulez utiliser.

Il semble donc que Linus ait cédé. Cependant, je soulignerais son argument - vous devez savoir ce que vous faites et bien connaître le système. C'est la terre du noyau. Si quelque chose ne va pas, vous n'obtenez pas segfault , vous obtenez quoi que ce soit d'un problème obscur plus tard à l'ensemble du système qui tombe en panne. Voilà des dragons. Procédez avec prudence, vous êtes prévenu.