1.1 Il concetto di processo Un sistema operativo può eseguire una grande varietà di attività diverse:  sistemi batch – jobs;  sistemi time-shared – programmi utente o task. Molti libri di testo utilizzano i termini job e processo in modo quasi interscambiabile. Processo – un programma in esecuzione; l’esecuzione di un processo deve progredire in modo sequenziale. Un processo comprende:  codice;  stack (es: variabili temporanee, parametri di subroutine);  sezione dati (es: variabili globali);  program counter;  un identificatore di processo univoco (PID).

1.2 Il concetto di processo

1.3 Modelli di esecuzione dei processi Multiprogrammazione di quattro programmi. Modello concettuale di 4 processi indipendenti e sequenziali. Un solo programma è attivo in ogni istante.

1.4 Creazione e terminazione di un processo Eventi principali che comportano la creazione di un processo: 1. boot del sistema; 2. esecuzione di una chiamata di sistema per la creazione di un processo; 3. l’utente richiede la creazione di un nuovo processo; 4. inizio di un job batch. Condizioni per la terminazione di un processo: 1. normale uscita, esecuzione dell’ultima istruzione del codice (volontaria); 2. chiamata esplicita di un’apposita system call (volontaria); 3. fatal error, tentativi di operazioni illegali (involontaria); 4. interruzione causata dalla ricezione di segnali (involontaria).

1.5 Stato del processo Mentre un processo è in esecuzione, subisce un cambiamento di stato:  new: il processo viene creato;  running: le istruzioni vengono eseguite;  waiting: il processo è in attesa che accada qualche evento;  ready: il processo è in attesa di essere assegnato a un processore;  terminated: il processo ha terminato l’esecuzione.

1.6 Diagramma degli stati di un processo

1.7 Processi UNIX UNIX e Linux sono sistemi multitasking, pertanto ci possono essere più processi in esecuzione contemporaneamente. Come si fa a visualizzare la lista dei processi in esecuzione?  $ ps -A

1.8 ps utility ps è un’abbreviazione di Process Status. Il comando può essere usato per mostrare i processi attualmente in esecuzione su sistemi Unix/Linux. $ ps PID TTY TIME CMD pts/0 00:00:00 bash pts/0 00:00:00 ps $ ps -u USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND dellungo pts/0 S 11:02 0:00 -bash dellungo pts/0 R 11:39 0:00 ps –u $ ps -l F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD 100 S wait4 pts/0 00:00:00 bash 000 R pts/0 00:00:00 ps Digitando ps --help viene mostrato un sommario delle opzioni e dell’utilizzo in generale del comando ps.

1.9 Eseguire processi in background Se a un singolo comando, a una pipeline, o a un gruppo di comandi viene fatto seguire il metacarattere &, viene creata una sottoshell per eseguire i comandi come processo in background. Il processo in background viene eseguito concorrentemente con la shell padre, non è controllato da tastiera e non pregiudica il controllo della tastiera. Eseguire processi in background è molto utile per eseguire task in parallelo che non richiedono controllo da tastiera. $ xemacs & [1] $ ps PID TTY TIME CMD pts/1 00:00:00 bash pts/1 00:00:00 xemacs pts/1 00:00:00 ps

1.10 Eseguire processi in background Per sospendere il processo foreground: Ctrl+Z Per inviare il processo sospeso in:  foreground: fg  background: bg $ xemacs Ctrl+Z [2]+ Stopped xemacs $ ps -l F S TTY TIME CMD 000 S :00:00 bash 000 T :00:00 xemacs 000 R :00:00 ps $ bg %2 [2]+ xemacs & $ ps -l F S TTY TIME CMD 000 S :00:00 bash 000 S :00:00 xemacs 000 R :00:00 ps

