Changeset 656 for trunk/kernel/mm

Timestamp:

Dec 6, 2019, 12:07:51 PM (5 years ago)

Author:

alain

Message:

Fix several bugs in the FATFS and in the VFS,
related to the creation of big files requiring
more than 4 Kbytes (one cluster) on device.

Location:

trunk/kernel/mm

Files:

• kcm.c (modified) (3 diffs)
• kmem.c (modified) (12 diffs)
• kmem.h (modified) (2 diffs)
• mapper.c (modified) (16 diffs)
• mapper.h (modified) (3 diffs)
• page.h (modified) (1 diff)
• ppm.c (modified) (21 diffs)
• ppm.h (modified) (3 diffs)
• vmm.c (modified) (29 diffs)
• vmm.h (modified) (2 diffs)

trunk/kernel/mm/kcm.c

@@ -509 +509 @@
         {
         // get one 4 Kbytes page from remote PPM
-        page_t * page = ppm_remote_alloc_pages( kcm_cxy , 0 );
-
-            if( page == NULL )
+        xptr_t page_xp = ppm_remote_alloc_pages( kcm_cxy , 0 );
+
+            if( page_xp == XPTR_NULL )
             {
                     printk("\n[ERROR] in %s : failed to allocate page in cluster %x\n",
@@ -519 +519 @@
         }
 
-            // get remote page base address
-            xptr_t base_xp = ppm_page2base( XPTR( kcm_cxy , page ) );
+            // get extended pointer on allocated buffer
+            xptr_t base_xp = ppm_page2base( page_xp );
 
         // get local pointer on kcm_page
@@ -529 +529 @@
             hal_remote_s64( XPTR( kcm_cxy , &kcm_page->status ) , 0 );
             hal_remote_spt( XPTR( kcm_cxy , &kcm_page->kcm )    , kcm_ptr );
-            hal_remote_spt( XPTR( kcm_cxy , &kcm_page->page )   , page );
+            hal_remote_spt( XPTR( kcm_cxy , &kcm_page->page )   , GET_PTR( page_xp ) );
 
             // introduce new page in remote KCM active_list

trunk/kernel/mm/kmem.c

@@ -45 +45 @@
         flags = req->flags;
 
-    ////////////////////////////////// PPM 
+    ////////////////////// 
         if( type == KMEM_PPM )
         {
@@ -76 +76 @@
         return ptr;
         }
-    ///////////////////////////////////// KCM 
+    /////////////////////////// 
         else if( type == KMEM_KCM )
         {
@@ -102 +102 @@
         return ptr;
         }
-    //////////////////////////////////// KHM 
+    /////////////////////////// 
         else if( type == KMEM_KHM )
         {
@@ -140 +140 @@
     uint32_t type = req->type;
 
+    //////////////////////
         if( type == KMEM_PPM )
         {
@@ -146 +147 @@
         ppm_free_pages( page );
     }
+    ///////////////////////////
     else if( type == KMEM_KCM )
     {
         kcm_free( req->ptr );
         }
+    ///////////////////////////
     else if( type == KMEM_KHM )
     {
@@ -172 +175 @@
         flags = req->flags;
 
-        ///////////////////////////////// PPM
-        if( type == KMEM_PPM )
-        {
-                // allocate the number of requested pages
-                page_t * page_ptr = ppm_remote_alloc_pages( cxy , order );
-
-                if( page_ptr == NULL )
+        //////////////////////
+        if( type == KMEM_PPM )
+        {
+                // allocate the number of requested pages from remote cluster
+                xptr_t page_xp = ppm_remote_alloc_pages( cxy , order );
+
+                if( page_xp == XPTR_NULL )
                 {
                         printk("\n[ERROR] in %s : failed for PPM / order %d in cluster %x\n",
@@ -185 +188 @@
                 }
 
-        xptr_t page_xp = XPTR( cxy , page_ptr );
-
-        // get pointer on buffer from the page descriptor
+        // get extended pointer on remote buffer
         xptr_t base_xp = ppm_page2base( page_xp );
 
@@ -193 +194 @@
                 if( flags & AF_ZERO ) hal_remote_memset( base_xp , 0 , CONFIG_PPM_PAGE_SIZE );
 
-        void * ptr = GET_PTR( base_xp );
 
 #if DEBUG_KMEM_REMOTE
@@ -201 +201 @@
 printk("\n[%s] thread[%x,%x] from PPM / %d page(s) / ppn %x / cxy %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
-1<<order, ppm_page2ppn(XPTR(local_cxy,ptr)), cxy, cycle );
-#endif
-        return ptr;
-        }
-    /////////////////////////////////// KCM
+1<<order, ppm_page2ppn( page_xp ), cxy, cycle );
+#endif
+        return GET_PTR( base_xp );
+        }
+    ///////////////////////////
         else if( type == KMEM_KCM ) 
         {
@@ -231 +231 @@
         return ptr;
         }
-        /////////////////////////////////// KHM 
+        /////////////////////////// 
         else if( type == KMEM_KHM )                
         {
@@ -250 +250 @@
     uint32_t type = req->type;
 
+    //////////////////////
         if( type == KMEM_PPM )
         {
@@ -256 +257 @@
         ppm_remote_free_pages( cxy , page );
     }
+    ///////////////////////////
     else if( type == KMEM_KCM )
     {
         kcm_remote_free( cxy , req->ptr );
         }
+    ///////////////////////////
     else if( type == KMEM_KHM )
     {

trunk/kernel/mm/kmem.h

@@ -29 +29 @@
 
 /*************************************************************************************
- * This enum defines the three Kernel Memory Allocaror types: 
+ * This enum defines the three Kernel Memory Allocaror types 
  ************************************************************************************/
 
@@ -71 +71 @@
  * - KHM (Kernel Heap Manager) allocates physical memory buffers of M bytes,
  *       M can have any value, and req.order = M.
+ *
+ * WARNING: the physical memory allocated with a given allocator type must be
+ *          released using the same allocator type.
  *************************************************************************************
  * @ cxy   : target cluster identifier for a remote access.

trunk/kernel/mm/mapper.c

@@ -27 +27 @@
 #include <hal_special.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <grdxt.h>
 #include <string.h>
@@ -141 +142 @@
     error_t    error;
 
+    uint32_t   inode_size;    
+    uint32_t   inode_type;
+
     thread_t * this = CURRENT_THREAD;
 
     // get target mapper cluster and local pointer
-    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
-    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+    cxy_t         mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t    * mapper_ptr = GET_PTR( mapper_xp );
+
+    // get inode pointer
+    vfs_inode_t * inode = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
+
+    // get inode size and type if relevant
+    if( inode != NULL )
+    {
+        inode_size = hal_remote_l32( XPTR( mapper_cxy , &inode->size ) );
+        inode_type = hal_remote_l32( XPTR( mapper_cxy , &inode->type ) );
+    }
+    else
+    {
+        inode_size = 0;
+        inode_type = 0;
+    }
 
 #if DEBUG_MAPPER_HANDLE_MISS
 uint32_t      cycle = (uint32_t)hal_get_cycles();
 char          name[CONFIG_VFS_MAX_NAME_LENGTH];
-vfs_inode_t * inode = mapper->inode;
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
 {
-    vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
-    printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cluster %x / cycle %d",
+    vfs_inode_get_name( XPTR( mapper_cxy , inode ) , name );
+    printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cxy %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, page_id, name, mapper_cxy, cycle );
-    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), name );
 }
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
 {
-    printk("\n[%s] thread[%x,%x] enter for page %d in FAT / cluster %x / cycle %d",
+    printk("\n[%s] thread[%x,%x] enter for page %d in FAT / cxy %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, page_id, mapper_cxy, cycle );
-    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), "FAT" );
+}
+#endif
+
+#if( DEBUG_MAPPER_HANDLE_MISS & 2 ) 
+if( DEBUG_MAPPER_HANDLE_MISS < cycle ) 
+{
+    if (inode != NULL) grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , name );
+    else               grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , "FAT" );
 }
 #endif
 
     // allocate one 4 Kbytes page from the remote mapper cluster
-    page_t * page_ptr = ppm_remote_alloc_pages( mapper_cxy , 0 );
+    xptr_t page_xp = ppm_remote_alloc_pages( mapper_cxy , 0 );
+    page_t * page_ptr = GET_PTR( page_xp );
                             
-    if( page_ptr == NULL )
+    if( page_xp == XPTR_NULL )
     {
         printk("\n[ERROR] in %s : thread [%x,%x] cannot allocate page in cluster %x\n",
@@ -176 +201 @@
     }
 
-    // build extended pointer on new page descriptor
-    xptr_t page_xp = XPTR( mapper_cxy , page_ptr );
-
     // initialize the page descriptor 
     page_remote_init( page_xp );
 
+    // initialize specific page descriptor fields
     hal_remote_s32( XPTR( mapper_cxy , &page_ptr->refcount ) , 1          );
     hal_remote_s32( XPTR( mapper_cxy , &page_ptr->index )    , page_id    );
@@ -200 +223 @@
     }
 
-    // launch I/O operation to load page from IOC device to mapper
-    error = vfs_fs_move_page( page_xp , IOC_SYNC_READ );
-
-    if( error )
-    {
-        printk("\n[ERROR] in %s : thread[%x,%x] cannot load page from device\n",
-        __FUNCTION__ , this->process->pid, this->trdid );
-        mapper_remote_release_page( mapper_xp , page_ptr );
-        return -1;
+    // launch I/O operation to load page from IOC device when required:
+    // - it is the FAT mapper
+    // - it is a directory mapper
+    // - it is a file mapper, and it exist data on IOC device for this page
+    if( (inode == NULL) || (inode_type == INODE_TYPE_DIR) || (inode_size > (page_id << 10) ) )
+    {
+        error = vfs_fs_move_page( page_xp , IOC_SYNC_READ );
+
+        if( error )
+        {
+            printk("\n[ERROR] in %s : thread[%x,%x] cannot load page from device\n",
+            __FUNCTION__ , this->process->pid, this->trdid );
+            mapper_remote_release_page( mapper_xp , page_ptr );
+            return -1;
+         }
     }
 
@@ -215 +244 @@
 
 #if DEBUG_MAPPER_HANDLE_MISS
-cycle = (uint32_t)hal_get_cycles();
+ppn_t ppn = ppm_page2ppn( page_xp );
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d in <%s> / ppn %x / cycle %d",
-    __FUNCTION__, this->process->pid, this->trdid,
-    page_id, name, ppm_page2ppn( page_xp ), cycle );
-    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt) , name );
+    printk("\n[%s] thread[%x,%x] exit for page %d in <%s> / page %x / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, page_ptr, ppn );
 }
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d in FAT / ppn %x / cycle %d",
-    __FUNCTION__, this->process->pid, this->trdid,
-    page_id, ppm_page2ppn( page_xp ), cycle );
-    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt ), "FAT" );
+    printk("\n[%s] thread[%x,%x] exit for page %d in FAT / page %x / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, page_ptr, ppn );
+}
+#endif
+
+#if( DEBUG_MAPPER_HANDLE_MISS & 2 ) 
+if( DEBUG_MAPPER_HANDLE_MISS < cycle ) 
+{
+    if (inode != NULL) grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , name );
+    else               grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , "FAT" );
 }
 #endif
