Changeset 984a9ba in mainline for uspace/srv/devman


Ignore:
Timestamp:
2018-07-05T09:34:09Z (7 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

Location:
uspace/srv/devman
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/client_conn.c

    r76f566d r984a9ba  
    6262 * device tree.
    6363 */
    64 static void devman_function_get_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
     64static void devman_function_get_handle(ipc_call_t *icall)
    6565{
    6666        char *pathname;
    … …  
    6969        errno_t rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0);
    7070        if (rc != EOK) {
    71                 async_answer_0(icall_handle, rc);
     71                async_answer_0(icall, rc);
    7272                return;
    7373        }
    … …  
    7878
    7979        if (fun == NULL) {
    80                 async_answer_0(icall_handle, ENOENT);
     80                async_answer_0(icall, ENOENT);
    8181                return;
    8282        }
    … …  
    8787        if (fun->state == FUN_REMOVED) {
    8888                fibril_rwlock_read_unlock(&device_tree.rwlock);
    89                 async_answer_0(icall_handle, ENOENT);
     89                async_answer_0(icall, ENOENT);
    9090                return;
    9191        }
    … …  
    9797        fun_del_ref(fun);
    9898
    99         async_answer_1(icall_handle, EOK, handle);
     99        async_answer_1(icall, EOK, handle);
    100100}
    101101
    102102/** Get device match ID. */
    103 static void devman_fun_get_match_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
     103static void devman_fun_get_match_id(ipc_call_t *icall)
    104104{
    105105        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    109109        fun_node_t *fun = find_fun_node(&device_tree, handle);
    110110        if (fun == NULL) {
    111                 async_answer_0(icall_handle, ENOMEM);
    112                 return;
    113         }
    114 
    115         cap_call_handle_t data_chandle;
     111                async_answer_0(icall, ENOMEM);
     112                return;
     113        }
     114
     115        ipc_call_t data;
    116116        size_t data_len;
    117         if (!async_data_read_receive(&data_chandle, &data_len)) {
    118                 async_answer_0(icall_handle, EINVAL);
     117        if (!async_data_read_receive(&data, &data_len)) {
     118                async_answer_0(icall, EINVAL);
    119119                fun_del_ref(fun);
    120120                return;
    … …  
    123123        buffer = malloc(data_len);
    124124        if (buffer == NULL) {
    125                 async_answer_0(data_chandle, ENOMEM);
    126                 async_answer_0(icall_handle, ENOMEM);
     125                async_answer_0(&data, ENOMEM);
     126                async_answer_0(icall, ENOMEM);
    127127                fun_del_ref(fun);
    128128                return;
    … …  
    146146        }
    147147
    148         async_data_read_finalize(data_chandle, mid->id, sent_length);
    149         async_answer_1(icall_handle, EOK, mid->score);
     148        async_data_read_finalize(&data, mid->id, sent_length);
     149        async_answer_1(icall, EOK, mid->score);
    150150
    151151        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    158158        free(buffer);
    159159
    160         async_answer_0(data_chandle, ENOENT);
    161         async_answer_0(icall_handle, ENOENT);
     160        async_answer_0(&data, ENOENT);
     161        async_answer_0(icall, ENOENT);
    162162        fun_del_ref(fun);
    163163}
    164164
    165165/** Get device name. */
    166 static void devman_fun_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
     166static void devman_fun_get_name(ipc_call_t *icall)
    167167{
    168168        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    170170        fun_node_t *fun = find_fun_node(&device_tree, handle);
    171171        if (fun == NULL) {
    172                 async_answer_0(icall_handle, ENOMEM);
    173                 return;
    174         }
    175 
    176         cap_call_handle_t data_chandle;
     172                async_answer_0(icall, ENOMEM);
     173                return;
     174        }
     175
     176        ipc_call_t data;
    177177        size_t data_len;
    178         if (!async_data_read_receive(&data_chandle, &data_len)) {
    179                 async_answer_0(icall_handle, EINVAL);
     178        if (!async_data_read_receive(&data, &data_len)) {
     179                async_answer_0(icall, EINVAL);
    180180                fun_del_ref(fun);
    181181                return;
    … …  
    184184        void *buffer = malloc(data_len);
    185185        if (buffer == NULL) {
    186                 async_answer_0(data_chandle, ENOMEM);
    187                 async_answer_0(icall_handle, ENOMEM);
     186                async_answer_0(&data, ENOMEM);
     187                async_answer_0(icall, ENOMEM);
    188188                fun_del_ref(fun);
    189189                return;
    … …  
    197197                free(buffer);
    198198
    199                 async_answer_0(data_chandle, ENOENT);
    200                 async_answer_0(icall_handle, ENOENT);
     199                async_answer_0(&data, ENOENT);
     200                async_answer_0(icall, ENOENT);
    201201                fun_del_ref(fun);
    202202                return;
    … …  
    208208        }
    209209
    210         async_data_read_finalize(data_chandle, fun->name, sent_length);
    211         async_answer_0(icall_handle, EOK);
     210        async_data_read_finalize(&data, fun->name, sent_length);
     211        async_answer_0(icall, EOK);
    212212
    213213        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    217217
    218218/** Get function driver name. */
    219 static void devman_fun_get_driver_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
     219static void devman_fun_get_driver_name(ipc_call_t *icall)
    220220{
    221221        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    223223        fun_node_t *fun = find_fun_node(&device_tree, handle);
    224224        if (fun == NULL) {
    225                 async_answer_0(icall_handle, ENOMEM);
    226                 return;
    227         }
    228 
    229         cap_call_handle_t data_chandle;
     225                async_answer_0(icall, ENOMEM);
     226                return;
     227        }
     228
     229        ipc_call_t data;
    230230        size_t data_len;
    231         if (!async_data_read_receive(&data_chandle, &data_len)) {
    232                 async_answer_0(icall_handle, EINVAL);
     231        if (!async_data_read_receive(&data, &data_len)) {
     232                async_answer_0(icall, EINVAL);
    233233                fun_del_ref(fun);
    234234                return;
    … …  
    237237        void *buffer = malloc(data_len);
    238238        if (buffer == NULL) {
    239                 async_answer_0(data_chandle, ENOMEM);
    240                 async_answer_0(icall_handle, ENOMEM);
     239                async_answer_0(&data, ENOMEM);
     240                async_answer_0(icall, ENOMEM);
    241241                fun_del_ref(fun);
    242242                return;
    … …  
    250250                free(buffer);
    251251
    252                 async_answer_0(data_chandle, ENOENT);
    253                 async_answer_0(icall_handle, ENOENT);
     252                async_answer_0(&data, ENOENT);
     253                async_answer_0(icall, ENOENT);
    254254                fun_del_ref(fun);
    255255                return;
    … …  
    261261                free(buffer);
    262262
    263                 async_answer_0(data_chandle, EINVAL);
    264                 async_answer_0(icall_handle, EINVAL);
     263                async_answer_0(&data, EINVAL);
     264                async_answer_0(icall, EINVAL);
    265265                fun_del_ref(fun);
    266266                return;
    … …  
    272272        }
    273273
    274         async_data_read_finalize(data_chandle, fun->child->drv->name,
     274        async_data_read_finalize(&data, fun->child->drv->name,
    275275            sent_length);
    276         async_answer_0(icall_handle, EOK);
     276        async_answer_0(icall, EOK);
    277277
    278278        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    282282
    283283/** Get device path. */
    284 static void devman_fun_get_path(cap_call_handle_t icall_handle, ipc_call_t *icall)
     284static void devman_fun_get_path(ipc_call_t *icall)
    285285{
    286286        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    288288        fun_node_t *fun = find_fun_node(&device_tree, handle);
    289289        if (fun == NULL) {
    290                 async_answer_0(icall_handle, ENOMEM);
    291                 return;
    292         }
    293 
    294         cap_call_handle_t data_chandle;
     290                async_answer_0(icall, ENOMEM);
     291                return;
     292        }
     293
     294        ipc_call_t data;
    295295        size_t data_len;
    296         if (!async_data_read_receive(&data_chandle, &data_len)) {
    297                 async_answer_0(icall_handle, EINVAL);
     296        if (!async_data_read_receive(&data, &data_len)) {
     297                async_answer_0(icall, EINVAL);
    298298                fun_del_ref(fun);
    299299                return;
    … …  
    302302        void *buffer = malloc(data_len);
    303303        if (buffer == NULL) {
    304                 async_answer_0(data_chandle, ENOMEM);
    305                 async_answer_0(icall_handle, ENOMEM);
     304                async_answer_0(&data, ENOMEM);
     305                async_answer_0(icall, ENOMEM);
    306306                fun_del_ref(fun);
    307307                return;
    … …  
    315315                free(buffer);
    316316
    317                 async_answer_0(data_chandle, ENOENT);
    318                 async_answer_0(icall_handle, ENOENT);
     317                async_answer_0(&data, ENOENT);
     318                async_answer_0(icall, ENOENT);
    319319                fun_del_ref(fun);
    320320                return;
    … …  
    326326        }
    327327
    328         async_data_read_finalize(data_chandle, fun->pathname, sent_length);
    329         async_answer_0(icall_handle, EOK);
     328        async_data_read_finalize(&data, fun->pathname, sent_length);
     329        async_answer_0(icall, EOK);
    330330
    331331        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    335335
    336336/** Get handle for parent function of a device. */
    337 static void devman_dev_get_parent(cap_call_handle_t icall_handle, ipc_call_t *icall)
     337static void devman_dev_get_parent(ipc_call_t *icall)
    338338{
    339339        dev_node_t *dev;
    … …  
    344344        if (dev == NULL || dev->state == DEVICE_REMOVED) {
    345345                fibril_rwlock_read_unlock(&device_tree.rwlock);
    346                 async_answer_0(icall_handle, ENOENT);
     346                async_answer_0(icall, ENOENT);
    347347                return;
    348348        }
    … …  
    350350        if (dev->pfun == NULL) {
    351351                fibril_rwlock_read_unlock(&device_tree.rwlock);
    352                 async_answer_0(icall_handle, ENOENT);
    353                 return;
    354         }
    355 
    356         async_answer_1(icall_handle, EOK, dev->pfun->handle);
    357 
    358         fibril_rwlock_read_unlock(&device_tree.rwlock);
    359 }
    360 
    361 static void devman_dev_get_functions(cap_call_handle_t icall_handle, ipc_call_t *icall)
    362 {
    363         cap_call_handle_t chandle;
     352                async_answer_0(icall, ENOENT);
     353                return;
     354        }
     355
     356        async_answer_1(icall, EOK, dev->pfun->handle);
     357
     358        fibril_rwlock_read_unlock(&device_tree.rwlock);
     359}
     360
     361static void devman_dev_get_functions(ipc_call_t *icall)
     362{
     363        ipc_call_t call;
    364364        size_t size;
    365365        size_t act_size;
    366366        errno_t rc;
    367367
    368         if (!async_data_read_receive(&chandle, &size)) {
    369                 async_answer_0(chandle, EREFUSED);
    370                 async_answer_0(icall_handle, EREFUSED);
     368        if (!async_data_read_receive(&call, &size)) {
     369                async_answer_0(&call, EREFUSED);
     370                async_answer_0(icall, EREFUSED);
    371371                return;
    372372        }
    … …  
    378378        if (dev == NULL || dev->state == DEVICE_REMOVED) {
    379379                fibril_rwlock_read_unlock(&device_tree.rwlock);
    380                 async_answer_0(chandle, ENOENT);
    381                 async_answer_0(icall_handle, ENOENT);
     380                async_answer_0(&call, ENOENT);
     381                async_answer_0(icall, ENOENT);
    382382                return;
    383383        }
    … …  
    386386        if (hdl_buf == NULL) {
    387387                fibril_rwlock_read_unlock(&device_tree.rwlock);
    388                 async_answer_0(chandle, ENOMEM);
    389                 async_answer_0(icall_handle, ENOMEM);
     388                async_answer_0(&call, ENOMEM);
     389                async_answer_0(icall, ENOMEM);
    390390                return;
    391391        }
    … …  
    394394        if (rc != EOK) {
    395395                fibril_rwlock_read_unlock(&device_tree.rwlock);
    396                 async_answer_0(chandle, rc);
    397                 async_answer_0(icall_handle, rc);
    398                 return;
    399         }
    400 
    401         fibril_rwlock_read_unlock(&device_tree.rwlock);
    402 
    403         errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
     396                async_answer_0(&call, rc);
     397                async_answer_0(icall, rc);
     398                return;
     399        }
     400
     401        fibril_rwlock_read_unlock(&device_tree.rwlock);
     402
     403        errno_t retval = async_data_read_finalize(&call, hdl_buf, size);
    404404        free(hdl_buf);
    405405
    406         async_answer_1(icall_handle, retval, act_size);
     406        async_answer_1(icall, retval, act_size);
    407407}
    408408
    409409/** Get handle for child device of a function. */
    410 static void devman_fun_get_child(cap_call_handle_t icall_handle, ipc_call_t *icall)
     410static void devman_fun_get_child(ipc_call_t *icall)
    411411{
    412412        fun_node_t *fun;
    … …  
    417417        if (fun == NULL || fun->state == FUN_REMOVED) {
    418418                fibril_rwlock_read_unlock(&device_tree.rwlock);
    419                 async_answer_0(icall_handle, ENOENT);
     419                async_answer_0(icall, ENOENT);
    420420                return;
    421421        }
    … …  
    423423        if (fun->child == NULL) {
    424424                fibril_rwlock_read_unlock(&device_tree.rwlock);
    425                 async_answer_0(icall_handle, ENOENT);
    426                 return;
    427         }
    428 
    429         async_answer_1(icall_handle, EOK, fun->child->handle);
     425                async_answer_0(icall, ENOENT);
     426                return;
     427        }
     428
     429        async_answer_1(icall, EOK, fun->child->handle);
    430430
    431431        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    438438 * of this function is linked to state of another function somehow).
    439439 */
    440 static void devman_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall)
     440static void devman_fun_online(ipc_call_t *icall)
    441441{
    442442        fun_node_t *fun;
    … …  
    445445        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    446446        if (fun == NULL) {
    447                 async_answer_0(icall_handle, ENOENT);
     447                async_answer_0(icall, ENOENT);
    448448                return;
    449449        }
    … …  
    452452        fun_del_ref(fun);
    453453
    454         async_answer_0(icall_handle, rc);
     454        async_answer_0(icall, rc);
    455455}
    456456
    … …  
    463463 * function somehow).
    464464 */
    465 static void devman_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall)
     465static void devman_fun_offline(ipc_call_t *icall)
    466466{
    467467        fun_node_t *fun;
    … …  
    470470        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    471471        if (fun == NULL) {
    472                 async_answer_0(icall_handle, ENOENT);
     472                async_answer_0(icall, ENOENT);
    473473                return;
    474474        }
    … …  
    477477        fun_del_ref(fun);
    478478
    479         async_answer_0(icall_handle, rc);
     479        async_answer_0(icall, rc);
    480480}
    481481
    482482/** Find handle for the function instance identified by its service ID. */
    483 static void devman_fun_sid_to_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
     483static void devman_fun_sid_to_handle(ipc_call_t *icall)
    484484{
    485485        fun_node_t *fun;
    … …  
    488488
    489489        if (fun == NULL) {
    490                 async_answer_0(icall_handle, ENOENT);
     490                async_answer_0(icall, ENOENT);
    491491                return;
    492492        }
    … …  
    497497        if (fun->state == FUN_REMOVED) {
    498498                fibril_rwlock_read_unlock(&device_tree.rwlock);
    499                 async_answer_0(icall_handle, ENOENT);
    500                 return;
    501         }
    502 
    503         async_answer_1(icall_handle, EOK, fun->handle);
     499                async_answer_0(icall, ENOENT);
     500                return;
     501        }
     502
     503        async_answer_1(icall, EOK, fun->handle);
    504504        fibril_rwlock_read_unlock(&device_tree.rwlock);
    505505        fun_del_ref(fun);
    … …  
    507507
    508508/** Get list of all registered drivers. */
    509 static void devman_get_drivers(cap_call_handle_t icall_handle, ipc_call_t *icall)
    510 {
    511         cap_call_handle_t chandle;
     509static void devman_get_drivers(ipc_call_t *icall)
     510{
     511        ipc_call_t call;
    512512        size_t size;
    513513        size_t act_size;
    514514        errno_t rc;
    515515
    516         if (!async_data_read_receive(&chandle, &size)) {
    517                 async_answer_0(icall_handle, EREFUSED);
     516        if (!async_data_read_receive(&call, &size)) {
     517                async_answer_0(icall, EREFUSED);
    518518                return;
    519519        }
    … …  
    521521        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
    522522        if (hdl_buf == NULL) {
    523                 async_answer_0(chandle, ENOMEM);
    524                 async_answer_0(icall_handle, ENOMEM);
     523                async_answer_0(&call, ENOMEM);
     524                async_answer_0(icall, ENOMEM);
    525525                return;
    526526        }
    … …  
    528528        rc = driver_get_list(&drivers_list, hdl_buf, size, &act_size);
    529529        if (rc != EOK) {
    530                 async_answer_0(chandle, rc);
    531                 async_answer_0(icall_handle, rc);
    532                 return;
    533         }
    534 
    535         errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
     530                async_answer_0(&call, rc);
     531                async_answer_0(icall, rc);
     532                return;
     533        }
     534
     535        errno_t retval = async_data_read_finalize(&call, hdl_buf, size);
    536536        free(hdl_buf);
    537537
    538         async_answer_1(icall_handle, retval, act_size);
    539 }
    540 
    541 static void devman_driver_get_devices(cap_call_handle_t icall_handle, ipc_call_t *icall)
    542 {
    543         cap_call_handle_t chandle;
     538        async_answer_1(icall, retval, act_size);
     539}
     540
     541static void devman_driver_get_devices(ipc_call_t *icall)
     542{
     543        ipc_call_t call;
    544544        size_t size;
    545545        size_t act_size;
    546546        errno_t rc;
    547547
    548         if (!async_data_read_receive(&chandle, &size)) {
    549                 async_answer_0(icall_handle, EREFUSED);
     548        if (!async_data_read_receive(&call, &size)) {
     549                async_answer_0(icall, EREFUSED);
    550550                return;
    551551        }
    … …  
    553553        driver_t *drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    554554        if (drv == NULL) {
    555                 async_answer_0(chandle, ENOENT);
    556                 async_answer_0(icall_handle, ENOENT);
     555                async_answer_0(&call, ENOENT);
     556                async_answer_0(icall, ENOENT);
    557557                return;
    558558        }
    … …  
    560560        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
    561561        if (hdl_buf == NULL) {
    562                 async_answer_0(chandle, ENOMEM);
    563                 async_answer_0(icall_handle, ENOMEM);
     562                async_answer_0(&call, ENOMEM);
     563                async_answer_0(icall, ENOMEM);
    564564                return;
    565565        }
    … …  
    568568        if (rc != EOK) {
    569569                fibril_rwlock_read_unlock(&device_tree.rwlock);
    570                 async_answer_0(chandle, rc);
    571                 async_answer_0(icall_handle, rc);
    572                 return;
    573         }
    574 
    575         errno_t retval = async_data_read_finalize(chandle, hdl_buf, size);
     570                async_answer_0(&call, rc);
     571                async_answer_0(icall, rc);
     572                return;
     573        }
     574
     575        errno_t retval = async_data_read_finalize(&call, hdl_buf, size);
    576576        free(hdl_buf);
    577577
    578         async_answer_1(icall_handle, retval, act_size);
     578        async_answer_1(icall, retval, act_size);
    579579}
    580580
    581581
    582582/** Find driver by name. */
    583 static void devman_driver_get_handle(cap_call_handle_t icall_handle, ipc_call_t *icall)
     583static void devman_driver_get_handle(ipc_call_t *icall)
    584584{
    585585        char *drvname;
    … …  
    587587        errno_t rc = async_data_write_accept((void **) &drvname, true, 0, 0, 0, 0);
    588588        if (rc != EOK) {
    589                 async_answer_0(icall_handle, rc);
     589                async_answer_0(icall, rc);
    590590                return;
    591591        }
    … …  
    596596
    597597        if (driver == NULL) {
    598                 async_answer_0(icall_handle, ENOENT);
    599                 return;
    600         }
    601 
    602         async_answer_1(icall_handle, EOK, driver->handle);
     598                async_answer_0(icall, ENOENT);
     599                return;
     600        }
     601
     602        async_answer_1(icall, EOK, driver->handle);
    603603}
    604604
    605605/** Get driver match ID. */
    606 static void devman_driver_get_match_id(cap_call_handle_t icall_handle, ipc_call_t *icall)
     606static void devman_driver_get_match_id(ipc_call_t *icall)
    607607{
    608608        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    611611        driver_t *drv = driver_find(&drivers_list, handle);
    612612        if (drv == NULL) {
    613                 async_answer_0(icall_handle, ENOMEM);
    614                 return;
    615         }
    616 
    617         cap_call_handle_t data_chandle;
     613                async_answer_0(icall, ENOMEM);
     614                return;
     615        }
     616
     617        ipc_call_t data;
    618618        size_t data_len;
    619         if (!async_data_read_receive(&data_chandle, &data_len)) {
    620                 async_answer_0(icall_handle, EINVAL);
     619        if (!async_data_read_receive(&data, &data_len)) {
     620                async_answer_0(icall, EINVAL);
    621621                return;
    622622        }
    … …  
    624624        void *buffer = malloc(data_len);
    625625        if (buffer == NULL) {
    626                 async_answer_0(data_chandle, ENOMEM);
    627                 async_answer_0(icall_handle, ENOMEM);
     626                async_answer_0(&data, ENOMEM);
     627                async_answer_0(icall, ENOMEM);
    628628                return;
    629629        }
    … …  
    634634                fibril_mutex_unlock(&drv->driver_mutex);
    635635                free(buffer);
    636                 async_answer_0(data_chandle, ENOMEM);
    637                 async_answer_0(icall_handle, ENOMEM);
     636                async_answer_0(&data, ENOMEM);
     637                async_answer_0(icall, ENOMEM);
    638638                return;
    639639        }
    … …  
    646646        }
    647647
    648         async_data_read_finalize(data_chandle, mid->id, sent_length);
    649         async_answer_1(icall_handle, EOK, mid->score);
     648        async_data_read_finalize(&data, mid->id, sent_length);
     649        async_answer_1(icall, EOK, mid->score);
    650650
    651651        fibril_mutex_unlock(&drv->driver_mutex);
    … …  
    655655
    656656/** Get driver name. */
    657 static void devman_driver_get_name(cap_call_handle_t icall_handle, ipc_call_t *icall)
     657static void devman_driver_get_name(ipc_call_t *icall)
    658658{
    659659        devman_handle_t handle = IPC_GET_ARG1(*icall);
    … …  
    661661        driver_t *drv = driver_find(&drivers_list, handle);
    662662        if (drv == NULL) {
    663                 async_answer_0(icall_handle, ENOMEM);
    664                 return;
    665         }
    666 
    667         cap_call_handle_t data_chandle;
     663                async_answer_0(icall, ENOMEM);
     664                return;
     665        }
     666
     667        ipc_call_t data;
    668668        size_t data_len;
    669         if (!async_data_read_receive(&data_chandle, &data_len)) {
    670                 async_answer_0(icall_handle, EINVAL);
     669        if (!async_data_read_receive(&data, &data_len)) {
     670                async_answer_0(icall, EINVAL);
    671671                return;
    672672        }
    … …  
    674674        void *buffer = malloc(data_len);
    675675        if (buffer == NULL) {
    676                 async_answer_0(data_chandle, ENOMEM);
    677                 async_answer_0(icall_handle, ENOMEM);
     676                async_answer_0(&data, ENOMEM);
     677                async_answer_0(icall, ENOMEM);
    678678                return;
    679679        }
    … …  
    686686        }
    687687
    688         async_data_read_finalize(data_chandle, drv->name, sent_length);
    689         async_answer_0(icall_handle, EOK);
     688        async_data_read_finalize(&data, drv->name, sent_length);
     689        async_answer_0(icall, EOK);
    690690
    691691        fibril_mutex_unlock(&drv->driver_mutex);
    … …  
    695695
    696696/** Get driver state. */
    697 static void devman_driver_get_state(cap_call_handle_t icall_handle, ipc_call_t *icall)
     697static void devman_driver_get_state(ipc_call_t *icall)
    698698{
    699699        driver_t *drv;
    … …  
    701701        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    702702        if (drv == NULL) {
    703                 async_answer_0(icall_handle, ENOENT);
    704                 return;
    705         }
    706 
    707         async_answer_1(icall_handle, EOK, (sysarg_t) drv->state);
     703                async_answer_0(icall, ENOENT);
     704                return;
     705        }
     706
     707        async_answer_1(icall, EOK, (sysarg_t) drv->state);
    708708}
    709709
    710710/** Forcibly load a driver. */
    711 static void devman_driver_load(cap_call_handle_t icall_handle, ipc_call_t *icall)
     711static void devman_driver_load(ipc_call_t *icall)
    712712{
    713713        driver_t *drv;
    … …  
    716716        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    717717        if (drv == NULL) {
    718                 async_answer_0(icall_handle, ENOENT);
     718                async_answer_0(icall, ENOENT);
    719719                return;
    720720        }
    … …  
    724724        fibril_mutex_unlock(&drv->driver_mutex);
    725725
    726         async_answer_0(icall_handle, rc);
     726        async_answer_0(icall, rc);
    727727}
    728728
    729729/** Unload a driver by user request. */
    730 static void devman_driver_unload(cap_call_handle_t icall_handle, ipc_call_t *icall)
     730static void devman_driver_unload(ipc_call_t *icall)
    731731{
    732732        driver_t *drv;
    … …  
    735735        drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
    736736        if (drv == NULL) {
    737                 async_answer_0(icall_handle, ENOENT);
     737                async_answer_0(icall, ENOENT);
    738738                return;
    739739        }
    … …  
    743743        fibril_mutex_unlock(&drv->driver_mutex);
    744744
    745         async_answer_0(icall_handle, rc);
     745        async_answer_0(icall, rc);
    746746}
    747747
    748748/** Function for handling connections from a client to the device manager. */
    749 void devman_connection_client(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     749void devman_connection_client(ipc_call_t *icall, void *arg)
    750750{
    751751        /* Accept connection. */
    752         async_answer_0(icall_handle, EOK);
     752        async_answer_0(icall, EOK);
    753753
    754754        while (true) {
    755755                ipc_call_t call;
    756                 cap_call_handle_t chandle = async_get_call(&call);
     756                async_get_call(&call);
    757757
    758758                if (!IPC_GET_IMETHOD(call))
    … …  
    761761                switch (IPC_GET_IMETHOD(call)) {
    762762                case DEVMAN_DEVICE_GET_HANDLE:
    763                         devman_function_get_handle(chandle, &call);
     763                        devman_function_get_handle(&call);
    764764                        break;
    765765                case DEVMAN_DEV_GET_PARENT:
    766                         devman_dev_get_parent(chandle, &call);
     766                        devman_dev_get_parent(&call);
    767767                        break;
    768768                case DEVMAN_DEV_GET_FUNCTIONS:
    769                         devman_dev_get_functions(chandle, &call);
     769                        devman_dev_get_functions(&call);
    770770                        break;
    771771                case DEVMAN_FUN_GET_CHILD:
    772                         devman_fun_get_child(chandle, &call);
     772                        devman_fun_get_child(&call);
    773773                        break;
    774774                case DEVMAN_FUN_GET_MATCH_ID:
    775                         devman_fun_get_match_id(chandle, &call);
     775                        devman_fun_get_match_id(&call);
    776776                        break;
    777777                case DEVMAN_FUN_GET_NAME:
    778                         devman_fun_get_name(chandle, &call);
     778                        devman_fun_get_name(&call);
    779779                        break;
    780780                case DEVMAN_FUN_GET_DRIVER_NAME:
    781                         devman_fun_get_driver_name(chandle, &call);
     781                        devman_fun_get_driver_name(&call);
    782782                        break;
    783783                case DEVMAN_FUN_GET_PATH:
    784                         devman_fun_get_path(chandle, &call);
     784                        devman_fun_get_path(&call);
    785785                        break;
    786786                case DEVMAN_FUN_ONLINE:
    787                         devman_fun_online(chandle, &call);
     787                        devman_fun_online(&call);
    788788                        break;
    789789                case DEVMAN_FUN_OFFLINE:
    790                         devman_fun_offline(chandle, &call);
     790                        devman_fun_offline(&call);
    791791                        break;
    792792                case DEVMAN_FUN_SID_TO_HANDLE:
    793                         devman_fun_sid_to_handle(chandle, &call);
     793                        devman_fun_sid_to_handle(&call);
    794794                        break;
    795795                case DEVMAN_GET_DRIVERS:
    796                         devman_get_drivers(chandle, &call);
     796                        devman_get_drivers(&call);
    797797                        break;
    798798                case DEVMAN_DRIVER_GET_DEVICES:
    799                         devman_driver_get_devices(chandle, &call);
     799                        devman_driver_get_devices(&call);
    800800                        break;
    801801                case DEVMAN_DRIVER_GET_HANDLE:
    802                         devman_driver_get_handle(chandle, &call);
     802                        devman_driver_get_handle(&call);
    803803                        break;
    804804                case DEVMAN_DRIVER_GET_MATCH_ID:
    805                         devman_driver_get_match_id(chandle, &call);
     805                        devman_driver_get_match_id(&call);
    806806                        break;
    807807                case DEVMAN_DRIVER_GET_NAME:
    808                         devman_driver_get_name(chandle, &call);
     808                        devman_driver_get_name(&call);
    809809                        break;
    810810                case DEVMAN_DRIVER_GET_STATE:
    811                         devman_driver_get_state(chandle, &call);
     811                        devman_driver_get_state(&call);
    812812                        break;
    813813                case DEVMAN_DRIVER_LOAD:
    814                         devman_driver_load(chandle, &call);
     814                        devman_driver_load(&call);
    815815                        break;
    816816                case DEVMAN_DRIVER_UNLOAD:
    817                         devman_driver_unload(chandle, &call);
     817                        devman_driver_unload(&call);
    818818                        break;
    819819                default:
    820                         async_answer_0(chandle, ENOENT);
     820                        async_answer_0(&call, ENOENT);
    821821                }
    822822        }
    823823}
    824 
    825824
    826825/** @}

  • uspace/srv/devman/client_conn.h

    r76f566d r984a9ba  
    3636#include "devman.h"
    3737
    38 extern void devman_connection_client(cap_call_handle_t, ipc_call_t *, void *);
     38extern void devman_connection_client(ipc_call_t *, void *);
    3939
    4040#endif

  • uspace/srv/devman/drv_conn.c

    r76f566d r984a9ba  
    6464
    6565/** Register running driver. */
    66 static driver_t *devman_driver_register(cap_call_handle_t chandle, ipc_call_t *call)
     66static driver_t *devman_driver_register(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(chandle, rc);
     76                async_answer_0(call, rc);
    7777                return NULL;
    7878        }
    … …  
    8787                free(drv_name);
    8888                drv_name = NULL;
    89                 async_answer_0(chandle, ENOENT);
     89                async_answer_0(call, ENOENT);
    9090                return NULL;
    9191        }
    … …  
    101101                    driver->name);
    102102                fibril_mutex_unlock(&driver->driver_mutex);
    103                 async_answer_0(chandle, EEXIST);
     103                async_answer_0(call, EEXIST);
    104104                return NULL;
    105105        }
    … …  
    126126        if (!driver->sess) {
    127127                fibril_mutex_unlock(&driver->driver_mutex);
    128                 async_answer_0(chandle, ENOTSUP);
     128                async_answer_0(call, ENOTSUP);
    129129                return NULL;
    130130        }
    … …  
    146146                    "for driver `%s'.", driver->name);
    147147                fibril_mutex_unlock(&driver->driver_mutex);
    148                 async_answer_0(chandle, ENOMEM);
     148                async_answer_0(call, ENOMEM);
    149149                return NULL;
    150150        }
    … …  
    153153        fibril_mutex_unlock(&driver->driver_mutex);
    154154
    155         async_answer_0(chandle, EOK);
     155        async_answer_0(call, EOK);
    156156        return driver;
    157157}
    … …  
    166166{
    167167        match_id_t *match_id = create_match_id();
    168         cap_call_handle_t chandle;
    169168        ipc_call_t call;
    170169        errno_t rc = 0;
    171170
    172         chandle = async_get_call(&call);
     171        async_get_call(&call);
    173172        if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    174173                log_msg(LOG_DEFAULT, LVL_ERROR,
    175174                    "Invalid protocol when trying to receive match id.");
    176                 async_answer_0(chandle, EINVAL);
     175                async_answer_0(&call, EINVAL);
    177176                delete_match_id(match_id);
    178177                return EINVAL;
    … …  
    181180        if (match_id == NULL) {
    182181                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate match id.");
    183                 async_answer_0(chandle, ENOMEM);
     182                async_answer_0(&call, ENOMEM);
    184183                return ENOMEM;
    185184        }
    186185
    187         async_answer_0(chandle, EOK);
     186        async_answer_0(&call, EOK);
    188187
    189188        match_id->score = IPC_GET_ARG1(call);
    … …  
    230229 * Child devices are registered by their parent's device driver.
    231230 */
    232 static void devman_add_function(cap_call_handle_t chandle, ipc_call_t *call)
     231static void devman_add_function(ipc_call_t *call)
    233232{
    234233        fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
    … …  
    239238        dev_node_t *pdev = find_dev_node(&device_tree, dev_handle);
    240239        if (pdev == NULL) {
    241                 async_answer_0(chandle, ENOENT);
     240                async_answer_0(call, ENOENT);
    242241                return;
    243242        }
    … …  
    250249
    251250                dev_del_ref(pdev);
    252                 async_answer_0(chandle, EINVAL);
     251                async_answer_0(call, EINVAL);
    253252                return;
    254253        }
    255254
    256255        char *fun_name = NULL;
    257         errno_t rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0);
     256        errno_t rc = async_data_write_accept((void **) &fun_name, true, 0, 0, 0, 0);
    258257        if (rc != EOK) {
    259258                dev_del_ref(pdev);
    260                 async_answer_0(chandle, rc);
     259                async_answer_0(call, rc);
    261260                return;
    262261        }
    … …  
    268267                fibril_rwlock_write_unlock(&tree->rwlock);
    269268                dev_del_ref(pdev);
    270                 async_answer_0(chandle, ENOENT);
     269                async_answer_0(call, ENOENT);
    271270                return;
    272271        }
    … …  
    278277                fibril_rwlock_write_unlock(&tree->rwlock);
    279278                dev_del_ref(pdev);
    280                 async_answer_0(chandle, EEXIST);
     279                async_answer_0(call, EEXIST);
    281280                printf(NAME ": Warning, driver tried to register `%s' twice.\n",
    282281                    fun_name);
    … …  
    303302                fun_del_ref(fun);
    304303                delete_fun_node(fun);
    305                 async_answer_0(chandle, ENOMEM);
     304                async_answer_0(call, ENOMEM);
    306305                return;
    307306        }
    … …  
    317316                fun_busy_unlock(fun);
    318317                fun_del_ref(fun);
    319                 async_answer_0(chandle, rc);
     318                async_answer_0(call, rc);
    320319                return;
    321320        }
    … …  
    325324
    326325        /* Return device handle to parent's driver. */
    327         async_answer_1(chandle, EOK, fun->handle);
    328 }
    329 
    330 static void devman_add_function_to_cat(cap_call_handle_t chandle, ipc_call_t *call)
     326        async_answer_1(call, EOK, fun->handle);
     327}
     328
     329static void devman_add_function_to_cat(ipc_call_t *call)
    331330{
    332331        devman_handle_t handle = IPC_GET_ARG1(*call);
    … …  
    339338            0, 0, 0, 0);
    340339        if (rc != EOK) {
    341                 async_answer_0(chandle, rc);
     340                async_answer_0(call, rc);
    342341                return;
    343342        }
    … …  
    345344        fun_node_t *fun = find_fun_node(&device_tree, handle);
    346345        if (fun == NULL) {
    347                 async_answer_0(chandle, ENOENT);
     346                async_answer_0(call, ENOENT);
    348347                return;
    349348        }
    … …  
    354353        if (fun->state == FUN_REMOVED) {
    355354                fibril_rwlock_read_unlock(&device_tree.rwlock);
    356                 async_answer_0(chandle, ENOENT);
     355                async_answer_0(call, ENOENT);
    357356                return;
    358357        }
    … …  
    371370        fun_del_ref(fun);
    372371
    373         async_answer_0(chandle, rc);
     372        async_answer_0(call, rc);
    374373}
    375374
    … …  
    377376 *
    378377 */
    379 static void devman_drv_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall,
    380     driver_t *drv)
     378static void devman_drv_fun_online(ipc_call_t *icall, driver_t *drv)
    381379{
    382380        fun_node_t *fun;
    … …  
    387385        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    388386        if (fun == NULL) {
    389                 async_answer_0(icall_handle, ENOENT);
     387                async_answer_0(icall, ENOENT);
    390388                return;
    391389        }
    … …  
    398396                fun_busy_unlock(fun);
    399397                fun_del_ref(fun);
    400                 async_answer_0(icall_handle, ENOENT);
     398                async_answer_0(icall, ENOENT);
    401399                return;
    402400        }
    … …  
    407405                fun_busy_unlock(fun);
    408406                fun_del_ref(fun);
    409                 async_answer_0(icall_handle, rc);
     407                async_answer_0(icall, rc);
    410408                return;
    411409        }
    … …  
    414412        fun_del_ref(fun);
    415413
    416         async_answer_0(icall_handle, EOK);
     414        async_answer_0(icall, EOK);
    417415}
    418416
    … …  
    421419 *
    422420 */
    423 static void devman_drv_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall,
    424     driver_t *drv)
     421static void devman_drv_fun_offline(ipc_call_t *icall, driver_t *drv)
    425422{
    426423        fun_node_t *fun;
    … …  
    429426        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    430427        if (fun == NULL) {
    431                 async_answer_0(icall_handle, ENOENT);
     428                async_answer_0(icall, ENOENT);
    432429                return;
    433430        }
    … …  
    439436                fun_busy_unlock(fun);
    440437                fun_del_ref(fun);
    441                 async_answer_0(icall_handle, ENOENT);
     438                async_answer_0(icall, ENOENT);
    442439                return;
    443440        }
    … …  
    448445                fun_busy_unlock(fun);
    449446                fun_del_ref(fun);
    450                 async_answer_0(icall_handle, rc);
     447                async_answer_0(icall, rc);
    451448                return;
    452449        }
    … …  
    454451        fun_busy_unlock(fun);
    455452        fun_del_ref(fun);
    456         async_answer_0(icall_handle, EOK);
     453        async_answer_0(icall, EOK);
    457454}
    458455
    459456/** Remove function. */
    460 static void devman_remove_function(cap_call_handle_t chandle, ipc_call_t *call)
     457static void devman_remove_function(ipc_call_t *call)
    461458{
    462459        devman_handle_t fun_handle = IPC_GET_ARG1(*call);
    … …  
    466463        fun_node_t *fun = find_fun_node(&device_tree, fun_handle);
    467464        if (fun == NULL) {
    468                 async_answer_0(chandle, ENOENT);
     465                async_answer_0(call, ENOENT);
    469466                return;
    470467        }
    … …  
    481478                fun_busy_unlock(fun);
    482479                fun_del_ref(fun);
    483                 async_answer_0(chandle, ENOENT);
     480                async_answer_0(call, ENOENT);
    484481                return;
    485482        }
    … …  
    523520                                fun_busy_unlock(fun);
    524521                                fun_del_ref(fun);
    525                                 async_answer_0(chandle, gone_rc);
     522                                async_answer_0(call, gone_rc);
    526523                                return;
    527524                        }
    … …  
    551548                                fun_busy_unlock(fun);
    552549                                fun_del_ref(fun);
    553                                 async_answer_0(chandle, EIO);
     550                                async_answer_0(call, EIO);
    554551                                return;
    555552                        }
    … …  
    567564
    568565        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function() succeeded.");
    569         async_answer_0(chandle, EOK);
     566        async_answer_0(call, EOK);
    570567}
    571568
    … …  
    586583
    587584/** Function for handling connections from a driver to the device manager. */
    588 void devman_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     585void devman_connection_driver(ipc_call_t *icall, void *arg)
    589586{
    590587        client_t *client;
    … …  
    592589
    593590        /* Accept the connection. */
    594         async_answer_0(icall_handle, EOK);
     591        async_answer_0(icall, EOK);
    595592
    596593        client = async_get_client_data();
    … …  
    602599        while (true) {
    603600                ipc_call_t call;
    604                 cap_call_handle_t chandle = async_get_call(&call);
     601                async_get_call(&call);
    605602
    606603                if (!IPC_GET_IMETHOD(call))
    … …  
    613610                        if (driver == NULL) {
    614611                                /* First call must be to DEVMAN_DRIVER_REGISTER */
    615                                 async_answer_0(chandle, ENOTSUP);
     612                                async_answer_0(&call, ENOTSUP);
    616613                                continue;
    617614                        }
    … …  
    623620                        if (client->driver != NULL) {
    624621                                fibril_mutex_unlock(&client->mutex);
    625                                 async_answer_0(chandle, EINVAL);
     622                                async_answer_0(&call, EINVAL);
    626623                                continue;
    627624                        }
    628                         client->driver = devman_driver_register(chandle, &call);
     625                        client->driver = devman_driver_register(&call);
    629626                        fibril_mutex_unlock(&client->mutex);
    630627                        break;
    631628                case DEVMAN_ADD_FUNCTION:
    632                         devman_add_function(chandle, &call);
     629                        devman_add_function(&call);
    633630                        break;
    634631                case DEVMAN_ADD_DEVICE_TO_CATEGORY:
    635                         devman_add_function_to_cat(chandle, &call);
     632                        devman_add_function_to_cat(&call);
    636633                        break;
    637634                case DEVMAN_DRV_FUN_ONLINE:
    638                         devman_drv_fun_online(chandle, &call, driver);
     635                        devman_drv_fun_online(&call, driver);
    639636                        break;
    640637                case DEVMAN_DRV_FUN_OFFLINE:
    641                         devman_drv_fun_offline(chandle, &call, driver);
     638                        devman_drv_fun_offline(&call, driver);
    642639                        break;
    643640                case DEVMAN_REMOVE_FUNCTION:
    644                         devman_remove_function(chandle, &call);
     641                        devman_remove_function(&call);
    645642                        break;
    646643                default:
    647                         async_answer_0(chandle, EINVAL);
     644                        async_answer_0(&call, EINVAL);
    648645                        break;
    649646                }

  • uspace/srv/devman/drv_conn.h

    r76f566d r984a9ba  
    3737#include "devman.h"
    3838
    39 extern void devman_connection_driver(cap_call_handle_t, ipc_call_t *, void *);
     39extern void devman_connection_driver(ipc_call_t *, void *);
    4040
    4141#endif

  • uspace/srv/devman/main.c

    r76f566d r984a9ba  
    6666dev_tree_t device_tree;
    6767
    68 static void devman_connection_device(cap_call_handle_t icall_handle, ipc_call_t *icall,
    69     void *arg)
     68static void devman_connection_device(ipc_call_t *icall, void *arg)
    7069{
    7170        devman_handle_t handle = IPC_GET_ARG2(*icall);
    … …  
    9493                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
    9594                    "function with handle %" PRIun " was found.", handle);
    96                 async_answer_0(icall_handle, ENOENT);
     95                async_answer_0(icall, ENOENT);
    9796                goto cleanup;
    9897        }
    … …  
    102101                    "connect to handle %" PRIun ", refers to a device.",
    103102                    handle);
    104                 async_answer_0(icall_handle, ENOENT);
     103                async_answer_0(icall, ENOENT);
    105104                goto cleanup;
    106105        }
    … …  
    116115                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - "
    117116                    "the device %" PRIun " is not in usable state.", handle);
    118                 async_answer_0(icall_handle, ENOENT);
     117                async_answer_0(icall, ENOENT);
    119118                goto cleanup;
    120119        }
    … …  
    123122                log_msg(LOG_DEFAULT, LVL_ERROR,
    124123                    "Could not forward to driver `%s'.", driver->name);
    125                 async_answer_0(icall_handle, EINVAL);
     124                async_answer_0(icall, EINVAL);
    126125                goto cleanup;
    127126        }
    … …  
    138137
    139138        async_exch_t *exch = async_exchange_begin(driver->sess);
    140         async_forward_fast(icall_handle, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
     139        async_forward_fast(icall, exch, INTERFACE_DDF_CLIENT, handle, 0, IPC_FF_NONE);
    141140        async_exchange_end(exch);
    142141
    … …  
    149148}
    150149
    151 static void devman_connection_parent(cap_call_handle_t icall_handle, ipc_call_t *icall,
    152     void *arg)
     150static void devman_connection_parent(ipc_call_t *icall, void *arg)
    153151{
    154152        devman_handle_t handle = IPC_GET_ARG2(*icall);
    … …  
    177175                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
    178176                    "function with handle %" PRIun " was found.", handle);
    179                 async_answer_0(icall_handle, ENOENT);
     177                async_answer_0(icall, ENOENT);
    180178                goto cleanup;
    181179        }
    … …  
    196194                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - "
    197195                    "the device %" PRIun " is not in usable state.", handle);
    198                 async_answer_0(icall_handle, ENOENT);
     196                async_answer_0(icall, ENOENT);
    199197                goto cleanup;
    200198        }
    … …  
    203201                log_msg(LOG_DEFAULT, LVL_ERROR,
    204202                    "Could not forward to driver `%s'.", driver->name);
    205                 async_answer_0(icall_handle, EINVAL);
     203                async_answer_0(icall, EINVAL);
    206204                goto cleanup;
    207205        }
    … …  
    218216
    219217        async_exch_t *exch = async_exchange_begin(driver->sess);
    220         async_forward_fast(icall_handle, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
     218        async_forward_fast(icall, exch, INTERFACE_DDF_DRIVER, fun_handle, 0, IPC_FF_NONE);
    221219        async_exchange_end(exch);
    222220
    … …  
    229227}
    230228
    231 static void devman_forward(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     229static void devman_forward(ipc_call_t *icall, void *arg)
    232230{
    233231        iface_t iface = IPC_GET_ARG1(*icall);
    … …  
    242240                    "not found.\n");
    243241                fibril_rwlock_read_unlock(&device_tree.rwlock);
    244                 async_answer_0(icall_handle, ENOENT);
     242                async_answer_0(icall, ENOENT);
    245243                return;
    246244        }
    … …  
    253251
    254252        async_exch_t *exch = async_exchange_begin(driver->sess);
    255         async_forward_fast(icall_handle, exch, iface, handle, 0, IPC_FF_NONE);
     253        async_forward_fast(icall, exch, iface, handle, 0, IPC_FF_NONE);
    256254        async_exchange_end(exch);
    257255
Note: See TracChangeset for help on using the changeset viewer.