wiki:virtualisation_et_emulation:qemu [Wiki Ordunix.net]

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== QEMU, l'émulateur multi-processeurs qui permet d'exécuter des OS pour toute sorte d'Ordinateur ======
**Logo** de l'**émulateur** **QEMU** : {{ :wiki:virtualisation_et_emulation:qemu_logo.png?nolink&240 |}}

=== Sites sur QEMU ===
**Sites** officiels **QEMU** :
  * [[https://www.qemu.org/|QEMU]]
  * [[https://www.qemu.org/download/|Téléchargement QEMU]]
  * [[https://www.qemu.org/documentation/|Documentation QEMU]]
  * [[https://wiki.qemu.org/Main_Page|Wiki QEMU]]
  * [[https://www.qemu.org/blog/|Blog QEMU]] 

===== Présentation de QEMU =====
**QEMU** (**//Quick Emulator//**) est un **émulateur** de type **multiplate-forme**, qui est compatible avec les ''3/4'' des **OS** comme **Linux**, **Windows**, **macOS**, tous les **BSD** actuels et les **systèmes UNIX** en général mais encore d'autres **OS**. Il est installable sur ses **OS** étant en autres, sous **architecture processeur** de type **x86**, **x64**, **PPC**, **Sparc**, **MIPS** ou encore **ARM**. Par défaut **QEMU** est un **logiciel** en **ligne de commande** mais il existe de nombreuses **interface graphique** tel que **AQEMU**, **Virt-Manager**, **GNOME Boxes**,..., il existe aussi des **interfaces Web**.

**QEMU** permet d'**émuler** les **jeux d'instructions** de **processeurs** suivants : **x86** , **x86-64** (nommé aussi **AMD64**), **MIPS** (**MIPS** ''32 bits'' ou ''64 bits''), **ARMv7** (**ARM** ''32 bits'') , **ARMv8** (**ARM64** aussi appelé **AArch64**), **PowerPC** (**PowerPC** ''32 bits'' ou ''64 bits'') **RISC-V** (**RISC-V** ''32 bits'' ou ''64 bits''), **SPARC** (**SPARC** ''32 bits'' ou ''64 bits''), **ETRAX CRIS**, **MicroBlaze**, **AVR** (**Atmel AVR**), **Xtensa**, **s390x**, **SH-4**(**SuperH**), **OpenRISC** et il y aussi les **architectures** du passé tel que **M68k** (famille **Motorala 68000**), **Alpha**, **HPPA** (**PA-RISC**), **Z80**, et d'autres.

**QEMU** n'est pas seulement un **émulateur** mais permet d'agir comme un **logiciel** de **virtualisation** (**back-end**), par exemple avec l'**hyperviseur** par défaut de **Linux** nommé **KVM** (**//Kernel-based Virtual Machine//**) mais il peut aussi servir de **back-end** pour les **hyperviseurs** comme **Xen**, **HVF** d'**Apple**, **WHPX** de **Windows** ou **NVMM** de **NetBSD**. Niveau **virtualisation**, **QEMU** peut **virtualiser** des **environnements invités** (**machines virtuelles**) **x86**, **ARM**, **PowerPC**, **MIPS** (''32 bits'' seulement), **Sparc**, **ColdFire** (**Motorola M68K**), **S3903**,... Par contre, pour permettre de **virtualiser** un **OS** invité, il faut qu'il soit de la même **architecture processeur** que l'**OS** de l'**ordinateur hôte**, par exemple pour virtualiser un **OS** pour **processeur** de type **AMD64**, il faut que votre **OS Hôte** soit aussi un **OS** de type **AMD64**. 

À l'origine **QEMU** a été **développé** par **Fabrice Bellard** en 2003, puis en 2006, la **fondation QEMU** a été créée pour pousuivre le **développement** avec de nombreux **contributeurs** externes. C'est dans les années 2008 que **QEMU** a été adopté par l'**hyperviseur** de **Linux**, **KVM**. La dernière version **stable** de **QEMU** est **QEMU 9.2.0**, sortie le 10 décembre 2024, **QEMU** est sous **licence** **GNU GPLv2**. 

===== Caractéristiques de QEMU =====
==== Composition de de QEMU ====
**QEMU** est un **logiciel** de type **émulateur** et **virtualiseur** associé à un **hyperviseur** comme **KVM**, de base, en **ligne de commande**. **QEMU** intègre différents **composants** en **mode texte** qui permettent une **gestion** complète de l'**émulateur**, ses **composants** sont les suivants :
  * **qemu-utils** qui se compose de :
    * **qemu-img** qui permet de **manipuler** les **fichier** de types **images** de **média de stockage**. Cet **utilitaire** permet en autres de ''créer'', ''modifier'', ''convertir'', ''redimensionner'', faire des ''snapshots'' des **images** de **disque**. Le **format** par défaut des **images** de **disque** de **QEMU** est ''.qcow2'' mais il est également possible de **manipuler** les **images** de **disque** ''.vdi'' de **VirtualBox**, ''.vmdk'' de **VMWare**, ''.vhd'' de l'**hyperviseur** nommé **Hyper-V** de **Microsoft** mais aussi de simple **image** ''.img''.
    * **qemu-io** qui permet de **tester** et de **déboguer** les ''opérations'' d'**entrée**/**sortie** (**I/O**) des **systèmes** ''émulés''.
    * **qemu-nbd** permet de gérer les **images** de **disque** avec le **protocole** **réseau** nommé **NBD** (**//Network Block device//**). **qemu-nbd** permet en autres de **monter** des **images disques** via la **réseau** **NBD**.
  * **qemu-efi** permet d'**émuler** le **firmware** (**micrologiciel**) **UEFI** (**//Unified Extensible Firmware Interface//**) qui a remplacé le **firmware** ''traditionnel'' du nom de **BIOS** (**//Basic Input Output System//**) sur la plupart des **compatibles PC** et **ordinateurs** à base de **processeur** de type **ARM64**. Donc cet **utilitaire** permet de **booter** son **OS** invité en mode **EFI** ou **UEFI** qui est devenu le **fimware** de **démarrage** qui est le **standard** sur nos **ordinateurs** ''récents''
  * **qemu-system-misc** comprend les **émulateurs** spécifique à des **architectures processeur** spécifiques, en autres, comme :
    * **qemu-system-x86_64** pour **émuler** les **OS** invités à **processeur** de type **x86_64** (**AMD64**) et **x86**.
    * **qemu-system-aarch64** pour **émuler** les **OS** invités à **processeur** de type **ARM64** (**AArch64**) ou **ARMv7** (''32 bits'').
    * **qemu-system-m68k** pour **émuler** les **OS** invités à **processeur** de type **M68k** (famille **Motorola 68000**).
    * **qemu-system-sparc64** pour **émuler** les **OS** invités à **processeur** de type **SPARC V9** (''64 bits''). 
    * **qemu-system-sparc** pour **émuler** les **OS** invités à **processeur** de type **SPARC V7** et **SPARC V8** (''32 bits'').
    * **qemu-system-ppc64** pour **émuler** les **OS** invités à **processeur** de type **PowerPC** aussi bien ''64 bits'' que ''32 bits''.
    * Voilà pour les plus ''courants'', il y a encore une multitude de **processeurs** pris en charge.

Si vous sohaitez créer un **disque virtuelle** au format par défaut ''.qcow2'', voici la **commande** :
<code user>qemu-img create -f qcow2 image_file.qcow2 4G</code>créée une **image disque** d'une taille de ''4G'', au **format** ''.qcow2'' (vous n'êtes pas obligé de mettre ''.qcow2'' à la fin de l'**image**). Puis pour avoir des **infos** sur l'**image disque** créée, tapez :
<code user>qemu-img info image_file.qcow2</code>vous affiche les détails de l'**image disque** :
<file>image: image_file.qcow2
file format: qcow2
virtual size: 4 GiB (4294967296 bytes)
disk size: 196 KiB
cluster_size: 65536
Format specific information:
    compat: 1.1
    compression type: zlib
    lazy refcounts: false
    refcount bits: 16
    corrupt: false
    extended l2: false</file>

<note>Avec les **images disque** de type ''.qcow2'' vous pouvez, tout comme les ''.vdi'' de **VirtualBox**, avoir une **image disque** de ''32 Go'' qui n'est pas ''fixe'', c'est à dire, qui ne prenne que ''2 Go'' (la taille de l'**OS** après installation) sur le **média de stockage** de votre **ordinateur** et qui ne grossisse qu'au fur et à mesure que vous installez des **logiciels** ou ajouter des **fichiers** à votre **image disque**.</note>

==== QEMU en tant qu'émulateur ====
L'**émulation** consite à **simuler** un **OS** qui n'a absolument pas la même **architecture processeur** que l'**OS** **Hôte**, comme par exemple **émuler** un **OS** à **processeur** de type **ARM** sur un **OS** **Hôte** à **processeur** de type **Intel x86_64**, pour se faire, sous **QEMU** vous utiliserez **qemu-system-aarch64** et là vous **émulerez** la ''totalité'' du **matériels** (**processeur** (**CPU**), **mémoire vive** (**RAM**), **carte graphique** (**GPU**), **carte réseau**,...etc) de la **VM** (**//Virtual Machine//** et **machine virtuelle** en français) de l'**OS** invité sur votre **hôte** à **processeur** de type **x86_64**. En définitive vous pourez **émuler** toute les **VM** qui n'ont aucun lien avec le **processeur** de votre **ordinateur hôte** mais avec des ''performances'' médiocre comparées à la **virtualisation** sous **QEMU** grâce à **KVM**.

**QEMU** permet d'**émuler** les **architectures processeur** suivantes : **x86** , **x86-64** (nommé aussi **AMD64**), **MIPS** (**MIPS** ''32 bits'' ou ''64 bits''), **ARMv7** (**ARM** ''32 bits'') , **ARMv8** (**ARM64** aussi appelé **AArch64**), **PowerPC** (**PowerPC** ''32 bits'' ou ''64 bits'') **RISC-V** (**RISC-V** ''32 bits'' ou ''64 bits''), **SPARC** (**SPARC** ''32 bits'' ou ''64 bits''), **ETRAX CRIS**, **MicroBlaze**, **AVR** (**Atmel AVR**), **Xtensa**, **s390x**, **SH-4**(**SuperH**), **OpenRISC**, **M68k** (famille **Motorala 68000**), **Alpha**, **HPPA** (**PA-RISC**), **Z80**, et d'autres.

Exemple d'**exécution** de **SunOS 4.1.4** sur **processeur** de type **Sun Sparc** via **ordinateur hôte** avec **OS** sous **processeur** de type **Intel** **x86-64** :
<code user>qemu-system-sparc -monitor tcp::4444,server,nowait -bios ss5.bin -m 32 -nographic -hda SunOS-4.1.4.qcow2 -net nic,id=tap0 -net tap,ifname=tap0,script=no,downscript=no</code>pour décortiquer la **commande**, **qemu-system-sparc** appelle l'**émulateur** de type **SPARC** (**Sun4m**), la **option** de **commande** ''-monitor'' permet de se **connecter** avec **telnet** via le **port réseau** ''4444'', ''-bios'' permet de spécifier le **bios** pour le **démarrage**, ''-m 32'' alloue ''32 Mo'' de **RAM**, ''-nographic'' affiche dirextement d'**OS** dans le **terminal** (ou **console**), ''-hda SunOS-4.1.4.qcow2'' spécifie l'**image disque** sur laquelle est installé l'**OS**, ''-net nic,id=tap0 -net tap,ifname=tap0,script=no,downscript=no'' permet de choisir le mode de connexion (en l'occurence avec l'**interface réseau** ''tap0'' qui est une **interface** de type **bridge** nommé aussi **pont réseau**).

==== QEMU pour la virtualisation sous KVM ====
**QEMU** a aussi le rôle de **virtualiseur** lorsque l'on l'associe avec l'**hyperviseur** nommé **KVM** (d'autres **hyperviseurs** sont compatibles avec **QEMU**) qui est directement intégré au **noyau Linux**, donc vous n'avez rien à faire sous **Linux**, pour utiliser le mode de **virtualisation** de **QEMU**, le seul prérequis est que l'**architecture processeur** ''simulée'' soit la même que celui de l'**ordinateur hôte**. Ainsi **QEMU** utilise directement le **CPU**, **RAM**, **GPU**,...,donc les **ressrouces** de l'**ordinateur hôte** ce qui n'est plus une **émulation** du **matériels** mais une **virtualisation** et de se fait les ''performances'' sont quasiment ''natives''.\\
Nous allons prendre l'exemple d'un **hôte linux** avec **processeur** de type **Intel x86_64** qui **virtualise** un **OS** pour **Intel x86_64** ou même un **Intel x86** :
<code user>qemu-system-x86_64 -m 128 -cpu 486 -hda openserver-5.0.7-x86_2003_2G.qcow2 -cdrom SCO_OpenServer_5.0.7.iso -net nic,model=pcnet,id=br0 -net user -rtc base=localtime -boot c -k fr &</code>l'**option** ''-boot c'' permet de **booter** l'**image disque** de l'**OS** (''-boot d'' permettrait de **booter** sur le **CD**), ''-cpu 486'' spécifie le **processeur** **Intel 80486**, vous pouvez également utilisez cette **commande**:  
<code user>kvm -m 128 -cpu 486 -hda openserver-5.0.7-x86_2003_2G.qcow2 -cdrom SCO_OpenServer_5.0.7.iso -net nic,model=pcnet,id=br0 -net user -rtc base=localtime -boot c -k fr &</code> qui est exactement la même **commande** car **kvm** n'est qu'un **lien symbolique** vers **qemu-system-x86_64** sur les **hôte** de type **Intel** ''64 bits''.

==== Les interfaces graphiques sous QEMU ====
**QEMU** peut également être utiliser via des **interfaces graphiques** tel que :
  * **Virt-Manager** qui permet d'utiliser **QEMU** comme **émulateur** mais surtout comme **hyperviseur**, il fonctionne également avec les **conteneurs** nommé **LXC** mais aussi les **hyperviseurs** comme **Xen**, **Bhyve**,...
  * **AQEMU** qui utilise l'**émulateur** **QEMU** et **hyperviseur** **KVM**.
  * et encore d'autres.

<note important>Sachez que **QEMU** a servi de base et d'inspiration à **VirtualBox**, **Xen-HVM**, **KVM**, **Win4Lin Pro Desktop**, **SerialICE**, **WinUAE**, **Unicorn**, **Limbo x86 PC Emulator** et d'autres **projet** d'**émulation** ou **virtualisation**.</note>

===== Documentation Complémentaire sur QEMU =====
Vous trouverez une large **documentation** sur l'**émulateur**, dans les [[wiki:virtualisation_et_emulation:qemu:tutoriels sur QEMU]]