@@ -241 +274 @@
 {
     error_t       error;
-    mapper_t    * mapper_ptr;
-    cxy_t         mapper_cxy;
-    xptr_t        lock_xp;        // extended pointer on mapper lock
-    xptr_t        page_xp;        // extended pointer on searched page descriptor
-    xptr_t        rt_xp;          // extended pointer on radix tree in mapper
 
     thread_t * this = CURRENT_THREAD;
 
     // get mapper cluster and local pointer
-    mapper_ptr = GET_PTR( mapper_xp );
-    mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
 
 #if DEBUG_MAPPER_GET_PAGE
@@ -270 +298 @@
 #endif
 
+#if( DEBUG_MAPPER_GET_PAGE & 2 )
+if( DEBUG_MAPPER_GET_PAGE < cycle ) 
+ppm_remote_display( local_cxy );
+#endif
+
     // check thread can yield
     thread_assert_can_yield( this , __FUNCTION__ );
 
     // build extended pointer on mapper lock and mapper rt
-    lock_xp  = XPTR( mapper_cxy , &mapper_ptr->lock );
-    rt_xp    = XPTR( mapper_cxy , &mapper_ptr->rt );
+    xptr_t lock_xp  = XPTR( mapper_cxy , &mapper_ptr->lock );
+    xptr_t rt_xp    = XPTR( mapper_cxy , &mapper_ptr->rt );
 
     // take mapper lock in READ_MODE
@@ -281 +314 @@
 
     // search page in radix tree
-    page_xp  = grdxt_remote_lookup( rt_xp , page_id );
+    xptr_t page_xp  = grdxt_remote_lookup( rt_xp , page_id );
 
     // test mapper miss 
@@ -310 +343 @@
 
 #if (DEBUG_MAPPER_GET_PAGE & 1)
-if( DEBUG_MAPPER_GET_PAGE < cycle )
-printk("\n[%s] thread[%x,%x] load missing page from FS : ppn %x\n",
-__FUNCTION__, this->process->pid, this->trdid, ppm_page2ppn(page_xp) );
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )
+{
+    printk("\n[%s] thread[%x,%x] introduced missing page in <%s> mapper / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, name, ppm_page2ppn(page_xp) );
+}
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] introduced missing page in FAT mapper / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, ppm_page2ppn(page_xp) );
+}
 #endif
         
