Changeset 433 for trunk/kernel

Timestamp:

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

Author:

alain

Message:

blip

Location:

trunk/kernel

Files:

• devices/dev_txt.c (modified) (2 diffs)
• fs/devfs.c (modified) (22 diffs)
• fs/vfs.c (modified) (26 diffs)
• kern/chdev.c (modified) (6 diffs)
• kern/cluster.c (modified) (6 diffs)
• kern/cluster.h (modified) (2 diffs)
• kern/core.c (modified) (2 diffs)
• kern/process.c (modified) (51 diffs)
• kern/process.h (modified) (12 diffs)
• kern/rpc.c (modified) (11 diffs)
• kern/rpc.h (modified) (6 diffs)
• kern/scheduler.c (modified) (8 diffs)
• kern/scheduler.h (modified) (1 diff)
• kern/thread.c (modified) (17 diffs)
• libk/elf.c (modified) (7 diffs)
• libk/remote_rwlock.c (modified) (4 diffs)
• libk/remote_spinlock.c (modified) (6 diffs)
• libk/remote_spinlock.h (modified) (2 diffs)
• libk/rwlock.c (modified) (5 diffs)
• libk/spinlock.c (modified) (6 diffs)
• mm/kcm.c (modified) (4 diffs)
• mm/kmem.c (modified) (2 diffs)
• mm/page.c (modified) (1 diff)
• mm/page.h (modified) (2 diffs)
• mm/ppm.c (modified) (9 diffs)
• mm/ppm.h (modified) (2 diffs)
• mm/vmm.c (modified) (47 diffs)
• mm/vmm.h (modified) (10 diffs)
• syscalls/sys_display.c (modified) (9 diffs)
• syscalls/sys_exec.c (modified) (5 diffs)
• syscalls/sys_exit.c (modified) (2 diffs)
• syscalls/sys_fork.c (modified) (3 diffs)
• syscalls/sys_kill.c (modified) (5 diffs)
• syscalls/sys_read.c (modified) (2 diffs)
• syscalls/sys_thread_exit.c (modified) (1 diff)
• syscalls/sys_wait.c (modified) (2 diffs)
• syscalls/sys_write.c (modified) (6 diffs)
• syscalls/syscalls.h (modified) (8 diffs)

trunk/kernel/devices/dev_txt.c

@@ -117 +117 @@
     thread_t * this = CURRENT_THREAD;
 
-txt_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) enters / cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type), hal_time_stamp() );
+#if CONFIG_DEBUG_DEV_TXT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEV_TXT < cycle )
+printk("\n[DBG] %s : thread %x enters / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD , cycle );
+#endif
 
     // check channel argument
@@ -140 +144 @@
     chdev_register_command( dev_xp );
 
-txt_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) exit / cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type), hal_time_stamp() );
+#if CONFIG_DEBUG_DEV_TXT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEV_TXT < cycle )
+printk("\n[DBG] %s : thread %x exit / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD , cycle );
+#endif
 
     // return I/O operation status from calling thread descriptor

trunk/kernel/fs/devfs.c

@@ -28 +28 @@
 #include <printk.h>
 #include <chdev.h>
+#include <thread.h>
 #include <dev_txt.h>
 #include <cluster.h>
@@ -86 +87 @@
     error_t  error;
 
-    devfs_dmsg("\n[DBG] %s : enter in cluster %x\n",
-               __FUNCTION__ , local_cxy );
+#if CONFIG_DEBUG_DEVFS_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x enter at cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
 
     // creates DEVFS "dev" inode in cluster IO
@@ -100 +105 @@
     assert( (error == 0) , __FUNCTION__ , "cannot create <dev>\n" );
 
-    devfs_dmsg("\n[DBG] %s : <dev> created in cluster %x\n",
-               __FUNCTION__ , local_cxy );
-
     // create DEVFS "external" inode in cluster IO
     error = vfs_add_child_in_parent( LOCAL_CLUSTER->io_cxy,
@@ -114 +116 @@
     assert( (error == 0) , __FUNCTION__ , "cannot create <external>\n" );
 
-    devfs_dmsg("\n[DBG] %s : <external> created in cluster %x\n",
-               __FUNCTION__ , local_cxy );
+#if CONFIG_DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x exit at cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
+
 } 
 
@@ -129 +136 @@
     xptr_t        inode_xp;
     uint32_t      channel;
+
+#if CONFIG_DEBUG_DEVFS_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x enter at cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
 
     // create "internal" directory linked to "dev"
@@ -140 +154 @@
                              devfs_internal_inode_xp );
 
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , node_name , local_cxy );
-
     // create MMC chdev inode
     chdev_xp  = chdev_dir.mmc[local_cxy];
@@ -155 +166 @@
                                  GET_PTR( chdev_xp ),
                                  &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
     }
 
@@ -175 +182 @@
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
         }
     }
@@ -197 +200 @@
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
         }
     }
@@ -219 +218 @@
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
         }
     }
@@ -243 +238 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
             }
         }
@@ -268 +259 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
             }
         }
@@ -293 +280 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
             }
         }
@@ -318 +301 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
             }
         }
@@ -343 +322 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
             }
         }
@@ -368 +343 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
-
-devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
-__FUNCTION__ , chdev_ptr->name , local_cxy );
-
-            }
-        }
-    }
+            }
+        }
+    }
+
+#if CONFIG_DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x exit at cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
+
 }  // end devfs_local_init()
 
@@ -396 +375 @@
     char               k_buf[CONFIG_TXT_KBUF_SIZE];  // local kernel buffer
 
-devfs_dmsg("\n[DBG] %s enter / cycle %d\n", 
-__FUNCTION__ , hal_time_stamp() );
+#if CONFIG_DEBUG_DEVFS_MOVE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEVFS_MOVE < cycle )
+printk("\n[DBG] %s : thread %x enter / to_mem %d / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , to_buffer , cycle );
+#endif
 
 #if CONFIG_READ_DEBUG
@@ -426 +409 @@
                 if( error ) 
                 {
-
-devfs_dmsg("\n[DBG] %s exit error / cycle %d\n", 
-__FUNCTION__ , hal_time_stamp() );
-
                     return -1;
                 }
@@ -438 +417 @@
              }
 
+#if CONFIG_DEBUG_DEVFS_MOVE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEVFS_MOVE < cycle )
+printk("\n[DBG] %s : thread %x exit / to_mem %d / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , to_buffer / cycle );
+#endif
+
 #if CONFIG_READ_DEBUG
 exit_devfs_move = hal_time_stamp();
 #endif
-
-devfs_dmsg("\n[DBG] %s exit success / size = %d / cycle %d\n", 
-__FUNCTION__ , size , hal_time_stamp() );
-
             return size;
         } 
@@ -454 +436 @@
             if( error ) 
             {
-
-devfs_dmsg("\n[DBG] %s exit error / cycle %d\n", 
-__FUNCTION__ , hal_time_stamp() );
-
                 return -1;
             }
@@ -463 +441 @@
             {
 
-devfs_dmsg("\n[DBG] %s exit success / size = %d / cycle %d\n", 
-__FUNCTION__ , size , hal_time_stamp() );
+#if CONFIG_DEBUG_DEVFS_MOVE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_DEVFS_MOVE < cycle )
+printk("\n[DBG] %s : thread %x exit / to_mem %d / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , to_buffer / cycle );
+#endif
 
                 return size;
@@ -477 +459 @@
         return -1;
     }
+
 }  // end devfs_user_move()
 

trunk/kernel/fs/vfs.c

@@ -157 +157 @@
     error_t            error;
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enter / dentry = %x in cluster %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, GET_PTR(dentry_xp), GET_CXY(dentry_xp) );
+#if CONFIG_DEBUG_VFS_INODE_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_INODE_CREATE < cycle )
+printk("\n[DBG] %s : thread %x enter / dentry = %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, GET_PTR(dentry_xp), GET_CXY(dentry_xp), cycle );
+#endif
  
     // check fs type and get pointer on context
@@ -230 +234 @@
     remote_spinlock_init( XPTR( local_cxy , &inode->main_lock ) );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] exit / inode = %x in cluster %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, inode , local_cxy );
+#if CONFIG_DEBUG_VFS_INODE_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_INODE_CREATE < cycle )
+printk("\n[DBG] %s : thread %x exit / inode = %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, inode, local_cxy, cycle );
+#endif
  
     // return extended pointer on inode
@@ -263 +271 @@
                         xptr_t        child_xp )
 {
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / cycle %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , hal_time_stamp() );
+
+#if CONFIG_DEBUG_VFS_INODE_LOAD
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_INODE_LOAD < cycle )
+printk("\n[DBG] %s : thread %x enter for <%s> / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD , name , cycle );
+#endif
 
     error_t error = 0;
@@ -293 +306 @@
     }
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / cycle %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_INODE_LOAD
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_INODE_LOAD < cycle )
+printk("\n[DBG] %s : thread %x exit for <%s> / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD , name , cycle );
+#endif
 
     return error;
@@ -416 +433 @@
         kmem_req_t       req;        // request to kernel memory allocator
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / parent inode = %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, name, parent, hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_DENTRY_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_DENTRY_CREATE < cycle )
+printk("\n[DBG] %s : thread %x enter for <%s> / parent_inode %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD , name , parent , cycle );
+#endif
 
     // get pointer on context
@@ -465 +486 @@
     *dentry_xp = XPTR( local_cxy , dentry );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / dentry = %x in cluster %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, name, dentry, local_cxy , hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_DENTRY_CREATE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_DENTRY_CREATE < cycle )
+printk("\n[DBG] %s : thread %x exit for <%s> / dentry %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD , name , dentry , cycle );
+#endif
 
     return 0;
@@ -584 +609 @@
     uint32_t      file_id;      // created file descriptor index in reference fd_array
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path, (uint32_t)hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_OPEN
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_OPEN < cycle )
+printk("\n[DBG] %s :  thread %x enter for <%s> / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, path, cycle );
+#endif
 
     // compute lookup working mode
@@ -610 +639 @@
     inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
     
-vfs_dmsg("\n[DBG] %s : core[%x,%d] found inode for <%s> in cluster %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path, inode_cxy , (uint32_t)hal_time_stamp() );
-
     // create a new file descriptor in cluster containing inode
     if( inode_cxy == local_cxy )      // target cluster is local
@@ -630 +656 @@
     if( error ) return error;
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / file = %x in cluster %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path,
-GET_PTR(file_xp), GET_CXY(file_xp), hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_OPEN
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_OPEN < cycle )
+printk("\n[DBG] %s : thread %x exit for <%s> / file %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, path, GET_PTR(file_xp), GET_CXY(file_xp), cycle );
+#endif
 
     // success
@@ -647 +676 @@
                    uint32_t size )
 {
-    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , 
-    "file_xp == XPTR_NULL" );
+    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" );
 
     cxy_t              file_cxy;     // remote file descriptor cluster 
@@ -1319 +1347 @@
     process = this->process;
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / cycle %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , pathname , hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_LOOKUP
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_LOOKUP < cycle )
+printk("\n[DBG] %s : thread %x enter for <%s> / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, path, cycle );
+#endif
 
     // get extended pointer on first inode to search
@@ -1343 +1375 @@
         vfs_get_name_from_path( current , name , &next , &last );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] look for <%s> / last = %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , name , last );
+#if (CONFIG_DEBUG_VFS_LOOKUP & 1)
+if( CONFIG_DEBUG_VFS_LOOKUP < cycle )
+printk("\n[DBG] %s : look for <%s> / last = %d\n", __FUNCTION__ , name , last );
+#endif
 
         // search a child dentry matching name in parent inode
@@ -1362 +1396 @@
         {
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] miss <%s> => load it\n",
-__FUNCTION__ , local_cxy , this->core->lid , name );
+#if (CONFIG_DEBUG_VFS_LOOKUP & 1)
+if( CONFIG_DEBUG_VFS_LOOKUP < cycle )
+printk("\n[DBG] %s : miss <%s> => load it\n", __FUNCTION__ , name );
+#endif
 
             // release lock on parent inode
@@ -1446 +1482 @@
             vfs_inode_lock( parent_xp );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] created node <%s>\n",
-__FUNCTION__ , local_cxy , this->core->lid , name );
+#if (CONFIG_DEBUG_VFS_LOOKUP & 1)
+if( CONFIG_DEBUG_VFS_LOOKUP < cycle )
+printk("\n[DBG] %s : created node <%s>\n", __FUNCTION__ , name );
+#endif
 
         }
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] found <%s> / inode = %x in cluster %x\n",
-__FUNCTION__ , local_cxy , this->core->lid , name , GET_PTR(child_xp) , GET_CXY(child_xp) );
+#if (CONFIG_DEBUG_VFS_LOOKUP & 1)
+if( CONFIG_DEBUG_VFS_LOOKUP < cycle )
+printk("\n[DBG] %s : found <%s> / inode %x in cluster %x\n",
+__FUNCTION__ , name , GET_PTR(child_xp) , GET_CXY(child_xp) );
+#endif
 
         // TODO check access rights here [AG]
@@ -1477 +1518 @@
     vfs_inode_unlock( parent_xp );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / inode = %x in cluster %x\n",
-__FUNCTION__,local_cxy,this->core->lid,pathname,GET_PTR(child_xp),GET_CXY(child_xp) );
+#if CONFIG_DEBUG_VFS_LOOKUP
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_LOOKUP < cycle )
+printk("\n[DBG] %s : thread %x exit for <%s> / inode %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, path, GET_PTR(child_xp), GET_CXY(child_xp), cycle );
+#endif
 
     // return searched pointer
@@ -1502 +1547 @@
     // we use two variables "index" and "count" because the buffer
     // is written in decreasing index order (from leaf to root) 
-    // TODO : handle conflict with a concurrent rename [AG]
-    // TODO : handle synchro in the loop  [AG]
+    // TODO  : handle conflict with a concurrent rename [AG]
+    // FIXME : handle synchro in the loop  [AG]
 
         // set the NUL character in buffer / initialise buffer index and count
@@ -1576 +1621 @@
     parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / child_cxy = %x / parent_cxy = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , child_cxy , parent_cxy );
+#if CONFIG_DEBUG_VFS_ADD_CHILD
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : thread %x enter for <%s> / child_cxy = %x / parent_cxy = %x\n",
+__FUNCTION__ , CURRENT_THREAD , name , child_cxy , parent_cxy );
+#endif
 
     // 1. create dentry
@@ -1587 +1636 @@
                                    &dentry_xp );
 
-vfs_dmsg("\n[DBG] %s : dentry <%s> created in local cluster %x\n",
-__FUNCTION__ , name , local_cxy );
+#if (CONFIG_DEBUG_VFS_ADD_CHILD & 1)
+if( CONFIG_DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : dentry <%s> created in cluster %x\n", __FUNCTION__, name, local_cxy );
+#endif
 
     }
@@ -1600 +1651 @@
                                       &error );
 
-vfs_dmsg("\n[DBG] %s : dentry <%s> created in remote cluster %x\n",
-__FUNCTION__ , name , parent_cxy );
+#if (CONFIG_DEBUG_VFS_ADD_CHILD & 1)
+if( CONFIG_DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : dentry <%s> created in cluster %x\n", __FUNCTION__, name, parent_cxy );
+#endif
 
     }
@@ -1629 +1682 @@
                                   gid,
                                   &inode_xp );
+
+#if (CONFIG_DEBUG_VFS_ADD_CHILD & 1)
+if( CONFIG_DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : inode <%x> created in cluster %x\n",
+__FUNCTION__ , GET_PTR(inode_xp) , local_cxy );
+#endif
 
 vfs_dmsg("\n[DBG] %s : inode %x created in local cluster %x\n",
@@ -1648 +1707 @@
                                      &error );
 
-vfs_dmsg("\n[DBG] %s : inode %x created in remote cluster %x\n",
+#if (CONFIG_DEBUG_VFS_ADD_CHILD & 1)
+if( CONFIG_DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : inode <%s> created in cluster %x\n",
 __FUNCTION__ , GET_PTR(inode_xp) , child_cxy );
+#endif
 
     }
@@ -1669 +1731 @@
     hal_remote_swd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) , inode_xp );
 
-vfs_dmsg("\n[DBG] %s : exit in cluster %x for <%s>\n",
-__FUNCTION__ , local_cxy , name );
+#if CONFIG_DEBUG_VFS_ADD_CHILD
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : thread %x exit for <%s>\n",
+__FUNCTION__ , CURRENT_THREAD , name );
+#endif
 
     // success : return extended pointer on child inode
@@ -1694 +1760 @@
     assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enters for page %d / mapper = %x / inode = %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid , page->index , mapper, mapper->inode );
+#if CONFIG_DEBUG_VFS_MAPPER_MOVE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_MAPPER_MOVE < cycle )
+printk("\n[DBG] %s : thread %x enter for page %d / mapper %x / inode %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, page->index, mapper, mapper->inode, cycle );
+#endif
 
     // get FS type
@@ -1720 +1790 @@
     }
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for page %d / mapper = %x / inode = %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, page->index, mapper, mapper->inode );
+#if CONFIG_DEBUG_VFS_MAPPER_MOVE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_MAPPER_MOVE < cycle )
+printk("\n[DBG] %s : thread %x exit for page %d / mapper %x / inode %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, page->index, mapper, mapper->inode, cycle );
+#endif
 
     return error;
@@ -1740 +1814 @@
     assert( (mapper != NULL) , __FUNCTION__ , "mapper pointer is NULL\n" );
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for inode %x in cluster %x/ cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, inode , local_cxy , hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_MAPPER_LOAD
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_MAPPER_MOVE < cycle )
+printk("\n[DBG] %s : thread %x enter for inode %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, inode, local_cxy, cycle );
+#endif
 
     // compute number of pages
@@ -1757 +1835 @@
     }
 
-vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for inode %x in cluster %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, inode , local_cxy , hal_time_stamp() );
+#if CONFIG_DEBUG_VFS_MAPPER_LOAD
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VFS_MAPPER_MOVE < cycle )
+printk("\n[DBG] %s : thread %x exit for inode %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, inode, local_cxy, cycle );
+#endif
 
     return 0;

trunk/kernel/kern/chdev.c

@@ -129 +129 @@
     thread_t * this = CURRENT_THREAD;
 
-chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) enter / cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type) , hal_time_stamp() );
+#if CONFIG_DEBUG_CHDEV_REGISTER_COMMAND
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CHDEV_REGISTER_COMMAND < cycle )
+printk("\n[DBG] %s : client_thread %x (%s) enter / cycle %d\n",
+__FUNCTION__, this, thread_type_str(this->type) , cycle );
+#endif
 
     // get device descriptor cluster and local pointer
@@ -142 +146 @@
     // get local pointer on server thread
     server_ptr = (thread_t *)hal_remote_lpt( XPTR( chdev_cxy , &chdev_ptr->server) );
-
-chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) / server_cxy %x / server_ptr %x / server_type %\n",
-__FUNCTION__, local_cxy, this->core->lid, server_cxy, server_ptr,
-thread_type_str( hal_remote_lw( XPTR( server_cxy , &server_ptr->type) ) ) );
 
     // build extended pointer on chdev lock protecting queue
@@ -178 +178 @@
     if( different ) dev_pic_send_ipi( chdev_cxy , lid ); 
     
-chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) deschedules / cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type) , hal_time_stamp() );
+#if CONFIG_DEBUG_CHDEV_REGISTER_COMMAND
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CHDEV_REGISTER_COMMAND < cycle )
+printk("\n[DBG] %s : client_thread %x (%s) exit / cycle %d\n",
+__FUNCTION__, this, thread_type_str(this->type) , cycle );
+#endif
 
     // deschedule
@@ -185 +189 @@
     sched_yield("blocked on I/O");
 
-chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) resumes / cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type) , hal_time_stamp() );
-
     // exit critical section
     hal_restore_irq( save_sr );
+
+#if CONFIG_DEBUG_CHDEV_REGISTER_COMMAND
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CHDEV_REGISTER_COMMAND < cycle )
+printk("\n[DBG] %s : client_thread %x (%s) resumes / cycle %d\n",
+__FUNCTION__, this, thread_type_str(this->type) , cycle );
+#endif
 
 #if CONFIG_READ_DEBUG
@@ -209 +217 @@
     server = CURRENT_THREAD;
 
-chdev_dmsg("\n[DBG] %s : enter / server = %x / chdev = %x / cycle %d\n",
-__FUNCTION__ , server , chdev , hal_time_stamp() );
+#if CONFIG_DEBUG_CHDEV_SEQUENCIAL_SERVER
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CHDEV_SEQUENCIAL_SERVER < cycle )
+printk("\n[DBG] %s : server_thread %x enter / chdev = %x / cycle %d\n",
+__FUNCTION__ , server , chdev , cycle );
+#endif
 
     root_xp = XPTR( local_cxy , &chdev->wait_root );
@@ -265 +277 @@
             thread_unblock( client_xp , THREAD_BLOCKED_IO );
 
-chdev_dmsg("\n[DBG] %s : thread %x complete operation for client %x / cycle %d\n",
-__FUNCTION__ , server , client_ptr , hal_time_stamp() );
+#if CONFIG_DEBUG_CHDEV_SEQUENCIAL_SERVER
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CHDEV_SEQUENCIAL_SERVER < cycle )
+printk("\n[DBG] %s : server_thread %x complete operation for client %x / cycle %d\n",
+__FUNCTION__ , server , client_ptr , cycle );
+#endif
 
 #if CONFIG_READ_DEBUG

trunk/kernel/kern/cluster.c

@@ -89 +89 @@
         spinlock_init( &cluster->kcm_lock );
 
