Changeset 406 for trunk/kernel/mm

Timestamp:

Aug 29, 2017, 12:03:37 PM (7 years ago)

Author:

alain

Message:

This version executed successfully the user "init" process on a mono-processor TSAR architecture.

Location:

trunk/kernel/mm

Files:

• kcm.c (modified) (5 diffs)
• kmem.c (modified) (6 diffs)
• mapper.c (modified) (13 diffs)
• ppm.c (modified) (3 diffs)
• vmm.c (modified) (32 diffs)
• vmm.h (modified) (7 diffs)
• vseg.c (modified) (3 diffs)
• vseg.h (modified) (1 diff)

trunk/kernel/mm/kcm.c

@@ -47 +47 @@
                              kcm_page_t * kcm_page )
 {
-        kcm_dmsg("\n[INFO] %s : enters for %s / page %x / count = %d / active = %d\n",
+        kcm_dmsg("\n[DMSG] %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[INFO] %s : allocated one block  %s / ptr = %p / page = %x / count = %d\n",
+        kcm_dmsg("\n[DMSG] %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[INFO] %s : KCM %s initialised / block_size = %d / blocks_nr = %d\n",
+        kcm_dmsg("\n[DMSG] %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[INFO] %s : enters for type %s at cycle %d / new page = %x / count = %d\n",
+                kcm_dmsg("\n[DMSG] %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[INFO] %s : enters for type %s at cycle %d / page = %x / count = %d\n",
+                kcm_dmsg("\n[DMSG] %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[INFO] %s : enters / KCM type %s missing in cluster %x\n",
+        kmem_dmsg("\n[DMSG] %s : enters / KCM type %s missing in cluster %x\n",
                   __FUNCTION__ , kmem_type_str( type ) , local_cxy );
 
@@ -169 +169 @@
         hal_fence();
 
-        kmem_dmsg("\n[INFO] %s : exit / KCM type %s created in cluster %x\n",
+        kmem_dmsg("\n[DMSG] %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[INFO] %s : enters in cluster %x for type %s\n",
+        kmem_dmsg("\n[DMSG] %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[INFO] %s : exit in cluster %x for type %s / page = %x / base = %x\n",
+                kmem_dmsg("\n[DMSG] %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[INFO] %s : exit in cluster %x for type %s / base = %x / size = %d\n",
+                kmem_dmsg("\n[DMSG] %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[INFO] %s : exit in cluster %x for type %s / base = %x / size = %d\n",
+                kmem_dmsg("\n[DMSG] %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[INFO] %s : enters for page %d in mapper %x\n",
+    mapper_dmsg("\n[DMSG] %s : enters for page %d / mapper %x\n",
                 __FUNCTION__ , index , mapper );
 
@@ -170 +170 @@
         if ( page == NULL )   // missing page => create it and load it from file system
         {
-            mapper_dmsg("\n[INFO] %s : missing page => load from device\n", __FUNCTION__ );
+            mapper_dmsg("\n[DMSG] %s : missing page => load from device\n", __FUNCTION__ );
 
             // allocate one page from PPM
@@ -212 +212 @@
             }
 
-            // update the mapper and index fields in page descriptor
-            // required by the vfs_move_page_to_mapper()
-            page->mapper = mapper;
-            page->index  = index;
-
             // launch I/O operation to load page from file system
             error = vfs_mapper_move_page( page, 
@@ -259 +254 @@
     }
 
-    mapper_dmsg("\n[INFO] %s : exit for page %d in mapper %x / page_desc = %x\n",
+    mapper_dmsg("\n[DMSG] %s : exit for page %d / mapper %x / page_desc = %x\n",
                 __FUNCTION__ , index , mapper , page );
 
@@ -315 +310 @@
     uint8_t  * buf_ptr;        // current buffer  address
 
-    mapper_dmsg("\n[INFO] %s : enters / to_buf = %d / buffer = %x\n",
+    mapper_dmsg("\n[DMSG] %s : enters / to_buf = %d / buffer = %x\n",
                 __FUNCTION__ , to_buffer , buffer );
 
@@ -341 +336 @@
         else                       page_count = CONFIG_PPM_PAGE_SIZE;
 
-        mapper_dmsg("\n[INFO] %s : index = %d / offset = %d / count = %d\n",
+        mapper_dmsg("\n[DMSG] %s : index = %d / offset = %d / count = %d\n",
                     __FUNCTION__ , index , page_offset , page_count );
 
@@ -356 +351 @@
         buf_ptr = (uint8_t *)buffer + done;
 
-        mapper_dmsg("\n[INFO] %s : index = %d / buf_ptr = %x / map_ptr = %x\n",
+        mapper_dmsg("\n[DMSG] %s : index = %d / buf_ptr = %x / map_ptr = %x\n",
                     __FUNCTION__ , index , buf_ptr , map_ptr );
 
@@ -373 +368 @@
     }
 
-    mapper_dmsg("\n[INFO] %s : exit for buffer %x\n",
+    mapper_dmsg("\n[DMSG] %s : exit for buffer %x\n",
                 __FUNCTION__, buffer );
 
@@ -398 +393 @@
     cxy_t      dst_cxy;        // destination cluster
 
-    mapper_dmsg("\n[INFO] %s : enters / to_buf = %d / buffer = %l / size = %x / cycle %d\n",
-                __FUNCTION__ , to_buffer , buffer_xp , size , hal_time_stamp() );
+    // get buffer cluster and local pointer
+    cxy_t     buffer_cxy = GET_CXY( buffer_xp );
+    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 );
 
     // compute offsets of first and last bytes in file
@@ -409 +408 @@
     uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
 
-    // get buffer cluster and local pointer
-    cxy_t     buffer_cxy = GET_CXY( buffer_xp );
-    uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp );
+    mapper_dmsg("\n[DMSG] %s : first_page = %d / last_page = %d\n",
+    __FUNCTION__ , first , last );
 
     // compute source and destination clusters
@@ -440 +438 @@
         else                       page_count = CONFIG_PPM_PAGE_SIZE;
 
-        mapper_dmsg("\n[INFO] %s : page_index = %d / offset = %d / count = %d\n",
+        mapper_dmsg("\n[DMSG] %s : page_index = %d / offset = %d / bytes = %d\n",
                     __FUNCTION__ , index , page_offset , page_count );
 
@@ -466 +464 @@
         }
 
-        mapper_dmsg("\n[INFO] %s : index = %d\n", __FUNCTION__ , index );
-
         // move fragment
         hal_remote_memcpy( XPTR( dst_cxy , dst_ptr ), XPTR( src_cxy , src_ptr ), page_count );
@@ -474 +470 @@
     }
 
-    mapper_dmsg("\n[INFO] %s : exit for buffer %l / size = %x / cycle %d\n",
-                __FUNCTION__ , buffer_xp , size , hal_time_stamp() );
+    mapper_dmsg("\n[DMSG] %s : exit / buf_cxy = %x / buf_ptr = %x / size = %x\n",
+    __FUNCTION__ , buffer_cxy , buffer_ptr , size );
 
     return 0;
 
-}  // end mapper_move_kernel_buffer()
-
+}  // end mapper_move_kernel()
+

trunk/kernel/mm/ppm.c

@@ -56 +56 @@
     page_t * page_ptr = (page_t *)GET_PTR( page_xp );
 
-    void   * base_ptr = ppm->vaddr_base + 
-                        ((page_ptr - ppm->pages_tbl)<<CONFIG_PPM_PAGE_SHIFT);
-  
+   void   * base_ptr = ppm->vaddr_base + 
+                       ((page_ptr - ppm->pages_tbl)<<CONFIG_PPM_PAGE_SHIFT);
+
         return XPTR( page_cxy , base_ptr );
 
@@ -203 +203 @@
         assert( (order < CONFIG_PPM_MAX_ORDER) , __FUNCTION__ , "illegal order argument" );
 
-        page_t * block = NULL;
-
-        ppm_dmsg("\n[INFO] %s : enters / order = %d\n",
+        page_t * block = NULL;  
+
+        ppm_dmsg("\n[DMSG] %s : enters / order = %d\n",
                  __FUNCTION__ , order );
 
@@ -256 +256 @@
         spinlock_unlock( &ppm->free_lock );
 
-        ppm_dmsg("\n[INFO] %s : base = %x / order = %d\n",
+        ppm_dmsg("\n[DMSG] %s : base = %x / order = %d\n",
                  __FUNCTION__ , (uint32_t)ppm_page2base( block ) , order );
 

trunk/kernel/mm/vmm.c

@@ -62 +62 @@
     intptr_t  size;
 
-    vmm_dmsg("\n[INFO] %s : enter for process %x\n", __FUNCTION__ , process->pid );
+    vmm_dmsg("\n[DMSG] %s : enter for process %x\n", __FUNCTION__ , process->pid );
 
     // get pointer on VMM
@@ -83 +83 @@
     vmm->vsegs_nr = 0;
         list_root_init( &vmm->vsegs_root );
-    error = grdxt_init( &vmm->grdxt,
-                        CONFIG_VMM_GRDXT_W1,
-                        CONFIG_VMM_GRDXT_W2,
-                        CONFIG_VMM_GRDXT_W3 );
- 
-    assert( (error == 0) , __FUNCTION__ , "cannot initialize radix tree\n" );
 
     // register kentry vseg in VMM
-    base = 1 << CONFIG_PPM_PAGE_SHIFT;
+    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 );
 
     assert( (vseg_kentry != NULL) , __FUNCTION__ , "cannot register kentry vseg\n" );
 
-    vmm->kent_vpn_base = 1;
-
-    // register the args vseg in VMM
-    base = (CONFIG_VMM_KENTRY_SIZE + 1 )<<CONFIG_PPM_PAGE_SHIFT;
+    vmm->kent_vpn_base = base;
+
+    // register args vseg in VMM
+    base = (CONFIG_VMM_KENTRY_BASE + 
+            CONFIG_VMM_KENTRY_SIZE ) << CONFIG_PPM_PAGE_SHIFT;
     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" );
 
-    vmm->args_vpn_base = CONFIG_VMM_KENTRY_SIZE + 1;
+    vmm->args_vpn_base = base;
 
     // register the envs vseg in VMM
-    base = (CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + 1 )<<CONFIG_PPM_PAGE_SHIFT;
+    base = (CONFIG_VMM_KENTRY_BASE + 
+            CONFIG_VMM_KENTRY_SIZE +
+            CONFIG_VMM_ARGS_SIZE   ) << CONFIG_PPM_PAGE_SHIFT;
     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" );
 
-    vmm->envs_vpn_base = CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + 1;
+    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 = CONFIG_VMM_HEAP_BASE;
+    vmm->heap_vpn_base = base;
 
     // initialize generic page table
@@ -149 +150 @@
     hal_fence();
 
-    vmm_dmsg("\n[INFO] %s : exit for process %x\n", __FUNCTION__ , process->pid );
+    vmm_dmsg("\n[DMSG] %s : exit for process %x / entry_point = %x\n",
+    __FUNCTION__ , process->pid , process->vmm.entry_point );
 
 }  // end vmm_init()
@@ -171 +173 @@
     dst_vmm->vsegs_nr = 0;
     list_root_init( &dst_vmm->vsegs_root );
-    error = grdxt_init( &dst_vmm->grdxt,
-                        CONFIG_VMM_GRDXT_W1,
-                        CONFIG_VMM_GRDXT_W2,
-                        CONFIG_VMM_GRDXT_W3 );
-    if( error )
-    {
-        printk("\n[ERROR] in %s : cannot initialize radix tree for process %x\n",
-               __FUNCTION__ , dst_process->pid );
-        return ENOMEM;
-    }
 
     // loop on src_vmm list of vsegs to create
@@ -292 +284 @@
         vseg_free( vseg );
         }
-
-    // delete vsegs radix_tree
-    grdxt_destroy( &vmm->grdxt );
 
     // release lock
@@ -456 +445 @@
         vmm_t * vmm = &process->vmm;
 
-        vmm_dmsg("\n[INFO] %s : enter for process %x / base = %x / size = %x / type = %s\n",
+        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) );
 
@@ -527 +516 @@
 
     // update "heap_vseg" in VMM
-        process->vmm.heap_vseg = vseg;
+        if( type == VSEG_TYPE_HEAP ) process->vmm.heap_vseg = vseg;
 
     // attach vseg to vmm
@@ -534 +523 @@
         rwlock_wr_unlock( &vmm->vsegs_lock );
 
-        vmm_dmsg("\n[INFO] %s : exit for process %x / vseg [%x, %x] has been mapped\n",
+        vmm_dmsg("\n[DMSG] %s : exit for process %x / vseg [%x, %x] registered\n",
                      __FUNCTION__ , process->pid , vseg->min , vseg->max );
 
         return vseg;
-}
+
+}  // vmm_create_vseg()
 
 /////////////////////////////////////
@@ -665 +655 @@
 }
 
+///////////////////////////////////////////////////////////////////////////////////////
+// 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 )
+{
+    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;
+}
+
 /////////////////////////////////////////////
 error_t vmm_resize_vseg( process_t * process,
@@ -670 +691 @@
                          intptr_t    size )
 {
-        error_t error;
+    error_t   error;
+    vseg_t  * new;
+    vpn_t     vpn_min;
+    vpn_t     vpn_max;
 
     // get pointer on process VMM
@@ -677 +701 @@
     intptr_t addr_min = base;
         intptr_t addr_max = base + size;
-    uint32_t shift    = CONFIG_PPM_PAGE_SHIFT;
 
     // get pointer on vseg
-        vseg_t * vseg = grdxt_lookup( &vmm->grdxt , (uint32_t)(base >> shift) );
+        vseg_t * vseg = vseg_from_vaddr( vmm , base );
 
         if( vseg == NULL)  return EINVAL;
@@ -696 +719 @@
         error = 0;
     }
-        else if( vseg->min == addr_min )                              // vseg must be resized
-    {
-        panic("resize not implemented yet");
-                error = 0;
-    }
-        else if( vseg->max == addr_max )                              // vseg must be resized
-    {
-        panic("resize not implemented yet");
-                error = 0;
-    }
-    else            // vseg cut in three regions => vseg must be resized & new vseg created
-    {
-        panic("resize not implemented yet");
-                error = 0;
+        else if( vseg->min == addr_min )                         // vseg must be resized
+    {
+        // update vseg base address
+        vseg->min = addr_max;
+
+        // update vpn_base and vpn_size
+        vpn_min        = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
+        vpn_max        = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
+        vseg->vpn_base = vpn_min;
+        vseg->vpn_size = vpn_max - vpn_min + 1;
+        error = 0;
+    }
+        else if( vseg->max == addr_max )                          // vseg must be resized
+    {
+        // update vseg max address
+        vseg->max = addr_min;
+
+        // update vpn_base and vpn_size
+        vpn_min        = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
+        vpn_max        = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
+        vseg->vpn_base = vpn_min;
+        vseg->vpn_size = vpn_max - vpn_min + 1;
+        error = 0;
+    }
+    else                                                      // vseg cut in three regions 
+    {
+        // resize existing vseg
+        vseg->max = addr_min;
+
+        // update vpn_base and vpn_size
+        vpn_min        = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
+        vpn_max        = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
+        vseg->vpn_base = vpn_min;
+        vseg->vpn_size = vpn_max - vpn_min + 1;
+
+        // create new vseg
+        new = vmm_create_vseg( process , addr_min , (vseg->max - addr_max) , vseg->type ); 
+        if( new == NULL ) error = EINVAL;
+        else              error = 0;
     }
 
@@ -716 +764 @@
 
         return error;
-}
+
+}  // vmm_resize_vseg()
 
 ///////////////////////////////////////////
@@ -723 +772 @@
                        vseg_t   ** found_vseg )
 {
-    vmm_t    * vmm;
-    vseg_t   * vseg;
-
-    // get pointer on process VMM
-    vmm = &process->vmm;
-
-    // get lock protecting the vseg list
-    rwlock_rd_lock( &vmm->vsegs_lock );
-
-    // get pointer on vseg from local radix tree
-        vseg = grdxt_lookup( &vmm->grdxt, (uint32_t)(vaddr >> CONFIG_PPM_PAGE_SHIFT) );
-
-    // release the lock
-    rwlock_rd_unlock( &vmm->vsegs_lock );
+    vmm_t  * vmm = &process->vmm;
+
+    // get vseg from vaddr
+    vseg_t * vseg = vseg_from_vaddr( vmm , vaddr );
 
     if( vseg == NULL )   // vseg not found in local cluster => try to get it from ref
@@ -752 +791 @@
         xptr_t   vseg_xp;
         error_t  error;
+
         rpc_vmm_get_vseg_client( ref_cxy , ref_ptr , vaddr , &vseg_xp , &error );
             
@@ -759 +799 @@
         vseg = vseg_alloc();
 
-        if( vseg == NULL ) panic("no memory for vseg copy in cluster %x", local_cxy );
+        if( vseg == NULL ) return -1;
 
         // initialise local vseg from reference
@@ -765 +805 @@
 
         // register local vseg in local VMM
-        error = vseg_attach( &process->vmm , vseg );
-
-        if( error ) panic("no memory for vseg registration in cluster %x", local_cxy );
+        vseg_attach( &process->vmm , vseg );
     }   
     
@@ -784 +822 @@
     cxy_t      page_cxy;          // physical page cluster
     page_t   * page_ptr;          // local pointer on physical page descriptor
-
-    uint32_t   type      = vseg->type;
-    xptr_t     mapper_xp = vseg->mapper_xp;
-    uint32_t   flags     = vseg->flags;
-
-    // get mapper cluster and local pointer
-    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
-    mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
-
-    // FILE type : simply get the physical page from the file mapper
+    uint32_t   index;             // missing page index in vseg mapper
+    uint32_t   type;              // vseg type;
+
+    type      = vseg->type;
+    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 );
+
+    // FILE type : get the physical page from the file mapper
     if( type == VSEG_TYPE_FILE )
     {
-        // compute index in file mapper
-        uint32_t index = vpn - vseg->vpn_base;
+        // get extended pointer on mapper
+        xptr_t     mapper_xp = vseg->mapper_xp;
+
+        assert( (mapper_xp != XPTR_NULL), __FUNCTION__,
+        "mapper not defined for a FILE vseg\n" );
+        
+        // get mapper cluster and local pointer
+        cxy_t      mapper_cxy = GET_CXY( mapper_xp );
+        mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
 
         // get page descriptor from mapper
@@ -814 +859 @@
     }
 
-    // all other types : allocate a physical page from target cluster,
+    // Other types : allocate a physical page from target cluster,
     else
     {
+        uint32_t flags = vseg->flags;
+
         // get target cluster for physical page
         if( flags & VSEG_DISTRIB ) // depends on VPN LSB
         {
-            uint32_t x_width = LOCAL_CLUSTER->x_width;
-            uint32_t y_width = LOCAL_CLUSTER->y_width;
-            page_cxy = vpn & ((1<<(x_width + y_width)) - 1);
+            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
@@ -831 +878 @@
         // allocate a physical page in target cluster
         kmem_req_t   req;
-        if( page_cxy == local_cxy )    // target cluster is the local cluster
+        if( page_cxy == local_cxy )  // target cluster is the local cluster
         {
             req.type  = KMEM_PAGE;
@@ -845 +892 @@
         if( page_ptr == NULL ) return ENOMEM;
 
-        // initialise page from .elf file mapper for DATA and CODE types
+        // initialise missing page from .elf file mapper for DATA and CODE types
+        // => the mapper_xp field is an extended pointer on the .elf file mapper
         if( (type == VSEG_TYPE_CODE) || (type == VSEG_TYPE_DATA) )
         {
-            // compute missing page index in vseg
-            vpn_t page_index = vpn - vseg->vpn_base;
+            // get extended pointer on mapper
+            xptr_t     mapper_xp = vseg->mapper_xp;
+
+            assert( (mapper_xp != XPTR_NULL), __FUNCTION__,
+            "mapper not defined for a CODE or DATA vseg\n" );
+        
+            // get mapper cluster and local pointer
+            cxy_t      mapper_cxy = GET_CXY( mapper_xp );
+            mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
+
+            // compute missing page offset in vseg
+            uint32_t offset = index << CONFIG_PPM_PAGE_SHIFT;
 
             // compute missing page offset in .elf file
-            intptr_t page_offset = vseg->file_offset + 
-                                   (page_index << CONFIG_PPM_PAGE_SHIFT);
-
-            // compute extended pointer on page first byte 
-            xptr_t base_xp = ppm_page2base( XPTR( page_cxy , page_ptr ) );
-
-            // file_size can be smaller than vseg_size for BSS
-            intptr_t file_size = vseg->file_size;
-
-            if( file_size < page_offset )                                // fully in  BSS 
+            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 );
+
+            // compute extended pointer on page base 
+            xptr_t base_xp  = ppm_page2base( XPTR( page_cxy , page_ptr ) );
+
+            // file_size (in .elf mapper) can be smaller than vseg_size (BSS)
+            uint32_t file_size = vseg->file_size;
+
+            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 )
                 {
@@ -872 +935 @@
                 }
             }
-            else if( file_size >= (page_offset + CONFIG_PPM_PAGE_SIZE) )  // fully in  mapper
+            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 );
+
                 if( mapper_cxy == local_cxy ) 
                 {
                     error = mapper_move_kernel( mapper_ptr,
                                                 true,             // to_buffer
-                                                page_offset,
+                                                elf_offset,
                                                 base_xp,
                                                 CONFIG_PPM_PAGE_SIZE ); 
@@ -888 +954 @@
                                                    true,         // to buffer
                                                    false,        // kernel buffer
-                                                   page_offset,
-                                                   (uint64_t)base_xp,
+                                                   elf_offset,
+                                                   base_xp,
                                                    CONFIG_PPM_PAGE_SIZE,
                                                    &error );
@@ -895 +961 @@
                 if( error ) return EINVAL;
             }
-            else  // in mapper : from page_offset -> (file_size - page_offset)
-                  // in BSS    : from file_size   -> (page_offset + page_size)
+            else  // both in mapper and in BSS :
+                  // - (file_size - offset)             bytes from mapper
+                  // - (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  );
+
                 // initialize mapper part
                 if( mapper_cxy == local_cxy )
@@ -903 +975 @@
                     error = mapper_move_kernel( mapper_ptr,
                                                 true,         // to buffer
-                                                page_offset,
+                                                elf_offset,
                                                 base_xp,
-                                                file_size - page_offset ); 
+                                                file_size - offset ); 
                 }
                 else                                
@@ -913 +985 @@
                                                    true,         // to buffer
                                                    false,        // kernel buffer
-                                                   page_offset,
-                                                   (uint64_t)base_xp,
-                                                   file_size - page_offset, 
+                                                   elf_offset,
+                                                   base_xp,
+                                                   file_size - offset, 
                                                    &error );
                 }
