Laface 2001 - Bach 13.1 Sistemi Operativi Modulo 13: System call relative al File System Chiamate di...

Sistemi Operativi Laface 2001 - Bach13.1

Modulo 13: System call relative al File System

Chiamate di sistema relative ai file

algoritmi di allocazione dei buffer

getblk brelse bread breada bwrite

iget iput bmap

namei alloc free ialloc ifree

algoritmi di basso livello per il File System

opencreatduppipeclose

open statcreat linkchdir unlinkchroot mknodchown mountchmod umount

creatmknod

linkunlink

chownchmod

stat

readwritelseek

mountumount

chdirchroot

Restituzione descrittore

Uso di nameiAssegnazione

inodeAttributi I/O

File SystemStruttura Manipolazione


open

fd = open (pathname, flag, modo);

procedura open

input: nome del file, tipo di open, permessi per tipo creazione

output: descrittore file

{

converte nome file in inode (procedura namei);

if (file non esiste o accesso non permesso) return (errore);

alloca entry di tabella file per inode,

inizializza contatore e offset;

alloca descrittore file utente,

posiziona puntatore all’entry della file table;

if (tipo specifica troncamento)

libera tutti i blocchi del file (procedura free);

sblocca inode; /* bloccato in namei */

return (descrittore file utente);

}

procedura open

input: nome del file, tipo di open, permessi per tipo creazione

output: descrittore file

{

converte nome file in inode (procedura namei);

if (file non esiste o accesso non permesso) return (errore);

alloca entry di tabella file per inode,

inizializza contatore e offset;

alloca descrittore file utente,

posiziona puntatore all’entry della file table;

if (tipo specifica troncamento)

libera tutti i blocchi del file (procedura free);

sblocca inode; /* bloccato in namei */

return (descrittore file utente);

}


Open - modo

•O_RDONLY

•O_WRONLY

•O_RDWR

•O_NDELAY

•O_APPEND

•O_CREAT

•O_TRUNC

•O_EXCL

………


Strutture dati relative al File System

Tabella dei file Tabella degli inode Tabella dei descrittori dei file dell'utente

0123456

RC=1 Lettura

RC=1 Scrittura

RC=1 Lett./Scrit.

RC=2 (/etc/passwd)

RC=1 (local)

fd1=open(“/etc/passwd”, O_RDONLY);

fd2=open(“local”, O_RDWR);

fd3=open(“/etc/passwd”, O_WRONLY);


Strutture dati relative al File System

012345

processo A

Tabella dei file

RC=1 Lett./Scritt.

RC=1 Lettura

RC=1 Lettura

RC=1 Scrittura

RC=1 Scrittura RC=3 (/etc/passwd)

RC=1 (local)

RC=1 (private)

Tabella degli inode

Tabella dei descrittori dei file dell'utente

0123456

processo B

