Rename RCU CB context to 'cannot block' context
[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 void init_awaiter(struct alarm_waiter *waiter,
49                   void (*func) (struct alarm_waiter *awaiter))
50 {
51         assert(func);
52         waiter->func = func;
53         waiter->wake_up_time = ALARM_POISON_TIME;
54         waiter->on_tchain = false;
55         waiter->is_running = false;
56         waiter->no_rearm = false;
57         cv_init_irqsave(&waiter->done_cv);
58 }
59
60 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
61  * the alarm to go off. */
62 void set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
63 {
64         waiter->wake_up_time = abs_time;
65 }
66
67 /* Give this a relative time from now, in microseconds.  This might be easier to
68  * use than dealing with the TSC. */
69 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
70 {
71         uint64_t now, then;
72         now = read_tsc();
73         then = now + usec2tsc(usleep);
74         /* This will go off if we wrap-around the TSC.  It'll never happen for legit
75          * values, but this might catch some bugs with large usleeps. */
76         assert(now <= then);
77         set_awaiter_abs(waiter, then);
78 }
79
80 /* Increment the timer that was already set, so that it goes off usleep usec
81  * from the previous tick.  This is different than 'rel' in that it doesn't care
82  * about when 'now' is. */
83 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
84 {
85         assert(waiter->wake_up_time != ALARM_POISON_TIME);
86         waiter->wake_up_time += usec2tsc(usleep);
87 }
88
89 /* Helper, makes sure the interrupt is turned on at the right time.  Most of the
90  * heavy lifting is in the timer-source specific function pointer. */
91 static void reset_tchain_interrupt(struct timer_chain *tchain)
92 {
93         assert(!irq_is_enabled());
94         if (TAILQ_EMPTY(&tchain->waiters)) {
95                 /* Turn it off */
96                 printd("Turning alarm off\n");
97                 tchain->set_interrupt(tchain);
98         } else {
99                 /* Make sure it is on and set to the earliest time */
100                 assert(tchain->earliest_time != ALARM_POISON_TIME);
101                 /* TODO: check for times in the past or very close to now */
102                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
103                 tchain->set_interrupt(tchain);
104         }
105 }
106
107 static void __finish_awaiter(struct alarm_waiter *waiter)
108 {
109         int8_t irq_state = 0;
110
111         /* Syncing with unset_alarm.  They are waiting for us to tell them the
112          * waiter is not running.
113          *
114          * 'is_running' is set true under the tchain lock.  It's checked and cleared
115          * under the cv_lock, but not necessarily with the tchain lock. */
116         cv_lock_irqsave(&waiter->done_cv, &irq_state);
117         waiter->is_running = false;
118         /* broadcast, instead of signal.  This allows us to have multiple unsetters
119          * concurrently.  (only one of which will succeed, so YMMV.) */
120         __cv_broadcast(&waiter->done_cv);
121         cv_unlock_irqsave(&waiter->done_cv, &irq_state);
122 }
123
124 static void __run_awaiter(uint32_t srcid, long a0, long a1, long a2)
125 {
126         struct alarm_waiter *waiter = (struct alarm_waiter*)a0;
127
128         waiter->func(waiter);
129         __finish_awaiter(waiter);
130 }
131
132 static void wake_awaiter(struct alarm_waiter *waiter,
133                          struct hw_trapframe *hw_tf)
134 {
135         send_kernel_message(core_id(), __run_awaiter, (long)waiter,
136                             0, 0, KMSG_ROUTINE);
137 }
138
139 /* This is called when an interrupt triggers a tchain, and needs to wake up
140  * everyone whose time is up.  Called from IRQ context. */
141 void __trigger_tchain(struct timer_chain *tchain, struct hw_trapframe *hw_tf)
142 {
143         struct alarm_waiter *i, *temp;
144         uint64_t now = read_tsc();
145         struct awaiters_tailq to_wake = TAILQ_HEAD_INITIALIZER(to_wake);
146
147         spin_lock_irqsave(&tchain->lock);
148         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
149                 printd("Trying to wake up %p who is due at %llu and now is %llu\n",
150                        i, i->wake_up_time, now);
151                 /* TODO: Could also do something in cases where we're close to now */
152                 if (i->wake_up_time > now)
153                         break;
154                 /* At this point, unset must wait until it has finished */
155                 i->on_tchain = false;
156                 i->is_running = true;
157                 TAILQ_REMOVE(&tchain->waiters, i, next);
158                 TAILQ_INSERT_TAIL(&to_wake, i, next);
159         }
160         reset_tchain_times(tchain);
161         reset_tchain_interrupt(tchain);
162         spin_unlock_irqsave(&tchain->lock);
163
164         TAILQ_FOREACH_SAFE(i, &to_wake, next, temp) {
165                 /* Don't touch the waiter after waking it, since it could be in use on
166                  * another core (and the waiter can be clobbered as the kthread unwinds
167                  * its stack).  Or it could be kfreed.  Technically, the waiter hasn't
168                  * finished until we cleared is_running and unlocked the cv lock. */
169                 TAILQ_REMOVE(&to_wake, i, next);
170                 wake_awaiter(i, hw_tf);
171         }
172 }
173
174 /* Helper, inserts the waiter into the tchain, returning TRUE if we still need
175  * to reset the tchain interrupt.  Caller holds the lock. */
176 static bool __insert_awaiter(struct timer_chain *tchain,
177                              struct alarm_waiter *waiter)
178 {
179         struct alarm_waiter *i, *temp;
180
181         waiter->on_tchain = TRUE;
182         /* Either the list is empty, or not. */
183         if (TAILQ_EMPTY(&tchain->waiters)) {
184                 tchain->earliest_time = waiter->wake_up_time;
185                 tchain->latest_time = waiter->wake_up_time;
186                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
187                 /* Need to turn on the timer interrupt later */
188                 return TRUE;
189         }
190         /* If not, either we're first, last, or in the middle.  Reset the interrupt
191          * and adjust the tchain's times accordingly. */
192         if (waiter->wake_up_time < tchain->earliest_time) {
193                 tchain->earliest_time = waiter->wake_up_time;
194                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
195                 /* Changed the first entry; we'll need to reset the interrupt later */
196                 return TRUE;
197         }
198         /* If there is a tie for last, the newer one will really go last.  We need
199          * to handle equality here since the loop later won't catch it. */
200         if (waiter->wake_up_time >= tchain->latest_time) {
201                 tchain->latest_time = waiter->wake_up_time;
202                 /* Proactively put it at the end if we know we're last */
203                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
204                 return FALSE;
205         }
206         /* Insert before the first one you are earlier than.  This won't scale well
207          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
208          * will help a bit. */
209         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
210                 if (waiter->wake_up_time < i->wake_up_time) {
211                         TAILQ_INSERT_BEFORE(i, waiter, next);
212                         return FALSE;
213                 }
214         }
215         panic("Could not find a spot for awaiter %p\n", waiter);
216 }
217
218 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
219  * later. */
220 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
221 {
222         assert(waiter->wake_up_time != ALARM_POISON_TIME);
223         assert(!waiter->on_tchain);
224
225         spin_lock_irqsave(&tchain->lock);
226         if (waiter->no_rearm) {
227                 /* no_rearm exists to prevent alarm handlers from perpetually rearming
228                  * when another thread is trying to unset the alarm.  We could return an
229                  * error / false, but I don't have a use for that yet. */
230                 spin_unlock_irqsave(&tchain->lock);
231                 return;
232         }
233         if (__insert_awaiter(tchain, waiter))
234                 reset_tchain_interrupt(tchain);
235         spin_unlock_irqsave(&tchain->lock);
236 }
237
238 /* Helper, rips the waiter from the tchain, knowing that it is on the list.
239  * Returns TRUE if the tchain interrupt needs to be reset.  Callers hold the
240  * lock. */
241 static bool __remove_awaiter(struct timer_chain *tchain,
242                              struct alarm_waiter *waiter)
243 {
244         struct alarm_waiter *temp;
245         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
246
247         /* Need to make sure earliest and latest are set, in case we're mucking with
248          * the first and/or last element of the chain. */
249         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
250                 temp = TAILQ_NEXT(waiter, next);
251                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
252                 reset_int = TRUE;               /* we'll need to reset the timer later */
253         }
254         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
255                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
256                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
257         }
258         TAILQ_REMOVE(&tchain->waiters, waiter, next);
259         waiter->on_tchain = FALSE;
260         return reset_int;
261 }
262
263 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
264  * disarmed before the alarm went off, FALSE if it already fired.  May block,
265  * since the handler may be running asynchronously. */
266 bool unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
267 {
268         int8_t irq_state = 0;
269
270         spin_lock_irqsave(&tchain->lock);
271         if (waiter->on_tchain) {
272                 if (__remove_awaiter(tchain, waiter))
273                         reset_tchain_interrupt(tchain);
274                 spin_unlock_irqsave(&tchain->lock);
275                 return true;
276         }
277
278         /* no_rearm is set and checked under the tchain lock.  It is cleared when
279          * unset completes, outside the lock.  That is safe since we know the alarm
280          * service is no longer aware of waiter (either the handler ran or we
281          * stopped it). */
282         waiter->no_rearm = true;
283         spin_unlock_irqsave(&tchain->lock);
284
285         cv_lock_irqsave(&waiter->done_cv, &irq_state);
286         while (waiter->is_running)
287                 cv_wait(&waiter->done_cv);
288         cv_unlock_irqsave(&waiter->done_cv, &irq_state);
289
290         waiter->no_rearm = false;
291         return false;
292 }
293
294 bool reset_alarm_abs(struct timer_chain *tchain, struct alarm_waiter *waiter,
295                      uint64_t abs_time)
296 {
297         bool ret;
298
299         ret = unset_alarm(tchain, waiter);
300         set_awaiter_abs(waiter, abs_time);
301         set_alarm(tchain, waiter);
302         return ret;
303 }
304
305 bool reset_alarm_rel(struct timer_chain *tchain, struct alarm_waiter *waiter,
306                      uint64_t usleep)
307 {
308         bool ret;
309
310         ret = unset_alarm(tchain, waiter);
311         set_awaiter_rel(waiter, usleep);
312         set_alarm(tchain, waiter);
313         return ret;
314 }
315
316 /* Sets the timer interrupt for the timer chain passed as parameter.
317  * The next interrupt will be scheduled at the nearest timer available in the
318  * chain.
319  * This function can be called either for the local CPU, or for a remote CPU.
320  * If called for the local CPU, it proceeds in setting up the local timer,
321  * otherwise it will trigger an IPI, and will let the remote CPU IRQ handler
322  * to setup the timer according to the active information on its timer chain.
323  *
324  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
325  * if time is 0.   Any function like this needs to do a few things:
326  *      - Make sure the interrupt is on and will go off when we want
327  *      - Make sure the interrupt source can find tchain
328  *      - Make sure the interrupt handler calls __trigger_tchain(tchain)
329  *      - Make sure you don't clobber an old tchain here (a bug)
330  * This implies the function knows how to find its timer source/void
331  *
332  * Called with the tchain lock held, and IRQs disabled.  However, we could be
333  * calling this cross-core, and we cannot disable those IRQs (hence the
334  * locking). */
335 void set_pcpu_alarm_interrupt(struct timer_chain *tchain)
336 {
337         uint64_t time, rel_usec, now;
338         int pcoreid = core_id();
339         struct per_cpu_info *rem_pcpui, *pcpui = &per_cpu_info[pcoreid];
340         struct timer_chain *pcpui_tchain = &pcpui->tchain;
341
342         if (pcpui_tchain != tchain) {
343                 /* cross-core call.  we can simply send an alarm IRQ.  the alarm handler
344                  * will reset its pcpu timer, based on its current lists.  they take an
345                  * extra IRQ, but it gets the job done. */
346                 rem_pcpui = (struct per_cpu_info*)((uintptr_t)tchain -
347                                     offsetof(struct per_cpu_info, tchain));
348                 /* TODO: using the LAPIC vector is a bit ghetto, since that's x86.  But
349                  * RISCV ignores the vector field, and we don't have a global IRQ vector
350                  * namespace or anything. */
351                 send_ipi(rem_pcpui - &per_cpu_info[0], IdtLAPIC_TIMER);
352                 return;
353         }
354         time = TAILQ_EMPTY(&tchain->waiters) ? 0 : tchain->earliest_time;
355         if (time) {
356                 /* Arm the alarm.  For times in the past, we just need to make sure it
357                  * goes off. */
358                 now = read_tsc();
359                 if (time <= now)
360                         rel_usec = 1;
361                 else
362                         rel_usec = tsc2usec(time - now);
363                 rel_usec = MAX(rel_usec, 1);
364                 printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
365                        "tchain %p\n", time, now, rel_usec, pcpui_tchain);
366                 set_core_timer(rel_usec, FALSE);
367         } else  {
368                 /* Disarm */
369                 set_core_timer(0, FALSE);
370         }
371 }
372
373 /* Debug helpers */
374
375 void print_chain(struct timer_chain *tchain)
376 {
377         struct alarm_waiter *i;
378         spin_lock_irqsave(&tchain->lock);
379         printk("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
380                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
381                tchain->earliest_time,
382                tchain->latest_time);
383         TAILQ_FOREACH(i, &tchain->waiters, next) {
384                 uintptr_t f = (uintptr_t)i->func;
385
386                 printk("\tWaiter %p, time %llu, func %p (%s)\n", i,
387                        i->wake_up_time, f, get_fn_name(f));
388         }
389         spin_unlock_irqsave(&tchain->lock);
390 }
391
392 /* Prints all chains, rather verbosely */
393 void print_pcpu_chains(void)
394 {
395         struct timer_chain *pcpu_chain;
396         printk("PCPU Chains:  It is now %llu\n", read_tsc());
397
398         for (int i = 0; i < num_cores; i++) {
399                 pcpu_chain = &per_cpu_info[i].tchain;
400                 print_chain(pcpu_chain);
401         }
402 }