Pannello di controllo

Emulazione di sistemi Linux embedded con QEMU

Emulazione di sistemi Linux embedded con QEMU

 

1. introduzione

Lo sviluppo di software integrato si basa su dispositivi hardware integrati, come schede di sviluppo, dispositivi di moduli esterni, ecc., ma se il lavoro di debug non ha nulla a che fare con le periferiche, solo il debug del kernel può essere simulato utilizzando QEMU senza acquistare hardware.

È disponibile per host Linux e Windows e target PowerPC, ARM, MIPS e SPARC emulati. QEMU adotta l'approccio di fornire un livello di traduzione minimo tra l'host e il processore di destinazione. Il processore host è quello che esegue l'emulatore e il processore di destinazione è ciò che viene emulato.

Quella che segue è un'introduzione dettagliata al processo di configurazione dell'ambiente di sviluppo QEMU.

 

2. Ambiente

2.1 Ambiente utilizzato

* Ubuntu-18.04.1

O:

* PC: Windows 10

* Macchina virtuale:VirtualBox-5.18

* Sistema operativo virtuale:Ubuntu-18.04.1

* Scheda di sviluppo simulata: vexpress

2.2 Strumenti utilizzati durante la configurazione dell'ambiente

* qemu-4.2.0

* linux-4.14.172 (kernel di Linux)

* u-boot-2017.05

* Busybox-1.31.1

* arm-linux-gnueabi-gcc

Metti tutti i file correlati in /home/joe/qemu

3. Installa strumenti di compilazione incrociata

# sudo apt install gcc-arm-linux-gnueabi

 

Controlla se l'installazione è andata a buon fine

$ arm-linux-gnueabi-gcc -v

Utilizzo delle specifiche integrate.

COLLECT_GCC=arm-linux-gnueabi-gcc

COLLECT_LTO_WRAPPER=/usr/lib/gcc-cross/arm-linux-gnueabi/7/lto-wrapper

Obiettivo: arm-linux-gnueabi

Configurato con: ../src/configure -v –with-pkgversion='Ubuntu/Linaro 7.5.0-3ubuntu1~18.04′–with-bugurl=file:///usr

Modello filettatura: posix

gcc versione 7.5.0 (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04)

 

4. Configura e compila il kernel Linux

4.1 Scarica il kernel Linux

Scarica la versione del kernel richiesta da www.kernel.org.

Qui scarico l'ultima versione del kernel supportata a lungo termine linux-4.4.157

wget https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.4.157.tar.xz  nella directory /qemu

4.2 Decomprimere il kernel Linux

# tar xvJf linux-4.4.157.tar.xz

4.3 Compila il kernel Linux

// Inserisci la directory del file sorgente del kernel

# cd linux-4.4.157

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

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

Se l'esecuzione di menuconfig mostra che il pacchetto ncurses è mancante, esegui semplicemente il comando seguente per installarlo)

$ sudo apt-get install libncurses5-dev

Entra nella configurazione del menu ed effettua le seguenti impostazioni

Compila con cross toolchain

Dopo aver compilato con successo, Genera un file immagine del kernel nella directory

arch/arm/boot, zImage e dtb possono essere copiati in una cartella separata per un comodo utilizzo

 

5. Installa gli strumenti QEMU

5.1 Installa QEMU

* wget https://download.qemu.org/qemu-4.2.0.tar.xz

* tar xvJf qemu-4.2.0.tar.xz

* cd qemu-4.2.0

5.2 Installa i pacchetti dipendenti prima di configurare QEMU

# apt install zlib1g-dev
# apt install libglib2.0-0 libglib2.0-dev
# apt install libsdl1.2-dev
# apt install libpixman-1-dev libfdt-dev

Per evitare che i file diventino disordinati dopo la compilazione, creare la directory del builder come percorso di destinazione intermedio per la compilazione.

Configura, compila e installa QEMU.

5.3 Configurare QEMU per supportare tutte le schede sotto l'architettura del braccio

# ../configure –target-list=arm-softmmu –audio-drv-list=

Se pixman non è presente quando viene visualizzato il seguente messaggio,

usa sudo apt-get install libpixman-1-dev per installarlo.

5.4 Visualizza la versione QEMU

5.5 Visualizza le schede di sviluppo supportate da QEMU

5.6 Esegui QEMU

# qemu-system-arm -M vexpress-a9 -m 512M -kernel ./zImage -dtb ./vexpress-v2p-ca9.dtb -nographic -append “console=ttyAMA0”

OR:

$ pwd

/casa/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”

Per testare meglio e avviare qemu, puoi creare lo script di avvio start.sh e dare allo script il permesso di eseguire chmod +x start.sh

 