fd1=open("/etc/passwd”, O_RDONLY);

fd2=open("private”, O_WRONLY);


read

numero = read (fd, buffer, contatore);

per efficienza si caricano nella u-area i parametri di I/O:

modo lettura o scrittura

contatore numero di byte da leggere o scrivere

offset in byte nel file dove iniziare le operazioni di I/O

• address indirizzo in (da) cui copiare i dati

• flag indica se l’indirizzo è nello spazio kernel o user

Altre informazione nell’u-area sono:– La directory attuale– Eventuale changed root


read

procedura readinput: descrittore file utente indirizzo del buffer nel processo utente

numero byte da leggereoutput: contatore byte copiati nello spazio utente{recupera entry di tabella file dal descrittore file utente;controlla accessibilità a file; // ad ogni chiamataposiziona parametri nella u-area per indirizzo utente,contatore byte, I/O all’utente;recupera inode da tabella file;blocca inode;posiziona offset in byte nella uarea da offset di tabella file;

procedura readinput: descrittore file utente indirizzo del buffer nel processo utente

numero byte da leggereoutput: contatore byte copiati nello spazio utente{recupera entry di tabella file dal descrittore file utente;controlla accessibilità a file; // ad ogni chiamataposiziona parametri nella u-area per indirizzo utente,contatore byte, I/O all’utente;recupera inode da tabella file;blocca inode;posiziona offset in byte nella uarea da offset di tabella file;


read

while (contatore non soddisfatto){ converte offset in byte in blocco (procedura bmap); calcola offset nel blocco, numero byte da leggere; if (numero byte da leggere = 0) break; /* cerca di leggere end of file */ legge blocco (procedura breada) se richiesta lettura anticipata,

altrimenti procedura bread; copia i dati dal buffer di sistema allo spazio utente; aggiorna i campi della u-area per l’offset nel file,

contatore di lettura, indirizzo di scrittura nello spazio utente; rilascia il buffer;}unlock inode;aggiorna offset in tabella file per la successiva lettura;return (numero byte letti);}

while (contatore non soddisfatto){ converte offset in byte in blocco (procedura bmap); calcola offset nel blocco, numero byte da leggere; if (numero byte da leggere = 0) break; /* cerca di leggere end of file */ legge blocco (procedura breada) se richiesta lettura anticipata,

altrimenti procedura bread; copia i dati dal buffer di sistema allo spazio utente; aggiorna i campi della u-area per l’offset nel file,

contatore di lettura, indirizzo di scrittura nello spazio utente; rilascia il buffer;}unlock inode;aggiorna offset in tabella file per la successiva lettura;return (numero byte letti);}


read

• Il ciclo termina:– Naturalmente– Per EOF– Per errore lettura da device– Per errore nella copia sul buffer utente

• È diverso raggiungere l’EOF rispetto a leggere un blocco con puntatore = 0 nell’Inode.

• Lock rilasciato alla fine di una system call consistenza, ma possibilità di accesso a più processi.

• Sono necessari file e record locking per gestire l’accesso e la correzione di record in mutua esclusione.


Read sequenziale

#include <fcntl.h>

main ()

{

int fd;

char lilbuf[20],bigbuf[1024];

fd = open("/etc/passwd", O_RDONLY);

read(fd, lilbuf,20);

read(fd, bigbuf,1024);

read(fd, lilbuf, 20);

}

#include <fcntl.h>

main ()

{

int fd;

char lilbuf[20],bigbuf[1024];


read(fd, lilbuf,20);

read(fd, bigbuf,1024);

read(fd, lilbuf, 20);

}

20

1024

20


Lettura anticipata (Read ahead)

• Finché un processo esegue la read di due blocchi sequenziali, il kernel assume che tutte le letture successive siano sequenziali.

• Ad ogni iterazione del ciclo di lettura, il kernel salva il successivo numero di blocco logico nell’inode in memoria e durante le successive iterazioni verifica se il numero di blocco corrente coincide con quello precedentemente salvato.

• Se sono uguali, il kernel calcola il numero di blocco fisico per la lettura anticipata e salva il sua valore nella u-area per utilizzarlo nella procedura breada.


Lettura e scrittura concorrente

#include <fcntl.h>

/* processo A */

main ()

{

int fd;

char buf[512];


read(fd, buf, sizeof(buf));/* lettura 1 */


}

#include <fcntl.h>

/* processo A */

main ()

{

int fd;

char buf[512];




}

#include <fcntl.h>

/*processo B */

main()

{

int fd,i;

char buf[512];

for (i=0; i<sizeof(buf);i++)

buf[i]='a';

fd = open("/etc/passwd", O_WRONLY);

write(fd, buf, sizeof(buf));/* scrittura 1 */


}

#include <fcntl.h>

/*processo B */

main()

{

int fd,i;

char buf[512];

for (i=0; i<sizeof(buf);i++)

buf[i]='a';

fd = open("/etc/passwd", O_WRONLY);



}


Lettura di un file utilizzando due descrittori

#include <fcntl.h>

main ()

{

int fd1, fd2;

char buf1[512],buf2[512];

fd1 = open("/etc/passwd", O_RDONLY);


read(fd1, buf1, sizeof(buf1));


}

#include <fcntl.h>

main ()

{

int fd1, fd2;

char buf1[512],buf2[512];





}


write

numero = write (fd, buffer, contatore);

• Se all’offset in cui si desidera scrivere non corrisponde un blocco già allocato, il kernel alloca un nuovo blocco ed inserisce il puntatore nella posizione opportuna all’interno della tabella dei puntatori nell’Inode.

• Può essere necesssario allocare uno o più blocchi indiretti nel caso di offset > 10Kb (se la dimensione del blocco è 1 Kb).

• Il kernel, nel caso debba scrivere durante l’iterazione solo una parte del blocco, deve prima leggere il blocco da disco in modo da non sovrascrivere le parti invariate.

• Il kernel usa la scrittura ritardata dei dati su disco, favorendo un ulteriore processo che voglia accedere agli stessi dati evitando ulteriori operazioni su disco.

• Delayed write ottima per pipe e file temporanei.


lseek

posizione = lseek (fd, offset, riferimento);

• fd è il descrittore del file

• offset è l’offset in byte all’interno del file

• riferimento è un parametro che indica se l'offset deve essere considerato:

0 (SEEK_SET) : dall'inizio del file

1 (SEEK_CUR): dalla posizione corrente di offset

2 (SEEK_END): dalla fine file

• posizione indica l’offset in byte dal quale partirà la successiva operazione di read o write.


lseek

#include <fcntl.h>main (int argc, char **argv){int fd;fd = open(argv[1], O_CREAT, 0755);if (fd == -1) exit();lseek(fd, 1000000, 0);write(fd, ” ”, 1);}

#include <fcntl.h>main (int argc, char **argv){int fd;fd = open(argv[1], O_CREAT, 0755);if (fd == -1) exit();lseek(fd, 1000000, 0);write(fd, ” ”, 1);}


lseek

#include <fcntl.h>main (int argc, char **argv){/* viene letto il primo byte di ogni blocco da 1K */

int fd, skval;char c;if (argc!=2) exit ();fd = open(argv[1], O_RDONLY);if (fd == -1) exit();while ((skval = read(fd, &c, 1)) == 1) {

printf("char %c\n", c);skval = lseek(fd, 1023L, 1);printf("nuovo valore di seek %d\n", skval);

}}

#include <fcntl.h>main (int argc, char **argv){/* viene letto il primo byte di ogni blocco da 1K */

int fd, skval;char c;if (argc!=2) exit ();fd = open(argv[1], O_RDONLY);if (fd == -1) exit();while ((skval = read(fd, &c, 1)) == 1) {

printf("char %c\n", c);skval = lseek(fd, 1023L, 1);printf("nuovo valore di seek %d\n", skval);

}}


