Consejo Regulador

Emulación de sistemas Linux integrados con QEMU

Emulación de sistemas Linux integrados con QEMU

 

1. Introducción

El desarrollo de software integrado se basa en dispositivos de hardware integrados, como placas de desarrollo, dispositivos de módulos externos, etc., pero si el trabajo de depuración no tiene nada que ver con los periféricos, solo se puede simular la depuración del kernel utilizando QEMU sin comprar hardware.

Está disponible para hosts Linux y Windows y para destinos PowerPC, ARM, MIPS y SPARC emulados. QEMU adopta el enfoque de proporcionar una capa de traducción mínima entre el host y el procesador de destino. El procesador host es el que ejecuta el emulador y el procesador de destino es el que se está emulando.

La siguiente es una introducción detallada al proceso de configuración del entorno de desarrollo QEMU.

 

2. Medio Ambiente

2.1 Entorno utilizado

* Ubuntu-18.04.1

O:

* PC: Windows10

* Máquina virtual: VirtualBox-5.18

* Sistema operativo virtual: Ubuntu-18.04.1

* Tablero de desarrollo simulado: vexpres

2.2 Herramientas utilizadas al configurar el entorno

* qemu-4.2.0

* linux-4.14.172 (núcleo de Linux)

* u-boot-2017.05

* caja ocupada-1.31.1

* brazo-linux-gnueabi-gcc

Coloque todos los archivos relacionados en /home/joe/qemu

3. Instalar herramientas de compilación cruzada

# sudo apt install gcc-arm-linux-gnueabi

 

Verifique si la instalación es exitosa

$ brazo-linux-gnueabi-gcc -v

Utilizando inspecs incorporados.

COLLECT_GCC = arm-linux-gnueabi-gcc

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

Destino: arm-linux-gnueabi

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

Modelo de hilo: posix

gcc versión 7.5.0 (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04)

 

4. Configurar y compilar el kernel de Linux

4.1 Descargar el núcleo de Linux

Descargue la versión del kernel requerida de www.kernel.org.

Aquí descargo la versión de kernel compatible a largo plazo relativamente más reciente linux-4.4.157

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

4.2 Descomprime el kernel de Linux

# tar xvJf linux-4.4.157.tar.xz

4.3 Compilar el kernel de Linux

// Ingrese el directorio del archivo fuente del kernel

# cd linux-4.4.157

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

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

Si ejecutar menuconfig muestra que falta el paquete ncurses, simplemente ejecute el siguiente comando para instalarlo)

$ sudo apt-get install libncurses5-dev

Ingrese al menú de configuración y realice los siguientes ajustes

Compilar con cadena de herramientas cruzada

Después de una compilación exitosa, genere un archivo de imagen del kernel en el directorio

arch/arm/boot, zImage y dtb se pueden copiar en una carpeta separada para un uso conveniente

 

5. Instalar herramientas QEMU

5.1 Instalar 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 Instalar paquetes dependientes antes de configurar QEMU

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

Para evitar que los archivos se desordenen después de la compilación, cree el directorio del generador como la ruta de destino intermedia para la compilación.

Configurar, compilar e instalar QEMU.

5.3 Configure QEMU para admitir todas las placas bajo la arquitectura del brazo

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

Si falta pixman cuando aparece el siguiente mensaje,

use sudo apt-get install libpixman-1-dev para instalarlo.

5.4 Ver versión QEMU

5.5 Ver placas de desarrollo compatibles con QEMU

5.6 Ejecutar QEMU

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

O:

$ pwd

/inicio/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 “consola=ttyAMA0”

Para realizar mejores pruebas e iniciar qemu, puede crear el script de inicio start.sh y otorgar permiso al script para ejecutar chmod +x start.sh

 

#! / Bin / bash

 

qemu-sistema-brazo \

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

-nográfico \

-agregar "consola = ttyAMA0"

 

6. Cree un sistema de archivos raíz

Use busybox para crear un sistema de archivos raíz simple.

6.1 Descargar la herramienta busybox

Descarga busybox desde https://busybox.net/downloads/

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

