In generale può essere utile che i due processi eseguano del codice diverso

Transcript

1 System call FORK

2 P fork() ha l aspetto di una funzione C, in realtà è una system call, una chiamata al sistema operativo fork() P P Il processo P' è una copia di P esegue lo stesso codice e possiede una copia delle variabili di P In generale può essere utile che i due processi eseguano del codice diverso

3 main() { int sono_il_padre; <<codice iniziale>> Fork restituisce: 0 al processo figlio PID del figlio al processo padre sono_il_padre = fork(); if (sono_il_padre) { else { <<codice processo padre>> <<codice processo figlio>> All'atto della chiamata della fork esiste solo il processo padre, all'uscita esistono due processi, che eseguono l'assegnamento

4 Padre (PID = 520) fork() sono_il_padre = 0 sono_il_padre = 574 Padre Figlio (PID = 574)

5 Cose in comune e cose diverse nei due processi

6 main() { int sono_il_padre; int x; Il figlio eredita una copia delle variabili del padre x = 10; sono_il_padre = fork(); if (sono_il_padre) { /* codice padre */ x = x+1; printf( %d, x); else { /* codice figlio */ printf( %d, x);

7 Vera definizione di fork Per utilizzare la system call fork occorre includere due librerie: #include <sys/types.h> #include <unistd.h> prototipo della system call fork: pid_t fork(void);

8 Unica eccezione i descrittori dei file aperti: vengono condivisi Padre (PID = 520) x = 10 x == 10 x = x + 1 fork() x == 10 Padre Figlio (PID = 574) I due processi non possono passarsi dati attraverso le variabili

9 #include <sys/types.h> #include <unistd.h> #include <stdio.h> esempio main() { pid_t sono_il_padre = fork(); if( sono_il_padre = = (pid_t) 1 ) {fprintf(stderr, "fork fallita"); exit(1); else if (sono_il_padre = = 0) { /* processo figlio */ printf("il risultato di fork() nel figlio e' %d\n", sono_il_padre); printf("il pid del figlio e' %d\n", getpid()); printf("il pid del padre visto dal figlio e' %d\n", getppid()); else { /* processo padre */ printf("il risultato di fork() nel padre e' %d\n", sono_il_padre); printf("il pid del padre e' %d\n", getpid());

10 Processi generati e descrittori di file Padre (PID = 520) fork() int file_des = open("letters",o_rdwr); Padre Figlio (PID = 574) NB: i descrittori dei file SONO condivisi (eccezione)

11 main() { int fd = open("letters",o_rdwr); pid_t n; char c; Supponiamo che letters contenga 1 a b c d e f g n=fork(); if (!n){ else 3 sleep(10); 5 read(fd,&c,1); printf("\n %d: ho letto %c\n", getpid(), c); fflush(stdout); 2 { read(fd,&c,1); printf("\n %d: ho letto %c\n", getpid(), c); fflush(stdout); write(fd,"12345",5); printf("\n %d: ho scritto \n", getpid()); fflush(stdout); close(fd); a g 4

12 Fork e loop

13 In C posso realizzare cicli infiniti con un semplice for... for ( ; ; ) { <<codice>> for ( ; ; ) fork(); Orrore!!! È un epidemia!!!

14 Supponiamo di voler creare 5 processi Soluzione 1: for (i=0; i < 5; i++) { fork(); 30 Quanti processi crea? P 0 i = 0 fork() i = 1 fork() P 1 i = 1 fork() i = 2 P 3 i = 2 fork() i = 3 P 2 i = 2 fork() i = 1

15 Supponiamo di voler creare 5 processi Soluzione 2: for (i=0; i < 5; i++) { sono_il_padre = fork(); if (!sono_il_padre) { <<codice figlio>> i=5;

16 Struttura del demone (prima approssimazione) for ( ; ; ) { <<attendo richiesta>> sono_il_padre = fork(); if (!sono_il_padre) { <<elaboro richiesta>> exit(0); Ciclo controllato

17 #include <...> #include <sys/types.h> void proc(int i) { int n; printf("processo %d con pid %d\n", i, getpid()); fflush(stdout); for (n=0; n< ; n++); main() { int i; pid_t pid; Provare a fare + esecuzioni for(i=0;i<5;i++) if (fork() = = 0) { proc(i); exit(0); ; for(i=0;i<5;i++) { pid=wait(0); printf("terminato processo %d\n", pid); fflush(stdout);

18 System Call EXEC

19 EXEC L effetto delle system call della famiglia exec consiste nel modificare l'immagine del processo chiamante sostituendo il suo codice con un altro programma P P fork fork exec(new_prog) P P P P Ho lasciato P xché il PID del processo non cambia

20 Per noi sarà un eseguibile C sono_il_padre = fork(); if (!sono_il_padre) { <<codice padre>> exec( new_prog ); /* il codice dopo exec non verrà mai eseguito a meno che exec fallisca!!! */ Non c è ritorno da una exec Non è una funzione terminata la quale si torna all ambiente chiamante

21 main (int argc, char **argv) I programmi in genere hanno degli argomenti #argomenti 1 argv[0]=nome progr. argomenti argv[1] argv[argc-1] #include <stdio.h> main(int argc, char **argv) { int i; printf("argc = %d\n", argc); for (i=0; i<argc; i++) printf("argv[%d] = %s\n", i, argv[i]); prompt>prova argc=4 argv[0]=prova argv[1]=1 argv[2]=2 argv[3]=3 prompt>

22 EXEC #include <unistd.h> int execl(const char *path, const char *arg0,..., const char *argn, char * /*NULL*/); int execv(const char *path, char *const argv[]); int execle (const char *path,char *const arg0[],..., const char *argn, char * /*NULL*/, char *const envp[]); int execve (const char *path, char *const argv[], char *const envp[]); int execlp (const char *file, const char *arg0,..., const char *argn, char * /*NULL*/); int execvp (const char *file, char *const argv[]);

23 int execl(const char *path, const char *arg0,..., const char *argn, char * NULL ); Eventuali argomenti Eseguibile Es. /bin/prog il numero variabile dipende dal programma che si intende eseguire Termina l elenco degli argomenti

24 #include <sys/types.h> #include <stdio.h> main() { pid_t sono_il_padre; int s; Provare a eseguire due volte: (2) Prima di avere compilato hello (execl fallirà) (3) Dopo aver compilato hello if( (sono_il_padre=fork()) = = (pid_t) 1 ) {fprintf(stderr, "fork fallita"); exit(1); else if (sono_il_padre = = (pid_t) 0) { /* processo figlio */ execl("hello","hello",null); fprintf(stderr, "exec fallita"); else { /* processo padre */ wait(&s); main() { printf("hello \n"); hello.c

25 Il processo mantiene: nice value (see nice(2)) scheduler class and priority (see priocntl(2)) process ID parent process ID process group ID supplementary group IDs semadj values (see semop(2)) session ID (see exit(2) and signal(2)) trace flag (see ptrace(2) request 0) time left until an alarm (see alarm(2)) current working directory root directory file mode creation mask (see umask(2)) resource limits (see getrlimit(2)) utime, stime, cutime, and cstime (see times(2)) file-locks (see fcntl(2) and lockf(3c)) controlling terminal process signal mask (see sigprocmask(2)) pending signals (see sigpending(2)) All utente che ha creato il processo vengono estesi i diritti d accesso del proprietario del process file invocato tramite exec

26 System Call WAIT

27 #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *stat_loc); Restituisce il PID del processo figlio terminato wait(0) int result; wait(&result) wait termina con successo quando uno dei processi figli del processo chiamante muore. In tal caso nella locazione di memoria puntata da stat_loc vengono inserite informazioni relative al modo in cui il processo figlio è terminato. Tali informazioni possono essere analizzate tramite le macro descritte wstat(5) [man s5 wstat] Si usa 0 quando si intende ignorare il risultato di wait

28 Un processo dovrebbe terminare utilizzando la system call exit: void exit(int status); Es. if (tutto_ok) exit(0); else exit(1); Es. int uscita; while (n--) { pid_figlio = wait(&uscita); <<eventuale analisi di uscita>>

29 Cosa succede quando un processo esegue EXIT? 3. Il padre è sospeso su una wait: wait termina restituendo il PID del processo morto 6. Il padre è in esecuzione ma non è sospeso su di una wait: il processo figlio termina malamente e diventa un processo zombie (tecnicamente morto ma i suoi dati rimangono nella tabella dei processi) 8. Il padre è già terminato: il processo in questione (più i suoi eventuali fratelli) è ereditato dal processo avente PID = 1

30 #include <stdio.h> #include <sys/wait.h> #include <unistd.h> main() { int sono_il_padre; int figlio_defunto, status; Provare ad eseguire due volte: Figlio: exit(0) Figlio: exit(1) sono_il_padre = fork(); if (sono_il_padre) { figlio_defunto = wait(&status); printf("\n E` terminato il processo %d, lo stato e` %d\n", figlio_defunto, status); fflush(stdout); else { printf("\n figlio: nasco e muoio"); fflush(stdout); exit(1);

31 Di norma un processo termina dopo che tutti i suoi figli sono terminati 1. Nascita processo padre 2. Nascita processo figlio 3. Morte processo figlio :: se il padre è in attesa con wait, wait termina e restituisce il PID del figlio morto 4. Morte processo padre Se un processo rimane orfano, viene ereditato dal processo INIT, avente PID = 1