SYSTÈME D’EXPLOITATION I

1. SYSTÈME D’EXPLOITATION I SIF-1015

2. Contenu du cours 6 • Communication par tubes • Tube nommé (FIFO) • IPC (Inter Process Communication) • Files de messages • Mémoire Partagée • Les signaux • LECTURES: • Chapitre 3 (OSC) • Chapitres 10, 12, 13 (Mitchell) • Chapitres 5, 10 et 11 (Card) • Annexe C (Mitchell)

3. Communication par tubes • Les tubes représentent un mécanisme de communication entre processus. La transmission des données entre processus s’effectue à travers un canal de communication: les données écrites à une extrémité sont lues à l’autre extrémité

4. Communication par tubes • Le premier type de tubes est le tube anonyme, il est créé par un processus et la transmission des descripteurs associés ne se fait que par héritage vers ses descendants. Ce mécanisme est contraignant puisqu’il ne permet la commu-nication qu’entre processus ayant un ancêtre commun qui lui est le créateur du tube • Les tubes nommés (FIFO) permettent d’éliminer cette contrainte puisqu’ils sont traités comme des fichiers en ce qui concerne les opérations d’ouverture, de fermeture, de lecture et d’écriture. Les FIFO ont donc une entrée dans le système de fichier. Un fichier de type FIFO peut être identifié par l’attribut p affiché par la commande shell ls -al

5. Communication par tubes • Appels système • Tubes anonymes: Créer par un appel système pipe() • int pipe(int filedes[2]); • filedes[0]: descripteur de lecture du tube • filedes[1]: descripteur d’écriture du tube

6. Communication par tubes exemple pipe1.c dans le répertoire Chap12ProgLinux sur mil08 • Exemple d’utilisation des pipes (1 processus) Exécution: > ./pipe1 Wrote 3 bytes Read 3 bytes : 123

7. Communication par tubes exemple pipe2.c dans le répertoire Chap12ProgLinux sur mil08 • Exemple d’utilisation des pipes (2 processus)

8. Communication par tubes exemple pipe3.c dans le répertoire Chap12ProgLinux sur mil08 • Exemple d’utilisation des pipes (2 processus, utilisation de execl())

9. Communication par tubes exemple pipe4.c dans le répertoire Chap12ProgLinux sur mil08 • Exemple d’utilisation des pipes (2 processus, utilisation de execl()) Exécution: > ./pipe3 980 - wrote 3 bytes 981 - read 3 bytes : 123

10. Communication par tubes • Appels système • FIFO: Peut être créée par la fonction libc mkfifo(). #include <sys/stat.h> int mkfifo(const char *path, mode_t mode); • Cette fonction fait en réalité appel à l’appel système mknod() mknod(const char *path, mode_t mode, dev_t dev); • Par exemple: mknod(path, mode | S_IFIFO, 0); • Comme pour les fichiers, les FIFO permettent les I/O bloquantes (par défauts) ou non bloquantes (en spécifiant l’option O_NODELAY ou O_NONBLOCK lors de l’ouverture avec open())

11. Communication par tubes • Utilisation des FIFO (Création d’un fichier FIFO, exemple fifo1.c dans le répertoire Chap12ProgLinux sur mil08)

12. Communication par tubes • Utilisation des FIFO (Création d’un fichier FIFO: Entrée dans le répertoire /tmp)

13. Communication par tubes • Utilisation des FIFO (Création d’un fichier FIFO: Entrée dans le répertoire /tmp)

14. Communication par tubes • Utilisation des FIFO (Création d’un fichier FIFO) • Fonctionnement: • La fonction mkfifo() permet de créer un fichier spécial. • Même si le mode d’ouverture de ce fichier est de 0777, cette valeur est modifiée par la valeur du masque utilisateur (variable système avec comme valeur typique: 0022) et ce comme dans le cas des fichiers normaux. • Le fichier spécial (FIFO) est donc ouvert en mode 755 (RWX pour le propriétaire du processus, RX pour le groupe et les autres). • Dans un programme si nous voulons modifier le masque utilisateur, nous utilisons l’appel système: #include <sys/stat.h> int umask(int mask) // nouvelle_permission = ancienne_permission & (~mask) // mask est le nouveau masque // umask() retourne la valeur de l’ancien masque

