Vous êtes sur la page 1sur 17

Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences &

06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Enseignement d'Informatique : II31

Titre : Programmation systme sous UNIX 1 Prsentation d'UNIX


Objectif : Approfondir la connaissance du systme d'exploitation UNIX en tudiant son fonctionnement et en
manipulant ses fonctions systmes 1.1 Historique
UNIX cr au Laboratoire BELL, USA, en 1969 .
Contenu : Destin la gestion d'un mini-ordinateur pour une petite quipe de programmeurs.
1 Prsentation d'UNIX ......................................................................................................................................2 Intresse rapidement de nombreuse universits puis des constructeurs.
2. Noyau Unix...................................................................................................................................................2 Deux principales familles de systmes UNIX (1983): Berkeley(BSD) et System V de Bell.
3. Fichiers.........................................................................................................................................................4 De nombreux efforts de normalisation : norme System V , POSIX(1988), OSF
4. Processus ......................................................................................................................................................9 De nombreuses versions d'UNIX sont donc apparues :
5. Communication inter processus ................................................................................................................... 18 ULTRIX (BSD) puis OSF sur DIGITAL, IRIX(System V) sur Silicon Graphics,
6. Sujets des TDs ............................................................................................................................................ 24 LINUX(POSIX) sur PC, et bien d'autres.
7. Sujets des TPs ............................................................................................................................................. 29

Bibliographie :

Maurice J. Bach "Conception du systme UNIX" Masson paris 1989


1.2 Les Concepts Fondamentaux
Jean-Marie Rifflet "La programmation sous UNIX" Ediscience International 1998 Systme multi-utilisateurs et multi-tches, indpendant de toute architecture matrielle/constructeur.
Permet la rpartition des ressources (mmoire, processeurs, espace disque, imprimantes, programmes et
Remerciements : utilitaires) entre les utilisateurs et les tches.
Je remercie Grard Berthelot , avec lequel j'ai eu le plaisir d'assurer l'enseignement d'UNIX l'Institut Chaque utilisateur peut excuter plusieurs programmes simultanment.
d'Informatique d'Entreprise (IIE) du CNAM, de m'avoir permis de reprendre son support de cours et de pouvoir Fournit des primitives pour construire des applications complexes partir d'autres plus simples, avec une
le modifier. interface graphique puissante- X-Windows (MIT) , MOTIF.
Il est possible de rediriger les entres et sorties des processus.
Un mcanisme de communication par tubes permet de synchroniser des processus et de leur faire changer
des informations.
Un systme UNIX est administr par un super-utilisateur ("superuser").

2. Noyau Unix
Le systme UNIX est avant tout une collection d'appels systme sur les fichiers, processus, entres/sorties,
communications inter-processus, communications rseaux, etc.
Chaque appel se prsente comme un appel de fonction.
Le traitement d'un appel systmes provoque un passage en mode systme (ou noyau).
Lorsque le traitement de l'exception se termine, le processeur repasse en mode utilisateur et on revient
excuter l'instruction se trouvant immdiatement derrire l'appel systme.
La plupart des appels systmes retournent une valeur qui indique le succs ou l'chec de l'opration
demande. En cas d'chec la cause exacte de l'chec peut tre prcise par le contenu de la variable globale
errno (langage C)disponible en incluant le fichier <errno.h>. Celui-ci contient galement la liste des codes
d'erreur.

II31 1 http://lsc.univ-evry.fr/~mallem II31 2 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Noyau UNIX (suite) - Diagramme bloc 3. Fichiers

3.1 Structure dun disque logique(partition) :

Bloc 0

Super Bloc Table des Bloc des donnes


i-noeuds
Bootstap

I-nud et blocs donnes dun fichier :

Noyau UNIX (suite)

Le traitement demand est ralis par le processus lui-mme ce qui vite de faire une commutation et
simplifie beaucoup le passage de paramtres et de valeur de retour puisqu'on reste dans le mme espace
d'adresses.

* les appels systmes sont excuts en utilisant une pile d'excution diffrente ;

* la priorit d'excution est plus grande ;

* certaines interruptions peuvent tre masques.

II31 3 http://lsc.univ-evry.fr/~mallem II31 4 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Fichiers (suite) Tables des fichiers ouverts

Toute utilisation d'un fichier commence par une ouverture qui renvoie un "file descriptor" traduit ici par
"numro de fichier ouvert" qui n'est que le numro de l'entre qui contient un pointeur vers l'inoeud du
fichier, dans la table des fichiers ouverts

3.2 Caractristiques des Fichiers Aprs ouverture, un programme dsigne un fichier non plus par une rfrence relative ou absolue mais par le
numro de l'entre dans la table.
Tout fichier est dfini par un descripteur de fichier unique appel i-noeud. Il contient les informations d'ordre
Avantage : inutile de retraduire le nom a chaque opration sur le fichier.
gnral concernant le fichier :
taille ;
adresse des blocs utiliss sur le disque ;
identification du propritaire ;
permissions d'accs ;
type de fichier (fichier ordinaire, catalogue, ...) ;
date de dernire modification ;
compteur de rfrences ce fichier dans un rpertoire.
L'i-noeud ne contient aucun nom pour le fichier.
Un fichier n'est effectivement dtruit (espace disque et i-noeud rcuprs par le systme) que si le compteur
de rfrences du i-noeud du fichier devient nul.
Table des fichiers ouverts
Fichiers (suite)

En plus des permissions d'accs, 3 autres bits ayant un rle spcial sont utiliss pour chaque fichier :
* set-uid permet d'excuter un programme avec les privilges de son propritaire et non pas ceux de
Fichiers (suite) Tables de gestion de fichiers
l'utilisateur qui lance l'excution.
Ce mcanisme est utilis en particulier pour changer le mot de passe. Le bit set-uid se traduit lorsqu'il est
Descripteurs de fichiers Table globale Table globale des
positionn par une lettre s dans les permissions d'accs (affiches lors d'un ls -l) ;
Ouverts d'un processus des fichiers ouverts i-nuds
* set-gid : mme chose avec le groupe ;
de tous Les processus
* bit de collage (sticky bit) assure le maintien du programme en mmoire mme lorsque aucun processus
actif ne correspond une excution du programme.
Un ficher rgulier UNIX peut tre considr comme un tableau de caractres et les oprations de
u.u_ofile[] file[] inode[]
lecture/criture se font partir d'un "pointeur de position" qui pointe sur le premier caractre lors de
l'ouverture et est ensuite avanc au fur et mesure des lectures et des critures.

Fichiers (suite)

Nouvelles_protections peut tre exprim de deux manires :


750 correspond en octal rwxr-x--- (1 = autoris, 0 = interdit)
ug+w rajoute les autorisations d'criture au propritaire et au groupe
Type de fichiers : Il existe 3 autres bits qui reprsentent le type de fichier
XXX rwxrwxrwx
Type User(Owner)
Group
Other
Type :
- : ordinaire; d : directory; p : pipe; s : socket; c : caractere; b : bloc; l : lien (symbolique/physique)

