Tutorial QEMU

QEMU es un emulador y virtualizador genérico de la CPU, lo que le diferencia de VMware y similares, que sólo permiten virtualizar. La faceta emuladora de QEMU le permite ejecutar sistemas operativos y programas creados para una determinada máquina en otra diferente (como puede ser nuestro PC). Cuando se utiliza como virtualizador requiere un acelerador (denominado KQEMU) y necesita que tanto la máquina huésped como la máquina invitada utilicen procesadores compatibles x86. QEMU es software libre.

En este tutorial -y a modo de ejemplo- virtualizaremos Windows XP en una máquina Linux...

Necesitarás instalar antes QEMU y KQEMU, siguiendo el método usual en tu distribución. Este tutorial lo he realizado sobre Arch Linux 0.8, utilizando qemu 0.9.0-1 y kqemu 1.3.0pre11-2.

En primer lugar, crearemos la imagen de disco, es decir, un fichero que contendrá la imagen del disco duro del sistema invitado, al que daremos un tamaño -por ejemplo- de 4 Gigabytes:

qemu-img create -f qcow xp.qcow 4G

Crearemos ahora una imagen superpuesta a ésta, de modo que los cambios se almacenen en un fichero aparte y podamos regresar a la imagen original en caso en caso de problemas o inestabilidades:

qemu-img create -b xp.qcow -f qcow xp2.qcow

A continuación habremos de insertar el CD de Windows XP en la unidad y preparar el medio de instalación del sistema invitado. Por ejemplo:

dd if=/dev/cdrom of=xp.iso

Procedemos ahora a instalar el sistema operativo:

qemu -cdrom xp.iso -boot d xp2.qcow

Correcto:

La instalación sigue el proceso habitual. El puntero del ratón quedará "atrapado" en la ventana de instalación; para liberarlo pulsa Ctrl y Alt a la vez.

Si te fijas ahora en la consola desde la que arrancaste, es posible que veas dos mensajes de aviso.

El primero dice:

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.

Si te aparece, la solución es inmediata. Teclea lo que se te indica como root en una consola:

echo 1024 > /proc/sys/dev/rtc/max-user-freq

Se supone que eso acelera la ejecución.

El segundo mensaje sólo indica que no estás utilizando el acelerador KQEMU:

Could not open '/dev/kqemu' - QEMU acceleration layer not activated

Para cargar el acelerador has de teclear (una sola vez) esto como root:

echo "options kqemu major=0" >> /etc/modprobe.conf

Tras el primer rearranque automático prosigue la instalación. Al final, tenemos el sistema virtualizado funcionando:

Desde este mismo momento puedes conectarte a cualquier servidor que corra en el host Linux sin más que utilizar para ello la dirección 10.0.2.2. Por ejemplo, aquí estamos conectados a un servidor web Apache corriendo en el Arch Linux anfitrión:

En algunos casos (ver comentarios) también se podría disponer ya de acceso a Internet en este punto. Compruébalo, apagando tu máquina virtual y arrancándola de nuevo con un comando como el siguiente:

qemu -hda /home/tu_nombre_usuario/xp2.qcow -m 384 -kernel-kqemu -localtime

El número que sigue a la m es la memoria RAM que quieres dedicar a tu máquina virtual XP y la opción localtime hace que se muestre la hora correcta (si no, emplea la UTC).

Si puedes salir a Internet, enhorabuena. Para ti, el tutorial acaba aquí.

Si no (o si quieres además que tu máquina virtual sea visible para tu red local), continúa leyendo.

Si no puedes salir a Internet...

En mi caso, por alguna razón el XP no pilla la IP de forma automática, así que tuve que configurar a mano la conexión de red. No me sirvió utilizar la IP de la pasarela de mi sistema y dar al XP una IP en ese rango, sino que tuve que dar ambas en el rango que utiliza QEMU, es decir:

IP : 10.0.2.15
Pasarela: 10.0.2.2

Con esto logré salir a Internet incluso en un caso tan atípico como el mío.

