Gestione delle directory

Program m azione di Sist em a – 2a
Lucidi per il corso di Laboratorio di Sistemi Operativi tenuto da Paolo Baldan presso l'Università Ca' Foscari di
Venezia, anno accademico 2004/ 2005. Parte di questo materiale è rielaborato dai lucidi del Corso di Laboratorio di
Sistemi Operativi tenuto da Rosario Pugliese presso l'Università di Firenze, anno accademico 2001/ 02.
Gest ione File: Manipolare le inform azioni
Operazioni che consent ono di accedere / m odificare le
inform azioni associat e ai file
Gest ire i link (hard e sim bolici)
link(), unlink(), symlink()
Ot t enere inform azioni su file e direct ory
stat(), getdents()
Cam biare propriet ario, gruppo e perm essi dei file
chown(), lchown(), fchown()
chmod(), fchmod()
Duplicare e condividere descrit t ori
dup(), dup2()
Operare sui descrit t ori di file
fctnl(), ioctl()
2
Gest ione dei Link
Ricordiam o che in Unix le inform azioni relat ive ai file
sono m em orizzat e negli i-node
i-node
Dat a
At tributes
...
Direct
blocks (12)
Single indirect
Double indirect
Triple indirect
...
Dat a
...
Index
Dat a
Dat a
...
Dat a
.
.
Index .
.
Index .
.
...
Dat a
Index
3
Gest ione dei Link
Per le direct ory, i blocchi dat i sono del t ipo
i- n ode
Nom e File
i- n ode
Nom e File
i- n ode
Nom e File
...
....
ovvero cont engono una list a di nom i di file (i file
cont enut i nella direct ory), e indici di i-node.
Varie ent ry di direct ory possono punt are allo st esso inode, che quindi può corrispondere a vari nom i di file.
Ogni i-node ha associat o un cont at ore di link (hard).
L'i-node è deallocat o quando il cont at ore scende a 0 (l'inode non è più riferit o da alcun nom e).
4
Gest ione dei Link: Direct ory
I link (hard) alle direct ory possono essere creat i solo
dal kernel (per m ant enere una st rut t ura consist ent e).
Ogni direct ory dir ha un num ero di link hard m aggiore
o uguale a due
com e ogni file, dir ha un link nella direct ory genit ore
cont iene una ent ry “ .” che punt a a se st essa.
Ogni sot t odirect ory di dir aggiunge un hard link
la sot t odirect ory cont iene una ent ry “ ..” che punt a alla
direct ory genit ore.
5
Creare Hard Link
int link(const char *oldPath,
const char *newPath)
Crea un nuovo collegam ent o (hard link) newPath al file
cui è già collegat o oldPath.
Viene creat o una nuova direct ory ent ry newPath che
condivide l'i-node di oldPath.
Il cont at ore dei link hard associat o all'i-node è
increm ent at o di una unit à (il suo valore può essere
esam inat o t ram it e il com ando ls -l).
Se newPath esist e, non viene sovrascrit t o (fallisce).
Rest it uisce 0, se ha successo; -1, alt rim ent i.
6
Creare Hard Link
Quando il link è creat o
i l nuovo nom e può essere usat o esat t am ent e com e il
vecchio per ogni operazione;
ent ram bi riferiscono lo st esso i-node (e quindi hanno gli
st essi perm essi e possessore) ed è im possibile dire quale
fosse il nom e originale.
Un file è effet t ivam ent e cancellat o dal file syst em
(spazio su disco deallocat o) solo quando t ut t i i suoi
link hard sono st at i rim ossi.
Se newPath e oldPath risiedono su file syst em
different i, non può essere creat o un hard link e
link() fallisce; in quest o caso si ut ilizza symlink().
7
Creare Link Sim bolici
int symlink(const char *oldPath,
const char *newPath)
Crea un file speciale, det t o link sim bolico (o soft ),
newPath che cont iene la st ringa oldPath.
Se newPath esist e, non viene sovrascrit t o (e fallisce).
Rest it uisce 0, se ha successo; -1, alt rim ent i.
I link sim bolici sono int erpret at i a “ run-t im e”
Se si opera sul link sim bolico con op(nome), il nucleo lo
dereferenzia aut om at icam ent e ed opera sul t arget .
Tut t avia, alcune operazioni (per esem pio, la rim ozione)
agiscono diret t am ent e sul link sim bolico.
Il link può punt are ad un file non esist ent e
(Es. ln -s link nonexistent; cat link).
8
Rim uovere Hard Link
int unlink(const char *fileName)
Rim uove il link hard fileName all'i-node corrisp.
Se fileName è l'ult im o link all'i-node, le risorse assegnat e
al file vengono deallocat e.
La ent ry relat iva è im m ediat . rim ossa dalla direct ory, m a
se il file è apert o da qualche processo, il file viene effet t iv.
deallocat o solo dopo che t ut t i i descrit t ori sono st at i chiusi.
Quindi un eseguibile può effet t uare un unlink() su di un
file durant e l'esecuzione ed usarlo fino al com plet am ent o.
Ut ile per creare file t em poranei che spariscono alla
t erm inazione del processo (anche in caso di crash).
Esem pio: rim uove il file t em poraneo tmpName
if (standardInput) unlink (tmpName);
9
Esem pio: unlinkTm p.c
/* unlinkTmp <file>
Crea un file temporaneo.
Se e` stato passato l'argomento <file>, crea un link hard
tra <file> ed il file creato.
Cancella il file temporaneo, scrive su questo, e mostra che
si puo` effettivamente ancora leggere.
Se e` stato specificato <file>, al termine questo contiene
quanto scritto nel file temporaneo, altrimenti il file
temporaneo, con il suo contenuto spariscono */
#include
#include
#include
#include
#include
#include
<sys/types.h>
<sys/stat.h>
<fcntl.h>
<stdio.h>
<unistd.h>
<string.h>
#define MSG "Il file temporaneo esiste ancora"
10
Esem pio: unlinkTm p.c
int main(int argc, char *argv[]) {
int charRead, fd;
char buf[100];
/* crea il file temporaneo */
fd = open("tempfile.tmp", O_RDWR | O_CREAT | O_TRUNC, 0600);
if (argv[1]) /* crea un link all'eventuale argomento */
link("tempfile.tmp", argv[1]);
unlink("tempfile.tmp");
/* cancella il file temporaneo */
/* scrive sul file descriptor che corrisponde al file temporaneo */
write(fd, MSG, strlen(MSG));
/* torna all'inizio del file, legge e comunica l'avvenuta lettura */
lseek(fd, SEEK_SET, 0);
charRead = read(fd, buf, 100);
buf[charRead]= '\0';
printf("Sono riuscito a leggere \"%s\"\n", buf); }
11
Esem pio: unlinkTm p.c
$ unlinkTmp
Sono riuscito a leggere "Il file temporaneo esiste ancora"
$ ls tempfile.tmp
ls: tempfile.tmp: no such file or directory
$ unlinkTmp prova
Sono riuscito a leggere "Il file temporaneo esiste ancora"
$ ls tempfile.tmp prova
ls: tempfile.tmp: no such file or directory
4 prova
$ cat prova
Il file temporaneo esiste ancora
12
Ot t enere Inform azioni sui File: st at ()
int stat(const char *name, struct stat *buf)
int lstat(const char *name, struct stat *buf)
int fstat(int fd, struct stat *buf)
stat() copia in buf inform azioni sul file name.
lstat() rest it uisce inform azioni sul link sim bolico name
piut t ost o che sul file cui fa riferim ent o.
fstat() opera com e stat(), m a ha com e argom ent o un
descrit t ore di file fd anziché un nom e di file.
Per usarle includere i file sys/stat.h e unistd.h.
Non occorre avere dirit t o di accesso al file m a è
necessario avere dirit t i di ricerca (x) su t ut t e le
direct ory nel pat h del file.
13
Ot t enere Inform azioni sui File
Il secondo argom ent o delle funzioni stat è un
punt at ore ad una st rut t ura di inform azioni sul file
specificat o
struct stat {
mode_t
st_mode;
ino_t
st_ino;
dev_t
st_dev;
dev_t
st_rdev;
nlink_t
st_nlink;
uit_t
st_uid;
gid_t
st_gid;
off_t
st_size;
time_t
st_atime;
time_t
st_mtime;
time_t
st_ctime;
long
st_blksize;
long
st_blocks;
}
//
//
//
//
//
//
//
//
//
//
//
//
//
File type & mode
i-node number
device number (file system)
device n. for special files
number of links
user ID of owner
group ID of owner
size in bytes, for reg. files
time of last access
time of last modif.
time of last status change
best I/O block size
number of 512-byte blocks
14
Ricavare il t ipo di file da st _m ode
Macro per det erm inare il t ipo di file
File regolari
S_ISREG()
Direct ory file
S_ISDIR()
Charact er special file S_ISCHR()
Device a caratt eri (es. /dev/console)
Block special file
S_ISBLK()
File speciale a blocchi (es. /dev/fd0)
FIFO
S_ISFIFO()
File ut ilizzat o per int erprocess com m unication (nam ed pipe)
Socket
S_ISSOCK()
File ut ilizzat o per com unicazione di rete (e non) fra processi.
Link sim bolico
S_ISLNK()
15
Esem pio: filet ype.c
/* filetype <fileName>+: verifica il tipo di fileName
e lo segnala */
#include
#include
#include
<sys/types.h>
<sys/stat.h>
<unistd.h>
int main(int argc, char *argv[])
{
int i;
struct stat buf;
char *ptr;
for (i = 1; i < argc; i++) {
printf("%s: ", argv[i]);
if (lstat(argv[i], &buf) < 0) {
perror("lstat error");
continue;
}
16
Esem pio: filet ype.c
/* filetype.c : continua */
if
(S_ISREG(buf.st_mode)) ptr = "regular";
else if (S_ISDIR(buf.st_mode)) ptr = "directory";
else if (S_ISCHR(buf.st_mode)) ptr = "character special";
else if (S_ISBLK(buf.st_mode)) ptr = "block special";
else if (S_ISFIFO(buf.st_mode)) ptr = "fifo";
#ifdef S_ISLNK
else if (S_ISLNK(buf.st_mode)) ptr = "symbolic link";
#endif
else if (S_ISSOCK(buf.st_mode)) ptr = "socket";
else
ptr = "** unknown mode **";
printf("%s\n", ptr);
}
exit(0);
}
17
Esem pio: filet ype.c
$ filetype /etc/passwd /etc /dev/ttya0 /dev/sda /bin/sh
/etc/passwd: regular
/etc: directory
/dev/ttya0: character special
/dev/sda: block special
/bin/sh: symbolic link
18
Real e Effect ive ID
Ogni processo possiede vari ID
real user ID, real group ID
ident ificano l’ ut ent e e il gruppo reale che esegue il proc.
sono let t i dalla ent ry dell'ut ent e nel passwd file
norm alm ent e non cam biano durant e la vit a di un proc.
effect ive user ID, effect ive group ID, supplem ent ary
group Ids
id effet t ivam ent e ut ilizzat i per det erm inare i dirit t i di
accesso al file syst em
saved set -user-ID, saved set -group-ID
cont engono copie di effect ive user id e effect ive group
id; ut ilizzat i con la syst em call setuid
19
Real e Effect ive ID: Accesso ai file
Modalit à di accesso ad un file:
effect ive uid, effect ive gid, supplem ent ary gids sono
propriet à del processo in esecuzione
owner e group owner sono propriet à del file a cui si vuole
accedere
Algorit m o per l'accesso ad un file
IF (effect ive uid = = 0)* THEN a llow e d
/* 0 è l'u id d i r oot * /
ELSE IF (effect ive uid = = owner) & (user perm ission)
THEN a llow e d
ELSE IF ({ effect ive gid} ∪ supplem ent ary gids ⊇ { group owner} )
& (group perm ission) THEN a llow e d
ELSE IF (ot her perm ission) THEN a llow e d
ELSE d e n ie d
20
Alt ri det t agli
Per aprire un file per nom e
Abbiam o bisogno dei dirit t i di esecuzione (x - search) su
t ut t e le direct ory che fanno part e del nom e.
At t enzione ai nom i relat ivi: current direct ory è im plicit a.
Per creare un nuovo file in una direct ory
Abbiam o bisogno dei dirit t i di esecuzione (x) e scrit t ura
(w) sulla direct ory.
Per cancellare un file in una direct ory
Abbiam o bisogno dei dirit t i di esecuzione (x) e scrit t ura
(w) sulla direct ory.
Non abbiam o bisogno di dirit t i sul file.
21
Real e Effect ive ID: Possibile uso
Norm alm ent e
effect ive user id = = real user id
effect ive group id = = real group id
ovvero, i dirit t i di accesso sono det erm inat i dall'ut ent e
che esegue il program m a
Talvolt a è desiderabile un com port am ent o diverso
pot rebbe esser necessario che un processo abbia (in un
dat o m om ent o) dirit t i m aggiori di chi esegue il progr.
Esem pio: com ando passwd
Eseguit o da chiunque
Deve avere la possibilit à di cam biare il file /etc/passwd
22
Real e Effect ive ID e il cam po st _m ode
set -user-ID e set -group-ID
se il flag set -user-ID in st_mode è at t ivo, quando il file
viene eseguit o
effect ive user id = = st_uid
se il flag set -group-ID in st_mode è at t ivo, quando il file
viene eseguit o
effect ive group id = = st_gid
Quest i flag risolvono il problem a di passwd
l’owner del com ando passwd è root
quando passwd viene eseguit o, il suo effect ive user id è
uguale a root
il com ando può accedere in scrit t ura al file /etc/passwd
23
Cost ant i per accedere st _m ode
Cost ant i per accedere ai dirit t i di let t ura e scrit t ura
cont enut i in st_mode
S_ISUID
S_ISGID
S_IRUSR
S_IWUSR
S_IXUSR
S_IRGRP
S_IWGRP
S_IXGRP
S_IROTH
S_IWOTH
S_IXOTH
set -user-ID
set -group-ID
accesso in let t ura, owner
accesso in scrit t ura, owner
accesso in esecuzione, owner
accesso in let t ura, gruppo
accesso in scrit t ura, gruppo
accesso in esecuzione, gruppo
accesso in let t ura, alt ri
accesso in scrit t ura, alt ri
accesso in esecuzione, alt ri
24
Ot t enere Inform azioni sulle Direct ory
int getdents(int fd, struct dirent *buf,
int structSize)
Legge un cert o num ero di st rut t ure del t ipo struct
dirent dal file della direct ory riferit a da fd e le
m em orizza nell'area di m em oria punt at a da buf.
structSize è la grandezza dell'area di m em oria.
Rest it uisce
il num ero di byt e let t i, se ha successo;
0 quando l'ult im a ent ry è già st at a let t a;
-1 in caso di errore.
25
Ot t enere Inform azioni sulle Direct ory
La st rut t ura dirent
definit a in sys/dirent.h
cont iene inform azioni su una ent ry della direct ory.
Ha la seguent e st rut t ura
struct dirent {
long d_ino;
off_t d_off;
unsigned short d_reclen;
char d_name [NAME_MAX+1];
}
/*
/*
/*
/*
numero di
offset di
lunghezza
nome file
inode */
questa dirent */
effettiva di d_name */
(null-terminated) */
26
Ot t enere Inform azioni sulle Direct ory
La syst em call getdents è obsolet a e non sem pre
disponibile. Alt ernat ivam ent e...
DIR *opendir(const char *pathname);
Apre una direct ory; rit orna un punt at ore se t ut t o è ok,
NULL in caso di errore
struct dirent *readdir(DIR *dp);
Rit orna un punt at ore ad una st rut t ura dat i cont enent e
inform azioni sulla prossim a ent ry, NULL se fine della
direct ory o errore
void rewinddir(DIR *dp);
Rit orna all'inizio della direct ory
void closedir(DIR *dp);
Chiude la direct ory
27
Esem pio: list Dirs.c
/* listDirs {dirName}*: elenca i file nelle directory date come
argomento, o della cwd, se non viene passato alcun argomento */
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
/* elenca tutti i file della directory dirName */
void listDir (char *dirName) {
DIR *fdir;
struct dirent *myentry;
fdir = opendir(dirName); /* apre la directory */
if (fdir == NULL) {
perror("listDirs");
exit(-1);
}
28
Esem pio: list Dirs.c
printf("Directory: %s\n", dirName);
/* elenca tutti i file della directory */
while ((myentry = readdir(fdir)) != NULL)
printf(" %s\n", myentry->d_name);
closedir(fdir);
}
int main (int argc, char *argv[]) {
if (argc == 1)
listDir(".");
else {
int i;
for (i=1; i<argc; i++)
listDir(argv[i]);
}
}
29
Sull'accesso alle direct ory
Le direct ory possono essere let t e da chiunque abbia
accesso in let t ura
Il form at o del file speciale direct ory dipende dalla
im plem ent azione di Unix
Per quest o m ot ivo, esist ono delle funzioni ad hoc per
leggere il cont enut o di una direct ory
Solo il kernel può scrivere in una direct ory
Per evit are problem i di consist enza
I dirit t i di scrit t ura specificano la possibilit à di ut ilizzare
uno dei seguent i com andi
creat, unlink, remove, symlink, mkdir, rmdir
30
Cam biare il propriet ario di un file
int chown(const char *name, uid_t ownerId,
gid_t groupId)
int lchown(const char *name, uid_t ownerId,
gid_t groupId)
int fchown(int fd, uid_t ownerId, gid_t groupId)
chown() m odifica gli ID del possessore e del gruppo del
file name in ownerId e groupId, rispet t ivam ent e.
Un valore -1 in un argom ent o, significa che il valore
associat o deve rest are inalt erat o.
lchown() m odifica possessore e gruppo del link sim bolico
nam e, piut t ost o che quelli relat ivi al file a cui il link fa
riferim ent o.
fchown() opera com e chown() m a prende com e
argom ent o un descrit t ore di file apert o.
31
Cam biare il propriet ario di un file
Solo un superut ent e può m odificare il possessore di un
file; un ut ent e può m odificare il gruppo in un alt ro a cui
l'ut ent e appart iene.
32
Cam biare i perm essi di un file
int chmod(const char *name, int mode)
int fchmod(int fd, int mode)
chmod() m odifica i perm essi sul file name in mode.
mode di solit o è una st ringa di cifre ot t ali.
Solo il possessore del file o un superut ent e può
m odificare i perm essi sul file.
fchmod() opera com e chmod() m a ha com e
argom ent o un descrit t ore di file apert o anziché il
nom e di un file.
33
Duplicare i descrit t ori di file
Le syst em call dup()
e dup2() perm et t ono
di duplicare un file
descript or
p r oce ss t a b le
op e n f ile t a b le
pt r
1
1
fd
Creano un (nuovo) file
descript or che punt a
alla st essa ent ry della
open file t able
newfd=dup(fd)
dup2(fd,newfd)
p r oce ss t a b le
op e n f ile t a b le
pt r
1
n ew fd
fd
2
34
Duplicare i descrit t ori di file
int dup(int oldFd)
int dup2(int oldFd, int newFd)
dup() t rova il più piccolo descrit t ore non ut ilizzat o e lo fa
riferire alla st essa file descript or ent ry (nella t abella dei
file apert i) a cui fa riferim ent o oldFd.
dup2() il secondo argom ent o newFd è il nuovo
descrit t ore. Se newFd è at t ualm ent e at t ivo, lo chiude e
lo fa poi riferire allo st esso file a cui fa riferim ent o oldFd.
Not a: il descrit t ore di file originale e quello copiat o
condividono lo st esso punt at ore int erno al file e le
st esse m odalit à di accesso.
Rit ornano il nuovo descrit t ore, se hanno successo; e -1
alt rim ent i.
35
Duplicare i descrit t ori di file: Esem pio
/* Il programma mydup.c */
#include <stdio.h>
#include <fcntl.h>
int main (void) {
int fd1, fd2, fd3;
fd1 = open ("test.txt", O_CREAT | O_RDWR, 0600);
printf ("fd1 = %d\n", fd1);
write (fd1, "what's", 6);
fd2 = dup (fd1); /* Make a copy of fd1 */
printf ("fd2 = %d\n", fd2);
write (fd2, " up", 3);
close (0); /* Close standard input */
fd3 = dup (fd1); /* Make another copy of fd1 */
printf ("fd3 = %d\n", fd3);
write (0, " doc", 4);
dup2 (3, 2); /* Duplicate channel 3 to channel 2 */
write (2, "?\n", 2);
return 0;
}
36
Ridirezione: Esem pio
/* programma redirectOut.c */
/* redirectOut.c cmd out: esegue il comando cmd, ridirigendo
l'output sul file out */
#include <stdio.h>
#include <fcntl.h>
int main (void) {
int fd;
fd = open (argv[2], O_CREAT | O_RDWR, 0600);
dup2 (fd,1); /* Stdin becomes a copy of fd */
execlp(argv[1],argv[1],NULL);
return 0;
}
37
Duplicare i descrit t ori di file: Esem pio
produ ce il segu en te ou tpu t
$ mydup
fd1 = 3
fd2 = 4
fd3 = 0
$ cat test.txt
what's up doc?
$
38
Operare sui descrit t ori di file
int fcntl(int fd, int cmd [, int arg])
Esegue l'operazione cmd sul file associat o al descrit t ore
fd. Il param . opzionale arg è un argom ent o per cmd.
I valori più com uni per cmd sono
F_SETFD: assegna il bit m eno significat ivo di arg al flag
close-on-exec.
F_GETFD: rest it uisce un num ero il cui bit m eno signific. è
1 o 0 a seconda che il flag close-on-exec sia at t ivo o no.
F_GETFL: rest it uisce un num ero che corrisponde ai flag
corrent i del file ed ai m odi di accesso.
F_SETFL: pone ad arg i flag dello st at o del file.
39
Operare sui descrit t ori di file
F_GETOWN: rest it uisce l'ident ificat ore del processo o il
gruppo di processo che è al m om ent o dest inat o a
ricevere i segnali SIGIO/SIGURG. Se il valore è posit ivo si
riferisce all'ID di un processo. Se è negat ivo, il suo valore
assolut o si riferisce a un gruppo di processo.
F_SETOWN: pone ad arg l'ident ificat ore del processo o il
gruppo di processo che dovrebbe ricevere i segnali
SIGIO/SIGURG (vale quant o det t o per F_GETOWN).
40
Cont rollare i disposit ivi
int ioctl(int fd, int cmd, int arg)
Esegue l'operazione cmd sul file associat o al descrit t ore
fd. Il param . opzionale arg è un argom ent o per cmd.
I valori validi per cmd dipendono dal disposit ivo a cui fd
fa riferim ent o e sono t ipicam ent e docum ent at i nel
m anuale d'ist ruzioni del disposit ivo.
41