prima esperiena (solo didattica) di programmazione con i processi

[sirus]

ciao a tutti, oggi ho provato a fare un semplicissimo programmino che creasse 5 processi e successivamente per mezzo dell'ultimo processo permette di killare tutti gli altri ;)
questo è quanto ho prodotto...

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>

#define MAX_PROC 5

int main() {
/* definizione delle variabili locali al main */
pid_t pid;
pid_t vettproc[MAX_PROC];
unsigned int numproc = 0;
unsigned int counter;

/* creazione dei processi figlio */
printf("Creating...\n");
while(numproc < MAX_PROC) {
pid = fork();
if(pid != 0) {
while(1);
} else {
vettproc[numproc] = getppid();
}
printf("PROCESSO: %d\tPID: %d\tPID_PADRE: %d\n",numproc,getpid(),getppid());
getchar();
numproc++;
}

/* controllo processi in esecuzione */
system("ps");

/* ciclo di cancellazione */
printf("\nKilling...\n");
do {
numproc--;
printf("PROCESSO: %d\tPID: %d\n",numproc,vettproc[numproc]);
kill(vettproc[numproc],SIGKILL);
getchar();
} while(numproc >= 0);
return(0);
}

tuttavia quando il 5° processo creato va a killare il padre di tutti, l'applicazione produce effetti incontrollati...un volta è partito X una volta è sclerato il Terminale :( insomma...non so come fare a far uccidere la radice al figlio ultimo :cry:
una manina???

ps ovviamente il programma è scritto per linux :sofico:

[Gica78R]

Stranamente, eseguendo il tuo programma cosi' com' e', sul mio sistema si ferma alla creazione del primo figlio... e non va piu' avanti!

Boh, non ho guardato bene il codice; magari piu' tardi ti fo' sapere...

Ciao

[VegetaSSJ5]

secondo me è sbagliato un po' di tutto. il mio consiglio è di far rimanere attivo il padre (di tutti) e ogni figlio appena creato esegue una wait() e poi il padre li uccide tutti. nel modo in cui lo fai tu ogni figlio crea un altro figlio e quandi uccidi un parente si vengono a creare dei processi zombie.#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>

#define MAX_PROC 5

int main() {
/* definizione delle variabili locali al main */
pid_t pid;
pid_t vettproc[MAX_PROC];
unsigned int numproc = 0;
unsigned int counter;

/* creazione dei processi figlio */
printf("Creating...\n");
while(numproc < MAX_PROC) {
pid = fork();
if(pid != 0) {
vettproc[numproc]= pid;
} else {
printf("PROCESSO: %d\tPID: %d\tPID_PADRE: %d\n", numproc, getpid(), getppid());
wait();
}
getchar();
numproc++;
}

/* controllo processi in esecuzione */
system("ps");

/* ciclo di cancellazione */
printf("\nKilling...\n");
do {
numproc--;
printf("PROCESSO: %d\tPID: %d\n", numproc, vettproc[numproc]);
kill(vettproc[numproc],SIGKILL);
getchar();
} while(numproc >= 0);
return(0);
}

[sirus]

secondo me è sbagliato un po' di tutto. il mio consiglio è di far rimanere attivo il padre (di tutti) e ogni figlio appena creato esegue una wait() e poi il padre li uccide tutti. nel modo in cui lo fai tu ogni figlio crea un altro figlio e quandi uccidi un parente si vengono a creare dei processi zombie.#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>

#define MAX_PROC 5

int main() {
/* definizione delle variabili locali al main */
pid_t pid;
pid_t vettproc[MAX_PROC];
unsigned int numproc = 0;
unsigned int counter;

/* creazione dei processi figlio */
printf("Creating...\n");
while(numproc < MAX_PROC) {
pid = fork();
if(pid != 0) {
vettproc[numproc]= pid;
} else {
printf("PROCESSO: %d\tPID: %d\tPID_PADRE: %d\n", numproc, getpid(), getppid());
wait();
}
getchar();
numproc++;
}

/* controllo processi in esecuzione */
system("ps");

/* ciclo di cancellazione */
printf("\nKilling...\n");
do {
numproc--;
printf("PROCESSO: %d\tPID: %d\n", numproc, vettproc[numproc]);
kill(vettproc[numproc],SIGKILL);
getchar();
} while(numproc >= 0);
return(0);
}
il problema sta nel fatto che io devo con l'ultimo figlio uccidere il padre :( lo so il problema è strano (non è un mio compito...) sto aiutando una persona :muro: il programma è puramente a scopo dimostrativo ;)
per fare in modo che il discendente più giovane (passatemi il termine) possa uccidere il vecchio antenato forse bisogna fare in modo che il processo principale diventi il più giovane no???

