Rename RCU CB context to 'cannot block' context
[akaros.git] / kern / src / kthread.c
index 59db13c..ea56d27 100644 (file)
@@ -126,7 +126,9 @@ void restart_kthread(struct kthread *kthread)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        uintptr_t current_stacktop;
-       struct kthread *current_kthread;
+       struct kthread *cur_kth;
+       struct proc *old_proc;
+
        /* Avoid messy complications.  The kthread will enable_irqsave() when it
         * comes back up. */
        disable_irq();
@@ -138,11 +140,11 @@ void restart_kthread(struct kthread *kthread)
                put_kstack(pcpui->spare->stacktop);
                kmem_cache_free(kthread_kcache, pcpui->spare);
        }
-       current_kthread = pcpui->cur_kthread;
-       current_stacktop = current_kthread->stacktop;
-       assert(!current_kthread->sysc); /* catch bugs, prev user should clear */
+       cur_kth = pcpui->cur_kthread;
+       current_stacktop = cur_kth->stacktop;
+       assert(!cur_kth->sysc); /* catch bugs, prev user should clear */
        /* Set the spare stuff (current kthread, which includes its stacktop) */
-       pcpui->spare = current_kthread;
+       pcpui->spare = cur_kth;
        /* When a kthread runs, its stack is the default kernel stack */
        set_stack_top(kthread->stacktop);
        pcpui->cur_kthread = kthread;
@@ -164,11 +166,12 @@ void restart_kthread(struct kthread *kthread)
                        lcr3(kthread->proc->env_cr3);
                        /* Might have to clear out an existing current.  If they need to be
                         * set later (like in restartcore), it'll be done on demand. */
-                       if (pcpui->cur_proc)
-                               proc_decref(pcpui->cur_proc);
+                       old_proc = pcpui->cur_proc;
                        /* Transfer our counted ref from kthread->proc to cur_proc. */
                        pcpui->cur_proc = kthread->proc;
                        kthread->proc = 0;
+                       if (old_proc)
+                               proc_decref(old_proc);
                }
        }
        /* Finally, restart our thread */
@@ -183,8 +186,6 @@ static void __launch_kthread(uint32_t srcid, long a0, long a1, long a2)
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        struct proc *cur_proc = pcpui->cur_proc;
 
-       /* Make sure we are a routine kmsg */
-       assert(in_early_rkmsg_ctx(pcpui));
        if (pcpui->owning_proc && pcpui->owning_proc != kthread->proc) {
                /* Some process should be running here that is not the same as the
                 * kthread.  This means the _M is getting interrupted or otherwise
@@ -198,9 +199,7 @@ static void __launch_kthread(uint32_t srcid, long a0, long a1, long a2)
        }
        /* o/w, just run the kthread.  any trapframes that are supposed to run or
         * were interrupted will run whenever the kthread smp_idles() or otherwise
-        * finishes.  We also need to clear the RKMSG context since we will not
-        * return from restart_kth. */
-       clear_rkmsg(pcpui);
+        * finishes. */
        restart_kthread(kthread);
        assert(0);
 }
@@ -227,21 +226,13 @@ void kthread_runnable(struct kthread *kthread)
                            KMSG_ROUTINE);
 }
 
-/* Kmsg helper for kthread_yield */
-static void __wake_me_up(uint32_t srcid, long a0, long a1, long a2)
-{
-       struct semaphore *sem = (struct semaphore*)a0;
-       assert(sem_up(sem));
-}
-
 /* Stop the current kthread.  It'll get woken up next time we run routine kmsgs,
  * after all existing kmsgs are processed. */
 void kthread_yield(void)
 {
        struct semaphore local_sem, *sem = &local_sem;
        sem_init(sem, 0);
-       send_kernel_message(core_id(), __wake_me_up, (long)sem, 0, 0,
-                           KMSG_ROUTINE);
+       run_as_rkm(sem_up, sem);
        sem_down(sem);
 }
 
@@ -329,15 +320,16 @@ void sem_init_irqsave(struct semaphore *sem, int signals)
        sem->irq_okay = TRUE;
 }
 
