kernel code source Fermé

Question

Bonjour, 
          Jusqu'ici je suis très passionné par les systèmes d'exploitation. Alors pour apprendre plus les concernant, j'ai rencontré un enseignant qui veut bien m'aider. Pour être bref, Il m'a demandé de commencer par étudier le kernel de Linux/Unix et de le modifier dans la mesure du possible. Alors pour cela j'ai téléchargé la version 4.14.2 et celle 1.0 sur kernel.org. Je m'attendais à trouver un projet compilable mais à la place, c'est plutôt un ensemble de code source organisé en fichier. Pourrez-vous m'aider avec un lien ou je peux trouver un projet compilable sinon comment utilisé celui de kernel.org à partir de tous ses dossiers.

Merci.


Configuration: Linux / Firefox 52.0

mamiemando · Answer

Bonjour,

Introduction

C'est tout à fait normal. En fait il faut distinguer plusieurs types de fichiers :
- les headers (.h) qui permettent de compiler quelque chose qui doit s'interfacer avec le noyau (par exemple un pilote)
- les sources (.c, et .h) qui inclue donc les headers, et qui permet de compiler le noyau lui même et ses modules de base (.ko) (et a fortiori, par la suite, des pilotes)
- l'image, installée à terme dans /boot, et ses modules (fichiers .ko) qui sont le résultat de cette compilation, ce qui permettent d'utiliser ta machine et son matériel. 

Afin d'illustrer la suite de mon message, je vais considérer que tu utilises une distribution debian ou un dérivé (ubuntu, mint...). Ce que j'explique reste applicable la plupart du temps pour les autres distributions linux moyennant quelques adaptations.

Sous debian cela revient à types de paquets, respectivement linux-sources-*, linux-headers-*, linux-image-* où * est à remplacer par une numéro de version et une architecture (e.g. 4.13.0-1-amd64). Ces paquets (.deb) sont installés à partir du gestionnaire de paquets apt-get et sont en gros soit une archive qui contient ce que tu as récupéré sur kernel.org (pour les paquets linux-headers et linux-sources), soit le résultat obtenu après compilation (linux-image).

En pratique quand tu installes un système, seul le paquet linux-image (dans sa dernière version et pour ton architecture de micro processeur est installé). Cela suffit à la plupart des utilisateurs. S'ils souhaitent préparer un pilote (e.g. un pilote nvidia), les headers sont suffisants. Ensuite pour un public plus curieux ou qui désire préparer un noyau plus optimisé, il est possible de récupérer les sources et d'indiquer quelles fonctionnalités doivent ou non être supportées dans le noyau.

Récupérer des sources sur kernel.org revient à ce dernier choix, sauf que tu n'es pas passé par apt-get. En soi rien de bien gênant, mais personnellement je préfère toujours passer par le gestionnaires de paquets car ça permet de retrouver ce qui est installé sur la machine plus facilement, et donc de la nettoyer plus facilement.

Compiler un noyau

Tu peux regarder ce tutoriel, qui explique comment compiler un kernel. Il est recommandé d'avoir quelques bases en compilation.

Un kernel est écrit en langage C. Le C est un langage compilé, ce qui signifie que ses sources doivent être traitées pour produire un programme utilisable.

Plus précisément :
- compiler un programme consiste à convertir des sources (e.g. fichiers .c) en binaires (.o, .ko, exécutable, librairie .a ou .so, kernel). Les .o sont des binaires destinés à produire un autre binaire (exécutable, .so, .a, ...). Les .ko sont des modules de noyau (~ pilotes).
- le logiciel traditionnellement utilisé pour produire un binaire est gcc
- chaque exécution de gcc est destiné à générer un objet ou un binaire.