close

close(fd);

• Se il reference count presente nella entry della tabella degli inode è > 1, decrementa il contatore e termina.

• Se il reference count = 1, il kernel libera l’entry e rilascia l’inode allocato in memoria durante la open (iput).

• Quando la close termina rilascia anche la entry della tabella dei descrittori ed il descrittore associato non ha più alcun significato, finché non sarà riassegnato (attenzione non tutti i sistemi annullano la entry).

• Quando un processo esegue exit, il kernel esegue close su tutti i descrittori di quel processo ancora attivi in modo che nessun file possa essere tenuto aperto dopo il completamento del processo.


creat

fd = creat (pathname, modo);

• Se il file non esiste, il kernel lo crea con il nome ed il modo specificati

• Se il file già esiste viene troncato rilasciando tutti i blocchi dati e ponendo la dimensione del file uguale a 0.

• Il kernel analizza il pathname tramite la procedura namei e quando raggiunge l’ultima componente, salva il nome all’interno della prima entry libera presente nell’ultima directory incontrata nel pathname.

• Se non esiste alcun file con il nome desiderato, il kernel assegna un inode libero al nuovo file e crea una entry nella directory nella quale inserisce il nome del file ed il numero dell’inode appena allocato.

• Se il file già esisteva, il kernel cercando il nome trova il suo inode, inizializza la dimensione a 0 e libera i suoi blocchi di dati in modo che il file appaia come uno appena creato.


