je suis dans le flou pour sys_exit, je n'ai pas compris où revenir à la fin du sys_exit, pour l'instant ça fonctionne mais on choisit le processus suivant. Il faudra peut-etre changer ça du coup. Mais si c'est bon alors j'en suis à retourner le status au kernel.

Author: Hugo

Aurel-Hugo/kmain.c

@@ -13,14 +13,25 @@ void user_process()
 	}
 }
 
+void user_process_stopping()
+{
+	int v=0;
+	while(v<1)
+	{
+		v++;
+		sys_yield();
+	}
+	sys_exit(0);
+}
+
 void kmain( void )
 {
 	sched_init();
 
 	int i;
 	for(i=0;i<NB_PROCESS;i++)
 	{
-		create_process((func_t*) &user_process);
+		create_process((func_t*) &user_process_stopping);
 	}
 
 	__asm("cps 0x10"); // switch CPU to USER mode
@@ -30,4 +41,14 @@ void kmain( void )
 	{
 		sys_yield();
 	}
-}
+}
+
+/** Question 6.5 **
+	Parce qu'il est impossible pour le moment de savoir quand le processus a fini son travail.
+*/
+
+/** Question 6.6 **
+	On est obligé de faire un tour complet du round robin pour trouver le "previous" du pcb courant
+	(celui à supprimer).
+	Oui ça peut être génant si il y a trop de processus : perte de temps importante
+*/

Aurel-Hugo/src/sched.c

@@ -6,6 +6,10 @@ struct pcb_s kmain_process;
 
 extern unsigned int* sp_sauv;
 
+#define SIZE_OF_PROCESS_STACK_OCTETS 10000
+
+/* SYS_ACTION */
+
 void
 sys_yieldto(struct pcb_s* dest)
 {
@@ -26,9 +30,20 @@ sys_yield(void)
 	__asm("mov %0, sp" : "=r"(current_process->sp));
 	__asm("swi #0");
 	__asm("mov sp, %0" : : "r"(current_process->sp));
-	__asm("mov lr, %0" : : "r"(current_process->lr_user)); // current_process est maintenant "dest"
+	__asm("mov lr, %0" : : "r"(current_process->lr_user));
+}
+
+void
+sys_exit(int status)
+{
+	__asm("mov r0, #7");
+	__asm("swi #0");
+	__asm("mov sp, %0" : : "r"(current_process->sp));
+	__asm("mov lr, %0" : : "r"(current_process->lr_user));
 }
 
+/* DO_SYS_ACTION */
+
 void
 do_sys_yieldto(void)
 {
@@ -59,7 +74,7 @@ do_sys_yield(void)
 	int i;
 	for(i=0 ; i<13 ; i++)
 	{
-		// on enregistre les registres courant
+		// on enregistre les registres courants
 		old_process->registres[i] = sp_sauv[i];
 		// puis on charge les registres du nouveau processus
 		sp_sauv[i] = current_process->registres[i];
@@ -70,27 +85,61 @@ do_sys_yield(void)
 	__asm("msr SPSR, %0" : : "r"(current_process->cpsr));
 }
 
+
+void
+do_sys_exit()
+{
+	current_process->etat = TERMINATED;
+	current_process->previous->next = current_process->next;
+	current_process->next->previous = current_process->previous;
+	struct pcb_s* to_delete = current_process;
+	elect();
+	kFree((void *)to_delete->sp, SIZE_OF_PROCESS_STACK_OCTETS);
+	kFree((void *)to_delete, sizeof(struct pcb_s));
+	// ici tout est propre mais il faut encore que l'on change de contexte
+	// on passe donc au processus suivant
+	int i;
+	for(i=0 ; i<13 ; i++)
+	{
+		// puis on charge les registres du nouveau processus
+		sp_sauv[i] = current_process->registres[i];
+	}
+	// puis on restaure le CPSR du nouveau processus
+	__asm("msr SPSR, %0" : : "r"(current_process->cpsr));
+}
+
+/* Autre */
+
 void
 sched_init(void)
 {
 	kheap_init();
 	current_process = &kmain_process;
 	current_process->next = current_process;
+	current_process->previous = current_process;
+	current_process->etat = RUNNING;
 }
 
 void
 create_process(func_t* entry)
 {
 	struct pcb_s* pcb_res = (struct pcb_s*) kAlloc(sizeof(struct pcb_s));
 	pcb_res->lr_user = entry;
-	pcb_res->sp = (uint32_t*) (kAlloc( 10000 ) + sizeof(uint8_t)*10000);
+	pcb_res->sp = (uint32_t*) (kAlloc(SIZE_OF_PROCESS_STACK_OCTETS) + sizeof(uint8_t)*SIZE_OF_PROCESS_STACK_OCTETS);
 	struct pcb_s* pcb_res_next = current_process->next;
+	
 	current_process->next = pcb_res;
+	pcb_res->previous = current_process;
+
 	pcb_res->next = pcb_res_next;
+	pcb_res_next->previous = pcb_res;
 }
 
 void
 elect()
 {
+	// si le processus courant tournait, alors on l'arrete
+	current_process->etat = (current_process->etat==RUNNING) ? READY : current_process->etat;
 	current_process = current_process->next;
+	current_process->etat = RUNNING;
 }

Aurel-Hugo/src/sched.h

@@ -4,6 +4,7 @@
 #include <stdint.h>
 
 typedef int (func_t) (void)	;
+typedef enum {READY, RUNNING, TERMINATED} status;
 struct pcb_s
 {
 	uint32_t registres[13]; 
@@ -12,13 +13,20 @@ struct pcb_s
 	uint32_t* sp;
 	uint32_t* cpsr;
 	struct pcb_s* next;
+	struct pcb_s* previous;
+	status etat;
 };
 
-void do_sys_yieldto(void);
-void do_sys_yield(void);
-
+// lance dest en tant que prochain processus à executer
 void sys_yieldto(struct pcb_s* dest);
+// laisse l'ordonnanceur choisir le prochain processus à executer
 void sys_yield();
+// Termine le processus courant avec le code de retour status.
+void sys_exit(int status);
+
+void do_sys_yieldto(void);
+void do_sys_yield(void);
+void do_sys_exit();
 
 void sched_init(void);
 void create_process(func_t* entry);

Aurel-Hugo/src/syscall.c

@@ -90,6 +90,7 @@ swi_handler(void)
 		case 4:	do_sys_gettime(); break;
 		case 5:	do_sys_yieldto(); break;
 		case 6:	do_sys_yield(); break;
+		case 7:	do_sys_exit(); break;
 		default: PANIC();
 	}
 	__asm("ldmfd sp!, {r0-r12, pc}^");