@@ -923 +995 @@
                 if( page_cxy == local_cxy )
                 {
-                    memset( GET_PTR( base_xp ) + file_size - page_offset , 0 , 
-                            page_offset + CONFIG_PPM_PAGE_SIZE - file_size );
+                    memset( GET_PTR( base_xp ) + file_size - offset , 0 , 
+                            offset + CONFIG_PPM_PAGE_SIZE - file_size );
                 }
                 else
                 {
-                   hal_remote_memset( base_xp + file_size - page_offset , 0 , 
-                                      page_offset + CONFIG_PPM_PAGE_SIZE - file_size );
+                   hal_remote_memset( base_xp + file_size - offset , 0 , 
+                                      offset + CONFIG_PPM_PAGE_SIZE - file_size );
                 }
             }    
@@ -937 +1009 @@
     // 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 );
+
     return 0;
 
@@ -954 +1030 @@
     // this function must be called by a thread running in the reference cluster
     assert( (GET_CXY( process->ref_xp ) == local_cxy ) , __FUNCTION__ ,
-             " not called in the reference cluster\n" );
+    "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 );
 
     // get VMM pointer
@@ -968 +1047 @@
     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 );
@@ -977 +1059 @@
             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
@@ -1005 +1091 @@
     }  // 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;

trunk/kernel/mm/vmm.h

