Guida per gli sviluppatori al test di sistema con i Linux User-Mode

1.  Ottenere le sorgenti per i Linux User-Mode

Come dichiarato nel sito i Linux User-mode (http://user-mode-linux.sourceforge.net) permettono all'utente di "eseguire linux all'interno di se stesso" Specificamente i Linux User-Mode forniscono una macchina virtuale all'interno della quale un utente può "eseguire software difettoso, sperimentare nuovi kernel o distribuzioni e penetrare nelle viscere di Linux, il tutto senza rischiare la propria installazione principale". Cambiamenti sperimentali ai principali pacchetti di Gentoo quali sys-apps/baselayout o sys-libs/glibc possono corrompere il sistema e renderlo inutilizzabile. Attraverso l'utilizzo dei Linux user-mode possiamo testare questi cambiamenti senza preoccuparci di possibili danni causati al sistema principale.

La maggior parte dei kernel 2.6 hanno il supporto UML. Sebbene si possano usare i sorgenti del kernel attuali, potrebbe essere più saggio mantenere separati gli alberi del kernel UML. Dopotutto, compilerai un nuovo kernel, con una diversa configurazione, e potresti voler avere diversi sistemi sul tuo sistema Linux principale (più di un kernel UML).

Dunque, scarica un buon albero del kernel (come il vanilla, da kernel.org) ed estrailo in una cartella di sviluppo.

Poi, configura il kernel UML come faresti per qualunque altro sistema, ma aggiungi ARCH=um, cosicché il software di compilazione del kernel sappia che il kernel sarà destinato a girare come processo ospite sul sistema principale.

# cd /srv/aegis/src/uml-linux
# make menuconfig ARCH=um
# make linux ARCH=um
# cp linux /usr/local/bin/linux

In un sistema Gentoo predefinito, /usr/local/bin è nel proprio $PATH. Se ci non dovesse essere vero, si dovrebbe trovare una definizione di PATH nel file /etc/profile e correggerla:

$ echo $PATH | grep /usr/local/bin

PATH="/usr/local/bin:/usr/bin:/bin:${PATH}"

Don't forget to run source /etc/profile for the change to take effect. Non dimenticarsi di lanciare source /etc/profile in modo che la modifica abbia effetto.

Per permettere ad un kernel Linux User-Mode di effettuare il boot di un sistema Gentoo in modo corretto, il kernel deve essere configurato per non montare automaticamente la directory /dev (devfs) in modo predefinito. Inoltre, dovrete assicurarvi di avere compilato il supporto per il tmpfs (ovvero il "Virtual Memory Filesystem") dato che gli script di boot, utilizzati da Gentoo Linux, memorizzano in modo predefinito le loro informazioni in una piccola partizione tmpfs. (I kernel binari presenti sul sito dei Linux user-mode montano automaticamente la directory /dev e non hanno compilato al loro interno il supporto per tempfs: non perdeteci tempo).

Vi raccomando di leggere la documentazione relativa ai Linux user-mode, ma l'idea di base è che: lanciando /usr/local/bin/linux il programma esegue il boot del kernel user-mode e tenta di far partire il sistema memorizzato nel file root_fs che dovrebbe essere posizionato nella directory di lavoro corrente.

Potrebbe essere utile installare gli strumenti per Linux User-Mode.

# emerge sys-apps/usermode-utilities

Questi strumenti facilitano (fra le altre cose) lo scambio di dati via rete fra il sistema virtuale lanciato nello user-mode e il sistema ospitante.

2.  Creare root_fs

Creare il sistema da eseguire in ambiente "chroot"

root_fs è un singolo file che contiene l'intero filesystem di Gentoo Linux. Al fine di generarlo dovrete aver abilitato il supporto per il dispositivo di Loopback nel kernel della macchina ospitante.

La generazione del file root_fs sarà il nostro ultimo passo. Prima genereremo un filesystem di Gentoo in un normale ambiente, creato attraverso il comando chroot. Abbiamo, quindi, bisogno dei file archivio degli stage, che possono essere scaricati, copiati da un CD di installazione o estratti da una file .iso di un CD di installazione.

# mkdir /mnt/loop
# mount -o loop /path/to/install-<TAB>.iso /mnt/loop

Creare un ambiente 'chroot' è essenzialmente identico ad una normale operazione di compilazione di una installazione di Gentoo.

# mkdir /mnt/gentoo
# cd /mnt/gentoo
# tar xvjpf /path/to/stage<TAB>.tar.bz2

Continuate e alla fine smontate il file .iso. Ora non vi serve null'altro.

Create il sistema come al solito: eseguite il chroot in /mnt/gentoo e seguite le istruzioni dell'installazione.

Aggiungete qualsiasi pacchetto che desiderate. Se volete, date pure un hostname al vostro sistema virtuale. In /etc/fstab fate in modo che /dev/ROOT sia /dev/ubda il tipo di fs può essere ext2, ext3 o reiserfs. Impostate /dev/SWAP a /dev/ubdb e commentate /dev/BOOT.

A questo punto ricordatevi di impostare la vostra password di root.

# passwd

Ora dobbiamo fare alcuni cambiamenti agli script di boot. Rimuovere, come segue, 'consolefont' e 'keymaps' dal runlevel di boot:

# rc-update del consolefont boot
# rc-update del keymaps boot

Uscite dall'ambiente chroot, smontate tutte le partizioni montate con l'opzione bind e fate un tar della nuova distribuzione, alla fine, cancellate i file che avete usato per fare il file tar.

# cd /mnt/gentoo
# tar cvjpf ~/gentoo.tbz2 *
# cd
# rm -rf /mnt/gentoo

Creare il file root_fs

L'ambiente chroot di Gentoo occupa circa 300 MB, quindi root_fs deve avere una dimensione almeno pari a questa. Scegliamo 0.5 GB, una dimensione ragionevole.

# dd if=/dev/zero of=root_fs seek=500 count=1 bs=1M
# mke2fs -F root_fs
# mount -o loop root_fs /mnt/loop
# tar xvjpf gentoo.tbz2 -C /mnt/loop
# umount /mnt/loop

Sarebbe meglio avere una partizione di swap di 0.5 GB.

# dd if=/dev/zero of=swap_fs seek=500 count=1 bs=1M
# mkswap -f swap_fs

Adesso vedete se funziona!

# linux ubd0=root_fs ubd1=swap_fs

Linux User-Mode utilizza xterm per i terminali virtuali che sono avviati in fase di boot, pertanto dovete assicurarvi che il terminale dal quale eseguite il Linux User-Mode abbia la variabile $DISPLAY correttamente valorizzata (insieme ai necessari permessi di xhost/xauth).

Con un po' di fortuna dovreste essere in grado di fare il login nel vostro sistema Gentoo eseguito attraverso Linux User-Mode. L'unica cosa che manca al sistema nei Linux User-Mode, per essere completamente funzionante, è il collegamento di rete dalla macchina virtuale al sistema ospitante.

3.  Reti

Usare una rete esistente

Assicuratevi che il kernel della macchina ospitante abbia le seguenti impostazioni compilate come moduli:

Networking -->
  IP: Netfilter Configuration -->
    IP tables support -->
      Full NAT -->
        <M> MASQUERADE target support

    Network Device Support -->
      <M> TUN/TAP Support

Ora, sulla macchina ospitante, eseguite quanto segue:

# modprobe tun
(Se qui ricevete un 'FATAL error', provate a eliminare /dev/net/tun e
riprovate)
# modprobe iptable_nat
# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
# echo 1 > /proc/sys/net/ipv4/ip_forward

La riga che contiene il comando iptables attiva l'opzione di IP Masquerading fra la rete privata sulla quale è attestato il sistema nello user-mode e internet (raggiungibile via eth0 nel nostro caso). La riga che contiene il comando echo, quindi, attiva l'opzione di packet forwarding fra la rete privata e quella sulla quale è attestata l'interfaccia che fa da gateway predefinito (eth0 nel nostro caso).

Adesso attiviamo il sistema nello user-mode e vediamo se le opzioni di networking sono funzionanti.

# linux ubd0=root_fs ubd1=swap_fs eth0=tuntap,,,192.168.0.254
(loggarsi al sistema user-mode)
# ifconfig eth0 192.168.0.1 up
# ping -c 2 192.168.0.254
PING 192.168.0.254 (192.168.0.254): 56 octets data
64 octets from 192.168.0.254: icmp_seq=0 ttl=255 time=0.8 ms
64 octets from 192.168.0.254: icmp_seq=1 ttl=255 time=0.6 ms

--- 192.168.0.254 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.6/0.7/0.8 ms
# route add default gw 192.168.0.254
# netstat -rn
Kernel IP routing table
Destination  Gateway        Genmask        Flags MSS Window irtt Iface
192.168.0.0  0.0.0.0        255.255.255.0  U      40 0         0 eth0
0.0.0.0      192.168.0.254  0.0.0.0        UG     40 0         0 eth0
# scp user@192.168.0.254:/etc/resolv.conf /etc/resolv.conf (se necessario)
# ping -c 2 www.gentoo.org
PING www.gentoo.org (207.170.82.202): 56 octets data
64 octets from 207.170.82.202: icmp_seq=0 ttl=240 time=119.6 ms
64 octets from 207.170.82.202: icmp_seq=1 ttl=240 time=92.0 ms

--- www.gentoo.org ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 92.0/105.8/119.6 ms

Sul sistema nello user-mode assegniamo all'interfaccia eth0 l'indirizzo IP 192.168.0.1 e la attiviamo. Il sistema ospitante ha l'IP privato 192.168.0.254, eseguiamo un ping verso quest'ultimo per assicurarci che le opzioni di networking siano realmente attive. La linea che contiene il comando route aggiunge un gateway predefinito, vale a dire il nostro sistema ospitante, usiamo scp per recuperare un file /etc/resolv.conf valido (se necessario), ed eseguiamo un ping verso www.gentoo.org per assicurarci che la risoluzione dei nomi (e in generale l'accesso ad internet) sia funzionante dal nostro sistema nello user-mode. Adesso il sistema nello user-mode può fare emerge a volontà.

Usare una rete virtuale

Prima che ti ecciti troppo, sappi che non si tratta di una rete privata virtuale. È una rete accessibile solo dai processi UML. Il pacchetto usermode-utilities contiene uno strumento chiamato uml_switch, che definisce gli end points dello switch.

(Se le informazioni di switch dovrebbero stare in primo piano:)
$ uml_switch -unix ~/tmp/switch.sock

(Se dovrebbero stare sullo sfondo:)
$ uml_switch -unix ~/tmp/switch.sock &>
~/tmp/switch.log &
 

Per avviare i processi UML sullo switch, esegui il seguente comando. La tua interfaccia di rete (virtuale) verrà connessa al processo uml_switch e userà il MAC address dato.

$ linux ubd0=first_rootfs ubd1=first_swapfs eth0=daemon,10:00:01:02:00:00,,~/tmp/switch.sock

Puoi ancora connettere il sistema alla rete esistente, oppure collegare un secondo processo sia alla rete virtuale che a quella esistente:

$ linux ubd0=second_rootfs ubd1=second_swapfs eth0=daemon,10:00:01:02:00:01,,~/tmp/switch.sock \
eth1=tuntap,,,192.168.1.43

Maggiori informazioni sulla configurazione di tuntap possono essere trovate nella sezione precedente.

4.  Testare il file .iso

Probabilmente il test ideale sarebbe quello di eseguire il boot direttamente del file .iso attraverso i Linux user-mode ed eseguire un'installazione completa all'interno del sistema virtuale.

Fare il boot del file .iso, o meglio, eseguire l'initrd dal file .iso è abbastanza semplice.

# mount -o loop /path/to/build-<TAB>.iso /mnt/loop
# cp /mnt/loop/isolinuxuml.xml/rescue.gz .
# linux load_ramdisk=1 prompt_ramdisk=0 ramdisk_size=22000 \
> initrd=rescue.gz root=/dev/ram0 ubd0=root_fs ubd1=swap_fs \
> ubd2=/dev/cdroms/cdrom0 eth0=tuntap,,,192.168.0.254

Adesso potete seguire la documentazione relativa all'installazione di Gentoo praticamente alla lettera, anche se dovrete tenere presente che: il filesystem di root sarà /dev/ubd/0, la "partizione" di swap sarà /dev/ubd/1, e il CDROM sarà /dev/ubd/2.

5.  Riferimenti

• Bridging with UML
• UML Homepage
• Caker's UML Notes
• UML Mailinglist archives

I contenuti di questo documento sono rilasciati sotto la licenza Creative Commons - Attribution / Share Alike.