Changeset 408 for trunk/kernel/mm

Timestamp:

Dec 5, 2017, 4:20:07 PM (6 years ago)

Author:

alain

Message:

Fix several bugs in the fork() syscall.

Location:

trunk/kernel/mm

Files:

• mapper.c (modified) (2 diffs)
• page.c (modified) (2 diffs)
• page.h (modified) (1 diff)
• vmm.c (modified) (27 diffs)
• vmm.h (modified) (3 diffs)
• vseg.c (modified) (2 diffs)
• vseg.h (modified) (1 diff)

trunk/kernel/mm/mapper.c

@@ -240 +240 @@
             rwlock_wr_unlock( &mapper->lock );
 
-            // deschedule to wait load completion
+            // wait load completion
             while( 1 )
             {
                 // exit waiting loop when loaded
-                if(  page_is_flag( page , PG_INLOAD ) ) break;
+                if( page_is_flag( page , PG_INLOAD ) == false ) break;
 
                 // deschedule
-                sched_yield();
+                sched_yield("waiting page loading");
             }
         }
@@ -253 +253 @@
     else                          // page available in mapper
     {
-
         rwlock_rd_unlock( &mapper->lock );
     }

trunk/kernel/mm/page.c

@@ -47 +47 @@
         page->index    = 0;
         page->refcount = 0;
+        page->fork_nr  = 0;
 
         spinlock_init( &page->lock );
@@ -180 +181 @@
                 // deschedule the calling thread
                 thread_block( thread , THREAD_BLOCKED_PAGE );
-                sched_yield();
+                sched_yield("cannot lock a page");
         }
         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          reserved;       /*! UNUSED                               (4)  */
+        uint32_t          fork_nr;        /*! number of pending forks              (4)  */
         spinlock_t        lock;           /*! only used to set the PG_LOCKED flag  (16) */
 }

trunk/kernel/mm/vmm.c

@@ -32 +32 @@
 #include <rwlock.h>
 #include <list.h>
+#include <xlist.h>
 #include <bits.h>
 #include <process.h>
@@ -69 +70 @@
     // initialize local list of vsegs 
     vmm->vsegs_nr = 0;
