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