Changeset 625 for trunk/kernel

Timestamp:

Apr 10, 2019, 10:09:39 AM (5 years ago)

Author:

alain

Message:

Fix a bug in the vmm_remove_vseg() function: the physical pages
associated to an user DATA vseg were released to the kernel when
the target process descriptor was in the reference cluster.
This physical pages release should be done only when the page
forks counter value is zero.
All other modifications are cosmetic.

Location:

trunk/kernel

Files:

• fs/fatfs.c (modified) (37 diffs)
• fs/fatfs.h (modified) (7 diffs)
• fs/vfs.c (modified) (53 diffs)
• fs/vfs.h (modified) (2 diffs)
• kern/chdev.c (modified) (14 diffs)
• kern/chdev.h (modified) (1 diff)
• kern/printk.c (modified) (3 diffs)
• kern/printk.h (modified) (4 diffs)
• kern/process.c (modified) (45 diffs)
• kern/process.h (modified) (9 diffs)
• kern/rpc.c (modified) (5 diffs)
• kern/rpc.h (modified) (2 diffs)
• kern/scheduler.c (modified) (11 diffs)
• kern/thread.c (modified) (46 diffs)
• kern/thread.h (modified) (10 diffs)
• kernel_config.h (modified) (8 diffs)
• libk/elf.c (modified) (1 diff)
• libk/elf.h (modified) (1 diff)
• libk/remote_rwlock.c (modified) (1 diff)
• mm/mapper.c (modified) (13 diffs)
• mm/mapper.h (modified) (3 diffs)
• mm/page.h (modified) (2 diffs)
• mm/ppm.c (modified) (2 diffs)
• mm/ppm.h (modified) (1 diff)
• mm/vmm.c (modified) (39 diffs)
• mm/vmm.h (modified) (8 diffs)
• mm/vseg.c (modified) (1 diff)
• mm/vseg.h (modified) (2 diffs)
• syscalls/sys_barrier.c (modified) (4 diffs)
• syscalls/sys_close.c (modified) (3 diffs)
• syscalls/sys_display.c (modified) (3 diffs)
• syscalls/sys_exec.c (modified) (3 diffs)
• syscalls/sys_exit.c (modified) (9 diffs)
• syscalls/sys_fork.c (modified) (5 diffs)
• syscalls/sys_get_config.c (modified) (5 diffs)
• syscalls/sys_get_core.c (modified) (1 diff)
• syscalls/sys_get_cycle.c (modified) (1 diff)
• syscalls/sys_is_fg.c (modified) (2 diffs)
• syscalls/sys_mmap.c (modified) (2 diffs)
• syscalls/sys_munmap.c (modified) (2 diffs)
• syscalls/sys_mutex.c (modified) (4 diffs)
• syscalls/sys_open.c (modified) (1 diff)
• syscalls/sys_opendir.c (modified) (2 diffs)
• syscalls/sys_read.c (modified) (2 diffs)
• syscalls/sys_readdir.c (modified) (1 diff)
• syscalls/sys_thread_exit.c (modified) (2 diffs)
• syscalls/sys_wait.c (modified) (9 diffs)
• syscalls/sys_write.c (modified) (4 diffs)

trunk/kernel/fs/fatfs.c

@@ -2 +2 @@
  * fatfs.c - FATFS file system API implementation.
  *
- * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -374 +374 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// This static function - atomically - decrements "free_clusters", and updates 
-// the "free_cluster_hint" shared variables in the FATFS context in the FAT cluster.
-// It scan the FAT to find the first free slot larger than the <cluster> argument,
-// and set "free_cluster_hint" <= (free - 1).
+// This static function decrements the  "free_clusters" variable, and updates the 
+// "free_cluster_hint" variable in the FATFS context, identified by the <fat_ctx_cxy>
+// and <fat_ctx_ptr> arguments (cluster containing the FAT mapper).
+// It scan all slots in the FAT mapper seen as an array of 32 bits words, looking for the
+// first free slot larger than the <cluster> argument, to update "free_cluster_hint".
 //
 // WARNING : The free_lock protecting exclusive access to these variables
 //           must be taken by the calling function. 
 //////////////////////////////////////////////////////////////////////////////////////////
-// @ cluster     : recently allocated cluster index in FAT.
-//////////////////////////////////////////////////////////////////////////////////////////
-static error_t fatfs_free_clusters_decrement( uint32_t  cluster )
-{
-    fatfs_ctx_t * loc_ctx;      // local pointer on local FATFS context
-    fatfs_ctx_t * fat_ctx;      // local pointer on FATFS in cluster containing FAT mapper
-    cxy_t         mapper_cxy;   // cluster identifier for cluster containing FAT mapper
+// @ fat_ctx_cxy  : FAT mapper cluster identifier. 
+// @ fat_ctx_ptr  : local pointer on FATFS context. 
+// @ cluster      : recently allocated cluster index in FAT.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_free_clusters_decrement( cxy_t         fat_ctx_cxy,
+                                              fatfs_ctx_t * fat_ctx_ptr,
+                                              uint32_t      cluster )
+{
     xptr_t        mapper_xp;    // extended pointer on FAT mapper
     xptr_t        hint_xp;      // extended pointer on "free_cluster_hint" shared variable
@@ -397 +399 @@
     uint32_t      page_max;     // max number of pages in FAT mapper
     xptr_t        page_xp;      // extended pointer on current page in FAT mapper
+    xptr_t        base_xp;      // extended pointer on current page base
     xptr_t        slot_xp;      // extended pointer on current slot in FAT mapper
 
@@ -407 +410 @@
 #endif
 
-    // get local pointer on local FATFS context
-    loc_ctx = fs_context[FS_TYPE_FATFS].extend;
-
-    // get cluster containing FAT mapper
-    mapper_xp  = loc_ctx->fat_mapper_xp;
-    mapper_cxy = GET_CXY( mapper_xp ); 
-
-    // get local pointer on FATFS context in FAT cluster
-    fat_ctx = hal_remote_lpt( XPTR( mapper_cxy , &fs_context[FS_TYPE_FATFS].extend ) );
-
     // build extended pointers on free_clusters, and free_cluster_hint
-    hint_xp = XPTR( mapper_cxy , &fat_ctx->free_cluster_hint );
-    numb_xp = XPTR( mapper_cxy , &fat_ctx->free_clusters );
+    hint_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_cluster_hint );
+    numb_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_clusters );
 
     // update "free_clusters"
@@ -425 +418 @@
     hal_remote_s32( numb_xp , numb - 1 );
 
-    // scan FAT mapper to find the first free slot > cluster
-    // and update "free_cluster_hint" as (free - 1)
+    // get extended pointer on FAT mapper
+    mapper_xp = hal_remote_l64( XPTR( fat_ctx_cxy , &fat_ctx_ptr->fat_mapper_xp ) );
+
+    // initialise variables to scan the FAT mapper
+    // and find the first free slot > cluster
     page_id  = (cluster + 1) >> 10;
     slot_id  = (cluster + 1) & 0x3FF;
-    page_max = (loc_ctx->fat_sectors_count >> 3);
+    page_max = hal_remote_l32( XPTR( fat_ctx_cxy, &fat_ctx_ptr->fat_sectors_count ) ) >> 3;
 
     // scan FAT mapper / loop on pages
@@ -443 +439 @@
         }
 
+        // get extended pointer on page
+        base_xp = ppm_page2base( page_xp );
+
         // scan FAT mapper / loop on slots
         while ( slot_id < 1024 )
         {
             // get extended pointer on current slot
-            slot_xp = ppm_page2base( page_xp ) + (slot_id << 2);
-
-            // test FAT slot value 
+            slot_xp = base_xp + (slot_id << 2);
+
+            // test slot value 
             if ( hal_remote_l32( slot_xp ) == FREE_CLUSTER )
             {
-                // update "free_cluster_hint" <= (free - 1)
+                // update "free_cluster_hint"
                 hal_remote_s32( hint_xp , (page_id << 10) + slot_id - 1 );
 
@@ -465 +464 @@
             }
 
-            // increment  slot_id
-            slot_id++;
+            // update slot_id
+            slot_id = 0;
 
         }  // end loop on slots
 
-        // update loop variables
+        // update (page_id,slot_id) variables
         page_id++;
         slot_id = 0;
@@ -483 +482 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// This static function atomically increments <free_clusters>, and updates 
-// the <free_cluster_hint> shared variables in the FATFS context in the FAT cluster.
-// If the released cluster index is smaller than the current (hint + 1) value, 
-// it set "free_cluster_hint" <= cluster - 1.
+// This static function increments the "free_clusters" variable, and updates the
+// "free_cluster_hint" variables in the FATFS context, identified by the <fat_ctx_cxy> 
+// and <fat_ctx_ptr> argument (cluster containing the FAT mapper).
+// If the released cluster index is smaller than the current (hint) value, 
+// it set "free_cluster_hint" <= cluster.
 //
 // WARNING : The free_lock protecting exclusive access to these variables
 //           must be taken by the calling function. 
 //////////////////////////////////////////////////////////////////////////////////////////
+// @ fat_ctx_cxy  : FAT mapper cluster identifier. 
+// @ fat_ctx_ptr  : local pointer on FATFS context. 
 // @ cluster     : recently released cluster index in FAT.
 //////////////////////////////////////////////////////////////////////////////////////////
-static void fatfs_free_clusters_increment( uint32_t  cluster )
-{
-    fatfs_ctx_t * loc_ctx;      // local pointer on local FATFS context
-    fatfs_ctx_t * fat_ctx;      // local pointer on FATFS in cluster containing FAT mapper
-    cxy_t         fat_cxy;      // cluster identifier for cluster containing FAT mapper
+static void fatfs_free_clusters_increment( cxy_t         fat_ctx_cxy,
+                                           fatfs_ctx_t * fat_ctx_ptr,
+                                           uint32_t      cluster )
+{
     xptr_t        hint_xp;      // extended pointer on "free_cluster_hint" shared variable
     xptr_t        numb_xp;      // extended pointer on "free_clusters" shared variable 
@@ -503 +504 @@
     uint32_t      numb;         // "free_clusters" variable current value
 
-    // get local pointer on local FATFS context
-    loc_ctx = fs_context[FS_TYPE_FATFS].extend;
-
-    // get cluster containing FAT mapper
-    fat_cxy = GET_CXY( loc_ctx->fat_mapper_xp );
-
-    // get local pointer on FATFS context in FAT cluster
-    fat_ctx = hal_remote_lpt( XPTR( fat_cxy , &fs_context[FS_TYPE_FATFS].extend ) );
-
-    // build extended pointers free_lock, free_clusters, and free_cluster_hint
-    hint_xp = XPTR( fat_cxy , &fat_ctx->free_cluster_hint );
-    numb_xp = XPTR( fat_cxy , &fat_ctx->free_clusters );
+    // build extended pointers on free_clusters, and free_cluster_hint
+    hint_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_cluster_hint );
+    numb_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_clusters );
 
     // get current value of free_cluster_hint and free_clusters
@@ -521 +513 @@
 
     // update free_cluster_hint if required
-    if ( cluster < (hint + 1) ) hal_remote_s32( hint_xp , (cluster - 1) );
+    if ( (cluster - 1) < hint ) hal_remote_s32( hint_xp , (cluster - 1) );
 
     // update free_clusters
@@ -542 +534 @@
 // It does NOT update the FS on the IOC device.
 //////////////////////////////////////////////////////////////////////////////////////////
-// @ fat_mapper_xp : extended pointer on FAT mapper.
-// @ cluster       : cluster index in FAT.
+// @ mapper_cxy : FAT mapper cluster identifier.
+// @ mapper_ptr : local pointer on FAT mapper.
+// @ fatfs_ctx  : local pointer on FATFS context in FAT cluster.
+// @ cluster    : index of cluster to be released from FAT mapper.
 // @ return 0 if success / return -1 if error (cannot access FAT)
 //////////////////////////////////////////////////////////////////////////////////////////
-static error_t fatfs_recursive_release( xptr_t    fat_mapper_xp,
-                                        uint32_t  cluster )
+static error_t fatfs_recursive_release( cxy_t         mapper_cxy,
+                                        mapper_t    * mapper_ptr,
+                                        fatfs_ctx_t * fatfs_ctx,
+                                        uint32_t      cluster )
 {
     uint32_t next;
 
-    // get next cluster from FAT mapper
-    if ( mapper_remote_get_32( fat_mapper_xp , cluster , &next ) ) return -1;
+    // build extended pointer on FAT mapper
+    xptr_t mapper_xp = XPTR( mapper_cxy , mapper_ptr );
+
+    // get next cluster index from FAT mapper
+    if ( mapper_remote_get_32( mapper_xp,
+                               cluster,
+                               &next ) ) return -1;
 
 #if (DEBUG_FATFS_RELEASE_INODE & 1)
@@ -564 +565 @@
     {
         // call fatfs_recursive_release() on next cluster
-        if ( fatfs_recursive_release( fat_mapper_xp , next ) ) return -1;
+        if ( fatfs_recursive_release( mapper_cxy,
+                                      mapper_ptr,
+                                      fatfs_ctx,
+                                      next ) ) return -1;
     }       
 
     // update current cluster in FAT mapper
-    if ( mapper_remote_set_32( fat_mapper_xp, cluster , FREE_CLUSTER ) ) return -1;
+    if ( mapper_remote_set_32( mapper_xp, 
+                               cluster,
+                               FREE_CLUSTER ) ) return -1;
 
     // Update free_cluster_hint and free_clusters in FAT context
-    fatfs_free_clusters_increment( cluster );
+    fatfs_free_clusters_increment( mapper_cxy,
+                                   fatfs_ctx,
+                                   cluster );
 
     return 0;
@@ -582 +590 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-//////////////////////////////
-void fatfs_ctx_display( void )
-{
-    // get pointer on local FATFS context
-    vfs_ctx_t   * vfs_ctx   = &fs_context[FS_TYPE_FATFS];
-    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
-
+///////////////////////////////////////////
+void fatfs_ctx_display( fatfs_ctx_t * ctx )
+{
     printk("\n*** FAT context ***\n" 
            "- fat_sectors       = %d\n"
@@ -599 +603 @@
            "- free_cluster_hint = %d\n"
            "- fat_mapper_xp     = %l\n",
-           fatfs_ctx->fat_sectors_count,
-           fatfs_ctx->bytes_per_sector,
-           fatfs_ctx->sectors_per_cluster * fatfs_ctx->bytes_per_sector,
-           fatfs_ctx->fat_begin_lba,
-           fatfs_ctx->cluster_begin_lba,
-           fatfs_ctx->root_dir_cluster,
-           fatfs_ctx->free_clusters,
-           fatfs_ctx->free_cluster_hint,
-           fatfs_ctx->fat_mapper_xp );
-
-}  // end fatfs_ctx_display()
+           ctx->fat_sectors_count,
+           ctx->bytes_per_sector,
+           ctx->sectors_per_cluster * ctx->bytes_per_sector,
+           ctx->fat_begin_lba,
+           ctx->cluster_begin_lba,
+           ctx->root_dir_cluster,
+           ctx->free_clusters,
+           ctx->free_cluster_hint,
+           ctx->fat_mapper_xp );
+
+}  // end ctx_display()
 
 //////////////////////////////////////////
@@ -659 +663 @@
     uint32_t * buffer;                 // pointer on current page (array of uint32_t)
     uint32_t   current_page_index;     // index of current page in FAT 
-    uint32_t   current_page_offset;    // offset of slot in current page
+    uint32_t   current_slot_index;     // index of slot in current page
     uint32_t   page_count_in_file;     // index of page in file (index in linked list)
     uint32_t   next_cluster_id;        // content of current FAT slot
@@ -670 +674 @@
 thread_t * this  = CURRENT_THREAD;
 if( DEBUG_FATFS_GET_CLUSTER < cycle )
-printk("\n[%s] thread[%x,%x] enter / first_cluster_id %d / searched_index / cycle %d\n",
+printk("\n[%s] thread[%x,%x] enter / first_cluster_id %d / searched_index %d / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, first_cluster_id, searched_page_index, cycle );
 #endif
@@ -678 +682 @@
 
     // get extended pointer and cluster on FAT mapper
-    xptr_t mapper_xp  = ctx->fat_mapper_xp;
-    cxy_t  mapper_cxy = GET_CXY( mapper_xp );
+    xptr_t fat_mapper_xp  = ctx->fat_mapper_xp;
+    cxy_t  fat_mapper_cxy = GET_CXY( fat_mapper_xp );
 
     // initialize loop variable (1024 slots per page)
     current_page_index  = first_cluster_id >> 10;
-    current_page_offset = first_cluster_id & 0x3FF;
+    current_slot_index  = first_cluster_id & 0x3FF;
     page_count_in_file  = 0;
     next_cluster_id     = 0xFFFFFFFF;
 
-    // scan FAT (i.e. traverse FAT linked list)
+    // scan FAT mapper (i.e. traverse FAT linked list)
     while( page_count_in_file < searched_page_index )
     {
-        // get pointer on current page descriptor
-        current_page_xp = mapper_remote_get_page( mapper_xp , current_page_index );
+        // get pointer on current page descriptor in FAT mapper
+        current_page_xp = mapper_remote_get_page( fat_mapper_xp , current_page_index );
 
         if( current_page_xp == XPTR_NULL )
         {
-            // TODO
+            printk("\n[ERROR] in %s : cannot get next page from FAT mapper\n", __FUNCTION__);
             return -1;
         }
@@ -704 +708 @@
 
         // get FAT slot content 
-        next_cluster_id = hal_remote_l32( XPTR( mapper_cxy , &buffer[current_page_offset] ) );
+        next_cluster_id = hal_remote_l32( XPTR( fat_mapper_cxy,
+                                                &buffer[current_slot_index] ) );
 
 #if (DEBUG_FATFS_GET_CLUSTER & 1)
 if( DEBUG_FATFS_GET_CLUSTER < cycle )
 printk("\n[%s] traverse FAT / current_page_index = %d\n"
-"current_page_offset = %d / next_cluster_id = %d\n",
-__FUNCTION__, current_page_index, current_page_offset , next_cluster_id );
+"current_slot_index = %d / next_cluster_id = %d\n",
+__FUNCTION__, current_page_index, current_slot_index , next_cluster_id );
 #endif
 
         // update loop variables
-        current_page_index  = next_cluster_id >> 10;
-        current_page_offset = next_cluster_id & 0x3FF;
+        current_page_index = next_cluster_id >> 10;
+        current_slot_index = next_cluster_id & 0x3FF;
         page_count_in_file++;
     }
 
-    if( next_cluster_id == 0xFFFFFFFF ) return -1;
+    if( next_cluster_id == 0xFFFFFFFF )
+    {
+        printk("\n[ERROR] in %s : searched_cluster_id not found in FAT\n", __FUNCTION__ );
+        return -1;
+    }
    
 #if DEBUG_FATFS_GET_CLUSTER
@@ -759 +768 @@
 
 #if DEBUG_FATFS_CTX_INIT
-uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
 if( DEBUG_FATFS_CTX_INIT < cycle )
 printk("\n[%s] thread[%x,%x] enter for fatfs_ctx = %x / cycle %d\n",
@@ -766 +776 @@
 
 // check argument
-assert( (fatfs_ctx != NULL) , "pointer on FATFS context is NULL\n" );
+assert( (fatfs_ctx != NULL) , "pointer on FATFS context is NULL" );
 
 // check only cluster 0 does FATFS init
-assert( (local_cxy == 0) , "only cluster 0 can initialize FATFS\n");
+assert( (local_cxy == 0) , "only cluster 0 can initialize FATFS");
 
     // allocate a 512 bytes buffer to store the boot record
@@ -882 +892 @@
     // WARNING : the inode field MUST be NULL for the FAT mapper
     fat_mapper->inode = NULL;
+
 
     // initialize the FATFS context
@@ -895 +906 @@
 
     remote_queuelock_init( XPTR( local_cxy , &fatfs_ctx->free_lock ) , LOCK_FATFS_FREE );
+
+#if (DEBUG_FATFS_CTX_INIT & 0x1)
+if( DEBUG_FATFS_CTX_INIT < cycle )
+fatfs_ctx_display( fatfs_ctx );
+#endif
 
 #if DEBUG_FATFS_CTX_INIT
@@ -1525 +1541 @@
                           xptr_t        child_inode_xp )
 {
-    uint8_t  * entry;    // pointer on FAT32 directory entry (array of 32 bytes)
-    uint32_t   index;    // index of FAT32 directory entry in mapper
-    mapper_t * mapper;   // pointer on directory mapper
-    uint32_t   cluster;  // directory entry cluster
-    uint32_t   size;     // directory entry size
-    bool_t     is_dir;   // directory entry type (file/dir)
-    error_t    error;
+    uint8_t      * entry;            // pointer on FAT32 directory entry (array of 32 bytes)
+    uint32_t       index;            // index of FAT32 directory entry in mapper
+    mapper_t     * mapper;           // pointer on directory mapper
+    uint32_t       cluster;          // directory entry cluster
+    uint32_t       size;             // directory entry size
+    bool_t         is_dir;           // directory entry type (file/dir)
+    xptr_t         root_xp;          // extended pointer on root of parent dentries
+    xptr_t         iter_xp;          // iterator for this list
+    cxy_t          child_inode_cxy;  // child inode cluster  
+    vfs_inode_t  * child_inode_ptr;  // child inode local pointer
+    xptr_t         dentry_xp;        // extended pointer on searched dentry descriptor
+    cxy_t          dentry_cxy;       // cluster identifier of dentry (must be local_cxy)
+    vfs_dentry_t * dentry_ptr;       // local pointer 
+    error_t        error;
+
+    char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
 
 // check arguments
@@ -1539 +1564 @@
 
 #if DEBUG_FATFS_GET_DENTRY
-char       parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
+vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
 if( DEBUG_FATFS_GET_DENTRY < cycle )
 printk("\n[%s]  thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name , parent_name , cycle );
-#endif
-
-    // get pointer and index of searched directory entry in mapper 
+__FUNCTION__, this->process->pid, this->trdid, name , dir_name , cycle );
+#endif
+
+    // get local pointer on parent mapper
     mapper = parent_inode->mapper;
+
+    // get pointer and index in mapper for searched directory entry 
     error  = fatfs_scan_directory( mapper, name , &entry , &index );
 
-    // update child inode and dentry descriptors if sucess
-    if( error == 0 )
+    if( error )
     { 
+        vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
+        printk("\n[ERROR] in %s : cannot find <%s> in parent mapper <%s>\n",
+        __FUNCTION__, name , dir_name );
+        return -1;
+    }
+
+    // get relevant infos from FAT32 directory entry
+    cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry , 1 ) << 16) |
+              (fatfs_get_record( DIR_FST_CLUS_LO , entry , 1 )      ) ;
+    is_dir  = (fatfs_get_record( DIR_ATTR        , entry , 1 ) & ATTR_DIRECTORY);
+    size    =  fatfs_get_record( DIR_FILE_SIZE   , entry , 1 );
+
+    // get child inode cluster and local pointer
+    child_inode_cxy = GET_CXY( child_inode_xp );
+    child_inode_ptr = GET_PTR( child_inode_xp );
+
+    // build extended pointer on root of list of parent dentries
+    root_xp = XPTR( child_inode_cxy , &child_inode_ptr->parents );
+
+// check child inode has at least one parent
+assert( (xlist_is_empty( root_xp ) == false ), "child inode must have one parent\n");
+
+    // scan list of parent dentries to search the parent_inode
+    bool_t found = false;
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        // get pointers on dentry
+        dentry_xp  = XLIST_ELEMENT( iter_xp , vfs_dentry_t , parents );
+        dentry_cxy = GET_CXY( dentry_xp );
+        dentry_ptr = GET_PTR( dentry_xp );
+
+        // get local pointer on current parent directory inode
+        vfs_inode_t * current = hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->parent ) );
+
+        // check if current parent is the searched parent
+        if( XPTR( dentry_cxy , current ) == XPTR( local_cxy , parent_inode ) )
+        {
+            found = true;
+            break;
+        }
+    }
+
+    if( found == false )
+    { 
+        vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
+        printk("\n[ERROR] in %s : cannot find <%s> directory in list of parents for <%s>\n",
+        __FUNCTION__, dir_name, name );
+        return -1;
+    }
+
+    // update the child inode "type", "size", and "extend" fields
+    vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
+
+    hal_remote_s32( XPTR( child_inode_cxy , &child_inode_ptr->type   ) , type );
+    hal_remote_s32( XPTR( child_inode_cxy , &child_inode_ptr->size   ) , size );
+    hal_remote_s32( XPTR( child_inode_cxy , &child_inode_ptr->extend ) , cluster );
+
+    // update the dentry "extend" field
+    dentry_ptr->extend = (void *)(intptr_t)index;
 
 #if DEBUG_FATFS_GET_DENTRY
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_GET_DENTRY < cycle )
-printk("\n[%s]  thread[%x,%x] exit / intialised child <%s> in %s / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name, parent_name, cycle );
-#endif
-        // get relevant infos from FAT32 directory entry
-        cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry , 1 ) << 16) |
-                  (fatfs_get_record( DIR_FST_CLUS_LO , entry , 1 )      ) ;
-        is_dir  = (fatfs_get_record( DIR_ATTR        , entry , 1 ) & ATTR_DIRECTORY);
-        size    =  fatfs_get_record( DIR_FILE_SIZE   , entry , 1 );
-
-        // get child inode cluster and local pointer
-        cxy_t          inode_cxy = GET_CXY( child_inode_xp );
-        vfs_inode_t  * inode_ptr = GET_PTR( child_inode_xp );
-
-        // build extended pointer on root of list of prent dentries
-        xptr_t parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
-
-// check child inode has at least one parent
-assert( (xlist_is_empty( parents_root_xp ) == false ), "child inode must have one parent\n");
-
-        // get dentry pointers and cluster
-        xptr_t         dentry_xp  = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
-        vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
-        cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-
-// check dentry descriptor in same cluster as parent inode
-assert( (dentry_cxy == local_cxy) , "illegal dentry cluster\n" );
-
-        // update the child inode "type", "size", and "extend" fields
-        vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
-
-        hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type   ) , type );
-        hal_remote_s32( XPTR( inode_cxy , &inode_ptr->size   ) , size );
-        hal_remote_s32( XPTR( inode_cxy , &inode_ptr->extend ) , cluster );
-
-        // update the dentry "extend" field
-        dentry_ptr->extend = (void *)(intptr_t)index;
-
-        return 0;
-    }
-    else
-    {
-        return -1;
-    }
+printk("\n[%s]  thread[%x,%x] exit / intialised inode & dentry for <%s> in <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, dir_name, cycle );
+#endif
+
+    return 0;
 
 }  // end fatfs_new_dentry()
@@ -1615 +1661 @@
     error_t    error;
 
+    char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
+
 // check arguments
 assert( (inode  != NULL) , "inode is NULL\n" );
@@ -1621 +1669 @@
 
 #if DEBUG_FATFS_UPDATE_DENTRY
-char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
 vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
 if( DEBUG_FATFS_UPDATE_DENTRY < cycle )
-printk("\n[%s]  thread[%x,%x] enter for entry <%s> in dir <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, dentry->name , dir_name , cycle );
-#endif
-
-    // get pointer and index of searched directory entry in mapper 
+printk("\n[%s]  thread[%x,%x] enter for <%s/%s> / size %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, size, cycle );
+#endif
+
+    // get local pointer on mapper
     mapper = inode->mapper;
+
+    // get pointer and index in mapper for searched directory entry
     error  = fatfs_scan_directory( mapper, dentry->name , &entry , &index );
 
-    // update size in mapper if found
-    if( error == 0 )
+    if( error )
     { 
+        vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
+        printk("\n[ERROR] in %s : cannot find <%s> in parent mapper <%s>\n",
+        __FUNCTION__, dentry->name, dir_name );
+        return -1;
+    }
+
+    // set size in FAT32 directory entry
+    fatfs_set_record( DIR_FILE_SIZE , entry , 1 , size );
+
+    // get local pointer on modified page base
+    void * base = (void *)((intptr_t)entry & (~CONFIG_PPM_PAGE_MASK)); 
+
+    // get extended pointer on modified page descriptor
+    xptr_t page_xp = ppm_base2page( XPTR( local_cxy , base ) );
+
+    // synchronously update the modified page on device
+    error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
+
+    if( error )
+    { 
+        vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
+        printk("\n[ERROR] in %s : cannot update parent directory <%s> on device\n",
+        __FUNCTION__, dir_name );
+        return -1;
+    }
 
 #if DEBUG_FATFS_UPDATE_DENTRY
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_UPDATE_DENTRY < cycle )
-printk("\n[%s]  thread[%x,%x] exit / found entry <%s> in <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, dentry->name, dir_name, cycle );
-#endif
-        // set size in FAT32 directory entry
-        fatfs_set_record( DIR_FILE_SIZE , entry , 1 , size );
-
-        // get local pointer on modified page base
-        void * base = (void *)((intptr_t)entry & (~CONFIG_PPM_PAGE_MASK)); 
-
-        // get extended pointer on modified page descriptor
-        xptr_t    page_xp = ppm_base2page( XPTR( local_cxy , base ) );
-
-        // mark page as dirty
-        ppm_page_do_dirty( page_xp );
-
-        return 0;
-    }
-    else
-    {
-        return -1;
-    }
+printk("\n[%s]  thread[%x,%x] exit / updated size for <%s/%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
+#endif
+
+    return 0;
 
 }  // end fatfs_update_dentry()
@@ -2044 +2101 @@
 error_t fatfs_cluster_alloc( uint32_t * searched_cluster )
 {
-    uint32_t      page_id;        // page index in mapper
+    uint32_t      page_id;        // page index in FAT mapper
     uint32_t      slot_id;        // slot index in page (1024 slots per page)
-    uint32_t      hint;           // first free cluster index in FAT
+    uint32_t      cluster;        // first free cluster index in FAT
     uint32_t      free_clusters;  // total number of free clusters
     vfs_ctx_t   * vfs_ctx;        // local pointer on VFS context (same in all clusters)
@@ -2080 +2137 @@
     fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_cxy , &vfs_ctx->extend ) );
 
-    // build relevant extended pointers in on free clusters info in FAT cluster 
+    // build relevant extended pointers on free clusters info in mapper cluster 
     lock_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_lock );
     hint_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_cluster_hint );
@@ -2089 +2146 @@
 
     // get hint and free_clusters values from FATFS context 
-    hint          = hal_remote_l32( hint_xp );
+    cluster       = hal_remote_l32( hint_xp ) + 1;
     free_clusters = hal_remote_l32( numb_xp );
         
