Première utilisation d'UML

Pour la première utilisation d'UML, nous allons installer quelques outils et utiliser des briques existantes (noyaux UML et systèmes de fichiers).

Documentation

Ajoutez à vos favoris un lien vers The User-mode Linux Kernel Home Page. Le présent tutoriel en fait essentiellement un résumé et une traduction de ce site de référence (que j'appelerai UMLKHP par la suite). N'hésitez pas à le consulter pour aller plus loin !

Installation des outils

Créez un répertoire UML.

Téléchargez uml_utilities_20040406.tar.bz2 depuis UMLKHP (ou ma copie locale) et décompressez dans UML.

En root, dans le répertoire UML/tools créé, tapez 'make all' puis 'make install DESTDIR=/'.

Les outils uml_moo, uml_mconsole, uml_switch (et d'autres) sont maintenant installés dans le répertoire /usr/bin ; nous découvrirons peu à peu leur utilité.

Téléchargement des "briques"

Noyau UML

Créez un répertoire UML/Noyaux.

Téléchargez linux-2.4.27.bz2, décompressez-le dans UML/Noyaux et rendez-le exécutable ('chmod +x linux-2.4.27').

Note : des noyaux déjà compilés sont également disponibles sur le site UMLKHP mais ils sont relativement vieux et lorsqu'on tente de les faire tourner sur RedHat 9 (entre autres), l'erreur suivante apparait : Kernel panic: outer trampoline didn't exit with SIGKILL. Ce bug d'UML a été corrigé à partir du patch 2.4.20-4. (source : FAQ d'usermodelinux.org). Vous découvrirez dans une autre section comment construire vos propres noyaux UML.

Système de fichiers

Créez un répertoire UML/SysFich.

Téléchargez root_fs_slack8.1.bz2 depuis UMLKHP (ou cliquez ici pour télécharger ma version locale) et décompressez-le dans le répertoire UML/SysFich.

Première utilisation

Placez-vous dans le répertoire UML/ et tapez 'Noyaux/linux-2.4.27 ubd0=SysFich/root_fs_slack8.1'. La machine UML démarre et 3 fenetres correspondant à 3 consoles supplémentaires de l'UML s'ouvrent. Choisissez une des fenetres et connectez-vous comme root (pas de mot de passe) et explorez quelques instants votre machine virtuelle.

Arretez proprement la machine UML en tapant 'shutdown -h now' (dans la fenetre où vous vous etes connecté à l'UML bien sur).
Note : si le noyau de votre hote a été patché pour supporter le mode SKAS, faire 2 "Crtl-C" dans le shell depuis lequel la machine UML a été démarrée pour récupérer la main après l'affichage du "Power down." de la machine UML.

Accès aux fichiers de l'hote

Une manière simple pour la machine UML de partager des fichiers avec l'hote est d'utiliser le système de fichiers virtuel hostfs pour monter depuis la machine UML un répertoire de l'hote.

Démarrez une machine UML. Dans la machine UML, créez un répertoire /mnt/hote puis tapez 'mount none /mnt/hote -t hostfs'. Le répertoire /mnt/hote de la machine UML correspond maintenant au répertoire racine (/) de l'hote.

Pour en savoir plus sur les options disponibles et sur la manière de construire un noyau disposant d'hostfs, voir user-mode-linux.sourceforge.net/hostfs.html

Plusieurs UMLs en meme temps : comment partager un système de fichiers

Il est bien sur possible de faire tourner plusieurs UMLs en meme temps. Mais on ne peut pas les démarrer sur le meme système de fichiers, car celà le corromprerait (d'ailleurs, avec l'UML précédente en fonctionnement, la tentative de lancement un 'Noyaux/linux-2.4.27 ubd0=SysFich/root_fs_slack8.1' supplémentaire se solde par un échec accompagné d'un message 

VFS: Cannot open root device "ubd0" or 62:00
Please append a correct "root=" boot option
Kernel panic: VFS: Unable to mount root fs on 62:00)

La première solution consiste à faire une copie du fichier root_fs_slack8.1 et de fournir cette copie pour le démarrage de la nouvelle machine UML. L'inconvénient est que si le système de fichiers est gros et que l'on doit démarrer beaucoup de machines UML, cela va prendre un espace disque considérable.

Le pilote du bloc UBD offre une autre solution : il permet d'enregistrer les écritures normalement faites sur le bloc dans un bloc séparé. Il suffit donc de partager en lecture seulement entre les différentes machines UML le système de fichiers initial et de munir chaque machine UML d'un fichier COW (Copy On Write) dans lequel elle enregistrera ses écritures. De cette manière, les données inchangées (la majorité) seront partagées et chaque UML n'aura qu'un petit fichier supplémentaire contenant ses changements. Au lancement de la machine UML, il suffit de faire précéder le nom du système de fichiers par le nom du fichier COW (si ce fichier n'existe pas dans le répertoire, il sera créé) et d'une virgule : linux ubd0=fichierCOW,systemedefichiers

Travaux pratiques :

  1. Lancez 2 UMLs munies d'un fichier COW chacune : 
    Noyaux/linux-2.4.27 ubd0=cow01,SysFich/root_fs_slack8.1
Noyaux/linux-2.4.27 ubd0=cow02,SysFich/root_fs_slack8.1
  2. Dans la première machine, créez un fichier (par exemple 'echo "hello" > toto').
  3. Vous pouvez vérifier que ce fichier n'existe pas pour la deuxième machine.
  4. Arretez les 2 machines.
  5. Regardez la taille sur le disque de l'hote du fichier root_fs_slack8.1 : 206032, à comparer avec la taille de cow01 : 460 ! (note : utilisez l'option -s de la commande ls car un fichier COW est un vrai gruyère !)
  6. Lancez à nouveau une machine UML en indiquant un fichier COW existant : 'Noyaux/linux-2.4.27 ubd0=cow01,SysFich/root_fs_slack8.1'. Le fichier toto est toujours là. Arretez la machine UML.
  7. Lancez à nouveau une machine UML en n'indiquant que le système de fichiers ; le fichier toto n'existe pas. Arretez la machine UML.
  8. Effacez le fichier cow01.

Attention : une fois qu'un fichier COW est créé par rapport à un système de fichiers, il ne faut plus toucher au système de fichiers (ne plus démarrer directement avec ce système de fichiers, ne pas le modifier, ne pas le déplacer).

Il est possible de fusionner les modifications enregistrées dans un fichier COW avec le système de fichiers initial en utilisant l'utilitaire uml_moo : uml_moo fichier_COW systeme_fichiers_fusion.

Travaux pratiques :

  1. Lancez une UML avec un fichier COW vierge : 'Noyaux/linux-2.4.27 ubd0=cowA,SysFich/root_fs_slack8.1'
  2. Dans la machine UML, créez un fichier (par exemple 'echo "hello" > toto').
  3. Arretez la machine UML.
  4. Fusionnez le fichier COW et le système de fichiers : 'uml_moo cowA nouveauSF'
  5. Lancez à nouveau une machine UML en utilisant le nouveau système de fichiers : 'Noyaux/linux-2.4.27 ubd0=nouveauFS'. Le fichier toto existe.
  6. Arretez la machine UML.

Pour plus de détails, voir la page de référence Sharing Filesystems between Virtual Machines.

Plusieurs UMLs en meme temps : nommer les machines virtuelles

Lorsqu'on lance plusieurs machines UML, il peut être pratique de leur donner un identifiant à chacune (par exemple de manière à distinguer les fenêtres qui se sont ouvertes pour la première de celles qui se sont ouvertes pour la suivante). Pour cela, il suffit ajouter une clause umid=nom_de_l-UML au lancement.

Essayez par exemple 'Noyaux/linux-2.4.27 umid=ordi1 ubd0=nouveauSF', vous verrez apparaître "(ordi1)" dans la barre de titre des consoles virtuelles.

Outil de gestion des machines UML

Il existe un outil de gestion des machines UML, l'UML management console, permettant de piloter partiellement de l'extérieur une machine UML lancée.

Au démarrage d'une machine UML, vous voyez une ligne 

mconsole (version 2) initialized on /home/galtier/.uml/oIm6Lc/mconsole
Démarrez la console de management en précisant le nom de socket qui a été créée pour communiquer avec l'UML : 
uml_mconsole oIm6Lc

Note : si un identifiant a été donné au lancement de la machine UML grace à l'option umid, il suffit de préciser cet identifiant, par exemple uml_mconsole ordi1.

Essayez les commandes suivantes (depuis la console de gestion) :

Lorsque vous n'avez plus besoin de la console de gestion, arretez-là grace à un 'quit'.

Cet outil sera surtout utile plus tard, pour ajouter une carte réseau par exemple.

Applications graphiques

Cet aspect sera couvert après les explications concernant la mise en réseau d'une machine UML.