-        list_root_init( &vmm->vsegs_root );
-        rwlock_init( &vmm->vsegs_lock );
+        xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
+        remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) );
 
     assert( ((CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE) 
@@ -154 +155 @@
     // initialize instrumentation counters
         vmm->pgfault_nr          = 0;
-        vmm->u_err_nr            = 0;
-        vmm->m_err_nr            = 0;
 
     hal_fence();
@@ -176 +175 @@
 
     // get lock protecting the vseg list
-    rwlock_rd_lock( &vmm->vsegs_lock );
+    remote_rwlock_rd_lock( XPTR( local_cxy , &vmm->vsegs_lock ) );
 
     // scan the list of vsegs
-    list_entry_t * iter;
+    xptr_t         root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+    xptr_t         iter_xp;
+    xptr_t         vseg_xp;
     vseg_t       * vseg;
-    LIST_FOREACH( &vmm->vsegs_root , iter )
-    {
-        vseg = LIST_ELEMENT( iter , vseg_t , list );
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+
         printk(" - %s : base = %X / size = %X / npages = %d\n",
         vseg_type_str( vseg->type ) , vseg->min , vseg->max - vseg->min , vseg->vpn_size );
@@ -206 +209 @@
 
     // release the lock
-    rwlock_rd_unlock( &vmm->vsegs_lock );
-}
-
-//////////////////////////////////////////
-error_t vmm_copy( process_t * dst_process,
-                  process_t * src_process )
-{
-    error_t error;
-
-    vmm_t * src_vmm = &src_process->vmm;
-    vmm_t * dst_vmm = &dst_process->vmm;
-
-    // take the src_vmm vsegs_lock
-    rwlock_wr_lock( &src_vmm->vsegs_lock );
-
-    // initialize dst_vmm vsegs_lock
-    rwlock_init( &dst_vmm->vsegs_lock );
-
-    // initialize the dst_vmm vsegs list
-    dst_vmm->vsegs_nr = 0;
-    list_root_init( &dst_vmm->vsegs_root );
-
-    // initialize generic page table
-    error = hal_gpt_create( &dst_vmm->gpt );
-
+    remote_rwlock_rd_unlock( XPTR( local_cxy , &vmm->vsegs_lock ) );
+
+}  // vmm_display()
+
+/////////////////////i////////////////////
+void vmm_update_pte( process_t * process,
+                     vpn_t       vpn,
+                     uint32_t    attr,
+                     ppn_t       ppn )
+{
+
+    xlist_entry_t * process_root_ptr;
+    xptr_t          process_root_xp;
+    xptr_t          process_iter_xp;
+
+    xptr_t          remote_process_xp;
+    cxy_t           remote_process_cxy;
+    process_t     * remote_process_ptr;
+    xptr_t          remote_gpt_xp;
+
+    pid_t           pid;
+    cxy_t           owner_cxy;
+    lpid_t          owner_lpid;
+
+    // get extended pointer on root of process copies xlist in owner cluster
+    pid              = process->pid;
+    owner_cxy        = CXY_FROM_PID( pid );
+    owner_lpid       = LPID_FROM_PID( pid );
+    process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
+    process_root_xp  = XPTR( owner_cxy , process_root_ptr );
+
+    // loop on destination process copies
+    XLIST_FOREACH( process_root_xp , process_iter_xp )
+    {
+        // get cluster and local pointer on remote process
+        remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
+        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_cxy = GET_CXY( remote_process_xp );
+
+        // get extended pointer on remote gpt
+        remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
+
+        hal_gpt_update_pte( remote_gpt_xp,
+                            vpn,
+                            attr,
+                            ppn );
+    }  
+}  // end vmm_update_pte()
+
+///////////////////////////////////////
+void vmm_set_cow( process_t * process )
+{
+    vmm_t         * vmm;
+
+    xlist_entry_t * process_root_ptr;
+    xptr_t          process_root_xp;
+    xptr_t          process_iter_xp;
+
+    xptr_t          remote_process_xp;
+    cxy_t           remote_process_cxy;
+    process_t     * remote_process_ptr;
+    xptr_t          remote_gpt_xp;
+
+    xptr_t          vseg_root_xp;
+    xptr_t          vseg_iter_xp;
+
+    xptr_t          vseg_xp;
+    vseg_t        * vseg;
+
+    pid_t           pid;
+    cxy_t           owner_cxy;
+    lpid_t          owner_lpid;
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+
+    // check cluster is reference
+    assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__,
+    "local cluster is not process reference cluster\n");
+
+    // get pointer on reference VMM
+    vmm = &process->vmm;
+
+    // get extended pointer on root of process copies xlist in owner cluster
+    pid              = process->pid;
+    owner_cxy        = CXY_FROM_PID( pid );
+    owner_lpid       = LPID_FROM_PID( pid );
+    process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
+    process_root_xp  = XPTR( owner_cxy , process_root_ptr );
+
+    // get extended pointer on root of vsegs xlist from reference VMM
+    vseg_root_xp  = XPTR( local_cxy , &vmm->vsegs_root ); 
+
+    // loop on destination process copies
+    XLIST_FOREACH( process_root_xp , process_iter_xp )
+    {
+        // get cluster and local pointer on remote process
+        remote_process_xp  = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
+        remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
+        remote_process_cxy = GET_CXY( remote_process_xp );
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] handling process %x in cluster %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid , remote_process_cxy );
+
+        // get extended pointer on remote gpt
+        remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
+
+        // loop on vsegs in (local) reference process VSL
+        XLIST_FOREACH( vseg_root_xp , vseg_iter_xp )
+        {
+            // get pointer on vseg
+            vseg_xp  = XLIST_ELEMENT( vseg_iter_xp , vseg_t , xlist );
+            vseg     = (vseg_t *)GET_PTR( vseg_xp );
+
+            assert( (GET_CXY( vseg_xp ) == local_cxy) , __FUNCTION__,
+            "all vsegs in reference VSL must be local\n" );
+
+            // get vseg type, base and size
+            uint32_t type     = vseg->type;
+            vpn_t    vpn_base = vseg->vpn_base;
+            vpn_t    vpn_size = vseg->vpn_size;
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] handling vseg %s / vpn_base = %x / vpn_size = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vseg_type_str(type), vpn_base, vpn_size );
+
+            // set COW flag on the remote GPT depending on vseg type
+            if( (type == VSEG_TYPE_DATA)  ||
+                (type == VSEG_TYPE_ANON)  ||
+                (type == VSEG_TYPE_REMOTE) )
+            {
+                hal_gpt_flip_cow( true,             // set_cow
+                                  remote_gpt_xp,
+                                  vpn_base,
+                                  vpn_size );
+            }
+        }    // en loop on vsegs
+    }   // end loop on process copies
+ 
+vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
+
+}  // end vmm_set-cow()
+
+/////////////////////////////////////////////////
+error_t vmm_fork_copy( process_t * child_process,
+                       xptr_t      parent_process_xp )
+{
+    error_t     error;
+    cxy_t       parent_cxy;
+    process_t * parent_process;
+    vmm_t     * parent_vmm;
+    xptr_t      parent_lock_xp;
+    vmm_t     * child_vmm;
+    xptr_t      iter_xp;
+    xptr_t      parent_vseg_xp;
+    vseg_t    * parent_vseg;
+    vseg_t    * child_vseg;
+    uint32_t    type;
+    bool_t      cow;
+    vpn_t       vpn;            
+    vpn_t       vpn_base;
+    vpn_t       vpn_size;
+    xptr_t      page_xp;
+    page_t    * page_ptr;
+    cxy_t       page_cxy;
+    xptr_t      parent_root_xp;
+    bool_t      mapped; 
+    ppn_t       ppn;
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] enter\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
+
+    // get parent process cluster and local pointer
+    parent_cxy     = GET_CXY( parent_process_xp );
+    parent_process = (process_t *)GET_PTR( parent_process_xp );
+
+    // get local pointers on parent and child VMM
+    parent_vmm = &parent_process->vmm; 
+    child_vmm  = &child_process->vmm;
+
+    // get extended pointer on lock protecting the parent VSL
+    parent_lock_xp = XPTR( parent_cxy , &parent_vmm->vsegs_lock );
+
+    // take the lock protecting the parent VSL
+    remote_rwlock_rd_lock( parent_lock_xp );
+
+    // initialize the lock protecting the child VSL
+    remote_rwlock_init( XPTR( local_cxy , &child_vmm->vsegs_lock ) );
+
+    // initialize the child VSL as empty
+    xlist_root_init( XPTR( local_cxy, &child_vmm->vsegs_root ) );
+    child_vmm->vsegs_nr = 0;
+
+    // create & initialize the child GPT as empty
+    error = hal_gpt_create( &child_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;
-    vseg_t       * dst_vseg;
-    LIST_FOREACH( &src_vmm->vsegs_root , iter )
-    {
-        // get pointer on current src_vseg
-        src_vseg = LIST_ELEMENT( iter , vseg_t , list );
-
-        // allocate memory for a new dst_vseg
-        dst_vseg = vseg_alloc();
-
-        if( dst_vseg == NULL )
+        printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // build extended pointer on parent VSL
+    parent_root_xp = XPTR( parent_cxy , &parent_vmm->vsegs_root );
+
+    // loop on parent VSL xlist
+    XLIST_FOREACH( parent_root_xp , iter_xp )
+    {
+        // get local and extended pointers on current parent vseg
+        parent_vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        parent_vseg    = (vseg_t *)GET_PTR( parent_vseg_xp );
+
+        // get vseg type
+        type = hal_remote_lw( XPTR( parent_cxy , &parent_vseg->type ) );
+        
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] found parent vseg %s / vpn_base = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+
+        // all parent vsegs - but STACK - must be copied in child VSL
+        if( type != VSEG_TYPE_STACK )
         {
-            // release all allocated vsegs
-            LIST_FOREACH( &dst_vmm->vsegs_root , iter )
+            // allocate memory for a new child vseg
+            child_vseg = vseg_alloc();
+            if( child_vseg == NULL )   // release all allocated vsegs
             {
-                dst_vseg = LIST_ELEMENT( iter , vseg_t , list );
-                vseg_free( dst_vseg );
+                vmm_destroy( child_process );
+                printk("\n[ERROR] in %s : cannot create vseg for child\n", __FUNCTION__ );
+                return -1;
             }
-            return ENOMEM;
-        }
-
-        // copy src_vseg to dst_vseg
-        vseg_init_from_ref( dst_vseg , XPTR( local_cxy , src_vseg ) );
-
-        // 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 STACK allocator
-    dst_vmm->stack_mgr.bitmap   = 0;
-    dst_vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
-
-    // initialize MMAP allocator
-    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;
+
+            // copy parent vseg to child vseg
+            vseg_init_from_ref( child_vseg , parent_vseg_xp );
+
+            // register child vseg in child VSL
+            vseg_attach( child_vmm , child_vseg );
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child VSL : vseg %s / vpn_base = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
+hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
+
+            // copy DATA, MMAP, REMOTE, FILE parent GPT entries to child GPT
+            if( type != VSEG_TYPE_CODE )
+            {
+                // activate the COW for DATA, MMAP, REMOTE vsegs only
+                cow = ( type != VSEG_TYPE_FILE );
+
+                vpn_base = child_vseg->vpn_base;
+                vpn_size = child_vseg->vpn_size;
+
+                // scan pages in parent vseg
+                for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
+                {
+                    error = hal_gpt_pte_copy( &child_vmm->gpt,
+                                              XPTR( parent_cxy , &parent_vmm->gpt ),
+                                              vpn,
+                                              cow,
+                                              &ppn,
+                                              &mapped );
+                    if( error )
+                    {
+                        vmm_destroy( child_process );
+                        printk("\n[ERROR] in %s : cannot copy GPT\n", __FUNCTION__ );
+                        return -1;
+                    }
+
+                    // increment page descriptor fork_nr for the referenced page if mapped
+                    if( mapped )
+                    {
+                        page_xp = ppm_ppn2page( ppn );
+                        page_cxy = GET_CXY( page_xp );
+                        page_ptr = (page_t *)GET_PTR( page_xp );
+                        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , 1 );
+
+vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child GPT : vpn %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
+
+                    }
+                }
+            }   // end if no code & no stack
+        }   // end if no stack
+    }   // end loop on vsegs
+
+    // release the parent vsegs lock
+    remote_rwlock_rd_unlock( parent_lock_xp );
+
+    // initialize the child VMM STACK allocator
+    child_vmm->stack_mgr.bitmap   = 0;
+    child_vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
+
+    // initialize the child VMM MMAP allocator
     uint32_t i;
