Guida alla Programmazione in Linux. Simone Piccardi

GaPiL Guida alla Programmazione in Linux Simone Piccardi 8 novembre 2003

ii Copyright c 2000-2003 Simone Piccardi. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being Prefazione, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled GNU Free Documentation License.

Indice Prefazione xiii I Programmazione di sistema 1 1 L architettura del sistema 3 1.1 Una panoramica.................................... 3 1.1.1 Concetti base.................................. 3 1.1.2 User space e kernel space........................... 4 1.1.3 Il kernel e il sistema.............................. 4 1.1.4 Chiamate al sistema e librerie di funzioni.................. 5 1.1.5 Un sistema multiutente............................ 6 1.2 Gli standard....................................... 7 1.2.1 Lo standard ANSI C.............................. 7 1.2.2 I tipi di dati primitivi............................. 8 1.2.3 Lo standard IEEE POSIX.......................... 8 1.2.4 Lo standard X/Open XPG3......................... 9 1.2.5 Gli standard Unix Open Group....................... 10 1.2.6 Lo standard BSD............................... 10 1.2.7 Lo standard System V............................. 10 1.2.8 Il comportamento standard del gcc e delle glibc.............. 11 2 L interfaccia base con i processi 13 2.1 Esecuzione e conclusione di un programma..................... 13 2.1.1 La funzione main................................ 13 2.1.2 Come chiudere un programma........................ 14 2.1.3 Le funzioni exit e _exit........................... 14 2.1.4 Le funzioni atexit e on_exit......................... 15 2.1.5 Conclusioni................................... 16 2.2 I processi e l uso della memoria............................ 16 2.2.1 I concetti generali............................... 16 2.2.2 La struttura della memoria di un processo.................. 17 2.2.3 Allocazione della memoria per i programmi C................ 19 2.2.4 Le funzioni malloc, calloc, realloc e free................ 20 2.2.5 La funzione alloca.............................. 22 2.2.6 Le funzioni brk e sbrk............................. 22 2.2.7 Il controllo della memoria virtuale...................... 23 2.3 Parametri, opzioni ed ambiente di un processo................... 25 2.3.1 Il formato dei parametri............................ 25 2.3.2 La gestione delle opzioni............................ 26 iii

iv INDICE 2.3.3 Opzioni in formato esteso........................... 27 2.3.4 Le variabili di ambiente............................ 27 2.4 Problematiche di programmazione generica..................... 30 2.4.1 Il passaggio delle variabili e dei valori di ritorno............... 30 2.4.2 Il passaggio di un numero variabile di argomenti.............. 31 2.4.3 Potenziali problemi con le variabili automatiche............... 33 2.4.4 Il controllo di flusso non locale........................ 33 3 La gestione dei processi 37 3.1 Introduzione...................................... 37 3.1.1 L architettura della gestione dei processi................... 37 3.1.2 Una panoramica sulle funzioni fondamentali................. 39 3.2 Le funzioni di base................................... 40 3.2.1 Gli identificatori dei processi......................... 40 3.2.2 La funzione fork................................ 41 3.2.3 La funzione vfork............................... 46 3.2.4 La conclusione di un processo......................... 46 3.2.5 Le funzioni wait e waitpid.......................... 48 3.2.6 Le funzioni wait3 e wait4........................... 51 3.2.7 Le funzioni exec................................ 51 3.3 Il controllo di accesso.................................. 54 3.3.1 Gli identificatori del controllo di accesso................... 54 3.3.2 Le funzioni setuid e setgid......................... 56 3.3.3 Le funzioni setreuid e setregid....................... 57 3.3.4 Le funzioni seteuid e setegid........................ 58 3.3.5 Le funzioni setresuid e setresgid..................... 58 3.3.6 Le funzioni setfsuid e setfsgid....................... 59 3.3.7 Le funzioni setgroups e getgroups..................... 59 3.4 La gestione della priorità di esecuzione........................ 61 3.4.1 I meccanismi di scheduling.......................... 61 3.4.2 Il meccanismo di scheduling standard.................... 62 3.4.3 Il meccanismo di scheduling real-time.................... 64 3.5 Problematiche di programmazione multitasking................... 67 3.5.1 Le operazioni atomiche............................ 67 3.5.2 Le race condition e i deadlock......................... 68 3.5.3 Le funzioni rientranti.............................. 69 4 L architettura dei file 71 4.1 L architettura generale................................. 71 4.1.1 L organizzazione di file e directory...................... 71 4.1.2 I tipi di file................................... 72 4.1.3 Le due interfacce ai file............................ 73 4.2 L architettura della gestione dei file.......................... 74 4.2.1 Il Virtual File System di Linux........................ 74 4.2.2 Il funzionamento del VFS........................... 76 4.2.3 Il funzionamento di un filesystem Unix.................... 77 4.2.4 Il filesystem ext2................................ 79

