Add sys_send_event() (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 17 Feb 2017 19:04:53 +0000 (14:04 -0500)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 17 Feb 2017 19:04:53 +0000 (14:04 -0500)
This syscall sends an event message to a specific event queue.  Given that
it's all in the user's shared memory, I didn't make a version of this that
works between processes.  Without a way for the target process to specify
the ev_q pointer, (such as the the kernel_events array), it seems extremely
dangerous to do IPC with this.

It's actually possible for userspace to post messages to its mboxes, under
certain circumstances.  In the future, I might have a parlib function that
tries that and falls back to the kernel for the cases where the user could
not do it.

Reinstall your kernel headers.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/include/ros/bits/syscall.h
kern/src/syscall.c
tests/strace.c
user/parlib/include/parlib/parlib.h
user/parlib/syscall.c

index a5883b2..23384c5 100644 (file)
@@ -41,6 +41,7 @@
 #define SYS_nanosleep                          36
 #define SYS_pop_ctx                                    37
 #define SYS_vmm_poke_guest                     38
+#define SYS_send_event                         39
 
 /* FS Syscalls */
 #define SYS_read                               100
index 6297b9d..b516568 100644 (file)
@@ -1314,6 +1314,19 @@ static int sys_self_notify(struct proc *p, uint32_t vcoreid,
        return 0;
 }
 
+static int sys_send_event(struct proc *p, struct event_queue *ev_q,
+                          struct event_msg *u_msg, uint32_t vcoreid)
+{
+       struct event_msg local_msg = {0};
+
+       if (memcpy_from_user(p, &local_msg, u_msg, sizeof(struct event_msg))) {
+               set_errno(EINVAL);
+               return -1;
+       }
+       send_event(p, ev_q, &local_msg, vcoreid);
+       return 0;
+}
+
 /* Puts the calling core into vcore context, if it wasn't already, via a
  * self-IPI / active notification.  Barring any weird unmappings, we just send
  * ourselves a __notify. */
@@ -2525,6 +2538,7 @@ const struct sys_table_entry syscall_table[] = {
        [SYS_provision] = {(syscall_t)sys_provision, "provision"},
        [SYS_notify] = {(syscall_t)sys_notify, "notify"},
        [SYS_self_notify] = {(syscall_t)sys_self_notify, "self_notify"},
+       [SYS_send_event] = {(syscall_t)sys_send_event, "send_event"},
        [SYS_vc_entry] = {(syscall_t)sys_vc_entry, "vc_entry"},
        [SYS_halt_core] = {(syscall_t)sys_halt_core, "halt_core"},
 #ifdef CONFIG_ARSC_SERVER
index ab2d798..f693009 100644 (file)
@@ -194,6 +194,7 @@ static struct trace_set proc_trace_set = { "proc",
         SYS_change_vcore,
         SYS_notify,
         SYS_self_notify,
+        SYS_send_event,
         SYS_vc_entry,
         SYS_halt_core,
         SYS_pop_ctx,
index 4009fb4..3581e5c 100644 (file)
@@ -46,6 +46,8 @@ int                   sys_provision(int pid, unsigned int res_type, long res_val);
 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, bool priv);
+int         sys_send_event(struct event_queue *ev_q, struct event_msg *ev_msg,
+                           uint32_t vcoreid);
 int         sys_halt_core(unsigned long usec);
 void*          sys_init_arsc();
 int         sys_block(unsigned long usec);
index 0307d1b..8c61542 100644 (file)
@@ -83,6 +83,12 @@ int sys_self_notify(uint32_t vcoreid, unsigned int ev_type,
        return ros_syscall(SYS_self_notify, vcoreid, ev_type, u_msg, priv, 0, 0);
 }
 
+int sys_send_event(struct event_queue *ev_q, struct event_msg *ev_msg,
+                   uint32_t vcoreid)
+{
+       return syscall(SYS_send_event, ev_q, ev_msg, vcoreid);
+}
+
 int sys_halt_core(unsigned long usec)
 {
        return ros_syscall(SYS_halt_core, usec, 0, 0, 0, 0, 0);