[C] - signal e wait

[cn73]

Continuo a rompere le scatole sull'IPC :D

Supponiamo di avere un processo padre P che genera 2 gruppi di processi figli logicamente diversi, diciamo gruppo f1 e f2.

Se a un certo punto P riceve un segnale USR1 deve:
1)Inviare un segnale di terminazione ai processi del gruppo f1 e ASPETTARE che terminino...
2)Inviare un segnale di terminazione immediata ai processi del gruppo f2.

Inizialmente avevo pensato di usare due array che tenessero traccia del pid dei due gruppi.

Ma, almeno per il gruppo f2 non è detto che esistano dei processi (potrbbero esser già terminati).

Possono venirmi utile la syscall setpgid e getpgid ??

[ilsensine]

Mi sembra sensato.
Ti consiglio di gestire i due gruppi di processi da due processi leader di gruppo (v. man setsid)

[cn73]

Stavo pensando al primo gruppo di processi figli... devo necessariamente usare un vettore, perchè dovrà esserci una sequenza di

kill (f1)
wait(f1)
...
kill (fn)
wait(fn)


Non posso mandare una kill a tutti e poi una wait per tutti!Perciò poi avendo terminato tutti gli fi, potrei lanciare una
kill(0) che mi ucciderebbe immediatamente tutti i restanti eventuali processi figli (che hanno lo stesso group id del padre!)

fila? :D

[ilsensine]

Io articolerei il problema in questo modo:

- Per ogni program group crei un leader. Questo leader tiene un contatore di quanti processi sono aggiunti al gruppo.
- Ogni volta che crei un processo, questo si deve spostare sul corretto gruppo di appartenenza, e manda un segnale (ad es. SIGURS1) al group leader. Il group leader, in corrispondenza di un SIGUSR1, incrementa il contatore dei processi.
- Quando devi terminare i processi di un certo gruppo, mandi un segnale (ad es. SIGQUIT) a tutti i processi del gruppo, tramite killpg. Questo segnale deve essere ignorato dal group leader, e intercettato dagli altri processi. Ogni volta che un processo muore, prima di morire manda un segnale (ad es. SIGUSR2) al group leader (non so se cambiando gruppo, la morte di un processo generi automaticamente un SIGCHLD al group leader -- non ho mai provato, ma dovrebbe essere così).
- Il group leader intercetta i SIGUSR2 (o SIGCHLD, se funziona come penso) e decrementa il contatore dei processi
- Quando il contatore dei processi arriva a 0, notifica con un segnale al processo padre che tutti i processi del gruppo sono terminati.

E' solo una via, potresti pensare altre soluzioni.

[cn73]

Allora, vediamo di spiegare meglio il problema: il primo gruppo di processi è composto da un numero n noto a priori. Tutti gli n processi di qusto gruppo vivono dall'inizio alla fine della vita del padre.
Prima di morire il padre deve killarli (attendendo la loro terminazione).
POI deve killare eventuali altri processi servi (appartenenti al gruppo 2) senza attenderne la terminazione.

Il discorso dei leader di gruppo è interessante, ma non credo debba rientrare nella soluzione di questo progettino, non essendo stato tema di studio.

[ilsensine]

Originariamente inviato da cn73
Allora, vediamo di spiegare meglio il problema: il primo gruppo di processi è composto da un numero n noto a priori. Tutti gli n processi di qusto gruppo vivono dall'inizio alla fine della vita del padre.
Prima di morire il padre deve killarli (attendendo la loro terminazione).
Questo puoi farlo semplicemente tramite un contatore di processi come ti dicevo. Tieni conto che quando un figlio muore, un SIGCHLD viene inviato al padre (il mio dubbio riguardava il group leader). Questo segnale è normalmente ignorato, puoi intercettarlo per decrementare il contatore di processi ancora "vivi". Quindi non devi far altro che aspettare che arrivi a 0.

POI deve killare eventuali altri processi servi (appartenenti al gruppo 2) senza attenderne la terminazione.
Se per "altri" intendi "tutti", killpg fa al caso tuo. Altrimenti devi per forza tenere un array dei processi da terminare.

Il discorso dei leader di gruppo è interessante, ma non credo debba rientrare nella soluzione di questo progettino, non essendo stato tema di studio.
Non credo che possa esistere un gruppo di processi senza un leader...forse mi sbaglio, ma mi sembra una pessima idea.

[cn73]

Il fatto è che sono tutti figli! Praticamente i primi n processi figli sono lanciati all'inizio e poi possono richiedere al Padre un servizio, e questo si forcherà per fornirglielo... Quindi io non ho solo n processi figli da killare, ma quegli n + eventuali altri servi.

Il termine "gruppo" l'ho usato io, non o se questo problema può rientrare in questa categoria.

for (i=0; i<n; i++) {
printf("Invio segnale di terminazione al processo%d \n",pid_processi[i]);
kill(pid_processii[i],SIGKILL);
printf("Attendo che %d termini \n",pid_processi[i]);
waitpid(pid_processi[i],&status,0);
}

free(pid_processi);
*pid_processi=NULL;

