Utilisez QEMU pour créer un environnement de développement BIOS et noyau

La description

Cet article crée principalement un système complet, qui comprend le BIOS décrit ci-dessus, ainsi que le GRUB, le noyau et le système de fichiers décrits ici.

 

Téléchargement et compilation du noyau

Comme l'environnement utilisé est Ubuntu 18.04, le téléchargement et la compilation du noyau sont relativement simples. La première consiste à télécharger le noyau, vous devez utiliser la commande suivante:

sudo apt install linux-source

Le processus de téléchargement est le suivant:

Le code téléchargé se trouve dans le répertoire / usr / src:

Nous le téléchargeons et le mettons dans le répertoire spécifié:

tar -xjvf linux-source-4.15.0.tar.bz2 -C /home/jw/code/

Le -C est utilisé pour spécifier le dossier de destination pour la décompression, afin que le code source Linux puisse être trouvé dans le répertoire spécifié et utilisé. Entrez ensuite le répertoire /home/jw/code/linux-source-4.15.0 et lancez la compilation. Avant de compiler, vous devez créer un fichier .config. Pour plus de commodité, utilisez directement la configuration par défaut (qui sera ensuite modifiée en fonction de la situation réelle):

make defconfig

Après cela, vous pouvez utiliser make pour compiler, mais une erreur peut être signalée pendant le processus de compilation, car certaines bibliothèques dépendantes n'existent pas, installez-la simplement, vous devez l'installer ici (différentes versions d'Ubuntu peuvent nécessiter l'installation de différentes bibliothèques, veuillez installer selon la situation réelle) :

sudo apt install libelf-dev
sudo apt install libssl-dev

Après une compilation réussie, vous pouvez trouver le fichier noyau dont nous avons besoin sous ~ / code / linux-source-4.15.0 / arch / x86 / boot:

A la fin de la compilation, veillez à ne pas installer le noyau en utilisant make install, car nous n'installons pas ce noyau sur le compilateur, mais devons utiliser la machine virtuelle (QEMU) pour exécuter le noyau, c'est-à-dire que bzImage sera utilisé pour le système de démarrage de QEMU.

 

VER

Vous pouvez télécharger GRUB via git. GRUB 2.02 est utilisé ici. La commande est la suivante:

git clone https://gitee.com/jiangwei0512/grub-2.02

Une fois le téléchargement terminé, entrez dans le répertoire et lancez d'abord ./configure:

./configure --target=x86_64 --with-platform=efi

Plusieurs paramètres sont utilisés ici, parmi lesquels le paramètre --target est utilisé pour spécifier la plate-forme correspondante, la plate-forme x86 64 bits est spécifiée ici et l'autre paramètre --with-platform est utilisé pour spécifier l'UEFI. Mais il y aura des erreurs lors de la configuration, car certaines bibliothèques doivent être installées:

sudo apt install flex bison

Une fois que configure s'exécute avec succès, vous pouvez exécuter la commande make. S'il n'y a pas d'erreur alcocal-1.15 lors de la compilation, vous pouvez installer automake et exécuter autoreconf -i -f pour le résoudre, mais il existe un moyen plus simple de toucher tous les fichiers. Une fois la création réussie, utilisez la commande suivante pour générer le binaire GRUB:

./grub-mkimage -p . -d ./grub-core/ -O x86_64-efi -o bootx64.efi XXX

Expliquez brièvement les paramètres suivants: -p spécifie le répertoire où se trouvent grub.cfg, les modules indépendants et les autres fichiers; -d spécifie l'emplacement de l'image et du module que nous venons de compiler, car ils sont ce dont nous avons besoin et n'existent pas déjà dans le système ; -O spécifie le format binaire, nous avons besoin du format UEFI sous la plate-forme x86; -o est utilisé pour spécifier le nom du fichier de sortie; le dernier XXX est le module GRUB, qui est le fichier * .module dans le répertoire grub-core:

Les modules utilisés ici sont spécifiés comme suit:

