Changeset a35b458 in mainline for uspace/lib/c/generic/devman.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/lib/c/generic/devman.c

    r3061bc1 ra35b458  
    6262{
    6363        fibril_mutex_lock(mtx);
    64        
     64
    6565        if ((*dst == NULL) && (src != NULL))
    6666                *dst = src;
    67        
     67
    6868        fibril_mutex_unlock(mtx);
    6969}
    … …  
    8181        case INTERFACE_DDF_DRIVER:
    8282                fibril_mutex_lock(&devman_driver_block_mutex);
    83                
     83
    8484                while (devman_driver_block_sess == NULL) {
    8585                        clone_session(&devman_driver_mutex, devman_driver_sess,
    8686                            &devman_driver_block_sess);
    87                        
     87
    8888                        if (devman_driver_block_sess == NULL)
    8989                                devman_driver_block_sess =
    … …  
    9191                                    INTERFACE_DDF_DRIVER, 0);
    9292                }
    93                
     93
    9494                fibril_mutex_unlock(&devman_driver_block_mutex);
    95                
     95
    9696                clone_session(&devman_driver_mutex, devman_driver_block_sess,
    9797                    &devman_driver_sess);
    98                
     98
    9999                return async_exchange_begin(devman_driver_block_sess);
    100100        case INTERFACE_DDF_CLIENT:
    101101                fibril_mutex_lock(&devman_client_block_mutex);
    102                
     102
    103103                while (devman_client_block_sess == NULL) {
    104104                        clone_session(&devman_client_mutex, devman_client_sess,
    105105                            &devman_client_block_sess);
    106                        
     106
    107107                        if (devman_client_block_sess == NULL)
    108108                                devman_client_block_sess =
    … …  
    110110                                    INTERFACE_DDF_CLIENT, 0);
    111111                }
    112                
     112
    113113                fibril_mutex_unlock(&devman_client_block_mutex);
    114                
     114
    115115                clone_session(&devman_client_mutex, devman_client_block_sess,
    116116                    &devman_client_sess);
    117                
     117
    118118                return async_exchange_begin(devman_client_block_sess);
    119119        default:
    … …  
    134134        case INTERFACE_DDF_DRIVER:
    135135                fibril_mutex_lock(&devman_driver_mutex);
    136                
     136
    137137                if (devman_driver_sess == NULL)
    138138                        devman_driver_sess =
    139139                            service_connect(SERVICE_DEVMAN,
    140140                            INTERFACE_DDF_DRIVER, 0);
    141                
     141
    142142                fibril_mutex_unlock(&devman_driver_mutex);
    143                
     143
    144144                if (devman_driver_sess == NULL)
    145145                        return NULL;
    146                
     146
    147147                return async_exchange_begin(devman_driver_sess);
    148148        case INTERFACE_DDF_CLIENT:
    149149                fibril_mutex_lock(&devman_client_mutex);
    150                
     150
    151151                if (devman_client_sess == NULL)
    152152                        devman_client_sess =
    153153                            service_connect(SERVICE_DEVMAN,
    154154                            INTERFACE_DDF_CLIENT, 0);
    155                
     155
    156156                fibril_mutex_unlock(&devman_client_mutex);
    157                
     157
    158158                if (devman_client_sess == NULL)
    159159                        return NULL;
    160                
     160
    161161                return async_exchange_begin(devman_client_sess);
    162162        default:
    … …  
    179179{
    180180        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    181        
     181
    182182        ipc_call_t answer;
    183183        aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
    184184        errno_t retval = async_data_write_start(exch, name, str_size(name));
    185        
    186         devman_exchange_end(exch);
    187        
     185
     186        devman_exchange_end(exch);
     187
    188188        if (retval != EOK) {
    189189                async_forget(req);
    190190                return retval;
    191191        }
    192        
     192
    193193        exch = devman_exchange_begin(INTERFACE_DDF_DRIVER);
    194194        async_connect_to_me(exch, 0, 0, 0);
    195195        devman_exchange_end(exch);
    196        
     196
    197197        async_wait_for(req, &retval);
    198198        return retval;
    … …  
    218218        unsigned long match_count = list_count(&match_ids->ids);
    219219        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    220        
     220
    221221        ipc_call_t answer;
    222222        aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
    … …  
    228228                return retval;
    229229        }
    230        
     230
    231231        list_foreach(match_ids->ids, link, match_id_t, match_id) {
    232232                ipc_call_t answer2;
    … …  
    241241                        return retval;
    242242                }
    243                
     243
    244244                async_wait_for(req2, &retval);
    245245                if (retval != EOK) {
    … …  
    249249                }
    250250        }
    251        
    252         devman_exchange_end(exch);
    253        
     251
     252        devman_exchange_end(exch);
     253
    254254        async_wait_for(req, &retval);
    255255        if (retval == EOK) {
    … …  
    260260                        *funh = -1;
    261261        }
    262        
     262
    263263        return retval;
    264264}
    … …  
    268268{
    269269        async_exch_t *exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    270        
     270
    271271        ipc_call_t answer;
    272272        aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY,
    … …  
    274274        errno_t retval = async_data_write_start(exch, cat_name,
    275275            str_size(cat_name));
    276        
    277         devman_exchange_end(exch);
    278        
     276
     277        devman_exchange_end(exch);
     278
    279279        if (retval != EOK) {
    280280                async_forget(req);
    281281                return retval;
    282282        }
    283        
     283
    284284        async_wait_for(req, &retval);
    285285        return retval;
    … …  
    289289{
    290290        async_sess_t *sess;
    291        
     291
    292292        if (flags & IPC_FLAG_BLOCKING)
    293293                sess = service_connect_blocking(SERVICE_DEVMAN,
    … …  
    296296                sess = service_connect(SERVICE_DEVMAN,
    297297                    INTERFACE_DEVMAN_DEVICE, handle);
    298        
     298
    299299        return sess;
    300300}
    … …  
    311311        async_exch_t *exch;
    312312        errno_t retval;
    313        
     313
    314314        exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    315315        retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
    316316        devman_exchange_end(exch);
    317        
     317
    318318        return retval;
    319319}
    … …  
    324324        if (exch == NULL)
    325325                return ENOMEM;
    326        
     326
    327327        errno_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_ONLINE, funh);
    328        
     328
    329329        devman_exchange_end(exch);
    330330        return retval;
    … …  
    336336        if (exch == NULL)
    337337                return ENOMEM;
    338        
     338
    339339        errno_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_OFFLINE, funh);
    340        
     340
    341341        devman_exchange_end(exch);
    342342        return retval;
    … …  
    347347{
    348348        async_sess_t *sess;
    349        
     349
    350350        if (flags & IPC_FLAG_BLOCKING)
    351351                sess = service_connect_blocking(SERVICE_DEVMAN,
    … …  
    354354                sess = service_connect_blocking(SERVICE_DEVMAN,
    355355                    INTERFACE_DEVMAN_PARENT, handle);
    356        
     356
    357357        return sess;
    358358}
    … …  
    362362{
    363363        async_exch_t *exch;
    364        
     364
    365365        if (flags & IPC_FLAG_BLOCKING)
    366366                exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    … …  
    370370                        return ENOMEM;
    371371        }
    372        
     372
    373373        ipc_call_t answer;
    374374        aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
    … …  
    376376        errno_t retval = async_data_write_start(exch, pathname,
    377377            str_size(pathname));
    378        
    379         devman_exchange_end(exch);
    380        
     378
     379        devman_exchange_end(exch);
     380
    381381        if (retval != EOK) {
    382382                async_forget(req);
    383383                return retval;
    384384        }
    385        
     385
    386386        async_wait_for(req, &retval);
    387        
     387
    388388        if (retval != EOK) {
    389389                if (handle != NULL)
    390390                        *handle = (devman_handle_t) -1;
    391                
    392                 return retval;
    393         }
    394        
     391
     392                return retval;
     393        }
     394
    395395        if (handle != NULL)
    396396                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    397        
     397
    398398        return retval;
    399399}
    … …  
    406406        size_t act_size;
    407407        errno_t dretval;
    408        
     408
    409409        exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    410        
     410
    411411        ipc_call_t answer;
    412412        aid_t req = async_send_2(exch, method, arg1, arg2, &answer);
    413413        aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
    414414        async_wait_for(dreq, &dretval);
    415        
    416         devman_exchange_end(exch);
    417        
     415
     416        devman_exchange_end(exch);
     417
    418418        if (dretval != EOK) {
    419419                async_forget(req);
    420420                return dretval;
    421421        }
    422        
     422
    423423        errno_t retval;
    424424        async_wait_for(req, &retval);
    425        
    426         if (retval != EOK) {
    427                 return retval;
    428         }
    429        
     425
     426        if (retval != EOK) {
     427                return retval;
     428        }
     429
    430430        if (r1 != NULL)
    431431                *r1 = IPC_GET_ARG1(answer);
    … …  
    433433        assert(act_size <= buf_size - 1);
    434434        buf[act_size] = '\0';
    435        
     435
    436436        return EOK;
    437437}
    … …  
    475475        if (exch == NULL)
    476476                return ENOMEM;
    477        
     477
    478478        errno_t retval = async_req_1_0(exch, DEVMAN_FUN_ONLINE, funh);
    479        
     479
    480480        devman_exchange_end(exch);
    481481        return retval;
    … …  
    487487        if (exch == NULL)
    488488                return ENOMEM;
    489        
     489
    490490        errno_t retval = async_req_1_0(exch, DEVMAN_FUN_OFFLINE, funh);
    491        
     491
    492492        devman_exchange_end(exch);
    493493        return retval;
    … …  
    502502        aid_t req = async_send_1(exch, method, arg1, &answer);
    503503        errno_t rc = async_data_read_start(exch, handle_buf, buf_size);
    504        
    505         devman_exchange_end(exch);
    506        
     504
     505        devman_exchange_end(exch);
     506
    507507        if (rc != EOK) {
    508508                async_forget(req);
    509509                return rc;
    510510        }
    511        
     511
    512512        errno_t retval;
    513513        async_wait_for(req, &retval);
    514        
    515         if (retval != EOK) {
    516                 return retval;
    517         }
    518        
     514
     515        if (retval != EOK) {
     516                return retval;
     517        }
     518
    519519        *act_size = IPC_GET_ARG1(answer);
    520520        return EOK;
    … …  
    579579        if (exch == NULL)
    580580                return ENOMEM;
    581        
     581
    582582        errno_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
    583583            funh, devh);
    584        
     584
    585585        devman_exchange_end(exch);
    586586        return retval;
    … …  
    599599        if (exch == NULL)
    600600                return ENOMEM;
    601        
     601
    602602        errno_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
    603603            devh, funh);
    604        
     604
    605605        devman_exchange_end(exch);
    606606        return retval;
    … …  
    612612        if (exch == NULL)
    613613                return ENOMEM;
    614        
     614
    615615        errno_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
    616616            sid, handle);
    617        
     617
    618618        devman_exchange_end(exch);
    619619        return retval;
    … …  
    640640        if (exch == NULL)
    641641                return ENOMEM;
    642        
     642
    643643        ipc_call_t answer;
    644644        aid_t req = async_send_0(exch, DEVMAN_DRIVER_GET_HANDLE, &answer);
    645645        errno_t retval = async_data_write_start(exch, drvname,
    646646            str_size(drvname));
    647        
    648         devman_exchange_end(exch);
    649        
     647
     648        devman_exchange_end(exch);
     649
    650650        if (retval != EOK) {
    651651                async_forget(req);
    652652                return retval;
    653653        }
    654        
     654
    655655        async_wait_for(req, &retval);
    656        
     656
    657657        if (retval != EOK) {
    658658                if (handle != NULL)
    659659                        *handle = (devman_handle_t) -1;
    660                
    661                 return retval;
    662         }
    663        
     660
     661                return retval;
     662        }
     663
    664664        if (handle != NULL)
    665665                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    666        
     666
    667667        return retval;
    668668}
    … …  
    695695        if (exch == NULL)
    696696                return ENOMEM;
    697        
     697
    698698        errno_t rc = async_req_1_1(exch, DEVMAN_DRIVER_GET_STATE, drvh,
    699699            &state);
    700        
     700
    701701        devman_exchange_end(exch);
    702702        if (rc != EOK)
    … …  
    712712        if (exch == NULL)
    713713                return ENOMEM;
    714        
     714
    715715        errno_t rc = async_req_1_0(exch, DEVMAN_DRIVER_LOAD, drvh);
    716        
     716
    717717        devman_exchange_end(exch);
    718718        return rc;
    … …  
    724724        if (exch == NULL)
    725725                return ENOMEM;
    726        
     726
    727727        errno_t rc = async_req_1_0(exch, DEVMAN_DRIVER_UNLOAD, drvh);
    728        
     728
    729729        devman_exchange_end(exch);
    730730        return rc;
Note: See TracChangeset for help on using the changeset viewer.