Introducción a la Configuración del Entorno de Emulación ARM

Este artículo describe el proceso completo para instalar y configurar QEMU 6.1.0 en un sistema Ubuntu 16.04, estableciendo un entorno robusto para el desarrollo y la emulación de sistemas ARM. Dada la antigüedad de Ubuntu 16.04, es necesario actualizar componentes clave como Python y GCC para cumplir con los requisitos de QEMU 6.1.0. La guía abarca desde la preparación del sistema hasta la compilación de un kernel Linux básico para su ejecución en QEMU.

Prerrequisitos del Sistema y Herramientas Necesarias

El entorno de trabajo utilizado para esta configuración incluye:

• Sistema operativo: Ubuntu 16.04 de 64 bits.
• Emulador: QEMU 6.1.0.
• Compilador: GCC versión 7.5.0.
• Intérprete de Python: Python 3.8.17.

El flujo general de instalación implica:

1. Instalación de bibliotecas de dependencia esenciales.
2. Actualización de Python a la versión 3.8.
3. Configuración de GCC a la versión 7.
4. Instalación de QEMU 6.1.0.
5. Preparación de U-Boot (no cubierto en detalle).
6. Compilación y prueba del kernel Linux.
7. Preparación de BusyBox (no cubierto en detalle).

Preparación del Entorno: Instalación de Dependencias Básicas

Es crucial instalar las bibliotecas y herramientas necesarias antes de proceder con Python y GCC. Esto ayuda a evitar problemas de compilación en etapas posteriores. Ejecute el siguiente comando para instalar las dependencias generales:

sudo apt-get update
sudo apt-get install -y build-essential zlib1g-dev pkg-config libglib2.0-dev \
binutils-dev libboost-all-dev autoconf libtool libssl-dev libpixman-1-dev \
python-capstone virtualenv

En caso de encontrar problemas de compilación como "unknown host os (uname -s linux...)", la reinstalación de Python y GCC después de estas bibliotecas suele ser la solución. Algunos paquetes como libpython2-dev y python-pip podrían omitirse si ya están presentes o no son estrictamente necesarios para QEMU.

Actualización de Python a la Versión 3.8

QEMU 6.1.0 requiere Python 3.6 o superior. Dado que Ubuntu 16.04 incluye Python 2.7.12 y Python 3.5.2, es necesario instalar Python 3.8.17.

1. Descarga del Código Fuente de Python 3.8.17

Puede descargar el paquete desde el sitio oficial de Python o mediante la línea de comandos:

wget https://www.python.org/ftp/python/3.8.17/Python-3.8.17.tgz

2. Creación de un Directorio de Instalación Dedicado

Para facilitar la gestión y posible desinstalación, se recomienda instalar la nueva versión de Python en un directorio separado:

sudo mkdir -p /usr/local/python/python3.8

3. Instalación de Dependencias Adicionales para Python

Antes de compilar Python, asegúrese de tener todas sus dependencias:

sudo apt-get install -y libffi-dev uuid-dev lzma-dev liblzma-dev libncurses5-dev \
libgdbm-dev sqlite3 libsqlite3-dev openssl tcl8.6-dev tk8.6-dev libreadline-dev \
zlib1g-dev bzip2 libbz2-dev libc6-dev libdb-dev libexpat1-dev libgdbm3 \
libncursesw5-dev libpcap-dev libreadline6-dev libsqlite0-dev libssl-dev \
libxml2-dev libxslt1-dev tcl tk-dev xz-utils make

4. Compilación e Instalación de Python 3.8

Descomprima el archivo descargado y proceda con la compilación:

tar -xvf Python-3.8.17.tgz
cd Python-3.8.17
./configure --prefix=/usr/local/python/python3.8 --enable-optimizations
make -j$(nproc)
sudo make altinstall

Nota importante: Utilice make altinstall en lugar de make install para evitar sobrescribir las versiones predeterminadas de Python del sistema, lo que podría causar inestabilidad en Ubuntu.

5. Configuración de Variables de Entorno

Añada la ruta del nuevo binario de Python al PATH de su usuario para que el sistema pueda encontrarlo. Edite su archivo ~/.bashrc:

gedit ~/.bashrc

Añada la siguiente línea al final del archivo:

export PATH=$PATH:/usr/local/python/python3.8/bin

Guarde y cierre el archivo, luego aplique los cambios:

source ~/.bashrc

6. Gestión de Versiones de Python con update-alternatives

Para que python3 apunte a la nueva versión 3.8, utilice el sistema update-alternatives. Esto permite cambiar fácilmente entre diferentes versiones de Python instaladas.

Primero, registre las versiones de Python para el comando python (opcional, si desea cambiar el predeterminado python):

sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 100
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.5 99
sudo update-alternatives --install /usr/bin/python python /usr/local/python/python3.8/bin/python3.8 38

Luego, registre las versiones para el comando python3:

sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.5 100
sudo update-alternatives --install /usr/bin/python3 python3 /usr/local/python/python3.8/bin/python3.8 38

Verifique las opciones disponibles:

sudo update-alternatives --list python
sudo update-alternatives --list python3

Seleccione interactivamente la versión de Python que desea para python3 (elija la opción correspondiente a la versión 3.8):

sudo update-alternatives --config python3

Instalación de GCC 7

QEMU 6.1.0 requiere GCC 7.5.0 o una versión posterior. Para instalar GCC 7 en Ubuntu 16.04, utilice el PPA (Personal Package Archive) oficial de Ubuntu para toolchains:

sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt-get update
sudo apt-get install -y gcc-7 g++-7

Advertencia: Desinstalar la versión predeterminada de GCC de su sistema puede causar problemas, incluso afectando la interfaz gráfica. Es preferible instalar GCC 7 junto con la versión existente y configurarla como la opción predeterminada sin eliminar las anteriores.

