QEMU (Español)

La
traducción
de este artículo o sección no refleja el texto original.
Motivos:
No updates since 2017-01-12, English page has seen major changes since. (Discusión en
Talk:QEMU (Español)#
)
Esta traducción de
QEMU
fue revisada el
2017-01-12
. Si existen
cambios
puede
actualizarla
o avisar al
equipo de traducción
.
Artículos relacionados
Category:Hypervisors
Libvirt
De acuerdo con
la wiki de QEMU
, "QEMU es un emulador genérico y de código abierto de máquinas virtuales."
Cuando se utiliza como un emulador de máquina, QEMU puede correr sistemas operativos y programas hechos para una máquina en particular (por ej. una placa ARM) en una máquina diferente (e.j. tu PC x86). Usando la traducción dinámica, se consigue un rendimiento muy bueno.
QEMU puede usar hipervisores como
Xen
o
KVM
para utilizar las extensiones del procesador para la virtualización. Cuando se utiliza como virtualizador, QEMU alcanza un rendimiento cercano a el nativo ejecutando el código de invitado directamente en el CPU host.
Instalación
Instale
el paquete
qemu-full
(ó
qemu-base
para la versión sin GUI y
qemu-desktop
para la versión con solo emulación x86_64 por defecto) y los paquetes opcionales para tus necesidades:
qemu-block-gluster
- Soporte para bloque
Glusterfs
qemu-block-iscsi
- Soporte para bloque
iSCSI
samba
- Soporte para servidor
SMB/CIFS
Front-ends para QEMU
A diferencia de otros programas de virtualización como
VirtualBox
y
VMware
, QEMU no proporciona una interfaz gráfica de usuario para administrar máquinas virtuales (a parte de la ventana que aparece cuando se ejecuta una máquina virtual), tampoco proporciona una forma de crear una máquina virtual persistente con valores guardados. Todos los parámetros para ejecutar una máquina virtual deben especificarse en la línea de comandos en cada puesta en marcha, a menos que haga un script personalizadp para iniciar su máquina(s) virtual. Sin embargo, hay  varios front-end GUI para QEMU:
qemu-launcher
AUR
qtemu
AUR
aqemu
AUR
front-ends con soporte para QEMU están disponibles por
libvirt
.
Creando un nuevo sistema virtualizado
Creando una imagen de disco duro
Sugerencia
Véase la
Wiki de QEMU
para más información sobre imágenes de QEMU.
Para ejecutar QMEU necesitarás una imagen de disco duro, a menos que estés cargando un sistema en vivo desde el CD-ROM ó la red (y no para instalar un sistema operativo en una imagen de disco duro). Una imagen de disco es un archivo que almacena los contenidos del disco duro emulado.
Una imagen de disco puede ser en "crudo", de manera que, literalemte, byte por byte es lo mismo que el cliente ve, y siempre utilizará toda la capacidad del disco duro del disco duro invitado en el host. Este método proporciona la menor sobrecarga de Entrada / Salida, pero puede desperdiciar una gran cantidad de espacio, ya que el espacio no utilizado por el invitado no se puede utilizar en el host.
Por otra parte, la imagen de disco duro puede estar en un formato tal como el de
qcow2
el cuál únicamente asigna espacio a el archivo de la imagen cuando el SO invitado está escribiendo en los sectores del disco virtual. La imagen aparece como el tamaño total del sistema operativo huésped, a pesar que puede tomar hasta una cantidad muy pequeña de espacio en el sistema host. El uso de este formato en lugar de el "crudo" probablemente afecte el rendimiento.
QEMU proporciona el
qemu-img
comando para crear imagenes de disco.
Por ejemplo, para crear una imagen de 4GB en formato "crudo":
$ qemu-img create -f raw
image_file
4G
Se puede uiltizar
-f qcow2
para crear un disco
qcow2
en su lugar.
Nota
También puedes simplemente crear una imagen "cruda" meidante la creación de un archivo del tamaño necesitado usando
dd
ó
fallocate
.
Advertencia
Si almacenas una imágen de disco en un sistema de archivos
Btrfs
, deberías considerar deshabilitar
Copy-on-Write
para el directorio antes de crear imágenes.
Superposición de imágenes de almacenamiento
Puede crear una imagen de almacenamiento una vez (la imagen de respaldo) y hacer que QEMU mantenga mutaciones a esta imagen en una imagen de superposición. Esto le permite volver a un estado anterior de esta imagen de almacenamiento. Puede volver a crear una nueva imagen de superposición en el momento en que desea revertir en función de la imagen de respaldo original.
Para crear una imagen de superposición, ingrese el comando:
$ qemu-img create -o backing_file=
img1.raw
,backing_fmt=
raw
-f
qcow2
img1.cow
Después de eso, puede ejecutar su máquina virtual como de costumbre (ver
#Ejecución del sistema virtualizado
):
$ qemu-system-x86_64
img1.cow
La imagen de respaldo se dejará intacta y se registrarán mutaciones en este almacenamiento en el archivo de imagen de superposición.
Cuando cambia la ruta de acceso a la imagen de respaldo, se requiere reparación.
Advertencia
La ruta del sistema de archivos absoluto de la imagen de respaldo se almacena en el archivo de imagen de superposición (binario)). Cambiar el trayecto de la imagen de respaldo requiere un esfuerzo.
Asegúrese de que la ruta de la imagen de respaldo original sigue conduciendo a esta imagen. Si es necesario, haga un enlace simbólico en la ruta original a la nueva ruta. A continuación, emita un comando como:
$ qemu-img rebase -b
/new/img1.raw
/new/img1.cow
A su discreción, usted puede alternativamente realizar un rebase 'inseguro' donde no se comprueba la ruta anterior a la imagen de respaldo:
$ qemu-img rebase -u -b
/new/img1.raw
/new/img1.cow
Cambiar el tamaño de una imagen
Advertencia
Cambiar el tamaño de una imagen que contiene un sistema de arranque NTFS podría hacer el sistema operativo instalado
no arrancable
. Para una explicación completa y solucioón alternativa mira
[1]
.
El ejecutable
qemu-img
tiene la opción
resize
, que permite redimensionar fácilmente una imagen de disco duro. Funciona tanto para
raw
como para
qcow2
. Por ejemplo, para aumentar el espacio de imagen en 10GB, ingresa:
$ qemu-img resize
disk_image
+10G
Después de ampliar la imagen de disco, debe utilizar el sistema de archivos y las herramientas de particionamiento dentro de la máquina virtual para comenzar a utilizar el nuevo espacio. Al reducir una imagen de disco, primero debe reducir los sistemas de archivos y los tamaños de partición asignados usando el sistema de archivos y las herramientas de partición dentro de la máquina virtual y luego reducir la imagen del disco en consecuencia, de lo contrario reducir la imagen del disco resultará en ¡pérdida de datos!
Preparando el medio de instalación
Para instalar un sistema operativo en su imagen de disco, necesita el medio de instalación (por ejemplo, disco óptico, unidad USB o imagen ISO) para el sistema operativo. El soporte de instalación no debe montarse porque QEMU accede directamente al medio.
Sugerencia
Si utiliza un disco óptico, es una buena idea volcar primero los medios a un archivo porque esto mejora el rendimiento y no requiere que tenga acceso directo a los dispositivos (es decir, puede ejecutar QEMU como un usuario normal sin tener Para cambiar permisos de acceso en el archivo de dispositivo del medio). Por ejemplo, si el nodo de dispositivo de CD-ROM tiene el nombre
/dev/cdrom
, puede volcarlo a un archivo de comandos:
$ dd if=/dev/cdrom of=
Cd_image.iso
Instalando el sistema operativo
Esta es la primera vez que necesitará iniciar el emulador. Para instalar el sistema operativo en la imagen de disco, debe adjuntar la imagen de disco y el medio de instalación a la máquina virtual y hacer que arranque desde el soporte de instalación.
Por ejemplo, en invitados i386, para instalar desde un archivo ISO de arranque como CD-ROM y una imagen de disco sin formato:
$ qemu-system-x86_64 -cdrom
iso_image
-boot order=d -drive file=
disk_image
,format=raw
Consulte
qemu (1)
para obtener más información sobre cómo cargar otros tipos de medios (como disquetes, imágenes de disco o unidades físicas) y
#Ejecución del sistema virtualizado
para otras opciones útiles.
Una vez que el sistema operativo haya finalizado de instalar, la imagen de QEMU se puede iniciar directamente (ver
#Ejecución del sistema virtualizado
).
Advertencia
De forma predeterminada, sólo se asignan 128 MB de memoria a la máquina. La cantidad de memoria se puede ajustar con el interruptor
-m
, por ejemplo
-m 512M
o
-m 2G
.
Sugerencia
En lugar de especificar
-boot order = x
, algunos usuarios pueden sentirse más cómodos usando un menú de arranque:
-boot menu = on
, al menos durante la configuración y la experimentación.
Si necesita reemplazar disquetes o CD como parte del proceso de instalación, puede usar el monitor de la máquina QEMU (presione
Ctrl + Alt + 2
en la ventana de la máquina virtual) para quitar y conectar dispositivos de almacenamiento a un máquina virtual. Escriba
info block
para ver los dispositivos de bloque y use el comando
change
para intercambiar un dispositivo. Pulse
Ctrl + Alt + 1
para volver a la máquina virtual.
Ejecución del sistema virtualizado
Los binarios
qemu-system-*
(por e.j.
qemu-system-i386
ó
qemu-system-x86_64
, dependiendo de la arquitectura del huésped) se usan para ejecutar el sistema virtualizado. El uso es:
$ qemu-system-x86_64
options
disk_image
Las opciones son las mismas para todos los binarios
qemu-system-*
, mira
qemu(1)
para más información sobre todas las opciones.
Por defecto, QEMU mostrará la salida de video de la máquina virtual en una ventana. Una cosa a considerar: al hacer click dentro de la ventana de QMEU, el puntero del cursor será capturado. Para liberarlo presione
Ctrl+Alt+g
.
Advertencia
QEMU nunca debe ejecutarse como root. Si se debe iniciar en root, deberá usar la opción
-runas
para que QEMU utilice privilegios de root.
Activar KVM
KVM debe ser soportado por su procesador y kernel, y necesariamente los
módulos del kernel
deben ser cargados. Mira
KVM
para más información.
Para iniciar QEMU en modo KVM, adjunta
-enable-kvm
a las opciones de inicio adicionales. Para verificar si KVM está activado para ejecutar una máquina virtual, ingresa a la wiki de QEMU
Monitor
, usando
Ctrl+Alt+Shift+2
, e ingresando
info kvm
.
Nota
Si inicia su máquina virtual con una herramienta GUI y experimenta un rendimiento muy malo, debe verificar el soporte adecuado de KVM.
KVM necesita activarse en orden de iniciar adecuadamente Windows 7 y Windows 8 sin
pantallazo azul
.
Habilitar soporte IOMMU (Intel VT-d/AMD-Vi)
Usando IOMMU (unidad de gestión de memoria de entrada y salida) se abre a las caraterísticas como el paso del PCI y la protección de la memoria de dispositivos defectuosos o maliciosos, mira
wikipedia:Input-output memory management unit#Advantages
y
Memory Management (computer programming): Could you explain IOMMU in plain English?
.
Para habilitar IOMMU:
Asegure que AMD-Vi/Intel VT-d es soportado por el CPU y es habilitado en la configuración de BIOS.
Agregue
intel_iommu=on
si tienes un procesador Intel ó
amd_iommu=on
si tienes un procesador AMD en los parámetros del kernel (
kernel parameters
)
Reinicie y asegure que IOMMU está habilitado verificando
dmesg
para
DMAR
:
[0.000000] DMAR: IOMMU enabled
Añade
-device intel-iommu
para crear el dispositivo IOMMU:
$ qemu-system-x86_64
-enable-kvm -machine q35 -device intel-iommu
-cpu host ..
Mover datos entre el host y el Sistema Operativo huésped
Red
Los datos pueden compartirse entre el host y el sistema operativo huésped usando cualquier protocolo de red que pueda transferir archivos, como
NFS
,
SMB
,
NBD
, HTTP,
FTP
, ó
SSH
, siempre que haya configurado la red apropiadamente y haya habilitado los servicios apropiados.
La red por defecto del modo de usuario permite al huésped acceder al sistema operativo host en la dirección IP 10.0.2.2. Todos los servidores que se estén ejecutando en el sistema operativo anfitrión, como un servidor SSH o un servidor SMB, estarán accesibles en esta dirección IP. Así que en los invitados, puede montar los directorios exportados en el host a través de
SMB
o
NFS
, o puede acceder al servidor HTTP del host, etc.
No será posible que el sistema operativo anfitrión acceda a los servidores que se ejecutan en el sistema operativo invitado, pero esto puede hacerse con otras configuraciones de red (consulte
#Tap de red con QEMU
).
Servidor SMB incorporado de QEMU
La documentación de QEMU dice que tiene un servidor SMB "incorporado", pero en realidad acaba de iniciar
Samba
con un archivo
smb.conf
generado automáticamente ubicado en
/tmp/qemu- Smb.
Pid
-0/smb.conf
y lo hace accesible para el invitado en una dirección IP diferente (10.0.2.4 por defecto). Esto sólo funciona para la red de usuarios, y esto no es necesariamente muy útil ya que el invitado también puede acceder al servicio normal
Samba
en el host si ha configurado acciones en él.
Para habilitar esta característica, inicie QEMU con un comando como:
$ qemu-system-x86_64 -nic user,id=nic0,smb=
shared_dir_path
disk_image
donde
shared_dir_path
es un directorio que quieres compartir entre huésped y el host.
Luego, en el invitado, podrá acceder al directorio compartido del host 10.0.2.4 con el nombre de recurso "qemu". Por ejemplo, en el Explorador de Windows iría a
\\ 10.0.2.4 \ qemu
.
Nota
Si estás usando opciones de compartir varias veces como
-net user, smb=
shared_dir_path1
-net user, smb=
shared_dir_path2
ó
-net user , Smb =
shared_dir_path1
, smb =
shared_dir_path2
entonces solo compartirá el último definido.
Si no puede acceder a la carpeta compartida y el sistema invitado es Windows, compruebe que está habilitado el protocolo
NetBIOS
[
enlace roto
2023-05-06]
Y que un cortafuegos no bloquea los puertos
[2]
utilizados por el protocolo NetBIOS.
Montaje de una partición dentro de una imagen de disco raw
Cuando la máquina virtual no se está ejecutando, es posible montar las particiones que están dentro de un archivo de imagen de disco sin formato configurándolas como dispositivos de bucle invertido. Esto no funciona con imágenes de disco en formatos especiales, como qcow2, aunque se pueden montar usando
qemu-nbd
.
Advertencia
Debe asegurarse de desmontar las particiones antes de ejecutar la máquina virtual de nuevo. De lo contrario, es muy probable que ocurra la corrupción de datos.
Con la especificación manual del desplazamiento de bytes
Una forma de montar una partición de imagen de disco es montar la imagen de disco en un cierto desplazamiento usando un comando como el siguiente:
$ mount -o loop, offset = 32256
disk_image
mountpoint
La opción
offset = 32256
se pasa realmente al programa
losetup
para configurar un dispositivo de bucle invertido que empieza en el desplazamiento de byte 32256 del archivo y continúa hasta el final. A continuación, se monta este dispositivo de bucle invertido. También puede utilizar la opción
sizelimit
para especificar el tamaño exacto de la partición, pero esto normalmente no es necesario.
Dependiendo de la imagen del disco, la partición necesaria no se puede iniciar en el desplazamiento 32256. Ejecute
fdisk -l
disk_image
para ver las particiones de la imagen. Fdisk da las compensaciones de inicio y fin en sectores de 512 bytes, así que multiplique por 512 para obtener el desplazamiento correcto para pasar a
mount
.
Con las particiones autodetecting del módulo de bucle (loop)
El controlador de bucle de Linux realmente admite particiones en dispositivos de bucle invertido, pero está desactivado de forma predeterminada. Para habilitarlo, haga lo siguiente:
Deshacerse de todos los dispositivos de bucle invertido (desmontar todas las imágenes montadas, etc.).
Descargar
el módulo del kernel
loop
y cargarlo con el conjunto de parámetros
max_part = 15
. Además, el número máximo de dispositivos de bucle puede controlarse con el parámetro
max_loop
.
Sugerencia
Puede poner una entrada en
/etc/modprobe.d
para cargar el módulo de bucle con
max_part=15
cada vez, o puede poner
loop.max_part = 15
en la línea de comandos del kernel, dependiendo de si tiene o no el módulo
loop.ko
integrado en su kernel.
Configure su imagen como un dispositivo de bucle invertido:
$ losetup -f -P
disk_image
Entonces, si el dispositivo creado fue
/dev/loop0
, se habrán creado automáticamente dispositivos adicionales
/dev/loop0pX
, donde X es el número de la partición. Estos dispositivos de loopback de partición se pueden montar directamente. Por ejemplo:
$ mount /dev/loop0p1
punto de montaje
Para montar la imagen de disco con
udisksctl
, vea
Udisks#Mount loop devices
.
Con kpartx
'Kpartx'
del paquete
multipath-tools
puede leer una tabla de particiones en un dispositivo y crear un nuevo dispositivo para cada partición. Por ejemplo:
 # Kpartx -a
