Changeset 188 for trunk/kernel/libk/xhtab.c

Timestamp:

Jul 12, 2017, 8:12:41 PM (7 years ago)

Author:

alain

Message:

Redefine the PIC device API.

File:

• trunk/kernel/libk/xhtab.c (modified) (10 diffs)

trunk/kernel/libk/xhtab.c

@@ -35 +35 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// Item type specific (static) functions (two functions for each item type).
-// - for type <vfs_dentry_t>, identifier is the name field.
-///////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// These static functions compute the hash index from the key.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ key      : local pointer on key.
+// Item type specific functions (three functions for each item type).
+///////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// This functions compute the hash index from the key when item is a vfs_dentry_t.
+// The key is the directory entry name.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ key      : local pointer on name.
 // @ return the index value, from 0 to (HASHTAB_SIZE - 1)
 ///////////////////////////////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////
-uint32_t xhtab_dentry_index( void * key )
+static uint32_t xhtab_dentry_index_from_key( void * key )
 {
         char     * name  = key;
@@ -55 +53 @@
         index = index + (*(name++) ^ index);
     }
-        return index % HASHTAB_SIZE;
+        return index % XHASHTAB_SIZE;
 } 
 
+///////////////////////////////////////////////////////////////////////////////////////////
+// This functions returns the extended pointer on the item, from the extended pointer 
+// on xlist contained in the item, when the item is a vfs_entry_t.
+///////////////////////////////////////////////////////////////////////////////////////////
+// @ xlist_xp      : extended pointer on embedded xlist entry.
+// @ return the extended pointer on the dentry containing this xlist entry.
+///////////////////////////////////////////////////////////////////////////////////////////
+static xptr_t xhtab_dentry_item_from_xlist( xptr_t xlist_xp )
+{
+    return XLIST_ELEMENT( xlist_xp , vfs_dentry_t , list );
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////
-// These static function are used by xhtab_lookup(), xhtab_insert(), xhtab_remove().
-// They scan one sub-list identified by  <index> to find an item  identified by <key>.
-// The sub-list is not modified, but the readlock must have been taken by the caller.
+// This function compare the identifier of an item to a given <key>. For a vfs_entry_t,
+// it returns true when the directory name matches the name pointed by the <key> argument.
 ////////////////////////////////////////////////////////////////////////////////////////////
-// @ xhtab_xp  : extended pointer on hash table.
-// @ index     : index of sub-list to be scanned.
-// @ key       : local pointer on item identifier.
-// return an extended pointer on item if found / return XPTR_NULL if not found.
+// @ item_xp   : extended pointer on item.
+// @ key       : pointer on searched item identifier.
+// returns true if given name matches directory entry name.
 ////////////////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////
-static xptr_t xhtab_dentry_scan( xptr_t    xhtab_xp,
-                                 uint32_t  index,
-                                 void    * key )
+static bool_t xhtab_dentry_item_match_key( xptr_t item_xp,
+                                           void    * key )
+{
+    vfs_dentry_t * dentry_ptr;
+    cxy_t          dentry_cxy;
+
+    char           name[CONFIG_VFS_MAX_NAME_LENGTH];
+
+    // get dentry cluster and local pointer
+    dentry_cxy = GET_CXY( item_xp );
+    dentry_ptr = (vfs_dentry_t *)GET_PTR( item_xp );
+
+    // make a local copy of directory entry name
+    hal_remote_strcpy( XPTR( local_cxy , name ) ,
+                       XPTR( dentry_cxy , &dentry_ptr->name ) );
+
+    return( strcmp( name , (char*)key ) == 0 );
+}
+                       
+////////////////////////////////////////////////////////////////////////////////////////
+//         Generic access functions
+////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////
+void xhtab_init( xhtab_t          * xhtab,
+                 xhtab_item_type_t  type )
+{
+        uint32_t i;
+
+    // initialize readlock
+    remote_rwlock_init( XPTR( local_cxy , &xhtab->lock) );
+
+    xhtab->items  = 0;
+
+    if( type == XHTAB_DENTRY_TYPE )
+    {
+        xhtab->item_match_key  = &xhtab_dentry_item_match_key;
+        xhtab->index_from_key  = &xhtab_dentry_index_from_key;
+        xhtab->item_from_xlist = &xhtab_dentry_item_from_xlist;
+    }
+    else
+    {
+        printk("\n[PANIC] in %s : illegal item type\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+        for( i=0 ; i < XHASHTAB_SIZE ; i++ )
+    {
+                xlist_root_init( XPTR( local_cxy , &xhtab->roots[i] ) );
+    }  
+
+}  // end xhtab_init()
+
+//////////////////////////////////////
+xptr_t xhtab_scan( xptr_t    xhtab_xp,
+                   uint32_t  index,
+                   void    * key )
 {
     xptr_t    xlist_xp;                                 // xlist_entry_t (iterator)
+    xptr_t    item_xp;                                  // associated item
     xhtab_t * xhtab_ptr;                                // hash table local pointer
     cxy_t     xhtab_cxy;                                // hash table cluster
-    char      local_name[CONFIG_VFS_MAX_NAME_LENGTH];   // local copy of dentry name
 
     // get hash table cluster and local pointer
@@ -86 +146 @@
     XLIST_FOREACH( XPTR( xhtab_cxy , &xhtab_ptr->roots[index] ) , xlist_xp )
     {
-        // get extended pointer on dentry containing the xlist_entry_t
-            xptr_t dentry_xp = XLIST_ELEMENT( xlist_xp , vfs_dentry_t , xlist );
-
-        // get dentry cluster and local pointer 
-        cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-        vfs_dentry_t * dentry_ptr = (vfs_dentry_t *)GET_PTR( dentry_xp );
-    
-        // make a local copy of dentry name
-        hal_remote_memcpy( XPTR( local_cxy  , local_name ) ,
-                           XPTR( dentry_cxy , dentry_ptr->name ),
-                           CONFIG_VFS_MAX_NAME_LENGTH  );
-
-        // check matching 
-        if( strcmp( local_name , (char *)key ) == 0 ) return dentry_xp; 
+        // get extended pointer on item containing the xlist entry
+            item_xp = xhtab_ptr->item_from_xlist( xlist_xp );
+
+        // check matching
+        if( xhtab_ptr->item_match_key( item_xp , key ) ) return item_xp;
     }
 
     // No matching item found
     return XPTR_NULL;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-//         Generic access functions
-////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////
-void xhtab_init( xhtab_t          * xhtab,
-                 xhtab_item_type_t  type )
-{
-        uint32_t i;
-
-    // initialize readlock
-    remote_rwlock_init( XPTR( local_cxy , &xhtab->lock) );
-
-    xhtab->items  = 0;
-
-    if( type == XHTAB_DENTRY_TYPE )
-    {
-        xhtab->scan  = &xhtab_dentry_scan;
-        xhtab->index = &xhtab_dentry_index;
-    }
-    else
-    {
-        printk("\n[PANIC] in %s : illegal item type\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
-        for( i=0 ; i < HASHTAB_SIZE ; i++ )
-    {
-                xlist_root_init( XPTR( local_cxy , &xhtab->roots[i] ) );
-    }  
 }
 
@@ -148 +167 @@
 
     // compute index from key
-        uint32_t index = xhtab_ptr->index( key );
+        uint32_t index = xhtab_ptr->index_from_key( key );
 
     // take the lock protecting hash table
@@ -154 +173 @@
 
     // search a matching item 
-    xptr_t item_xp = xhtab_ptr->scan( xhtab_xp , index , key );
+    xptr_t item_xp = xhtab_scan( xhtab_xp , index , key );
 
     if( item_xp != XPTR_NULL )    // error if found
@@ -188 +207 @@
 
     // compute index from key
-        uint32_t index = xhtab_ptr->index( key );
+        uint32_t index = xhtab_ptr->index_from_key( key );
 
     // take the lock protecting hash table
@@ -194 +213 @@
 
     // get extended pointer on item to remove
-    xptr_t item_xp = xhtab_ptr->scan( xhtab_xp , index , key );
+    xptr_t item_xp = xhtab_scan( xhtab_xp , index , key );
 
     if( item_xp == XPTR_NULL )    // error if not found
@@ -229 +248 @@
 
     // compute index from key
-        uint32_t index = xhtab_ptr->index( key );
+        uint32_t index = xhtab_ptr->index_from_key( key );
 
     // take the lock protecting hash table
@@ -235 +254 @@
 
     // scan sub-list
-    item_xp = xhtab_ptr->scan( xhtab_xp , index , key );
+    item_xp = xhtab_scan( xhtab_xp , index , key );
 
     // release the lock protecting hash table
@@ -244 +263 @@
 }  // end xhtab_lookup()
 
-
+///////////////////////////////////////
+void xhtab_read_lock( xptr_t xhtab_xp )
+{
+    // get xhtab cluster and local pointer 
+    cxy_t     xhtab_cxy = GET_CXY( xhtab_xp );
+    xhtab_t * xhtab_ptr = (xhtab_t *)GET_PTR( xhtab_xp );
+
+    // take the lock protecting hash table
+    remote_rwlock_rd_lock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+}
+
+/////////////////////////////////////////
+void xhtab_read_unlock( xptr_t xhtab_xp )
+{
+    // get xhtab cluster and local pointer 
+    cxy_t     xhtab_cxy = GET_CXY( xhtab_xp );
+    xhtab_t * xhtab_ptr = (xhtab_t *)GET_PTR( xhtab_xp );
+
+    // release the lock protecting hash table
+    remote_rwlock_rd_unlock( XPTR( xhtab_cxy , &xhtab_ptr->lock ) );
+}
+
+/////////////////////////////////////////
+xptr_t xhtab_get_first( xptr_t xhtab_xp )
+{
+    uint32_t index;
+    xptr_t   xlist_xp;
+    xptr_t   item_xp;
+    xptr_t   root_xp;
+
+    // get xhtab cluster and local pointer 
+    cxy_t     xhtab_cxy = GET_CXY( xhtab_xp );
+    xhtab_t * xhtab_ptr = (xhtab_t *)GET_PTR( xhtab_xp );
+
+    //loop on subsets
+    for( index = 0 ; index < XHASHTAB_SIZE ; index++ )
+    {
+        // get root of subset
+        root_xp = XPTR( xhtab_cxy , &xhtab_ptr->roots[index] );
+
+        // get first item
+        xlist_xp = xlist_next( root_xp , root_xp );
+
+        if( xlist_xp != XPTR_NULL )  // first item found
+        {
+            // get extended pointer on item containing the xlist entry
+                item_xp = xhtab_ptr->item_from_xlist( xlist_xp );
+
+            // register item in hash table header
+            hal_remote_sw ( XPTR( xhtab_cxy , &xhtab_ptr->current_index ) , index );
+            hal_remote_swd( XPTR( xhtab_cxy , &xhtab_ptr->current_xlist_xp ) , xlist_xp );
+
+            return item_xp;
+        }
+    }
+            
+    // item not found
+    return XPTR_NULL;
+
+} // end xhtab_get_first()
+    
+////////////////////////////////////////
+xptr_t xhtab_get_next( xptr_t xhtab_xp )
+{
+    uint32_t index;
+    xptr_t   xlist_xp;
+    xptr_t   item_xp;
+    xptr_t   root_xp;
+
+    uint32_t current_index;
+    xptr_t   current_xlist_xp;
+
+    // get xhtab cluster and local pointer 
+    cxy_t     xhtab_cxy = GET_CXY( xhtab_xp );
+    xhtab_t * xhtab_ptr = (xhtab_t *)GET_PTR( xhtab_xp );
+
+    // get current item pointers
+    current_index    = hal_remote_lw ( XPTR( xhtab_cxy , &xhtab_ptr->current_index ) ); 
+    current_xlist_xp = hal_remote_lwd( XPTR( xhtab_cxy , &xhtab_ptr->current_xlist_xp ) ); 
+
+    //loop on subsets
+    for( index = current_index ; index < XHASHTAB_SIZE ; index++ )
+    {
+        // get root of subset 
+        root_xp = XPTR( xhtab_cxy , &xhtab_ptr->roots[index] );
+
+        // get next item
+        xlist_xp = xlist_next( root_xp , current_xlist_xp );
+
+        if( xlist_xp != XPTR_NULL )  // next item found
+        {
+            // get extended pointer on item containing the xlist entry
+                item_xp = xhtab_ptr->item_from_xlist( xlist_xp );
+
+            // register item in hash table header
+            hal_remote_sw ( XPTR( xhtab_cxy , &xhtab_ptr->current_index ) , index );
+            hal_remote_swd( XPTR( xhtab_cxy , &xhtab_ptr->current_xlist_xp ) , xlist_xp );
+
+            return item_xp;
+        }
+    }
+            
+    // item not found
+    return XPTR_NULL;
+
+} // end xhtab_get_next()
+
+