# tar xjvf busybox-1.31.1.tar.bz2

# cd caja ocupada-1.31.1

# hacer defconfig

# hacer CROSS_COMPILE=arm-linux-gnueabi-

# hacer instalar CROSS_COMPILE=arm-linux-gnueabi-

Se solicita la siguiente información, lo que indica que la instalación se realizó correctamente.

Una vez completada la instalación, el archivo de destino generado se establece de manera predeterminada en el directorio ./_install.

 

6.2 Generar sistema de archivos raíz

6.2.1 compilar e instalar busybox

# mkdir rootfs

# sudo cp -r _install/* rootfs/

6.2.2 Agregar biblioteca glibc, agregar cargador y biblioteca dinámica en el sistema de archivos raíz

# sudo cp -r _install/* rootfs/

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

6.2.3 Cree 4 dispositivos de terminal tty (c significa dispositivo de caracteres, 4 es el número de dispositivo principal y 1~4 son los números de dispositivo menor, respectivamente)

 

6.3 Hacer una imagen del sistema de archivos de la tarjeta SD

6.3.1 Generar una imagen de tarjeta SD vacía

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

6.3.2 Formatear la tarjeta SD como sistema de archivos exts

# mkfs.ext3 rootfs.ext3

6.3.3 Grabar rootfs en la tarjeta SD

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

# sudo cp -rf rootfs/* /mnt/

# sudo cantidad /mnt

 

7. Verificar

7.1 Iniciar Qemu

Ejecute el siguiente comando para probar, verifique si el kernel compilado se puede ejecutar correctamente

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

O usando Script:

 

En la prueba anterior, el kernel informará pánico, lo que sugiere que carecemos del sistema de archivos raíz.

El problema anterior se debe a la herramienta busybox generada en el entorno x86.

Usamos make install cuando instalamos busybox, por lo que debe usar

hacer ARCH=armar CROSS_COMPILE=armar-linux-gnueabi-instalar

 

La herramienta de compilación genera la herramienta busybox utilizada por la plataforma arm

# archivo rootfs/bin/busybox

rootfs/bin/busybox: ELF ejecutable LSB de 32 bits, ARM, EABI5 versión 1 (SYSV), enlazado dinámicamente, intérprete /lib/ld-, para GNU/Linux 3.2.0, BuildID[sha1]=cbcd33b8d6c946cb19408a5e8e714de554c87f52, eliminado

 

7.2 Verificar de nuevo

Ahora, Qemu inició el kernel de Linux y montó el sistema de archivos con éxito, y puede interactuar con el sistema con funciones simples a través de la terminal serial. El problema de no poder ejecutar /etc/init.d/rcS en el proceso de impresión, solo necesita agregar el archivo /etc/init.d/rcS. El contenido del archivo puede ser una pronta declaración.

 

7.3 Salir de QEMU

Dos formas de salir de qemu

* En otra entrada de terminal: matar a todos qemu-system-arm

* En la entrada de Qemu: Ctrl+ A; X

QEMU: Terminado

 

8. Inicie el kernel de Linux a través de u-boot

El sistema integrado generalmente incluye: u-boot, kernel, rootfs y appfs. La relación de posición de estas piezas en la placa de desarrollo ARM que se muestra en la siguiente figura

 

Cargador de arranque Parámetros de arranque Núcleo raíces aplicaciones

 

Rootfs puede ejecutarse en placa o PC

 

8.1 Preparar arranque en U

8.1.1 Descargar uboot

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

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

8.1.2 Compilar u-boot

# vim Makefile

CROSS_COMPILE = arm-linux-gnueabi-

#vimconfig.mk

ARCO = brazo

# hacer vexpress_ca9x4_defconfig, error

Necesidad: sudo apt install bisonte

sudo apt instalar flex

entonces: # make -j4 error

Necesita: exportar CROSS_COMPILE = arm-linux-gnueabi-

exportar ARCH = armar

de nuevo: # hacer vexpress_ca9x4_defconfig

# hacer -j4

 

 8.1.3 Prueba, iniciar u-boot

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

 

