alarm: Clean up condition variable usage
[akaros.git] / user / parlib / 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 #alarm device and an alarm service, based off a slimmed down version
7  * of the kernel alarms.  Under the hood, the user alarm uses the #alarm service
8  * for 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 #alarm 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 as a constructor
18  * - set_alarm() and friends are __tc_set_alarm(), passing global_tchain.
19  * - reset_tchain_interrupt() uses #alarm
20  * - removed anything related to semaphores or kthreads
21  * - spinlocks -> spin_pdr_locks
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 = TAILQ_FIRST(&tchain->waiters)->wake_up_time;
133                 tchain->latest_time =
134                         TAILQ_LAST(&tchain->waiters, awaiters_tailq)->wake_up_time;
135         }
136 }
137
138 static void devalarm_forked(void)
139 {
140         close(global_tchain.ctlfd);
141         close(global_tchain.timerfd);
142         if (devalarm_get_fds(&global_tchain.ctlfd, &global_tchain.timerfd, NULL))
143                 perror("Useralarm on fork");
144 }
145
146 static void __attribute__((constructor)) alarm_service_ctor(void)
147 {
148         int ctlfd, timerfd, alarmid;
149         struct event_queue *ev_q;
150         static struct fork_cb devalarm_fork_cb = {.func = devalarm_forked};
151
152         if (__in_fake_parlib())
153                 return;
154         /* Sets up timer chain (only one chain per process) */
155         spin_pdr_init(&global_tchain.lock);
156         TAILQ_INIT(&global_tchain.waiters);
157         reset_tchain_times(&global_tchain);
158
159         if (devalarm_get_fds(&ctlfd, &timerfd, &alarmid)) {
160                 perror("Useralarm: devalarm_get_fds");
161                 return;
162         }
163         /* Since we're doing SPAM_PUBLIC later, we actually don't need a big ev_q.
164          * But someone might copy/paste this and change a flag. */
165         register_ev_handler(EV_ALARM, handle_user_alarm, 0);
166         if (!(ev_q = get_eventq(EV_MBOX_UCQ))) {
167                 perror("Useralarm: Failed ev_q");
168                 return;
169         }
170         ev_q->ev_vcore = 0;
171         /* We could get multiple events for a single alarm.  It's okay, since
172          * __trigger can handle spurious upcalls.  If it ever is not okay, then use
173          * an INDIR (probably with SPAM_INDIR too) instead of SPAM_PUBLIC. */
174         ev_q->ev_flags = EVENT_IPI | EVENT_SPAM_PUBLIC | EVENT_WAKEUP;
175         if (devalarm_set_evq(timerfd, ev_q, alarmid)) {
176                 perror("set_alarm_evq");
177                 return;
178         }
179         /* now the alarm is all set, just need to write the timer whenever we want
180          * it to go off. */
181         global_tchain.alarmid = alarmid;
182         global_tchain.ctlfd = ctlfd;
183         global_tchain.timerfd = timerfd;
184         global_tchain.ev_q = ev_q;      /* mostly for debugging */
185         register_fork_cb(&devalarm_fork_cb);
186 }
187
188 /* Initializes a new awaiter. */
189 void init_awaiter(struct alarm_waiter *waiter,
190                   void (*func) (struct alarm_waiter *awaiter))
191 {
192         waiter->wake_up_time = ALARM_POISON_TIME;
193         assert(func);
194         waiter->func = func;
195         waiter->on_tchain = false;
196         waiter->is_running = false;
197         waiter->no_rearm = false;
198         uth_cond_var_init(&waiter->done_cv);
199 }
200
201 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
202  * the alarm to go off. */
203 static void __set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
204 {
205         waiter->wake_up_time = abs_time;
206 }
207
208 /* Give this the absolute unix time (in microseconds) that you want the alarm
209  * to go off. */
210 void set_awaiter_abs_unix(struct alarm_waiter *waiter, uint64_t abs_usec)
211 {
212         __set_awaiter_abs(waiter, epoch_nsec_to_tsc(abs_usec * 1000));
213 }
214
215 /* Give this a relative time from now, in microseconds.  This might be easier to
216  * use than dealing with the TSC. */
217 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
218 {
219         uint64_t now, then;
220         now = read_tsc();
221         then = now + usec2tsc(usleep);
222         /* This will go off if we wrap-around the TSC.  It'll never happen for legit
223          * values, but this might catch some bugs with large usleeps. */
224         assert(now <= then);
225         __set_awaiter_abs(waiter, then);
226 }
227
228 /* Increment the timer that was already set, so that it goes off usleep usec
229  * from the previous tick.  This is different than 'rel' in that it doesn't care
230  * about when 'now' is. */
231 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
232 {
233         assert(waiter->wake_up_time != ALARM_POISON_TIME);
234         waiter->wake_up_time += usec2tsc(usleep);
235 }
236
237 /* User interface to the global tchain */
238 void set_alarm(struct alarm_waiter *waiter)
239 {
240         __tc_set_alarm(&global_tchain, waiter);
241 }
242
243 bool unset_alarm(struct alarm_waiter *waiter)
244 {
245         return __tc_unset_alarm(&global_tchain, waiter);
246 }
247
248 bool reset_alarm_abs(struct alarm_waiter *waiter, uint64_t abs_time)
249 {
250         return __tc_reset_alarm_abs(&global_tchain, waiter, abs_time);
251 }
252
253 /* Helper, makes sure the kernel alarm is turned on at the right time. */
254 static void reset_tchain_interrupt(struct timer_chain *tchain)
255 {
256         if (TAILQ_EMPTY(&tchain->waiters)) {
257                 /* Turn it off */
258                 printd("Turning alarm off\n");
259                 if (devalarm_disable(tchain->timerfd)) {
260                         printf("Useralarm: unable to disarm alarm!\n");
261                         return;
262                 }
263         } else {
264                 /* Make sure it is on and set to the earliest time */
265                 assert(tchain->earliest_time != ALARM_POISON_TIME);
266                 /* TODO: check for times in the past or very close to now */
267                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
268                 if (devalarm_set_time(tchain->timerfd, tchain->earliest_time)) {
269                         perror("Useralarm: Failed to set timer");
270                         return;
271                 }
272         }
273 }
274
275 /* When an awaiter's time has come, this gets called. */
276 static void wake_awaiter(struct alarm_waiter *waiter)
277 {
278         waiter->func(waiter);
279         uth_cond_var_lock(&waiter->done_cv);
280         waiter->is_running = false;
281         __uth_cond_var_broadcast_and_unlock(&waiter->done_cv);
282 }
283
284 /* This is called when the kernel alarm triggers a tchain, and needs to wake up
285  * everyone whose time is up.  Called from vcore context. */
286 static void __trigger_tchain(struct timer_chain *tchain)
287 {
288         struct alarm_waiter *i, *temp;
289         uint64_t now = read_tsc();
290         struct awaiters_tailq to_wake = TAILQ_HEAD_INITIALIZER(to_wake);
291
292         spin_pdr_lock(&tchain->lock);
293         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
294                 printd("Trying to wake up %p who is due at %llu and now is %llu\n",
295                        i, i->wake_up_time, now);
296                 /* TODO: Could also do something in cases where we're close to now */
297                 if (i->wake_up_time > now)
298                         break;
299                 /* At this point, unset must wait until it has finished */
300                 i->on_tchain = false;
301                 i->is_running = true;
302                 TAILQ_REMOVE(&tchain->waiters, i, next);
303                 TAILQ_INSERT_TAIL(&to_wake, i, next);
304         }
305         reset_tchain_times(tchain);
306         reset_tchain_interrupt(tchain);
307         spin_pdr_unlock(&tchain->lock);
308
309         TAILQ_FOREACH_SAFE(i, &to_wake, next, temp) {
310                 /* Don't touch the waiter after waking it, since it could be in use on
311                  * another core (and the waiter can be clobbered as the kthread unwinds
312                  * its stack).  Or it could be kfreed.  Technically, the waiter hasn't
313                  * finished until we cleared is_running and unlocked the cv lock. */
314                 TAILQ_REMOVE(&to_wake, i, next);
315                 wake_awaiter(i);
316         }
317 }
318
319 static void handle_user_alarm(struct event_msg *ev_msg, unsigned int ev_type,
320                               void *data)
321 {
322         assert(ev_type == EV_ALARM);
323         if (devalarm_get_id(ev_msg) == global_tchain.alarmid)
324                 __trigger_tchain(&global_tchain);
325 }
326
327 /* Helper, inserts the waiter into the tchain, returning TRUE if we still need
328  * to reset the tchain interrupt.  Caller holds the lock. */
329 static bool __insert_awaiter(struct timer_chain *tchain,
330                              struct alarm_waiter *waiter)
331 {
332         struct alarm_waiter *i, *temp;
333
334         waiter->on_tchain = TRUE;
335         /* Either the list is empty, or not. */
336         if (TAILQ_EMPTY(&tchain->waiters)) {
337                 tchain->earliest_time = waiter->wake_up_time;
338                 tchain->latest_time = waiter->wake_up_time;
339                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
340                 /* Need to turn on the timer interrupt later */
341                 return TRUE;
342         }
343         /* If not, either we're first, last, or in the middle.  Reset the interrupt
344          * and adjust the tchain's times accordingly. */
345         if (waiter->wake_up_time < tchain->earliest_time) {
346                 tchain->earliest_time = waiter->wake_up_time;
347                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
348                 /* Changed the first entry; we'll need to reset the interrupt later */
349                 return TRUE;
350         }
351         /* If there is a tie for last, the newer one will really go last.  We need
352          * to handle equality here since the loop later won't catch it. */
353         if (waiter->wake_up_time >= tchain->latest_time) {
354                 tchain->latest_time = waiter->wake_up_time;
355                 /* Proactively put it at the end if we know we're last */
356                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
357                 return FALSE;
358         }
359         /* Insert before the first one you are earlier than.  This won't scale well
360          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
361          * will help a bit. */
362         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
363                 if (waiter->wake_up_time < i->wake_up_time) {
364                         TAILQ_INSERT_BEFORE(i, waiter, next);
365                         return FALSE;
366                 }
367         }
368         panic("Could not find a spot for awaiter %p\n", waiter);
369 }
370
371 static void __tc_set_alarm(struct timer_chain *tchain,
372                            struct alarm_waiter *waiter)
373 {
374         assert(waiter->wake_up_time != ALARM_POISON_TIME);
375         assert(!waiter->on_tchain);
376
377         spin_pdr_lock(&tchain->lock);
378         if (waiter->no_rearm) {
379                 spin_pdr_unlock(&tchain->lock);
380                 return;
381         }
382         if (__insert_awaiter(tchain, waiter))
383                 reset_tchain_interrupt(tchain);
384         spin_pdr_unlock(&tchain->lock);
385 }
386
387 /* Helper, rips the waiter from the tchain, knowing that it is on the list.
388  * Returns TRUE if the tchain interrupt needs to be reset.  Callers hold the
389  * lock. */
390 static bool __remove_awaiter(struct timer_chain *tchain,
391                              struct alarm_waiter *waiter)
392 {
393         struct alarm_waiter *temp;
394         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
395
396         /* Need to make sure earliest and latest are set, in case we're mucking with
397          * the first and/or last element of the chain. */
398         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
399                 temp = TAILQ_NEXT(waiter, next);
400                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
401                 reset_int = TRUE;               /* we'll need to reset the timer later */
402         }
403         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
404                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
405                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
406         }
407         TAILQ_REMOVE(&tchain->waiters, waiter, next);
408         waiter->on_tchain = FALSE;
409         return reset_int;
410 }
411
412 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
413  * disarmed before the alarm went off, FALSE if it already fired.  May block,
414  * since the handler may be running asynchronously. */
415 static bool __tc_unset_alarm(struct timer_chain *tchain,
416                              struct alarm_waiter *waiter)
417 {
418         spin_pdr_lock(&tchain->lock);
419         if (waiter->on_tchain) {
420                 if (__remove_awaiter(tchain, waiter))
421                         reset_tchain_interrupt(tchain);
422                 spin_pdr_unlock(&tchain->lock);
423                 return true;
424         }
425
426         /* A common case is that it already finished.  We need the CV lock farther
427          * below so that we don't miss the signal.  You don't need it if you can see
428          * the signal (is_running == false) is already sent. */
429         if (!waiter->is_running) {
430                 spin_pdr_unlock(&tchain->lock);
431                 return false;
432         }
433
434         /* no_rearm is set and checked under the tchain lock.  It is cleared when
435          * unset completes, outside the lock.  That is safe since we know the alarm
436          * service is no longer aware of waiter (either the handler ran or we
437          * stopped it). */
438         waiter->no_rearm = true;
439         spin_pdr_unlock(&tchain->lock);
440
441         uth_cond_var_lock(&waiter->done_cv);
442         while (waiter->is_running)
443                 uth_cond_var_wait(&waiter->done_cv, NULL);
444         uth_cond_var_unlock(&waiter->done_cv);
445
446         waiter->no_rearm = false;
447         return false;
448 }
449
450 /* waiter may be on the tchain, or it might have fired already and be off the
451  * tchain.  Either way, this will put the waiter on the list, set to go off at
452  * abs_time.  If you know the alarm has fired, don't call this.  Just set the
453  * awaiter, and then set_alarm() */
454 static bool __tc_reset_alarm_abs(struct timer_chain *tchain,
455                                  struct alarm_waiter *waiter, uint64_t abs_time)
456 {
457         bool ret;
458
459         ret = __tc_unset_alarm(tchain, waiter);
460         __set_awaiter_abs(waiter, abs_time);
461         __tc_set_alarm(tchain, waiter);
462         return ret;
463 }
464
465 /* Debug helpers */
466
467 void print_chain(struct timer_chain *tchain)
468 {
469         struct alarm_waiter *i;
470         spin_pdr_lock(&tchain->lock);
471         printf("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
472                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
473                tchain->earliest_time,
474                tchain->latest_time);
475         spin_pdr_unlock(&tchain->lock);
476 }
477
478 /* "parlib" alarm handlers */
479 void alarm_abort_sysc(struct alarm_waiter *awaiter)
480 {
481         struct uthread *uth = awaiter->data;
482
483         assert(uth);
484         if (uth->sysc && sys_abort_sysc(uth->sysc))
485                 return;
486         /* There are a bunch of reasons why we didn't abort the syscall.  The
487          * syscall might not have been issued or blocked at all, so uth->sysc would
488          * be NULL.  The syscall might have blocked, but at a non-abortable location
489          * - picture blocking on a qlock, then unblocking and blocking later on a
490          * rendez.  If you try to abort in between, abort_sysc will fail, then we'll
491          * get blocked on the rendez until the next abort.  Finally, the syscall
492          * might have completed, but the uthread hasn't cancelled the alarm yet.
493          *
494          * It's always safe to rearm the alarm - the uthread will unset it and break
495          * us out of the rearm loop. */
496         set_awaiter_rel(awaiter, 10000);
497         set_alarm(awaiter);
498 }