Lorsqu'on compile un noyau, des centaines de binaires (.ko et autres) devront être générés. Bien trop pour qu'on les compile tous un par un :-) Pour éviter une tâche aussi fastidieuse, on va s'appuyer sur un script, appelé Makefile. Il permet au travers de la commande make de réaliser toute une chaîne de commandes. Plus précisément, un Makefile décrit les dépendances entre les différents objets. Il est alors possible de ne construire que les dépendances nécessaires à la compilation de ce que tu veux obtenir (par exemple, ton image de noyau).

L'utilisation des Makefile est très répandue et utilisée pour de nombreux projets (pas forcément des noyaux, et pas forcément écrits en C d'ailleurs). Généralement les dépendances sont connues à l'avance, mais ce n'est pas le cas d'un noyau qu'on veut, en général, optimiser. C'est la raison pour laquelle les dépendances utilisées par le Makefile sont déportées dans un fichier tiers, le fichier .config (placé dans le répertoire des sources du noyau).

La première étape pour compiler un noyau consiste à générer/mettre à jour ce .config en indiquant ce que tu veux construire. Pour ce faire, une interface permet de le faire make menuconfig ou make oldconfig (quand on le récupères depuis un répertoire de source de noyau antérieur).

Attention à ne pas enlever des fonctionnalités vitales, car sinon ta machine ne démarrera pas sur ce noyau (kernel panic). Comme généralement le but quand on compile son propre noyau est d'obtenir un noyau optimisé, toute la difficulté est donc de déterminer les fonctionnalités nécessaires ou dont tu pourrais avoir besoin, et désactiver autant que possible les autres. Pour commencer en douceur, tu peux te contenter de garder les choix activés par défaut, ce qui devrait te donner un noyau peu optimisé mais utilisable.

Une fois le .config défini, il est alors possible de passer à la compilation proprement dite, puis d'installer le noyau dans /boot et ses modules dans /lib/modules et de mettre à jour ton boot loader (e.g. grub). Si tu es sous debian ou une distribution qui en dérive, je te conseille d'utiliser make-kpkg pour avoir un paquet propre, puis d'installer le paquet obtenu avec dpkg -i. Cela permet également ne pas avoir à réaliser toutes ces étapes manuellement. Tout ceci est décrit dans le tutoriel (ainsi que le cas où tu n'es pas sous debian).

Bonne chance

mamiemando · Answer

Attention il ne faut pas mélanger deux choses : le noyau et le système. Cette procédure permet de compiler uniquement le noyau. A la fin tu obtiens une image noyau ou un paquet debian selon la méthode que tu as utilisé (e.g. make-kpkg).

On est loin après ça d'avoir un système, il faut ensuite une chaîne de démarrage, un certain nombre de paquets essentiels (par exemple un shell). Si l'idée est de faire une distribution live minimale, il y a des outils pour ça et il n'est même pas utile de compiler son propre noyau (un noyau par défaut fera amplement l'affaire).
https://debian-facile.org/utilisateurs:abdelqahar:tutos:live-build

Bonne chance

mamiemando · Answer

Merci pour ton retour.

Pour make-kpkg il suffit que tu installes avec apt-get le paquet approprié.

Bonne chance

mamiemando · Answer

Bonjour,

Tu n'as pas a télécharger les sources de noyau "à la main" dans 

/home/user/Téléchargements/linuxx comme tu sembles l'avoir fait. Si tu installes un paquet linux-source le noyau correspondant sera dans /usr/src/.

De plus ton erreur de compilation semble provenir du fait que tu lance make oldconfig (visiblement indirectement, par l'intermédiaire de make-kpgk). Mais dans ce cas, il faut que le Makefile de tes sources de noyau propose cette cible, ce qui ne semble pas être le cas. Je pense que c'est lié au fait que tu n'as pas pris des sources de noyaux prévues pour être compilées avec make-kpkg. Cette commande est prévue pour fonctionner avec des sources fournies par un paquet linux-source.

Si tu veux absolument compiler les sources que tu as récupérées, suis ce tutoriel :
https://www.mistra.fr/tutoriel-linux-compiler.html

Bonne chance

Kernel code source

4 réponses

Discussions similaires