Noyau Linux: Bon tutoriel pour débutants [fermé]

Je suis intéressé par la modification des composants internes du noyau, l'application de correctifs, la gestion des pilotes de périphériques et des modules, pour mon plaisir personnel.

Existe-t-il une ressource complète pour le piratage du noyau, destinée aux programmeurs expérimentés?

**TODO** +editPic: Linux Kernel Developer -> (Ring Layer 0)
         +addSection: Kernel Virtualization Engine

KERN_WARN_CODING_STYLE: Do not Loop unless you absolutely have to.

Livres recommandés pour les non- initialisésvoid *i

"Les hommes ne comprennent pas les livres tant qu'ils n'ont pas une certaine durée de vie, ou du moins aucun homme ne comprend un livre profond, jusqu'à ce qu'il ait vu et vécu au moins une partie de son contenu". –Ezra Pound

Un voyage de mille codes-milles doit commencer par un seul pas. Si vous ne savez pas lequel des livres suivants commencer, ne vous inquiétez pas, choisissez l'un de vos choix. Tous ceux qui errent ne sont pas perdus. Au fur et à mesure que toutes les routes se connectent à l’autoroute , vous explorerez de nouvelles choses dans votre parcours du noyau au fur et à mesure que les pages avancent sans rencontrer d’impasse, et vous vous connecterez au final à code-set. Lisez avec l'esprit alerte et souvenez-vous: le code n'est pas de la littérature .

Ce qui reste n'est pas une chose ou une émotion, ni une image, ni une image mentale, ni un souvenir, ni même une idée. C'est une fonction. Un processus de quelque sorte. Un aspect de la vie qui pourrait être décrit en fonction de quelque chose de "plus grand". Et donc, il semble que ce n’est pas vraiment "séparé" de cet autre chose. La fonction d'un couteau - couper quelque chose - n'est en réalité pas séparée du couteau lui-même. La fonction peut ou peut ne pas être utilisée pour le moment, mais elle n'est potentiellement JAMAIS séparée.

Algorithme de Solovay Strassen Derandomized pour le test de primalité :

Lire pour ne pas contredire et confondre; ni croire et prendre pour acquis; ni pour trouver la parole et le discours; mais peser et considérer. Certains livres doivent être goûtés, d'autres doivent être avalés et certains doivent être croqués et digérés: certains livres ne doivent être lus que partiellement, d'autres ne doivent pas être lus avec curiosité et certains doivent être lus intégralement. et avec diligence et attention.

static void tasklet_hi_action(struct softirq_action *a)
{
        struct tasklet_struct *list;

        local_irq_disable();
        list = __this_cpu_read(tasklet_hi_vec.head);
        __this_cpu_write(tasklet_hi_vec.head, NULL);
        __this_cpu_write(tasklet_hi_vec.tail, this_cpu_ptr(&tasklet_hi_vec.head));
        local_irq_enable();

        while (list) {
                struct tasklet_struct *t = list;

                list = list->next;

                if (tasklet_trylock(t)) {
                        if (!atomic_read(&t->count)) {
                                if (!test_and_clear_bit(TASKLET_STATE_SCHED,
                                                        &t->state))
                                        BUG();
                                t->func(t->data);
                                tasklet_unlock(t);
                                continue;
                        }
                        tasklet_unlock(t);
                }

                local_irq_disable();
                t->next = NULL;
                *__this_cpu_read(tasklet_hi_vec.tail) = t;
                __this_cpu_write(tasklet_hi_vec.tail, &(t->next));
                __raise_softirq_irqoff(HI_SOFTIRQ);
                local_irq_enable();
        }
}

Core Linux (5 -> 1 -> 3 -> 2 -> 7 -> 4 -> 6)

«La nature n'a ni noyau ni coque; elle est tout à la fois »- Johann Wolfgang von Goethe

Reader doit bien connaître les concepts du système d’exploitation ; une compréhension juste des processus de longue durée et de leurs différences avec les processus à exécution rapide; tolérance aux pannes tout en respectant les contraintes temps réel et temporel. Lors de la lecture, il est important de comprendre n/ackles choix de conception effectués par la source du noyau Linux dans les sous-systèmes centraux.

