1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
| #include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
main()
{
/* Initialisation des variables. */
...
int pid;
int tube[2];
struct sembuf operation;
char chaine1[1 /* Un tableau pour un seul élément ??? */], chaine2[2];
...
while (1)
{
...
/* Création d'un ensemble de sémaphores. */
semid = semget( (key_t)999, 1, IPC_CREAT | IPC_EXCL | 0660 );
/*
Concernant la clef, t'as le droit d'utiliser la macro
IPC_PRIVATE qui te garantit l'unicité de ton ipc
Inutile si l'ipc doit être accessible par 2 programmes distincts
mais utile dans le cas d'une communication père-fils...
*/
/* Initialisation d'un Mutex. */
semctl( semid, 0, SETVAL, 1);
...
pid = fork();
if(pid == -1){ perror("fork"); exit(1); }
else if(pid == 0) /* Le fils. */
{
/* Réquisition du Mutex. */
operation.sem_num = 0;
operation.sem_op = -1;
operation.sem_flg = 0;
semop (semid, &operation, 1);
/*
Me semble que si tu veux être sûr que le père attende l'écriture du fils,
tu ne dois faire descendre le sémaphore à 0 que quand
le fils est prêt, c'est à dire qu'il a déjà écrit...
*/
...
/* Libération du Mutex. */
operation.sem_num = 0;
operation.sem_op = 1;
operation.sem_flg = 0;
semop (semid, &operation, 1);
/* Le père tuera le mutex. */
/* tube anonyme créé par le fils. */
pipe(tube);
/* Le fils écrit au père. */
close(tube[0]);
write(tube[1], "A", 1);
write(tube[1], "BC", 2);
// Attention tu n'as pas écrit le '\0'...
close(tube[1]);
exit(0);
}
else /* Le père. */
{
printf("\nLe pere.\n");
/* Attente de l'écriture du fils par le père, contrôlée par la Mutex. */
operation.sem_num = 0;
operation.sem_op = 0;
operation.sem_flg = 0;
semop (semid, &operation, 1);
close(tube[1]);
/* Le père lit le fils. */
read(tube[0], chaine1, 1);
printf("%s\n", chaine1);
read(tube[0], chaine2, 2);
printf("%s\n", chaine2);
/* Attention, le fils a écrit {'A'} puis {'A', 'B'}. Nulle part il n'a écrit le '\0'. Donc tes chaines 1 et 2 n'en sont pas => crash probable ... */
close(tube[0]);
wait();/* Le père attend la fin du fils, de plus, le tube anonyme fils-père est définitivement détruit. */
/* Destruction du Mutex créé par le fils. */
semctl( semid, 0, IPC_RMID, 0);
}//fin du père
}//fin du while
exit(0);
} |
Partager