Modification obtention du intframe.

Corrige #173

kernel/include/interrupts.h

@@ -84,7 +84,10 @@ typedef struct {
 
 } intframe;
 
-#define GET_INTFRAME(stack_ptr) {__asm__ __volatile__("mov (%%ebp), %%eax; mov %%eax, %0" : "=m" (stack_ptr) : :"%eax");}
+// +8 car dans le call de la fonction a empilé l'@ de retour et la fonction a empilé ebp.
+#define GET_INTFRAME(stack_ptr) {__asm__ __volatile__("mov %%ebp, %%eax; add $8, %%eax; mov %%eax, %0" : "=m" (stack_ptr) : :"%eax");}
+// à utiliser après un autre appel de fonction :
+#define GET_INTFRAME2(stack_ptr) {__asm__ __volatile__("mov (%%ebp), %%eax; add $8, %%eax; mov %%eax, %0" : "=m" (stack_ptr) : :"%eax");}
 
 typedef void (*interrupt_handler_t)(int interrupt_id);
 

kernel/interrupts_wrappers.S

@@ -47,15 +47,13 @@
 					pushl $\id
 					leal  interrupts_handler_array,%edi
 					call  *\id*4(%edi)
-					addl  $4, %esp
 
 					.ifeq \id
-					push %ebp
-					mov %esp,%ebp
 					call do_schedule
-					pop %ebp
 					.endif
 
+					addl  $4, %esp
+
                /* La seule difference avec les exceptions : */
                /* Send EOI to PIC. See i8259 datasheet */
                movb $0x20, %al
@@ -136,15 +134,13 @@
 					pushl $\id
 					leal  interrupts_handler_array,%edi
 					call  *\id*4(%edi)
-					addl  $4, %esp
 
 					.ifeq \id-16
-					push %ebp
-					mov %esp,%ebp
 					call do_schedule
-					pop %ebp
 					.endif
 
+					addl  $4, %esp
+
 					pop %es
 					pop %ds
 					pop %fs

kernel/kpanic.c

@@ -217,6 +217,8 @@ static void kpanic_handler(uint32_t error_id, uint32_t error_code)
 	}
 
 	process_t* badboy;
+
+	//XXX: La récupération du stack_ptr est un peu trop moche...
 	uint32_t* stack_ptr;
 	/* récupération du pointeur de pile */
 	asm("mov (%%ebp), %%eax; mov %%eax, %0" : "=m" (stack_ptr) : );

kernel/ksignal.c

@@ -148,29 +148,19 @@ SYSCALL_HANDLER3(sys_kill, int pid, int signum, int* ret)
 
 SYSCALL_HANDLER0(sys_sigret)
 {
-	/* 
-	 * Je met un petit trophée ici, ce code a marche du premier coup
-	 */
-	uint32_t* stack_ptr;
-	/* On récupere un pointeur de pile pour acceder aux registres empilés */
-	GET_INTFRAME(stack_ptr);
-
-	sigframe* sframe;
-	intframe* iframe;
-	process_t* current = get_current_process();
-
 	/* On récupère les données empilées par l'interruption */
 	/* Le but ici est de remplacer ces valeurs par celles stockées dans la sigframe, 
 	 * de cette manière l'iret à la fin de l'interruption restaurera le contexte du processus */
-	iframe = (intframe*) (stack_ptr+2); /* XXX le "+4" a été déduis, pas très safe, faudrait chercher pourquoi */
-
-	/* On récupère les données empilées avant le signal. */
-
+	intframe* iframe;
+	GET_INTFRAME2(iframe);
+
+	process_t* current = get_current_process();
+
 	/* A la fin du handler, on pop l'adresse de retour, puis on pop eax, 
 	 * esp se retrouve donc à +8 par rapport à la stack frame du signal, 
 	 * on va donc chercher cette frame à esp-8
 	 */	
-	sframe = (sigframe*) (iframe->esp-8);
+	sigframe* sframe = (sigframe*) (iframe->esp-8);
 
 
 	iframe->eax = sframe->context.eax;

kernel/ksyscall.c

@@ -54,12 +54,11 @@ void syscall_entry()
 	process->sig_interruptable = 0;
 	uint32_t function, param1, param2, param3;
 	syscall_handler_t handler;
+
+	/* Récupération des données empilées par l'interruption*/
 	intframe* frame;
+	GET_INTFRAME(frame);
 
-	/* Récupération des données empilées par l'interruption*/
-	uint32_t ebp;
-	asm volatile("mov %%ebp, %0" : "=r" (ebp));
-	frame = (intframe*) (ebp + 8);
 	function = frame->eax;
 	param1 = frame->ebx;
 	param2 = frame->ecx;

kernel/scheduler.c

@@ -224,7 +224,7 @@ void do_schedule()
 	/* On récupere un pointeur de pile pour acceder aux registres empilés
 	 * C'est fait au début pour éviter de toucher à ebp.
 	 * */
-	uint32_t* stack_ptr;
+	intframe* stack_ptr;
 	GET_INTFRAME(stack_ptr);
 
 	/* On met le contexte dans la structure "process"*/
@@ -239,7 +239,7 @@ void do_schedule()
 			/* On regarde si le process a des signaux en attente */
 			if (signal_pending(next) && current == next) {
 				// backup de current pour éviter de mettre dans sigframe de vieilles données.
-				copy_context_current(current, (intframe*)(stack_ptr));
+				copy_context_current(current, stack_ptr);
 			}
 			exec_signal = exec_sighandler(next);
 		} else if (next->state == PROCSTATE_WAITING || next->state == PROCSTATE_SUSPENDED) {
@@ -258,7 +258,7 @@ void do_schedule()
 
 	/* On fait une copie du contexte du processus actuel uniquement si il a déja été lancé */
 	if (current != idle_process && current != next && current->state != PROCSTATE_IDLE) {
-		copy_context_current(current, (intframe*)(stack_ptr));
+		copy_context_current(current, stack_ptr);
 	}
 
 	/* Si le processus courant n'a pas encore commencé son exécution, on le lance */
@@ -384,8 +384,7 @@ void force_immediate_resched() {
 			"push %ds \n\t"
 			"push %es \n\t"
 
-			"push %ebp \n\t"
-			"mov %esp,%ebp \n\t"
+			"push $0 \n\t"
 			"call do_schedule \n"
 			"add $64, %esp \n\t"
 			"fin_force_immediate_resched:"