<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>

Portage du KVM sur Fast Models ARM Cortex-A15

Un guide étape par étape pour la virtualisation linux kvm sur les systèmes embarqués

Ce guide KVM-sur-ARM est un document étape par étape pour mettre en valeur la virtualisation par linux KVM sur des systèmes embarqués et des serveurs basés sur ARM. On commence par l'explication du portage de KVM sur ARM Cortex-A15 et big.LITTLE Fast Models. Ce guide aide à découvrir comment installer l'environnement pour développement de KVM sur les processeurs embarqués multi-coeur. Il fait partie d'une collection de guides techniques sur la virtualisation de Virtual Open Systems.

Introduction

Durant la dernière décennie la virtualisation a été reconnue en tant qu'outil puissant pour étendre les capacités de serveurs, permettant des technologies de rupture comme le cloud computing. Dans le même temps, la virtualisation a également été utilisée par des utilisateurs finaux, des chercheurs dans le domaine de la sécurité informatique, des administrateurs et développeurs de systèmes. La virtualisation a commencé à montrer ses atouts sur les plateformes mobiles et embarqués, mais également pour les ordinateurs de bureau et serveurs, pour lesquels une très large gamme de nouveaux cas d'utilisation peut être envisagée.

Le Kernel Virtual Machine de Linux (Linux KVM) est l'une des solutions de virtualisation le plus réussi et le plus puissant disponible sur le marché, permettant au noyau Linux de démarrer les systèmes d'exploitation invités sous un processus. Linux KVM a été conçu pour être portable, et a fait ses preuves dans un certain nombre d'architectures, comme Intel VT-x, AMD SVM, PowerPC et IA64, et dernièrement sur les plate-formes ARMv7 et ARMv8 (Cortex-A15, Cortex-A57 ..).

Ce document explique comment mettre en place un environnement de développement pour KVM/ARM sur Cortex-A15. Un système de Linux récent fonctionnel est supposé d'être utilisé par l'utilisateur pour le développement. Les instructions fournies supposent l'installation d'une version récente d'Ubuntu (11.10 au moment de cet rédaction), mais pourraient être ajustées pour d'autres distributions modernes. Après avoir suivi ce guide, l'utilisateur sera en mesure de démarrer une plate-forme de simulation Cortex-A15, avec une configuration fonctionnel de virtualisation KVM capable de démarrer un invité Linux.

Ce document guidera les lecteurs à travers un certain nombre d'étapes afin d'installer l'environnement de développement pour KVM sur Cortex-A15:

bullet Installation et paramétrage de la plate-forme de simulation. Nous utiliserons la plate-forme Fast Models d'ARM pour générer un environnement Cortex-A15.

bullet Installation d'un système Linux ARM Hôte. Nous compilerons un noyau Linux ARM qui nous pouvons démarrer sur notre plate-forme de simulation; Nous allons utiliser une image de base du système de fichiers pour démarrer un système fonctionnel.

bullet Compiler KVM et QEMU sur notre configuration. Nous allons activer le support de KVM dans le noyau Linux hôte, et construit QEMU avec le support KVM/ARM afin de démarrer un système invité.

bullet Démarrer une machine virtuelle invitée. En utilisons le noyau hôte et le système de fichiers déjà prêt, nous allons démarrer un système d'exploitation invité sous KVM/ARM.

Le système final, qui s'exécute avec un invité sous notre système Linux hôte, peut être illustrer comme suit:

/static/vosapp/images/guides/kvm_on_arm/images/guide_fig.png

Pour plus d'informations sur l'architecture matérielle consultez le manuel de référence d'architecture ARM pour les processeurs v7-a. D'autres documents liés incluent la documentation des extensions de la virtualisation ainsi que les Extensions de Large Physical Address (LPAE). Ceux-ci peuvent être trouvés sur le Centre d'informations ARM.

Plat-forme de Simulation

Nous utilisons le simulateur Fast Models d'ARM. Une version d'évaluation est disponible sur le Site web d'ARM. Cliquez sur le Download now bouton et passez à trouver les Fast Models Evaluation Linux. Un enregistrement avec ARM est nécessaire pour être en mesure de procéder au téléchargement du logiciel.