Autres attributs : Il existe 3 autres autres combinaisons qui positionnent des bits spciaux :
04000 : positionne le suid bit (le fichier sexcute avec les droits du propritaire)
X X X r w s r w x r w x (le x du propritaire est transform en s) <user.h> <file.h> <inode.h>
02000 : positionne le sgid bit (le fichier sexcute avec les droits du groupe)
X X X r w x r w s r w x (le x du groupe est transform en s)
01000 : positionne le sticky bit (le fichier est maintenu en mmoire aprs son excution, ex :
compilateur )
X X X r w t r w x r w x (le x du propritaire est transform en t)

II31 5 http://lsc.univ-evry.fr/~mallem II31 6 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Appels Systmes Oprant sur les Fichiers (suite)


3.3 Appels Systmes Oprant sur les Fichiers
#include <fcntl.h> * int write(int no_fichier, char *adr_zone, int nb);
int open(char *rfrence ,int mode [,int permission]) Transfre nb caractres depuis l'adresse dsigne par adr_zone l'endroit point par le pointeur de
Si le fichier dsign par la rfrence relative ou absolue rfrence existe alors il est ouvert et position du fichier no_fichier.
permission peut tre omis. Retourne le nombre de caractres transfrs dans le fichier ou -1 en cas de problme.
mode indique le type d'accs : O_RDONLY, O_WRONLY , O_RDWR et O_CREAT pour respectivement : Exemple :
int nb;
lecture seulement, criture seulement , lecture/criture et cration.
char c,tab[8]="bonjour";
La fonction open retourne le numro de fichier(non ngatif) ouvert en cas de succs et -1 sinon. nb = write(1,&c,1);
Le pointeur de position du fichier pointe sur le premier octet du fichier. nb = write(nf,tab,sizeof tab);
Exemple :
int nf;
nf = open("projet.c", O_RDWR);

Appels Systmes Oprant sur les Fichiers (suite)

* long lseek(int no_fichier, long dplacement, int apartir);


Appels Systmes Oprant sur les Fichiers (suite) Dplace le pointeur de position du fichier dsign par no_fichier de dplacement octets par
* int close (int no_fichier); rapport la position courante, par rapport au dbut du fichier, ou par rapport la fin du fichier suivant
Ferme le fichier de numro no_fichier, ouvert par open() que apartir est gal respectivement 0, 1, 2.
L'entre dans la table des fichiers ouverts est libre et peut tre rutilise ultrieurement lors de Retourne la valeur du pointeur de position aprs l'opration et -1 en cas d'erreur.
l'ouverture d'un autre fichier. Le dbut du fichier correspond la valeur 0.
La fonction close retourne 0 si l'opration se termine normalement et -1 sinon.
Exemple :
int nf,ff; Appels Systmes Oprant sur les Fichiers (suite)
nf = open("projet.c", O_RDWR);
ff = close(nf); Exemple :

#include <fcntl.h>

void main()
{
Appels Systmes Oprant sur les Fichiers (suite) int no_fichier;
char tab[8]="bonjour";
* int read(int no_fichier, char *adr_zone, int nb); no_fichier=open("/dev/lpr" , O_WRONLY);
if(no_fichier>0)write(no_fichier, tab,sizeof tab);
Essaye de lire nb octets partir de la position indique par le pointeur de position du fichier dsign }
par no_fichier et les copie l'emplacement dsign par adr_zone.

La valeur retourne est le minimum de nb et de la quantit effectivement disponible et est gale


zro si la fin de fichier(EOF) est atteinte, ou -1 en cas d'erreur.
Autres fonctions systmes utilises pour les manipulations sur les fichiers :
Le pointeur de position du fichier est augment de la quantit lue. Creat : cration d'un fichier.
Exemple : Link : cration d'un lien physique sur un fichier (ln).
Unlink : suppression d'un lien physique sur un fichier et suppression du fichier si c'tait le dernier lien
int nb; existant.
Dup : duplication d'une entre dans la table des fichiers ouverts dans la premire entre disponible.
char c,tab[100]; Chdir : changement de rpertoire de travail (cd).
Chown : changement de propritaire de fichier.
nb = read(0,&c,1);
Chmod : changement de permission d'accs.
nb = read(nf,tab,sizeof tab); Flush : vide un tampon d'entre/sortie.
Stat : donne attributs d'un fichier (type, propritaire, permission d'accs, etc).
Umask : modification du "masque" des permissions d'accs utilis lors des crations de fichiers.
Mknod : cration d'un rpertoire.
Mount : montage d'une arborescence d'un volume amovible.
Tar : cration, modification et lecture d'archives.

II31 7 http://lsc.univ-evry.fr/~mallem II31 8 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Appels Systmes Oprant sur les Fichiers (suite)


4.2 Gestion de Processus par le Systme Unix
#include <sys/types.h>
La mmoire alloue un processus (ou image mmoire) est constitu partir du fichier qui contient le
#include <sys/stat.h>
int stat(char *nom , struct stat *buf); programme.
C'est un espace d'adresses virtuelles (0 232 ) propre chaque processus
Lit l'i-nud du fichier nom et renvoie la partie systme de celui-ci sous forme d'une structure pointe par
Seules les parties utilises correspondent a des zones de la mmoire physique.
buf. Celle-ci contient le numro d'i-nud , la taille, le propritaire, les protections du fichier
Des zones physiques peuvent tre partages.
stat retourne 0 en cas d'accs russi et -1 en cas d'erreur.
la zone utilisateur : en zone systme, contient les donnes de gestion du processus : tables des fichiers
ouverts, paramtres des E/S ...
le segment de texte contient la squence d'instructions excute;
la zone des donnes statiques (variables globales du programme, ...);
4. Processus la zone de donnes dynamique pour les objets non permanents.
un tas pour les variables accdes par pointeurs.
4.1 Caractristiques des Processus une pile pour les variables locales, les paramtres de fonctions, ...);
Un processus est une excution d'un programme un instant donn. Le programme lui-mme est un objet
inerte rang sur disque sous forme d'un fichier ordinaire excutable. Plusieurs caractristiques sont associes
un processus, dont :
une identification ou Process IDentifier ou PID (entier) ;
un propritaire rel ou Real User IDentifier (entier) ;
un propritaire effectif ou Effective User IDentifier (entier) ;
un groupe propritaire rel ou Real Group IDentfifier (entier) ;
un groupe propritaire effectif ou Effective Group ID (entier)
un terminal d'attachement (le terminal du login).
Lors du lancement d'un processus, le programme qu'il doit excuter est charg en mmoire centrale en vue de
son excution.

Diffrents types de processus :


Un processus systme est un processus cr lors du lancement du systme pour excuter des tches
l'intrieur du noyau : Gestion de Processus par le Systme Unix (suite)
Gestion des pages de mmoire, Tables de gestion de fichiers
Transferts des processus suspendus sur disque ...
Table des processus Table des rgions Table globale
cr lors du dmarrage .
par processus des rgions
Un dmon est un processus charg d'une tche d'intrt gnral :
Gestion d'impression, gestion rseau, gestion du courrier ...
Il n'est pas attach un terminal.
crs au dmarrage ou par l'administrateur
interrompus que par l'administrateur ou lors de l'arrt du systme .
Un processus utilisateur est lanc par un utilisateur particulier depuis un terminal donn. Lors du login sur un
terminal, un processus est lanc (shell en gnral , mais ce peut tre un autre programme).

