Fix dopo merge; #20

include/handler/handler.h

@@ -1,10 +1,6 @@
 #ifndef H_HANDLER
 #define H_HANDLER
 
-// SysCall/BP Handler functions and define
-//-------------------------------------------------------
-#define TERMINATEPROCESS 3
-
 /**
  * @brief Gestore SYSCALL/BP. Richiama il gestore 
  * specifico per SYSCALL/BP se il registro di causa
@@ -17,6 +13,12 @@ void Handler_SysCall(void);
  * @param request Puntatore alla SYS/BP New Area
  */
 void handle_syscall(state_t *request);
+
+/**
+ * @brief Gestore specifico per BREAKPOINT.
+ * @param request Puntatore alla SYS/BP New Area
+ */
+void handle_breakpoint(state_t *request);
 //-------------------------------------------------------
 
 // Trap Handler functions and define

include/handler/shared.h

@@ -1,10 +1,80 @@
 #ifndef H_HANDLER_SHARED
 #define H_HANDLER_SHARED
 
+#include <system/system.h>
+
+#define SYSNO2INDEX( n )( (n)-1 )
+
+#define SYS_SPECPASSUP_TYPE_SYSBK 0
+#define SYS_SPECPASSUP_TYPE_TLB 1
+#define SYS_SPECPASSUP_TYPE_PGMTRAP 2
+
+void SpecPassup_init();
+
+/**
+ * @brief Indica se è stato definito un handler superiore del tipo fornito
+ * 
+ * @param type 
+ * @return int boooleano
+ */
+int IsSetSpecPassup( int type );
+
+/**
+ * @brief Imposta l'area fornita come handler superiore del tipo fornito
+ * 
+ * @param type 
+ * @param area 
+ * @return int 
+ *         - 0 se è l'area stata impostata correttamente
+ *         - -1 se il tipo fornito non è gestito, area == NULL, oppure se è già stata assegnata un'area all'handler del tipo specifiato
+ */
+int SetSpecPassup( int type, state_t *area );
+
+/**
+ * @brief Restituisce il puntatore dello stato dell'handler superiore, associato al tipo specificato
+ * 
+ * @param type 
+ * @return state_t* 
+ *          - NULL se IsSetSpecPassup avrebbe restituito TRUE
+ *          - l'area altrimenti
+ */
+state_t *GetSpecPassup( int type );
+
+/**
+ * @brief Chiamante di system call che dati dei parametri forniti, chiama la specifica system call con i parametri dati
+ * @PostCondition valgono tutte le PostCondition delle system call
+ *                inoltre,  se è gestita internamente saranno passati solo i paramentri necessari alla system call,
+ *                          altrimenti se definita una SPECPASSUP, sarà caricato il contesto specificato sul processore
+ *                Se la syscall ritorna un valore, il suo valore è assegnato a returnValueAddr;
+ * @PreCondition returnValueAddr != NULL
+ * @param sysno codice identificativo della system call
+ * @param currState ultimo stato del processo in esecuzione
+ * @param param1 
+ * @param param2 
+ * @param param3 
+ * @param returnValueAddr puntatore nella quale sarà assegnato il valore di ritorno
+ * @return word se == 0 la system call chiamata non ha restituito alcun valore, 1 altrimenti
+ */
+word Syscaller( state_t* currState, word sysno, word param1, word param2, word param3, word *returnValueAddr );
+
+void Sys1_GetCPUTime( state_t* currState, word *user, word *kernel, word *wallclock );
+
+int Sys2_CreateProcess( state_t *state, int priority, void **cpid );
+
 /**
  * @brief Implementazione della syscall TERMINATE_PROCESS.
  * Termina il processo corrente e tutta la sua progenie.
  * Infine, richiama lo scheduler.
  */
-void sys3_terminate(void);
+int Sys3_TerminateProcess( void *pid );
+
+void Sys4_Verhogen( int* semaddr );
+
+void Sys5_Passeren( int* semaddr );
+
+int Sys6_DoIO( word command, word *devreg, int subdevice );
+
+int Sys7_SpecPassup( state_t* currState, int type, state_t *old_area, state_t *new_area );
+
+int Sys8_GetPID( void **pid, void **ppid );
 #endif

include/scheduler/scheduler.h

