Gestione dei file: filosofia. carica in memoria l i-node del file read / write. close cose rilascia le strutture dati di memoria del file

Transcript

1 File system 1

2 Gestione dei file: filosofia open carica in memoria l i-node del file read / write accedono al file tramite il suo i-node close cose rilascia le strutture dati di memoria del file 2

3 Gestione File Gestione file: generalità Un file per essere usato deve essere aperto (open) L operazione open: localizza il file nel file system attraverso il suo pathname copia in memoria il descrittore del file (i-node) associa al file un intero non negativo (file descriptor), che verrà usato nelle operazioni di accesso al file, invece del pathname I file standard non devono essere aperti, perchè sono aperti dalla shell. Sono associati ai file descriptor 0 (input), 1 (output) e 2 (error). La close rende disponibile il file descriptor per ulteriori usi

4 Gestione File File Sharing File Sharing Unix supporta la condivisione dei file aperti tra processi differenti Tre strutture dati differenti sono utilizzate dal kernel Nel process control block di ogni processo è contenuta una tabella di descrittori di file aperti organizzata come vettore, indicizzata dal numero di descrittore Ad ogni entry della tabella sono associati: un flag del file descriptor un puntatore ad una tabella di file aperti

5 Gestione File Strutture dati Ogni entry della File Table contiene: il file status flag per il file (lettura, scrittura, append, etc.); il current file offset; un puntatore ad una entry della I-Node Table. Ogni entry della I-Node Table contiene: informazioni sul tipo di file; puntatori alle funzioni che operano sul file; copia dell i-node del file Alberto Montresor, Renzo Davoli 4