II31 9 http://lsc.univ-evry.fr/~mallem II31 10 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Substitution de programme par un processus


Gestion de processus (suite) Une famille de primitives exec permettent le lancement de l'excution par le processus appelant d'un
Remarques : nouveau programme
Programmes gnralement partageables : Le texte du nouveau programme recouvre et efface celui de l'ancien programme excut.
si plusieurs utilisateurs demandent l'excution d'un mme programme, une seule copie du segment => pas de retour d'un exec russi. Les appels ces fonctions n'entranent pas de cration de processus
de texte du programme est place en mmoire centrale, puis elle est partage par les diffrents mais seulement une modification de l'image excute.
processus correspondants. execl(char *ref, char *arg0, ..., char *argn, 0).
programmes partageable gnralement rentrants : Permet de lancer l'excution du fichier dont la rfrence est ref avec les paramtres arg1, ..., argn.
le systme affecte des zones mmoire propres pour les donnes de chacun d'eux => pas Le paramtre arg0 est obligatoire et doit tre la mme chane de caractres que ref.
d'interfrences entre les diffrentes excutions d'un mme programme.
Table des processus avec une entre par processus
contient toutes les informations ncessaires pour que le systme puisse grer le processus lorsqu'il
n'est pas actif.
alloue lors de la cration du proc. et libre lorsqu'il se termine.

Cration de processus 4.3.2 Fin d'un Processus


Cration par clonage d'un processus pre qui utilise l'appel systme fork(). exit (int n);
Le processus fils est une copie exacte du processus pre avec : Termine le processus qui l'appelle. La valeur de n est disponible pour le processus pre du processus
le mme programme mais appelant et il peut l'obtenir par la fonction wait (voir plus loin). La fonction exit provoque la fermeture
des copies des donnes du pre. de tous les fichiers ouverts par le processus et la libration de toutes les ressources dtenues par le
Mcanisme de substitution : processus (mmoire, etc). Les processus fils du processus qui se termine sont orphelins mais sont
on remplace l'image mmoire d'un processus par une nouvelle image construite partir d'un fichier adopts par le processus "init" (processus 1). L'entre correspondant au processus dans la table des
excutable : processus est libre. L'identificateur de processus ne sera pas rutilis avant un certain temps pour
nouveau programme et viter des confusions.
nouvelles donnes Il n'y a pas de retour pour cet appel systme.
L'excution du processus se poursuit au dbut du nouveau programme.
Mcanisme de suspension : permet d'attendre (la terminaison d'un fils).

4.3.3 Attente de la Fin d'un Fils


4.3 Appels Systmes Oprant sur les Processus int wait(int *n);
De nombreuses primitives de gestion de processus peuvent tre utilises dans des programmes crits en C Permet de suspendre un processus jusqu' la rception d'un signal ou qu'un de ses processus fils se
sous UNIX. termine ou s'arrte.
Renvoie le numro du processus qui s'est termin.
4.3.1 Cration de Processus Si n est un pointeur non nul, la valeur de l'entier *n contient des informations sur l'arrt du processus
int fork(); fils.
Cre un processus, le "fils", copie du processus appelant, le "pre". S'il n'y a pas de processus fils, la primitive wait retourne immdiatement la valeur -1.
Le processus fils :
- excute le mme programme que le processus pre;
- utilise des copies des donnes du pre;
- mmes fichiers ouverts que le pre et mmes pointeurs de position;
- mmes propritaires rel et effectif que le pre;
- mmes ractions aux signaux que le processus pre;
- mme rpertoire de travail que le pre;
- attach au mme terminal que le pre;
- identificateur de processus (PID) diffrent de celui du pre.
En cas de succs l'appel systme fork renvoie 0 au processus fils, et renvoie le numro du processus fils
nouvellement cr au processus pre.

II31 11 http://lsc.univ-evry.fr/~mallem II31 12 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Exemple d'utilisation des mcanismes processus par le shell

4.4.1.Communication entre Processus par Tubes anonymes (suite)


int pipe (int no_fichier[2]);

cr et ouvre le tube la fois en lecture et en criture et rend deux numros de fichiers ouverts, l'un
correspondant l'ouverture en lecture et l'autre l'ouverture en criture.

Retourne 0 si la cration du tube a bien eu lieu et -1 sinon.


4.3.5 Quelques Primitives de gestion de processus
Exemple :
sleep(int n) : met le processus en sommeil pour n secondes.
getpid() : fournit le numro du processus. int retour, no_fichier[2];
getppid() : fournit le numro du processus pre.
getuid() : donne le propritaire. retour = pipe(no_fichier);
getgid() : donne le groupe du processus.
Un tube ne peut tre utilis que par le processus qui l'a cr ou par ses descendants (du fait de son
setuid(int id) : change le propritaire. absence de nom).
setgid(int gid) : change le groupe du processus.
L'criture et la lecture dans un tube se font en utilisant les appels normaux read() et write() avec
comme paramtre le numro de fichier correspondant.

Tubes anonymes (suite)


Il n'y a qu'un seul pointeur de position pour les lectures, qui est partag par tous les processus "lecteurs".
4.4 Communication entre Processus par Tubes De mme il n'y a qu'un seul pointeur de position en criture qui est partag par tous les processus
Un tube est un fichier sans nom gr par le systme. Il existe deux catgories de tubes, les tubes anonymes "crivains".
utiliss par des processus apparents , et des tubes nomms utilisables par des processus non forcment de Pour assurer le caractre FIFO, les modifications de pointeur de position par lseek() sont interdites.
mme famille. tube vide : pointeur de lecture est gal au pointeur d'criture.
Ci-dessous l'tat de la table des fichiers aprs la cration d'un pipe :
tube plein : pointeur d'criture -pointeur de lecture = max.

Lors d'une lecture, le nombre d'octets effectivement lus est le minimum du nombre demand et du
nombre disponible. Le systme se charge de suspendre tout processus qui tente de lire dans un tube
vide jusqu' l'introduction de nouveau octets ou la fermeture dfinitive du tube en criture. De
mme pour l'criture.

II31 13 http://lsc.univ-evry.fr/~mallem II31 14 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

4.4.2.Communication entre Processus par un Tube nomm


Tubes anonymes (suite) int mknod (char *ref, S_IFIFO|0666, int flg);
Une "extrmit" d'un tube peut tre ferme par appel de close() sur le numro de fichier ouvert
correspondant. cr le tube ref la fois en lecture et en criture.
Un tube ferm une extrmit par un processus ne peut tre r-ouvert par ce mme processus (absence
de nom de tube). Retourne 0 si la cration du tube a bien eu lieu et -1 sinon.
tube dfinitivement ferm en criture : tous les processus qui possdaient le numro de fichier ouvert en
Exemple :
criture l'ont ferm en criture.
tube dfinitivement ferm en lecture : tous les processus qui possdaient le numro de fichier ouvert en Retour = mknod ("fifo", S_IFIFO|0666, 0);
lecture l'ont ferm en lecture.
crire dans un tube dfinitivement ferm en lecture n'a pas de sens. Par consquent toute criture dans Un tube nomm peut tre utilis par le processus qui l'a cr et par ceux qui sont autoriss.
un tube dfinitivement ferm en lecture provoque l'envoi d'un signal "tube ferm" (SIGPIPE) au
processus demandeur. Sauf mention contraire ce signal provoque sa mort (voir signaux). L'ouverture d'un pipe nomm se fait, comme pour un fichier, avec la fonction open().
L'criture et la lecture dans un tube se font en utilisant les appels normaux read() et write() avec
comme paramtre le numro de fichier correspondant.
Tubes anonymes(suite)

