Formation à Linux Embarqué. Jérôme Pouiller <j.pouiller@sysmic.org>

Formation à Linux Embarqué Jérôme Pouiller <j.pouiller@sysmic.org>

Sommaire Administration d un Linux embarqué Création d un Linux Le noyau Debug et instrumentation Sysmic - J. Pouiller Formation à Linux Embarqué 2 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Première partie I Administrer Sysmic - J. Pouiller Formation à Linux Embarqué 3 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué 1 Notre environement Linux L embarqué 2 Le shell Bases 3 Communiquer avec la cible En RS232 Par ethernet Transférer des fichiers Utilisation de clefs numériques 4 Compiler et executer 5 Compiler un programme tiers Les Makefile Les Autotools Kmake En cas de problème 6 Ecrire un projet pour Linux embarqué Avec les AutotoolsSysmic - J. Pouiller Formation à Linux Embarqué 4 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Qu est-ce que Linux? Linux ne désigne que le noyau Linux est souvent associé aux outils GNU d où le nom de GNU/Linux Systèmes avec les outils GNU mais un noyau différent : GNU/Hurd, Solaris, etc... Systèmes Linux sans GNU : Android Le nombre de systèmes Linux installés est difficile à évaluer (en partie à cause des système Linux embarqués) Sysmic - J. Pouiller Formation à Linux Embarqué 5 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Composants de Linux GNU/Linux est finalement un aggloméra : App App App Bash GNU App App GNU lib Lib GNU libc Noyau Linux Matériel Sysmic - J. Pouiller Formation à Linux Embarqué 6 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué La Norme Posix Portable Operating System Interface [for Unix] Uniformise les OS Première version publiée en 1988 Souvent implémentée en partie... et parfois s en inspire simplement Posix Linux Linux Posix Sysmic - J. Pouiller Formation à Linux Embarqué 7 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Le Projet GNU Créé en 1983 par Richard Stallman Pose les bases politiques de GNU/Linux GPL publiée en 1989 GPLv2 en 1991 GPLv3 en 2006 gcc apparait en 1985 bash et les Coreutils apparaissent en 1988 (inspirés de sh 1971/1977) Nombre d architectures supportées incalculable Sysmic - J. Pouiller Formation à Linux Embarqué 8 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Le noyau Linux Créé en 1991 par Linus Torvalds Système communautaire 15 millions de lignes de code dans 30000 fichiers (+15%/an) Environ 1200 développeurs dans 600 entreprises (+35%/an) Environ 5000 contributeurs depuis la première version de Linux Environ 650 mainteneurs (c est-à-dire responsbales d une partie du noyau) Domaine d application très large, du DSP au super-calculateurs en passant pas les grille de calcul 24 architectures (= jeux d instructions) Des centaines de plateformes Environ 1000 drivers Une centaine de versions publiées Environ 10000 contributions sur chaque version Enormément de forks et de version non-officielles Sysmic - J. Pouiller Formation à Linux Embarqué 9 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Qu est-ce qu une distribution? Debian, Ubuntu, Meego, Red Hat, Suse,... Compilations de programmes disponibles pour GNU/Linux Ensemble de normes et de procédure Permet de garantir le fonctionnement des programmes distribué Notre distribution Hôte : Ubuntu Notre distribution Cible : Aucune Sysmic - J. Pouiller Formation à Linux Embarqué 10 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Qu est-ce que l embarqué? D après Wikipedia : Un système embarqué peut être défini comme un système électronique et informatique autonome, qui est dédié à une tâche bien précise. Ses ressources disponibles sont généralement limitées. Cette limitation est généralement d ordre spatial (taille limitée) et énergétique (consommation restreinte). Les systèmes embarqués font très souvent appel à l informatique, et notamment aux systèmes temps réel. Le terme de système embarqué désigne aussi bien le matériel que le logiciel utilisé. Sysmic - J. Pouiller Formation à Linux Embarqué 11 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Cible et Hôte Nous parlerons de système cible (target, la board) et de système hôte (host, votre machine) Le host va nous permettre de programmer, debugger, contrôler le système cible durant la période de développement Le système cible sera ensuite autonome. Nous utilisons un Linux sur les deux systèmes. Cela n est pas une obligation (même, si cela facilite certains automatismes). Sysmic - J. Pouiller Formation à Linux Embarqué 12 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué La cible : Calao USB-A9260 Sysmic - J. Pouiller Formation à Linux Embarqué 13 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué La cible : Calao USB-A9260 Architecture très classique dans le milieu de Linux embarqué : Microcontrolleur Atmel AT91SAM9260 Core ARM926EJ-S 180MHz 256Mo de flash 64Mo de RAM 64Ko d EEPROM Choisie car compacte, bien documentée, ouverte et très bien supportée par Linux Sysmic - J. Pouiller Formation à Linux Embarqué 14 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Quelques notions de shell Bases Sous Linux, on peut faire beaucoup de choses avec la ligne de commande Très souvent, ce sera le seul langage de script disponible sur la cible Lancer une commande $ ls Séparation des arguments par des espaces $ mkdir dir1 dir2 Souvent les arguments optionnels commence par - pour les options courtes et -- pour les options longues (attention aux exceptions) $ ls -l -a $ ls -la $ ls --sort=time Sysmic - J. Pouiller Formation à Linux Embarqué 15 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Quelques notions de shell Redirections On utilise beaucoup les redirections des entrées/sorties sous Linux (< >) : Commande standard $ echo foo Sortie standard vers un fichier $ echo foo > file1 Un fichier vers l entrée standard $ cat -n < file1 Sysmic - J. Pouiller Formation à Linux Embarqué 16 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Quelques notions de shell Redirections Sortie standard d une commande vers l entrée d une autre $ echo bar foo wc $ ls wc -l Couplage des redirections $ cat -n < file1 wc > file3 L espace n est pas obligatoire et les redirections ne sont pas forcement à la fin de la ligne $ >file2 cat<file1 -n Sysmic - J. Pouiller Formation à Linux Embarqué 17 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Quelques notions de shell Les chemins Il est possible d utiliser des chemins : absolus $ mkdir /tmp/tete relatifs $ mkdir../../tmp/titi mkdir foo signifie mkdir./foo Sysmic - J. Pouiller Formation à Linux Embarqué 18 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Quelques notions de shell Documentation : man (man -l pour une page locale ). </> et <?> permettent de rechercher dans une page de man Globbing (à ne pas confondre avec les expressions régulières) $ rm *.o Alias $ alias ll="ls -l --color=auto" $ alias cp="cp -i" $ alias mv="mv -i" $ alias rm="rm --one-file-system" Complétion (permet d aller plus vite et se protèger des fautes de frappe) $ cd /h<tab>/j<tab>/c<tab> Sysmic - J. Pouiller Formation à Linux Embarqué 19 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Quelques notions de shell Quelques séquences de touches : <Home>/<End> : début/fin de ligne <Ctrl+Left>/<Ctrl+Right> : se déplacer d un mot à l autre <Up>/<Down> : se déplacer dans l historique des commandes <Ctrl+R> : rechercher dans l historique. <Ctrl+R> de nouveau pour itérer Utilisez le copier-coller à la souris selection : copie click-milieu : colle double-click : selectionne le mot triple-click : selectionne la ligne Sysmic - J. Pouiller Formation à Linux Embarqué 20 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Ecrire un script shell Les fonctionnalités d un script shell sont abolument identiques à celles de la ligne de commande. Ouvrir un nouveau fichier. On suffixe généralement les shell par +.sh+ $ vim script.sh Indiquer le shell utilisé sur la première ligne, préfixé de #! #!/bin/sh La suite s ecrit comme sur la ligne de commande echo foo bar Il est nécéssaire de donner les droits en exécution au script $ bash script.sh $ chmod +x script.sh $./script.sh Sysmic - J. Pouiller Formation à Linux Embarqué 21 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Convention Par convention, nous préfixons dans ces slides les commandes shell par : $ pour les commandes à exécuter par l utilisateur normal % pour les commandes à exécuter par root > pour les commandes non-shell Nous préfixons parfois les commandes shell par le système ou la commande doit être executée Sysmic - J. Pouiller Formation à Linux Embarqué 22 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Se connecter par RS232 RS232 est très utilisé. Vous trouverez peu de systèmes sans RS232 D un point de vue électrique : Gnd, Rx, Tx (+ RTS et CTS, mais inutile) Il est relativement simple de communiquer en RS232 avec une pin de sortie du processeur, mais de nos jours, on utilise des contrôleurs RS232 qui simplifient énormément le travail On pourra trouver des bus similaires et convertible en RS232 : RS422, RS485 Sysmic - J. Pouiller Formation à Linux Embarqué 23 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Se connecter par RS232 Il faut un câble nul modem (= câble croisé) Il faut que le Linux sur la cible soit configuré pour utiliser le port RS232 comme console Possible en ajoutant console=ttys0,115200n8 dans la ligne de commande du noyau (sur PC, il suffit de passer par grub) Possible de le mettre dans la configuration du noyau Il faut sur le Linux un programme pour se logguer sur le port RS232 (comme sur PC) : login ou getty Il faut configurer le port RS232 : bitrate, protocole... Sysmic - J. Pouiller Formation à Linux Embarqué 24 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Pourquoi n y a-t-il pas de port série sur notre cible? Vous savez qu il existe des convertisseurs USB/RS232 Sur notre cible, un convertisseur USB/RS232 intégré à la carte Le port USB que vous voyez n est pas vu par le micro-contrôleur. Il est relié à une puce qui effectue la conversion USB/RS232 et relie la connexion série à la sortie console du micro-contrôleur. Cela permet : d économiser une alimentation (le PC alimente) de gagner la place d un port série et d un port Jtag Sysmic - J. Pouiller Formation à Linux Embarqué 25 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Communiqer par RS232 Avec les outils de haut niveau Permettre d accéder au port série sans être root : host% adduser user dialout Il est nécessaire de se relogguer pour que les modifications sur les groupes soient prises en compte Les outils de haut niveau : minicom : La référence picocom : Fonctionne sans ncurses (mieux pour l automatisation) gtkterm : Fonctionne en graphique putty : Fonctionne sous Linux et sous Windows Attention aux conflits avec certains services comme ModemManager Sysmic - J. Pouiller Formation à Linux Embarqué 26 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Communiqer par RS232 Minicom host% apt-get install minicom host$ minicom -D /dev/ttyusb0 host$ minicom La configuration se fait par <RET><Ctrl+A><O> Serial Device : /dev/ttyusb0... Bps/Par/Bits : 115200 8N1 Hardware Flow Control : No <- Important Software Flow Control : No Sysmic - J. Pouiller Formation à Linux Embarqué 27 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Communiquer par RS232 Avec les outils de bas niveau Outils de bas niveau : stty, cat, echo Permet de scripter (Tests automatiques, etc...) Dans le cas ou vous devriez coder votre propre client Fonctionnement : Configuration : host$ stty -F/dev/ttyUSB0 115200 Lecture host$ cat /dev/ttyusb0 > file Ecriture host$ echo root > /dev/ttyusb0 host$ cat file > /dev/ttyusb0 Sysmic - J. Pouiller Formation à Linux Embarqué 28 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Rebooter la clef Pour le fun : host$ lsusb -t host$ echo 3-1 sudo tee /sys/bus/usb/drivers/usb/ unbind host$ echo 3-1 sudo tee /sys/bus/usb/drivers/usb/ bind host$ dmesg tail Sysmic - J. Pouiller Formation à Linux Embarqué 29 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Communiquer par réseau ethernet Plus difficile. Il faut : Une interface réseau (plus complexe qu un controleur RS232) Une pile IP (plus complexe qu une communication RS232, donc ne permet de se connecter que plus tardivement dans le boot) Une configuration IP Un programme pour recevoir la demande de connexion Sysmic - J. Pouiller Formation à Linux Embarqué 30 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Communiquer par réseau ethernet Protocoles les plus utilisés : Telnet telnetd et telnet target% telnetd host$ telnet -l root target target% Pas sécurisé, attention à votre mot de passe (tshark -i lo -o out, puis chaosreader out) <CTRL+]> permet d accéder à l interface de commande Ssh sshd et ssh host$ ssh root@target target% Sécurisé Plein de bonus de sécurisés Il est possible de forcer la déconnexion avec <RET><~><.> et de suspendre une connexion avec <RET><~><CTRL+Z> Sysmic - J. Pouiller Formation à Linux Embarqué 31 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Transférer des fichiers Par réseau rcp/scp host$ scp -r ~/dir root@target:dir-target target$ scp -r user@host:dir-host. tftp. La syntaxe dépend de l implémentation. udpsvd -ve 0.0.0.0 69 tftpd -c /files/to/serve target$ tftp host -g -r file target$ tftp host -p -l file host$ tftp target -c get file host$ tftp target -c put file wget host$ wget http://host/file host$ wget ftp://host/file Beaucoup d autres méthodes plus ou moins standards Sysmic - J. Pouiller Formation à Linux Embarqué 32 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Transférer des fichiers Par liaison série Plus lent, moins malléable, mais peut vous sauver Protocoles {X,Y,Z}MODEM ou Kermit host% apt-get install lrzsz target$ sz file target$ rz <Ctrl-A><S> Sysmic - J. Pouiller Formation à Linux Embarqué 33 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Utiliser des clef ssh Possibilité de créer des clefs pour ssh host$ ssh-keygen -t dsa Toujours mettre un mot de passe sur votre clef Recopiez votre clef dans ~/.ssh/authorized_keys host$ ssh-copy-id root@target Sysmic - J. Pouiller Formation à Linux Embarqué 34 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Utiliser des clefs ssh Utiliser ssh-agent (inutile de nos jours car déjà lancé avec la session) host$ ssh-agent host$ SSH_AUTH_SOCK=/tmp/agent.3391; export SSH_AUTH_SOCK; host$ SSH_AGENT_PID=3392; export SSH_AGENT_PID; host$ echo Agent pid 3392; Enregistrer votre passphrase auprès de l agent host$ ssh-add Forwarder votre agent host$ ssh -A root@target target% Sysmic - J. Pouiller Formation à Linux Embarqué 35 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Notre premier programme hello.c #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include "hello.h" int main(int argc, char **argv) { static const char *str = "Hello World"; 8 long num = -1; char *end = NULL; if (argc > 1) { num = strtol(argv[1], &end, 10); if (!*argv[1] *end num < 0) { fprintf(stderr, "Invalid iteration number\ n"); num = -1; Sysmic - J. Pouiller Formation à Linux Embarqué 36 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Notre premier programme hello.c } } } print(str, num); return 0; void print(const char *str, long num) { int i; for (i = 0; i!= num; i++) { 10 printf("%s\n", str); sleep(1); } } Sysmic - J. Pouiller Formation à Linux Embarqué 37 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Notre premier programme hello.h #ifndef HELLO_H #define HELLO_H void print(const char *str, long num); #endif /* HELLO_H */ Sysmic - J. Pouiller Formation à Linux Embarqué 38 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compilation Installation du compilateur : host% apt-get install gcc libc-dev Compilation normale : host$ mkdir build-x86 host$ gcc hello.c -o build-x86/hello host$ build-x86/hello 1 Hello World Remarque : On préfère effectuer des compilation out-of-source ou les objets se trouvent séparés des sources. Il est ainsi possible d avoir un répertoire pour la production et un pour le debug ou bien un répertoire par cible. Sysmic - J. Pouiller Formation à Linux Embarqué 39 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compilation Décompression de la toolchain : host% cd / host% tar xvzf.../arm-sysmic-linuxuclibcgnueabi_i386.tgz On installe très souvent les chaines de cross-compilation dans /opt. Beaucoup de toolchain ne sont pas relocable. C est-à-dire qu elle doivent être placée à l endroit où elles ont été compilée (car il contiennent certains chemins en dur ). Sysmic - J. Pouiller Formation à Linux Embarqué 40 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compilation Compilation pour la cible : host$ mkdir build-arm host$ /opt/arm-sysmic-linux-uclibc/bin/arm-linuxgcc hello.c -o build-arm/hello ou bien host$ PATH+=:/opt/arm-sysmic-linux-uclibc/bin host$ arm-linux-gcc hello.c -o build-arm/hello Test : target%./hello 1 Hello World Sysmic - J. Pouiller Formation à Linux Embarqué 41 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Identifier le résultat Un bon moyen de reconnaître les binaires est d utiliser la commande file : host$ file */hello arm/hello: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), not stripped arm-static/hello: ELF 32-bit LSB executable, ARM, version 1 (SYSV), statically linked, not stripped x86/hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, not stripped x86-static/hello: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.15, not stripped Sysmic - J. Pouiller Formation à Linux Embarqué 42 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler et exécuter La force de Linux, c est sa polyvalence Programmer pour un Linux embarqué n est pas très différent que sur un Linux PC. Principales différences à garder à l esprit : Différence de vitesse de CPU et de quantité de mémoire Différence de périphérique. Conséquences : Drivers différents Bibliothèques différentes (exemple : Qt dépend de l accélération graphique) Les différence d architecture CPU peuvent empêcher l utilisation de certains outils de debug (ex : Perf, Valgrind, SystemTap...) Compiler un programme pour une autre cible s appelle cross-compiler Sysmic - J. Pouiller Formation à Linux Embarqué 43 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Règle d or Jamais d espaces dans les chemins de compilation Sysmic - J. Pouiller Formation à Linux Embarqué 44 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler avec un Makefile classique Pas très normalisé Utilisé pour les petits projets ou les projets non standard Ressemble souvent à : host$ make CC=arm-linux-gcc LD=arm-linux-ld Il peut être nécessaire d avoir la chaîne de cross-compilation dans son PATH. host$ PATH+=:/opt/arm-sysmic-linuxuclibcgnueabi/bin Ne pas hésiter à lire le Makefile Sysmic - J. Pouiller Formation à Linux Embarqué 45 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler avec un Makefile classique Exemple avec memstat : Récupération des sources host$ wget http://ftp.de.debian.org/debian/pool /main/m/memstat/memstat_0.9.tar.gz Décompression des sources host$ tar xvzf memstat_0.9.tar.gz Compilation host$ cd memstat-0.9 host$ make CC=arm-linux-gcc LD=arm-linux-ld memstat Sysmic - J. Pouiller Formation à Linux Embarqué 46 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler avec Makefile classique Il est aussi souvent possible de compiler ces programmes sans passer par Makefile ou de réécrire le Makefile pour une utilisation plus récurrente. Exemple avec memstat : host$ make clean host$ arm-linux-gcc memstat.c -o memstat Sysmic - J. Pouiller Formation à Linux Embarqué 47 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler avec autotools C est le cas le plus courant Pour une compilation classique : host$./configure host$ make host% make install Compilation out-of-source. il est nécessaire d appeller le configure à partir du répertoire de build. host$ mkdir build host$ cd build host$../configure host$ make host% make install L installation peut nécessiter les droits root Utiliser sudo -E (attention à l option secure_path dans /etc/sudoers) Utiliser fakeroot Sysmic - J. Pouiller Formation à Linux Embarqué 48 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler avec autotools Compilation out-of-source : host$ cd build host$../configure --prefix=~/rootfs host$ make host$ make install Cross-compilation. host$ PATH+=/opt/arm-sysmic-linux-uclibcgnueabi /usr/bin host$ mkdir build host$../configure --host=arm-linux --build= i386 --prefix=~/rootfs host$ make host$ make install Il est aussi possible (parfois préférable) d utiliser DESTDIR= lors de make install au lieu de --prefix= Sysmic - J. Pouiller Formation à Linux Embarqué 49 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler avec autotools Exemple avec lzma : Récupération et décompression des sources host$ wget http://tukaani.org/lzma/lzma-4.32.7. tar.gz host$ tar xvzf lzma-4.32.7.tar.gz host$ cd lzma-4.32.7 Configuration host$ mkdir build && cd build host$ PATH+=/opt/arm-sysmic-linux-uclibcgnueabi /usr/bin host$../configure --host=arm-linux --build= i386 --prefix=~/rootfs Compilation host$ make Installation Sysmic - J. Pouiller Formation à Linux Embarqué 50 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler avec autotools Obtenir de l aide : host$./configure --help Parmis les fichiers générés : config.log contient la sortie des opérations effectuées lors de l appel de./configure. En particulier, il contient la ligne de commande utilisée. Il est ainsi possible de facilement dupliquer la configuration. host$ head config.log config.status permet de regénérer les Makefile. config.status est automatiquement appellé si un Makefile.am est modifié. Sysmic - J. Pouiller Formation à Linux Embarqué 51 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler un programme tiers Kconfig Système de compilation du noyau Très bien adapté à la cross-compilation Adapté aux environnements embarqués Adapté aux environnements avec beaucoup de configuration Pas un système de compilation réel. Composé de : Kconfig, Système de gestion de configuration Kmake, règles Makefile bien étudiées. Chaque projet les adapte à ces besoins Application de la règle : "Pas générique mais simple à hacker" Dépend principalement de gmake Exemple avec busybox : host$ wget http://busybox.net/downloads/busybox -1.19.4.tar.bz2 host$ tar xvjf busybox-1.19.4.tar.bz2 host$ cd busybox-1.19.4 host$ make help Sysmic - J. Pouiller Formation à Linux Embarqué 52 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler un programme tiers Kconfig Pour configurer les options : En ncurses (2 versions) host% apt-get install libncurses5-dev host$ make menuconfig host$ make nconfig En Qt4 host% apt-get install libqt4-dev host$ make xconfig Permettent d effectuer des recherches Ne pas oublier d installer les headers des bibliothèques Sysmic - J. Pouiller Formation à Linux Embarqué 53 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler un programme tiers Kconfig Pour cross-compiler host$ make Pour compiler out-of-source host$ mkdir build host$ make O=build Mode verbose : V=1 Forcer la toolchain : CROSS_COMPILE=arm-linux- Indispensable pour le noyau : ARCH=arm Sysmic - J. Pouiller Formation à Linux Embarqué 54 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler un programme tiers Kconfig Test avec busybox : Récupération d une configuration par défaut host$ make CROSS_COMPILE=arm-linux- O=build defconfig Personnalisation de la configuration host% apt-get install libncurses5-dev host$ make CROSS_COMPILE=arm-linux- O=build menuconfig Compilation host$ make CROSS_COMPILE=arm-linux- Installation host$ make CROSS_COMPILE=arm-linux- CONFIG_PREFIX=~/rootfs install Sysmic - J. Pouiller Formation à Linux Embarqué 55 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler un programme tiers Placement des bibliothèques Pour que les autres programmes puissent en profiter le plus simple est d installer les bibliothèques dans TOOLCHAIN/TRIPLET/sysroot. Elle seront ainsi trouvées automatiquement par le compilateur. Il est aussi possible de modifier les variables CFLAGS et LDFLAGS (plus complexe) Nous verrons que les bibliothèques doivent aussi se trouver sur la cible. Sysmic - J. Pouiller Formation à Linux Embarqué 56 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Compiler un programme tiers Et si ca ne marche pas? Cas où des programmes doivent être compilés puis exécutés sur la cible lors de la compilation Classiquement, des cas de bootstraping Cas notable de Python 1 Deux solutions : Résoudre le problème et envoyer un patch Compiler sur la target. Vous avez alors besoin d un gcc natif sur la target Un émulateur type qemu peut vous aider 1. compile avec des patchs, mais pas évident Sysmic - J. Pouiller Formation à Linux Embarqué 57 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Historique des Autotools 1 Makefile 2 Makefile + hacks pour effectuer de la configuration 3 Makefile.in + configure 4 Makefile.in + configure.ac 5 Makefile.am + configure.ac Sysmic - J. Pouiller Formation à Linux Embarqué 58 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet avec autotools Fonctionnement des autotools : Préparation % apt-get install automake autoconf Déclaration de notre programme et de nos sources pour automake $ vim Makefile.am bin_programs = hello hello_sources = hello.c hello.h Sysmic - J. Pouiller Formation à Linux Embarqué 59 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet avec autotools Création d un template pour autoconf contenant les macros utiles pour notre projet $ autoscan $ mv configure.scan configure.ac $ rm autoscan.log $ vim configure.ac Personnalisation du résultat... AC_INIT([hello], [1.0], [bug@sysmic.org]) AM_INIT_AUTOMAKE([foreign])... Génération du configure et des Makefile.in. C est cette version qui devrait être livée aux packageurs. $ autoreconf -iv Sysmic - J. Pouiller Formation à Linux Embarqué 60 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet avec autotools Compilation $./configure --help $ mkdir build $ cd build $../configure --host=arm-linux --build=i386 -- prefix=~/rootfs $ make $ make install Sysmic - J. Pouiller Formation à Linux Embarqué 61 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet avec autotools La cible distcheck : 1 Recopie les fichiers référencés dans Autotools 2 Retire les droits en écriture sur les sources 3 Lance une compilation out-of-source 4 Installe le projet 5 Lance la suite de test 6 Lance un distclean 7 Vérifie que tous les fichiers créés sont effectivement supprimés 8 Crée une tarball correctement nommée contenant les sources Sysmic - J. Pouiller Formation à Linux Embarqué 62 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet avec autotools Si automake est appelé avec -gnits, distcheck effectue des vérifications supplémentaires sur la documentation, etc... La fonctionnalité distcheck est le point fort souvent énoncé des autotools. $ make distcheck $ tar tvzf hello-1.0.tar.gz Sysmic - J. Pouiller Formation à Linux Embarqué 63 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet sans autotools Utiliser les règles implicites facilite votre travail hello: hello.o Testons : host$ make CC=arm-linux-gcc CFLAGS=-Wall Sysmic - J. Pouiller Formation à Linux Embarqué 64 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet sans autotools VPATH vous permet de gérer la compilation out-of-source. Remarquez que, pour que VPATH fonctionne correctement, il faut avoir correctement utilisé le quoting pour les directives d inclusion (< pour les entêtes systèmes et " pour les entêtes du projet). Testons : host$ cd build host$ make -f../makefile VPATH=.. CC=arm-linux-gcc Sysmic - J. Pouiller Formation à Linux Embarqué 65 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet sans autotools gcc peut générer les dépendances de vos fichiers. On génère ainsi des morceaux de Makefile que l on inclue. Il ne faut pas oublier d ajouter la dépendance entre hello.d et les dépendances de hello.c %.o: %.c $(COMPILE.c) -MMD -o $@ $< -include hello.d hello: hello.o Sysmic - J. Pouiller Formation à Linux Embarqué 66 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet sans autotools Les Makefile permettent d utiliser des fonctions de substitutions qui peuvent nous aider à rendre notre système plus générique. %.o: %.c $(COMPILE.c) -MMD -o $@ $< HELLO_SRC = hello.c 5 -include $(HELLO_SRC:%.c=%.d) hello: $(HELLO_SRC:%.c=%.o) Sysmic - J. Pouiller Formation à Linux Embarqué 67 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet sans autotools Nous pouvons ajouter des alias pour nous aider dans les commandes complexes clean: rm -f hello $(HELLO_SRC:%.c=%.o) $(HELLO_SRC :%.c=%.d) 4.PHONY: debug-x86 debug-arm clean debug-arm/makefile: mkdir -p debug-arm echo all %: >> debug-arm/makefile echo make -f../makefile VPATH=.. CFLAGS=-g CC=arm-linux-gcc $$@ >> debug-arm/ Makefile debug-arm: debug-arm/makefile make -C debug-arm Sysmic - J. Pouiller Formation à Linux Embarqué 68 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Créer un projet sans autotools En poussant ce fonctionnement un peu plus loin, on obtient le Kmake. Un système génère un fichier contenant toutes les options. Kmake, utilise des variables pour rendre la compilation conditionnelle : HELLO_$(CONFIG1) += hello.o Néanmoins, le résultat n est pas portable entre les différentes implémentations de make. Sysmic - J. Pouiller Formation à Linux Embarqué 69 / 254

