Sytèmes 1 Processus et la communication entre les processus par les tubes, redirections

Sytèmes 1 Processus et la communication entre les processus par les tubes, redirections 16 décembre 2014 Table des matières 1 Le concept de processus 2 2 Propriétés d un processus 2 2.1 L identité..................................... 2 2.2 Propriétaire.................................... 3 2.3 Répertoire de travail............................... 4 2.4 Session et groupe de processus......................... 4 2.4.1 Terminal de contrôle........................... 5 2.5 Date de création................................. 5 2.6 Temps CPU.................................... 5 2.6.1 Le masque de création de fichiers.................... 6 2.7 Table de descripteurs............................... 6 3 Espace d adressage de processus 6 4 Création de processus 7 5 Primitives de recouvrement (exec) 8 5.1 Propriétés d un processus après le recouvrement................ 10 6 Terminaison de processus (exit et exit) 10 7 Processus zombie et synchronisation père fils 11 7.1 wait........................................ 11 7.2 waitpid...................................... 12 8 Communication entre des processus par les tubes 13 8.1 Tubes nommés.................................. 14 8.1.1 Création de tube nommé........................ 14 8.1.2 Ouverture de tube nommé........................ 14 8.2 Lecture et écriture dans un tube nommé ou anonyme............. 15 8.2.1 Lecture à partir un tube......................... 15 8.2.2 Écriture dans un tube.......................... 16 8.3 Tubes anonymes................................. 16 8.3.1 Création d un tube anonyme...................... 16 8.3.2 Lecture/écriture dans le tube anonyme................. 16 1

8.3.3 Exemple - communication père fils par un tube anonyme..... 17 8.4 Changement de propriété bloquant non bloquant............. 18 9 Duplication de descripteur avec dup() et dup2() 18 9.1 Exemple - redirections.............................. 18 10 select et pool 21 10.1 select........................................ 22 10.2 poll......................................... 22 1 Le concept de processus L espace d adressage d un processus: les instructions, les données(dont la pile d exécution et le tas). Cet espace est dynamique et change avec le temps. L exécution de deux modes différents : mode utilisateur (user mode) le processus exécute ses propres instructions et accède aux données de son espace d adressage. La tentative d accéder à des données hors de son espace d adressage provoque une exception, Dans le mode système, mode noyau (supervisor, system, kernel mode) le processus exécute des instruction n appartenant pas au programme mais au noyau, cela permet d accéder à l ensemble de données de système (tables de système). Changement de mode via l appel de système par une trappe (trap) ou par un évènement (interruption). Dans le dernier cas le processus exécute le gérant de l interruption (handler) correspondant et soit reprend au retour de handler soit termine si aucun handler n est installé. L ordonnancement(schedulling) de processus. L utilisation de priorités. Les caractéristiques de processus dans le bloc de contrôle (BCP). BCP composé de deux parties : 1. une partie conservée dans le noyau. Contient les information utiles pour le noyau même si le processus inactif : identité, les informations disponibles uniquement en mode noyau, 2. les informations dans l espace d adressage de processus : les descripteurs de fichiers, les handlers de signaux. 2 Propriétés d un processus Chaque processus possède un certain nombre de propriétés. Cette section donne la liste de fonctions qui permettent d obtenir les valeurs de différents propriétés. 2.1 L identité L identité de processus, pid, est un entier positif unique qui permet d identifier le processus. #include <sys/types.h> pid_t getpid(void); //l identite du processus pid_t getppid(void); //l identite du processus pere 2

pid_t c est un type entier signé. getpid() donne le pid de processus, le pid ne change pas depuis la création jusqu à la mort du processus. getppid() donne l identité du processus père. Cette identité peut changer si le processus père termine. 2.2 Propriétaire Chaque processus possède un propriétaire (identifié par une valeur de type uid_t, uid_t une valeur entière) et un groupe propriétaires (du type gid_t, aussi un type entier). En fait il y a même trois propriétaires et trois groupes propriétaires, le propriétaire réel, le propriétaire effectif et le propriétaire sauvegardé (le proptriétaire sauvegardé seulement dans les systèmes modernes, les anciens systèmes UNIX ne connaissaient pas de propriétaire sauvegardé). Pour determiner si un processus P peut accéder à un fichier F le système utilise l algorithme suivant : si le proprietaire effectif de P == proprietaire de fichier F alors utiliser les droits du proprietaire de fichier pour determiner si l acces possible sinon si le groupe proprietaire effectif de P == groupe proprietaire de fichier F alors utiliser les droits du groupe proprietaire de fichier pour determiner si l acces possible sinon utiliser les droits des autres Donc c est le propriétaire effectif du processus et groupe propriétaire effectif qui déterminent si un processus peut accéder à un fichier. Pour changer le(s) propriétaire(s) le processus peut utiliser les fonctions suivantes : int setuid(uid_t uid) int setgid(gid_t) Le tableau suivant indique comment changent les trois ID (réel, effectif et sauvegardé) si le processus fait exec ou s il exécute setuid(id) : ID exec setuid(id) set used bit off set user id bit on superuser utilisateur real user ID conservé conservé mis à uid conservé pris de user ID de effective user ID conservé mis à uid mis à uid fichier executable copier à partir de copier à partir de saved set-user ID mis à uid conservé effective user ID effective user ID Utilisateur non privilégié paut appeler setuid() pour que ID du propriétaire effectif prenne la valeur du ID du propréitaire réel ou la valeur ID du propriétaire sauvegardé. C est sont les seule modification de ID propriétaire effectif disponibles pour un utlisateur non privilégié. Obtenir l identité du propriétaire réel et du propriétaire effectif #include <sys/types.h> uid_t getuid(void); /*retourne l identite du proprietaire reel*/ uid_t geteuid(void); /* retourne id du proprietaire effectif*/ 3