La dernière version de la plate-forme au moment de la rédaction de ce document est 8.3. Lors du téléchargement du logiciel, on peut aussi recevoir un fichier de licence pour une évaluation de 45 jours. Extraire le logiciel et lisez le instructions d'installation Installation_Guide.txt. Les instructions officielles affirment de supporter gcc 4.1.2 ou gcc 4.4.4, mais selon notre expérience les versions plus récentes offertes par les distributions modernes ont généralement tendance à mieux fonctionner.

À ce moment nous devons nous assurer que le système a installé tous les outils de développement standard. Sinon, nous pouvons les installer en utilisant les outils de gestion de paquets de la distribution, par exemple, sur Debian et Ubuntu:

$ sudo apt-get install build-essential xutils xutils-dev

Exécutez ./setup.bin et choisissez un chemin d'installation et l'emplacement du fichier de licence; Par exemple /home/user/ARM/. Il est également conseillé de modifier le fichier .bashrc de l'utilisateur actuel et ajouter une ligne comme ça:

$ source ~/ARM/FastModelsTools_8.3/source_all.sh

Dans le cas contraire cette commande devra être exécutée manuellement à chaque fois que nous avons besoin d'utiliser les Fast Models plate-forme de simulation.

Tip

Interface réseau

Dans certaines distributions le gestionnaire de licence risque de ne pas trouver eth0 ou assumer d'un HOSTID de 000000000000. Dans ce cas, nous avons besoin de configurer le système Linux utilisé, pour nommer la première interface réseau comme eth0; consultez la documentation de la distribution, ou consultez les instructions pour Fedora http://fedoraproject.org/wiki/Features/ConsistentNetworkDeviceNaming.

Réalisation d'une plate-forme de simulation

Après l'installation et la mise en place de Fast Models, nous pouvons exécuter sgcanvas afin de lancer l'outil Fast Models utilisé pour concevoir et compiler une plate-forme de simulation. Nous allons utiliser un modèle basé sur Cortex-A15 fourni par ARM; ouvrez le projet situé au FastModelsPortfolio_8.3/examples/FVP_VE/Build_Cortex-A15x1/FVP_VE_Cortex-A15x1.sgproj. Sinon, l'utilisation d'un modèle de Cortex-A15 multi-coeur est possible aussi.

Tip

Sur lstdc++ manquant

Si la compilation échoue sur un système 64 bits, se plaignant que lstdc++ ne peut pas être trouvé, essayez ce qui suit:

$ sudo ln -s /usr/lib/i386-linux-gnu/libstdc++.so.6 /usr/lib32/libstdc++.so

Nous pouvons maintenant compiler le modèle en allant à Projet>Build System. Si le System Canvas se plaint de GCC, assurez-vous d'appuyer sur le bouton des paramètres et modifier la liste déroulante du compilateur à la plaine gcc. Ensuite, utilisez un terminal pour naviguer vers le répertoire du projet et exécuter le modèle:

$ cd FastModelsPortfolio_8.3/examples/FVP_VE/Build_Cortex-A15x1/Linux-Release-GCC-4.1/
$ model_shell cadi_system_Linux-Release-GCC-4.1.so

La simulation de la plate-forme devrait commencer, mais nous avons fourni aucun logiciel pour cela, donc rien d'intéressant peut encore se produire.

Tip

Les systèmes 64 bits

Vous pouvez utiliser à la place de model_shell le model_shell64 sur les systèmes 64 bits, mais nous vous déconseillons en raison d'une dégradation mineur de performance.

Le système linux hôte

Ayant une plate-forme de simulation en état de marche pour l'ARM Cortex-A15 avec le support de virtualisation matérielle, nous pouvons maintenant créer le système Linux qui servira de l'hôte. Nous aurons besoin de ce qui suit:

bullet Cross compilateur pour construire notre noyau

bullet Noyau Linux Hôte

bullet Device Tree Blob (DTB)

bullet Bootloader

bullet Le système de fichiers

Cross compilateur

Nous aurons besoin d'un compilateur croisé basé sur GCC 4.8 avec binutils version 2.23 minimum, qui inclut le support pour Cortex-A15 et ses extensions de virtualisation. Heureusement Ubuntu inclut déjà un compilateur croisé capable de cet tâche.

$ sudo apt-get install binutils-arm-linux-gnueabihf \
               libc6-armhf-cross linux-libc-dev-armhf-cross libncurses5-dev \
               gcc-arm-linux-gnueabihf libc6-dev-armhf-cross cpp-arm-linux-gnueabihf

