Changeset 623 for trunk/hal/tsar_mips32/core/hal_vmm.c

Timestamp:

Mar 6, 2019, 4:37:15 PM (5 years ago)

Author:

alain

Message:

Introduce three new types of vsegs (KCODE,KDATA,KDEV)
to map the kernel vsegs in the process VSL and GPT.
This now used by both the TSAR and the I86 architectures.

File:

• trunk/hal/tsar_mips32/core/hal_vmm.c (modified) (3 diffs)

trunk/hal/tsar_mips32/core/hal_vmm.c

@@ -2 +2 @@
  * hal_vmm.c - Virtual Memory Manager Initialisation for TSAR
  *
- * Authors  Alain Greiner (2016,2017)
+ * Authors  Alain Greiner (2016,2017,2018,2019)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -26 +26 @@
 #include <hal_vmm.h>
 #include <hal_gpt.h>
+#include <process.h>
 #include <vseg.h>
 #include <xlist.h>
@@ -32 +33 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// This file contains the TSAR specific code to initialize the Virtual Memory Manager.
-// The "kentry" vseg contains the kernel code executed when a core enter/exit the kernel,
-// in case of Interrupt, Exception, or Syscall.
-// For the TSAR architecture, the kernel uses physical addresses, and this code must be
-// identity mapped. The following function is called by the generic vmm_init() function
-// and identity map all pages of the "kentry" vseg.
-// We dont take the locks protecting the VSL and the GPT, because there is no concurrent
-// accesses to VMM during VMM initialization.
+// This file contains the TSAR specific code used to initialize the kernel process VMM,
+// or to update an user process VMM with informations related to the kernel vsegs.
+// As the TSAR architure does not use the DATA MMU, but use only the DATA extension
+// address register to access local and remote kernel data, the kernel VSL contains only
+// one "kcode" segment, and the kernel GPT contains only one big page in PT1[0] slot.
 //////////////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////
