UserModeLinux

De ClissXXI.

UML ou User-mode Linux est un moyen de lancer un deuxième noyau Linux, utilisable sans être root. C'est en fait un portage du noyau Linux, non pas pour une architecture matérielle, mais pour lui-même. Un portage de Linux pour Linux! Cela a des points communs avec l'Émulation.

UML est intégré dans le noyau officiel (kernel.org) depuis un bon moment.

Sommaire

Compilation du noyau utilisateur

C'est très simple: on compile le noyau Linux avec le paramètre ARCH=um pour chaque commande.

wget http://kernel.org/pub/linux/kernel/v2.6/linux-2.6.17.13.tar.bz2
tar xjf linux-2.6.17.13.tar.bz2
cd linux-2.6.17.13
make defconfig ARCH=um
make xconfig ARCH=um # facultatif; pensez à activer HOSTFS si besoin
make ARCH=um
strip linux
make modules_install ARCH=um INSTALL_MOD_PATH=uml-modules/

Cf. Building from source chez UML.

Des options que j'active:

  • MAGIC_SYSRQ: active l'équivalent de Alt+ImprÉcr, utilisable depuis uml_mconsole
  • HOST_2G_2G: contourne un problème de certains noyaux hôte (cf. plus bas)
  • HOSTFS: possibilité de monter des répertoires de la machine hôte - attention à la sécurité)
  • STATIC_LINK: compiler le noyau en statique (pas de dépendance sur des bibliothèques partagées .so)

Il y a également des patches à essayer [1]:

  • hôte/host:
    • skas3 - meilleures performances (dossier skas3-2.6)
  • invité/guest:
    • exec support: permet de lancer des commandes shell avec uml_mconsole (ex: [2]) - Jeff Dike recommande cependant de passer par login ou SSH, ce patch a peu de chance d'être inclus officiellement, voir le bouquin au chapitre 8 (p.181).

Construction du système de base

On se propose de construire et de lancer un système UML sans aucun accès root.

Vraisemblablement, ce n'est pas possible facilement. Cela est dû au manque d'outil en mode utilisateur pour travailler directement sur des systèmes de fichiers ext3.

Tentative 1

Essayons de créer un système complet, sans faire d'image, et en possédant tous les fichiers:

La dernière version de debootstrap propose une variante fakechroot qui permet de l'utiliser sans accès root:

export PATH=/usr/local/sbin:/usr/sbin:/sbin:$PATH # pour trouver la commande 'chroot'
fakechroot /usr/sbin/debootstrap --variant=fakechroot sarge sarge-uml/ http://localhost/mirrors/debian
/usr/src/linux-2.6.17.13/linux  root=/dev/root rootflags=/home/sylvain/tests/uml/debian/sarge-uml/ rootfstype=hostfs

Résultat: cela ne fonctionne pas, à mon avis parce que dans ce cas précis sarge-uml/dev est un lien symbolique vers /dev.

Tentative 2

Essayons à partir d'une image UML déjà opérationnelle. Le principe est de monter le système de fichier hôte avec hostfs, puis de faire un mount -o loop depuis le UML sur l'image disque à bootstrap-per. Cela permet de monter l'image sans avoir de privilèges super-utilisateur.

mount none host/ -t hostfs -o /home/sylvain/tests/uml/debian
cd host/
mkdir loop/
mount image -o loop loop/
ls loop/ # -> bin  boot  dev  etc  ...

D'après le Rob's quick and dirty UML howto, nul besoin d'une image disque pour jouer avec UML. Ni donc pour monter une image:

$ ./linux rootfstype=hostfs rw init=/bin/sh quiet
# insmod /usr/src/linux-2.6.20-um/drivers/block/loop.ko
# mount image -o loop loop/
# ls loop/ # -> bin  boot  dev  etc  ...

Excellent!!! Cela ressemble vaguement à un chcontext de VServer.

Notez l'option peu documentée rootfstype. init pointe sur le chemin complet d'un exécutable (binaire ou même script). rootstrap fonctionne sur ce principe.

En mode root

Faute de mieux, utilisons sudo:

mkdir loop/
# image de 1Go, à trous (espace disque progressif)
dd if=/dev/null of=image count=0 bs=1G seek=1
# on formatte en ext3
/sbin/mkfs.ext3 -F image

sudo mount image loop/ -o loop
sudo debootstrap sarge loop/ http://192.168.1.60/mirrors/debian

# configuration de la console:
sudo grep -v tty loop/etc/inittab > inittab.work
sudo echo "1:2345:respawn:/sbin/getty 38400 console linux" >> inittab.work
sudo mv inittab.work loop/etc/inittab

