Rename KMALLOC_* -> MEM_* [2/2]
[akaros.git] / kern / src / alarm.c
index 81891ba..4712288 100644 (file)
@@ -38,7 +38,7 @@ static void reset_tchain_times(struct timer_chain *tchain)
 
 /* One time set up of a tchain, currently called in per_cpu_init() */
 void init_timer_chain(struct timer_chain *tchain,
-                      void (*set_interrupt) (uint64_t, struct timer_chain *))
+                      void (*set_interrupt)(struct timer_chain *))
 {
        spinlock_init_irqsave(&tchain->lock);
        TAILQ_INIT(&tchain->waiters);
@@ -52,6 +52,7 @@ static void __init_awaiter(struct alarm_waiter *waiter)
 {
        waiter->wake_up_time = ALARM_POISON_TIME;
        waiter->on_tchain = FALSE;
+       waiter->holds_tchain_lock = FALSE;
        if (!waiter->has_func)
                sem_init_irqsave(&waiter->sem, 0);
 }
@@ -112,13 +113,13 @@ static void reset_tchain_interrupt(struct timer_chain *tchain)
        if (TAILQ_EMPTY(&tchain->waiters)) {
                /* Turn it off */
                printd("Turning alarm off\n");
-               tchain->set_interrupt(0, tchain);
+               tchain->set_interrupt(tchain);
        } else {
                /* Make sure it is on and set to the earliest time */
                assert(tchain->earliest_time != ALARM_POISON_TIME);
                /* TODO: check for times in the past or very close to now */
                printd("Turning alarm on for %llu\n", tchain->earliest_time);
-               tchain->set_interrupt(tchain->earliest_time, tchain);
+               tchain->set_interrupt(tchain);
        }
 }
 
