Changes in uspace/srv/devman/devman.c [4820360:bc216a0] in mainline

File:

• uspace/srv/devman/devman.c (modified) (14 diffs)

uspace/srv/devman/devman.c

@@ -66 +66 @@
 /* hash table operations */
 
-static hash_index_t devices_hash(unsigned long key[])
-{
-        return key[0] % DEVICE_BUCKETS;
-}
-
-static int devman_devices_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
-{
-        dev_node_t *dev = hash_table_get_instance(item, dev_node_t, devman_dev);
-        return (dev->handle == (devman_handle_t) key[0]);
-}
-
-static int devman_functions_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
-{
-        fun_node_t *fun = hash_table_get_instance(item, fun_node_t, devman_fun);
-        return (fun->handle == (devman_handle_t) key[0]);
-}
-
-static int loc_functions_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
-{
-        fun_node_t *fun = hash_table_get_instance(item, fun_node_t, loc_fun);
-        return (fun->service_id == (service_id_t) key[0]);
-}
-
-static void devices_remove_callback(link_t *item)
-{
-}
-
-static hash_table_operations_t devman_devices_ops = {
-        .hash = devices_hash,
-        .compare = devman_devices_compare,
-        .remove_callback = devices_remove_callback
+static inline size_t handle_key_hash(void *key)
+{
+        devman_handle_t handle = *(devman_handle_t*)key;
+        return handle;
+}
+
+static size_t devman_devices_hash(const ht_link_t *item)
+{
+        dev_node_t *dev = hash_table_get_inst(item, dev_node_t, devman_dev);
+        return handle_key_hash(&dev->handle);
+}
+
+static size_t devman_functions_hash(const ht_link_t *item)
+{
+        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, devman_fun);
+        return handle_key_hash(&fun->handle);
+}
+
+static bool devman_devices_key_equal(void *key, const ht_link_t *item)
+{
+        devman_handle_t handle = *(devman_handle_t*)key;
+        dev_node_t *dev = hash_table_get_inst(item, dev_node_t, devman_dev);
+        return dev->handle == handle;
+}
+
+static bool devman_functions_key_equal(void *key, const ht_link_t *item)
+{
+        devman_handle_t handle = *(devman_handle_t*)key;
+        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, devman_fun);
+        return fun->handle == handle;
+}
+
+static inline size_t service_id_key_hash(void *key)
+{
+        service_id_t service_id = *(service_id_t*)key;
+        return service_id;
+}
+
+static size_t loc_functions_hash(const ht_link_t *item)
+{
+        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, loc_fun);
+        return service_id_key_hash(&fun->service_id);
+}
+
+static bool loc_functions_key_equal(void *key, const ht_link_t *item)
+{
+        service_id_t service_id = *(service_id_t*)key;
+        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, loc_fun);
+        return fun->service_id == service_id;
+}
+
+
+static hash_table_ops_t devman_devices_ops = {
+        .hash = devman_devices_hash,
+        .key_hash = handle_key_hash,
+        .key_equal = devman_devices_key_equal,
+        .equal = 0,
+        .remove_callback = 0
 };
 
