Changeset ffa2c8ef in mainline for uspace/lib


Ignore:
Timestamp:
2011-01-29T11:36:08Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
46b881c
Parents:
64d2b10
Message:

do not intermix low-level IPC methods with async framework methods

Location:
uspace/lib
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/block/libblock.c

    r64d2b10 rffa2c8ef  
    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/event.c

    r64d2b10 rffa2c8ef  
    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/drv/generic/driver.c

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    3939
    4040#include <async.h>
    41 #include <ipc/ipc.h>
    4241#include <ipc/services.h>
    4342

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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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

    r64d2b10 rffa2c8ef  
    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.