Changeset 407 for trunk/kernel/syscalls/sys_fork.c

Timestamp:

Nov 7, 2017, 3:08:12 PM (7 years ago)

Author:

alain

Message:

First implementation of fork/exec.

File:

• trunk/kernel/syscalls/sys_fork.c (modified) (9 diffs)

trunk/kernel/syscalls/sys_fork.c

@@ -24 +24 @@
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_context.h>
+#include <hal_switch.h>
 #include <hal_atomic.h>
 #include <errno.h>
@@ -45 +47 @@
     pid_t                child_pid;       // child process identifier
         thread_t           * child_thread;    // pointer on child main thread descriptor
-    trdid_t              child_trdid;     // child main thread identifier
-    lid_t                child_core_lid;  // core local index for the child main thread
-    cxy_t                target_cxy;      // final target cluster for forked child process 
+    cxy_t                target_cxy;      // target cluster for forked child process 
         error_t              error;
+
+        uint64_t      tm_start;
+        uint64_t      tm_end;
+
+        tm_start = hal_get_cycles();
 
     // get pointers on parent process and thread
@@ -55 +60 @@
     parent_pid     = parent_process->pid;
 
+fork_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / cycle %d\n",
+__FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid , (uint32_t)tm_start );
+
     // check parent process children number
         if( hal_atomic_add( &parent_process->children_nr , 1 ) >= CONFIG_PROCESS_MAX_CHILDREN )
@@ -61 +69 @@
             hal_atomic_add ( &parent_process->children_nr , -1 );
         return EAGAIN;
-        }
-
-        fork_dmsg("\n[DMSG] %s : enters for process %d at cycle [%d]\n",
-                  __FUNCTION__, parent_process->pid, hal_get_cycles());
-
-    // save FPU state in fpu_context if parent process is FPU owner
-    // because we want the child process to share the FPU context
-        if( CURRENT_CORE->fpu_owner == parent_thread )
-        {
-                hal_fpu_context_save( parent_thread );
-                fork_dmsg("\n[DMSG] %s : save FPU\n", __FUNCTION__);
         }
 
@@ -95 +92 @@
         }
 
-        fork_dmsg("INFO : %s select target_cluster = %x\n",
-              __FUNCTION__ , target_cxy );
+//printk("\n[DBG] %s : core[%x,%d] for process %x selects target_cluster = %x\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid , target_cxy );
 
     // allocates memory in local cluster for the child process descriptor 
@@ -127 +124 @@
 
     // initialize and register the child process descriptor
-    process_reference_init( child_process , child_pid , parent_pid );
-
-        fork_dmsg("\n[DMSG] : %s created child process : pid = %x / ppid = %x\n", 
-              __FUNCTION__, child_pid , parent_pid );
+    process_reference_init( child_process , child_pid , XPTR(local_cxy, parent_process) );
 
     // initialises child process standard files structures
@@ -148 +142 @@
                             XPTR( local_cxy , &parent_process->fd_array ) );
 
-        fork_dmsg("\n[DMSG] %s : duplicated child process from parent process\n",
-                  __FUNCTION__ );
-
-    // replicates virtual memory manager
+//printk("\n[DBG] %s : core[%x,%d] for process %x created child process %x\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid , child_pid );
+
+    // replicate VMM
         error = vmm_copy( child_process , parent_process );
 
@@ -162 +156 @@
     }
   
-        fork_dmsg("\n[DMSG] %s : parent vmm duplicated in child process\n", __FUNCTION__ );
-
-    // create child main thread descriptor in local cluster 
-    error = thread_user_fork( parent_process , &child_thread );
-
+//printk("\n[DBG] %s : core[%x,%d] for process %x duplicated vmm in child process\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid , parent_pid );
+//vmm_display( parent_process , true );
+//vmm_display( child_process , true );
+
+    // create child main thread in local cluster 
+    error = thread_user_fork( child_process,
+                              parent_thread->u_stack_size,
+                              parent_thread->u_stack_base,
+                              &child_thread );
         if( error )
     {
-            printk("\n[ERROR] in %s : cannot duplicate thread\n", __FUNCTION__ );
+            printk("\n[ERROR] in %s : cannot duplicate main thread\n", __FUNCTION__ );
             hal_atomic_add( &parent_process->children_nr , -1 );
         process_destroy( child_process );
@@ -175 +174 @@
     }
 
