VMM: Lazily unload the VMCS
[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 ways to defer work on a specific timer.  These can be
6  * per-core, global or whatever.  Like with most systems, you won't wake up til
7  * after the time you specify. (for now, this might change).
8  *
9  * TODO:
10  *      - have a kernel sense of time, instead of just the TSC or whatever timer the
11  *      chain uses...
12  *      - coalesce or otherwise deal with alarms that are close to cut down on
13  *      interrupt overhead. */
14
15 #include <ros/common.h>
16 #include <sys/queue.h>
17 #include <kthread.h>
18 #include <alarm.h>
19 #include <stdio.h>
20 #include <smp.h>
21 #include <kmalloc.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)(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 static void __init_awaiter(struct alarm_waiter *waiter)
49 {
50         waiter->wake_up_time = ALARM_POISON_TIME;
51         waiter->on_tchain = FALSE;
52         waiter->holds_tchain_lock = FALSE;
53 }
54
55 void init_awaiter(struct alarm_waiter *waiter,
56                   void (*func) (struct alarm_waiter *awaiter))
57 {
58         waiter->irq_ok = FALSE;
59         assert(func);
60         waiter->func = func;
61         __init_awaiter(waiter);
62         cv_init(&waiter->rkm_cv);
63 }
64
65 void init_awaiter_irq(struct alarm_waiter *waiter,
66                       void (*func_irq) (struct alarm_waiter *awaiter,
67                                         struct hw_trapframe *hw_tf))
68 {
69         waiter->irq_ok = TRUE;
70         assert(func_irq);
71         waiter->func_irq = func_irq;
72         __init_awaiter(waiter);
73 }
74
75 /* Give this the absolute time.  For now, abs_time is the TSC time that you want
76  * the alarm to go off. */
77 void set_awaiter_abs(struct alarm_waiter *waiter, uint64_t abs_time)
78 {
79         waiter->wake_up_time = abs_time;
80 }
81
82 /* Give this a relative time from now, in microseconds.  This might be easier to
83  * use than dealing with the TSC. */
84 void set_awaiter_rel(struct alarm_waiter *waiter, uint64_t usleep)
85 {
86         uint64_t now, then;
87         now = read_tsc();
88         then = now + usec2tsc(usleep);
89         /* This will go off if we wrap-around the TSC.  It'll never happen for legit
90          * values, but this might catch some bugs with large usleeps. */
91         assert(now <= then);
92         set_awaiter_abs(waiter, then);
93 }
94
95 /* Increment the timer that was already set, so that it goes off usleep usec
96  * from the previous tick.  This is different than 'rel' in that it doesn't care
97  * about when 'now' is. */
98 void set_awaiter_inc(struct alarm_waiter *waiter, uint64_t usleep)
99 {
100         assert(waiter->wake_up_time != ALARM_POISON_TIME);
101         waiter->wake_up_time += usec2tsc(usleep);
102 }
103
104 /* Helper, makes sure the interrupt is turned on at the right time.  Most of the
105  * heavy lifting is in the timer-source specific function pointer. */
106 static void reset_tchain_interrupt(struct timer_chain *tchain)
107 {
108         assert(!irq_is_enabled());
109         if (TAILQ_EMPTY(&tchain->waiters)) {
110                 /* Turn it off */
111                 printd("Turning alarm off\n");
112                 tchain->set_interrupt(tchain);
113         } else {
114                 /* Make sure it is on and set to the earliest time */
115                 assert(tchain->earliest_time != ALARM_POISON_TIME);
116                 /* TODO: check for times in the past or very close to now */
117                 printd("Turning alarm on for %llu\n", tchain->earliest_time);
118                 tchain->set_interrupt(tchain);
119         }
120 }
121
122 static void __run_awaiter(uint32_t srcid, long a0, long a1, long a2)
123 {
124         struct alarm_waiter *waiter = (struct alarm_waiter*)a0;
125
126         waiter->func(waiter);
127         cv_lock(&waiter->rkm_cv);
128         /* This completes the alarm's function.  We don't need to sync with
129          * wake_waiter, we happen after.  We do need to sync with unset_alarm. */
130         waiter->rkm_pending = FALSE;
131         /* broadcast, instead of signal.  This allows us to have multiple unsetters
132          * concurrently.  (only one of which will succeed, so YMMV.) */
133         __cv_broadcast(&waiter->rkm_cv);
134         cv_unlock(&waiter->rkm_cv);
135 }
136
137 static void wake_awaiter(struct alarm_waiter *waiter,
138                          struct hw_trapframe *hw_tf)
139 {
140         if (waiter->irq_ok) {
141                 waiter->holds_tchain_lock = TRUE;
142                 waiter->func_irq(waiter, hw_tf);
143                 waiter->holds_tchain_lock = FALSE;
144         } else {
145                 /* The alarm is in limbo and is uncancellable from now (IRQ ctx, tchain
146                  * lock held) until it finishes. */
147                 waiter->rkm_pending = TRUE;
148                 send_kernel_message(core_id(), __run_awaiter, (long)waiter,
149                                     0, 0, KMSG_ROUTINE);
150         }
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         struct alarm_waiter *i, *temp;
158         uint64_t now = read_tsc();
159         bool changed_list = FALSE;
160         /* why do we disable irqs here?  the lock is irqsave, but we (think we) know
161          * the timer IRQ for this tchain won't fire again.  disabling irqs is nice
162          * for the lock debugger.  i don't want to disable the debugger completely,
163          * and we can't make the debugger ignore irq context code either in the
164          * general case.  it might be nice for handlers to have IRQs disabled too.*/
165         spin_lock_irqsave(&tchain->lock);
166         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
167                 printd("Trying to wake up %p who is due at %llu and now is %llu\n",
168                        i, i->wake_up_time, now);
169                 /* TODO: Could also do something in cases where we're close to now */
170                 if (i->wake_up_time <= now) {
171                         changed_list = TRUE;
172                         i->on_tchain = FALSE;
173                         TAILQ_REMOVE(&tchain->waiters, i, next);
174                         cmb();  /* enforce waking after removal */
175                         /* Don't touch the waiter after waking it, since it could be in use
176                          * on another core (and the waiter can be clobbered as the kthread
177                          * unwinds its stack).  Or it could be kfreed */
178                         wake_awaiter(i, hw_tf);
179                 } else {
180                         break;
181                 }
182         }
183         if (changed_list) {
184                 reset_tchain_times(tchain);
185         }
186         /* Need to reset the interrupt no matter what */
187         reset_tchain_interrupt(tchain);
188         spin_unlock_irqsave(&tchain->lock);
189 }
190
191 /* Helper, inserts the waiter into the tchain, returning TRUE if we still need
192  * to reset the tchain interrupt.  Caller holds the lock. */
193 static bool __insert_awaiter(struct timer_chain *tchain,
194                              struct alarm_waiter *waiter)
195 {
196         struct alarm_waiter *i, *temp;
197         /* This will fail if you don't set a time */
198         assert(waiter->wake_up_time != ALARM_POISON_TIME);
199         assert(!waiter->on_tchain);
200         waiter->on_tchain = TRUE;
201         /* Either the list is empty, or not. */
202         if (TAILQ_EMPTY(&tchain->waiters)) {
203                 tchain->earliest_time = waiter->wake_up_time;
204                 tchain->latest_time = waiter->wake_up_time;
205                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
206                 /* Need to turn on the timer interrupt later */
207                 return TRUE;
208         }
209         /* If not, either we're first, last, or in the middle.  Reset the interrupt
210          * and adjust the tchain's times accordingly. */
211         if (waiter->wake_up_time < tchain->earliest_time) {
212                 tchain->earliest_time = waiter->wake_up_time;
213                 TAILQ_INSERT_HEAD(&tchain->waiters, waiter, next);
214                 /* Changed the first entry; we'll need to reset the interrupt later */
215                 return TRUE;
216         }
217         /* If there is a tie for last, the newer one will really go last.  We need
218          * to handle equality here since the loop later won't catch it. */
219         if (waiter->wake_up_time >= tchain->latest_time) {
220                 tchain->latest_time = waiter->wake_up_time;
221                 /* Proactively put it at the end if we know we're last */
222                 TAILQ_INSERT_TAIL(&tchain->waiters, waiter, next);
223                 return FALSE;
224         }
225         /* Insert before the first one you are earlier than.  This won't scale well
226          * (TODO) if we have a lot of inserts.  The proactive insert_tail up above
227          * will help a bit. */
228         TAILQ_FOREACH_SAFE(i, &tchain->waiters, next, temp) {
229                 if (waiter->wake_up_time < i->wake_up_time) {
230                         TAILQ_INSERT_BEFORE(i, waiter, next);
231                         return FALSE;
232                 }
233         }
234         panic("Could not find a spot for awaiter %p\n", waiter);
235 }
236
237 static void __set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
238 {
239         assert(!waiter->on_tchain);
240         if (__insert_awaiter(tchain, waiter))
241                 reset_tchain_interrupt(tchain);
242 }
243
244 static void __set_alarm_irq(struct timer_chain *tchain,
245                             struct alarm_waiter *waiter)
246 {
247         /* holds_tchain_lock is set when we're called from an alarm handler */
248         if (waiter->holds_tchain_lock) {
249                 __set_alarm(tchain, waiter);
250         } else {
251                 spin_lock_irqsave(&tchain->lock);
252                 __set_alarm(tchain, waiter);
253                 spin_unlock_irqsave(&tchain->lock);
254         }
255 }
256
257 static void __set_alarm_rkm(struct timer_chain *tchain,
258                             struct alarm_waiter *waiter)
259 {
260         spin_lock_irqsave(&tchain->lock);
261         __set_alarm(tchain, waiter);
262         spin_unlock_irqsave(&tchain->lock);
263 }
264
265 /* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
266  * later. */
267 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
268 {
269         if (waiter->irq_ok)
270                 return __set_alarm_irq(tchain, waiter);
271         else
272                 return __set_alarm_rkm(tchain, waiter);
273 }
274
275 /* Helper, rips the waiter from the tchain, knowing that it is on the list.
276  * Returns TRUE if the tchain interrupt needs to be reset.  Callers hold the
277  * lock. */
278 static bool __remove_awaiter(struct timer_chain *tchain,
279                              struct alarm_waiter *waiter)
280 {
281         struct alarm_waiter *temp;
282         bool reset_int = FALSE;         /* whether or not to reset the interrupt */
283         /* Need to make sure earliest and latest are set, in case we're mucking with
284          * the first and/or last element of the chain. */
285         if (TAILQ_FIRST(&tchain->waiters) == waiter) {
286                 temp = TAILQ_NEXT(waiter, next);
287                 tchain->earliest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
288                 reset_int = TRUE;               /* we'll need to reset the timer later */
289         }
290         if (TAILQ_LAST(&tchain->waiters, awaiters_tailq) == waiter) {
291                 temp = TAILQ_PREV(waiter, awaiters_tailq, next);
292                 tchain->latest_time = (temp) ? temp->wake_up_time : ALARM_POISON_TIME;
293         }
294         TAILQ_REMOVE(&tchain->waiters, waiter, next);
295         waiter->on_tchain = FALSE;
296         return reset_int;
297 }
298
299 static bool __unset_alarm_irq(struct timer_chain *tchain,
300                               struct alarm_waiter *waiter)
301 {
302         bool was_on_chain = FALSE;
303
304         /* We need to lock the tchain before looking at on_tchain.  At one point, I
305          * thought we could do the check-signal-check again style (lockless peek).
306          * The reason we can't is that on_tchain isn't just set FALSE.  A handler
307          * could reset the alarm and set it TRUE while we're looking.  We could
308          * briefly peek when it is off the chain but about to run its handler.
309          *
310          * I was tempted to assert(!waiter->holds_tchain_lock), to catch people who
311          * try to unset from a handler.  That won't work, since you can validly
312          * unset while the alarm is going off.  In that case, you might see
313          * holds_tchain_lock set briefly. */
314         spin_lock_irqsave(&tchain->lock);
315         if (waiter->on_tchain) {
316                 was_on_chain = TRUE;
317                 if (__remove_awaiter(tchain, waiter))
318                         reset_tchain_interrupt(tchain);
319         }
320         spin_unlock_irqsave(&tchain->lock);
321         /* IRQ alarms run under the tchain lock.  If we ripped it off the chain, it
322          * won't fire again.  Alarms that rearm may have fired multiple times before
323          * we locked, but once we locked, it was done. */
324         return was_on_chain;
325 }
326
327 static bool __unset_alarm_rkm(struct timer_chain *tchain,
328                               struct alarm_waiter *waiter)
329 {
330         bool was_on_chain, was_pending;
331
332         cv_lock(&waiter->rkm_cv);
333         while (1) {
334                 spin_lock_irqsave(&tchain->lock);
335                 was_on_chain = waiter->on_tchain;
336                 /* I think we can safely check pending outside the tchain lock, but it's
337                  * not worth the hassle and this is probably safer.  Basically,
338                  * rkm_pending will be set only if on_tchain is FALSE, and it won't get
339                  * cleared until someone grabs the cv_lock (which we hold). */
340                 was_pending = waiter->rkm_pending;
341                 if (was_on_chain) {
342                         /* The only way we ever stop repeating alarms permanently (i.e. they
343                          * rearm) is if we yank it off the tchain */
344                         if (__remove_awaiter(tchain, waiter))
345                                 reset_tchain_interrupt(tchain);
346                         spin_unlock_irqsave(&tchain->lock);
347                         cv_unlock(&waiter->rkm_cv);
348                         return TRUE;
349                 }
350                 spin_unlock_irqsave(&tchain->lock);
351                 if (!was_pending) {
352                         /* wasn't on the chain and wasn't pending: it executed and did not
353                          * get rearmed */
354                         cv_unlock(&waiter->rkm_cv);
355                         return FALSE;
356                 }
357                 /* Wait til it executes and then try again. */
358                 cv_wait(&waiter->rkm_cv);
359         }
360 }
361
362 /* Removes waiter from the tchain before it goes off.  Returns TRUE if we
363  * disarmed before the alarm went off, FALSE if it already fired.  May block for
364  * non-IRQ / RKM alarms, since the handler may be running asynchronously. */
365 bool unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
366 {
367         if (waiter->irq_ok)
368                 return __unset_alarm_irq(tchain, waiter);
369         else
370                 return __unset_alarm_rkm(tchain, waiter);
371 }
372
373 bool reset_alarm_abs(struct timer_chain *tchain, struct alarm_waiter *waiter,
374                      uint64_t abs_time)
375 {
376         bool ret;
377
378         ret = unset_alarm(tchain, waiter);
379         set_awaiter_abs(waiter, abs_time);
380         set_alarm(tchain, waiter);
381         return ret;
382 }
383
384 bool reset_alarm_rel(struct timer_chain *tchain, struct alarm_waiter *waiter,
385                      uint64_t usleep)
386 {
387         bool ret;
388
389         ret = unset_alarm(tchain, waiter);
390         set_awaiter_rel(waiter, usleep);
391         set_alarm(tchain, waiter);
392         return ret;
393 }
394
395 /* Sets the timer interrupt for the timer chain passed as parameter.
396  * The next interrupt will be scheduled at the nearest timer available in the
397  * chain.
398  * This function can be called either for the local CPU, or for a remote CPU.
399  * If called for the local CPU, it proceeds in setting up the local timer,
400  * otherwise it will trigger an IPI, and will let the remote CPU IRQ handler
401  * to setup the timer according to the active information on its timer chain.
402  *
403  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
404  * if time is 0.   Any function like this needs to do a few things:
405  *      - Make sure the interrupt is on and will go off when we want
406  *      - Make sure the interrupt source can find tchain
407  *      - Make sure the interrupt handler calls __trigger_tchain(tchain)
408  *      - Make sure you don't clobber an old tchain here (a bug)
409  * This implies the function knows how to find its timer source/void
410  *
411  * Called with the tchain lock held, and IRQs disabled.  However, we could be
412  * calling this cross-core, and we cannot disable those IRQs (hence the
413  * locking). */
414 void set_pcpu_alarm_interrupt(struct timer_chain *tchain)
415 {
416         uint64_t time, rel_usec, now;
417         int pcoreid = core_id();
418         struct per_cpu_info *rem_pcpui, *pcpui = &per_cpu_info[pcoreid];
419         struct timer_chain *pcpui_tchain = &pcpui->tchain;
420
421         if (pcpui_tchain != tchain) {
422                 /* cross-core call.  we can simply send an alarm IRQ.  the alarm handler
423                  * will reset its pcpu timer, based on its current lists.  they take an
424                  * extra IRQ, but it gets the job done. */
425                 rem_pcpui = (struct per_cpu_info*)((uintptr_t)tchain -
426                                     offsetof(struct per_cpu_info, tchain));
427                 /* TODO: using the LAPIC vector is a bit ghetto, since that's x86.  But
428                  * RISCV ignores the vector field, and we don't have a global IRQ vector
429                  * namespace or anything. */
430                 send_ipi(rem_pcpui - &per_cpu_info[0], IdtLAPIC_TIMER);
431                 return;
432         }
433         time = TAILQ_EMPTY(&tchain->waiters) ? 0 : tchain->earliest_time;
434         if (time) {
435                 /* Arm the alarm.  For times in the past, we just need to make sure it
436                  * goes off. */
437                 now = read_tsc();
438                 if (time <= now)
439                         rel_usec = 1;
440                 else
441                         rel_usec = tsc2usec(time - now);
442                 rel_usec = MAX(rel_usec, 1);
443                 printd("Setting alarm for %llu, it is now %llu, rel_time %llu "
444                        "tchain %p\n", time, now, rel_usec, pcpui_tchain);
445                 set_core_timer(rel_usec, FALSE);
446         } else  {
447                 /* Disarm */
448                 set_core_timer(0, FALSE);
449         }
450 }
451
452 /* Debug helpers */
453
454 void print_chain(struct timer_chain *tchain)
455 {
456         struct alarm_waiter *i;
457         spin_lock_irqsave(&tchain->lock);
458         printk("Chain %p is%s empty, early: %llu latest: %llu\n", tchain,
459                TAILQ_EMPTY(&tchain->waiters) ? "" : " not",
460                tchain->earliest_time,
461                tchain->latest_time);
462         TAILQ_FOREACH(i, &tchain->waiters, next) {
463                 uintptr_t f;
464                 char *f_name;
465
466                 if (i->irq_ok)
467                         f = (uintptr_t)i->func_irq;
468                 else
469                         f = (uintptr_t)i->func;
470                 f_name = get_fn_name(f);
471                 printk("\tWaiter %p, time %llu, func %p (%s)\n", i,
472                        i->wake_up_time, f, f_name);
473                 kfree(f_name);
474         }
475         spin_unlock_irqsave(&tchain->lock);
476 }
477
478 /* Prints all chains, rather verbosely */
479 void print_pcpu_chains(void)
480 {
481         struct timer_chain *pcpu_chain;
482         printk("PCPU Chains:  It is now %llu\n", read_tsc());
483
484         for (int i = 0; i < num_cores; i++) {
485                 pcpu_chain = &per_cpu_info[i].tchain;
486                 print_chain(pcpu_chain);
487         }
488 }