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