Changeset 984a9ba in mainline for uspace/lib/c


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

do not expose the call capability handler from the async framework

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

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

Location:
uspace/lib/c
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/async/ports.c

    r76f566d r984a9ba  
    8585 * not have a specific handler defined.
    8686 *
    87  * @param chandle  Handle of the incoming call.
    88  * @param call     Data of the incoming call.
    89  * @param arg      Local argument
     87 * @param call Data of the incoming call.
     88 * @param arg  Local argument
    9089 *
    9190 */
    92 static void default_fallback_port_handler(cap_call_handle_t chandle,
    93     ipc_call_t *call, void *arg)
    94 {
    95         ipc_answer_0(chandle, ENOENT);
     91static void default_fallback_port_handler(ipc_call_t *call, void *arg)
     92{
     93        async_answer_0(call, ENOENT);
    9694}
    9795

  • uspace/lib/c/generic/async/server.c

    r76f566d r984a9ba  
    7777 *   }
    7878 *
    79  *   port_handler(ichandle, *icall)
     79 *   port_handler(ipc_call_t *icall)
    8080 *   {
    8181 *     if (want_refuse) {
    82  *       async_answer_0(ichandle, ELIMIT);
     82 *       async_answer_0(icall, ELIMIT);
    8383 *       return;
    8484 *     }
    85  *     async_answer_0(ichandle, EOK);
    86  *
    87  *     chandle = async_get_call(&call);
    88  *     somehow_handle_the_call(chandle, call);
    89  *     async_answer_2(chandle, 1, 2, 3);
    90  *
    91  *     chandle = async_get_call(&call);
     85 *
     86 *     async_answer_0(icall, EOK);
     87 *
     88 *     async_get_call(&call);
     89 *     somehow_handle_the_call(&call);
     90 *     async_answer_2(&call, 1, 2, 3);
     91 *
     92 *     async_get_call(&call);
    9293 *     ...
    9394 *   }
    … …  
    133134typedef struct {
    134135        link_t link;
    135 
    136136        ipc_call_t call;
    137137} msg_t;
    … …  
    418418         * Call the connection handler function.
    419419         */
    420         fibril_connection->handler(fibril_connection->call.cap_handle,
    421             &fibril_connection->call, fibril_connection->data);
     420        fibril_connection->handler(&fibril_connection->call,
     421            fibril_connection->data);
    422422
    423423        /*
    … …  
    964964/** Return new incoming message for the current (fibril-local) connection.
    965965 *
    966  * @param call   Storage where the incoming call data will be stored.
    967  * @param usecs  Timeout in microseconds. Zero denotes no timeout.
    968  *
    969  * @return  If no timeout was specified, then a handle of the incoming call is
    970  *          returned. If a timeout is specified, then a handle of the incoming
    971  *          call is returned unless the timeout expires prior to receiving a
    972  *          message. In that case zero CAP_NIL is returned.
    973  */
    974 cap_call_handle_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
     966 * @param call  Storage where the incoming call data will be stored.
     967 * @param usecs Timeout in microseconds. Zero denotes no timeout.
     968 *
     969 * @return If no timeout was specified, then true is returned.
     970 * @return If a timeout is specified, then true is returned unless
     971 *         the timeout expires prior to receiving a message.
     972 *
     973 */
     974bool async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
    975975{
    976976        assert(call);
    … …  
    10071007                        IPC_SET_IMETHOD(*call, IPC_M_PHONE_HUNGUP);
    10081008                        futex_unlock(&async_futex);
    1009                         return conn->close_chandle;
     1009                        return true;
    10101010                }
    10111011
    … …  
    10271027                        /* If we timed out -> exit */
    10281028                        futex_unlock(&async_futex);
    1029                         return CAP_NIL;
     1029                        return false;
    10301030                }
    10311031        }
    … …  
    10351035        list_remove(&msg->link);
    10361036
    1037         cap_call_handle_t chandle = msg->call.cap_handle;
    10381037        *call = msg->call;
    10391038        free(msg);
    10401039
    10411040        futex_unlock(&async_futex);
    1042         return chandle;
     1041        return true;
    10431042}
    10441043
    … …  
    12511250}
    12521251
    1253 errno_t async_answer_0(cap_call_handle_t chandle, errno_t retval)
    1254 {
    1255         return ipc_answer_0(chandle, retval);
    1256 }
    1257 
    1258 errno_t async_answer_1(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1)
    1259 {
    1260         return ipc_answer_1(chandle, retval, arg1);
    1261 }
    1262 
    1263 errno_t async_answer_2(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     1252errno_t async_answer_0(ipc_call_t *call, errno_t retval)
     1253{
     1254        return ipc_answer_0(call->cap_handle, retval);
     1255}
     1256
     1257errno_t async_answer_1(ipc_call_t *call, errno_t retval, sysarg_t arg1)
     1258{
     1259        return ipc_answer_1(call->cap_handle, retval, arg1);
     1260}
     1261
     1262errno_t async_answer_2(ipc_call_t *call, errno_t retval, sysarg_t arg1,
    12641263    sysarg_t arg2)
    12651264{
    1266         return ipc_answer_2(chandle, retval, arg1, arg2);
    1267 }
    1268 
    1269 errno_t async_answer_3(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     1265        return ipc_answer_2(call->cap_handle, retval, arg1, arg2);
     1266}
     1267
     1268errno_t async_answer_3(ipc_call_t *call, errno_t retval, sysarg_t arg1,
    12701269    sysarg_t arg2, sysarg_t arg3)
    12711270{
    1272         return ipc_answer_3(chandle, retval, arg1, arg2, arg3);
    1273 }
    1274 
    1275 errno_t async_answer_4(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     1271        return ipc_answer_3(call->cap_handle, retval, arg1, arg2, arg3);
     1272}
     1273
     1274errno_t async_answer_4(ipc_call_t *call, errno_t retval, sysarg_t arg1,
    12761275    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    12771276{
    1278         return ipc_answer_4(chandle, retval, arg1, arg2, arg3, arg4);
    1279 }
    1280 
    1281 errno_t async_answer_5(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     1277        return ipc_answer_4(call->cap_handle, retval, arg1, arg2, arg3, arg4);
     1278}
     1279
     1280errno_t async_answer_5(ipc_call_t *call, errno_t retval, sysarg_t arg1,
    12821281    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
    12831282{
    1284         return ipc_answer_5(chandle, retval, arg1, arg2, arg3, arg4, arg5);
    1285 }
    1286 
    1287 errno_t async_forward_fast(cap_call_handle_t chandle, async_exch_t *exch,
     1283        return ipc_answer_5(call->cap_handle, retval, arg1, arg2, arg3, arg4,
     1284            arg5);
     1285}
     1286
     1287errno_t async_forward_fast(ipc_call_t *call, async_exch_t *exch,
    12881288    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    12891289{
     1290        assert(call);
     1291
    12901292        if (exch == NULL)
    12911293                return ENOENT;
    12921294
    1293         return ipc_forward_fast(chandle, exch->phone, imethod, arg1, arg2, mode);
    1294 }
    1295 
    1296 errno_t async_forward_slow(cap_call_handle_t chandle, async_exch_t *exch,
     1295        return ipc_forward_fast(call->cap_handle, exch->phone, imethod, arg1,
     1296            arg2, mode);
     1297}
     1298
     1299errno_t async_forward_slow(ipc_call_t *call, async_exch_t *exch,
    12971300    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
    12981301    sysarg_t arg4, sysarg_t arg5, unsigned int mode)
    12991302{
     1303        assert(call);
     1304
    13001305        if (exch == NULL)
    13011306                return ENOENT;
    13021307
    1303         return ipc_forward_slow(chandle, exch->phone, imethod, arg1, arg2, arg3,
    1304             arg4, arg5, mode);
     1308        return ipc_forward_slow(call->cap_handle, exch->phone, imethod, arg1,
     1309            arg2, arg3, arg4, arg5, mode);
    13051310}
    13061311
    … …  
    13091314 * Ask through phone for a new connection to some service.
    13101315 *
    1311  * @param exch            Exchange for sending the message.
    1312  * @param arg1            User defined argument.
    1313  * @param arg2            User defined argument.
    1314  * @param arg3            User defined argument.
     1316 * @param exch Exchange for sending the message.
     1317 * @param arg1 User defined argument.
     1318 * @param arg2 User defined argument.
     1319 * @param arg3 User defined argument.
    13151320 *
    13161321 * @return Zero on success or an error code.
    … …  
    13501355 * So far, this wrapper is to be used from within a connection fibril.
    13511356 *
    1352  * @param chandle  Storage for the handle of the IPC_M_SHARE_IN call.
    1353  * @param size     Destination address space area size.
     1357 * @param call Storage for the data of the IPC_M_SHARE_IN call.
     1358 * @param size Destination address space area size.
    13541359 *
    13551360 * @return True on success, false on failure.
    13561361 *
    13571362 */
    1358 bool async_share_in_receive(cap_call_handle_t *chandle, size_t *size)
    1359 {
    1360         assert(chandle);
     1363bool async_share_in_receive(ipc_call_t *call, size_t *size)
     1364{
     1365        assert(call);
    13611366        assert(size);
    13621367
    1363         ipc_call_t data;
    1364         *chandle = async_get_call(&data);
    1365 
    1366         if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN)
     1368        async_get_call(call);
     1369
     1370        if (IPC_GET_IMETHOD(*call) != IPC_M_SHARE_IN)
    13671371                return false;
    13681372
    1369         *size = (size_t) IPC_GET_ARG1(data);
     1373        *size = (size_t) IPC_GET_ARG1(*call);
    13701374        return true;
    13711375}
    … …  
    13771381 * argument.
    13781382 *
    1379  * @param chandle  Handle of the IPC_M_DATA_READ call to answer.
    1380  * @param src      Source address space base.
    1381  * @param flags    Flags to be used for sharing. Bits can be only cleared.
     1383 * @param call IPC_M_DATA_READ call to answer.
     1384 * @param src   Source address space base.
     1385 * @param flags Flags to be used for sharing. Bits can be only cleared.
    13821386 *
    13831387 * @return Zero on success or a value from @ref errno.h on failure.
    13841388 *
    13851389 */
    1386 errno_t async_share_in_finalize(cap_call_handle_t chandle, void *src,
    1387     unsigned int flags)
    1388 {
     1390errno_t async_share_in_finalize(ipc_call_t *call, void *src, unsigned int flags)
     1391{
     1392        assert(call);
     1393
    13891394        // FIXME: The source has no business deciding destination address.
    1390         return ipc_answer_3(chandle, EOK, (sysarg_t) src, (sysarg_t) flags,
     1395        return ipc_answer_3(call->cap_handle, EOK, (sysarg_t) src, (sysarg_t) flags,
    13911396            (sysarg_t) _end);
    13921397}
    … …  
    14001405 * So far, this wrapper is to be used from within a connection fibril.
    14011406 *
    1402  * @param chandle  Storage for the hash of the IPC_M_SHARE_OUT call.
    1403  * @param size     Storage for the source address space area size.
    1404  * @param flags    Storage for the sharing flags.
     1407 * @param call  Storage for the data of the IPC_M_SHARE_OUT call.
     1408 * @param size  Storage for the source address space area size.
     1409 * @param flags Storage for the sharing flags.
    14051410 *
    14061411 * @return True on success, false on failure.
    14071412 *
    14081413 */
    1409 bool async_share_out_receive(cap_call_handle_t *chandle, size_t *size,
     1414bool async_share_out_receive(ipc_call_t *call, size_t *size,
    14101415    unsigned int *flags)
    14111416{
    1412         assert(chandle);
     1417        assert(call);
    14131418        assert(size);
    14141419        assert(flags);
    14151420
    1416         ipc_call_t data;
    1417         *chandle = async_get_call(&data);
    1418 
    1419         if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT)
     1421        async_get_call(call);
     1422
     1423        if (IPC_GET_IMETHOD(*call) != IPC_M_SHARE_OUT)
    14201424                return false;
    14211425
    1422         *size = (size_t) IPC_GET_ARG2(data);
    1423         *flags = (unsigned int) IPC_GET_ARG3(data);
     1426        *size = (size_t) IPC_GET_ARG2(*call);
     1427        *flags = (unsigned int) IPC_GET_ARG3(*call);
    14241428        return true;
    14251429}
    … …  
    14311435 * argument.
    14321436 *
    1433  * @param chandle  Handle of the IPC_M_DATA_WRITE call to answer.
    1434  * @param dst      Address of the storage for the destination address space area
    1435  *                 base address.
     1437 * @param call IPC_M_DATA_WRITE call to answer.
     1438 * @param dst  Address of the storage for the destination address space area
     1439 *             base address.
    14361440 *
    14371441 * @return  Zero on success or a value from @ref errno.h on failure.
    14381442 *
    14391443 */
    1440 errno_t async_share_out_finalize(cap_call_handle_t chandle, void **dst)
    1441 {
    1442         return ipc_answer_2(chandle, EOK, (sysarg_t) _end, (sysarg_t) dst);
     1444errno_t async_share_out_finalize(ipc_call_t *call, void **dst)
     1445{
     1446        assert(call);
     1447
     1448        return ipc_answer_2(call->cap_handle, EOK, (sysarg_t) _end,
     1449            (sysarg_t) dst);
    14431450}
    14441451
    … …  
    14511458 * So far, this wrapper is to be used from within a connection fibril.
    14521459 *
    1453  * @param chandle  Storage for the handle of the IPC_M_DATA_READ.
    1454  * @param size     Storage for the maximum size. Can be NULL.
     1460 * @param call Storage for the data of the IPC_M_DATA_READ.
     1461 * @param size Storage for the maximum size. Can be NULL.
    14551462 *
    14561463 * @return True on success, false on failure.
    14571464 *
    14581465 */
    1459 bool async_data_read_receive(cap_call_handle_t *chandle, size_t *size)
    1460 {
    1461         ipc_call_t data;
    1462         return async_data_read_receive_call(chandle, &data, size);
    1463 }
    1464 
    1465 /** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
    1466  *
    1467  * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ
    1468  * calls so that the user doesn't have to remember the meaning of each IPC
    1469  * argument.
    1470  *
    1471  * So far, this wrapper is to be used from within a connection fibril.
    1472  *
    1473  * @param chandle  Storage for the handle of the IPC_M_DATA_READ.
    1474  * @param size     Storage for the maximum size. Can be NULL.
    1475  *
    1476  * @return True on success, false on failure.
    1477  *
    1478  */
    1479 bool async_data_read_receive_call(cap_call_handle_t *chandle, ipc_call_t *data,
    1480     size_t *size)
    1481 {
    1482         assert(chandle);
    1483         assert(data);
    1484 
    1485         *chandle = async_get_call(data);
    1486 
    1487         if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_READ)
     1466bool async_data_read_receive(ipc_call_t *call, size_t *size)
     1467{
     1468        assert(call);
     1469
     1470        async_get_call(call);
     1471
     1472        if (IPC_GET_IMETHOD(*call) != IPC_M_DATA_READ)
    14881473                return false;
    14891474
    14901475        if (size)
    1491                 *size = (size_t) IPC_GET_ARG2(*data);
     1476                *size = (size_t) IPC_GET_ARG2(*call);
    14921477
    14931478        return true;
    … …  
    15001485 * argument.
    15011486 *
    1502  * @param chandle  Handle of the IPC_M_DATA_READ call to answer.
    1503  * @param src      Source address for the IPC_M_DATA_READ call.
    1504  * @param size     Size for the IPC_M_DATA_READ call. Can be smaller than
    1505  *                 the maximum size announced by the sender.
     1487 * @param call IPC_M_DATA_READ call to answer.
     1488 * @param src  Source address for the IPC_M_DATA_READ call.
     1489 * @param size Size for the IPC_M_DATA_READ call. Can be smaller than
     1490 *             the maximum size announced by the sender.
    15061491 *
    15071492 * @return  Zero on success or a value from @ref errno.h on failure.
    15081493 *
    15091494 */
    1510 errno_t async_data_read_finalize(cap_call_handle_t chandle, const void *src,
    1511     size_t size)
    1512 {
    1513         return ipc_answer_2(chandle, EOK, (sysarg_t) src, (sysarg_t) size);
     1495errno_t async_data_read_finalize(ipc_call_t *call, const void *src, size_t size)
     1496{
     1497        assert(call);
     1498
     1499        return ipc_answer_2(call->cap_handle, EOK, (sysarg_t) src,
     1500            (sysarg_t) size);
    15141501}
    15151502
    … …  
    15241511                return ENOENT;
    15251512
    1526         cap_call_handle_t chandle;
    1527         if (!async_data_read_receive(&chandle, NULL)) {
    1528                 ipc_answer_0(chandle, EINVAL);
     1513        ipc_call_t call;
     1514        if (!async_data_read_receive(&call, NULL)) {
     1515                async_answer_0(&call, EINVAL);
    15291516                return EINVAL;
    15301517        }
    … …  
    15331520            dataptr);
    15341521        if (msg == 0) {
    1535                 ipc_answer_0(chandle, EINVAL);
     1522                async_answer_0(&call, EINVAL);
    15361523                return EINVAL;
    15371524        }
    15381525
    1539         errno_t retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
     1526        errno_t retval = ipc_forward_fast(call.cap_handle, exch->phone, 0, 0, 0,
    15401527            IPC_FF_ROUTE_FROM_ME);
    15411528        if (retval != EOK) {
    15421529                async_forget(msg);
    1543                 ipc_answer_0(chandle, retval);
     1530                async_answer_0(&call, retval);
    15441531                return retval;
    15451532        }
    … …  
    15591546 * So far, this wrapper is to be used from within a connection fibril.
    15601547 *
    1561  * @param chandle  Storage for the handle of the IPC_M_DATA_WRITE.
    1562  * @param size     Storage for the suggested size. May be NULL.
    1563  *
    1564  * @return  True on success, false on failure.
    1565  *
    1566  */
    1567 bool async_data_write_receive(cap_call_handle_t *chandle, size_t *size)
    1568 {
    1569         ipc_call_t data;
    1570         return async_data_write_receive_call(chandle, &data, size);
    1571 }
    1572 
    1573 /** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
    1574  *
    1575  * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE
    1576  * calls so that the user doesn't have to remember the meaning of each IPC
    1577  * argument.
    1578  *
    1579  * So far, this wrapper is to be used from within a connection fibril.
    1580  *
    1581  * @param chandle  Storage for the handle of the IPC_M_DATA_WRITE.
    1582  * @param data     Storage for the ipc call data.
    1583  * @param size     Storage for the suggested size. May be NULL.
     1548 * @param call Storage for the data of the IPC_M_DATA_WRITE.
     1549 * @param size Storage for the suggested size. May be NULL.
    15841550 *
    15851551 * @return True on success, false on failure.
    15861552 *
    15871553 */
    1588 bool async_data_write_receive_call(cap_call_handle_t *chandle, ipc_call_t *data,
    1589     size_t *size)
    1590 {
    1591         assert(chandle);
    1592         assert(data);
    1593 
    1594         *chandle = async_get_call(data);
    1595 
    1596         if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_WRITE)
     1554bool async_data_write_receive(ipc_call_t *call, size_t *size)
     1555{
     1556        assert(call);
     1557
     1558        async_get_call(call);
     1559
     1560        if (IPC_GET_IMETHOD(*call) != IPC_M_DATA_WRITE)
    15971561                return false;
    15981562
    15991563        if (size)
    1600                 *size = (size_t) IPC_GET_ARG2(*data);
     1564                *size = (size_t) IPC_GET_ARG2(*call);
    16011565
    16021566        return true;
    … …  
    16091573 * argument.
    16101574 *
    1611  * @param chandle  Handle of the IPC_M_DATA_WRITE call to answer.
    1612  * @param dst      Final destination address for the IPC_M_DATA_WRITE call.
    1613  * @param size     Final size for the IPC_M_DATA_WRITE call.
     1575 * @param call IPC_M_DATA_WRITE call to answer.
     1576 * @param dst  Final destination address for the IPC_M_DATA_WRITE call.
     1577 * @param size Final size for the IPC_M_DATA_WRITE call.
    16141578 *
    16151579 * @return  Zero on success or a value from @ref errno.h on failure.
    16161580 *
    16171581 */
    1618 errno_t async_data_write_finalize(cap_call_handle_t chandle, void *dst,
    1619     size_t size)
    1620 {
    1621         return ipc_answer_2(chandle, EOK, (sysarg_t) dst, (sysarg_t) size);
     1582errno_t async_data_write_finalize(ipc_call_t *call, void *dst, size_t size)
     1583{
     1584        assert(call);
     1585
     1586        return async_answer_2(call, EOK, (sysarg_t) dst, (sysarg_t) size);
    16221587}
    16231588
    … …  
    16491614        assert(data);
    16501615
    1651         cap_call_handle_t chandle;
     1616        ipc_call_t call;
    16521617        size_t size;
    1653         if (!async_data_write_receive(&chandle, &size)) {
    1654                 ipc_answer_0(chandle, EINVAL);
     1618        if (!async_data_write_receive(&call, &size)) {
     1619                async_answer_0(&call, EINVAL);
    16551620                return EINVAL;
    16561621        }
    16571622
    16581623        if (size < min_size) {
    1659                 ipc_answer_0(chandle, EINVAL);
     1624                async_answer_0(&call, EINVAL);
    16601625                return EINVAL;
    16611626        }
    16621627
    16631628        if ((max_size > 0) && (size > max_size)) {
    1664                 ipc_answer_0(chandle, EINVAL);
     1629                async_answer_0(&call, EINVAL);
    16651630                return EINVAL;
    16661631        }
    16671632
    16681633        if ((granularity > 0) && ((size % granularity) != 0)) {
    1669                 ipc_answer_0(chandle, EINVAL);
     1634                async_answer_0(&call, EINVAL);
    16701635                return EINVAL;
    16711636        }
    … …  
    16791644
    16801645        if (arg_data == NULL) {
    1681                 ipc_answer_0(chandle, ENOMEM);
     1646                async_answer_0(&call, ENOMEM);
    16821647                return ENOMEM;
    16831648        }
    16841649
    1685         errno_t rc = async_data_write_finalize(chandle, arg_data, size);
     1650        errno_t rc = async_data_write_finalize(&call, arg_data, size);
    16861651        if (rc != EOK) {
    16871652                free(arg_data);
    … …  
    17081673void async_data_write_void(errno_t retval)
    17091674{
    1710         cap_call_handle_t chandle;
    1711         async_data_write_receive(&chandle, NULL);
    1712         ipc_answer_0(chandle, retval);
     1675        ipc_call_t call;
     1676        async_data_write_receive(&call, NULL);
     1677        async_answer_0(&call, retval);
    17131678}
    17141679
    … …  
    17231688                return ENOENT;
    17241689
    1725         cap_call_handle_t chandle;
    1726         if (!async_data_write_receive(&chandle, NULL)) {
    1727                 ipc_answer_0(chandle, EINVAL);
     1690        ipc_call_t call;
     1691        if (!async_data_write_receive(&call, NULL)) {
     1692                async_answer_0(&call, EINVAL);
    17281693                return EINVAL;
    17291694        }
    … …  
    17321697            dataptr);
    17331698        if (msg == 0) {
    1734                 ipc_answer_0(chandle, EINVAL);
     1699                async_answer_0(&call, EINVAL);
    17351700                return EINVAL;
    17361701        }
    17371702
    1738         errno_t retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
     1703        errno_t retval = ipc_forward_fast(call.cap_handle, exch->phone, 0, 0, 0,
    17391704            IPC_FF_ROUTE_FROM_ME);
    17401705        if (retval != EOK) {
    17411706                async_forget(msg);
    1742                 ipc_answer_0(chandle, retval);
     1707                async_answer_0(&call, retval);
    17431708                return retval;
    17441709        }
    … …  
    17651730        /* Accept the phone */
    17661731        ipc_call_t call;
    1767         cap_call_handle_t chandle = async_get_call(&call);
     1732        async_get_call(&call);
     1733
    17681734        cap_phone_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(call);
    17691735
    17701736        if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) ||
    17711737            !CAP_HANDLE_VALID((phandle))) {
    1772                 async_answer_0(chandle, EINVAL);
     1738                async_answer_0(&call, EINVAL);
    17731739                return NULL;
    17741740        }
    … …  
    17761742        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
    17771743        if (sess == NULL) {
    1778                 async_answer_0(chandle, ENOMEM);
     1744                async_answer_0(&call, ENOMEM);
    17791745                return NULL;
    17801746        }
    … …  
    17951761
    17961762        /* Acknowledge the connected phone */
    1797         async_answer_0(chandle, EOK);
     1763        async_answer_0(&call, EOK);
    17981764
    17991765        return sess;
    … …  
    18431809}
    18441810
    1845 bool async_state_change_receive(cap_call_handle_t *chandle, sysarg_t *arg1,
    1846     sysarg_t *arg2, sysarg_t *arg3)
    1847 {
    1848         assert(chandle);
    1849 
    1850         ipc_call_t call;
    1851         *chandle = async_get_call(&call);
    1852 
    1853         if (IPC_GET_IMETHOD(call) != IPC_M_STATE_CHANGE_AUTHORIZE)
     1811bool async_state_change_receive(ipc_call_t *call)
     1812{
     1813        assert(call);
     1814
     1815        async_get_call(call);
     1816
     1817        if (IPC_GET_IMETHOD(*call) != IPC_M_STATE_CHANGE_AUTHORIZE)
    18541818                return false;
    18551819
    1856         if (arg1)
    1857                 *arg1 = IPC_GET_ARG1(call);
    1858         if (arg2)
    1859                 *arg2 = IPC_GET_ARG2(call);
    1860         if (arg3)
    1861                 *arg3 = IPC_GET_ARG3(call);
    1862 
    18631820        return true;
    18641821}
    18651822
    1866 errno_t async_state_change_finalize(cap_call_handle_t chandle,
    1867     async_exch_t *other_exch)
    1868 {
    1869         return ipc_answer_1(chandle, EOK, CAP_HANDLE_RAW(other_exch->phone));
     1823errno_t async_state_change_finalize(ipc_call_t *call, async_exch_t *other_exch)
     1824{
     1825        assert(call);
     1826
     1827        return async_answer_1(call, EOK, CAP_HANDLE_RAW(other_exch->phone));
    18701828}
    18711829

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

    r76f566d r984a9ba  
    4646#include <offset.h>
    4747
    48 static void bd_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     48static void bd_cb_conn(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 icall_handle, ipc_call_t *icall, void *arg)
     198static void bd_cb_conn(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 chandle = async_get_call(&call);
     206                async_get_call(&call);
    207207
    208208                if (!IPC_GET_IMETHOD(call)) {
    … …  
    213213                switch (IPC_GET_IMETHOD(call)) {
    214214                default:
    215                         async_answer_0(chandle, ENOTSUP);
     215                        async_answer_0(&call, ENOTSUP);
    216216                }
    217217        }

  • 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        }

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

    r76f566d r984a9ba  
    3636#include <stdlib.h>
    3737
    38 static void inet_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     38static void inet_cb_conn(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 icall_handle, ipc_call_t *icall)
     178static void inet_ev_recv(ipc_call_t *icall)
    179179{
    180180        inet_dgram_t dgram;
    … …  
    183183        dgram.iplink = IPC_GET_ARG2(*icall);
    184184
    185         cap_call_handle_t chandle;
     185        ipc_call_t call;
    186186        size_t size;
    187         if (!async_data_write_receive(&chandle, &size)) {
    188                 async_answer_0(chandle, EINVAL);
    189                 async_answer_0(icall_handle, EINVAL);
     187        if (!async_data_write_receive(&call, &size)) {
     188                async_answer_0(&call, EINVAL);
     189                async_answer_0(icall, EINVAL);
    190190                return;
    191191        }
    192192
    193193        if (size != sizeof(inet_addr_t)) {
    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);
     194                async_answer_0(&call, EINVAL);
     195                async_answer_0(icall, EINVAL);
     196                return;
     197        }
     198
     199        errno_t rc = async_data_write_finalize(&call, &dgram.src, size);
     200        if (rc != EOK) {
     201                async_answer_0(&call, rc);
     202                async_answer_0(icall, rc);
     203                return;
     204        }
     205
     206        if (!async_data_write_receive(&call, &size)) {
     207                async_answer_0(&call, EINVAL);
     208                async_answer_0(icall, EINVAL);
    209209                return;
    210210        }
    211211
    212212        if (size != sizeof(inet_addr_t)) {
    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);
     213                async_answer_0(&call, EINVAL);
     214                async_answer_0(icall, EINVAL);
     215                return;
     216        }
     217
     218        rc = async_data_write_finalize(&call, &dgram.dest, size);
     219        if (rc != EOK) {
     220                async_answer_0(&call, rc);
     221                async_answer_0(icall, 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(icall_handle, rc);
     227                async_answer_0(icall, rc);
    228228                return;
    229229        }
    … …  
    231231        rc = inet_ev_ops->recv(&dgram);
    232232        free(dgram.data);
    233         async_answer_0(icall_handle, rc);
    234 }
    235 
    236 static void inet_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     233        async_answer_0(icall, rc);
     234}
     235
     236static void inet_cb_conn(ipc_call_t *icall, void *arg)
    237237{
    238238        while (true) {
    239239                ipc_call_t call;
    240                 cap_call_handle_t chandle = async_get_call(&call);
     240                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(chandle, &call);
     249                        inet_ev_recv(&call);
    250250                        break;
    251251                default:
    252                         async_answer_0(chandle, ENOTSUP);
     252                        async_answer_0(&call, ENOTSUP);
    253253                }
    254254        }

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

    r76f566d r984a9ba  
    4141#include <stdlib.h>
    4242
    43 static void tcp_cb_conn(cap_call_handle_t, ipc_call_t *, void *);
     43static void tcp_cb_conn(ipc_call_t *, void *);
    4444static errno_t tcp_conn_fibril(void *);
    4545
    … …  
    633633/** Connection established event.
    634634 *
    635  * @param tcp           TCP client
    636  * @param icall_handle  Call handle
    637  * @param icall         Call data
    638  */
    639 static void
    640 tcp_ev_connected(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     635 * @param tcp   TCP client
     636 * @param icall Call data
     637 *
     638 */
     639static void tcp_ev_connected(tcp_t *tcp, ipc_call_t *icall)
    641640{
    642641        tcp_conn_t *conn;
    … …  
    648647        rc = tcp_conn_get(tcp, conn_id, &conn);
    649648        if (rc != EOK) {
    650                 async_answer_0(icall_handle, ENOENT);
     649                async_answer_0(icall, ENOENT);
    651650                return;
    652651        }
    … …  
    657656        fibril_mutex_unlock(&conn->lock);
    658657
    659         async_answer_0(icall_handle, EOK);
     658        async_answer_0(icall, EOK);
    660659}
    661660
    662661/** Connection failed event.
    663662 *
    664  * @param tcp           TCP client
    665  * @param icall_handle  Call handle
    666  * @param icall         Call data
    667  */
    668 static void
    669 tcp_ev_conn_failed(tcp_t *tcp, cap_call_handle_t icall_handle,
    670     ipc_call_t *icall)
     663 * @param tcp   TCP client
     664 * @param icall Call data
     665 *
     666 */
     667static void tcp_ev_conn_failed(tcp_t *tcp, ipc_call_t *icall)
    671668{
    672669        tcp_conn_t *conn;
    … …  
    678675        rc = tcp_conn_get(tcp, conn_id, &conn);
    679676        if (rc != EOK) {
    680                 async_answer_0(icall_handle, ENOENT);
     677                async_answer_0(icall, ENOENT);
    681678                return;
    682679        }
    … …  
    687684        fibril_mutex_unlock(&conn->lock);
    688685
    689         async_answer_0(icall_handle, EOK);
     686        async_answer_0(icall, EOK);
    690687}
    691688
    692689/** Connection reset event.
    693690 *
    694  * @param tcp           TCP client
    695  * @param icall_handle  Call handle
    696  * @param icall         Call data
    697  */
    698 static void tcp_ev_conn_reset(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     691 * @param tcp   TCP client
     692 * @param icall Call data
     693 *
     694 */
     695static void tcp_ev_conn_reset(tcp_t *tcp, ipc_call_t *icall)
    699696{
    700697        tcp_conn_t *conn;
    … …  
    706703        rc = tcp_conn_get(tcp, conn_id, &conn);
    707704        if (rc != EOK) {
    708                 async_answer_0(icall_handle, ENOENT);
     705                async_answer_0(icall, ENOENT);
    709706                return;
    710707        }
    … …  
    715712        fibril_mutex_unlock(&conn->lock);
    716713
    717         async_answer_0(icall_handle, EOK);
     714        async_answer_0(icall, EOK);
    718715}
    719716
    720717/** Data available event.
    721718 *
    722  * @param tcp           TCP client
    723  * @param icall_handle  Call handle
    724  * @param icall         Call data
    725  */
    726 static void
    727 tcp_ev_data(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     719 * @param tcp   TCP client
     720 * @param icall Call data
     721 *
     722 */
     723static void tcp_ev_data(tcp_t *tcp, ipc_call_t *icall)
    728724{
    729725        tcp_conn_t *conn;
    … …  
    735731        rc = tcp_conn_get(tcp, conn_id, &conn);
    736732        if (rc != EOK) {
    737                 async_answer_0(icall_handle, ENOENT);
     733                async_answer_0(icall, ENOENT);
    738734                return;
    739735        }
    … …  
    745741                conn->cb->data_avail(conn);
    746742
    747         async_answer_0(icall_handle, EOK);
     743        async_answer_0(icall, EOK);
    748744}
    749745
    750746/** Urgent data event.
    751747 *
    752  * @param tcp           TCP client
    753  * @param icall_handle  Call handle
    754  * @param icall         Call data
    755  */
    756 static void
    757 tcp_ev_urg_data(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
    758 {
    759         async_answer_0(icall_handle, ENOTSUP);
     748 * @param tcp   TCP client
     749 * @param icall Call data
     750 *
     751 */
     752static void tcp_ev_urg_data(tcp_t *tcp, ipc_call_t *icall)
     753{
     754        async_answer_0(icall, ENOTSUP);
    760755}
    761756
    762757/** New connection event.
    763758 *
    764  * @param tcp           TCP client
    765  * @param icall_handle  Call handle
    766  * @param icall         Call data
    767  */
    768 static void
    769 tcp_ev_new_conn(tcp_t *tcp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     759 * @param tcp   TCP client
     760 * @param icall Call data
     761 *
     762 */
     763static void tcp_ev_new_conn(tcp_t *tcp, ipc_call_t *icall)
    770764{
    771765        tcp_listener_t *lst;
    … …  
    782776        rc = tcp_listener_get(tcp, lst_id, &lst);
    783777        if (rc != EOK) {
    784                 async_answer_0(icall_handle, ENOENT);
     778                async_answer_0(icall, ENOENT);
    785779                return;
    786780        }
    … …  
    788782        rc = tcp_conn_new(tcp, conn_id, lst->cb, lst->cb_arg, &conn);
    789783        if (rc != EOK) {
    790                 async_answer_0(icall_handle, ENOMEM);
     784                async_answer_0(icall, ENOMEM);
    791785                return;
    792786        }
    … …  
    795789                cinfo = calloc(1, sizeof(tcp_in_conn_t));
    796790                if (cinfo == NULL) {
    797                         async_answer_0(icall_handle, ENOMEM);
     791                        async_answer_0(icall, ENOMEM);
    798792                        return;
    799793                }
    … …  
    804798                fid = fibril_create(tcp_conn_fibril, cinfo);
    805799                if (fid == 0) {
    806                         async_answer_0(icall_handle, ENOMEM);
     800                        async_answer_0(icall, ENOMEM);
    807801                }
    808802
    … …  
    810804        }
    811805
    812         async_answer_0(icall_handle, EOK);
     806        async_answer_0(icall, EOK);
    813807}
    814808
    815809/** Callback connection handler.
    816810 *
    817  * @param icall_handle  Connect call handle
    818  * @param icall         Connect call data
    819  * @param arg           Argument, TCP client
    820  */
    821 static void
    822 tcp_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     811 * @param icall Connect call data
     812 * @param arg   Argument, TCP client
     813 *
     814 */
     815static void tcp_cb_conn(ipc_call_t *icall, void *arg)
    823816{
    824817        tcp_t *tcp = (tcp_t *)arg;
    825818
    826         async_answer_0(icall_handle, EOK);
     819        async_answer_0(icall, EOK);
    827820
    828821        while (true) {
    829822                ipc_call_t call;
    830                 cap_call_handle_t chandle = async_get_call(&call);
     823                async_get_call(&call);
    831824
    832825                if (!IPC_GET_IMETHOD(call)) {
    … …  
    837830                switch (IPC_GET_IMETHOD(call)) {
    838831                case TCP_EV_CONNECTED:
    839                         tcp_ev_connected(tcp, chandle, &call);
     832                        tcp_ev_connected(tcp, &call);
    840833                        break;
    841834                case TCP_EV_CONN_FAILED:
    842                         tcp_ev_conn_failed(tcp, chandle, &call);
     835                        tcp_ev_conn_failed(tcp, &call);
    843836                        break;
    844837                case TCP_EV_CONN_RESET:
    845                         tcp_ev_conn_reset(tcp, chandle, &call);
     838                        tcp_ev_conn_reset(tcp, &call);
    846839                        break;
    847840                case TCP_EV_DATA:
    848                         tcp_ev_data(tcp, chandle, &call);
     841                        tcp_ev_data(tcp, &call);
    849842                        break;
    850843                case TCP_EV_URG_DATA:
    851                         tcp_ev_urg_data(tcp, chandle, &call);
     844                        tcp_ev_urg_data(tcp, &call);
    852845                        break;
    853846                case TCP_EV_NEW_CONN:
    854                         tcp_ev_new_conn(tcp, chandle, &call);
     847                        tcp_ev_new_conn(tcp, &call);
    855848                        break;
    856849                default:
    857                         async_answer_0(chandle, ENOTSUP);
     850                        async_answer_0(&call, ENOTSUP);
    858851                        break;
    859852                }
    860853        }
     854
    861855out:
    862856        fibril_mutex_lock(&tcp->lock);

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

    r76f566d r984a9ba  
    4141#include <stdlib.h>
    4242
    43 static void udp_cb_conn(cap_call_handle_t, ipc_call_t *, void *);
     43static void udp_cb_conn(ipc_call_t *, void *);
    4444
    4545/** Create callback connection from UDP service.
    … …  
    451451 * callback and discard it.
    452452 *
    453  * @param udp UDP client
    454  * @param iid IPC message ID
     453 * @param udp   UDP client
    455454 * @param icall IPC message
    456  */
    457 static void udp_ev_data(udp_t *udp, cap_call_handle_t icall_handle, ipc_call_t *icall)
     455 *
     456 */
     457static void udp_ev_data(udp_t *udp, ipc_call_t *icall)
    458458{
    459459        udp_rmsg_t rmsg;
    … …  
    481481        }
    482482
    483         async_answer_0(icall_handle, EOK);
     483        async_answer_0(icall, EOK);
    484484}
    485485
    486486/** UDP service callback connection.
    487487 *
    488  * @param iid Connect message ID
    489488 * @param icall Connect message
    490  * @param arg Argument, UDP client
    491  */
    492 static void udp_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     489 * @param arg   Argument, UDP client
     490 *
     491 */
     492static void udp_cb_conn(ipc_call_t *icall, void *arg)
    493493{
    494494        udp_t *udp = (udp_t *)arg;
    495495
    496         async_answer_0(icall_handle, EOK);
     496        async_answer_0(icall, EOK);
    497497
    498498        while (true) {
    499499                ipc_call_t call;
    500                 cap_call_handle_t chandle = async_get_call(&call);
     500                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, chandle, &call);
     509                        udp_ev_data(udp, &call);
    510510                        break;
    511511                default:
    512                         async_answer_0(chandle, ENOTSUP);
     512                        async_answer_0(&call, ENOTSUP);
    513513                        break;
    514514                }
    515515        }
     516
    516517out:
    517518        fibril_mutex_lock(&udp->lock);

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

    r76f566d r984a9ba  
    3838#include <str.h>
    3939
    40 static void inetping_cb_conn(cap_call_handle_t, ipc_call_t *, void *);
    41 static void inetping_ev_recv(cap_call_handle_t, ipc_call_t *);
     40static void inetping_cb_conn(ipc_call_t *, void *);
     41static void inetping_ev_recv(ipc_call_t *);
    4242
    4343static async_sess_t *inetping_sess = NULL;
    … …  
    150150}
    151151
    152 static void inetping_ev_recv(cap_call_handle_t icall_handle, ipc_call_t *icall)
     152static void inetping_ev_recv(ipc_call_t *icall)
    153153{
    154154        inetping_sdu_t sdu;
    … …  
    156156        sdu.seq_no = IPC_GET_ARG1(*icall);
    157157
    158         cap_call_handle_t chandle;
     158        ipc_call_t call;
    159159        size_t size;
    160         if (!async_data_write_receive(&chandle, &size)) {
    161                 async_answer_0(chandle, EREFUSED);
    162                 async_answer_0(icall_handle, EREFUSED);
     160        if (!async_data_write_receive(&call, &size)) {
     161                async_answer_0(&call, EREFUSED);
     162                async_answer_0(icall, EREFUSED);
    163163                return;
    164164        }
    165165
    166166        if (size != sizeof(sdu.src)) {
    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);
     167                async_answer_0(&call, EINVAL);
     168                async_answer_0(icall, EINVAL);
     169                return;
     170        }
     171
     172        errno_t rc = async_data_write_finalize(&call, &sdu.src, size);
     173        if (rc != EOK) {
     174                async_answer_0(&call, rc);
     175                async_answer_0(icall, rc);
     176                return;
     177        }
     178
     179        if (!async_data_write_receive(&call, &size)) {
     180                async_answer_0(&call, EREFUSED);
     181                async_answer_0(icall, EREFUSED);
    182182                return;
    183183        }
    184184
    185185        if (size != sizeof(sdu.dest)) {
    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);
     186                async_answer_0(&call, EINVAL);
     187                async_answer_0(icall, EINVAL);
     188                return;
     189        }
     190
     191        rc = async_data_write_finalize(&call, &sdu.dest, size);
     192        if (rc != EOK) {
     193                async_answer_0(&call, rc);
     194                async_answer_0(icall, 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(icall_handle, rc);
     200                async_answer_0(icall, rc);
    201201                return;
    202202        }
    … …  
    204204        rc = inetping_ev_ops->recv(&sdu);
    205205        free(sdu.data);
    206         async_answer_0(icall_handle, rc);
    207 }
    208 
    209 static void inetping_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     206        async_answer_0(icall, rc);
     207}
     208
     209static void inetping_cb_conn(ipc_call_t *icall, void *arg)
    210210{
    211211        while (true) {
    212212                ipc_call_t call;
    213                 cap_call_handle_t chandle = async_get_call(&call);
     213                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(chandle, &call);
     222                        inetping_ev_recv(&call);
    223223                        break;
    224224                default:
    225                         async_answer_0(chandle, ENOTSUP);
     225                        async_answer_0(&call, ENOTSUP);
    226226                }
    227227        }

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

    r76f566d r984a9ba  
    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 chandle,
    46     ipc_call_t *call)
     45static void chardev_read_srv(chardev_srv_t *srv, ipc_call_t *icall)
    4746{
    4847        void *buf;
    … …  
    5049        size_t nread;
    5150        errno_t rc;
    52         cap_call_handle_t rcall_handle;
    5351
    54         if (!async_data_read_receive(&rcall_handle, &size)) {
    55                 async_answer_0(chandle, EINVAL);
     52        ipc_call_t call;
     53        if (!async_data_read_receive(&call, &size)) {
     54                async_answer_0(icall, EINVAL);
    5655                return;
    5756        }
    … …  
    5958        buf = malloc(size);
    6059        if (buf == NULL) {
    61                 async_answer_0(rcall_handle, ENOMEM);
    62                 async_answer_0(chandle, ENOMEM);
     60                async_answer_0(&call, ENOMEM);
     61                async_answer_0(icall, ENOMEM);
    6362                return;
    6463        }
    6564
    6665        if (srv->srvs->ops->read == NULL) {
    67                 async_answer_0(rcall_handle, ENOTSUP);
    68                 async_answer_0(chandle, ENOTSUP);
     66                async_answer_0(&call, ENOTSUP);
     67                async_answer_0(icall, ENOTSUP);
    6968                free(buf);
    7069                return;
    … …  
    7372        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    7473        if (rc != EOK && nread == 0) {
    75                 async_answer_0(rcall_handle, rc);
    76                 async_answer_0(chandle, rc);
     74                async_answer_0(&call, rc);
     75                async_answer_0(icall, rc);
    7776                free(buf);
    7877                return;
    7978        }
    8079
    81         async_data_read_finalize(rcall_handle, buf, nread);
     80        async_data_read_finalize(&call, buf, nread);
    8281
    8382        free(buf);
    84         async_answer_2(chandle, EOK, (sysarg_t) rc, nread);
     83        async_answer_2(icall, EOK, (sysarg_t) rc, nread);
    8584}
    8685
    87 static void chardev_write_srv(chardev_srv_t *srv, cap_call_handle_t chandle,
    88     ipc_call_t *call)
     86static void chardev_write_srv(chardev_srv_t *srv, ipc_call_t *icall)
    8987{
    9088        void *data;
    … …  
    9593        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    9694        if (rc != EOK) {
    97                 async_answer_0(chandle, rc);
     95                async_answer_0(icall, rc);
    9896                return;
    9997        }
    10098
    10199        if (srv->srvs->ops->write == NULL) {
    102                 async_answer_0(chandle, ENOTSUP);
     100                async_answer_0(icall, ENOTSUP);
    103101                return;
    104102        }
    … …  
    107105        free(data);
    108106        if (rc != EOK && nwr == 0) {
    109                 async_answer_0(chandle, rc);
     107                async_answer_0(icall, rc);
    110108                return;
    111109        }
    112110
    113         async_answer_2(chandle, EOK, (sysarg_t) rc, nwr);
     111        async_answer_2(icall, EOK, (sysarg_t) rc, nwr);
    114112}
    115113
    … …  
    132130}
    133131
    134 errno_t chardev_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, chardev_srvs_t *srvs)
     132errno_t chardev_conn(ipc_call_t *icall, chardev_srvs_t *srvs)
    135133{
    136134        chardev_srv_t *srv;
    … …  
    138136
    139137        /* Accept the connection */
    140         async_answer_0(icall_handle, EOK);
     138        async_answer_0(icall, EOK);
    141139
    142140        srv = chardev_srv_create(srvs);
    … …  
    152150        while (true) {
    153151                ipc_call_t call;
    154                 cap_call_handle_t chandle = async_get_call(&call);
     152                async_get_call(&call);
    155153                sysarg_t method = IPC_GET_IMETHOD(call);
    156154
    157155                if (!method) {
    158156                        /* The other side has hung up */
    159                         async_answer_0(chandle, EOK);
     157                        async_answer_0(&call, EOK);
    160158                        break;
    161159                }
    … …  
    163161                switch (method) {
    164162                case CHARDEV_READ:
    165                         chardev_read_srv(srv, chandle, &call);
     163                        chardev_read_srv(srv, &call);
    166164                        break;
    167165                case CHARDEV_WRITE:
    168                         chardev_write_srv(srv, chandle, &call);
     166                        chardev_write_srv(srv, &call);
    169167                        break;
    170168                default:
    171169                        if (srv->srvs->ops->def_handler != NULL)
    172                                 srv->srvs->ops->def_handler(srv, chandle, &call);
     170                                srv->srvs->ops->def_handler(srv, &call);
    173171                        else
    174                                 async_answer_0(chandle, ENOTSUP);
     172                                async_answer_0(&call, ENOTSUP);
    175173                }
    176174        }

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

    r76f566d r984a9ba  
    4242#include <io/con_srv.h>
    4343
    44 static errno_t console_ev_encode(cons_event_t *event, ipc_call_t *call)
    45 {
    46         IPC_SET_ARG1(*call, event->type);
     44static errno_t console_ev_encode(cons_event_t *event, ipc_call_t *icall)
     45{
     46        IPC_SET_ARG1(*icall, event->type);
    4747
    4848        switch (event->type) {
    4949        case CEV_KEY:
    50                 IPC_SET_ARG2(*call, event->ev.key.type);
    51                 IPC_SET_ARG3(*call, event->ev.key.key);
    52                 IPC_SET_ARG4(*call, event->ev.key.mods);
    53                 IPC_SET_ARG5(*call, event->ev.key.c);
     50                IPC_SET_ARG2(*icall, event->ev.key.type);
     51                IPC_SET_ARG3(*icall, event->ev.key.key);
     52                IPC_SET_ARG4(*icall, event->ev.key.mods);
     53                IPC_SET_ARG5(*icall, event->ev.key.c);
    5454                break;
    5555        case CEV_POS:
    56                 IPC_SET_ARG2(*call, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff));
    57                 IPC_SET_ARG3(*call, event->ev.pos.btn_num);
    58                 IPC_SET_ARG4(*call, event->ev.pos.hpos);
    59                 IPC_SET_ARG5(*call, event->ev.pos.vpos);
     56                IPC_SET_ARG2(*icall, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff));
     57                IPC_SET_ARG3(*icall, event->ev.pos.btn_num);
     58                IPC_SET_ARG4(*icall, event->ev.pos.hpos);
     59                IPC_SET_ARG5(*icall, event->ev.pos.vpos);
    6060                break;
    6161        default:
    … …  
    6666}
    6767
    68 static void con_read_srv(con_srv_t *srv, cap_call_handle_t chandle,
    69     ipc_call_t *call)
     68static void con_read_srv(con_srv_t *srv, ipc_call_t *icall)
    7069{
    7170        void *buf;
    7271        size_t size;
    7372        errno_t rc;
    74         cap_call_handle_t rcall_handle;
    75 
    76         if (!async_data_read_receive(&rcall_handle, &size)) {
    77                 async_answer_0(chandle, EINVAL);
     73
     74        ipc_call_t call;
     75        if (!async_data_read_receive(&call, &size)) {
     76                async_answer_0(icall, EINVAL);
    7877                return;
    7978        }
    … …  
    8180        buf = malloc(size);
    8281        if (buf == NULL) {
    83                 async_answer_0(rcall_handle, ENOMEM);
    84                 async_answer_0(chandle, ENOMEM);
     82                async_answer_0(&call, ENOMEM);
     83                async_answer_0(icall, ENOMEM);
    8584                return;
    8685        }
    8786
    8887        if (srv->srvs->ops->read == NULL) {
    89                 async_answer_0(rcall_handle, ENOTSUP);
    90                 async_answer_0(chandle, ENOTSUP);
     88                async_answer_0(&call, ENOTSUP);
     89                async_answer_0(icall, ENOTSUP);
    9190                free(buf);
    9291                return;
    … …  
    9695        rc = srv->srvs->ops->read(srv, buf, size, &nread);
    9796        if (rc != EOK) {
    98                 async_answer_0(rcall_handle, rc);
    99                 async_answer_0(chandle, rc);
     97                async_answer_0(&call, rc);
     98                async_answer_0(icall, rc);
    10099                free(buf);
    101100                return;
    102101        }
    103102
    104         async_data_read_finalize(rcall_handle, buf, nread);
     103        async_data_read_finalize(&call, buf, nread);
    105104        free(buf);
    106105
    107         async_answer_1(chandle, EOK, nread);
    108 }
    109 
    110 static void con_write_srv(con_srv_t *srv, cap_call_handle_t chandle,
    111     ipc_call_t *call)
     106        async_answer_1(icall, EOK, nread);
     107}
     108
     109static void con_write_srv(con_srv_t *srv, ipc_call_t *icall)
    112110{
    113111        void *data;
    … …  
    117115        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    118116        if (rc != EOK) {
    119                 async_answer_0(chandle, rc);
     117                async_answer_0(icall, rc);
    120118                return;
    121119        }
    122120
    123121        if (srv->srvs->ops->write == NULL) {
    124                 async_answer_0(chandle, ENOTSUP);
     122                async_answer_0(icall, ENOTSUP);
    125123                return;
    126124        }
    … …  
    130128        free(data);
    131129
    132         async_answer_1(chandle, rc, nwritten);
    133 }
    134 
    135 static void con_sync_srv(con_srv_t *srv, cap_call_handle_t chandle,
    136     ipc_call_t *call)
     130        async_answer_1(icall, rc, nwritten);
     131}
     132
     133static void con_sync_srv(con_srv_t *srv, ipc_call_t *icall)
    137134{
    138135        if (srv->srvs->ops->sync == NULL) {
    139                 async_answer_0(chandle, ENOTSUP);
     136                async_answer_0(icall, ENOTSUP);
    140137                return;
    141138        }
    142139
    143140        srv->srvs->ops->sync(srv);
    144         async_answer_0(chandle, EOK);
    145 }
    146 
    147 static void con_clear_srv(con_srv_t *srv, cap_call_handle_t chandle,
    148     ipc_call_t *call)
     141        async_answer_0(icall, EOK);
     142}
     143
     144static void con_clear_srv(con_srv_t *srv, ipc_call_t *icall)
    149145{
    150146        if (srv->srvs->ops->clear == NULL) {
    151                 async_answer_0(chandle, ENOTSUP);
     147                async_answer_0(icall, ENOTSUP);
    152148                return;
    153149        }
    154150
    155151        srv->srvs->ops->clear(srv);
    156         async_answer_0(chandle, EOK);
    157 }
    158 
    159 static void con_set_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    160     ipc_call_t *call)
     152        async_answer_0(icall, EOK);
     153}
     154
     155static void con_set_pos_srv(con_srv_t *srv, ipc_call_t *icall)
    161156{
    162157        sysarg_t col;
    163158        sysarg_t row;
    164159
    165         col = IPC_GET_ARG1(*call);
    166         row = IPC_GET_ARG2(*call);
     160        col = IPC_GET_ARG1(*icall);
     161        row = IPC_GET_ARG2(*icall);
    167162
    168163        if (srv->srvs->ops->set_pos == NULL) {
    169                 async_answer_0(chandle, ENOTSUP);
     164                async_answer_0(icall, ENOTSUP);
    170165                return;
    171166        }
    172167
    173168        srv->srvs->ops->set_pos(srv, col, row);
    174         async_answer_0(chandle, EOK);
    175 }
    176 
    177 static void con_get_pos_srv(con_srv_t *srv, cap_call_handle_t chandle,
    178     ipc_call_t *call)
     169        async_answer_0(icall, EOK);
     170}
     171
     172static void con_get_pos_srv(con_srv_t *srv, ipc_call_t *icall)
    179173{
    180174        errno_t rc;
    … …  
    183177
    184178        if (srv->srvs->ops->get_pos == NULL) {
    185                 async_answer_0(chandle, ENOTSUP);
     179                async_answer_0(icall, ENOTSUP);
    186180                return;
    187181        }
    188182
    189183        rc = srv->srvs->ops->get_pos(srv, &col, &row);
    190         async_answer_2(chandle, rc, col, row);
    191 }
    192 
    193 static void con_get_size_srv(con_srv_t *srv, cap_call_handle_t chandle,
    194     ipc_call_t *call)
     184        async_answer_2(icall, rc, col, row);
     185}
     186
     187static void con_get_size_srv(con_srv_t *srv, ipc_call_t *icall)
    195188{
    196189        errno_t rc;
    … …  
    199192
    200193        if (srv->srvs->ops->get_size == NULL) {
    201                 async_answer_0(chandle, ENOTSUP);
     194                async_answer_0(icall, ENOTSUP);
    202195                return;
    203196        }
    204197
    205198        rc = srv->srvs->ops->get_size(srv, &cols, &rows);
    206         async_answer_2(chandle, rc, cols, rows);
    207 }
    208 
    209 static void con_get_color_cap_srv(con_srv_t *srv, cap_call_handle_t chandle,
    210     ipc_call_t *call)
     199        async_answer_2(icall, rc, cols, rows);
     200}
     201
     202static void con_get_color_cap_srv(con_srv_t *srv, ipc_call_t *icall)
    211203{
    212204        errno_t rc;
    … …  
    214206
    215207        if (srv->srvs->ops->get_color_cap == NULL) {
    216                 async_answer_0(chandle, ENOTSUP);
     208                async_answer_0(icall, ENOTSUP);
    217209                return;
    218210        }
    219211
    220212        rc = srv->srvs->ops->get_color_cap(srv, &ccap);
    221         async_answer_1(chandle, rc, (sysarg_t)ccap);
    222 }
    223 
    224 static void con_set_style_srv(con_srv_t *srv, cap_call_handle_t chandle,
    225     ipc_call_t *call)
     213        async_answer_1(icall, rc, (sysarg_t)ccap);
     214}
     215
     216static void con_set_style_srv(con_srv_t *srv, ipc_call_t *icall)
    226217{
    227218        console_style_t style;
    228219
    229         style = IPC_GET_ARG1(*call);
     220        style = IPC_GET_ARG1(*icall);
    230221
    231222        if (srv->srvs->ops->set_style == NULL) {
    232                 async_answer_0(chandle, ENOTSUP);
     223                async_answer_0(icall, ENOTSUP);
    233224                return;
    234225        }
    235226
    236227        srv->srvs->ops->set_style(srv, style);
    237         async_answer_0(chandle, EOK);
    238 }
    239 
    240 static void con_set_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    241     ipc_call_t *call)
     228        async_answer_0(icall, EOK);
     229}
     230
     231static void con_set_color_srv(con_srv_t *srv, ipc_call_t *icall)
    242232{
    243233        console_color_t bgcolor;
    … …  
    245235        console_color_attr_t flags;
    246236
    247         bgcolor = IPC_GET_ARG1(*call);
    248         fgcolor = IPC_GET_ARG2(*call);
    249         flags = IPC_GET_ARG3(*call);
     237        bgcolor = IPC_GET_ARG1(*icall);
     238        fgcolor = IPC_GET_ARG2(*icall);
     239        flags = IPC_GET_ARG3(*icall);
    250240
    251241        if (srv->srvs->ops->set_color == NULL) {
    252                 async_answer_0(chandle, ENOTSUP);
     242                async_answer_0(icall, ENOTSUP);
    253243                return;
    254244        }
    255245
    256246        srv->srvs->ops->set_color(srv, bgcolor, fgcolor, flags);
    257         async_answer_0(chandle, EOK);
    258 }
    259 
    260 static void con_set_rgb_color_srv(con_srv_t *srv, cap_call_handle_t chandle,
    261     ipc_call_t *call)
     247        async_answer_0(icall, EOK);
     248}
     249
     250static void con_set_rgb_color_srv(con_srv_t *srv, ipc_call_t *icall)
    262251{
    263252        pixel_t bgcolor;
    264253        pixel_t fgcolor;
    265254
    266         bgcolor = IPC_GET_ARG1(*call);
    267         fgcolor = IPC_GET_ARG2(*call);
     255        bgcolor = IPC_GET_ARG1(*icall);
     256        fgcolor = IPC_GET_ARG2(*icall);
    268257
    269258        if (srv->srvs->ops->set_rgb_color == NULL) {
    270                 async_answer_0(chandle, ENOTSUP);
     259                async_answer_0(icall, ENOTSUP);
    271260                return;
    272261        }
    273262
    274263        srv->srvs->ops->set_rgb_color(srv, bgcolor, fgcolor);
    275         async_answer_0(chandle, EOK);
    276 }
    277 
    278 static void con_set_cursor_visibility_srv(con_srv_t *srv, cap_call_handle_t chandle,
    279     ipc_call_t *call)
     264        async_answer_0(icall, EOK);
     265}
     266
     267static void con_set_cursor_visibility_srv(con_srv_t *srv, ipc_call_t *icall)
    280268{
    281269        bool show;
    282270
    283         show = IPC_GET_ARG1(*call);
     271        show = IPC_GET_ARG1(*icall);
    284272
    285273        if (srv->srvs->ops->set_cursor_visibility == NULL) {
    286                 async_answer_0(chandle, ENOTSUP);
     274                async_answer_0(icall, ENOTSUP);
    287275                return;
    288276        }
    289277
    290278        srv->srvs->ops->set_cursor_visibility(srv, show);
    291         async_answer_0(chandle, EOK);
    292 }
    293 
    294 static void con_get_event_srv(con_srv_t *srv, cap_call_handle_t chandle,
    295     ipc_call_t *call)
     279        async_answer_0(icall, EOK);
     280}
     281
     282static void con_get_event_srv(con_srv_t *srv, ipc_call_t *icall)
    296283{
    297284        errno_t rc;
    … …  
    300287
    301288        if (srv->srvs->ops->get_event == NULL) {
    302                 async_answer_0(chandle, ENOTSUP);
     289                async_answer_0(icall, ENOTSUP);
    303290                return;
    304291        }
    … …  
    306293        rc = srv->srvs->ops->get_event(srv, &event);
    307294        if (rc != EOK) {
    308                 async_answer_0(chandle, rc);
     295                async_answer_0(icall, rc);
    309296                return;
    310297        }
    … …  
    312299        rc = console_ev_encode(&event, &result);
    313300        if (rc != EOK) {
    314                 async_answer_0(chandle, rc);
    315                 return;
    316         }
    317 
    318         async_answer_5(chandle, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
     301                async_answer_0(icall, rc);
     302                return;
     303        }
     304
     305        async_answer_5(icall, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
    319306            IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
    320307}
    … …  
    340327}
    341328
    342 errno_t con_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, con_srvs_t *srvs)
     329errno_t con_conn(ipc_call_t *icall, con_srvs_t *srvs)
    343330{
    344331        con_srv_t *srv;
    … …  
    346333
    347334        /* Accept the connection */
    348         async_answer_0(icall_handle, EOK);
     335        async_answer_0(icall, EOK);
    349336
    350337        srv = con_srv_create(srvs);
    … …  
    360347        while (true) {
    361348                ipc_call_t call;
    362                 cap_call_handle_t chandle = 0;
    363 
    364                 while (chandle == 0) {
     349                bool received = false;
     350
     351                while (!received) {
    365352                        /* XXX Need to be able to abort immediately */
    366                         chandle = async_get_call_timeout(&call,
     353                        received = async_get_call_timeout(&call,
    367354                            srvs->abort_timeout);
    368355
    369356                        if (srv->srvs->aborted) {
    370                                 if (chandle != 0)
    371                                         async_answer_0(chandle, EINTR);
     357                                if (received)
     358                                        async_answer_0(&call, EINTR);
    372359                                break;
    373360                        }
    374361                }
    375362
    376                 if (chandle == 0)
     363                if (!received)
    377364                        break;
    378365
    … …  
    381368                if (!method) {
    382369                        /* The other side has hung up */
    383                         async_answer_0(chandle, EOK);
     370                        async_answer_0(&call, EOK);
    384371                        break;
    385372                }
    … …  
    387374                switch (method) {
    388375                case VFS_OUT_READ:
    389                         con_read_srv(srv, chandle, &call);
     376                        con_read_srv(srv, &call);
    390377                        break;
    391378                case VFS_OUT_WRITE:
    392                         con_write_srv(srv, chandle, &call);
     379                        con_write_srv(srv, &call);
    393380                        break;
    394381                case VFS_OUT_SYNC:
    395                         con_sync_srv(srv, chandle, &call);
     382                        con_sync_srv(srv, &call);
    396383                        break;
    397384                case CONSOLE_CLEAR:
    398                         con_clear_srv(srv, chandle, &call);
     385                        con_clear_srv(srv, &call);
    399386                        break;
    400387                case CONSOLE_SET_POS:
    401                         con_set_pos_srv(srv, chandle, &call);
     388                        con_set_pos_srv(srv, &call);
    402389                        break;
    403390                case CONSOLE_GET_POS:
    404                         con_get_pos_srv(srv, chandle, &call);
     391                        con_get_pos_srv(srv, &call);
    405392                        break;
    406393                case CONSOLE_GET_SIZE:
    407                         con_get_size_srv(srv, chandle, &call);
     394                        con_get_size_srv(srv, &call);
    408395                        break;
    409396                case CONSOLE_GET_COLOR_CAP:
    410                         con_get_color_cap_srv(srv, chandle, &call);
     397                        con_get_color_cap_srv(srv, &call);
    411398                        break;
    412399                case CONSOLE_SET_STYLE:
    413                         con_set_style_srv(srv, chandle, &call);
     400                        con_set_style_srv(srv, &call);
    414401                        break;
    415402                case CONSOLE_SET_COLOR:
    416                         con_set_color_srv(srv, chandle, &call);
     403                        con_set_color_srv(srv, &call);
    417404                        break;
    418405                case CONSOLE_SET_RGB_COLOR:
    419                         con_set_rgb_color_srv(srv, chandle, &call);
     406                        con_set_rgb_color_srv(srv, &call);
    420407                        break;
    421408                case CONSOLE_SET_CURSOR_VISIBILITY:
    422                         con_set_cursor_visibility_srv(srv, chandle, &call);
     409                        con_set_cursor_visibility_srv(srv, &call);
    423410                        break;
    424411                case CONSOLE_GET_EVENT:
    425                         con_get_event_srv(srv, chandle, &call);
     412                        con_get_event_srv(srv, &call);
    426413                        break;
    427414                default:
    428                         async_answer_0(chandle, ENOTSUP);
     415                        async_answer_0(&call, ENOTSUP);
    429416                }
    430417        }

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

    r76f566d r984a9ba  
    4343#include <stdlib.h>
    4444
    45 static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     45static void input_cb_conn(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 chandle,
    95     ipc_call_t *call)
     94static void input_ev_active(input_t *input, ipc_call_t *call)
    9695{
    9796        errno_t rc = input->ev_ops->active(input);
    98         async_answer_0(chandle, rc);
    99 }
    100 
    101 static void input_ev_deactive(input_t *input, cap_call_handle_t chandle,
    102     ipc_call_t *call)
     97        async_answer_0(call, rc);
     98}
     99
     100static void input_ev_deactive(input_t *input, ipc_call_t *call)
    103101{
    104102        errno_t rc = input->ev_ops->deactive(input);
    105         async_answer_0(chandle, rc);
    106 }
    107 
    108 static void input_ev_key(input_t *input, cap_call_handle_t chandle,
    109     ipc_call_t *call)
     103        async_answer_0(call, rc);
     104}
     105
     106static void input_ev_key(input_t *input, ipc_call_t *call)
    110107{
    111108        kbd_event_type_t type;
    … …  
    121118
    122119        rc = input->ev_ops->key(input, type, key, mods, c);
    123         async_answer_0(chandle, rc);
    124 }
    125 
    126 static void input_ev_move(input_t *input, cap_call_handle_t chandle,
    127     ipc_call_t *call)
     120        async_answer_0(call, rc);
     121}
     122
     123static void input_ev_move(input_t *input, ipc_call_t *call)
    128124{
    129125        int dx;
    … …  
    135131
    136132        rc = input->ev_ops->move(input, dx, dy);
    137         async_answer_0(chandle, rc);
    138 }
    139 
    140 static void input_ev_abs_move(input_t *input, cap_call_handle_t chandle,
    141     ipc_call_t *call)
     133        async_answer_0(call, rc);
     134}
     135
     136static void input_ev_abs_move(input_t *input, ipc_call_t *call)
    142137{
    143138        unsigned x;
    … …  
    153148
    154149        rc = input->ev_ops->abs_move(input, x, y, max_x, max_y);
    155         async_answer_0(chandle, rc);
    156 }
    157 
    158 static void input_ev_button(input_t *input, cap_call_handle_t chandle,
    159     ipc_call_t *call)
     150        async_answer_0(call, rc);
     151}
     152
     153static void input_ev_button(input_t *input, ipc_call_t *call)
    160154{
    161155        int bnum;
    … …  
    167161
    168162        rc = input->ev_ops->button(input, bnum, press);
    169         async_answer_0(chandle, rc);
    170 }
    171 
    172 static void input_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    173 {
    174         input_t *input = (input_t *)arg;
     163        async_answer_0(call, rc);
     164}
     165
     166static void input_cb_conn(ipc_call_t *icall, void *arg)
     167{
     168        input_t *input = (input_t *) arg;
    175169
    176170        while (true) {
    177171                ipc_call_t call;
    178                 cap_call_handle_t chandle = async_get_call(&call);
     172                async_get_call(&call);
    179173
    180174                if (!IPC_GET_IMETHOD(call)) {
    … …  
    185179                switch (IPC_GET_IMETHOD(call)) {
    186180                case INPUT_EVENT_ACTIVE:
    187                         input_ev_active(input, chandle, &call);
     181                        input_ev_active(input, &call);
    188182                        break;
    189183                case INPUT_EVENT_DEACTIVE:
    190                         input_ev_deactive(input, chandle, &call);
     184                        input_ev_deactive(input, &call);
    191185                        break;
    192186                case INPUT_EVENT_KEY:
    193                         input_ev_key(input, chandle, &call);
     187                        input_ev_key(input, &call);
    194188                        break;
    195189                case INPUT_EVENT_MOVE:
    196                         input_ev_move(input, chandle, &call);
     190                        input_ev_move(input, &call);
    197191                        break;
    198192                case INPUT_EVENT_ABS_MOVE:
    199                         input_ev_abs_move(input, chandle, &call);
     193                        input_ev_abs_move(input, &call);
    200194                        break;
    201195                case INPUT_EVENT_BUTTON:
    202                         input_ev_button(input, chandle, &call);
     196                        input_ev_button(input, &call);
    203197                        break;
    204198                default:
    205                         async_answer_0(chandle, ENOTSUP);
     199                        async_answer_0(&call, ENOTSUP);
    206200                }
    207201        }

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

    r76f566d r984a9ba  
    4545#include <stdlib.h>
    4646
    47 static void iplink_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg);
     47static void iplink_cb_conn(ipc_call_t *icall, void *arg);
    4848
    4949errno_t iplink_open(async_sess_t *sess, iplink_ev_ops_t *ev_ops, void *arg,
    … …  
    197197}
    198198
    199 
    200199errno_t iplink_addr_add(iplink_t *iplink, inet_addr_t *addr)
    201200{
    … …  
    245244}
    246245
    247 static void iplink_ev_recv(iplink_t *iplink, cap_call_handle_t icall_handle,
    248     ipc_call_t *icall)
     246static void iplink_ev_recv(iplink_t *iplink, ipc_call_t *icall)
    249247{
    250248        iplink_recv_sdu_t sdu;
    … …  
    255253            &sdu.size);
    256254        if (rc != EOK) {
    257                 async_answer_0(icall_handle, rc);
     255                async_answer_0(icall, rc);
    258256                return;
    259257        }
    … …  
    261259        rc = iplink->ev_ops->recv(iplink, &sdu, ver);
    262260        free(sdu.data);
    263         async_answer_0(icall_handle, rc);
    264 }
    265 
    266 static void iplink_ev_change_addr(iplink_t *iplink, cap_call_handle_t icall_handle,
    267     ipc_call_t *icall)
     261        async_answer_0(icall, rc);
     262}
     263
     264static void iplink_ev_change_addr(iplink_t *iplink, ipc_call_t *icall)
    268265{
    269266        addr48_t *addr;
    270267        size_t size;
    271268
    272         errno_t rc = async_data_write_accept((void **)&addr, false,
     269        errno_t rc = async_data_write_accept((void **) &addr, false,
    273270            sizeof(addr48_t), sizeof(addr48_t), 0, &size);
    274271        if (rc != EOK) {
    275                 async_answer_0(icall_handle, rc);
     272                async_answer_0(icall, rc);
    276273                return;
    277274        }
    … …  
    279276        rc = iplink->ev_ops->change_addr(iplink, *addr);
    280277        free(addr);
    281         async_answer_0(icall_handle, EOK);
    282 }
    283 
    284 static void iplink_cb_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     278        async_answer_0(icall, EOK);
     279}
     280
     281static void iplink_cb_conn(ipc_call_t *icall, void *arg)
    285282{
    286283        iplink_t *iplink = (iplink_t *) arg;
    … …  
    288285        while (true) {
    289286                ipc_call_t call;
    290                 cap_call_handle_t chandle = async_get_call(&call);
     287                async_get_call(&call);
    291288
    292289                if (!IPC_GET_IMETHOD(call)) {
    … …  
    297294                switch (IPC_GET_IMETHOD(call)) {
    298295                case IPLINK_EV_RECV:
    299                         iplink_ev_recv(iplink, chandle, &call);
     296                        iplink_ev_recv(iplink, &call);
    300297                        break;
    301298                case IPLINK_EV_CHANGE_ADDR:
    302                         iplink_ev_change_addr(iplink, chandle, &call);
     299                        iplink_ev_change_addr(iplink, &call);
    303300                        break;
    304301                default:
    305                         async_answer_0(chandle, ENOTSUP);
     302                        async_answer_0(&call, ENOTSUP);
    306303                }
    307304        }

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

    r76f566d r984a9ba  
    4242#include <inet/iplink_srv.h>
    4343
    44 static void iplink_get_mtu_srv(iplink_srv_t *srv, cap_call_handle_t chandle,
    45     ipc_call_t *call)
     44static void iplink_get_mtu_srv(iplink_srv_t *srv, ipc_call_t *call)
    4645{
    4746        size_t mtu;
    4847        errno_t rc = srv->ops->get_mtu(srv, &mtu);
    49         async_answer_1(chandle, rc, mtu);
    50 }
    51 
    52 static void iplink_get_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    53     ipc_call_t *icall)
     48        async_answer_1(call, rc, mtu);
     49}
     50
     51static void iplink_get_mac48_srv(iplink_srv_t *srv, ipc_call_t *icall)
    5452{
    5553        addr48_t mac;
    5654        errno_t rc = srv->ops->get_mac48(srv, &mac);
    5755        if (rc != EOK) {
    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);
     56                async_answer_0(icall, rc);
     57                return;
     58        }
     59
     60        ipc_call_t call;
     61        size_t size;
     62        if (!async_data_read_receive(&call, &size)) {
     63                async_answer_0(&call, EREFUSED);
     64                async_answer_0(icall, EREFUSED);
    6765                return;
    6866        }
    6967
    7068        if (size != sizeof(addr48_t)) {
    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);
     69                async_answer_0(&call, EINVAL);
     70                async_answer_0(icall, EINVAL);
     71                return;
     72        }
     73
     74        rc = async_data_read_finalize(&call, &mac, size);
    7775        if (rc != EOK)
    78                 async_answer_0(chandle, rc);
    79 
    80         async_answer_0(icall_handle, rc);
    81 }
    82 
    83 static void iplink_set_mac48_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    84     ipc_call_t *icall)
     76                async_answer_0(&call, rc);
     77
     78        async_answer_0(icall, rc);
     79}
     80
     81static void iplink_set_mac48_srv(iplink_srv_t *srv, ipc_call_t *icall)
    8582{
    8683        errno_t rc;
    8784        size_t size;
    8885        addr48_t mac;
    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);
     86
     87        ipc_call_t call;
     88        if (!async_data_write_receive(&call, &size)) {
     89                async_answer_0(&call, EREFUSED);
     90                async_answer_0(icall, EREFUSED);
    9491        }
    9592
    9693        rc = srv->ops->set_mac48(srv, &mac);
    9794        if (rc != EOK) {
    98                 async_answer_0(icall_handle, rc);
    99                 return;
    100         }
    101 
    102         rc = async_data_read_finalize(chandle, &mac, sizeof(addr48_t));
     95                async_answer_0(icall, rc);
     96                return;
     97        }
     98
     99        rc = async_data_read_finalize(&call, &mac, sizeof(addr48_t));
    103100        if (rc != EOK)
    104                 async_answer_0(chandle, rc);
    105 
    106         async_answer_0(icall_handle, rc);
    107 }
    108 
    109 static 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);
     101                async_answer_0(&call, rc);
     102
     103        async_answer_0(icall, rc);
     104}
     105
     106static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_call_t *icall)
     107{
     108        ipc_call_t call;
     109        size_t size;
     110        if (!async_data_write_receive(&call, &size)) {
     111                async_answer_0(&call, EREFUSED);
     112                async_answer_0(icall, EREFUSED);
    117113                return;
    118114        }
    119115
    120116        if (size != sizeof(inet_addr_t)) {
    121                 async_answer_0(chandle, EINVAL);
    122                 async_answer_0(icall_handle, EINVAL);
     117                async_answer_0(&call, EINVAL);
     118                async_answer_0(icall, EINVAL);
    123119                return;
    124120        }
    125121
    126122        inet_addr_t addr;
    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);
     123        errno_t rc = async_data_write_finalize(&call, &addr, size);
     124        if (rc != EOK) {
     125                async_answer_0(&call, rc);
     126                async_answer_0(icall, rc);
    131127        }
    132128
    133129        rc = srv->ops->addr_add(srv, &addr);
    134         async_answer_0(icall_handle, rc);
    135 }
    136 
    137 static 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);
     130        async_answer_0(icall, rc);
     131}
     132
     133static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_call_t *icall)
     134{
     135        ipc_call_t call;
     136        size_t size;
     137        if (!async_data_write_receive(&call, &size)) {
     138                async_answer_0(&call, EREFUSED);
     139                async_answer_0(icall, EREFUSED);
    145140                return;
    146141        }
    147142
    148143        if (size != sizeof(inet_addr_t)) {
    149                 async_answer_0(chandle, EINVAL);
    150                 async_answer_0(icall_handle, EINVAL);
     144                async_answer_0(&call, EINVAL);
     145                async_answer_0(icall, EINVAL);
    151146                return;
    152147        }
    153148
    154149        inet_addr_t addr;
    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);
     150        errno_t rc = async_data_write_finalize(&call, &addr, size);
     151        if (rc != EOK) {
     152                async_answer_0(&call, rc);
     153                async_answer_0(icall, rc);
    159154        }
    160155
    161156        rc = srv->ops->addr_remove(srv, &addr);
    162         async_answer_0(icall_handle, rc);
    163 }
    164 
    165 static void iplink_send_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    166     ipc_call_t *icall)
     157        async_answer_0(icall, rc);
     158}
     159
     160static void iplink_send_srv(iplink_srv_t *srv, ipc_call_t *icall)
    167161{
    168162        iplink_sdu_t sdu;
    … …  
    174168            &sdu.size);
    175169        if (rc != EOK) {
    176                 async_answer_0(icall_handle, rc);
     170                async_answer_0(icall, rc);
    177171                return;
    178172        }
    … …  
    180174        rc = srv->ops->send(srv, &sdu);
    181175        free(sdu.data);
    182         async_answer_0(icall_handle, rc);
    183 }
    184 
    185 static void iplink_send6_srv(iplink_srv_t *srv, cap_call_handle_t icall_handle,
    186     ipc_call_t *icall)
     176        async_answer_0(icall, rc);
     177}
     178
     179static void iplink_send6_srv(iplink_srv_t *srv, ipc_call_t *icall)
    187180{
    188181        iplink_sdu6_t sdu;
    189182
    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);
     183        ipc_call_t call;
     184        size_t size;
     185        if (!async_data_write_receive(&call, &size)) {
     186                async_answer_0(&call, EREFUSED);
     187                async_answer_0(icall, EREFUSED);
    195188                return;
    196189        }
    197190
    198191        if (size != sizeof(addr48_t)) {
    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);
     192                async_answer_0(&call, EINVAL);
     193                async_answer_0(icall, EINVAL);
     194                return;
     195        }
     196
     197        errno_t rc = async_data_write_finalize(&call, &sdu.dest, size);
     198        if (rc != EOK) {
     199                async_answer_0(&call, rc);
     200                async_answer_0(icall, rc);
    208201        }
    209202
    … …  
    211204            &sdu.size);
    212205        if (rc != EOK) {
    213                 async_answer_0(icall_handle, rc);
     206                async_answer_0(icall, rc);
    214207                return;
    215208        }
    … …  
    217210        rc = srv->ops->send6(srv, &sdu);
    218211        free(sdu.data);
    219         async_answer_0(icall_handle, rc);
     212        async_answer_0(icall, rc);
    220213}
    221214
    … …  
    229222}
    230223
    231 errno_t iplink_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     224errno_t iplink_conn(ipc_call_t *icall, void *arg)
    232225{
    233226        iplink_srv_t *srv = (iplink_srv_t *) arg;
    … …  
    237230        if (srv->connected) {
    238231                fibril_mutex_unlock(&srv->lock);
    239                 async_answer_0(icall_handle, EBUSY);
     232                async_answer_0(icall, EBUSY);
    240233                return EBUSY;
    241234        }
    … …  
    245238
    246239        /* Accept the connection */
    247         async_answer_0(icall_handle, EOK);
     240        async_answer_0(icall, EOK);
    248241
    249242        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    … …  
    259252        while (true) {
    260253                ipc_call_t call;
    261                 cap_call_handle_t chandle = async_get_call(&call);
     254                async_get_call(&call);
    262255                sysarg_t method = IPC_GET_IMETHOD(call);
    263256
    … …  
    267260                        srv->connected = false;
    268261                        fibril_mutex_unlock(&srv->lock);
    269                         async_answer_0(chandle, EOK);
     262                        async_answer_0(&call, EOK);
    270263                        break;
    271264                }
    … …  
    273266                switch (method) {
    274267                case IPLINK_GET_MTU:
    275                         iplink_get_mtu_srv(srv, chandle, &call);
     268                        iplink_get_mtu_srv(srv, &call);
    276269                        break;
    277270                case IPLINK_GET_MAC48:
    278                         iplink_get_mac48_srv(srv, chandle, &call);
     271                        iplink_get_mac48_srv(srv, &call);
    279272                        break;
    280273                case IPLINK_SET_MAC48:
    281                         iplink_set_mac48_srv(srv, chandle, &call);
     274                        iplink_set_mac48_srv(srv, &call);
    282275                        break;
    283276                case IPLINK_SEND:
    284                         iplink_send_srv(srv, chandle, &call);
     277                        iplink_send_srv(srv, &call);
    285278                        break;
    286279                case IPLINK_SEND6:
    287                         iplink_send6_srv(srv, chandle, &call);
     280                        iplink_send6_srv(srv, &call);
    288281                        break;
    289282                case IPLINK_ADDR_ADD:
    290                         iplink_addr_add_srv(srv, chandle, &call);
     283                        iplink_addr_add_srv(srv, &call);
    291284                        break;
    292285                case IPLINK_ADDR_REMOVE:
    293                         iplink_addr_remove_srv(srv, chandle, &call);
     286                        iplink_addr_remove_srv(srv, &call);
    294287                        break;
    295288                default:
    296                         async_answer_0(chandle, EINVAL);
     289                        async_answer_0(&call, EINVAL);
    297290                }
    298291        }

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

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

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

    r76f566d r984a9ba  
    802802errno_t vfs_receive_handle(bool high, int *handle)
    803803{
    804         cap_call_handle_t chandle;
    805         if (!async_state_change_receive(&chandle, NULL, NULL, NULL)) {
    806                 async_answer_0(chandle, EINVAL);
     804        ipc_call_t call;
     805        if (!async_state_change_receive(&call)) {
     806                async_answer_0(&call, EINVAL);
    807807                return EINVAL;
    808808        }
    … …  
    810810        async_exch_t *vfs_exch = vfs_exchange_begin();
    811811
    812         async_state_change_finalize(chandle, vfs_exch);
     812        async_state_change_finalize(&call, vfs_exch);
    813813
    814814        sysarg_t ret;

  • uspace/lib/c/include/async.h

    r76f566d r984a9ba  
    6161/** Port connection handler
    6262 *
    63  * @param chandle  Handle of the incoming call or CAP_NIL if connection
    64  *                 initiated from inside using async_create_callback_port()
    65  * @param call     Incoming call or 0 if connection initiated from inside
    66  *                 using async_create_callback_port()
    67  * @param arg      Local argument.
    68  *
    69  */
    70 typedef void (*async_port_handler_t)(cap_call_handle_t, ipc_call_t *, void *);
     63 * @param call Incoming call or NULL if connection initiated from inside
     64 *             using async_create_callback_port()
     65 * @param arg  Local argument.
     66 *
     67 */
     68typedef void (*async_port_handler_t)(ipc_call_t *, void *);
    7169
    7270/** Notification handler */
    … …  
    115113        async_get_call_timeout(data, 0)
    116114
    117 extern cap_call_handle_t async_get_call_timeout(ipc_call_t *, suseconds_t);
     115extern bool async_get_call_timeout(ipc_call_t *, suseconds_t);
    118116
    119117/*
    … …  
    194192 */
    195193
    196 extern errno_t async_answer_0(cap_call_handle_t, errno_t);
    197 extern errno_t async_answer_1(cap_call_handle_t, errno_t, sysarg_t);
    198 extern errno_t async_answer_2(cap_call_handle_t, errno_t, sysarg_t, sysarg_t);
    199 extern errno_t async_answer_3(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     194extern errno_t async_answer_0(ipc_call_t *, errno_t);
     195extern errno_t async_answer_1(ipc_call_t *, errno_t, sysarg_t);
     196extern errno_t async_answer_2(ipc_call_t *, errno_t, sysarg_t, sysarg_t);
     197extern errno_t async_answer_3(ipc_call_t *, errno_t, sysarg_t, sysarg_t,
    200198    sysarg_t);
    201 extern errno_t async_answer_4(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     199extern errno_t async_answer_4(ipc_call_t *, errno_t, sysarg_t, sysarg_t,
    202200    sysarg_t, sysarg_t);
    203 extern errno_t async_answer_5(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     201extern errno_t async_answer_5(ipc_call_t *, errno_t, sysarg_t, sysarg_t,
    204202    sysarg_t, sysarg_t, sysarg_t);
    205203
    … …  
    208206 */
    209207
    210 extern errno_t async_forward_fast(cap_call_handle_t, async_exch_t *, sysarg_t,
     208extern errno_t async_forward_fast(ipc_call_t *, async_exch_t *, sysarg_t,
    211209    sysarg_t, sysarg_t, unsigned int);
    212 extern errno_t async_forward_slow(cap_call_handle_t, async_exch_t *, sysarg_t,
     210extern errno_t async_forward_slow(ipc_call_t *, async_exch_t *, sysarg_t,
    213211    sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, unsigned int);
    214212
    … …  
    380378extern errno_t async_share_in_start(async_exch_t *, size_t, sysarg_t,
    381379    unsigned int *, void **);
    382 extern bool async_share_in_receive(cap_call_handle_t *, size_t *);
    383 extern errno_t async_share_in_finalize(cap_call_handle_t, void *, unsigned int);
     380extern bool async_share_in_receive(ipc_call_t *, size_t *);
     381extern errno_t async_share_in_finalize(ipc_call_t *, void *, unsigned int);
    384382
    385383extern errno_t async_share_out_start(async_exch_t *, void *, unsigned int);
    386 extern bool async_share_out_receive(cap_call_handle_t *, size_t *,
    387     unsigned int *);
    388 extern errno_t async_share_out_finalize(cap_call_handle_t, void **);
     384extern bool async_share_out_receive(ipc_call_t *, size_t *, unsigned int *);
     385extern errno_t async_share_out_finalize(ipc_call_t *, void **);
    389386
    390387/*
    … …  
    420417extern aid_t async_data_read(async_exch_t *, void *, size_t, ipc_call_t *);
    421418extern errno_t async_data_read_start(async_exch_t *, void *, size_t);
    422 extern bool async_data_read_receive(cap_call_handle_t *, size_t *);
    423 extern bool async_data_read_receive_call(cap_call_handle_t *, ipc_call_t *,
    424     size_t *);
    425 extern errno_t async_data_read_finalize(cap_call_handle_t, const void *,
    426     size_t);
     419extern bool async_data_read_receive(ipc_call_t *, size_t *);
     420extern errno_t async_data_read_finalize(ipc_call_t *, const void *, size_t);
    427421
    428422extern errno_t async_data_read_forward_fast(async_exch_t *, sysarg_t, sysarg_t,
    … …  
    461455
    462456extern errno_t async_data_write_start(async_exch_t *, const void *, size_t);
    463 extern bool async_data_write_receive(cap_call_handle_t *, size_t *);
    464 extern bool async_data_write_receive_call(cap_call_handle_t *, ipc_call_t *,
    465     size_t *);
    466 extern errno_t async_data_write_finalize(cap_call_handle_t, void *, size_t);
     457extern bool async_data_write_receive(ipc_call_t *, size_t *);
     458extern errno_t async_data_write_finalize(ipc_call_t *, void *, size_t);
    467459
    468460extern errno_t async_data_write_accept(void **, const bool, const size_t,
    … …  
    478470extern errno_t async_state_change_start(async_exch_t *, sysarg_t, sysarg_t,
    479471    sysarg_t, async_exch_t *);
    480 extern bool async_state_change_receive(cap_call_handle_t *, sysarg_t *,
    481     sysarg_t *, sysarg_t *);
    482 extern errno_t async_state_change_finalize(cap_call_handle_t, async_exch_t *);
     472extern bool async_state_change_receive(ipc_call_t *);
     473extern errno_t async_state_change_finalize(ipc_call_t *, async_exch_t *);
    483474
    484475extern void *async_remote_state_acquire(async_sess_t *);

  • uspace/lib/c/include/bd_srv.h

    r76f566d r984a9ba  
    7070extern void bd_srvs_init(bd_srvs_t *);
    7171
    72 extern errno_t bd_conn(cap_call_handle_t, ipc_call_t *, bd_srvs_t *);
     72extern errno_t bd_conn(ipc_call_t *, bd_srvs_t *);
    7373
    7474#endif

  • uspace/lib/c/include/inet/iplink_srv.h

    r76f566d r984a9ba  
    6666extern void iplink_srv_init(iplink_srv_t *);
    6767
    68 extern errno_t iplink_conn(cap_call_handle_t, ipc_call_t *, void *);
     68extern errno_t iplink_conn(ipc_call_t *, void *);
    6969extern errno_t iplink_ev_recv(iplink_srv_t *, iplink_recv_sdu_t *, ip_ver_t);
    7070extern errno_t iplink_ev_change_addr(iplink_srv_t *, addr48_t *);

  • uspace/lib/c/include/io/chardev_srv.h

    r76f566d r984a9ba  
    6161        errno_t (*read)(chardev_srv_t *, void *, size_t, size_t *);
    6262        errno_t (*write)(chardev_srv_t *, const void *, size_t, size_t *);
    63         void (*def_handler)(chardev_srv_t *, cap_call_handle_t, ipc_call_t *);
     63        void (*def_handler)(chardev_srv_t *, ipc_call_t *);
    6464};
    6565
    6666extern void chardev_srvs_init(chardev_srvs_t *);
    6767
    68 extern errno_t chardev_conn(cap_call_handle_t, ipc_call_t *, chardev_srvs_t *);
     68extern errno_t chardev_conn(ipc_call_t *, chardev_srvs_t *);
    6969
    7070#endif

  • uspace/lib/c/include/io/con_srv.h

    r76f566d r984a9ba  
    8787extern void con_srvs_init(con_srvs_t *);
    8888
    89 extern errno_t con_conn(cap_call_handle_t, ipc_call_t *, con_srvs_t *);
     89extern errno_t con_conn(ipc_call_t *, con_srvs_t *);
    9090
    9191#endif
Note: See TracChangeset for help on using the changeset viewer.