Qemu al igual que Vmware, VIrtualBox, Xen y demás aplicaciones de emulación de Sistemas operativos, crea una máquina virtual, coge recursos de nuestro sistema para crear una computadora virtual (Lógicamente) y sobre ella, gracias a un disco duro virtual (imagen de disco) correr el sistema que queramos (Darwin, Minix, Windows, NetBSD, Haicku,Linux,..). Para este emulador encontramos kqemu el cual acelera la emulación de sistemas para i386, con qemu-launcher tendremos ese gestor gráfico (gui) que no hará obligatorio el uso de comandos en consola, cosa que por otro lado no tiene complicación ninguna como veremos.

Paquete Qemu (sources): qemu-0.9.0.tar.gz
Paquete Qemu (Binario): qemu-0.9.0-i386.tar.gz (Descomprimir en "/")

Paquete Kqemu (sources): Kqemu-1.3.0pre11.tar.gz

Paquete qemu-launcher (sources): qemu-launcher_1.7.4.tar.gz

Procedamos a instalar y usar Qemu de forma básica para poder hacer un uso optimo (Con soporte de usb, disquetera, lectores CD-ROM/DVD y acceso a disco del pc base sobre el que se crean las máquinas virtuales, todo ello con permisos de solo lectura ya que no esta implementada la escritura).

Compilación / Instalación QEMU:


$ tar -zxvf qemu-0.9.0.tar.gz
$ cd qemu-0.9.0/
$ ./configure --prefix=/usr --enable-alsa --enable-adlib --enable-coreaudio --enable-system --enable-linux-user --enable-darwin-user
$ make
# make install


Compilación / Instalación KQEMU:


$ tar -zxvf /kqemu-1.3.0pre11.tar.gz
$ cd kqemu-1.3.0pre11
$ ./configure
$ make
# make install


Kqemu en Kernel 2.4

# modprobe kqemu major=250
#echo 1024 > /proc/sys/dev/rtc/max-user-freq


De no funcionar:


# modprobe kqemu major=0
#echo 1024 > /proc/sys/dev/rtc/max-user-freq


Kqemu en Kernel 2.6

# modprobe kqemu

Kqemu es un modulo que acelera la emulación en Sistemas para i386. Al cargar el modulo de forma normal en kernel de la rama 2.6. La aplicación "udev" es usada para la creación del dispositivo "/dev/kqemu" gracias a la instrucción que la aplicación Hotplug, la cual al cargar el modulo le da la instrucción a udev para la creación del dispositivo. Esta creación automática de dispositivos por parte de "udev", sólo está disponible para la serie 2.6 del kernel por lo que es necesario usar otra forma de cargar el modulo kqemu con la rama 2.4 del kernel. Con esto evitamos los típicos mensajes:

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

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...

Compilación / Instalación Qemu-Launcher:

Dependencias (Módulos de Perl):

gettext:gettext-1.05.tar.gz
Gtk2-GladeXML-: Gtk2-GladeXML-1.006.tar.gz

Compilación de dependencias:

$ perl Makefile.PL
$ make
# make test
# make install

Compilación de qemu-launcher:

# make install

¿Como emulo un sistema operativo?

1 Creamos la imagen del SO a emular:

# dd if=/dev/cdrom of=NetBSD.iso

2 Creamos el archivo qcow:

$ qemu-img create -f qcow NetBSD.qcow 500M

o también:

$ qemu-img create -f qcow NetBSD.img 1G

Como vemos se puede variar la extensión del fichero (img / qcow) ya que realmente no influye y la sintaxis para describir el tamaño deseado (M / G).

Imágenes de disco soportadas por qemu-img: qcow2, vvfat, vpc, bochs, dmg, cloop, vmdk, qcow, cow, host_device y raw.

3 Instalamos la Imagen sobre el "disco" (El fichero qcow simula el hd):

$ qemu -cdrom NetBSD.iso -boot d NetBSD.qcow

Veamos otra forma con ficheros disk (No aumenta el tamaño según necesidad):

1 Creamos el espacio de intercambio (600 Mb):

# dd if=/dev/zero of=$HOME/NetBSD.disk bs=1024 count=600000

2 Instalamos el sistema operativo:

# qemu -boot d -cdrom /dev/cdrom -hda NetBSD.disk -enable-audio -user-net -m 256

AVISO: La extensión "disk" NO permite que el sistema requiera de más espacio, su espacio NO se amplia según necesidad, si son 600Mb de ahí no puede pasar (Esos 600 Mb del ejemplo, los use o no, ocuparan 600 Mb de nuestro disco duro). Con qcow el tamaño va ampliándose según necesitara el sistema emulado y mientras no se use solo ocupa el uso real de disco duro. Para pasar de disk a qcow, sin tener qemu corriendo podemos usar el siguiente comando:

$ qemu-img convert Archivo.disk -O qcow Archivo.qcow