disk_image
Esto configurará el dispositivo de bucle invertido y creará los dispositivos de partición necesarios en
/dev/mapper/
.
Montar una partición dentro de una imagen qcow2
Puede montar una partición dentro de una imagen qcow2 usando
qemu-nbd
. Mira
Wikibooks
.
Utilizar cualquier partición real como la única partición primaria de una imagen de disco duro
A veces, puede que desee utilizar una de las particiones del sistema desde dentro de QEMU. El uso de una partición sin procesar para una máquina virtual mejorará el rendimiento, ya que las operaciones de lectura y escritura no pasan por la capa del sistema de archivos del host físico. Esta partición también proporciona una forma de compartir datos entre el host y el invitado.
En Arch Linux, los archivos de dispositivo para las particiones sin procesar son, por defecto, propiedad de
root
y del grupo
disk
. Si desea que un usuario no root pueda leer y escribir en una partición en bruto, debe cambiar el propietario del archivo de dispositivo de la partición para ese usuario.
Advertencia
Aunque es posible, no se recomienda permitir que las máquinas virtuales alteren los datos críticos en el sistema host, como la partición raíz.
No debe montar un sistema de archivos en una partición de lectura-escritura en el host y el invitado al mismo tiempo. De lo contrario, se producirá corrupción de datos.
Después de hacerlo, puede adjuntar la partición a una máquina virtual QEMU como un disco virtual.
Sin embargo, las cosas son un poco más complicadas si desea tener la máquina virtual
completa
contenida en una partición. En ese caso, no habría ningún archivo de imagen de disco para arrancar realmente la máquina virtual, ya que no se puede instalar un cargador de arranque en una partición que está formateada como un sistema de archivos y no como un dispositivo particionado con un MBR. Una máquina virtual de este tipo se puede iniciar especificando el kernel y el initramfs manualmente o simulando un disco con un MBR usando RAID lineal.
Especificar el kernel y el initrd manualmente
QEMU es compatible con cargar
Linux kernels
e
init ramdisks
directamente, evitando así los cargadores de arranque como
GRUB
. A continuación, se puede iniciar con la partición física que contiene el sistema de archivos raíz como el disco virtual, que no parecen ser particionados. Esto se hace emitiendo un comando similar al siguiente:
Nota
En este ejemplo, se trata de las imágenes del
host
que se están utilizando, no del invitado. Si desea utilizar las imágenes del huésped, monte
/dev/sda3
de sólo lectura (para proteger el sistema de archivos del host) y especifique
/full/path/to/images
ó usar algún truco kexec en el invitado para recargar el kernel del invitado (extiende el tiempo de arranque).
$ Qemu-system-i386 -kernel /boot/vmlinuz-linux -initrd /boot/initramfs-linux.img -append root=/dev/sda/dev/sda3
En el ejemplo anterior, la partición física que se utiliza para el sistema de archivos raíz del huésped es
/dev/sda3
en el host, pero aparece como
/dev/sda
en el invitado.
Por supuesto, puede especificar cualquier kernel e initrd que desee, y no sólo los que vienen con Arch Linux.
Cuando hay varios
kernel parameters
que se pasan a la opción
-append
, necesitan ser citados usando comillas simples o dobles. Por ejemplo:
$ ... -append 'root=/dev/sda1 console=ttyS0'
Simular disco virtual con MBR usando RAID lineal
Una forma más complicada de tener una máquina virtual usar una partición física, mientras que mantener esa partición formateada como un sistema de archivos y no sólo tener la partición invitado la partición como si fuera un disco, es simular un MBR para que pueda Arranque utilizando un gestor de arranque tal como GRUB.
Puede hacerlo utilizando el RAID del software en modo lineal (necesita el controlador de kernel
linear.ko
) y un dispositivo de loopback: el truco consiste en añadir previamente un registro maestro de arranque (MBR) Real que desea incrustar en una imagen de disco RAEM QEMU.
Suponga que tiene una partición simple
/
con algún sistema de archivos en la que desea formar parte de una imagen de disco QEMU. En primer lugar, crear un pequeño archivo para mantener el MBR:
$ dd if=/dev/zero of=
/path/to/mbr
count=32
Aquí, se crea un archivo de 16 KB (32 * 512 bytes). Es importante no hacerlo demasiado pequeño (incluso si el MBR sólo necesita un bloque de 512 bytes), ya que cuanto menor sea, menor será el tamaño del chasis del dispositivo RAID de software, lo que podría tener un impacto En el rendimiento. A continuación, configura un dispositivo de bucle invertido en el archivo MBR:
# losetup -f
/path/to/mbr
Supongamos que el dispositivo resultante es
/dev/loop0
, porque ya no habríamos estado usando otros bucle. El siguiente paso es crear la imagen de disco "fusionada" MBR +
/dev/hda
N
utilizando RAID de software:
# modprobe lineal
# mdadm --build --verbose /dev/md0 --chunk=16 --level=linear --raid-devices=2 /dev/loop0/dev/hda
N
El resultante
/dev/md0
es lo que utilizará como una imagen de disco cruda QEMU (no olvide establecer los permisos para que el emulador pueda acceder a él). El último paso (y algo complicado) es configurar la configuración del disco (geometría del disco y tabla de particiones) para que el punto de inicio de la partición primaria en el MBR coincida con el de
/dev/hda
N
} Dentro
/dev/md0
(un desplazamiento de exactamente 16 * 512 = 16384 bytes en este ejemplo). Hacer esto usando
fdisk
en la máquina host, no en el emulador: la rutina de detección de disco crudo predeterminada de QEMU a menudo da lugar a offsets redondeados no kilobyte (como 31.5 KB, como en la sección anterior) que No puede ser administrado por el código RAID de software. Por lo tanto, desde el anfitrión:
$ fdisk /dev/md0
Pulse
X
para entrar en el menú de expertos. Establezca el número de sectores por pista para que el tamaño de un cilindro coincida con el tamaño de su archivo MBR. Para dos cabezas y un tamaño de sector de 512, el número de sectores por pista debe ser 16, por lo que obtenemos cilindros de tamaño 2x16x512 = 16k.
Ahora, presione
R
para regresar al menú principal.
Presione
P
y compruebe que el tamaño del cilindro es ahora 16k.
Ahora, cree una única partición primaria correspondiente a
/dev/hda
N
. Debe comenzar en el cilindro 2 y terminar en el extremo del disco (tenga en cuenta que el número de cilindros ahora difiere de lo que era cuando se introdujo fdisk.
Finalmente, escribe el resultado al archivo: ya está. Ahora tiene una partición que puede montar directamente desde su host, así como parte de una imagen de disco QEMU:
$ Qemu-system-i386 -hdc /dev/md0
[...]
Por supuesto, puede configurar con seguridad cualquier cargador de arranque en esta imagen de disco utilizando QEMU, siempre que la partición original
/dev/hda
N
contenga las herramientas necesarias.
Redes
El rendimiento de la red virtual debería ser mejor con los dispositivos de derivación (tap) y puentes que con la red en modo de usuario o vde porque los dispositivos de derivación y los puentes se implementan en el kernel.
Además, el rendimiento de la red se puede mejorar asignando a las máquinas virtuales un dispositivo de red
virtio
en lugar de la emulación predeterminada de una NIC e1000. Consulte
#Instalación de controladores virtio
para obtener más información.
Advertencia de dirección a nivel de enlace
Al asignar el argumento
-net nic
a QEMU, asignará por defecto a una máquina virtual una interfaz de red con la dirección de enlace
52:54:00:12:34:56
. Sin embargo, cuando se utiliza la creación de redes puenteadas con varias máquinas virtuales, es esencial que cada máquina virtual tenga una dirección única de nivel de enlace (MAC) en el lado de la máquina virtual del dispositivo de derivación. De lo contrario, el puente no funcionará correctamente, ya que recibirá paquetes de varias fuentes que tienen la misma dirección de nivel de enlace. Este problema se produce incluso si los propios dispositivos de derivación tienen direcciones de nivel de enlace únicas porque la dirección de nivel de enlace de origen no se vuelve a escribir a medida que los paquetes pasan a través del dispositivo de derivación.
Asegúrese de que cada máquina virtual tiene una dirección única de nivel de enlace, pero siempre debe comenzar con
52:54:
. Utilice la opción siguiente, reemplazar
X
por un dígito hexadecimal arbitrario:
$ qemu-system-i386 -net nic,macaddr=52:54:
XX:XX:XX:XX
-net vde
disk_image
Generar direcciones únicas de nivel de enlace se puede realizar de varias maneras:
Especificar manualmente la dirección única de nivel de enlace para cada NIC. El beneficio es que el servidor DHCP asignará la misma dirección IP cada vez que se ejecute la máquina virtual, pero es inutilizable para un gran número de máquinas virtuales.
Generar dirección de nivel de enlace aleatoria cada vez que se ejecuta la máquina virtual. Prácticamente cero probabilidad de colisiones, pero la desventaja es que el servidor DHCP asignará una dirección IP diferente cada vez. Puede utilizar el siguiente comando en una secuencia de comandos para generar una dirección de nivel de enlace aleatoria en una variable
macaddr
:
printf -v macaddr "52:54:%02x:%02x:%02x:%02x" $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff )) $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff ))
qemu-system-i386 -net nic,macaddr="$macaddr" -net vde
disk_image
Utilice el siguiente script
qemu-mac-hasher.py
para generar la dirección de nivel de enlace desde el nombre de la máquina virtual mediante una función de hash. Dado que los nombres de las máquinas virtuales son únicos, este método combina los beneficios de los métodos antes mencionados: genera la misma dirección de nivel de enlace cada vez que se ejecuta el script, aunque preserva la probabilidad prácticamente nula de colisiones.
qemu-mac-hasher.py
#!/usr/bin/env python