-    for( i = 0 ; i < 32 ; i++ ) list_root_init( &dst_vmm->mmap_mgr.zombi_list[i] );
+    child_vmm->mmap_mgr.vpn_base        = CONFIG_VMM_HEAP_BASE;
+    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] );
 
     // initialize instrumentation counters
-        dst_vmm->pgfault_nr    = 0;
-        dst_vmm->u_err_nr      = 0;
-        dst_vmm->m_err_nr      = 0;
-
-    // copy base addresses
-    dst_vmm->kent_vpn_base = src_vmm->kent_vpn_base;
-    dst_vmm->args_vpn_base = src_vmm->args_vpn_base;
-    dst_vmm->envs_vpn_base = src_vmm->envs_vpn_base;
-    dst_vmm->heap_vpn_base = src_vmm->heap_vpn_base;
-    dst_vmm->code_vpn_base = src_vmm->code_vpn_base;
-    dst_vmm->data_vpn_base = src_vmm->data_vpn_base;
-
-    dst_vmm->entry_point   = src_vmm->entry_point;
+        child_vmm->pgfault_nr    = 0;
+
+    // copy base addresses from parent VMM to child VMM
+    child_vmm->kent_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->kent_vpn_base));
+    child_vmm->args_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->args_vpn_base));
+    child_vmm->envs_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->envs_vpn_base));
+    child_vmm->heap_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->heap_vpn_base));
+    child_vmm->code_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->code_vpn_base));
+    child_vmm->data_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->data_vpn_base));
+
+    child_vmm->entry_point = (intptr_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->entry_point));
 
     hal_fence();