-    // get page index & slot index for the first free cluster 
-    page_id  = (hint + 1) >> 10;
-    slot_id  = (hint + 1) & 0x3FF;
-
-    // get relevant page from mapper
-    page_xp = mapper_remote_get_page( mapper_xp , page_id );
-
-    if( page_xp == XPTR_NULL )
-    {
-        printk("\n[ERROR] in %s : cannot acces FAT mapper\n", __FUNCTION__ );
-        return -1;
-    }
-
-    // build extended pointer on free cluster slot 
-    slot_xp = ppm_page2base( page_xp ) + (slot_id<<2);
-         
 #if (DEBUG_FATFS_CLUSTER_ALLOC & 1)
 if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
-printk("\n[%s] thread[%x,%x] get free info / hint %x / free_clusters %x\n",
-__FUNCTION__, this->process->pid, this->trdid, hint, free_clusters );
+printk("\n[%s] thread[%x,%x] get free info : hint %x / free_clusters %x\n",
+__FUNCTION__, this->process->pid, this->trdid, (cluster - 1), free_clusters );
 #endif
 
@@ -2127 +2168 @@
     }
 
-    // check "hint" 
+
+
+    // get page index & slot index for selected cluster 
+    page_id  = cluster >> 10;
+    slot_id  = cluster & 0x3FF;
+
+    // get relevant page descriptor from mapper
+    page_xp = mapper_remote_get_page( mapper_xp , page_id );
+
+    if( page_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : cannot acces FAT mapper\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // build extended pointer on selected cluster slot in FAT mapper
+    slot_xp = ppm_page2base( page_xp ) + (slot_id << 2);
+         
+    // check selected cluster actually free
     if( hal_remote_l32( slot_xp ) != FREE_CLUSTER )
     { 
-        printk("\n[ERROR] in %s : illegal hint cluster\n", __FUNCTION__ );
+        printk("\n[ERROR] in %s : selected cluster %x not free\n", __FUNCTION__, cluster );
         remote_queuelock_acquire( lock_xp );
         return -1;
     }
 
-    // update allocated cluster in FAT mapper
-    hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
-
-    // update free cluster info
-    fatfs_free_clusters_decrement( hint + 1 );
+    // update free cluster info in FATFS context
+    fatfs_free_clusters_decrement( mapper_cxy , fat_fatfs_ctx , cluster );
 
     // release free clusters busylock
     remote_queuelock_release( lock_xp );
+
+    // update FAT mapper
+    hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
+
+    // synchronously update FAT on device
+    fatfs_move_page( page_xp , IOC_SYNC_WRITE );
 
 #if DEBUG_FATFS_CLUSTER_ALLOC 
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
-printk("\n[%s] thread[%x,%x] exit / cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, hint + 1, cycle );
-#endif
-
-    *searched_cluster = hint + 1;
+printk("\n[%s] thread[%x,%x] exit / updated cluster %x in FAT / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cluster, cycle );
+#endif
+
+    *searched_cluster = cluster;
     return 0;
 
@@ -2164 +2226 @@
     xptr_t        mapper_xp;      // extended pointer on FAT mapper
     cxy_t         mapper_cxy;     // Fat mapper cluster identifier
+    mapper_t    * mapper_ptr;     // local pointer on FAT mapper
     xptr_t        lock_xp;        // extended pointer on lock protecting free clusters info.
     xptr_t        first_xp;       // extended pointer on inode extension
@@ -2204 +2267 @@
     loc_fatfs_ctx = vfs_ctx->extend;
 
-    // get extended pointer and cluster on FAT mapper
+    // get pointers and cluster on FAT mapper
     mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
     mapper_cxy = GET_CXY( mapper_xp );
+    mapper_ptr = GET_PTR( mapper_xp );
     
     // get local pointer on FATFS context in FAT cluster 
@@ -2218 +2282 @@
 
     // call the recursive function to release all clusters from FAT mapper
-    if ( fatfs_recursive_release( mapper_xp , first_cluster ) )
+    if ( fatfs_recursive_release( mapper_cxy,
+                                  mapper_ptr,
+                                  fat_fatfs_ctx,
+                                  first_cluster ) )
     {
         printk("\n[ERROR] in %s : cannot update FAT mapper\n", __FUNCTION__ );
@@ -2300 +2367 @@
     {
         // get lba from FATFS context and page_id 
-        uint32_t      lba        = fatfs_ctx->fat_begin_lba + (page_id << 3);
+        uint32_t      lba = fatfs_ctx->fat_begin_lba + (page_id << 3);
  
         // access device
@@ -2311 +2378 @@
         if( error ) return EIO;
 
-#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
-if( DEBUG_FATFS_MOVE_PAGE < cycle )
-mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id );
-#endif
-
 #if DEBUG_FATFS_MOVE_PAGE
-cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
 {
@@ -2357 +2418 @@
                                        page_id,
                                        &searched_cluster );
-            if( error )  return EIO;
+            if( error )
+            {
+                printk("\n[ERROR] in %s : cannot access FAT mapper\n", __FUNCTION__ );
+                return -1;
+            }
         }
 
         // get lba from searched_cluster
         uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster );
+
+#if DEBUG_FATFS_MOVE_PAGE
+if( DEBUG_FATFS_MOVE_PAGE < cycle )
+{
+    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
+    printk("\n[%s] thread[%x,%x] load page %d of <%s> / cluster_id %x / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, searched_cluster, cycle );
+    else
+    printk("\n[%s] thread[%x,%x] sync page %d of <%s> / cluster_id %x / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, searched_cluster, cycle );
+}
+#endif
 
         // access device
@@ -2370 +2447 @@
         else                                  error = -1;
 
-        if( error ) return EIO;
-
-#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
-if( DEBUG_FATFS_MOVE_PAGE < cycle )
-mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id );
-#endif
-
-#if DEBUG_FATFS_MOVE_PAGE
-cycle = (uint32_t)hal_get_cycles();
-if(DEBUG_FATFS_MOVE_PAGE < cycle)
-{
-    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
-        printk("\n[%s] thread[%x,%x] load page %d of <%s> inode / cycle %d\n",
-        __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
-    else
-        printk("\n[%s] thread[%x,%x] sync page %d of <%s> inode / cycle %d\n",
-        __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
-}
-#endif
-
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ );
+            return -1;
+        }
     }
 

trunk/kernel/fs/fatfs.h

@@ -35 +35 @@
 // The FATFS File System implements a FAT32 read/write file system.
 //
-// The FATFS extensions to the generic VFS are the following:
+// The FATFS specific extensions to the generic VFS are the following:
 //
 // 1) The vfs_ctx_t "extend" field is a void* pointing on the fatfs_ctx_t structure.
@@ -190 +190 @@
     uint32_t            root_dir_cluster;      /*! cluster index for  root directory    */
     xptr_t              fat_mapper_xp;         /*! extended pointer on FAT mapper       */
-    uint32_t            free_cluster_hint;     /*! start point to search free cluster   */
+    uint32_t            free_cluster_hint;     /*! cluster[hint+1] is the first free    */
     uint32_t            free_clusters;         /*! free clusters number                 */
     remote_queuelock_t  free_lock;             /*! exclusive access to hint & number    */
@@ -224 +224 @@
 
 /*****************************************************************************************
- * This function display the content of the FATFS context.
- ****************************************************************************************/
-void fatfs_ctx_display( void );
+ * This function display the content of the local FATFS context.
+ *****************************************************************************************
+ * @ ctx  : local pointer on the context. 
+ ****************************************************************************************/
+void fatfs_ctx_display( fatfs_ctx_t * ctx );
 
 /*****************************************************************************************
@@ -312 +314 @@
  *****************************************************************************************
  * It initializes a new inode/dentry couple in Inode Tree, attached to the directory
- * identified by the <parent_inode> argument. The new directory entry is identified
- * by the <name> argument. The child inode descriptor identified by the <child_inode_xp>
- * argument, and the dentry descriptor must have been previously allocated.
+ * identified by the <parent_inode> argument. The directory entry is identified
+ * by the <name> argument. The child inode descriptor, identified by the <child_inode_xp>
+ * argument, and the associated dentry descriptor must have been previously allocated.
  * It scan the parent mapper to find the <name> argument.
- * It set the "type", "size", and "extend" fields in inode descriptor.
- * It set the " extend" field in dentry descriptor.
+ * It set the "type", "size", and "extend" fields in the child inode descriptor.
+ * It set the " extend" field in the dentry descriptor.
  * It must be called by a thread running in the cluster containing the parent inode.
  *****************************************************************************************
@@ -333 +335 @@
  *****************************************************************************************
  * It update the size of a directory entry identified by the <dentry> argument in
- * the mapper of a directory identified by the <inode> argument, as defined by the <size>
- * argument.
+ * the mapper of a directory identified by the <inode> argument, as defined by the
+ * <size> argument.
  * It scan the mapper to find the entry identified by the dentry "name" field.
  * It set the "size" field in the in the directory mapper AND marks the page as DIRTY.
@@ -427 +429 @@
  * in <searched_cluster> the FATFS cluster index of a free cluster.
  * It can be called by a thread running in any cluster, as it uses remote access
- * primitives when the FAT mapper is remote. It takes the "free_lock" stored in the 
- * FATFS context located in the same cluster as the FAT mapper itself, to get exclusive
- * access to the FAT. It uses (and updates) the <free_cluster_hint> and <free_clusters> 
- * shared variables in this FATFS context.
- * It updates the FAT mapper, and synchronously updates the FAT region on IOC device. 
- * The FAT mapper being a cache, this function updates the FAT mapper from informations
- * stored on IOC device in case of miss.
+ * primitives when the FAT mapper is remote. It takes the queuelock stored in the FATFS
+ * context (located in the same cluster as the FAT mapper itself), to get exclusive
+ * access to the FAT. It uses the <free_cluster_hint> and <free_clusters> variables 
+ * stored in this FATFS context.
+ * - it updates the <free_cluster_hint> and <free_clusters> variables in FATFS context.
+ * - it updates the FAT mapper (handling miss from IOC device if required). 
+ * - it synchronously updates the FAT region on IOC device. 
+ * - it returns the allocated cluster index.
  *****************************************************************************************
  * @ searched_cluster    : [out] found FATFS cluster index.
@@ -461 +464 @@
  * This function moves a page from/to the mapper to/from the FATFS file system on device.
  * The page must have been previously allocated and registered in the mapper.   
- * The page - and the mapper - can be located in another cluster than the calling thread.
  * The pointer on the mapper and the page index in file are found in the page descriptor.
  * It is used for both a regular file/directory mapper, and the FAT mapper.

trunk/kernel/fs/vfs.c

@@ -175 +175 @@
     else
     {
-        ctx = NULL;
-                assert( false , "illegal file system type = %d\n" , fs_type );
+        printk("\n[ERROR] in %s : illegal FS type\n", __FUNCTION__ );
+        return -1;
     }
 
@@ -185 +185 @@
     {
         printk("\n[ERROR] in %s : cannot allocate inum\n", __FUNCTION__ );
-        return ENOMEM;
+        return -1;
     }
 
@@ -378 +378 @@
 {
 
-assert( (inode != NULL) , "inode pointer is NULL\n" );
+assert( (inode != NULL) , "inode pointer is NULL" );
 
     uint32_t   page_id;
@@ -386 +386 @@
     uint32_t   size   = inode->size;
 
-assert( (mapper != NULL) , "mapper pointer is NULL\n" );
+assert( (mapper != NULL) , "mapper pointer is NULL" );
 
 #if DEBUG_VFS_INODE_LOAD_ALL
@@ -560 +560 @@
 void vfs_file_destroy( vfs_file_t *  file )
 {
-
-// check refcount
-// assert( (file->refcount == 0) , "refcount non zero\n" );
-
         kmem_req_t req;
         req.ptr   = file;
@@ -766 +762 @@
 
 // check argument
-assert( (file_xp != XPTR_NULL), "file_xp == XPTR_NULL\n" );
+assert( (file_xp != XPTR_NULL), "file_xp == XPTR_NULL" );
 
     // get cluster and local pointer on remote file descriptor
@@ -776 +772 @@
    
 // check inode type
-assert( (inode_type == INODE_TYPE_FILE), "inode type is not INODE_TYPE_FILE" );
+assert( (inode_type == INODE_TYPE_FILE), "bad inode type" );
 
     // get mapper pointer and file offset from file descriptor
     file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
-    mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+    mapper      = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
 
     // move data between mapper and buffer
@@ -788 +784 @@
                               buffer,
                               size );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot move data", __FUNCTION__ );
+        return -1;
+    }
 
     // update file offset in file descriptor
     hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->offset ) , size );
 
-    if( error ) 
-    {
-        return -1;
-    }
+#if DEBUG_VFS_USER_MOVE
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t      cycle      = (uint32_t)hal_get_cycles();
+thread_t    * this       = CURRENT_THREAD;
+vfs_inode_t * inode      = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
+if( cycle > DEBUG_VFS_USER_MOVE )
+{
+    if( to_buffer ) 
+    printk("\n[%s] thread[%x,%x] moves %d bytes from <%s> mapper to buffer (%x) / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, name, buffer );
+    else            
+    printk("\n[%s] thread[%x,%x] moves %d bytes from buffer (%x) to <%s> mapper / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, buffer, name );
+}
+#endif
 
     return size;
@@ -816 +829 @@
 
 // check argument
-assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
+assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
 
     // get cluster and local pointer on remote file descriptor
@@ -825 +838 @@
     inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
 
-    // action depends on inode type
-    if( inode_type == INODE_TYPE_FILE )
-    {
-        // get mapper pointers and file offset from file descriptor
-        file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
-        mapper_ptr  = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
-        mapper_xp   = XPTR( file_cxy , mapper_ptr );
-
-        // move data between mapper and buffer
-        error = mapper_move_kernel( mapper_xp,
-                                    to_buffer,
-                                    file_offset,
-                                    buffer_xp,
-                                    size );
-        if( error ) return -1;
-    }
-    else 
-    {
-        printk("\n[ERROR] in %s : inode is not a file", __FUNCTION__ );
+// check inode type
+assert( (inode_type == INODE_TYPE_FILE), "bad file type" );
+
+    // get mapper pointers and file offset from file descriptor
+    file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
+    mapper_ptr  = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+    mapper_xp   = XPTR( file_cxy , mapper_ptr );
+
+    // move data between mapper and buffer
+    error = mapper_move_kernel( mapper_xp,
+                                to_buffer,
+                                file_offset,
+                                buffer_xp,
+                                size );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot move data", __FUNCTION__ );
         return -1;
     }
+
+#if DEBUG_VFS_KERNEL_MOVE
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t      cycle      = (uint32_t)hal_get_cycles();
+thread_t    * this       = CURRENT_THREAD;
+cxy_t         buffer_cxy = GET_CXY( buffer_xp );
+void        * buffer_ptr = GET_PTR( buffer_xp );
+vfs_inode_t * inode      = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
+if( cycle > DEBUG_VFS_KERNEL_MOVE )
+{
+    if( to_buffer ) 
+    printk("\n[%s] thread[%x,%x] moves %d bytes from <%s> mapper to buffer(%x,%x) / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, name, buffer_cxy, buffer_ptr );
+    else            
+    printk("\n[%s] thread[%x,%x] moves %d bytes from buffer(%x,%x) to <%s> mapper / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, buffer_cxy, buffer_ptr, name );
+}
+#endif
 
     return 0;
@@ -866 +896 @@
 
 // check argument
-assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
+assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
 
     // get cluster and local pointer on remote file descriptor
@@ -946 +976 @@
 
 // check argument
-assert( (file_xp != XPTR_NULL) , "file_xp is XPTR_NULL\n" );
+assert( (file_xp != XPTR_NULL) , "file_xp is XPTR_NULL" );
 
     thread_t  * this    = CURRENT_THREAD;
@@ -997 +1027 @@
 #endif
 
-    //////// 2) update file size in all parent directory mapper(s) and on device
+    //////// 2) update file size in all parent directory mapper(s) and update device
 
     // get pointers on remote inode
@@ -1052 +1082 @@
 vfs_inode_get_name( XPTR( parent_cxy , parent_inode_ptr ) , parent_name );
 if( DEBUG_VFS_CLOSE < cycle )
-printk("\n[%s] thread[%x,%x] updated size of <%s> in parent <%s>\n",
-__FUNCTION__, process->pid, this->trdid, name, parent_name );
+printk("\n[%s] thread[%x,%x] updated <%s> in <%s> / size = %d bytes\n",
+__FUNCTION__, process->pid, this->trdid, name, parent_name, size );
 #endif
 
@@ -1114 +1144 @@
 #if DEBUG_VFS_CLOSE 
 if( DEBUG_VFS_CLOSE < cycle )
-printk("\n[%s] thread[%x,%x] reset all fd-array copies for <%x>\n",
+printk("\n[%s] thread[%x,%x] reset all fd-array copies for <%s>\n",
 __FUNCTION__, process->pid, this->trdid, name );
 #endif
@@ -1132 +1162 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_CLOSE < cycle )
-printk("\n[%s] thread[%x,%x] exit / <%s> closed / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, name, cycle );
+printk("\n[%s] thread[%x,%x] exit / closed <%s> in process %x / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, name, process->pid, cycle );
 #endif
 
@@ -2029 +2059 @@
     vfs_inode_type_t  inode_type;   // target inode type
 
-    // set lookup working mode
-    assert( (rights == 0), __FUNCTION__,
-    "access rights non implemented yet\n" );
+// check lookup working mode
+assert( (rights == 0), "access rights non implemented yet" );
  
     // get extended pointer on target inode
@@ -2051 +2080 @@
     // TODO implement this function
 
-assert( false , "not implemented\n" );
+assert( false , "not implemented" );
 
     return 0;
@@ -2061 +2090 @@
                     uint32_t rights )
 {
-    assert( false , "not implemented cwd_xp: %x, path <%s>, rights %x\n",
-      cwd_xp, path, rights );
+    assert( false , "not implemented %l %x %x", cwd_xp, path, rights );
     return 0;
 }
@@ -2084 +2112 @@
     vfs_inode_type_t   inode_type;
     uint32_t           inode_size;
-    uint32_t           inode_inum;
     uint32_t           inode_attr;
     uint32_t           inode_dirty;
+    void             * inode_extd;
+
     xptr_t             children_xp;    // extended pointer on children xhtab
 
@@ -2115 +2144 @@
                                         "                              " };  // level 15
 
-assert( (inode_xp != XPTR_NULL) , "inode_xp cannot be NULL\n" );
-assert( (name_xp  != XPTR_NULL) , "name_xp cannot be NULL\n" );
-assert( (indent < 16)           , "depth cannot be larger than 15\n" );
+assert( (inode_xp != XPTR_NULL) , "inode_xp cannot be NULL" );
+assert( (name_xp  != XPTR_NULL) , "name_xp cannot be NULL" );
+assert( (indent < 16)           , "depth cannot be larger than 15" );
     
     // get current inode cluster and local pointer
@@ -2126 +2155 @@
     inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type   ) );
     inode_size = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->size   ) );
-    inode_inum = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->inum   ) );
     inode_attr = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->attr   ) );
+    inode_extd = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->extend ) );
     mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
@@ -2137 +2166 @@
 
     // display inode
-    nolock_printk("%s<%s> : %s / inum %d / %d bytes / dirty %d / cxy %x / inode %x / mapper %x\n",
-                  indent_str[indent], name, vfs_inode_type_str( inode_type ),
-                  inode_inum, inode_size, inode_dirty, inode_cxy, inode_ptr, mapper_ptr );
+    nolock_printk("%s<%s> : %s / extd %d / %d bytes / dirty %d / cxy %x / inode %x / mapper %x\n",
+    indent_str[indent], name, vfs_inode_type_str( inode_type ), (uint32_t)inode_extd,
+    inode_size, inode_dirty, inode_cxy, inode_ptr, mapper_ptr );
 
     // scan directory entries when current inode is a directory
@@ -2405 +2434 @@
 // check pathname / root_xp consistency
 assert( ((pathname[0] != '/') || (root_xp == process->vfs_root_xp)), 
-"root inode must be VFS root for path <%s>\n", pathname );
+"root inode must be VFS root for path <%s>", pathname );
 
 #if DEBUG_VFS_LOOKUP
@@ -2550 +2579 @@
                 if ( error )   // child not found in parent mapper
                 {
-                    if ( last && create )  // add a brand new dentry in parent
+                    if ( last && create )  // add a brand new dentry in parent directory
                     {
                         error = vfs_new_dentry_init( parent_xp,                
@@ -2705 +2734 @@
     uint32_t    child_size;
 
-#if DEBUG_VFS_NEW_CHILD_INIT
+#if DEBUG_VFS_NEW_DENTRY_INIT
 char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
 char child_name[CONFIG_VFS_MAX_NAME_LENGTH];
@@ -2712 +2741 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
+if( DEBUG_VFS_NEW_DENTRY_INIT < cycle )
 printk("\n[%s] thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid, parent_name, child_name, cycle );
@@ -2741 +2770 @@
     }
 
-#if( DEBUG_VFS_NEW_CHILD_INIT & 1)
-if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
-printk("\n[%s] thread[%x,%x] allocated one FAT cluster to <%s>\n",
-__FUNCTION__ , this->process->pid, this->trdid, child_name );
+#if( DEBUG_VFS_NEW_DENTRY_INIT & 1)
+if( DEBUG_VFS_NEW_DENTRY_INIT < cycle )
+printk("\n[%s] thread[%x,%x] allocated FAT cluster %x to <%s>\n",
+__FUNCTION__ , this->process->pid, this->trdid, cluster, child_name );
 #endif
 
@@ -2775 +2804 @@
     }
 
-#if DEBUG_VFS_NEW_CHILD_INIT
+#if DEBUG_VFS_NEW_DENTRY_INIT
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
+if( DEBUG_VFS_NEW_DENTRY_INIT < cycle )
 printk("\n[%s] thread[%x,%x] exit / parent <%s> / child <%s> / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid, parent_name, child_name, cycle );
@@ -3085 +3114 @@
 
 // check buffer overflow
-assert( (index >= 0) , "kernel buffer too small\n" );
+assert( (index >= 0) , "kernel buffer too small" );
 
             }
@@ -3111 +3140 @@
 
 // check buffer overflow
-assert( (index >= 0) , "kernel buffer too small\n" );
+assert( (index >= 0) , "kernel buffer too small" );
 
             // update pathname
@@ -3379 +3408 @@
     error_t error = 0;
 
-assert( (page_xp != XPTR_NULL) , "page pointer is NULL\n" );
+assert( (page_xp != XPTR_NULL) , "page pointer is NULL" );
 
     page_t * page_ptr = GET_PTR( page_xp );
@@ -3387 +3416 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
 
-assert( (mapper != NULL) , "no mapper for page\n" );
+assert( (mapper != NULL) , "no mapper for page" );
 
     // get FS type
@@ -3407 +3436 @@
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3420 +3449 @@
     error_t error = 0;
 
-assert( (inode  != NULL) , "inode  pointer is NULL\n" );
-assert( (dentry != NULL) , "dentry pointer is NULL\n" );
+assert( (inode  != NULL) , "inode  pointer is NULL" );
+assert( (dentry != NULL) , "dentry pointer is NULL" );
 
     mapper_t * mapper = inode->mapper;
 
-assert( (mapper != NULL) , "mapper pointer is NULL\n" );
+assert( (mapper != NULL) , "mapper pointer is NULL" );
 
     // get FS type
@@ -3445 +3474 @@
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3458 +3487 @@
     error_t error = 0;
 
-assert( (inode  != NULL) , "inode  pointer is NULL\n" );
-assert( (dentry != NULL) , "dentry pointer is NULL\n" );
+assert( (inode  != NULL) , "inode  pointer is NULL" );
+assert( (dentry != NULL) , "dentry pointer is NULL" );
 
     mapper_t * mapper = inode->mapper;
 
-assert( (mapper != NULL) , "mapper pointer is NULL\n" );
+assert( (mapper != NULL) , "mapper pointer is NULL" );
 
     // get FS type
@@ -3483 +3512 @@
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3498 +3527 @@
 
 // check arguments
-assert( (parent != NULL) , "parent pointer is NULL\n");
-assert( (child_xp != XPTR_NULL) , "child pointer is NULL\n");
+assert( (parent != NULL) , "parent pointer is NULL");
+assert( (child_xp != XPTR_NULL) , "child pointer is NULL");
 
     // get parent inode FS type
@@ -3511 +3540 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3534 +3563 @@
 
 // check arguments
-assert( (inode  != NULL) , "inode  pointer is NULL\n");
-assert( (dentry != NULL) , "dentry pointer is NULL\n");
+assert( (inode  != NULL) , "inode  pointer is NULL");
+assert( (dentry != NULL) , "dentry pointer is NULL");
 
     // get parent inode FS type
@@ -3547 +3576 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3574 +3603 @@
 
 // check arguments
-assert( (inode != NULL) , "parent pointer is NULL\n");
-assert( (array != NULL) , "child pointer is NULL\n");
+assert( (inode != NULL) , "parent pointer is NULL");
+assert( (array != NULL) , "child pointer is NULL");
 assert( (detailed == false) , "detailed argument not supported\n");
 
@@ -3602 +3631 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
@@ -3616 +3645 @@
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3629 +3658 @@
 
 // check arguments
-assert( (inode != NULL) , "inode pointer is NULL\n");
+assert( (inode != NULL) , "inode pointer is NULL");
 
     // get inode FS type
@@ -3641 +3670 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3668 +3697 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3695 +3724 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3723 +3752 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 
@@ -3743 +3772 @@
     error_t error = 0;
 
-assert( (inode_xp  != XPTR_NULL) , "inode pointer is NULL\n")        
+assert( (inode_xp  != XPTR_NULL) , "inode pointer is NULL")        
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3751 +3780 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL\n")        
+assert( (mapper != NULL) , "mapper pointer is NULL")        
 
     // get FS type from mapper
@@ -3763 +3792 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type\n" );
+        assert( false , "undefined file system type" );
     }
 

trunk/kernel/fs/vfs.h

@@ -593 +593 @@
  * This function is called by the vfs_lookup() function when a new dentry/inode must
  * be created from scratch and introduced in both the Inode Tree and the IOC device.
- * The dentry and inode descriptors have been created by the caller:
+ * The dentry and inode descriptors have been created by the caller.
  * - It allocates one cluster from the relevant FS, and updates the File Allocation
  *   Table (both the FAT mapper, and the IOC device).
@@ -966 +966 @@
  * the <inode> argument, to find a directory entry identified by the <dentry> argument,
  * and update the size for this directory entry in mapper, as defined by <size>.
- * The searched "name" is defined in the <dentry> argument, that must be in the same 
- * cluster as the parent inode. It is called by the vfs_close() function.
+ * The parent directory on device is synchronously updated.
+ * It is called by the vfs_close() function.
  *
  * Depending on the file system type, it calls the relevant, FS specific function.

trunk/kernel/kern/chdev.c

@@ -138 +138 @@
     uint32_t   server_lid;    // core running the server thread local index
     xptr_t     lock_xp;       // extended pointer on lock protecting the chdev state
-    uint32_t   save_sr;       // for critical section
 
 #if (DEBUG_SYS_READ & 1)
@@ -177 +176 @@
 uint32_t rx_cycle = (uint32_t)hal_get_cycles();
 if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
-printk("\n[%s] client[%x,%x] enter for RX / server[%x,%x] / cycle %d\n",
+printk("\n[%s] client thread[%x,%x] enter for RX / server[%x,%x] / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid, rx_cycle );
 #endif
@@ -184 +183 @@
 uint32_t tx_cycle = (uint32_t)hal_get_cycles();
 if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
-printk("\n[%s] client[%x,%x] enter for TX / server[%x,%x] / cycle %d\n",
+printk("\n[%s] client thread[%x,%x] enter for TX / server[%x,%x] / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid, tx_cycle );
 #endif
@@ -194 +193 @@
     xptr_t  root_xp    = XPTR( chdev_cxy , &chdev_ptr->wait_root );
 
-    // build extended pointer on server thread blocked state
-    xptr_t  blocked_xp = XPTR( chdev_cxy , &server_ptr->blocked );
-
     // build extended pointer on lock protecting chdev waiting queue
     lock_xp            = XPTR( chdev_cxy , &chdev_ptr->wait_lock );
 
-    // TODO the hal_disable_irq() / hal_restore_irq() 
-    // in the sequence below is probably useless, as it is 
-    // already done by the busylock_acquire() / busylock_release()
-    // => remove it [AG] october 2018
-
-    // critical section for the following sequence: 
+    // The following actions execute in critical section,
+    // because the lock_acquire / lock_release : 
     // (1) take the lock protecting the chdev state
-    // (2) block the client thread
-    // (3) unblock the server thread if required
-    // (4) register client thread in server queue 
-    // (5) send IPI to force server scheduling
-    // (6) release the lock protecting waiting queue
-    // (7) deschedule
-
-    // enter critical section
-    hal_disable_irq( &save_sr );
-
-    // take the lock protecting chdev queue
+    // (2) register client thread in server queue 
+    // (3) unblock the server thread and block client thread
+    // (4) send IPI to force server scheduling
+    // (5) release the lock protecting waiting queue
+
+    // 1. take the lock protecting chdev queue
     remote_busylock_acquire( lock_xp );
 
-    // block current thread
-    thread_block( XPTR( local_cxy , CURRENT_THREAD ) , THREAD_BLOCKED_IO );
-
-#if (DEBUG_CHDEV_CMD_TX & 1)
-if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
-printk("\n[%s] client thread[%x,%x] blocked\n",
-__FUNCTION__, this->process->pid, this->trdid );
-#endif
-
-#if (DEBUG_CHDEV_CMD_RX & 1)
-if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
-printk("\n[%s] client thread[%x,%x] blocked\n",
-__FUNCTION__, this->process_pid, this->trdid );
-#endif
-
-    // unblock server thread if required
-    if( hal_remote_l32( blocked_xp ) & THREAD_BLOCKED_IDLE )
-    thread_unblock( server_xp , THREAD_BLOCKED_IDLE );
-
-#if (DEBUG_CHDEV_CMD_TX & 1)
-if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
-printk("\n[%s] TX server thread[%x,%x] unblocked\n",
-__FUNCTION__, server_pid, server_trdid );
-#endif
-
-#if (DEBUG_CHDEV_CMD_RX & 1)
-if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
-printk("\n[%s] RX server thread[%x,%x] unblocked\n",
-__FUNCTION__, server_pid, server_trdid );
-#endif
-
-    // register client thread in waiting queue 
+    // 2. register client thread in waiting queue 
     xlist_add_last( root_xp , list_xp );
 
@@ -266 +222 @@
 #endif
  
-    // send IPI to core running the server thread when server core != client core
+    // 3. client thread unblocks server thread and blocks itself
+    thread_unblock( server_xp , THREAD_BLOCKED_IDLE );
+    thread_block( XPTR( local_cxy , CURRENT_THREAD ) , THREAD_BLOCKED_IO );
+
+#if (DEBUG_CHDEV_CMD_TX & 1)
+if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
+printk("\n[%s] client thread[%x,%x] unblock server thread[%x,%x] and block itsef\n",
+__FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid );
+#endif
+
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[%s] client thread[%x,%x] unblock server thread[%x,%x] and block itsef\n",
+__FUNCTION__, this->process->pid, this->trdid, server_pid, server_trdid );
+#endif
+
+    // 4. send IPI to core running the server thread when server core != client core
     if( (server_lid != this->core->lid) || (local_cxy != chdev_cxy) )
     {
@@ -285 +257 @@
     }
  
-    // release lock protecting chdev queue
+    // 5. release lock protecting chdev queue
     remote_busylock_release( lock_xp );
 
     // deschedule
     sched_yield("blocked on I/O");
-
-    // exit critical section
-    hal_restore_irq( save_sr );
 
 #if DEBUG_CHDEV_CMD_RX
 rx_cycle = (uint32_t)hal_get_cycles();
 if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
-printk("\n[%s] client_thread[%x,%x] exit for RX / cycle %d\n",
+printk("\n[%s] client thread[%x,%x] exit for RX / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, rx_cycle );
 #endif
@@ -304 +273 @@
 tx_cycle = (uint32_t)hal_get_cycles();
 if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
-printk("\n[%s] client_thread[%x,%x] exit for TX / cycle %d\n",
+printk("\n[%s] client thread[%x,%x] exit for TX / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, tx_cycle );
 #endif
@@ -344 +313 @@
 uint32_t rx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
-printk("\n[%s] DEV thread[%x,%x] check TXT_RX channel %d / cycle %d\n",
+printk("\n[%s] server thread[%x,%x] check TXT_RX channel %d / cycle %d\n",
 __FUNCTION__ , server->process->pid, server->trdid, chdev->channel, rx_cycle );
 #endif
@@ -370 +339 @@
 rx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
-printk("\n[%s] thread[%x,%x] found RX queue empty => blocks / cycle %d\n",
+printk("\n[%s] server thread[%x,%x] found RX queue empty => blocks / cycle %d\n",
 __FUNCTION__ , server->process->pid, server->trdid, rx_cycle );
 #endif
@@ -377 +346 @@
 tx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
-printk("\n[%s] thread[%x,%x] found TX queue empty => blocks / cycle %d\n",
+printk("\n[%s] server thread[%x,%x] found TX queue empty => blocks / cycle %d\n",
 __FUNCTION__ , server->process->pid, server->trdid, tx_cycle );
 #endif
@@ -407 +376 @@
 rx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
-printk("\n[%s] thread[%x,%x] for RX get client thread[%x,%x] / cycle %d\n",
+printk("\n[%s] server thread[%x,%x] get command from client thread[%x,%x] / cycle %d\n",
 __FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, rx_cycle );
 #endif
@@ -414 +383 @@
 tx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
-printk("\n[%s] thread[%x,%x] for TX get client thread[%x,%x] / cycle %d\n",
+printk("\n[%s] server thread[%x,%x] get command from client thread[%x,%x] / cycle %d\n",
 __FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, tx_cycle );
 #endif
@@ -445 +414 @@
 rx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
-printk("\n[%s] thread[%x,%x] completes RX for client thread[%x,%x] / cycle %d\n",
+printk("\n[%s] thread[%x,%x] completes command for client thread[%x,%x] / cycle %d\n",
 __FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, rx_cycle );
 #endif
@@ -452 +421 @@
 tx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
-printk("\n[%s] thread[%x,%x] completes TX for client thread[%x,%x] / cycle %d\n",
+printk("\n[%s] thread[%x,%x] completes command for client thread[%x,%x] / cycle %d\n",
 __FUNCTION__, server->process->pid, server->trdid, client_pid, client_trdid, tX_cycle );
 #endif

trunk/kernel/kern/chdev.h

@@ -111 +111 @@
 /******************************************************************************************
  * This structure defines a chdev descriptor.
- * For multi-channels device, there is one chdev descriptor per channel.
  * This structure is NOT replicated, and can be located in any cluster.
  * One kernel thread, in charge of handling the commands registered in the waiting queue

trunk/kernel/kern/printk.c

@@ -253 +253 @@
                 break;
             }
-            case ('b'):             // excactly 2 digits hexadecimal
+            case ('b'):             /* exactly 2 digits hexadecimal */
             {
                 int  val = va_arg( *args, int );
@@ -426 +426 @@
 
     // print generic infos
-    nolock_printk("\n[PANIC] in %s: line %d | cycle %d\n"
+    nolock_printk("\n\n[PANIC] in %s: line %d | cycle %d\n"
                   "core[%x,%d] | thread %x (%x) | process %x (%x)\n",
                   function_name, line, (uint32_t)cycle,
@@ -502 +502 @@
     remote_busylock_acquire( lock_xp );
 
-    // display string on TTY0
+    // display buf on TTY0
     dev_txt_sync_write( buf , 10 );
+
+    // release TXT0 lock
+    remote_busylock_release( lock_xp );
+}
+
+////////////////////////
+void putd( int32_t val )
+{
+    static const char HexaTab[] = "0123456789ABCDEF";
+
+    char      buf[10];
+    uint32_t  i;
+
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
+
+    if (val < 0) 
+    {
+        val = -val;
+        dev_txt_sync_write( "-" , 1 );
+    }
+
+    for(i = 0; i < 10 ; i++) 
+    {
+        buf[9 - i] = HexaTab[val % 10];
+        if (!(val /= 10)) break;
+    }
+
+    // display buf on TTY0
+    dev_txt_sync_write( &buf[9-i] , i+1 );
 
     // release TXT0 lock

trunk/kernel/kern/printk.h

@@ -123 +123 @@
 
 /**********************************************************************************
- * This function displays a non-formated message on kernel TXT0 terminal.
+ * This function displays a non-formated message on TXT0 terminal.
  * This function is actually used to debug the assembly level kernel functions.
  **********************************************************************************
@@ -131 +131 @@
 
 /**********************************************************************************
- * This function displays a 32 bits value in hexadecimal on kernel TXT0 terminal.
+ * This function displays a 32 bits value in hexadecimal on TXT0 terminal.
  * This function is actually used to debug the assembly level kernel functions.
  **********************************************************************************
@@ -139 +139 @@
 
 /**********************************************************************************
- * This function displays a 64 bits value in hexadecimal on kernel TXT0 terminal.
+ * This function displays a 32 bits signed value in decimal on TXT0 terminal.
+ * This function is actually used to debug the assembly level kernel functions.
+ **********************************************************************************
+ * @ val   : 32 bits signed value.
+ *********************************************************************************/
+void putd( int32_t val );
+
+/**********************************************************************************
+ * This function displays a 64 bits value in hexadecimal on TXT0 terminal.
  * This function is actually used to debug the assembly level kernel functions.
  **********************************************************************************
@@ -147 +155 @@
 
 /**********************************************************************************
- * This debug function displays on the kernel TXT0 terminal the content of an
+ * This debug function displays on the TXT0 terminal the content of an
  * array of bytes defined by <buffer> and <size> arguments (16 bytes per line).
  * The <string> argument is displayed before the buffer content.

trunk/kernel/kern/process.c

@@ -91 +91 @@
 }
 
-/////////////////////////////////////////////////
-void process_reference_init( process_t * process,
-                             pid_t       pid,
-                             xptr_t      parent_xp )
-{
+////////////////////////////////////////////////////
+error_t process_reference_init( process_t * process,
+                                pid_t       pid,
+                                xptr_t      parent_xp )
+{
+    error_t     error;
     xptr_t      process_xp;
     cxy_t       parent_cxy;
@@ -105 +106 @@
     uint32_t    stdout_id;
     uint32_t    stderr_id;
-    error_t     error;
     uint32_t    txt_id;
     char        rx_path[40];
@@ -111 +111 @@
     xptr_t      file_xp;
     xptr_t      chdev_xp;
-    chdev_t *   chdev_ptr;
+    chdev_t   * chdev_ptr;
     cxy_t       chdev_cxy;
     pid_t       parent_pid;
+    vmm_t     * vmm;
 
     // build extended pointer on this reference process
     process_xp = XPTR( local_cxy , process );
+
+    // get pointer on process vmm
+    vmm = &process->vmm;
 
     // get parent process cluster and local pointer
@@ -129 +133 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
-printk("\n[%s] thread[%x,%x] enter to initalialize process %x / cycle %d\n",
-__FUNCTION__, parent_pid, this->trdid, pid, cycle );
+printk("\n[%s] thread[%x,%x] enter to initialize process %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, pid, cycle );
 #endif
 
@@ -144 +148 @@
     process->cwd_xp      = hal_remote_l64( XPTR( parent_cxy, &parent_ptr->cwd_xp ) );
 
-    // initialize vmm as empty 
-    error = vmm_init( process );
-
-assert( (error == 0) , "cannot initialize VMM\n" );
+    // initialize VSL as empty
+    vmm->vsegs_nr = 0;
+        xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
+
+    // create an empty GPT as required by the architecture
+    error = hal_gpt_create( &vmm->gpt );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot create empty GPT\n", __FUNCTION__ );
+        return -1;
+    }
+
+#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
+if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
+printk("\n[%s] thread[%x,%x] created empty GPT for process %x\n",
+__FUNCTION__, parent_pid, this->trdid, pid );
+#endif
+
+    // initialize GPT and VSL locks
+    remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
+        remote_rwlock_init( XPTR( local_cxy , &vmm->vsl_lock ) , LOCK_VMM_VSL );
+
+    // register kernel vsegs in VMM as required by the architecture
+    error = hal_vmm_kernel_update( process );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot register kernel vsegs in VMM\n", __FUNCTION__ );
+        return -1;
+    }
+
+#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
+if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
+printk("\n[%s] thread[%x,%x] registered kernel vsegs for process %x\n",
+__FUNCTION__, parent_pid, this->trdid, pid );
+#endif
+
+    // create "args" and "envs" vsegs
+    // create "stacks" and "mmap" vsegs allocators 
+    // initialize locks protecting GPT and VSL
+    error = vmm_user_init( process );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot register user vsegs in VMM\n", __FUNCTION__ );
+        return -1;
+    }
  
 #if (DEBUG_PROCESS_REFERENCE_INIT & 1)
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
-printk("\n[%s] thread[%x,%x] / vmm empty for process %x / cycle %d\n", 
-__FUNCTION__, parent_pid, this->trdid, pid, cycle );
+printk("\n[%s] thread[%x,%x] initialized vmm for process %x\n", 
+__FUNCTION__, parent_pid, this->trdid, pid );
 #endif
 
@@ -187 +232 @@
                            &stdin_xp, 
                            &stdin_id );
-
-assert( (error == 0) , "cannot open stdin pseudo file" );
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot open stdout pseudo-file\n", __FUNCTION__ );
+            return -1;
+        }
+
 assert( (stdin_id == 0) , "stdin index must be 0" );
 
@@ -206 +255 @@
                            &stdout_xp, 
                            &stdout_id );
-
-        assert( (error == 0) , "cannot open stdout pseudo file" );
-        assert( (stdout_id == 1) , "stdout index must be 1" );
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot open stdout pseudo-file\n", __FUNCTION__ );
+            return -1;
+        }
+
+assert( (stdout_id == 1) , "stdout index must be 1" );
 
 #if (DEBUG_PROCESS_REFERENCE_INIT & 1)
@@ -225 +278 @@
                            &stderr_xp, 
                            &stderr_id );
-
-        assert( (error == 0) , "cannot open stderr pseudo file" );
-        assert( (stderr_id == 2) , "stderr index must be 2" );
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot open stderr pseudo-file\n", __FUNCTION__ );
+            return -1;
+        }
+
+assert( (stderr_id == 2) , "stderr index must be 2" );
 
 #if (DEBUG_PROCESS_REFERENCE_INIT & 1)
@@ -240 +297 @@
     {
         // get extended pointer on stdin pseudo file in parent process
-        file_xp = (xptr_t)hal_remote_l64( XPTR( parent_cxy , &parent_ptr->fd_array.array[0] ) );
+        file_xp = (xptr_t)hal_remote_l64( XPTR( parent_cxy,
+                                                &parent_ptr->fd_array.array[0] ) );
 
         // get extended pointer on parent process TXT chdev
@@ -261 +319 @@
 
     // initialize lock protecting CWD changes
-    remote_busylock_init( XPTR( local_cxy , &process->cwd_lock ), LOCK_PROCESS_CWD );
+    remote_busylock_init( XPTR( local_cxy , 
+                                &process->cwd_lock ), LOCK_PROCESS_CWD );
 
 #if (DEBUG_PROCESS_REFERENCE_INIT & 1)
@@ -273 +332 @@
     xlist_root_init( XPTR( local_cxy , &process->children_root ) );
     process->children_nr     = 0;
-    remote_queuelock_init( XPTR( local_cxy , &process->children_lock ), LOCK_PROCESS_CHILDREN );
+    remote_queuelock_init( XPTR( local_cxy,
+                                 &process->children_lock ), LOCK_PROCESS_CHILDREN );
 
     // reset semaphore / mutex / barrier / condvar list roots and lock
@@ -280 +340 @@
     xlist_root_init( XPTR( local_cxy , &process->barrier_root ) );
     xlist_root_init( XPTR( local_cxy , &process->condvar_root ) );
-    remote_queuelock_init( XPTR( local_cxy , &process->sync_lock ), LOCK_PROCESS_USERSYNC );
+    remote_queuelock_init( XPTR( local_cxy , 
+                                 &process->sync_lock ), LOCK_PROCESS_USERSYNC );
 
     // reset open directories root and lock 
     xlist_root_init( XPTR( local_cxy , &process->dir_root ) );
-    remote_queuelock_init( XPTR( local_cxy , &process->dir_lock ), LOCK_PROCESS_DIR );
+    remote_queuelock_init( XPTR( local_cxy , 
+                                 &process->dir_lock ), LOCK_PROCESS_DIR );
 
     // register new process in the local cluster manager pref_tbl[]
@@ -315 +377 @@
 #endif
 
+    return 0;
+
 }  // process_reference_init()
 
@@ -321 +385 @@
                            xptr_t      reference_process_xp )
 {
-    error_t error;
+    error_t   error;
+    vmm_t   * vmm;
 
     // get reference process cluster and local pointer
     cxy_t       ref_cxy = GET_CXY( reference_process_xp );
     process_t * ref_ptr = GET_PTR( reference_process_xp );
+
+    // get pointer on process vmm
+    vmm = &local_process->vmm;
 
     // initialize PID, REF_XP, PARENT_XP, and STATE
@@ -343 +411 @@
 
 // check user process
-assert( (local_process->pid != 0), "PID cannot be 0" );
-
-    // reset local process vmm
-    error = vmm_init( local_process );
-    assert( (error == 0) , "cannot initialize VMM\n");
-
-    // reset process file descriptors array
+assert( (local_process->pid != 0), "LPID cannot be 0" );
+
+    // initialize VSL as empty
+    vmm->vsegs_nr = 0;
+        xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
+
+    // create an empty GPT as required by the architecture
+    error = hal_gpt_create( &vmm->gpt );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot create empty GPT\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // initialize GPT and VSL locks
+    remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
+        remote_rwlock_init( XPTR( local_cxy , &vmm->vsl_lock ) , LOCK_VMM_VSL );
+
+    // register kernel vsegs in VMM as required by the architecture
+    error = hal_vmm_kernel_update( local_process );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot register kernel vsegs in VMM\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // create "args" and "envs" vsegs
+    // create "stacks" and "mmap" vsegs allocators 
+    // initialize locks protecting GPT and VSL
+    error = vmm_user_init( local_process );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot register user vsegs in VMM\n", __FUNCTION__ );
+        return -1;
+    }
+ 
+#if (DEBUG_PROCESS_COPY_INIT & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_COPY_INIT < cycle )
+printk("\n[%s] thread[%x,%x] initialized vmm for process %x / cycle %d\n", 
+__FUNCTION__, parent_pid, this->trdid, pid, cycle );
+#endif
+
+    // set process file descriptors array
         process_fd_init( local_process );
 
-    // reset vfs_root_xp / vfs_bin_xp / cwd_xp fields
+    // set vfs_root_xp / vfs_bin_xp / cwd_xp fields
     local_process->vfs_root_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->vfs_root_xp ) );
     local_process->vfs_bin_xp  = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->vfs_bin_xp ) );
@@ -380 +485 @@
     local_process->th_nr  = 0;
     rwlock_init( &local_process->th_lock , LOCK_PROCESS_THTBL );
-
 
     // register new process descriptor in local cluster manager local_list
@@ -451 +555 @@
 #endif
 
-    // remove process from children_list 
-    // and release PID if owner cluster
+    // when target process cluster is the owner cluster
+    // - remove process from TXT list and transfer ownership
+    // - remove process from children_list 
+    // - release PID
     if( CXY_FROM_PID( pid ) == local_cxy )
     {
+        process_txt_detach( XPTR( local_cxy , process ) );
+
+#if (DEBUG_PROCESS_DESTROY & 1)
+if( DEBUG_PROCESS_DESTROY < cycle )
+printk("\n[%s] thread[%x,%x] removed process %x from TXT list\n",
+__FUNCTION__, this->process->pid, this->trdid, pid );
+#endif
+
         // get pointers on parent process
         parent_xp  = process->parent_xp;
@@ -472 +586 @@
 #if (DEBUG_PROCESS_DESTROY & 1)
 if( DEBUG_PROCESS_DESTROY < cycle )
-printk("\n[%s] thread[%x,%x] removed process %x in cluster %x from children list\n",
-__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy );
+printk("\n[%s] thread[%x,%x] removed process %x from parent process children list\n",
+__FUNCTION__, this->process->pid, this->trdid, pid );
 #endif
 
@@ -777 +891 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[%s] thread[%x,%x] enter in cluster %x for process %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, local_cxy, process->pid, cycle );
+printk("\n[%s] thread[%x,%x] enter for process %x n cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy, cycle );
 #endif
 
@@ -1189 +1303 @@
 }  // end process_register_thread()
 
-/////////////////////////////////////////////////
-bool_t process_remove_thread( thread_t * thread )
+///////////////////////////////////////////////////
+uint32_t process_remove_thread( thread_t * thread )
 {
     uint32_t count;  // number of threads in local process descriptor
+
+// check thread
+assert( (thread != NULL) , "thread argument is NULL" );
 
     process_t * process = thread->process;
@@ -1205 +1322 @@
     count = process->th_nr;
 
-// check thread
-assert( (thread != NULL) , "thread argument is NULL" );
-
 // check th_nr value
 assert( (count > 0) , "process th_nr cannot be 0" );
@@ -1218 +1332 @@
     rwlock_wr_release( &process->th_lock );
 
-    return (count == 1);
+    return count;
 
 }  // end process_remove_thread()
@@ -1283 +1397 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
-printk("\n[%s] thread[%x,%x] allocated process %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] allocated child_process %x / cycle %d\n",
 __FUNCTION__, pid, trdid, new_pid, cycle );
 #endif
 
     // initializes child process descriptor from parent process descriptor 
-    process_reference_init( process,
-                            new_pid,
-                            parent_process_xp );
+    error = process_reference_init( process,
+                                    new_pid,
+                                    parent_process_xp );
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : cannot initialize child process in cluster %x\n", 
+        __FUNCTION__, local_cxy ); 
+        process_free( process );
+        return -1;
+    }
 
 #if( DEBUG_PROCESS_MAKE_FORK & 1 )
@@ -1298 +1419 @@
 __FUNCTION__, pid, trdid, new_pid, cycle );
 #endif
-
 
     // copy VMM from parent descriptor to child descriptor
@@ -1361 +1481 @@
 #endif
 
-    // set Copy_On_Write flag in parent process GPT 
-    // this includes all replicated GPT copies
+    // set COW flag in DATA, ANON, REMOTE vsegs for parent process VMM
+    // this includes all parnet process copies in all clusters
     if( parent_process_cxy == local_cxy )   // reference is local
     {
@@ -1373 +1493 @@
     }
 
-    // set Copy_On_Write flag in child process GPT 
+    // set COW flag in DATA, ANON, REMOTE vsegs for child process VMM
     vmm_set_cow( process );
  
@@ -1423 +1543 @@
     char          ** args_pointers;           // array of pointers on main thread arguments
 
-    // get thread, process, pid and ref_xp 
+    // get calling thread, process, pid and ref_xp 
     thread  = CURRENT_THREAD;
     process = thread->process;
@@ -1470 +1590 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[%s] thread[%x,%x] deleted all threads / cycle %d\n",
+printk("\n[%s] thread[%x,%x] deleted existing threads / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );
 #endif
 
-    // reset local process VMM
-    vmm_destroy( process );
+    // reset calling process VMM
+    vmm_user_reset( process );
 
 #if( DEBUG_PROCESS_MAKE_EXEC & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[%s] thread[%x,%x] reset VMM / cycle %d\n",
+printk("\n[%s] thread[%x,%x] completed VMM reset / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );
 #endif
 
-    // re-initialize the VMM (kentry/args/envs vsegs registration)
-    error = vmm_init( process );
+    // re-initialize the VMM (args/envs vsegs registration)
+    error = vmm_user_init( process );
     if( error )
     {
@@ -1497 +1617 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[%s] thread[%x,%x] / kentry/args/envs vsegs registered / cycle %d\n",
+printk("\n[%s] thread[%x,%x] registered args/envs vsegs / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );
 #endif
@@ -1515 +1635 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[%s] thread[%x,%x] / code/data vsegs registered / cycle %d\n",
+printk("\n[%s] thread[%x,%x] registered code/data vsegs / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );
 #endif
@@ -1577 +1697 @@
     vmm->vsegs_nr = 0;
         xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
-        remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) , LOCK_VMM_VSL );
 
     // initialise GPT as empty
     error = hal_gpt_create( &vmm->gpt );
-
     if( error ) 
     {
@@ -1588 +1706 @@
     }
 
-    // initialize GPT lock
+    // initialize VSL and GPT locks
+        remote_rwlock_init( XPTR( local_cxy , &vmm->vsl_lock ) , LOCK_VMM_VSL );
     remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
     
     // create kernel vsegs in GPT and VSL, as required by the hardware architecture
     error = hal_vmm_kernel_init( info );
-
     if( error ) 
     {
@@ -1652 +1770 @@
     // allocates memory for process descriptor from local cluster
         process = process_alloc(); 
-        
-// check memory allocator
-assert( (process != NULL),
-"no memory for process descriptor in cluster %x", local_cxy  );
+    if( process == NULL )
+    {
+        printk("\n[PANIC] in %s : cannot allocate process\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 
     // set the CWD and VFS_ROOT fields in process descriptor
@@ -1663 +1782 @@
     // get PID from local cluster
     error = cluster_pid_alloc( process , &pid );
-
-// check PID allocator 
-assert( (error == 0),
-"cannot allocate PID in cluster %x", local_cxy );
-
-// check PID value
-assert( (pid == 1) ,
-"process INIT must be first process in cluster 0" );
+    if( error ) 
+    {
+        printk("\n[PANIC] in %s : cannot allocate PID\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    if( pid != 1 ) 
+    {
+        printk("\n[PANIC] in %s : process PID must be 0x1\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 
     // initialize process descriptor / parent is local process_zero
-    process_reference_init( process,
-                            pid,
-                            XPTR( local_cxy , &process_zero ) );  
+    error = process_reference_init( process,
+                                    pid,
+                                    XPTR( local_cxy , &process_zero ) );  
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot initialize process\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 
 #if(DEBUG_PROCESS_INIT_CREATE & 1)
@@ -1693 +1819 @@
                             &file_xp,
                             &file_id );
-
-assert( (error == 0),
-"failed to open file <%s>", CONFIG_PROCESS_INIT_PATH );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot open file <%s>\n",
+         __FUNCTION__, CONFIG_PROCESS_INIT_PATH  );
+        hal_core_sleep();
+    }
 
 #if(DEBUG_PROCESS_INIT_CREATE & 1)
@@ -1703 +1832 @@
 #endif
 
-   // register "code" and "data" vsegs as well as entry-point
+    // register "code" and "data" vsegs as well as entry-point
     // in process VMM, using information contained in the elf file.
         error = elf_load_process( file_xp , process );
 
-assert( (error == 0),
-"cannot access .elf file <%s>", CONFIG_PROCESS_INIT_PATH );
+    if( error ) 
+    {
+        printk("\n[PANIC] in %s : cannot access file <%s>\n",
+         __FUNCTION__, CONFIG_PROCESS_INIT_PATH  );
+        hal_core_sleep();
+    }
+
 
 #if(DEBUG_PROCESS_INIT_CREATE & 1)
@@ -1714 +1848 @@
 printk("\n[%s] thread[%x,%x] registered code/data vsegs in VMM\n",
 __FUNCTION__, this->process->pid, this->trdid );
+#endif
+
+#if (DEBUG_PROCESS_INIT_CREATE & 1)
+hal_vmm_display( process , true );
 #endif
 
@@ -1751 +1889 @@
                                 &thread );
 
-assert( (error == 0),
-"cannot create main thread for <%s>", CONFIG_PROCESS_INIT_PATH );
-
-assert( (thread->trdid == 0),
-"main thread must have index 0 for <%s>", CONFIG_PROCESS_INIT_PATH );
+    if( error )
+    {
+        printk("\n[PANIC] in %s : cannot create main thread\n", __FUNCTION__  );
+        hal_core_sleep();
+    }
+    if( thread->trdid != 0 )
+    {
+        printk("\n[PANIC] in %s : bad main thread trdid\n", __FUNCTION__  );
+        hal_core_sleep();
+    }
 
 #if(DEBUG_PROCESS_INIT_CREATE & 1)
@@ -1989 +2132 @@
     process_txt_transfer_ownership( process_xp );
 
-    // get extended pointer on process stdin file
+    // get extended pointer on process stdin pseudo file
     file_xp = (xptr_t)hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
 
@@ -2014 +2157 @@
 uint32_t txt_id = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[%s] thread[%x,%x] detached process %x from TXT %d / cycle %d\n",
+printk("\n[%s] thread[%x,%x] detached process %x from TXT%d / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, process_pid, txt_id, cycle );
 #endif
@@ -2056 +2199 @@
 uint32_t txt_id = hal_remote_l32( XPTR( txt_cxy , &txt_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[%s] thread[%x,%x] give TXT %d to process %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] give TXT%d ownership to process %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, txt_id, process_pid, cycle );
 #endif
@@ -2078 +2221 @@
     xptr_t      iter_xp;         // iterator for xlist
     xptr_t      current_xp;      // extended pointer on current process
-    process_t * current_ptr;     // local pointer on current process
-    cxy_t       current_cxy;     // cluster for current process
+    bool_t      found;
 
 #if DEBUG_PROCESS_TXT
@@ -2086 +2228 @@
 #endif
 
-    // get pointers on process in owner cluster
+    // get pointers on target process 
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
     process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
 
-    // check owner cluster
-    assert( (process_cxy == CXY_FROM_PID( process_pid )) ,
-    "process descriptor not in owner cluster" );
+// check owner cluster
+assert( (process_cxy == CXY_FROM_PID( process_pid )) ,
+"process descriptor not in owner cluster" );
 
     // get extended pointer on stdin pseudo file
@@ -2103 +2245 @@
     txt_ptr = GET_PTR( txt_xp );
 
-    // get extended pointer on TXT_RX owner and TXT channel
+    // get relevant infos from chdev descriptor
     owner_xp = hal_remote_l64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
-    txt_id   = hal_remote_l32 ( XPTR( txt_cxy , &txt_ptr->channel ) );
-
-    // transfer ownership only if process is the TXT owner
+    txt_id   = hal_remote_l32( XPTR( txt_cxy , &txt_ptr->channel ) );
+
+    // transfer ownership only if target process is the TXT owner
     if( (owner_xp == process_xp) && (txt_id > 0) )  
     {
@@ -2114 +2256 @@
         lock_xp = XPTR( txt_cxy , &txt_ptr->ext.txt.lock );
 
-        // get lock
-        remote_busylock_acquire( lock_xp );
-
-        if( process_get_ppid( process_xp ) != 1 )           // process is not KSH
+        if( process_get_ppid( process_xp ) != 1 )       // target process is not KSH
         {
+            // get lock
+            remote_busylock_acquire( lock_xp );
+
             // scan attached process list to find KSH process
-            XLIST_FOREACH( root_xp , iter_xp )
+            found = false;
+            for( iter_xp = hal_remote_l64( root_xp ) ;
+                 (iter_xp != root_xp) && (found == false) ;
+                 iter_xp = hal_remote_l64( iter_xp ) )
+            {
+                current_xp = XLIST_ELEMENT( iter_xp , process_t , txt_list );
+
+                if( process_get_ppid( current_xp ) == 1 )  // current is KSH 
+                {
+                    // set owner field in TXT chdev 
+                    hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
+
+#if DEBUG_PROCESS_TXT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_TXT < cycle )
+printk("\n[%s] thread[%x,%x] transfered TXT%d ownership to KSH / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, txt_id, cycle );
+#endif
+                    found = true;
+                }
+            }
+
+            // release lock
+            remote_busylock_release( lock_xp );
+
+// It must exist a KSH process for each user TXT channel
+assert( (found == true), "KSH process not found for TXT%d", txt_id );
+
+        }
+        else                                           // target process is KSH
+        {
+            // get lock
+            remote_busylock_acquire( lock_xp );
+
+            // scan attached process list to find another process 
+            found = false;
+            for( iter_xp = hal_remote_l64( root_xp ) ;
+                 (iter_xp != root_xp) && (found == false) ;
+                 iter_xp = hal_remote_l64( iter_xp ) )
             {
                 current_xp  = XLIST_ELEMENT( iter_xp , process_t , txt_list );
-                current_cxy = GET_CXY( current_xp );
-                current_ptr = GET_PTR( current_xp );
-
-                if( process_get_ppid( current_xp ) == 1 )  // current is KSH 
+
+                if( current_xp != process_xp )            // current is not KSH 
                 {
-                    // release lock
-                    remote_busylock_release( lock_xp );
-
                     // set owner field in TXT chdev 
                     hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
 
 #if DEBUG_PROCESS_TXT
-cycle = (uint32_t)hal_get_cycles();
-uint32_t ksh_pid = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
+cycle  = (uint32_t)hal_get_cycles();
+cxy_t       current_cxy = GET_CXY( current_xp );
+process_t * current_ptr = GET_PTR( current_xp );
+uint32_t    new_pid     = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[%s] thread[%x,%x] release TXT %d to KSH %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, txt_id, ksh_pid, cycle );
-process_txt_display( txt_id );
-#endif
-                     return;
+printk("\n[%s] thread[%x,%x] transfered TXT%d ownership to process %x / cycle %d\n",
+__FUNCTION__,this->process->pid, this->trdid, txt_id, new_pid, cycle );
+#endif
+                    found = true;
                 }
             }
- 
+
             // release lock
             remote_busylock_release( lock_xp );
 
-            // PANIC if KSH not found
-            assert( false , "KSH process not found for TXT %d" );
-
-            return;
+            // no more owner for TXT if no other process found
+            if( found == false )
+            {
+                // set owner field in TXT chdev 
+                hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , XPTR_NULL );
+
+#if DEBUG_PROCESS_TXT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_TXT < cycle )
+printk("\n[%s] thread[%x,%x] released TXT%d (no attached process) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, txt_id, cycle );
+#endif
+            }
         }
-        else                                               // process is KSH
-        {
-            // scan attached process list to find another process 
-            XLIST_FOREACH( root_xp , iter_xp )
-            {
-                current_xp  = XLIST_ELEMENT( iter_xp , process_t , txt_list );
-                current_cxy = GET_CXY( current_xp );
-                current_ptr = GET_PTR( current_xp );
-
-                if( current_xp != process_xp )            // current is not KSH 
-                {
-                    // release lock
-                    remote_busylock_release( lock_xp );
-
-                    // set owner field in TXT chdev 
-                    hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
+    }
+    else
+    {
 
 #if DEBUG_PROCESS_TXT
-cycle  = (uint32_t)hal_get_cycles();
-uint32_t new_pid = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[%s] thread[%x,%x] release TXT %d to process %x / cycle %d\n",
-__FUNCTION__,this->process->pid, this->trdid, txt_id, new_pid, cycle );
-process_txt_display( txt_id );
-#endif
-                     return;
-                }
-            }
-
-            // release lock
-            remote_busylock_release( lock_xp );
-
-            // no more owner for TXT if no other process found
-            hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , XPTR_NULL );
-
-#if DEBUG_PROCESS_TXT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[%s] thread[%x,%x] release TXT %d to nobody / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, txt_id, cycle );
-process_txt_display( txt_id );
-#endif
-            return;
-        }
-    }
-    else
-    {
-
-#if DEBUG_PROCESS_TXT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[%s] thread %x in process %d does nothing (not TXT owner) / cycle %d\n",
-__FUNCTION__, this->trdid, process_pid, cycle );
-process_txt_display( txt_id );
-#endif
-
-    }
+printk("\n[%s] thread[%x,%x] does nothing for process %x (not TXT owner) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process_pid, cycle );
+#endif
+
+    }
+
 }  // end process_txt_transfer_ownership()
 

trunk/kernel/kern/process.h

@@ -228 +228 @@
 
 /*********************************************************************************************
- * This function initializes a reference, user process descriptor from another process
+ * This function initializes a reference user process descriptor from another process
  * descriptor, defined by the <parent_xp> argument. The <process> and <pid> arguments 
  * are previously allocated by the caller. This function can be called by two functions:
- * 1) process_init_create() : process is the INIT process; parent is process-zero.
+ * 1) process_init_create() : process is the INIT process, and parent is process-zero.
  * 2) process_make_fork() : the parent process descriptor is generally remote.
  * The following fields are initialised :
  * - It set the pid / ppid / ref_xp / parent_xp / state fields.
- * - It initializes the VMM (register the kentry, args, envs vsegs in VSL)
+ * - It creates an empty GPT and an empty VSL.
+ * - It initializes the locks protecting the GPT and the VSL.
+ * - It registers the "kernel" vsegs in VSL, using the hal_vmm_kernel_update() function.
+ * - It registers the "args" and "envs" vsegs in VSL, using the vmm_user_init() function.
+ * - The "code and "data" must be registered later, using the elf_load_process() function.
  * - It initializes the FDT, defining the three pseudo files STDIN / STDOUT / STDERR.
  *   . if INIT process     => link to kernel TXT[0].
- *   . if KSH[i] process   => allocate a free TXT[i] and give TXT ownership.
- *   . if USER process     => same TXT[i] as parent process and give TXT ownership.
+ *   . if KSH[i] process   => allocate a free TXT[i].
+ *   . if USER process     => link to parent process TXT[i].
  * - It set the root_xp, bin_xp, cwd_xp fields.
  * - It reset the children list as empty, but does NOT register it in parent children list.
@@ -251 +255 @@
  * @ pid          : [in] process identifier.
  * @ parent_xp    : [in] extended pointer on parent process descriptor.
- ********************************************************************************************/
-void process_reference_init( process_t * process,
-                             pid_t       pid,
-                             xptr_t      parent_xp );
+ * @ return 0 if success / return -1 if failure
+ ********************************************************************************************/
+error_t process_reference_init( process_t * process,
+                                pid_t       pid,
+                                xptr_t      parent_xp );
 
 /*********************************************************************************************
  * This function initializes a copy process descriptor, in the local cluster,
  * from information defined in the reference remote process descriptor.
+ * As the VSL and the GPT of a process copy are handled as local caches, the GPT copy is 
+ * created empty, and the VSL copy contains only the "kernel", "args", and "envs" vsegs. 
  *********************************************************************************************
  * @ process              : [in] local pointer on process descriptor to initialize.
  * @ reference_process_xp : [in] extended pointer on reference process descriptor.
- * @ return 0 if success / return ENOMEM if failure
+ * @ return 0 if success / return -1 if failure
  ********************************************************************************************/
 error_t process_copy_init( process_t * local_process,
@@ -272 +279 @@
  * The local th_tbl[] array must be empty.
  *********************************************************************************************
- * @ process     : pointer on the process descriptor.
+ * @ process     : [in] pointer on the process descriptor.
  ********************************************************************************************/
 void process_destroy( process_t * process );
@@ -283 +290 @@
  * taken by the caller function. 
  *********************************************************************************************
- * @ process_xp : extended pointer on process descriptor.
+ * @ process_xp    : [in] extended pointer on process descriptor.
  ********************************************************************************************/
 void process_display( xptr_t process_xp );
@@ -396 +403 @@
 /*********************************************************************************************
  * This function implements the "fork" system call, and is called by the sys_fork() function,
- * likely throuch the RPC_PROCESS_MAKE_FORK. 
- * It allocates memory and initializes a new "child" process descriptor, and the associated
- * "child" thread descriptor in local cluster. It involves up to three different clusters :
+ * likely through the RPC_PROCESS_MAKE_FORK. 
+ * It allocates memory and initializes a new child process descriptor, and the associated
+ * child thread descriptor in local cluster. It involves up to three different clusters:
  * - the child (local) cluster can be any cluster selected 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.
- * The new "child" process descriptor is initialised from informations found in the "parent"
+ * The new child process descriptor is initialised from informations found in the parent
  * reference process descriptor, containing the complete process description.
- * The new "child" thread descriptor is initialised from informations found in the "parent"
+ * The new child thread descriptor is initialised from informations found in the parent
  * thread descriptor.
  *********************************************************************************************
@@ -504 +511 @@
 
 /*********************************************************************************************
- * This function atomically registers a new thread in the local process descriptor.
- * It checks that there is an available slot in the local th_tbl[] array, and allocates
- * a new LTID using the relevant lock depending on the kernel/user type.
- *********************************************************************************************
- * @ process  : pointer on the local process descriptor.
- * @ thread   : pointer on new thread to be registered.
+ * This function atomically registers a new thread identified by the <thread> argument 
+ * in the th_tbl[] array of the local process descriptor identified by the <process>
+ * argument. It checks that there is an available slot in the local th_tbl[] array,
+ * and allocates a new LTID using the relevant lock depending on the kernel/user type,
+ * and returns the global thread identifier in the <trdid> buffer.
+ *********************************************************************************************
+ * @ process  : [in]  pointer on the local process descriptor.
+ * @ thread   : [in]  pointer on new thread to be registered.
  * @ trdid    : [out] buffer for allocated trdid.
  * @ returns 0 if success / returns non zero if no slot available.
@@ -516 +525 @@
                                  struct thread_s * thread,
                                  trdid_t         * trdid );
+
+/*********************************************************************************************
+ * This function atomically removes a thread identified by the <thread> argument from 
+ * the local process descriptor th_tbl[] array, and returns the number of thread currently
+ * registered in th_tbl[] array before this remove.
+ *********************************************************************************************
+ * @ thread   : pointer on thread to be removed.
+ * @ returns number of threads registered in th_tbl before thread remove.
+ ********************************************************************************************/
+uint32_t process_remove_thread( struct thread_s * thread );
 
 
@@ -556 +575 @@
 
 /*********************************************************************************************
- * This function gives a process identified by the <process_xp> argument the exclusive
+ * This function gives a process identified by the <process_xp> argument the 
  * ownership of its attached TXT_RX terminal (i.e. put the process in foreground).
- * It can be called by a thread running in any cluster, but the <process_xp> must be the
- * owner cluster process descriptor. 
+ * It can be called by a thread running in any cluster, but the target process descriptor
+ * must be the process owner.
  *********************************************************************************************
  * @ owner_xp  : extended pointer on process descriptor in owner cluster.
@@ -566 +585 @@
 
 /*********************************************************************************************
- * When the process identified by the <owner_xp> argument has the exclusive ownership of
- * the TXT_RX terminal, this function transfer this ownership to another attached process.
- * The process descriptor must be the process owner.
- * This function does nothing if the process identified by the <process_xp> is not 
- * the TXT owner.
+ * When the target process identified by the <owner_xp> argument has the exclusive ownership
+ * of the TXT_RX terminal, this function transfer this ownership to another process attached
+ * to the same terminal. The target process descriptor must be the process owner.
+ * This function does nothing if the target process is not the TXT owner.
  * - If the current owner is not the KSH process, the new owner is the KSH process.
  * - If the current owner is the KSH process, the new owner is another attached process.

trunk/kernel/kern/rpc.c

@@ -24 +24 @@
 #include <kernel_config.h>
 #include <hal_kernel_types.h>
+#include <hal_vmm.h>
 #include <hal_atomic.h>
 #include <hal_remote.h>
@@ -52 +53 @@
     &rpc_pmem_get_pages_server,            // 0
     &rpc_pmem_release_pages_server,        // 1
-    &rpc_undefined,                        // 2    unused slot
+    &rpc_ppm_display_server,               // 2
     &rpc_process_make_fork_server,         // 3
     &rpc_user_dir_create_server,           // 4
@@ -81 +82 @@
     &rpc_vmm_create_vseg_server,           // 27
     &rpc_vmm_set_cow_server,               // 28
-    &rpc_hal_vmm_display_server,               // 29
+    &rpc_hal_vmm_display_server,           // 29
 };
 
@@ -88 +89 @@
     "PMEM_GET_PAGES",            // 0
     "PMEM_RELEASE_PAGES",        // 1
-    "undefined",                 // 2
+    "PPM_DISPLAY",               // 2
     "PROCESS_MAKE_FORK",         // 3
     "USER_DIR_CREATE",           // 4
@@ -566 +567 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [2]      undefined slot
-/////////////////////////////////////////////////////////////////////////////////////////
+// [2]            Marshaling functions attached to RPC_PPM_DISPLAY    
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////
+void rpc_ppm_display_client( cxy_t  cxy )
+{
+#if DEBUG_RPC_PPM_DISPLAY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_PPM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    uint32_t responses = 1;
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_PPM_DISPLAY;
+    rpc.blocking = true;
+    rpc.rsp      = &responses;
+
+    // register RPC request in remote RPC fifo
+    rpc_send( cxy , &rpc );
+
+#if DEBUG_RPC_PPM_DISPLAY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_PPM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+}
+
+////////////////////////////////////////////////////////////////////
+void rpc_ppm_display_server( xptr_t __attribute__((__unused__)) xp )
+{
+#if DEBUG_RPC_PPM_DISPLAY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_PPM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
+#endif
+
+    // call local kernel function
+    ppm_display();
+
+#if DEBUG_RPC_PPM_DISPLAY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_PPM_DISPLAY )
+printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, this->core->lid, cycle );
+#endif
+}
 
 /////////////////////////////////////////////////////////////////////////////////////////

trunk/kernel/kern/rpc.h

@@ -62 +62 @@
     RPC_PMEM_GET_PAGES            = 0,
     RPC_PMEM_RELEASE_PAGES        = 1,
-    RPC_UNDEFINED_2               = 2,      
+    RPC_PPM_DISPLAY               = 2,      
     RPC_PROCESS_MAKE_FORK         = 3,
     RPC_USER_DIR_CREATE           = 4,
@@ -200 +200 @@
 
 /***********************************************************************************
- * [2] undefined slot
- **********************************************************************************/
+ * [2] The RPC_PPM_DISPLAY allows any client thread to require any remote cluster
+ * identified by the <cxy> argumentto display the physical memory allocator state.
+ **********************************************************************************/
+void rpc_ppm_display_client( cxy_t  cxy );
+
+void rpc_ppm_display_server( xptr_t xp );
 
 /***********************************************************************************

trunk/kernel/kern/scheduler.c

@@ -180 +180 @@
     sched = &core->scheduler;
 
-    /////////////// scan user threads to handle both ACK and DELETE requests
+    ////////////////// scan user threads to handle both ACK and DELETE requests
     root = &sched->u_root;
     iter = root->next;
@@ -240 +240 @@
             busylock_release( &sched->lock );
 
-// check th_nr value
-assert( (process->th_nr > 0) , "process th_nr cannot be 0\n" );
-
-            // remove thread from process th_tbl[]
-            process->th_tbl[ltid] = NULL;
-            count = hal_atomic_add( &process->th_nr , - 1 );
- 
-            // release memory allocated for thread descriptor
-            thread_destroy( thread );
+            // release memory allocated for thread 
+            count = thread_destroy( thread );
 
             hal_fence();
@@ -255 +248 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_SCHED_HANDLE_SIGNALS < cycle )
-printk("\n[%s] thread[%x,%x] on core[%x,%d] deleted / cycle %d\n",
-__FUNCTION__ , process->pid , thread->trdid , local_cxy , thread->core->lid , cycle );
+printk("\n[%s] thread[%x,%x] on core[%x,%d] deleted / %d threads / cycle %d\n",
+__FUNCTION__, process->pid, thread->trdid, local_cxy, thread->core->lid, count, cycle );
 #endif
             // destroy process descriptor if last thread
@@ -274 +267 @@
     }  // end user threads
 
-    ////// scan kernel threads for DELETE only
+    ///////////// scan kernel threads for DELETE only
     root = &sched->k_root;
     iter = root->next;
@@ -290 +283 @@
 
 // check process descriptor is local kernel process
-assert( ( thread->process == &process_zero ) , "illegal process descriptor\n");
+assert( ( thread->process == &process_zero ) , "illegal process descriptor");
 
             // get thread ltid
@@ -325 +318 @@
 
 // check th_nr value
-assert( (process_zero.th_nr > 0) , "kernel process th_nr cannot be 0\n" );
+assert( (process_zero.th_nr > 0) , "kernel process th_nr cannot be 0" );
 
             // remove thread from process th_tbl[]
@@ -477 +470 @@
 }  // end sched_register_thread()
 
-//////////////////////////////////////
-void sched_yield( const char * cause )
+//////////////////////////////////////////////////////////////////
+void sched_yield( const char * cause __attribute__((__unused__)) )
 {
     thread_t      * next;
@@ -512 +505 @@
 // check next thread kernel_stack overflow
 assert( (next->signature == THREAD_SIGNATURE),
-"kernel stack overflow for thread %x on core[%x,%d] \n", next, local_cxy, lid );
+"kernel stack overflow for thread %x on core[%x,%d]", next, local_cxy, lid );
 
 // check next thread attached to same core as the calling thread
 assert( (next->core == current->core),
-"next core %x != current core %x\n", next->core, current->core );
+"next core %x != current core %x", next->core, current->core );
 
 // check next thread not blocked when type != IDLE
 assert( ((next->blocked == 0) || (next->type == THREAD_IDLE)) ,
-"next thread %x (%s) is blocked on core[%x,%d]\n", 
+"next thread %x (%s) is blocked on core[%x,%d]", 
 next->trdid , thread_type_str(next->type) , local_cxy , lid );
 
@@ -561 +554 @@
 #if (DEBUG_SCHED_YIELD & 1)
 // if( sched->trace )
-if(uint32_t)hal_get_cycles() > DEBUG_SCHED_YIELD )
+if( (uint32_t)hal_get_cycles() > DEBUG_SCHED_YIELD )
 printk("\n[%s] core[%x,%d] / cause = %s\n"
 "      thread %x (%s) (%x,%x) continue / cycle %d\n",
@@ -584 +577 @@
     list_entry_t * iter;
     thread_t     * thread;
-
-// check lid
-assert( (lid < LOCAL_CLUSTER->cores_nr), 
-"illegal core index %d\n", lid);
 
     core_t       * core    = &LOCAL_CLUSTER->core_tbl[lid];
@@ -644 +633 @@
 {
     thread_t     * thread;
-
-// check cxy
-assert( (cluster_is_undefined( cxy ) == false),
-"illegal cluster %x\n", cxy );
-
-assert( (lid < hal_remote_l32( XPTR( cxy , &LOCAL_CLUSTER->cores_nr ) ) ),
-"illegal core index %d\n", lid );
 
     // get local pointer on target scheduler

trunk/kernel/kern/thread.c

@@ -3 +3 @@
  *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
- *         Alain Greiner (2016,2017,2018)
+ *         Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -29 +29 @@
 #include <hal_special.h>
 #include <hal_remote.h>
+#include <hal_vmm.h>
 #include <memcpy.h>
 #include <printk.h>
@@ -96 +97 @@
 
 /////////////////////////////////////////////////////////////////////////////////////
-// This static function releases the physical memory for a thread descriptor.
-// It is called by the three functions:
-// - thread_user_create()
-// - thread_user_fork()
-// - thread_kernel_create()
-/////////////////////////////////////////////////////////////////////////////////////
-// @ thread  : pointer on thread descriptor.
-/////////////////////////////////////////////////////////////////////////////////////
-static void thread_release( thread_t * thread )
-{
-    kmem_req_t   req;
-
-    xptr_t base_xp = ppm_base2page( XPTR(local_cxy , thread ) );
-
-    req.type  = KMEM_PAGE;
-    req.ptr   = GET_PTR( base_xp );
-    kmem_free( &req );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////
 // This static function initializes a thread descriptor (kernel or user).
 // It can be called by the four functions:
@@ -122 +103 @@
 // - thread_kernel_create()
 // - thread_idle_init()
+// The "type" and "trdid" fields must have been previously set.
 // It updates the local DQDT.
 /////////////////////////////////////////////////////////////////////////////////////
-// @ thread       : pointer on local thread descriptor
-// @ process      : pointer on local process descriptor.
-// @ type         : thread type.
-// @ func         : pointer on thread entry function.
-// @ args         : pointer on thread entry function arguments.
-// @ core_lid     : target core local index.
-// @ u_stack_base : stack base (user thread only)
-// @ u_stack_size : stack base (user thread only)
+// @ thread          : pointer on local thread descriptor
+// @ process         : pointer on local process descriptor.
+// @ type            : thread type.
+// @ trdid           : thread identifier
+// @ func            : pointer on thread entry function.
+// @ args            : pointer on thread entry function arguments.
+// @ core_lid        : target core local index.
+// @ user_stack_vseg : local pointer on user stack vseg (user thread only)
 /////////////////////////////////////////////////////////////////////////////////////
 static error_t thread_init( thread_t      * thread,
                             process_t     * process,
                             thread_type_t   type,
+                            trdid_t         trdid,
                             void          * func,
                             void          * args,
                             lid_t           core_lid,
-                            intptr_t        u_stack_base,
-                            uint32_t        u_stack_size )
-{
-    error_t        error;
-    trdid_t        trdid;      // allocated thread identifier
-
-        cluster_t    * local_cluster = LOCAL_CLUSTER;
+                            vseg_t        * user_stack_vseg )
+{
+
+// check type and trdid fields initialized
+assert( (thread->type == type)   , "bad type argument" );
+assert( (thread->trdid == trdid) , "bad trdid argument" );
 
 #if DEBUG_THREAD_INIT
@@ -152 +134 @@
 if( DEBUG_THREAD_INIT < cycle )
 printk("\n[%s] thread[%x,%x] enter for thread %x in process %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, thread, process->pid , cycle );
+__FUNCTION__, this->process->pid, this->trdid, thread->trdid, process->pid , cycle );
 #endif
 
@@ -159 +141 @@
 
         // Initialize new thread descriptor
-        thread->type            = type;
     thread->quantum         = 0;            // TODO
     thread->ticks_nr        = 0;            // TODO
     thread->time_last_check = 0;            // TODO
-        thread->core            = &local_cluster->core_tbl[core_lid];
+        thread->core            = &LOCAL_CLUSTER->core_tbl[core_lid];
         thread->process         = process;
-
     thread->busylocks       = 0;
 
@@ -172 +152 @@
 #endif
 
-    thread->u_stack_base    = u_stack_base;
-    thread->u_stack_size    = u_stack_size;
+    thread->user_stack_vseg = user_stack_vseg;
     thread->k_stack_base    = (intptr_t)thread + desc_size;
     thread->k_stack_size    = CONFIG_THREAD_DESC_SIZE - desc_size;
-
     thread->entry_func      = func;         // thread entry point
     thread->entry_args      = args;         // thread function arguments
@@ -185 +163 @@
     thread->blocked         = THREAD_BLOCKED_GLOBAL;
 
-    // register new thread in process descriptor, and get a TRDID
-    error = process_register_thread( process, thread , &trdid );
-
-    if( error )
-    {
-        printk("\n[ERROR] in %s : thread %x in process %x cannot get TRDID in cluster %x\n"
-        "    for thread %s in process %x / cycle %d\n",
-        __FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
-        local_cxy, thread_type_str(type), process->pid, (uint32_t)hal_get_cycles() );
-        return EINVAL;
-    }
-
-    // initialize trdid 
-    thread->trdid           = trdid;
-
     // initialize sched list
     list_entry_init( &thread->sched_list );
@@ -237 +200 @@
 } // end thread_init()
 
-/////////////////////////////////////////////////////////
+//////////////////////////////////////////////////
 error_t thread_user_create( pid_t             pid,
                             void            * start_func,
@@ -246 +209 @@
     error_t        error;
         thread_t     * thread;       // pointer on created thread descriptor
+    trdid_t        trdid;        // created thred identifier
     process_t    * process;      // pointer to local process descriptor
     lid_t          core_lid;     // selected core local index
-    vseg_t       * vseg;         // stack vseg
+    vseg_t       * us_vseg;      // user stack vseg
 
 assert( (attr != NULL) , "pthread attributes must be defined" );
@@ -266 +230 @@
     {
                 printk("\n[ERROR] in %s : cannot get process descriptor %x\n",
-               __FUNCTION__ , pid );
-        return ENOMEM;
+        __FUNCTION__ , pid );
+        return -1;
     }
 
@@ -284 +248 @@
                 printk("\n[ERROR] in %s : illegal core index attribute = %d\n",
             __FUNCTION__ , core_lid );
-            return EINVAL;
+            return -1;
         }
     }
@@ -298 +262 @@
 #endif
 
-    // allocate a stack from local VMM
-    vseg = vmm_create_vseg( process,
-                            VSEG_TYPE_STACK,
-                            0,                 // size unused
-                            0,                 // length unused
-                            0,                 // file_offset unused
-                            0,                 // file_size unused
-                            XPTR_NULL,         // mapper_xp unused
-                            local_cxy );
-
-    if( vseg == NULL )
-    {
-            printk("\n[ERROR] in %s : cannot create stack vseg\n", __FUNCTION__ );
-                return ENOMEM;
-    }
-
-#if( DEBUG_THREAD_USER_CREATE & 1)
-if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[%s] stack vseg created / vpn_base %x / %d pages\n",
-__FUNCTION__, vseg->vpn_base, vseg->vpn_size );
-#endif
-
     // allocate memory for thread descriptor
     thread = thread_alloc();
@@ -325 +267 @@
     if( thread == NULL )
     {
-            printk("\n[ERROR] in %s : cannot create new thread\n", __FUNCTION__ );
-        vmm_delete_vseg( process->pid , vseg->min );
-        return ENOMEM;
+            printk("\n[ERROR] in %s : cannot create new thread in cluster %x\n",
+        __FUNCTION__, local_cxy );
+        return -1;
     }
 
@@ -336 +278 @@
 #endif
 
+    // set type in thread descriptor
+    thread->type = THREAD_USER;
+
+    // register new thread in process descriptor, and get a TRDID
+    error = process_register_thread( process, thread , &trdid );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot register new thread in process %x\n",
+        __FUNCTION__, pid );
+        thread_destroy( thread );
+        return -1;
+    }
+
+    // set trdid in thread descriptor 
+    thread->trdid = trdid;
+
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[%s] new thread %x registered in process %x\n",
+__FUNCTION__, trdid, pid );
+#endif
+
+    // allocate a stack from local VMM
+    us_vseg = vmm_create_vseg( process,
+                               VSEG_TYPE_STACK,
+                               LTID_FROM_TRDID( trdid ),
+                               0,                         // size unused
+                               0,                         // file_offset unused
+                               0,                         // file_size unused
+                               XPTR_NULL,                 // mapper_xp unused
+                               local_cxy );
+
+    if( us_vseg == NULL )
+    {
+            printk("\n[ERROR] in %s : cannot create stack vseg\n", __FUNCTION__ );
+        process_remove_thread( thread );
+        thread_destroy( thread );
+                return -1;
+    }
+
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[%s] stack vseg created / vpn_base %x / %d pages\n",
+__FUNCTION__, us_vseg->vpn_base, us_vseg->vpn_size );
+#endif
+
     // initialize thread descriptor
     error = thread_init( thread,
                          process,
                          THREAD_USER,
+                         trdid,
                          start_func,
                          start_arg,
                          core_lid,
-                         vseg->min,
-                         vseg->max - vseg->min );
+                         us_vseg );
     if( error )
     {
             printk("\n[ERROR] in %s : cannot initialize new thread\n", __FUNCTION__ );
-        vmm_delete_vseg( process->pid , vseg->min );
-        thread_release( thread );
-        return EINVAL;
+        vmm_remove_vseg( process , us_vseg );
+        process_remove_thread( thread );
+        thread_destroy( thread );
+        return -1;
     }
 
 #if( DEBUG_THREAD_USER_CREATE & 1)
 if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[%s] new thread descriptor initialised / trdid %x\n",
-__FUNCTION__, thread->trdid );
+printk("\n[%s] new thread %x in process %x initialised\n",
+__FUNCTION__, thread->trdid, process->pid );
 #endif
 
@@ -369 +359 @@
     {
             printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
-        vmm_delete_vseg( process->pid , vseg->min );
-        thread_release( thread );
-        return ENOMEM;
+        vmm_remove_vseg( process , us_vseg );
+        process_remove_thread( thread );
+        thread_destroy( thread );
+        return -1;
     }
     hal_cpu_context_init( thread );
@@ -379 +370 @@
     {
             printk("\n[ERROR] in %s : cannot create FPU context\n", __FUNCTION__ );
-        vmm_delete_vseg( process->pid , vseg->min );
-        thread_release( thread );
-        return ENOMEM;
+        vmm_remove_vseg( process , us_vseg );
+        process_remove_thread( thread );
+        thread_destroy( thread );
+        return -1;
     }
     hal_fpu_context_init( thread );
@@ -410 +402 @@
 {
     error_t        error;
-        thread_t     * child_ptr;        // local pointer on local child thread
+        thread_t     * child_ptr;        // local pointer on child thread
+    trdid_t        child_trdid;      // child thread identifier
     lid_t          core_lid;         // selected core local index
-
     thread_t     * parent_ptr;       // local pointer on remote parent thread
     cxy_t          parent_cxy;       // parent thread cluster
     process_t    * parent_process;   // local pointer on parent process
     xptr_t         parent_gpt_xp;    // extended pointer on parent thread GPT
-
-    void         * func;             // parent thread entry_func
-    void         * args;             // parent thread entry_args
-    intptr_t       base;             // parent thread u_stack_base
-    uint32_t       size;             // parent thread u_stack_size
-    uint32_t       flags;            // parent_thread flags
-    vpn_t          vpn_base;         // parent thread stack vpn_base
-    vpn_t          vpn_size;         // parent thread stack vpn_size
-    reg_t        * uzone;            // parent thread pointer on uzone  
-
-    vseg_t       * vseg;             // child thread STACK vseg
+    void         * parent_func;      // parent thread entry_func
+    void         * parent_args;      // parent thread entry_args
+    uint32_t       parent_flags;     // parent_thread flags
+    vseg_t       * parent_us_vseg;   // parent thread user stack vseg
+    vseg_t       * child_us_vseg;    // child thread user stack vseg
 
 #if DEBUG_THREAD_USER_FORK
@@ -433 +419 @@
 thread_t * this  = CURRENT_THREAD;
 if( DEBUG_THREAD_USER_FORK < cycle )
-printk("\n[%s] thread[%x,%x] enter / child_process %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] enter for child_process %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, child_process->pid, cycle );
 #endif
@@ -439 +425 @@
     // select a target core in local cluster
     core_lid = cluster_select_local_core();
+
+#if (DEBUG_THREAD_USER_FORK & 1)
+if( DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[%s] thread[%x,%x] selected core [%x,%d]\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, core_lid );
+#endif
 
     // get cluster and local pointer on parent thread descriptor
@@ -444 +436 @@
     parent_ptr = GET_PTR( parent_thread_xp );
 
-    // get relevant fields from parent thread 
-    func  = (void *)  hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->entry_func    ));
-    args  = (void *)  hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->entry_args    ));
-    base  = (intptr_t)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->u_stack_base  ));
-    size  = (uint32_t)hal_remote_l32 ( XPTR( parent_cxy , &parent_ptr->u_stack_size  ));
-    flags =           hal_remote_l32 ( XPTR( parent_cxy , &parent_ptr->flags         ));
-    uzone = (reg_t *) hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->uzone_current ));
-
-    vpn_base = base >> CONFIG_PPM_PAGE_SHIFT;
-    vpn_size = size >> CONFIG_PPM_PAGE_SHIFT;
+    // get relevant infos from parent thread 
+    parent_func    = (void *)  hal_remote_lpt( XPTR(parent_cxy,&parent_ptr->entry_func ));
+    parent_args    = (void *)  hal_remote_lpt( XPTR(parent_cxy,&parent_ptr->entry_args ));
+    parent_flags   = (uint32_t)hal_remote_l32( XPTR(parent_cxy,&parent_ptr->flags ));
+    parent_us_vseg = (vseg_t *)hal_remote_lpt( XPTR(parent_cxy,&parent_ptr->user_stack_vseg ));
 
     // get pointer on parent process in parent thread cluster
@@ -459 +446 @@
                                                         &parent_ptr->process ) );
  
-    // get extended pointer on parent GPT in parent thread cluster
+    // build extended pointer on parent GPT in parent thread cluster
     parent_gpt_xp = XPTR( parent_cxy , &parent_process->vmm.gpt );
+
+#if (DEBUG_THREAD_USER_FORK & 1)
+if( DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[%s] thread[%x,%x] get parent GPT\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
 
     // allocate memory for child thread descriptor
     child_ptr = thread_alloc();
+
     if( child_ptr == NULL )
     {
-        printk("\n[ERROR] in %s : cannot allocate new thread\n", __FUNCTION__ );
+        printk("\n[ERROR] in %s : cannot allocate new thread\n",
+        __FUNCTION__ );
         return -1;
     }
+
+#if (DEBUG_THREAD_USER_FORK & 1)
+if( DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[%s] thread[%x,%x] allocated new thread descriptor %x\n",
+__FUNCTION__, this->process->pid, this->trdid, child_ptr );
+#endif
+
+    // set type in thread descriptor
+    child_ptr->type = THREAD_USER;
+
+    // register new thread in process descriptor, and get a TRDID
+    error = process_register_thread( child_process, child_ptr , &child_trdid );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot register new thread in process %x\n",
+        __FUNCTION__, child_process->pid );
+        thread_destroy( child_ptr );
+        return -1;
+    }
+
+    // set trdid in thread descriptor
+    child_ptr->trdid = child_trdid;
+
+#if (DEBUG_THREAD_USER_FORK & 1)
+if( DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[%s] thread[%x,%x] registered child thread %x in child process %x\n",
+__FUNCTION__, this->process->pid, this->trdid, child_trdid, child_process->pid );
+#endif
+
+    // get an user stack vseg from local VMM allocator
+    child_us_vseg = vmm_create_vseg( child_process,
+                                     VSEG_TYPE_STACK,
+                                     LTID_FROM_TRDID( child_trdid ),  
+                                     0,                               // size unused
+                                     0,                               // file_offset unused
+                                     0,                               // file_size unused
+                                     XPTR_NULL,                       // mapper_xp unused
+                                     local_cxy );
+    if( child_us_vseg == NULL )
+    {
+            printk("\n[ERROR] in %s : cannot create stack vseg\n", __FUNCTION__ );
+        process_remove_thread( child_ptr );
+        thread_destroy( child_ptr );
+        return -1;
+    }
+
+#if (DEBUG_THREAD_USER_FORK & 1)
+if( DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[%s] thread[%x,%x] created an user stack vseg / vpn_base %x / %d pages\n",
+__FUNCTION__, this->process->pid, this->trdid,
+child_us_vseg->vpn_base, child_us_vseg->vpn_size );
+#endif
 
     // initialize thread descriptor
@@ -474 +522 @@
                          child_process,
                          THREAD_USER,
-                         func,
-                         args,
+                         child_trdid,
+                         parent_func,
+                         parent_args,
                          core_lid,
-                         base,
-                         size );
+                         child_us_vseg );
     if( error )
     {
             printk("\n[ERROR] in %s : cannot initialize child thread\n", __FUNCTION__ );
-        thread_release( child_ptr );
-        return EINVAL;
+        vmm_remove_vseg( child_process , child_us_vseg ); 
+        process_remove_thread( child_ptr );
+        thread_destroy( child_ptr );
+        return -1;
     }
 
@@ -492 +542 @@
 #endif
 
-    // return child pointer
-    *child_thread = child_ptr;
-
     // set detached flag if required
-    if( flags & THREAD_FLAG_DETACHED ) child_ptr->flags = THREAD_FLAG_DETACHED;
-
-    // update uzone pointer in child thread descriptor
-    child_ptr->uzone_current = (char *)((intptr_t)uzone +
-                                        (intptr_t)child_ptr - 
-                                        (intptr_t)parent_ptr );
- 
-
-    // allocate CPU context for child thread
+    if( parent_flags & THREAD_FLAG_DETACHED ) child_ptr->flags = THREAD_FLAG_DETACHED;
+
+    // allocate a CPU context for child thread
         if( hal_cpu_context_alloc( child_ptr ) )
     {
             printk("\n[ERROR] in %s : cannot allocate CPU context\n", __FUNCTION__ );
-        thread_release( child_ptr );
+        vmm_remove_vseg( child_process , child_us_vseg );
+        process_remove_thread( child_ptr );
+        thread_destroy( child_ptr );
         return -1;
     }
 
-    // allocate FPU context for child thread
+    // allocate a FPU context for child thread
         if( hal_fpu_context_alloc( child_ptr ) )
     {
             printk("\n[ERROR] in %s : cannot allocate FPU context\n", __FUNCTION__ );
-        thread_release( child_ptr );
+        vmm_remove_vseg( child_process , child_us_vseg );
+        process_remove_thread( child_ptr );
+        thread_destroy( child_ptr );
         return -1;
     }
@@ -526 +571 @@
 #endif
 
-   // create and initialize STACK vseg 
-    vseg = vseg_alloc();
-    vseg_init( vseg,
-               VSEG_TYPE_STACK,
-               base,
-               size,
-               vpn_base,
-               vpn_size,
-               0, 0, XPTR_NULL,                         // not a file vseg
-               local_cxy );
-
-    // register STACK vseg in local child VSL
-    vmm_attach_vseg_to_vsl( &child_process->vmm , vseg );
-
-#if (DEBUG_THREAD_USER_FORK & 1)
-if( DEBUG_THREAD_USER_FORK < cycle )
-printk("\n[%s] thread[%x,%x] created stack vseg for thread %x in process %x\n",
-__FUNCTION__, this->process->pid, this->trdid, child_ptr->trdid, child_process->pid );
-#endif
-
-    // copy all valid STACK GPT entries   
-    vpn_t          vpn;
-    bool_t         mapped;
-    ppn_t          ppn;
-    for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
+    // scan parent GPT, and copy all valid entries
+    // associated to user stack vseg into child GPT
+    vpn_t  parent_vpn;
+    vpn_t  child_vpn;
+    bool_t mapped;
+    ppn_t  ppn;
+    vpn_t  parent_vpn_base = hal_remote_l32( XPTR( parent_cxy, &parent_us_vseg->vpn_base ) );
+    vpn_t  parent_vpn_size = hal_remote_l32( XPTR( parent_cxy, &parent_us_vseg->vpn_size ) );
+    vpn_t  child_vpn_base  = child_us_vseg->vpn_base;
+    for( parent_vpn = parent_vpn_base , child_vpn = child_vpn_base ; 
+         parent_vpn < (parent_vpn_base + parent_vpn_size) ;
+         parent_vpn++ , child_vpn++ )
     {
         error = hal_gpt_pte_copy( &child_process->vmm.gpt,
+                                  child_vpn,
                                   parent_gpt_xp,
-                                  vpn,
+                                  parent_vpn,
                                   true,                 // set cow
                                   &ppn,
@@ -560 +593 @@
         if( error )
         {
-            vmm_detach_vseg_from_vsl( &child_process->vmm , vseg );
-            thread_release( child_ptr );
             printk("\n[ERROR] in %s : cannot update child GPT\n", __FUNCTION__ );
+            vmm_remove_vseg( child_process , child_us_vseg );
+            process_remove_thread( child_ptr );
+            thread_destroy( child_ptr );
             return -1;
         }
 
-        // increment pending forks counter for the page if mapped
+        // increment pending forks counter for a mapped page 
         if( mapped )
         {
@@ -574 +608 @@
             page_t * page_ptr = GET_PTR( page_xp );
 
-            // get extended pointers on forks and lock fields
+            // build extended pointers on forks and lock fields
             xptr_t forks_xp = XPTR( page_cxy , &page_ptr->forks );
             xptr_t lock_xp  = XPTR( page_cxy , &page_ptr->lock );
@@ -586 +620 @@
             // release lock protecting page
             remote_busylock_release( lock_xp );  
+        }
+    }
 
 #if (DEBUG_THREAD_USER_FORK & 1)
-cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_FORK < cycle )
-printk("\n[%s] thread[%x,%x] copied one PTE to child GPT : vpn %x / forks %d\n",
-__FUNCTION__, this->process->pid, this->trdid, 
-vpn, hal_remote_l32( XPTR( page_cxy , &page_ptr->forks) ) );
-#endif
-
-        }
-    }
-
-    // set COW flag for all mapped entries of STAK vseg in parent thread GPT 
+printk("\n[%s] thread[%x,%x] copied all stack vseg PTEs to child GPT\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+
+    // set COW flag for all mapped entries of user stack vseg in parent GPT 
     hal_gpt_set_cow( parent_gpt_xp,
-                     vpn_base,
-                     vpn_size );
- 
+                     parent_vpn_base,
+                     parent_vpn_size );
+
+#if (DEBUG_THREAD_USER_FORK & 1)
+if( DEBUG_THREAD_USER_FORK < cycle )
+printk("\n[%s] thread[%x,%x] set the COW flag for stack vseg in parent GPT\n",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
+
+    // return child pointer
+    *child_thread = child_ptr;
+
 #if DEBUG_THREAD_USER_FORK
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_FORK < cycle )
-printk("\n[%s] thread[%x,%x] exit / child_thread %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, child_ptr, cycle );
+printk("\n[%s] thread[%x,%x] exit / created thread[%x,%x] / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+child_ptr->process->pid, child_ptr->trdid, cycle );
 #endif
 
@@ -660 +701 @@
 
     // allocate an user stack vseg for main thread
-    vseg_t * vseg = vmm_create_vseg( process,
-                                     VSEG_TYPE_STACK,
-                                     0,                 // size unused
-                                     0,                 // length unused
-                                     0,                 // file_offset unused
-                                     0,                 // file_size unused
-                                     XPTR_NULL,         // mapper_xp unused
-                                     local_cxy );
-    if( vseg == NULL )
+    vseg_t * us_vseg = vmm_create_vseg( process,
+                                        VSEG_TYPE_STACK,
+                                        LTID_FROM_TRDID( thread->trdid ),
+                                        0,                 // length unused
+                                        0,                 // file_offset unused
+                                        0,                 // file_size unused
+                                        XPTR_NULL,         // mapper_xp unused
+                                        local_cxy );
+    if( us_vseg == NULL )
     {
             printk("\n[ERROR] in %s : cannot create stack vseg for main thread\n", __FUNCTION__ );
@@ -675 +716 @@
 
     // update user stack in thread descriptor
-    thread->u_stack_base = vseg->min;
-    thread->u_stack_size = vseg->max - vseg->min;
+    thread->user_stack_vseg = us_vseg;
     
     // release FPU ownership if required
@@ -710 +750 @@
     error_t        error;
         thread_t     * thread;       // pointer on new thread descriptor
+    trdid_t        trdid;        // new thread identifier
 
     thread_t * this = CURRENT_THREAD; 
@@ -737 +778 @@
     }
 
+    // set type in thread descriptor
+    thread->type = type;
+
+    // register new thread in local kernel process descriptor, and get a TRDID
+    error = process_register_thread( &process_zero , thread , &trdid );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot register thread in kernel process\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // set trdid in thread descriptor
+    thread->trdid = trdid;
+
     // initialize thread descriptor
     error = thread_init( thread,
                          &process_zero,
                          type,
+                         trdid,
                          func,
                          args,
                          core_lid,
-                         0 , 0 );  // no user stack for a kernel thread
+                         NULL );  // no user stack for a kernel thread
 
     if( error ) // release allocated memory for thread descriptor
     {
-        printk("\n[ERROR] in %s : thread %x in process %x\n"
-        "   cannot initialize thread descriptor\n",
-        __FUNCTION__, this->trdid, this->process->pid );
-        thread_release( thread );
+        printk("\n[ERROR] in %s : cannot initialize thread descriptor\n", __FUNCTION__ );
+        thread_destroy( thread );
         return ENOMEM;
     }
@@ -763 +818 @@
         "    cannot create CPU context\n",
         __FUNCTION__, this->trdid, this->process->pid );
-        thread_release( thread );
+        thread_destroy( thread );
         return EINVAL;
     }
@@ -791 +846 @@
                            lid_t           core_lid )
 {
+    trdid_t trdid;   
+    error_t error;
 
 // check arguments
@@ -796 +853 @@
 assert( (core_lid < LOCAL_CLUSTER->cores_nr) , "illegal core index" );
 
+    // set type in thread descriptor
+    thread->type = THREAD_IDLE;
+
+    // register idle thread in local kernel process descriptor, and get a TRDID
+    error = process_register_thread( &process_zero , thread , &trdid );
+
+assert( (error == 0), "cannot register idle_thread in kernel process" );
+
+    // set trdid in thread descriptor
+    thread->trdid = trdid;
+
     // initialize thread descriptor
-    error_t  error = thread_init( thread,
-                                  &process_zero,
-                                  type,
-                                  func,
-                                  args,
-                                  core_lid,
-                                  0 , 0 );   // no user stack for a kernel thread
-
-    assert( (error == 0), "cannot create thread idle" );
+    error = thread_init( thread,
+                         &process_zero,
+                         THREAD_IDLE,
+                         trdid,
+                         func,
+                         args,
+                         core_lid,
+                         NULL );   // no user stack for a kernel thread
+
+assert( (error == 0), "cannot initialize idle_thread" );
 
     // allocate & initialize CPU context if success
     error = hal_cpu_context_alloc( thread );
 
-    assert( (error == 0), "cannot allocate CPU context" );
+assert( (error == 0), "cannot allocate CPU context" );
 
     hal_cpu_context_init( thread );
@@ -816 +885 @@
 }  // end thread_idle_init()
 
-///////////////////////////////////////////////////////////////////////////////////////
-// TODO: check that all memory dynamically allocated during thread execution
-// has been released => check vmm destroy for MMAP vsegs  [AG]
-///////////////////////////////////////////////////////////////////////////////////////
-void thread_destroy( thread_t * thread )
-{
-    reg_t        save_sr;
-
-    process_t  * process    = thread->process;
-    core_t     * core       = thread->core;
+////////////////////////////////////////////
+uint32_t thread_destroy( thread_t * thread )
+{
+    reg_t           save_sr;
+    uint32_t        count;
+
+    thread_type_t   type    = thread->type;
+    process_t     * process = thread->process;
+    core_t        * core    = thread->core;
 
 #if DEBUG_THREAD_DESTROY
@@ -835 +903 @@
 #endif
 
-    // check busylocks counter
+    // check calling thread busylocks counter
     thread_assert_can_yield( thread , __FUNCTION__ );
 
-    // update intrumentation values
+    // update target process instrumentation counter
         process->vmm.pgfault_nr += thread->info.pgfault_nr;
 
-    // release memory allocated for CPU context and FPU context
+    // remove thread from process th_tbl[]
+    count = process_remove_thread( thread );
+
+    // release memory allocated for CPU context and FPU context if required
         hal_cpu_context_destroy( thread );
-        if ( thread->type == THREAD_USER ) hal_fpu_context_destroy( thread );
+        hal_fpu_context_destroy( thread );
         
+    // release user stack vseg (for an user thread only)
+    if( type == THREAD_USER )  vmm_remove_vseg( process , thread->user_stack_vseg );
+
     // release FPU ownership if required
         hal_disable_irq( &save_sr );
@@ -857 +931 @@
         thread->signature = 0;
 
-    // release memory for thread descriptor
-    thread_release( thread );
+    // release memory for thread descriptor (including kernel stack)
+    kmem_req_t   req;
+    xptr_t       base_xp = ppm_base2page( XPTR(local_cxy , thread ) );
+
+    req.type  = KMEM_PAGE;
+    req.ptr   = GET_PTR( base_xp );
+    kmem_free( &req );
 
 #if DEBUG_THREAD_DESTROY
@@ -866 +945 @@
 __FUNCTION__, this->process->pid, this->trdid, process->pid, thread->trdid, cycle );
 #endif
+
+    return count;
 
 }   // end thread_destroy()
@@ -993 +1074 @@
     cxy_t       target_cxy;             // target thread cluster     
     thread_t  * target_ptr;             // pointer on target thread
+    process_t * target_process;         // pointer on arget process
+    pid_t       target_pid;             // target process identifier
     xptr_t      target_flags_xp;        // extended pointer on target thread <flags>
     xptr_t      target_join_lock_xp;    // extended pointer on target thread <join_lock>
@@ -1006 +1089 @@
     target_ptr      = GET_PTR( target_xp );
 
-    // get target thread identifiers, and attached flag
+    // get target thread identifier, attached flag, and process PID
     target_trdid    = hal_remote_l32( XPTR( target_cxy , &target_ptr->trdid ) );
     target_ltid     = LTID_FROM_TRDID( target_trdid );
     target_flags_xp = XPTR( target_cxy , &target_ptr->flags ); 
     target_attached = ( (hal_remote_l32( target_flags_xp ) & THREAD_FLAG_DETACHED) == 0 );
+    target_process  = hal_remote_lpt( XPTR( target_cxy , &target_ptr->process ) );
+    target_pid      = hal_remote_l32( XPTR( target_cxy , &target_process->pid ) );
+
+// check target PID
+assert( (pid == target_pid),
+"unconsistent pid and target_xp arguments" );
 
     // get killer thread pointers
@@ -1027 +1116 @@
 // must be deleted by the parent process sys_wait() function
 assert( ((CXY_FROM_PID( pid ) != target_cxy) || (target_ltid != 0)),
-"tharget thread cannot be the main thread\n" );
+"target thread cannot be the main thread" );
 
     // check killer thread can yield 
@@ -1151 +1240 @@
 void thread_idle_func( void )
 {
+
+#if DEBUG_THREAD_IDLE
+uint32_t cycle;
+#endif
+
     while( 1 )
     {
@@ -1161 +1255 @@
 
 #if DEBUG_THREAD_IDLE
-{ 
-uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_IDLE < cycle )
 printk("\n[%s] idle thread on core[%x,%d] goes to sleep / cycle %d\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, cycle );
-}
 #endif
 
@@ -1172 +1264 @@
 
 #if DEBUG_THREAD_IDLE
-{
-uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_IDLE < cycle )
 printk("\n[%s] idle thread on core[%x,%d] wake up / cycle %d\n",
 __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, cycle );
-}
 #endif
 
@@ -1183 +1273 @@
 
 #if DEBUG_THREAD_IDLE
-{
-uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_IDLE < cycle )
 sched_display( CURRENT_THREAD->core->lid );
-}
 #endif     
         // search a runable thread

trunk/kernel/kern/thread.h

@@ -3 +3 @@
  *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
- *         Alain Greiner (2016,2017,2018)
+ *         Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -29 +29 @@
 #include <shared_syscalls.h>
 #include <hal_special.h>
+#include <hal_kentry.h>
 #include <xlist.h>
 #include <list.h>
@@ -100 +101 @@
 {
         uint32_t              pgfault_nr;    /*! cumulated number of page fault           */
-        uint32_t              sched_nr;      /*! TODO ???  [AG]                           */
-        uint32_t              u_err_nr;      /*! TODO ???  [AG]                           */
-        uint32_t              m_err_nr;      /*! TODO ???  [AG]                           */
         cycle_t               last_cycle;    /*! last cycle counter value (date)          */
         cycle_t               usr_cycles;    /*! user execution duration (cycles)         */
@@ -121 +119 @@
  *
  * WARNING (1) Don't modify the first 4 fields order, as this order is used by the
- *             hal_kentry assembly code for some architectures (TSAR).
+ *             hal_kentry assembly code for the TSAR architectures.
  *
  * WARNING (2) Most of the thread state is private and accessed only by this thread,
@@ -165 +163 @@
     uint32_t          * ack_rsp_count;   /*! pointer on acknowledge response counter  */
 
-        intptr_t            u_stack_base;    /*! user stack base address                  */
-        uint32_t            u_stack_size;    /*! user stack size (bytes)                  */
+        vseg_t            * user_stack_vseg; /*! local pointer on user stack vseg         */
 
     void              * entry_func;      /*! pointer on entry function                */
@@ -248 +245 @@
 
 /***************************************************************************************
- * This function is used by the sys_fork() system call to create the "child" thread
- * in the local cluster. It allocates memory for a thread descriptor, and initializes
- * it from the "parent" thread descriptor defined by the <parent_thread_xp> argument.
+ * This function is used by the sys_fork() syscall to create the "child" main thread
+ * in the local cluster. It is called, generally through the RPC_PROCESS_MAKE_FORK,
+ * by the process_make_fork() function. It allocates memory from the local cluster
+ * for a "child" thread descriptor, and initializes it from the "parent" thread 
+ * descriptor defined by the <parent_thread_xp> argument.
  * The new thread is attached to the core that has the lowest load in local cluster.
  * It is registered in the "child" process defined by the <child_process> argument.
@@ -259 +258 @@
  * uses physical addressing on some architectures).
  * The CPU and FPU execution contexts are created and linked to the new thread.
- * but the actual context copy is NOT done, and must be done by by the sys_fork(). 
+ * but the actual context copy is NOT done, and is done by the sys_fork() function. 
  * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated to start.
  ***************************************************************************************
@@ -273 +272 @@
 /***************************************************************************************
  * This function is called by the process_make_exec() function to re-initialise the
- * thread descriptor of the calling thread (that will become the new process main
- * thread), and immediately jump to user code without returning to kentry!!!
+ * calling thread descriptor, that will become the new process main thread.
  * It must be called by the main thread of the calling process.
+ * - The calling thread TRDID is not modified.
+ * - The kernel stack (currently in use) is not modified.  
  * - A new user stack vseg is created and initialised.
- * - The kernel stack (currently in use) is not modified.  
  * - The function calls the hal_cpu_context_exec() to re-initialize the CPU context
- *   an jump to user code.  
+ *   and the uzone registered in kernel stack, an jump to user code.  
  ***************************************************************************************
  * @ entry_func : main thread entry point.
@@ -329 +328 @@
 
 /***************************************************************************************
- * This low-level function is called by the sched_handle_signals() function to releases 
- * the physical memory allocated for a thread in a given cluster, when this thread 
- * is marked for delete. This include the thread descriptor itself, the associated 
- * CPU and FPU context, and the physical memory allocated for an user thread local stack.
+ * This low-level function is called by the sched_handle_signals() function when a
+ * thread is marked for delete. It removes the thread identified by the <thread>
+ * argument from the process th_tbl[], and releases all physical memory allocated for 
+ * this. This includes the thread descriptor itself, the associated CPU and FPU context,
+ * and the physical memory allocated for an user thread stack.
  ***************************************************************************************
  * @ thread  : pointer on the thread descriptor to release.
- * @ return true, if the thread was the last registerd thread in local process.
- **************************************************************************************/
-void thread_destroy( thread_t * thread );
+ * @ return the number of threads registered in the process th_tbl[] before deletion.
+ **************************************************************************************/
+uint32_t thread_destroy( thread_t * thread );
 
 /***************************************************************************************
@@ -383 +383 @@
  * This function is used by the four sys_thread_cancel(), sys_thread_exit(),
  * sys_kill() and sys_exit() system calls to mark for delete a given thread. 
- * It set the THREAD_BLOCKED_GLOBAL bit and set the the THREAD_FLAG_REQ_DELETE bit
- * in the thread descriptor identified by the <thread_xp> argument, to ask the scheduler 
+ * It set the THREAD_BLOCKED_GLOBAL bit and set the THREAD_FLAG_REQ_DELETE bit in the
+ * thread descriptor identified by the <thread_xp> argument, to ask the scheduler 
  * to asynchronously delete the target thread, at the next scheduling point. 
- * The calling thread can run in any cluster, as it uses remote accesses, but
- * the target thread cannot be the main thread of the process identified by the <pid>
- * argument, because the main thread must be deleted by the parent process argument.
+ * The calling thread can run in any cluster, as it uses remote accesses.
+ * This function makes a kernel panic if the target thread is the main thread,
+ * because * the main thread deletion will cause the process deletion, and a process
+ * must be deleted by the parent process, running the wait function.
  * If the target thread is running in "attached" mode, and the <is_forced> argument
  * is false, this function implements the required sychronisation with the joining 

trunk/kernel/kernel_config.h

@@ -26 +26 @@
 #define _KERNEL_CONFIG_H_
 
-#define CONFIG_ALMOS_VERSION           "Version 1.1 / October 2018"
+#define CONFIG_ALMOS_VERSION           "Version 2.0 / April 2019"
 
 ////////////////////////////////////////////////////////////////////////////////////////////
@@ -40 +40 @@
 
 #define DEBUG_BUSYLOCK                    0
-#define DEBUG_BUSYLOCK_PID                0x10001    // thread pid (when detailed debug)
-#define DEBUG_BUSYLOCK_TRDID              0x10000    // thread trdid (when detailed debug)
+#define DEBUG_BUSYLOCK_PID                0x10001    // for busylock detailed debug
+#define DEBUG_BUSYLOCK_TRDID              0x10000    // for busylock detailed debug
                  
 #define DEBUG_CHDEV_CMD_RX                0
@@ -92 +92 @@
 #define DEBUG_FATFS_UPDATE_DENTRY         0
 
+#define DEBUG_HAL_CONTEXT                 0
 #define DEBUG_HAL_EXCEPTIONS              0
 #define DEBUG_HAL_GPT_SET_PTE             0
@@ -164 +165 @@
 
 #define DEBUG_SCHED_HANDLE_SIGNALS        2
-#define DEBUG_SCHED_YIELD                 0     
+#define DEBUG_SCHED_YIELD                 0
 #define DEBUG_SCHED_RPC_ACTIVATE          0
 
@@ -186 +187 @@
 #define DEBUG_SYS_IS_FG                   0
 #define DEBUG_SYS_KILL                    0
-#define DEBUG_SYS_OPEN                    0
-#define DEBUG_SYS_OPENDIR                 0
 #define DEBUG_SYS_MKDIR                   0
 #define DEBUG_SYS_MMAP                    0
 #define DEBUG_SYS_MUNMAP                  0
 #define DEBUG_SYS_MUTEX                   0
+#define DEBUG_SYS_OPEN                    0
+#define DEBUG_SYS_OPENDIR                 0
 #define DEBUG_SYS_READ                    0
 #define DEBUG_SYS_READDIR                 0
@@ -230 +231 @@
 #define DEBUG_VFS_INODE_CREATE            0
 #define DEBUG_VFS_INODE_LOAD_ALL          0
+#define DEBUG_VFS_KERNEL_MOVE             0
 #define DEBUG_VFS_LINK                    0
 #define DEBUG_VFS_LOOKUP                  0
 #define DEBUG_VFS_LSEEK                   0
 #define DEBUG_VFS_MKDIR                   0
-#define DEBUG_VFS_NEW_CHILD_INIT          0
+#define DEBUG_VFS_NEW_DENTRY_INIT         0
 #define DEBUG_VFS_OPEN                    0
 #define DEBUG_VFS_OPENDIR                 0
 #define DEBUG_VFS_STAT                    0
+#define DEBUG_VFS_USER_MOVE               0
 #define DEBUG_VFS_UNLINK                  0
 
@@ -248 +251 @@
 #define DEBUG_VMM_HANDLE_PAGE_FAULT       0
 #define DEBUG_VMM_HANDLE_COW              0
-#define DEBUG_VMM_INIT                    0
 #define DEBUG_VMM_MMAP_ALLOC              0
 #define DEBUG_VMM_PAGE_ALLOCATE           0
+#define DEBUG_VMM_REMOVE_VSEG             0
 #define DEBUG_VMM_RESIZE_VSEG             0
 #define DEBUG_VMM_SET_COW                 0
 #define DEBUG_VMM_UPDATE_PTE              0
+#define DEBUG_VMM_USER_INIT               0
+#define DEBUG_VMM_USER_RESET              0
 
 #define DEBUG_XHTAB                       0
@@ -421 +426 @@
 #define CONFIG_VMM_ARGS_SIZE          0x000004     // args vseg size         : 16  Kbytes
 #define CONFIG_VMM_ENVS_SIZE          0x000008     // envs vseg size         : 32  Kbytes
-#define CONFIG_VMM_STACK_SIZE         0x000100     // single stack vseg size : 1   Mbytes
+#define CONFIG_VMM_STACK_SIZE         0x001000     // single stack vseg size : 16  Mbytes
 
 ////////////////////////////////////////////////////////////////////////////////////////////

trunk/kernel/libk/elf.c

@@ -196 +196 @@
 
 #if DEBUG_ELF_LOAD
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_ELF_LOAD < cycle )
-printk("\n[%s] found %s vseg / base %x / size %x\n"
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_ELF_LOAD < cycle )
+printk("\n[%s] thread[%x,%x] 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 ,
+__FUNCTION__ , this->process_pid, this->trdid, 
+vseg_type_str(vseg->type) , vseg->min , vseg->max - vseg->min ,
 vseg->file_size , vseg->file_offset , vseg->mapper_xp );
 #endif

trunk/kernel/libk/elf.h

@@ -228 +228 @@
 
 /****************************************************************************************
- * This function registers in VMM of the process identified by the <process> argument
- * the CODE and DATA vsegs defined in the .elf open file descriptor <file_xp>.
+ * This function registers in the VSL of the process identified by the <process>
+ * argument the CODE and DATA vsegs defined in the .elf file descriptor <file_xp>.
  * The segments are not loaded in memory.
  * It also registers the process entry point in VMM.

trunk/kernel/libk/remote_rwlock.c

@@ -251 +251 @@
         thread_t *  thread_ptr = GET_PTR( thread_xp ); 
 
+printk("\n@@@ in %s : release first waiting writer[%x,%x]\n",
+__FUNCTION__, thread_cxy, thread_ptr );
+
         // remove this waiting thread from waiting list
         xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_xlist ) );

trunk/kernel/mm/mapper.c

@@ -153 +153 @@
 
 #if DEBUG_MAPPER_GET_PAGE
-uint32_t cycle = (uint32_t)hal_get_cycles();
+vfs_inode_t * inode = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
+uint32_t      cycle = (uint32_t)hal_get_cycles();
 char          name[CONFIG_VFS_MAX_NAME_LENGTH];
-vfs_inode_t * inode = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
-vfs_inode_get_name( XPTR( mapper_cxy , inode ) , name );
-if( DEBUG_MAPPER_GET_PAGE < cycle )
-printk("\n[%s] thread [%x,%x] enter for page %d of <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode == NULL) )  // FAT mapper
+{
+    printk("\n[%s] thread[%x,%x] enter for page %d of FAT mapper / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+}
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )  // file mapper
+{
+    vfs_inode_get_name( XPTR( mapper_cxy , inode ) , name );
+    printk("\n[%s] thread[%x,%x] enter for page %d of <%s> mapper / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
+}
 #endif
 
@@ -235 +242 @@
 #if DEBUG_MAPPER_GET_PAGE
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_MAPPER_GET_PAGE < cycle )
-printk("\n[%s] thread[%x,%x] exit for page %d of <%s> / ppn %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, 
-page_id, name, ppm_page2ppn( page_xp ), cycle );
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d of <%s> mapper / ppn %x / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id,
+    name, ppm_page2ppn(page_xp), cycle );
+}
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d of FAT mapper  / ppn %x / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id,
+    ppm_page2ppn(page_xp), cycle );
+}
 #endif
 
@@ -257 +272 @@
 
 #if DEBUG_MAPPER_HANDLE_MISS
-uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t      cycle = (uint32_t)hal_get_cycles();
 char          name[CONFIG_VFS_MAX_NAME_LENGTH];
 vfs_inode_t * inode = mapper->inode;
-vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
-if( DEBUG_MAPPER_HANDLE_MISS < cycle )
-printk("\n[%s] enter for page %d in <%s> / cycle %d",
-__FUNCTION__, page_id, name, cycle );
-if( DEBUG_MAPPER_HANDLE_MISS & 1 )
-grdxt_display( XPTR( local_cxy , &mapper->rt ) , name );
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
+{
+    vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
+    printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
+   if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), name );
+}
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] enter for page %d in FAT / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+   if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), "FAT" );
+}
 #endif
 
@@ -321 +343 @@
 #if DEBUG_MAPPER_HANDLE_MISS
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_MAPPER_HANDLE_MISS < cycle )
-printk("\n[%s] exit for page %d in <%s> / ppn %x / cycle %d",
-__FUNCTION__, page_id, name, ppm_page2ppn( *page_xp ), cycle );
-if( DEBUG_MAPPER_HANDLE_MISS & 1 )
-grdxt_display( XPTR( local_cxy , &mapper->rt ) , name );
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d in <%s> / ppn %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid,
+    page_id, name, ppm_page2ppn( *page_xp ), cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt) , name );
+}
+if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] exit for page %d in FAT / ppn %x / cycle %d",
+    __FUNCTION__, this->process->pid, this->trdid,
+    page_id, ppm_page2ppn( *page_xp ), cycle );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt ), "FAT" );
+}
 #endif
 
@@ -482 +513 @@
 
 #if DEBUG_MAPPER_MOVE_KERNEL
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t      cycle  = (uint32_t)hal_get_cycles();
+thread_t    * this   = CURRENT_THREAD;
+mapper_t    * mapper = GET_PTR( mapper_xp );
+vfs_inode_t * inode  = hal_remote_lpt( XPTR( mapper_cxy , &mapper->inode ) );
+vfs_inode_get_name( XPTR( mapper_cxy , inode ) , name );
 if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
-printk("\n[%s] thread[%x,%x] enter / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, to_buffer, buffer_cxy, buffer_ptr, cycle );
+printk("\n[%s] thread[%x,%x] enter / %d bytes / offset %d / mapper <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, size, file_offset, name, cycle );
 #endif
 
@@ -496 +531 @@
     uint32_t first = min_byte >> CONFIG_PPM_PAGE_SHIFT;
     uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
-
-#if (DEBUG_MAPPER_MOVE_KERNEL & 1)
-if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
-printk("\n[%s] first_page %d / last_page %d\n", __FUNCTION__, first, last );
-#endif
 
     // compute source and destination clusters
@@ -528 +558 @@
         else if ( page_id == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
         else                         page_count = CONFIG_PPM_PAGE_SIZE;
-
-#if (DEBUG_MAPPER_MOVE_KERNEL & 1)
-if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
-printk("\n[%s] page_id = %d / offset = %d / bytes = %d\n",
-__FUNCTION__ , page_id , page_offset , page_count );
-#endif
 
         // get extended pointer on page descriptor
@@ -560 +584 @@
 #if (DEBUG_MAPPER_MOVE_KERNEL & 1)
 if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
-printk("\n[%s] src_cxy %x / src_ptr %x / dst_cxy %x / dst_ptr %x\n",
-__FUNCTION__, src_cxy, src_ptr, dst_cxy, dst_ptr );
+{
+    if( to_buffer )
+    printk("\n[%s] mapper <%s> page %d => buffer(%x,%x) / %d bytes\n",
+    __FUNCTION__, name, page_id, dst_cxy, dst_ptr, page_count );
+    else
+    printk("\n[%s] buffer(%x,%x) => mapper <%s> page %d / %d bytes\n",
+    __FUNCTION__, src_cxy, src_ptr, name, page_id, page_count );
+}
 #endif
 
@@ -571 +601 @@
 
 #if DEBUG_MAPPER_MOVE_KERNEL
-cycle = (uint32_t)hal_get_cycles();
+cycle  = (uint32_t)hal_get_cycles();
 if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
-printk("\n[%s] thread[%x,%x] exit / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, to_buffer, buffer_cxy, buffer_ptr, cycle );
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
 #endif
 
@@ -662 +692 @@
 
     // get pointer on radix tree
-    rt        = &mapper->rt;
+    rt = &mapper->rt;
 
     // initialise loop variable 
@@ -675 +705 @@
         if( page == NULL ) break;
 
-assert( (page->index == found_key ), __FUNCTION__, "wrong page descriptor index" );
-assert( (page->order == 0),          __FUNCTION__, "mapper page order must be 0" );
+assert( (page->index == found_key ), "wrong page descriptor index" );
+assert( (page->order == 0),          "mapper page order must be 0" );
 
         // build extended pointer on page descriptor
@@ -730 +760 @@
     char          buffer[4096];   // local buffer
     uint32_t    * tabi;           // pointer on uint32_t to scan buffer
-    char        * tabc;           // pointer on char to scan buffer
     uint32_t      line;           // line index
     uint32_t      word;           // word index
-    uint32_t      n;              // char index
     cxy_t         mapper_cxy;     // mapper cluster identifier
     mapper_t    * mapper_ptr;     // mapper local pointer
@@ -776 +804 @@
     // display 8 words per line
     tabi = (uint32_t *)buffer;
-    tabc = (char *)buffer;
     printk("\n***** <%s> first %d bytes of page %d *****\n", name, nbytes, page_id );
     for( line = 0 ; line < (nbytes >> 5) ; line++ )
     {
-        printk("%X : ", line );
+        printk("%X : ", line << 5 );
         for( word = 0 ; word < 8 ; word++ ) printk("%X ", tabi[(line<<3) + word] );
-        printk(" | ");
-        for( n = 0 ; n < 32 ; n++ ) printk("%c", tabc[(line<<5) + n] );
         printk("\n");
     }

trunk/kernel/mm/mapper.h

@@ -123 +123 @@
 
 /*******************************************************************************************
- * This function move data between a remote mapper, dentified by the <mapper_xp> argument,
+ * This function move data between a remote mapper, identified by the <mapper_xp> argument,
  * and a distributed user buffer. It can be called by a thread running in any cluster.
  * It is called by the vfs_user_move() to implement sys_read() and sys_write() syscalls.
@@ -148 +148 @@
 
 /********************************************************************************************
- * This function move data between a remote mapper and a remote kernel buffer. 
- * It can be called by a thread running any cluster. 
+ * This function move data between a remote mapper, identified by the <mapper_xp> argument,
+ * and a localised remote kernel buffer. It can be called by a thread running any cluster. 
  * If required, the data transfer is split in "fragments", where one fragment contains 
  * contiguous bytes in the same mapper page.
@@ -215 +215 @@
 /*******************************************************************************************
  * This function allows to write a single word to a mapper seen as and array of uint32_t.
- * It has bee designed to support remote access tho the FAT mapper of the FATFS. 
+ * It has been designed to support remote access to the FAT mapper of the FATFS. 
  * It can be called by any thread running in any cluster.
  * In case of miss, it takes the mapper lock in WRITE_MODE, load the missing

trunk/kernel/mm/page.h

@@ -50 +50 @@
  *   test/modify the forks counter or the page flags.
  * - The list entry is used to register the page in a free list or in dirty list.
- * NOTE: Size is 48 bytes for a 32 bits core.
- * TODO : the refcount use is not defined [AG]
+ *   The refcount is used for page release to KMEM.
+ * NOTE: the size is 48 bytes for a 32 bits core.
  ************************************************************************************/
 
@@ -61 +61 @@
     uint32_t          index;          /*! page index in mapper                 (4)  */
         list_entry_t      list;           /*! for both dirty pages and free pages  (8)  */
-        uint32_t          refcount;       /*! reference counter TODO ??? [AG]      (4)  */
+        int32_t           refcount;       /*! references counter for page release  (4)  */
         uint32_t          forks;          /*! number of pending forks              (4)  */
         remote_busylock_t lock;           /*! protect forks or flags modifs        (16) */

trunk/kernel/mm/ppm.c

@@ -349 +349 @@
 }  // end ppm_free_pages()
 
-///////////////////////////////
-void ppm_print( char * string )
+////////////////////////
+void ppm_display( void )
 {
         uint32_t       order;
@@ -361 +361 @@
         busylock_acquire( &ppm->free_lock );
 
-        printk("\n***  PPM in cluster %x / %s / %d pages ***\n",
-    local_cxy , string, ppm->pages_nr );
+        printk("\n***** PPM in cluster %x / %d pages\n", local_cxy , ppm->pages_nr );
 
         for( order = 0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )

trunk/kernel/mm/ppm.h

@@ -176 +176 @@
  * string   : character string printed in header
  ****************************************************************************************/
-void ppm_print( char * string );
+void ppm_display( void );
 
 /*****************************************************************************************

trunk/kernel/mm/vmm.c

@@ -4 +4 @@
  * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
  *           Mohamed Lamine Karaoui (2015)
- *           Alain Greiner (2016,2017,2018)
+ *           Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -55 +55 @@
 extern  process_t  process_zero;      // allocated in cluster.c 
 
-///////////////////////////////////////
-error_t vmm_init( process_t * process )
+////////////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by the vmm_create_vseg() function, and implements
+// the VMM STACK specific allocator.
+////////////////////////////////////////////////////////////////////////////////////////////
+// @ vmm      : [in]  pointer on VMM.
+// @ ltid     : [in]  requested slot == local user thread identifier.
+// @ vpn_base : [out] first allocated page
+// @ vpn_size : [out] number of allocated pages
+////////////////////////////////////////////////////////////////////////////////////////////
+static void vmm_stack_alloc( vmm_t  * vmm,
+                             ltid_t   ltid,
+                             vpn_t  * vpn_base,
+                             vpn_t  * vpn_size )
 {
-    error_t   error;
+
+// check ltid argument
+assert( (ltid <= ((CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE) / CONFIG_VMM_STACK_SIZE)),
+"slot index %d too large for an user stack vseg", ltid );
+
+    // get stack allocator pointer
+    stack_mgr_t * mgr = &vmm->stack_mgr;
+
+    // get lock on stack allocator
+    busylock_acquire( &mgr->lock );
+
+// check requested slot is available
+assert( (bitmap_state( &mgr->bitmap , ltid ) == false),
+"slot index %d already allocated", ltid );
+
+    // update bitmap
+    bitmap_set( &mgr->bitmap , ltid );
+
+    // release lock on stack allocator
+    busylock_release( &mgr->lock );
+
+    // returns vpn_base, vpn_size (first page non allocated)
+    *vpn_base = mgr->vpn_base + ltid * CONFIG_VMM_STACK_SIZE + 1;
+    *vpn_size = CONFIG_VMM_STACK_SIZE - 1;
+
+} // end vmm_stack_alloc()
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by the vmm_remove_vseg() function, and implements
+// the VMM STACK specific desallocator.
+////////////////////////////////////////////////////////////////////////////////////////////
+// @ vmm      : [in] pointer on VMM.
+// @ vseg     : [in] pointer on released vseg.
+////////////////////////////////////////////////////////////////////////////////////////////
+static void vmm_stack_free( vmm_t  * vmm,
+                            vseg_t * vseg )
+{
+    // get stack allocator pointer
+    stack_mgr_t * mgr = &vmm->stack_mgr;
+
+    // compute slot index
+    uint32_t index = (vseg->vpn_base - 1 - mgr->vpn_base) / CONFIG_VMM_STACK_SIZE;
+
+// check index
+assert( (index <= ((CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE) / CONFIG_VMM_STACK_SIZE)),
+"slot index %d too large for an user stack vseg", index );
+
+// check released slot is allocated
+assert( (bitmap_state( &mgr->bitmap , index ) == true),
+"released slot index %d non allocated", index );
+
+    // get lock on stack allocator
+    busylock_acquire( &mgr->lock );
+
+    // update stacks_bitmap
+    bitmap_clear( &mgr->bitmap , index );
+
+    // release lock on stack allocator
+    busylock_release( &mgr->lock );
+
+}  // end vmm_stack_free()
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by the vmm_create_vseg() function, and implements
+// the VMM MMAP specific allocator.
+////////////////////////////////////////////////////////////////////////////////////////////
+// @ vmm      : [in] pointer on VMM.
+// @ npages   : [in] requested number of pages.
+// @ vpn_base : [out] first allocated page.
+// @ vpn_size : [out] actual number of allocated pages.
+////////////////////////////////////////////////////////////////////////////////////////////
+static error_t vmm_mmap_alloc( vmm_t * vmm,
+                               vpn_t   npages,
+                               vpn_t * vpn_base,
+                               vpn_t * vpn_size )
+{
+    uint32_t   order;
+    xptr_t     vseg_xp;
+    vseg_t   * vseg;
+    vpn_t      base;
+    vpn_t      size;
+    vpn_t      free;
+
+#if DEBUG_VMM_MMAP_ALLOC
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VMM_MMAP_ALLOC < cycle )
+printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
+    // number of allocated pages must be power of 2
+    // compute actual size and order 
+    size  = POW2_ROUNDUP( npages );
+    order = bits_log2( size );
+
+    // get mmap allocator pointer
+    mmap_mgr_t * mgr = &vmm->mmap_mgr;
+
+    // build extended pointer on root of zombi_list[order]
+    xptr_t root_xp = XPTR( local_cxy , &mgr->zombi_list[order] );
+
+    // take lock protecting zombi_lists
+    busylock_acquire( &mgr->lock );
+
+    // get vseg from zombi_list or from mmap zone
+    if( xlist_is_empty( root_xp ) )                   // from mmap zone
+    {
+        // check overflow
+        free = mgr->first_free_vpn;
+        if( (free + size) > mgr->vpn_size ) return -1;
+
+        // update MMAP allocator
+        mgr->first_free_vpn += size;
+
+        // compute base
+        base = free;
+    }
+    else                                              // from zombi_list
+    {
+        // get pointer on zombi vseg from zombi_list
+        vseg_xp = XLIST_FIRST( root_xp , vseg_t , xlist );
+        vseg    = GET_PTR( vseg_xp );
+
+        // remove vseg from free-list
+        xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
+
+        // compute base
+        base = vseg->vpn_base;
+    }
+
+    // release lock 
+    busylock_release( &mgr->lock );
+
+#if DEBUG_VMM_MMAP_ALLOC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VMM_DESTROY < cycle )
+printk("\n[%s] thread[%x,%x] exit / vpn_base %x / vpn_size %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, base, size, cycle );
+#endif
+
+    // returns vpn_base, vpn_size
+    *vpn_base = base;
+    *vpn_size = size;
+    return 0;
+
+}  // end vmm_mmap_alloc()
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by the vmm_remove_vseg() function, and implements
+// the VMM MMAP specific desallocator.
+////////////////////////////////////////////////////////////////////////////////////////////
+// @ vmm      : [in] pointer on VMM.
+// @ vseg     : [in] pointer on released vseg.
+////////////////////////////////////////////////////////////////////////////////////////////
+static void vmm_mmap_free( vmm_t  * vmm,
+                           vseg_t * vseg )
+{
+    // get pointer on mmap allocator
+    mmap_mgr_t * mgr = &vmm->mmap_mgr;
+
+    // compute zombi_list order
+    uint32_t order = bits_log2( vseg->vpn_size );
+
+    // take lock protecting zombi lists
+    busylock_acquire( &mgr->lock );
+
+    // update relevant zombi_list
+    xlist_add_first( XPTR( local_cxy , &mgr->zombi_list[order] ),
+                     XPTR( local_cxy , &vseg->xlist ) );
+
+    // release lock
+    busylock_release( &mgr->lock );
+
+}  // end of vmm_mmap_free()
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// This static function registers one vseg in the VSL of a local process descriptor.
+////////////////////////////////////////////////////////////////////////////////////////////
+// vmm       : [in] pointer on VMM.
+// vseg      : [in] pointer on vseg.
+////////////////////////////////////////////////////////////////////////////////////////////
+void vmm_attach_vseg_to_vsl( vmm_t  * vmm,
+                             vseg_t * vseg )
+{
+    // update vseg descriptor
+    vseg->vmm = vmm;
+
+    // increment vsegs number
+    vmm->vsegs_nr++;
+
+    // add vseg in vmm list
+    xlist_add_last( XPTR( local_cxy , &vmm->vsegs_root ),
+                    XPTR( local_cxy , &vseg->xlist ) );
+
+}  // end vmm_attach_vseg_from_vsl()
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// This static function removes one vseg from the VSL of a local process descriptor.
+////////////////////////////////////////////////////////////////////////////////////////////
+// vmm       : [in] pointer on VMM.
+// vseg      : [in] pointer on vseg.
+////////////////////////////////////////////////////////////////////////////////////////////
+void vmm_detach_vseg_from_vsl( vmm_t  * vmm,
+                               vseg_t * vseg )
+{
+    // update vseg descriptor
+    vseg->vmm = NULL;
+
+    // decrement vsegs number
+    vmm->vsegs_nr--;
+
+    // remove vseg from VSL
+    xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
+
+}  // end vmm_detach_from_vsl()
+
+
+
+
+////////////////////////////////////////////
+error_t vmm_user_init( process_t * process )
+{
     vseg_t  * vseg_args;
     vseg_t  * vseg_envs;
@@ -65 +298 @@
     uint32_t  i;
 
-#if DEBUG_VMM_INIT
+#if DEBUG_VMM_USER_INIT
 thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_INIT )
+if( DEBUG_VMM_USER_INIT )
 printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n", 
 __FUNCTION__ , this->process->pid, this->trdid, process->pid, local_cxy, cycle );
@@ -76 +309 @@
     vmm_t   * vmm = &process->vmm;
 
-    // initialize VSL (empty)
-    vmm->vsegs_nr = 0;
-        xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
-        remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) , LOCK_VMM_VSL );
-
+// check UTILS zone 
 assert( ((CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE) <= 
          (CONFIG_VMM_ELF_BASE - CONFIG_VMM_UTILS_BASE)) ,
          "UTILS zone too small\n" );
 
+// check STACK zone
 assert( ((CONFIG_VMM_STACK_SIZE * CONFIG_THREADS_MAX_PER_CLUSTER) <=
 (CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE)) ,
 "STACK zone too small\n");
 
-    // register args vseg in VSL
+    // register "args" vseg in VSL
     base = CONFIG_VMM_UTILS_BASE << CONFIG_PPM_PAGE_SHIFT;
     size = CONFIG_VMM_ARGS_SIZE << CONFIG_PPM_PAGE_SHIFT;
@@ -101 +331 @@
                                  XPTR_NULL,     // mapper_xp unused
                                  local_cxy );
-
     if( vseg_args == NULL )
     {
@@ -110 +339 @@
     vmm->args_vpn_base = base;
 
-    // register the envs vseg in VSL
+    // register "envs" vseg in VSL
     base = (CONFIG_VMM_UTILS_BASE + CONFIG_VMM_ARGS_SIZE) << CONFIG_PPM_PAGE_SHIFT;
     size = CONFIG_VMM_ENVS_SIZE << CONFIG_PPM_PAGE_SHIFT;
@@ -122 +351 @@
                                  XPTR_NULL,     // mapper_xp unused
                                  local_cxy );
-
     if( vseg_envs == NULL )
     {
@@ -130 +358 @@
 
     vmm->envs_vpn_base = base;
-
-    // create GPT (empty)
-    error = hal_gpt_create( &vmm->gpt );
-
-    if( error ) 
-    {
-        printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
-        return -1;
-    }
-
-    // initialize GPT lock
-    remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
-
-    // update process VMM with kernel vsegs as required by the hardware architecture
-    error = hal_vmm_kernel_update( process );
-
-    if( error )
-    { 
-        printk("\n[ERROR] in %s : cannot update GPT for kernel vsegs\n", __FUNCTION__ );
-        return -1;
-    }
 
     // initialize STACK allocator
@@ -162 +369 @@
     vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
     busylock_init( &vmm->mmap_mgr.lock , LOCK_VMM_MMAP );
-    for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
+    for( i = 0 ; i < 32 ; i++ )
+    {
+        xlist_root_init( XPTR( local_cxy , &vmm->mmap_mgr.zombi_list[i] ) );
+    }
 
     // initialize instrumentation counters
@@ -169 +379 @@
     hal_fence();
 
-#if DEBUG_VMM_INIT
+#if DEBUG_VMM_USER_INIT
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_INIT )
+if( DEBUG_VMM_USER_INIT )
 printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n", 
 __FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy, cycle );
@@ -178 +388 @@
     return 0;
 
-}  // end vmm_init()
-
+}  // end vmm_user_init()
 
 //////////////////////////////////////////
-void vmm_attach_vseg_to_vsl( vmm_t  * vmm,
-                             vseg_t * vseg )
+void vmm_user_reset( process_t * process )
 {
-    // build extended pointer on rwlock protecting VSL
-    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
-
-    // get rwlock in write mode
-    remote_rwlock_wr_acquire( lock_xp );
-
-    // update vseg descriptor
-    vseg->vmm = vmm;
-
-    // increment vsegs number
-    vmm->vsegs_nr++;
-
-    // add vseg in vmm list
-    xlist_add_last( XPTR( local_cxy , &vmm->vsegs_root ),
-                    XPTR( local_cxy , &vseg->xlist ) );
-
-    // release rwlock in write mode
-    remote_rwlock_wr_release( lock_xp );
-}
-
-////////////////////////////////////////////
-void vmm_detach_vseg_from_vsl( vmm_t  * vmm,
-                               vseg_t * vseg )
-{
-    // get vseg type
-    uint32_t type = vseg->type;
-
-    // build extended pointer on rwlock protecting VSL
-    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
-
-    // get rwlock in write mode
-    remote_rwlock_wr_acquire( lock_xp );
-
-    // update vseg descriptor
-    vseg->vmm = NULL;
-
-    // remove vseg from VSL
-    xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
-
-    // release rwlock in write mode
-    remote_rwlock_wr_release( lock_xp );
-
-    // release the stack slot to VMM stack allocator if STACK type
-    if( type == VSEG_TYPE_STACK )
-    {
-        // get pointer on stack allocator
-        stack_mgr_t * mgr = &vmm->stack_mgr;
-
-        // compute slot index
-        uint32_t index = ((vseg->vpn_base - mgr->vpn_base - 1) / CONFIG_VMM_STACK_SIZE);
-
-        // update stacks_bitmap
-        busylock_acquire( &mgr->lock );
-        bitmap_clear( &mgr->bitmap , index );
-        busylock_release( &mgr->lock );
-    }
-
-    // release the vseg to VMM mmap allocator if MMAP type
-    if( (type == VSEG_TYPE_ANON) || (type == VSEG_TYPE_FILE) || (type == VSEG_TYPE_REMOTE) )
-    {
-        // get pointer on mmap allocator
-        mmap_mgr_t * mgr = &vmm->mmap_mgr;
-
-        // compute zombi_list index
-        uint32_t index = bits_log2( vseg->vpn_size );
-
-        // update zombi_list
-        busylock_acquire( &mgr->lock );
-        list_add_first( &mgr->zombi_list[index] , &vseg->zlist );
-        busylock_release( &mgr->lock );
-    }
-
-    // release physical memory allocated for vseg if no MMAP and no kernel type
-    if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) &&
-        (type != VSEG_TYPE_KCODE) && (type != VSEG_TYPE_KDATA) && (type != VSEG_TYPE_KDEV) )
-    {
-        vseg_free( vseg );
-    }
-
-}  // end vmm_remove_vseg_from_vsl()
+    xptr_t       vseg_xp;
+        vseg_t     * vseg;
+    vseg_type_t  vseg_type;
+
+#if DEBUG_VMM_USER_RESET
+uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this = CURRENT_THREAD;
+if( DEBUG_VMM_USER_RESET < cycle )
+printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy, cycle );
+#endif
+
+#if (DEBUG_VMM_USER_RESET & 1 )
+if( DEBUG_VMM_USER_RESET < cycle )
+hal_vmm_display( process , true );
+#endif
+
+    // get pointer on local VMM
+    vmm_t * vmm = &process->vmm;
+
+    // build extended pointer on VSL root and VSL lock
+    xptr_t   root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+    xptr_t   lock_xp = XPTR( local_cxy , &vmm->vsl_lock );
+
+    // take the VSL lock
+        remote_rwlock_wr_acquire( lock_xp );
+
+    // scan the VSL to delete all non kernel vsegs
+    // (we don't use a FOREACH in case of item deletion)
+    xptr_t   iter_xp;
+    xptr_t   next_xp;
+        for( iter_xp = hal_remote_l64( root_xp ) ; 
+         iter_xp != root_xp ;
+         iter_xp = next_xp )
+        {
+        // save extended pointer on next item in xlist
+        next_xp = hal_remote_l64( iter_xp );
+
+        // get pointers on current vseg in VSL
+        vseg_xp   = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg      = GET_PTR( vseg_xp );
+        vseg_type = vseg->type;
+
+#if( DEBUG_VMM_USER_RESET & 1 )
+if( DEBUG_VMM_USER_RESET < cycle )
+printk("\n[%s] found %s vseg / vpn_base %x / vpn_size %d\n",
+__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
+#endif
+        // delete non kernel vseg  
+        if( (vseg_type != VSEG_TYPE_KCODE) && 
+            (vseg_type != VSEG_TYPE_KDATA) && 
+            (vseg_type != VSEG_TYPE_KDEV ) )
+        {
+            // remove vseg from VSL
+            vmm_remove_vseg( process , vseg );
+
+#if( DEBUG_VMM_USER_RESET & 1 )
+if( DEBUG_VMM_USER_RESET < cycle )
+printk("\n[%s] %s vseg deleted / vpn_base %x / vpn_size %d\n",
+__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
+#endif
+        }
+        else
+        {
+
+#if( DEBUG_VMM_USER_RESET & 1 )
+if( DEBUG_VMM_USER_RESET < cycle )
+printk("\n[%s] keep %s vseg / vpn_base %x / vpn_size %d\n",
+__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
+#endif
+        }
+        }  // end loop on vsegs in VSL
+
+    // release the VSL lock
+        remote_rwlock_wr_release( lock_xp );
+
+// FIXME il faut gérer les process copies...
+
+#if DEBUG_VMM_USER_RESET
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VMM_USER_RESET < cycle )
+printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy , cycle );
+#endif
+
+}  // end vmm_user_reset()
 
 ////////////////////////////////////////////////
@@ -507 +721 @@
     cxy_t       page_cxy;
     xptr_t      forks_xp;       // extended pointer on forks counter in page descriptor
-    xptr_t      lock_xp;        // extended pointer on lock protecting the forks counter
     xptr_t      parent_root_xp;
     bool_t      mapped; 
@@ -528 +741 @@
     child_vmm  = &child_process->vmm;
 
-    // get extended pointer on lock protecting the parent VSL
-    parent_lock_xp = XPTR( parent_cxy , &parent_vmm->vsegs_lock );
-
-    // initialize the lock protecting the child VSL
-    remote_rwlock_init( XPTR( local_cxy , &child_vmm->vsegs_lock ), LOCK_VMM_STACK );
+    // initialize the locks protecting the child VSL and GPT
+    remote_rwlock_init( XPTR( local_cxy , &child_vmm->gpt_lock ) , LOCK_VMM_GPT );
+        remote_rwlock_init( XPTR( local_cxy , &child_vmm->vsl_lock ) , LOCK_VMM_VSL );
 
     // initialize the child VSL as empty
@@ -538 +749 @@
     child_vmm->vsegs_nr = 0;
 
-    // create the child GPT
+    // create an empty child GPT
     error = hal_gpt_create( &child_vmm->gpt );
-
     if( error )
     {
@@ -547 +757 @@
     }
 
-    // build extended pointer on parent VSL
+    // build extended pointer on parent VSL root and lock
     parent_root_xp = XPTR( parent_cxy , &parent_vmm->vsegs_root );
+    parent_lock_xp = XPTR( parent_cxy , &parent_vmm->vsl_lock );
 
     // take the lock protecting the parent VSL in read mode
@@ -556 +767 @@
     XLIST_FOREACH( parent_root_xp , iter_xp )
     {
-        // get local and extended pointers on current parent vseg
+        // get pointers on current parent vseg
         parent_vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
         parent_vseg    = GET_PTR( parent_vseg_xp );
@@ -587 +798 @@
             vseg_init_from_ref( child_vseg , parent_vseg_xp );
 
+            // build extended pointer on VSL lock
+            xptr_t lock_xp = XPTR( local_cxy , &child_vmm->vsl_lock );
+ 
+            // take the VSL lock in write mode
+            remote_rwlock_wr_acquire( lock_xp );
+
             // register child vseg in child VSL
             vmm_attach_vseg_to_vsl( child_vmm , child_vseg );
+
+            // release the VSL lock
+            remote_rwlock_wr_release( lock_xp );
 
 #if DEBUG_VMM_FORK_COPY
@@ -597 +817 @@
 hal_remote_l32( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) , cycle );
 #endif
-
-            // copy DATA, MMAP, REMOTE, FILE parent GPT entries to child GPT
+            // copy DATA, ANON, REMOTE, FILE parent GPT entries to child GPT
             if( type != VSEG_TYPE_CODE )
             {
-                // activate the COW for DATA, MMAP, REMOTE vsegs only
+                // activate the COW for DATA, ANON, REMOTE vsegs only
                 cow = ( type != VSEG_TYPE_FILE );
 
@@ -611 +830 @@
                 {
                     error = hal_gpt_pte_copy( &child_vmm->gpt,
+                                              vpn,
                                               XPTR( parent_cxy , &parent_vmm->gpt ),
                                               vpn,
@@ -677 +897 @@
     child_vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
     child_vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
-    for( i = 0 ; i < 32 ; i++ ) list_root_init( &child_vmm->mmap_mgr.zombi_list[i] );
+    for( i = 0 ; i < 32 ; i++ ) 
+    {
+        xlist_root_init( XPTR( local_cxy , &child_vmm->mmap_mgr.zombi_list[i] ) );
+    }
 
     // initialize instrumentation counters
@@ -726 +949 @@
     vmm_t  * vmm = &process->vmm;
 
-    // get extended pointer on VSL root and VSL lock
-    xptr_t   root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+    // build extended pointer on VSL root, VSL lock and GPT lock
+    xptr_t   vsl_root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+    xptr_t   vsl_lock_xp = XPTR( local_cxy , &vmm->vsl_lock );
+    xptr_t   gpt_lock_xp = XPTR( local_cxy , &vmm->gpt_lock );
+
+    // take the VSL lock
+    remote_rwlock_wr_acquire( vsl_lock_xp );
 
     // scan the VSL to delete all registered vsegs
-    // (don't use a FOREACH for item deletion in xlist)
-
-        while( !xlist_is_empty( root_xp ) )
+    // (we don't use a FOREACH in case of item deletion)
+    xptr_t  iter_xp;
+    xptr_t  next_xp;
+        for( iter_xp = hal_remote_l64( vsl_root_xp ) ; 
+         iter_xp != vsl_root_xp ;
+         iter_xp = next_xp )
         {
-        // get pointer on first vseg in VSL
-                vseg_xp = XLIST_FIRST( root_xp , vseg_t , xlist );
-        vseg    = GET_PTR( vseg_xp );
+        // save extended pointer on next item in xlist
+        next_xp = hal_remote_l64( iter_xp );
+
+        // get pointers on current vseg in VSL
+        vseg_xp   = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg      = GET_PTR( vseg_xp );
 
         // delete vseg and release physical pages 
-        vmm_delete_vseg( process->pid , vseg->min );
+        vmm_remove_vseg( process , vseg );
 
 #if( DEBUG_VMM_DESTROY & 1 )
@@ -749 +983 @@
         }
 
-    // remove all vsegs from zombi_lists in MMAP allocator
+    // release the VSL lock
+    remote_rwlock_wr_release( vsl_lock_xp );
+
+    // remove all registered MMAP vsegs
+    // from zombi_lists in MMAP allocator
     uint32_t i;
     for( i = 0 ; i<32 ; i++ )
     {
-            while( !list_is_empty( &vmm->mmap_mgr.zombi_list[i] ) )
+        // build extended pointer on zombi_list[i]
+        xptr_t root_xp = XPTR( local_cxy , &vmm->mmap_mgr.zombi_list[i] );
+  
+        // scan zombi_list[i]
+            while( !xlist_is_empty( root_xp ) )
             {
-                    vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , zlist );
+                    vseg_xp = XLIST_FIRST( root_xp , vseg_t , xlist );
+            vseg    = GET_PTR( vseg_xp );
 
 #if( DEBUG_VMM_DESTROY & 1 )
@@ -765 +1008 @@
             vseg->vmm = NULL;
 
-            // remove vseg from  xlist
+            // remove vseg from  zombi_list
             xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
 
@@ -779 +1022 @@
     }
 
+    // take the GPT lock
+    remote_rwlock_wr_acquire( gpt_lock_xp );
+
     // release memory allocated to the GPT itself
     hal_gpt_destroy( &vmm->gpt );
+
+    // release the GPT lock
+    remote_rwlock_wr_release( gpt_lock_xp );
 
 #if DEBUG_VMM_DESTROY
@@ -816 +1065 @@
 }  // end vmm_check_conflict()
 
-////////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the vmm_create_vseg() function, and implements
-// the VMM stack_vseg specific allocator.
-////////////////////////////////////////////////////////////////////////////////////////////
-// @ vmm      : pointer on VMM.
-// @ vpn_base : (return value) first allocated page
-// @ vpn_size : (return value) number of allocated pages
-////////////////////////////////////////////////////////////////////////////////////////////
-static error_t vmm_stack_alloc( vmm_t * vmm,
-                                vpn_t * vpn_base,
-                                vpn_t * vpn_size )
-{
-    // get stack allocator pointer
-    stack_mgr_t * mgr = &vmm->stack_mgr;
-
-    // get lock on stack allocator
-    busylock_acquire( &mgr->lock );
-
-    // get first free slot index in bitmap
-    int32_t index = bitmap_ffc( &mgr->bitmap , 4 );
-    if( (index < 0) || (index > 31) )
-    {
-        busylock_release( &mgr->lock );
-        return 0xFFFFFFFF;
-    }
-
-    // update bitmap
-    bitmap_set( &mgr->bitmap , index );
-
-    // release lock on stack allocator
-    busylock_release( &mgr->lock );
-
-    // returns vpn_base, vpn_size (one page non allocated)
-    *vpn_base = mgr->vpn_base + index * CONFIG_VMM_STACK_SIZE + 1;
-    *vpn_size = CONFIG_VMM_STACK_SIZE - 1;
-    return 0;
-
-} // end vmm_stack_alloc()
-
-////////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the vmm_create_vseg() function, and implements
-// the VMM MMAP specific allocator.
-////////////////////////////////////////////////////////////////////////////////////////////
-// @ vmm      : [in] pointer on VMM.
-// @ npages   : [in] requested number of pages.
-// @ vpn_base : [out] first allocated page.
-// @ vpn_size : [out] actual number of allocated pages.
-////////////////////////////////////////////////////////////////////////////////////////////
-static error_t vmm_mmap_alloc( vmm_t * vmm,
-                               vpn_t   npages,
-                               vpn_t * vpn_base,
-                               vpn_t * vpn_size )
-{
-    uint32_t   index;
-    vseg_t   * vseg;
-    vpn_t      base;
-    vpn_t      size;
-    vpn_t      free;
-
-#if DEBUG_VMM_MMAP_ALLOC
-thread_t * this = CURRENT_THREAD;
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_MMAP_ALLOC < cycle )
-printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, cycle );
-#endif
-
-    // vseg size must be power of 2
-    // compute actual size and index in zombi_list array
-    size  = POW2_ROUNDUP( npages );
-    index = bits_log2( size );
-
-    // get mmap allocator pointer
-    mmap_mgr_t * mgr = &vmm->mmap_mgr;
-
-    // get lock on mmap allocator
-    busylock_acquire( &mgr->lock );
-
-    // get vseg from zombi_list or from mmap zone
-    if( list_is_empty( &mgr->zombi_list[index] ) )     // from mmap zone
-    {
-        // check overflow
-        free = mgr->first_free_vpn;
-        if( (free + size) > mgr->vpn_size ) return -1;
-
-        // update MMAP allocator
-        mgr->first_free_vpn += size;
-
-        // compute base
-        base = free;
-    }
-    else                                             // from zombi_list
-    {
-        // get pointer on zombi vseg from zombi_list
-        vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , zlist );
-
-        // remove vseg from free-list
-        list_unlink( &vseg->zlist );
-
-        // compute base
-        base = vseg->vpn_base;
-    }
-
-    // release lock on mmap allocator
-    busylock_release( &mgr->lock );
-
-#if DEBUG_VMM_MMAP_ALLOC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_DESTROY < cycle )
-printk("\n[%s] thread[%x,%x] exit / vpn_base %x / vpn_size %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, base, size, cycle );
-#endif
-
-    // returns vpn_base, vpn_size
-    *vpn_base = base;
-    *vpn_size = size;
-    return 0;
-
-}  // end vmm_mmap_alloc()
+
 
 ////////////////////////////////////////////////
@@ -968 +1099 @@
     {
         // get vpn_base and vpn_size from STACK allocator
-        error = vmm_stack_alloc( vmm , &vpn_base , &vpn_size );
-        if( error )
-        {
-            printk("\n[ERROR] in %s : no space for stack vseg / process %x in cluster %x\n",
-            __FUNCTION__ , process->pid , local_cxy );
-            return NULL;
-        }
+        vmm_stack_alloc( vmm , base , &vpn_base , &vpn_size );
 
         // compute vseg base and size from vpn_base and vpn_size
@@ -1072 +1197 @@
                cxy );
 
+    // build extended pointer on VSL lock
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsl_lock );
+ 
+    // take the VSL lock in write mode
+    remote_rwlock_wr_acquire( lock_xp );
+
     // attach vseg to VSL
         vmm_attach_vseg_to_vsl( vmm , vseg );
+
+    // release the VSL lock
+    remote_rwlock_wr_release( lock_xp );
 
 #if DEBUG_VMM_CREATE_VSEG
@@ -1086 +1220 @@
 }  // vmm_create_vseg()
 
-///////////////////////////////////
-void vmm_delete_vseg( pid_t    pid,
-                      intptr_t vaddr )
+
+//////////////////////////////////////////
+void vmm_remove_vseg( process_t * process,
+                      vseg_t    * vseg )
 {
-    process_t * process;    // local pointer on local process 
-    vmm_t     * vmm;        // local pointer on local process VMM
-    vseg_t    * vseg;       // local pointer on local vseg containing vaddr
-    gpt_t     * gpt;        // local pointer on local process GPT
+    vmm_t     * vmm;        // local pointer on process VMM
+    bool_t      is_ref;     // local process is reference process
+    uint32_t    vseg_type;  // vseg type
     vpn_t       vpn;        // VPN of current PTE
     vpn_t       vpn_min;    // VPN of first PTE
@@ -1103 +1237 @@
     cxy_t       page_cxy;   // page descriptor cluster
     page_t    * page_ptr;   // page descriptor pointer
-    xptr_t      forks_xp;   // extended pointer on pending forks counter
-    xptr_t      lock_xp;    // extended pointer on lock protecting forks counter
-    uint32_t    forks;      // actual number of pendinf forks
-    uint32_t    vseg_type;  // vseg type
-
-#if DEBUG_VMM_DELETE_VSEG
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
-if( DEBUG_VMM_DELETE_VSEG < cycle )
-printk("\n[%s] thread[%x,%x] enter / process %x / vaddr %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, pid, vaddr, cycle );
-#endif
-
-    // get local pointer on local process descriptor
-    process = cluster_get_local_process_from_pid( pid );
-
-    if( process == NULL )
-    {
-        printk("\n[ERRORR] in %s : cannot get local process descriptor\n",
-        __FUNCTION__ );
-        return;
-    }
-
-    // get pointers on local process VMM an GPT
+    xptr_t      count_xp;   // extended pointer on page refcount
+    uint32_t    count;      // current value of page refcount
+
+// check arguments
+assert( (process != NULL), "process argument is NULL" );
+assert( (vseg    != NULL), "vseg argument is NULL" );
+
+    // compute is_ref
+    is_ref = (GET_CXY( process->ref_xp ) == local_cxy);
+
+    // get pointers on local process VMM 
     vmm = &process->vmm;
-    gpt = &process->vmm.gpt;
-
-    // get local pointer on vseg containing vaddr
-    vseg = vmm_vseg_from_vaddr( vmm , vaddr );
-
-    if( vseg == NULL )
-    {
-        printk("\n[ERRORR] in %s : cannot get vseg descriptor\n",
-        __FUNCTION__ );
-        return;
-    }
 
     // get relevant vseg infos
@@ -1145 +1255 @@
     vpn_max   = vpn_min + vseg->vpn_size;
 
-    // loop to invalidate all vseg PTEs in GPT
+#if DEBUG_VMM_REMOVE_VSEG
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_VMM_REMOVE_VSEG < cycle )
+printk("\n[%s] thread[%x,%x] enter / process %x / %s / base %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+process->pid, vseg_type_str(vseg->type), vseg->min, cycle );
+#endif
+
+    // loop on PTEs in GPT
         for( vpn = vpn_min ; vpn < vpn_max ; vpn++ )
     {
-        // get ppn and attr from GPT entry
-        hal_gpt_get_pte( XPTR( local_cxy , gpt ) , vpn , &attr , &ppn );
-
-        if( attr & GPT_MAPPED )  // entry is mapped
+        // get ppn and attr
+        hal_gpt_get_pte( XPTR( local_cxy , &vmm->gpt ) , vpn , &attr , &ppn );
+
+        if( attr & GPT_MAPPED )  // PTE is mapped
         { 
 
-#if( DEBUG_VMM_DELETE_VSEG & 1 )
-if( DEBUG_VMM_DELETE_VSEG < cycle )
-printk("- unmap vpn %x / ppn %x / vseg %s \n" , vpn , ppn, vseg_type_str(vseg->type) );
+#if( DEBUG_VMM_REMOVE_VSEG & 1 )
+if( DEBUG_VMM_REMOVE_VSEG < cycle )
+printk("- unmap vpn %x / ppn %x / %s" , vpn , ppn, vseg_type_str(vseg_type) );
 #endif
             // unmap GPT entry in local GPT
-            hal_gpt_reset_pte( gpt , vpn );
-
-            // the allocated page is not released to for kernel vseg
-            if( (vseg_type != VSEG_TYPE_KCODE) && 
-                (vseg_type != VSEG_TYPE_KDATA) && 
-                (vseg_type != VSEG_TYPE_KDEV ) )
+            hal_gpt_reset_pte( &vmm->gpt , vpn );
+
+            // get pointers on physical page descriptor
+            page_xp  = ppm_ppn2page( ppn );
+            page_cxy = GET_CXY( page_xp );
+            page_ptr = GET_PTR( page_xp );
+
+            // decrement page refcount
+            count_xp = XPTR( page_cxy , &page_ptr->refcount );
+            count    = hal_remote_atomic_add( count_xp , -1 );
+
+            // compute the ppn_release condition depending on vseg type
+            bool_t ppn_release;
+            if( (vseg_type == VSEG_TYPE_FILE)  ||
+                (vseg_type == VSEG_TYPE_KCODE) || 
+                (vseg_type == VSEG_TYPE_KDATA) || 
+                (vseg_type == VSEG_TYPE_KDEV) )            
             {
-                // get extended pointer on physical page descriptor
-                page_xp  = ppm_ppn2page( ppn );
-                page_cxy = GET_CXY( page_xp );
-                page_ptr = GET_PTR( page_xp );
-
-// FIXME This code must be re-written, as the actual release depends on vseg type,
-// the reference cluster, the page refcount and/or the forks counter...
-
-                // get extended pointers on forks and lock fields
-                forks_xp = XPTR( page_cxy , &page_ptr->forks );
-                lock_xp  = XPTR( page_cxy , &page_ptr->lock );
-
-                // get the lock protecting the page
+                // no physical page release for FILE and KERNEL 
+                ppn_release = false;
+            }
+            else if( (vseg_type == VSEG_TYPE_CODE)  ||
+                     (vseg_type == VSEG_TYPE_STACK) ) 
+            {
+                // always release physical page for private vsegs
+                ppn_release = true;
+            }
+            else if( (vseg_type == VSEG_TYPE_ANON)  ||
+                     (vseg_type == VSEG_TYPE_REMOTE) )
+            {
+                // release physical page if reference cluster
+                ppn_release = is_ref;
+            }
+            else if( is_ref )  // vseg_type == DATA in reference cluster
+            {
+                // get extended pointers on forks and lock field in page descriptor
+                xptr_t forks_xp = XPTR( page_cxy , &page_ptr->forks );
+                xptr_t lock_xp  = XPTR( page_cxy , &page_ptr->lock );
+
+                // take lock protecting "forks" counter
                 remote_busylock_acquire( lock_xp );
 
-                // get pending forks counter
-                forks = hal_remote_l32( forks_xp );
-
-                if( forks )  // decrement pending forks counter
+                // get number of pending forks from page descriptor
+                uint32_t forks = hal_remote_l32( forks_xp );
+
+                // decrement pending forks counter if required
+                if( forks )  hal_remote_atomic_add( forks_xp , -1 );
+
+                // release lock protecting "forks" counter
+                remote_busylock_release( lock_xp );
+
+                // release physical page if forks == 0
+                ppn_release = (forks == 0); 
+            }
+            else              // vseg_type == DATA not in reference cluster
+            {
+                // no physical page release if not in reference cluster 
+                ppn_release = false;
+            }
+
+            // release physical page to relevant kmem when required
+            if( ppn_release )
+            {
+                if( page_cxy == local_cxy )
                 {
-                    // update forks counter
-                    hal_remote_atomic_add( forks_xp , -1 );
-
-                    // release the lock protecting the page
-                    remote_busylock_release( lock_xp );
-                }  
-                else         // release physical page to relevant cluster
+                    req.type = KMEM_PAGE;
+                    req.ptr  = page_ptr; 
+                    kmem_free( &req );
+                }
+                else
                 {
-                    // release the lock protecting the page
-                    remote_busylock_release( lock_xp );
-
-                    // release the page to kmem
-                    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 );
-                    }
-
-#if( DEBUG_VMM_DELETE_VSEG & 1 )
-if( DEBUG_VMM_DELETE_VSEG < cycle )
-printk("- release ppn %x\n", ppn );
-#endif
+                    rpc_pmem_release_pages_client( page_cxy , page_ptr );
                 }
-
             }
+
+#if( DEBUG_VMM_REMOVE_VSEG & 1 )
+if( DEBUG_VMM_REMOVE_VSEG < cycle )
+{
+    if( ppn_release ) printk(" / released to kmem\n" );
+    else              printk("\n");
+}
+#endif
         }
     }
 
-    // remove vseg from VSL and release vseg descriptor (if not MMAP)
+    // remove vseg from VSL 
     vmm_detach_vseg_from_vsl( vmm , vseg );
 
-#if DEBUG_VMM_DELETE_VSEG
+    // release vseg descriptor depending on vseg type
+    if( vseg_type == VSEG_TYPE_STACK )
+    {
+        // release slot to local stack allocator
+        vmm_stack_free( vmm , vseg );
+
+        // release vseg descriptor to local kmem
+        vseg_free( vseg );
+    }
+    else if( (vseg_type == VSEG_TYPE_ANON) || 
+             (vseg_type == VSEG_TYPE_FILE) || 
+             (vseg_type == VSEG_TYPE_REMOTE) )  
+    {
+        // release vseg to local mmap allocator
+        vmm_mmap_free( vmm , vseg );
+    }
+    else
+    {
+        // release vseg descriptor to local kmem
+        vseg_free( vseg );
+    }
+
+#if DEBUG_VMM_REMOVE_VSEG
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VMM_DELETE_VSEG < cycle )
-printk("\n[%s] thread[%x,%x] exit / process %x / vseg %s / base %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, pid, vseg_type_str(vseg->type), vaddr, cycle );
-#endif
-
-}  // end vmm_delete_vseg()
+if( DEBUG_VMM_REMOVE_VSEG < cycle )
+printk("[%s] thread[%x,%x] exit / process %x / %s / base %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+process->pid, vseg_type_str(vseg->type), vseg->min, cycle );
+#endif
+
+}  // end vmm_remove_vseg()
+
+
+///////////////////////////////////
+void vmm_delete_vseg( pid_t    pid,
+                      intptr_t vaddr )
+{
+    process_t * process;    // local pointer on local process 
+    vseg_t    * vseg;       // local pointer on local vseg containing vaddr
+
+    // get local pointer on local process descriptor
+    process = cluster_get_local_process_from_pid( pid );
+
+    if( process == NULL )
+    {
+        printk("\n[WARNING] in %s : cannot get local process descriptor\n",
+        __FUNCTION__ );
+        return;
+    }
+
+    // get local pointer on local vseg containing vaddr
+    vseg = vmm_vseg_from_vaddr( &process->vmm , vaddr );
+
+    if( vseg == NULL )
+    {
+        printk("\n[WARNING] in %s : cannot get vseg descriptor\n",
+        __FUNCTION__ );
+        return;
+    }
+
+    // call relevant function
+    vmm_remove_vseg( process , vseg );
+
+}  // end vmm_delete_vseg
+
 
 /////////////////////////////////////////////
@@ -1235 +1436 @@
                               intptr_t   vaddr )
 {
-    xptr_t   iter_xp;
     xptr_t   vseg_xp;
     vseg_t * vseg;
+    xptr_t   iter_xp;
 
     // get extended pointers on VSL lock and root
-    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsl_lock );
     xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
 
@@ -1249 +1450 @@
     XLIST_FOREACH( root_xp , iter_xp )
     {
+        // get pointers on vseg
         vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
         vseg    = GET_PTR( vseg_xp );
 
+        // return success when match
         if( (vaddr >= vseg->min) && (vaddr < vseg->max) )
         { 
@@ -1262 +1465 @@
     // return failure
     remote_rwlock_rd_release( lock_xp );
-
     return NULL;
 
@@ -1462 +1664 @@
         vseg_init_from_ref( vseg , vseg_xp );
 
+        // build extended pointer on VSL lock
+        xptr_t lock_xp = XPTR( local_cxy , &vmm->vsl_lock );
+ 
+        // take the VSL lock in write mode
+        remote_rwlock_wr_acquire( lock_xp );
+
         // register local vseg in local VSL
         vmm_attach_vseg_to_vsl( vmm , vseg );
+ 
+        // release the VSL lock
+        remote_rwlock_wr_release( lock_xp );
     }   
 
@@ -1486 +1697 @@
 uint32_t   cycle   = (uint32_t)hal_get_cycles();
 thread_t * this    = CURRENT_THREAD;
-xptr_t     this_xp = XPTR( local_cxy , this );
 if( DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
@@ -1717 +1927 @@
     error_t          error;           // value returned by called functions
 
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_VMM_HANDLE_PAGE_FAULT < cycle )
+printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, vpn, cycle );
+hal_vmm_display( process , true );
+#endif
+
     // get local vseg (access to reference VSL can be required)
     error = vmm_get_vseg( process, 
@@ -1723 +1942 @@
     if( error )
     {
-        printk("\n[ERROR] in %s : vpn %x in process %x not in a registered vseg\n",
-        __FUNCTION__ , vpn , process->pid );
+        printk("\n[ERROR] in %s : vpn %x in process %x not in registered vseg / cycle %d\n",
+        __FUNCTION__ , vpn , process->pid, (uint32_t)hal_get_cycles() );
         
         return EXCP_USER_ERROR;
     }
 
- #if DEBUG_VMM_HANDLE_PAGE_FAULT
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
+#if DEBUG_VMM_HANDLE_PAGE_FAULT
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VMM_HANDLE_PAGE_FAULT < cycle )
-printk("\n[%s] threadr[%x,%x] enter for vpn %x / %s / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, vpn, vseg_type_str(vseg->type), cycle );
+printk("\n[%s] threadr[%x,%x] found vseg %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(vseg->type), cycle );
 #endif
 
@@ -1971 +2189 @@
     error_t          error;
 
+    thread_t * this = CURRENT_THREAD;
+
 #if DEBUG_VMM_HANDLE_COW
 uint32_t   cycle   = (uint32_t)hal_get_cycles();
-thread_t * this    = CURRENT_THREAD;
-xptr_t     this_xp = XPTR( local_cxy , this );
 if( DEBUG_VMM_HANDLE_COW < cycle )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / core[%x,%d] / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, local_cxy, this->core->lid, cycle );
+hal_vmm_display( process , true );
 #endif
 
@@ -1991 +2210 @@
     if( error )
     {
-        printk("\n[PANIC] in %s : vpn %x in process %x not in a registered vseg\n",
-        __FUNCTION__, vpn, process->pid );
+        printk("\n[PANIC] in %s vpn %x in thread[%x,%x] not in a registered vseg\n",
+        __FUNCTION__, vpn, process->pid, this->trdid );
 
         return EXCP_KERNEL_PANIC;

trunk/kernel/mm/vmm.h

@@ -48 +48 @@
  * Each slot can contain one user stack vseg. The first 4 Kbytes page in the slot is not
  * mapped to detect stack overflow.
- * The slot index can be computed form the slot base address, and reversely.
- * All allocation / release operations are registered in the stack_bitmap, that completely
- * define the STACK zone status.
+ * In this implementation, the slot index is defined by the user thead LTID.
+ * All allocated stacks are registered in a bitmap defining the STACK zone state: 
+ * - The allocator checks that the requested slot has not been already allocated, and set the
+ *   corresponding bit in the bitmap.
+ * - The de-allocator function reset the corresponding bit in the bitmap.
  ********************************************************************************************/
 
@@ -57 +59 @@
     busylock_t     lock;               /*! lock protecting STACK allocator                  */
     vpn_t          vpn_base;           /*! first page of STACK zone                         */
-    bitmap_t       bitmap;             /*! bit bector of allocated stacks                   */
+    bitmap_t       bitmap;             /*! bit vector of allocated stacks                   */
 }
 stack_mgr_t;
@@ -84 +86 @@
     vpn_t          vpn_size;           /*! number of pages in MMAP zone                     */
     vpn_t          first_free_vpn;     /*! first free page in MMAP zone                     */
-    list_entry_t   zombi_list[32];     /*! array of roots of released vsegs lists           */
+    xlist_entry_t  zombi_list[32];     /*! array of roots of released vsegs lists           */
 }
 mmap_mgr_t;
@@ -109 +111 @@
 typedef struct vmm_s
 {
-        remote_rwlock_t  vsegs_lock;         /*! lock protecting the local VSL                  */
+        remote_rwlock_t  vsl_lock;           /*! lock protecting the local VSL                  */
         xlist_entry_t    vsegs_root;         /*! Virtual Segment List (complete in reference)   */
         uint32_t         vsegs_nr;           /*! total number of local vsegs                    */
@@ -132 +134 @@
 
 /*********************************************************************************************
- * This function initialises the virtual memory manager attached to an user process.
+ * This function mkkes a partial initialisation of the VMM attached to an user process. 
+ * The GPT must have been previously created, with the hal_gpt_create() function.
+ * - It registers "args", "envs" vsegs in the VSL.
  * - It initializes the STACK and MMAP allocators.
- * - It registers the "kentry", "args", "envs" vsegs in the VSL.
- * - It initializes the generic page table, calling the HAL specific hal_gpt_init() function.
- * - For TSAR it map all pages for the "kentry" vseg, that must be identity mapping.
- ******************************************************a**************************************
- * Implementation notes:
+ * Note:
  * - The "code" and "data" vsegs are registered by the elf_load_process() function.
- * - The "stack" vsegs are dynamically created by the thread_user_create() function.
- * - The "file", "anon", "remote" vsegs are dynamically created by the mmap() syscall.
+ * - The "stack" vsegs are dynamically registered by the thread_user_create() function.
+ * - The "file", "anon", "remote" vsegs are dynamically registered by the mmap() syscall.
  *********************************************************************************************
  * @ process   : pointer on process descriptor
  * @ return 0 if success / return -1 if failure.
  ********************************************************************************************/
-error_t vmm_init( struct process_s * process );
-
-/*********************************************************************************************
- * This function displays on TXY0 the list or registered vsegs for a given <process>.
- * It must be executed by a thread running in reference cluster.
- * If the <mapping> argument is true, it displays for each vseg all mapped PTEs in GPT.
+error_t vmm_user_init( struct process_s * process );
+
+/*********************************************************************************************
+ * This function re-initialises the VMM attached to an user process to prepare a new
+ * call to the vmm_user_init() function after an exec() syscall.
+ * It removes from the VMM of the process identified by the <process> argument all
+ * non kernel vsegs (i.e. all user vsegs), by calling the vmm_remove_vseg() function.
+ * - the vsegs are removed from the VSL.
+ * - the corresponding GPT entries are removed from the GPT.
+ * - the physical pages are released to the relevant kmem when they are not shared.
+ * The VSL and the GPT are not modified for the kernel vsegs.
  *********************************************************************************************
  * @ process   : pointer on process descriptor.
- * @ mapping   : detailed mapping if true.
- ********************************************************************************************/
-void hal_vmm_display( struct process_s * process,
-                  bool_t             mapping );
+ ********************************************************************************************/
+void vmm_user_reset( struct process_s * process );
 
 /*********************************************************************************************
  * 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
- *   VSL, and all valid GPT entries in parent GPT are copied to the child GPT. 
- *   The WRITABLE flag is reset and the COW flag is set in child GPT.
- * - all CODE vsegs registered in the parent VSL are registered in the child VSL, but the
- *   GPT entries are not copied in the chilf GPT, that will be dynamically updated from
+ * - All DATA, ANON, REMOTE vsegs registered in the parent VSL are registered in the
+ *   child VSL. All valid PTEs in parent GPT are copied to the child GPT, but the 
+ *   WRITABLE flag is reset and the COW flag is set.
+ * - All CODE vsegs registered in the parent VSL are registered in the child VSL, but the
+ *   GPT entries are not copied in the child GPT, and will be dynamically updated from
  *   the .elf file when a page fault is reported.
- * - all FILE vsegs registered in the parent VSL are registered in the child VSL, and all
+ * - All FILE vsegs registered in the parent VSL are registered in the child VSL, and all
  *   valid GPT entries in parent GPT are copied to the child GPT. The COW flag is not set.
- * - no STACK vseg is copied from  parent VMM to child VMM, because the child STACK vseg
+ * - No STACK vseg is copied from  parent VMM to child VMM, because the child stack vseg
  *   must be copied later from the cluster containing the user thread requesting the fork().
+ * - The KERNEL vsegs required by the target architecture are re-created in the child
+ *   VMM, from the local kernel process VMM, using the hal_vmm_kernel_update() function.
  *********************************************************************************************
  * @ child_process     : local pointer on local child process descriptor.
@@ -196 +201 @@
 
 /*********************************************************************************************
- * This global function modifies a GPT entry identified by the <process> and <vpn> 
- * arguments in all clusters containing a process copy.
+ * This 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,
@@ -240 +245 @@
 /*********************************************************************************************
  * This function allocates memory for a vseg descriptor, initialises it, and register it
- * in the VMM of the local process descriptor, that must be the reference process.
- * For the 'stack", "file", "anon", & "remote" types, it does not use the <base> argument,
- * but uses the STACK and MMAP virtual memory allocators.
+ * in the VSL of the local process descriptor, that must be the reference process.
+ * - For the FILE, ANON, & REMOTE types, it does not use the <base> and <size> arguments,
+ *   but uses the specific MMAP virtual memory allocator.
+ * - For the STACK type, it does not use the <size> argument, and the <base> argument
+ *   defines the user thread LTID used by the specific STACK virtual memory allocator.
  * It checks collision with all pre-existing vsegs.
- * To comply with the "on-demand" paging policy, this function does NOT modify the page table,
+ * To comply with the "on-demand" paging policy, this function does NOT modify the GPT,
  * and does not allocate physical memory for vseg data.
  * It should be called by a local thread (could be a RPC thread if the client thread is not
- * running in the regerence cluster).
+ * running in the reference cluster).
  *********************************************************************************************
  * @ process     : pointer on local processor descriptor.
  * @ type        : vseg type.
- * @ base        : vseg base address (not used for dynamically allocated vsegs).
+ * @ base        : vseg base address (or user thread ltid for an user stack vseg).
  * @ size        : vseg size (bytes).
  * @ file_offset : offset in file for CODE, DATA, FILE types. 
@@ -269 +276 @@
 
 /*********************************************************************************************
- * This function removes from the local VMM of a process descriptor identified by the <pid>
- * argument a local vseg identified by its base address <vaddr> in user space.
- * It can be used for any type of vseg, but must be called by a local thread.
- * Use the RPC_VMM_DELETE_VSEG if the client thread is not local.
- * It does nothing if the process is not registered in the local cluster.
- * It does nothing if the vseg is not registered in the local process VSL.
- * - It removes from the local GPT all registered PTEs. If it is executed in the reference
- *   cluster, it releases the referenced physical pages, to the relevant kmem allocator,
- *   depending on vseg type and the pending forks counter.
- * - It removes the vseg from the local VSL, and release the vseg descriptor if not MMAP.
- *********************************************************************************************
- * @ process  : process identifier.
- * @ vaddr    : vseg base address in user space.
+ * This function removes from the VMM of a process descriptor identified by the <process>
+ * argument the vseg identified by the <vseg> argument. It can be used for any type of vseg. 
+ * As it uses local pointers, it must be called by a local thread.
+ * It is called by the vmm_user_reset(), vmm_delete_vseg() and vmm_destroy() functions.
+ * It makes a kernel panic if the process is not registered in the local cluster,
+ * or if the vseg is not registered in the process VSL.
+ * For all vseg types, the vseg is detached from local VSL, and all associated PTEs are
+ * unmapped from local GPT. Other actions depend on the vseg type:
+ * - Regarding the vseg descriptor release:
+ *   . for ANON and REMOTE, the vseg is not released, but registered in local zombi_list.
+ *   . for STACK the vseg is released to the local stack allocator.
+ *   . for all other types, the vseg is released to the local kmem.
+ * - Regarding the physical pages release:
+ *   . for KERNEL and FILE, the pages are not released to kmem.
+ *   . for CODE and STACK, the pages are released to local kmem when they are not COW.
+ *   . for DATA, ANON and REMOTE, the pages are released to relevant kmem only when
+ *     the local cluster is the reference cluster.
+ * The lock protecting the VSL must be taken by the caller.
+ *********************************************************************************************
+ * @ process  : local pointer on process.
+ * @ vseg     : local pointer on vseg. 
+ ********************************************************************************************/
+void vmm_remove_vseg( struct process_s * process,
+                      struct vseg_s    * vseg );
+
+/*********************************************************************************************
+ * This function call the vmm_remove vseg() function to remove from the VMM of a local
+ * process descriptor, identified by the <pid> argument the vseg identified by the <vaddr>
+ * virtual address in user space. 
+ * Use the RPC_VMM_DELETE_VSEG to remove a vseg from a remote process descriptor.
+ *********************************************************************************************
+ * @ pid      : process identifier.
+ * @ vaddr    : virtual address in user space.
  ********************************************************************************************/
 void vmm_delete_vseg( pid_t    pid,
                       intptr_t vaddr );
-
-/*********************************************************************************************
- * This function insert a new <vseg> descriptor in the VSL identifed by the <vmm> argument.
- * and updates the vmm field in the vseg descriptor.
- * It takes the lock protecting VSL.
- *********************************************************************************************
- * @ vmm       : local pointer on local VMM.
- * @ vseg      : local pointer on local vseg descriptor.
- ********************************************************************************************/
-void vmm_attach_vseg_to_vsl( vmm_t  * vmm,
-                             vseg_t * vseg );
-
-/*********************************************************************************************
- * This function removes a vseg identified by the <vseg> argument from the local VSL
- * identified by the <vmm> argument and release the memory allocated to vseg descriptor,
- * for all vseg types, BUT the MMAP type (i.e. ANON or REMOTE).
- * - If the vseg has not the STACK or MMAP type, it is simply removed from the VSL,
- *   and vseg descriptor is released.
- * - If the vseg has the STACK type, it is removed from VSL, vseg descriptor is released,
- *   and the stack slot is returned to the local VMM_STACK allocator.
- * - If the vseg has the MMAP type, it is removed from VSL and is registered in zombi_list
- *   of the VMM_MMAP allocator for future reuse. The vseg descriptor is NOT released.
- *********************************************************************************************
- * @ vmm       : local pointer on local VMM.
- * @ vseg      : local pointer on local vseg to be removed.
- ********************************************************************************************/
-void vmm_detach_vseg_from_vsl( vmm_t  * vmm,
-                               vseg_t * vseg );
 
 /*********************************************************************************************

trunk/kernel/mm/vseg.c

@@ -61 +61 @@
 }
 
-/////////////////////
+///////////////////////////
 vseg_t * vseg_alloc( void )
 {

trunk/kernel/mm/vseg.h

@@ -70 +70 @@
 /*******************************************************************************************
  * This structure defines a virtual segment descriptor.
- * - The VSL contains only local vsegs, but is implemented as an xlist, because it can be
- *   accessed by thread running in a remote cluster.
- * - The zombi list is used by the local MMAP allocator. It is implemented as a local list.
+ * The VSL contains only local vsegs, but is implemented as an xlist, because it can be
+ * accessed by a thread running in a remote cluster.
+ * The xlist field is also used to implement the zombi lists used by the MMAP allocator.
  ******************************************************************************************/
 
@@ -78 +78 @@
 {
     xlist_entry_t     xlist;        /*! all vsegs in same VSL                             */
-    list_entry_t      zlist;        /*! all vsegs in same zombi list                      */
     struct vmm_s    * vmm;          /*! pointer on associated VM manager                  */
     uint32_t          type;         /*! vseg type                                         */

trunk/kernel/syscalls/sys_barrier.c

@@ -2 +2 @@
  * sys_barrier.c - Access a POSIX barrier.
  * 
- * authors       Alain Greiner (2016,2017,2018)
+ * authors       Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -25 +25 @@
 #include <hal_special.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <errno.h>
 #include <thread.h>
@@ -56 +57 @@
     process_t * process = this->process;
 
+#if (DEBUG_SYS_BARRIER || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_BARRIER
-uint64_t   tm_start;
-uint64_t   tm_end;
-tm_start = hal_get_cycles();
 if( DEBUG_SYS_BARRIER < tm_start )
 printk("\n[%s] thread[%x,%x] enters for %s / count %d / cycle %d\n",
@@ -184 +186 @@
         }  // end switch
 
+    hal_fence();
+
+#if (DEBUG_SYS_BARRIER || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_BARRIER
-tm_end = hal_get_cycles();
 if( DEBUG_SYS_BARRIER < tm_end )
-printk("\n[%s] thread[%x,%x] exit for %s / cost %d / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, sys_barrier_op_str(operation), 
-(uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+printk("\n[%s] thread[%x,%x] exit for %s / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, sys_barrier_op_str(operation), (uint32_t)tm_end );
+#endif
+
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_BARRIER] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_BARRIER] , 1 );
 #endif
 

trunk/kernel/syscalls/sys_close.c

@@ -35 +35 @@
 int sys_close ( uint32_t file_id )
 {
-    error_t     error;
-    xptr_t      file_xp;
+    error_t            error;
+    xptr_t             file_xp;
+    cxy_t              file_cxy;
+    vfs_file_t       * file_ptr;
+    vfs_inode_type_t   file_type;
 
         thread_t  * this    = CURRENT_THREAD;
@@ -54 +57 @@
         if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
         {
-        printk("\n[ERROR] in %s : illegal file descriptor index = %d\n",
-               __FUNCTION__ , file_id );
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : illegal file descriptor index = %d\n",
+__FUNCTION__ , file_id );
+#endif
                 this->errno = EBADFD;
                 return -1;
@@ -73 +79 @@
                 return -1;
     }
+
+    // get file type
+    file_cxy  = GET_CXY( file_xp );
+    file_ptr  = GET_PTR( file_xp );
+    file_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
+
+    if( file_type == INODE_TYPE_DIR ) 
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : file descriptor %d is a directory\n",
+__FUNCTION__ , file_id );
+#endif
+                this->errno = EBADFD;
+                return -1;
+        }
 
     // call the relevant VFS function

trunk/kernel/syscalls/sys_display.c

@@ -96 +96 @@
             // check string in user space
             error = vmm_get_vseg( process , (intptr_t)arg0 , &vseg );
-
             if( error )
             {
@@ -110 +109 @@
             // ckeck string length
             length = hal_strlen_from_uspace( string );
-
             if( length >= 512 )
             {
@@ -150 +148 @@
             // get extended pointer on process PID in cluster CXY
             xptr_t process_xp = cluster_get_process_from_pid_in_cxy( cxy , pid );
-
                 if( process_xp == XPTR_NULL )
             {

trunk/kernel/syscalls/sys_exec.c

@@ -2 +2 @@
  * sys_exec.c - Kernel function implementing the "exec" system call.
  *
- * Authors   Alain Greiner (2016,2017)
+ * Authors   Alain Greiner (2016,2017,2017,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -208 +208 @@
 #if DEBUG_SYS_EXEC
 if( DEBUG_SYS_EXEC < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] enter for path <%s> / cycle = %d\n",
+printk("\n[%s] thread[%x,%x] enter for path <%s> / cycle = %d\n",
 __FUNCTION__, pid, this->trdid, exec_info.path, (uint32_t)tm_start );
 #endif
@@ -256 +256 @@
     }
 
-    assert( false , "we should not execute this code" );
+    assert( false , "we should never execute this code" );
 
     return 0;  

trunk/kernel/syscalls/sys_exit.c

@@ -2 +2 @@
  * sys_exit.c - Kernel function implementing the "exit" system call.
  * 
- * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c)  UPMC Sorbonne Universites
@@ -53 +53 @@
     pid_t       pid     = process->pid;
 
+#if (DEBUG_SYS_EXIT || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_EXIT
-uint64_t    tm_start;
-uint64_t    tm_end;
-tm_start = hal_get_cycles();
 if( DEBUG_SYS_EXIT < tm_start )
 printk("\n[%s] thread[%x,%x] enter / status %x / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid , status , (uint32_t)tm_start );
+__FUNCTION__, pid, this->trdid , status , (uint32_t)tm_start );
 #endif
 
@@ -66 +67 @@
     owner_cxy = GET_CXY( owner_xp );
     owner_ptr = GET_PTR( owner_xp );
-
-#if (DEBUG_SYS_EXIT & 1)
-if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[%s] thread[%x,%x] get owner process in cluster %x\n",
-__FUNCTION__, process->pid, this->trdid, owner_cxy );
-#endif
 
     // get local pointer on the main thread
@@ -80 +75 @@
     parent_cxy = GET_CXY( parent_xp );
     parent_ptr = GET_PTR( parent_xp );
-
-#if (DEBUG_SYS_EXIT & 1)
-if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[%s] thread[%x,%x] get parent process in cluster %x\n",
-__FUNCTION__, process->pid, this->trdid, parent_cxy );
-#endif
 
     // get pointers on the parent process main thread
@@ -96 +85 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[%s] thread[%x,%x] detached process from TXT\n",
-__FUNCTION__, process->pid, this->trdid );
+printk("\n[%s] thread[%x,%x] detached process %x from TXT\n",
+__FUNCTION__, pid, this->trdid, pid );
 #endif
 
     // mark for delete all process threads in all clusters, 
     // but the main thread and this calling thread 
-    process_sigaction( process->pid , DELETE_ALL_THREADS );
+    process_sigaction( pid , DELETE_ALL_THREADS );
 
 #if( DEBUG_SYS_EXIT & 1)
 if( DEBUG_SYS_EXIT < tm_start )
-printk("\n[%s] thread[%x,%x] deleted all threads but itself\n",
-__FUNCTION__, process->pid, this->trdid );
+printk("\n[%s] thread[%x,%x] deleted all threads in process %x (but itself)\n",
+__FUNCTION__, pid, this->trdid, pid );
 #endif
 
@@ -116 +105 @@
 #if( DEBUG_SYS_EXIT & 1)
 if( tm_start > DEBUG_SYS_EXIT )
-printk("\n[%u] thread[%x,%x] marked iself for delete\n",
-__FUNCTION__, process->pid, this->trdid );
+printk("\n[%s] thread[%x,%x] marked iself for delete\n",
+__FUNCTION__, pid, this->trdid );
 #endif
         thread_delete( XPTR( local_cxy , this ) , pid , true );
     }
 
-    // block this main thread 
+    // block the main thread 
     thread_block( XPTR( owner_cxy , main_ptr ) , THREAD_BLOCKED_GLOBAL );
 
 #if( DEBUG_SYS_EXIT & 1)
+trdid_t main_trdid = hal_remote_l32( XPTR( owner_cxy , &main_ptr->trdid ) );
 if( tm_start > DEBUG_SYS_EXIT )
-printk("\n[%s] thread[%x,%x] blocked main thread\n",
-__FUNCTION__, process->pid, this->trdid );
+printk("\n[%s] thread[%x,%x] blocked main thread[%x,%x]\n",
+__FUNCTION__, pid, this->trdid, pid, main_trdid );
 #endif
 
-    // atomically update owner process descriptor term_state to ask
-    // the parent process sys_wait() function to delete the main thread 
+    // update term_state in owner process descriptor to ask
+    // the parent process sys_wait() function to delete the process 
     term_state = (status & 0xFF) | PROCESS_TERM_EXIT;
     hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) , term_state );
