Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4d6629f r6a5d05b  
    7777 *   }
    7878 *
    79  *   port_handler(icallid, *icall)
     79 *   port_handler(ichandle, *icall)
    8080 *   {
    8181 *     if (want_refuse) {
    82  *       async_answer_0(icallid, ELIMIT);
     82 *       async_answer_0(ichandle, ELIMIT);
    8383 *       return;
    8484 *     }
    85  *     async_answer_0(icallid, EOK);
    86  *
    87  *     callid = async_get_call(&call);
    88  *     somehow_handle_the_call(callid, call);
    89  *     async_answer_2(callid, 1, 2, 3);
    90  *
    91  *     callid = async_get_call(&call);
     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);
    9292 *     ...
    9393 *   }
    … …  
    106106#include <fibril.h>
    107107#include <adt/hash_table.h>
     108#include <adt/hash.h>
    108109#include <adt/list.h>
    109110#include <assert.h>
    … …  
    112113#include <libarch/barrier.h>
    113114#include <stdbool.h>
    114 #include <malloc.h>
     115#include <stdlib.h>
    115116#include <mem.h>
    116117#include <stdlib.h>
    … …  
    184185        link_t link;
    185186       
    186         ipc_callid_t callid;
     187        cap_handle_t chandle;
    187188        ipc_call_t call;
    188189} msg_t;
    … …  
    204205        ipc_call_t *dataptr;
    205206       
    206         sysarg_t retval;
     207        int retval;
    207208} amsg_t;
    208209
    … …  
    236237       
    237238        /** Identification of the opening call. */
    238         ipc_callid_t callid;
     239        cap_handle_t chandle;
    239240       
    240241        /** Call data of the opening call. */
    … …  
    242243       
    243244        /** Identification of the closing call. */
    244         ipc_callid_t close_callid;
     245        cap_handle_t close_chandle;
    245246       
    246247        /** Fibril function that will be used to handle the connection. */
    … …  
    331332                msg->destroyed = false;
    332333                msg->dataptr = NULL;
    333                 msg->retval = (sysarg_t) EINVAL;
     334                msg->retval = EINVAL;
    334335                awaiter_initialize(&msg->wdata);
    335336        }
    … …  
    373374/** Default fallback fibril function.
    374375 *
    375  * This fallback fibril function gets called on incomming
    376  * connections that do not have a specific handler defined.
    377  *
    378  * @param callid Hash of the incoming call.
    379  * @param call   Data of the incoming call.
    380  * @param arg    Local argument
    381  *
    382  */
    383 static void default_fallback_port_handler(ipc_callid_t callid, ipc_call_t *call,
    384     void *arg)
    385 {
    386         ipc_answer_0(callid, ENOENT);
     376 * This fallback fibril function gets called on incomming connections that do
     377 * not have a specific handler defined.
     378 *
     379 * @param chandle  Handle of the incoming call.
     380 * @param call     Data of the incoming call.
     381 * @param arg      Local argument
     382 *
     383 */
     384static void default_fallback_port_handler(cap_handle_t chandle,
     385    ipc_call_t *call, void *arg)
     386{
     387        ipc_answer_0(chandle, ENOENT);
    387388}
    388389
    … …  
    587588};
    588589
    589 /** Compute hash into the connection hash table based on the source phone hash.
    590  *
    591  * @param key Pointer to source phone hash.
     590typedef struct {
     591        task_id_t task_id;
     592        sysarg_t phone_hash;
     593} conn_key_t;
     594
     595/** Compute hash into the connection hash table
     596 *
     597 * The hash is based on the source task ID and the source phone hash. The task
     598 * ID is included in the hash because a phone hash alone might not be unique
     599 * while we still track connections for killed tasks due to kernel's recycling
     600 * of phone structures.
     601 *
     602 * @param key Pointer to the connection key structure.
    592603 *
    593604 * @return Index into the connection hash table.
    … …  
    596607static size_t conn_key_hash(void *key)
    597608{
    598         sysarg_t in_phone_hash = *(sysarg_t *) key;
    599         return in_phone_hash;
     609        conn_key_t *ck = (conn_key_t *) key;
     610
     611        size_t hash = 0;
     612        hash = hash_combine(hash, LOWER32(ck->task_id));
     613        hash = hash_combine(hash, UPPER32(ck->task_id));
     614        hash = hash_combine(hash, ck->phone_hash);
     615        return hash;
    600616}
    601617
    … …  
    603619{
    604620        connection_t *conn = hash_table_get_inst(item, connection_t, link);
    605         return conn_key_hash(&conn->in_phone_hash);
     621        return conn_key_hash(&(conn_key_t){
     622                .task_id = conn->in_task_id,
     623                .phone_hash = conn->in_phone_hash
     624        });
    606625}
    607626
    608627static bool conn_key_equal(void *key, const ht_link_t *item)
    609628{
    610         sysarg_t in_phone_hash = *(sysarg_t *) key;
     629        conn_key_t *ck = (conn_key_t *) key;
    611630        connection_t *conn = hash_table_get_inst(item, connection_t, link);
    612         return (in_phone_hash == conn->in_phone_hash);
     631        return ((ck->task_id == conn->in_task_id) &&
     632            (ck->phone_hash == conn->in_phone_hash));
    613633}
    614634
    … …  
    695715        client_t *client = async_client_get(fibril_connection->in_task_id, true);
    696716        if (!client) {
    697                 ipc_answer_0(fibril_connection->callid, ENOMEM);
     717                ipc_answer_0(fibril_connection->chandle, ENOMEM);
    698718                return 0;
    699719        }
    … …  
    704724         * Call the connection handler function.
    705725         */
    706         fibril_connection->handler(fibril_connection->callid,
     726        fibril_connection->handler(fibril_connection->chandle,
    707727            &fibril_connection->call, fibril_connection->data);
    708728       
    … …  
    716736         */
    717737        futex_down(&async_futex);
    718         hash_table_remove(&conn_hash_table, &fibril_connection->in_phone_hash);
     738        hash_table_remove(&conn_hash_table, &(conn_key_t){
     739                .task_id = fibril_connection->in_task_id,
     740                .phone_hash = fibril_connection->in_phone_hash
     741        });
    719742        futex_up(&async_futex);
    720743       
    … …  
    728751               
    729752                list_remove(&msg->link);
    730                 ipc_answer_0(msg->callid, EHANGUP);
     753                ipc_answer_0(msg->chandle, EHANGUP);
    731754                free(msg);
    732755        }
    … …  
    736759         * i.e. IPC_M_PHONE_HUNGUP.
    737760         */
    738         if (fibril_connection->close_callid)
    739                 ipc_answer_0(fibril_connection->close_callid, EOK);
     761        if (fibril_connection->close_chandle)
     762                ipc_answer_0(fibril_connection->close_chandle, EOK);
    740763       
    741764        free(fibril_connection);
    742         return 0;
     765        return EOK;
    743766}
    744767
    745768/** Create a new fibril for a new connection.
    746769 *
    747  * Create new fibril for connection, fill in connection structures
    748  * and insert it into the hash table, so that later we can easily
    749  * do routing of messages to particular fibrils.
    750  *
    751  * @param in_task_id    Identification of the incoming connection.
    752  * @param in_phone_hash Identification of the incoming connection.
    753  * @param callid        Hash of the opening IPC_M_CONNECT_ME_TO call.
    754  *                      If callid is zero, the connection was opened by
    755  *                      accepting the IPC_M_CONNECT_TO_ME call and this
    756  *                      function is called directly by the server.
    757  * @param call          Call data of the opening call.
    758  * @param handler       Connection handler.
    759  * @param data          Client argument to pass to the connection handler.
    760  *
    761  * @return New fibril id or NULL on failure.
     770 * Create new fibril for connection, fill in connection structures and insert it
     771 * into the hash table, so that later we can easily do routing of messages to
     772 * particular fibrils.
     773 *
     774 * @param in_task_id     Identification of the incoming connection.
     775 * @param in_phone_hash  Identification of the incoming connection.
     776 * @param chandle        Handle of the opening IPC_M_CONNECT_ME_TO call.
     777 *                       If chandle is CAP_NIL, the connection was opened by
     778 *                       accepting the IPC_M_CONNECT_TO_ME call and this
     779 *                       function is called directly by the server.
     780 * @param call           Call data of the opening call.
     781 * @param handler        Connection handler.
     782 * @param data           Client argument to pass to the connection handler.
     783 *
     784 * @return  New fibril id or NULL on failure.
    762785 *
    763786 */
    764787static fid_t async_new_connection(task_id_t in_task_id, sysarg_t in_phone_hash,
    765     ipc_callid_t callid, ipc_call_t *call, async_port_handler_t handler,
     788    cap_handle_t chandle, ipc_call_t *call, async_port_handler_t handler,
    766789    void *data)
    767790{
    768791        connection_t *conn = malloc(sizeof(*conn));
    769792        if (!conn) {
    770                 if (callid)
    771                         ipc_answer_0(callid, ENOMEM);
     793                if (chandle != CAP_NIL)
     794                        ipc_answer_0(chandle, ENOMEM);
    772795               
    773796                return (uintptr_t) NULL;
    … …  
    777800        conn->in_phone_hash = in_phone_hash;
    778801        list_initialize(&conn->msg_queue);
    779         conn->callid = callid;
    780         conn->close_callid = 0;
     802        conn->chandle = chandle;
     803        conn->close_chandle = CAP_NIL;
    781804        conn->handler = handler;
    782805        conn->data = data;
    … …  
    792815                free(conn);
    793816               
    794                 if (callid)
    795                         ipc_answer_0(callid, ENOMEM);
     817                if (chandle != CAP_NIL)
     818                        ipc_answer_0(chandle, ENOMEM);
    796819               
    797820                return (uintptr_t) NULL;
    … …  
    821844 * @param port_id ID of the newly created port.
    822845 *
    823  * @return Zero on success or a negative error code.
     846 * @return Zero on success or an error code.
    824847 *
    825848 */
    … …  
    837860            &answer);
    838861       
    839         sysarg_t ret;
     862        int ret;
    840863        async_wait_for(req, &ret);
    841864        if (ret != EOK)
    … …  
    869892       
    870893        fid_t fid = async_new_connection(answer.in_task_id, phone_hash,
    871             0, NULL, handler, data);
     894            CAP_NIL, NULL, handler, data);
    872895        if (fid == (uintptr_t) NULL)
    873896                return ENOMEM;
    … …  
    938961 * timeouts are unregistered.
    939962 *
    940  * @param callid Hash of the incoming call.
    941  * @param call   Data of the incoming call.
     963 * @param chandle  Handle of the incoming call.
     964 * @param call     Data of the incoming call.
    942965 *
    943966 * @return False if the call doesn't match any connection.
    … …  
    945968 *
    946969 */
    947 static bool route_call(ipc_callid_t callid, ipc_call_t *call)
     970static bool route_call(cap_handle_t chandle, ipc_call_t *call)
    948971{
    949972        assert(call);
    … …  
    951974        futex_down(&async_futex);
    952975       
    953         ht_link_t *link = hash_table_find(&conn_hash_table, &call->in_phone_hash);
     976        ht_link_t *link = hash_table_find(&conn_hash_table, &(conn_key_t){
     977                .task_id = call->in_task_id,
     978                .phone_hash = call->in_phone_hash
     979        });
    954980        if (!link) {
    955981                futex_up(&async_futex);
    … …  
    965991        }
    966992       
    967         msg->callid = callid;
     993        msg->chandle = chandle;
    968994        msg->call = *call;
    969995        list_append(&msg->link, &conn->msg_queue);
    970996       
    971997        if (IPC_GET_IMETHOD(*call) == IPC_M_PHONE_HUNGUP)
    972                 conn->close_callid = callid;
     998                conn->close_chandle = chandle;
    973999       
    9741000        /* If the connection fibril is waiting for an event, activate it */
    … …  
    9911017/** Process notification.
    9921018 *
    993  * @param callid Hash of the incoming call.
    9941019 * @param call   Data of the incoming call.
    9951020 *
    9961021 */
    997 static void process_notification(ipc_callid_t callid, ipc_call_t *call)
     1022static void process_notification(ipc_call_t *call)
    9981023{
    9991024        async_notification_handler_t handler = NULL;
    … …  
    10161041       
    10171042        if (handler)
    1018                 handler(callid, call, data);
     1043                handler(call, data);
    10191044}
    10201045
    … …  
    10261051 * @param ucode   Top-half pseudocode handler.
    10271052 *
    1028  * @return IRQ capability handle on success.
    1029  * @return Negative error code.
     1053 * @param[out] handle  IRQ capability handle on success.
     1054 *
     1055 * @return An error code.
    10301056 *
    10311057 */
    10321058int async_irq_subscribe(int inr, async_notification_handler_t handler,
    1033     void *data, const irq_code_t *ucode)
     1059    void *data, const irq_code_t *ucode, cap_handle_t *handle)
    10341060{
    10351061        notification_t *notification =
    … …  
    10511077        futex_up(&async_futex);
    10521078       
    1053         return ipc_irq_subscribe(inr, imethod, ucode);
     1079        cap_handle_t cap;
     1080        int rc = ipc_irq_subscribe(inr, imethod, ucode, &cap);
     1081        if (rc == EOK && handle != NULL) {
     1082                *handle = cap;
     1083        }
     1084        return rc;
    10541085}
    10551086
    … …  
    10581089 * @param cap     IRQ capability handle.
    10591090 *
    1060  * @return Zero on success or a negative error code.
     1091 * @return Zero on success or an error code.
    10611092 *
    10621093 */
    … …  
    10751106 * @param data    Notification handler client data.
    10761107 *
    1077  * @return Zero on success or a negative error code.
     1108 * @return Zero on success or an error code.
    10781109 *
    10791110 */
    … …  
    11081139 * @param data    Notification handler client data.
    11091140 *
    1110  * @return Zero on success or a negative error code.
     1141 * @return Zero on success or an error code.
    11111142 *
    11121143 */
    … …  
    11611192/** Return new incoming message for the current (fibril-local) connection.
    11621193 *
    1163  * @param call  Storage where the incoming call data will be stored.
    1164  * @param usecs Timeout in microseconds. Zero denotes no timeout.
    1165  *
    1166  * @return If no timeout was specified, then a hash of the
    1167  *         incoming call is returned. If a timeout is specified,
    1168  *         then a hash of the incoming call is returned unless
    1169  *         the timeout expires prior to receiving a message. In
    1170  *         that case zero is returned.
    1171  *
    1172  */
    1173 ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
     1194 * @param call   Storage where the incoming call data will be stored.
     1195 * @param usecs  Timeout in microseconds. Zero denotes no timeout.
     1196 *
     1197 * @return  If no timeout was specified, then a handle of the incoming call is
     1198 *          returned. If a timeout is specified, then a handle of the incoming
     1199 *          call is returned unless the timeout expires prior to receiving a
     1200 *          message. In that case zero CAP_NIL is returned.
     1201 */
     1202cap_handle_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
    11741203{
    11751204        assert(call);
    … …  
    11941223        /* If nothing in queue, wait until something arrives */
    11951224        while (list_empty(&conn->msg_queue)) {
    1196                 if (conn->close_callid) {
     1225                if (conn->close_chandle) {
    11971226                        /*
    11981227                         * Handle the case when the connection was already
    … …  
    12051234                        IPC_SET_IMETHOD(*call, IPC_M_PHONE_HUNGUP);
    12061235                        futex_up(&async_futex);
    1207                         return conn->close_callid;
     1236                        return conn->close_chandle;
    12081237                }
    12091238               
    … …  
    12301259                        /* If we timed out -> exit */
    12311260                        futex_up(&async_futex);
    1232                         return 0;
     1261                        return CAP_NIL;
    12331262                }
    12341263        }
    … …  
    12381267        list_remove(&msg->link);
    12391268       
    1240         ipc_callid_t callid = msg->callid;
     1269        cap_handle_t chandle = msg->chandle;
    12411270        *call = msg->call;
    12421271        free(msg);
    12431272       
    12441273        futex_up(&async_futex);
    1245         return callid;
     1274        return chandle;
    12461275}
    12471276
    … …  
    13061335 * Otherwise the call is routed to its connection fibril.
    13071336 *
    1308  * @param callid Hash of the incoming call.
    1309  * @param call   Data of the incoming call.
    1310  *
    1311  */
    1312 static void handle_call(ipc_callid_t callid, ipc_call_t *call)
     1337 * @param chandle  Handle of the incoming call.
     1338 * @param call     Data of the incoming call.
     1339 *
     1340 */
     1341static void handle_call(cap_handle_t chandle, ipc_call_t *call)
    13131342{
    13141343        assert(call);
    13151344       
    13161345        /* Kernel notification */
    1317         if ((callid & IPC_CALLID_NOTIFICATION)) {
     1346        if ((chandle == CAP_NIL) && (call->flags & IPC_CALL_NOTIF)) {
    13181347                fibril_t *fibril = (fibril_t *) __tcb_get()->fibril_data;
    13191348                unsigned oldsw = fibril->switches;
    13201349               
    1321                 process_notification(callid, call);
     1350                process_notification(call);
    13221351               
    13231352                if (oldsw != fibril->switches) {
    … …  
    13451374                sysarg_t in_phone_hash = IPC_GET_ARG5(*call);
    13461375               
    1347                 async_notification_handler_t handler = fallback_port_handler;
     1376                async_port_handler_t handler = fallback_port_handler;
    13481377                void *data = fallback_port_data;
    13491378               
    … …  
    13551384                }
    13561385               
    1357                 async_new_connection(call->in_task_id, in_phone_hash, callid,
     1386                async_new_connection(call->in_task_id, in_phone_hash, chandle,
    13581387                    call, handler, data);
    13591388                return;
    … …  
    13611390       
    13621391        /* Try to route the call through the connection hash table */
    1363         if (route_call(callid, call))
     1392        if (route_call(chandle, call))
    13641393                return;
    13651394       
    13661395        /* Unknown call from unknown phone - hang it up */
    1367         ipc_answer_0(callid, EHANGUP);
     1396        ipc_answer_0(chandle, EHANGUP);
    13681397}
    13691398
    … …  
    14601489               
    14611490                ipc_call_t call;
    1462                 ipc_callid_t callid = ipc_wait_cycle(&call, timeout, flags);
     1491                int rc = ipc_wait_cycle(&call, timeout, flags);
    14631492               
    14641493                atomic_dec(&threads_in_ipc_wait);
    14651494               
    1466                 if (!callid) {
    1467                         handle_expired_timeouts();
     1495                assert(rc == EOK);
     1496
     1497                if (call.cap_handle == CAP_NIL) {
     1498                        if ((call.flags &
     1499                            (IPC_CALL_NOTIF | IPC_CALL_ANSWERED)) == 0) {
     1500                                /* Neither a notification nor an answer. */
     1501                                handle_expired_timeouts();
     1502                                continue;
     1503                        }
     1504                }
     1505
     1506                if (call.flags & IPC_CALL_ANSWERED)
    14681507                        continue;
    1469                 }
    1470                
    1471                 if (callid & IPC_CALLID_ANSWERED)
    1472                         continue;
    1473                
    1474                 handle_call(callid, &call);
    1475         }
    1476        
     1508
     1509                handle_call(call.cap_handle, &call);
     1510        }
     1511
    14771512        return 0;
    14781513}
    … …  
    16051640 * @param arg3    Service-defined payload argument.
    16061641 * @param arg4    Service-defined payload argument.
    1607  * @param dataptr If non-NULL, storage where the reply data will be
    1608  *                stored.
     1642 * @param dataptr If non-NULL, storage where the reply data will be stored.
    16091643 *
    16101644 * @return Hash of the sent message or 0 on error.
    … …  
    16751709 *
    16761710 */
    1677 void async_wait_for(aid_t amsgid, sysarg_t *retval)
     1711void async_wait_for(aid_t amsgid, int *retval)
    16781712{
    16791713        assert(amsgid);
    … …  
    17211755 *
    17221756 */
    1723 int async_wait_timeout(aid_t amsgid, sysarg_t *retval, suseconds_t timeout)
     1757int async_wait_timeout(aid_t amsgid, int *retval, suseconds_t timeout)
    17241758{
    17251759        assert(amsgid);
    … …  
    18221856void async_usleep(suseconds_t timeout)
    18231857{
    1824         amsg_t *msg = amsg_create();
    1825         if (!msg)
    1826                 return;
    1827        
    1828         msg->wdata.fid = fibril_get_id();
    1829        
    1830         getuptime(&msg->wdata.to_event.expires);
    1831         tv_add_diff(&msg->wdata.to_event.expires, timeout);
     1858        awaiter_t awaiter;
     1859        awaiter_initialize(&awaiter);
     1860       
     1861        awaiter.fid = fibril_get_id();
     1862       
     1863        getuptime(&awaiter.to_event.expires);
     1864        tv_add_diff(&awaiter.to_event.expires, timeout);
    18321865       
    18331866        futex_down(&async_futex);
    18341867       
    1835         async_insert_timeout(&msg->wdata);
     1868        async_insert_timeout(&awaiter);
    18361869       
    18371870        /* Leave the async_futex locked when entering this function */
    … …  
    18391872       
    18401873        /* Futex is up automatically after fibril_switch() */
    1841        
    1842         amsg_destroy(msg);
     1874}
     1875
     1876/** Delay execution for the specified number of seconds
     1877 *
     1878 * @param sec Number of seconds to sleep
     1879 */
     1880void async_sleep(unsigned int sec)
     1881{
     1882        /*
     1883         * Sleep in 1000 second steps to support
     1884         * full argument range
     1885         */
     1886
     1887        while (sec > 0) {
     1888                unsigned int period = (sec > 1000) ? 1000 : sec;
     1889
     1890                async_usleep(period * 1000000);
     1891                sec -= period;
     1892        }
    18431893}
    18441894
    … …  
    18621912 * @param r5      If non-NULL, storage for the 5th reply argument.
    18631913 *
    1864  * @return Return code of the reply or a negative error code.
    1865  *
    1866  */
    1867 sysarg_t async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     1914 * @return Return code of the reply or an error code.
     1915 *
     1916 */
     1917int async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
    18681918    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
    18691919    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    … …  
    18761926            &result);
    18771927       
    1878         sysarg_t rc;
     1928        int rc;
    18791929        async_wait_for(aid, &rc);
    18801930       
    … …  
    19141964 * @param r5      If non-NULL, storage for the 5th reply argument.
    19151965 *
    1916  * @return Return code of the reply or a negative error code.
    1917  *
    1918  */
    1919 sysarg_t async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     1966 * @return Return code of the reply or an error code.
     1967 *
     1968 */
     1969int async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
    19201970    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
    19211971    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    … …  
    19281978            &result);
    19291979       
    1930         sysarg_t rc;
     1980        int rc;
    19311981        async_wait_for(aid, &rc);
    19321982       
    … …  
    19922042}
    19932043
    1994 sysarg_t async_answer_0(ipc_callid_t callid, sysarg_t retval)
    1995 {
    1996         return ipc_answer_0(callid, retval);
    1997 }
    1998 
    1999 sysarg_t async_answer_1(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1)
    2000 {
    2001         return ipc_answer_1(callid, retval, arg1);
    2002 }
    2003 
    2004 sysarg_t async_answer_2(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     2044int async_answer_0(cap_handle_t chandle, int retval)
     2045{
     2046        return ipc_answer_0(chandle, retval);
     2047}
     2048
     2049int async_answer_1(cap_handle_t chandle, int retval, sysarg_t arg1)
     2050{
     2051        return ipc_answer_1(chandle, retval, arg1);
     2052}
     2053
     2054int async_answer_2(cap_handle_t chandle, int retval, sysarg_t arg1,
    20052055    sysarg_t arg2)
    20062056{
    2007         return ipc_answer_2(callid, retval, arg1, arg2);
    2008 }
    2009 
    2010 sysarg_t async_answer_3(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     2057        return ipc_answer_2(chandle, retval, arg1, arg2);
     2058}
     2059
     2060int async_answer_3(cap_handle_t chandle, int retval, sysarg_t arg1,
    20112061    sysarg_t arg2, sysarg_t arg3)
    20122062{
    2013         return ipc_answer_3(callid, retval, arg1, arg2, arg3);
    2014 }
    2015 
    2016 sysarg_t async_answer_4(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     2063        return ipc_answer_3(chandle, retval, arg1, arg2, arg3);
     2064}
     2065
     2066int async_answer_4(cap_handle_t chandle, int retval, sysarg_t arg1,
    20172067    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    20182068{
    2019         return ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4);
    2020 }
    2021 
    2022 sysarg_t async_answer_5(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     2069        return ipc_answer_4(chandle, retval, arg1, arg2, arg3, arg4);
     2070}
     2071
     2072int async_answer_5(cap_handle_t chandle, int retval, sysarg_t arg1,
    20232073    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
    20242074{
    2025         return ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5);
    2026 }
    2027 
    2028 int async_forward_fast(ipc_callid_t callid, async_exch_t *exch,
     2075        return ipc_answer_5(chandle, retval, arg1, arg2, arg3, arg4, arg5);
     2076}
     2077
     2078int async_forward_fast(cap_handle_t chandle, async_exch_t *exch,
    20292079    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    20302080{
    … …  
    20322082                return ENOENT;
    20332083       
    2034         return ipc_forward_fast(callid, exch->phone, imethod, arg1, arg2, mode);
    2035 }
    2036 
    2037 int async_forward_slow(ipc_callid_t callid, async_exch_t *exch,
     2084        return ipc_forward_fast(chandle, exch->phone, imethod, arg1, arg2, mode);
     2085}
     2086
     2087int async_forward_slow(cap_handle_t chandle, async_exch_t *exch,
    20382088    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
    20392089    sysarg_t arg4, sysarg_t arg5, unsigned int mode)
    … …  
    20422092                return ENOENT;
    20432093       
    2044         return ipc_forward_slow(callid, exch->phone, imethod, arg1, arg2, arg3,
     2094        return ipc_forward_slow(chandle, exch->phone, imethod, arg1, arg2, arg3,
    20452095            arg4, arg5, mode);
    20462096}
    … …  
    20552105 * @param arg3            User defined argument.
    20562106 *
    2057  * @return Zero on success or a negative error code.
     2107 * @return Zero on success or an error code.
    20582108 *
    20592109 */
    … …  
    20682118            &answer);
    20692119       
    2070         sysarg_t rc;
     2120        int rc;
    20712121        async_wait_for(req, &rc);
    20722122        if (rc != EOK)
    … …  
    20772127
    20782128static int async_connect_me_to_internal(int phone, sysarg_t arg1, sysarg_t arg2,
    2079     sysarg_t arg3, sysarg_t arg4)
     2129    sysarg_t arg3, sysarg_t arg4, int *out_phone)
    20802130{
    20812131        ipc_call_t result;
     2132       
     2133        // XXX: Workaround for GCC's inability to infer association between
     2134        // rc == EOK and *out_phone being assigned.
     2135        *out_phone = -1;
    20822136       
    20832137        amsg_t *msg = amsg_create();
    … …  
    20912145            msg, reply_received);
    20922146       
    2093         sysarg_t rc;
     2147        int rc;
    20942148        async_wait_for((aid_t) msg, &rc);
    20952149       
    … …  
    20972151                return rc;
    20982152       
    2099         return (int) IPC_GET_ARG5(result);
     2153        *out_phone = (int) IPC_GET_ARG5(result);
     2154        return EOK;
    21002155}
    21012156
    … …  
    21272182        }
    21282183       
    2129         int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
    2130             0);
    2131         if (phone < 0) {
    2132                 errno = phone;
     2184        int phone;
     2185        int rc = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
     2186            0, &phone);
     2187        if (rc != EOK) {
     2188                errno = rc;
    21332189                free(sess);
    21342190                return NULL;
    … …  
    21792235        }
    21802236       
    2181         int phone = async_connect_me_to_internal(exch->phone, iface, arg2,
    2182             arg3, 0);
    2183         if (phone < 0) {
    2184                 errno = phone;
     2237        int phone;
     2238        int rc = async_connect_me_to_internal(exch->phone, iface, arg2,
     2239            arg3, 0, &phone);
     2240        if (rc != EOK) {
     2241                errno = rc;
    21852242                free(sess);
    21862243                return NULL;
    … …  
    22492306        }
    22502307       
    2251         int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
    2252             IPC_FLAG_BLOCKING);
    2253        
    2254         if (phone < 0) {
    2255                 errno = phone;
     2308        int phone;
     2309        int rc = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
     2310            IPC_FLAG_BLOCKING, &phone);
     2311       
     2312        if (rc != EOK) {
     2313                errno = rc;
    22562314                free(sess);
    22572315                return NULL;
    … …  
    23022360        }
    23032361       
    2304         int phone = async_connect_me_to_internal(exch->phone, iface, arg2,
    2305             arg3, IPC_FLAG_BLOCKING);
    2306         if (phone < 0) {
    2307                 errno = phone;
     2362        int phone;
     2363        int rc = async_connect_me_to_internal(exch->phone, iface, arg2,
     2364            arg3, IPC_FLAG_BLOCKING, &phone);
     2365        if (rc != EOK) {
     2366                errno = rc;
    23082367                free(sess);
    23092368                return NULL;
    … …  
    23372396        }
    23382397       
    2339         int phone = ipc_connect_kbox(id);
    2340         if (phone < 0) {
    2341                 errno = phone;
     2398        cap_handle_t phone;
     2399        int rc = ipc_connect_kbox(id, &phone);
     2400        if (rc != EOK) {
     2401                errno = rc;
    23422402                free(sess);
    23432403                return NULL;
    … …  
    23702430 * @param sess Session to hung up.
    23712431 *
    2372  * @return Zero on success or a negative error code.
     2432 * @return Zero on success or an error code.
    23732433 *
    23742434 */
    … …  
    24562516                } else if (mgmt == EXCHANGE_PARALLEL) {
    24572517                        int phone;
     2518                        int rc;
    24582519                       
    24592520                retry:
    … …  
    24612522                         * Make a one-time attempt to connect a new data phone.
    24622523                         */
    2463                         phone = async_connect_me_to_internal(sess->phone, sess->arg1,
    2464                             sess->arg2, sess->arg3, 0);
    2465                         if (phone >= 0) {
     2524                        rc = async_connect_me_to_internal(sess->phone, sess->arg1,
     2525                            sess->arg2, sess->arg3, 0, &phone);
     2526                        if (rc == EOK) {
    24662527                                exch = (async_exch_t *) malloc(sizeof(async_exch_t));
    24672528                                if (exch != NULL) {
    … …  
    25492610 *              base address. Cannot be NULL.
    25502611 *
    2551  * @return Zero on success or a negative error code from errno.h.
     2612 * @return Zero on success or an error code from errno.h.
    25522613 *
    25532614 */
    … …  
    25782639 * So far, this wrapper is to be used from within a connection fibril.
    25792640 *
    2580  * @param callid Storage for the hash of the IPC_M_SHARE_IN call.
    2581  * @param size   Destination address space area size.
     2641 * @param chandle  Storage for the handle of the IPC_M_SHARE_IN call.
     2642 * @param size     Destination address space area size.
    25822643 *
    25832644 * @return True on success, false on failure.
    25842645 *
    25852646 */
    2586 bool async_share_in_receive(ipc_callid_t *callid, size_t *size)
    2587 {
    2588         assert(callid);
     2647bool async_share_in_receive(cap_handle_t *chandle, size_t *size)
     2648{
     2649        assert(chandle);
    25892650        assert(size);
    25902651       
    25912652        ipc_call_t data;
    2592         *callid = async_get_call(&data);
     2653        *chandle = async_get_call(&data);
    25932654       
    25942655        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN)
    … …  
    26052666 * argument.
    26062667 *
    2607  * @param callid Hash of the IPC_M_DATA_READ call to answer.
    2608  * @param src    Source address space base.
    2609  * @param flags  Flags to be used for sharing. Bits can be only cleared.
     2668 * @param chandle  Handle of the IPC_M_DATA_READ call to answer.
     2669 * @param src      Source address space base.
     2670 * @param flags    Flags to be used for sharing. Bits can be only cleared.
    26102671 *
    26112672 * @return Zero on success or a value from @ref errno.h on failure.
    26122673 *
    26132674 */
    2614 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
    2615 {
    2616         return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
     2675int async_share_in_finalize(cap_handle_t chandle, void *src, unsigned int flags)
     2676{
     2677        return ipc_answer_3(chandle, EOK, (sysarg_t) src, (sysarg_t) flags,
    26172678            (sysarg_t) __entry);
    26182679}
    … …  
    26242685 * @param flags Flags to be used for sharing. Bits can be only cleared.
    26252686 *
    2626  * @return Zero on success or a negative error code from errno.h.
     2687 * @return Zero on success or an error code from errno.h.
    26272688 *
    26282689 */
    … …  
    26442705 * So far, this wrapper is to be used from within a connection fibril.
    26452706 *
    2646  * @param callid Storage for the hash of the IPC_M_SHARE_OUT call.
    2647  * @param size   Storage for the source address space area size.
    2648  * @param flags  Storage for the sharing flags.
     2707 * @param chandle Storage for the hash of the IPC_M_SHARE_OUT call.
     2708 * @param size     Storage for the source address space area size.
     2709 * @param flags    Storage for the sharing flags.
    26492710 *
    26502711 * @return True on success, false on failure.
    26512712 *
    26522713 */
    2653 bool async_share_out_receive(ipc_callid_t *callid, size_t *size, unsigned int *flags)
    2654 {
    2655         assert(callid);
     2714bool async_share_out_receive(cap_handle_t *chandle, size_t *size,
     2715    unsigned int *flags)
     2716{
     2717        assert(chandle);
    26562718        assert(size);
    26572719        assert(flags);
    26582720       
    26592721        ipc_call_t data;
    2660         *callid = async_get_call(&data);
     2722        *chandle = async_get_call(&data);
    26612723       
    26622724        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT)
    … …  
    26742736 * argument.
    26752737 *
    2676  * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
    2677  * @param dst    Address of the storage for the destination address space area
    2678  *               base address.
    2679  *
    2680  * @return Zero on success or a value from @ref errno.h on failure.
    2681  *
    2682  */
    2683 int async_share_out_finalize(ipc_callid_t callid, void **dst)
    2684 {
    2685         return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
     2738 * @param chandle  Handle of the IPC_M_DATA_WRITE call to answer.
     2739 * @param dst      Address of the storage for the destination address space area
     2740 *                 base address.
     2741 *
     2742 * @return  Zero on success or a value from @ref errno.h on failure.
     2743 *
     2744 */
     2745int async_share_out_finalize(cap_handle_t chandle, void **dst)
     2746{
     2747        return ipc_answer_2(chandle, EOK, (sysarg_t) __entry, (sysarg_t) dst);
    26862748}
    26872749
    … …  
    27092771 * @param size Size of the destination buffer.
    27102772 *
    2711  * @return Zero on success or a negative error code from errno.h.
     2773 * @return Zero on success or an error code from errno.h.
    27122774 *
    27132775 */
    … …  
    27292791 * So far, this wrapper is to be used from within a connection fibril.
    27302792 *
    2731  * @param callid Storage for the hash of the IPC_M_DATA_READ.
    2732  * @param size   Storage for the maximum size. Can be NULL.
     2793 * @param chandle  Storage for the handle of the IPC_M_DATA_READ.
     2794 * @param size     Storage for the maximum size. Can be NULL.
    27332795 *
    27342796 * @return True on success, false on failure.
    27352797 *
    27362798 */
    2737 bool async_data_read_receive(ipc_callid_t *callid, size_t *size)
     2799bool async_data_read_receive(cap_handle_t *chandle, size_t *size)
    27382800{
    27392801        ipc_call_t data;
    2740         return async_data_read_receive_call(callid, &data, size);
     2802        return async_data_read_receive_call(chandle, &data, size);
    27412803}
    27422804
    … …  
    27492811 * So far, this wrapper is to be used from within a connection fibril.
    27502812 *
    2751  * @param callid Storage for the hash of the IPC_M_DATA_READ.
    2752  * @param size   Storage for the maximum size. Can be NULL.
     2813 * @param chandle  Storage for the handle of the IPC_M_DATA_READ.
     2814 * @param size     Storage for the maximum size. Can be NULL.
    27532815 *
    27542816 * @return True on success, false on failure.
    27552817 *
    27562818 */
    2757 bool async_data_read_receive_call(ipc_callid_t *callid, ipc_call_t *data,
     2819bool async_data_read_receive_call(cap_handle_t *chandle, ipc_call_t *data,
    27582820    size_t *size)
    27592821{
    2760         assert(callid);
     2822        assert(chandle);
    27612823        assert(data);
    27622824       
    2763         *callid = async_get_call(data);
     2825        *chandle = async_get_call(data);
    27642826       
    27652827        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_READ)
    … …  
    27782840 * argument.
    27792841 *
    2780  * @param callid Hash of the IPC_M_DATA_READ call to answer.
    2781  * @param src    Source address for the IPC_M_DATA_READ call.
    2782  * @param size   Size for the IPC_M_DATA_READ call. Can be smaller than
    2783  *               the maximum size announced by the sender.
    2784  *
    2785  * @return Zero on success or a value from @ref errno.h on failure.
    2786  *
    2787  */
    2788 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
    2789 {
    2790         return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
     2842 * @param chandle  Handle of the IPC_M_DATA_READ call to answer.
     2843 * @param src      Source address for the IPC_M_DATA_READ call.
     2844 * @param size     Size for the IPC_M_DATA_READ call. Can be smaller than
     2845 *                 the maximum size announced by the sender.
     2846 *
     2847 * @return  Zero on success or a value from @ref errno.h on failure.
     2848 *
     2849 */
     2850int async_data_read_finalize(cap_handle_t chandle, const void *src, size_t size)
     2851{
     2852        return ipc_answer_2(chandle, EOK, (sysarg_t) src, (sysarg_t) size);
    27912853}
    27922854
    … …  
    28012863                return ENOENT;
    28022864       
    2803         ipc_callid_t callid;
    2804         if (!async_data_read_receive(&callid, NULL)) {
    2805                 ipc_answer_0(callid, EINVAL);
     2865        cap_handle_t chandle;
     2866        if (!async_data_read_receive(&chandle, NULL)) {
     2867                ipc_answer_0(chandle, EINVAL);
    28062868                return EINVAL;
    28072869        }
    … …  
    28102872            dataptr);
    28112873        if (msg == 0) {
    2812                 ipc_answer_0(callid, EINVAL);
     2874                ipc_answer_0(chandle, EINVAL);
    28132875                return EINVAL;
    28142876        }
    28152877       
    2816         int retval = ipc_forward_fast(callid, exch->phone, 0, 0, 0,
     2878        int retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
    28172879            IPC_FF_ROUTE_FROM_ME);
    28182880        if (retval != EOK) {
    28192881                async_forget(msg);
    2820                 ipc_answer_0(callid, retval);
     2882                ipc_answer_0(chandle, retval);
    28212883                return retval;
    28222884        }
    28232885       
    2824         sysarg_t rc;
     2886        int rc;
    28252887        async_wait_for(msg, &rc);
    28262888       
    … …  
    28342896 * @param size Size of the source buffer.
    28352897 *
    2836  * @return Zero on success or a negative error code from errno.h.
     2898 * @return Zero on success or an error code from errno.h.
    28372899 *
    28382900 */
    … …  
    28542916 * So far, this wrapper is to be used from within a connection fibril.
    28552917 *
    2856  * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
    2857  * @param size   Storage for the suggested size. May be NULL.
    2858  *
    2859  * @return True on success, false on failure.
    2860  *
    2861  */
    2862 bool async_data_write_receive(ipc_callid_t *callid, size_t *size)
     2918 * @param chandle  Storage for the handle of the IPC_M_DATA_WRITE.
     2919 * @param size     Storage for the suggested size. May be NULL.
     2920 *
     2921 * @return  True on success, false on failure.
     2922 *
     2923 */
     2924bool async_data_write_receive(cap_handle_t *chandle, size_t *size)
    28632925{
    28642926        ipc_call_t data;
    2865         return async_data_write_receive_call(callid, &data, size);
     2927        return async_data_write_receive_call(chandle, &data, size);
    28662928}
    28672929
    … …  
    28742936 * So far, this wrapper is to be used from within a connection fibril.
    28752937 *
    2876  * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
    2877  * @param data   Storage for the ipc call data.
    2878  * @param size   Storage for the suggested size. May be NULL.
     2938 * @param chandle  Storage for the handle of the IPC_M_DATA_WRITE.
     2939 * @param data     Storage for the ipc call data.
     2940 * @param size     Storage for the suggested size. May be NULL.
    28792941 *
    28802942 * @return True on success, false on failure.
    28812943 *
    28822944 */
    2883 bool async_data_write_receive_call(ipc_callid_t *callid, ipc_call_t *data,
     2945bool async_data_write_receive_call(cap_handle_t *chandle, ipc_call_t *data,
    28842946    size_t *size)
    28852947{
    2886         assert(callid);
     2948        assert(chandle);
    28872949        assert(data);
    28882950       
    2889         *callid = async_get_call(data);
     2951        *chandle = async_get_call(data);
    28902952       
    28912953        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_WRITE)
    … …  
    29042966 * argument.
    29052967 *
    2906  * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
    2907  * @param dst    Final destination address for the IPC_M_DATA_WRITE call.
    2908  * @param size   Final size for the IPC_M_DATA_WRITE call.
    2909  *
    2910  * @return Zero on success or a value from @ref errno.h on failure.
    2911  *
    2912  */
    2913 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
    2914 {
    2915         return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
     2968 * @param chandle  Handle of the IPC_M_DATA_WRITE call to answer.
     2969 * @param dst      Final destination address for the IPC_M_DATA_WRITE call.
     2970 * @param size     Final size for the IPC_M_DATA_WRITE call.
     2971 *
     2972 * @return  Zero on success or a value from @ref errno.h on failure.
     2973 *
     2974 */
     2975int async_data_write_finalize(cap_handle_t chandle, void *dst, size_t size)
     2976{
     2977        return ipc_answer_2(chandle, EOK, (sysarg_t) dst, (sysarg_t) size);
    29162978}
    29172979
    … …  
    29433005        assert(data);
    29443006       
    2945         ipc_callid_t callid;
     3007        cap_handle_t chandle;
    29463008        size_t size;
    2947         if (!async_data_write_receive(&callid, &size)) {
    2948                 ipc_answer_0(callid, EINVAL);
     3009        if (!async_data_write_receive(&chandle, &size)) {
     3010                ipc_answer_0(chandle, EINVAL);
    29493011                return EINVAL;
    29503012        }
    29513013       
    29523014        if (size < min_size) {
    2953                 ipc_answer_0(callid, EINVAL);
     3015                ipc_answer_0(chandle, EINVAL);
    29543016                return EINVAL;
    29553017        }
    29563018       
    29573019        if ((max_size > 0) && (size > max_size)) {
    2958                 ipc_answer_0(callid, EINVAL);
     3020                ipc_answer_0(chandle, EINVAL);
    29593021                return EINVAL;
    29603022        }
    29613023       
    29623024        if ((granularity > 0) && ((size % granularity) != 0)) {
    2963                 ipc_answer_0(callid, EINVAL);
     3025                ipc_answer_0(chandle, EINVAL);
    29643026                return EINVAL;
    29653027        }
    … …  
    29733035       
    29743036        if (arg_data == NULL) {
    2975                 ipc_answer_0(callid, ENOMEM);
     3037                ipc_answer_0(chandle, ENOMEM);
    29763038                return ENOMEM;
    29773039        }
    29783040       
    2979         int rc = async_data_write_finalize(callid, arg_data, size);
     3041        int rc = async_data_write_finalize(chandle, arg_data, size);
    29803042        if (rc != EOK) {
    29813043                free(arg_data);
    … …  
    30003062 *
    30013063 */
    3002 void async_data_write_void(sysarg_t retval)
    3003 {
    3004         ipc_callid_t callid;
    3005         async_data_write_receive(&callid, NULL);
    3006         ipc_answer_0(callid, retval);
     3064void async_data_write_void(int retval)
     3065{
     3066        cap_handle_t chandle;
     3067        async_data_write_receive(&chandle, NULL);
     3068        ipc_answer_0(chandle, retval);
    30073069}
    30083070
    … …  
    30173079                return ENOENT;
    30183080       
    3019         ipc_callid_t callid;
    3020         if (!async_data_write_receive(&callid, NULL)) {
    3021                 ipc_answer_0(callid, EINVAL);
     3081        cap_handle_t chandle;
     3082        if (!async_data_write_receive(&chandle, NULL)) {
     3083                ipc_answer_0(chandle, EINVAL);
    30223084                return EINVAL;
    30233085        }
    … …  
    30263088            dataptr);
    30273089        if (msg == 0) {
    3028                 ipc_answer_0(callid, EINVAL);
     3090                ipc_answer_0(chandle, EINVAL);
    30293091                return EINVAL;
    30303092        }
    30313093       
    3032         int retval = ipc_forward_fast(callid, exch->phone, 0, 0, 0,
     3094        int retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
    30333095            IPC_FF_ROUTE_FROM_ME);
    30343096        if (retval != EOK) {
    30353097                async_forget(msg);
    3036                 ipc_answer_0(callid, retval);
     3098                ipc_answer_0(chandle, retval);
    30373099                return retval;
    30383100        }
    30393101       
    3040         sysarg_t rc;
     3102        int rc;
    30413103        async_wait_for(msg, &rc);
    30423104       
    … …  
    30593121        /* Accept the phone */
    30603122        ipc_call_t call;
    3061         ipc_callid_t callid = async_get_call(&call);
    3062         int phone = (int) IPC_GET_ARG5(call);
    3063        
    3064         if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) ||
    3065             (phone < 0)) {
    3066                 async_answer_0(callid, EINVAL);
     3123        cap_handle_t chandle = async_get_call(&call);
     3124        cap_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(call);
     3125       
     3126        if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) || (phandle < 0)) {
     3127                async_answer_0(chandle, EINVAL);
    30673128                return NULL;
    30683129        }
    … …  
    30703131        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
    30713132        if (sess == NULL) {
    3072                 async_answer_0(callid, ENOMEM);
     3133                async_answer_0(chandle, ENOMEM);
    30733134                return NULL;
    30743135        }
    … …  
    30763137        sess->iface = 0;
    30773138        sess->mgmt = mgmt;
    3078         sess->phone = phone;
     3139        sess->phone = phandle;
    30793140        sess->arg1 = 0;
    30803141        sess->arg2 = 0;
    … …  
    30893150       
    30903151        /* Acknowledge the connected phone */
    3091         async_answer_0(callid, EOK);
     3152        async_answer_0(chandle, EOK);
    30923153       
    30933154        return sess;
    … …  
    31103171async_sess_t *async_callback_receive_start(exch_mgmt_t mgmt, ipc_call_t *call)
    31113172{
    3112         int phone = (int) IPC_GET_ARG5(*call);
    3113        
    3114         if ((IPC_GET_IMETHOD(*call) != IPC_M_CONNECT_TO_ME) ||
    3115             (phone < 0))
     3173        cap_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(*call);
     3174       
     3175        if ((IPC_GET_IMETHOD(*call) != IPC_M_CONNECT_TO_ME) || (phandle < 0))
    31163176                return NULL;
    31173177       
    … …  
    31223182        sess->iface = 0;
    31233183        sess->mgmt = mgmt;
    3124         sess->phone = phone;
     3184        sess->phone = phandle;
    31253185        sess->arg1 = 0;
    31263186        sess->arg2 = 0;
    … …  
    31443204}
    31453205
    3146 bool async_state_change_receive(ipc_callid_t *callid, sysarg_t *arg1,
     3206bool async_state_change_receive(cap_handle_t *chandle, sysarg_t *arg1,
    31473207    sysarg_t *arg2, sysarg_t *arg3)
    31483208{
    3149         assert(callid);
     3209        assert(chandle);
    31503210       
    31513211        ipc_call_t call;
    3152         *callid = async_get_call(&call);
     3212        *chandle = async_get_call(&call);
    31533213       
    31543214        if (IPC_GET_IMETHOD(call) != IPC_M_STATE_CHANGE_AUTHORIZE)
    … …  
    31653225}
    31663226
    3167 int async_state_change_finalize(ipc_callid_t callid, async_exch_t *other_exch)
    3168 {
    3169         return ipc_answer_1(callid, EOK, other_exch->phone);
     3227int async_state_change_finalize(cap_handle_t chandle, async_exch_t *other_exch)
     3228{
     3229        return ipc_answer_1(chandle, EOK, other_exch->phone);
    31703230}
    31713231
Note: See TracChangeset for help on using the changeset viewer.