G. Frosini - Interruzioni Slide 1 · G. Frosini - Interruzioni Slide 5 Tipo di un’interruzione...

G. Frosini - Interruzioni Slide 1

INTERRUZIONI


Concetto di Interruzione

• Interruzione:– sospensione forzata del programma in esecuzione;– trasferimento del controllo ad un'apposita routine di servizio.

• Routine di servizio:– soddisfa le esigenze che hanno provocato l'interruzione e, al termine,

restituisce il controllo al programma sospeso.


Fonti di Interruzione

• Interruzioni esterne:– determinate da richieste sul piedino /INTR (INTerrupt Request) o sul

piedino /NMI (Non Maskable Interrupt);• richieste su /NMI: si traduce in una interruzione (interruzione non

mascherabile);• richieste su /INTR: si traduce o meno in una interruzione a seconda che il

flag IF (Interrupt Flag: bit n. 9 del registro RFLAGS) valga 1 oppure 0 (interruzione mascherabile).

• Interruzioni software:– prodotte da un’istruzione int.

• Single Step Trap:– prodotte, al termine della fase di esecuzione di ogni istruzione, se il flag

TF (Trap Flag: bit n. 8 del registro RFLAGS) vale 1: fa eccezione l'istruzione che ha provveduto a porre ad 1 il flag TF.

• Eccezioni nel processore:– prodotte da circuiterie di controllo interne al processore, al verificarsi di

una condizione anomala che impedisce il completamento della istruzione in corso.


Richieste e Interruzioni

• Richieste di interruzione esterne:– possono giungere al processore in qualunque momento (sono asincrone

rispetto al programma);– il processore porta a termine l'esecuzione dell'istruzione in corso, ed

esamina le richieste prima di effettuare il prelievo dell’istruzione successiva;

– un’interruzione esterna non può sospendere nel bel mezzo l'esecuzione di un’istruzione.

• Altre richieste di interruzione:– sono prodotte dalla esecuzione di istruzioni (sono sincrone rispetto al

programma);– interruzioni software e per single step trap:

• avvengono alla fine della fase di esecuzione e non producono nessuna sospensione di istruzione;

– eccezioni:• sospendono l'esecuzione dell’istruzione quando essa produce un'anomalia

(prima che essa giunga al termine o quando è già giubta al termine).


Tipo di un’interruzione (1)

• Ogni interruzione ha associato un tipo:– il tipo determina l'indirizzo della routine di servizio;– i tipi possibili sono 256, ed altrettanti le possibili routine di servizio.

• Regola per ricavare il tipo.– Interruzioni esterne:

