Informatica 2 – Prova di lunedì 8 maggio 2006 – CON SOLUZIONI pagina 13 di 14

Esercizio n. 4 – File system

Un processo P esegue il programma seguente, creando un processo figlio Q, che crea a sua volta un figlio R:

int main ( ) { /* processo P */ /∗ dichiarazioni varie ∗/ fd1 = open ("/cat1/cat3/file1", O_RDONLY); read (fd1, bufP1, 5); fd2 = open ("/cat1/cat3/file2", O_RDONLY); read (fd2, bufP2, 4); pid = fork ( ); if (pid == 0) { /* processo Q */

read (fd2, bufQ, 6); pid = fork ( ); if (pid == 0) { /* processo R */

fd3 = open ("/cat1/cat2/file3", O_RDONLY); read (fd3, bufR3, 6); close (fd1); lseek (fd2, -2, 1); /* 1 = rif. relativo alla pos. corr. ∗/ read (fd2, bufR2, 5); exit (0);

} /∗ fine R ∗/ ...

} /∗ fine Q ∗/ ...

} /∗ fine P ∗/

A un certo istante di tempo T si sono verificati gli eventi seguenti: • dopo l’esecuzione della prima fork è andato subito in esecuzione il processo Q • dopo l’esecuzione della seconda fork è andato subito in esecuzione il processo R • il processo R ha eseguito la seconda funzione read (ma non ha ancora eseguito la funzione exit)

Durante l’esecuzione del codice il contenuto del volume è il seguente:

i-lista: <0,dir,8> <3,dir,20> <4,dir,12> <5,dir,17> <11,norm,75> <18,norm,80> <30,norm,90> ... blocco dati 8: … < 1, dev >, < 3, cat1> … blocco dati 12: … < 11, file1> … <18, file2> … blocco dati 17: … < 30, file3> blocco dati 20: … < 4, cat3 > … <5, cat2> … blocco dati 75: ABCDEFGHI blocco dati 80: AlfaBetaGammaDelta blocco dati 90: PQRSTUVZ Nota bene: lo i-node contiene la terna <i-number, tipo file (dir., norm. o spec.), punt. al primo blocco dati>; il catalogo contiene coppie <i-number, nome file>; lo i-node del catalogo radice “/ “ ha 0 come i-number.

1) Si indichi il contenuto, all’istante di tempo T, delle variabili seguenti:

bufP1: ABCDE _____________ bufP2: Alfa ______________ bufQ: BetaGa ___________

bufR2: Gamma _______________ bufR3: PQRSTU _____________

2) Si completi il contenuto, all’istante di tempo T, delle tabelle seguenti:

Tabella dei File Aperti

di P

Tabella dei File Aperti

di Q

Tabella dei File Aperti

di R Tabella Globale dei File Aperti

f.d. rif. f.d. rif. f.d. rif. riga pos.corr.

n. di proc. i-number

0 X 0 X 0 X 0 X X X 1 X 1 X 1 X 1 X X X 2 X 2 X 2 X 2 0, 5 1,2,3,2 11 3 2 3 2 3 2 L NE 3 0,4,10,8,13 //1,2,3,2 184 3 4 3 4 3 NE 4 0 6 L1,L 30 ,L 5 5 5 4 NE 5

Nota bene: f.d. è il numero di descrittore di file; rif. è il puntatore alla riga della tabella globale dei file aperti; riga è il numero di riga della tab. glob.; pos. corr. è l’indicatore di posizione corrente all’interno del file; n. di proc. è il nu-mero di processi che correntemente hanno il file aperto; X indica che è presente un valore non significativo ai fini del problema; le tabelle sono semplificate e contengono solamente le colonne di cui è richiesto il riempimento; si scriva L per indicare che una cella utilizzata precedentemente è diventata libera (p. es. a seguito di una “close”).

Informatica 2 – Prova di lunedì 8 maggio 2006 – CON SOLUZIONI pagina 14 di 14

L’esercizio è piuttosto semplice e non necessita di commenti particolari. Si osservi solamente che:

- i tre file “file1”, “file2” e “file3” vengono aperti una sola volta ciascuno

- i due file “file1” e “file2” vengono entrambi aperti da P

- il file “file3” viene aperto da R

- i due file “file1” e “file3” (aperti dai processi P e R, rispettivamente) vengono usati (read) solo dai processi P e R, rispettivamente

- il file “file2” (aperto dal processo P) viene usato da tutti e tre i processi P, Q e R (read, lseek); pertanto le modifiche di posizione corrente fatte da un processo sono visibili anche agli altri due (ovvero sono cumulative), in quanto la riga della tabella globale dei file aperti che fà riferimento a “file2” è una sola; si veda al riguardo il commento alla tabella dei file globali aperti

Il resto della soluzione si commenta da sé.

Nota bene: le righe numero 0 e 1 della tabella globale dei file aperti si riferiscono ai file standard input (riga 0; questo file speciale di solito si riferisce alla tastiera con eco sulla finestra di terminale) e standard output ed error (riga 1; questi due file speciali di solito coincidono e si riferiscono alla finestra di terminale), rispettivamente; nelle tabelle dei file aperti dei vari processi (P, Q e R), il numero di descrittore di file 0 si riferisce alla riga 0, ovvero allo standard input, mentre i numeri di descrittore di file 1 e 2 si riferiscono entrambi alla riga 1, ovvero allo standard output ed error; tali tre file standard vengono sempre aperti d’ufficio quando il processo viene creato, e dunque sono sempre presenti a meno che il processo stesso in seguito non li chiuda esplicitamente (qui ciò non succede); nelle tabelle, alle righe in questione si legge “X” perché tali informazioni, pur presenti, non sono significative per il problema proposto.

Nota bene: gli i-node elencati nella i-lista sono un po’ semplificati, omettendo i permessi di accesso, le varie date, il contatore di link, ecc, e indicando solo il primo puntatore al blocco dati (i puntatori rimanenti qui sono tutti omessi, per semplicità e in quanto non servono ai fini del problema proposto).

Informatica 2 – Esame di giovedì 13 settembre 2007 - CON SOLUZIONI pagina 10 di 22

Esercizio n. 4 – File System

Un processo P esegue il programma seguente, creando un processo figlio Q, che crea a sua volta un figlio R:

int main ( ) { /∗ processo P ∗/

/∗ dichiarazioni varie ∗/ fd1 = open ("/cat1/cat3/file1", O_RDONLY); read (fd1, bufP1, 3); pid = fork ( );

if (pid == 0) { /∗ processo Q ∗/ fd2 = open ("/cat1/cat3/file2", O_RDONLY);

lseek (fd2, -6, 2); /∗ 2 = rif. relativo alla fine del file ∗/ read (fd2, bufQ1, 4);

lseek (fd2, -9, 1); /∗ 1 = rif. relativo alla pos. corr. ∗/ pid = fork ( );

if (pid == 0) { /∗ processo R ∗/ fd3 = open ("/cat1/cat2/file3", O_RDONLY); read (fd3, bufR3, 5); read (fd2, bufR2, 4); exit (0);

} /∗ fine R ∗/ pid = wait (NULL); read (fd2, bufQ2, 3); close (fd2); close (fd1); exit (0);

} /∗ fine Q ∗/

} /∗ fine P ∗/

A un certo istante di tempo T1 si sono verificati i tre eventi seguenti:

1) dopo l’esecuzione della prima fork è andato subito in esecuzione il processo Q

2) dopo l’esecuzione della seconda fork è andato subito in esecuzione il processo R

3) il processo R è arrivato all’invocazione della funzione exit (che non è stata ancora eseguita)

A un certo istante di tempo successivo T2 > T1 si è aggiunto a questi tre l’ulteriore evento seguente:

4) il processo Q è arrivato all’invocazione della funzione exit (che non è stata ancora eseguita)

Il contenuto del volume durante l’esecuzione è il seguente:

I-Lista: <0,dir,4>, <6,dir,9>,<7,dir,18>,<10,dir,12>,<70,norm,56>,<86,norm,70>,<92,norm,90> Blocco 4: …< 1, dev >, < 6, cat1> … Blocco 9: …< 7, cat3 > … <10, cat2>… Blocco 12: …< 70, file3> Blocco 18: …< 92, file1> … <86, file2>… Blocco 56: INFORMATICA Blocco 70: ELETTRONICA Blocco 90: TELECOMUNICAZIONI

Nota bene: lo i-node associato al catalogo radice “/” ha 0 come i-number; la i-lista contiene terne <i-number, tipo_file, indice_blocco>; i cataloghi contengono coppie < i-number, nome_file>.

Informatica 2 – Esame di giovedì 13 settembre 2007 - CON SOLUZIONI pagina 11 di 22

Si svolgano i punti seguenti:

1) Si indichi il contenuto, all’istante di tempo T1, delle variabili seguenti:

bufR2: ELET__________________ bufR3: INFOR ______________

e si indichi il contenuto, all’istante di tempo T2, delle variabili seguenti:

bufP1: TEL ________________ bufQ1: RONI _____________ bufQ2: TRO _____________

2) Si completi il contenuto delle tabelle seguenti, indicando la sequenza di valori assunti fino all’istante T2

(si scriva L oppure NE per indicare che una cella si è liberata oppure non esiste più):

Tab. File Aperti Proc. P

Tab. File Aperti Proc. Q

Tab. File Aperti Proc. R

Tabella Globale dei File Aperti

file des.

rif. riga

file des.

rif. riga

file des.

rif. riga riga pos. corr. n. di proc. punt.

0 × 0 × 0 × 0 × × ×

1 × 1 × 1 × 1 × × ×

2 × 2 × 2 × 2 × × ×

3 3 3 3, L 3 3, NE 3 0, 3 1, 2, 3, 2, 1 92

4 4 4, L 4 4, NE 4 0, 5, 9, 0, 4, 7, L 1, 2, 1, L 86, L

5 5 5 5, NE 5 0, 5, L 1, L 70, L

Nota bene: file des. indica il numero di descrittore di file; rif. riga indica il riferimento alla riga della tabella globale dei file aperti; pos. corr. è l’indicatore di posizione corrente all’interno del file; n. di proc. è il numero di processi nel cui contesto il file risulta essere correntemente aperto; punt. è lo i-number che fa riferimento allo i-node; “×” indica che è presente un valore non significativo ai fini del problema; le tabelle sono semplificate e contengono solamente le colonne che si chiede di riempire.

Informatica 2 – Prova di giovedì 8 maggio 2008 – CON SOLUZIONI pagina 10 di 13

Esercizio n. 4 – file system

Si consideri un calcolatore dotato di sistema operativo Linux, dove valgono le seguenti ulteriori specifiche:

1. per tutte le operazioni su file: a) la dimensione di un blocco trasferito in DMA da o su file è di 512 byte b) l’interruzione di fine DMA è associata al trasferimento di un singolo blocco c) il sistema deve garantire che, per tutti i file aperti, il blocco contenente la posizione corrente sia in

memoria (a meno che il file sia vuoto, cioè al momento non abbia ancora blocchi dati) 2. per la lettura e scrittura su file:

d) le operazioni di lettura e scrittura su file accedono sempre a disco, cioè è sempre necessario eseguire trasferimenti in DMA

3. per l’apertura del file: e) è sempre necessario trasferire in DMA:

- 1 blocco per l’accesso allo I-node di ogni cartella (catalogo) o file presente nel nome-percorso (pathname) (tranne che per la cartella radice), e

- 1 blocco per il contenuto di ogni cartella (catalogo) presente nel nome-percorso (pathname) f) lo I-node di un file aperto resta disponibile in memoria fino alla chiusura del file g) la seconda “open” non ha a disposizione in memoria blocchi letti dalla prima “open”

DOMANDA

Per ciascuna delle chiamate di sistema sotto riportate si indichi il numero di interruzioni di fine DMA che si verificano affinché l’operazione possa essere completata.

chiamata di sistema valore della posizione

corrente nel file all’atto della chiamata di sistema

n° di interruzionidi fine DMA

fd1 = open (“/info2/file1”, O_RDWR) non significativo 5 (a)

fd2 = open (“/home/info2/nuovo”, O_RDWR) non significativo 7 (b)

lseek (fd, 0L, 1) – vedi nota non significativo 0 (c)

read (fd, c, 500) 100 1 (d)

read (stdin, c, 1) non significativo 0 (e)

write (fd, c, 5000) 0 10 (f) write (fd, c, 5200) 0 12Nota a proposito di “lseek”: il valore 1 del terzo parametro indica “posizione corrente”.

Ovviamente si ha un’interruzione per ciascun blocco trasferito via DMA (in lettura o scrittura). Dunque per determinare il numero di interruzioni basta contare i blocchi da trasferire in ciascuna chiamata di sistema. Le chiamate di sistema elencate sono indipendenti, cioè si chiede di considerarle individualmente. Ecco alcuni commenti dettagliati alle varie chiamate di sistema (non richiesti nella soluzione):

(a) la chiamata “open” legge da disco: un blocco di dati della cartella radice “/” (lo I-node della radice è già in memoria), un blocco contenente lo I-node della cartella “info2”, un blocco di dati della cartella “info2”, un blocco contenente lo I-node del file “file1”, e il primo blocco di dati del file “file1”; la posizione corrente vale 0 e il primo blocco di dati del file è quello corrente da tenere in memoria; in totale la chiamata legge da disco 5 blocchi ovvero si verificano 5 interruzioni di fine DMA

(b) la chiamata “open” legge da disco: un blocco di dati della cartella radice “/” (lo I-node della radice è già in memoria), un blocco contenente lo I-node della cartella “home”, un blocco di dati della cartella “home”, un blocco contenente lo I-node della cartella “info2”, un blocco di dati della cartella “info2”, un blocco contenente lo I-node del file “nuovo”, e il primo blocco di dati del file “nuovo”; la posizione corrente vale 0 e il primo blocco di dati del file è quello corrente da tenere in memoria; in totale la chiamata legge da disco 7 blocchi ovvero si verificano 7 interruzioni di fine DMA

Informatica 2 – Prova di giovedì 8 maggio 2008 – CON SOLUZIONI pagina 11 di 13

(c) la chiamata “lseek” non modifica la posizione corrente e si limita a restituirla in uscita (comunemente si usa appunto tale forma di “lseek” per conoscere il valore della posizione corrente); pertanto la chiamata si limita a leggere la posizione corrente nella tabella globale dei file aperti, la quale sta in memoria, e non accede al disco; dunque non si verificano interruzioni di fine DMA

(d) prima della chiamata la posizione corrente vale 100 e cade nel primo blocco del file; la chiamata “read” legge 500 byte e dopo l’operazione la posizione corrente varrà 100 + 500 = 600, che cade nel secondo blocco del file; pertanto la chiamata deve usare il primo e il secondo blocco del file; i puntatori a tali blocchi sono direttamente disponibili nello I-node del file (lo I-node è già stato caricato in memoria dalla “open” ed è tuttora disponibile in memoria); il primo blocco (dove cade la posizione corrente 100) è già in memoria e dunque non c’è bisogno di leggerlo da disco, mentre il secondo va effettivamente letto da disco; il secondo blocco diventa quello corrente da tenere in memoria; in totale la chiamata legge da disco un solo blocco ovvero si verifica una sola interruzione di fine DMA

(e) la chiamata “read” legge dal file speciale “stdin” (descrittore di file numero 0), che si riferisce al terminale (o alla finestra di terminale) standard ed è un dispositivo di tipo a caratteri, non a blocchi; pertanto non c’è alcun trasferimento di blocco (i dispositivi a caratteri non sono gestiti in DMA) e dunque non si verifica nessuna interruzione nota bene: per correttezza sintattica e semantica a chiamata andrebbe scritta così:

read (0, &temp, 1)

giacché il tipo di “stdin” è “FILE ∗” (puntatore a FILE), e non intero (come richiede “read”); si tratta comunque di un dettaglio di scarso rilievo

(f) prima della chiamata la posizione corrente vale 0 e cade nel primo blocco del file; la chiamata “write” scrive (o sovrascrive) 5000 byte e dopo l’operazione la posizione corrente varrà 0 + 5000 = 5000, che cade nel decimo blocco del file; pertanto la chiamata deve usare i primi 10 blocchi del file; i puntatori a tali blocchi sono direttamente disponibili nello I-node del file (lo I-node è già stato caricato in memoria dalla “open” ed è tuttora disponibile in memoria); pertanto la chiamata deve scrivere (o sovrascrivere) i primi 10 blocchi del file; dato che la posizione corrente prima della chiamata vale 0, non si sa se il file sia vuoto; se il file non è vuoto, il primo blocco (dove cade la posizione corrente 0) è in memoria e va modificato e poi sovrascritto su disco, altrimenti il primo blocco non è in memoria (in quanto non esiste ancora) e va semplicemente scritto su disco; i blocchi dal secondo al decimo (compresi) non sono in memoria e vengono scritti (o sovrascritti) direttamente su disco (senza alcun bisogno prima di leggerli da disco, se pure esistono); il decimo blocco diventa quello corrente e viene tenuto anche in memoria (oltre ad essere scritto o sovrascritto su disco); in totale la chiamata scrive su disco 10 blocchi ovvero si verificano 10 interruzioni di fine DMA

nota bene: se il file è vuoto, i 10 blocchi da scrivere vengono tutti aggiunti ex-novo al file (il quale assume dimensione pari a esattamente 5000 byte ovvero 10 blocchi); se il file non è vuoto e ha dimensione minore di o uguale a 5000 byte, i primi blocchi già esistenti del file vengono sovrascritti da altrettanti blocchi nuovi e il file viene eventualmente allungato concatenandogli i blocchi nuovi eccedenti (se ce ne sono); altrimenti i 10 blocchi nuovi vengono sovrascritti ai primi 10 blocchi già esistenti del file e gli eventuali blocchi eccedenti già esistenti non vengono modificati (e ovviamente il file non si allunga)

Anche se non è detto esplicitamente nel testo, la variabile “c” che compare nelle chiamate “read” e “write” è da considerare nome di vettore di caratteri (stringa), pertanto è puntatore al primo elemento del vettore stesso (si veda anche il programma all’es. 3).

Si consideri un calcolatore dotato di sistema operativo Linux e in cui valgono le seguenti ulteriori specifiche:

1. per tutte le operazioni su file:

a) la dimensione di un blocco trasferito in DMA da o su file è di 512 byteb) l’interruzione di fine DMA è associata al trasferimento di un singolo bloccoc) il sistema deve garantire che, per tutti i file aperti, il blocco contenente la posizione 

corrente sia in memoria2. per la lettura e scrittura su file:

d) le operazioni di lettura e scrittura su file accedono sempre a disco, cioè è sempre necessario eseguire trasferimenti in DMA

3. per l’apertura del file:

e) è sempre necessario trasferire in DMA:

­ 1 blocco    per l’accesso allo I­node di ogni cartella (catalogo) o file presente nel nome­percorso (pathname) (tranne che per la cartella radice), e 

­ 1 blocco    per il contenuto di ogni cartella (catalogo) presente nel nome­percorso (pathname)

f) Le chiamate di sistema sono DIPENDENTI e rimangono a disposizione in memoria blocchi allocati/letti dalle precedenti chiamate di sistema 

DOMANDA 

Per ciascuna delle chiamate di sistema sotto riportate si indichi la posizione corrente nel file dopo la chiamata, il numero totale di interruzioni di fine DMA che si verificano affinché l’operazione possa essere completata, la sequenza di accessi agli i­node e ai blocchi (del tipo: I­Lista[X] oppure Blocco Y) in memoria principale (MM) o su disco (vedi anche le prime due righe di esempio di soluzione in tabella)

chiamata di sistema

posizione corrente nel file dopo 

la chiamata di sistema  

n° diinterruzionidi fine DMA

Sequenza accessi in memoria /su disco

fd = open (“/cat1/file1”, O_RDONLY)

0

-11111

Totale 5

I-Lista[0] in MMBlocco 5I­Lista[6]Blocco 7

I­Lista[20]Blocco 100

lseek(fd, 700L, 0)700

­1

Totale 1

I-Lista[20] in MMBlocco 101

read (fd, buf1, 400)1100

­­

1Totale 1

I­Lista[20] in MMBlocco 101 in MM

Blocco 102

lseek(fd, 0L, 0)0

­­

Totale 0

I­Lista[20] in MMBlocco 100 in MM

read (fd, buf2, 5300)

5300

----111111111

Totale 9 (e)

I-Lista[20] in MMBlocco 100 in MM Blocco 101 in MMBlocco 102 in MM

Blocco 103Blocco 104Blocco 105Blocco 106Blocco 107Blocco 108Blocco 109Blocco 110Blocco 600

Il contenuto del volume durante l’esecuzione è il seguente:

I­Lista: <0,dir,5> <6,dir,7> <7,dir,11> <8,dir,9> <60, norm,{730,..}><92, norm,{840,..}><20, norm, {100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,111,112}> 

Blocco 5: … < 6, cat1> …

Blocco 7: …< 7, cat2 >< 20, file1>…

Blocco 11: …< 92, file3> … <60, file2>…

Blocco 110: {600,601,..,727}

Blocco 111: {800,801,...,827}

Blocco 112: {900,901,...,927}

Nota bene: lo i­node associato al catalogo radice “/” ha 0 come i­number; la i­lista contiene terne<i­number, tipo_file, {indice_blocchi}>; i cataloghi contengono coppie < i­number, nome_file>.

ACSO – Prova del 26 Febbraio 2010 Pagina 7 di 16

Esercizio 3: File system Si consideri un calcolatore dotato di sistema operativo Linux e in cui valgono le seguenti ulteriori specifiche:

1. per tutte le operazioni su file: a) la dimensione di un blocco trasferito in DMA da o su file è di 512 byte b) l’interruzione di fine DMA è associata al trasferimento di un singolo blocco c) il sistema deve garantire che, per tutti i file aperti, il blocco contenente la posizione corrente

sia in memoria 2. per la lettura e scrittura su file:

d) le operazioni di lettura e scrittura su file accedono sempre a disco, cioè è sempre necessario eseguire trasferimenti in DMA

3. per l’apertura del file: e) è sempre necessario trasferire in DMA: - 1 blocco per l’accesso allo I-node di ogni cartella (catalogo) o file presente nel nome-percorso

(pathname) (tranne che per la cartella radice), e - 1 blocco per il contenuto di ogni cartella (catalogo) presente nel nome-percorso (pathname)

f) Le chiamate di sistema sono DIPENDENTI e rimangono a disposizione in memoria blocchi allocati/letti dalle precedenti chiamate di sistema

DOMANDA    

Per ciascuna delle chiamate di sistema sotto riportate si indichi la posizione corrente nel file dopo la chiamata, il numero totale di interruzioni di fine DMA che si verificano affinché l’operazione possa essere completata, la sequenza di accessi agli i-node e ai blocchi (del tipo: I-Lista[X] oppure Blocco Y) in memoria principale (MM) o su disco (vedi anche le prime due righe di esempio di soluzione in tabella)  

Chiamata di sistema Posizione corrente nel file dopo la

chiamata di sistema

n. di interruzioni di fine DMA

Sequenza di accessi in

memoria (MM) o disco.

fd1=open(“/cat1/cat2/file1”, O_RDONLY) 0 - 1 1 1 1 1 1 1

(totale 7)

I-lista[0] in MM Blocco 4 I-lista[6] Blocco 9

I-Lista[10] Blocco 12 I-Lista[60] Blocco 56

fd2=open(“/cat1/cat3/file2”, O_RDONLY) 0 - - - - 1 1 1 1

(totale 4)

I-lista[0] in MM Blocco 4 in MM I-lista[6] in MM Blocco 9 in MM

I-Lista[7] Blocco 18 I-Lista[86] Blocco 70

ACSO – Prova del 26 Febbraio 2010 Pagina 8 di 16

read (fd1, buf1, 3) 3 totale 0

I-Lista [60] in MM Blocco 56 in MM

read (fd2, buf2, 6) 6 totale 0

I-Lista [86] in MM Blocco 70 in MM

read(fd2, buf3, 1100) 1106 - - 1 1

(totale 2)

I-Lista[86] in MM Blocco 70 in MM

Blocco 72 Blocco 80

Il contenuto del volume durante l’esecuzione è il seguente:

I-Lista:<0,dir,4>,<6,dir,9>,<7,dir,18>,<10,dir,12>,<60,norm,{56}>, <86,norm,{70,72,80}>,<92,norm,{90}>

Blocco 4: … < 6, cat1> … Blocco 9: …< 7, cat3 > … <10, cat2>… Blocco 12: …< 60, file1> Blocco 18: …< 92, file3> … <86, file2>… Blocco 56: BLOCCO1_FILE1 Blocco 70: BLOCCO1_FILE2 Blocco 72: BLOCCO2_FILE2 Blocco 80: BLOCCO3_FILE2 Blocco 90: BLOCCO1_FILE3 Nota: Per facilitare la comprensione dell’esercizio, i blocchi dati dei file sono stati indicati come: BLOCCOn_FILEi

Nota bene: lo i-node associato al catalogo radice “/” ha 0 come i-number; la i-lista contiene terne <i-number, tipo_file, {indice_blocchi}>; i cataloghi contengono coppie < i-number, nome_file>.

(a) Lettura in memoria dello I-node della radice. Letture da disco: blocco 4 di dati della cartella radice “/”, blocco di i-nodo 6 della cartella “cat1”, blocco 9 di dati della cartella “cat1”, blocco di i-nodo 10 della cartella “cat2”, blocco 12 di dati della cartella “cat2”, blocco di i-nodo 60 del file “file1”, blocco 56 primo blocco di dati del file “file1”; totale 7 blocchi ovvero 7 interruzioni di fine DMA (b) Lettura in memoria dello I-node della radice, del blocco 4 di dati della cartella radice “/”, del blocco di i-nodo 6 della cartella “cat1”, del blocco 9 di dati della cartella “cat1”. Letture da disco: blocco di i-nodo 7 della cartella “cat3”, blocco 18 di dati della cartella “cat3”, blocco di i-nodo 86 del file “file2”, blocco 70 primo blocco di dati del file “file2”; totale 4 blocchi letti effettivamente da disco ovvero 4 interruzioni di fine DMA (c) la chiamata legge 3 byte dal file con descrittore fd1 e dopo la lettura la posizione corrente varrà 3 (che cade sempre nel primo blocco); essa deve pertanto leggere l’i-node 60 del file e il primo blocco del file che risiedono già in memoria, ovvero non necessita di accessi al disco. (d) la chiamata legge 6 byte dal file con descrittore fd2 e dopo la lettura la posizione corrente varrà 6 (che cade sempre nel primo blocco); essa deve pertanto leggere l’i-node 86 e il primo blocco del file che risiedono già in memoria, ovvero non necessita di accessi al disco. (e) la chiamata legge 1100 byte dal file con descrittore fd2 a partire dalla posizione corrente 6 (che cade nel primo blocco) e dopo la lettura la posizione corrente varrà 1106 (che cade nel terzo blocco); essa deve pertanto leggere l’i-node 86 e il primo blocco del file che risiedono già in memoria, e successivamente deve leggere i successivi blocchi del file che risiedono su disco usando i rispettivi puntatori disponibili nello i-node 86 del file già caricato in memoria. Gli accessi dal secondo al terzo blocco avvengono per accesso diretto tramite i puntatori. In totale è stato necessario accedere a 2 blocchi su disco corrispondenti a 2 interruzioni di fine DMA.

Un processo esegue la seguente porzione di programma:...

fd = open (”/dir1/dir2/file_A”, O_RDWR);

lseek (fd, 615L, 0); /* relativa all'inizio del file */

write (fd, v1, 980);

lseek (fd,-200L, 1); /* relativa alla posizione corrente */

read (fd, v2, 486);

write (fd, v3, 200);

close (fd);

...

Sapendo che:• nell’I­node di file_A sono indicati i seguenti puntatori ai blocchi < 41, 37, 10, 22, 33 >• l’I­node di un file viene letto al momento della apertura e mantenuto in memoria fino alla 

chiusura• lo I-node della radice si trova inizialmente già in memoria

• un blocco viene letto solamente quando il suo contenuto è necessario per svolgere l’operazione in corso

• un blocco viene riscritto su disco solamente quando è necessario salvarne il contenuto• la dimensione di un blocco è di 512 byte• per accedere un catalogo è necessario leggere due blocchi: uno per l’I­node e uno per il 

contenuto effettivoCompilare le seguenti tabelle, indicando per ogni operazione la posizione corrente di file_A dopo l’operazione, i blocchi di file_A letti o scritti per eseguire l’operazione e il numero di interrupt di DMA richiesti dall’operazione

A) E' disponibile un solo buffer di memoria di 512Byte per contenere il blocco dati  corrente del file file_AOperazione Posizione corrente

dopo l'operazioneBlocchi di file_A letti

Blocchi di file_A scritti

Numero di interrupt richiesti

open 0 Nessuno Nessuno 6

lseek 615 Nessuno Nessuno 0

write 1595 37,10,22 37,10 5

lseek 1395 Nessuno Nessuno 0

read 1881 10,22 22 3

write 2081 33 22 2

close ­­­­­­­­­ Nessuno 33 1

B) Sono disponibili 2 buffer di memoria di 512Byte per contenere fino a due blocchi dati del file file_AOperazione Posizione corrente

dopo l'operazioneBlocchi di file_A letti

Blocchi di file_A scritti

Numero di interrupt richiesti

open 0 Nessuno Nessuno 6

lseek 615 Nessuno Nessuno 0

write 1595 37,10,22 37 4

lseek 1395 Nessuno Nessuno 0

read 1881 Nessuno Nessuno 0

write 2081 33 10 2

close ­­­­­­­­­ Nessuno 22,33 2

AXO – prova di martedì 17 novembre 2009 – CON SOLUZIONI pagina 10 di 14

Esercizio n. 4 – file system

Il programma seguente viene eseguito:

int main ( ) { fd1 = open (“/miocat/F”, O_RDWR); pid1 = fork ( ); if (pid1 == 0) {

lseek (fd1, 1022L, 1); /∗ relativa alla posizione corrente ∗/ write (fd1, v1, 4); exit (0);

} /∗ end if ∗/ waitpid (pid1, NULL); read (fd1, v2, 100);

lseek (fd1, −200L, 1); /∗ relativa alla posizione corrente ∗/ write (fd1, v3, 1024); close (fd1);

} /∗ end main ∗/

Sapendo che: 1. nello I-node del file F sono indicati i seguenti puntatori ai blocchi: < 12, 17, 24, 13, 11 > 2. lo I-node di un file viene letto al momento dell’apertura e mantenuto in memoria fino alla chiusura 3. lo I-node della radice si trova inizialmente già in memoria 4. un blocco viene letto solamente quando il suo contenuto è necessario per svolgere l’operazione in corso 5. per potere scrivere un blocco, è necessario che esso sia già in memoria o altrimenti che venga caricato

in memoria 6. un blocco viene aggiornato in memoria, ma viene successivamente riscritto su disco solamente quando è

necessario salvarne il contenuto 7. la dimensione di un blocco è di 512 byte 8. per accedere un catalogo è necessario leggere due blocchi: uno per lo I-node e uno per il contenuto

effettivo Si compilino le due tabelle seguenti, indicando per ogni operazione la posizione corrente del file F dopo l’operazione, i puntatori ai blocchi di F letti o scritti per eseguire l’operazione, e il numero di interrupt di DMA richiesti dall’operazione A) c’è un solo buffer di memoria da 512 byte, per contenere il blocco dati corrente del file F