./grub-mkimage -p . -d ./grub-core/ -O x86_64-efi -o bootx64.efi boot linux part_msdos part_gpt fat normal serial efi_gop minicmd

Le binaire compilé final est bootx64.efi (le nom est utilisé car il s'agit du nom universel du chargeur de système d'exploitation dans UEFI), et ce fichier sera utilisé plus tard. De plus, GRUB a un fichier de configuration correspondant appelé grub.cfg, et son contenu spécifique sera présenté plus tard. GRUB et ses fichiers de configuration seront utilisés pour le système de démarrage QEMU.

 

boîte occupée

Vous pouvez télécharger le code source de busybox sur https://busybox.net/downloads/ , voici la version 1.29.1, décompressez-le dans le répertoire spécifié:

tar -xjvf busybox-1.29.2.tar.bz2 -C /home/jw/code

Entrez ensuite dans le répertoire de configuration (exécutez make menuconfig dans le répertoire du code source):

Ce que nous devons configurer est de sélectionner la compilation statique, et l'emplacement est sous Paramètres. Notez que pour utiliser menuconfig, des bibliothèques supplémentaires (libncurses5-dev) peuvent avoir besoin d'être installées. Après la configuration, vous pouvez utiliser make pour compiler. Une fois la compilation terminée, installez via la commande make install:

make install

Après avoir exécuté la commande ci-dessus, un nouveau répertoire appelé _install sera généré dans le répertoire courant. Nous avons besoin de ces fichiers pour générer des initramfs que le noyau doit utiliser. Les fichiers correspondants sont les suivants:

La méthode de création d'initramfs, la plus simple est utilisée ici, et la commande correspondante est la suivante:

mkdir initramfs
cd initramfs
mkdir dev proc sys
cp ../_install/* ./ -ra
sudo cp -a /dev/{null,console,tty1,tty2,tty3,tty4} dev/
touch init
chmod a+x init

Le contenu de init est le suivant:

mount -t proc none /proc
mount -t sysfs none /sys
mdev -s
exec /sbin/init

Enfin, créez un package via la commande suivante:

find . -print0 | cpio --null -ov --format=newc | gzip -9 > ../initramfs.cpio.gz

initramfs.cpio.gz est le fichier que nous obtenons finalement, il sera utilisé pour le système de démarrage QEMU.

 

Système de démarrage QEMU

La première consiste à créer un disque dur utilisé par QEMU (en fait juste un fichier) et à le formater au format FAT (car UEFI ne reconnaît que ce type par défaut):

dd if=/dev/zero of=disk.img bs=1M count=32
mkfs.fat disk.img

La taille du disk.img créé ici est de 32 Mo. Ce n'est pas une exigence absolue, tant qu'il est plus grand que la somme des tailles du noyau, des initramfs, GRUB, etc. L'opération suivante consiste à monter disk.img et à placer les fichiers mentionnés ci-dessus dans disk.img:

sudo mount disk.img tmp
sudo mkdir tmp/EFI tmp/EFI/BOOT
sudo cp bootx64.efi grub.cfg tmp/EFI/BOOT
sudo cp bzImage initramfs.cpio.gz tmp

Il faut d'abord dire que disk.img est monté dans un répertoire (ici tmp), puis les fichiers y sont placés. Une attention particulière doit être portée à GRUB et à ses fichiers de configuration, qui doivent être placés dans le répertoire / EFI / BOOT, le fichier final comme suit:

À ce stade, nous avons placé les fichiers requis dans disk.img, qui peut être utilisé comme disque dur QEMU. Les instructions correspondantes sont les suivantes:

qemu-system-x86_64 -bios OVMF.fd -hda disk.img -m 512M

Les paramètres QEMU ici sont les suivants: -bios spécifie le nom du BIOS, ici est OVMF.fd; -hda spécifie le disque dur, ici est disk.img; -m spécifie la taille de mémoire utilisée par la machine virtuelle. L'état final après le démarrage est le suivant:

À ce stade, un noyau de base a été démarré et nous pouvons compter sur le système pour le débogage plus tard.