1.11 Terminazione di un processo È possibile terminare un processo digitando: Ctrl+C. Se vogliamo terminare un processo background prima che si completi, possiamo usare il comando kill. Naturalmente, abbiamo i permessi per terminare esclusivamente i nostri processi. La sintassi per il comando kill è:  kill [-signalId] PID. Esempio: $ ps PID TTY TIME CMD pts/1 00:00:00 bash pts/1 00:00:00 xemacs pts/1 00:00:00 ps $ kill [1]+ Terminated xemacs kill invia la signal con relativo codice signalId alla lista dei processi elencati. Di default, kill invia una signal TERM (numero 15). Per ottenere la lista delle signals, si può usare kill –l. Alcuni processi resistono ad essere terminati facilmente, per essi si può usare l’opzione "-9" per forzare l’eliminazione del processo.

1.12 Creazione dei processi Il solo modo di creare un nuovo processo in UNIX e Linux è quello di duplicare un processo esistente. Processi padri creano processi figli, che, a loro volta, creano altri processi, dando vita così a un albero di processi.

1.13 Creazione dei processi Nel momento in cui un processo viene duplicato (fork()), i processi padre e figlio sono totalmente identici, eccetto che per il loro PID; codice, dati e stack del figlio sono una copia di quelli del padre, pertanto i due processi continuano ad eseguire lo stesso codice dall’istruzione che segue la fork. Tuttavia, un processo figlio può sostituire (exec()) il suo codice con un altro file eseguibile, differenziandosi in tal modo dal proprio padre. Condivisione di risorse  Padre e figlio condividono tutte le risorse.  Il figlio condivide un sottoinsieme delle risorse del padre.  Padre e figlio non condividono alcuna risorsa. Esecuzione  Padre e figlio sono in esecuzione concorrente.  Il padre attende che il figlio termini per riprendere l’esecuzione.

1.14 Terminazione di un processo Il processo esegue l’ultima istruzione e chiede al sistema operativo di essere cancellato (exit()).  Possone essere restituiti dai dati (output) al padre da parte di un figlio che viene terminato (via wait()).  Tutte le risorse del processo vengono deallocate dal sistema operativo. Il padre può terminare l’esecuzione dei processi figli (abort()).  Il figlio ha ecceduto nell’uso di alcune delle risorse che gli sono state allocate.  Il compito assegnato al figlio non è più necessario.  Il padre termina.

1.15 Esempio Parent Process PID 34 Running shell Child Process PID 35 Running shell Child Process PID 35 Running utility Child Process PID 35 Terminates Parent Process PID 34 Running shell Waiting for child Parent Process PID 34 Running shell awakens Duplicate: fork () Differentiate: exec () Terminate: exit () signal Wait for child: wait ()

1.16 Creare un nuovo processo: fork System call: int fork() causa la duplicazione di un processo. Il processo figlio condivide il codice con il padre ed eredita una copia delle aree dati globali e dello stack, ma riceve un differente PID. Se fork() ha successo, restituisce il PID del figlio al processo padre, e restituisce 0 al processo figlio. Se fallisce, restituisce –1 al processo padre e non viene creato alcun figlio. Entrambi i processi continuano ad eseguire il medesimo codice in concorrenza, ma mantengono uno spazio di indirizzamento dei dati completamente separato.

1.17 Esempio con fork #include main() { int pid; printf("I am the original process with PID %d and PPID %d \n",getpid(),getppid()); pid=fork(); if (pid!=0) {printf("I am the parent process with PID %d and PPID %d\n",getpid(),getppid()); printf("My child's PID is %d\n",pid);} else {printf("I am the child process with PID %d and PPID %d\n",getpid(),getppid());} printf("PID %d terminates \n",getpid()); }

1.18 Esempio con fork $ gcc fork1.c -o fork1.out $ ls -l fork1.* -rw-r--r-- 1 lferrari lferrari 421 apr 28 12:35 fork1.c -rwxrwxr-x 1 lferrari lferrari apr 28 12:36 fork1.out* $./fork1.out I am the original process with PID and PPID I am the parent process with PID and PPID I am the child process with PID and PPID PID terminates My child's PID is PID terminates

