Changeset 46b881c in mainline for uspace/lib


Ignore:
Timestamp:
2011-01-29T11:36:41Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0b6931a, 8add9ca5
Parents:
e26a4633 (diff), ffa2c8ef (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

IPC/async: strictly isolate the use of low-level IPC methods (ipc_*) and async framework methods (async_*) in user code, do not allow a mixture of both in a single source file

Benefits for future plans

  • The async framework could use different communication style under the hood, but keeping the same high-level API
  • The async framework can be integrated more tightly with sessions without potential problems of intermixing session-aware async methods with session-unaware low-level methods in user code
  • The async_serialize_start()/_end() can be deprecated more easily
Location:
uspace/lib
Files:
1 added
78 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/block/libblock.c

    re26a4633 r46b881c  
    4444#include <sys/mman.h>
    4545#include <async.h>
    46 #include <ipc/ipc.h>
    4746#include <as.h>
    4847#include <assert.h>
    … …  
    177176        if (rc != EOK) {
    178177                munmap(comm_area, comm_size);
    179                 ipc_hangup(dev_phone);
     178                async_hangup(dev_phone);
    180179                return rc;
    181180        }
    … …  
    183182        if (get_block_size(dev_phone, &bsize) != EOK) {
    184183                munmap(comm_area, comm_size);
    185                 ipc_hangup(dev_phone);
     184                async_hangup(dev_phone);
    186185                return rc;
    187186        }
    … …  
    190189        if (rc != EOK) {
    191190                munmap(comm_area, comm_size);
    192                 ipc_hangup(dev_phone);
     191                async_hangup(dev_phone);
    193192                return rc;
    194193        }
    … …  
    211210
    212211        munmap(devcon->comm_area, devcon->comm_size);
    213         ipc_hangup(devcon->dev_phone);
     212        async_hangup(devcon->dev_phone);
    214213
    215214        free(devcon);   

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

    re26a4633 r46b881c  
    7777 *   {
    7878 *     if (want_refuse) {
    79  *       ipc_answer_0(icallid, ELIMIT);
     79 *       async_answer_0(icallid, ELIMIT);
    8080 *       return;
    8181 *     }
    82  *     ipc_answer_0(icallid, EOK);
     82 *     async_answer_0(icallid, EOK);
    8383 *
    8484 *     callid = async_get_call(&call);
    8585 *     somehow_handle_the_call(callid, call);
    86  *     ipc_answer_2(callid, 1, 2, 3);
     86 *     async_answer_2(callid, 1, 2, 3);
    8787 *
    8888 *     callid = async_get_call(&call);
    … …  
    9292 */
    9393
     94#define LIBC_ASYNC_C_
     95#include <ipc/ipc.h>
     96#include <async.h>
     97#undef LIBC_ASYNC_C_
     98
    9499#include <futex.h>
    95 #include <async.h>
    96100#include <fibril.h>
    97101#include <stdio.h>
    98102#include <adt/hash_table.h>
    99103#include <adt/list.h>
    100 #include <ipc/ipc.h>
    101104#include <assert.h>
    102105#include <errno.h>
    … …  
    12351238}
    12361239
     1240void async_msg_0(int phone, sysarg_t imethod)
     1241{
     1242        ipc_call_async_0(phone, imethod, NULL, NULL, true);
     1243}
     1244
     1245void async_msg_1(int phone, sysarg_t imethod, sysarg_t arg1)
     1246{
     1247        ipc_call_async_1(phone, imethod, arg1, NULL, NULL, true);
     1248}
     1249
     1250void async_msg_2(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2)
     1251{
     1252        ipc_call_async_2(phone, imethod, arg1, arg2, NULL, NULL, true);
     1253}
     1254
     1255void async_msg_3(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
     1256    sysarg_t arg3)
     1257{
     1258        ipc_call_async_3(phone, imethod, arg1, arg2, arg3, NULL, NULL, true);
     1259}
     1260
     1261void async_msg_4(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
     1262    sysarg_t arg3, sysarg_t arg4)
     1263{
     1264        ipc_call_async_4(phone, imethod, arg1, arg2, arg3, arg4, NULL, NULL,
     1265            true);
     1266}
     1267
     1268void async_msg_5(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
     1269    sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
     1270{
     1271        ipc_call_async_5(phone, imethod, arg1, arg2, arg3, arg4, arg5, NULL,
     1272            NULL, true);
     1273}
     1274
     1275sysarg_t async_answer_0(ipc_callid_t callid, sysarg_t retval)
     1276{
     1277        return ipc_answer_0(callid, retval);
     1278}
     1279
     1280sysarg_t async_answer_1(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1)
     1281{
     1282        return ipc_answer_1(callid, retval, arg1);
     1283}
     1284
     1285sysarg_t async_answer_2(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1286    sysarg_t arg2)
     1287{
     1288        return ipc_answer_2(callid, retval, arg1, arg2);
     1289}
     1290
     1291sysarg_t async_answer_3(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1292    sysarg_t arg2, sysarg_t arg3)
     1293{
     1294        return ipc_answer_3(callid, retval, arg1, arg2, arg3);
     1295}
     1296
     1297sysarg_t async_answer_4(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1298    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
     1299{
     1300        return ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4);
     1301}
     1302
     1303sysarg_t async_answer_5(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1304    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
     1305{
     1306        return ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5);
     1307}
     1308
     1309int async_forward_fast(ipc_callid_t callid, int phoneid, int imethod,
     1310    sysarg_t arg1, sysarg_t arg2, int mode)
     1311{
     1312        return ipc_forward_fast(callid, phoneid, imethod, arg1, arg2, mode);
     1313}
     1314
     1315int async_forward_slow(ipc_callid_t callid, int phoneid, int imethod,
     1316    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
     1317    int mode)
     1318{
     1319        return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4,
     1320            arg5, mode);
     1321}
     1322
    12371323/** Wrapper for making IPC_M_CONNECT_TO_ME calls using the async framework.
    12381324 *
    … …  
    13141400       
    13151401        return newphid;
     1402}
     1403
     1404/** Connect to a task specified by id.
     1405 *
     1406 */
     1407int async_connect_kbox(task_id_t id)
     1408{
     1409        return ipc_connect_kbox(id);
     1410}
     1411
     1412/** Wrapper for ipc_hangup.
     1413 *
     1414 * @param phone Phone handle to hung up.
     1415 *
     1416 * @return Zero on success or a negative error code.
     1417 *
     1418 */
     1419int async_hangup(int phone)
     1420{
     1421        return ipc_hangup(phone);
     1422}
     1423
     1424/** Interrupt one thread of this task from waiting for IPC. */
     1425void async_poke(void)
     1426{
     1427        ipc_poke();
    13161428}
    13171429
    … …  
    15031615
    15041616/** Wrapper for forwarding any read request
    1505  *
    15061617 *
    15071618 */
    … …  
    16901801/** Wrapper for forwarding any data that is about to be received
    16911802 *
    1692  *
    16931803 */
    16941804int async_data_write_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1,

  • uspace/lib/c/generic/async_sess.c

    re26a4633 r46b881c  
    9999
    100100#include <async_sess.h>
    101 #include <ipc/ipc.h>
    102101#include <fibril_synch.h>
    103102#include <adt/list.h>
    … …  
    200199                list_remove(&conn->global_link);
    201200               
    202                 ipc_hangup(conn->data_phone);
     201                async_hangup(conn->data_phone);
    203202                free(conn);
    204203        }
    … …  
    260259                        data_phone = conn->data_phone;
    261260                        free(conn);
    262                         ipc_hangup(data_phone);
     261                        async_hangup(data_phone);
    263262                        goto retry;
    264263                } else {
    … …  
    292291                 * means that we simply hang up.
    293292                 */
    294                 ipc_hangup(data_phone);
     293                async_hangup(data_phone);
    295294                fibril_mutex_unlock(&async_sess_mutex);
    296295                return;

  • uspace/lib/c/generic/ddi.c

    re26a4633 r46b881c  
    127127}
    128128
     129/** Register IRQ notification.
     130 *
     131 * @param inr    IRQ number.
     132 * @param devno  Device number of the device generating inr.
     133 * @param method Use this method for notifying me.
     134 * @param ucode  Top-half pseudocode handler.
     135 *
     136 * @return Value returned by the kernel.
     137 *
     138 */
     139int register_irq(int inr, int devno, int method, irq_code_t *ucode)
     140{
     141        return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method,
     142            (sysarg_t) ucode);
     143}
     144
     145/** Unregister IRQ notification.
     146 *
     147 * @param inr   IRQ number.
     148 * @param devno Device number of the device generating inr.
     149 *
     150 * @return Value returned by the kernel.
     151 *
     152 */
     153int unregister_irq(int inr, int devno)
     154{
     155        return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
     156}
     157
    129158/** @}
    130159 */

  • uspace/lib/c/generic/devman.c

    re26a4633 r46b881c  
    2828 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929 */
    30  
    31  /** @addtogroup libc
     30
     31/** @addtogroup libc
    3232 * @{
    3333 */
    … …  
    3737#include <str.h>
    3838#include <stdio.h>
    39 #include <ipc/ipc.h>
    4039#include <ipc/services.h>
    4140#include <ipc/devman.h>
    … …  
    116115        async_set_client_connection(conn);
    117116       
    118         ipc_connect_to_me(phone, 0, 0, 0, NULL, NULL);
     117        async_connect_to_me(phone, 0, 0, 0, NULL);
    119118        async_wait_for(req, &retval);
    120119       
    … …  
    221220        case DEVMAN_DRIVER:
    222221                if (devman_phone_driver >= 0) {
    223                         ipc_hangup(devman_phone_driver);
     222                        async_hangup(devman_phone_driver);
    224223                        devman_phone_driver = -1;
    225224                }
    … …  
    227226        case DEVMAN_CLIENT:
    228227                if (devman_phone_client >= 0) {
    229                         ipc_hangup(devman_phone_client);
     228                        async_hangup(devman_phone_client);
    230229                        devman_phone_client = -1;
    231230                }

  • uspace/lib/c/generic/devmap.c

    re26a4633 r46b881c  
    2929
    3030#include <str.h>
    31 #include <ipc/ipc.h>
    3231#include <ipc/services.h>
    3332#include <ipc/ns.h>
    … …  
    8079        case DEVMAP_DRIVER:
    8180                if (devmap_phone_driver >= 0) {
    82                         ipc_hangup(devmap_phone_driver);
     81                        async_hangup(devmap_phone_driver);
    8382                        devmap_phone_driver = -1;
    8483                }
    … …  
    8685        case DEVMAP_CLIENT:
    8786                if (devmap_phone_client >= 0) {
    88                         ipc_hangup(devmap_phone_client);
     87                        async_hangup(devmap_phone_client);
    8988                        devmap_phone_client = -1;
    9089                }
    … …  
    117116        async_set_client_connection(conn);
    118117       
    119         ipc_connect_to_me(phone, 0, 0, 0, NULL, NULL);
     118        async_connect_to_me(phone, 0, 0, 0, NULL);
    120119        async_wait_for(req, &retval);
    121120       

  • uspace/lib/c/generic/event.c

    re26a4633 r46b881c  
    3535 */
    3636/** @file
    37  */ 
     37 */
    3838
    3939#include <libc.h>
    4040#include <event.h>
    4141#include <kernel/ipc/event_types.h>
    42 #include <ipc/ipc.h>
    4342
    4443/** Subscribe for event notifications.

  • uspace/lib/c/generic/fibril_synch.c

    re26a4633 r46b881c  
    5555         */
    5656        if (atomic_get(&threads_in_ipc_wait) > 0)
    57                 ipc_poke();
     57                async_poke();
    5858}
    5959

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

    re26a4633 r46b881c  
    4141#include <bool.h>
    4242#include <malloc.h>
     43#include <async.h>
    4344#include <io/klog.h>
    4445#include <vfs/vfs.h>
    … …  
    322323       
    323324        if (stream->phone >= 0)
    324                 ipc_hangup(stream->phone);
     325                async_hangup(stream->phone);
    325326       
    326327        if (stream->fd >= 0)

  • uspace/lib/c/generic/ipc.c

    re26a4633 r46b881c  
    4545#include <errno.h>
    4646#include <adt/list.h>
    47 #include <stdio.h>
    48 #include <unistd.h>
    4947#include <futex.h>
    50 #include <kernel/synch/synch.h>
    51 #include <async.h>
    5248#include <fibril.h>
    53 #include <assert.h>
    5449
    5550/**
    … …  
    650645}
    651646
    652 /** Register IRQ notification.
    653  *
    654  * @param inr           IRQ number.
    655  * @param devno         Device number of the device generating inr.
    656  * @param method        Use this method for notifying me.
    657  * @param ucode         Top-half pseudocode handler.
    658  *
    659  * @return              Value returned by the kernel.
    660  */
    661 int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode)
    662 {
    663         return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method,
    664             (sysarg_t) ucode);
    665 }
    666 
    667 /** Unregister IRQ notification.
    668  *
    669  * @param inr           IRQ number.
    670  * @param devno         Device number of the device generating inr.
    671  *
    672  * @return              Value returned by the kernel.
    673  */
    674 int ipc_unregister_irq(int inr, int devno)
    675 {
    676         return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
    677 }
    678 
    679647/** Forward a received call to another destination.
    680648 *

  • uspace/lib/c/generic/ipc/ns.c

    re26a4633 r46b881c  
    7979}
    8080
     81void *service_realtime_share_in(void)
     82{
     83        void *rtime = as_get_mappable_page(PAGE_SIZE);
     84        if (rtime == NULL)
     85                return NULL;
     86       
     87        int res = async_share_in_start_1_0(PHONE_NS, rtime, PAGE_SIZE,
     88            SERVICE_MEM_REALTIME);
     89        if (res != EOK) {
     90                as_area_destroy((void *) rtime);
     91                return NULL;
     92        }
     93       
     94        return rtime;
     95}
     96
    8197/** @}
    8298 */

  • uspace/lib/c/generic/libc.c

    re26a4633 r46b881c  
    4747#include <thread.h>
    4848#include <fibril.h>
    49 #include <ipc/ipc.h>
    5049#include <async.h>
    5150#include <as.h>

  • uspace/lib/c/generic/loader.c

    re26a4633 r46b881c  
    3333 */
    3434
    35 #include <ipc/ipc.h>
    3635#include <ipc/loader.h>
    3736#include <ipc/services.h>
    … …  
    320319                return rc;
    321320       
    322         ipc_hangup(ldr->phone_id);
     321        async_hangup(ldr->phone_id);
    323322        ldr->phone_id = 0;
    324323        return EOK;
    … …  
    338337void loader_abort(loader_t *ldr)
    339338{
    340         ipc_hangup(ldr->phone_id);
     339        async_hangup(ldr->phone_id);
    341340        ldr->phone_id = 0;
    342341}

  • uspace/lib/c/generic/net/icmp_api.c

    re26a4633 r46b881c  
    4141#include <net/modules.h>
    4242#include <net/ip_codes.h>
    43 
    4443#include <async.h>
    4544#include <sys/types.h>
    4645#include <sys/time.h>
    4746#include <errno.h>
    48 
    49 #include <ipc/ipc.h>
    5047#include <ipc/services.h>
    5148#include <ipc/icmp.h>

  • uspace/lib/c/generic/net/modules.c

    re26a4633 r46b881c  
    4343#include <errno.h>
    4444#include <sys/time.h>
    45 
    46 #include <ipc/ipc.h>
    4745#include <ipc/services.h>
    48 
    4946#include <net/modules.h>
    5047
    … …  
    6764                switch (count) {
    6865                case 0:
    69                         ipc_answer_0(callid, (sysarg_t) result);
     66                        async_answer_0(callid, (sysarg_t) result);
    7067                        break;
    7168                case 1:
    72                         ipc_answer_1(callid, (sysarg_t) result,
     69                        async_answer_1(callid, (sysarg_t) result,
    7370                            IPC_GET_ARG1(*answer));
    7471                        break;
    7572                case 2:
    76                         ipc_answer_2(callid, (sysarg_t) result,
     73                        async_answer_2(callid, (sysarg_t) result,
    7774                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer));
    7875                        break;
    7976                case 3:
    80                         ipc_answer_3(callid, (sysarg_t) result,
     77                        async_answer_3(callid, (sysarg_t) result,
    8178                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    8279                            IPC_GET_ARG3(*answer));
    8380                        break;
    8481                case 4:
    85                         ipc_answer_4(callid, (sysarg_t) result,
     82                        async_answer_4(callid, (sysarg_t) result,
    8683                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    8784                            IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer));
    … …  
    8986                case 5:
    9087                default:
    91                         ipc_answer_5(callid, (sysarg_t) result,
     88                        async_answer_5(callid, (sysarg_t) result,
    9289                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    9390                            IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer),
    … …  
    137134    sysarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
    138135{
    139         int rc;
    140        
    141136        /* Connect to the needed service */
    142137        int phone = connect_to_service_timeout(need, timeout);
    143138        if (phone >= 0) {
    144139                /* Request the bidirectional connection */
    145                 sysarg_t taskhash;
    146                 sysarg_t phonehash;
    147                
    148                 rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &taskhash,
    149                     &phonehash);
     140                int rc = async_connect_to_me(phone, arg1, arg2, arg3, client_receiver);
    150141                if (rc != EOK) {
    151                         ipc_hangup(phone);
     142                        async_hangup(phone);
    152143                        return rc;
    153144                }
    154                 async_new_connection(taskhash, phonehash, 0, NULL,
    155                     client_receiver);
    156145        }
    157146       

  • uspace/lib/c/generic/net/socket_client.c

    re26a4633 r46b881c  
    4343#include <stdlib.h>
    4444#include <errno.h>
    45 
     45#include <task.h>
    4646#include <ipc/services.h>
    4747#include <ipc/socket.h>
    48 
    4948#include <net/modules.h>
    5049#include <net/in.h>
    … …  
    278277        }
    279278
    280         ipc_answer_0(callid, (sysarg_t) rc);
     279        async_answer_0(callid, (sysarg_t) rc);
    281280        goto loop;
    282281}
    … …  
    687686
    688687        /* Read address */
    689         ipc_data_read_start(socket->phone, cliaddr, *addrlen);
     688        async_data_read_start(socket->phone, cliaddr, *addrlen);
    690689        fibril_rwlock_write_unlock(&socket_globals.lock);
    691690        async_wait_for(message_id, &ipc_result);

  • uspace/lib/c/generic/time.c

    re26a4633 r46b881c  
    3535#include <sys/time.h>
    3636#include <unistd.h>
    37 #include <ipc/ipc.h>
    38 #include <stdio.h>
     37#include <bool.h>
     38#include <ipc/ns.h>
    3939#include <arch/barrier.h>
    40 #include <unistd.h>
    41 #include <atomic.h>
    42 #include <sysinfo.h>
    43 #include <ipc/services.h>
     40#include <macros.h>
    4441#include <libc.h>
    45 
    46 #include <sysinfo.h>
    47 #include <as.h>
    48 #include <ddi.h>
    49 
    5042#include <time.h>
    5143
    52 /* Pointers to public variables with time */
     44/** Pointer to kernel shared variables with time */
    5345struct {
    5446        volatile sysarg_t seconds1;
    … …  
    5951/** Add microseconds to given timeval.
    6052 *
    61  * @param tv            Destination timeval.
    62  * @param usecs         Number of microseconds to add.
     53 * @param tv    Destination timeval.
     54 * @param usecs Number of microseconds to add.
     55 *
    6356 */
    6457void tv_add(struct timeval *tv, suseconds_t usecs)
    … …  
    6659        tv->tv_sec += usecs / 1000000;
    6760        tv->tv_usec += usecs % 1000000;
     61       
    6862        if (tv->tv_usec > 1000000) {
    6963                tv->tv_sec++;
    … …  
    7468/** Subtract two timevals.
    7569 *
    76  * @param tv1           First timeval.
    77  * @param tv2           Second timeval.
    78  *
    79  * @return              Return difference between tv1 and tv2 (tv1 - tv2) in
    80  *                      microseconds.
     70 * @param tv1 First timeval.
     71 * @param tv2 Second timeval.
     72 *
     73 * @return Difference between tv1 and tv2 (tv1 - tv2) in
     74 *         microseconds.
     75 *
    8176 */
    8277suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2)
    8378{
    84         suseconds_t result;
    85 
    86         result = tv1->tv_usec - tv2->tv_usec;
    87         result += (tv1->tv_sec - tv2->tv_sec) * 1000000;
    88 
    89         return result;
     79        return (tv1->tv_usec - tv2->tv_usec) +
     80            ((tv1->tv_sec - tv2->tv_sec) * 1000000);
    9081}
    9182
    9283/** Decide if one timeval is greater than the other.
    9384 *
    94  * @param t1            First timeval.
    95  * @param t2            Second timeval.
    96  *
    97  * @return              Return true tv1 is greater than tv2. Otherwise return
    98  *                      false.
     85 * @param t1 First timeval.
     86 * @param t2 Second timeval.
     87 *
     88 * @return True if tv1 is greater than tv2.
     89 * @return False otherwise.
     90 *
    9991 */
    10092int tv_gt(struct timeval *tv1, struct timeval *tv2)
    10193{
    10294        if (tv1->tv_sec > tv2->tv_sec)
    103                 return 1;
    104         if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec > tv2->tv_usec)
    105                 return 1;
    106         return 0;
     95                return true;
     96       
     97        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec > tv2->tv_usec))
     98                return true;
     99       
     100        return false;
    107101}
    108102
    109103/** Decide if one timeval is greater than or equal to the other.
    110104 *
    111  * @param tv1           First timeval.
    112  * @param tv2           Second timeval.
    113  *
    114  * @return              Return true if tv1 is greater than or equal to tv2.
    115  *                      Otherwise return false.
     105 * @param tv1 First timeval.
     106 * @param tv2 Second timeval.
     107 *
     108 * @return True if tv1 is greater than or equal to tv2.
     109 * @return False otherwise.
     110 *
    116111 */
    117112int tv_gteq(struct timeval *tv1, struct timeval *tv2)
    118113{
    119114        if (tv1->tv_sec > tv2->tv_sec)
    120                 return 1;
    121         if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec >= tv2->tv_usec)
    122                 return 1;
    123         return 0;
    124 }
    125 
    126 
    127 /** POSIX gettimeofday
    128  *
    129  * The time variables are memory mapped(RO) from kernel, which updates
    130  * them periodically. As it is impossible to read 2 values atomically, we
    131  * use a trick: First read a seconds, then read microseconds, then
    132  * read seconds again. If a second elapsed in the meantime, set it to zero.
    133  * This provides assurance, that at least the
    134  * sequence of subsequent gettimeofday calls is ordered.
     115                return true;
     116       
     117        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec >= tv2->tv_usec))
     118                return true;
     119       
     120        return false;
     121}
     122
     123/** Get time of day
     124 *
     125 * The time variables are memory mapped (read-only) from kernel which
     126 * updates them periodically.
     127 *
     128 * As it is impossible to read 2 values atomically, we use a trick:
     129 * First we read the seconds, then we read the microseconds, then we
     130 * read the seconds again. If a second elapsed in the meantime, set
     131 * the microseconds to zero.
     132 *
     133 * This assures that the values returned by two subsequent calls
     134 * to gettimeofday() are monotonous.
     135 *
    135136 */
    136137int gettimeofday(struct timeval *tv, struct timezone *tz)
    137138{
    138         void *mapping;
    139         sysarg_t s1, s2;
    140         int rights;
    141         int res;
    142 
    143139        if (!ktime) {
    144                 mapping = as_get_mappable_page(PAGE_SIZE);
    145                 /* Get the mapping of kernel clock */
    146                 res = ipc_share_in_start_1_1(PHONE_NS, mapping, PAGE_SIZE,
    147                     SERVICE_MEM_REALTIME, &rights);
    148                 if (res) {
    149                         printf("Failed to initialize timeofday memarea\n");
    150                         _exit(1);
    151                 }
    152                 if (!(rights & AS_AREA_READ)) {
    153                         printf("Received bad rights on time area: %X\n",
    154                             rights);
    155                         as_area_destroy(mapping);
    156                         _exit(1);
    157                 }
    158                 ktime = mapping;
    159         }
     140                ktime = service_realtime_share_in();
     141                if (!ktime)
     142                        return -1;
     143        }
     144       
    160145        if (tz) {
    161146                tz->tz_minuteswest = 0;
    162147                tz->tz_dsttime = DST_NONE;
    163148        }
    164 
    165         s2 = ktime->seconds2;
     149       
     150        sysarg_t s2 = ktime->seconds2;
     151       
    166152        read_barrier();
    167153        tv->tv_usec = ktime->useconds;
     154       
    168155        read_barrier();
    169         s1 = ktime->seconds1;
     156        sysarg_t s1 = ktime->seconds1;
     157       
    170158        if (s1 != s2) {
     159                tv->tv_sec = max(s1, s2);
    171160                tv->tv_usec = 0;
    172                 tv->tv_sec = s1 > s2 ? s1 : s2;
    173161        } else
    174162                tv->tv_sec = s1;
    175 
     163       
    176164        return 0;
    177165}
    … …  
    180168{
    181169        struct timeval tv;
    182 
    183170        if (gettimeofday(&tv, NULL))
    184171                return (time_t) -1;
     172       
    185173        if (tloc)
    186174                *tloc = tv.tv_sec;
     175       
    187176        return tv.tv_sec;
    188177}
    189178
    190 /** Wait unconditionally for specified number of microseconds */
     179/** Wait unconditionally for specified number of microseconds
     180 *
     181 */
    191182int usleep(useconds_t usec)
    192183{
    … …  
    195186}
    196187
    197 /** Wait unconditionally for specified number of seconds */
     188/** Wait unconditionally for specified number of seconds
     189 *
     190 */
    198191unsigned int sleep(unsigned int sec)
    199192{
    200         /* Sleep in 1000 second steps to support
    201            full argument range */
     193        /*
     194         * Sleep in 1000 second steps to support
     195         * full argument range
     196         */
     197       
    202198        while (sec > 0) {
    203199                unsigned int period = (sec > 1000) ? 1000 : sec;
    204        
     200               
    205201                usleep(period * 1000000);
    206202                sec -= period;
    207203        }
     204       
    208205        return 0;
    209206}

  • uspace/lib/c/generic/udebug.c

    re26a4633 r46b881c  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#include <udebug.h>
    3636#include <sys/types.h>
    37 #include <ipc/ipc.h>
    3837#include <async.h>
    3938

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

    re26a4633 r46b881c  
    11/*
    2  * Copyright (c) 2008 Jakub Jermar 
     2 * Copyright (c) 2008 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    4343#include <sys/stat.h>
    4444#include <sys/types.h>
    45 #include <ipc/ipc.h>
    4645#include <ipc/services.h>
    4746#include <ipc/ns.h>

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

    re26a4633 r46b881c  
    3333 */
    3434
     35#if ((defined(LIBC_IPC_H_)) && (!defined(LIBC_ASYNC_C_)))
     36        #error Do not intermix low-level IPC interface and async framework
     37#endif
     38
    3539#ifndef LIBC_ASYNC_H_
    3640#define LIBC_ASYNC_H_
    3741
    38 #include <ipc/ipc.h>
     42#include <ipc/common.h>
    3943#include <async_sess.h>
    4044#include <fibril.h>
    … …  
    4246#include <atomic.h>
    4347#include <bool.h>
     48#include <task.h>
    4449
    4550typedef ipc_callid_t aid_t;
    … …  
    4954
    5055typedef void (*async_client_conn_t)(ipc_callid_t, ipc_call_t *);
    51 
    52 extern atomic_t async_futex;
    5356
    5457extern atomic_t threads_in_ipc_wait;
    … …  
    110113extern void async_set_interrupt_received(async_client_conn_t);
    111114
    112 /* Wrappers for simple communication */
    113 #define async_msg_0(phone, method) \
    114         ipc_call_async_0((phone), (method), NULL, NULL, true)
    115 #define async_msg_1(phone, method, arg1) \
    116         ipc_call_async_1((phone), (method), (arg1), NULL, NULL, \
    117             true)
    118 #define async_msg_2(phone, method, arg1, arg2) \
    119         ipc_call_async_2((phone), (method), (arg1), (arg2), NULL, NULL, \
    120             true)
    121 #define async_msg_3(phone, method, arg1, arg2, arg3) \
    122         ipc_call_async_3((phone), (method), (arg1), (arg2), (arg3), NULL, NULL, \
    123             true)
    124 #define async_msg_4(phone, method, arg1, arg2, arg3, arg4) \
    125         ipc_call_async_4((phone), (method), (arg1), (arg2), (arg3), (arg4), NULL, \
    126             NULL, true)
    127 #define async_msg_5(phone, method, arg1, arg2, arg3, arg4, arg5) \
    128         ipc_call_async_5((phone), (method), (arg1), (arg2), (arg3), (arg4), \
    129             (arg5), NULL, NULL, true)
     115/*
     116 * Wrappers for simple communication.
     117 */
     118
     119extern void async_msg_0(int, sysarg_t);
     120extern void async_msg_1(int, sysarg_t, sysarg_t);
     121extern void async_msg_2(int, sysarg_t, sysarg_t, sysarg_t);
     122extern void async_msg_3(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
     123extern void async_msg_4(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
     124extern void async_msg_5(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     125    sysarg_t);
     126
     127/*
     128 * Wrappers for answer routines.
     129 */
     130
     131extern sysarg_t async_answer_0(ipc_callid_t, sysarg_t);
     132extern sysarg_t async_answer_1(ipc_callid_t, sysarg_t, sysarg_t);
     133extern sysarg_t async_answer_2(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t);
     134extern sysarg_t async_answer_3(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     135    sysarg_t);
     136extern sysarg_t async_answer_4(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     137    sysarg_t, sysarg_t);
     138extern sysarg_t async_answer_5(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     139    sysarg_t, sysarg_t, sysarg_t);
     140
     141/*
     142 * Wrappers for forwarding routines.
     143 */
     144
     145extern int async_forward_fast(ipc_callid_t, int, int, sysarg_t, sysarg_t, int);
     146extern int async_forward_slow(ipc_callid_t, int, int, sysarg_t, sysarg_t,
     147    sysarg_t, sysarg_t, sysarg_t, int);
    130148
    131149/*
    … …  
    135153 * and slow verion based on m.
    136154 */
     155
    137156#define async_req_0_0(phoneid, method) \
    138157        async_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \
    … …  
    270289extern int async_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
    271290extern int async_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);
     291extern int async_connect_kbox(task_id_t);
     292extern int async_hangup(int);
     293extern void async_poke(void);
    272294
    273295/*
    274296 * User-friendly wrappers for async_share_in_start().
    275297 */
     298
    276299#define async_share_in_start_0_0(phoneid, dst, size) \
    277300        async_share_in_start((phoneid), (dst), (size), 0, NULL)
    … …  
    293316 * User-friendly wrappers for async_data_read_forward_fast().
    294317 */
     318
    295319#define async_data_read_forward_0_0(phoneid, method, answer) \
    296320        async_data_read_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL)
    … …  
    329353 * User-friendly wrappers for async_data_write_forward_fast().
    330354 */
     355
    331356#define async_data_write_forward_0_0(phoneid, method, answer) \
    332357        async_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL)

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

    re26a4633 r46b881c  
    3636#define LIBC_DDI_H_
    3737
     38#include <sys/types.h>
     39#include <kernel/ddi/irq.h>
    3840#include <task.h>
    3941
    … …  
    4244extern int iospace_enable(task_id_t, void *, unsigned long);
    4345extern int pio_enable(void *, size_t, void **);
     46extern int register_irq(int, int, int, irq_code_t *);
     47extern int unregister_irq(int, int);
    4448
    4549#endif

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

    re26a4633 r46b881c  
    4141#include <bool.h>
    4242
    43 
    4443extern int devman_get_phone(devman_interface_t, unsigned int);
    4544extern void devman_hangup_phone(devman_interface_t);

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

    re26a4633 r46b881c  
    3737
    3838#include <kernel/ipc/event_types.h>
    39 #include <ipc/ipc.h>
    4039
    4140extern int event_subscribe(event_type_t, sysarg_t);

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

    re26a4633 r46b881c  
    3636#define LIBC_IO_CONSOLE_H_
    3737
    38 #include <ipc/ipc.h>
    3938#include <bool.h>
    4039

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

    re26a4633 r46b881c  
    3838#include <stdint.h>
    3939#include <sys/types.h>
    40 #include <ipc/ipc.h>
    4140#include <bool.h>
    4241

  • uspace/lib/c/include/ipc/adb.h

    re26a4633 r46b881c  
    3232/** @file
    3333 * @brief ADB device interface.
    34  */ 
     34 */
    3535
    3636#ifndef LIBC_IPC_ADB_H_
    3737#define LIBC_IPC_ADB_H_
    3838
    39 #include <ipc/ipc.h>
     39#include <ipc/common.h>
    4040
    4141typedef enum {
    4242        ADB_REG_WRITE = IPC_FIRST_USER_METHOD
    4343} adb_request_t;
    44 
    4544
    4645typedef enum {

  • uspace/lib/c/include/ipc/arp.h

    re26a4633 r46b881c  
    3939#define LIBC_ARP_MESSAGES_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342

  • uspace/lib/c/include/ipc/bd.h

    re26a4633 r46b881c  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#ifndef LIBC_IPC_BD_H_
    3636#define LIBC_IPC_BD_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/char.h

    re26a4633 r46b881c  
    3232/** @file
    3333 * @brief Character device interface.
    34  */ 
     34 */
    3535
    3636#ifndef LIBC_IPC_CHAR_H_
    3737#define LIBC_IPC_CHAR_H_
    3838
    39 #include <ipc/ipc.h>
     39#include <ipc/common.h>
    4040
    4141typedef enum {
    4242        CHAR_WRITE_BYTE = IPC_FIRST_USER_METHOD
    4343} char_request_t;
    44 
    4544
    4645typedef enum {

  • uspace/lib/c/include/ipc/clipboard.h

    re26a4633 r46b881c  
    3636#define LIBC_IPC_CLIPBOARD_H_
    3737
    38 #include <ipc/ipc.h>
    39 
    4038typedef enum {
    4139        CLIPBOARD_PUT_DATA = IPC_FIRST_USER_METHOD,

  • uspace/lib/c/include/ipc/console.h

    re26a4633 r46b881c  
    3636#define LIBC_IPC_CONSOLE_H_
    3737
    38 #include <ipc/ipc.h>
    3938#include <ipc/vfs.h>
    4039

  • uspace/lib/c/include/ipc/dev_iface.h

    re26a4633 r46b881c  
    3030#define LIBC_IPC_DEV_IFACE_H_
    3131
    32 #include <ipc/ipc.h>
    3332#include <malloc.h>
    3433#include <unistd.h>

  • uspace/lib/c/include/ipc/devman.h

    re26a4633 r46b881c  
    3030 * @{
    3131 */
    32  
     32
    3333#ifndef LIBC_IPC_DEVMAN_H_
    3434#define LIBC_IPC_DEVMAN_H_
    3535
     36#include <ipc/common.h>
    3637#include <adt/list.h>
    37 #include <ipc/ipc.h>
    38 #include <stdlib.h>
    39 #include <stdio.h>
    40 #include <str.h>
     38#include <malloc.h>
     39#include <mem.h>
    4140
    42 #define DEVMAN_NAME_MAXLEN 256
     41#define DEVMAN_NAME_MAXLEN  256
    4342
    4443typedef sysarg_t devman_handle_t;
    … …  
    6766} match_id_list_t;
    6867
    69 
    70 static inline match_id_t * create_match_id()
     68static inline match_id_t *create_match_id(void)
    7169{
    7270        match_id_t *id = malloc(sizeof(match_id_t));
    … …  
    8583}
    8684
    87 static inline void add_match_id(match_id_list_t *ids, match_id_t *id) 
     85static inline void add_match_id(match_id_list_t *ids, match_id_t *id)
    8886{
    8987        match_id_t *mid = NULL;
    90         link_t *link = ids->ids.next;   
     88        link_t *link = ids->ids.next;
    9189       
    9290        while (link != &ids->ids) {
    … …  
    9896        }
    9997       
    100         list_insert_before(&id->link, link);   
     98        list_insert_before(&id->link, link);
    10199}
    102100

  • uspace/lib/c/include/ipc/devmap.h

    re26a4633 r46b881c  
    3434#define DEVMAP_DEVMAP_H_
    3535
    36 #include <atomic.h>
    37 #include <ipc/ipc.h>
    38 #include <adt/list.h>
     36#include <ipc/common.h>
    3937
    4038#define DEVMAP_NAME_MAXLEN  255

  • uspace/lib/c/include/ipc/fb.h

    re26a4633 r46b881c  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#ifndef LIBC_FB_H_
    3636#define LIBC_FB_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/icmp.h

    re26a4633 r46b881c  
    3939#define LIBC_ICMP_MESSAGES_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342#include <sys/types.h>
    4443#include <sys/time.h>
    45 
    4644#include <net/icmp_codes.h>
    4745

  • uspace/lib/c/include/ipc/il.h

    re26a4633 r46b881c  
    4040#define LIBC_IL_MESSAGES_H_
    4141
    42 #include <ipc/ipc.h>
    4342#include <ipc/net.h>
    4443

  • uspace/lib/c/include/ipc/ip.h

    re26a4633 r46b881c  
    3939#define LIBC_IP_MESSAGES_H_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    43 
    4442#include <net/in.h>
    4543#include <net/ip_codes.h>

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

    re26a4633 r46b881c  
    3333 */
    3434
    35 #ifndef LIBIPC_IPC_H_
    36 #define LIBIPC_IPC_H_
    37 
     35#if ((defined(LIBC_ASYNC_H_)) && (!defined(LIBC_ASYNC_C_)))
     36        #error Do not intermix low-level IPC interface and async framework
     37#endif
     38
     39#ifndef LIBC_IPC_H_
     40#define LIBC_IPC_H_
     41
     42#include <sys/types.h>
     43#include <ipc/common.h>
     44#include <kernel/synch/synch.h>
    3845#include <task.h>
    39 #include <kernel/ipc/ipc.h>
    40 #include <kernel/ddi/irq.h>
    41 #include <sys/types.h>
    42 #include <kernel/synch/synch.h>
    43 
    44 #define IPC_FLAG_BLOCKING  0x01
    45 
    46 typedef struct {
    47         sysarg_t args[IPC_CALL_LEN];
    48         sysarg_t in_task_hash;
    49         sysarg_t in_phone_hash;
    50 } ipc_call_t;
    51 
    52 typedef sysarg_t ipc_callid_t;
    53 
    54 typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
     46
     47typedef void (*ipc_async_callback_t)(void *, int, ipc_call_t *);
    5548
    5649/*
    … …  
    263256extern int ipc_connect_me_to_blocking(int, int, int, int);
    264257extern int ipc_hangup(int);
    265 extern int ipc_register_irq(int, int, int, irq_code_t *);
    266 extern int ipc_unregister_irq(int, int);
    267258extern int ipc_forward_fast(ipc_callid_t, int, int, sysarg_t, sysarg_t, int);
    268259extern int ipc_forward_slow(ipc_callid_t, int, int, sysarg_t, sysarg_t,

  • uspace/lib/c/include/ipc/irc.h

    re26a4633 r46b881c  
    3636#define LIBC_IRC_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/kbd.h

    re26a4633 r46b881c  
    3838#define LIBC_IPC_KBD_H_
    3939
    40 #include <ipc/ipc.h>
     40#include <ipc/common.h>
    4141
    4242typedef enum {

  • uspace/lib/c/include/ipc/loader.h

    re26a4633 r46b881c  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#ifndef LIBC_IPC_LOADER_H_
    3636#define LIBC_IPC_LOADER_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/mouse.h

    re26a4633 r46b881c  
    3737#define LIBC_IPC_MOUSE_H_
    3838
    39 #include <ipc/ipc.h>
     39#include <ipc/common.h>
    4040
    4141typedef enum {

  • uspace/lib/c/include/ipc/net.h

    re26a4633 r46b881c  
    3838#define LIBC_NET_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/services.h>
    42 
    4341#include <net/device.h>
    4442#include <net/packet.h>

  • uspace/lib/c/include/ipc/net_net.h

    re26a4633 r46b881c  
    3939#define LIBC_NET_NET_MESSAGES_H_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342

  • uspace/lib/c/include/ipc/netif.h

    re26a4633 r46b881c  
    3838#define LIBC_NETIF_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241

  • uspace/lib/c/include/ipc/nil.h

    re26a4633 r46b881c  
    3838#define LIBC_NIL_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241

  • uspace/lib/c/include/ipc/ns.h

    re26a4633 r46b881c  
    3333 */
    3434
    35 #ifndef LIBIPC_NS_H_
    36 #define LIBIPC_NS_H_
     35#ifndef LIBC_NS_H_
     36#define LIBC_NS_H_
    3737
    3838#include <sys/types.h>
    39 #include <ipc/ipc.h>
     39#include <ipc/common.h>
    4040
    4141typedef enum {
    … …  
    5151
    5252extern wchar_t *service_klog_share_in(size_t *);
     53extern void *service_realtime_share_in(void);
    5354
    5455#endif

  • uspace/lib/c/include/ipc/packet.h

    re26a4633 r46b881c  
    3838#define LIBC_PACKET_MESSAGES_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241

  • uspace/lib/c/include/ipc/services.h

    re26a4633 r46b881c  
    3535 */
    3636
    37 #ifndef LIBIPC_SERVICES_H_
    38 #define LIBIPC_SERVICES_H_
     37#ifndef LIBC_SERVICES_H_
     38#define LIBC_SERVICES_H_
    3939
    4040typedef enum {
    … …  
    6666} services_t;
    6767
    68 /* Memory area to be received from NS */
    69 #define SERVICE_MEM_REALTIME    1
    70 #define SERVICE_MEM_KLOG        2
     68/* Memory areas to be received from NS */
     69typedef enum {
     70        SERVICE_MEM_REALTIME = 1,
     71        SERVICE_MEM_KLOG = 2
     72} mem_services_t;
    7173
    7274#endif

  • uspace/lib/c/include/ipc/socket.h

    re26a4633 r46b881c  
    3838#define LIBC_SOCKET_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241

  • uspace/lib/c/include/ipc/tl.h

    re26a4633 r46b881c  
    3939#define LIBC_TL_MESSAGES_H_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342

  • uspace/lib/c/include/ipc/vfs.h

    re26a4633 r46b881c  
    3636#define LIBC_IPC_VFS_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939#include <sys/types.h>
    4040#include <bool.h>

  • uspace/lib/c/include/net/modules.h

    re26a4633 r46b881c  
    4343
    4444#include <async.h>
    45 
    46 #include <ipc/ipc.h>
    4745#include <ipc/services.h>
    48 
    4946#include <sys/time.h>
    5047

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

    re26a4633 r46b881c  
    3838#include <kernel/udebug/udebug.h>
    3939#include <sys/types.h>
    40 #include <libarch/types.h>
    4140
    4241typedef sysarg_t thash_t;
    4342
    44 int udebug_begin(int phoneid);
    45 int udebug_end(int phoneid);
    46 int udebug_set_evmask(int phoneid, udebug_evmask_t mask);
    47 int udebug_thread_read(int phoneid, void *buffer, size_t n,
    48         size_t *copied, size_t *needed);
    49 int udebug_name_read(int phoneid, void *buffer, size_t n,
    50         size_t *copied, size_t *needed);
    51 int udebug_areas_read(int phoneid, void *buffer, size_t n,
    52         size_t *copied, size_t *needed);
    53 int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n);
    54 int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer);
    55 int udebug_regs_read(int phoneid, thash_t tid, void *buffer);
    56 int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
    57         sysarg_t *val0, sysarg_t *val1);
    58 int udebug_stop(int phoneid, thash_t tid);
     43int udebug_begin(int);
     44int udebug_end(int);
     45int udebug_set_evmask(int, udebug_evmask_t);
     46int udebug_thread_read(int, void *, size_t , size_t *, size_t *);
     47int udebug_name_read(int, void *, size_t, size_t *, size_t *);
     48int udebug_areas_read(int, void *, size_t, size_t *, size_t *);
     49int udebug_mem_read(int, void *, uintptr_t, size_t);
     50int udebug_args_read(int, thash_t, sysarg_t *);
     51int udebug_regs_read(int, thash_t, void *);
     52int udebug_go(int, thash_t, udebug_event_t *, sysarg_t *, sysarg_t *);
     53int udebug_stop(int, thash_t);
    5954
    6055#endif

  • uspace/lib/clui/tinput.h

    re26a4633 r46b881c  
    3636#ifndef LIBCLUI_TINPUT_H_
    3737#define LIBCLUI_TINPUT_H_
    38 
    39 #include <ipc/ipc.h>
    4038
    4139#define HISTORY_LEN     10

  • uspace/lib/drv/generic/driver.c

    re26a4633 r46b881c  
    186186                pseudocode = &default_pseudocode;
    187187       
    188         int res = ipc_register_irq(irq, dev->handle, ctx->id, pseudocode);
     188        int res = register_irq(irq, dev->handle, ctx->id, pseudocode);
    189189        if (res != EOK) {
    190190                remove_interrupt_context(&interrupt_contexts, ctx);
    … …  
    199199        interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts,
    200200            dev, irq);
    201         int res = ipc_unregister_irq(irq, dev->handle);
     201        int res = unregister_irq(irq, dev->handle);
    202202       
    203203        if (ctx != NULL) {
    … …  
    272272        }
    273273       
    274         ipc_answer_0(iid, res);
     274        async_answer_0(iid, res);
    275275}
    276276
    … …  
    278278{
    279279        /* Accept connection */
    280         ipc_answer_0(iid, EOK);
     280        async_answer_0(iid, EOK);
    281281       
    282282        bool cont = true;
    … …  
    293293                        break;
    294294                default:
    295                         ipc_answer_0(callid, ENOENT);
     295                        async_answer_0(callid, ENOENT);
    296296                }
    297297        }
    … …  
    316316                printf("%s: driver_connection_gen error - no device with handle"
    317317                    " %" PRIun " was found.\n", driver->name, handle);
    318                 ipc_answer_0(iid, ENOENT);
     318                async_answer_0(iid, ENOENT);
    319319                return;
    320320        }
    … …  
    331331                ret = (*dev->ops->open)(dev);
    332332       
    333         ipc_answer_0(iid, ret);
     333        async_answer_0(iid, ret);
    334334        if (ret != EOK)
    335335                return;
    … …  
    347347                        if (dev->ops != NULL && dev->ops->close != NULL)
    348348                                (*dev->ops->close)(dev);
    349                         ipc_answer_0(callid, EOK);
     349                        async_answer_0(callid, EOK);
    350350                        return;
    351351                default:
    … …  
    368368                                    "invalid interface id %d.",
    369369                                    driver->name, iface_idx);
    370                                 ipc_answer_0(callid, ENOTSUP);
     370                                async_answer_0(callid, ENOTSUP);
    371371                                break;
    372372                        }
    … …  
    381381                                printf("device with handle %" PRIun " has no interface "
    382382                                    "with id %d.\n", handle, iface_idx);
    383                                 ipc_answer_0(callid, ENOTSUP);
     383                                async_answer_0(callid, ENOTSUP);
    384384                                break;
    385385                        }
    … …  
    400400                                printf("%s: driver_connection_gen error - "
    401401                                    "invalid interface method.", driver->name);
    402                                 ipc_answer_0(callid, ENOTSUP);
     402                                async_answer_0(callid, ENOTSUP);
    403403                                break;
    404404                        }
    … …  
    446446        default:
    447447                /* No such interface */
    448                 ipc_answer_0(iid, ENOENT);
     448                async_answer_0(iid, ENOENT);
    449449        }
    450450}

  • uspace/lib/drv/generic/remote_char_dev.c

    re26a4633 r46b881c  
    3333 */
    3434
    35 #include <ipc/ipc.h>
    3635#include <async.h>
    3736#include <errno.h>
    … …  
    8180        if (!async_data_read_receive(&cid, &len)) {
    8281                /* TODO handle protocol error. */
    83                 ipc_answer_0(callid, EINVAL);
     82                async_answer_0(callid, EINVAL);
    8483                return;
    8584        }
    … …  
    8786        if (!char_dev_ops->read) {
    8887                async_data_read_finalize(cid, NULL, 0);
    89                 ipc_answer_0(callid, ENOTSUP);
     88                async_answer_0(callid, ENOTSUP);
    9089                return;
    9190        }
    … …  
    10099                /* Some error occured. */
    101100                async_data_read_finalize(cid, buf, 0);
    102                 ipc_answer_0(callid, ret);
     101                async_answer_0(callid, ret);
    103102                return;
    104103        }
    … …  
    106105        /* The operation was successful, return the number of data read. */
    107106        async_data_read_finalize(cid, buf, ret);
    108         ipc_answer_1(callid, EOK, ret);
     107        async_answer_1(callid, EOK, ret);
    109108}
    110109
    … …  
    128127        if (!async_data_write_receive(&cid, &len)) {
    129128                /* TODO handle protocol error. */
    130                 ipc_answer_0(callid, EINVAL);
     129                async_answer_0(callid, EINVAL);
    131130                return;
    132131        }
    … …  
    134133        if (!char_dev_ops->write) {
    135134                async_data_write_finalize(cid, NULL, 0);
    136                 ipc_answer_0(callid, ENOTSUP);
     135                async_answer_0(callid, ENOTSUP);
    137136                return;
    138137        }
    … …  
    148147        if (ret < 0) {
    149148                /* Some error occured. */
    150                 ipc_answer_0(callid, ret);
     149                async_answer_0(callid, ret);
    151150        } else {
    152151                /*
    … …  
    154153                 * written.
    155154                 */
    156                 ipc_answer_1(callid, EOK, ret);
     155                async_answer_1(callid, EOK, ret);
    157156        }
    158157}

  • uspace/lib/drv/generic/remote_hw_res.c

    re26a4633 r46b881c  
    3333 */
    3434
    35 #include <ipc/ipc.h>
    3635#include <async.h>
    3736#include <errno.h>
    … …  
    6261       
    6362        if (hw_res_ops->enable_interrupt == NULL)
    64                 ipc_answer_0(callid, ENOTSUP);
     63                async_answer_0(callid, ENOTSUP);
    6564        else if (hw_res_ops->enable_interrupt(dev))
    66                 ipc_answer_0(callid, EOK);
     65                async_answer_0(callid, EOK);
    6766        else
    68                 ipc_answer_0(callid, EREFUSED);
     67                async_answer_0(callid, EREFUSED);
    6968}
    7069
    … …  
    7574
    7675        if (hw_res_ops->get_resource_list == NULL) {
    77                 ipc_answer_0(callid, ENOTSUP);
     76                async_answer_0(callid, ENOTSUP);
    7877                return;
    7978        }
    … …  
    8180        hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(dev);
    8281        if (hw_resources == NULL){
    83                 ipc_answer_0(callid, ENOENT);
     82                async_answer_0(callid, ENOENT);
    8483                return;
    8584        }
    8685       
    87         ipc_answer_1(callid, EOK, hw_resources->count);
     86        async_answer_1(callid, EOK, hw_resources->count);
    8887
    8988        size_t len;

  • uspace/lib/drv/include/dev_iface.h

    re26a4633 r46b881c  
    3636#define LIBDRV_DEV_IFACE_H_
    3737
     38#include <ipc/common.h>
    3839#include <ipc/dev_iface.h>
    3940

  • uspace/lib/drv/include/driver.h

    re26a4633 r46b881c  
    3636#define LIBDRV_DRIVER_H_
    3737
     38#include <kernel/ddi/irq.h>
    3839#include <adt/list.h>
    39 #include <ipc/ipc.h>
    4040#include <devman.h>
    4141#include <ipc/devman.h>

  • uspace/lib/fs/libfs.c

    re26a4633 r46b881c  
    4040#include <errno.h>
    4141#include <async.h>
    42 #include <ipc/ipc.h>
    4342#include <as.h>
    4443#include <assert.h>
    … …  
    5857#define answer_and_return(rid, rc) \
    5958        do { \
    60                 ipc_answer_0((rid), (rc)); \
     59                async_answer_0((rid), (rc)); \
    6160                return; \
    6261        } while (0)
    … …  
    102101         * Ask VFS for callback connection.
    103102         */
    104         sysarg_t taskhash;
    105         ipc_connect_to_me(vfs_phone, 0, 0, 0, &taskhash, &reg->vfs_phonehash);
     103        async_connect_to_me(vfs_phone, 0, 0, 0, conn);
    106104       
    107105        /*
    … …  
    128126        async_wait_for(req, NULL);
    129127        reg->fs_handle = (int) IPC_GET_ARG1(answer);
    130        
    131         /*
    132          * Create a connection fibril to handle the callback connection.
    133          */
    134         async_new_connection(taskhash, reg->vfs_phonehash, 0, NULL, conn);
    135128       
    136129        /*
    … …  
    166159        if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) ||
    167160            (mountee_phone < 0)) {
    168                 ipc_answer_0(callid, EINVAL);
    169                 ipc_answer_0(rid, EINVAL);
     161                async_answer_0(callid, EINVAL);
     162                async_answer_0(rid, EINVAL);
    170163                return;
    171164        }
    172165       
    173166        /* Acknowledge the mountee_phone */
    174         ipc_answer_0(callid, EOK);
     167        async_answer_0(callid, EOK);
    175168       
    176169        fs_node_t *fn;
    177170        res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
    178171        if ((res != EOK) || (!fn)) {
    179                 ipc_hangup(mountee_phone);
     172                async_hangup(mountee_phone);
    180173                async_data_write_void(combine_rc(res, ENOENT));
    181                 ipc_answer_0(rid, combine_rc(res, ENOENT));
     174                async_answer_0(rid, combine_rc(res, ENOENT));
    182175                return;
    183176        }
    184177       
    185178        if (fn->mp_data.mp_active) {
    186                 ipc_hangup(mountee_phone);
     179                async_hangup(mountee_phone);
    187180                (void) ops->node_put(fn);
    188181                async_data_write_void(EBUSY);
    189                 ipc_answer_0(rid, EBUSY);
     182                async_answer_0(rid, EBUSY);
    190183                return;
    191184        }
    … …  
    193186        rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
    194187        if (rc != EOK) {
    195                 ipc_hangup(mountee_phone);
     188                async_hangup(mountee_phone);
    196189                (void) ops->node_put(fn);
    197190                async_data_write_void(rc);
    198                 ipc_answer_0(rid, rc);
     191                async_answer_0(rid, rc);
    199192                return;
    200193        }
    … …  
    214207         * Do not release the FS node so that it stays in memory.
    215208         */
    216         ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     209        async_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
    217210            IPC_GET_ARG3(answer));
    218211}
    … …  
    227220        res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
    228221        if ((res != EOK) || (!fn)) {
    229                 ipc_answer_0(rid, combine_rc(res, ENOENT));
     222                async_answer_0(rid, combine_rc(res, ENOENT));
    230223                return;
    231224        }
    … …  
    236229        if (!fn->mp_data.mp_active) {
    237230                (void) ops->node_put(fn);
    238                 ipc_answer_0(rid, EINVAL);
     231                async_answer_0(rid, EINVAL);
    239232                return;
    240233        }
    … …  
    250243         */
    251244        if (res == EOK) {
    252                 ipc_hangup(fn->mp_data.phone);
     245                async_hangup(fn->mp_data.phone);
    253246                fn->mp_data.mp_active = false;
    254247                fn->mp_data.fs_handle = 0;
    … …  
    260253
    261254        (void) ops->node_put(fn);
    262         ipc_answer_0(rid, res);
     255        async_answer_0(rid, res);
    263256}
    264257
    … …  
    300293       
    301294        if (cur->mp_data.mp_active) {
    302                 ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
     295                async_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
    303296                    next, last, cur->mp_data.devmap_handle, lflag, index,
    304297                    IPC_FF_ROUTE_FROM_ME);
    … …  
    324317                        if (len + 1 == NAME_MAX) {
    325318                                /* Component length overflow */
    326                                 ipc_answer_0(rid, ENAMETOOLONG);
     319                                async_answer_0(rid, ENAMETOOLONG);
    327320                                goto out;
    328321                        }
    … …  
    358351                                next--;
    359352                       
    360                         ipc_forward_slow(rid, tmp->mp_data.phone,
     353                        async_forward_slow(rid, tmp->mp_data.phone,
    361354                            VFS_OUT_LOOKUP, next, last, tmp->mp_data.devmap_handle,
    362355                            lflag, index, IPC_FF_ROUTE_FROM_ME);
    … …  
    372365                        if (next <= last) {
    373366                                /* There are unprocessed components */
    374                                 ipc_answer_0(rid, ENOENT);
     367                                async_answer_0(rid, ENOENT);
    375368                                goto out;
    376369                        }
    … …  
    380373                                /* Request to create a new link */
    381374                                if (!ops->is_directory(cur)) {
    382                                         ipc_answer_0(rid, ENOTDIR);
     375                                        async_answer_0(rid, ENOTDIR);
    383376                                        goto out;
    384377                                }
    … …  
    398391                                                if (lflag & L_CREATE)
    399392                                                        (void) ops->destroy(fn);
    400                                                 ipc_answer_0(rid, rc);
     393                                                async_answer_0(rid, rc);
    401394                                        } else {
    402395                                                aoff64_t size = ops->size_get(fn);
    403                                                 ipc_answer_5(rid, fs_handle,
     396                                                async_answer_5(rid, fs_handle,
    404397                                                    devmap_handle,
    405398                                                    ops->index_get(fn),
    … …  
    410403                                        }
    411404                                } else
    412                                         ipc_answer_0(rid, ENOSPC);
     405                                        async_answer_0(rid, ENOSPC);
    413406                               
    414407                                goto out;
    415408                        }
    416409                       
    417                         ipc_answer_0(rid, ENOENT);
     410                        async_answer_0(rid, ENOENT);
    418411                        goto out;
    419412                }
    … …  
    441434                if (lflag & (L_CREATE | L_LINK)) {
    442435                        if (!ops->is_directory(cur)) {
    443                                 ipc_answer_0(rid, ENOTDIR);
     436                                async_answer_0(rid, ENOTDIR);
    444437                                goto out;
    445438                        }
    … …  
    450443                                if (ops->plb_get_char(next) == '/') {
    451444                                        /* More than one component */
    452                                         ipc_answer_0(rid, ENOENT);
     445                                        async_answer_0(rid, ENOENT);
    453446                                        goto out;
    454447                                }
    … …  
    456449                                if (len + 1 == NAME_MAX) {
    457450                                        /* Component length overflow */
    458                                         ipc_answer_0(rid, ENAMETOOLONG);
     451                                        async_answer_0(rid, ENAMETOOLONG);
    459452                                        goto out;
    460453                                }
    … …  
    480473                                        if (lflag & L_CREATE)
    481474                                                (void) ops->destroy(fn);
    482                                         ipc_answer_0(rid, rc);
     475                                        async_answer_0(rid, rc);
    483476                                } else {
    484477                                        aoff64_t size = ops->size_get(fn);
    485                                         ipc_answer_5(rid, fs_handle,
     478                                        async_answer_5(rid, fs_handle,
    486479                                            devmap_handle,
    487480                                            ops->index_get(fn),
    … …  
    492485                                }
    493486                        } else
    494                                 ipc_answer_0(rid, ENOSPC);
     487                                async_answer_0(rid, ENOSPC);
    495488                       
    496489                        goto out;
    497490                }
    498491               
    499                 ipc_answer_0(rid, ENOENT);
     492                async_answer_0(rid, ENOENT);
    500493                goto out;
    501494        }
    … …  
    510503                if (rc == EOK) {
    511504                        aoff64_t size = ops->size_get(cur);
    512                         ipc_answer_5(rid, fs_handle, devmap_handle,
     505                        async_answer_5(rid, fs_handle, devmap_handle,
    513506                            ops->index_get(cur), LOWER32(size), UPPER32(size),
    514507                            old_lnkcnt);
    515508                } else
    516                         ipc_answer_0(rid, rc);
     509                        async_answer_0(rid, rc);
    517510               
    518511                goto out;
    … …  
    521514        if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
    522515            (lflag & L_LINK)) {
    523                 ipc_answer_0(rid, EEXIST);
     516                async_answer_0(rid, EEXIST);
    524517                goto out;
    525518        }
    526519       
    527520        if ((lflag & L_FILE) && (ops->is_directory(cur))) {
    528                 ipc_answer_0(rid, EISDIR);
     521                async_answer_0(rid, EISDIR);
    529522                goto out;
    530523        }
    531524       
    532525        if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
    533                 ipc_answer_0(rid, ENOTDIR);
     526                async_answer_0(rid, ENOTDIR);
    534527                goto out;
    535528        }
    536529
    537530        if ((lflag & L_ROOT) && par) {
    538                 ipc_answer_0(rid, EINVAL);
     531                async_answer_0(rid, EINVAL);
    539532                goto out;
    540533        }
    … …  
    548541                if (rc == EOK) {
    549542                        aoff64_t size = ops->size_get(cur);
    550                         ipc_answer_5(rid, fs_handle, devmap_handle,
     543                        async_answer_5(rid, fs_handle, devmap_handle,
    551544                            ops->index_get(cur), LOWER32(size), UPPER32(size),
    552545                            ops->lnkcnt_get(cur));
    553546                } else
    554                         ipc_answer_0(rid, rc);
     547                        async_answer_0(rid, rc);
    555548               
    556549        } else
    557                 ipc_answer_0(rid, rc);
     550                async_answer_0(rid, rc);
    558551       
    559552out:
    … …  
    584577            (size != sizeof(struct stat))) {
    585578                ops->node_put(fn);
    586                 ipc_answer_0(callid, EINVAL);
    587                 ipc_answer_0(rid, EINVAL);
     579                async_answer_0(callid, EINVAL);
     580                async_answer_0(rid, EINVAL);
    588581                return;
    589582        }
    … …  
    604597       
    605598        async_data_read_finalize(callid, &stat, sizeof(struct stat));
    606         ipc_answer_0(rid, EOK);
     599        async_answer_0(rid, EOK);
    607600}
    608601
    … …  
    626619       
    627620        if (fn == NULL) {
    628                 ipc_answer_0(rid, ENOENT);
     621                async_answer_0(rid, ENOENT);
    629622                return;
    630623        }
    … …  
    632625        rc = ops->node_open(fn);
    633626        aoff64_t size = ops->size_get(fn);
    634         ipc_answer_4(rid, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn),
     627        async_answer_4(rid, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn),
    635628            (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0));
    636629       

  • uspace/lib/fs/libfs.h

    re26a4633 r46b881c  
    3939#include <ipc/vfs.h>
    4040#include <stdint.h>
    41 #include <ipc/ipc.h>
    4241#include <async.h>
    4342#include <devmap.h>
    … …  
    8685typedef struct {
    8786        int fs_handle;           /**< File system handle. */
    88         sysarg_t vfs_phonehash;  /**< Initial VFS phonehash. */
    8987        uint8_t *plb_ro;         /**< Read-only PLB view. */
    9088} fs_reg_t;

  • uspace/lib/net/generic/generic.c

    re26a4633 r46b881c  
    3636
    3737#include <generic.h>
    38 
    3938#include <async.h>
    40 #include <ipc/ipc.h>
    4139#include <ipc/services.h>
    42 
    4340#include <net/device.h>
    4441#include <adt/measured_strings.h>

  • uspace/lib/net/generic/packet_remote.c

    re26a4633 r46b881c  
    3838#include <async.h>
    3939#include <errno.h>
    40 #include <ipc/ipc.h>
    4140#include <ipc/packet.h>
    4241#include <sys/mman.h>

  • uspace/lib/net/il/arp_remote.c

    re26a4633 r46b881c  
    4141#include <async.h>
    4242#include <errno.h>
    43 #include <ipc/ipc.h>
    4443#include <ipc/services.h>
    4544#include <ipc/arp.h>

  • uspace/lib/net/il/il_skel.c

    re26a4633 r46b881c  
    5454         * the initial IPC_M_CONNECT_ME_TO call.
    5555         */
    56         ipc_answer_0(iid, EOK);
     56        async_answer_0(iid, EOK);
    5757       
    5858        while (true) {
    … …  
    115115                goto out;
    116116       
    117         rc = ipc_connect_to_me(PHONE_NS, service, 0, 0, NULL, NULL);
     117        rc = async_connect_to_me(PHONE_NS, service, 0, 0, NULL);
    118118        if (rc != EOK)
    119119                goto out;

  • uspace/lib/net/include/generic.h

    re26a4633 r46b881c  
    3939
    4040#include <async.h>
    41 #include <ipc/ipc.h>
    4241#include <ipc/services.h>
    4342

  • uspace/lib/net/include/il_skel.h

    re26a4633 r46b881c  
    4141#include <async.h>
    4242#include <fibril_synch.h>
    43 #include <ipc/ipc.h>
    4443#include <ipc/services.h>
    4544

  • uspace/lib/net/include/netif_skel.h

    re26a4633 r46b881c  
    4141#include <async.h>
    4242#include <fibril_synch.h>
    43 #include <ipc/ipc.h>
    4443#include <ipc/services.h>
    4544

  • uspace/lib/net/include/nil_skel.h

    re26a4633 r46b881c  
    4141#include <async.h>
    4242#include <fibril_synch.h>
    43 #include <ipc/ipc.h>
    4443#include <ipc/services.h>
    4544

  • uspace/lib/net/include/tl_skel.h

    re26a4633 r46b881c  
    4141#include <async.h>
    4242#include <fibril_synch.h>
    43 #include <ipc/ipc.h>
    4443#include <ipc/services.h>
    4544

  • uspace/lib/net/netif/netif_skel.c

    re26a4633 r46b881c  
    4040#include <fibril_synch.h>
    4141#include <stdio.h>
    42 #include <ipc/ipc.h>
    4342#include <ipc/services.h>
    4443#include <ipc/netif.h>
    … …  
    369368         * the initial IPC_M_CONNECT_ME_TO call.
    370369         */
    371         ipc_answer_0(iid, EOK);
     370        async_answer_0(iid, EOK);
    372371       
    373372        while (true) {

  • uspace/lib/net/nil/nil_skel.c

    re26a4633 r46b881c  
    5454         * the initial IPC_M_CONNECT_ME_TO call.
    5555         */
    56         ipc_answer_0(iid, EOK);
     56        async_answer_0(iid, EOK);
    5757       
    5858        while (true) {
    … …  
    115115                goto out;
    116116       
    117         rc = ipc_connect_to_me(PHONE_NS, service, 0, 0, NULL, NULL);
     117        rc = async_connect_to_me(PHONE_NS, service, 0, 0, NULL);
    118118        if (rc != EOK)
    119119                goto out;

  • uspace/lib/net/tl/icmp_remote.c

    re26a4633 r46b881c  
    4242#include <async.h>
    4343#include <errno.h>
    44 #include <ipc/ipc.h>
    4544#include <ipc/services.h>
    4645#include <ipc/icmp.h>

  • uspace/lib/net/tl/tl_skel.c

    re26a4633 r46b881c  
    5454         * the initial IPC_M_CONNECT_ME_TO call.
    5555         */
    56         ipc_answer_0(iid, EOK);
     56        async_answer_0(iid, EOK);
    5757       
    5858        /* Per-connection initialization */
    … …  
    117117                goto out;
    118118       
    119         rc = ipc_connect_to_me(PHONE_NS, service, 0, 0, NULL, NULL);
     119        rc = async_connect_to_me(PHONE_NS, service, 0, 0, NULL);
    120120        if (rc != EOK)
    121121                goto out;

  • uspace/lib/packet/generic/packet_server.c

    re26a4633 r46b881c  
    4444#include <unistd.h>
    4545#include <sys/mman.h>
    46 
    47 #include <ipc/ipc.h>
    4846#include <ipc/packet.h>
    4947#include <ipc/net.h>
    50 
    5148#include <net/packet.h>
    5249#include <net/packet_header.h>
    … …  
    292289
    293290        if (!async_share_in_receive(&callid, &size)) {
    294                 ipc_answer_0(callid, EINVAL);
     291                async_answer_0(callid, EINVAL);
    295292                return EINVAL;
    296293        }
    297294
    298295        if (size != packet->length) {
    299                 ipc_answer_0(callid, ENOMEM);
     296                async_answer_0(callid, ENOMEM);
    300297                return ENOMEM;
    301298        }

  • uspace/lib/packet/include/packet_server.h

    re26a4633 r46b881c  
    4545#define LIBPACKET_PACKET_SERVER_H_
    4646
    47 #include <ipc/ipc.h>
     47#include <ipc/common.h>
    4848
    4949extern int packet_server_message(ipc_callid_t, ipc_call_t *, ipc_call_t *,
Note: See TracChangeset for help on using the changeset viewer.