Use run_as_rkm() for simple functions
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 20 Jul 2018 02:12:15 +0000 (22:12 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 20 Jul 2018 14:25:54 +0000 (10:25 -0400)
These were a few places where the kernel message trampoline was just a
wrapper around a single function.  There are a bunch of places where
there is a separate function that does a bunch of things in the kmsg.
I'm fine with leaving them as-is for now.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/src/kthread.c
kern/src/rcu.c
kern/src/schedule.c
kern/src/taskqueue.c

index e1010ca..1457a3b 100644 (file)
@@ -227,21 +227,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);
 }
 
index 8481025..23a8a6c 100644 (file)
@@ -160,19 +160,13 @@ static void rcu_exec_cb(struct rcu_head *head)
                head->func(head);
 }
 
-static void __early_call_rcu_kmsg(uint32_t srcid, long a0, long a1, long a2)
-{
-       rcu_exec_cb((struct rcu_head*)a0);
-}
-
 void __early_call_rcu(struct rcu_head *head)
 {
        extern bool booting;
 
        assert(booting);
        assert(core_id() == 0);
-       send_kernel_message(0, __early_call_rcu_kmsg, (long)head, 0, 0,
-                           KMSG_ROUTINE);
+       run_as_rkm(rcu_exec_cb, head);
 }
 
 /* This could be called from a remote core, e.g. rcu_barrier().  Returns the
index 5823b03..4804885 100644 (file)
@@ -79,12 +79,6 @@ static void set_ksched_alarm(void)
        set_alarm(&per_cpu_info[core_id()].tchain, &ksched_waiter);
 }
 
-/* Need a kmsg to just run the sched, but not to rearm */
-static void __just_sched(uint32_t srcid, long a0, long a1, long a2)
-{
-       run_scheduler();
-}
-
 /* RKM alarm, to run the scheduler tick (not in interrupt context) and reset the
  * alarm.  Note that interrupts will be disabled, but this is not the same as
  * interrupt context.  We're a routine kmsg, which means the core is in a
@@ -301,8 +295,7 @@ static bool __schedule_scp(void)
                        /* process might be dying, with a KMSG to clean it up waiting on
                         * this core.  can't do much, so we'll attempt to restart */
                        if (proc_is_dying(pcpui->owning_proc)) {
-                               send_kernel_message(core_id(), __just_sched, 0, 0, 0,
-                                                   KMSG_ROUTINE);
+                               run_as_rkm(run_scheduler);
                                spin_unlock(&pcpui->owning_proc->proc_lock);
                                return FALSE;
                        }
index e988409..0588afa 100644 (file)
 #include <kthread.h>
 
 /* BSD Taskqueue wrappers. */
-static void __tq_wrapper(uint32_t srcid, long a0, long a1, long a2)
-{
-       task_fn_t tq_fn = (task_fn_t)a0;
-       void *tq_arg = (void*)a1;
-       tq_fn(tq_arg, 0);
-}
-
 int taskqueue_enqueue(struct taskqueue *queue, struct task *task)
 {
-       send_kernel_message(core_id(), __tq_wrapper, (long)task->ta_func,
-                           (long)task->ta_context, 0, KMSG_ROUTINE);
+       run_as_rkm(task->ta_func, task->ta_context, 0);
        return 0;
 }
 
-
 /* Linux workqueue wrappers */
 void flush_workqueue(struct workqueue_struct *wq)
 {