/*TerminatePcb si preoccupa di terminare ricorsivamente tutta la progenie di p, root dell'albero di processi*/
void terminatePcb(pcb_t *p){
semd_t* semd;
if(p->p_first_child != NULL)
terminatePcb(p->p_first_child);
if(p->p_first_child == NULL && p->p_sib != NULL)
terminatePcb(p->p_sib);
if(p->p_first_child == NULL && p->p_sib == NULL){
lock(MUTEX_SCHEDULER);
if(outBlocked(p)){
/*Rimuovo p dalla coda dei processi del suo semaforo*/
lessSoftCounter(); /*Decremento il softBlock counter*/
semd = getSemd(p->p_semkey);
/*Se p è bloccato su un semaforo di un device, non incremento il value. Sarà l'interrupt a farlo*/
if(!checkSemaphore(p))
(*semd->s_key)++;
}
/*Tolgo p dalla ReadyQueue, se presente*/
outProcQ(&ready_queue[getPRID()], p);
outChild(p);
freePcb(p);
unlock(MUTEX_SCHEDULER);
}
}
/*Richiama la funzione fun per ogni elemento della coda di processi del semaforo della ASL con chiave key*/
void forallBlocked(int *key, void fun(struct pcb_t *pcb, void *), void *arg){
semd_t *semd_target = getSemd(key);
if (!semd_target->s_procQ)
return;
else
forallProcQ(semd_target->s_procQ, fun, arg);
}
/*[3]
* Viene inserito il PCB puntato da p nella coda
dei processi bloccati associata al SEMD con chiave key. Se
il semaforo corrispondente non e’ presente nella ASL, alloca
un nuovo SEMD dalla lista di quelli liberi (semdFree) e lo
inserisce nella ASL, settando I campi in maniera opportuna. Se
non e’ possibile allocare un nuovo SEMD perche’ la lista di
quelli liberi e’ vuota, restituisce TRUE. In tutti gli altri casi,
restituisce FALSE.
*/
int insertBlocked(int *key, pcb_t* p)
{
semd_t *tmp;
p->p_next=NULL;
tmp = getSemd(key);
/*se il semaforo non esiste*/
if (tmp == NULL)
{
/**/
tmp = allocSem();
/*se la lista dei semd liberi e vuota*/
if (tmp == NULL){
return TRUE;
}
tmp->s_key = key;
insert(&semd_h, tmp);
p->p_semkey = key;
insertProcQ(&(tmp->s_procQ), p);
}
else
insertProcQ(&(tmp->s_procQ), p);
return FALSE;
}
/*Rimuove il pcb puntato da p dalla coda dei processi sul semaforo a lui associato (p->p_semkey) sulla ASL.
Se il processo non risulta bloccato (cioè è un errore), restituisce NULL, altrimenti restituisce il puntatore al processo*/
pcb_t* outBlocked(pcb_t *p){
semd_t *semd_target = getSemd(p->p_semkey);
pcb_t *blocked = NULL;
if(semd_target)
blocked = outProcQ(&(semd_target->s_procQ), p);
/*Se p non esiste nella coda del semaforo*/
return blocked;
}
/*Restituisce il puntatore al pcb del primo processo bloccato sul semaforo, senza deaccordarlo.
Se il semaforo non esiste restituisce NULL.*/
pcb_t* headBlocked(int *key){
semd_t *semd_target = getSemd(key);
if (semd_target)
return headProcQ(semd_target->s_procQ);
else
return NULL;
}
/*[8]
Descrizione:richiama la funzione fun per ogni provesso
bloccato sul semaforo identificato da key
*/
void forallBlocked(int *key, void fun(struct pcb_t *pcb, void *), void *arg){
semd_t *tmp;
tmp = getSemd(key);
if ((tmp->s_procQ)==NULL){
return;
} else {
forallProcQ(tmp->s_procQ, fun, arg);
}
}
int main() {
int i,j;
/* Setting up CPU0 new areas in ROM. */
populateArea((state_t *)INT_NEWAREA,(memaddr)intHandler,0);
populateArea((state_t *)TLB_NEWAREA,(memaddr)tlbHandler,0);
populateArea((state_t *)PGMTRAP_NEWAREA,(memaddr)trapHandler,0);
populateArea((state_t *)SYSBK_NEWAREA,(memaddr)sysHandler,0);
/* Setting up CPU-n (with n >= 1) new areas in RAM, in a defined array of state_t pointers. */
for (i = 1; i < NUM_CPU; i++)
for (j = 0; j < 4; j++)
switch (j) {
case 0: populateArea(&new_old_areas[i][1],(memaddr)intHandler,i); break;
case 1: populateArea(&new_old_areas[i][3],(memaddr)tlbHandler,i); break;
case 2: populateArea(&new_old_areas[i][5],(memaddr)trapHandler,i); break;
case 3: populateArea(&new_old_areas[i][7],(memaddr)sysHandler,i); break;
}
/* Initialization of underlaying data structures. */
initPcbs();
initASL();
/* Inizialization of device semaphores. TODO */
if ((psClock_timer = getSemd(0)) != NULL)
psClock_timer -> s_value = 0;
if ((terminalWrite = getSemd(1)) != NULL)
terminalWrite -> s_value = 0;
if ((terminalRead = getSemd(2)) != NULL)
terminalRead -> s_value = 0;
/* Scheduler initialization process. */
initScheduler(i);
return 1;
}
pcb_t *headBlocked(int *key){
semd_t *tmp;
tmp = getSemd(key);
/*se il semaforo non esiste*/
if(tmp == NULL){
return NULL;
} else {
return tmp->s_procQ;
}
}
/*[7]
* Rimuove il PCB puntato da p
dalla coda del semaforo su cui e’ bloccato, termina anche tutti i processi discendenti
*/
void outChildBlocked(pcb_t *p){
semd_t *tmp;
tmp = getSemd(p->p_semkey);
outProcQ(&(tmp->s_procQ), p);
if(p->p_first_child == NULL){
p->p_first_child = NULL;
return;
}else{
outChildBlocked(p->p_first_child);
}
}
/*Ritorna il primo PCB dalla coda dei processi bloccati(s_ProcQ) associata al SEMD della ASL con chiave key.
Se tale descrittore non esiste nella ASL, restituisce NULL.
Altrimenti,restituisce l’elemento rimosso.
Se la coda dei processi bloccati per il semaforo diventa vuota, rimuove il descrittore del semaforo corrispondente dalla ASL e lo inserisce nella coda dei semafori liberi (semdFree).*/
pcb_t* removeBlocked(int *key){
semd_t *semd_target = getSemd(key);
if(semd_target){
/*Il semaforo è nella ASL*/
pcb_t *removed = removeProcQ(&(semd_target->s_procQ)); /*Rimuovo il primo PCB della sua coda di processi*/
if (semd_target->s_procQ == NULL)
deAllocSem(&semd_h, semd_target);
return removed;
}
else
return NULL;
}
/*[6]
* rimuove il pcb puntato da p dalla coda dei processi*/
pcb_t* outBlocked(pcb_t *p){
semd_t *tmp;
pcb_t *temp;
tmp = getSemd(p->p_semkey);
temp = outProcQ(&(tmp->s_procQ), p);
/*se non esiste*/
if(temp==NULL){
return NULL;
}else{
return temp;
}
}
/**[5]
* Ritorna il primo PCB dalla coda dei processi bloccati (s_ProcQ) associata al SEMD
* della ASL con chiave key. Se tale descrittore non esiste nella ASL, restituisce NULL.
* Altrimenti, restituisce l’elemento rimosso. Se la coda dei processi bloccati per il
* semaforo diventa vuota, rimuove il descrittore corrispondente dalla ASL e lo
* inserisce nella coda dei descrittori liberi (semdFree).
*/
struct pcb_t* removeBlocked(int *key)
{
semd_t *tmp;
pcb_t* rem;
tmp = getSemd(key);
if(tmp == NULL){
return NULL;
}else{
rem = removeProcQ(&(tmp->s_procQ));
if (tmp->s_procQ == NULL)
RemRec(&semd_h, tmp);
return rem;
}
}
/*Rimuove il PCB puntato da p dalla coda del semaforo su cui e’ bloccato
outChildBlocked() termina anche tutti i processi discendenti di p.
L'eliminazione avviene visitando l'albero come una DFS*/
void outChildBlocked(pcb_t *p){
semd_t* semd;
if(outBlocked(p)){
/*Rimuovo p dalla coda dei processi del suo semaforo*/
lessSoftCounter(); /*Decremento il softBlock counter*/
semd = getSemd(p->p_semkey);
/*Se p è bloccato su un semaforo di un device, non incremento il value. Sarà l'interrupt a farlo*/
if(!checkSemaphore(p))
(*semd->s_key)++;
}
outChild(p);
/*Se p ha una progenie, terminatePcb si occupa di terminarla*/
if(p->p_first_child)
terminatePcb(p->p_first_child); /*Elimina la progenie di p*/
lock(MUTEX_SCHEDULER);
freePcb(p); /*Resetto i campi del pcb puntato da p che viene reinserito nella lista pcbFree*/
unlock(MUTEX_SCHEDULER);
}
/*Viene inserito il PCB puntato da p nella coda dei processi bloccati associata al SEMD con chiave key.
Se il semaforo corrispondente non è presente nella ASL, alloca un nuovo SEMD dalla lista di quelli liberi (semdFree) e lo inserisce nella ASL.
Se non è possibile allocare un nuovo SEMD perchè la lista di quelli liberi è vuota, restituisce TRUE.
In tutti gli altri casi,restituisce FALSE*/
int insertBlocked(int *key, pcb_t* p){
semd_t *semd_target = getSemd(key);
if(semd_target == NULL){
/*Il semaforo non esiste nella ASL*/
semd_target = allocSem(); /*semd_target ora punta al SEMD tolto dalla semdFree. Se semdFree è vuota, semd_target == NULL*/
if (semd_target == NULL) /*Se la semdFree è vuota restituisco TRUE*/
return TRUE;
semd_target->s_key = key;
insertSEMList(&semd_h, semd_target); /*Alloco semd_target nella ASL*/
p->p_semkey = key;
if(*key <= 0)
insertProcQ(&(semd_target->s_procQ), p); /*Inserisco p nella coda di processi bloccati di semd_target*/
return FALSE;
}
else{
/*Il semaforo esiste già nella ASL*/
insertProcQ(&(semd_target->s_procQ), p);
p->p_semkey = key;
return FALSE;
}
}
