Kernel message parameters are now longs
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 8 Jun 2011 21:17:51 +0000 (14:17 -0700)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Nov 2011 00:36:04 +0000 (17:36 -0700)
Instead of void*s.  This helps code be 64-bit friendly, and we avoid
casting to and from pointers when we don't care about pointers.

kern/arch/i686/trap.c
kern/arch/riscv/trap.c
kern/arch/sparc/trap.c
kern/include/kthread.h
kern/include/process.h
kern/include/trap.h
kern/src/frontend.c
kern/src/kthread.c
kern/src/monitor.c
kern/src/process.c
kern/src/testing.c

index 0413dd5..3c095fb 100644 (file)
@@ -428,8 +428,8 @@ void kernel_msg_init(void)
                           sizeof(struct kernel_message), HW_CACHE_ALIGN, 0, 0, 0);
 }
 
-uint32_t send_kernel_message(uint32_t dst, amr_t pc, TV(a0t) arg0, TV(a1t) arg1,
-                             TV(a2t) arg2, int type)
+uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
+                             long arg2, int type)
 {
        kernel_message_t *k_msg;
        assert(pc);
index e7a66bb..9110e42 100644 (file)
@@ -36,8 +36,8 @@ spinlock_t kernel_message_buf_busy[MAX_NUM_CPUS] = {SPINLOCK_INITIALIZER};
 kernel_message_t kernel_message_buf[MAX_NUM_CPUS];
 
 /* This is mostly identical to x86's, minus the different send_ipi call. */
-uint32_t send_kernel_message(uint32_t dst, amr_t pc,
-                             TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2, int type)
+uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
+                             long arg2, int type)
 {
        kernel_message_t *k_msg;
        assert(pc);
index d35364f..206ae1d 100644 (file)
@@ -45,8 +45,8 @@ spinlock_t kernel_message_buf_busy[MAX_NUM_CPUS] = {SPINLOCK_INITIALIZER};
 kernel_message_t kernel_message_buf[MAX_NUM_CPUS];
 
 /* This is mostly identical to x86's, minus the different send_ipi call. */
-uint32_t send_kernel_message(uint32_t dst, amr_t pc,
-                             TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2, int type)
+uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
+                             long arg2, int type)
 {
        kernel_message_t *k_msg;
        assert(pc);
index eb4df9e..60108c0 100644 (file)
@@ -91,7 +91,7 @@ void restart_kthread(struct kthread *kthread);
 void kthread_runnable(struct kthread *kthread);
 /* Kmsg handler to launch/run a kthread.  This must be a routine message, since
  * it does not return. */
-void __launch_kthread(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
-                         void *a2);
+void __launch_kthread(struct trapframe *tf, uint32_t srcid, long a0, long a1,
+                         long a2);
 
 #endif /* ROS_KERN_KTHREAD_H */
index cf58486..bdcecab 100644 (file)
@@ -110,11 +110,10 @@ bool __proc_set_allcores(struct proc *SAFE p, uint32_t *pcorelist,
                          size_t *num, amr_t message, TV(a0t) arg0,
                          TV(a1t) arg1, TV(a2t) arg2);
 /* Takes from process p the num cores listed in corelist */
-bool __proc_take_cores(struct proc *SAFE p, uint32_t *pcorelist,
-                       size_t num, amr_t message, TV(a0t) arg0,
-                       TV(a1t) arg1, TV(a2t) arg2);
-bool __proc_take_allcores(struct proc *SAFE p, amr_t message, TV(a0t) arg0,
-                          TV(a1t) arg1, TV(a2t) arg2);
+bool __proc_take_cores(struct proc *p, uint32_t *pcorelist, size_t num,
+                       amr_t message, long arg0, long arg1, long arg2);
+bool __proc_take_allcores(struct proc *p, amr_t message, long arg0, long arg1,
+                          long arg2);
 void __proc_kmsg_pending(struct proc *p, bool ipi_pending);
 /* Exposed for kern/src/resource.c for now */
 void __map_vcore(struct proc *p, uint32_t vcoreid, uint32_t pcoreid);
@@ -134,12 +133,13 @@ void abandon_core(void);
 void __proc_tlbshootdown(struct proc *p, uintptr_t start, uintptr_t end);
 
 /* Kernel message handlers for process management */
-void __startcore(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2);
-void __notify(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2);
-void __preempt(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2);
-void __death(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2);
-void __tlbshootdown(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
-                    void *a2);
+void __startcore(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);
 
 /* Arch Specific */
 void proc_init_trapframe(trapframe_t *SAFE tf, uint32_t vcoreid,
index 5ba3b9a..ad02681 100644 (file)
@@ -74,28 +74,28 @@ void send_nmi(uint32_t os_coreid);
 
 #define KMSG_IMMEDIATE                         1
 #define KMSG_ROUTINE                   2
+
 void kernel_msg_init(void);
-typedef void (*amr_t)(trapframe_t* tf, uint32_t srcid,
-                      TV(a0t) a0, TV(a1t) a1, TV(a2t) a2);
+typedef void (*amr_t)(struct trapframe *tf, uint32_t srcid, long a0, long a1,
+                      long a2);
 
 /* Must stay 8-byte aligned for sparc */
 struct kernel_message
 {
-       STAILQ_ENTRY(kernel_message NTPTV(a0t) NTPTV(a1t) NTPTV(a2t))
-               NTPTV(a0t) NTPTV(a1t) NTPTV(a2t) link;
+       STAILQ_ENTRY(kernel_message) link;
        uint32_t srcid;
        uint32_t dstid;
        amr_t pc;
-       TV(a0t) arg0;
-       TV(a1t) arg1;
-       TV(a2t) arg2;
+       long arg0;
+       long arg1;
+       long arg2;
 }__attribute__((aligned(8)));
 
-STAILQ_HEAD(kernel_msg_list, kernel_message NTPTV(a0t) NTPTV(a1t) NTPTV(a2t));
-typedef struct kernel_message NTPTV(a0t) NTPTV(a1t) NTPTV(a2t) kernel_message_t;
+STAILQ_HEAD(kernel_msg_list, kernel_message);
+typedef struct kernel_message kernel_message_t;
 
-uint32_t send_kernel_message(uint32_t dst, amr_t pc, TV(a0t) arg0, TV(a1t) arg1,
-                             TV(a2t) arg2, int type);
+uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
+                             long arg2, int type);
 void process_routine_kmsg(struct trapframe *tf);
 
 #endif /* ROS_KERN_TRAP_H */
index a74a4bf..3f4ab22 100644 (file)
@@ -200,7 +200,7 @@ void appserver_die(uintptr_t code)
        int i;
        for(i = 0; i < num_cpus; i++)
                if(i != core_id())
-                       while(send_kernel_message(i,(amr_t)&__diediedie,(void*)code,0,0,
+                       while(send_kernel_message(i, (amr_t)&__diediedie, code, 0, 0,
                                                  KMSG_IMMEDIATE));
 
        // just in case.
index 2207d30..db0b9f8 100644 (file)
@@ -212,7 +212,7 @@ void kthread_runnable(struct kthread *kthread)
        }
        #endif
        /* For lack of anything better, send it to ourselves. (TODO: KSCHED) */
-       send_kernel_message(dst, __launch_kthread, (void*)kthread, 0, 0,
+       send_kernel_message(dst, __launch_kthread, (long)kthread, 0, 0,
                            KMSG_ROUTINE);
 }
 
@@ -220,8 +220,8 @@ void kthread_runnable(struct kthread *kthread)
  * it does not return.  Furthermore, like all routine kmsgs that don't return,
  * this needs to handle the fact that it won't return to the given TF (which is
  * a proc's TF, since this was routine). */
-void __launch_kthread(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
-                         void *a2)
+void __launch_kthread(struct trapframe *tf, uint32_t srcid, long a0, long a1,
+                         long a2)
 {
        struct kthread *kthread = (struct kthread*)a0;
        struct proc *cur_proc = current;
@@ -232,7 +232,7 @@ void __launch_kthread(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
                 * is a bit ghetto, and a lot of this will need work. */
                if (cur_proc->state == PROC_DYING) {
                        /* We could fake it and send it manually, but this is fine */
-                       send_kernel_message(core_id(), __launch_kthread, (void*)kthread,
+                       send_kernel_message(core_id(), __launch_kthread, (long)kthread,
                                            0, 0, KMSG_ROUTINE);
                        return;
                }
index 486d811..d976cd6 100644 (file)
@@ -705,8 +705,8 @@ int mon_monitor(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
                printk("No such core!  Maybe it's in another cell...\n");
                return 1;
        }
-       void run_mon(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
-                    void *a2)
+       void run_mon(struct trapframe *tf, uint32_t srcid, long a0, long a1,
+                    long a2)
        {
                monitor(0);
        }
index f01aa2e..d379285 100644 (file)
@@ -516,8 +516,8 @@ void proc_run(struct proc *p)
                                if (is_mapped_vcore(p, core_id()))
                                        self_ipi_pending = TRUE;
                                for (int i = 0; i < p->procinfo->num_vcores; i++)
-                                       send_kernel_message(get_pcoreid(p, i), __startcore, p, 0,
-                                                           0, KMSG_ROUTINE);
+                                       send_kernel_message(get_pcoreid(p, i), __startcore, (long)p,
+                                                           0, 0, KMSG_ROUTINE);
                        } else {
                                warn("Tried to proc_run() an _M with no vcores!");
                        }
@@ -642,7 +642,7 @@ void proc_destroy(struct proc *p)
                case PROC_RUNNABLE_M:
                        /* Need to reclaim any cores this proc might have, even though it's
                         * not running yet. */
-                       __proc_take_allcores(p, NULL, NULL, NULL, NULL);
+                       __proc_take_allcores(p, 0, 0, 0, 0);
                        // fallthrough
                case PROC_RUNNABLE_S:
                        // Think about other lists, like WAITING, or better ways to do this
@@ -674,8 +674,7 @@ void proc_destroy(struct proc *p)
                         * deallocate the cores.
                         * The rule is that the vcoremap is set before proc_run, and reset
                         * within proc_destroy */
-                       __proc_take_allcores(p, __death, (void *SNT)0, (void *SNT)0,
-                                            (void *SNT)0);
+                       __proc_take_allcores(p, __death, 0, 0, 0);
                        break;
                case PROC_CREATED:
                        break;
@@ -872,8 +871,8 @@ void proc_notify(struct proc *p, uint32_t vcoreid)
                        if ((p->state & PROC_RUNNING_M) && // TODO: (VC#) (_S state)
                                      (p->procinfo->vcoremap[vcoreid].valid)) {
                                printd("[kernel] sending notif to vcore %d\n", vcoreid);
-                               send_kernel_message(get_pcoreid(p, vcoreid), __notify, p, 0, 0,
-                                                   KMSG_ROUTINE);
+                               send_kernel_message(get_pcoreid(p, vcoreid), __notify, (long)p,
+                                                   0, 0, KMSG_ROUTINE);
                        } else { // TODO: think about this, fallback, etc
                                warn("Vcore unmapped, not receiving an active notif");
                        }
@@ -939,7 +938,7 @@ bool __proc_preempt_core(struct proc *p, uint32_t pcoreid)
 
        p->procinfo->vcoremap[vcoreid].preempt_served = TRUE;
        // expects a pcorelist.  assumes pcore is mapped and running_m
-       return __proc_take_cores(p, &pcoreid, 1, __preempt, p, 0, 0);
+       return __proc_take_cores(p, &pcoreid, 1, __preempt, (long)p, 0, 0);
 }
 
 /* Raw function to preempt every vcore.  Returns TRUE if the calling core will
@@ -955,7 +954,7 @@ bool __proc_preempt_all(struct proc *p)
                p->procinfo->vcoremap[active_vcoreid].preempt_served = TRUE;
                active_vcoreid++;
        }
-       return __proc_take_allcores(p, __preempt, p, 0, 0);
+       return __proc_take_allcores(p, __preempt, (long)p, 0, 0);
 }
 
 /* Warns and preempts a vcore from p.  No delaying / alarming, or anything.  The
@@ -1121,7 +1120,7 @@ bool __proc_give_cores(struct proc *SAFE p, uint32_t *pcorelist, size_t num)
                                       pcorelist[i]);
                                __map_vcore(p, free_vcoreid, pcorelist[i]);
                                p->procinfo->num_vcores++;
-                               send_kernel_message(pcorelist[i], __startcore, p, 0, 0,
+                               send_kernel_message(pcorelist[i], __startcore, (long)p, 0, 0,
                                                    KMSG_ROUTINE);
                                if (pcorelist[i] == core_id())
                                        self_ipi_pending = TRUE;
@@ -1159,9 +1158,8 @@ bool __proc_set_allcores(struct proc *SAFE p, uint32_t *pcorelist,
  * in this function group, bool signals whether or not an IPI is pending.
  *
  * WARNING: You must hold the proc_lock before calling this! */
-bool __proc_take_cores(struct proc *SAFE p, uint32_t *pcorelist,
-                       size_t num, amr_t message, TV(a0t) arg0,
-                       TV(a1t) arg1, TV(a2t) arg2)
+bool __proc_take_cores(struct proc *p, uint32_t *pcorelist, size_t num,
+                       amr_t message, long arg0, long arg1, long arg2)
 { TRUSTEDBLOCK
        uint32_t vcoreid, pcoreid;
        bool self_ipi_pending = FALSE;
@@ -1211,8 +1209,8 @@ bool __proc_take_cores(struct proc *SAFE p, uint32_t *pcorelist,
  * IPI is coming in once you unlock.
  *
  * WARNING: You must hold the proc_lock before calling this! */
-bool __proc_take_allcores(struct proc *SAFE p, amr_t message,
-                          TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2)
+bool __proc_take_allcores(struct proc *p, amr_t message, long arg0, long arg1,
+                          long arg2)
 {
        uint32_t active_vcoreid = 0, pcoreid;
        bool self_ipi_pending = FALSE;
@@ -1336,7 +1334,7 @@ void __proc_tlbshootdown(struct proc *p, uintptr_t start, uintptr_t end)
                                /* find next active vcore */
                                active_vcoreid = get_busy_vcoreid(p, active_vcoreid);
                                send_kernel_message(get_pcoreid(p, active_vcoreid),
-                                                   __tlbshootdown, (void*)start, (void*)end,
+                                                   __tlbshootdown, start, end,
                                                    0, KMSG_IMMEDIATE);
                                active_vcoreid++; /* next loop, skip the one we just used */
                        }
@@ -1354,7 +1352,7 @@ void __proc_tlbshootdown(struct proc *p, uintptr_t start, uintptr_t end)
 
 /* Kernel message handler to start a process's context on this core.  Tightly
  * coupled with proc_run().  Interrupts are disabled. */
-void __startcore(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2)
+void __startcore(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
 {
        uint32_t pcoreid = core_id(), vcoreid;
        struct proc *p_to_run = (struct proc *CT(1))a0;
@@ -1401,7 +1399,7 @@ void __startcore(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2)
 /* Bail out if it's the wrong process, or if they no longer want a notif.  Make
  * sure that you are passing in a user tf (otherwise, it's a bug).  Try not to
  * grab locks or write access to anything that isn't per-core in here. */
-void __notify(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2)
+void __notify(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
 {
        struct user_trapframe local_tf;
        struct preempt_data *vcpd;
@@ -1434,7 +1432,7 @@ void __notify(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2)
        __proc_startcore(p, &local_tf);
 }
 
-void __preempt(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *a2)
+void __preempt(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
 {
        struct preempt_data *vcpd;
        uint32_t vcoreid, coreid = core_id();
@@ -1472,8 +1470,7 @@ void __preempt(trapframe_t *tf, uint32_t srcid, void *a0, void *a1, void *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(trapframe_t *tf, uint32_t srcid, void *SNT a0, void *SNT a1,
-             void *SNT a2)
+void __death(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
 {
        uint32_t vcoreid, coreid = core_id();
        if (current) {
@@ -1488,8 +1485,8 @@ void __death(trapframe_t *tf, uint32_t srcid, void *SNT a0, void *SNT a1,
 
 /* Kernel message handler, usually sent IMMEDIATE, to shoot down virtual
  * addresses from a0 to a1. */
-void __tlbshootdown(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
-                    void *a2)
+void __tlbshootdown(struct trapframe *tf, uint32_t srcid, long a0, long a1,
+                    long a2)
 {
        /* TODO: (TLB) something more intelligent with the range */
        tlbflush();
index 1cfd030..ab92055 100644 (file)
@@ -675,8 +675,8 @@ void test_circ_buffer(void)
        return;
 }
 
-void test_km_handler(trapframe_t* tf, uint32_t srcid, void *a0, void *a1,
-                     void *a2)
+void test_km_handler(struct trapframe *tf, 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);
@@ -690,28 +690,28 @@ void test_kernel_messages(void)
         * precendence (the immediates should trump the others) */
        printk("sending 5 IMMED to core 1, sending (#,deadbeef,0)\n");
        for (int i = 0; i < 5; i++)
-               send_kernel_message(1, test_km_handler, (void*)i, (void*)0xdeadbeef,
-                                   (void*)0, KMSG_IMMEDIATE);
+               send_kernel_message(1, test_km_handler, (long)i, 0xdeadbeef, 0,
+                                   KMSG_IMMEDIATE);
        udelay(5000000);
        printk("sending 5 routine to core 1, sending (#,cafebabe,0)\n");
        for (int i = 0; i < 5; i++)
-               send_kernel_message(1, test_km_handler, (void*)i, (void*)0xcafebabe,
-                                   (void*)0, KMSG_ROUTINE);
+               send_kernel_message(1, test_km_handler, (long)i, 0xcafebabe, 0,
+                                   KMSG_ROUTINE);
        udelay(5000000);
        printk("sending 10 routine and 3 immediate to core 2\n");
        for (int i = 0; i < 10; i++)
-               send_kernel_message(2, test_km_handler, (void*)i, (void*)0xcafebabe,
-                                   (void*)0, KMSG_ROUTINE);
+               send_kernel_message(2, test_km_handler, (long)i, 0xcafebabe, 0,
+                                   KMSG_ROUTINE);
        for (int i = 0; i < 3; i++)
-               send_kernel_message(2, test_km_handler, (void*)i, (void*)0xdeadbeef,
-                                   (void*)0, KMSG_IMMEDIATE);
+               send_kernel_message(2, test_km_handler, (long)i, 0xdeadbeef, 0,
+                                   KMSG_IMMEDIATE);
        udelay(5000000);
        printk("sending 5 ea alternating to core 2\n");
        for (int i = 0; i < 5; i++) {
-               send_kernel_message(2, test_km_handler, (void*)i, (void*)0xdeadbeef,
-                                   (void*)0, KMSG_IMMEDIATE);
-               send_kernel_message(2, test_km_handler, (void*)i, (void*)0xcafebabe,
-                                   (void*)0, KMSG_ROUTINE);
+               send_kernel_message(2, test_km_handler, (long)i, 0xdeadbeef, 0,
+                                   KMSG_IMMEDIATE);
+               send_kernel_message(2, test_km_handler, (long)i, 0xcafebabe, 0,
+                                   KMSG_ROUTINE);
        }
        udelay(5000000);
        return;
@@ -1215,8 +1215,8 @@ void test_random_fs(void)
 void test_kthreads(void)
 {
        /* Kernel message to restart our kthread */
-       void test_up_sem(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
-                        void *a2)
+       void test_up_sem(struct trapframe *tf, uint32_t srcid, long a0, long a1,
+                        long a2)
        {
                struct semaphore *sem = (struct semaphore*)a0;
                struct kthread *kthread;
@@ -1237,7 +1237,7 @@ void test_kthreads(void)
               get_stack_top());
        /* So we have something that will wake us up.  Routine messages won't get
         * serviced in the kernel right away. */
-       send_kernel_message(core_id(), test_up_sem, (void*)&sem, 0, 0,
+       send_kernel_message(core_id(), test_up_sem, (long)&sem, 0, 0,
                            KMSG_ROUTINE);
        /* Actually block (or try to) */
        /* This one shouldn't block - but will test the unwind (if 1 above) */
@@ -1255,8 +1255,8 @@ void test_kref(void)
        struct kref local_kref;
        bool done = FALSE;
        /* Second player's kmsg */
-       void test_kref_2(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
-                        void *a2)
+       void test_kref_2(struct trapframe *tf, uint32_t srcid, long a0, long a1,
+                        long a2)
        {
                struct kref *kref = (struct kref*)a0;
                bool *done = (bool*)a1;
@@ -1271,7 +1271,8 @@ void test_kref(void)
        }
        
        kref_init(&local_kref, fake_release, 1);
-       send_kernel_message(2, test_kref_2, &local_kref, &done, 0, KMSG_ROUTINE);
+       send_kernel_message(2, test_kref_2, (long)&local_kref, (long)&done, 0,
+                           KMSG_ROUTINE);
        for (int i = 0; i < 10000000; i++) {
                kref_get(&local_kref, 1);
                udelay(2);