-bool sem_trydown(struct semaphore *sem)
+bool sem_trydown_bulk(struct semaphore *sem, int nr_signals)
 {
        bool ret = FALSE;
+
        /* lockless peek */
-       if (sem->nr_signals <= 0)
+       if (sem->nr_signals - nr_signals < 0)
                return ret;
        debug_lock_semlist();
        spin_lock(&sem->lock);
-       if (sem->nr_signals > 0) {
+       if (sem->nr_signals - nr_signals >= 0) {
                sem->nr_signals--;
                ret = TRUE;
                debug_downed_sem(sem);
@@ -347,6 +339,11 @@ bool sem_trydown(struct semaphore *sem)
        return ret;
 }
 
+bool sem_trydown(struct semaphore *sem)
+{
+       return sem_trydown_bulk(sem, 1);
+}
+
 /* Bottom-half of sem_down.  This is called after we jumped to the new stack. */
 static void __attribute__((noreturn)) __unlock_and_idle(void *arg)
 {
@@ -420,9 +417,8 @@ void sem_down(struct semaphore *sem)
         *
         * Normal kthreads need to stay in the process context, but we want the core
         * (which could be a vcore) to stay in the context too. */
-       if (kthread->flags & KTH_SAVE_ADDR_SPACE) {
+       if ((kthread->flags & KTH_SAVE_ADDR_SPACE) && current) {
                kthread->proc = current;
-               assert(kthread->proc);
                /* In the future, we could check owning_proc. If it isn't set, we could
                 * clear current and transfer the refcnt to kthread->proc.  If so, we'll
                 * need to reset the cr3 to something (boot_cr3 or owning_proc's cr3),
@@ -435,7 +431,8 @@ void sem_down(struct semaphore *sem)
                goto block_return_path;
        debug_lock_semlist();
        spin_lock(&sem->lock);
-       if (sem->nr_signals-- <= 0) {
+       sem->nr_signals -= 1;
+       if (sem->nr_signals < 0) {
                TAILQ_INSERT_TAIL(&sem->waiters, kthread, link);
                debug_downed_sem(sem);  /* need to debug after inserting */
                /* At this point, we know we'll sleep and change stacks.  Once we unlock
@@ -475,6 +472,20 @@ block_return_path:
        return;
 }
 
+void sem_down_bulk(struct semaphore *sem, int nr_signals)
+{
+       /* This is far from ideal.  Our current sem code expects a 1:1 pairing of
+        * signals to waiters.  For instance, if we have 10 waiters of -1 each or 1
+        * waiter of -10, we can't tell from looking at the overall structure.  We'd
+        * need to track the desired number of signals per waiter.
+        *
+        * Note that if there are a bunch of signals available, sem_down will
+        * quickly do a try_down and return, so we won't block repeatedly.  But if
+        * we do block, we could wake up N times. */
+       for (int i = 0; i < nr_signals; i++)
+               sem_down(sem);
+}
+
 /* Ups the semaphore.  If it was < 0, we need to wake up someone, which we do.
  * Returns TRUE if we woke someone, FALSE o/w (used for debugging in some
  * places).  If we need more control, we can implement a version of the old
@@ -506,22 +517,35 @@ bool sem_up(struct semaphore *sem)
        return FALSE;
 }
 
-bool sem_trydown_irqsave(struct semaphore *sem, int8_t *irq_state)
+bool sem_trydown_bulk_irqsave(struct semaphore *sem, int nr_signals,
+                              int8_t *irq_state)
 {
        bool ret;
+
        disable_irqsave(irq_state);
-       ret = sem_trydown(sem);
+       ret = sem_trydown_bulk(sem, nr_signals);
        enable_irqsave(irq_state);
        return ret;
 }
 
-void sem_down_irqsave(struct semaphore *sem, int8_t *irq_state)
+bool sem_trydown_irqsave(struct semaphore *sem, int8_t *irq_state)
+{
+       return sem_trydown_bulk_irqsave(sem, 1, irq_state);
+}
+
+void sem_down_bulk_irqsave(struct semaphore *sem, int nr_signals,
+                           int8_t *irq_state)
 {
        disable_irqsave(irq_state);
-       sem_down(sem);
+       sem_down_bulk(sem, nr_signals);
        enable_irqsave(irq_state);
 }
 
+void sem_down_irqsave(struct semaphore *sem, int8_t *irq_state)
+{
+       sem_down_bulk_irqsave(sem, 1, irq_state);
+}
+
 bool sem_up_irqsave(struct semaphore *sem, int8_t *irq_state)
 {
        bool retval;
@@ -593,11 +617,34 @@ static void debug_upped_sem(struct semaphore *sem)
 
 #endif /* CONFIG_SEMAPHORE_DEBUG */
 
-void print_sem_info(struct semaphore *sem)
+static bool __sem_has_pid(struct semaphore *sem, pid_t pid)
+{
+       struct kthread *kth_i;
+
+       if (pid == -1)
+               return TRUE;
+       TAILQ_FOREACH(kth_i, &sem->waiters, link) {
+               if (kth_i->proc) {
+                       if (kth_i->proc->pid == pid)
+                               return TRUE;
+               } else {
+                       if (pid == 0)
+                               return TRUE;
+               }
+       }
+       return FALSE;
+}
+
+static void print_sem_info(struct semaphore *sem, pid_t pid)
 {
        struct kthread *kth_i;
+
        /* Always safe to irqsave */
        spin_lock_irqsave(&sem->lock);
+       if (!__sem_has_pid(sem, pid)) {
+               spin_unlock_irqsave(&sem->lock);
+               return;
+       }
        printk("Semaphore %p has %d signals (neg = waiters)\n", sem,
               sem->nr_signals);
        TAILQ_FOREACH(kth_i, &sem->waiters, link)
@@ -609,14 +656,14 @@ void print_sem_info(struct semaphore *sem)
        spin_unlock_irqsave(&sem->lock);
 }
 
-void print_all_sem_info(void)
+void print_all_sem_info(pid_t pid)
 {
 #ifdef CONFIG_SEMAPHORE_DEBUG
        struct semaphore *sem_i;
        printk("All sems with waiters:\n");
        spin_lock_irqsave(&sems_with_waiters_lock);
        TAILQ_FOREACH(sem_i, &sems_with_waiters, link)
-               print_sem_info(sem_i);
+               print_sem_info(sem_i, pid);
        spin_unlock_irqsave(&sems_with_waiters_lock);
 #else
        printk("Failed to print all sems: build with CONFIG_SEMAPHORE_DEBUG\n");