Changeset 407 for trunk/kernel/mm

Timestamp:

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

Author:

alain

Message:

First implementation of fork/exec.

Location:

trunk/kernel/mm

Files:

• kcm.c (modified) (5 diffs)
• kmem.c (modified) (6 diffs)
• mapper.c (modified) (15 diffs)
• mapper.h (modified) (2 diffs)
• page.c (modified) (2 diffs)
• page.h (modified) (1 diff)
• ppm.c (modified) (5 diffs)
• ppm.h (modified) (1 diff)
• vmm.c (modified) (37 diffs)
• vmm.h (modified) (14 diffs)
• vseg.c (modified) (6 diffs)
• vseg.h (modified) (3 diffs)

trunk/kernel/mm/kcm.c

@@ -47 +47 @@
                              kcm_page_t * kcm_page )
 {
-        kcm_dmsg("\n[DMSG] %s : enters for %s / page %x / count = %d / active = %d\n",
+        kcm_dmsg("\n[DBG] %s : enters for %s / page %x / count = %d / active = %d\n",
                  __FUNCTION__ , kmem_type_str( kcm->type ) ,
                  (intptr_t)kcm_page , kcm_page->count , kcm_page->active );
@@ -80 +80 @@
                      + (index * kcm->block_size) );
 
-        kcm_dmsg("\n[DMSG] %s : allocated one block  %s / ptr = %p / page = %x / count = %d\n",
+        kcm_dmsg("\n[DBG] %s : allocated one block  %s / ptr = %p / page = %x / count = %d\n",
                  __FUNCTION__ , kmem_type_str( kcm->type ) , ptr ,
                  (intptr_t)kcm_page , kcm_page->count );
@@ -231 +231 @@
         kcm->blocks_nr = blocks_nr;
 
-        kcm_dmsg("\n[DMSG] %s : KCM %s initialised / block_size = %d / blocks_nr = %d\n",
+        kcm_dmsg("\n[DBG] %s : KCM %s initialised / block_size = %d / blocks_nr = %d\n",
                  __FUNCTION__ , kmem_type_str( type ) , kcm->block_size , kcm->blocks_nr );
 }
@@ -301 +301 @@
                 kcm_page->active = 1;
 
-                kcm_dmsg("\n[DMSG] %s : enters for type %s at cycle %d / new page = %x / count = %d\n",
+                kcm_dmsg("\n[DBG] %s : enters for type %s at cycle %d / new page = %x / count = %d\n",
                          __FUNCTION__ , kmem_type_str( kcm->type ) , hal_get_cycles() ,
                          (intptr_t)kcm_page , kcm_page->count );
@@ -311 +311 @@
                 kcm_page = (kcm_page_t *)LIST_FIRST( &kcm->active_root , kcm_page_t , list );
 
-                kcm_dmsg("\n[DMSG] %s : enters for type %s at cycle %d / page = %x / count = %d\n",
+                kcm_dmsg("\n[DBG] %s : enters for type %s at cycle %d / page = %x / count = %d\n",
                          __FUNCTION__ , kmem_type_str( kcm->type ) , hal_get_cycles() ,
                          (intptr_t)kcm_page , kcm_page->count );

trunk/kernel/mm/kmem.c

@@ -145 +145 @@
         assert( ((type > 1) && (type < KMEM_TYPES_NR) ) , __FUNCTION__ , "illegal KCM type" );
 
-        kmem_dmsg("\n[DMSG] %s : enters / KCM type %s missing in cluster %x\n",
+        kmem_dmsg("\n[DBG] %s : enters / KCM type %s missing in cluster %x\n",
                   __FUNCTION__ , kmem_type_str( type ) , local_cxy );
 
@@ -169 +169 @@
         hal_fence();
 
-        kmem_dmsg("\n[DMSG] %s : exit / KCM type %s created in cluster %x\n",
+        kmem_dmsg("\n[DBG] %s : exit / KCM type %s created in cluster %x\n",
                   __FUNCTION__ , kmem_type_str( type ) , local_cxy );
 
@@ -192 +192 @@
         assert( (type < KMEM_TYPES_NR) , __FUNCTION__ , "illegal KMEM request type" );
 
-        kmem_dmsg("\n[DMSG] %s : enters in cluster %x for type %s\n",
+        kmem_dmsg("\n[DBG] %s : enters in cluster %x for type %s\n",
                       __FUNCTION__ , local_cxy , kmem_type_str( type ) );
 
@@ -210 +210 @@
                 if( flags & AF_ZERO ) page_zero( (page_t *)ptr );
 
-                kmem_dmsg("\n[DMSG] %s : exit in cluster %x for type %s / page = %x / base = %x\n",
+                kmem_dmsg("\n[DBG] %s : exit in cluster %x for type %s / page = %x / base = %x\n",
                           __FUNCTION__, local_cxy , kmem_type_str( type ) ,
                           (intptr_t)ptr , (intptr_t)ppm_page2base( ptr ) );
@@ -228 +228 @@
                 if( flags & AF_ZERO ) memset( ptr , 0 , size );
 
-                kmem_dmsg("\n[DMSG] %s : exit in cluster %x for type %s / base = %x / size = %d\n",
+                kmem_dmsg("\n[DBG] %s : exit in cluster %x for type %s / base = %x / size = %d\n",
                           __FUNCTION__, local_cxy , kmem_type_str( type ) ,
                           (intptr_t)ptr , req->size );
@@ -255 +255 @@
                 if( flags & AF_ZERO ) memset( ptr , 0 , kmem_type_size( type ) );
 
-                kmem_dmsg("\n[DMSG] %s : exit in cluster %x for type %s / base = %x / size = %d\n",
+                kmem_dmsg("\n[DBG] %s : exit in cluster %x for type %s / base = %x / size = %d\n",
                           __FUNCTION__, local_cxy , kmem_type_str( type ) ,
                           (intptr_t)ptr , kmem_type_size( type ) );

trunk/kernel/mm/mapper.c

@@ -143 +143 @@
     error_t       error;
 
-    mapper_dmsg("\n[DMSG] %s : enters for page %d / mapper %x\n",
-                __FUNCTION__ , index , mapper );
+mapper_dmsg("\n[DBG] %s : core[%x,%d] enters for page %d / mapper %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , index , mapper );
 
     thread_t * this = CURRENT_THREAD;
@@ -170 +170 @@
         if ( page == NULL )   // missing page => create it and load it from file system
         {
-            mapper_dmsg("\n[DMSG] %s : missing page => load from device\n", __FUNCTION__ );
+
+mapper_dmsg("\n[DBG] %s : core[%x,%d] missing page => load from device\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
 
             // allocate one page from PPM
@@ -188 +190 @@
             // initialize the page descriptor
             page_init( page );
-            page_set_flag( page , PG_INIT );
-            page_set_flag( page , PG_INLOAD );
+            page_set_flag( page , PG_INIT | PG_INLOAD );
             page_refcount_up( page );
             page->mapper = mapper;
@@ -215 +216 @@
             error = vfs_mapper_move_page( page, 
                                           true );   // to mapper
-
             if( error )
             {
@@ -231 +231 @@
             page_clear_flag( page , PG_INLOAD );
 
+mapper_dmsg("\n[DBG] %s : missing page loaded / ppn = %x\n",
+__FUNCTION__ , ppm_page2ppn(XPTR(local_cxy,page)) );
+
         }
         else if( page_is_flag( page , PG_INLOAD ) )   // page is loaded by another thread
@@ -244 +247 @@
 
                 // deschedule
-                sched_yield( NULL );
+                sched_yield();
             }
         }
@@ -254 +257 @@
     }
 
-    mapper_dmsg("\n[DMSG] %s : exit for page %d / mapper %x / page_desc = %x\n",
-                __FUNCTION__ , index , mapper , page );
+mapper_dmsg("\n[DBG] %s : exit for page %d / mapper %x / page_desc = %x\n",
+__FUNCTION__ , index , mapper , page );
 
     return page;
@@ -310 +313 @@
     uint8_t  * buf_ptr;        // current buffer  address
 
-    mapper_dmsg("\n[DMSG] %s : enters / to_buf = %d / buffer = %x\n",
+    mapper_dmsg("\n[DBG] %s : enters / to_buf = %d / buffer = %x\n",
                 __FUNCTION__ , to_buffer , buffer );
 
@@ -336 +339 @@
         else                       page_count = CONFIG_PPM_PAGE_SIZE;
 
-        mapper_dmsg("\n[DMSG] %s : index = %d / offset = %d / count = %d\n",
+        mapper_dmsg("\n[DBG] %s : index = %d / offset = %d / count = %d\n",
                     __FUNCTION__ , index , page_offset , page_count );
 
@@ -351 +354 @@
         buf_ptr = (uint8_t *)buffer + done;
 
-        mapper_dmsg("\n[DMSG] %s : index = %d / buf_ptr = %x / map_ptr = %x\n",
+        mapper_dmsg("\n[DBG] %s : index = %d / buf_ptr = %x / map_ptr = %x\n",
                     __FUNCTION__ , index , buf_ptr , map_ptr );
 
@@ -368 +371 @@
     }
 
-    mapper_dmsg("\n[DMSG] %s : exit for buffer %x\n",
+    mapper_dmsg("\n[DBG] %s : exit for buffer %x\n",
                 __FUNCTION__, buffer );
 
@@ -397 +400 @@
     uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp );
 
-    mapper_dmsg("\n[DMSG] %s : to_buf = %d / buf_cxy = %x / buf_ptr = %x / size = %x\n",
-    __FUNCTION__ , to_buffer , buffer_cxy , buffer_ptr , size );
+mapper_dmsg("\n[DBG] %s : core[%x,%d] / to_buf = %d / buf_cxy = %x / buf_ptr = %x / size = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, to_buffer, buffer_cxy, buffer_ptr, size );
 
     // compute offsets of first and last bytes in file
@@ -408 +411 @@
     uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
 
-    mapper_dmsg("\n[DMSG] %s : first_page = %d / last_page = %d\n",
-    __FUNCTION__ , first , last );
+mapper_dmsg("\n[DBG] %s : core[%x,%d] / first_page = %d / last_page = %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, first, last );
 
     // compute source and destination clusters
@@ -438 +441 @@
         else                       page_count = CONFIG_PPM_PAGE_SIZE;
 
-        mapper_dmsg("\n[DMSG] %s : page_index = %d / offset = %d / bytes = %d\n",
-                    __FUNCTION__ , index , page_offset , page_count );
+mapper_dmsg("\n[DBG] %s : core[%x;%d] / page_index = %d / offset = %d / bytes = %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, index, page_offset, page_count );
 
         // get page descriptor
@@ -470 +473 @@
     }
 
-    mapper_dmsg("\n[DMSG] %s : exit / buf_cxy = %x / buf_ptr = %x / size = %x\n",
-    __FUNCTION__ , buffer_cxy , buffer_ptr , size );
+mapper_dmsg("\n[DBG] %s : core_cxy[%x,%d] / exit / buf_cxy = %x / buf_ptr = %x / size = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, buffer_cxy, buffer_ptr, size );
 
     return 0;

trunk/kernel/mm/mapper.h

@@ -131 +131 @@
  * @ to_buffer    : mapper -> buffer if true / buffer -> mapper if false.
  * @ file_offset  : first byte to move in file.
- * @ buffer       : user space pointer on user buffer.
+ * @ u_buf        : user space pointer on user buffer.
  * @ size         : number of bytes to move.
  * returns O if success / returns EINVAL if error.
@@ -138 +138 @@
                           bool_t     to_buffer,
                           uint32_t   file_offset,
-                          void     * buffer,
+                          void     * u_buf,
                           uint32_t   size );
 

trunk/kernel/mm/page.c

@@ -46 +46 @@
         page->mapper   = NULL;
         page->index    = 0;
-        page->fork_nr  = 0;
         page->refcount = 0;
 
@@ -181 +180 @@
                 // deschedule the calling thread
                 thread_block( thread , THREAD_BLOCKED_PAGE );
-                sched_yield( NULL );
+                sched_yield();
         }
         else                                    // page is not locked

trunk/kernel/mm/page.h

@@ -67 +67 @@
     xlist_entry_t     wait_root;      /*! root of list of waiting threads      (16) */
         uint32_t          refcount;       /*! reference counter                    (4)  */
-        uint32_t          fork_nr;        /*! number of forked processes           (4)  */
+        uint32_t          reserved;       /*! UNUSED                               (4)  */
         spinlock_t        lock;           /*! only used to set the PG_LOCKED flag  (16) */
 }

trunk/kernel/mm/ppm.c

@@ -154 +154 @@
         page_t   * pages_tbl   = ppm->pages_tbl;
 
-        assert( !page_is_flag( page , PG_FREE ) , __FUNCTION__ , "page already freed" );
-        assert( !page_is_flag( page , PG_RESERVED ) , __FUNCTION__ , "freeing reserved page" );
+        assert( !page_is_flag( page , PG_FREE ) , __FUNCTION__ , 
+    "page already released : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
+
+        assert( !page_is_flag( page , PG_RESERVED ) , __FUNCTION__ , 
+    "reserved page : ppn = %x\n" , ppm_page2ppn(XPTR(local_cxy,page)) );
 
         // update released page descriptor flags
@@ -201 +204 @@
         ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
 
-        assert( (order < CONFIG_PPM_MAX_ORDER) , __FUNCTION__ , "illegal order argument" );
+        assert( (order < CONFIG_PPM_MAX_ORDER) , __FUNCTION__ ,
+    "illegal order argument = %x\n" , order );
 
         page_t * block = NULL;  
 
-        ppm_dmsg("\n[DMSG] %s : enters / order = %d\n",
+        ppm_dmsg("\n[DBG] %s : enters / order = %d\n",
                  __FUNCTION__ , order );
 
@@ -256 +260 @@
         spinlock_unlock( &ppm->free_lock );
 
-        ppm_dmsg("\n[DMSG] %s : base = %x / order = %d\n",
+        ppm_dmsg("\n[DBG] %s : base = %x / order = %d\n",
                  __FUNCTION__ , (uint32_t)ppm_page2base( block ) , order );
 
@@ -289 +293 @@
 
         printk("\n***  PPM in cluster %x : %d pages / &pages_tbl = %x / vaddr_base = %x ***\n",
-               local_cxy , ppm->pages_nr , (intptr_t)ppm->pages_tbl , (intptr_t)ppm->vaddr_base );
+    local_cxy , ppm->pages_nr , (intptr_t)ppm->pages_tbl , (intptr_t)ppm->vaddr_base );
 
         for( order = 0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )
@@ -316 +320 @@
         page_t       * page;
 
-        for(order=0; order < CONFIG_PPM_MAX_ORDER; order++)
+        for( order=0 ; order < CONFIG_PPM_MAX_ORDER ; order++ )
         {
                 if( list_is_empty( &ppm->free_pages_root[order] ) ) continue;

trunk/kernel/mm/ppm.h

@@ -127 +127 @@
 
 /*****************************************************************************************
- * Get extended pointer on page base from Global PPN.
+ * Get extended pointer on page base from global PPN.
  *****************************************************************************************
  * @ ppn    : global physical page number.

trunk/kernel/mm/vmm.c

@@ -58 +58 @@
     vseg_t  * vseg_args;
     vseg_t  * vseg_envs;
-    vseg_t  * vseg_heap;
     intptr_t  base;
     intptr_t  size;
 
-    vmm_dmsg("\n[DMSG] %s : enter for process %x\n", __FUNCTION__ , process->pid );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n", 
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
 
     // get pointer on VMM
     vmm_t   * vmm = &process->vmm;
+
+    // initialize local list of vsegs 
+    vmm->vsegs_nr = 0;
+        list_root_init( &vmm->vsegs_root );
+        rwlock_init( &vmm->vsegs_lock );
 
     assert( ((CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE) 
@@ -77 +82 @@
              "STACK zone too small\n");
 
-    // initialize the rwlock protecting the vsegs list
-        rwlock_init( &vmm->vsegs_lock );
-
-    // initialize local list of vsegs and radix-tree
-    vmm->vsegs_nr = 0;
-        list_root_init( &vmm->vsegs_root );
-
     // register kentry vseg in VMM
     base = CONFIG_VMM_KENTRY_BASE << CONFIG_PPM_PAGE_SHIFT;
     size = CONFIG_VMM_KENTRY_SIZE << CONFIG_PPM_PAGE_SHIFT;
 
-    vseg_kentry = vmm_create_vseg( process , base , size , VSEG_TYPE_CODE );
+    vseg_kentry = vmm_create_vseg( process,
+                                   VSEG_TYPE_CODE,
+                                   base,
+                                   size,
+                                   0,             // file_offset unused
+                                   0,             // file_size unused
+                                   XPTR_NULL,     // mapper_xp unused
+                                   local_cxy );
 
     assert( (vseg_kentry != NULL) , __FUNCTION__ , "cannot register kentry vseg\n" );
@@ -99 +104 @@
     size = CONFIG_VMM_ARGS_SIZE << CONFIG_PPM_PAGE_SHIFT;
 
-    vseg_args = vmm_create_vseg( process , base , size , VSEG_TYPE_DATA );
-
-    assert( (vseg_args != NULL) , __FUNCTION__ , "cannot register args vseg\n" );
+    vseg_args = vmm_create_vseg( process,
+                                 VSEG_TYPE_DATA,
+                                 base,
+                                 size,
+                                 0,             // file_offset unused
+                                 0,             // file_size unused
+                                 XPTR_NULL,     // mapper_xp unused
+                                 local_cxy );
+
+    assert( (vseg_args != NULL) , __FUNCTION__ , "cannot create args vseg\n" );
 
     vmm->args_vpn_base = base;
@@ -111 +123 @@
     size = CONFIG_VMM_ENVS_SIZE << CONFIG_PPM_PAGE_SHIFT;
 
-    vseg_envs = vmm_create_vseg( process , base , size , VSEG_TYPE_DATA );
-
-    assert( (vseg_envs != NULL) , __FUNCTION__ , "cannot register envs vseg\n" );
+    vseg_envs = vmm_create_vseg( process,
+                                 VSEG_TYPE_DATA,
+                                 base,
+                                 size,
+                                 0,             // file_offset unused
+                                 0,             // file_size unused
+                                 XPTR_NULL,     // mapper_xp unused
+                                 local_cxy );
+
+    assert( (vseg_envs != NULL) , __FUNCTION__ , "cannot create envs vseg\n" );
 
     vmm->envs_vpn_base = base;
-
-    // register the heap vseg in VMM
-    base = CONFIG_VMM_HEAP_BASE << CONFIG_PPM_PAGE_SHIFT;
-    size = (CONFIG_VMM_MMAP_BASE-CONFIG_VMM_HEAP_BASE) << CONFIG_PPM_PAGE_SHIFT;
-
-    vseg_heap = vmm_create_vseg( process , base , size , VSEG_TYPE_HEAP );
-
-    assert( (vseg_heap != NULL) , __FUNCTION__ , "cannot register heap vseg\n" );
-
-    vmm->heap_vpn_base = base;
 
     // initialize generic page table
@@ -137 +146 @@
 
     // initialize MMAP allocator
-    vmm->mmap_mgr.vpn_base        = CONFIG_VMM_MMAP_BASE;
-    vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_MMAP_BASE;
-    vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_MMAP_BASE;
+    vmm->mmap_mgr.vpn_base        = CONFIG_VMM_HEAP_BASE;
+    vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
+    vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
     uint32_t i;
     for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
@@ -150 +159 @@
     hal_fence();
 
-    vmm_dmsg("\n[DMSG] %s : exit for process %x / entry_point = %x\n",
-    __FUNCTION__ , process->pid , process->vmm.entry_point );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x / entry_point = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , 
+process->pid , process->vmm.entry_point );
 
 }  // end vmm_init()
+
+//////////////////////////////////////
+void vmm_display( process_t * process,
+                  bool_t      mapping )
+{
+    vmm_t * vmm = &process->vmm;
+    gpt_t * gpt = &vmm->gpt;
+
+    printk("\n***** VSL and GPT for process %x\n\n", 
+    process->pid );
+
+    // get lock protecting the vseg list
+    rwlock_rd_lock( &vmm->vsegs_lock );
+
+    // scan the list of vsegs
+    list_entry_t * iter;
+    vseg_t       * vseg;
+    LIST_FOREACH( &vmm->vsegs_root , iter )
+    {
+        vseg = LIST_ELEMENT( iter , vseg_t , list );
+        printk(" - %s : base = %X / size = %X / npages = %d\n",
+        vseg_type_str( vseg->type ) , vseg->min , vseg->max - vseg->min , vseg->vpn_size );
+
+        if( mapping )
+        {
+            vpn_t    vpn;
+            ppn_t    ppn;
+            uint32_t attr;
+            vpn_t    base = vseg->vpn_base;
+            vpn_t    size = vseg->vpn_size;
+            for( vpn = base ; vpn < (base+size) ; vpn++ )
+            {
+                hal_gpt_get_pte( gpt , vpn , &attr , &ppn );
+                if( attr & GPT_MAPPED )
+                {
+                    printk("    . vpn = %X / attr = %X / ppn = %X\n", vpn , attr , ppn );
+                }
+            }
+        }
+    }
+
+    // release the lock
+    rwlock_rd_unlock( &vmm->vsegs_lock );
+}
 
 //////////////////////////////////////////
@@ -170 +224 @@
     rwlock_init( &dst_vmm->vsegs_lock );
 
-    // initialize the dst_vmm vsegs list and the radix tree
+    // initialize the dst_vmm vsegs list
     dst_vmm->vsegs_nr = 0;
     list_root_init( &dst_vmm->vsegs_root );
 
-    // loop on src_vmm list of vsegs to create
-    // and register vsegs copies in dst_vmm
+    // initialize generic page table
+    error = hal_gpt_create( &dst_vmm->gpt );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
+        return ENOMEM;
+    }
+
+    // loop on SRC VSL to register vsegs copies in DST VSL
+    // and copy valid PTEs from SRC GPT to DST GPT
     list_entry_t * iter;
     vseg_t       * src_vseg;
@@ -201 +264 @@
         vseg_init_from_ref( dst_vseg , XPTR( local_cxy , src_vseg ) );
 
-        // register dst_vseg in dst_vmm
+        // register dst_vseg in DST VSL
         vseg_attach( dst_vmm , dst_vseg );
+
+        // copy SRC GPT to DST GPT / set COW for all writable vsegs, but the FILE type
+        bool_t cow = (src_vseg->type != VSEG_TYPE_FILE) && (src_vseg->flags & VSEG_WRITE); 
+        error = hal_gpt_copy( &dst_vmm->gpt, 
+                              &src_vmm->gpt,
+                              src_vseg->vpn_base,
+                              src_vseg->vpn_size,
+                              cow );
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot copy page GPT\n", __FUNCTION__ );
+            hal_gpt_destroy( &dst_vmm->gpt );
+            return ENOMEM;
+        }
     }
 
     // release the src_vmm vsegs_lock
     rwlock_wr_unlock( &src_vmm->vsegs_lock );
-
-    // initialize generic page table
-    error = hal_gpt_create( &dst_vmm->gpt );
-
-    if( error )
-    {
-        printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
-        return ENOMEM;
-    }
 
     // initialize STACK allocator
@@ -222 +290 @@
 
     // initialize MMAP allocator
-    dst_vmm->mmap_mgr.vpn_base        = CONFIG_VMM_MMAP_BASE;
-    dst_vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_MMAP_BASE;
-    dst_vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_MMAP_BASE;
+    dst_vmm->mmap_mgr.vpn_base        = CONFIG_VMM_HEAP_BASE;
+    dst_vmm->mmap_mgr.vpn_size        = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
+    dst_vmm->mmap_mgr.first_free_vpn  = CONFIG_VMM_HEAP_BASE;
     uint32_t i;
     for( i = 0 ; i < 32 ; i++ ) list_root_init( &dst_vmm->mmap_mgr.zombi_list[i] );
@@ -242 +310 @@
 
     dst_vmm->entry_point   = src_vmm->entry_point;
-
-    // HEAP TODO : new heap for child ???
-    dst_vmm->heap_vseg     = src_vmm->heap_vseg;
-
-    // initialize generic page table
-    error = hal_gpt_create( &dst_vmm->gpt );
-
-    if( error )
-    {
-        printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
-        return ENOMEM;
-    }
-
-    // copy GPT content from src_vmm to dst_vmm, activating "Copy-On-Write"
-    // TODO register Copy-On_Write in page descriptors
-    bool_t cow = true;
-    hal_gpt_copy( &dst_vmm->gpt , &src_vmm->gpt , cow );
 
     hal_fence();
@@ -431 +482 @@
 }  // end vmm_mmap_alloc()
 
-//////////////////////////////////////////////
-vseg_t * vmm_create_vseg( process_t * process,
-                          intptr_t    base,
-                              intptr_t    size,
-                              uint32_t    type )
+////////////////////////////////////////////////
+vseg_t * vmm_create_vseg( process_t   * process,
+                              vseg_type_t   type,
+                          intptr_t      base,
+                              uint32_t      size,
+                          uint32_t      file_offset,
+                          uint32_t      file_size,
+                          xptr_t        mapper_xp,
+                          cxy_t         cxy )
 {
     vseg_t     * vseg;          // created vseg pointer
@@ -442 +497 @@
         error_t      error;
 
-    // get pointer on VMM
-        vmm_t * vmm = &process->vmm;
-
-        vmm_dmsg("\n[DMSG] %s : enter for process %x / base = %x / size = %x / type = %s\n",
-                     __FUNCTION__ , process->pid , base , size , vseg_type_str(type) );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enters / process %x / base %x / size %x / %s / cxy = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
+process->pid , base , size , vseg_type_str(type) , cxy );
+
+    // get pointer on VMM 
+        vmm_t * vmm    = &process->vmm;
 
     // compute base, size, vpn_base, vpn_size, depending on vseg type
-    // we use the VMM specific allocators for STACK and MMAP vsegs
+    // we use the VMM specific allocators for "stack", "file", "anon", & "remote" vsegs
     if( type == VSEG_TYPE_STACK )
     {
@@ -456 +512 @@
         if( error )
         {
-            printk("\n[ERROR] in %s : no vspace for stack vseg / process %x in cluster %x\n",
-                   __FUNCTION__ , process->pid , local_cxy );
+            printk("\n[ERROR] in %s : no space for stack vseg / process %x in cluster %x\n",
+            __FUNCTION__ , process->pid , local_cxy );
             return NULL;
         }
@@ -498 +554 @@
         printk("\n[ERROR] in %s for process %x : new vseg [vpn_base = %x / vpn_size = %x]\n"
                "  overlap existing vseg [vpn_base = %x / vpn_size = %x]\n",
-               __FUNCTION__ , process->pid, vpn_base, vpn_size,
-               vseg->vpn_base, vseg->vpn_size );
+        __FUNCTION__ , process->pid, vpn_base, vpn_size, vseg->vpn_base, vseg->vpn_size );
         return NULL;
     }
@@ -508 +563 @@
         {
             printk("\n[ERROR] in %s for process %x : cannot allocate memory for vseg\n",
-             __FUNCTION__ , process->pid );
+        __FUNCTION__ , process->pid );
         return NULL;
         }
 
     // initialize vseg descriptor
-        vseg_init( vseg , base, size , vpn_base , vpn_size , type , local_cxy );
-
-    // update "heap_vseg" in VMM
-        if( type == VSEG_TYPE_HEAP ) process->vmm.heap_vseg = vseg;
+        vseg_init( vseg,
+               type,
+               base,
+               size,
+               vpn_base,
+               vpn_size,
+               file_offset,
+               file_size,
+               mapper_xp,
+               cxy );
 
     // attach vseg to vmm
@@ -523 +584 @@
         rwlock_wr_unlock( &vmm->vsegs_lock );
 
-        vmm_dmsg("\n[DMSG] %s : exit for process %x / vseg [%x, %x] registered\n",
-                     __FUNCTION__ , process->pid , vseg->min , vseg->max );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / base %x / size %x / type %s\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
+process->pid , base , size , vseg_type_str(type) );
 
         return vseg;
@@ -579 +641 @@
         vseg_free( vseg );
     }
-}
+}  // end vmm_remove_vseg()
 
 //////////////////////////////////////////////
@@ -655 +717 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
 // This low-level static function is called by the vmm_get_vseg() and vmm_resize_vseg()
 // functions.  It scan the list of registered vsegs to find the unique vseg containing
 // a given virtual address.
-///////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
 // @ vmm     : pointer on the process VMM.
 // @ vaddr   : virtual address.
 // @ return vseg pointer if success / return NULL if not found.
-///////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
 static vseg_t * vseg_from_vaddr( vmm_t    * vmm,
                                  intptr_t   vaddr )
@@ -755 +817 @@
 
         // create new vseg
-        new = vmm_create_vseg( process , addr_min , (vseg->max - addr_max) , vseg->type ); 
+        new = vmm_create_vseg( process, 
+                               vseg->type,
+                               addr_min, 
+                               (vseg->max - addr_max),
+                               vseg->file_offset,
+                               vseg->file_size,
+                               vseg->mapper_xp,
+                               vseg->cxy ); 
+
         if( new == NULL ) error = EINVAL;
         else              error = 0;
@@ -814 +884 @@
 }  // end vmm_get_vseg()
 
+//////////////////////////////////////////////////////////////////////////////////////
+// This static function compute the target cluster to allocate a physical page
+// for a given <vpn> in a given <vseg>, allocates the page (with an RPC if required)
+// and returns an extended pointer on the allocated page descriptor.
+// The vseg cannot have the FILE type.
+//////////////////////////////////////////////////////////////////////////////////////
+static xptr_t vmm_page_allocate( vseg_t * vseg,
+                                 vpn_t    vpn )
+{
+    // compute target cluster
+    page_t     * page_ptr;
+    cxy_t        page_cxy;
+    kmem_req_t   req;
+
+    uint32_t     type  = vseg->type;
+    uint32_t     flags = vseg->flags;
+
+    assert( ( type != VSEG_TYPE_FILE ) , __FUNCTION__ , "illegal vseg type\n" );
+
+    if( flags & VSEG_DISTRIB )    // distributed => cxy depends on vpn LSB
+    {
+        uint32_t x_size  = LOCAL_CLUSTER->x_size;
+        uint32_t y_size  = LOCAL_CLUSTER->y_size;
+        uint32_t y_width = LOCAL_CLUSTER->y_width;
+        uint32_t index   = vpn & ((x_size * y_size) - 1);
+        uint32_t x       = index / y_size;
+        uint32_t y       = index % y_size;
+        page_cxy         = (x<<y_width) + y;
+    }
+    else                          // other cases => cxy specified in vseg
+    {
+        page_cxy         = vseg->cxy;
+    }
+
+    // allocate a physical page from target cluster
+    if( page_cxy == local_cxy )  // target cluster is the local cluster
+    {
+        req.type  = KMEM_PAGE;
+        req.size  = 0;
+        req.flags = AF_NONE;
+        page_ptr  = (page_t *)kmem_alloc( &req );
+    }
+    else                           // target cluster is not the local cluster
+    {
+        rpc_pmem_get_pages_client( page_cxy , 0 , &page_ptr );
+    }
+
+    if( page_ptr == NULL ) return XPTR_NULL;
+    else                   return XPTR( page_cxy , page_ptr );
+
+}  // end vmm_page_allocate()  
+
 ////////////////////////////////////////
 error_t vmm_get_one_ppn( vseg_t * vseg,
@@ -820 +942 @@
 {
     error_t    error;
-    cxy_t      page_cxy;          // physical page cluster
+    xptr_t     page_xp;           // extended pointer on physical page descriptor
     page_t   * page_ptr;          // local pointer on physical page descriptor
     uint32_t   index;             // missing page index in vseg mapper
@@ -828 +950 @@
     index     = vpn - vseg->vpn_base;
 
-    vmm_dmsg("\n[DMSG] %s : core[%x,%d] enter for vpn = %x / type = %s / index = %d\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, vseg_type_str(type), index );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x / type = %s / index = %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, vseg_type_str(type), index );
 
     // FILE type : get the physical page from the file mapper
@@ -835 +957 @@
     {
         // get extended pointer on mapper
-        xptr_t     mapper_xp = vseg->mapper_xp;
+        xptr_t mapper_xp = vseg->mapper_xp;
 
         assert( (mapper_xp != XPTR_NULL), __FUNCTION__,
@@ -856 +978 @@
         if ( page_ptr == NULL ) return EINVAL;
 
-        page_cxy = mapper_cxy;
+        page_xp = XPTR( mapper_cxy , page_ptr );
     }
 
     // Other types : allocate a physical page from target cluster,
+    // as defined by vseg type and vpn value
     else
     {
-        uint32_t flags = vseg->flags;
-
-        // get target cluster for physical page
-        if( flags & VSEG_DISTRIB ) // depends on VPN LSB
-        {
-            uint32_t x_size = LOCAL_CLUSTER->x_size;
-            uint32_t y_size = LOCAL_CLUSTER->y_size;
-            page_cxy = vpn & ((x_size * y_size) - 1);
-        }
-        else                       // defined in vseg descriptor
-        {
-            page_cxy = vseg->cxy;
-        }
-
-        // allocate a physical page in target cluster
-        kmem_req_t   req;
-        if( page_cxy == local_cxy )  // target cluster is the local cluster
-        {
-            req.type  = KMEM_PAGE;
-            req.size  = 0;
-            req.flags = AF_NONE;
-            page_ptr  = (page_t *)kmem_alloc( &req );
-        }
-        else                           // target cluster is not the local cluster
-        {
-            rpc_pmem_get_pages_client( page_cxy , 0 , &page_ptr );
-        }
-
-        if( page_ptr == NULL ) return ENOMEM;
+        // allocate physical page 
+        page_xp = vmm_page_allocate( vseg , vpn );
+
+        if( page_xp == XPTR_NULL ) return ENOMEM;
 
         // initialise missing page from .elf file mapper for DATA and CODE types
@@ -912 +1010 @@
             uint32_t elf_offset = vseg->file_offset + offset;
 
-            vmm_dmsg("\n[DMSG] %s : core[%x,%d] for vpn = %x / elf_offset = %x\n",
-            __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, elf_offset );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / elf_offset = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, elf_offset );
 
             // compute extended pointer on page base 
-            xptr_t base_xp  = ppm_page2base( XPTR( page_cxy , page_ptr ) );
+            xptr_t base_xp  = ppm_page2base( page_xp );
 
             // file_size (in .elf mapper) can be smaller than vseg_size (BSS)
@@ -923 +1021 @@
             if( file_size < offset )                 // missing page fully in  BSS 
             {
-                vmm_dmsg("\n[DMSG] %s : core[%x,%d] for vpn = %x / fully in BSS\n",
-                __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
-
-                if( page_cxy == local_cxy )
+vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in BSS\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
+
+                if( GET_CXY( page_xp ) == local_cxy )
                 {
                     memset( GET_PTR( base_xp ) , 0 , CONFIG_PPM_PAGE_SIZE );
@@ -937 +1035 @@
             else if( file_size >= (offset + CONFIG_PPM_PAGE_SIZE) )  // fully in  mapper
             {
-                vmm_dmsg("\n[DMSG] %s : core[%x,%d] for vpn = %x / fully in mapper\n",
-                __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in mapper\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
 
                 if( mapper_cxy == local_cxy ) 
@@ -965 +1064 @@
                   // - (page_size + offset - file_size) bytes from BSS
             {
-                vmm_dmsg("\n[DMSG] %s : core[%x,%d] for vpn = %x / both mapper & BSS\n"
-                         "      %d bytes from mapper / %d bytes from BSS\n",
-                __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn,
-                file_size - offset , offset + CONFIG_PPM_PAGE_SIZE - file_size  );
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / both mapper & BSS\n"
+         "      %d bytes from mapper / %d bytes from BSS\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn,
+file_size - offset , offset + CONFIG_PPM_PAGE_SIZE - file_size  );
 
                 // initialize mapper part
@@ -993 +1093 @@
 
                 // initialize BSS part
-                if( page_cxy == local_cxy )
+                if( GET_CXY( page_xp ) == local_cxy )
                 {
                     memset( GET_PTR( base_xp ) + file_size - offset , 0 , 
@@ -1008 +1108 @@
 
     // return ppn
-    *ppn = ppm_page2ppn( XPTR( page_cxy , page_ptr ) );
-
-    vmm_dmsg("\n[DMSG] %s : core[%x,%d] exit for vpn = %x / ppn = %x\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , *ppn );
+    *ppn = ppm_page2ppn( page_xp );
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for vpn = %x / ppn = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , *ppn );
 
     return 0;
@@ -1020 +1120 @@
 error_t vmm_get_pte( process_t * process,
                      vpn_t       vpn,
-                     uint32_t  * ret_attr,
-                     ppn_t     * ret_ppn )
-{
-    vseg_t  * vseg;   // pointer on vseg containing VPN
-    ppn_t     ppn;    // physical page number
-    uint32_t  attr;   // attributes from GPT entry
+                     bool_t      cow,
+                     uint32_t  * attr,
+                     ppn_t     * ppn )
+{
+    vseg_t  * vseg;       // pointer on vseg containing VPN
+    ppn_t     old_ppn;    // current PTE_PPN
+    uint32_t  old_attr;   // current PTE_ATTR
+    ppn_t     new_ppn;    // new PTE_PPN
+    uint32_t  new_attr;   // new PTE_ATTR
+    xptr_t    page_xp;    // extended pointer on allocated page descriptor
     error_t   error;
 
@@ -1032 +1136 @@
     "not called in the reference cluster\n" );
 
-    vmm_dmsg("\n[DMSG] %s : core[%x,%d] enter for vpn = %x in process %x\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid );
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x in process %x / cow = %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid , %d);
 
     // get VMM pointer
     vmm_t * vmm = &process->vmm;
 
-    // access GPT to get PTE attributes and PPN
-    hal_gpt_get_pte( &vmm->gpt , vpn , &attr , &ppn );
-
-    // if PTE is unmapped
-    // 1) get VSEG containing the missing VPN
-    // 2) get & initialize physical page (depending on vseg type),
-    // 3) register the PTE in reference GPT 
-    if( (attr & GPT_MAPPED) == 0 )
-    {
-        vmm_dmsg("\n[DMSG] %s : core[%x,%d] page %x unmapped => try to map it\n",
-        __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
-
-        // 1. get vseg pointer
-        error = vmm_get_vseg( process , vpn<<CONFIG_PPM_PAGE_SHIFT , &vseg );
+    // get vseg pointer from ref VSL
+    error = vmm_get_vseg( process , vpn<<CONFIG_PPM_PAGE_SHIFT , &vseg );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : out of segment / process = %x / vpn = %x\n",
+        __FUNCTION__ , process->pid , vpn );
+        return error;
+    }
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] found vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
+vseg_type_str(vseg->type) , vseg->vpn_base , vseg->vpn_size );
+
+    // access GPT to get current PTE attributes and PPN
+    hal_gpt_get_pte( &vmm->gpt , vpn , &old_attr , &old_ppn );
+
+    // for both copy_on_write and page_fault events, we allocate a physical page,
+    // initialize it, register it in the GPT, and return the new_ppn and new_attr
+
+    if( cow )               ////////////// copy_on_write request ///////////
+    {
+        assert( (*attr & GPT_MAPPED) , __FUNCTION__ , 
+        "PTE must be mapped for a copy-on-write\n" );
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] page %x must be copied => do it\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+
+        // allocate a physical page depending on vseg type
+        page_xp = vmm_page_allocate( vseg , vpn );
+
+        if( page_xp == XPTR_NULL ) 
+        {
+            printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
+            __FUNCTION__ , process->pid , vpn );
+            return ENOMEM;
+        }
+
+        // compute allocated page PPN
+        new_ppn = ppm_page2ppn( page_xp );
+
+        // copy old page content to new page
+        xptr_t  old_base_xp = ppm_ppn2base( old_ppn );
+        xptr_t  new_base_xp = ppm_ppn2base( new_ppn );
+        memcpy( GET_PTR( new_base_xp ),
+                GET_PTR( old_base_xp ),
+                CONFIG_PPM_PAGE_SIZE );
+
+        // update attributes: reset COW and set WRITABLE
+        new_attr = old_attr & ~GPT_COW;  
+        new_attr = new_attr | GPT_WRITABLE;
+
+        // register PTE in GPT
+        error = hal_gpt_set_pte( &vmm->gpt , vpn , new_ppn , new_attr );
 
         if( error )
         {
-            printk("\n[ERROR] in %s : out of segment / process = %x / vpn = %x\n",
-                   __FUNCTION__ , process->pid , vpn );
+            printk("\n[ERROR] in %s : cannot update GPT / process = %x / vpn = %x\n",
+            __FUNCTION__ , process->pid , vpn );
             return error;
         }
-
-        vmm_dmsg("\n[DMSG] %s : core[%x,%d] found vseg %s / vpn_base = %x / vpn_size = %x\n",
-        __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
-        vseg_type_str(vseg->type) , vseg->vpn_base , vseg->vpn_size );
-
-        // 2. get physical page number, depending on vseg type
-        error = vmm_get_one_ppn( vseg , vpn , &ppn );
-
-        if( error )
+    }
+    else                    //////////////////// page_fault request ///////////
+    {  
+        if( (old_attr & GPT_MAPPED) == 0 )    // PTE unmapped in ref GPT
         {
-            printk("\n[ERROR] in %s : cannot allocate memory / process = %x / vpn = %x\n",
-                   __FUNCTION__ , process->pid , vpn );
-            return error;
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] page %x unmapped => try to map it\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+
+            // allocate one physical page, depending on vseg type
+            error = vmm_get_one_ppn( vseg , vpn , &new_ppn );
+
+            if( error )
+            {
+                printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
+                __FUNCTION__ , process->pid , vpn );
+                return error;
+            }
+
+            // define attributes from vseg flags 
+            new_attr = GPT_MAPPED | GPT_SMALL;
+            if( vseg->flags & VSEG_USER  ) new_attr |= GPT_USER;
+            if( vseg->flags & VSEG_WRITE ) new_attr |= GPT_WRITABLE;
+            if( vseg->flags & VSEG_EXEC  ) new_attr |= GPT_EXECUTABLE;
+            if( vseg->flags & VSEG_CACHE ) new_attr |= GPT_CACHABLE;
+
+            // register PTE in GPT
+            error = hal_gpt_set_pte( &vmm->gpt , vpn , new_ppn , new_attr );
+
+            if( error )
+            {
+                printk("\n[ERROR] in %s : cannot update GPT / process = %x / vpn = %x\n",
+                __FUNCTION__ , process->pid , vpn );
+                return error;
+            }
         }
-
-        // 3. define attributes from vseg flags and register in GPT
-        attr = GPT_MAPPED | GPT_SMALL;
-        if( vseg->flags & VSEG_USER  ) attr |= GPT_USER;
-        if( vseg->flags & VSEG_WRITE ) attr |= GPT_WRITABLE;
-        if( vseg->flags & VSEG_EXEC  ) attr |= GPT_EXECUTABLE;
-        if( vseg->flags & VSEG_CACHE ) attr |= GPT_CACHABLE;
-
-        error = hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
-
-        if( error )
+        else
         {
-            printk("\n[ERROR] in %s : cannot register PTE / process = %x / vpn = %x\n",
-                   __FUNCTION__ , process->pid , vpn );
-            return error;
+            new_attr = old_attr;
+            new_ppn  = old_ppn;
         }
-    }  // end new PTE
-
-    vmm_dmsg("\n[DMSG] %s : core[%x,%d] exit for vpn = %x / ppn = %x\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , ppn );
-
-    *ret_ppn  = ppn;
-    *ret_attr = attr;
+    }
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for vpn = %x / ppn = %x / attr = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , new_ppn , new_attr );
+
+    *ppn  = new_ppn;
+    *attr = new_attr;
     return 0;
 
@@ -1106 +1261 @@
     uint32_t         attr;          // missing page attributes
     ppn_t            ppn;           // missing page PPN
-    error_t          error;         // return value
+    error_t          error;
 
     // get reference process cluster and local pointer
@@ -1113 +1268 @@
 
     // get missing PTE attributes and PPN from reference cluster
-    if( local_cxy != ref_cxy )   // local cluster is not the reference cluster
-    {
-        rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , &attr , &ppn , &error );
-    }
-    else                              // local cluster is the reference cluster
-    {
-        error = vmm_get_pte( process , vpn , &attr , &ppn );
+    if( local_cxy != ref_cxy )  
+    {
+        rpc_vmm_get_pte_client( ref_cxy,
+                                ref_ptr,
+                                vpn,
+                                false,    // page_fault
+                                &attr,
+                                &ppn,
+                                &error );
+
+        // get local VMM pointer
+        vmm_t * vmm = &process->vmm;
+
+        // update local GPT
+        error |= hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
+    }
+    else   // local cluster is the reference cluster
+    {
+        error = vmm_get_pte( process,
+                             vpn,
+                             false,      // page-fault
+                             &attr,
+                             &ppn );
     }
 
@@ -1126 +1297 @@
 }  // end vmm_handle_page_fault()
 
+///////////////////////////////////////////////
+error_t vmm_copy_on_write( process_t * process,
+                           vpn_t       vpn )
+{
+    uint32_t         attr;          // missing page attributes
+    ppn_t            ppn;           // missing page PPN
+    error_t          error;
+
+    // get reference process cluster and local pointer
+    cxy_t       ref_cxy = GET_CXY( process->ref_xp );
+    process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
+
+    // get new PTE attributes and PPN from reference cluster
+    if( local_cxy != ref_cxy )
+    {
+        rpc_vmm_get_pte_client( ref_cxy,
+                                ref_ptr,
+                                vpn,
+                                true,     // copy-on-write
+                                &attr,
+                                &ppn,
+                                &error );
+
+        // get local VMM pointer
+        vmm_t * vmm = &process->vmm;
+
+        // update local GPT
+        error |= hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
+    }
+    else   // local cluster is the reference cluster
+    {
+        error = vmm_get_pte( process,
+                             vpn,
+                             true,      // copy-on-write
+                             &attr,
+                             &ppn );
+    }
+
+    return error;
+
+}  // end vmm_copy_on_write()
 
 ///////////////////////////////////////////
@@ -1152 +1364 @@
     if( local_cxy == GET_CXY( process->ref_xp) ) // calling process is reference process
     {
-        error = vmm_get_pte( process, vpn , &attr , &ppn );
+        error = vmm_get_pte( process, vpn , false , &attr , &ppn );
     }
     else                                         // calling process is not reference process
@@ -1158 +1370 @@
         cxy_t       ref_cxy = GET_CXY( process->ref_xp );
         process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
-        rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , &attr , &ppn , &error );
+        rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , false , &attr , &ppn , &error );
     }
 

trunk/kernel/mm/vmm.h

@@ -40 +40 @@
 
 /*********************************************************************************************
- * This structure defines the STACK allocator used by the VMM to dynamically allocate
- * STACK vsegs requested or released by the user process.
- * This allocator handles a fixed size array of fixed size slots stores in the STACK zone.
+ * This structure defines the STACK allocator used by the VMM to dynamically handle
+ * a STACK vseg requested or released by an user process.
+ * This allocator handles a fixed size array of fixed size slots in the STACK zone.
  * The stack size and the number of slots are defined by the CONFIG_VMM_STACK_SIZE, and
- * CONFIG_THREAD
+ * CONFIG_VMM_STACK_BASE parameters.
  * Each slot can contain one user stack vseg. The first page in the slot is not allocated
  * to detect stack overflow.
@@ -50 +50 @@
  * All allocation / release operations are registered in the stack_bitmap, that completely
  * define the STACK zone state.
- * In this implementation, the max number of slots is 32.
  ********************************************************************************************/
 
@@ -62 +61 @@
 
 /*********************************************************************************************
- * This structure defines the MMAP allocator used by the VMM to dynamically allocate
+ * This structure defines the MMAP allocator used by the VMM to dynamically handle  
  * MMAP vsegs requested or released by an user process.
  * This allocator should be only used in the reference cluster.
@@ -92 +91 @@
  * This local VMM provides three main services:
  * 1) It registers all vsegs statically or dynamically defined in the vseg list.
- * 2) It allocates virtual memory space for the STACKS and MMAP vsegs.
+ * 2) It allocates virtual memory space for the STACKS and MMAP vsegs (FILE/ANON/REMOTE).
  * 3) It contains the local copy of the generic page table descriptor.
  ********************************************************************************************/
@@ -98 +97 @@
 typedef struct vmm_s
 {
-        rwlock_t       vsegs_lock;         /*! lock protecting the vsegs list & radix tree      */
+        rwlock_t       vsegs_lock;         /*! lock protecting the vsegs list                   */
         list_entry_t   vsegs_root;         /*! all vsegs in same process and same cluster       */
         uint32_t       vsegs_nr;           /*! total number of local vsegs                      */
@@ -107 +106 @@
     mmap_mgr_t     mmap_mgr;           /*! embedded MMAP vsegs allocator                    */
 
-        uint32_t       pgfault_nr;         /*! page fault counter                               */
+        uint32_t       pgfault_nr;         /*! page fault counter (instrumentation)             */
         uint32_t       u_err_nr;           /*! TODO ??? [AG]                                    */
         uint32_t       m_err_nr;           /*! TODO ??? [AG]                                    */
@@ -119 +118 @@
 
         intptr_t       entry_point;        /*! main thread entry point                          */
-
-    vseg_t       * heap_vseg;          /*! pointer on local heap vseg descriptor            */
 }
 vmm_t;
 
 /*********************************************************************************************
- * This structure is used to store the arguments of the mmap() system call.
- ********************************************************************************************/
-
-typedef struct mmap_attr_s
-{
-        void     * addr;            /*! requested virtual address (unused : should be NULL)     */
-        uint32_t   length;          /*! requested vseg size (bytes)                             */
-        uint32_t   prot;            /*! access modes                                            */
-        uint32_t   flags;           /*! only MAP_FILE / MAP_ANON / MAP_PRIVATE / MAP_SHARED     */
-        fdid_t     fdid;            /*! file descriptor index (if MAP_FILE is set)              */
-        int32_t    offset;          /*! file offset (if MAP_FILE is set)                        */
-}
-mmap_attr_t;
-
-/*********************************************************************************************
  * This function initialises the virtual memory manager attached to an user process.
- * - It registers the "kentry", "args", "envs" and "heap" vsegs in the vsegs list.
- *   The "code" and "data" vsegs are registered by the elf_load_process() function,
- *   the "stack" vsegs are registered by the thread_user_create() function, and the
- *   "mmap" vsegs are dynamically created by syscalls.
+ * - It initializes the STACK and MMAP allocators.
+ * - It registers the "kentry", "args", "envs" vsegs in the VSL.
+ * - 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() syscalls.
  * - 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.
- * - It initializes the STAK and MMAP allocators.
+ * - For TSAR it map all pages for the "kentry" vseg, that must be identity mapping.
  * TODO : Any error in this function gives a kernel panic => improve error handling.
  *********************************************************************************************
@@ -155 +137 @@
 
 /*********************************************************************************************
- * This function copies the content of a source VMM to a destination VMM.
+ * This function displays on TXY0 the list or registered vsegs for a given <process>.
+ * If the <mapping> argument is true, it displays for each vesg all mapped PTEs in GPT.
+ *********************************************************************************************
+ * @ process   : pointer on process descriptor.
+ * @ mapping   : detailed mapping if true.
+ ********************************************************************************************/
+void vmm_display( struct process_s * process,
+                  bool_t             mapping );
+
+/*********************************************************************************************
+ * This function is called by the sys_fork() system call.
+ * It copies the content of a parent process descriptor VMM to a child process VMM.
+ * - All vsegs registered in the source VSL are copied in the destination VSL. 
+ * - All PTEs registered in the source GPT are copied in destination GPT. For all writable
+ *   PTEs - but the FILE vsegs - the WRITABLE flag is reset and the COW flag is set in
+ *   the destination GPT. 
  *********************************************************************************************
  * @ dst_process   : pointer on destination process descriptor.
@@ -187 +184 @@
 /*********************************************************************************************
  * This function allocates memory for a vseg descriptor, initialises it, and register it
- * in the VMM of the process. It checks the collision with pre-existing vsegs in VMM.
- * For STACK and MMAP types vseg, it does not use the base argument, but uses the VMM STACK
- * and MMAP specific allocators to get a base address in virtual space.
- * To comply with the "on-demand" paging policy, this function does NOT modify the
- * page table, and does not allocate physical memory for vseg data.
- *********************************************************************************************
- * @ vmm   : pointer on process descriptor.
- * @ base      : vseg base address
- * @ size      : vseg size (bytes)
- * @ type      : vseg type
- * @ returns pointer on vseg if success / returns NULL if no memory or conflict.
+ * in the VMM of the local process descriptor, that should 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.
+ * It checks collision with all pre-existing vsegs.
+ * To comply with the "on-demand" paging policy, this function does NOT modify the page table,
+ * 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).
+ *********************************************************************************************
+ * @ process     : pointer on local processor descriptor.
+ * @ type        : vseg type.
+ * @ base        : vseg base address (not used for dynamically allocated vsegs).
+ * @ size        : vseg size (bytes).
+ * @ file_offset : offset in file for CODE, DATA, FILE types. 
+ * @ file_size   : can be smaller than "size" for DATA type.
+ * @ mapper_xp   : extended pointer on mapper for CODE, DATA, FILE types.
+ * @ cxy         : physical mapping cluster (for non distributed vsegs).
+ * @ returns pointer on vseg if success / returns NULL if no memory, or conflict.
  ********************************************************************************************/
 vseg_t * vmm_create_vseg( struct process_s * process,
+                          vseg_type_t        type,
                           intptr_t           base,
-                              intptr_t           size,
-                              uint32_t           type );
+                              uint32_t           size,
+                          uint32_t           file_offset,
+                          uint32_t           file_size,
+                          xptr_t             mapper_xp,
+                          cxy_t              cxy );
 
 /*********************************************************************************************
@@ -245 +253 @@
 /*********************************************************************************************
  * This function removes a given region (defined by a base address and a size) from
- * the VMM of a given process descriptor. This can modify several vsegs:
+ * the VMM of a given process descriptor. This can modify the number of vsegs:
  * (a) if the region is not entirely mapped in an existing vseg, it's an error.
  * (b) if the region has same base and size as an existing vseg, the vseg is removed.
@@ -251 +259 @@
  * (d) if the removed region cut the vseg in three parts, it is modified, and a new
  *     vseg is created with same type.
+ * FIXME [AG] this function must be called by a thread running in the reference cluster,
+ * and the VMM must be updated in all process descriptors copies. 
  *********************************************************************************************
  * @ process   : pointer on process descriptor
@@ -279 +289 @@
 
 /*********************************************************************************************
- * This function is called by the generic exception handler when a page fault 
+ * This function is called by the generic exception handler when a page-fault event
  * has been detected in a given cluster. 
+ * - If the local cluster is the reference, it call directly the vmm_get_pte() function.
  * - If the local cluster is not the reference cluster, it send a RPC_VMM_GET_PTE
- *   to the reference cluster to get the missing PTE attributes and PPN, and update
- *   the local page table. 
- * - If the local cluster is the reference, it call directly the vmm_get_pte() function.
+ *   to the reference cluster to get the missing PTE attributes and PPN,
+ *   and update the local page table. 
  *********************************************************************************************
  * @ process   : pointer on process descriptor.
@@ -294 +304 @@
 
 /*********************************************************************************************
- * This function returns in the "attr" and "ppn" arguments the PTE associated to a given
- * VPN for a given process. This function must be called by a thread running in the 
- * reference cluster. To get the PTE from another cluster, use the RPC_VMM_GET_PTE.
- * The vseg containing the searched VPN should be registered in the reference VMM.
- * If the PTE in the reference page table is unmapped, this function allocates the missing
- * physical page from the target cluster defined by the vseg type, initialize it,
- * and update the reference page table. It calls the RPC_PMEM_GET_PAGES to get and 
- * initialize the missing physical page, if the target cluster is not the reference cluster.
+ * This function is called by the generic exception handler when a copy-on-write event
+ * has been detected in a given cluster. 
+ * - If the local cluster is the reference, it call directly the vmm_get_pte() function.
+ * - If the local cluster is not the reference cluster, it send a RPC_VMM_GET_PTE
+ *   to the reference cluster to get the missing PTE attributes and PPN,
+ *   and update the local page table. 
+ *********************************************************************************************
+ * @ process   : pointer on process descriptor.
+ * @ vpn       : VPN of the missing PTE.
+ * @ returns 0 if success / returns ENOMEM if no memory.
+ ********************************************************************************************/
+error_t vmm_copy_on_write( struct process_s * process,
+                           vpn_t              vpn );
+
+/*********************************************************************************************
+ * This function is called when a new PTE (GPT entry) is required because a "page-fault",
+ * or "copy-on_write" event has been detected for a given <vpn> in a given <process>. 
+ * The <cow> argument defines the type of event to be handled. 
+ * This function must be called by a thread running in reference cluster, and the vseg
+ * containing the searched VPN should be registered in the reference VMM.
+ * - for an actual page-fault, it allocates the missing physical page from the target cluster
+ *   defined by the vseg type, initialize it, and update the reference page table. 
+ * - for a copy-on-write, it allocates a new physical page from the target cluster,
+ *   initialise it from the old physical page, and update the reference page table. 
+ * In both cases, it calls the RPC_PMEM_GET_PAGES to get the new physical page if the
+ * target cluster is not the reference cluster.
+ * It returns in the <attr> and <ppn> arguments the accessed or modified PTE.
  *********************************************************************************************
  * @ process   : [in] pointer on process descriptor.
  * @ vpn       : [in] VPN defining the missing PTE.
+ * @ cow       : [in] "copy_on_write" if true / "page_fault" if false.
  * @ attr      : [out] PTE attributes.
  * @ ppn       : [out] PTE ppn.
@@ -311 +341 @@
 error_t vmm_get_pte( struct process_s * process,
                      vpn_t              vpn,
+                     bool_t             cow,
                      uint32_t         * attr,
                      ppn_t            * ppn );

trunk/kernel/mm/vseg.c

@@ -52 +52 @@
         if     ( vseg_type == VSEG_TYPE_CODE   ) return "CODE";
         else if( vseg_type == VSEG_TYPE_DATA   ) return "DATA";
-        else if( vseg_type == VSEG_TYPE_HEAP   ) return "HEAP";
-        else if( vseg_type == VSEG_TYPE_STACK  ) return "STACK";
+        else if( vseg_type == VSEG_TYPE_STACK  ) return "STAK";
         else if( vseg_type == VSEG_TYPE_ANON   ) return "ANON";
         else if( vseg_type == VSEG_TYPE_FILE   ) return "FILE";
-        else if( vseg_type == VSEG_TYPE_REMOTE ) return "REMOTE";
-        else if( vseg_type == VSEG_TYPE_KCODE  ) return "KCODE";
-        else if( vseg_type == VSEG_TYPE_KDATA  ) return "KDATA";
-        else if( vseg_type == VSEG_TYPE_KDEV   ) return "KDEV";
+        else if( vseg_type == VSEG_TYPE_REMOTE ) return "REMO";
     else                                     return "undefined";
 }
@@ -87 +83 @@
 ///////////////////////////////////
 void vseg_init( vseg_t      * vseg,
+                vseg_type_t   type,
                     intptr_t      base,
-                intptr_t      size,
+                uint32_t      size,
                 vpn_t         vpn_base,
                 vpn_t         vpn_size,
-                        uint32_t      type,
+                        uint32_t      file_offset,
+                uint32_t      file_size,
+                xptr_t        mapper_xp,
                 cxy_t         cxy )
 {
-    vseg->type      = type;
-        vseg->min       = base;
-        vseg->max       = base + size;
-    vseg->vpn_base  = vpn_base;
-        vseg->vpn_size  = vpn_size;
-        vseg->mapper_xp = XPTR_NULL;
-    vseg->cxy       = cxy;
+    vseg->type        = type;
+        vseg->min         = base;
+        vseg->max         = base + size;
+    vseg->vpn_base    = vpn_base;
+        vseg->vpn_size    = vpn_size;
+    vseg->file_offset = file_offset;
+    vseg->file_size   = file_size;
+        vseg->mapper_xp   = mapper_xp;
+    vseg->cxy         = cxy;
 
     // set vseg flags depending on type
@@ -124 +125 @@
                       VSEG_DISTRIB ;
     }
-    else if( type == VSEG_TYPE_HEAP )
-    {
-        vseg->flags = VSEG_USER    |
-                      VSEG_WRITE   |
-                      VSEG_CACHE   |
-                      VSEG_DISTRIB ;
-    }
     else if( type == VSEG_TYPE_REMOTE )
     {
@@ -141 +135 @@
         vseg->flags = VSEG_USER    |
                       VSEG_WRITE   |
-                      VSEG_CACHE   |
-                      VSEG_DISTRIB ;
+                      VSEG_CACHE; 
     }
     else if( type == VSEG_TYPE_FILE )
@@ -161 +154 @@
                       VSEG_CACHE   |
                       VSEG_PRIVATE ;
+    }
+    else if( type == VSEG_TYPE_KDEV )
+    {
+        vseg->flags = VSEG_WRITE   ;
     }
     else
@@ -171 +168 @@
 //////////////////////////////////////////
 void vseg_init_from_ref( vseg_t    * vseg,
-                         xptr_t      ref )
+                         xptr_t      ref_xp )
 {
     // get remote vseg cluster and pointer
-    cxy_t    cxy = (cxy_t   )GET_CXY( ref );
-    vseg_t * ptr = (vseg_t *)GET_PTR( ref );
+    cxy_t    cxy = (cxy_t   )GET_CXY( ref_xp );
+    vseg_t * ptr = (vseg_t *)GET_PTR( ref_xp );
 
     // initialize vseg with remote_read access
-    vseg->type       =           hal_remote_lw ( XPTR( cxy , &ptr->type      ) );
-    vseg->min        = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->min       ) );
-    vseg->max        = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->max       ) );
-    vseg->vpn_base   =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_base  ) );
-    vseg->vpn_size   =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_size  ) );
-    vseg->flags      =           hal_remote_lw ( XPTR( cxy , &ptr->flags     ) );
-        vseg->mapper_xp  = (xptr_t)  hal_remote_lwd( XPTR( cxy , &ptr->mapper_xp ) );
+    vseg->type        =           hal_remote_lw ( XPTR( cxy , &ptr->type        ) );
+    vseg->min         = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->min         ) );
+    vseg->max         = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->max         ) );
+    vseg->vpn_base    =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_base    ) );
+    vseg->vpn_size    =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_size    ) );
+    vseg->flags       =           hal_remote_lw ( XPTR( cxy , &ptr->flags       ) );
+    vseg->file_offset =           hal_remote_lw ( XPTR( cxy , &ptr->file_offset ) );
+    vseg->file_size   =           hal_remote_lw ( XPTR( cxy , &ptr->file_size   ) );
+        vseg->mapper_xp   = (xptr_t)  hal_remote_lwd( XPTR( cxy , &ptr->mapper_xp   ) );
 }
 

trunk/kernel/mm/vseg.h

@@ -36 +36 @@
 
 /**********************************************************************************************
- * This enum defines the vseg types
+ * This enum defines the vseg types for an user process.
  *********************************************************************************************/
 
-enum
+typedef enum
 {
-    VSEG_TYPE_CODE   = 0,          /*! executable code        / private / localized          */
-    VSEG_TYPE_DATA   = 1,          /*! initialized data       / public  / distributed        */
-    VSEG_TYPE_HEAP   = 2,          /*! standard malloc        / public  / distributed        */
-    VSEG_TYPE_STACK  = 3,          /*! execution stack        / private / localized          */
-    VSEG_TYPE_ANON   = 4,          /*! anonymous mmap         / public  / localized          */
-    VSEG_TYPE_FILE   = 5,          /*! file mmap              / public  / localized          */
-    VSEG_TYPE_REMOTE = 6,          /*! remote mmap            / public  / localized          */
-    VSEG_TYPE_KCODE  = 7,          /*! kernel code            / private / localized          */
-    VSEG_TYPE_KDATA  = 8,          /*! kernel data            / private / localized          */
-    VSEG_TYPE_KDEV   = 9,          /*! device segment         / public  / localized          */
+    VSEG_TYPE_CODE   = 0,          /*! executable user code   / private / localized          */
+    VSEG_TYPE_DATA   = 1,          /*! initialized user data  / public  / distributed        */
+    VSEG_TYPE_STACK  = 2,          /*! execution user stack   / private / localized          */
+    VSEG_TYPE_ANON   = 3,          /*! anonymous mmap         / public  / localized          */
+    VSEG_TYPE_FILE   = 4,          /*! file mmap              / public  / localized          */
+    VSEG_TYPE_REMOTE = 5,          /*! remote mmap            / public  / localized          */
 
-    VSEG_TYPES_NR    = 10,
-};
+    VSEG_TYPE_KDATA  = 10,
+    VSEG_TYPE_KCODE  = 11,
+    VSEG_TYPE_KDEV   = 12,
+}
+vseg_type_t;
 
 
@@ -81 +80 @@
         vpn_t             vpn_size;     /*! number of pages occupied                             */
         uint32_t          flags;        /*! vseg attributes                                      */
-        xptr_t            mapper_xp;    /*! xptr on remote mapper (for types CODE / DATA / FILE) */
-        intptr_t          file_offset;  /*! vseg offset in file (for types CODE/DATA)            */
+        xptr_t            mapper_xp;    /*! xptr on remote mapper (for types CODE/DATA/FILE)     */
+        intptr_t          file_offset;  /*! vseg offset in file (for types CODE/DATA/FILE        */
     intptr_t          file_size;    /*! max segment size in mapper (for type CODE/DATA)      */
     cxy_t             cxy;          /*! physical mapping (for non distributed vseg)          */ 
@@ -125 +124 @@
  *********************************************************************************************/
 void vseg_init( vseg_t      * vseg,
+                    vseg_type_t   type,
                 intptr_t      base,
-                    intptr_t      size,
+                    uint32_t      size,
                 vpn_t         vpn_base,
                 vpn_t         vpn_size,
-                    uint32_t      type,
+                uint32_t      file_offset,
+                uint32_t      file_size,
+                xptr_t        mapper_xp,
                 cxy_t         cxy );