NOTA: Podemos hacer conversiones entre todas las imágenes virtuales de disco soportadas vistas anteriormente.

Uso de qemu

Vamos a ver como usarlo con soporte para cdrom, usb, floppy (Disquetera) y acceso a carpetas del disco nativo. Todo esto es de modo lectura, no se soporta escritura por ahora. Para pasar archivos entre el sistema emulado y nativo tenemos varias opciones como veremos mas adelante.

qemu -hda NetBSD.disk -m 480 -kernel-kqemu -localtime -soundhw all -cdrom /dev/cdrom -usb - usbdevice host:xxxx:xxxx -k es -fda /dev/fd0 -hdb fat:/home/busi/opensolaris -hdc fat:/mnt/debian

O con formato qcow (Lo mismo, solo cambia la extensión).

qemu -hda NetBSD.qcow -m 480 -kernel-kqemu -localtime -soundhw all -cdrom /dev/cdrom -usb - usbdevice host:xxxx:xxxx -k es -fda /dev/fd0 -hdb fat:/home/busi/opensolaris -hdc fat:/mnt/debian

Indicamos que utilice como disco duro NetBSD.disk : -hda
Ram (Mb): -m
Aceleración: -kernel-kqemu
Uso de la hora del sistema local: -localtime
Aplicar todos los donidos del sistema emulado: -soundhw all
Uso de cdrom (como root): -cdrom /dev/cdrom
Soporte usb (pendrive): -usb - usbdevice host:xxxx:xxxx
Idioma de teclado español: -k es
Soporte para floppy: -fda /dev/fd0
Montar directorio local como si fuera otro disco duro: -hdb fat:/directorio1 -hdc fat:/directorio2
Pantalla completa: -full-screen
Usar el sistema en modo lectura: -snapshot

NOTA: Por norma solo se tiene permisos de lectura, pero en floppy se puede conseguir escribir algo en disquetes, aunque muestre errores. Recordar que para pasar archivos tenemos ftp, tftp,ssh y demás. Al usar hdb , hdc y demás no podemos usar particiones montadas (/mnt, /media) porque dará un error de este tipo.


# qemu -hda opensolaris_linux.img -m 480 -kernel-kqemu -localtime -k es -hdb fat:/mnt/hda5/
qemu: /home/busi/qemu-0.9.0/block-vvfat.c:97: array_get: Assertion `index < array->next' failed.
Abortado

En sistemas emulados windows aparecerán como discos duros (FAT32) los distintos directorios usados con opción "-hdb fat", en GNU/Linux lo mismo y debemos montarlos con -t vfat (Por ejemplo: # mount -t vfat /dev/hdb1 /mnt/hd1).

Para el tema de usb, en el sistema nativo debemos realizar el comando "lsusb" el cual mostrara un resultado de este tipo:


Bus 005 Device 001: ID 0000:0000
Bus 005 Device 002: ID 04fc:5602 Sunplus Technology Co., Ltd
Bus 004 Device 001: ID 0000:0000
Bus 003 Device 001: ID 0000:0000
Bus 002 Device 001: ID 0000:0000
Bus 002 Device 002: ID 09aa:3642 Intersil Corp. Prism2.x 802.11b Adapter
Bus 001 Device 001: ID 0000:0000
Bus 001 Device 002: ID 0204:6025
Bus 001 Device 003: ID 148f:2573


Los que tienen un ID son los dispositivos usb (pendrive, tarjeta wireless, cámara de fotos,..), siendo ese ID el que debemos poner en la opción: - usbdevice host:0204:6025

Típico aviso usando la opción -kernel-kqemu:

You do not have enough space in '/dev/shm' for the XXX MB of QEMU virtual RAM.
To have more space available provided you have enough RAM and swap, do as root:
umount /dev/shm
mount -t tmpfs -o size=XXXm none /dev/shm
Or disable the accelerator module with -no-kqemu

Debemos hacer lo que nos dice y aumentar la memoria (tmpfs) en lo que nos diga (XX).

Un error que podemos encontrar al usar "-soundhw" es:


oss: Could not initialize DAC
oss: Failed to open `/dev/dsp'
oss: Reason: Device or resource busy
oss: Could not initialize DAC
oss: Failed to open `/dev/dsp'
oss: Reason: Device or resource busy
audio: Failed to create voice `pcspk'
pcspk: Could not open voice

Esto se debe a que estamos usando nosotros el dispositivo de sonido (mplayer, xine,amaraok, firefox,..).

NOTA: También podemos hacer uso de "qemu-launcher" para gráficamente poner la configuración que queramos, en vez de usar la linea de comandos.

Uso de qemu con opción "-nographic"

