Pages persos Eric Meyer

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.
====== Outil de compilation croisée (cross compilation tool chain) ======

Reprise de l'article de Pierre Ficheux, mai 2005((http://pficheux.free.fr/articles/lmf/cross_compilation/cross_compilation_images.pdf)).

===== Résumé =====
Cet article décrit la mise en place d'une chaîne de compilation croisée utilisable dans l'environnement Linux x86 pour une cible ARM. Nous utiliserons l'outil ELDK associé à la distribution Linux Ubuntu version 8.04 mis à jour 9.10.

===== Objectifs de ce document =====
Nous devons constituer une chaine d'outils pour réaliser un système embarqué sur le kit KITAT91 de la société Eukréa à partir d'une installation Ubuntu 8.10.

===== La compilation sous Linux =====
La chaîne de compilation GNU utilise les composants suivants: \\ 
  * Le compilateur qui constitue le paquetage gcc.
  * Les outils annexes (assembleur, éditeur de liens, etc.) qui constituent le paquetage binutils.
  * La GNU-Libc qui constitue le paquetage glibc. Ce paquetage contient en général la bibliothèque de gestion des threads (soit le plus souvent LinuxThreads).

===== Mise en œuvre de l'outil ELDK =====
ELDK((http://www.denx.de/wiki/DULG/ELDK)) est développé par DENX Sofware, société de consulting Linux située en Allemagne. Le fondateur, Wilfried Denk, est un professionnel de talent, contribuant à de nombreux projets open source dont RTAI (voir http://www.rtai.org).\\ 
Le produit est disponible sous forme de paquetages RPM binaires ou sources. Il est également possible de télécharger l'image ISO du CDROM contenant les binaires ou les sources. ELDK permet de mettre en place une chaîne de compilation utilisable sur un PC Linux x86 pour des cibles telles que PowerPC, MIPS ou ARM. Cet outil fournit également une distribution que l'on peut utiliser comme root-filesystem au travers d'un montage NFS. Cette technique permet de faciliter la mise au point car il n'est pas nécessaire de mettre à jour systématiquement la cible. La version de noyau fournie par ELDK est la 2.6.24 améliorée par Denx principalement pour la plate-forme PowerPC. \\ 
L'installation est très simple. Il suffit de télécharger l'image ISO du CDROM auprès d'un des miroirs du projet. J'ai utilisé \\ 
http://www.denx.de/ftp/pub/eldk/ \\ 
avec la commande, après s'être positionné dans le répertoire où l'on souhaite télécharger le fichier : \\

  $ wget http://ftp.denx.de/pub/eldk/4.2/arm-linux-x86/iso/arm-2008-11-24-src.iso
Pour cela, il est nécessaire que le paquetage wget soit installé.
<box round red | Attention > Vérifier le paramétrage du proxy dans le fichier "/etc/wgetrc". Si nécessaire, modifiez le en tant qu'administrateur </box>

La dernière version à ce jour est la 4.2. Il faut noter que les images ISO n'existent pas forcément pour les anciennes versions comme la 2.1.0. A partir de l'image ISO, il est aisé de graver le CD sur un système Linux, ou même sur une machine Windows. On peut aussi utiliser l'image ISO grâce à la fonction de loopback device du noyau Linux. Cette fonctionnalité permet de monter un fichier image comme s'il constituait un périphérique physique (exemples: un CDROM au format ISO- 9660 ou une disquette au format VFAT). Elle est disponible en standard sur les noyaux fournis avec les distributions. \\ 
On peut donc monter le fichier en utilisant la commande suivante: \\ 

  $ sudo mount -t iso9660 -o loop </chemin/de/l/image/iso>/arm-2008-11-24.iso /mnt

où // /chemin/de/l/image/iso //est le l'emplacement où l'image ISO a été téléchargée.et // /mnt // est le chemin où l'image sera "montée".\\ 
\\ 
Lorsque l'image (ou le CD) est montée, on peut installer la distribution en exécutant simplement la commande suivante. Les options : //-d /chemin/du/répertoire/d/installation famille_de_cpu//

  $ /mnt/install -d ~/eldk_arm arm
  Do you really want to install into /opt/eldk_arm directory[y/n]?: y
  Creating directories
  Done
  Installing cross RPMs
  ...
Par exemple, ici les outils seront placés dans le répertoire //eldk_arm//, situé dans la racine du répertoire de l'utilisateur, avec l'architecture des processeurs ARM.
==== Au sujet des droits d'utilisateur ====

Il n'est pas nécessaire d'installer ELDK en tant que super-utilisateur (root). Dans le cas ou ELDK est installé en tant que simple utilisateur il faut bien entendu disposer des droits d'écriture sur le répertoire d'installation. Dans le cas de l'utilisation du root-filesystem ELDK par NFS, il sera nécessaire d'utiliser le script ELDK_MAKEDEV pour créer les entrées dans le répertoire // /dev// de l'image fournie par ELDK. Si ELDK n'est pas installé en tant que super-utilisateur, il faudra utiliser ELDK_FIXOWNER pour configurer correctement l'image NFS comme décrit dans la documentation ELDK sur http://www.denx.de/twiki/bin/view/DULG/ELDKMountingTargetComponentsViaNFS. 

==== Configuration du chemin d'accès des outils ====

Lorsque le paquetage est installé, la chaîne de compilation est utilisable si l'on configure le chemin d'accès
aux outils à sa variable d'environnement PATH comme ci-dessous.

  $ PATH=</chemin/du/répertoire/d/installation>/eldk_arm/usr/bin:$PATH
  $ export PATH

A partir de là on peut utiliser le compilateur et les outils associés.

  $ arm-linux-gcc -v
  Reading specs from /.../eldk_arm/usr/bin/../lib/gcc/arm-linux-gnueabi/4.2.2/specs 
  Target: arm-linux-gnueabi 
  Configured with: /opt/eldk/build/arm-2008-11-24/work/usr/src/denx/BUILD/crosstool-0.43/build/gcc-4.2.2-glibc-20070515T2025-eldk/arm-linux-gnueabi/gcc-4.2.2/configure --target=arm-linux-gnueabi --host=i686-host_pc-linux-gnu --prefix=/var/tmp/eldk.ywMqKk/usr/crosstool/gcc-4.2.2-glibc-20070515T2025-eldk/arm-linux-gnueabi --disable-hosted-libstdcxx --with-headers=/var/tmp/eldk.ywMqKk/usr/crosstool/gcc-4.2.2-glibc-20070515T2025-eldk/arm-linux-gnueabi/arm-linux-gnueabi/include --with-local-prefix=/var/tmp/eldk.ywMqKk/usr/crosstool/gcc-4.2.2-glibc-20070515T2025-eldk/arm-linux-gnueabi/arm-linux-gnueabi --disable-nls --enable-threads=posix --enable-symvers=gnu --enable-__cxa_atexit --enable-languages=c,c++,java --enable-shared --enable-c99 --enable-long-long --without-x 
  Thread model: posix 
  gcc version 4.2.2 

On peut compiler le programme de test classique Hello World [[Linux embarqué:programmes#helloworld.c|voir le chapitre Divers scripts et programmes]].

  $arm-linux-gcc -o helloworld helloworld.c 
  $ file helloworld 
  helloworld: ELF 32-bit LSB executable, ARM, version 1 (SYSV), for GNU/Linux 2.6.14, dynamically linked (uses shared libs), not stripped

La dernière commande indique bien que nous sommes en présence d'un exécutable ARM.

==== Montage de composants cibles via NFS ====

Qu'est-ce que NFS ? Le système de fichiers en réseau (Network File System ou NFS) est un protocole développé par Sun Microsystems qui permet à un ordinateur d'accéder à des fichiers via un réseau (wikipedia). \\ 
Comme il a été dit plus haut, NFS permettra de créer le système de fichiers de la cible sur le PC de développement. Et donc, il ne sera pas nécessaire de mettre à jour les données sur la cible systématiquement. \\ 
Le système de fichiers partagés par NFS doit avoir une entrée sur le PC de développement. Pour en faciliter la création, ELDK fournit un script nommé ELDK_MAKEDEV qui est situé dans la racine de l'image ISO de sa distribution. Il est donc nécessaire que cette image ISO soit montée pour exécuter ce script. \\
=== Créer les entrées ===
 
Ceci va créer les entrées dans le répertoire // /chemin/d/installation/de/ELDK/famille_de_cpu/dev // de l'installation de ELDK. \\
Dans le répertoire où ELDK est installé (//~/eldk_arm// dans notre exemple), taper :

  $ sudo /mnt/ELDK_MAKEDEV -a arm


Donnera //~/eldk_arm/arm/dev// dans notre exemple. \\ 
Puis, taper :

  $ sudo /mnt/ELDK_FIXOWNER -a arm

Pour configurer correctement l'image NFS et pour que quelques utilitaires sur la cible, comme mount ou su, puissent fonctionner correctement.

=== Configurer le serveur NFS ===
Le PC de développement fournit les fonctionnalités du serveur NFS et exporte un répertoire qui peut être monté depuis la cible comme le système de fichiers principal.

En supposant que le PC de développement fournisse déjà les fonctionnalités du serveur NFS, la seule configuration qui est nécessaire et d'ajouter une entrée pour le système de fichier de la cible à votre fichier // /etc/exports //. Pour notre cas :

  /chemin/d/installation/de/ELDK/famille_de_cpu       192.168.1.3(rw,no_root_squash,sync)

où ((http://doc.ubuntu-fr.org/nfs)) : 
  * // /chemin/d/installation/de/ELDK/famille_de_cpu // : cette ligne va exporter le répertoire ;
  * // 192.168.1.3 // : indique quel est l'hôte qui peut accéder à ce partage, ici définit par une IP ;
  * // (options) // : indique les options de partage. Soit :
    * // rw // : permet la lecture et l'écriture ;
    * // no_root_squash // : n'effectue pas de mapping pour l'utilisateur root ;
    * // sync // : Le serveur NFS respecte le protocole NFS de synchronisation des fichiers

Après modification de // /etc/exports //, il faut s'assurer que le système NFS est pris en compte ce changement en utilisant la commande par exemple ((plusieurs commandes sont possibles, voir le script de démarrage de NFs dans la documentation de votre distribution)) :

  $ sudo /etc/init.d/nfs-kernel-server restart