Ignore:
File:
1 edited

Legend:

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

    ra35b458 r5a6cc679  
    7171        devman_handle_t handle = IPC_GET_ARG2(*icall);
    7272        dev_node_t *dev = NULL;
    73 
     73       
    7474        fun_node_t *fun = find_fun_node(&device_tree, handle);
    7575        if (fun == NULL) {
     
    7777        } else {
    7878                fibril_rwlock_read_lock(&device_tree.rwlock);
    79 
     79               
    8080                dev = fun->dev;
    8181                if (dev != NULL)
    8282                        dev_add_ref(dev);
    83 
     83               
    8484                fibril_rwlock_read_unlock(&device_tree.rwlock);
    8585        }
    86 
     86       
    8787        /*
    8888         * For a valid function to connect to we need a device. The root
     
    9797                goto cleanup;
    9898        }
    99 
     99       
    100100        if (fun == NULL) {
    101101                log_msg(LOG_DEFAULT, LVL_ERROR, NAME ": devman_forward error - cannot "
     
    105105                goto cleanup;
    106106        }
    107 
     107       
    108108        fibril_rwlock_read_lock(&device_tree.rwlock);
    109 
     109       
    110110        /* Connect to the specified function */
    111111        driver_t *driver = dev->drv;
    112 
     112       
    113113        fibril_rwlock_read_unlock(&device_tree.rwlock);
    114 
     114       
    115115        if (driver == NULL) {
    116116                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - " \
     
    119119                goto cleanup;
    120120        }
    121 
     121       
    122122        if (!driver->sess) {
    123123                log_msg(LOG_DEFAULT, LVL_ERROR,
     
    126126                goto cleanup;
    127127        }
    128 
     128       
    129129        if (fun != NULL) {
    130130                log_msg(LOG_DEFAULT, LVL_DEBUG,
     
    136136                    dev->pfun->pathname, driver->name);
    137137        }
    138 
     138       
    139139        async_exch_t *exch = async_exchange_begin(driver->sess);
    140140        async_forward_fast(iid, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
    141141        async_exchange_end(exch);
    142 
     142       
    143143cleanup:
    144144        if (dev != NULL)
    145145                dev_del_ref(dev);
    146 
     146       
    147147        if (fun != NULL)
    148148                fun_del_ref(fun);
     
    154154        devman_handle_t handle = IPC_GET_ARG2(*icall);
    155155        dev_node_t *dev = NULL;
    156 
     156       
    157157        fun_node_t *fun = find_fun_node(&device_tree, handle);
    158158        if (fun == NULL) {
     
    160160        } else {
    161161                fibril_rwlock_read_lock(&device_tree.rwlock);
    162 
     162               
    163163                dev = fun->dev;
    164164                if (dev != NULL)
    165165                        dev_add_ref(dev);
    166 
     166               
    167167                fibril_rwlock_read_unlock(&device_tree.rwlock);
    168168        }
    169 
     169       
    170170        /*
    171171         * For a valid function to connect to we need a device. The root
     
    180180                goto cleanup;
    181181        }
    182 
     182       
    183183        driver_t *driver = NULL;
    184 
     184       
    185185        fibril_rwlock_read_lock(&device_tree.rwlock);
    186 
     186       
    187187        /* Connect to parent function of a device (or device function). */
    188188        if (dev->pfun->dev != NULL)
    189189                driver = dev->pfun->dev->drv;
    190 
     190       
    191191        devman_handle_t fun_handle = dev->pfun->handle;
    192 
     192       
    193193        fibril_rwlock_read_unlock(&device_tree.rwlock);
    194 
     194       
    195195        if (driver == NULL) {
    196196                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - " \
     
    199199                goto cleanup;
    200200        }
    201 
     201       
    202202        if (!driver->sess) {
    203203                log_msg(LOG_DEFAULT, LVL_ERROR,
     
    206206                goto cleanup;
    207207        }
    208 
     208       
    209209        if (fun != NULL) {
    210210                log_msg(LOG_DEFAULT, LVL_DEBUG,
     
    216216                    dev->pfun->pathname, driver->name);
    217217        }
    218 
     218       
    219219        async_exch_t *exch = async_exchange_begin(driver->sess);
    220220        async_forward_fast(iid, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
    221221        async_exchange_end(exch);
    222 
     222       
    223223cleanup:
    224224        if (dev != NULL)
    225225                dev_del_ref(dev);
    226 
     226       
    227227        if (fun != NULL)
    228228                fun_del_ref(fun);
     
    233233        iface_t iface = IPC_GET_ARG1(*icall);
    234234        service_id_t service_id = IPC_GET_ARG2(*icall);
    235 
     235       
    236236        fun_node_t *fun = find_loc_tree_function(&device_tree, service_id);
    237 
     237       
    238238        fibril_rwlock_read_lock(&device_tree.rwlock);
    239 
     239       
    240240        if ((fun == NULL) || (fun->dev == NULL) || (fun->dev->drv == NULL)) {
    241241                log_msg(LOG_DEFAULT, LVL_WARN, "devman_forward(): function "
     
    245245                return;
    246246        }
    247 
     247       
    248248        dev_node_t *dev = fun->dev;
    249249        driver_t *driver = dev->drv;
    250250        devman_handle_t handle = fun->handle;
    251 
     251       
    252252        fibril_rwlock_read_unlock(&device_tree.rwlock);
    253 
     253       
    254254        async_exch_t *exch = async_exchange_begin(driver->sess);
    255255        async_forward_fast(iid, exch, iface, handle, 0, IPC_FF_NONE);
    256256        async_exchange_end(exch);
    257 
     257       
    258258        log_msg(LOG_DEFAULT, LVL_DEBUG,
    259259            "Forwarding service request for `%s' function to driver `%s'.",
    260260            fun->pathname, driver->name);
    261 
     261       
    262262        fun_del_ref(fun);
    263263}
     
    266266{
    267267        client_t *client;
    268 
     268       
    269269        client = calloc(1, sizeof(client_t));
    270270        if (client == NULL)
    271271                return NULL;
    272 
     272       
    273273        fibril_mutex_initialize(&client->mutex);
    274274        return client;
     
    284284{
    285285        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_init - looking for available drivers.");
    286 
     286       
    287287        /* Initialize list of available drivers. */
    288288        init_driver_list(&drivers_list);
     
    292292                return false;
    293293        }
    294 
     294       
    295295        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_init - list of drivers has been initialized.");
    296 
     296       
    297297        /* Create root device node. */
    298298        if (!init_device_tree(&device_tree, &drivers_list)) {
     
    300300                return false;
    301301        }
    302 
     302       
    303303        /*
    304304         * Caution: As the device manager is not a real loc
     
    309309         */
    310310        loc_server_register(NAME);
    311 
     311       
    312312        return true;
    313313}
     
    316316{
    317317        printf("%s: HelenOS Device Manager\n", NAME);
    318 
     318       
    319319        errno_t rc = log_init(NAME);
    320320        if (rc != EOK) {
     
    322322                return rc;
    323323        }
    324 
     324       
    325325        /* Set handlers for incoming connections. */
    326326        async_set_client_data_constructor(devman_client_data_create);
    327327        async_set_client_data_destructor(devman_client_data_destroy);
    328 
     328       
    329329        port_id_t port;
    330330        rc = async_create_port(INTERFACE_DDF_DRIVER,
     
    334334                return rc;
    335335        }
    336 
     336       
    337337        rc = async_create_port(INTERFACE_DDF_CLIENT,
    338338            devman_connection_client, NULL, &port);
     
    341341                return rc;
    342342        }
    343 
     343       
    344344        rc = async_create_port(INTERFACE_DEVMAN_DEVICE,
    345345            devman_connection_device, NULL, &port);
     
    348348                return rc;
    349349        }
    350 
     350       
    351351        rc = async_create_port(INTERFACE_DEVMAN_PARENT,
    352352            devman_connection_parent, NULL, &port);
     
    355355                return rc;
    356356        }
    357 
     357       
    358358        async_set_fallback_port_handler(devman_forward, NULL);
    359 
     359       
    360360        if (!devman_init()) {
    361361                log_msg(LOG_DEFAULT, LVL_ERROR, "Error while initializing service.");
    362362                return -1;
    363363        }
    364 
     364       
    365365        /* Register device manager at naming service. */
    366366        rc = service_register(SERVICE_DEVMAN);
     
    369369                return rc;
    370370        }
    371 
     371       
    372372        printf("%s: Accepting connections.\n", NAME);
    373373        task_retval(0);
    374374        async_manager();
    375 
     375       
    376376        /* Never reached. */
    377377        return 0;
Note: See TracChangeset for help on using the changeset viewer.