Exemple :
Le programme suivant donne un exemple de communication par pipe entre un processus et son fils: 4.5 Les Signaux
#include <unistd.h>
void main(void) { 4.5.1 Caractristiques des Signaux
Avertir un processus qu'un vnement important s'est produit
int tube[2]; char message[50]; => un processus peut ragir cet vnement sans tre oblig de le tester
pipe(tube); Mcanisme utilis par le systme pour informer les processus d'erreurs lors des appels systmes ou
switch(fork()) { d'une erreur d'instruction : overflow, adresse illgale, etc.
case 0 : close(tube[0]); Le signal est envoy par la routine de traitement de l'exception cause par l'erreur.
write(tube[1],"message du fils",15);
Utiliss pour avertir un processus que l'utilisateur a frapp une touche du clavier du terminal auquel
close(tube[1]);
il est attach.
break;
default : close(tube[1]); Tout processus peut envoyer un signal un autre processus (moyennant certaines autorisations) par
read(tube[0],message,15); la fonction systme kill.
message[20]=0; La rception d'un signal provoque le plus souvent la fin du processus qui le reoit, sauf si
printf("Message lu par le pere : %s\n",message); installation pralable dune fonction de traitement par signal.
close(tube[0]);
}
}
4.5.2 Principaux Signaux
nom numro signification
SIGHUP 1 (hang up) mis tous les processus associs un terminal lorsque celui-ci se dconnecte.
SIGINT 2 (interrupt) signal d'interruption mis tous les processusassocis un terminal lorsque le caractre
d'interruption (en gnral <CTRL-C>) est tap.
SIGQUIT 3 (quit) signal d'interruption mis tous les processus associs un terminal lorsque le caractre
pour quitter une application (en gnral <CTRL-\>) est tap.
SIGILL 4 (illegal) mis en cas d'instruction illgale.
SIGTRAP 5 (trap) mis aprs chaque instruction en cas de traage de processus.

II31 15 http://lsc.univ-evry.fr/~mallem II31 16 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Principaux signaux (suite) Autres appels systmes associs aux signaux


SIGIOT 6 (input/output trap) mis en cas d'erreur matrielle. * int pause();
SIGKILL 9 (kill) tue un processus, quel que soit son tat. Suspend le processus jusqu' rception d'un signal. Suivant la nature du signal et les traitements de
SIGSEGV 11 (segmentation violation) mis en cas de violation de la segmentation mmoire. signaux mis en place, il reprend son excution ou traite le signal puis reprend son excution, ou bien se
SIGSYS 12 (system) mis en cas d'erreur de paramtre dans un appel systme. termine directement.
SIGPIPE 13 (pipe) mis en cas d'criture sur un tube sans lecteur.
SIGALRM 14 (alarm) signal associ une horloge. * int alarm (int sec);
SIGTERM 15 (termination) terminaison normale d'un processus. Programme l'envoi par le systme du signal SIGALRM au processus appelant dans sec secondes.

4.5.3 Appels Systmes Associs aux Signaux


* int kill(int pid, int sig); 5. Communication inter processus
met le signalsig au processus pid, condition que les proc. metteur et destinataire soient du mme
propritaire, ou que le premier soit le super-utilisateur. IPC (Inter Process Communications) UNIX :
Renvoie 0 en cas de succs et -1 sinon. Messages
* int (*signal())(int sig, int *() fonction); segments de mmoire partageables
Permet d'installer fonction comme fonction de traitement lors de la rception du signalsig. La smaphores
fonction de traitement peut tre remplace par une des constantes SIGIGN et SIGDFL . Le signal
SIGKILL ne peut tre ignor. Par nature un objet IPC est partageable par plusieurs processus
Renvoie l'adresse de la fonction de traitement prcdemment utilise en cas de succs et -1 en cas d'chec.
Dclaration au niveau de la totalit des utilisateurs
Droits d'accs spcifique pour chaque catgorie de processus
(user, group, other)
deux types d'accs : lecture ou modification
identifi par un nom externe ou identifiant (entier de type key_t)
Signaux (suite) utilis au moyen d'un nom interne ou dsignateur (entier)

Exemple :

Le programme suivant met en place un traitement pour les signaux SIGINT et SIGQUIT, puis se /* Common IPC Structures */
suspend pendant 120s avant de se terminer. Il ragit aux signaux SIGINT et SIGQUIT mais ne meurt
pas . struct ipc_perm {
#include <signal.h>
void trait_sigint(){ uid_t uid; /* owner's user id */
printf("bien recu SIGINT, mais je m'en moque\n");
} gid_t gid; /* owner's group id */
void trait_sigquit() {
printf("bien recu SIGQUIT,mais je m'en moque\n"); uid_t cuid; /* creator's user id */
}
main(){ gid_t cgid; /* creator's group id */
signal(SIGINT, trait_sigint);
signal(SIGQUIT, trait_sigquit); mode_t mode; /* access modes */
sleep(120);
print("je meurs de ma belle mort\n"); } ushort_t seq; /* slot usage sequence number */

key_t key; /* key */

};

II31 17 http://lsc.univ-evry.fr/~mallem II31 18 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Reception de message:
5.1 Messages sous UNIX int msgrcv( int msgid, struct msgbuf *buf, int nboctets, long mtype , int msgflg);

msgrcv() permet, partir d'un nom interne(msgid), de pratiquer l'opration de reception d'un message de
5.1.1 Caractristiques des messages sous UNIX nboctets dans la structure buf selon les modalits fixes dans msgflg. Mtype contient le type du message
- Flots de donnes formats(type, donnes) , reu.
- Envoys dans une FIFO connue par le rdacteur et par le lecteur,
- La FIFO est identifie par une cl (entier long), La structure suivante reprsente l'entte d'un message :
- La FIFO est reprsente par une entre dans la table des descripteurs de fichiers, struct msgbuf
- Les fonctions d'envoi et de reception de messages permettent de synchroniser les rdacteur et { long int mtype; //type du message (PID en gnral)
lecteur. char *mtext [1];
}

msgsrcv() renvoi le nbre d'octets reus si succs et -1 sinon

Contrle de message:
5.1.2 Fonctions d'accs : int msgctl( int msgid, int cmd, struct msgid_ds *sbuf);