INDICE v 5 File e directory 81 5.1 La gestione di file e directory............................. 81 5.1.1 Le funzioni link e unlink........................... 81 5.1.2 Le funzioni remove e rename......................... 83 5.1.3 I link simbolici................................. 84 5.1.4 La creazione e la cancellazione delle directory................ 87 5.1.5 La creazione di file speciali.......................... 88 5.1.6 Accesso alle directory............................. 89 5.1.7 La directory di lavoro............................. 95 5.1.8 I file temporanei................................ 96 5.2 La manipolazione delle caratteristiche dei files.................... 98 5.2.1 Le funzioni stat, fstat e lstat....................... 99 5.2.2 I tipi di file................................... 99 5.2.3 Le dimensioni dei file.............................. 100 5.2.4 I tempi dei file................................. 101 5.2.5 La funzione utime............................... 103 5.3 Il controllo di accesso ai file.............................. 103 5.3.1 I permessi per l accesso ai file......................... 104 5.3.2 I bit suid e sgid................................. 106 5.3.3 Il bit sticky................................... 107 5.3.4 La titolarità di nuovi file e directory..................... 108 5.3.5 La funzione access.............................. 108 5.3.6 Le funzioni chmod e fchmod.......................... 109 5.3.7 La funzione umask............................... 110 5.3.8 Le funzioni chown, fchown e lchown..................... 111 5.3.9 Un quadro d insieme sui permessi....................... 112 5.3.10 La funzione chroot.............................. 113 6 I file: l interfaccia standard Unix 115 6.1 L architettura di base................................. 115 6.1.1 L architettura dei file descriptor....................... 115 6.1.2 I file standard.................................. 116 6.2 Le funzioni base.................................... 117 6.2.1 La funzione open................................ 117 6.2.2 La funzione close............................... 119 6.2.3 La funzione lseek............................... 120 6.2.4 La funzione read................................ 121 6.2.5 La funzione write............................... 122 6.3 Caratteristiche avanzate................................ 123 6.3.1 La condivisione dei files............................ 123 6.3.2 Operazioni atomiche con i file......................... 124 6.3.3 La funzioni sync e fsync........................... 126 6.3.4 La funzioni dup e dup2............................. 127 6.3.5 La funzione fcntl............................... 128 6.3.6 La funzione ioctl............................... 130 7 I file: l interfaccia standard ANSI C 133 7.1 Introduzione...................................... 133 7.1.1 I file stream................................... 133 7.1.2 Gli oggetti FILE................................ 134 7.1.3 Gli stream standard.............................. 134

vi INDICE 7.1.4 Le modalità di bufferizzazione......................... 134 7.2 Funzioni base...................................... 135 7.2.1 Apertura e chiusura di uno stream...................... 136 7.2.2 Lettura e scrittura su uno stream....................... 138 7.2.3 Input/output binario.............................. 139 7.2.4 Input/output a caratteri............................ 140 7.2.5 Input/output di linea............................. 142 7.2.6 L input/output formattato.......................... 144 7.2.7 Posizionamento su uno stream........................ 148 7.3 Funzioni avanzate.................................... 149 7.3.1 Le funzioni di controllo............................ 149 7.3.2 Il controllo della bufferizzazione........................ 150 7.3.3 Gli stream e i thread.............................. 152 8 La gestione del sistema, del tempo e degli errori 155 8.1 Capacità e caratteristiche del sistema......................... 155 8.1.1 Limiti e parametri di sistema......................... 155 8.1.2 La funzione sysconf.............................. 158 8.1.3 I limiti dei file................................. 159 8.1.4 La funzione pathconf............................. 160 8.1.5 La funzione uname............................... 160 8.2 Opzioni e configurazione del sistema......................... 161 8.2.1 La funzione sysctl ed il filesystem /proc.................. 161 8.2.2 La gestione delle proprietà dei filesystem................... 163 8.2.3 La gestione di utenti e gruppi......................... 166 8.2.4 Il database di accounting........................... 168 8.3 Limitazione ed uso delle risorse............................ 171 8.3.1 L uso delle risorse............................... 171 8.3.2 Limiti sulle risorse............................... 172 8.3.3 Le risorse di memoria e processore...................... 173 8.4 La gestione dei tempi del sistema........................... 174 8.4.1 La misura del tempo in Unix......................... 175 8.4.2 La gestione del process time.......................... 176 8.4.3 Le funzioni per il calendar time........................ 177 8.4.4 La gestione delle date.............................. 180 8.5 La gestione degli errori................................. 182 8.5.1 La variabile errno............................... 183 8.5.2 Le funzioni strerror e perror........................ 183 8.5.3 Alcune estensioni GNU............................ 184 9 I segnali 187 9.1 Introduzione...................................... 187 9.1.1 I concetti base................................. 187 9.1.2 Le semantiche del funzionamento dei segnali................ 188 9.1.3 Tipi di segnali................................. 189 9.1.4 La notifica dei segnali............................. 189 9.2 La classificazione dei segnali.............................. 190 9.2.1 I segnali standard............................... 190 9.2.2 Segnali di errore di programma........................ 191 9.2.3 I segnali di terminazione............................ 193 9.2.4 I segnali di allarme............................... 194

INDICE vii 9.2.5 I segnali di I/O asincrono........................... 194 9.2.6 I segnali per il controllo di sessione...................... 195 9.2.7 I segnali di operazioni errate......................... 195 9.2.8 Ulteriori segnali................................. 196 9.2.9 Le funzioni strsignal e psignal....................... 196 9.3 La gestione dei segnali................................. 197 9.3.1 Il comportamento generale del sistema.................... 197 9.3.2 La funzione signal.............................. 198 9.3.3 Le funzioni kill e raise........................... 199 9.3.4 Le funzioni alarm e abort........................... 201 9.3.5 Le funzioni di pausa e attesa......................... 204 9.3.6 Un esempio elementare............................ 205 9.4 Gestione avanzata................................... 206 9.4.1 Alcune problematiche aperte......................... 207 9.4.2 Gli insiemi di segnali o signal set....................... 209 9.4.3 La funzione sigaction............................ 210 9.4.4 La gestione della maschera dei segnali o signal mask............ 213 9.4.5 Ulteriori funzioni di gestione......................... 215 9.4.6 I segnali real-time............................... 218 10 Terminali e sessioni di lavoro 221 10.1 Il job control...................................... 221 10.1.1 Una panoramica introduttiva......................... 221 10.1.2 I process group e le sessioni.......................... 222 10.1.3 Il terminale di controllo e il controllo di sessione.............. 224 10.1.4 Dal login alla shell............................... 227 10.1.5 Prescrizioni per un programma daemon................... 228 10.2 L I/O su terminale................................... 232 10.2.1 L architettura.................................. 232 10.2.2 La gestione delle caratteristiche di un terminale............... 234 10.2.3 La gestione della disciplina di linea...................... 243 10.2.4 Operare in modo non canonico........................ 245 11 La gestione avanzata dei file 247 11.1 Le funzioni di I/O avanzato.............................. 247 11.1.1 La modalità di I/O non-bloccante...................... 247 11.1.2 L I/O multiplexing............................... 247 11.1.3 L I/O asincrono................................ 251 11.1.4 I/O vettorizzato................................ 256 11.1.5 File mappati in memoria............................ 257 11.2 Il file locking...................................... 262 11.2.1 L advisory locking............................... 263 11.2.2 La funzione flock............................... 264 11.2.3 Il file locking POSIX.............................. 265 11.2.4 La funzione lockf............................... 272 11.2.5 Il mandatory locking.............................. 272

