==========================MEMOIR ++++++++++++++++++=============

—« mémoire » tout composant électronique capable de stocker des —Pour créer un nouveau processus il faut appeler l’appel-système fork(),
données. qui va dupliquer le processus appelant.
—La mémoire est un assemblage de cellules repérées par leur numéro, èAu retour de cet appel-système, deux processus identiques continueront
ou adresse. d’exécuter le code à la suite de fork().
—Les caractéristiques d’une mémoire: compactage de la mémoire —La différence essentielle entre ces deux processus est un numéro
—La capacité, représentant le volume global d'informations (en bits) est une opération très d’identification (PID)
que la mémoire peut stocker ; coûteuse =========================CREATION PROC=============================
—Le temps d'accès, correspondant à l'intervalle de temps entre la —L’appel-système fork() est déclaré dans <unistd.h>, ainsi :pid_t fork(void);
demande de lecture/écriture et la disponibilité de la donnée ; Pour connaître son propre identifiant PID, on utilise l’appel-système
pid_t getpid(void),
—Le temps de cycle, représentant l'intervalle de temps minimum entre
deux accès successifs ; —Lors de l'appel de fork, le
—Le débit, définissant le volume d'information échangé par unité de ======Pagination processus courant est
temps, exprimé en bits par seconde ; L'allocation en mémoire centrale d'un seul tenant souffre donc de deux dupliqué.
—La non volatilité caractérisant l'aptitude d'une mémoire à conserver défauts principaux : — Au retour de fork, le
les données lorsqu'elle n'est plus alimentée électriquement. —Elle nécessite une opération de compactage de la mémoire qui est une père et le fils exécutent le
opération très coûteuse même code.
—Il existe essentiellement deux types de mémoire: —Elle exige d'allouer le programme en une zone d'un seul tenant.
—la mémoire centrale:—Mémoire primaire = Mémoire vive = RAM —Une solution est de diviser le programme en portions de taille fixe et
—La mémoire vive peut être lue et modifiée à volonté. égales à l'unité d'allocation de la mémoire centrale.
—Mémoire vive: (RAM) Le nom RAM = "RandomAccess Memory", en ==>On dit alors que le programme est découpé en pages. Le mécanisme
français c'est Accès aléatoire à la Mémoire. C'est-à-dire Lecture-Ecriture d'allocation associé s'appelle la pagination. La primitive fork
sur la RAM. retourne la valeur 0
—La RAM est volatile, c'est-à-dire qu’elle ne peut stocker les —Dans le mécanisme de pagination, l'espace d'adressage du programme est au processus fils, et
informations que lorsque l'ordinateur est allumé découpé en morceaux de même de taille : la page. elle retourne
—Permettant de mémoriser temporairement les données lors de —L'espace de la mémoire physique est lui-même découpé en morceaux de l'identificateur du
l'exécution des programmes. même taille : la case. taille case = taille page processus créé au
processus père
—la mémoire de masse:—la mémoire de masse (appelée également
mémoire physique ou mémoire externe) permettant de stocker des
informations à long terme, y compris lors de l'arrêt de l'ordinateur.
=============Lecture des attributs du processus courant:
—La mémoire de masse correspond:
—getpid : retourne l'identificateur unique du processus courant.
—Aux dispositifs de stockage magnétiques, tels que le disque dur,
—getppid : retourne l'identificateur unique du pére du processus courant.
—Aux dispositifs de stockage optique, correspondant par exemple aux
—getuid: retourne l'identificateur d'utilisateur réel du processus courant.
CD-ROM ou aux DVD-ROM,
—geteuid : retourne l'identificateur d'utilisateur effectif du processus
—Ainsi qu'aux mémoires mortes, tels que la ROM
courant.
—La mémoire physique est constituée d'un ensemble de mots mémoire
—getgid : retourne l'identificateur de groupe réel du processus courant.
contigus désignés chacun par une adresse physique
—getegid : retourne l'identificateur de groupe effectif du processus courant.
==========Traduction de l'adresse paginée vers l'adresse physique
—getgroups : retourne le nombre total de groupes associés au processus
===========MULTOPROGRAMMATION —C'est la MMU (Memory Management Unit) qui est chargée de faire cette
courant.
—Dans un système multiprogrammé, trois problèmes sont à résoudre conversion. Il faut donc savoir pour toute page, dans quelle case de la
==========>CAS ERROR : —En cas d'échec fork retourne la valeur -1 et le code
vis-à-vis de la mémoire centrale : mémoire centrale celle-ci a été placée : cette correspondance s'effectue
d'erreur est stocké dans la variable errno définie dans <errno.h>.
—Il faut définir un espace d'adressage indépendant pour chaque grâce à une structure particulière appelée la table de pages.
— EAGAIN : Le nombre maximal de processus a été atteint pour user ou le
processus —
systm
—Il faut protéger les espaces d'adressage des processus les uns vis-à-vis —Dans une première approche, la table des pages est une table contenant
ENOMEM : Le noyau ne dispose pas d'assez d mémoire pr créer nv processus
des autres autant d'entrées que de pages dans l'espace d'adressage d'un processus.
Il faut allouer de la mémoire physique à chaque espace d'adressage Chaque processus a sa propre table des pages. Chaque entrée de la table est
un couple < n°de page, n°de case physique dans laquelle la page est chargée >
=========>Les méthodes d'allocation mémoire peuvent être divisées en
deux grandes familles : ==========SEGMENTATION
—Pour la première famille, un programme est un ensemble de mots —La pagination constitue un découpage de l'espace d'adressage du
contigus insécables. processus qui ne correspond pas à l'image que le programmeur a de son
—Pour la seconde famille, un programme est un ensemble de mots programme.
contigus sécable, c'est-à-dire que le programme peut être divisé en plus !=
petits morceaux, chaque morceau étant lui-même un ensemble de mots —La segmentation est un découpage de l'espace d'adressage qui cherche à
contigus. Chaque morceau peut alors être alloué de manière conserver cette vue du programmeur. Ainsi, lors de la compilation, le
indépendante. On trouve ici les mécanismes de segmentation et de compilateur associe un segment à chaque morceau du programme compilé.
pagination. Un segment est un ensemble d'emplacements mémoire consécutifs non
sécable. A la différence des pages, les segments d'un même espace
=======Allocation mémoire d'un seul tenant d'adressage peuvent être de taille différente. D'une manière générale, on
—Dans cette méthode d'allocation, le programme est considéré comme trouvera un segment de code, un segment de données et un segment de pile
un espace d'adressage insécable.
—La mémoire physique est découpée en zones disjointes de taille ===Traduction de l'adresse segmentée vers l'adresse physique: ==================>Terminaison du processus:==============
variable, adaptables à la taille des programmes : ces zones sont appelés C'est la MMU (Memory Management Unit) qui est chargée de faire cette —Une autre façon de terminer un programme normalement est d’utiliser la
des partitions . conversion. Il faut donc connaitre pour tout segment, l'adresse fonction exit().
—Initialement, la mémoire centrale est uniquement occupée par les d'implantation dans la mémoire centrale du segment : cette correspondance —Les marcos :
procédures du système d'exploitation. s'effectue grâce à une structure particulière appelée la table des segments ✔ EXIT_SUCCESS
—La zone réservée aux programmes utilisateurs est vide et constitue ✔ EXIT_FAILURE
une unique zone libre.
—Au fur et à mesure des chargements de programmes, la zone libre va
se réduire et à l’instant t, elle n'occupe plus qu'une fraction de la —Les opérations exécutées avant la fin du processus :
mémoire central. ✔ l'exécution éventuelle de fonctions enregistrées grâce aux fonctions
atexit() ou on_exit().
==============Allocation en
✔ La fermeture des flux (fichiers) encore ouverts.
partitions variables:
✔ La suppression de fichiers temporaires créés par tmpfile().
—Lorsque l'exécution des
✔ La fermeture des descripteurs ouverts.
programmes se termine (ici
✔ L'invocation de l'appel-système exit(status) qui terminera le processus.
P2 et P4), la mémoire est
libérée : il se crée alors pour =========================>Attente de la fin d'un fils============
chaque zone libérée, une —La table des segments est une table contenant autant d'entrées que de —wait() permet à un processus de se
nouvelle zone libre. segments dans l'espace d'adressage d'un processus. Chaque entrée de la mettre en attente jusqu’à la
Finalement, la mémoire table est un couple < n°de segment, adresse d'implantation du segment >. terminaison d'un de ses fils
centrale se retrouve et de récupérer les informations
constituée d'un ensemble de =====GESTION AVEC RECOUVREMENT sur l'état de terminaison de celui-ci.
zones allouées et de zones —Dès que le nombre de processus devient supérieur au nombre de
libres réparties dans toute la partitions, il faut pouvoir simuler la présence en MC de tous les processus —Un processus est suspendu jusqu'à la terminaison d'un de ses fils.
mémoire. pour pouvoir satisfaire au principe d'équité et minimiser le temps de —Si ce dernier n'a pas de fils, la fonction ==> -1.
Les zones libres sont organisées en une liste chaînée de zones libres réponse des processus. La technique du recouvrement (swapping) permet de —S'il existe un/des fils à l'état zombie, la fnction =>pid d'un de ces fils.
repérée par une tête de liste. stocker temporairement sur disque des images de processus afin de libérer —Lorsqu'un fils se termine, le père réveille et la fonction =>pid de ce fils.
de la MC pour d'autres processus.
++++++++Stratégie First Fit ======VA et Vient ou Swap waitpid() permet de se mettre en attente de la fin
—Dans ce contexte, charger un se comporte exactement comme la mémoire vive, à la différence près qu'on du fils dont le PID est indiqué par le paramètre pid.
nouveau programme consiste à ne peut y exécuter des processus (pour exécuter un processus sur le swap, il
trouver une zone libre faut le charger en mémoire vive). Le swap contient les processus inactifs.
suffisamment grande pour
pouvoir y placer le programme. ============================PROCESSEUR============================== —Si la valeur pour le paramètre pid est -1, waitpid() se comporte comme
—Une première stratégie pour Un processus est une instance d’un programme en train de s’exécuter wait().
trouver et choisir cette zone —Un processus est connu du système par une structure de données appelée —Si pid est positif, il spécifie le numéro du processus fils à attendre.
libre est de prendre la Descripteur de Processus(DdP). —Si le pid est nul, il spécifie tout les processus fils dont le numéro de groupe
première zone libre —Véritable carte d’identité du processus, cette structure mémorise de processus est égal à celui du processus appelant.
suffisamment grande trouvée notamment : —Si pid est inférieur à -1, il spécifie tout processus fils dont le numéro de
au cours du parcours de la num processus ,priorité, état, contexte (copie des registres du processeur...) groupe de processus est égal à la valeur absolue de pid.
mémoire ,pointeurs sur diverses tables (pagination mémoire par ex.,
—Ici, donc, le programme 7 est placée dans la zone libre de 120K ce qui pointeurs sur le code et les données du processus concerné =========Attente de la fin d'un fils
crée une nouvelle zone libre résiduelle de 40K. —Un processus est créé par d’autres processus (sauf le premier). —Il faut utiliser les macros suivantes pour analyser les circonstances de la
===========BEST FIT— —Un processus peut être suspendu, redémarré, comme il peut recevoir des fin du fils :
Une seconde stratégie pour événements (signaux) ✔ WIFEXITED(status) est vraie si le processus s’est terminé de son propre
trouver et choisir cette zone chef en invoquant exit() ou en revenant de main(). On peut obtenir le code
libre est de prendre la zone etat processur = => de retour du processus fils, c’està- dire la valeur transmise à exit(), en
libre dont la taille est la plus élu, c'est-à-dire en cours d'exécution : appelant WEXITSTATUS(status).
proche de celle du programme ✔ WIFSIGNALED(status) indique que le fils s’est terminé à cause d’un signal.
à allouer, donc celle non élu, c'est-à-dire que ce n'est pas celui qui s'exécute en ce Le numéro du signal ayant tué le processus fils est disponible en utilisant la
engendrant le plus petit trou moment:—Puisqu'un seul processus peut être exécuté à un instant donné, il macro WTERMSIG(status).
résiduel : c'est la stratégie Best faut choisir. ✔ WIFSTOPPED(status) indique que le fils est stoppé temporairement. Le
Fit. — Les processus, bien qu'étant des entités indépendantes, doivent parfois numéro du signal ayant stoppé le processus fils est accessible en utilisant
interagir avec d'autres processus. Les résultats d'un processus peuvent, par WSTOPSIG(status).
—Ici, donc, le programme 7 est placée dans la zone libre de 100K ce qui exemple, être les données d'un autre. La situation suivante peut donc se —Deux constantes déclarées dans <sys/wait.h> peuvent être utilisées pour
crée une nouvelle zone libre résiduelle de 20K produire : le second processus est prêt à s'exécuter mais ne peut le faire initialiser le paramètre options :
faute de données. Il doit alors se bloquer en attendant les données. ✔ WNOHANG : provoque un retour immédiat si aucun processus fils ne s'est
—Zombie: Le processus a terminé son exécution encore terminé.
mais i il est toujours référencé ✔ WUNTRACED : provoque la prise en compte des fils dont l'état change,
dans le système. c'est-à-dire des processus fils dont l'état est passé de prêt à suspendu.
 —Si l'appel se déroule correctement, la valeur 0 est renvoyée, sinon, le
======>suite Attente de la fin d'un fils— Variables d’alternances de Peterson : valeur -1 est renvoyée si une erreur s'est produite et la variable errno
En cas d'échec, la fonction retourne -1 et la variable errno contient une —améliore l’approche de variable d’alternances en permettant au processus contient l'une des valeurs suivantes :
valeur permettant d'identifier la cause de l'échec qui peut être entre autres : dont ce n’est pas le tour de rentrer quand-même en section critique, lorsque —EINVAL : Le numéro du signal est invalide.
✔ ECHILD : le processus spécifié par pid n'existe pas. l’autre processus n’est pas encore prêt à le faire —ESRCH : Le processus ou groupe de processus cible n'existe pas.
✔ EFAULT : status contient une adresse invalide. —EPERM : Le processus appelant n'a pas la permission d'envoyer un
✔ EINTR : l'appel système a été interrompu par la réception d'un signal. ========>Problèmes classiques de synchronisation signal au processus destinataire car ils n'appartiennent pas au même
✔ EPERM : le processus appelant n'est pas privilégié et son identificateur —Les producteurs / consommateurs propriétaire.
d'utilisateur effectif n'est pas égal à celui du processus spécifié par pid. :L’exécution concourante des producteurs et des consommateurs repose sur Un processus appartenant au super utilisateur a bien sûr le droit
✔ EINVAL : la valeur de l'argument option n'est pas valide l’utilisation d’un ensemble de N buffers intermédiaires remplis par les d'envoyer un signal à tous les autres processus (sauf init afin de
producteurs et vidés par les consommateurs. ESP :—Le processus clavier protéger le système, aucun processus ne peut envoyer de signal qui
produit des caractères qui sont consommés par le processus d’affichage à provoquerait la terminaison du processus init
l’écran.
—Le pilote de l’imprimante produit des lignes de caractères, consommées par ===>killpg() est utilisé pour envoyer un signal à un groupe de processus
l’imprimante. —Le premier argument de l'appel représente le groupe vers lequel le
execution
Un compilateur produit des lignes de code consommées par l’assembleur signal est émis. Si sa valeur est nulle, alors le signal est envoyé aux
processus du groupe du processus émetteur. Sinon, le fonctionnement
—Les lecteurs / rédacteurs: est similaire à celui de kill().
—Un objet est partagé entre plusieurs activités concurrentes. Certaines
activités (les lecteurs) ne modifient pas le contenu de l’objet contrairement à —une fonction ANSI-C permettant à un processus de s'envoyer un
d’autres (les écrivains).EXP :—Supposons qu'une base de données ait des signal, c'est la fonction raise().
lecteurs et des rédacteurs, et qu'il faille programmer les lecteurs et les Cette fonction est équivalente à kill(getpid(), sig). En cas d'erreur, une
rédacteurs de cette base de données. valeur non nulle est renvoyée
—Les contraintes sont les suivantes :
—plusieurs lecteurs doivent pouvoir lire la base de données en même temps ;
—si un rédacteur est en train de modifier la base de données, aucun autre
utilisateur (ni rédacteur, ni même lecteur) ne doit pouvoir y accéder.
—
==================>SEMAPHORe
Un sémaphore intervient donc dans le mécanisme de partage des ressources
===========================Ordonnensement===========================
disponibles, qu'elles soient uniques ou non, dans un environnement donné
La fonction d'ordonnancement gère le partage du processeur entre les execution
différents processus en attente pour s'exécuter, c'est-à-dire entre les
—Un sémaphore S est une variable entière qui n'est accessible qu'au travers
différents processus qui sont dans l'état prêt
de 3 opérations Init, P et V.
—Le système d'ordonnancement gère:
—La valeur d'un semaphore est le nombre d'unités de ressource (exemple :
—une file des processus prêts et une file des processus bloqués.
imprimantes...) libres. S'il n'y a qu'une ressource, un semaphore binaire avec
================>Critères pour une bonne politique d’ordonnancement
les valeurs 0 ou 1 est utilise.
—Équité /efficacité/minimiser le temps de réponse/minimiser le temps
—Init(S, valeur) est seulement utilise pour initialiser le sémaphore S avec
d’exécution/maximiser le rendement
une valeur. Cette opération ne doit être réalisée qu'une seule et unique
fois.
==============Algo
—L'opération P (Puis-je?)est en attente jusqu'à ce qu'une ressource soit
—FCFS (First Come First Serve), premier arrivé premier servi.
disponible, ressource qui sera immédiatement allouée au processus
—SJF (Short Job First), plus court d'abord
courant. ====>Réception d'un signal :
SRT (Shortest Remaining Time), plus petit temps de séjour
—V (Vas-y) est l'opération inverse; elle rend simplement une ressource signal() permet d'installer un gestionnaire de signaux en une seule
—RR (Round Robin), algorithme circulaire tourniquet, circulaire ou round robin
disponible à nouveau après que le processus a terminé de l'utiliser instruction
—PRI (Priorités, sans évolution)
—SIG_ING : Pour ignorer le signal.
=====>L’idée des sémaphores est d’utiliser une variable entière pour compter
============INTERRUPTION
le nombre de réveils en attente, et d’encapsuler cette variable SIG_DFL : Pour repositionner le comportement par défaut
—est un signal
—est la conséquence d'un évènement qui peut être interne au processus et
résultant de son exécution, ou bien extérieur et indépendant de cette
=============================LES SIGNAUX=============================
exécution.
—Un mécanisme de communication entre le noyau et les processus ou entre
—Dans un système multitâche, interruptions:
processus.
—causées par les périphériques (fin d’exécution de requête)
—L'arrivée d'un signal interrompt le processus destinataire et déclenche une
—causées par signaux d’horloge
action qui peut être :
—évènements extérieurs
—L'arrêt brutal du processus par le système.
—Le passage à l'état stoppé du processus.
=====interruption disque:—: interruption venant d’un contrôleur de disques
—La reprise de l'exécution du processus s'il était à l'état stoppé.
—mettre le processus actif à l’état prêt
— L'exécution d'une fonction du processus.
—déterminer la cause de l’interruption (p. ex : fin de lecture)
Aucune action, on dit alors que le processus ignore le signal
—trouver le processus demandeur (qui est bloqué)
—lui transférer les données reçues
—Un signal est représenté dans le système par un nom de la forme
—le remettre à l’état prêt
SIGXXX.
—activer un des processus prêts ==>ATTENTE SGNL
—Il existe un nombre déterminé de signaux et divisés en deux catégories:
Un processus peut se mettre en
les signaux classiques ou standards et les signaux temps-réel
=====>interruption horloge:—quantum de temps épuisé (ordonnancement attente de l'arrivée d'un signal
—Le nombre total de signaux existants dans le système est indiqué par la
avec réquisition, preemptive scheduling) grâce à l'appel système pause().
constante NSIG définie dans le fichier d'en-tête <signal.h>.
—remettre le processus actif à l’état prêt/ activer un des processus prêts —Cet appel suspend le processus
Sur les systèmes supportant les signaux temps-réels, deux valeurs sont
appelant jusqu'a l'arrivée d'un
définies SIGRTMIN et SIGRTMAX, les numéros du plus petit et du plus grand
=======>priorité des nv interruption : —S'il existe plusieurs niveaux signal quelconque (inconvénient).
signal temps-réel
d'interruption, on peut avoir à un moment donné, plusieurs indicateurs —La valeur de retour de l'appel est
d'interruption positionnés en même temps. toujours -1, et la variable errno
======>SIGNAUX CLASSIQUE :sont numérotés de 1 à 31.
—D'où l'utilisation de priorités sur les niveaux d'interruption. contient la valeur EINTR.
—SIGTERM : Terminaison du processus [T].
Si dans une interruption, une seconde se produit, ..., les processus ne EINTR : L'appel système a été
—SIGKILL : Terminaison irrévocable [T].
progressent plus ; on fait des commutations de mots d'état en cascade interrompu par la réception d'un
— SIGINT : Terminaison à partir du clavier (généralement ctrl-c) [T].
—D'où le masquage et le désarmement de niveaux d'interruption. signal
—SIGQUIT : Terminaison clavier (ctrl-\ en général) [D].
—En masquant un niveau d'interruption, on retarde la prise en compte des
—SIGSTOP : Arrêt temporaire du processus (passage à l'état stoppé) [A].
interruptions de ce niveau.
—SIGSTP : Arrêt temporaire du processus à partir du clavier (ctrl-z) [A]. ========================>GRP SIGNAUX
En désarmant un niveau d'interruption on annule l'effet des interruptions
—SIGCONT : Reprise de l'exécution [R]. Il est possible de suspendre ou de bloquer plusieurs signaux
correspondantes. On peut réarmer un niveau désarmé
—SIGSEGV : Référence mémoire invalide [D]. simultanément.
—SIGCHLD : Fils stoppé ou terminé [I]. —Dans ce cas, les signaux sont gérés par groupe.
=========================Communication inter-processus=================
—Les objets de type sigset_t défini dans <signal.h> représentent des
—La solution à la résolution des problèmes d’accès concurrents consiste à
=====>Les signaux temps-réel :sont numérotés de 32 à 64. ensembles de signaux.
interdire la modification de données partagées à plus d’un processus à la fois,
—Ils sont réservés à l'utilisateur, ce sont des extensions de SIGUSR1 et
—c’est-à-dire définir un mécanisme d’exclusion mutuelle sur des portions
SIGUSR2.
spécifique du code, appelés sections critiques — crée un ensemble vide.
—Ils ne sont pas représentés par des constantes, mais directement par leurs
=======> section critique la partie d’un prog où se produit le conflit d’accès crée un ensemble ou y'a tous les signau
valeurs, qui s'entendent de SIGRTMIN et SIGRTMAX.
++++++++>Comment éviter ces conflits d’accès ? ajouter un signal à un ensble
—¨ Il faut trouver un moyen d’interdiction de la lecture ou de l’écriture des ou l' !=
=====>Affichage des signaux :
données partagées à plus d’un processus à la fois
— Les deux fonctions de
—¨ Il faut une exclusion mutuelle qui empêche les autres processus d’accéder
la bibliothèque C —Le retrait permet de tester l'appartenance d'un signal à un ensemble,
à des données partagées si celles-ci sont en train d’être utilisées par un
:strsignal() et psignal(). il renvoi 1 si le signal appartient à l'ensemble, et 0 sinon.
processus
—Le seul cas d'erreur possible pour l'ensemble de ces fonctions
consiste à fournir un signal invalide. La valeur de retour est alors -1 et
—On peut formaliser le comportement des sections critiques au moyen de
la variable errno contient la valeur EINVAL.
quatre conditions suivantes afin d’éviter le conflit d’accès et garantir le bon
======>BLOCAGES Signaux
fonctionnement du SE:
—Chaque processus possède un ensemble nommé masque de signaux,
[Link] processus ne peuvent être simultanément dans la même section
contenant la liste des signaux bloqués. Cet ensemble peut être modifié
critiques
grâce à l'appel système sigprocmask().
[Link] hypothèse n’est faite sur les vitesses relatives des processus, ni sur
le nombre de processeurs
[Link] processus suspendu en dehors d’une section critique ne peut bloquer
les autres
[Link] processus ne doit attendre trop longtemps avant d’entrer en section
critique
===========>mécanismes pour mettre en œuvre l’exclusion mutuelle
Masquage des interruptions :avant d’entrer dans une section critique et de execution
les restaurer à la sortie.
[Link] le masquage se fait par le processus entrant au section critique donc il ne
pourra pas être suspendu au profit d’un autre processus, puisque l’inhibition
(le masquage) des interruptions empêche l’ordonnanceur de s’exécuter.
[Link] le SE fait le masquage, cette méthode ne sera pas efficace pour les
systèmes multi-processeurs; puisque les processus s’exécutant sur les autres
processeurs peuvent toujours entrer en section critique.
Variables de verrouillage:Inconvénient: pour le cas du masquage des
interruptions. Lorsqu’un processus entre en section critique, tous les
autres processus sont bloqués, même si la section critique ne concerne
=======>Emission d'un signal:
qu’un seul processus. Pour cela, on déclare une variable par section
critiques, qui joue le rôle de verrou. La variable est mise à 1 par le ——Le premier argument indique la façon dont l'ensemble de signaux
kill() est utilisé pour envoyer un signal à un processus ou à un groupe de
processus entrant dans la section critique considérée et remise à 0 par le passé en second argument doit être traité. Il prend l'une des valeurs
processus —Le premier argument représente l'identité du destinataire.
processus lorsqu’il quitte ======>While(verrou==1) /*Attenre*/ suivantes :
—Le deuxième argument indique le signal à émettre.
Verrou=1; —SIG_BLOCK : Les signaux bloqués sont l’union de l'ensemble courant
—Si pid >0 le signal sig est envoyé au processus identifié par pid.
Section_critique(); et de l'ensemble set.
—Si pid=0, le signal sig est=>aux processus du groupe du procesus émetteur.
Verrou=0; —SIG_UNBLOCK : Les signaux de l'ensemble set sont retirés de la liste
—Si pid= -1, le signal sig est envoyé à tous les processus, sauf le 1er (prss init).
des signaux bloqués.
—Si pid <-1, le signal sig est =>au grp du processus identifié par la valeur -pid.
—SIG_SETMASK : Les signaux bloqués sont ceux de l'ensemble set.
Si le signal envoyé=0, l'appel ne génère pas de signal mais contrôle
=======>Le blocage des signaux : sigpending
—Le processus peut demander au système la
liste des signaux en attente par l'appel système
sigpending().

—Le paramètre set contient à l'issue de

—Cet appel retourne:

— Le seul cas d'erreur possible pour cet appel