Specify an mbox type when getting an event queue
[akaros.git] / user / parlib / include / event.h
index 7dc164e..23f765b 100644 (file)
@@ -1,40 +1,84 @@
-/* Copyright (c) 2011 The Regents of the University of California
+/* Copyright (c) 2011-2014 The Regents of the University of California
+ * Copyright (c) 2015 Google Inc
  * Barret Rhoden <brho@cs.berkeley.edu>
  * See LICENSE for details.
  *
  * Userspace utility functions for receiving events and notifications (IPIs).
  * Some are higher level than others; just use what you need. */ 
 
-#ifndef _EVENT_H
-#define _EVENT_H
+#ifndef PARLIB_EVENT_H
+#define PARLIB_EVENT_H
 
 #include <ros/event.h>
 #include <ros/common.h>
 
+__BEGIN_DECLS
+
 /********* Event_q Setup / Registration  ***********/
-struct event_queue *get_big_event_q(void);
+struct event_queue *get_big_event_q_raw(void);
+struct event_queue *get_big_event_q(int mbox_type);
+void event_mbox_init(struct event_mbox *ev_mbox, int mbox_type);
+void put_big_event_q_raw(struct event_queue *ev_q);
 void put_big_event_q(struct event_queue *ev_q);
+void event_mbox_cleanup(struct event_mbox *ev_mbox);
 struct event_queue *get_event_q(void);
-struct event_queue *get_event_q_vcpd(uint32_t vcoreid);
+struct event_queue *get_event_q_vcpd(uint32_t vcoreid, int ev_flags);
 void put_event_q(struct event_queue *ev_q);
 void register_kevent_q(struct event_queue *ev_q, unsigned int ev_type);
 struct event_queue *clear_kevent_q(unsigned int ev_type);
 void enable_kevent(unsigned int ev_type, uint32_t vcoreid, int ev_flags);
-void disable_kevent(unsigned int ev_type);
+struct event_queue *disable_kevent(unsigned int ev_type);
 
 /********* Event Handling / Reception ***********/
-unsigned int event_clear_overflows(struct event_queue *ev_q);
 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,
-                               bool overflow);
-extern handle_event_t ev_handlers[];
-void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type,
-                  bool overflow);
+                               void *data);
+struct ev_handler {
+       struct ev_handler                       *next;
+       handle_event_t                          func;
+       void                                            *data;
+};
+int register_ev_handler(unsigned int ev_type, handle_event_t handler,
+                        void *data);
+int deregister_ev_handler(unsigned int ev_type, handle_event_t handler,
+                          void *data);
+
+/* Default event handlers */
+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);
-int handle_mbox_msgs(struct event_mbox *ev_mbox);
+bool extract_one_mbox_msg(struct event_mbox *ev_mbox, struct event_msg *ev_msg);
+int handle_one_mbox_msg(struct event_mbox *ev_mbox);
+int handle_mbox(struct event_mbox *ev_mbox);
+bool mbox_is_empty(struct event_mbox *ev_mbox);
+void send_self_vc_msg(struct event_msg *ev_msg);
+void handle_vcpd_mbox(uint32_t rem_vcoreid);
+void try_handle_remote_mbox(void);
+
+/* Event handler helpers */
+bool ev_might_not_return(void);
+void ev_we_returned(bool were_handling_remotes);
+
+/* Debugging */
+void print_ev_msg(struct event_msg *msg);
+
+/* Uthreads blocking on event queues.  M uthreads can block on subsets of N
+ * event queues.  The structs and details are buried in event.c.  We can move
+ * some of them here if users need greater control over their evqs. */
+void evq_attach_wakeup_ctlr(struct event_queue *ev_q);
+void evq_remove_wakeup_ctlr(struct event_queue *ev_q);
+/* Handler, attaches to the ev_q.  Most people won't need this directly. */
+void evq_wakeup_handler(struct event_queue *ev_q);
+void uth_blockon_evqs_arr(struct event_msg *ev_msg,
+                          struct event_queue **which_evq,
+                          struct event_queue *evqs[], size_t nr_evqs);
+void uth_blockon_evqs(struct event_msg *ev_msg, struct event_queue **which_evq,
+                      size_t nr_evqs, ...);
+bool uth_check_evqs(struct event_msg *ev_msg, struct event_queue **which_evq,
+                    size_t nr_evqs, ...);
+
+__END_DECLS
 
-#endif /* _EVENT_H */
+#endif /* PARLIB_EVENT_H */