Changeset 408 for trunk/hal/tsar_mips32/core/hal_context.c

Timestamp:

Dec 5, 2017, 4:20:07 PM (5 years ago)

Author:

alain

Message:

Fix several bugs in the fork() syscall.

File:

• trunk/hal/tsar_mips32/core/hal_context.c (modified) (4 diffs)

trunk/hal/tsar_mips32/core/hal_context.c

@@ -36 +36 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-//       Define various SR values for TSAR-MIPS32 
-/////////////////////////////////////////////////////////////////////////////////////////
-
-#define SR_USR_MODE       0x0000FC13
-#define SR_USR_MODE_FPU   0x2000FC13
-#define SR_SYS_MODE       0x0000FC00
+//       Define various SR initialisation values for TSAR-MIPS32 
+/////////////////////////////////////////////////////////////////////////////////////////
+
+#define SR_USR_MODE       0x0000FF13
+#define SR_USR_MODE_FPU   0x2000FF13
+#define SR_SYS_MODE       0x0000FF00
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -191 +191 @@
 }  // end hal_cpu_context_create()
 
+////////////////////////////////////////////
+void hal_cpu_context_fork( xptr_t child_xp )
+{
+    // allocate a local CPU context in kernel stack
+    // It is initialized from local parent context
+    // and from child specific values, and is copied in
+    // in the remote child context using a remote_memcpy()
+    hal_cpu_context_t  context;
+
+    // get local parent thread local pointer
+    thread_t * parent_ptr = CURRENT_THREAD;
+
+    // get remote child thread cluster and local pointer
+    cxy_t      child_cxy = GET_CXY( child_xp );
+    thread_t * child_ptr = (thread_t *)GET_PTR( child_xp );
+
+    // get remote child cpu_context local pointer
+    char * child_context_ptr = hal_remote_lpt( XPTR(child_cxy , &child_ptr->cpu_context) );
+
+    // get local pointer on remote child process
+    process_t * process = (process_t *)hal_remote_lpt( XPTR(child_cxy , &child_ptr->process) );
+
+    // get ppn of remote child process page table
+    uint32_t    pt_ppn = hal_remote_lw( XPTR(child_cxy , &process->vmm.gpt.ppn) );
+
+    // save CPU registers in local CPU context
+    hal_do_cpu_save( &context );
+
+    // From this point, both parent and child threads execute the following code.
+    // They can be distinguished by the CURRENT_THREAD value, and child will only 
+    // execute it when it is unblocked by parent, after return to sys_fork().
+    // - parent thread copies user stack, and patch sp_29 / c0_th / C0_sr / c2_ptpr
+    // - child thread does nothing
+
+    thread_t * current = CURRENT_THREAD;
+
+    if( current == parent_ptr )    // current == parent thread
+    {
+        // get parent and child stack pointers
+        char * parent_sp = (char *)context.sp_29;
+        char * child_sp  = (char *)((intptr_t)parent_sp +
+                                    (intptr_t)child_ptr - 
+                                    (intptr_t)parent_ptr );
+ 
+        // patch kernel_stack pointer, current thread, and status slots
+        context.sp_29   = (uint32_t)child_sp;
+        context.c0_th   = (uint32_t)child_ptr;
+        context.c0_sr   = SR_SYS_MODE;
+        context.c2_ptpr = pt_ppn >> 1;
+
+        // copy local context to remote child context)
+        hal_remote_memcpy( XPTR( child_cxy , child_context_ptr ),
+                           XPTR( local_cxy  , &context ) , 
+                           sizeof( hal_cpu_context_t ) );
+
+        // copy kernel stack content from local parent thread to remote child thread
+        uint32_t size = (uint32_t)parent_ptr + CONFIG_THREAD_DESC_SIZE - (uint32_t)parent_sp;
+        hal_remote_memcpy( XPTR( child_cxy , child_sp ),
+                           XPTR( local_cxy , parent_sp ),
+                           size );
+    }
+    else                           // current == child thread
+    {
+        assert( (current == child_ptr) , __FUNCTION__ , "current = %x / child = %x\n");
+    }
+
+}  // end hal_cpu_context_fork()
+
 /////////////////////////////////////////////////