@@ -139 +129 @@
 if( tm_start > DEBUG_SYS_EXIT )
 printk("\n[%s] thread[%x,%x] set exit status %x in owner process\n",
-__FUNCTION__, process->pid, this->trdid, term_state );
+__FUNCTION__, pid, this->trdid, term_state );
 #endif
 
@@ -148 +138 @@
 if( tm_start > DEBUG_SYS_EXIT )
 printk("\n[%s] thread[%x,%x] unblocked parent main thread in process %x\n",
-__FUNCTION__ , process->pid, this->trdid,
+__FUNCTION__ , pid, this->trdid,
 hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid) ) );
 #endif
@@ -154 +144 @@
     hal_fence();
 
+#if (DEBUG_SYS_EXIT || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_EXIT
-tm_end = hal_get_cycles();
 if( DEBUG_SYS_EXIT < tm_end )
-printk("\n[%s] thread[%x,%x] exit / status %x / cost = %d / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, status,
-(uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+printk("\n[%s] thread[%x,%x] exit / term_state %x / cycle %d\n",
+__FUNCTION__, pid, this->trdid, term_state,  (uint32_t)tm_end );
+#endif
+
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_EXIT] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_EXIT] , 1 );
 #endif
 

trunk/kernel/syscalls/sys_fork.c

