Exécutez Linux avec l'architecture ARM à l'aide de QEMU

introduction

• Nous avons résumé comment utiliser QEMU pour exécuter Linux avec l'architecture ARM.

Aperçu

• QEMU est un émulateur Linux. Ici, le noyau Linux est compilé de manière croisée pour ARM et le système de fichiers racine est créé à l'aide de BusyBox.
• BusyBox est un logiciel qui combine les commandes Linux standard dans un seul fichier binaire.

Environnement d'exploitation

• Ubuntu 20.04 LTS

Environnement

1. Installez git.

   $ sudo apt-get install git
   

2. Installez le compilateur croisé ARM.

   $ sudo apt-get install gcc-arm-linux-gnueabi
   

3. Installez le logiciel nécessaire pour construire le noyau Linux.

   $ sudo apt-get install flex bison libncurses-dev libssl-dev
   

4. Installez QEMU pour ARM.

   $ sudo apt-get install qemu-system-arm
   

Structure du répertoire au moment de la construction

• Dans les éléments suivants, la structure du répertoire créé est la suivante.

{top_directory} ├ linux-stable │ └ arch │ └ arm │ └ boot │ ├ zImage: Image du noyau │ └ dts │ └ polyvalent-pb.dtb: arborescence des périphériques │ ├ busybox │ ├ _install: système de fichiers racine │ └ rootfs.img: Image du système de fichiers racine │ ├ driver │ └ sample │ └ driver_sample.ko: module de pilote de périphérique │ └ app └ sample └ app_sample: fichier binaire d'exécution de l'application ~~~

Construction du noyau Linux

1. Clonez le noyau Linux (noyau stable).

   $ git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git
   

2. Accédez au répertoire cloné.

   $ cd linux-stable
   

3. Appliquez les paramètres par défaut des cartes Arm Versatile (versatilepb).

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- versatile_defconfig
   

4. Construisez.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

5. Assurez-vous que l'image du noyau et l'arborescence des périphériques sont générées.

   $ ls -latr arch/arm/boot/dts/versatile-pb.dtb
   $ ls -latr arch/arm/boot/zImage
   

Construire BusyBox

1. Clonez la BusyBox.

   $ git clone git://git.busybox.net/busybox
   

2. Accédez au répertoire cloné.

   $ cd busybox
   

3. Appliquez les paramètres par défaut.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- defconfig
   

4. Puisque nous devons créer un lien statique pour travailler avec un seul binaire, exécutez la commande make menuconfig pour activer la configuration du noyau "Construire un binaire statique (pas de bibliothèques partagées)".

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- menuconfig
   

   Settings --> Build static binary (no shared libs)
   

5. Construisez.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

6. Installez. Une fois l'installation terminée, un système de fichiers racine sera créé sous le répertoire _install.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- install
   

Créer un pilote de périphérique

1. Créez un répertoire pour le pilote de périphérique et accédez-y.

   $ mkdir -p driver/sample
   $ cd driver/sample
   

2. Créez le code source du pilote de périphérique. (Le code source suivant est un exemple de pilote de périphérique qui se charge / décharge simplement.)

   $ nano driver_sample.c
   

   #include <linux/module.h>
   #include <linux/kernel.h>
   
   static int __init sample_module_init( void )
   {
   	printk( "driver sample load\n" );
   	return 0;
   }
   
   static void __exit sample_module_exit( void )
   {
   	printk( "driver sample remove\n" );
   }
   
   module_init( sample_module_init );
   module_exit( sample_module_exit );
   
   MODULE_DESCRIPTION( "sample_module" );
   MODULE_LICENSE( "GPL" );
   

3. Créez un Makefile.

   $ nano Makefile
   

   obj-m := driver_sample.o
   
   all:
   	make -C $(shell pwd)/../../linux M=$(shell pwd) modules
   clean:
   	make -C $(shell pwd)/../../linux M=$(shell pwd) clean
   

4. Compilez le pilote de périphérique.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

5. Copiez le pilote de périphérique dans le répertoire busybox _install.

   $ cp driver_sample.ko ../../busybox/_install/
   

Créer une application

1. Créez un répertoire pour votre application et accédez-y.

   $ mkdir -p app/sample
   $ cd app/sample
   

2. Créez le code source de votre application. (Le code source suivant est un exemple d'application qui génère uniquement des journaux.)

   $ nano app_sample.c
   

   #include <stdio.h>
   
   int main(int argc, char *argv[])
   {
   	printf( "app sample run\n" );
   	return 0;
   }
   

3. Créez un Makefile.

   $ nano Makefile
   

   TARGET	= app_sample
   
   CC		= ${CROSS_COMPILE}gcc
   LD		= ${CROSS_COMPILE}gcc
   
   CSRCS	= $(TARGET).c
   CFLAGS	= -c
   LDFLAGS	= -static -o $(TARGET)
   
   OBJS	= $(CSRCS:.c=.o)
   LIBS	=
   
   .c.o:
   	$(CC) $(CFLAGS) $<
   
   $(TARGET): $(OBJS)
   	$(LD) $(LDFLAGS) $(OBJS) $(LIBS)
   
   clean: ;
   	rm $(OBJS) $(TARGET)
   

4. Cross-compilez votre application.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

5. Copiez l'application dans le répertoire busybox _install.

   $ cp app_sample ../../busybox/_install/
   

Exécutez QEMU

1. Image du système de fichiers racine.

   $ cd busybox/_install/
   $ find .| cpio -o --format=newc > ../rootfs.img
   $ cd ../../
   

2. Exécutez QEMU.

   $ qemu-system-arm \
   	-M versatilepb \
   	-kernel ./linux/arch/arm/boot/zImage \
   	-dtb ./linux/arch/arm/boot/dts/versatile-pb.dtb \
   	-nographic \
   	-append "rdinit=/bin/sh" \
   	-initrd ./busybox/rootfs.img
   

3. Lorsque le démarrage est terminé, le shell démarre. En vérifiant avec la commande ls, le système de fichiers racine ressemble à ceci:

   / # ls
   app_sample        dev               linuxrc           sbin
   bin               driver_sample.ko  root              usr
   / #
   

4. Chargez le pilote de périphérique.

   / # insmod driver_sample.ko
   driver_sample: loading out-of-tree module taints kernel.
   driver sample load
   

5. Exécutez l'application.

   / # ./app_sample
   app sample run