-static hash_table_operations_t devman_functions_ops = {
-        .hash = devices_hash,
-        .compare = devman_functions_compare,
-        .remove_callback = devices_remove_callback
+static hash_table_ops_t devman_functions_ops = {
+        .hash = devman_functions_hash,
+        .key_hash = handle_key_hash,
+        .key_equal = devman_functions_key_equal,
+        .equal = 0,
+        .remove_callback = 0
 };
 
-static hash_table_operations_t loc_devices_ops = {
-        .hash = devices_hash,
-        .compare = loc_functions_compare,
-        .remove_callback = devices_remove_callback
+static hash_table_ops_t loc_devices_ops = {
+        .hash = loc_functions_hash,
+        .key_hash = service_id_key_hash,
+        .key_equal = loc_functions_key_equal,
+        .equal = 0,
+        .remove_callback = 0
 };
 
@@ -974 +1002 @@
         tree->current_handle = 0;
         
-        hash_table_create(&tree->devman_devices, DEVICE_BUCKETS, 1,
-            &devman_devices_ops);
-        hash_table_create(&tree->devman_functions, DEVICE_BUCKETS, 1,
-            &devman_functions_ops);
-        hash_table_create(&tree->loc_functions, DEVICE_BUCKETS, 1,
-            &loc_devices_ops);
+        hash_table_create(&tree->devman_devices, 0, 0, &devman_devices_ops);
+        hash_table_create(&tree->devman_functions, 0, 0, &devman_functions_ops);
+        hash_table_create(&tree->loc_functions, 0, 0, &loc_devices_ops);
         
         fibril_rwlock_initialize(&tree->rwlock);
@@ -1013 +1038 @@
         list_initialize(&dev->functions);
         link_initialize(&dev->driver_devices);
-        link_initialize(&dev->devman_dev);
         
         return dev;
@@ -1052 +1076 @@
 }
 
+
 /** Find the device node structure of the device witch has the specified handle.
  *
@@ -1060 +1085 @@
 dev_node_t *find_dev_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
 {
-        unsigned long key = handle;
-        link_t *link;
-        
         assert(fibril_rwlock_is_locked(&tree->rwlock));
         
-        link = hash_table_find(&tree->devman_devices, &key);
+        ht_link_t *link = hash_table_find(&tree->devman_devices, &handle);
         if (link == NULL)
                 return NULL;
         
-        return hash_table_get_instance(link, dev_node_t, devman_dev);
+        return hash_table_get_inst(link, dev_node_t, devman_dev);
 }
 
@@ -1141 +1163 @@
         fun->state = FUN_INIT;
         atomic_set(&fun->refcnt, 0);
-        fibril_mutex_initialize(&fun->busy_lock);
         link_initialize(&fun->dev_functions);
         list_initialize(&fun->match_ids.ids);
-        link_initialize(&fun->devman_fun);
-        link_initialize(&fun->loc_fun);
         
         return fun;
@@ -1186 +1205 @@
 }
 
-/** Make function busy for reconfiguration operations. */
-void fun_busy_lock(fun_node_t *fun)
-{
-        fibril_mutex_lock(&fun->busy_lock);
-}
-
-/** Mark end of reconfiguration operation. */
-void fun_busy_unlock(fun_node_t *fun)
-{
-        fibril_mutex_unlock(&fun->busy_lock);
-}
-
 /** Find the function node with the specified handle.
  *
@@ -1206 +1213 @@
 fun_node_t *find_fun_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
 {
-        unsigned long key = handle;
-        link_t *link;
         fun_node_t *fun;
         
         assert(fibril_rwlock_is_locked(&tree->rwlock));
         
-        link = hash_table_find(&tree->devman_functions, &key);
+        ht_link_t *link = hash_table_find(&tree->devman_functions, &handle);
         if (link == NULL)
                 return NULL;
         
-        fun = hash_table_get_instance(link, fun_node_t, devman_fun);
+        fun = hash_table_get_inst(link, fun_node_t, devman_fun);
         
         return fun;
@@ -1294 +1299 @@
         /* Add the node to the handle-to-node map. */
         dev->handle = ++tree->current_handle;
-        unsigned long key = dev->handle;
-        hash_table_insert(&tree->devman_devices, &key, &dev->devman_dev);
+        hash_table_insert(&tree->devman_devices, &dev->devman_dev);
 
         /* Add the node to the list of its parent's children. */
@@ -1316 +1320 @@
         
         /* Remove node from the handle-to-node map. */
-        unsigned long key = dev->handle;
-        hash_table_remove(&tree->devman_devices, &key, 1);
+        hash_table_remove(&tree->devman_devices, &dev->handle);
         
         /* Unlink from parent function. */
@@ -1358 +1361 @@
         /* Add the node to the handle-to-node map. */
         fun->handle = ++tree->current_handle;
-        unsigned long key = fun->handle;
-        hash_table_insert(&tree->devman_functions, &key, &fun->devman_fun);
+        hash_table_insert(&tree->devman_functions, &fun->devman_fun);
 
         /* Add the node to the list of its parent's children. */
@@ -1379 +1381 @@
         
         /* Remove the node from the handle-to-node map. */
-        unsigned long key = fun->handle;
-        hash_table_remove(&tree->devman_functions, &key, 1);
+        hash_table_remove(&tree->devman_functions, &fun->handle);
         
         /* Remove the node from the list of its parent's children. */
@@ -1493 +1494 @@
 {
         fun_node_t *fun = NULL;
-        link_t *link;
-        unsigned long key = (unsigned long) service_id;
         
         fibril_rwlock_read_lock(&tree->rwlock);
-        link = hash_table_find(&tree->loc_functions, &key);
+        ht_link_t *link = hash_table_find(&tree->loc_functions, &service_id);
         if (link != NULL) {
-                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
+                fun = hash_table_get_inst(link, fun_node_t, loc_fun);
                 fun_add_ref(fun);
         }
@@ -1511 +1510 @@
         assert(fibril_rwlock_is_write_locked(&tree->rwlock));
         
-        unsigned long key = (unsigned long) fun->service_id;
-        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
+        hash_table_insert(&tree->loc_functions, &fun->loc_fun);
 }