@@ -30 +30 @@
 #include <bits.h>
 #include <list.h>
-#include <grdxt.h>
 #include <spinlock.h>
 #include <hal_gpt.h>
@@ -92 +91 @@
  * 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,
- *    and in the associated radix-tree.
- * 2) It allocates virtual memory space for the STACKS and MMAP vsegs,
- *    using dedicated allocators.
+ * 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.
  * 3) It contains the local copy of the generic page table descriptor.
  ********************************************************************************************/
@@ -104 +101 @@
         list_entry_t   vsegs_root;         /*! all vsegs in same process and same cluster       */
         uint32_t       vsegs_nr;           /*! total number of local vsegs                      */
-        grdxt_t        grdxt;              /*! embedded generic vsegs radix tree (key is vpn)   */
 
     gpt_t          gpt;                /*! embedded generic page table descriptor           */
@@ -144 +140 @@
 
 /*********************************************************************************************
- * This function initialises the virtual memory manager attached to a process.
- * - It initializes the VSL (list of vsegs and associated radix tree).
- * - It initializes the generic page table (empty).
+ * 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 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.
- * - It registers the "kentry", "args", "envs" and "heap" vsegs in the vsegs list.
- * Any error in this function gives a kernel panic.
+ * TODO : Any error in this function gives a kernel panic => improve error handling.
  *********************************************************************************************
  * @ process   : pointer on process descriptor
@@ -249 +248 @@
  * (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.
- * (c) if the removed region cut the vseg in two parts, it is removed and re-created.
- * (d) if the removed region cut the vseg in three parts, it is removed, and two are created.
- * TODO : cases (c) and (d) are not implemented [AG]
+ * (c) if the removed region cut the vseg in two parts, it is modified.
+ * (d) if the removed region cut the vseg in three parts, it is modified, and a new
+ *     vseg is created with same type.
  *********************************************************************************************
  * @ process   : pointer on process descriptor
@@ -267 +266 @@
  * - if the vseg is missing in local VMM, it uses a RPC to get it from the reference cluster,
  *   register it in local VMM and returns the local vseg pointer, if success.
- * - if the vseg is missing in reference VMM, it returns an user error.
- * It creates a kernel panic if there is not enough memory to create a new vseg descriptor
- * in the cluster containing the calling thread.
+ * - it returns an user error if the vseg is missing in the reference VMM, or if there is 
+ *   not enough memory for a new vseg descriptor in cluster containing the calling thread.
  *********************************************************************************************
  * @ process   : [in] pointer on process descriptor
@@ -320 +318 @@
  * Depending on the vseg type, defined by the <vseg> argument, it returns the PPN 
  * (Physical Page Number) associated to a missing page defined by the <vpn> argument.
- * - For the VSEG_TYPE_FILE, it returns the physical page from the file mapper.
- *   For all other types, it allocates a new physical page from the cluster defined
- *   by the <vseg->cxy> field, or by the <vpn> MSB bits for a distributed vseg.
- * - For the VSEG_TYPE_CODE and VSEG_TYPE_DATA types, the allocated page is initialized
- *   from the .elf file mapper. For others vseg types it is not initialised.
+ * - For the FILE type, it returns directly the physical page from the file mapper.
+ * - For the CODE and DATA types, it allocates a new phsical page from the cluster defined
+ *   by the <vseg->cxy> field, or by the <vpn> MSB bits for a distributed vseg,
+ *   and initialize this page from the .elf file mapper.
+ * - For all other types, it allocates a new physical page from the cluster defined
+ *   by the <vseg->cxy> field, or by the <vpn> MSB bits for a distributed vseg,
+ *   but the new page is not initialized.
  *********************************************************************************************
  * @ vseg   : local pointer on vseg containing the mising page.

trunk/kernel/mm/vseg.c

@@ -188 +188 @@
 
 ///////////////////////////////
-error_t vseg_attach( vmm_t  * vmm,
-                     vseg_t * vseg )
-{
-    // add vseg in radix-tree
-    error_t error = grdxt_insert( &vmm->grdxt , vseg->vpn_base , vseg );
-    if ( error ) return ENOMEM;
-
+void vseg_attach( vmm_t  * vmm,
+                  vseg_t * vseg )
+{
     // update vseg descriptor
     vseg->vmm = vmm;
@@ -200 +196 @@
     // add vseg in vmm list
     list_add_last( &vmm->vsegs_root , &vseg->list );
-
-    return 0;
 }
 
@@ -208 +202 @@
                   vseg_t * vseg )
 {
-    // remove vseg from radix-tree
-    grdxt_remove( &vmm->grdxt , vseg->vpn_base );
-
     // update vseg descriptor
     vseg->vmm = NULL;

trunk/kernel/mm/vseg.h

@@ -149 +149 @@
  * @ vmm       : pointer on the VMM
  * @ vseg      : pointer on the vseg descriptor
- * @ returns 0 if success / returns ENOMEM if registration in GRDXT unpossible. 
  *********************************************************************************************/
-error_t vseg_attach( struct vmm_s  * vmm,
-                     vseg_t        * vseg );
+void vseg_attach( struct vmm_s  * vmm,
+                  vseg_t        * vseg );
 
 /**********************************************************************************************