• richiesta sul piedino /NMI: tipo implicito (2);• richiesta sul piedino /INTR: tipo prelevato da un apposito bus (bus di

interruzione), che collega il processore con il controllore di interruzione APIC) (l'invio di una richiesta su questo piedino deve essere accompagnato dalla specifica del tipo).

– Interruzioni software:• tipo dato dall'operando immediato (ad 8 bit) dell'istruzione int (è compito

del programmatore specificare il tipo).– Single Step Trap:

• tipo implicito (1).– Eccezioni nel processore:

• tipo implicito e legato alla causa che determina l‘eccezione.


Tipo di un’interruzione (2)

• Suddivisione delle eccezioni:– trap: avviene alla fine dell’esecuzione di un’istruzione;– fault: errore recuperabile, che avviene mentre viene eseguita un’istruzione;– abort: errore irrecuperabile, che produce la terminazione forzata dell’istruzione:

• viene tipicamente utilizzata per segnalare errori hardware.• Esempi di eccezioni

Tipo Causa dell’interruzione0 Quoziente non rappresentabile durante l'esecuzione delle istruzioni DIV, IDIV (fault)4 Presenza di overflow durante l'esecuzione dell'istruzione into (trap)5 Superamento dei limiti durante l'esecuzione dell'istruzione bound (fault)6 Codice operativo non valido (fault)16 Errore nell’unità FPU (fault)

• Tipi riservati e tipi liberi:– tipi riservati: da 0 a 31;– tipi utilizzabili dal programmatore (hardware (piedino /INTR) o software

(operando dell’istruzione int): da 32 a 255.


Tabella IDT

• Processore x86-64:– in memoria, a partire da un indirizzo contenuto in un registro del processore

(IDTR), è presente la Tabella delle Interruzioni (IDT: Interrupt DescriptorTable);

– la tabella IDT contiene tanti descrittori (o gate) quanti sono i tipi (256);– ogni descrittore è costituito da 16 byte.

• Gate:– specifica l'indirizzo della routine di servizio dell'interruzione;– possiede un byte di accesso, nel quale compaiono i bit GP e I/T.

Indirizzo

Accesso

063

GP T/ I


Azioni del processore per una interruzione (1)

• Il processore, quando accetta una richiesta di interruzione, compie le seguenti azioni:

– riconosce il tipo dell'interruzione;– preleva da un gate (a partire dall'indirizzo, relativo all’inizio della tabella,

dato da tipo*16) il nuovo indirizzo e il byte di accesso;– se il bit GP del byte di accesso vale 0 (gate non presente), genera una eccezione

(fault di tipo implicito 11) per interruzione non implementata;– memorizza in un registro di appoggio RSPP il valore di RSP (questa azione è

utile nel meccanismo di protezione);– immette in pila 5 parole quadruple, contenenti:

• un valore riservato (ragioni di compatibilità);• il valore di RSPP (meccanismo di protezione);• il valore di RFLAGS; • il valore di un registro speciale del processore CPL (meccanismo di

protezione); • il valore di RIP;

– carica in RIP il nuovo indirizzo prelevato dal gate;– pone a 0 il flag TF se il bit T/I del byte di accesso vale 1 (gate di trap) (il flag IF

non viene modificato), o entrambi i flag TF ed IF se il bit T/I vale 0 (gate di interrupt)


Azioni del processore per una interruzione (2)

Spazio riservato

RSPP

RIP (rit)

RFLAGS

CPL

• Parole quadruple memorizzate in pila, al momento significative:– contenuti dei registri RFLAGS e RIP.


Routine di servizio

• Routine di servizio:– inizia dall'indirizzo corrispondente al nuovo valore caricato in RIP.

• Termine della routine di servizio:– ritorno al programma che era stato interrotto;– tale ritorno avviene tramite l'esecuzione della istruzione iretq, la quale preleva

dalla pila 5 parole quadruple, trasferisce la prima in RIP e la terza inRFLAGS;

• il prelievo delle parole quadruple CPL e RSPP riguarda il meccanismo di protezione;

• il prelievo della parola quadrupla riservata avviene per ragioni di compatibilità.

• Meccanismo vettorizzato:– una interruzione ha associato un tipo, che determina l'acceso ad un

determinato gate, e quindi l'esecuzione di una routine dipendente dal tipo.


Gate di interrupt/trap

• Gate di interrupt:– la routine di servizio viene eseguita con il processore disabilitato ad accettare

nuove richieste di interruzioni mascherabili;– non si ha annidamento delle interruzioni mascherabili, a meno che la routine

di servizio non provveda esplicitamente a porre nuovamente ad 1 il flag IF.

• Gate sia di interrupt che di trap:– durante l'esecuzione della routine di servizio non si verifica mai

un’interruzione di single step trap, a meno che la routine non provveda esplicitamente a porre nuovamente ad 1 il flag TF.


Tipo dell’interruzione

• Riconoscimento del tipo:– tipo implicito:

• interruzioni esterne non mascherabili;• single step trap;• eccezioni nel processore.

– interruzioni software:• tipo coincidente con l'operando immediato dell’istruzione int.

– Interruzioni esterne mascherabili:• tipo prelevato dal bus di interruzione.


Indirizzo di ritorno

• Indirizzo di ritorno:– interruzioni esterne, software, di single step trap:

• memorizzazione in pila dell'indirizzo dell’istruzione che deve essere ancora eseguita (quello dell'istruzione sequenzialmente successiva, ovvero quello determinato da un’istruzione di salto).

– eccezioni: trap, fault e abort.• trap: come al punto precedente.• fault: memorizzazione in pila dell'indirizzo dell'istruzione che ha prodotto

l'eccezione, con conseguente riesecuzione della stessa al termine della routine di servizio (dopo l'esecuzione dell’istruzione iretq).

