Changeset a46e56b in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2018-03-22T06:49:35Z (8 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

Location:
uspace/lib/c/generic
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/bd.c

    r3e242d2 ra46e56b  
    4646#include <offset.h>
    4747
    48 static void bd_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
     48static void bd_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
    4949
    5050errno_t bd_open(async_sess_t *sess, bd_t **rbd)
    … …  
    196196}
    197197
    198 static void bd_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     198static void bd_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    199199{
    200200        bd_t *bd = (bd_t *)arg;
    … …  
    204204        while (true) {
    205205                ipc_call_t call;
    206                 cap_call_handle_t callid = async_get_call(&call);
     206                cap_call_handle_t chandle = async_get_call(&call);
    207207
    208208                if (!IPC_GET_IMETHOD(call)) {
    … …  
    213213                switch (IPC_GET_IMETHOD(call)) {
    214214                default:
    215                         async_answer_0(callid, ENOTSUP);
     215                        async_answer_0(chandle, ENOTSUP);
    216216                }
    217217        }

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

    r3e242d2 ra46e56b  
    4343#include <bd_srv.h>
    4444
    45 static void bd_read_blocks_srv(bd_srv_t *srv, cap_call_handle_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         cap_call_handle_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, cap_call_handle_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         cap_call_handle_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, cap_call_handle_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, cap_call_handle_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, cap_call_handle_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, cap_call_handle_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(cap_call_handle_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                 cap_call_handle_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        }

  • uspace/lib/c/generic/inet.c

    r3e242d2 ra46e56b  
    3636#include <stdlib.h>
    3737
    38 static void inet_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
     38static void inet_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
    3939
    4040static async_sess_t *inet_sess = NULL;
    … …  
    176176}
    177177
    178 static void inet_ev_recv(cap_call_handle_t iid, ipc_call_t *icall)
     178static void inet_ev_recv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    179179{
    180180        inet_dgram_t dgram;
    … …  
    183183        dgram.iplink = IPC_GET_ARG2(*icall);
    184184
    185         cap_call_handle_t callid;
     185        cap_call_handle_t chandle;
    186186        size_t size;
    187         if (!async_data_write_receive(&callid, &size)) {
    188                 async_answer_0(callid, EINVAL);
    189                 async_answer_0(iid, EINVAL);
     187        if (!async_data_write_receive(&chandle, &size)) {
     188                async_answer_0(chandle, EINVAL);
     189                async_answer_0(icall_handle, EINVAL);
    190190                return;
    191191        }
    192192
    193193        if (size != sizeof(inet_addr_t)) {
    194                 async_answer_0(callid, EINVAL);
    195                 async_answer_0(iid, EINVAL);
    196                 return;
    197         }
    198 
    199         errno_t rc = async_data_write_finalize(callid, &dgram.src, size);
    200         if (rc != EOK) {
    201                 async_answer_0(callid, rc);
    202                 async_answer_0(iid, rc);
    203                 return;
    204         }
    205 
    206         if (!async_data_write_receive(&callid, &size)) {
    207                 async_answer_0(callid, EINVAL);
    208                 async_answer_0(iid, EINVAL);
     194                async_answer_0(chandle, EINVAL);
     195                async_answer_0(icall_handle, EINVAL);
     196                return;
     197        }
     198
     199        errno_t rc = async_data_write_finalize(chandle, &dgram.src, size);
     200        if (rc != EOK) {
     201                async_answer_0(chandle, rc);
     202                async_answer_0(icall_handle, rc);
     203                return;
     204        }
     205
     206        if (!async_data_write_receive(&chandle, &size)) {
     207                async_answer_0(chandle, EINVAL);
     208                async_answer_0(icall_handle, EINVAL);
    209209                return;
    210210        }
    211211
    212212        if (size != sizeof(inet_addr_t)) {
    213                 async_answer_0(callid, EINVAL);
    214                 async_answer_0(iid, EINVAL);
    215                 return;
    216         }
    217 
    218         rc = async_data_write_finalize(callid, &dgram.dest, size);
    219         if (rc != EOK) {
    220                 async_answer_0(callid, rc);
    221                 async_answer_0(iid, rc);
     213                async_answer_0(chandle, EINVAL);
     214                async_answer_0(icall_handle, EINVAL);
     215                return;
     216        }
     217
     218        rc = async_data_write_finalize(chandle, &dgram.dest, size);
     219        if (rc != EOK) {
     220                async_answer_0(chandle, rc);
     221                async_answer_0(icall_handle, rc);
    222222                return;
    223223        }
    … …  
    225225        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
    226226        if (rc != EOK) {
    227                 async_answer_0(iid, rc);
     227                async_answer_0(icall_handle, rc);
    228228                return;
    229229        }
    … …  
    231231        rc = inet_ev_ops->recv(&dgram);
    232232        free(dgram.data);
    233         async_answer_0(iid, rc);
    234 }
    235 
    236 static void inet_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     233        async_answer_0(icall_handle, rc);
     234}
     235
     236static void inet_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    237237{
    238238        while (true) {
    239239                ipc_call_t call;
    240                 cap_call_handle_t callid = async_get_call(&call);
     240                cap_call_handle_t chandle = async_get_call(&call);
    241241
    242242                if (!IPC_GET_IMETHOD(call)) {
    … …  
    247247                switch (IPC_GET_IMETHOD(call)) {
    248248                case INET_EV_RECV:
    249                         inet_ev_recv(callid, &call);
     249                        inet_ev_recv(chandle, &call);
    250250                        break;
    251251                default:
    252                         async_answer_0(callid, ENOTSUP);
     252                        async_answer_0(chandle, ENOTSUP);
    253253                }
    254254        }

  • uspace/lib/c/generic/inet/tcp.c

    r3e242d2 ra46e56b  
    637637 * @param icall Call data
    638638 */
    639 static void tcp_ev_connected(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
     639static void tcp_ev_connected(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
    640640{
    641641        tcp_conn_t *conn;
    … …  
    647647        rc = tcp_conn_get(tcp, conn_id, &conn);
    648648        if (rc != EOK) {
    649                 async_answer_0(iid, ENOENT);
     649                async_answer_0(icall_handle, ENOENT);
    650650                return;
    651651        }
    … …  
    656656        fibril_mutex_unlock(&conn->lock);
    657657
    658         async_answer_0(iid, EOK);
     658        async_answer_0(icall_handle, EOK);
    659659}
    660660
    … …  
    665665 * @param icall Call data
    666666 */
    667 static void tcp_ev_conn_failed(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
     667static void tcp_ev_conn_failed(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
    668668{
    669669        tcp_conn_t *conn;
    … …  
    675675        rc = tcp_conn_get(tcp, conn_id, &conn);
    676676        if (rc != EOK) {
    677                 async_answer_0(iid, ENOENT);
     677                async_answer_0(icall_handle, ENOENT);
    678678                return;
    679679        }
    … …  
    684684        fibril_mutex_unlock(&conn->lock);
    685685
    686         async_answer_0(iid, EOK);
     686        async_answer_0(icall_handle, EOK);
    687687}
    688688
    … …  
    693693 * @param icall Call data
    694694 */
    695 static void tcp_ev_conn_reset(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
     695static void tcp_ev_conn_reset(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
    696696{
    697697        tcp_conn_t *conn;
    … …  
    703703        rc = tcp_conn_get(tcp, conn_id, &conn);
    704704        if (rc != EOK) {
    705                 async_answer_0(iid, ENOENT);
     705                async_answer_0(icall_handle, ENOENT);
    706706                return;
    707707        }
    … …  
    712712        fibril_mutex_unlock(&conn->lock);
    713713
    714         async_answer_0(iid, EOK);
     714        async_answer_0(icall_handle, EOK);
    715715}
    716716
    … …  
    721721 * @param icall Call data
    722722 */
    723 static void tcp_ev_data(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
     723static void tcp_ev_data(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
    724724{
    725725        tcp_conn_t *conn;
    … …  
    731731        rc = tcp_conn_get(tcp, conn_id, &conn);
    732732        if (rc != EOK) {
    733                 async_answer_0(iid, ENOENT);
     733                async_answer_0(icall_handle, ENOENT);
    734734                return;
    735735        }
    … …  
    741741                conn->cb->data_avail(conn);
    742742
    743         async_answer_0(iid, EOK);
     743        async_answer_0(icall_handle, EOK);
    744744}
    745745
    … …  
    750750 * @param icall Call data
    751751 */
    752 static void tcp_ev_urg_data(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
    753 {
    754         async_answer_0(iid, ENOTSUP);
     752static void tcp_ev_urg_data(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     753{
     754        async_answer_0(icall_handle, ENOTSUP);
    755755}
    756756
    … …  
    761761 * @param icall Call data
    762762 */
    763 static void tcp_ev_new_conn(tcp_t *tcp, cap_call_handle_t iid, ipc_call_t *icall)
     763static void tcp_ev_new_conn(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
    764764{
    765765        tcp_listener_t *lst;
    … …  
    776776        rc = tcp_listener_get(tcp, lst_id, &lst);
    777777        if (rc != EOK) {
    778                 async_answer_0(iid, ENOENT);
     778                async_answer_0(icall_handle, ENOENT);
    779779                return;
    780780        }
    … …  
    782782        rc = tcp_conn_new(tcp, conn_id, lst->cb, lst->cb_arg, &conn);
    783783        if (rc != EOK) {
    784                 async_answer_0(iid, ENOMEM);
     784                async_answer_0(icall_handle, ENOMEM);
    785785                return;
    786786        }
    … …  
    789789                cinfo = calloc(1, sizeof(tcp_in_conn_t));
    790790                if (cinfo == NULL) {
    791                         async_answer_0(iid, ENOMEM);
     791                        async_answer_0(icall_handle, ENOMEM);
    792792                        return;
    793793                }
    … …  
    798798                fid = fibril_create(tcp_conn_fibril, cinfo);
    799799                if (fid == 0) {
    800                         async_answer_0(iid, ENOMEM);
     800                        async_answer_0(icall_handle, ENOMEM);
    801801                }
    802802
    … …  
    804804        }
    805805
    806         async_answer_0(iid, EOK);
     806        async_answer_0(icall_handle, EOK);
    807807}
    808808
    … …  
    813813 * @param arg Argument, TCP client
    814814 */
    815 static void tcp_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     815static void tcp_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    816816{
    817817        tcp_t *tcp = (tcp_t *)arg;
    818818
    819         async_answer_0(iid, EOK);
     819        async_answer_0(icall_handle, EOK);
    820820
    821821        while (true) {
    822822                ipc_call_t call;
    823                 cap_call_handle_t callid = async_get_call(&call);
     823                cap_call_handle_t chandle = async_get_call(&call);
    824824
    825825                if (!IPC_GET_IMETHOD(call)) {
    … …  
    830830                switch (IPC_GET_IMETHOD(call)) {
    831831                case TCP_EV_CONNECTED:
    832                         tcp_ev_connected(tcp, callid, &call);
     832                        tcp_ev_connected(tcp, chandle, &call);
    833833                        break;
    834834                case TCP_EV_CONN_FAILED:
    835                         tcp_ev_conn_failed(tcp, callid, &call);
     835                        tcp_ev_conn_failed(tcp, chandle, &call);
    836836                        break;
    837837                case TCP_EV_CONN_RESET:
    838                         tcp_ev_conn_reset(tcp, callid, &call);
     838                        tcp_ev_conn_reset(tcp, chandle, &call);
    839839                        break;
    840840                case TCP_EV_DATA:
    841                         tcp_ev_data(tcp, callid, &call);
     841                        tcp_ev_data(tcp, chandle, &call);
    842842                        break;
    843843                case TCP_EV_URG_DATA:
    844                         tcp_ev_urg_data(tcp, callid, &call);
     844                        tcp_ev_urg_data(tcp, chandle, &call);
    845845                        break;
    846846                case TCP_EV_NEW_CONN:
    847                         tcp_ev_new_conn(tcp, callid, &call);
     847                        tcp_ev_new_conn(tcp, chandle, &call);
    848848                        break;
    849849                default:
    850                         async_answer_0(callid, ENOTSUP);
     850                        async_answer_0(chandle, ENOTSUP);
    851851                        break;
    852852                }

  • uspace/lib/c/generic/inet/udp.c

    r3e242d2 ra46e56b  
    455455 * @param icall IPC message
    456456 */
    457 static void udp_ev_data(udp_t *udp, cap_call_handle_t iid, ipc_call_t *icall)
     457static void udp_ev_data(udp_t *udp, cap_call_handle_t icall_handle, ipc_call_t *icall)
    458458{
    459459        udp_rmsg_t rmsg;
    … …  
    481481        }
    482482
    483         async_answer_0(iid, EOK);
     483        async_answer_0(icall_handle, EOK);
    484484}
    485485
    … …  
    490490 * @param arg Argument, UDP client
    491491 */
    492 static void udp_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     492static void udp_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    493493{
    494494        udp_t *udp = (udp_t *)arg;
    495495
    496         async_answer_0(iid, EOK);
     496        async_answer_0(icall_handle, EOK);
    497497
    498498        while (true) {
    499499                ipc_call_t call;
    500                 cap_call_handle_t callid = async_get_call(&call);
     500                cap_call_handle_t chandle = async_get_call(&call);
    501501
    502502                if (!IPC_GET_IMETHOD(call)) {
    … …  
    507507                switch (IPC_GET_IMETHOD(call)) {
    508508                case UDP_EV_DATA:
    509                         udp_ev_data(udp, callid, &call);
     509                        udp_ev_data(udp, chandle, &call);
    510510                        break;
    511511                default:
    512                         async_answer_0(callid, ENOTSUP);
     512                        async_answer_0(chandle, ENOTSUP);
    513513                        break;
    514514                }

  • uspace/lib/c/generic/inetping.c

    r3e242d2 ra46e56b  
    150150}
    151151
    152 static void inetping_ev_recv(cap_call_handle_t iid, ipc_call_t *icall)
     152static void inetping_ev_recv(cap_call_handle_t icall_handle, ipc_call_t *icall)
    153153{
    154154        inetping_sdu_t sdu;
    … …  
    156156        sdu.seq_no = IPC_GET_ARG1(*icall);
    157157
    158         cap_call_handle_t callid;
     158        cap_call_handle_t chandle;
    159159        size_t size;
    160         if (!async_data_write_receive(&callid, &size)) {
    161                 async_answer_0(callid, EREFUSED);
    162                 async_answer_0(iid, EREFUSED);
     160        if (!async_data_write_receive(&chandle, &size)) {
     161                async_answer_0(chandle, EREFUSED);
     162                async_answer_0(icall_handle, EREFUSED);
    163163                return;
    164164        }
    165165
    166166        if (size != sizeof(sdu.src)) {
    167                 async_answer_0(callid, EINVAL);
    168                 async_answer_0(iid, EINVAL);
    169                 return;
    170         }
    171 
    172         errno_t rc = async_data_write_finalize(callid, &sdu.src, size);
    173         if (rc != EOK) {
    174                 async_answer_0(callid, rc);
    175                 async_answer_0(iid, rc);
    176                 return;
    177         }
    178 
    179         if (!async_data_write_receive(&callid, &size)) {
    180                 async_answer_0(callid, EREFUSED);
    181                 async_answer_0(iid, EREFUSED);
     167                async_answer_0(chandle, EINVAL);
     168                async_answer_0(icall_handle, EINVAL);
     169                return;
     170        }
     171
     172        errno_t rc = async_data_write_finalize(chandle, &sdu.src, size);
     173        if (rc != EOK) {
     174                async_answer_0(chandle, rc);
     175                async_answer_0(icall_handle, rc);
     176                return;
     177        }
     178
     179        if (!async_data_write_receive(&chandle, &size)) {
     180                async_answer_0(chandle, EREFUSED);
     181                async_answer_0(icall_handle, EREFUSED);
    182182                return;
    183183        }
    184184
    185185        if (size != sizeof(sdu.dest)) {
    186                 async_answer_0(callid, EINVAL);
    187                 async_answer_0(iid, EINVAL);
    188                 return;
    189         }
    190 
    191         rc = async_data_write_finalize(callid, &sdu.dest, size);
    192         if (rc != EOK) {
    193                 async_answer_0(callid, rc);
    194                 async_answer_0(iid, rc);
     186                async_answer_0(chandle, EINVAL);
     187                async_answer_0(icall_handle, EINVAL);
     188                return;
     189        }
     190
     191        rc = async_data_write_finalize(chandle, &sdu.dest, size);
     192        if (rc != EOK) {
     193                async_answer_0(chandle, rc);
     194                async_answer_0(icall_handle, rc);
    195195                return;
    196196        }
    … …  
    198198        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    199199        if (rc != EOK) {
    200                 async_answer_0(iid, rc);
     200                async_answer_0(icall_handle, rc);
    201201                return;
    202202        }
    … …  
    204204        rc = inetping_ev_ops->recv(&sdu);
    205205        free(sdu.data);
    206         async_answer_0(iid, rc);
    207 }
    208 
    209 static void inetping_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     206        async_answer_0(icall_handle, rc);
     207}
     208
     209static void inetping_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    210210{
    211211        while (true) {
    212212                ipc_call_t call;
    213                 cap_call_handle_t callid = async_get_call(&call);
     213                cap_call_handle_t chandle = async_get_call(&call);
    214214
    215215                if (!IPC_GET_IMETHOD(call)) {
    … …  
    220220                switch (IPC_GET_IMETHOD(call)) {
    221221                case INETPING_EV_RECV:
    222                         inetping_ev_recv(callid, &call);
     222                        inetping_ev_recv(chandle, &call);
    223223                        break;
    224224                default:
    225                         async_answer_0(callid, ENOTSUP);
     225                        async_answer_0(chandle, ENOTSUP);
    226226                }
    227227        }

  • uspace/lib/c/generic/io/chardev_srv.c

    r3e242d2 ra46e56b  
    4343static chardev_srv_t *chardev_srv_create(chardev_srvs_t *);
    4444
    45 static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t callid,
     45static void chardev_read_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
    4646    ipc_call_t *call)
    4747{
    … …  
    5050        size_t nread;
    5151        errno_t rc;
    52         cap_call_handle_t rcallid;
     52        cap_call_handle_t rcall_handle;
    5353
    54         if (!async_data_read_receive(&rcallid, &size)) {
    55                 async_answer_0(callid, EINVAL);
     54        if (!async_data_read_receive(&rcall_handle, &size)) {
     55                async_answer_0(chandle, EINVAL);
    5656                return;
    5757        }
    … …  
    5959        buf = malloc(size);
    6060        if (buf == NULL) {
    61                 async_answer_0(rcallid, ENOMEM);
    62                 async_answer_0(callid, ENOMEM);
     61                async_answer_0(rcall_handle, ENOMEM);
     62                async_answer_0(chandle, ENOMEM);
    6363                return;
    6464        }
    6565
    6666        if (srv->srvs->ops->read == NULL) {
    67                 async_answer_0(rcallid, ENOTSUP);
    68                 async_answer_0(callid, ENOTSUP);
     67                async_answer_0(rcall_handle, ENOTSUP);
     68                async_answer_0(chandle, ENOTSUP);
    6969                free(buf);
    7070                return;
    … …  
    7373        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    7474        if (rc != EOK && nread == 0) {
    75                 async_answer_0(rcallid, rc);
    76                 async_answer_0(callid, rc);
     75                async_answer_0(rcall_handle, rc);
     76                async_answer_0(chandle, rc);
    7777                free(buf);
    7878                return;
    7979        }
    8080
    81         async_data_read_finalize(rcallid, buf, nread);
     81        async_data_read_finalize(rcall_handle, buf, nread);
    8282
    8383        free(buf);
    84         async_answer_2(callid, EOK, (sysarg_t) rc, nread);
     84        async_answer_2(chandle, EOK, (sysarg_t) rc, nread);
    8585}
    8686
    87 static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t callid,
     87static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
    8888    ipc_call_t *call)
    8989{
    … …  
    9595        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    9696        if (rc != EOK) {
    97                 async_answer_0(callid, rc);
     97                async_answer_0(chandle, rc);
    9898                return;
    9999        }
    100100
    101101        if (srv->srvs->ops->write == NULL) {
    102                 async_answer_0(callid, ENOTSUP);
     102                async_answer_0(chandle, ENOTSUP);
    103103                return;
    104104        }
    … …  
    107107        free(data);
    108108        if (rc != EOK && nwr == 0) {
    109                 async_answer_0(callid, rc);
     109                async_answer_0(chandle, rc);
    110110                return;
    111111        }
    112112
    113         async_answer_2(callid, EOK, (sysarg_t) rc, nwr);
     113        async_answer_2(chandle, EOK, (sysarg_t) rc, nwr);
    114114}
    115115
    … …  
    132132}
    133133
    134 errno_t chardev_conn(cap_call_handle_t iid, ipc_call_t *icall, chardev_srvs_t *srvs)
     134errno_t chardev_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, chardev_srvs_t *srvs)
    135135{
    136136        chardev_srv_t *srv;
    … …  
    138138
    139139        /* Accept the connection */
    140         async_answer_0(iid, EOK);
     140        async_answer_0(icall_handle, EOK);
    141141
    142142        srv = chardev_srv_create(srvs);
    … …  
    152152        while (true) {
    153153                ipc_call_t call;
    154                 cap_call_handle_t callid = async_get_call(&call);
     154                cap_call_handle_t chandle = async_get_call(&call);
    155155                sysarg_t method = IPC_GET_IMETHOD(call);
    156156
    157157                if (!method) {
    158158                        /* The other side has hung up */
    159                         async_answer_0(callid, EOK);
     159                        async_answer_0(chandle, EOK);
    160160                        break;
    161161                }
    … …  
    163163                switch (method) {
    164164                case CHARDEV_READ:
    165                         chardev_read_srv(srv, callid, &call);
     165                        chardev_read_srv(srv, chandle, &call);
    166166                        break;
    167167                case CHARDEV_WRITE:
    168                         chardev_write_srv(srv, callid, &call);
     168                        chardev_write_srv(srv, chandle, &call);
    169169                        break;
    170170                default:
    171171                        if (srv->srvs->ops->def_handler != NULL)
    172                                 srv->srvs->ops->def_handler(srv, callid, &call);
     172                                srv->srvs->ops->def_handler(srv, chandle, &call);
    173173                        else
    174                                 async_answer_0(callid, ENOTSUP);
     174                                async_answer_0(chandle, ENOTSUP);
    175175                }
    176176        }

  • uspace/lib/c/generic/io/con_srv.c

    r3e242d2 ra46e56b  
    6666}
    6767
    68 static void con_read_srv(con_srv_t *srv, cap_call_handle_t callid,
     68static void con_read_srv(con_srv_t *srv, cap_call_handle_t chandle,
    6969    ipc_call_t *call)
    7070{
    … …  
    7272        size_t size;
    7373        errno_t rc;
    74         cap_call_handle_t rcallid;
    75 
    76         if (!async_data_read_receive(&rcallid, &size)) {
    77                 async_answer_0(callid, EINVAL);
     74        cap_call_handle_t rcall_handle;
     75
     76        if (!async_data_read_receive(&rcall_handle, &size)) {
     77                async_answer_0(chandle, EINVAL);
    7878                return;
    7979        }
    … …  
    8181        buf = malloc(size);
    8282        if (buf == NULL) {
    83                 async_answer_0(rcallid, ENOMEM);
    84                 async_answer_0(callid, ENOMEM);
     83                async_answer_0(rcall_handle, ENOMEM);
     84                async_answer_0(chandle, ENOMEM);
    8585                return;
    8686        }
    8787
    8888        if (srv->srvs->ops->read == NULL) {
    89                 async_answer_0(rcallid, ENOTSUP);
    90                 async_answer_0(callid, ENOTSUP);
     89                async_answer_0(rcall_handle, ENOTSUP);
     90                async_answer_0(chandle, ENOTSUP);
    9191                free(buf);
    9292                return;
    … …  
    9696        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    9797        if (rc != EOK) {
    98                 async_answer_0(rcallid, rc);
    99                 async_answer_0(callid, rc);
     98                async_answer_0(rcall_handle, rc);
     99                async_answer_0(chandle, rc);
    100100                free(buf);
    101101                return;
    102102        }
    103103
    104         async_data_read_finalize(rcallid, buf, nread);
     104        async_data_read_finalize(rcall_handle, buf, nread);
    105105        free(buf);
    106106
    107         async_answer_1(callid, EOK, nread);
    108 }
    109 
    110 static void con_write_srv(con_srv_t *srv, cap_call_handle_t callid,
     107        async_answer_1(chandle, EOK, nread);
     108}
     109
     110static void con_write_srv(con_srv_t *srv, cap_call_handle_t chandle,
    111111    ipc_call_t *call)
    112112{
    … …  
    117117        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    118118        if (rc != EOK) {
    119                 async_answer_0(callid, rc);
     119                async_answer_0(chandle, rc);
    120120                return;
    121121        }
    122122
    123123        if (srv->srvs->ops->write == NULL) {
    124                 async_answer_0(callid, ENOTSUP);
     124                async_answer_0(chandle, ENOTSUP);
    125125                return;
    126126        }
    … …  
    130130        free(data);
    131131
    132         async_answer_1(callid, rc, nwritten);
    133 }
    134 
    135 static void con_sync_srv(con_srv_t *srv, cap_call_handle_t callid,
     132        async_answer_1(chandle, rc, nwritten);
     133}
     134
     135static void con_sync_srv(con_srv_t *srv, cap_call_handle_t chandle,
    136136    ipc_call_t *call)
    137137{
    138138        if (srv->srvs->ops->sync == NULL) {
    139                 async_answer_0(callid, ENOTSUP);
     139                async_answer_0(chandle, ENOTSUP);
    140140                return;
    141141        }
    142142
    143143        srv->srvs->ops->sync(srv);
    144         async_answer_0(callid, EOK);
    145 }
    146 
    147 static void con_clear_srv(con_srv_t *srv, cap_call_handle_t callid,
     144        async_answer_0(chandle, EOK);
     145}
     146
     147static void con_clear_srv(con_srv_t *srv, cap_call_handle_t chandle,
    148148    ipc_call_t *call)
    149149{
    150150        if (srv->srvs->ops->clear == NULL) {
    151                 async_answer_0(callid, ENOTSUP);
     151                async_answer_0(chandle, ENOTSUP);
    152152                return;
    153153        }
    154154
    155155        srv->srvs->ops->clear(srv);
    156         async_answer_0(callid, EOK);
    157 }
    158 
    159 static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
     156        async_answer_0(chandle, EOK);
     157}
     158
     159static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    160160    ipc_call_t *call)
    161161{
    … …  
    167167
    168168        if (srv->srvs->ops->set_pos == NULL) {
    169                 async_answer_0(callid, ENOTSUP);
     169                async_answer_0(chandle, ENOTSUP);
    170170                return;
    171171        }
    172172
    173173        srv->srvs->ops->set_pos(srv, col, row);
    174         async_answer_0(callid, EOK);
    175 }
    176 
    177 static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t callid,
     174        async_answer_0(chandle, EOK);
     175}
     176
     177static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    178178    ipc_call_t *call)
    179179{
    … …  
    183183
    184184        if (srv->srvs->ops->get_pos == NULL) {
    185                 async_answer_0(callid, ENOTSUP);
     185                async_answer_0(chandle, ENOTSUP);
    186186                return;
    187187        }
    188188
    189189        rc = srv->srvs->ops->get_pos(srv, &col, &row);
    190         async_answer_2(callid, rc, col, row);
    191 }
    192 
    193 static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t callid,
     190        async_answer_2(chandle, rc, col, row);
     191}
     192
     193static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t chandle,
    194194    ipc_call_t *call)
    195195{
    … …  
    199199
    200200        if (srv->srvs->ops->get_size == NULL) {
    201                 async_answer_0(callid, ENOTSUP);
     201                async_answer_0(chandle, ENOTSUP);
    202202                return;
    203203        }
    204204
    205205        rc = srv->srvs->ops->get_size(srv, &cols, &rows);
    206         async_answer_2(callid, rc, cols, rows);
    207 }
    208 
    209 static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t callid,
     206        async_answer_2(chandle, rc, cols, rows);
     207}
     208
     209static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t chandle,
    210210    ipc_call_t *call)
    211211{
    … …  
    214214
    215215        if (srv->srvs->ops->get_color_cap == NULL) {
    216                 async_answer_0(callid, ENOTSUP);
     216                async_answer_0(chandle, ENOTSUP);
    217217                return;
    218218        }
    219219
    220220        rc = srv->srvs->ops->get_color_cap(srv, &ccap);
    221         async_answer_1(callid, rc, (sysarg_t)ccap);
    222 }
    223 
    224 static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t callid,
     221        async_answer_1(chandle, rc, (sysarg_t)ccap);
     222}
     223
     224static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t chandle,
    225225    ipc_call_t *call)
    226226{
    … …  
    230230
    231231        if (srv->srvs->ops->set_style == NULL) {
    232                 async_answer_0(callid, ENOTSUP);
     232                async_answer_0(chandle, ENOTSUP);
    233233                return;
    234234        }
    235235
    236236        srv->srvs->ops->set_style(srv, style);
    237         async_answer_0(callid, EOK);
    238 }
    239 
    240 static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t callid,
     237        async_answer_0(chandle, EOK);
     238}
     239
     240static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    241241    ipc_call_t *call)
    242242{
    … …  
    250250
    251251        if (srv->srvs->ops->set_color == NULL) {
    252                 async_answer_0(callid, ENOTSUP);
     252                async_answer_0(chandle, ENOTSUP);
    253253                return;
    254254        }
    255255
    256256        srv->srvs->ops->set_color(srv, bgcolor, fgcolor, flags);
    257         async_answer_0(callid, EOK);
    258 }
    259 
    260 static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t callid,
     257        async_answer_0(chandle, EOK);
     258}
     259
     260static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    261261    ipc_call_t *call)
    262262{
    … …  
    268268
    269269        if (srv->srvs->ops->set_rgb_color == NULL) {
    270                 async_answer_0(callid, ENOTSUP);
     270                async_answer_0(chandle, ENOTSUP);
    271271                return;
    272272        }
    273273
    274274        srv->srvs->ops->set_rgb_color(srv, bgcolor, fgcolor);
    275         async_answer_0(callid, EOK);
    276 }
    277 
    278 static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t callid,
     275        async_answer_0(chandle, EOK);
     276}
     277
     278static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t chandle,
    279279    ipc_call_t *call)
    280280{
    … …  
    284284
    285285        if (srv->srvs->ops->set_cursor_visibility == NULL) {
    286                 async_answer_0(callid, ENOTSUP);
     286                async_answer_0(chandle, ENOTSUP);
    287287                return;
    288288        }
    289289
    290290        srv->srvs->ops->set_cursor_visibility(srv, show);
    291         async_answer_0(callid, EOK);
    292 }
    293 
    294 static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t callid,
     291        async_answer_0(chandle, EOK);
     292}
     293
     294static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t chandle,
    295295    ipc_call_t *call)
    296296{
    … …  
    300300
    301301        if (srv->srvs->ops->get_event == NULL) {
    302                 async_answer_0(callid, ENOTSUP);
     302                async_answer_0(chandle, ENOTSUP);
    303303                return;
    304304        }
    … …  
    306306        rc = srv->srvs->ops->get_event(srv, &event);
    307307        if (rc != EOK) {
    308                 async_answer_0(callid, rc);
     308                async_answer_0(chandle, rc);
    309309                return;
    310310        }
    … …  
    312312        rc = console_ev_encode(&event, &result);
    313313        if (rc != EOK) {
    314                 async_answer_0(callid, rc);
    315                 return;
    316         }
    317 
    318         async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
     314                async_answer_0(chandle, rc);
     315                return;
     316        }
     317
     318        async_answer_5(chandle, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
    319319            IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
    320320}
    … …  
    340340}
    341341
    342 errno_t con_conn(cap_call_handle_t iid, ipc_call_t *icall, con_srvs_t *srvs)
     342errno_t con_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, con_srvs_t *srvs)
    343343{
    344344        con_srv_t *srv;
    … …  
    346346
    347347        /* Accept the connection */
    348         async_answer_0(iid, EOK);
     348        async_answer_0(icall_handle, EOK);
    349349
    350350        srv = con_srv_create(srvs);
    … …  
    366366        while (true) {
    367367                ipc_call_t call;
    368                 cap_call_handle_t callid = 0;
    369 
    370                 while (callid == 0) {
     368                cap_call_handle_t chandle = 0;
     369
     370                while (chandle == 0) {
    371371                        /* XXX Need to be able to abort immediately */
    372                         callid = async_get_call_timeout(&call,
     372                        chandle = async_get_call_timeout(&call,
    373373                            srvs->abort_timeout);
    374374
    375375                        if (srv->srvs->aborted) {
    376                                 if (callid != 0)
    377                                         async_answer_0(callid, EINTR);
     376                                if (chandle != 0)
     377                                        async_answer_0(chandle, EINTR);
    378378                                break;
    379379                        }
    380380                }
    381381
    382                 if (callid == 0)
     382                if (chandle == 0)
    383383                        break;
    384384
    … …  
    387387                if (!method) {
    388388                        /* The other side has hung up */
    389                         async_answer_0(callid, EOK);
     389                        async_answer_0(chandle, EOK);
    390390                        break;
    391391                }
    … …  
    393393                switch (method) {
    394394                case VFS_OUT_READ:
    395                         con_read_srv(srv, callid, &call);
     395                        con_read_srv(srv, chandle, &call);
    396396                        break;
    397397                case VFS_OUT_WRITE:
    398                         con_write_srv(srv, callid, &call);
     398                        con_write_srv(srv, chandle, &call);
    399399                        break;
    400400                case VFS_OUT_SYNC:
    401                         con_sync_srv(srv, callid, &call);
     401                        con_sync_srv(srv, chandle, &call);
    402402                        break;
    403403                case CONSOLE_CLEAR:
    404                         con_clear_srv(srv, callid, &call);
     404                        con_clear_srv(srv, chandle, &call);
    405405                        break;
    406406                case CONSOLE_SET_POS:
    407                         con_set_pos_srv(srv, callid, &call);
     407                        con_set_pos_srv(srv, chandle, &call);
    408408                        break;
    409409                case CONSOLE_GET_POS:
    410                         con_get_pos_srv(srv, callid, &call);
     410                        con_get_pos_srv(srv, chandle, &call);
    411411                        break;
    412412                case CONSOLE_GET_SIZE:
    413                         con_get_size_srv(srv, callid, &call);
     413                        con_get_size_srv(srv, chandle, &call);
    414414                        break;
    415415                case CONSOLE_GET_COLOR_CAP:
    416                         con_get_color_cap_srv(srv, callid, &call);
     416                        con_get_color_cap_srv(srv, chandle, &call);
    417417                        break;
    418418                case CONSOLE_SET_STYLE:
    419                         con_set_style_srv(srv, callid, &call);
     419                        con_set_style_srv(srv, chandle, &call);
    420420                        break;
    421421                case CONSOLE_SET_COLOR:
    422                         con_set_color_srv(srv, callid, &call);
     422                        con_set_color_srv(srv, chandle, &call);
    423423                        break;
    424424                case CONSOLE_SET_RGB_COLOR:
    425                         con_set_rgb_color_srv(srv, callid, &call);
     425                        con_set_rgb_color_srv(srv, chandle, &call);
    426426                        break;
    427427                case CONSOLE_SET_CURSOR_VISIBILITY:
    428                         con_set_cursor_visibility_srv(srv, callid, &call);
     428                        con_set_cursor_visibility_srv(srv, chandle, &call);
    429429                        break;
    430430                case CONSOLE_GET_EVENT:
    431                         con_get_event_srv(srv, callid, &call);
     431                        con_get_event_srv(srv, chandle, &call);
    432432                        break;
    433433                default:
    434                         async_answer_0(callid, ENOTSUP);
     434                        async_answer_0(chandle, ENOTSUP);
    435435                }
    436436        }

  • uspace/lib/c/generic/io/input.c

    r3e242d2 ra46e56b  
    4343#include <stdlib.h>
    4444
    45 static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
     45static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
    4646
    4747errno_t input_open(async_sess_t *sess, input_ev_ops_t *ev_ops,
    … …  
    9292}
    9393
    94 static void input_ev_active(input_t *input, cap_call_handle_t callid,
     94static void input_ev_active(input_t *input, cap_call_handle_t chandle,
    9595    ipc_call_t *call)
    9696{
    9797        errno_t rc = input->ev_ops->active(input);
    98         async_answer_0(callid, rc);
    99 }
    100 
    101 static void input_ev_deactive(input_t *input, cap_call_handle_t callid,
     98        async_answer_0(chandle, rc);
     99}
     100
     101static void input_ev_deactive(input_t *input, cap_call_handle_t chandle,
    102102    ipc_call_t *call)
    103103{
    104104        errno_t rc = input->ev_ops->deactive(input);
    105         async_answer_0(callid, rc);
    106 }
    107 
    108 static void input_ev_key(input_t *input, cap_call_handle_t callid,
     105        async_answer_0(chandle, rc);
     106}
     107
     108static void input_ev_key(input_t *input, cap_call_handle_t chandle,
    109109    ipc_call_t *call)
    110110{
    … …  
    121121
    122122        rc = input->ev_ops->key(input, type, key, mods, c);
    123         async_answer_0(callid, rc);
    124 }
    125 
    126 static void input_ev_move(input_t *input, cap_call_handle_t callid,
     123        async_answer_0(chandle, rc);
     124}
     125
     126static void input_ev_move(input_t *input, cap_call_handle_t chandle,
    127127    ipc_call_t *call)
    128128{
    … …  
    135135
    136136        rc = input->ev_ops->move(input, dx, dy);
    137         async_answer_0(callid, rc);
    138 }
    139 
    140 static void input_ev_abs_move(input_t *input, cap_call_handle_t callid,
     137        async_answer_0(chandle, rc);
     138}
     139
     140static void input_ev_abs_move(input_t *input, cap_call_handle_t chandle,
    141141    ipc_call_t *call)
    142142{
    … …  
    153153
    154154        rc = input->ev_ops->abs_move(input, x, y, max_x, max_y);
    155         async_answer_0(callid, rc);
    156 }
    157 
    158 static void input_ev_button(input_t *input, cap_call_handle_t callid,
     155        async_answer_0(chandle, rc);
     156}
     157
     158static void input_ev_button(input_t *input, cap_call_handle_t chandle,
    159159    ipc_call_t *call)
    160160{
    … …  
    167167
    168168        rc = input->ev_ops->button(input, bnum, press);
    169         async_answer_0(callid, rc);
    170 }
    171 
    172 static void input_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     169        async_answer_0(chandle, rc);
     170}
     171
     172static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    173173{
    174174        input_t *input = (input_t *)arg;
    … …  
    176176        while (true) {
    177177                ipc_call_t call;
    178                 cap_call_handle_t callid = async_get_call(&call);
     178                cap_call_handle_t chandle = async_get_call(&call);
    179179
    180180                if (!IPC_GET_IMETHOD(call)) {
    … …  
    185185                switch (IPC_GET_IMETHOD(call)) {
    186186                case INPUT_EVENT_ACTIVE:
    187                         input_ev_active(input, callid, &call);
     187                        input_ev_active(input, chandle, &call);
    188188                        break;
    189189                case INPUT_EVENT_DEACTIVE:
    190                         input_ev_deactive(input, callid, &call);
     190                        input_ev_deactive(input, chandle, &call);
    191191                        break;
    192192                case INPUT_EVENT_KEY:
    193                         input_ev_key(input, callid, &call);
     193                        input_ev_key(input, chandle, &call);
    194194                        break;
    195195                case INPUT_EVENT_MOVE:
    196                         input_ev_move(input, callid, &call);
     196                        input_ev_move(input, chandle, &call);
    197197                        break;
    198198                case INPUT_EVENT_ABS_MOVE:
    199                         input_ev_abs_move(input, callid, &call);
     199                        input_ev_abs_move(input, chandle, &call);
    200200                        break;
    201201                case INPUT_EVENT_BUTTON:
    202                         input_ev_button(input, callid, &call);
     202                        input_ev_button(input, chandle, &call);
    203203                        break;
    204204                default:
    205                         async_answer_0(callid, ENOTSUP);
     205                        async_answer_0(chandle, ENOTSUP);
    206206                }
    207207        }

  • uspace/lib/c/generic/iplink.c

    r3e242d2 ra46e56b  
    4545#include <stdlib.h>
    4646
    47 static void iplink_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg);
     47static void iplink_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
    4848
    4949errno_t iplink_open(async_sess_t *sess, iplink_ev_ops_t *ev_ops, void *arg,
    … …  
    245245}
    246246
    247 static void iplink_ev_recv(iplink_t *iplink, cap_call_handle_t iid,
     247static void iplink_ev_recv(iplink_t *iplink, cap_call_handle_t icall_handle,
    248248    ipc_call_t *icall)
    249249{
    … …  
    255255            &sdu.size);
    256256        if (rc != EOK) {
    257                 async_answer_0(iid, rc);
     257                async_answer_0(icall_handle, rc);
    258258                return;
    259259        }
    … …  
    261261        rc = iplink->ev_ops->recv(iplink, &sdu, ver);
    262262        free(sdu.data);
    263         async_answer_0(iid, rc);
    264 }
    265 
    266 static void iplink_ev_change_addr(iplink_t *iplink, cap_call_handle_t iid,
     263        async_answer_0(icall_handle, rc);
     264}
     265
     266static void iplink_ev_change_addr(iplink_t *iplink, cap_call_handle_t icall_handle,
    267267    ipc_call_t *icall)
    268268{
    … …  
    273273            sizeof(addr48_t), sizeof(addr48_t), 0, &size);
    274274        if (rc != EOK) {
    275                 async_answer_0(iid, rc);
     275                async_answer_0(icall_handle, rc);
    276276                return;
    277277        }
    … …  
    279279        rc = iplink->ev_ops->change_addr(iplink, *addr);
    280280        free(addr);
    281         async_answer_0(iid, EOK);
    282 }
    283 
    284 static void iplink_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     281        async_answer_0(icall_handle, EOK);
     282}
     283
     284static void iplink_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    285285{
    286286        iplink_t *iplink = (iplink_t *) arg;
    … …  
    288288        while (true) {
    289289                ipc_call_t call;
    290                 cap_call_handle_t callid = async_get_call(&call);
     290                cap_call_handle_t chandle = async_get_call(&call);
    291291
    292292                if (!IPC_GET_IMETHOD(call)) {
    … …  
    297297                switch (IPC_GET_IMETHOD(call)) {
    298298                case IPLINK_EV_RECV:
    299                         iplink_ev_recv(iplink, callid, &call);
     299                        iplink_ev_recv(iplink, chandle, &call);
    300300                        break;
    301301                case IPLINK_EV_CHANGE_ADDR:
    302                         iplink_ev_change_addr(iplink, callid, &call);
     302                        iplink_ev_change_addr(iplink, chandle, &call);
    303303                        break;
    304304                default:
    305                         async_answer_0(callid, ENOTSUP);
     305                        async_answer_0(chandle, ENOTSUP);
    306306                }
    307307        }

  • uspace/lib/c/generic/iplink_srv.c

    r3e242d2 ra46e56b  
    4242#include <inet/iplink_srv.h>
    4343
    44 static void iplink_get_mtu_srv(iplink_srv_t *srv, cap_call_handle_t callid,
     44static void iplink_get_mtu_srv(iplink_srv_t *srv, cap_call_handle_t chandle,
    4545    ipc_call_t *call)
    4646{
    4747        size_t mtu;
    4848        errno_t rc = srv->ops->get_mtu(srv, &mtu);
    49         async_answer_1(callid, rc, mtu);
    50 }
    51 
    52 static void iplink_get_mac48_srv(iplink_srv_t *srv, cap_call_handle_t iid,
     49        async_answer_1(chandle, rc, mtu);
     50}
     51
     52static void iplink_get_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    5353    ipc_call_t *icall)
    5454{
    … …  
    5656        errno_t rc = srv->ops->get_mac48(srv, &mac);
    5757        if (rc != EOK) {
    58                 async_answer_0(iid, rc);
    59                 return;
    60         }
    61 
    62         cap_call_handle_t callid;
    63         size_t size;
    64         if (!async_data_read_receive(&callid, &size)) {
    65                 async_answer_0(callid, EREFUSED);
    66                 async_answer_0(iid, EREFUSED);
     58                async_answer_0(icall_handle, rc);
     59                return;
     60        }
     61
     62        cap_call_handle_t chandle;
     63        size_t size;
     64        if (!async_data_read_receive(&chandle, &size)) {
     65                async_answer_0(chandle, EREFUSED);
     66                async_answer_0(icall_handle, EREFUSED);
    6767                return;
    6868        }
    6969
    7070        if (size != sizeof(addr48_t)) {
    71                 async_answer_0(callid, EINVAL);
    72                 async_answer_0(iid, EINVAL);
    73                 return;
    74         }
    75 
    76         rc = async_data_read_finalize(callid, &mac, size);
     71                async_answer_0(chandle, EINVAL);
     72                async_answer_0(icall_handle, EINVAL);
     73                return;
     74        }
     75
     76        rc = async_data_read_finalize(chandle, &mac, size);
    7777        if (rc != EOK)
    78                 async_answer_0(callid, rc);
    79 
    80         async_answer_0(iid, rc);
    81 }
    82 
    83 static void iplink_set_mac48_srv(iplink_srv_t *srv, cap_call_handle_t iid,
     78                async_answer_0(chandle, rc);
     79
     80        async_answer_0(icall_handle, rc);
     81}
     82
     83static void iplink_set_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    8484    ipc_call_t *icall)
    8585{
    … …  
    8787        size_t size;
    8888        addr48_t mac;
    89         cap_call_handle_t callid;
    90 
    91         if (!async_data_write_receive(&callid, &size)) {
    92                 async_answer_0(callid, EREFUSED);
    93                 async_answer_0(iid, EREFUSED);
     89        cap_call_handle_t chandle;
     90
     91        if (!async_data_write_receive(&chandle, &size)) {
     92                async_answer_0(chandle, EREFUSED);
     93                async_answer_0(icall_handle, EREFUSED);
    9494        }
    9595
    9696        rc = srv->ops->set_mac48(srv, &mac);
    9797        if (rc != EOK) {
    98                 async_answer_0(iid, rc);
    99                 return;
    100         }
    101 
    102         rc = async_data_read_finalize(callid, &mac, sizeof(addr48_t));
     98                async_answer_0(icall_handle, rc);
     99                return;
     100        }
     101
     102        rc = async_data_read_finalize(chandle, &mac, sizeof(addr48_t));
    103103        if (rc != EOK)
    104                 async_answer_0(callid, rc);
    105 
    106         async_answer_0(iid, rc);
    107 }
    108 
    109 static void iplink_addr_add_srv(iplink_srv_t *srv, cap_call_handle_t iid,
    110     ipc_call_t *icall)
    111 {
    112         cap_call_handle_t callid;
    113         size_t size;
    114         if (!async_data_write_receive(&callid, &size)) {
    115                 async_answer_0(callid, EREFUSED);
    116                 async_answer_0(iid, EREFUSED);
     104                async_answer_0(chandle, rc);
     105
     106        async_answer_0(icall_handle, rc);
     107}
     108
     109static void iplink_addr_add_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
     110    ipc_call_t *icall)
     111{
     112        cap_call_handle_t chandle;
     113        size_t size;
     114        if (!async_data_write_receive(&chandle, &size)) {
     115                async_answer_0(chandle, EREFUSED);
     116                async_answer_0(icall_handle, EREFUSED);
    117117                return;
    118118        }
    119119
    120120        if (size != sizeof(inet_addr_t)) {
    121                 async_answer_0(callid, EINVAL);
    122                 async_answer_0(iid, EINVAL);
     121                async_answer_0(chandle, EINVAL);
     122                async_answer_0(icall_handle, EINVAL);
    123123                return;
    124124        }
    125125
    126126        inet_addr_t addr;
    127         errno_t rc = async_data_write_finalize(callid, &addr, size);
    128         if (rc != EOK) {
    129                 async_answer_0(callid, rc);
    130                 async_answer_0(iid, rc);
     127        errno_t rc = async_data_write_finalize(chandle, &addr, size);
     128        if (rc != EOK) {
     129                async_answer_0(chandle, rc);
     130                async_answer_0(icall_handle, rc);
    131131        }
    132132
    133133        rc = srv->ops->addr_add(srv, &addr);
    134         async_answer_0(iid, rc);
    135 }
    136 
    137 static void iplink_addr_remove_srv(iplink_srv_t *srv, cap_call_handle_t iid,
    138     ipc_call_t *icall)
    139 {
    140         cap_call_handle_t callid;
    141         size_t size;
    142         if (!async_data_write_receive(&callid, &size)) {
    143                 async_answer_0(callid, EREFUSED);
    144                 async_answer_0(iid, EREFUSED);
     134        async_answer_0(icall_handle, rc);
     135}
     136
     137static void iplink_addr_remove_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
     138    ipc_call_t *icall)
     139{
     140        cap_call_handle_t chandle;
     141        size_t size;
     142        if (!async_data_write_receive(&chandle, &size)) {
     143                async_answer_0(chandle, EREFUSED);
     144                async_answer_0(icall_handle, EREFUSED);
    145145                return;
    146146        }
    147147
    148148        if (size != sizeof(inet_addr_t)) {
    149                 async_answer_0(callid, EINVAL);
    150                 async_answer_0(iid, EINVAL);
     149                async_answer_0(chandle, EINVAL);
     150                async_answer_0(icall_handle, EINVAL);
    151151                return;
    152152        }
    153153
    154154        inet_addr_t addr;
    155         errno_t rc = async_data_write_finalize(callid, &addr, size);
    156         if (rc != EOK) {
    157                 async_answer_0(callid, rc);
    158                 async_answer_0(iid, rc);
     155        errno_t rc = async_data_write_finalize(chandle, &addr, size);
     156        if (rc != EOK) {
     157                async_answer_0(chandle, rc);
     158                async_answer_0(icall_handle, rc);
    159159        }
    160160
    161161        rc = srv->ops->addr_remove(srv, &addr);
    162         async_answer_0(iid, rc);
    163 }
    164 
    165 static void iplink_send_srv(iplink_srv_t *srv, cap_call_handle_t iid,
     162        async_answer_0(icall_handle, rc);
     163}
     164
     165static void iplink_send_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    166166    ipc_call_t *icall)
    167167{
    … …  
    174174            &sdu.size);
    175175        if (rc != EOK) {
    176                 async_answer_0(iid, rc);
     176                async_answer_0(icall_handle, rc);
    177177                return;
    178178        }
    … …  
    180180        rc = srv->ops->send(srv, &sdu);
    181181        free(sdu.data);
    182         async_answer_0(iid, rc);
    183 }
    184 
    185 static void iplink_send6_srv(iplink_srv_t *srv, cap_call_handle_t iid,
     182        async_answer_0(icall_handle, rc);
     183}
     184
     185static void iplink_send6_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    186186    ipc_call_t *icall)
    187187{
    188188        iplink_sdu6_t sdu;
    189189
    190         cap_call_handle_t callid;
    191         size_t size;
    192         if (!async_data_write_receive(&callid, &size)) {
    193                 async_answer_0(callid, EREFUSED);
    194                 async_answer_0(iid, EREFUSED);
     190        cap_call_handle_t chandle;
     191        size_t size;
     192        if (!async_data_write_receive(&chandle, &size)) {
     193                async_answer_0(chandle, EREFUSED);
     194                async_answer_0(icall_handle, EREFUSED);
    195195                return;
    196196        }
    197197
    198198        if (size != sizeof(addr48_t)) {
    199                 async_answer_0(callid, EINVAL);
    200                 async_answer_0(iid, EINVAL);
    201                 return;
    202         }
    203 
    204         errno_t rc = async_data_write_finalize(callid, &sdu.dest, size);
    205         if (rc != EOK) {
    206                 async_answer_0(callid, rc);
    207                 async_answer_0(iid, rc);
     199                async_answer_0(chandle, EINVAL);
     200                async_answer_0(icall_handle, EINVAL);
     201                return;
     202        }
     203
     204        errno_t rc = async_data_write_finalize(chandle, &sdu.dest, size);
     205        if (rc != EOK) {
     206                async_answer_0(chandle, rc);
     207                async_answer_0(icall_handle, rc);
    208208        }
    209209
    … …  
    211211            &sdu.size);
    212212        if (rc != EOK) {
    213                 async_answer_0(iid, rc);
     213                async_answer_0(icall_handle, rc);
    214214                return;
    215215        }
    … …  
    217217        rc = srv->ops->send6(srv, &sdu);
    218218        free(sdu.data);
    219         async_answer_0(iid, rc);
     219        async_answer_0(icall_handle, rc);
    220220}
    221221
    … …  
    229229}
    230230
    231 errno_t iplink_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     231errno_t iplink_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    232232{
    233233        iplink_srv_t *srv = (iplink_srv_t *) arg;
    … …  
    237237        if (srv->connected) {
    238238                fibril_mutex_unlock(&srv->lock);
    239                 async_answer_0(iid, EBUSY);
     239                async_answer_0(icall_handle, EBUSY);
    240240                return EBUSY;
    241241        }
    … …  
    245245
    246246        /* Accept the connection */
    247         async_answer_0(iid, EOK);
     247        async_answer_0(icall_handle, EOK);
    248248
    249249        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    … …  
    259259        while (true) {
    260260                ipc_call_t call;
    261                 cap_call_handle_t callid = async_get_call(&call);
     261                cap_call_handle_t chandle = async_get_call(&call);
    262262                sysarg_t method = IPC_GET_IMETHOD(call);
    263263
    … …  
    267267                        srv->connected = false;
    268268                        fibril_mutex_unlock(&srv->lock);
    269                         async_answer_0(callid, EOK);
     269                        async_answer_0(chandle, EOK);
    270270                        break;
    271271                }
    … …  
    273273                switch (method) {
    274274                case IPLINK_GET_MTU:
    275                         iplink_get_mtu_srv(srv, callid, &call);
     275                        iplink_get_mtu_srv(srv, chandle, &call);
    276276                        break;
    277277                case IPLINK_GET_MAC48:
    278                         iplink_get_mac48_srv(srv, callid, &call);
     278                        iplink_get_mac48_srv(srv, chandle, &call);
    279279                        break;
    280280                case IPLINK_SET_MAC48:
    281                         iplink_set_mac48_srv(srv, callid, &call);
     281                        iplink_set_mac48_srv(srv, chandle, &call);
    282282                        break;
    283283                case IPLINK_SEND:
    284                         iplink_send_srv(srv, callid, &call);
     284                        iplink_send_srv(srv, chandle, &call);
    285285                        break;
    286286                case IPLINK_SEND6:
    287                         iplink_send6_srv(srv, callid, &call);
     287                        iplink_send6_srv(srv, chandle, &call);
    288288                        break;
    289289                case IPLINK_ADDR_ADD:
    290                         iplink_addr_add_srv(srv, callid, &call);
     290                        iplink_addr_add_srv(srv, chandle, &call);
    291291                        break;
    292292                case IPLINK_ADDR_REMOVE:
    293                         iplink_addr_remove_srv(srv, callid, &call);
     293                        iplink_addr_remove_srv(srv, chandle, &call);
    294294                        break;
    295295                default:
    296                         async_answer_0(callid, EINVAL);
     296                        async_answer_0(chandle, EINVAL);
    297297                }
    298298        }

  • uspace/lib/c/generic/loc.c

    r3e242d2 ra46e56b  
    5555static async_sess_t *loc_consumer_sess = NULL;
    5656
    57 static void loc_cb_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     57static void loc_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    5858{
    5959        while (true) {
    6060                ipc_call_t call;
    61                 cap_call_handle_t callid = async_get_call(&call);
     61                cap_call_handle_t chandle = async_get_call(&call);
    6262
    6363                if (!IPC_GET_IMETHOD(call)) {
    … …  
    7272                        fibril_mutex_unlock(&loc_callback_mutex);
    7373
    74                         async_answer_0(callid, EOK);
     74                        async_answer_0(chandle, EOK);
    7575
    7676                        if (cb_fun != NULL)
    … …  
    7979                        break;
    8080                default:
    81                         async_answer_0(callid, ENOTSUP);
     81                        async_answer_0(chandle, ENOTSUP);
    8282                }
    8383        }

  • uspace/lib/c/generic/vfs/vfs.c

    r3e242d2 ra46e56b  
    802802errno_t vfs_receive_handle(bool high, int *handle)
    803803{
    804         cap_call_handle_t callid;
    805         if (!async_state_change_receive(&callid, NULL, NULL, NULL)) {
    806                 async_answer_0(callid, EINVAL);
     804        cap_call_handle_t chandle;
     805        if (!async_state_change_receive(&chandle, NULL, NULL, NULL)) {
     806                async_answer_0(chandle, EINVAL);
    807807                return EINVAL;
    808808        }
    … …  
    810810        async_exch_t *vfs_exch = vfs_exchange_begin();
    811811
    812         async_state_change_finalize(callid, vfs_exch);
     812        async_state_change_finalize(chandle, vfs_exch);
    813813
    814814        sysarg_t ret;
Note: See TracChangeset for help on using the changeset viewer.