Le propriétaire réel c est celui qui a lancé le processus. Si vous lancez un processus depuis le terminal c est le propriétaire du processus l interprète de commande qui contrôle le terminal qui devient le propriétaire réel de votre nouveau processus. Obtenir le groupe propriétaire réel et effectif gid_t getgid(void); /*retourne groupe prop reel*/ gid_t getegid(void); /* retourne groupe pro effectif*/ int setgid(gid_t) setgid permet de changer le groupe propriétaire réel et effectif. L utilisateur non privilégié peut modifier uniquement le groupe propriétaire effectif en lui attribuant la valeur de groupe propriétaire réel ou sauvegardé. 2.3 Répertoire de travail Chaque processus possède le répertoire de travail utilisé pour résoudre les chemins relatifs vers les fichiers. Le répertoire de travail est référencé par. (point). On peut modifier le répertoire de travail avec : int chdir(const char *reference) où la référence donne le chemin vers le nouveau répertoire de travail. chdir() retourne 0 en cas de succès et 1 en cas d échec. Pour obtenir la référence absolue (le chemin absolu) de répertoire de travail on utilise la fonction : #inlcude <unistd.h> char *getcwd(char *tampon, size_t taille) Dans tampon vous indiquez l adresse où getcwd doit stocker le chemin absolu vers le répertoire de travail. taille indique la taille de votre tampon. La valeur retournée par getcwd() est tampon si l appel réussi ou NULL dans le cas contraire. Les erreurs possibles : EACCESS problème d accès, ERANGE si le tampon trop petit. Si le tampon trop petit il faut l agrandir et refaire l appel à getcwd. 2.4 Session et groupe de processus Une session est composée de processus lancés par utilisateur après la connexion. Les sessions sont utiles pour gérer les déconnexions de l utilisateur pour provoquer la terminaison des tous les processus lancés par l utilisateur. Les groupes de processus sert au contrôle de tâches (job control). Permet de détacher les tâches en arrière plan et les ramener en avant plan. Il est possible d envoyer un signal à tous les processsus d un groupe de processus. 4

2.4.1 Terminal de contrôle Un terminal un fichier spécial permettant d effectuer les entrées sorties asynchrones. Fonctionne en mode full duplex c est-à-dire traite les entrés et sorties en parallèle (claver/écran). D habitude un processus (ou plus exactement un groupe de processus) possède un terminal de contrôle désigné par /dev/tty. Même si on ferme les descripteurs 0, 1, 2 nous pouvons toujours (re)ouvrir le terminal de contrôle : int d=open( /dev/tty, O_RDWR); Si plusieurs groupes de processus possèdent le même terminal de contrôle un de ce groupes c est le groupe en avant plan (foreground), les autres groupes sont en arrière plan (background). Si on tape par exemple CTRL-Z alors le signal d interruption est envoyé vers tous les processus du groupe en avant plan. Il y a des fonctions qui permettent de trouver le groupe en avant plan, mettre en arrière plan un groupe qui est en avant plan etc. Sauf si vous écrivez un shell ces fonctions ont peu d intérêt. 2.5 Date de création La date de création d un processus est donnée en nombre de secondes depuis EPOCH (1 janvier 1970). 2.6 Temps CPU Pour connaître le temps CPU pour les deux modes : utilisateur et noyau, on utilise la fonction times en lui passant l adresse de la structure tms : clock_t times(struct tms *buf) où clock_t un type entier. La fonction met à jour le contenu de la structure struct tms. La fonction retourne (clock_t) -1 en cas d echec et mets dans errno le code d erreur. Dans ce qui suit le temps clock_t est toujours mesuré en nombre de clics d horloge. La structure struct tms définie dans #include <sys/times.h> struct tms{ clock_t tms_utime; user CPU time clock_t tms_stime; system CPU time clock_t tms_cutime; user CPU time of terminated child processes clock_t tms_cstime; system CPU time of terminated child processes Le temps tms_utime et tms_stime d un fils sont ajoutés dans tms_cutime et tms_cstime pour chaque fils terminé au moment où wait() ou waitpid() retourne le pid de ce fils. tms_utime le temps que le processus a passé en mode utilisateur (en exécutant les instructions de l utilisateur). tms_stime le temps que le processus a passé en mode système, 5

