Specify an mbox type when getting an event queue
[akaros.git] / user / benchutil / alarm.c
1 /* Copyright (c) 2013 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Userspace alarms.  There are lower level helpers to build your own alarms
6  * from the #A device and an alarm service, based off a slimmed down version of
7  * the kernel alarms.  Under the hood, the user alarm uses the #A service for
8  * the root of the alarm chain.
9  *
10  * There's only one timer chain, unlike in the kernel, for the entire process.
11  * If you want one-off timers unrelated to the chain (and sent to other vcores),
12  * use #A directly.
13  *
14  * Your handlers will run from vcore context.
15  *
16  * Code differences from the kernel (for future porting):
17  * - init_alarm_service, run once out of init_awaiter (or wherever).
18  * - set_alarm() and friends are __tc_set_alarm(), passing global_tchain.
19  * - reset_tchain_interrupt() uses #A
20  * - removed anything related to semaphores or kthreads
21  * - spinlocks -> spin_pdr_locks
22  * - ev_q wrappers for converting #A events to __triggers
23  * - printks, and other minor stuff. */
24
25 #include <sys/queue.h>
26 #include <sys/time.h>
27 #include <benchutil/alarm.h>
28 #include <stdio.h>
29 #include <assert.h>
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <parlib/parlib.h>
36 #include <parlib/event.h>
37 #include <benchutil/measure.h>
38 #include <parlib/uthread.h>
39 #include <parlib/spinlock.h>
40 #include <parlib/timing.h>
41
42 /* Helper to get your own alarm.   If you don't care about a return value, pass
43  * 0 and it'll be ignored.  The alarm is built, but has no evq or timer set. */
44 int devalarm_get_fds(int *ctlfd_r, int *timerfd_r, int *alarmid_r)
45 {
46         int ctlfd, timerfd, alarmid, ret;
47         char buf[20];
48         char path[32];
49
50         ctlfd = open("#A/clone", O_RDWR | O_CLOEXEC);
51         if (ctlfd < 0)
52                 return -1;
53         ret = read(ctlfd, buf, sizeof(buf) - 1);
54         if (ret <= 0)
55                 return -1;
56         buf[ret] = 0;
57         alarmid = atoi(buf);
58         snprintf(path, sizeof(path), "#A/a%s/timer", buf);
59         timerfd = open(path, O_RDWR | O_CLOEXEC);
60         if (timerfd < 0)
61                 return -1;
62         if (ctlfd_r)
63                 *ctlfd_r = ctlfd;
64         else
65                 close(ctlfd);
66         if (timerfd_r)
67                 *timerfd_r = timerfd;
68         else
69                 close(timerfd);
70         if (alarmid_r)
71                 *alarmid_r = alarmid;
72         return 0;
73 }
74
75 int devalarm_set_evq(int ctlfd, struct event_queue *ev_q)
76 {
77         int ret;
78         char path[32];
79         ret = snprintf(path, sizeof(path), "evq %llx", ev_q);
80         ret = write(ctlfd, path, ret);
81         if (ret <= 0)
82                 return -1;
83         return 0;
84 }
85
86 int devalarm_set_time(int timerfd, uint64_t tsc_time)
87 {
88         int ret;
89         char buf[20];
90         ret = snprintf(buf, sizeof(buf), "%llx", tsc_time);
91         ret = write(timerfd, buf, ret);
92         if (ret <= 0)
93                 return -1;
94         return 0;
95 }
96
97 int devalarm_disable(int ctlfd)
98 {
99         int ret = write(ctlfd, "cancel", sizeof("cancel"));
100         if (ret <= 0)
101                 return -1;
102         return 0;
103 }
104
105 /* Helpers, basically renamed kernel interfaces, with the *tchain. */
106 static void __tc_locked_set_alarm(struct timer_chain *tchain,
107                                   struct alarm_waiter *waiter);
108 static void __tc_set_alarm(struct timer_chain *tchain,
109                            struct alarm_waiter *waiter);
110 static bool __tc_unset_alarm(struct timer_chain *tchain,
111                              struct alarm_waiter *waiter);
112 static void __tc_reset_alarm_abs(struct timer_chain *tchain,
113                                  struct alarm_waiter *waiter,
114                                  uint64_t abs_time);
115 static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type,
116                               void *data);
117
118 /* One chain to rule them all. */
119 struct timer_chain global_tchain;
120
121 /* Unix time offsets so we can allow people to specify an absolute unix time to
122  * an alarm, rather than an absolute time in terms of raw tsc ticks.  This
123  * value is initialized when the timer service is started. */
124 static struct {
125         uint64_t tod; // The initial time of day in microseconds
126         uint64_t tsc; // The initial value of the tsc counter
127 } unixtime_offsets;
128 static inline void init_unixtime_offsets()
129 {
130         struct timeval tv;
131         gettimeofday(&tv, NULL);
132         unixtime_offsets.tsc = read_tsc();
133         unixtime_offsets.tod = tv.tv_sec*1000000 + tv.tv_usec;
134 }
135
136 /* Helper, resets the earliest/latest times, based on the elements of the list.
137  * If the list is empty, we set the times to be the 12345 poison time.  Since
138  * the list is empty, the alarm shouldn't be going off. */
139 static void reset_tchain_times(struct timer_chain *tchain)
140 {
141         if (TAILQ_EMPTY(&tchain->waiters)) {
142                 tchain->earliest_time = ALARM_POISON_TIME;
143                 tchain->latest_time = ALARM_POISON_TIME;
144         } else {
145                 tchain->earliest_time = TAILQ_FIRST(&tchain->waiters)->wake_up_time;
146                 tchain->latest_time =
147                         TAILQ_LAST(&tchain->waiters, awaiters_tailq)->wake_up_time;
148         }
149 }
150
151 static void init_alarm_service(void)
152 {
153         int ctlfd, timerfd, alarmid;
154         struct event_queue *ev_q;
155
156         /* Initialize the unixtime_offsets */
157         init_unixtime_offsets();
158
159         /* Sets up timer chain (only one chain per process) */
160         spin_pdr_init(&global_tchain.lock);
161         TAILQ_INIT(&global_tchain.waiters);
162         reset_tchain_times(&global_tchain);
163
164         if (devalarm_get_fds(&ctlfd, &timerfd, &alarmid)) {
165                 perror("devalarm_get_fds");
166                 return;
167         }
168         /* Since we're doing SPAM_PUBLIC later, we actually don't need a big ev_q.
169          * But someone might copy/paste this and change a flag. */
170         register_ev_handler(EV_ALARM, handle_user_alarm, 0);
171         if (!(ev_q = get_big_event_q(EV_MBOX_UCQ))) {
172                 perror("Useralarm: Failed ev_q");
173                 return;
174         }
175         ev_q->ev_vcore = 0;
176         /* We could get multiple events for a single alarm.  It's okay, since
177          * __trigger can handle spurious upcalls.  If it ever is not okay, then use
178          * an INDIR (probably with SPAM_INDIR too) instead of SPAM_PUBLIC. */
179         ev_q->ev_flags = EVENT_IPI | EVENT_SPAM_PUBLIC | EVENT_WAKEUP;
180         if (devalarm_set_evq(ctlfd, ev_q)) {
181                 perror("set_alarm_evq");
182                 return;
183         }
184         /* now the alarm is all set, just need to write the timer whenever we want
185          * it to go off. */
186         global_tchain.alarmid = alarmid;
187         global_tchain.ctlfd = ctlfd;
188         global_tchain.timerfd = timerfd;
189         global_tchain.ev_q = ev_q;      /* mostly for debugging */
190 }
191
192 /* Initializes a new awaiter.  Pass 0 for the function if you want it to be a
193  * kthread-alarm, and sleep on it after you set the alarm later. */
194 void init_awaiter(struct alarm_waiter *waiter,
195                   void (*func) (struct alarm_waiter *awaiter))
196 {
197         run_once_racy(init_alarm_service());
198         waiter->wake_up_time = ALARM_POISON_TIME;
199         assert(func);
200         waiter->func = func;
201         waiter->on_tchain = FALSE;
202 }
203
204 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
205  * the alarm to go off. */
206 void set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
207 {
208         waiter->wake_up_time = abs_time;
209 }
210
211 /* Give this the absolute unix time (in microseconds) that you want the alarm
212  * to go off. */
213 void set_awaiter_abs_unix(struct alarm_waiter *waiter, uint64_t abs_time)
214 {
215         abs_time = usec2tsc(abs_time - unixtime_offsets.tod) + unixtime_offsets.tsc;
216         set_awaiter_abs(waiter, abs_time);
217 }
218
219 /* Give this a relative time from now, in microseconds.  This might be easier to
220  * use than dealing with the TSC. */
221 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
222 {
223         uint64_t now, then;
224         now = read_tsc();
225         then = now + usec2tsc(usleep);
226         /* This will go off if we wrap-around the TSC.  It'll never happen for legit
227          * values, but this might catch some bugs with large usleeps. */
228         assert(now <= then);
229         set_awaiter_abs(waiter, then);
230 }
231
232 /* Increment the timer that was already set, so that it goes off usleep usec
233  * from the previous tick.  This is different than 'rel' in that it doesn't care
234  * about when 'now' is. */
235 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
236 {
237         assert(waiter->wake_up_time != ALARM_POISON_TIME);
238         waiter->wake_up_time += usec2tsc(usleep);
239 }
240
241 /* User interface to the global tchain */
242 void __set_alarm(struct alarm_waiter *waiter)
243 {
244         __tc_locked_set_alarm(&global_tchain, waiter);
245 }
246
247 void set_alarm(struct alarm_waiter *waiter)
248 {
249         __tc_set_alarm(&global_tchain, waiter);
250 }
251
252 bool unset_alarm(struct alarm_waiter *waiter)
253 {
254         return __tc_unset_alarm(&global_tchain, waiter);
255 }
256
257 void reset_alarm_abs(struct alarm_waiter *waiter, uint64_t abs_time)
258 {
259         __tc_reset_alarm_abs(&global_tchain, waiter, abs_time);
260 }
261
262 /* Helper, makes sure the kernel alarm is turned on at the right time. */
263 static void reset_tchain_interrupt(struct timer_chain *tchain)
264 {
265         if (TAILQ_EMPTY(&tchain->waiters)) {
266                 /* Turn it off */
267                 printd("Turning alarm off\n");
268                 if (devalarm_disable(tchain->ctlfd)) {
269                         printf("Useralarm: unable to disarm alarm!\n");
270                         return;
271                 }
272         } else {
273                 /* Make sure it is on and set to the earliest time */
274                 assert(tchain->earliest_time != ALARM_POISON_TIME);
275                 /* TODO: check for times in the past or very close to now */
276                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
277                 if (devalarm_set_time(tchain->timerfd, tchain->earliest_time)) {
278                         perror("Useralarm: Failed to set timer");
279                         return;
280                 }
281         }
282 }
283
284 /* When an awaiter's time has come, this gets called. */
285 static void wake_awaiter(struct alarm_waiter *waiter)
286 {
287         waiter->on_tchain = FALSE;
288         cmb();  /* enforce the on_tchain write before the handlers */
289         waiter->func(waiter);
290 }
291
292 /* This is called when the kernel alarm triggers a tchain, and needs to wake up
293  * everyone whose time is up.  Called from vcore context. */
294 static void __trigger_tchain(struct timer_chain *tchain)
295 {
296         struct alarm_waiter *i, *temp;
297         uint64_t now = read_tsc();
298         bool changed_list = FALSE;
299         spin_pdr_lock(&tchain->lock);
300         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
301                 printd("Trying to wake up %p who is due at %llu and now is %llu\n",
302                        i, i->wake_up_time, now);
303                 /* TODO: Could also do something in cases where we're close to now */
304                 if (i->wake_up_time <= now) {
305                         changed_list = TRUE;
306                         TAILQ_REMOVE(&tchain->waiters, i, next);
307                         /* Don't touch the waiter after waking it, since it could be in use
308                          * on another core (and the waiter can be clobbered as the kthread
309                          * unwinds its stack).  Or it could be kfreed */
310                         wake_awaiter(i);
311                 } else {
312                         break;
313                 }
314         }
315         if (changed_list) {
316                 reset_tchain_times(tchain);
317         }
318         /* Need to reset the interrupt no matter what */
319         reset_tchain_interrupt(tchain);
320         spin_pdr_unlock(&tchain->lock);
321 }
322
323 static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type,
324                               void *data)
325 {
326         assert(ev_type == EV_ALARM);
327         if (ev_msg && (ev_msg->ev_arg2 == global_tchain.alarmid))
328                 __trigger_tchain(&global_tchain);
329 }
330
331 /* Helper, inserts the waiter into the tchain, returning TRUE if we still need
332  * to reset the tchain interrupt.  Caller holds the lock. */
333 static bool __insert_awaiter(struct timer_chain *tchain,
334                              struct alarm_waiter *waiter)
335 {
336         struct alarm_waiter *i, *temp;
337         /* This will fail if you don't set a time */
338         assert(waiter->wake_up_time != ALARM_POISON_TIME);
339         waiter->on_tchain = TRUE;
340         /* Either the list is empty, or not. */
341         if (TAILQ_EMPTY(&tchain->waiters)) {
342                 tchain->earliest_time = waiter->wake_up_time;
343                 tchain->latest_time = waiter->wake_up_time;
344                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
345                 /* Need to turn on the timer interrupt later */
346                 return TRUE;
347         }
348         /* If not, either we're first, last, or in the middle.  Reset the interrupt
349          * and adjust the tchain's times accordingly. */
350         if (waiter->wake_up_time < tchain->earliest_time) {
351                 tchain->earliest_time = waiter->wake_up_time;
352                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
353                 /* Changed the first entry; we'll need to reset the interrupt later */
354                 return TRUE;
355         }
356         /* If there is a tie for last, the newer one will really go last.  We need
357          * to handle equality here since the loop later won't catch it. */
358         if (waiter->wake_up_time >= tchain->latest_time) {
359                 tchain->latest_time = waiter->wake_up_time;
360                 /* Proactively put it at the end if we know we're last */
361                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
362                 return FALSE;
363         }
364         /* Insert before the first one you are earlier than.  This won't scale well
365          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
366          * will help a bit. */
367         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
368                 if (waiter->wake_up_time < i->wake_up_time) {
369                         TAILQ_INSERT_BEFORE(i, waiter, next);
370                         return FALSE;
371                 }
372         }
373         printf("Could not find a spot for awaiter %p\n", waiter);
374 }
375
376 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
377  * later.  This version assumes you have the lock held.  That only makes sense
378  * from alarm handlers, which are called with this lock held from IRQ context */
379 static void __tc_locked_set_alarm(struct timer_chain *tchain,
380                                   struct alarm_waiter *waiter)
381 {       
382         if (__insert_awaiter(tchain, waiter))
383                 reset_tchain_interrupt(tchain);
384 }
385
386 /* Sets the alarm.  Don't call this from an alarm handler, since you already
387  * have the lock held.  Call __set_alarm() instead. */
388 static void __tc_set_alarm(struct timer_chain *tchain,
389                            struct alarm_waiter *waiter)
390 {
391         spin_pdr_lock(&tchain->lock);
392         __set_alarm(waiter);
393         spin_pdr_unlock(&tchain->lock);
394 }
395
396 /* Helper, rips the waiter from the tchain, knowing that it is on the list.
397  * Returns TRUE if the tchain interrupt needs to be reset.  Callers hold the
398  * lock. */
399 static bool __remove_awaiter(struct timer_chain *tchain,
400                              struct alarm_waiter *waiter)
401 {
402         struct alarm_waiter *temp;
403         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
404         /* Need to make sure earliest and latest are set, in case we're mucking with
405          * the first and/or last element of the chain. */
406         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
407                 temp = TAILQ_NEXT(waiter, next);
408                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
409                 reset_int = TRUE;               /* we'll need to reset the timer later */
410         }
411         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
412                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
413                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
414         }
415         TAILQ_REMOVE(&tchain->waiters, waiter, next);
416         return reset_int;
417 }
418
419 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
420  * disarmed before the alarm went off, FALSE if it already fired. */
421 static bool __tc_unset_alarm(struct timer_chain *tchain,
422                              struct alarm_waiter *waiter)
423 {
424         spin_pdr_lock(&tchain->lock);
425         if (!waiter->on_tchain) {
426                 /* the alarm has already gone off.  its not even on this tchain's list,
427                  * though the concurrent change to on_tchain (specifically, the setting
428                  * of it to FALSE), happens under the tchain's lock. */
429                 spin_pdr_unlock(&tchain->lock);
430                 return FALSE;
431         }
432         if (__remove_awaiter(tchain, waiter))
433                 reset_tchain_interrupt(tchain);
434         spin_pdr_unlock(&tchain->lock);
435         return TRUE;
436 }
437
438 /* waiter may be on the tchain, or it might have fired already and be off the
439  * tchain.  Either way, this will put the waiter on the list, set to go off at
440  * abs_time.  If you know the alarm has fired, don't call this.  Just set the
441  * awaiter, and then set_alarm() */
442 static void __tc_reset_alarm_abs(struct timer_chain *tchain,
443                                  struct alarm_waiter *waiter, uint64_t abs_time)
444 {
445         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
446         spin_pdr_lock(&tchain->lock);
447         /* We only need to remove/unset when the alarm has not fired yet (is still
448          * on the tchain).  If it has fired, it's like a fresh insert */
449         if (waiter->on_tchain)
450                 reset_int = __remove_awaiter(tchain, waiter);
451         set_awaiter_abs(waiter, abs_time);
452         /* regardless, we need to be reinserted */
453         if (__insert_awaiter(tchain, waiter) || reset_int)
454                 reset_tchain_interrupt(tchain);
455         spin_pdr_unlock(&tchain->lock);
456 }
457
458 /* Debug helpers */
459
460 void print_chain(struct timer_chain *tchain)
461 {
462         struct alarm_waiter *i;
463         spin_pdr_lock(&tchain->lock);
464         printf("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
465                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
466                tchain->earliest_time,
467                tchain->latest_time);
468         spin_pdr_unlock(&tchain->lock);
469 }
470
471 /* "parlib" alarm handlers */
472 void alarm_abort_sysc(struct alarm_waiter *awaiter)
473 {
474         struct uthread *uth = awaiter->data;
475         assert(uth);
476         if (!uth->sysc) {
477                 /* It's possible the sysc hasn't blocked yet or is in the process of
478                  * unblocking, or even has returned, but hasn't cancelled the alarm.
479                  * regardless, we request a new alarm (the uthread will cancel us one
480                  * way or another). */
481                 set_awaiter_inc(awaiter, 1000000);
482                 __set_alarm(awaiter);
483                 return;
484         }
485         sys_abort_sysc(uth->sysc);
486 }