@@ -315 +523 @@
     return 0;
 
-}  // vmm_copy()
+}  // vmm_fork_copy()
 
 ///////////////////////////////////////
 void vmm_destroy( process_t * process )
 {
+    xptr_t   vseg_xp;
         vseg_t * vseg;
 
@@ -325 +534 @@
     vmm_t  * vmm = &process->vmm;
 
+    // get 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->vsegs_lock );
+
     // get lock protecting vseg list
-        rwlock_wr_lock( &vmm->vsegs_lock );
-
-    // remove all vsegs registered in vmm
-        while( !list_is_empty( &vmm->vsegs_root ) )
+        remote_rwlock_wr_lock( lock_xp );
+
+    // remove all vsegs registered in VSL
+        while( !xlist_is_empty( root_xp ) )
         {
-                vseg = LIST_FIRST( &vmm->vsegs_root ,  vseg_t , list );
+                vseg_xp = XLIST_FIRST_ELEMENT( root_xp , vseg_t , xlist );
+        vseg = (vseg_t *)GET_PTR( vseg_xp );
                 vseg_detach( vmm , vseg );
         vseg_free( vseg );
@@ -337 +551 @@
 
     // release lock
-        rwlock_wr_unlock(&vmm->vsegs_lock);
+        remote_rwlock_wr_unlock( lock_xp );
 
     // remove all vsegs from zombi_lists in MMAP allocator
@@ -345 +559 @@
             while( !list_is_empty( &vmm->mmap_mgr.zombi_list[i] ) )
             {
-                    vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , list );
+                    vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , zlist );
                     vseg_detach( vmm , vseg );
             vseg_free( vseg );
@@ -362 +576 @@
 {
     vmm_t        * vmm = &process->vmm;
+
+    // scan the VSL
         vseg_t       * vseg;
-    list_entry_t * iter;
-
-    // scan the list of registered vsegs
-        LIST_FOREACH( &vmm->vsegs_root , iter )
+    xptr_t         iter_xp;
+    xptr_t         vseg_xp;
+    xptr_t         root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+
+        XLIST_FOREACH( root_xp , iter_xp )
         {
-                vseg = LIST_ELEMENT( iter , vseg_t , list );
+                vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg    = (vseg_t *)GET_PTR( vseg_xp );
 
                 if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
@@ -463 +681 @@
     {
         // get pointer on zombi vseg from zombi_list
-        vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , list );
+        vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , zlist );
 
         // remove vseg from free-list
-        list_unlink( &vseg->list );
+        list_unlink( &vseg->zlist );
 
         // compute base
@@ -579 +797 @@
                cxy );
 
-    // attach vseg to vmm
-        rwlock_wr_lock( &vmm->vsegs_lock );
+    // attach vseg to VSL
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+        remote_rwlock_wr_lock( lock_xp );
         vseg_attach( vmm , vseg );
-        rwlock_wr_unlock( &vmm->vsegs_lock );
+        remote_rwlock_wr_unlock( lock_xp );
 
 vmm_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / base %x / size %x / type %s\n",
@@ -601 +820 @@
     uint32_t     type    = vseg->type;
 
-    // detach vseg from VMM
-        rwlock_wr_lock( &vmm->vsegs_lock );
-    vseg_detach( &process->vmm , vseg );
-        rwlock_wr_unlock( &vmm->vsegs_lock );
+    // detach vseg from VSL
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+        remote_rwlock_wr_lock( lock_xp );
+        vseg_detach( &process->vmm , vseg );
+        remote_rwlock_wr_unlock( lock_xp );
 
     // release the stack slot to VMM stack allocator if STACK type
@@ -632 +852 @@
         // update zombi_list
         spinlock_lock( &mgr->lock );
-        list_add_first( &mgr->zombi_list[index] , &vseg->list );
+        list_add_first( &mgr->zombi_list[index] , &vseg->zlist );
         spinlock_unlock( &mgr->lock );
     }