-    // register child thread in child process, and get a TRDID
-    spinlock_lock( &child_process->th_lock );
-    error = process_register_thread( child_process, child_thread , &child_trdid );
-    spinlock_unlock( &child_process->th_lock );
-
-    if( error ) 
-    {
-        printk("\n[ERROR] in %s : cannot register thread\n", __FUNCTION__ );
-            hal_atomic_add ( &parent_process->children_nr , -1 );
-        thread_destroy( child_thread );
-        process_destroy( child_process );
-        return EAGAIN;
-    }
- 
-    // get a local core to execute child thread
-    child_core_lid = cluster_select_local_core();
-
-        // Update child thread descriptor
-        child_thread->core    = &LOCAL_CLUSTER->core_tbl[child_core_lid];
-        child_thread->process = child_process;
-    child_thread->trdid   = child_trdid;
-
-        fork_dmsg("\n[DMSG] %s : initialised child main thread\n", __FUNCTION__ );
-
-    // register local child thread into local child process th_tbl[]
-    // we don't use the th_lock because there is no concurrent access
-    ltid_t ltid = LTID_FROM_TRDID( child_trdid );
-        child_process->th_tbl[ltid] = child_thread;
-        child_process->th_nr = 1;
-
-    // register child thread in scheduler 
-        sched_register_thread( child_thread->core , child_thread );
-  
-        fork_dmsg("\n[DMSG] %s : registered main thread in scheduler\n", __FUNCTION__);
+//printk("\n[DBG] %s : core[%x,%d] initialised child main thread\n",
+//__FUNCTION__ , local_cxy , parent_thread->core->lid );
 
         // update DQDT for the child thread 
     dqdt_local_update_threads( 1 );
 
-        fork_dmsg("\n[DMSG] %s : completed / parent pid = %x / child pid = %x / at cycle [%d]\n",
-                  __FUNCTION__, parent_process->pid, child_process->pid, hal_get_cycles() );
-
-        return child_process->pid;
+    // set child_thread FPU_context from parent_thread register values
+    // only when the parent process is the FPU owner
+        if( CURRENT_THREAD->core->fpu_owner == parent_thread )
+        {
+                hal_fpu_context_save( child_thread->fpu_context );
+        }
+
+    // set child_thread CPU context from parent_thread register values
+    hal_do_cpu_save( child_thread->cpu_context,
+                     child_thread,
+                     (int)((intptr_t)child_thread - (intptr_t)parent_thread) );
+
+
+    // from this point, both parent and child threads execute the following code
+    // but child execute it only when it has been unblocked by its parent
+
+    thread_t * current = CURRENT_THREAD;
+
+    if( current == parent_thread )
+    {
+        // parent_thread unblock child_thread
+        thread_unblock( XPTR( local_cxy , child_thread ) , THREAD_BLOCKED_GLOBAL );
+
+        tm_end = hal_get_cycles();
+
+fork_dmsg("\n[DBG] %s : core[%x,%d] parent_process %x exit / cycle %d\n"
+"     child_process %x / child_thread = %x / cost = %d\n",
+__FUNCTION__, local_cxy, parent_thread->core->lid,  parent_pid, (uint32_t)tm_start,
+child_pid, child_thread->trdid , (uint32_t)(tm_end - tm_start) );
+
+        return child_pid;
+    }
+        else  // current == child_thread
+    {
+        assert( (current == child_thread) , __FUNCTION__ , 
+        "current thread %x is not the child thread %x\n", current , child_thread );
+
+fork_dmsg("\n[DBG] %s : core[%x,%d] child process %x exit / cycle %d\n",
+__FUNCTION__, local_cxy, parent_thread->core->lid, child_pid, (uint32_t)hal_get_cycles() );
+
+        return 0;
+    }
 
 }  // end sys_fork()