Modulo 13: System call relative al File System
Chiamate di sistema relative ai file
Restituzione
descrittore
Uso di namei
Assegnazione
Attributi
inode
open
creat
dup
pipe
close
open
stat
creat
link
chdir
unlink
chroot mknod
chown mount
chmod umount
creat
mknod
link
unlink
File System
Struttura Manipolazione
I/O
chown
chmod
stat
read
write
lseek
mount
umount
chdir
chroot
algoritmi di basso livello per il File System
namei
alloc
iget
iput
free
ialloc
ifree
bmap
algoritmi di allocazione dei buffer
getblk
Sistemi Operativi
brelse
bread
13.1
breada
bwrite
Laface 2001 - Bach
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);
}
Sistemi Operativi
13.2
Laface 2001 - Bach
Open - modo
• O_RDONLY
• O_WRONLY
• O_RDWR
• O_NDELAY
• O_APPEND
• O_CREAT
• O_TRUNC
• O_EXCL
………
Sistemi Operativi
13.3
Laface 2001 - Bach
Strutture dati relative al File System
fd1=open(“/etc/passwd”, O_RDONLY);
fd2=open(“local”, O_RDWR);
fd3=open(“/etc/passwd”, O_WRONLY);
Tabella dei descrittori
dei file dell'utente
0
1
2
3
4
5
6
Tabella dei file
Tabella degli inode
RC=1 Lettura
RC=2 (/etc/passwd)
RC=1 Lett./Scrit.
RC=1 Scrittura
Sistemi Operativi
13.4
RC=1 (local)
Laface 2001 - Bach
Strutture dati relative al File System
Tabella dei descrittori
dei file dell'utente
0
1
2
3
4
5
Tabella dei file
Tabella degli inode
RC=1 Scrittura
RC=3 (/etc/passwd)
RC=1 Lettura
RC=1 (local)
processo A
0
1
2
3
4
5
6
RC=1 Lettura
RC=1 Lett./Scritt.
RC=1 (private)
RC=1 Scrittura
fd1=open("/etc/passwd”, O_RDONLY);
processo B
Sistemi Operativi
fd2=open("private”, O_WRONLY);
13.5
Laface 2001 - Bach
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
Sistemi Operativi
13.6
Laface 2001 - Bach
read
procedura
read
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 all’utente;
recupera inode da tabella file;
blocca inode;
posiziona offset in byte nella uarea da offset di tabella file;
Sistemi Operativi
13.7
Laface 2001 - Bach
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);
}
Sistemi Operativi
13.8
Laface 2001 - Bach
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.
Sistemi Operativi
13.9
Laface 2001 - Bach
Read sequenziale
#include <fcntl.h>
20
main ()
{
int fd;
1024
char lilbuf[20],bigbuf[1024];
fd = open("/etc/passwd", O_RDONLY);
20
read(fd, lilbuf,20);
read(fd, bigbuf,1024);
read(fd, lilbuf, 20);
}
Sistemi Operativi
13.10
Laface 2001 - Bach
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.
Sistemi Operativi
13.11
Laface 2001 - Bach
Lettura e scrittura concorrente
#include <fcntl.h>
#include <fcntl.h>
/* processo A */
main ()
/*processo B */
{
main()
int fd;
{
char buf[512];
int fd,i;
fd = open("/etc/passwd",
O_RDONLY);
char buf[512];
read(fd, buf, sizeof(buf));
/* lettura 1 */
read(fd, buf, sizeof(buf));
/* lettura 2 */
}
for (i=0; i<sizeof(buf);i++)
buf[i]='a';
fd = open("/etc/passwd", O_WRONLY);
write(fd, buf, sizeof(buf));
/* scrittura 1 */
write(fd, buf, sizeof(buf));
/* scrittura 2 */
}
Sistemi Operativi
13.12
Laface 2001 - Bach
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);
fd2 = open("/etc/passwd", O_RDONLY);
read(fd1, buf1, sizeof(buf1));
read(fd2, buf2, sizeof(buf2));
}
Sistemi Operativi
13.13
Laface 2001 - Bach
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.
Sistemi Operativi
13.14
Laface 2001 - Bach
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.
Sistemi Operativi
13.15
Laface 2001 - Bach
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);
}
Sistemi Operativi
13.16
Laface 2001 - Bach
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);
}
}
Sistemi Operativi
13.17
Laface 2001 - Bach
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.
Sistemi Operativi
13.18
Laface 2001 - Bach
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.
Sistemi Operativi
13.19
Laface 2001 - Bach
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.
Sistemi Operativi
13.20
Laface 2001 - Bach
creat
procedura
creat
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);
}
}
Sistemi Operativi
13.21
Laface 2001 - Bach
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);
}
Sistemi Operativi
13.22
Laface 2001 - Bach
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
Sistemi Operativi
13.23
Laface 2001 - Bach
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.
Sistemi Operativi
13.24
Laface 2001 - Bach
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.
Sistemi Operativi
13.25
Laface 2001 - Bach
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.
Sistemi Operativi
13.26
Laface 2001 - Bach
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.
Sistemi Operativi
13.27
Laface 2001 - Bach