Émuler les systèmes Linux embarqués avec QEMU
1. Introduction
Le développement de logiciels embarqués repose sur des périphériques matériels embarqués, tels que des cartes de développement, des modules externes, etc., mais si le travail de débogage n'a rien à voir avec les périphériques, seul le débogage du noyau peut être simulé à l'aide de QEMU sans acheter de matériel.
Il est disponible pour les hôtes Linux et Windows et les cibles émulées PowerPC, ARM, MIPS et SPARC. QEMU adopte l'approche de fournir une couche de traduction minimale entre l'hôte et le processeur cible. Le processeur hôte est celui qui exécute l'émulateur et le processeur cible est celui qui est émulé.
Ce qui suit est une introduction détaillée au processus de configuration de l'environnement de développement QEMU.
2. Milieu
2.1 Environnement utilisé
* Ubuntu-18.04.1
OU:
*PC：Windows10
* Machine virtuelle：VirtualBox-5.18
* OS virtuel：Ubuntu-18.04.1
* Carte de développement simulée : vexpres
2.2 Outils utilisés lors de la configuration de l'environnement
* qemu-4.2.0
* linux-4.14.172 (noyau Linux)
* u-boot-2017.05
*boîte occupée-1.31.1
* arm-linux-gnueabi-gcc
Mettez tous les fichiers associés dans /home/joe/qemu
3. Installer des outils de compilation croisée
# sudo apt install gcc-arm-linux-gnueabi
Vérifiez si l'installation est réussie
| $ arm-linux-gnueabi-gcc -v
Utilisation des spécifications intégrées. COLLECT_GCC=arm-linux-gnueabi-gcc COLLECT_LTO_WRAPPER=/usr/lib/gcc-cross/arm-linux-gnueabi/7/lto-wrapper Cible: arm-linux-gnueabi Configuré avec : ../src/configure -v –with-pkgversion='Ubuntu/Linaro 7.5.0-3ubuntu1~18.04′–with-bugurl=file:///usr Modèle de fil: posix gcc version 7.5.0 (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04) |
4. Configurer et compiler le noyau Linux
4.1 Télécharger le noyau Linux
Téléchargez la version du noyau requise sur www.kernel.org.
Ici, je télécharge la version relativement récente du noyau pris en charge à long terme linux-4.4.157
wget https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.4.157.tar.xz dans le répertoire /qemu
4.2 Décompressez le noyau Linux
# tar xvJf linux-4.4.157.tar.xz
4.3 Compiler le noyau Linux
// Entrer le répertoire du fichier source du noyau
#cd linux-4.4.157
make CROSS_COMPILE=arm-linux-gnueabi-ARCH=arm vexpress_defconfig
make CROSS_COMPILE=arm-linux-gnueabi-ARCH=arm menuconfig
Si l'exécution de menuconfig montre que le package ncurses est manquant, exécutez simplement la commande suivante pour l'installer)
$ sudo apt-get install libncurses5-dev
Entrez dans le menu de configuration et effectuez les réglages suivants
Compiler avec la chaîne d'outils croisée
Après une compilation réussie, générez un fichier image du noyau sous le répertoire
arch/arm/boot, zImage et dtb peuvent être copiés dans un dossier séparé pour une utilisation pratique
5. Installer les outils QEMU
5.1 Installer QEMU
* wget https://download.qemu.org/qemu-4.2.0.tar.xz
* tar xvJf qemu-4.2.0.tar.xz
* cdqemu-4.2.0
5.2 Installer les packages dépendants avant de configurer QEMU
# apt installer zlib1g-dev
# apt installer libglib2.0-0 libglib2.0-dev
# apt installer libsdl1.2-dev
# apt installer libpixman-1-dev libfdt-dev
Afin d'éviter que les fichiers ne soient désordonnés après la compilation, créez le répertoire du générateur comme chemin cible intermédiaire pour la compilation.
Configurer, compiler et installer QEMU.
5.3 Configurer QEMU pour prendre en charge toutes les cartes sous l'architecture arm
# ../configure –target-list=arm-softmmu –audio-drv-list=
Si pixman est manquant lorsque l'invite suivante apparaît,
utilisez sudo apt-get install libpixman-1-dev pour l'installer.
5.4 Afficher la version QEMU
5.5 Afficher les cartes de développement prises en charge par QEMU
5.6 Exécuter QEMU
# qemu-system-arm -M vexpress-a9 -m 512M -kernel ./zImage -dtb ./vexpress-v2p-ca9.dtb -nographic -append "console=ttyAMA0"
OU:
$pwd
/accueil/joe/qemu
# qemu-system-arm -M vexpress-a9 -m 512M -kernel linux-.4.157/arch/arm/boot/zImage -dtb linux-4.4.157/arch/arm/boot/dts/vexpress-v2p-ca9. dtb -nographic -append "console=ttyAMA0"
Afin de mieux tester et démarrer qemu, vous pouvez créer le script de démarrage start.sh et autoriser le script à exécuter chmod +x start.sh
#! / Bin / bash
qemu-système-bras \
-M vexpress-a9 \
-m 512M\
-kernel /home/joe/jemu/linux-4.4.157/arch/arm/boot/zImage\
-dtb /home/joe/jemu/linux-4.4.157/arch/arm/boot/dts/vexpress-v2p-ca9.dtb \
-nographique \
-ajouter "console=ttyAMA0"
6. Créez un système de fichiers racine
Utilisez busybox pour créer un système de fichiers racine simple.
6.1 Télécharger l'outil busybox
Téléchargez busybox depuis https://busybox.net/downloads/
# wget https://busybox.net/downloads/busybox-1.31.1.tar.bz2
# tar xjvf occupébox-1.31.1.tar.bz2
# cdboîte occupée-1.31.1
# faire defconfig
# faire CROSS_COMPILE=arm-linux-gnueabi-
# make install CROSS_COMPILE=arm-linux-gnueabi-
Les informations suivantes s'affichent, indiquant que l'installation a réussi.
Une fois l'installation terminée, le fichier cible généré se trouve par défaut dans le répertoire ./_install.
6.2 Générer le système de fichiers racine
6.2.1 compiler et installer busybox
# mkdir racinefs
# sudo cp -r _install/* rootfs/
6.2.2 Ajouter la bibliothèque glibc, ajouter le chargeur et la bibliothèque dynamique dans le système de fichiers racine
# sudo cp -r _install/* rootfs/
# sudo cp -p /usr/arm-linux-gnueabi/lib/* rootfs/lib/
6.2.3 Créer 4 périphériques terminaux tty (c signifie périphérique de caractère, 4 est le numéro de périphérique principal et 1 ~ 4 sont respectivement les numéros de périphérique mineurs)
6.3 Créer une image du système de fichiers de la carte SD
6.3.1 Générer une image de carte SD vide
# dd if=/dev/zero of=rootfs.ext3 bs=1M count=32
6.3.2 Formater la carte SD en tant que système de fichiers exts
# mkfs.ext3 rootfs.ext3
6.3.3 Graver rootfs sur une carte SD
# sudo mount -t ext3 rootfs.ext3 /mnt -o boucle
# sudo cp -rf rootfs/* /mnt/
# sudo umount /mnt
7. Vérifiez
7.1 Démarrer Qemu
Exécutez la commande suivante pour tester, vérifiez si le noyau compilé peut s'exécuter avec succès
# sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel ~/qemu/zImage –dtb ~/qemu/vexpress-v2p-ca9.dtb -nographic -append "console=ttyAMA0"
Ou en utilisant Script :
Dans le test ci-dessus, le noyau signalera une panique, suggérant que nous manquons du système de fichiers racine.
Le problème ci-dessus est dû à l'outil busybox généré dans l'environnement x86.
Nous avons utilisé make install lors de l'installation de busybox, vous devez donc utiliser
| make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-install |
L'outil de compilation génère l'outil busybox utilisé par la plateforme arm
# fichier rootfs/bin/busybox
rootfs/bin/busybox : exécutable LSB 32 bits, ARM, EABI5 version 1 (SYSV), lié dynamiquement, interpréteur /lib/ld-, pour GNU/Linux 3.2.0, BuildID[sha1]=cbcd33b8d6c946cb19408a5e8e714de554c87f52, supprimé
7.2 Vérifier à nouveau
Maintenant, Qemu a démarré le noyau Linux et monté le système de fichiers avec succès, et peut interagir avec le système avec des fonctions simples via le terminal série. Le problème de ne pas pouvoir exécuter /etc/init.d/rcS dans le processus d'impression, il vous suffit d'ajouter le fichier /etc/init.d/rcS. Le contenu du fichier peut être une instruction d'invite.
7.3 Quitter QEMU
Deux façons de quitter qemu
* Dans une autre entrée de terminal : kill all qemu-system-arm
* En entrée Qemu : Ctrl+A ; X
QEMU : terminé
8. Démarrez le noyau Linux via u-boot
Le système embarqué comprend généralement : u-boot, kernel, rootfs et appfs. La relation de position de ces pièces sur la carte de développement ARM illustrée dans la figure ci-dessous
| Chargeur de démarrage | Paramètres de démarrage | Noyau | Racines | Applications |
Rootfs peut fonctionner en carte ou en PC
8.1 Préparer le U-boot
8.1.1 Télécharger u-boot
http://ftp.denx.de/pub/u-boot/, nous utilisons : u-boot-2021.01.tar.bz2
# tar -jxvf u-boot-2018.09.tar.bz2
8.1.2 Compiler u-boot
# Makefile vim
CROSS_COMPILE = arm-linux-gnueabi-
# vim config.mk
ARCH = bras
# make vexpress_ca9x4_defconfig, erreur
Besoin : sudo apt install bison
sudo apt installer flex
alors : # make -j4 error
Besoin : export CROSS_COMPILE=arm-linux-gnueabi-
exporter ARCH=bras
encore : # make vexpress_ca9x4_defconfig
# make -j4
8.1.3 Tester, démarrer u-boot
$ sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel u-boot-2021.01/u-boot –nographic
8.2 Compilation de la configuration du noyau
Utilisez u-boot pour démarrer l'image du noyau :
Besoin de compiler le noyau au format uImage,
Besoin de spécifier l'adresse de chargement de uImage en mémoire
Spécifiez lors de la compilation du noyau : make LOADADDR=? uImage -j4
# cd /home/joe/qemu/linux-4.4.157
# faire LOADADDR=0x60003000 uImage -j4
Une fois la compilation u-boot terminée, un fichier mkimage sera généré dans le dossier de l'outil, copiez ce fichier dans le dossier bin sous le répertoire du compilateur croisé.
$cdqemu/linux-4.4.157
Erreur:
$ sudo apt installer u-boot-tools
Obtenir uImage
9. Paramètres de la fonction réseau QEMU
Lorsque la machine virtuelle Qemu démarre sur u-boot, uImage doit être chargé dans la mémoire et uImage peut être téléchargé à l'adresse spécifiée dans la mémoire via le serveur TFTP.
9.1 Vérifiez si le noyau hôte prend en charge le module tun/tap
// Installer les deux outils dont dépend le réseau ponté
# sudo apt install uml-utilities bridge-utils
Créer un fichier de périphérique tun : /dev/net/tun (généralement créé automatiquement)
Modifier le /etc/network/interfaces (configurer le réseau, redémarrer pour prendre effet)
# sudo vim /etc/network/interfaces
| auto loiface lo inet loopbackauto enp0s3 // nom de la carte réseau virtuelleauto br0iface br0 inet dhcpbridge_ports enp0s3 |
JAMAIS redémarrer
# redémarrer
Vérifiez ensuite l'environnement réseau de Qemu
Le port réseau virtuel br0 est le port réseau pour la communication entre la machine virtuelle Qemu et l'hôte Linux.
10. Installer le serveur TFTP
Créez un serveur TFTP pour télécharger uImage dans la mémoire lors du lancement de uImage pour la carte de développement de simulation Qemu
10.1 Installer l'outil tftp
$ apt-get install tftp-hpa tftpd-hpa xinetd
10.2 Modifier le fichier de configuration et définir le répertoire du serveur TFTP
| # sudo vim /etc/default/tftpd-hpa
...... TFTP_DIRECTORY="/home/joe/tftpboot" ...... |
10.3 Créer un répertoire tftp sur l'hôte Linux
# mkdir /home/joe/tftpboot
# chmod 777 /home/joe/tftpboot
10.4 Redémarrer le service tftp
# sudo /etc/init.d/tftpd-hpa redémarrer
10.5 Définir les paramètres de démarrage du noyau dans u-boot
copiez uImage et cexpress-v2p-ca9.dtb dans tftpboot
Démarrez Qemu pour vérifier
$ sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel u-boot-2021.01/u-boot –nographic -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 -sd rootfs. poste3
Maintenant, le répertoire rootfs est un simple système de fichiers racine, qui peut être transformé en un fichier miroir, et le fichier miroir peut être gravé sur la carte de développement, ou le noyau Linux peut être démarré par u-boot dans Qemu et monté sur le fichier miroir. Il peut également être configuré pour démarrer via le système de fichiers réseau NFS.
11. Monter le système de fichiers NFS
11.1 Installer et configurer le service NFS
Installation de 11.1.1
$ sudo apt installer le serveur nfs-kernel
11.1.2 Configuration
$ sudo mkdir /home/joe/qemu/rootfs
$ sudo chown personne:nogroup /home/joe/qemu/rootfs
$ sudo chmod 777 /home/joe/qemu/rootfs
$ sudo nano /etc/exports
Ajouter : /home/joe/qemu/rootfs *(rw,sync,no_root_squash)
Redémarrez le serveur nfs :
$ sudo /etc/init.d/nfs-kernel-server restart
Ou : $systemctl restart nfs-kernel-server
Vérifiez si le répertoire partagé NFS est créé
$ sudo showmount –e
Lors de l'utilisation du système de fichiers réseau NFS, l'hôte Linux doit fermer le pare-feu du système, sinon des anomalies se produiront lors de l'exécution du système.
Conclusion
J'espère qu'avec l'aide de ce blog, vous en saurez plus sur QEMU. Toutes les techniques démontrées ci-dessus ont été utilisées dans diverses soumissions à notre programme. Il n'y a pas un seul moyen fixe d'émuler avec QEMU. Explorez différentes techniques et voyez ce qui fonctionne pour vous. Familiarisez-vous avec les connaissances et vous serez surpris de voir comment cela peut vous aider de manière inattendue.