@@ -328 +368 @@
 if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d of <%s> mapper / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id,
-    name, ppm_page2ppn(page_xp), cycle );
+    printk("\n[%s] thread[%x,%x] exit for page %d of <%s> mapper / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, ppm_page2ppn(page_xp) );
 }
 if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode == NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d of FAT mapper  / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id,
-    ppm_page2ppn(page_xp), cycle );
-}
+    printk("\n[%s] thread[%x,%x] exit for page %d of FAT mapper  / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, ppm_page2ppn(page_xp) );
+}
+#endif
+
+#if( DEBUG_MAPPER_GET_PAGE & 2)
+if( DEBUG_MAPPER_GET_PAGE < cycle ) 
+ppm_remote_display( local_cxy );
 #endif
 
@@ -476 +519 @@
 __FUNCTION__, this->process->pid, this->trdid, page_bytes,
 local_cxy, buf_ptr, name, GET_CXY(map_xp), GET_PTR(map_xp) );
-mapper_display_page(  mapper_xp , page_id, 128 );
+mapper_display_page(  mapper_xp , page_xp , 128 );
 #endif
 
@@ -600 +643 @@
 {
     if( to_buffer )
-    printk("\n[%s] mapper <%s> page %d => buffer(%x,%x) / %d bytes\n",
+    printk("\n[%s] mapper <%s> page %d => buffer (%x,%x) / %d bytes\n",
     __FUNCTION__, name, page_id, dst_cxy, dst_ptr, page_bytes );
     else
-    printk("\n[%s] buffer(%x,%x) => mapper <%s> page %d / %d bytes\n",
+    printk("\n[%s] buffer (%x,%x) => mapper <%s> page %d / %d bytes\n",
     __FUNCTION__, src_cxy, src_ptr, name, page_id, page_bytes );
 }
@@ -617 +660 @@
 cycle  = (uint32_t)hal_get_cycles();
 if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
-printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, cycle );
+printk("\n[%s] thread[%x,%x] exit / mapper <%s> / buffer (%x,%x) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, buffer_cxy, buffer_ptr, cycle );
 #endif
 
@@ -707 +750 @@
         if( page == NULL ) break;
 
-assert( (page->index == found_key ), "wrong page descriptor index" );
-assert( (page->order == 0),          "mapper page order must be 0" );
+assert( (page->index == found_key ), "page_index (%d) != key (%d)", page->index, found_key );
+assert( (page->order == 0), "page_order (%d] != 0", page->order );
 
         // build extended pointer on page descriptor
@@ -753 +796 @@
 }  // end mapper_sync()
 
-//////////////////////////////////////////////////
-error_t mapper_display_page( xptr_t     mapper_xp,
-                             uint32_t   page_id,
-                             uint32_t   nbytes )
-{
-    xptr_t        page_xp;        // extended pointer on page descriptor
-    xptr_t        base_xp;        // extended pointer on page base
+///////////////////////////////////////////////
+void mapper_display_page( xptr_t     mapper_xp,
+                          xptr_t     page_xp,
+                          uint32_t   nbytes )
+{
     char          buffer[4096];   // local buffer
-    uint32_t    * tabi;           // pointer on uint32_t to scan buffer
     uint32_t      line;           // line index
     uint32_t      word;           // word index
-    cxy_t         mapper_cxy;     // mapper cluster identifier
-    mapper_t    * mapper_ptr;     // mapper local pointer
-    vfs_inode_t * inode_ptr;      // inode local pointer
  
     char       name[CONFIG_VFS_MAX_NAME_LENGTH];
 
-    if( nbytes > 4096)
-    {
-        printk("\n[ERROR] in %s : nbytes (%d) cannot be larger than 4096\n",
-        __FUNCTION__, nbytes );
-        return -1;
-    }
-    
-    // get extended pointer on page descriptor
-    page_xp = mapper_remote_get_page( mapper_xp , page_id );
-
-    if( page_xp == XPTR_NULL)
-    {
-        printk("\n[ERROR] in %s : cannot access page %d in mapper\n",
-        __FUNCTION__, page_id );
-        return -1;
-    }
-
-    // get cluster and local pointer
-    mapper_cxy = GET_CXY( mapper_xp );
-    mapper_ptr = GET_PTR( mapper_xp );
+assert( (nbytes <= 4096)         , "nbytes cannot be larger than 4096");
+assert( (mapper_xp != XPTR_NULL) , "mapper_xp argument cannot be null");
+assert( (page_xp   != XPTR_NULL) , "page_xp argument cannot be null");
+
+    // get mapper cluster and local pointer
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+
+    // get page cluster an local pointer
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+    // get page_id and mapper from page descriptor
+    uint32_t   page_id = hal_remote_l32( XPTR( page_cxy , &page_ptr->index ) );
+    mapper_t * mapper  = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
+
+assert( (mapper_cxy == page_cxy ) , "mapper and page must be in same cluster");
+assert( (mapper_ptr == mapper   ) , "unconsistent mapper_xp & page_xp arguments");
 
     // get inode
-    inode_ptr = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
+    vfs_inode_t * inode_ptr = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
 
     // get inode name
-    if( inode_ptr == NULL ) strcpy( name , "fat" );
+    if( inode_ptr == NULL ) strcpy( name , "FAT" );
     else  vfs_inode_get_name( XPTR( mapper_cxy , inode_ptr ) , name );
     
     // get extended pointer on page base
-    base_xp = ppm_page2base( page_xp );
+    xptr_t base_xp = ppm_page2base( page_xp );
    
     // copy remote page to local buffer
     hal_remote_memcpy( XPTR( local_cxy , buffer ) , base_xp , nbytes );
 
+    // display header
+    uint32_t * tabi = (uint32_t *)buffer;
+    printk("\n***** mapper <%s> / page_id %d / cxy %x / mapper %x / buffer %x\n",
+    name, page_id, mapper_cxy, mapper_ptr, GET_PTR( base_xp ) );
+
     // display 8 words per line
-    tabi = (uint32_t *)buffer;
-    printk("\n***** mapper <%s> / %d bytes in page %d (%x,%x)\n",
-    name, nbytes, page_id, GET_CXY(base_xp), GET_PTR(base_xp) );
     for( line = 0 ; line < (nbytes >> 5) ; line++ )
     {
@@ -815 +852 @@
     }
 
-    return 0;
-
-}  // end mapper_display_page
-
-
+}  // end mapper_display_page()
+
+

trunk/kernel/mm/mapper.h

@@ -62 +62 @@
  *   and the  allocated memory is only released when the mapper/inode is destroyed.
  *
- * TODO (1) the mapper being only used to implement the VFS cache(s), the mapper.c
- *          and mapper.h file should be trandfered to the fs directory.
- * TODO (2) the "type" field in mapper descriptor is redundant and probably unused. 
+ * TODO the "type" field in mapper descriptor is redundant and probably unused. 
  ******************************************************************************************/
 
@@ -161 +159 @@
 
 /********************************************************************************************
- * This function move data between a remote mapper, identified by the <mapper_xp> argument,
- * and a localised remote kernel buffer. It can be called by a thread running any cluster. 
+ * This function move <size> bytes from/to a remote mapper, identified by the <mapper_xp>
+ * argument, to/from a remote kernel buffer, identified by the <buffer_xp> argument.
+ * It can be called by a thread running in any cluster. 
  * If required, the data transfer is split in "fragments", where one fragment contains 
- * contiguous bytes in the same mapper page.
- * It uses a "remote_memcpy" to move a fragment to/from the kernel buffer.
- * In case of write, the dirty bit is set for all pages written in the mapper.
+ * contiguous bytes in the same mapper page. Each fragment uses a "remote_memcpy".
+ * In case of write to mapper, the dirty bit is set for all pages written in the mapper.
  *******************************************************************************************
  * @ mapper_xp    : extended pointer on mapper.
@@ -248 +246 @@
 
 /*******************************************************************************************
- * This debug function displays the content of a given page of a given mapper.
- * - the mapper is identified by the <mapper_xp> argument.
- * - the page is identified by the <page_id> argument.
- * - the number of bytes to display in page is defined by the <nbytes> argument.
+ * This debug function displays the content of a given page of a given mapper, identified
+ * by the <mapper_xp> and <page_xp> arguments.
+ * The number of bytes to display in page is defined by the <nbytes> argument.
  * The format is eigth (32 bits) words per line in hexadecimal.
  * It can be called by any thread running in any cluster.
- * In case of miss in mapper, it load the missing page from device to mapper.
  *******************************************************************************************
  * @ mapper_xp  : [in]  extended pointer on the mapper.
- * @ page_id    : [in]  page index in file.
- * @ nbytes     : [in]  value to be written.
- * @ returns 0 if success / return -1 if error.
- ******************************************************************************************/
-error_t mapper_display_page( xptr_t     mapper_xp,
-                             uint32_t   page_id,
-                             uint32_t   nbytes );
+ * @ page_xp    : [in]  extended pointer on page descriptor.
+ * @ nbytes     : [in]  number of bytes in page.
+ * @ returns 0 if success / return -1 if error.
+ ******************************************************************************************/
+void mapper_display_page( xptr_t     mapper_xp,
+                          xptr_t     page_xp,
+                          uint32_t   nbytes );
 
 

trunk/kernel/mm/page.h

@@ -49 +49 @@
  * - The remote_busylock is used to allows any remote thread to atomically
  *   test/modify the forks counter or the flags.
- * - The list entry is used to register the page in a free list or in dirty list.
- *   The refcount is used for page release to KMEM.
+ * - The list field is used to register the page in a free list, or in dirty list,
+ *   as a given page cannot be simultaneously dirty and free.
+ * - The refcount is used to release the page to the PPM.
  * NOTE: the size is 48 bytes for a 32 bits core.
  ************************************************************************************/

trunk/kernel/mm/ppm.c

@@ -151 +151 @@
         page_t   * buddy;               // searched buddy page descriptor
         uint32_t   buddy_index;         // buddy page index in page_tbl[]
-        page_t   * current;             // current (merged) page descriptor
+        page_t   * current_ptr;         // current (merged) page descriptor
         uint32_t   current_index;       // current (merged) page index in page_tbl[]
         uint32_t   current_order;       // current (merged) page order
@@ -168 +168 @@
 
     // initialise loop variables
-    current       = page;
+    current_ptr   = page;
     current_order = page->order;
         current_index = page - ppm->pages_tbl;
@@ -191 +191 @@
                 buddy->order = 0;
 
-                // compute next (merged) page index in page_tbl[]
+                // compute next values for loop variables
                 current_index &= buddy_index;
-
-        // compute next (merged) page order
         current_order++;
-
-        // compute next (merged) page descripror
-        current = pages_tbl + current_index; 
+        current_ptr = pages_tbl + current_index; 
     }
 
         // update order field for merged page descriptor 
