tp2-correction

Licence Informatique Système d’exploitation
Multi-Processing - premiers pas
Exercice 1 : Exécution concurrente des processus père et fils
Ecrire un programme qui crée un fils.
3Le père affiche : « Je suis le père mon PID est ... et mon PPID est ... ».
3Le fils affiche : « Je suis le fils mon PID est ... et mon PPID est ... ».
Rajouter l’appel à la primitive sleep pour voir les exécutions possibles :
1. Le fils se termine avant le père,
2. Le père se termine avant le fils.
#i nc lude <s t d i o . h>
#i nc lude <u n i s t d . h>
void main ( )
{
pid_t p ;
p=f o r k ( ) ;
switch ( p )
{
case ( 0 ) :
// s l e e p ( 1 5 ) ;
p r i n t f ( "Le f i l s pid e s t =%d e t mon ppid e s t=%d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ) ;
break ;
case (−1) :
// s l e e p (1 5) ;
p r i n t f ( " E rr e ur f o r k \n" ) ;
break ;
def aul t :
p r i n t f ( "Le p e re p id e s t =%d e t mon ppid e s t=%d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ) ;
}
p r i n t f ( " Fin du p r o c e s s u s %d\ n" , g e t p i d ( ) ) ;
}
Exercice 2 : Héritage des attributs et copies des variables
Reprendre le programme ci-dessus et compléter en affichant l’uid, le gid, et le contenu d’une variable x
initialisée à 2 (avant le fork) et modifié selon x+3 par le fils et selon x*5 par le père.
#include<u n i s t d . h>
#include<s t d i o . h>
void main ( )
{
pid_t p ;
int x = 2 ;
p=f o r k ( ) ;
switch ( p )
{
case ( 0 ) :
x = x + 3 ;
p r i n t f ( "Le f i l s pid=%d ppi d=%d ui d=%d g i d=%d x=%d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ,
g e t u i d ( ) ,
g e t g i d ( ) ,
Université de Pau et des Pays de l’Adour

Licence Informatique Système d’exploitation
x ) ;
break ;
cas e (−1) :
p r i n t f ( " E rr e ur f o r k \n" ) ;
break ;
def aul t :
x=x ∗5 ;
p r i n t f ( "Le f i l s p id=%d p pi d=%d ui d=%d g i d=%d x=%d\ n" , g e t p i d ( ) ,
g e t p p i d ( ) ,
g e t u i d ( ) ,
g e t g i d ( ) ,
x ) ;
}
p r i n t f ( " Fin programme\n" ) ;
}
Exercice 3 : Cas particulier des descripteurs de fichiers
Ecrire un programme qui ouvre un fichier nommé « toto », en lecture et écriture, dont le contenu est la suite
123456789. Le programme fork ensuite ; le fils écrit ab dans le fichier ensuite il s’endort et il lit 2 caractères ; le
père s’endort, lit 2 caractères et écrit AB.
/∗Le d e s c r i p t e u r n e s t pa s d u p l iq u é ca r i l e s t s t o ck é dans l a t b l de s f i c h i e r s ∗/
/∗e t non dans l a t b l des d e s c r i p t e u r ( p ro pre à chaq ue pcs ) ∗/
#include<s t d i o . h>
#include<f c n t l . h>
#include<u n i s t d . h>
#include<s y s / s t a t . h>
#include<s y s / t y p e s . h>
void main ( )
{
pid_t p ;
char c h a i n e [ 3 ] ;
int desc ;
d e sc=open ( " t o t o " ,O_RDWR, 0 ) ;
p=f o r k ( ) ;
switch ( p )
{
case ( 0 ) :
p r i n t f ( "Le f i l s PID=%d PPID=%d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ) ;
read ( desc , chai n e , 2 ) ;
c h a i n e [ 2 ] = ’ \0 ’ ;
p r i n t f ( " c h a i n e l u e pa r l e f i l s %s \n " , c h a i n e ) ;
s l e e p ( 1 0 ) ;
c l o s e ( d e s c ) ;
break ;
case (−1) :
p r i n t f ( " E rr e ur f o r k \n" ) ;
break ;
default :
p r i n t f ( " Le p è r e V al eur de r e t o u r du f o r k=%d\n" , p ) ;
p r i n t f ( "Le p ère PID=%d PPID=%d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ) ;
s l e e p ( 3 ) ;
read ( desc , chai n e , 2 ) ;
c h a i n e [ 2 ] = ’ \0 ’ ;
p r i n t f ( " c h a i n e l u e p ar l e p è r e %s \ n" , c h a i n e ) ;
s l e e p ( 2 0 ) ;
w r i t e ( des c , "AB" , 2 ) ;
c l o s e ( d e s c ) ;
}
p r i n t f ( " Fin du Programme\n" ) ;
}
Exercice 4 : Synchronisation des processus père et fils par le wait
Ecrire un programme qui crée un fils et affiche, pour chacun des processus le PID et PPID dans l’ordre :
Fils puis père si l’on passe « synchro » comme paramètre, exécution des processus dans l’ordre décidé par
l’ordonnanceur sinon.
Université de Pau et des Pays de l’Adour

Licence Informatique Système d’exploitation
#include<u n i s t d . h>
#include<s t d i o . h>
#include<e r r n o . h>
#include<s t r i n g . h>
void main ( int argc , char ∗argv [ ] )
{
pid_t p i d ;
int s t a t u t ;
i f ( ( a r g c ==2) && ( s trcmp ( a rg v [ 1 ] , " s y nc h ro " ) ! = 0 ) )
{
p r i n t f ( " La ncer l e programme avec un argument : \ n" ) ;
p r i n t f ( "\ t Synchr o pour a f f i c h e r l e f i l s p uis l e pere \n" ) ;
p r i n t f ( "Aucun arg ument s i n o n . \n" ) ;
}
e l s e
{
sy stem ( " c l e a r " ) ;
p r i n t f ( "\n\ t \ t \tGENERATION AUTOMATIQUE DE PROCESSUS\n\n" ) ;
pid = f o r k ( ) ;
switch ( p id )
{
cas e −1:
p e r r o r ( " e r r e u r f o r k : \ t " ) ;
break ;
cas e 0 :
s l e e p ( 1 ) ;
p r i n t f ( " f i l s PID : %d \ t PPID : %d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ) ;
break ;
def aul t :
i f ( ( a rgc==2) && ( strcmp ( a rgv [ 1 ] , " s yn ch ro " )==0))
{
wait (& s t a t u t ) ;
p r i n t f ( " p e r e PID : %d \ t PPID : %d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ) ;
}
e l s e
{
p r i n t f ( " p e r e PID : %d \ t PPID : %d\n" ,
g e t p i d ( ) ,
g e t p p i d ( ) ) ;
wait (& s t a t u t ) ; } /∗E v i t e r un p r o c e s s us z ombi e ∗/
}
p r i n t f ( " \n\ t F in du programme . PID : %d\ n" , g e t p i d ( ) ) ;
}
}
Exercice 5 : Attente et passage de paramètres
Ecrire un programme dont le fonctionnement est le suivant :Il lit sur la ligne de commande (utiliser argc
et argv) le nombre N de processus à créer. Il crée ces N processus en faisant N appels à fork (cf. plus loin la
tâche assignée à ces processus).Il se met en attente (appel à Pid_Fils = wait(&Etat)) de ces N processus fils et
visualise leur identité (Pid_Fils et valeur de Etat) au fur et à mesure de leurs terminaisons (Pour attendre la
fin de tous les fils, utiliser le fait que wait renvoie la valeur -1 quand il n’y a plus de processus fils à attendre).
Chacun des processus fils Pi exécute les instructions suivantes : il visualise son pid (getpid) et celui de son
père (getppid), puis il se met en attente pendant 2*i secondes (sleep (2*i)), et visualise la fin de l’attente, puis
se termine par exit (i).
#include<u n i s t d . h>
#include<s y s / w a it . h>
#include<s t d i o . h>
#include<s t d l i b . h>
#include<e r r n o . h>
#include<s t r i n g . h>
int main ( int argc , char ∗a rgv [ ] ) {
pid_t pid , p i d F i l s ;
int s t a t u t , i , i R e tu r n ;
Université de Pau et des Pays de l’Adour

Licence Informatique Système d’exploitation
int iNbProc ;
i f ( a r g c !=2 )
{
p r i n t f ( " La ncer l e programme avec un argument : \ n" ) ;
p r i n t f ( " \ t l e nombre de p r o c e s s u s f i l s a c r e e r \n" ) ;
}
e l s e
{
sy stem ( " c l e a r " ) ;
p r i n t f ( "\n\ t \ t \tATTENTE AUTOMATIQUE DE LA TERMINAISON DES FILS\n\n" ) ;
iNbProc = a t o i ( a rgv [ 1 ] ) ;
for ( i =0; i <iNbProc ; i ++)
{
pid = f o r k ( ) ;
i f ( pid==−1){
p e r r o r ( " C r ea t i on f i l s " ) ;
exit(−1);
}
e l s e i f ( p id !=0){
/∗code p ere ∗/
continue ;
}
e l s e {
/∗code f i l s ∗/
p i d F i l s=ge tpi d ( ) ;
f p r i n t f ( s t dout ,
" F i l s num:%d de pid %d e t de %d\n" , i ,
p i d F i l s ,
g e t p p i d ( ) ) ;
s l e e p ( 2∗i ) ;
f p r i n t f ( s t dout ,
" F i l s num:%d de pid %d e t j e me t er mi ne \n" , i ,
pidFils );
e x i t ( i ) ;
}
}
/∗Les f i l s s on t c r e es . Le pe re s e met en a t t e n t e ∗/
while (1)
{
iRetur n=wa it (& s t a t u t ) ;
i f ( iReturn==−1)
break ;/∗re t u r n −1 quand i l ne r e s t e p l u s de f i l s a a t t e n d r e ∗/
e l s e
{
/∗l a f o n c t i o n WEXITSTATUS r e t ou r n e l a v a l e u r t r an s mi se par l e e x i t ∗/
f p r i n t f ( s t dout ,
" Je s u i s l e p ere de pid %d e t mon f i l s de p id %d s e t ermin e a vec l e s t a t u t %d\n" ,
g e t p i d ( ) ,
iRetur n ,
WEXITSTATUS( s t a t u t ) ) ;
}
}
f p r i n t f ( s t dout ,
" Je s u i s l e p e r e de pid %d e t j e me termin e \n" ,
g e t p i d ( ) ) ;
}
return ( 0 ) ;
}
Exercice 6 : Recouvrement d’un processus,interpréteur
Ecrire un interpréteur simple de commandes externes (exemples ps, ls, gcc, ...).
#i nc lude <s t d i o . h>
#i nc lude <e r r n o . h>
#i nc lude <u n i s t d . h>
#i nc lude <s t r i n g . h>
void main ( int argc , char ∗argv [ ] )
{
pid_t p i d ;
int i , s t a t u t , a ;
char commande [ 1 0 ] ;
s t r c p y ( commande , " " ) ;
while ( strcmp ( commande , " e x i t " )!=0)
Université de Pau et des Pays de l’Adour

Licence Informatique Système d’exploitation
{
p r i n t f ( "$" ) ;
f f l u s h ( s t d i n ) ;
s c a n f ( "%s " , commande ) ;
pid = f o r k ( ) ;
switch ( p id )
{
case −1:
p e r r o r ( " e r r e u r de f o r k \n" ) ;
exit(−1);
case 0 :
p r i n t f ( "%s PPID = %d , PID = %d \n" ,
commande ,
g e t p p i d ( ) ,
g e t p i d ( ) ) ;
i f ( s tr cmp ( commande , " e x i t " ) ! = 0 )
e x e c l p ( commande , commande , NULL ) ;
p e r r o r ( " e x e c l p " ) ;
// i l ne f a u t p as que l e f i l s con t in ue
exit(−1);
default :
pid = wait (& s t a t u t ) ;
i f ( pid==−1)
p e r r o r ( " l e w ai t " ) ;
e l s e
p r i n t f ( " p r o c e s s u s zombi %d\n" , p id ) ;
}
}
p r i n t f ( "\n \ t tou t e st t er mi ne \n" ) ;
}
Université de Pau et des Pays de l’Adour