Historias de Cronopios

QEMU es un conocido emulador que permite ejecutar otros sistemas (como Hasefroch u otras distribuciones de GNU/Linux) en una ventana. Desafortunadamente, el sistema emulado funcionará unas diez veces más lento que una instalación nativa. kqemu es un acelerador de QEMU, un módulo para el núcleo escrito por el mismo autor de QEMU, que acelera notablemente el funcionamiento de éste (multiplica la velocidad por cinco) si emulamos un x86 en un x86 (pues qemu permite ejecutar binarios compilados para una arquitectura sobre otra distinta).

Debe advertirse que, por el momento, kqemu es gratuito, pero no libre (el autor está dispuesto a liberarlo si alguien le da dinero para compensar el tiempo invertido en él):

As a supporter of open source, the author accepts to open source the QEMU Accelerator Technology provided a company invests enough money to support the project and to recompense the author from the potential loss of revenue. Interested companies can look at the roadmap and make suggestions to the author.

(Cita de http://fabrice.bellard.free.fr/qemu/qemu-accel.html)

Ya se está desarrollando un acelerador libre, llamado qvm86, pero parece estar todavía en estado pre-alpha y no lo he probado.

Algunas alternativas a QEMU son Xen y Bochs (quizás también OpenVZ, que todavía no he mirado, pero me parece que es más comparable a Linux-VServer o User Mode Linux (UML)). Como opción privativa estaría VMWare.

Instalacion de QEMU

Para emplear el módulo acelerador no podemos instalar QEMU desde el paquete .deb binario, sino que debemos compilarlo todo nosotros mismos. Empezamos instalando las dependencias y programas necesarios para compilar:
aptitude install libsdl1.2-dev zlib1g-dev linux-headers-`uname -r` build-esential checkinstall nasm vgabios bochsbios

A continuación descargamos el código fuente de la última versión de QEMU de

http://fabrice.bellard.free.fr/qemu/download.html

y lo descomprimimos en /usr/local/src.

Parece ser que QEMU da problemas cuando se compila con gcc 4.x, así que debe compilarse con gcc 3.x:
# cd /usr/local/src/qemu-0.8.2
# ./configure --cc=gcc-3.4 --host-cc=gcc-3.4
# make
# checkinstall (para instalar usando un paquete debian, o bien make install)

Para evitar que nuestro paquete pueda ser sobreescrito al hacer un aptitude upgrade perdiendo así la aceleración, bloqueamos el paquete con
# echo "qemu hold" | dpkg --set-selections

Instalación de kqemu

Ahora descargamos de la misma página el tarball del módulo acelerador de QEMU (kqemu), y lo descomprimimos. El módulo kqemu debe compilarse con la misma versión del compilador que el núcleo que usamos (se puede ver con cat /proc/version), y para el mismo procesador, u obtendremos un error similar a
FATAL: Error inserting kqemu (/lib/modules/2.6.15-26-686/misc/kqemu.ko): Invalid module format
En nuestro caso, observamos que el núcleo ha sido compilado con la versión de gcc que usa por omisión el sistema, así que no nos preocupamos de ello.

Pensaba que con las cabeceras del núcleo linux sería suficiente, pero me encontré con este error:
# ./configure
Could not find kernel includes in /lib/modules or /usr/src/linux - cannot build the kqemu module
Source path /usr/local/src/kqemu-1.3.0pre9
C compiler gcc
Host C compiler gcc
make make
host CPU i386
./configure: line 344: test: =: se esperaba operador unario

Así que instalé el paquete del código fuente del núcleo, lo descomprimí, creé un enlace simbólico «linux» al directorio del código fuente, y copié en él el fichero de configuración.
# aptitude install linux-source-2.6.15
# cd /usr/src/
# tar jxvf linux-source-2.6.15.tar.bz2
# ln -s linux-source-2.6.15 linux
# cp /boot/config-2.6.15-26-686 linux/.config

Pero entonces pasé a encontrarme con este otro error al intentar hacer el make:
WARNING: Symbol version dump /usr/src/linux-source-2.6.15/Module.symvers
is missing; modules will have no dependencies and modversions.
y otros indicando que no encontraba autoconf.h, etc.

Finalmente lo resolví con
# cd /usr/src/linux
# make
Si quisiéramos aprovechar para personalizar nuestro núcleo, sería buena idea editar el Makefile antes de compilar, y cambiar la variable EXTRAVERSION.

Finalmente pude ya compilar kqemu:
# cd /usr/local/src/kqemu-1.3.0pre9/
# ./configure
# make

Durante el make aparece una advertencia:
Warning: could not find /usr/local/src/kqemu-1.3.0pre9/.kqemu-mod.o.cmd for /usr/local/src/kqemu-1.3.0pre9/kqemu-mod.o
pero podemos prescindir de ella.

Primero intenté instalarlo usando un paquete debian, pero me daba el error
dpkg: error al procesar /usr/local/src/kqemu-1.3.0pre9/kqemu_1.3.0pre9-1_i386.deb (--install):
intentando sobreescribir `/lib/modules/2.6.15-25-686/modules.alias', que está también en el paquete linux-image-2.6.15-25-686
dpkg-deb: el subproceso paste fue terminado por la señal (Tubería rota)
así que finalmente lo he instalado con
# cp /lib/modules/2.6.15-26-686/modules.alias /lib/modules/2.6.15-26-686/modules.alias.bak
# make install

Para cargar el módulo normalmente ejecutaríamos
# modprobe kqemu
pero como Ubuntu utiliza udev, lo hacemos con
# modprobe kqemu major=0
para que se cree el dispositivo /dev/kqemu (por supuesto también podríamos crearlo con # mknod /dev/kqemu c 250 0).

También podemos utilizar modconf para que se cargue siempre automáticamente (el módulo está en la sección misc).

Ahora debemos dar permisos al dispositivo kqemu para que todos los usuarios puedan acceder a él:
# chmod 666 /dev/kqemu
Para que udev ponga automáticamente los permisos adecuados en el arranque, editamos el fichero /etc/udev/rules.d/40-permissions.rules añadiendo las líneas
# Permisos para /dev/kqemu
KERNEL=="kqemu", MODE="0666"


Si no diésemos estos pasos, nos encontraríamos con este error al intentar usar QEMU:
Could not open '/dev/kqemu' - QEMU acceleration layer not activated
es decir, que a pesar de tener el módulo cargado, el acelerador no funcionaría.

Mientras estamos emulando algún sistema, para comprobar que el módulo acelerador está efectivamente en funcionamiento, pasamos al monitor de QEMU pulsando Ctrl-Alt-2, e introducimos la orden info kqemu. Deberíamos obtener algo así:
QEMU 0.8.2 monitor - type 'help' for more information
(qemu) info kqemu
kqemu support: enabled for user and kernel code
(qemu)
Para volver al sistema emulado pulsamos Ctrl-Alt-1

Al utilizar QEMU por primera vez me apareció esta curiosa advertencia:
Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal
error, but for better emulation accuracy either use a 2.6 host Linux kernel or
type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.
y la califico de curiosa porque sí que estoy usando un núcleo Linux 2.6… En fin, podemos hacer que se calle ejecutando esa orden.

Utilización de QEMU

Tras estudiar como instalar QEMU y el módulo acelerador kqemu en un sistema Ubuntu o Debian GNU/Linux, veamos ahora cómo usar las opciones básicas. Para más información, se puede consultar la documentación de QEMU.

Para probar la imagen ISO de una distribución en live-CD, ejecutaremos una orden similar a
$ qemu -boot d -m 224 -kernel-kqemu -cdrom gluz2_beta1.iso

La opción -boot d indica el dispositivo desde el que debe arrancar: disquete (a), disco duro (c) o CD-ROM (d).

La opción -m 224 indica cuanta memoria le asignamos a QEMU. Por omisión son 128 MB, pero si disponemos de más memoria libre, es recomendable asignarle más.
-kernel-kqemu es una nueva opción que habilita el modo de virtualización completa: tanto el código de usuario como el del núcleo invitado se ejecutan directamente en la CPU anfitriona (en el modo normal, sólo se ejecuta directamente el código de usuario, mientras que el código de núcleo es traducido dinámicamente por QEMU). Esto no funciona para todos los sistemas operativos invitados (sí la mayoría de los recientes, como GNU/Linux y Windows 2000/XP, aunque estos últimos no durante la instalación), y de momento sólo de 32 bits.

Y con la opción -cdrom gluz2_beta1.iso indicamos que la máquina virtual debe usar como unidad de CD-ROM ese fichero de imagen ISO.

Otra opción es -soundhw es1370, que habilita el sonido emulando una tarjeta con chip ENSONIQ AudioPCI ES1370 (como la SoundBlaster 128). A mí me da problemas, pero es posible que sea debido al hardware de mi máquina.

Si lo que necesitamos es poder usar dos sistemas operativos distintos simultáneamente, lo mejor es hacer una instalación en el disco duro. Para ello, empezamos creando una imagen de disco, que es un fichero que contendrá un sistema de ficheros con el sistema emulado, actuando como su disco duro

Esto se podría hacer con dd, pero normalmente lo haremos con la orden qemu-img, que admite varios formatos de imagen de disco:

raw

formato de imagen de disco en bruto (formato predeterminado). Este formato tiene la ventaja de ser sencillo y fácilmente exportable a los demás emuladores. Si nuestro sistema de ficheros admite agujeros (como ext2 y ext3), solamente se reservará espacio para los sectores escritos. Podemos conocer el tamaño real que usa la imagen con qemu-img info o ls -ls en sistemas de tipo Unix.

qcow

Formato de imagen de QEMU, el más versátil. Se usa para obtener imágenes más pequeñas en sistemas de ficheros que no admiten agujeros, como el de Windows, cifrado AES opcional y compresión basada en zlib.

cow

Formato de imagen Copy On Write de User Mode Linux. Antiguamente era el único formato de QEMU que podía crecer. Ahora se conserva solamente para mantener compatibilidad con las versiones anteriores. No funciona en Windows.

vmdk

Formato de imagen compatible con VMware 3 y 4.

cloop

Imagen Loop comprimido de GNU/Linux, útil para usar directamente imágenes de CD-ROM comprimidas, como la que usa Knoppix. Ubuntu usa squashfs en vez de cloop.

Si necesitásemos instalar uno de los sistemas de Hasecorp, podríamos ejecutar por ejemplo:
$ qemu-img create -f qcow winxp.img 10G
qcow es el formato recomendado para Hasefroch, winxp.img es el nombre del fichero de imagen, y 10G es el tamaño que le damos.

Para instalar el sistema en el fichero imagen, introducimos el CD-ROM de instalación y ejecutamos
$ qemu -boot d -m 224 -cdrom /dev/cdrom -hda winxp.img
Con la opción -hda indicamos que utilice como disco duro ese fichero de imagen.

Tras realizar la instalación, podremos arrancar el Hasefroch XP con
qemu -boot c -m 224 -hda winxp.img
Por omision arranca con la opción -net user, que proporciona una manera de usar la red. Sin embargo hay otra manera más fina de configurar la red, usando un dispositivo tun y el paquete bridge-utils (véase la documentación). Una cosa que me estaba volviendo loco: desde el sistema emulado, no podemos hacer ping a máquinas de Internet. Sin embargo, sí podemos navegar por la web, etc.

También es posible tener un directorio en el sistema anfitrión al que el Windows emulado pueda acceder por SMB de forma transparente (véase la documentación).

¿Llevas tiempo deseando echar un vistazo a FreeBSD, Plan 9 o Minix? En FreeOsZoo puedes descargar imágenes para QEMU de estos y otros sistemas, y así probarlos fácilmente.

This entry was posted on Domingo, Agosto 6th, 2006 at 20:20 and is filed under Software libre. You can follow any responses to this entry through the RSS 2.0 feed. You can skip to the end and leave a response. Pinging is currently not allowed.