Notre environement Le shell Communiquer avec la cible Compiler et executer Compiler un programme tiers Ecrire un projet pour Linux embarqué Bibliothèques courantes Il existe des milliers de bibliothèques et d API disponibles pour Linux. Parmi elles : Les appels systèmes. Inclus avec le noyau Linux. Documentés par les pages de man. Liste sur syscalls(2) L interface Posix. Fournis par la libc. Documentés par les pages de man des sections 3 ou 3posix ou sur http://www.unix.org/version3/ Les bibliothèques très utilisées : libapr, glibc, ømq,... La documentation se trouve avec les source ou sur leur site web. Qt. Bibliothèque très complète pouvant être utilisé pour des usage très divers : embarqué, multimédia, etc... En C++. Documentation sur http://qt-project.org/doc/qt-5.0 Regarder les packets inclus dans Buildroot ou sur votre distribution permet d avoir une idée des bibliothèques les plus courantes Sysmic - J. Pouiller Formation à Linux Embarqué 70 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Deuxième partie II Créer Sysmic - J. Pouiller Formation à Linux Embarqué 71 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation 8 Booter par réseau Le bootloader TFTP NFS 9 Compilation des differents éléments Compilation du noyau Création de l init Compilation de l espace utilisateur 10 Quelques ajouts 11 Bootstrapper la toolchain 12 Flasher le rootfs 13 Simuler 14 Automatisation Sysmic - J. Pouiller Formation à Linux Embarqué 72 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Booter par réseau Permet de travailler plus confortablement car évite les cycles de scp/flash Parfois, il faut demarrer la cible sous Linux pour pouvoir la flasher. C est donc la seule manière de continuer. Fonctionne aussi très bien avec des PC Trois étapes pour démarrer un système 1 Le bootloader configure la carte réseau et place le noyau en mémoire 2 Le noyau s exécute et monte un filesystem réseau 3 Le premier processus de la vie du système est lancé : init Sysmic - J. Pouiller Formation à Linux Embarqué 73 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Le bootloader Description Le bootloader se trouve souvent sur une eeprom. Celle-ci est directement mappée sur le bus d adresse Au minimum, il doit initialiser : les timing de la mémoire RAM les caches CPU Sysmic - J. Pouiller Formation à Linux Embarqué 74 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Le bootloader Description Il peut : Initialiser une ligne série pour l utiliser comme terminal Offrir un prompt et accèder à des options de boot Initialiser la mémoire flash Copier le noyau en mémoire Passer des arguments au noyau Initialiser le chipset réseau Récupérer des informations provenant d un serveur DHCP (serveur où récupérer l image du noyau, indications sur les mise à jour disponibles, etc...) Lire des fichiers provenant du réseau Lire des fichiers par {X,Y,Z}MODEM Ecrire sur la flash Gérer un système de secours Initialiser des fonctionnalités cryptographiques (Trusted Plateform Manager) Sysmic - J. Pouiller Formation à Linux Embarqué 75 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Le bootloader Description Il est très rare de pouvoir démarrer Linux sans bootloader fonctionnel Si votre bootloader n est pas fonctionnel, vous aurez souvent besoin d un matériel particulier pour le mettre à jour (un outil capable de flasher l eeprom) Bootloader connus : Grub Syslinux (et son dérivé Isolinux) U-Boot (utilisé ici) Redboot BareBox (successeur de U-Boot) Sysmic - J. Pouiller Formation à Linux Embarqué 76 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Le bootloader Test Testons notre bootloader : Démarrez minicom host$ minicom -D /dev/ttyusb0 Resettez la carte Appuyez sur une touche pour stopper le démarrage [...] Hit any key to stop autoboot: 0 Obtenez la liste des commandes uboot> help Attention aux caractères de contrôle (<PgUp>, Ctrl+V,...) En cas de problème pour vous connecter, vérifiez vos paramètres RS232. Sysmic - J. Pouiller Formation à Linux Embarqué 77 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation TFTP Mise en place Identique au protocole ftp mais plus simple Permet d etre implémenté avec très peu de ressource Mise en place : host% apt-get install tftp-hpa tftpd-hpa host% cp hello/build-arm/hello /var/lib/ tftpboot Test en local Par le shell interactif host$ tftp 127.0.0.1 > get hello > quit Par la ligne de commande host$ tftp 127.0.0.1 -c get hello Il est possible de modifier le répertoire partagé dans /etc/default/tftpd-hpa Sysmic - J. Pouiller Formation à Linux Embarqué 78 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation TFTP Configuration de la cible pour télécharger et démarrer le noyau. Par RS232 : Configuration de l IP uboot> setenv ipaddr 192.168.1.12 Vérification la configuration IP uboot> ping 192.168.1.10 Déclaration de notre host comme serveur tftp uboot> setenv serverip 192.168.1.10 Pafois nécessaire de passer la console au noyau : uboot> setenv console console=ttys0,115200 uboot> setenv bootargs ${console} uboot> saveenv Sysmic - J. Pouiller Formation à Linux Embarqué 79 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation TFTP Téléchargement du noyau dans une zone libre de la mémoire uboot> tftpboot 21000000 uimage Exécution du noyau uboot> bootm 21000000 Le noyau trouve la flash, monte la flash et charge l init de la flash Sysmic - J. Pouiller Formation à Linux Embarqué 80 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Nfs Comparable au partage réseau de windows. Installation host% apt-get install nfs-kernel-server nfscommon host$ mkdir nfs host% vim /etc/exports Configuration du partage /home/user/nfs 0.0.0.0/0.0.0.0(rw, no_root_squash) Sysmic - J. Pouiller Formation à Linux Embarqué 81 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Nfs Test sur l hôte host% service nfs-kernel-server restart host$ mkdir nfs-mount host% mount -t nfs 127.0.0.1:/home/user/nfs nfs -mount En cas de problème, vérifiez les logs : /var/log/daemon.log Sysmic - J. Pouiller Formation à Linux Embarqué 82 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Démarrage sur le NFS Modification des arguments passés au noyau Configuration IP uboot> setenv ipconf ip=192.168.1.13 Configuration NFS uboot> setenv nfsconf root=/dev/nfs nfsroot =192.168.1.10:/home/user/nfs La variable bootargs permet de passer des arguments au noyau uboot> setenv bootargs ${ipconf} ${nfsconf} ${console} Démarrage uboot> tftpboot 21000000 uimage Voir Documentation/filesystem/nfs/nfsroot.txt Après avoir monté le NFS, le noyau essaye de passer la main au programme init Sysmic - J. Pouiller Formation à Linux Embarqué 83 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Récupération des sources Où récupérer les sources du noyau? 1 Utiliser les sources souvent fournies. Il arrive souvent qu elles contiennent des drivers particuliers et qu elles soient déjà configurées 2 Utiliser git clone (nous y reviendrons) 3 Télecharger sur kernel.org host$ wget http://www.kernel.org/pub/linux/kernel/ v3.x/linux-3.5.7.tar.bz2 host$ tar xvjf linux-3.5.7.tar.bz2 Sysmic - J. Pouiller Formation à Linux Embarqué 84 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Interface de configuration du noyau Utilise Kconfig host$ make help host$ mkdir build host$ make O=build ARCH=arm CROSS_COMPILE=armlinux- menuconfig Beaucoup d options, mais il y a l aide (<h>) et la recherche (</>) La configuration est sauvée dans.config usb-a9260_defconfig permet de charger une configuration pré-établie pour notre carte host$ make O=build ARCH=arm CROSS_COMPILE=armlinux- usb-a9260_defconfig Certains constructeur vous fournirons un patch ajoutant une cible _defconfig D autres vous fournirons un.config Sysmic - J. Pouiller Formation à Linux Embarqué 85 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compilation du noyau Vérifier les options du type de processeur Cocher NFS Le reste ne devrait pas empêcher de démarrer votre cible La compilation se lance avec host$ make O=build ARCH=arm CROSS_COMPILE=armlinux- XXImage XX fait référence au format de la binaire produite : Le premier octet est-il du code? Respecte-t-il le format ELF? Y a-t-il un format particulier d entête à respecter? Dans le doute, il faut consulter la documentation de votre bootloader Sysmic - J. Pouiller Formation à Linux Embarqué 86 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler le noyau Dans notre cas, nous utilisons U-Boot (standard) Compilation host% apt-get install uboot-mkimage host$ make O=build ARCH=arm CROSS_COMPILE=armlinux- uimage Partage de l image par TFTP host% cp build/arch/arm/boot/uimage /var/lib/ tftpboot/uimage-3.5.7 host% ln -s uimage-3.5.7 /var/lib/tftpboot/ uimage Sysmic - J. Pouiller Formation à Linux Embarqué 87 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compilation du noyau Fichiers produits (ou productibles) par la compilation : vmlinux : L image ELF du noyau. Lisible par les debugueurs, certains flasheurs, certains bootloaders Image : vmlinux strippé et préfixé par un mini-bootloader permettant de sauter sur la fonction start_kernel de vmlinux. bzimage et zimage : Comme Image mais compressé en bz2 ou gz. vmlinuz : Normalement équivalent du bzimage. xipimage : Idem Image mais destiné à être exécuté directement sur un eeprom sans être copier en mémoire au préalable. uimage : zimage avec une entête spéciale pour u-boot. Sysmic - J. Pouiller Formation à Linux Embarqué 88 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Les modules Deux mots sur les modules : Morceaux de noyaux externalisés Compilation avec make [...] modules Installation avec make [...] INSTALL_MOD_PATH=~/ rootfs modules_install Sysmic - J. Pouiller Formation à Linux Embarqué 89 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Démarrage du noyau A la fin du démarrage du noyau, ce dernier donne la main à l exécutable déclaré avec init=. Par défaut, il s agit de /sbin/init init ne se termine jamais Les arguments non-utilisés par le noyau sont passés à init On peut estimer que notre système démarre à partir du moment ou nous obtenons un shell (c est en tous cas là que la plupart des intégrateurs Linux embarqué s arrêteront) Du moins complexe au plus complexe à démarrer : init=/hello-arm-static init=/hello-arm init=/bin/sh init=/sbin/init Effectuons ces tests avec le Rootfs original et un Rootfs vierge. Sysmic - J. Pouiller Formation à Linux Embarqué 90 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Créer l espace utilisateur Créer l arborescence Nous travaillerons dans un répertoire vierge host$ mkdir nfs-root-mine host$ ln -s nfs-root-mine nfs host$ cd nfs-root-mine L arborescence classique sera : bin sbin usr/bin usr/sbin etc dev proc sys tmp var Il est possible de ne pas respecter cette arborescence, mais cela compliquerait inutilement la chose Sysmic - J. Pouiller Formation à Linux Embarqué 91 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Créer l espace utilisateur Créer l arborescence Après le démarrage, le noyau ne trouve pas l init : [...] Kernel panic - not syncing: No init found. Try passing init= option to kernel. Copions maintenant hello-arm-static et hello-arm et essayons de démarrer avec. Sysmic - J. Pouiller Formation à Linux Embarqué 92 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Installation des bibliothèques de base Les bibliothèques de base (libc et apparentés) sont forcement fournies avec le cross-compilateur, car elles y sont intimement liées Liste des bibliothèques nécessaires host$ arm-linux-ldd --root. hello-arm Copie host$ mkdir lib host$ cp /opt/arm-linux-.../lib/ld-uclibc -0.9.30.2.so lib host$ cp /opt/arm-linux-.../lib/libuclibc -0.9.30.2.so lib Sysmic - J. Pouiller Formation à Linux Embarqué 93 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Installation des bibliothèques de base Configuration de ldconfig host$ echo /lib > etc/ld.so.conf host$ echo /usr/lib >> etc/ld.so.conf Création des liens symboliques host$ ldconfig -r. -N Création du cache. Le cache n est pas obligatoire, mais si il existe, il doit être à jour host$ ldconfig -r. Nous pouvons maintenant démarrer avec init=/hello-arm Sysmic - J. Pouiller Formation à Linux Embarqué 94 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Busybox Contient la plupart des binaires nécessaires pour démarrer un système Attention, ce ne sont pas les mêmes outils que sur PC. Il y a souvent des options non-implémentées ou des comportements différents Téléchargement host$ wget http://busybox.net/downloads/busybox -1.19.4.tar.bz2 host$ tar xvjf busybox-1.19.4.tar.bz2 host$ mkdir build On retrouve Kconfig host$ make O=build CROSS_COMPILE=arm-linuxmenuconfig Sysmic - J. Pouiller Formation à Linux Embarqué 95 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Busybox On trouve plein d outils Au minimum, vérifions les options ash, init, les Coreutils Vérifions le chemin d installation Sysmic - J. Pouiller Formation à Linux Embarqué 96 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Installation de Busybox Configurons le chemin de destination vers ~/nfs host$ make O=build CROSS_COMPILE=arm-linuxhost$ make O=build CROSS_COMPILE=arm-linux- CONFIG_PREFIX=~/nfs install L installation créé des liens symboliques vers la binaire busybox Sans Busybox, toutes ces binaires seraient séparées et dispersées sur une dizaine de sources Nous pouvons maintenant démarrer avec init=/bin/sh init=/sbin/init pose encore quelques problèmes. Sysmic - J. Pouiller Formation à Linux Embarqué 97 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Configuration de init Il est possible de configurer init avec le fichier /etc/inittab Lancement automatique d un shell host$ echo ::askfirst:/bin/sh > etc/inittab Appel d un script de démarrage. host$ echo ::sysinit:/etc/init.d/rcs >> etc/ inittab host$ mkdir etc/init.d host$ echo #!/bin/sh > etc/init.d/rcs host$ chmod +x etc/init.d/rcs Documentation disponible sur la page de man inittab(5) (disponible ici : http://tfm.cz/man/5/inittab). Des fichiers de configuration de init et d autres utilitaires de busybox sont disponibles dans busybox/examples Sysmic - J. Pouiller Formation à Linux Embarqué 98 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Autres init Il existe d autres formes d init : SystemV (celui que nous utilisons) runit (aussi proposé par Busybox) upstart (utilisé autrefois par Ubuntu) systemd (utilisé par le reste du monde) Ces init, plus modernes offrent de nouvelles fonctionnalités et plus de robustesse pour le système. Sysmic - J. Pouiller Formation à Linux Embarqué 99 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compilons init Fichiers de configuration Nous pouvons maintenant démarrer avec init=/bin/init mais certaines fonctionnalités sont absentes (ps, ifconfig, top, lsusb, etc... ) Il faut monter les partitions /proc et /sys : target% mount -t proc none /proc target% mount -t sysfs none /sys Automatisation du montage avec inittab : host$ echo "::sysinit:mount -t proc none /proc" >> etc/inittab host$ echo "::sysinit:mount -t sysfs none /sys" >> etc/inittab Nos commandes semblent maintenant correctement fonctionner. Sysmic - J. Pouiller Formation à Linux Embarqué 100 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Utilisation de fstab Il est possible d automatiser ce montage au démarrage avec fstab et mount -a host$ echo none /proc proc >> etc/fstab host$ echo none /sys sysfs >> etc/fstab target% mount -a Nous pouvons utiliser le fichier etc/inittab pour monter nos partitions automatiquement. host$ echo "::sysinit:/bin/mount -a" >> etc/inittab host$ echo "::shutdown:/bin/mount -r -a" >> etc/ inittab Sysmic - J. Pouiller Formation à Linux Embarqué 101 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Filesystem temporaire Créer un filesystem en mémoire permet de protéger notre flash (à durée de vie limitée), de garantir que nos systèmes seront toujours identiques entre chaque démarrage et d améliorer les performances. Création host$ mkdir tmp Ajout du stickybit comme il se doit host$ chmod 777 tmp host$ chmod +t tmp Montage d un filesystem contenu en mémoire target% mount -t tmpfs none /tmp host$ echo none /tmp tmpfs >> etc/fstab Sysmic - J. Pouiller Formation à Linux Embarqué 102 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Démarrage d une binaire statique Les fichiers devices Permettent de communiquer avec le noyau Il représente plus ou moins chacun un périphérique Les plus importants sont normés (Documentation/devices.txt) Il est possible de les créer avec mknod : host% mknod dev/console c 5 1 host% mknod dev/ttys0 c 4 64 host% mknod dev/random c 1 8 host% mknod dev/mtdblock1 b 31 1 host% mknod dev/sda b 8 0 host% mknod dev/sda1 b 8 1 Sysmic - J. Pouiller Formation à Linux Embarqué 103 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Utilisation de MAKEDEV MAKEDEV permet d automatiser la création des fichiers devices de base host$ cd dev host% MAKEDEV std host% MAKEDEV console Sysmic - J. Pouiller Formation à Linux Embarqué 104 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Peudo Terminal Multiplexer ptmx (Peudo Terminal Multiplexer) Permet de facilement gérer l allocation des terminaux. (Nécessaire pour Dropbear) host% mknod dev/ptmx c 5 2 host$ mkdir dev/pts host$ echo none /dev/pts devpts >> etc/fstab Sysmic - J. Pouiller Formation à Linux Embarqué 105 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Utilisation de mdev Intégré dans Busybox Uniquement depuis 2.6, nécessite /sys compilé et monté Permet de créer les devices à la volée Sur les systèmes très petits et où l utilisation de device dynamique n est pas nécessaire, onse passe de mdev à cause des dépendances avec le noyau Création de /dev sur un disque mémoire target% mount -t tmpfs none /dev Initialisation /dev lors du démarrage target% mdev -s Installation de mdev comme handler pour les nouveaux périphériques target% echo /sbin/mdev > /proc/sys/kernel/ hotplug Sysmic - J. Pouiller Formation à Linux Embarqué 106 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Utilisation de mdev Automatisation du processus host$ echo none /dev tmpfs >> etc/fstab host$ echo "mdev -s" >> etc/rcs host$ echo "echo /sbin/mdev > /proc/sys/kernel/ hotplug" >> etc/rcs Il est aussi possible d utiliser devtmpfs Sysmic - J. Pouiller Formation à Linux Embarqué 107 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Résumé Toujours commencer par hello-static, le moins dépendant Si il ne fonctionne pas, recherchez du coté du format de binaire de la chaîne de compilation et avec sa compatibilité avec les options du noyaux Si hello-static fonctionne, mais pas hello en dynamique, cherchez du coté du format de la libc et de sa compatibilité avec le format de binaire de hello Si hello fonctionne mais que vous ne pouvez pas lancer de shell, cherchez du coté des devices et des droits. Si le shell démarre mais pas init, rechechez du coté des fichiers de configuration et des devices Vérifier que votre cible ne change pas d IP en démarrant (ici dans /etc/inittab) Sinon, cherchez dans les parametres passés au noyau ou dans la configuration Si possible, toujours tester entre chaque modification Sysmic - J. Pouiller Formation à Linux Embarqué 108 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Résolution DNS Ajout de la résolution DNS host$ echo nameserver 8.8.8.8 > etc/resolv.conf target% ping www.google.com Si nous Utilisions la glibc au lieu de la uclibc, il serait alors nécessaire de configurer le fichier /etc/nsswitch.conf. Il serait possible de choisir parmi différents backends pour gérer les authentifications et le réseau. Le reste de la configuration réseau s effectue normalement dans /etc/network, puis en utilisant ifup et ifdown Pour utiliser le dhcp, ne pas oublier de recopier le fichier examples/udhcp/simple.script fourni avec busybox vers /usr/share/udhcpc/default.script Sysmic - J. Pouiller Formation à Linux Embarqué 109 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Ajouts d utilisateurs Ajout d utilisateurs (nécessaire pour beaucoup d applications dont Dropbear) host$ echo root:x:0:0:root:/root:/bin/sh > etc/passwd host$ echo root:x:0: > etc/group host$ echo "::sysinit:login" >> etc/inittab root::0:0:root:/root:/bin/sh créerait un utilisateur sans mot de passe Possibilité de calculer les mots de passe avec mkpasswd. Voir mkpasswd -m help Possibilité de gérer les mots de passe dans /etc/shadow (shadow(5)) pour plus de sécurité : host$ echo root:x::::::: > etc/shadow Sysmic - J. Pouiller Formation à Linux Embarqué 110 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Dropbear Serveur et client ssh Procédure classique (ou presque, cf. INSTALL) host$ wget http://matt.ucc.asn.au/dropbear/ releases/dropbear-0.53.tar.bz2 host$ tar xvjf dropbear-0.53.tar.bz2 host$ cd dropbear; mkdir build; cd build host$../configure --disable-zlib --host=armlinux --build=i386 --prefix=$(pwd)/../ install host$ make PROGRAMS="dropbear dbclient dropbearkey dropbearconvert scp" host$ make install Sysmic - J. Pouiller Formation à Linux Embarqué 111 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Dropbear Gestion des clefs autorisées host$ mkdir -p etc/dropbear host$ mkdir -p root/.ssh host$ cat ~/.ssh/id_dsa.pub >> root/.ssh/ authorized_keys Génération des clefs host : target% dropbearkey -t rsa -f /etc/dropbear/ dropbear_rsa_host_key target% dropbearkey -t dss -f /etc/dropbear/ dropbear_dss_host_key target% dropbear -E host$ echo "ttys0::respawn:/sbin/dropbear -EF" >> etc/inittab host$ ssh root@target Dropbear nécessite un certain nombre de fonctionnalités de notre Linux. Le faire fonctionner est un bon test de compatibilité de notre Sysmic - J. Pouiller Formation à Linux Embarqué 112 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler le cross-compiler et la libc Le compilateur et la libc se compilent ensemble On peut identifier la toolchain à son triplet : <CPU>-<VENDOR>-<SYSTEM> <SYSTEM> ~ <KERNEL>-<OS> <KERNEL> = linux <OS> est une notion plus floue : gnu, ulibc, glibc, ulibcgnueabi... Pour gcc, on abbrège souvent le triplet en omettant <VENDOR> Exemples : ppc85-e8541-linux-gnu arm9-atmel-linux-ulibceabi sh4-st-unknown : Pas de libc, permet de compiler le noyau et u-boot, mais pas d application user i586-pc-mingw32msvc : Target windows Attention, ca n est pas une science exacte Sysmic - J. Pouiller Formation à Linux Embarqué 113 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler le cross-compiler et la libc 3 étapes : On compile arm-unknown-gcc On configure le noyau pour installer les headers On compile la libc avec arm-unknown-gcc et le noyau préconfiguré, on compile le noyau On compile arm-linux-libc-gcc Difficultés : Assez complexe Souvent des problèmes de compatibilité entre les versions Sysmic - J. Pouiller Formation à Linux Embarqué 114 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler le cross-compiler et la libc Différentes libc : glibc ( GNU C Library, la vénérable) eglibc ( Embedded GNU C Library, meilleur support des diverses architectures. Utilisée depuis peu sur diverses distributions desktop ) newlib (utilisée par Cygwin) µclibc (très utilisée dans l embarqué) dietlibc (encore plus petite que µlibc destinée à la compilation statique) bionic (Android) Sysmic - J. Pouiller Formation à Linux Embarqué 115 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler la toolchain Crosstool-NG Crosstool-NG : Système automatisant toute la procédure et intégrant les patchs connus pour rendre compatible certains systèmes Principalement maintenu par Yann Morin (cocoricco) Il n existe pas de paquet, nous devons donc le compiler nous même : host% apt-get install automake libtool texinfo flex bison gawk... host$ wget http://crosstool-ng.org/download/ crosstool-ng/crosstool-ng-1.13.4.tar.bz2 host$ tar xvzf crosstool-ng-1.13.4.tar.bz2 host$ cd crosstool-ng-1.13.4 host$./configure && make host% make install Sysmic - J. Pouiller Formation à Linux Embarqué 116 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler la toolchain Crosstool-NG Préparation du répertoire de build $ mkdir ct-build ct-dl $ cd ct-build $ ct-ng help Partons de l exemple le plus proche de notre configuration $ ct-ng list-samples $ ct-ng arm-unknown-linux-uclibcgnueabi Vérifions que le l exemple compile $ ct-ng build Sysmic - J. Pouiller Formation à Linux Embarqué 117 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler la toolchain Crosstool-NG Configurons notre chaîne de compilation finale $ ct-ng clean $ ct-ng menuconfig Sysmic - J. Pouiller Formation à Linux Embarqué 118 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler la toolchain Crosstool-NG Compilons $ chmod 777 /opt $ ct-ng build $ ct-ng tarball Testons en statique host$ /opt/arm-sysmic-linux-uclibcgnueabi/bin/arm-sysmic-linuxuclibcgnueabi-gcc -static -Wall hello.c -o hello-mygcc-static target$./hello-mygcc-static Testons en dynamique host$ /opt/arm-sysmic-linux-uclibcgnueabi/bin/arm-sysmic-linuxuclibcgnueabi-gcc -Wall hello.c -o hello-mygcc target$./hello-mygcc Sysmic - J. Pouiller Formation à Linux Embarqué 119 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Compiler la toolchain Crosstool-NG Il possible (probable) que les bibliothèques et le format de binaire ne soient pas compatibles avec la toolchain existante. Il est alors nécessaire de recopier les bibliothèques provenant de toolchain et de recompiler TOUTES les binaires du système Ajoutons quelques liens symboliques bien pensés host$ cd /opt/arm-unknown-linux-uclibcgnueabi/bin host$ for i in arm-unknown-linux-uclibcgnueabi-*; do > ln -s $i arm-linux-${i#arm-unknown-linux-uclibcgnueabi-}; > done N espérez pas compiler du premier coup. Mais autrefois, c était pire! Sysmic - J. Pouiller Formation à Linux Embarqué 120 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Création du rootfs Pour créer une image jffs2, vous devez au minimum spécifier le répertoire de source, l image de destination, l endianness et le padding : target% cat /proc/mtd host% apt-get install mtd-utils host$ mkfs.jffs2 -l -p -r nfs -o rootfs.jffs2 Afin de rendre notre image plus performante, ajustons la taille des pages, supprimons les cleanmarkers (on pourrait aussi utiliser -c 0) et changeons le propriétaires des fichier en root : host$ mkfs.jffs2 -l -p -q -n -s 2048 -e 128 -r nfs -o rootfs.jffs2 Sysmic - J. Pouiller Formation à Linux Embarqué 121 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Recopier le système sur la flash Le plus générique pour recopier la flash sur la cible est de démarrer Linux par un autre moyen (NFS ou partition de rescue) et d utiliser les outils Linux. Il existe des fichiers devices mtd* et mtdblock* : Les fichiers block ne sont là que pour la compatibilité avec certains outils. Ils ne gèrent pas les badblock et les clean markers. Il est préférable de passer le plus possible par les fichiers mtd* Les flashs doivent être écrites en prenant certaines précautions (padding sur les pages, etc...). Il est préférable de systématiquement écrire en utilisant les outils spécialisés Toujours commencer par effacer le contenu précédent (on risque sinon des corruptions sur le filesystem) target% flash_eraseall /dev/mtd1 target% cd /tmp Sysmic - J. Pouiller Formation à Linux Embarqué 122 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Recopier le système sur la flash Téléchargeons le rootfs sur notre cible. Nous pouvons avoir des problèmes de place pour stoker cette image. Il est dans ce cas préférable de travailler sur NFS (mais ca n est pas toujours possible). target% tftp -g -r rootfs.jffs2 host target% nandwrite -p /dev/mtd1 rootfs.jffs2 ou bien host$ serve_image 0.0.0.0 1234 rootfs.jffs2 128 target% recv_image host 1234 /dev/mtd1 Test target% mkdir /tmp/mtd1 target% mount -t jffs2 /dev/mtdblock1 /tmp/mtd1 Sysmic - J. Pouiller Formation à Linux Embarqué 123 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Recopier le système sur la flash Il est possible d effectuer cette opération à partir de U-Boot. Nous allons utiliser TFTP sans démarrer dessous. Désactivons l autostart uboot> set autostart no Toujours effacer la flash avant de flasher uboot> nand erase clean 1000000 7800000 On place l image en mémoire afin de la flasher uboot> tftp 21000000 rootfs.arm.jffs2 uboot> nand write 21000000 1000000 5A0000 Sysmic - J. Pouiller Formation à Linux Embarqué 124 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Recopier le noyau sur la flash L opération est similaire au filesystem. Dans la plupart des cas, on place le noyau à part sur une autre partition de la flash. Nous n avons alors pas besoin de filesystem : Sous Linux target% flash_erase /dev/mtd0 0x400000 0 target% cd /tmp target% tftp -g -r uimage target% nandwrite -s 0x400000 -p /dev/mtd0 uimage Sous U-boot uboot> tftp 21000000 uimage uboot> nand erase clean 400000 200000 uboot> nand write 21000000 400000 200000 Sysmic - J. Pouiller Formation à Linux Embarqué 125 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Ubifs Ubi ajoute une couche d abstraction à la flash Il a le même rôle que controlleur matériel de mémoire flash sur les clefs USB Ubi est géré en volume. A l intérieur d un volume, il est possible d avoir plusieurs partition Ubifs est un filesystem qui optimise les accès à la flash au dessus d UBI Sysmic - J. Pouiller Formation à Linux Embarqué 126 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Ubifs Création d une partition Ubifs : host% mkfs.ubifs -m 2048 -e 128KiB -c 960 -d / home/user/nfs -o rootfs.ubifs Integration dans un volume UBI : host$ cat <<EOF > ubinize.cfg >[rootfs] >mode=ubi >image=rootfs.ubifs >vol_id=0 >vol_type=dynamic >vol_name=rootfs >vol_alignment=1 9 EOF host$ ubinize -p 128KiB -m 2048 -o rootfs.ubi / tmp/ubinize.cfg Sysmic - J. Pouiller Formation à Linux Embarqué 127 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Ubifs Flashage. Remarquez que l utilisation de ubiformat permet de conserver les erase counters target% ubiformat /dev/mtd1 -f rootfs.ubifs On peut maintenant monter le volume puis la partition target% ubiattach /dev/ubi_ctrl -m 1 target% mount -t ubifs /dev/ubi0_0 /tmp/ubi0 Remarquez que le volume doit être attaché avant de pouvoir monter la partition. Du coup, démarrer sur une partition ubifs possède une syntaxe particulière : ubi.mtd=rootfs rootfstype=ubifs root=ubi0:0 Sysmic - J. Pouiller Formation à Linux Embarqué 128 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Monter le rootfs sur l hôte L hôte ne possédant pas de flash, nous devons la simuler pour pouvoir monter le rootfs : Chargeons le module permettant l émulation d une flash et copions notre image sur la flash virtuelle host% modprobe mtdram total_size=65536 erase_size=256 host% nandwrite -p /dev/mtd0 rootfs.jffs2 Alternativement, il est possible de directement mapper un fichier sur une flash avec block2mtd host% losetup /dev/loop0 rootfs.jffs2 host% modprobe block2mtd block2mtd=/dev/loop0 host% mount -t jffs2 /dev/mtdblock0 nfs-mount Sysmic - J. Pouiller Formation à Linux Embarqué 129 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Monter le rootfs sur l hôte Chargeons la couche d émulation par block et le filesystem host% modprobe mtdblock host% modprobe jffs2 Copie de notre image host% mkdir jffs2-mount host% mount -t jffs2 /dev/mtdblock0 jffs2-mount Sysmic - J. Pouiller Formation à Linux Embarqué 130 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Qu est-ce que Qemu? Machine Virtuelle Comparé à VirtualBox et VMWare : Plus polyvalent...mais un peu moins intuitif (possibilité d utiliser qtemu ou qemulator) Rapide car : Utilise la compilation JIT (Just-In-Time) Utilise des extensions du processeur pour gérer les adresses virtuelles (Module KVM, Nested paging) host% apt-get install qemu-kvm-extras Sysmic - J. Pouiller Formation à Linux Embarqué 131 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Qu est-ce que Qemu? Emule : Simplement un jeux d instruction Toutes les grandes architectures sont supportées Les appels système sont alors bindez vers les appels systèmes de l hôte host% qemu-arm./hello-arm-static host% qemu-arm -L../arm-linux-uclibceabi/./hello-arm-debug Utilisé par Scratchbox Scratchbox crée un chroot et utilise fakechroot Qemu doit être compilé en static pour être utilisé avec fakechroot (sombre histoire de libld) Ne permet pas d avoir un périphérique virtuel Un système Il est possible d émuler des périphériques non existants sur PC Il est possible avec un peu d effort de simuler des périphériques spéciaux. Simulation de systèmes complets. QA Sysmic - J. Pouiller Formation à Linux Embarqué 132 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Qu est-ce que Qemu? Le port série de l AT91 n est pas présent dans la liste des périphériques de Qemu On va donc simuler une autre board host$ wget http://wiki.qemu.org/download/arm-test-0.2. tar.gz host$ tar xvzf arm-test-0.2.tar.gz host$ qemu-system-arm -M integrator -cpu arm926 -m 16 -kernel zimage. integrator -initrd arm_root.img host$ qemu-system-arm -M integrator -cpu arm926 -m 16 -kernel zimage. integrator -initrd arm_root.img -nographic -append "console=ttyama0" host$ qemu-system-arm -M integrator -cpu arm926 -m 16 -kernel zimage. integrator -nographic -append "console=ttyama0 root=/dev/nfs nfsroot =10.0.2.2:/home/user/nfs ip=10.0.2.15" Sysmic - J. Pouiller Formation à Linux Embarqué 133 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Automatisation Buildroot But : créer un filesystem root Utilisation de Kconfig Permet d automatiser la création de la toolchain, du noyau, de busybox et d environ 300 outils serveurs http, ftp, ssh, etc.. outils réseau, wireless, bluetooth, etc... Serveur X, gtk Architecture assez propre Extension relativement simple ou nous retrouvons les commandes utilisées pour compiler des programmes tiers C est un peu l extension de Busybox Sysmic - J. Pouiller Formation à Linux Embarqué 134 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Automatisation Buildroot Récupération des sources host$ wget http://buildroot.uclibc.org/ downloads/buildroot-2010.11.tar.bz2 host$ tar xvf buildroot-2010.11.tar.bz2 host$ cd buildroot-2010.11 Utilisation d une configuration pré-établie comme base de configuration host$ make usb-a9260_defconfig host$ make menuconfig host$ make linux26-menuconfig host$ make uclibc-menuconfig host$ make busybox-menuconfig host$ make all Documentation : http://buildroot.uclibc.org/buildroot.html Sysmic - J. Pouiller Formation à Linux Embarqué 135 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Automatisation OpenEmbedded et Yocto But : créer une distribution type Debian Gère un système de paquets Assez lourd à la configuration Très lourd de créer un nouveau type de cible... mais relativement simple de gérer des dizaines de cibles Beaucoup de paquets sont déjà préparés ( 1800)... Principalement, toute la suite Gtk Opie Yocto remplace peu à peu OpenEmbedded dans les nouveau projet Il est poussé pour la Linux Foundation Sysmic - J. Pouiller Formation à Linux Embarqué 136 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Automatisation Strachbox but : créer une distribution type Debian Utilisé par Meego (Nokia, intel, Renault, etc..) et Android (en cours) packagé : apt-get install scratchbox2 Coquille vide On peut installer l environnement de Maemo ou de Android Basé sur un fonctionnement hybride avec qemu On compile avec le cross-compiler mais le reste est exécuté avec qemu ou en ssh sur la cible S utilise comme un environnement de compilation normal Rend la cross-compilation transparente Fonctionne pour ARM and x86 targets (PowerPC, MIPS and CRIS targets are experimental) Permet de compiler certains paquets ne pouvant pas être cross-compilés (Notablement Python) Dépend du bon fonctionnement de qemu Sysmic - J. Pouiller Formation à Linux Embarqué 137 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Qemu et Scratchbox Installation host% apt-get install scratchbox2 host$ mkdir scratchbox host$ cd scratchbox Initialisation de l environnement. Nous utilisons qemu-arm pour lancer nos binaires cibles et arm-linux-gcc comme compilateur host$ sb2-init -c qemu-arm -n A926 arm-linuxgcc Démarrage de l environnement host$ sb2 Sysmic - J. Pouiller Formation à Linux Embarqué 138 / 254