Les fichiers suivants sont inclure : msgctl() permet, partir d'un nom interne(msgid), de pratiquer l'opration de contrle d'une file
#include <sysy/types.h> message selon le mode prcis dans cmd. Le compte rendu de cette action se trouve dans sbuf.
#include <sysy/ipc.h>
#include <sysy/msg.h> La structure struct msgid_ds contient le descripteur de la file de messages (UID, GID, permissions,
taille, PID du crateur, PID du dernier utilisateur)
Cration d'une FIFO de messages:
int msgget( key_t key, int msgflg); msgctl() renvoi 0 si succs et -1 sinon

msgget() permet, en donnant un nom externe, de rcuprer le nom interne d'une file de messages aprs
cration ventuelle si elle n'existait pas;

Envoi de message:
int msgsnd( int msgid, struct msgbuf *buf, int nboctets, int msgflg); 5.2 Mmoire partage sous UNIX

msgsnd() permet, partir d'un nom interne(msgid), de pratiquer l'opration d'envoi d'un message de 5.2.1 Fonctions systme et structures associes permettant l'utilisation des
nboctets dans la structure buf selon les modalits fixes dans msgflg. segments de mmoire partageables sous unix
La structure suivante reprsente l'entte d'un message :
Struct msgbuf Un segment de mmoire partageable peut tre simultanment attach (en fait incorpor) l'espace
{ long int mtype; //type du message (PID en gnral) d'adresses virtuelles de plusieurs processus.
char *mtext [1];
} Il peut galement tre incorpor plusieurs fois, mais des adresses virtuelles diffrentes, dans l'espace
d'adresse d'un processus.
msgsnd() renvoi 0 si succs et -1 sinon

II31 19 http://lsc.univ-evry.fr/~mallem II31 20 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

5.2.2 structure shmid_ds associe chaque segment partageable


Attachement d'une mmoire partage :
void *shmat( int shmid, void *shmaddr, int shmflg);
struct shmid_ds {
Une fois cr, un segment partageable peut tre attach l'espace d'adresses virtuelles d'un processus par
struct ipc_perm shm_perm; /* operation permissions*/
la fonction shmat() condition d'avoir les droits d'accs ncessaires.
Le segment peut tre attach une adresse virtuelle donne ou un emplacement disponible quelconque
int shm_segsz; /* size of segment in bytes */
Lorsqu'il est attach l'espace d'adresses virtuelles d'un processus, ce dernier peut y lire ou y crire s'il
pid_t shm_lpid; /* pid of last shmop */
possde les droits d'accs correspondants.
Un mme segment partageable peut tre attach plusieurs fois des adresses diffrentes dans l'espace
pid_t shm_cpid; /* pid of creator */
d'adresses virtuelles d'un processus.
shmatt_t shm_nattch; /* current # attached */
Dtachement d'une mmoire partage :
int shmdt(caddr_t *addr);
time_t shm_atime; /* last shmat time */
Il peut en tre dtach (enlev de l'espace d'adresses virtuelles) en utilisant la fonction shmdt().
time_t shm_dtime; /* last shmdt time */

time_t shm_ctime; /* last change time */


}; 5.3 Smaphores UNIX

5.3.1 Caractristiques des smaphores UNIX


Fonctionnalit identique aux smaphores de Dijkstra
5.2.3 Fonctions associes aux segment de mmoire partageable : Paquet de smaphores (nombre choisi par l'utilisateur)
un paquet est dsign par un un identifiant (entier de type key_t)
Les fichiers suivants sont inclure : un smaphore d'un paquet est identifi par son numro
#include <sysy/types.h> un seul appel systme mais avec diffrentes options :
#include <sysy/ipc.h> V avec augmentation du compteur choisie par l'utilisateur
#include <sysy/shm.h> (non limite a +1)
P avec diminution du compteur choisie par l'utilisateur
Cration d'une mmoire partage : (non limites -1 )
int shmget( key_t key, u_int size, u_int flags); option NOWAIT (permet de retourner immdiatement en cas de blocage)
Z (permet a un processus d'attendre que le compteur soit 0
Avant toute utilisation, un segment de mmoire partageable doit tre cr par la fonction shmget(). Possibilit de consulter et de modifier le compteur tout instant
Dispositions pour ragir un signal
Partant d'un nom externe key, cette fonction restitue un nom interne, qui peut tre celui d'un segment Dispositions pour ragir la destruction d'un processus
existant ou celui d'un segment cr cette occasion.
IPC_PRIVATE permet d'obtenir un nouveau segment.

Le processus crateur dfinit les droits d'accs et la taille du segment en octets. 5.3.2 structure de donnes associe un groupe de smaphore

struct semid_ds {
struct ipc_perm sem_perm; /* operation permission */
Contrle d'une mmoire partage :
struct sem *sem_base; /* ptr to first sema. in set*/
int shmctl( int shmid, int cmd , struct shmid_ds *buf);
ushort_t sem_nsems; /* # of semaphores in set */
time_t sem_otime; /* last semop time */
la fonction shmctl() permet de procder des oprations de contrle :
time_t sem_ctime; /* last change time *
};
rcupration ou modification du propritaire,
modification des droits d'accs, ou
Structure de donnes associe un semaphore:
destruction du segment partageable qui autrement subsiste jusqu' la prochaine rinitialisation du
systme.
struct sem {
ushort_t semval; /* semaphore text map address */
Cette fonction peut aussi tre utilise par les autres processus pour obtenir divers renseignements sur un
pid_t sempid; /* pid of last operation */
segment partageable.
ushort_t semncnt; /* # awaiting semval > cval */
ushort_t semzcnt; /* # awaiting semval = 0 */
};

II31 21 http://lsc.univ-evry.fr/~mallem II31 22 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

6. Sujets des TDs


5.3.3 Fonctions d'accs :
TD 1 : Le systme de gestion de fichiers
Les fichiers suivants sont inclure :
#include <sysy/types.h>
#include <sysy/ipc.h> But : L'objet de ce TD est l'tude des primitives de gestion de fichiers par le systme Unix
#include <sysy/sem.h>
Cration de smaphore : Prrequis :Une connaissance du langage C et des fonctions d'entre/sortie de la bibliothque est requise.
int semget( key_t key, int nsems, int semflg);

semget() permet, en donnant un nom externe, de rcuprer le nom interne d'un paquet de smaphores Exercice 1 : Soit l'arborescence de fichiers suivante :
aprs cration ventuelle s'il n'existait pas;
/
Liste des groupes : root :root
IPC_PRIVATE peut tre utilis pour obtenir un paquet de smaphores inexistant auparavant. prof : prof1 drwxr-xr-x
etudiant:user1,user2,user3
tp : user1,user2
home
ami:user1,user3
root :root
Manipulation de smaphore: drwxr-xr-x
int semop( int semid, struct sembuf *sops, u_int nsops);

semop() permet, partir d'un nom interne, de pratiquer les oprations P,V; prof1 user1 user2 user3
prof1 :prof user1 :etudiant user2 :etudiant user3 :etudiant
drwx------ drwxr-xr-x drwx------ drwx------
struct sembuf
{ bin sources divers
unsigned short int sem_num; /* semaphore number */ user1 :tp user1 :etudiant user1 :ami
short int sem_op; /* semaphore operation */ drwxrwx--- drwxr-xr-x drwxr-x---
short int sem_flg; /* operation flag */
}; tp1 a.out C C++ music.mp3 video.avi
user1 :tp user1 :etudiant user1 :etudiant user1 :etudiant user1 :etudiant user1 :etudiant
-rwxr-xr-x -rwxr--r-- drwxr-xr-x drwxr-x--- -rw-r--r-- -rw-r--r--

Consultation de smaphore : tp1.c p2.c p1.cpp p2.cpp


int semctl( int semid, int semnum, int cmd, union semun { int val, user1 :etudiant user1 :etudiant user1 :etudiant user1 :etudiant
struct semid_ds *buf, u_short *array,} arg ); -rw-r--r-- -rw-r----- -rw-r--r-- -rw-r--r--
Remplir les cases vides du tableau ci-dessous par "oui" si la commande est possible pour l'utilisateur indiqu et
semctl() permet , partir d'un nom interne, d'affecter les diffrentes valeurs relatives un smaphore ou
par "non" sinon.
au contraire de les rcuprer .
Code Commande shell prof1 user2 user3
C1 ls /export/home/user1/bin
C2 /export/home/user1/bin/tp1
C3 ls /export/home/user1/sources/C
C4 ls /export/home/user1/sources/C/tp1.c
C5 more /export/home/user1/sources/C/tp1.c
C6 ls /export/home/user1/sources/C/p2.c
C7 more ls /export/home/user1/sources/C/p2.c
C8 ls /export/home/user1/sources/C++
C9 ls /export/home/user1/sources/C++/p2.cpp
C10 more /export/home/user1/sources/C++/p2.cpp
C11 ls /export/home/user1/divers
C12 ls /export/home/user1/divers/music.mp3
C13 ls /export/home/user1/divers/video.avi

Exercice 2 :

Ecrire la fonction getchar1() qui renvoie un caractre lu sur l'entre standard, ou la constante EOF de fin de
fichier.
Ecrire une version bufferise de getchar2().

II31 23 http://lsc.univ-evry.fr/~mallem II31 24 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Exercice 3 : TD 2 : Les primitives de gestion de processus

Ecrire un programme qui affiche en clair le type du fichier demand(rpertoire, fichier ordinaire, ) ainsi que But :
ses protections(lecture, criture et excution). L'objet de ce TD est l'tude des primitives de gestion de processus par le systme Unix

Prrequis :
Exercice 4 : Une matrise de la notion de primitive systme et la pratique des processus en Shell sont requises.

Ecrire une commande similaire ls qui liste les noms des fichiers contenus dans le rpertoire dont le nom est Exercice 1 :
pass en paramtre de votre commande. Celle-ci devra avoir la syntaxe suivante : a) Ecrire un programme C o le processus pre cre n processus fils. Chaque fils affiche son PID et son
PPID(PID de son pre) et se termine en renvoyant un entier qui reprsente son rang dans la famille. Le pre
Liste repertoire attend chacun de ses fils en affichant pour chacun son PID et son code de retour.

b)Soit le programme suivant :


