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

File:

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

uspace/srv/devman/devman.c

@@ -66 +66 @@
 /* hash table operations */
 
-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_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 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 devman_functions_ops = {
+        .hash = devices_hash,
+        .compare = devman_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
+static hash_table_operations_t loc_devices_ops = {
+        .hash = devices_hash,
+        .compare = loc_functions_compare,
+        .remove_callback = devices_remove_callback
 };
 
@@ -1002 +974 @@
         tree->current_handle = 0;
         
-        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);
+        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);
         
         fibril_rwlock_initialize(&tree->rwlock);
@@ -1038 +1013 @@
         list_initialize(&dev->functions);
         link_initialize(&dev->driver_devices);
+        link_initialize(&dev->devman_dev);
         
         return dev;
@@ -1085 +1061 @@
 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));
         
-        ht_link_t *link = hash_table_find(&tree->devman_devices, &handle);
+        link = hash_table_find(&tree->devman_devices, &key);
         if (link == NULL)
                 return NULL;
         
-        return hash_table_get_inst(link, dev_node_t, devman_dev);
+        return hash_table_get_instance(link, dev_node_t, devman_dev);
 }
 
@@ -1165 +1144 @@
         link_initialize(&fun->dev_functions);
         list_initialize(&fun->match_ids.ids);
+        link_initialize(&fun->devman_fun);
+        link_initialize(&fun->loc_fun);
         
         return fun;
@@ -1213 +1194 @@
 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));
         
-        ht_link_t *link = hash_table_find(&tree->devman_functions, &handle);
+        link = hash_table_find(&tree->devman_functions, &key);
         if (link == NULL)
                 return NULL;
         
-        fun = hash_table_get_inst(link, fun_node_t, devman_fun);
+        fun = hash_table_get_instance(link, fun_node_t, devman_fun);
         
         return fun;
@@ -1299 +1282 @@
         /* Add the node to the handle-to-node map. */
         dev->handle = ++tree->current_handle;
-        hash_table_insert(&tree->devman_devices, &dev->devman_dev);
+        unsigned long key = dev->handle;
+        hash_table_insert(&tree->devman_devices, &key, &dev->devman_dev);
 
         /* Add the node to the list of its parent's children. */
@@ -1320 +1304 @@
         
         /* Remove node from the handle-to-node map. */
-        hash_table_remove(&tree->devman_devices, &dev->handle);
+        unsigned long key = dev->handle;
+        hash_table_remove(&tree->devman_devices, &key, 1);
         
         /* Unlink from parent function. */
@@ -1361 +1346 @@
         /* Add the node to the handle-to-node map. */
         fun->handle = ++tree->current_handle;
-        hash_table_insert(&tree->devman_functions, &fun->devman_fun);
+        unsigned long key = fun->handle;
+        hash_table_insert(&tree->devman_functions, &key, &fun->devman_fun);
 
         /* Add the node to the list of its parent's children. */
@@ -1381 +1367 @@
         
         /* Remove the node from the handle-to-node map. */
-        hash_table_remove(&tree->devman_functions, &fun->handle);
+        unsigned long key = fun->handle;
+        hash_table_remove(&tree->devman_functions, &key, 1);
         
         /* Remove the node from the list of its parent's children. */
@@ -1494 +1481 @@
 {
         fun_node_t *fun = NULL;
+        link_t *link;
+        unsigned long key = (unsigned long) service_id;
         
         fibril_rwlock_read_lock(&tree->rwlock);
-        ht_link_t *link = hash_table_find(&tree->loc_functions, &service_id);
+        link = hash_table_find(&tree->loc_functions, &key);
         if (link != NULL) {
-                fun = hash_table_get_inst(link, fun_node_t, loc_fun);
+                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
                 fun_add_ref(fun);
         }
@@ -1510 +1499 @@
         assert(fibril_rwlock_is_write_locked(&tree->rwlock));
         
-        hash_table_insert(&tree->loc_functions, &fun->loc_fun);
+        unsigned long key = (unsigned long) fun->service_id;
+        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
 }