• abort: terminazione forzata della istruzione attuale (non è significativo l'indirizzo della istruzione che deve essere ancora eseguita).


Registri fotocopia

• Riesecuzione di un’istruzione:– i contenuti dei registri del processore devono essere quelli originari.

• Processore: possiede registri fotocopia:– all’inizio della fase di chiamata, il contenuto dei registri originari viene

ricopiato nei registri fotocopia (RIP non è ancora stato aggiornato);– alla fine della fase di chiamata, viene aggiornato il valore di RIP

fotocopia;– durante la fase di esecuzione, le micro operazioni avvengono sui registri

fotocopia;– alla fine della fase di esecuzione, il contenuto dei registri fotocopia viene

ricopiato in quelli originari.• Generazione di un fault (istruzione non terminata):

– in pila vengono memorizzati i valori dei registri originari RFLAGS ed RIP non ancora aggiornati (RIP contiene l’indirizzo dell’istruzione che ha prodotto il fault).


Classificazione delle routine di servizio (1)

• Interruzioni esterne non mascherabili:– prodotte da cause catastrofiche, come l'abbassarsi della tensione di

alimentazione sotto un livello di soglia;– routine di servizio (unica, essendo unico il tipo): provvede ad effettuare

opportune azioni di recupero.• Interruzioni esterne mascherabili:

– prodotte tipicamente dalle interfacce di I/O;– routine di servizio (driver): provvedono ad effettuare il trasferimento dei dati.

• Istruzione int:– invocazione di routine di sistema (primitive), con un meccanismo alternativo

alla istruzione call; – riferisce primitive tramite un numero d'ordine e non con un nome:

• non è necessaria l’operazione di collegamento.

• Eccezioni:– routine di servizio: sostituendosi al programma in esecuzione, impediscono che

questo continui ad operare in modo scorretto (possono semplicemente inviare un messaggio di errore).


Classificazione delle routine di servizio (2)

• Single Step Trap:– la routine di servizio consente ad un utente, che abbia posto TF ad 1, di

eseguire il programma in single step, con esame ed eventualmente modifica, dopo ogni istruzione, del il contenuto dei registri e delle locazioni di memoria e di I/O;

– la routine gira con il flag TF a 0 (per non essere essa stessa eseguita in single step);

– la routine memorizza il contenuto dei registri in una apposita area di memoria e gestisce le operazioni di visualizzazione/modifica;

– prima di terminare, la routine ripristina il contenuto dei registri del processore e (con l’istruzione iretq) il vecchio contenuto del registro RFLAGS: in tal modo il flag TF assume nuovamente il valore 1.

• Nuovo Single Step Trap:– si verifica alla fine della successiva istruzione del programma utente (non

dopo l'istruzione iretq, in quanto questa ha provveduto a mettere ad 1 il flag TF).


Inizializzazioni

• Per le operazioni di inizializzazione, si utilizzano le seguentidefinizioni typedef:

typedef void* addr; // indirizzo nello spazio di memoriatypedef unsigned short ioaddr; // indirizzo nello spazio di I/Otypedef unsigned char natb;typedef unsigned short natw;typedef unsigned int natl;typedef unsigned long natq;

• Nota: – in C++ un indirizzo di memoria può essere dereferenziato (essendo di tipo

void*, richiede però una preliminare conversione di tipo);– un indirizzo di I/O non può essere dereferenziato in C++, ma solo in

Assembler.


Inizializzazione della tabella IDT (1)

• Tabella IDT:– viene posizionata in memoria a indirizzi multipli di 8;– vanno inizializzati i gate relativi ai tipi di interruzione utilizzati.

• Sottoprogrammi utilizzati:– gate_init() (in Assembler, in quanto occorre agire sui vari gruppi di bit), che

compone un gate (di tipo interrupt o trap) specificato, utilizzando un indirizzo di memoria che individua la routine che deve essere eseguita;

– componi-gate() (in C++), che ha per argomenti formali il tipo del gate it , il tipo dell’interruzione tipo e l’indirizzo di memoria routine, che richiama il sottoprogramma gate_init() con gli stessi parametri.


Inizializzazione della tabella IDT (2)

# file in Assembler

.text

.global componi_gatecomponi_gate: …

ret

// file in C++struct gate{ natq q1; natq q2; };gate idt[256]; // allineata a indirizzi multipli di 8, come ognuno dei 2 campiextern "C" void componi_gate(gate& g, bool it, addr ff );void gate_init(natb tipo, bool it, addr routine ){ gate gg;

componi_gate(gg, it, routine);idt[tipo] = gg;

}


Controllore APIC (1)

• Processore x86-64:– possiede un solo piedino /INTR per le richieste di interruzioni

mascherabili.• Calcolatore:

– contiene più sorgenti di interruzione.• Controllore di interruzione:

– circuiteria apposita che gestisce più fonti di interruzione;– stabilisce, nel caso di richieste multiple, quale di queste debba avere la

precedenza.• Caso tipico:

– circuiteria costituita da un controllore di interruzione APIC (IO APIC + LOCAL APIC);



IO APIC

D31-D0

/INTR

/INTA

A31-A2

/RD

/WR

/S

TP

IORegSel

IOWin

EOI

IRR

ISR

31

LOCAL APIC

0xFEE000B0

0xFEC00000

0xFEC00010Porta per i dati

Porta per gli indirizzi

0 IR0

IR23

Registri speciali

/BE3-/BE0



• Montato nello spazio di memoria.• Visibile al programmatore come un insieme di registri a 32 bit:

– 3 registri direttamente accessibili:• IORegSel: 0x00000000FEC00000: porta per gli indirizzi• IOWin: 0x00000000FEC00010: porta per i dati• EOI: 0x00000000FEE000B0: per la configurazione End Of Interrupt

– 64 registri speciali, che stabiliscono alcune modalità di funzionamento.• Piedini IR23-IR0:

– servono a ricevere le richieste di interruzione provenienti da sorgenti esterne.

• Tutto avviene come se il controllore:– per il collegamento al bus, fosse in possesso dei classici piedini per i dati

(D31-D0), per gli indirizzi (A31-A2, /BE3-/BE0), per i comandi di lettura e scrittura e per l'abilitazione (/RD, /WR, /S).

– per il colloquio con il processore, fosse in possesso di un piedino /INTR, di un piedino /INTA e di un piedino TP, collegati ai piedini omonimi del processore.



• Tabella interna:– costituita da 24 entrate ed inizia dall’indirizzo interno 16 (0x10);

• Entrata:– associata a un piedino IR e costituita da due registri da 32 bit.

24 piedini

0x10

0x11

0x3E

0x3F

APIC 24 coppie di registri a 32 bit



• Registro di indirizzo minore:– 1 bit che maschera (valore 1) le richieste di interruzione (bit 16);– 8 bit per il tipo associato alle richieste di interruzione (bit 7-0) (il tipo può

andare da 0x20 a 0xFE)).– 1 bit per la forma del segnale, livello (valore 1) oppure impulso (valore 0) (bit

15);– 1 bit per la polarità, attivo basso (valore 1) o attivo alto (valore 0) (bit 13):

