System Call (Gestione dei Processi nei Sistemi Operativi)

appuntiDiIngegneria

System Call

Sommario

1.1. System Call ........................................................................................................................................2

1.1.1. Primitive di Gestione di File e Directory in UNIX .............................................................................4

1.1.2. Primitive di Gestione dei Processi in UNIX .....................................................................................7

1.1.3. Primitive di Comunicazione tra Processi in UNIX .......................................................................... 10

1

1.1. System Call

Ogni qual volta un programma che si trova in modalità Utente deve accedere all'Hardware, deve

richiedere un servizio al SO utilizzando delle funzioni speciali dette System Call SC (Chiamate di

Sistema). Le System Call portano il sistema in stato Supervisore e mandano in esecuzione il servizio

richiesto dal programma, per fare ciò devono interrompere il programma utente, il quale potrà

essere riattivato secondo 2 politiche diverse a seconda che la SC sia bloccante o non bloccante:

 System Call Bloccanti: sono quelle che bloccano l'esecuzione del Processo in attesa della

fine della gestione della richiesta.

 System Call Non Bloccanti: sono quelle che dopo l'accettazione della richiesta da parte del

SO fanno riprendere l'esecuzione del Processo, in maniera tale che quest’ultimo possa fare

altre cose durante la gestione del SO.

Le SC sono delle chiamate speciali perché portano il programma da uno stato utente ad uno stato

supervisore (privilegiato), per effettuare questo passaggio occorre utilizzare il seguente trucco:

viene generata una Trap, ovvero un’interruzione software provocata volontariamente dal

programma utente. Le Trap, esattamente come gli Interrupt, vengono gestiti da un Interrupt

Service Routine ISR, che è un pezzo di software che lavora in modalità supervisionata, in tal modo

è stata portata momentaneamente l’esecuzione dell’applicazione da uno stato utente ad uno

privilegiato. In altre parole una SC è un salto ad un sottoprogramma ISR che nasconde una Trap

per passare dallo stato utente ad uno stato privilegiato. Per comprendere il meccanismo di

funzionamento di una SC viene mostrata l’esecuzione della SC int n = read(file, buffer, nbyte);

La System Call read non fa altro che leggere n bytes da uno specifico file, e salvare tali bytes in un

buffer di Memoria il cui indirizzo è specificato dall’apposito parametro di ingresso. La figura

precedente mostra il contenuto di una cella di Memoria durante l’esecuzione della SC read: nelle

fasi preparatorie 1, 2 e 3 il SO mette in cima ad un’area Stack i parametri di ingresso della read,

essendo accorto a passare il secondo parametro per riferimento in quanto si tratta di un indirizzo

2

di memoria; nella fase 4 il SO memorizza nello Stack il contenuto del registro Program Counter PC

ed del registro di stato PSW, dopodiché viene effettuato un salto ad una funzione read. Nella fase

5 viene associato il Numero della chiamata alla read, per poi nella fase 6 eseguire una Trap che

genera un’eccezione che porta il programma in modalità supervisore: da questo punto in poi il

programma viene eseguito nello spazio Kernel, nel quale un dispatcher esamina il numero di

chiamata per capire quel pezzo del SO attivare. In tal modo viene attivata la vera funzione read

che legge N bytes dal file e li mette in Memoria; quando finisce ritorna il controllo alla procedura

read dello spazio utente, per poi nella fase 10 ritornare il controllo al programma utente nello

stesso punto in cui esso si ritrovava prima della chiamata alla read. Infine nella fase 11 viene

ripulito lo Stack.

Le System Call dipendono dal SO e quindi variano da sistema a sistema. Esiste però un certo

numeri di System Call (94 per l'esattezza) che sono uguali per tutti gli SO e sono raggruppate in un

insieme chiamato Standard POSIX (Portable Operating System Interface for Unix): un programma

in C che sfrutta solo funzioni Posix una volta ricompilato funzionerà su qualsiasi SO, se invece lo

stesso programma in C contiene anche solo una funzione non-Posix, allora funzionerà

esclusivamente sul sistema dove quella funzione è riconosciuta. L’utilizzo di funzioni POSIX

comporta dunque la Portabilità del Codice Sorgente. Le System Calls dello standard POSIX

vengono anche chiamate Primitive. Ci sono un totale di 30 primitive Posix che sono state inglobate

nelle C Standard Library, e sono quindi disponibili per i programmatori C.

Esse possono essere suddivise in 3 grandi categorie:

 Primitive di Gestione File e Directory.

 Primitive di Gestione Processi.

 Primitive di Comunicazione fra Processi

Ma prima di parlare più nel dettaglio di queste categorie di System Call, bisogna sapere qual'è il

funzionamento generale delle System Call in caso di errore: le System Call quando sono delle

richieste di servizio e pertanto possono fallire, in tal caso esse restituiscono un valore -1 ed

3

assegnano lo specifico codice di errore in una variabile globale detta errno. I codici di errore sono

molti, per semplificare la vita del programmatore esiste una funzione che traduce il codice in una

stringa di caratteri, si tratta della funzione perror (print error).

1.1.1. Primitive di Gestione di File e Directory in UNIX

In questa categoria le p