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
una manina???

ps ovviamente il programma è scritto per linux

[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]

Originariamente inviato da 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);
}

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 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]

Originariamente inviato da 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 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 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

[VegetaSSJ5]

Originariamente inviato da Gica78R

Sono un idiota 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 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

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...

[Gica78R]

Originariamente inviato da VegetaSSJ5

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...

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...Killed

In pratica funziona, ma non capisco da dove viene il messaggio "Killed" subito dopo "Premi enter..."
C'e' qualcosa che ci sfugge
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]

Originariamente inviato da Gica78R

...

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

[Gica78R]

Originariamente inviato da sirus

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]

Originariamente inviato da Gica78R

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 ma quando l'ultimo figlio "ammazza" il padre (primo processo) il sistema in qualche modo crasha non so il motivo però mi piacerebbe capirlo

[gottardi_davide]

Originariamente inviato da 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
una manina???

ps ovviamente il programma è scritto per linux

Sborone!

[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);