Changeset 657 for trunk/kernel/mm

Timestamp:

Mar 18, 2020, 11:16:59 PM (5 years ago)

Author:

alain

Message:

Introduce remote_buf.c/.h & socket.c/.h files.
Update dev_nic.c/.h files.

Location:

trunk/kernel/mm

Files:

• kcm.c (modified) (16 diffs)
• kcm.h (modified) (2 diffs)
• kmem.c (modified) (1 diff)
• mapper.c (modified) (25 diffs)
• mapper.h (modified) (8 diffs)
• ppm.c (modified) (1 diff)
• vmm.c (modified) (3 diffs)
• vmm.h (modified) (7 diffs)
• vseg.c (modified) (1 diff)
• vseg.h (modified) (1 diff)

trunk/kernel/mm/kcm.c

@@ -43 +43 @@
 //////////////////////////////////////////////////////////////////////////////////////
 // This static function must be called by a local thread.
-// It returns a pointer on a block allocated from a non-full kcm_page.
-// It makes a panic if no block is available in selected page.
+// It returns a pointer on a block allocated from an active kcm_page.
+// It makes a panic if no block is available in the selected page.
 // It changes the page status as required.
 //////////////////////////////////////////////////////////////////////////////////////
 // @ kcm      : pointer on KCM allocator.
-// @ kcm_page : pointer on a non-full kcm_page.
+// @ kcm_page : pointer on an active kcm_page.
 // @ return pointer on allocated block.
 /////////////////////////////////////////////////////////////////////////////////////
@@ -64 +64 @@
     uint32_t index  = 1;
     uint64_t mask   = (uint64_t)0x2;
-    uint32_t found  = 0;
 
         // allocate first free block in kcm_page, update status,
@@ -70 +69 @@
     while( index <= max )
     {
-        if( (status & mask) == 0 )   // block non allocated
+        if( (status & mask) == 0 )   // block found
         {
+            // update page count and status
             kcm_page->status = status | mask;
             kcm_page->count  = count + 1;
-            found  = 1;
-
             break;      
         }
@@ -83 +81 @@
     }
 
-    // change the page list if almost full
+    // change the page list if found block is the last
     if( count == max-1 )
     {
@@ -162 +160 @@
 
 /////////////////////////////////////////////////////////////////////////////////////
-// This private static function must be called by a local thread.
-// It returns one non-full kcm_page with te following policy :
+// This static function must be called by a local thread.
+// It returns one non-full kcm_page with the following policy :
 // - if the "active_list" is non empty, it returns the first "active" page,
 //   without modifying the KCM state.
-// - if the "active_list" is empty, it allocates a new page fromm PPM, inserts
+// - if the "active_list" is empty, it allocates a new page from PPM, inserts
 //   this page in the active_list, and returns it. 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -275 +273 @@
         // release KCM lock
         remote_busylock_release( lock_xp );
-}
+
+}  // end kcm_destroy()
 
 //////////////////////////////////
@@ -284 +283 @@
         void       * block_ptr;
 
-    // min block size is 64 bytes
+   // min block size is 64 bytes
     if( order < 6 ) order = 6;
 
@@ -301 +300 @@
     kcm_page = kcm_get_page( kcm_ptr );
 
+#if DEBUG_KCM
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( (DEBUG_KCM < cycle) && (local_cxy == 1) )
+{
+printk("\n[%s] thread[%x,%x] enters / order %d / page %x / kcm %x / page_status (%x|%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, order, kcm_page, kcm_ptr,
+GET_CXY( kcm_page->status ), GET_PTR( kcm_page->status ) );
+kcm_remote_display( local_cxy , kcm_ptr );
+}
+#endif
+
     if( kcm_page == NULL )
         {
@@ -314 +325 @@
 
 #if DEBUG_KCM
-thread_t * this  = CURRENT_THREAD;
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_KCM < cycle )
-printk("\n[%s] thread[%x,%x] allocated block %x / order %d / kcm %x / status[%x,%x] / count %d\n",
-__FUNCTION__, this->process->pid, this->trdid, block_ptr, order, kcm_ptr,
-GET_CXY(kcm_page->status), GET_PTR(kcm_page->status), kcm_page->count );
+if( (DEBUG_KCM < cycle) && (local_cxy == 1) )
+{
+printk("\n[%s] thread[%x,%x] exit / order %d / block %x / kcm %x / page_status (%x|%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, order, block_ptr, kcm_ptr,
+GET_CXY( kcm_page->status ), GET_PTR( kcm_page->status ) );
+kcm_remote_display( local_cxy , kcm_ptr );
+}
 #endif
 
@@ -344 +356 @@
 thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_KCM < cycle )
