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