Changeset 0da4e41 in mainline for uspace/srv


Ignore:
Timestamp:
2009-10-11T16:11:22Z (16 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ba8f8cb
Parents:
bbb01b98
Message:

ipc_data_*() and ipc_share_*(), respectively, should be renamed to
async_data_*() and async_share_*(), respectively, because these functions are
using the async framework.

Location:
uspace/srv
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/ata_bd/ata_bd.c

    rbbb01b98 r0da4e41  
    252252        ipc_answer_0(iid, EOK);
    253253
    254         if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
     254        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    255255                ipc_answer_0(callid, EHANGUP);
    256256                return;
    … …  
    263263        }
    264264
    265         (void) ipc_share_out_finalize(callid, fs_va);
     265        (void) async_share_out_finalize(callid, fs_va);
    266266
    267267        while (1) {

  • uspace/srv/bd/file_bd/file_bd.c

    rbbb01b98 r0da4e41  
    130130        ipc_answer_0(iid, EOK);
    131131
    132         if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
     132        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    133133                ipc_answer_0(callid, EHANGUP);
    134134                return;
    … …  
    141141        }
    142142
    143         (void) ipc_share_out_finalize(callid, fs_va);
     143        (void) async_share_out_finalize(callid, fs_va);
    144144
    145145        while (1) {

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    rbbb01b98 r0da4e41  
    185185        ipc_answer_0(iid, EOK);
    186186
    187         if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
     187        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    188188                ipc_answer_0(callid, EHANGUP);
    189189                return;
    … …  
    201201        }
    202202
    203         (void) ipc_share_out_finalize(callid, fs_va);
     203        (void) async_share_out_finalize(callid, fs_va);
    204204
    205205        while (1) {

  • uspace/srv/bd/rd/rd.c

    rbbb01b98 r0da4e41  
    102102         */
    103103        int flags;
    104         if (ipc_share_out_receive(&callid, &comm_size, &flags)) {
     104        if (async_share_out_receive(&callid, &comm_size, &flags)) {
    105105                fs_va = as_get_mappable_page(comm_size);
    106106                if (fs_va) {
    107                         (void) ipc_share_out_finalize(callid, fs_va);
     107                        (void) async_share_out_finalize(callid, fs_va);
    108108                } else {
    109109                        ipc_answer_0(callid, EHANGUP);

  • uspace/srv/console/console.c

    rbbb01b98 r0da4e41  
    429429        ipc_callid_t callid;
    430430        size_t size;
    431         if (!ipc_data_write_receive(&callid, &size)) {
     431        if (!async_data_write_receive(&callid, &size)) {
    432432                ipc_answer_0(callid, EINVAL);
    433433                ipc_answer_0(rid, EINVAL);
    … …  
    442442        }
    443443       
    444         (void) ipc_data_write_finalize(callid, buf, size);
     444        (void) async_data_write_finalize(callid, buf, size);
    445445       
    446446        async_serialize_start();
    … …  
    464464        ipc_callid_t callid;
    465465        size_t size;
    466         if (!ipc_data_read_receive(&callid, &size)) {
     466        if (!async_data_read_receive(&callid, &size)) {
    467467                ipc_answer_0(callid, EINVAL);
    468468                ipc_answer_0(rid, EINVAL);
    … …  
    489489       
    490490        if (pos == size) {
    491                 (void) ipc_data_read_finalize(callid, buf, size);
     491                (void) async_data_read_finalize(callid, buf, size);
    492492                ipc_answer_1(rid, EOK, size);
    493493                free(buf);
    … …  
    713713       
    714714        if (interbuffer) {
    715                 if (ipc_share_out_start(fb_info.phone, interbuffer,
     715                if (async_share_out_start(fb_info.phone, interbuffer,
    716716                    AS_AREA_READ) != EOK) {
    717717                        as_area_destroy(interbuffer);

  • uspace/srv/console/gcons.c

    rbbb01b98 r0da4e41  
    339339                goto exit;
    340340       
    341         rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
     341        rc = async_share_out_start(fbphone, shm, PROTO_READ);
    342342        if (rc)
    343343                goto drop;
    … …  
    409409                goto exit;
    410410       
    411         rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
     411        rc = async_share_out_start(fbphone, shm, PROTO_READ);
    412412        if (rc)
    413413                goto drop;

  • uspace/srv/devmap/devmap.c

    rbbb01b98 r0da4e41  
    213213        ipc_callid_t callid;
    214214        size_t name_size;
    215         if (!ipc_data_write_receive(&callid, &name_size)) {
     215        if (!async_data_write_receive(&callid, &name_size)) {
    216216                free(driver);
    217217                ipc_answer_0(callid, EREFUSED);
    … …  
    241241         * Send confirmation to sender and get data into buffer.
    242242         */
    243         if (ipc_data_write_finalize(callid, driver->name, name_size) != EOK) {
     243        if (async_data_write_finalize(callid, driver->name, name_size) != EOK) {
    244244                free(driver->name);
    245245                free(driver);
    … …  
    358358        ipc_callid_t callid;
    359359        size_t size;
    360         if (!ipc_data_write_receive(&callid, &size)) {
     360        if (!async_data_write_receive(&callid, &size)) {
    361361                free(device);
    362362                ipc_answer_0(iid, EREFUSED);
    … …  
    381381        }
    382382       
    383         ipc_data_write_finalize(callid, device->name, size);
     383        async_data_write_finalize(callid, device->name, size);
    384384        device->name[size] = 0;
    385385       
    … …  
    466466        ipc_callid_t callid;
    467467        size_t size;
    468         if (!ipc_data_write_receive(&callid, &size)) {
     468        if (!async_data_write_receive(&callid, &size)) {
    469469                ipc_answer_0(callid, EREFUSED);
    470470                ipc_answer_0(iid, EREFUSED);
    … …  
    491491         * Send confirmation to sender and get data into buffer.
    492492         */
    493         ipcarg_t retval = ipc_data_write_finalize(callid, name, size);
     493        ipcarg_t retval = async_data_write_finalize(callid, name, size);
    494494        if (retval != EOK) {
    495495                ipc_answer_0(iid, EREFUSED);
    … …  
    553553         * size_t name_size = str_size(device->name);
    554554         *
    555          * int rc = ipc_data_write_send(phone, device->name, name_size);
     555         * int rc = async_data_write_send(phone, device->name, name_size);
    556556         * if (rc != EOK) {
    557557         *     async_wait_for(req, NULL);
    … …  
    576576        ipc_callid_t callid;
    577577        size_t size;
    578         if (!ipc_data_read_receive(&callid, &size)) {
     578        if (!async_data_read_receive(&callid, &size)) {
    579579                ipc_answer_0(callid, EREFUSED);
    580580                ipc_answer_0(iid, EREFUSED);
    … …  
    608608        }
    609609       
    610         ipcarg_t retval = ipc_data_read_finalize(callid, desc, pos * sizeof(dev_desc_t));
     610        ipcarg_t retval = async_data_read_finalize(callid, desc, pos * sizeof(dev_desc_t));
    611611        if (retval != EOK) {
    612612                ipc_answer_0(iid, EREFUSED);

  • uspace/srv/fs/devfs/devfs_ops.c

    rbbb01b98 r0da4e41  
    108108        ipc_callid_t callid;
    109109        size_t size;
    110         if (!ipc_data_write_receive(&callid, &size)) {
     110        if (!async_data_write_receive(&callid, &size)) {
    111111                ipc_answer_0(callid, EINVAL);
    112112                ipc_answer_0(rid, EINVAL);
    … …  
    121121        }
    122122       
    123         ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
     123        ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    124124        if (retval != EOK) {
    125125                ipc_answer_0(rid, retval);
    … …  
    286286        ipc_callid_t callid;
    287287        size_t size;
    288         if (!ipc_data_read_receive(&callid, &size) ||
     288        if (!async_data_read_receive(&callid, &size) ||
    289289            size != sizeof(struct stat)) {
    290290                ipc_answer_0(callid, EINVAL);
    … …  
    315315        }
    316316
    317         ipc_data_read_finalize(callid, &stat, sizeof(struct stat));
     317        async_data_read_finalize(callid, &stat, sizeof(struct stat));
    318318        ipc_answer_0(rid, EOK);
    319319}
    … …  
    340340               
    341341                ipc_callid_t callid;
    342                 if (!ipc_data_read_receive(&callid, NULL)) {
     342                if (!async_data_read_receive(&callid, NULL)) {
    343343                        fibril_mutex_unlock(&devices_mutex);
    344344                        ipc_answer_0(callid, EINVAL);
    … …  
    367367                ipc_callid_t callid;
    368368                size_t size;
    369                 if (!ipc_data_read_receive(&callid, &size)) {
     369                if (!async_data_read_receive(&callid, &size)) {
    370370                        ipc_answer_0(callid, EINVAL);
    371371                        ipc_answer_0(rid, EINVAL);
    … …  
    384384               
    385385                if (pos < max) {
    386                         ipc_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
     386                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    387387                } else {
    388388                        ipc_answer_0(callid, ENOENT);
    … …  
    418418               
    419419                ipc_callid_t callid;
    420                 if (!ipc_data_write_receive(&callid, NULL)) {
     420                if (!async_data_write_receive(&callid, NULL)) {
    421421                        fibril_mutex_unlock(&devices_mutex);
    422422                        ipc_answer_0(callid, EINVAL);

  • uspace/srv/fs/fat/fat_ops.c

    rbbb01b98 r0da4e41  
    897897        ipc_callid_t callid;
    898898        size_t size;
    899         if (!ipc_data_write_receive(&callid, &size)) {
     899        if (!async_data_write_receive(&callid, &size)) {
    900900                ipc_answer_0(callid, EINVAL);
    901901                ipc_answer_0(rid, EINVAL);
    … …  
    908908                return;
    909909        }
    910         ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
     910        ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    911911        if (retval != EOK) {
    912912                ipc_answer_0(rid, retval);
    … …  
    10471047        ipc_callid_t callid;
    10481048        size_t len;
    1049         if (!ipc_data_read_receive(&callid, &len)) {
     1049        if (!async_data_read_receive(&callid, &len)) {
    10501050                fat_node_put(fn);
    10511051                ipc_answer_0(callid, EINVAL);
    … …  
    10661066                        /* reading beyond the EOF */
    10671067                        bytes = 0;
    1068                         (void) ipc_data_read_finalize(callid, NULL, 0);
     1068                        (void) async_data_read_finalize(callid, NULL, 0);
    10691069                } else {
    10701070                        bytes = min(len, bps - pos % bps);
    … …  
    10731073                            BLOCK_FLAGS_NONE);
    10741074                        assert(rc == EOK);
    1075                         (void) ipc_data_read_finalize(callid, b->data + pos % bps,
     1075                        (void) async_data_read_finalize(callid, b->data + pos % bps,
    10761076                            bytes);
    10771077                        rc = block_put(b);
    … …  
    11311131                return;
    11321132hit:
    1133                 (void) ipc_data_read_finalize(callid, name, str_size(name) + 1);
     1133                (void) async_data_read_finalize(callid, name, str_size(name) + 1);
    11341134                bytes = (pos - spos) + 1;
    11351135        }
    … …  
    11691169        ipc_callid_t callid;
    11701170        size_t len;
    1171         if (!ipc_data_write_receive(&callid, &len)) {
     1171        if (!async_data_write_receive(&callid, &len)) {
    11721172                fat_node_put(fn);
    11731173                ipc_answer_0(callid, EINVAL);
    … …  
    12041204                rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
    12051205                assert(rc == EOK);
    1206                 (void) ipc_data_write_finalize(callid, b->data + pos % bps,
     1206                (void) async_data_write_finalize(callid, b->data + pos % bps,
    12071207                    bytes);
    12081208                b->dirty = true;                /* need to sync block */
    … …  
    12411241                    flags);
    12421242                assert(rc == EOK);
    1243                 (void) ipc_data_write_finalize(callid, b->data + pos % bps,
     1243                (void) async_data_write_finalize(callid, b->data + pos % bps,
    12441244                    bytes);
    12451245                b->dirty = true;                /* need to sync block */

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    rbbb01b98 r0da4e41  
    389389        ipc_callid_t callid;
    390390        size_t size;
    391         if (!ipc_data_write_receive(&callid, &size)) {
     391        if (!async_data_write_receive(&callid, &size)) {
    392392                ipc_answer_0(callid, EINVAL);
    393393                ipc_answer_0(rid, EINVAL);
    … …  
    400400                return;
    401401        }
    402         ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
     402        ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    403403        if (retval != EOK) {
    404404                ipc_answer_0(rid, retval);
    … …  
    467467        ipc_callid_t callid;
    468468        size_t size;
    469         if (!ipc_data_read_receive(&callid, &size)) {
     469        if (!async_data_read_receive(&callid, &size)) {
    470470                ipc_answer_0(callid, EINVAL);   
    471471                ipc_answer_0(rid, EINVAL);
    … …  
    476476        if (nodep->type == TMPFS_FILE) {
    477477                bytes = max(0, min(nodep->size - pos, size));
    478                 (void) ipc_data_read_finalize(callid, nodep->data + pos,
     478                (void) async_data_read_finalize(callid, nodep->data + pos,
    479479                    bytes);
    480480        } else {
    … …  
    503503                dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
    504504
    505                 (void) ipc_data_read_finalize(callid, dentryp->name,
     505                (void) async_data_read_finalize(callid, dentryp->name,
    506506                    str_size(dentryp->name) + 1);
    507507                bytes = 1;
    … …  
    541541        ipc_callid_t callid;
    542542        size_t size;
    543         if (!ipc_data_write_receive(&callid, &size)) {
     543        if (!async_data_write_receive(&callid, &size)) {
    544544                ipc_answer_0(callid, EINVAL);   
    545545                ipc_answer_0(rid, EINVAL);
    … …  
    552552        if (pos + size <= nodep->size) {
    553553                /* The file size is not changing. */
    554                 (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
     554                (void) async_data_write_finalize(callid, nodep->data + pos, size);
    555555                ipc_answer_2(rid, EOK, size, nodep->size);
    556556                return;
    … …  
    574574        nodep->size += delta;
    575575        nodep->data = newdata;
    576         (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
     576        (void) async_data_write_finalize(callid, nodep->data + pos, size);
    577577        ipc_answer_2(rid, EOK, size, nodep->size);
    578578}

  • uspace/srv/loader/main.c

    rbbb01b98 r0da4e41  
    102102        task_id = task_get_id();
    103103       
    104         if (!ipc_data_read_receive(&callid, &len)) {
     104        if (!async_data_read_receive(&callid, &len)) {
    105105                ipc_answer_0(callid, EINVAL);
    106106                ipc_answer_0(rid, EINVAL);
    … …  
    111111                len = sizeof(task_id);
    112112       
    113         ipc_data_read_finalize(callid, &task_id, len);
     113        async_data_read_finalize(callid, &task_id, len);
    114114        ipc_answer_0(rid, EOK);
    115115}
    … …  
    127127        char *name_buf;
    128128       
    129         if (!ipc_data_write_receive(&callid, &len)) {
     129        if (!async_data_write_receive(&callid, &len)) {
    130130                ipc_answer_0(callid, EINVAL);
    131131                ipc_answer_0(rid, EINVAL);
    … …  
    140140        }
    141141       
    142         ipc_data_write_finalize(callid, name_buf, len);
     142        async_data_write_finalize(callid, name_buf, len);
    143143        ipc_answer_0(rid, EOK);
    144144       
    … …  
    164164        int n;
    165165       
    166         if (!ipc_data_write_receive(&callid, &buf_size)) {
     166        if (!async_data_write_receive(&callid, &buf_size)) {
    167167                ipc_answer_0(callid, EINVAL);
    168168                ipc_answer_0(rid, EINVAL);
    … …  
    187187        }
    188188       
    189         ipc_data_write_finalize(callid, arg_buf, buf_size);
     189        async_data_write_finalize(callid, arg_buf, buf_size);
    190190       
    191191        arg_buf[buf_size] = '\0';
    … …  
    239239        ipc_callid_t callid;
    240240        size_t buf_size;
    241         if (!ipc_data_write_receive(&callid, &buf_size)) {
     241        if (!async_data_write_receive(&callid, &buf_size)) {
    242242                ipc_answer_0(callid, EINVAL);
    243243                ipc_answer_0(rid, EINVAL);
    … …  
    268268        }
    269269       
    270         ipc_data_write_finalize(callid, fil_buf, buf_size);
     270        async_data_write_finalize(callid, fil_buf, buf_size);
    271271       
    272272        int count = buf_size / sizeof(fdi_node_t);

  • uspace/srv/part/mbr_part/mbr_part.c

    rbbb01b98 r0da4e41  
    419419        ipc_answer_0(iid, EOK);
    420420
    421         if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
     421        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    422422                ipc_answer_0(callid, EHANGUP);
    423423                return;
    … …  
    430430        }
    431431
    432         (void) ipc_share_out_finalize(callid, fs_va);
     432        (void) async_share_out_finalize(callid, fs_va);
    433433
    434434        while (1) {

  • uspace/srv/vfs/vfs_ops.c

    rbbb01b98 r0da4e41  
    125125                            (ipcarg_t) dev_handle, &answer);
    126126                        /* send the mount options */
    127                         rc = ipc_data_write_start(phone, (void *)opts,
     127                        rc = async_data_write_start(phone, (void *)opts,
    128128                            str_size(opts));
    129129                        if (rc != EOK) {
    … …  
    207207       
    208208        /* send the mount options */
    209         rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
     209        rc = async_data_write_start(phone, (void *)opts, str_size(opts));
    210210        if (rc != EOK) {
    211211                async_wait_for(msg, NULL);
    … …  
    268268        ipc_callid_t callid;
    269269        size_t size;
    270         if (!ipc_data_write_receive(&callid, &size)) {
     270        if (!async_data_write_receive(&callid, &size)) {
    271271                ipc_answer_0(callid, EINVAL);
    272272                ipc_answer_0(rid, EINVAL);
    … …  
    290290       
    291291        /* Deliver the mount point. */
    292         ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
     292        ipcarg_t retval = async_data_write_finalize(callid, mp, size);
    293293        if (retval != EOK) {
    294294                ipc_answer_0(rid, retval);
    … …  
    299299       
    300300        /* Now we expect to receive the mount options. */
    301         if (!ipc_data_write_receive(&callid, &size)) {
     301        if (!async_data_write_receive(&callid, &size)) {
    302302                ipc_answer_0(callid, EINVAL);
    303303                ipc_answer_0(rid, EINVAL);
    … …  
    324324
    325325        /* Deliver the mount options. */
    326         retval = ipc_data_write_finalize(callid, opts, size);
     326        retval = async_data_write_finalize(callid, opts, size);
    327327        if (retval != EOK) {
    328328                ipc_answer_0(rid, retval);
    … …  
    337337         * system.
    338338         */
    339         if (!ipc_data_write_receive(&callid, &size)) {
     339        if (!async_data_write_receive(&callid, &size)) {
    340340                ipc_answer_0(callid, EINVAL);
    341341                ipc_answer_0(rid, EINVAL);
    … …  
    370370       
    371371        /* Deliver the file system name. */
    372         retval = ipc_data_write_finalize(callid, fs_name, size);
     372        retval = async_data_write_finalize(callid, fs_name, size);
    373373        if (retval != EOK) {
    374374                ipc_answer_0(rid, retval);
    … …  
    469469       
    470470        ipc_callid_t callid;
    471         if (!ipc_data_write_receive(&callid, &len)) {
     471        if (!async_data_write_receive(&callid, &len)) {
    472472                ipc_answer_0(callid, EINVAL);
    473473                ipc_answer_0(rid, EINVAL);
    … …  
    483483       
    484484        int rc;
    485         if ((rc = ipc_data_write_finalize(callid, path, len))) {
     485        if ((rc = async_data_write_finalize(callid, path, len))) {
    486486                ipc_answer_0(rid, rc);
    487487                free(path);
    … …  
    747747        int res;
    748748        if (read)
    749                 res = ipc_data_read_receive(&callid, NULL);
     749                res = async_data_read_receive(&callid, NULL);
    750750        else
    751                 res = ipc_data_write_receive(&callid, NULL);
     751                res = async_data_write_receive(&callid, NULL);
    752752        if (!res) {
    753753                ipc_answer_0(callid, EINVAL);
    … …  
    943943
    944944        ipc_callid_t callid;
    945         if (!ipc_data_read_receive(&callid, NULL)) {
     945        if (!async_data_read_receive(&callid, NULL)) {
    946946                ipc_answer_0(callid, EINVAL);
    947947                ipc_answer_0(rid, EINVAL);
    … …  
    969969        ipc_callid_t callid;
    970970
    971         if (!ipc_data_write_receive(&callid, &len)) {
     971        if (!async_data_write_receive(&callid, &len)) {
    972972                ipc_answer_0(callid, EINVAL);
    973973                ipc_answer_0(rid, EINVAL);
    … …  
    981981        }
    982982        int rc;
    983         if ((rc = ipc_data_write_finalize(callid, path, len))) {
     983        if ((rc = async_data_write_finalize(callid, path, len))) {
    984984                ipc_answer_0(rid, rc);
    985985                free(path);
    … …  
    988988        path[len] = '\0';
    989989
    990         if (!ipc_data_read_receive(&callid, NULL)) {
     990        if (!async_data_read_receive(&callid, NULL)) {
    991991                free(path);
    992992                ipc_answer_0(callid, EINVAL);
    … …  
    10371037        ipc_callid_t callid;
    10381038
    1039         if (!ipc_data_write_receive(&callid, &len)) {
     1039        if (!async_data_write_receive(&callid, &len)) {
    10401040                ipc_answer_0(callid, EINVAL);
    10411041                ipc_answer_0(rid, EINVAL);
    … …  
    10491049        }
    10501050        int rc;
    1051         if ((rc = ipc_data_write_finalize(callid, path, len))) {
     1051        if ((rc = async_data_write_finalize(callid, path, len))) {
    10521052                ipc_answer_0(rid, rc);
    10531053                free(path);
    … …  
    10741074        ipc_callid_t callid;
    10751075
    1076         if (!ipc_data_write_receive(&callid, &len)) {
     1076        if (!async_data_write_receive(&callid, &len)) {
    10771077                ipc_answer_0(callid, EINVAL);
    10781078                ipc_answer_0(rid, EINVAL);
    … …  
    10861086        }
    10871087        int rc;
    1088         if ((rc = ipc_data_write_finalize(callid, path, len))) {
     1088        if ((rc = async_data_write_finalize(callid, path, len))) {
    10891089                ipc_answer_0(rid, rc);
    10901090                free(path);
    … …  
    11251125
    11261126        /* Retrieve the old path. */
    1127         if (!ipc_data_write_receive(&callid, &olen)) {
     1127        if (!async_data_write_receive(&callid, &olen)) {
    11281128                ipc_answer_0(callid, EINVAL);
    11291129                ipc_answer_0(rid, EINVAL);
    … …  
    11361136                return;
    11371137        }
    1138         if ((rc = ipc_data_write_finalize(callid, old, olen))) {
     1138        if ((rc = async_data_write_finalize(callid, old, olen))) {
    11391139                ipc_answer_0(rid, rc);
    11401140                free(old);
    … …  
    11441144       
    11451145        /* Retrieve the new path. */
    1146         if (!ipc_data_write_receive(&callid, &nlen)) {
     1146        if (!async_data_write_receive(&callid, &nlen)) {
    11471147                ipc_answer_0(callid, EINVAL);
    11481148                ipc_answer_0(rid, EINVAL);
    … …  
    11571157                return;
    11581158        }
    1159         if ((rc = ipc_data_write_finalize(callid, new, nlen))) {
     1159        if ((rc = async_data_write_finalize(callid, new, nlen))) {
    11601160                ipc_answer_0(rid, rc);
    11611161                free(old);

  • uspace/srv/vfs/vfs_register.c

    rbbb01b98 r0da4e41  
    122122         * VFS info structure from the client FS.
    123123         */
    124         if (!ipc_data_write_receive(&callid, &size)) {
     124        if (!async_data_write_receive(&callid, &size)) {
    125125                /*
    126126                 * The client doesn't obey the same protocol as we do.
    … …  
    163163        fibril_mutex_initialize(&fs_info->phone_lock);
    164164               
    165         rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
     165        rc = async_data_write_finalize(callid, &fs_info->vfs_info, size);
    166166        if (rc != EOK) {
    167167                dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
    … …  
    229229         */
    230230
    231         if (!ipc_share_in_receive(&callid, &size)) {
     231        if (!async_share_in_receive(&callid, &size)) {
    232232                dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
    233233                list_remove(&fs_info->fs_link);
    … …  
    257257         * Commit to read-only sharing the PLB with the client.
    258258         */
    259         (void) ipc_share_in_finalize(callid, plb,
     259        (void) async_share_in_finalize(callid, plb,
    260260            AS_AREA_READ | AS_AREA_CACHEABLE);
    261261
Note: See TracChangeset for help on using the changeset viewer.