Signaux et processus, synchronisation

Bonjour,

J'aurais voulu savoir qi vous pouviez m'aider dans la compréhension des processus et des signaux sous Unix à travers qq exemples.

1) J'ai le prog suivant:


Code :
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
int main (void) {
void fonc (int Sig);
int i;
for (i=1; i < NSIG; i++) signal (i, fonc);
for (i=1; i < NSIG; i++) kill (getpid(), i);
return 1;
}
void fonc (int Sig){
printf ("Recu signal %d\n", Sig);
signal (Sig, fonc);
}

Je dois repondre a la question: combien de fois s'affiche les message "reçu signal ..." et pourquoi?

J'aurais tendance à dire qu'il faille inverser les deux lignes des for pour d'abord envoyer les signaux et après les traiter avec la fonction fonc.
Est-ce correct?

2) J'ai un deuxieme prog:


Code :
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#define N 100000
int main (void) {
int ret_fork, Etat, i;
void fonc(int NumSig);
ret_fork= fork();
if (ret_fork == 0) {
kill(getppid(), SIGUSR1);
exit(1);
}
if (ret_fork > 0){
for (i=0; i<N ; i++); /* boucle exécutée N fois */
signal(SIGUSR1, fonc);
wait(&Etat);
}
return 0;
}
void fonc(int NumSig){
printf("Signal SIGUSR1 recu\n");
signal(NumSig, fonc);
}Le probleme est que je n'arrive pas a voir ce que fait ce programme et combien de lignes vont etre affichées apres son execution.

3) C'est sur fork avc le prog:


Code :
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(void) {
int ret_fork, Etat;
ret_fork = fork();
if( ret_fork == 0 ) {
fork();
printf("1-Pid %d fils de %d\n", getpid(), getppid());
exit(0);
} else {
printf("2-Pid %d fils de %d\n", getpid(), getppid());
wait(&Etat);
exit(0);
}
return 0;
}Est ce bien 3 lignes qui seront affichées par ce programme.
Apres ret_fork = fork(); deux processus executent la suite du code: le fils qui obtient 0 comme resultat du fork execute le premier if à l'interieur duquel on a de nouveau un fork donc deux processus vont executés le printf qui suit donc deux lignes. Puisle pere issu du premier ret_fork = fork();, execute ce qu'il y a dans le else car il a pour resultat du fork le numero de son fils donc pas 0 d'ou la troisieme ligne affichée ici. Donc au total on a trois lignes?

Est-ce correct?

Voila, si quelqu'un pouvait me corriger et m'expliquer mes erreurs et l'exemple 2 en particulier ce seait sympa car j'apprend seul unix donc c'est pas toujours facile...

D'autre part, j'avais aussi des questions sur la synchronisation.
J'essaye de resoudre qq exos pr m'entrainer mais je bloque sur celui la:

Le processus R doit écrire un message dès que l’un des processus P1 à P5 se termine.
Ordonnancement par quantum de temps. Tous les processus ont la même priorité. R ne
démarre pas le premier.

Variables partagées par tous les processus :
- un sémaphore S initialisé par : init(S,1)
- la variable NProc initialisée à 0

Programme exécuté par le processus R:
#define MAX 5
int main (void) {
while (NProc< MAX){
P(S);
...
printf(«Processus terminés :%d\n», NProc);
V(S);
};
}


Programme exécuté par les processus P1 à P5:
int main (void) {
P(S);
...
NProc= NProc + 1;
V(S);
}

On veut que R affiche un message chaque fois qu’un processus Pi se termine.

En fait, j'arrive pas à voir ce que fair R (même si je pense qu'il va y avoir un probleme) et où mettre un sémaphore pour remedier à ce probleme.

Voila, si vous pouviez m'expliquer tout cela, ce serait sympa.

A+