|
| Precedente :: Successivo |
| Autore |
Messaggio |
Smjert
Dio maturo
Registrato: 01/04/06 17:19
Messaggi: 1619
Residenza: Perso nella rete
|
 Inviato: 16 Nov 2007 11:29 Oggetto: * Gestione Processi C su Linux |
 |
|
In questi giorni sto tentando di imparare il C.
Prima di tutto sto leggendo una guida che spiega come sono strutturate le cose in linux, sono arrivato ad un esempio di gestione dei processi con la funzione fork() ed exec() e non riesco a capire una cosa.
Questo è il codice d'esempio:
| Codice: | #include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
/* Spawn a child process running a new program. PROGRAM is the name
of the program to run; the path will be searched for this program.
ARG_LIST is a NULL-terminated list of character strings to be
passed as the program?s argument list. Returns the process ID of
the spawned process. */
int spawn (char* program, char** arg_list)
{
pid_t child_pid;
/* Duplicate this process. */
child_pid = fork ();
if (child_pid != 0)
/* This is the parent process. */
return child_pid;
else {
/* Now execute PROGRAM, searching for it in the path. */
execvp (program, arg_list);
/* The execvp function returns only if an error occurs. */
fprintf (stderr, ?an error occurred in execvp\n?);
abort ();
}
}
int main ()
{
/* The argument list to pass to the ?ls? command. */
char* arg_list[] = {
?ls?, /* argv[0], the name of the program. */
?-l?,
?/?,
NULL /* The argument list must end with a NULL. */
};
/* Spawn a child process running the ?ls? command. Ignore the
returned child process ID. */
spawn (?ls?, arg_list);
printf (?done with main program\n?);
return 0;
} |
Da quanto ho capito se si duplica un processo, sia il processo padre che il figlio eseguono lo stesso codice e che l'unico modo per capire se in dato momento il codice lo sta eseguendo il padre o il figlio è controllare il pid, se è 0 è il figlio altrimenti il padre.
Ora.. nel codice viene chiamata la funzione spawn dove viene duplicato il processo.. e c'è un controllo, se il pid non è 0 allora è il processo padre che esegue il codice, se sì fai ritorna il pid del processo figlio altrimenti sei nel processo figlio, esegui quindi il comando "ls".
L'altrimenti mi è chiaro ma nn mi è chiara la prima parte dell'if... cioè se siamo nel processo padre c'è un return del pid del figlio, quindi si esce dalla funzione spawn e nessun comando viene eseguito (viene fatto printf e return 0).
Mi pare che non abbia senso o sbaglio? Non dovrebbe ciclare finchè non si è fatto partire il programma? |
|
| Top |
|
 |
