Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/bd_srv.c

    r5a6cc679 ra46e56b  
    4343#include <bd_srv.h>
    4444
    45 static void bd_read_blocks_srv(bd_srv_t *srv, ipc_callid_t callid,
     45static void bd_read_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    4646    ipc_call_t *call)
    4747{
    … …  
    5151        size_t size;
    5252        errno_t rc;
    53         ipc_callid_t rcallid;
     53        cap_call_handle_t rcall_handle;
    5454
    5555        ba = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
    5656        cnt = IPC_GET_ARG3(*call);
    5757
    58         if (!async_data_read_receive(&rcallid, &size)) {
    59                 async_answer_0(callid, EINVAL);
     58        if (!async_data_read_receive(&rcall_handle, &size)) {
     59                async_answer_0(chandle, EINVAL);
    6060                return;
    6161        }
    … …  
    6363        buf = malloc(size);
    6464        if (buf == NULL) {
    65                 async_answer_0(rcallid, ENOMEM);
    66                 async_answer_0(callid, ENOMEM);
     65                async_answer_0(rcall_handle, ENOMEM);
     66                async_answer_0(chandle, ENOMEM);
    6767                return;
    6868        }
    6969
    7070        if (srv->srvs->ops->read_blocks == NULL) {
    71                 async_answer_0(rcallid, ENOTSUP);
    72                 async_answer_0(callid, ENOTSUP);
     71                async_answer_0(rcall_handle, ENOTSUP);
     72                async_answer_0(chandle, ENOTSUP);
    7373                free(buf);
    7474                return;
    … …  
    7777        rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
    7878        if (rc != EOK) {
    79                 async_answer_0(rcallid, ENOMEM);
    80                 async_answer_0(callid, ENOMEM);
    81                 free(buf);
    82                 return;
    83         }
    84 
    85         async_data_read_finalize(rcallid, buf, size);
     79                async_answer_0(rcall_handle, ENOMEM);
     80                async_answer_0(chandle, ENOMEM);
     81                free(buf);
     82                return;
     83        }
     84
     85        async_data_read_finalize(rcall_handle, buf, size);
    8686
    8787        free(buf);
    88         async_answer_0(callid, EOK);
    89 }
    90 
    91 static void bd_read_toc_srv(bd_srv_t *srv, ipc_callid_t callid,
     88        async_answer_0(chandle, EOK);
     89}
     90
     91static void bd_read_toc_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    9292    ipc_call_t *call)
    9393{
    … …  
    9696        size_t size;
    9797        errno_t rc;
    98         ipc_callid_t rcallid;
     98        cap_call_handle_t rcall_handle;
    9999
    100100        session = IPC_GET_ARG1(*call);
    101101
    102         if (!async_data_read_receive(&rcallid, &size)) {
    103                 async_answer_0(callid, EINVAL);
     102        if (!async_data_read_receive(&rcall_handle, &size)) {
     103                async_answer_0(chandle, EINVAL);
    104104                return;
    105105        }
    … …  
    107107        buf = malloc(size);
    108108        if (buf == NULL) {
    109                 async_answer_0(rcallid, ENOMEM);
    110                 async_answer_0(callid, ENOMEM);
     109                async_answer_0(rcall_handle, ENOMEM);
     110                async_answer_0(chandle, ENOMEM);
    111111                return;
    112112        }
    113113
    114114        if (srv->srvs->ops->read_toc == NULL) {
    115                 async_answer_0(rcallid, ENOTSUP);
    116                 async_answer_0(callid, ENOTSUP);
     115                async_answer_0(rcall_handle, ENOTSUP);
     116                async_answer_0(chandle, ENOTSUP);
    117117                free(buf);
    118118                return;
    … …  
    121121        rc = srv->srvs->ops->read_toc(srv, session, buf, size);
    122122        if (rc != EOK) {
    123                 async_answer_0(rcallid, ENOMEM);
    124                 async_answer_0(callid, ENOMEM);
    125                 free(buf);
    126                 return;
    127         }
    128 
    129         async_data_read_finalize(rcallid, buf, size);
     123                async_answer_0(rcall_handle, ENOMEM);
     124                async_answer_0(chandle, ENOMEM);
     125                free(buf);
     126                return;
     127        }
     128
     129        async_data_read_finalize(rcall_handle, buf, size);
    130130
    131131        free(buf);
    132         async_answer_0(callid, EOK);
    133 }
    134 
    135 static void bd_sync_cache_srv(bd_srv_t *srv, ipc_callid_t callid,
     132        async_answer_0(chandle, EOK);
     133}
     134
     135static void bd_sync_cache_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    136136    ipc_call_t *call)
    137137{
    … …  
    144144
    145145        if (srv->srvs->ops->sync_cache == NULL) {
    146                 async_answer_0(callid, ENOTSUP);
     146                async_answer_0(chandle, ENOTSUP);
    147147                return;
    148148        }
    149149
    150150        rc = srv->srvs->ops->sync_cache(srv, ba, cnt);
    151         async_answer_0(callid, rc);
    152 }
    153 
    154 static void bd_write_blocks_srv(bd_srv_t *srv, ipc_callid_t callid,
     151        async_answer_0(chandle, rc);
     152}
     153
     154static void bd_write_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    155155    ipc_call_t *call)
    156156{
    … …  
    166166        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    167167        if (rc != EOK) {
    168                 async_answer_0(callid, rc);
     168                async_answer_0(chandle, rc);
    169169                return;
    170170        }
    171171
    172172        if (srv->srvs->ops->write_blocks == NULL) {
    173                 async_answer_0(callid, ENOTSUP);
     173                async_answer_0(chandle, ENOTSUP);
    174174                return;
    175175        }
    … …  
    177177        rc = srv->srvs->ops->write_blocks(srv, ba, cnt, data, size);
    178178        free(data);
    179         async_answer_0(callid, rc);
    180 }
    181 
    182 static void bd_get_block_size_srv(bd_srv_t *srv, ipc_callid_t callid,
     179        async_answer_0(chandle, rc);
     180}
     181
     182static void bd_get_block_size_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    183183    ipc_call_t *call)
    184184{
    … …  
    187187
    188188        if (srv->srvs->ops->get_block_size == NULL) {
    189                 async_answer_0(callid, ENOTSUP);
     189                async_answer_0(chandle, ENOTSUP);
    190190                return;
    191191        }
    192192
    193193        rc = srv->srvs->ops->get_block_size(srv, &block_size);
    194         async_answer_1(callid, rc, block_size);
    195 }
    196 
    197 static void bd_get_num_blocks_srv(bd_srv_t *srv, ipc_callid_t callid,
     194        async_answer_1(chandle, rc, block_size);
     195}
     196
     197static void bd_get_num_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    198198    ipc_call_t *call)
    199199{
    … …  
    202202
    203203        if (srv->srvs->ops->get_num_blocks == NULL) {
    204                 async_answer_0(callid, ENOTSUP);
     204                async_answer_0(chandle, ENOTSUP);
    205205                return;
    206206        }
    207207
    208208        rc = srv->srvs->ops->get_num_blocks(srv, &num_blocks);
    209         async_answer_2(callid, rc, LOWER32(num_blocks), UPPER32(num_blocks));
     209        async_answer_2(chandle, rc, LOWER32(num_blocks), UPPER32(num_blocks));
    210210}
    211211
    … …  
    228228}
    229229
    230 errno_t bd_conn(ipc_callid_t iid, ipc_call_t *icall, bd_srvs_t *srvs)
     230errno_t bd_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, bd_srvs_t *srvs)
    231231{
    232232        bd_srv_t *srv;
    … …  
    234234
    235235        /* Accept the connection */
    236         async_answer_0(iid, EOK);
     236        async_answer_0(icall_handle, EOK);
    237237
    238238        srv = bd_srv_create(srvs);
    … …  
    252252        while (true) {
    253253                ipc_call_t call;
    254                 ipc_callid_t callid = async_get_call(&call);
     254                cap_call_handle_t chandle = async_get_call(&call);
    255255                sysarg_t method = IPC_GET_IMETHOD(call);
    256256
    257257                if (!method) {
    258258                        /* The other side has hung up */
    259                         async_answer_0(callid, EOK);
     259                        async_answer_0(chandle, EOK);
    260260                        break;
    261261                }
    … …  
    263263                switch (method) {
    264264                case BD_READ_BLOCKS:
    265                         bd_read_blocks_srv(srv, callid, &call);
     265                        bd_read_blocks_srv(srv, chandle, &call);
    266266                        break;
    267267                case BD_READ_TOC:
    268                         bd_read_toc_srv(srv, callid, &call);
     268                        bd_read_toc_srv(srv, chandle, &call);
    269269                        break;
    270270                case BD_SYNC_CACHE:
    271                         bd_sync_cache_srv(srv, callid, &call);
     271                        bd_sync_cache_srv(srv, chandle, &call);
    272272                        break;
    273273                case BD_WRITE_BLOCKS:
    274                         bd_write_blocks_srv(srv, callid, &call);
     274                        bd_write_blocks_srv(srv, chandle, &call);
    275275                        break;
    276276                case BD_GET_BLOCK_SIZE:
    277                         bd_get_block_size_srv(srv, callid, &call);
     277                        bd_get_block_size_srv(srv, chandle, &call);
    278278                        break;
    279279                case BD_GET_NUM_BLOCKS:
    280                         bd_get_num_blocks_srv(srv, callid, &call);
     280                        bd_get_num_blocks_srv(srv, chandle, &call);
    281281                        break;
    282282                default:
    283                         async_answer_0(callid, EINVAL);
     283                        async_answer_0(chandle, EINVAL);
    284284                }
    285285        }
Note: See TracChangeset for help on using the changeset viewer.