void main(void) {
for(i=0 ; i<n ; i++) pid=fork() ;
}
Donner le relation entre n du a) et p (nombre de processus).

Exercice 2 :
Donner le diagramme base de fonctions systme de gestion de processus(fork, exec, wait,exit) permettant de
raliser les commandes shell suivantes :

$ ls ; who | sort ;

Exercice 3 :
Ecrire un programme qui ralise la commande $ ls > /dev/null en :
- lanant la commande ls sur un rpertoire pass en paramtre,
- redirigeant la sortie standard de ls sur /dev/null,
- affichant le temps pris par la commande ls.

TDs 3 & 4 : Les primitives de gestion de pipe et de signaux

But :
L'objet de ce TD est l'tude des primitives de communication inter processus via un pipe par le systme Unix .

Prrequis :
Une matrise des primitives systme de gestion de processus et celles de gestion de fichiers est requise.

Exercice 1 :
Le programme suivant donne un exemple de communication par pipe entre un processus et son fils:

#include <unistd.h>
void main(void) {
int tube[2]; char message[50];
pipe(tube);
switch(fork()) {
case 0 : close(tube[0]);
write(tube[1],"message du fils",15);
close(tube[1]);
break;
default : close(tube[1]);

II31 25 http://lsc.univ-evry.fr/~mallem II31 26 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

read(tube[0],message,15); Exercice 1 :
message[20]=0; Ecrire un programme C o le pre cre une file de messages et N fils. Chaque fils envoie au pre, de faon
printf("Message lu par le pere : %s\n",message); continue, des messages de type 1, suivi de son PID et du texte de la requte. Le pre reoit ces messages et
close(tube[0]);}} rpond en envoyant des messages dont le type est le PID dun fils suivi de la rponse la question du fils.
Modifier ce programme de faon ce que le processus pre cre filtre pour son fils parmi les caractres qu'il lit Chaque fils reoit les messages et les affiche. La cl de la FIFO est fournie sur la ligne de commande. La fin de
, sur l'entre standard, les lettres miniscules. les lettres ainsi filtres sont transmises au fils par un pipe. Le fils les tous les processus est ralise par linterception, par le pre, de SIGINT et met fin ses fils et se termine aussi.
lit du pipe et les place dans un tableau afin de les afficher sur sa sortie standard. Si un fils intercepte SIGINT, il en informe son pre en lui envoyant SIGUSR1.