-        current->order = current_order;
+        current_ptr->order = current_order;
 
         // insert merged page in relevant free list
-        list_add_first( &ppm->free_pages_root[current_order] , &current->list );
+        list_add_first( &ppm->free_pages_root[current_order] , &current_ptr->list );
         ppm->free_pages_nr[current_order] ++;
 
 }  // end ppm_free_pages_nolock()
-
 
 ////////////////////////////////////////////
@@ -221 +216 @@
     thread_t * this = CURRENT_THREAD;
 
+        ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
+
 #if DEBUG_PPM_ALLOC_PAGES
 uint32_t cycle = (uint32_t)hal_get_cycles();
 #endif
 
-#if (DEBUG_PPM_ALLOC_PAGES & 1)
+#if DEBUG_PPM_ALLOC_PAGES 
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
 {
     printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, 1<<order, local_cxy, cycle );
-    ppm_remote_display( local_cxy );
-}
-#endif
-
-        ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
+    if( DEBUG_PPM_ALLOC_PAGES & 1 ) ppm_remote_display( local_cxy );
+}
+#endif
 
 // check order
@@ -316 +311 @@
     dqdt_increment_pages( local_cxy , order );
 
+    hal_fence();
+
 #if DEBUG_PPM_ALLOC_PAGES
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
@@ -322 +319 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<order, local_cxy, ppm_page2ppn(XPTR( local_cxy , found_block )), cycle );
-    ppm_remote_display( local_cxy );
+    if( DEBUG_PPM_ALLOC_PAGES & 1 ) ppm_remote_display( local_cxy );
 }
 #endif
