Changeset 315 for trunk/kernel/mm

Timestamp:

Aug 3, 2017, 10:15:18 AM (7 years ago)

Author:

alain

Message:

Redefine the fuctions ppm_base2page() / ppm_page2base() / ppm_page2ppn() / ppm_ppn2page() / ppm_base2ppn() / ppm_ppn2base(),
to use explicitely extended pointers.

Location:

trunk/kernel/mm

Files:

• kcm.c (modified) (1 diff)
• khm.c (modified) (1 diff)
• mapper.c (modified) (2 diffs)
• mapper.h (modified) (2 diffs)
• page.c (modified) (2 diffs)
• page.h (modified) (1 diff)
• ppm.c (modified) (1 diff)
• ppm.h (modified) (1 diff)
• vmm.c (modified) (10 diffs)
• vseg.c (modified) (4 diffs)
• vseg.h (modified) (3 diffs)

trunk/kernel/mm/kcm.c

@@ -160 +160 @@
 
         // get page base address
-        kcm_page = (kcm_page_t *)ppm_page2vaddr( page );
+        xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
+        kcm_page = (kcm_page_t *)GET_PTR( base_xp );
 
         // initialize KCM-page descriptor

trunk/kernel/mm/khm.c

@@ -51 +51 @@
         // get kernel heap base from PPM
         page_t * page      = ppm_alloc_pages( CONFIG_PPM_HEAP_ORDER );
-        void   * heap_base = ppm_page2vaddr( page );
+        xptr_t   base_xp   = ppm_page2base( XPTR( local_cxy, page ) );
+        void   * heap_base = GET_PTR( base_xp );
 
         // initialize first block (complete heap)

trunk/kernel/mm/mapper.c

@@ -349 +349 @@
 
         // compute pointer in mapper
-        map_ptr = (uint8_t *)ppm_page2vaddr( page ) + page_offset;
+        xptr_t base_xp = ppm_page2base( XPTR( local_cxy, page ) );
+        map_ptr = (uint8_t *)GET_PTR( base_xp ) + page_offset;
 
         // compute pointer in buffer
@@ -446 +447 @@
         if ( page == NULL ) return EINVAL;
 
