SCPs can sleep on events (XCC)
[akaros.git] / kern / src / syscall.c
index 0386bf9..d1beec4 100644 (file)
@@ -24,7 +24,6 @@
 #include <syscall.h>
 #include <kmalloc.h>
 #include <stdio.h>
-#include <resource.h>
 #include <frontend.h>
 #include <colored_caches.h>
 #include <hashtable.h>
@@ -74,8 +73,8 @@ static void finish_sysc(struct syscall *sysc, struct proc *p)
 
 /* Helper that "finishes" the current async syscall.  This should be used when
  * we are calling a function in a syscall that might not return and won't be
- * able to use the normal syscall return path, such as proc_yield() and
- * resource_req().  Call this from within syscall.c (I don't want it global).
+ * able to use the normal syscall return path, such as proc_yield().  Call this
+ * from within syscall.c (I don't want it global).
  *
  * It is possible for another user thread to see the syscall being done early -
  * they just need to be careful with the weird proc management calls (as in,
@@ -639,16 +638,6 @@ static int sys_shared_page_free(env_t* p1, void*DANGEROUS addr, pid_t p2)
        return -1;
 }
 
-
-static int sys_resource_req(struct proc *p, int type, unsigned int amt_wanted,
-                            unsigned int amt_wanted_min, int flags)
-{
-       /* resource_req returns and we'll eventually finish the sysc later.  The
-        * original context may restart on a remote core before we return and
-        * finish, but that's fine thanks to the async kernel interface. */
-       return resource_req(p, type, amt_wanted, amt_wanted_min, flags);
-}
-
 /* Untested.  Will notify the target on the given vcore, if the caller controls
  * the target.  Will honor the target's wanted/vcoreid.  u_ne can be NULL. */
 static int sys_notify(struct proc *p, int target_pid, unsigned int ev_type,
@@ -731,6 +720,40 @@ static int sys_halt_core(struct proc *p, unsigned int usec)
        return 0;
 }
 
+/* Changes a process into _M mode, or -EINVAL if it already is an mcp.
+ * __proc_change_to_m() returns and we'll eventually finish the sysc later.  The
+ * original context may restart on a remote core before we return and finish,
+ * but that's fine thanks to the async kernel interface. */
+static int sys_change_to_m(struct proc *p)
+{
+       int retval = 0;
+       spin_lock(&p->proc_lock);
+       if (!__proc_is_mcp(p)) {
+               /* Catch user bugs */
+               if (!p->procdata->res_req[RES_CORES].amt_wanted) {
+                       printk("[kernel] process needs to specify amt_wanted\n");
+                       p->procdata->res_req[RES_CORES].amt_wanted = 1;
+               }
+               __proc_change_to_m(p);
+               /* Tell the ksched about us */
+               register_mcp(p);
+       } else {
+               set_errno(EINVAL);
+               retval = -1;
+       }
+       spin_unlock(&p->proc_lock);
+       return retval;
+}
+
+/* Not sure what people will need.  For now, they can send in the resource they
+ * want.  Up to the ksched to support this, and other things (like -1 for all
+ * resources).  Might have this info go in via procdata instead. */
+static int sys_poke_ksched(struct proc *p, int res_type)
+{
+       poke_ksched(p, res_type);
+       return 0;
+}
+
 /************** Platform Specific Syscalls **************/
 
 //Read a buffer over the serial port
@@ -1330,7 +1353,6 @@ const static struct sys_table_entry syscall_table[] = {
        [SYS_mprotect] = {(syscall_t)sys_mprotect, "mprotect"},
        [SYS_shared_page_alloc] = {(syscall_t)sys_shared_page_alloc, "pa"},
        [SYS_shared_page_free] = {(syscall_t)sys_shared_page_free, "pf"},
-       [SYS_resource_req] = {(syscall_t)sys_resource_req, "resource_req"},
        [SYS_notify] = {(syscall_t)sys_notify, "notify"},
        [SYS_self_notify] = {(syscall_t)sys_self_notify, "self_notify"},
        [SYS_halt_core] = {(syscall_t)sys_halt_core, "halt_core"},
@@ -1347,6 +1369,8 @@ const static struct sys_table_entry syscall_table[] = {
 #ifdef __CONFIG_ARSC_SERVER__
        [SYS_init_arsc] = {(syscall_t)sys_init_arsc, "init_arsc"},
 #endif
+       [SYS_change_to_m] = {(syscall_t)sys_change_to_m, "change_to_m"},
+       [SYS_poke_ksched] = {(syscall_t)sys_poke_ksched, "poke_ksched"},
        [SYS_read] = {(syscall_t)sys_read, "read"},
        [SYS_write] = {(syscall_t)sys_write, "write"},
        [SYS_open] = {(syscall_t)sys_open, "open"},