viii INDICE 12 La comunicazione fra processi 275 12.1 La comunicazione fra processi tradizionale...................... 275 12.1.1 Le pipe standard................................ 275 12.1.2 Un esempio dell uso delle pipe........................ 277 12.1.3 Le funzioni popen e pclose.......................... 279 12.1.4 Le pipe con nome, o fifo............................ 282 12.1.5 La funzione socketpair............................ 287 12.2 La comunicazione fra processi di System V..................... 288 12.2.1 Considerazioni generali............................ 288 12.2.2 Il controllo di accesso............................. 290 12.2.3 Gli identificatori ed il loro utilizzo...................... 291 12.2.4 Code di messaggi................................ 293 12.2.5 Semafori..................................... 302 12.2.6 Memoria condivisa............................... 312 12.3 Tecniche alternative.................................. 323 12.3.1 Alternative alle code di messaggi....................... 323 12.3.2 I file di lock................................... 323 12.3.3 La sincronizzazione con il file locking..................... 325 12.3.4 Il memory mapping anonimo......................... 327 12.4 La comunicazione fra processi di POSIX....................... 327 12.4.1 Considerazioni generali............................ 327 12.4.2 Code di messaggi................................ 328 12.4.3 Semafori..................................... 334 12.4.4 Memoria condivisa............................... 334 II Programmazione di rete 339 13 Introduzione alla programmazione di rete 341 13.1 Modelli di programmazione.............................. 341 13.1.1 Il modello client-server............................ 341 13.1.2 Il modello peer-to-peer............................. 342 13.1.3 Il modello three-tier.............................. 342 13.2 I protocolli di rete................................... 343 13.2.1 Il modello ISO/OSI.............................. 343 13.2.2 Il modello TCP/IP (o DoD).......................... 344 13.2.3 Criteri generali dell architettura del TCP/IP................ 346 13.3 Il protocollo TCP/IP.................................. 346 13.3.1 Il quadro generale............................... 347 13.3.2 Internet Protocol (IP)............................. 349 13.3.3 User Datagram Protocol (UDP)....................... 350 13.3.4 Transport Control Protocol (TCP)...................... 350 13.3.5 Limiti e dimensioni riguardanti la trasmissione dei dati.......... 351 14 Introduzione ai socket 353 14.1 Una panoramica.................................... 353 14.1.1 I socket..................................... 353 14.1.2 Concetti base.................................. 353 14.2 La creazione di un socket............................... 354 14.2.1 La funzione socket.............................. 354 14.2.2 Il dominio, o protocol family.......................... 355

INDICE ix 14.2.3 Il tipo, o stile.................................. 356 14.3 Le strutture degli indirizzi dei socket......................... 357 14.3.1 La struttura generica.............................. 357 14.3.2 La struttura degli indirizzi IPv4....................... 358 14.3.3 La struttura degli indirizzi IPv6....................... 359 14.3.4 La struttura degli indirizzi locali....................... 359 14.3.5 La struttura degli indirizzi AppleTalk.................... 360 14.3.6 La struttura degli indirizzi dei packet socket................. 360 14.4 Le funzioni di conversione degli indirizzi....................... 362 14.4.1 La endianess.................................. 362 14.4.2 Le funzioni per il riordinamento....................... 364 14.4.3 Le funzioni inet_aton, inet_addr e inet_ntoa.............. 364 14.4.4 Le funzioni inet_pton e inet_ntop..................... 365 15 Socket TCP elementari 367 15.1 Il funzionamento di una connessione TCP...................... 367 15.1.1 La creazione della connessione: il three way handshake........... 367 15.1.2 Le opzioni TCP................................. 368 15.1.3 La terminazione della connessione...................... 369 15.1.4 Un esempio di connessione........................... 370 15.1.5 Lo stato TIME_WAIT.............................. 372 15.1.6 I numeri di porta................................ 373 15.1.7 Le porte ed il modello client/server...................... 375 15.2 Le funzioni di base per la gestione dei socket.................... 376 15.2.1 La funzione bind................................ 376 15.2.2 La funzione connect.............................. 378 15.2.3 La funzione listen.............................. 379 15.2.4 La funzione accept.............................. 381 15.2.5 Le funzioni getsockname e getpeername................... 382 15.2.6 La funzione close............................... 383 15.3 Un esempio elementare: il servizio daytime..................... 384 15.3.1 Il comportamento delle funzioni di I/O.................... 384 15.3.2 Il client daytime................................ 385 15.3.3 Un server daytime iterativo.......................... 387 15.3.4 Un server daytime concorrente........................ 389 15.4 Un esempio più completo: il servizio echo...................... 391 15.4.1 Il servizio echo................................. 392 15.4.2 Il client: prima versione............................ 392 15.4.3 Il server: prima versione............................ 393 15.4.4 L avvio e il funzionamento normale...................... 396 15.4.5 La conclusione normale............................ 398 15.4.6 La gestione dei processi figli.......................... 398 15.5 I vari scenari critici................................... 402 15.5.1 La terminazione precoce della connessione.................. 402 15.5.2 La terminazione precoce del server...................... 403 15.5.3 Altri scenari di terminazione della connessione............... 406

