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


Ignore:
Timestamp:
2011-09-02T16:54:18Z (13 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f480d7e
Parents:
7a72ce1a (diff), 224c0e7 (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 basic infrastructure for anticipated device removal from
lp:~jsvoboda/helenos/devrem

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/devman.c

    r7a72ce1a ra1b7e80  
    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}
     882
     883int driver_fun_online(dev_tree_t *tree, fun_node_t *fun)
     884{
     885        async_exch_t *exch;
     886        sysarg_t retval;
     887        driver_t *drv;
     888        devman_handle_t handle;
     889       
     890        log_msg(LVL_DEBUG, "driver_fun_online(%p)", fun);
     891
     892        fibril_rwlock_read_lock(&tree->rwlock);
     893       
     894        if (fun->dev == NULL) {
     895                /* XXX root function? */
     896                fibril_rwlock_read_unlock(&tree->rwlock);
     897                return EINVAL;
     898        }
     899       
     900        drv = fun->dev->drv;
     901        handle = fun->handle;
     902        fibril_rwlock_read_unlock(&tree->rwlock);
     903       
     904        exch = async_exchange_begin(drv->sess);
     905        retval = async_req_1_0(exch, DRIVER_FUN_ONLINE, handle);
     906        loc_exchange_end(exch);
     907       
     908        return retval;
     909}
     910
     911int driver_fun_offline(dev_tree_t *tree, fun_node_t *fun)
     912{
     913        async_exch_t *exch;
     914        sysarg_t retval;
     915        driver_t *drv;
     916        devman_handle_t handle;
     917       
     918        log_msg(LVL_DEBUG, "driver_fun_offline(%p)", fun);
     919
     920        fibril_rwlock_read_lock(&tree->rwlock);
     921        if (fun->dev == NULL) {
     922                /* XXX root function? */
     923                fibril_rwlock_read_unlock(&tree->rwlock);
     924                return EINVAL;
     925        }
     926       
     927        drv = fun->dev->drv;
     928        handle = fun->handle;
     929        fibril_rwlock_read_unlock(&tree->rwlock);
     930       
     931        exch = async_exchange_begin(drv->sess);
     932        retval = async_req_1_0(exch, DRIVER_FUN_OFFLINE, handle);
     933        loc_exchange_end(exch);
     934       
     935        return retval;
     936
    800937}
    801938
    … …  
    826963        if (!create_root_nodes(tree))
    827964                return false;
    828 
     965   
    829966        /* Find suitable driver and start it. */
    830         return assign_driver(tree->root_node->child, drivers_list, tree);
     967        dev_node_t *rdev = tree->root_node->child;
     968        dev_add_ref(rdev);
     969        int rc = assign_driver(rdev, drivers_list, tree);
     970        dev_del_ref(rdev);
     971       
     972        return rc;
    831973}
    832974
    … …  
    839981dev_node_t *create_dev_node(void)
    840982{
    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;
     983        dev_node_t *dev;
     984       
     985        dev = calloc(1, sizeof(dev_node_t));
     986        if (dev == NULL)
     987                return NULL;
     988       
     989        atomic_set(&dev->refcnt, 0);
     990        list_initialize(&dev->functions);
     991        link_initialize(&dev->driver_devices);
     992        link_initialize(&dev->devman_dev);
     993       
     994        return dev;
    851995}
    852996
    … …  
    8641008}
    8651009
     1010/** Increase device node reference count.
     1011 *
     1012 * @param dev   Device node
     1013 */
     1014void dev_add_ref(dev_node_t *dev)
     1015{
     1016        atomic_inc(&dev->refcnt);
     1017}
     1018
     1019/** Decrease device node reference count.
     1020 *
     1021 * When the count drops to zero the device node is freed.
     1022 *
     1023 * @param dev   Device node
     1024 */
     1025void dev_del_ref(dev_node_t *dev)
     1026{
     1027        if (atomic_predec(&dev->refcnt) == 0)
     1028                delete_dev_node(dev);
     1029}
     1030
     1031
    8661032/** Find the device node structure of the device witch has the specified handle.
    8671033 *
    … …  
    8931059        fibril_rwlock_read_lock(&tree->rwlock);
    8941060        dev = find_dev_node_no_lock(tree, handle);
     1061        if (dev != NULL)
     1062                dev_add_ref(dev);
     1063       
    8951064        fibril_rwlock_read_unlock(&tree->rwlock);
    8961065       
    … …  
    9201089                    list_get_instance(item, fun_node_t, dev_functions);
    9211090
    922                 if (pos < buf_cnt)
     1091                if (pos < buf_cnt) {
    9231092                        hdl_buf[pos] = fun->handle;
     1093                }
     1094
    9241095                pos++;
    9251096        }
    … …  
    9371108fun_node_t *create_fun_node(void)
    9381109{
    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;
     1110        fun_node_t *fun;
     1111
     1112        fun = calloc(1, sizeof(fun_node_t));
     1113        if (fun == NULL)
     1114                return NULL;
     1115       
     1116        fun->state = FUN_INIT;
     1117        atomic_set(&fun->refcnt, 0);
     1118        link_initialize(&fun->dev_functions);
     1119        list_initialize(&fun->match_ids.ids);
     1120        link_initialize(&fun->devman_fun);
     1121        link_initialize(&fun->loc_fun);
     1122       
     1123        return fun;
    9501124}
    9511125
    … …  
    9651139}
    9661140
     1141/** Increase function node reference count.
     1142 *
     1143 * @param fun   Function node
     1144 */
     1145void fun_add_ref(fun_node_t *fun)
     1146{
     1147        atomic_inc(&fun->refcnt);
     1148}
     1149
     1150/** Decrease function node reference count.
     1151 *
     1152 * When the count drops to zero the function node is freed.
     1153 *
     1154 * @param fun   Function node
     1155 */
     1156void fun_del_ref(fun_node_t *fun)
     1157{
     1158        if (atomic_predec(&fun->refcnt) == 0)
     1159                delete_fun_node(fun);
     1160}
     1161
    9671162/** Find the function node with the specified handle.
    9681163 *
    … …  
    9751170        unsigned long key = handle;
    9761171        link_t *link;
     1172        fun_node_t *fun;
    9771173       
    9781174        assert(fibril_rwlock_is_locked(&tree->rwlock));
    … …  
    9821178                return NULL;
    9831179       
    984         return hash_table_get_instance(link, fun_node_t, devman_fun);
     1180        fun = hash_table_get_instance(link, fun_node_t, devman_fun);
     1181       
     1182        return fun;
    9851183}
    9861184
    … …  
    9961194       
    9971195        fibril_rwlock_read_lock(&tree->rwlock);
     1196       
    9981197        fun = find_fun_node_no_lock(tree, handle);
     1198        if (fun != NULL)
     1199                fun_add_ref(fun);
     1200       
    9991201        fibril_rwlock_read_unlock(&tree->rwlock);
    10001202       
    … …  
    10041206/** Create and set device's full path in device tree.
    10051207 *
     1208 * @param tree          Device tree
    10061209 * @param node          The device's device node.
    10071210 * @param parent        The parent device node.
    … …  
    10091212 *                      resources etc.).
    10101213 */
    1011 static bool set_fun_path(fun_node_t *fun, fun_node_t *parent)
    1012 {
     1214static bool set_fun_path(dev_tree_t *tree, fun_node_t *fun, fun_node_t *parent)
     1215{
     1216        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10131217        assert(fun->name != NULL);
    10141218       
    … …  
    10371241 *
    10381242 * @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.
     1243 * @param dev           The newly added device node.
     1244 * @param pfun          The parent function node.
    10421245 *
    10431246 * @return              True on success, false otherwise (insufficient resources
    … …  
    10461249bool insert_dev_node(dev_tree_t *tree, dev_node_t *dev, fun_node_t *pfun)
    10471250{
    1048         assert(dev != NULL);
    1049         assert(tree != NULL);
    10501251        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10511252       
    … …  
    10651266}
    10661267
     1268/** Remove device from device tree.
     1269 *
     1270 * @param tree          Device tree
     1271 * @param dev           Device node
     1272 */
     1273void remove_dev_node(dev_tree_t *tree, dev_node_t *dev)
     1274{
     1275        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
     1276       
     1277        log_msg(LVL_DEBUG, "remove_dev_node(dev=%p)", dev);
     1278       
     1279        /* Remove node from the handle-to-node map. */
     1280        unsigned long key = dev->handle;
     1281        hash_table_remove(&tree->devman_devices, &key, 1);
     1282       
     1283        /* Unlink from parent function. */
     1284        dev->pfun->child = NULL;
     1285        dev->pfun = NULL;
     1286       
     1287        dev->state = DEVICE_REMOVED;
     1288}
     1289
     1290
    10671291/** Insert new function into device tree.
    10681292 *
    10691293 * @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.
     1294 * @param fun           The newly added function node.
     1295 * @param fun_name      The name of the newly added function.
     1296 * @param dev           Owning device node.
    10731297 *
    10741298 * @return              True on success, false otherwise (insufficient resources
    … …  
    10801304        fun_node_t *pfun;
    10811305       
    1082         assert(fun != NULL);
    1083         assert(tree != NULL);
    10841306        assert(fun_name != NULL);
    10851307        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    … …  
    10921314       
    10931315        fun->name = fun_name;
    1094         if (!set_fun_path(fun, pfun)) {
     1316        if (!set_fun_path(tree, fun, pfun)) {
    10951317                return false;
    10961318        }
    … …  
    11161338void remove_fun_node(dev_tree_t *tree, fun_node_t *fun)
    11171339{
    1118         assert(tree != NULL);
    1119         assert(fun != NULL);
    11201340        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    11211341       
    … …  
    11271347        if (fun->dev != NULL)
    11281348                list_remove(&fun->dev_functions);
     1349       
     1350        fun->dev = NULL;
     1351        fun->state = FUN_REMOVED;
    11291352}
    11301353
    … …  
    11481371       
    11491372        fun_node_t *fun = tree->root_node;
     1373        fun_add_ref(fun);
    11501374        /*
    11511375         * Relative path to the function from its parent (but with '/' at the
    … …  
    11651389                }
    11661390               
    1167                 fun = find_node_child(fun, rel_path + 1);
     1391                fun_node_t *cfun = find_node_child(tree, fun, rel_path + 1);
     1392                fun_del_ref(fun);
     1393                fun = cfun;
    11681394               
    11691395                if (cont) {
    … …  
    11831409 * Device tree rwlock should be held at least for reading.
    11841410 *
     1411 * @param tree Device tree
    11851412 * @param dev Device the function belongs to.
    11861413 * @param name Function name (not path).
    … …  
    11881415 * @retval NULL No function with given name.
    11891416 */
    1190 fun_node_t *find_fun_node_in_device(dev_node_t *dev, const char *name)
    1191 {
    1192         assert(dev != NULL);
     1417fun_node_t *find_fun_node_in_device(dev_tree_t *tree, dev_node_t *dev,
     1418    const char *name)
     1419{
    11931420        assert(name != NULL);
     1421        assert(fibril_rwlock_is_locked(&tree->rwlock));
    11941422
    11951423        fun_node_t *fun;
    … …  
    11981426                fun = list_get_instance(link, fun_node_t, dev_functions);
    11991427
    1200                 if (str_cmp(name, fun->name) == 0)
     1428                if (str_cmp(name, fun->name) == 0) {
     1429                        fun_add_ref(fun);
    12011430                        return fun;
     1431                }
    12021432        }
    12031433
    … …  
    12091439 * Device tree rwlock should be held at least for reading.
    12101440 *
     1441 * @param tree          Device tree
    12111442 * @param parent        The parent function node.
    12121443 * @param name          The name of the child function.
    12131444 * @return              The child function node.
    12141445 */
    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);
     1446static fun_node_t *find_node_child(dev_tree_t *tree, fun_node_t *pfun,
     1447    const char *name)
     1448{
     1449        return find_fun_node_in_device(tree, pfun->child, name);
    12181450}
    12191451
    … …  
    12281460        fibril_rwlock_read_lock(&tree->rwlock);
    12291461        link = hash_table_find(&tree->loc_functions, &key);
    1230         if (link != NULL)
     1462        if (link != NULL) {
    12311463                fun = hash_table_get_instance(link, fun_node_t, loc_fun);
     1464                fun_add_ref(fun);
     1465        }
    12321466        fibril_rwlock_read_unlock(&tree->rwlock);
    12331467       
    … …  
    12371471void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun)
    12381472{
     1473        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
     1474       
    12391475        unsigned long key = (unsigned long) fun->service_id;
    1240         fibril_rwlock_write_lock(&tree->rwlock);
    12411476        hash_table_insert(&tree->loc_functions, &key, &fun->loc_fun);
    1242         fibril_rwlock_write_unlock(&tree->rwlock);
    12431477}
    12441478
Note: See TracChangeset for help on using the changeset viewer.