• significato di attivo basso: se livello, valore 0, se impulso sequenza di valori 1-0-1;

• significato di attivo alto: se livello, valore 1, se impulso sequenza di valori 0-1-0.

• Richieste di interruzione:– più fonti di interruzione possono essere collegate allo stesso piedino;– in questo caso le richieste di interruzione sono costituite da un livello

basso;– sul piedino avviene una operazione hardware di OR logico (OR di

collettore).



• Colloquio tra controllore e processore,:– previsto un bus speciale (bus di interruzione), che può essere schematizzato

come un insieme di 3 collegamenti:– /INTR: il controllore invia al processore richieste di interruzione;– /INTA: il controllore riceve risposta a una richiesta di interruzione;– TP: il controllore invia (serialmente) il tipo di interruzione al processore.

• Priorità delle richieste:– livelli di priorità (16) dipendenti dai 4 bit più significativi del tipo;– il controllore, quando accetta una richiesta di interruzione:

• continua a gestire le richieste a maggiore priorità;• cessa di gestire (ma non di memorizzare) le richieste a minore o uguale

priorità;– tutto ciò fino a quando il controllore stesso non riceve (via software, nel

registro EOI) la configurazione End Of Interrupt (valore 0):• da quel momento il controllore riprende a gestire anche le richieste di

interruzione a minore o uguale priorità rispetto a quella servita (che ha inviato la configurazione End Of Interrupt).



• Controllore APIC:– funziona in modo annidato (quello precedentemente descritto);– utilizza due registri (non visibili al programmatore) IRR (Interrupt

Request Register) e ISR (In Service Register), ciascuno di 256 bit (ogni bit associato a uno dei 256 tipi di interruzione).

• Registri IRR e ISR:– suddivisi in 16 parti, a cui corrispondono priorità crescenti da destra a

sinistra;– ciascuna parte è composta da 16 bit a cui corrisponde la stessa priorità.

• Tabella interna:– associa a ognuno dei piedini IR0-IR23:

• il bit di maschera;• il tipo di interruzione;• la forma (impulso o livello) e la polarità del segnale di richiesta di

interruzione. • Azioni del controllore APIC:

– le azioni di cui ai successivi punti 1., 2. e 3. sono svolte in parallelo.



• Il controllore, ogni volta che riceve una richiesta di interruzione tramite uno dei piedini IR0-IR23, pone a 1 il bit di IRR corrispondente al tipo:

– per segnali di richiesta aventi la forma di impulso, una richiesta di interruzione è rappresentata da un segnale che da inattivo diviene attivo;

– per segnali aventi la forma di livello, una richiesta di interruzione èrappresentata da un segnale che risulta attivo nel momento in cui il controllore riceve la configurazione End Of Interrupt.

• Il controllore ripete ciclicamente i seguenti passi:– a)attende che il il bit più significativo di IRR di valore 1 abbia una priorità

maggiore del bit più significativo di ISR di valore 1;– b) invia al processore una richiesta di interruzione attivando il piedino /INTR;– c)attende la risposta sul piedino /INTA e, quando la riceve:

• i) considera il bit di IRR più a sinistra di valore 1, sia il j-mo; • ii) pone a 0 il j-mo bit di IRR e ad 1 il j-mo bit di ISR;• iii) invia j (tipo dell’interruzione) al processore (serialmente) sul collegamento TP;• iv) rimuove la richiesta di interruzione al processore disattivando il piedino /INTR.



• Configurazione EOI (End Of Interrupt):– Il controllore, ogni volta che riceve (via software) la configurazione EOI,

azzera il bit più a sinistra di ISR di valore 1 (non possono esservi richieste sotto servizio di uguale priorità, e la routine in esecuzione è certamente quella che gestisce la richiesta sotto servizio a più alta priorità).


Predisposizione del controllore APIC (1)

• Ipotesi:– unica fonte di interruzione per piedino.

• Proprietà del controllore indipendenti dalla specifica operazione (predisposte in fase di inizializzazione).

– segnale costituito da un livello e attivo baso;

• Proprietà del controllore variabili da operazione a operazione:– funzione apic_set_MIRQ(), per mascherare/smascherare il piedino su cui

arrivano richieste di interruzione;– funzione apic_set_VECT(), per associare un tipo al piedino su cui

arrivano richieste di interruzione;– tali funzioni agiscono sulla tabella interna del controllore;

• ha indirizzo base 16;• è costituita da 24 entrate (ciascuna comprende due parole lunghe di 32 bit);

– la parte bassa di ogni entrata ha indirizzo relativo ir*2, dove ir è il numero d’ordine del piedino di richiesta di interruzione (va da 0 a 23).



