Race in kmem_cache_init fixed
[akaros.git] / user / parlib / event.c
1 /* Copyright (c) 2011 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Userspace utility functions for receiving events and notifications (IPIs).
6  * Some are higher level than others; just use what you need. */ 
7
8 #include <ros/event.h>
9 #include <ros/procdata.h>
10 #include <ucq.h>
11 #include <bitmask.h>
12 #include <vcore.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <assert.h>
16 #include <errno.h>
17 #include <parlib.h>
18 #include <event.h>
19 #include <uthread.h>
20
21 /* For remote VCPD mbox event handling */
22 __thread bool __vc_handle_an_mbox = FALSE;
23 __thread uint32_t __vc_rem_vcoreid;
24
25 /********* Event_q Setup / Registration  ***********/
26
27 /* Get event_qs via these interfaces, since eventually we'll want to either
28  * allocate from pinned memory or use some form of a slab allocator.  Also,
29  * these stitch up the big_q so its ev_mbox points to its internal mbox.  Never
30  * access the internal mbox directly.
31  *
32  * Raw ones need to have their UCQs initialized.  If you're making a lot of
33  * these, you can do one big mmap and init the ucqs on your own, which ought to
34  * perform better.
35  *
36  * Use the 'regular' one for big_qs if you don't want to worry about the ucq
37  * initalization */
38 struct event_queue *get_big_event_q_raw(void)
39 {
40         /* TODO: (PIN) should be pinned memory */
41         struct event_queue_big *big_q = malloc(sizeof(struct event_queue_big));
42         memset(big_q, 0, sizeof(struct event_queue_big));
43         big_q->ev_mbox = &big_q->ev_imbox;
44         return (struct event_queue*)big_q;
45 }
46
47 struct event_queue *get_big_event_q(void)
48 {
49         struct event_queue *big_q = get_big_event_q_raw();
50         /* uses the simpler, internally mmapping ucq_init() */
51         ucq_init(&big_q->ev_mbox->ev_msgs);
52         return big_q;
53 }
54
55 /* Give it up.  I don't recommend calling these unless you're sure the queues
56  * aren't in use (unregistered, etc). (TODO: consider some checks for this) */
57 void put_big_event_q_raw(struct event_queue *ev_q)
58 {
59         /* if we use something other than malloc, we'll need to be aware that ev_q
60          * is actually an event_queue_big.  One option is to use the flags, though
61          * this could be error prone. */
62         free(ev_q);
63 }
64
65 void put_big_event_q(struct event_queue *ev_q)
66 {
67         ucq_free_pgs(&ev_q->ev_mbox->ev_msgs);
68         put_big_event_q_raw(ev_q);
69 }
70
71 /* Need to point this event_q to an mbox - usually to a vcpd */
72 struct event_queue *get_event_q(void)
73 {
74         /* TODO: (PIN) should be pinned memory */
75         struct event_queue *ev_q = malloc(sizeof(struct event_queue));
76         memset(ev_q, 0, sizeof(struct event_queue));
77         return ev_q;
78 }
79
80 /* Gets a small ev_q, with ev_mbox pointing to the vcpd mbox of vcoreid.  If
81  * ev_flags has EVENT_VCORE_PRIVATE set, it'll give you the private mbox.  o/w,
82  * you'll get the public one. */
83 struct event_queue *get_event_q_vcpd(uint32_t vcoreid, int ev_flags)
84 {
85         struct event_queue *ev_q = get_event_q();
86         if (ev_flags & EVENT_VCORE_PRIVATE)
87                 ev_q->ev_mbox = &vcpd_of(vcoreid)->ev_mbox_private;
88         else
89                 ev_q->ev_mbox = &vcpd_of(vcoreid)->ev_mbox_public;
90         return ev_q;
91 }
92
93 void put_event_q(struct event_queue *ev_q)
94 {
95         /* if we use something other than malloc, we'll need to be aware that ev_q
96          * is not an event_queue_big. */
97         free(ev_q);
98 }
99
100 /* Sets ev_q to be the receiving end for kernel event ev_type */
101 void register_kevent_q(struct event_queue *ev_q, unsigned int ev_type)
102 {
103         __procdata.kernel_evts[ev_type] = ev_q;
104 }
105
106 /* Clears the event, returning an ev_q if there was one there.  You'll need to
107  * free it. */
108 struct event_queue *clear_kevent_q(unsigned int ev_type)
109 {
110         struct event_queue *ev_q = __procdata.kernel_evts[ev_type];
111         __procdata.kernel_evts[ev_type] = 0;
112         return ev_q;
113 }
114
115 /* Enables an IPI/event combo for ev_type sent to vcoreid's default mbox.  IPI
116  * if you want one or not.  If you want the event to go to the vcore private
117  * mbox (meaning no other core should ever handle it), send in
118  * EVENT_VCORE_PRIVATE with ev_flags.
119  *
120  * This is the simplest thing applications may want, and shows how you can put
121  * the other event functions together to get similar things done. */
122 void enable_kevent(unsigned int ev_type, uint32_t vcoreid, int ev_flags)
123 {
124         struct event_queue *ev_q = get_event_q_vcpd(vcoreid, ev_flags);
125         ev_q->ev_flags = ev_flags;
126         ev_q->ev_vcore = vcoreid;
127         ev_q->ev_handler = 0;
128         wmb();  /* make sure ev_q is filled out before registering */
129         register_kevent_q(ev_q, ev_type);
130 }
131
132 /* Stop receiving the events (one could be on the way).  Caller needs to be
133  * careful, since the kernel might be sending an event to the ev_q.  Depending
134  * on the ev_q, it may be hard to know when it is done (for instance, if all
135  * syscalls you ever registered with the ev_q are done, then it would be okay).
136  * o/w, don't free it. */
137 struct event_queue *disable_kevent(unsigned int ev_type)
138 {
139         return clear_kevent_q(ev_type);
140 }
141
142 /********* Event Handling / Reception ***********/
143 /* Somewhat ghetto helper, for the lazy.  If all you care about is an event
144  * number, this will see if the event happened or not.  It will try for a
145  * message, but if there is none, it will go for a bit.  Note that multiple
146  * bit messages will turn into just one bit. */
147 unsigned int get_event_type(struct event_mbox *ev_mbox)
148 {
149         struct event_msg local_msg = {0};
150         /* UCQ returns 0 on success, so this will dequeue and return the type. */
151         if (!get_ucq_msg(&ev_mbox->ev_msgs, &local_msg)) {
152                 return local_msg.ev_type;
153         }
154         if (BITMASK_IS_CLEAR(&ev_mbox->ev_bitmap, MAX_NR_EVENT))
155                 return EV_NONE; /* aka, 0 */
156         for (int i = 0; i < MAX_NR_EVENT; i++) {
157                 if (GET_BITMASK_BIT(ev_mbox->ev_bitmap, i)) {
158                         CLR_BITMASK_BIT_ATOMIC(ev_mbox->ev_bitmap, i);
159                         return i;
160                 }
161         }
162         return EV_NONE;
163 }
164
165 /* Actual Event Handling */
166
167 /* List of handlers, process-wide, that the 2LS should fill in.  They all must
168  * return (don't context switch to a u_thread) */
169 handle_event_t ev_handlers[MAX_NR_EVENT] = {[EV_EVENT] handle_ev_ev,
170                                             [EV_CHECK_MSGS] handle_check_msgs,
171                                             0};
172
173 /* Attempts to handle a message.  Returns 1 if we dequeued a msg, 0 o/w. */
174 int handle_one_mbox_msg(struct event_mbox *ev_mbox)
175 {
176         struct event_msg local_msg;
177         unsigned int ev_type;
178         /* get_ucq returns 0 on success, -1 on empty */
179         if (get_ucq_msg(&ev_mbox->ev_msgs, &local_msg) == -1)
180                 return 0;
181         ev_type = local_msg.ev_type;
182         printd("[event] UCQ (mbox %08p), ev_type: %d\n", ev_mbox, ev_type);
183         if (ev_handlers[ev_type])
184                 ev_handlers[ev_type](&local_msg, ev_type);
185         return 1;
186 }
187
188 /* Handle an mbox.  This is the receive-side processing of an event_queue.  It
189  * takes an ev_mbox, since the vcpd mbox isn't a regular ev_q.  Returns the
190  * number handled/attempted: counts if you don't have a handler. */
191 int handle_mbox(struct event_mbox *ev_mbox)
192 {
193         int retval = 0;
194         uint32_t vcoreid = vcore_id();
195         void bit_handler(unsigned int bit) {
196                 printd("[event] Bit: ev_type: %d\n", bit);
197                 if (ev_handlers[bit])
198                         ev_handlers[bit](0, bit);
199                 retval++;
200                 /* Consider checking the queue for incoming messages while we're here */
201         }
202         printd("[event] handling ev_mbox %08p on vcore %d\n", ev_mbox, vcore_id());
203         /* Some stack-smashing bugs cause this to fail */
204         assert(ev_mbox);
205         /* Handle all full messages, tracking the number of attempts. */
206         while (handle_one_mbox_msg(ev_mbox))
207                 retval++;
208         /* Process all bits, if the kernel tells us any bit is set.  We don't clear
209          * the flag til after we check everything, in case one of the handlers
210          * doesn't return.  After we clear it, we recheck. */
211         if (ev_mbox->ev_check_bits) {
212                 do {
213                         ev_mbox->ev_check_bits = TRUE;  /* in case we don't return */
214                         cmb();
215                         BITMASK_FOREACH_SET(ev_mbox->ev_bitmap, MAX_NR_EVENT, bit_handler,
216                                             TRUE);
217                         ev_mbox->ev_check_bits = FALSE;
218                         wrmb(); /* check_bits written before we check for it being clear */
219                 } while (!BITMASK_IS_CLEAR(ev_mbox->ev_bitmap, MAX_NR_EVENT));
220         }
221         return retval;
222 }
223
224 /* Empty if the UCQ is empty and the bits don't need checked */
225 bool mbox_is_empty(struct event_mbox *ev_mbox)
226 {
227         return (ucq_is_empty(&ev_mbox->ev_msgs) && (!ev_mbox->ev_check_bits));
228 }
229
230 /* The EV_EVENT handler - extract the ev_q from the message. */
231 void handle_ev_ev(struct event_msg *ev_msg, unsigned int ev_type)
232 {
233         struct event_queue *ev_q;
234         /* EV_EVENT can't handle not having a message / being a bit.  If we got a
235          * bit message, it's a bug somewhere */
236         assert(ev_msg);
237         ev_q = ev_msg->ev_arg3;
238         /* Same deal, a null ev_q is probably a bug, or someone being a jackass */
239         assert(ev_q);
240         /* Clear pending, so we can start getting INDIRs and IPIs again.  We must
241          * set this before (compared to handle_events, then set it, then handle
242          * again), since there is no guarantee handle_event_q() will return.  If
243          * there is a pending preemption, the vcore quickly yields and will deal
244          * with the remaining events in the future - meaning it won't return to
245          * here. */
246         ev_q->ev_alert_pending = FALSE;
247         wmb();  /* don't let the pending write pass the signaling of an ev recv */
248         handle_event_q(ev_q);
249 }
250
251 /* This handler tells us to check the public message box of a vcore. */
252 void handle_check_msgs(struct event_msg *ev_msg, unsigned int ev_type)
253 {
254         uint32_t rem_vcoreid;
255         assert(ev_msg);
256         rem_vcoreid = ev_msg->ev_arg2;
257         printd("[event] handle check msgs for VC %d on VC %d\n", rem_vcoreid,
258                vcore_id());
259         /* if it is a message for ourselves, then we can abort.  Vcores will check
260          * their own messages via handle_events() (which either we're doing now, or
261          * will do when we are done dealing with another vcore's mbox). */
262         if (rem_vcoreid == vcore_id())
263                 return;
264         /* they should have had their can_rcv turned off at some point, though it is
265          * possible that it was turned back on by now.  we don't really care - our
266          * job is to make sure their messages get checked. */
267         handle_vcpd_mbox(rem_vcoreid);
268 }
269
270 /* 2LS will probably call this in vcore_entry and places where it wants to check
271  * for / handle events.  This will process all the events for the given vcore.
272  * Note, it probably should be the calling vcore you do this to...  Returns the
273  * number of events handled. */
274 int handle_events(uint32_t vcoreid)
275 {
276         struct preempt_data *vcpd = vcpd_of(vcoreid);
277         int retval = 0;
278         retval += handle_mbox(&vcpd->ev_mbox_private);
279         retval += handle_mbox(&vcpd->ev_mbox_public);
280         return retval;
281 }
282
283 /* Handles the events on ev_q IAW the event_handlers[].  If the ev_q is
284  * application specific, then this will dispatch/handle based on its flags. */
285 void handle_event_q(struct event_queue *ev_q)
286 {
287         /* If the program wants to handle the ev_q on its own: */
288         if (ev_q->ev_flags & (EVENT_JUSTHANDLEIT | EVENT_THREAD)) {
289                 if (!ev_q->ev_handler) {
290                         printf("No ev_handler installed for ev_q %08p, aborting!\n", ev_q);
291                         return;
292                 }
293                 if (ev_q->ev_flags & EVENT_JUSTHANDLEIT) {
294                         /* Remember this can't block or page fault */
295                         ev_q->ev_handler(ev_q);
296                 } else if (ev_q->ev_flags & EVENT_THREAD) {
297                         /* 2LS sched op.  The 2LS can use an existing thread if it wants,
298                          * but do so inside spawn_thread() */
299                         if (sched_ops->spawn_thread)
300                                 sched_ops->spawn_thread((uintptr_t)ev_q->ev_handler, ev_q);
301                         else
302                                 printf("2LS can't spawn a thread for ev_q %08p\n", ev_q);
303                 }
304                 return;
305         }
306         printd("[event] handling ev_q %08p on vcore %d\n", ev_q, vcore_id());
307         /* Raw ev_qs that haven't been connected to an mbox, user bug: */
308         assert(ev_q->ev_mbox);
309         handle_mbox(ev_q->ev_mbox);
310 }
311
312 /* Sends the calling vcore a message to its public mbox.  This is purposefully
313  * limited to just the calling vcore, since in future versions, we can send via
314  * ucqs directly (in many cases).  That will require the caller to be the
315  * vcoreid, due to some preemption recovery issues (another ucq poller is
316  * waiting on us when we got preempted, and we never up nr_cons). */
317 void send_self_vc_msg(struct event_msg *ev_msg)
318 {
319         // TODO: try to use UCQs (requires additional support)
320         /* ev_type actually gets ignored currently.  ev_msg is what matters if it is
321          * non-zero.  FALSE means it's going to the public mbox */
322         sys_self_notify(vcore_id(), ev_msg->ev_type, ev_msg, FALSE);
323 }
324
325 /* Helper: makes the current core handle a remote vcore's VCPD public mbox events.
326  *
327  * Both cases (whether we are handling someone else's already or not) use some
328  * method of telling our future self what to do.  When we aren't already
329  * handling it, we use TLS, and jump to vcore entry.  When we are already
330  * handling, then we send a message to ourself, which we deal with when we
331  * handle our own events (which is later in vcore entry).
332  *
333  * We need to reset the stack and deal with it in vcore entry to avoid recursing
334  * deeply and running off the transition stack.  (handler calling handle event).
335  *
336  * Note that we might not be the one that gets the message we send.  If we pull
337  * a sys_change_to, someone else might be polling our public message box.  All
338  * we're doing is making sure that we don't forget to check rem_vcoreid's mbox.
339  *
340  * Finally, note that this function might not return.  However, it'll handle the
341  * details related to vcpd mboxes, so you don't use the ev_might_not_return()
342  * helpers with this. */
343 void handle_vcpd_mbox(uint32_t rem_vcoreid)
344 {
345         uint32_t vcoreid = vcore_id();
346         struct preempt_data *vcpd = vcpd_of(vcoreid);
347         struct event_msg local_msg = {0};
348         assert(vcoreid != rem_vcoreid);                 /* this shouldn't happen */
349         /* If they are empty, then we're done */
350         if (mbox_is_empty(&vcpd_of(rem_vcoreid)->ev_mbox_public))
351                 return;
352         if (__vc_handle_an_mbox) {
353                 /* we might be already handling them, in which case, abort */
354                 if (__vc_rem_vcoreid == rem_vcoreid)
355                         return;
356                 /* Already handling message for someone, need to send ourselves a
357                  * message to check rem_vcoreid, which we'll process later. */
358                 local_msg.ev_type = EV_CHECK_MSGS;
359                 local_msg.ev_arg2 = rem_vcoreid;        /* 32bit arg */
360                 send_self_vc_msg(&local_msg);
361                 return;
362         }
363         /* No return after here */
364         /* At this point, we aren't in the process of handling someone else's
365          * messages, so just tell our future self what to do */
366         __vc_handle_an_mbox = TRUE;
367         __vc_rem_vcoreid = rem_vcoreid;
368         /* Reset the stack and start over in vcore context */
369         set_stack_pointer((void*)vcpd->transition_stack);
370         vcore_entry();
371         assert(0);
372 }
373
374 /* Handle remote vcpd public mboxes, if that's what we want to do.  Call this
375  * from vcore entry, pairs with handle_vcpd_mbox(). */
376 void try_handle_remote_mbox(void)
377 {
378         if (__vc_handle_an_mbox) {
379                 handle_mbox(&vcpd_of(__vc_rem_vcoreid)->ev_mbox_public);
380                 /* only clear the flag when we have returned from handling messages.  if
381                  * an event handler (like preempt_recover) doesn't return, we'll clear
382                  * this flag elsewhere. (it's actually not a big deal if we don't). */
383                 cmb();
384                 __vc_handle_an_mbox = FALSE;
385         }
386 }
387
388 /* Event handler helpers */
389
390 /* For event handlers that might not return, we need to call this before the
391  * command that might not return.  In the event we were handling a remote
392  * vcore's messages, it'll send ourselves a messages that we (or someone who
393  * polls us) will get so that someone finishes off that vcore's messages).
394  * Doesn't matter who does, so long as someone does.
395  *
396  * This returns whether or not we were handling someone's messages.  Pass the
397  * parameter to ev_we_returned() */
398 bool ev_might_not_return(void)
399 {
400         struct event_msg local_msg = {0};
401         bool were_handling_remotes = FALSE;
402         if (__vc_handle_an_mbox) {
403                 /* slight chance we finished with their mbox (were on the last one) */
404                 if (!mbox_is_empty(&vcpd_of(__vc_rem_vcoreid)->ev_mbox_public)) {
405                         /* But we aren't, so we'll need to send a message */
406                         local_msg.ev_type = EV_CHECK_MSGS;
407                         local_msg.ev_arg2 = __vc_rem_vcoreid;   /* 32bit arg */
408                         send_self_vc_msg(&local_msg);
409                 }
410                 /* Either way, we're not working on this one now.  Note this is more of
411                  * an optimization - it'd be harmless (I think) to poll another vcore's
412                  * pub mbox once when we pop up in vc_entry in the future */
413                 __vc_handle_an_mbox = FALSE;
414                 return TRUE;
415         }
416         return FALSE;
417 }
418
419 /* Call this when you return, paired up with ev_might_not_return().  If
420  * ev_might_not_return turned off uth_handle, we'll turn it back on. */
421 void ev_we_returned(bool were_handling_remotes)
422 {
423         if (were_handling_remotes)
424                 __vc_handle_an_mbox = TRUE;
425 }