x INDICE 16 Socket TCP avanzati 411 16.1 Socket I/O multiplexing................................ 411 16.1.1 Il comportamento della funzione select con i socket............ 411 16.1.2 Un esempio di I/O multiplexing....................... 413 16.1.3 La funzione shutdown............................. 415 16.1.4 Un server basato sull I/O multiplexing.................... 419 16.1.5 Un esempio di I/O multiplexing con poll.................. 419 16.2 Le opzioni dei socket.................................. 420 16.3 I dati out-of-band.................................... 420 A Il livello di rete 421 A.1 Il protocollo IP..................................... 421 A.1.1 Introduzione.................................. 421 A.2 Il protocollo IPv6.................................... 422 A.2.1 I motivi della transizione........................... 423 A.2.2 Principali caratteristiche di IPv6....................... 423 A.2.3 L intestazione di IPv6............................. 424 A.2.4 Gli indirizzi di IPv6.............................. 426 A.2.5 La notazione.................................. 426 A.2.6 La architettura degli indirizzi di IPv6.................... 427 A.2.7 Indirizzi unicast provider-based........................ 428 A.2.8 Indirizzi ad uso locale............................. 429 A.2.9 Indirizzi riservati................................ 429 A.2.10 Multicasting.................................. 430 A.2.11 Indirizzi anycast................................ 431 A.2.12 Le estensioni.................................. 431 A.2.13 Qualità di servizio............................... 432 A.2.14 Etichette di flusso............................... 433 A.2.15 Priorità..................................... 433 A.2.16 Sicurezza a livello IP.............................. 434 A.2.17 Autenticazione................................. 434 A.2.18 Riservatezza.................................. 435 A.2.19 Autoconfigurazione............................... 436 A.2.20 Autoconfigurazione stateless.......................... 436 A.2.21 Autoconfigurazione stateful.......................... 437 B Il livello di trasporto 439 B.1 Il protocollo TCP.................................... 439 B.1.1 Gli stati del TCP................................ 439 C I codici di errore 441 C.1 Gli errori dei file.................................... 441 C.2 Gli errori dei processi................................. 443 C.3 Gli errori di rete.................................... 443 C.4 Errori generici...................................... 445 C.5 Errori del kernel.................................... 447 D Ringraziamenti 449

INDICE xi E GNU Free Documentation License 451 E.1 Applicability and Definitions............................. 451 E.2 Verbatim Copying................................... 452 E.3 Copying in Quantity.................................. 452 E.4 Modifications...................................... 453 E.5 Combining Documents................................. 454 E.6 Collections of Documents............................... 455 E.7 Aggregation With Independent Works........................ 455 E.8 Translation....................................... 455 E.9 Termination....................................... 455 E.10 Future Revisions of This License........................... 455

Prefazione Nelle motivazioni in cui si introduce la GNU Free Documentation License (FDL) (reperibili su http://www.gnu.org/philosophy/free-doc.html) si dà una grande rilevanza all importanza di disporre di buoni manuali, in quanto la fruibilità e la possibilità di usare appieno il software libero vengono notevolmente ridotte senza la presenza di un valido manuale che sia altrettanto liberamente disponibile. E, come per il software libero, anche in questo caso è di fondamentale importanza la libertà di accedere ai sorgenti (e non solo al risultato finale, sia questo una stampa o un file formattato) e la libertà di modificarli per apportarvi migliorie, aggiornamenti, etc. Per questo la Free Software Foundation ha approntato una licenza apposita per la documentazione, che tiene conto delle differenze che restano fra un testo e un programma. Esiste però un altro campo, diverso dalla documentazione e dai manuali, in cui avere a disposizione testi liberi, aperti e modificabili è essenziale ed estremamente utile: quello della didattica e dell educazione. E benché anche questo campo sia citato dalla FDL non è altrettanto comune trovarlo messo in pratica. In particolare sarebbe di grande interesse poter disporre di testi didattici in grado di crescere, essere adattati alle diverse esigenze, modificati e ampliati, o anche ridotti per usi specifici, nello stesso modo in cui si fa per il software libero. Questo progetto mira alla stesura di un libro il più completo e chiaro possibile sulla programmazione in un sistema basato su un kernel Linux. Essendo i concetti in gran parte gli stessi, il testo dovrebbe restare valido anche per la programmazione in ambito Unix generico, ma resta una attenzione specifica alle caratteristiche peculiari del kernel Linux e delle versioni delle librerie del C in uso con esso, ed in particolare per le glibc del progetto GNU (che ormai sono usate nella stragrande maggioranza dei casi). Nonostante l uso nel titolo del solo Linux, (che si è fatto sia per brevità sia perché il libro ha a che fare principalmente con le interfacce del kernel e dei principali standard supportati delle librerie del C), voglio sottolineare che trovo assolutamente scorretto chiamare in questo modo un sistema completo. Il kernel infatti, senza tutte le librerie e le applicazioni di base fornite dal progretto GNU, sarebbe sostanzialmente inutile: per questo il nome del sistema nella sua interezza non può che essere GNU/Linux. L obiettivo finale di questo progetto è quello di riuscire a ottenere un testo utilizzabile per apprendere i concetti fondamentali della programmazione di sistema della stessa qualità dei libri del compianto R. W. Stevens (è un progetto molto ambizioso...). Infatti benché le pagine di manuale del sistema (quelle che si accedono con il comando man) e il manuale delle librerie del C GNU siano una fonte inesauribile di informazioni (da cui si è costantemente attinto nella stesura di tutto il testo) la loro struttura li rende totalmente inadatti ad una trattazione che vada oltre la descrizione delle caratteristiche particolari dello specifico argomento in esame (ed in particolare lo GNU C Library Reference Manual non brilla per chiarezza espositiva). Per questo motivo si è cercato di fare tesoro di quanto appreso dai testi di R. Stevens (in xiii

xiv PREFAZIONE particolare [1] e [2]) per rendere la trattazione dei vari argomenti in una sequenza logica il più esplicativa possibile, corredata, quando possibile, da programmi di esempio. Il progetto prevede il rilascio del testo sotto licenza FDL, ed una modalità di realizzazione aperta che permetta di accogliere i contributi di chiunque sia interessato. Tutti i programmi di esempio sono invece rilasciati sotto GNU GPL. Dato che sia il kernel che tutte le librerie fondamentali di GNU/Linux sono scritte in C, questo sarà il linguaggio di riferimento del testo. In particolare il compilatore usato per provare tutti i programmi e gli esempi descritti nel testo è lo GNU GCC. Il testo presuppone una conoscenza media del linguaggio, e di quanto necessario per scrivere, compilare ed eseguire un programma. Infine, dato che lo scopo del progetto è la produzione di un libro, si è scelto di usare LATEX come ambiente di sviluppo del medesimo, sia per l impareggiabile qualità tipografica ottenibile, che per la congruenza dello strumento, tanto sul piano pratico, quanto su quello filosofico. Il testo sarà, almeno inizialmente, in italiano.

