Changeset 0da4e41 in mainline for uspace/srv/fs


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/fs
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • 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}
Note: See TracChangeset for help on using the changeset viewer.