Booter par réseau Compilation des differents éléments Quelques ajouts Bootstrapper la toolchain Flasher le rootfs Simuler Automatisation Qemu et Scratchbox La cross-compilation est transparente qemu$ gcc hello.c -static -o hello-sb2-static qemu$ file hello-sb2-static qemu$./hello-sb2-static qemu$ gcc hello.c -o hello-sb2 qemu$ file hello-sb2 Comme sur la cible, nous avons besoin que les bibliothèques soient bien configurées dans notre environnement qemu$ cp -a /opt/arm-unknown-linuxuclibcgnueabi/arm-unknown-linuxuclibcgnueabi/sysroot/lib. qemu$./hello-sb2 Sysmic - J. Pouiller Formation à Linux Embarqué 139 / 254

Options principales du noyau Création de modules Notre premier device Troisième partie III Modules noyau Sysmic - J. Pouiller Formation à Linux Embarqué 140 / 254

Options principales du noyau Création de modules Notre premier device 15 Options principales du noyau Configuration globale Fonctionnalités du noyau Les options de boot Le réseau Les systèmes de fichiers Les drivers Autres options 16 Création de modules Template Compilation externe Licences Compilation interne 17 Notre premier device Sysmic - J. Pouiller Formation à Linux Embarqué 141 / 254