[VegetaSSJ5]

fammi capire... l'ultimo figlio deve uccidere solo il padre oppure deve uccidere anche tutti gli altri figli? oppure non ha importanza chi uccida gli altri figli ma è importante che gli altri figli vengano uccisi dall'ultimo?

[Gica78R]

Stranamente, eseguendo il tuo programma cosi' com' e', sul mio sistema si ferma alla creazione del primo figlio... e non va piu' avanti!
Sono un idiota :doh: non avevo visto la getchar()...
Comunque, a guardarlo il programma non sembra scorretto, non credo ci siano problemi se un processo uccide quello che lo ha generato :confused: L'unica cosa e' che, cosi' facendo, l'ultimo figlio (quello che esegue tutte le 'kill'), viene automaticamente ereditato dal processo init. Pero' le kill utilizzano come argomento i pid memorizzati (che coincidono sempre con i processi da terminare), quindi non capisco per quale stracacchio di motivo (nel mio caso) terminato il programma, al primo tasto che premo mi si riavvia X :confused:

[VegetaSSJ5]

Sono un idiota :doh: non avevo visto la getchar()...
Comunque, a guardarlo il programma non sembra scorretto, non credo ci siano problemi se un processo uccide quello che lo ha generato :confused: L'unica cosa e' che, cosi' facendo, l'ultimo figlio (quello che esegue tutte le 'kill'), viene automaticamente ereditato dal processo init. Pero' le kill utilizzano come argomento i pid memorizzati (che coincidono sempre con i processi da terminare), quindi non capisco per quale stracacchio di motivo (nel mio caso) terminato il programma, al primo tasto che premo mi si riavvia X :confused:
il fatto è che per come è scritto il programma non è detto che sia l'ultimo figlio ad uccidere gli altri. il ciclo while di killing viene eseguito da tutti i figli quindi secondo me lì viene fuori un bordello con tutte quelle uccisioni... :D

[Gica78R]

il fatto è che per come è scritto il programma non è detto che sia l'ultimo figlio ad uccidere gli altri. il ciclo while di killing viene eseguito da tutti i figli quindi secondo me lì viene fuori un bordello con tutte quelle uccisioni... :D
Sicuro? A me sembra che ogni processo, a partire dal primo, crei un figlio e poi entri in un ciclo infinito... cioe':
Il primo processo esegue la fork() e poi esamina il valore ritornato; se e' positivo, allora si sta eseguendo ancora il processo iniziale, percio' si entra nel while(1); se e' zero, allora ci si trova nel figlio appena creato. Questo figlio effettua alcune operazioni, poi rientra nel ciclo while di creazione e rifa' la stessa cosa, cioe': crea un nuovo figlio, e poi entra nel while(1), mentre il figlio appena creato ripete il ciclo di creazione...

processo_0: crea processo_1 e poi cicla all'infinito;
processo_1: crea processo_2 e poi cicla all'infinito;
processo_2: crea processo_3 e poi cicla all'infinito;
.................
.................
ecc. ecc.
L' ultimo figlio creato non rientra nel ciclo di creazione perche' numproc=MAXPROC, percio' non crea nessun altro figlio; pero' invia SIGKILL a tutti gli "antenati", che in quel momento sono tutti in loop nel while(1).

Boh! Io ne ho fatto una versione semplificata: un processo crea un figlio soltanto, quindi entra in un loop infinito; il figlio "uccide" il padre; sembra andare bene, ma non capisco l'output. Vi riporto il listato:
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include "./connessioni/semafori.h"