-error_t  hal_vmm_init( vmm_t * vmm )
+// extern global variables
+extern process_t process_zero;
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function is called by the process_zero_init() function during kernel_init.
+// It initializes the VMM of the kernel proces_zero (containing all kernel threads)
+// in the local cluster.
+//////////////////////////////////////////////////////////////////////////////////////////
+error_t  hal_vmm_kernel_init( boot_info_t * info )
 {
-    error_t error;
+    error_t   error;
 
-    // map all pages of "kentry" vseg
-    uint32_t vpn;
-    uint32_t attr;
-    attr = GPT_MAPPED | GPT_SMALL | GPT_EXECUTABLE | GPT_CACHABLE | GPT_GLOBAL;
-    for( vpn = CONFIG_VMM_KENTRY_BASE;
-         vpn < (CONFIG_VMM_KENTRY_BASE + CONFIG_VMM_KENTRY_SIZE); vpn++ )
+    // get pointer on kernel GPT
+    gpt_t * gpt = &process_zero.vmm.gpt;
+
+    // get cluster identifier
+    cxy_t cxy = local_cxy;
+
+    // allocate memory for kernel GPT
+    error = hal_gpt_create( gpt );
+
+    if( error )
     {
-        error = hal_gpt_set_pte( XPTR( local_cxy , &vmm->gpt ),
-                                 vpn,
-                                 attr,
-                                 (local_cxy<<20) | (vpn & 0xFFFFF) );
-
-        if( error ) return error;
+        printk("\n[PANIC] in %s : cannot allocate kernel GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
     }
 
-    // scan the VSL to found the "kentry" vseg
-    xptr_t         root_xp = XPTR( local_cxy , &vmm->vsegs_root );
-    xptr_t         iter_xp;
-    xptr_t         vseg_xp;
-    vseg_t       * vseg;
-    bool_t         found = false;
- 
-    XLIST_FOREACH( root_xp , iter_xp )
+    // compute attr and ppn for one PTE1
+    uint32_t attr  = 0x8A800000;           // bits : V,C,X,G
+    uint32_t ppn   = (cxy << 20) >> 9;     // physical page index is 0
+
+    // set PTE1  in slot[0]
+    error = hal_gpt_set_pte( XPTR( cxy , gpt ) , 0 , attr , ppn );
+
+    if( error )
     {
-        vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
-        vseg    = (vseg_t *)GET_PTR( vseg_xp );
-
-        // set the IDENT flag in "kentry" vseg descriptor
-        if( vseg->vpn_base == CONFIG_VMM_KENTRY_BASE )
-        {
-            vseg->flags |= VSEG_IDENT;
-            found = true;
-            break;
-        }
+        printk("\n[PANIC] in %s : cannot initialize kernel GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
     }
 
-    if( found == false ) return 0XFFFFFFFF;
-
-    return 0;
+    // create kcode vseg and register it in kernel VSL
+    vseg_t * vseg = vmm_create_vseg( &process_zero,
+                                     VSEG_TYPE_CODE,
+                                     info->kcode_base,
+                                     info->kcode_size,
+                                     0, 0,                  // file ofset and file size (unused)
+                                     XPTR_NULL,             // no mapper
+                                     local_cxy );
+    if( vseg == NULL )
+    {
+        printk("\n[PANIC] in %s : cannot register vseg to VSL in cluster %x\n",
+        __FUNCTION__ , cxy );
+        hal_core_sleep();
+    }
 
 }  // end hal_vmm_init()
 
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function is called by the vmm_init() function to update the VMM of an user
+// process identified by the <process> argument.
+// It registers in the user VSL the "kcode" vseg, registered in the local kernel VSL,
+// and register in the user GPT the big page[0] mapped in the local kernel GPT. 
+//////////////////////////////////////////////////////////////////////////////////////////
+error_t hal_vmm_kernel_update( process_t * process )
+{
+    error_t error;
+    uint32_t attr;
+    uint32_t ppn;
 
+// TODO check ppn value in kernel GPT (must be 0)
+
+    // get cluster identifier
+    cxy_t cxy = local_cxy;
+
+    // get extended pointer on user GPT
+    xptr_t gpt_xp = XPTR( cxy , &process->vmm.gpt );
+
+    // get ppn and attributes from slot[0] in kernel GPT
+    hal_gpt_get_pte( gpt_xp , 0 , &attr , &ppn );
+
+// check ppn and attributes 
+assert( (attr == 0x8A800000) && (ppn == ((cxy << 20) >> 9)),  __FUNCTION__,
+"bad ppn = %x or attr = %x in slot[0] of kernel GPT\n", ppn , attr );
+ 
+    // update user GPT : set PTE1 in slot[0]
+    error = hal_gpt_set_pte( gpt_xp , 0 , attr , ppn );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update GPT in cluster %x\n",
+        __FUNCTION__ , cxy );
+        return -1;
+    }
+
+    // get pointer on the unique vseg registered in kernel VSL
+    xptr_t root_xp = XPTR( cxy , &process_zero.vmm.vsegs_root );
+    vseg_t * vseg = XLIST_FIRST( root_xp , vseg_t , xlist );
+
+// check vsegs_nr 
+assert( (process_zero.vmm.vsegs_nr == 1 ) , __FUNCTION__,
+"bad vsegs number in kernel VSL\n" );
+
+    // update user VSL : register one new vseg for kcode
+    vseg_t * new = vmm_create_vseg( process,
+                                    vseg->type,
+                                    vseg->min,
+                                    vseg->max - vseg->min,
+                                    0, 0,                  // file ofset and file size (unused)
+                                    XPTR_NULL,             // no mapper
+                                    local_cxy );
+    if( new == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot update VSL in cluster %x\n",
+        __FUNCTION__ , cxy );
+        return -1;
+    }
+}
+
+