Les fils [et] les signaux [constituent] une traînée de misère, de désespoir, d’horreur et de folie qui dépend de la plate-forme (~ Anthony Baxte). Cela étant dit, vous devriez être un expert en auto-évaluation avant de plonger dans le noyau. Vous devez également avoir une bonne expérience des listes chaînées, des piles, des files d’attente, des arbres Noirs Rouges, des fonctions de hachage, et al.

volatile int i;
int main(void)
{
    int c;
    for (i=0; i<3; i++) {
        c = i&&&i;
        printf("%d\n", c);    /* find c */
    }
    return 0;
}

La beauté et l’art de la source du noyau Linux résident dans l’obscurcissement délibéré du code utilisé. Cela est souvent nécessaire pour transmettre la signification informatique impliquant deux opérations ou plus de manière propre et élégante. Cela est particulièrement vrai lors de l'écriture de code pour une architecture multi-core.

Conférences vidéo sur les systèmes en temps réel , Planification des tâches , la mémoire de compression , barrières de mémoire , SMP

#ifdef __compiler_offsetof
#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
#else
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif

1. Développement du noyau Linux - Robert Love
2. Comprendre le noyau Linux - Daniel P. Bovet, Marco Cesati
3. L'art de Linux KerneL Design - Yang Lixiang
4. Architecture de noyau Linux professionnelle - Wolfgang Mauerer
5. Conception du système d'exploitation UNIX - Maurice J. Bach
6. Comprendre le gestionnaire de mémoire virtuelle Linux - Mel Gorman
7. Fonctionnement interne du noyau Linux - Tigran Aivazian
8. Introduction à Linux intégré - Christopher Hallinan

Pilotes de périphérique Linux (1 -> 2 -> 4 -> 3 -> 8 -> ...)

"La musique ne vous emporte pas. Vous devez l'emporter strictement par votre capacité à vous concentrer vraiment sur ce petit noyau d'émotion ou d'histoire". - Debbie Harry

Votre tâche consiste essentiellement à établir une interface de communication à haut débit entre le périphérique matériel et le noyau du logiciel. Vous devez lire la fiche technique / le manuel de référence du matériel pour comprendre le comportement du périphérique, de ses états de contrôle et de données et des canaux physiques fournis. La connaissance d'Assembly pour votre architecture particulière et une connaissance approfondie de la description matérielle VLSI Des langages comme VHDL ou Verilog vous aideront à long terme.

• Manuel du développeur de logiciels architecturaux Intel® 64 et IA-32
• Manuel de référence de l'architecture ARM
• Guide du développeur de système ARM

Q : Mais pourquoi dois-je lire les spécifications du matériel?

R : Parce qu'il y a "un gouffre de carbone et de silicium, le logiciel ne peut pas combler" - Rahul Sonnad

Cependant, ce qui précède ne pose pas de problème pour les algorithmes de calcul ( code de pilote - traitement dans la moitié inférieure ), car il peut être totalement simulé sur une machine de turing universelle . Si le résultat calculé est vrai dans le domaine mathématique , il est certain qu'il l'est également dans le domaine physique .

Conférences vidéo sur les pilotes de périphériques Linux (Lec. 17 et 18), anatomie d'un pilote KMS intégré , mise à jour du contrôle des broches et des GPIO , cadre d'horloge commune , écriture d'un pilote réel pour Linux - Greg KH

static irqreturn_t phy_interrupt(int irq, void *phy_dat)
{
         struct phy_device *phydev = phy_dat;

         if (PHY_HALTED == phydev->state)
                 return IRQ_NONE;                /* It can't be ours.  */

         /* The MDIO bus is not allowed to be written in interrupt
          * context, so we need to disable the irq here.  A work
          * queue will write the PHY to disable and clear the
          * interrupt, and then reenable the irq line.
          */
         disable_irq_nosync(irq);
         atomic_inc(&phydev->irq_disable);

         queue_work(system_power_efficient_wq, &phydev->phy_queue);

         return IRQ_HANDLED;
}