-void hal_cpu_context_display( thread_t * thread )
-{
-    hal_cpu_context_t * ctx = (hal_cpu_context_t *)thread->cpu_context;
-
+void hal_cpu_context_display( xptr_t  thread_xp )
+{
+    hal_cpu_context_t * ctx;
+
+    // get thread cluster and local pointer
+    cxy_t      cxy = GET_CXY( thread_xp );
+    thread_t * ptr = (thread_t *)GET_PTR( thread_xp );
+
+    // get context pointer
+    ctx = (hal_cpu_context_t *)hal_remote_lpt( XPTR( cxy , &ptr->cpu_context ) );
+
+    // get relevant context slots values
+    uint32_t sp_29   = hal_remote_lw( XPTR( cxy , &ctx->sp_29   ) );
+    uint32_t ra_31   = hal_remote_lw( XPTR( cxy , &ctx->ra_31   ) );
+    uint32_t c0_sr   = hal_remote_lw( XPTR( cxy , &ctx->c0_sr   ) );
+    uint32_t c0_epc  = hal_remote_lw( XPTR( cxy , &ctx->c0_epc  ) );
+    uint32_t c0_th   = hal_remote_lw( XPTR( cxy , &ctx->c0_th   ) );
+    uint32_t c2_ptpr = hal_remote_lw( XPTR( cxy , &ctx->c2_ptpr ) );
+    uint32_t c2_mode = hal_remote_lw( XPTR( cxy , &ctx->c2_mode ) );
+    
     printk("\n***** CPU context for thread %x in process %x / cycle %d\n" 
-           " gp_28   = %X    sp_29   = %X    ra_31   = %X\n" 
+           " sp_29   = %X    ra_31   = %X\n" 
            " c0_sr   = %X    c0_epc  = %X    c0_th = %X\n"
            " c2_ptpr = %X    c2_mode = %X\n",
-           thread->trdid, thread->process->pid, hal_time_stamp(),
-           ctx->gp_28   , ctx->sp_29   , ctx->ra_31,
-           ctx->c0_sr   , ctx->c0_epc  , ctx->c0_th,
-           ctx->c2_ptpr , ctx->c2_mode );
+           ptr->trdid, ptr->process->pid, hal_time_stamp(),
+           sp_29   , ra_31,
+           c0_sr   , c0_epc  , c0_th,
+           c2_ptpr , c2_mode );
 
 }  // end hal_cpu_context_display()
@@ -270 +354 @@
 
 //////////////////////////////////////////////
-void hal_fpu_context_save( thread_t * thread )
-{
-    uint32_t ctx = (uint32_t)thread->fpu_context;
+void hal_fpu_context_save( xptr_t  thread_xp )
+{
+    // allocate a local FPU context in kernel stack
+    hal_fpu_context_t  context;
+
+    // get remote child cluster and local pointer
+    cxy_t      thread_cxy = GET_CXY( thread_xp );
+    thread_t * thread_ptr = (thread_t *)GET_PTR( thread_xp );
 
     asm volatile(
@@ -309 +398 @@
     "swc1    $f31,  31*4(%0)  \n"   
     ".set reorder             \n"
-    : : "r"(ctx) );
-
-}  // end hal_cpu_context_save()
+    : : "r"(&context) );
+
+    // copy local context to remote child context)
+    hal_remote_memcpy( XPTR( thread_cxy , &thread_ptr->fpu_context ),
+                       XPTR( local_cxy  , &context ) , 
+                       sizeof( hal_fpu_context_t ) );
+
+}  // end hal_fpu_context_save()
 
 /////////////////////////////////////////////////