b4a00ed37ac6ed52686e1214d23f24b7e202c27e
[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         TAILQ_INIT(&tchain->waiters);
43         tchain->set_interrupt = set_interrupt;
44         reset_tchain_times(tchain);
45 }
46
47 /* Initializes a new awaiter.  Pass 0 for the function if you want it to be a
48  * kthread-alarm, and sleep on it after you set the alarm later. */
49 void init_awaiter(struct alarm_waiter *waiter,
50                   void (*func) (struct alarm_waiter *awaiter))
51 {
52         waiter->wake_up_time = ALARM_POISON_TIME;
53         waiter->func = func;
54         if (!func)
55                 init_sem(&waiter->sem, 0);
56 }
57
58 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
59  * the alarm to go off. */
60 void set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
61 {
62         waiter->wake_up_time = abs_time;
63 }
64
65 /* Give this a relative time from now, in microseconds.  This might be easier to
66  * use than dealing with the TSC. */
67 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
68 {
69         uint64_t now, then;
70         now = read_tsc();
71         then = now + usec2tsc(usleep);
72         /* This will go off if we wrap-around the TSC.  It'll never happen for legit
73          * values, but this might catch some bugs with large usleeps. */
74         assert(now < then);
75         set_awaiter_abs(waiter, then);
76 }
77
78 /* Increment the timer that was already set, so that it goes off usleep usec
79  * from the previous tick.  This is different than 'rel' in that it doesn't care
80  * about when 'now' is. */
81 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
82 {
83         assert(waiter->wake_up_time != ALARM_POISON_TIME);
84         waiter->wake_up_time += usec2tsc(usleep);
85 }
86
87 /* Helper, makes sure the interrupt is turned on at the right time.  Most of the
88  * heavy lifting is in the timer-source specific function pointer. */
89 static void reset_tchain_interrupt(struct timer_chain *tchain)
90 {
91         assert(!irq_is_enabled());
92         if (TAILQ_EMPTY(&tchain->waiters)) {
93                 /* Turn it off */
94                 printd("Turning alarm off\n");
95                 tchain->set_interrupt(0, tchain);
96         } else {
97                 /* Make sure it is on and set to the earliest time */
98                 assert(tchain->earliest_time != ALARM_POISON_TIME);
99                 /* TODO: check for times in the past or very close to now */
100                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
101                 tchain->set_interrupt(tchain->earliest_time, tchain);
102         }
103 }
104
105 /* When an awaiter's time has come, this gets called.  If it was a kthread, it
106  * will wake up.  o/w, it will call the func ptr stored in the awaiter. */
107 static void wake_awaiter(struct alarm_waiter *waiter)
108 {
109         if (waiter->func) {
110                 waiter->func(waiter);
111         } else {
112                 /* Might encaps this */
113                 struct kthread *sleeper;
114                 sleeper = __up_sem(&waiter->sem, TRUE);
115                 if (sleeper)
116                         kthread_runnable(sleeper);
117                 /* Don't touch the sleeper or waiter after making the kthread runnable,
118                  * since it could be in use on another core (and the waiter can be
119                  * clobbered as the kthread unwinds its stack). */
120         }
121 }
122
123 /* This is called when an interrupt triggers a tchain, and needs to wake up
124  * everyone whose time is up. */
125 void trigger_tchain(struct timer_chain *tchain)
126 {
127         struct alarm_waiter *i, *temp;
128         uint64_t now = read_tsc();
129         bool changed_list = FALSE;
130         assert(!irq_is_enabled());
131         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
132                 printd("Trying to wake up %08p who is due at %llu and now is %llu\n",
133                        i, i->wake_up_time, now);
134                 /* TODO: Could also do something in cases where we're close to now */
135                 if (i->wake_up_time <= now) {
136                         changed_list = TRUE;
137                         TAILQ_REMOVE(&tchain->waiters, i, next);
138                         /* Don't touch the waiter after waking it, since it could be in use
139                          * on another core (and the waiter can be clobbered as the kthread
140                          * unwinds its stack).  Or it could be kfreed */
141                         wake_awaiter(i);
142                 } else {
143                         break;
144                 }
145         }
146         if (changed_list) {
147                 reset_tchain_times(tchain);
148         }
149         /* Need to reset the interrupt no matter what */
150         reset_tchain_interrupt(tchain);
151 }
152
153 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
154  * later.  Hold the lock, if applicable.  If this is a per-core tchain, the
155  * interrupt-disabling ought to suffice. */
156 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
157 {
158         struct alarm_waiter *i, *temp;
159         int8_t irq_state = 0;
160
161         /* This will fail if you don't set a time */
162         assert(waiter->wake_up_time != ALARM_POISON_TIME);
163         disable_irqsave(&irq_state);
164         /* Either the list is empty, or not. */
165         if (TAILQ_EMPTY(&tchain->waiters)) {
166                 tchain->earliest_time = waiter->wake_up_time;
167                 tchain->latest_time = waiter->wake_up_time;
168                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
169                 /* Need to turn on the timer interrupt later */
170                 goto reset_out;
171         }
172         /* If not, either we're first, last, or in the middle.  Reset the interrupt
173          * and adjust the tchain's times accordingly. */
174         if (waiter->wake_up_time < tchain->earliest_time) {
175                 tchain->earliest_time = waiter->wake_up_time;
176                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
177                 /* Changed the first entry; we'll need to reset the interrupt later */
178                 goto reset_out;
179         }
180         /* If there is a tie for last, the newer one will really go last.  We need
181          * to handle equality here since the loop later won't catch it. */
182         if (waiter->wake_up_time >= tchain->latest_time) {
183                 tchain->latest_time = waiter->wake_up_time;
184                 /* Proactively put it at the end if we know we're last */
185                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
186                 goto no_reset_out;
187         }
188         /* Insert before the first one you are earlier than.  This won't scale well
189          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
190          * will help a bit. */
191         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
192                 if (waiter->wake_up_time < i->wake_up_time) {
193                         TAILQ_INSERT_BEFORE(i, waiter, next);
194                         goto no_reset_out;
195                 }
196         }
197         panic("Could not find a spot for awaiter %08p\n", waiter);
198 reset_out:
199         reset_tchain_interrupt(tchain);
200 no_reset_out:
201         enable_irqsave(&irq_state);
202         /* TODO: could put some debug stuff here */
203 }
204
205 /* Removes waiter from the tchain before it goes off. 
206  * TODO: handle waiters that already went off. */
207 void unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
208 {
209         struct alarm_waiter *temp;
210         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
211         int8_t irq_state = 0;
212
213         disable_irqsave(&irq_state);
214         warn("Code currently assumes the alarm waiter hasn't triggered yet!");
215         /* Need to make sure earliest and latest are set, in case we're mucking with
216          * the first and/or last element of the chain. */
217         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
218                 temp = TAILQ_NEXT(waiter, next);
219                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
220                 reset_int = TRUE;               /* we'll need to reset the timer later */
221         }
222         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
223                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
224                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
225         }
226         TAILQ_REMOVE(&tchain->waiters, waiter, next);
227         if (reset_int)
228                 reset_tchain_interrupt(tchain);
229         enable_irqsave(&irq_state);
230 }
231
232 /* Attempts to sleep on the alarm.  Could fail if you aren't allowed to kthread
233  * (process limit, etc).  Don't call it on a waiter that is an event-handler. */
234 int sleep_on_awaiter(struct alarm_waiter *waiter)
235 {
236         if (waiter->func)
237                 panic("Tried blocking on a waiter %08p with a func %08p!", waiter,
238                       waiter->func);
239         /* Put the kthread to sleep.  TODO: This can fail (or at least it will be
240          * able to in the future) and we'll need to handle that. */
241         sleep_on(&waiter->sem);
242         return 0;
243 }
244
245 /* Sets the Alarm interrupt, per-core style.  Also is an example of what any
246  * similar function needs to do (this is the func ptr in the tchain). 
247  * Note the tchain is our per-core one, and we don't need tchain passed to us to
248  * figure that out.  It's kept around in case other tchain-usage wants it -
249  * might not be necessary in the future.
250  *
251  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
252  * if time is 0.   Any function like this needs to do a few things:
253  *      - Make sure the interrupt is on and will go off when we want
254  *      - Make sure the interrupt source can find tchain
255  *      - Make sure the interrupt handler calls trigger_tchain(tchain)
256  *      - Make sure you don't clobber an old tchain here (a bug) 
257  * This implies the function knows how to find its timer source/void */
258 void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
259 {
260         uint64_t rel_usec, now;
261         struct timer_chain *pcpui_tchain = &per_cpu_info[core_id()].tchain;
262         if (time) {
263                 /* Arm the alarm.  For times in the past, we just need to make sure it
264                  * goes off. */
265                 now = read_tsc();
266                 if (time <= now)
267                         rel_usec = 1;
268                 else
269                         rel_usec = tsc2usec(time - now);
270                 rel_usec = MAX(rel_usec, 1);
271                 printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
272                        "tchain %08p\n", time, now, rel_usec, pcpui_tchain);
273                 /* Note that sparc doesn't honor the one-shot setting, so you might get
274                  * spurious interrupts. */
275                 set_core_timer(rel_usec, FALSE);
276                 /* Make sure the caller is setting the right tchain */
277                 assert(pcpui_tchain == tchain);
278         } else  {
279                 /* Disarm */
280                 set_core_timer(0, FALSE);
281         }
282 }
283
284 /* Debug helpers */
285
286 /* Disable irqs before calling this, or otherwise protect yourself. */
287 void print_chain(struct timer_chain *tchain)
288 {
289         struct alarm_waiter *i;
290         printk("Chain %08p is%s empty, early: %llu latest: %llu\n", tchain,
291                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
292                tchain->earliest_time,
293                tchain->latest_time);
294         TAILQ_FOREACH(i, &tchain->waiters, next) {
295                 struct kthread *kthread = TAILQ_FIRST(&i->sem.waiters);
296                 printk("\tWaiter %08p, time: %llu, kthread: %08p (%08p)\n", i,
297                        i->wake_up_time, kthread, (kthread ? kthread->proc : 0));
298
299         }
300 }
301
302 /* Prints all chains, rather verbosely */
303 void print_pcpu_chains(void)
304 {
305         struct timer_chain *pcpu_chain;
306         int8_t irq_state = 0;
307         printk("PCPU Chains:  It is now %llu\n", read_tsc());
308
309         disable_irqsave(&irq_state);
310         for (int i = 0; i < num_cpus; i++) {
311                 pcpu_chain = &per_cpu_info[i].tchain;
312                 print_chain(pcpu_chain);
313         }
314         enable_irqsave(&irq_state);
315 }