chapitre 08. IPCs système V

Transcription

UNSA
UFR Sciences
Université de Nice Sophia-Antipolis
Département Informatique
Licence d’informatique et Maîtrise EEA – Module L3I6
Cours Système
et
Réseaux
Roger Rousseau
CNRS-UNSA/I3S
Version 4.1
Janvier 2006
08. COMMUNICATIONS INTERPROCESSUS
Chapitre 08
6.1 Introduction
IPCs Système V
(Inter Processus Communication)
Communications Interprocessus :
IPC
1) Introduction des IPCs Système V : ftok
Introduits dans la version Système V de Unix (années 80) :
✱ file de messages : msg
✱
segments de mémoire partagée : shm
✱
jeux de sémaphores : sem
Mécanismes semi-persistants :
2) Files de messages : msgget, msgsnd, msgrcv,
msgctl,
3) Segments de mémoire partagée : shmget, shmat,
shmdt, shmctl
✱
intégrés dans le noyau,
✱
durent au plus jusqu’au prochain arrêt du système :
=> occupent de la place dans le noyau,
si on oublie de les détruire après usage
4) Jeu de sémaphores : semget, semop, semctl
393
6.1 Introduction
394
Critique des IPC système V
Critique des IPC système V
6.1 Introduction
suite(1)
En fait, on peut s’en passer et n’utiliser que des mécanismes
typiquement Unix, en implémentant :
Ils ne sont pas bien intégrés aux concepts Unix :
✱
pas de fd, donc pas de possibilité d’utiliser les primitives
usuelles : open, read, write, fcntl, select, poll...
✱
file de messages : avec des tubes volatiles ou persistants,
✱
pas de position dans la hiérarchie des fichiers
(au sens large),
donc système d’identification très spécifique.
✱
segments de mémoire partagée : avec des associations (mapping) portant sur des fichiers partagés ( cf. mmap,
p. ?? )
✱
sémaphores : avec des tubes ou des verrous
395
6.1 Introduction
396
Sommaire des primitives
Manipulations spécifiques
Manipulations communes
6.1 Introduction
suite(1)
✱
msgsnd, msgrcv : envoi, réception d’un message
✱
msgget, shmget, semget : ouverture d’un IPC
✱
✱
msgctl, shmctl, semctl : contrôle de l’IPC
(≈ fstat, unlink , chmod...)
shmat, shmdt : attachement,
détachement d’un segment de mémoire
✱
semop : initialisation, réservation, libération de ressources
✱
ftok (3) : construction d’une clé d’identification
397
398
Commandes d’administration
Commande d’administration : ipcs (1)
suite(2)
ipcs { -q | -m | -s } -i id
✱
ips(1) : listage des IPC de l’utilisateur,
✱
iprm(1) : destruction des IPC de l’utilisateur.
listage de tous les attributs de l’IPC d’identifiant id,
dont le type est indiqué par l’argument obligatoire :
-q
queue,
-m
mémoire partagée,
-s
jeu de sémaphores.
399
6.1 Introduction
Commande d’administration : ipcs
400
6.1 Introduction
Commande d’admnistration : ipcrm (1)
suite(1)
ipcs [ -aqms ] [ -tclup ]
listage de certains attributs de tous les IPC du type indiqué
(par défauts, ou pour l’option -a : tous les types)
-u : attributs résumés,
ipcrm { shm | msg | sem } id ...
-p : PID du processus propriétaire (encore en vie) et du dernier acteur (pas forcément en vie),
-c : protections : permissions, uid, gid du créateur et du propriétaire,
demande de destruction des IPC du type et identifiants indiqués : la destruction sera effective lorsque l’IPC n’est plus
utilisé.
-t : dates (création, dernière opération...),
-l : limites (tailles, nombres maximum...).
401
6.1 Introduction
402
Identifiant externe et interne d’un IPC
6.1 Introduction
IPC privé ou public
✱
privés :
• utilisables seulement par des processus apparentés,
identifiant interne : un entier positif, l’équivalent d’un fd de
fichier, utilisé par toutes les primitives de manipulation.
identifiant externe, la clé : un entier positif, l’équivalent du
nom de chemin d’un fichier.
• accès à l’identifiant interne par héritage, lors des appels à fork .
✱
publics :
• utilisables par des processus non apparentés, donc
IPC semi-persistants (détruits à chaque boot),
L’identifiant interne est rendu par le système à partir de la clé,
lors de l’ouverture de l’IPC par une primitive de type XXXget
(XXX= MSG, SHM, SEM).
• souvent propres à un groupe de processus complices,
organisés en projet.
403
404
6.1 Introduction
ftok (3)
Clé d’identification d’un IPC
Les IPC privés s’obtiennnent avec une clé spéciale :
IPC_PRIVATE.
Les IPC publics doivent être créés avec une clé spécifique,
connue des différents processus utilisateurs :
✱
placée dans un fichier commun,
✱
compilée, placée dans un fichier d’en-tête commun,
✱
construite par la fonction ftok (3).
6.1 Introduction
405
✱
Syntaxe :
#inlude <sys/ip.h>
key_t ftok ( har* nom_hemin, har projet )
✱
Retour :
• clé, si OK,
• -1, si erreur
✱
Arguments :
• nom_chemin : pour ancrer l’IPC dans la hiérarchie
de fichiers et bénéficier de son mécanisme de protection,
• projet : pour distinguer différents groupes de processus.
406
strut ip_perm
Contrôle d’accès à un IPC :
suite(1)
struct ipc_perm
✱
Syntaxe :
#inlude <sys/ip.h>
strut ip_perm {
ushort uid ; /* UID du réateur */
ushort gid; /* GID du réateur */
ushort uid; /* UID du propriétaire */
ushort gid; /* GID du propriétaire */
ushort mode; /* Permissions r/w */
key_t key; /* Clé d'identifiation externe */
}
✱
Sémantique :
• On distingue l’identité du créateur et du propriétaire
(car il n’y a pas de commande chown),
• Les permissions sont indiquées par 9 bits, et correspondent (comme pour les fichiers) aux permissions
r, w, x du propriétaire, de son groupe ou des autres.
• mais la permission x n’est pas utilisée !
407
6.1 Introduction
408
Valeurs limites des IPCs
✱
Elles sont affichables par la commande : ips -l.
Les valeurs indiquées sont des exemples pour Linux 2.4.3.
✱
6.1 Introduction
suite(1)
segments de mémoire partagée : (définies dans sys/shm.h)
• SHMMAX : taille maximum totale des segments : 8 Go
• SHMMNI : nb maximum total de segments : 4096
file de messages : (définies dans sys/msg.h)
• SHMSEG : nb maximum de segments partagés par processus : 4096
• MSGMNI : nb maximum de files dans le système : 16
• MSGMAX : taille maximum d’un messages : 8192 octets
• SHMALL : taille maximum d’un segment : 32 Mo
• MSGMNB : taille maximum par défaut d’une file : 16384
octets
• SHMMIN : taille minimum d’un segment : 1 o
409
✱
6.1 Introduction
410
6.2 File de messages
Files (ou queues) de messages
suite(2)
Consommateurs
jeux de sémaphores : (définies dans sys/sem.h)
• SEMMNI : nb maximum de jeux de sémaphores : 128
File
• SEMMSL : nb maximum de sémaphores par jeu : 250
t0 l1
• SEMMNS nb maximum total de sémaphores par système
: 32 000
message 1
t1 l2 mess 2
message 3
t0 l3
• SEMOPM nb maximum d’actions par primitive semop :
32
t2 l4
message 4
• SEMVMX valeur max des compteurs de sémaphores :
32 767
Producteurs
411
412
Production de messages
✱
Consommation de messages
taille des message bornée, toujours < taille des files
✱
écriture atomique,
✱
suspension des producteurs, s’il n’y a pas assez de place
dans la file.
413
✱
lecture atomique,
✱
possibilité de choisir un message disponible ou attendu,
selon un critère de préférence (priorité).
✱
suspension des consommateurs, s’il n’y a pas de message adéquate,
414
Création / ouverture d’une file : msgget (2)
✱
✱
✱
Syntaxe :
#inlude <sys/ip.h>
int msgget ( key_t key, int msgflag )
Création d’une file avec msgget
✱
Retour :
• identifiant interne si OK,
• -1, si erreur
Sémantique (suite) :
• Si key = IPC_PRIVATE, crée une file privée, sans tenir
compte de msgflag.
• Sinon, il faut IPC_CREAT présent :
⊲ Si IPC_EXCL est présent : création d’une file si
key n’existe pas, sinon erreur,
Sémantique :
• crée ou ouvre une file de messages, selon msgflag
qui combine (opérateur |) les constantes IPC_CREAT
et IPC_EXCL (comme O_CREAT et O_EXCL pour open)
et les permissions définies par les 9 bits de poids
faible.
415
suite(1)
⊲ Si IPC_EXCL est absent : création d’une file,
même si key existe.
• la file crée est vide.
416
Attributs de file de messages :
Création d’une file avec msgget
suite(1)
struct msqid_ds
✱
✱
Syntaxe :
#inlude <sys/msg.h> /* dépend en partie du système */
strut msqid_ds { /* si ! pas msgid_ds ??? */
strut ip_perm msg_perm;/* permissions d'usage */
ushort msg_qnum; /* nb de messages dans la file */
ushort msg_bytes; /* nb de bytes dans file */
ushort msg_qbytes; /* nb max de bytes ds la file */
pid_t msg_lspid; /* pid du dernier msgsnd */
pid_t msg_lrpid; /* pid du dernier msgrv */
time_t msg_stime; /* instant du dernier msgsnd */
time_t msg_rtime; /* instant du dernier msgrv */
time_t msg_time; /* dernier hangement (msgntl) */
};
• Initialisation des attributs de la file créée :
⊲
msg_perm.uid et msg_perm.uid : EUID du processus appelant,
⊲
msg_perm.gid et msg_perm.gid : EGID du processus appelant,
⊲
msg_perm.mode : les 9 bits de poids faible de msgflag,
⊲
msg_qnum, msg_bytes, msg_lspid, msg_lrpid, msg_stime,
msg_rtime : 0.
⊲
msg_time : l’heure actuelle,
⊲
msg_qbytes : limite système MSGMNB.
417
Ouverture d’une file avec msgget
✱
418
Structure d’un message : struct msgbuf
suite(2)
✱
Syntaxe :
#inlude <sys/msg.h>
strut msgbuf {
long int mtype; /* type du message */
har mtext[ ℄; /* ontenu du message */
};
✱
Sémantique :
• mtype : entier positif choisi par le producteur
(cf. msgsnd), comme critère éventuel de choix par
les consommateurs (cf. msgrcv ),
• Si key existe et IPC_CREAT est absent : ouvre la file.
• On vérifie les droits d’accès du processus et si une
demande de destruction est en cours,
• Il n’y a pas d’indication d’usage, pour exprimer si le
processus veut être producteur ou consommateur
de messages.
• mtext : contenu du message
(sa taille est implicitement connue des processus).
419
420
Envoi d’un message : msgsnd (2)
✱
✱
✱
msgsnd
Syntaxe :
#inlude <sys/msg.h>
int msgsnd (int msgid, strut msgbuf* msgp,
int msgsz, int msgflg )
✱
Retour :
• 0, si OK,
• -1, si erreur ou échec (errno)
Sémantique :
• Envoie sur la file msgid le message msgp de taille
msgsz, selon l’option msgflg : IPC_NOWAIT ou 0.
421
suite(1)
• Le processus doit avoir la permission d’écriture sur
la file,
• Si la taille indiquée du message est inférieure à la
taille maximum d’un message (msg_qbytes), le message est déposé dans celle-ci, avec mise à jour des
attributs msg_lspid, msg_qnum, msg_stime.
422
msgsnd
✱
Réception d’un message : msgrcv (2)
suite(2)
✱
Syntaxe :
#inlude <sys/msg.h>
int msgrv (int msgid, strut msgbuf* msgp,
int msgsz, long msgtyp, int msgflg )
✱
Retour :
• taille du message lu si OK,
✱
Sémantique :
• lit sur la file msgid un message de type msgtyp dans le tableau msgp->mtext de taille msgsz,
selon l’option msgflg : IPC_NOWAIT, IPC_NORROR,
IPC_EXCEPT ou 0.
• Sinon :
⊲ si IPC_NOWAIT, échec et errno = EAGAIN
⊲ sinon
le
processus
est
jusqu’à :
◦ qu’il y ait assez de place => OK
suspendu
◦
file détruite => échec + errno = EIDRM
◦
réception d’un signal => échec + errno =
EINTR
423
msgrcv
✱
424
msgrcv
suite(1)
• msgtyp sert à la sélection du message :
⊲ msgtyp = 0 :
1er message, côté lecture,
✱
⊲ msgtyp > 0 :
◦ pas d’option IPC_EXCEPT :
1er message du type msgtyp
◦
suite(2)
• Si aucun message dans la file ne satisfait le critère
msgtyp :
⊲ IPC_NOWAIT : échec + errno = ENOMSG
⊲ sinon, attente jusqu’à :
◦ message d’un type désiré arrive,
option IPC_EXCEPT (SAUF) :
1er message d’un type 6= msgtyp
⊲ msgtyp < 0 :
1er message d’un type t tel que t ≤ | msgtyp |
◦
file supprimée => échec + errno = EIDRM
◦
le processus reçoit un signal => échec +
errno = EINTR
425
msgrcv
✱
426
Contrôle d’un message : msgctl (2)
suite(3)
• Le processus doit avoir la permission de lecture sur
la file,
✱
• Si msgsz est supérieur à la taille du message, le
message est placé dans msgp->mtext, avec mise
à jour de msg_lrpid, msg_qnum, msg_rtime, msgp>mtype.
Syntaxe :
#inlude <sys/msg.h>
int msgtl ( int msgid, int md,
strut msqid_ds* buf )
✱
Retour :
• 0, si OK,
• -1, si erreur (errno)
• Sinon :
⊲ si MSG_NOERROR, troncature
✱
Sémantique :
• selon cmd : consulte ou modifie les attributs ou demande la destruction de la file msgid.
⊲ sinon échec (errno == E2BIG) et le message restera dans la file.
427
msgctl
✱
428
msgctl
suite(1)
• cmd = IPC_STAT : copie les attributs de la file dans
la structure pointée par buf.
• cmd = IPC_SET : copie certains des champs de la
structure pointée par buf dans les attributs de la file :
msg_perm.uid, msg_perm.gid, msg_perm.mode (9
bits de poids faible), msg_qbytes.
429
✱
suite(2)
• cmd = IPC_RMID : supprimer immédiatement la file,
en réveillant les processus producteurs ou consommateurs en attente.
• L’EUID du processus doit être SU ou le créateur ou
le propriétaire. Seul SU peut augmenter msg_qbytes
> MSGMNB.
430
Introduction aux segments shm
Segments de mémoire partagée : shm
Noyau du système
✱
Taille demandée : de 1 octet à quelques 10 ko
✱
Taille effective : arrondie supérieurement à un nombre
entier de pages.
✱
Attachement:
attachement des segments
• les segments sont placés dans les mémoires virtuelles
des processus
• à une adresse choisie par le programmeur ou le système,
• adresse arrondie inférieurement à une frontière de
page.
Mémoires virtuelles des processus
431
6.3 Mémoire partagée
✱
432
suite(1)
✱
Utilisation parallèle :
=> nécessite une exclusion mutuelle :
suite(2)
Effet des autres primitives système :
• entre les écritures et écritures,
• après fork : le processus fils hérite des segments de
mémoire partagée de son père,
• entre écritures et lectures.
• après exec, exit : tous les segments sont détachés.
433
✱
434
Création / ouverture d’un shm : shmget (2)
suite(3)
Double protection d’usage :
✱
Syntaxe :
#inlude <sys/ip.h>
int shmget (key_t key, int size, int shmflag )
✱
Retour :
• -1, si erreur
✱
Sémantique :
• crée ou ouvre un segment de mémoire partagée de
taille size, selon shmflag qui combine (opérateur |)
les constantes IPC_CREAT et IPC_EXCL et les permissions définies par les 9 bits de poids faible.
• un processus doit déclarer son intention de lire ou
écrire au moment de l’attachement,
• de plus, il doit avoir les permissions pour les usages
déclarés.
435
shmget
✱
au
multiple
Création d’un shm avec shmget
suite(1)
• key est la clé externe d’identification,
• size est arrondie
PAGE_SIZE,
436
✱
supérieur
de
• PAGE_SIZE est donnée par getpagesize()
(4096 sous Linux).
• les conditions de création, d’ouverture d’un segment
ou d’erreur dépendent, comme msgget des valeurs
de key , de l’existence du segment et de shmflag.
437
suite(2)
• Si key = IPC_PRIVATE, crée un segment privé, sans
tenir compte de shmflag.
• Sinon, il faut que IPC_CREAT soit présent dans shmflag :
⊲ Si IPC_EXCL est présent : création d’un segment
partageablesi key n’existe pas, sinon erreur,
⊲ Si IPC_EXCL est absent : création d’un segment
partageable, même si key existe.
438
Attributs d’un shm : struct shmid_ds
✱
Création d’un shm avec shmget
✱
Syntaxe :
#inlude <sys/shm.h> /* dépend en partie du système */
strut shmid_ds {
strut ip_perm shm_perm;/* permissions d'usage */
int shm_segsz; /* taille segment en otets */
short shm_natth; /* nb d'attahements */
pid_t shm_pid; /* pid du réateur */
pid_t shm_dpid; /* pid du dernier opérateur */
time_t shm_atime; /* instant du dernier shmat */
time_t shm_dtime; /* instant du dernier shmdt */
time_t shm_time; /* dernier hangement (shmntl) */
};
• Initialisation
des
créé :
attributs
du
suite(1)
segment
⊲
shm_perm.uid et shm_perm.uid avec le EUID du processus appelant,
⊲
shm_perm.gid et shm_perm.gid avec le EGID du processus appelant,
⊲
shm_perm.mode avec les 9 bits de poids faible de shmflag,
⊲
shm_segsize prend la valeur size,
⊲
shm_lpid, shm_natth, shm_atime, shm_dtime à 0.
⊲
shm_time à l’heure actuelle,
439
Ouverture d’un shm avec shmget
✱
440
Attachement d’un segment : shmat (2)
suite(2)
• Si key existe et IPC_CREAT est absent : ouvre le segment.
✱
Syntaxe :
#inlude <sys/shm.h>
int shmat ( int shmid, har* shmaddr, int shmflg )
✱
Retour :
• adresse d’attachement si OK,
✱
Sémantique :
• attache le segment de mémoire partagée shmid à
une adresse déterminée selon shmaddr et shmflg.
processus veut lire ou écrire dans le segment.
441
shmat
✱
442
shmat
suite(1)
• si shmaddr = 0, le système essaie de trouver une
zone libre dans l’intervalle [1 Go .. 1.5 Go], en commençant par les adresses hautes et en descendant
jusqu’à trouver cet emplacement.
✱
suite(2)
• SHM_RDONLY ∈ shmflg, le segment est attaché en lecture seule et le processus doit avoir le droit de lecture,
• sinon le segment est ataché en lecture-écriture et le
processus doit avoir la permission.
• si shmaddr > 0 et SHM_RND ∈ shmflg, attachement à
l’adresse shmaddr arrondie au multiple inférieur de
SHMLBA.
• brk du processus n’est pas modifié.
• si shmaddr > 0 et SHM_RND 6∈ shmflg, attachement
à l’adresse shmaddr qui doit être un multiple de
PAGE_SIZE.
• si l’attachement réussit, les attributs suivants sont
mis à jour : shm_atime, shm_lpid, shm_natth
443
444
Contrôle d’un segment : shmctl (2)
Détachement d’un segment : shmdt (2)
✱
✱
✱
Syntaxe :
#inlude <sys/shm.h>
int shmdt ( har* shmaddr )
Retour :
• 0, si OK,
Sémantique :
• le segment attaché à l’adresse shmaddr est détaché, s’il existe,
• les attributs suivants sont alors mis à jour :
shm_dtime, shm_lpid, shm_natth.
• sinon, erreur avec errno == EINVAL
445
✱
Syntaxe :
#inlude <sys/shm.h>
int shmtl (int shmid, int md, strut shmid_ds* buf )
✱
Retour :
• 0, si OK,
✱
Sémantique :
• selon cmd : consulte, modifie les attributs ou demande la destruction du segment shmid.
446
shmctl
✱
shmctl
suite(1)
• cmd = IPC_STAT : copie les attributs du segment
dans buf (strut shmid_ds).
Le processus doit avoir le droit de lecture du segment.
✱
suite(2)
• cmd = IPC_RMID : demande de destruction du segment après le dernier détachement.
• Le processus doit être SU , le créateur ou le propriétaire.
• cmd = IPC_SET : copie certains champs de la
structure buf dans les attributs du segment :
shm_perm.uid, shm_perm.gid, shm_perm.mode.
Le processus doit être SU , le créateur ou le propriétaire.
• Attention ! le contenu d’un segment détruit n’est
pas effacé, il peut être lu lors d’une création d’un
nouveau segment.
447
6.4 Jeu de sémaphores
448
Rappels sur les sémaphores
Jeux de sémaphores (Unix)
✱
Les sémaphores sont des mécanismes de contrôle de
l’accès à des ressources, introduits par Dijkstra en 1968
pour le système the.
✱
Les sémaphores de Dijkstra sont des compteurs indépendants, avec file d’attente et deux primitives de manipulation P(argsem) pour acquérir et V(sem) pour libérer des
ressources quantifiables, utilisables par plusieurs processus en compétition : nb de pages mémoire, d’appareils...
✱
Contrairement à d’autres mécanismes (moniteurs...),
l’utilisation des sémaphores est facultative : les processus doivent être disciplinés.
✱
Ils permettent d’acquérir ou de libérer, de manière atomique, des quantités de ressoures de plusieurs espèces.
✱
Les manipulations ne portent pas sur un seul sémaphore,
mais sur une sélection de sémaphores choisis dans un
jeu de sémaphores : un ensemble, représenté par un tableau de structures.
✱
D’autres mécanismes complètent les primitives de Dijkstra : attente facultative, attente de fin, undo...
✱
Les jeux de sémaphores sont riches en possibilités,
mais complexes à utiliser...
449
Jeux de sémaphores
+1
−2
0
+2
1
2
3
sem_val
sem_val
sem_val
sem_val
sem_pid
sem_pid
sem_pid
sem_pid
✱
Sur option, on peut libérer automatiquement les ressources
acquises par un processus, lors de sa terminaison.
✱
Cela nécessite de comptabiliser les ressources acquises
pour chaque sémaphore manipulé par le processus :
−7
n−1
...
Gestion des options undo sur sémaphores
Pq
+3
450
suite(1)
...
P1
sem_val
• chaque descripteur de processus gère une liste chaînée de compteurs undo (placés dans une strut sem_undo),
qui comptabilisent les ressources acquises,
sem_pid
Jeu de sémaphores
sem_perm
sem_otime
sem_nsems
sem_undo
• ces compteurs doivent être mis à jour à chaque acquisition ou libération de ressources.
10:42:37.833
n
...
Attributs
• les strut sem_undo d’un processus sont détruites lors
de sa terminaison.
452
3
451
Critique des options undo sur sémaphores
✱
Ce mécanisme est criticable :
Création / ouverture d’un jeu : semget (2)
✱
Syntaxe :
#inlude <sys/sem.h>
int semget ( key_t key, int nsems, int semflag )
✱
Retour :
• -1, si erreur
✱
Sémantique :
• crée ou ouvre un jeu de nsems sémaphores, selon
semflag qui combine (opérateur |) les constantes
IPC_CREAT et IPC_EXCL (comme O_CREAT et O_EXCL
pour open) et les permissions définies par les 9 bits
de poids faible.
• le terme undo est inapproprié,
• sémantique non usuelle pour les sémaphores
• gestion non automatique : les processus doivent être
disciplinés à fournir les options strut sem_undo,
• sémantique pas claire pour l’attente...
✱
Pour les opération avec l’option undo, Linux choisit :
• d’effectuer celles qui réussissent immédiatement,
• d’ignorer silencieusement les autres.
453
454
Création d’un jeu avec semget
✱
Attributs d’un jeu de sémaphores :
suite(1)
• Si key = IPC_PRIVATE, crée un jeu privé, sans tenir
compte de semflag.
struct semid_ds
✱
• Sinon, il faut IPC_CREAT présent :
⊲ Si IPC_EXCL est présent : création d’un jeu si
key n’existe pas, sinon erreur,
⊲ Si IPC_EXCL est absent : création d’un jeu,
même si key existe.
• Attention ! les sémaphores du jeu ne sont pas initialisés ! Utiliser semctl avec SETVAL ou SETALL pour
l’initialisation.
Syntaxe :
#inlude <sys/sem.h> /* dépend en partie du système */
strut semid_ds {
strut ip_perm sem_perm;/* permissions d'usage */
time_t sem_otime; /* instant du dernier semop */
time_t sem_time; /* dernier semntl / semget ) */
ushort sem_nsems; /* nb de sémaphores dans le jeu */
strut sem sem_base[ ℄; /* jeu de sémaphores */
strut sem_queue* sem_pending; /* opérations en suspens */
strut sem_queue** sem_pending_last; /* dern. op. en suspens */
strut sem_undo* undo; /* nb de ompteurs undo sur e jeu */
};
455
456
Ouverture d’un jeu avec semget
Création d’un jeu de sémaphores avec
semget suite(1)
✱
✱
• Initialisation des attributs du jeu créé :
⊲
sem_perm.uid et sem_perm.uid : EUID du processus appelant,
⊲
sem_perm.gid et sem_perm.gid : EGID du processus appelant,
⊲
sem_perm.mode : les 9 bits de poids faible de semflag,
⊲
sem_nsems : nsems,
⊲
sem_time : l’heure actuelle,
⊲
sem_otime : 0
suite(2)
• Si key existe et IPC_CREAT est absent : ouvre le jeu
de sémaphores.
processus veut acquérir ou libérer des ressources
sur les sémaphores.
457
458
Structure d’un sémaphore : struct sem
Manipulations de sémaphores :
semop (2), struct sembuf
✱
✱
Syntaxe :
#inlude <sys/sem.h>
int semop ( int semid,
strut sembufsops [ ℄, unsigned nsops )
strut sembuf {
short sem_num; /* n◦du sémaphore (0=premier) */
short sem_op; /* opération sur le sémaphore */
short sem_flg; /* option pour l'opération */
}
✱
Retour :
• 0, si OK,
Syntaxe :
#inlude <sys/sem.h>
strut sem {
int semval; /* valeur ourante du sémaphore */
pid_t sempid; /* pid de la dernière opération */
}
459
semop
460
semop
suite(1)
✱
nsops
sem_num
sem_num
sem_num
sem_op
sem_op
sem_op
sem_flag
sem_flag
sem_flag
sem_num
...
sem_op
sem_flag
suite(2)
Sémantique :
• opérations individuelles sur les nsops sémaphores
de semid dans la liste sops (tableau).
• Chaque entrée de type strut sembuf indique le
n◦du sémaphore, l’opération à effectuer et une option éventuelle (IPC_NOWAIT ou SEM_UNDO).
• Chaque opération n’est effective que si toutes réussissent.
• L’option SEM_UNDO précise que l’opération doit être
annulée à la terminaison du processus.
semops
461
462
semop
✱
semop (2) : libération, ajout de resources
suite(3)
Sémantique :
• L’opération sur chaque sémaphore sélectionné dépend de la valeur de sem_op :
⊲ sem_op > 0 : libère, ajoute sem_op ressources au
sémaphore,
✱
⊲ sem_op < 0 : demande d’acquisition, de retrait de
|sem_op| ressources au sémaphore,
• sem_op > 0 : libère, ajoute sem_op ressources au sémaphore : semval += sem_op.
⊲ si l’option SEM_UNDO est demandée, met à jour
le compteur undo du processus pour ce sémaphores.
⊲ l’ajout de ressources n’est jamais blocant.
⊲ sem_op == 0 : attente de fin, d’épuisement de
ressources (qu’il n’y en ait plus, compteur nul).
⊲ il faut le droit d’écriture sur le jeu de sémaphores
pour un ajout.
463
semop (2) : demande de retrait de resources
464
semop (2) : retrait immédiat de resources
✱
✱
• sem_op < 0 : demande d’acquisition, de retrait de
|sem_op| ressources, avec attente éventuelle.
• sem_op < 0 : demande de retrait de |sem_op| ressources
• si semval >= |sem_op|, retrait immédiat possible...
• on retire |sem_op| ressources au sémaphore
semval -= |sem_op|
• le processus doit avoir le droit d’écriture sur le jeu
de sémaphores
• si l’option SEM_UNDO est demandée,
met à jour le compteur undo du processus pour ce
sémaphore.
465
466
semop (2) : attente de resources
semop (2) : retrait différé de ressources
✱
Sémantique (suite) : pas de retrait immédiat
• sem_op < 0 : demande de retrait de |sem_op| ressources, mais
✱
• Si semval < |sem_op|, le retrait demandé n’est pas
encore possible :
⊲ Si l’option IPC_NOWAIT est demandée :
échec et errno = EAGAIN
• L’attente de ressources dure jusqu’à
que:
⊲ semval >= |sem_op| :
semnnt--, semval -= |sem_op|
si l’option SEM_UNDO est demandée,
met à jour le compteur undo du processus.
⊲ la réception d’un signal :
semnnt-- et échec et errno == EINTR
467
semop (2) : attente de fin de ressources
✱
ce
⊲ le jeu soit supprimé => échec + errno == EIDRM
⊲ Si l’option IPC_NOWAIT n’est pas demandée :
semnt-- et attente de ressources...
:
468
semop : attente de fin de ressources
• sem_op == 0 : attente que le compteur semval du
sémaphore soit nul.
⊲ semval == 0 : pas d’attente.
⊲ semval > 0 && IPC_NOWAIT : échec de l’appel
(donc de toutes les opérations sur les autres sémaphores sélectionnés) et errno == EAGAIN (pas
d’attente).
⊲ semval > 0&& non IPC_NOWAIT :
attente du processus et semznt++
✱
suite(1)
• L’attente persiste jusqu’à :
⊲ semval == 0 : semznt-⊲ destruction du jeu de sémaphores : échec de
l’appel errno == EIDRM
⊲ réception d’un signal non masqué : semznt-- et
errno == EINTR
• Le processus doit avoir le droit de lecture sur le jeu.
469
470
semctl
Contrôle d’un jeu de sémaphores :
suite(1)
semctl (2), union semun
✱
Syntaxe :
#inlude <sys/sem.h>
int semtl ( int semid, int semno, int md,
union semnum arg )
semno : n◦du sémaphore utilisé, seulement pour
GETNCNT GETPID GETVAL GETZCNT SETVAL
union semun {
int val ;
/* pour SETVAL */
strut semid_ds* buf ; /* pour IPC_STAT IPC_SET */
ushort array[ ℄ ;
/* pour GETALL SETALL */
}
✱
Sémantique :
• selon cmd effectue de nombreuses opérations sur
l’ensemble de sémaphores ou sur le ...
• cmd peut prendre des valeurs
⊲ communes aux IPC : IPC_STAT, IPC_SET,
IPC_RMID
⊲ spécifiques aux sémaphores : GETALL, GETNCNT,
GETPID, GETVAL, GETZCNT, SETALL, SETVAL
• Critique : sémantique fourre-tout, d’où syntaxe et
valeurs retournées fourre-tout...
471
semctl
472
semctl
suite(2)
✱
✱
Valeurs retournées :
• 0, si OK (IPC_XXX, SETXXX, GETALL)
• la valeur semnnt, si GETNCNT,
suite(3)
• cmd = IPC_STAT : rend les attributs de semid dans
la structure pointée par arg.buf.
• cmd = IPC_SET : copie les champs sem_perm.uid,
sem_perm.gid, sem_perm.mode (9 bits poids fbe), de
la structure arg.buf dans les attributs du jeu.
Mise à jour de sem_time.
• la valeur sempid, si GETPID,
• la valeur semval, si GETVAL,
• la valeur semznt, si GETZCNT,
• cmd = IPC_RMID :
supprime le jeu de sémaphores, en réveillant les
processus en attente (échec + errno == EIDRM).
473
semctl
✱
474
semctl
suite(4)
• cmd = GETPID :
rend sempid, (PID du dernier processus ayant exécuté semop) sur le semno_ième sémaphore du jeu.
✱
• cmd = GETNCNT :
rend semnnt, i.e. le nb de processus en attente sur
le semno_ième sémaphore du jeu.
suite(5)
• cmd = GETVAL :
la valeur du compteur du
rend semval, i.e.
semno_ième sémaphore du jeu.
• cmd = GETALL :
rend dans arg.array les valeurs semval de tous les
compteurs des sémaphores du jeu.
• cmd = GETZCNT :
rend semznt, i.e. le nb de processus en attente de
fin de ressources pour le semno_ième sémaphore
du jeu.
475
semctl
✱
476
semctl (2) : protections
suite(6)
• cmd = SETVAL :
initialise le compteur du semno_ième sémaphore du
jeu avec arg.val.
Réveil des processus en attente de ressources.
• cmd = SETALL :
initialise les compteurs des sémaphores du jeu avec
le tableau de valeurs arg.array.
Réveil des processus en attente de ressources.
477
✱
Les commandes de consultation (IPC_STAT, GETXXX) du
jeu de sémaphores requièrent le droit de lecture du jeu.
✱
Les commandes de modification ( SETXXX ) du jeu de
sémaphores requièrent le droit d’écriture du jeu.
✱
Les commandes
• de changement des permissions (IPC_SET)
• ou de destruction (IPC_RMID)
requièrent que le EUID du processus appelant soit le
créateur ou le propriétaire ou l’admnistrateur.
478
Table des matières

chapitre 08. IPCs système V

Transcription

Documents pareils

Locationde voilier - Oceanis 40

FILIERE INTERNATIONALE - Fénelon Notre-Dame

Déclaration de vol ou de tentative de vol

trame pwp - Sémaphores

Locationde voilier - Bavaria 39 cruiser

Locationde voilier - Gib Sea 43

280€/sem. - comite des oeuvres sociales ptt du tarn

Annuaire 2016-2017.indd

FIche COTE D`IVOIRE