Bonjour à tous.

Je vous explique mon cas. Pour plusieurs raisons, j'ai le besoin mais aussi l'envie d'apprendre la programmation système en C sous LINUX. Je m'y suis mis plusieurs fois cette année mais là, depuis deux semaines, je peux y porter vraiment attention.

J'ai suivi le cours d'un professeur. Aujourd'hui j'ai un exercice BILAN on va dire. Mais je bloque sur certaines questions ou termes…

Donc je vous propose de vous montrer le code, dire ce qui ne va pas et j'espère que vous pourrez m'aider. Le code :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
 
#define DUREE_MAX   3
 
#define CHECK(sts,msg) if ((sts) == -1) { perror(msg); exit(sts); }
 
void Fils (int myPID, unsigned int consigne)
{
    unsigned int etat = 0;
int lol2 = getppid();
printf("lol2 = %d\n", lol2);
    do
    {
        printf("\nProcess n° %d (PID=%d) : Consigne = %d, Etat = %d",
               myPID, getpid(), consigne, etat);
        sleep(1 + rand() % DUREE_MAX);   // temps de réalisation d'un pas de consigne
        etat++;
    }while (etat < consigne);
    printf("\nProcess n° %d (PID=%d) INACTIF : Consigne %d ... atteinte",
			myPID, getpid(), consigne);
    printf("\n\t**********************************************************************\n");
}
 
void tuerLesFils(void)
{
    // Ce traitement est activé sur réception du signal SIGUSR1
    // Proposer une implémentation à base de thread
    // A compléter
}
 
void acquitterLesFils(void)
{
    // Gérer la fin des processus fils à base de la signalisation fils/père
    // A compléter
}
 
void creerFils(unsigned int consigne)
{
    int pid;
    static int myChild = 1;
 
    CHECK(pid=fork(),"Ne peut pas forker");
    if (pid == 0)
    {
        Fils (myChild, consigne);
        exit(consigne);
    }
    printf("\tProcessus de régulation n° %d (PID=%d) est actif\n", myChild, pid);
    printf("\t______________________________________________________________________\n");
    myChild++;
}
 
int main (int argc, char **argv)
{
	unsigned int myConsigne;
 
	sigset_t intmask;                                                   
        int sts;
 
	srand(time(NULL));
 
    printf("\tCe programme (incomplet) permet de lancer des processus de régulation\n");
    printf("\tChaque processus prend en paramètre une consigne saisie au clavier\n");
    printf("\t######################################################################\n");
 
// BLOQUER LE CONTROLE-C
	// Initialise et affecte le masque                                  
        sts = sigemptyset(&intmask);                                        
        CHECK(sts, "appel de sigemptyset");
        sts = sigaddset(&intmask, SIGINT); 
        CHECK(sts, "appel de sigaddset");
        // On interdit le control-C
        sts = sigprocmask(SIG_BLOCK, &intmask, NULL);
        CHECK(sts, "appel de sigprocmask");
	printf("\nATTENTION : Le CONTROLE-C est désactivé tout au long du programme\n\n");
	printf("\t######################################################################\n");
 
    tuerLesFils();
 
    while (1)
    {
        printf("\nDonnez une série de consignes de régulation (>0) (^D=fin) : ");
        if (scanf("%u", &myConsigne) != EOF) 
            creerFils(myConsigne);
        else 
            raise(SIGUSR1);
    }
 
    return EXIT_SUCCESS;
}
Donc c'est un programme qui s’exécute en boucle et lance des processus fils dits de régulation avec une consigne saisie au clavier. Ce programme ne gère par la terminaison des processus fils, ni la fin de programme. Nous considérerons également que les processus de régulation partagent une ressource critique. LE PROGRAMME EST DONC INCOMPLET.

Il y a donc plusieurs questions auxquelles il faut répondre.
La première demande de bloquer le CONTROLE-C dans le père et dans le fils. Les lignes que j'ai ajoutées (après // Blocage Controle-C) bloquent ce signal et ça fonctionne. Déjà ce bout de code vous paraît-il bien ?

Mon principal problème concerne les questions d'après. La deuxième question :

Rappeler quel est le signal généré par un processus lorsqu'il se termine, à destination de son processus père.

Compléter le processus père de façon à ce qu'il acquitte la terminaison d’un processus fils.

Déjà c'est super mal posé, j'ai l'impression. Je pensais à : envoyer le signal SIGCHLD au père quand le fils est fini et pour pas avoir de zombie, quand le père reçoit ce signal il fait un wait(3). Ça parait bon ? ^^

Et là vient le calvaire : La saisie de contrôle-D termine la saisie et provoque l’émission du signal SIGUSR1 vers le processus lui-même.
Compléter la fonction tuerLesFils() qui met en œuvre un thread qui se chargera d’attendre ce signal (pause()). Sur réception de SIGUSR1, le thread alors termine tous les processus fils en cours.


Je ne comprends pas du tout la question... et je ne sais pas du tout la mettre en œuvre

Merci d'avance à ceux qui pourront m'aider, et désolé de la taille du post.

Bonne journée,
Fuot.