Noyau Linux Hôte

Une image du noyau précompilé peut être téléchargé à partir de:

$ wget http://www.virtualopensystems.com/downloads/guides/kvm_on_arm/uImage

Nous utilisons un noyau récent upstream pour le développement, y compris les patches pour le support d'LPAE. Pour télécharger la dernière version du noyau pour le développement KVM sur ARM à partir de dépôt Virtual Open Systems, suivez les étapes suivantes:

$ sudo apt-get install git
$ git clone git://github.com/virtualopensystems/linux-kvm-arm.git
$ cd linux-kvm-arm

Également, mkimage du paquet u-boot est requis pour créer un noyau uImage; sous Debian ou Ubuntu, nous pouvons faire ce qui suit pour l'installer:

$ sudo apt-get install u-boot-tools

La configuration du noyau pour la compilation croisée ne diffère pas beaucoup que d'habitude, mais il est important de définir les variables ARCH et CROSS_COMPILE.

Nous pouvons télécharger une configuration préformée pour le noyau:

$ curl http://www.virtualopensystems.com/downloads/guides/kvm_on_arm/kernel-config > .config
$ CROSS_COMPILE=arm-linux-gnueabihf- ARCH=arm make menuconfig

Et enfin compilez le noyau hôte:

$ LOADADDR=0x80008000 CROSS_COMPILE=arm-linux-gnueabihf- ARCH=arm make uImage

Device Tree Blob

Si vous voulez sauter ce chapitre, vous pouvez télécharger les fichiers de Device Tree Blob:

$ wget http://www.virtualopensystems.com/downloads/guides/kvm_on_arm/host-a15.dtb
$ wget http://www.virtualopensystems.com/downloads/guides/kvm_on_arm/guest-a15.dtb

Les nouvelles versions du noyau (3.4 ou plus récent) ont besoin de support FDT (Flattened Device Tree) afin de démarrer un hôte Cortex-A15.

Prenez les fichiers Device Tree Source (DTS):

$ git clone git://github.com/virtualopensystems/arm-dts.git

Sur la racine de notre noyau source:

$ ./scripts/dtc/dtc -O dtb -o host-a15.dtb \
       ../arm-dts/fast_models/rtsm_ve-cortex_a15x1.dts
$ ./scripts/dtc/dtc -O dtb -o guest-a15.dtb \
       ../arm-dts/versatile_express/vexpress-v2p-ca15-tc1.dts

Les fichiers Device Tree Blob qui en résultent doivent être utilisés avec le bootloader de l'hôte et QEMU, comme indiqué dans les chapitres suivants.

Bootloader

On peut s'affranchir de cette étape un télé-chargeant une version pré-compilée du bootwrapper:

$ wget http://www.virtualopensystems.com/downloads/guides/kvm_on_arm/linux-system-semi.axf

Nous n'utilisons pas encore u-boot pour lancer Cortex-A15, mais à la place un petit bootloader customisé, avec l'API de contrôle d'hyperviseur nécessaire pour initialiser le KVM. Nous pouvons cloner une copie de ce bootloader depuis le dépôt de Virtual Open Systems:

$ git clone git://github.com/virtualopensystems/boot-wrapper.git

Enfin, pour créer le fichier image du système, nous procédons tout simplement ainsi:

$ make clean
$ LOADADDR=0x80008000 CROSS_COMPILE=arm-linux-gnueabihf- ARCH=arm make

Le système de fichiers hôte

Nous allons démarrer notre système de fichiers à partir d'un partage NFS exporté par la machine que nous utilisons pour le développement. Bien sûr, n'importe quelle machine accessible depuis le réseau local pourrait être utilisé à la place. D'abord, nous devons nous assurer que NFS est bien installé, avec l'aide des outils de notre distribution. Par exemple pour Debian et Ubuntu:

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

Assurez-vous que un répertoire approprié est exporté dans /etc/exports avec les bonnes paramètres. Par exemple:

/srv/nfsroot 192.168.0.0/255.255.0.0(rw,sync,no_root_squash,no_subtree_check,insecure)

La configuration ci-dessus définit un partage NFS dans /srv/nfsroot, accessible par n'importe quelle machine du réseau local avec une adresse IP de 192.168.x.x. En outre, assurez-vous de redémarrer le serveur NFS après avoir modifié le fichier /etc/exports:

$ sudo /etc/init.d/nfs-kernel-server restart

N'importe quel système de fichier compatible avec le processeur peut être utilisé. Un point de départ peut être l'une des images du système de fichiers disponible sur http://www.arm.com/community/software-enablement/linux.php. Sinon, vous pouvez télécharger cet environnement busybox minimale:

$ wget http://www.virtualopensystems.com/downloads/guides/kvm_on_arm/fs-alip-armel.cramfs

Nous devons extraire le tar dans notre part NFS exporté:

$ sudo mount -o loop -t cramfs fs-alip-armel.cramfs /mnt
$ sudo cp -a /mnt/* /srv/nfsroot/
$ sudo umount /mnt

Tip

Utiliser une autre méthode de démarrage d'hôte

Au cas où vous ne voulez pas démarrer l'hôte via NFS, consultez le chapitre Démarrage MMC d'Hôte.

Tester le système hôte

À ce point nous avons tout ce qu'il faut pour démarrer un système Linux entièrement fonctionnel dans les Fast Models basé sur la plate-forme de simulation Cortex-A15. Nous devons maintenant tester que tout fonctionne comme prévu.

Nous aurons besoin de revenir au répertoire où nous avons compilé notre modèle Cortex-A15, qui nous allons exécuter avec un certain nombre des paramètres. Par souci de utilité, nous allons ajouter nos paramètres dans un fichier params:

motherboard.smsc_91c111.enabled=1
motherboard.hostbridge.userNetworking=1
cluster.cpu0.semihosting-cmd_line="semihosting arguments"

Le format des arguments pour semihosting:

Kernel: --kernel /path-to/uImage
Optional initrd: --initrd /path-to/initrd
Optional device tree file: --dtb /path-to/dtb
Kernel arguments: followed by a double dash and a space "-- "

Dans notre cas, pour démarrer le noyau hôte, les arguments semihosting doivent être (dans une ligne contiguë):

"--kernel uImage --dtb host-a15.dtb -- earlyprintk console=ttyAMA0
   mem=2048M root=/dev/nfs nfsroot=192.168.x.x:/srv/nfsroot/ rw ip=dhcp"

Maintenant, nous pouvons exécuter notre modèle:

$ model_shell cadi_system_Linux-Release-GCC-4.1.so -f params \
             ~/ARM/boot-wrapper/linux-system-semi.axf

Après un certain temps, nous devons pouvoir se connecter en tant que root, accueillis par un shell de Busybox que nous pouvons utiliser.

En option, vous pouvez consultez le chapitre Démarrage sans Semihosting, dans le cas peu probable que vous n'avez pas besoin de la fonction semihosting du bootloader.

Préparation du système pour démarrer un invité

Nous pouvons maintenant commencer à préparer notre hôte pour être en mesure de démarrer les systèmes invités. Un binaire précompilé du qemu peut être téléchargé depuis notre site web, qui peut être utilisé pour sauter cet section et la suivante:

$ wget http://www.virtualopensystems.com/downloads/guides/kvm_on_arm/qemu-system-arm

QEMU a quelques dépendances. Nous pouvons utiliser les outils fournis par Ubuntu, pour obtenir facilement tous pour la version croix compilé de QEMU pour ARM:

$ sudo apt-get build-dep qemu
$ sudo apt-get install xapt

Créez un fichier de /etc/apt/sources.list.d/armhf-saucy.list avec les dépôts nécessaires:

deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports saucy main restricted universe multiverse
deb-src [arch=armhf] http://ports.ubuntu.com/ubuntu-ports saucy main restricted universe multiverse

Maintenant, nous pouvons compiler et installer les paquets nécessaires:

$ sudo xapt -a armhf -m -b zlib1g-dev libglib2.0-dev libfdt-dev libpixman-1-dev
$ sudo dpkg -i /var/lib/xapt/output/*.deb

Nous avons également besoin de télécharger et d'installer ce paquet sur Ubuntu:

$ sudo apt-get install pkg-config-arm-linux-gnueabihf

QEMU

Nous devons compiler QEMU pour émuler les périphériques et conduire KVM à partir de l'espace utilisateur. Nous pouvons cloner la dernière version avec le support de KVM sur ARM à partir de dépôt Virtual Open Systems:

$ git clone git://github.com/virtualopensystems/qemu.git

Identifiant ou inscription pour visualiser l'information complète