Made ros_pop_tf work on SPARC
authorAndrew Waterman <waterman@ros-dev.(none)>
Sat, 17 Apr 2010 01:23:20 +0000 (18:23 -0700)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Nov 2011 00:35:42 +0000 (17:35 -0700)
Unfortunately, this involves a kernel crossing.  The "good" news
is that register window flushing is necessary anyway, so the
actual overhead of the kernel crossing isn't substantial.

GNUmakefile
kern/arch/sparc/process.c
kern/arch/sparc/trap.c
kern/arch/sparc/trap_table.S
tests/mhello.c
user/include/sparc/vcore.h

index ccf8d8d..5274948 100644 (file)
@@ -84,6 +84,7 @@ endif
 endif
 
 # Default programs for compilation
+USER_CFLAGS := -O2
 ifeq ($(COMPILER),IVY)
 KERN_CFLAGS += --deputy \
                --no-rc-sharc \
index 7728424..e0a4d5f 100644 (file)
@@ -29,7 +29,8 @@ proc_init_trapframe(trapframe_t *tf, uint32_t vcoreid,
 
 void proc_secure_trapframe(struct trapframe *tf)
 {
-       tf->psr = PSR_S; // but PS = 0
+       // only take the condition codes from the user.  we set S=1, PS=0
+       tf->psr = (tf->psr & PSR_ICC) | PSR_S;
 }
 
 /* For cases that we won't return from a syscall via the normal path, and need
index 684fbea..d6cfaa0 100644 (file)
@@ -374,6 +374,17 @@ fp_disabled(trapframe_t* state)
 }
 
 void
+handle_pop_tf(trapframe_t* state)
+{
+       trapframe_t tf;
+       if(memcpy_from_user(current,&tf,(void*)state->gpr[8],sizeof(tf)))
+               proc_destroy(current);
+
+       proc_secure_trapframe(&tf);
+       proc_restartcore(current,&tf);
+}
+
+void
 handle_syscall(trapframe_t* state)
 {
        uint32_t num = state->gpr[1];
index 3f5d8a9..6797554 100644 (file)
@@ -144,7 +144,7 @@ trap_table_pagefault:
        UNHANDLED_TRAP                          ! 0x81
        UNHANDLED_TRAP                          ! 0x82
        TRAP_TABLE_ENTRY(handle_flushw)         ! 0x83
-       UNHANDLED_TRAP                          ! 0x84
+       TRAP_TABLE_ENTRY(handle_pop_tf)         ! 0x84
        UNHANDLED_TRAP                          ! 0x85
        UNHANDLED_TRAP                          ! 0x86
        UNHANDLED_TRAP                          ! 0x87
index 5c0be1e..721347a 100644 (file)
@@ -21,7 +21,7 @@ int main(int argc, char** argv)
        uint32_t vcoreid;
        int retval;
 
-       mcs_barrier_init(&b, max_vcores() - 1);
+       mcs_barrier_init(&b, max_vcores());
 
 /* begin: stuff userspace needs to do before switching to multi-mode */
        if (vcore_init())
@@ -56,8 +56,9 @@ int main(int argc, char** argv)
                       vcoreid, &temp, temp);
                printf("Multi-Goodbye, world, from PID: %d!\n", sys_getpid());
                //retval = sys_resource_req(RES_CORES, 2, 0);
-               //retval = vcore_request(vcore_max_vcores()-2);
-               retval = vcore_request(3);
+               printf("Requesting %d vcores\n",max_vcores());
+               retval = vcore_request(max_vcores());
+               //retval = vcore_request(3);
                printf("This is vcore0, right after vcore_request, retval=%d\n", retval);
        }
 
index 465a6a8..e211ee2 100644 (file)
@@ -3,6 +3,9 @@
 
 #include <ros/common.h>
 #include <ros/arch/trapframe.h>
+#include <arch/arch.h>
+#include <ros/syscall.h>
+#include <ros/procdata.h>
 
 /* Pops an ROS kernel-provided TF, reanabling notifications at the same time.
  * A Userspace scheduler can call this when transitioning off the transition
  * running. */
 static inline void pop_ros_tf(struct user_trapframe *tf, uint32_t vcoreid)
 {
-       // TODO: whatever sparc needs.
+       // since we're changing the stack, move stuff into regs for now
+       register uint32_t _vcoreid = _vcoreid;
+       register struct user_trapframe* _tf = tf;
+
+       set_stack_pointer((void*)tf->gpr[14]);
+
+       tf = _tf;
+       vcoreid = _vcoreid;
+       struct preempt_data* vcpd = &__procdata.vcore_preempt_data[vcoreid];
+
+       vcpd->notif_enabled = true;
+       if(vcpd->notif_pending)
+               ros_syscall(SYS_self_notify,vcoreid,0,0,0,0);
+
+       // tell the kernel to load the new trapframe
+       asm volatile ("mov %0, %%o0; ta 4" : : "r"(tf) : "memory");
 }
 
 /* Feel free to ignore vcoreid.  It helps x86 to avoid a call to