La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Laface 2001 - Bach 13.1 Sistemi Operativi Modulo 13: System call relative al File System Chiamate di sistema relative ai file algoritmi di allocazione.

Presentazioni simili


Presentazione sul tema: "Laface 2001 - Bach 13.1 Sistemi Operativi Modulo 13: System call relative al File System Chiamate di sistema relative ai file algoritmi di allocazione."— Transcript della presentazione:

1 Laface Bach 13.1 Sistemi Operativi 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 freeialloc ifree algoritmi di basso livello per il File System open creat dup pipe close open stat creat link chdir unlink chroot mknod chown mount chmod umount creat mknod link unlink chown chmod stat read write lseek mount umount chdir chroot Restituzione descrittore Uso di namei Assegnazione inode AttributiI/O File System Struttura Manipolazione

2 Laface Bach 13.2 Sistemi Operativi open fd = open (pathname, flag, modo); proceduraopen 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 allentry della file table; if (tipo specifica troncamento) libera tutti i blocchi del file (procedura free); sblocca inode;/* bloccato in namei */ return (descrittore file utente); } proceduraopen 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 allentry della file table; if (tipo specifica troncamento) libera tutti i blocchi del file (procedura free); sblocca inode;/* bloccato in namei */ return (descrittore file utente); }

3 Laface Bach 13.3 Sistemi Operativi Open - modo O_RDONLY O_WRONLY O_RDWR O_NDELAY O_APPEND O_CREAT O_TRUNC O_EXCL ………

4 Laface Bach 13.4 Sistemi Operativi Strutture dati relative al File System Tabella dei file Tabella degli inode Tabella dei descrittori dei file dell'utente 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);

5 Laface Bach 13.5 Sistemi Operativi Strutture dati relative al File System processo A Tabella dei file RC=1 Lett./Scritt. RC=1 Lettura RC=1 Scrittura RC=3 (/etc/passwd) RC=1 (local) RC=1 (private) Tabella degli inode Tabella dei descrittori dei file dell'utente processo B fd1=open("/etc/passwd, O_RDONLY); fd2=open("private, O_WRONLY);

6 Laface Bach 13.6 Sistemi Operativi read numero = read (fd, buffer, contatore); per efficienza si caricano nella u-area i parametri di I/O: modolettura o scrittura contatorenumero di byte da leggere o scrivere offsetin byte nel file dove iniziare le operazioni di I/O addressindirizzo in (da) cui copiare i dati flag indica se lindirizzo è nello spazio kernel o user Altre informazione nellu-area sono: –La directory attuale –Eventuale changed root

7 Laface Bach 13.7 Sistemi Operativi read proceduraread input:descrittore file utente indirizzo del buffer nel processo utente numero byte da leggere output:contatore byte copiati nello spazio utente { recupera entry di tabella file dal descrittore file utente; controlla accessibilità a file; // ad ogni chiamata posiziona parametri nella u-area per indirizzo utente,contatore byte, I/O allutente; recupera inode da tabella file; blocca inode; posiziona offset in byte nella uarea da offset di tabella file; proceduraread input:descrittore file utente indirizzo del buffer nel processo utente numero byte da leggere output:contatore byte copiati nello spazio utente { recupera entry di tabella file dal descrittore file utente; controlla accessibilità a file; // ad ogni chiamata posiziona parametri nella u-area per indirizzo utente,contatore byte, I/O allutente; recupera inode da tabella file; blocca inode; posiziona offset in byte nella uarea da offset di tabella file;

8 Laface Bach 13.8 Sistemi Operativi 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 loffset 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 loffset 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); }

9 Laface Bach 13.9 Sistemi Operativi read Il ciclo termina: –Naturalmente –Per EOF –Per errore lettura da device –Per errore nella copia sul buffer utente È diverso raggiungere lEOF rispetto a leggere un blocco con puntatore = 0 nellInode. Lock rilasciato alla fine di una system call consistenza, ma possibilità di accesso a più processi. Sono necessari file e record locking per gestire laccesso e la correzione di record in mutua esclusione.

10 Laface Bach Sistemi Operativi Read sequenziale #include 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 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); }

11 Laface Bach Sistemi Operativi 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 nellinode 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.

