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