Riferimenti per il file sistema.cpp

Parte C++ del modulo sistema. Continua...

#include <costanti.h>
#include <libce.h>
#include <sys.h>
#include <sysio.h>
#include <boot.h>
#include <vm.h>
#include <cfi.h>

Grafo delle dipendenze di inclusione per sistema.cpp:

Vai al codice sorgente di questo file.

Strutture dati
struct	des_proc
	Descrittore di processo.
struct	des_sem
	Descrittore di semaforo. Continua...
struct	richiesta
	Richiesta al timer. Continua...
struct	des_frame
	Descrittore di frame. Continua...
struct	copy_segment
	Oggetto da usare con map() per caricare un segmento in memoria virtuale. Continua...

Ridefinizioni di tipo (typedef)
typedef void(*	entry_t) (natq)
	Tipo degli entry point dei moduli I/O e utente.

Funzioni
void	inserimento_lista (des_proc *&p_lista, des_proc *p_elem)
	Inserimento in lista ordinato (per priorità)
des_proc *	rimozione_lista (des_proc *&p_lista)
	Estrazione del processo a maggiore priorità
void	inspronti ()
	Inserisce esecuzione in testa alla lista pronti.
void	schedulatore (void)
	Sceglie il prossimo processo da mettere in esecuzione.
int	liv_chiamante ()
	Restituisce il livello a cui si trovava il processore al momento in cui è stata invocata la primitiva.
natl	alloca_sem ()
	Alloca un nuovo semaforo.
bool	sem_valido (natl sem)
	Verifica un id di semaforo.
void	c_sem_ini (int val)
	Parte C++ della primitiva sem_ini().
void	c_sem_wait (natl sem)
	Parte C++ della primitiva sem_wait().
void	c_sem_signal (natl sem)
	Parte C++ della primitiva sem_signal().
void	inserimento_lista_attesa (richiesta *p)
	Inserisce un processo nella coda delle richieste al timer.
void	c_delay (natl n)
	Parte C++ della primitiva delay.
void	c_driver_td (void)
	Driver del timer.
void	gestore_eccezioni (int tipo, natq errore, vaddr rip)
	Gestore generico di eccezioni.
void	init_frame ()
	Inizializza la parte M2 e i descrittori di frame.
paddr	alloca_frame ()
	Estrae un frame dalla lista dei frame liberi.
void	rilascia_frame (paddr f)
	Restiuisce un frame alla lista dei frame liberi.
paddr	alloca_tab ()
	Alloca un frame libero destinato a contenere una tabella.
void	rilascia_tab (paddr f)
	Dealloca un frame che contiene una tabella.
void	inc_ref (paddr f)
	Incrementa il contatore delle entrate valide di una tabella.
void	dec_ref (paddr f)
	Decrementa il contatore delle entrate valide di una tabella.
natl	get_ref (paddr f)
	Legge il contatore delle entrate valide di una tabella.
bool	in_utn_c (vaddr v)
	Controlla che un indirizzo appartenga alla zona utente/condivisa.
bool	in_sis_c (vaddr v)
	Controlla che un indirizzo appartenga alla zona sistema/condivisa.
bool	c_access (vaddr begin, natq dim, bool writeable, bool shared=true)
	Parte C++ della primitiva access()
void	c_trasforma (vaddr ind_virt)
	Parte C++ della primitiva trasforma()
void	c_activate_p (void f(natq), natq a, natl prio, natl liv)
	Parte C++ della primitiva activate_p()
void	c_terminate_p (bool logmsg)
	Parte C++ della pritimiva terminate_p()
void	c_abort_p (bool selfdump)
	Distrugge il processo puntato da esecuzione.
bool	load_handler (natq tipo, natq irq)
	Carica un handler nella IDT.
void	c_activate_pe (void f(natq), natq a, natl prio, natl liv, natb irq)
	Parte C++ della primitiva activate_pe().
void	c_fill_gate (natb tipo, void routine(), int liv)
	Parte C++ della primitiva fill_gate().
void	c_phys_alloc (size_t size, std::align_val_t align)
	Parte C++ della primitiva phys_alloc().
void	c_phys_dealloc (void *ptr)
	Parte C++ della primitiva phys_dealloc().
void	cedi_controllo (des_proc *p)
	Cede il controllo ad un altro processo.
void	main (natq)
	Inizializza il sistema e poi esegue il ciclo dummy fino allo shutdown.
entry_t	carica_modulo (boot64_modinfo *mod, paddr root_tab, natq flags, natq heap_size)
	Carica un modulo in M2.
void	panic (const char *msg)
	Ferma il sistema e stampa lo stato di tutti i processi.
void	c_nmi ()
	Routine di risposta a un non-maskable-interrupt.
void	c_do_log (log_sev sev, const char *buf, natl quanti)
	Parte C++ della primitiva do_log().
void	c_getmeminfo ()
	Parte C++ della primitiva getmeminfo().
natq	read_mem (void *token, vaddr v)
	Callback invocata dalla funzione cfi_backstep() per leggere dalla pila di un qualunque processo.
void	process_dump (des_proc *p, log_sev sev)
	Invia sul log lo stato di un processo.
Funzioni di supporto alla creazione e distruzione dei processi
natl	alloca_proc_id (des_proc *p)
	Alloca un id di processo.
