Program Mat Ion Systeme Unix
Program Mat Ion Systeme Unix
Program Mat Ion Systeme Unix
06/09/04 Universit d'Evry-Val d'Essonne UFR Sciences & Technologies/IUP GEII 06/09/04
Bibliographie :
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.
Bloc 0
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 ;
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)
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)
#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.
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.
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.
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.
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 */
};
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];
}
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
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 */
};
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--
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().
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.
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.
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]);
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.
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.
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.
Question 4 :
Question 5 :
ou
$ ./produc CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE &&
./comsom CLE_SEM_PROD CLE_SEM_CONSOM CLE_MEM_PARTAGEE