Remove the alarm-with-no-func use case
[akaros.git] / kern / src / alarm.c
1 /* Copyright (c) 2011 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Alarms.  This includes ways to defer work on a specific timer.  These can be
6  * per-core, global or whatever.  Like with most systems, you won't wake up til
7  * after the time you specify. (for now, this might change).
8  *
9  * TODO:
10  *      - have a kernel sense of time, instead of just the TSC or whatever timer the
11  *      chain uses...
12  *      - coalesce or otherwise deal with alarms that are close to cut down on
13  *      interrupt overhead. */
14
15 #include <ros/common.h>
16 #include <sys/queue.h>
17 #include <kthread.h>
18 #include <alarm.h>
19 #include <stdio.h>
20 #include <smp.h>
21 #include <kmalloc.h>
22
23 /* Helper, resets the earliest/latest times, based on the elements of the list.
24  * If the list is empty, we set the times to be the 12345 poison time.  Since
25  * the list is empty, the alarm shouldn't be going off. */
26 static void reset_tchain_times(struct timer_chain *tchain)
27 {
28         if (TAILQ_EMPTY(&tchain->waiters)) {
29                 tchain->earliest_time = ALARM_POISON_TIME;
30                 tchain->latest_time = ALARM_POISON_TIME;
31         } else {
32                 tchain->earliest_time = TAILQ_FIRST(&tchain->waiters)->wake_up_time;
33                 tchain->latest_time =
34                         TAILQ_LAST(&tchain->waiters, awaiters_tailq)->wake_up_time;
35         }
36 }
37
38 /* One time set up of a tchain, currently called in per_cpu_init() */
39 void init_timer_chain(struct timer_chain *tchain,
40                       void (*set_interrupt)(struct timer_chain *))
41 {
42         spinlock_init_irqsave(&tchain->lock);
43         TAILQ_INIT(&tchain->waiters);
44         tchain->set_interrupt = set_interrupt;
45         reset_tchain_times(tchain);
46 }
47
48 static void __init_awaiter(struct alarm_waiter *waiter)
49 {
50         waiter->wake_up_time = ALARM_POISON_TIME;
51         waiter->on_tchain = FALSE;
52         waiter->holds_tchain_lock = FALSE;
53 }
54
55 void init_awaiter(struct alarm_waiter *waiter,
56                   void (*func) (struct alarm_waiter *awaiter))
57 {
58         waiter->irq_ok = FALSE;
59         assert(func);
60         waiter->func = func;
61         __init_awaiter(waiter);
62 }
63
64 void init_awaiter_irq(struct alarm_waiter *waiter,
65                       void (*func_irq) (struct alarm_waiter *awaiter,
66                                         struct hw_trapframe *hw_tf))
67 {
68         waiter->irq_ok = TRUE;
69         assert(func_irq);
70         waiter->func_irq = func_irq;
71         __init_awaiter(waiter);
72 }
73
74 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
75  * the alarm to go off. */
76 void set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
77 {
78         waiter->wake_up_time = abs_time;
79 }
80
81 /* Give this a relative time from now, in microseconds.  This might be easier to
82  * use than dealing with the TSC. */
83 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
84 {
85         uint64_t now, then;
86         now = read_tsc();
87         then = now + usec2tsc(usleep);
88         /* This will go off if we wrap-around the TSC.  It'll never happen for legit
89          * values, but this might catch some bugs with large usleeps. */
90         assert(now <= then);
91         set_awaiter_abs(waiter, then);
92 }
93
94 /* Increment the timer that was already set, so that it goes off usleep usec
95  * from the previous tick.  This is different than 'rel' in that it doesn't care
96  * about when 'now' is. */
97 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
98 {
99         assert(waiter->wake_up_time != ALARM_POISON_TIME);
100         waiter->wake_up_time += usec2tsc(usleep);
101 }
102
103 /* Helper, makes sure the interrupt is turned on at the right time.  Most of the
104  * heavy lifting is in the timer-source specific function pointer. */
105 static void reset_tchain_interrupt(struct timer_chain *tchain)
106 {
107         assert(!irq_is_enabled());
108         if (TAILQ_EMPTY(&tchain->waiters)) {
109                 /* Turn it off */
110                 printd("Turning alarm off\n");
111                 tchain->set_interrupt(tchain);
112         } else {
113                 /* Make sure it is on and set to the earliest time */
114                 assert(tchain->earliest_time != ALARM_POISON_TIME);
115                 /* TODO: check for times in the past or very close to now */
116                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
117                 tchain->set_interrupt(tchain);
118         }
119 }
120
121 static void __run_awaiter(uint32_t srcid, long a0, long a1, long a2)
122 {
123         struct alarm_waiter *waiter = (struct alarm_waiter*)a0;
124         waiter->func(waiter);
125 }
126
127 static void wake_awaiter(struct alarm_waiter *waiter,
128                          struct hw_trapframe *hw_tf)
129 {
130         if (waiter->irq_ok) {
131                 waiter->holds_tchain_lock = TRUE;
132                 waiter->func_irq(waiter, hw_tf);
133                 waiter->holds_tchain_lock = FALSE;
134         } else {
135                 send_kernel_message(core_id(), __run_awaiter, (long)waiter,
136                                     0, 0, KMSG_ROUTINE);
137         }
138 }
139
140 /* This is called when an interrupt triggers a tchain, and needs to wake up
141  * everyone whose time is up.  Called from IRQ context. */
142 void __trigger_tchain(struct timer_chain *tchain, struct hw_trapframe *hw_tf)
143 {
144         struct alarm_waiter *i, *temp;
145         uint64_t now = read_tsc();
146         bool changed_list = FALSE;
147         /* why do we disable irqs here?  the lock is irqsave, but we (think we) know
148          * the timer IRQ for this tchain won't fire again.  disabling irqs is nice
149          * for the lock debugger.  i don't want to disable the debugger completely,
150          * and we can't make the debugger ignore irq context code either in the
151          * general case.  it might be nice for handlers to have IRQs disabled too.*/
152         spin_lock_irqsave(&tchain->lock);
153         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
154                 printd("Trying to wake up %p who is due at %llu and now is %llu\n",
155                        i, i->wake_up_time, now);
156                 /* TODO: Could also do something in cases where we're close to now */
157                 if (i->wake_up_time <= now) {
158                         changed_list = TRUE;
159                         i->on_tchain = FALSE;
160                         TAILQ_REMOVE(&tchain->waiters, i, next);
161                         cmb();  /* enforce waking after removal */
162                         /* Don't touch the waiter after waking it, since it could be in use
163                          * on another core (and the waiter can be clobbered as the kthread
164                          * unwinds its stack).  Or it could be kfreed */
165                         wake_awaiter(i, hw_tf);
166                 } else {
167                         break;
168                 }
169         }
170         if (changed_list) {
171                 reset_tchain_times(tchain);
172         }
173         /* Need to reset the interrupt no matter what */
174         reset_tchain_interrupt(tchain);
175         spin_unlock_irqsave(&tchain->lock);
176 }
177
178 /* Helper, inserts the waiter into the tchain, returning TRUE if we still need
179  * to reset the tchain interrupt.  Caller holds the lock. */
180 static bool __insert_awaiter(struct timer_chain *tchain,
181                              struct alarm_waiter *waiter)
182 {
183         struct alarm_waiter *i, *temp;
184         /* This will fail if you don't set a time */
185         assert(waiter->wake_up_time != ALARM_POISON_TIME);
186         assert(!waiter->on_tchain);
187         waiter->on_tchain = TRUE;
188         /* Either the list is empty, or not. */
189         if (TAILQ_EMPTY(&tchain->waiters)) {
190                 tchain->earliest_time = waiter->wake_up_time;
191                 tchain->latest_time = waiter->wake_up_time;
192                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
193                 /* Need to turn on the timer interrupt later */
194                 return TRUE;
195         }
196         /* If not, either we're first, last, or in the middle.  Reset the interrupt
197          * and adjust the tchain's times accordingly. */
198         if (waiter->wake_up_time < tchain->earliest_time) {
199                 tchain->earliest_time = waiter->wake_up_time;
200                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
201                 /* Changed the first entry; we'll need to reset the interrupt later */
202                 return TRUE;
203         }
204         /* If there is a tie for last, the newer one will really go last.  We need
205          * to handle equality here since the loop later won't catch it. */
206         if (waiter->wake_up_time >= tchain->latest_time) {
207                 tchain->latest_time = waiter->wake_up_time;
208                 /* Proactively put it at the end if we know we're last */
209                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
210                 return FALSE;
211         }
212         /* Insert before the first one you are earlier than.  This won't scale well
213          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
214          * will help a bit. */
215         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
216                 if (waiter->wake_up_time < i->wake_up_time) {
217                         TAILQ_INSERT_BEFORE(i, waiter, next);
218                         return FALSE;
219                 }
220         }
221         panic("Could not find a spot for awaiter %p\n", waiter);
222 }
223
224 static void __set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
225 {
226         if (__insert_awaiter(tchain, waiter))
227                 reset_tchain_interrupt(tchain);
228 }
229
230 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
231  * later. */
232 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
233 {
234         if (waiter->holds_tchain_lock) {
235                 __set_alarm(tchain, waiter);
236         } else {
237                 spin_lock_irqsave(&tchain->lock);
238                 __set_alarm(tchain, waiter);
239                 spin_unlock_irqsave(&tchain->lock);
240         }
241 }
242
243 /* Helper, rips the waiter from the tchain, knowing that it is on the list.
244  * Returns TRUE if the tchain interrupt needs to be reset.  Callers hold the
245  * lock. */
246 static bool __remove_awaiter(struct timer_chain *tchain,
247                              struct alarm_waiter *waiter)
248 {
249         struct alarm_waiter *temp;
250         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
251         /* Need to make sure earliest and latest are set, in case we're mucking with
252          * the first and/or last element of the chain. */
253         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
254                 temp = TAILQ_NEXT(waiter, next);
255                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
256                 reset_int = TRUE;               /* we'll need to reset the timer later */
257         }
258         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
259                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
260                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
261         }
262         TAILQ_REMOVE(&tchain->waiters, waiter, next);
263         waiter->on_tchain = FALSE;
264         return reset_int;
265 }
266
267 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
268  * disarmed before the alarm went off, FALSE if it already fired. */
269 bool unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
270 {
271         assert(!waiter->holds_tchain_lock);     /* Don't call from within a handler */
272         spin_lock_irqsave(&tchain->lock);
273         bool ret = waiter->on_tchain;
274         if (ret && __remove_awaiter(tchain, waiter))
275                 reset_tchain_interrupt(tchain);
276
277         /* if alarm had already gone off then its not on this tchain's list, though
278          * the concurrent change to on_tchain (specifically, the setting of it to
279          * FALSE), happens under the tchain's lock. */
280         spin_unlock_irqsave(&tchain->lock);
281         return ret;
282 }
283
284 /* waiter may be on the tchain, or it might have fired already and be off the
285  * tchain.  Either way, this will put the waiter on the list, set to go off at
286  * abs_time.  If you know the alarm has fired, don't call this.  Just set the
287  * awaiter, and then set_alarm() */
288 static bool __reset_alarm_abs(struct timer_chain *tchain,
289                               struct alarm_waiter *waiter, uint64_t abs_time)
290 {
291         /* The tchain's lock is held */
292         bool ret = waiter->on_tchain;
293         /* We only need to remove/unset when the alarm has not fired yet (is still
294          * on the tchain).  If it has fired, it's like a fresh insert. We must also
295          * check if we need to reset the interrupt. */
296         bool reset_int = ret && __remove_awaiter(tchain, waiter);
297         set_awaiter_abs(waiter, abs_time);
298         /* regardless, we need to be reinserted */
299         if (__insert_awaiter(tchain, waiter) || reset_int)
300                 reset_tchain_interrupt(tchain);
301         return ret;
302 }
303
304 static bool __reset_alarm_rel(struct timer_chain *tchain,
305                               struct alarm_waiter *waiter, uint64_t usleep)
306 {
307         uint64_t now, then;
308         now = read_tsc();
309         then = now + usec2tsc(usleep);
310         assert(now <= then);
311         return __reset_alarm_abs(tchain, waiter, then);
312 }
313
314 bool reset_alarm_abs(struct timer_chain *tchain, struct alarm_waiter *waiter,
315                      uint64_t abs_time)
316 {
317         bool ret;
318         if (waiter->holds_tchain_lock) {
319                 ret = __reset_alarm_abs(tchain, waiter, abs_time);
320         } else {
321                 spin_lock_irqsave(&tchain->lock);
322                 ret = __reset_alarm_abs(tchain, waiter, abs_time);
323                 spin_unlock_irqsave(&tchain->lock);
324         }
325         return ret;
326 }
327
328 bool reset_alarm_rel(struct timer_chain *tchain, struct alarm_waiter *waiter,
329                      uint64_t usleep)
330 {
331         bool ret;
332         if (waiter->holds_tchain_lock) {
333                 ret =__reset_alarm_rel(tchain, waiter, usleep);
334         } else {
335                 spin_lock_irqsave(&tchain->lock);
336                 ret =__reset_alarm_rel(tchain, waiter, usleep);
337                 spin_unlock_irqsave(&tchain->lock);
338         }
339         return ret;
340 }
341
342 /* Sets the timer interrupt for the timer chain passed as parameter.
343  * The next interrupt will be scheduled at the nearest timer available in the
344  * chain.
345  * This function can be called either for the local CPU, or for a remote CPU.
346  * If called for the local CPU, it proceeds in setting up the local timer,
347  * otherwise it will trigger an IPI, and will let the remote CPU IRQ handler
348  * to setup the timer according to the active information on its timer chain.
349  *
350  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
351  * if time is 0.   Any function like this needs to do a few things:
352  *      - Make sure the interrupt is on and will go off when we want
353  *      - Make sure the interrupt source can find tchain
354  *      - Make sure the interrupt handler calls __trigger_tchain(tchain)
355  *      - Make sure you don't clobber an old tchain here (a bug)
356  * This implies the function knows how to find its timer source/void
357  *
358  * Called with the tchain lock held, and IRQs disabled.  However, we could be
359  * calling this cross-core, and we cannot disable those IRQs (hence the
360  * locking). */
361 void set_pcpu_alarm_interrupt(struct timer_chain *tchain)
362 {
363         uint64_t time, rel_usec, now;
364         int pcoreid = core_id();
365         struct per_cpu_info *rem_pcpui, *pcpui = &per_cpu_info[pcoreid];
366         struct timer_chain *pcpui_tchain = &pcpui->tchain;
367
368         if (pcpui_tchain != tchain) {
369                 /* cross-core call.  we can simply send an alarm IRQ.  the alarm handler
370                  * will reset its pcpu timer, based on its current lists.  they take an
371                  * extra IRQ, but it gets the job done. */
372                 rem_pcpui = (struct per_cpu_info*)((uintptr_t)tchain -
373                                     offsetof(struct per_cpu_info, tchain));
374                 /* TODO: using the LAPIC vector is a bit ghetto, since that's x86.  But
375                  * RISCV ignores the vector field, and we don't have a global IRQ vector
376                  * namespace or anything. */
377                 send_ipi(rem_pcpui - &per_cpu_info[0], IdtLAPIC_TIMER);
378                 return;
379         }
380         time = TAILQ_EMPTY(&tchain->waiters) ? 0 : tchain->earliest_time;
381         if (time) {
382                 /* Arm the alarm.  For times in the past, we just need to make sure it
383                  * goes off. */
384                 now = read_tsc();
385                 if (time <= now)
386                         rel_usec = 1;
387                 else
388                         rel_usec = tsc2usec(time - now);
389                 rel_usec = MAX(rel_usec, 1);
390                 printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
391                        "tchain %p\n", time, now, rel_usec, pcpui_tchain);
392                 set_core_timer(rel_usec, FALSE);
393         } else  {
394                 /* Disarm */
395                 set_core_timer(0, FALSE);
396         }
397 }
398
399 /* Debug helpers */
400
401 void print_chain(struct timer_chain *tchain)
402 {
403         struct alarm_waiter *i;
404         spin_lock_irqsave(&tchain->lock);
405         printk("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
406                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
407                tchain->earliest_time,
408                tchain->latest_time);
409         TAILQ_FOREACH(i, &tchain->waiters, next) {
410                 uintptr_t f;
411                 char *f_name;
412
413                 if (i->irq_ok)
414                         f = (uintptr_t)i->func_irq;
415                 else
416                         f = (uintptr_t)i->func;
417                 f_name = get_fn_name(f);
418                 printk("\tWaiter %p, time %llu, func %p (%s)\n", i,
419                        i->wake_up_time, f, f_name);
420                 kfree(f_name);
421         }
422         spin_unlock_irqsave(&tchain->lock);
423 }
424
425 /* Prints all chains, rather verbosely */
426 void print_pcpu_chains(void)
427 {
428         struct timer_chain *pcpu_chain;
429         printk("PCPU Chains:  It is now %llu\n", read_tsc());
430
431         for (int i = 0; i < num_cores; i++) {
432                 pcpu_chain = &per_cpu_info[i].tchain;
433                 print_chain(pcpu_chain);
434         }
435 }