@@ -2 +2 @@
  * sys_fork.c - Kernel function implementing the "fork" system call.
  * 
- * Authors  Alain Greiner  (2016,2017)
+ * Authors  Alain Greiner  (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -73 +73 @@
 #if DEBUG_SYS_FORK
 if( DEBUG_SYS_FORK < tm_start )
-printk("\n[DBG] %s : thread[%x,%x] enter / cycle =  %d\n",
+printk("\n[%s] thread[%x,%x] enter / cycle =  %d\n",
 __FUNCTION__, parent_pid, parent_thread_ptr->trdid, (uint32_t)tm_start );
 #endif
@@ -151 +151 @@
 
     // set remote child CPU context from parent_thread register values
+    // replicates the parent thread kernel stack to the child thread descriptor,
+    // and finally unblock the child thread. 
     hal_cpu_context_fork( XPTR( child_cxy , child_thread_ptr ) );
 
     // From this point, both parent and child threads execute the following code,
-    // but they can be distinguished by the (CURRENT_THREAD,local_cxy) values.
-    // - parent unblock child, and return child PID to user application.
-    // - child thread does nothing, and return 0 to user pplication 
-    // The child thread will only execute it when it is unblocked by parent thread.
+    // but child thread will only execute it after being unblocked by parent thread.
+    // They can be distinguished by the (CURRENT_THREAD,local_cxy) values.
+    // - parent return child PID to user application.
+    // - child  return 0 to user application 
 
     thread_t * current = CURRENT_THREAD;
@@ -165 +167 @@
 #endif
 
+    if( (current == parent_thread_ptr) && (local_cxy == parent_cxy) )   // parent thread
+    {
+
 #if DEBUG_SYS_FORK
 if( DEBUG_SYS_FORK < tm_end )
-printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
-__FUNCTION__, current->process->pid, current->trdid, (uint32_t)tm_end );
+printk("\n[%s] parent thread[%x,%x] exit / child_pid %x / cycle %d\n",
+__FUNCTION__, current->process->pid, current->trdid, child_pid, (uint32_t)tm_end );
 #endif
 
-    if( (current == parent_thread_ptr) && (local_cxy == parent_cxy) )   // parent thread
-    {
-        // parent_thread unblock child_thread
-        thread_unblock( XPTR( child_cxy , child_thread_ptr ) , THREAD_BLOCKED_GLOBAL );
-
-        // only parent contribute to instrumentation
-
+// only parent contribute to instrumentation
 #if CONFIG_INSTRUMENTATION_SYSCALLS
 hal_atomic_add( &syscalls_cumul_cost[SYS_FORK] , tm_end - tm_start );
@@ -186 +185 @@
         else                                                               // child_thread
     {
+
+#if DEBUG_SYS_FORK
+if( DEBUG_SYS_FORK < tm_end )
+printk("\n[%s] child thread[%x,%x] exit / child_pid %x / cycle %d\n",
+__FUNCTION__, current->process->pid, current->trdid, child_pid, (uint32_t)tm_end );
+#endif
+
         return 0;
     }

trunk/kernel/syscalls/sys_get_config.c

@@ -2 +2 @@
  * sys_get_config.c - get hardware platform parameters.
  * 
- * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
  *  
  * Copyright (c) UPMC Sorbonne Universites
@@ -24 +24 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <hal_special.h>
 #include <errno.h>
@@ -48 +49 @@
     process_t * process = this->process;
 
+#if (DEBUG_SYS_GET_CONFIG || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_GET_CONFIG
-uint64_t     tm_start;
-uint64_t     tm_end;
 tm_start = hal_get_cycles();
 if( DEBUG_SYS_GET_CONFIG < tm_start )
@@ -114 +117 @@
     hal_fence();
 
+#if (DEBUG_SYS_GET_CONFIG || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_GET_CONFIG
-tm_end = hal_get_cycles();
 if( DEBUG_SYS_GET_CONFIG < tm_end )
 printk("\n[DBG] %s : thread %x exit / process %x / cost %d / cycle %d\n",
@@ -121 +127 @@
 #endif
 
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_GET_CONFIG] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_GET_CONFIG] , 1 );
+#endif
+
         return 0; 
 

trunk/kernel/syscalls/sys_get_core.c

@@ -24 +24 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <hal_special.h>
 #include <errno.h>

trunk/kernel/syscalls/sys_get_cycle.c

@@ -24 +24 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <hal_special.h>
 #include <errno.h>

trunk/kernel/syscalls/sys_is_fg.c

@@ -2 +2 @@
  * sys_fg.c - Kernel function implementing the "is_fg" system call.
  * 
- * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c)  UPMC Sorbonne Universites
@@ -25 +25 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <hal_special.h>
 #include <errno.h>