-cluster_dmsg("\n[DBG] %s for cluster %x enters\n",
-__FUNCTION__ , local_cxy );
+#if CONFIG_DEBUG_CLUSTER_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CLUSTER_INIT < cycle )
+printk("\n[DBG] %s enters for cluster %x / cycle %d\n",
+__FUNCTION__ , local_cxy , cycle );
+#endif
 
     // initialises DQDT
@@ -109 +113 @@
     }
 
-cluster_dmsg("\n[DBG] %s : PPM initialized in cluster %x at cycle %d\n",
-__FUNCTION__ , local_cxy , hal_get_cycles() );
+#if CONFIG_DEBUG_CLUSTER_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CLUSTER_INIT < cycle )
+cluster_dmsg("\n[DBG] %s : PPM initialized in cluster %x / cycle %d\n",
+__FUNCTION__ , local_cxy , cycle );
+#endif
 
     // initialises embedded KHM
@@ -132 +140 @@
         }
 
-cluster_dmsg("\n[DBG] %s : cores initialized in cluster %x at cycle %d\n",
-__FUNCTION__ , local_cxy , hal_get_cycles() );
+#if CONFIG_DEBUG_CLUSTER_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CLUSTER_INIT < cycle )
+cluster_dmsg("\n[DBG] %s : cores initialized in cluster %x / cycle %d\n",
+__FUNCTION__ , local_cxy , cycle );
+#endif
 
     // initialises RPC fifo
@@ -164 +176 @@
     }
 
-cluster_dmsg("\n[DBG] %s Process Manager initialized in cluster %x at cycle %d\n",
-__FUNCTION__ , local_cxy , hal_get_cycles() );
+#if CONFIG_DEBUG_CLUSTER_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_CLUSTER_INIT < cycle )
+cluster_dmsg("\n[DBG] %s Process Manager initialized in cluster %x / cycle %d\n",
+__FUNCTION__ , local_cxy , cycle );
+#endif
 
     hal_fence();
@@ -215 +231 @@
 //  Process related functions
 ////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////
+xptr_t cluster_get_owner_process_from_pid( pid_t pid )
+{
+    xptr_t      root_xp;       // xptr on root of list of processes in owner cluster
+    xptr_t      lock_xp;       // xptrr on lock protecting this list
+    xptr_t      iter_xp;       // iterator
+    xptr_t      current_xp;    // xptr on current process descriptor
+    process_t * current_ptr;   // local pointer on current process
+    pid_t       current_pid;   // current process identifier
+    bool_t      found;
+
+    cluster_t * cluster = LOCAL_CLUSTER;
+
+    // get owner cluster and lpid
+    cxy_t  owner_cxy = CXY_FROM_PID( pid );
+
+    // get lock & root of list of process in owner cluster
+    root_xp = XPTR( owner_cxy , &cluster->pmgr.local_root );
+    lock_xp = XPTR( owner_cxy , &cluster->pmgr.local_lock );
+
+    // take the lock protecting the list of processes
+    remote_spinlock_lock( lock_xp );
+
+    // scan list of processes in owner cluster
+    found = false;
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        current_xp  = XLIST_ELEMENT( iter_xp , process_t , local_list );
+        current_ptr = GET_PTR( current_xp );
+        current_pid = hal_remote_lw( XPTR( owner_cxy , &current_ptr->pid ) );
+
+        if( current_pid == pid )
+        {
+            found = true;
+            break;
+        }
+    }
+
+    // release the lock protecting the list of processes
+    remote_spinlock_unlock( lock_xp );
+
+    // return extended pointer on process descriptor in owner cluster
+    if( found ) return current_xp;
+    else        return XPTR_NULL;
+}
 
 //////////////////////////////////////////////////////////
@@ -442 +505 @@
 
     // skip one line
-    printk("\n");
+    printk("\n***** processes in cluster %x / cycle %d\n", cxy , (uint32_t)hal_get_cycles() );
 
     // loop on all reference processes in cluster cxy 

trunk/kernel/kern/cluster.h

@@ -189 +189 @@
 
 /******************************************************************************************
+ * This function returns an extended pointer on the process descriptor in owner cluster
+ * from the process PID. This PID can be be different from the calling process PID.
+ * It can be called by any thread running in any cluster,
+ ******************************************************************************************
+ * @ pid  : process identifier.
+ * @ return extended pointer on owner process if found / XPTR_NULL if not found.
+ *****************************************************************************************/
+xptr_t cluster_get_owner_process_from_pid( pid_t pid );
+
+/******************************************************************************************
  * This function returns an extended pointer on the reference process descriptor
  * from the process PID. This PID can be be different from the calling process PID.
@@ -194 +204 @@
  ******************************************************************************************
  * @ pid  : process identifier.
- * @ return extended pointer on reference process if success / return XPTR_NULL if error.
+ * @ return extended pointer on reference process if found / XPTR_NULL if not found.
  *****************************************************************************************/
 xptr_t cluster_get_reference_process_from_pid( pid_t pid );

trunk/kernel/kern/core.c

@@ -75 +75 @@
 }
 
-/* deprecated 14/08/2017 [AG]
-//////////////////////////////////////
-void core_time_update( core_t * core )
-{
-        uint32_t elapsed;
-        uint32_t ticks_nr   = core->ticks_nr;
-        uint64_t cycles     = core->cycles;
-        uint32_t time_stamp = core->time_stamp;
-        uint32_t time_now   = hal_get_cycles();
-
-        // compute number of elapsed cycles taking into account 32 bits register wrap
-        if( time_now < time_stamp ) elapsed = (0xFFFFFFFF - time_stamp) + time_now;
-        else                        elapsed = time_now - time_stamp;
-
-        cycles  += elapsed;
-        ticks_nr = elapsed / core->ticks_period;
-
-        core->time_stamp     = time_now;
-        core->cycles         = cycles + elapsed;
-        core->ticks_nr       = ticks_nr + (elapsed / core->ticks_period);
-        hal_fence();
-}
-*/
-
 ////////////////////////////////
 void core_clock( core_t * core )
@@ -136 +112 @@
         hal_fence();
 
-#if CONFIG_SHOW_CPU_USAGE
-        printk(INFO, "INFO: core %d in cluster %x : busy_percent = %d / cumulated_usage = %d\n",
-               core->lid, local_cxy , busy_percent , usage );
-#endif
-
         core->ticks_nr = 0;
         idle->ticks_nr = 0;

trunk/kernel/kern/process.c

@@ -4 +4 @@
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Mohamed Lamine Karaoui (2015)
- *          Alain Greiner (2016,2017)
+ *          Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -124 +124 @@
     model_pid  = hal_remote_lw( XPTR( model_cxy  , &model_ptr->pid ) );
 
-process_dmsg("\n[DBG] %s : core[%x,%d] enters / pid = %x / ppid = %x / model_pid = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid , parent_pid , model_pid );
+#if CONFIG_DEBUG_PROCESS_REFERENCE_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_REFERENCE_INIT )
+printk("\n[DBG] %s : thread %x enter / pid = %x / ppid = %x / model_pid = %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , pid , parent_pid , model_pid , cycle );
+#endif
 
     // initialize PID, REF_XP, PARENT_XP, and STATE
-        process->pid       = pid;
-    process->ref_xp    = XPTR( local_cxy , process );
-    process->parent_xp = parent_xp;
-    process->state     = PROCESS_STATE_RUNNING;
+        process->pid        = pid;
+    process->ref_xp     = XPTR( local_cxy , process );
+    process->parent_xp  = parent_xp;
+    process->term_state = 0;
 
     // initialize vmm as empty 
@@ -137 +141 @@
     assert( (error == 0) , __FUNCTION__ , "cannot initialize VMM\n" );
  
-process_dmsg("\n[DBG] %s : core[%x,%d] / vmm inialised as empty for process %x\n", 
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+#if (CONFIG_DEBUG_PROCESS_REFERENCE_INIT & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_REFERENCE_INIT )
+printk("\n[DBG] %s : thread %x / vmm empty for process %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+#endif
 
     // initialize fd_array as empty
@@ -224 +232 @@
     remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
 
-process_dmsg("\n[DBG] %s : core[%x,%d] / fd array initialised for process %x\n", 
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+#if (CONFIG_DEBUG_PROCESS_REFERENCE_INIT & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_REFERENCE_INIT )
+printk("\n[DBG] %s : thread %x / fd_array for process %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+#endif
 
     // reset children list root 
@@ -260 +272 @@
         hal_fence();
 
-process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+#if (CONFIG_DEBUG_PROCESS_REFERENCE_INIT & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_REFERENCE_INIT )
+printk("\n[DBG] %s : thread %x exit / process %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+#endif
 
 }  // process_reference_init()
@@ -276 +292 @@
 
     // initialize PID, REF_XP, PARENT_XP, and STATE
-    local_process->pid       = hal_remote_lw(  XPTR( ref_cxy , &ref_ptr->pid ) );
-    local_process->parent_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->parent_xp ) );
-    local_process->ref_xp    = reference_process_xp;
-    local_process->state     = PROCESS_STATE_RUNNING;
-
-process_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , local_process->pid );
+    local_process->pid        = hal_remote_lw(  XPTR( ref_cxy , &ref_ptr->pid ) );
+    local_process->parent_xp  = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->parent_xp ) );
+    local_process->ref_xp     = reference_process_xp;
+    local_process->term_state = 0;
+
+#if CONFIG_DEBUG_PROCESS_COPY_INIT 
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_COPY_INIT )
+printk("\n[DBG] %s : thread %x enter for process %x\n",
+__FUNCTION__ , CURRENT_THREAD , local_process->pid );
+#endif
 
     // reset local process vmm
@@ -327 +347 @@
         hal_fence();
 
-process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , local_process->pid );
+#if CONFIG_DEBUG_PROCESS_COPY_INIT 
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_COPY_INIT )
+printk("\n[DBG] %s : thread %x exit for process %x\n",
+__FUNCTION__ , CURRENT_THREAD , local_process->pid );
+#endif
 
     return 0;
@@ -347 +371 @@
     "process %x in cluster %x has still active threads", process->pid , local_cxy );
 
-process_dmsg("\n[DBG] %s : core[%x,%d] enter for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_PROCESS_DESTROY
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_DESTROY )
+printk("\n[DBG] %s : thread %x enter to destroy process %x (pid = %x) / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process, process->pid , cycle );
+#endif
 
     // get local process manager pointer
@@ -386 +414 @@
         xlist_unlink( XPTR( local_cxy , &process->children_list ) );
         remote_spinlock_unlock( children_lock_xp );
-
-        // get extende pointer on parent main thread
-        parent_thread_xp = XPTR( parent_cxy ,
-                           hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[1] )));
-        
-        // unblock parent process main thread
-        thread_unblock( parent_thread_xp , THREAD_BLOCKED_WAIT );
     }
 
@@ -411 +432 @@
     process_free( process );
 
-process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_PROCESS_DESTROY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_DESTROY )
+printk("\n[DBG] %s : thread %x exit / destroyed process %x (pid = %x) / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process, process->pid, cycle );
+#endif
 
 }  // end process_destroy()
@@ -440 +465 @@
     uint32_t           responses;         // number of remote process copies
     uint32_t           rsp_count;         // used to assert number of copies
-
     rpc_desc_t         rpc;               // rpc descriptor allocated in stack
 
-process_dmsg("\n[DBG] %s : enter to %s process %x in cluster %x\n",
-__FUNCTION__ , process_action_str( action_type ) , process->pid , local_cxy );
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x enter to %s process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, process_action_str( action_type ) ,
+process->pid , local_cxy , cycle );
+#endif
 
     thread_t         * client = CURRENT_THREAD;
-    xptr_t             client_xp = XPTR( local_cxy , client );
 
     // get local pointer on local cluster manager
@@ -492 +520 @@
         {
 
-process_dmsg("\n[DBG] %s : send RPC to remote cluster %x\n",
-__FUNCTION__ , process_cxy );
+#if CONFIG_DEBUG_PROCESS_SIGACTION 
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : send RPC to remote cluster %x\n", __FUNCTION__ , process_cxy );
+#endif
 
             rpc.args[0] = (uint64_t)action_type;
@@ -517 +547 @@
     }
 
-process_dmsg("\n[DBG] %s : make action in owner cluster %x\n",
-__FUNCTION__ , local_cxy );
-
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : make action in owner cluster %x\n", __FUNCTION__ , local_cxy );
+#endif
 
     // call directly the relevant function in local owner cluster
-    if      (action_type == DELETE_ALL_THREADS  ) process_delete_threads ( process , client_xp ); 
-    else if (action_type == BLOCK_ALL_THREADS   ) process_block_threads  ( process , client_xp ); 
-    else if (action_type == UNBLOCK_ALL_THREADS ) process_unblock_threads( process             );
-
-process_dmsg("\n[DBG] %s : exit after %s process %x in cluster %x\n",
-__FUNCTION__ , process_action_str( action_type ) , process->pid , local_cxy );
+    if      (action_type == DELETE_ALL_THREADS  ) process_delete_threads ( process ); 
+    else if (action_type == BLOCK_ALL_THREADS   ) process_block_threads  ( process ); 
+    else if (action_type == UNBLOCK_ALL_THREADS ) process_unblock_threads( process );
+
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x exit after %s process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, process_action_str( action_type ) ,
+process->pid , local_cxy , cycle );
+#endif
 
 }  // end process_sigaction()
 
-////////////////////////////////////////////////
-void process_block_threads( process_t * process,
-                            xptr_t      client_xp )
+/////////////////////////////////////////////////
+void process_block_threads( process_t * process )
 {
     thread_t          * target;         // pointer on target thread 
+    thread_t          * this;           // pointer on calling thread 
     uint32_t            ltid;           // index in process th_tbl
-    thread_t          * requester;      // requesting thread pointer
     uint32_t            count;          // requests counter
     volatile uint32_t   rsp_count;      // responses counter
 
     // get calling thread pointer
-    requester = CURRENT_THREAD;
-
-sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
-__FUNCTION__ , process->pid , local_cxy );
+    this = CURRENT_THREAD;
+
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , this , process->pid , local_cxy , cycle );
+#endif
 
     // get lock protecting process th_tbl[]
@@ -559 +598 @@
         target = process->th_tbl[ltid];
 
+        assert( (target != this) , __FUNCTION__ , "calling thread cannot be a target\n" );
+
         if( target != NULL )             // thread found
         {
             count++;
 
-            // - if the target thread is the client thread, we do nothing,
-            //   and we simply decrement the responses counter.
             // - if the calling thread and the target thread are on the same core,
             //   we block the target thread, we don't need confirmation from scheduler,
@@ -572 +611 @@
             //   to be sure that the target thread is not running.
             
-            if( XPTR( local_cxy , target ) == client_xp )
-            {
-                // decrement responses counter
-                hal_atomic_add( (void *)&rsp_count , -1 );
-            }
-            else if( requester->core->lid == target->core->lid )
+            if( this->core->lid == target->core->lid )
             {
                 // set the global blocked bit in target thread descriptor.
@@ -612 +646 @@
     }
 
-sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
-__FUNCTION__ , process->pid , local_cxy , count );
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , this , process->pid , local_cxy , cycle );
+#endif
 
 }  // end process_block_threads()
@@ -621 +659 @@
 {
     thread_t          * target;        // pointer on target thead 
+    thread_t          * this;          // pointer on calling thread 
     uint32_t            ltid;          // index in process th_tbl
     uint32_t            count;         // requests counter
 
-sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
-__FUNCTION__ , process->pid , local_cxy );
+    // get calling thread pointer
+    this = CURRENT_THREAD;
+
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , this , process->pid , local_cxy , cycle );
+#endif
 
     // get lock protecting process th_tbl[]
@@ -636 +682 @@
         target = process->th_tbl[ltid];
 
+        assert( (target != this) , __FUNCTION__ , "calling thread cannot be a target\n" );
+
         if( target != NULL )             // thread found
         {
@@ -648 +696 @@
     spinlock_unlock( &process->th_lock );
 
-sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
-__FUNCTION__ , process->pid , local_cxy , count );
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , this , process->pid , local_cxy , cycle );
+#endif
 
 }  // end process_unblock_threads()
 
-/////////////////////////////////////////////////
-void process_delete_threads( process_t * process,
-                             xptr_t      client_xp )
+//////////////////////////////////////////////////
+void process_delete_threads( process_t * process )
 {
     thread_t          * target;        // pointer on target thread 
+    thread_t          * this;          // pointer on calling thread 
     uint32_t            ltid;          // index in process th_tbl
     uint32_t            count;         // request counter
-
-sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x at cycle %d\n",
-__FUNCTION__ , process->pid , local_cxy , (uint32_t)hal_get_cycles() );
+    cxy_t               owner_cxy;     // owner cluster identifier
+
+    // get calling thread pointer
+    this = CURRENT_THREAD;
+    owner_cxy = CXY_FROM_PID( process->pid );
+
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , this , process->pid , local_cxy , cycle );
+#endif
 
     // get lock protecting process th_tbl[]
@@ -673 +734 @@
         target = process->th_tbl[ltid];
 
-        if( target != NULL )             // thread found
+        assert( (target != this) , __FUNCTION__ , "calling thread cannot be a target\n" );
+
+        if( target != NULL )            // thread found
         {
             count++;
-
-            // delete only if the target is not the client
-            if( XPTR( local_cxy , target ) != client_xp ) 
-            { 
+            
+            // the main thread should not be deleted
+            if( (owner_cxy != local_cxy) || (ltid != 0) )   
+            {
                 hal_atomic_or( &target->flags , THREAD_FLAG_REQ_DELETE );
             }
@@ -688 +751 @@
     spinlock_unlock( &process->th_lock );
 
-sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x at cycle %d\n",
-__FUNCTION__ , process->pid , local_cxy , (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_SIGACTION
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , this , process->pid , local_cxy , cycle );
+#endif
 
 }  // end process_delete_threads()
@@ -988 +1055 @@
     "parent process must be the reference process\n" );
 
-fork_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid , (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_MAKE_FORK
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, parent_pid, cycle );
+#endif
 
     // allocate a process descriptor
@@ -999 +1070 @@
         return -1;
     }
-
-fork_dmsg("\n[DBG] %s : core[%x,%d] created child process %x at cycle %d\n",
- __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process, (uint32_t)hal_get_cycles() );
 
     // allocate a child PID from local cluster
@@ -1012 +1080 @@
         return -1;
     }
-
-fork_dmsg("\n[DBG] %s : core[%x, %d] child process PID = %x at cycle %d\n",
- __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, new_pid , (uint32_t)hal_get_cycles() );
 
     // initializes child process descriptor from parent process descriptor 
@@ -1022 +1087 @@
                             parent_process_xp );
 
-fork_dmsg("\n[DBG] %s : core[%x, %d] child process initialised at cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_MAKE_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x created child_process %x / child_pid %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process, new_pid, cycle );
+#endif
 
     // copy VMM from parent descriptor to child descriptor
@@ -1037 +1106 @@
     }
 
-fork_dmsg("\n[DBG] %s : core[%x, %d] child process VMM copied at cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_MAKE_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x copied VMM from parent %x to child %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , parent_pid, new_pid, cycle );
+#endif
 
     // update extended pointer on .elf file
@@ -1059 +1132 @@
     assert( (thread->trdid == 0) , __FUNCTION__ , "main thread must have index 0\n" );
 
-fork_dmsg("\n[DBG] %s : core[%x,%d] child thread created at cycle %d\n", 
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
-
-    // update parent process GPT to set Copy_On_Write for shared data vsegs 
+#if CONFIG_DEBUG_PROCESS_MAKE_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x created child thread %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD, thread, cycle );
+#endif
+
+    // set Copy_On_Write flag in parent process GPT 
     // this includes all replicated GPT copies
     if( parent_process_cxy == local_cxy )   // reference is local
@@ -1074 +1151 @@
     }
 
-fork_dmsg("\n[DBG] %s : core[%x,%d] COW set in parent_process at cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
+    // set Copy_On_Write flag in child process GPT 
+    vmm_set_cow( process );
+ 
+#if CONFIG_DEBUG_PROCESS_MAKE_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x set COW in parent and child / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, cycle );
+#endif
 
     // get extended pointers on parent children_root, children_lock and children_nr
@@ -1092 +1176 @@
     *child_pid    = new_pid;
 
-
-fork_dmsg("\n[DBG] %s : core[%x,%d] exit at cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_MAKE_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x exit / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, cycle );
+#endif
 
     return 0;
@@ -1105 +1192 @@
 {
     char           * path;                    // pathname to .elf file
-    pid_t            pid;                     // old_process PID given to new_process
-    pid_t            temp_pid;                // temporary PID given to old_process 
+    pid_t            pid;                     // old_process PID / given to new_process
+    pid_t            temp_pid;                // temporary PID / given to old_process 
     process_t      * old_process;             // local pointer on old process
+    thread_t       * old_thread;              // local pointer on old thread
     process_t      * new_process;             // local pointer on new process
-    thread_t       * new_thread;              // local pointer on main thread
-    pthread_attr_t   attr;                    // main thread attributes
+    thread_t       * new_thread;              // local pointer on new thread
+    xptr_t           parent_xp;               // extended pointer on parent process
+    pthread_attr_t   attr;                    // new thread attributes
     lid_t            lid;                     // selected core local index
         error_t          error;
 
-        // get .elf pathname and PID from exec_info
+    // get old_thread / old_process / PID / parent_xp
+    old_thread  = CURRENT_THREAD;
+    old_process = old_thread->process;
+    pid         = old_process->pid;
+    parent_xp   = old_process->parent_xp;
+    
+        // get .elf pathname from exec_info
         path     = exec_info->path;
-    pid      = exec_info->pid;
 
     // this function must be executed by a thread running in owner cluster
     assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
-    "local cluster %x is not owner for process %x\n", local_cxy, pid );
-
-exec_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / %s / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path, (uint32_t)hal_get_cycles() );
-
-    // get old_process local pointer
-    old_process = (process_t *)cluster_get_local_process_from_pid( pid );
-    
-    if( old_process == NULL )
-    {
-        printk("\n[ERROR] in %s : cannot get old process descriptor\n", __FUNCTION__ );
-        return -1;
-    }
+    "local_cluster must be owner_cluster\n" );
+
+    assert( (LTID_FROM_TRDID( old_thread->trdid ) == 0) , __FUNCTION__,
+    "must be called by the main thread\n" );
+ 
+#if CONFIG_DEBUG_PROCESS_MAKE_EXEC
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x enters for process %x / %s / cycle %d\n",
+__FUNCTION__, old_thread, pid, path, cycle );
+#endif
 
      // allocate memory for new_process descriptor