15. Communication par tubes • Utilisation des FIFO (Création d’un fichier FIFO) • Fonctionnement: • Pour effacer un fichier spécial nous pouvons utiliser l’appel système: #include <unistd.h> int unlink( const char *pathname); // unlink() supprime le fichier dont le nom est pointé par pathname // unlink() retourne la valeur 0 si la suppression est réussi et –1 sinon

16. Communication par tubes Voir exemple fifo2.c • Utilisation des FIFO (Ouverture d’un fichier FIFO)

17. Communication par tubes • Utilisation des FIFO (Ouverture d’un fichier FIFO) Exécution: >./fifo2 O_RDONLY & [1] 152 Process 152 opening FIFO >./fifo2 O_WRONLY Process 153 opening FIFO Process 152 result 3 Process 153 result 3 Process 152 finished Process 153 finished La fonction access() vérifie si l’utilisateur a les permissions d’accès à une FIFO Permet aussi de vérifier si une FIFO existe

18. Communication par tubes Voir exemple fifo3.c • Utilisation des FIFO (I/O dans un fichier FIFO: Écriture)

19. Communication par tubes • Utilisation des FIFO (I/O dans un fichier FIFO: Écriture)

20. Communication par tubes Exécution: >./fifo3 & [1] 375 Process 375 opening FIFO O_WRONLY >./fifo4 Process 377 opening FIFO O_RDONLY Process 375 result 3 Process 377 result 3 Process 375 finished Process 377 finished, 10485760 bytes read Voir exemple fifo4.c • Utilisation des FIFO (I/O dans un fichier FIFO: Lecture)

21. Communication par tubes Voir exemple server.c, client.h • Utilisation des FIFO (Serveur)

22. Communication par tubes Voir exemple client.c • Utilisation des FIFO (Client)

