1. File normale: contiene dati 2. Directory: contiene nomi di altri file ed informazioni sugli stessi

Transcript

1 File Tipi di file 2 1. File normale: contiene dati 2. Directory: contiene nomi di altri file ed informazioni sugli stessi 3. File speciali di caratteri: es. un terminale, /dev/tty 4. File speciali a blocchi: usati per dischi, /dev/sd0 5. FIFO file: usati per la comunicazione tra processi (detti anche pipe) 6. Socket file: usati per comunicazione in rete 7. Link simbolici 1

2 Proprietà dei file 3 Per ogni file il filesystem mantiene delle informazioni: Tipo di file (normale, directory, link, speciale, ) Permessi (lettura, scrittura, esecuzione) Tempo ultimo accesso Tempo ultima modifica Tempo ultimo cambiamento dell stato (permessi) User ID del proprietario del file Group ID del proprietario del file Numero di link che puntano al file Altre informazioni Link simbolici 4 Un link simbolico è un file il cui contenuto è il nome di un altro file. Seguire un link significa operare sul file il cui nome è contenuto nel link e non sul link stesso, che è comunque un file. bash> ls l pippo -rw-r--r-- 1 users robdep 345 Mar 4 19:21 pippo bash> ln s pippo pippo2 bash> ls l pippo* -rw-r--r-- 1 users robdep 345 Mar 4 19:21 pippo lrw-r--r-- 1 users robdep 12 Mar 4 19:21 pippo2 -> /usr/pippo... 2

3 Identificatori e processi 5 Ogni processo ha I seguenti ID associati Real user ID Real group ID Effective user ID Effective group ID Saved set-user-id Saved set-group-id A che servono? Per controllare l accesso ai file. Ogni file ha permessi di lettura, scrittura ed esecuzioni per user, group e other; inoltre ha un user e un group (proprietario del file) Effective user ID deve soddisfare i permessi Set-user-ID e set-group-id 6 robdep> ls /usr/giuper zoff gentile cabrini... tetris.c... robdep> cat /usr/giuper/tetris.c cat: cannot open /usr/giuper/tetris.c robdep> ls -l /usr/giuper/tetris.c -rw giuper prof 2955 Oct /usr/giuper/tetris.c superuser può cambiarlo Il real user ID è (quasi) sempre chi esegue il processo. Normalmente l effective user ID del processo (ls nell esempio) è uguale al real user ID... ma si può settare un bit (set-user-id) nel campo st_mode che fa si che il processo sia eseguito con effective user ID = proprietario del file Analogamente per il group id c è un altro bit (set-group-id) 3

4 esempi 7 robdep> ls -l /etc/passwd -rw-r--r-- 1 root system 1004 Sep 17 14:12 /etc/passwd Se eseguo passwd come fa il processo a cambiare la mia passwd nel file /etc/passwd? Non può. robdep> which passwd /bin/passwd robdep> ls -l /bin/passwd -rws--x--x 1 root bin Apr /bin/passwd user group group owner user owner Quando eseguo passwd l effective user id è root. Quindi posso scrivere nel file /etc/passwd (ma solo usando passwd) Regole di accesso ai file 8 Occorre avere x in tutte le directory nel filename, e, se il path è relativo, anche nella cwd: /dir1/dir2/dir3/pippo a/b/pippo Permesso di lettura directory: permette di leggere la directory. Permesso di esecuzione: permette di passare attraverso la directory L accesso al file è regolato dai permessi del file e dall effective user e group ID del processo: User ID processo = owner ID file -rwx--x--x Group ID processo = group ID file -rwx--x--x Altrimenti -rws--x--x 4

5 Regole di accesso ai file 9 Non possiamo creare un file in una directory se non abbiamo permessi di scrittura nella directory Per cancellare un file in una directory serve il permesso di scrittura e quello di esecuzione nella directory. non serve nessun permesso sul file Per eseguire un file (programma) occorre avere il permesso di esecuzione Permessi di file nuovi 10 Quando si crea un file (o directory): proprietario del file = effective user ID del processo che lo crea Gruppo proprietario del file può essere: 1. Group ID della directory dove il file è creato 2. Group ID del processo che crea il file dipende dal sistema operativo. 5

6 Struttura stat 11 Macro per tipi di file 12 #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) 6

7 SysCall: stat, fstat, lstat 13 #include <sys/types.h> #include <sys/stat.h> int stat (const char *pathname, struct stat *buf ); int fstat (int fd, struct stat *buf ); int lstat (const char *pathname, struct stat *buf ); Valore di ritorno: -1 se errore 0 se OK La struttura buf contiene le info se OK SysCall: stat, fstat, lstat 14 Differenze: Stat: filename e segue i link simbolici Fstat: file aperto (fd) e segue i link simbolici Lstat: filename e NON segue i link simbolici Ma sostanzialmente sono uguali: Tutte e tre forniscono le informazione sul file nella struttura buf. 7