1.19 Processi orfani Cosa accade se un padre termina senza attendere la morte del figlio? Ad esempio, si potrebbe inserire un istruzione di sleep nel codice del figlio del programma precedente: else{ sleep (5); printf(“I am the child process …); } In tal modo, mandando in esecuzione orphan.out (il programma nuovo) otteniamo: $./orphan.out I am the original process with PID and PPID I am the parent process with PID and PPID My child's PID is PID terminates I am the child process with PID and PPID 1 PID terminates

1.20 Processi orfani Ciò significa che se un padre muore prima del proprio figlio, il figlio viene automaticamente adottato dal processo originario init (PID 1). Il kernel assicura che tutti i figli di un processo in terminazione vengono adottati da init impostando il loro PPID a 1. Parent Process dies first Child Process Survives the parent init Adopt child

1.21 Terminare un processo: exit System call: int exit (int status) chiude tutti i descrittori del processo, provvede a deallocare il suo codice, i suoi dati e il suo stack, e termina il processo. Quando un processo figlio termina, invia al proprio padre una signal SIGCHLD e rimane in attesa che venga accettato il proprio valore d’uscita status. Un processo in attesa che il proprio padre raccolga le informazioni sul suo stato viene chiamato un processo zombie. Un padre raccoglie le informazioni relative alla terminazione di un figlio eseguendo la system call wait(). Se il processo padre è vivo ma non esegue mai una wait(), il codice di uscita del figlio non verrà mai accettato e il processo rimane uno zombie.

1.22 Esempio con exit $ cat exit.c #include main() {printf (“I am going to exit with return code 42”); exit(42);} $ exit.out I am going to exit with return code 42 $ echo $? 42

1.23 Processo zombie $ cat zombie.c #include main() { int pid; pid=fork(); if (pid!=0) {while(1) sleep(1000);} else {exit(42);} } $./zombie.out & [1] $ ps PID TTY TIME CMD pts/0 00:00:00 bash pts/0 00:00:00 zombie.out pts/0 00:00:00 zombie.out pts/0 00:00:00 ps $ kill [1]+ Terminated./zombie.out

1.24 Attendere un figlio: wait System call: int wait (int status) fa sì che un processo venga sospeso finchè uno dei suoi figli termina. Una chiamata wait() che ha successo restituisce il PID del figlio che è stato terminato e memorizza nella variabile status lo stato di terminazione del figlio nel modo seguente:  se il byte meno significativo (più a destra) di status è zero, la terminazione del figlio è avvenuta volontariamente e nel byte più significativo (più a sinistra) è memorizzato lo stato di terminazione (il valore eventualmente passato dalla exit() al figlio);  se il byte meno significativo è diverso da zero, la terminazione è avvenuta involontariamente e il suo valore è uguale al numero della signal che ha provocato la terminazione del figlio.  se un processo esegue una wait() e non ha figli, wait() restituisce immediatamente –1.

1.25 Esempio con wait #include main() { int pid, status, childPID; printf(“I am the original process with PID %d \n”, getpid(),getppid()); pid=fork(); if (pid!=0) {printf("I am the parent process with PID %d and PPID %d\n",getpid(),getppid()); childPID = wait(&status); printf(“A child with PID %d terminated with exit code %d \n",childPID, status>>8);} else {printf("I am the child process with PID %d and PPID %d\n",getpid(),getppid()); exit(42);} printf("PID %d terminates \n",getpid()); }

1.26 Esempio con wait $ gcc wait.c -o wait.out $ ls -l wait.* -rw-r--r-- 1 lferrari lferrari 421 apr 28 12:35 wait.c -rwxrwxr-x 1 lferrari lferrari apr 28 12:36 wait.out* $./wait.out I am the parent process with PID I am the parent process with PID and PPID I am the child process with PID and PPID A child with PID terminated with exit code 42 PID terminates