import sys
import zlib

if len(sys.argv) != 2:
    print("usage: %s <VM Name>" % sys.argv[0])
    sys.exit(1)

crc = zlib.crc32(sys.argv[1].encode("utf-8")) & 0xffffffff
crc = str(hex(crc))[2:]
print("52:54:%s%s:%s%s:%s%s:%s%s" % tuple(crc))
En un script, puede utilizar por ejemplo:
vm_name="
VM Name
"
qemu-system-i386 -name "$vm_name" -net nic,macaddr=$(qemu-mac-hasher.py "$vm_name") -net vde
disk_image
Redes en modo de usuario
De forma predeterminada, sin ningún argumento
-netdev
, QEMU utilizará la red en modo usuario con un servidor DHCP incorporado. A sus máquinas virtuales se les asignará una dirección IP cuando ejecuten su cliente DHCP, y podrán acceder a la red del host físico a través de la mascarada de IP realizada por QEMU.
Advertencia
Esto sólo funciona con los protocolos TCP y UDP, por lo que ICMP, incluido
ping
, no funcionará. No utilice
ping
para probar la conectividad de red.
Esta configuración predeterminada permite que sus máquinas virtuales accedan fácilmente a Internet, siempre que el host esté conectado a él, pero las máquinas virtuales no estarán directamente visibles en la red externa ni las máquinas virtuales podrán comunicarse entre sí si empieza Más de uno simultáneamente.
La red de usuario en modo QEMU puede ofrecer más capacidades, como servidores TFTP o SMB incorporados, redirigir los puertos del host al huésped (por ejemplo, para permitir conexiones SSH al invitado) o conectar invitados a las VLAN para que puedan hablar entre sí. Consulte la documentación de QEMU en el indicador
-net user
para obtener más detalles.
Sin embargo, la conexión en red en modo usuario tiene limitaciones tanto en la utilidad como en el rendimiento. Las configuraciones de red más avanzadas requieren el uso de dispositivos de derivación u otros métodos.
Tap de red con QEMU
Los
dispositivos tap
Son una característica del kernel de Linux que le permite crear interfaces de red virtuales que aparecen como interfaces de red reales. Los paquetes enviados a una interfaz de derivación se entregan a un programa de espacio de usuario, tal como QEMU, que se ha enlazado a la interfaz.
QEMU puede utilizar la red de derivación para una máquina virtual de modo que los paquetes enviados a la interfaz de derivación se envíen a la máquina virtual y aparezcan como procedentes de una interfaz de red (normalmente una interfaz Ethernet) en la máquina virtual. Por el contrario, todo lo que la máquina virtual envía a través de su interfaz de red aparecerá en la interfaz de tap.
Los dispositivos de toque son soportados por los controladores de puente de Linux, por lo que es posible conectar entre sí los dispositivos entre sí y posiblemente con otras interfaces de host como
eth0
. Esto es deseable si desea que sus máquinas virtuales puedan hablar entre sí, o si desea que otras máquinas en su LAN puedan hablar con las máquinas virtuales.
Advertencia
Si conectas el dispositivo de toque y alguna interfaz de host, como
eth0
, las máquinas virtuales aparecerán directamente en la red externa, lo que los exponerá a posibles ataques. Dependiendo de los recursos a los que tengan acceso sus máquinas virtuales, es posible que tenga que tomar todas las
precauciones
que normalmente tomaría al asegurar una computadora para proteger sus máquinas virtuales. Si el riesgo es demasiado grande, las máquinas virtuales tienen pocos recursos o se configuran varias máquinas virtuales, una solución mejor podría ser utilizar
#Red de host solamente
y configurar NAT. En este caso sólo necesitará un firewall en el host en lugar de múltiples firewalls para cada huésped.
Como se indica en la sección de conexión en red de modo de usuario, los dispositivos de derivación ofrecen un rendimiento de red más alto que el modo de usuario. Si el OS invitado admite el controlador de red virtio, el rendimiento de la red se incrementará considerablemente también. Suponiendo el uso del dispositivo tap0, que el controlador virtio se utiliza en el invitado, y que no se utilizan scripts para ayudar a iniciar / detener la creación de redes, a continuación es parte del comando qemu se debe ver:
-net nic, model=virtio -net tap, ifname=tap0, script=no, downscript=no
Pero si ya está utilizando un dispositivo de tap con virtio controlador de red, uno puede incluso aumentar el rendimiento de la red mediante la activación de vhost, como:
-net nic, model=virtio -net tap, ifname=tap0, script=no, downscript=no, vhost=on
Ver
http://www.linux-kvm.com/content/how-maximize-virtio-net-performance-vhost-net
para obtener más información.
Red de host solamente
Si al puente se le da una dirección IP y se permite el tráfico destinado a ello, pero no hay una interfaz real (por ejemplo,
eth0
) conectada al puente, las máquinas virtuales podrán hablar entre sí y la Sistema anfitrión. Sin embargo, no podrán hablar con nada en la red externa, siempre y cuando no configure IP enmascarada en el host físico. Esta configuración se llama
red de host solamente
por otro software de virtualización como
VirtualBox
.
Sugerencia
Si desea configurar IP masquerading, ej. NAT para máquinas virtuales, consulte la página
Internet sharing#Enable NAT
.
Es posible que desee tener un servidor DHCP que se ejecute en la interfaz de puente para dar servicio a la red virtual. Por ejemplo, para usar la subred
172.20.0.1/16
con
dnsmasq
como servidor DHCP:
# ip addr add 172.20.0.1/16 dev br0
# ip link set br0 up
# dnsmasq --interface=br0 --bind-interfaces --dhcp-range=172.20.0.2,172.20.255.254
Red interna
Si no le da al puente una dirección IP y agrega una regla
iptables
para eliminar todo el tráfico al puente en la cadena INPUT, las máquinas virtuales podrán hablar entre sí, pero no con el host físico ó la red exterior. Esta configuración se llama "red interna" por otro software de virtualización como
VirtualBox
. Deberá asignar direcciones IP estáticas a las máquinas virtuales o ejecutar un servidor DHCP en una de ellas.
De forma predeterminada, iptables eliminaría los paquetes de la red de bridge. Es posible que necesite utilizar dicha regla iptables para permitir paquetes en una red puenteada:
# iptables -I FORWARD -m physdev --physdev-is-bridged -j ACCEPT
Redes puenteadas usando qemu-bridge-helper
Nota
Este método está disponible desde QEMU 1.1, consulte
https://wiki.qemu.org/Features/HelperNetworking
.
Este método no requiere una secuencia de comandos de inicio y acepta fácilmente múltiples tomas y puentes múltiples. Utiliza el binario
/usr/lib/qemu/qemu-bridge-helper
, que permite crear dispositivos de derivación en un puente existente.
Sugerencia
Véase
Network bridge
para obtener información sobre cómo crear un puente.
En primer lugar, cree un archivo de configuración que contenga los nombres de todos los puentes que QEMU utilizará:
/etc/qemu/bridge.conf
allow
bridge0
allow
bridge1
...
Ahora inicie la VM. El uso más básico sería:
$ qemu-system-i386 -net nic -net bridge,br=
bridge0
[...]
Con múltiples taps, el uso más básico requiere especificar la VLAN para todos los NIC adicionales:
$ qemu-system-i386 -net nic -net bridge,br=
bridge0
-net nic,vlan=1 -net bridge,vlan=1,br=
bridge1
[...]
Creación manual del puente
Sugerencia
Desde QEMU 1.1, el
puente de red ayudante
puede establecer tun / tap up para usted sin necesidad de secuencias de comandos adicionales. Consulte
#Redes puenteadas usando qemu-bridge-helper
.
A continuación se describe cómo conectar una máquina virtual con una interfaz de host como
eth0
, que es probablemente la configuración más común. Esta configuración hace que parezca que la máquina virtual está ubicada directamente en la red externa, en el mismo segmento Ethernet que la máquina host física.
Vamos a reemplazar el adaptador Ethernet normal con un adaptador de puente y enlazar el adaptador Ethernet normal a él.
Instale
bridge-utils
AUR
, que proporciona
brctl
para manipular puentes.
Habilitar el reenvío IPv4:
# sysctl net.ipv4.ip_forward=1
Para hacer el cambio permanente, cambie
net.ipv4.ip_forward = 0
a
net.ipv4.ip_forward = 1
en
/etc/sysctl.d/99-sysctl.conf
.
Cargue el módulo
tun
y configurelo para cargarlo en el arranque. Véase
Kernel modules (Español)
para más detalles.
Ahora cree el puente. Ver
Bridge with netctl
para más detalles. Recuerde nombrar su puente como
br0
, o modifique lo scripts a continuación del nombre del puente.
Cree el script que QEMU utiliza para abrir el adaptador de toma con los permisos
root:kvm
750:
/etc/qemu-ifup
#!/bin/sh