@@ -686 +906 @@
         // set page table entry
         ppn = ppm_page2ppn( XPTR( local_cxy , page ) );
-        error = hal_gpt_set_pte( gpt , vpn , ppn , attr );
+        error = hal_gpt_set_pte( gpt,
+                                 vpn,
+                                 attr,
+                                 ppn );
                 if( error )
         {
@@ -695 +918 @@
 
         return 0;
-}
+
+}  // end vmm_map_kernel_vseg()
 
 /////////////////////////////////////////
@@ -729 +953 @@
                                  intptr_t   vaddr )
 {
-    list_entry_t * iter;
-    vseg_t       * vseg = NULL;
-
-    // get lock protecting the vseg list
-    rwlock_rd_lock( &vmm->vsegs_lock );
-
-    // scan the list of vsegs
-    LIST_FOREACH( &vmm->vsegs_root , iter )
-    {
-        vseg = LIST_ELEMENT( iter , vseg_t , list );
-        if( (vaddr >= vseg->min) && (vaddr < vseg->max) ) break;
-    }
-
-    // release the lock
-    rwlock_rd_unlock( &vmm->vsegs_lock );
-
-    return vseg;
-}
+    xptr_t   iter_xp;
+    xptr_t   vseg_xp;
+    vseg_t * vseg;
+
+    // get extended pointers on VSL lock and root
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+    xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
+
+    // get lock protecting the VSL
+    remote_rwlock_rd_lock( lock_xp );
+
+    // scan the list of vsegs in VSL
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
+        vseg    = (vseg_t *)GET_PTR( vseg_xp );
+        if( (vaddr >= vseg->min) && (vaddr < vseg->max) )
+        {
+            // return success
+            remote_rwlock_rd_unlock( lock_xp );
+            return vseg;
+        }
+    }
+
+    // return failure
+    remote_rwlock_rd_unlock( lock_xp );
+    return NULL;
+
+}  // end vseg_from_vaddr()
 
 /////////////////////////////////////////////
@@ -769 +1004 @@
         if( vseg == NULL)  return EINVAL;
 
