Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/client_conn.c

    r5a6cc679 ra35b458  
    6565        char *pathname;
    6666        devman_handle_t handle;
    67        
     67
    6868        errno_t rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0);
    6969        if (rc != EOK) {
    … …  
    7171                return;
    7272        }
    73        
     73
    7474        fun_node_t *fun = find_fun_node_by_path(&device_tree, pathname);
    75        
     75
    7676        free(pathname);
    7777
    … …  
    306306                return;
    307307        }
    308        
     308
    309309        fibril_rwlock_read_lock(&device_tree.rwlock);
    310        
     310
    311311        /* Check function state */
    312312        if (fun->state == FUN_REMOVED) {
    … …  
    319319                return;
    320320        }
    321        
     321
    322322        size_t sent_length = str_size(fun->pathname);
    323323        if (sent_length > data_len) {
    … …  
    337337{
    338338        dev_node_t *dev;
    339        
     339
    340340        fibril_rwlock_read_lock(&device_tree.rwlock);
    341        
     341
    342342        dev = find_dev_node_no_lock(&device_tree, IPC_GET_ARG1(*icall));
    343343        if (dev == NULL || dev->state == DEVICE_REMOVED) {
    … …  
    346346                return;
    347347        }
    348        
     348
    349349        if (dev->pfun == NULL) {
    350350                fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    352352                return;
    353353        }
    354        
     354
    355355        async_answer_1(iid, EOK, dev->pfun->handle);
    356        
     356
    357357        fibril_rwlock_read_unlock(&device_tree.rwlock);
    358358}
    … …  
    364364        size_t act_size;
    365365        errno_t rc;
    366        
     366
    367367        if (!async_data_read_receive(&callid, &size)) {
    368368                async_answer_0(callid, EREFUSED);
    … …  
    370370                return;
    371371        }
    372        
     372
    373373        fibril_rwlock_read_lock(&device_tree.rwlock);
    374        
     374
    375375        dev_node_t *dev = find_dev_node_no_lock(&device_tree,
    376376            IPC_GET_ARG1(*icall));
    … …  
    381381                return;
    382382        }
    383        
     383
    384384        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
    385385        if (hdl_buf == NULL) {
    … …  
    389389                return;
    390390        }
    391        
     391
    392392        rc = dev_get_functions(&device_tree, dev, hdl_buf, size, &act_size);
    393393        if (rc != EOK) {
    … …  
    397397                return;
    398398        }
    399        
    400         fibril_rwlock_read_unlock(&device_tree.rwlock);
    401        
     399
     400        fibril_rwlock_read_unlock(&device_tree.rwlock);
     401
    402402        errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
    403403        free(hdl_buf);
    404        
     404
    405405        async_answer_1(iid, retval, act_size);
    406406}
    … …  
    410410{
    411411        fun_node_t *fun;
    412        
     412
    413413        fibril_rwlock_read_lock(&device_tree.rwlock);
    414        
     414
    415415        fun = find_fun_node_no_lock(&device_tree, IPC_GET_ARG1(*icall));
    416416        if (fun == NULL || fun->state == FUN_REMOVED) {
    … …  
    419419                return;
    420420        }
    421        
     421
    422422        if (fun->child == NULL) {
    423423                fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    425425                return;
    426426        }
    427        
     427
    428428        async_answer_1(iid, EOK, fun->child->handle);
    429        
     429
    430430        fibril_rwlock_read_unlock(&device_tree.rwlock);
    431431}
    … …  
    447447                return;
    448448        }
    449        
     449
    450450        rc = driver_fun_online(&device_tree, fun);
    451451        fun_del_ref(fun);
    452        
     452
    453453        async_answer_0(iid, rc);
    454454}
    … …  
    472472                return;
    473473        }
    474        
     474
    475475        rc = driver_fun_offline(&device_tree, fun);
    476476        fun_del_ref(fun);
    477        
     477
    478478        async_answer_0(iid, rc);
    479479}
    … …  
    485485
    486486        fun = find_loc_tree_function(&device_tree, IPC_GET_ARG1(*icall));
    487        
     487
    488488        if (fun == NULL) {
    489489                async_answer_0(iid, ENOENT);
    … …  
    512512        size_t act_size;
    513513        errno_t rc;
    514        
     514
    515515        if (!async_data_read_receive(&callid, &size)) {
    516516                async_answer_0(iid, EREFUSED);
    517517                return;
    518518        }
    519        
     519
    520520        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
    521521        if (hdl_buf == NULL) {
    … …  
    524524                return;
    525525        }
    526        
     526
    527527        rc = driver_get_list(&drivers_list, hdl_buf, size, &act_size);
    528528        if (rc != EOK) {
    … …  
    531531                return;
    532532        }
    533        
     533
    534534        errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
    535535        free(hdl_buf);
    536        
     536
    537537        async_answer_1(iid, retval, act_size);
    538538}
    … …  
    544544        size_t act_size;
    545545        errno_t rc;
    546        
     546
    547547        if (!async_data_read_receive(&callid, &size)) {
    548548                async_answer_0(iid, EREFUSED);
    549549                return;
    550550        }
    551        
     551
    552552        driver_t *drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    553553        if (drv == NULL) {
    … …  
    556556                return;
    557557        }
    558        
     558
    559559        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
    560560        if (hdl_buf == NULL) {
    … …  
    563563                return;
    564564        }
    565        
     565
    566566        rc = driver_get_devices(drv, hdl_buf, size, &act_size);
    567567        if (rc != EOK) {
    … …  
    571571                return;
    572572        }
    573        
     573
    574574        errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
    575575        free(hdl_buf);
    576        
     576
    577577        async_answer_1(iid, retval, act_size);
    578578}
    … …  
    583583{
    584584        char *drvname;
    585        
     585
    586586        errno_t rc = async_data_write_accept((void **) &drvname, true, 0, 0, 0, 0);
    587587        if (rc != EOK) {
    … …  
    589589                return;
    590590        }
    591        
     591
    592592        driver_t *driver = driver_find_by_name(&drivers_list, drvname);
    593        
     593
    594594        free(drvname);
    595        
     595
    596596        if (driver == NULL) {
    597597                async_answer_0(iid, ENOENT);
    598598                return;
    599599        }
    600        
     600
    601601        async_answer_1(iid, EOK, driver->handle);
    602602}
    … …  
    697697{
    698698        driver_t *drv;
    699        
     699
    700700        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    701701        if (drv == NULL) {
    … …  
    703703                return;
    704704        }
    705        
     705
    706706        async_answer_1(iid, EOK, (sysarg_t) drv->state);
    707707}
    … …  
    712712        driver_t *drv;
    713713        errno_t rc;
    714        
     714
    715715        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    716716        if (drv == NULL) {
    … …  
    718718                return;
    719719        }
    720        
     720
    721721        fibril_mutex_lock(&drv->driver_mutex);
    722722        rc = start_driver(drv) ? EOK : EIO;
    … …  
    731731        driver_t *drv;
    732732        errno_t rc;
    733        
     733
    734734        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    735735        if (drv == NULL) {
    … …  
    737737                return;
    738738        }
    739        
     739
    740740        fibril_mutex_lock(&drv->driver_mutex);
    741741        rc = stop_driver(drv);
    … …  
    750750        /* Accept connection. */
    751751        async_answer_0(iid, EOK);
    752        
     752
    753753        while (true) {
    754754                ipc_call_t call;
    755755                ipc_callid_t callid = async_get_call(&call);
    756                
     756
    757757                if (!IPC_GET_IMETHOD(call))
    758758                        break;
    759                
     759
    760760                switch (IPC_GET_IMETHOD(call)) {
    761761                case DEVMAN_DEVICE_GET_HANDLE:
Note: See TracChangeset for help on using the changeset viewer.