// file in C++natq* iIOREGSEL = reinterpret_cast<nati*>(0x00000000FEC00000);natq* iIOWIN = reinterpret_cast<nati*>(0x00000000FEC00010);

void apic_set_MIRQ(natb ir, bool v)// ir: numero d’ordine del piedino; v: determina il mascheramento{ natl work;

// lettura della prima parola lunga dell'entrata ir-esima della tabella interna*iIOREGSEL = 16 + ir*2;work = *iIOWIN;if (v) work |= 0x00010000; // bit n. 16 a 1, mascheramento

else work &= 0xFFFEFFFF; // bit n. 16 a 0, smascheramento// scrittura nella prima parola lunga dell'entrata ir-esima della tabella interna*iIOREGSEL = 16 + ir*2;*iIOWIN = work;

}



// file in C++void apic_set_VECT(natb ir, natb vec)// ir: numero d’ordine del piedino; vec: tipo che vi deve essere associato{ natl work;

// lettura della prima parola lunga dell'entrata ir-esima della tabella interna*iIOREGSEL) = 16 + ir*2;work = *iIOWIN;// azzeramento (operazione di &) e predisposizione (operazione di | ) dei bit 7-0 con il valore di vecwork &= 0xFFFFFF00;work |= vec;// scrittura nella prima parola lunga dell’entrata ir-esima della tabella interna*iIOREGSEL = 16 + ir*2;*iIOWIN = work;

}


Primitive e Driver

• Primitive e Driver:– due categorie di routine di servizio:

• primitive: prodotte dalla esecuzione di una istruzione software int, con un operando immediato, per eseguire operazioni che l’utente non può o non deve fare da solo;

• driver: prodotti dall’arrivo di un segnale di interruzione, sul piedini /INTR del processore tramite il controllore di interruzione, per eseguire le operazioni richieste dall’interruzione stessa.

• Coppie di file, uno in C++ e uno in Assembler:– una coppia utilizzabili dall’utente, siano utente.cpp e utente.s; – una coppia non utilizzabili dall’utente (ma dal sistema operativo, come

verrà chiarito esaminando il meccanismo di protezione), siano sistema.se sistema.cpp.


Struttura di una primitiva (2)

• Primitive in C++:– in C++ non è presente l’istruzione int;– per invocare una primitiva si utilizza un sottoprogramma di interfaccia, che

può avere argomenti e restituire un risultato.

• Sottoprogramma di interfaccia:– esegue un’istruzione int, con esecuzione della primitiva vera e propria

(a_primitiva()).

• a-primitiva:– in genere è in Assembler, dovendo talvolta agire sui registri del processore;– la parte elaborativa è in genere in C++ (c-primitiva).

• c-primitiva:– ha gli stessi parametri della primitiva.

• Gate utilizzato:– può essere di interrupt o di trap.



// file utente.cpp, contenente il programma principaleextern "C" void primitiva_i(/* argomenti formali */);int main(){ …

primitiva_i(/* argomenti attuali */); // richiamo del sottoprogramma di interfaccia// rit …

}

# file utente.s, contenente il sottoprogramma di interfaccia.text.global primitiva_iprimitiva_i:

int $tipo_i # gate utilizzato: può essere di interrupt o di trapirit: ret



# file sistema.s....text.extern c_primitiva_ia_primitiva_i: # routine associata a tipo_i

call c_primitiva_iprit: iretq

// file sistema.cpp, contenente la parte elaborativa della primitiva (c_primitiva_i)extern "C" void c_primitiva_i(/* argomenti formali*/){ … }

• Funzione c_primitiva_i():– ha gli stessi argomenti di primitiva_i() (sottoprogramma di interfaccia), che

si trovano negli stessi registri.


Driver di interruzione (1)

• Driver di interruzione con risposta:– il segnale di richiesta è costituito da un livello di polarità bassa (possono

esservi più richiedenti per quel piedino). • effettua azioni che rappresentano anche una risposta alla pertinente

richiesta di interruzione (semplicemente, legge o scrive in un registro dell’interfaccia);

• la fonte che ha effettuato una richiesta rimuove la richiesta stessa;• Driver di interruzione senza risposta:

– il segnale di richiesta è costituito da un impulso (il richiedente per quel piedino è unico e la polarità può essere qualsivoglia):

• non fornisce alcuna risposta all’interfaccia;• Controllore di interruzione:

– deve essere programmato in modo opportuno per i differenti piedini IR23-IR0.

• Gate utilizzati:– gate di interrupt (i driver girano con le interruzioni (mascherabili)

disabilitate);– non si verifica mai annidamento fra driver.



// file sistema.s.text.global c_driver_jdriver_j: # routine associata a tipo_j

# salvataggio registricall c_ driver_j # parte elaborativa del drivermovl $0, 0x00000000FEE000B0 # invio di EOI# ripristino registriiretq

// file sistema.cpp, contenente la parte elaborativa del driver (c_driver_j)extern "C" void c_driver_j(){ …}

• Invio della configurazione End Of Interrupt:– deve avvenire con le interruzioni disabilitate, per evitare che il driver venga