//killa eventuali altri figli(i servi) IMMEDIATAMENTE
kill(0,SIGKILL); // mi killa tutti i processi con lo stesso PGID del padre, ovvero tutti i figli restanti!

[ilsensine]

Originariamente inviato da cn73

for (i=0; i<n; i++) {
printf("Invio segnale di terminazione al processo%d \n",pid_processi[i]);
kill(pid_processii[i],SIGKILL);
printf("Attendo che %d termini \n",pid_processi[i]);
waitpid(pid_processi[i],&status,0);
}


L'efficienza è un'opinione? ;)

for (i=0; i<n; i++) kill(pid_processi[i],SIGKILL);
for (i=0; i<n; i++) waitpid(pid_processi[i],&status,0);


Attento qui:


kill(0,SIGKILL); // mi killa tutti i processi con lo stesso PGID del padre, ovvero tutti i figli restanti!
...compreso il padre.

[cn73]

for (i=0; i<n; i++) kill(pid_processi[i],SIGKILL);

for (i=0; i<n; i++) waitpid(pid_processi[i],&status,0);


Ma facendo così non rischio che un processo termini prima che il padre si metta in wait??


compreso il padre....


mmm questo devo verificarlo...da manuale non è chiarissimo:

ProcessID Specifies a decimal integer representing a process or process
group to be signaled.

If PID is a positive value, the kill command sends the process whose process ID is equal to the PID. If the PID value is 0, the kill command sends the signal to all processes having
a process group ID equal to the process group ID of the sender. Thesignal is not sent to processes with a PID of 0 or 1.
If the PID is-1, the kill command sends the signal to all processes owned by theeffective user of the sender. The signal is not sent to processeswith a PID of 0 or 1.
If it is a negative number but not -1, the killcommand sends the signal to all processes that have a process groupID equal to the absolute value of the PID.


A questo proposito...come vengono assegnati gli id di gruppo?? Non è che rischio di killare altri processi che non centrano nulla??

[ilsensine]

Originariamente inviato da cn73
Ma facendo così non rischio che un processo termini prima che il padre si metta in wait??
Probabilmente (visto tra l'altro che usi SIGKILL). Dov'è il problema?


mmm questo devo verificarlo...da manuale non è chiarissimo
Il gpid di un processo padre dovrebbe essere il proprio pid, di default (dipende da come viene lanciato, credo). Quello di un figlio dovrebbe essere quello del padre, se non lo cambi o non usi setsid dal figlio.


A questo proposito...come vengono assegnati gli id di gruppo?? Non è che rischio di killare altri processi che non centrano nulla??
Ho incontrato un simile bug con kde. L'ho risolto eseguendo manualmente setsid all'inizio del processo padre.

[cn73]

ovvero se mi metto in wait di un processo che non esiste più non ho problemi? se ne accorge ed esce ? :)


Ho incontrato un simile bug con kde. L'ho risolto eseguendo manualmente setsid all'inizio del processo padre


Ma chi sei?? :eek:

[cn73]

Si il gpid del padre è settato al pid...perciò non posso usare una kill(0) o una kill (-pid) perchè morirebbe anche il Padre...
Approfondisco il discorso sul setsid...

[cn73]

Fatto! ;)
Per il secondo gruppo di processi creo un gruppo con un leader), tengo traccia del gpid del gruppo e poi li killo con killpg :)

#include<stdio.h>
#include<errno.h>
#include<signal.h>
#include<sys/types.h>

main (){
int i,f;

pid_t *pid_processi=NULL;
char *fil_num;
int sid;

pid_processi=(int *)malloc(3*sizeof(pid_t));
fil_num=(char *)malloc(2*sizeof(char));

printf("PADRE! gpid: %d -- pid: %d -- sid: %d\n",getpgid(),getpid(),getsid());

for (i=0; i < 3; i++) {
f = pid_processi[i] = fork();
sprintf(fil_num,"%d",i);
printf("fil_num: %d ",i,fil_num);
if (f == 0)
execl("./s","./s",NULL); //n e fil_num sono gl iargomenti passati al filosofo
}

for (i=0; i < 3; i++)
//printf("pid_processi[%d]: %d ",i,pid_processi[i]);
printf("\n");

f = sid = fork();
if (f==0){
setsid(); //nuovo gruppo!
printf("SERVO LEADER! gpid: %d -- pid: %d -- sid: %d\n",getpgid(),getpid(),getsid());
i=0;
while(i< 3) {
i++;
f = fork();
if (f==0){ //ereditano i gpgid del leader
printf("SERVO! gpid: %d -- pid: %d -- sid: %d\n",getpgid(),getpid(),getsid());
system("sleep 5");
exit(0);
}
}
exit(0);
}
for (i=0; i < 3; i++)
kill(pid_processi[i],SIGKILL);

for (i=0; i < 3; i++)
wait(pid_processi[i]);

printf("PADRE! gpid: %d -- pid: %d -- sid: %d\n",getpgid(),getpid(),getsid());

killpg(sid,SIGKILL);

printf("termino anche io!\n");
exit(0);

}