void	rilascia_proc_id (natw id)
	Rilascia un id di processo non più utilizzato.
void	init_root_tab (paddr dest)
	Inizializza la tabella radice di un nuovo processo.
void	clear_root_tab (paddr dest)
	Ripulisce la tabella radice di un processo.
bool	crea_pila (paddr root_tab, vaddr bottom, natq size, natl liv)
	Crea una pila processo.
void	distruggi_pila (paddr root_tab, vaddr bottom, natq size)
	Distrugge una pila processo.
des_proc *	crea_processo (void f(natq), natq a, int prio, char liv)
	Funzione interna per la creazione di un processo.
void	distruggi_processo (des_proc *p)
	Dealloca tutte le risorse allocate da crea_processo()

Variabili
const natl	DUMMY_PRIORITY = 0
	Priorità del processo dummy.
des_proc *	proc_table [MAX_PROC]
	Tabella che associa l'id di un processo al corrispondente des_proc.
natl	processi
	Numero di processi utente attivi.
des_proc *	esecuzione
	Coda esecuzione (contiene sempre un solo elemento)
des_proc *	pronti
	Coda pronti (vuota solo quando dummy è in esecuzione)
des_sem	array_dess [MAX_SEM *2]
	Array dei descrittori di semaforo.
natl	sem_allocati_utente = 0
	Numero di semafori allocati per il livello utente.
natl	sem_allocati_sistema = 0
	Numero di semafori allocati per il livello sistema (moduli sistema e I/O)
richiesta *	sospesi
	Coda dei processi sospesi.
natq const	N_FRAME = MEM_TOT / DIM_PAGINA
	Numero totale di frame (M1 + M2)
natq	N_M1
	Numero di frame in M1.
natq	N_M2
	Numero di frame in M2.
des_frame	vdf [N_FRAME]
	Array dei descrittori di frame.
natq	primo_frame_libero
	Testa della lista dei frame liberi.
natq	num_frame_liberi
	Numero di frame nella lista dei frame liberi.
static const natq	PART_SIZE = dim_region(MAX_LIV - 1)
	Granularità delle parti della memoria virtuale.
const vaddr	ini_sis_c = norm(I_SIS_C * PART_SIZE)
	base di sistema/condivisa
const vaddr	ini_sis_p = norm(I_SIS_P * PART_SIZE)
	base di sistema/privata
const vaddr	ini_mio_c = norm(I_MIO_C * PART_SIZE)
	base di modulo IO/condivisa
const vaddr	ini_utn_c = norm(I_UTN_C * PART_SIZE)
	base di utente/condivisa
const vaddr	ini_utn_p = norm(I_UTN_P * PART_SIZE)
	base di utente/privata
const vaddr	fin_sis_c = ini_sis_c + PART_SIZE * N_SIS_C
	limite di sistema/condivisa
const vaddr	fin_sis_p = ini_sis_p + PART_SIZE * N_SIS_P
	limite di sistema/privata
const vaddr	fin_mio_c = ini_mio_c + PART_SIZE * N_MIO_C
	limite di modulo IO/condivisa
const vaddr	fin_utn_c = ini_utn_c + PART_SIZE * N_UTN_C
	limite di utente/condivisa
const vaddr	fin_utn_p = ini_utn_p + PART_SIZE * N_UTN_P
	limite di utente/privata
des_proc *	a_p [apic::MAX_IRQ]
	Associazione IRQ -> processo esterno che lo gestisce.
des_proc *const	ESTERN_BUSY = reinterpret_cast<des_proc*>(1UL)
	Valore da inserire in a_p per gli IRQ che sono gestiti da driver.
const natl	DELAY = 59659
	Periodo del timer di sistema.
int	MAX_LOG = 5
	Massimo livello ammesso per la severità dei messaggi del log.

Distruzione della pila sistema corrente
Quando dobbiamo eliminare una pila sistema dobbiamo stare attenti a non eliminare proprio quella che stiamo usando. Questo succede durante una terminate_p() o abort_p(), quando si tenta di distrugguere proprio il processo che ha invocato la primitiva. Per fortuna, se stiamo terminando il processo corrente, vuol dire anche che stiamo per metterne in esecuzione un altro e possiamo dunque usare la pila sistema di quest'ultimo. Operiamo dunque nel seguente modo: all'ingresso nel sistema (in salva_stato()), salviamo il valore di esecuzione in esecuzione_precedente; questo è il processo a cui appartiene la pila sistema che stiamo usando; in distruggi_processo(), se esecuzione è uguale a esecuzione_precedente (stiamo distruggendo proprio il processo a cui appartiene la pila corrente), non distruggiamo la pila sistema e settiamo la variabile ultimo_terminato; in carica_stato(), dopo aver cambiato pila, se ultimo_terminato è settato, distruggiamo la pila sistema di esecuzione_precedente.
des_proc *	esecuzione_precedente
	Processo che era in esecuzione all'entrata nel modulo sistema.
paddr	ultimo_terminato
	Se diverso da zero, indirizzo fisico della root_tab dell'ultimo processo terminato o abortito.
void	distruggi_pila_precedente ()
	Distrugge la pila sistema del processo uscente e rilascia la sua tabella radice.

Descrizione dettagliata

Parte C++ del modulo sistema.

Definizione nel file sistema.cpp.