-printk("\n[%s] thread[%x,%x] release block %x / order %d / kcm %x / status [%x,%x] / count %d\n",
-__FUNCTION__, this->process->pid, this->trdid, block_ptr, kcm_ptr->order, kcm_ptr,
-GET_CXY(kcm_page->status), GET_PTR(kcm_page->status), kcm_page->count );
+if( (DEBUG_KCM < cycle) && (local_cxy == 1) )
+{
+printk("\n[%s] thread[%x,%x] enters / order %d / block %x / page %x / kcm %x / status [%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, kcm_ptr->order, block_ptr, kcm_page, kcm_ptr,
+GET_CXY(kcm_page->status), GET_PTR(kcm_page->status) );
+kcm_remote_display( local_cxy , kcm_ptr );
+}
 #endif
 
@@ -361 +376 @@
         // release lock
         remote_busylock_release( lock_xp );
+
+#if DEBUG_KCM
+if( (DEBUG_KCM < cycle) && (local_cxy == 1) )
+{
+printk("\n[%s] thread[%x,%x] exit / order %d / page %x / status [%x,%x]\n",
+__FUNCTION__, this->process->pid, this->trdid, kcm_ptr->order, kcm_ptr,
+GET_CXY(kcm_page->status), GET_PTR(kcm_page->status) );
+kcm_remote_display( local_cxy , kcm_ptr );
 }
+#endif
+
+}  // end kcm_free() 
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -369 +395 @@
 /////////////////////////////////////////////////////////////////////////////////////
 // This static function can be called by any thread running in any cluster.
-// It returns a local pointer on a block allocated from an non-full kcm_page.
-// It makes a panic if no block available in selected page.
+// It returns a local pointer on a block allocated from an active kcm_page.
+// It makes a panic if no block available in the selected kcm_page.
 // It changes the page status as required.
 /////////////////////////////////////////////////////////////////////////////////////
-// @ kcm_cxy  : remote KCM cluster identidfier.
+// @ kcm_cxy  : remote KCM cluster identifier.
 // @ kcm_ptr  : local pointer on remote KCM allocator.
-// @ kcm_page : pointer on active kcm page to use.
+// @ kcm_page : local pointer on remote active kcm_page to use.
 // @ return a local pointer on the allocated block. 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -392 +418 @@
     uint32_t index  = 1;
     uint64_t mask   = (uint64_t)0x2;
-    uint32_t found  = 0;
     
         // allocate first free block in kcm_page, update status,
@@ -398 +423 @@
     while( index <= max )
     {
-        if( (status & mask) == 0 )   // block non allocated
+        if( (status & mask) == 0 )   // block found
         {
             hal_remote_s64( XPTR( kcm_cxy , &kcm_page->status ) , status | mask );
-            hal_remote_s64( XPTR( kcm_cxy , &kcm_page->count  ) , count + 1 );
-            found  = 1; 
+            hal_remote_s32( XPTR( kcm_cxy , &kcm_page->count  ) , count + 1 );
             break;      
         }
@@ -410 +434 @@
     }
 
-        // change the page list if almost full
+        // change the page list if found block is the last
         if( count == max-1 )
         {
@@ -631 +655 @@
                          kcm_t * kcm_ptr )
 {
+    list_entry_t * iter;
+    kcm_page_t   * kcm_page;
+    uint64_t       status;
+    uint32_t       count;
+
     uint32_t order           = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->order) );
     uint32_t full_pages_nr   = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->full_pages_nr ) );
     uint32_t active_pages_nr = hal_remote_l32( XPTR( kcm_cxy , &kcm_ptr->active_pages_nr ) );
 
-        printk("*** KCM / cxy %x / order %d / full_pages %d / empty_pages %d / active_pages %d\n",
+        printk("*** KCM : cxy %x / order %d / full_pages_nr %d / active_pages_nr %d\n",
         kcm_cxy, order, full_pages_nr, active_pages_nr );
-}
+
+    if( active_pages_nr )
+    {
+        LIST_REMOTE_FOREACH( kcm_cxy , &kcm_ptr->active_root , iter )
+        {
+            kcm_page = LIST_ELEMENT( iter , kcm_page_t , list );
+            status   = hal_remote_l64( XPTR( kcm_cxy , &kcm_page->status ) );
+            count    = hal_remote_l32( XPTR( kcm_cxy , &kcm_page->count ) );
+
+            printk("- active page %x / status (%x,%x) / count %d\n",
+            kcm_page, GET_CXY( status ), GET_PTR( status ), count );
+        }
+    }
+
+    if( full_pages_nr )
+    {
+        LIST_REMOTE_FOREACH( kcm_cxy , &kcm_ptr->full_root , iter )
+        {
+            kcm_page = LIST_ELEMENT( iter , kcm_page_t , list );
+            status   = hal_remote_l64( XPTR( kcm_cxy , &kcm_page->status ) );
+            count    = hal_remote_l32( XPTR( kcm_cxy , &kcm_page->count ) );
+
+            printk("- full page %x / status (%x,%x) / count %d\n",
+            kcm_page, GET_CXY( status ), GET_PTR( status ), count );
+        }
+    }
+}  // end kcm remote_display()

trunk/kernel/mm/kcm.h

@@ -92 +92 @@
  * It initializes a Kernel Cache Manager, depending on block size.
  ****************************************************************************************