8 SysCall: access 15 Permette di controllare i permessi basandosi sul real user e group ID Utile per processi che hanno il set-user-id o il setgroup-id # include <unistd.h> int access(const char *pathname, int mode); Valore di ritorno: -1 se errore 0 se OK umask 16 Cosa è la umask: Alla creazione di un file vengono specificati dei permessi. la umask ha un bit per ognuno dei 9 permessi Se il bit nella umask è 1, allora il permesso è 0 Open file umask grou user p other -rwx rw- r rw- r Permessi finali 8

9 SysCall: umask 17 #include <sys/types.h> #include <sys/stat.h> Mode_t umask (mode_t cmask); cmask è la nuova umask; Il valore di ritorno è la vecchia umask Questa è una delle pochi funzioni che non ritornano mai un errore SysCall: chmod e fchmod 18 #include <sys/types.h> #include <sys/stat.h> int chmod(const char *pathname, mode_t mode); int fchmod(int fd, mode_t mode); Valore di ritorno: -1 se errore, 0 se OK Per poter cambiare I permessi di un file bisogna o essere il proprietario oppure il superuser. 9

10 Costanti per chmod = st_mode Bit# Sticky bit In vecchie versioni di Unix lo sticky bit serviva per programmi che venivano eseguiti spesso: Se lo sticky bit era on, il codice del programma veniva salvato nell area di swap del disco Quando il programma veniva eseguito di nuovo, il codice veniva letto dall area di swap e non dal file originale La lettura è più veloce perchè normalmente nell area di swap I dati sono contigui mentre per un file regolare possono essere in posizioni casuali nel disco Con la memoria virtuale e con file system più veloci, lo sticky bit non serve più 20 Solo il superutente può modificare lo sticky bit 10

11 chmod - esempio 21 #include <sys/types.h> #include <sys/stat.h> #include <errno.h> int main(void) { struct stat statbuf; if (stat("pippo", &statbuf) < 0 ) { perror("errore in stat per pippo"); exit(1); } if (chmod("pippo",(statbuf.st_mode&~s_ixgrp) S_ISGID)< 0){ perror("errore in chmod per pippo"); exit(1); } if (chmod("pluto",s_irusr S_IWUSR S_IRGRP S_IROTH) < 0 ) { perror("errore in chmod per pluto"); exit(1); } exit(0); } SysCall: chown, fchow, lchown 22 #include <sys/types.h> #include <unistd.h> int chown(const char* file, uid_t owner, gid_t group); int fchown(int fd, uid_t owner, gid_t group); int lchown(const char* file, uid_t owner, gid_t group); (Simili a stat, fstat e lstat) 11

12 Chown 23 Chi può cambiare il proprietario di un file? System V: il proprietario del file Berkeley: solo il superuser POSIX entrambe: Variabile _POSIX_CHOWN_RESTRICTED, se vera allora solo il superuser può cambaire il propriotario di un file Attenzione: Se cambi il proprietario di un file tuo il file non è più tuo! Filesystem 24 Organizzazione di un disco e dei file system 12

13 I-node e blocchi di dati 25 I-node contiene informazioni sui file tipo del file bit di permesso puntatori ai blocchi di dati del file... altre informazioni I blocchi di dati sono 1. Directory block (dati della directory, lista file) Nome del file, puntatore all i-node del file 2. Data block (dati nei file) Contengono i dati del file Filesystem 26 13

14 Filesystem: esempio 27 testdir Hard links CWD prompt> mkdir testdir Filesystem: esempio 28 FILESYSTEM: / directory /home directory /home/robdep directory /home/giuper /home/robdep/pippo /home/robdep/pippo2 directory file: abcde file: AAAAA AAAAA lista di i-node blocchi dati block 823: Inode 0: 0 Inode 213: 734 Inode 344: 823 Inode 512: 111 Inode 516: 1435, 1436 block 0: home Mancano I blocchi per la directory giuper block 111: abcde block 734: robdep 348 giuper pippo 516 pippo2 block 1435: AAAAA block 1436: AAAAA 14

15 Hard link 29 Concetto di ( hard ) link Numero di directory entry che puntano all i-node I file corrispondenti agli i-node 512 e 516 hanno 2 link lista di i-node blocchi dati Inode 0: 0 Inode 213: 734 Inode 344: 823 Inode 512: 111 Inode 516: 1435, 1436 block 111: abcde block 734: robdep 348 giuper 512 filex block 823: pippo 516 pippo2 516 pippo3 block 1435: AAAAA block 1436: AAAAA Filesystem: osservazioni 30 ogni i-node ha un contatore di link che contiene il numero di directory entry che lo puntano solo quando scende a zero, allora il file può essere cancellato (i blocchi di dati sono rilasciati) il contatore è nella struct stat nel campo st_nlink questi tipi di link sono detti hard link gli altri sono soft link (link simbolici) lib /usr/lib (7 caratteri di dati nel data block) non si possono fare hard link tra filesystem differenti Per cambiare il nome di un file non serve spostare il contenuto del file 15

