BR

Introduzione

User Mode Linux (UML) è una caratteristica del kernel Linux che permette l'esecuzione di un kernel 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 compilato 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/src/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

• 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

CategoryDaRevisionare