+        // get page base address
+        uint8_t * base = (uint8_t *)GET_PTR( XPTR( local_cxy , page ) );
+        
         // compute source and destination pointers
         if( to_buffer )
         {
-            dst_ptr = buf_ptr + done;
-            src_ptr = (uint8_t *)ppm_page2vaddr( page ) + page_offset;
+            dst_ptr = buffer_ptr + done;
+            src_ptr = base + page_offset;
         }
         else
         {
-            src_ptr = buf_ptr + done;
-            dst_ptr = (uint8_t *)ppm_page2vaddr( page ) + page_offset;
+            src_ptr = buffer_ptr + done;
+            dst_ptr = base + page_offset;
 
             page_do_dirty( page );

trunk/kernel/mm/mapper.h

@@ -130 +130 @@
  * @ mapper       : local pointer on mapper.
  * @ to_buffer    : mapper -> buffer if true / buffer -> mapper if false.
- * @ is_user      : user space buffer if true / kernel local buffer if false.
  * @ file_offset  : first byte to move in file.
  * @ buffer       : user space pointer on user buffer.
@@ -138 +137 @@
 error_t mapper_move_user( mapper_t * mapper,
                           bool_t     to_buffer,
-                          bool_t     is_user,
                           uint32_t   file_offset,
                           void     * buffer,

trunk/kernel/mm/page.c

@@ -232 +232 @@
 }
 
-//////////////////////////////
-void page_copy(  page_t * dst,
-                 page_t * src )
-{
-        uint32_t  size;
-        void    * src_base;
-        void    * dst_base;
-
-        assert( (dst->order == src->order) , __FUNCTION__ , "src size != dst size\n" );
-
-        size = (1 << dst->order) * CONFIG_PPM_PAGE_SIZE;
-        src_base = ppm_page2vaddr( src );
-        dst_base = ppm_page2vaddr( dst );
-
-        memcpy( dst_base , src_base , size );
-}
-
 ///////////////////////////////
 void page_zero( page_t * page )
 {
-        uint32_t   size;
-        void     * base;
-
-        size = (1 << page->order) * CONFIG_PPM_PAGE_SIZE;
-        base = ppm_page2vaddr( page );
-
-        memset( base , 0 , size );
+        uint32_t   size = (1 << page->order) * CONFIG_PPM_PAGE_SIZE;
+
+        xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
+
+        memset( GET_PTR( base_xp ) , 0 , size );
 }
 
@@ -266 +247 @@
         printk("*** Page %d : base = %x / flags = %x / order = %d / count = %d\n",
                 page->index,
-                ppm_page2vaddr( page ),
+                GET_PTR( ppm_page2base( XPTR( local_cxy , page ) ) ),
                 page->flags,
                 page->order,

trunk/kernel/mm/page.h

@@ -132 +132 @@
 
 /*************************************************************************************
- * This function makes a local copy of the content of a src page to a dst page.
- *************************************************************************************
- * @ dst      : pointer on destination page descriptor.
- * @ src      : pointer on source page descriptor.
- ************************************************************************************/
-void page_copy( page_t * dst,
-                page_t * src );
-
-/*************************************************************************************
  * This function resets to 0 all bytes in a given page.
  *************************************************************************************

trunk/kernel/mm/ppm.c

@@ -47 +47 @@
 
 
+
 /////////////////////////////////////////////
-inline void * ppm_page2vaddr( page_t * page )
-{
-        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
-        return ppm->vaddr_base + ((page - ppm->pages_tbl) << CONFIG_PPM_PAGE_SHIFT);
-}
-
-//////////////////////////////////////////////
-inline page_t * ppm_vaddr2page( void * vaddr )
-{
-        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
-        return ppm->pages_tbl + (vaddr - ppm->vaddr_base);
-}
+inline xptr_t ppm_page2base( xptr_t page_xp )
+{
+        ppm_t  * ppm      = &LOCAL_CLUSTER->ppm;
+
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    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);
+  
+        return XPTR( page_cxy , base_ptr );
+
+} // end ppm_page2base()
+
+/////////////////////////////////////////////
+inline xptr_t ppm_base2page( xptr_t base_xp )
+{
+        ppm_t  * ppm = &LOCAL_CLUSTER->ppm;
+
+    cxy_t    base_cxy = GET_CXY( base_xp );
+    void   * base_ptr = (void *)GET_PTR( base_xp );
+
+        page_t * page_ptr = ppm->pages_tbl + 
+                        ((base_ptr - ppm->vaddr_base)>>CONFIG_PPM_PAGE_SHIFT);
+
+        return XPTR( base_cxy , page_ptr );
+
+}  // end ppm_base2page()
+
+
+
+///////////////////////////////////////////
+inline ppn_t ppm_page2ppn( xptr_t page_xp )
+{
+        ppm_t  * ppm      = &LOCAL_CLUSTER->ppm;
+
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = (page_t *)GET_PTR( page_xp );
+
+    paddr_t  paddr    = PADDR( page_cxy , (page_ptr - ppm->pages_tbl)<<CONFIG_PPM_PAGE_SHIFT );
+
+    return paddr >> CONFIG_PPM_PAGE_SHIFT;
+
+}  // end hal_page2ppn()
+
+///////////////////////////////////////
+inline xptr_t ppm_ppn2page( ppn_t ppn )
+{
+        ppm_t  * ppm      = &LOCAL_CLUSTER->ppm;
+
+    paddr_t  paddr    = ppn << CONFIG_PPM_PAGE_SHIFT;
+
+    cxy_t    page_cxy = CXY_FROM_PADDR( paddr );
+    lpa_t    page_lpa = LPA_FROM_PADDR( paddr );
+
+    return XPTR( page_cxy , &ppm->pages_tbl[page_lpa>>CONFIG_PPM_PAGE_SHIFT] );
+
+}  // end hal_ppn2page
+
+
+
+///////////////////////////////////////
+inline xptr_t ppm_ppn2base( ppn_t ppn )
+{
+        ppm_t  * ppm      = &LOCAL_CLUSTER->ppm;
+   
+    paddr_t  paddr    = ppn << CONFIG_PPM_PAGE_SHIFT;
+
+    cxy_t    page_cxy = CXY_FROM_PADDR( paddr );
+    lpa_t    page_lpa = LPA_FROM_PADDR( paddr );
+
+    void   * base_ptr = (void *)ppm->vaddr_base + (page_lpa & ~CONFIG_PPM_PAGE_SHIFT);
+  
+        return XPTR( page_cxy , base_ptr );
+
+}  // end ppm_ppn2base()
+
+///////////////////////////////////////////
+inline ppn_t ppm_base2ppn( xptr_t base_xp )
+{
+        ppm_t  * ppm      = &LOCAL_CLUSTER->ppm;
+
+    cxy_t    base_cxy = GET_CXY( base_xp );
+    void   * base_ptr = (void *)GET_PTR( base_xp );
+
+    paddr_t  paddr    = PADDR( base_cxy , (base_ptr - ppm->vaddr_base) );
+
+    return paddr >> CONFIG_PPM_PAGE_SHIFT;
+
+}  // end ppm_base2ppn()
+
+
 
 ///////////////////////////////////////////

trunk/kernel/mm/ppm.h

@@ -106 +106 @@
 inline bool_t ppm_page_is_valid( page_t * page );
 
-/*****************************************************************************************
- * Get the page virtual address from the page descriptor pointer.
- *****************************************************************************************
- * @ page         : pointer to page descriptor
- * @ returns virtual address of page itself.
- ****************************************************************************************/
-inline void* ppm_page2vaddr( page_t * page );
+
 
 /*****************************************************************************************
- * Get the page descriptor pointer from the page virtual address.
+ * Get extended pointer on page base from extended pointer on page descriptor.
  *****************************************************************************************
- * @ vaddr        : page virtual address
- * @ returns pointer on page descriptor
+ * @ page_xp    : extended pointer to page descriptor
+ * @ returns extended pointer on page base.
  ****************************************************************************************/
-inline page_t * ppm_vaddr2page( void * vaddr );
+inline xptr_t ppm_page2base( xptr_t page_xp );
+
+/*****************************************************************************************
+ * Get extended pointer on page descriptor from extended pointer on page base.
+ *****************************************************************************************
+ * @ base_xp   : extended pointer to page base.
+ * @ returns extended pointer on page descriptor
+ ****************************************************************************************/
+inline xptr_t ppm_base2page( xptr_t base_xp );
+
+
+
+/*****************************************************************************************
+ * Get extended pointer on page base from Global PPN.
+ *****************************************************************************************
+ * @ ppn    : global physical page number.
+ * @ returns extended pointer on page base.
+ ****************************************************************************************/
+inline xptr_t ppm_ppn2base( ppn_t ppn );
+
+/*****************************************************************************************
+ * Get global PPN from extended pointer on page base.
+ *****************************************************************************************
+ * @ base_xp   : extended pointer to page base.
+ * @ returns global physical page number.
+ ****************************************************************************************/
+inline ppn_t ppm_base2ppn( xptr_t base_xp );
+
+
+
+/*****************************************************************************************
+ * Get global PPN from extended pointer on page descriptor.
+ *****************************************************************************************
+ * @ page_xp   : pointer to page descriptor
+ * @ returns global physical page number.
+ ****************************************************************************************/
+inline ppn_t ppm_page2ppn( xptr_t page_xp );
+
+/*****************************************************************************************
+ * Get extended pointer on page descriptor from global PPN.
+ *****************************************************************************************
+ * @ ppn       : global physical page number
+ * @ returns extended pointer on page descriptor.
+ ****************************************************************************************/
+inline xptr_t ppm_ppn2page( ppn_t ppn );
+
+
 
 /*****************************************************************************************

trunk/kernel/mm/vmm.c

@@ -524 +524 @@
 
     // initialize vseg descriptor
-        vseg_init( vseg , base, size , vpn_base , vpn_size , type , local_cxy , 0 , 0 );
+        vseg_init( vseg , base, size , vpn_base , vpn_size , type , local_cxy );
 
     // update "heap_vseg" in VMM
@@ -633 +633 @@
 
         // set page table entry
-        ppn = ppm_page2ppn( page );
+        ppn = ppm_page2ppn( XPTR( local_cxy , page ) );
         error = hal_gpt_set_pte( gpt , vpn , ppn , attr );
                 if( error )
@@ -752 +752 @@
     uint32_t   type      = vseg->type;
     xptr_t     mapper_xp = vseg->mapper_xp;
+    uint32_t   flags     = vseg->flags;
 
     // get mapper cluster and local pointer
@@ -816 +817 @@
 
             // compute missing page offset in .elf file
-            intptr_t page_offset = vseg->file_offset + (page_index << PPM_PAGE_SHIFT);
-
-            // compute both local and extended pointer on page first byte 
-            // WARNING : the pages_offset must have the same value in all clusters !!!
-            //           to use this ppm_page2vaddr() function for a remote cluster
-            uint8_t * base_ptr = (uint8_t *)ppm_page2vaddr( page_ptr );
-            xptr_t    base_xp  = XPTR( page_cxy , base_ptr );
+            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
-            file_size = vseg->file_size;
-
-            if( file_size < page_offset )                          // page fully in  BSS 
+            intptr_t file_size = vseg->file_size;
+
+            if( file_size < page_offset )                                // fully in  BSS 
             {
                 if( page_cxy == local_cxy )
                 {
-                    memset( base_ptr , 0 , PPM_PAGE_SIZE );
+                    memset( GET_PTR( base_xp ) , 0 , CONFIG_PPM_PAGE_SIZE );
                 }
                 else
                 {
-                   hal_remote_memset( base_xp , 0 , PPM_PAGE_SIZE );       
+                   hal_remote_memset( base_xp , 0 , CONFIG_PPM_PAGE_SIZE );       
                 }
             }
-            else if( file size >= (page_offset + PPM_PAGE_SIZE) )  // page fully in  mapper
-    
+            else if( file_size >= (page_offset + CONFIG_PPM_PAGE_SIZE) )  // fully in  mapper
+            {
                 if( mapper_cxy == local_cxy ) 
                 {
@@ -846 +845 @@
                                                 page_offset,
                                                 base_xp,
-                                                PPM_PAGE_SIZE ); 
+                                                CONFIG_PPM_PAGE_SIZE ); 
                 }
                 else 
@@ -856 +855 @@
                                                    page_offset,
                                                    (uint64_t)base_xp,
-                                                   PPM_PAGE_SIZE,
+                                                   CONFIG_PPM_PAGE_SIZE,
                                                    &error );
                 }
@@ -865 +864 @@
             {
                 // initialize mapper part
-                if( mapper_cxy == local_cxy )                    // mapper is local
+                if( mapper_cxy == local_cxy )
                 {
                     error = mapper_move_kernel( mapper_ptr,
-                                                true,         // to_buffer
+                                                true,         // to buffer
                                                 page_offset,
                                                 base_xp,
                                                 file_size - page_offset ); 
                 }
-                else                                             // mapper is remote
+                else                                
                 {
                     rpc_mapper_move_buffer_client( mapper_cxy,
                                                    mapper_ptr,
-                                                   true,
+                                                   true,         // to buffer
                                                    false,        // kernel buffer
                                                    page_offset,
@@ -889 +888 @@
                 if( page_cxy == local_cxy )
                 {
-                    memset( base_ptr + file_size - page_offset , 0 , 
-                            page_offset + PPM_PAGE_SIZE - file_size );
+                    memset( GET_PTR( base_xp ) + file_size - page_offset , 0 , 
+                            page_offset + CONFIG_PPM_PAGE_SIZE - file_size );
                 }
                 else
                 {
                    hal_remote_memset( base_xp + file_size - page_offset , 0 , 
-                                      page_offset + PPM_PAGE_SIZE - file_size );
+                                      page_offset + CONFIG_PPM_PAGE_SIZE - file_size );
                 }
             }    
@@ -902 +901 @@
 
     // return ppn
-    *ppn = hal_page2ppn( XPTR( page_cxy , page_ptr ) );
+    *ppn = ppm_page2ppn( XPTR( page_cxy , page_ptr ) );
     return 0;
 
@@ -1064 +1063 @@
     return error;
 
-}
-/*
+}  // end vmm_v2p_translate()
+
+/* deprecated
 
 ///////////////////////////////////////////////////////////////////

trunk/kernel/mm/vseg.c

@@ -92 +92 @@
                 vpn_t         vpn_size,
                         uint32_t      type,
-                cxy_t         cxy,
-                fdid_t        fdid,
-                        uint32_t      offset )
+                cxy_t         cxy )
 {
     vseg->type      = type;
@@ -101 +99 @@
     vseg->vpn_base  = vpn_base;
         vseg->vpn_size  = vpn_size;
-        vseg->mapper    = XPTR_NULL;
-        vseg->fdid      = fdid;
-        vseg->offset    = offset;
+        vseg->mapper_xp = XPTR_NULL;
     vseg->cxy       = cxy;
 
@@ -171 +167 @@
         hal_core_sleep();
     }
-}
+
+}  // end vseg_init()
 
 //////////////////////////////////////////
@@ -182 +179 @@
 
     // initialize vseg with remote_read access
-    vseg->type     =           hal_remote_lw ( XPTR( cxy , &ptr->type     ) );
-    vseg->min      = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->min      ) );
-    vseg->max      = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->max      ) );
-    vseg->vpn_base =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_base ) );
-    vseg->vpn_size =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_size ) );
-    vseg->flags    =           hal_remote_lw ( XPTR( cxy , &ptr->flags    ) );
-        vseg->mapper   = (xptr_t)  hal_remote_lwd( XPTR( cxy , &ptr->mapper   ) );
-
-    if( vseg->type == VSEG_TYPE_FILE )
-    {
-        vseg->fdid   = hal_remote_lw( XPTR( cxy , &ptr->fdid   ) );
-        vseg->offset = hal_remote_lw( XPTR( cxy , &ptr->offset ) );
-    }
-    else
-    {
-        vseg->fdid   = 0;
-        vseg->offset = 0;
-    }
+    vseg->type       =           hal_remote_lw ( XPTR( cxy , &ptr->type      ) );
+    vseg->min        = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->min       ) );
+    vseg->max        = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->max       ) );
+    vseg->vpn_base   =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_base  ) );
+    vseg->vpn_size   =           hal_remote_lw ( XPTR( cxy , &ptr->vpn_size  ) );
+    vseg->flags      =           hal_remote_lw ( XPTR( cxy , &ptr->flags     ) );
+        vseg->mapper_xp  = (xptr_t)  hal_remote_lwd( XPTR( cxy , &ptr->mapper_xp ) );
 }
 

trunk/kernel/mm/vseg.h

@@ -81 +81 @@
         vpn_t             vpn_size;     /*! number of pages occupied                             */
         uint32_t          flags;        /*! vseg attributes                                      */
-        xptr_t            file_mapper;  /*! xptr on remote mapper (for types CODE / DATA / FILE) */
-        intptr_t          file_offset;  /*! offset in file (for types CODE / DATA / FILE)        */
-    intptr_t          file_size;    /*! max segment size in mapper (for type DATA)           */
-    cxy_t             cxy;          /*! cluster for physical mapping (for non distributed)   */ 
+        xptr_t            mapper_xp;    /*! xptr on remote mapper (for types CODE / DATA / FILE) */
+        intptr_t          file_offset;  /*! vseg offset in file (for types CODE/DATA)            */
+    intptr_t          file_size;    /*! max segment size in mapper (for type CODE/DATA)      */
+    cxy_t             cxy;          /*! physical mapping (for non distributed vseg)          */ 
 }
 vseg_t;
@@ -123 +123 @@
  * @ type      : vseg type.
  * @ cxy       : target cluster for physical mapping.
- * @ fdid      : file descriptor index if VSEG_TYPE_FILE.
- * @ offset    : offset in file if VSEG_TYPE_FILE.
  *********************************************************************************************/
 void vseg_init( vseg_t      * vseg,
@@ -132 +130 @@
                 vpn_t         vpn_size,
                     uint32_t      type,
-                cxy_t         cxy,
-                fdid_t        fdid,
-                    uint32_t      offset );
+                cxy_t         cxy );
 
 /**********************************************************************************************