parlib: Include event type headers in event.h
[akaros.git] / user / parlib / include / parlib / event.h
1 /* Copyright (c) 2011-2014 The Regents of the University of California
2  * Copyright (c) 2015 Google Inc
3  * Barret Rhoden <brho@cs.berkeley.edu>
4  * See LICENSE for details.
5  *
6  * Userspace utility functions for receiving events and notifications (IPIs).
7  * Some are higher level than others; just use what you need. */ 
8
9 #pragma once
10
11 #include <ros/event.h>
12 #include <ros/syscall.h>
13 #include <parlib/common.h>
14 #include <parlib/ucq.h>
15 #include <parlib/evbitmap.h>
16 #include <parlib/ceq.h>
17
18 __BEGIN_DECLS
19
20 /********* Event_q Setup / Registration  ***********/
21 struct event_queue *get_eventq(int mbox_type);
22 struct event_queue *get_eventq_raw(void);
23 struct event_queue *get_eventq_slim(void);
24 struct event_queue *get_eventq_vcpd(uint32_t vcoreid, int ev_flags);
25 void put_eventq(struct event_queue *ev_q);
26 void put_eventq_raw(struct event_queue *ev_q);
27 void put_eventq_slim(struct event_queue *ev_q);
28 void put_eventq_vcpd(struct event_queue *ev_q);
29
30 void event_mbox_init(struct event_mbox *ev_mbox, int mbox_type);
31 void event_mbox_cleanup(struct event_mbox *ev_mbox);
32
33 void register_kevent_q(struct event_queue *ev_q, unsigned int ev_type);
34 struct event_queue *clear_kevent_q(unsigned int ev_type);
35 void enable_kevent(unsigned int ev_type, uint32_t vcoreid, int ev_flags);
36 struct event_queue *disable_kevent(unsigned int ev_type);
37
38 /********* Event Handling / Reception ***********/
39 unsigned int get_event_type(struct event_mbox *ev_mbox);
40 bool register_evq(struct syscall *sysc, struct event_queue *ev_q);
41 void deregister_evq(struct syscall *sysc);
42
43 typedef void (*handle_event_t)(struct event_msg *ev_msg, unsigned int ev_type,
44                                void *data);
45 struct ev_handler {
46         struct ev_handler                       *next;
47         handle_event_t                          func;
48         void                                            *data;
49 };
50 int register_ev_handler(unsigned int ev_type, handle_event_t handler,
51                         void *data);
52 int deregister_ev_handler(unsigned int ev_type, handle_event_t handler,
53                           void *data);
54
55 /* Default event handlers */
56 void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type, void *data);
57
58 int handle_events(uint32_t vcoreid);
59 void handle_event_q(struct event_queue *ev_q);
60 bool extract_one_mbox_msg(struct event_mbox *ev_mbox, struct event_msg *ev_msg);
61 int handle_one_mbox_msg(struct event_mbox *ev_mbox);
62 int handle_mbox(struct event_mbox *ev_mbox);
63 bool mbox_is_empty(struct event_mbox *ev_mbox);
64 void send_self_vc_msg(struct event_msg *ev_msg);
65 void handle_vcpd_mbox(uint32_t rem_vcoreid);
66 void try_handle_remote_mbox(void);
67
68 /* Event handler helpers */
69 bool ev_might_not_return(void);
70 void ev_we_returned(bool were_handling_remotes);
71
72 /* Debugging */
73 void print_ev_msg(struct event_msg *msg);
74
75 /* Uthreads blocking on event queues.  M uthreads can block on subsets of N
76  * event queues.  The structs and details are buried in event.c.  We can move
77  * some of them here if users need greater control over their evqs. */
78 void evq_attach_wakeup_ctlr(struct event_queue *ev_q);
79 void evq_remove_wakeup_ctlr(struct event_queue *ev_q);
80 /* Handler, attaches to the ev_q.  Most people won't need this directly. */
81 void evq_wakeup_handler(struct event_queue *ev_q);
82 void uth_blockon_evqs_arr(struct event_msg *ev_msg,
83                           struct event_queue **which_evq,
84                           struct event_queue *evqs[], size_t nr_evqs);
85 void uth_blockon_evqs(struct event_msg *ev_msg, struct event_queue **which_evq,
86                       size_t nr_evqs, ...);
87 bool uth_check_evqs(struct event_msg *ev_msg, struct event_queue **which_evq,
88                     size_t nr_evqs, ...);
89
90 __END_DECLS