Utilice QEMU para crear un entorno de desarrollo de BIOS y kernel

Descripción

Este artículo crea principalmente un sistema completo, que incluye el BIOS descrito anteriormente y GRUB, el kernel y el sistema de archivos que se describen aquí.

 

Descarga y compilación del kernel

Dado que el entorno utilizado es Ubuntu 18.04, descargar y compilar el kernel es relativamente sencillo. La primera es descargar el kernel, necesita usar el siguiente comando:

sudo apt install linux-source

El proceso de descarga es el siguiente:

El código descargado se puede encontrar en el directorio / usr / src:

Lo descargamos y lo colocamos en el directorio especificado:

tar -xjvf linux-source-4.15.0.tar.bz2 -C /home/jw/code/

La -C se utiliza para especificar la carpeta de destino para la descompresión, de modo que el código fuente de Linux se pueda encontrar en el directorio especificado y utilizar. Luego ingrese al directorio /home/jw/code/linux-source-4.15.0 y comience a compilar. Antes de compilar, debe crear un archivo .config. Para su comodidad, utilice la configuración predeterminada directamente (a continuación, se modificará de acuerdo con la situación real):

make defconfig

Después de eso, puede usar make para compilar, pero es posible que se informe un error durante el proceso de compilación, porque algunas bibliotecas dependientes no existen, simplemente instálelas, debe instalarlas aquí (diferentes versiones de Ubuntu pueden requerir la instalación de diferentes bibliotecas, por favor instale de acuerdo a la situación real) :

sudo apt install libelf-dev
sudo apt install libssl-dev

Después de una compilación exitosa, puede encontrar el archivo del kernel que necesitamos en ~ / code / linux-source-4.15.0 / arch / x86 / boot:

Al final de la compilación, tenga cuidado de no instalar el kernel usando make install, porque no estamos instalando este kernel en el compilador, pero necesitamos usar la máquina virtual (QEMU) para ejecutar el kernel, es decir, bzImage se usará para el sistema de inicio de QEMU.

 

COMIDA

Puede descargar GRUB a través de git. Aquí se usa GRUB 2.02. El comando es el siguiente:

git clone https://gitee.com/jiangwei0512/grub-2.02

Una vez completada la descarga, ingrese al directorio y primero ejecute ./configure:

./configure --target=x86_64 --with-platform=efi

Aquí se usan varios parámetros, entre los cuales el parámetro --target se usa para especificar la plataforma correspondiente, la plataforma x86 de 64 bits se especifica aquí y el otro parámetro --with-platform se usa para especificar la UEFI. Pero habrá un error al configurar, porque hay algunas bibliotecas que deben instalarse:

sudo apt install flex bison

Después de que configure se ejecute correctamente, puede ejecutar el comando make. Si no hay un error alcocal-1.15 al compilar, puede instalar automake y ejecutar autoreconf -i -f para resolverlo, pero hay una manera más fácil de tocar todos los archivos. Después de que la creación sea exitosa, use el siguiente comando para generar el binario de GRUB:

./grub-mkimage -p . -d ./grub-core/ -O x86_64-efi -o bootx64.efi XXX

Explique brevemente los siguientes parámetros: -p especifica el directorio donde se ubican grub.cfg, los módulos independientes y otros archivos; -d especifica la ubicación de la imagen y el módulo que acabamos de compilar, porque son lo que necesitamos, no ya existentes en el sistema ; -O especifica el formato binario, necesitamos el formato UEFI bajo la plataforma x86; -o se usa para especificar el nombre del archivo de salida; el último XXX es el módulo GRUB, que es el archivo * .module en el directorio grub-core:

Los módulos utilizados aquí se especifican de la siguiente manera:

./grub-mkimage -p . -d ./grub-core/ -O x86_64-efi -o bootx64.efi boot linux part_msdos part_gpt fat normal serial efi_gop minicmd

El binario finalmente compilado es bootx64.efi (el nombre se usa porque es el nombre del cargador de sistema operativo universal en UEFI), que se usará más adelante. Además, GRUB tiene un archivo de configuración correspondiente llamado grub.cfg, y su contenido específico se presentará más adelante. GRUB y sus archivos de configuración se utilizarán para el sistema de arranque QEMU.

 

caja ocupada

Puede descargar el código fuente de busybox en https://busybox.net/downloads/ , aquí está la versión 1.29.1, descomprímalo en el directorio especificado:

tar -xjvf busybox-1.29.2.tar.bz2 -C /home/jw/code

Luego ingrese al directorio para la configuración (ejecute make menuconfig en el directorio del código fuente):

Lo que debemos configurar es seleccionar la compilación estática, y la ubicación está en Configuración. Tenga en cuenta que para usar menuconfig, es posible que sea necesario instalar bibliotecas adicionales (libncurses5-dev). Después de la configuración, puede usar make para compilar. Una vez completada la compilación, instale mediante el comando make install:

make install

Después de ejecutar el comando anterior, se generará un nuevo directorio llamado _install en el directorio actual.Necesitamos estos archivos para generar initramfs para que los use el kernel.Los archivos correspondientes son los siguientes:

El método para crear initramfs, el más simple se usa aquí, y el comando correspondiente es el siguiente:

mkdir initramfs
cd initramfs
mkdir dev proc sys
cp ../_install/* ./ -ra
sudo cp -a /dev/{null,console,tty1,tty2,tty3,tty4} dev/
touch init
chmod a+x init

El contenido de init es el siguiente:

mount -t proc none /proc
mount -t sysfs none /sys
mdev -s
exec /sbin/init

Finalmente, empaquételo a través del siguiente comando:

find . -print0 | cpio --null -ov --format=newc | gzip -9 > ../initramfs.cpio.gz

initramfs.cpio.gz es el archivo que finalmente obtenemos, se usará para el sistema de arranque QEMU.

 

Sistema de arranque QEMU

El primero es crear un disco duro utilizado por QEMU (en realidad, solo un archivo) y formatearlo en formato FAT (porque UEFI solo reconoce este tipo de forma predeterminada):

dd if=/dev/zero of=disk.img bs=1M count=32
mkfs.fat disk.img

El tamaño del disk.img creado aquí es 32 M. Este no es un requisito estricto, siempre que sea mayor que la suma de los tamaños del kernel, initramfs, GRUB, etc. La siguiente operación es montar disk.img y colocar los archivos mencionados anteriormente en disk.img:

sudo mount disk.img tmp
sudo mkdir tmp/EFI tmp/EFI/BOOT
sudo cp bootx64.efi grub.cfg tmp/EFI/BOOT
sudo cp bzImage initramfs.cpio.gz tmp

Primero debemos decir que disk.img está montado en un directorio (aquí es tmp), y luego los archivos se colocan en él. Se debe prestar especial atención a GRUB y sus archivos de configuración, que deben colocarse en el directorio / EFI / BOOT, el archivo final como sigue:

En este punto, hemos puesto los archivos requeridos en disk.img, que se pueden usar como un disco duro QEMU. Las instrucciones correspondientes son las siguientes:

qemu-system-x86_64 -bios OVMF.fd -hda disk.img -m 512M

Los parámetros QEMU aquí son los siguientes: -bios especifica el nombre del BIOS, aquí está OVMF.fd; -hda especifica el disco duro, aquí está disk.img; -m especifica el tamaño de memoria utilizado por la máquina virtual. El estado final después del inicio es el siguiente:

En este punto, se ha iniciado un kernel básico y podemos confiar en el sistema para depurarlo más tarde.