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