fin de sys_exit avec sys_exit non-explicite. Toujours un gros doute sur le code de retour.. Je ne vois pas où on le récupère coté noyau. Variable globale ?

Author: Hugo

Aurel-Hugo/kmain.c

@@ -3,7 +3,7 @@
 #include "sched.h"
 #define NB_PROCESS 5
 
-void user_process()
+void user_process(void)
 {
 	int v=0;
 	for(;;)
@@ -13,10 +13,10 @@ void user_process()
 	}
 }
 
-void user_process_stopping()
+void user_process_stopping(void)
 {
 	int v=0;
-	while(v<1)
+	while(v<2)
 	{
 		v++;
 		sys_yield();

Aurel-Hugo/src/sched.c

@@ -1,5 +1,6 @@
 #include "sched.h"
 #include "kheap.h"
+#include "hw.h"
 
 struct pcb_s* current_process;
 struct pcb_s kmain_process;
@@ -33,13 +34,15 @@ sys_yield(void)
 	__asm("mov lr, %0" : : "r"(current_process->lr_user));
 }
 
-void
+int
 sys_exit(int status)
 {
+	current_process->code_retour = 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));
+	return status;
 }
 
 /* DO_SYS_ACTION */
@@ -79,7 +82,7 @@ do_sys_yield(void)
 		// puis on charge les registres du nouveau processus
 		sp_sauv[i] = current_process->registres[i];
 	}
-	// on enregistre le CPSR de l'ancien processus
+	// on enregistre le CPSR et lr_svc de l'ancien processus
 	__asm("mrs %0, SPSR" : "=r"(old_process->cpsr));
 	// puis on restaure le CPSR du nouveau processus
 	__asm("msr SPSR, %0" : : "r"(current_process->cpsr));
@@ -118,28 +121,50 @@ sched_init(void)
 	current_process->next = current_process;
 	current_process->previous = current_process;
 	current_process->etat = RUNNING;
+	current_process->code_retour = -1;
 }
 
 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(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;
+
+	// pcb_res->lr_user = entry;
+	pcb_res->lr_user = (func_t*)(&start_current_process);
+	pcb_res->fonction_process = entry;
+	pcb_res->sp = (uint32_t*) (kAlloc(SIZE_OF_PROCESS_STACK_OCTETS) + sizeof(uint8_t)*SIZE_OF_PROCESS_STACK_OCTETS);
+	pcb_res->code_retour = -1;
+	pcb_res->etat = READY;
+	pcb_res->cpsr = 0b101010000;
 }
 
 void
-elect()
+elect(void)
 {
 	// 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;
-}
+	if(current_process == current_process->next)
+	{
+		// il n'y a plus de processus à executer : on termine le kernel
+		terminate_kernel();
+	}
+	else
+	{
+		current_process = current_process->next;
+		current_process->etat = RUNNING;
+	}
+}
+
+void
+start_current_process(void)
+{
+	current_process->fonction_process();
+	sys_exit(0);
+}

Aurel-Hugo/src/sched.h

@@ -7,29 +7,35 @@ typedef int (func_t) (void)	;
 typedef enum {READY, RUNNING, TERMINATED} status;
 struct pcb_s
 {
-	uint32_t registres[13]; 
+	uint32_t registres[13];
+	// lr_user = start_current_process OU = pc où on a fait le yield()
 	func_t* lr_user;
 	func_t* lr_svc;
+	// fonction_process = la fonction à executer par le processus (cf start_current_process)
+	func_t* fonction_process;
 	uint32_t* sp;
-	uint32_t* cpsr;
+	uint32_t cpsr;
 	struct pcb_s* next;
 	struct pcb_s* previous;
 	status etat;
+	int code_retour;
 };
 
 // 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);
+int 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);
-void elect();
+void elect(void);
+//demarre le processus courant, puis appelle sys_exit()
+void start_current_process(void);
 
 #endif

Aurel-Hugo/src/syscall.c

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