Jdoe’s Throwaway

Aggiornamento 04/06/2008: Nuova versione

Prima di procedere controllate che il vostro processore abbia il supporto a queste istruzioni, altrimenti è tutto inutile:

per processori intel:

# cat /proc/cpuinfo | grep vmx

se esce qualcosa siamo apposto… se tutto tace.. dovrete rimanere con kqemu. sorry :p

se qualcuno mi manda anche la stringa per i processori amd mi farebbe un favore. Oppure cercate su gooOOoogle

Installazione del software necessario:

L’ebuild per kvm non è presente ancora nel tree di gentoo: è disponibile però in un overlay, chiamato sajinet. Dobbiamo quindi, intanto, abilitare l’overlay.

Se usate portage:

layman -f -o http://tapir.sajinet.com.pe/gentoo/layman.xml -a sajinet
layman -s sajinet


Se usate paludis editate il file /etc/paludis/repositories/sajinet.conf (ovviamente modificando per il vostro sistema, sopratutto la variabile location)

location = ${ROOT}/usr/local/repositories/sajinet
sync = rsync://tapir.sajinet.com.pe/portage
master_repository = gentoo
format = ebuild
names_cache = ${location}/.cache/names
write_cache = /var/cache/paludis/metadata

A differenza di qemu, che necessita di gcc-3.4.6 per compilare, kvm può compilarsi anche con gcc4, abilitando la use flag omonima. Se volete usare sia qemu/kqemu che kvm, potete installare entrambi gli ebuild, ricordandovi di abilitare la use-flag qemu all’ebuild di kvm.
C’è una flag, chiamata kvm che abilita il modulo esterno del pacchetto anziché quello compreso nel kernel. Generalmente è più nuovo il modulo esterno, quindi vi consiglio di usare quello, dato che si tratta di una tecnologia in forte sviluppo.
Per usare il modulo esterno, abilitate la use-flag, e quindi assicuratevi che non sia abilitato nel kernel, ovvero la voce Virtualization –> Kernel Based Virtual Machine (KVM) support sia impostata su NO

Virtualization --->
< > Kernel-based Virtual Machine (KVM) support

Inoltre, per la rete, vi serve il supporto al bridging ethernet e all’interfaccia tun-tap

Networking --->
Networking options --->
<M> 802.1d Ethernet Bridging
Device Drivers --->
[*] Network device support --->
<M> Universal TUN/TAP device driver support

In caso la configurazione del kernel sia stata modificata è necessario, ovviamente, ricompilare e riavviare (aspettate i prossimi passi prima di riavviare)

Controllate bene le use flag e quindi installate il pacchetto

paludis -ip app-emulation/kvm net-misc/bridge-utils sys-apps/usermode-utilities
paludis -i kvm


A questo punto editate il file /etc/conf.d/modules e aggiungete, in fondo:
(se avete amd usate kvm-amd anziché kvm-intel)

modules_2_6="${modules_2_6} kvm-intel"
modules_kvm_intel_args=""

modules_2_6=”${modules_2_6} tun”
modules_tun_args=”"

così che i moduli saranno caricati al riavvio.

Networking
se usate Networkmanager, per usare il bridging, purtroppo dovete disabilitarlo. Almeno, io ho dovuto farlo, perché mi creava problemi e non si connetteva, oltre a dover ricompilare tutti i pacchetti di GNOME che avevano la flag networkmanager abilitata.
Quindi occorre disabilitare la flag networkmanager, ricompilare i pacchetti che la usano, e disabilitare networkmanager.

paludis -ip world --dl-reinstall if-use-changed
paludis -i world --dl-reinstall if-use-changed
sudo rc-update del NetworkManager


non riavviate, ancora.
Aprite il file /etc/conf.d/net e inserite SOLO queste righe per eth0 e per br0 (ovviamente se avete altre schede di rete lasciate le righe per configurarle).
Se usate l’ip statico anzichè il dhcp cambiate la riga config_br0 con quello che volete

bridge_br0="eth0"
config_eth0=( "null" )
config_br0=( "dhcp" )
dhcpcd_br0="-t 10"
RC_NEED_br0="net.eth0"
brctl_br0=( "setfd 0" "sethello 0" "stp off" )