echo "Executing /etc/qemu-ifup"
echo "Bringing up $1 for bridged mode..."
sudo /usr/bin/ip link set $1 up promisc on
echo "Adding $1 to br0..."
sudo /usr/bin/brctl addif br0 $1
sleep 2
Cree el guión que QEMU utiliza para derribar el adaptador de toma en
/etc/qemu-ifdown
con los permisos
root:kvm
750:
/etc/qemu-ifdown
#!/bin/sh

echo "Executing /etc/qemu-ifdown"
sudo /usr/bin/ip link set $1 down
sudo /usr/bin/brctl delif br0 $1
sudo /usr/bin/ip link delete dev $1
Use
visudo
para añadir lo siguiente a el archivo
sudoers
:
Cmnd_Alias      QEMU=/usr/bin/ip,/usr/bin/modprobe,/usr/bin/brctl
%kvm     ALL=NOPASSWD: QEMU
Se inicia QEMU con el siguiente script
run-qemu
:
run-qemu
#!/bin/bash
USERID=$(whoami)

# Get name of newly created TAP device; see https://bbs.archlinux.org/viewtopic.php?pid=1285079#p1285079
precreationg=$(/usr/bin/ip tuntap list | /usr/bin/cut -d: -f1 | /usr/bin/sort)
sudo /usr/bin/ip tuntap add user $USERID mode tap
postcreation=$(/usr/bin/ip tuntap list | /usr/bin/cut -d: -f1 | /usr/bin/sort)
IFACE=$(comm -13 <(echo "$precreationg") <(echo "$postcreation"))

# This line creates a random MAC address. The downside is the DHCP server will assign a different IP address each time
printf -v macaddr "52:54:%02x:%02x:%02x:%02x" $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff )) $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff ))
# Instead, uncomment and edit this line to set a static MAC address. The benefit is that the DHCP server will assign the same IP address.
# macaddr='52:54:be:36:42:a9'

qemu-system-i386 -net nic,macaddr=$macaddr -net tap,ifname="$IFACE" $*

