Changeset 561 for trunk

Timestamp:

Sep 21, 2018, 10:26:47 PM (6 years ago)

Author:

nicolas.van.phan@…

Message:

Remove y_max in all functions except dqdt_init()

Location:

trunk/kernel

Files:

• fs/ramfs.c (modified) (1 diff)
• fs/vfs.c (modified) (2 diffs)
• fs/vfs.h (modified) (1 diff)
• kern/cluster.c (modified) (2 diffs)
• kern/cluster.h (modified) (1 diff)
• kern/kernel_init.c (modified) (1 diff)
• mm/vmm.c (modified) (2 diffs)

trunk/kernel/fs/ramfs.c

@@ -38 +38 @@
     xptr_t    root_inode_xp;   // unused                      
  
-    cxy_t     cxy = vfs_cluster_random_select();
+    cxy_t     cxy = cluster_random_select();
 
     // create VFS dentry and VFS inode for RAMFS root directory

trunk/kernel/fs/vfs.c

@@ -1124 +1124 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-/////////////////////////////////
-cxy_t vfs_cluster_random_select( void )
-{
-    uint32_t  x_max     = LOCAL_CLUSTER->x_max; // [FIXME]
-    uint32_t  y_max     = LOCAL_CLUSTER->y_max; // [FIXME]
-    uint32_t  y_width   = LOCAL_CLUSTER->y_width;
-    uint32_t  index     = ( hal_get_cycles() + hal_get_gid() ) % (x_max * y_max); // [FIXME]
-    uint32_t  x         = index / y_max; // [FIXME]
-    uint32_t  y         = index % y_max; // [FIXME]
-
-    return (x<<y_width) + y;
-}
-
 
 //////////////////////////////////////////////////////////////////////////
@@ -1512 +1499 @@
 
             // select a cluster for missing inode
-            child_cxy = vfs_cluster_random_select();
+            child_cxy = cluster_random_select();
  
             // insert a new child dentry/inode in inode tree

trunk/kernel/fs/vfs.h

@@ -517 +517 @@
 
 /****************************************************************************************** 
- * This function randomly selects a cluster for a new inode.
- ******************************************************************************************
- * @ returns the selected cluster identifier.
- *****************************************************************************************/
-cxy_t vfs_cluster_random_select( void );
-
-/****************************************************************************************** 
  * This function returns in a kernel buffer allocated by the caller function,
  * the pathname of a file/dir identified by an extended pointer on the inode. 

trunk/kernel/kern/cluster.c

@@ -45 +45 @@
 #include <process.h>
 #include <dqdt.h>
+#include <cluster_info.h>
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -212 +213 @@
 } // end cluster_init()
 
+/////////////////////////////////
+cxy_t cluster_random_select( void )
+{
+    uint32_t  x_size;
+    uint32_t  y_size;
+    uint32_t  y_width;
+    uint32_t  index;
+    uint32_t  x;
+    uint32_t  y;
+
+    do {
+        x_size     = LOCAL_CLUSTER->x_size;
+        y_size     = LOCAL_CLUSTER->y_size;
+        y_width   = LOCAL_CLUSTER->y_width;
+        index     = ( hal_get_cycles() + hal_get_gid() ) % (x_size * y_size);
+        x         = index / y_size;
+        y         = index % y_size;
+    } while ( cluster_info_is_active( LOCAL_CLUSTER->cluster_info[x][y] ) == 0 );
+
+    return (x<<y_width) + y;
+}
+
 ////////////////////////////////////////
 bool_t cluster_is_undefined( cxy_t cxy )

trunk/kernel/kern/cluster.h

@@ -176 +176 @@
 error_t cluster_init( boot_info_t * info );
 
+/****************************************************************************************** 
+ * This function randomly selects a cluster.
+ ******************************************************************************************
+ * @ returns the selected cluster identifier.
+ *****************************************************************************************/
+cxy_t cluster_random_select( void );
+
 /******************************************************************************************
  * This function checks the validity of a cluster identifier. 

trunk/kernel/kern/kernel_init.c

@@ -621 +621 @@
 
                 // compute target cluster for chdev[func,channel,direction]
-                uint32_t offset     = ext_chdev_gid % ( info->x_size * (info->y_max) ); // [FIXME]
-                uint32_t cx         = offset / (info->y_max); // [FIXME]
-                uint32_t cy         = offset % (info->y_max); // [FIXME]
-                uint32_t target_cxy = (cx<<info->y_width) + cy;
-
+                uint32_t offset;
+                uint32_t cx;
+                uint32_t cy;
+                uint32_t target_cxy;
+                while (1) {
+                    offset     = ext_chdev_gid % ( info->x_size * (info->y_size) );
+                    cx         = offset / (info->y_size);
+                    cy         = offset % (info->y_size);
+                    target_cxy = (cx<<info->y_width) + cy;
+                    // ext_chdev_gid that results in empty target clusters are skipped
+                    if ( cluster_info_is_active( LOCAL_CLUSTER->cluster_info[cx][cy] ) == 0 ) {
+                        ext_chdev_gid++;
+                    } else { // The ext_chdev_gid resulted in a full target cluster
+                        break;
+                    }
+                }
                 // allocate and initialize a local chdev
                 // when local cluster matches target cluster

trunk/kernel/mm/vmm.c

@@ -45 +45 @@
 #include <kmem.h>
 #include <vmm.h>
+#include <cluster_info.h>
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -1384 +1385 @@
     if( flags & VSEG_DISTRIB )    // distributed => cxy depends on vpn LSB
     {
-        uint32_t x_max   = LOCAL_CLUSTER->x_max; // [FIXME]
-        uint32_t y_max   = LOCAL_CLUSTER->y_max; // [FIXME]
+        uint32_t x_size  = LOCAL_CLUSTER->x_size;
+        uint32_t y_size  = LOCAL_CLUSTER->y_size;
         uint32_t y_width = LOCAL_CLUSTER->y_width;
-        uint32_t index   = vpn & ((x_max * y_max) - 1); // [FIXME]
-        uint32_t x       = index / y_max; // [FIXME]
-        uint32_t y       = index % y_max; // [FIXME]
-        page_cxy         = (x<<y_width) + y;
+        uint32_t index   = vpn & ((x_size * y_size) - 1);
+        uint32_t x       = index / y_size;
+        uint32_t y       = index % y_size;
+
+        // If the cluster selected from VPN's LSBs is empty, then we select one randomly
+        // cluster_random_select() ensures that its randomly selected cluster is not empty
+        if ( cluster_info_is_active( LOCAL_CLUSTER->cluster_info[x][y] ) == 0 ) {
+            cxy_t cxy = cluster_random_select();
+            x = ( ( cxy >> y_width ) & 0xF);
+            y = ( cxy & 0xF );
+        }
+        page_cxy = ( x << y_width ) + y;
     }
     else                          // other cases => cxy specified in vseg
     {
-        page_cxy         = vseg->cxy;
+        page_cxy = vseg->cxy;
     }