Qemu

From air
Jump to: navigation, search

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 :


Installation de qemu

  • 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

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.

  • Compiler les sources

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)


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

  • 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)
./qemu-system-arm -M stm32l152rbt6 -nographic -kernel ./main.bin

Options :

  • -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

La liste d'options peut être retrouvée grâce à l'option --help

Qemu et GDB

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::<port> : 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


CharDev

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

  • Initialisation du chardev
chrdev = qemu_chr_find("idCharDev");
if (s->chr) {
    chr_add_handlers(chrdev, canReceiveHandler, receiveHandler, eventHandler, deviceData);
}
  • Envoi de caractères dans le chardev. Le buffer est un tableau de uint8_t
qemu_chr_fe_write(chrdev, buffer, bufferSize);
  • 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:
void IOReadHandler(void *opaque, const uint8_t *buf, int size);

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