Changeset 615

Timestamp:

Jul 15, 2015, 6:17:41 PM (9 years ago)

Author:

bellefin

Message:

Introduce mmc distributed lock
The locks are distributed in the kernel heaps (one lock in each cluster) and there is a global table in the kernel data segment which contains the addresses of all the locks.
The _mmc_boot_mode variable is defined in boot.c and kernel_init.c and defines which kind of lock is used.
The distributed locks are initialized inside the kernel_init() function.

Location:

soft/giet_vm

Files:

• giet_boot/boot.c (modified) (1 diff)
• giet_drivers/mmc_driver.c (modified) (5 diffs)
• giet_drivers/mmc_driver.h (modified) (2 diffs)
• giet_kernel/kernel_init.c (modified) (2 diffs)

soft/giet_vm/giet_boot/boot.c

@@ -164 +164 @@
 unsigned int        _tty0_boot_mode = 1;
 
+// boot code does not use distributed locks to protect MMC
+__attribute__((section(".kdata")))
+unsigned int        _mmc_boot_mode = 1;
+
 // boot code does not uses a lock to protect HBA command allocator
 __attribute__((section(".kdata")))

soft/giet_vm/giet_drivers/mmc_driver.c

@@ -39 +39 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// Distributed locks protecting MMC components (one per cluster)
-///////////////////////////////////////////////////////////////////////////////
+// Locks protecting MMC components (one per cluster)
+// There are two kinds of lock: the _mmc_lock table contains all the locks and
+// and is stored in the kernel data segment, whereas the _mmc_distributed_lock
+// contains the addresses of locks which are distributed in every cluster (each
+// cluster contains the lock which protects its own mmc_component).
+// The global variable mmc_boot_mode define the type of lock which is used,
+// and must be defined in both kernel_init.c and boot.c files.
+// - the boot code must use a spin_lock because the kernel heap is not set.
+// - the kernel code can use a sqt_lock when the kernel heap is set.
+///////////////////////////////////////////////////////////////////////////////
+
+extern unsigned int  _mmc_boot_mode;
 
 __attribute__((section(".kdata")))
-spin_lock_t  _mmc_lock[X_SIZE][Y_SIZE]  __attribute__((aligned(64)));
+spin_lock_t           _mmc_lock[X_SIZE][Y_SIZE]  __attribute__((aligned(64)));
+
+__attribute__((section(".kdata")))
+spin_lock_t*          _mmc_distributed_lock[X_SIZE][Y_SIZE];
+
+//////////////////////////////////////////////////////////////////////////////
+// This function initializes the distributed locks stored in the kernel heaps
+//////////////////////////////////////////////////////////////////////////////
+
+void _mmc_init_locks()
+{
+    unsigned int cx;    // cluster X coordinate
+    unsigned int cy;    // cluster Y coordinate
+    
+    for ( cx = 0 ; cx < X_SIZE ; cx++ )
+    {
+        for ( cy = 0 ; cy < Y_SIZE ; cy++ )
+        {
+            _mmc_distributed_lock[cx][cy] = _remote_malloc( sizeof(spin_lock_t), cx, cy );
+            _spin_lock_init( _mmc_distributed_lock[cx][cy] );
+        }
+    }
+}
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -105 +137 @@
 
     // get the lock protecting exclusive access to MEMC
-    _spin_lock_acquire( &_mmc_lock[x][y] );
+    if ( _mmc_boot_mode ) _spin_lock_acquire( &_mmc_lock[x][y] );
+    else                  _spin_lock_acquire( _mmc_distributed_lock[x][y] );
 
     // write inval arguments
@@ -114 +147 @@
 
     // release the lock 
-    _spin_lock_release( &_mmc_lock[x][y] );
+    if ( _mmc_boot_mode ) _spin_lock_release( &_mmc_lock[x][y] );
+    else                  _spin_lock_release( _mmc_distributed_lock[x][y] );
 }
 
@@ -140 +174 @@
 
     // get the lock protecting exclusive access to MEMC
-    _spin_lock_acquire( &_mmc_lock[x][y] );
+    if ( _mmc_boot_mode ) _spin_lock_acquire( &_mmc_lock[x][y] );
+    else                  _spin_lock_acquire( _mmc_distributed_lock[x][y] );
 
     // write inval arguments
@@ -149 +184 @@
 
     // release the lock 
-    _spin_lock_release( &_mmc_lock[x][y] );
+    if ( _mmc_boot_mode ) _spin_lock_release( &_mmc_lock[x][y] );
+    else                  _spin_lock_release( _mmc_distributed_lock[x][y] );
 }
 

soft/giet_vm/giet_drivers/mmc_driver.h

@@ -11 +11 @@
 #include <hard_config.h>
 #include <kernel_locks.h>
+#include <kernel_malloc.h>
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -124 +125 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
+extern void _mmc_init_locks();
+
 extern unsigned int _mmc_instrument( unsigned int x,
                                      unsigned int y,

soft/giet_vm/giet_kernel/kernel_init.c

@@ -113 +113 @@
 unsigned int   _tty0_boot_mode = 0;
 
+// Kernel uses distributed locks to protect MMC   
+__attribute__((section(".kdata")))
+unsigned int   _mmc_boot_mode = 0;
+
 // Kernel uses sqt_lock to protect command allocator in HBA        
 __attribute__((section(".kdata")))
@@ -161 +165 @@
 #if GIET_DEBUG_INIT
 _nolock_printf("\n[DEBUG KINIT] P[%d,%d,%d] completes kernel heap init\n", x, y, p );
+#endif
+        //////  distributed lock for MMC
+        _mmc_init_locks();
+
+#if GIET_DEBUG_INIT
+_nolock_printf("\n[DEBUG KINIT] P[%d,%d,%d] completes MMC distributed lock init\n", x , y , p );
 #endif
         //////  distributed lock for TTY0