1.27 Esempio con wait #include main() { int pid, status, childPID; printf(“I am the original process with PID %d \n”, getpid(),getppid()); pid=fork(); if (pid!=0) {printf("I am the parent process with PID %d and PPID %d\n",getpid(),getppid()); childPID = wait(&status); printf(“A child with PID %d terminated with exit code %d \n",childPID, status);} else {printf("I am the child process with PID %d and PPID %d\n",getpid(),getppid()); sleep(10000); exit(42);} printf("PID %d terminates \n",getpid()); }

1.28 Esempio con wait $ xterm & (con xterm apriamo una nuova finestra) $./waitsleep.out I am the parent process with PID 2000 I am the parent process with PID 2000 and PPID 1806 I am the child process with PID 2001 and PPID 2000 Nel nuovo terminale aperto digitiamo $ ps –a PIDTTYCDM 1999pst/1xterm.real 2000pst/1wait.out 2001pst/1wait.out 2002pst/2ps $ kill –kill 2001 Nel finestra originaria si vedrà A child with PID 2001 terminated with exit code 9 PID 2001 terminates

1.29 Signal I processi a volte si trovano ad avere a che fare con eventi imprevisti (un errore di floating point, un’interruzione dell’alimentazione elettrica, la morte di un processo figlio, una richiesta di terminazione da parte di un utente (cioè Ctrl-C) …). Tali eventi vengono detti interrupts; essi devono interrompere il regolare flusso del processo per essere opportunamente presi in consierazione. Quando Linux riconosce che un tale evento si è verificato, manda una signal al processo corrispondente. C’è un’unica signal, opportunamente numerata con interi positivi da 1 a 63, per ogni possibile evento. Ad esempio, se un processo causa un errore di floating point, il kernel manda al processo in questione la signal SIGFPE (vale a dire, la signal numero 8). Il kernel non è l’unico che può mandare signal. Ogni processo può inviare ad ogni altro processo una signal, se ha il permesso.

1.30 La lista predefinita delle signal $ kill -l 1) SIGHUP2) SIGINT3) SIGQUIT4) SIGILL 5) SIGTRAP6) SIGABRT7) SIGBUS8) SIGFPE 9) SIGKILL10) SIGUSR111) SIGSEGV12) SIGUSR2 13) SIGPIPE14) SIGALRM15) SIGTERM17) SIGCHLD 18) SIGCONT19) SIGSTOP20) SIGTSTP21) SIGTTIN 22) SIGTTOU23) SIGURG24) SIGXCPU25) SIGXFSZ 26) SIGVTALRM27) SIGPROF28) SIGWINCH29) SIGIO 30) SIGPWR31) SIGSYS32) SIGRTMIN33) SIGRTMIN+1 34) SIGRTMIN+2 35) SIGRTMIN+3 36) SIGRTMIN+4 37) SIGRTMIN+5 38) SIGRTMIN+6 39) SIGRTMIN+7 40) SIGRTMIN+8 41) SIGRTMIN+9 42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45) SIGRTMIN+13 46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49) SIGRTMAX-14 50) SIGRTMAX-13 51) SIGRTMAX-12 52) SIGRTMAX-11 53) SIGRTMAX-10 54) SIGRTMAX-9 55) SIGRTMAX-8 56) SIGRTMAX-7 57) SIGRTMAX-6 58) SIGRTMAX-5 59) SIGRTMAX-4 60) SIGRTMAX-3 61) SIGRTMAX-2 62) SIGRTMAX-1 63) SIGRTMAX man signal mostra un riassunto della descrizione della signal.

