programmation rt comportements temps réel sous … · travaux pratiques 7 - 8 octobre 2002...

LABORATOIRE D’ANNECY-LE-VIEUX DE PHYSIQUE DES PARTICULESIN2P3/CNRS – UNIVERSITE DE SAVOIE

Chemin de Bellevue – BP 110 – F- 74941 Annecy-le-Vieux Cedex – Tél. : 04 50 09 16 00 – Fax : 04 50 27 94 95http://wwwlapp.in2p3.fr/

Ecole IN2P3d'Informatique TempsRéel

Travaux Pratiques

7 - 8 octobre 2002

Programmationconcurrente sous LinuxRT

Comportements tempsréel sous Linux etRTLinux

LAPP - Service Informatique

Ecole Temps Réel> • TP 2

Table des Matières

1. Introduction 4Résumé 4Bibliographie 4

2. Objectifs du TP 5

3. Vu d’ensemble des OS Linux et RTLinux 6

4. Présentation générale du TP 8Mini Carte électronique : Carte Pulse 8Configuration système du poste PC 10Aspects pratiques 11

5. Première partie du TP : Programmation concurrente sous RTLinux 11Mise en œuvre d'un système cadencé par événement (gestion d'une interruptionmatérielle) 11Présentation de l'application temps réel 13Structure des données 15Application de traitement statistique RtlMonitor 15Comment interagir avec le système ? 17Squelette d'une tâche 17Déroulement de la première partie du TP ( système cadencé par événement) 18Comparaison avec un système cadencé par le temps sous RT Linux 28

6. Deuxième partie du TP : Comportements temporels sous Linux et RTLinux 30Présentation de l’application 30Description d’un driver sous LINUX / RTLinux 31Environnement 31Etape0 : Installer un driver sous linux et RTLinux 33Etape1 : Mesure des performances en interruption 35Etape2 : Mesure de performances en mode polling 36Etape3 : Propagation d’une interruption avec un sémaphore 38

A1. Fonctions de base de RTLinux 44Afficher du texte dans RTLinux 44Contrôle de l’interface parallèle 44Créer/détruire une tache 44Changement des attributs par défaut d’une tache 44Activer une tache par intervalle 45Travailler avec une FIFO 45Travailler avec un sémaphore 45Travailler avec un MUTEX 45

A2. Interface parallèle 46Registres de l’interface parallèle 46Aspects software 48


1. Introduction

RésuméCe document propose un sujet de travaux pratiques élaboré pour l'Ecole d'informatique Temps réel de l'IN2P3.

TerminologieLe terme de Tâche sera utilisé au sens de Thread : processus léger permettant de structurer une application enactivités indépendantes qui s'exécutent de manière concurrente.

sTermes et Acronymes génériques: OS Operating System RTLinux Un OS temps réel qui coexiste avec le OS Linux PWM Pulse Width Modulator ISR Interrupt Service Routine MUTEX Mutual Exclusive Semaphore POSIX Portable Operating System Interface API Application Program Interface FIFO First In First Out

Bibliographie Michael Tischer : PC Programmation Système. La Bible PC, ISBN 2-7429-0144-2,

1994 Getting Started with RTLinux,

http://www.fsmlabs.com/developers/docs/pdf/GettingStarted.pdf Alessandro Rubini : LINUX device drivers. O’REILLY

2. Objectifs du TP

Le TP est organisé en deux parties distinctes. La première partie de ce TP propose de mettre enpratique sous RTLinux les différents concepts de la programmation concurrente :

la création de tâches, la communication et la synchronisation entre tâches notamment,

les mécanismes d'exclusion mutuelle ou MUTEX les sémaphores et les Fifo (facilité RTLinux)

la gestion d'interruption matérielle.

La seconde partie du TP propose d'expérimenter les limites des comportements temporels sousLinux et RTLinux et de comparer le déterminisme d'un OS généraliste et d'un OS temps réel.


3. Vu d’ensemble des OS Linux et RTLinux

En standard, le noyau Linux dispose de certaines fonctionnalités utiles pour le temps réel. Il supportenotamment la norme POSIX qui définit une interface standard pour la gestion des tâches concurrentes.Mais en aucun cas, le noyau standard n'est prédictif. Il faut pour cela avoir recours à une variantetemps réel de Linux capable de garantir l'exécution d'une tâche dans un délai donné.

Figure 3-1 Vue d'ensemble du noyau Linux

Le plugin RTlinux gère les interruptions matérielles à la place du noyau Linux et met en place ungestionnaire de tâches prédictif. Le noyau standard Linux est ainsi considéré comme une tâcheRTLinux ayant la plus basse priorité. Les API POSIX font partie des fonctions de base décrites enannexe. Elles sont disponibles sous Linux et sous RTLinux.ATTENTION :. En conséquence, si les tâches temps réel consomment tout le temps CPU, la tâcheLinux pourra donner l'impression que le système est arrêté.

Figure 3-2 Vue d'ensemble du noyau LINUX avec le plugin RTLinux

HARDWARE

Librairies Système

Drivers Noyau UNIX/Linux

Interruptions matériellesI/O

Processus Utilisateur

Plugin RTLinux


Librairies système

Noyau LinuxDrivers

I/O

I/O

Interruptions matérielles

Interruptions logiciellesAccèsdirect auhardware

Tâches temps réel

Linux s'exécute en tâche de fond

Scheduler RTLinux

HARDWARE


4. Présentation générale du TP

Mini Carte électronique : Carte PulseCette carte a été réalisée par messieurs M.Moynot et H.Bonnefon, électroniciens au LAPP.

Marche/ArrêtGamme

Fréquence

Figure 4-1 Carte Pulse

Cette carte permet de générer un signal périodique de rapport cyclique 0.5 sur l’entrée ACK du portparallèle(Voir A2 Interface parallèle). Le signal ACK peut être ensuite utilisé comme signald’interruption associé au vecteur 7, ou lu sur le bit 6 du registre d’état du port parallèle.La carte est munie :

