cf678a1fcc57768f5777f07155e36ae1ce3d376b
[akaros.git] / user / parlib / alarm.c
1 /* Copyright (c) 2013 The Regents of the University of California
2  * Copyright (c) 2018 Google Inc.
3  * Barret Rhoden <brho@cs.berkeley.edu>
4  * See LICENSE for details.
5  *
6  * Userspace alarms.  There are lower level helpers to build your own alarms
7  * from the #alarm device and an alarm service, based off a slimmed down version
8  * of the kernel alarms.  Under the hood, the user alarm uses the #alarm service
9  * for the root of the alarm chain.
10  *
11  * There's only one timer chain, unlike in the kernel, for the entire process.
12  * If you want one-off timers unrelated to the chain (and sent to other vcores),
13  * use #alarm directly.
14  *
15  * Your handlers will run from vcore context.
16  *
17  * Code differences from the kernel (for future porting):
18  * - init_alarm_service, run as a constructor
19  * - set_alarm() and friends are __tc_set_alarm(), passing global_tchain.
20  * - reset_tchain_interrupt() uses #alarm
21  * - spinlocks -> spin_pdr_locks (cv's lock, actually)
22  * - ev_q wrappers for converting #alarm events to __triggers
23  * - printks, and other minor stuff. */
24
25 #include <sys/queue.h>
26 #include <sys/time.h>
27 #include <parlib/alarm.h>
28 #include <stdio.h>
29 #include <parlib/assert.h>
30 #include <parlib/stdio.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <fcntl.h>
36 #include <parlib/parlib.h>
37 #include <parlib/event.h>
38 #include <parlib/uthread.h>
39 #include <parlib/spinlock.h>
40 #include <parlib/timing.h>
41 #include <sys/plan9_helpers.h>
42 #include <sys/fork_cb.h>
43
44 /* Helper to get your own alarm.   If you don't care about a return value, pass
45  * 0 and it'll be ignored.  The alarm is built, but has no evq or timer set. */
46 int devalarm_get_fds(int *ctlfd_r, int *timerfd_r, int *alarmid_r)
47 {
48         int ctlfd, timerfd, alarmid, ret;
49         char buf[20];
50         char path[32];
51
52         ctlfd = open("#alarm/clone", O_RDWR | O_CLOEXEC);
53         if (ctlfd < 0)
54                 return -1;
55         ret = read(ctlfd, buf, sizeof(buf) - 1);
56         if (ret <= 0)
57                 return -1;
58         buf[ret] = 0;
59         alarmid = atoi(buf);
60         snprintf(path, sizeof(path), "#alarm/a%s/timer", buf);
61         timerfd = open(path, O_RDWR | O_CLOEXEC);
62         if (timerfd < 0)
63                 return -1;
64         if (ctlfd_r)
65                 *ctlfd_r = ctlfd;
66         else
67                 close(ctlfd);
68         if (timerfd_r)
69                 *timerfd_r = timerfd;
70         else
71                 close(timerfd);
72         if (alarmid_r)
73                 *alarmid_r = alarmid;
74         return 0;
75 }
76
77 int devalarm_set_evq(int timerfd, struct event_queue *ev_q, int alarmid)
78 {
79         struct fd_tap_req tap_req = {0};
80
81         tap_req.fd = timerfd;
82         tap_req.cmd = FDTAP_CMD_ADD;
83         tap_req.filter = FDTAP_FILT_WRITTEN;
84         tap_req.ev_id = EV_ALARM;
85         tap_req.ev_q = ev_q;
86         tap_req.data = (void*)(long)alarmid;
87         if (sys_tap_fds(&tap_req, 1) != 1)
88                 return -1;
89         return 0;
90 }
91
92 int devalarm_set_time(int timerfd, uint64_t tsc_time)
93 {
94         return write_hex_to_fd(timerfd, tsc_time);
95 }
96
97 int devalarm_get_id(struct event_msg *ev_msg)
98 {
99         if (!ev_msg)
100                 return -1;
101         return (int)(long)ev_msg->ev_arg3;
102 }
103
104 int devalarm_disable(int timerfd)
105 {
106         return write_hex_to_fd(timerfd, 0);
107 }
108
109 /* Helpers, basically renamed kernel interfaces, with the *tchain. */
110 static void __tc_set_alarm(struct timer_chain *tchain,
111                            struct alarm_waiter *waiter);
112 static bool __tc_unset_alarm(struct timer_chain *tchain,
113                              struct alarm_waiter *waiter);
114 static bool __tc_reset_alarm_abs(struct timer_chain *tchain,
115                                  struct alarm_waiter *waiter,
116                                  uint64_t abs_time);
117 static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type,
118                               void *data);
119
120 /* One chain to rule them all. */
121 struct timer_chain global_tchain;
122
123 /* Helper, resets the earliest/latest times, based on the elements of the list.
124  * If the list is empty, we set the times to be the 12345 poison time.  Since
125  * the list is empty, the alarm shouldn't be going off. */
126 static void reset_tchain_times(struct timer_chain *tchain)
127 {
128         if (TAILQ_EMPTY(&tchain->waiters)) {
129                 tchain->earliest_time = ALARM_POISON_TIME;
130                 tchain->latest_time = ALARM_POISON_TIME;
131         } else {
132                 tchain->earliest_time =
133                     TAILQ_FIRST(&tchain->waiters)->wake_up_time;
134                 tchain->latest_time =
135                     TAILQ_LAST(&tchain->waiters, awaiters_tailq)->wake_up_time;
136         }
137 }
138
139 static void devalarm_forked(void)
140 {
141         close(global_tchain.ctlfd);
142         close(global_tchain.timerfd);
143         if (devalarm_get_fds(&global_tchain.ctlfd, &global_tchain.timerfd,
144                              NULL))
145                 perror("Useralarm on fork");
146 }
147
148 static void __attribute__((constructor)) alarm_service_ctor(void)
149 {
150         int ctlfd, timerfd, alarmid;
151         struct event_queue *ev_q;
152         static struct fork_cb devalarm_fork_cb = {.func = devalarm_forked};
153
154         if (__in_fake_parlib())
155                 return;
156         /* Sets up timer chain (only one chain per process) */
157         TAILQ_INIT(&global_tchain.waiters);
158         global_tchain.running = NULL;
159         reset_tchain_times(&global_tchain);
160         uth_cond_var_init(&global_tchain.cv);
161
162         if (devalarm_get_fds(&ctlfd, &timerfd, &alarmid)) {
163                 perror("Useralarm: devalarm_get_fds");
164                 return;
165         }
166         /* Since we're doing SPAM_PUBLIC later, we actually don't need a big
167          * ev_q.  But someone might copy/paste this and change a flag. */
168         register_ev_handler(EV_ALARM, handle_user_alarm, 0);
169         if (!(ev_q = get_eventq(EV_MBOX_UCQ))) {
170                 perror("Useralarm: Failed ev_q");
171                 return;
172         }
173         ev_q->ev_vcore = 0;
174         /* We could get multiple events for a single alarm.  It's okay, since
175          * __trigger can handle spurious upcalls.  If it ever is not okay, then
176          * use an INDIR (probably with SPAM_INDIR too) instead of SPAM_PUBLIC.
177          */
178         ev_q->ev_flags = EVENT_IPI | EVENT_SPAM_PUBLIC | EVENT_WAKEUP;
179         if (devalarm_set_evq(timerfd, ev_q, alarmid)) {
180                 perror("set_alarm_evq");
181                 return;
182         }
183         /* now the alarm is all set, just need to write the timer whenever we
184          * want it to go off. */
185         global_tchain.alarmid = alarmid;
186         global_tchain.ctlfd = ctlfd;
187         global_tchain.timerfd = timerfd;
188         global_tchain.ev_q = ev_q;      /* mostly for debugging */
189         register_fork_cb(&devalarm_fork_cb);
190 }
191
192 /* Initializes a new awaiter. */
193 void init_awaiter(struct alarm_waiter *waiter,
194                   void (*func) (struct alarm_waiter *awaiter))
195 {
196         waiter->wake_up_time = ALARM_POISON_TIME;
197         assert(func);
198         waiter->func = func;
199         waiter->on_tchain = false;
200 }
201
202 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
203  * the alarm to go off. */
204 static void __set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
205 {
206         waiter->wake_up_time = abs_time;
207 }
208
209 /* Give this the absolute unix time (in microseconds) that you want the alarm
210  * to go off. */
211 void set_awaiter_abs_unix(struct alarm_waiter *waiter, uint64_t abs_usec)
212 {
213         __set_awaiter_abs(waiter, epoch_nsec_to_tsc(abs_usec * 1000));
214 }
215
216 /* Give this a relative time from now, in microseconds.  This might be easier to
217  * use than dealing with the TSC. */
218 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
219 {
220         uint64_t now, then;
221
222         now = read_tsc();
223         then = now + usec2tsc(usleep);
224         /* This will go off if we wrap-around the TSC.  It'll never happen for
225          * legit values, but this might catch some bugs with large usleeps. */
226         assert(now <= then);
227         __set_awaiter_abs(waiter, then);
228 }
229
230 /* Increment the timer that was already set, so that it goes off usleep usec
231  * from the previous tick.  This is different than 'rel' in that it doesn't care
232  * about when 'now' is. */
233 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
234 {
235         assert(waiter->wake_up_time != ALARM_POISON_TIME);
236         waiter->wake_up_time += usec2tsc(usleep);
237 }
238
239 /* User interface to the global tchain */
240 void set_alarm(struct alarm_waiter *waiter)
241 {
242         __tc_set_alarm(&global_tchain, waiter);
243 }
244
245 bool unset_alarm(struct alarm_waiter *waiter)
246 {
247         return __tc_unset_alarm(&global_tchain, waiter);
248 }
249
250 bool reset_alarm_abs(struct alarm_waiter *waiter, uint64_t abs_time)
251 {
252         return __tc_reset_alarm_abs(&global_tchain, waiter, abs_time);
253 }
254
255 /* Helper, makes sure the kernel alarm is turned on at the right time. */
256 static void reset_tchain_interrupt(struct timer_chain *tchain)
257 {
258         if (TAILQ_EMPTY(&tchain->waiters)) {
259                 /* Turn it off */
260                 printd("Turning alarm off\n");
261                 if (devalarm_disable(tchain->timerfd)) {
262                         printf("Useralarm: unable to disarm alarm!\n");
263                         return;
264                 }
265         } else {
266                 /* Make sure it is on and set to the earliest time */
267                 assert(tchain->earliest_time != ALARM_POISON_TIME);
268                 /* TODO: check for times in the past or very close to now */
269                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
270                 if (devalarm_set_time(tchain->timerfd, tchain->earliest_time)) {
271                         perror("Useralarm: Failed to set timer");
272                         return;
273                 }
274         }
275 }
276
277 /* This is called when the kernel alarm triggers a tchain, and needs to wake up
278  * everyone whose time is up.  Called from vcore context. */
279 static void __trigger_tchain(struct timer_chain *tchain)
280 {
281         struct alarm_waiter *i, *temp;
282         struct uthread *unsetter;
283
284         spin_pdr_lock(&tchain->cv.lock);
285         /* It's possible we have multiple contexts running a single tchain.  It
286          * shouldn't be possible for per-core tchains, but it is possible
287          * otherwise.  In that case, we can just abort, treating the event/IRQ
288          * that woke us up as a 'poke'. */
289         if (tchain->running) {
290                 spin_pdr_unlock(&tchain->cv.lock);
291                 return;
292         }
293         while ((i = TAILQ_FIRST(&tchain->waiters))) {
294                 /* TODO: Could also do something in cases where it's close to
295                  * expiring. */
296                 if (i->wake_up_time > read_tsc())
297                         break;
298                 TAILQ_REMOVE(&tchain->waiters, i, next);
299                 i->on_tchain = false;
300                 tchain->running = i;
301
302                 /* Need the tchain times (earliest/latest) in sync when
303                  * unlocked. */
304                 reset_tchain_times(tchain);
305
306                 spin_pdr_unlock(&tchain->cv.lock);
307
308                 /* Don't touch the waiter after running it, since the memory can
309                  * be used immediately */
310                 i->func(i);
311
312                 spin_pdr_lock(&tchain->cv.lock);
313                 tchain->running = NULL;
314
315                 /* This is the guts of a signal, but we're optimizing for the
316                  * common case where there is no unsetter.  Uthread CV
317                  * signal/broadcast wakes the uthreads up outside of the CV
318                  * lock, which will avoid any lock-ordering issues with the 2LS
319                  * and the CV - in this case, the alarm service. */
320                 unsetter = __uth_cond_var_wake_one(&tchain->cv);
321                 if (unsetter) {
322                         spin_pdr_unlock(&tchain->cv.lock);
323                         uthread_runnable(unsetter);
324                         spin_pdr_lock(&tchain->cv.lock);
325                 }
326         }
327         reset_tchain_interrupt(tchain);
328         spin_pdr_unlock(&tchain->cv.lock);
329 }
330
331 static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type,
332                               void *data)
333 {
334         assert(ev_type == EV_ALARM);
335         if (devalarm_get_id(ev_msg) == global_tchain.alarmid)
336                 __trigger_tchain(&global_tchain);
337 }
338
339 /* Helper, inserts the waiter into the tchain, returning TRUE if we still need
340  * to reset the tchain interrupt.  Caller holds the lock. */
341 static bool __insert_awaiter(struct timer_chain *tchain,
342                              struct alarm_waiter *waiter)
343 {
344         struct alarm_waiter *i, *temp;
345
346         waiter->on_tchain = TRUE;
347         /* Either the list is empty, or not. */
348         if (TAILQ_EMPTY(&tchain->waiters)) {
349                 tchain->earliest_time = waiter->wake_up_time;
350                 tchain->latest_time = waiter->wake_up_time;
351                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
352                 /* Need to turn on the timer interrupt later */
353                 return TRUE;
354         }
355         /* If not, either we're first, last, or in the middle.  Reset the
356          * interrupt and adjust the tchain's times accordingly. */
357         if (waiter->wake_up_time < tchain->earliest_time) {
358                 tchain->earliest_time = waiter->wake_up_time;
359                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
360                 /* Changed the first entry; we'll need to reset the interrupt
361                  * later */
362                 return TRUE;
363         }
364         /* If there is a tie for last, the newer one will really go last.  We
365          * need to handle equality here since the loop later won't catch it. */
366         if (waiter->wake_up_time >= tchain->latest_time) {
367                 tchain->latest_time = waiter->wake_up_time;
368                 /* Proactively put it at the end if we know we're last */
369                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
370                 return FALSE;
371         }
372         /* Insert before the first one you are earlier than.  This won't scale
373          * well (TODO) if we have a lot of inserts.  The proactive insert_tail
374          * up above will help a bit. */
375         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
376                 if (waiter->wake_up_time < i->wake_up_time) {
377                         TAILQ_INSERT_BEFORE(i, waiter, next);
378                         return FALSE;
379                 }
380         }
381         panic("Could not find a spot for awaiter %p\n", waiter);
382 }
383
384 static void __tc_set_alarm(struct timer_chain *tchain,
385                            struct alarm_waiter *waiter)
386 {
387         assert(waiter->wake_up_time != ALARM_POISON_TIME);
388         assert(!waiter->on_tchain);
389
390         spin_pdr_lock(&tchain->cv.lock);
391         if (__insert_awaiter(tchain, waiter))
392                 reset_tchain_interrupt(tchain);
393         spin_pdr_unlock(&tchain->cv.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
405         /* Need to make sure earliest and latest are set, in case we're mucking
406          * with the first and/or last element of the chain. */
407         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
408                 temp = TAILQ_NEXT(waiter, next);
409                 tchain->earliest_time = (temp) ? temp->wake_up_time :
410                                                  ALARM_POISON_TIME;
411                 reset_int = TRUE; /* we'll need to reset the timer later */
412         }
413         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
414                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
415                 tchain->latest_time = (temp) ? temp->wake_up_time :
416                                                ALARM_POISON_TIME;
417         }
418         TAILQ_REMOVE(&tchain->waiters, waiter, next);
419         waiter->on_tchain = FALSE;
420         return reset_int;
421 }
422
423 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
424  * disarmed before the alarm went off, FALSE if it already fired.  May block,
425  * since the handler may be running asynchronously. */
426 static bool __tc_unset_alarm(struct timer_chain *tchain,
427                              struct alarm_waiter *waiter)
428 {
429         spin_pdr_lock(&tchain->cv.lock);
430         for (;;) {
431                 if (waiter->on_tchain) {
432                         if (__remove_awaiter(tchain, waiter))
433                                 reset_tchain_interrupt(tchain);
434                         spin_pdr_unlock(&tchain->cv.lock);
435                         return true;
436                 }
437                 if (tchain->running != waiter) {
438                         spin_pdr_unlock(&tchain->cv.lock);
439                         return false;
440                 }
441                 /* It's running.  We'll need to try again.  Note the alarm could
442                  * have resubmitted itself, so ideally the caller can tell it to
443                  * not resubmit.
444                  *
445                  * Despite the slightly more difficult wake-up code in userspace
446                  * compared to the kernel, it's still better to use a CV here.
447                  * Some go tests in qemu were more likely to timeout/starve even
448                  * if we did some form of unlock/yield/relock pattern. */
449                 uth_cond_var_wait(&tchain->cv, NULL);
450         }
451 }
452
453 /* waiter may be on the tchain, or it might have fired already and be off the
454  * tchain.  Either way, this will put the waiter on the list, set to go off at
455  * abs_time.  If you know the alarm has fired, don't call this.  Just set the
456  * awaiter, and then set_alarm() */
457 static bool __tc_reset_alarm_abs(struct timer_chain *tchain,
458                                  struct alarm_waiter *waiter, uint64_t abs_time)
459 {
460         bool ret;
461
462         ret = __tc_unset_alarm(tchain, waiter);
463         __set_awaiter_abs(waiter, abs_time);
464         __tc_set_alarm(tchain, waiter);
465         return ret;
466 }
467
468 /* Debug helpers */
469
470 void print_chain(struct timer_chain *tchain)
471 {
472         struct alarm_waiter *i;
473         spin_pdr_lock(&tchain->cv.lock);
474         printf("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
475                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
476                tchain->earliest_time,
477                tchain->latest_time);
478         spin_pdr_unlock(&tchain->cv.lock);
479 }
480
481 /* "parlib" alarm handlers */
482 void alarm_abort_sysc(struct alarm_waiter *awaiter)
483 {
484         struct uthread *uth = awaiter->data;
485
486         assert(uth);
487         if (uth->sysc && sys_abort_sysc(uth->sysc))
488                 return;
489         /* There are a bunch of reasons why we didn't abort the syscall.  The
490          * syscall might not have been issued or blocked at all, so uth->sysc
491          * would be NULL.  The syscall might have blocked, but at a
492          * non-abortable location
493          * - picture blocking on a qlock, then unblocking and blocking later on
494          *   a rendez.  If you try to abort in between, abort_sysc will fail,
495          *   then we'll get blocked on the rendez until the next abort.
496          *   Finally, the syscall might have completed, but the uthread hasn't
497          *   cancelled the alarm yet.
498          *
499          * It's always safe to rearm the alarm - the uthread will unset it and
500          * break us out of the rearm loop. */
501         set_awaiter_rel(awaiter, 10000);
502         set_alarm(awaiter);
503 }