Changeset 984a9ba in mainline for uspace/srv/devman/client_conn.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (6 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.

File:
1 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/** @}
Note: See TracChangeset for help on using the changeset viewer.