int main(void)
{
int mutex;
key_t chiave=500;

setvbuf(stdout,NULL,_IONBF,0);
pid_t pid;

mutex=SemCreate(chiave,1,0660,NULL);
SemSet(mutex,0,0,1,NULL);
SemWait(mutex,0,NULL);

pid=fork();

if (pid>0)
{
printf("Padre: %d, loop infinito...\n",getpid());
SemSignal(mutex,0,NULL);
while (1)
;
return 0;
}

else
{
if (pid==0)
{
setvbuf(stdout,NULL,_IONBF,0);
SemWait(mutex,0,NULL);
printf("Figlio: %d, tenta di terminare %d\n",getpid(),getppid());
if (kill(getppid(),SIGKILL)<0)
perror("Kill error");
else printf("Kill success\n");
printf("Premi enter...");
getchar();
SemSignal(mutex,0,NULL);
return 0;
}
else
perror("Fork error");
}
return 0;
}
mentre questo e' l'output:
[gianluca@p3 test]$ ./sirus2
Padre: 4122, loop infinito...
Figlio: 4123, tenta di terminare 4122
Kill success
Premi enter...KilledIn pratica funziona, ma non capisco da dove viene il messaggio "Killed" subito dopo "Premi enter..."
C'e' qualcosa che ci sfugge :boh:
Ah, ignorate le funzioni Sem***, sono mie funzioni per usare semafori, cosi' che si esegua sicuramente prima la parte if (pid>0). Le setvbuf servono per non bufferizzare l'output.

[sirus]

...

no problem ho risolto il fattaccio...
il padre di tuttodeve rimanere in esecuzione quindi a programma modificato niente crash ;) o messaggi strani

[Gica78R]

no problem ho risolto il fattaccio...
il padre di tuttodeve rimanere in esecuzione quindi a programma modificato niente crash ;) o messaggi strani
Ma e' una regola? Per quanto ne so, non dovrebbero esserci problemi a terminare un particolare processo con un segnale inviatogli da un qualsiasi altro processo, figlio o non figlio che sia... Se per caso e' una regola, sapresti indicarmi qualche documento che ne parla? Sto anch'io realizzando una piccola applicazione multiprocesso, funziona correttamente ed e' il padre di tutti i processi a coordinare i figli e a gestirne avvio e terminazione, quindi non ci sono inconvenienti, pero' mi piacerebbe approfondire... :)


Grazie,

Gica

[sirus]

Ma e' una regola? Per quanto ne so, non dovrebbero esserci problemi a terminare un particolare processo con un segnale inviatogli da un qualsiasi altro processo, figlio o non figlio che sia... Se per caso e' una regola, sapresti indicarmi qualche documento che ne parla? Sto anch'io realizzando una piccola applicazione multiprocesso, funziona correttamente ed e' il padre di tutti i processi a coordinare i figli e a gestirne avvio e terminazione, quindi non ci sono inconvenienti, pero' mi piacerebbe approfondire... :)


Grazie,

Gica

non so che regola ci stia dietro :boh: ma quando l'ultimo figlio "ammazza" il padre (primo processo) il sistema in qualche modo crasha :doh: non so il motivo :cry: però mi piacerebbe capirlo

[gottardi_davide]

ciao a tutti, oggi ho provato a fare un semplicissimo programmino che creasse 5 processi e successivamente per mezzo dell'ultimo processo permette di killare tutti gli altri ;)
questo è quanto ho prodotto...

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>

#define MAX_PROC 5

int main() {
/* definizione delle variabili locali al main */
pid_t pid;
pid_t vettproc[MAX_PROC];
unsigned int numproc = 0;
unsigned int counter;

/* creazione dei processi figlio */
printf("Creating...\n");
while(numproc < MAX_PROC) {
pid = fork();
if(pid != 0) {
while(1);
} else {
vettproc[numproc] = getppid();
}
printf("PROCESSO: %d\tPID: %d\tPID_PADRE: %d\n",numproc,getpid(),getppid());
getchar();
numproc++;
}

/* controllo processi in esecuzione */
system("ps");

/* ciclo di cancellazione */
printf("\nKilling...\n");
do {
numproc--;
printf("PROCESSO: %d\tPID: %d\n",numproc,vettproc[numproc]);
kill(vettproc[numproc],SIGKILL);
getchar();
} while(numproc >= 0);
return(0);
}

tuttavia quando il 5° processo creato va a killare il padre di tutti, l'applicazione produce effetti incontrollati...un volta è partito X una volta è sclerato il Terminale :( insomma...non so come fare a far uccidere la radice al figlio ultimo :cry:
una manina???

ps ovviamente il programma è scritto per linux :sofico:

Sborone! :D

[Qu@ker]

Direi che il problema e' qui:

do {
numproc--;
printf("PROCESSO: %d\tPID: %d\n",numproc,vettproc[numproc]);
kill(vettproc[numproc],SIGKILL);
getchar();
} while(numproc >= 0);