1. Pilotes de périphérique Linux - Jonathan Corbet, Alessandro Rubini et Greg Kroah-Hartman
2. Pilotes de périphérique Linux essentiels - Sreekrishnan Venkateswaran
3. Ecriture de pilotes de périphérique Linux - Jerry Cooperstein
4. Guide de programmation du module de noyau Linux - Peter Jay Salzman, Michael Burian, Ori Pomerantz
5. Guide du programmeur PCMCIA Linux - David Hinds
6. Guide de programmation Linux SCSI - Heiko Eibfeldt
7. Guide de programmation en série pour les systèmes d'exploitation POSIX - Michael R. Sweet
8. Pilotes graphiques Linux: une introduction - Stéphane Marchesin
9. Guide de programmation pour pilotes de périphérique USB Linux - Detlef Fliegl
10. Le modèle de périphérique du noyau Linux - Patrick Mochel

Mise en réseau du noyau (1 -> 2 -> 3 -> ...)

"Appelez ça un clan, appelez ça un réseau, appelez ça une tribu, appelez ça une famille: peu importe comment vous l'appelez, qui que vous soyez, vous en avez besoin." - Jane Howard

Comprendre le parcours d'un paquet dans le noyau est une clé pour comprendre les réseaux du noyau. Comprendre cela est indispensable si nous voulons comprendre les éléments internes de Netfilter ou IPSec, et plus encore. Les deux structures les plus importantes de la couche réseau du noyau Linux sont: struct sk_buffetstruct net_device

static inline int sk_hashed(const struct sock *sk)
{
        return !sk_unhashed(sk);
} 

1. Comprendre le fonctionnement interne du réseau Linux - Christian Benvenuti
2. Réseau noyau Linux: implémentation et théorie - Rami Rosen
3. Programmation réseau UNIX - W. Richard Stevens
4. Le guide ultime de la programmation réseau Linux - Keir Davis, John W. Turner et Nathan Yocom
5. La pile Linux TCP / IP: Mise en réseau pour systèmes embarqués - Thomas F. Herbert
6. Programmation de sockets Linux par exemple - Warren W. Gay
7. HOWTO Linux sur le routage avancé et le contrôle de trafic - Bert Hubert

Débogage du noyau (1 -> 4 -> 9 -> ...)

À moins de communiquer avec lui, on ne dit pas exactement ce que l'on veut dire, il en résultera forcément des problèmes. ~ Alan Turing, à propos des ordinateurs

Brian W. Kernighan, dans l'article d'Unix pour les débutants (1979), a déclaré: "L'outil de débogage le plus efficace reste un outil de réflexion avancé, associé à des instructions d'impression judicieusement placées". Savoir quoi collecter vous aidera à obtenir rapidement les bonnes données pour un diagnostic rapide. Edsger Dijkstra, grand informaticien, a déclaré un jour que les tests pouvaient démontrer la présence de bugs, mais pas leur absence. De bonnes pratiques d’enquête doivent concilier le besoin de résoudre rapidement les problèmes, le besoin de développer vos compétences et l’utilisation efficace d’experts en la matière.

Il y a des moments où vous touchez le fond, rien ne semble fonctionner et vous manquez de toutes vos options. C'est alors que le vrai débogage commence. Un bug peut fournir la pause dont vous avez besoin pour vous dégager d'une fixation sur la solution inefficace.

Conférences vidéo sur le débogage et le profilage du noyau , l' analyse du vidage de la mémoire , le débogage multicore avec GDB , le contrôle des conditions de course multicœurs , le débogage de l'électronique

/* Buggy Code -- Stack frame problem
 * If you require information, do not free memory containing the information
 */
char *initialize() {
  char string[80];
  char* ptr = string;
  return ptr;
}

int main() {
  char *myval = initialize();
  do_something_with(myval);
}
/*  “When debugging, novices insert corrective code; experts remove defective code.”
 *     – Richard Pattis
#if DEBUG
 printk("The above can be considered as Development and Review in Industrial Practises");
#endif
 */

1. Débogage Linux et réglage des performances - Steve Best
2. Techniques de débogage d'applications Linux - Aurelian Melinte
3. Débogage avec GDB: Le débogueur de niveau source GNU - Roland H. Pesch
4. Débogage de Linux intégré - Christopher Hallinan
5. L'art du débogage avec GDB, DDD et Eclipse - Norman S. Matloff
6. Pourquoi les programmes échouent-ils? Guide de débogage systématique - Andreas Zeller
7. Exorcisme logiciel: Manuel pour le débogage et l'optimisation de code hérité - Bill Blunden
8. Débogage: Trouver la plupart des problèmes matériels et logiciels insaisissables - David J. Agans
9. Débogage par la pensée: une approche multidisciplinaire - Robert Charles Metzger
10. Trouvez le bogue: un livre de programmes incorrects - Adam Barr