Parte I Programmazione di sistema 1

Capitolo 1 L architettura del sistema In questo primo capitolo sarà fatta un introduzione ai concetti generali su cui è basato un sistema operativo di tipo Unix come GNU/Linux, in questo modo potremo fornire una base di comprensione mirata a sottolineare le peculiarità del sistema che sono più rilevanti per quello che riguarda la programmazione. Dopo un introduzione sulle caratteristiche principali di un sistema di tipo Unix passeremo ad illustrare alcuni dei concetti base dell architettura di GNU/Linux (che sono comunque comuni a tutti i sistemi unix-like) ed introdurremo alcuni degli standard principali a cui viene fatto riferimento. 1.1 Una panoramica In questa prima sezione faremo una breve panoramica sull architettura del sistema. Chi avesse già una conoscenza di questa materia può tranquillamente saltare questa sezione. 1.1.1 Concetti base Il concetto base di un sistema unix-like è quello di un nucleo del sistema (il cosiddetto kernel, nel nostro caso Linux) a cui si demanda la gestione delle risorse essenziali (la CPU, la memoria, le periferiche) mentre tutto il resto, quindi anche la parte che prevede l interazione con l utente, deve venire realizzato tramite programmi eseguiti dal kernel e che accedano alle risorse hardware tramite delle richieste a quest ultimo. Fin dall inizio uno Unix si presenta come un sistema operativo multitasking, cioè in grado di eseguire contemporaneamente più programmi, e multiutente, in cui è possibile che più utenti siano connessi ad una macchina eseguendo più programmi in contemporanea (in realtà, almeno per macchine a processore singolo, i programmi vengono eseguiti singolarmente a rotazione). I kernel Unix più recenti, come Linux, sono realizzati sfruttando alcune caratteristiche dei processori moderni come la gestione hardware della memoria e la modalità protetta. In sostanza con i processori moderni si può disabilitare temporaneamente l uso di certe istruzioni e l accesso a certe zone di memoria fisica. Quello che succede è che il kernel è il solo programma ad essere eseguito in modalità privilegiata, con il completo accesso all hardware, mentre i programmi normali vengono eseguiti in modalità protetta (e non possono accedere direttamente alle zone di memoria riservate o alle porte di input/output). Una parte del kernel, lo scheduler, si occupa di stabilire, ad intervalli fissi e sulla base di un opportuno calcolo delle priorità, quale processo deve essere posto in esecuzione (il cosiddetto preemptive scheduling). Questo verrà comunque eseguito in modalità protetta; quando necessario il processo potrà accedere alle risorse hardware soltanto attraverso delle opportune chiamate al sistema che restituiranno il controllo al kernel. 3

4 CAPITOLO 1. L ARCHITETTURA DEL SISTEMA La memoria viene sempre gestita dal kernel attraverso il meccanismo della memoria virtuale, che consente di assegnare a ciascun processo uno spazio di indirizzi virtuale (vedi sez. 2.2) che il kernel stesso, con l ausilio della unità di gestione della memoria, si incaricherà di rimappare automaticamente sulla memoria disponibile, salvando su disco quando necessario (nella cosiddetta area di swap) le pagine di memoria in eccedenza. Le periferiche infine vengono viste in genere attraverso un interfaccia astratta che permette di trattarle come fossero file, secondo il concetto per cui everything is a file, su cui torneremo in dettaglio in cap. 4, (questo non è vero per le interfacce di rete, che hanno un interfaccia diversa, ma resta valido il concetto generale che tutto il lavoro di accesso e gestione a basso livello è effettuato dal kernel). 1.1.2 User space e kernel space Uno dei concetti fondamentali su cui si basa l architettura dei sistemi Unix è quello della distinzione fra il cosiddetto user space, che contraddistingue l ambiente in cui vengono eseguiti i programmi, e il kernel space, che è l ambiente in cui viene eseguito il kernel. Ogni programma vede sé stesso come se avesse la piena disponibilità della CPU e della memoria ed è, salvo i meccanismi di comunicazione previsti dall architettura, completamente ignaro del fatto che altri programmi possono essere messi in esecuzione dal kernel. Per questa separazione non è possibile ad un singolo programma disturbare l azione di un altro programma o del sistema e questo è il principale motivo della stabilità di un sistema unixlike nei confronti di altri sistemi in cui i processi non hanno di questi limiti, o che vengono per vari motivi eseguiti al livello del kernel. Pertanto deve essere chiaro a chi programma in Unix che l accesso diretto all hardware non può avvenire se non all interno del kernel; al di fuori dal kernel il programmatore deve usare le opportune interfacce che quest ultimo fornisce allo user space. 1.1.3 Il kernel e il sistema Per capire meglio la distinzione fra kernel space e user space si può prendere in esame la procedura di avvio di un sistema unix-like; all avvio il BIOS (o in generale il software di avvio posto nelle EPROM) eseguirà la procedura di avvio del sistema (il cosiddetto boot), incaricandosi di caricare il kernel in memoria e di farne partire l esecuzione; quest ultimo, dopo aver inizializzato le periferiche, farà partire il primo processo, init, che è quello che a sua volta farà partire tutti i processi successivi. Fra questi ci sarà pure quello che si occupa di dialogare con la tastiera e lo schermo della console, e quello che mette a disposizione dell utente che si vuole collegare, un terminale e la shell da cui inviare i comandi. E da rimarcare come tutto ciò, che usualmente viene visto come parte del sistema, non abbia in realtà niente a che fare con il kernel, ma sia effettuato da opportuni programmi che vengono eseguiti, allo stesso modo di un qualunque programma di scrittura o di disegno, in user space. Questo significa, ad esempio, che il sistema di per sé non dispone di primitive per tutta una serie di operazioni (come la copia di un file) che altri sistemi (come Windows) hanno invece al loro interno. Pertanto buona parte delle operazioni di normale amministrazione di un sistema, come quella in esempio, sono implementate come normali programmi. Per questo motivo quando ci si riferisce al sistema nella sua interezza è corretto parlare di un sistema GNU/Linux: da solo il kernel è assolutamente inutile; quello che costruisce un sistema operativo utilizzabile è la presenza di tutta una serie di librerie e programmi di utilità (che di norma sono quelli realizzati dal progetto GNU della Free Software Foundation) che permettono di eseguire le normali operazioni che ci si aspetta da un sistema operativo.

