Fixes slab page allocators
[akaros.git] / user / parlib / syscall.c
index 941fc21..10f46bb 100644 (file)
@@ -1,6 +1,7 @@
 // System call stubs.
 
 #include <parlib.h>
+#include <vcore.h>
 
 int sys_proc_destroy(int pid, int exitcode)
 {
@@ -12,9 +13,9 @@ int sys_getpid(void)
         return ros_syscall(SYS_getpid, 0, 0, 0, 0, 0, 0);
 }
 
-size_t sys_getcpuid(void)
+size_t sys_getpcoreid(void)
 {
-        return ros_syscall(SYS_getcpuid, 0, 0, 0, 0, 0, 0);
+        return ros_syscall(SYS_getpcoreid, 0, 0, 0, 0, 0, 0);
 }
 
 ssize_t sys_cputs(const uint8_t *s, size_t len)
@@ -75,12 +76,6 @@ ssize_t sys_eth_read(void* buf, size_t len)
        return ros_syscall(SYS_eth_read, buf, len, 0, 0, 0, 0);
 }
 
-/* Request resources from the kernel.  Flags in ros/resource.h. */
-ssize_t sys_resource_req(int type, size_t amt_max, size_t amt_min, uint32_t flags)
-{
-       return ros_syscall(SYS_resource_req, type, amt_max, amt_min, flags, 0, 0);
-}
-
 void sys_reboot(void)
 {
        ros_syscall(SYS_reboot, 0, 0, 0, 0, 0, 0);
@@ -118,9 +113,9 @@ int sys_notify(int pid, unsigned int ev_type, struct event_msg *u_msg)
 }
 
 int sys_self_notify(uint32_t vcoreid, unsigned int ev_type,
-                    struct event_msg *u_msg)
+                    struct event_msg *u_msg, bool priv)
 {
-       return ros_syscall(SYS_self_notify, vcoreid, ev_type, u_msg, 0, 0, 0);
+       return ros_syscall(SYS_self_notify, vcoreid, ev_type, u_msg, priv, 0, 0);
 }
 
 int sys_halt_core(unsigned int usec)
@@ -131,5 +126,63 @@ int sys_halt_core(unsigned int usec)
 void* sys_init_arsc()
 {
        return (void*)ros_syscall(SYS_init_arsc, 0, 0, 0, 0, 0, 0);
-       return (void*)ros_syscall(SYS_init_arsc, 0, 0, 0, 0, 0);
+}
+
+int sys_block(unsigned int usec)
+{
+       return ros_syscall(SYS_block, usec, 0, 0, 0, 0, 0);
+}
+
+/* enable_my_notif tells the kernel whether or not it is okay to turn on notifs
+ * when our calling vcore 'yields'.  This controls whether or not the vcore will
+ * get started from vcore_entry() or not, and whether or not remote cores need
+ * to sys_change_vcore to preempt-recover the calling vcore.  Only set this to
+ * FALSE if you are unable to handle starting fresh at vcore_entry().  One
+ * example of this is in mcs_pdr_locks.
+ *
+ * Will return:
+ *             0 if we successfully changed to the target vcore.
+ *             -EBUSY if the target vcore is already mapped (a good kind of failure)
+ *             -EAGAIN if we failed for some other reason and need to try again.  For
+ *             example, the caller could be preempted, and we never even attempted to
+ *             change.
+ *             -EINVAL some userspace bug */
+int sys_change_vcore(uint32_t vcoreid, bool enable_my_notif)
+{
+       /* Since we might be asking to start up on a fresh stack (if
+        * enable_my_notif), we need to use some non-stack memory for the struct
+        * sysc.  Our vcore could get restarted before the syscall finishes (after
+        * unlocking the proc, before finish_sysc()), and the act of finishing would
+        * write onto our stack.  Thus we use the per-vcore struct. */
+       int flags;
+       /* Need to wait while a previous syscall is not done or locked.  Since this
+        * should only be called from VC ctx, we'll just spin.  Should be extremely
+        * rare.  Note flags is initialized to SC_DONE. */
+       do {
+               cpu_relax();
+               flags = atomic_read(&__vcore_one_sysc.flags);
+       } while (!(flags & SC_DONE) || flags & SC_K_LOCK);
+       __vcore_one_sysc.num = SYS_change_vcore;
+       __vcore_one_sysc.arg0 = vcoreid;
+       __vcore_one_sysc.arg1 = enable_my_notif;
+       /* keep in sync with glibc sysdeps/ros/syscall.c */
+       __ros_arch_syscall((long)&__vcore_one_sysc, 1);
+       /* If we returned, either we wanted to (!enable_my_notif) or we failed.
+        * Need to wait til the sysc is finished to find out why.  Again, its okay
+        * to just spin. */
+       do {
+               cpu_relax();
+               flags = atomic_read(&__vcore_one_sysc.flags);
+       } while (!(flags & SC_DONE) || flags & SC_K_LOCK);
+       return __vcore_one_sysc.retval;
+}
+
+int sys_change_to_m(void)
+{
+       return ros_syscall(SYS_change_to_m, 0, 0, 0, 0, 0, 0);
+}
+
+int sys_poke_ksched(int res_type)
+{
+       return ros_syscall(SYS_poke_ksched, res_type, 0, 0, 0, 0, 0);
 }