creat

• Se il processo che chiama creat ha i diritti di scrittura ed il file già esiste, l’owner ed i diritti di accesso del file non cambiano.

• Inoltre il kernel non controlla neppure che la directory padre del file esistente abbia i permessi di scrittura in quanto il contenuto della directory non cambia.


creat

procedura creatinput: nome file, permessioutput: descrittore file{prende inode per nome file (procedura namei);if (file già esistente){ if (accesso non permesso){ rilascia inode (procedura iput); return (errore); }}

procedura creatinput: nome file, permessioutput: descrittore file{prende inode per nome file (procedura namei);if (file già esistente){ if (accesso non permesso){ rilascia inode (procedura iput); return (errore); }}


creat

else { /* file non esistente */ assegna inode libero da file system (ialloc); crea nuova entry nella directory (include nomefile e numero inode appena assegnato); (notare: prima si scrive su disco l’Inode, poi si scrive nella directory)}alloca entry di tabella dei file per l'inode,inizializza count;if (file esistente alla creazione) libera tutti i blocchi di disco (procedura free);unlock inode;return (descrittore file utente);}

else { /* file non esistente */ assegna inode libero da file system (ialloc); crea nuova entry nella directory (include nomefile e numero inode appena assegnato); (notare: prima si scrive su disco l’Inode, poi si scrive nella directory)}alloca entry di tabella dei file per l'inode,inizializza count;if (file esistente alla creazione) libera tutti i blocchi di disco (procedura free);unlock inode;return (descrittore file utente);}


mknod

mknod (pathname, tipo e permessi, dispositivo);

•pathname è il nome del file da creare,

•tipo e permessi rappresentano il tipo di file da creare ed i permessi associati

•dispositivo specifica il major e il minor number del dispositivo


chdir

chdir ( pathname );

•pathname è il percorso delle directory che dovrà diventare quella corrente.

•chdir cerca innanzitutto l’Inode nella directory destinataria mediante namei e controlla che il file sia una directory e che il processo abbia i diritti per accedervi.

• Rilascia il blocco dell’Inode e dopo aver decrementato il contatore di riferimenti della vecchia directory corrente, memorizza il nuovo Inode della directory corrente nella u-area.

• L’Inode della directory corrente viene rilasciato dopo che il processo ha effettuato una nuova chdir oppure una exit.


chroot

chroot (pathname);

• Serve per cambiare la directory root del File System.

• Il kernel mantiene una variabile globale che punta all’inode della radice del File System, la quale viene usata ogni qualvolta un pathname inizia con un ”/”.

• Per mezzo di chroot tale variabile punta ad una nuova directory e che il processo e tutti i suoi discendenti vedono come root del File System.


chown - chmod

chown (pathname, proprietario, gruppo);

chmod (pathname, nodo);

• Il cambiamento di proprietario o modo (permessi di accesso) di un file sono operazioni sull’Inode e non sul file stesso

• Per cambiare il proprietario di un file, il processo deve essere il superuser o il proprietario del file.

• Tramite namei il pathname viene convertito nel relativo Inode, nel quale viene inserito il nuovo proprietario e gruppo o il nuovo insieme di diritti di accesso.


stat - fstat

stat (pathname, buffer);

fstat (fd, buffer);

•pathname è il nome del file

•fd è il suo descrittore

•buffer è l’indirizzo di una struttura dati adatta a contenere le informazioni di ritorno

• Consentono ai processi di leggere lo stato di un file, restituendo informazioni come il tipo del file, il proprietario, i permessi di accesso, la dimensione, il numero di link, il numero dell’Inode ed le date di accesso, e modifica al file.

Laface 2001 - Bach 13.1 Sistemi Operativi Modulo 13: System call relative al File System Chiamate di...

Documents

Transcript of Laface 2001 - Bach 13.1 Sistemi Operativi Modulo 13: System call relative al File System Chiamate di...