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


Ignore:
Timestamp:
2018-03-22T06:49:35Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/client_conn.c

    r3e242d2 ra46e56b  
    6161/** Find handle for the device instance identified by the device's path in the
    6262 * device tree. */
    63 static void devman_function_get_handle(cap_call_handle_t iid, ipc_call_t *icall)
     63static void devman_function_get_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
    6464{
    6565        char *pathname;
    … …  
    6868        errno_t rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0);
    6969        if (rc != EOK) {
    70                 async_answer_0(iid, rc);
     70                async_answer_0(icall_handle, rc);
    7171                return;
    7272        }
    … …  
    7777
    7878        if (fun == NULL) {
    79                 async_answer_0(iid, ENOENT);
     79                async_answer_0(icall_handle, ENOENT);
    8080                return;
    8181        }
    … …  
    8686        if (fun->state == FUN_REMOVED) {
    8787                fibril_rwlock_read_unlock(&device_tree.rwlock);
    88                 async_answer_0(iid, ENOENT);
     88                async_answer_0(icall_handle, ENOENT);
    8989                return;
    9090        }
    … …  
    9696        fun_del_ref(fun);
    9797
    98         async_answer_1(iid, EOK, handle);
     98        async_answer_1(icall_handle, EOK, handle);
    9999}
    100100
    101101/** Get device match ID. */
    102 static void devman_fun_get_match_id(cap_call_handle_t iid, ipc_call_t *icall)
     102static void devman_fun_get_match_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
    103103{
    104104        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    108108        fun_node_t *fun = find_fun_node(&device_tree, handle);
    109109        if (fun == NULL) {
    110                 async_answer_0(iid, ENOMEM);
    111                 return;
    112         }
    113 
    114         cap_call_handle_t data_callid;
     110                async_answer_0(icall_handle, ENOMEM);
     111                return;
     112        }
     113
     114        cap_call_handle_t data_chandle;
    115115        size_t data_len;
    116         if (!async_data_read_receive(&data_callid, &data_len)) {
    117                 async_answer_0(iid, EINVAL);
     116        if (!async_data_read_receive(&data_chandle, &data_len)) {
     117                async_answer_0(icall_handle, EINVAL);
    118118                fun_del_ref(fun);
    119119                return;
    … …  
    122122        buffer = malloc(data_len);
    123123        if (buffer == NULL) {
    124                 async_answer_0(data_callid, ENOMEM);
    125                 async_answer_0(iid, ENOMEM);
     124                async_answer_0(data_chandle, ENOMEM);
     125                async_answer_0(icall_handle, ENOMEM);
    126126                fun_del_ref(fun);
    127127                return;
    … …  
    145145        }
    146146
    147         async_data_read_finalize(data_callid, mid->id, sent_length);
    148         async_answer_1(iid, EOK, mid->score);
     147        async_data_read_finalize(data_chandle, mid->id, sent_length);
     148        async_answer_1(icall_handle, EOK, mid->score);
    149149
    150150        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    157157        free(buffer);
    158158
    159         async_answer_0(data_callid, ENOENT);
    160         async_answer_0(iid, ENOENT);
     159        async_answer_0(data_chandle, ENOENT);
     160        async_answer_0(icall_handle, ENOENT);
    161161        fun_del_ref(fun);
    162162}
    163163
    164164/** Get device name. */
    165 static void devman_fun_get_name(cap_call_handle_t iid, ipc_call_t *icall)
     165static void devman_fun_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
    166166{
    167167        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    169169        fun_node_t *fun = find_fun_node(&device_tree, handle);
    170170        if (fun == NULL) {
    171                 async_answer_0(iid, ENOMEM);
    172                 return;
    173         }
    174 
    175         cap_call_handle_t data_callid;
     171                async_answer_0(icall_handle, ENOMEM);
     172                return;
     173        }
     174
     175        cap_call_handle_t data_chandle;
    176176        size_t data_len;
    177         if (!async_data_read_receive(&data_callid, &data_len)) {
    178                 async_answer_0(iid, EINVAL);
     177        if (!async_data_read_receive(&data_chandle, &data_len)) {
     178                async_answer_0(icall_handle, EINVAL);
    179179                fun_del_ref(fun);
    180180                return;
    … …  
    183183        void *buffer = malloc(data_len);
    184184        if (buffer == NULL) {
    185                 async_answer_0(data_callid, ENOMEM);
    186                 async_answer_0(iid, ENOMEM);
     185                async_answer_0(data_chandle, ENOMEM);
     186                async_answer_0(icall_handle, ENOMEM);
    187187                fun_del_ref(fun);
    188188                return;
    … …  
    196196                free(buffer);
    197197
    198                 async_answer_0(data_callid, ENOENT);
    199                 async_answer_0(iid, ENOENT);
     198                async_answer_0(data_chandle, ENOENT);
     199                async_answer_0(icall_handle, ENOENT);
    200200                fun_del_ref(fun);
    201201                return;
    … …  
    207207        }
    208208
    209         async_data_read_finalize(data_callid, fun->name, sent_length);
    210         async_answer_0(iid, EOK);
     209        async_data_read_finalize(data_chandle, fun->name, sent_length);
     210        async_answer_0(icall_handle, EOK);
    211211
    212212        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    216216
    217217/** Get function driver name. */
    218 static void devman_fun_get_driver_name(cap_call_handle_t iid, ipc_call_t *icall)
     218static void devman_fun_get_driver_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
    219219{
    220220        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    222222        fun_node_t *fun = find_fun_node(&device_tree, handle);
    223223        if (fun == NULL) {
    224                 async_answer_0(iid, ENOMEM);
    225                 return;
    226         }
    227 
    228         cap_call_handle_t data_callid;
     224                async_answer_0(icall_handle, ENOMEM);
     225                return;
     226        }
     227
     228        cap_call_handle_t data_chandle;
    229229        size_t data_len;
    230         if (!async_data_read_receive(&data_callid, &data_len)) {
    231                 async_answer_0(iid, EINVAL);
     230        if (!async_data_read_receive(&data_chandle, &data_len)) {
     231                async_answer_0(icall_handle, EINVAL);
    232232                fun_del_ref(fun);
    233233                return;
    … …  
    236236        void *buffer = malloc(data_len);
    237237        if (buffer == NULL) {
    238                 async_answer_0(data_callid, ENOMEM);
    239                 async_answer_0(iid, ENOMEM);
     238                async_answer_0(data_chandle, ENOMEM);
     239                async_answer_0(icall_handle, ENOMEM);
    240240                fun_del_ref(fun);
    241241                return;
    … …  
    249249                free(buffer);
    250250
    251                 async_answer_0(data_callid, ENOENT);
    252                 async_answer_0(iid, ENOENT);
     251                async_answer_0(data_chandle, ENOENT);
     252                async_answer_0(icall_handle, ENOENT);
    253253                fun_del_ref(fun);
    254254                return;
    … …  
    260260                free(buffer);
    261261
    262                 async_answer_0(data_callid, EINVAL);
    263                 async_answer_0(iid, EINVAL);
     262                async_answer_0(data_chandle, EINVAL);
     263                async_answer_0(icall_handle, EINVAL);
    264264                fun_del_ref(fun);
    265265                return;
    … …  
    271271        }
    272272
    273         async_data_read_finalize(data_callid, fun->child->drv->name,
     273        async_data_read_finalize(data_chandle, fun->child->drv->name,
    274274            sent_length);
    275         async_answer_0(iid, EOK);
     275        async_answer_0(icall_handle, EOK);
    276276
    277277        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    281281
    282282/** Get device path. */
    283 static void devman_fun_get_path(cap_call_handle_t iid, ipc_call_t *icall)
     283static void devman_fun_get_path(cap_call_handle_t icall_handle, ipc_call_t *icall)
    284284{
    285285        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    287287        fun_node_t *fun = find_fun_node(&device_tree, handle);
    288288        if (fun == NULL) {
    289                 async_answer_0(iid, ENOMEM);
    290                 return;
    291         }
    292 
    293         cap_call_handle_t data_callid;
     289                async_answer_0(icall_handle, ENOMEM);
     290                return;
     291        }
     292
     293        cap_call_handle_t data_chandle;
    294294        size_t data_len;
    295         if (!async_data_read_receive(&data_callid, &data_len)) {
    296                 async_answer_0(iid, EINVAL);
     295        if (!async_data_read_receive(&data_chandle, &data_len)) {
     296                async_answer_0(icall_handle, EINVAL);
    297297                fun_del_ref(fun);
    298298                return;
    … …  
    301301        void *buffer = malloc(data_len);
    302302        if (buffer == NULL) {
    303                 async_answer_0(data_callid, ENOMEM);
    304                 async_answer_0(iid, ENOMEM);
     303                async_answer_0(data_chandle, ENOMEM);
     304                async_answer_0(icall_handle, ENOMEM);
    305305                fun_del_ref(fun);
    306306                return;
    … …  
    314314                free(buffer);
    315315
    316                 async_answer_0(data_callid, ENOENT);
    317                 async_answer_0(iid, ENOENT);
     316                async_answer_0(data_chandle, ENOENT);
     317                async_answer_0(icall_handle, ENOENT);
    318318                fun_del_ref(fun);
    319319                return;
    … …  
    325325        }
    326326
    327         async_data_read_finalize(data_callid, fun->pathname, sent_length);
    328         async_answer_0(iid, EOK);
     327        async_data_read_finalize(data_chandle, fun->pathname, sent_length);
     328        async_answer_0(icall_handle, EOK);
    329329
    330330        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    334334
    335335/** Get handle for parent function of a device. */
    336 static void devman_dev_get_parent(cap_call_handle_t iid, ipc_call_t *icall)
     336static void devman_dev_get_parent(cap_call_handle_t icall_handle, ipc_call_t *icall)
    337337{
    338338        dev_node_t *dev;
    … …  
    343343        if (dev == NULL || dev->state == DEVICE_REMOVED) {
    344344                fibril_rwlock_read_unlock(&device_tree.rwlock);
    345                 async_answer_0(iid, ENOENT);
     345                async_answer_0(icall_handle, ENOENT);
    346346                return;
    347347        }
    … …  
    349349        if (dev->pfun == NULL) {
    350350                fibril_rwlock_read_unlock(&device_tree.rwlock);
    351                 async_answer_0(iid, ENOENT);
    352                 return;
    353         }
    354 
    355         async_answer_1(iid, EOK, dev->pfun->handle);
    356 
    357         fibril_rwlock_read_unlock(&device_tree.rwlock);
    358 }
    359 
    360 static void devman_dev_get_functions(cap_call_handle_t iid, ipc_call_t *icall)
    361 {
    362         cap_call_handle_t callid;
     351                async_answer_0(icall_handle, ENOENT);
     352                return;
     353        }
     354
     355        async_answer_1(icall_handle, EOK, dev->pfun->handle);
     356
     357        fibril_rwlock_read_unlock(&device_tree.rwlock);
     358}
     359
     360static void devman_dev_get_functions(cap_call_handle_t icall_handle, ipc_call_t *icall)
     361{
     362        cap_call_handle_t chandle;
    363363        size_t size;
    364364        size_t act_size;
    365365        errno_t rc;
    366366
    367         if (!async_data_read_receive(&callid, &size)) {
    368                 async_answer_0(callid, EREFUSED);
    369                 async_answer_0(iid, EREFUSED);
     367        if (!async_data_read_receive(&chandle, &size)) {
     368                async_answer_0(chandle, EREFUSED);
     369                async_answer_0(icall_handle, EREFUSED);
    370370                return;
    371371        }
    … …  
    377377        if (dev == NULL || dev->state == DEVICE_REMOVED) {
    378378                fibril_rwlock_read_unlock(&device_tree.rwlock);
    379                 async_answer_0(callid, ENOENT);
    380                 async_answer_0(iid, ENOENT);
     379                async_answer_0(chandle, ENOENT);
     380                async_answer_0(icall_handle, ENOENT);
    381381                return;
    382382        }
    … …  
    385385        if (hdl_buf == NULL) {
    386386                fibril_rwlock_read_unlock(&device_tree.rwlock);
    387                 async_answer_0(callid, ENOMEM);
    388                 async_answer_0(iid, ENOMEM);
     387                async_answer_0(chandle, ENOMEM);
     388                async_answer_0(icall_handle, ENOMEM);
    389389                return;
    390390        }
    … …  
    393393        if (rc != EOK) {
    394394                fibril_rwlock_read_unlock(&device_tree.rwlock);
    395                 async_answer_0(callid, rc);
    396                 async_answer_0(iid, rc);
    397                 return;
    398         }
    399 
    400         fibril_rwlock_read_unlock(&device_tree.rwlock);
    401 
    402         errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
     395                async_answer_0(chandle, rc);
     396                async_answer_0(icall_handle, rc);
     397                return;
     398        }
     399
     400        fibril_rwlock_read_unlock(&device_tree.rwlock);
     401
     402        errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
    403403        free(hdl_buf);
    404404
    405         async_answer_1(iid, retval, act_size);
     405        async_answer_1(icall_handle, retval, act_size);
    406406}
    407407
    408408/** Get handle for child device of a function. */
    409 static void devman_fun_get_child(cap_call_handle_t iid, ipc_call_t *icall)
     409static void devman_fun_get_child(cap_call_handle_t icall_handle, ipc_call_t *icall)
    410410{
    411411        fun_node_t *fun;
    … …  
    416416        if (fun == NULL || fun->state == FUN_REMOVED) {
    417417                fibril_rwlock_read_unlock(&device_tree.rwlock);
    418                 async_answer_0(iid, ENOENT);
     418                async_answer_0(icall_handle, ENOENT);
    419419                return;
    420420        }
    … …  
    422422        if (fun->child == NULL) {
    423423                fibril_rwlock_read_unlock(&device_tree.rwlock);
    424                 async_answer_0(iid, ENOENT);
    425                 return;
    426         }
    427 
    428         async_answer_1(iid, EOK, fun->child->handle);
     424                async_answer_0(icall_handle, ENOENT);
     425                return;
     426        }
     427
     428        async_answer_1(icall_handle, EOK, fun->child->handle);
    429429
    430430        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    437437 * of this function is linked to state of another function somehow).
    438438 */
    439 static void devman_fun_online(cap_call_handle_t iid, ipc_call_t *icall)
     439static void devman_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall)
    440440{
    441441        fun_node_t *fun;
    … …  
    444444        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    445445        if (fun == NULL) {
    446                 async_answer_0(iid, ENOENT);
     446                async_answer_0(icall_handle, ENOENT);
    447447                return;
    448448        }
    … …  
    451451        fun_del_ref(fun);
    452452
    453         async_answer_0(iid, rc);
     453        async_answer_0(icall_handle, rc);
    454454}
    455455
    … …  
    462462 * function somehow).
    463463 */
    464 static void devman_fun_offline(cap_call_handle_t iid, ipc_call_t *icall)
     464static void devman_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall)
    465465{
    466466        fun_node_t *fun;
    … …  
    469469        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    470470        if (fun == NULL) {
    471                 async_answer_0(iid, ENOENT);
     471                async_answer_0(icall_handle, ENOENT);
    472472                return;
    473473        }
    … …  
    476476        fun_del_ref(fun);
    477477
    478         async_answer_0(iid, rc);
     478        async_answer_0(icall_handle, rc);
    479479}
    480480
    481481/** Find handle for the function instance identified by its service ID. */
    482 static void devman_fun_sid_to_handle(cap_call_handle_t iid, ipc_call_t *icall)
     482static void devman_fun_sid_to_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
    483483{
    484484        fun_node_t *fun;
    … …  
    487487
    488488        if (fun == NULL) {
    489                 async_answer_0(iid, ENOENT);
     489                async_answer_0(icall_handle, ENOENT);
    490490                return;
    491491        }
    … …  
    496496        if (fun->state == FUN_REMOVED) {
    497497                fibril_rwlock_read_unlock(&device_tree.rwlock);
    498                 async_answer_0(iid, ENOENT);
    499                 return;
    500         }
    501 
    502         async_answer_1(iid, EOK, fun->handle);
     498                async_answer_0(icall_handle, ENOENT);
     499                return;
     500        }
     501
     502        async_answer_1(icall_handle, EOK, fun->handle);
    503503        fibril_rwlock_read_unlock(&device_tree.rwlock);
    504504        fun_del_ref(fun);
    … …  
    506506
    507507/** Get list of all registered drivers. */
    508 static void devman_get_drivers(cap_call_handle_t iid, ipc_call_t *icall)
    509 {
    510         cap_call_handle_t callid;
     508static void devman_get_drivers(cap_call_handle_t icall_handle, ipc_call_t *icall)
     509{
     510        cap_call_handle_t chandle;
    511511        size_t size;
    512512        size_t act_size;
    513513        errno_t rc;
    514514
    515         if (!async_data_read_receive(&callid, &size)) {
    516                 async_answer_0(iid, EREFUSED);
     515        if (!async_data_read_receive(&chandle, &size)) {
     516                async_answer_0(icall_handle, EREFUSED);
    517517                return;
    518518        }
    … …  
    520520        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
    521521        if (hdl_buf == NULL) {
    522                 async_answer_0(callid, ENOMEM);
    523                 async_answer_0(iid, ENOMEM);
     522                async_answer_0(chandle, ENOMEM);
     523                async_answer_0(icall_handle, ENOMEM);
    524524                return;
    525525        }
    … …  
    527527        rc = driver_get_list(&drivers_list, hdl_buf, size, &act_size);
    528528        if (rc != EOK) {
    529                 async_answer_0(callid, rc);
    530                 async_answer_0(iid, rc);
    531                 return;
    532         }
    533 
    534         errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
     529                async_answer_0(chandle, rc);
     530                async_answer_0(icall_handle, rc);
     531                return;
     532        }
     533
     534        errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
    535535        free(hdl_buf);
    536536
    537         async_answer_1(iid, retval, act_size);
    538 }
    539 
    540 static void devman_driver_get_devices(cap_call_handle_t iid, ipc_call_t *icall)
    541 {
    542         cap_call_handle_t callid;
     537        async_answer_1(icall_handle, retval, act_size);
     538}
     539
     540static void devman_driver_get_devices(cap_call_handle_t icall_handle, ipc_call_t *icall)
     541{
     542        cap_call_handle_t chandle;
    543543        size_t size;
    544544        size_t act_size;
    545545        errno_t rc;
    546546
    547         if (!async_data_read_receive(&callid, &size)) {
    548                 async_answer_0(iid, EREFUSED);
     547        if (!async_data_read_receive(&chandle, &size)) {
     548                async_answer_0(icall_handle, EREFUSED);
    549549                return;
    550550        }
    … …  
    552552        driver_t *drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    553553        if (drv == NULL) {
    554                 async_answer_0(callid, ENOENT);
    555                 async_answer_0(iid, ENOENT);
     554                async_answer_0(chandle, ENOENT);
     555                async_answer_0(icall_handle, ENOENT);
    556556                return;
    557557        }
    … …  
    559559        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
    560560        if (hdl_buf == NULL) {
    561                 async_answer_0(callid, ENOMEM);
    562                 async_answer_0(iid, ENOMEM);
     561                async_answer_0(chandle, ENOMEM);
     562                async_answer_0(icall_handle, ENOMEM);
    563563                return;
    564564        }
    … …  
    567567        if (rc != EOK) {
    568568                fibril_rwlock_read_unlock(&device_tree.rwlock);
    569                 async_answer_0(callid, rc);
    570                 async_answer_0(iid, rc);
    571                 return;
    572         }
    573 
    574         errno_t retval = async_data_read_finalize(callid, hdl_buf, size);
     569                async_answer_0(chandle, rc);
     570                async_answer_0(icall_handle, rc);
     571                return;
     572        }
     573
     574        errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
    575575        free(hdl_buf);
    576576
    577         async_answer_1(iid, retval, act_size);
     577        async_answer_1(icall_handle, retval, act_size);
    578578}
    579579
    580580
    581581/** Find driver by name. */
    582 static void devman_driver_get_handle(cap_call_handle_t iid, ipc_call_t *icall)
     582static void devman_driver_get_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
    583583{
    584584        char *drvname;
    … …  
    586586        errno_t rc = async_data_write_accept((void **) &drvname, true, 0, 0, 0, 0);
    587587        if (rc != EOK) {
    588                 async_answer_0(iid, rc);
     588                async_answer_0(icall_handle, rc);
    589589                return;
    590590        }
    … …  
    595595
    596596        if (driver == NULL) {
    597                 async_answer_0(iid, ENOENT);
    598                 return;
    599         }
    600 
    601         async_answer_1(iid, EOK, driver->handle);
     597                async_answer_0(icall_handle, ENOENT);
     598                return;
     599        }
     600
     601        async_answer_1(icall_handle, EOK, driver->handle);
    602602}
    603603
    604604/** Get driver match ID. */
    605 static void devman_driver_get_match_id(cap_call_handle_t iid, ipc_call_t *icall)
     605static void devman_driver_get_match_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
    606606{
    607607        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    610610        driver_t *drv = driver_find(&drivers_list, handle);
    611611        if (drv == NULL) {
    612                 async_answer_0(iid, ENOMEM);
    613                 return;
    614         }
    615 
    616         cap_call_handle_t data_callid;
     612                async_answer_0(icall_handle, ENOMEM);
     613                return;
     614        }
     615
     616        cap_call_handle_t data_chandle;
    617617        size_t data_len;
    618         if (!async_data_read_receive(&data_callid, &data_len)) {
    619                 async_answer_0(iid, EINVAL);
     618        if (!async_data_read_receive(&data_chandle, &data_len)) {
     619                async_answer_0(icall_handle, EINVAL);
    620620                return;
    621621        }
    … …  
    623623        void *buffer = malloc(data_len);
    624624        if (buffer == NULL) {
    625                 async_answer_0(data_callid, ENOMEM);
    626                 async_answer_0(iid, ENOMEM);
     625                async_answer_0(data_chandle, ENOMEM);
     626                async_answer_0(icall_handle, ENOMEM);
    627627                return;
    628628        }
    … …  
    633633                fibril_mutex_unlock(&drv->driver_mutex);
    634634                free(buffer);
    635                 async_answer_0(data_callid, ENOMEM);
    636                 async_answer_0(iid, ENOMEM);
     635                async_answer_0(data_chandle, ENOMEM);
     636                async_answer_0(icall_handle, ENOMEM);
    637637                return;
    638638        }
    … …  
    645645        }
    646646
    647         async_data_read_finalize(data_callid, mid->id, sent_length);
    648         async_answer_1(iid, EOK, mid->score);
     647        async_data_read_finalize(data_chandle, mid->id, sent_length);
     648        async_answer_1(icall_handle, EOK, mid->score);
    649649
    650650        fibril_mutex_unlock(&drv->driver_mutex);
    … …  
    654654
    655655/** Get driver name. */
    656 static void devman_driver_get_name(cap_call_handle_t iid, ipc_call_t *icall)
     656static void devman_driver_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
    657657{
    658658        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    660660        driver_t *drv = driver_find(&drivers_list, handle);
    661661        if (drv == NULL) {
    662                 async_answer_0(iid, ENOMEM);
    663                 return;
    664         }
    665 
    666         cap_call_handle_t data_callid;
     662                async_answer_0(icall_handle, ENOMEM);
     663                return;
     664        }
     665
     666        cap_call_handle_t data_chandle;
    667667        size_t data_len;
    668         if (!async_data_read_receive(&data_callid, &data_len)) {
    669                 async_answer_0(iid, EINVAL);
     668        if (!async_data_read_receive(&data_chandle, &data_len)) {
     669                async_answer_0(icall_handle, EINVAL);
    670670                return;
    671671        }
    … …  
    673673        void *buffer = malloc(data_len);
    674674        if (buffer == NULL) {
    675                 async_answer_0(data_callid, ENOMEM);
    676                 async_answer_0(iid, ENOMEM);
     675                async_answer_0(data_chandle, ENOMEM);
     676                async_answer_0(icall_handle, ENOMEM);
    677677                return;
    678678        }
    … …  
    685685        }
    686686
    687         async_data_read_finalize(data_callid, drv->name, sent_length);
    688         async_answer_0(iid, EOK);
     687        async_data_read_finalize(data_chandle, drv->name, sent_length);
     688        async_answer_0(icall_handle, EOK);
    689689
    690690        fibril_mutex_unlock(&drv->driver_mutex);
    … …  
    694694
    695695/** Get driver state. */
    696 static void devman_driver_get_state(cap_call_handle_t iid, ipc_call_t *icall)
     696static void devman_driver_get_state(cap_call_handle_t icall_handle, ipc_call_t *icall)
    697697{
    698698        driver_t *drv;
    … …  
    700700        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    701701        if (drv == NULL) {
    702                 async_answer_0(iid, ENOENT);
    703                 return;
    704         }
    705 
    706         async_answer_1(iid, EOK, (sysarg_t) drv->state);
     702                async_answer_0(icall_handle, ENOENT);
     703                return;
     704        }
     705
     706        async_answer_1(icall_handle, EOK, (sysarg_t) drv->state);
    707707}
    708708
    709709/** Forcibly load a driver. */
    710 static void devman_driver_load(cap_call_handle_t iid, ipc_call_t *icall)
     710static void devman_driver_load(cap_call_handle_t icall_handle, ipc_call_t *icall)
    711711{
    712712        driver_t *drv;
    … …  
    715715        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    716716        if (drv == NULL) {
    717                 async_answer_0(iid, ENOENT);
     717                async_answer_0(icall_handle, ENOENT);
    718718                return;
    719719        }
    … …  
    723723        fibril_mutex_unlock(&drv->driver_mutex);
    724724
    725         async_answer_0(iid, rc);
     725        async_answer_0(icall_handle, rc);
    726726}
    727727
    728728/** Unload a driver by user request. */
    729 static void devman_driver_unload(cap_call_handle_t iid, ipc_call_t *icall)
     729static void devman_driver_unload(cap_call_handle_t icall_handle, ipc_call_t *icall)
    730730{
    731731        driver_t *drv;
    … …  
    734734        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    735735        if (drv == NULL) {
    736                 async_answer_0(iid, ENOENT);
     736                async_answer_0(icall_handle, ENOENT);
    737737                return;
    738738        }
    … …  
    742742        fibril_mutex_unlock(&drv->driver_mutex);
    743743
    744         async_answer_0(iid, rc);
     744        async_answer_0(icall_handle, rc);
    745745}
    746746
    747747/** Function for handling connections from a client to the device manager. */
    748 void devman_connection_client(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     748void devman_connection_client(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    749749{
    750750        /* Accept connection. */
    751         async_answer_0(iid, EOK);
     751        async_answer_0(icall_handle, EOK);
    752752
    753753        while (true) {
    754754                ipc_call_t call;
    755                 cap_call_handle_t callid = async_get_call(&call);
     755                cap_call_handle_t chandle = async_get_call(&call);
    756756
    757757                if (!IPC_GET_IMETHOD(call))
    … …  
    760760                switch (IPC_GET_IMETHOD(call)) {
    761761                case DEVMAN_DEVICE_GET_HANDLE:
    762                         devman_function_get_handle(callid, &call);
     762                        devman_function_get_handle(chandle, &call);
    763763                        break;
    764764                case DEVMAN_DEV_GET_PARENT:
    765                         devman_dev_get_parent(callid, &call);
     765                        devman_dev_get_parent(chandle, &call);
    766766                        break;
    767767                case DEVMAN_DEV_GET_FUNCTIONS:
    768                         devman_dev_get_functions(callid, &call);
     768                        devman_dev_get_functions(chandle, &call);
    769769                        break;
    770770                case DEVMAN_FUN_GET_CHILD:
    771                         devman_fun_get_child(callid, &call);
     771                        devman_fun_get_child(chandle, &call);
    772772                        break;
    773773                case DEVMAN_FUN_GET_MATCH_ID:
    774                         devman_fun_get_match_id(callid, &call);
     774                        devman_fun_get_match_id(chandle, &call);
    775775                        break;
    776776                case DEVMAN_FUN_GET_NAME:
    777                         devman_fun_get_name(callid, &call);
     777                        devman_fun_get_name(chandle, &call);
    778778                        break;
    779779                case DEVMAN_FUN_GET_DRIVER_NAME:
    780                         devman_fun_get_driver_name(callid, &call);
     780                        devman_fun_get_driver_name(chandle, &call);
    781781                        break;
    782782                case DEVMAN_FUN_GET_PATH:
    783                         devman_fun_get_path(callid, &call);
     783                        devman_fun_get_path(chandle, &call);
    784784                        break;
    785785                case DEVMAN_FUN_ONLINE:
    786                         devman_fun_online(callid, &call);
     786                        devman_fun_online(chandle, &call);
    787787                        break;
    788788                case DEVMAN_FUN_OFFLINE:
    789                         devman_fun_offline(callid, &call);
     789                        devman_fun_offline(chandle, &call);
    790790                        break;
    791791                case DEVMAN_FUN_SID_TO_HANDLE:
    792                         devman_fun_sid_to_handle(callid, &call);
     792                        devman_fun_sid_to_handle(chandle, &call);
    793793                        break;
    794794                case DEVMAN_GET_DRIVERS:
    795                         devman_get_drivers(callid, &call);
     795                        devman_get_drivers(chandle, &call);
    796796                        break;
    797797                case DEVMAN_DRIVER_GET_DEVICES:
    798                         devman_driver_get_devices(callid, &call);
     798                        devman_driver_get_devices(chandle, &call);
    799799                        break;
    800800                case DEVMAN_DRIVER_GET_HANDLE:
    801                         devman_driver_get_handle(callid, &call);
     801                        devman_driver_get_handle(chandle, &call);
    802802                        break;
    803803                case DEVMAN_DRIVER_GET_MATCH_ID:
    804                         devman_driver_get_match_id(callid, &call);
     804                        devman_driver_get_match_id(chandle, &call);
    805805                        break;
    806806                case DEVMAN_DRIVER_GET_NAME:
    807                         devman_driver_get_name(callid, &call);
     807                        devman_driver_get_name(chandle, &call);
    808808                        break;
    809809                case DEVMAN_DRIVER_GET_STATE:
    810                         devman_driver_get_state(callid, &call);
     810                        devman_driver_get_state(chandle, &call);
    811811                        break;
    812812                case DEVMAN_DRIVER_LOAD:
    813                         devman_driver_load(callid, &call);
     813                        devman_driver_load(chandle, &call);
    814814                        break;
    815815                case DEVMAN_DRIVER_UNLOAD:
    816                         devman_driver_unload(callid, &call);
     816                        devman_driver_unload(chandle, &call);
    817817                        break;
    818818                default:
    819                         async_answer_0(callid, ENOENT);
     819                        async_answer_0(chandle, ENOENT);
    820820                }
    821821        }
Note: See TracChangeset for help on using the changeset viewer.