Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rc7bbf029 ra93d79a  
    4242#include <libfs.h>
    4343#include <libblock.h>
     44#include <ipc/ipc.h>
    4445#include <ipc/services.h>
    4546#include <ipc/devmap.h>
    … …  
    5556#include <sys/mman.h>
    5657#include <align.h>
    57 #include <malloc.h>
    5858
    5959#define FAT_NODE(node)  ((node) ? (fat_node_t *) (node)->data : NULL)
    … …  
    7272 * Forward declarations of FAT libfs operations.
    7373 */
    74 static int fat_root_get(fs_node_t **, devmap_handle_t);
     74static int fat_root_get(fs_node_t **, dev_handle_t);
    7575static int fat_match(fs_node_t **, fs_node_t *, const char *);
    76 static int fat_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
     76static int fat_node_get(fs_node_t **, dev_handle_t, fs_index_t);
    7777static int fat_node_open(fs_node_t *);
    7878static int fat_node_put(fs_node_t *);
    79 static int fat_create_node(fs_node_t **, devmap_handle_t, int);
     79static int fat_create_node(fs_node_t **, dev_handle_t, int);
    8080static int fat_destroy_node(fs_node_t *);
    8181static int fat_link(fs_node_t *, fs_node_t *, const char *);
    … …  
    8888static bool fat_is_directory(fs_node_t *);
    8989static bool fat_is_file(fs_node_t *node);
    90 static devmap_handle_t fat_device_get(fs_node_t *node);
     90static dev_handle_t fat_device_get(fs_node_t *node);
    9191
    9292/*
    … …  
    120120        assert(node->dirty);
    121121
    122         bs = block_bb_get(node->idx->devmap_handle);
     122        bs = block_bb_get(node->idx->dev_handle);
    123123       
    124124        /* Read the block that contains the dentry of interest. */
    125         rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
     125        rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
    126126            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    127127            BLOCK_FLAGS_NONE);
    … …  
    145145}
    146146
    147 static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
     147static int fat_node_fini_by_dev_handle(dev_handle_t dev_handle)
    148148{
    149149        link_t *lnk;
    … …  
    170170                        goto restart;
    171171                }
    172                 if (nodep->idx->devmap_handle != devmap_handle) {
     172                if (nodep->idx->dev_handle != dev_handle) {
    173173                        fibril_mutex_unlock(&nodep->idx->lock);
    174174                        fibril_mutex_unlock(&nodep->lock);
    … …  
    299299                return rc;
    300300
    301         bs = block_bb_get(idxp->devmap_handle);
     301        bs = block_bb_get(idxp->dev_handle);
    302302
    303303        /* Read the block that contains the dentry of interest. */
    304         rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
     304        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc, NULL,
    305305            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    306306        if (rc != EOK) {
    … …  
    323323                 */
    324324                uint16_t clusters;
    325                 rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
     325                rc = fat_clusters_get(&clusters, bs, idxp->dev_handle,
    326326                    uint16_t_le2host(d->firstc));
    327327                if (rc != EOK) {
    328                         (void) block_put(b);
    329328                        (void) fat_node_put(FS_NODE(nodep));
    330329                        return rc;
    … …  
    357356 */
    358357
    359 int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    360 {
    361         return fat_node_get(rfn, devmap_handle, 0);
     358int fat_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
     359{
     360        return fat_node_get(rfn, dev_handle, 0);
    362361}
    363362
    … …  
    370369        unsigned blocks;
    371370        fat_dentry_t *d;
    372         devmap_handle_t devmap_handle;
     371        dev_handle_t dev_handle;
    373372        block_t *b;
    374373        int rc;
    375374
    376375        fibril_mutex_lock(&parentp->idx->lock);
    377         devmap_handle = parentp->idx->devmap_handle;
     376        dev_handle = parentp->idx->dev_handle;
    378377        fibril_mutex_unlock(&parentp->idx->lock);
    379378
    380         bs = block_bb_get(devmap_handle);
     379        bs = block_bb_get(dev_handle);
    381380        blocks = parentp->size / BPS(bs);
    382381        for (i = 0; i < blocks; i++) {
    … …  
    403402                                /* hit */
    404403                                fat_node_t *nodep;
    405                                 fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
     404                                fat_idx_t *idx = fat_idx_get_by_pos(dev_handle,
    406405                                    parentp->firstc, i * DPS(bs) + j);
    407406                                if (!idx) {
    … …  
    436435
    437436/** Instantiate a FAT in-core node. */
    438 int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
     437int fat_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
    439438{
    440439        fat_node_t *nodep;
    … …  
    442441        int rc;
    443442
    444         idxp = fat_idx_get_by_index(devmap_handle, index);
     443        idxp = fat_idx_get_by_index(dev_handle, index);
    445444        if (!idxp) {
    446445                *rfn = NULL;
    … …  
    493492}
    494493
    495 int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
     494int fat_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int flags)
    496495{
    497496        fat_idx_t *idxp;
    … …  
    501500        int rc;
    502501
    503         bs = block_bb_get(devmap_handle);
     502        bs = block_bb_get(dev_handle);
    504503        if (flags & L_DIRECTORY) {
    505504                /* allocate a cluster */
    506                 rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
     505                rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
    507506                if (rc != EOK)
    508507                        return rc;
    509508                /* populate the new cluster with unused dentries */
    510                 rc = fat_zero_cluster(bs, devmap_handle, mcl);
     509                rc = fat_zero_cluster(bs, dev_handle, mcl);
    511510                if (rc != EOK) {
    512                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     511                        (void) fat_free_clusters(bs, dev_handle, mcl);
    513512                        return rc;
    514513                }
    … …  
    517516        rc = fat_node_get_new(&nodep);
    518517        if (rc != EOK) {
    519                 (void) fat_free_clusters(bs, devmap_handle, mcl);
     518                (void) fat_free_clusters(bs, dev_handle, mcl);
    520519                return rc;
    521520        }
    522         rc = fat_idx_get_new(&idxp, devmap_handle);
    523         if (rc != EOK) {
    524                 (void) fat_free_clusters(bs, devmap_handle, mcl);       
     521        rc = fat_idx_get_new(&idxp, dev_handle);
     522        if (rc != EOK) {
     523                (void) fat_free_clusters(bs, dev_handle, mcl); 
    525524                (void) fat_node_put(FS_NODE(nodep));
    526525                return rc;
    … …  
    571570        assert(!has_children);
    572571
    573         bs = block_bb_get(nodep->idx->devmap_handle);
     572        bs = block_bb_get(nodep->idx->dev_handle);
    574573        if (nodep->firstc != FAT_CLST_RES0) {
    575574                assert(nodep->size);
    576575                /* Free all clusters allocated to the node. */
    577                 rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
     576                rc = fat_free_clusters(bs, nodep->idx->dev_handle,
    578577                    nodep->firstc);
    579578        }
    … …  
    621620       
    622621        fibril_mutex_lock(&parentp->idx->lock);
    623         bs = block_bb_get(parentp->idx->devmap_handle);
     622        bs = block_bb_get(parentp->idx->dev_handle);
    624623
    625624        blocks = parentp->size / BPS(bs);
    … …  
    660659                return ENOSPC;
    661660        }
    662         rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
     661        rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
    663662        if (rc != EOK) {
    664663                fibril_mutex_unlock(&parentp->idx->lock);
    665664                return rc;
    666665        }
    667         rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
    668         if (rc != EOK) {
    669                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     666        rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
     667        if (rc != EOK) {
     668                (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
    670669                fibril_mutex_unlock(&parentp->idx->lock);
    671670                return rc;
    … …  
    673672        rc = fat_append_clusters(bs, parentp, mcl, lcl);
    674673        if (rc != EOK) {
    675                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     674                (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
    676675                fibril_mutex_unlock(&parentp->idx->lock);
    677676                return rc;
    … …  
    723722                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
    724723                        memset(d, 0, sizeof(fat_dentry_t));
    725                         memcpy(d->name, FAT_NAME_DOT, FAT_NAME_LEN);
    726                         memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
     724                        str_cpy((char *) d->name, 8, FAT_NAME_DOT);
     725                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
    727726                        d->attr = FAT_ATTR_SUBDIR;
    728727                        d->firstc = host2uint16_t_le(childp->firstc);
    … …  
    733732                    (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
    734733                        memset(d, 0, sizeof(fat_dentry_t));
    735                         memcpy(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN);
    736                         memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
     734                        str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
     735                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
    737736                        d->attr = FAT_ATTR_SUBDIR;
    738737                        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
    … …  
    790789        assert(childp->lnkcnt == 1);
    791790        fibril_mutex_lock(&childp->idx->lock);
    792         bs = block_bb_get(childp->idx->devmap_handle);
    793 
    794         rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
     791        bs = block_bb_get(childp->idx->dev_handle);
     792
     793        rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
    795794            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    796795            BLOCK_FLAGS_NONE);
    … …  
    813812        fibril_mutex_unlock(&childp->idx->lock);
    814813        childp->lnkcnt = 0;
    815         childp->refcnt++;       /* keep the node in memory until destroyed */
    816814        childp->dirty = true;
    817815        fibril_mutex_unlock(&childp->lock);
    … …  
    842840       
    843841        fibril_mutex_lock(&nodep->idx->lock);
    844         bs = block_bb_get(nodep->idx->devmap_handle);
     842        bs = block_bb_get(nodep->idx->dev_handle);
    845843
    846844        blocks = nodep->size / BPS(bs);
    … …  
    916914}
    917915
    918 devmap_handle_t fat_device_get(fs_node_t *node)
     916dev_handle_t fat_device_get(fs_node_t *node)
    919917{
    920918        return 0;
    … …  
    948946void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    949947{
    950         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     948        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    951949        enum cache_mode cmode;
    952950        fat_bs_t *bs;
    … …  
    957955       
    958956        if (rc != EOK) {
    959                 async_answer_0(rid, rc);
     957                ipc_answer_0(rid, rc);
    960958                return;
    961959        }
    … …  
    970968
    971969        /* initialize libblock */
    972         rc = block_init(devmap_handle, BS_SIZE);
    973         if (rc != EOK) {
    974                 async_answer_0(rid, rc);
     970        rc = block_init(dev_handle, BS_SIZE);
     971        if (rc != EOK) {
     972                ipc_answer_0(rid, rc);
    975973                return;
    976974        }
    977975
    978976        /* prepare the boot block */
    979         rc = block_bb_read(devmap_handle, BS_BLOCK);
    980         if (rc != EOK) {
    981                 block_fini(devmap_handle);
    982                 async_answer_0(rid, rc);
     977        rc = block_bb_read(dev_handle, BS_BLOCK);
     978        if (rc != EOK) {
     979                block_fini(dev_handle);
     980                ipc_answer_0(rid, rc);
    983981                return;
    984982        }
    985983
    986984        /* get the buffer with the boot sector */
    987         bs = block_bb_get(devmap_handle);
     985        bs = block_bb_get(dev_handle);
    988986       
    989987        if (BPS(bs) != BS_SIZE) {
    990                 block_fini(devmap_handle);
    991                 async_answer_0(rid, ENOTSUP);
     988                block_fini(dev_handle);
     989                ipc_answer_0(rid, ENOTSUP);
    992990                return;
    993991        }
    994992
    995993        /* Initialize the block cache */
    996         rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
    997         if (rc != EOK) {
    998                 block_fini(devmap_handle);
    999                 async_answer_0(rid, rc);
     994        rc = block_cache_init(dev_handle, BPS(bs), 0 /* XXX */, cmode);
     995        if (rc != EOK) {
     996                block_fini(dev_handle);
     997                ipc_answer_0(rid, rc);
    1000998                return;
    1001999        }
    10021000
    10031001        /* Do some simple sanity checks on the file system. */
    1004         rc = fat_sanity_check(bs, devmap_handle);
    1005         if (rc != EOK) {
    1006                 (void) block_cache_fini(devmap_handle);
    1007                 block_fini(devmap_handle);
    1008                 async_answer_0(rid, rc);
    1009                 return;
    1010         }
    1011 
    1012         rc = fat_idx_init_by_devmap_handle(devmap_handle);
    1013         if (rc != EOK) {
    1014                 (void) block_cache_fini(devmap_handle);
    1015                 block_fini(devmap_handle);
    1016                 async_answer_0(rid, rc);
     1002        rc = fat_sanity_check(bs, dev_handle);
     1003        if (rc != EOK) {
     1004                (void) block_cache_fini(dev_handle);
     1005                block_fini(dev_handle);
     1006                ipc_answer_0(rid, rc);
     1007                return;
     1008        }
     1009
     1010        rc = fat_idx_init_by_dev_handle(dev_handle);
     1011        if (rc != EOK) {
     1012                (void) block_cache_fini(dev_handle);
     1013                block_fini(dev_handle);
     1014                ipc_answer_0(rid, rc);
    10171015                return;
    10181016        }
    … …  
    10211019        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    10221020        if (!rfn) {
    1023                 (void) block_cache_fini(devmap_handle);
    1024                 block_fini(devmap_handle);
    1025                 fat_idx_fini_by_devmap_handle(devmap_handle);
    1026                 async_answer_0(rid, ENOMEM);
     1021                (void) block_cache_fini(dev_handle);
     1022                block_fini(dev_handle);
     1023                fat_idx_fini_by_dev_handle(dev_handle);
     1024                ipc_answer_0(rid, ENOMEM);
    10271025                return;
    10281026        }
    … …  
    10311029        if (!rootp) {
    10321030                free(rfn);
    1033                 (void) block_cache_fini(devmap_handle);
    1034                 block_fini(devmap_handle);
    1035                 fat_idx_fini_by_devmap_handle(devmap_handle);
    1036                 async_answer_0(rid, ENOMEM);
     1031                (void) block_cache_fini(dev_handle);
     1032                block_fini(dev_handle);
     1033                fat_idx_fini_by_dev_handle(dev_handle);
     1034                ipc_answer_0(rid, ENOMEM);
    10371035                return;
    10381036        }
    10391037        fat_node_initialize(rootp);
    10401038
    1041         fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
     1039        fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
    10421040        if (!ridxp) {
    10431041                free(rfn);
    10441042                free(rootp);
    1045                 (void) block_cache_fini(devmap_handle);
    1046                 block_fini(devmap_handle);
    1047                 fat_idx_fini_by_devmap_handle(devmap_handle);
    1048                 async_answer_0(rid, ENOMEM);
     1043                (void) block_cache_fini(dev_handle);
     1044                block_fini(dev_handle);
     1045                fat_idx_fini_by_dev_handle(dev_handle);
     1046                ipc_answer_0(rid, ENOMEM);
    10491047                return;
    10501048        }
    … …  
    10641062        fibril_mutex_unlock(&ridxp->lock);
    10651063
    1066         async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
     1064        ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    10671065}
    10681066
    … …  
    10741072void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    10751073{
    1076         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1074        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    10771075        fs_node_t *fn;
    10781076        fat_node_t *nodep;
    10791077        int rc;
    10801078
    1081         rc = fat_root_get(&fn, devmap_handle);
    1082         if (rc != EOK) {
    1083                 async_answer_0(rid, rc);
     1079        rc = fat_root_get(&fn, dev_handle);
     1080        if (rc != EOK) {
     1081                ipc_answer_0(rid, rc);
    10841082                return;
    10851083        }
    … …  
    10921090        if (nodep->refcnt != 2) {
    10931091                (void) fat_node_put(fn);
    1094                 async_answer_0(rid, EBUSY);
     1092                ipc_answer_0(rid, EBUSY);
    10951093                return;
    10961094        }
    … …  
    11071105         * stop using libblock for this instance.
    11081106         */
    1109         (void) fat_node_fini_by_devmap_handle(devmap_handle);
    1110         fat_idx_fini_by_devmap_handle(devmap_handle);
    1111         (void) block_cache_fini(devmap_handle);
    1112         block_fini(devmap_handle);
    1113 
    1114         async_answer_0(rid, EOK);
     1107        (void) fat_node_fini_by_dev_handle(dev_handle);
     1108        fat_idx_fini_by_dev_handle(dev_handle);
     1109        (void) block_cache_fini(dev_handle);
     1110        block_fini(dev_handle);
     1111
     1112        ipc_answer_0(rid, EOK);
    11151113}
    11161114
    … …  
    11271125void fat_read(ipc_callid_t rid, ipc_call_t *request)
    11281126{
    1129         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1127        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    11301128        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    11311129        aoff64_t pos =
    … …  
    11381136        int rc;
    11391137
    1140         rc = fat_node_get(&fn, devmap_handle, index);
    1141         if (rc != EOK) {
    1142                 async_answer_0(rid, rc);
     1138        rc = fat_node_get(&fn, dev_handle, index);
     1139        if (rc != EOK) {
     1140                ipc_answer_0(rid, rc);
    11431141                return;
    11441142        }
    11451143        if (!fn) {
    1146                 async_answer_0(rid, ENOENT);
     1144                ipc_answer_0(rid, ENOENT);
    11471145                return;
    11481146        }
    … …  
    11531151        if (!async_data_read_receive(&callid, &len)) {
    11541152                fat_node_put(fn);
    1155                 async_answer_0(callid, EINVAL);
    1156                 async_answer_0(rid, EINVAL);
    1157                 return;
    1158         }
    1159 
    1160         bs = block_bb_get(devmap_handle);
     1153                ipc_answer_0(callid, EINVAL);
     1154                ipc_answer_0(rid, EINVAL);
     1155                return;
     1156        }
     1157
     1158        bs = block_bb_get(dev_handle);
    11611159
    11621160        if (nodep->type == FAT_FILE) {
    … …  
    11771175                        if (rc != EOK) {
    11781176                                fat_node_put(fn);
    1179                                 async_answer_0(callid, rc);
    1180                                 async_answer_0(rid, rc);
     1177                                ipc_answer_0(callid, rc);
     1178                                ipc_answer_0(rid, rc);
    11811179                                return;
    11821180                        }
    … …  
    11861184                        if (rc != EOK) {
    11871185                                fat_node_put(fn);
    1188                                 async_answer_0(rid, rc);
     1186                                ipc_answer_0(rid, rc);
    11891187                                return;
    11901188                        }
    … …  
    12431241miss:
    12441242                rc = fat_node_put(fn);
    1245                 async_answer_0(callid, rc != EOK ? rc : ENOENT);
    1246                 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
     1243                ipc_answer_0(callid, rc != EOK ? rc : ENOENT);
     1244                ipc_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    12471245                return;
    12481246
    12491247err:
    12501248                (void) fat_node_put(fn);
    1251                 async_answer_0(callid, rc);
    1252                 async_answer_0(rid, rc);
     1249                ipc_answer_0(callid, rc);
     1250                ipc_answer_0(rid, rc);
    12531251                return;
    12541252
    … …  
    12591257
    12601258        rc = fat_node_put(fn);
    1261         async_answer_1(rid, rc, (sysarg_t)bytes);
     1259        ipc_answer_1(rid, rc, (ipcarg_t)bytes);
    12621260}
    12631261
    12641262void fat_write(ipc_callid_t rid, ipc_call_t *request)
    12651263{
    1266         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1264        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    12671265        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    12681266        aoff64_t pos =
    … …  
    12771275        int rc;
    12781276       
    1279         rc = fat_node_get(&fn, devmap_handle, index);
    1280         if (rc != EOK) {
    1281                 async_answer_0(rid, rc);
     1277        rc = fat_node_get(&fn, dev_handle, index);
     1278        if (rc != EOK) {
     1279                ipc_answer_0(rid, rc);
    12821280                return;
    12831281        }
    12841282        if (!fn) {
    1285                 async_answer_0(rid, ENOENT);
     1283                ipc_answer_0(rid, ENOENT);
    12861284                return;
    12871285        }
    … …  
    12921290        if (!async_data_write_receive(&callid, &len)) {
    12931291                (void) fat_node_put(fn);
    1294                 async_answer_0(callid, EINVAL);
    1295                 async_answer_0(rid, EINVAL);
    1296                 return;
    1297         }
    1298 
    1299         bs = block_bb_get(devmap_handle);
     1292                ipc_answer_0(callid, EINVAL);
     1293                ipc_answer_0(rid, EINVAL);
     1294                return;
     1295        }
     1296
     1297        bs = block_bb_get(dev_handle);
    13001298
    13011299        /*
    … …  
    13211319                if (rc != EOK) {
    13221320                        (void) fat_node_put(fn);
    1323                         async_answer_0(callid, rc);
    1324                         async_answer_0(rid, rc);
     1321                        ipc_answer_0(callid, rc);
     1322                        ipc_answer_0(rid, rc);
    13251323                        return;
    13261324                }
    … …  
    13281326                if (rc != EOK) {
    13291327                        (void) fat_node_put(fn);
    1330                         async_answer_0(callid, rc);
    1331                         async_answer_0(rid, rc);
     1328                        ipc_answer_0(callid, rc);
     1329                        ipc_answer_0(rid, rc);
    13321330                        return;
    13331331                }
    … …  
    13381336                if (rc != EOK) {
    13391337                        (void) fat_node_put(fn);
    1340                         async_answer_0(rid, rc);
     1338                        ipc_answer_0(rid, rc);
    13411339                        return;
    13421340                }
    … …  
    13471345                size = nodep->size;
    13481346                rc = fat_node_put(fn);
    1349                 async_answer_2(rid, rc, bytes, nodep->size);
     1347                ipc_answer_2(rid, rc, bytes, nodep->size);
    13501348                return;
    13511349        } else {
    … …  
    13591357                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13601358                /* create an independent chain of nclsts clusters in all FATs */
    1361                 rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
     1359                rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
    13621360                if (rc != EOK) {
    13631361                        /* could not allocate a chain of nclsts clusters */
    13641362                        (void) fat_node_put(fn);
    1365                         async_answer_0(callid, rc);
    1366                         async_answer_0(rid, rc);
     1363                        ipc_answer_0(callid, rc);
     1364                        ipc_answer_0(rid, rc);
    13671365                        return;
    13681366                }
    … …  
    13701368                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13711369                if (rc != EOK) {
    1372                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1370                        (void) fat_free_clusters(bs, dev_handle, mcl);
    13731371                        (void) fat_node_put(fn);
    1374                         async_answer_0(callid, rc);
    1375                         async_answer_0(rid, rc);
     1372                        ipc_answer_0(callid, rc);
     1373                        ipc_answer_0(rid, rc);
    13761374                        return;
    13771375                }
    1378                 rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
     1376                rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL,
    13791377                    (pos / BPS(bs)) % SPC(bs), flags);
    13801378                if (rc != EOK) {
    1381                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1379                        (void) fat_free_clusters(bs, dev_handle, mcl);
    13821380                        (void) fat_node_put(fn);
    1383                         async_answer_0(callid, rc);
    1384                         async_answer_0(rid, rc);
     1381                        ipc_answer_0(callid, rc);
     1382                        ipc_answer_0(rid, rc);
    13851383                        return;
    13861384                }
    … …  
    13901388                rc = block_put(b);
    13911389                if (rc != EOK) {
    1392                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1390                        (void) fat_free_clusters(bs, dev_handle, mcl);
    13931391                        (void) fat_node_put(fn);
    1394                         async_answer_0(rid, rc);
     1392                        ipc_answer_0(rid, rc);
    13951393                        return;
    13961394                }
    … …  
    14011399                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    14021400                if (rc != EOK) {
    1403                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1401                        (void) fat_free_clusters(bs, dev_handle, mcl);
    14041402                        (void) fat_node_put(fn);
    1405                         async_answer_0(rid, rc);
     1403                        ipc_answer_0(rid, rc);
    14061404                        return;
    14071405                }
    … …  
    14091407                nodep->dirty = true;            /* need to sync node */
    14101408                rc = fat_node_put(fn);
    1411                 async_answer_2(rid, rc, bytes, size);
     1409                ipc_answer_2(rid, rc, bytes, size);
    14121410                return;
    14131411        }
    … …  
    14161414void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    14171415{
    1418         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1416        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    14191417        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    14201418        aoff64_t size =
    … …  
    14251423        int rc;
    14261424
    1427         rc = fat_node_get(&fn, devmap_handle, index);
    1428         if (rc != EOK) {
    1429                 async_answer_0(rid, rc);
     1425        rc = fat_node_get(&fn, dev_handle, index);
     1426        if (rc != EOK) {
     1427                ipc_answer_0(rid, rc);
    14301428                return;
    14311429        }
    14321430        if (!fn) {
    1433                 async_answer_0(rid, ENOENT);
     1431                ipc_answer_0(rid, ENOENT);
    14341432                return;
    14351433        }
    14361434        nodep = FAT_NODE(fn);
    14371435
    1438         bs = block_bb_get(devmap_handle);
     1436        bs = block_bb_get(dev_handle);
    14391437
    14401438        if (nodep->size == size) {
    … …  
    14631461                } else {
    14641462                        fat_cluster_t lastc;
    1465                         rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
     1463                        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
    14661464                            &lastc, NULL, (size - 1) / BPC(bs));
    14671465                        if (rc != EOK)
    … …  
    14771475out:
    14781476        fat_node_put(fn);
    1479         async_answer_0(rid, rc);
     1477        ipc_answer_0(rid, rc);
    14801478        return;
    14811479}
    … …  
    14831481void fat_close(ipc_callid_t rid, ipc_call_t *request)
    14841482{
    1485         async_answer_0(rid, EOK);
     1483        ipc_answer_0(rid, EOK);
    14861484}
    14871485
    14881486void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    14891487{
    1490         devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
     1488        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    14911489        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    14921490        fs_node_t *fn;
    1493         fat_node_t *nodep;
    14941491        int rc;
    14951492
    1496         rc = fat_node_get(&fn, devmap_handle, index);
    1497         if (rc != EOK) {
    1498                 async_answer_0(rid, rc);
     1493        rc = fat_node_get(&fn, dev_handle, index);
     1494        if (rc != EOK) {
     1495                ipc_answer_0(rid, rc);
    14991496                return;
    15001497        }
    15011498        if (!fn) {
    1502                 async_answer_0(rid, ENOENT);
    1503                 return;
    1504         }
    1505 
    1506         nodep = FAT_NODE(fn);
    1507         /*
    1508          * We should have exactly two references. One for the above
    1509          * call to fat_node_get() and one from fat_unlink().
    1510          */
    1511         assert(nodep->refcnt == 2);
     1499                ipc_answer_0(rid, ENOENT);
     1500                return;
     1501        }
    15121502
    15131503        rc = fat_destroy_node(fn);
    1514         async_answer_0(rid, rc);
     1504        ipc_answer_0(rid, rc);
    15151505}
    15161506
    … …  
    15271517void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    15281518{
    1529         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1519        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    15301520        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    15311521       
    15321522        fs_node_t *fn;
    1533         int rc = fat_node_get(&fn, devmap_handle, index);
    1534         if (rc != EOK) {
    1535                 async_answer_0(rid, rc);
     1523        int rc = fat_node_get(&fn, dev_handle, index);
     1524        if (rc != EOK) {
     1525                ipc_answer_0(rid, rc);
    15361526                return;
    15371527        }
    15381528        if (!fn) {
    1539                 async_answer_0(rid, ENOENT);
     1529                ipc_answer_0(rid, ENOENT);
    15401530                return;
    15411531        }
    … …  
    15471537       
    15481538        fat_node_put(fn);
    1549         async_answer_0(rid, rc);
     1539        ipc_answer_0(rid, rc);
    15501540}
    15511541
Note: See TracChangeset for help on using the changeset viewer.