@@ -9,13 +9,17 @@
 /*
     Ciclo di vita dello scheduler:
         (Per # si intende un evento che genera l'interruzione dell'esecuzione )
-
+        (Per @ si intende una possibile gestione dell'evento)
     -> scheduler_init()
     -> scheduler_main()
-        -> 	scheduler_StateToRunning() -> # -> scheduler_StateToTerminate()
-                    ^                     |		
-                    |                     |
-			scheduler_StateToready() <----|
+        -> 	scheduler_schedule() -> # -> scheduler_UpdateContext() -> V
+               ^                                                      |		
+               |                                                      @ ----> scheduler_StateToTerminate()
+               -------------------------------scheduler_StateToReady<-@
+                                                        ^             :
+                                                        |             :
+                                            scheduler_StateToWaiting<-@ 
+
 
 */
 struct scheduler_t {
@@ -26,6 +30,9 @@ struct scheduler_t {
 	/* puntatore al descrittore del processo in esecuzione */
 	pcb_t* running_p;
 
+    /* booleano indicante se il processo attuale non può continuare lo scheduling (TRUE) oppure continuare mantenere il processo schedulato (FALSE) */
+    int b_force_switch;
+
 };
 typedef struct scheduler_t scheduler_t;
 
@@ -44,41 +51,62 @@ void scheduler_init();
 int scheduler_main();
 
 /**
- * @brief 	Avvia l'esecuzione del prossimo processo nella ready queue per un TIME_SLICE, impostando tale valore al Interrupt Timer
+ * @brief Aggiorna lo stato del processo tracciato in esecuzione, con quello fornito
+ * 
+ * @param state 
+ */
+void scheduler_UpdateContext( state_t* state );
+
+/**
+ * @brief 	Avvia l'esecuzione dell'algoritmo dello scheduler che in base alle circostanze può:
+ *          - continuare l'esecuzione del processo attuale;
+ *          - sospendere il processo attuale e scegliere ed avviare il prossimo processo nella ready queue per un TIME_SLICE, impostando tale valore al Interrupt Timer
  * 			Se la coda dei processi ready non è vuota,
  * 				Sceglie il processo dalla ready queue con priorità più alta
  * 				Imposta l' interrupt timer a TIME_SLICE
  * 				e carica lo stato del processo sul processore
  * 				Dopo questo la funzione non dovrebbe restituire poichè il controllo dell'esecuzione è passato al processo
  * 				Se ciò avviene è dovuto ad un errore di LDST.
- * @PreCondition Prima di chiamare questa funzione, è necessario chiamare scheduler_StateToReady o scheduler_StateToTerminate
- * 				 per aggiornare il contesto dell'ultimo processo eseguito
+ * @PreCondition Prima di chiamare questa funzione, è necessario chiamare scheduler_UpdateContext() per aggiornare il contesto del processo attuale
+ * 				 
+ * @param b_force_switch se TRUE lo scheduler è forzato a cambiare il processo da eseguire
  * @return int 
  * 			* manda Il sistema in HALT se la coda dei processi è vuota
  * 			* -1 se non è stato caricato lo stato di un nuovo processo, senza cambiare il controllo di esecuzione ( malfunzionamento LDST )
  */
-int scheduler_StateToRunning();
+int scheduler_schedule( int b_force_switch );
 
 /**
- * @brief 	Aggiorna lo stato del processo fornito al processo corrente;
- * 			effettua un azione di aging per tutti gli elementi nella ready queue;
- * 			ripristina la priorità originale del processo che era in esecuzione
+ * @brief   Ripristina la priorità originale del processo che era in esecuzione
  * 			Disassocia il processo in esecuzione dallo scheduler
- * @PostCondition Dopo questo stato è necessario richiamare scheduler_StateToRunning per procedere con la schedulazione dei processi
+ * @PreCondition Prima di chiamare questa funzione, è necessario chiamare scheduler_UpdateContext() per aggiornare il contesto del processo attuale
+ * @PostCondition Dopo questo stato è necessario richiamare scheduler_schedule per procedere con la schedulazione dei processi
  * 
  * @param state stato del processo che era in esecuzione
  * @return int 
  * 			* 1 se non c'è alcun processo tracciato dallo scheduler in esecuzione
  * 			* 0 altrimenti se l'inserimento in ready queue è avvenuto correttamente
  */
-int scheduler_StateToReady( state_t* state );
+int scheduler_StateToReady();
 
-/* WIP UNCOMPLETE */
-int scheduler_StateToWaiting();
+/**
+ * @brief aggiunge il processo corrente alla ASL con associato la chiave fornita
+ * 
+ * @PreCondition Prima di chiamare questa funzione, è necessario chiamare scheduler_UpdateContext() per aggiornare il contesto del processo attuale
+ * @PostCondition Dopo questo stato è necessario richiamare scheduler_schedule per procedere con la schedulazione dei processi
+ * @param semKey chiave da associare al semaforo
+ * @return int 
+ * 			* -1 se nessun processo è attualmente assegnato come processo corrente
+ * 			* 0 se l'operazione è stata effettuata correttamente
+ * 			* 1 se non è stato possibile aggiungere il processo corrente alla ASL (impossibile allocare semaforo)
+ */
+int scheduler_StateToWaiting( int* semKey );
 
 /**
  * @brief Dealloca il descrittore del processo che era in esecuzione, rimuovendo eventualmente la sua progenie
  * 
+ * @PreCondition Prima di chiamare questa funzione, è necessario chiamare scheduler_UpdateContext() per aggiornare il contesto del processo attuale
+ * @PostCondition Dopo questo stato è necessario richiamare scheduler_schedule per procedere con la schedulazione dei processi
  * @return int 
  * 			* 1 se non c'è alcun processo tracciato dallo scheduler in esecuzione
  * 			* 0 altrimenti se è avvenuto tutto correttamente
@@ -88,6 +116,15 @@ int scheduler_StateToWaiting();
  */
 int scheduler_StateToTerminate( int b_flag_terminate_progeny  );
 
+/**
+ * @brief Restituisce il puntatore dell'attuale pcb_t in esecuzione
+ * 
+ * @return state_t* 
+ */
+pcb_t *scheduler_GetRunningProcess();
+
+scheduler_t *scheduler_Get();
+
 /**@WIP funzione non completata, ma sarà completato in fasi successive
  * @brief Crea un processo, aggiungendolo al ciclo di vita dello scheduler
  * Quando il processo sarà scelto, inizierà l'esecuzine a partire dall'indirizzo di funzione fornito

include/umps/umpsconst.h

@@ -19,7 +19,6 @@
 #define RAMSIZE    *((unsigned int *)BUS_REG_RAM_SIZE)
 #define RAM_TOP     (RAMBASE + RAMSIZE)
 
-#define FRAMESIZE (4096)
 
 #define STATUS_NULL          0x00000000
 #define INTERRUPT_ON          (STATUS_IEp)