Linux, émuler un Raspberry avec une machine virtuelle – QEMU

Que ce soit pour tester une configuration particulière, approfondir un aspect d’un système d’exploitation ou simplement tester un système, une machine virtuelle peut-être idéale, nous allons voir comment nous y prendre pour émuler un Raspberry et son Raspbian.Personnellement, j’aime bien tester les systèmes mais j’avoue deux choses me concernant :

  • je craignais de me lancer dans le fonctionnement d’une machine virtuelle
  • je ne voulais pas procéder à une installation et utiliser un de mes disques durs (rare)

Il y a bien des solutions sur clé USB en live, mais je trouve qu’en terme de performances, l’expérience peut être gâchée. J’ai souvent lu et vu le terme machine virtuelle (ou VM pour les intimes), j’avais saisi en quoi ça consistait et m’était rempli de mauvaises idées alors qu’en faite, que nenni, cela est plus simple (vraiment plus simple que tout ce que je croyais).

Principe de fonctionnement

Nous allons avoir besoin d’un poste avec suffisamment de mémoire vive pour faire tourner deux système (en général au moins 2Go), d’une fréquence minimale de 2GHz et d’espace disque pour stocker le système virtualiser.

Nous allons tout simplement installer dans un dossier spécialement créé dans un système hôte, le système que nous allons virtualiser en lui attribuant des ressources (mémoire vive, fréquence, port usb, son …).

Tout plein de détails ici.

Différentes solutions de virtualisation de machine