Systèmes de fichiers (1 -> 2 -> 6 -> ...)

"Je voulais avoir de la mémoire virtuelle, du moins car elle est couplée à des systèmes de fichiers". - Ken Thompson

Sur un système UNIX, tout est un fichier. si quelque chose n'est pas un fichier, c'est un processus, à l'exception des canaux nommés et des sockets. Dans un système de fichiers, un fichier est représenté par un inode, un type de numéro de série contenant des informations sur les données qui composent le fichier. Le système de fichiers virtuel Linux VFSmet en cache les informations en mémoire de chaque système de fichiers lors de son montage et de son utilisation. Il faut prendre soin de mettre à jour correctement le système de fichiers car les données contenues dans ces caches sont modifiées lors de la création, de la création et de la suppression de fichiers et de répertoires. Le plus important de ces caches est le cache de tampons, intégré à la manière dont les systèmes de fichiers individuels accèdent à leurs périphériques de stockage de blocs sous-jacents.

Conférences vidéo sur les systèmes de stockage , système de fichiers Flash Friendly

long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
        struct open_flags op;
        int fd = build_open_flags(flags, mode, &op);
        struct filename *tmp;

        if (fd)
                return fd;

        tmp = getname(filename);
        if (IS_ERR(tmp))
                return PTR_ERR(tmp);

        fd = get_unused_fd_flags(flags);
        if (fd >= 0) {
                struct file *f = do_filp_open(dfd, tmp, &op);
                if (IS_ERR(f)) {
                        put_unused_fd(fd);
                        fd = PTR_ERR(f);
                } else {
                        fsnotify_open(f);
                        fd_install(fd, f);
                }
        }
        putname(tmp);
        return fd;
}

SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;

        return do_sys_open(AT_FDCWD, filename, flags, mode);
}

1. Systèmes de fichiers Linux - Barre Moshe
2. Systèmes de fichiers Linux - William Von Hagen
3. Systèmes de fichiers UNIX: évolution, conception et implémentation - Steve D. Pate
4. Conception pratique du système de fichiers - Dominic Giampaolo
5. Analyse judiciaire du système de fichiers - Brian Carrier
6. Hiérarchie des systèmes de fichiers Linux - Binh Nguyen
7. BTRFS: le système de fichiers Linux B-tree - Ohad Rodeh
8. StegFS: un système de fichiers stéganographique pour Linux - Andrew D. McDonald, Markus G. Kuhn

Sécurité (1 -> 2 -> 8 -> 4 -> 3 -> ...)

"UNIX n'a ​​pas été conçu pour empêcher ses utilisateurs de faire des choses stupides, cela les empêcherait également de faire des choses intelligentes". - Doug Gwyn

Aucune technique ne fonctionne si elle n'est pas utilisée. L'éthique change avec la technologie.

" F × S = k " le produit de la liberté et de la sécurité est une constante. - Lois de Niven

La cryptographie constitue la base de la confiance en ligne. Le piratage consiste à exploiter les contrôles de sécurité dans un élément technique, physique ou humain. La protection du noyau contre d’autres programmes en cours d’exécution est un premier pas vers un système sécurisé et stable, mais cela n’est évidemment pas suffisant: un certain degré de protection doit également exister entre différentes applications utilisateurs. Les exploits peuvent cibler des services locaux ou distants.

"Vous ne pouvez pas pirater votre destin, la force brute ... vous avez besoin d'une porte arrière, d'un canal latéral dans la vie." - Clyde Dsouza

Les ordinateurs ne résolvent pas les problèmes, ils exécutent des solutions. Derrière chaque code algorithmique non déterministe , il y a un esprit déterminé . - / var / log / dmesg

Conférences vidéo sur la cryptographie et la sécurité des réseaux , espaces de noms pour la sécurité , protection contre les attaques à distance , Linux embarqué sécurisé

env x='() { :;}; echo vulnerable' bash -c "echo this is a test for Shellsock"