# configuration réseau:
cat <<'EOF' > interfaces.work
auto lo
iface lo inet loopback
EOF
sudo mv interfaces.work loop/etc/network/interfaces

# fake mtab and fstab
cat <<'EOF' > fstab.work
proc            /proc           proc    defaults        0 0
/dev/ubda       /               auto    defaults,errors=remount-ro 0 1
EOF
sudo mv fstab.work loop/etc/fstab 

sudo umount loop/

Optimiser la taille de l'image pour la distribuer

Une image UML contient souvent des zones vides, où il n'y a pas encore de fichiers.

L'image ci-dessus réserve 1Go mais n'en occupe que 230Mo grâce à la création d'image "à trous" (sparse en anglais).

$ ls -lh image
-rw-r--r--  1 sylvain sylvain 1,0G 2006-09-18 15:55 image
$ du -sh image
234M    image

D'autres méthodes (dd sur /dev/zero par exemple) n'en tiennent pas compte.

df -h dans UML indique une utilisation de 178Mo, donc on doit pouvoir encore améliorer (comment?). Éviter e2defrag, qui est obsolète et corrompt les systèmes de fichier. Piste: copier les fichiers dans une nouvelle image et supprimer l'ancienne - défragmentation à la volée; inconvénient: les secteurs d'amorçages dont perdus (si vous les utilisez avec qemu, sinon aucune importance).


Pour optimiser une image "pleine":

cp --sparse=always image image.sparse

Pour envoyer une image par le réseau en respectant les trous:

tar cSf image.tar image # S pour "sparse"

Réseau

Imaginez un câble virtuel qui relie la machine hôte et la machine UML, une carte carte réseau virtuelle à chaque bout. Chaque carte a une adresse IP, mais comme sur un réseau classique, les deux cartes ne doivent pas avoir la même adresse.

Mode root avec tuntap

host# sudo /usr/src/linux ubda=sarge-debootstrap eth0=tuntap,,,192.168.1.101

Notez les messages d'UML indiquant la mise en place d'une interface tuntap tap0, une route pour accéder à la machine virtuelle, et un partage de connexion pour que la machine virtuelle puisse accéder au réseau extérieur.

Puis dans UML:

uml# ifconfig eth0 192.168.1.201

Mode semi-root avec tuntap

Pour utiliser tuntap, il faut créer à l'avance (et en mode root) une interface tap0 et lui assigner une adresse IP.

# tunctl -u sylvain
Set 'tap0' persistent and owned by uid 1000

Puis il faut donner des droits aux utilisateurs non-privilégiés d'utiliser tuntap (en mode root aussi):

chmod 666 /dev/net/tun

ou bien ajouter l'utilisateur au groupe "uml-net" (uniquement sous Debian?)

$ sudo adduser sylvain uml-net
Adding user `sylvain' to group `uml-net' ...
Done.

C'est une solution efficace mais qui nécessite plusieurs étapes de préconfiguration en mode root.

