# [How-To] Xen -installation

## -KuRGaN-

Présentation

Xen est un para-virtualiseur qui permet de faire tourner plusieurs systèmes virtuels sur une seule machine physique. Un peu comme VmWare mais en mieux   :Wink:  .

Pour plus d'info sur Xen, consulter le site de Xen et Wikipédia

Configuration du système

Tout d'abord, pour de meilleures performances, il faut s'assurer d'avoir au minimum la version 3.4.4 de gcc.

Ensuite il faut passer les UseFlags nptl nptlonly à glibc:

```
echo 'sys-libs/glibc nptl nptlonly' >> /etc/portage/package.use
```

Puis il faut recompiler tout le système afin de prendre en compte les modifications:

```
emerge -eD world
```

Installation de xen

Il faut maintenant installé le paquet xen-sources contenant le noyau xen et xen, qui en dépend, qui est le daemon xen.

```

echo "app-emulation/xen ~x86" >> /etc/portage/package.keywords

echo "sys-devel/dev86 ~x86" >> /etc/portage/package.keywords

echo "sys-kernel/xen-sources ~x86" >> /etc/portage/package.keywords

echo "sys-kernel/xen-sources" >> /etc/portage/package.unmask

emerge xen-sources
```

Compiler le kernel du dom0

Nous allons maintenant compiler un kernel pour le dom0:

```

cd /usr/src/linux-xxxx-xen

make ARCH=xen menuconfig
```

Voici des modules importants à mettre en dur dans le dom0:

```

XEN --->

[*] Privileged Guest (domain 0)

[*]  Block-device backend driver

[*]  Network-device backend driver

[ ] Block-device frontend driver

[ ] Network-device frontend driver

[ ]   Piplined transmitter (DANGEROUS)

[*] Scrub memory before freeing it to Xen

Device Drivers ---> 

 Networking support ---> 

  Networking options ---> 

  [*] 802.1d Ethernet Bridging</pre>
```

Ensuite il faut compiler le kernel et copier l'image dans /boot :

```

make && make modules_install

cp vmlinuz /boot/xen3-dom0
```

Configuration de grub

L'hyperviser de Xen se trouve dans /boot/xen3.gz, il est lancé en même temps que le noyau.

Editer le grub.conf:

```

title  Gentoo Xen3

root   (hd0,0)

kernel /xen.gz dom0_mem=128M 

module /xen3-dom0 root=/dev/hda3

```

L'option dom0_mem permet de spécifier la quantité de Ram alloué au dom0, elle peut prendre le suffixe B(byte), K(kilobyte), M(megabyte) et G(gygabyte). 

PS: Ce how-to ne serat pas mis à jour aussi souvent que celui là. Je vais ensuite faire un how-to sur la configuration de Xen que je posterai également sur ce forum.

Sur ce, bonne virtualisation à tous   :Wink: 

----------

## creuvard

Voyant que le lien que tu proposes semble down je me permets de continuer un peu ce HowTo. (Je prendrais les mêmes notations histoire de faire une continuité)

Compiler le kernel du domU

Nous allons maintenant compiler un kernel pour le domU:

```

cd /usr/src/linux

make menuconfig

```

La seule différence avec la configuration du Dom0 se trouve dans la rubrique XEN:

```

 -> XEN

[ ] Privileged Guest (domain 0)                                                                      

[ ] PCI device backend driver                                                                        

      PCI Backend Mode (Virtual PCI)  --->                                                         

[ ]   PCI Backend Debugging                                                                       

< > Block-device backend driver                                                                   

< >   Block Tap support for backend driver (DANGEROUS)                                              

< > Network-device backend driver                                                                  

[ ]   Pipelined transmitter (DANGEROUS)                                                              

< >   Network-device loopback driver                                                               

< > TPM-device backend driver                                                                      

<*> Block-device frontend driver                                                                  

<*> Network-device frontend driver                                                                 

< > Block device tap driver                                                                        

< > TPM-device frontend driver                                                                     

[*] Scrub memory before freeing it to Xen                                                          

[ ] Disable serial port drivers   

```

Ensuite il faut compiler le kernel et copier l'image dans /boot : 

```

make && make modules_install

cp vmlinuz /boot/xen3-domU

```

La configuration du noyau est maintenant terminée. Il faut construire une image du système virtuel que l'on va lancer.

Construction d'une image Gentoo

Soit 2 répertoires, 1 dans lequel nous allons y construire notre image et un autre qui nous servira pour monter cette image.

```

mkdir -p /mnt/xen/xen_images/

mkdir -p /mnt/xen/xen_server/

```

On construit dans le répertoire xen_images 2 fichiers images, une pour la swap (de 512Mo) et une pour le système en tant que tel (de 4Go).

```

cd /mnt/xen/xen_images/

dd if=/dev/zero of=/mnt/xen/xen_images/gentoo1_swap.img bs=1M count=512

dd if=/dev/zero of=/mnt/xen/xen_images/gentoo1.img bs=1M count=4000

```

On crée ensuite des sytèmes de fichiers pour ces 2 images.

```

mkswap  /mnt/xen/xen_images/gentoo1_swap.img

mke2fs -j /mnt/xen/xen_images/gentoo1.img

```