1. Piratage: l'art de l'exploitation - Jon Erickson
2. L'arsenal des rootkits: évasion et évasion dans les coins sombres du système - Bill Blunden
3. Piratage exposé: secrets de sécurité réseau - Stuart McClure, Joel Scambray, George Kurtz
4. Guide sur l'exploitation du noyau: attaquer le noyau - Enrico Perla, Massimiliano Oldani
5. L'art de la médecine légale - Michael Hale Ligh, Andrew Case, Jamie Levy, AAron Walters
6. Ingénierie inverse pratique - Bruce Dang, Alexandre Gazet, Elias Bachaalany
7. Analyse pratique des programmes malveillants - Michael Sikorski, Andrew Honig
8. Maximum Linux Security: Guide de l'intrus pour protéger votre serveur Linux - Anonyme
9. Sécurité Linux - Craig Hunt
10. Sécurité dans le monde réel - Bob Toxen

Source du noyau (0.11 -> 2.4 -> 2.6 -> 3.18)

"Comme le vin, la maîtrise de la programmation par noyau mûrit avec le temps. Mais contrairement au vin, elle devient plus douce dans le processus". - Lawrence Mucheka

Vous ne pensez peut-être pas que les programmeurs sont des artistes, mais la programmation est une profession extrêmement créative. C'est une créativité basée sur la logique. La formation en informatique ne peut faire de tout un programmeur expert, pas plus qu'étudier les pinceaux et les pigments peut faire de quelqu'un un peintre expert. Comme vous le savez déjà, il y a une différence entre connaître le chemin et le parcourir; il est de la plus haute importance de se retrousser les manches et de se salir les mains avec le code source du noyau. Enfin, avec votre connaissance du noyau ainsi acquise , où que vous alliez, vous brillerez .

Les codeurs immatures imitent; les codeurs matures volent; les mauvais codeurs dégradent ce qu'ils prennent et de bons codeurs en font quelque chose de mieux, ou du moins de différent. Le bon codeur soude son vol en un sentiment unique, totalement différent de celui dont il a été déchiré.

Conférences vidéo sur les recettes du noyau

linux-0.11
├── boot
│   ├── bootsect.s      head.s      setup.s
├── fs
│   ├── bitmap.c    block_dev.c buffer.c        char_dev.c  exec.c
│   ├── fcntl.c     file_dev.c  file_table.c    inode.c     ioctl.c
│   ├── namei.c     open.c      pipe.c          read_write.c
│   ├── stat.c      super.c     truncate.c
├── include
│   ├── a.out.h     const.h     ctype.h     errno.h     fcntl.h
│   ├── signal.h    stdarg.h    stddef.h    string.h    termios.h
│   ├── time.h      unistd.h    utime.h
│   ├── asm
│   │   ├── io.h    memory.h    segment.h   system.h
│   ├── linux
│   │   ├── config.h    fdreg.h fs.h    hdreg.h     head.h
│   │   ├── kernel.h    mm.h    sched.h sys.h       tty.h
│   ├── sys
│   │   ├── stat.h      times.h types.h utsname.h   wait.h
├── init
│   └── main.c
├── kernel
│   ├── asm.s       exit.c      fork.c      mktime.c    panic.c
│   ├── printk.c    sched.c     signal.c    sys.c       system_calls.s
│   ├── traps.c     vsprintf.c
│   ├── blk_drv
│   │   ├── blk.h   floppy.c    hd.c    ll_rw_blk.c     ramdisk.c
│   ├── chr_drv
│   │   ├── console.c   keyboard.S  rs_io.s
│   │   ├── serial.c    tty_io.c    tty_ioctl.c
│   ├── math
│   │   ├── math_emulate.c
├── lib
│   ├── close.c  ctype.c  dup.c     errno.c  execve.c  _exit.c
│   ├── malloc.c open.c   setsid.c  string.c wait.c    write.c
├── Makefile
├── mm
│   ├── memory.c page.s
└── tools
    └── build.c