sudo ip link set dev $IFACE down &> /dev/null
sudo ip tuntap del $IFACE mode tap &> /dev/null
Para ejecutar una VM, haz algo como esto:
$ run-qemu -hda
myvm.img
-m 512 -vga std
Se recomienda, por motivos de rendimiento y seguridad, deshabilitar el firewall
en el puente
:
/etc/sysctl.d/10-disable-firewall-on-bridge.conf
net.bridge.bridge-nf-call-ip6tables = 0
net.bridge.bridge-nf-call-iptables = 0
net.bridge.bridge-nf-call-arptables = 0
Ejecute
sysctl -p /etc/sysctl.d/10-disable-firewall-on-bridge.conf
para aplicar los cambios inmediatamente.
Ver
libvirt wiki
y
Fedora bug 512206
. Si obtiene errores de sysctl durante el inicio de archivos no existentes, haga que el módulo
bridge
se cargue al arrancar. Véase
Kernel module (Español)#systemd
.
Como alternativa, puede configurar
iptables
para permitir que todo el tráfico se reenvíe a través del puente mediante la adición de una regla como esta:
-I FORWARD -m physdev --physdev-is-bridged -j ACCEPT
Compartición de red entre dispositivo físico y un dispositivo de toque a través de iptables
La conexión en puente funciona bien entre una interfaz cableada (por ejemplo, eth0), y es fácil de configurar. Sin embargo, si el host se conecta a la red a través de un dispositivo inalámbrico, el puente no es posible.
Consulte
Network bridge#Wireless interface on a bridge
como referencia.
Una forma de superar esto es configurar un dispositivo de derivación con una IP estática, haciendo que linux maneje automáticamente el enrutamiento para ella y, a continuación, reenvíe el tráfico entre la interfaz de derivación y el dispositivo conectado a la red a través de las reglas de iptables.
Consulte
Internet sharing
como referencia.
Allí puede encontrar lo que se necesita para compartir la red entre dispositivos, incluidos los de tap y tun. Lo siguiente sólo indica algunas de las configuraciones de host requeridas. Como se indica en la referencia anterior, el cliente debe configurarse para una IP estática, utilizando la IP asignada a la interfaz de derivación como puerta de enlace. La advertencia es que los servidores DNS del cliente pueden necesitar ser editados manualmente si cambian al cambiar de un dispositivo host conectado a la red a otro.
Para permitir el reenvío de IP en cada inicio, es necesario agregar las siguientes líneas al archivo de configuración de sysctl dentro de /etc/sysctl.d:
net.ipv4.ip_forward = 1
net.ipv6.conf.default.forwarding = 1
net.ipv6.conf.all.forwarding = 1
Las reglas de iptables pueden verse así:
# Forwarding from/to outside
iptables -A FORWARD -i ${INT} -o ${EXT_0} -j ACCEPT
iptables -A FORWARD -i ${INT} -o ${EXT_1} -j ACCEPT
iptables -A FORWARD -i ${INT} -o ${EXT_2} -j ACCEPT
iptables -A FORWARD -i ${EXT_0} -o ${INT} -j ACCEPT
iptables -A FORWARD -i ${EXT_1} -o ${INT} -j ACCEPT
iptables -A FORWARD -i ${EXT_2} -o ${INT} -j ACCEPT
# NAT/Masquerade (network address translation)
iptables -t nat -A POSTROUTING -o ${EXT_0} -j MASQUERADE
iptables -t nat -A POSTROUTING -o ${EXT_1} -j MASQUERADE
iptables -t nat -A POSTROUTING -o ${EXT_2} -j MASQUERADE
El anterior supone que hay 3 dispositivos conectados a la red compartiendo tráfico con un dispositivo interno, donde por ejemplo:
INT=tap0
EXT_0=eth0
EXT_1=wlan0
EXT_2=tun0
El anterior muestra un reenvío que permitiría compartir conexiones cableadas e inalámbricas con el dispositivo de derivación (tap).
Las reglas de reenvío que se muestran son apátridas y para el reenvío puro. Se podría pensar en restringir el tráfico específico, poniendo un cortafuegos en el lugar para proteger al huésped y otros. Sin embargo, esto reduciría el rendimiento de la red, mientras que un simple puente no incluye nada de eso.
Bonus: Si la conexión es cableada o inalámbrica, si se conecta a través de VPN a un sitio remoto con un dispositivo tun, suponiendo que el dispositivo tun abierto para esa conexión es tun0, y las reglas iptables anteriores se aplican, entonces la conexión remota se obtiene también Compartido con el huésped. Esto evita la necesidad de que el invitado también abra una conexión VPN. Una vez más, como la red de invitados debe ser estática, entonces si la conexión del host de forma remota de esta manera, uno probablemente tendrá que editar los servidores DNS en el invitado.
Trabajo en red con VDE2
¿Qué es VDE?
VDE significa Virtual Distributed Ethernet. Comenzó como una mejora del interruptor
uml
_. Es una caja de herramientas para administrar redes virtuales.
La idea es crear interruptores virtuales, que son básicamente sockets, y "conectar" tanto máquinas físicas como máquinas virtuales en ellas. La configuración que mostramos aquí es bastante simple; Sin embargo, VDE es mucho más potente que esto, puede conectar conmutadores virtuales juntos, ejecutarlos en diferentes hosts y supervisar el tráfico en los switches. Usted está invitado a leer
la documentación del proyecto
.
La ventaja de este método es que no tienes que agregar privilegios de sudo a tus usuarios. No se debe permitir que los usuarios regulares ejecuten modprobe.
Basics
El soporte de VDE puede ser
instalado
a través del paquete
vde2
en los
repositorios oficiales
.
En nuestra configuración, usamos tun/tap para crear una interfaz virtual en el host. Cargue el módulo
tun
(véase
kernel modules (Español)
para obtener más detalles):
# modprobe tun
Ahora crea el conmutador virtual:
# vde_switch -tap tap0 -daemon -mod 660 -group users
Esta línea crea el switch, crea
tap0
, lo "enchufa" y permite a los usuarios del grupo
users
usarlo.
La interfaz está conectada pero no está configurada todavía. Para configurarlo, ejecute este comando:
# ip addr add 192.168.100.254/24 dev tap0
Ahora, sólo tiene que ejecutar KVM con estas opciones
-net
como usuario normal:
$ qemu-system-i386 -net nic -net vde -hda
[...]
Configure la red para su invitado como lo haría en una red física.
Sugerencia
Es posible que desee configurar NAT en dispositivo de toque para acceder a Internet desde la máquina virtual. Consulte
Internet sharing#Enable NAT
para obtener más información.
Startup scripts
Ejemplo de script principal que inicia VDE:
/etc/systemd/scripts/qemu-network-env
#!/bin/sh
# Preparación del entorno de red QEMU/VDE

# La configuración IP del dispositivo de derivación que se utilizará para
# La red de la máquina virtual:

TAP_DEV=tap0
TAP_IP=192.168.100.254
TAP_MASK=24
TAP_NETWORK=192.168.100.0

# Host interface
NIC=eth0

case "$1" in
  start)
        echo -n "Starting VDE network for QEMU: "

        # If you want tun kernel module to be loaded by script uncomment here
	#modprobe tun 2>/dev/null
	## Wait for the module to be loaded
 	#while ! lsmod | grep -q "^tun"; do echo "Waiting for tun device"; sleep 1; done

        # Start tap switch
        vde_switch -tap "$TAP_DEV" -daemon -mod 660 -group users

        # Bring tap interface up
        ip address add "$TAP_IP"/"$TAP_MASK" dev "$TAP_DEV"
        ip link set "$TAP_DEV" up

        # Start IP Forwarding
        echo "1" > /proc/sys/net/ipv4/ip_forward
        iptables -t nat -A POSTROUTING -s "$TAP_NETWORK"/"$TAP_MASK" -o "$NIC" -j MASQUERADE
        ;;
  stop)
        echo -n "Stopping VDE network for QEMU: "
        # Delete the NAT rules
        iptables -t nat -D POSTROUTING "$TAP_NETWORK"/"$TAP_MASK" -o "$NIC" -j MASQUERADE

        # Bring tap interface down
        ip link set "$TAP_DEV" down

        # Kill VDE switch
        pgrep -f vde_switch | xargs kill -TERM
        ;;
  restart|reload)
        $0 stop
        sleep 1
        $0 start
        ;;
  *)
        echo "Usage: $0 {start|stop|restart|reload}"
        exit 1
esac
exit 0
Ejemplo de servicio systemd utilizando el script anterior:
/etc/systemd/system/qemu-network-env.service
[Unit]
Description=Manage VDE Switch

[Service]
Type=oneshot
ExecStart=/etc/systemd/scripts/qemu-network-env start
ExecStop=/etc/systemd/scripts/qemu-network-env stop
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
Cambiar permisos de
qemu-network-env
para ser ejecutable
# chmod u+x /etc/systemd/scripts/qemu-network-env
Puede iniciar
qemu-network-env.service
como de costumbre.
Método alternativo
Si el método anterior no funciona o no quiere meterse con las configuraciones del kernel, TUN, dnsmasq e iptables, puede hacer lo siguiente para obtener el mismo resultado.
# vde_switch -daemon -mod 660 -group users
# slirpvde --dhcp --daemon
A continuación, para iniciar la VM con una conexión a la red del host:
$ qemu-system-i386 -net nic,macaddr=52:54:00:00:EE:03 -net vde
disk_image
Puente VDE2
Basado en
quickhowto: qemu networking using vde, tun/tap, and bridge
gráfico. Cualquier máquina virtual conectada a vde está expuesta externamente. Por ejemplo, cada máquina virtual puede recibir la configuración DHCP directamente desde su enrutador ADSL.
Conceptos básicos
Recuerde que necesita el módulo
tun
y el paquete
bridge-utils
AUR
.
Cree el dispositivo vde2/tap:
# vde_switch -tap tap0 -daemon -mod 660 -group users
# ip link set tap0 up
Cree el puente:
# brctl addbr br0
Agregue dispositivos:
# brctl addif br0 eth0
# brctl addif br0 tap0
Y configure la interfaz del puente:
# dhcpcd br0
Startup scripts
Todos los dispositivos deben estar configurados. Y sólo el puente necesita una dirección IP. Para dispositivos físicos en el puente (por ejemplo,
eth0
), esto puede hacerse con
netctl
utilizando un perfil Ethernet personalizado con:
/etc/netctl/ethernet-noip
Description='A more versatile static Ethernet connection'
Interface=eth0
Connection=ethernet
IP=no
El siguiente servicio systemd personalizado puede utilizarse para crear y activar una interfaz de toma VDE2 para su uso en el grupo de usuarios
users
.
/etc/systemd/system/vde2@.service
[Unit]
Description=Network Connectivity for %i
Wants=network.target
Before=network.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/bin/vde_switch -tap %i -daemon -mod 660 -group users
ExecStart=/usr/bin/ip link set dev %i up
ExecStop=/usr/bin/ip addr flush dev %i
ExecStop=/usr/bin/ip link set dev %i down

