All user events take a void *data
authorBarret Rhoden <brho@cs.berkeley.edu>
Tue, 3 Jun 2014 01:11:18 +0000 (18:11 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Tue, 3 Jun 2014 01:51:57 +0000 (18:51 -0700)
For upcoming event handler registration.

13 files changed:
tests/alarm.c
tests/lock_test.c
tests/mhello.c
tests/old/syscall.c
user/benchutil/alarm.c
user/benchutil/alarm_dispatch.c
user/benchutil/pvcalarm.c
user/parlib/event.c
user/parlib/include/event.h
user/parlib/include/uthread.h
user/parlib/signal.c
user/parlib/uthread.c
user/pthread/pthread.c

index b86f4ae..4ab4447 100644 (file)
@@ -20,7 +20,8 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 
-static void handle_alarm(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_alarm(struct event_msg *ev_msg, unsigned int ev_type,
+                         void *data)
 {
        assert(ev_type == EV_ALARM);
        printf("\tAlarm fired!, id %d\n", ev_msg ? ev_msg->ev_arg2 : 55555);
index 8eb2310..b3d45a4 100644 (file)
@@ -605,22 +605,24 @@ atomic_t indir_idx;
 atomic_t preempt_cnt;
 atomic_t indir_cnt;
 
-static void handle_preempt(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_preempt(struct event_msg *ev_msg, unsigned int ev_type,
+                           void *data)
 {
        unsigned long my_slot = atomic_fetch_and_add(&preempt_idx, 1);
        if (my_slot < MAX_NR_EVENT_TRACES)
                preempts[my_slot] = read_tsc();
        atomic_inc(&preempt_cnt);
-       handle_vc_preempt(ev_msg, ev_type);
+       handle_vc_preempt(ev_msg, ev_type, data);
 }
 
-static void handle_indir(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_indir(struct event_msg *ev_msg, unsigned int ev_type,
+                         void *data)
 {
        unsigned long my_slot = atomic_fetch_and_add(&indir_idx, 1);
        if (my_slot < MAX_NR_EVENT_TRACES)
                indirs[my_slot] = read_tsc();
        atomic_inc(&indir_cnt);
-       handle_vc_indir(ev_msg, ev_type);
+       handle_vc_indir(ev_msg, ev_type, data);
 }
 
 /* Helper, prints out the preempt trace */
index 1006efa..370f47b 100644 (file)
@@ -19,7 +19,8 @@ __thread int temp;
 void *core0_tls = 0;
 
 struct event_queue *indirect_q;
-static void handle_generic(struct event_msg *ev_msg, unsigned int ev_type);
+static void handle_generic(struct event_msg *ev_msg, unsigned int ev_type,
+                           void *data);
 
 void ghetto_vcore_entry(void);
 
@@ -132,7 +133,8 @@ int main(int argc, char** argv)
        return 0;
 }
 
-static void handle_generic(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_generic(struct event_msg *ev_msg, unsigned int ev_type,
+                           void *data)
 {
        printf("Got event type %d on vcore %d\n", ev_type, vcore_id());
 }
index 9548798..c64370d 100644 (file)
@@ -9,7 +9,8 @@
 
 /* Deprecated, don't use this in any serious way */
 
-static void handle_syscall(struct event_msg *ev_msg, unsigned int ev_type);
+static void handle_syscall(struct event_msg *ev_msg, unsigned int ev_type,
+                           void *data);
 struct syscall sysc = {0};
 struct event_queue *ev_q;
 void ghetto_vcore_entry(void);
@@ -88,7 +89,8 @@ int main(int argc, char** argv)
        return 0;
 }
 
-static void handle_syscall(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_syscall(struct event_msg *ev_msg, unsigned int ev_type,
+                           void *data)
 {
        struct syscall *my_sysc;
        if (!ev_msg)
index eb6737e..753dd4d 100644 (file)
@@ -49,7 +49,8 @@ static bool __tc_unset_alarm(struct timer_chain *tchain,
 static void __tc_reset_alarm_abs(struct timer_chain *tchain,
                                  struct alarm_waiter *waiter,
                                  uint64_t abs_time);
-static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type);
+static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type,
+                              void *data);
 
 /* One chain to rule them all. */
 struct timer_chain global_tchain;
@@ -282,7 +283,8 @@ static void __trigger_tchain(struct timer_chain *tchain)
        spin_pdr_unlock(&tchain->lock);
 }
 
-static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type,
+                              void *data)
 {
        assert(ev_type == EV_ALARM);
        if (ev_msg && (ev_msg->ev_arg2 == global_tchain.alarmid))
index d34d5fb..0ce7e97 100644 (file)
@@ -21,7 +21,8 @@ struct {
 } dispatch;
 
 /* Dispatch the alarm event to its proper handler */
-static void dispatch_alarm(struct event_msg *ev_msg, unsigned int ev_type)
+static void dispatch_alarm(struct event_msg *ev_msg, unsigned int ev_type,
+                           void *data)
 {
        assert(ev_type == EV_ALARM);
        if (ev_msg) {
@@ -29,7 +30,7 @@ static void dispatch_alarm(struct event_msg *ev_msg, unsigned int ev_type)
                // deregistering its handler.  Make sure you do this properly.
                handle_event_t handler = dispatch.handlers[ev_msg->ev_arg2];
                if (handler)
-                       handler(ev_msg, ev_type);
+                       handler(ev_msg, ev_type, data);
        }
 }
 
index 91b62c0..6acb89d 100644 (file)
@@ -42,7 +42,7 @@ struct pvcalarm {
 
        atomic_t state;
        int busy_count;
-       void (*handler) (struct event_msg *ev_msg, unsigned int ev_type);
+       handle_event_t handler;
        struct pvcalarm_data *data;
 };
 
@@ -52,9 +52,12 @@ static struct pvcalarm global_pvcalarm = { .state = (void*)S_DISABLED };
 
 /* Helper functions */
 static void init_pvcalarm(struct pvcalarm_data *pvcalarm_data, int vcoreid);
-static void handle_pvcalarm(struct event_msg *ev_msg, unsigned int ev_type);
-static void handle_alarm_real(struct event_msg *ev_msg, unsigned int ev_type);
-static void handle_alarm_prof(struct event_msg *ev_msg, unsigned int ev_type);
+static void handle_pvcalarm(struct event_msg *ev_msg, unsigned int ev_type,
+                            void *data);
+static void handle_alarm_real(struct event_msg *ev_msg, unsigned int ev_type,
+                              void *data);
+static void handle_alarm_prof(struct event_msg *ev_msg, unsigned int ev_type,
+                              void *data);
 
 /* Initialize the pvcalarm service. Only call this function once */
 static int init_global_pvcalarm()
@@ -253,16 +256,18 @@ static inline void __vcore_postamble()
 /* The global handler function.  It simply calls the proper underlying handler
  * function depending on whether the service is set for the REAL or PERF
  * policy. */
-static void handle_pvcalarm(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_pvcalarm(struct event_msg *ev_msg, unsigned int ev_type,
+                            void *data)
 {
        if (!__vcore_preamble()) return;
-       global_pvcalarm.handler(ev_msg, ev_type);
+       global_pvcalarm.handler(ev_msg, ev_type, data);
        __vcore_postamble();
 }
 
 /* The pvcalarm handler for the REAL policy.  Simply call the registered
  * callback and restart the interval alarm. */
-static void handle_alarm_real(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_alarm_real(struct event_msg *ev_msg, unsigned int ev_type,
+                              void *data)
 {
        global_pvcalarm.callback();
        start_pvcalarm(&global_pvcalarm.data[vcore_id()], global_pvcalarm.interval);
@@ -272,7 +277,8 @@ static void handle_alarm_real(struct event_msg *ev_msg, unsigned int ev_type)
  * has been offline.  Only when the uptime since the last interval is equal to
  * the interval time do we run the callback function.  Otherwise we restart the
  * alarm to make up the difference. */
-static void handle_alarm_prof(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_alarm_prof(struct event_msg *ev_msg, unsigned int ev_type,
+                              void *data)
 { 
        int vcoreid = vcore_id();
        struct pvcalarm_data *pvcalarm_data = &global_pvcalarm.data[vcoreid];
index c5bf0f4..aaf7595 100644 (file)
@@ -181,7 +181,7 @@ int handle_one_mbox_msg(struct event_mbox *ev_mbox)
        assert(ev_type < MAX_NR_EVENT);
        printd("[event] UCQ (mbox %08p), ev_type: %d\n", ev_mbox, ev_type);
        if (ev_handlers[ev_type])
-               ev_handlers[ev_type](&local_msg, ev_type);
+               ev_handlers[ev_type](&local_msg, ev_type, 0);
        return 1;
 }
 
@@ -195,7 +195,7 @@ int handle_mbox(struct event_mbox *ev_mbox)
        void bit_handler(unsigned int bit) {
                printd("[event] Bit: ev_type: %d\n", bit);
                if (ev_handlers[bit])
-                       ev_handlers[bit](0, bit);
+                       ev_handlers[bit](0, bit, 0);
                retval = 1;
                /* Consider checking the queue for incoming messages while we're here */
        }
@@ -228,7 +228,7 @@ bool mbox_is_empty(struct event_mbox *ev_mbox)
 }
 
 /* The EV_EVENT handler - extract the ev_q from the message. */
-void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type)
+void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type, void *data)
 {
        struct event_queue *ev_q;
        /* EV_EVENT can't handle not having a message / being a bit.  If we got a
index 63d1176..a785fe2 100644 (file)
@@ -29,10 +29,11 @@ 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) */
-typedef void (*handle_event_t)(struct event_msg *ev_msg, unsigned int ev_type);
+typedef void (*handle_event_t)(struct event_msg *ev_msg, unsigned int ev_type,
+                               void *data);
 extern handle_event_t ev_handlers[];
 /* Default event handlers */
-void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type);
+void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type, void *data);
 
 int handle_events(uint32_t vcoreid);
 void handle_event_q(struct event_queue *ev_q);
index 8bb9155..d52596a 100644 (file)
@@ -91,8 +91,10 @@ void run_uthread(struct uthread *uthread);
 static inline struct uthread **get_cur_uth_addr(uint32_t vcoreid);
 
 /* 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);
+void handle_vc_preempt(struct event_msg *ev_msg, unsigned int ev_type,
+                       void *data);
+void handle_vc_indir(struct event_msg *ev_msg, unsigned int ev_type,
+                     void *data);
 
 /* Asking for trouble with this API, when we just want stacktop (or whatever
  * the SP will be). */
index 60ead50..bda3a5e 100644 (file)
@@ -140,7 +140,8 @@ void trigger_posix_signal(int sig_nr, struct siginfo *info, void *aux)
 /* This is the catch all akaros event->posix signal handler.  All posix signals
  * are received in a single akaros event type.  They are then dispatched from
  * this function to their proper posix signal handler */
-static void handle_event(struct event_msg *ev_msg, unsigned int ev_type)
+static void handle_event(struct event_msg *ev_msg, unsigned int ev_type,
+                         void *data)
 {
        int sig_nr;
        struct siginfo info = {0};
index 438655e..9ff0cef 100644 (file)
@@ -836,7 +836,8 @@ out_we_returned:
 
 /* This handles a preemption message.  When this is done, either we recovered,
  * or recovery *for our message* isn't needed. */
-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,
+                       void *data)
 {
        uint32_t vcoreid = vcore_id();
        struct preempt_data *vcpd = vcpd_of(vcoreid);
@@ -935,7 +936,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. */
-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, void *data)
 {
        uint32_t vcoreid = vcore_id();
        uint32_t rem_vcoreid = ev_msg->ev_arg2;
index 2cd0e16..56cc8ea 100644 (file)
@@ -48,7 +48,8 @@ void pth_preempt_pending(void);
 void pth_spawn_thread(uintptr_t pc_start, void *data);
 
 /* Event Handlers */
-static void pth_handle_syscall(struct event_msg *ev_msg, unsigned int ev_type);
+static void pth_handle_syscall(struct event_msg *ev_msg, unsigned int ev_type,
+                               void *data);
 
 struct schedule_ops pthread_sched_ops = {
        pth_sched_entry,
@@ -226,7 +227,8 @@ static void restart_thread(struct syscall *sysc)
 
 /* This handler is usually run in vcore context, though I can imagine it being
  * called by a uthread in some other threading library. */
-static void pth_handle_syscall(struct event_msg *ev_msg, unsigned int ev_type)
+static void pth_handle_syscall(struct event_msg *ev_msg, unsigned int ev_type,
+                               void *data)
 {
        struct syscall *sysc;
        assert(in_vcore_context());