Qemu

=Qemu=

Qemu est un émulateur de référence dont on trouve une définition plus exhaustive sur la page wikipédia de QEMU

Le logiciel Qemu à été utilisé pour différents projets innovant dans le cadre de la formation RICM4 de Polytech Grenoble :
 * Projet d'émulation de la carte STMicroelectronics STM32L-Discovery (fiche)
 * Projet d'amélioration de l'émulation de la carte Stellaris Luminary Lm3s6965 ( fiche)

Installation de qemu
Dans le dossier extrait, taper la commande : ./configure --target-list=arm-softmmu --python=/usr/bin/python2.7 La première option permet de compiler qemu uniquement pour l'émulation de programmes destinés à une architecture ARM. La deuxième option permet de forcer l'utilisation de la version 2.7 de python. Executer la commande : make Le résultat de la compilation sera placé dans un sous-répertoire en fonction des options utilisées dans la configuation (Ex: arm-softmmu)
 * Récuperer la dernière version de qemu ici (v1.0 lors de la rédaction de cet article)
 * Décompresser le dossier Qemu-x.xtar.gz
 * Configuration de compilation
 * Compiler les sources

Composants
Un exemple détaillé de la structure d'un composant est disponible sur la fiche projet de l'émulation de la carte STM32L-Discovery.

Assemblage
Qemu est un programme modulaire. Chaque fichier présent dans le dossier hardware (src/hw) représente l'émulation d'un ou plusieurs périphériques. On trouve par exemple dans src/hw/ les fichiers suivants :
 * pl022.c : Port série synchrone
 * pl050.c : Interface clavier
 * pl061.c : GPIO

Pour émuler un système complet, il faut donc le constituer composant par composant. Chaque composant est crée grâce à la fonction : DeviceState *sysbus_create_simple(const char *name,                                             target_phys_addr_t addr,                                              qemu_irq irq) ou, s'il y plusieurs irq : DeviceState *sysbus_create_varargs(const char *name,                                target_phys_addr_t addr, ...);

Un composant est représenté dans Qemu par la structure suivante contenant les liens avec les autres composants et les zones de la mémoire émulée qu'il utilise: struct SysBusDevice { DeviceState qdev; int num_irq; qemu_irq irqs[QDEV_MAX_IRQ]; qemu_irq *irqp[QDEV_MAX_IRQ]; int num_mmio; struct { target_phys_addr_t addr; target_phys_addr_t size; mmio_mapfunc cb; mmio_mapfunc unmap; ram_addr_t iofunc; MemoryRegion *memory; } mmio[QDEV_MAX_MMIO]; int num_pio; pio_addr_t pio[QDEV_MAX_PIO]; };

Cette structure contient une autre structure appelée qdev gérant le lien avec les autres composants. C'est au travers de l'api définie dans qdev.h que ces liens sont définis : qemu_irq qdev_get_gpio_in(DeviceState *dev, int n); void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin);

Remarque :L'appel à cette API devrait disparaitre dans les prochaines versions de qemu au profit d'un fichier de configuration définissant le composant ainsi que ses connexions avec les autres composants.

Un lecteur attentif aura remarqué l'utilisation de la structure de données qemu_irq dans les fonctions précédentes. Une qemu_irq est en fait la représentation d'une interruption matériel à l’intérieur de Qemu, mais elle est couramment utilisée pour envoyer des signaux entre les différents composants. Elle est de la forme suivante : typedef struct IRQState *qemu_irq; struct IRQState { qemu_irq_handler handler; void *opaque; int n; };

Mémoire
Pour fonctionner, un composant peut avoir besoin d'utiliser une zone de la mémoire fournie par le système. L'adresse de cette zone est définie lors de l'appel des fonction sysbus_create. Une fonction d'initialisation dans le composant est alors chargée de contacter Qemu afin qu'il lui délègue la gestion de cette zone. iomemtype = cpu_register_io_memory(readHandler, writeHandler, deviceData, NATIVE_ENDIAN); sysbus_init_mmio(dev, 0x1000, iomemtype);

Ou 0x1000 est la taille réservée en mémoire pour le composant.

Compilation et lancement du programme émulé
Ce chapitre est très résumé. Si vous cherchez un document plus exhaustif ce site très bien fait explique tout de A à Z.

Cross compilation
Dans le cas où le système émulé n'a pas la même architecture que le système hôte, il est nécessaire d'utiliser un utilitaire de cross-compilation à la place de l'utilitaire de compilation standard de l'hôte.

Emulation
./qemu-system-arm -M stm32l152rbt6 -nographic -kernel ./main.bin Options : La liste d'options peut être retrouvée grâce à l'option --help
 * Compiler les sources du programme (dans le cas ou l'architecture du système hôte est différente de celle du système cible, voir la rubrique: cross compilation)
 * Lancement de Qemu (dans le cas d'une cible ARM)
 * -M xxxx : Sélection de la machine émulée
 * -nographic : désactive les entrées/sorties (I/O) graphiques et redirige les I/O séries vers la console
 * -kernel xxxx : Programme à émuler

Lancement en mode debug
Il est possible de lier Qemu à GDB. Ainsi, il sera aisé de suivre le déroulement du programme émulé. ./qemu-system-arm -M stm32l152rbt6 -nographic -kernel ./main.bin -S -gdb tcp::51234 Options:
 * -S : Active le mode debug
 * -gdb tcp:: : Spécifie l'interface de débbogage

Remarque : Il faut également que le programme éxécuté par l'émulateur ai été compilé avec les options de débogage

Connexion avec GDB
Il suffit maintenant de connecter gdb à qemu. arm-none-eabi-gdb target remote localhost:51234 load ./main.elf continue

Présentation
Qemu offre un système de communication avec l'environnement extérieur: les char devices. Ce sont des flux offerts par Qemu sur lesquels un composant peut lire ou écrire. Lors du lancement de l'émulation, il sera possible de connecter ces flux à des structure informatique (telnet, socket, fichier, ...). D'un coté il faudra implémenter le chardev dans un composant de Qemu, puis de l'autre coté il faudra fournir au démarrage de l'application les connexions nécessaires aux chardev.

Implémentation
chrdev = qemu_chr_find("idCharDev"); if (s->chr) { chr_add_handlers(chrdev, canReceiveHandler, receiveHandler, eventHandler, deviceData); } qemu_chr_fe_write(chrdev, buffer, bufferSize); void IOReadHandler(void *opaque, const uint8_t *buf, int size);
 * Initialisation du chardev
 * Envoi de caractères dans le chardev. Le buffer est un tableau de uint8_t
 * La réception des données se fait de la même manière à travers la fonction receiveHandler de type void IOReadHandler définie par la signature suivante:

Utilisation
Il suffit de lancer Qemu avec l'option -chardev. Voici un exemple d'utilisation: ./src/arm-softmmu/qemu-system-arm -M stm32l152rbt6 -nographic -chardev socket,id=B,port=4242,host=localhost,nodelay -kernel ./main.bin La documentation de Qemu expose les différentes options à passer pour connecter les chardev: UserDoc