16 Syscall: link 31 #include <unistd.h> int link(const char* existing, const char* new); bash> ln /bin/pippo pippo bash> ls l pippo -rw-r--r-- 1 users robdep Mar 4 19:21 pippo Solo root può creare link a directory per evitare loop Comunque si può farlo con i link simbolici (errore ELOOP quando c è un loop) Syscall: unlink 32 #include <unistd.h> int unlink(const char* pathname); Decrementa il contatore di (hard) link del file pathname Non segue i link simbolici: Se path name è un link simbolico viene decrementato il contatore del link simbolico non il contatore del file specificato nel link simbolico Unlink su un file è come remove (vedremo dopo), mentre unlink su una directory è come rmdir (vedremo dopo) I dati sono cancellati solo quando il file è chiuso proprietà spesso usata per essere sicuri di non lasciare file temporanei su disco 16

17 unlink - esempio 33 #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <errno.h> int main (int argc, char *argv[]) { } if (open(argv[1], O_RDWR) < 0 ) { perror("errore in open"); exit(1); } if (unlink(argv[1]) < 0 ) { perror("errore in unlink"); exit(1); } printf("file unlinked\n"); sleep(20); printf("done.\n"); exit(0); Unlink e cancellazione dei dati 34 bash> ls l tempfile -rw-r--r-- robdep prof Jul 31 13:42 tempfile bash> df /home Filesystem kbytes used avail capacity mounted on /dev/sdoh % /home bash> unlink tempfile & 1354 bash> File unlinked ls l tempfile tempfile not found bash> df /home Filesystem kbytes used avail capacity mounted on /dev/sdoh % /home bash> Done df /home Filesystem kbytes used avail capacity mounted on /dev/sdoh % /home 17

18 Symlink e readlink 35 #include <unistd.h> int symlink(const char* existing, const char* new); bash> ln s /bin/pippo pippo bash> ls l pippo lrw-r--r-- 1 users robdep 10 Mar 4 19:21 pippo -> /bin/pippo #include <unistd.h> int readlink(const char* existing, char* buf, int bufsize); Per aprire link simbolici (visto che open segue il link simbolico) Date di accesso e modifica 36 Per ogni file/directory 1. Data ultimo accesso (access time) Cambiato per esempio da read 2. Data ultima modifica del contenuto (modification time) Cambiato per esempio da write 3. Data ultima modifica dell i-node (changed-status time) Cambiato per esempio da chmod, chown Struttura stat contiene st_atime, st_mtime e st_ctime Quando si crea o si cancella un file/dir vengono modificati anche i tempi di modifica del contenuto e dell i-node della directory che contiene il file 18

19 SysCall: utime 37 int utime(const char *pathname, const struct utimbuf *times); struct utimbuf { time_t actime; /*access time*/ time_t modtime; /*modification time*/ } Per cambiare i tempi occorre essere il proprietario del file (a meno che times = NULL, allora basta il permesso in scrittura, e viene assegnato il tempo corrente) Non possiamo cambiare il changed-status time poichè esso è cambiato automaticamente quando si usa utime, visto che modifica l i-node. SysCall: mkdir e rmdir 38 #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> int mkdir (const char *pathname, mode_t mode); int rmdir (const char *pathname); mode = permessi (ricordarsi la x ) rmdir: Se il link count va a 0, ma ci sono dei processi che hanno la directory aperta, i blocchi vengono rilasciati quando I processi chiudono la directory. La directory viene comunque cancellata subito. 19

20 Leggere una directory 39 #include <sys/types.h> #include <dirent.h> DIR* opendir(const char* pathname); struct dirent* readdir(dir* ptr); void rewinddir(dir *ptr); int closedir(dir* ptr); struct dirent { /* in alcune implementazioni è: */ ino_t d_ino; /*numero dell i-node */ char d_name[name_max+1]; /* nome del file */ } Current working directory 40 #include <unistd.h> int chdir(const char* pathname); int fchdir(int fd); Modificano la current working directory, dalla quale inizia la ricerca per un pathname relativo char* getcwd(char* buf, size_t size); Restituisce la cwd 20

21 SysCall: sync, fsync 41 Problema del delayed write: dati sono messi in un buffer. Il kernel li trasferisce successivamente su disco. Per assicurare consistenza fra il disco e il buffer interno si posso usare sync e fsync int sync(void) inizia il processo di scrittura di tutti i blocchi modificati e ancora non scritti sul disco ma ritorna prima che sia finito int fsync(int fd) Scrive i blocchi di un singolo file e aspetta che l operazione di I/O sia finita prima di ritornare. Esercizi Studiare il programma 4.7, pag 109 del libro È difficile, ma è un ottimo esercizio per controllare che avete capito quello che abbiamo studiato finora I programmi del libro usano #include ourhdr ed una libreria di Stevens Sono inclusi nel software allegato al libro 1. Vi scaricate i sorgenti del libro da Internet ftp.uu.net published/books/stevens.advprogr.tar.z 2. Modificate il programma: in generale basta sostituire le chiamate a funzioni particulari (es. err_ret, err_dump) con funzioni standard (es. perror) 21