Qemu usa para mostrar imagenes en pantalla la biblioteca multiplataforma SDL (Simple DirectMedia Layer), la cual esta escrita en C y es usada por un sin fin de aplicaciones como reproductores y juegos. Pero si emulamos un sistema operativo que tiene la posibilidad de usarse solo en modo texto, podemos hacer que esa salida, en vez de en pantalla gráfica (fondo negro y letras gris, típica del modo texto) sea visualizada en la consola (Gracias a la emulación del puerto serial) donde ejecutemos qemu, ahorrándose el uso de la librería SDL y aumentando aun mas la velocidad del emulador. Ya que el modo texto emulado requiere de imágenes también. Al ejecutarse en nuestra consola el modo texto del sistema operativo emulado, podemos copiar y pegar sin ningún problema, es como si entabláramos una sesión de ssh contra un equipo, no hay salida gráfica ninguna. Realmente muy útil como vemos, pero la distro tiene que estar preparada para soportar la opcion -nographic.

Esta opción lo que realiza es la emulación de una redirección del puerto serial a la consola donde se ejecute qemu. Una de las utilidades de los puertos seriales en los ordenadores es la de interactuar modo texto con un sistema operativo a partir de un terminal ascii (Parecido a un monitor pero solo maneja texto), que es el que se enchufa al puerto serial. Entonces necesitamos hacer que nuestro GNU/Linux u otro SO a emular use también el puerto serial como salida, no solo la pantalla (Que es lo normal).

Preparar un GNU/LInux para usar la opción -nographic:

Grub:

Añadir este par de lineas antes de la descripcion de las distros:

"serial unit=0 --speed=9600 --word=8 --parity=no --stop=1"
"terminal serial"

Añadir a la imagen del kernel: "console=tty0 console=ttyS0,9600n8"

Veamos un ejemplo:


serial unit=0 --speed=9600 --word=8 --parity=no --stop=1
terminal serial
## ## End Default Options ##
....
title *****
root (hd0,0)
kernel /boot/vmlinuz***** root=/dev/hda1 ro console=tty0 console=ttyS0,9600n8
....


Lilo (/etc/lilo.conf):

Añadimos la linea de serial y append como en el siguiente ejemplo:


...
serial=0,9600n8
image=/boot/vmlinuz****
label=l****
initrd=/boot/initrd*****.img
append="console=tty0 console=ttyS0,9600n8"
...


Una vez modificado nuestro cargador de arranque (Grub o Lilo) nos queda modificar /etc/inittab añadiendo al final esta linea:

co:2345:respawn:/sbin/getty -L ttyS0 9600 vt100

Estas opciones son:

Nombre de la consola
Runlevels donde se saca la salida al puerto serie
respawn: Si muere arrancara de nuevo
/sbin/getty -L ttyS0 9600 vt100 -> El tipo de ejecucion y sus opciones de velocidad y terminal usado.

Una vez este configurado ya podemos usar la opción -nographic (Junto con las demas), permitiendo seleccionar distro y ver el arranque del kernel todo desde nuestra terminal (konsole,xterm, etc...), más optimizado imposible.

También otra gran ventaja de esto es el uso de la opción "-nographic" en una máquina en la que estemos mediante ssh, ya que no requiere de ningún tipo de gráfico en pantalla, incluso que dependiendo de quien se valide en el sistema le salte un sistema operativo (emulado) u otro usando la opción de modo lectura (-snapshot).

Teclas especiales:

Ctrl + Alt -> Saca el puntero fuera del sistema operativo emulado.
Ctrl + Alt + 2 -> Nos muestra la consola de qemu donde permite interactuar con el sistema mediante comandos ("help" mostrará todos con su funcionalidad).
Ctrl + Alr + f -> Full screen

Ejemplo: El comando "usb_add host: xxxx:xxx" añade un dispositivo usb (lsusb)

¿Como configuro la RED?

De no realizar una configuración automática, debemos añadir una ip del tipo 10.0.2.33 cuyo gateway es de 10.0.2.2 (El pc sobre el que corremos el emulador). Mascara: 255.0.0.0 y Broadcast: 10.255.255.255.

En los DNS ponemos los que nosotros queramos. Los ping no dan respuesta de echo, pero si resuelve direcciones, lo cual es indicador de que hay acceso a Internet, para comprobar siempre podemos hacer un telnet al puerto 80 de cualquier web.

Aun no se permite la interacción entre sistemas de varias maquinas virtuales, esperemos que en un futuro sea funcional.

¿Como comparto información con el sistema base sobre el que se virtualiza?

Pues dado que para el emulador nuestro sistema base es 10.0.2.2 si tenemos un Apache podemos hacer uso del mismo poniendo esa ip en la dirección del navegador web, con FTP o ssh (scp) también seria funcional, lógicamente. También es posible configurarlo para usar SAMBA o NTFS, pero de las formas anteriores es más cómodo.

Imágenes de SO para Qemu listas para usar (torrents): OS_images

Imágenes:

http://www.busindre.com/wp-content/uploads/2007/06/qemu.png
http://www.busindre.com/wp-content/uploads/2007/07/qemu_busi.png

Usando la opción "-nographic":

http://www.busindre.com/wp-content/uploads/2007/07/qemu_serial.png