BNX2X: spatch signed typedefs
[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 #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) (uint64_t, 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 }
48
49 /* Initializes a new awaiter.  Pass 0 for the function if you want it to be a
50  * kthread-alarm, and sleep on it after you set the alarm later. */
51 static void __init_awaiter(struct alarm_waiter *waiter)
52 {
53         waiter->wake_up_time = ALARM_POISON_TIME;
54         waiter->on_tchain = FALSE;
55         waiter->holds_tchain_lock = FALSE;
56         if (!waiter->has_func)
57                 sem_init_irqsave(&waiter->sem, 0);
58 }
59
60 void init_awaiter(struct alarm_waiter *waiter,
61                   void (*func) (struct alarm_waiter *awaiter))
62 {
63         waiter->irq_ok = FALSE;
64         waiter->has_func = func ? TRUE : FALSE;
65         waiter->func = func;                    /* if !func, this is a harmless zeroing */
66         __init_awaiter(waiter);
67 }
68
69 void init_awaiter_irq(struct alarm_waiter *waiter,
70                       void (*func_irq) (struct alarm_waiter *awaiter,
71                                         struct hw_trapframe *hw_tf))
72 {
73         waiter->irq_ok = TRUE;
74         waiter->has_func = func_irq ? TRUE : FALSE;
75         waiter->func_irq = func_irq;    /* if !func, this is a harmless zeroing */
76         __init_awaiter(waiter);
77 }
78
79 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
80  * the alarm to go off. */
81 void set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
82 {
83         waiter->wake_up_time = abs_time;
84 }
85
86 /* Give this a relative time from now, in microseconds.  This might be easier to
87  * use than dealing with the TSC. */
88 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
89 {
90         uint64_t now, then;
91         now = read_tsc();
92         then = now + usec2tsc(usleep);
93         /* This will go off if we wrap-around the TSC.  It'll never happen for legit
94          * values, but this might catch some bugs with large usleeps. */
95         assert(now <= then);
96         set_awaiter_abs(waiter, then);
97 }
98
99 /* Increment the timer that was already set, so that it goes off usleep usec
100  * from the previous tick.  This is different than 'rel' in that it doesn't care
101  * about when 'now' is. */
102 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
103 {
104         assert(waiter->wake_up_time != ALARM_POISON_TIME);
105         waiter->wake_up_time += usec2tsc(usleep);
106 }
107
108 /* Helper, makes sure the interrupt is turned on at the right time.  Most of the
109  * heavy lifting is in the timer-source specific function pointer. */
110 static void reset_tchain_interrupt(struct timer_chain *tchain)
111 {
112         assert(!irq_is_enabled());
113         if (TAILQ_EMPTY(&tchain->waiters)) {
114                 /* Turn it off */
115                 printd("Turning alarm off\n");
116                 tchain->set_interrupt(0, tchain);
117         } else {
118                 /* Make sure it is on and set to the earliest time */
119                 assert(tchain->earliest_time != ALARM_POISON_TIME);
120                 /* TODO: check for times in the past or very close to now */
121                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
122                 tchain->set_interrupt(tchain->earliest_time, tchain);
123         }
124 }
125
126 static void __run_awaiter(uint32_t srcid, long a0, long a1, long a2)
127 {
128         struct alarm_waiter *waiter = (struct alarm_waiter*)a0;
129         waiter->func(waiter);
130 }
131
132 /* When an awaiter's time has come, this gets called.  If it was a kthread, it
133  * will wake up.  o/w, it will call the func ptr stored in the awaiter. */
134 static void wake_awaiter(struct alarm_waiter *waiter,
135                          struct hw_trapframe *hw_tf)
136 {
137         if (waiter->has_func) {
138                 if (waiter->irq_ok) {
139                         waiter->holds_tchain_lock = TRUE;
140                         waiter->func_irq(waiter, hw_tf);
141                         waiter->holds_tchain_lock = FALSE;
142                 } else {
143                         send_kernel_message(core_id(), __run_awaiter, (long)waiter,
144                                             0, 0, KMSG_ROUTINE);
145                 }
146         } else {
147                 sem_up(&waiter->sem); /* IRQs are disabled, can call sem_up directly */
148         }
149 }
150
151 /* This is called when an interrupt triggers a tchain, and needs to wake up
152  * everyone whose time is up.  Called from IRQ context. */
153 void __trigger_tchain(struct timer_chain *tchain, struct hw_trapframe *hw_tf)
154 {
155         struct alarm_waiter *i, *temp;
156         uint64_t now = read_tsc();
157         bool changed_list = FALSE;
158         /* why do we disable irqs here?  the lock is irqsave, but we (think we) know
159          * the timer IRQ for this tchain won't fire again.  disabling irqs is nice
160          * for the lock debugger.  i don't want to disable the debugger completely,
161          * and we can't make the debugger ignore irq context code either in the
162          * general case.  it might be nice for handlers to have IRQs disabled too.*/
163         spin_lock_irqsave(&tchain->lock);
164         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
165                 printd("Trying to wake up %p who is due at %llu and now is %llu\n",
166                        i, i->wake_up_time, now);
167                 /* TODO: Could also do something in cases where we're close to now */
168                 if (i->wake_up_time <= now) {
169                         changed_list = TRUE;
170                         i->on_tchain = FALSE;
171                         TAILQ_REMOVE(&tchain->waiters, i, next);
172                         cmb();  /* enforce waking after removal */
173                         /* Don't touch the waiter after waking it, since it could be in use
174                          * on another core (and the waiter can be clobbered as the kthread
175                          * unwinds its stack).  Or it could be kfreed */
176                         wake_awaiter(i, hw_tf);
177                 } else {
178                         break;
179                 }
180         }
181         if (changed_list) {
182                 reset_tchain_times(tchain);
183         }
184         /* Need to reset the interrupt no matter what */
185         reset_tchain_interrupt(tchain);
186         spin_unlock_irqsave(&tchain->lock);
187 }
188
189 /* Helper, inserts the waiter into the tchain, returning TRUE if we still need
190  * to reset the tchain interrupt.  Caller holds the lock. */
191 static bool __insert_awaiter(struct timer_chain *tchain,
192                              struct alarm_waiter *waiter)
193 {
194         struct alarm_waiter *i, *temp;
195         /* This will fail if you don't set a time */
196         assert(waiter->wake_up_time != ALARM_POISON_TIME);
197         assert(!waiter->on_tchain);
198         waiter->on_tchain = TRUE;
199         /* Either the list is empty, or not. */
200         if (TAILQ_EMPTY(&tchain->waiters)) {
201                 tchain->earliest_time = waiter->wake_up_time;
202                 tchain->latest_time = waiter->wake_up_time;
203                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
204                 /* Need to turn on the timer interrupt later */
205                 return TRUE;
206         }
207         /* If not, either we're first, last, or in the middle.  Reset the interrupt
208          * and adjust the tchain's times accordingly. */
209         if (waiter->wake_up_time < tchain->earliest_time) {
210                 tchain->earliest_time = waiter->wake_up_time;
211                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
212                 /* Changed the first entry; we'll need to reset the interrupt later */
213                 return TRUE;
214         }
215         /* If there is a tie for last, the newer one will really go last.  We need
216          * to handle equality here since the loop later won't catch it. */
217         if (waiter->wake_up_time >= tchain->latest_time) {
218                 tchain->latest_time = waiter->wake_up_time;
219                 /* Proactively put it at the end if we know we're last */
220                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
221                 return FALSE;
222         }
223         /* Insert before the first one you are earlier than.  This won't scale well
224          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
225          * will help a bit. */
226         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
227                 if (waiter->wake_up_time < i->wake_up_time) {
228                         TAILQ_INSERT_BEFORE(i, waiter, next);
229                         return FALSE;
230                 }
231         }
232         panic("Could not find a spot for awaiter %p\n", waiter);
233 }
234
235 static void __set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
236 {
237         if (__insert_awaiter(tchain, waiter))
238                 reset_tchain_interrupt(tchain);
239 }
240
241 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
242  * later. */
243 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
244 {
245         if (waiter->holds_tchain_lock) {
246                 __set_alarm(tchain, waiter);
247         } else {
248                 spin_lock_irqsave(&tchain->lock);
249                 __set_alarm(tchain, waiter);
250                 spin_unlock_irqsave(&tchain->lock);
251         }
252 }
253
254 /* Helper, rips the waiter from the tchain, knowing that it is on the list.
255  * Returns TRUE if the tchain interrupt needs to be reset.  Callers hold the
256  * lock. */
257 static bool __remove_awaiter(struct timer_chain *tchain,
258                              struct alarm_waiter *waiter)
259 {
260         struct alarm_waiter *temp;
261         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
262         /* Need to make sure earliest and latest are set, in case we're mucking with
263          * the first and/or last element of the chain. */
264         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
265                 temp = TAILQ_NEXT(waiter, next);
266                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
267                 reset_int = TRUE;               /* we'll need to reset the timer later */
268         }
269         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
270                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
271                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
272         }
273         TAILQ_REMOVE(&tchain->waiters, waiter, next);
274         waiter->on_tchain = FALSE;
275         return reset_int;
276 }
277
278 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
279  * disarmed before the alarm went off, FALSE if it already fired. */
280 bool unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
281 {
282         assert(!waiter->holds_tchain_lock);     /* Don't call from within a handler */
283         spin_lock_irqsave(&tchain->lock);
284         bool ret = waiter->on_tchain;
285         if (ret && __remove_awaiter(tchain, waiter))
286                 reset_tchain_interrupt(tchain);
287
288         /* if alarm had already gone off then its not on this tchain's list, though
289          * the concurrent change to on_tchain (specifically, the setting of it to
290          * FALSE), happens under the tchain's lock. */
291         spin_unlock_irqsave(&tchain->lock);
292         return ret;
293 }
294
295 /* waiter may be on the tchain, or it might have fired already and be off the
296  * tchain.  Either way, this will put the waiter on the list, set to go off at
297  * abs_time.  If you know the alarm has fired, don't call this.  Just set the
298  * awaiter, and then set_alarm() */
299 static bool __reset_alarm_abs(struct timer_chain *tchain,
300                               struct alarm_waiter *waiter, uint64_t abs_time)
301 {
302         /* The tchain's lock is held */
303         bool ret = waiter->on_tchain;
304         /* We only need to remove/unset when the alarm has not fired yet (is still
305          * on the tchain).  If it has fired, it's like a fresh insert. We must also
306          * check if we need to reset the interrupt. */
307         bool reset_int = ret && __remove_awaiter(tchain, waiter);
308         set_awaiter_abs(waiter, abs_time);
309         /* regardless, we need to be reinserted */
310         if (__insert_awaiter(tchain, waiter) || reset_int)
311                 reset_tchain_interrupt(tchain);
312         return ret;
313 }
314
315 static bool __reset_alarm_rel(struct timer_chain *tchain,
316                               struct alarm_waiter *waiter, uint64_t usleep)
317 {
318         uint64_t now, then;
319         now = read_tsc();
320         then = now + usec2tsc(usleep);
321         assert(now <= then);
322         return __reset_alarm_abs(tchain, waiter, then);
323 }
324
325 bool reset_alarm_abs(struct timer_chain *tchain, struct alarm_waiter *waiter,
326                      uint64_t abs_time)
327 {
328         bool ret;
329         if (waiter->holds_tchain_lock) {
330                 ret = __reset_alarm_abs(tchain, waiter, abs_time);
331         } else {
332                 spin_lock_irqsave(&tchain->lock);
333                 ret = __reset_alarm_abs(tchain, waiter, abs_time);
334                 spin_unlock_irqsave(&tchain->lock);
335         }
336         return ret;
337 }
338
339 bool reset_alarm_rel(struct timer_chain *tchain, struct alarm_waiter *waiter,
340                      uint64_t usleep)
341 {
342         bool ret;
343         if (waiter->holds_tchain_lock) {
344                 ret =__reset_alarm_rel(tchain, waiter, usleep);
345         } else {
346                 spin_lock_irqsave(&tchain->lock);
347                 ret =__reset_alarm_rel(tchain, waiter, usleep);
348                 spin_unlock_irqsave(&tchain->lock);
349         }
350         return ret;
351 }
352
353 /* Attempts to sleep on the alarm.  Could fail if you aren't allowed to kthread
354  * (process limit, etc).  Don't call it on a waiter that is an event-handler. */
355 int sleep_on_awaiter(struct alarm_waiter *waiter)
356 {
357         int8_t irq_state = 0;
358         if (waiter->has_func)
359                 panic("Tried blocking on a waiter %p with a func %p!", waiter,
360                       waiter->func);
361         /* Put the kthread to sleep.  TODO: This can fail (or at least it will be
362          * able to in the future) and we'll need to handle that. */
363         sem_down_irqsave(&waiter->sem, &irq_state);
364         return 0;
365 }
366
367 /* Sets the Alarm interrupt, per-core style.  Also is an example of what any
368  * similar function needs to do (this is the func ptr in the tchain). 
369  * Note the tchain is our per-core one, and we don't need tchain passed to us to
370  * figure that out.  It's kept around in case other tchain-usage wants it -
371  * might not be necessary in the future.
372  *
373  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
374  * if time is 0.   Any function like this needs to do a few things:
375  *      - Make sure the interrupt is on and will go off when we want
376  *      - Make sure the interrupt source can find tchain
377  *      - Make sure the interrupt handler calls __trigger_tchain(tchain)
378  *      - Make sure you don't clobber an old tchain here (a bug) 
379  * This implies the function knows how to find its timer source/void
380  *
381  * Called with the tchain lock held, and IRQs disabled.  However, we could be
382  * calling this cross-core, and we cannot disable those IRQs (hence the
383  * locking). */
384 void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
385 {
386         uint64_t rel_usec, now;
387         int pcoreid = core_id();
388         struct per_cpu_info *rem_pcpui, *pcpui = &per_cpu_info[pcoreid];
389         struct timer_chain *pcpui_tchain = &pcpui->tchain;
390
391         if (pcpui_tchain != tchain) {
392                 /* cross-core call.  we can simply send an alarm IRQ.  the alarm handler
393                  * will reset its pcpu timer, based on its current lists.  they take an
394                  * extra IRQ, but it gets the job done. */
395                 rem_pcpui = (struct per_cpu_info*)((uintptr_t)tchain -
396                                     offsetof(struct per_cpu_info, tchain));
397                 /* TODO: using the LAPIC vector is a bit ghetto, since that's x86.  But
398                  * RISCV ignores the vector field, and we don't have a global IRQ vector
399                  * namespace or anything. */
400                 send_ipi(rem_pcpui - &per_cpu_info[0], IdtLAPIC_TIMER);
401                 return;
402         }
403         if (time) {
404                 /* Arm the alarm.  For times in the past, we just need to make sure it
405                  * goes off. */
406                 now = read_tsc();
407                 if (time <= now)
408                         rel_usec = 1;
409                 else
410                         rel_usec = tsc2usec(time - now);
411                 rel_usec = MAX(rel_usec, 1);
412                 printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
413                        "tchain %p\n", time, now, rel_usec, pcpui_tchain);
414                 set_core_timer(rel_usec, FALSE);
415         } else  {
416                 /* Disarm */
417                 set_core_timer(0, FALSE);
418         }
419 }
420
421 /* Debug helpers */
422
423 void print_chain(struct timer_chain *tchain)
424 {
425         struct alarm_waiter *i;
426         spin_lock_irqsave(&tchain->lock);
427         printk("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
428                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
429                tchain->earliest_time,
430                tchain->latest_time);
431         TAILQ_FOREACH(i, &tchain->waiters, next) {
432                 if (i->has_func) {
433                         uintptr_t f;
434                         if (i->irq_ok)
435                                 f = (uintptr_t)i->func_irq;
436                         else
437                                 f = (uintptr_t)i->func;
438                         char *f_name = get_fn_name(f);
439                         printk("\tWaiter %p, time %llu, func %p (%s)\n", i,
440                                i->wake_up_time, f, f_name);
441                         kfree(f_name);
442                         continue;
443                 }
444                 struct kthread *kthread = TAILQ_FIRST(&i->sem.waiters);
445                 printk("\tWaiter %p, time: %llu, kthread: %p (%p) %s\n", i,
446                        i->wake_up_time, kthread, (kthread ? kthread->proc : 0),
447                        (kthread ? kthread->name : 0));
448
449         }
450         spin_unlock_irqsave(&tchain->lock);
451 }
452
453 /* Prints all chains, rather verbosely */
454 void print_pcpu_chains(void)
455 {
456         struct timer_chain *pcpu_chain;
457         printk("PCPU Chains:  It is now %llu\n", read_tsc());
458
459         for (int i = 0; i < num_cpus; i++) {
460                 pcpu_chain = &per_cpu_info[i].tchain;
461                 print_chain(pcpu_chain);
462         }
463 }