1.1. UNA PANORAMICA 5 1.1.4 Chiamate al sistema e librerie di funzioni Come accennato le interfacce con cui i programmi possono accedere all hardware vanno sotto il nome di chiamate al sistema (le cosiddette system call), si tratta di un insieme di funzioni che un programma può chiamare, per le quali viene generata un interruzione del processo passando il controllo dal programma al kernel. Sarà poi quest ultimo che (oltre a compiere una serie di operazioni interne come la gestione del multitasking e l allocazione della memoria) eseguirà la funzione richiesta in kernel space restituendo i risultati al chiamante. Ogni versione di Unix ha storicamente sempre avuto un certo numero di queste chiamate, che sono riportate nella seconda sezione del Manuale di programmazione di Unix (quella cui si accede con il comando man 2 <nome>) e Linux non fa eccezione. Queste sono poi state codificate da vari standard, che esamineremo brevemente in sez. 1.2. Uno schema elementare della struttura del sistema è riportato in fig. 1.1. Figura 1.1: Schema di massima della struttura di interazione fra processi, kernel e dispositivi in Linux. Normalmente ciascuna di queste chiamate al sistema viene rimappata in opportune funzioni con lo stesso nome definite dentro la Libreria Standard del C, che, oltre alle interfacce alle system call, contiene anche tutta la serie delle ulteriori funzioni definite dai vari standard, che sono comunemente usate nella programmazione. Questo è importante da capire perché programmare in Linux significa anzitutto essere in grado di usare le varie interfacce contenute nella Libreria Standard del C, in quanto né il kernel, né il linguaggio C, implementano direttamente operazioni comuni come l allocazione dinamica della memoria, l input/output bufferizzato o la manipolazione delle stringhe, presenti in qualunque programma. Quanto appena illustrato mette in evidenza il fatto che nella stragrande maggioranza dei casi, 1 si dovrebbe usare il nome GNU/Linux (piuttosto che soltanto Linux) in quanto una parte essenziale del sistema (senza la quale niente funzionerebbe) è la GNU Standard C Library (in breve glibc), ovvero la libreria realizzata dalla Free Software Foundation nella quale sono state 1 esistono implementazioni diverse delle librerie Standard del C, come le libc5 o le uclib, che non derivano dal progetto GNU. Le libc5 oggi sono, tranne casi particolari, completamente soppiantate dalle glibc, le uclib pur non essendo complete come le glibc, restano invece molto diffuse nel mondo embedded per le loro di dimensioni ridotte (e soprattutto la possibilità di togliere le parti non necessarie), e pertanto costituiscono un valido rimpiazzo delle glibc in tutti quei sistemi specializzati che richiedono una minima occupazione di memoria.

6 CAPITOLO 1. L ARCHITETTURA DEL SISTEMA implementate tutte le funzioni essenziali definite negli standard POSIX e ANSI C, utilizzabili da qualunque programma. Le funzioni di questa libreria sono quelle riportate dalla terza sezione del Manuale di Programmazione di Unix (cioè accessibili con il comando man 3 <nome>) e sono costruite sulla base delle chiamate al sistema del kernel; è importante avere presente questa distinzione, fondamentale dal punto di vista dell implementazione, anche se poi, nella realizzazione di normali programmi, non si hanno differenze pratiche fra l uso di una funzione di libreria e quello di una chiamata al sistema. 1.1.5 Un sistema multiutente Linux, come gli altri kernel Unix, nasce fin dall inizio come sistema multiutente, cioè in grado di fare lavorare più persone in contemporanea. Per questo esistono una serie di meccanismi di sicurezza, che non sono previsti in sistemi operativi monoutente, e che occorre tenere presente. Il concetto base è quello di utente (user) del sistema, le cui capacità rispetto a quello che può fare sono sottoposte a ben precisi limiti. Sono così previsti una serie di meccanismi per identificare i singoli utenti ed una serie di permessi e protezioni per impedire che utenti diversi possano danneggiarsi a vicenda o danneggiare il sistema. Ogni utente è identificato da un nome (l username), che è quello che viene richiesto all ingresso nel sistema dalla procedura di login (descritta in dettaglio in sez. 10.1.4). Questa procedura si incarica di verificare l identità dell utente, in genere attraverso la richiesta di una parola d ordine (la password), anche se sono possibili meccanismi diversi. 2 Eseguita la procedura di riconoscimento in genere il sistema manda in esecuzione un programma di interfaccia (che può essere la shell su terminale o un interfaccia grafica) che mette a disposizione dell utente un meccanismo con cui questo può impartire comandi o eseguire altri programmi. Ogni utente appartiene anche ad almeno un gruppo (il cosiddetto default group), ma può essere associato ad altri gruppi (i supplementary group), questo permette di gestire i permessi di accesso ai file e quindi anche alle periferiche, in maniera più flessibile, definendo gruppi di lavoro, di accesso a determinate risorse, etc. L utente e il gruppo sono identificati da due numeri (la cui corrispondenza ad un nome espresso in caratteri è inserita nei due file /etc/passwd e /etc/groups). Questi numeri sono l user identifier, detto in breve user-id, ed indicato dall acronimo uid, e il group identifier, detto in breve group-id, ed identificato dall acronimo gid, e sono quelli che vengono usati dal kernel per identificare l utente. In questo modo il sistema è in grado di tenere traccia per ogni processo dell utente a cui appartiene ed impedire ad altri utenti di interferire con esso. Inoltre con questo sistema viene anche garantita una forma base di sicurezza interna in quanto anche l accesso ai file (vedi sez. 5.3) è regolato da questo meccanismo di identificazione. Infine in ogni Unix è presente un utente speciale privilegiato, il cosiddetto superuser, il cui username è di norma root, ed il cui uid è zero. Esso identifica l amministratore del sistema, che deve essere in grado di fare qualunque operazione; per l utente root infatti i meccanismi di controllo descritti in precedenza sono disattivati. 3 2 Ad esempio usando la libreria PAM (Pluggable Autentication Methods) è possibile astrarre completamente dai meccanismi di autenticazione e sostituire ad esempio l uso delle password con meccanismi di identificazione biometrica. 3 i controlli infatti vengono sempre eseguiti da un codice del tipo if (uid) {... }

