Alarm infrastructure
[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, any new waiters will be earlier and later than the
25  * current (which is none). */
26 static void reset_tchain_times(struct timer_chain *tchain)
27 {
28         if (TAILQ_EMPTY(&tchain->waiters)) {
29                 tchain->earliest_time = (uint64_t)-1;
30                 tchain->latest_time = 0;
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 = (uint64_t)-1;
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 = read_tsc();
70         set_awaiter_abs(waiter, now + usleep * (system_timing.tsc_freq / 1000000));
71 }
72
73 /* Helper, makes sure the interrupt is turned on at the right time.  Most of the
74  * heavy lifting is in the timer-source specific function pointer. */
75 static void reset_tchain_interrupt(struct timer_chain *tchain)
76 {
77         assert(!irq_is_enabled());
78         if (TAILQ_EMPTY(&tchain->waiters)) {
79                 /* Turn it off */
80                 tchain->set_interrupt(0, tchain);
81         } else {
82                 /* Make sure it is on and set to the earliest time */
83                 /* TODO: check for times in the past or very close to now */
84                 tchain->set_interrupt(tchain->earliest_time, tchain);
85         }
86 }
87
88 /* When an awaiter's time has come, this gets called.  If it was a kthread, it
89  * will wake up.  o/w, it will call the func ptr stored in the awaiter. */
90 static void wake_awaiter(struct alarm_waiter *waiter)
91 {
92         if (waiter->func) {
93                 waiter->func(waiter);
94         } else {
95                 /* Might encaps this */
96                 struct kthread *sleeper;
97                 sleeper = __up_sem(&waiter->sem);
98                 if (sleeper)
99                         kthread_runnable(sleeper);
100                 assert(TAILQ_EMPTY(&waiter->sem.waiters));
101         }
102 }
103
104 /* This is called when an interrupt triggers a tchain, and needs to wake up
105  * everyone whose time is up. */
106 void trigger_tchain(struct timer_chain *tchain)
107 {
108         struct alarm_waiter *i, *temp;
109         uint64_t now = read_tsc();
110         bool changed_list = FALSE;
111         assert(!irq_is_enabled());
112         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
113                 printd("Trying to wake up %08p who is due at %llu and it is now %llu\n",
114                        i, i->wake_up_time, now);
115                 /* TODO: Could also do something in cases where we're close to now */
116                 if (i->wake_up_time <= now) {
117                         changed_list = TRUE;
118                         TAILQ_REMOVE(&tchain->waiters, i, next);
119                         wake_awaiter(i);
120                 } else {
121                         break;
122                 }
123         }
124         if (changed_list) {
125                 reset_tchain_times(tchain);
126         }
127         /* Need to reset the interrupt no matter what */
128         reset_tchain_interrupt(tchain);
129 }
130
131 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
132  * later.  Hold the lock, if applicable.  If this is a per-core tchain, the
133  * interrupt-disabling ought to suffice. */
134 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
135 {
136         struct alarm_waiter *i, *temp;
137         bool reset_int = FALSE;
138         int8_t irq_state = 0;
139         bool inserted = FALSE;
140
141         disable_irqsave(&irq_state);
142         /* Set the tchains upper and lower bounds, possibly needing a change to the
143          * interrupt time. */
144         if (waiter->wake_up_time < tchain->earliest_time) {
145                 tchain->earliest_time = waiter->wake_up_time;
146                 /* later on, set the core time to go off at the new, earliest time */
147                 reset_int = TRUE;
148         }
149         if (waiter->wake_up_time > tchain->latest_time) {
150                 tchain->latest_time = waiter->wake_up_time;
151                 /* Proactively put it at the end if we know we're last */
152                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
153                 inserted = TRUE;
154         }
155         /* Insert before the first one you are earlier than.  This won't scale well
156          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
157          * will help a bit. */
158         if (!inserted) {
159                 TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
160                         if (waiter->wake_up_time < i->wake_up_time) {
161                                 TAILQ_INSERT_BEFORE(i, waiter, next);
162                                 inserted = TRUE;
163                                 break;
164                         }
165                 }
166         }
167         /* Still not in?  The list ought to be empty. */
168         if (!inserted) {
169                 assert(TAILQ_EMPTY(&tchain->waiters));
170                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
171         }
172         if (reset_int)
173                 reset_tchain_interrupt(tchain);
174         enable_irqsave(&irq_state);
175 }
176
177 /* Removes waiter from the tchain before it goes off.  */
178 void unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
179 {
180         struct alarm_waiter *temp;
181         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
182         int8_t irq_state = 0;
183
184         disable_irqsave(&irq_state);
185         /* Need to make sure earliest and latest are set, in case we're mucking with
186          * the first and/or last element of the chain. */
187         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
188                 temp = TAILQ_NEXT(waiter, next);
189                 tchain->earliest_time = (temp) ? temp->wake_up_time : (uint64_t)-1;
190                 reset_int = TRUE;               /* we'll need to reset the timer later */
191         }
192         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
193                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
194                 tchain->latest_time = (temp) ? temp->wake_up_time : 0;
195         }
196         TAILQ_REMOVE(&tchain->waiters, waiter, next);
197         if (reset_int)
198                 reset_tchain_interrupt(tchain);
199         enable_irqsave(&irq_state);
200 }
201
202 /* Attempts to sleep on the alarm.  Could fail if you aren't allowed to kthread
203  * (process limit, etc).  Don't call it on a waiter that is an event-handler. */
204 int sleep_on_awaiter(struct alarm_waiter *waiter)
205 {
206         if (waiter->func)
207                 panic("Tried blocking on a waiter %08p with a func %08p!", waiter,
208                       waiter->func);
209         /* Put the kthread to sleep.  TODO: This can fail (or at least it will be
210          * able to in the future) and we'll need to handle that. */
211         sleep_on(&waiter->sem);
212         return 0;
213 }
214
215 /* Sets the Alarm interrupt, per-core style.  Also is an example of what any
216  * similar function needs to do (this is the func ptr in the tchain). 
217  * Note the tchain is our per-core one, and we don't need tchain passed to us to
218  * figure that out.  It's kept around in case other tchain-usage wants it -
219  * might not be necessary in the future.
220  *
221  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
222  * if time is 0.   Any function like this needs to do a few things:
223  *      - Make sure the interrupt is on and will go off when we want
224  *      - Make sure the interrupt source can find tchain
225  *      - Make sure the interrupt handler calls trigger_tchain(tchain)
226  *      - Make sure you don't clobber an old tchain here (a bug) 
227  * This implies the function knows how to find its timer source/void */
228 void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
229 {
230         uint64_t rel_usec, now;
231         struct timer_chain *pcpui_tchain = &per_cpu_info[core_id()].tchain;
232         if (time) {
233                 /* Arm the alarm.  For times in the past, we just need to make sure it
234                  * goes off. */
235                 now = read_tsc();
236                 if (time <= now)
237                         rel_usec = 1;
238                 else
239                         rel_usec = ((time - now) / (system_timing.tsc_freq / 1000000));
240                 printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
241                        "tchain %08p\n", time, now, rel_usec, pcpui_tchain);
242                 /* Note that sparc doesn't honor the one-shot setting, so you might get
243                  * spurious interrupts. */
244                 set_core_timer(rel_usec);       /* TODO: Want this to be one-shot */
245                 /* Make sure the caller is setting the right tchain */
246                 assert(pcpui_tchain == tchain);
247         } else  {
248                 /* Disarm */
249                 set_core_timer(0);
250         }
251 }
252
253 /* Debug helpers */
254 void print_chain(struct timer_chain *tchain)
255 {
256         struct alarm_waiter *i;
257         printk("Chain %08p is%s empty, early: %llu latest: %llu\n", tchain,
258                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
259                tchain->earliest_time,
260                tchain->latest_time);
261         TAILQ_FOREACH(i, &tchain->waiters, next) {
262                 printk("\tWaiter %08p, time: %llu\n", i, i->wake_up_time);
263         }
264 }