-    // get VMM lock protecting vsegs list
-        rwlock_wr_lock( &vmm->vsegs_lock );
+    // get extended pointer on VSL lock
+    xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
+
+    // get lock protecting VSL
+        remote_rwlock_wr_lock( lock_xp );
 
         if( (vseg->min > addr_min) || (vseg->max < addr_max) )   // region not included in vseg
@@ -831 +1069 @@
 
     // release VMM lock
-        rwlock_wr_unlock( &vmm->vsegs_lock );
+        remote_rwlock_wr_unlock( lock_xp );
 
         return error;
@@ -1129 +1367 @@
     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;
 
@@ -1137 +1374 @@
 
 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);
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid , cow );
 
     // get VMM pointer
@@ -1159 +1396 @@
     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
+    // for both "copy_on_write" and "page_fault" events, allocate a physical page,
+    // initialize it, register it in the reference GPT, update GPT copies in all
+    // clusters containing a copy, 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",
+        assert( (old_attr & GPT_MAPPED) , __FUNCTION__ , 
+        "PTE must be mapped for a copy-on-write exception\n" );
+
+excp_dmsg("\n[DBG] %s : core[%x,%d] handling COW for vpn %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
 
-        // allocate a physical page depending on vseg type
-        page_xp = vmm_page_allocate( vseg , vpn );
-
-        if( page_xp == XPTR_NULL ) 
+        // get extended pointer, cluster and local pointer on page descriptor
+        xptr_t   page_xp  = ppm_ppn2page( old_ppn );
+        cxy_t    page_cxy = GET_CXY( page_xp );
+        page_t * page_ptr = (page_t *)GET_PTR( page_xp );
+
+        // get number of pending forks in page descriptor
+        uint32_t count = hal_remote_lw( XPTR( page_cxy , &page_ptr->fork_nr ) );
+
+        if( count )        // pending fork => allocate a new page, copy it, reset COW
         {
-            printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
-            __FUNCTION__ , process->pid , vpn );
-            return ENOMEM;
+            // allocate a new physical page
+            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 -1;
+            }
+
+            // 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 );
+        }             
+        else               // no pending fork => keep the existing page, reset COW
+        {
+            new_ppn = old_ppn;
         }
 
-        // 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 )
+        // build new_attr : reset COW and set WRITABLE,
+        new_attr = (old_attr | GPT_WRITABLE) & (~GPT_COW);
+
+        // update GPT[vpn] for all GPT copies
+        // to maintain coherence of copies
+        vmm_update_pte( process,
+                        vpn,
+                        new_attr,
+                        new_ppn );
+
+        // decrement fork_nr in page descriptor
+        hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , -1 );
+    }
+    else                         /////////////// page_fault request ///////////
+    {  
+        if( (old_attr & GPT_MAPPED) == 0 )   // true page_fault => map it
         {
-            printk("\n[ERROR] in %s : cannot update GPT / process = %x / vpn = %x\n",
-            __FUNCTION__ , process->pid , vpn );
-            return error;
-        }
-    }
-    else                    //////////////////// page_fault request ///////////
-    {  
-        if( (old_attr & GPT_MAPPED) == 0 )    // PTE unmapped in ref GPT
-        {
-
-vmm_dmsg("\n[DBG] %s : core[%x,%d] page %x unmapped => try to map it\n",
+
+excp_dmsg("\n[DBG] %s : core[%x,%d] handling page fault for vpn %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
 
-            // allocate one physical page, depending on vseg type
+            // allocate new_ppn, 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;
+                return -1;
             }
 
-            // define attributes from vseg flags 
+            // define new_attr from vseg flags 
             new_attr = GPT_MAPPED | GPT_SMALL;
             if( vseg->flags & VSEG_USER  ) new_attr |= GPT_USER;
@@ -1229 +1479 @@
             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 );
-
+            // register new PTE in reference GPT
+            // on demand policy => no update of GPT copies
+            error = hal_gpt_set_pte( &vmm->gpt,
+                                     vpn,
+                                     new_attr,
+                                     new_ppn );
             if( error )
             {
                 printk("\n[ERROR] in %s : cannot update GPT / process = %x / vpn = %x\n",
                 __FUNCTION__ , process->pid , vpn );
-                return error;
+                return -1;
             }
         }
-        else
+        else                                  // mapped in reference GPT => get it
         {
+            new_ppn  = old_ppn;
             new_attr = old_attr;
-            new_ppn  = old_ppn;
         }
     }
 
-vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for vpn = %x / ppn = %x / attr = %x\n",
+excp_dmsg("\n[DBG] %s : core[%x,%d] update GPT for vpn %x / ppn = %x / attr = %x\n",
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , new_ppn , new_attr );
 
+    // retur success
     *ppn  = new_ppn;
     *attr = new_attr;
@@ -1282 +1536 @@
 
         // update local GPT
-        error |= hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
+        error |= hal_gpt_set_pte( &vmm->gpt,
+                                  vpn,
+                                  attr,
+                                  ppn );
     }
     else   // local cluster is the reference cluster
@@ -1297 +1554 @@
 }  // end vmm_handle_page_fault()
 
-///////////////////////////////////////////////
-error_t vmm_copy_on_write( process_t * process,
-                           vpn_t       vpn )
+////////////////////////////////////////////
+error_t vmm_handle_cow( process_t * process,
+                        vpn_t       vpn )
 {
     uint32_t         attr;          // missing page attributes
@@ -1324 +1581 @@
 
         // update local GPT
-        error |= hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
+        error |= hal_gpt_set_pte( &vmm->gpt,
+                                  vpn,
+                                  attr,
+                                  ppn );
     }
     else   // local cluster is the reference cluster
@@ -1337 +1597 @@
     return error;
 
-}  // end vmm_copy_on_write()
+}  // end vmm_handle_cow()
 
 ///////////////////////////////////////////

trunk/kernel/mm/vmm.h

@@ -89 +89 @@
 /*********************************************************************************************
  * This structure defines the Virtual Memory Manager for a given process in a given cluster.
- * 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 (FILE/ANON/REMOTE).
- * 3) It contains the local copy of the generic page table descriptor.
+ * This local VMM provides four main services:
+ * 1) It registers all vsegs in the local copy of the vseg list (VSL).
+ * 2) It contains the local copy of the generic page table (GPT).
+ * 3) The stack manager dynamically allocates virtual memory space for the STACK vsegs.
+ * 4) The mmap manager dynamically allocates virtual memory for the (FILE/ANON/REMOTE) vsegs.
+ ******************************************************a**************************************
+ * Implementation notes:
+ * 1. The VSL contains only local vsegs, but it is implemented as an xlist, and protected by
+ *    a remote_rwlock, because it can be accessed by a thread running in a remote cluster.
+ *    An exemple is the vmm_fork_copy() function.
+ * 2. In most custers, the VSL and GPT are only partial copies of the reference VSL and GPT
+ *    structures, stored in the reference cluster.
  ********************************************************************************************/
 
 typedef struct vmm_s
 {
-        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                      */
-
-    gpt_t          gpt;                /*! embedded generic page table descriptor           */
-
-    stack_mgr_t    stack_mgr;          /*! embedded STACK vsegs allocator                   */
-    mmap_mgr_t     mmap_mgr;           /*! embedded MMAP vsegs allocator                    */
-
-        uint32_t       pgfault_nr;         /*! page fault counter (instrumentation)             */
-        uint32_t       u_err_nr;           /*! TODO ??? [AG]                                    */
-        uint32_t       m_err_nr;           /*! TODO ??? [AG]                                    */
-
-    vpn_t          kent_vpn_base;      /*! kentry vseg first page                           */
-    vpn_t          args_vpn_base;      /*! args vseg first page                             */
-    vpn_t          envs_vpn_base;      /*! envs zone first page                             */
-    vpn_t          heap_vpn_base;      /*! envs zone first page                             */
-        vpn_t          code_vpn_base;      /*! code zone first page                             */
-        vpn_t          data_vpn_base;      /*! data zone first page                             */
-
-        intptr_t       entry_point;        /*! main thread entry point                          */
+        remote_rwlock_t  vsegs_lock;         /*! lock protecting the vsegs list                 */
+        xlist_entry_t    vsegs_root;         /*! VSL root (VSL only complete in reference)      */
+        uint32_t         vsegs_nr;           /*! total number of local vsegs                    */
+
+    gpt_t            gpt;                /*! Generic Page Table (complete in reference)     */
+
+    stack_mgr_t      stack_mgr;          /*! embedded STACK vsegs allocator                 */
+    mmap_mgr_t       mmap_mgr;           /*! embedded MMAP vsegs allocator                  */
+
+        uint32_t         pgfault_nr;         /*! page fault counter (instrumentation)           */
+
+    vpn_t            kent_vpn_base;      /*! kentry vseg first page                         */
+    vpn_t            args_vpn_base;      /*! args vseg first page                           */
+    vpn_t            envs_vpn_base;      /*! envs zone first page                           */
+    vpn_t            heap_vpn_base;      /*! envs zone first page                           */
+        vpn_t            code_vpn_base;      /*! code zone first page                           */
+        vpn_t            data_vpn_base;      /*! data zone first page                           */
+
+        intptr_t         entry_point;        /*! main thread entry point                        */
 }
 vmm_t;