12 Laface Bach Sistemi Operativi Lettura e scrittura concorrente #include /* processo A */ main () { int fd; char buf[512]; fd = open("/etc/passwd", O_RDONLY); read(fd, buf, sizeof(buf)); /* lettura 1 */ read(fd, buf, sizeof(buf)); /* lettura 2 */ } #include /* processo A */ main () { int fd; char buf[512]; fd = open("/etc/passwd", O_RDONLY); read(fd, buf, sizeof(buf)); /* lettura 1 */ read(fd, buf, sizeof(buf)); /* lettura 2 */ } #include /*processo B */ main() { int fd,i; char buf[512]; for (i=0; i

13 Laface Bach Sistemi Operativi Lettura di un file utilizzando due descrittori #include main () { int fd1, fd2; char buf1[512],buf2[512]; fd1 = open("/etc/passwd", O_RDONLY); fd2 = open("/etc/passwd", O_RDONLY); read(fd1, buf1, sizeof(buf1)); read(fd2, buf2, sizeof(buf2)); } #include main () { int fd1, fd2; char buf1[512],buf2[512]; fd1 = open("/etc/passwd", O_RDONLY); fd2 = open("/etc/passwd", O_RDONLY); read(fd1, buf1, sizeof(buf1)); read(fd2, buf2, sizeof(buf2)); }

14 Laface Bach Sistemi Operativi write numero = write (fd, buffer, contatore); Se alloffset in cui si desidera scrivere non corrisponde un blocco già allocato, il kernel alloca un nuovo blocco ed inserisce il puntatore nella posizione opportuna allinterno della tabella dei puntatori nellInode. 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 literazione 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.

15 Laface Bach Sistemi Operativi lseek posizione = lseek (fd, offset, riferimento); fd è il descrittore del file offset è loffset in byte allinterno 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 loffset in byte dal quale partirà la successiva operazione di read o write.

16 Laface Bach Sistemi Operativi lseek #include main (int argc, char **argv) { int fd; fd = open(argv[1], O_CREAT, 0755); if (fd == -1) exit(); lseek(fd, , 0); write(fd,, 1); } #include main (int argc, char **argv) { int fd; fd = open(argv[1], O_CREAT, 0755); if (fd == -1) exit(); lseek(fd, , 0); write(fd,, 1); }

17 Laface Bach Sistemi Operativi lseek #include 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 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); }

18 Laface Bach Sistemi Operativi 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 lentry e rilascia linode 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.

19 Laface Bach Sistemi Operativi 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 lultima componente, salva il nome allinterno della prima entry libera presente nellultima 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 dellinode 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.

20 Laface Bach Sistemi Operativi creat Se il processo che chiama creat ha i diritti di scrittura ed il file già esiste, lowner 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.

21 Laface Bach Sistemi Operativi creat proceduracreat input:nome file, permessi output:descrittore file { prende inode per nome file (procedura namei); if (file già esistente){ if (accesso non permesso){ rilascia inode (procedura iput); return (errore); } proceduracreat input:nome file, permessi output:descrittore file { prende inode per nome file (procedura namei); if (file già esistente){ if (accesso non permesso){ rilascia inode (procedura iput); return (errore); }

22 Laface Bach Sistemi Operativi 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 lInode, 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 lInode, 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); }

23 Laface Bach Sistemi Operativi 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

24 Laface Bach Sistemi Operativi chdir chdir ( pathname ); pathname è il percorso delle directory che dovrà diventare quella corrente. chdir cerca innanzitutto lInode 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 dellInode e dopo aver decrementato il contatore di riferimenti della vecchia directory corrente, memorizza il nuovo Inode della directory corrente nella u-area. LInode della directory corrente viene rilasciato dopo che il processo ha effettuato una nuova chdir oppure una exit.

25 Laface Bach Sistemi Operativi chroot chroot (pathname); Serve per cambiare la directory root del File System. Il kernel mantiene una variabile globale che punta allinode 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.

26 Laface Bach Sistemi Operativi chown - chmod chown (pathname, proprietario, gruppo); chmod (pathname, nodo); Il cambiamento di proprietario o modo (permessi di accesso) di un file sono operazioni sullInode 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.

27 Laface Bach Sistemi Operativi stat - fstat stat (pathname, buffer); fstat (fd, buffer); pathname è il nome del file fd è il suo descrittore buffer è lindirizzo 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 dellInode ed le date di accesso, e modifica al file.


Scaricare ppt "Laface 2001 - Bach 13.1 Sistemi Operativi Modulo 13: System call relative al File System Chiamate di sistema relative ai file algoritmi di allocazione."

Presentazioni simili


Annunci Google