Changeset a46e56b in mainline for uspace/srv/devman


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

Location:
uspace/srv/devman
Files:
3 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        }

  • uspace/srv/devman/drv_conn.c

    r3e242d2 ra46e56b  
    6464
    6565/** Register running driver. */
    66 static driver_t *devman_driver_register(cap_call_handle_t callid, ipc_call_t *call)
     66static driver_t *devman_driver_register(cap_call_handle_t chandle, ipc_call_t *call)
    6767{
    6868        driver_t *driver = NULL;
    … …  
    7474        errno_t rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
    7575        if (rc != EOK) {
    76                 async_answer_0(callid, rc);
     76                async_answer_0(chandle, rc);
    7777                return NULL;
    7878        }
    … …  
    8787                free(drv_name);
    8888                drv_name = NULL;
    89                 async_answer_0(callid, ENOENT);
     89                async_answer_0(chandle, ENOENT);
    9090                return NULL;
    9191        }
    … …  
    101101                    driver->name);
    102102                fibril_mutex_unlock(&driver->driver_mutex);
    103                 async_answer_0(callid, EEXIST);
     103                async_answer_0(chandle, EEXIST);
    104104                return NULL;
    105105        }
    … …  
    126126        if (!driver->sess) {
    127127                fibril_mutex_unlock(&driver->driver_mutex);
    128                 async_answer_0(callid, ENOTSUP);
     128                async_answer_0(chandle, ENOTSUP);
    129129                return NULL;
    130130        }
    … …  
    146146                    "for driver `%s'.", driver->name);
    147147                fibril_mutex_unlock(&driver->driver_mutex);
    148                 async_answer_0(callid, ENOMEM);
     148                async_answer_0(chandle, ENOMEM);
    149149                return NULL;
    150150        }
    … …  
    153153        fibril_mutex_unlock(&driver->driver_mutex);
    154154
    155         async_answer_0(callid, EOK);
     155        async_answer_0(chandle, EOK);
    156156        return driver;
    157157}
    … …  
    166166{
    167167        match_id_t *match_id = create_match_id();
    168         cap_call_handle_t callid;
     168        cap_call_handle_t chandle;
    169169        ipc_call_t call;
    170170        errno_t rc = 0;
    171171
    172         callid = async_get_call(&call);
     172        chandle = async_get_call(&call);
    173173        if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    174174                log_msg(LOG_DEFAULT, LVL_ERROR,
    175175                    "Invalid protocol when trying to receive match id.");
    176                 async_answer_0(callid, EINVAL);
     176                async_answer_0(chandle, EINVAL);
    177177                delete_match_id(match_id);
    178178                return EINVAL;
    … …  
    181181        if (match_id == NULL) {
    182182                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate match id.");
    183                 async_answer_0(callid, ENOMEM);
     183                async_answer_0(chandle, ENOMEM);
    184184                return ENOMEM;
    185185        }
    186186
    187         async_answer_0(callid, EOK);
     187        async_answer_0(chandle, EOK);
    188188
    189189        match_id->score = IPC_GET_ARG1(call);
    … …  
    230230 * Child devices are registered by their parent's device driver.
    231231 */
    232 static void devman_add_function(cap_call_handle_t callid, ipc_call_t *call)
     232static void devman_add_function(cap_call_handle_t chandle, ipc_call_t *call)
    233233{
    234234        fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
    … …  
    239239        dev_node_t *pdev = find_dev_node(&device_tree, dev_handle);
    240240        if (pdev == NULL) {
    241                 async_answer_0(callid, ENOENT);
     241                async_answer_0(chandle, ENOENT);
    242242                return;
    243243        }
    … …  
    250250
    251251                dev_del_ref(pdev);
    252                 async_answer_0(callid, EINVAL);
     252                async_answer_0(chandle, EINVAL);
    253253                return;
    254254        }
    … …  
    258258        if (rc != EOK) {
    259259                dev_del_ref(pdev);
    260                 async_answer_0(callid, rc);
     260                async_answer_0(chandle, rc);
    261261                return;
    262262        }
    … …  
    268268                fibril_rwlock_write_unlock(&tree->rwlock);
    269269                dev_del_ref(pdev);
    270                 async_answer_0(callid, ENOENT);
     270                async_answer_0(chandle, ENOENT);
    271271                return;
    272272        }
    … …  
    278278                fibril_rwlock_write_unlock(&tree->rwlock);
    279279                dev_del_ref(pdev);
    280                 async_answer_0(callid, EEXIST);
     280                async_answer_0(chandle, EEXIST);
    281281                printf(NAME ": Warning, driver tried to register `%s' twice.\n",
    282282                    fun_name);
    … …  
    303303                fun_del_ref(fun);
    304304                delete_fun_node(fun);
    305                 async_answer_0(callid, ENOMEM);
     305                async_answer_0(chandle, ENOMEM);
    306306                return;
    307307        }
    … …  
    317317                fun_busy_unlock(fun);
    318318                fun_del_ref(fun);
    319                 async_answer_0(callid, rc);
     319                async_answer_0(chandle, rc);
    320320                return;
    321321        }
    … …  
    325325
    326326        /* Return device handle to parent's driver. */
    327         async_answer_1(callid, EOK, fun->handle);
    328 }
    329 
    330 static void devman_add_function_to_cat(cap_call_handle_t callid, ipc_call_t *call)
     327        async_answer_1(chandle, EOK, fun->handle);
     328}
     329
     330static void devman_add_function_to_cat(cap_call_handle_t chandle, ipc_call_t *call)
    331331{
    332332        devman_handle_t handle = IPC_GET_ARG1(*call);
    … …  
    339339            0, 0, 0, 0);
    340340        if (rc != EOK) {
    341                 async_answer_0(callid, rc);
     341                async_answer_0(chandle, rc);
    342342                return;
    343343        }
    … …  
    345345        fun_node_t *fun = find_fun_node(&device_tree, handle);
    346346        if (fun == NULL) {
    347                 async_answer_0(callid, ENOENT);
     347                async_answer_0(chandle, ENOENT);
    348348                return;
    349349        }
    … …  
    354354        if (fun->state == FUN_REMOVED) {
    355355                fibril_rwlock_read_unlock(&device_tree.rwlock);
    356                 async_answer_0(callid, ENOENT);
     356                async_answer_0(chandle, ENOENT);
    357357                return;
    358358        }
    … …  
    371371        fun_del_ref(fun);
    372372
    373         async_answer_0(callid, rc);
     373        async_answer_0(chandle, rc);
    374374}
    375375
    … …  
    377377 *
    378378 */
    379 static void devman_drv_fun_online(cap_call_handle_t iid, ipc_call_t *icall,
     379static void devman_drv_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall,
    380380    driver_t *drv)
    381381{
    … …  
    387387        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    388388        if (fun == NULL) {
    389                 async_answer_0(iid, ENOENT);
     389                async_answer_0(icall_handle, ENOENT);
    390390                return;
    391391        }
    … …  
    398398                fun_busy_unlock(fun);
    399399                fun_del_ref(fun);
    400                 async_answer_0(iid, ENOENT);
     400                async_answer_0(icall_handle, ENOENT);
    401401                return;
    402402        }
    … …  
    407407                fun_busy_unlock(fun);
    408408                fun_del_ref(fun);
    409                 async_answer_0(iid, rc);
     409                async_answer_0(icall_handle, rc);
    410410                return;
    411411        }
    … …  
    414414        fun_del_ref(fun);
    415415
    416         async_answer_0(iid, EOK);
     416        async_answer_0(icall_handle, EOK);
    417417}
    418418
    … …  
    421421 *
    422422 */
    423 static void devman_drv_fun_offline(cap_call_handle_t iid, ipc_call_t *icall,
     423static void devman_drv_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall,
    424424    driver_t *drv)
    425425{
    … …  
    429429        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    430430        if (fun == NULL) {
    431                 async_answer_0(iid, ENOENT);
     431                async_answer_0(icall_handle, ENOENT);
    432432                return;
    433433        }
    … …  
    439439                fun_busy_unlock(fun);
    440440                fun_del_ref(fun);
    441                 async_answer_0(iid, ENOENT);
     441                async_answer_0(icall_handle, ENOENT);
    442442                return;
    443443        }
    … …  
    448448                fun_busy_unlock(fun);
    449449                fun_del_ref(fun);
    450                 async_answer_0(iid, rc);
     450                async_answer_0(icall_handle, rc);
    451451                return;
    452452        }
    … …  
    454454        fun_busy_unlock(fun);
    455455        fun_del_ref(fun);
    456         async_answer_0(iid, EOK);
     456        async_answer_0(icall_handle, EOK);
    457457}
    458458
    459459/** Remove function. */
    460 static void devman_remove_function(cap_call_handle_t callid, ipc_call_t *call)
     460static void devman_remove_function(cap_call_handle_t chandle, ipc_call_t *call)
    461461{
    462462        devman_handle_t fun_handle = IPC_GET_ARG1(*call);
    … …  
    466466        fun_node_t *fun = find_fun_node(&device_tree, fun_handle);
    467467        if (fun == NULL) {
    468                 async_answer_0(callid, ENOENT);
     468                async_answer_0(chandle, ENOENT);
    469469                return;
    470470        }
    … …  
    481481                fun_busy_unlock(fun);
    482482                fun_del_ref(fun);
    483                 async_answer_0(callid, ENOENT);
     483                async_answer_0(chandle, ENOENT);
    484484                return;
    485485        }
    … …  
    523523                                fun_busy_unlock(fun);
    524524                                fun_del_ref(fun);
    525                                 async_answer_0(callid, gone_rc);
     525                                async_answer_0(chandle, gone_rc);
    526526                                return;
    527527                        }
    … …  
    551551                                fun_busy_unlock(fun);
    552552                                fun_del_ref(fun);
    553                                 async_answer_0(callid, EIO);
     553                                async_answer_0(chandle, EIO);
    554554                                return;
    555555                        }
    … …  
    567567
    568568        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function() succeeded.");
    569         async_answer_0(callid, EOK);
     569        async_answer_0(chandle, EOK);
    570570}
    571571
    … …  
    586586
    587587/** Function for handling connections from a driver to the device manager. */
    588 void devman_connection_driver(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     588void devman_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    589589{
    590590        client_t *client;
    … …  
    592592
    593593        /* Accept the connection. */
    594         async_answer_0(iid, EOK);
     594        async_answer_0(icall_handle, EOK);
    595595
    596596        client = async_get_client_data();
    … …  
    602602        while (true) {
    603603                ipc_call_t call;
    604                 cap_call_handle_t callid = async_get_call(&call);
     604                cap_call_handle_t chandle = async_get_call(&call);
    605605
    606606                if (!IPC_GET_IMETHOD(call))
    … …  
    613613                        if (driver == NULL) {
    614614                                /* First call must be to DEVMAN_DRIVER_REGISTER */
    615                                 async_answer_0(callid, ENOTSUP);
     615                                async_answer_0(chandle, ENOTSUP);
    616616                                continue;
    617617                        }
    … …  
    623623                        if (client->driver != NULL) {
    624624                                fibril_mutex_unlock(&client->mutex);
    625                                 async_answer_0(callid, EINVAL);
     625                                async_answer_0(chandle, EINVAL);
    626626                                continue;
    627627                        }
    628                         client->driver = devman_driver_register(callid, &call);
     628                        client->driver = devman_driver_register(chandle, &call);
    629629                        fibril_mutex_unlock(&client->mutex);
    630630                        break;
    631631                case DEVMAN_ADD_FUNCTION:
    632                         devman_add_function(callid, &call);
     632                        devman_add_function(chandle, &call);
    633633                        break;
    634634                case DEVMAN_ADD_DEVICE_TO_CATEGORY:
    635                         devman_add_function_to_cat(callid, &call);
     635                        devman_add_function_to_cat(chandle, &call);
    636636                        break;
    637637                case DEVMAN_DRV_FUN_ONLINE:
    638                         devman_drv_fun_online(callid, &call, driver);
     638                        devman_drv_fun_online(chandle, &call, driver);
    639639                        break;
    640640                case DEVMAN_DRV_FUN_OFFLINE:
    641                         devman_drv_fun_offline(callid, &call, driver);
     641                        devman_drv_fun_offline(chandle, &call, driver);
    642642                        break;
    643643                case DEVMAN_REMOVE_FUNCTION:
    644                         devman_remove_function(callid, &call);
     644                        devman_remove_function(chandle, &call);
    645645                        break;
    646646                default:
    647                         async_answer_0(callid, EINVAL);
     647                        async_answer_0(chandle, EINVAL);
    648648                        break;
    649649                }

  • uspace/srv/devman/main.c

    r3e242d2 ra46e56b  
    6666dev_tree_t device_tree;
    6767
    68 static void devman_connection_device(cap_call_handle_t iid, ipc_call_t *icall,
     68static void devman_connection_device(cap_call_handle_t icall_handle, ipc_call_t *icall,
    6969    void *arg)
    7070{
    … …  
    9494                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
    9595                    "function with handle %" PRIun " was found.", handle);
    96                 async_answer_0(iid, ENOENT);
     96                async_answer_0(icall_handle, ENOENT);
    9797                goto cleanup;
    9898        }
    … …  
    102102                    "connect to handle %" PRIun ", refers to a device.",
    103103                    handle);
    104                 async_answer_0(iid, ENOENT);
     104                async_answer_0(icall_handle, ENOENT);
    105105                goto cleanup;
    106106        }
    … …  
    116116                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - "
    117117                    "the device %" PRIun " is not in usable state.", handle);
    118                 async_answer_0(iid, ENOENT);
     118                async_answer_0(icall_handle, ENOENT);
    119119                goto cleanup;
    120120        }
    … …  
    123123                log_msg(LOG_DEFAULT, LVL_ERROR,
    124124                    "Could not forward to driver `%s'.", driver->name);
    125                 async_answer_0(iid, EINVAL);
     125                async_answer_0(icall_handle, EINVAL);
    126126                goto cleanup;
    127127        }
    … …  
    138138
    139139        async_exch_t *exch = async_exchange_begin(driver->sess);
    140         async_forward_fast(iid, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
     140        async_forward_fast(icall_handle, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
    141141        async_exchange_end(exch);
    142142
    … …  
    149149}
    150150
    151 static void devman_connection_parent(cap_call_handle_t iid, ipc_call_t *icall,
     151static void devman_connection_parent(cap_call_handle_t icall_handle, ipc_call_t *icall,
    152152    void *arg)
    153153{
    … …  
    177177                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
    178178                    "function with handle %" PRIun " was found.", handle);
    179                 async_answer_0(iid, ENOENT);
     179                async_answer_0(icall_handle, ENOENT);
    180180                goto cleanup;
    181181        }
    … …  
    196196                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - "
    197197                    "the device %" PRIun " is not in usable state.", handle);
    198                 async_answer_0(iid, ENOENT);
     198                async_answer_0(icall_handle, ENOENT);
    199199                goto cleanup;
    200200        }
    … …  
    203203                log_msg(LOG_DEFAULT, LVL_ERROR,
    204204                    "Could not forward to driver `%s'.", driver->name);
    205                 async_answer_0(iid, EINVAL);
     205                async_answer_0(icall_handle, EINVAL);
    206206                goto cleanup;
    207207        }
    … …  
    218218
    219219        async_exch_t *exch = async_exchange_begin(driver->sess);
    220         async_forward_fast(iid, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
     220        async_forward_fast(icall_handle, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
    221221        async_exchange_end(exch);
    222222
    … …  
    229229}
    230230
    231 static void devman_forward(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     231static void devman_forward(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    232232{
    233233        iface_t iface = IPC_GET_ARG1(*icall);
    … …  
    242242                    "not found.\n");
    243243                fibril_rwlock_read_unlock(&device_tree.rwlock);
    244                 async_answer_0(iid, ENOENT);
     244                async_answer_0(icall_handle, ENOENT);
    245245                return;
    246246        }
    … …  
    253253
    254254        async_exch_t *exch = async_exchange_begin(driver->sess);
    255         async_forward_fast(iid, exch, iface, handle, 0, IPC_FF_NONE);
     255        async_forward_fast(icall_handle, exch, iface, handle, 0, IPC_FF_NONE);
    256256        async_exchange_end(exch);
    257257
Note: See TracChangeset for help on using the changeset viewer.