interrotto da richieste a minore (o uguale) priorità.


• Driver:– non può avere argomenti;

• non possono essere lasciati da nessuna parte, in quanto le interruzioni possono avvenire in qualunque momento.

• può operare su variabili globali.– asincrono rispetto al programma;

• un’interruzione può avvenire solo fra una istruzione macchina e un’altra, ma può verificarsi nel mezzo di una istruzione C++ (che corrisponde a piùistruzioni macchina).

– occorre che effettui il salvataggio e il ripristino dei registri utilizzati.• Utilizzo della routine c_driver:

– come qualunque routine C++, non modifica le informazioni presenti nei registri rsp, rbp, rbx, r12-r15 (eventualmente prima salvando e poi ripristinando il loro valore), mentre può modificare il contenuto dei registri rax, rdi, rsi, rdx, rcx, r8, r9;

• Salvataggio e ripristino dei registri:– occorre che il driver prima salvi e poi ripristini il contenuto dei registri rax,

rdi, rsi, rdx, rcx, r8, r9, che possono essere modificati dalla routine c_driver.



• Istruzione iretq:– ripristina anche il vecchio valore del registro RFLAGS (che ha il flag

IF uguale ad 1), a prescindere dalla configurazione attualmente contenuta nel registro RFLAGS stesso.


Operazioni di I/O a interruzione (1)

• Operazioni di I/O:– sono in genere organizzate come primitive, utilizzando gate di trap

(interruzioni abilitate);• è bene che il programma non acceda direttamente alle interfacce.

• Realizzazione delle operazioni di I/O:– risulta naturale che le operazioni di I/O siano sincrone:

• il programma che le effettua si blocca in attesa della loro terminazione;• esso viene sbloccato solo quando l’operazione è terminata.

• Attese attive:– per non averle, occorrerebbe operare in un ambiente multiprogrammato;

• quando un programma è bloccato in attesa che sia terminata un’operazione di I/O, viene eseguito un altro programma.

– al momento, si opera in un ambiente monoprogrammato, e quindi si hanno attese attive.


Operazioni di I/O a interruzione (2)

• Interfaccia:– ogni volta che è pronta a trasferire un dato, invia una richiesta di interruzione;– quando la richiesta viene accettata dal processore, va in esecuzione un driver di

interruzione che provvede a trasferire il dato. • Driver:

– ogni volta che va in esecuzione, verifica se trattasi dell’ultimo dato da trasferire;

– in caso affermativo, disabilita l’interfaccia a generare richieste di interruzione;

– in ogni caso trasferisce un dato e invia al controllore la configurazione End OfInterrupt;

• Trasferimento di N dati:– generazione di N richieste di interruzione ed esecuzione del driver per N volte.

• Nota:– il trasferimento di un singolo dato richiede più tempo nel caso di interruzione

che non nel caso di controllo di programma ( il meccanismo di interruzione, infatti, prevede accessi aggiuntivi in memoria);

– il meccanismo di interruzione risulta globalmente vantaggioso solo se si eliminano le attese attive.


Meccanismo di sincronizzazione (1)• Meccanismo semplice:

– non realistico, in quanto non prevede la multiprogrammazione;– consente di fare programmi di prova.

• Semaforo di sincronizzazione, costituito da:– una variabile di sincronizzazione (booleana), elemento di un array di

semafori;– due sottoprogrammi, che hanno per argomento il numero d’ordine di

un semaforo (indice) all’interno dell’array:• ss_wait():

– inizializza la variabile di sincronizzazione a false;– ciclicamente, finché la variabile di sincronizzazione non vale true,

tiene in attesa (attiva) il programma.• ss_signal():

– pone la variabile di sincronizzazione a true.• Argomento attuale dei due sottoprogrammi:

– stesso numero d’ordine di semaforo. • Sottoprogramma ss_wait():

– viene richiamato dalla primitiva di lettura, che ha le interruzioni abilitate.

• Sottoprogramma ss_signal():– viene richiamato dal driver di interruzione.


Meccanismo di sincronizzazione (2)

// file sistema.cppconst int S = …;bool ss [S];void ss_wait(int sem){ ss [sem] = 0;

while (ss[sem] == 0) ; // le interruzioni sono abilitatereturn;

}void ss_signal(int sem){ ss [sem] = 1;

return;}


Schematizzazione di un’interfaccia (1)

• Interfaccia in grado di funzionare a interruzione di programma, sia per operazioni di ingresso che di uscita:

0 RBRA1-A0

D7-D0

EXIO

1 TBR

0

2 CTRI

0

3 CTRO

/RD

/WR

/S

INTI

CLK

INTO


Schematizzazione di un’interfaccia (2)

• L’interfaccia invia una richiesta di interruzione quando: – il buffer di ingresso diviene pieno (RBR contiene un nuovo byte prelevato

dal dispositivo); la richiesta viene inviata tramite il piedino INTI;– il buffer di uscita diviene vuoto (il byte in TBR è stato inviato al

dispositivo ); la richiesta viene inviata tramite il piedino INTO.• Accesso a RBR (lettura) o a TBR (scrittura) effettuato dal driver:

– costituisce anche una risposta alla richiesta di interruzione;– l’interfaccia può rimuovere la richiesta stessa e iniziare un nuovo

trasferimento.• L’interfaccia può essere abilitata o disabilitata a inviare richieste

di interruzione:– bit meno significativo dei registri CTRI e CTRO (ConTrol Register

In/Out), rispettivamente;– una volta effettuata l’abilitazione, l’interfaccia genera immediatamente

una richiesta di interruzione se il buffer di ingresso è già pieno o il buffer di uscita è già vuoto.


Indirizzi e funzioni per l’I/O

• Indirizzi dei registri dell’interfaccia nello spazio di I/O;const ioaddr iRBR = …;const ioaddr iTBR = …;const ioaddr iCTRI = …;const ioaddr iCTRO = …;

• Semaforo di sincronizzazione utilizzato:const natl sincr_s = …;

• Funzioni di utilità per leggere da, o scrivere in, un registro dello spazio di I/O (scritte in Assembler):

extern "C" void inputb(ioaddr ireg, natb &a);// trasferisce dal registro di indirizzo ireg nella variabile aextern "C" void outputb(natb a, ioaddr ireg);// trasferisce dalla variabile a al registro di indirizzo ireg


Ingresso dati

• Programma che intende fare un’operazione di ingresso dati:– invoca una primitiva di I/O, sia read_n();– argomenti di read_n():

• numero di byte da trasferire;• indirizzo del buffer di memoria nel quale devono essere immessi i byte.

• Primitiva read_n(), parte c_read_n():– trasferisce il valore degli argomenti in due variabile cont_in e punt_in

accessibili anche al driver;– abilita l’interfaccia a generare richieste di interruzione in ingresso;– richiama il sottoprogramma ss_wait().


Driver di ingresso

• Driver di interruzione driver_in(), parte c_driver_in(); ogni volta che va in esecuzione:

– decrementa cont_in;– se cont_in è uguale a 0:

• disabilita l’interfaccia a generare richieste di interruzione in ingresso;• richiama il sottoprogramma ss_signal();

– in ogni caso:• trasferisce un byte da interfaccia a memoria;• incrementa punt_in ;• invia la configurazione End_Of_Interrupt.


Primitiva read_n()// file main.cpp#include <libce.h>cont int N = …; natb buffr[N];extern "C" void read_n(natl nn, natb vv[]);int main(){ natl quanti;

// …read_n(quanti, buffr);// ...return 0;

}

# file main.s.text.global read_nread_n: int $tipo_i

ret


Routine assembler a_read_n e a_driverin_n

# file sistema.s.text.extern c_read_n.global a_read_n # globale per inizializzare la IDTa_read_n: # routine associata a tipo_i, interruzioni abilitate

call c_read_niretq

.extern c_driverin_n

.global a_driverin_n # globale per inizializzzare la IDTa_driverin_n: # routine associata a tipo_j, interruzioni disabilitate

# salva registricall c_driverin_nmovl $0, 0x00000000FEE000B0# ripristina registriiretq


Funzioni C++ c_read_n() e c_driver_n()// file sistema.cppnatl cont_in;natb* punt_in;extern "C" void c_read_n(natl nn, natb vv[]){ cont_in = nn;

punt_in = vv;outputb(0x01, iCTRI); // abilit. richieste di interruzione ingressoss_wait(sincr_s);

}extern "C" void c_driverin_n(){ natb c;

cont_in--;if (cont_in == 0){ outputb(0x00, iCTRI); // disab. richieste di interruzione ingresso

ss_signal(sincr_s);}inputb(iRBR, c);*punt_in = c; // trasferimento in memoriapunt_in++;

}


Sottoprogrammi inputb e outputb

// file sistema.cppextern "C" void inputb(ioaddr ireg, natb &a);extern "C" void outputb(natb a, ioaddr ireg);

# file sistema.s.global inputb# ireg in rdi, &a in rsiinputb: movw %di, %dx

inb %dx, %almovb %al, (%rsi)ret

.global outputb# a in rdi, ireg in rsioutputb: movw %si, %dx

outb %dl, %dxret


Osservazioni sul driver

• Driver:– prima di trasferire l’ultimo dato, oltre a disabilitare l’interfaccia,

richiama anche il sottoprogramma ss_signal(): • non è concettualmente corretto richiamare ss_signal() prima che i dati

siano stati tutti trasferiti;• tuttavia non si verificano malfunzionamenti perché le interruzioni

mascherabili sono disabilitate;• non vi è pertanto il rischio che, prima che il driver finisca, vada in

esecuzione una qualsivoglia routine di interruzione che magari esamini il valore del semaforo, trovandolo già ad 1 quando i trasferimenti dei dati non sono stati tutti effettuati.

• Esecuzione di un driver:– inizia quando arriva un’interruzione durante il ciclo di attesa del

sottoprogramma ss_wait();– termina (ritornando al ciclo di attesa del sottoprogramma ss_wait()) solo