@@ -147 +153 @@
 
 /*********************************************************************************************
- * 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.
- * @ src_process   : pointer on source process descriptor.
+ * This function is called by the process_fork_create() 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
+ *   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
+ *   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
+ *   must be copied from the cluster containing the user thread requesting the fork().
+ *********************************************************************************************
+ * @ child_process     : local pointer on local child process descriptor.
+ * @ parent_process_xp : extended pointer on remote parent process descriptor.
  * @ return 0 if success / return ENOMEM if failure.
  ********************************************************************************************/
-error_t vmm_copy( struct process_s * dst_process,
-                  struct process_s * src_process );
-
-/*********************************************************************************************
- * This function removes all vsegs registered in in a virtual memory manager,
- * and releases the memory allocated to the local generic page table.
+error_t vmm_fork_copy( struct process_s * child_process,
+                       xptr_t             parent_process_xp );
+
+/*********************************************************************************************
+ * This function is called by the process_make_fork() function to handle the fork syscall.
+ * It set the COW flag, and reset the WRITABLE flag of all GPT entries of the DATA, MMAP,
+ * and REMOTE vsegs of a process identified by the <process> argument.
+ * It must be called by a thread running in the reference cluster, that contains the complete
+ * list of vsegs. Use the rpc_vmm_set_cow_client() when the calling thread client is remote. 
+ * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
+ * using the list of copies stored in the owner process, and using remote_write accesses to
+ * update the remote GPTs. It cannot fail, as only mapped entries in GPT copies are updated.
+ *********************************************************************************************
+ * @ process   : local pointer on local reference process descriptor.
+ ********************************************************************************************/
+void vmm_set_cow( struct process_s * process );
+
+/*********************************************************************************************
+ * This function is called by the vmm_get_pte() function in case of COW exception.
+ * It modifies both the PPN an the attributes for a GPT entry identified by the <process>
+ * and <vpn> arguments. 
+ * It updates all copies of the process in all clusters, to maintain coherence in GPT copies,
+ * using the list of copies stored in the owner process, and using remote_write accesses to
+ * update the remote GPTs. It cannot fail, as only mapped entries in GPT copies are updated.
+ *********************************************************************************************
+ * @ process   : local pointer on local process descriptor.
+ * @ vpn       : PTE index.
+ * @ attr      : PTE / attributes.
+ * @ ppn       : PTE / physical page index.
+ ********************************************************************************************/
+void vmm_update_pte( struct process_s * process,
+                     vpn_t              vpn,
+                     uint32_t           attr,
+                     ppn_t              ppn );
+
+/*********************************************************************************************
+ * This function removes all vsegs registered in in the virtual memory manager of the
+ * process identified by the <process> argument. 
+ * It releases the memory allocated to the local generic page table.
  *********************************************************************************************
  * @ process   : pointer on process descriptor.
@@ -315 +360 @@
  * @ returns 0 if success / returns ENOMEM if no memory.
  ********************************************************************************************/
-error_t vmm_copy_on_write( struct process_s * process,
-                           vpn_t              vpn );
+error_t vmm_handle_cow( struct process_s * process,
+                        vpn_t              vpn );
 
 /*********************************************************************************************

trunk/kernel/mm/vseg.c

@@ -194 +194 @@
 
     // add vseg in vmm list
-    list_add_last( &vmm->vsegs_root , &vseg->list );
+    xlist_add_last( XPTR( local_cxy , &vmm->vsegs_root ),
+                    XPTR( local_cxy , &vseg->xlist ) );
 }
 
@@ -205 +206 @@
 
     // remove vseg from vmm list
-    list_unlink( &vseg->list );
-}
-
+    xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
+}
+

trunk/kernel/mm/vseg.h

@@ -68 +68 @@
 /**********************************************************************************************
  * 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.
  *********************************************************************************************/
 
 typedef struct vseg_s
 {
-        list_entry_t      list;         /*! all vsegs in same process / same free list if mmap   */
+        xlist_entry_t     xlist;        /*! all vsegs in same VSL (or same zombi list)           */
+        list_entry_t      zlist;        /*! all vsegs in same zombi list                         */
         struct vmm_s    * vmm;          /*! pointer on associated VM manager                     */
     uint32_t          type;         /*! vseg type                                            */