Options principales du noyau Création de modules Notre premier device Configuration globale General setup : Prompt for development and/or incomplete code/drivers : Débloque les options de compilation pour les drivers/options instables (staging, etc...) Cross-compiler tool prefix : Affecte la variable CROSS_COMPILE Local version : Ajoute un identifiant à la version. Indispensable dans les phases d intégration. La version peut être lue dans /proc/version. Il est aussi possible de faire make kernelrelease dans un répertoire de compilation du noyau. Automatically append version information : Ajoute l identifiant git à la version. Indispensable dans les phases de développement Kernel compression mode : Permet de choisir le type de compression. Chaque algorithme a ses inconvénients et ses intérêts. SWAP : Permet de gérer un espace d échange dur un disque Sysmic - J. Pouiller Formation à Linux Embarqué 142 / 254

Options principales du noyau Création de modules Notre premier device Configuration globale SYSVIPC et MQUEUE : Communication inter-processus définis par Posix IKCONFIG : Embarque le.config dans le noyau EXPERT et EMBEDDED Débloque les options permettant principalement de réduire la taille du noyau en supprimant des modules importants CC_OPTIMIZE_FOR_SIZE : Compile avec -Os KPROBES, PERF_EVENTS, PROFILING, GCOV_KERNEL : Active les différentes instrumentations du noyau Sysmic - J. Pouiller Formation à Linux Embarqué 143 / 254