6 Gestione File: Strutture dati NON RESIDENTE (U-AREA) RESIDENTE Ø 1 2 File descriptor Table File Table I-node Table m read Ø 1 2 (Processo 1) File descriptor Table p write... 2 n write n... ref count modalità di apertura ref count in-core i-node (copia dell'i-node statico) (Processo( 2) ) offset di ultimo byte letto/scritto i-number i b logical device number flag di modificato Una entry per ogni file aperto da ogni processo (Globale) Una entry per ogni modalità di apertura di ogni file aperto (Globale) Una entry per ogni file aperto 5

7 Esempio Processo A fd1=open("/etc/passwd",o_rd ONLY); fd2=open("local",o O RDWR); 4 fd3=open("/etc/passwd",o_wr ONLY); User File descriptor Table File Table I-node Table (Processo A) count 1 Read count 3 (/etc/passwd) Processo B fd1=open("/etc/passwd",o_rd ONLY); fd2=open("private",o i t " O RDONLY ); count 1 count 1 Rd-Wrt Read count 1 (local) (Processo B) count 1 Write count 1 (private) count 1 Read 6 6

8 Visione d insieme Switcher l Kernel Ready queue System calls Interrupt Handlers I/O drivers Process Table File table i-node table Buffer pool U-Area File descriptor table U-Area Stack Dati Stack Dati... Stack Dati Testo Testo Testo Processo 1 Processo 2 Processo n 7

9 Gestione File Esempio: int fd;... fd=open(pathname,...); if (fd==-1) { /*gestione errore*/ }... read(fd,...);... write(fd,...);... close(fd); Nota: Un file può essere aperto più volte, e quindi avere più file descriptor associati contemporaneamente Alberto Montresor, Renzo Davoli 9

10 Gestione File int open(const char *path, int oflag,...); apre (o crea) il file specificato da pathname (assoluto o relativo), secondo la modalità specificata in oflag restituisce il file descriptor con il quale ci si riferirà al file successivamente (o -1 se errore) Valori di oflag O_RDONLY read-only (0) O_WRONLY write-only (1) O_RDWR read and write (2) Solo una di queste costanti può essere utilizzata in oflag Altre costanti (che vanno aggiunte in or ad una di queste tre) permettono di definire alcuni comportamenti particolari Le costanti sono definite in <fcntl.h>

11 Gestione File Valori di oflag: O_APPEND append O_CREAT creazione del file O_EXECL con O_CREAT, ritorna un errore se il file esiste O_TRUNC se il file esiste, viene svuotato O_NONBLOCK file speciali (discusso in seguito) O_SYNC synchronous write Se si specifica O_CREAT, è necessario specificare anche i permessi iniziali come terzo argomento; La maschera O_ACCMODE (uguale a 3) permette di isolare la modalità di accesso. oflag & O_ACCMODE può essere uguale a O_RDONLY, O_WRONLY, oppure O_RDWR Alberto Montresor, Renzo Davoli 11

12 Gestione File #include <fcntl.h> int creat(const char *path, mode_t mode); crea un nuovo file normale di specificato pathname, e lo apre in scrittura mode specifica i permessi iniziali; l'owner è l'effective user-id del processo se il file esiste già, lo svuota (owner e mode restano invariati) restituisce il file descriptor, o -1 se errore Equivalenze: creat(path, mode); open(path, O_WRONLY O_CREAT O_TRUNC, mode);

13 Gestione File int close(int filedes); chiude il file descriptor filedes restituisce l esito dell operazione (0 o -1) Nota: Quando un processo termina, tutti i suoi file vengono comunque chiusi automaticamente

14 Gestione File Ogni file aperto: e associato ad un current file offset, la posizione attuale all interno del file; un valore non negativo che misura il numero di byte dall inizio del file; operazioni read/write leggono dalla posizione attuale e incrementano il current file offset in avanti del numero di byte letti o scritti; quando viene aperto un file: Il current file descriptor viene posizionato a 0. a meno che l opzione O_APPEND non sia specificata Alberto Montresor, Renzo Davoli 14

15 Gestione File off_t lseek(int filedes, off_t offset, int whence); sposta la posizione corrente nel file filedes di offset bytes a partire dalla posizione specificata in whence: SEEK_SET dall'inizio del file SEEK_CUR dalla posizione corrente SEEK_END dalla fine del file restituisce la posizione corrente dopo la lseek, o -1 se errore Nota: La lseek non effettua alcuna operazione di I/O. Il valore di offset può anche essere negativo oppure 0 per recuperare la posizione corrente. Non tutti i files supportano l'operazione di lseek. lseek oltre la fine del file provocano dei buchi

16 Gestione File ssize_t read(int filedes, void *buf, size_t nbyte); legge in *buf una sequenza di nbyte byte dalla posizione corrente del file filedes; aggiorna la posizione corrente; restituisce il numero di bytes effettivamente letti, o -1 se errore; Esistono un certo numero di casi in cui il numero di byte letti è inferiore al numero di byte richiesti: Fine di un file regolare Per letture da stream provenienti dalla rete Per letture da terminale etc Alberto Montresor, Renzo Davoli 16

17 Gestione File ssize_t write(int filedes, const void *buf, size_t nbyte); scrive in *buf una sequenza di nbyte byte dalla posizione corrente del file filedes; aggiorna la posizione corrente; restituisce il numero di bytes effettivamente scritti, o -1 se errore Alberto Montresor, Renzo Davoli 17

18 Gestione File Esempio Copia lo standard input sullo standard output A seconda della dimensione di BUFFERSIZE si ottengono prestazioni differenti #define BUFFSIZE?? int main(void) { int n; char buf[buffsize]; while ( (n = read(stdin_fileno, buf, BUFFSIZE)) > 0) if (write(stdout_fileno, buf, n)!= n) { perror("write error"); exit(1); } if (n < 0) { perror("read error"); exit(1); } } exit(0);

19 Buffer cache user Level kernel Level trap user programs libraries system call interface kernel Level hardware Level file subsystem buffer cache character block device drivers process control subsystem hardware control hardware inter-process communication scheduler memory management 36

20 Buffer cache 37

21 Buffer cache 38

22 La buffer cache: lettura buffer buffer cache read(fd, buffer, n) processo kernel disco 18

23 La buffer cache: scrittura buffer buffer cache write(fd, buffer, n) processo kernel disco 19

24 Gestione File BUFFSIZE User CPU (seconds) System CPU (seconds) Clock time (seconds) # loops

25 Gestione File - Fcntl La funzione fcntl può cambiare le proprietà di un file aperto int fcntl(int filedes, int cmd, /* int arg */) Argomento 1: è il descrittore del file su cui operare Argomento 2: è il comando da eseguire Argomento 3: quando presente, parametro del comando; Comandi: duplicazione di file descriptor (F_DUPFD) get/set file descriptor flag (F_GETFD, F_SETFD) get/set file status flag (F_GETFL, F_SETFL) get/set async. I/O ownership (F_GETOWN, F_SETOWN) get/set record locks (F_GETLK, F_SETLK, F_SETLKW)

26 Gestione File - Fcntl int fcntl(int filedes, F_DUPFD, int min) Duplica il file descriptor specificato da filedes Ritorna il nuovo file descriptor Il file descriptor scelto è uguale al valore più basso corrispondente ad un file descriptor non aperto e che sia maggiore o uguale a min int fcntl(int filedes, F_GETFD) Ritorna i file descriptor flag associati a filedes Attualmente, è definito un solo file descriptor flag: FD_CLOEXEC (se true, il file descriptor sarà chiuso all'exec)

27 Gestione File int fcntl(int filedes, F_SETFD, int newflag) Modifica i file descriptor flag associati a filedes, utilizzando il terzo argomento come nuovo insieme di flag. int fcntl(int filedes, F_GETFL) Ritorna i file status flag associati a filedes; I file status flag sono quelli utilizzati nella funzione open; Per determinare la modalità di accesso, è possibile utilizzare la maschera ACC_MODE; Per determinare gli altri flag, è possibile utilizzare le costanti definite (O_APPEND, O_NONBLOCK, O_SYNC) Alberto Montresor, Renzo Davoli 23

28 Gestione File - Fcntl int fcntl(int filedes, F_SETFL, int newflag) Modifica i file status flag associati a filedes con il valore specificato in newflag I soli valori che possono essere modificati sono O_APPEND, O_NONBLOCK, O_SYNC; l access mode deve rimanere inalterato Che succede nell'esempio del buffer cache se abilitiamo O_SYNC?

29 Gestione File - Ioctl La funzione ioctl raccoglie tutti i comportamenti che non possono essere racchiusi nella interfaccia basata su file int iocntl(int filedes, int request, /*args*/); filedes è il descrittore del file stream request è la funzione di controllo selezionata e tipica di filedes args sono informazioni opzionali associate a request Categorie di comandi disk labels I/O file I/O magnetic tapes I/O socket I/O terminal I/O

30 Gestione File - Fsync La system call fsync() int fsync(int fildes); effettua l'operazione di "flush" dei dati bufferizzati dal s.o. per il file descriptor fildes (ovvero li scrive sul disco o sul dispositivo sottostante) Motivazione il gestore del file system può mantenere i dati in buffer in memoria per diversi secondi, prima di scriverli su disco per ragioni efficienza ritorna 0 in caso di successo, -1 altrimenti

31 Gestione File System - Select System call select() permette di aspettare contemporaneamente file descriptor multipli (con timeout) int select(int nfds, /* # of file descriptors */ fd_set *readfds, /* Read descriptor set */ fd_set *writefds, /* Write descriptor set */ fd_set *exceptfds, /* Exception descriptor set */ struct timeval *timeout); /* Timeout value */ Parametri di input nfsd è la dimensione massima dei sottoinsiemi *...fds sono i sets dei file descriptors realizzati tramite mappe di bit timeout è il timeout di attesa (opzionale) Parametri di output 0 timeout; -1 errore (see errno); k < 0 numero di descriptors pronti per l'i/o Modifica fd_set ponendo a 1 i bit relativi ai file descriptors pronti per l'i/o

32 Gestione File System - Select System call select() permette di aspettare contemporaneamente file descriptor multipli (con timeout) int select(int nfds, /* # of file descriptors */ fd_set *readfds, /* Read descriptor set */ fd_set *writefds, /* Write descriptor set */ fd_set *exceptfds, /* Exception descriptor set */ struct timeval *timeout); /* Timeout value */ Gestire fd_set FD_SET(fd, _fdset); /* add fd to _fdset */ FD_CLR(fd, _fdset); /* remove fd from _fdset*/ FD_ISSET(fd, _fdset); /* test if fd is in _fdset*/ FD_ZERO(_fdset); /* inizialize/clear _fdset*/ Esempio: if ( FD_ISSET(0,&readfds) ) { // Read input data from unit 0}

33 File e Directory open, read, write, close permettono di leggere e scrivere file regolari Ulteriori operazioni: leggere gli attributi di un file (stat) modificare gli attributi di un file (chmod, chown, chgrp, ) concetto di hard link (link, unlink, remove) lettura di directory

34 Gestione File : #include <sys/types.h> #include <sys/stat.h> int stat(const char *pathname, struct stat *buf); int fstat(int filedes, struct stat* buf); int lstat(const char *pathname, struct stat *buf); stat identifica il file tramite un pathname; fstat identifica un file aperto tramite il suo descrittore; lstat, se applicato ad un link simbolico, ritorna informazioni sul link simbolico, non sul file linkato Alberto Montresor, Renzo Davoli 28

35 Gestione File Il secondo argomento delle funzioni stat è un puntatore ad una struttura di informazioni sul file specificato struct stat { mode_t st_mode; // File type & mode ino_t st_ino; // i-node number dev_t st_dev; // device number (file system) dev_t st_rdev; // device n. for special files nlink_t st_nlink; // number of links uit_t uid; // user ID of owner gid_t gid; // group ID of owner off_t st_size; // size in bytes, for reg. files time_t st_atime; // time of last access time_t st_mtime; // time of last modif. time_t st_ctime; // time of last status change long st_blksize; // best I/O block size long st_blocks; // number of 512-byte blocks } Alberto Montresor, Renzo Davoli

36 File e Directory Tipo e accesso Tipi di file Campo st_mode struct stat sbuf; if ( stat(path,&sbuf) == -1 ) { /* error */} Macro per determinare il tipo di file File regolari S_ISREG(sbuf.st_mode) Directory file S_ISDIR(sbuf.st_mode) Character special file S_ISCHR(sbuf.st_mode) Block special file S_ISBLK(sbuf.st_mode) FIFO S_ISFIFO(sbuf.st_mode) Socket S_ISSOCK(sbuf.st_mode) Link simbolico S_ISLNK(sbuf.st_mode)

37 File e directory Tipo e accesso set-user-id e set-group-id: st_mode offre informazioni nell flag st_uid (set-user-id) per identificare l'effective user id: effective user id == st_uid Analogamente, st_mode offre informazioni nel flag st_gid (setgroup-id) per l'effective group id: effective group id == st_gid E possibile utilizzare questi due bit per risolvere il problema di passwd: l owner del comando passwd è root quando passwd viene eseguito, il suo effective user id è uguale a root il comando può modificare in scrittura il file /etc/passwd

38 File e directory Tipo e accesso Costanti per accedere ai diritti di lettura e scrittura contenuti in st_mode S_ISUID == 0x04000 set-user-id S_IRWXU == 0x00700 read/write/esecuzione, owner S_IRUSR == 0x00400 accesso in lettura, owner S_IWUSR == 0x00200 accesso in scrittura, owner S_IXUSR == 0x00100 accesso in esecuzione, owner S_IRGRP == 0x00040 accesso in lettura, gruppo S_IWGRP == 0x00020 accesso in scrittura, gruppo S_IXGRP == 0x00010 accesso in esecuzione, gruppo S_IROTH == 0x00004 accesso in lettura, altri S_IWOTH == 0x00002 accesso in scrittura, altri S_IXOTH == 0x00001 accesso in esecuzione, altri...

39 File e Directory Tipo e accesso System call: int access(const char* pathname, int mode) Quando si accede ad un file, vengono utilizzati effective uid e effective gid (inizialmente come i real ids ma possono cambiare) A volte, può essere necessario verificare l accessibilità in base a real uid e real gid Per fare questo, si utilizza access() Mode è un maschera ottenuta tramite bitwise or delle seguenti costanti: R_OK W_OK X_OK F_OK testa se si hanno i permessi di lettura testa se si hanno i permessi di scrittura testa se si hanno i permessi di esecuzione testa se il file esiste

40 File e Directory Tipo e accesso System call: mode_t umask(mode_t cmask); Cambia la maschera utilizzata per la creazione dei file (es. in open()). Ritorna la maschera precedentemente utilizzata. La maschera riguarda i permessi di rwx per utente, gruppo e others. Funzionamento: Si applica tutte le volte che un processo crea un nuovo file. I bit accesi in cmask disabilitano i rispettivi permessi nell'access mode del nuovo file.

41 File e Directory Tipo e accesso Esempio di umask: Supponiamo di voler aprire un file e di crearlo se non esiste. open(mfile, O_WRONLY O_CREAT..., mmode); In cui mmode è specificato come: (default) mmode == S_IRUSR S_IWUSR S_IRGRP S_IWRGRP S_IROTH S_IWOTH 0x666 Se la corrente umask è: (default) umask == S_IWGRP S_IWOTH 0x022 I permessi sul nuovo file saranno: mfile == S_IRUSR S_IWUSR S_IRGRP S_IROTH 0x0644 Schema mmode & ~umask

42 File e Directory Tipo e accesso System call: int chmod (const char* path, mode_t mode); int fchmod (int filedes, mode_t mode); int lchmod(const char *path, mode_t mode); Per cambiare i diritti su un file esistente. Opera su un pathname (chmod) o di un file aperto (fchmod) o di un link simbolico (lchmod) Per cambiare i diritti di un file: l effective_uid del processo deve essere uguale all owner del file oppure deve essere uguale a root

43 File e Directory Proprietario Alla creazione di un file L access mode del file viene scelto seguendo la modalità illustrata in precedenza. L'user id del proprietario è settato con l'effective uid del processo Per il group_id POSIX permette due possibilità: Può essere uguale allo effective gid del processo Può essere uguale al group id della directory in cui il file viene creato In alcuni sistemi, questo può dipendere dal bit set-group-id della directory in cui viene creato il file

44 File e Directory Proprietario System call: int chown(char* pathname, uid_t owner, gid_t group); int fchown(int filedes, uid_t owner, gid_t group); int lchown(char* pathname, uid_t owner, gid_t group); Queste tre funzioni cambiano lo user id e il group id di un file Nella prima, il file è specificato come pathname Nella seconda, il file aperto è specificato da un file descriptor Nella terza, si cambia il possessore del link simbolico, non del file stesso Restrizioni: In alcuni sistemi, solo il superutente può cambiare l owner di un file Costante POSIX_CHOWN_RESTRICTED definisce se tale restrizione è in vigore

45 File e Directory Hard link Hard link: Ogni i-node mantiene un contatore con il numero di hard link ad esso associati. Ogni link corrisponde ad una entry nella tabella di una directory. Operazioni: Linking: aggiungere un link ad un file Unlinking: rimuovere un link da un file In stat il campo st_nlink contiene il numero di link al file Solo quando il numero di link scende a zero è possibile rimuovere un file

46 File e Directory Hard link Suddivisione delle informazioni: gli inode mantengono tutte le informazioni sul file: dimensioni, permessi, puntatori ai blocchi dati, etc. le directory entry mantengono un file name e un inode number Limitazioni degli hard-link: la directory entry contiene un numero di inode sullo stesso file system non è possibile fare hard-linking con file su file system diversi in questo caso, si utilizzano symbolic link Hard link per directory: ogni directory dir ha un numero di hard link maggiore uguale a 2: Uno perché dir possiede un link nella sua directory genitore Uno perché dir possiede un entry. che punta a se stessa ogni sottodirectory di dir aggiunge un hard link: Uno perché la sottodirectory possiede un entry.. che punta alla directory genitore

47 File e Directory Hard link System call: int link(char* path, char* alias); crea un nuovo hard link per il file specificato da path operazione atomica: aggiunge la directory entry (riferita alla directori di alias) ed aumenta il numero di link del file individuato da path errori: path non esiste Una componente del path non esiste non è una directory la directory di destinazione per l'alias non è accessibile in scrittura path e alias non risiedono nello stesso file system... utilizzato dal comando ln

48 File e Directory Hard link System call: int unlink(char* path); int remove(char* path); rimuove un hard link per il file specificato da path operazione atomica: rimuove la directory entry e decrementa di uno il numero di link del file errori: path non esiste un utente diverso da root cerca di fare unlink su una directory utilizzato dal comando rm un file può essere effettivamente cancellato dall hard disk: quando il suo conteggio raggiunge 0

49 File e Directory Rename System call: int rename(char* oldpath, char* newpath); Cambia il nome di un file da oldpath a newpath Casi: se oldpath specifica un file regolare, newpath non può essere una directory esistente se oldpath specifica un file regolare e newpath è un file regolare esistente, questo viene rimosso e sostituito sono necessarie write permission su entrambe le directory se oldpath specifica una directory, newpath non può essere un file regolare esistente se oldpath specifica una directory, newpath non può essere una directory non vuota

50 File e Directory Link simbolici Un link simbolico: E un file speciale che contiene il pathname assoluto di un altro file E un puntatore indiretto ad un file (gli hard link invece sono puntatori diretti ad inode) Introdotto per superare le limitazioni degli hard link: hard link possibili solo fra file nello stesso file system hard link a directory possibili solo al superuser nota: questo comporta la possibilità di creare loop i programmi che analizzano il file system devono essere in grado di gestire questi loop Quando si utilizza una funzione, bisogna avere chiaro se: segue i link simbolici (la funzione si applica al file puntato dal link simbolico) non segue i link simbolici (la funzione si applica sul link) Funzioni che non seguono i link simbolici: lchown, lstat, readlink, remove, rename, unlink

51 Gestione File int symlink(char* oldpath, char* newpath); Crea una nuova directory entry newpath con un link simbolico che punta al file specificato da oldpath. oldpath e newpath non devono risiedere necessariamente nello stesso file system. int readlink(char* path, char* buf, int size); Copia in buf il valore del link simbolico. poiché la open segue il link simbolico, abbiamo bisogno di una system call per ottenere il contenuto del link simbolico Alberto Montresor, Renzo Davoli 45

52 File e Directory Tempi Tre valori temporali sono mantenuti nella struttura stat st_atime (opzione u in ls) Ultimo tempo di accesso read, creat/open (when creating a new file), utime st_mtime (default in ls) Ultimo tempo di modifica del contenuto write, creat/open, truncate, utime st_ctime (opzione c in ls) Ultimo cambiamento nello stato (nell inode) chmod, chown, creat, mkdir, open, remove, rename, truncate, link, unlink, utime, write

53 File e Directory Tempi System call #include <utime.h> int utime(char* pathname, struct utimbuf *times); struct utimbuf { time_t actime; time_t modtime; } Modifica il tempo di accesso e modifica del file puntato da pathname Il tempo di changed-status viene modificato automaticamente Nota Se times è null viene settato il tempo corrente L'effective user ID del processo deve essere il proprietario del file oppure il processo ha i diritti di scrittura sul file

54 File e Directory Directory int mkdir(char* path, mode_t); Crea una nuova directory vuota dal path specificato Modalità di accesso: I permessi specificati da mode_t vengono modificati in base ad umask L'UID è impostato all'effective UID Il GID è impostato al GID della directory parent oppure all'effective GID int rmdir(char* path); Rimuove la directory vuota specificata da path La directory deve essere vuota path non può essere un link simbolico o terminare con.,.. Se st_nlink della directory è 0: Non ci sono processi che la tengono aperta viene eliminata. Almeno un processo esiste ancora ma. e.. vengono rimossi.

55 File e Directory Directory Ogni processo: ha una directory corrente a partire dalla quale vengono fatte le ricerche per i pathname relativi System call: int chdir(char* path); int fchdir(int filedes); Cambia la directory corrente associata al processo, utilizzando un pathname oppure un file descriptor Funzione: char* getcwd(char* buf, size_t size); Legge la directory corrente e riporta il pathname assoluto nel buffer specificato da buf e di dimensione size

56 File e Directory Directory Leggere / scrivere directory Le directory possono essere lette da chiunque abbia accesso in lettura Solo il kernel può scrivere in una directory Per evitare problemi di consistenza I diritti di scrittura specificano la possibilità di utilizzare uno dei seguenti comandi: open, creat, unlink, remove, symlink, mkdir, rmdir Il formato del file speciale directory dipende dall implementazione di Unix Per questo motivo, esistono delle funzioni speciali per leggere il contenuto di una directory

57 File e Directory Directory Funzioni definite in dirent.h DIR *opendir(const char *pathname); Apre una directory e ne ritorna un puntatore di tipo DIR. NULL in caso di errore (e viene settato errno) struct dirent *readdir(dir *dp); Legge la prossima entry del puntatore a directory dp. Ritorna NULL se si raggiunge la fine della directory NULL in caso di errore e errno viene settato void rewinddir(dir *dp); Ritorna all'inizio della directory void closedir(dir *dp); Chiude la directory

58 Gestione File La struttura dirent è definita in dirent.h: struct dirent { } ino_t d_ino; // i-node number char d_name[name_max+1];// null-terminated name Note: la struttura DIR è una struttura interna utilizzata da queste quattro funzioni come "directory descriptor"; le entry di una directory vengono lette in un ordine non determinato a priori Alberto Montresor, Renzo Davoli 49