Guida alla configurazione di User Mode Linux (UML)

Che cos'è UML

User Mode Linux (UML) è una caratteristica del kernel linux che permette l'esecuzione di un kernel linux in modalità utente.

Questo si comporta esattamente come se fosse un normale programma utente , che effettua chiamate di sistema al kernel reale che opera in modalità monitor sulla nostra macchina.

Sappiamo infatti che il kernel di un sistema operativo è la parte fondamentale dello stesso, che si occupa di inizializzare le periferiche di sistema e di gestirle attraverso gli opportuni sottosistemi, operando in modalità privilegiata, ovvero accedendo alla CPU in modalità monitor (gli accessi alla memoria non sono protetti). Questo fa si che i bugs di un kernel possano produrre ogni sorta di danno al sistema, da comportamenti instabili al danneggiamento delle periferiche del sistema stesso a causa per esempio di operazioni di trasferimento e gestione scorretta dell'accesso alle stesse.

Quando ad esempio controlliamo lo stato dei processi e delle risorse del sistema utilizzando i comandi

ps -aux

vmstat 5 5 

iostat

cat /proc/meminfo

oppure attraverso l'utility grafica di GNOME monitor di sistema otteniamo le informazioni dalle tabelle di sistema contenute nel kernel e da esso costantemente aggiornate.

E' pertanto di fondamentale importanza che i bugs e i problemi del kernel siano corretti nel più breve tempo possibile, ed è anche per questo che si raccomanda di mantenere sempre aggiornato il proprio sistema all'ultima versione del kernel.

Tuttavia nonostante i nostri aggiornamenti sappiamo bene che le vulnerabilità del nostro sistema saranno sempre presenti, in quanto l'unico sistema realmente sicuro è un sistema spento ed inutilizzato (e quindi inutile).

User Mode Linux ci permette tuttavia di superare il problema in oggetto in modo elegante.

Infatti come già detto poichè il kernel UML non è altro che un normale programma utente esso non opera in modalità privilegiata sul processore ma in modalità utente, effettuando ogni qualvolta deve eseguire delle operazioni privilegiate delle chiamate di sistema al kernel reale che si prende carico di effettuarle.

In questo modo viene garantita la separazione dello spazio di indirizzamento dei processi kernel UML e kernel reale : il primo viene eseguito come utente semplice, il secondo come root. Ovviamente ne deriva che le risorse accessibili dal kernel UML sono limitate così come lo sono le operazioni che il kernel stesso può effettuare (può accedere soltanto alle risorse ad esso assegnate e non in modo illimitato).

Il principio del kernel UML è l'idea di macchina virtuale sviluppata da Sun Microsystems.

Il principale effetto di un kernel UML è la possibilità di avviare una finestra di terminale nella quale vedremo l'inizializzazione del nuovo sistema operativo in modalità utente. Questa finestra di terminale rappresenta il nostro nuovo sistema Linux virtuale dentro il sistema Linux reale!

Ora passiamo a vedere come realizzare un sistema UML con il nostro Ubuntu.

Realizzazione di UML

Per realizzare il nostro sistema UML abbiamo bisogno innanzitutto di un kernel linux sorgente.

Una volta compilatolo per l'architettura UML dobbiamo

creare un filesystem vuoto utilizzando l'utility

mkemptyfs.txt.

Poi dovremo effettuare il mount del filesystem creato su un mount point specifico, indi dovremo trasferire tutto il nostro

filesystem reale in quello vuoto.

Infine dovremo lanciare l'esecuzione del nostro kernel UML abilitandone la visualizzazione in una finestra di terminale.

Ecco i passi necessari :

ci troviamo nella directory /fs;il filesystem vuoto sarà qui creato e verrà montato in una nuova directory appositamente creata /fs/ubuntufs
creiamo un nuovo filesystem vuoto con l'utility mkemptyfs.txt eseguendo il comando

#mkemptyfs.txt ext3 4096

la dimensione specificata è in Megabytes, pertanto il filesystem creato sarà di 4 GB;

creaiamo il mount point /fs/ubuntufs e vi montiamo poi il filesystem creato in /fs con i comandi :

#mkdir /fs/ubuntufs

#mount -o loop /fs/emptyfs.ext3.4096 /fs/ubuntufs/

come vediamo il filesystem è montato come filesystem di loop;

ci procuriamo l'ultimo kernel creando la directory di compilazione /usr/scr/uml, estraendolo in essa e compilandolo con i comandi

#mkdir /usr/src/uml

#tar xzvf kernel-2.6.12.tar.gz

#make menuconfig ARCH=um

#make modules ARCH=um

#make modules_install ARCH=um INSTALL_MOD_PATH=/fs/ubuntufs

#make linux ARCH=um

N.B. : notiamo che il supporto dei moduli è richiesto soltanto se li abbiamo abilitati a livello del kernel (altrimenti basta il comando make linux ARCH=um);

copiamo ora tutte le directories sotto / dei filesystems della nostra macchina reale (/bin , /boot , etc...) sotto /fs/ubuntufs/ (il filesystem di UML) con il comando

#cp -R / /fs/ubuntufs

ora possiamo smontare il nostro filesystem con il comando

#umount /fs/emptyfs.ext3.4096

ora spostiamoci nella directory di compilazione del kernel UML (nell'esempio /usr/src/uml) e lanciamo il nostro kernel UML con il comando :

#cd /usr/src/uml

#./linux ubd0=/fs/emptyfs.ext3.4096 con0=xterm eth0=tuntap,tap0 mem=64M

Dopo qualche secondo si apre una finestra di terminale nella quale vediamo i messaggi di boot del kernel UML.

Le opzioni passate al kernel UML hanno il seguente significato :

udb0=/fs/emptyfs.ext3.4096 : dice al nostro kernel UML di usare come filesystem quello in /fs/emptyfs.ext3.4096
con0=xterm : dice al kernel UML di utilizzare come periferica di ouput per il messaggi di avvio del kernel la finestra di terminale xterm
eth0=tuntap,tap0 : dice al kernel UML di utilizzare come interfaccia di rete quqlle di tunneling tap0, che comporta il caricamento del modulo del kernel reale tuntap
mem=64M : dice al kernel UML di avviare il sistema in modalità utente con 64Mbytes di memoria. Questo parametro può assumere valori di 16M, 32M, 64M e 128M

performed by whiterabbit