@@ -1144 +1236 @@
     }
 
-    // get a new PID for old_process
+    // get a temporary PID for old_process
     error = cluster_pid_alloc( old_process , &temp_pid );
     if( error ) 
@@ -1154 +1246 @@
     }
 
-    // request blocking for all threads in old_process (but the calling thread)
-    process_sigaction( old_process , BLOCK_ALL_THREADS );
-
-    // request destruction for all threads in old_process (but the calling thread)
-    process_sigaction( old_process , DELETE_ALL_THREADS );
-
-exec_dmsg("\n[DBG] %s : core[%x,%d] marked old threads for destruction / cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid , (uint32_t)hal_get_cycles() );
-
-    // set new PID to old_process 
+    // set temporary PID to old_process 
     old_process->pid = temp_pid;
 
@@ -1169 +1252 @@
     process_reference_init( new_process,
                             pid,
-                            old_process->parent_xp,             // parent_process_xp
-                            XPTR(local_cxy , old_process) );    // model_process_xp
+                            parent_xp,                          // parent_process_xp
+                            XPTR(local_cxy , old_process) );    // model_process
 
     // give TXT ownership to new_process
     process_txt_set_ownership( XPTR( local_cxy , new_process ) );
 
-exec_dmsg("\n[DBG] %s : core[%x,%d] initialised new process %x / cycle %d \n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, new_process, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_MAKE_EXEC
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x created new process %x / cycle %d \n",
+__FUNCTION__ , old_thread , new_process , cycle );
+#endif
 
     // register code & data vsegs as well as entry-point in new process VMM,
@@ -1188 +1275 @@
         }
 
-exec_dmsg("\n[DBG] %s : core[%x,%d] vsegs registered in new process %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, new_process, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_MAKE_EXEC
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x registered code/data vsegs in new process %x / cycle %d\n",
+__FUNCTION__, old_thread , new_process->pid , cycle );
+#endif
 
     // select a core in local cluster to execute the main thread
@@ -1216 +1307 @@
     assert( (new_thread->trdid == 0) , __FUNCTION__ , "main thread must have index 0\n" );
 
-exec_dmsg("\n[DBG] %s : core[%x,%d] created new_process main thread / cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
-
-    // get pointers on parent process
-    xptr_t      parent_xp  = new_process->parent_xp;
+#if CONFIG_DEBUG_PROCESS_MAKE_EXEC
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x created new_process main thread %x / cycle %d\n",
+__FUNCTION__ , old_thread , new_thread , cycle );
+#endif
+
+    // get cluster and local pointer on parent process
     process_t * parent_ptr = GET_PTR( parent_xp );
     cxy_t       parent_cxy = GET_CXY( parent_xp );
@@ -1235 +1329 @@
     remote_spinlock_unlock( lock_xp );
 
-exec_dmsg("\n[DBG] %s : core[%x,%d] updated parent process children list / cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
-   
-    // block and mark calling thread for deletion
-    // only when it is an user thread
-    thread_t * this = CURRENT_THREAD;
-    if( this->type == THREAD_USER )
-    {
-        thread_block( this , THREAD_BLOCKED_GLOBAL );
-        hal_atomic_or( &this->flags , THREAD_FLAG_REQ_DELETE );
-    }
-
     // activate new thread
         thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
 
+    // request old_thread destruction => old_process destruction
+    thread_block( old_thread , THREAD_BLOCKED_GLOBAL );
+    hal_atomic_or( &old_thread->flags , THREAD_FLAG_REQ_DELETE );
+
     hal_fence();
 
-exec_dmsg("\n[DBG] %s : core[%x,%d] exit for path = %s / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path , (uint32_t)hal_get_cycles() );
-
+#if CONFIG_DEBUG_PROCESS_MAKE_EXEC
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : old_thread %x blocked / new_thread %x activated / cycle %d\n",
+__FUNCTION__ , old_thread , new_thread , cycle );
+#endif
+   
         return 0;
 
 }  // end process_make_exec()
 
-///////////////////////////////////////
-void process_make_kill( pid_t      pid,
-                        uint32_t   sig_id )
-{
-    // this function must be executed by a thread running in owner cluster
-    assert( (CXY_FROM_PID( pid ) == local_cxy) , __FUNCTION__ ,
-    "must execute in owner cluster" );
-
+////////////////////////////////////////////
+void process_make_kill( process_t * process,
+                        bool_t      is_exit,
+                        uint32_t    exit_status )
+{
     thread_t * this = CURRENT_THREAD;
 
-kill_dmsg("\n[DBG] %s : core[%x,%d] enter / process %x / sig %d\n",
-__FUNCTION__, local_cxy, this->core->lid, pid , sig_id );
-
-    // get pointer on local target process descriptor
-    process_t * process = process_get_local_copy( pid );
-
-    // does nothing if process does not exist
-    if( process == NULL )
-    {
-        printk("\n[WARNING] %s : process %x does not exist => do nothing\n",
-        __FUNCTION__ , pid );
-        return;
-    }
-
-    // analyse signal type
-    switch( sig_id )
-    {
-        case SIGSTOP:     
-        {
-            // block all threads in all clusters
-            process_sigaction( process , BLOCK_ALL_THREADS );
-
-            // remove TXT ownership to target process 
-            process_txt_reset_ownership( XPTR( local_cxy , process ) );
-        }
-        break;
-        case SIGCONT:     // unblock all threads in all clusters
-        {
-            process_sigaction( process , UNBLOCK_ALL_THREADS );
-        }
-        break;
-        case SIGKILL:  // block all threads, then delete all threads
-        {
-            // block all threads in all clusters
-            process_sigaction( process , BLOCK_ALL_THREADS );
-
-            // remove TXT ownership to target process 
-            process_txt_reset_ownership( XPTR( local_cxy , process ) );
-
-            // delete all threads (but the calling thread)
-            process_sigaction( process , DELETE_ALL_THREADS );
-
-            // delete the calling thread if required
-            if( CURRENT_THREAD->process == process )
-            {
-                // set REQ_DELETE flag
-                hal_atomic_or( &this->flags , THREAD_FLAG_REQ_DELETE );
-
-                // deschedule
-                sched_yield( "suicide after kill" ); 
-            }
-        }
-        break;
-    }
-
-kill_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / sig %d \n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid , sig_id );
+    assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
+    "must be executed in process owner cluster\n" );
+
+    assert( ( this->type == THREAD_RPC ) , __FUNCTION__ ,
+    "must be executed by an RPC thread\n" );
+
+#if CONFIG_DEBUG_PROCESS_MAKE_KILL
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_KILL < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
+__FUNCTION__, this , process->pid , cycle );
+#endif
+
+    // register exit_status in owner process descriptor
+    if( is_exit ) process->term_state = exit_status;
+
+    // atomically update owner process descriptor flags
+    if( is_exit ) hal_atomic_or( &process->term_state , PROCESS_FLAG_EXIT );
+    else          hal_atomic_or( &process->term_state , PROCESS_FLAG_KILL );
+
+    // remove TXT ownership from owner process descriptor
+    process_txt_reset_ownership( XPTR( local_cxy , process ) );
+
+    // block all process threads in all clusters
+    process_sigaction( process , BLOCK_ALL_THREADS );
+
+    // mark all process threads in all clusters for delete 
+    process_sigaction( process , DELETE_ALL_THREADS );
+
+/* unused if sys_wait deschedules without blocking [AG]
+
+    // get cluster and pointers on reference parent process
+    xptr_t      parent_xp  = process->parent_xp;
+    process_t * parent_ptr = GET_PTR( parent_xp );
+    cxy_t       parent_cxy = GET_CXY( parent_xp );
+
+    // get loal pointer on parent main thread
+    thread_t * main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) );
+ 
+    // reset THREAD_BLOCKED_WAIT bit in parent process main thread
+    thread_unblock( XPTR( parent_cxy , main_ptr ) , THREAD_BLOCKED_WAIT );
+*/
+
+#if CONFIG_DEBUG_PROCESS_MAKE_KILL
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_MAKE_KILL < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
+__FUNCTION__, this, process->pid , cycle );
+#endif
 
 }  // end process_make_kill()
-
-/////////////////////////////////////////
-void process_make_exit( pid_t       pid,
-                        uint32_t    status )
-{
-    // this function must be executed by a thread running in owner cluster
-    assert( (CXY_FROM_PID( pid ) == local_cxy) , __FUNCTION__ ,
-    "must execute in owner cluster" );
-
-    // get pointer on local process descriptor
-    process_t * process = process_get_local_copy( pid );
-
-    // does nothing if process does not exist
-    if( process == NULL )
-    {
-        printk("\n[WARNING] %s : process %x does not exist => do nothing\n",
-        __FUNCTION__ , pid );
-        return;
-    }
-
-    // block all threads in all clusters (but the calling thread)
-    process_sigaction( process , BLOCK_ALL_THREADS );
-
-    // delete all threads in all clusters (but the calling thread)
-    process_sigaction( process , DELETE_ALL_THREADS );
-
-    // delete the calling thread 
-    hal_atomic_or( &CURRENT_THREAD->flags , THREAD_FLAG_REQ_DELETE );
-
-    // deschedule
-    sched_yield( "suicide after exit" ); 
-
-}  // end process_make_exit()
 
 ///////////////////////////////////////////////
@@ -1366 +1412 @@
 {
 
-process_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_ZERO_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_ZERO_CREATE < cycle )
+printk("\n[DBG] %s : thread %x enter / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+#endif
 
     // initialize PID, REF_XP, PARENT_XP, and STATE
-    process->pid       = 0;
-    process->ref_xp    = XPTR( local_cxy , process );
-    process->parent_xp = XPTR_NULL;
-    process->state     = PROCESS_STATE_RUNNING;
+    process->pid        = 0;
+    process->ref_xp     = XPTR( local_cxy , process );
+    process->parent_xp  = XPTR_NULL;
+    process->term_state = 0;
 
     // reset th_tbl[] array as empty
@@ -1391 +1440 @@
         hal_fence();
 
-process_dmsg("\n[DBG] %s : core[%x,%d] exit at cycle %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_ZERO_CREATE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_ZERO_CREATE < cycle )
+printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+#endif
 
 }  // end process_zero_init()
@@ -1406 +1458 @@
     error_t          error;
 
-process_dmsg("\n[DBG] %s :  core[%x,%d] enters at cycle %d\n", 
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid );
+#if CONFIG_DEBUG_PROCESS_INIT_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x enter / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+#endif
 
     // allocates memory for process descriptor from local cluster
@@ -1434 +1489 @@
                             XPTR( local_cxy , &process_zero ),     // parent
                             XPTR( local_cxy , &process_zero ) );   // model
-
-process_dmsg("\n[DBG] %s : core[%x,%d] / initialisation done\n", 
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid );
 
     // register "code" and "data" vsegs as well as entry-point
@@ -1446 +1498 @@
         process_destroy( process );
         }
-
-process_dmsg("\n[DBG] %s : core[%x,%d] vsegs registered / path = %s\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, CONFIG_PROCESS_INIT_PATH );
 
     // get extended pointers on process_zero children_root, children_lock
@@ -1489 +1538 @@
     hal_fence();
 
-process_dmsg("\n[DBG] %s : core[%x,%d] exit / main thread = %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, thread );
+#if CONFIG_DEBUG_PROCESS_INIT_CREATE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+#endif
 
 }  // end process_init_create()
-
-//////////////////////////////////////////
-char * process_state_str( uint32_t state )
-{
-    if     ( state == PROCESS_STATE_RUNNING ) return "RUNNING";
-    else if( state == PROCESS_STATE_KILLED  ) return "KILLED";
-    else if( state == PROCESS_STATE_EXITED  ) return "EXITED";
-    else                                      return "undefined";
-}
 
 /////////////////////////////////////////
@@ -1542 +1585 @@
     // get PID and state
     pid   = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
-    state = hal_remote_lw( XPTR( process_cxy , &process_ptr->state ) );
+    state = hal_remote_lw( XPTR( process_cxy , &process_ptr->term_state ) );
 
     // get PPID
@@ -1577 +1620 @@
     if( owner_xp == process_xp )
     {
-        printk("PID %X | PPID %X | %s\t| %s (FG) | %X | %d | %s\n", 
-        pid, ppid, process_state_str(state), txt_name, process_ptr, th_nr, elf_name );
+        printk("PID %X | PPID %X | STS %X | %s (FG) | %X | %d | %s\n", 
+        pid, ppid, state, txt_name, process_ptr, th_nr, elf_name );
     }
     else
     {
-        printk("PID %X | PPID %X | %s\t| %s (BG) | %X | %d | %s\n", 
-        pid, ppid, process_state_str(state), txt_name, process_ptr, th_nr, elf_name );
+        printk("PID %X | PPID %X | STS %X | %s (BG) | %X | %d | %s\n", 
+        pid, ppid, state, txt_name, process_ptr, th_nr, elf_name );
     }
 }  // end process_display() 
@@ -1632 +1675 @@
     xptr_t      lock_xp;      // extended pointer on list lock in chdev
 
-process_dmsg("\n[DBG] %s : core[%x,%d] enter for process %x at cycle\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_TXT_ATTACH
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_TXT_ATTACH < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / txt_id = %d  / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, txt_id, cycle );
+#endif
 
     // check process is reference
@@ -1657 +1704 @@
     remote_spinlock_unlock( lock_xp );
 
-process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x at cycle\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_TXT_ATTACH
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_TXT_ATTACH < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / txt_id = %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, txt_id , cycle );
+#endif
 
 } // end process_txt_attach()
@@ -1670 +1721 @@
     xptr_t      lock_xp;      // extended pointer on list lock in chdev
 
-process_dmsg("\n[DBG] %s : core[%x,%d] enter for process %x at cycle\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_TXT_DETACH
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_TXT_DETACH < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid , cycle );
+#endif
 
     // check process is reference
@@ -1690 +1745 @@
     remote_spinlock_unlock( lock_xp );
    
-process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x at cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid, (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_PROCESS_TXT_DETACH
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PROCESS_TXT_DETACH < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, cycle );
+#endif
 
 } // end process_txt_detach()
@@ -1732 +1791 @@
     xptr_t      file_xp;         // extended pointer on TXT_RX pseudo file
     xptr_t      txt_xp;          // extended pointer on TXT_RX chdev
-    chdev_t   * txt_ptr;
-    cxy_t       txt_cxy;
+    chdev_t   * txt_ptr;         // local pointer on TXT_RX chdev
+    cxy_t       txt_cxy;         // cluster of TXT_RX chdev
+    uint32_t    txt_id;          // TXT_RX channel 
     xptr_t      owner_xp;        // extended pointer on current TXT_RX owner
     xptr_t      root_xp;         // extended pointer on root of attached process list
     xptr_t      iter_xp;         // iterator for xlist
     xptr_t      current_xp;      // extended pointer on current process
-    process_t * current_ptr;
-    cxy_t       current_cxy;
-    pid_t       ppid;
+    process_t * current_ptr;     // local pointer on current process
+    cxy_t       current_cxy;     // cluster for current process
+    pid_t       ppid;            // parent process identifier for current process
 
     // get cluster and local pointer on process
@@ -1752 +1812 @@
     txt_xp  = chdev_from_file( file_xp );
     txt_cxy = GET_CXY( txt_xp );
-    txt_ptr = (chdev_t *)GET_PTR( txt_xp );
-
-    // get extended pointer on TXT_RX owner
+    txt_ptr = GET_PTR( txt_xp );
+
+    // get extended pointer on TXT_RX owner and TXT channel
     owner_xp = hal_remote_lwd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
+    txt_id   = hal_remote_lw ( XPTR( txt_cxy , &txt_ptr->channel ) );
 
     // transfer ownership to KSH if required
-    if( owner_xp == process_xp )   
+    if( (owner_xp == process_xp) && (txt_id > 0) )   
     {
         // get extended pointer on root of list of attached processes
@@ -1782 +1843 @@
             }
         }
-    }
-
-    assert( false , __FUNCTION__ , "KSH process not found" ); 
-
+
+        assert( false , __FUNCTION__ , "KSH process not found" ); 
+    }
 }  // end process_txt_reset_ownership()
 

trunk/kernel/kern/process.h

@@ -4 +4 @@
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
  *          Mohamed Lamine Karaoui (2015)
- *          Alain Greiner (2016,2017)
+ *          Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -65 +65 @@
 
 /*********************************************************************************************
- * This enum defines the process states for ALMOS_MKH.
- ********************************************************************************************/
-
-enum process_states
-{
-    PROCESS_STATE_RUNNING = 0,           /*! process is executing                           */
-    PROCESS_STATE_STOPPED = 1,           /*! process has been stopped by a signal           */
-    PROCESS_STATE_KILLED  = 2,           /*! process has been killed by a signal            */
-    PROCESS_STATE_EXITED  = 3,           /*! process terminated with an exit                */ 
-};
+ * The termination state is a 32 bits word:
+ * - the 8 LSB bits contain the user defined exit status
+ * - the 24 other bits contain the flags defined below
+ ********************************************************************************************/
+
+#define PROCESS_FLAG_BLOCK 0x100  /*! process received as SIGSTOP signal                    */
+#define PROCESS_FLAG_KILL  0x200  /*! process terminated by a sys_kill()                    */
+#define PROCESS_FLAG_EXIT  0x400  /*! process terminated by a sys_exit()                    */ 
+#define PROCESS_FLAG_WAIT  0x800  /*! parent process executed successfully a sys_wait()     */
 
 /*********************************************************************************************
@@ -118 +117 @@
  * 6) The <local_list>, <copies_list>, <th_tbl>, <th_nr>, <th_lock> fields
  *    are defined in all process descriptors copies.
+ * 7) The termination <flags> and <exit_status> are only defined in the reference cluster.
  ********************************************************************************************/
 
@@ -155 +155 @@
     remote_spinlock_t sync_lock;        /*! lock protecting sem,mutex,barrier,condvar lists */
 
-    uint32_t          state;            /*! RUNNING / STOPPED / KILLED / EXITED             */
+    uint32_t          term_state;       /*! termination status (flags & exit status)        */
 
     bool_t            txt_owner;        /*! current TXT owner                               */