Exercice 2 :Ecrire un programme C permettant dengendrer un rdacteur et 2 lecteurs dans un pipe nomm Exercice 2 :
fifo. Le rdacteur est indpendant des 2 lecteurs, en revanche les 2 lecteurs sont pre et fils.
Eclater le programme prcdent en 2, de manire ce que les processus deviennent indpendants et apporter
chaque programme les modifications ncessaires. La cl de la FIFO est fournie sur la ligne de commande.
Exercice 3 :Ecrire un programme compos de 2 processus, un pre et son fils. Le fils doit excuter une
fonction "traite()" toutes les secondes. Le pere demande au fils , au bout d'une minute de s'arrter. Quand le fils TDs 6 & 7 : Les primitives de gestion des smaphores et de la mmoire partage
s'arrte , le pre s'arrte aussi.
But :
Exercice 4 :La fonction C mkfifo()(section 3C du manuel en ligne) permet de crer un tube nomm, c'est a dire
L'objet de ce TD est l'tude des primitives de communication inter processus via les smaphores et la mmoire
un tube de communication analogue a celui cre par l'appel systme pipe(), mais caractris par un chemin
partage par le systme Unix .
d'accs(au mme titre qu'un fichier logique).
Commenter les fonctions suivantes et dcrire le rsultat de leur excution. Prrequis :
#include <sys/fcntl.h>
#include <sys/stat.h> Une matrise des primitives systme de gestion de processus et celles de gestion de fichiers est requise.
#include <stdio.h>
#define TAILLEMAX 50 Exercice 1 :
Ecrire deux programmes C :
int creer_tube(void) { Le 1er est celui du producteur et consommateur de donnes dans une mmoire partage. Ce programme cre une
return mkfifo("essai-tube",S_IRWXU|S_IRWXG|S_IRWXO); } mmoire partage, linitialise avec les valeurs de lindice dune boucle(allant de 0 N-1) et se met en course
avec un autre consommateur pour lire le contenu de la mmoire partage. Le 1er processus dtruit la mmoire
void detruire_tube(void) { partage et se termine la rception dun signal quelconque.
unlink("essai-tube"); } Le 2nd programme est celui de cet autre consommateur.
Proposez une solution sans utilisation de smaphores.
void lecture(void) {
int tube,longueur; Exercice 2 :Ecrire les fonctions suivantes :
char message[50]; -int creatsem(key_t cle) qui permet de crer un smaphore partir dune cl numrique cle et qui renvoie le
tube=open("essai-tube",O_RDONLY); N interne du smaphore ou 1 si erreur.
longueur=read(tube,message,30); -void opsem(int semid, int op) qui ralise lopration op (P ou V) sur le smaphore semid .
message[longueur]='\0'; -void P(int semid) et void V(int semid) qui font appel la fonction opsem().
printf("%d a lu le message\n\t\t%s\n",getpid(), message) ;
close(tube); Exercice 3 :Ecrire deux programmes C :
}
Le 1er correspond au producteur dans une mmoire partage de 2 Kmots. Ce producteur initialise chaque mot (4
void ecriture(void) {
octets) de la mmoire partage avec la valeur de lindice de la boucle dinitialisation. Aprs celle-ci le
int tube;
producteur devient consommateur en lisant et en affichant le contenu de la mmoire partage. Le producteur
char message[50];
dtruit la mmoire partage lors de la rception dun signal quelconque (1 31) et met fin son excution.
sprintf(message,"processus %d ",getpid());
Le 2nd programme joue le rle de consommateur ds linstant o le la production des donnes dans la mmoire
tube=open("essai-tube",O_WRONLY);
partage est termine. Il lit et affiche le contenu de la mmoire partage et se termine.
write(tube,message,strlen(message ));
close(tube);
Exercice 4 :
}
Ecrire et tester un programme lecteur.c et un programme ecrivain.c pour tester les fonctions lecture() et criture() a) Ecrire un programme C o le pre et le fils manipulent deux variables X et Y implants dans une mmoire
en lanant simultanment plusieurs lecteurs et plusieurs crivains. partage. X et Y sont initialiss 1.
Le pre excute 10 fois les instructions X=X+1 ; Y=Y+1 ;
TD 5 : Les primitives de gestion des files de messages Le fils excute galement 10 fois : X=2*X ; Y=2*Y ;

Les oprations excutes par ces 2 processus doivent tre atomiques. Les valeurs de X et Y sont identiques tout
But : instant.
L'objet de ce TD est l'tude des primitives de communication inter processus via les files de messages par le
systme Unix . b)Modifier le programme prcdent de faon ce que le fils cre un autre fils qui lit 1 fois les variables X et Y
et se termine.
Prrequis :
Une matrise des primitives systme de gestion de processus et celles de gestion de fichiers est requise.

II31 27 http://lsc.univ-evry.fr/~mallem II31 28 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Universite d'Evry
IUP Sces et Technologies GEII
TP2 II31 - Unix
7. Sujets des TPs Sujet : Gestion des processus
Universite d'Evry
IUP Sces et Technologies GEII
TP1 II31 PARTIE A : Creation et synchronisation de processus
Le programme "fork.c" se trouvant dans le repertoire :
Sujet : Gestion de fichiers ens-unix $ /export/home/mallem/cours/ii31/processus
permet d'afficher les messages du pere et des fils qu'il cree.
PARTIE A :
Le repertoire : /export/home/mallem/ii31/1Fichiers Question 0 :
contient des fichiers : La compilation du programme "fork.c" est obtenue par la commande :
- entete (.h), $ cc fork.c -o fork
- des executables qui permettent d'afficher en clair le type du fichier L'execution de "fork" est realisee par la commande :
demande(repertoire, ordinaire, ...), ainsi que les protections(lecture, $ ./fork Commenter ce qui se passe.
ecriture, execution)- (stat et stat2), Question 1 :
- des executables qui permettent d'afficher les noms des fichiers contenus Modifier le programme fork.c de maniere a ce que chaque processus
dans le repertoire dont le nom est passe comme parametre a ce fils se terminera toujours avant son pere. Commenter ce qui se passe.
programme(dir, dir2, dir3). Vous pouvez constater le resultat attendu en executant le fichier
"fork2".
Question 2 :
Question 1: Modifier le programme fork2.c, que vous aurez ecrit, de maniere a ce
que chaque processus fils se terminera toujours avant son pere et que le
Ecrire un programme en C qui prend en compte le type et les fils renverra un code(1: pour fils1 et 2: pour fils2) au pere que celui-ci
protections du fichier, pass comme argument, et de les faire afficher en affichera. Commenter ce qui se passe.
clair comme le fait la commande SHELL "ls -l". Vous pouvez constater le resultat attendu en executant le fichier
Vous pouvez constater le resultat attendu en executant les fichiers "fork3".
"stat" et "stat2". ___________________________________________________________
Les Fonctions a utiliser
Question 2 : exit( i )
termine un processus, i est un octet renvoy dans un 'int' au processus
Ecrire une commande similaire ls qui liste les noms ainsi que leur pre.
numros d'inodes des fichiers contenus dans le rpertoire dont le nom est wait( &etat )
pass en paramtre de votre commande. Celle-ci devra avoir la syntaxe met le processus en attente de la fin de l'un de ses processus fils .
suivante : La valeur de retour de 'wait' est le numro du processus fils venant de se
terminer.
$ dir repertoire Lorsqu'il n'y a plus (ou pas) de processus fils attendre, la fonction
wait renvoie -1.
Chaque fois qu'un fils se termine le processus pre sort de 'wait', et il
Vous pouvez constater le resultat attendu en executant les fichiers peut consulter 'etat' pour obtenir des informations
"dir" et "dir2". sur le fils qui vient de se terminer.
'etat' est un pointeur sur un mot de deux octets. L'octet de poids fort
Question 3 : contient la valeur renvoye par le fils ( i de la
Il s'agit d'afficher pour chacun des fichiers, obtenus par le fonction exit( i )), et l'octet de poids faible contient 0.
programme prcdent, son type et ses permissions. En cas de terminaison anormale du processus fils, l'octet de poids
Vous pouvez constater le resultat attendu en executant le fichier faible contient la valeur du signal reu par le fils.
"dir3". Cette valeur est augmente de 80 en hexadcimal (128 dcimal), si ce signal
Attention : ne fonctionne que si le chemin du fichier est complet! a entrain la sauvegarde de l'image
Dans le repertoire courant, cela fonctionne, par contre s'il s'agit d'un mmoire du processus dans un fichier 'core'.
autre repertoire il faut prevoir le chemin complet menant aux fichiers de ________________________________________________
celui-ci. PARTIE B : Creation et transformation de processus
Ecrire un programme C "exec-ls.c" qui permet de remplacer le code du
processus fils par celui de la commande 'ls'. La sortie de 'ls' est
redirige dans le vide (/dev/null).
L'execution du programme suivant donne une idee du resultat attendu :
$ ./exec-ls
Question 1 :
Modifier ce programme de maniere a ce que le resultat de 'ls'
s'affichera a l'ecran.