1.2. GLI STANDARD 7 1.2 Gli standard In questa sezione faremo una breve panoramica relativa ai vari standard che nel tempo sono stati formalizzati da enti, associazioni, consorzi e organizzazioni varie al riguardo del sistema o alle caratteristiche che si sono stabilite come standard di fatto in quanto facenti parte di alcune implementazioni molto diffuse come BSD o SVr4. Ovviamente prenderemo in considerazione solo gli standard riguardanti interfacce di programmazione e le altre caratteristiche di un sistema unix-like (alcuni standardizzano pure i comandi base del sistema e la shell) ed in particolare ci concentreremo sul come ed in che modo essi sono supportati sia per quanto riguarda il kernel che le librerie del C (con una particolare attenzione alle glibc). 1.2.1 Lo standard ANSI C Lo standard ANSI C è stato definito nel 1989 dall American National Standard Institute, come standard del linguaggio C ed è stato successivamente adottato dalla International Standard Organisation come standard internazionale con la sigla ISO/IEC 9899:1990, e va anche sotto il nome di standard ISO C. Scopo dello standard è quello di garantire la portabilità dei programmi C fra sistemi operativi diversi, ma oltre alla sintassi ed alla semantica del linguaggio C (operatori, parole chiave, tipi di dati) lo standard prevede anche una libreria di funzioni che devono poter essere implementate su qualunque sistema operativo. Per questo motivo, anche se lo standard non ha alcun riferimento ad un sistema di tipo Unix, GNU/Linux (per essere precisi le glibc), come molti Unix moderni, provvede la compatibilità con questo standard, fornendo le funzioni di libreria da esso previste. Queste sono dichiarate in una serie di header file 4 (anch essi provvisti dalla glibc), In tab. 1.1 si sono riportati i principali header file definiti nello standard POSIX, insieme a quelli definiti negli altri standard descritti nelle sezioni successive. Header Standard ANSI C POSIX Contenuto assert.h Verifica le asserzioni fatte in un programma. errno.h Errori di sistema. fcntl.h Controllo sulle opzioni dei file. limits.h Limiti e parametri del sistema...... stdio.h I/O bufferizzato in standard ANSI C. stdlib.h definizioni della libreria standard. Tabella 1.1: Elenco dei vari header file definiti dallo standard POSIX. In realtà glibc ed i relativi header file definiscono un insieme di funzionalità in cui sono incluse come sottoinsieme anche quelle previste dallo standard ANSI C. È possibile ottenere una conformità stretta allo standard (scartando le funzionalità addizionali) usando il gcc con l opzione -ansi. Questa opzione istruisce il compilatore a definire nei vari header file soltanto le funzionalità previste dallo standard ANSI C e a non usare le varie estensioni al linguaggio e al preprocessore da esso supportate. 4 i file di dichiarazione di variabili, tipi e funzioni, usati normalmente da un compilatore C. Per poter accedere alle funzioni occorre includere con la direttiva #include questi file nei propri programmi; per ciascuna funzione che tratteremo in seguito indicheremo anche gli header file necessari ad usarla.