Quindi create il file /etc/init.d/net.br0 e /etc/init.d/net.eth0

cd /etc/init.d
ln -s net.lo net.br0
ln -s net.lo net.eth0
rc-update add net.br0 default


Ora riavviate. Se avete fatto tutto a modo, vi trovate con il nuovo kernel, il modulo kvm e tun caricato (controllate con lsmod) e la rete avviata e funzionante (ifconfig br0 vi mostra l’indirizzo)

Avvio:
Ora possiamo, quindi far partire kvm in bridgin. Per far questo, io uso un semplice scriptino in messo in /usr/local/bin che mi fa il setup della rete e quindi avvia la macchina virtuale, aspetta che termini e riporta la rete in stato iniziale. L’incoveniente è che è necessario avviare lo script con sudo o da root.
Lo script è specifico per una macchina, ovvero se volete 3 VM, copiate e modificate lo script 3 volte.
E’ un po’ una noia, ma uno script che gestisse tutto diventava complicato (e quindi più soggetto a errori – che cmq credo ci siano già in abbondanza-).
Lo script crea 2 tap device, le associa una a br0 (il bridge di sistema) e un’altra a kvmbr, un bridge che crea se non esiste. kvmbr serve se si volesse simulare una rete interna tra due o più macchine virtuali, in quanto TUTTE le seconde interfacce create dallo script vengono connesse a kvmbr, creando, di fatto, una LAN virtuale.

Creiamo il disco virtuale

qemu-img create -f qcow2 /percorso/al/disco.img 10G


creiamo lo script (lo potete trovare anche qua: www.jdoe.biz/files/kvm.sh

cd /usr/local/bin
wget www.jdoe.biz/files/kvm.sh
chmod +x /usr/local/bin/kvm.sh


Ecco il contenuto del file.

#!/bin/bash

# CONFIGURATION

DISK=/strg/qemu_img/vm1/hda.img # modify with your path
MEM=512						    # in megabyte
BR1=kvmbr						# virtual bridge
BR0=br0							# system bridge

# DO NOT EDIT HERE-AFTER.
# you have been warned

# unless you know what to do.
# in this case PLEASE report back : - )
function add_tap_to_bridge {
   echo "Adding device $1 to bridge $2"
   /sbin/ifconfig $1 0.0.0.0 promisc up
   /sbin/brctl addif $2 $1
}

[ $UID != 0 ] && echo "you need to start this with root privileges" && exit

user=root
group=kvm
tap0=$(tunctl -b -u $user -g $group)
tap1=$(tunctl -b -u $user -g $group)

if [[ $(brctl show | grep ${BR1}) == "" ]]
then
     echo "Creating bridge ${BR1}"
     brctl addbr ${BR1}
fi

echo -n "Setting up new tap device "
echo "$tap0, $tap1"

add_tap_to_bridge ${tap0} ${BR0}
add_tap_to_bridge ${tap1} ${BR1}

echo "Starting Virtual Machine"

kvm -hda ${DISK} \
         -net nic,macaddr=52:54:00:12:34:5 \
         -net tap,ifname=${tap0},script=no \
         -net nic,macaddr=52:54:00:12:34:6 \
         -net tap,ifname=${tap1},script=no \
         -m ${MEM} $* &

echo -n "Wait for VM to terminate... "
wait
echo "[ ok ]"
echo "Removing Tap devices"
brctl delif ${BR0} ${tap0}
brctl delif ${BR1} ${tap1}
tunctl -d ${tap0}
tunctl -d ${tap1}

if [[ $(brctl show | grep ${BR1} | grep tap) == "" ]]
then
         echo "Removing bridge br1"
         brctl delbr ${BR1}
fi

Quindi avviamo l’installazione della macchina virtuale

/usr/local/bin/kvm.sh -cdrom /path/to/distro.iso -boot d


Lo script passa qualsiasi parametro all’emulatore, quindi riferitevi alla documentazione di kvm/qemu
Il comando sopra avvia la macchina virtuale da cdrom (ad esempio per l’installazione di ubuntu o suse o windows o quel ch volete)
Una volta finita l’installazione per eseguire la macchina virtuale facendo il boot da disco fisso basterà


/usr/local/bin/kvm.sh