INDIRIZZAMENTO DELLA MEMORIA I programmatori si riferiscono all’indirizzo di memoria come al modo di accedere al contenuto di una cella di memoria. Quando si tratta di processori 80x86, dobbiamo distinguere tre tipi di indirizzo: Indirizzo logico – usato nelle istruzioni in linguaggio macchina per specificare l’indirizzo di un operando o di una istruzione. Questo tipo rappresenta la base dell’architettura a segmenti del 80x86 che costringe i programmatori MS-DOS e Windows a dividere i programmi in segmenti . Ogni indirizzo logico è formato da un segmento e da un offset (o spiazzamento) che indica la distanza tra l’inizio del segmento e la posizione attuale. Indirizzo lineare o virtuale – un intero a 32 bit senza segno che può indirizzare fino a 4 GB di locazioni di memoria. Viene di solito rappresentato in notazione esadecimale; l'intervallo di valori va da 0x00000000 a 0xffffffff. Indirizzo fisico – usato per indirizzare le celle nei chip di memoria. Corrisponde al segnale elettrico inviato dai contatti del microprocessore al bus di memoria. Viene rappresentato da un intero senza segno a 32 o 36 bit. L’unità di gestione della memoria (Memory Management Unit – MMU) trasforma un indirizzo logico in uno lineare per mezzo di un circuito hardware chiamato unità di segmentazione; un secondo circuito chiamato unità di paginazione trasforma l’indirizzo lineare in fisico. Nei sistemi multiprocessore, tutte le CPU condividono di solito la stessa memoria; ciò significa che ai chip di RAM possono accedere contemporaneamente e in modo indipendente. Poiché le operazioni di lettura e scrittura su un chip devono avvenire in modo seriale, un circuito chiamato arbitro della memoria è inserito fra il bus ed ogni chip di RAM. Il suo compito è garantire l’accesso al chip se libero e rinviarlo se occupato dalla richiesta di un’altra CPU. Anche i sistemi uniprocessore usano l’arbitro della memoria, poiché includono processori specializzati, i controller DMA, che operano contemporaneamente alla CPU. Nel caso dei sistemi multiprocessore, la struttura dell’arbitro è più complessa a causa del maggior numero di ingressi. Il Pentium dual-core, ad esempio, ha un arbitro con due porte di ingresso per ogni chip e richiede messaggi di sincronizzazione tra le due CPU prima del tentativo di uso del bus in comune. Dal punto di vista del programmatore, la gestione dell’arbitro è trasparente perché viene svolta da circuiti hardware.
Segmentazione hardware A partire dal 386, i microprocessori Intel compiono la traduzione degli indirizzi in due modi diversi, in modalità reale e protetta. Nel prossimo paragrafo verrà trattata la modalità protetta. La modalità reale esiste principalmente per mantenere la compatibilità con i modelli più vecchi e per consentire l’avviamento del sistema operativo (bootstrap). Selettori e registri di segmento Selettore di segmento indice 15
TI = Table Indicator
TI 3
RPL 2
RPL= Requestor Privilege Level
1
0 bit
Un indirizzo logico è diviso in due parti: un identificatore di segmento e un offset che indica la posizione relativa entro il segmento. L’identificatore è un campo di 16 bit chiamato selettore di segmento, mentre l’offset è un campo di 32 bit. Il selettore viene descritto più avanti. Per ottenere più velocemente il selettore di segmento, il processore fornisce registri di segmento, il cui scopo è di memorizzare il selettore di segmento: sono i registri cs, ss, ds, es, fs, gs. Anche se sono solo sei, un programma può utilizzarli per scopi differenti, salvandone il contenuto in memoria per poi memorizzarlo di nuovo. Tre dei sei registri hanno finalità specifiche: cs – registro del segmento del codice, punta al segmento che contiene le istruzioni del programma ss – registro del segmento dello stack, punta al segmento che contiene lo stack del programma corrente ds – registro del segmento dei dati, punta al segmento che contiene i dati globali e statici. Gli altri tre registri sono di uso generale e possono riferirsi a segmenti generici. Il registro cs ha un’altra importante funzione: include un campo di 2 bit che specifica il Livello di Privilegio Corrente (Current Privilege Level – CPL) della CPU. Il valore 0 indica il privilegio maggiore, mentre 3 quello inferiore. Linux usa solo i livello 0 e 3, che corrispondono rispettivamente alla modalità del kernel (Kernel Mode) e alla modalità utente (User Mode).
Descrittori di segmento Ogni segmento è rappresentato da un Descrittore di Segmento di 8 byte che ne descrive le caratteristiche. I descrittori sono memorizzati nella Global Descriptor Table (GDT) o nella Local Descriptor Table (LDT). Descrittore di segmento dati Base(24-31)
G
B
0
A V L
Limit(16-19)
1
D P L
S = 1
Type
Base (16-23)
Base(0-15)
Limit(0-15)
1
D P L
S = 1
Type
Base (16-23)
Base(0-15)
Limit(0-15)
D P L
S = 0
Type
Base(16-23)
Base(0-15)
Limit(0-15)
Descrittore di segmento codice Base(24-31)
G
D
0
A V L
Limit(16-19)
Descrittore di segmento di sistema Base(24-31) 63
G
0
Limit(16-19)
1
bit
0
Di solito esiste una sola GDT, mentre ogni processo può avere la propria LDT se ne ha bisogno per creare altri segmenti oltre a quelli contenuti nella GDT. L’indirizzo e la dimensione della GDT e della LDT corrente sono memorizzati nei registri di controllo gdtr e ldtr. Il significato dei campi dei descrittori è il seguente: Base – contiene l’indirizzo lineare del primo byte del segmento.
2
G – flag di granularità; se è azzerato, la dimensione del segmento è espressa in byte, altrimenti è in multipli di 4096 bytes. Limit – contiene l’offset dell’ultima locazione di memoria del segmento; rappresenta la lunghezza del segmento. Quando G = 0, la dimensione può andare da 1 byte a 1 MB; altrimenti può andare da 4 K a 4 GB. S – flag di sistema; se è azzerato, indica un segmento di sistema che contiene strutture dati importanti come la LDT; se è settato, indica un segmento codice o dati normali. Type – caratterizza il tipo di segmento e i diritti di accesso DPL – Livello di Privilegio del Descrittore (Descriptor Privilege Level): usato per limitare gli accessi al segmento. Rappresenta il livello minimo di privilegio della CPU per accedere al segmento. Quindi un segmento con DPL uguale a 0 è accessibile solo quando CPL è 0, cioè in modalità del kernel, mentre un segmento con DPL uguale a 3 è accessibile con qualunque valore di CPL. P – flag presente: è uguale a 0 se il segmento non è attualmente caricato in memoria. Linux imposta sempre a 1 questo flag, perché non usa mai lo swapping su disco di un intero segmento. D o B – a seconda che il segmento contenga codice o dati. Il significato è piuttosto diverso nei due casi, ma il byte è impostato a 1 se gli indirizzi usati come offset sono di 32 bit, ed è azzerato se sono di 16 bit (per maggiori dettagli consultare la documentazione Intel). AVL – può essere usato dal sistema operativo, ma è ignorato da Linux.
Ci sono diversi tipi di segmenti e di conseguenza diversi tipi di Descrittori di Segmento. Di seguito sono elencati quelli più usati da Linux. Descrittore di Segmento Codice - si riferisce ad un segmento di codice; può essere incluso sia nella GDT che nella LDT. Ha il flag S attivato (non è di sistema). Descrittore di Segmento Dati – si riferisce ad un segmento dati; può essere incluso sia nella GDT che nella LDT. Ha il flag S attivato. I segmenti che contengono lo stack sono implementati con questo tipo. Descrittore di Segmento di Stato del Task (TSSD) – si riferisce a un Task State Segment (TSS), cioè a un segmento usato per salvare il contenuto dei registri del processore; è presente solo nella GDT. Il valore del campo Type è 11 o 9, a seconda se il processo corrispondente è attualmente in esecuzione su una CPU oppure no. Il flag S è azzerato. Descrittore di Tabella del Descrittore Locale (Local Descriptor Table Descriptor – LDTD) – si riferisce a un segmento che contiene una LDT; può apparire solo nella GDT. Il campo Type ha valore 2. Il flag S è azzerato. Di seguito viene spiegato come il processore 80x86 è in grado di decidere se un descrittore è memorizzato nella GDT o nella LDT di un processo.
Accesso rapido ai descrittori di segmento Gli indirizzi logici sono composti da un Selettore di Segmento a 16 bit e da un offset a 32 bit, e i registri di segmento memorizzano solo il Selettore di Segmento. Per velocizzare la traduzione di indirizzi logici in lineari, il processore 80x86 è dotato di un registro addizionale non programmabile – che non può essere impostato dal programmatore – per ognuno dei sei registri di segmento programmabili. Ogni registro non programmabile contiene gli 8 byte del Descrittore di Segmento corrispondente . Ogni volta che un Selettore 3
è caricato in un registro di segmento, il relativo Descrittore viene caricato nel registro non programmabile corrispondente. Di conseguenza la traduzione degli indirizzi logici che si riferiscono a quel segmento può avvenire senza accedere alla GDT o alla LDT presenti in memoria. L’accesso alle tabelle è necessario solo quando cambia il contenuto dei registri di segmento. Ogni Selettore di Segmento contiene questi tre campi: index – identifica la entry del Descrittore nella GDT o nella LDT TI – Indicatore di Tabella (Table Indicator): specifica se il Descrittore è incluso nella GDT (TI = 0) o nella LDT (TI = 1). RPL – Requestor Privilege Level: specifica il CPL della CPU quando il selettore è caricato nel registro cs; può essere usato per ridurre selettivamente il livello di privilegio quando si accede ai segmenti dati (per maggiori dettagli consultare la documentazione Intel).
Poiché un Descrittore di segmento è lungo 8 byte, il suo indirizzo relativo entro la GDT o la LDT viene calcolato moltiplicando il campo indice del Selettore (13 byte) per 8. Per esempio, se la GDT si trova all’indirizzo 0x00020000 (valore memorizzato nel registro gdtr) e l'indice vale 2, l’indirizzo del descrittore corrispondente sarà 0x00020000 + (2 x 8), ossia 0x00020010. La prima entry della GDT ha sempre valore 0. Questo assicura che l’indirizzo logico con un Selettore di Segmento nullo viene considerato non valido, causando così un’eccezione del processore. Il numero massimo di descrittori nella GDT è 8.191 (2 13 – 1).
Unità di segmentazione Per tradurre un indirizzo logico nel corrispondente indirizzo lineare, l’unità di segmentazione compie le seguenti operazioni: 1 - esamina il campo TI del Selettore per determinare quale tabella contiene il Descrittore. Questo campo indica se esso è presente nella GDT (in questo caso l’unità di segmentazione ottiene l’indirizzo lineare di base della GDT dal registro gdtr) o nella LDT attiva (in questo caso l’indirizzo è ottenuto dal registro ldtr); 2 -calcola l’indirizzo del Descrittore in base al campo Indice del selettore. L’Indice viene moltiplicato per 8 (la dimensione del Descrittore) e il risultato viene aggiunto al contenuto del registro gdtr o ldtr; 3 -aggiunge l’offset al campo Base del Descrittore, ottenendo così l’indirizzo lineare. Da notare che, grazie ai registri non programmabili associati a quelli di segmento, le prime due operazioni sono necessarie solo se il registro di segmento ha cambiato valore.
Segmentazione in Linux La segmentazione è stata introdotta nei microprocessori 80x86 per incoraggiare i programmatori a dividere le loro applicazioni in entità correlate logicamente, come subroutine o aree dati globali e locali. Linux però usa la segmentazione in modo molto limitato. Infatti segmentazione e paginazione sono in qualche modo ridondanti, perché entrambe possono venire usate per separare lo spazio degli indirizzi fisici dei processi: la segmentazione può assegnare un intervallo di indirizzi lineari differente ad ogni processo, mentre la 4
paginazione può mappare lo stesso intervallo di indirizzi lineari in spazi diversi di indirizzi fisici. Linux preferisce la paginazione per questi motivi: - la gestione della memoria è più semplice quando tutti i processi usano lo stesso valore dei registri di segmento, cioè quando condividono lo stesso intervallo di indirizzi lineari; - uno degli obiettivi di progetto di Linux è la portabilità in un vasto insieme di architetture; in particolare i sistemi RISC hanno un limitato supporto alla segmentazione. La versione 2.6 di Linux usa la segmentazione solo quando richiesto dall’architettura 80x86. Tutti i processi in modalità utente impiegano lo stesso paio di segmenti per istruzioni e dati: user code segment e user data segment rispettivamente. Allo stesso modo tutti i processi in modalità del kernel usano lo stesso paio di segmenti codice e dati: kernel code segment e kernel data segment. La tabella riporta i valori dei campi del Descrittore per questi segmenti:
Segmento user code user data kernel code kernel data
Base 0x00000000 0x00000000 0x00000000 0x00000000
G 1 1 1 1
Limit 0xfffff 0xfffff 0xfffff 0xfffff
S 1 1 1 1
Type 10 2 10 2
DPL 3 3 0 0
D/B 1 1 1 1
P 1 1 1 1
I Selettori di Segmento corrispondenti sono definiti dalle macro __USER_CS, __USER_DS, __KERNEL_CS, __KERNEL_DS. Per indirizzare il segmento codice del kernel, viene caricato nel registro di segmento cs il valore definito dalla macro __KERNEL_CS.. Da notare che tutti gli indirizzi associati ai segmenti in questione vanno da 0 al limite di 2 32 – 1. Questo significa che tutti i processi, sia in modalità del kernel che in modalità utente, possono usare gli stessi indirizzi logici. Un’altra importante conseguenza è che in Linux gli indirizzi logici coincidono con quelli lineari; ciò significa anche che il valore del campo offset di un indirizzo logico coincide sempre con il valore del corrispondente indirizzo lineare. Come detto in precedenza, il CPL del processore indica se esso si trova in modalità del kernel o in modalità utente, e viene specificato dal campo RPL del Selettore di Segmento contenuto nel registro cs. Quando il valore di CPL cambia, alcuni registri di segmento devono essere aggiornati. Per esempio, quando CPL = 3, ds deve contenere il Selettore del segmento dati utente, ma quando CPL = 0 deve contenere il Selettore del segmento dati del kernel. Lo stesso vale per ss, che deve riferirsi allo stack della modalità utente nel primo caso, e allo stack della modalità del kernel nel secondo. Quando salva un puntatore ad una istruzione o a una struttura dati, il kernel non ha bisogno di memorizzare il Selettore dell’indirizzo logico, perché il registro ss contiene il Selettore di segmento corrente. Ad esempio, quando il kernel invoca una funzione, esegue una istruzione call specificando solo il componente offset del suo indirizzo logico; è implicitamente indicato che il Selettore è quello contenuto nel registro cs. Poiché esiste un solo segmento del tipo “eseguibile in modalità kernel”, cioè __KERNEL_CS, è sufficiente caricare questo valore in cs quando la CPU passa in modalità del kernel. Oltre ai quattro descritti, Linux usa pochi altri segmenti specializzati che vengono descritti insieme alla GDT.
5
La GDT di Linux In sistemi uniprocessore, c’è un’unica GDT, mentre quelli multiprocessore ne hanno una per ogni CPU. Tutte le GDT sono contenute nell’array cpu_gdt_table, mentre gli indirizzi e le dimensioni delle stesse sono memorizzate nell’array cpu_gdt_descr. Questi simboli sono definiti nel file arch/i386/kernel/head.S dei sorgenti del kernel. GDT Linux null reserved reserved reserved not used not used TLS#1 TLS#2 TLS#3 reserved reserved reserved kernel code kernel data user code user data
0x0
0x33 0x3b 0x43
0x60 __KERNEL_CS 0x68 __KERNEL_DS 0x73 __USER_CS 0x7b __USER_DS
TSS LDT PNPBIOS 32 bit code PNPBIOS 16 bit code PNPBIOS 16 bit code PNPBIOS 16 bit code PNPBIOS 16 bit code APMBIOS 32 bit code APMBIOS 16 bit code APMBIOS data not used not used not used not used not used Double fault TSS
0x80 0x88 0x90 0x98 0xa0 0xa8 0xb0 0xb8 0xc0 0xc8
0xf8
Dal file /arch/i386/kernel/head.S /* * The Global Descriptor Table contains 28 */ .align PAGE_SIZE_asm ENTRY(cpu_gdt_table) .quad 0x0000000000000000 /* NULL .quad 0x0000000000000000 /* 0x0b .quad 0x0000000000000000 /* 0x13 .quad 0x0000000000000000 /* 0x1b .quad 0x0000000000000000 /* 0x20 .quad 0x0000000000000000 /* 0x28 .quad 0x0000000000000000 /* 0x33 .quad 0x0000000000000000 /* 0x3b .quad 0x0000000000000000 /* 0x43 .quad 0x0000000000000000 /* 0x4b .quad 0x0000000000000000 /* 0x53 .quad 0x0000000000000000 /* 0x5b .quad .quad .quad .quad
0x00cf9a000000ffff 0x00cf92000000ffff 0x00cffa000000ffff 0x00cff2000000ffff
/* /* /* /*
0x60 0x68 0x73 0x7b
6
quadwords, per-CPU.
descriptor */ reserved */ reserved */ reserved */ unused */ unused */ TLS entry 1 */ TLS entry 2 */ TLS entry 3 */ reserved */ reserved */ reserved */ kernel 4GB code at 0x00000000 */ kernel 4GB data at 0x00000000 */ user 4GB code at 0x00000000 */ user 4GB data at 0x00000000 */
.quad 0x0000000000000000 .quad 0x0000000000000000
/* 0x80 TSS descriptor */ /* 0x88 LDT descriptor */
/* Segments used for calling PnP BIOS */ .quad 0x00c09a0000000000 /* 0x90 32-bit code */ .quad 0x00809a0000000000 /* 0x98 16-bit code */ .quad 0x0080920000000000 /* 0xa0 16-bit data */ .quad 0x0080920000000000 /* 0xa8 16-bit data */ .quad 0x0080920000000000 /* 0xb0 16-bit data */ /* * The APM segments have byte granularity and their * and limits are set at run time. */ .quad 0x00409a0000000000 /* 0xb8 APM CS code .quad 0x00009a0000000000 /* 0xc0 APM CS 16 code .quad 0x0040920000000000 /* 0xc8 APM DS data .quad .quad .quad .quad .quad .quad
0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000
/* /* /* /* /* /*
0xd0 0xd8 0xe0 0xe8 0xf0 0xf8
-
bases
*/ (16 bit) */ */
unused */ unused */ unused */ unused */ unused */ GDT entry 31: double-fault TSS */
Ogni GDT include 18 descrittori di segmento e 14 entry nulle, non usate o riservate. Esse sono inserite per fare si che i descrittori normalmente utilizzati insieme siano mantenuti nella stessa linea di 32 byte della cache hardware. - I 18 descrittori puntano ai seguenti segmenti: - I 4 fondamentali descritti in precedenza - Un Task State Segment (TSS) diverso per ogni processore. Lo spazio di indirizzi lineari di un TSS è un piccolo sottoinsieme di quello del segmento dati del kernel. I TSS sono memorizzati in sequenza nell’array init_tss; in particolare il campo Base del descrittore TSS per la CPU numero n punta alla posizione n dell’array init_tss. Il campo G è azzerato e Limit vale 0xeb, per cui il segmento è lungo 236 bytes. Type vale 9 o 11 e DPL è posto a 0 poiché i processi in modalità utente non possono accedere ai TSS. - Un segmento che contiene la LDT locale, di solito condivisa tra tutti i processi. - 3 Thread-Local Storage (TLS): è un sistema che consente alle applicazioni multithread di impiegare fino a tre segmenti di dati locali per ogni thread. Le chiamate di sistema set_thread_area() e get_thread_area() creano e rilasciano i TLS per il processo in esecuzione. - 3 segmenti connessi al sistema Advanced Power Management (APM): il codice del BIOS fa uso dei segmenti, per cui quando il driver Linux APM invoca le funzioni del BIOS per interrogare o definire lo stato dei dispositivi APM può fare uso degli appositi segmenti codice e dati. -5 segmenti correlati ai servizi Plug and Play (PnP) del BIOS. Vale il caso precedente. - Un segmento speciale TSS usato dal kernel per gestire le eccezioni “Double fault”. 7
Tutte le GDT dei sistemi multiprocessore hanno le medesime entry, tranne che in pochi casi. Ogni processore ha un proprio TSS, per cui la relativa entry nella GDT differisce dalle altre. Inoltre alcune entry possono dipendere dal processo che la CPU sta eseguendo (LDT e TLS). Infine in alcuni casi un processore può modificare temporaneamente una entry nella propria copia della GDT, ad esempio quando chiama una procedura APM del BIOS.
La LDT di Linux La maggior parte delle applicazioni in modalità utente non usano la LDT, per cui il kernel ne definisce una comune a tutti i processi, contenuta nell’array default_ldt. Questo array contiene 5 entry, ma solo 2 sono effettivamente usate dal kernel: una call gate per gli eseguibili BCS e una per gli eseguibili Solaris/x86. Le call gate sono metodi forniti dai processori 80x86 per cambiare il livello di privilegio della CPU quando chiama una funzione predefinita; per i particolari consultare la documentazione Intel In qualche caso però un processo può richiedere la propria LDT, ad esempio Wine che esegue applicazioni Windows orientate ai segmenti. La chiamata di sistema modify_ldt() permette di fare ciò. Ogni LDT privata richiede anche il proprio segmento; viene di conseguenza modificata la entry della LDT nella copia della GDT che si riferisce alla CPU in questione. Le applicazioni in modalità utente possono allocare nuovi segmenti per mezzo di modify_ldt(); il kernel tuttavia non li utilizza mai e non tiene traccia dei corrispondenti Descrittori, poiché sono inclusi nella LDT del processo.
Paginazione hardware L’unità di paginazione traduce gli indirizzi lineari in indirizzi fisici. Uno dei compiti chiave dell’unità è di controllare il tipo di accesso richiesto confrontandolo con i diritti di accesso dell’indirizzo. Se l'accesso alla memoria non è valido, genera una eccezione di “Page Fault” (errore di pagina). Per ragioni di efficienza gli indirizzi lineari sono raggruppati in intervalli di lunghezza fissa chiamati pagine: indirizzi consecutivi appartenenti ad una pagina sono mappati in indirizzi fisici contigui. In questo modo il kernel può definire l’indirizzo e i diritti di accesso di una pagina intera e non dei singoli indirizzi lineari. Il termine “pagina” indica sia l’insieme di indirizzi lineari sia i dati contenuti in essi. L’unità di paginazione considera la RAM suddivisa in frame di pagina di lunghezza fissa (a volte chiamati pagine fisiche). Ogni frame contiene una pagina, per cui le loro dimensioni coincidono. Un frame è una parte della memoria, quindi un’area di memorizzazione. E’ importante distinguere la pagina dal frame di pagina: la prima è un blocco di dati che può essere memorizzato in un frame di pagina o su disco. Le strutture che mappano gli indirizzi lineari in indirizzi fisici sono dette tabelle di pagina (page tables); si trovano nella memoria principale e devono essere inizializzate dal kernel prima che venga abilitata l'unità di paginazione. A partire dal 386, tutti i processori 80x86 supportano la paginazione; essa viene abilitata attivando il flag PG del registro di controllo cr0. Quando PG = 0 gli indirizzi lineari sono interpretati come indirizzi fisici.
Paginazione regolare
8
A partire dal 386, l’unità di paginazione dei processori Intel utilizza pagine di 4 KB. I 32 bit di un indirizzo lineare sono divisi in tre campi: Directory, i 10 bit più significativi Table, i 10 intermedi Offset, i 12 meno significativi. La traduzione degli indirizzi lineari è realizzata in due fasi, ognuna basata su una tabella di traduzione. La prima è chiamata Page Directory (PD), e la seconda Page Table (PT)1. Obiettivo di questo schema a tre livelli è quello di ridurre la richiesta di RAM per la PT di ogni processo. Se fosse usato un unico livello di tabelle, occorrerebbero fino a 2 20 entry (e con entry di 4 byte, 4 MB di RAM) per rappresentare la PT di ogni processo, se ognuno usasse uno spazio di indirizzi di 4 GB, anche se non tutti gli indirizzi nell’intervallo vengono usati. Lo schema a due livelli riduce l’impegno di memoria richiedendo la PT solo per le regioni di memoria attualmente in uso. Ogni processo in attività deve avere una PD, ma non è necessario allocare subito la RAM per tutte le PT, è più efficiente allocare RAM per una PT solo quando il processo la richiede. L’indirizzo fisico della PD è memorizzato nel registro di controllo cr3. Il campo Directory dell’indirizzo lineare indica l’entry nella PD che punta alla PT appropriata. Il campo Table indica l’entry nella PT che contiene l’indirizzo fisico del frame di pagina. Il campo Offset determina la posizione relativa entro il frame di pagina. Poiché è lungo 12 bit, ogni pagina ha la dimensione di 4096 byte. I campi Directory e Table sono entrambi di 10 bit, quindi PD e PT contengono fino a 1024 entry. Una PD può indirizzare 1024 x 1024 x 4096 = 232 celle di memoria, come ci si può aspettare da indirizzi a 32 bit. Le entry delle PD e PT hanno la stessa struttura e sono formate dai seguenti campi: Flag Present: se è attivato, la pagina è contenuta nella memoria principale; se è 0, la pagina non è in memoria e i rimanenti bit della entry possono essere usati dal sistema operativo per i propri scopi. Se la entry della PD o della PT richiesta per la traduzione di un indirizzo ha il flag Present azzerato, l’unità di paginazione memorizza l’indirizzo nel registro cr2 e genera l’eccezione 14: Page Fault. Campo contenente i 20 bit più significativi dell’indirizzo fisico di un frame di pagina: poiché ogni frame di pagina può contenere 4 KB, il suo indirizzo fisico deve essere un multiplo di 4096, per cui i 12 bit meno significativi dell’indirizzo sono uguali a 0. Se il campo si riferisce a una PD, il frame contiene una PT; se si riferisce a una PT, il frame contiene una pagina di dati. Flag Accessed: è attivato ogni volta che l’unità di paginazione indirizza il frame di pagina corrispondente. Questo flag può essere usato dal sistema operativo per lo swapping delle pagine. L’unità di paginazione non resetta mai questo flag; lo deve fare il sistema operativo. Flag Dirty: si applica solo alle entry della PT. Viene attivato ogni volta che è compiuta una operazione di scrittura sul frame di pagina. Come per il flag Accessed, può essere usato dal sistema operativo per lo swapping delle pagine. L’unità di paginazione non resetta mai questo flag; lo deve fare il sistema operativo. Flag Read/Write: contiene i diritti di accesso (lettura/scrittura o lettura) della pagina o della PT. 1 Il termine page table minuscolo identifica ogni pagina che contiene la mappatura di indirizzi lineari in fisici, mentre il termine Page Table in maiuscolo indica la pagina all’ultimo livello delle tabelle di pagina.
9
Flag User/Supervisor: contiene il livello di privilegio richiesto per accedere alla pagina o alla PT. Flag PCD e PWT: controlla il modo in cui la pagina o la PT è gestita dalla cache hardware. Flag Page Size: si applica solo alle entry della PD. Se è attivato, l’entry si riferisce a frame di pagina di 2 o 4 MB. Flag Global: si applica solo alle entry di PT. Questo flag è stato introdotto nel Pentium Pro per evitare che pagine usate di frequente vengano eliminate dalla cache TLB (Translation Lookaside Buffer). E’ attivo solo se è settato il flag PGE (Page Global Enable) nel registro cr4
Paginazione estesa A partire dal Pentium è stata introdotta la paginazione estesa che consente di avere pagine di 4 MB invece che 4 KB. La paginazione estesa è usata per tradurre ampi intervalli di indirizzi lineari; in questi casi il kernel può eseguire l’operazione senza l’intervento di PT, risparmiando così memoria e preservando le entry di TLB. La paginazione estesa è abilitata attivando il flag Page Size in una entry di PD. In questo caso l’unità di paginazione divide i 32 bit di un indirizzo lineare in due campi: Directory: i 10 bit più significativi Offset: i restanti 22 bit. Le entry della PD non cambiano rispetto alla paginazione normale eccetto che: -
Il flag Page Size è settato
-
Solo i 10 bit più significativi dei 20 dell’indirizzo fisico hanno un significato. Questo perché ogni indirizzo fisico è allineato a 4 MB, per cui i 22 bit meno significativi sono azzerati.
La paginazione estesa coesiste con quella regolare e viene abilitata settando il flag PSE del registro cr4.
Sistema di protezione hardware L’unità di paginazione usa un sistema di protezione diverso dall’unità di segmentazione. Mentre i processori 80x86 ammettono 4 livelli di privilegio per un segmento, solo 2 sono associati alle pagine e alle PT, dato che i privilegi sono controllati dal flag User/Supervisor. Quando il flag è azzerato, la pagina può essere indirizzata solo se il CPL è inferiore a 3 (cioè il processore è in modalità del kernel). Quando il flag è impostato a 1, la pagina può sempre essere indirizzata. In più, invece dei tre diritti di accesso (lettura, scrittura ed esecuzione) associati ai segmenti, solo due (lettura e scrittura) sono associati alle pagine. Se il flag Read/Write di una PD o PT è impostato a 0, la PT o la pagina corrispondente possono essere solo lette; altrimenti la pagina può essere letta e scritta 2.
Un esempio di paginazione regolare 2 Il Pentium 4 ha un flag NX (No eXecute) in ogni entry di PT a 64 bit (la paginazione estesa deve essere abilitata. Linux 2.6.11 supporta questa caratteristica hardware).
10
Il kernel assegna ad un processo in esecuzione l’intervallo di indirizzi tra 0x20000000 e 0x2003ffff. Questo spazio comprende 64 pagine. Non interessa l’indirizzo fisico dei frame di pagina che contengono le pagine; alcune di esse possono non essere ancora in memoria. Interessano solo i restanti campi delle entry della PT. I 10 bit più significativi sono interpretati dall’unità di paginazione come campi Directory. L’indirizzo inizia con un 2 seguito da zeri, per cui i 10 bit hanno tutti lo stesso valore 0x80 (128 decimale). Il campo Directory in tutti gli indirizzi punta alla 129° entry della PD del processo. Essa contiene l’indirizzo fisico della PT. Se al processo non sono assegnati altri indirizzi, tutte le restanti 1023 entry della PD sono riempite con 0. I valori assunti dai 10 bit intermedi (campo Table) vanno da 0 a 0x03f, cioè 63 decimale. Quindi solo le prime 64 entry della PT sono valide; le restanti 960 sono riempite con 0. Se il processo richiede di leggere l’indirizzo lineare 0x20021406: -
Il campo Directory (0X080) viene usato per selezionare la entry 0x080 nella PD, che punta a PT;
-
Il campo Table (0x21) viene usato per selezionare la entry numero 0x21 nella PT che punta al frame di pagina;
-
Il campo Offset (0x406) viene usato per selezionare il byte 0x406 nel frame di pagina.
Se il flag Present della 0x21esima entry della PT è azzerato, la pagina non è presente in memoria; in questo caso l’unità di paginazione origina l’eccezione Page Fault. La stessa eccezione viene generata se il processo tenta di accedere a un indirizzo al di fuori dell’intervallo 0x20000000 0x2003ffff, poiché le corrispondenti entry della PT sono poste a 0 e il flag Present è azzerato.
Estensione degli indirizzi fisici (Physical Address Extension – PAE) La quantità di memoria di un processore è limitata dal numero di pin di indirizzo connessi al bus di memoria. I vecchi processori Intel, a partire dal 386, usano indirizzi fisici a 32 bit. In teoria su questi sistemi si possono installare fino a 4 GB di memoria; in pratica, a causa delle richieste di spazio di indirizzamento dei processi in modalità utente, il kernel può indirizzare direttamente solo 1 GB di RAM. I server che gestiscono migliaia di processi contemporaneamente richiedono anche più di 4 GB di memoria, e la spinta all’aumento della RAM è continua. Intel ha soddisfatto questa richiesta aumentando il numero di pin di indirizzo nei processori da 32 a 36. A partire dal Pentium Pro ora i processori possono indirizzare fino a 236 = 64 GB di RAM. Questo intervallo di indirizzi però può essere sfruttato solo introducendo un nuovo meccanismo di paginazione che traduca gli indirizzi lineari a 32 bit in indirizzi fisici a 36 bit. Con il Pentium Pro, Intel ha introdotto la Physical Address Extension (PAE). Un altro sistema, la Page Size Extension (PSE-36) venne introdotta col Pentium III, ma Linux non lo usa. PAE viene attivata impostando a 1 il flag PAE nel registro di controllo cr4. Il flag Page Size (PS) nella entry della PD abilita il formato di pagina a 2 MB (quando PAE è attiva). Per supportare questo sistema Intel ha cambiato il meccanismo di paginazione. -
I 64 GB di RAM sono divisi in 2 24 frame di pagina e il campo indirizzo fisico della PT è stato ampliato da 20 a 24 bit. Poiché una entry di PT in PAE deve includere 12 bit di flag e 24 bit di indirizzo fisico per un totale di 36 bit, la sua dimensione è stata portata da 32 a 64 bit. Di conseguenza una PT di 4 KB contiene 512 entry invece di 1024.
11
-
E’ stato introdotto un nuovo livello di tabelle di pagina chiamato Page Directory Pointer Table (PDPT) che comprende 4 entry di 64 bit.
-
Il registro di controllo cr3 contiene un indirizzo base a 27 bit della PDPT. Poiché le PDPT sono contenute nei primi 4 GB di RAM e sono allineate a un multiplo di 32 byte (2 5), 27 bit sono sufficienti.
-
Quando vengono mappati gli indirizzi lineari a pagine di 4 KB (il flag PS nella PD è azzerato), i 32 bit di un indirizzo lineare sono interpretati in questo modo: cr3 punta alla PDPT i bit 31 – 30 puntano a una delle 4 entry della PDPT i bit 29 – 21 puntano a una delle 512 entry della PD i bit 20 – 12 puntano a una delle 512 entry della PT i bit 11 – 0 rappresentano l’offset della pagina di 4 KB
-
Quando vengono mappati gli indirizzi lineari a pagine di 2 MB (il flag PS nella PD è settato a 1), i 32 bit dell’indirizzo lineare sono interpretati in questo modo: cr3 punta alla PDPT bit 31 – 30 puntano a una delle 4 entry della PDPT i bit 29 – 21 puntano a una delle 512 entry della PD i bit 20 – 0 rappresentano l’offset della pagina di 2 MB
Per riassumere, una volta che cr3 è settato, è possibile indirizzare fino a 4 GB di RAM. Se si vuole indirizzare più RAM, si deve inserire un nuovo valore in cr3 o cambiare il contenuto della PDPT. Il problema principale è che gli indirizzi lineari sono ancora di 32 bit. Questo costringe i programmatori del kernel a riutilizzare gli stessi indirizzi lineari per mappare diverse aree di RAM. Chiaramente PAE non amplia lo spazio di indirizzi di un processo perché riguarda solo gli indirizzi fisici. Inoltre solo il kernel può variare le tabelle di pagina per cui un processo in modalità utente non può usare più di 4 GB di indirizzi. D’altra parte PAE permette al kernel di gestire fino a 64 GB di RAM e quindi di incrementare significativamente il numero di processi del sistema.
Paginazione nell’architettura a 64 bit La paginazione a due livelli, comunemente usata dai sistemi a 32 bit, non è sufficiente per quelli a 64 bit, come spiegato di seguito. La dimensione di pagina è 4 KB. Poiché 1 KB copre un intervallo di 2 10 indirizzi, 4 KB copre 212 indirizzi, per cui il campo Offset è di 12 bit. Restano 52 bit da dividere trai campi Table e Directory. Se si usano soltanto 48 dei 64 bit (con uno spazio di indirizzamento di 256 TB), restano 48 – 12 = 36 bit da dividere tra Table e Directory. Se vengono divisi in due campi di 18 bit ciascuno, sia la PD che la PT dovrebbero contenere 218 (ovvero 256.000) entry ciascuna. Per questo motivo i sistemi di paginazione a 64 bit usano livelli addizionali. Il loro numero dipende dal tipo di processore. In tabella sono elencate le caratteristiche di alcune piattaforme supportate da Linux. piattaforma
dimensione di pagina
bit di indirizzo 12
livelli di paginazione
divisione dell’indirizzo
alpha ia64 ppc64 sh64 x86_64
8 KB 4 KB 4 KB 4 KB 4 KB
43 39 41 41 48
3 3 3 3 4
10 + 10 + 10 + 13 9 + 9 + 9 + 12 10 + 10 + 9 + 12 10 + 10 + 9 + 12 9 + 9 + 9 + 12
Linux adotta un sistema di paginazione comune che soddisfa i sistemi hardware supportati.
Cache hardware Gli attuali processori hanno frequenze di clock dell’ordine dei gigahertz, mentre le RAM dinamiche (DRAM) hanno tempi di accesso dell’ordine delle centinaia di cicli di clock. Ciò significa che la CPU viene molto rallentata quando esegue istruzioni che comportano letture di operandi o salvataggi di dati in memoria. Le memorie cache sono state introdotte per ridurre la differenza tra le velocità di CPU e RAM. Si basano sul noto principio di località, che riguarda sia i programmi che le strutture dati. A causa della struttura ciclica dei programmi e dell’impaccamento dei dati correlati entro gli array lineari, indirizzi vicini a quelli usati di recente hanno una elevata probabilità di essere richiesti a breve. Ha senso perciò introdurre una piccola ma veloce unità di memoria che contiene codice e dati usati di recente. Per questo fine è stata introdotta una nuova unità chiamata linea. La linea è formata da poche dozzine di byte contigui trasferiti in blocco dalla lenta DRAM alla veloce RAM statica (SRAM) posta sul chip del processore che implementa la cache. La cache è divisa in un sottoinsieme di linee. A un estremo, la cache può essere a mappatura diretta se una linea della memoria principale è sempre memorizzata nella stessa locazione della cache. All'altro estremo può essere pienamente associativa se ogni linea della memoria può essere memorizzata in ogni locazione della cache. La maggior parte è associativa di grado N se ogni linea di memoria può essere memorizzata in una di N linee di cache. La cache è inserita fra l'unità di paginazione e la memoria principale. Comprende una memoria cache hardware e un controller. La cache contiene le linee di memoria; il controller contiene un array di entry, una per ogni linea di cache. Ogni entry include un tag e alcuni flag che descrivono lo stato della linea di cache. Il tag consiste di alcuni bit che permettono al controller di riconoscere la locazione di memoria attualmente mappata nella linea. I bit dell'indirizzo fisico sono divisi in tre gruppi: i più significativi corrispondono al tag, quelli di mezzo all'indice del subset del controller e i meno significativi all'offset entro la linea. Quando accede ad una cella di memoria della RAM, la CPU estrae l'indice del subset dall'indirizzo fisico e confronta il tag di tutte le linee nel subset con i bit di ordine maggiore dell'indirizzo. Se la CPU trova una linea con il tag che corrisponde ai bit di ordine maggiore dell'indirizzo, si ha una corrispondenza (cache hit), altrimenti una cache miss. Quando si ha una cache hit, il controller si comporta in modo diverso a seconda del tipo di accesso. Per una operazione di lettura, il controller seleziona i dati dalla linea e li trasferisce a un registro della CPU; la memoria non viene interrogata e la CPU risparmia tempo, che è poi lo scopo per cui la cache è stata inventata. Per una operazione di scrittura, il controller può scegliere tra due strategie: write-through e write-back. Nella prima il controller scrive sempre sia sulla RAM che sulla linea di cache. Nella seconda, che comporta maggior efficienza immediata, solo la linea di cache viene aggiornata, mentre la RAM rimane invariata. Dopo una operazione write-back, naturalmente anche la RAM viene aggiornata. Il controller scrive nella RAM solo quando la CPU esegue una istruzione che richiede un flush della cache oppure quando riceve un segnale di FLUSH hardware (di solito dopo una cache miss).
13
Quando si verifica una cache miss, la linea di cache viene scritta in memoria, se necessario, e la linea corretta viene caricata dalla RAM nella cache. I sistemi multiprocessore hanno una cache hardware separata per ogni processore e necessitano di circuiti hardware addizionali per sincronizzare i contenuti. L'aggiornamento richiede più tempo: quando una CPU modifica la sua cache deve controllare se gli stessi dati sono contenuti in altre cache; se così, deve notificare alle altre CPU di aggiornare i propri valori. Questo processo è detto cache snooping. Fortunatamente questo avviene a livello hardware e non interessa il kernel. La tecnologia della cache è in rapida evoluzione. Il primo Pentium conteneva una singola cache on-chip chiamata L1. Modelli più recenti includono cache on-chip più grandi e più lente dette L2, L3, ecc. La consistenza fra i vari livelli è implementata a livello hardware. Linux ne ignora i dettagli e considera solo l'esistenza di una unica cache. Il flag CD nel registro cr0 abilita o disabilita il circuito della cache. Il flag NW nello stesso registro specifica se adottare la strategia write-through oppure write-back. Un'altra caratteristica della cache del Pentium è che permette al sistema operativo di associare una diversa politica di gestione della cache per ogni frame di pagina. A questo scopo ogni entry di PD e PT include due flag: PCD (Page Cache Disable) che abilita/disabilita la cache e PWT(Page Write-Through) che specifica la strategia da adottare. Linux azzera PCD e PWT in tutte le entry di PD e PT; di conseguenza la cache è sempre abilitata per tutti i frame di pagina e viene adottata la strategia write-back per le operazioni di scrittura.
Translation Lookaside Buffers (TLB) Oltre alla cache di uso generale, i processori 80x86 includono anche una cache chiamata TLB per velocizzare la traduzione degli indirizzi lineari. Quando uno di questi viene usato per la prima volta, il suo corrispondente fisico è determinato con un accesso lento alla PT in RAM. Viene però memorizzato in una entry di TLB, in modo da avere una traduzione veloce in un futuro accesso. Nei sistemi multiprocessore ogni CPU ha una TLB locale. Le TLB non richiedono sincronizzazione tra le CPU, dato che diversi processi in differenti CPU possono associare lo stesso indirizzo lineare a diversi indirizzi fisici. Quando il registro cr3 viene modificato, l'hardware annulla tutte le entry delle TLB locali, dato che viene ora usato un nuovo set di tabelle di pagina e le TLB puntano a dati ormai vecchi.
14
PAGINAZIONE IN LINUX Linux adotta un modello di paginazione che vale sia per le architetture a 32 che a 64 bit; queste ultime infatti richiedono un maggior numero di livelli di paginazione rispetto ai 32 bit. Dalla versione 2.6.10 il modello di Linux prevede 3 livelli di paginazione, mentre dalla 2.6.11 è stato adottato un modello a 4 livelli così denominati: •
Page Global Directory (PGD)
•
Page Upper Directory (PUD)
•
Page Middle Directory (PMD)
•
Page Table (PT).
La PGD include gli indirizzi di varie PUD, ognuna delle quali punta a diverse PMD; ognuna di queste ultime contiene l'indirizzo di varie PT che puntano ai frame di pagina. Perciò l'indirizzo lineare viene diviso in vari campi, fino a 5; la loro dimensione dipende dall'architettura del computer. Per sistemi a 32 bit senza PAE, due livelli sono sufficienti, per cui Linux elimina i campi PUD e PMD assegnando loro una dimensione di 0 bit. Mantiene comunque la posizione delle relative tabelle nella sequenza di puntatori, in modo che lo stesso codice possa valere sia per i 32 che per i 64 bit; lo fa semplicemente assegnando a PUD e PMD 1 sola entry che mappa la corrispondente voce della PGD. Per sistemi a 32 bit con PAE abilitata, vengono usati 3 livelli; PGD corrisponde alla PDPT descritta in precedenza, la PUD viene eliminata, la PMD corrisponde alla PD, e la PT corrisponde a sé stessa. Per le architetture a 64 bit vengono usati 3 o 4 livelli a seconda dell'hardware usato. La gestione dei processi in Linux si basa molto sulla paginazione. Infatti essa consente: –
di assegnare un diverso spazio di indirizzi fisici ad ogni processo, assicurando una efficace protezione contro gli errori di indirizzamento;
–
di distinguere tra pagine (di dati) e frame di pagina (nella memoria fisica). Ciò permette di memorizzare la stessa pagina in un frame in memoria, salvarla su disco e poi caricarla in un frame differente. Questi sono gli ingredienti base del sistema di memoria virtuale.
Nella spiegazione successiva, si farà riferimento all'hardware del 80x86. Quando avviene una commutazione di processo, Linux salva il registro di controllo cr3 nel descrittore del processo precedentemente in esecuzione, poi carica in cr3 il valore memorizzato nel descrittore del processo che deve essere eseguito; per cui quando quest'ultimo viene avviato dalla CPU, la unità di paginazione trova il corretto set di tabella di pagina. La mappatura degli indirizzi è un procedimento meccanico, anche se complesso, e si basa su varie macro e funzioni che forniscono al kernel le informazioni di cui ha bisogno.
Campi degli indirizzi lineari Le macro seguenti facilitano la gestione delle tabelle: •
PAGE_SHIFT: lunghezza in bit del campo Offset. Restituisce il valore 12 nei sistemi 80x86. Rappresenta il logaritmo in base 2 della dimensione della Pagina (212 = 4 KB). Viene usata da 15
PAGE_SIZE per restituire la dimensione della pagina. PAGE_MASK dà il valore 0xfffff000 usato per mascherare i bit dell'Offset. •
PMD_SHIFT: lunghezza in bit della somma dei campi Offset e Table; in altre parole è il logaritmo della dimensione dell'area mappata da una entry di PMD. Questa dimensione viene fornita dalla macro PMD_SIZE. La PMD_MASK è usata per mascherare i due campi nell'indirizzo lineare. Con PAE disabilitata PMD_SHIFT vale 22 (12 Offset + 10 Table), PMD_SIZE vale 2 22 = 4MB e PMD_MASK vale 0xffc00000. Con PAE abilitata i valori sono rispettivamente: 21 (12 Offset + 9 Table), 2 21 = 2 MB, 0xffe00000.
•
PUD_SHIFT: logaritmo della dimensione dell'area mappata da una entry della PUD. PUD_SIZE fornisce l'ampiezza dell'area mappata da una entry della PUD. PUD_MASK maschera i bit dei campi Offset, Table, Middle Air. Nei processori 80x86 PUD_SHIFT = PMD_SHIFT e PUD_SIZE = 4 MB oppure 2 MB.
•
PGDIR_SHIFT: logaritmo della dimensione dell'area che può mappare una entry della PGD. PGDIR_SIZE fornisce il valore di questa dimensione. PGDIR_MASK maschera i bit dei campi Offset, Table, Middle Air e Upper Air. Con PAE disabilitata, PGDIR_SHIFT vale 22, PGDIR_SIZE vale 2 22 = 4 MB e PGDIR_MASK vale 0xffc00000. Quando PAE è abilitata, i valori sono rispettivamente 30 (12 Offset + 9 Table + 9 Middle Air), 230 = 1 GB e 0xc0000000.
•
PTRS_PER_PTE, PTRS_PER_PMD, PTRS_PER_PUD, PTRS_PER_PGD: calcolano il numero di entry per le tabelle. Con PAE disabilitato valgono rispettivamente: 1024, 1, 1, 1024; con PAE abilitato: 512, 512, 1, 4.
Aspetto della memoria fisica Durante la fase di inizializzazione il kernel deve costruire una mappa della memoria fisica che indichi quale intervallo di indirizzi il kernel può usare e quali no (o perché mappano memoria condivisa di I/O per dispositivi hardware o perché contengono dati del BIOS). Il kernel considera riservati i frame di pagina: •
che ricadono nell'intervallo non disponibile
•
che contengono codice o strutture dati inizializzate del kernel.
Una pagina contenuta in un frame riservato non può essere assegnata dinamicamente o soggetta a swapping su disco. Come regola generale, il kernel viene caricato in RAM a partire dall'indirizzo fisico 0x0010000, cioè dal secondo MB. L'occupazione di memoria dipende da come è stato configurato: tipicamente occupa meno di 3 MB. Il motivo di questa collocazione risiede nelle particolarità dell'architettura PC: •
il frame di pagina 0 è usato dal BIOS per memorizzare la configurazione hardware del sistema rilevata durante il Power-On Self-Test (POST). In alcuni laptop il BIOS scrive dati in questa zona anche dopo l'inizializzazione.
•
l'intervallo tra 0x000a0000 e 0x000fffff è riservato alle routine del BIOS e per la mappatura della memoria interna delle schede grafiche ISA. E' noto come il “buco” tra 640 KB e 1 MB e non è disponibile per il kernel.
16
•
altri frame entro il primo MB possono essere riservati da specifici modelli di computer. Ad esempio Think-pad mappa il frame 0xa0 nel 0x9f.
All'inizio della fase di boot, il kernel interroga il BIOS e ottiene la dimensione della memoria fisica. In modelli recenti invoca anche una procedura del BIOS per costruire una lista di indirizzi fisici e dei corrispondenti tipi di memoria. In seguito esegue la funzione machine_specific_memory_setup(), che costruisce la mappa degli indirizzi fisici sulla base della lista del BIOS, se disponibile; altrimenti segue un modello standard prudenziale: tutti i frame con numeri da 0x9f (LOWMEMSIZE()) a 0x100 (HIGH_MEMORY) sono marcati come riservati. Esempio di mappa degli indirizzi fisici in un sistema con 128 MB di RAM inizio
fine
tipo
0x00000000
0x0009ffff
disponibile
0x000f0000
0x000fffff
riservato
0x00100000
0x07feffff
disponibile
0x07ff0000
0x07ff2fff
dati ACPI
0x07ff3000
0x07ffffff
NVS ACPI
0xffff0000
0xffffffff
riservato
L'intervallo tra 0x07ff0000 e 0x07ff2fff contiene informazioni sui componenti hardware scritte dal BIOS nella fase POST; il kernel poi copia queste informazioni in una propria struttura dati e considera il frame usabile. L'intervallo 0x07ff3000 – 0x07ffffff è riservato alla mappatura dei chip ROM dei dispositivi hardware. L'intervallo che inizia da 0xffff0000 è riservato al chip ROM del BIOS. Da notare che il BIOS può non fornire indicazioni su alcuni intervalli (come 0x000a0000 – 0x000effff); per sicurezza, Linux li considera non utilizzabili. Il kernel può non vedere tutta la memoria riportata dal BIOS; ad esempio, se non è compilato con in supporto a PAE, può indirizzare solo 4 GB, anche se la memoria fisica è maggiore. La funzione setup_memory() viene chiamata subito dopo machine_specific_memory_setup(); analizza la tabella delle regioni di memoria e inizializza alcune variabili che descrivono lo stato della memoria fisica:
Descrizione
Variabile num_physpages
il più alto numero di frame di pagina utilizzabile
totalram_pages
numero totale di frame utlizzabili
min_low_pfn
numero del primo frame utilizzabile dopo l'immagine del kernel
max_pfn
numero dell'ultimo frame utilizzabile
max_low_pfn
numero dell'ultimo frame mappato direttamente dal kernel (low memory)
totalhigh_pages
numero totale di frame non mappati direttamente dal kernel (high memory)
highstart_pfn
numero del primo frame non mappato direttamente dal kernel
highend_pfn
numero dell'ultimo frame non mappato direttamente dal kernel
17
Per evitare di caricare il kernel in pagine non contigue, Linux preferisce evitare il primo MB; chiaramente le pagine non riservate dall'architettura PC saranno usate per memorizzare pagine assegnate dinamicamente. La figura mostra come sono utilizzati i primi 3 MB (768 frame di pagina) 0
1 non disp.
0x9f disponibile
0x100
non disp.
0x2ff
disponibile
codice kernel
_text
Initializedkernel data _etext
uninitializeddisponibile kernel data _edata
_end
Il simbolo _text che corrisponde all'indirizzo 0x00100000, identifica il primo byte del kernel; il simbolo _etext identifica l'ultimo byte. I dati del kernel sono divisi in due gruppi: inizializzati, che vanno da _etext a _edata, e non inizializzati che terminano a _end. Questi simboli non sono definiti nel codice sorgente di Linux, ma sono prodotti durante la compilazione (i loro indirizzi sono presenti nel file System.map).
Tabelle di pagina dei processi Lo spazio degli indirizzi di un processo è diviso in due parti: •
da 0x00000000 a 0xbfffffff può essere indirizzato sia in modalità del kernel che utente
•
da 0xc0000000 a 0xffffffff può essere indirizzato solo in modalità del kernel
Un processo in modalità utente opera con indirizzi inferiori a 0xc0000000; in modalità del kernel opera su indirizzi superiori a 0xc0000000; in qualche caso, comunque, il kernel deve avere accesso allo spazio di indirizzi della modalità utente per acquisire o memorizzare dati. La macro PAGE_OFFSET restituisce il valore 0xc0000000. Il contenuto delle prime entry della PGD che mappa gli indirizzi inferiori a 0xc0000000 (le prime 768 entry con PAE disabilitato o le prime tre con PAE abilitato) dipende dal processo. Le altre entry sono comuni a tutti i processi e sono uguali alle corrispondenti entry della PGD principale del kernel.
Tabelle di pagina del kernel Il kernel mantiene un insieme di tabelle di pagina per il proprio uso basate sulla master kernel Page Global Directory (MKPGD). Dopo l'inizializzazione del sistema questo set di pagine non viene adoperato da nessun processo o thread del kernel; piuttosto, le entry finali della MKPGD sono il modello di quelle corrispondenti della PGD dei processi regolari. L'inizializzazione delle tabelle di pagina del kernel è un procedimento a due fasi. Subito prima del caricamento in memoria dell'immagine del kernel, la CPU è ancora in modalità reale, e la paginazione non è attivata. Nella prima fase, il kernel crea un limitato spazio di indirizzi che comprende i propri segmenti codice e dati, la PT iniziale e 128 KB per alcune strutture dinamiche. Questo spazio minimale è sufficiente per caricare in RAM il kernel e inizializzare le sue strutture principali. Nella seconda fase il kernel sfrutta tutta la memoria disponibile e inizializza le tabelle di pagina.
18
Tabelle di Pagina provvisorie del kernel Una PGD provvisoria è inizializzata staticamente durante la compilazione del kernel, mentre le PT provvisorie sono inizializzate dalla funzione assembly startup_32(), definita in arch/i386/kernel/head.S. Non verranno più menzionate le PUD e le PMD, in quanto sono equiparate a entry della PGD, dato che il supporto a PAE non è ancora attivo in questo stadio. La PGD provvisoria è contenuta nella variabile swapper_pg_dir. Le PT provvisorie sono memorizzate a partire da pg0, subito dopo il valore _end. Per semplificare, si può ipotizzare che tutto lo spazio iniziale di indirizzamento del kernel cada nei primi 8 MB di RAM, per cui per indirizzare 8 MB occorrono due PT. L'obiettivo in questa prima fase è indirizzare facilmente gli 8 MB sia in modalità reale che protetta. Perciò il kernel deve mappare i due intervalli tra 0x00000000 e 0x007fffff e tra 0xc0000000 e 0xc07fffff negli indirizzi fisici tra 0x00000000 e 0x007fffff. In altre parole il kernel può indirizzare i primi 8 MB o con indirizzi lineari identici a quelli fisici o con 8 MB di indirizzi lineari a partire da 0xc0000000. Tutte le entry della swapper_page_dir sono riempite con zeri, tranne la 0, 1, 0x300 (768 decimale) e 0x301 (769): queste vengono inizializzate in questo modo: •
nel campo indirizzo delle entry 0 e 0x300 viene inserito l'indirizzo fisico di pg0, in quello delle entry 1 e 0x301, l'indirizzo fisico del frame successivo a pg0
•
i flag Present, Read/Write e User/Supervisor sono settati in tutte le 4 entry
•
i flag Accessed, Dirty, PCD, PWD, Page Size sono azzerati in tutte le 4 entry
La funzione startup_32() abilita anche l'unità di paginazione, caricando l'indirizzo di swapper_pg_dir nel registro cr3 e settando il flag PG nel registro cr0, come mostrato nel frammento di codice equivalente: movl $swapper_pg_dir-0xc0000000, %eax movl $eax, %cr3 movl %cr0, %eax orl $0x80000000, %eax movl %eax, %cr0 Tabella definitiva delle pagine del kernel quando la RAM è meno di 896 MB La mappatura finale deve trasformare gli indirizzi lineari a partire da 0xc0000000 in indirizzi fisici a partire da 0. La macro __pa converte un indirizzo lineare che parte da PAGE_OFFSET nell'indirizzo fisico corrispondente, mentre la macro __va opera la conversione inversa. La PGD è ancora memorizzata in swapper_pg_dir. Viene inizializzata dalla funzione paging_init() che esegue le azioni seguenti: 1 – chiama pagetable_init() per creare le entry della PT 2 – scrive l'indirizzo fisico di swapper_pg_dir nel registro cr3 3 – se il kernel è compilato con il supporto a PAE, setta il flag PAE nel registro cr4 4 – chiama __flush_tlb_all() per invalidare tutte le voci di TLB. 19
Le azioni compiute da pagetable_init() dipendono dalla quantità di RAM e dal modello di CPU. Nel caso più semplice, il computer ha meno di 896 MB di RAM (gli ultimi 128 MB di indirizzi lineari sono riservati a particolari tipi di mappatura come “Fix mapped linear addresses”; al kernel restano perciò 1 GB – 128 MB = 896 MB), gli indirizzi a 32 bit sono sufficienti a indirizzare tutta la RAM e non c'è bisogno di PAE. La PGD della swapper_pg_dir viene reinizializzata per mezzo di un ciclo simile al seguente: pgd = swapper_pg_dir + pgd_index(PAGE_OFFSET); /* 768 */ phys_addr = 0x00000000; while (phys_addr < (max_low_pfn * PAGE_SIZE)) { pmd = one_md_table_init(pgd); /* returns pgd itself */ set_pmd(pmd, __pmd(phys_addr | pgprot_val(__pgprot(0x1e3)))); /* 0x1e3 == Present, Accessed, Dirty, Read/Write, Page Size, Global */ phys_addr += PTRS_PER_PTE * PAGE_SIZE; /* 0x40000000 */ ++pgd; } Il flag User/Supervisor è azzerato, quindi i processi in modalità utente non possono accedere allo spazio del kernel; il flag Page Size è settato, quindi il kernel può usare pagine di 4 MB. La mappatura dei primi 8 MB è richiesta nella fase di inizializzazione: quando non è più necessaria, il kernel azzera le tabelle di pagina chiamando la funzione zap_low_mappings(). Questa descrizione non esaurisce tutte le operazioni; in realtà il kernel imposta anche le entry della PT che corrispondono a gli indirizzi lineari a mappatura fissa (fix-mapped linear addresses).
Tabella definitiva delle pagine del kernel quando la RAM è tra 896 MB e 4 GB In questo caso la RAM non può essere interamente mappata nello spazio degli indirizzi lineari del kernel. Linux nella fase di inizializzazione mappa perciò solo una finestra di 896 MB. Se un programma richiede altre parti della RAM, altri intervalli di indirizzi lineari devono essere mappati nella RAM richiesta. Ciò significa cambiare le entry di alcune pagine (rimappatura dinamica). Per inizializzare la PGD il kernel usa lo stesso codice del caso precedente.
Tabella definitiva delle pagine del kernel quando la RAM è superiore a 4 GB In questo caso si verificano queste condizioni: •
la CPU supporta la PAE
•
la RAM supera i 4 GB
•
il kernel è compilato con il supporto a PAE.
Anche se la PAE usa indirizzi fisici a 36 bit, gli indirizzi lineari sono ancora a 32 bit. Come nel caso precedente, Linux mappa una finestra di 896 MB; il resto della RAM rimane non mappato e viene gestito con la rimappatura dinamica. La differenza è che viene usato un modello a tre livelli di pagine e la PGD è inizializzata con un ciclo differente. Il kernel inizializza le prime tre entry della PGD con l'indirizzo di una pagina vuota (empty_zero_page).La quarta è inizializzata con l'indirizzo della PMD (pmd) allocata chiamando la funzione 20
alloc_bootmem_low_pages(). Le prime 448 entry nella PMD (64 delle 512 sono riservate alla “allocazione di memoria non-contigua”) sono riempite con gli indirizzi fisici dei primi 896 MB di RAM. Tutte le CPU che supportano PAE supportano anche le pagine di 2 MB; come prima, quando è possibile, Linux le usa per ridurre il numero delle Tabelle di Pagina. La quarta entry della PGD viene poi copiata nella prima, per copiare la mappatura della memoria fisica inferiore nei primi 896 MB di spazio degli indirizzi lineari. Questa azione è richiesta per completare l'inizializzazione dei sistemi SMP; quando non è più necessaria, il kernel chiama zap_low_mappings() per ripulire le entry delle tabelle.
Indirizzi lineari a mappatura fissa La parte iniziale del quarto gigabyte dello spazio di indirizzi lineari del kernel mappa la memoria fisica del sistema. Però almeno 128 MB sono disponibili per implementare l'allocazione della memoria non-contigua e gli indirizzi lineari a mappatura fissa. Un indirizzo lineare a mappatura fissa (FMLA) è un indirizzo lineare costante come 0xffffc000, il cui corrispondente indirizzo fisico non deve essere l'indirizzo lineare meno 0xc0000000, ma piuttosto un indirizzo fisico definito in modo arbitrario. Perciò ogni FMLA mappa un frame di pagina di memoria fisica. Il kernel li usa al posto di variabili puntatore che non cambiano il loro valore. FMLA sono concettualmente simili agli indirizzi lineari che mappano i primi 896 MB di RAM. Comunque un FMLA può mappare un qualunque indirizzo fisico, mentre la mappatura dei primi 896 MB è lineare. Rispetto ai puntatori, gli FMLA sono più efficienti. Infatti dereferenziare un puntatore richiede un accesso di memoria in più che dereferenziare un indirizzo costante immediato. In più, controllare il valore di una variabile prima di dereferenziare è una buona pratica di programmazione, che non è richiesta per gli indirizzi. Ogni FMLA è rappresentato da un indice intero definito nella struttura enum fixed_addresses { FIX_HOLE, FIX_VSYSCALL, FIX_APIC_BASE, FIX_IO_APIC_BASE_O, […] __end_of_fixed_addresses }; Gli FMLA sono posti alla fine del quarto gigabyte di indirizzi lineari. La funzione fix_to virt calcola l'indirizzo lineare costante a partire dall'indice inline unsigned long fix_to_virt(const unsigned int idx) { if(idx >= __end_of_fixed_addresses) __this_fixmap_does_not_exist(); return (0xfffff000UL – (idx << PAGE_SHIFT)); } Una funzione del kernel può chiamare fix_to_virt(FIX_IOAPIC_BASE_O); dato che la funzione è dichiarata “inline”, il compilatore non genera una chiamata di funzione ma inserisce il codice nella funzione 21
chiamante. Il controllo sul valore dell'indice non viene mai compiuto a runtime. Infatti FIX_IOAPIC_BASE_O è una costante uguale a 3 e il compilatore può eliminare la condizione if dato che essa risulta falsa. Al contrario, se la condizione è vera oppure l'argomento di fix_to_virt() non è una costante, il compilatore genera un errore nella fase di linking perché il simbolo __this_fixmap_does_not_exist() non è definito da nessuna parte. Eventualmente, il compilatore calcola 0xfffff000 – (3 << PAGE_SHIFT) e sostituisce alla funzione il valore 0xfffc000. Per associare un indirizzo fisico a un FMLA il kernel usa le macro set_fixmap(idx,phys) e set_fixmap_nocache(idx,phys). Entrambe inizializzano la entry dell PT che corrisponde a fix_to_virt(idx) con phys; la seconda funzione in più disabilita la cache settando il flag PCD. Invece clear_fixmap(idx) rimuove la mappatura tra idx e phys. Gestione della cache hardware e di TLB Cache e TLB hanno un ruolo importante nell'aumentare le prestazioni dei computer. Gli sviluppatori del kernel usano varie tecniche per ridurre il numero di cache miss. Gestione della cache hardware La cache è indirizzata per linee; la macro L1_CACHE_BYTES fornisce la dimensione in byte di una linea di cache. Nel Pentium 4 il valore è 128; sui modelli precedenti 32. Per ottimizzare la percentuale di cache hit, il kernel considera l'architettura nel prendere le seguenti decisioni: –
i campi delle strutture usati più di frequente sono posti a offset inferiori nella struttura, in modo che vengano memorizzati nella stessa linea di cache
–
quando deve allocare un numeroso insieme di strutture, il kernel tenta di memorizzare ognuna di esse in modo da usare uniformemente ogni linea di cache.
La sincronizzazione della cache è fatta automaticamente dal microprocessore 80x86, per cui il kernel non compie nessuna azione di flush.
Gestione di TLB I processori non possono sincronizzare la propria cache TLB, poiché è il kernel a decidere se la mappatura di indirizzi non è più valida. Linux 2.6 offre molti metodi di flush che possono essere applicati a seconda del tipo di cambiamento della tabella delle pagine (flush_tlb_all, flush_tlb_kernel_page, flush_tlb, flush_tlb_mm, flush_tlb_range, flush_tlb_pgtables, flush_tlb_page). Ogni microprocessore di solito offre un insieme di istruzioni assembly molto più ristretto per invalidare un TLB; per questo aspetto, una delle architetture più flessibili è Ultra SPARC. Intel ha solo due tecniche: –
tutti i modelli di Pentium compiono il flush automatico delle entry TLB relative a pagine non globali quando un valore viene memorizzato nel registro cr3
–
nel Pentium Pro e nei modelli successivi, l'istruzione invlpg invalida una singola entry TLB che mappa un dato indirizzo.
Le seguenti macro sfruttano questi metodi hardware e sono la base per implementare le funzioni indipendenti dall'architettura elencate all'inizio del paragrafo: 22
__flush_tlb():
riscrive cr3 con il proprio valore. Usato da flush_tlb, flush_tlb_mm, flush_tlb_range.
__flush_tlb_global():
azzera il flag PGE nel registro cr4, riscrive c3 con il proprio valore e resetta PGE. Usato per flush_tlb_all, flush_tlb_kernel_range.
__flush_tlb_single(addr):
esegue l'istruzione assembly invlpg con il parametro addr. Usata da flush_tlb_page.
Non viene citata la funzione flush_tlb_pgtables; nell'architettura 80x86 non deve essere fatto nulla quando una tabella di pagina viene scollegata dalla tabella da cui viene indirizzata, per cui la funzione è vuota. I metodi di flush vengono estesi in modo semplice ai sistemi multiprocessore; la funzione manda un interrupt interprocessore che costringe le altre CPU a eseguire le funzioni di invalidazione di TLB. In generale, una commutazione di processo (process switch) comporta il cambiamento delle tabelle di pagina attive. Le entry di TLB devono venire azzerate; questo avviene automaticamente quando il kernel scrive l'indirizzo della nuova PGD nel registro cr3. Il kernel riesce ad evitare il flush nei seguenti casi: –
quando avviene la commutazione tra processi che usano lo stesso set di tabelle di pagina
–
quando avviene la commutazione tra processi normali e thread del kernel; infatti questi ultimi non hanno un proprio set di tabelle di pagina, ma usano quelli dei processi in esecuzione sulla CPU al momento della commutazione.
Vi sono altri casi in cui il kernel deve annullare alcune entry di TLB; ad esempio quando assegna un frame di pagina ad un processo in modalità utente e memorizza il suo indirizzo in una entry di PT, deve invalidare le voci di TLB che si riferiscono a quell'indirizzo lineare. Nei sistemi multiprocessore deve invalidare anche le TLB delle CPU che usano la stessa tabella di pagina. Per evitare operazioni inutili, in sistemi multiprocessore viene usata la tecnica “lazy TLB mode”. L'idea di fondo è la seguente: se diverse CPU usano le stesse tabelle di pagina e una entry di TLB va invalidata su tutte, il flush può essere rinviato nelle CPU che eseguono thread del kernel. Infatti i thread usano le tabelle del processo in esecuzione in quel momento, e non è necessario invalidare le voci di TLB dato che essi non accedono allo spazio degli indirizzi della modalità utente. Per inciso, il metodo flush_tlb_all non usa la modalità “lazy”; viene chiamata quando il kernel modifica una tabella dello spazio di indirizzi in modalità del kernel. Quando una CPU esegue un thread del kernel, passa in “lazy TLB mode”. Quando viene inviato un segnale di cancellazione per qualche entry, la CPU non lo esegue, ma memorizza che il processo usa un set di tabelle non valido. Appena nella CPU avviene una commutazione di processo con un diverso set di tabelle di pagina, l'hardware esegue il flush delle entry di TLB e il kernel pone la CPU in modalità non-lazy. Invece se la commutazione riguarda un processo che usa lo stesso set di tabelle del precedente, le cancellazioni di entry differite vanno eseguite; questo avviene eseguendo il flush di tutte le entry non globali di TLB. Per implementare la modalità “lazy” occorrono ulteriori strutture dati. La variabile cpu_tlbstate è un array static di NR_CPUS strutture (di default il valore è 32, cioè il massimo numero di CPU per sistema) contenenti un campo active_mm che punta al descrittore di memoria del processo corrente, e un flag state che può assumere due valori: TLBSTATE_OK (modalità non lazy) e TLBSTATE_LAZY. In aggiunta, ogni descrittore di memoria include un campo cpu_vm_mask che contiene gli indici delle CPU che dovrebbero ricevere gli interrupt interprocessore legati al flush. Questo campo è significativo solo se il descrittore di memoria appartiene ad un processo in esecuzione.
23
Quando una CPU esegue un thread del kernel, il kernel setta il flag state a TLBSTATE_LAZY; cpu_vm_mask contiene gli indici di tutte le CPU del sistema, inclusa la presente. Quando un'altra CPU vuole annullare le entry relative ad un certo set di tabelle, invia un Interrupt a tutte le CPU il cui indice è incluso in cpu_vm_mask. Quando una CPU riceve l'interrupt e verifica che esso riguarda il set di tabelle usato dal processo che sta eseguendo, controlla che il flag state sia a TLBSTATE_LAZY. In questo caso il kernel non esegue il flushing e toglie l'indice di questa CPU dal campo cpu_vm_mask. Ne consegue che: –
finché la CPU rimane in modalità “lazy”, non riceve altri interrupt di flush
–
se avviene la commutazione con un altro processo che usa lo stesso set di tabelle, il kernel chiama __flush_tlb() per cancellare tutte le entry non globali di TLB.
24
