VOSySofficial
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:
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.
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.
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é.
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:
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:
Cross compilateur pour construire notre noyau
Noyau Linux Hôte
Device Tree Blob (DTB)
Bootloader
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
- Kvm android sur fastmodels
- Virtualisation kvm sur arndale
- Kvm sur arm vexpress
- Kvm sur chromebook
- Vhost-user pour snabbswitch
- Kvm sur armv8
- Vfio sur arm
- Kvm svirt omap5
- Criticité mixte agl sur armv8
- yocto qemu kvm vswitch nxp ls2085a
- Opnfv with vosyswitch
- Vosysmonitor on raspberry pi4
- Agl kvm rcar m3