23. Communication par tubes • La taille d’un tube est limitée à 4Ko (valeur de la constante PIPE_BUF dans le fichier <linux/limits.h> • La création d’une FIFO correspond à la création d’un fichier et est détaillée dans le fichier source fs/fifo.c • La lecture et l’écriture sont détaillées dans le fichier source fs/pipe.c • Au niveau de l’entrée dans le système de fichier (i-nœud). L’i-nœud (inode) qui est décrit avec plus de détails dans le section sur les systèmes de fichiers LINUX est une structure décrivant les fichiers • Pour un tube, un des champs de la structure i-nœud, i_pipe est mis à 1 pour identifier que le i-nœud correspond à un tube

24. Communication par tubes • Le champ u du i-nœud est constitué de la structure pipe_inode_info décrite dans le fichier <linux/pipe_fs_i.h>

25. IPC (Inter Process Communication) • Les IPC permettent d’échanger, de partager des données mais également de synchroniser des processus entre eux • Les IPC sont constitués de trois mécanismes: • Files de messages: Similaire à une boîte aux lettres. Une application peut déposer (si elle a les permissions nécessaires) un message (un nombre, une chaîne de caractères, ou le contenu d’une structure), d’autres applications peuvent lire ce message • Mémoire partagée: Permet de mettre en commun une zone de mémoire entre plusieurs applications. Normalement, lorsqu’une zone de mémoire est allouée (ex: malloc()), elle est locale au processus donc aucun autre processus ne peut y accéder. Plusieurs processus peuvent par contre, accéder autant en lecture qu’en écriture à une zone de mémoire partagée

26. IPC (Inter Process Communication) • Les IPC sont constitués de trois mécanismes: • Sémaphores: Permet la synchronisation des processus. Permet alors à plusieurs processus qui fonctionnent en même temps d’accéder aux mêmes données • A la différence des autres modes de communication (pipes) les IPC n’utilisent pas le système de fichiers. Un IPC n’est donc pas utilisé comme un fichier donc les appels open(), read() et write() deviennent inutilisables dans ce contexte. • La seule manière de manipuler un IPC est de connaître sa clef d’identification. • Cette clef d’identification permet d’avoir accès à la zone de mémoire où sont stockées les IPC.

27. IPC (Inter Process Communication) • La gestion des clefs • Pour créer ou accéder à un IPC il faut posséder un identificateur (clef) • Cette clef est un nombre qui identifie l’IPC de façon unique au niveau du système • Génération d’une clef: #include <sys/types.h> #include <sys/ipc.h> key_t ftok(char *pathname, char proj); pathname: Un nom de fichier quelconque proj: Facteur permettant de générer plusieurs clefs différentes pour un même fichier • ftok() retourne un identificateur unique de l’IPC qui doit être utilisé pour gérer l’IPC

28. IPC (Inter Process Communication) • La gestion des clefs • ftok() retourne un identificateur unique de l’IPC qui doit être utilisé pour gérer l’IPC • Clef est calculée par: clef = (st_ino & 0xFFFF) | ((st_dev & 0xFF) << 16) | (proj << 24) • La clef découle d’une combinaison entre le numéro de l’i-nœud du fichier, le numéro du périphérique sur lequel se trouve le fichier et le paramètre proj, ce qui permet de générer une clef unique (voir exemple CreerClef.c p 383 Card)

29. IPC (Inter Process Communication) • La gestion des clefs • Chaque IPC possède une structure ipc_perm qui contient des informations relatives aux permissions

30. IPC (Inter Process Communication) • Les appels système par catégorie: • Création: msget() , semget() , shmget() • Contrôle: msgctl() , semctl() , shmctl() • Communication: msgsnd() , msgrcv() , semop() , shmop() • Constantes importantes: • IPC_PRIVATE: Nouvelle file de messages créée strictement pour un processus et ses descendants • IPC_CREAT: Création d’un IPC si la clef n’est pas déjà utilisée • IPC_EXCL: Création d’un objet si il n’existe pas • IPC_NOWAIT: Pas d’attente (msgsnd() , msgrcv())

31. IPC (Inter Process Communication) • Les files de messages • Un processus dépose un ou plusieurs messages dans une boîte aux lettres. Un ou plusieurs autres processus peut alors lire les messages selon leur ordre d’arrivée, selon le type de messages désiré • La structure msqid_ds (définit dans <sys/msg.h>) correspond à un objet de la file de messages. Cette structure permet la manipulation des objets créés.

32. IPC (Inter Process Communication) • Les files de messages • La structure msg stocke un message et son type:

33. IPC (Inter Process Communication) • Les files de messages • Représentation interne des files de messages

34. IPC (Inter Process Communication) • Création et recherche des files de messages • L’appel système msgget() permet: • La création d’une nouvelle file de messages • La recherche d’une file de messages existante (pouvant avoir été créée par une autre application) grâce à sa clef #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgget(key_t clef, int option); clef: clef ( découlant de ftok()) de la file de messages qui existe déjà ou celle que nous voulons créer • Si la valeur IPC_PRIVATE est passée comme valeur de clef, une file est alors créée

35. IPC (Inter Process Communication) • Si la valeur de clef est différente, deux possibilités peuvent survenir: • Si la clef n’est pas déjà utilisée par une autre file de messages, il faut que le champ option soit affecté à IPC_CREAT. La file sera alors créée avec la clef passée en argument. Certains droits d’accès peuvent aussi être fixés par les options • La clef est utilisée par une autre file de messages, il faut alors que IPC_CREAT ou IPC_EXCL aient été passés en paramètre. Par la suite, la file de messages peut être accédée en lecture ou en écriture si les permissions le permettent

36. IPC (Inter Process Communication) • Écriture de messages • L’appel msgsnd() permet de déposer un message dans une file de messages #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgsnd(int msqid, struct msgbuf *msgp, int msgtaille, int msgopt); msgqid: Identificateur de file de messages découlant de msgget() msgp: Pointeur sur les données constituant le message à déposer dans le file de messages msgtaille: Taille de l’objet déposé dans la file de messages msgopt: Si l’option est IPC_NOWAIT alors msgsnd() sera non bloquant

37. IPC (Inter Process Communication) • Lecture de messages • L’appel msgrcv() permet de lire un message dans une file de messages #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgrcv(int msqid, struct msgbuf *msgp, int msgsz, long msgtyp, int msgflg); msgqid: Identificateur de file de message découlant de msgget() msgp: Pointeur sur les données du message récupéré de la file de messages msgsz: Taille de l’objet retiré de la file de messages msgtyp: Type du message à lire msgflg: Options sur la lecture du message

38. IPC (Inter Process Communication) • Lecture de messages • Types de messages • Si msgtyp == 0, lecture en mode FIFO (plus vieux message en premier) • Si msgtyp est négatif, le premier message de la file avec un type <= |msgtyp| est extrait • Si msgtyp est positif, le premier message de la file avec un type == msgtyp est extrait • Options • IPC_NOWAIT: cette option permet d’éviter l’attente active. Si une file est vide lors d’une lecture l’erreur ENOMSG est retournée. Si cette option n’est pas activée, l’appel est suspendu jusqu’à ce qu’un message du type recherché arrive dans la file de messages

39. IPC (Inter Process Communication) • Utilisation des files de messages dans un contexte d’échange de fichiers (Voir CopieServeur.c et CopieClient.c, p. 391 Card)

40. IPC (Inter Process Communication) • Utilisation des files de messages dans un contexte d’échange de caractères (Programme de réception)

41. IPC (Inter Process Communication) • Utilisation des files de messages dans un contexte d’échange de caractères (Programme de réception)

42. IPC (Inter Process Communication) • Utilisation des files de messages dans un contexte d’échange de caractères (Programme de transmission)

43. IPC (Inter Process Communication) • Utilisation des files de messages dans un contexte d’échange de caractères (Programme de transmission)

44. IPC (Inter Process Communication) • Utilisation des files de messages dans un contexte d’échange de caractères (Programmes de transmission et réception) • Exécution: >./msg2 Enter some text: Bonjour les amis Enter some text: du cours SIF-1015 ! Enter some text: Comment allez-vous ce soir ? Enter some text: end >./msg1 You wrote: Bonjour les amis You wrote: du cours SIF-1015 ! You wrote: Comment allez-vous ce soir ? You wrote: end

45. IPC (Inter Process Communication) • Mémoires partagées • Dans un programme standard, une zone de mémoire allouée est propre au processus qui l’utilise. Aucun autre processus ne peut y accéder. Le principe de la mémoire partagée est de permettre à des processus de partager une partie de leur espace d’adressage • Par contre, l’utilisation de zones de mémoire partagées requiert la mise en place de mécanismes de synchronisation d’accès • La solution pour résoudre ce problème est d’utiliser les sémaphores

46. IPC (Inter Process Communication) • Mémoires partagées

47. IPC (Inter Process Communication) • Mémoires partagées • La structure shmid_ds (définit dans <sys/shm.h>) correspond à un objet de la table de mémoire partagées

48. IPC (Inter Process Communication) • Mémoires partagées • Représentation interne des mémoires partagées

49. IPC (Inter Process Communication) • Création et recherche d’une zone de mémoire partagée • L’appel système shmget() permet: • La création d’une nouvelle zone de mémoire partagée • La recherche d’une zone mémoire partagée existante (pouvant avoir été créée par une autre application) grâce à sa clef #include <sys/ipc.h> #include <sys/shm.h> int shmget(key_t clef, int taille, int option); taille: Représente la taille du segment de mémoire partagée désiré • shmget() retourne un indice dans le vecteur shm_segs

50. IPC (Inter Process Communication) • Attachement d’une zone de mémoire partagée • L’appel shmat() permet de rattacher une mémoire partagée à un processus. Consiste en fait à attacher un zone mémoire à l’espace d’adressage virtuel du processus appelant #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> int *shmat(int msqid, const void *shmaddr, int option); shmaddr: Permet de spécifier l’adresse de la mémoire partagée. Si ce champ est null (0), le noyau tente de chercher une zone de mémoire libre (à préconiser) • shmat() retourne un pointeur sur la mémoire partagée • A chaque appel shmat(), les paramètres shm_atime, shm_lpid, shm_nattach de la structure shmid_ds sont mis à jour