Changeset ffa2c8ef in mainline for uspace/srv/fs


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

Legend:

Unmodified
Added
Removed

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

    r64d2b10 rffa2c8ef  
    4040
    4141#include <stdio.h>
    42 #include <ipc/ipc.h>
    4342#include <ipc/services.h>
    4443#include <ipc/ns.h>
    … …  
    6362{
    6463        if (iid)
    65                 ipc_answer_0(iid, EOK);
     64                async_answer_0(iid, EOK);
    6665       
    6766        while (true) {
    … …  
    112111                        break;
    113112                default:
    114                         ipc_answer_0(callid, ENOTSUP);
     113                        async_answer_0(callid, ENOTSUP);
    115114                        break;
    116115                }

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

    r64d2b10 rffa2c8ef  
    3636 */
    3737
    38 #include <ipc/ipc.h>
    3938#include <macros.h>
    4039#include <bool.h>
    … …  
    465464            0, NULL);
    466465        if (retval != EOK) {
    467                 ipc_answer_0(rid, retval);
     466                async_answer_0(rid, retval);
    468467                return;
    469468        }
    470469       
    471470        free(opts);
    472         ipc_answer_3(rid, EOK, 0, 0, 0);
     471        async_answer_3(rid, EOK, 0, 0, 0);
    473472}
    474473
    … …  
    480479void devfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    481480{
    482         ipc_answer_0(rid, ENOTSUP);
     481        async_answer_0(rid, ENOTSUP);
    483482}
    484483
    … …  
    513512                size_t size;
    514513                if (!async_data_read_receive(&callid, &size)) {
    515                         ipc_answer_0(callid, EINVAL);
    516                         ipc_answer_0(rid, EINVAL);
     514                        async_answer_0(callid, EINVAL);
     515                        async_answer_0(rid, EINVAL);
    517516                        return;
    518517                }
    … …  
    535534                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    536535                        free(desc);
    537                         ipc_answer_1(rid, EOK, 1);
     536                        async_answer_1(rid, EOK, 1);
    538537                        return;
    539538                }
    … …  
    550549                                async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    551550                                free(desc);
    552                                 ipc_answer_1(rid, EOK, 1);
     551                                async_answer_1(rid, EOK, 1);
    553552                                return;
    554553                        }
    … …  
    557556                }
    558557               
    559                 ipc_answer_0(callid, ENOENT);
    560                 ipc_answer_1(rid, ENOENT, 0);
     558                async_answer_0(callid, ENOENT);
     559                async_answer_1(rid, ENOENT, 0);
    561560                return;
    562561        }
    … …  
    569568                size_t size;
    570569                if (!async_data_read_receive(&callid, &size)) {
    571                         ipc_answer_0(callid, EINVAL);
    572                         ipc_answer_0(rid, EINVAL);
     570                        async_answer_0(callid, EINVAL);
     571                        async_answer_0(rid, EINVAL);
    573572                        return;
    574573                }
    … …  
    580579                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    581580                        free(desc);
    582                         ipc_answer_1(rid, EOK, 1);
     581                        async_answer_1(rid, EOK, 1);
    583582                        return;
    584583                }
    585584               
    586585                free(desc);
    587                 ipc_answer_0(callid, ENOENT);
    588                 ipc_answer_1(rid, ENOENT, 0);
     586                async_answer_0(callid, ENOENT);
     587                async_answer_1(rid, ENOENT, 0);
    589588                return;
    590589        }
    … …  
    601600                if (lnk == NULL) {
    602601                        fibril_mutex_unlock(&devices_mutex);
    603                         ipc_answer_0(rid, ENOENT);
     602                        async_answer_0(rid, ENOENT);
    604603                        return;
    605604                }
    … …  
    611610                if (!async_data_read_receive(&callid, NULL)) {
    612611                        fibril_mutex_unlock(&devices_mutex);
    613                         ipc_answer_0(callid, EINVAL);
    614                         ipc_answer_0(rid, EINVAL);
     612                        async_answer_0(callid, EINVAL);
     613                        async_answer_0(rid, EINVAL);
    615614                        return;
    616615                }
    … …  
    623622               
    624623                /* Forward the IPC_M_DATA_READ request to the driver */
    625                 ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     624                async_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    626625                fibril_mutex_unlock(&devices_mutex);
    627626               
    … …  
    632631               
    633632                /* Driver reply is the final result of the whole operation */
    634                 ipc_answer_1(rid, rc, bytes);
    635                 return;
    636         }
    637        
    638         ipc_answer_0(rid, ENOENT);
     633                async_answer_1(rid, rc, bytes);
     634                return;
     635        }
     636       
     637        async_answer_0(rid, ENOENT);
    639638}
    640639
    … …  
    643642        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    644643        if (index == 0) {
    645                 ipc_answer_0(rid, ENOTSUP);
     644                async_answer_0(rid, ENOTSUP);
    646645                return;
    647646        }
    … …  
    651650        if (type == DEV_HANDLE_NAMESPACE) {
    652651                /* Namespace directory */
    653                 ipc_answer_0(rid, ENOTSUP);
     652                async_answer_0(rid, ENOTSUP);
    654653                return;
    655654        }
    … …  
    665664                if (lnk == NULL) {
    666665                        fibril_mutex_unlock(&devices_mutex);
    667                         ipc_answer_0(rid, ENOENT);
     666                        async_answer_0(rid, ENOENT);
    668667                        return;
    669668                }
    … …  
    675674                if (!async_data_write_receive(&callid, NULL)) {
    676675                        fibril_mutex_unlock(&devices_mutex);
    677                         ipc_answer_0(callid, EINVAL);
    678                         ipc_answer_0(rid, EINVAL);
     676                        async_answer_0(callid, EINVAL);
     677                        async_answer_0(rid, EINVAL);
    679678                        return;
    680679                }
    … …  
    687686               
    688687                /* Forward the IPC_M_DATA_WRITE request to the driver */
    689                 ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     688                async_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    690689               
    691690                fibril_mutex_unlock(&devices_mutex);
    … …  
    697696               
    698697                /* Driver reply is the final result of the whole operation */
    699                 ipc_answer_1(rid, rc, bytes);
    700                 return;
    701         }
    702        
    703         ipc_answer_0(rid, ENOENT);
     698                async_answer_1(rid, rc, bytes);
     699                return;
     700        }
     701       
     702        async_answer_0(rid, ENOENT);
    704703}
    705704
    706705void devfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    707706{
    708         ipc_answer_0(rid, ENOTSUP);
     707        async_answer_0(rid, ENOTSUP);
    709708}
    710709
    … …  
    714713       
    715714        if (index == 0) {
    716                 ipc_answer_0(rid, EOK);
     715                async_answer_0(rid, EOK);
    717716                return;
    718717        }
    … …  
    722721        if (type == DEV_HANDLE_NAMESPACE) {
    723722                /* Namespace directory */
    724                 ipc_answer_0(rid, EOK);
     723                async_answer_0(rid, EOK);
    725724                return;
    726725        }
    … …  
    735734                if (lnk == NULL) {
    736735                        fibril_mutex_unlock(&devices_mutex);
    737                         ipc_answer_0(rid, ENOENT);
     736                        async_answer_0(rid, ENOENT);
    738737                        return;
    739738                }
    … …  
    744743               
    745744                if (dev->refcount == 0) {
    746                         ipc_hangup(dev->phone);
     745                        async_hangup(dev->phone);
    747746                        hash_table_remove(&devices, key, DEVICES_KEYS);
    748747                }
    … …  
    750749                fibril_mutex_unlock(&devices_mutex);
    751750               
    752                 ipc_answer_0(rid, EOK);
    753                 return;
    754         }
    755        
    756         ipc_answer_0(rid, ENOENT);
     751                async_answer_0(rid, EOK);
     752                return;
     753        }
     754       
     755        async_answer_0(rid, ENOENT);
    757756}
    758757
    … …  
    762761       
    763762        if (index == 0) {
    764                 ipc_answer_0(rid, EOK);
     763                async_answer_0(rid, EOK);
    765764                return;
    766765        }
    … …  
    770769        if (type == DEV_HANDLE_NAMESPACE) {
    771770                /* Namespace directory */
    772                 ipc_answer_0(rid, EOK);
     771                async_answer_0(rid, EOK);
    773772                return;
    774773        }
    … …  
    783782                if (lnk == NULL) {
    784783                        fibril_mutex_unlock(&devices_mutex);
    785                         ipc_answer_0(rid, ENOENT);
     784                        async_answer_0(rid, ENOENT);
    786785                        return;
    787786                }
    … …  
    802801               
    803802                /* Driver reply is the final result of the whole operation */
    804                 ipc_answer_0(rid, rc);
    805                 return;
    806         }
    807        
    808         ipc_answer_0(rid, ENOENT);
     803                async_answer_0(rid, rc);
     804                return;
     805        }
     806       
     807        async_answer_0(rid, ENOENT);
    809808}
    810809
    811810void devfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    812811{
    813         ipc_answer_0(rid, ENOTSUP);
     812        async_answer_0(rid, ENOTSUP);
    814813}
    815814

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

    r64d2b10 rffa2c8ef  
    3434#define DEVFS_DEVFS_OPS_H_
    3535
    36 #include <ipc/ipc.h>
     36#include <ipc/common.h>
    3737#include <bool.h>
    3838

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

    r64d2b10 rffa2c8ef  
    3838
    3939#include "fat.h"
    40 #include <ipc/ipc.h>
    4140#include <ipc/services.h>
    4241#include <ipc/ns.h>
    … …  
    8584                 * created by IPC_M_CONNECT_TO_ME.
    8685                 */
    87                 ipc_answer_0(iid, EOK);
     86                async_answer_0(iid, EOK);
    8887        }
    8988       
    … …  
    137136                        break;
    138137                default:
    139                         ipc_answer_0(callid, ENOTSUP);
     138                        async_answer_0(callid, ENOTSUP);
    140139                        break;
    141140                }

  • uspace/srv/fs/fat/fat.h

    r64d2b10 rffa2c8ef  
    3535
    3636#include "fat_fat.h"
    37 #include <ipc/ipc.h>
    3837#include <fibril_synch.h>
    3938#include <libfs.h>

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

    r64d2b10 rffa2c8ef  
    4242#include <libfs.h>
    4343#include <libblock.h>
    44 #include <ipc/ipc.h>
    4544#include <ipc/services.h>
    4645#include <ipc/devmap.h>
    … …  
    955954       
    956955        if (rc != EOK) {
    957                 ipc_answer_0(rid, rc);
     956                async_answer_0(rid, rc);
    958957                return;
    959958        }
    … …  
    970969        rc = block_init(devmap_handle, BS_SIZE);
    971970        if (rc != EOK) {
    972                 ipc_answer_0(rid, rc);
     971                async_answer_0(rid, rc);
    973972                return;
    974973        }
    … …  
    978977        if (rc != EOK) {
    979978                block_fini(devmap_handle);
    980                 ipc_answer_0(rid, rc);
     979                async_answer_0(rid, rc);
    981980                return;
    982981        }
    … …  
    987986        if (BPS(bs) != BS_SIZE) {
    988987                block_fini(devmap_handle);
    989                 ipc_answer_0(rid, ENOTSUP);
     988                async_answer_0(rid, ENOTSUP);
    990989                return;
    991990        }
    … …  
    995994        if (rc != EOK) {
    996995                block_fini(devmap_handle);
    997                 ipc_answer_0(rid, rc);
     996                async_answer_0(rid, rc);
    998997                return;
    999998        }
    … …  
    10041003                (void) block_cache_fini(devmap_handle);
    10051004                block_fini(devmap_handle);
    1006                 ipc_answer_0(rid, rc);
     1005                async_answer_0(rid, rc);
    10071006                return;
    10081007        }
    … …  
    10121011                (void) block_cache_fini(devmap_handle);
    10131012                block_fini(devmap_handle);
    1014                 ipc_answer_0(rid, rc);
     1013                async_answer_0(rid, rc);
    10151014                return;
    10161015        }
    … …  
    10221021                block_fini(devmap_handle);
    10231022                fat_idx_fini_by_devmap_handle(devmap_handle);
    1024                 ipc_answer_0(rid, ENOMEM);
     1023                async_answer_0(rid, ENOMEM);
    10251024                return;
    10261025        }
    … …  
    10321031                block_fini(devmap_handle);
    10331032                fat_idx_fini_by_devmap_handle(devmap_handle);
    1034                 ipc_answer_0(rid, ENOMEM);
     1033                async_answer_0(rid, ENOMEM);
    10351034                return;
    10361035        }
    … …  
    10441043                block_fini(devmap_handle);
    10451044                fat_idx_fini_by_devmap_handle(devmap_handle);
    1046                 ipc_answer_0(rid, ENOMEM);
     1045                async_answer_0(rid, ENOMEM);
    10471046                return;
    10481047        }
    … …  
    10621061        fibril_mutex_unlock(&ridxp->lock);
    10631062
    1064         ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
     1063        async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    10651064}
    10661065
    … …  
    10791078        rc = fat_root_get(&fn, devmap_handle);
    10801079        if (rc != EOK) {
    1081                 ipc_answer_0(rid, rc);
     1080                async_answer_0(rid, rc);
    10821081                return;
    10831082        }
    … …  
    10901089        if (nodep->refcnt != 2) {
    10911090                (void) fat_node_put(fn);
    1092                 ipc_answer_0(rid, EBUSY);
     1091                async_answer_0(rid, EBUSY);
    10931092                return;
    10941093        }
    … …  
    11101109        block_fini(devmap_handle);
    11111110
    1112         ipc_answer_0(rid, EOK);
     1111        async_answer_0(rid, EOK);
    11131112}
    11141113
    … …  
    11381137        rc = fat_node_get(&fn, devmap_handle, index);
    11391138        if (rc != EOK) {
    1140                 ipc_answer_0(rid, rc);
     1139                async_answer_0(rid, rc);
    11411140                return;
    11421141        }
    11431142        if (!fn) {
    1144                 ipc_answer_0(rid, ENOENT);
     1143                async_answer_0(rid, ENOENT);
    11451144                return;
    11461145        }
    … …  
    11511150        if (!async_data_read_receive(&callid, &len)) {
    11521151                fat_node_put(fn);
    1153                 ipc_answer_0(callid, EINVAL);
    1154                 ipc_answer_0(rid, EINVAL);
     1152                async_answer_0(callid, EINVAL);
     1153                async_answer_0(rid, EINVAL);
    11551154                return;
    11561155        }
    … …  
    11751174                        if (rc != EOK) {
    11761175                                fat_node_put(fn);
    1177                                 ipc_answer_0(callid, rc);
    1178                                 ipc_answer_0(rid, rc);
     1176                                async_answer_0(callid, rc);
     1177                                async_answer_0(rid, rc);
    11791178                                return;
    11801179                        }
    … …  
    11841183                        if (rc != EOK) {
    11851184                                fat_node_put(fn);
    1186                                 ipc_answer_0(rid, rc);
     1185                                async_answer_0(rid, rc);
    11871186                                return;
    11881187                        }
    … …  
    12411240miss:
    12421241                rc = fat_node_put(fn);
    1243                 ipc_answer_0(callid, rc != EOK ? rc : ENOENT);
    1244                 ipc_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
     1242                async_answer_0(callid, rc != EOK ? rc : ENOENT);
     1243                async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    12451244                return;
    12461245
    12471246err:
    12481247                (void) fat_node_put(fn);
    1249                 ipc_answer_0(callid, rc);
    1250                 ipc_answer_0(rid, rc);
     1248                async_answer_0(callid, rc);
     1249                async_answer_0(rid, rc);
    12511250                return;
    12521251
    … …  
    12571256
    12581257        rc = fat_node_put(fn);
    1259         ipc_answer_1(rid, rc, (sysarg_t)bytes);
     1258        async_answer_1(rid, rc, (sysarg_t)bytes);
    12601259}
    12611260
    … …  
    12771276        rc = fat_node_get(&fn, devmap_handle, index);
    12781277        if (rc != EOK) {
    1279                 ipc_answer_0(rid, rc);
     1278                async_answer_0(rid, rc);
    12801279                return;
    12811280        }
    12821281        if (!fn) {
    1283                 ipc_answer_0(rid, ENOENT);
     1282                async_answer_0(rid, ENOENT);
    12841283                return;
    12851284        }
    … …  
    12901289        if (!async_data_write_receive(&callid, &len)) {
    12911290                (void) fat_node_put(fn);
    1292                 ipc_answer_0(callid, EINVAL);
    1293                 ipc_answer_0(rid, EINVAL);
     1291                async_answer_0(callid, EINVAL);
     1292                async_answer_0(rid, EINVAL);
    12941293                return;
    12951294        }
    … …  
    13191318                if (rc != EOK) {
    13201319                        (void) fat_node_put(fn);
    1321                         ipc_answer_0(callid, rc);
    1322                         ipc_answer_0(rid, rc);
     1320                        async_answer_0(callid, rc);
     1321                        async_answer_0(rid, rc);
    13231322                        return;
    13241323                }
    … …  
    13261325                if (rc != EOK) {
    13271326                        (void) fat_node_put(fn);
    1328                         ipc_answer_0(callid, rc);
    1329                         ipc_answer_0(rid, rc);
     1327                        async_answer_0(callid, rc);
     1328                        async_answer_0(rid, rc);
    13301329                        return;
    13311330                }
    … …  
    13361335                if (rc != EOK) {
    13371336                        (void) fat_node_put(fn);
    1338                         ipc_answer_0(rid, rc);
     1337                        async_answer_0(rid, rc);
    13391338                        return;
    13401339                }
    … …  
    13451344                size = nodep->size;
    13461345                rc = fat_node_put(fn);
    1347                 ipc_answer_2(rid, rc, bytes, nodep->size);
     1346                async_answer_2(rid, rc, bytes, nodep->size);
    13481347                return;
    13491348        } else {
    … …  
    13611360                        /* could not allocate a chain of nclsts clusters */
    13621361                        (void) fat_node_put(fn);
    1363                         ipc_answer_0(callid, rc);
    1364                         ipc_answer_0(rid, rc);
     1362                        async_answer_0(callid, rc);
     1363                        async_answer_0(rid, rc);
    13651364                        return;
    13661365                }
    … …  
    13701369                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13711370                        (void) fat_node_put(fn);
    1372                         ipc_answer_0(callid, rc);
    1373                         ipc_answer_0(rid, rc);
     1371                        async_answer_0(callid, rc);
     1372                        async_answer_0(rid, rc);
    13741373                        return;
    13751374                }
    … …  
    13791378                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13801379                        (void) fat_node_put(fn);
    1381                         ipc_answer_0(callid, rc);
    1382                         ipc_answer_0(rid, rc);
     1380                        async_answer_0(callid, rc);
     1381                        async_answer_0(rid, rc);
    13831382                        return;
    13841383                }
    … …  
    13901389                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13911390                        (void) fat_node_put(fn);
    1392                         ipc_answer_0(rid, rc);
     1391                        async_answer_0(rid, rc);
    13931392                        return;
    13941393                }
    … …  
    14011400                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    14021401                        (void) fat_node_put(fn);
    1403                         ipc_answer_0(rid, rc);
     1402                        async_answer_0(rid, rc);
    14041403                        return;
    14051404                }
    … …  
    14071406                nodep->dirty = true;            /* need to sync node */
    14081407                rc = fat_node_put(fn);
    1409                 ipc_answer_2(rid, rc, bytes, size);
     1408                async_answer_2(rid, rc, bytes, size);
    14101409                return;
    14111410        }
    … …  
    14251424        rc = fat_node_get(&fn, devmap_handle, index);
    14261425        if (rc != EOK) {
    1427                 ipc_answer_0(rid, rc);
     1426                async_answer_0(rid, rc);
    14281427                return;
    14291428        }
    14301429        if (!fn) {
    1431                 ipc_answer_0(rid, ENOENT);
     1430                async_answer_0(rid, ENOENT);
    14321431                return;
    14331432        }
    … …  
    14751474out:
    14761475        fat_node_put(fn);
    1477         ipc_answer_0(rid, rc);
     1476        async_answer_0(rid, rc);
    14781477        return;
    14791478}
    … …  
    14811480void fat_close(ipc_callid_t rid, ipc_call_t *request)
    14821481{
    1483         ipc_answer_0(rid, EOK);
     1482        async_answer_0(rid, EOK);
    14841483}
    14851484
    … …  
    14931492        rc = fat_node_get(&fn, devmap_handle, index);
    14941493        if (rc != EOK) {
    1495                 ipc_answer_0(rid, rc);
     1494                async_answer_0(rid, rc);
    14961495                return;
    14971496        }
    14981497        if (!fn) {
    1499                 ipc_answer_0(rid, ENOENT);
     1498                async_answer_0(rid, ENOENT);
    15001499                return;
    15011500        }
    15021501
    15031502        rc = fat_destroy_node(fn);
    1504         ipc_answer_0(rid, rc);
     1503        async_answer_0(rid, rc);
    15051504}
    15061505
    … …  
    15231522        int rc = fat_node_get(&fn, devmap_handle, index);
    15241523        if (rc != EOK) {
    1525                 ipc_answer_0(rid, rc);
     1524                async_answer_0(rid, rc);
    15261525                return;
    15271526        }
    15281527        if (!fn) {
    1529                 ipc_answer_0(rid, ENOENT);
     1528                async_answer_0(rid, ENOENT);
    15301529                return;
    15311530        }
    … …  
    15371536       
    15381537        fat_node_put(fn);
    1539         ipc_answer_0(rid, rc);
     1538        async_answer_0(rid, rc);
    15401539}
    15411540

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

    r64d2b10 rffa2c8ef  
    4242
    4343#include "tmpfs.h"
    44 #include <ipc/ipc.h>
    4544#include <ipc/services.h>
    4645#include <ipc/ns.h>
    … …  
    9190                 * created by IPC_M_CONNECT_TO_ME.
    9291                 */
    93                 ipc_answer_0(iid, EOK);
     92                async_answer_0(iid, EOK);
    9493        }
    9594       
    … …  
    143142                        break;
    144143                default:
    145                         ipc_answer_0(callid, ENOTSUP);
     144                        async_answer_0(callid, ENOTSUP);
    146145                        break;
    147146                }

  • uspace/srv/fs/tmpfs/tmpfs.h

    r64d2b10 rffa2c8ef  
    3434#define TMPFS_TMPFS_H_
    3535
    36 #include <ipc/ipc.h>
    3736#include <libfs.h>
    3837#include <atomic.h>

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

    r64d2b10 rffa2c8ef  
    3939#include "tmpfs.h"
    4040#include "../../vfs/vfs.h"
    41 #include <ipc/ipc.h>
    4241#include <macros.h>
    4342#include <stdint.h>
    … …  
    450449        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    451450        if (rc != EOK) {
    452                 ipc_answer_0(rid, rc);
     451                async_answer_0(rid, rc);
    453452                return;
    454453        }
    … …  
    459458                (void) tmpfs_node_put(rootfn);
    460459                free(opts);
    461                 ipc_answer_0(rid, EEXIST);
     460                async_answer_0(rid, EEXIST);
    462461                return;
    463462        }
    … …  
    466465        if (!tmpfs_instance_init(devmap_handle)) {
    467466                free(opts);
    468                 ipc_answer_0(rid, ENOMEM);
     467                async_answer_0(rid, ENOMEM);
    469468                return;
    470469        }
    … …  
    475474        if (str_cmp(opts, "restore") == 0) {
    476475                if (tmpfs_restore(devmap_handle))
    477                         ipc_answer_3(rid, EOK, rootp->index, rootp->size,
     476                        async_answer_3(rid, EOK, rootp->index, rootp->size,
    478477                            rootp->lnkcnt);
    479478                else
    480                         ipc_answer_0(rid, ELIMIT);
     479                        async_answer_0(rid, ELIMIT);
    481480        } else {
    482                 ipc_answer_3(rid, EOK, rootp->index, rootp->size,
     481                async_answer_3(rid, EOK, rootp->index, rootp->size,
    483482                    rootp->lnkcnt);
    484483        }
    … …  
    496495
    497496        tmpfs_instance_done(devmap_handle);
    498         ipc_answer_0(rid, EOK);
     497        async_answer_0(rid, EOK);
    499498}
    500499
    … …  
    526525        hlp = hash_table_find(&nodes, key);
    527526        if (!hlp) {
    528                 ipc_answer_0(rid, ENOENT);
     527                async_answer_0(rid, ENOENT);
    529528                return;
    530529        }
    … …  
    538537        size_t size;
    539538        if (!async_data_read_receive(&callid, &size)) {
    540                 ipc_answer_0(callid, EINVAL);
    541                 ipc_answer_0(rid, EINVAL);
     539                async_answer_0(callid, EINVAL);
     540                async_answer_0(rid, EINVAL);
    542541                return;
    543542        }
    … …  
    566565
    567566                if (lnk == &nodep->cs_head) {
    568                         ipc_answer_0(callid, ENOENT);
    569                         ipc_answer_1(rid, ENOENT, 0);
     567                        async_answer_0(callid, ENOENT);
     568                        async_answer_1(rid, ENOENT, 0);
    570569                        return;
    571570                }
    … …  
    581580         * Answer the VFS_READ call.
    582581         */
    583         ipc_answer_1(rid, EOK, bytes);
     582        async_answer_1(rid, EOK, bytes);
    584583}
    585584
    … …  
    601600        hlp = hash_table_find(&nodes, key);
    602601        if (!hlp) {
    603                 ipc_answer_0(rid, ENOENT);
     602                async_answer_0(rid, ENOENT);
    604603                return;
    605604        }
    … …  
    613612        size_t size;
    614613        if (!async_data_write_receive(&callid, &size)) {
    615                 ipc_answer_0(callid, EINVAL);   
    616                 ipc_answer_0(rid, EINVAL);
     614                async_answer_0(callid, EINVAL);
     615                async_answer_0(rid, EINVAL);
    617616                return;
    618617        }
    … …  
    624623                /* The file size is not changing. */
    625624                (void) async_data_write_finalize(callid, nodep->data + pos, size);
    626                 ipc_answer_2(rid, EOK, size, nodep->size);
     625                async_answer_2(rid, EOK, size, nodep->size);
    627626                return;
    628627        }
    … …  
    637636        void *newdata = realloc(nodep->data, nodep->size + delta);
    638637        if (!newdata) {
    639                 ipc_answer_0(callid, ENOMEM);
    640                 ipc_answer_2(rid, EOK, 0, nodep->size);
     638                async_answer_0(callid, ENOMEM);
     639                async_answer_2(rid, EOK, 0, nodep->size);
    641640                return;
    642641        }
    … …  
    646645        nodep->data = newdata;
    647646        (void) async_data_write_finalize(callid, nodep->data + pos, size);
    648         ipc_answer_2(rid, EOK, size, nodep->size);
     647        async_answer_2(rid, EOK, size, nodep->size);
    649648}
    650649
    … …  
    665664        link_t *hlp = hash_table_find(&nodes, key);
    666665        if (!hlp) {
    667                 ipc_answer_0(rid, ENOENT);
     666                async_answer_0(rid, ENOENT);
    668667                return;
    669668        }
    … …  
    672671       
    673672        if (size == nodep->size) {
    674                 ipc_answer_0(rid, EOK);
     673                async_answer_0(rid, EOK);
    675674                return;
    676675        }
    677676       
    678677        if (size > SIZE_MAX) {
    679                 ipc_answer_0(rid, ENOMEM);
     678                async_answer_0(rid, ENOMEM);
    680679                return;
    681680        }
    … …  
    683682        void *newdata = realloc(nodep->data, size);
    684683        if (!newdata) {
    685                 ipc_answer_0(rid, ENOMEM);
     684                async_answer_0(rid, ENOMEM);
    686685                return;
    687686        }
    … …  
    694693        nodep->size = size;
    695694        nodep->data = newdata;
    696         ipc_answer_0(rid, EOK);
     695        async_answer_0(rid, EOK);
    697696}
    698697
    699698void tmpfs_close(ipc_callid_t rid, ipc_call_t *request)
    700699{
    701         ipc_answer_0(rid, EOK);
     700        async_answer_0(rid, EOK);
    702701}
    703702
    … …  
    715714        hlp = hash_table_find(&nodes, key);
    716715        if (!hlp) {
    717                 ipc_answer_0(rid, ENOENT);
     716                async_answer_0(rid, ENOENT);
    718717                return;
    719718        }
    … …  
    721720            nh_link);
    722721        rc = tmpfs_destroy_node(FS_NODE(nodep));
    723         ipc_answer_0(rid, rc);
     722        async_answer_0(rid, rc);
    724723}
    725724
    … …  
    740739         * thus the sync operation is a no-op.
    741740         */
    742         ipc_answer_0(rid, EOK);
     741        async_answer_0(rid, EOK);
    743742}
    744743
Note: See TracChangeset for help on using the changeset viewer.