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

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 à travers de l'api définis 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 devrais disparaitre dans les prochaine version de qemu au profit d'un fichier de configuration définissant le composant ainsi que ses connexion avec les autres composants.

Un lecteur attentif aura remarqué l'utilisation de la structure de donnée qemu_irq dans les fonctions précédentes. Une qemu_irq est en faites la représentation d'une interruption matériel à l’intérieur de Qemu, mais elle est couramment utilisé 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é en mémoire pour le composant.

Emulation
./qemu-system-arm -M stm32l152rbt6 -nographic -kernel ./main.bin Options : La liste de option peut être retrouvée grâce à l'option --help
 * Compiler les sources du programme (dans le cas ou l'architecture du système hote est différente de cette 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) graphique et redirige les I/O série vers la console
 * -kernel xxxx : Programme à émuler

Cross compilation
Dans le cas ou 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.

Lancement en mode debug
Il est possible d'interfacer Qemu avec 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

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émenté le chardev dans un composant de Qemu, puis de l'autre coté il faudra fournir au démarrage de l'application les connexion 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éfinis par la signature suivante:

Utilisation
Il suffit de lancer Qemu avec l'option -chardev dont 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