1. Standard input 2. Standard output 3. Standard error

Transcript

1 System Call di I/O 2 Per operare su un file abbiamo bisogno di aprirlo, scriverlo, leggerlo, chiuderlo: open (e creat) write read close lseek I/O (Input/Output) File descriptors 3 Standard file 4 File descriptor (fd) è un intero non negativo: 0 fd OPEN_MAX Un fd non è un file pointer (ANSI C) fopen, fclose usano FILE *file_pointer Ogni file aperto ha un file descriptor assegnato dal kernel Le system call di I/O identificano I file tramite I file descriptor Ogni nuovo processo apre 3 file standard 1. Standard input 2. Standard output 3. Standard error e vi si riferisce con i tre file descriptor STDIN_FILENO = 0 STDOUT_FILENO = 1 STDERR_FILENO = 2 Costanti definite in <unistd.h> SysCall: Open 5 Open - parametri 6 #include <sys/stat.h> int open(const char* nome_file, int flag, ); int open(const char* nome_file, int flag); int open(const char* nome_file, int flag, mode_t permessi); un file descriptor se OK char* nome_file = /a/b/c/pippo int flag = sequenza di bit (13), OR di costanti <sys/stat.h>, esempio: O_WRONLY O_CREAT O_TRUNC Una ed una sola costante tra O_RDONLY (0), O_WRONLY (1), O_RDWR (2) Mentre le seguenti sono opzionali O_APPEND (1024), O_CREAT (64), O_EXCL (128), O_TRUNC (512), O_NOCTTY (256), O_NONBLOCK (2048), O_SYNC (4096) (SVR4) 1

2 Open parametri (2) 7 Open - esempio 8 int permessi = 9 bit, , usati per O_CREAT -rwxr-xr-- users robdep Mar 2 16:14 pippo user group other S_IRUSR bit Read user 256 S_IWUSR bit Write user 128 S_IXUSR bit execute user 64 S_IRGRP bit Read group 32 S_IWGRP bit Write group 16 S_IXGRP bit execute group 8 S_IROTH bit Read others 4 S_IWOTH bit Write others 2 S_IXOTH bit execute others 1 const char* nome_file = /a/b/c/pippo ; int flag = O_WRONLY O_CREAT O_TRUNC int permessi = S_IWUSR S_IRUSR S_IRGRP S_IROTH open(nome_file, flag, permessi); bash> cd /a/b/c bash> ls l pippo -rw-r--r-- users robdep 0 Mar 2 17:22 pippo SysCall: Creat 9 SysCall: Write 10 #include <sys/stat.h> int creat(const char* nome_file, int permessi); restituisce un fd se OK, altrimenti -1 Equivalente a: open(nome_file, O_WRONLY O_CREAT O_TRUNC, permessi); ssize_t write(int fd, const void* buffer, size_t nbyte); Restituisce numero di byte scritti se OK, altrimenti -1 Scrive i primi nbyte byte di buffer Scrive a partire dall offset corrente Offset incrementato del numero di byte scritti Normalmente il valore di ritorno è nbyte (in alcune circostanze potrebbe essere minore) In vecchie versioni di unix open poteva solo aprire un file, ma non crearlo SysCall: Read 11 Syscall: Close 12 ssize_t read(int fd, void* buffer, size_t nbyte); Restituisce:numero di byte letti se OK, 0 se file è finito -1 errore Legge nbyte byte, li scrive in buffer Se sono disponibili meno di nbyte nel file, legge solo i byte rimasti int close(int fd); 0 se OK Il kernel chiude I file quando il processo termina, quindi si potrebbe lasciar chiudere il file al kernel. E buona abitudine chiudere I file che si aprono. 2

3 File offset 13 Syscall: lseek 14 file: sequenza di byte offset File offset Ogni file aperto ha un offset (intero 0) che fornisce la posizione nel file, cioe il numero di byte dall inizio del file Operazioni di lettura e scrittura partono dall offset corrente e causano un incremento pari al numero di byte letti o scritti off_t lseek(int fd, off_t n, int da_dove); il nuovo offset se OK Il parametro da_dove può essere: SEEK_SET nuovo offset = n SEEK_CUR nuovo offset = vecchio offset + n SEEK_END nuovo offset = fine file + n Lseek: note 15 lseek - esempio 16 Quando il file viene aperto l offset è inizializzato a 0, a meno che non venga usata O_APPEND Il parametro n può essere anche negativo, a patto che il nuovo offset non sia negativo off_t offset; int fd = open( pippo, O_WRONLY O_CREAT, permessi); offset = lseek(fd, 10, SEEK_SET); offset = lseek(fd, 10, SEEK_CUR); offset = lseek(fd, 10, SEEK_END); write(fd, Ciao,4); offset = lseek(fd, 10, SEEK_END); Se l offset è > fine file, il file non viene allungato fino a quando non si scrive File pippo: offset finale = 24 C i a o Efficienza di I/O 17 Note 18 #include <stdio.h> #include <errno.h> #define BUFFSIZE 8192 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); Il programma assume che STDIN_FILENO e STDOUT_FILENO siano aperti: il kernel apre per ogni processo stdin, stdout e stderr Il programma non chiude i file: il kernel li chiude quando il programma termina Efficienza: più grande è il buffer meno iterazioni servono. Tuttavia una volta raggiunto la grandezza dei blocchi di dati del filesystem non c è miglioramento dell efficienza di I/O (vedi Figura 3.1, Stevens). 3