• d’un commutateur et d’un témoin (LED) de mise sous-tension• d’un sélecteur de gamme 1Hz-1KHz , 1KHz-500KHz et d’un sélecteur à choix multiple de

fréquence.Le tableau ci-dessous donne les fréquences disponibles en fonction de la gamme et la position dusélecteur à choix multiple. Les périodes et fréquences indiquées sont données avec une précision20%.

Gamme

1Hz-1KHz 1KHz-500KHz

Sélecteurà choixmultiple

Période Fréquence Période Fréquence8 1s 1Hz 1ms 1KHz7 100ms 10Hz 100us 10KHz6 50ms 20Hz 50us 20KHz5 20ms 50Hz 25us 40KHz4 10ms 100Hz 12us 83KHz3 5ms 200Hz 7us 143KHz2 2ms 500Hz 3.5us 285KHz1 1ms 1KHz 2.2us 454KHz

Tableau 4-1 Fréquences disponibles sur la carte Pulse


Configuration système du poste PC• Linux RedHat 7.1 – linux v2.4.4-rtl3.1• Les commandes utiles pour gérer les modules sont :

• ${HOME}/bin/Rt.sh pour charger ou enlever les modules RTLinux• insmod <file.o> permet d’installer le module au fichier objet file.o• rmmod file enlève le module correspondant au fichier file.o• lsmod donne la liste de l’ensemble des modules installés et leur dépendance

Aspects pratiques• Bookmark permettant l’accès à la description de fonction RTLinux disponible• Répertoire TP1 pour la Première partie du TP : Programmation concurrente sous RTLinux• Répertoire TP2 pour la Deuxième partie du TP : Comportements temporels sous Linux et

RTLinux

5. Première partie du TP : Programmation concurrente sousRTLinux

Mise en œuvre d'un système cadencé par événement (gestion d'une interruptionmatérielle)Un ensemble de trois tâches sera utilisé pour montrer la mise en œuvre d’une application temps réelleexécutée sous le noyau RTLinux. Le tout sera cadencé par un signal électrique périodique qui produiraune interruption sur le port parallèle du PC. Le but de cette application est de calculer la période dece signal, voire sa fréquence. L’ensemble de ces fonctions utilisera uniquement des ressources deRTLinux (voir l’encadré rouge Figure 5-1).

Figure 5-1 Vue d'ensemble de l'application temps réel mise en œuvre dans la première partie du TP


Plugin RTLinux

Librairies système

Noyau LinuxDrivers

I/O

I/O

Interruptions matérielles

Interruptions logiciellesAccèsdirect auhardware


Scheduler RTLinux

HARDWARE

Tâche d’acquisitionTâche d’affichageTâche d’inhibition

ISR


Présentation de l'application temps réelL'application temps réel est constituée de 3 tâches concurrentes (voir Figure 5-2): une tâche d'acquisition une tâche d'inhibition ou de blocage une tâche d'affichage

Tâche d’acquisitionCadencée par le temps, cette tâche permet, en conjonction avec la fonction d’interruption, d’acquériret de déterminer la validité des données ; une périodicité d’une seconde semble raisonnable. Quand lesconditions de validité seront satisfaites, elle active un sémaphore vers la tâche d’affichage.

Tâche d’inhibition ou de blocageCadencée par le temps, cette tâche inhibe la tâche d’affichage à intervalles réguliers de temps ; unepériodicité d’une seconde semble raisonnable. Pour ce faire, elle se sert d'un MUTEX qui a uncomportement de type verrou : pendent une seconde le MUTEX est mis, la seconde d’après il estenlevé.

Tâche d’affichageSynchronisée par le sémaphore provenant de la tâche d’acquisition, cette tâche écrit les données dansune FIFO. Ces données seront ensuite lues par une application de traitement statistique et d'affichage.Pour éviter que la fonction d’interruption ne modifie les données pendant qu’elles sont transférées versla FIFO, l’opération d’écriture des données sera traitée comme section critique ; simplement, onmasque l’interruption avant l’écriture et on l’autorise après. Pour compliquer le comportement de latâche, elle sera ensuite synchronisée par le MUTEX envoyé par la tâche d’inhibition.

Fonction d'interruption (ISR)Le front négatif sur la ligne d’interruption (voir la description du hard) activera cette fonction qui valire la valeur de l’horloge haute résolution et prépare les données brutes nécessaires pour les calculsstatistiques.

intr_handler()Fonction d’inte rr uption

AcqTask()Tâche d’acquisition

DisplayTask()Tâc he d’affichage

InhibitTask()Tâche d’inhibition

/dev/rt f0FIFO

semAcqT oDi spl ay se ma phor e

mut exInh ibi tA cq mutex

RTLinux

Linux Application de traitement statistique (RtlMonitor)

w rite fifo

read fifo

Figure 5-2 Système cadencé par événement


Structure des donnéesLa structure des données acquises en temps réel par la tâche d’acquisition est la suivante (voir Rtl.h) :