Options principales du noyau Création de modules Notre premier device Les périphériques de block MODULES : Active la gestion des modules BLOCK : Il est possible de désactiver la gestion des périphériques de block si votre système n utilise que de la mémoire flash. IO Schedulers : Permet de choisir un ordonnanceur d E/S différent de celui proposé en standard System type : Permet de choisir le type d architecture et de chipset Il est possible de désactiver certains cache lors des phases de développement Vous trouverez aussi dans ce menu les options relatives au jeu d instructions accepté Sysmic - J. Pouiller Formation à Linux Embarqué 144 / 254

Options principales du noyau Création de modules Notre premier device Options de l horloges Kernel features HZ (pas sur ARM) : Définit l intervalle de réordonnancement de l ordonnanceur. Plus cette valeur est forte, plus l overhead introduit par le changement de contexte est important et plus les temps de réponses des tâches sont courts NO_HZ : Permet de rendre la période de réordonnancement des tâches dynamique. Devrait permettre un léger gain de CPU (finalement négligeable avec l ordonnanceur en o(1)). Permet surtout de gagner en consommation électrique. HIGH_RES_TIMER : Gère les timers avec une horloge différente de l ordonnanceur (l horloge est alors gérée comme un périphérique à part). Permet d obtenir une bien meilleure précision sur les mesure de temps, à condition que votre matériel possède une horloge HighRes. Sysmic - J. Pouiller Formation à Linux Embarqué 145 / 254

Options principales du noyau Création de modules Notre premier device Options de l ordonnanceur Preemption Model : Permet d activer la préemption du noyau. Le pire temps réponse sont améliorés, mais le temps moyen est généralement moins bon. Un noyau préemptif stresse beaucoup plus de code. Ne pas activer si vous utilisez des drivers extérieur non garanti pour cette option. RT_PREEMPT (sur certaines architectures seulement) : Permet de threader les IRQ et ainsi de remplacer les spinlock par des mutex. Ajoute un protocole d héritage de priorité aux mutex. Le kernel devient alors totalement préemptif. A n utilisez que lors d application temps réelle. Etudiez des solutions à base d hyperviseurs. Ne confondez pas la préemption du noyau avec la préemption des tâches utilisateur. Sysmic - J. Pouiller Formation à Linux Embarqué 146 / 254

Options principales du noyau Création de modules Notre premier device Option de gestion de la mémoire EABI, OABI, etc... : Différentes format d appel des fonctions. Spécifique à ARM (mais très important) Memory Model : Permet de gérer les futurs systèmes à mémoire asymétriques entre les CPU COMPACTION : Permet de compresser les page de mémoire plutôt que les mettre en swap. Particulièrement utile dans les systèmes sans swap! KSM : Permet de fusionner les page mémoire identiques. Uniquement utile avec des machines virtuelles ou des chroot. Sinon, les noyau sait que le fichier est déjà en mémoire et ne duplique pas la page Sysmic - J. Pouiller Formation à Linux Embarqué 147 / 254

Options principales du noyau Création de modules Notre premier device Configuration du boot et du FPE Boot options : Flattened Device Tree : Utilise OpenFirmware, le nouveau format de description matériel appelé aussi Flatten Device Tree Default kernel command string : Permet de passer des paramètres par défaut au noyau (nous verrons cela un peu plus loin) boot loader address : Permettent de démarrer le noyau à partir d une ROM, d une MMC, etc... Kernel Execute-In-Place from ROM : Permet d exécuter un noyau non compressé à partir d une ROM Floating point emulation : Si une instruction sur des nombres à virgule flottante est rencontrée et ne peut pas être exécutée, le noyau peut alors émuler l instruction (voir aussi -msoft-float) Sysmic - J. Pouiller Formation à Linux Embarqué 148 / 254

Options principales du noyau Création de modules Notre premier device Configuration réseau Networking : Possibilité d activer les innombrables protocoles réseaux de niveaux 1, 2 et 3 Network options : Beaucoup de fonctionnalité réseau : client dhcp, bootp, rarp, ipv6, ipsec, les protocole de routage, gestion de QoS, support des VLAN, du multicast, Unix domain sockets : Les sockets UNIX (cf. sortie de netstat) TCP/IP networking : Les sockets bien connue TCP/IP Netfilter : Le firewall de Linux. D innombrable options. Permet l utilisation d iptables si l option IPTABLES est active. Sysmic - J. Pouiller Formation à Linux Embarqué 149 / 254

Options principales du noyau Création de modules Notre premier device Configuration des systèmes de fichiers File systems : Second extended, Ext3 journalling file, The Extended 4 filesystem : Le file system standard de Linux FUSE : Permet de développer des systèmes de fichiers en espace utilisateur Pseudo filesystems Systèmes de fichiers sans supports physiques TMPFS : File system volatile en RAM. Très utilisé avec des système en flash vu que l accès à la Flash est coûteux en temps et destructeur pour la flash SYSFS et PROC_FS : Permettent au noyau d exporter un certain nombre de donnée interne vers le userland. Beaucoup d outils système tirent lors informations de ces systèmes de fichiers. Ils doivent être montés dans /sys et /proc. /proc est plutôt orienté processus alors que /sys est orienté modules et paramétrage du noyau. Sysmic - J. Pouiller Formation à Linux Embarqué 150 / 254