[Install]
WantedBy=multi-user.target
Y, por último, puede crear el puente interfaz con netctl.
Gráficos
QEMU puede utilizar las siguientes salidas gráficas diferentes:
std
,
qxl
,
vmware
,
virtio
,
cirrus
y
none
.
std
Con
-vga std
puede obtener una resolución de hasta 2560 x 1600 píxeles sin necesidad de controladores invitados. Este es el valor predeterminado desde QEMU 2.2.
qxl
QXL Es un controlador de gráficos paravirtual con soporte 2D. Para usarlo, pase la opción
-vga qxl
e instale los controladores en el invitado. Es posible que desee utilizar SPICE para mejorar el rendimiento gráfico al utilizar QXL.
En los invitados de Linux, los módulos del kernel
qxl
y
bochs_drm
deben ser inicializados para poder tener un rendimiento decente.
SPICE
El proyecto
SPICE
tiene como objetivo proporcionar una solución completa de código abierto para el acceso remoto a máquinas virtuales de una manera transparente.
SPICE sólo se puede utilizar cuando se utiliza QXL como la salida gráfica.
El siguiente es un ejemplo de arranque con SPICE como protocolo de escritorio remoto:
$ qemu-system-i386 -vga qxl -spice port=5930,disable-ticketing -chardev spicevm
Conéctese al invitado utilizando un cliente SPICE. En este momento se recomienda
spice-gtk
, sin embargo otros
clientes
, incluyendo otras plataformas, están disponibles:
$ spicy -h 127.0.0.1 -p 5930
El uso de
Unix sockets
en lugar de los puertos TCP no implica el uso de pila de red en el sistema host, por lo que es
Sockets-vs-tcp-ports según se informa
mejor para el rendimiento. Ejemplo:
$ qemu-system-x86_64 -vga qxl -device virtio-serial-pci -device virtserialport,chardev=spicechannel0,name=com.redhat.spice.0 -chardev spicevmc,id=spicechannel0,name=vdagent -spice unix,addr=/tmp/vm_spice.socket,disable-ticketing
$ spicy --uri="spice+unix:///tmp/vm_spice.socket"
Para una mejor compatibilidad con varios monitores, compartir el portapapeles, etc., los paquetes siguientes deben estar instalados en el invitado:
spice-vdagent
: Spice agent xorg cliente que permite copiar y pegar entre el cliente y X-session y más
xf86-video-qxl
xf86-video-qxl-git
AUR
: Xorg X11 qxl controlador de vídeo
Para otros sistemas operativos, mire la sección Guest de la página
SPICE-Space download
.
vmware
Aunque tiene pocos errores, tiene mejor rendimiento que std y cirrus. Instale los controladores de VMware
xf86-video-vmware
AUR
y
xf86-input-vmmouse
para los invitados de Arch Linux.
virtio
virtio-vga
/
virtio-gpu
Es un controlador de gráficos 3D paravirtual basado en
virgl
. Actualmente un trabajo en curso, que sólo admite a invitados Linux (>= 4.4) con
mesa
(>= 11.2) compilados con la opción
--with-gallium-drivers=virgl
.
Para activar la aceleración 3D en el sistema invitado, seleccione vga con
-vga virtio
y habilitar el contexto opengl en el dispositivo de visualización con
-display sdl,gl=on
ó
-display gtk,gl=on
Para la salida de pantalla sdl y gtk respectivamente. La configuración correcta se puede confirmar mirando el registro del kernel en el invitado:
# dmesg | grep drm
[drm] pci: virtio-vga detected
[drm] virgl 3d acceleration enabled
A partir de septiembre de 2016, el soporte para el protocolo de especias está en desarrollo y se puede probar la instalación de la versión de desarrollo de
spice
(>= 0.13.2) y la recompilación de qemu.
Para más información visite
blog de kraxel
.
cirrus
El adaptador gráfico cirrus fue el predeterminado
before 2.2
.
no debería
utilizarse en sistemas modernos.
none
Esto es como un PC que no tiene tarjeta VGA en absoluto. Ni siquiera podrías acceder a ella con la opción
-vnc
. Además, esto es diferente de la opción
-nographic
que permite a QEMU emular una tarjeta VGA, pero deshabilita la visualización SDL.
vnc
Dado que usó la opción
-nographic
, puede agregar la opción
-vnc display
para que QEMU escuche en
display
y redirigir la pantalla VGA a la sesión VNC . Hay un ejemplo de esto en las configuraciones de ejemplo de la sección
#Inicio de las máquinas virtuales QEMU en el arranque
.
$ qemu-system-i386 -vga std -nographic -vnc :0
$ gvncviewer :0
Al usar VNC, puede experimentar problemas de teclado descritos (en detalles gory)
aquí
. La solución es "no" usar la opción
-k
en QEMU y usar
gvncviewer
de
gtk-vnc
. Ver también
este
mensaje publicado en la lista de correo de libvirt.
Audio
Host
El controlador de audio utilizado por QEMU se establece con la variable de entorno
QEMU_AUDIO_DRV
:
$ export QEMU_AUDIO_DRV=pa
Ejecute el siguiente comando para obtener las opciones de configuración de QEMU relacionadas con PulseAudio:
$ qemu-system-x86_64 -audio-help | awk '/Name: pa/' RS=
Las opciones listadas se pueden exportar como variables de entorno, por ejemplo:
$ export QEMU_PA_SINK=alsa_output.pci-0000_04_01.0.analog-stereo.monitor
$ export QEMU_PA_SOURCE=input
Invitado
Para obtener la lista de los controladores de audio de emulación compatibles:
$ qemu-system-x86_64 -soundhw help
Para usar (ej.
hda
) para el invitado utilice el comando
-soundhw hda
con QEMU.
Nota
Los controladores emulados con tarjeta gráfica de vídeo para la máquina invitada también pueden causar un problema con la calidad del sonido. Pruebe uno por uno para que funcione. Puede listar las opciones posibles con
qemu-system-x86_64 -h
.
VirtIO sound
VirtIO sound está disponible desde la versión 8.2.0 de QEMU. El uso es:
-device virtio-sound-pci,audiodev=my_audiodev -audiodev alsa,id=my_audiodev
Para más información, consulte la
documentación de QEMU
[
enlace roto
2025-11-17]
.
Instalación de controladores virtio
QEMU ofrece a los clientes la posibilidad de utilizar dispositivos bloqueados y de red paravirtualizados utilizando los controladores
virtio
, que proporcionan un mejor rendimiento y menores gastos generales.
Un dispositivo virtio bloque requiere la opción
-drive
en lugar del simple
-hd *
más
if=virtio
:
$ qemu-system-i386 -boot order=c -drive file=
disk_image
,if=virtio
Nota
-boot order=c
es absolutamente necesario cuando se desea arrancar desde él. No hay detección automática como con
-hd*
.
Casi de la misma manera para la red:
$ qemu-system-i386 -net nic,model=virtio
Nota
Esto sólo funcionará si la máquina invitada tiene controladores para dispositivos virtio. Linux lo hace, y los controladores necesarios están incluidos en Arch Linux, pero no hay garantía de que los dispositivos virtio funcionen con otros sistemas operativos.
Preparando a Arch Linux como invitado
Para utilizar los dispositivos virtio después de instalar un invitado de Arch Linux, se deben cargar en el invitado los siguientes módulos:
virtio
,
virtio_pci
,
virtio_blk
,
Virtio_net
, y
virtio_ring
. Para los huéspedes de 32 bits, no es necesario el módulo "virtio" específico.
Si desea arrancar desde un disco virtio, el disco ramd inicial debe contener los módulos necesarios. De forma predeterminada, esto es manejado por el gancho
autodetect
de
mkinitcpio
. De lo contrario, utilice la matriz
MODULES
en
/etc/mkinitcpio.conf
para incluir los módulos necesarios y reconstruir el disco ramd inicial.
/etc/mkinitcpio.conf
MODULES="virtio virtio_blk virtio_pci virtio_net"
Los discos Virtio se reconocen con el prefijo
v
(ej.
v
da
,
v
db
, etc.); Por lo tanto, los cambios deben realizarse al menos en
/etc/fstab
y
/boot/grub/grub.cfg
al arrancar desde un disco virtio.
Nota
Cuando se hace referencia a discos por
UUID
en
/etc/fstab
y bootloader, no hay nada que hacer.
Se puede encontrar más información sobre la paravirtualización con KVM
aquí
.
También puede instalar
qemu-guest-agent
para implementar la compatibilidad con los comandos QMP que mejorarán las capacidades de administración del hipervisor. Después de instalar el paquete, puedes habilitar e iniciar el
qemu-ga.service
.
Preparar un invitado de Windows
Nota
La única forma (fiable) de actualizar un cliente de Windows 8.1 a Windows 10 parece que es elegir temporalmente cpu core2duo, nx para la instalación
[3]
. Después de la instalación, puede volver a otros ajustes de la CPU (8/8/2015).
Bloquear controladores de dispositivo
Nueva instalación de Windows
Windows no viene con los controladores virtio. Por lo tanto, tendrá que cargarlos durante la instalación. Hay básicamente dos maneras de hacer esto: vía disco blando o vía archivos de ISO. Ambas imágenes se pueden descargar desde el repositorio
Fedora
.
La opción del disquete es difícil porque necesitará presionar F6 (Shift-F6 en Windows más reciente) al inicio de la alimentación del QEMU. Esto es difícil ya que necesitas tiempo para conectar tu ventana de consola VNC. Puede intentar agregar un retardo a la secuencia de arranque. Consulte
man qemu-system
para obtener más detalles sobre la aplicación de un retardo en el arranque.
La opción ISO para cargar los controladores es la forma preferida, pero está disponible sólo en Windows Vista y Windows Server 2008 y versiones posteriores. El procedimiento consiste en cargar la imagen con controladores virtio en un dispositivo de cdrom adicional junto con el dispositivo de disco principal y el instalador de Windows:
$ qemu-system-i386 ... \
-drive file=
/path/to/primary/disk.img
,index=0,media=disk,if=virtio \
-drive file=
/path/to/installer.iso
,index=2,media=cdrom \
-drive file=
/path/to/virtio.iso
,index=3,media=cdrom \
...
Durante la instalación, el instalador de Windows le pedirá su clave de producto y realizará algunas comprobaciones adicionales. Cuando llegue a la "¿Dónde desea instalar Windows?" Pantalla, dará una advertencia de que no se encuentran discos. Siga las instrucciones de ejemplo siguientes (basadas en Windows Server 2012 R2 con Actualización).
Seleccione la opción
Load Drivers
.
Desactive la casilla de "Ocultar los controladores que no son compatibles con el hardware de este equipo".
Haga clic en el botón Examinar y abra el CDROM para la virtio iso, normalmente llamada "virtio-win-XX".
Ahora vaya a
E:\viostor\[your-os]\amd64
, seleccione y pulse OK.
Click Next
Ahora debería ver sus discos virtio listados aquí, listos para ser seleccionados, formateados e instalados.
Cambiar la máquina virtual existente de Windows para utilizar virtio
Modificar un invitado de Windows existente para arrancar desde disco virtio es un poco difícil.
Puede descargar el controlador de disco virtio desde el
repositorio de Fedora
.
Ahora necesita crear una nueva imagen de disco, que llene la fuerza de Windows para buscar el controlador. Por ejemplo:
$ qemu-img create -f qcow2
fake.qcow2
1G
Ejecute el invitado original de Windows (con el disco de inicio todavía en modo IDE) con el disco falso (en modo virtio) y un CD-ROM con el controlador.
$ qemu-system-i386 -m 512 -vga std -drive file=
windows_disk_image
,if=ide -drive file=
fake.qcow2
,if=virtio -cdrom virtio-win-0.1-81.iso
Windows detectará el disco falso y tratará de encontrar un controlador para ello. Si falla, vaya al
Administrador de dispositivos
, busque la unidad SCSI con un icono de signo de exclamación (debe estar abierto), haga clic en
Actualizar controlador
y seleccione el CD-ROM virtual. No olvide seleccionar la casilla de verificación que dice que debe buscar directorios recursivamente.
Cuando la instalación se realiza correctamente, puede apagar la máquina virtual y volver a iniciarla, ahora con el disco de arranque conectado en modo virtio:
$ qemu-system-i386 -m 512 -vga std -drive file=
windows_disk_image
,if=virtio
Nota
Si encuentra la pantalla azul de Death, asegúrese de no olvidar el parámetro
-m
y de que no arranca con virtio en lugar de ide para la unidad del sistema antes de instalar los controladores.
Controladores de red
La instalación de los controladores de red virtio es un poco más fácil, simplemente agregue el argumento
-net
como se explicó anteriormente.
$ qemu-system-i386 -m 512 -vga std -drive file=
windows_disk_image
,if=virtio -net nic,model=virtio -cdrom virtio-win-0.1-74.iso
Windows detectará el adaptador de red y tratará de encontrar un controlador para ello. Si falla, vaya al
Administrador de dispositivos
, localice el adaptador de red con un icono de signo de exclamación (debe estar abierto), haga clic en
Actualizar controlador
y seleccione el CD-ROM virtual. No olvide seleccionar la casilla de verificación que dice que debe buscar directorios recursivamente.
Preparación de FreeBSD como invitado
Instale el puerto
emulators/virtio-kmod
si está utilizando FreeBSD 8.3 o posterior hasta 10.0-CURRENT donde están incluidos en el kernel. Después de la instalación, añada lo siguiente a su archivo
/boot/loader.conf
:
virtio_loader="YES"
virtio_pci_load="YES"
virtio_blk_load="YES"
if_vtnet_load="YES"
virtio_balloon_load="YES"
A continuación, modifique su
/etc/fstab
haciendo lo siguiente:
sed -i bak "s/ada/vtbd/g" /etc/fstab
Y verificar que
/etc/fstab
es consistente. Si algo sale mal, sólo arranque en un CD de rescate y copie
/etc/fstab.bak
de vuelta a
/etc/fstab
.
Consejos y trucos
Inicio de las máquinas virtuales QEMU en el arranque
Con libvirt
Si se configura una máquina virtual con
libvirt
, se puede configurar a través de la interfaz gráfica de usuario de virt-manager para iniciar en el arranque de host, accediendo a las Opciones de arranque de la máquina virtual y seleccionando "Inicio de la máquina virtual en el arranque del host".
Script personalizado
Para ejecutar QEMU VMs al arrancar, puede usar las siguientes unidades systemd y config.
/etc/systemd/system/qemu@.service
[Unit]
Description=QEMU virtual machine