@@ -340 +337 @@
 #endif
 
-#if ( DEBUG_PPM_FREE_PAGES & 1 )
+#if DEBUG_PPM_FREE_PAGES 
 if( DEBUG_PPM_FREE_PAGES < cycle )
 {
@@ -346 +343 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<page->order, local_cxy, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
-    ppm_remote_display( local_cxy );
+    if( DEBUG_PPM_FREE_PAGES & 1 ) ppm_remote_display( local_cxy );
+}
 #endif
 
@@ -362 +360 @@
     // update DQDT
     dqdt_decrement_pages( local_cxy , page->order );
+
+    hal_fence();
 
 #if DEBUG_PPM_FREE_PAGES
@@ -369 +369 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<page->order, local_cxy, ppm_page2ppn(XPTR(local_cxy , page)) , cycle );
-    ppm_remote_display( local_cxy );
+    if( DEBUG_PPM_FREE_PAGES & 1 ) ppm_remote_display( local_cxy );
 }
 #endif
@@ -376 +376 @@
 
 
-
-
 /////////////////////////////////////////////
-void * ppm_remote_alloc_pages( cxy_t     cxy,
+xptr_t ppm_remote_alloc_pages( cxy_t     cxy,
                                uint32_t  order )
 {
@@ -389 +387 @@
     thread_t * this  = CURRENT_THREAD;
 
+// check order
+assert( (order < CONFIG_PPM_MAX_ORDER) , "illegal order argument = %d\n" , order );
+
+    // get local pointer on PPM (same in all clusters)
+        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
 #if DEBUG_PPM_REMOTE_ALLOC_PAGES
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 #endif
 
-#if ( DEBUG_PPM_REMOTE_ALLOC_PAGES & 1 )
+#if DEBUG_PPM_REMOTE_ALLOC_PAGES 
 if( DEBUG_PPM_REMOTE_ALLOC_PAGES < cycle )
 {
-    printk("\n[%s] thread[%x,%x] enter for %d small page(s) in cluster %x / cycle %d\n",
+    printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, 1<<order, cxy, cycle );
-    ppm_remote_display( cxy );
-}
-#endif
-
-// check order
-assert( (order < CONFIG_PPM_MAX_ORDER) , "illegal order argument = %d\n" , order );
-
-    // get local pointer on PPM (same in all clusters)
-        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+    if( DEBUG_PPM_REMOTE_ALLOC_PAGES & 1 ) ppm_remote_display( cxy );
+}
+#endif
 
     //build extended pointer on lock protecting remote PPM
@@ -489 +487 @@
     dqdt_increment_pages( cxy , order );
 
+    hal_fence();
+
 #if DEBUG_PPM_REMOTE_ALLOC_PAGES
 if( DEBUG_PPM_REMOTE_ALLOC_PAGES < cycle )
@@ -495 +495 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<order, cxy, ppm_page2ppn(XPTR( cxy , found_block )), cycle );
-    ppm_remote_display( cxy );
-}
-#endif
-
-        return found_block;
+    if( DEBUG_PPM_REMOTE_ALLOC_PAGES & 1 ) ppm_remote_display( cxy );
+}
+#endif
+
+        return XPTR( cxy , found_block );
 
 }  // end ppm_remote_alloc_pages()