#! / Bin / bash

 

braccio-sistema-qemu \

-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 \

-nografico \

-aggiungi “console=ttyAMA0”

 

6. Crea un file system root

Usa busybox per creare un semplice file system root.

6.1 Scarica lo strumento busybox

Scarica busybox da https://busybox.net/downloads/

# wget https://busybox.net/downloads/busybox-1.31.1.tar.bz2

# tar xjvf busybox-1.31.1.tar.bz2

# cd busybox-1.31.1

# fai defconfig

# make CROSS_COMPILE=arm-linux-gnueabi-

# make install CROSS_COMPILE=arm-linux-gnueabi-

Vengono richieste le seguenti informazioni, che indicano che l'installazione è riuscita.

Al termine dell'installazione, il file di destinazione generato viene impostato per impostazione predefinita nella directory ./_install.

 

6.2 Generare il file system di root

6.2.1 compilazione e installazione di busybox

# mkdir rootfs

# sudo cp -r _install/* rootfs/

6.2.2 Aggiungere la libreria glibc, aggiungere il caricatore e la libreria dinamica nel file system di root

# sudo cp -r _install/* rootfs/

# sudo cp -p /usr/arm-linux-gnueabi/lib/* rootfs/lib/

6.2.3 Creare 4 dispositivi terminali tty (c sta per dispositivo a caratteri, 4 è il numero di dispositivo principale e 1~4 sono rispettivamente i numeri di dispositivo secondari)

 

6.3 Crea l'immagine del file system della scheda SD

6.3.1 Generare un'immagine della scheda SD vuota

# dd if=/dev/zero of=rootfs.ext3 bs=1M conteggio=32

6.3.2 Formatta la scheda SD come file system exts

# mkfs.ext3 rootfs.ext3

6.3.3 Masterizza rootfs su scheda SD

# sudo mount -t ext3 rootfs.ext3 /mnt -o loop

# sudo cp -rf rootfs/* /mnt/

# sudo smonta /mnt

 

7. Verifica

7.1 Avvia Qemù

Esegui il seguente comando per testare, controlla se il kernel compilato può essere eseguito correttamente

# sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel ~/qemu/zImage –dtb ~/qemu/vexpress-v2p-ca9.dtb -nographic -append “console=ttyAMA0”

Oppure usando Script:

 

Nel test di cui sopra, il kernel segnalerà il panico, suggerendo che ci manca il file system di root.

Il problema di cui sopra è dovuto allo strumento busybox generato nell'ambiente x86.

Abbiamo usato make install durante l'installazione di busybox, quindi dovresti usare

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

 

Lo strumento di compilazione genera lo strumento busybox utilizzato dalla piattaforma braccio

# file rootfs/bin/busybox

rootfs/bin/busybox: eseguibile ELF LSB a 32 bit, ARM, EABI5 versione 1 (SYSV), linkato dinamicamente, interprete /lib/ld-, per GNU/Linux 3.2.0, BuildID[sha1]=cbcd33b8d6c946cb19408a5e8e714de554c87f52, strippato

 

7.2 Verificare di nuovo

Ora, Qemu ha avviato il kernel Linux e montato correttamente il file system e può interagire con il sistema con semplici funzioni tramite il terminale seriale. Il problema di non essere in grado di eseguire /etc/init.d/rcS nel processo di stampa, devi solo aggiungere il file /etc/init.d/rcS. Il contenuto del file può essere un'istruzione prompt.

 

7.3 Esci da QEMU

Due modi per uscire da qemu

* In un altro ingresso terminale: kill all qemu-system-arm

* Nell'input Qemu: Ctrl+ A; X

QEMU: terminato

 

8. Avvia il kernel Linux tramite u-boot

I sistemi embedded di solito includono: u-boot, kernel, rootfs e appfs. La relazione posizionale di queste parti sulla scheda di sviluppo ARM mostrata nella figura seguente

 

Boot loader Parametri di avvio nocciolo rootfs App

 

I rootf possono essere eseguiti su scheda o PC

 

8.1 Preparare l'U-boot

8.1.1 Scarica u-boot

http://ftp.denx.de/pub/u-boot/, usiamo: u-boot-2021.01.tar.bz2

# tar -jxvf u-boot-2018.09.tar.bz2

8.1.2 Compila u-boot

# vim Makefile

CROSS_COMPILE = arm-linux-gnueabi-

# vim config.mk

ARCO = braccio

# make vexpress_ca9x4_defconfig, errore

Necessità: sudo apt install bison

sudo apt install flex

quindi: # make -j4 errore

Necessità: esporta CROSS_COMPILE=arm-linux-gnueabi-