Il existe plusieurs solutions afin de créer une machine virtuelle, voici les trois plus communs (enfin que j’ai rencontrer en cherchant les infos (notamment un comparatif) :

  • VirtualBox, gratuit pour un usage personnel, fonctionne sur Windows, Mac Os, Linux
  • VMWare, payant, sur Windows, Linux, possibilité sur Mac Os
  • QEMU, gratuit, il fonctionne sur Linux mais permet d’émuler une architecture arm (ce que les deux autres ne font pas).

Cette architecture est d’ailleurs intéressante pour nous, le Raspberry possède celle-ci.

Virtualisation d’un Raspberry sur Debian

Nous allons passer à la partie principale de ce tuto, la mise en place de l’émulation de Raspbian (le système officiel de la fondation Raspberry) avec QEMU.

Installation des paquets

Mise à jour du système

Comme toujours, on commence par un :

sudo apt-get update && sudo apt-get upgrade -y

Installation de QEMU

Il faut installer QEMU pour les systèmes ARM :

sudo apt-get install qemu-system-arm

Une petite vérification s’impose, il faut vérifier que le processeur ARM1176 du Raspberry est bien supporté avec :

qemu-system-arm -machine ? | grep raspi

Vous devriez voir apparaître quelquechose comme ça :

Tester la présence du raspberry dans QEMU
Tester la présence du raspberry dans QEMU

Au jour de l’écriture, voilà ce que j’ai obtenu

Récupération du système et du noyau du Raspberry

Nous allons devoir récupérer deux choses, le système Raspbian ainsi que le noyau.

Pour que ce soit propre, je me suis placé dans ~/VM/Raspberry, pour le créer mkdir -p ~/VM/Raspberryet cd ~/VM/Raspberry

Je suis donc dans ~/VM/Raspberry et on télécharge la dernière version de Raspbian : wget http://raspbian-france.fr/download/raspbian_latest.zip, puis on le décompresse : unzip raspbian_latest.zip.

Passons au noyau, toujours en ligne de commande, faites git clone https://github.com/dhruvvyas90/qemu-rpi-kernel.git

Vous devriez obtenir une arborescence de ce type (j’ai supprimé le fichier zip une fois décompressé) :

Arborescence de VM Raspbian
Arborescence de VM Raspbian

Il va falloir une petite de préparation, en effet, l’image de Raspbian n’est pas directement utilisable par QEMU, commencez par installer kpartx :

sudo apt-get install kpartx

Dans un second temps, nous créons les deux périphériques qui correspondent aux deux partitions de l’image :

sudo kpartx -av ~/VM/Raspberry/2018-03-13-raspbian-stretch.img

Puis nous créons le dossier qui permettra de monter la partition à modifier :

sudo mkdir /mnt/loop0p2
sudo mount /dev/mapper/loop0p2 /mnt/loop0p2

Maintenant, il est temps de modifier le premier fichier afin de désactiver une bibliothèque inutilisable par QEMU, dans le terminal : sudo nano /mnt/loop0p2/etc/ld.so.preloadet commentez la ligne /usr/lib/arm-linux-gnueabihf/libcofi_rpi.so en plaçant un # en début de ligne. Faites Ctrl+x, valider.

La dernière modification, consiste à corriger une petite différence dans le nom des périphérique de stockage, faites sudo nano /mnt/loop0p2/etc/udev/rules.d/90-qemu.rulespuis ajouter :

KERNEL=="sda", SYMLINK+="mmcblk0"
KERNEL=="sda?", SYMLINK+="mmcblk0p%n"
KERNEL=="sda2", SYMLINK+="root"

Enfin, on clos le montage :

sudo umount /mnt/loop0p2
sudo kpartx -d ~/VM/Raspberry/nom-fichier-image-raspbian.img

Cette partie provient de ce site, toute cette configuration est disponible dans le script qui suit à exécuter en root / admin.

#!/bin/sh
# à exécuter en root / admin
RASPBIAN_IMAGE_FILE=~/VM/Raspberry/nom-fichier-image-raspbian.img
MOUNT_PATH=/mnt/loop0p2

# Mount the partition
kpartx -av ${RASPBIAN_IMAGE_FILE}
mkdir -v ${MOUNT_PATH} 2> /dev/null
mount /dev/mapper/loop0p2 ${MOUNT_PATH}

# Disable libcofi_rpi.so
# Comment "/usr/lib/arm-linux-gnueabihf/libcofi_rpi.so"
# in "${MOUNT_PATH}/etc/ld.so.preload"
sed -ri "s/^.*libcofi_rpi.so/#\0/g" ${MOUNT_PATH}/etc/ld.so.preload

# Fix partition names
cat << 'EOF' >> ${MOUNT_PATH}/etc/udev/rules.d/90-qemu.rules
KERNEL=="sda", SYMLINK+="mmcblk0"
KERNEL=="sda?", SYMLINK+="mmcblk0p%n"
KERNEL=="sda2", SYMLINK+="root"
EOF

# Umount the partition
umount ${MOUNT_PATH}
kpartx -d ${RASPBIAN_IMAGE_FILE}

Accélération de la virtualisation (optionnel)

J’ai trouvé sur ce site, une option afin d’améliorer la virtualisation (niveau performance), nous allons convertir le fichier image en .qcow et étendre la taille du disque :

qemu-img convert -f raw -O qcow2 ~/VM/Raspberry/2018-03-13-raspbian-stretch.img ~/VM/Raspberry/raspbian-stretch.qcow  
qemu-img resize ~/VM/Raspberry/raspbian-stretch.qcow +6G

 

Lancement de la virtualisation

Pour lancer la virtualisation de votre système Raspbian, saisissez (la première ligne sera utilisé si vous utilisez l’image, la seconde dans le cas où vous avez converti l’image) :

qemu-system-arm -kernel ~/VM/Raspberry/qemu-rpi-kernel/kernel-qemu-4.4.34-jessie -cpu arm1176 -m 256 -M versatilepb -no-reboot -serial stdio -append "root=/dev/sda2 panic=1 rootfstype=ext4 rw" -hda ~/VM/Raspberry/2018-03-13-raspbian-stretch.img
qemu-system-arm -kernel ~/VM/Raspberry/qemu-rpi-kernel/kernel-qemu-4.4.34-jessie -cpu arm1176 -m 256 -M versatilepb -no-reboot -serial stdio -append "root=/dev/sda2 panic=1 rootfstype=ext4 rw" -hda ~/VM/Raspberry/raspbian-stretch.qco

Vous pouvez placer cette commande dans un fichier que vous appellerez, penser à lui donner les droits en exécution.

Attention, n’utilisez que l’une OU l’autre ligne de commande

Conclusion

Voici donc une solution pour tester Raspbian, une configuration sans soucis et sans avoir à devoir ou redevoir flasher sa micro-sd. On se retrouve par contre avec une machine virtuelle en Pi 2 (simple cœur) et seulement 256 Mo de ram (contre 1024 dans la réalité), les performances pures d’un Pi 3 seront de loin supérieures à ce que vous allez voir avec cette machine virtuelle.

Laisser un commentaire