tms_cutime c est la somme de tms_utime de processus courant et de tms_cutime de chaque processus fils terminé et attendu avec wait() oun waitpid(). tms_cstime est la somme de tms_stime de processus courant et de tms_stime de chaque fils terminé et attendus avec wait() up waitpid(). Pour déterminer le nombre de clics d horloge par seconde on utilise sysconf(_sc_clk_tck). Ce nombre change d une machine à l autre. 2.6.1 Le masque de création de fichiers Le masque de création de fichier est une propriété de processus. Pour changer de masque : mode_t umask(mode_t masque) Pour les détails voir les explications dans la partie FICHIERS. 2.7 Table de descripteurs Le processus fils hérite la table de descripteurs de processus père. 3 Espace d adressage de processus L espace d adressage virtuel d un processus est divisé en plusieurs segments : le segment de code (text segment) contient les instructions de programme. S il y a plusieurs processus exécutant le même programme (par exemple un éditeur de texte) alors souvent ces processus partagent le même segment de texte. Ce segment est souvent accessible uniquement en lecture pour que le programme ne puisse pas modifier par erreur son propre code. le segment de données initialisées (initialized data segment) contient les variables déclarées en dehors de fonctions 1 et initialisées explicitement dans le programme. Par exemple si le programme contient la déclaration int toto=99; à l extérieur de toute fonction C alors la mémoire pour la variable toto se trouve dans ce segment et elle est initialisée avec la valeur 99 au moment de chargement de programme pour l exécution. Ce segment contient aussi les variables static initialisées (peu importe où elles se trouvent, à l intérieur des fonctions ou au niveau 0). Donc si static int toto=9; alors toto sera placé dans ce segment aussi bien quand cette instruction se trouve dans une fonction ou au niveau 0. le segment de données non-initialisées (bss segment) contient par les variables de niveau 0 (définies en dehors de fonctions) non-initialisées et les variables static non initialisées. Par exemple si long tab[20]; est défini en dehors de toute fonction alors la mémoire pour tab se trouve dans ce segment et est initialisée à 0 au moment de chargement de programme dans la mémoire. Pareil, une variable déclarée comme 1. les variables de niveau 0 6

static int n; n importe où dans le programme se trouve dans le segment bss et elle est initialisée à 0. le tas (heap) contient les variables allouées dynamiquement par malloc et ses cousins, la pile (user stack) pour stocker les variables définies dans les fonctions et les paramètres de fonctions. arguments de la ligne de commande et les variables d'environnement pile (stack) tas (heap) les données non initialisées (bbs) initialisées à 0 par exec les données initialisées lues par exec à partir de fichier de programme code (text) Figure 1 Les segments d un programme C. Les flèches montrent dans quelle direction grossissent la pile et le tas. La commande size permet d afficher la taille de différents segments. Par exemple size copier text data bss dec hex filename 1172 272 8 1452 5ac copier permet de voir que pour l exécutable copier la taille de segment de code est 1172, segment de données 272, segment bss 8, total 1452 (tout en decimal). La figure 3 présente la mémoire et les différents segments d un processus. 4 Création de processus Pour voir tous les processus utilisez la commande ps axl. Création d un nouveau processus : #include <sys/types.h> pid_t fork(void) 7

Tout processus (sauf 0) est créé avec fork() fork crée un nouveau processus (nommée processus fils ou processus enfant) qui est une copie exacte du processus père : les segments text, data, bss du fils sont de copies de segments correspondant du père, le tas et la pile de fils sont des copies du tas et de la pile du père 2. En particulier la table de descripteurs de fichier du fils est initialement une copie de la table de descripteurs de fichiers du père. Les descripteurs de fichiers ouverts avant fork pointent toujours vers les mêmes objets fichier ouvert dans la table de fichiers ouverts, donc le changement de la position courante dans le fichier par un de deux processus change la position courante dans l autre. Après fork() les processus fils et père continuent à exécuter les instructions qui suivent fork(). Les différences entre le processus fils et le processus père : 1. chez le fils fork() retourne 0, chez le père fork() retourne le pid du fils, 2. le processus enfant a son propre pid différents de tous les autres pid et gid, 3. le ppid de l enfant initialisé avec le pid de père, 4. les mesures du temps consommé sont initialisées à 0 pour l enfant, 5. les verrous de fichiers posés par le père ne sont pas hérités, 6. si une minuterie est activé avec unsigned int alarm(unsigned int secondes) elle est désactivée chez le fils, 7. chez le fils l ensemble de signaux pendants est initialisé comme l ensemble vide 3. #include <sys/types.h> pid_t vfork(void) La fonction vfork() fait la même chose que fork() mais ne fait pas de copie de données, les données sont partagées entre le processus père et le processus fils. L utilisation de vfork() appropriée uniquement pour faire immédiatement exec() chez le fils. 5 Primitives de recouvrement (exec) Juste après fork() le processus fils est une copie du père. Mais dans la plupart de cas nous voulons que le nouveau processus exécute un autre programme que celui exécuté par le père. Quand un processus 4 fait appel à une de fonctions de la famille exec le code exécuté par ce processus est remplacé par le code du programme indiqué par les paramètres d exec. Il y a six primitives de recouvrement. Différences entre ces primitives concernent : 1. manière de faire passer les arguments de main() : soit une liste l (execl, execle, execlp 2. Les systèmes modernes sont optimisés et ne font pas tout de suite de copies de données, de tas et de pile, parce que ces copies auraient été inutiles si le fils fait immédiatement exec(). Donc seulement au moment où le fils ou père essaient de modifier soit les données soit la pile soit le tas que le système fait une copie de la page mémoire correspondante. 3. Plus de précisions sur les signaux dans le cours Systèmes du Master 1. 4. d habitude c est le processus fils qui fait appel à exec 8