@@ -515 +515 @@
         uint32_t   current_order;    // current (merged) page order
 
+    // get local pointer on PPM (same in all clusters)
+        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
+    // get page ppn and order
+    uint32_t   order = hal_remote_l32( XPTR( page_cxy , &page_ptr->order ) );
+
 #if DEBUG_PPM_REMOTE_FREE_PAGES
 thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
-#endif
-
-#if ( DEBUG_PPM_REMOTE_FREE_PAGES & 1 )
+ppn_t      ppn   = ppm_page2ppn( XPTR( page_cxy , page_ptr ) );
+#endif
+
+#if DEBUG_PPM_REMOTE_FREE_PAGES
 if( DEBUG_PPM_REMOTE_FREE_PAGES < cycle )
 {
     printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, 
-    1<<page_ptr->order, page_cxy, ppm_page2ppn(XPTR( page_cxy , page_ptr )), cycle );
-    ppm_remote_display( page_cxy );
+    __FUNCTION__, this->process->pid, this->trdid, 1<<order, page_cxy, ppn, cycle );
+    if( DEBUG_PPM_REMOTE_FREE_PAGES & 1 ) ppm_remote_display( page_cxy );
 }
 #endif
@@ -533 +539 @@
     page_xp = XPTR( page_cxy , page_ptr );
     
-    // get local pointer on PPM (same in all clusters)
-        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
-
     // build extended pointer on lock protecting remote PPM
     xptr_t lock_xp = XPTR( page_cxy , &ppm->free_lock );
@@ -556 +559 @@
     // initialise loop variables
     current_ptr   = page_ptr;
-    current_order = hal_remote_l32( XPTR( page_cxy , &page_ptr->order ) );
+    current_order = order;
         current_index = page_ptr - ppm->pages_tbl;
 
@@ -582 +585 @@
         hal_remote_s32( XPTR( page_cxy , &buddy_ptr->order ) , 0 );
 
-                // compute next (merged) page index in page_tbl[]
+                // compute next values for loop variables
                 current_index &= buddy_index;
-
-        // compute next (merged) page order
         current_order++;
-
-        // compute next (merged) page descripror
         current_ptr = pages_tbl + current_index; 
 
@@ -594 +593 @@
 
         // update current (merged) page descriptor order field
-        current_ptr = pages_tbl + current_index;
     hal_remote_s32( XPTR( page_cxy , &current_ptr->order ) , current_order );
 
         // insert current (merged) page into relevant free list
-        list_remote_add_first( page_cxy , &ppm->free_pages_root[current_order] , &current_ptr->list );
+        list_remote_add_first( page_cxy, &ppm->free_pages_root[current_order], &current_ptr->list );
     hal_remote_atomic_add( XPTR( page_cxy , &ppm->free_pages_nr[current_order] ) , 1 );
 
@@ -607 +605 @@
     dqdt_decrement_pages( page_cxy , page_ptr->order );
 
+    hal_fence();
+
 #if DEBUG_PPM_REMOTE_FREE_PAGES
 if( DEBUG_PPM_REMOTE_FREE_PAGES < cycle )
 {
     printk("\n[%s] thread[%x,%x] released %d page(s) in cluster %x / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, 
-    1<<page_ptr->order, page_cxy, ppm_page2ppn(XPTR( page_cxy , page_ptr ) ), cycle );
-    ppm_remote_display( page_cxy );
+    __FUNCTION__, this->process->pid, this->trdid, 1<<order, page_cxy, ppn, cycle );
+    if( DEBUG_PPM_REMOTE_FREE_PAGES & 1 ) ppm_remote_display( page_cxy );
 }
 #endif
@@ -658 +657 @@
         uint32_t n = hal_remote_l32( XPTR( cxy , &ppm->free_pages_nr[order] ) );
 
-        // display direct free_list[order]
-                nolock_printk("- forward  : order = %d / n = %d\t: ", order , n );
+        // display forward free_list[order]
+                nolock_printk("- forward  : order = %d / n = %d : ", order , n );
                 LIST_REMOTE_FOREACH( cxy , &ppm->free_pages_root[order] , iter )