[Service]
Environment="type=system-x86_64" "haltcmd=kill -INT $MAINPID"
EnvironmentFile=/etc/conf.d/qemu.d/%i
ExecStart=/usr/bin/env qemu-${type} -name %i -nographic $args
ExecStop=/bin/sh -c ${haltcmd}
TimeoutStopSec=30
KillMode=none

[Install]
WantedBy=multi-user.target
Nota
De acuerdo con
systemd.service (5)
y
systemd.kill (5)
man, es necesario utilizar
KillMode=none
opción. De lo contrario, el proceso qemu principal se eliminará inmediatamente después de que se cierre el comando
ExecStop
(simplemente hace eco de una cadena) y su sistema de búsqueda no podrá apagarse correctamente.
A continuación, cree archivos de configuración por-VM, denominados
/etc/conf.d/qemu.d/
vm_name
, con las siguientes variables establecidas:
type
QEMU binary to call. If specified, will be prepended with
/usr/bin/qemu-
and that binary will be used to start the VM. I.e. you can boot e.g.
qemu-system-arm
images with
type="system-arm"
.
args
QEMU command line to start with. Will always be prepended with
-name ${vm} -nographic
.
haltcmd
Command to shut down a VM safely. I am using
-monitor telnet:..
and power off my VMs via ACPI by sending
system_powerdown
to monitor. You can use SSH or some other ways.
Ejemplo de configuración:
/etc/conf.d/qemu.d/one
type="system-x86_64"

args="-enable-kvm -m 512 -hda /dev/mapper/vg0-vm1 -net nic,macaddr=DE:AD:BE:EF:E0:00 \
 -net tap,ifname=tap0 -serial telnet:localhost:7000,server,nowait,nodelay \
 -monitor telnet:localhost:7100,server,nowait,nodelay -vnc :0"

haltcmd="echo 'system_powerdown' | nc localhost 7100" # or netcat/ncat

# You can use other ways to shut down your VM correctly
#haltcmd="ssh powermanager@vm1 sudo poweroff"
/etc/conf.d/qemu.d/two
args="-enable-kvm -m 512 -hda /srv/kvm/vm2.img -net nic,macaddr=DE:AD:BE:EF:E0:01 \
 -net tap,ifname=tap1 -serial telnet:localhost:7001,server,nowait,nodelay \
 -monitor telnet:localhost:7101,server,nowait,nodelay -vnc :1"

