Führen Sie Linux mit ARM-Architektur mit QEMU aus

Einführung

• Wir haben zusammengefasst, wie QEMU zum Ausführen von Linux mit ARM-Architektur verwendet wird.

Überblick

• QEMU ist ein Linux-Emulator. Hier wird der Linux-Kernel für ARM crosskompiliert und das Root-Dateisystem mit BusyBox erstellt.
• BusyBox ist eine Software, die Standard-Linux-Befehle in einer einzigen Binärdatei kombiniert.

Betriebsumgebung

• Ubuntu 20.04 LTS

Umgebung

1. Installieren Sie git.

   $ sudo apt-get install git
   

2. Installieren Sie den ARM-Cross-Compiler.

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

3. Installieren Sie die Software, die zum Erstellen des Linux-Kernels erforderlich ist.

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

4. Installieren Sie QEMU for ARM.

   $ sudo apt-get install qemu-system-arm
   

Verzeichnisstruktur zur Erstellungszeit

• In den folgenden Elementen ist das erstellte Verzeichnis wie folgt aufgebaut.

{top_directory} ├ linux-stable │ └ arch │ └ arm │ └ boot │ ├ zImage: Kernel-Image │ └ dts Atile └ vielseitig-pb.dtb: Gerätebaum │ ├ busybox Inst ├ _install: Root-Dateisystem │ └ rootfs.img: Image des Root-Dateisystems │ ├ driver │ └ sample │ └ driver_sample.ko: Gerätetreibermodul │ └ app └ sample └ app_sample: Ausführungsbinärdatei der App ~~~

Linux Kernel Build

1. Klonen Sie den Linux-Kernel (Stable Kernel).

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

2. Navigieren Sie zum geklonten Verzeichnis.

   $ cd linux-stable
   

3. Wenden Sie die Standardeinstellungen für Arm Versatile-Boards (versatilepb) an.

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

4. Bauen.

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

5. Stellen Sie sicher, dass das Kernel-Image und der Gerätebaum generiert wurden.

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

Erstellen Sie BusyBox

1. Klonen Sie die BusyBox.

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

2. Navigieren Sie zum geklonten Verzeichnis.

   $ cd busybox
   

3. Wenden Sie die Standardeinstellungen an.

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

4. Wir müssen einen statischen Link erstellen, um mit einer einzelnen Binärdatei arbeiten zu können. Führen Sie daher den Befehl make menuconfig aus, um die Kernelkonfiguration "Statische Binärdatei erstellen (keine gemeinsam genutzten Bibliotheken)" zu aktivieren.

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

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

5. Bauen.

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

6. Installieren. Nach Abschluss der Installation wird im Verzeichnis _install ein Root-Dateisystem erstellt.

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

Gerätetreiber erstellen

1. Erstellen Sie ein Verzeichnis für den Gerätetreiber und wechseln Sie in dieses.

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

2. Erstellen Sie den Quellcode für den Gerätetreiber. (Der folgende Quellcode ist ein Beispielgerätetreiber, der nur geladen / entladen wird.)

   $ 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. Erstellen Sie ein 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. Kompilieren Sie den Gerätetreiber.

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

5. Kopieren Sie den Gerätetreiber in das Verzeichnis Busybox _install.

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

App erstellen

1. Erstellen Sie ein Verzeichnis für Ihre App und wechseln Sie zu diesem.

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

2. Erstellen Sie den Quellcode für Ihre App. (Der folgende Quellcode ist eine Beispielanwendung, die nur Protokolle ausgibt.)

   $ nano app_sample.c
   

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

3. Erstellen Sie ein 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. Kompilieren Sie Ihre App.

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

5. Kopieren Sie die App in das Verzeichnis Busybox _install.

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

Führen Sie QEMU aus

1. Stellen Sie das Root-Dateisystem ab.

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

2. Führen Sie QEMU aus.

   $ 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. Nach Abschluss des Startvorgangs wird die Shell gestartet. Wenn Sie mit dem Befehl ls prüfen, sieht das Root-Dateisystem folgendermaßen aus:

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

4. Laden Sie den Gerätetreiber.

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

5. Führen Sie die App aus.

   / # ./app_sample
   app sample run