+                {
+            page_xp = XPTR( cxy , LIST_ELEMENT( iter , page_t , list ) );
+                        nolock_printk("%x," , ppm_page2ppn( page_xp ) );
+                }
+                nolock_printk("\n");
+
+        // display backward free_list[order]
+                nolock_printk("- backward : order = %d / n = %d : ", order , n );
+                LIST_REMOTE_FOREACH_BACKWARD( cxy , &ppm->free_pages_root[order] , iter )
                 {
             page_xp = XPTR( cxy , LIST_ELEMENT( iter , page_t , list ) );

trunk/kernel/mm/ppm.h

@@ -84 +84 @@
 /*****************************************************************************************
  * This local allocator must be called by a thread running in local cluster. 
- * It allocates n contiguous physical 4 Kbytes pages from the local cluster, where 
- * n is a power of 2 defined by the <order> argument. 
+ * It allocates N contiguous physical 4 Kbytes pages from the local cluster, where 
+ * N is a power of 2 defined by the <order> argument. 
  * In normal use, it should not be called directly, as the recommended way to allocate
  * physical pages is to call the generic allocator defined in kmem.h.
@@ -116 +116 @@
 /*****************************************************************************************
  * This remote  allocator can be called by any thread running in any cluster. 
- * It allocates n contiguous physical 4 Kbytes pages from cluster identified 
- * by the <cxy> argument, where n is a power of 2 defined by the <order> argument. 
+ * It allocates N contiguous physical 4 Kbytes pages from cluster identified 
+ * by the <cxy> argument, where N is a power of 2 defined by the <order> argument. 
  * In normal use, it should not be called directly, as the recommended way to allocate
  * physical pages is to call the generic allocator defined in kmem.h.
@@ -123 +123 @@
  * @ cxy       : remote cluster identifier.
  * @ order     : ln2( number of 4 Kbytes pages)
- * @ returns a local pointer on remote page descriptor if success / XPTR_NULL if error.
- ****************************************************************************************/
-void *  ppm_remote_alloc_pages( cxy_t    cxy,
+ * @ returns an extended pointer on page descriptor if success / XPTR_NULL if error.
+ ****************************************************************************************/
+xptr_t  ppm_remote_alloc_pages( cxy_t    cxy,
                                 uint32_t order );
 

trunk/kernel/mm/vmm.c

@@ -1745 +1745 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the vmm_remove_vseg() and vmm_resize_vseg() functions.
-// Depending on the vseg <type>, it decrements the physical page refcount, and
-// conditionnally release to the relevant kmem the physical page identified by <ppn>.
+// This static function is called by the vmm_remove_vseg() and vmm_resize_vseg() functions
+// to update the physical page descriptor identified by the <ppn> argument. 
+// It decrements the refcount, set the dirty bit when required, and releases the physical
+// page to kmem depending on the vseg type.
+// - KERNEL : refcount decremented / not released to kmem    / dirty bit not set
+// - FILE   : refcount decremented / not released to kmem    / dirty bit set when required.
+// - CODE   : refcount decremented / released to kmem        / dirty bit not set.
+// - STAK   : refcount decremented / released to kmem        / dirty bit not set.
+// - DATA   : refcount decremented / released to kmem if ref / dirty bit not set.
+// - MMAP   : refcount decremented / released to kmem if ref / dirty bit not set.
 ////////////////////////////////////////////////////////////////////////////////////////////
 // @ process  : local pointer on process.
 // @ vseg     : local pointer on vseg.
 // @ ppn      : released pysical page index. 
+// @ dirty    : set the dirty bit in page descriptor when non zero.
 ////////////////////////////////////////////////////////////////////////////////////////////
 static void vmm_ppn_release( process_t * process,
                              vseg_t    * vseg,
-                             ppn_t       ppn )
+                             ppn_t       ppn,
+                             uint32_t    dirty )
 {
-    bool_t do_release;
+    bool_t do_kmem_release;
 
     // get vseg type
     vseg_type_t type = vseg->type;
 
-    // compute is_ref
+    // compute is_ref <=> this vseg is the reference vseg
     bool_t is_ref = (GET_CXY( process->ref_xp ) == local_cxy);
 
@@ -1774 +1783 @@
     hal_remote_atomic_add( count_xp , -1 );
 
-    // compute the do_release condition depending on vseg type
-    if( (type == VSEG_TYPE_FILE)  ||
-        (type == VSEG_TYPE_KCODE) || 
+    // compute the do_kmem_release condition depending on vseg type
+    if( (type == VSEG_TYPE_KCODE) || 
         (type == VSEG_TYPE_KDATA) || 
         (type == VSEG_TYPE_KDEV) )            
     {
-        // no physical page release for FILE and KERNEL 
-        do_release = false;
-    }
+        // no physical page release for KERNEL 
+        do_kmem_release = false;
+    }
+    else if( type == VSEG_TYPE_FILE )
+    {
+        // no physical page release for KERNEL 
+        do_kmem_release = false;
+
+        // set dirty bit if required
+        if( dirty ) ppm_page_do_dirty( page_xp );
+    }   
     else if( (type == VSEG_TYPE_CODE)  ||
              (type == VSEG_TYPE_STACK) ) 
     {
         // always release physical page for private vsegs
-        do_release = true;
+        do_kmem_release = true;
     }
     else if( (type == VSEG_TYPE_ANON)  ||
@@ -1793 +1809 @@
     {
         // release physical page if reference cluster
-        do_release = is_ref;
+        do_kmem_release = is_ref;
     }
     else if( is_ref )  // vseg_type == DATA in reference cluster
@@ -1814 +1830 @@
 
         // release physical page if forks == 0
-        do_release = (forks == 0); 
+        do_kmem_release = (forks == 0); 
     }
     else              // vseg_type == DATA not in reference cluster
     {
         // no physical page release if not in reference cluster 
-        do_release = false;
+        do_kmem_release = false;
     }
 
     // release physical page to relevant kmem when required
-    if( do_release )
-    {
-        ppm_remote_free_pages( page_cxy , page_ptr );
+    if( do_kmem_release )
+    {
+        kmem_req_t req;
+        req.type = KMEM_PPM;
+        req.ptr  = GET_PTR( ppm_ppn2base( ppn ) );
+
+        kmem_remote_free( page_cxy , &req );
 
 #if DEBUG_VMM_PPN_RELEASE
@@ -1892 +1912 @@
             hal_gpt_reset_pte( gpt_xp , vpn );
 
-            // release physical page when required
-            vmm_ppn_release( process , vseg , ppn );
+            // release physical page depending on vseg type
+            vmm_ppn_release( process , vseg , ppn , attr & GPT_DIRTY );
         }
     }
@@ -1986 +2006 @@
 
             // release physical page when required
-            vmm_ppn_release( process , vseg , ppn );
+            vmm_ppn_release( process , vseg , ppn , attr & GPT_DIRTY );
         }
     }