trunk/kernel/syscalls/sys_mmap.c

@@ -2 +2 @@
  * sys_mmap.c - map files, memory or devices into process virtual address space
  * 
- * Authors       Ghassan Almaless (2008,2009,2010,2011,2012)
- *               Alain Greiner (2016,2017,2018)
+ * Authors       Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -25 +24 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <hal_irqmask.h>
 #include <shared_syscalls.h>

trunk/kernel/syscalls/sys_munmap.c

@@ -2 +2 @@
  * sys_munmap.c - unmap a mapping from process virtual address space
  * 
- * Authors       Ghassan Almaless (2008,2009,2010,2011,2012)
- *               Alain Greiner (2016,2017,2018)
+ * Authors       Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -25 +24 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <hal_irqmask.h>
 #include <shared_syscalls.h>

trunk/kernel/syscalls/sys_mutex.c

@@ -2 +2 @@
  * sys_mutex.c - Access a POSIX mutex.
  * 
- * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -24 +24 @@
 #include <hal_kernel_types.h>
 #include <hal_special.h>
+#include <hal_vmm.h>
 #include <errno.h>
 #include <thread.h>
@@ -56 +57 @@
     process_t * process = this->process;
 
+#if (DEBUG_SYS_MUTEX || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_MUTEX
-uint64_t    tm_start;
-uint64_t    tm_end;
-tm_start = hal_get_cycles();
 if( DEBUG_SYS_MUTEX < tm_start )