operazione posiz. corr. dopo oper.

puntatori ai blocchi di F letti

puntatori ai blocchi di F scritti

numero di interrupt richiesti

open 0 nessuno nessuno 4

lseek 1022 nessuno nessuno 0

write 1026 17, 24 17 3

read 1126 nessuno nessuno 0

lseek 926 nessuno nessuno 0

write 1950 17, 24, 13 24, 17, 24 6

close ---------- nessuno 13 1

B) ci sono tre buffer di memoria da 512 byte ciascuno, per contenere fino a tre blocchi dati del file F

operazione posiz. corr. dopo oper.

puntatori ai blocchi di F letti

puntatori ai blocchi di F scritti

numero di interrupt richiesti

open 0 nessuno nessuno 4

lseek 1022 nessuno nessuno 0

write 1026 17, 24 nessuno 2

read 1126 nessuno nessuno 0

lseek 926 nessuno nessuno 0

write 1950 13 nessuno 1

close ---------- nessuno 17, 24, 13 3

AXO – esame di martedì 1 marzo 2011 - CON SOLUZIONI pagina 6 di 16

esercizio n. 3 – processi e sistema operativo

prima parte – commutazione tra processi

Si considerino i seguenti frammenti di programma:

/∗ programma CODICE_UNO.c eseguito dai processi P e Q ∗/