Répondez oui à la question qui vous est posée.

```

mke2fs 1.38 (3-May-2006)

/mnt/xen/xen_images/gentoo1.img is not a block special device.

Proceed anyway? (y,n) y

```

Une fois ceci fait on peut maintenant monter l'image (ce qui va nous permettre d'y installer Gentoo dedans).

```

mount -o loop /mnt/xen/xen_images/gentoo1.img /mnt/xen/xen_server/

```

A ce stade on peut maintenant traiter le répertoire /mnt/xen/xen_server/ comme un répertoire normal. (Il sera l'équivalent de /mnt/gentoo dans la doc ) 

On peut, à partir d'ici, reprendre la doc a partir du  Chapitre 5

Notez que vous devez sauter la Configuration du  noyau  et l'installation du Chargeur de démarrage

Notez que pour éviter un Warning de Xen (j'ai plus le message exacte   :Embarassed:  ) il est préférable comme pour l'hôte de compiler votre système avec le CFLAG -mno-tls-direct-seg-refs et un gcc supérieur à 3.3

```

echo "<=sys-devel/gcc-3.3.6" >> /etc/portage/package.mask

emerge -e system

```

Pour le fstab les partitions que vous choisirez pour monter la racine / et la swap seront virtuelles vous pouvez donc prendre n'importe quoi a condition de garder les noms en mémoire car on doit s'en resservir ensuite   :Sad: 

Exemple:

```

# <fs>                  <mountpoint>    <type>          <opts>          <dump/pass>

# NOTE: If your BOOT partition is ReiserFS, add the notail option to opts.

/dev/hda1               /               ext3            noatime         0 1

/dev/hda2               none            swap            sw              0 0

#/dev/cdroms/cdrom0     /mnt/cdrom      iso9660         noauto,ro       0 0

#/dev/fd0               /mnt/floppy     auto            noauto          0 0

# NOTE: The next line is critical for boot!

proc                    /proc           proc            defaults        0 0

# glibc 2.2 and above expects tmpfs to be mounted at /dev/shm for

# POSIX shared memory (shm_open, shm_unlink).

# (tmpfs is a dynamically expandable/shrinkable ramdisk, and will

#  use almost no memory if not populated with files)

shm                     /dev/shm        tmpfs           nodev,nosuid,noexec     0 0 

```

Maintenant il est tant de sortir de votre prison chroot en démontant ce qui doit l'être (cf la doc)

```

exit

cd

umount /mnt/xen/xen_server/dev  /mnt/xen/xen_server/proc  /mnt/xen/xen_server/

```

Configuration du fichier qui nous servira à lancer l'image Gentoo

On a par défaut les fichiers de configuration se trouvent dans /etc/xen

```

cd /etc/xen/

```

Avec son éditeur favori on crée le fichier gentoo1 qui devra ressembler à cela.

```

name = "Image Gentoo1"         

kernel = '/boot/xen3-domU'       

memory = 64                     

disk = 'file:/mnt/xen/xen_image/gentoo1.img,hda1,w','file:/mnt/xen/xen_image/gentoo1-swap.img,hda2,w']

root = '/dev/hda1 rw'

vif = [ ' ' ] 

```

name : est donc le nom du système virtuel.

memory : la dimension de la RAM que l'on lui aloue

disk :   il prend en paramètre les images que l'on a construites juste avant.

vif : C'est pour la configuration réseau; Xen peut simuler jusqu'a 7 cartes réseau par système virtuel. Si vous souhaitez 2 cartes il suffit de mettre vif = [ ' ', ' ' ] , si vous laissez nulle la valeur des paramètres Xen attribuera tout seul une adresse MAC à vos cartes réseau virtuelles. Si vous souhaitez leur attribuer une adresse MAC voici la syntaxe => vif=[ 'mac=00:16:3e:01:01:01,bridge=mybridge' ]  Plus d'informations sur le réseau en image ici (page en Anglais)  

A ce stade il ne reste plus grand chose a faire   :Cool: 

Il faut lancer le daemon xend:

```

/etc/init.d/xend start

rc-update add xend default

```

Et pour finir lancer notre première Gentoo virtuelle:

```

xm create -c gentoo1

```

Et normalement tout devrait se lancer normalement   :Twisted Evil:   :Twisted Evil: 

Liste de commande utile pour xen:

xm list

xm shutdown nom_de_l'image

xm destroy nom_de_l'image

xm info

xm dmesg

xm top

Rmq:

J'ai eu un message d'erreur en lançant les images

 *Quote:*   

> 
> 
> Using config file "gentoo1".
> 
> Error: Device 769 (vbd) could not be connected. Backend device not found. 
> ...

 

Que j'ai résolu en recompilant  app-emulation/xen avec le useflag custom-cflags (cas isolé...? en tout cas si ca peux aider quelqu'un   :Wink:  )

```

echo "app-emulation/xen custom-cflags" >> /etc/portage/package.use

emerge xen

```

J'espère que ca servira à quelqu'un et que je n'ai pas laissé trop de fautes d'orthographe.

Voialà   :Very Happy: 

----------

