<div class='slidealt'>Projets de recherche de virtualisation <a title='kvm en logiciel libre pour ARM multicoeur' href='/fr/innovation/'>pour les systèmes embarqués et le cloud</a></div> <div class='slidealt'>Solutions de virtualisation pour systèmes <a title='solutions en logiciels libres de virtualisation pour ARMv7-ARMv8' href='/fr/solutions/'>hétérogènes multicoeur ARM</a></div> <div class='slidealt'>Faites appelle à des <a title='services de full virtualisation pour kvm sur coeur ARM' href='/fr/services/'>services de virtualisation sur mesure</a></div> <div class='slidealt'>Expérimentez des extensions de <a title='virtualisation pour plateformes hétérogènes à base de processeurs ARM' href='/fr/produits/'>virtualisation KVM</a></div> <div class='slidealt'>Virtualisation KVM des E/S's pour coeurs ARMv7, ARMv8 <a title='extensions de virtualisation de plateforme VFIO des E/S par kvm sur arm en logiciel libre' href='/fr/solutions/guides/vfio-sur-arm/'>par extensions VFIO/IOMMU</a></div>

La Virtualisation KVM pour les Architectures ARMv8

Comment installer l'environnement de développement KVM pour les SoCs ARM 64-bits

Ceci est un guide pour la virtualisation KVM sur l'architecture ARMv8 et illustre comment mettre en place un environnement de développement KVM sur les processeurs ARM64. Il présente comment exécuter une machine virtuelle d'invité en dessus d'un hôte KVM Linux sur une architecture matérielle ARM64. Ce guide utilise les "Foundations Models" d'ARM pour simuler l'environnement ARMv8.

Introduction au guide de mise en place de KVM pour ARM 64-bits

L'architecture ARMv8 introduit le support 64 bits à l'architecture ARM, y compris la compatibilité descendante (ou rétrocompatibilité) pour le logiciel 32-bit. En plus d'améliorer les performances des processeurs ARM, l'architecture ARMv8 offre par ailleurs une faible consommation d'énergie.

Il existe des outils pour compiler le logiciel pour l'architecture ARMv8: il y a d'une part des compilateurs croisés pour générer les binaires ARM64 (certaines distributions comme Ubuntu les incluent dans leurs propres dépôts) et d'autres part des images de systèmes de fichiers déjà compilés à partir de GNU/Linux de base. Comme alternative, Virtual Open Systems propose de créer un système de fichiers customisé à l'aide d'outils bootstrap et ces outils sont également disponibles dans les dépôts d'Ubuntu.

L'objectif principal de ce guide est de démontrer comment faire fonctionner un système d'exploitation d'invité à l'intérieur d'un hôte linux KVM s'exécutant sur ARM64, alimenté par le noyau Linux. L'utilisation de Linux apporte l'avantage du module KVM pour virtualiser des machines virtuelles invitées. Ce scénario est tout à fait commun: nous aurons un système, appelé Hôte, qui fournira les capacités de la virtualisation, son noyau doit être compilé sur mesure (customisé) pour inclure tous les modules nécessaires. L'Invité est le système virtualisé par l'hôte et ne nécessite pas des modules particuliers dans son noyau. Pour simplifier les choses, à la fois hôte et invité se partageront la même architecture (ARM64) et utiliseront le même noyau avec le même espace utilisateur (système de fichiers).

Attention!

Tout au long de ce guide, nous nous référerons à ARM64, ARMv8 ou aarch64 pour indiquer la même architecture.

Dans les sections suivantes, nous allons passer en revue l'ensemble de ces sujets, en fournissant des descriptions détaillées pour atteindre un environnement complètement fonctionnel, apte à la virtualisation et prêt à être déployé sur les prochaines plateformes de développement. Dans ce guide, nous validons ces systèmes en utilisant les "Foundations Models" d'ARM, qui sont un moyen pratique pour simuler l'environnement ARMv8.

Composants Requis

Les étapes décrites dans ce guide sont basées sur le système Ubuntu 13.04 (codename Raring), mais tous les outils référencés par le présent guide sont également disponibles pour d'autres distributions Linux, comme Debian et Fedora. Voici la liste des composants nécessaires:

bullet Compilateur croisé ARM 64-bits Le compilateur croisé utilisé pour compiler vers l'architecture 64-bits ARMv8.

bullet Foundation Model ARMv8 Le Foundation Model, disponible gratuitement, utilisé pour émuler une plateforme ARMv8.

Les composants suivants constituent le système que nous simulons. Chacun des systèmes (hôte et invité) nécessite un noyau Linux, y compris un bootloader (ou bootwrapper) et une image de l'espace utilisateur (également appelé comme le système de fichier).

bullet Les images de l'espace utilisateur 64-bits pour l'Hôte et l'Invité Les images de l'espace utilisateur pour les systèmes que nous allons fonctionner.

bullet Noyaux ARM64 pour l'Hôte et l'Invité Les noyaux 64-bits ARM avec une capacité de KVM, qui est obligatoire pour le système hôte.

bullet Bootwrapper Bootloader pour démarrer le noyau hôte.

Obtenir le Compilateur Croisé ARM 64-bits

