From 701b9bf5600d7f6dd70c7f1f096e4da88e204217 Mon Sep 17 00:00:00 2001
From: Florian Lukas <florian.lukas@gmail.com>
Date: Thu, 13 Feb 2014 15:47:36 +0100
Subject: [PATCH] arch: syscalls support up to 3 parameters

syscall() now supports 0-3 parameters, which are all passed in registers.
The option to execute the syscall directly in the IRQ handler has become
a template parameter.

Change-Id: Id939c3317d4eb263098f443b63827b624b4c215f
---
 arch/i386/dispatch.h |  2 +-
 arch/i386/machine.cc |  2 +-
 arch/i386/syscall.cc | 14 ++++++++------
 arch/i386/syscall.h  | 39 +++++++++++++++++++++++++++++++--------
 4 files changed, 41 insertions(+), 16 deletions(-)

diff --git a/arch/i386/dispatch.h b/arch/i386/dispatch.h
index 2237d61..be55edd 100644
--- a/arch/i386/dispatch.h
+++ b/arch/i386/dispatch.h
@@ -84,7 +84,7 @@ public:
 
 	/** \brief Syscall to start idle loop (in ring 0) */
 	static forceinline void idle(void) {
-		syscall(&idle_loop, 0, true);
+		syscall<true>(&idle_loop);
 	}
 
 	/** \brief The idle loop
diff --git a/arch/i386/machine.cc b/arch/i386/machine.cc
index d1a65a8..af8b063 100644
--- a/arch/i386/machine.cc
+++ b/arch/i386/machine.cc
@@ -11,6 +11,6 @@ noinline void __OS_trigger_syscall(uint8_t irq) {
 }
 
 void Machine::trigger_interrupt_from_user(uint8_t irq) {
-	arch::syscall(__OS_trigger_syscall, irq, true);
+	arch::syscall<true>(__OS_trigger_syscall, irq);
 }
 
diff --git a/arch/i386/syscall.cc b/arch/i386/syscall.cc
index 7a92815..5ce6072 100644
--- a/arch/i386/syscall.cc
+++ b/arch/i386/syscall.cc
@@ -15,10 +15,10 @@ namespace arch {
 IRQ_HANDLER(IRQ_SYSCALL) {
 	// get arguments from registers
 	// also, store pointer to context in %esi before we change %esp
-	uint32_t fun, arg;
+	uint32_t fun, arg1, arg2, arg3;
 	bool direct;
 	cpu_context* ctx;
-	asm volatile("leal -4(%%esp), %0" : "=r"(ctx), "=c"(arg), "=b"(fun), "=d"(direct));
+	asm volatile("leal -4(%%esp), %0" : "=r"(ctx), "=c"(arg1), "=a"(arg2), "=D"(arg3), "=b"(fun), "=d"(direct));
 
 	// TODO: remove/reuse pushed CPU context?
 
@@ -42,13 +42,15 @@ IRQ_HANDLER(IRQ_SYSCALL) {
 			save_sp = 0; // for detecting bugs, not stricly neccessary
 		}
 
-		// put syscall argument on top kernel stack
+		// put syscall arguments on top kernel stack
 		uint32_t* sp = (uint32_t*) (&_estack_os - 2048);
-		*sp = arg;
+		*sp = arg3;
+		*(sp-1) = arg2;
+		*(sp-2) = arg1;
 
 		// push the syscall stack address/segment
 		Machine::push(GDT::USER_DATA_SEGMENT | 0x3); // push stack segment, DPL3
-		Machine::push((uint32_t)(sp) - 4); // push stack pointer above argument
+		Machine::push((uint32_t)(sp-3)); // push stack pointer above argument
 
 		// push flags, IO privilege level 3
 		Machine::push(ctx->eflags | 0x3000);
@@ -74,7 +76,7 @@ IRQ_HANDLER(IRQ_SYSCALL) {
 		// call syscall function with argument
 		// C code does not work as compiler overwrites our return address with arg
 		//void (* f)(uint32_t) = (void (*)(uint32_t))fun; f(arg);
-		asm volatile("push %0; call *%1; pop %0" :: "r"(arg), "r"(fun));
+		asm volatile("push %3; push %2; push %1; call *%0; pop %1; pop %2; pop %3" :: "r"(fun), "r"(arg1), "r"(arg2), "r"(arg3));
 
 		// restore page directory
 		asm volatile("mov %0, %%cr3" :: "S"(pd));
diff --git a/arch/i386/syscall.h b/arch/i386/syscall.h
index a21b9e8..970732f 100644
--- a/arch/i386/syscall.h
+++ b/arch/i386/syscall.h
@@ -13,29 +13,52 @@
 
 namespace arch {
 
+/**@{*/
 /** \brief Run specified function as syscall
  *
  * Currently, any function can be called this way. Eventually, this will be replaced
  * by an (encoded) index to a static jumptable of syscalls
  *
  * \param fun syscall function to be called
- * \param arg (optional) argument for syscall
- * \param direct execute syscall directly in IRQ handler instead of userspace (default: false)
+ * \param arg1 (optional) argument for syscall
+ * \param arg2 (optional) argument for syscall
+ * \param arg3 (optional) argument for syscall
+ * \tparam direct execute syscall directly in IRQ handler instead of userspace (default: false)
  */
