Changeset 433 for trunk/kernel/syscalls/sys_wait.c

Timestamp:

Feb 14, 2018, 3:40:19 PM (6 years ago)

Author:

alain

Message:

blip

File:

• trunk/kernel/syscalls/sys_wait.c (modified) (2 diffs)

trunk/kernel/syscalls/sys_wait.c

@@ -41 +41 @@
     pid_t       child_pid;
     int         child_state;
+    thread_t  * child_thread;
 
     thread_t  * this    = CURRENT_THREAD;
     process_t * process = this->process;
+    pid_t       pid     = process->pid;
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_WAIT
 uint64_t    tm_start;
 uint64_t    tm_end;
 tm_start = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] enter / process %x / cycle %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , process->pid, (uint32_t)tm_start );
+if( CONFIG_DEBUG_SYS_WAIT < tm_start )
+printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
+__FUNCTION__, this, process->pid, (uint32_t)tm_start );
 #endif
 
@@ -64 +67 @@
         }
 
-    // get cluster and local pointer on reference process
-    xptr_t      ref_xp  = process->ref_xp;
-    cxy_t       ref_cxy = GET_CXY( ref_xp );
-    process_t * ref_ptr = GET_PTR( ref_xp );
+    // get process owner cluster 
+    cxy_t owner_cxy = CXY_FROM_PID( pid );
 
-    // get extended pointer on children list root
-    xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->children_root );
+    // This function must be executed in owner cluster
+    assert( (owner_cxy == local_cxy) , __FUNCTION__ , 
+    "calling thread must execute in owner cluster" );
 
-    // get extended pointer on lock protecting the children list
-    xptr_t lock_xp = XPTR( ref_cxy , &ref_ptr->children_lock );
+    // This function must be executed by the main thread
+    assert( (process->th_tbl[0] == this) , __FUNCTION__ ,
+    "this function must be executed by the main thread" );
+   
+    // get extended pointer on children list root and lock
+    xptr_t children_root_xp = XPTR( owner_cxy , &process->children_root );
+    xptr_t children_lock_xp = XPTR( owner_cxy , &process->children_lock );
 
     // exit this blocking loop only when a child processes change state
     while( 1 )
     {
-        // get lock
-        remote_spinlock_lock( lock_xp );
+        // get lock protecting children list
+        remote_spinlock_lock( children_lock_xp );
 
-        // scan the list of child process
-        XLIST_FOREACH( root_xp , iter_xp )
+        // scan the list of owner child process
+        XLIST_FOREACH( children_root_xp , iter_xp )
         {
-            // get child process cluster and local pointer 
+            // get child process owner cluster and local pointer 
             child_xp  = XLIST_ELEMENT( iter_xp , process_t , children_list );
             child_ptr = GET_PTR( child_xp );
             child_cxy = GET_CXY( child_xp );
 
-            // get the child PID
-            child_pid = (int)hal_remote_lw( XPTR( child_cxy , &child_ptr->pid ) );
+            // get term_state from child owner process
+            child_state = (int)hal_remote_lw ( XPTR(child_cxy,&child_ptr->term_state));
 
-            // get the child process state
-            child_state = hal_remote_lw( XPTR( child_cxy , &child_ptr->state ) );
+            // test if child process is terminated,
+            // but termination not yet reported to parent process
+            if( ((child_state & PROCESS_FLAG_EXIT)   || 
+                 (child_state & PROCESS_FLAG_KILL)   ||
+                 (child_state & PROCESS_FLAG_BLOCK)) &&
+                 ((child_state & PROCESS_FLAG_WAIT) == 0) )
+            {
+                // get pointer on main thread and PID from child owner process
+                child_pid    = (pid_t)     hal_remote_lw ( XPTR(child_cxy,&child_ptr->pid));
+                child_thread = (thread_t *)hal_remote_lpt( XPTR(child_cxy,&child_ptr->th_tbl[0]));
 
-            // check child process state
-            if( child_state != PROCESS_STATE_RUNNING )
-            {
-                // release lock
-                remote_spinlock_unlock( lock_xp );
+                // set the PROCESS_FLAG_WAIT in owner child descriptor
+                hal_remote_atomic_or( XPTR( child_cxy , &child_ptr->term_state ),
+                                      PROCESS_FLAG_WAIT );
 
-#if CONFIG_SYSCALL_DEBUG 
+                // set the THREAD_FLAG_REQ_DELETE in child main thread
+                hal_remote_atomic_or( XPTR( child_cxy , &child_thread->flags ) ,
+                                            THREAD_FLAG_REQ_DELETE );
+
+#if CONFIG_DEBUG_SYS_WAIT 
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] exit / process %x / cost = %d\n",
-__FUNCTION__ , local_cxy, this->core->lid, process->pid, (uint32_t)(tm_end - tm_start) );
+if( CONFIG_DEBUG_SYS_WAIT < tm_end )
+printk("\n[DBG] %s : thread %x exit / process %x / cycle %d\n",
+__FUNCTION__, this, process->pid, (uint32_t)tm_end );
 #endif
 
-                // return relevant info to process 
-                hal_copy_to_uspace( status , &child_state , sizeof(int) );
-                return child_pid;
+                 // return relevant info to calling parent process 
+                 hal_copy_to_uspace( status , &child_state , sizeof(int) );
+                 return child_pid;
             }
         }
         
         // release lock
-        remote_spinlock_unlock( lock_xp );
+        remote_spinlock_unlock( children_lock_xp );
 
-        // block the calling thread until a child process change state
-        thread_block( this , THREAD_BLOCKED_WAIT );
-        sched_yield( "wait child termination" );
+        // deschedule without blocking
+        sched_yield( "parent wait children termination" );
     }