main ( ) { char buff_1 [..], buff_2 [..]; char buff_3 [ ] = “fghilfghil”;

(1) fd1 = open (“/acso/file1”, O_RDWR); /∗ 4 blocchi ∗/

read (fd1, buff_1, 100); /∗ 1 blocco ∗/ pid1 = fork ( );

if (pid1 == 0) {

/∗ codice eseguito da Q figlio di P ∗/ (2) fd2 = open (“/acso/file2”, O_RDWR); /∗ 4 blocchi ∗/

(3) write (fd1, buff_3, 5); /∗ 1 blocco ∗/ ... exit (1);

} else {

/∗ codice eseguito dal padre P ∗/ pid1 = wait (&status); ... exit (0);

} /∗ end if ∗/

} /∗ CODICE_UNO ∗/

/∗ programma CODICE_DUE.c eseguito dal processo S ∗/

main ( ) { char buff [ ] = “abcdeabcde”;

(4) fd = open (“/acso/file1”, O_RDWR); /∗ 4 blocchi ∗/ lseek (fd, 100, 1); (5) write (fd, buff, 10); ... exit (2);

} /∗ CODICE_DUE ∗/

Sono dati due processi P e S:

• il processo P esegue il programma CODICE_UNO e crea il processo figlio Q

• il processo S esegue il programma CODICE_DUE