- * @ kcm      : pointer on KCM manager to initialize.
+ * @ kcm      : pointer on KCM to be initialized.
  * @ order    : ln(block_size).
  ***************************************************************************************/
@@ -122 +122 @@
  ***************************************************************************************/
 void kcm_free( void    * block_ptr );
+
+
+
 
 /****************************************************************************************

trunk/kernel/mm/kmem.c

@@ -2 +2 @@
  * kmem.c - kernel memory allocator implementation.
  *
- * Authors  Alain Greiner (2016,2017,2018,2019)
+ * Authors  Alain Greiner (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites

trunk/kernel/mm/mapper.c

@@ -3 +3 @@
  *
  * Authors   Mohamed Lamine Karaoui (2015)
- *           Alain Greiner (2016,2017,2018,2019)
+ *           Alain Greiner (2016,2017,2018,2019,2020)
  *
  * Copyright (c)  UPMC Sorbonne Universites
@@ -46 +46 @@
 
 
-//////////////////////////////////////////////
-mapper_t * mapper_create( vfs_fs_type_t type )
-{
-    mapper_t * mapper;
+/////////////////////////////////////
+xptr_t  mapper_create( cxy_t     cxy,
+                       uint32_t  type )
+{
+    mapper_t * mapper_ptr;
     kmem_req_t req;
     error_t    error;
 
     // allocate memory for mapper descriptor
-    req.type  = KMEM_KCM;
-    req.order = bits_log2( sizeof(mapper_t) );
-    req.flags = AF_KERNEL | AF_ZERO;
-    mapper    = kmem_alloc( &req );
-
-    if( mapper == NULL )
+    req.type    = KMEM_KCM;
+    req.order   = bits_log2( sizeof(mapper_t) );
+    req.flags   = AF_KERNEL | AF_ZERO;
+    mapper_ptr  = kmem_remote_alloc( cxy , &req );
+
+    if( mapper_ptr == NULL )
     {
         printk("\n[ERROR] in %s : no memory for mapper descriptor\n", __FUNCTION__ );
-        return NULL;
-    }
-
-    // initialize refcount & inode
-    mapper->refcount = 0;
-    mapper->inode    = NULL;
+        return XPTR_NULL;
+    }
+
+    // initialize refcount and type
+    hal_remote_s32( XPTR( cxy , &mapper_ptr->refcount ) , 0 );
+    hal_remote_s32( XPTR( cxy , &mapper_ptr->fs_type )  , type );
 
     // initialize radix tree
-    error = grdxt_init( &mapper->rt,
-                        CONFIG_MAPPER_GRDXT_W1,
-                        CONFIG_MAPPER_GRDXT_W2,
-                        CONFIG_MAPPER_GRDXT_W3 );
+    error = grdxt_remote_init( XPTR( cxy , &mapper_ptr->rt ),
+                               CONFIG_MAPPER_GRDXT_W1,
+                               CONFIG_MAPPER_GRDXT_W2,
+                               CONFIG_MAPPER_GRDXT_W3 );
     if( error )
     {
         printk("\n[ERROR] in %s : cannot initialize radix tree\n", __FUNCTION__ );
         req.type  = KMEM_KCM;
-        req.ptr   = mapper;
-        kmem_free( &req );
-        return NULL;
-    }
-
-    // initialize mapper type
-    mapper->type = type;
+        req.ptr   = mapper_ptr;
+        kmem_remote_free( cxy , &req );
+        return XPTR_NULL;
+    }
 
     // initialize mapper lock
-    remote_rwlock_init( XPTR( local_cxy , &mapper->lock ) , LOCK_MAPPER_STATE );
+    remote_rwlock_init( XPTR( cxy , &mapper_ptr->lock ) , LOCK_MAPPER_STATE );
 
     // initialize waiting threads xlist (empty)
-    xlist_root_init( XPTR( local_cxy , &mapper->wait_root ) );
+    xlist_root_init( XPTR( cxy , &mapper_ptr->wait_root ) );
 
     // initialize vsegs xlist (empty)
-    xlist_root_init( XPTR( local_cxy , &mapper->vsegs_root ) );
-
-    return mapper;
+    xlist_root_init( XPTR( cxy , &mapper_ptr->vsegs_root ) );
+
+    return XPTR( cxy , mapper_ptr );
 
 }  // end mapper_create()
 
 ////////////////////////////////////////
-void mapper_destroy( mapper_t * mapper )
-{
+void mapper_destroy( xptr_t  mapper_xp )
+{
+    xptr_t     page_xp;
     page_t   * page;
     uint32_t   found_index = 0;
@@ -107 +106 @@
     kmem_req_t req;
 
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp ); 
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+
+    // build extended pointer on radix tree
+    xptr_t rt_xp = XPTR( mapper_cxy , &mapper_ptr->rt );
+
     // scan radix tree
     do
     {
         // get page from radix tree
-        page = (page_t *)grdxt_get_first( &mapper->rt , start_index , &found_index );
-
+        page_xp = grdxt_remote_get_first( rt_xp,
+                                          start_index , 
+                                          &found_index );
+        page = GET_PTR( page_xp );
+        
         // release registered pages to PPM
         if( page != NULL )
         {
             // remove page from mapper and release to PPM
-            mapper_remote_release_page( XPTR( local_cxy , mapper ) , page );
+            mapper_remote_release_page( mapper_xp , page );
 
             // update start_key value for next page
@@ -126 +134 @@
 
     // release the memory allocated to radix tree itself
-    grdxt_destroy( &mapper->rt );
+    grdxt_remote_destroy( rt_xp );
 
     // release memory for mapper descriptor
     req.type = KMEM_KCM;
-    req.ptr  = mapper;
-    kmem_free( &req );
+    req.ptr  = mapper_ptr;
+    kmem_remote_free( mapper_cxy , &req );
 
 }  // end mapper_destroy()
 
-////////////////////////////////////////////////////////
-error_t mapper_remote_handle_miss( xptr_t     mapper_xp,
-                                   uint32_t   page_id,
-                                   xptr_t   * page_xp_ptr )
+/////////////////////////////////////////////////
+error_t mapper_handle_miss( xptr_t     mapper_xp,
+                            uint32_t   page_id,
+                            xptr_t   * page_xp_ptr )
 {
     error_t    error;
 
-    uint32_t   inode_size;    
-    uint32_t   inode_type;
+    uint32_t   inode_size = 0;    
+    uint32_t   inode_type = 0;
 
     thread_t * this = CURRENT_THREAD;
@@ -159 +167 @@
         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;
     }
 
@@ -267 +270 @@
     return 0;
 
-}  // end mapper_remote_handle_miss()
-
-////////////////////////////////////////////////////
-xptr_t  mapper_remote_get_page( xptr_t    mapper_xp,
-                                uint32_t  page_id )
+}  // end mapper_handle_miss()
+
+/////////////////////////////////////////////
+xptr_t  mapper_get_page( xptr_t    mapper_xp,
+                         uint32_t  page_id )
 {
     error_t       error;
@@ -281 +284 @@
     cxy_t      mapper_cxy = GET_CXY( mapper_xp );
 
+assert( (hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) ) != NULL ),
+"should not be used for the FAT mapper");
+
 #if DEBUG_MAPPER_GET_PAGE
-vfs_inode_t * inode = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
 uint32_t      cycle = (uint32_t)hal_get_cycles();
 char          name[CONFIG_VFS_MAX_NAME_LENGTH];
-if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode == NULL) )  // FAT mapper
-{
-    printk("\n[%s] thread[%x,%x] enter for page %d of FAT mapper / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
-}
-if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )  // file mapper
-{
+if( DEBUG_MAPPER_GET_PAGE < cycle )  
+{
+    vfs_inode_t * inode = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
     vfs_inode_get_name( XPTR( mapper_cxy , inode ) , name );
     printk("\n[%s] thread[%x,%x] enter for page %d of <%s> mapper / cycle %d\n",
@@ -330 +331 @@
         if ( page_xp == XPTR_NULL )  // miss confirmed => handle it
         {
-            error = mapper_remote_handle_miss( mapper_xp,
-                                               page_id,
-                                               &page_xp );
+            error = mapper_handle_miss( mapper_xp,
+                                        page_id,
+                                        &page_xp );
             if( error )
             {
@@ -343 +344 @@
 
 #if (DEBUG_MAPPER_GET_PAGE & 1)
-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) );
-}
+if( DEBUG_MAPPER_GET_PAGE < cycle )
+printk("\n[%s] thread[%x,%x] introduced missing page %d in <%s> mapper / ppn %x\n",
+__FUNCTION__, this->process->pid, this->trdid, page_id, name, ppm_page2ppn(page_xp) );
 #endif
         
@@ -365 +359 @@
 
 #if DEBUG_MAPPER_GET_PAGE
-cycle = (uint32_t)hal_get_cycles();
-if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )
-{
-    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\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id, ppm_page2ppn(page_xp) );
-}
+if( DEBUG_MAPPER_GET_PAGE < 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) );
 #endif
 
@@ -385 +371 @@
     return page_xp;
 
-}  // end mapper_remote_get_page()
+}  // end mapper_get_page()
+
+/////////////////////////////////////////////////
+xptr_t  mapper_get_fat_page( xptr_t    mapper_xp,
+                             uint32_t  page_id )
+{
+    error_t       error;
+
+    thread_t * this = CURRENT_THREAD;
+
+    // get mapper cluster and local pointer
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
+
+assert( (hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) ) == NULL ),
+"should be used for the FAT mapper");
+
+#if DEBUG_MAPPER_GET_FAT_PAGE
+uint32_t      cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_MAPPER_GET_FAT_PAGE < cycle ) 
+printk("\n[%s] thread[%x,%x] enter for page %d of FAT mapper / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+#endif
+
+#if( DEBUG_MAPPER_GET_FAT_PAGE & 2 )
+if( DEBUG_MAPPER_GET_FAT_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
+    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
+    remote_rwlock_rd_acquire( lock_xp );
+
+    // search page in radix tree
+    xptr_t page_xp  = grdxt_remote_lookup( rt_xp , page_id );
+
+    // test mapper miss 
+    if( page_xp == XPTR_NULL )                  // miss => handle it
+    {
+        // release the lock in READ_MODE and take it in WRITE_MODE
+        remote_rwlock_rd_release( lock_xp );
+        remote_rwlock_wr_acquire( lock_xp );
+
+        // second test on missing page because the page status can be modified
+        // by another thread, when passing from READ_MODE to WRITE_MODE.
+        // from this point there is no concurrent accesses to mapper.
+        page_xp = grdxt_remote_lookup( rt_xp , page_id );
+
+        if ( page_xp == XPTR_NULL )  // miss confirmed => handle it
+        {
+            error = mapper_handle_miss( mapper_xp,
+                                        page_id,
+                                        &page_xp );
+            if( error )
+            {
+                printk("\n[ERROR] in %s : thread[%x,%x] cannot handle mapper miss\n",
+                __FUNCTION__ , this->process->pid, this->trdid );
+                remote_rwlock_wr_release( lock_xp );
+                return XPTR_NULL;
+            }
+        }
+
+#if (DEBUG_MAPPER_GET_FAT_PAGE & 1)
+if( DEBUG_MAPPER_GET_FAT_PAGE < cycle )
+printk("\n[%s] thread[%x,%x] introduced missing page %d in FAT mapper / ppn %x\n",
+__FUNCTION__, this->process->pid, this->trdid, page_id, ppm_page2ppn(page_xp) );
+#endif
+        
+        // release mapper lock from WRITE_MODE
+        remote_rwlock_wr_release( lock_xp );
+    }
+    else                                              // hit 
+    {
+        // release mapper lock from READ_MODE
+        remote_rwlock_rd_release( lock_xp );
+    }
+
+#if DEBUG_MAPPER_GET_FAT_PAGE
+if( DEBUG_MAPPER_GET_FAT_PAGE < 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_FAT_PAGE & 2)
+if( DEBUG_MAPPER_GET_FAT_PAGE < cycle ) 
+ppm_remote_display( local_cxy );
+#endif
+
+    return page_xp;
+
+}  // end mapper_get_fat_page()
 
 ////////////////////////////////////////////////////
@@ -481 +563 @@
 
         // get extended pointer on page descriptor in mapper
-        page_xp = mapper_remote_get_page( mapper_xp , page_id ); 
+        page_xp = mapper_get_page( mapper_xp , page_id ); 
 
         if ( page_xp == XPTR_NULL ) return -1;
@@ -519 +601 @@
 __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_xp , 128 );
+mapper_display_page(  mapper_xp , page_id , 128 );
 #endif
 
@@ -617 +699 @@
 
         // get extended pointer on page descriptor
-        page_xp = mapper_remote_get_page( mapper_xp , page_id );
+        page_xp = mapper_get_page( mapper_xp , page_id );
 
         if ( page_xp == XPTR_NULL ) return -1;
@@ -678 +760 @@
     
     // get page containing the searched word
-    page_xp  = mapper_remote_get_page( mapper_xp , page_id );
+    page_xp  = mapper_get_page( mapper_xp , page_id );
 
     if( page_xp == XPTR_NULL )  return -1;
@@ -702 +784 @@
 
     // get page containing the searched word
-    page_xp  = mapper_remote_get_page( mapper_xp , page_id );
+    page_xp  = mapper_get_page( mapper_xp , page_id );
 
     if( page_xp == XPTR_NULL ) return -1;
@@ -719 +801 @@
 }  // end mapper_remote_set_32()
 
-/////////////////////////////////////////
-error_t mapper_sync( mapper_t *  mapper )
-{
-    page_t   * page;                // local pointer on current page descriptor
-    xptr_t     page_xp;             // extended pointer on current page descriptor
-    grdxt_t  * rt;                  // pointer on radix_tree descriptor
-    uint32_t   start_key;           // start page index in mapper
-    uint32_t   found_key;           // current page index in mapper
+////////////////////////////////////////
+error_t mapper_sync( xptr_t  mapper_xp )
+{
+    uint32_t   found_key;           // unused, required by grdxt_remote_get_first()
     error_t    error;
+
+    // get mapper cluster and local pointer
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
 
 #if DEBUG_MAPPER_SYNC
@@ -733 +815 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 char       name[CONFIG_VFS_MAX_NAME_LENGTH];
-vfs_inode_get_name( XPTR( local_cxy , mapper->inode ) , name );
-#endif
-
-    // get pointer on radix tree
-    rt = &mapper->rt;
+vfs_inode_get_name( XPTR( mapper_cxy , &mapper_ptr->inode ) , name );
+#endif
+
+    // build extended pointer on radix tree
+    xptr_t   rt_xp = XPTR( mapper_cxy , &mapper_ptr->rt );
 
     // initialise loop variable 
-    start_key = 0;
+    uint32_t start_key = 0;
 
     // scan radix-tree until last page found
@@ -746 +828 @@
     {
         // get page descriptor from radix tree
-        page = (page_t *)grdxt_get_first( rt , start_key , &found_key );
+        xptr_t page_xp = grdxt_remote_get_first( rt_xp , start_key , &found_key );
          
-        if( page == NULL ) break;
-
-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
-        page_xp = XPTR( local_cxy , page );
+        page_t * page_ptr = GET_PTR( page_xp );
+
+        // exit loop when last page found
+        if( page_ptr == NULL ) break;
+
+        // get page flags & index fields
+        uint32_t flags = hal_remote_l32( XPTR( mapper_cxy , &page_ptr->flags ) );
+        uint32_t index = hal_remote_l32( XPTR( mapper_cxy , &page_ptr->index ) );
 
         // synchronize page if dirty
-        if( (page->flags & PG_DIRTY) != 0 )
+        if( flags & PG_DIRTY )
         {
 
@@ -763 +846 @@
 if( cycle > DEBUG_MAPPER_SYNC )
 printk("\n[%s] thread[%x,%x] synchonise page %d of <%s> to IOC device\n",
-__FUNCTION__, this->process->pid, this->trdid, page->index, name );
+__FUNCTION__, this->process->pid, this->trdid, page_ptr->index, name );
 #endif
             // copy page to file system
@@ -771 +854 @@
             {
                 printk("\n[ERROR] in %s : cannot synchonize dirty page %d\n", 
-                __FUNCTION__, page->index );
+                __FUNCTION__, page_ptr->index );
                 return -1;
             }
@@ -784 +867 @@
 if( cycle > DEBUG_MAPPER_SYNC )
 printk("\n[%s] thread[%x,%x] skip page %d for <%s>\n",
-__FUNCTION__, this->process->pid, this->trdid, page->index, name );
+__FUNCTION__, this->process->pid, this->trdid, page_ptr->index, name );
 #endif
         }
 
         // update loop variable
-        start_key = page->index + 1;
+        start_key = index + 1;
     }  // end while
 
@@ -798 +881 @@
 ///////////////////////////////////////////////
 void mapper_display_page( xptr_t     mapper_xp,
-                          xptr_t     page_xp,
+                          uint32_t   page_id,
                           uint32_t   nbytes )
 {
@@ -809 +892 @@
 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
@@ -815 +897 @@
     mapper_t * mapper_ptr = GET_PTR( mapper_xp );
 
-    // get page cluster an local pointer
+    // get extended pointer on page descriptor
+    xptr_t page_xp = mapper_get_page( mapper_xp , page_id );
+
+    // get page cluster and 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 ) );
+    uint32_t   index   = 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");
+assert( (mapper_ptr == mapper   ) , "unconsistent mapper field in page descriptor");
+assert( (page_id    == index    ) , "unconsistent index  field in page descriptor");
 
     // get inode

trunk/kernel/mm/mapper.h

@@ -61 +61 @@
  * - In the present implementation the cache size for a given file increases on demand,
  *   and the  allocated memory is only released when the mapper/inode is destroyed.
- *
- * TODO the "type" field in mapper descriptor is redundant and probably unused. 
  ******************************************************************************************/
 
