Lesson 1: Linux Kernel, révision

Rappel actif

Restitue de mémoire, sans support.

Donne dans l’ordre les six étapes pour passer des sources d’un noyau à une machine qui démarre dessus, avec la commande ou le fichier clé de chaque étape.
1. Récupérer les sources sur kernel.org et décompresser l’archive (tar.gz, tar.bz2, tar.xz).
2. Générer le .config : make menuconfig (ou config, xconfig, gconfig, defconfig, oldconfig).
3. Compiler : make (ou make bzImage puis make modules).
4. Installer : make modules_install (modules vers /lib/modules/<version>) et make install (image et System.map vers /boot).
5. Créer le ramdisk : mkinitramfs -o /boot/initramfs-<version>.img <version> (ou mkinitrd).
6. Ajouter une entrée au gestionnaire de démarrage, sans rien retirer à l’existant.
Le piège habituel : oublier les étapes 5 et 6. Le noyau est en place mais rien ne le charge, ou il démarre sans les modules dont il a besoin.
Cite les sept services de base que le noyau offre au reste du système, et par quel mécanisme un programme utilisateur y accède.
Où vivent le cœur du noyau et ses modules sur le disque ? Donne l’extension d’un module et le nom des images du cœur.
- Cœur : un fichier de quelques Mo dans /boot, nommé zImage ou bzImage (souvent vmlinuz-<version>), chargé intégralement par le bootloader.
- Modules : fichiers .ko dans /lib/modules/<version>/, rangés en drivers/, net/, sound/, fs/…

Tape la commande

Écris la commande exacte, puis Entrée pour vérifier.

Affiche seulement la version du noyau en cours d’exécution.
```
uname -r
```
-s donnerait le nom du système (Linux), -p le type de processeur, -a tout. C’est aussi uname -r qui sert à construire le chemin /lib/modules/$(uname -r).
Vérifie si le module vfat est actuellement chargé en mémoire, en une seule ligne.
```
lsmod | grep vfat
```
lsmod liste les modules chargés, grep filtre. Aucune sortie : le module n’est pas chargé.
Charge le module vfat en laissant le système résoudre et charger ses dépendances.
```
modprobe vfat
```
modprobe prend un nom de module et lit les dépendances dans modules.dep. insmod prendrait un chemin de fichier .ko et ne charge aucune dépendance.
Charge vfat directement depuis son fichier .ko, sans passer par modprobe, en construisant le chemin avec la version du noyau courant.
```
insmod /lib/modules/$(uname -r)/kernel/fs/fat/vfat.ko
```
Si vfat dépend de fat et que fat n’est pas chargé, insmod échoue : il ne gère pas les dépendances.
Retire vfat de la mémoire avec l’outil qui sait aussi retirer les dépendances devenues inutiles.
```
modprobe -r vfat
```
rmmod vfat retire aussi le module, mais seulement lui.
Affiche les informations d’un module (fichier, description, dépendances, paramètres) pour vfat, sans le charger.
```
modinfo vfat
```
Tu as copié un module à la main dans /lib/modules/<version>/ et modprobe ne le trouve pas. Régénère le fichier de dépendances.
```
depmod -a
```
Il reconstruit modules.dep, le fichier que lit modprobe.
Active le routage IPv4 à chaud avec sysctl.
```
sysctl -w net.ipv4.ip_forward=1
```
Effet immédiat mais perdu au redémarrage. Pour le rendre permanent : net.ipv4.ip_forward = 1 dans /etc/sysctl.conf.
Même chose, sans sysctl : écris directement dans le fichier qui représente le paramètre.
```
echo 1 > /proc/sys/net/ipv4/ip_forward
```
Les points du nom sysctl deviennent des / sous /proc/sys.
Configure le noyau pour qu’il redémarre automatiquement 20 secondes après un kernel panic, à chaud, via /proc.
```
echo 20 > /proc/sys/kernel/panic
```
Équivalent : sysctl -w kernel.panic=20.
Applique le patch patch-5.10.2 sur les sources, sachant que les chemins du patch ont un niveau de répertoire en trop.
```
patch -p1 < patch-5.10.2
```
-p1 retire le premier composant de chaque chemin décrit dans le patch.
Le noyau patché pose problème : retire ce même patch.
```
patch -p1 -R < patch-5.10.2
```
-R inverse le patch, avec le même niveau -p que pour l’appliquer.
Génère le .config d’un nouveau noyau en partant de celui de l’ancienne version, pour ne répondre qu’aux nouvelles options.
```
make oldconfig
```
Tu es connecté en SSH, sans interface graphique. Lance l’outil de configuration du noyau en mode texte amélioré.
```
make menuconfig
```
Il faut libncurses-dev. xconfig (QT) et gconfig (GTK) demandent un affichage graphique.
Crée l’image ramdisk avec mkinitramfs pour le noyau 5.10.2, dans /boot/initramfs-5.10.2.img.
```
mkinitramfs -o /boot/initramfs-5.10.2.img 5.10.2
```
Le dernier argument est le nom du répertoire des modules dans /lib/modules. Version historique : mkinitrd /boot/initrd-5.10.2.img 5.10.2.
Tu viens de modifier une règle udev : recharge les règles puis redéclenche les événements, en une ligne.
```
udevadm control --reload-rules && udevadm trigger
```
Sans trigger, les nouvelles règles ne s’appliquent qu’aux prochains événements, pas aux périphériques déjà présents.
Affiche le détail du périphérique PCI situé à l’adresse 00:03.0.
```
lspci -s 00:03.0 -v
```

