Changeset a35b458 in mainline for uspace/srv/devman/client_conn.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/client_conn.c

    r3061bc1 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.