Changeset 984a9ba in mainline for uspace/lib/c/generic/bd_srv.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/lib/c/generic/bd_srv.c

    r76f566d r984a9ba  
    4343#include <bd_srv.h>
    4444
    45 static void bd_read_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    46     ipc_call_t *call)
     45static void bd_read_blocks_srv(bd_srv_t *srv, ipc_call_t *call)
    4746{
    4847        aoff64_t ba;
    … …  
    5150        size_t size;
    5251        errno_t rc;
    53         cap_call_handle_t rcall_handle;
    5452
    5553        ba = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
    5654        cnt = IPC_GET_ARG3(*call);
    5755
    58         if (!async_data_read_receive(&rcall_handle, &size)) {
    59                 async_answer_0(chandle, EINVAL);
     56        ipc_call_t rcall;
     57        if (!async_data_read_receive(&rcall, &size)) {
     58                async_answer_0(call, EINVAL);
    6059                return;
    6160        }
    … …  
    6362        buf = malloc(size);
    6463        if (buf == NULL) {
    65                 async_answer_0(rcall_handle, ENOMEM);
    66                 async_answer_0(chandle, ENOMEM);
     64                async_answer_0(&rcall, ENOMEM);
     65                async_answer_0(call, ENOMEM);
    6766                return;
    6867        }
    6968
    7069        if (srv->srvs->ops->read_blocks == NULL) {
    71                 async_answer_0(rcall_handle, ENOTSUP);
    72                 async_answer_0(chandle, ENOTSUP);
     70                async_answer_0(&rcall, ENOTSUP);
     71                async_answer_0(call, ENOTSUP);
    7372                free(buf);
    7473                return;
    … …  
    7776        rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
    7877        if (rc != EOK) {
    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);
     78                async_answer_0(&rcall, ENOMEM);
     79                async_answer_0(call, ENOMEM);
     80                free(buf);
     81                return;
     82        }
     83
     84        async_data_read_finalize(&rcall, buf, size);
    8685
    8786        free(buf);
    88         async_answer_0(chandle, EOK);
    89 }
    90 
    91 static void bd_read_toc_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    92     ipc_call_t *call)
     87        async_answer_0(call, EOK);
     88}
     89
     90static void bd_read_toc_srv(bd_srv_t *srv, ipc_call_t *call)
    9391{
    9492        uint8_t session;
    … …  
    9694        size_t size;
    9795        errno_t rc;
    98         cap_call_handle_t rcall_handle;
    9996
    10097        session = IPC_GET_ARG1(*call);
    10198
    102         if (!async_data_read_receive(&rcall_handle, &size)) {
    103                 async_answer_0(chandle, EINVAL);
     99        ipc_call_t rcall;
     100        if (!async_data_read_receive(&rcall, &size)) {
     101                async_answer_0(call, EINVAL);
    104102                return;
    105103        }
    … …  
    107105        buf = malloc(size);
    108106        if (buf == NULL) {
    109                 async_answer_0(rcall_handle, ENOMEM);
    110                 async_answer_0(chandle, ENOMEM);
     107                async_answer_0(&rcall, ENOMEM);
     108                async_answer_0(call, ENOMEM);
    111109                return;
    112110        }
    113111
    114112        if (srv->srvs->ops->read_toc == NULL) {
    115                 async_answer_0(rcall_handle, ENOTSUP);
    116                 async_answer_0(chandle, ENOTSUP);
     113                async_answer_0(&rcall, ENOTSUP);
     114                async_answer_0(call, ENOTSUP);
    117115                free(buf);
    118116                return;
    … …  
    121119        rc = srv->srvs->ops->read_toc(srv, session, buf, size);
    122120        if (rc != EOK) {
    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);
     121                async_answer_0(&rcall, ENOMEM);
     122                async_answer_0(call, ENOMEM);
     123                free(buf);
     124                return;
     125        }
     126
     127        async_data_read_finalize(&rcall, buf, size);
    130128
    131129        free(buf);
    132         async_answer_0(chandle, EOK);
    133 }
    134 
    135 static void bd_sync_cache_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    136     ipc_call_t *call)
     130        async_answer_0(call, EOK);
     131}
     132
     133static void bd_sync_cache_srv(bd_srv_t *srv, ipc_call_t *call)
    137134{
    138135        aoff64_t ba;
    … …  
    144141
    145142        if (srv->srvs->ops->sync_cache == NULL) {
    146                 async_answer_0(chandle, ENOTSUP);
     143                async_answer_0(call, ENOTSUP);
    147144                return;
    148145        }
    149146
    150147        rc = srv->srvs->ops->sync_cache(srv, ba, cnt);
    151         async_answer_0(chandle, rc);
    152 }
    153 
    154 static void bd_write_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    155     ipc_call_t *call)
     148        async_answer_0(call, rc);
     149}
     150
     151static void bd_write_blocks_srv(bd_srv_t *srv, ipc_call_t *call)
    156152{
    157153        aoff64_t ba;
    … …  
    166162        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    167163        if (rc != EOK) {
    168                 async_answer_0(chandle, rc);
     164                async_answer_0(call, rc);
    169165                return;
    170166        }
    171167
    172168        if (srv->srvs->ops->write_blocks == NULL) {
    173                 async_answer_0(chandle, ENOTSUP);
     169                async_answer_0(call, ENOTSUP);
    174170                return;
    175171        }
    … …  
    177173        rc = srv->srvs->ops->write_blocks(srv, ba, cnt, data, size);
    178174        free(data);
    179         async_answer_0(chandle, rc);
    180 }
    181 
    182 static void bd_get_block_size_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    183     ipc_call_t *call)
     175        async_answer_0(call, rc);
     176}
     177
     178static void bd_get_block_size_srv(bd_srv_t *srv, ipc_call_t *call)
    184179{
    185180        errno_t rc;
    … …  
    187182
    188183        if (srv->srvs->ops->get_block_size == NULL) {
    189                 async_answer_0(chandle, ENOTSUP);
     184                async_answer_0(call, ENOTSUP);
    190185                return;
    191186        }
    192187
    193188        rc = srv->srvs->ops->get_block_size(srv, &block_size);
    194         async_answer_1(chandle, rc, block_size);
    195 }
    196 
    197 static void bd_get_num_blocks_srv(bd_srv_t *srv, cap_call_handle_t chandle,
    198     ipc_call_t *call)
     189        async_answer_1(call, rc, block_size);
     190}
     191
     192static void bd_get_num_blocks_srv(bd_srv_t *srv, ipc_call_t *call)
    199193{
    200194        errno_t rc;
    … …  
    202196
    203197        if (srv->srvs->ops->get_num_blocks == NULL) {
    204                 async_answer_0(chandle, ENOTSUP);
     198                async_answer_0(call, ENOTSUP);
    205199                return;
    206200        }
    207201
    208202        rc = srv->srvs->ops->get_num_blocks(srv, &num_blocks);
    209         async_answer_2(chandle, rc, LOWER32(num_blocks), UPPER32(num_blocks));
     203        async_answer_2(call, rc, LOWER32(num_blocks), UPPER32(num_blocks));
    210204}
    211205
    … …  
    228222}
    229223
    230 errno_t bd_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, bd_srvs_t *srvs)
     224errno_t bd_conn(ipc_call_t *icall, bd_srvs_t *srvs)
    231225{
    232226        bd_srv_t *srv;
    … …  
    234228
    235229        /* Accept the connection */
    236         async_answer_0(icall_handle, EOK);
     230        async_answer_0(icall, EOK);
    237231
    238232        srv = bd_srv_create(srvs);
    … …  
    252246        while (true) {
    253247                ipc_call_t call;
    254                 cap_call_handle_t chandle = async_get_call(&call);
     248                async_get_call(&call);
    255249                sysarg_t method = IPC_GET_IMETHOD(call);
    256250
    257251                if (!method) {
    258252                        /* The other side has hung up */
    259                         async_answer_0(chandle, EOK);
     253                        async_answer_0(&call, EOK);
    260254                        break;
    261255                }
    … …  
    263257                switch (method) {
    264258                case BD_READ_BLOCKS:
    265                         bd_read_blocks_srv(srv, chandle, &call);
     259                        bd_read_blocks_srv(srv, &call);
    266260                        break;
    267261                case BD_READ_TOC:
    268                         bd_read_toc_srv(srv, chandle, &call);
     262                        bd_read_toc_srv(srv, &call);
    269263                        break;
    270264                case BD_SYNC_CACHE:
    271                         bd_sync_cache_srv(srv, chandle, &call);
     265                        bd_sync_cache_srv(srv, &call);
    272266                        break;
    273267                case BD_WRITE_BLOCKS:
    274                         bd_write_blocks_srv(srv, chandle, &call);
     268                        bd_write_blocks_srv(srv, &call);
    275269                        break;
    276270                case BD_GET_BLOCK_SIZE:
    277                         bd_get_block_size_srv(srv, chandle, &call);
     271                        bd_get_block_size_srv(srv, &call);
    278272                        break;
    279273                case BD_GET_NUM_BLOCKS:
    280                         bd_get_num_blocks_srv(srv, chandle, &call);
     274                        bd_get_num_blocks_srv(srv, &call);
    281275                        break;
    282276                default:
    283                         async_answer_0(chandle, EINVAL);
     277                        async_answer_0(&call, EINVAL);
    284278                }
    285279        }
Note: See TracChangeset for help on using the changeset viewer.