@@ -73 +71 @@
 {
         struct vfs_inode_s * inode;           /*! owner inode                                     */
-    uint32_t             type;        /*! file system type                                */
+    uint32_t             fs_type;     /*! file system type                                */
         grdxt_t              rt;              /*! embedded pages cache descriptor (radix tree)    */
         remote_rwlock_t      lock;        /*! several readers / only one writer               */
@@ -84 +82 @@
 
 /*******************************************************************************************
- * This function allocates physical memory for a mapper descriptor, and initializes it
- * (refcount <= 0) / inode <= NULL).
- * It must be executed by a thread running in the cluster containing the mapper.
- *******************************************************************************************
- * @ type   : type of the mapper to create.
- * @ return : pointer on created mapper if success / return NULL if no memory
- ******************************************************************************************/
-mapper_t * mapper_create( vfs_fs_type_t type );
-
-/*******************************************************************************************
- * This function releases all physical memory allocated for a mapper.
- * Both the mapper descriptor and the radix tree are released.
+ * This function allocates physical memory for a mapper descriptor, in cluster
+ * identified by the <cxy> argument. It initializes it (refcount <= 0) / inode <= NULL).
+ * It can be executed by any thread running in any cluster.
+ *******************************************************************************************
+ * @ cxy    : target cluster identifier.
+ * @ type   : FS type.
+ * @ return an extended pointer on created mapper if success / return NULL if no memory
+ ******************************************************************************************/
+xptr_t  mapper_create( cxy_t     cxy,
+                       uint32_t  type );
+
+/*******************************************************************************************
+ * This function releases all physical memory allocated for a mapper, identified
+ * by the <mapper_xp> argument. Both the mapper descriptor and the radix tree are released.
  * It does NOT synchronize dirty pages. Use the vfs_sync_inode() function if required.
- * It must be executed by a thread running in the cluster containing the mapper.
- *******************************************************************************************
- * @ mapper      : target mapper.
- ******************************************************************************************/
-void mapper_destroy( mapper_t * mapper );
+ * It can be executed by any thread running in any cluster.
+ *******************************************************************************************
+ * @ mapper_xp   : extended pointer on target mapper.
+ ******************************************************************************************/
+void mapper_destroy( xptr_t  mapper_xp );
 
 /*******************************************************************************************
@@ -117 +117 @@
  * @ return 0 if success / return -1 if IOC cannot be accessed.
  ******************************************************************************************/
-error_t mapper_remote_handle_miss( xptr_t     mapper_xp,
-                                   uint32_t   page_id,
-                                   xptr_t   * page_xp );
+error_t mapper_handle_miss( xptr_t     mapper_xp,
+                            uint32_t   page_id,
+                            xptr_t   * page_xp );
 
 /*******************************************************************************************
@@ -180 +180 @@
 
 /*******************************************************************************************
- * This function returns an extended pointer on a page descriptor.
- * The - possibly remote - mapper is identified by the <mapper_xp> argument.
+ * This function returns an extended pointer on a page descriptor for a regular mapper
+ * (i.e. this mapper is NOT the FAT mapper), identified by the <mapper_xp> argument.
  * The page is identified by <page_id> argument (page index in the file).
  * It can be executed by a thread running in any cluster, as it uses remote
@@ -193 +193 @@
  * @ returns extended pointer on page descriptor if success / return XPTR_NULL if error.
  ******************************************************************************************/
-xptr_t mapper_remote_get_page( xptr_t    mapper_xp,
-                               uint32_t  page_id );
+xptr_t mapper_get_page( xptr_t    mapper_xp,
+                        uint32_t  page_id );
+
+/*******************************************************************************************
+ * This function returns an extended pointer on a page descriptor for the FAT mapper.
+ * The page is identified by <page_id> argument (page index in the FAT mapper).
+ * It can be executed by a thread running in any cluster, as it uses remote
+ * access primitives to scan the mapper.
+ * In case of miss, this function takes the mapper lock in WRITE_MODE, and call the 
+ * mapper_handle_miss() to load the missing page from device to mapper, using an RPC 
+ * when the mapper is remote.
+ *******************************************************************************************
+ * @ mapper_xp  : extended pointer on the mapper.
+ * @ page_id    : page index in file
+ * @ returns extended pointer on page descriptor if success / return XPTR_NULL if error.
+ ******************************************************************************************/
+xptr_t mapper_get_fat_page( xptr_t    mapper_xp,
+                            uint32_t  page_id );
 
 /*******************************************************************************************
@@ -234 +250 @@
 
 /*******************************************************************************************
- * This function scan all pages present in the mapper identified by the <mapper> argument,
- * and synchronize all pages marked as "dirty" on disk. 
+ * This function scan all pages present in the mapper identified by the <mapper_xp>
+ * argument, and synchronize all pages marked as "dirty" on disk. 
  * These pages are unmarked and removed from the local PPM dirty_list. 
- * This function must be called by a local thread running in same cluster as the mapper.
- * A remote thread must call the RPC_MAPPER_SYNC function.
- *******************************************************************************************
- * @ mapper     : [in]  local pointer on local mapper.
- * @ returns 0 if success / return -1 if error.
- ******************************************************************************************/
-error_t mapper_sync( mapper_t *  mapper );
+ * It can be called by any thread running in any cluster.
+ *******************************************************************************************
+ * @ mapper_xp  : [in]  extended pointer on local mapper.
+ * @ returns 0 if success / return -1 if error.
+ ******************************************************************************************/
+error_t mapper_sync( xptr_t  mapper_xp );
 
 /*******************************************************************************************
  * This debug function displays the content of a given page of a given mapper, identified
- * by the <mapper_xp> and <page_xp> arguments.
+ * by the <mapper_xp> and <page_id> 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.
@@ -253 +268 @@
  *******************************************************************************************
  * @ mapper_xp  : [in]  extended pointer on the mapper.
- * @ page_xp    : [in]  extended pointer on page descriptor.
+ * @ page_id    : [in]  page_index in mapper.
  * @ 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   page_id,
                           uint32_t   nbytes );
 

trunk/kernel/mm/ppm.c

@@ -3 +3 @@
  *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
- *          Alain Greiner    (2016,2017,2018,2019)
+ *          Alain Greiner    (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites

trunk/kernel/mm/vmm.c

@@ -3 +3 @@
  *
  * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
- *           Alain Greiner (2016,2017,2018,2019)
+ *           Alain Greiner (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -1988 +1988 @@
     xptr_t gpt_xp = XPTR( local_cxy , &process->vmm.gpt );
 
-    // loop on PTEs in GPT to unmap PTE if (oldd_vpn_min <= vpn < new_vpn_min)
+    // loop on PTEs in GPT to unmap PTE if (old_vpn_min <= vpn < new_vpn_min)
         for( vpn = old_vpn_min ; vpn < new_vpn_min ; vpn++ )
     {
@@ -2292 +2292 @@
         
         // get extended pointer on page descriptor
-        page_xp = mapper_remote_get_page( mapper_xp , page_id );
+        page_xp = mapper_get_page( mapper_xp , page_id );
 
         if ( page_xp == XPTR_NULL ) return EINVAL;

trunk/kernel/mm/vmm.h

@@ -3 +3 @@
  *
  * Authors   Ghassan Almaless (2008,2009,2010,2011, 2012)
- *           Mohamed Lamine Karaoui (2015)
- *           Alain Greiner (2016,2017,2018,2019)
+ *           Alain Greiner (2016,2017,2018,2019,2020))
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -31 +30 @@
 #include <list.h>
 #include <queuelock.h>
+#include <remote_queuelock.h>
 #include <hal_gpt.h>
 #include <vseg.h>
@@ -208 +208 @@
 
 /*********************************************************************************************
- * This function modifies the size of the vseg identified by <process> and <base> arguments
- * in all clusters containing a VSL copy, as defined by <new_base> and <new_size> arguments.
- * This function is called by the sys_munmap() function, and can be called by a thread
- * running in any cluster, as it uses remote accesses.
+ * This function modifies the vseg identified by <process> and <base> arguments in all
+ * clusters containing a VSL copy, as defined by <new_base> and <new_size> arguments.
+ * The new vseg, defined by the <new_base> and <new_size> arguments must be included
+ * in the existing vseg. The target VSL size and base fields are modified in the VSL.
+ * This is done in all clusters containing a VMM copy to maintain VMM coherence. 
+ * It is called by the sys_munmap() and dev_fbf_resize_window() functions.
+ * It can be called by a thread running in any cluster, as it uses the vmm_resize_vseg() in
+ * the local cluster, and parallel RPC_VMM_RESIZE_VSEG for remote clusters.
  * It cannot fail, as only vseg registered  in VSL copies are updated.
  *********************************************************************************************
@@ -228 +232 @@
  * the VSL and remove all associated PTE entries from the GPT.
  * This is done in all clusters containing a VMM copy to maintain VMM coherence. 
- * This function can be called by a thread running in any cluster, as it uses the
- * vmm_remove_vseg() in the local cluster, and the RPC_VMM_REMOVE_VSEG for remote clusters.
+ * It is called by the sys_munmap() and dev_fbf_resize_window() functions.
+ * It can be called by a thread running in any cluster, as it uses the vmm_remove_vseg() in
+ * the local cluster, and parallel RPC_VMM_REMOVE_VSEG for remote clusters.
  * It cannot fail, as only vseg registered  in VSL copies are deleted.
  *********************************************************************************************
@@ -317 +322 @@
  * It must be called by a local thread, running in the cluster containing the modified VMM.
  * Use the RPC_VMM_REMOVE_VSEG if required.
- * It makes a kernel panic if the process is not registered in the local cluster,
- * or if the vseg is not registered in the process VSL.
+ * It makes a kernel panic if the process is not registered in the local cluster.
  * For all vseg types, the vseg is detached from local VSL, and all associated PTEs are
  * unmapped from local GPT. Other actions depend on the vseg type:
@@ -340 +344 @@
 /*********************************************************************************************
  * This function resize a local vseg identified by the <process> and <vseg> arguments.
- * It is called by the vmm_global_resize() function.
- * It must be called by a local thread, running in the cluster containing the modified VMM.
+ * Both the "size" and "base" fields are modified in the process VSL. When the new vseg
+ * contains less pages than the target vseg, the relevant pages are removed from the GPT. 
+ * It is called by the vmm_global_resize() and dev_fbf_resize_window() functions.
+ * It must be called by a local thread, running in the cluster containing the modified VSL.
  * Use the RPC_VMM_RESIZE_VSEG if required.
- * It makes a kernel panic if the process is not registered in the local cluster,
- * or if the vseg is not registered in the process VSL.
- * The new vseg, defined by the <new_base> and <new_size> arguments must be strictly
- * included in the target vseg. The target VSL size and base fields are modified in the VSL.
- * If the new vseg contains less pages than the target vseg, the relevant pages are
- * removed from the GPT. 
  * The VSL lock protecting the VSL must be taken by the caller.
  *********************************************************************************************
@@ -454 +454 @@
                          ppn_t  * ppn );
 
-
 #endif /* _VMM_H_ */

trunk/kernel/mm/vseg.c

@@ -2 +2 @@
  * vseg.c - virtual segment (vseg) related operations
  *
- * Authors   Alain Greiner (2016,2017,2018,2019)
+ * Authors   Alain Greiner (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites

trunk/kernel/mm/vseg.h

@@ -2 +2 @@
  * vseg.h - virtual segment (vseg) related operations
  *
- * Authors  Alain Greiner (2016,2017,2018,2019)
+ * Authors  Alain Greiner (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites