Kqemu: Qemu 5x mais rápido. Um concorrente à altura do VMware

Rodar outros sistemas operacionais via emulação não é uma coisa recente. Os primeiros emuladores surgiram na década de 80 para permitir que softwares escritos para computadores antigos rodassem em novas plataformas, isso ainda na época dos mainframes.

Mais tarde, conforme os micros PC foram ficando mais rápidos, começaram a surgir emuladores para todo tipo de console ou plataforma antiga. Você pode rodar desde programinhas para o Commodore, até games do PlayStation One.

O problema dos emuladores é que eles são quase sempre muito lentos. É preciso um Pentium 3 com uma placa 3D relativamente rápida para emular com perfeição um PlayStation One, que possui um processador de 33 MHz e 2 MB de memória RAM.

Depois surgiram os virtualizadores, que trabalham de uma forma um pouco diferente dos emuladores. Ao invés de simular todos os periféricos da plataforma alvo, incluindo as instruções do processador e dispositivos como a placa de som, eles se limitam a repassar as instruções recebidas para o processador principal, que as processa diretamente, sem conversão. Os virtualizadores processam o mínimo possível, basicamente convertem instruções e chamadas problemáticas.

Um exemplo de virtualizador é o VMware, que conhecemos de outros artigos. Ele permite rodar outros sistemas operacionais com de 70 a 90% do desempenho bruto da máquina, um aproveitamento muito melhor que o dos emuladores. A limitação é que o VMware é capaz de executar apenas softwares para a plataforma x86, enquanto os emuladores permitem rodar programas para quase qualquer plataforma.

O problema do VMware é que ele é muito caro, a versão Personal (a mais barata) custa US$ 199. A alternativa mais desenvolvida é o Qemu, um emulador que oferece a maior parte dos recursos, mas é muito mais lento, fornecendo apenas cerca de 10% do desempenho bruto da máquina. Ou seja, rodar uma cópia do Windows 2000 dentro do Qemu, no seu Celeron de 2.0 GHz equivale mais ou menos ao desempenho de rodá-lo num 233 MMX.

Bem, o Qemu é um projeto mantido ativamente, por isso era de se esperar que seu desempenho fosse melhorando com o lançamento de novas versões mas, de repente, algo radical aconteceu.

Durante esta semana foi anunciado o Kqemu (Kernel Qemu, também chamado de Qemu Acelerator), um módulo de Kernel que transforma o Qemu for Linux num virtualizador similar ao VMware. Ele passa a repassar as chamadas ao invés de interpretar cada uma, como fazia até então. Mais do que isso, o desempenho também fica de 4 a 5 vezes melhor, também atingindo um patamar próximo ao do VMware!

É como se um novo chip de injeção eletrônica deixasse o seu carro 1.0 com 250 cavalos de potência, um ganho brutal.

Segundo publicado no http://fabrice.bellard.free.fr/qemu/, usando o Kqemu o desempenho fica entre 50 e 100% do original. Isto se aplica ao desempenho bruto do processador. O acesso ao disco rígido e à memória RAM e também o desempenho do driver de vídeo virtual são bem mais baixos que o normal, o que faz com que, em aplicações práticas, você tenha de 25 a 50% do desempenho original da máquina. É menos do que o oferecido pelo VMware, mas já brutalmente mais que as versões antigas do Qemu.

Por enquanto, a única forma de utilizar o Kqemu é baixar a versão mais recente do Qemu via CVS, incluir a pasta com o fonte do Kqemu e compilar tudo.

Nas próximas semanas, deve ser lançada uma nova versão do Qemu (a atual é a 0.6.1) que já deve incluir o Kqemu e depois disso é só esperar mais algum tempo até que ele comece a ser incluído nas distribuições.

Mas claro, você não que esperar todo este tempo, então vamos à instalação:

O primeiro passo é baixar o código fonte do Qemu via CVS, usando os comandos:

Ele vai pedir uma confirmação, responda “yes” para continuar. Quando pedir a senha, apenas pressione Enter. Para usar este comando você precisa ter instalado o cliente ssh e o cvs.

Isto criará uma pasta “qemu” no diretório atual. Baixe agora o kqemu no:

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

Descompacte o arquivo dentro da pasta “qemu” criada, de forma que seja criada a pasta “qemu/kqemu/”:

Veja que o Kqemu é apenas um componente adicional para o Qemu, que é compilado juntamente com o resto. Justamente por isso ele só funciona em conjunto com a versão mais recente.

A pasta com o código fonte está pronta, falta apenas compilar e instalar.

Como de praxe, você precisará ter instalado o pacote de compiladores da sua distribuição, junto com o código fonte do Kernel (o pacote kernel-source).

O Qemu precisa também dos pacotes texi2html e libsdl1.2-dev. Se você não encontrar os dois nos CDs ou repositórios da sua distribuição, procure no http://rpmfind.net ou outros sites de downloads, eles são realmente necessários. Se você usa uma distribuição derivada do Debian, pode instala-los via apt-get.

Para compilar e instalar, rode os comandos:

(este último como como root)

Se algo der errado durante o ./configure ou make, veja a mensagem de erro para tentar localizar o pacote que está faltando. Antes de tentar de novo, rode o comando “make clean” para eliminar os restos da tentativa anterior.

