appunti kernel

==========================
File system
==========================
Il kernel 2.6 supporta 40 tipi di filesystem, per far fronte alle necessità di utenti di piattaforme diverse. Un file
non è altro che un punto di accesso a dati che possono trovarsi su un disco locale o in rete. Generalizzando
il concetto addirittura tutto è un file su Linux: i dati, le cartelle, i dispositivi fisici o il meccanismo di
comunicazione tra processi. Il kernel accede i file per mezzo di un'unica interfaccia, il filesystem virtuale
(VFS).
Il VFS è uno strato software che consente di rappresentare tutti i file di un sistema tramite una
rappresentazione ad albero gerarchica. I processi utente possono accedere ad un file senza sapere dove e
in quale filesystem tale file sia memorizzato.
Le richieste di accesso come read, write e open vengono inviate al filesystem virtuale che determina il
filesystem reale corrispondente ed esegue l'operazione grazie al driver specifico.
La posizione di ciascun file è descritta da un attributo chiamato inode e il VFS consente di associare a ogni
inode differenti nomi di file.
Per migliorare le prestazioni di accesso a file e directory, il sistema mantiene due cache relative alle directory
e agli inode referenziate di recente.

==========================
I/O
==========================
I vari dispositivi di un sistema possono essere raggruppati in classi in base alle funzioni eseguite, in questo
modo il kernel è in grado di considerare le necessità delle diverse classi di dispositivi al fine di migliorarne le
prestazioni.
In particolare possiamo distinguere i dispositivi a caratteri e i dispositivi a blocchi.
Un dispositivo a caratteri trasmette i dati come un “flusso” di byte, in modo sequenziale. Ne sono un esempio
stampanti, mouse, tastiere e modem. Le operazioni base del dispositivo (apertura, lettura, scrittura, chiusura)
vengono implementate dai driver. I dispositivi sono rappresentati da una struttura che contiene il nome del
driver e le operazioni consentite. Quando un dispositivo viene inizializzato, il driver deve registrare tali
operazioni nel VFS. Quando una chiamata di sistema accede al file di un dispositivo, il VFS si occupa di
invocare l'operazione appropriata.
I dati di un dispositivo a blocchi sono invece organizzati in blocchi di byte di dimensione fissa,
consentendone quindi l'accesso casuale (non sequenziale). A tale scopo, la gestione dell'I/O risulta più
sofisticata che sui dispositivi a caratteri, utilizzando strategie di caching e raggruppamento delle operazioni
per ottimizzare le performance. Quando un processo richiede dei dati da un dispositivo a blocchi il kernel
cerca i blocchi richiesti nella cache e li trasferisce nello spazio virtuale dell'utente se li trova. Per le
operazioni di scrittura invece viene utilizzata una cache di operazioni pendenti che verrà processata
seguendo il meccanismo di scheduling del disco.

==========================
Comunicazione tra processi
==========================
Linux eredita i meccanismi di comunicazione tra processi di UNIX. Lo scopo di tali meccanismi è quello di
permettere ai processi lo scambio di informazioni. Esistono diversi metodi per consentire tale scambio di
informazioni ma alcuni risultano più adatti di altri in determinate situazioni:
–
Segnali: sono uno dei primi meccanismi disponibili su unix e non consentono di scambiare più di una
parola di dati alla volta. Solitamente vengono utilizzati per notificare a un processo il verificarsi di un
determinato evento. Sebbene i segnali effettivamente supportati dipendano dall'architettura del
processore, tutte le moderne architetture supportano l'insieme di segnali specificati dallo standard
POSIX.
Un processo può ignorare un segnale (tranne SIGSTOP e SIGKILL responsabili dell'arresto e della
terminazione di un processo), “catturarlo” (cioè invocare un proprio gestore relativo a quel segnale)
oppure eseguire un'azione di default definita dal kernel per quel segnale.
–
Pipe: una pipe consente a due processi di comunicare secondo uno schema
produttore/consumatore. Il produttore scrive i dati nella pipe e il processo consumatore li legge
nell'ordine in cui li ha ricevuti (politica FIFO: First In First Out). Quando viene creata una pipe, le
viene assegnato un inode e due descrittori d'accesso: uno in scrittura, l'altro in lettura. In questo
modo è possibile accedere alla pipe come ad un file utilizzando il VFS.
–
Socket: è un meccanismo di comunicazione diretta tra processi su un canale bidirezionale,
superando la comunicazione unidirezionale delle pipe. Tuttavia la maggior flessibilità ha un costo in
termini di prestazioni.
–
Messaggi: un messaggio è un'informazione composta da un tipo di messaggio e da un'area di
lunghezza variabile per i dati. Sono organizzati in code accessibili grazie a specifici descrittori.
Quando un messaggio viene aggiunto alla coda, il kernel cerca un processo in attesa di un
messaggio di quel tipo, se ne trova inoltra il messaggio ad ognuno di loro.
–
Memoria condivisa: una volta stabilita una regione di memoria condivisa, il vantaggio rispetto alle
altre forme di IPC è che l'accesso è regolato nello spazio utente e non è necessario l'intervento del
kernel. Questo migliora le prestazioni di processi che richiedono accessi frequenti ed elimina i tempi
di attesa quando i processi lavorano a velocità differenti.
–
Semafori: come il nome lascia intuire, si tratta di un meccanismo per gestire la sincronizzazione,
proteggendo le sezioni critiche in caso di accesso alla stessa risorsa da parte di più processi.

==========================
Sottosistema di rete
==========================
Si occupa di eseguire operazioni sui pacchetti durante l'attraversamento dei vari strati dei protocolli di rete.
Quando una scheda di rete riceve un pacchetto, lo copia in un buffer e lo aggiunge alla coda dei pacchetti in
attesa di elaborazione. Per l'elaborazione il pacchetto viene rimosso dalla coda e passato al gestore del
protocollo appropriato. In particolare ci riferiamo al protocollo IP dal momento che altri protocolli sono
raramente usati seppur supportati. Il gestore del protocollo IP ne determina la destinazione : se il pacchetto è
destinato ad un altra macchina lo inoltra, se è destinato alla macchina locale lo passa al gestore appropriato
tra TCP, UDP o ICMP che a sua volta si occupa di consegnare il pacchetto alla porta specificata. Infine i dati
sono trasmessi al processo destinatario tramite il socket collegato alla porta.