@@ -134,11 +135,14 @@ static void wake_awaiter(struct alarm_waiter *waiter,
                          struct hw_trapframe *hw_tf)
 {
        if (waiter->has_func) {
-               if (waiter->irq_ok)
+               if (waiter->irq_ok) {
+                       waiter->holds_tchain_lock = TRUE;
                        waiter->func_irq(waiter, hw_tf);
-               else
+                       waiter->holds_tchain_lock = FALSE;
+               } else {
                        send_kernel_message(core_id(), __run_awaiter, (long)waiter,
                                            0, 0, KMSG_ROUTINE);
+               }
        } else {
                sem_up(&waiter->sem); /* IRQs are disabled, can call sem_up directly */
        }
@@ -228,22 +232,23 @@ static bool __insert_awaiter(struct timer_chain *tchain,
        panic("Could not find a spot for awaiter %p\n", waiter);
 }
 
-/* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
- * later.  This version assumes you have the lock held.  That only makes sense
- * from alarm handlers, which are called with this lock held from IRQ context */
-void __set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
+static void __set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
 {
        if (__insert_awaiter(tchain, waiter))
                reset_tchain_interrupt(tchain);
 }
 
-/* Sets the alarm.  Don't call this from an alarm handler, since you already
- * have the lock held.  Call __set_alarm() instead. */
+/* Sets the alarm.  If it is a kthread-style alarm (func == 0), sleep on it
+ * later. */
 void set_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
 {
-       spin_lock_irqsave(&tchain->lock);
-       __set_alarm(tchain, waiter);
-       spin_unlock_irqsave(&tchain->lock);
+       if (waiter->holds_tchain_lock) {
+               __set_alarm(tchain, waiter);
+       } else {
+               spin_lock_irqsave(&tchain->lock);
+               __set_alarm(tchain, waiter);
+               spin_unlock_irqsave(&tchain->lock);
+       }
 }
 
 /* Helper, rips the waiter from the tchain, knowing that it is on the list.
@@ -274,38 +279,75 @@ static bool __remove_awaiter(struct timer_chain *tchain,
  * disarmed before the alarm went off, FALSE if it already fired. */
 bool unset_alarm(struct timer_chain *tchain, struct alarm_waiter *waiter)
 {
+       assert(!waiter->holds_tchain_lock);     /* Don't call from within a handler */
        spin_lock_irqsave(&tchain->lock);
-       if (!waiter->on_tchain) {
-               /* the alarm has already gone off.  its not even on this tchain's list,
-                * though the concurrent change to on_tchain (specifically, the setting
-                * of it to FALSE), happens under the tchain's lock. */
-               spin_unlock_irqsave(&tchain->lock);
-               return FALSE;
-       }
-       if (__remove_awaiter(tchain, waiter))
+       bool ret = waiter->on_tchain;
+       if (ret && __remove_awaiter(tchain, waiter))
                reset_tchain_interrupt(tchain);
+
+       /* if alarm had already gone off then its not on this tchain's list, though
+        * the concurrent change to on_tchain (specifically, the setting of it to
+        * FALSE), happens under the tchain's lock. */
        spin_unlock_irqsave(&tchain->lock);
-       return TRUE;
+       return ret;
 }
 
 /* waiter may be on the tchain, or it might have fired already and be off the
  * tchain.  Either way, this will put the waiter on the list, set to go off at
  * abs_time.  If you know the alarm has fired, don't call this.  Just set the
  * awaiter, and then set_alarm() */
-void reset_alarm_abs(struct timer_chain *tchain, struct alarm_waiter *waiter,
-                     uint64_t abs_time)
+static bool __reset_alarm_abs(struct timer_chain *tchain,
+                              struct alarm_waiter *waiter, uint64_t abs_time)
 {
-       bool reset_int = FALSE;         /* whether or not to reset the interrupt */
-       spin_lock_irqsave(&tchain->lock);
+       /* The tchain's lock is held */
+       bool ret = waiter->on_tchain;
        /* We only need to remove/unset when the alarm has not fired yet (is still
-        * on the tchain).  If it has fired, it's like a fresh insert */
-       if (waiter->on_tchain)
-               reset_int = __remove_awaiter(tchain, waiter);
+        * on the tchain).  If it has fired, it's like a fresh insert. We must also
+        * check if we need to reset the interrupt. */
+       bool reset_int = ret && __remove_awaiter(tchain, waiter);
        set_awaiter_abs(waiter, abs_time);
        /* regardless, we need to be reinserted */
        if (__insert_awaiter(tchain, waiter) || reset_int)
                reset_tchain_interrupt(tchain);
-       spin_unlock_irqsave(&tchain->lock);
+       return ret;
+}
+
+static bool __reset_alarm_rel(struct timer_chain *tchain,
+                              struct alarm_waiter *waiter, uint64_t usleep)
+{
+       uint64_t now, then;
+       now = read_tsc();
+       then = now + usec2tsc(usleep);
+       assert(now <= then);
+       return __reset_alarm_abs(tchain, waiter, then);
+}
+
+bool reset_alarm_abs(struct timer_chain *tchain, struct alarm_waiter *waiter,
+                     uint64_t abs_time)
+{
+       bool ret;
+       if (waiter->holds_tchain_lock) {
+               ret = __reset_alarm_abs(tchain, waiter, abs_time);
+       } else {
+               spin_lock_irqsave(&tchain->lock);
+               ret = __reset_alarm_abs(tchain, waiter, abs_time);
+               spin_unlock_irqsave(&tchain->lock);
+       }
+       return ret;
+}
+
+bool reset_alarm_rel(struct timer_chain *tchain, struct alarm_waiter *waiter,
+                     uint64_t usleep)
+{
+       bool ret;
+       if (waiter->holds_tchain_lock) {
+               ret =__reset_alarm_rel(tchain, waiter, usleep);
+       } else {
+               spin_lock_irqsave(&tchain->lock);
+               ret =__reset_alarm_rel(tchain, waiter, usleep);
+               spin_unlock_irqsave(&tchain->lock);
+       }
+       return ret;
 }
 
 /* Attempts to sleep on the alarm.  Could fail if you aren't allowed to kthread
@@ -322,11 +364,13 @@ int sleep_on_awaiter(struct alarm_waiter *waiter)
        return 0;
 }
 
-/* Sets the Alarm interrupt, per-core style.  Also is an example of what any
- * similar function needs to do (this is the func ptr in the tchain). 
- * Note the tchain is our per-core one, and we don't need tchain passed to us to
- * figure that out.  It's kept around in case other tchain-usage wants it -
- * might not be necessary in the future.
+/* Sets the timer interrupt for the timer chain passed as parameter.
+ * The next interrupt will be scheduled at the nearest timer available in the
+ * chain.
+ * This function can be called either for the local CPU, or for a remote CPU.
+ * If called for the local CPU, it proceeds in setting up the local timer,
+ * otherwise it will trigger an IPI, and will let the remote CPU IRQ handler
+ * to setup the timer according to the active information on its timer chain.
  *
  * Needs to set the interrupt to trigger tchain at the given time, or disarm it
  * if time is 0.   Any function like this needs to do a few things:
@@ -339,9 +383,9 @@ int sleep_on_awaiter(struct alarm_waiter *waiter)
  * Called with the tchain lock held, and IRQs disabled.  However, we could be
  * calling this cross-core, and we cannot disable those IRQs (hence the
  * locking). */
-void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
+void set_pcpu_alarm_interrupt(struct timer_chain *tchain)
 {
-       uint64_t rel_usec, now;
+       uint64_t time, rel_usec, now;
        int pcoreid = core_id();
        struct per_cpu_info *rem_pcpui, *pcpui = &per_cpu_info[pcoreid];
        struct timer_chain *pcpui_tchain = &pcpui->tchain;
@@ -358,6 +402,7 @@ void set_pcpu_alarm_interrupt(uint64_t time, struct timer_chain *tchain)
                send_ipi(rem_pcpui - &per_cpu_info[0], IdtLAPIC_TIMER);
                return;
        }
+       time = TAILQ_EMPTY(&tchain->waiters) ? 0 : tchain->earliest_time;
        if (time) {
                /* Arm the alarm.  For times in the past, we just need to make sure it
                 * goes off. */
@@ -414,7 +459,7 @@ void print_pcpu_chains(void)
        struct timer_chain *pcpu_chain;
        printk("PCPU Chains:  It is now %llu\n", read_tsc());
 
-       for (int i = 0; i < num_cpus; i++) {
+       for (int i = 0; i < num_cores; i++) {
                pcpu_chain = &per_cpu_info[i].tchain;
                print_chain(pcpu_chain);
        }