Depois de instalado, carregue o módulo do kqemu com o comando:

Caso necessário, crie o device que ele utiliza:

O “modprobe kqemu” precisa ser executado a cada boot. Para automatizar isso, adicione o comando no final do arquivo “/etc/rc.d/rc.local” (/etc/init.d/bootmisc.sh no Debian) ou a linha “kqemu” no final do arquivo “/etc/modules”. As duas formas carregam o módulo no boot.

Como kqemu carregado, você pode rodar o qemu da forma habitual, seja via linha de comando, seja usando o kurumin-emu ou outra interface. Desde que o módulo kqemu esteja carregado você se beneficiará da melhoria de desempenho.

Você pode ler mais detalhes sobre o uso do Qemu no capítulo 4 do Kurumin desvendando seus segredos:

https://www.hardware.com.br/livros/kurumin/04

Em resumo, se não houver nenhum interface disponível, o Qemu pode ser chamado via linha de comando, como em:

Este comando faz com que o qemu use o drive de CD-ROM físico (-cdrom /dev/cdrom), dê boot através do CD-ROM (-boot d), use 128 MB de RAM (-m 128), compartilhe a placa de som (-enable-audio) e use o arquivo win98.qcow como disco virtual.

Os discos virtuais do Qemu podem ser criados usando o comando qemu-img, como em:

O “-f qcow” especifica que você quer criar um disco dinâmico, que originalmente ocupa pouco espaço no HD (apenas alguns KB) e vai crescendo conforme são gravados dados, enquanto o “2000M” especifica o tamanho do disco virtual, em MB.

Uma forma mais antiquada, mas que também funciona é usar o comando dd, como em: “dd if=/dev/zero of=win98.img bs=1024000 count=2000”. Neste caso estamos criando um arquivo de 2 GB, cheio de zeros, que também pode ser usado como disco no Qemu. A desvantagem neste caso é que o arquivo vai ocupar 2 GB logo de cara.

Um segundo exemplo de comando de abertura seria:

Aqui ele vai usar um arquivo ISO como CD-ROM (-cdrom kurumin-4.0.iso), inicializar direto através do disco virtual e não do CD-ROM (-boot c), usar 128 MB e RAM e usar o arquivo /mnt/hda6/kurumin.qcow como disco virtual. Desta vez a placa de som não foi compartilhada, pois não usei a opção “-enable-audio”

Mais um exemplo:

Aqui ele vai simplesmente inicializar o sistema instalado no disco virtual /mnt/hda6/win2k.img, sem compartilhar o CD-ROM nem a placa de som.

Se você fosse por exemplo instalar o Windows 2000 dentro do Qemu, começaria usando o comando:

Aqui estou criando um disco virtual de 4GB, para ter espaço para instalar outros programas e arquivos além do sistema operacional.

Em seguida, você precisaria dar boot usando o CD-ROM do Windows 2000 no drive, de forma a instalar o sistema:

Lembre-se que o “-boot d” especifica que o Qemu deve dar boot através do CD-ROM, e não através do disco virtual. Depois de terminar a instalação, você poderia inicializar usando o comando:

Veja que mudou apenas a opção “-boot”. O “-boot c” especifica que agora quero dar boot usando a cópia instalada no disco virtual.

O Windows 98 não funciona nesta versão, ele dá um erro de proteção depois de instalado. Você pode desabilitar o kqemu incluindo a opção “-no-kqemu” na linha de comando, mas isso elimina os ganhos de desempenho. É preferível usar o Windows 2000 ou mesmo o XP, que rodam sem problemas.

Existe um problema contornável com a instalação do Windows 2000. Depois do primeiro reboot, quando o instalador detecta os periféricos algum problema desconhecido faz com que a barra de progresso fique parada enquanto o arquivo de imagem começa a ser enchido com dados aleatórios, até que o espaço livre se esgote. Isso faz o instalador reclamar mais adiante que não existe espaço livre suficiente e a instalação seja abortada.

Para contornar isso, feche a janela do Qemu cerca de 1 minuto depois de iniciada a detecção dos periféricos e abra o instalador novamente, desta vez dando boot pelo HD (não pelo CD-ROM) e a instalação deverá correr sem problemas. Se o mesmo problema se repetir, reinicie mais uma vez.

Se você está usando uma versão recente do Kurumin, pode baixar um pacote já compilado com a nova versão do Qemu aqui:

https://www.hardware.com.br/linux/kurumin/download/qemu_0.62-1_i386.deb

Antes de instalar, remova a versão antiga do Qemu:

Depois instale com um:

Atualizando desta forma, você pode continuar usando o Kurumin-emu, da forma usual:

Uma observação importante é que embora o Qemu seja GPL, o Kqemu é distribuído gratuitamente porém tem seu código fechado. Você pode baixar e usar, mas precisa pedir autorização ao incluir numa distribuição ou numa solução qualquer por exemplo.

Aparentemente o autor pretende manter o uso gratuito para usuários finais e distribuições não comerciais mas cobrar pelo uso em soluções comerciais.

Ele autorizou o uso do Kqemu no Kurumin, de forma que o Kurumin 4.1 já virá com ele pré-instalado.