@@ -2008 +2028 @@
 
             // release physical page when required
-            vmm_ppn_release( process , vseg , ppn );
+            vmm_ppn_release( process , vseg , ppn , attr & GPT_DIRTY );
         }
     }
@@ -2170 +2190 @@
 // @ vseg   : local pointer on vseg.
 // @ vpn    : unmapped vpn.
-// @ return an extended pointer on the allocated page
+// @ return an extended pointer on the allocated page descriptor.
 //////////////////////////////////////////////////////////////////////////////////////
 static xptr_t vmm_page_allocate( vseg_t * vseg,
@@ -2186 +2206 @@
     xptr_t       page_xp;
     cxy_t        page_cxy;
-    page_t     * page_ptr;
     uint32_t     index;
 
@@ -2197 +2216 @@
 assert( ( type != VSEG_TYPE_FILE ) , "illegal vseg type\n" );
 
+    // compute target cluster identifier
     if( flags & VSEG_DISTRIB )    // distributed => cxy depends on vpn LSB
     {
@@ -2214 +2234 @@
 
     // allocate one small physical page from target cluster
-    page_ptr = ppm_remote_alloc_pages( page_cxy , 0 );
-
-    page_xp = XPTR( page_cxy , page_ptr );
+    kmem_req_t req;
+    req.type  = KMEM_PPM;
+    req.order = 0;
+    req.flags = AF_ZERO;
+
+    // get local pointer on page base
+    void * ptr = kmem_remote_alloc( page_cxy , &req );
+
+    // get extended pointer on page descriptor
+    page_xp = ppm_base2page( XPTR( page_cxy , ptr ) );
 
 #if DEBUG_VMM_PAGE_ALLOCATE
@@ -2245 +2272 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
-printk("\n[%s] thread[%x,%x] enter for vpn %x / type %s / page_id  %d / cycle %d\n",
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
+printk("\n[%s] thread[%x,%x] enter for vpn %x / vseg %s / page_id  %d / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, vseg_type_str(type), page_id, cycle );
+#endif
+
+#if (DEBUG_VMM_GET_ONE_PPN & 2)
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
 #endif
 
@@ -2291 +2323 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn = %x / elf_offset = %x\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, elf_offset );
@@ -2305 +2337 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in BSS\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
@@ -2322 +2354 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in mapper\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
@@ -2339 +2371 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn  %x / both mapper & BSS\n"
 "      %d bytes from mapper / %d bytes from BSS\n",
@@ -2365 +2397 @@
                 }
             }    
-        }  // end initialisation for CODE or DATA types   
+
+        }  // end if CODE or DATA types   
     } 
 
@@ -2372 +2405 @@
 
 #if DEBUG_VMM_GET_ONE_PPN
-cycle = (uint32_t)hal_get_cycles();
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid , vpn , *ppn, cycle );
+#endif
+
+#if (DEBUG_VMM_GET_ONE_PPN & 2)
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
 #endif
 
@@ -2404 +2441 @@
 
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
-if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) & (vpn > 0) )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, start_cycle );
 #endif
 
-#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
-hal_vmm_display( this->process , true );
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
 #endif
 
@@ -2504 +2541 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2513 +2549 @@
 #endif
 
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
+#endif
+
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.local_pgfault_nr++;
 this->info.local_pgfault_cost += cost;
@@ -2584 +2626 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2593 +2634 @@
 #endif
 
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
+#endif
+
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.false_pgfault_nr++;
 this->info.false_pgfault_cost += cost;
@@ -2651 +2698 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2660 +2706 @@
 #endif
 
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
+#endif
+
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.global_pgfault_nr++;
 this->info.global_pgfault_cost += cost;
@@ -2676 +2728 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2686 +2737 @@
 
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.false_pgfault_nr++;
 this->info.false_pgfault_cost += cost;
@@ -2720 +2772 @@
 #endif
 
-#if ((DEBUG_VMM_HANDLE_COW & 3) == 3 )
+#if (DEBUG_VMM_HANDLE_COW & 2)
 hal_vmm_display( XPTR( local_cxy , process ) , true );
 #endif
@@ -2902 +2954 @@
 #endif
 
-#if ((DEBUG_VMM_HANDLE_COW & 3) == 3)
+#if (DEBUG_VMM_HANDLE_COW & 2)
 hal_vmm_display( XPTR( local_cxy , process ) , true );
 #endif

trunk/kernel/mm/vmm.h

@@ -312 +312 @@
 
 /*********************************************************************************************
- * This function removes from the VMM of a process descriptor identified by the <process>
- * argument the vseg identified by the <vseg> argument.  
- * It is called by the vmm_user_reset(), vmm_global_delete_vseg() and vmm_destroy() functions.
+ * This function removes from the VMM of a local process descriptor, identified by
+ * the <process> argument, the vseg identified by the <vseg> argument.  
+ * It is called by the vmm_user_reset(), vmm_global_delete_vseg(), vmm_destroy() functions.
  * It must be called by a local thread, running in the cluster containing the modified VMM.
  * Use the RPC_VMM_REMOVE_VSEG if required.
@@ -324 +324 @@
  *   . for ANON and REMOTE, the vseg is not released, but registered in local zombi_list.
  *   . for STACK the vseg is released to the local stack allocator.
- *   . for all other types, the vseg is released to the local kmem.
+ *   . for all other types, the vseg descriptor is released to the local kmem.
  * Regarding the physical pages release:
  *   . for KERNEL and FILE, the pages are not released to kmem.
- *   . for CODE and STACK, the pages are released to local kmem when they are not COW.
+ *   . for CODE and STACK, the pages are released to local kmem.
  *   . for DATA, ANON and REMOTE, the pages are released to relevant kmem only when
  *     the local cluster is the reference cluster.