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
* cdqemu-4.2.0
5.2 Installa i pacchetti dipendenti prima di configurare QEMU
# apt installa zlib1g-dev
# APT Installa libglib2.0-0 libglib2.0-dev
# APT Installa libsdl1.2-dev
# APT Installa 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 Installa 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
#mkdirrootfs
# 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-
# vimconfig.mk
ARCO = braccio
# make vexpress_ca9x4_defconfig, errore
Necessità: sudo apt install bison
sudo apt installa 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 installa u-boots u-boot
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/rete/interfacce
| 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 installa 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 /esportazioni
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.