8.2 Compilación de la configuración del kernel

Use u-boot para iniciar la imagen del kernel:

Necesita compilar el kernel en formato uImage,

Necesidad de especificar la dirección de carga de uImage en la memoria

Especifique al compilar el kernel: make LOADADDR =? uImage -j4

 

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

# hacer LOADADDR=0x60003000 uImage -j4

 

Una vez finalizada la compilación de u-boot, se generará un archivo mkimage en la carpeta de herramientas, copie este archivo en la carpeta bin en el directorio del compilador cruzado.

$ cd qemu/linux-4.4.157

Error:

$ sudo apt install u-boot-herramientas

Obtener uImagen

9. Configuración de la función de red QEMU

Cuando la máquina virtual Qemu se inicia en u-boot, uImage debe cargarse en la memoria y uImage puede descargarse a la dirección especificada en la memoria a través del servidor TFTP.

9.1 Comprobar si el kernel del host es compatible con el módulo tun/tap

// Instale las dos herramientas de las que depende la red puenteada

# sudo apt install uml-utilities bridge-utils

Crear archivo de dispositivo tun: /dev/net/tun (generalmente se crea automáticamente)

Modifique /etc/network/interfaces (configure la red, reinicie para que surta efecto)

# sudo vim /etc/network/interfaces

auto loiface lo inet loopbackauto enp0s3 // nombre de la tarjeta de red virtualauto br0iface br0 inet dhcpbridge_ports enp0s3

 

NUNCA reiniciar

# reiniciar

Luego verifique el entorno de red de Qemu

El puerto de red virtual br0 es el puerto de red para la comunicación entre la máquina virtual Qemu y el host Linux.

 

10. Instalar servidor TFTP

Cree un servidor TFTP para descargar uImage a la memoria al iniciar uImage para la placa de desarrollo de simulación Qemu

 

10.1 Instalar la herramienta tftp

 

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

 

10.2 Modificar el archivo de configuración y configurar el directorio del servidor TFTP

# sudo vim /etc/default/tftpd-hpa

......

TFTP_DIRECTORY=”/inicio/joe/tftpboot”

......

10.3 Crear un directorio tftp en el host Linux

# mkdir / inicio / joe / tftpboot

# chmod 777 / home / joe / tftpboot

 

10.4 Reinicie el servicio tftp

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

 

10.5 Establecer los parámetros de inicio del kernel en u-boot

copie uImage y cexpress-v2p-ca9.dtb a tftpboot

Inicie Qemu para verificar

 

$ 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

 

Ahora, el directorio rootfs es un sistema de archivos raíz simple, que se puede convertir en un archivo espejo, y el archivo espejo se puede grabar en la placa de desarrollo, o el kernel de Linux puede iniciarse mediante u-boot en Qemu y montarse en el archivo espejo. También se puede configurar para que arranque a través del sistema de archivos de red NFS.

 

11. Monte el sistema de archivos NFS

11.1 Instalar y configurar el servicio NFS

Instalación de 11.1.1

$ sudo apt install nfs-kernel-servidor

 

11.1.2 Configuración

$ sudo mkdir /home/joe/qemu/rootfs

$ sudo chown nadie: ningún grupo /home/joe/qemu/rootfs

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

$ sudo nano /etc/exportaciones

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

 

Reinicie el servidor nfs:

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

O: $systemctl reiniciar nfs-kernel-server

 

Compruebe si se crea el directorio compartido NFS

$ sudo showmount –e

Cuando se utiliza el sistema de archivos de red NFS, el host de Linux debe cerrar el firewall del sistema; de lo contrario, se producirán anomalías cuando el sistema se esté ejecutando.

 

Conclusión

Con suerte, con la ayuda de este blog, conocerá más sobre QEMU. Todas las técnicas demostradas anteriormente se utilizaron en varias presentaciones a nuestro programa. No hay una forma única y fija de emular con QEMU. Explore diferentes técnicas y vea qué funciona para usted. Familiarícese con el conocimiento y se sorprenderá de cómo puede ayudarle de formas inesperadas.

Contáctenos