4 Esercizi 19 Rappresentazione file nel kernel Osservare la ridirezione dell input nel programma 3.1. (pag. 52, Stevens) 2. Stampare il contenuto del file col buco creato dal programma 3.2 (pag 53, Stevens) usando il programma od. 3. Scrivere in un file la stringa , lasciare un buco di 10 byte e poi scrivere la stringa abcde. Il kernel mantiene: Tavola dei processi, tavola dei file e tavola dei v-nodi 4. Scrivere un programma che legga un file stampando in linee separate: numero byte: contenuto byte 5. Analizzare l efficienza di I/O (misurare quanto tempo si impiega a leggere un file grande al variare della grandezza del buffer) FD_CLOEXEC O_RDONLY O_WRONLY O_APPEND etc Condivisione dei file Due o più processi possono condividere file 21 Note Dopo ogni write, il file offset corrente nella file table viene aumentato del numero di byte scritti. Se diventa maggiore della grandezza (size), il file viene esteso (file size = offset) 22 Se il file è aperto con O_APPEND, ogni volta che si usa write il file offset viene cambiato: diventa uguale alla grandezza del file (in pratica si scrive sempre alla fine del file) Lseek modifica solo il file offset nella file table Dup e dup2 23 Operazioni atomiche 24 int dup(int filedes); int dup2(int filedes, int filedes2); il nuovo fd se OK Cosa succede se due processi scrivono lo stesso file? Meglio evitare. E se i due processi vogliono solo appendere dati alla fine del file? Un pò meglio ma Per scrivere alla fine del file normalmente: 1. Posizionare l offset all fine del file 2. Scrivere I dati Questo può creare problemi 4

5 Operazioni atomiche 25 Syscall: fcntl 26 Operazioni atomiche Sequenza di istruzioni tale che o tutte le istruzioni sono eseguite oppure nessuna istruzione è eseguita Quando si apre un file con il flag O_APPEND le operazioni di write diventano atomiche dup2 prima chiude filedes2 (se era aperto) e poi esegue filedes2 = filedes1. int fcntl(int filedes, int cmd,...); int fcntl(int fd, int cmd); int fcntl(int fd, int cmd, long arg); int fcntl(int fd, int cmd, struct flock * lock); Valore di ritorno: -1 errore dipende da cmd se OK dup2 è atomica. fcntl 27 fctnl 28 cmd = F_DUPFD: duplica un descrittore esistente 2. F_GETFD / F_SETFD: prende/assegna i flag dei fd 3. F_GETFL / SETFL: prende/assegna i flag di stato dei file 4. F_GETOWN / F_SETOWN: prende/assegna il processo al quale vengono inviati i segnali SIGIO e SIGURG per I/O asincrono (usato per file speciali) F_GETLK, F_SETLK o F_SETLKW: non li studiamo newfd = fcntl(fd, F_DUPFD); fdflag = fcntl(fd, F_GETFD); Un solo flag: FD_CLOEXEC, se 1 il fd viene chiuso dopo una exec vecchio_fdflag = fcntl(fd, F_SETFD, nuovo_flag); fcntl(fd, F_SETFL, arg); solo O_APPEND, O_NONBLOCK, O_SYNC possono essere modificati statusflags = fcntl(fd, F_GETFL, 0); fcntl(fd, F_SETOWN, pid); fcntl - esempio 29 Esercizi 30 #include <stdio.h> #include <stdarg.h> int main(int argc, char *argv[]) { int accmode, val; if (argc!= 2) { printf("usage: %s <descriptor#>\n",argv[0]); exit(1); if ( (val = fcntl(atoi(argv[1]), F_GETFL, 0)) < 0) { perror("errore in fcntl"); exit(1); accmode = val & O_ACCMODE; if (accmode == O_RDONLY) printf("read only"); else if (accmode == O_WRONLY) printf("write only"); else if (accmode == O_RDWR) printf("read write"); else { printf("access mode sconosciuto"); exit(1); if (val & O_APPEND) printf(", append"); if (val & O_NONBLOCK) printf(", nonblocking"); #if!defined(_posix_source) && defined(o_sync) if (val & O_SYNC) printf(", synchronous writes"); #endif putchar('\n');exit(0); 1. Scrivere un programma che copia un file in un altrousandosolo getchar e putchar, senza sfruttare la ridirezione offerta dalla shell (cioè non usare copia < file1 > file2 ) Suggerimento: duplicare gli standard file descriptor con dup e dup2 2. Ripetere l esercizio precedente facendo in modo che dopo la copia la funzione printf stampi normalmente su stdout. 5

6 Esercizi Scrivere un programma che prende input dalla tastiera e lo scrive in un file il cui nome è fornito sulla linea di comandi (command line). 4. Scrivere un programma che copia in ordine inverso il contenuto di un file in un altro file e sul terminale (i nomi dei file vengono forniti sulla linea di comandi). 6