typedef struct{ unsigned long long minPeriod; // mini. interval between 2 triggers unsigned long long maxPeriod; // maxi. interval between 2 triggers unsigned long long sum; // running sum of intervals unsigned long long sum2; // running squared sum of intervals unsigned int nbTriggers; // number of triggers unsigned int nbLostTriggers; // number of lost triggers} stat_type;

La tâche d’acquisition traite deux de ces structures : une pour les valeurs courantes (périodicité d’uneseconde) et une autre pour les valeurs cumulées sur toute la période d’installation du module.typedef struct{ stat_type crnt; // the values accumulated in TASK_PERIOD

stat_type total; // the values accumulated after the controlleris started

} data_type;

Application de traitement statistique RtlMonitorCe programme RtlMonitor s'exécute sous Linux standard et se charge du traitement des données luesdans la FIFO et de leur affichage. A partir des données brutes qui lui sont transmises, l'applicationRtlMonitor effectue des calculs statistiques dont les résultats seront affichés à l’écran.

Options d’exécutionLe programme RtlMonitor peut être exécute de plusieurs manières : RtlMonitor crt uniquement les résultats statistiques effectués sur la structure

crnt (voir la structure data_type plus haut)seront affichés

RtlMonitor tot uniquement les résultats statistiques effectués sur la structuretotal (voir la structure data_type plushaut) seront affichés

RtlMonitor les résultats statistiques effectués sur la structure crntsuivis des résultats statistiques effectués sur la structuretotal (voir la structure data_type plushaut) seront affichés

Format d’affichagemin: %11.6f, max: %11.6f, mean: %11.6f, SNR: %10.3f, Trig: %10d(%d) min valeur minimale de la période du signal exprimée en milliseconde

. max valeur maximale de la période du signal exprimée en milliseconde mean valeur moyenne de la période du signal exprimée en milliseconde SNR rapport signal sur bruit (i.e. rapport valeur moyenne / écart type) ;

cette valeur est sensée diminuer avec l’augmentation de lafréquence du signal

Trig le nombre d’événements détectés suivi du nombre d’événementsperdus ; cette dernière valeur est une estimation grossière de lacapacité de la tâche d’acquisition de suivre le train desévénements ; en réalité, il s’agit d’un compteur qui est incrémentéchaque fois que l’intervalle entre deux événements successifsdépasse le double de la période moyenne totale.


Comment interagir avec le système ?Ces indications seront utiles à partir de l’étape 4. Pour interagir avec le système, il est conseillé derespecter les étapes suivantes :

make compiler le code carte OFF s’assurer que la carte n’est pas alimentée installation installer le module dans une fenêtre de type Terminal RtlMonitor lancer le programme RtlMonitor dans une autre fenêtre de type

Terminal carte ON mettre la carte sous tension tests effectuer les tests carte OFF mettre la carte hors tension arrêt RtlMonitor arrêter RtlMonitor par CTRL_C désinstallation désinstaller le module

Squelette d'une tâche

Déroulement de la première partie du TP ( système cadencé par événement)Cette première partie du TP est composée de six étapes. Pour chaque étape, les solutions se trouventdans les sous répertoires correspondants solutionXirq(X= 0 .. 5). A la fin de chaque étape, on vousrecommande de copier la solution proposée avant de passer à l'étape suivante. Toutes les fonctions debase de RTLinux utilisées dans le TP sont décrites dans l’annexe 0.

Etape 0 : Se procurer et tester un modèleCette étape n’est rien qu’un simple test. Il s'agit d'installer un module vide, de suivre les messagesaffichés dans la fenêtre xconsole et de faire la connaissance du fichier central RtlIrq.c que, désormais,vous pouvez éditer. Les lignes de code que vous allez introduire sont marquées par des commentaireset toutes les variables globales sont déjà définies. Copier les fichiers modèle à partir de solution0irq. Suite à cette opération les fichiers

suivants seront copiés dans le répertoire de travail : fichier de compilation (Makefile etrtl.mk), fichiers en-tête (Rtl.h), fichiers source (RtlIrq.c, RtlTime.c et RtlMonitor.c),

Compiler (NB le résultat de compilation est un fichier de type .o ; dans le cas présentil n’y a pas d’édition de lien ; voir installation)

void* Task(void* param){

« code spécifique à l’initialisation de la tâche »

while(1){

wait() ; // appel générique ; attente de synchronisation

« code représentant le corps de la tâche »}return 0 ;

}

$> cp solutions0irq/* . ↵

$> make ↵


Pour tester le module : Installer les modules RTLinux

Installer le module (Ne pas oublier le suffixe .o)

Désinstaller le module

Désinstaller les modules RTLinux

Etape 1 : Créer la tâche d’inhibitionCette procédure sera répétée chaque fois qu’une tâche sera créée. Enregistrer la tâche dans init_module()

// register InhibitTask with its priority

schedParam.sched_priority = TASK_INHIBIT_PRIO;pthread_attr_setschedparam(&attr, &schedParam);if(pthread_create(&threads[TASK_INHIBIT], &attr, InhibitTask, (void *) TASK_INHIBIT))return -1;

Désinstaller la tâche dans cleanup_module()// unregister InhibitTask with its priority

pthread_cancel (threads[TASK_INHIBIT]);pthread_join (threads[TASK_INHIBIT], NULL);

Créer la tâche suivant le modèle présenté dans Squelette d'une tâche// Inhibition Task

void* InhibitTask(void* arg) // nom de la tâchepthread_make_periodic_np(pthread_self(), gethrtime()+TASK_SART_TIMEOUT,TASK_PERIOD); // dans l’initialisation de la tâchepthread_wait_np(); // pour wait()

// insérer le code qui gère le « toggle » et qui affiche des messages dans xterminalif(!(inhibit & 1)){ RtPrintMessage("InhibitTask pthread_mutex_lock\n");}else{ RtPrintMessage("InhibitTask pthread_mutex_unlock\n");}inhibit++

$> insmod RtlIrq.o ↵

$> rmmod RtlIrq ↵

$> Rt.sh start ↵

$> Rt.sh stop ↵


Pour tester le module : Installer / désinstaller le module RtlIrq.

Etape 2 : Créer la tâche d’affichage et mettre en place le mécanisme de MUTEX(voir 0)Pour créer la tâche la procédure est identique à celle décrite dans l’étape précédente. Enregistrer la tâche dans init_module() (copier la section correspondant à la tâche

précédente):// register DisplayTask with its priority

remplacer TASK_INHIBIT_PRIO par TASK_DISPLAY_PRIOremplacer TASK_INHIBIT par TASK_DISPLAYremplacer InhibitTask par DisplayTask dans la function pthread_create

Désinstaller la tâche dans cleanup_module () (copier la section correspondant à latâche précédente):// unregister DisplayTask with its priority

remplacer TASK_INHIBIT par TASK_DISPLAY

Créer la tâche suivant le modèle présenté// Display Task

void* DisplayTask (void* arg) // nom de la tâchepthread_make_periodic_np(pthread_self(), gethrtime()+TASK_SART_TIMEOUT,TASK_PERIOD); // dans l’initialisation de la tâchepthread_wait_np(); // pour wait()

Pour installer le MUTEX : Enregistrer le MUTEX dans init_module() :

// create a mutex

if(pthread_mutex_init(&mutexInhibitAcq, NULL))return -1;

Désinstaller le MUTEX dans cleanup_module() :// free the mutex.

pthread_mutex_destroy(&mutexInhibitAcq);

Activer / désactiver le MUTEX dans la tâche d’inhibitionif(!(inhibit & 1)){ RtPrintMessage("InhibitTask pthread_mutex_lock\n");

pthread_mutex_lock(&mutexInhibitAcq) ;}else{ RtPrintMessage("InhibitTask pthread_mutex_unlock\n");

pthread_mutex_unlock(&mutexInhibitAcq) ;}inhibit++


Activer / désactiver le MUTEX dans la tâche d’affichagepthread_mutex_lock(&mutexInhibitAcq) ;pthread_mutex_unlock(&mutexInhibitAcq) ;


Etape 3 : Créer la tâche d’acquisition et installer le sémaphore (voir 0)Pour créer la tâche la procédure est identique à celle décrite dans l’étape précédente. Enregistrer la tâche dans init_module() (copier la section correspondant à la tâche

précédente):// register AcqTask with its priority

remplacer TASK_INHIBIT_PRIO par TASK_ ACQ _PRIOremplacer TASK_INHIBIT par TASK_ ACQremplacer InhibitTask par AcqTask dans la function pthread_create

Désinstaller la tâche dans cleanup_module () (copier la section correspondant à latâche précédente):// unregister AcqTask with its priority

remplacer TASK_INHIBIT par TASK_ACQ

Créer la tâche suivant le modèle présenté// Acquisition Task

void* AcqTask (void* arg) // nom de la tâchepthread_make_periodic_np(pthread_self(), gethrtime()+TASK_SART_TIMEOUT,TASK_PERIOD); // dans l’initialisation de la tâchepthread_wait_np(); // pour wait()

Créer dans le corps de la tâche :if(++data.crnt.nbTriggers >= NB_TRIGGER_MIN){ RtPrintMessage("AcqTask sem_post\n");

sem_post(&semAcqToDisplay);}

Pour installer le sémaphore : Enregistrer le sémaphore dans init_module() :

// create a semaphore

if(sem_init(&semAcqToDisplay, 1, 0))return -1;

Désinstaller le sémaphore dans cleanup_module() :// free the semaphore

sem_destroy(&semAcqToDisplay);

Changer le mode de synchronisation de la tâche d’affichage : elle ne sera plus cadencée par le temps,elle sera synchronisée par un sémaphore:


Enlever la création de la période de tempspthread_make_periodic_np(pthread_self(), gethrtime()+TASK_SART_TIMEOUT,TASK_PERIOD);

Remplacer :pthread_wait_np();PARsem_wait(&semAcqToDisplay);


Etape 4 : Installer la FIFO (voir 0) Enregistrer la FIFO dans init_module() :

// create a FIFOrtf_destroy(FIFO_ACQ_DISPLAY);rtf_create(FIFO_ACQ_DISPLAY, FIFO_SIZE);

Désinstaller la FIFO dans cleanup_module() :// free the FIFOclose(fifoDisplay);rtf_destroy(FIFO_ACQ_DISPLAY);

Ouvrir la FIFO dans la section d’initialisation de la tâche d’affichage :fifoDisplay = open("/dev/rtf0", O_NONBLOCK);if (fifoDisplay < 0)

return (void *) -1;

Utiliser la FIFO dans le corps de la tâche d’affichage :write(fifoDisplay, &data, sizeof(data_type));

Pour tester le module : Installer / désinstaller le module RtlIrq. Exécuter . /RtlMonitor. Que des valeurs nulles seront affichées mais tout le système

est en marche. Il manque que le ISR.

Etape 5 : Installer la fonction d'interruption (ISR) et autoriser les interruptions Installer l'ISR dans init_module() :

// install the interrupt handler request_RTirq(LPT_IRQ, intr_handler);

Demander au LPT de travailler par interruption dans init_module() :// enable the LPT interrupt outb_p(LPT_IRQ_ENABLE, LPT_CTRL);

Désinstaller la ISR dans cleanup_module() :// free the interrupt handler

free_RTirq(LPT_IRQ);

Demander au LPT de travailler sans interruption dans cleanup_module() :// disable the LPT interruptoutb_p(LPT_IRQ_DISABLE, LPT_CTRL);


Créer la fonction d’interruption :// Interrupt Service Routine ISRvoid intr_handler(void){

if(oldTime == 0) // resynchronize{ oldTime++;

data.total.nbTriggers = 0 ;}else

data.crnt.nbTriggers++;

}

Etalonnage de la carte d’acquisitionFaire un premier test du module pour vérifier la capture de l’interruption générée par la carte etl’étalonner. Installer / désinstaller le module RtlIrq. Exécuter . /RtlMonitor. Jouer avec la carte et noter les valeurs. Observer le nombre d’événements affichés. Cette valeur représente le nombre de

Triggers détectés par seconde, en l’occurrence la fréquence du signal d’entrée. Procéder à un étalonnage de la carte en notant les valeurs lues pour chaque position

du micro-interrupteur en commençant par les fréquences basses (voir Tableau 4-1). Interpréter les valeurs et observer les limites du système.

Mesures de la période du signalCopier la solutionIrq dans le répertoire courant. La fonction d’interruption qui vous est proposée,inclut le code nécessaire pour les mesures et le traitement statistique de la période du signal d’entrée.Reportez-vous au code. Installer / désinstaller le module RtlIrq. Exécuter . /RtlMonitor qui affiche toutes les informations décrites page 15.

Comparaison avec un système cadencé par le temps sous RT LinuxLa solution proposée se trouve dans le répertoire solutionTime. Elle consiste essentiellement à enleverla ISR et à remplacer l’intervalle d’activation de la tâche AcqTask() par une valeur beaucoup pluspetite (ex. TASK_SAMPLING_FREQ = 20 µs). Pour tester cette modalité, nous vous proposons decopier la solution.NB On peut descendre la valeur de TASK_SAMPLING_FREQ plus bas mais le système sera occupéprincipalement par cette tâche et les effets sont imprévisibles.

Mesures de la période du signalCopier la solutionTime dans le répertoire courant. La fonction d’interruption qui vous est proposée,inclut le code nécessaire pour les mesures et le traitement statistique de la période du signal d’entrée.Reportez-vous au code. Installer / désinstaller le module RtlTime. Exécuter . /RtlMonitor qui affiche toutes les informations décrites page 15.


6. Deuxième partie du TP : Comportements temporelssous Linux et RTLinux

Présentation de l’applicationLe but de cette partie est de caractériser un système non-préemptif LINUX d’un système préemptifRTLinux en fonctionnement en interruption, en polling et via un sémaphore. Pour cela nousmesurerons le temps entre deux fronts descendants du signal ACK du port en mettant en œuvre (cffigure 6-1) :• un driver sous linux ParMod et un driver sous Rtlinux RtParMod pour accéder aux ressources

matérielles• une tâche d’affichage MonitorIo accédant aux drivers, récupérant les mesures (minimum,

maximun, moyenne, écart type) et un histogramme qui permet de quantifier le nombred’événements perdus à partir de la moyenne. Nous considèrerons qu’un événement est perdu si sapériode est supérieur à 2 fois la moyenne.

Figure 6-1 Vue d'ensemble de l'application mise en œuvre dans la seconde partie du TP

Description d’un driver sous LINUX / RTLinuxUn driver est défini par : un point d’accès, un nombre majeur et un nombre mineur. Nous utiliserons le point d’accès

/dev/ParMod avec comme nombre majeur 127 et nombre mineur 0. La commande mkmod/dev/ParMod c 127 0 permet de créer notre point d’accès.

une fonction d’installation init_module et une fonction de dé-installation cleanup_module une structure file_operations qui contient l’ensemble de ses points d’entrée. Dans notre cas nous

ne définirons que les points d’entrée suivant : lecture ParRead, écriture ParWrite, entrée-sortie decontrôle ParIoctl, ouverture ParOpen, et fermeture ParClose.

l’ensemble de fonctions accessibles installées au niveau noyau. Dans le cas du module ParMod,nous aurons accès uniquement aux fonctions du noyau Linux. Dans le cas du module RtParMod,nous aurons accès aux fonctions Linux standard plus les fonctions des modules RTLinux(rtl,rtl_sched, rtl_time).


Librairies système

Noyau Linux

I/O

I/OAccèsdirect auhardware


Scheduler RTLinux

HARDWARE

RTLinux ThreadParTh

ISR

ISR

Plugin RTLinux

ParModProcessus


EnvironnementLes drivers ParMod et RtParMod ont le même squelette, il contient :

• La routine d’interruption ParIsrFnt• la fonction de lecture ParRead qui lit la structure contenant les statistiques RtStat_t• la fonction d’écriture ParWrite vide• la fonction de contrôle ParIoctl contenant la commande ParIoHsto pour lire l’histogramme• la fonction ParOpen qui initialise la structure ParDrvr_t• la fonction ParRelease qui désinstalle l’interruption et tue le thread s’il existe (RTLinux

uniquement)• les fonctions d’initialisation init_module et de destruction cleanup_module du module

L’application est composé des fichiers suivants:• Rt.h contenant l’ensemble des définitions nécessaires dont la structure définissant les statistiques

RtStat_t• lTime.c : fournit la fonction TimeStatTreat qui mesure du temps entre 2 appels et remplit un

histogramme• MonitorIo.c contient la fonction d’affichage et est exécuté sous LINUX . Il génère le fichier

hsto.dat contenant l’histogramme des mesures. Le premier argument permettra de sélectionner lemode de fonctionnement

• ParDrvr.c contient le squelette du driver LINUX et exécute des fonctions LINUX RtParDrvr.ccontient le squelette du driver RTLINUX et exécute des fonctions RTLinux et LINUX

• Makefile qui permet de compiler les drivers et le moniteur

Note : le plugin RTLinux n’est activé que lorsque les modules associés sont chargés via la commandeRt.sh start autrement seul le noyau Linux existe.

Cette deuxième partie du TP est composée de 4 étapes. Pour chaque étape Etapex, les solutions setrouvent dans les sous répertoires correspondants Cx+1. A la fin de chaque étape, on vousrecommande de copier la solution proposée avant de passer à l'étape suivante.

Etape0 : Installer un driver sous linux et RTLinuxCette étape permet de prendre connaissance avec les différents fichiers C,H et de comprendre lesdifférents éléments et leurs relations.On ajoute quelques commandes dans la fonction de contrôle (ioctl) des drivers et on met en place lesthreads dans RTLinux et au niveau utilisateur sur Linux

• Copier les fichiers contenus dans C0• Installer les commandes ParIoIsrInstall, ParIoPollWait de la fonction ParIoctl du fichier

ParDrvr.c

case ParIoIsrInstall: printk(KERN_INFO "ParIoctl> ParIoIsrInstall call\n" );return(RT_OK);

case ParIoPollWait: return(RT_OK);

• Installer les commandes ParIoIsrInstall, ParIoPollWait, ParIoKthPollInstall de la fonctionParIoctl et créer le thread RTLinux de polling ParThPoll dans le fichier RtParDrvr.c

case ParIoIsrInstall: printk(KERN_INFO "RtParIoctl> ParIsrInstall call\n" ); return(RT_OK);


case ParIoPollWait: return(RT_OK);

case ParIoKThPollInstall: printk(KERN_INFO "RtParIoctl> ParIoKThPollInstall call\n" ); copy_from_user( &rtStat->maxCount, (int*)arg, sizeof(int) ); pthread_create( &ParDrvr->pTh, NULL, (void *(*)(void *))PartPoll, ParDrvr ); // Create theRTLinux Polling thread return(RT_OK);

• Appeler les commandes ParIoIsrInstall, ParIoPollWait, ParIoKthPollInstall et installer le threadLinux de pollling MoniThPoll dans MonitorIo.c

if( !strcmp(argv[1], "ISR") ) { ioctl( Rt->fd, ParIoIsrInstall, &Rt->rtStat.maxCount ); } else if( !strcmp(argv[1], "POLL") ){ pthread_create( &Rt->pTh, NULL, (void *(*)(void*)) MoniThPoll, Rt ); // Create the Linux Pollingthread } else if( !strcmp(argv[1], "KTHPOLL") ){ ioctl( Rt->fd, ParIoKThPollInstall, &Rt->rtStat.maxCount ); } else exit(EXIT_FAILURE);

• Compiler make puis tester :• Activer une xconsole• Installer le module sous Linux : insmod ParMod.o • Exécuter ./MonitorIo (ISR|POLL) et vérifier que les messages arrivent bien lors des actions

dans les bonnes fenêtres xconsole ou xterm.• Déinstaller le module sous Linux rmmod ParMod• Installer le module sous RTLinux : Rt.sh start ; insmod RtParMod.o • Exécuter ./MonitorIo (ISR|POLL) et vérifier que les messages arrivent bien lors des actions

dans les bonnes fenêtres xconsole ou xterm.• Déinstaller le module sous RTLinux rmmod RtParMod ; Rt.sh stop

Etape1 : Mesure des performances en interruptionInstaller la fonction d’interruption ParIsrFnt comme fonction d’interruption associée au vecteurRtParInt_Irq relatif au port parallèle.

• Copier les fichiers contenus dans C1• Compléter la commande ParIoIsrInstall de la fonction ParIoctl dans le fichier ParDrvr.c

case ParIoIsrInstall: printk(KERN_INFO "ParIoctl> ParIoIsrInstall call\n" ); request_irq( RtParInt_Irq, ParIsrFnt, SA_INTERRUPT, "Par", NULL ); // Install the ISR ParDrvr->irqState = 1; copy_from_user( &rtStat->maxCount, (int*)arg, sizeof(int) ); outb(RtParCtr_IrqEnable, RtParInt_Ctrl); // Enable the IRQ on the Parallel Port return(RT_OK);

• Compléter la commande ParIoIsrInstall de la fonction ParIoctl dans le fichier RtParDrvr.c

case ParIoIsrInstall: printk(KERN_INFO "RtParIoctl> ParIoIsrInstall call\n" ); rtl_request_irq( RtParInt_Irq, ParIsrFnt); // Install the ISR ParDrvr->irqState = 1;


copy_from_user( &rtStat->maxCount, (int*)arg, sizeof(int) ); outb(RtParCtr_IrqEnable, RtParInt_Ctrl); // Enable the IRQ on the Parallel Port return(RT_OK);

• Compiler make puis tester à différentes fréquences et comparer les deux systèmes• Linux : insmod ParMod.o ; ./MonitorIo ISR; rmmod ParMod• RtLinux : Rt.sh start ; insmod RtParMod.o ; ./MonitorIo ISR ; rmmod RtParMod ; Rt.sh

stop;

Etape2 : Mesure de performances en mode pollingL’attente de changement d’état est effectuée au niveau noyau soit dans un thread travaillant au niveaukernel(RTLinux uniquement) soit dans un thread au niveau utilisateur(Linux) avec les modulesParMod et RtParMod.

• Copier les fichiers contenus dans C2• Compléter la commande ParIoPolWait de la fonction ParIoctl dans le fichier ParDrvr.c

case ParIoPollWait: copy_from_user( &rtn, (int*)arg, sizeof(int) ); // Get the waiting state for( ; (inb(RtParInt_Sts) & RtParSts_Ack) == rtn; ) schedule(); // Wait on the state return(RT_OK);

• Compléter la commande ParIoPolWait de la fonction ParIoctl dans le fichier RtParDrvr.c

case ParIoPollWait: copy_from_user( &rtn, (int*)arg, sizeof(int) ); // Get the waiting state for( ; (inb(RtParInt_Sts) & RtParSts_Ack) == rtn; ) schedule();// Wait on the state return(RT_OK);

• Compléter le thread RTLinux de polling ParThPoll en mettant en œuvre le polling dans le fichierRtParDrvr.c

for( ; !(inb(RtParInt_Sts) & RtParSts_Ack); rtl_schedule()); /*--------------------------------------------------------------------------*/ for( run = RT_OK; run == RT_OK; ) { /*-------------------------------------------------- Wait for Ack is zero */ for( ; inb(RtParInt_Sts) & RtParSts_Ack; rtl_schedule() ); /*------------------------------------------- Ack is 0 for the first time */ run = TimeStatTreat( rtStat, pDrvr->hsto, RT_HSTO ); /*-------------------------------------------- Wait for Ack return to one */ if( rtStat->count == 1 ) tmo.tv_nsec = rtStat->min*256; if( tmo.tv_nsec ) nanosleep(&tmo, NULL); for( ; !(inb(RtParInt_Sts) & RtParSts_Ack); rtl_schedule()); }

• Compléter le thread Linux de polling MoniThPoll en mettant en œuvre le polling dans le fichierMonitorIo.c

val = 0; ioctl( rt->fd, ParIoPollWait, &val ); /*--------------------------------------------------------------------------*/ for( run = RT_OK; run == RT_OK; ){ /*-------------------------------------------------- Wait for Ack is zero */


val = RtParSts_Ack; ioctl( rt->fd, ParIoPollWait, &val ); /*------------------------------------------- Ack is 0 for the first time */ run = TimeStatTreat( rtStat, rt->hsto, RT_HSTO ); /*-------------------------------------------- Wait for Ack return to one */ val = 0; ioctl( rt->fd, ParIoPollWait, &val ); }

• Compiler make puis tester à différentes fréquences et comparer les deux systèmes• Linux : insmod ParMod.o ; ./MonitorIo POLL; rmmod ParMod• RtLinux : Rt.sh start ; insmod RtParMod.o ; ./MonitorIo POLL; ./MonitorIo KTHPOLL;

rmmod RtParMod ; Rt.sh stop

Etape3 : Propagation d’une interruption avec un sémaphoreDans cette étape nous mettrons en œuvre la propagation d’une interruption via un sémaphore vers unthread travaillant au niveau kernel(RTLinux uniquement) et vers un thread au niveau utilisateur(Linux)avec les modules ParMod et RtParMod.

Sous Linux au niveau noyau, nous utilisons :• une structure struct semaphore initialisée par sema_init,• la fonction up permet d’incrémenter le sémaphore ou de réveiller une tâche• la fonction down_interruptible permet de mettre une tâche en attente ou de décrémenter le

sémaphoreSous RTLinux, nous utiliserons un sémaphore défini par la norme POSIX

• Copier les fichiers contenus dans C3• Ajouter et compléter les commandes ParIoEventInstall, ParIoEventWait de la fonction ParIoctl et

installer la fonction d’interruption ParEventFnt cadençant le sémaphore dans le fichier ParDrvr.c

/* Interrupt subroutine ----------------------------------------- ParEventFnt */static void ParEventFnt( int irq, void *dev_id, struct pt_regs *regs ) {

/*--------------------------------------------------------------------------*/ up( &ParDrvr->sem ); /*--------------------------------------------------------------------------*/ return;}

/* Driver function ------------------------------------------------- ParIoctl */

case ParIoEventInstall: printk(KERN_INFO "ParIoctl> ParIoEventInstall call\n" ); sema_init( &ParDrvr->sem, 0 ); request_irq( RtParInt_Irq, ParEventFnt, SA_INTERRUPT, "Par", NULL ); ParDrvr->irqState = 1; outb(RtParCtr_IrqEnable, RtParInt_Ctrl); return(RT_OK);

/*--------------------------------------------------------------------------*/ case ParIoEventWait: down_interruptible( &ParDrvr->sem ); return(RT_OK);


• Ajouter et compléter les commandes ParIoEventInstall, ParIoEventWait, ParIoKThEventInstallde la fonction ParIoctl et installer la fonction d’interruption ParEventFnt cadençant le sémaphoredans le fichier RtParDrvr.c

/* Interrupt subroutine ----------------------------------------- ParEventFnt */static unsigned int ParEventFnt( unsigned int irq, struct pt_regs *regs ) {

/*--------------------------------------------------------------------------*/ sem_post( &ParDrvr->sem ); rtl_hard_enable_irq( RtParInt_Irq ); /*--------------------------------------------------------------------------*/ return(RT_OK);}

/* Driver function ------------------------------------------------- ParIoctl */

case ParIoEventInstall: printk(KERN_INFO "RtParIoctl> ParIoEventInstall call\n" ); sem_init( &ParDrvr->sem, 1, 0 ); rtl_request_irq( RtParInt_Irq, ParEventFnt ); ParDrvr->irqState = 1; outb(RtParCtr_IrqEnable, RtParInt_Ctrl); return(RT_OK);

/*--------------------------------------------------------------------------*/ case ParIoEventWait: sem_wait( &ParDrvr->sem ); return(RT_OK);

• Créer le thread RTLinux ParThEvent cadencé par le sémaphore dans le fichier RtParDrvr.c

/* RealTime Linux Kernel Thread ---------------------------------- ParThEvent */

static void *ParThEvent( ParDrvr_t *pDrvr ) { RtStat_t *rtStat = &pDrvr->rtStat; int run; struct sched_param p;

p.sched_priority = sched_get_priority_min(SCHED_FIFO)+1; pthread_setschedparam( pDrvr->pTh, SCHED_FIFO, &p ); printk(KERN_INFO "RtParThEvent> Kernel Thread started\n"); /*--------------------------------------------------------------------------*/ for( run = RT_OK; run == RT_OK; ) { /*---------------------------------------------------------- Wait for Irq */ sem_wait( &pDrvr->sem ); /*------------------------------------------- Ack is 0 for the first time */ run = TimeStatTreat( rtStat, pDrvr->hsto, RT_HSTO ); } /*--------------------------------------------------------------------------*/ pthread_exit(NULL); return(NULL);}

/*--------------------------------------------------------------------------*/ case ParIoKThEventInstall: printk(KERN_INFO "RtParIoctl> ParIoKThEventInstall call\n" ); sem_init( &ParDrvr->sem, 1, 0 );


rtl_request_irq( RtParInt_Irq, ParEventFnt ); ParDrvr->irqState = 1; copy_from_user( &rtStat->maxCount, (int*)arg, sizeof(int) ); pthread_create( &ParDrvr->pTh, NULL, (void *(*)(void *))ParThEvent,

ParDrvr ); outb(RtParCtr_IrqEnable, RtParInt_Ctrl); return(RT_OK);

• Appeler les commandes ParIoEventInstall, ParIoEventWait et ParIoKThEventInstall de lafonction ParIoctl et créer le Thread Linux MoniThEvent cadencé par le sémaphore dans le fichierMonitorIo.c

/* Linux Thread ------------------------------------------------- MoniThEvent */static void MoniThEvent( RtRoot_t *rt ) { int run; RtStat_t *rtStat = &rt->rtStat;

setpriority(PRIO_PROCESS, 0, 120); printf("MoniEvent User's Thread: pid %d - prio %d\n", getpid(), getpriority(PRIO_PROCESS, 0) );

ioctl( rt->fd, ParIoEventInstall, NULL ); /*--------------------------------------------------------------------------*/ for( run = RT_OK; run == RT_OK; ) { /*-------------------------------------------------------- Wait for Event */ ioctl( rt->fd, ParIoEventWait, NULL ); run = TimeStatTreat( rtStat, rt->hsto, RT_HSTO ); } /*--------------------------------------------------------------------------*/ return;}

/*---------------------------------------------------------- Select Options */ if( !strcmp(argv[1], "ISR") ) { ioctl( Rt->fd, ParIoIsrInstall, &Rt->rtStat.maxCount ); } else if( !strcmp(argv[1], "POLL") ){ pthread_create( &Rt->pTh, NULL, (void *(*)(void *)) MoniThPoll, Rt ); } else if( !strcmp(argv[1], "KTHPOLL") ){ ioctl( Rt->fd, ParIoKThPollInstall, &Rt->rtStat.maxCount ); } else if( !strcmp(argv[1], "EVENT") ){ pthread_create( &Rt->pTh, NULL, (void *(*)(void *)) MoniThEvent, Rt ); } else if( !strcmp(argv[1], "KTHEVENT") ){ ioctl( Rt->fd, ParIoKThEventInstall, &Rt->rtStat.maxCount );} else { printf("Mode inconnu !!\n"); exit(EXIT_FAILURE);}

• Compiler make puis tester à différentes fréquences et comparer les deux systèmes• Linux : insmod ParMod.o ; ./MonitorIo Compiler make puis tester à différentes fréquences et

comparer les deux systèmes• Linux : insmod ParMod.o ; ./MonitorIo EVENT; rmmod ParMod• RtLinux : Rt.sh start ; insmod RtParMod.o ; ./MonitorIo KTHEVENT; ./MonitorIo

EVENT; rmmod RtParMod ; Rt.sh stop


A1. Fonctions de base de RTLinux

Cette annexe a uniquement le rôle de vous pointer vers les fonctions RTLinux les plus utiles pourréaliser ce TP. Pour la description de ces fonctions et leur liste de paramètres consulter le document“Getting Started with RTLinux”.

Afficher du texte dans RTLinuxLes fonctions rtl_printf et RtPrintMessage permettent d’afficher du texte en respectant le format de lafonction standard C printf.

Ex : rtl_printf ("START: val = %d\n", val);NB Le point flottant n’est pas supporté par RTLinux

Contrôle de l’interface parallèlePour ces fonctions consultez l’annexe A2.

Créer/détruire une tachePour créer une tache, utiliser la fonction pthread_create, pour la détruire, utiliser la fonctionpthread_cancel suivi de la fonction pthread_join. Pour la liste des paramètres regardez dans ledocument “Getting Started with RTLinux”.

Changement des attributs par défaut d’une tachePour changer les attributs par défaut d’une tâche, utiliser la fonction pthread_attr_init pour uneinitialisation générale des paramètres et la fonction pthread_attr_setschedparam pour fixer lesattributs spécifiques de ta tache cible.

Activer une tache par intervalleUne tache peut être activée à des intervalles re temps réguliers. Les fonctions utiles pour aboutir sontpthread_self et pthread_make_periodic_np.

Travailler avec une FIFOPlusieurs actions sont nécessaires pour travailler avec une FIFO.- Création/destruction d’une FIFO rtf_create et rtf_destroy.- Ouverture/fermeture d’une FIFO en utilisant les fonctions standard C open et close.- Lecture/écriture d’une FIFO en utilisant les fonctions standard C read et write.

Travailler avec un sémaphorePlusieurs actions sont nécessaires pour travailler avec un sémaphore.- Création/destruction d’une FIFO sem_init et sem_destroy.- Poster ou activer un sémaphore sem_post.- Attendre pour un sémaphore sem_wait.

Travailler avec un MUTEXPlusieurs actions sont nécessaires pour travailler avec un sémaphore.- Création/destruction d’un MUTEX pthread_mutex_init et pthread_mutex_destroy.- Bloquer indéfiniment un MUTEX pthread_mutex_lock.- Débloquer un MUTEX pthread_mutex_unlock


A2. Interface parallèle

Registres de l’interface parallèleCe paragraphe se concentre uniquement sur les éléments de l’interface parallèle qui seront utilisésdans ce TP. Le signal d’entrée (signal carré ; PWM = 0.5 ) est connecté à la pine 11 (ACK) duconnecteur Centronics. En tout moment, en lisant le registre d’état, le programmeur peut savoir l’étatdu signal d’interruption. Quand l’interruption est autorisée, une interruption hardware du niveau 7 estproduite.

Port Centronics Pine 11 Réception du dernier caractère ACK

Adresses de l’imprimante Adresse de base 0x378 Adresse data Adresse de base 0x378 Adresse d’état Adresse de base + 1 0x379 Adresse de contrôle Adresse de base + 2 0x37a

Registre « data »Paramètres : (8 bits à l’adresse 0x378) Bit 0-7 les données en sortie – ne sera pas utilisé

Registre d’étatParamètres : (en lecture uniquement ; 8 bits ; adresse 0x379) Bit 0 1 = Erreur « time out » Bit 3 1 = Erreur de transmission ERROR Bit 4 1 = Imprimante ON LINE SLCT Bit 5 1 = Plus de papier PE Bit 6 1 = Accusée de réception ACK Bit 7 0 = Imprimante occupée BUSY

Registre de contrôleParamètres : (lecture/écriture; 8 bits ; adresse 0x37a) Bit 4 1 = Autoriser l’interruption IRQ

0 = pas d’interruption /IRQ

InterruptionParamètres : (type hardware ; niveau 7) IRQ écrire 0x10 0x37a /IRQ écrire 0x00 0x37a

Aspects software

Installer/désinstaller un ISR associé à l’interruption 7 request_RTirq (7, ISR); free_RTirq (7);

Autoriser ou non l’interruption hardware 7 rtl_hard_enable_irq(7); rtl_hard_disable_irq(7);

Accéder à un port de l’imprimante unsigned char val = inb_p(adresse)

Ex : lire l’état de l’imprimante unsigned char status = inb_p(0x379)


outb_p(val, adresse)Ex : autoriser i’interruption outb_p(7, 0x37a)

programmation rt comportements temps réel sous … · travaux pratiques 7 - 8 octobre 2002...

Documents