Configuración de GCC 7 como Compilador Predeterminado

Utilice update-alternatives para que gcc y g++ apunten a la versión 7:

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 100
sudo update-alternatives --config gcc

sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 100
sudo update-alternatives --config g++

Verifique la versión instalada:

gcc --version
g++ --version

Debería mostrar la versión 7.5.0.

Instalación de QEMU 6.1.0

Una vez configurados Python y GCC, se puede proceder con la instalación de QEMU.

1. Descarga y Extracción de QEMU 6.1.0

Descargue el código fuente de QEMU 6.1.0:

wget https://download.qemu.org/qemu-6.1.0.tar.xz

Cree una estructura de directorios y extraiga el contenido:

mkdir qemu-build-env
cd qemu-build-env
tar xvJf ../qemu-6.1.0.tar.xz
mkdir build
cd build

2. Configuración de la Compilación de QEMU

Desde el directorio build, ejecute el script configure de QEMU. Es común encontrar problemas de dependencia durante esta etapa. A continuación, se detallan algunos errores frecuentes y sus soluciones:

• **Error: Python >= 3.6 es requerido.**Asegúrese de que python3 --version apunte a la versión 3.8. Si no, puede especificar la ruta a Python 3.8 directamente al configurar:

  ../qemu-6.1.0/configure --python=/usr/local/python/python3.8/bin/python3.8
  
  

• **Error: Se requiere al menos GCC v7.5 o Clang v6.0.**Verifique que gcc --version muestre la versión 7.5.0. Si no, reconfigure GCC con update-alternatives como se explicó anteriormente.

• **Error: glib-2.56 gthread-2.0 es requerido para compilar QEMU.**Si su sistema no tiene una versión de GLib suficientemente nueva (Ubuntu 16.04 por defecto tiene una versión anetrior), puede ser necesario compilar GLib 2.56 manualmente. Descargue el código fuente de GLib (por ejemplo, glib-2.56.1.tar.xz), extraiga y compile. Durante la configuración de GLib, puede encontrar errores como "Python interpreter is too old" o "Could not find libmount", que se resuelven de la siguiente manera:

  # Ejemplo de compilación de GLib (si es necesario)
  cd /path/to/glib-2.56.1
  sudo PYTHON="/usr/local/python/python3.8/bin/python3.8" ./autogen.sh --enable-libmount=no
  make -j$(nproc)
  sudo make install
  
  

• **Error: No se pudo detectar Ninja v1.7 o posterior.**Ninja es una herramienta de compilación rápida. Instálela con:

  sudo apt-get install -y ninja-build
  
  

  Si esto falla o la versión no es suficiente, puede intentar compilar Ninja desde su fuente:

  git clone git://github.com/ninja-build/ninja.git && cd ninja
  ./configure.py --bootstrap
  sudo cp ninja /usr/local/bin/
  
  

• **Error: Binario 'pkg-config' no encontrado.**Instale pkg-config si no está presente:

  sudo apt-get install -y pkg-config
  
  

Una vez resueltos los problemas de dependencia, puede ejecutar la configuración de QEMU con las opciones deseadas. Un ejemplo básico es:

../qemu-6.1.0/configure --target-list=arm-softmmu --enable-virtfs --disable-docs --enable-debug --enable-fdt --python=/usr/local/python/python3.8/bin/python3.8

Ajuste --target-list según las arquitecturas que necesite emular. arm-softmmu es fundamental para ARM.

3. Compilación e Instalación de QEMU

Después de una configuración exitosa, compile e instale QEMU:

make -j$(nproc)
sudo make install

4. Verificación de la Instalación de QEMU

Verifique que QEMU se haya instalado correctamente y que pueda emular sistemas ARM:

sudo apt-get install qemu-system-arm # Asegura que los binarios básicos de ARM estén disponibles
qemu-system-arm --version
qemu-system-arm -M help

Primeros Pasos con el Kernel Linux en QEMU

Con QEMU instalado, se puede comenzar a probar la emulación de sistemas ARM. Un paso fundamental es compilar un kernel Linux y ejecutarlo.

1. Compilación de un Kernel Linux para ARM

Asumiendo que tiene un árbol de código fuente de Linux (por ejemplo, la versión 5.x), siga estos pasos para compilar un kernel para la plataforma ARM vexpress-a9:

cd linux-source-5.x/
export KERNEL_ARCH=arm
export ARM_CROSS_COMPILE=arm-linux-gnueabi-
make vexpress_defconfig
make -j$(nproc)
make modules -j$(nproc)
make uImage LOADADDR=0x60000000 # Opcional, para U-Boot
make dtbs

Después de la compilación, los artefactos del kernel se encontrarán en arch/arm/boot/. Copie los archivos necesarios a un directorio de imágenes para facilitar su uso:

mkdir -p ../kernel_images/
cp -f arch/arm/boot/zImage ../kernel_images/
cp -f arch/arm/boot/dts/vexpress-v2p-ca9.dtb ../kernel_images/device.dtb

2. Ejecución del Kernel en QEMU

Puede iniciar el kernel directamente en QEMU para la plataforma vexpress-a9:

qemu-system-arm -M vexpress-a9 -m 512M -kernel ../kernel_images/zImage \
-nographic -append "console=ttyAMA0" -dtb ../kernel_images/device.dtb

Es normal ver un "Kernel panic" al final de la secuencia de arranque, como "VFS: Unable to mount root fs on unknown-block(0,0)". Esto indica que el kernel se ha iniciado con éxito, pero no ha encontrado un sistema de archivos raíz donde cargar el sistema operativo completo. Este es el comportamiento esperado cuando se ejecuta solo el kernel sin un root filesystem.