cf1fd7090c5d6e30eac4e996841a27da74df0713
[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 various ways to sleep for a while or defer work on a
6  * specific timer.  These can be per-core, global or whatever.  Like with most
7  * systems, you won't wake up til after the time you specify. (for now, this
8  * 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
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) (uint64_t, 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 /* Initializes a new awaiter.  Pass 0 for the function if you want it to be a
49  * kthread-alarm, and sleep on it after you set the alarm later. */
50 void init_awaiter(struct alarm_waiter *waiter,
51                   void (*func) (struct alarm_waiter *awaiter))
52 {
53         waiter->wake_up_time = ALARM_POISON_TIME;
54         waiter->func = func;
55         if (!func)
56                 sem_init_irqsave(&waiter->sem, 0);
57         waiter->has_fired = FALSE;      /* so we can check this before arming */
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(0, 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->earliest_time, tchain);
104         }
105 }
106
107 /* When an awaiter's time has come, this gets called.  If it was a kthread, it
108  * will wake up.  o/w, it will call the func ptr stored in the awaiter. */
109 static void wake_awaiter(struct alarm_waiter *waiter)
110 {
111         waiter->has_fired = TRUE;
112         cmb();  /* enforce the has_fired write before the handlers */
113         if (waiter->func)
114                 waiter->func(waiter);
115         else
116                 sem_up(&waiter->sem); /* IRQs are disabled, can call sem_up directly */
117 }
118
119 /* This is called when an interrupt triggers a tchain, and needs to wake up
120  * everyone whose time is up.  Called from IRQ context. */
121 void trigger_tchain(struct timer_chain *tchain)
122 {
123         struct alarm_waiter *i, *temp;
124         uint64_t now = read_tsc();
125         bool changed_list = FALSE;
126         assert(!irq_is_enabled());
127         spin_lock(&tchain->lock);
128         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
129                 printd("Trying to wake up %p who is due at %llu and now is %llu\n",
130                        i, i->wake_up_time, now);
131                 /* TODO: Could also do something in cases where we're close to now */
132                 if (i->wake_up_time <= now) {
133                         changed_list = TRUE;
134                         TAILQ_REMOVE(&tchain->waiters, i, next);
135                         /* Don't touch the waiter after waking it, since it could be in use
136                          * on another core (and the waiter can be clobbered as the kthread
137                          * unwinds its stack).  Or it could be kfreed */
138                         wake_awaiter(i);
139                 } else {
140                         break;
141                 }
142         }
143         if (changed_list) {
144                 reset_tchain_times(tchain);
145         }
146         /* Need to reset the interrupt no matter what */
147         reset_tchain_interrupt(tchain);
148         spin_unlock(&tchain->lock);
149 }
150
151 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
152  * later.  This version assumes you have the lock held.  That only makes sense
153  * from alarm handlers, which are called with this lock held from IRQ context */
154 void __set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
155 {
156         struct alarm_waiter *i, *temp;
157         /* This will fail if you don't set a time */
158         assert(waiter->wake_up_time != ALARM_POISON_TIME);
159         /* has_fired tells us if it is on the tchain or not */
160         waiter->has_fired = FALSE;
161         /* Either the list is empty, or not. */
162         if (TAILQ_EMPTY(&tchain->waiters)) {
163                 tchain->earliest_time = waiter->wake_up_time;
164                 tchain->latest_time = waiter->wake_up_time;
165                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
166                 /* Need to turn on the timer interrupt later */
167                 goto reset_out;
168         }
169         /* If not, either we're first, last, or in the middle.  Reset the interrupt
170          * and adjust the tchain's times accordingly. */
171         if (waiter->wake_up_time < tchain->earliest_time) {
172                 tchain->earliest_time = waiter->wake_up_time;
173                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
174                 /* Changed the first entry; we'll need to reset the interrupt later */
175                 goto reset_out;
176         }
177         /* If there is a tie for last, the newer one will really go last.  We need
178          * to handle equality here since the loop later won't catch it. */
179         if (waiter->wake_up_time >= tchain->latest_time) {
180                 tchain->latest_time = waiter->wake_up_time;
181                 /* Proactively put it at the end if we know we're last */
182                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
183                 goto no_reset_out;
184         }
185         /* Insert before the first one you are earlier than.  This won't scale well
186          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
187          * will help a bit. */
188         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
189                 if (waiter->wake_up_time < i->wake_up_time) {
190                         TAILQ_INSERT_BEFORE(i, waiter, next);
191                         goto no_reset_out;
192                 }
193         }
194         panic("Could not find a spot for awaiter %p\n", waiter);
195 reset_out:
196         reset_tchain_interrupt(tchain);
197 no_reset_out:
198         ;
199         /* TODO: could put some debug stuff here */
200 }
201
202 /* Sets the alarm.  Don't call this from an alarm handler, since you already
203  * have the lock held.  Call __set_alarm() instead. */
204 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
205 {
206         spin_lock_irqsave(&tchain->lock);
207         __set_alarm(tchain, waiter);
208         spin_unlock_irqsave(&tchain->lock);
209 }
210
211 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
212  * disarmed before the alarm went off, FALSE if it already fired. */
213 bool unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
214 {
215         struct alarm_waiter *temp;
216         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
217
218         spin_lock_irqsave(&tchain->lock);
219         if (waiter->has_fired) {
220                 /* the alarm has already gone off.  its not even on this tchain's list,
221                  * though the concurrent change to has_fired (specifically, the setting
222                  * of it to TRUE), happens under the tchain's lock.  As a side note, the
223                  * code that sets it to FALSE is called when the waiter is on no chain,
224                  * so there is no race on that. */
225                 spin_unlock_irqsave(&tchain->lock);
226                 return FALSE;
227         }
228         /* Need to make sure earliest and latest are set, in case we're mucking with
229          * the first and/or last element of the chain. */
230         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
231                 temp = TAILQ_NEXT(waiter, next);
232                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
233                 reset_int = TRUE;               /* we'll need to reset the timer later */
234         }
235         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
236                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
237                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
238         }
239         TAILQ_REMOVE(&tchain->waiters, waiter, next);
240         if (reset_int)
241                 reset_tchain_interrupt(tchain);
242         spin_unlock_irqsave(&tchain->lock);
243         return TRUE;
244 }
245
246 /* Attempts to sleep on the alarm.  Could fail if you aren't allowed to kthread
247  * (process limit, etc).  Don't call it on a waiter that is an event-handler. */
248 int sleep_on_awaiter(struct alarm_waiter *waiter)
249 {
250         int8_t irq_state = 0;
251         if (waiter->func)
252                 panic("Tried blocking on a waiter %p with a func %p!", waiter,
253                       waiter->func);
254         /* Put the kthread to sleep.  TODO: This can fail (or at least it will be
255          * able to in the future) and we'll need to handle that. */
256         sem_down_irqsave(&waiter->sem, &irq_state);
257         return 0;
258 }
259
260 /* Sets the Alarm interrupt, per-core style.  Also is an example of what any
261  * similar function needs to do (this is the func ptr in the tchain). 
262  * Note the tchain is our per-core one, and we don't need tchain passed to us to
263  * figure that out.  It's kept around in case other tchain-usage wants it -
264  * might not be necessary in the future.
265  *
266  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
267  * if time is 0.   Any function like this needs to do a few things:
268  *      - Make sure the interrupt is on and will go off when we want
269  *      - Make sure the interrupt source can find tchain
270  *      - Make sure the interrupt handler calls trigger_tchain(tchain)
271  *      - Make sure you don't clobber an old tchain here (a bug) 
272  * This implies the function knows how to find its timer source/void
273  *
274  * Called with the tchain lock held, and IRQs disabled.  However, we could be
275  * calling this cross-core, and we cannot disable those IRQs (hence the
276  * locking). */
277 void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
278 {
279         uint64_t rel_usec, now;
280         int pcoreid = core_id();
281         struct timer_chain *pcpui_tchain = &per_cpu_info[pcoreid].tchain;
282
283         if (pcpui_tchain != tchain) {
284                 /* cross-core call.  we can simply send an alarm IRQ.  the alarm handler
285                  * will reset its pcpu timer, based on its current lists.  they take an
286                  * extra IRQ, but it gets the job done. */
287                 /* TODO: using the LAPIC vector is a bit ghetto, since that's x86.  But
288                  * RISCV ignores the vector field, and we don't have a global IRQ vector
289                  * namespace or anything. */
290                 send_ipi(pcoreid + (pcpui_tchain - tchain), LAPIC_TIMER_DEFAULT_VECTOR);
291                 return;
292         }
293         if (time) {
294                 /* Arm the alarm.  For times in the past, we just need to make sure it
295                  * goes off. */
296                 now = read_tsc();
297                 if (time <= now)
298                         rel_usec = 1;
299                 else
300                         rel_usec = tsc2usec(time - now);
301                 rel_usec = MAX(rel_usec, 1);
302                 printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
303                        "tchain %p\n", time, now, rel_usec, pcpui_tchain);
304                 set_core_timer(rel_usec, FALSE);
305         } else  {
306                 /* Disarm */
307                 set_core_timer(0, FALSE);
308         }
309 }
310
311 /* Debug helpers */
312
313 void print_chain(struct timer_chain *tchain)
314 {
315         struct alarm_waiter *i;
316         spin_lock_irqsave(&tchain->lock);
317         printk("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
318                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
319                tchain->earliest_time,
320                tchain->latest_time);
321         TAILQ_FOREACH(i, &tchain->waiters, next) {
322                 struct kthread *kthread = TAILQ_FIRST(&i->sem.waiters);
323                 printk("\tWaiter %p, time: %llu, kthread: %p (%p) %s\n", i,
324                        i->wake_up_time, kthread, (kthread ? kthread->proc : 0),
325                        (kthread ? kthread->name : 0));
326
327         }
328         spin_unlock_irqsave(&tchain->lock);
329 }
330
331 /* Prints all chains, rather verbosely */
332 void print_pcpu_chains(void)
333 {
334         struct timer_chain *pcpu_chain;
335         printk("PCPU Chains:  It is now %llu\n", read_tsc());
336
337         for (int i = 0; i < num_cpus; i++) {
338                 pcpu_chain = &per_cpu_info[i].tchain;
339                 print_chain(pcpu_chain);
340         }
341 }