1.31 Sospensione e ripresa dei processi #include main() { int pid1, pid2; pid1=fork(); if (pid ==0) /* first child */ {while(1) {printf(“pid1 is alive\n”); sleep(1);}} pid2=fork(); if (pid ==0) /* second child */ {while(1) {printf(“pid2 is alive\n”); sleep(1);}} sleep(3); kill(pid1,SIGSTOP); /* suspend first child */ sleep(3); kill(pid1,SIGCONT); /* resume first child */ sleep(3); kill(pid1,SIGINT); /* kill first child */ kill(pid1,SIGINT); /* kill second child */ }

1.32 Esempio con kill() $./susres.out pid1 is alive … entrambi in esecuzione nei primi tre secondi pid2 is alive pid1 is alive pid2 is alive pid1 is alive pid2 is alive pid2 is alive … ora è in esecuzione soltanto il secondo figlio pid2 is alive pid1 is alive … il primo figlio viene ripreso pid2 is alive pid1 is alive pid2 is alive pid1 is alive pid2 is alive $

1.33 Sostituzione di codice: exec La system call: int execl (char path, char arg0, …, char argn, NULL) sostituisce codice, dati globali e stack del processo chiamante prendendo i nuovi dal file con pathname path. Se l’eseguibile non viene trovato, viene restituito -1; altrimenti, il processo chiamante sostituisce i propri codice, dati e stack con quelli dell’eseguibile e comincia ad eseguire il nuovo codice. Una chiamata exec() eseguita con successo è “senza ritorno”, in quanto il processo chiamante perde ogni riferimento al vecchio codice. C’è un’intera famiglia di system call di tipo exec() in Unix per la sostituzione del codice: execv(), execlp(), execvp() …

1.34 Esempio con execl $ cat exec.c #include main() { printf(“I am process with PID %d and I am about to exec an ls –l \n”, getpid()); execl (“/bin/ls”,“ls”, “-l”, NULL); printf(“this line should never be executed \n”); } $./exec.out I am process with PID 2031 and I am about to exec ls -l -rw-r--r-- 1 lferrari lferrari 421 apr 28 12:35 exec.c -rwxrwxr-x 1 lferrari lferrari apr 28 12:36 exec.out*

1.35 Una shell semplificata #include main() { while (1) { type_prompt( ); read_command (path, command, parameters) pid=fork(); if (pid < 0) { printf(“Unable to fork”);} else if (pid != 0) {wait(&status);} else {execl (path, command, parameters, NULL);} }

1.36 Gestione dei processi della shell Parent Process PID 501 Running shell Child Process PID 748 Running shell Child Process PID 748 Running utility Child Process PID 748 Terminates Parent Process PID 501 Running shell Waiting for child Parent Process PID 501 Running shell awakens Duplicate: fork () Differentiate: exec () Terminate: exit () signal Wait for child: wait ()

1.37 Passi effettuati durante l’esecuzione del comando di shell ls

1.38 Scheduling Con questo termine si indica l’attività di allocare il tempo della CPU a compiti diversi all’interno di un sistema operativo. Sebbene si pensi normalmente allo scheduling come all’esecuzione e interruzione dei processi, in Linux lo scheduling comprende anche l’esecuzione dei vari task del kernel. L’esecuzione dei task del kernel comprende sia i task che sono richiesti da un processo in esecuzione sia i task che vengono eseguiti internamente per conto dei driver delle periferiche.

1.39 La sincronizzazione del kernel Una richiesta di esecuzione in modalità kernel può avvenire in due modi distinti:  un programma in esecuzione può richiedere un servizio del sistema operativo, o esplicitamente tramite una system call, o implicitamente, ad esempio, quando si verifica un page fault;  un driver di periferica può scatenare un interrupt hardware che provoca l’esecuzione da parte della CPU dell’handler definito dal kernel per quel particolare interrupt. La sincronizzazione del kernel richiede una struttura che consenta l’esecuzione di una sezione critica del kernel, senza violare l’integrità dei dati condivisi.

1.40 Scheduler di UNIX Lo scheduler di UNIX è basato su una struttura a code multiple.