Pour accéder au réseau et en être accessible, configuration manuelle (cf. uml_net pour l'automatisation):

# Côté invité:
ifconfig eth0 192.168.1.200
# Même config routeur que l'hôte:
route add default 192.168.1.1 eth0
# Même config DNS que l'hôte:
echo "nameserver 192.168.1.1" > /etc/resolv.conf
# Côté hôte:
/sbin/ifconfig tap0 192.168.1.150 netmask 255.255.255.255
# Autoriser le routage des paquets
echo 1 > /proc/sys/net/ipv4/ip_forward
# Exception: cette adresse ne passe pas par eth0:
route add -host 192.168.1.200 dev tap0

# Pour être visible du réseau, il faut annoncer cette IP sur la carte physique:
echo 1 > /proc/sys/net/ipv4/conf/tap0/proxy_arp
arp -Ds 192.168.1.200 eth0 pub

# Au moment de partir, on enlève l'annonce ARP:
arp -d 192.168.1.200 dev eth0

Cela ne fonctionne que si l'on utilise le même réseau que l'hôte. Dans le cas contraire (ex: 172.20.0.0/16), il faudrait ajouter des routes sur toutes les machines du réseau physique pour savoir comment accéder à ce réseau différent (ou alors utiliser l'hôte comme routeur et (D)NATer le traffic).

Autre solution similaire: avec un pont (bridge).

brctl addbr br0
ifconfig eth0 0.0.0.0 promisc
brctl addif br0 eth0
dhclient br0

tunctl -u sylvain
brctl addif br0 tap0
# invité: ifconfig eth0 192.168.1.200

Le pont se chargera d'écouter les paquets sur le réseau à destination de l'adresse du tap0 côté invité, et de les lui envoyer (pas besoin de ip_forward, ni de arp, ni d'une route spéciale pour contacter l'invité, ni d'une IP côté hôte pour tap0). Un inconvénient: la reconfiguration du réseau de la machine hôte. Le super-avantage étant de pouvoir configurer l'invité via le DHCP du réseau physique!

Mode semi-root avec tuntap (2)

Mettre l'utilisateur concerné dans le groupe uml-net. Ce groupe a accès au programme setuid /usr/lib/uml/uml_net, qui peut lancer et configurer des interfaces tuntap. La sécurité du procédé n'est pas grande (l'utilisateur peut créer de nouvelles interfaces réseau et perturber iptables par exemple), mais est facile à mettre en place.

host# /usr/src/linux ubda=sarge-debootstrap umid=deb eth0=tuntap,,,10.10.10.10
uml# ifconfig eth0 10.10.10.11
uml# route add default gw 10.10.10.10

Note: la configuration automatique côté hôte nécessite uml_net (partage de connexion, route vers la machine UML...).

Mode utilisateur avec slirp

Lancer UML avec une interface slirp, en utilisant le binaire 'fullbolt' (qui s'affranchit de la limitation débit de 10ko/s dans slirp 'classique'):

host# /usr/src/linux ubda=sarge-debootstrap umid=deb eth0=slirp,,/usr/bin/slirp-fullbolt

Dans UML, quelques étapes spécifiques à slirp sont nécessaires:

# Configurer l'interface sur 10.2.0.15 (IP de choix pour slirp d'après la doc?)
ifconfig eth0 10.2.0.15
# Utiliser la redirection DNS 10.0.2.3
echo "nameserver 10.0.2.3" > /etc/resolv.conf
# Ajouter une route par défaut vers eth0:
route add default dev eth0

Note: ping ne fonctionne pas, car il nécessite un accès root (sur l'hôte, ping est d'ailleurs souvent setuid).

Note 2: dans QEMU, l'IP assignée est 10.0.2.15. Le DNS est également 10.0.2.3. La configuration se fait automatiquement via un serveur DHCP intégré.

  • Cf. Slirp dans le UML HOWTO.

/etc/network/interfaces

Voici comment configurer automatiquement le réseau au démarrage d'UML, dans son fichier interfaces:

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static

# eth0=tuntap,,,10.10.10.1
#  address 10.10.10.10
#  netmask 255.0.0.0
#  gateway 10.10.10.1

# eth0=slirp,,/usr/bin/slirp-fullbolt
  address 10.2.0.15
  netmask 255.0.0.0
  dns-nameservers 10.0.2.3
  up route add default eth0

(dns-nameservers nécessite le paquet resolvconf)

Autre solution pour gérer automatiquement les DNS: installez un serveur DNS dans l'UML, et évitez ainsi de vous faire suer à déterminer ceux de l'hôte. In-dé-pen-dan-ce ;) À moins que vous n'ayez besoin du serveur DNS de votre réseau interne.

Lancer un UML en tâche fond

./linux ubda=... con=null &


Versions

La version officielle est vraisemblablement celle intégrée au noyau kernel.org.

Aucune version de développement n'est vraisemblablement accessible.

La version kernel.org ne compile pas nécessairement (ex.).

Jeff Dyke publie de temps à autre un combo précompilé noyau + image FC5 sur la page d'accueil du site.

Patches

Cf. http://www.user-mode-linux.org/~blaisorblade/

Clarifions un peu:

  • skas3+sysemu: patch pour le noyau hôte pour gagner en rapidité,
  • -bb: patch pour le noyau invité, fonctionnalités supplémentaires en test. À utiliser en bloc, ou en choissant une fonctionnalité en particulier parmi un jeu de patches séparés (splitout/broken-out). Il y a un jeu de patches correspondants pour les uml-utilities.

C'est un peu confus sur le site, mais c'est tout.

TODO: il y a aussi les patches pour uml-utilities mais je ne sais pas à quoi ils servent [3].

Liens

Dépannage

Kernel panic - not syncing: start_userspace : expected SIGSTOP, got status = 256

Cf. http://www.mail-archive.com/user-mode-linux-devel@lists.sourceforge.net/msg03414.html

Votre noyau (hôte) est, si j'ai bien compris, mal configuré. Recompilez-le ou utilisez-en un autre.

Vous pouvez également activer CONFIG_HOST_2G_2G dans la configuration du noyau UM.

Outils personnels