Options principales du noyau Création de modules Notre premier device Configuration des systèmes de fichiers Miscellaneous filesystems Contient des systèmes de fichiers spécifiques ecrypt filesystem layer : Gestion transparent d un file system codé Journalling Flash File System v2 : Spécialisé pour les Flash avec gestion de l écriture uniforme, des bad blocks et des erase blocks. Compressed ROM file system : Spécialisé pour ROM sans accès en écriture. Squashed file system : Idem cramfs mais fortement compressé Network File Systems NFS client support : File system sur ethernet. Très utilisé dans l embarqué durant les phases de développement Root file system on NFS : Permet de démarrer le noyau sur une partition NFS Sysmic - J. Pouiller Formation à Linux Embarqué 151 / 254

Options principales du noyau Création de modules Notre premier device Configuration des Drivers Device Drivers Des centaines de drivers. Notons : path to uevent helper : Le programme apellé lorsqu un nouveau périphérique est détecté (cf. /proc/sys/kernel/hotplug et /sys/kernel/uevent_helper) Maintain a devtmpfs filesystem to mount at /dev : Un tmpfs spécifique pour les devices automatiquement monté sur /dev. Les fichiers devices sont alors automatiquement créés sans l aide d un programme extérieur. Memory Technology Device : Les flashs Staging drivers : Des drivers en cours de bêta Sysmic - J. Pouiller Formation à Linux Embarqué 152 / 254

Options principales du noyau Création de modules Notre premier device Configuration du noyau Mais aussi : Kernel Hacking : Options concernant le débugging du noyau. Security Options : Plusieurs framework permettant de gérer des droits plus fin sur les programmes exécutés et/ou de garantir l intégrité des donnée à l aide de TPM. Cryptographic API : Fonctions de cryptographies sélectionnées automatiquement par d autres modules (particulièrement les protocoles réseaux) Library routines : Idem Cryptographic API mais avec principalement des calculs de checksum. Sysmic - J. Pouiller Formation à Linux Embarqué 153 / 254

Options principales du noyau Création de modules Notre premier device Les modules noyau my_module // Declare special functions module_init(m_init); module_exit(m_exit); // These uppercase macro will be added to informative section of module (.modinfo) MODULE_AUTHOR("Jérôme Pouiller"); MODULE_DESCRIPTION("A pedagogic Hello World"); MODULE_LICENSE("Proprietary"); MODULE_VERSION("1.1"); Sysmic - J. Pouiller Formation à Linux Embarqué 154 / 254

Options principales du noyau Création de modules Notre premier device Quelques macros de base Ces macros permettent de placer des informations sur des symboles particulier dans module ; Déclare la fonction à apeller lors du chargement du module module_init Déclare la fonction à appeller lors du déchargement du modules module_exit Déclare un auteur du fichier. Peut apparaitre plusieurs fois. MODULE_AUTHOR Description du modules MODULE_DESCRIPTION Version du module MODULE_VERSION Sysmic - J. Pouiller Formation à Linux Embarqué 155 / 254

Options principales du noyau Création de modules Notre premier device Les modules noyau my_module #include <linux/kernel.h> #include <linux/module.h> #include <linux/init.h> static int init m_init(void) { pr_info("my_module init\n"); return 0; 9 } static void exit m_exit(void) { pr_info("my_module exit\n"); } Sysmic - J. Pouiller Formation à Linux Embarqué 156 / 254

Options principales du noyau Création de modules Notre premier device Les modules noyau my_module Makefile : obj-m := my_module.o Puis, on appelle : host$ KDIR=/lib/modules/$(uname -r)/build host$ make -C $KDIR ARCH=arm M=$(pwd) modules Sysmic - J. Pouiller Formation à Linux Embarqué 157 / 254

Options principales du noyau Création de modules Notre premier device Les modules noyau my_module Pour améliorer le processus, on ajoute ces lignes dans le Makefile : KDIR?= /lib/modules/$(shell uname -r)/build default: modules install: modules_install modules modules_install help clean: $(MAKE) -C $(KDIR) M=$(shell pwd) $@ et on appelle host$ make ARCH=arm CROSS_COMPILE=arm-linux- KDIR =../linux-3.5.7/usb-a9260 Sysmic - J. Pouiller Formation à Linux Embarqué 158 / 254

Options principales du noyau Création de modules Notre premier device Gérer les modules Avoir des informations sur le module host$ modinfo my_module.ko Charger un module target% insmod my_module.ko Décharger un module target% rmmod my_module Afficher le buffer de log du kernel target$ dmesg Charger/décharger un module correctement installé/indexé target% modprobe my_module target% modprobe -r my_module Mettre à jour le fichier de dépendance target% depmod Sysmic - J. Pouiller Formation à Linux Embarqué 159 / 254

Options principales du noyau Création de modules Notre premier device Paramètres Il est possible de passer des paramètres aux modules : target$ modinfo my_module.ko target% insmod my_module.ko param=2 Nous devons déclarer le paramètre à l aide de la macro module_param. #include <linux/moduleparam.h> module_param(param, int, 0644); La paramètre doit évidement être alloué : static int param = 0; Il est fortement recommandé de documenter le paramètre MODULE_PARM_DESC(param, "Display this value at loading and unloading"); Sysmic - J. Pouiller Formation à Linux Embarqué 160 / 254

Options principales du noyau Création de modules Notre premier device /sys Etudions /sys /sys/module/my_module/parameters : paramètres. Modifiable si déclaré modifiables /sys/module/my_module/sections : des info sur la zone de chargement Sysmic - J. Pouiller Formation à Linux Embarqué 161 / 254

Options principales du noyau Création de modules Notre premier device Quelques macros de base License. Indispensable MODULE_LICENSE Rend le symbole visible par les autres modules. Il sera alors pris en compte dans le calcul des dépendances de symboles. EXPORT_SYMBOL Idem EXPORT_SYMBOL mais ne permet sont utilisation que pour les modules GPL EXPORT_SYMBOL_GPL Sysmic - J. Pouiller Formation à Linux Embarqué 162 / 254

Options principales du noyau Création de modules Notre premier device Parlons des licenses Le noyau est sous license GPL. Néanmoins, le débat est ouvert sur la possibilité qu un module propriétaire puisse se linker avec. Le débat n est pas tranché. Le noyau laisse la posisbilité à l auteur d exporter ses modules avec EXPORT_SYMBOL ou avec EXPORT_SYMBOL_GPL. Si vous développez un module Propriétaire, vous n aurez pas accès à toute l API du noyau (environ 90% seulement). Il est néanmoins possible de contourner le problème en utilisant un module intermédiaire comme proxy logiciel. Sysmic - J. Pouiller Formation à Linux Embarqué 163 / 254

Options principales du noyau Création de modules Notre premier device Compilation avec Kbuild Fichier Makefile à l intérieur de l arborescence noyau : obj-$(condif_my_option) := my_module.o $(CONFIG_MY_OPTION) sera remplacé par : ø : Non compilé m : compilé en module y : compilé en statique Fichier Kconfig : config MY_OPTION tristate "my_module: A small Hello World sample" help Pedagogic purpose only. To compile it as a module, choose M here. If unsure, say N. Sysmic - J. Pouiller Formation à Linux Embarqué 164 / 254

Options principales du noyau Création de modules Notre premier device Utilisation de Kconfig Chaque entrée config prend comme attribut : Son type et sa description en une ligne : tristate, le plus classique pouvant prendre les valeurs ø, m et y bool pouvant prendre seulement les valeurs n et y int prennant un nombre string prennant une chaîne default Sa valeur par défaut depends on L option n apparait si l expression suivante est vraie. Il est possible de spécifier des conditions complexes avec les opérateurs &&,, = et!= select Active automatiquement les options en argument si l option est activée help Description détaillée de l option. Si votre description ne tient pas en moins de 20 lignes, pensez à écrire une documentation dans Documentation et à y faire référence Sysmic - J. Pouiller Formation à Linux Embarqué 165 / 254

Options principales du noyau Création de modules Notre premier device Utilisation de Kconfig Il est aussi possible : D inclure d autres fichiers avec source De déclarer un sous menu avec menu De demander un choix parmis un nombre fini d options avec choice Sysmic - J. Pouiller Formation à Linux Embarqué 166 / 254

Options principales du noyau Création de modules Notre premier device Les modules noyau my_module Quelques conseils : Pour mettre un code à la norme : host$ apt-get indent host$ scripts/lindent my_module.c host$ scripts/cleanfile my_module.c Voir Documentation/CodingStyle Sauvez l espace de nom du noyau : utilisez des static! Votre code doit être réentrant Sysmic - J. Pouiller Formation à Linux Embarqué 167 / 254

Options principales du noyau Création de modules Notre premier device Obtenir de la documentation host$ make mandocs host% make installmandocs Paquet linux-doc : /usr/share/doc/linux-doc/html/kernel-api Pas de paquet pour ces pages de man Sysmic - J. Pouiller Formation à Linux Embarqué 168 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev Voie classique pour un driver pour communiquer avec le noyau Major, Minor target% mknod my_chardev c <major> <minor> Communication en écrivant/lisant des données target% insmod my_chardev.ko target% echo toto > my_chardev target% cat my_chardev Possibilité de faire un peu de configuration par les ioctl Sysmic - J. Pouiller Formation à Linux Embarqué 169 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev Tentons de faire un driver qui renvois la dernière chaine recue : target% insmod my_chardev.ko target% mknod my_chardev c 249 0 target% echo toto > my_chardev target% cat my_chardev toto Sysmic - J. Pouiller Formation à Linux Embarqué 170 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev Enregistrement du file device #include <linux/fs.h> static int major = 0; static int init m_init(void) { 5 major = register_chrdev(0, "m_chrdev", &m_fops); } static void exit m_exit(void) { unregister_chrdev(major, "m_chrdev"); } Sysmic - J. Pouiller Formation à Linux Embarqué 171 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev &m_fops est une structure contenant les références des callbacks à appeller par le noyau (cf. include/linux/fs.h) : static struct file_operations m_fops = {.owner = THIS_MODULE,.read = m_read,.write = m_write, }; Sysmic - J. Pouiller Formation à Linux Embarqué 172 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev Nous devons maintenant implémenter m_read et m_write static ssize_t m_read(struct file *file, char * user_buf, size_t count, loff_t *ppos) { return 0; } static ssize_t m_write(struct file *file, const char *user_buf, size_t count, loff_t *ppos) { return count; } Effectuons un premier test : target% echo toto > my_chardev target% cat my_chardev Sysmic - J. Pouiller Formation à Linux Embarqué 173 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev Ajoutons la gestion du buffer. Il est necessaire de prendre des précaution pour accéder à la mémoire du programme utilisateur. static char global_buf[255]; static ssize_t m_read(struct file *file, char * user_buf, size_t count, loff_t *ppos) { if (count > idx) count = idx; copy_to_user(user_buf, global_buf, count); idx = 0; 8 return count; } static ssize_t m_write(struct file *file, const char *user_buf, size_t count, loff_t *ppos) { if (count > 255) count = 255; copy_from_user(global_buf, user_buf, count); Sysmic - J. Pouiller Formation à Linux Embarqué 174 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev 3 Protégeons notre code contre les accès concurent : #include <linux/mutex.h> static struct mutex mutex; static ssize_t m_read(struct file *file, char * user_buf, size_t count, loff_t *ppos) { mutex_lock(&mutex); [...] mutex_unlock(&mutex); return count; } static ssize_t m_write(struct file *file, const char *user_buf, size_t count, loff_t *ppos) { mutex_lock(&mutex); 13 [...] mutex_unlock(&mutex); return count; Sysmic - J. Pouiller Formation à Linux Embarqué 175 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev Ajoutons un ioctl : #include "mod2_chr.h" static long m_ioctl(struct file *file, unsigned int nr, unsigned long arg) { if (nr == FIFO_GET_LEN) { 4 int ret = copy_to_user((void *) arg, &idx, sizeof(idx)); return ret; } return -EINVAL; } static struct file_operations m_fops = { [...].unlocked_ioctl = m_ioctl, }; Dans mod2_chr.h : #include <linux/ioctl.h> Sysmic - J. Pouiller Formation à Linux Embarqué 176 / 254

Options principales du noyau Création de modules Notre premier device Communiquer avec le noyau char_dev Testons : #include "mod2_chr.h" int main(int argc, char **argv) { int ret, arg = 42; int fd = open(argv[1], O_RDONLY); ret = ioctl(fd, FIFO_GET_LEN, &arg); 7 printf("returned %m with argument %d\n", -ret, arg); return 0; } Sysmic - J. Pouiller Formation à Linux Embarqué 177 / 254

Debug Couverture Profiling Les sondes Jtag Quatrième partie IV Debuguer Sysmic - J. Pouiller Formation à Linux Embarqué 178 / 254

