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


Ignore:
Timestamp:
2011-09-07T00:03:26Z (13 years ago)
Author:
Petr Koupy <petr.koupy@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5081276
Parents:
bb74dabe (diff), 038b289 (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

    rbb74dabe rc05642d  
    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>
     
    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 */
     
    406425        }
    407426       
     427        fun_add_ref(fun);
    408428        insert_fun_node(tree, fun, str_dup(""), NULL);
     429       
    409430        match_id_t *id = create_match_id();
    410431        id->id = str_dup("root");
     
    422443        }
    423444       
     445        dev_add_ref(dev);
    424446        insert_dev_node(tree, dev, fun);
    425447       
     
    467489/** Assign a driver to a device.
    468490 *
     491 * @param tree          Device tree
    469492 * @param node          The device's node in the device tree.
    470493 * @param drv           The driver.
    471494 */
    472 void attach_driver(dev_node_t *dev, driver_t *drv)
     495void attach_driver(dev_tree_t *tree, dev_node_t *dev, driver_t *drv)
    473496{
    474497        log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")",
     
    476499       
    477500        fibril_mutex_lock(&drv->driver_mutex);
     501        fibril_rwlock_write_lock(&tree->rwlock);
    478502       
    479503        dev->drv = drv;
    480504        list_append(&dev->driver_devices, &drv->devices);
    481505       
     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);
    482532        fibril_mutex_unlock(&drv->driver_mutex);
    483533}
     
    556606        while (link != &driver->devices.head) {
    557607                dev = list_get_instance(link, dev_node_t, driver_devices);
     608                fibril_rwlock_write_lock(&tree->rwlock);
     609               
    558610                if (dev->passed_to_driver) {
     611                        fibril_rwlock_write_unlock(&tree->rwlock);
    559612                        link = link->next;
    560613                        continue;
    561614                }
    562615
    563                 /*
    564                  * We remove the device from the list to allow safe adding
    565                  * of new devices (no one will touch our item this way).
    566                  */
    567                 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);
    568619
    569620                /*
     
    572623                 */
    573624                fibril_mutex_unlock(&driver->driver_mutex);
     625                fibril_rwlock_write_unlock(&tree->rwlock);
    574626
    575627                add_device(driver, dev, tree);
     628
     629                dev_del_ref(dev);
    576630
    577631                /*
     
    580634                 */
    581635                fibril_mutex_lock(&driver->driver_mutex);
    582 
    583                 /*
    584                  * Insert the device back.
    585                  * The order is not relevant here so no harm is done
    586                  * (actually, the order would be preserved in most cases).
    587                  */
    588                 list_append(link, &driver->devices);
    589636
    590637                /*
     
    679726        char *loc_name = NULL;
    680727       
     728        assert(fibril_rwlock_is_locked(&tree->rwlock));
     729       
    681730        asprintf(&loc_name, "%s", fun->pathname);
    682731        if (loc_name == NULL)
     
    726775       
    727776        ipc_call_t answer;
    728         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,
    729778            parent_handle, &answer);
    730779       
     
    783832       
    784833        /* Attach the driver to the device. */
    785         attach_driver(dev, drv);
     834        attach_driver(tree, dev, drv);
    786835       
    787836        fibril_mutex_lock(&drv->driver_mutex);
     
    797846                add_device(drv, dev, tree);
    798847       
     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);
    799856        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
    800959}
    801960
     
    826985        if (!create_root_nodes(tree))
    827986                return false;
    828 
     987   
    829988        /* Find suitable driver and start it. */
    830         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;
    831995}
    832996
     
    8391003dev_node_t *create_dev_node(void)
    8401004{
    841         dev_node_t *res = malloc(sizeof(dev_node_t));
    842        
    843         if (res != NULL) {
    844                 memset(res, 0, sizeof(dev_node_t));
    845                 list_initialize(&res->functions);
    846                 link_initialize(&res->driver_devices);
    847                 link_initialize(&res->devman_dev);
    848         }
    849        
    850         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;
    8511017}
    8521018
     
    8641030}
    8651031
     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
    8661054/** Find the device node structure of the device witch has the specified handle.
    8671055 *
     
    8931081        fibril_rwlock_read_lock(&tree->rwlock);
    8941082        dev = find_dev_node_no_lock(tree, handle);
     1083        if (dev != NULL)
     1084                dev_add_ref(dev);
     1085       
    8951086        fibril_rwlock_read_unlock(&tree->rwlock);
    8961087       
     
    9201111                    list_get_instance(item, fun_node_t, dev_functions);
    9211112
    922                 if (pos < buf_cnt)
     1113                if (pos < buf_cnt) {
    9231114                        hdl_buf[pos] = fun->handle;
     1115                }
     1116
    9241117                pos++;
    9251118        }
     
    9371130fun_node_t *create_fun_node(void)
    9381131{
    939         fun_node_t *res = malloc(sizeof(fun_node_t));
    940        
    941         if (res != NULL) {
    942                 memset(res, 0, sizeof(fun_node_t));
    943                 link_initialize(&res->dev_functions);
    944                 list_initialize(&res->match_ids.ids);
    945                 link_initialize(&res->devman_fun);
    946                 link_initialize(&res->loc_fun);
    947         }
    948        
    949         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;
    9501146}
    9511147
     
    9651161}
    9661162
     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
    9671184/** Find the function node with the specified handle.
    9681185 *
     
    9751192        unsigned long key = handle;
    9761193        link_t *link;
     1194        fun_node_t *fun;
    9771195       
    9781196        assert(fibril_rwlock_is_locked(&tree->rwlock));
     
    9821200                return NULL;
    9831201       
    984         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;
    9851205}
    9861206
     
    9961216       
    9971217        fibril_rwlock_read_lock(&tree->rwlock);
     1218       
    9981219        fun = find_fun_node_no_lock(tree, handle);
     1220        if (fun != NULL)
     1221                fun_add_ref(fun);
     1222       
    9991223        fibril_rwlock_read_unlock(&tree->rwlock);
    10001224       
     
    10041228/** Create and set device's full path in device tree.
    10051229 *
     1230 * @param tree          Device tree
    10061231 * @param node          The device's device node.
    10071232 * @param parent        The parent device node.
     
    10091234 *                      resources etc.).
    10101235 */
    1011 static bool set_fun_path(fun_node_t *fun, fun_node_t *parent)
    1012 {
     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));
    10131239        assert(fun->name != NULL);
    10141240       
     
    10371263 *
    10381264 * @param tree          The device tree.
    1039  * @param node          The newly added device node.
    1040  * @param dev_name      The name of the newly added device.
    1041  * @param parent        The parent device node.
     1265 * @param dev           The newly added device node.
     1266 * @param pfun          The parent function node.
    10421267 *
    10431268 * @return              True on success, false otherwise (insufficient resources
     
    10461271bool insert_dev_node(dev_tree_t *tree, dev_node_t *dev, fun_node_t *pfun)
    10471272{
    1048         assert(dev != NULL);
    1049         assert(tree != NULL);
    10501273        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10511274       
     
    10651288}
    10661289
     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
    10671313/** Insert new function into device tree.
    10681314 *
    10691315 * @param tree          The device tree.
    1070  * @param node          The newly added function node.
    1071  * @param dev_name      The name of the newly added function.
    1072  * @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.
    10731319 *
    10741320 * @return              True on success, false otherwise (insufficient resources
     
    10801326        fun_node_t *pfun;
    10811327       
    1082         assert(fun != NULL);
    1083         assert(tree != NULL);
    10841328        assert(fun_name != NULL);
    10851329        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
     
    10921336       
    10931337        fun->name = fun_name;
    1094         if (!set_fun_path(fun, pfun)) {
     1338        if (!set_fun_path(tree, fun, pfun)) {
    10951339                return false;
    10961340        }
     
    11161360void remove_fun_node(dev_tree_t *tree, fun_node_t *fun)
    11171361{
    1118         assert(tree != NULL);
    1119         assert(fun != NULL);
    11201362        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    11211363       
     
    11271369        if (fun->dev != NULL)
    11281370                list_remove(&fun->dev_functions);
     1371       
     1372        fun->dev = NULL;
     1373        fun->state = FUN_REMOVED;
    11291374}
    11301375
     
    11481393       
    11491394        fun_node_t *fun = tree->root_node;
     1395        fun_add_ref(fun);
    11501396        /*
    11511397         * Relative path to the function from its parent (but with '/' at the
     
    11651411                }
    11661412               
    1167                 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;
    11681416               
    11691417                if (cont) {
     
    11831431 * Device tree rwlock should be held at least for reading.
    11841432 *
     1433 * @param tree Device tree
    11851434 * @param dev Device the function belongs to.
    11861435 * @param name Function name (not path).
     
    11881437 * @retval NULL No function with given name.
    11891438 */
    1190 fun_node_t *find_fun_node_in_device(dev_node_t *dev, const char *name)
    1191 {
    1192         assert(dev != NULL);
     1439fun_node_t *find_fun_node_in_device(dev_tree_t *tree, dev_node_t *dev,
     1440    const char *name)
     1441{
    11931442        assert(name != NULL);
     1443        assert(fibril_rwlock_is_locked(&tree->rwlock));
    11941444
    11951445        fun_node_t *fun;
     
    11981448                fun = list_get_instance(link, fun_node_t, dev_functions);
    11991449
    1200                 if (str_cmp(name, fun->name) == 0)
     1450                if (str_cmp(name, fun->name) == 0) {
     1451                        fun_add_ref(fun);
    12011452                        return fun;
     1453                }
    12021454        }
    12031455
     
    12091461 * Device tree rwlock should be held at least for reading.
    12101462 *
     1463 * @param tree          Device tree
    12111464 * @param parent        The parent function node.
    12121465 * @param name          The name of the child function.
    12131466 * @return              The child function node.
    12141467 */
    1215 fun_node_t *find_node_child(fun_node_t *pfun, const char *name)
    1216 {
    1217         return find_fun_node_in_device(pfun->child, name);
     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);
    12181472}
    12191473
     
    12281482        fibril_rwlock_read_lock(&tree->rwlock);
    12291483        link = hash_table_find(&tree->loc_functions, &key);
    1230         if (link != NULL)
     1484        if (link != NULL) {
    12311485                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
     1486                fun_add_ref(fun);
     1487        }
    12321488        fibril_rwlock_read_unlock(&tree->rwlock);
    12331489       
     
    12371493void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun)
    12381494{
     1495        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
     1496       
    12391497        unsigned long key = (unsigned long) fun->service_id;
    1240         fibril_rwlock_write_lock(&tree->rwlock);
    12411498        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
    1242         fibril_rwlock_write_unlock(&tree->rwlock);
    12431499}
    12441500
Note: See TracChangeset for help on using the changeset viewer.