Écris-le

Rédige la requête, la configuration ou le code, puis compare avec la réponse.

Le module virtio-net doit être chargé à chaque démarrage, que le matériel soit détecté ou non (Red Hat 7/8, systemd). Donne le chemin du fichier à créer et son contenu exact.
Fichier /etc/modules-load.d/virtio-net.conf :
```
virtio-net
```
Un nom de module par ligne, sans .ko. C’est systemd-modules-load.service qui le lit au démarrage.
Avec systemd, renomme en eth0 l’interface dont l’adresse MAC est 00:0c:29:9c:00:76. Donne le fichier et son contenu.
/etc/systemd/network/70-custom-ifnames.link :
```
[Match]
MACAddress=00:0c:29:9c:00:76
[Link]
Name=eth0
```
Puis reboot. [Match] dit quelle interface, [Link] dit quoi lui appliquer.
Rends le routage IPv4 permanent, puis applique le fichier sans redémarrer.
Dans /etc/sysctl.conf :
```
net.ipv4.ip_forward = 1
```
Puis sysctl -p pour relire le fichier. (Le cours montre la ligne à 0 : c’est la valeur qui désactive.)

Distingue

Deux notions proches : dis ce qui les sépare vraiment.

Noyau modulaire et noyau monolithique : avantage de chacun, et pourquoi un serveur de production pourrait préférer l’un ou l’autre ?
- Modulaire : charge et décharge les modules à la demande, économise la mémoire, permet d’ajouter un pilote sans arrêter le système.
- Monolithique : tout est embarqué, d’où la haute disponibilité et le support d’un grand nombre de configurations, sans dépendre de fichiers externes au démarrage.
Choix : modulaire si le matériel change ou qu’on veut éviter les redémarrages, monolithique pour un matériel fixe où l’on veut un noyau autonome.
insmod et modprobe chargent tous deux un module. Donne deux différences concrètes.
Kernel mode et user mode : qu’est-ce qui change quand un bug survient dans chacun ?
echo 1 > /proc/sys/..., sysctl -w et /etc/sysctl.conf : lesquels survivent à un redémarrage ?
make seul, make bzImage et make modules : que produit chacun ?
- make : le noyau et les modules.
- make bzImage (ou zImage) : seulement l’image du noyau.
- make modules : seulement les modules.

	`insmod`	`modprobe`
Argument	chemin du fichier `.ko`	nom du module
Dépendances	aucune, échoue si une manque	résolues via `modules.dep`
Retrait	`rmmod`	`modprobe -r`, qui retire aussi les dépendances inutilisées

Explique pourquoi

Le mécanisme derrière la règle.

Pourquoi ne peut-on appliquer que le patch de la version qui suit exactement la version actuelle des sources ?
Pourquoi un noyau fraîchement installé a-t-il besoin d’un ramdisk (initrd / initramfs) ?
Pourquoi le cours insiste-t-il pour ajouter une entrée au gestionnaire de démarrage plutôt que remplacer l’ancienne ?

Cas pratique

Choisis et justifie avec les critères du cours.

Une nouvelle carte réseau est branchée sur un serveur qui ne doit pas redémarrer. Le pilote existe déjà sous forme de module. Comment l’activer, et qu’est-ce que ça dit du type de noyau ?
Après une mise à jour, l’interface réseau s’appelle ens33 alors que tous les scripts attendent eth0. Quelles sont les deux approches vues en cours ?
1. Règle udev associant la MAC au nom (... ATTR{address}=="<mac>", ... NAME="eth0"), puis udevadm control --reload-rules && udevadm trigger.
2. Fichier .link systemd (/etc/systemd/network/70-custom-ifnames.link, [Match] MACAddress= puis [Link] Name=eth0), puis reboot.
Le nom par défaut vient de NamePolicy dans 99-default.link.

Trouve l'erreur

Chaque affirmation contient au moins une faute.

« Pour charger vfat avec ses dépendances, je tape insmod vfat. »
« J’ai tapé echo 1 > /proc/sys/net/ipv4/ip_forward, le routage restera activé après le redémarrage. »
« Mes sources sont en 5.10.1. Je télécharge le patch 5.10.3 et je l’applique directement pour gagner du temps. »
« make install copie l’image du noyau et les modules dans /boot. » (C’est ce que dit le résumé du cours.)
« udev est un composant du noyau qui crée les fichiers de /dev. »

Classe

Range chaque élément et explique les cas limites.

Décompose la version 5.15.0.91 selon le schéma X.Y.Z.a du cours.
Range chaque outil de configuration du noyau selon ce dont il a besoin : make config, make menuconfig, make xconfig, make gconfig, make defconfig, make oldconfig.
- Aucune interaction : defconfig (valeurs par défaut), oldconfig (repart de l’ancien .config, ne demande que les nouveautés).
- Terminal, question par question : config.
- Terminal amélioré, utilisable en SSH : menuconfig (libncurses-dev).
- Graphique : xconfig (QT, libqt3-mt-dev, g++), gconfig (GTK).
Et make mrproper ne configure rien : il supprime l’ancien .config.

X	Y	Z	a
5 (major)	15 (minor)	0 (revision)	91 (release)

Et si...

Prévois la conséquence.

Et si on compile et installe un nouveau noyau, mais qu’on oublie de générer son initramfs ?
Et si on lance make mrproper dans un dossier de sources déjà configuré, juste avant make ?

Lessons / Lesson 1: Linux Kernel, révision