quando è giunto alla fine dell’esecuzione;– nell’ultima esecuzione, termina quando ha disabilitato l’interfaccia, messo

a 1 il semaforo, ed effettuato il trasferimento dell’ultimo dato:• il ciclo del sottoprogramma ss_wait() non è più di attesa.


Inizializzazioni

• Sottoprogramma ini() (eseguito in fase di inizializzazione):

// sistema.cppconst int natb tipo_prim = …, tipo_driv = …;const int pin_driv = …;

void ini_ip_interf_in(){ outputb(0x00, iCTRI); // disabilit. richieste di interruzione ingresso}

extern "C" addr a_read_n;extern "C" addr a_driverin_n;void ini(){ ini_ip_interf_in();

gate_init(tipo_prim, false, a_read_n);gate_init(tipo_driv, true, a_driverin_n);apic_set_VECT(pin_driv, tipo_driv ); // associazione del tipo al piedinoapic_set_MIRQ(pin_driv, false); // abilit. piedino dello IO APIC

}


Terminazione determinata da un particolare byte

• Condizione di terminazione di una operazione:– può anche essere determinata, oltre che dal conteggio dei byte, anche dalla

lettura dall’interfaccia di un particolare byte, o dalla scrittura nell’interfaccia di un particolare byte.

• Operazione di lettura:– in questo caso il driver va così modificato:

• disabilita l’interfaccia a generare richieste di interruzione;• legge un dato;• se il dato letto non è quello di terminazione, riabilita l’interfaccia a

generare richieste di interruzione.• Operazione di scrittura:

– in questo caso il driver subisce modeste modifiche:• esamina ogni dato prelevato dal buffer;• se il dato è di terminazione, disabilita l’interfaccia a generare richieste di

interruzione come se il conteggio fosse arrivato a 0.


Buffer di memoria

• Buffer di memoria utilizzati nelle primitive read_n() e write_n():– sono stati definiti come variabili globali;

• se fossero definiti locali ai programmi principali di lettura o di scrittura, verrebbero ad essere memorizzati nelle loro pile.

• Quando da un’interfaccia arriva una richiesta di interruzione:– manda in esecuzione un driver;– il programma che sta effettuando un’operazione di I/O è bloccato sul

sottoprogramma wait();– in un ambiente multiprogrammato, la sua pila non è accessibile, ma è

accessibile quella di un eventuale altro programma che nel frattempo può essere eseguito.

• Queste ultime considerazioni saranno comprese a pieno quando verrà trattata la multiprogrammazione.


Sistema di sviluppo (1)

• Per effettuare programmi di I/O:– utilizzo dell’ emulatore QEMU, che emula un Elaboratore x86-64,

comprendente:• processore x86-64, bus locale con banchi di memoria;• controllore di interruzione APIC;• bus PCI con bus mastering (Direct Memory Access);• bus ATA e 2 unità a disco rigido;• bus a 8 bit con tastiera, timer e interfacce seriali;• finestra video funzionante in modo testo o in modo grafico. …

• Emulatore: provvisto di un boot-loader che provvede:– a portare il processore emulato da modo (reale) 8086 a modo (protetto)

x86-64;– a caricare un programma eseguibile da un file UNIX nella memoria

dell’elaboratore;– a far partire il programma dall’ entry-point (_start).


Sistema di sviluppo (2)

• Ipotesi per lo sviluppo di un programma:– i file (parte in C++ e parte in Assembler) si trovano tutti e soli in un’unica

cartella, dalla quale si emettono i comandi di compilazione-collegamento e di caricamento-esecuzione.

• Comando di compilazione-collegamento:compile nomefile

– traduce tutti i file C++ e Assembler contenuti nella cartella corrente, collega i file tradotti ed alcuni facenti parte di un’apposita libreria libce, fra cui il file contenente l’entry point _start;

– genera il file eseguibile nomefile: • se nomefile viene omesso, il file eseguibile è a.out.

• File eseguibile (entry point _start):– richiama i due sottoprogrammi ini() e main(), quindi ritorna al sistema

operativo UNIX.• Comando di caricamento-esecuzione:

boot nomefile– carica il programma eseguibile e fa iniziare il processo di emulazione.


Libreria libce (1)

• Libreria libce contiene:– un file libce.h, con le dichiarazioni typedef e le dichiarazioni di funzioni;– tanti file con estensione cpp contenenti ciascuno la definizione di una

funzione dichiarata in libce.h;– altri file con estensione s o cpp, coinvolti (direttamente o indirettamente) dai

file precedenti.• Fase di collegamento di un programma:

– con il comando compile (che collega la libreria come ultima, dopo i file del programma), la risoluzione dei nomi viene risolta utilizzando anzitutto i file del programma, quindi i file di libreria.

G. Frosini - Interruzioni Slide 1 · G. Frosini - Interruzioni Slide 5 Tipo di un’interruzione...

Documents

Transcript of G. Frosini - Interruzioni Slide 1 · G. Frosini - Interruzioni Slide 5 Tipo di un’interruzione...