Removes redundant event handler, exposes others
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 3 May 2013 23:46:40 +0000 (16:46 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 3 May 2013 23:46:40 +0000 (16:46 -0700)
The old handler wasn't being used - was overwritten by uthread code.
The main difference is that the uthread handler knows how to deal with
the CAN_RCV_MSG flag.

This also exposes the uthread's preemption/indir handlers, so that
applications can wrap the handlers with their own handlers.

user/parlib/event.c
user/parlib/include/event.h
user/parlib/include/uthread.h
user/parlib/uthread.c

index ab17d88..c5bf0f4 100644 (file)
@@ -167,7 +167,6 @@ unsigned int get_event_type(struct event_mbox *ev_mbox)
 /* List of handlers, process-wide, that the 2LS should fill in.  They all must
  * return (don't context switch to a u_thread) */
 handle_event_t ev_handlers[MAX_NR_EVENT] = {[EV_EVENT] handle_ev_ev,
-                                            [EV_CHECK_MSGS] handle_check_msgs,
                                             0};
 
 /* Attempts to handle a message.  Returns 1 if we dequeued a msg, 0 o/w. */
@@ -249,25 +248,6 @@ void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type)
        handle_event_q(ev_q);
 }
 
-/* This handler tells us to check the public message box of a vcore. */
-void handle_check_msgs(struct event_msg *ev_msg, unsigned int ev_type)
-{
-       uint32_t rem_vcoreid;
-       assert(ev_msg);
-       rem_vcoreid = ev_msg->ev_arg2;
-       printd("[event] handle check msgs for VC %d on VC %d\n", rem_vcoreid,
-              vcore_id());
-       /* if it is a message for ourselves, then we can abort.  Vcores will check
-        * their own messages via handle_events() (which either we're doing now, or
-        * will do when we are done dealing with another vcore's mbox). */
-       if (rem_vcoreid == vcore_id())
-               return;
-       /* they should have had their can_rcv turned off at some point, though it is
-        * possible that it was turned back on by now.  we don't really care - our
-        * job is to make sure their messages get checked. */
-       handle_vcpd_mbox(rem_vcoreid);
-}
-
 /* Attempts to handle events, if notif_pending.  The kernel always sets
  * notif_pending after posting a message to either public or private mailbox.
  * When this returns, as far as we are concerned, notif_pending is FALSE.
index 41f2321..63d1176 100644 (file)
@@ -33,7 +33,6 @@ typedef void (*handle_event_t)(struct event_msg *ev_msg, unsigned int ev_type);
 extern handle_event_t ev_handlers[];
 /* Default event handlers */
 void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type);
-void handle_check_msgs(struct event_msg *ev_msg, unsigned int ev_type);
 
 int handle_events(uint32_t vcoreid);
 void handle_event_q(struct event_queue *ev_q);
index d195cbb..7ccfbfa 100644 (file)
@@ -78,6 +78,10 @@ void highjack_current_uthread(struct uthread *uthread);
 void run_current_uthread(void);
 void run_uthread(struct uthread *uthread);
 
+/* Event handlers - exported globally so programs can wrap them */
+void handle_vc_preempt(struct event_msg *ev_msg, unsigned int ev_type);
+void handle_vc_indir(struct event_msg *ev_msg, unsigned int ev_type);
+
 /* Asking for trouble with this API, when we just want stacktop (or whatever
  * the SP will be). */
 static inline void init_uthread_ctx(struct uthread *uth, void (*entry)(void),
index 21ac6d0..867bba7 100644 (file)
@@ -21,8 +21,6 @@ static int __uthread_allocate_tls(struct uthread *uthread);
 static int __uthread_reinit_tls(struct uthread *uthread);
 static void __uthread_free_tls(struct uthread *uthread);
 static void __run_current_uthread_raw(void);
-static void handle_vc_preempt(struct event_msg *ev_msg, unsigned int ev_type);
-static void handle_vc_indir(struct event_msg *ev_msg, unsigned int ev_type);
 
 /* Block the calling uthread on sysc until it makes progress or is done */
 static void __ros_mcp_syscall_blockon(struct syscall *sysc);
@@ -733,7 +731,7 @@ out_we_returned:
 
 /* This handles a preemption message.  When this is done, either we recovered,
  * or recovery *for our message* isn't needed. */
-static void handle_vc_preempt(struct event_msg *ev_msg, unsigned int ev_type)
+void handle_vc_preempt(struct event_msg *ev_msg, unsigned int ev_type)
 {
        uint32_t vcoreid = vcore_id();
        struct preempt_data *vcpd = vcpd_of(vcoreid);
@@ -837,7 +835,7 @@ out_stealing:
  * their indirs, or the vcore restarted enough so that checking them is
  * unnecessary.  If that happens and they got preempted quickly, then another
  * preempt/check_indirs was sent out. */
-static void handle_vc_indir(struct event_msg *ev_msg, unsigned int ev_type)
+void handle_vc_indir(struct event_msg *ev_msg, unsigned int ev_type)
 {
        uint32_t vcoreid = vcore_id();
        uint32_t rem_vcoreid = ev_msg->ev_arg2;