@@ -168 +168 @@
 typedef struct exec_info_s
 {
-    pid_t              pid;            /*! process identifier (both parent and child)       */
-
     char               path[CONFIG_VFS_MAX_PATH_LENGTH];   /*!  .elf file path              */
 
@@ -276 +274 @@
 
 /*********************************************************************************************
- * This function returns a printable string defining the process state.
- *********************************************************************************************
- * @ state   : RUNNING / BLOCKED / EXITED / KILLED
- * @ return a string pointer.
- ********************************************************************************************/
-char * process_state_str( uint32_t state );
-
-/*********************************************************************************************
  * This debug function diplays on the kernel terminal TXT0 detailed informations on a 
  * reference process identified by the <process_xp> argument.
@@ -324 +314 @@
 
 /*********************************************************************************************
- * This function blocks all threads (but the client thread defined by the <client_xp>
- * argument) for a given <process> in a given cluster.
+ * This function blocks all threads for a given <process> in a given cluster.
+ * The calling thread cannot be a target thread.
  * It loops on all local threads of the process, set the THREAD_BLOCKED_GLOBAL bit, 
  * and request the relevant schedulers to acknowledge the blocking, using IPI if required. 
@@ -332 +322 @@
  *********************************************************************************************
  * @ process     : pointer on the target process descriptor.
- * @ client_xp   : extended pointer on the client thread, that should not be blocked.
- ********************************************************************************************/
-void process_block_threads( process_t * process,
-                            xptr_t      client_xp );
+ ********************************************************************************************/
+void process_block_threads( process_t * process );
 
 /*********************************************************************************************
@@ -345 +333 @@
 
 /*********************************************************************************************
- * This function delete all threads, (but the client thread defined by the <client_xp>
- * argument) for a given <process> in a given cluster.
+ * This function marks for deletion all threads - but one _ for a given <process>
+ * in a given cluster. The main thread in owner cluster is NOT marked.
+ * It will be marked for deletion by the parent process sys_wait().
+ * The calling thread cannot be a target thread.
  * It loops on all local threads of the process, and set the THREAD_FLAG_REQ_DELETE bit.
  * For each marked thread, the following actions will be done by the scheduler at the next
@@ -357 +347 @@
  *********************************************************************************************
  * @ process     : pointer on the process descriptor.
- * @ client_xp   : extended pointer on the client thread, that should not be deleted.
- ********************************************************************************************/
-void process_delete_threads( process_t * process,
-                             xptr_t      client_xp );
+ ********************************************************************************************/
+void process_delete_threads( process_t * process );
 
 /*********************************************************************************************
@@ -396 +384 @@
  * associated "child" thread descriptor in the local cluster. This function can involve
  * up to three different clusters :
- * - the local (child) cluster can be any cluster defined by the sys_fork function.
+ * - the child (local) cluster can be any cluster defined by the sys_fork function.
  * - the parent cluster must be the reference cluster for the parent process.
  * - the client cluster containing the thread requesting the fork can be any cluster.
@@ -416 +404 @@
 
 /*********************************************************************************************
- * This function implement the "exit" system call, and is called by the sys_exit() function.
- * It must be executed by a thread running in the calling process owner cluster.
- * It uses twice the multicast RPC_PROCESS_SIGNAL to first block all process threads
- * in all clusters, and then delete all threads and process descriptors.
- *********************************************************************************************
- * @ pid      : process identifier.
- * @ status   : exit return value.
- ********************************************************************************************/
-void process_make_exit( pid_t       pid,
-                        uint32_t    status );
-
-/*********************************************************************************************
- * This function implement the "kill" system call, and is called by the sys_kill() function.
- * It must be executed by a thread running in the target process owner cluster.
- * Only the SIGKILL, SIGSTOP, and SIGCONT signals are supported.
- * User defined handlers are not supported.
- * It uses once or twice the multicast RPC_PROCESS_SIGNAL to block, unblock or delete
- * all process threads in all clusters, and then delete process descriptors.
- *********************************************************************************************
- * @ pid     : process identifier.
- * @ sig_id  : signal type.
- ********************************************************************************************/
-void process_make_kill( pid_t     pid,
-                        uint32_t  sig_id );
+ * This function is called by both the sys_kill() and sys_exit() system calls.
+ * It must be executed by an RPC thread running in the target process owner cluster.
+ * It uses twice the process_sigaction() function: 
+ * - first, to block all target process threads, in all clusters.
+ * - second, to delete all target process threads in all clusters.
+ * Finally, it synchronizes with the parent process sys_wait() function that MUST be called
+ * by the parent process main thread.
+ *********************************************************************************************
+ * @ process      : pointer on process descriptor in owner cluster.
+ * @ is_exit      : true when called by sys_exit() / false when called by sys_kill().
+ * @ exit_status  : exit status, when called by sys_exit().
+ ********************************************************************************************/
+void process_make_kill( process_t * process,
+                        bool_t      is_exit,
+                        uint32_t    exit_status );
 
 

trunk/kernel/kern/rpc.c

@@ -42 +42 @@
 #include <rpc.h>
 
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//        Debug macros for marshalling functions
+/////////////////////////////////////////////////////////////////////////////////////////
+
+#if CONFIG_DEBUG_RPC_MARSHALING
+
+#define RPC_DEBUG_ENTER                                                                \
+uint32_t cycle = (uint32_t)hal_get_cycles();                                           \
+if( cycle > CONFIG_DEBUG_RPC_MARSHALING )                                              \
+printk("\n[DBG] %s : enter thread %x on core[%x,%d] / cycle %d\n",                     \
+__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, CURRENT_THREAD->core->lid , cycle );
+
+#define RPC_DEBUG_EXIT                                                                 \
+cycle = (uint32_t)hal_get_cycles();                                                    \
+if( cycle > CONFIG_DEBUG_RPC_MARSHALING )                                              \
+printk("\n[DBG] %s : exit thread %x on core[%x,%d] / cycle %d\n",                      \
+__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, CURRENT_THREAD->core->lid , cycle );
+
+#else
+
+#define RPC_DEBUG_ENTER
+
+#define RPC_DEBUG_EXIT
+
+#endif
+
 /////////////////////////////////////////////////////////////////////////////////////////
 //      array of function pointers  (must be consistent with enum in rpc.h) 
@@ -50 +77 @@
     &rpc_pmem_get_pages_server,         // 0
     &rpc_pmem_release_pages_server,     // 1
-    &rpc_process_make_exec_server,      // 2
+    &rpc_undefined,                     // 2    unused slot
     &rpc_process_make_fork_server,      // 3
-    &rpc_process_make_exit_server,      // 4
+    &rpc_undefined,                     // 4    unused slot
     &rpc_process_make_kill_server,      // 5
     &rpc_thread_user_create_server,     // 6
@@ -68 +95 @@
     &rpc_vfs_mapper_load_all_server,    // 17
     &rpc_fatfs_get_cluster_server,      // 18
-    &rpc_undefined,                     // 19
+    &rpc_undefined,                     // 19   unused slot
 
     &rpc_vmm_get_vseg_server,           // 20
@@ -497 +524 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [2]           Marshaling functions attached to RPC_PROCESS_MAKE_EXEC (blocking)
-/////////////////////////////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////////////
-void rpc_process_make_exec_client( cxy_t         cxy,
-                                   exec_info_t * info,     // in
-                                   error_t     * error )   // out
-{
-rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-
-    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
-
-    // initialise RPC descriptor header 
-    rpc_desc_t  rpc;
-    rpc.index    = RPC_PROCESS_MAKE_EXEC;
-    rpc.response = 1;
-    rpc.blocking = true;
-
-    // set input arguments in RPC descriptor  
-    rpc.args[0] = (uint64_t)(intptr_t)info;
-
-    // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc );
-
-    // get output arguments from RPC descriptor
-    *error  = (error_t)rpc.args[1];     
-
-rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-}
-
-//////////////////////////////////////////////
-void rpc_process_make_exec_server( xptr_t xp )
-{
-rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-
-    exec_info_t * ptr;       // local pointer on remote exec_info structure
-    exec_info_t   info;      // local copy of exec_info structure
-    error_t       error;     // local error error status
-
-    // get client cluster identifier and pointer on RPC descriptor
-    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
-    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
-
-    // get pointer on exec_info structure in client cluster from RPC descriptor
-    ptr = (exec_info_t*)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
-
-    // copy exec_info structure from client buffer to server buffer
-    hal_remote_memcpy( XPTR( client_cxy , ptr ),
-                       XPTR( local_cxy , &info ),
-                       sizeof(exec_info_t) );
-
-    // call local kernel function
-    error = process_make_exec( &info ); 
-
-    // set output argument into client RPC descriptor
-    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
-
-rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-}
+// [2]      undefined slot
+/////////////////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -644 +606 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [4]      Marshaling functions attached to RPC_PROCESS_MAKE_EXIT (blocking)
+// [4]      undefined slot
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [5]      Marshaling functions attached to RPC_PROCESS_MAKE_KILL (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////
-void rpc_process_make_exit_client( cxy_t       cxy,
-                                   pid_t       pid,
+void rpc_process_make_kill_client( cxy_t       cxy,
+                                   process_t * process,
+                                   bool_t      is_exit,
                                    uint32_t    status ) 
 {
@@ -656 +623 @@
 CURRENT_THREAD->core->lid , hal_time_stamp() );
 
-    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
-
-    // initialise RPC descriptor header 
-    rpc_desc_t  rpc;
-    rpc.index    = RPC_PROCESS_MAKE_EXIT;
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_PROCESS_MAKE_KILL;
     rpc.response = 1;
     rpc.blocking = true;
 
     // set input arguments in RPC descriptor  
-    rpc.args[0] = (uint64_t)pid;
-    rpc.args[1] = (uint64_t)status;
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[1] = (uint64_t)is_exit;
+    rpc.args[2] = (uint64_t)status;
 
     // register RPC request in remote RPC fifo (blocking function)
@@ -677 +643 @@
 
 //////////////////////////////////////////////
-void rpc_process_make_exit_server( xptr_t xp )
+void rpc_process_make_kill_server( xptr_t xp )
 {
 rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
@@ -683 +649 @@
 CURRENT_THREAD->core->lid , hal_time_stamp() );
 
-    pid_t     pid;
-    uint32_t  status;  
+    process_t * process;
+    bool_t      is_exit;
+    uint32_t    status;
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -691 +658 @@
 
     // get arguments from RPC descriptor
-    pid    = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
-    status = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    is_exit = (bool_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    status  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
 
     // call local kernel function
-    process_make_exit( pid , status ); 
+    process_make_kill( process , is_exit , status ); 
 
 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -703 +671 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [5]      Marshaling functions attached to RPC_PROCESS_MAKE_KILL (blocking)
-/////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////
-void rpc_process_make_kill_client( cxy_t       cxy,
-                                   pid_t       pid,
-                                   uint32_t    sig_id ) 
-{
-rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-
-    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
-
-    // initialise RPC descriptor header 
-    rpc_desc_t  rpc;
-    rpc.index    = RPC_PROCESS_MAKE_KILL;
-    rpc.response = 1;
-    rpc.blocking = true;
-
-    // set input arguments in RPC descriptor  
-    rpc.args[0] = (uint64_t)pid;
-    rpc.args[1] = (uint64_t)sig_id;
-
-    // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc );
-
-rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-}  
-
-//////////////////////////////////////////////
-void rpc_process_make_kill_server( xptr_t xp )
-{
-rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-
-    pid_t       pid;
-    uint32_t    sig_id;
-
-    // get client cluster identifier and pointer on RPC descriptor
-    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
-    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
-
-    // get arguments from RPC descriptor
-    pid    = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
-    sig_id = (uint32_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
-
-    // call local kernel function
-    process_make_exit( pid , sig_id ); 
-
-rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-CURRENT_THREAD->core->lid , hal_time_stamp() );
-} 
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [6]           Marshaling functions attached to RPC_THREAD_USER_CREATE (blocking)               
+// [6]           Marshaling functions attached to RPC_THREAD_USER_CREATE (blocking)  
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1036 +945 @@
 
     // call relevant kernel function
-    if      (action == DELETE_ALL_THREADS  ) process_delete_threads ( process , client_xp ); 
-    else if (action == BLOCK_ALL_THREADS   ) process_block_threads  ( process , client_xp ); 
-    else if (action == UNBLOCK_ALL_THREADS ) process_unblock_threads( process             );
+    if      (action == DELETE_ALL_THREADS  ) process_delete_threads ( process ); 
+    else if (action == BLOCK_ALL_THREADS   ) process_block_threads  ( process ); 
+    else if (action == UNBLOCK_ALL_THREADS ) process_unblock_threads( process );
 
     // decrement the responses counter in RPC descriptor,

trunk/kernel/kern/rpc.h

@@ -62 +62 @@
     RPC_PMEM_GET_PAGES         = 0,
     RPC_PMEM_RELEASE_PAGES     = 1,
-    RPC_PROCESS_MAKE_EXEC      = 2,      
+    RPC_UNDEFINED_2            = 2,      
     RPC_PROCESS_MAKE_FORK      = 3,
-    RPC_PROCESS_MAKE_EXIT      = 4,
+    RPC_UNDEFINED_4            = 4,
     RPC_PROCESS_MAKE_KILL      = 5,
     RPC_THREAD_USER_CREATE     = 6,
@@ -80 +80 @@
     RPC_VFS_MAPPER_LOAD_ALL    = 17,
     RPC_FATFS_GET_CLUSTER      = 18,
+    RPC_UNDEFINED_19           = 19,
 
     RPC_VMM_GET_VSEG           = 20,
@@ -210 +211 @@
 
 /***********************************************************************************
- * [2] The RPC_PROCESS_MAKE_EXEC creates a new process descriptor, from an existing
- * process descriptor in a remote server cluster. This server cluster must be 
- * the owner cluster for the existing process. The new process descriptor is 
- * initialized from informations found in the <exec_info> structure.
- * A new main thread descriptor is created in the server cluster.
- * All copies of the old process descriptor and all old threads are destroyed.
- ***********************************************************************************
- * @ cxy     : server cluster identifier.
- * @ process : [in]  local pointer on the exec_info structure in client cluster.
- * @ error   : [out] error status (0 if success).
- **********************************************************************************/
-void rpc_process_make_exec_client( cxy_t                cxy,
-                                   struct exec_info_s * info, 
-                                   error_t            * error );
-
-void rpc_process_make_exec_server( xptr_t xp );
+ * [2] undefined slot
+ **********************************************************************************/
 
 /***********************************************************************************
@@ -251 +238 @@
 
 /***********************************************************************************
- * [4] The RPC_PROCESS_MAKE_EXIT can be called by any thread to request the owner
- * cluster to execute the process_make_exit() function for the target process.
- ***********************************************************************************
- * @ cxy      : owner cluster identifier.
- * @ pid      : target process identifier.
- * @ status   : calling process exit status.
- **********************************************************************************/
-void rpc_process_make_exit_client( cxy_t              cxy,
-                                   pid_t              pid,
-                                   uint32_t           status );
-
-void rpc_process_make_exit_server( xptr_t xp );
+ * [4] undefined slot
+ **********************************************************************************/
 
 /***********************************************************************************
@@ -269 +246 @@
  ***********************************************************************************
  * @ cxy      : owner cluster identifier.
- * @ pid      : target process identifier.
- * @ seg_id   : signal type (only SIGKILL / SIGSTOP / SIGCONT are supported).
+ * @ process  : pointer on process in owner cluster.
+ * @ is_exit  : true if called by sys_exit() / false if called by sys_kill()
+ * @ status   : exit status (only when called by sys_exit()
  **********************************************************************************/
 void rpc_process_make_kill_client( cxy_t              cxy,
-                                   pid_t              pid,
-                                   uint32_t           seg_id );
+                                   struct process_s * process,
+                                   bool_t             is_exit,
+                                   uint32_t           status );
 
 void rpc_process_make_kill_server( xptr_t xp );
@@ -517 +496 @@
 
 /***********************************************************************************
+ * [19] undefined slot
+ **********************************************************************************/
+
+/***********************************************************************************
  * [20] The RPC_VMM_GET_VSEG returns an extended pointer 
  * on the vseg containing a given virtual address in a given process.

trunk/kernel/kern/scheduler.c

@@ -178 +178 @@
 
 ///////////////////////////////////////////
-void sched_handle_requests( core_t * core )
+void sched_handle_signals( core_t * core )
 {
     list_entry_t * iter;
@@ -231 +231 @@
             thread_destroy( thread );
 
-sched_dmsg("\n[DBG] %s : thread %x deleted thread %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , thread , (uint32_t)hal_get_cycles() );
-
+#if CONFIG_DEBUG_SCHED_HANDLE_SIGNALS
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_SCHED_HANDLE_SIGNALS < cycle )
+printk("\n[DBG] %s : thread %x deleted thread %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , thread , cycle );
+#endif
             // destroy process descriptor if no more threads
             if( process->th_nr == 0 ) 
@@ -240 +243 @@
                 process_destroy( process );
 
-sched_dmsg("\n[DBG] %s : thread %x deleted process %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , process , (uint32_t)hal_get_cycles() );
+#if CONFIG_DEBUG_SCHED_HANDLE_SIGNALS
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_SCHED_HANDLE_SIGNALS < cycle )
+printk("\n[DBG] %s : thread %x deleted process %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process , cycle );
+#endif
 
             }
@@ -251 +258 @@
     spinlock_unlock( &sched->lock );
 
-} // end sched_handle_requests()
+} // end sched_handle_signals()
 
 ////////////////////////////////
@@ -261 +268 @@
     scheduler_t * sched   = &core->scheduler;
  
-#if( CONFIG_SCHED_DEBUG & 0x1 )
-if( hal_time_stamp() > CONFIG_SCHED_DEBUG ) sched_display( core->lid );
+#if (CONFIG_DEBUG_SCHED_YIELD & 0x1)
+if( CONFIG_DEBUG_SCHED_YIELD < (uint32_t)hal_get_cycles() )
+sched_display( core->lid );
 #endif
 
@@ -291 +299 @@
     {
 
-sched_dmsg("\n[DBG] %s : core[%x,%d] / cause = %s\n"
+#if CONFIG_DEBUG_SCHED_YIELD
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_SCHED_YIELD < cycle )
+printk("\n[DBG] %s : core[%x,%d] / cause = %s\n"
 "      thread %x (%s) (%x,%x) => thread %x (%s) (%x,%x) / cycle %d\n",
 __FUNCTION__, local_cxy, core->lid, cause, 
 current, thread_type_str(current->type), current->process->pid, current->trdid,
-next   , thread_type_str(next->type)   , next->process->pid   , next->trdid,
-(uint32_t)hal_get_cycles() );
+next , thread_type_str(next->type) , next->process->pid , next->trdid , cycle );
+#endif
 
         // update scheduler 
@@ -316 +327 @@
     {
 
-#if( CONFIG_SCHED_DEBUG & 0x1 )
-if( hal_time_stamp() > CONFIG_SCHED_DEBUG ) 
-printk("\n[DBG] %s : core[%x,%d] / cause = %s\n" 
-"      thread %x (%s) (%x,%x) continue / cycle %d\n",
+#if( CONFIG_DEBUG_SCHED_YIELD & 0x1 )
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_SCHED_YIELD < cycle )
+printk("\n[DBG] %s : core[%x,%d] / cause = %s / thread %x (%s) (%x,%x) continue / cycle %d\n",
 __FUNCTION__, local_cxy, core->lid, cause,
-current, thread_type_str(current->type), current->process->pid, current->trdid, 
-(uint32_t)hal_get_cycles() );
+current, thread_type_str(current->type), current->process->pid, current->trdid, cycle );
 #endif
 
@@ -328 +338 @@
 
     // handle pending requests for all threads executing on this core.
-    sched_handle_requests( core );
+    sched_handle_signals( core );
 
     // exit critical section / restore SR from next thread context

trunk/kernel/kern/scheduler.h

@@ -91 +91 @@
  * @ core    : local pointer on the core descriptor.
  ********************************************************************************************/
-void sched_handle_requests( struct core_s * core );
+void sched_handle_signals( struct core_s * core );
 
 /*********************************************************************************************

trunk/kernel/kern/thread.c

@@ -227 +227 @@
     assert( (attr != NULL) , __FUNCTION__, "pthread attributes must be defined" );
 
-thread_dmsg("\n[DBG] %s : core[%x,%d] enter for process %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid );
+#if CONFIG_DEBUG_THREAD_USER_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, pid , cycle );
+#endif
 
     // get process descriptor local copy
     process = process_get_local_copy( pid );
-
     if( process == NULL )
     {
@@ -326 +329 @@
     dqdt_local_update_threads( 1 );
 
-thread_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x / trdid = %x / core = %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid, thread->trdid, core_lid );
+#if CONFIG_DEBUG_THREAD_USER_CREATE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : thread %x exit / process %x / new_thread %x / core %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, pid, thread, core_lid, cycle );
+#endif
 
     *new_thread = thread;
@@ -359 +366 @@
     vseg_t       * vseg;             // child thread STACK vseg
 
-thread_dmsg("\n[DBG] %s : core[%x,%d] enters at cycle %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_get_cycles() );
+#if CONFIG_DEBUG_THREAD_USER_FORK
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[DBG] %s : thread %x enter / child_process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, child_process->pid, cycle );
+#endif
 
     // select a target core in local cluster
@@ -474 +485 @@
         }
 
-        // increment page descriptor fork_nr for the referenced page if mapped
+        // increment pending forks counter for the page if mapped
         if( mapped )
         {
@@ -480 +491 @@
             cxy_t    page_cxy = GET_CXY( page_xp );
             page_t * page_ptr = (page_t *)GET_PTR( page_xp );
-            hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , 1 );
-
-thread_dmsg("\n[DBG] %s : core[%x,%d] copied PTE to child GPT : vpn %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+            hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->forks ) , 1 );
+
+#if (CONFIG_DEBUG_THREAD_USER_FORK & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[DBG] %s : thread %x copied stack PTE to child GPT : vpn %x\n",
+__FUNCTION__, CURRENT_THREAD, vpn );
+#endif
 
         }
     }
 
-    // set COW flag for STAK vseg in parent thread GPT 
-    hal_gpt_flip_cow( true,                               // set cow
-                      parent_gpt_xp,
-                      vpn_base,
-                      vpn_size );
+    // set COW flag for all mapped entries of STAK vseg in parent thread GPT 
+    hal_gpt_set_cow( parent_gpt_xp,
+                     vpn_base,
+                     vpn_size );
  
         // update DQDT for child thread 
     dqdt_local_update_threads( 1 );
 
-thread_dmsg("\n[DBG] %s : core[%x,%d] exit / created main thread %x for process %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, child_ptr->trdid, child_process->pid );
+#if CONFIG_DEBUG_THREAD_USER_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[DBG] %s : thread %x exit / child_process %x / child_thread %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, child_process->pid, child_ptr, cycle );
+#endif
 
         return 0;
@@ -514 +532 @@
         thread_t     * thread;       // pointer on new thread descriptor
 
-thread_dmsg("\n[DBG] %s : core[%x,%d] enters / type %s / cycle %d\n",
-__FUNCTION__ , local_cxy , core_lid , thread_type_str( type ) , hal_time_stamp() );
-
     assert( ( (type == THREAD_IDLE) || (type == THREAD_RPC) || (type == THREAD_DEV) ) ,
     __FUNCTION__ , "illegal thread type" );
@@ -522 +537 @@
     assert( (core_lid < LOCAL_CLUSTER->cores_nr) ,
             __FUNCTION__ , "illegal core_lid" );
+
+#if CONFIG_DEBUG_THREAD_KERNEL_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_KERNEL_CREATE < cycle )
+printk("\n[DBG] %s : thread %x enter / requested_type %s / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, thread, thread_type_str(type), cycle );
+#endif
 
     // allocate memory for new thread descriptor
@@ -549 +571 @@
     dqdt_local_update_threads( 1 );
 
-thread_dmsg("\n[DBG] %s : core = [%x,%d] exit / trdid = %x / type %s / cycle %d\n",
-__FUNCTION__, local_cxy, core_lid, thread->trdid, thread_type_str(type), hal_time_stamp() );
+#if CONFIG_DEBUG_THREAD_KERNEL_CREATE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_KERNEL_CREATE < cycle )
+printk("\n[DBG] %s : thread %x exit / new_thread %x / type %s / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, thread, thread_type_str(type), cycle );
+#endif
 
     *new_thread = thread;
@@ -589 +615 @@
 void thread_destroy( thread_t * thread )
 {
-        uint32_t     tm_start;
-        uint32_t     tm_end;
     reg_t        save_sr;
 
@@ -596 +620 @@
     core_t     * core       = thread->core;
 
-    thread_dmsg("\n[DBG] %s : enters for thread %x in process %x / type = %s\n",
-                __FUNCTION__ , thread->trdid , process->pid , thread_type_str( thread->type ) );
+#if CONFIG_DEBUG_THREAD_DESTROY
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_DESTROY < cycle )
+printk("\n[DBG] %s : thread %x enter to destroy thread %x in process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, thread, process->pid, cycle );
+#endif
 
     assert( (thread->children_nr == 0) , __FUNCTION__ , "still attached children" );
@@ -604 +632 @@
 
     assert( (thread->remote_locks == 0) , __FUNCTION__ , "all remote locks not released" );
-
-        tm_start = hal_get_cycles();
 
     // update intrumentation values
@@ -635 +661 @@
     thread_release( thread );
 
-        tm_end = hal_get_cycles();
-
-        thread_dmsg("\n[DBG] %s : exit for thread %x in process %x / duration = %d\n",
-                       __FUNCTION__, thread->trdid , process->pid , tm_end - tm_start );
+#if CONFIG_DEBUG_THREAD_DESTROY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_DESTROY < cycle )
+printk("\n[DBG] %s : thread %x exit / destroyed thread %x in process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, thread, process->pid, cycle );
+#endif
 
 }   // end thread_destroy()
@@ -779 +807 @@
     hal_fence();
 
+#if CONFIG_DEBUG_THREAD_BLOCK
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_BLOCK < cycle )
+printk("\n[DBG] %s : thread %x blocked thread %x / cause %x / state %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , thread , cause , thread->blocked , cycle );
+#endif
+
 } // end thread_block()
 
-/////////////////////////////////////////
-uint32_t thread_unblock( xptr_t   thread,
+////////////////////////////////////////////
+uint32_t thread_unblock( xptr_t   thread_xp,
                          uint32_t cause )
 {
     // get thread cluster and local pointer
-    cxy_t      cxy = GET_CXY( thread );
-    thread_t * ptr = (thread_t *)GET_PTR( thread );
+    cxy_t      cxy = GET_CXY( thread_xp );
+    thread_t * ptr = GET_PTR( thread_xp );
 
     // reset blocking cause
@@ -793 +828 @@
     hal_fence();
 
+#if CONFIG_DEBUG_THREAD_BLOCK
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_THREAD_BLOCK < cycle )
+printk("\n[DBG] %s : thread %x unblocked thread %x / cause %x / state %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , ptr , cause , ptr->blocked , cycle );
+#endif
+
     // return a non zero value if the cause bit is modified 
     return( previous & cause );
@@ -805 +847 @@
     thread_t * killer = CURRENT_THREAD;
 
-thread_dmsg("\n[DBG] %s : killer thread %x enter for target thread %x\n",
-__FUNCTION__, local_cxy, killer->trdid , target->trdid );
+#if CONFIG_DEBUG_THREAD_KILL
+uint32_t cycle  = (uint32_t)hal_get_cycles;
+if( CONFIG_DEBUG_THREAD_KILL < cycle )
+printk("\n[DBG] %s : thread %x enter for target thread %x / cycle %d\n",
+__FUNCTION__, killer, target, cycle );
+#endif
 
     // set the global blocked bit in target thread descriptor.
@@ -835 +881 @@
         hal_atomic_or( &target->flags , THREAD_FLAG_REQ_DELETE );
 
-thread_dmsg("\n[DBG] %s : killer thread %x exit for target thread %x\n",
-__FUNCTION__, local_cxy, killer->trdid , target->trdid );
+#if CONFIG_DEBUG_THREAD_KILL
+cycle  = (uint32_t)hal_get_cycles;
+if( CONFIG_DEBUG_THREAD_KILL < cycle )
+printk("\n[DBG] %s : thread %x exit for target thread %x / cycle %d\n",
+__FUNCTION__, killer, target, cycle );
+#endif
 
 }  // end thread_kill()
@@ -851 +901 @@
         {
 
-idle_dmsg("\n[DBG] %s : core[%x][%d] goes to sleep at cycle %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_get_cycles() );
+#if CONFIG_DEBUG_THREAD_IDLE
+uint32_t cycle  = (uint32_t)hal_get_cycles;
+thread_t * this = CURRENT_THREAD;
+if( CONFIG_DEBUG_THREAD_IDLE < cycle )
+printk("\n[DBG] %s : idle thread %x on core[%x,%d] goes to sleep / cycle %d\n",
+__FUNCTION__, this, local_cxy, this->core->lid, cycle );
+#endif
 
             hal_core_sleep();
 
-idle_dmsg("\n[DBG] %s : core[%x][%d] wake up at cycle %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_get_cycles() );
+#if CONFIG_DEBUG_THREAD_IDLE
+cycle  = (uint32_t)hal_get_cycles;
+if( CONFIG_DEBUG_THREAD_IDLE < cycle )
+printk("\n[DBG] %s : idle thread %x on core[%x,%d] wake up / cycle %d\n",
+__FUNCTION__, this, local_cxy, this->core->lid, cycle );
+#endif
 
         }

trunk/kernel/libk/elf.c

@@ -201 +201 @@
                 vfs_file_count_up( file_xp );
 
-                elf_dmsg("\n[DBG] %s : found %s vseg / base = %x / size = %x\n"
-                 "       file_size = %x / file_offset = %x / mapper_xp = %l\n",
-            __FUNCTION__ , vseg_type_str(vseg->type) , vseg->min , vseg->max - vseg->min ,
-        vseg->file_size , vseg->file_offset , vseg->mapper_xp );
+#if CONFIG_DEBUG_ELF_LOAD
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : found %s vseg / base %x / size %x\n"
+"  file_size %x / file_offset %x / mapper_xp %l / cycle %d\n",
+__FUNCTION__ , vseg_type_str(vseg->type) , vseg->min , vseg->max - vseg->min ,
+vseg->file_size , vseg->file_offset , vseg->mapper_xp );
+#endif
+
         }
 
@@ -223 +228 @@
         error_t      error;
 
-    elf_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s>\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pathname );
+#if CONFIG_DEBUG_ELF_LOAD
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : thread %d enter for <%s> / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, pathname, cycle );
+#endif
 
     // avoid GCC warning
@@ -243 +252 @@
         }
 
-    elf_dmsg("\n[DBG] %s : open file <%s>\n", __FUNCTION__ , pathname );
+#if (CONFIG_DEBUG_ELF_LOAD & 1)
+if( CONFIG_DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : open file <%s>\n", __FUNCTION__, pathname );
+#endif
 
         // load header in local buffer
@@ -256 +268 @@
         }
 
-        elf_dmsg("\n[DBG] %s : loaded elf header for %s\n", __FUNCTION__ , pathname );
+#if (CONFIG_DEBUG_ELF_LOAD & 1)
+if( CONFIG_DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : loaded elf header for %s\n", __FUNCTION__ , pathname );
+#endif
 
         if( header.e_phnum == 0 )
@@ -293 +308 @@
         }
 
-        elf_dmsg("\n[DBG] %s : segments array allocated for %s\n", __FUNCTION__ , pathname );
+#if (CONFIG_DEBUG_ELF_LOAD & 1)
+if( CONFIG_DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : segments array allocated for %s\n", __FUNCTION__ , pathname );
+#endif
 
         // load seg descriptors array to local buffer
@@ -310 +328 @@
         }
 
-        elf_dmsg("\n[DBG] %s loaded segments descriptors for %s \n", __FUNCTION__ , pathname );
+#if (CONFIG_DEBUG_ELF_LOAD & 1)
+if( CONFIG_DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s loaded segments descriptors for %s \n", __FUNCTION__ , pathname );
+#endif
 
         // register loadable segments in process VMM
@@ -335 +356 @@
         kmem_free(&req);
 
-    elf_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / entry_point = %x\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pathname , header.e_entry );
+#if CONFIG_DEBUG_ELF_LOAD
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_ELF_LOAD < cycle )
+printk("\n[DBG] %s : thread %d exit for <%s> / entry_point %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, pathname, header.e_entry, cycle );
+#endif
 
         return 0;

trunk/kernel/libk/remote_rwlock.c

@@ -41 +41 @@
     hal_remote_sw ( XPTR( lock_cxy , &lock_ptr->count )   , 0 );
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner )   , XPTR_NULL );
     xlist_entry_init( XPTR( lock_cxy , &lock_ptr->list ) );
@@ -86 +86 @@
     thread_ptr->remote_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     xlist_add_first( XPTR( local_cxy , &thread_ptr->xlocks_root ) ,
                      XPTR( lock_cxy ,  &lock_ptr->list ) );
@@ -126 +126 @@
         thread_ptr->remote_locks--;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );
 #endif
@@ -176 +176 @@
     }
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     hal_remote_swd( XPTR( lock_cxy  , &lock_ptr->owner ) ,
                     XPTR( local_cxy , thread_ptr ) );

trunk/kernel/libk/remote_spinlock.c

@@ -39 +39 @@
         hal_remote_sw ( XPTR( cxy , &ptr->taken ) , 0 );
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
         hal_remote_swd( XPTR( cxy , &ptr->owner ) , XPTR_NULL );
         xlist_entry_init( XPTR( cxy , &ptr->list ) );
@@ -76 +76 @@
                 thread_ptr->remote_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
                 hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) ,
                                 XPTR( local_cxy , thread_ptr) );
@@ -121 +121 @@
         thread_ptr->remote_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
         hal_remote_swd( XPTR( lock_cxy  , &lock_ptr->owner ) ,
                         XPTR( local_cxy , thread_ptr) );
@@ -144 +144 @@
         thread_t          * thread_ptr = CURRENT_THREAD;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
         hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) , XPTR_NULL );
         xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );
@@ -197 +197 @@
         thread_ptr->remote_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
         hal_remote_swd( XPTR( lock_cxy  , &lock_ptr->owner ) ,
                         XPTR( local_cxy , thread_ptr) );
@@ -218 +218 @@
         thread_t          * thread_ptr = CURRENT_THREAD;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
         hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) , XPTR_NULL );
         xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );

trunk/kernel/libk/remote_spinlock.h

@@ -72 +72 @@
  * This function releases a remote busy_waiting spinlock.
  * It restores the CPU SR state.
+ * It decrements the calling thread locks count.
  *******************************************************************************************
  * @ lock_xp    : extended pointer on remote spinlock.
@@ -100 +101 @@
 /***************************************************************************************
  * This function releases a remote spinlock.
+ * It decrements the calling thread locks count.
  ***************************************************************************************
  * @ lock_xp    : extended pointer on the remote spinlock

trunk/kernel/libk/rwlock.c

@@ -38 +38 @@
     lock->count   = 0;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
         lock->owner   = NULL;
     list_entry_init( &lock->list ); 
@@ -70 +70 @@
     this->local_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     list_add_first( &this->locks_root , &lock->list );
 #endif
@@ -98 +98 @@
     this->local_locks--;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     list_unlink( &lock->list );
 #endif
@@ -138 +138 @@
     this->local_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     lock->owner = this;
     list_add_first( &this->locks_root , &lock->list );
@@ -157 +157 @@
         hal_disable_irq( &mode );
   
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     lock->owner = NULL;
     list_unlink( &lock->list );

trunk/kernel/libk/spinlock.c

@@ -38 +38 @@
     lock->taken = 0;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     lock->owner = NULL;
     list_entry_init( &lock->list );
@@ -71 +71 @@
     this->local_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     lock->owner = this;
     list_add_first( &this->locks_root , &lock->list );
@@ -86 +86 @@
     thread_t * this = CURRENT_THREAD;;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     lock->owner = NULL;
     list_unlink( &lock->list );
@@ -132 +132 @@
     this->local_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     lock->owner = this;
     list_add_first( &this->locks_root , &lock->list );
@@ -162 +162 @@
         this->local_locks++;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
         lock->owner = this;
         list_add_first( &this->locks_root , &lock->list );
@@ -177 +177 @@
     thread_t * this = CURRENT_THREAD;
 
-#if CONFIG_LOCKS_DEBUG
+#if CONFIG_DEBUG_LOCKS
     lock->owner = NULL;
     list_unlink( &lock->list );

trunk/kernel/mm/kcm.c

@@ -47 +47 @@
                              kcm_page_t * kcm_page )
 {
-        kcm_dmsg("\n[DBG] %s : enters for %s / page %x / count = %d / active = %d\n",
-                 __FUNCTION__ , kmem_type_str( kcm->type ) ,
-                 (intptr_t)kcm_page , kcm_page->count , kcm_page->active );
+
+#if CONFIG_DEBUG_KCM_ALLOC
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_KCM_ALLOC < cycle )
+printk("\n[DBG] %s : thread %x enters for %s / page %x / count %d / active %d\n",
+__FUNCTION__ , CURRENT_THREAD , kmem_type_str( kcm->type ) ,
+(intptr_t)kcm_page , kcm_page->count , kcm_page->active );
+#endif
 
         assert( kcm_page->active , __FUNCTION__ , "kcm_page should be active" );
@@ -80 +85 @@
                      + (index * kcm->block_size) );
 
-        kcm_dmsg("\n[DBG] %s : allocated one block  %s / ptr = %p / page = %x / count = %d\n",
-                 __FUNCTION__ , kmem_type_str( kcm->type ) , ptr ,
-                 (intptr_t)kcm_page , kcm_page->count );
+#if CONFIG_DEBUG_KCM_ALLOC
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_KCM_ALLOC < cycle )
+printk("\n[DBG] %s : thread %x exit / type  %s / ptr %p / page %x / count %d\n",
+__FUNCTION__ , CURRENT_THREAD , kmem_type_str( kcm->type ) , ptr ,
+(intptr_t)kcm_page , kcm_page->count );
+#endif
 
         return ptr;
@@ -300 +309 @@
                 kcm->active_pages_nr ++;
                 kcm_page->active = 1;
-
-                kcm_dmsg("\n[DBG] %s : enters for type %s at cycle %d / new page = %x / count = %d\n",
-                         __FUNCTION__ , kmem_type_str( kcm->type ) , hal_get_cycles() ,
-                         (intptr_t)kcm_page , kcm_page->count );
-
         }
         else                                    // get first page from active list
@@ -310 +314 @@
                 // get page pointer from active list
                 kcm_page = (kcm_page_t *)LIST_FIRST( &kcm->active_root , kcm_page_t , list );
-
-                kcm_dmsg("\n[DBG] %s : enters for type %s at cycle %d / page = %x / count = %d\n",
-                         __FUNCTION__ , kmem_type_str( kcm->type ) , hal_get_cycles() ,
-                         (intptr_t)kcm_page , kcm_page->count );
         }
 

trunk/kernel/mm/kmem.c

@@ -198 +198 @@
         if( type == KMEM_PAGE )                        // PPM allocator
         {
+
+#if CONFIG_DEBUG_KMEM_ALLOC
+if( CONFIG_DEBUG_KMEM_ALLOC < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x enter for %d page(s)\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<size );
+#endif
+
                 // allocate the number of requested pages
                 ptr = (void *)ppm_alloc_pages( size );
@@ -213 +220 @@
                           __FUNCTION__, local_cxy , kmem_type_str( type ) ,
                           (intptr_t)ptr , (intptr_t)ppm_page2base( ptr ) );
+
+#if CONFIG_DEBUG_KMEM_ALLOC
+if( CONFIG_DEBUG_KMEM_ALLOC < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x exit / %d page(s) allocated / ppn = %x\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<size , ppm_page2ppn( XPTR( local_cxy , ptr ) ) );
+#endif
+
         }
         else if( type == KMEM_GENERIC )                // KHM allocator

trunk/kernel/mm/page.c

@@ -47 +47 @@
         page->index    = 0;
         page->refcount = 0;
-        page->fork_nr  = 0;
+        page->forks    = 0;
 
         spinlock_init( &page->lock );

trunk/kernel/mm/page.h

@@ -56 +56 @@
  * This structure defines a physical page descriptor.
  * Size is 64 bytes for a 32 bits core...
+ * TODO : the list of waiting threads seems to be unused [AG]
+ $ TODO : the spinlock use has to be clarified [AG]
  ************************************************************************************/
 
@@ -67 +69 @@
     xlist_entry_t     wait_root;      /*! root of list of waiting threads      (16) */
         uint32_t          refcount;       /*! reference counter                    (4)  */
-        uint32_t          fork_nr;        /*! number of pending forks              (4)  */
-        spinlock_t        lock;           /*! only used to set the PG_LOCKED flag  (16) */
+        uint32_t          forks;          /*! number of pending forks              (4)  */
+        spinlock_t        lock;           /*! To Be Defined [AG]                   (16) */
 }
 page_t;

trunk/kernel/mm/ppm.c

@@ -193 +193 @@
         list_add_first( &ppm->free_pages_root[current_order] , &current->list );
         ppm->free_pages_nr[current_order] ++;
-}
+
+}  // end ppm_free_pages_nolock()
 
 ////////////////////////////////////////////