II31 29 http://lsc.univ-evry.fr/~mallem II31 30 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Vous pouvez constater le resultat attendu en executant le fichier Universite d'Evry


"exec-ls2". IUP Sces et Technologies GEII
Question 2 ( preparation du TP3): TP3 II31 - Unix
Ecrire un programme qui realise la commande $ ps -a | more:
Vous pouvez constater le resultat attendu en executant le fichier Sujet : Communication entre processus par pipe
"ps-more".

Le programme "pipe.c" se trouvant dans le repertoire :


ens-unix $ /export/home/mallem/cours/ii31/pipes/
permet au fils de communiquer a son pere un message par le biais d'un pipe.
La compilation de ce programme est obtenue par la commande :
$ cc pipe.c -o pipe

L'execution de "pipe" est realisee par la commande :


$ ./pipe

Question 1 :
Que se passe t il si l'instruction close(p[1]) est supprimee du code
du fils et pourquoi ?

Question 2 :
Que se passe t il si l'instruction close(p[1]) est supprimee du code
du pere et pourquoi?

Question 3 :
Modifier le programme pipe.c de maniere a ce que le pere filtre pour
son fils parmi les caracteres qu'il lit , sur l'entree standard , les
lettres miniscules. Les lettres ainsi filtrees sont transmises au fils par
un pipe. Le fils les lit du pipe et les transmet son fils(petit fils) via
un deuxieme pipe. Le petit fils les lit du pipe et les place dans un
tableau afin de les afficher sur sa sortie standard.

Vous pouvez constater le resultat attendu en executant le fichier


"pipe2".

Question 4 :

Ecrire un programme C permettant d'engendrer un rdacteur et 1


lecteur dans un pipe nomm "fifo". Le rdacteur est independant du lecteur.
Le redacteur ecrit la chaine "abbccc", trois fois, dans le pipe et le
lecteur se charge de vider le pipe.

Vous pouvez constater le resultat attendu en executant le fichier


"fifo1".

Question 5 :

Ecrire un programme C permettant d'engendrer un rdacteur et 2


lecteurs dans un pipe nomm "fifo". Le rdacteur est independant des 2
lecteurs. Ces derniers sont pere et fils.
Le redacteur ecrit la chaine "abbccc", trois fois, dans le pipe et les
lecteurs se chargent de vider le pipe de faon asynchrone en faisant
afficher leur rsultat respectif.
Vous pouvez constater le resultat attendu en executant le fichier "fifo2".
Question 6 (facultative):
Ecrire un programme qui ralise la commande shell :
$ ps -e | more
_______________________________________

II31 31 http://lsc.univ-evry.fr/~mallem II31 32 http://lsc.univ-evry.fr/~mallem


Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04

Universite d'Evry Universite d'Evry


IUP Sces et Technologies GEII IUP Sces et Technologies GEII
TP4 II31 - Unix TP5 II31 - Unix
Sujet : Communication et synchronisation entre processus par pipe et
signaux Sujet : PARTIE A : Communication entre processus par messsages

Le programme "signal.c" se trouvant dans le repertoire :


ens-unix $ /export/home2/mallem/cours/ii31/pipes/
permet de generer 2 processus un pere et son fils. Le fils execute une
fonction traite() Le programme "messecr_lec.c" se trouvant dans le repertoire :
toutes les secondes et s'arrete quand le pere le lui demande. ens-unix $ /export/home/mallem/cours/ii31/ipc/messages/
Le pere s'endort pendant un certain temps. A son reveil, il demande au fils permet a un processus d'envoyer des messages dans une FIFO, de les relire
de se terminer. et les afficher .
La compilation de ce programme est obtenue par la commande :
$ cc signal.c -o signal L'execution de ce programme est realise par la commande :
Son execution est realisee par la commande : bash $ ./messecr_lec CLE texte_message
$ ./signal
Question 1 :
Pendant combien de temps le pere s'endort il et comment fait il pour Question A.1 :
reveiller le fils ? Creer 2 programmes l'un pour l'ecrivain(messecr.c) et un autre pour
Question 2 : le lecteur(messlec.c)
A quoi servent les fonctions alarm() et pause()? sur une meme FIFO de messages.
Question 3 : L'execution de ces programmes est realise par les commandes :
Que se passe t il si la fonction signal()est supprimee du code du bash $ ./messecr CLE texte_message && ./messlec CLE &
fils et pourquoi ?
Question 4 : Question A.2 :
Que se passe t il si la fonction signal()est supprimee du code du Que se passe t il si l'on execute les commandes suivantes et
pere et pourquoi ? pourquoi:
Question 5 : bash $ ./messecr_lec CLE texte_message && ./messlec CLE &
Modifier le programme signal.c de faon a ce que le fils ecrive dans
le pipe a chaque
reception du signal SIGALRM le message "abcd". PARTIE B : Communication entre processus par memoire partage
Le pere a son reveil recupere le message du fils du pipe et met fin au
fils. Sujet :
Vous pouvez constater le resultat attendu en executant le fichier
"signal2".
Question 6 : Ecrire un programme C dans lequel le fils recherche dans le Les programmes "initsem.c" et "produc.c"se trouvant dans le
fichier "annuaire" repertoire :
toutes les lignes commenant par le caractre, passe en parametre, les ens-unix $ /export/home/mallem/cours/ii31/ipc/semaphores/
stockent dans un pipe anonyme. permettent de creer des semaphores et un producteur de donnees.
Le contenu du pipe est l par le pre qui l'affiche aprs l'avoir l. Ce dernier stocke les donnees dans une memoire partagee.
Le pre envoie ensuite le signal SIGUSR1 au fils. Ce dernier accuse L'execution de ces programmes est realisee par les commandes :
rception en affichant le message :
"Fils de PID a bien recu SIGUSR1 du pere de PID ". $ ./initsem CLE_SEM_PROD CLE_SEM_CONSOM
Vous pouvez constater le resultat attendu en executant le fichier
"signal3 caractere". Question B.1 :
Question 7 : Modifier le programme precedent de maniere ce que le fils Creer le programme("consom.c") du consommateur de ces donnees.
fasse la recherche d'un abonne dans "annuaire" a chaque fois que le pere le L'execution des programmes du producteur et du consommateur est
lui demande. Ce dernier le fait 3 fois en envoyant au fils, a chaque fois realisee par les commandes :
le SIGUSR2. A chaque fois que le fils a stocke le resultat de sa recherche $ ./produc CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE &
dans le pipe, il en informe son pere en lui envoyant SIGUSR1. Apres 3 ./comsom CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE
iterations le pere envoie a son fils SIGUSR1 pour lui demander de se
terminer et se termine aussi. Dans l'iteration i+1 le fils recherche les Question B.2 :
abonnes dont le nom commencent par argv[1][0]+1. Que se passe t il si l'on execute les commandes suivantes et pourquoi

$ ./produc CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE ;


./comsom CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE

ou
$ ./produc CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE &&
./comsom CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE

II31 33 http://lsc.univ-evry.fr/~mallem II31 34 http://lsc.univ-evry.fr/~mallem