Nel sistema non ci sono altri processi utente oltre a P, S e Q.

AXO – esame di martedì 1 marzo 2011 - CON SOLUZIONI pagina 10 di 16

terza parte – funzioni del file system

Si consideri nuovamente il codice dei programmi e in particolare le chiamate di sistema identificate dai nu-meri d’ordine 1, 2, 3, 4 e 5.

CASO_1: nell’ipotesi che l’ordine di esecuzione delle chiamate di sistema considerate sia 1 2 4 3 5

• si completi il contenuto delle tabelle seguenti, indicando la sequenza dei valori assunti fino alla conclusione di 5 (tutti i processi sono ancora esistenti):

tab file del proc P

tab file del proc Q

tab file del proc S tabella globale dei file

file des rif riga file

des rif riga file des rif riga riga posizione

corrente n. di processi nome del file

0 X 0 X 0 X 0 X X X

1 X 1 X 1 X 1 X X X

2 X 2 X 2 X 2 X X X

3 3 3 3 3 5 3 0, 100, 105 1, 2 file1

4 L 4 4 4 L 4 0 1 file2

5 L 5 L 5 L 5 0, 100, 110 1 file1

6 L 6 L 6 L 6 L L L

• si scriva, al momento della conclusione di 5, il contenuto di file1 a partire dalla posizione 100: abcdeabcde

CASO_2: nell’ipotesi che l’ordine di esecuzione delle chiamate di sistema considerate sia 1 2 4 5 3

• si completi il contenuto delle tabelle seguenti, indicando la sequenza dei valori assunti fino alla conclusione di 3 (tutti i processi sono ancora esistenti):

tab file del proc P

tab file del proc Q

tab file del proc S tabella globale dei file

file des rif riga file

des rif riga file des rif riga riga posizione

corrente n. di processi nome del file

0 X 0 X 0 X 0 X X X

1 X 1 X 1 X 1 X X X

2 X 2 X 2 X 2 X X X

3 3 3 3 3 5 3 0, 100, 105 1, 2 file1

4 L 4 4 4 L 4 0 1 file2

5 L 5 L 5 L 5 0, 100, 110 1 file1

6 L 6 L 6 L 6 L L L

• si scriva, al momento della conclusione di 3, il contenuto di file1 a partire dalla posizione 100: fghilabcde