haltcmd="echo 'system_powerdown' | nc localhost 7101"
Para establecer qué máquinas virtuales se iniciarán al arrancar, habilite la unidad de
systemd
qemu@
vm_name
.service
.
Integración del ratón
Para evitar que el ratón sea agarrado al hacer clic en la ventana del sistema operativo invitado, agregue la opción
-usbdevice tablet
. Esto significa que QEMU puede reportar la posición del ratón sin tener que agarrar el ratón. Esto también anula la emulación de ratón PS/2 cuando se activa. Por ejemplo:
$ qemu-system-i386 -hda
disk_image
-m 512 -vga std -usbdevice tablet
If that does not work, try the tip at
#El cursor del ratón está nervioso o errático
.
Dispositivo USB del host de paso
Para acceder al dispositivo físico USB conectado al host desde la VM, puede utilizar la opción:
-usbdevice host:
vendor_id
:
product_id
.
Puedes encontrar
vendor_id
y
product_id
de tu dispositivo con el comando
lsusb
.
Puesto que el chipset I440FX por defecto emulado por qemu cuentan con un solo controlador UHCI (USB 1), la opción
-usbdevice
intentará conectar su dispositivo físico a él. En algunos casos esto puede causar problemas con los dispositivos más nuevos. Una posible solución es emular el chipset
ICH9
, que ofrece un controlador EHCI que soporta hasta 12 dispositivos, usando la opción
-machine type=q35
.
Una solución menos invasiva es emular un controlador EHCI (USB 2) o XHCI (USB 3) con la opción
-device usb-ehci, id = ehci
o
-device nec -usb-xhci, id=xhci
respectivamente y luego adjuntar su dispositivo físico con la opción
-device usb-host,..
como sigue:
-device usb-host,bus=
controller_id
.0,vendorid=0x
vendor_id
,productid=0x
product_id
También puede agregar la configuración
..., port =
<n>
a la opción anterior para especificar en qué puerto físico del controlador virtual que desea conectar su dispositivo, útil en El caso que desea agregar varios dispositivos usb a la VM.
Nota
Si encuentra errores de permisos al ejecutar QEMU, consulte
udev#About udev rules
[
enlace roto
: sección no válida]
para obtener información sobre cómo establecer permisos del dispositivo.
Habilitar KSM
Kernel Samepage Merging (KSM) es una característica del kernel de Linux que permite que una aplicación se registre con el kernel para que sus páginas se combinen con otros procesos que también se registren para que sus páginas se fusionen. El mecanismo KSM permite a las máquinas virtuales invitadas compartir páginas entre sí. En un entorno donde muchos de los sistemas operativos invitados son similares, esto puede resultar en ahorros significativos de memoria.
Para activar KSM, simplemente ejecute:
# echo 1 > /sys/kernel/mm/ksm/run
Para hacerlo permanente, puede utilizar
archivos temporales de systemd
:
/etc/tmpfiles.d/ksm.conf
w /sys/kernel/mm/ksm/run - - - - 1
Si KSM está en ejecución y hay páginas que se van a fusionar (es decir, al menos dos máquinas virtuales similares se están ejecutando), entonces
/sys/kernel/mm/ksm/pages_shared
debería ser distinto de cero. Consulte
https://docs.kernel.org/vm/ksm.html
[
enlace roto
2022-09-22]
para obtener más información.
Sugerencia
Una manera fácil de ver lo bien que KSM está realizando es simplemente imprimir el contenido de todos los archivos de ese directorio:
$ grep./Sys/kernel/mm/ksm/*
Multi-monitor support
El controlador QXL de Linux soporta cuatro cabezas (pantallas virtuales) de forma predeterminada. Esto se puede cambiar a través del parámetro kernel
qxl.heads = N
.
El tamaño de memoria VGA predeterminado para los dispositivos QXL es de 16M (el tamaño de la VRAM es de 64M). Esto no es suficiente si desea habilitar dos monitores 1920x1200 ya que requiere 2 × 1920 × 4 (profundidad de color) × 1200 = 17.6 MiB memoria VGA. Esto se puede cambiar reemplazando
-vga qxl
por
-vga none -device qxl-vga, vgamem_mb=32
. Si alguna vez incrementas vgamem_mb más allá de 64M, también debes aumentar la opción
vram_size_mb
.
Copiar y pegar
Para poder copiar y pegar entre el host y el invitado, debe habilitar el canal de comunicación del agente de especias. Requiere agregar un dispositivo virtio-serial al huésped, y abrir un puerto para el vdagent de la especia. También es necesario instalar el spice vdagent en invitado (
spice-vdagent
para invitados de Arch,
Herramientas para invitados de Windows
para invitados de Windows). Asegúrese de que el agente se está ejecutando (y para el futuro, se iniciará automáticamente).
Inicie QEMU con las siguientes opciones:
$ qemu-system-i386 -vga qxl -spice port=5930,disable-ticketing -device virtio-serial-pci -device virtserialport,chardev=spicechannel0,name=com.redhat.spice.0 -chardev spicevmc,id=spicechannel0,name=vdagent
La opción
-device virtio-serial-pci
añade el dispositivo virtio-serial,
-device virtserialport, chardev=spicechannel0, nombre=com.redhat.spice.0
abre un puerto Para spice vdagent en ese dispositivo y
-chardev spicevmc, id=spicechannel0, nombre=vdagent
añade un spicevmc chardev para ese puerto.
Es importante que la opción
chardev=
del dispositivo
virtserialport
coincida con la opción
id=
dada a la opción
chardev
(
spicechannel0
en este ejemplo). También es importante que el nombre del puerto sea
com.redhat.spice.0
, ya que es el espacio de nombres donde vdagent está buscando en el invitado. Y finalmente, especifique
name=vdagent
para que spice sepa para qué sirve este canal.
Notas específicas de Windows
QEMU puede ejecutar cualquier versión de Windows desde Windows 95 a través de Windows 10.
Es posible ejecutar
Windows PE
en QEMU.
Inicio rápido
Nota
Se requiere una cuenta de administrador para cambiar la configuración de energía.
Para invitados de Windows 8 (o posteriores), es mejor desactivar "Activar inicio rápido (recomendado)" en Opciones de energía del Panel de control, ya que hace que el invitado se bloquee durante cada arranque.
El inicio rápido también puede necesitar deshabilitarse para que los cambios en la opción
-smp
se apliquen correctamente.
Protocolo de escritorio remoto
Si utiliza un invitado de MS Windows, puede utilizar RDP para conectarse a su VM invitada. Si está utilizando una VLAN o no está en la misma red que el invitado, utilice:
$ qemu-system-i386 -nographic -net user,hostfwd=tcp::5555-:3389
A continuación, conéctese con
rdesktop
ó
freerdp
al invitado. Por ejemplo:
$ xfreerdp -g 2048x1152 localhost:5555 -z -x lan
Solución de problemas
La máquina virtual virtual corre muy lento
Hay algunas técnicas que se pueden usar para implementar rendimiento en la máquina virtual, por ejemplo:
Use la opción
-cpu host
para hacer que QEMU emule la CPU del host. Si no se hace esto, podría intentar emular un CPU más genérico.
Especialmente para los invitados de Windows, habilite
Iluminaciones de Hyper-V
:
-Host de la CPU, hv_relaxed, hv_spinlocks=0x1fff, hv_vapic, hv_time
.
Si la máquina host tiene varias CPUs, asigne al invitado más CPUs usando la opción
-smp
.
Asegúrese de haber asignado a la máquina virtual suficiente memoria. De forma predeterminada, QEMU sólo asigna 128 MiB de memoria a cada máquina virtual. Utilice la opción
-m
para asignar más memoria. Por ejemplo,
-m 1024
ejecuta una máquina virtual con 1024 MiB de memoria.
Utilice KVM si es posible: agregue
-machine type=pc, accel=kvm
al comando de arranque QEMU que utilice.
Si es compatible con los controladores del sistema operativo invitado, utilice
virtio
para dispositivos de red y/o bloque. Por ejemplo:
$ qemu-system-i386 -net nic, model=virtio -net tap, if=tap0, script=no-drive file=
disk_image
,media=disco, if=virtio
Utilizar dispositivos TAP en lugar de redes en modo usuario. Consulte
#Tap de red con QEMU
.
Si el sistema operativo invitado está haciendo escritura pesada en su disco, puede beneficiarse de ciertas opciones de montaje en el sistema de archivos del host. Por ejemplo, puede montar un
sistema de archivos ext4
con la opción
barrier=0
. Debe leer la documentación de las opciones que cambie porque a veces las opciones de mejora de rendimiento para los sistemas de archivos tienen el costo de integridad de los datos.
Si tiene una imagen de disco sin procesar, puede deshabilitar la caché:
$ qemu-system-i386 -drive file=
disk_image
, if=virtio, cache=none
Utilice el nativo Linux AIO:
$ qemu-system-i386 -drive file=
disk_image
, if=virtio, aio=native
Si utiliza una imagen de disco qcow2, el rendimiento de E/S se puede mejorar considerablemente al garantizar que el caché L2 es de tamaño suficiente. La fórmula
[4]
para calcular La caché L2 es: l2_cache_size = disk_size * 8 / cluster_size. Suponiendo que la imagen qcow2 se creó con el tamaño de clúster predeterminado de 64 K, esto significa que para cada 8 GB de tamaño de la imagen qcow2, 1 MB de caché L2 es mejor para el rendimiento. QEMU utiliza sólo 1 MB por defecto; Especificar una caché más grande se hace en la línea de comandos QEMU. Por ejemplo, para especificar 4 MB de caché (adecuado para un disco de 32 GB con un tamaño de clúster de 64 KB):
$ qemu-system-i386 -drive file=
disk_image
,format=qcow2, l2-cache-size=4M
Si está ejecutando varias máquinas virtuales al mismo tiempo que todas tienen el mismo sistema operativo instalado, puede ahorrar memoria al habilitar
kernel de la misma página de fusión
. Consulte
#Habilitar KSM
.
En algunos casos, la memoria se puede recuperar de correr máquinas virtuales ejecutando un controlador de globo de memoria en el sistema operativo invitado y lanzando QEMU con la opción
-balloon virtio
.
Es posible utilizar una capa de emulación para un controlador ICH-9 AHCI (aunque puede ser inestable). La emulación AHCI soporta
NCQ
, por lo que varias peticiones de lectura o escritura pueden estar pendientes al mismo tiempo:
$ qemu-system-i386 -drive id=disc, file=
disk_image
, if=none -device ich9-ahci, id=ahci -device ide-drive, drive=disk, bus=ahci.0
Mira
https://www.linux-kvm.org/page/Tuning_KVM
para más información.
El cursor del ratón está nervioso o errático
Si el cursor "brinca" descontroladamente, podría ayudar ingresar este comando en la terminal antes de iniciar QEMU
$ export SDL_VIDEO_X11_DGAMOUSE=0
Si funciono, puedes agregarlo a tu
~/.bashrc
archivo.
El cursor no es visible
Añade
-show-cursor
a las opciones de QEMU para poder ver el cursor.
Si persiste, asegurate de configurar la pantalla apropiadamente
Por ejemplo:
-vga qxl
No se puede mover / adjuntar el cursor
Reemplaza
-usbdevice tablet
con
-usb
como opción en QEMU.
El teclado parece roto ó las teclas de flecha no funcionan
Probablemente notarás que algunas de tus teclas no funcionan ó "presionan" la tecla equivocada (en particular, las flechas), preferentemente, necesitas especificar la distribución de tu teclado como una opción. La distribución del teclado puede encontrarse en
/usr/share/qemu/keymaps
.
$ qemu-system-i386 -k
keymap
disk_image
Pantalla de invitado estirada en el tamaño de la ventana
Para restarurar el tamaño por defecto de la ventanta, presiona
Ctrl+Alt+u
.
ioctl(KVM_CREATE_VM) failed: 16 Device or resource busy
Si un mensaje de error como este es listado en el arranque de QEMU con la opción
-enable-kvm
:
ioctl(KVM_CREATE_VM) failed: 16 Device or resource busy
failed to initialize KVM: Device or resource busy
Significa que otro
hypervisor
está actualmente activo. No se recomienda ó no es poible correr varios hypervisores en paralelo.
Mensaje de error libgfapi
El mensaje de error listado en el arranque:
Failed to open module: libgfapi.so.0: cannot open shared object file: No such file or directory
No es un problema, sólo significa que hace falta la dependencia opcional de GlusterFS
Kernel panic en entornos live
Si inicia un sistema en vivo (ó bootea uno) podría encontrar esto:
end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown block(0,0)
Ó algún otro proceso de arranque (ej. no se puede desempaquetar initramfs, no puede iniciar un servicio foo).
Intente iniciar la Máquina Virtual con el
-m VALOR
switch y un tamaño apropiado de RAM, si la RAM es muy poca probablemente encontrará problemas similares a los anteriores.
Ver también
Sitio web oficial de QEMU
Sitio web oficial de KVM
Documentación para el usuario del emulador QEMU
(en inglés)
Wikilibro de QEMU
(en inglés)
[
https://alien.slackbook.org/dokuwiki/doku.php?id=slackware:qemu
Virtualización de hardware con QEMU por AlienBOB (última actualización en 2008) (en inglés)
Construyendo un ejército virtual
por Falconindy (en inglés)
Últimos documentos
QEMU en Windows
Wikipedia
QEMU - Wiki de Debian
(en inglés)
QEMU Networking on gnome.org
[
enlace roto
2022-09-22]
Red virtual de QEMU en sistemas BSD
(en inglés)
QEMU on gnu.org
QEMU en FreeBSD como host
(en inglés)