esporta ARCH=braccio

di nuovo: # make vexpress_ca9x4_defconfig

# make -j4

 

 8.1.3 Prova, avvia u-boot

$ sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel u-boot-2021.01/u-boot –nografico

 

8.2 Compilazione della configurazione del kernel

Usa u-boot per avviare l'immagine del kernel:

Necessità di compilare il kernel in formato uImage,

È necessario specificare l'indirizzo di caricamento di uImage in memoria

Specificare durante la compilazione del kernel: make LOADADDR=? uImmagine -j4

 

# cd /home/joe/qemu/linux-4.4.157

# make LOADADDR=0x60003000 uImage -j4

 

Al termine della compilazione di u-boot, verrà generato un file mkimage nella cartella degli strumenti, copiare questo file nella cartella bin nella directory del compilatore incrociato.

$ cd qemu/linux-4.4.157

Errore:

$ sudo apt install u-boot-tools

Ottieni uImage

9. Impostazioni delle funzioni di rete QEMU

Quando la macchina virtuale Qemu si avvia su u-boot, uImage deve essere caricato nella memoria e uImage può essere scaricato all'indirizzo specificato nella memoria tramite il server TFTP.

9.1 Verificare se il kernel host supporta il modulo tun/tap

// Installa i due strumenti da cui dipende la rete in bridge

# sudo apt install uml-utilities bridge-utils

Crea il file del dispositivo tun: /dev/net/tun (generalmente creato automaticamente)

Modificare /etc/network/interfaces (configurare la rete, riavviare per avere effetto)

# sudo vim /etc/network/interfaces

auto loiface lo inet loopbackauto enp0s3 // nome della rete virtuale cardauto br0iface br0 inet dhcpbridge_ports enp0s3

 

Non riavviare MAI

# riavvio

Quindi controlla l'ambiente di rete di Qemu

La porta di rete virtuale br0 è la porta di rete per la comunicazione tra la macchina virtuale Qemu e l'host Linux.

 

10. Installa il server TFTP

Crea un server TFTP per scaricare uImage nella memoria all'avvio di uImage per la scheda di sviluppo della simulazione Qemu

 

10.1 Installa lo strumento tftp

 

$ apt-get install tftp-hpa tftpd-hpa xinetd

 

10.2 Modificare il file di configurazione e impostare la directory del server TFTP

# sudo vim /etc/default/tftpd-hpa

......

TFTP_DIRECTORY="/home/joe/tftpboot"

......

10.3 Creare una directory tftp sull'host Linux

# mkdir /home/joe/tftpboot

# chmod 777 /home/joe/tftpboot

 

10.4 Riavviare il servizio tftp

# sudo /etc/init.d/tftpd-hpa riavvio

 

10.5 Impostare i parametri di avvio del kernel in u-boot

copia uImage e cexpress-v2p-ca9.dtb su tftpboot

Avvia Qemu per verificare

 

$ 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. ext3

 

Ora, la directory rootfs è un semplice file system root, che può essere trasformato in un file mirror e il file mirror può essere masterizzato sulla scheda di sviluppo, oppure il kernel Linux può essere avviato da u-boot in Qemu e montato sul file speculare. Può anche essere impostato per l'avvio tramite il file system di rete NFS.

 

11. Montare il file system NFS

11.1 Installare e configurare il servizio NFS

11.1.1 Installa

$ sudo apt install nfs-kernel-server

 

11.1.2 Configurazione

$ sudo mkdir /home/joe/qemu/rootfs

$ sudo chown nessuno:nogroup /home/joe/qemu/rootfs

$ sudo chmod 777 /home/joe/qemu/rootfs

$ sudo nano /etc/exports

Aggiungi: /home/joe/qemu/rootfs *(rw,sync,no_root_squash)

 

Riavvia il server nfs:

$ sudo /etc/init.d/nfs-kernel-server restart

Oppure: $systemctl riavvia nfs-kernel-server

 

Controlla se la directory condivisa NFS è stata creata

$ sudo showmount – e

Quando si utilizza il file system di rete NFS, l'host Linux deve chiudere il firewall di sistema, altrimenti si verificheranno anomalie durante l'esecuzione del sistema.

 

Conclusione

Si spera che, con l'aiuto di questo blog, tu sappia di più su QEMU. Tutte le tecniche mostrate sopra sono state utilizzate in varie presentazioni al nostro programma. Non esiste un unico modo fisso per emulare con QEMU. Esplora diverse tecniche e scopri cosa funziona per te. Familiarizza con la conoscenza e rimarrai sorpreso di come può aiutarti in modi inaspettati.

Contattaci