8 CAPITOLO 1. L ARCHITETTURA DEL SISTEMA 1.2.2 I tipi di dati primitivi Uno dei problemi di portabilità del codice più comune è quello dei tipi di dati utilizzati nei programmi, che spesso variano da sistema a sistema, o anche da una architettura ad un altra (ad esempio passando da macchine con processori 32 bit a 64). In particolare questo è vero nell uso dei cosiddetti tipi elementari del linguaggio C (come int) la cui dimensione varia a seconda dell architettura hardware. Storicamente alcuni tipi nativi dello standard ANSI C sono sempre stati associati ad alcune variabili nei sistemi Unix, dando per scontata la dimensione. Ad esempio la posizione corrente all interno di un file è sempre stata associata ad un intero a 32 bit, mentre il numero di dispositivo è sempre stato associato ad un intero a 16 bit. Storicamente questi erano definiti rispettivamente come int e short, ma tutte le volte che, con l evolversi ed il mutare delle piattaforme hardware, alcuni di questi tipi si sono rivelati inadeguati o sono cambiati, ci si è trovati di fronte ad una infinita serie di problemi di portabilità. Tipo caddr_t clock_t dev_t gid_t ino_t key_t loff_t mode_t nlink_t off_t pid_t rlim_t sigset_t size_t ssize_t ptrdiff_t time_t uid_t Contenuto core address. contatore del tempo di sistema. Numero di dispositivo. Identificatore di un gruppo. Numero di inode. Chiave per il System V IPC. Posizione corrente in un file. Attributi di un file. Contatore dei link su un file. Posizione corrente in un file. Identificatore di un processo. Limite sulle risorse. Insieme di segnali. Dimensione di un oggetto. Dimensione in numero di byte ritornata dalle funzioni. Differenza fra due puntatori. Numero di secondi (in tempo di calendario). Identificatore di un utente. Tabella 1.2: Elenco dei tipi primitivi, definiti in sys/types.h. Per questo motivo tutte le funzioni di libreria di solito non fanno riferimento ai tipi elementari dello standard del linguaggio C, ma ad una serie di tipi primitivi del sistema, riportati in tab. 1.2, e definiti nell header file sys/types.h, in modo da mantenere completamente indipendenti i tipi utilizzati dalle funzioni di sistema dai tipi elementari supportati dal compilatore C. 1.2.3 Lo standard IEEE POSIX Uno standard più attinente al sistema nel suo complesso (e che concerne sia il kernel che le librerie) è lo standard POSIX. Esso prende origine dallo standard ANSI C, che contiene come sottoinsieme, prevedendo ulteriori capacità per le funzioni in esso definite, ed aggiungendone di nuove. In realtà POSIX è una famiglia di standard diversi, il cui nome, suggerito da Richard Stallman, sta per Portable Operating System Interface, ma la X finale denuncia la sua stretta relazione con i sistemi Unix. Esso nasce dal lavoro dell IEEE (Institute of Electrical and Electronics Engeneers) che ne produsse una prima versione, nota come IEEE 1003.1-1988, mirante a standardizzare l interfaccia con il sistema operativo. Ma gli standard POSIX non si limitano alla standardizzazione delle funzioni di libreria, e in seguito sono stati prodotti anche altri standard per la shell e i comandi di sistema (1003.2), per le estensioni realtime e per i thread (1003.1d e 1003.1c) e vari altri. In tab. 1.3 è riportata una

1.2. GLI STANDARD 9 classificazione sommaria dei principali documenti prodotti, e di come sono identificati fra IEEE ed ISO; si tenga conto inoltre che molto spesso si usa l estensione IEEE anche come aggiunta al nome POSIX (ad esempio si può parlare di POSIX.4 come di POSIX.1b). Si tenga presente inoltre che nuove specifiche e proposte di standardizzazione si aggiungono continuamente, mentre le versioni precedenti vengono riviste; talvolta poi i riferimenti cambiamo nome, per cui anche solo seguire le denominazioni usate diventa particolarmente faticoso; una pagina dove si possono recuperare varie (e di norma piuttosto intricate) informazioni è: http://www.pasc.org/standing/sd11.html. Standard IEEE ISO Contenuto POSIX.1 1003.1 9945-1 Interfacce di base POSIX.1a 1003.1a 9945-1 Estensioni a POSIX.1 POSIX.2 1003.2 9945-2 Comandi POSIX.3 2003 TR13210 Metodi di test POSIX.4 1003.1b Estensioni real-time POSIX.4a 1003.1c Thread POSIX.4b 1003.1d 9945-1 Ulteriori estensioni real-time POSIX.5 1003.5 14519 Interfaccia per il linguaggio ADA POSIX.6 1003.2c,1e 9945-2 Sicurezza POSIX.8 1003.1f 9945-1 Accesso ai file via rete POSIX.9 1003.9 Interfaccia per il Fortran-77 POSIX.12 1003.1g 9945-1 Socket Tabella 1.3: Elenco dei vari standard POSIX e relative denominazioni. Benché l insieme degli standard POSIX siano basati sui sistemi Unix essi definiscono comunque un interfaccia di programmazione generica e non fanno riferimento ad una implementazione specifica (ad esempio esiste un implementazione di POSIX.1 anche sotto Windows NT). Lo standard principale resta comunque POSIX.1, che continua ad evolversi; la versione più nota, cui gran parte delle implementazioni fanno riferimento, e che costituisce una base per molti altri tentativi di standardizzazione, è stata rilasciata anche come standard internazionale con la sigla ISO/IEC 9945-1:1996. Linux e le glibc implementano tutte le funzioni definite nello standard POSIX.1, queste ultime forniscono in più alcune ulteriori capacità (per funzioni di pattern matching e per la manipolazione delle regular expression), che vengono usate dalla shell e dai comandi di sistema e che sono definite nello standard POSIX.2. Nelle versioni più recenti del kernel e delle librerie sono inoltre supportate ulteriori funzionalità aggiunte dallo standard POSIX.1c per quanto riguarda i thread (vedi cap.??), e dallo standard POSIX.1b per quanto riguarda i segnali e lo scheduling real-time (sez. 9.4.6 e sez. 3.4.3), la misura del tempo, i meccanismi di intercomunicazione (sez. 12.4) e l I/O asincrono (sez. 11.1.3). 1.2.4 Lo standard X/Open XPG3 Il consorzio X/Open nacque nel 1984 come consorzio di venditori di sistemi Unix per giungere ad un armonizzazione delle varie implementazioni. Per far questo iniziò a pubblicare una serie di documentazioni e specifiche sotto il nome di X/Open Portability Guide (a cui di norma si fa riferimento con l abbreviazione XPGn). Nel 1989 produsse una terza versione di questa guida particolarmente voluminosa (la X/Open Portability Guide, Issue 3 ), contenente un ulteriore standardizzazione dell interfaccia di sistema di Unix, che venne presa come riferimento da vari produttori. Questo standard, detto anche XPG3 dal nome della suddetta guida, è sempre basato sullo standard POSIX.1, ma prevede una serie di funzionalità aggiuntive fra cui le specifiche delle API (Application Programmable Interface) per l interfaccia grafica (X11).