@@ -201 +202 @@
         page_t   * remaining_block;
         uint32_t   current_size;
+ 
+#if CONFIG_DEBUG_PPM_ALLOC_PAGES
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x enter for %d page(s) / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<order, cycle );
+#endif
+
+#if(CONFIG_DEBUG_PPM_ALLOC_PAGES & 0x1)
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+ppm_print();
+#endif
 
         ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
@@ -208 +221 @@
 
         page_t * block = NULL;  
-
-        ppm_dmsg("\n[DBG] %s : enters / order = %d\n",
-                 __FUNCTION__ , order );
 
         // take lock protecting free lists
@@ -231 +241 @@
                 spinlock_unlock( &ppm->free_lock );
 
+#if CONFIG_DEBUG_PPM_ALLOC_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x cannot allocate %d page(s) at cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<order, cycle );
+#endif
+
                 return NULL;
         }
@@ -260 +277 @@
         spinlock_unlock( &ppm->free_lock );
 
-        ppm_dmsg("\n[DBG] %s : base = %x / order = %d\n",
-                 __FUNCTION__ , (uint32_t)ppm_page2base( block ) , order );
+#if CONFIG_DEBUG_PPM_ALLOC_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_ALLOC_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x exit / %d page(s) allocated / ppn = %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, 1<<order, ppm_page2ppn(XPTR( local_cxy , block )), cycle );
+#endif
 
         return block;
-}
+
+}  // end ppm_alloc_pages()
 
 
@@ -272 +294 @@
         ppm_t * ppm = &LOCAL_CLUSTER->ppm;
 
+#if CONFIG_DEBUG_PPM_FREE_PAGES
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_FREE_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x enter for %d page(s) / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , 1<<page->order , cycle );
+#endif
+
+#if(CONFIG_DEBUG_PPM_FREE_PAGES & 0x1)
+if( CONFIG_DEBUG_PPM_FREE_PAGES < cycle )
+ppm_print();
+#endif
+
         // get lock protecting free_pages[] array
         spinlock_lock( &ppm->free_lock );
@@ -279 +313 @@
         // release lock protecting free_pages[] array
         spinlock_unlock( &ppm->free_lock );
+
+#if CONFIG_DEBUG_PPM_FREE_PAGES
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_PPM_FREE_PAGES < cycle )
+printk("\n[DBG] in %s : thread %x exit / %d page(s) released / ppn = %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, 1<<page->order, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
+#endif
+
 }
 
