Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset db6e419 in mainline for uspace/srv/devman/devman.c


Ignore:
Timestamp:
2011-08-16T18:53:00Z (10 years ago)
Author:
Petr Koupy <petr.koupy@…>
Branches:
lfn, master
Children:
49160c4
Parents:
e0e922d (diff), 45058baa (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/devman/devman.c

    re0e922d rdb6e419  
    3737#include <ipc/driver.h>
    3838#include <ipc/devman.h>
    39 #include <devmap.h>
     39#include <loc.h>
    4040#include <str_error.h>
    4141#include <stdio.h>
     
    6666}
    6767
    68 static int devmap_functions_compare(unsigned long key[], hash_count_t keys,
     68static int loc_functions_compare(unsigned long key[], hash_count_t keys,
    6969    link_t *item)
    7070{
    71         fun_node_t *fun = hash_table_get_instance(item, fun_node_t, devmap_fun);
    72         return (fun->devmap_handle == (devmap_handle_t) key[0]);
    73 }
    74 
    75 static int devmap_devices_class_compare(unsigned long key[], hash_count_t keys,
     71        fun_node_t *fun = hash_table_get_instance(item, fun_node_t, loc_fun);
     72        return (fun->service_id == (service_id_t) key[0]);
     73}
     74
     75static int loc_devices_class_compare(unsigned long key[], hash_count_t keys,
    7676    link_t *item)
    7777{
    7878        dev_class_info_t *class_info
    79             = hash_table_get_instance(item, dev_class_info_t, devmap_link);
     79            = hash_table_get_instance(item, dev_class_info_t, loc_link);
    8080        assert(class_info != NULL);
    8181
    82         return (class_info->devmap_handle == (devmap_handle_t) key[0]);
     82        return (class_info->service_id == (service_id_t) key[0]);
    8383}
    8484
     
    9999};
    100100
    101 static hash_table_operations_t devmap_devices_ops = {
     101static hash_table_operations_t loc_devices_ops = {
    102102        .hash = devices_hash,
    103         .compare = devmap_functions_compare,
     103        .compare = loc_functions_compare,
    104104        .remove_callback = devices_remove_callback
    105105};
    106106
    107 static hash_table_operations_t devmap_devices_class_ops = {
     107static hash_table_operations_t loc_devices_class_ops = {
    108108        .hash = devices_hash,
    109         .compare = devmap_devices_class_compare,
     109        .compare = loc_devices_class_compare,
    110110        .remove_callback = devices_remove_callback
    111111};
     
    701701}
    702702
    703 /** Create devmap path and name for the function. */
    704 void devmap_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
    705 {
    706         char *devmap_pathname = NULL;
    707         char *devmap_name = NULL;
    708        
    709         asprintf(&devmap_name, "%s", fun->pathname);
    710         if (devmap_name == NULL)
     703/** Create loc path and name for the function. */
     704void loc_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
     705{
     706        char *loc_pathname = NULL;
     707        char *loc_name = NULL;
     708       
     709        asprintf(&loc_name, "%s", fun->pathname);
     710        if (loc_name == NULL)
    711711                return;
    712712       
    713         replace_char(devmap_name, '/', DEVMAP_SEPARATOR);
    714        
    715         asprintf(&devmap_pathname, "%s/%s", DEVMAP_DEVICE_NAMESPACE,
    716             devmap_name);
    717         if (devmap_pathname == NULL) {
    718                 free(devmap_name);
     713        replace_char(loc_name, '/', LOC_SEPARATOR);
     714       
     715        asprintf(&loc_pathname, "%s/%s", LOC_DEVICE_NAMESPACE,
     716            loc_name);
     717        if (loc_pathname == NULL) {
     718                free(loc_name);
    719719                return;
    720720        }
    721721       
    722         devmap_device_register_with_iface(devmap_pathname,
    723             &fun->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
    724        
    725         tree_add_devmap_function(tree, fun);
    726        
    727         free(devmap_name);
    728         free(devmap_pathname);
     722        loc_service_register_with_iface(loc_pathname,
     723            &fun->service_id, DEVMAN_CONNECT_FROM_LOC);
     724       
     725        tree_add_loc_function(tree, fun);
     726       
     727        free(loc_name);
     728        free(loc_pathname);
    729729}
    730730
     
    856856        hash_table_create(&tree->devman_functions, DEVICE_BUCKETS, 1,
    857857            &devman_functions_ops);
    858         hash_table_create(&tree->devmap_functions, DEVICE_BUCKETS, 1,
    859             &devmap_devices_ops);
     858        hash_table_create(&tree->loc_functions, DEVICE_BUCKETS, 1,
     859            &loc_devices_ops);
    860860       
    861861        fibril_rwlock_initialize(&tree->rwlock);
     
    952952                list_initialize(&res->classes);
    953953                link_initialize(&res->devman_fun);
    954                 link_initialize(&res->devmap_fun);
     954                link_initialize(&res->loc_fun);
    955955        }
    956956       
     
    12681268                memset(info, 0, sizeof(dev_class_info_t));
    12691269                link_initialize(&info->dev_classes);
    1270                 link_initialize(&info->devmap_link);
     1270                link_initialize(&info->loc_link);
    12711271                link_initialize(&info->link);
    12721272        }
     
    14141414        list_initialize(&class_list->classes);
    14151415        fibril_rwlock_initialize(&class_list->rwlock);
    1416         hash_table_create(&class_list->devmap_functions, DEVICE_BUCKETS, 1,
    1417             &devmap_devices_class_ops);
    1418 }
    1419 
    1420 
    1421 /* Devmap devices */
    1422 
    1423 fun_node_t *find_devmap_tree_function(dev_tree_t *tree, devmap_handle_t devmap_handle)
     1416        hash_table_create(&class_list->loc_functions, DEVICE_BUCKETS, 1,
     1417            &loc_devices_class_ops);
     1418}
     1419
     1420
     1421/* loc devices */
     1422
     1423fun_node_t *find_loc_tree_function(dev_tree_t *tree, service_id_t service_id)
    14241424{
    14251425        fun_node_t *fun = NULL;
    14261426        link_t *link;
    1427         unsigned long key = (unsigned long) devmap_handle;
     1427        unsigned long key = (unsigned long) service_id;
    14281428       
    14291429        fibril_rwlock_read_lock(&tree->rwlock);
    1430         link = hash_table_find(&tree->devmap_functions, &key);
     1430        link = hash_table_find(&tree->loc_functions, &key);
    14311431        if (link != NULL)
    1432                 fun = hash_table_get_instance(link, fun_node_t, devmap_fun);
     1432                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
    14331433        fibril_rwlock_read_unlock(&tree->rwlock);
    14341434       
     
    14361436}
    14371437
    1438 fun_node_t *find_devmap_class_function(class_list_t *classes,
    1439     devmap_handle_t devmap_handle)
     1438fun_node_t *find_loc_class_function(class_list_t *classes,
     1439    service_id_t service_id)
    14401440{
    14411441        fun_node_t *fun = NULL;
    14421442        dev_class_info_t *cli;
    14431443        link_t *link;
    1444         unsigned long key = (unsigned long)devmap_handle;
     1444        unsigned long key = (unsigned long)service_id;
    14451445       
    14461446        fibril_rwlock_read_lock(&classes->rwlock);
    1447         link = hash_table_find(&classes->devmap_functions, &key);
     1447        link = hash_table_find(&classes->loc_functions, &key);
    14481448        if (link != NULL) {
    14491449                cli = hash_table_get_instance(link, dev_class_info_t,
    1450                     devmap_link);
     1450                    loc_link);
    14511451                fun = cli->fun;
    14521452        }
     
    14561456}
    14571457
    1458 void class_add_devmap_function(class_list_t *class_list, dev_class_info_t *cli)
    1459 {
    1460         unsigned long key = (unsigned long) cli->devmap_handle;
     1458void class_add_loc_function(class_list_t *class_list, dev_class_info_t *cli)
     1459{
     1460        unsigned long key = (unsigned long) cli->service_id;
    14611461       
    14621462        fibril_rwlock_write_lock(&class_list->rwlock);
    1463         hash_table_insert(&class_list->devmap_functions, &key, &cli->devmap_link);
     1463        hash_table_insert(&class_list->loc_functions, &key, &cli->loc_link);
    14641464        fibril_rwlock_write_unlock(&class_list->rwlock);
    14651465
    1466         assert(find_devmap_class_function(class_list, cli->devmap_handle) != NULL);
    1467 }
    1468 
    1469 void tree_add_devmap_function(dev_tree_t *tree, fun_node_t *fun)
    1470 {
    1471         unsigned long key = (unsigned long) fun->devmap_handle;
     1466        assert(find_loc_class_function(class_list, cli->service_id) != NULL);
     1467}
     1468
     1469void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun)
     1470{
     1471        unsigned long key = (unsigned long) fun->service_id;
    14721472        fibril_rwlock_write_lock(&tree->rwlock);
    1473         hash_table_insert(&tree->devmap_functions, &key, &fun->devmap_fun);
     1473        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
    14741474        fibril_rwlock_write_unlock(&tree->rwlock);
    14751475}
Note: See TracChangeset for help on using the changeset viewer.