Nous allons utiliser le compilateur croisé disponible dans le dépôt d'Ubuntu 13.04:

$ sudo apt-get install gcc-aarch64-linux-gnu

Et tester si le compilateur a été ajouté correctement à la variable PATH:

$ which aarch64-linux-gnu-gcc
< Vous devriez obtenir le chemin du compilateur ici >

Tip

Étant donné que les versions précédentes d'Ubuntu ne fournissent pas ce paquet, il est nécessaire d'ajouter un dépôt Ubuntu Raring afin d'installer le compilateur croisé. Ce conseil s'applique également pour tout dérivé de Debian. Modifier votre fichier /etc/apt/sources.list et ajoutez la ligne suivante:

deb http://en.archive.ubuntu.com/ubuntu/ raring universe

Puis poursuivrez les commandes suivantes pour installer le paquet:

$ sudo apt-get update && sudo apt-get install gcc-aarch64-linux-gnu

Attention!

Une fois que le compilateur est installé, il est fortement conseillé de supprimer le dépôt annexé et de mettre à jour à nouveau l'indice d'apt afin d'éviter des problèmes potentiels lors de la prochaine mise à jour du système.

Autrement, vous pouvez toujours télécharger manuellement depuis le dépôt d'Ubuntu les paquets et ses dépendances. Au moment de la rédaction de ce guide, les paquets nécessaires sont gcc-4.7-aarch64-linux-gnu-base, cpp-4.7-aarch64-linux-gnu, binutils-aarch64-linux-gnu, libgcc-4.7-dev-arm64-cross, libc6, libcloog-ppl1, libgmp10, libmpc2, libmpfr4, libppl-c4, zlib1g.

Le Foundation Model d'ARMv8

Les "Foundations Models" fournissent les développeurs ARM avec tous les outils nécessaires pour exécuter les systèmes ARMv8 avant la disponibilité d'une plateforme de développement. Ces modèles sont basés sur les Fast Models d'ARM, et ils sont gratuitement disponibles sur le site ARM, après inscription. Une fois connecté, l'URL de téléchargement du logiciel se trouve à la page http://www.arm.com/products/tools/models/fast-models/foundation-model.php.

En supposant que FM000-KT-00035-r0p8-52rel06.tgz est le nom du modèle téléchargé, alors nous pouvons l'extraire par:

$ tar -xf FM000-KT-00035-r0p8-52rel06.tgz

Le fichier exécutable de Foundation Model "Foundation_v8" se trouve dans le dossier Foundation_v8pkg/models/Linux64_GCC-4.1/. Nous pouvons l'ajouter à la variable*PATH*:

$ export PATH=$PWD/Foundation_v8pkg/models/Linux64_GCC-4.1/Foundation_v8/:$PATH

Les images de l'espace utilisateur 64-bits pour l'Hôte et l'Invité

Il existe différentes images de l'espace utilisateur et vous pouvez les télécharger à partir du dépôt de linaro. Dans ce guide, nous utilisons l'image OpenEmbedded (Minimale) (linaro-image-minimal-genericarmv8-20130526-319.rootfs.tar.gz). Vous pouvez vous reporter à cette page web pour essayer d'autres alternatives.

L'image NFS d'espace utilisateur pour l'hôte

Nous allons utiliser NFS pour monter l'image de l'espace utilisateur pour notre hôte. Cela nous permettra d'accéder au système de fichiers monté depuis la machine hôte réel, même lorsque l'hôte ARM est en cours d'exécution.

Pour exporter un répertoire via NFS nous devons installer le service NFS, qui est disponible dans presque toutes les distributions Linux. Par exemple, sous Ubuntu, nous pouvons installer le service NFS avec la commande suivante:

$ sudo apt-get install nfs-kernel-server nfs-common

Un répertoire racine NFS (/srv/nfsroot par exemple) doit être exporté dans le fichier /etc/exports:

/srv/nfsroot 192.168.1.20/255.255.255.0(rw,sync,no_root_squash,no_subtree_check,insecure)

Cette configuration exporte le répertoire /srv/nfsroot pour toutes les machines dans le sous-réseau 192.168.1.0/24. À ce point, le service NFS est configuré et nous devons donc redémarrer le processus de serveur:

$ sudo service nfs-kernel-server stop
$ sudo service nfs-kernel-server start

Pour plus d'informations sur NFS reportez-vous à la NFS-HOWTO officiel.

Maintenant, nous sommes prêts à créer le dossier /srv/nfsroot/ qui servira l'image d'hôte ARM, puis nous allons copier le système de fichiers d'hôte dedans:

$ sudo mkdir -p /srv/nfsroot/
$ sudo tar -xf linaro-image-minimal-genericarmv8-20130526-319.rootfs.tar.gz \
               -C /srv/nfsroot/

Pour le rendre disponible via NFS, nous ajoutons dans le fichier /etc/exports la configuration suivante:

/srv/nfsroot 192.168.1.20/255.255.255.0(rw,sync,no_root_squash,no_subtree_check,insecure)

Puis on redémarre le serveur NFS:

sudo service nfs-kernel-server restart

Identifiant ou inscription pour visualiser l'information complète