Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/client_conn.c

    ra35b458 r5a6cc679  
    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.