Debug Couverture Profiling Les sondes Jtag 18 Debug 19 Couverture 20 Profiling 21 Les sondes Jtag Sysmic - J. Pouiller Formation à Linux Embarqué 179 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Utilisation classique. -g3 permet d inclure les symboles de debug 1 host$ gcc -Wall -g3 -c hello.c -o hello.o host$ gcc -Wall -g3 hello.o -o hello-x86-dbg host$ gdb hello-x86-dbg Sysmic - J. Pouiller Formation à Linux Embarqué 180 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Commandes utiles Gestion de l éxecution Point d arrêt à l adresse 0x9876 gdb> b *0x9876 b hello.c:30 Point d arrêt à la ligne 30 du fichier hello.c gdb> b hello.c:30 Point d arrêt sur la fonction main gdb> b main Continuer un programme arrêté gdb> c Démarrer le programme avec arg comme argument gdb> r arg Sysmic - J. Pouiller Formation à Linux Embarqué 181 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Commandes utiles Obtenir des informations Voir la pile d appel gdb> bt Afficher les variable locales à la fonction gdb> i locals Afficher les arguments de la fonction gdb> i args Afficher la valeur de a gdb> p a Afficher la valeur de abs(2 * (a - 4)) gdb> p abs(2 * (a - 4)) Sysmic - J. Pouiller Formation à Linux Embarqué 182 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Commandes utiles Debuguer à chaud Attacher gdb à un processus existant gdb> attach 1234 Arrêter le debug sans arrêter le processus gdb> detach Sysmic - J. Pouiller Formation à Linux Embarqué 183 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Commandes utiles Et plus... Afficher la valeur de i à chaque fois que l on passe sur le point d arrêt 1 gdb> command 1 > silent > p i > c > end Arrêter le programme lorsque la variable i est modifiée ou lue gdb> watch i gdb> awatch i Passer d une thread à une autre gdb> thread 2 gdb> thread 1 Sysmic - J. Pouiller Formation à Linux Embarqué 184 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Utilisation des Cores Dump : Vérifiez la limite coredump size avec ulimit -c Core Dump automatique en cas de crash Forcé avec kill -QUIT ou <Ctrl+\> (man kill) Créé avec la commande gdb gcore (voir avec attach) (malheureusement, ne fonctionnement pas en mode debug croisé) Il est possible de savoir à quelle binaire est attaché le coredump avec file Sysmic - J. Pouiller Formation à Linux Embarqué 185 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur distante Utilisation croisée Compilation host$ arm-linux-gcc -g3 -c hello.c -o hello.o host$ arm-linux-gcc -g3 hello.o -o hello-armdbg Démarrage du serveur de debug target$ gdbserver *:1234 hello host$ arm-ulibceabi-gdb hello Configuration des chemins > set solib-absolute-prefix /home/user/nfs Connexion au serveur de debug > target remote target:1234 Sysmic - J. Pouiller Formation à Linux Embarqué 186 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur distante Debug d une application en cours d éxecution Execution target$./hello > /dev/null & On attache gdb au processus target$ gdbserver *:1234 --attach $! configuration classque de gdb host$ arm-linux-gdb > exec-file hello > set solib-absolute-prefix /home/user/nfs > target remote target:1234 Remarque : Si vous dugger une programme utilisant libpthread, vous devez avoir le fichier libthread_db pour que gdb puisse décoder les emplacements les piles des threads Libérons le processus > detach Sysmic - J. Pouiller Formation à Linux Embarqué 187 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Séparer les symbols de debug permet : de n uploader sur la cible que le nécéssaire à l éxecution. de livrer des binaires strippées en production tout en conservant les possibilités de debug d analyser des core dump produit en production Utilisation de objcopy pour créer le fichier de symboles : host$ arm-linux-objcopy --only-keep-debug hello hello.sym host$ chmod -x hello.sym host$ arm-linux-strip --strip-unneeded hello target$ gdbserver *:1234 hello host$ arm-linux-gdb > target remote target:1234 > symbol-file hello.sym Sysmic - J. Pouiller Formation à Linux Embarqué 188 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer une application utilisateur Sous certaines conditions, il est possible de rendre le chargement des symboles automatique : host$ arm-linux-objcopy --add-gnu-debuglink=hello. sym hello Remarque : l option -g n influence pas le code compilé : $ gcc hello.c -O3 -o hello $ gcc hello.c -O3 -g -o hello.dbg $ strip hello.dbg hello $ cmp hello.dbg hello && echo ok ok Sysmic - J. Pouiller Formation à Linux Embarqué 189 / 254

Debug Couverture Profiling Les sondes Jtag Analyse sans execution Très bons outils pédagogiques strings affiche les chaine de caractères affichables d une binaire ldd affiche quel sera le comportement de ld lors du chargement (en d autres termes, liste les dépendances avec des bibliothèques dynamique) gdb est capable de charger des fichiers objets et d en sortir beaucoup d informations sans execution objdump -h permet d obtenir des information sur le placement des sections dans le fichier objdump -T ou readelf -s ou nm liste les symbols contenu dans un fichier objdump -d permet de désassembler un fichier objet objdump -S permet d obtenir l assembleur intermixé avec les code objdump -C permet de "demangler" des fonction C++ adddr2line permet de convertir une addresse mémoire en numéro ligne dans le code Sysmic - J. Pouiller Formation à Linux Embarqué 190 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer le noyau Activiation d kgdb permettant d embarquer gdbserver dans le noyau : Compilation host$ cp -a build build-dbg host$ make O=build-dbg ARCH=arm CROSS_COMPILE= arm-linux- menuconfig... Compile the kernel with debug info...... KGDB: kernel debugging with remote gdb... host$ make -j3 O=build-dbg ARCH=arm CROSS_COMPILE=arm-linux- uimage L image ELF est beaucoup plus grosse host$ ls -l build-dbg/vmlinux build/vmlinux host$ cp build-dbg/uimage /srv/tftp/uimage -2.6.33.7-dbg Sysmic - J. Pouiller Formation à Linux Embarqué 191 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer le noyau Passage des arguments kgdboc indiquant quel interface kgdb doit utilisé et kgdbwait indiquant que kgdb doit attendre notre connexion avant de continuer le boot uboot> set bootargs ${bootargs} kgdboc=ttys0 kgdbwait uboot> tftp <Ctrl-a q> host$ arm-linux-gdb vmlinux gdb> target remote /dev/ttyusb0 Sysmic - J. Pouiller Formation à Linux Embarqué 192 / 254

Debug Couverture Profiling Les sondes Jtag Il existe des scripts effectuant la procédure automatiquement. A adapter suivant vos besoins. Remarque : Les modules sont des fichiers ELF normaux. Il peuvent être analysés Sysmicavec - J. Pouillerobjdump Formation à Linux Embarqué 193 / 254 Kgdb et les modules Les modules sont chargé dynamiquement. Ils ne sont pas contenu dans le fichier vmlinux Il est nécessaire d indiquer à gdb de charger le module que l on souhaite débuguer Néanmoins, gdb ne peut pas savoir à quel addresse à été chargé le module Ces informations peuvent être récupérées dans /sys/modules/*/sections On peut alors les donner à gdb avec add-symbol-file : target% cat /sys/module/mod2_chr/sections host$ gdb vmlinux > target remote 192.168.1.55:2345 > add-symbol-file my_modules.ko 0xd0832000 \ -s.bss 0xd0837100 -s.data 0xd0836be0

Debug Couverture Profiling Les sondes Jtag ld.so Lors du chargement d une binaire, la bibliothèque ld.so charge les bibliothèques indiquées dans la section.dynamic. Il est possible de changer le comportement de ld.so par des fichier de configuration (/etc/ld.so.conf) ou par des variables d environnement. LD_LIBRARY_PATH permet d ajouter un répertoire ou les bibliothèques seront recherchées. LD_PRELOAD permet de précharger une bibliothèque. Ainsi les symboles définis dans cette bibliothèque surcharge les symboles standards Sysmic - J. Pouiller Formation à Linux Embarqué 194 / 254

Debug Couverture Profiling Les sondes Jtag ld.so #include <stdio.h> #include <unistd.h> unsigned int sleep(unsigned int s) { static int (*real_sleep)(unsigned int) = NULL; if (!real_sleep) real_sleep = dlsym(rtld_next, "sleep"); 10 } printf("try to reveal race-conditions\n"); return real_sleep(5 * s); Sysmic - J. Pouiller Formation à Linux Embarqué 195 / 254

Debug Couverture Profiling Les sondes Jtag ld.so host$ gcc -shared -ldl -fpic mysleep.c -o libmysleep.so target$ LD_PRELOAD=libmysleep.so./hello target$ export LD_PRELOAD=libmysleep.so taregt$./hello Cette technique est utilisé pour tracer et profiler certains évènement Les expert en sécurité l utilisent pour détourner un programme de son but original Enfin, il permet de simuler des problèmes afin de vérifier la robustesse d un programme Sysmic - J. Pouiller Formation à Linux Embarqué 196 / 254

Debug Couverture Profiling Les sondes Jtag strace et ltrace strace permet de d afficher les appels systèmes effectué par un processus. Il a l avantage d afficher beaucoup d informations sous des formes lisible. target$ strace./hello Il est possible de filtrer les appels systèmes à suivre. ltrace est une génératlisation de strace. Il permet de suivre les appels à une bibliothèque extérieure host$ arm-linux-ldd --root../hello target$ ltrace -l /lib/libc.so.0 -e sleep./ hello target$ ltrace -l /lib/libc.so.0 -e malloc -e free /bin/ls Ces outils sont une aide préciseuse lorsque l on souhaite identifier le comportement d une binaire dont nous ne disposons pas des sources. Sysmic - J. Pouiller Formation à Linux Embarqué 197 / 254

Debug Couverture Profiling Les sondes Jtag ptrace ptrace est l appel système permettant le fonctionnement de debuguers et d outils tel que strace et ltrace. Il permet de prendre la main sur un processus, puis d obtenir des informations sur son état et de modifier sa mémoire. Sysmic - J. Pouiller Formation à Linux Embarqué 198 / 254

Debug Couverture Profiling Les sondes Jtag Couverture de code Principe : On instrumente le code généré Entre chaque ligne de C (équialent à plusieurs ligne d assembleur), on ajoute une instruction du type inc $ADDR ADDR est une constante definie à la compilation ADDR pointe sur une entrée d un tableau initialisé à zero Chaque entrée du tableau symbolise une ligne Par conséquent, 100000 ligne augmentra la taille en mémoire de l application d environ 400Ko Lorsque le programme se termine, on écrit le tableau sur le disque (fichiers.gcda) Un fichier index est généré durant la compilation afin de faire le lien entre les lignes du fichier source et les données générées (fichiers.gcno) Fonctionne sur une binaire utilisateur. Permet de valider une campagne de test unitaire. Sysmic - J. Pouiller Formation à Linux Embarqué 199 / 254

Debug Couverture Profiling Les sondes Jtag Couverture de code Utilisation de gcov en natif : Compilation host$ mkdir x86-cov host$ gcc --coverage hello.c -o x86-cov/hello Execution d un scénario d utilisation host$ x86-cov/hello Conversion des fichiers gcda dans un format lisible host$ for i in **/*.gcda; do > gcov -o $(dirname $i) $i > done Convertion des fichier gcda en HTML en utilisant lcov/genhtml host$ lcov -i -o coverage-x86.info -b. -d x86- cov host$ genhtml -o html coverage-x86.info Sysmic - J. Pouiller Formation à Linux Embarqué 200 / 254

Debug Couverture Profiling Les sondes Jtag Couverture de code Utilisation de gcov sur la cible : On précise le répertoire ou les fichier doivent être stockés host$ cd arm-cov host$ arm-linux-gcc --fprofile-generate=/tmp/ data --coverage../hello.c -o hello-arm-cov On execute sur la cible host$ scp hello-arm-cov root@target: target$./hello-arm-cov On récupère les résultats pour les traiter sur le host host$ scp -r root@target:/tmp/data. Sysmic - J. Pouiller Formation à Linux Embarqué 201 / 254