-printk("\n[DBG] %s : thread %x in process %x enter for %s / cycle %d\n",
+printk("\n[%s] thread[%x,%x] enter for %s / cycle %d\n",
 __FUNCTION__, this->trdid, process->pid, sys_mutex_op_str( operation ), (uint32_t)tm_start );
 #endif
@@ -221 +223 @@
     hal_fence();
 
+#if (DEBUG_SYS_MUTEX || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
 #if DEBUG_SYS_MUTEX
-tm_end = hal_get_cycles();
-if( DEBUG_SYS_MUTEX < tm_start )
-printk("\n[DBG] %s : thread %x in process %x exit for %s / cost %d / cycle %d\n",
-__FUNCTION__, this->trdid, process->pid, sys_mutex_op_str( operation ),
-(uint32_t)(tm_end - tm_start), (uint32_t)tm_end );
+if( DEBUG_SYS_MUTEX < tm_end )
+printk("\n[%s] thread[%x,%x] exit for %s / cycle %d\n",
+__FUNCTION__, this->trdid, process->pid, sys_mutex_op_str( operation ), (uint32_t)tm_end );
+#endif
+
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_MUTEX] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_MUTEX] , 1 );
 #endif
 

trunk/kernel/syscalls/sys_open.c

@@ -2 +2 @@
  * sys_open.c - open a file.
  *