Otra forma más complicada de lograrlo consiste en configurar una conexión bridged (puenteada), que da una IP propia al equipo virtual, lo que -a cambio de una mayor complicación- comporta la ventaja añadida de que lo hace visible desde el host u otros equipos de la red.

El método que sigo a continuación funcionó tal cual en Arch Linux, pero seguramente habrá que modificarlo para otras distribuciones [disponemos también un tutorial para Fedora, gentileza de Jonsito]. Requiere tener instalados los paquetes bridge-utils y uml_utilities.

Lo que haremos será reconfigurar la red para poder disponer de un interfaz puente, llamado br0.

Crearemos el fichero /etc/qemu-ifup con el siguiente contenido (insisto: las rutas serán las de distribución):

#!/bin/sh
echo "Executing /etc/qemu-ifup"
echo "Bringing up $1 for bridged mode..."
sudo /sbin/ifconfig $1 0.0.0.0 promisc up
echo "Adding $1 to br0..."
sudo /usr/sbin/brctl addif br0 $1
sleep 2

Para dar a este fichero permisos de ejecución tecleamos:

chmod a+x /etc/qemu-ifup

Crearemos /etc/udev/rules.d/70-kqemu.rules, con el siguiente contenido:

KERNEL=="kqemu", MODE="0666"
KERNEL=="tun", MODE="0666"

Crearemos ~/bin/qemu_setup (es decir, en tu home) con el siguiente contenido:

# insert the tuntap module
modprobe tun

# insert the bridge module
modprobe bridge

# insert the kqemu module
modprobe kqemu major=0

# setup bridge
ifconfig eth0 down
brctl addbr br0
ifconfig eth0 up
brctl addif br0 eth0
ifconfig br0 192.168.0.111 up
ifconfig eth0 down
ifconfig eth0 0.0.0.0 up
route add default gw 192.168.0.1

(ojo: la primera IP será la que quieras darle a tu máquina invitada y la segunda la de tu pasarela a Internet).

Hazlo ejecutable:

chmod a+x ~/bin/qemu_setup

Por último nos creamos un script (~/bin/windows) para arrancar la máquina Windows con las opciones que deseemos (Así, el número que sigue a m representa la RAM que queremos utilizar, etc. Puedes observar todas las opciones disponibles tecleando qemu en la línea de comandos).

Nuestro ~/bin/windows será algo así:

#!/bin/sh
USERID=`whoami`
iface=`sudo tunctl -b -u $USERID`
qemu -hda /home/turing/xp2.qcow -m 384 -cdrom /dev/cdrom -kernel-kqemu -localtime -snapshot -net nic -net tap,ifname=$iface 
sudo tunctl -d $iface &>/dev/null

Hazlo ejecutable:

chmod a+x ~/bin/windows

Tecleamos ahora visudo para añadir las siguientes líneas a /etc/sudoers y poder ejecutar QEMU como usuario normal:

tu_nombre_de_usuario ALL=(ALL) NOPASSWD: /usr/sbin/brctl
tu_nombre_de_usuario ALL=(ALL) NOPASSWD: /usr/bin/tunctl
tu_nombre_de_usuario ALL=(ALL) NOPASSWD: /sbin/ifconfig

Tras reiniciar, ahora, siempre que queramos usar la máquina virtualizada, hemos de ejecutar -como root- el script qemu_setup para poner en marcha la conexión de red y después arrancar -con tu usuario- el script windows.

Ahora ya tenemos salida a Intenet, como demuestra el hecho de que Explorer ya puede encontrar felizmente su casa:

Hasta aquí sólo hemos visto un ejemplo del uso de QEMU como virtualizador, pero QEMU es también un emulador y dispone de muchas otras opciones y posibilidades (y también de una versión para Windows) así que, a poco que me demostréis que el tema os interesa, ésta que ahora contemplas podría ser sólo la primera entrega de toda una saga.

Referencias:

• QEMU [Home Page].
• QEMU [Archwiki].
• QEMU setup [Wisdom is the prime thing].
• QEMU and TUN/TAP networking [Felipe Alfaro Blog].