Windows su Linux con qemu

Menu
MontelLUG frontpage
Aiuto: Come modificare le pagine
Torna indietro

WINDOWS SU LINUX CON QEMU

Ormai sono due anni che uso esclusivamente Linux, anche nell'ambiente lavorativo. Non sono un amministratore di rete, non lavoro nemmeno in un'azienda che utilizza solo Linux. Semplicemente, pur vivendo in mezzo ai SO di Micro$oft, sono sempre riuscito ad interfacciarmi più che egregiamente. Condivisione di documenti (con OpenOffice), scambio di file (smb, ftp etc.), mail, terminal server etc. non hanno mai rappresentato un problema. Anzi, il mio motto in questo periodo è diventato:

"Se è difficile passare da Winzozz a Linux, passare da Linux a Winzozz è impossibile. In Linux si possono fare troppe cose che in Winzozz non sono concepibili"

Ultimamente ho però necessità di modificare un programma scritto in VisualBasic...

In attesa del porting su Linux di Visual Studio, mi sono attrezzato emulando un sistema windows all'interno di Linux.

Introduzione

Dopo una rapida raccolta di informazioni sui vari emulatori, ho deciso di provare inizialmente con qemu. Vi sono molti altri prodotti, quali WMWare, Win4Linux etc. ma a pagamento. Ho preferito inizialmente vedere cosa vi fosse di disponibile nel mondo dell'open source. Xen, che ultimamente pare essere molto di moda, purtroppo richiede il porting del Sistema Operativo (che ovviamente non è disponibile per Winzozz).

QEMU

Qemu è un emulatore: è quindi un software che imita un PC e fa sembrare al SO ospitato di girare su un computer vero completamente a sua disposizione. In poche parole, il Sistema Operativo Ospitato, quello che gira all'interno dell'emulatore, interagisce con un processore, una scheda video, una scheda di rete, una scheda audio etc. che non sono reali, ma sono emulate da qemu. Il sito di riferimento di qemu è fabrice.bellard.free.fr/qemu/. Qui potete trovare la documentazione ufficiale e da qui si possono scaricare i sorgenti, i binari e altri file utili (come ad esempio le immagini già pronte per testare la vostra installazine di qemu).

Una caratteristica importante, che si è dimostrata molto performante, è l'accelerazione. Tenterò di spiegarmi semplicemente anche se non correttamente dal punto di vista tecnico. In breve, quando si emula un pc x86 su un vero x86 (intel e amd per inenderci), l'emulatore non esegue le istruzioni sul processore da lui emulato, ma invia le istruzioni direttamente al processore vero della macchina. Questo permette di velocizzare di molto le prestazioni di qemu in questo caso specifico (ma molto diffuso), facendo quasi raggiungere la velocità nativa al Sistema Operativo Ospitato.

Installazione

Per avere l'ultima versione ho deciso di installare l'emulatore da sorgente. Di seguito quindi spiegherò solo questa installazione.

Per vedere l'interfaccia grafica del sistema ospitato (necessario per emulare Winzozz) bisogna disporre degli header delle librerie SDL. In sistemi debian-like dovrebbe essere sufficiente, da root, digitare:

apt-get install libsdl1.2-dev

Poi è necessario procurarsi i file di qemu scaricando dal sito fabrice.bellard.free.fr/qemu/ i file qemu-0.7.0.tar.gz e kqemu-0.6.2-1.tar.gz.

Estrarre il primo in una directory di lavoro con il comando:

tar zxvf qemu-0.7.0.tar.gz

Il file kqemu-*.tar.gz va estratto all'interno della cartella qemu estratta dall'archivio precedente. Dalla directory di lavoro digitare quindi:

tar zxvf ../kqemu-0.7.0.tar.gz -C ./qemu-0.7.0

Spostarsi nella cartella qemu ed eseguire ./configure:

cd qemu-0.7.0 ./configure

L'output del comando dovrebbe essere:

Install prefix    /usr/local
BIOS directory    /usr/local/share/qemu
binary directory  /usr/local/bin
Manual directory  /usr/local/share/man
ELF interp prefix /usr/gnemul/qemu-%M
Source path       /home/alessandro/temp/qemu/qemu-0.7.0
C compiler        gcc
make              make
host CPU          i386
host big endian   no
target list       i386-user arm-user armeb-user sparc-user ppc-user i386-softmmu ppc-softmmu sparc-softmmu x86_64-softmmu
gprof enabled     no
static build      no
SDL support       yes
SDL static link   no
mingw32 support   no
Adlib support     no
FMOD support      no
kqemu support     yes

KQEMU Linux module configuration:
kernel sources    /lib/modules/2.6.10-5-386/build
kbuild type       2.6

Bisogna controllare che vi sia nell'output di configure siano attivate le opzioni Sdl e kqemu:

SDL support yes
kqemu support yes

A questo punto è possibile compilare:

make
make install

Per quest'ultimo comando bisogna avere i diritti di "root".

L'emulatore è installato. Prima di poterlo utilizzare è necessario però fare alcune configurazioni. Innanzitutto bisogna fare in modo che ad ogni avvio venga caricato il modulo del kernel "kqemu" e che venga creato il file di device "kqemu". Vi sono molti modi per farlo, tra cui il pi becero ma anche il più semplice è inserire nel file /etc/rc.local le seguenti righe (i più esperti possono desumere da queste stesse righe cosa sia necessario fare):

modprobe kqemu
mknod /dev/kqemu c 250 0

Consideriamo di utilizzare tun/tap per la rete, in modo da poter gestire con più flessibilità le connessioni. Per configurare la rete è poi necessario creare un file di configurazione, avviato automaticamente all'avvio di qemu, per configurare la rete del sistema operativo ospitato (per l'operazione successiva servono i diritti di root):

touch /etc/qemu-ifup
chmod 771 /etc/qemu-ifup

Nel file è necessario scrivere, con un editor qualsiasi, le seguenti righe (è necessario avere i diritti di amministratore):

#!/bin/sh
sudo /sbin/ifconfig $1 10.0.0.77
sudo echo "1" > /proc/sys/net/ipv4/ip_forward
sudo iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE

Dovrete adattare lo script alle vostre esigenze. Di seguito la spiegazione di tutte le righe:

#!/bin/sh

indica chi deve interpretare lo script. Presumibilmente questa righa va bene così com'è per tutti.

sudo /sbin/ifconfig $1 10.0.0.77

quando qemu viene avviato, crea una connessione punto punto tra la scheda di rete del pc emulato e il device tun0 creato al momento dell'avvio. E' come se il pc reale avesse una scheda di rete in più (quella denominata tun0) collegata direttamente alla scheda di rete del pc emulato. Sarà necessario quindi assegnare al device tun0 e alla scheda di rete del pc emulato due indirizzi sulla stessa sottorete. In questa riga quindi si configura la cheda di rete (virtuale) collegata con il pc emulato. In questo caso gli viene dato l'indirizzo 10.0.0.77. In seguito, nel sistema operativo che gira all'interno del pc emulato verrà configurata la scheda di rete con l'indirizzo 10.0.0.76 (in modo che siano sotto la stessa sottorete). Così il nostro pc reale riuscirà a pingare l'ip 10.0.0.76 del pc emulato; viceversa, dal Sistema Operativo emulato in qemu, si riuscirà a pingare l'ip 10.0.0.77 della scheda di rete virtuale del pc reale (che scioglilingua!).

sudo echo "1" > /proc/sys/net/ipv4/ip_forward

abilito il pc reale al forwarding. Questo mi serve per fare in modo che il pc reale lasci passare i pacchetti destinati all'esterno senza bloccarli. Serve in pratica per connettere alle altre reti il sistema emulato.

sudo iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE

indico al pc reale di mascherare l'indirizzo reale della sottorete virtuale (quella che collega la scheda tun0 con la scheda di rete del pc emulato).

Perchè lo script /etc/qemu-ifconfig funzioni correttamente bisogna che l'utente che lo avvia sia inserito tra i sudoers e che possa lanciare i comandi sopra indicati senza password. Se questo per voi rappresentasse un problema, potete lanciare qemu come root e non vi dovrebbero essere problemi.