SverX
Supervisor Macchinisti
Registrato: 25/03/02 11:16
Messaggi: 11568
Residenza: Tokelau
|
| Inviato: 16 Nov 2007 11:40 Oggetto: |
|
|
non capisco la tua domanda: hai letto di execvp() sul web?
| Citazione: | | Le funzioni execl(), execlp(), execle(), execvl(), execvp() sostituiscono il processo corrente con un nuovo processo. |
quindi immagina che il programma lanciato diventino due, ed uno viene sostituito da
... |
|
| Top |
|
|
Smjert
Dio maturo
Registrato: 01/04/06 17:19
Messaggi: 1619
Residenza: Perso nella rete
|
| Inviato: 16 Nov 2007 11:45 Oggetto: |
|
|
Sì questo l'ho capito 
Mi sono un po' incasinato con la domanda..
Quello che non capisco è: se lo scopo di questo codice è quello di eseguire il comando ls, sapendo che il codice dopo la chiamata alla funzione fork() può essere eseguito aribitrariamente dal processo padre o dal figlio, perchè nel caso in cui siamo ancora nel processo padre (prima parte dell'if (child_pid !=0) ) ritorna il pid del figlio, esce e non fa nulla?
In questo modo non ha eseguito ls.. e il programma/codice non ha fatto il suo compito o sbaglio? |
|
| Top |
|
|
SverX
Supervisor Macchinisti
Registrato: 25/03/02 11:16
Messaggi: 11568
Residenza: Tokelau
|
| Inviato: 16 Nov 2007 12:18 Oggetto: |
|
|
| Smjert ha scritto: | Sì questo l'ho capito
Mi sono un po' incasinato con la domanda..
Quello che non capisco è: se lo scopo di questo codice è quello di eseguire il comando ls, sapendo che il codice dopo la chiamata alla funzione fork() può essere eseguito aribitrariamente dal processo padre o dal figlio, perchè nel caso in cui siamo ancora nel processo padre (prima parte dell'if (child_pid !=0) ) ritorna il pid del figlio, esce e non fa nulla?
In questo modo non ha eseguito ls.. e il programma/codice non ha fatto il suo compito o sbaglio? |
sbagli... nel senso che funziona così: il programma lanciato entra in memoria e diventa un processo. Quando arriva alla fork questo processo diventa DUE processi, uno poi continua 'regolarmente' mentre l'altro diventa un altro processo, un
l' IF serve a distinguere il padre dal figlio...
http://it.wikipedia.org/wiki/Fork_(programmazione)... fork() su wikipedia per completezza... |
|
| Top |
|
|
Smjert
Dio maturo
Registrato: 01/04/06 17:19
Messaggi: 1619
Residenza: Perso nella rete
|
| Inviato: 16 Nov 2007 17:03 Oggetto: |
|
|
Il viaggio in treno verso casa mi ha rischiarato le idee.
Sapevo che venivano generati due processi uguali ma non riuscivo comunque a pensare in quella prospettiva.
è come dici tu ma c'è da aggiungere che.. il processo padre esegue l'if? il pid non è 0 e quindi fa quel return e il padre giustamente va in uscita.
Il figlio intanto esegue il comando, il padre però c'è ancora (anche se non fa niente) e non si chiude finchè il figlio non finisce il lavoro. |
|
| Top |
|
|
SverX
Supervisor Macchinisti
Registrato: 25/03/02 11:16
Messaggi: 11568
Residenza: Tokelau
|
| Inviato: 19 Nov 2007 11:27 Oggetto: |
|
|
| Smjert ha scritto: | | Il figlio intanto esegue il comando, il padre però c'è ancora (anche se non fa niente) e non si chiude finchè il figlio non finisce il lavoro. |
non mi è chiaro perchè, secondo te, il padre aspetterebbe la fine del figlio... a me sembra che, avvenuta la fork(), il padre stampi una riga in output e finisca... il figlio ha vita propria... |
|
| Top |
|
|
disturbatore
Semidio
Registrato: 25/05/07 14:14
Messaggi: 278
Residenza: pianeta in corso di distruzione
|
| Inviato: 19 Nov 2007 21:16 Oggetto: |
 |
|
L'obiettivo basico della fork non è quello di mantenere collegati i due processi, ma di permettere che un processo possa avviarne un altro, il quale essendo una copia del primo ne ha le stesse caratteristiche (librerie, variabili, ecc.) me è del tutto indipendente.
In altre parole, il padre crea il figlio e poi prosegue per la propria strada (il proprio flusso di istruzioni), il figlio non appena viene creato parte pure lui per la propria strada.
Ma, tu dirai (scusa, ti metto pure le parole in bocca), se sono lo stesso processo come possono eseguire codice diverso (come dicevi nel tuo primo post)? Qui viene d'aiuto il PID, e il test che ne verifica il valore; semplificando un po', la "if" è l'unica istruzione che i due condividono, e che serve proprio per diversificare l'esecuzione dei due processi.
Nell'esempio riportato, per il padre la "if" serve per ritornare all'istruzione dopo la fork e proseguire con la propria elaborazione (la printf e l'uscita), per il figlio serve per iniziare la propria elaborazione, formalmente distinta da quella del padre sia per il contenuto elaborativo sia per l'indipendenza reciproca (nessuno dei due è condizionato dal comportamento dell'altro).
Spero di aver contribuito a chiarire la questione, anche se con qualche ripetizione... |
|
| Top |
|
|
|
|
Non puoi inserire nuovi argomenti
Non puoi rispondere a nessun argomento
Non puoi modificare i tuoi messaggi
Non puoi cancellare i tuoi messaggi
Non puoi votare nei sondaggi
|
|
FAQ
Cerca
Lista utenti
Gruppi
Registrati
Profilo
Messaggi privati
Log in