-template<typename F, typename A=int>
-forceinline void syscall(F fun, A arg=0, bool direct=false) {
-	// save all registers and call syscall interrupt
-	//asm volatile("pusha; int %0; popa" :: "i"(IRQ_SYSCALL), "b"(fun), "c"(*((uint32_t*)&arg)));
-
+template<bool direct=false, typename F>
+forceinline void syscall(F fun) {
 	// use clobber instead of pusha to save and restore only required registers:
 	// gcc documentation says to list modified input in outputs and they must not be included
 	// in clobber list, but LLVM works only the other way ...
-	asm volatile("int %0" :: "i"(IRQ_SYSCALL), "b"(fun), "c"(*((uint32_t*)&arg)), "d"(direct) :
+	asm volatile("int %0" :: "i"(IRQ_SYSCALL), "b"(fun), "d"(direct) :
+		"ebx", "ecx", "eax", "edx", "ebp", "esi", "edi", "cc", "memory");
+}
+
+template<bool direct=false, typename F, typename A>
+forceinline void syscall(F fun, A arg1) {
+	asm volatile("int %0" :: "i"(IRQ_SYSCALL), "b"(fun), "c"(*((uint32_t*)&arg1)), "d"(direct) :
 		"ebx", "ecx", "eax", "edx", "ebp", "esi", "edi", "cc", "memory");
 }
 
+template<bool direct=false, typename F, typename A, typename B>
+forceinline void syscall(F fun, A arg1, B arg2) {
+	asm volatile("int %0" :: "i"(IRQ_SYSCALL), "b"(fun), "c"(*((uint32_t*)&arg1)), "d"(direct),
+		"a"(*((uint32_t*)&arg2)) :
+		"ebx", "ecx", "eax", "edx", "ebp", "esi", "edi", "cc", "memory");
+}
+
+template<bool direct=false, typename F, typename A, typename B, typename C>
+forceinline void syscall(F fun, A arg1, B arg2, C arg3) {
+	asm volatile("int %0" :: "i"(IRQ_SYSCALL), "b"(fun), "c"(*((uint32_t*)&arg1)), "d"(direct),
+		"a"(*((uint32_t*)&arg2)), "D"(*((uint32_t*)&arg3)) :
+		"ebx", "ecx", "eax", "edx", "ebp", "esi", "edi", "cc", "memory");
+}
+
+/**@}*/
+
 /** \brief Return true if calling code is running as part of a syscall */
 forceinline bool in_syscall() {
+	// TODO: determine using some (encoded) system variable instead of hardware register?
 	return (LAPIC::get_task_prio() == 128);
 }
 
-- 
GitLab