Changeset 925a21e in mainline for uspace/srv/devman/devman.c


Ignore:
Timestamp:
2011-09-24T14:20:29Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5bf76c1
Parents:
867e2555 (diff), 1ab4aca (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

    r867e2555 r925a21e  
    3030 * @{
    3131 */
     32/** @file Device Manager
     33 *
     34 * Locking order:
     35 *   (1) driver_t.driver_mutex
     36 *   (2) dev_tree_t.rwlock
     37 *
     38 * Synchronization:
     39 *    - device_tree.rwlock protects:
     40 *        - tree root, complete tree topology
     41 *        - complete contents of device and function nodes
     42 *    - dev_node_t.refcnt, fun_node_t.refcnt prevent nodes from
     43 *      being deallocated
     44 *    - find_xxx() functions increase reference count of returned object
     45 *    - find_xxx_no_lock() do not increase reference count
     46 *
     47 * TODO
     48 *    - Track all steady and transient device/function states
     49 *    - Check states, wait for steady state on certain operations
     50 */
    3251
    3352#include <errno.h>
    … …  
    3756#include <ipc/driver.h>
    3857#include <ipc/devman.h>
    39 #include <devmap.h>
     58#include <loc.h>
    4059#include <str_error.h>
    4160#include <stdio.h>
    … …  
    4362#include "devman.h"
    4463
    45 fun_node_t *find_node_child(fun_node_t *parent, const char *name);
     64static fun_node_t *find_node_child(dev_tree_t *, fun_node_t *, const char *);
    4665
    4766/* hash table operations */
    … …  
    6685}
    6786
    68 static int devmap_functions_compare(unsigned long key[], hash_count_t keys,
     87static int loc_functions_compare(unsigned long key[], hash_count_t keys,
    6988    link_t *item)
    7089{
    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,
    76     link_t *item)
    77 {
    78         dev_class_info_t *class_info
    79             = hash_table_get_instance(item, dev_class_info_t, devmap_link);
    80         assert(class_info != NULL);
    81 
    82         return (class_info->devmap_handle == (devmap_handle_t) key[0]);
     90        fun_node_t *fun = hash_table_get_instance(item, fun_node_t, loc_fun);
     91        return (fun->service_id == (service_id_t) key[0]);
    8392}
    8493
    … …  
    99108};
    100109
    101 static hash_table_operations_t devmap_devices_ops = {
     110static hash_table_operations_t loc_devices_ops = {
    102111        .hash = devices_hash,
    103         .compare = devmap_functions_compare,
    104         .remove_callback = devices_remove_callback
    105 };
    106 
    107 static hash_table_operations_t devmap_devices_class_ops = {
    108         .hash = devices_hash,
    109         .compare = devmap_devices_class_compare,
     112        .compare = loc_functions_compare,
    110113        .remove_callback = devices_remove_callback
    111114};
    … …  
    422425        }
    423426       
     427        fun_add_ref(fun);
    424428        insert_fun_node(tree, fun, str_dup(""), NULL);
     429       
    425430        match_id_t *id = create_match_id();
    426431        id->id = str_dup("root");
    … …  
    438443        }
    439444       
     445        dev_add_ref(dev);
    440446        insert_dev_node(tree, dev, fun);
    441447       
    … …  
    483489/** Assign a driver to a device.
    484490 *
     491 * @param tree          Device tree
    485492 * @param node          The device's node in the device tree.
    486493 * @param drv           The driver.
    487494 */
    488 void attach_driver(dev_node_t *dev, driver_t *drv)
     495void attach_driver(dev_tree_t *tree, dev_node_t *dev, driver_t *drv)
    489496{
    490497        log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")",
    … …  
    492499       
    493500        fibril_mutex_lock(&drv->driver_mutex);
     501        fibril_rwlock_write_lock(&tree->rwlock);
    494502       
    495503        dev->drv = drv;
    496504        list_append(&dev->driver_devices, &drv->devices);
    497505       
     506        fibril_rwlock_write_unlock(&tree->rwlock);
     507        fibril_mutex_unlock(&drv->driver_mutex);
     508}
     509
     510/** Detach driver from device.
     511 *
     512 * @param tree          Device tree
     513 * @param node          The device's node in the device tree.
     514 * @param drv           The driver.
     515 */
     516void detach_driver(dev_tree_t *tree, dev_node_t *dev)
     517{
     518        driver_t *drv = dev->drv;
     519       
     520        assert(drv != NULL);
     521       
     522        log_msg(LVL_DEBUG, "detach_driver(dev=\"%s\",drv=\"%s\")",
     523            dev->pfun->pathname, drv->name);
     524       
     525        fibril_mutex_lock(&drv->driver_mutex);
     526        fibril_rwlock_write_lock(&tree->rwlock);
     527       
     528        dev->drv = NULL;
     529        list_remove(&dev->driver_devices);
     530       
     531        fibril_rwlock_write_unlock(&tree->rwlock);
    498532        fibril_mutex_unlock(&drv->driver_mutex);
    499533}
    … …  
    564598
    565599        fibril_mutex_lock(&driver->driver_mutex);
    566        
    567         async_exch_t *exch = async_exchange_begin(driver->sess);
    568         async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE, exch,
    569             DRIVER_DEVMAN, 0, 0);
    570         async_exchange_end(exch);
    571 
    572         if (!sess) {
    573                 fibril_mutex_unlock(&driver->driver_mutex);
    574                 return;
    575         }
    576600
    577601        /*
    … …  
    582606        while (link != &driver->devices.head) {
    583607                dev = list_get_instance(link, dev_node_t, driver_devices);
     608                fibril_rwlock_write_lock(&tree->rwlock);
     609               
    584610                if (dev->passed_to_driver) {
     611                        fibril_rwlock_write_unlock(&tree->rwlock);
    585612                        link = link->next;
    586613                        continue;
    587614                }
    588615
    589                 /*
    590                  * We remove the device from the list to allow safe adding
    591                  * of new devices (no one will touch our item this way).
    592                  */
    593                 list_remove(link);
     616                log_msg(LVL_DEBUG, "pass_devices_to_driver: dev->refcnt=%d\n",
     617                    (int)atomic_get(&dev->refcnt));
     618                dev_add_ref(dev);
    594619
    595620                /*
    … …  
    598623                 */
    599624                fibril_mutex_unlock(&driver->driver_mutex);
    600 
    601                 add_device(sess, driver, dev, tree);
     625                fibril_rwlock_write_unlock(&tree->rwlock);
     626
     627                add_device(driver, dev, tree);
     628
     629                dev_del_ref(dev);
    602630
    603631                /*
    … …  
    608636
    609637                /*
    610                  * Insert the device back.
    611                  * The order is not relevant here so no harm is done
    612                  * (actually, the order would be preserved in most cases).
    613                  */
    614                 list_append(link, &driver->devices);
    615 
    616                 /*
    617638                 * Restart the cycle to go through all devices again.
    618639                 */
    619640                link = driver->devices.head.next;
    620641        }
    621 
    622         async_hangup(sess);
    623642
    624643        /*
    … …  
    701720}
    702721
    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)
     722/** Create loc path and name for the function. */
     723void loc_register_tree_function(fun_node_t *fun, dev_tree_t *tree)
     724{
     725        char *loc_pathname = NULL;
     726        char *loc_name = NULL;
     727       
     728        assert(fibril_rwlock_is_locked(&tree->rwlock));
     729       
     730        asprintf(&loc_name, "%s", fun->pathname);
     731        if (loc_name == NULL)
    711732                return;
    712733       
    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);
     734        replace_char(loc_name, '/', LOC_SEPARATOR);
     735       
     736        asprintf(&loc_pathname, "%s/%s", LOC_DEVICE_NAMESPACE,
     737            loc_name);
     738        if (loc_pathname == NULL) {
     739                free(loc_name);
    719740                return;
    720741        }
    721742       
    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);
     743        loc_service_register_with_iface(loc_pathname,
     744            &fun->service_id, DEVMAN_CONNECT_FROM_LOC);
     745       
     746        tree_add_loc_function(tree, fun);
     747       
     748        free(loc_name);
     749        free(loc_pathname);
    729750}
    730751
    … …  
    734755 * @param node          The device's node in the device tree.
    735756 */
    736 void add_device(async_sess_t *sess, driver_t *drv, dev_node_t *dev,
    737     dev_tree_t *tree)
     757void add_device(driver_t *drv, dev_node_t *dev, dev_tree_t *tree)
    738758{
    739759        /*
    … …  
    752772        }
    753773       
    754         async_exch_t *exch = async_exchange_begin(sess);
     774        async_exch_t *exch = async_exchange_begin(drv->sess);
    755775       
    756776        ipc_call_t answer;
    757         aid_t req = async_send_2(exch, DRIVER_ADD_DEVICE, dev->handle,
     777        aid_t req = async_send_2(exch, DRIVER_DEV_ADD, dev->handle,
    758778            parent_handle, &answer);
    759779       
    … …  
    812832       
    813833        /* Attach the driver to the device. */
    814         attach_driver(dev, drv);
     834        attach_driver(tree, dev, drv);
    815835       
    816836        fibril_mutex_lock(&drv->driver_mutex);
    … …  
    822842        fibril_mutex_unlock(&drv->driver_mutex);
    823843
    824         if (is_running) {
    825                 /* Notify the driver about the new device. */
    826                 async_exch_t *exch = async_exchange_begin(drv->sess);
    827                 async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE, exch,
    828                     DRIVER_DEVMAN, 0, 0);
    829                 async_exchange_end(exch);
    830                
    831                 if (sess) {
    832                         add_device(sess, drv, dev, tree);
    833                         async_hangup(sess);
    834                 }
    835         }
    836        
     844        /* Notify the driver about the new device. */
     845        if (is_running)
     846                add_device(drv, dev, tree);
     847       
     848        fibril_mutex_lock(&drv->driver_mutex);
     849        fibril_mutex_unlock(&drv->driver_mutex);
     850
     851        fibril_rwlock_write_lock(&tree->rwlock);
     852        if (dev->pfun != NULL) {
     853                dev->pfun->state = FUN_ON_LINE;
     854        }
     855        fibril_rwlock_write_unlock(&tree->rwlock);
    837856        return true;
     857}
     858
     859int driver_dev_remove(dev_tree_t *tree, dev_node_t *dev)
     860{
     861        async_exch_t *exch;
     862        sysarg_t retval;
     863        driver_t *drv;
     864        devman_handle_t handle;
     865       
     866        assert(dev != NULL);
     867       
     868        log_msg(LVL_DEBUG, "driver_dev_remove(%p)", dev);
     869       
     870        fibril_rwlock_read_lock(&tree->rwlock);
     871        drv = dev->drv;
     872        handle = dev->handle;
     873        fibril_rwlock_read_unlock(&tree->rwlock);
     874       
     875        exch = async_exchange_begin(drv->sess);
     876        retval = async_req_1_0(exch, DRIVER_DEV_REMOVE, handle);
     877        async_exchange_end(exch);
     878       
     879        return retval;
     880}
     881
     882int driver_dev_gone(dev_tree_t *tree, dev_node_t *dev)
     883{
     884        async_exch_t *exch;
     885        sysarg_t retval;
     886        driver_t *drv;
     887        devman_handle_t handle;
     888       
     889        assert(dev != NULL);
     890       
     891        log_msg(LVL_DEBUG, "driver_dev_gone(%p)", dev);
     892       
     893        fibril_rwlock_read_lock(&tree->rwlock);
     894        drv = dev->drv;
     895        handle = dev->handle;
     896        fibril_rwlock_read_unlock(&tree->rwlock);
     897       
     898        exch = async_exchange_begin(drv->sess);
     899        retval = async_req_1_0(exch, DRIVER_DEV_GONE, handle);
     900        async_exchange_end(exch);
     901       
     902        return retval;
     903}
     904
     905int driver_fun_online(dev_tree_t *tree, fun_node_t *fun)
     906{
     907        async_exch_t *exch;
     908        sysarg_t retval;
     909        driver_t *drv;
     910        devman_handle_t handle;
     911       
     912        log_msg(LVL_DEBUG, "driver_fun_online(%p)", fun);
     913
     914        fibril_rwlock_read_lock(&tree->rwlock);
     915       
     916        if (fun->dev == NULL) {
     917                /* XXX root function? */
     918                fibril_rwlock_read_unlock(&tree->rwlock);
     919                return EINVAL;
     920        }
     921       
     922        drv = fun->dev->drv;
     923        handle = fun->handle;
     924        fibril_rwlock_read_unlock(&tree->rwlock);
     925       
     926        exch = async_exchange_begin(drv->sess);
     927        retval = async_req_1_0(exch, DRIVER_FUN_ONLINE, handle);
     928        loc_exchange_end(exch);
     929       
     930        return retval;
     931}
     932
     933int driver_fun_offline(dev_tree_t *tree, fun_node_t *fun)
     934{
     935        async_exch_t *exch;
     936        sysarg_t retval;
     937        driver_t *drv;
     938        devman_handle_t handle;
     939       
     940        log_msg(LVL_DEBUG, "driver_fun_offline(%p)", fun);
     941
     942        fibril_rwlock_read_lock(&tree->rwlock);
     943        if (fun->dev == NULL) {
     944                /* XXX root function? */
     945                fibril_rwlock_read_unlock(&tree->rwlock);
     946                return EINVAL;
     947        }
     948       
     949        drv = fun->dev->drv;
     950        handle = fun->handle;
     951        fibril_rwlock_read_unlock(&tree->rwlock);
     952       
     953        exch = async_exchange_begin(drv->sess);
     954        retval = async_req_1_0(exch, DRIVER_FUN_OFFLINE, handle);
     955        loc_exchange_end(exch);
     956       
     957        return retval;
     958
    838959}
    839960
    … …  
    856977        hash_table_create(&tree->devman_functions, DEVICE_BUCKETS, 1,
    857978            &devman_functions_ops);
    858         hash_table_create(&tree->devmap_functions, DEVICE_BUCKETS, 1,
    859             &devmap_devices_ops);
     979        hash_table_create(&tree->loc_functions, DEVICE_BUCKETS, 1,
     980            &loc_devices_ops);
    860981       
    861982        fibril_rwlock_initialize(&tree->rwlock);
    … …  
    864985        if (!create_root_nodes(tree))
    865986                return false;
    866 
     987   
    867988        /* Find suitable driver and start it. */
    868         return assign_driver(tree->root_node->child, drivers_list, tree);
     989        dev_node_t *rdev = tree->root_node->child;
     990        dev_add_ref(rdev);
     991        int rc = assign_driver(rdev, drivers_list, tree);
     992        dev_del_ref(rdev);
     993       
     994        return rc;
    869995}
    870996
    … …  
    8771003dev_node_t *create_dev_node(void)
    8781004{
    879         dev_node_t *res = malloc(sizeof(dev_node_t));
    880        
    881         if (res != NULL) {
    882                 memset(res, 0, sizeof(dev_node_t));
    883                 list_initialize(&res->functions);
    884                 link_initialize(&res->driver_devices);
    885                 link_initialize(&res->devman_dev);
    886         }
    887        
    888         return res;
     1005        dev_node_t *dev;
     1006       
     1007        dev = calloc(1, sizeof(dev_node_t));
     1008        if (dev == NULL)
     1009                return NULL;
     1010       
     1011        atomic_set(&dev->refcnt, 0);
     1012        list_initialize(&dev->functions);
     1013        link_initialize(&dev->driver_devices);
     1014        link_initialize(&dev->devman_dev);
     1015       
     1016        return dev;
    8891017}
    8901018
    … …  
    9021030}
    9031031
     1032/** Increase device node reference count.
     1033 *
     1034 * @param dev   Device node
     1035 */
     1036void dev_add_ref(dev_node_t *dev)
     1037{
     1038        atomic_inc(&dev->refcnt);
     1039}
     1040
     1041/** Decrease device node reference count.
     1042 *
     1043 * When the count drops to zero the device node is freed.
     1044 *
     1045 * @param dev   Device node
     1046 */
     1047void dev_del_ref(dev_node_t *dev)
     1048{
     1049        if (atomic_predec(&dev->refcnt) == 0)
     1050                delete_dev_node(dev);
     1051}
     1052
     1053
    9041054/** Find the device node structure of the device witch has the specified handle.
    9051055 *
    … …  
    9311081        fibril_rwlock_read_lock(&tree->rwlock);
    9321082        dev = find_dev_node_no_lock(tree, handle);
     1083        if (dev != NULL)
     1084                dev_add_ref(dev);
     1085       
    9331086        fibril_rwlock_read_unlock(&tree->rwlock);
    9341087       
    … …  
    9361089}
    9371090
     1091/** Get list of device functions. */
     1092int dev_get_functions(dev_tree_t *tree, dev_node_t *dev,
     1093    devman_handle_t *hdl_buf, size_t buf_size, size_t *act_size)
     1094{
     1095        size_t act_cnt;
     1096        size_t buf_cnt;
     1097
     1098        assert(fibril_rwlock_is_locked(&tree->rwlock));
     1099
     1100        buf_cnt = buf_size / sizeof(devman_handle_t);
     1101
     1102        act_cnt = list_count(&dev->functions);
     1103        *act_size = act_cnt * sizeof(devman_handle_t);
     1104
     1105        if (buf_size % sizeof(devman_handle_t) != 0)
     1106                return EINVAL;
     1107
     1108        size_t pos = 0;
     1109        list_foreach(dev->functions, item) {
     1110                fun_node_t *fun =
     1111                    list_get_instance(item, fun_node_t, dev_functions);
     1112
     1113                if (pos < buf_cnt) {
     1114                        hdl_buf[pos] = fun->handle;
     1115                }
     1116
     1117                pos++;
     1118        }
     1119
     1120        return EOK;
     1121}
     1122
     1123
    9381124/* Function nodes */
    9391125
    … …  
    9441130fun_node_t *create_fun_node(void)
    9451131{
    946         fun_node_t *res = malloc(sizeof(fun_node_t));
    947        
    948         if (res != NULL) {
    949                 memset(res, 0, sizeof(fun_node_t));
    950                 link_initialize(&res->dev_functions);
    951                 list_initialize(&res->match_ids.ids);
    952                 list_initialize(&res->classes);
    953                 link_initialize(&res->devman_fun);
    954                 link_initialize(&res->devmap_fun);
    955         }
    956        
    957         return res;
     1132        fun_node_t *fun;
     1133
     1134        fun = calloc(1, sizeof(fun_node_t));
     1135        if (fun == NULL)
     1136                return NULL;
     1137       
     1138        fun->state = FUN_INIT;
     1139        atomic_set(&fun->refcnt, 0);
     1140        link_initialize(&fun->dev_functions);
     1141        list_initialize(&fun->match_ids.ids);
     1142        link_initialize(&fun->devman_fun);
     1143        link_initialize(&fun->loc_fun);
     1144       
     1145        return fun;
    9581146}
    9591147
    … …  
    9731161}
    9741162
     1163/** Increase function node reference count.
     1164 *
     1165 * @param fun   Function node
     1166 */
     1167void fun_add_ref(fun_node_t *fun)
     1168{
     1169        atomic_inc(&fun->refcnt);
     1170}
     1171
     1172/** Decrease function node reference count.
     1173 *
     1174 * When the count drops to zero the function node is freed.
     1175 *
     1176 * @param fun   Function node
     1177 */
     1178void fun_del_ref(fun_node_t *fun)
     1179{
     1180        if (atomic_predec(&fun->refcnt) == 0)
     1181                delete_fun_node(fun);
     1182}
     1183
    9751184/** Find the function node with the specified handle.
    9761185 *
    … …  
    9831192        unsigned long key = handle;
    9841193        link_t *link;
     1194        fun_node_t *fun;
    9851195       
    9861196        assert(fibril_rwlock_is_locked(&tree->rwlock));
    … …  
    9901200                return NULL;
    9911201       
    992         return hash_table_get_instance(link, fun_node_t, devman_fun);
     1202        fun = hash_table_get_instance(link, fun_node_t, devman_fun);
     1203       
     1204        return fun;
    9931205}
    9941206
    … …  
    10041216       
    10051217        fibril_rwlock_read_lock(&tree->rwlock);
     1218       
    10061219        fun = find_fun_node_no_lock(tree, handle);
     1220        if (fun != NULL)
     1221                fun_add_ref(fun);
     1222       
    10071223        fibril_rwlock_read_unlock(&tree->rwlock);
    10081224       
    … …  
    10121228/** Create and set device's full path in device tree.
    10131229 *
     1230 * @param tree          Device tree
    10141231 * @param node          The device's device node.
    10151232 * @param parent        The parent device node.
    … …  
    10171234 *                      resources etc.).
    10181235 */
    1019 static bool set_fun_path(fun_node_t *fun, fun_node_t *parent)
    1020 {
     1236static bool set_fun_path(dev_tree_t *tree, fun_node_t *fun, fun_node_t *parent)
     1237{
     1238        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10211239        assert(fun->name != NULL);
    10221240       
    … …  
    10451263 *
    10461264 * @param tree          The device tree.
    1047  * @param node          The newly added device node.
    1048  * @param dev_name      The name of the newly added device.
    1049  * @param parent        The parent device node.
     1265 * @param dev           The newly added device node.
     1266 * @param pfun          The parent function node.
    10501267 *
    10511268 * @return              True on success, false otherwise (insufficient resources
    … …  
    10541271bool insert_dev_node(dev_tree_t *tree, dev_node_t *dev, fun_node_t *pfun)
    10551272{
    1056         assert(dev != NULL);
    1057         assert(tree != NULL);
    10581273        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10591274       
    … …  
    10731288}
    10741289
     1290/** Remove device from device tree.
     1291 *
     1292 * @param tree          Device tree
     1293 * @param dev           Device node
     1294 */
     1295void remove_dev_node(dev_tree_t *tree, dev_node_t *dev)
     1296{
     1297        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
     1298       
     1299        log_msg(LVL_DEBUG, "remove_dev_node(dev=%p)", dev);
     1300       
     1301        /* Remove node from the handle-to-node map. */
     1302        unsigned long key = dev->handle;
     1303        hash_table_remove(&tree->devman_devices, &key, 1);
     1304       
     1305        /* Unlink from parent function. */
     1306        dev->pfun->child = NULL;
     1307        dev->pfun = NULL;
     1308       
     1309        dev->state = DEVICE_REMOVED;
     1310}
     1311
     1312
    10751313/** Insert new function into device tree.
    10761314 *
    10771315 * @param tree          The device tree.
    1078  * @param node          The newly added function node.
    1079  * @param dev_name      The name of the newly added function.
    1080  * @param parent        Owning device node.
     1316 * @param fun           The newly added function node.
     1317 * @param fun_name      The name of the newly added function.
     1318 * @param dev           Owning device node.
    10811319 *
    10821320 * @return              True on success, false otherwise (insufficient resources
    … …  
    10881326        fun_node_t *pfun;
    10891327       
    1090         assert(fun != NULL);
    1091         assert(tree != NULL);
    10921328        assert(fun_name != NULL);
    10931329        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    … …  
    11001336       
    11011337        fun->name = fun_name;
    1102         if (!set_fun_path(fun, pfun)) {
     1338        if (!set_fun_path(tree, fun, pfun)) {
    11031339                return false;
    11041340        }
    … …  
    11151351       
    11161352        return true;
     1353}
     1354
     1355/** Remove function from device tree.
     1356 *
     1357 * @param tree          Device tree
     1358 * @param node          Function node to remove
     1359 */
     1360void remove_fun_node(dev_tree_t *tree, fun_node_t *fun)
     1361{
     1362        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
     1363       
     1364        /* Remove the node from the handle-to-node map. */
     1365        unsigned long key = fun->handle;
     1366        hash_table_remove(&tree->devman_functions, &key, 1);
     1367       
     1368        /* Remove the node from the list of its parent's children. */
     1369        if (fun->dev != NULL)
     1370                list_remove(&fun->dev_functions);
     1371       
     1372        fun->dev = NULL;
     1373        fun->state = FUN_REMOVED;
    11171374}
    11181375
    … …  
    11361393       
    11371394        fun_node_t *fun = tree->root_node;
     1395        fun_add_ref(fun);
    11381396        /*
    11391397         * Relative path to the function from its parent (but with '/' at the
    … …  
    11421400        char *rel_path = path;
    11431401        char *next_path_elem = NULL;
    1144         bool cont = true;
     1402        bool cont = (rel_path[1] != '\0');
    11451403       
    11461404        while (cont && fun != NULL) {
    … …  
    11531411                }
    11541412               
    1155                 fun = find_node_child(fun, rel_path + 1);
     1413                fun_node_t *cfun = find_node_child(tree, fun, rel_path + 1);
     1414                fun_del_ref(fun);
     1415                fun = cfun;
    11561416               
    11571417                if (cont) {
    … …  
    11711431 * Device tree rwlock should be held at least for reading.
    11721432 *
     1433 * @param tree Device tree
    11731434 * @param dev Device the function belongs to.
    11741435 * @param name Function name (not path).
    … …  
    11761437 * @retval NULL No function with given name.
    11771438 */
    1178 fun_node_t *find_fun_node_in_device(dev_node_t *dev, const char *name)
    1179 {
    1180         assert(dev != NULL);
     1439fun_node_t *find_fun_node_in_device(dev_tree_t *tree, dev_node_t *dev,
     1440    const char *name)
     1441{
    11811442        assert(name != NULL);
     1443        assert(fibril_rwlock_is_locked(&tree->rwlock));
    11821444
    11831445        fun_node_t *fun;
    … …  
    11861448                fun = list_get_instance(link, fun_node_t, dev_functions);
    11871449
    1188                 if (str_cmp(name, fun->name) == 0)
     1450                if (str_cmp(name, fun->name) == 0) {
     1451                        fun_add_ref(fun);
    11891452                        return fun;
     1453                }
    11901454        }
    11911455
    … …  
    11931457}
    11941458
    1195 /** Find function node by its class name and index. */
    1196 fun_node_t *find_fun_node_by_class(class_list_t *class_list,
    1197     const char *class_name, const char *dev_name)
    1198 {
    1199         assert(class_list != NULL);
    1200         assert(class_name != NULL);
    1201         assert(dev_name != NULL);
    1202 
    1203         fibril_rwlock_read_lock(&class_list->rwlock);
    1204 
    1205         dev_class_t *cl = find_dev_class_no_lock(class_list, class_name);
    1206         if (cl == NULL) {
    1207                 fibril_rwlock_read_unlock(&class_list->rwlock);
    1208                 return NULL;
    1209         }
    1210 
    1211         dev_class_info_t *dev = find_dev_in_class(cl, dev_name);
    1212         if (dev == NULL) {
    1213                 fibril_rwlock_read_unlock(&class_list->rwlock);
    1214                 return NULL;
    1215         }
    1216 
    1217         fun_node_t *fun = dev->fun;
    1218 
    1219         fibril_rwlock_read_unlock(&class_list->rwlock);
    1220 
    1221         return fun;
    1222 }
    1223 
    1224 
    12251459/** Find child function node with a specified name.
    12261460 *
    12271461 * Device tree rwlock should be held at least for reading.
    12281462 *
     1463 * @param tree          Device tree
    12291464 * @param parent        The parent function node.
    12301465 * @param name          The name of the child function.
    12311466 * @return              The child function node.
    12321467 */
    1233 fun_node_t *find_node_child(fun_node_t *pfun, const char *name)
    1234 {
    1235         return find_fun_node_in_device(pfun->child, name);
    1236 }
    1237 
    1238 /* Device classes */
    1239 
    1240 /** Create device class.
    1241  *
    1242  * @return      Device class.
    1243  */
    1244 dev_class_t *create_dev_class(void)
    1245 {
    1246         dev_class_t *cl;
    1247        
    1248         cl = (dev_class_t *) malloc(sizeof(dev_class_t));
    1249         if (cl != NULL) {
    1250                 memset(cl, 0, sizeof(dev_class_t));
    1251                 list_initialize(&cl->devices);
    1252                 fibril_mutex_initialize(&cl->mutex);
    1253         }
    1254        
    1255         return cl;
    1256 }
    1257 
    1258 /** Create device class info.
    1259  *
    1260  * @return              Device class info.
    1261  */
    1262 dev_class_info_t *create_dev_class_info(void)
    1263 {
    1264         dev_class_info_t *info;
    1265        
    1266         info = (dev_class_info_t *) malloc(sizeof(dev_class_info_t));
    1267         if (info != NULL) {
    1268                 memset(info, 0, sizeof(dev_class_info_t));
    1269                 link_initialize(&info->dev_classes);
    1270                 link_initialize(&info->devmap_link);
    1271                 link_initialize(&info->link);
    1272         }
    1273        
    1274         return info;
    1275 }
    1276 
    1277 size_t get_new_class_dev_idx(dev_class_t *cl)
    1278 {
    1279         size_t dev_idx;
    1280        
    1281         fibril_mutex_lock(&cl->mutex);
    1282         dev_idx = ++cl->curr_dev_idx;
    1283         fibril_mutex_unlock(&cl->mutex);
    1284        
    1285         return dev_idx;
    1286 }
    1287 
    1288 
    1289 /** Create unique device name within the class.
    1290  *
    1291  * @param cl            The class.
    1292  * @param base_dev_name Contains the base name for the device if it was
    1293  *                      specified by the driver when it registered the device by
    1294  *                      the class; NULL if driver specified no base name.
    1295  * @return              The unique name for the device within the class.
    1296  */
    1297 char *create_dev_name_for_class(dev_class_t *cl, const char *base_dev_name)
    1298 {
    1299         char *dev_name;
    1300         const char *base_name;
    1301        
    1302         if (base_dev_name != NULL)
    1303                 base_name = base_dev_name;
    1304         else
    1305                 base_name = cl->base_dev_name;
    1306        
    1307         size_t idx = get_new_class_dev_idx(cl);
    1308         asprintf(&dev_name, "%s%zu", base_name, idx);
    1309        
    1310         return dev_name;
    1311 }
    1312 
    1313 /** Add the device function to the class.
    1314  *
    1315  * The device may be added to multiple classes and a class may contain multiple
    1316  * devices. The class and the device are associated with each other by the
    1317  * dev_class_info_t structure.
    1318  *
    1319  * @param dev           The device.
    1320  * @param class         The class.
    1321  * @param base_dev_name The base name of the device within the class if
    1322  *                      specified by the driver, NULL otherwise.
    1323  * @return              dev_class_info_t structure which associates the device
    1324  *                      with the class.
    1325  */
    1326 dev_class_info_t *add_function_to_class(fun_node_t *fun, dev_class_t *cl,
    1327     const char *base_dev_name)
    1328 {
    1329         dev_class_info_t *info;
    1330 
    1331         assert(fun != NULL);
    1332         assert(cl != NULL);
    1333 
    1334         info = create_dev_class_info();
    1335 
    1336        
    1337         if (info != NULL) {
    1338                 info->dev_class = cl;
    1339                 info->fun = fun;
    1340                
    1341                 /* Add the device to the class. */
    1342                 fibril_mutex_lock(&cl->mutex);
    1343                 list_append(&info->link, &cl->devices);
    1344                 fibril_mutex_unlock(&cl->mutex);
    1345                
    1346                 /* Add the class to the device. */
    1347                 list_append(&info->dev_classes, &fun->classes);
    1348                
    1349                 /* Create unique name for the device within the class. */
    1350                 info->dev_name = create_dev_name_for_class(cl, base_dev_name);
    1351         }
    1352        
    1353         return info;
    1354 }
    1355 
    1356 dev_class_t *get_dev_class(class_list_t *class_list, char *class_name)
    1357 {
    1358         dev_class_t *cl;
    1359        
    1360         fibril_rwlock_write_lock(&class_list->rwlock);
    1361         cl = find_dev_class_no_lock(class_list, class_name);
    1362         if (cl == NULL) {
    1363                 cl = create_dev_class();
    1364                 if (cl != NULL) {
    1365                         cl->name = class_name;
    1366                         cl->base_dev_name = "";
    1367                         add_dev_class_no_lock(class_list, cl);
    1368                 }
    1369         }
    1370 
    1371         fibril_rwlock_write_unlock(&class_list->rwlock);
    1372         return cl;
    1373 }
    1374 
    1375 dev_class_t *find_dev_class_no_lock(class_list_t *class_list,
    1376     const char *class_name)
    1377 {
    1378         dev_class_t *cl;
    1379        
    1380         list_foreach(class_list->classes, link) {
    1381                 cl = list_get_instance(link, dev_class_t, link);
    1382                 if (str_cmp(cl->name, class_name) == 0) {
    1383                         return cl;
    1384                 }
    1385         }
    1386        
    1387         return NULL;
    1388 }
    1389 
    1390 void add_dev_class_no_lock(class_list_t *class_list, dev_class_t *cl)
    1391 {
    1392         list_append(&cl->link, &class_list->classes);
    1393 }
    1394 
    1395 dev_class_info_t *find_dev_in_class(dev_class_t *dev_class, const char *dev_name)
    1396 {
    1397         assert(dev_class != NULL);
    1398         assert(dev_name != NULL);
    1399 
    1400         list_foreach(dev_class->devices, link) {
    1401                 dev_class_info_t *dev = list_get_instance(link,
    1402                     dev_class_info_t, link);
    1403 
    1404                 if (str_cmp(dev->dev_name, dev_name) == 0) {
    1405                         return dev;
    1406                 }
    1407         }
    1408 
    1409         return NULL;
    1410 }
    1411 
    1412 void init_class_list(class_list_t *class_list)
    1413 {
    1414         list_initialize(&class_list->classes);
    1415         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)
     1468static fun_node_t *find_node_child(dev_tree_t *tree, fun_node_t *pfun,
     1469    const char *name)
     1470{
     1471        return find_fun_node_in_device(tree, pfun->child, name);
     1472}
     1473
     1474/* loc devices */
     1475
     1476fun_node_t *find_loc_tree_function(dev_tree_t *tree, service_id_t service_id)
    14241477{
    14251478        fun_node_t *fun = NULL;
    14261479        link_t *link;
    1427         unsigned long key = (unsigned long) devmap_handle;
     1480        unsigned long key = (unsigned long) service_id;
    14281481       
    14291482        fibril_rwlock_read_lock(&tree->rwlock);
    1430         link = hash_table_find(&tree->devmap_functions, &key);
    1431         if (link != NULL)
    1432                 fun = hash_table_get_instance(link, fun_node_t, devmap_fun);
     1483        link = hash_table_find(&tree->loc_functions, &key);
     1484        if (link != NULL) {
     1485                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
     1486                fun_add_ref(fun);
     1487        }
    14331488        fibril_rwlock_read_unlock(&tree->rwlock);
    14341489       
    … …  
    14361491}
    14371492
    1438 fun_node_t *find_devmap_class_function(class_list_t *classes,
    1439     devmap_handle_t devmap_handle)
    1440 {
    1441         fun_node_t *fun = NULL;
    1442         dev_class_info_t *cli;
    1443         link_t *link;
    1444         unsigned long key = (unsigned long)devmap_handle;
    1445        
    1446         fibril_rwlock_read_lock(&classes->rwlock);
    1447         link = hash_table_find(&classes->devmap_functions, &key);
    1448         if (link != NULL) {
    1449                 cli = hash_table_get_instance(link, dev_class_info_t,
    1450                     devmap_link);
    1451                 fun = cli->fun;
    1452         }
    1453         fibril_rwlock_read_unlock(&classes->rwlock);
    1454        
    1455         return fun;
    1456 }
    1457 
    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;
    1461        
    1462         fibril_rwlock_write_lock(&class_list->rwlock);
    1463         hash_table_insert(&class_list->devmap_functions, &key, &cli->devmap_link);
    1464         fibril_rwlock_write_unlock(&class_list->rwlock);
    1465 
    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;
    1472         fibril_rwlock_write_lock(&tree->rwlock);
    1473         hash_table_insert(&tree->devmap_functions, &key, &fun->devmap_fun);
    1474         fibril_rwlock_write_unlock(&tree->rwlock);
     1493void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun)
     1494{
     1495        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
     1496       
     1497        unsigned long key = (unsigned long) fun->service_id;
     1498        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
    14751499}
    14761500
Note: See TracChangeset for help on using the changeset viewer.