Debug Couverture Profiling Les sondes Jtag Couverture de code Conversion des fichiers gcda dans un format lisible host$ for i in **/*.gcda; do > arm-linux-gcov -o $(dirname $i) $i > done host$ lcov -i -o coverage-arm.info -b.. -d data --gcov-tool arm-linux-gcov host$ genhtml -o html coverage-arm.info host$ firefox html/index.html Fonctionne aussi avec le noyau : CONFIG_LCOV Sysmic - J. Pouiller Formation à Linux Embarqué 202 / 254

Debug Couverture Profiling Les sondes Jtag Valgrind On execute notre programme dans une machine virtuelle. Cette machine virtuelle instrumente les accès en lecture et en écriture à la mémoire. suit les appels aux fonctions malloc et free suit les copie de pointeurs Ainsi, en plus de détecter les zone non désallouées à la sortie du programme, valgrind est capable de détecter : l écriture et la lecture d une zone non allouée (voir aussi DUMA) la lecture d une zone jamais écrite les zone de mémoire n étant plus pointées valgrind peut indiquer les contextes exacts où tous ces évènements se produisent. Sysmic - J. Pouiller Formation à Linux Embarqué 203 / 254

Debug Couverture Profiling Les sondes Jtag Valgrind /* * Test with: * echo 123456 valgrind --leak-check=yes./a.out */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> 10 void fun() { int var; int *stck = &var; int *heap = malloc(2 * sizeof(int)); static int *bss; printf("%d\n", var); initialized // var hasn t been Sysmic - J. Pouiller Formation à Linux Embarqué 204 / 254

Debug Couverture Profiling Les sondes Jtag Valgrind Appellons nos deux fonctions de tests heap[2] = 42; // wrote past the end of the block printf("%d\n", heap[-1]); // read from before start of the block printf("%d\n", stck[-15]); // reading from a bad stack location (detected if outside current frame) 4 read(0, heap, 10); // buffer passed to syscall is too small //read(0, stck, 10); // buffer passed to syscall is too small (not detected) free(heap); printf("%d\n", *heap); // heap was already freed heap = malloc(sizeof(int)); // memory leaks ( definitely lost) stck = heap; //.. even if another variable point on it Sysmic - J. Pouiller Formation à Linux Embarqué 205 / 254

Debug Couverture Profiling Les sondes Jtag Valgrind Valgrind a donné naissance à d autres outils : Cachegrind permet de simuler les lignes de cache du processeur et ainsi d indiquer ou se produise les erreurs de pages (voir aussi perf) Callgrind permet d instrumenter les appels de fonctions. Il génère des graphes d appels et des informations de profiling (voir aussi perf) Hellgrind et DRD instrumente les mécanismes générant des sections critique et détecte les Race Conditions sur les données. Massif detecte les contexte d allocation de mémoire (heap profiling) Ptrcheck suit les blocks pointé et détecte ainsi les overruns (voir aussi DUMA) Sysmic - J. Pouiller Formation à Linux Embarqué 206 / 254

Debug Couverture Profiling Les sondes Jtag Bases Avant de se lancer dans des procédure de profiling complexe, quelques commandes simples : free indique les ressources mémoire disponibles sur le système Les buffers indiquent des données devant être écritent sur le disque (ou sur un IO) mais dont le système repouse l écriture pour des raisons de performances Les caches indiquent des données lue sur le disque (ou sur un IO) conservées en mémoires afin d accélérer les futurs accès time indique les ressources utilisées par un processus Temps total Temps CPU en utilisateur et dans le noyau Nombre de d erreur de page majeure (nécessitant un accès disque) et mineurs Nombre de message socket ( réseau) envoyés/recus Mémoire utilisée en moyenne Nombre d accès aux disques en entrée et en sortie Sysmic - J. Pouiller Formation à Linux Embarqué 207 / 254

Debug Couverture Profiling Les sondes Jtag Bases top indique à peu près les même informations que time mais de manière intéractive ps affiche aussi ces informations sur un ou plusieurs processus en cours d éxecution /proc/${pid}/{stat,statm,status} contiennent les données bruts de ces outils /proc/${pid}/{map,smap,pagesmap} contiennent des infomration très précisesnt aux sujet du mapping mémoire d un processus Sysmic - J. Pouiller Formation à Linux Embarqué 208 / 254

Debug Couverture Profiling Les sondes Jtag perf perf utilise les registre de debug du cpu. Faible overhead. depend du CPU. Le cpu le plus fourni est x86. Obtenir une vue synthétique d un processus target% apt-get install linux-tools-common target$ perf stat./hello-dbg Effectuer une mesure plus précise target$ perf record./hello-dbg target$ perf report Annoter le code avec les information de profiling target$ perf annotate timeattack Sysmic - J. Pouiller Formation à Linux Embarqué 209 / 254

Debug Couverture Profiling Les sondes Jtag perf Même manipulation mais avec les contextes d appel target$ perf record -g./hello-dbg target$ perf report Il est possible d utiliser d autre point de mesure que la consommation CPU target$ perf list target$ perf stat -e cache-misses./hello-dbg target$ perf record -e cache-misses./hello-dbg target$ perf report target$ perf annotate timeattack target$ perf record -e cache-misses -g./hellodbg target$ perf report Sysmic - J. Pouiller Formation à Linux Embarqué 210 / 254

Debug Couverture Profiling Les sondes Jtag oprofile Idem perf, mais moins générique Initialement sur les architectures ST (pas ARM, ni x86) Si vous avez un noyau suffisament récent, oprofile utilise perf comme backend Démarrage du daemon target% opcontrol --init Liste des évènements pouvant être enregistrés target% opcontrol -l Profiling d un évènement target% opcontrol --start --no-vmlinux -e CPU_CLK_UNHALTED:100000:0:1:1 target%./hello target% opcontrol --shutdown Sysmic - J. Pouiller Formation à Linux Embarqué 211 / 254

Debug Couverture Profiling Les sondes Jtag oprofile Génération du rapport target% opreport hello Génération du source annoté target% opannotate --source hello-prof Sysmic - J. Pouiller Formation à Linux Embarqué 212 / 254

Debug Couverture Profiling Les sondes Jtag U-boot Notre vendeur nous fourni une version de u-boot patchée pour notre carte. Dans ce cas, il nous suffit de configurer correctement u-boot et de le compiler : make usb-a9260_config make CROSS_COMPILE=arm-linux- Sysmic - J. Pouiller Formation à Linux Embarqué 213 / 254

Debug Couverture Profiling Les sondes Jtag U-boot Si nous voulons ajouter une nouvelle carte, nous devons : Ajouter un nouveau fichier d entêtes dans include/configs Ajouter un nouveau répertoire dans board A priori, vous n aurez pas besoin d ajouter une architecture et encore moins un jeu d instruction Ajouter une cible dans le Makefile Cette cible appellera mkconfig mkconfig prend en paramètre le nom du fichier d entête, le type de CPU, d architecture et de carte, ainsi que le nom du vendeur et le modèle de chipset../mkconfig usb-a9260 arm arm926ejs usb-a9260 Calao at91sam926x Sysmic - J. Pouiller Formation à Linux Embarqué 214 / 254

Debug Couverture Profiling Les sondes Jtag U-boot mkconfig créera un fichier config.h pointant sur votre fichier entête et un fichier config.mk contenant : ARCH = arm CPU = arm926ejs BOARD = usb-a9260 VENDOR = Calao SOC = at91sam926x Placer les drivers nécéssaire à votre carte dans board/usb-a9260. L implémentation des drivers est proche de ce que l on trouve dans le noyau Linux. Il suffit d associer les callback aux champs d une structure. Le fichier usb-a9260.h devra contenir la configuration des fonctionnalité de u-boot Vous trouverez des options de configuration haut niveau telles que les commandes devant être incluse Vous trouverez aussi les paramètre d initialisation bas niveau pour le CPU et l architecture (timing mémoire, etc...) Sysmic - J. Pouiller Formation à Linux Embarqué 215 / 254

Debug Couverture Profiling Les sondes Jtag OpenOCD Qu est-ce qu une sonde Jtag? TAP (Test Access Port) est un module matériel capable de traiter des commande de debug (souvent sur le processeur). Notre TAP est embarqué sur le ARM9260EJ-S. JTAG est un standard de communication normalisé pour les TAP. Une hardware interface dongle doit être utilisée pour empaqueter le standard JTAG dans un autre protocole (ethernet, USB, serie...) afin d être traitable par un PC. Nous utilisons la FTDI FT2232 pour cette partie. Cette puce permet de présenter à l host deux périphérique USB : Le JTAG et la console RS232. Sysmic - J. Pouiller Formation à Linux Embarqué 216 / 254

Debug Couverture Profiling Les sondes Jtag OpenOCD Qu est-ce qu une sonde Jtag? OpenOCD permet de gérer la communication avec la puce FTDI et de traduire le langage de bas niveau JTAG en langage de debug gdb On trouve souvent des sonde JTAG incluant déjà l équivalent de OpenOCD et sachant déjà communiquer avec gdb (par ethernet ou série très souvent). (Abatron, Lautherbar, etc...) On peut reconnaitre les deux types de sondes à leur prix. Les première coute au maximum quelques centaines d euros alros que les secondes coutent rarement moins de 1000euros. Sysmic - J. Pouiller Formation à Linux Embarqué 217 / 254

Debug Couverture Profiling Les sondes Jtag OpenOCD Beaucoup de sondes JTAG (USB, port parallèle, port serie) sont supportées par OpenOCD : doc/openocd/jtag-hardware-dongles.html. host% apt-get install openocd Sysmic - J. Pouiller Formation à Linux Embarqué 218 / 254

Debug Couverture Profiling Les sondes Jtag OpenOCD Il est nécessaire de corriger un bug dans le fichier de configuration de notre cible : host% ln -s at91sam9260.cfg /usr/share/openocd/ scripts/target/at91sam9260minimal.cfg Nous pouvons maintenant utiliser notre sonde Jtag host$ openocd -f interface/calao-usb-a9260-c01.cfg host$ telnet 127.0.0.1 4444 > help > reset init > arm reg > arm disassemble 0x00000000 5 > arm disassemble 0x00000058 5 > ^C Sysmic - J. Pouiller Formation à Linux Embarqué 219 / 254

Debug Couverture Profiling Les sondes Jtag OpenOCD avec gdb Lancement de gdb host$ arm-linux-gdb Connexion avec OpenOCD gdb> target remote localhost:3333 monitor permet d envoyer des commande brutes à OpenOCD gdb> monitor reset init gdb> monitor help Vu que nous ne sommes pas lié à une binaire, nos commandes sont limitées. Nous pouvons néanmoins dumper la mémoire et placer des breakpoints gdb> x/10i 0 gdb> hbreak *0x58 gdb> b *0x0 Sysmic - J. Pouiller Formation à Linux Embarqué 220 / 254

Debug Couverture Profiling Les sondes Jtag OpenOCD Deux mots sur la configuration : Les fichiers de interfaces/ contiennent les informations sur le driver à utiliser et comment s y connecter. Le repertoire target/ contient la configuration du microcontrolleur en lui-même. La documentation se trouve sur http://openocd.sourceforge.net/doc/openocd.html ou dans /usr/share/doc/openocd Il est possible d avoir l aide contextuelle sur une commande help command Sysmic - J. Pouiller Formation à Linux Embarqué 221 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer U-Boot Notre fichier de configuration de OpenOCD ne lance pas la cible à la vitesse maximum. Laissons cette tâche à u-boot, puis arrêtons la cible. Hit any key to stop autoboot: 0 u-boot> Arrêtons la cible afin de pouvoir travailler dessus telnet> halt Configurons une vitesse de transmission raisonnable telnet> jtag_hkz 10000 telnet> arm7_9 dcc_downloads enable Chargeons l image ELF de u-boot telnet> load_image.../u-boot (elf,13secondes) Sysmic - J. Pouiller Formation à Linux Embarqué 222 / 254

Debug Couverture Profiling Les sondes Jtag Debuguer U-Boot Vérifions que nous retrouvons bien le code assembleur de U-boot à l endroit indiqué telnet> disassemble XXXX Sautons jusqu à cette addresse telnet> resume XXX Arrêtons le démarrage telnet> halt Sysmic - J. Pouiller Formation à Linux Embarqué 223 / 254

Debug Couverture Profiling Les sondes Jtag Debugguer U-Boot Maintenant que notre cible est correctement initialisées, nous pouvons prendre la main dessus avec gdb : host$ arm-linux-gdb u-boot gdb> target remote localhost:3333 gdb> c ^C gdb> hbreak run_command gdb> c u-boot> help Sysmic - J. Pouiller Formation à Linux Embarqué 224 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Cinquième partie V Linux et le temps réel Sysmic - J. Pouiller Formation à Linux Embarqué 225 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt 22 Systèmes Symétriques et Asymétriques 23 Problématique des OS RT 24 Bases 25 Latences 26 Low latency 27 Hyperviseurs 28 RT-préempt Sysmic - J. Pouiller Formation à Linux Embarqué 226 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Architectures multi-coeurs Il est possible d utiliser des architecture multi-coeurs pour des systèmes temps réels. On distingue alors 2 types d architectures : Les systèmes symétriques (SMP) où les tâches ne sont pas affectées à un CPU particulier Les systèmes asymétriques où on affecte manuellement les tâches à un CPU Sysmic - J. Pouiller Formation à Linux Embarqué 227 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Systèmes asymétriques Les systèmes asymétriques sont assez simples à architecturer : On effectue une étude séparées pour chaque CPU On considère les échanges entre les CPU comme des entrées/sorties Sous Linux, il est possible d associer une tâche avec un CPU grâce à : la fonction CPU affinity la commande taskset ou lxc aux fonctions cgroup et cpuset Sysmic - J. Pouiller Formation à Linux Embarqué 228 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Systèmes symétriques Beaucoup plus complexe à architecturer La plupart de nos algorithme ne sont plus prouvé dans une architecture SMP La technologie est relativement récente (fin des années 90) Pourquoi si tard? Principalement problèmes matériels Problèmes de barrières mémoires (hard ou soft) Algorithme beaucoup plus ardu (inversion de priorité par exemple) Sysmic - J. Pouiller Formation à Linux Embarqué 229 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Limites des système classiques Les systèmes classiques s appuient sur un système d exploitation en général mal adapté pour le temps réel : Politique d ordonnancement visant à équilibrer équitablement le temps alloué à chaque tâche La gestion de la mémoire virtuelle, des caches engendrent des fluctuations temporelles La gestion des temporisateurs qui servent à la manipulation des temps pas assez fin Mécanismes d accès aux ressources partagées et de synchronisation comportent des incertitudes temporelles Gestion des interruptions non-optimisées Systèmes non-certifiés API mal adaptées au systèmes temps réels Sysmic - J. Pouiller Formation à Linux Embarqué 230 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Mécanisme basiques Possibilité d exécuter une tache avec SCHED_RT ou SCHED_FIFO (priorité toujours inférieure aux sofirqs du noyau) Possibilité de marquer les pages de mémoire avec mlock L accès à des horloges haute précision est un élément clef d un système temps réel. Le framework hpet (High Precision Timers) est assez récent dans le noyau Linux (2001) (à titre de comparaison, l équivalent de hpet est apparu sous Windows à partir de Vista). Autrefois, l horloge était utilisée pour l ordonnanceur. Le temps retourné par les différents services était celui calculé par l ordonnanceur. Avec hpet, les horloges sont des périphériques à part entière Sysmic - J. Pouiller Formation à Linux Embarqué 231 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt LXC lxc permet de créer des container et d avoir une gestion fine des limitations de ressources. Activer Control Group Support dans le noyau Démonstration avec lxc-test.c $ gcc samples/lxc-test.c -o lxc-test $ apt-get install lxc Création d un container et éxecution de la commande $ lxc-create -n test $ lxc-execute -n test./lxc-test Sysmic - J. Pouiller Formation à Linux Embarqué 232 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt LXC Limiter le container à au CPU 0 : $ lxc-cgroup -n test cpuset.cpus 0 Supprimer la limite : $ lxc-cgroup -n test cpuset.cpus 0,1 Limiter la consommation cpu à 10% : $ lxc-cgroup -n test cpu.cfs_quota_us 10000 Retirer la limite : $ lxc-cgroup -n test cpu.cfs_quota_us -1 Connaitre la consommation CPU du container : $ lxc-cgroup -n test cpuacct.usage cf. /sys/fs/cgroup/ Sysmic - J. Pouiller Formation à Linux Embarqué 233 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Temps réel dans le noyau Travailler dans le noyau : Possibilité de travailler sous interruptions... ou de travailler avec les soft IRQ et/ou les tasklets Oblige à travailler dans le noyau (problèmes d APIs, etc...) Nécessaite beauoup de connaissance pour faire quelque chose de bien Accès difficiles aux bibliothèques de haut niveau (un simple accès au réseau peut devenir très complexe) Gardez le kernel pour faire des drivers, externalisez le traitement Sysmic - J. Pouiller Formation à Linux Embarqué 234 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Latence aux évènements Coeur du problème Si la latence était nul (ou au moins constante), on calculerait simplement le temps de réponses de nos tâches. Interruption Tache Latence Tache de priorité supérieure temps Sysmic - J. Pouiller Formation à Linux Embarqué 235 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Latence aux évènements Exemple concret On paramètre un timer à 50Hz On mesure le temps effectif de chaque période Sysmic - J. Pouiller Formation à Linux Embarqué 236 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Latence aux évènements Système temps réel Sysmic - J. Pouiller Formation à Linux Embarqué 237 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Latence aux évènements Système temps réels Sysmic - J. Pouiller Formation à Linux Embarqué 238 / 254

Systèmes Symétriques et Asymétriques Problématique des OS RT Bases Latences Low latency Hyperviseurs RT-préempt Latence aux évènements Système classique Sysmic - J. Pouiller Formation à Linux Embarqué 239 / 254