soit un vecteur v (execv, execve, execvp), 2. la manière utilisée pour trouver le fichier à charger : soit en utilisant la variable PATH de l environnement, ce que indique la lettre p dans le nom de la fonction, c est le cas de primitives exelp() et execvp(), soit relativement au répertoire courant du processus (ou une référence absolue), 3. l environnement du processus après le recouvrement, dans le cas de execve() et execle() un nouvel environnement se substitue à l ancien. Les primitives de la famille exec ne retournent jamais en cas de succès. En cas d échec la valeur de retour est 1. int execl(const char *path, const char *arg0,... /*, (char *)0*/); int execv(const char *path, char *const argv[]); int execle(const char *path, const char *arg0,... /*, (char *)0, char *const envp[]*/); int execve(const char *path, char *const argv[], char *const envp[]); int execlp(const char *file, const char *arg0,... /*, (char *)0 */); int execvp(const char *file, char *const argv[]); Exemple 1. Pour remplacer le code actuellement exécuté par le code de ls : execl( /bin/ls, ls, -l, /,(char *)0); Les listes de paramètres de execl, execlp terminent toujours avec (char *)0. execlp() se comporte de la même manière sauf que pour résoudre les références relatives execlp utilise la variable PATH. Par exemple si PATH contient.:/bin:/usr/bin on pourra faire execlp( ls, ls, -l, /,(char *)0); La même chose avec le vecteur d arguments : char *tab[]={"ls", "-l", "/", NULL; execvp("ls",tab); ou avec un vecteur alloué dynamiquement : char **tab=malloc( 4 * sizeof(char *)); tab[0]="ls"; tab[1]="-l"; tab[2]="/"; tab[3]=null; execvp("ls",tab); 9

5.1 Propriétés d un processus après le recouvrement La plupart de propriétés de processus ne changent pas après exec. Cependant il y a quelques exceptions : (1) propriétaire effectif si le bit set-uid est positionné sur le fichier chargé par exec le propriétaire de ce fichier devient le propriétaire effectif du processus. (2) groupe effectif si set-uid est positionné sur le fichier chargé par exec alors le groupe propriétaire du fichier chargé devient le groupe propriétaire effectif du processus, (3) le handler par défaut est installé pour les signaux captés, (4) descripteurs Le processus garde la même table de descripteurs. Mais si le bit FD_CLOEXEC de fermeture automatique en cas d exec a été positionné par un appel à fcntl() alors ce descripteur sera fermé par exec. Les autres descripteurs de fichiers restent ouverts 5. Avant faire exec le processus doit fermer tous les descripteurs qu il ne utilisera plus. Si les fichiers étaient ouverts avec le drapeaux FD CLOEXEC la fermeture de fichiers par le processus par le fils sera inutile, c est le système qui s en chargera au moment où le processus fait appel à exec. Le processus après exec garde son pid et pid de son parent, le terminal de contrôle, le répertoire courant, le masque umask, les valeurs de temps d exécutions, etc. etc. 6 Terminaison de processus (exit et exit) Le processus termine soit à sa demande soit à la réception d un signal provoquant sa terminaison. Le processus qui termine devient zombie, l information sur la terminaison est enregistrée dans le bloc de contrôle est reste disponible jusqu à la consultation par le processus père avec un des primitives wait ou waitpid Il y a deux fonctions pour terminer un processus : void exit(int valeur) vois _exit(int valeur) exit provoque 1. fflush() sur tous les fichiers ouverts pour vider les tampons, 2. suppression de fichiers créés avec tmpfile() 3. la fonction appelle toutes les fonctions enregistrées avec atexit() dans l ordre inverse d enregistrement, 4. fait appel à _exit(valeur) 5. dans les programmes étudiés en cours FD CLOEXEC n a jamais été utilisé donc les processus vues en cours gardaient la table de descripteurs intact après exec. 10

Seulement l octet de poids faible de valeur peut être récupéré, donc en pratique les valeur d exit limités aux valeurs entre 0 et 255. Deux constantes symboliques EXIT_SUCCESS et EXIT_FAILURE définies dans stdlib.h peuvent être utilisées comme les valeurs d exit. L appel à _exit() provoque 1. fermeture de fichiers et répertoires (sans fflush()) 2. envoie de signal SIGHUP à tous les processus de groupe si le processus qui termine est le leader du groupe, 3. rattachement des fils au processus 1, 4. si le père du processus qui fait _exit est en attente sur wait() ou waitpid() alors il est réveillé sinon le processus qui fait _exit devient zombie. Le signal SIGCHLD est envoyé au père. L instruction return exécutée dans main() provoque l appel à exit 7 Processus zombie et synchronisation père fils Le processus qui termine devient zombie. Il est maintenu dans la table de processus mais ne consomme plus de ressources système. Le processus peut terminer pour deux raisons : (1) terminaison normale par exit(), _exit() ou return de la fonction main, dans ce cas le processus retourne le code de retour, (2) une terminaison à la suite de réception d un signal. Si on exécute sur le terminal la commande ps -eo pid,user,args,s --sort user pour voir tous les processus les processus zombie sont marqués comme comme defunct et leur état est Z. Les seules informations maintenues dans le bloc de contrôle après la terminaison de processus sont : son code de retour exit ou le signal, le temps d exécution dans les modes utilisateur et noyau, son identité et l identité de son père. Si le processus père termine et s il possède de fils zombie alors ces fils seront automatiquement supprimés. Les fonctions wait() et waitpid() permettent d obtenir les informations sur le statut d un processus fils qui est soit terminé soit stoppé. 7.1 wait #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *p_status) Supposons qu un processus fait appel à wait alors (1) si le processus n a pas de fils wait retourne 1 et errno==echild. 11

(2) si le processus possède des fils zombies alors wait retourne le pid d un fils zombie et ce fils est supprimé de la table de processus. De plus si p_status n est pas NULL alors *p_status reçoit les informations sur la terminaison du fils. (3) si le processus possède des fils mais aucun fils zombie alors le processus qui appel wait est bloqué en attendant soit qu un fils devient zombie, voir (2), soit jusqu à la réception d un signal. Dans ce dernier cas la valeur de retour de wait est 1 et errno est EINTR. Exemple 2. Le processus attend la terminaison d un fils quelconque et on récupère la valeur exit de ce fils (s il a terminé par exit) : pid_t fils; int status, code_ret, code_signal;... fils=wait(&status); if( fils < 0 ){ /* erreur ou signal */ else{ /* fils zombie supprime*/ if( WIFEXITED(status) ){ /*le fils a termine par exit*/ code_ret=wexitstatus(status); /*recuperer le code d exit de fils*/ printf("code de retour %d\n", code_ret); else if( WIFSIGNALED(status) ){ code_signal = WTERMSIG(status); printf("numero de %d\n", code_signal); 7.2 waitpid #include <sys/types.h> #include <sys/wait.h> pid_t waitpid(pid_t pid, int *p_status, int options) permet de tester la terminaison d un processus fils spécifique. De plus le paramètre options permet de spécifier si l attente est bloquante ou non. Le paramètre pid permet de spécifier le processus dont on attend la terminaison : valeur pid attente de la terminaison < 1 d un processus quelconque dans le groupe de processus pid (pid_t) 1 d un processus fils quelconque (équivalent à wait()) 0 d un processus fils quelconque du même groupe de processus que l appelant > 0 du processus fils d identité pid Le paramètre options de waitpid est soit 0 soit la constante 6 6. cette description n est pas complète, il y a aussi une autre constante WUNTRACED qui peut être utilisée comme troisième paramètre. 12

WNOHANG appel non bloquant waitpid() retourne le pid de fils zombie s il y avait un fils zombie. Si waitpid() retourneàcaused unsignal alorslavaleurderetourest 1eterrno == EINTR.Siwaitpid() est appelé avec le flag W_NOHANGet le premier paramètre spécifie un ou des fils existant mais aucun de ces fils n est zombie alors waitpid retourne 0. Si waitpid() retourne à cause d une erreur alors la valeur de retour est 1 et errno donne le numéro d erreur. Exemple 3. Pour supprimer tous les fils zombies sans attente bloquante : pid_t p; while( ( p = waitpid(0, NULL, WNOHANG ) ) > 0 ){ printf("fils %d a termine\n", p); if( p == 0 ){ /* il y a encore des fils mais aucun fils zombie */ Rappel : Dans le code de retour donné à l appel de exit() juste l octet de poids faible compte, donc les codes de retour valables sont entre 0 et 255. Si le processus fils termine à cause d un signal alors *p_status contient le numéro de signal augmenté de 128 si le fichier core a été créé. Les macro-fonctions suivantes permettent interroger la valeur de p_status : WIFEXITED non nulle si le fils a terminé par exit ou exit WIFSIGNALED non nulle si le fils a terminé en recevant un signal Pour obtenir les informations supplémentaires on utilise les macro-fonctions suivantes : WEXITSTATUS donne le code de retour pour le processus terminés par exit ou par exit WTERMSIG si le retour de la macro-fonction WIFSIGNALED est non nul alors cette macro-fonctions donne le numéro du signal Voir l exemple 2. 8 Communication entre des processus par les tubes Le tube est un fichier spécial qui permet d établir une communication entre des processus. Les écrivains les processus qui écrivent dans le tube, les lecteurs les processus qui lisent dans le tube. Il existe deux types de tubes : tubes anonymes et tubes nommés. Les deux types de tubes ont plusieurs caractéristiques communes. (1) Chaque tube est représenté par un vnode, donc l utilisation de tubes ressemble à l utilisation de fichiers, en particulier dans les programmes les tubes sont accessibles au moyen de descripteurs. (2) Un tube possède deux extrémités, représentées par deux descripteurs différents : un descripteurs utilisé pour la lecture et un autre pour l écriture. Donc les tubes réalisent une communication unidirectionnelle. 13

(3) On peut utiliser le mécanisme de duplication de descripteurs sur les descripteurs de tubes. Donc il est possible d avoir plusieurs descripteurs à l entrée et à la sortie d un tube. (4) Les fils hérite les descripteurs de tubes de son père, c est le mecanisme utilisé pour instaurer une communication entre père et fils par les tubes anonymes. (5) Un tube est une file FIFO (first in first out), les octets écrits dans le tube sont ajoutés à la fin de la file, les octets lus ce sont les octets au débuts de la file. Les octets lus sont automatiquement supprimé du tube. La notion de la position courante ne s applique pas aux tubes, impossible d utiliser lseek() pour les tubes. (6) Le tube a une capacité limitée, donc si le tube est plein un écrivain ne peut plus écrire tant qu un n a pas lu ce qui a été envoyé dans le tube. (7) Si le nombre de lecteurs est nul (aucun descripteur ouvert pour la lecture) l écrivain essayant écrire dans le tube reçoit le signal SIGPIPE. (8) Si le nombre d écrivains est nul (le nombre de descripteurs ouverts pour l écriture dans le tube est nul) alors le lecteur détecte la fin de fichier pendant la tentative de lecture. 8.1 Tubes nommés 8.1.1 Création de tube nommé Un tube nommé peut être créé depuis un terminal avec la commande : mkfifo reference Par exemple mkfifo toto ls -l grep toto prw-r--r-- 1 zielonka zielonka 0 2010-12-06 18:16 toto Nous pouvons voir que mkfifo a créé un fichier spécial toto et type de fichier est p (pipe). Faire man mkfifo pour voir les options de mkfifo. Dans un programme C la création d un tube nommé s effectue avec #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *chemin, mode_t droits); où chemin donne le chemin d accès au tube et droits les droits d accès (comme pour open()). Comme les tubes nommés apparaissent dans l arbre de fichiers on les supprime comme on le fait avec les fichiers ordinaires, voir la fonction unlink. 8.1.2 Ouverture de tube nommé Une fois le tube nommé créé on peut y accéder en l ouvrant avec open(), de la même façon que pour les fichiers ordinaires. Les seuls modes d ouverture possibles sont O_RDONLY et O_WRONLY. Dans cequisuiton supposequetubeest untubenommé quisetrouvedanslerépertoire courant du processus. 14

Ouverture bloquante de tube nommé : une demande d ouverture int in = open("tube", O_RDONLY); en lecture est bloquente en absence d écrivain, une demande d ouverture en écriture int out = open( tube,o_wronly); est bloquante s il n y pas de lecteurs. Donc deux processus peuvent se synchroniser en utilisant le tube, un en lecture et l autre en écriture. L ouverture en mode non bloquant est réalisée avec le flag O_NONBLOCK : Ouverture non bloquante en lecture : int in = open( tube, O_RDONLY O_NONBLOCK ); réussit immédiatement même en absence d écrivains. Les opérations de lecture qui suivent l ouverture non bloquante restent non bloquantes (jusqu à, éventuellement, de changement de mode à l aide de fcntl()). Ouverture non bloquante en écriture : int out = open( tube, O_WRONLY O_NONBLOCK ); sans lecteurs échoue (open retourne 1 et errno==enxio). Après l ouverture non bloquante les opération write sont réalisées en mode non bloquant (jusqu à, éventuellement, de changement de mode à l aide de fcntl()). 8.2 Lecture et écriture dans un tube nommé ou anonyme 8.2.1 Lecture à partir un tube Une fois un processus dispose d un descripteur de tube ouvert en lecture il peut effectuer les opérations de lecture à l aide de read. Un read(in, tampon,len) sur un descripteur in de tube ouvert en lecture lit au plus len octets et mets les octets lus à l adresse tampon et retourne le nombre d octets lus. Les octets lus sont automatiquement supprimés du tube. Une tentative de read sur un tube vide provoque : s il n y a pas d écrivains 7 alors read retourne 0 (comme pour la fin de fichier), s il existe au moins un écrivain sur ce tube alors si le processus lecteur a positionné le flag O_NONBLOCK (lecture non bloquante) alors read est non bloquant et retourne 1 et errno == EAGAIN, si le processus lecteur n a pas positionné de flag O_NONBLOCK (lecture bloquante) alors read est bloqué jusqu à ce que soit un écrivain écrit dans le tube soit tous les écrivains ferment le tube pour écriture. 7. c est-à-dire pas de processus qui a un descripteur sur ce tube ouvert en écriture 15

8.2.2 Écriture dans un tube Il n y a pas d offset (de position courante) associé à un tube, l écriture s effectue toujours à la fin de tube. (1) Un write qui demande d écrire moins de PIPE_BUF octets fait toujours une écriture atomique : tous les caractères sont écrits d un seul coup sans être intercalés par des caractères écrits par un autre processus. (2) Un write dans un tube qui n a pas de lecteurs (aucun processus n a pas de tube ouvert en lecture) provoque l envoie de signal SIGPIPE vers le processus qui fait write. Si on a pas installé de handler pour ce signal alors le signal SIGPIPE termine l exécution de l écrivain. (3) S il existe des lecteurs pour le tubes alors Si le flag O_NONBLOCK n est pas positionné chez l écrivain (l écriture bloquante) alors write est bloqué jusqu à ce que write réussi à écrire tous les octets dans le tube, si le flag O_NONBLOCK est positionné chez l écrivain (l écriture non bloquante) alors soit write réussi à écrire dans le tube et il retourne le nombre d octets écrits soit write ne réussi pas (tube plein) et retourne 1 et errno == EAGAIN. 8.3 Tubes anonymes Letubesanonymessontcréés àlavoléparl appelàlafonctionpipe,voirlasection8.3.1. Contrairement aux tubes nommés les tubes anonymes ne sont pas visibles dans l arbre de fichiers et disparaissent automatiquement quand il n y a plus de processus possédant un descripteur ouvert sur le tube. Par contre les tubes anonymes possèdent les v-nodes et apparaissent dans la table de v-nodes, la table de fichiers ouverts et dans les tables de descripteurs. Les descripteurs ouvert sur un tube anonymes sont créés avec le tube lui-même, open ne s applique pas aux tubes anonymes. Par contre close est toujours utilisé pour fermer un descripteur d un tube anonyme. Les descripteurs d un tube anonyme apparaissent dans la table de descripteur, en particulier le processus fils créé par fork possède la copie de la table de descripteurs du père y inclus les descripteurs de tubes anonymes créés par le père. 8.3.1 Création d un tube anonyme La création d un tube anonyme s effectue à l aide de la fonction pipe : int pipe(int desc[2]) desc est un vecteur (tableau) de deux entiers. Si l appel à pipe réussit desc[0] contient un descripteur ouvert en lecture tandis que desc[1] contient un descripteur ouvert en écriture et la fonction pipe retourne 0. En cas d échec pipe() renvoie 1. Noter que pipe non seulement crée un tube anonyme, pipe fournit aussi deux descripteurs déjà ouverts, un pour la lecture l autre pour l écriture. 8.3.2 Lecture/écriture dans le tube anonyme Identique comme pour le tube nommé, voir la section 8.2. 16

8.3.3 Exemple - communication père fils par un tube anonyme #include <stdlib.h>... int tube[2]; #define BSIZE = 100 char buf[bsize]; ssize_t nbytes; int status; status = pipe(tube); if (status == -1 ) { /* traiter erreur de pipe() */... switch (fork()) { case -1: /* traiter erreur de fork() */ break; case 0: /* fils - lit du tube */ close(tube[1]); /* fils n ecrit pas, * fermer le descripteur * d ecriture */ while( (nbytes = read(tube[0], buf, BSIZE) ) > 0){ /* lire dans le tube*/ /* traitement */ close(tube[0]); /* fils termine */ exit(exit_success); default: /* processus pere - ecrit dans le tube */ close(tube[0]); /* le pere ne lit pas * fermer le descripteur de lecture */ write(tube[1], "Hello world\n", 12); /* pere ecrit */ close(tube[1]); /* fermer le tube pour que le fils voie la fin de fichier */ exit(exit_success); 17

8.4 Changement de propriété bloquant non bloquant Pour modifier la valeur du drapeauo NONBLOCK on utilise la fonction fcntl, voir le poly sur les fichiers. 9 Duplication de descripteur avec dup() et dup2() Le mécanisme de redirections des entrées/sorties standard est possible grâce à l utilisation homogène de descripteurs de fichiers et s applique non seulement aux fichiers réguliers mais aussi aux tubes. L opération de duplication d un descripteur d consiste à créer un nouveau descripteur e qui est une copie de d, c est-à-dire e pointera vers le même objet fichier ouvert dans la table de fichiers ouverts que d. La fonction int dup(int desc) prend comme argument un descripteur valide. Elle cherche le plus petit descripteur libre e (non utilisé) dans la table de descripteur de fichiers et copie desc dans e. La fonction retourne le nouveau descripteur e ainsi créé. Si l appel à dup échoue (par exemple quand desc n est pas un descripteur valide) alors dup retourne 1. Un exemple est présenté dans la figure 2 page 19. int dup2(int oldfd, int newfd) La fonction dup2() ferme le descripteurs newfd s il était ouvert et fait copie de oldfd dans newfd. La fonction retourne 1 en cas de problèmes et newfd sinon. Après l appel réussi les descripteurs newfd et oldfd pointent vers la même entrée de la table de fichiers ouverts. Si newfd<0 ou newfd >= MAX_OPEN alors dup2() retourne 1 et errno == EBADF. Si oldfd est un descripteur valide et égal à newfd alors la fonction dup2() retourne oldfd sans le fermer (donc dup2() n a pas d effet.) Si oldfd n est pas un descripteur valide alors dup2() retourne 1 et ne ferme pas newfd. 9.1 Exemple - redirections Supposons que voulons établir une communication entre le processus parent et le processus enfant par deux tubes anonymes, le tube parent2enfant sert à envoyer les messages de parent vers l enfant tandis que le tube enfant2parent permet d envoyer le message de l enfant vers le parent. On suppose que le processus enfant lit après le recouvrement les messages en utilisant le descripteur 0 et écrit sur le descripteur 1 Donc quand l enfant lit sur le descripteur 0 il doit lire sur le tube parent2enfant quand il écrit sur le descripteur 1 il doit écrire dans le tube enfant2parent. La création de tube, de processus enfant et les redirections sont réalisés par la fonction redirection suivante : 18

AVANT APRES dup2(2, 6) Figure 2 Processus 1 exécute i=dup(3). Le premier descripteur libre pour ce processus est 1 donc dup retournera la valeur 1 et le descripteur 3 sera copié dans le descripteur 1. Les descripteurs 1 et 3 pointent maintenant vers le même fichier ouvert. Processus 2 exécute dup2(2,6). Cet appel ferme le descripteur 6 et ensuite copie le descripteur 2 vers 6. A gauche la configuration avant que les deux processus exécutent dup et dup2, à droite après. Notez que le compteur de descripteur ouvert augmente pour les fichiers dont le descripteur a été dupliqué. #define POSIX C SOURCE 200112L #include <unistd.h> #include <sys/types.h> #include redirection.h #include panic.h / Cette fonction cree un processus enfant et etablit une communication entre le parent et enfant par deux tubes anonymes. Les parametres d entree : char ref chemin vers executable execute par le processus enfant char argv le tableau d arguments pour l executable de l enfant Les parametres de sortie : int in in le descripteur de lecture pour le parent int out out le descripteur d ecriture pour le parent Valeur de retour : le pid de l enfant. / pid t redirection (char ref, char argv, int in, int out){ / les tableaux de descripteur : parent2enfant pour le tube de parent vers l enfant, enfant2parent pour le tube de l enfant vers le parent. / int parent2enfant [2], enfant2parent [2]; 19

pid t pid ; / creer deux tubes anonymes / if ( pipe(parent2enfant) < 0 ){ perror( pipe ); return 1; if ( pipe(enfant2parent) < 0 ){ perror( pipe ); return 1; if ( ( pid=fork () ) == ( pid t ) 1 ){ perror( fork ); return 2; / processus enfant / else if ( pid == 0 ){ / fermer les descripteurs inutiles pour l enfant / close (enfant2parent [0]); close(parent2enfant [1]); / pour le processus enfant la lecture sur le descripteur 0 c est la meme chose que la lecture de tube parent2enfant / if ( dup2( parent2enfant [0], 0 ) == 1 ){ perror( dup2 ); return 3; / fermer le descripteur qui devient inutile apres la duplication / close (parent2enfant [0]); / pour l enfant l ecriture sur le descripteur 1 c est l ecriture dans le tube enfant2parent / if ( dup2( enfant2parent [1], STDOUT FILENO) == 1 ){ perror( dup2 ); return 4; / fermer le descripteur qui devient inutile apres la duplication / close (enfant2parent [1]); / recouvrement avec exec l enfant execute un nouveau programme / execvp(ref, argv ); perror( exec ); return 5; else{/ parent / / fermer les descripteurs inutiles pour le parent / close (enfant2parent [1]); close (parent2enfant [0]); / preparer les parametres de retour de la fonction / out = parent2enfant [1]; in = enfant2parent [0]; return pid ; L exemple d utilisation de cette fonction : #define POSIX C SOURCE 200112L #include <stdio.h> #include <sys/types.h> #include <stdlib.h> #include <unistd.h> 20

#include <string.h> #include <sys/wait.h> #include redirection.h int main(void){ #define T 512 char tampon[t]; / les tableau de chaines de caracteres a envoyer vers les processus enfant / char text[]={ Assez vu. La vision s est rencontrée à tous les airs., Assez eu. Rumeurs des villes, le soir, et au soleil, et toujours., Assez connu. Les arrêts de la vie. Ô Rumeurs et Visions!, Départ dans l affection et le bruit neufs! ; / les enfants vont executer la commande tr / char ref= tr ; char arg[]={ tr, a z, A Z, (char ) NULL ; int in, out ; int dim=sizeof text/sizeof text [0]; for(int i=0; i<dim; i++){ int k; pid t f = redirection (ref, arg, &in, &out ); if ( f < 0){ fprintf (stderr, echec redirection\n ); exit (1); / ecrire vers l enfant / if ( (k = write(out, text [ i ], strlen(text [ i ])) ) < 0){ perror( write ); continue; close (out ); / lire ce que l enfant envoie / k=read(in,tampon, sizeof tampon); if (k < 0){ perror( read ); continue; close (in ); tampon[k]= \0 ; printf ( [%s]\n,tampon); / attendre la terminaison de l enfant / wait(null); exit (0); 10 select et pool Parfois un processus attend une lecture sur plusieurs descripteurs. Cette attente multiple est facilité par des fonctions select et poll. 21

10.1 select #include <sys/select.h> int select(int maxfdp, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict exceptfds, struct timeval *restrict tvptr); La fonction retourne le nombre de descripteur prêts (pour la lecture ou écriture). Nous utiliserons toujours exceptpds == NULL. Si tvptr==null alors attendre sans limite du temps. Ceci peut être interrompu par un signal. Dans ce cas select retourne 1 et errno==eintr. Si tvtpr->tv_sec == 0 && tvtpr -> tvusec == 0 alors ne pas attendre. Les descripteurs sont testés et la fonction retourne immédiatement. Si tvtpr->tv_sec!= 0 tvtpr -> tvusec!= 0 alors attendre le temps donné(secondes et milisecondes). int FD_ISSET(int fd, fd_set *fdset); int FD_CLR(int fd, fd_set *fdset); int FD_SET(int fd, fd_set *fdset); int FD_ZERO(fd_set *fdset); FD_ISSET retourne une valeur différente de 0 si fd se trouve dans fdset., 0 sinon. FD_ZERO vide fdset. maxfd est le descripteur maximal plus 1. Un descripteur dans le readset est considéré comme prêt si read ne bloquera pas sur ce descripteur. Pareil pour write. Read/write bloquant ou non n affecte pas le comportement de select. Le descripteur qui retourne 0 à la lecture est considéré comme prêt pour la lecture. 10.2 poll #include <poll.h> int spoll(struct pollfd fdarray[], nfds_t nfds, int timeout); La fonction retourne le nombre de desc ripteurs prêts, 0 si timeout, 1 si erreur. struct pollfd { int fd; short events; /*evenements attendus*/ short revents; /*evenements prets*/ 22

events et revents prend des constantes POLLIN, POLLOUT (et pleines d autres mais on est intéréssé par ces deux). timeout==-1 attendre sans timeout, timeout==0 sans attente timeout>0 attente en milisecondes. 23