1. Le débutant commence avec Linux 0.11 source (moins de 20 000 lignes de code source). Après 20 ans de développement, comparé à Linux 0.11, Linux est devenu très énorme, complexe et difficile à apprendre. Mais le concept et la structure principale n'ont pas de changements fondamentaux. L'apprentissage de Linux 0.11 a toujours une signification pratique importante.
2. Lecture obligatoire pour les hackers du noyau => Linux_source_dir/Documentation/*
3. Vous devez être abonné et actif sur au moins une liste de diffusion du noyau. Commencez avec les débutants du noyau .
4. Vous n'avez pas besoin de lire le code source complet. Une fois que vous êtes familiarisé avec les API du noyau et son utilisation, commencez directement par le code source du sous-système qui vous intéresse. Vous pouvez également commencer par écrire vos propres modules plug-n-play pour expérimenter le noyau.
5. Les auteurs de pilotes de périphériques auraient intérêt à disposer de leur propre matériel dédié. Commencez par Raspberry Pi .

Les débutants dans le noyau Linux sont une excellente ressource.

Je vous suggère de lire " Le noyau Linux en quelques mots " de Greg Kroah-Hartman et " Comprendre le noyau Linux " de Robert Love. Doit lire :)

Les pilotes de périphériques Linux sont une autre bonne ressource. Cela vous donnerait un autre moyen d'entrer dans le fonctionnement interne. De la préface:

Il s’agit, à première vue, d’un livre sur l’écriture de pilotes de périphérique pour le système Linux. C'est un objectif louable, bien sûr; le flux de nouveaux produits matériels ne devrait pas ralentir de si tôt et quelqu'un devra faire en sorte que tous ces nouveaux gadgets fonctionnent avec Linux. Mais ce livre explique également comment fonctionne le noyau Linux et comment adapter son fonctionnement à vos besoins et à vos intérêts. Linux est un système ouvert. Nous espérons qu'avec ce livre, il sera plus ouvert et accessible à une plus grande communauté de développeurs.

Voir le projet de documentation Linux . En particulier le "Guide du module du noyau Linux".

Linux Kernel 2.4 Internals est une autre ressource en ligne à consulter. Il semble adopter une approche plutôt novatrice, à commencer par le démarrage. Voici la table des matières:

1. Démarrage
   • 1.1 Construire l'image du noyau Linux
   • 1.2 Démarrage: vue d'ensemble
   • 1.3 Amorçage: POST BIOS
   • 1.4 Amorçage: secteur de démarrage et configuration
   • 1.5 Utiliser LILO comme chargeur de démarrage
   • 1.6 Initialisation de haut niveau
   • 1.7 Démarrage SMP sur x86
   • 1.8 Libération des données d'initialisation et du code
   • 1.9 Traitement de la ligne de commande du noyau
2. Gestion des processus et des interruptions
   • 2.1 Structure des tâches et table de processus
   • 2.2 Création et fin de tâches et de threads du noyau
   • 2.3 Planificateur Linux
   • 2.4 Implémentation de la liste chaînée Linux
   • 2.5 files d'attente
   • 2.6 Timers du noyau
   • 2.7 moitiés inférieures
   • 2.8 files d'attente de tâches
   • 2.9 Tasklets
   • 2.10 Softirqs
   • 2.11 Comment les appels système sont mis en œuvre sur l'architecture i386?
   • 2.12 Opérations atomiques
   • 2.13 Spinlocks, Spinlocks en lecture-écriture et Spinlocks à gros lecteur
   • 2.14 Sémaphores et lire / écrire des sémaphores
   • 2.15 Support du noyau pour le chargement de modules
3. Système de fichiers virtuel (VFS)
   • 3.1 Caches d'inodes et interaction avec Dcache
   • 3.2 Enregistrement / désenregistrement de système de fichiers
   • 3.3 Gestion des descripteurs de fichiers
   • 3.4 Gestion de la structure de fichier
   • 3.5 Superblock et Mountpoint Management
   • 3.6 Exemple de système de fichiers virtuel: pipefs
   • 3.7 Exemple de système de fichiers disque: BFS
   • 3.8 Domaines d'exécution et formats binaires
4. Cache de page Linux
5. Mécanismes IPC
   • 5.1 Sémaphores
   • 5.2 Files d'attente de messages
   • 5.3 Mémoire partagée
   • 5.4 Primitives IPC Linux

Et, pour le rendre encore plus doux, il y a une nouvelle version de Linux Kernel Development Third Edition de Robert Love et Slashdot a fait l'objet d'une étude.

Commencez par Linux Kernel Primer de Claudia Salzberg et al. Bon pour commencer pour les débutants. Le livre de Robert Love n’est certainement pas le livre par lequel les débutants devraient commencer. Ce dernier livre est au-dessus du niveau intermédiaire.