-////////////////////////////
-void ppm_print( ppm_t * ppm,
-                char  * string )
+////////////////
+void ppm_print()
 {
         uint32_t       order;
@@ -289 +330 @@
         page_t       * page;
 
+    ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
         // get lock protecting free lists
         spinlock_lock( &ppm->free_lock );
 
-        printk("\n***  PPM in cluster %x : %d pages / &pages_tbl = %x / vaddr_base = %x ***\n",
-    local_cxy , ppm->pages_nr , (intptr_t)ppm->pages_tbl , (intptr_t)ppm->vaddr_base );
+        printk("\n***  PPM in cluster %x : %d pages ***\n", local_cxy , ppm->pages_nr );
 
         for( order = 0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )
         {
-                printk("- order = %d / free_pages = %d  [",
+                printk("- order = %d / free_pages = %d\t: ",
                        order , ppm->free_pages_nr[order] );
 
@@ -303 +345 @@
                 {
                         page = LIST_ELEMENT( iter , page_t , list );
-                        printk("%d," , page - ppm->pages_tbl );
+                        printk("%x," , page - ppm->pages_tbl );
                 }
 
-                printk("]\n", NULL );
+                printk("\n");
         }
 

trunk/kernel/mm/ppm.h

@@ -52 +52 @@
  * from the "kernel_heap" section.
  * This low-level allocator implements the buddy algorithm: an allocated block is
- * an integer number n of 4 Kbytes pages, and n (called order) is a power of 2.
+ * an integer number n of 4 small pages, and n (called order) is a power of 2.
  ****************************************************************************************/
 
@@ -163 +163 @@
 
 /*****************************************************************************************
- * This function prints the PPM allocator status.
- *****************************************************************************************
- * @ ppm      : pointer on PPM allocator.
- * @ string   : define context of display.
+ * This function prints the PPM allocator status in the calling thread cluster.
  ****************************************************************************************/
-void ppm_print( ppm_t * ppm,
-                char  * string );
+void ppm_print();
 
 /*****************************************************************************************

trunk/kernel/mm/vmm.c

@@ -63 +63 @@
     intptr_t  size;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n", 
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_VMM_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_INIT )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
 
     // get pointer on VMM
@@ -179 +183 @@
     hal_fence();
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x / entry_point = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , 
-process->pid , process->vmm.entry_point );
+#if CONFIG_DEBUG_VMM_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_INIT )
+printk("\n[DBG] %s : thread %x exit for process %x / entry_point = %x / cycle %d\n", 
+__FUNCTION__ , CURRENT_THREAD , process->pid , process->vmm.entry_point , cycle );
+#endif
 
     return 0;
@@ -211 +218 @@
     {
         vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        vseg    = GET_PTR( vseg_xp );
 
         printk(" - %s : base = %X / size = %X / npages = %d\n",
@@ -239 +246 @@
 }  // vmm_display()
 
-/////////////////////i////////////////////
-void vmm_update_pte( process_t * process,
-                     vpn_t       vpn,
-                     uint32_t    attr,
-                     ppn_t       ppn )
+/////////////////////i//////////////////////////
+void vmm_global_update_pte( process_t * process,
+                            vpn_t       vpn,
+                            uint32_t    attr,
+                            ppn_t       ppn )
 {
 
@@ -258 +265 @@
     cxy_t           owner_cxy;
     lpid_t          owner_lpid;
+
+#if CONFIG_DEBUG_VMM_UPDATE_PTE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UPDATE_PTE < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / vpn %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , vpn , cycle );
+#endif
+
+    // check cluster is reference
+    assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__,
+    "not called in reference cluster\n");
 
     // get extended pointer on root of process copies xlist in owner cluster
@@ -271 +289 @@
         // get cluster and local pointer on remote process
         remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
-        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_ptr = GET_PTR( remote_process_xp );
         remote_process_cxy = GET_CXY( remote_process_xp );
+
+#if (CONFIG_DEBUG_VMM_UPDATE_PTE & 0x1)
+if( CONFIG_DEBUG_VMM_UPDATE_PTE < cycle )
+printk("\n[DBG] %s : thread %x handling process %x in cluster %x\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , remote_process_cxy );
+#endif
 
         // get extended pointer on remote gpt
         remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
 
-        hal_gpt_update_pte( remote_gpt_xp,
-                            vpn,
-                            attr,
-                            ppn );
+        // update remote GPT
+        hal_gpt_update_pte( remote_gpt_xp, vpn, attr, ppn );
     }  
-}  // end vmm_update_pte()
+
+#if CONFIG_DEBUG_VMM_UPDATE_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UPDATE_PTE < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / vpn %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , vpn , cycle );
+#endif
+
+}  // end vmm_global_update_pte()
 
 ///////////////////////////////////////
@@ -308 +338 @@
     lpid_t          owner_lpid;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_VMM_SET_COW
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
 
     // check cluster is reference
@@ -333 +367 @@
         // get cluster and local pointer on remote process
         remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
-        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_ptr = GET_PTR( remote_process_xp );
         remote_process_cxy = GET_CXY( remote_process_xp );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] handling process %x in cluster %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid , remote_process_cxy );
+#if (CONFIG_DEBUG_VMM_SET_COW &0x1)
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x handling process %x in cluster %x\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , remote_process_cxy );
+#endif
 
         // get extended pointer on remote gpt
@@ -347 +384 @@
             // get pointer on vseg
             vseg_xp  = XLIST_ELEMENT( vseg_iter_xp , vseg_t , xlist );
-            vseg     = (vseg_t *)GET_PTR( vseg_xp );
+            vseg     = GET_PTR( vseg_xp );
 
             assert( (GET_CXY( vseg_xp ) == local_cxy) , __FUNCTION__,
@@ -357 +394 @@
             vpn_t    vpn_size = vseg->vpn_size;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] handling vseg %s / vpn_base = %x / vpn_size = %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vseg_type_str(type), vpn_base, vpn_size );
-
-            // set COW flag on the remote GPT depending on vseg type
+#if (CONFIG_DEBUG_VMM_SET_COW & 0x1)
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x handling vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, CURRENT_THREAD , vseg_type_str(type), vpn_base, vpn_size );
+#endif
+            // only DATA, ANON and REMOTE vsegs
             if( (type == VSEG_TYPE_DATA)  ||
                 (type == VSEG_TYPE_ANON)  ||
                 (type == VSEG_TYPE_REMOTE) )
             {
-                hal_gpt_flip_cow( true,             // set_cow
-                                  remote_gpt_xp,
-                                  vpn_base,
-                                  vpn_size );
-            }
-        }    // en loop on vsegs
+                vpn_t      vpn;
+                uint32_t   attr;
+                ppn_t      ppn;
+                xptr_t     page_xp;
+                cxy_t      page_cxy;
+                page_t   * page_ptr;
+                xptr_t     forks_xp;
+
+                // update flags in remote GPT 
+                hal_gpt_set_cow( remote_gpt_xp,
+                                 vpn_base,
+                                 vpn_size ); 
+
+                // atomically increment pending forks counter in physical pages,
+                // for all vseg pages that are mapped in reference cluster 
+                if( remote_process_cxy == local_cxy )
+                {
+                    // the reference GPT is the local GPT
+                    gpt_t * gpt = GET_PTR( remote_gpt_xp );
+
+                    // scan all pages in vseg 
+                    for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
+                    {
+                        // get page attributes and PPN from reference GPT
+                        hal_gpt_get_pte( gpt , vpn , &attr , &ppn ); 
+
+                        // atomically update pending forks counter if page is mapped
+                        if( attr & GPT_MAPPED )
+                        {
+                            page_xp  = ppm_ppn2page( ppn );
+                            page_cxy = GET_CXY( page_xp );
+                            page_ptr = GET_PTR( page_xp );
+                            forks_xp = XPTR( page_cxy , &page_ptr->forks );
+                            hal_remote_atomic_add( forks_xp , 1 );
+                        }
+                    }   // end loop on vpn
+                }   // end if local
+            }   // end if vseg type
+        }   // end loop on vsegs
     }   // end loop on process copies
  
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+#if CONFIG_DEBUG_VMM_SET_COW
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_SET_COW < cycle )
+printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
 
 }  // end vmm_set-cow()
@@ -404 +480 @@
     ppn_t       ppn;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
+#if CONFIG_DEBUG_VMM_FORK_COPY
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x enter / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, cycle );
+#endif
 
     // get parent process cluster and local pointer
     parent_cxy     = GET_CXY( parent_process_xp );
-    parent_process = (process_t *)GET_PTR( parent_process_xp );
+    parent_process = GET_PTR( parent_process_xp );
 
     // get local pointers on parent and child VMM
@@ -445 +525 @@
         // get local and extended pointers on current parent vseg
         parent_vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        parent_vseg    = (vseg_t *)GET_PTR( parent_vseg_xp );
+        parent_vseg    = GET_PTR( parent_vseg_xp );
 
         // get vseg type
         type = hal_remote_lw( XPTR( parent_cxy , &parent_vseg->type ) );
         
-
-vmm_dmsg("\n[DBG] %s : core[%x,%d] found parent vseg %s / vpn_base = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
-hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x found parent vseg %s / vpn_base = %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD, vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) , cycle );
+#endif
 
         // all parent vsegs - but STACK - must be copied in child VSL
@@ -473 +556 @@
             vseg_attach( child_vmm , child_vseg );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child VSL : vseg %s / vpn_base = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
-hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x copied vseg %s / vpn_base = %x to child VSL / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) , cycle );
+#endif
 
             // copy DATA, MMAP, REMOTE, FILE parent GPT entries to child GPT
@@ -502 +589 @@
                     }
 
-                    // increment page descriptor fork_nr for the referenced page if mapped
+                    // increment pending forks counter in page if mapped
                     if( mapped )
                     {
                         page_xp = ppm_ppn2page( ppn );
                         page_cxy = GET_CXY( page_xp );
-                        page_ptr = (page_t *)GET_PTR( page_xp );
-                        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , 1 );
-
-vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child GPT : vpn %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+                        page_ptr = GET_PTR( page_xp );
+                        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->forks ) , 1 );
+
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x copied vpn %x to child GPT / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , vpn , cycle );
+#endif
 
                     }
@@ -558 +649 @@
     hal_fence();
 
+#if CONFIG_DEBUG_VMM_FORK_COPY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_FORK_COPY < cycle )
+printk("\n[DBG] %s : thread %x exit successfully / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
+
     return 0;
 
@@ -568 +666 @@
         vseg_t * vseg;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
-
-    // get pointer on VMM
+#if CONFIG_DEBUG_VMM_DESTROY
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_DESTROY < cycle )
+printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , process->pid , cycle );
+#endif
+
+    // get pointer on local VMM
     vmm_t  * vmm = &process->vmm;
 
@@ -586 +688 @@
         // get pointer on first vseg in VSL
                 vseg_xp = XLIST_FIRST_ELEMENT( root_xp , vseg_t , xlist );
-        vseg = (vseg_t *)GET_PTR( vseg_xp );
-
-        // unmap and release all pages
+        vseg    = GET_PTR( vseg_xp );
+
+        // unmap rand release physical pages if required)
         vmm_unmap_vseg( process , vseg );
 
@@ -598 +700 @@
         }
 
-    // release lock
+    // release lock protecting VSL
         remote_rwlock_wr_unlock( lock_xp );
 
@@ -616 +718 @@
     hal_gpt_destroy( &vmm->gpt );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
+#if CONFIG_DEBUG_VMM_DESTROY
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_DESTROY < cycle )
+printk("\n[DBG] %s : thread %x exit / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , cycle );
+#endif
 
 }  // end vmm_destroy()
@@ -637 +743 @@
         {
                 vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        vseg    = GET_PTR( vseg_xp );
 
                 if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
@@ -766 +872 @@
         error_t      error;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enters / process %x / base %x / size %x / %s / cxy = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
-process->pid , base , size , vseg_type_str(type) , cxy );
+#if CONFIG_DEBUG_VMM_CREATE_VSEG
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_CREATE_VSEG < cycle )
+printk("\n[DBG] %s : thread %x enter / process %x / base %x / size %x / %s / cxy %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, base, size, vseg_type_str(type), cxy, cycle );
+#endif
 
     // get pointer on VMM 
@@ -854 +963 @@
         remote_rwlock_wr_unlock( lock_xp );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / base %x / size %x / type %s\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
-process->pid , base , size , vseg_type_str(type) );
+#if CONFIG_DEBUG_VMM_CREATE_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_CREATE_VSEG < cycle )
+printk("\n[DBG] %s : thread %x exit / process %x / %s / cxy %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, vseg_type_str(type), cxy, cycle );
+#endif
 
         return vseg;
@@ -985 +1097 @@
     cxy_t       page_cxy;   // page descriptor cluster
     page_t    * page_ptr;   // page descriptor pointer
-
-vmm_dmsg("\n[DBG] %s : core[%x, %d] enter / process %x / vseg %s / base %x / cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid ,
-vseg_type_str( vseg->type ), vseg->vpn_base, (uint32_t)hal_get_cycles() );
-
-    // get pointer on process GPT
+    xptr_t      forks_xp;   // extended pointer on pending forks counter
+    uint32_t    count;      // actual number of pendinf forks
+
+#if CONFIG_DEBUG_VMM_UNMAP_VSEG
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UNMAP_VSEG < cycle )
+printk("\n[DBG] %s : thread %x enter / process %x / vseg %s / base %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, vseg_type_str( vseg->type ), vseg->vpn_base, cycle );
+#endif
+
+    // get pointer on local GPT
     gpt_t     * gpt = &process->vmm.gpt;
 
@@ -1007 +1124 @@
             "an user vseg must use small pages" );
 
-            // unmap GPT entry
+            // unmap GPT entry in all GPT copies
             hal_gpt_reset_pte( gpt , vpn );
 
-            // release memory if not identity mapped
-            if( (vseg->flags & VSEG_IDENT)  == 0 )
+            // handle pending forks counter if
+            // 1) not identity mapped
+            // 2) running in reference cluster
+            if( ((vseg->flags & VSEG_IDENT)  == 0) &&
+                (GET_CXY( process->ref_xp ) == local_cxy) )
             {
-                // get extended pointer on page descriptor
+                // get extended pointer on physical page descriptor
                 page_xp  = ppm_ppn2page( ppn );
                 page_cxy = GET_CXY( page_xp );
-                page_ptr = (page_t *)GET_PTR( page_xp );
-
-                // release physical page to relevant cluster
-                if( page_cxy == local_cxy )                   // local cluster
+                page_ptr = GET_PTR( page_xp );
+
+                // FIXME lock the physical page
+
+                // get extended pointer on pending forks counter
+                forks_xp = XPTR( page_cxy , &page_ptr->forks );
+
+                // get pending forks counter
+                count = hal_remote_lw( forks_xp );
+                
+                if( count )  // decrement pending forks counter
                 {
-                    req.type = KMEM_PAGE;
-                    req.ptr  = page_ptr; 
-                    kmem_free( &req );
+                    hal_remote_atomic_add( forks_xp , -1 );
+                }  
+                else         // release physical page to relevant cluster
+                {
+                    if( page_cxy == local_cxy )   // local cluster
+                    {
+                        req.type = KMEM_PAGE;
+                        req.ptr  = page_ptr; 
+                        kmem_free( &req );
+                    }
+                    else                          // remote cluster
+                    {
+                        rpc_pmem_release_pages_client( page_cxy , page_ptr );
+                    }
                 }
-                else                                          // remote cluster
-                {
-                    rpc_pmem_release_pages_client( page_cxy , page_ptr );
-                }
+
+                // FIXME unlock the physical page
             }
         }
     }
+
+#if CONFIG_DEBUG_VMM_UNMAP_VSEG
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_UNMAP_VSEG < cycle )
+printk("\n[DBG] %s : thread %x exit / process %x / vseg %s / base %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, process->pid, vseg_type_str( vseg->type ), vseg->vpn_base, cycle );
+#endif
+
 }  // end vmm_unmap_vseg()
 
@@ -1061 +1205 @@
     {
         vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        vseg    = GET_PTR( vseg_xp );
         if( (vaddr >= vseg->min) && (vaddr < vseg->max) )
         {
@@ -1185 +1329 @@
         // get cluster and local pointer on reference process 
         cxy_t       ref_cxy = GET_CXY( ref_xp );
-        process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+        process_t * ref_ptr = GET_PTR( ref_xp );
 
         if( local_cxy == ref_cxy )  return -1;   // local cluster is the reference
@@ -1224 +1368 @@
                                  vpn_t    vpn )
 {
+
+#if CONFIG_DEBUG_VMM_ALLOCATE_PAGE
+if( CONFIG_DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x enter for vpn %x\n",
+__FUNCTION__ , CURRENT_THREAD, vpn );
+#endif
+
     // compute target cluster
     page_t     * page_ptr;
@@ -1262 +1413 @@
     }
 
+#if CONFIG_DEBUG_VMM_ALLOCATE_PAGE
+if( CONFIG_DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] in %s : thread %x exit for vpn = %d / ppn = %x\n",
+__FUNCTION__ , CURRENT_THREAD, vpn, ppm_page2ppn( XPTR( page_cxy , page_ptr ) ) );
+#endif
+
     if( page_ptr == NULL ) return XPTR_NULL;
     else                   return XPTR( page_cxy , page_ptr );
@@ -1281 +1438 @@
     index     = vpn - vseg->vpn_base;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x / type = %s / index = %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, vseg_type_str(type), index );
+#if CONFIG_DEBUG_VMM_GET_ONE_PPN 
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x enter for vpn = %x / type = %s / index = %d\n",
+__FUNCTION__, CURRENT_THREAD, vpn, vseg_type_str(type), index );
+#endif
 
     // FILE type : get the physical page from the file mapper
@@ -1295 +1455 @@
         // get mapper cluster and local pointer
         cxy_t      mapper_cxy = GET_CXY( mapper_xp );
-        mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
+        mapper_t * mapper_ptr = GET_PTR( mapper_xp );
 
         // get page descriptor from mapper
@@ -1316 +1476 @@
     else
     {
-        // allocate physical page 
+        // allocate one physical page 
         page_xp = vmm_page_allocate( vseg , vpn );
 
@@ -1322 +1482 @@
 
         // initialise missing page from .elf file mapper for DATA and CODE types
-        // => the mapper_xp field is an extended pointer on the .elf file mapper
+        // (the vseg->mapper_xp field is an extended pointer on the .elf file mapper)
         if( (type == VSEG_TYPE_CODE) || (type == VSEG_TYPE_DATA) )
         {
@@ -1333 +1493 @@
             // get mapper cluster and local pointer
             cxy_t      mapper_cxy = GET_CXY( mapper_xp );
-            mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
+            mapper_t * mapper_ptr = GET_PTR( mapper_xp );
 
             // compute missing page offset in vseg
@@ -1341 +1501 @@
             uint32_t elf_offset = vseg->file_offset + offset;
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / elf_offset = %x\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, elf_offset );
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x for vpn = %x / elf_offset = %x\n",
+__FUNCTION__, CURRENT_THREAD, vpn, elf_offset );
+#endif
 
             // compute extended pointer on page base 
@@ -1352 +1515 @@
             if( file_size < offset )                 // missing page fully in  BSS 
             {
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in BSS\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
+
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread%x for vpn = %x / fully in BSS\n",
+__FUNCTION__, CURRENT_THREAD, vpn );
+#endif
 
                 if( GET_CXY( page_xp ) == local_cxy )
@@ -1367 +1534 @@
             {
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in mapper\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x, for vpn = %x / fully in mapper\n",
+__FUNCTION__, CURRENT_THREAD, vpn );
+#endif
 
                 if( mapper_cxy == local_cxy ) 
@@ -1396 +1566 @@
             {
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / both mapper & BSS\n"
-         "      %d bytes from mapper / %d bytes from BSS\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn,
+#if (CONFIG_DEBUG_VMM_GET_ONE_PPN & 0x1)
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x for vpn = %x / both mapper & BSS\n"
+"      %d bytes from mapper / %d bytes from BSS\n",
+__FUNCTION__, CURRENT_THREAD, vpn,
 file_size - offset , offset + CONFIG_PPM_PAGE_SIZE - file_size  );
-
+#endif
                 // initialize mapper part
                 if( mapper_cxy == local_cxy )
@@ -1441 +1613 @@
     *ppn = ppm_page2ppn( page_xp );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for vpn = %x / ppn = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , *ppn );
+#if CONFIG_DEBUG_VMM_GET_ONE_PPN
+if( CONFIG_DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
+printk("\n[DBG] %s : thread %x exit for vpn = %x / ppn = %x\n",
+__FUNCTION__ , CURRENT_THREAD , vpn , *ppn );
+#endif
 
     return 0;
@@ -1455 +1630 @@
                      ppn_t     * ppn )
 {
-    vseg_t  * vseg;       // pointer on vseg containing VPN
+    vseg_t  * vseg;       // vseg containing VPN
     ppn_t     old_ppn;    // current PTE_PPN
     uint32_t  old_attr;   // current PTE_ATTR
@@ -1466 +1641 @@
     "not called in the reference cluster\n" );
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x in process %x / cow = %d\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid , cow );
+#if CONFIG_DEBUG_VMM_GET_PTE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE > cycle )
+printk("\n[DBG] %s : thread %x enter for vpn = %x / process %x / cow = %d / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , vpn , process->pid , cow , cycle );
+#endif
 
     // get VMM pointer
     vmm_t * vmm = &process->vmm;
 
-    // get vseg pointer from ref VSL
+    // get vseg pointer from reference VSL
     error = vmm_get_vseg( process , vpn<<CONFIG_PPM_PAGE_SHIFT , &vseg );
 
@@ -1482 +1661 @@
     }
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] found vseg %s / vpn_base = %x / vpn_size = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
-vseg_type_str(vseg->type) , vseg->vpn_base , vseg->vpn_size );
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread %x found vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, CURRENT_THREAD, vseg_type_str(vseg->type), vseg->vpn_base, vseg->vpn_size );
+#endif
 
     // access GPT to get current PTE attributes and PPN
@@ -1493 +1675 @@
     // clusters containing a copy, and return the new_ppn and new_attr
 
-    if( cow )               ////////////// copy_on_write request ///////////
+    if( cow )  /////////////////////////// copy_on_write request //////////////////////
     {
         assert( (old_attr & GPT_MAPPED) , __FUNCTION__ , 
         "PTE must be mapped for a copy-on-write exception\n" );
 
-excp_dmsg("\n[DBG] %s : core[%x,%d] handling COW for vpn %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
-
-        // get extended pointer, cluster and local pointer on page descriptor
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread %x handling COW for vpn %x in process %x\n",
+__FUNCTION__, CURRENT_THREAD, vpn, process->pid );
+#endif
+
+        // get extended pointer, cluster and local pointer on physical page descriptor
         xptr_t   page_xp  = ppm_ppn2page( old_ppn );
         cxy_t    page_cxy = GET_CXY( page_xp );
-        page_t * page_ptr = (page_t *)GET_PTR( page_xp );
+        page_t * page_ptr = GET_PTR( page_xp );
 
         // get number of pending forks in page descriptor
-        uint32_t count = hal_remote_lw( XPTR( page_cxy , &page_ptr->fork_nr ) );
-
-        if( count )        // pending fork => allocate a new page, copy it, reset COW
+        uint32_t forks = hal_remote_lw( XPTR( page_cxy , &page_ptr->forks ) );
+
+        if( forks )        // pending fork => allocate a new page, copy old to new
         {
             // allocate a new physical page
@@ -1539 +1725 @@
 
         // update GPT[vpn] for all GPT copies
-        // to maintain coherence of copies
-        vmm_update_pte( process,
-                        vpn,
-                        new_attr,
-                        new_ppn );
-
-        // decrement fork_nr in page descriptor
-        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , -1 );
-    }
-    else                         /////////////// page_fault request ///////////
+        vmm_global_update_pte( process, vpn, new_attr, new_ppn );
+
+        // decrement pending forks counter in page descriptor
+        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->forks ) , -1 );
+    }
+    else  ////////////////////////////////// page_fault request ////////////////////////
     {  
         if( (old_attr & GPT_MAPPED) == 0 )   // true page_fault => map it
         {
 
-excp_dmsg("\n[DBG] %s : core[%x,%d] handling page fault for vpn %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread %x handling page fault for vpn %x in process %x\n",
+__FUNCTION__, CURRENT_THREAD, vpn, process->pid );
+#endif
 
             // allocate new_ppn, depending on vseg type
@@ -1592 +1778 @@
     }
 
-excp_dmsg("\n[DBG] %s : core[%x,%d] update GPT for vpn %x / ppn = %x / attr = %x\n",
-__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , new_ppn , new_attr );
-
-    // retur success
+#if CONFIG_DEBUG_VMM_GET_PTE
+cycle = (uint32_t)hal_get_cycles();
+if( CONFIG_DEBUG_VMM_GET_PTE < cycle )
+printk("\n[DBG] %s : thread,%x exit for vpn %x in process %x / ppn = %x / attr = %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD, vpn, process->pid, new_ppn, new_attr, cycle );
+#endif
+
+    // return success
     *ppn  = new_ppn;
     *attr = new_attr;
@@ -1612 +1802 @@
     // get reference process cluster and local pointer
     cxy_t       ref_cxy = GET_CXY( process->ref_xp );
-    process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
+    process_t * ref_ptr = GET_PTR( process->ref_xp );
 
     // get missing PTE attributes and PPN from reference cluster
@@ -1651 +1841 @@
                         vpn_t       vpn )
 {
-    uint32_t         attr;          // missing page attributes
-    ppn_t            ppn;           // missing page PPN
+    uint32_t         attr;          // page attributes
+    ppn_t            ppn;           // page PPN
     error_t          error;
 
+    
     // get reference process cluster and local pointer
     cxy_t       ref_cxy = GET_CXY( process->ref_xp );
-    process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
+    process_t * ref_ptr = GET_PTR( process->ref_xp );
 
     // get new PTE attributes and PPN from reference cluster
@@ -1722 +1913 @@
     {
         cxy_t       ref_cxy = GET_CXY( process->ref_xp );
-        process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
+        process_t * ref_ptr = GET_PTR( process->ref_xp );
         rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , false , &attr , &ppn , &error );
     }

trunk/kernel/mm/vmm.h

@@ -99 +99 @@
  *    a remote_rwlock, because it can be accessed by a thread running in a remote cluster.
  *    An exemple is the vmm_fork_copy() function.
- * 2. In most custers, the VSL and GPT are only partial copies of the reference VSL and GPT
+ * 2. In most clusters, the VSL and GPT are only partial copies of the reference VSL and GPT
  *    structures, stored in the reference cluster.
  ********************************************************************************************/
@@ -155 +155 @@
 
 /*********************************************************************************************
- * This function is called by the process_fork_create() function. It partially copies
+ * This function is called by the process_make_fork() function. It partially copies
  * the content of a remote parent process VMM to the local child process VMM:
  * - all DATA, MMAP, REMOTE vsegs registered in the parent VSL are registered in the child
@@ -176 +176 @@
 
 /*********************************************************************************************
- * This function is called by the process_make_fork() function to handle the fork syscall.
+ * This function is called by the process_make_fork() function executing the fork syscall.
  * It set the COW flag, and reset the WRITABLE flag of all GPT entries of the DATA, MMAP,
  * and REMOTE vsegs of a process identified by the <process> argument.
  * It must be called by a thread running in the reference cluster, that contains the complete
- * list of vsegs. Use the rpc_vmm_set_cow_client() when the calling thread client is remote. 
+ * VSL and GPT (use the rpc_vmm_set_cow_client() when the calling thread client is remote). 
  * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
  * using the list of copies stored in the owner process, and using remote_write accesses to
- * update the remote GPTs. It cannot fail, as only mapped entries in GPT copies are updated.
+ * update the remote GPTs. It atomically increment the pending_fork counter, in all involved
+ * physical page descriptors. It cannot fail, as only mapped entries in GPTs are updated.
  *********************************************************************************************
  * @ process   : local pointer on local reference process descriptor.
@@ -190 +191 @@
 
 /*********************************************************************************************
- * This function is called by the vmm_get_pte() function in case of COW exception.
- * It modifies both the PPN an the attributes for a GPT entry identified by the <process>
- * and <vpn> arguments. 
+ * This global function modifies a GPT entry identified  by the <process> and <vpn> 
+ * arguments in all clusters containing a process copy.
+ * It must be called by a thread running in the reference cluster.
  * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
  * using the list of copies stored in the owner process, and using remote_write accesses to
@@ -202 +203 @@
  * @ ppn       : PTE / physical page index.
  ********************************************************************************************/
-void vmm_update_pte( struct process_s * process,
-                     vpn_t              vpn,
-                     uint32_t           attr,
-                     ppn_t              ppn );
-
-/*********************************************************************************************
- * This function scan the list of vsegs registered in the VSL of the process 
- * identified by the <process> argument, and for each vseg:
- * - it unmap from the GPT and releases all mapped pages in vseg.
- * - it removes the vseg from the process VSL.
- * - It releases the memory allocated to the vseg descriptor.
+void vmm_global_update_pte( struct process_s * process,
+                            vpn_t              vpn,
+                            uint32_t           attr,
+                            ppn_t              ppn );
+
+/*********************************************************************************************
+ * This function unmaps from the local GPT all mapped PTEs of a vseg identified by the
+ * <process> and <vseg> arguments. It can be used for any type of vseg.
+ * If this function is executed in the reference cluster, it handles for each referenced 
+ * physical pages the pending forks counter :
+ * - if counter is non-zero, it decrements it.
+ * - if counter is zero, it releases the physical page to local kmem allocator.
+ *********************************************************************************************
+ * @ process  : pointer on process descriptor.
+ * @ vseg     : pointer on the vseg to be unmapped.
+ ********************************************************************************************/
+void vmm_unmap_vseg( struct process_s * process,
+                     vseg_t           * vseg );
+
+/*********************************************************************************************
+ * This function deletes, in the local cluster, all vsegs registered in the VSL
+ * of the process identified by the <process> argument. For each vseg:
+ * - it unmaps all vseg PTEs from the GPT (release the physical pages when required). 
+ * - it removes the vseg from the local VSL.
+ * - it releases the memory allocated to the local vseg descriptors.
  * Finally, it releases the memory allocated to the GPT itself.
  *********************************************************************************************
@@ -291 +306 @@
 
 /*********************************************************************************************
- * This function unmaps all mapped PTEs of a given vseg, from the generic page table 
- * associated to a given process descriptor, and releases the physical memory allocated
- * to all mapped GPT entries.  It can be used for any type of vseg.
- *********************************************************************************************
- * @ process  : pointer on process descriptor.
- * @ vseg     : pointer on the vseg to be unmapped.
- ********************************************************************************************/
-void vmm_unmap_vseg( struct process_s * process,
-                     vseg_t           * vseg );
-
-/*********************************************************************************************
  * This function removes a given region (defined by a base address and a size) from
  * the VMM of a given process descriptor. This can modify the number of vsegs:
@@ -340 +344 @@
 /*********************************************************************************************
  * This function is called by the generic exception handler when a page-fault event
- * has been detected in a given cluster. 
+ * has been detected for a given process in a given cluster.
  * - If the local cluster is the reference, it call directly the vmm_get_pte() function.
  * - If the local cluster is not the reference cluster, it send a RPC_VMM_GET_PTE
@@ -355 +359 @@
 /*********************************************************************************************
  * This function is called by the generic exception handler when a copy-on-write event
- * has been detected in a given cluster. 
- * - If the local cluster is the reference, it call directly the vmm_get_pte() function.
- * - If the local cluster is not the reference cluster, it send a RPC_VMM_GET_PTE
- *   to the reference cluster to get the missing PTE attributes and PPN,
- *   and update the local page table. 
+ * has been detected for a given process in a given cluster.
+ * It takes the lock protecting the physical page, and test the pending forks counter.
+ * If no pending fork:
+ * - it reset the COW flag and set the WRITE flag in the reference GPT entry, and in all
+ *   the GPT copies
+
+ * If there is a pending forkon the
+ * - It get the involved vseg pointer. 
+ * - It allocates a new physical page from the cluster defined by the vseg type.
+ * - It copies the old physical page content to the new physical page.
+ * - It decrements the pending_fork counter in old physical page descriptor.
+
  *********************************************************************************************
  * @ process   : pointer on process descriptor.
@@ -369 +380 @@
 
 /*********************************************************************************************
- * This function is called when a new PTE (GPT entry) is required because a "page-fault",
- * or "copy-on_write" event has been detected for a given <vpn> in a given <process>. 
- * The <cow> argument defines the type of event to be handled. 
+ * This function handle both the "page-fault" and "copy-on_write" events for a given <vpn> 
+ * in a given <process>.  The <cow> argument defines the type of event to be handled. 
  * This function must be called by a thread running in reference cluster, and the vseg
- * containing the searched VPN should be registered in the reference VMM.
- * - for an actual page-fault, it allocates the missing physical page from the target cluster
- *   defined by the vseg type, initialize it, and update the reference page table. 
+ * containing the searched VPN must be registered in the reference VMM.
+ * - for an page-fault, it allocates the missing physical page from the target cluster
+ *   defined by the vseg type, initializes it, and updates the reference GPT, but not
+ *   the copies GPT, that will be updated on demand. 
  * - for a copy-on-write, it allocates a new physical page from the target cluster,
- *   initialise it from the old physical page, and update the reference page table. 
- * In both cases, it calls the RPC_PMEM_GET_PAGES to get the new physical page if the
- * target cluster is not the reference cluster.
+ *   initialise it from the old physical page, and updates the reference GPT and all
+ *   the GPT copies, for coherence. 
+ * In both cases, it calls the RPC_PMEM_GET_PAGES to get the new physical page when
+ * the target cluster is not the reference cluster.
  * It returns in the <attr> and <ppn> arguments the accessed or modified PTE.
  *********************************************************************************************
@@ -400 +412 @@
  * (Physical Page Number) associated to a missing page defined by the <vpn> argument.
  * - For the FILE type, it returns directly the physical page from the file mapper.
- * - For the CODE and DATA types, it allocates a new phsical page from the cluster defined
+ * - For the CODE and DATA types, it allocates a new physical page from the cluster defined
  *   by the <vseg->cxy> field, or by the <vpn> MSB bits for a distributed vseg,
  *   and initialize this page from the .elf file mapper.

trunk/kernel/syscalls/sys_display.c

@@ -25 +25 @@
 #include <hal_uspace.h>
 #include <errno.h>
+#include <vmm.h>
 #include <cluster.h>
 #include <thread.h>
 #include <process.h>
+#include <string.h>
 
 
@@ -35 +37 @@
                  reg_t  arg1 )
 {
+    // get thread, process and core
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+    core_t    * core    = this->core;
+
+#if CONFIG_DEBUG_SYS_DISPLAY
+uint64_t    tm_start;
+uint64_t    tm_end;
+tm_start = hal_get_cycles();
+if( CONFIG_DEBUG_SYS_DISPLAY < tm_start )
+printk("\n[DBG] %s : thread %d enter / process %x / cycle = %d\n",
+__FUNCTION__, this, process->pid, (uint32_t)tm_start );
+#endif
+
     if( type == DISPLAY_STRING )
     {
         paddr_t   paddr;
         char      kbuf[256];
+        uint32_t  length;
 
         char    * string = (char *)arg0;
  
         // check string in user space
-        if( vmm_v2p_translate( false , string , &paddr ) ) return -1;
+        if( vmm_v2p_translate( false , string , &paddr ) )
+        {
+            printk("\n[ERROR] in %s : string buffer %x unmapped\n",
+            __FUNCTION__ , string );
+            return -1;
+        }
 
         // ckeck string length
-        if( hal_strlen_from_uspace( string ) >= 256 ) return -1;
+        length = hal_strlen_from_uspace( string );
+        if( length >= 256 )
+        {
+            printk("\n[ERROR] in %s : string length %d too large\n",
+            __FUNCTION__ , length );
+            return -1;
+        }
 
         // copy string in kernel space
         hal_strcpy_from_uspace( kbuf , string , 256 );
-
-        // get thread, process and core
-        thread_t  * this    = CURRENT_THREAD;
-        process_t * process = this->process;
-        core_t    * core    = this->core;
 
         // print message on TXT0 kernel terminal
@@ -60 +83 @@
         this->trdid , process->pid , local_cxy, core->lid ,
         (uint32_t)hal_get_cycles() , kbuf );
-
-            return 0; 
     }
     else if( type == DISPLAY_VMM )
@@ -70 +91 @@
         xptr_t process_xp = cluster_get_reference_process_from_pid( pid );
 
-            if( process_xp == XPTR_NULL ) return -1;
+            if( process_xp == XPTR_NULL )
+        {
+            printk("\n[ERROR] in %s : undefined PID %x\n",
+            __FUNCTION__ , pid );
+            return -1;
+        }
 
         // get cluster and local pointer on process
@@ -85 +111 @@
             rpc_vmm_display_client( process_cxy , process_ptr , true );
         }
-
-            return 0; 
     }
     else if( type == DISPLAY_SCHED )
@@ -94 +118 @@
 
         // check cluster argument
-            if( cluster_is_undefined( cxy ) ) return -1;
+            if( cluster_is_undefined( cxy ) ) 
+        {
+            printk("\n[ERROR] in %s : undefined cluster identifier %x\n",
+            __FUNCTION__ , cxy );
+            return -1;
+        }
 
         // check core argument
-        if( lid >= LOCAL_CLUSTER->cores_nr ) return -1;
+        if( lid >= LOCAL_CLUSTER->cores_nr )
+        {
+            printk("\n[ERROR] in %s : undefined local index %d\n",
+            __FUNCTION__ , lid );
+            return -1;
+        }
 
-        // call kernel function
         if( cxy == local_cxy )
         {
@@ -108 +141 @@
             rpc_sched_display_client( cxy , lid );
         }
-
-            return 0; 
     }
     else if( type == DISPLAY_PROCESS )
@@ -116 +147 @@
 
         // check cluster argument
-            if( cluster_is_undefined( cxy ) ) return -1;
+            if( cluster_is_undefined( cxy ) )
+        {
+            printk("\n[ERROR] in %s : undefined cluster identifier %x\n",
+            __FUNCTION__ , cxy );
+            return -1;
+        }
 
-        // call kernel function
         cluster_processes_display( cxy );
-
-        return 0;
     }
     else if( type == DISPLAY_VFS )
@@ -128 +161 @@
         process_t * process = CURRENT_THREAD->process;
         vfs_display( process->vfs_root_xp );
-
-        return 0;
     }
     else if( type == DISPLAY_CHDEV )
     {
-        // call kernel function
         chdev_dir_display();
+    }
+    else 
+    {
+        printk("\n[ERROR] in %s : undefined display type %x\n",
+        __FUNCTION__ , type );
+        return -1;
+    }
 
-        return 0;
-    }
-    else return -1;
+#if CONFIG_DEBUG_SYS_DISPLAY
+tm_end = hal_get_cycles();
+if( CONFIG_DEBUG_SYS_DISPLAY < tm_end )
+printk("\n[DBG] %s : thread %x exit / process %x / cost = %d / cycle %d\n",
+__FUNCTION__, this, process->pid, (uint32_t)(tm_end - tm_start) , (uint32_t)tm_end );
+#endif
 
-}  // end sys_get_sched()
+    return 0;
+
+}  // end sys_display()

trunk/kernel/syscalls/sys_exec.c

@@ -149 +149 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 // Implementation note:
-// This function build an exec_info_t structure containing all informations
+// This function must be called by the main thread (thread 0 in owner cluster).
+// IT build an exec_info_t structure containing all informations
 // required to initialize the new process descriptor and the associated thread.
-// It includes the process PID (unchanged), main() arguments, environment variables, 
+// It includes the process main() arguments, the environment variables, 
 // and the pathname to the new process .elf file. 
 // It calls the process_exec_get_strings() functions to copy the main() arguments and 
@@ -169 +170 @@
     error_t       error;
 
-    // get parent process pid
+    // get calling thread, process, & pid
     thread_t    * this    = CURRENT_THREAD;
     process_t   * process = this->process;
     pid_t         pid     = process->pid;
 
-#if CONFIG_SYSCALL_DEBUG
+    assert( (CXY_FROM_PID( pid ) == local_cxy) , __FUNCTION__ ,
+    "must be called in the owner cluster\n");
+
+    assert( (LTID_FROM_TRDID( this->trdid ) == 0) , __FUNCTION__ ,
+    "must be called by the main thread\n");
+
+    assert( (args == NULL) , __FUNCTION__ , 
+    "args not supported yet\n" );
+
+    assert( (envs == NULL) , __FUNCTION__ , 
+    "args not supported yet\n" );
+
+    // get owner cluster
+
+    // check pathname length
+    if( hal_strlen_from_uspace( pathname ) >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+#endif
+        this->errno = ENFILE;
+        return -1;
+    }
+
+    // copy pathname in exec_info structure (kernel space)
+    hal_strcpy_from_uspace( exec_info.path , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
+
+#if CONFIG_DEBUG_SYS_EXEC
 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, pid, (uint32_t)tm_start );
-#endif
-
-    // get owner cluster
-    cxy_t  owner_cxy = CXY_FROM_PID( pid );
-
-    // check pathname length
-    if( hal_strlen_from_uspace( pathname ) >= CONFIG_VFS_MAX_PATH_LENGTH )
-    {
-        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
-        this->errno = ENFILE;
-        return -1;
-    }
-
-    // copy pathname in exec_info structure (kernel space)
-    hal_strcpy_from_uspace( exec_info.path , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
-
-    // check args argument
-    assert( (args == NULL) , __FUNCTION__ , 
-    "args not supported yet\n" );
-
-    // check envs argument
-    assert( (envs == NULL) , __FUNCTION__ , 
-    "args not supported yet\n" );
+if( CONFIG_DEBUG_SYS_EXEC < tm_start )
+printk("\n[DBG] %s : thread %x enter / process %x / path %s / cycle = %d\n",
+__FUNCTION__, this, pid, exec_info.path, (uint32_t)tm_start );
+#endif
 
     // check and store args in exec_info structure if required
@@ -209 +217 @@
         if( process_exec_get_strings( &exec_info , true , args ) )
         {
-            printk("\n[ERROR] in %s : cannot access args\n", __FUNCTION__ );
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : cannot access args\n", __FUNCTION__ );
+#endif
             this->errno = error;
             return -1;
@@ -220 +231 @@
         if( process_exec_get_strings( &exec_info , false , envs ) )
         {
-            printk("\n[ERROR] in %s : cannot access envs\n", __FUNCTION__ );
+
+#if CONFIG_DEBUG_SYCALLS_ERROR
+printk("\n[ERROR] in %s : cannot access envs\n", __FUNCTION__ );
+#endif
             this->errno = error;
             return -1;
@@ -226 +240 @@
     }
 
-    // register PID in exec_info
-    exec_info.pid = pid;
-
-    // call process_make_exec (local or remote)
-    if( owner_cxy == local_cxy )
-    {
-        error = process_make_exec( &exec_info );
-    }
-    else
-    {
-        rpc_process_make_exec_client( owner_cxy,
-                                      &exec_info,
-                                      &error );
-    }
+    // call relevant kernel function
+    error = process_make_exec( &exec_info );
 
     if( error )
     {
-        printk("\n[ERROR] in %s : cannot create new process %x in cluster %x\n",
-        __FUNCTION__, pid, owner_cxy );
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : cannot create process %x in cluster %x\n",
+__FUNCTION__, pid, CXY_FROM_PID( pid );
+#endif
         this->errno = error;
         return -1;
     }
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_EXEC
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] exit / process %x / path = %s / cost = %d / cycle %d\n",
-__FUNCTION__, local_cxy, this->core->lid, pid, exec_info.path, 
-(uint32_t)(tm_end - tm_start) , (uint32_t)tm_end );
-#endif
-
-    return 0;
+if( CONFIG_DEBUG_SYS_EXEC < tm_end )
+printk("\n[DBG] %s : thread %x exit / process %x / cost = %d / cycle %d\n",
+__FUNCTION__, this, pid, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+#endif
+
+    // deschedule <=> old thread suicide because the BLOCKED_GLOBAL
+    // and the FLAG_REQ_DELETE have been set by process_make_exec()
+    sched_yield( "old process suicide in sys_exec()" );
+
+    assert( false , __FUNCTION__ , "This code should not be executed\n" );
+
+    return 0;  
 
 } // end sys_exec()

trunk/kernel/syscalls/sys_exit.c

@@ -36 +36 @@
 int sys_exit( uint32_t status )
 {
-    uint32_t    save_sr;       // required to enable IRQs
+    reg_t       save_sr;       // required to enable IRQs
 
-    thread_t  * this = CURRENT_THREAD;
-    pid_t       pid  = this->process->pid;
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+    pid_t       pid     = process->pid;
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_EXIT
 uint64_t    tm_start;
 uint64_t    tm_end;
 tm_start = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] enter / process %x / status %x / cycle %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , pid , status , (uint32_t)tm_start );
+if( CONFIG_DEBUG_SYS_EXIT < tm_start )
+printk("\n[DBG] %s : thread %x enter / process %x / status %x / cycle %d\n",
+__FUNCTION__ , this, pid , status , (uint32_t)tm_start );
 #endif
 
-    // get owner process cluster 
-    cxy_t   owner_cxy  = CXY_FROM_PID( pid );
+    // get cluster and pointers on process in owner cluster
+    xptr_t      owner_xp  = cluster_get_owner_process_from_pid( pid );
+    cxy_t       owner_cxy = GET_CXY( owner_xp );
+    process_t * owner_ptr = GET_PTR( owner_xp );
+
+    assert( (owner_xp != XPTR_NULL) , __FUNCTION__ , "owner_xp cannot be NULL\n" );
 
     // enable IRQs
     hal_enable_irq( &save_sr );
 
-    // execute process_make_exit() function in owner cluster
-    if( local_cxy == owner_cxy )                                // owner is local 
-    {
-        process_make_exit( pid , status );
-    }
-    else                                                        // owner is remote
-    {
-        rpc_process_make_exit_client( owner_cxy, pid , status );
-    }
+    // the process_make_kill() function must be executed
+    // by an RPC thread in reference cluster
+    rpc_process_make_kill_client( owner_cxy, owner_ptr, true , status );
 
     // restore IRQs
@@ -70 +70 @@
     hal_fence();
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_EXIT
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] exit / process %x / status %x / cost = %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , pid , status , (uint32_t)(tm_end - tm_start) );
+if( CONFIG_DEBUG_SYS_EXIT < tm_end )
+printk("\n[DBG] %s : thread %x exit / process %x / status %x / cost = %d / cycle %d\n",
+__FUNCTION__, this, pid, status, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif
 

trunk/kernel/syscalls/sys_fork.c

@@ -63 +63 @@
     parent_pid         = parent_process_ptr->pid;
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_FORK
 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, parent_thread_ptr->core->lid, parent_pid, 
-(uint32_t)tm_start );
+if( CONFIG_DEBUG_SYS_FORK < tm_start )
+printk("\n[DBG] %s : thread %x enter / parent %x / cycle =  %d\n",
+__FUNCTION__, parent_thread_ptr, parent_pid, (uint32_t)tm_start );
 #endif
 
@@ -148 +148 @@
         thread_unblock( XPTR( target_cxy , child_thread_ptr ) , THREAD_BLOCKED_GLOBAL );
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_FORK
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] parent_process %x exit / cost = %d\n",
-__FUNCTION__, local_cxy, parent_thread_ptr->core->lid,  parent_pid, 
-(uint32_t)(tm_end - tm_start) );
+if( CONFIG_DEBUG_SYS_FORK < tm_end )
+printk("\n[DBG] %s : parent_thread %x exit / cost = %d / cycle %d\n",
+__FUNCTION__ , parent_thread_ptr, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif
 
@@ -160 +160 @@
     {
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_FORK
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] child process %x exit / cost =  %d\n",
-__FUNCTION__, local_cxy, parent_thread_ptr->core->lid, child_pid, 
-(uint32_t)(tm_end - tm_start) );
+if( CONFIG_DEBUG_SYS_FORK < tm_end )
+printk("\n[DBG] %s : child_thread %x exit / cost = %d / cycle %d\n",
+__FUNCTION__ , child_thread_ptr, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif
 

trunk/kernel/syscalls/sys_kill.c

@@ -38 +38 @@
 {
     uint32_t    save_sr;       // required to enable IRQs
-    xptr_t      process_xp;    // extended pointer on target reference process
-    cxy_t       process_cxy;   // target process cluster
-    process_t * process_ptr;   // local pointer on target process
+    xptr_t      owner_xp;      // extended pointer on target reference process
+    cxy_t       owner_cxy;     // target process cluster
+    process_t * owner_ptr;     // local pointer on target process
     xptr_t      parent_xp;     // extended pointer on parent process
     cxy_t       parent_cxy;    // parent process cluster
     process_t * parent_ptr;    // local pointer on parent process
     pid_t       ppid;          // parent process PID
+    uint32_t    retval;        // return value for the switch
 
     thread_t  * this    = CURRENT_THREAD;
 
-#if CONFIG_SYSCALL_DEBUG
+#if CONFIG_DEBUG_SYS_KILL
 uint64_t    tm_start;
 uint64_t    tm_end;
 tm_start = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] enter / process %x / sig %d / cycle %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , pid, sig_id, (uint32_t)tm_start );
+if( CONFIG_DEBUG_SYS_KILL < tm_start )
+printk("\n[DBG] %s : thread %x enter / process %x / sig %d / cycle %d\n",
+__FUNCTION__ , this, pid, sig_id, (uint32_t)tm_start );
 #endif
 
-    // get cluster and pointers on reference process
-    process_xp  = cluster_get_reference_process_from_pid( pid );
-    process_cxy = GET_CXY( process_xp );
-    process_ptr = (process_t *)GET_PTR( process_xp );
+    // get cluster and pointers on owner process
+    owner_xp  = cluster_get_owner_process_from_pid( pid );
+    owner_cxy = GET_CXY( owner_xp );
+    owner_ptr = GET_PTR( owner_xp );
 
     // check process existence
-    if( process_xp == XPTR_NULL )
+    if( owner_xp == XPTR_NULL )
     {
-        syscall_dmsg("\n[ERROR] in %s : process %x not found\n",
-        __FUNCTION__ , pid );
+
+syscall_dmsg("\n[ERROR] in %s : process %x not found\n", __FUNCTION__ , pid );
+
         this->errno = EINVAL;
         return -1;
@@ -71 +74 @@
     
     // get parent process PID
-    parent_xp  = hal_remote_lwd( XPTR( process_cxy , &process_ptr->parent_xp ) );
+    parent_xp  = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
     parent_cxy = GET_CXY( parent_xp );
     parent_ptr = GET_PTR( parent_xp );
@@ -79 +82 @@
     if( ppid < 2 )
     {
-        syscall_dmsg("\n[ERROR] in %s : process %x cannot be killed\n",
-        __FUNCTION__ , pid );
-                this->errno = EINVAL;
-        return -1;
-    }
 
-    // does nothing if sig_id == 0
-    if( sig_id == 0 )  return 0;
-    
-    // check sig_id
-    if( (sig_id != SIGSTOP) && (sig_id != SIGCONT) && (sig_id != SIGKILL) ) 
-    {
-        syscall_dmsg("\n[ERROR] in %s : illegal signal type for process %x\n",
-        __FUNCTION__ , sig_id , pid );
+syscall_dmsg("\n[ERROR] in %s : process %x cannot be killed\n", __FUNCTION__ , pid );
+
                 this->errno = EINVAL;
         return -1;
@@ -100 +92 @@
     hal_enable_irq( &save_sr );
 
-    // execute process_make_kill() function in owner cluster
-    if( local_cxy == process_cxy )                            // owner cluster is local 
+    // analyse signal type
+    // supported values are : 0, SIGSTOP, SIGCONT, SIGKILL
+    switch( sig_id )
     {
-        process_make_kill( pid , sig_id );
+        case 0 :
+        {
+            // does nothing
+            retval = 0;
+            break;
+        }
+        case SIGSTOP:     
+        {
+            // remove TXT ownership from target process 
+            process_txt_reset_ownership( owner_xp );
+
+            // block all threads in all clusters
+            process_sigaction( owner_ptr , BLOCK_ALL_THREADS );
+
+            // atomically update reference process termination state
+            hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
+                                  PROCESS_FLAG_BLOCK );
+ 
+            retval = 0;
+            break;
+        }
+        case SIGCONT:
+        {
+            // unblock all threads in all clusters
+            process_sigaction( owner_ptr , UNBLOCK_ALL_THREADS );
+
+            // atomically update reference process termination state
+            hal_remote_atomic_and( XPTR( owner_cxy , &owner_ptr->term_state ) ,
+                                   ~PROCESS_FLAG_BLOCK );
+            retval = 0;
+            break;
+        }
+        break;
+        case SIGKILL:
+        {
+            // the process_make_kill() function must be executed
+            // by an RPC thread in process owner cluster
+            // It deletes all target process threads in all clusters, 
+            // and updates the process termination state 
+            rpc_process_make_kill_client( owner_cxy , owner_ptr , false , 0 );
+
+            retval = 0;
+            break;
+        }
+        default:
+        {
+
+syscall_dmsg("\n[ERROR] in %s : illegal signal type %d for process %x\n",
+__FUNCTION__ , sig_id , pid );
+
+            this->errno = EINVAL;
+            retval = -1;
+            break;
+        }
     }
-    else                                                      // owner cluster is remote
-    {
-        rpc_process_make_kill_client( process_cxy , pid , sig_id );
-    }
-
+    
     // restore IRQs
     hal_restore_irq( save_sr );
@@ -115 +157 @@
     hal_fence();
 
-#if CONFIG_SYSCALL_DEBUG 
+#if CONFIG_DEBUG_SYS_KILL
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] exit / process %x / sig %d / cost = %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , pid, sig_id, (uint32_t)(tm_end - tm_start) );
+if( CONFIG_DEBUG_SYS_KILL < tm_end )
+printk("\n[DBG] %s : thread %x enter / process %x / sig %d / cost = %d / cycle %d\n",
+__FUNCTION__ , this, pid, sig_id, (uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
 #endif
- 
-        return 0;
+
+        return retval;
 
 }  // end sys_kill()

trunk/kernel/syscalls/sys_read.c

@@ -65 +65 @@
 
 #if CONFIG_READ_DEBUG
+enter_sys_read = (uint32_t)tm_start;
+#endif
+
+        thread_t  *  this    = CURRENT_THREAD;
+        process_t *  process = this->process;
+ 
+#if CONFIG_DEBUG_SYS_READ
 uint64_t     tm_start;
 uint64_t     tm_end;
 tm_start = hal_get_cycles();
-#endif
-
-#if CONFIG_READ_DEBUG
-enter_sys_read = (uint32_t)tm_start;
-#endif
-
-        thread_t  *  this    = CURRENT_THREAD;
-        process_t *  process = this->process;
- 
+if( CONFIG_DEBUG_SYS_READ < tm_start )
+printk("\n[DBG] %s : thread %d enter / process %x / vaddr = %x / count %d / cycle %d\n",
+__FUNCTION__, this, process->pid, vaddr, count, (uint32_t)tm_start );
+#endif
+
     // check file_id argument
         if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
@@ -188 +191 @@
     hal_fence();
 
-#if CONFIG_READ_DEBUG
+#if CONFIG_DEBUG_SYS_READ
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] / thread %x in process %x / cycle %d\n"
+if( CONFIG_DEBUG_SYS_READ < tm_end )
+printk("\n[DBG] %s : thread %x / process %x / cycle %d\n"
 "nbytes = %d / first byte = %c / file_id = %d / cost = %d\n",
 __FUNCTION__ , local_cxy , this->core->lid , this->trdid , this->process->pid ,

trunk/kernel/syscalls/sys_thread_exit.c

@@ -87 +87 @@
             thread_block( this , THREAD_BLOCKED_JOIN );
 
-            // release the lock protecting the flags
+            // release the lock protecting the join
                 remote_spinlock_unlock( XPTR( local_cxy, &this->join_lock ) );
 

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" );
     }
 

trunk/kernel/syscalls/sys_write.c

@@ -46 +46 @@
     reg_t        save_sr;         // required to enable IRQs during syscall
 
-#if CONFIG_WRITE_DEBUG
+        thread_t   * this = CURRENT_THREAD;
+        process_t  * process = this->process;
+
+#if CONFIG_DEBUG_SYS_WRITE
 uint32_t     tm_start;
 uint32_t     tm_end;
 tm_start = hal_get_cycles();
+if( CONFIG_DEBUG_SYS_WRITE < tm_start )
+printk("\n[DBG] %s : thread %x / process %x / vaddr %x / count %d / cycle %d\n",
+__FUNCTION__, this, process->pid, vaddr, count, (uint32_t)tm_start );
 #endif
-
-        thread_t   * this = CURRENT_THREAD;
-        process_t  * process = this->process;
  
     // check file_id argument
         if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
         {
-        printk("\n[ERROR] in %s : illegal file descriptor index\n", __FUNCTION__ );
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : illegal file descriptor index\n", __FUNCTION__ );
+#endif
         this->errno = EBADFD;
                 return -1;
@@ -68 +74 @@
     if ( error )
     {
-        printk("\n[ERROR] in %s : user buffer unmapped = %x\n",
-        __FUNCTION__ , (intptr_t)vaddr );
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : user buffer unmapped = %x\n", __FUNCTION__ , (intptr_t)vaddr );
+#endif
                 this->errno = EINVAL;
                 return -1;
@@ -82 +90 @@
     if( file_xp == XPTR_NULL )
     {
-        printk("\n[ERROR] in %s : undefined file descriptor index = %d in process %x\n",
-        __FUNCTION__ , file_id , process->pid );
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : undefined file descriptor index = %d in process %x\n",
+__FUNCTION__ , file_id , process->pid );
+#endif
                 this->errno = EBADFD;
                 return -1;
@@ -103 +114 @@
         if( (attr & FD_ATTR_WRITE_ENABLE) == 0 )
             {
-            printk("\n[ERROR] in %s : file %d not writable in process %x\n",
-            __FUNCTION__ , file_id , process->pid );
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : file %d not writable in process %x\n",
+__FUNCTION__ , file_id , process->pid );
+#endif
                     this->errno = EBADFD;
                     return -1;
@@ -131 +145 @@
     if( nbytes != count )
     {
-        printk("\n[ERROR] in %s cannot write data to file %d in process %x\n",
-        __FUNCTION__ , file_id , process->pid );
+
+#if CONFIG_DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s cannot write data to file %d in process %x\n",
+__FUNCTION__ , file_id , process->pid );
+#endif
         this->errno = error;
         return -1;
@@ -142 +159 @@
     hal_fence();
 
-#if CONFIG_WRITE_DEBUG
+#if CONFIG_DEBUG_SYS_WRITE
 tm_end = hal_get_cycles();
-printk("\n[DBG] %s : core[%x,%d] / thread %x in process %x / cycle %d\n"
+if( CONFIG_DEBUG_SYS_WRITE < tm_end )
+printk("\n[DBG] %s : thread %x in process %x / cycle %d\n"
 "nbytes = %d / first byte = %c / file_id = %d / cost = %d\n",
-__FUNCTION__ , local_cxy , this->core->lid , this->trdid , this->process->pid ,
-(uint32_t)tm_start , nbytes , *((char *)(intptr_t)paddr) , file_id , 
-(uint32_t)(tm_end - tm_start) );
+__FUNCTION__, this, process->pid, (uint32_t)tm_start,
+nbytes, *((char *)(intptr_t)paddr) , file_id , (uint32_t)(tm_end - tm_start) );
 #endif
  
-#if (CONFIG_WRITE_DEBUG & 0x1)
-printk("\n@@@@@@@@@@@@ timing to write character %c\n"
-" - enter_sys_write    = %d\n"
-" - exit_sys_write     = %d\n",
-*((char *)(intptr_t)paddr) , (uint32_t)tm_start , (uint32_t)tm_end );
-#endif
-
         return nbytes;
 

trunk/kernel/syscalls/syscalls.h

@@ -171 +171 @@
 /****************************************************************************************** 
  * [10] This function implement the exit system call terminating a POSIX process.
+ * In the present implementation, this function implements actually the _exit():
+ * - it does not flush open ourput steams.
+ * - it does not close open streams.
  ******************************************************************************************
  * @ status   : terminaison status (not used in present implementation).
@@ -421 +424 @@
 
 /****************************************************************************************** 
- * [34] This function implements the "kill" system call.
+ * [34] This function implements the "kill" system call on the kernel side.
  * It register the signal defined by the <sig_id> argument in all thread descriptors 
  * of a target process identified by the <pid> argument. This is done in all clusters
@@ -432 +435 @@
  ****************************************************************************************** 
  * @ pid      : target process identifier.
- * @ sig_id   : index defining the signal type (from 1 to 31). 
+ * @ sig_id   : index defining the signal type. 
  * @ return 0 if success / returns -1 if failure.
  *****************************************************************************************/
@@ -439 +442 @@
 
 /****************************************************************************************** 
- * [35] This function implements the "getpid" system call.
+ * [35] This function implements the "getpid" system call on the kernel side.
  ****************************************************************************************** 
  * @ returns the process PID for the calling thread.
@@ -446 +449 @@
 
 /****************************************************************************************** 
- * [36] This function implement the "fork" system call.
- * The calling process descriptor (parent process), and the associated thread descriptor are
- * replicated in the same cluster as the calling thread, but the new process (child process)
- * is registered in another target cluster, that is the new process owner. 
- * The child process and the associated main thread will be migrated to the target cluster
- * later, when the child process makes an "exec" or any other system call... TODO [AG]
+ * [36] This function implement the "fork" system call on the kernel side.
+ * The calling process descriptor (parent process), and the associated thread descriptor
+ * are replicated in a - likely - remote cluster, that becomes the child process owner. 
+ * The child process get a new PID, and is linked to the parent PID. The child process 
+ * inherit from its parent the memory image, and all open files (including the TXT).
+ * The child process becomes the TXT terminal owner.
  * The target cluster depends on the "fork_user" flag and "fork_cxy" variable that can be
  * stored in the calling thread descriptor by the specific fork_place() system call.
- * If not, the sys_fork() function makes a query to the DQDT to select the target cluster. 
+ * If not, the kernel function makes a query to the DQDT to select the target cluster. 
  ****************************************************************************************** 
  * @ if success, returns child process PID to parent, and return O to child.
@@ -462 +465 @@
 
 /****************************************************************************************** 
- * [37] This function implement the "exec" system call, that creates a new process 
- * descriptor.
- * It is executed in the client cluster, but the new process descriptor and the main
- * thread are created in a server cluster, that is generally another cluster. 
- * - if the server_cluster is the client cluster, it calls directly the process_make_exec()
- *   function to create a new process, and launch a new thread in local cluster.
- * - if the target_cluster is remote, it calls the rpc_process_exec_client() to execute
- *   process_signedmake_exec() on the remote cluster.
- * In both case this function build an exec_info_t structure containing all informations
- * required to build the new process descriptor and the associated thread.
- * Finally, the calling process and thread are deleted.
+ * [37] This function implement the "exec" system call on the kernel side.
+ * It creates, in the same cluster as the calling thread, a new process descriptor,
+ * and a new associated main thread descriptor, executing a new memory image defined 
+ * by the <filename> argument. This new process inherit from the old process the PID
+ * and the PPID, as well as all open files (including the TXT). 
+ * The old process descriptor, and all its threads are blocked, and marked for deletion.
+ * Therefore the exec syscall does not return to the calling thread in case of success.
+ * This function build an exec_info_t structure containing the new process arguments,
+ * as defined by the <arv> argument, and the new process environment variables, 
+ * as defined by the <envp>  argument.
+ * TODO : the <argv> and <envp> arguments are not supported yet (both must be NULL).
  ****************************************************************************************** 
  * @ filename : string pointer on .elf filename (pointer in user space)
  * @ argv     : array of strings on process arguments (pointers in user space)
  * @ envp     : array of strings on environment variables (pointers in user space)
- * @ returns O if success / returns -1 if failure.
+ * @ does not return if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_exec( char  * filename,
@@ -495 +498 @@
 
 /****************************************************************************************** 
- * [39] This blocking function wait a change of a child process state. A change can be:
- * - a termination of child following a child exit.
- * - a termination of child following a SIGKILL signal.
+ * [39] This blocking function waits a change of a child process state, that can be:
+ * - a termination of child following a process_make_exit().
+ * - a termination of child following a process_make_kill().
  * - a blocking of child following a SIGSTOP signal.
- * It returns the PID of the involved child process, after storing in the memory slot
- * pointed by the <status> argument relevant information on the child state change.
+ * In case of a multi-thread process, this function must be called by the main thread
+ * runningin the reference cluster.
+ * When a change has been observed, it returns the PID of the child process, and stores
+ * in the <status> argument relevant information on the child state change.
  * The following macros can be used to extract information from status:
  * - WIFEXITED(status)   : is true if the child process terminated with an exit().
@@ -506 +511 @@
  * - WIFSTOPPED(status)  : is true if the child process is stopped by a signal.
  * - WEXITSTATUS(status) : returns the low-order 8 bits of the exit() argument.
- * A status of 0 indicates a normal termination.
  * If a parent process terminates without waiting for all child processes to terminate,
  * the remaining child processes are attached to the init process.
- ******************************************************************************************
- * @ status : pointer on the child PID status.
- * @ return child PID if success / return -1 if failure.
+ * WARNING: negative values for the <pid> argument are not supported.
+ ******************************************************************************************
+ * @ searched_pid : searched child process identifier.
+ * @ status       : [out] child termination status.
+ * @ return child PID if success / return -1 if searched PID not found.
  *****************************************************************************************/
 int sys_wait( uint32_t * status );