Kernel messages no longer take *tf
authorBarret Rhoden <brho@cs.berkeley.edu>
Thu, 11 Apr 2013 22:14:10 +0000 (15:14 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 11 Apr 2013 22:14:10 +0000 (15:14 -0700)
I've been considering getting rid of this for a while - it is mostly an
artifact of old-school KMSGs that operated on running TFs, which was
from back before we were tracking the user-tf via pcpui->cur_tf.  Those
old messages wanted to operate on the user context, not whatever
hardware TF happened to be running at the time the KMSG executes.

16 files changed:
kern/arch/i686/e1000.c
kern/arch/i686/e1000.h
kern/arch/riscv/smp.c
kern/arch/sparc/smp.c
kern/include/arsc_server.h
kern/include/console.h
kern/include/process.h
kern/include/trap.h
kern/src/arsc.c
kern/src/console.c
kern/src/frontend.c
kern/src/kthread.c
kern/src/process.c
kern/src/schedule.c
kern/src/testing.c
kern/src/trap.c

index 7b57188..ae614cb 100644 (file)
@@ -692,7 +692,8 @@ void e1000_interrupt_handler(trapframe_t *tf, void* data) {
        e1000_irq_enable();
 }
 
-void process_pbuf(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2){
+void process_pbuf(uint32_t srcid, long a0, long a1, long a2)
+{
        if (srcid != core_id())
                warn("pbuf came from a different core\n");
        /* assume it is an ip packet */
index 55edf08..580a98f 100644 (file)
@@ -124,6 +124,6 @@ int e1000_send_pbuf(struct pbuf *p);
 static void e1000_clean_rx_irq();
 /* returns a chain of pbuf from the driver */
 struct pbuf* e1000_recv_pbuf();
-void process_pbuf(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2);
+void process_pbuf(uint32_t srcid, long a0, long a1, long a2);
 static void schedule_pb(struct pbuf* pb);
 #endif /* !ROS_INC_E1000_H */
index 5f57ff2..e6f88c2 100644 (file)
@@ -43,13 +43,12 @@ smp_make_wrapper()
        return NULL;
 }
 
-void
-smp_call_wrapper(trapframe_t* tf, uint32_t src, isr_t handler,
-                 handler_wrapper_t* wrapper, void* data)
+void smp_call_wrapper(uint32_t src, isr_t handler, handler_wrapper_t *wrapper,
+                      void *data)
 {
        if(wrapper)
                wrapper->wait_list[core_id()] = 0;
-       handler(tf, data);
+       handler(0, data);
 }
 
 int smp_call_function_self(isr_t handler, void* data,
index cb71356..1503125 100644 (file)
@@ -58,13 +58,12 @@ smp_make_wrapper()
        return NULL;
 }
 
-void
-smp_call_wrapper(trapframe_t* tf, uint32_t src, isr_t handler,
-                 handler_wrapper_t* wrapper,void* data)
+void smp_call_wrapper(uint32_t src, isr_t handler, handler_wrapper_t *wrapper,
+                      void *data)
 {
        if(wrapper)
                wrapper->wait_list[core_id()] = 0;
-       handler(tf,data);
+       handler(0, data);
 }
 
 int smp_call_function_self(isr_t handler, void* data,
index b8afedd..1f15f23 100644 (file)
@@ -19,7 +19,7 @@ extern spinlock_t arsc_proc_lock;
 
 syscall_sring_t* sys_init_arsc(struct proc* p);
 intreg_t syscall_async(struct proc* p, syscall_req_t *syscall);
-void arsc_server(trapframe_t *tf);
+void arsc_server(uint32_t srcid, long a0, long a1, long a2);
 
 static intreg_t process_generic_syscalls(struct proc* p, size_t max);
 #endif //ARSC_SERVER
index 08d80e9..fab3dbb 100644 (file)
@@ -33,8 +33,7 @@ void kb_get_from_buf(struct kb_buffer *kb, char *dst, size_t cnt);
 /* Kernel messages associated with the console.  Arch-specific interrupt
  * handlers need to call these.  For add char, a0 = &cons_buf and a1 = the char
  * you read.  Call __run_mon on your 'magic' input.  */
-void __cons_add_char(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                     long a2);
-void __run_mon(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2);
+void __cons_add_char(uint32_t srcid, long a0, long a1, long a2);
+void __run_mon(uint32_t srcid, long a0, long a1, long a2);
 
 #endif /* ROS_KERN_CONSOLE_H */
index 15a752e..3afe382 100644 (file)
@@ -128,15 +128,12 @@ void clear_owning_proc(uint32_t coreid);
 void proc_tlbshootdown(struct proc *p, uintptr_t start, uintptr_t end);
 
 /* Kernel message handlers for process management */
-void __startcore(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                 long a2);
-void __set_curtf(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                 long a2);
-void __notify(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2);
-void __preempt(trapframe_t *tf, uint32_t srcid, long a0, long a1, long a2);
-void __death(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2);
-void __tlbshootdown(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                    long a2);
+void __startcore(uint32_t srcid, long a0, long a1, long a2);
+void __set_curtf(uint32_t srcid, long a0, long a1, long a2);
+void __notify(uint32_t srcid, long a0, long a1, long a2);
+void __preempt(uint32_t srcid, long a0, long a1, long a2);
+void __death(uint32_t srcid, long a0, long a1, long a2);
+void __tlbshootdown(uint32_t srcid, long a0, long a1, long a2);
 
 /* Arch Specific */
 void proc_init_trapframe(trapframe_t *SAFE tf, uint32_t vcoreid,
index 16811ef..3ffaeac 100644 (file)
@@ -85,8 +85,7 @@ void send_nmi(uint32_t os_coreid);
 #define KMSG_IMMEDIATE                         1
 #define KMSG_ROUTINE                   2
 
-typedef void (*amr_t)(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                      long a2);
+typedef void (*amr_t)(uint32_t srcid, long a0, long a1, long a2);
 
 /* Must stay 8-byte aligned for sparc */
 struct kernel_message
index 732aced..424f463 100644 (file)
@@ -60,7 +60,7 @@ syscall_sring_t* sys_init_arsc(struct proc *p)
        return (syscall_sring_t*)va;
 }
 
-void arsc_server(struct trapframe *tf)
+void arsc_server(uint32_t srcid, long a0, long a1, long a2)
 {
        struct proc *p = NULL;
        TAILQ_INIT(&arsc_proc_list);
index 56b92df..080f2f9 100644 (file)
@@ -86,14 +86,12 @@ void kb_get_from_buf(struct kb_buffer *kb, char *dst, size_t cnt)
 /* Kernel messages associated with the console.  Arch-specific interrupt
  * handlers need to call these.  For add char, a0 = &cons_buf and a1 = the char
  * you read.  Call __run_mon on your 'magic' input.  */
-void __cons_add_char(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                     long a2)
+void __cons_add_char(uint32_t srcid, long a0, long a1, long a2)
 {
        kb_add_to_buf((struct kb_buffer*)a0, (char)a1);
 }
 
-void __run_mon(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-               long a2)
+void __run_mon(uint32_t srcid, long a0, long a1, long a2)
 {
        monitor(0);
 }
index 3f4ab22..f59ba5e 100644 (file)
@@ -188,7 +188,7 @@ int32_t frontend_syscall(pid_t pid, int32_t syscall_num,
        return ret;
 }
 
-void __diediedie(trapframe_t* tf, uint32_t srcid, uint32_t code, uint32_t a1, uint32_t a2)
+void __diediedie(uint32_t srcid, uint32_t code, uint32_t a1, uint32_t a2)
 {
        int32_t errno;
        frontend_syscall(0,APPSERVER_SYSCALL_exit,(int)code,0,0,0,&errno);
@@ -204,5 +204,5 @@ void appserver_die(uintptr_t code)
                                                  KMSG_IMMEDIATE));
 
        // just in case.
-       __diediedie(0,0,code,0,0);
+       __diediedie(0, code, 0, 0);
 }
index a9250c5..c59469c 100644 (file)
@@ -78,8 +78,7 @@ void restart_kthread(struct kthread *kthread)
 
 /* Kmsg handler to launch/run a kthread.  This must be a routine message, since
  * it does not return.  */
-static void __launch_kthread(struct trapframe *tf, uint32_t srcid, long a0,
-                             long a1, long a2)
+static void __launch_kthread(uint32_t srcid, long a0, long a1, long a2)
 {
        struct kthread *kthread = (struct kthread*)a0;
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
@@ -144,8 +143,7 @@ void kthread_runnable(struct kthread *kthread)
 }
 
 /* Kmsg helper for kthread_yield */
-static void __wake_me_up(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                                        long a2)
+static void __wake_me_up(uint32_t srcid, long a0, long a1, long a2)
 {
        struct semaphore *sem = (struct semaphore*)a0;
        assert(sem_up(sem));
index 1dea2f6..dc19a4d 100644 (file)
@@ -1850,7 +1850,7 @@ out_locked:
 /* Kernel message handler to start a process's context on this core, when the
  * core next considers running a process.  Tightly coupled with __proc_run_m().
  * Interrupts are disabled. */
-void __startcore(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
+void __startcore(uint32_t srcid, long a0, long a1, long a2)
 {
        uint32_t vcoreid = (uint32_t)a1;
        uint32_t coreid = core_id();
@@ -1885,7 +1885,7 @@ void __startcore(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2
  * to __startcore, except it is used when p already controls the core (e.g.
  * change_to).  Since the core is already controlled, pcpui such as owning proc,
  * vcoreid, and cur_proc are all already set. */
-void __set_curtf(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
+void __set_curtf(uint32_t srcid, long a0, long a1, long a2)
 {
        struct proc *p = (struct proc*)a0;
        uint32_t vcoreid = (uint32_t)a1;
@@ -1896,7 +1896,7 @@ void __set_curtf(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2
 /* Bail out if it's the wrong process, or if they no longer want a notif.  Don't
  * use the TF we passed in, we care about cur_tf.  Try not to grab locks or
  * write access to anything that isn't per-core in here. */
-void __notify(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
+void __notify(uint32_t srcid, long a0, long a1, long a2)
 {
        uint32_t vcoreid, coreid = core_id();
        struct per_cpu_info *pcpui = &per_cpu_info[coreid];
@@ -1933,7 +1933,7 @@ void __notify(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
        /* this cur_tf will get run when the kernel returns / idles */
 }
 
-void __preempt(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
+void __preempt(uint32_t srcid, long a0, long a1, long a2)
 {
        uint32_t vcoreid, coreid = core_id();
        struct per_cpu_info *pcpui = &per_cpu_info[coreid];
@@ -1981,7 +1981,7 @@ void __preempt(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
  * Note this leaves no trace of what was running.
  * It's okay if death comes to a core that's already idling and has no current.
  * It could happen if a process decref'd before __proc_startcore could incref. */
-void __death(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
+void __death(uint32_t srcid, long a0, long a1, long a2)
 {
        uint32_t vcoreid, coreid = core_id();
        struct per_cpu_info *pcpui = &per_cpu_info[coreid];
@@ -1999,8 +1999,7 @@ void __death(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
 
 /* Kernel message handler, usually sent IMMEDIATE, to shoot down virtual
  * addresses from a0 to a1. */
-void __tlbshootdown(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                    long a2)
+void __tlbshootdown(uint32_t srcid, long a0, long a1, long a2)
 {
        /* TODO: (TLB) something more intelligent with the range */
        tlbflush();
index 417c239..4065ffa 100644 (file)
@@ -101,8 +101,7 @@ static void set_ksched_alarm(void)
  * 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
  * quiescent state. */
-static void __ksched_tick(struct trapframe *tf, uint32_t srcid, long a0,
-                          long a1, long a2)
+static void __ksched_tick(uint32_t srcid, long a0, long a1, long a2)
 {
        /* TODO: imagine doing some accounting here */
        schedule();
@@ -144,7 +143,7 @@ void schedule_init(void)
        struct sched_pcore *a_core = TAILQ_FIRST(&idlecores);
        assert(a_core);
        TAILQ_REMOVE(&idlecores, a_core, alloc_next);
-       send_kernel_message(spc2pcoreid(a_core), (amr_t)arsc_server, 0, 0, 0,
+       send_kernel_message(spc2pcoreid(a_core), arsc_server, 0, 0, 0,
                            KMSG_ROUTINE);
        warn("Using core %d for the ARSCs - there are probably issues with this.",
             spc2pcoreid(a_core));
index 70755a0..7f15984 100644 (file)
@@ -679,8 +679,7 @@ void test_circ_buffer(void)
        return;
 }
 
-static void test_km_handler(struct trapframe *tf, uint32_t srcid, long a0,
-                            long a1, long a2)
+static void test_km_handler(uint32_t srcid, long a0, long a1, long a2)
 {
        printk("Received KM on core %d from core %d: arg0= 0x%08x, arg1 = "
               "0x%08x, arg2 = 0x%08x\n", core_id(), srcid, a0, a1, a2);
@@ -1308,8 +1307,7 @@ void test_random_fs(void)
 }
 
 /* Kernel message to restart our kthread */
-static void __test_up_sem(struct trapframe *tf, uint32_t srcid, long a0,
-                          long a1, long a2)
+static void __test_up_sem(uint32_t srcid, long a0, long a1, long a2)
 {
        struct semaphore *sem = (struct semaphore*)a0;
        printk("[kmsg] Upping the sem to start the kthread, stacktop is %08p\n",
@@ -1346,8 +1344,7 @@ void test_kthreads(void)
 }
 
 /* Second player's kmsg */
-static void __test_kref_2(struct trapframe *tf, uint32_t srcid, long a0,
-                          long a1, long a2)
+static void __test_kref_2(uint32_t srcid, long a0, long a1, long a2)
 {
        struct kref *kref = (struct kref*)a0;
        bool *done = (bool*)a1;
@@ -1430,8 +1427,7 @@ void test_atomics(void)
 }
 
 /* Helper KMSG for test_abort.  Core 1 does this, while core 0 sends an IRQ. */
-static void __test_try_halt(struct trapframe *tf, uint32_t srcid, long a0,
-                            long a1, long a2)
+static void __test_try_halt(uint32_t srcid, long a0, long a1, long a2)
 {
        disable_irq();
        /* wait 10 sec.  should have a bunch of ints pending */
@@ -1462,8 +1458,7 @@ atomic_t counter;
 struct cond_var *cv = &local_cv;
 volatile bool state = FALSE;           /* for test 3 */
 
-void __test_cv_signal(struct trapframe *tf, uint32_t srcid, long a0,
-                      long a1, long a2)
+void __test_cv_signal(uint32_t srcid, long a0, long a1, long a2)
 {
        if (atomic_read(&counter) % 4)
                cv_signal(cv);
@@ -1471,16 +1466,16 @@ void __test_cv_signal(struct trapframe *tf, uint32_t srcid, long a0,
                cv_broadcast(cv);
        atomic_dec(&counter);
 }
-void __test_cv_waiter(struct trapframe *tf, uint32_t srcid, long a0,
-                      long a1, long a2)
+
+void __test_cv_waiter(uint32_t srcid, long a0, long a1, long a2)
 {
        cv_lock(cv);
        /* check state, etc */
        cv_wait_and_unlock(cv);
        atomic_dec(&counter);
 }
-void __test_cv_waiter_t3(struct trapframe *tf, uint32_t srcid, long a0,
-                         long a1, long a2)
+
+void __test_cv_waiter_t3(uint32_t srcid, long a0, long a1, long a2)
 {
        udelay(a0);
        /* if state == false, we haven't seen the signal yet */
index 9a200dd..0c070a0 100644 (file)
@@ -76,7 +76,7 @@ void handle_kmsg_ipi(struct trapframe *tf, void *data)
        /* The lock serves as a cmb to force a re-read of the head of the list */
        spin_lock(&pcpui->immed_amsg_lock);
        STAILQ_FOREACH_SAFE(kmsg_i, &pcpui->immed_amsgs, link, temp) {
-               kmsg_i->pc(tf, kmsg_i->srcid, kmsg_i->arg0, kmsg_i->arg1, kmsg_i->arg2);
+               kmsg_i->pc(kmsg_i->srcid, kmsg_i->arg0, kmsg_i->arg1, kmsg_i->arg2);
                STAILQ_REMOVE(&pcpui->immed_amsgs, kmsg_i, kernel_message, link);
                kmem_cache_free(kernel_msg_cache, (void*)kmsg_i);
        }
@@ -125,11 +125,7 @@ void process_routine_kmsg(void)
                kmem_cache_free(kernel_msg_cache, (void*)kmsg);
                assert(msg_cp.dstid == pcoreid);        /* caught a brutal bug with this */
                set_rkmsg(pcpui);                                       /* we're now in early RKM ctx */
-               /* Note we pass pcpui->cur_tf to all kmsgs.  I'm leaning towards
-                * dropping the TFs completely, but might find a debugging use for them
-                * later. */
-               msg_cp.pc(pcpui->cur_tf, msg_cp.srcid, msg_cp.arg0, msg_cp.arg1,
-                         msg_cp.arg2);
+               msg_cp.pc(msg_cp.srcid, msg_cp.arg0, msg_cp.arg1, msg_cp.arg2);
                /* If we aren't still in early RKM, it is because the KMSG blocked
                 * (thus leaving early RKM, finishing in default context) and then
                 * returned.  This is a 'detached' RKM.  Must idle in this scenario,
@@ -179,7 +175,8 @@ void kmsg_queue_stat(void)
                spin_lock_irqsave(&per_cpu_info[i].routine_amsg_lock);
                routine_emp = STAILQ_EMPTY(&per_cpu_info[i].routine_amsgs);
                spin_unlock_irqsave(&per_cpu_info[i].routine_amsg_lock);
-               printk("Core %d's immed_emp: %d, routine_emp %d\n", i, immed_emp, routine_emp);
+               printk("Core %d's immed_emp: %d, routine_emp %d\n", i, immed_emp,
+               routine_emp);
                if (!immed_emp) {
                        kmsg = STAILQ_FIRST(&per_cpu_info[i].immed_amsgs);
                        printk("Immed msg on core %d:\n", i);