- * Author        Alain Greiner (2016,2017)
+ * Author        Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites

trunk/kernel/syscalls/sys_opendir.c

@@ -2 +2 @@
  * sys_opendir.c - Open an user accessible VFS directory.
  * 
- * Author        Alain Greiner (2016,2017,2018)
+ * Author        Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -25 +25 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <thread.h>
 #include <process.h>

trunk/kernel/syscalls/sys_read.c

@@ -1 +1 @@
 /*
- * sys_read.c - read bytes from a file
+ * sys_read.c - Kernel function implementing the "read" system call.
  * 
- * Author     Alain Greiner (2016,2017,2018)
+ * Author     Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -24 +24 @@
 #include <kernel_config.h>
 #include <hal_kernel_types.h>
+#include <hal_vmm.h>
 #include <hal_uspace.h>
 #include <hal_irqmask.h>

trunk/kernel/syscalls/sys_readdir.c

@@ -25 +25 @@
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <errno.h>
 #include <thread.h>

trunk/kernel/syscalls/sys_thread_exit.c

@@ -64 +64 @@
 uint64_t     tm_start = hal_get_cycles();
 if( DEBUG_SYS_THREAD_EXIT < tm_start )
-printk("\n[%s] thread[%x,%x] / main => delete process / cycle %d\n",
+printk("\n[%s] thread[%x,%x] is main => delete process / cycle %d\n",
 __FUNCTION__ , pid , trdid , (uint32_t)tm_start );
 #endif
@@ -76 +76 @@
 uint64_t     tm_start = hal_get_cycles();
 if( DEBUG_SYS_THREAD_EXIT < tm_start )
-printk("\n[%s] thread[%x,%x] / not main => delete thread / cycle %d\n",
+printk("\n[%s] thread[%x,%x] is not main => delete thread / cycle %d\n",
 __FUNCTION__ , pid , trdid , (uint32_t)tm_start );
 #endif

trunk/kernel/syscalls/sys_wait.c

@@ -2 +2 @@
  * sys_wait.c - wait termination or blocking of a child process.
  * 
- * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
  *  
  * Copyright (c) UPMC Sorbonne Universites
@@ -56 +56 @@
 uint64_t    cycle = hal_get_cycles();
 if( DEBUG_SYS_WAIT < cycle )
-printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
-__FUNCTION__, this, process->pid, (uint32_t)cycle );
+printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
+__FUNCTION__, pid, this->trdid, (uint32_t)cycle );
 #endif
 
@@ -67 +67 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : status buffer %x unmapped for thread %x in process %x\n",
-__FUNCTION__ , (intptr_t)status, this->trdid , process->pid );
+printk("\n[ERROR] in %s : status buffer %x unmapped for thread[%x,%x]\n",
+__FUNCTION__ , (intptr_t)status, pid, this->trdid );
 hal_vmm_display( process , false );
 #endif
@@ -86 +86 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : calling thread %x is not thread 0 in owner cluster %x\n",
-__FUNCTION__ , trdid , owner_cxy );
+printk("\n[ERROR] in %s : calling thread[%x,%x] is not thread 0 in owner cluster %x\n",
+__FUNCTION__ , pid, this->trdid , owner_cxy );
 #endif
         this->errno = EINVAL;
@@ -119 +119 @@
             child_thread = hal_remote_lpt(XPTR( child_cxy , &child_ptr->th_tbl[0] ));
 
-#if (DEBUG_SYS_WAIT & 1)
-cycle = hal_get_cycles();
-if( DEBUG_SYS_WAIT < cycle )
-printk("\n[DBG] %s : thread %x in process %x check child %x / state %x\n",
-__FUNCTION__, this, process->pid, child_pid, child_state );
-#endif
             // test if this child process is terminated,
             // but termination not yet reported to parent process
@@ -148 +142 @@
 if( DEBUG_SYS_WAIT < cycle )
 {
-    if     ( child_state & PROCESS_TERM_EXIT )
-        printk("\n[DBG] %s : thread %x in process %x exit / child %x exit / cycle %d\n",
-        __FUNCTION__, this, process->pid, child_pid, (uint32_t)cycle );
+    if( child_state & PROCESS_TERM_EXIT )
+        printk("\n[%s] thread[%x,%x] exit : child process %x terminated / cycle %d\n",
+        __FUNCTION__, pid, this->trdid, child_pid, (uint32_t)cycle );
     if( child_state & PROCESS_TERM_KILL )
-        printk("\n[DBG] %s : thread %x in process %x exit / child %x killed / cycle %d\n",
-        __FUNCTION__, this, process->pid, child_pid, (uint32_t)cycle );
+        printk("\n[%s] thread[%x,%x] exit : child process %x killed / cycle %d\n",
+        __FUNCTION__, pid, this->trdid, child_pid, (uint32_t)cycle );
     if( child_state & PROCESS_TERM_STOP )
-        printk("\n[DBG] %s : thread %x in process %x exit / child %x stopped / cycle %d\n",
-        __FUNCTION__, this, process->pid, child_pid, (uint32_t)cycle );
+        printk("\n[%s] thread[%x,%x] exit : child process %x stopped / cycle %d\n",
+        __FUNCTION__, pid, this->trdid, child_pid, (uint32_t)cycle );
 }
 #endif
@@ -165 +159 @@
         }  // end loop on children
         
-        // we execute this code when no child terminated:
+        // we execute this code when no child change detected
         // - release the lock protecting children list,
         // - block on the WAIT condition
@@ -179 +173 @@
 cycle = hal_get_cycles();
 if( DEBUG_SYS_WAIT < cycle )
-printk("\n[DBG] %s : thread %x in process %x block & deschedule / cycle %d\n",
-__FUNCTION__, this, process->pid, (uint32_t)cycle );
+printk("\n[%s] thread[%x,%x] block & deschedule / cycle %d\n",
+__FUNCTION__, pid, this->trdid, (uint32_t)cycle );
 #endif
 
@@ -189 +183 @@
 cycle = hal_get_cycles();
 if( DEBUG_SYS_WAIT < cycle )
-printk("\n[DBG] %s : thread %x in process %x unblock & resume / cycle %d\n",
-__FUNCTION__, this, process->pid, (uint32_t)cycle );
+printk("\n[%s] thread[%x,%x] resume / cycle %d\n",
+__FUNCTION__, pid, this->trdid, (uint32_t)cycle );
 #endif
 

trunk/kernel/syscalls/sys_write.c

@@ -2 +2 @@
  * sys_write.c - Kernel function implementing the "write" system call.
  * 
- * Author        Alain Greiner (2016,2017,2018)
+ * Author        Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -76 +76 @@
 
 #if DEBUG_SYS_WRITE
-tm_start = hal_get_cycles();
 if( DEBUG_SYS_WRITE < tm_start )
-printk("\n[%s] thread[%x,%x] enter / vaddr %x / count %d / cycle %d\n",
+printk("\n[%s] thread[%x,%x] enter / vaddr %x / %d bytes / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, vaddr, count, (uint32_t)tm_start );
 #endif
@@ -140 +139 @@
     hal_enable_irq( &save_sr );
 
-   // action depend on file type
-    if( file_type == INODE_TYPE_FILE )  // write to file mapper 
+    // action depend on file type
+    if( file_type == INODE_TYPE_FILE )  // write to a file mapper 
     {
         // check file writable
@@ -180 +179 @@
         xptr_t inode_xp = XPTR( file_cxy , inode_ptr );
         vfs_inode_update_size( inode_xp , file_offset + count );
-
     }
     else if( file_type == INODE_TYPE_DEV )  // write to TXT device