Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    ra93d79a rc7bbf029  
    4242#include <libfs.h>
    4343#include <libblock.h>
    44 #include <ipc/ipc.h>
    4544#include <ipc/services.h>
    4645#include <ipc/devmap.h>
    … …  
    5655#include <sys/mman.h>
    5756#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 **, dev_handle_t);
     74static int fat_root_get(fs_node_t **, devmap_handle_t);
    7575static int fat_match(fs_node_t **, fs_node_t *, const char *);
    76 static int fat_node_get(fs_node_t **, dev_handle_t, fs_index_t);
     76static int fat_node_get(fs_node_t **, devmap_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 **, dev_handle_t, int);
     79static int fat_create_node(fs_node_t **, devmap_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 dev_handle_t fat_device_get(fs_node_t *node);
     90static devmap_handle_t fat_device_get(fs_node_t *node);
    9191
    9292/*
    … …  
    120120        assert(node->dirty);
    121121
    122         bs = block_bb_get(node->idx->dev_handle);
     122        bs = block_bb_get(node->idx->devmap_handle);
    123123       
    124124        /* Read the block that contains the dentry of interest. */
    125         rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
     125        rc = _fat_block_get(&b, bs, node->idx->devmap_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_dev_handle(dev_handle_t dev_handle)
     147static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
    148148{
    149149        link_t *lnk;
    … …  
    170170                        goto restart;
    171171                }
    172                 if (nodep->idx->dev_handle != dev_handle) {
     172                if (nodep->idx->devmap_handle != devmap_handle) {
    173173                        fibril_mutex_unlock(&nodep->idx->lock);
    174174                        fibril_mutex_unlock(&nodep->lock);
    … …  
    299299                return rc;
    300300
    301         bs = block_bb_get(idxp->dev_handle);
     301        bs = block_bb_get(idxp->devmap_handle);
    302302
    303303        /* Read the block that contains the dentry of interest. */
    304         rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc, NULL,
     304        rc = _fat_block_get(&b, bs, idxp->devmap_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->dev_handle,
     325                rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
    326326                    uint16_t_le2host(d->firstc));
    327327                if (rc != EOK) {
     328                        (void) block_put(b);
    328329                        (void) fat_node_put(FS_NODE(nodep));
    329330                        return rc;
    … …  
    356357 */
    357358
    358 int fat_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
    359 {
    360         return fat_node_get(rfn, dev_handle, 0);
     359int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
     360{
     361        return fat_node_get(rfn, devmap_handle, 0);
    361362}
    362363
    … …  
    369370        unsigned blocks;
    370371        fat_dentry_t *d;
    371         dev_handle_t dev_handle;
     372        devmap_handle_t devmap_handle;
    372373        block_t *b;
    373374        int rc;
    374375
    375376        fibril_mutex_lock(&parentp->idx->lock);
    376         dev_handle = parentp->idx->dev_handle;
     377        devmap_handle = parentp->idx->devmap_handle;
    377378        fibril_mutex_unlock(&parentp->idx->lock);
    378379
    379         bs = block_bb_get(dev_handle);
     380        bs = block_bb_get(devmap_handle);
    380381        blocks = parentp->size / BPS(bs);
    381382        for (i = 0; i < blocks; i++) {
    … …  
    402403                                /* hit */
    403404                                fat_node_t *nodep;
    404                                 fat_idx_t *idx = fat_idx_get_by_pos(dev_handle,
     405                                fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
    405406                                    parentp->firstc, i * DPS(bs) + j);
    406407                                if (!idx) {
    … …  
    435436
    436437/** Instantiate a FAT in-core node. */
    437 int fat_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
     438int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
    438439{
    439440        fat_node_t *nodep;
    … …  
    441442        int rc;
    442443
    443         idxp = fat_idx_get_by_index(dev_handle, index);
     444        idxp = fat_idx_get_by_index(devmap_handle, index);
    444445        if (!idxp) {
    445446                *rfn = NULL;
    … …  
    492493}
    493494
    494 int fat_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int flags)
     495int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
    495496{
    496497        fat_idx_t *idxp;
    … …  
    500501        int rc;
    501502
    502         bs = block_bb_get(dev_handle);
     503        bs = block_bb_get(devmap_handle);
    503504        if (flags & L_DIRECTORY) {
    504505                /* allocate a cluster */
    505                 rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
     506                rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
    506507                if (rc != EOK)
    507508                        return rc;
    508509                /* populate the new cluster with unused dentries */
    509                 rc = fat_zero_cluster(bs, dev_handle, mcl);
     510                rc = fat_zero_cluster(bs, devmap_handle, mcl);
    510511                if (rc != EOK) {
    511                         (void) fat_free_clusters(bs, dev_handle, mcl);
     512                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    512513                        return rc;
    513514                }
    … …  
    516517        rc = fat_node_get_new(&nodep);
    517518        if (rc != EOK) {
    518                 (void) fat_free_clusters(bs, dev_handle, mcl);
     519                (void) fat_free_clusters(bs, devmap_handle, mcl);
    519520                return rc;
    520521        }
    521         rc = fat_idx_get_new(&idxp, dev_handle);
    522         if (rc != EOK) {
    523                 (void) fat_free_clusters(bs, dev_handle, mcl); 
     522        rc = fat_idx_get_new(&idxp, devmap_handle);
     523        if (rc != EOK) {
     524                (void) fat_free_clusters(bs, devmap_handle, mcl);       
    524525                (void) fat_node_put(FS_NODE(nodep));
    525526                return rc;
    … …  
    570571        assert(!has_children);
    571572
    572         bs = block_bb_get(nodep->idx->dev_handle);
     573        bs = block_bb_get(nodep->idx->devmap_handle);
    573574        if (nodep->firstc != FAT_CLST_RES0) {
    574575                assert(nodep->size);
    575576                /* Free all clusters allocated to the node. */
    576                 rc = fat_free_clusters(bs, nodep->idx->dev_handle,
     577                rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
    577578                    nodep->firstc);
    578579        }
    … …  
    620621       
    621622        fibril_mutex_lock(&parentp->idx->lock);
    622         bs = block_bb_get(parentp->idx->dev_handle);
     623        bs = block_bb_get(parentp->idx->devmap_handle);
    623624
    624625        blocks = parentp->size / BPS(bs);
    … …  
    659660                return ENOSPC;
    660661        }
    661         rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
     662        rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
    662663        if (rc != EOK) {
    663664                fibril_mutex_unlock(&parentp->idx->lock);
    664665                return rc;
    665666        }
    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);
     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);
    669670                fibril_mutex_unlock(&parentp->idx->lock);
    670671                return rc;
    … …  
    672673        rc = fat_append_clusters(bs, parentp, mcl, lcl);
    673674        if (rc != EOK) {
    674                 (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
     675                (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
    675676                fibril_mutex_unlock(&parentp->idx->lock);
    676677                return rc;
    … …  
    722723                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
    723724                        memset(d, 0, sizeof(fat_dentry_t));
    724                         str_cpy((char *) d->name, 8, FAT_NAME_DOT);
    725                         str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
     725                        memcpy(d->name, FAT_NAME_DOT, FAT_NAME_LEN);
     726                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
    726727                        d->attr = FAT_ATTR_SUBDIR;
    727728                        d->firstc = host2uint16_t_le(childp->firstc);
    … …  
    732733                    (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
    733734                        memset(d, 0, sizeof(fat_dentry_t));
    734                         str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
    735                         str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
     735                        memcpy(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN);
     736                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
    736737                        d->attr = FAT_ATTR_SUBDIR;
    737738                        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
    … …  
    789790        assert(childp->lnkcnt == 1);
    790791        fibril_mutex_lock(&childp->idx->lock);
    791         bs = block_bb_get(childp->idx->dev_handle);
    792 
    793         rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
     792        bs = block_bb_get(childp->idx->devmap_handle);
     793
     794        rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
    794795            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    795796            BLOCK_FLAGS_NONE);
    … …  
    812813        fibril_mutex_unlock(&childp->idx->lock);
    813814        childp->lnkcnt = 0;
     815        childp->refcnt++;       /* keep the node in memory until destroyed */
    814816        childp->dirty = true;
    815817        fibril_mutex_unlock(&childp->lock);
    … …  
    840842       
    841843        fibril_mutex_lock(&nodep->idx->lock);
    842         bs = block_bb_get(nodep->idx->dev_handle);
     844        bs = block_bb_get(nodep->idx->devmap_handle);
    843845
    844846        blocks = nodep->size / BPS(bs);
    … …  
    914916}
    915917
    916 dev_handle_t fat_device_get(fs_node_t *node)
     918devmap_handle_t fat_device_get(fs_node_t *node)
    917919{
    918920        return 0;
    … …  
    946948void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    947949{
    948         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     950        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    949951        enum cache_mode cmode;
    950952        fat_bs_t *bs;
    … …  
    955957       
    956958        if (rc != EOK) {
    957                 ipc_answer_0(rid, rc);
     959                async_answer_0(rid, rc);
    958960                return;
    959961        }
    … …  
    968970
    969971        /* initialize libblock */
    970         rc = block_init(dev_handle, BS_SIZE);
    971         if (rc != EOK) {
    972                 ipc_answer_0(rid, rc);
     972        rc = block_init(devmap_handle, BS_SIZE);
     973        if (rc != EOK) {
     974                async_answer_0(rid, rc);
    973975                return;
    974976        }
    975977
    976978        /* prepare the boot block */
    977         rc = block_bb_read(dev_handle, BS_BLOCK);
    978         if (rc != EOK) {
    979                 block_fini(dev_handle);
    980                 ipc_answer_0(rid, rc);
     979        rc = block_bb_read(devmap_handle, BS_BLOCK);
     980        if (rc != EOK) {
     981                block_fini(devmap_handle);
     982                async_answer_0(rid, rc);
    981983                return;
    982984        }
    983985
    984986        /* get the buffer with the boot sector */
    985         bs = block_bb_get(dev_handle);
     987        bs = block_bb_get(devmap_handle);
    986988       
    987989        if (BPS(bs) != BS_SIZE) {
    988                 block_fini(dev_handle);
    989                 ipc_answer_0(rid, ENOTSUP);
     990                block_fini(devmap_handle);
     991                async_answer_0(rid, ENOTSUP);
    990992                return;
    991993        }
    992994
    993995        /* Initialize the block cache */
    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);
     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);
    9981000                return;
    9991001        }
    10001002
    10011003        /* Do some simple sanity checks on the file system. */
    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);
     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);
    10151017                return;
    10161018        }
    … …  
    10191021        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    10201022        if (!rfn) {
    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);
     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);
    10251027                return;
    10261028        }
    … …  
    10291031        if (!rootp) {
    10301032                free(rfn);
    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);
     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);
    10351037                return;
    10361038        }
    10371039        fat_node_initialize(rootp);
    10381040
    1039         fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
     1041        fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
    10401042        if (!ridxp) {
    10411043                free(rfn);
    10421044                free(rootp);
    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);
     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);
    10471049                return;
    10481050        }
    … …  
    10621064        fibril_mutex_unlock(&ridxp->lock);
    10631065
    1064         ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
     1066        async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    10651067}
    10661068
    … …  
    10721074void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    10731075{
    1074         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1076        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    10751077        fs_node_t *fn;
    10761078        fat_node_t *nodep;
    10771079        int rc;
    10781080
    1079         rc = fat_root_get(&fn, dev_handle);
    1080         if (rc != EOK) {
    1081                 ipc_answer_0(rid, rc);
     1081        rc = fat_root_get(&fn, devmap_handle);
     1082        if (rc != EOK) {
     1083                async_answer_0(rid, rc);
    10821084                return;
    10831085        }
    … …  
    10901092        if (nodep->refcnt != 2) {
    10911093                (void) fat_node_put(fn);
    1092                 ipc_answer_0(rid, EBUSY);
     1094                async_answer_0(rid, EBUSY);
    10931095                return;
    10941096        }
    … …  
    11051107         * stop using libblock for this instance.
    11061108         */
    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);
     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);
    11131115}
    11141116
    … …  
    11251127void fat_read(ipc_callid_t rid, ipc_call_t *request)
    11261128{
    1127         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1129        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    11281130        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    11291131        aoff64_t pos =
    … …  
    11361138        int rc;
    11371139
    1138         rc = fat_node_get(&fn, dev_handle, index);
    1139         if (rc != EOK) {
    1140                 ipc_answer_0(rid, rc);
     1140        rc = fat_node_get(&fn, devmap_handle, index);
     1141        if (rc != EOK) {
     1142                async_answer_0(rid, rc);
    11411143                return;
    11421144        }
    11431145        if (!fn) {
    1144                 ipc_answer_0(rid, ENOENT);
     1146                async_answer_0(rid, ENOENT);
    11451147                return;
    11461148        }
    … …  
    11511153        if (!async_data_read_receive(&callid, &len)) {
    11521154                fat_node_put(fn);
    1153                 ipc_answer_0(callid, EINVAL);
    1154                 ipc_answer_0(rid, EINVAL);
    1155                 return;
    1156         }
    1157 
    1158         bs = block_bb_get(dev_handle);
     1155                async_answer_0(callid, EINVAL);
     1156                async_answer_0(rid, EINVAL);
     1157                return;
     1158        }
     1159
     1160        bs = block_bb_get(devmap_handle);
    11591161
    11601162        if (nodep->type == FAT_FILE) {
    … …  
    11751177                        if (rc != EOK) {
    11761178                                fat_node_put(fn);
    1177                                 ipc_answer_0(callid, rc);
    1178                                 ipc_answer_0(rid, rc);
     1179                                async_answer_0(callid, rc);
     1180                                async_answer_0(rid, rc);
    11791181                                return;
    11801182                        }
    … …  
    11841186                        if (rc != EOK) {
    11851187                                fat_node_put(fn);
    1186                                 ipc_answer_0(rid, rc);
     1188                                async_answer_0(rid, rc);
    11871189                                return;
    11881190                        }
    … …  
    12411243miss:
    12421244                rc = fat_node_put(fn);
    1243                 ipc_answer_0(callid, rc != EOK ? rc : ENOENT);
    1244                 ipc_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
     1245                async_answer_0(callid, rc != EOK ? rc : ENOENT);
     1246                async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    12451247                return;
    12461248
    12471249err:
    12481250                (void) fat_node_put(fn);
    1249                 ipc_answer_0(callid, rc);
    1250                 ipc_answer_0(rid, rc);
     1251                async_answer_0(callid, rc);
     1252                async_answer_0(rid, rc);
    12511253                return;
    12521254
    … …  
    12571259
    12581260        rc = fat_node_put(fn);
    1259         ipc_answer_1(rid, rc, (ipcarg_t)bytes);
     1261        async_answer_1(rid, rc, (sysarg_t)bytes);
    12601262}
    12611263
    12621264void fat_write(ipc_callid_t rid, ipc_call_t *request)
    12631265{
    1264         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1266        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    12651267        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    12661268        aoff64_t pos =
    … …  
    12751277        int rc;
    12761278       
    1277         rc = fat_node_get(&fn, dev_handle, index);
    1278         if (rc != EOK) {
    1279                 ipc_answer_0(rid, rc);
     1279        rc = fat_node_get(&fn, devmap_handle, index);
     1280        if (rc != EOK) {
     1281                async_answer_0(rid, rc);
    12801282                return;
    12811283        }
    12821284        if (!fn) {
    1283                 ipc_answer_0(rid, ENOENT);
     1285                async_answer_0(rid, ENOENT);
    12841286                return;
    12851287        }
    … …  
    12901292        if (!async_data_write_receive(&callid, &len)) {
    12911293                (void) fat_node_put(fn);
    1292                 ipc_answer_0(callid, EINVAL);
    1293                 ipc_answer_0(rid, EINVAL);
    1294                 return;
    1295         }
    1296 
    1297         bs = block_bb_get(dev_handle);
     1294                async_answer_0(callid, EINVAL);
     1295                async_answer_0(rid, EINVAL);
     1296                return;
     1297        }
     1298
     1299        bs = block_bb_get(devmap_handle);
    12981300
    12991301        /*
    … …  
    13191321                if (rc != EOK) {
    13201322                        (void) fat_node_put(fn);
    1321                         ipc_answer_0(callid, rc);
    1322                         ipc_answer_0(rid, rc);
     1323                        async_answer_0(callid, rc);
     1324                        async_answer_0(rid, rc);
    13231325                        return;
    13241326                }
    … …  
    13261328                if (rc != EOK) {
    13271329                        (void) fat_node_put(fn);
    1328                         ipc_answer_0(callid, rc);
    1329                         ipc_answer_0(rid, rc);
     1330                        async_answer_0(callid, rc);
     1331                        async_answer_0(rid, rc);
    13301332                        return;
    13311333                }
    … …  
    13361338                if (rc != EOK) {
    13371339                        (void) fat_node_put(fn);
    1338                         ipc_answer_0(rid, rc);
     1340                        async_answer_0(rid, rc);
    13391341                        return;
    13401342                }
    … …  
    13451347                size = nodep->size;
    13461348                rc = fat_node_put(fn);
    1347                 ipc_answer_2(rid, rc, bytes, nodep->size);
     1349                async_answer_2(rid, rc, bytes, nodep->size);
    13481350                return;
    13491351        } else {
    … …  
    13571359                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13581360                /* create an independent chain of nclsts clusters in all FATs */
    1359                 rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
     1361                rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
    13601362                if (rc != EOK) {
    13611363                        /* could not allocate a chain of nclsts clusters */
    13621364                        (void) fat_node_put(fn);
    1363                         ipc_answer_0(callid, rc);
    1364                         ipc_answer_0(rid, rc);
     1365                        async_answer_0(callid, rc);
     1366                        async_answer_0(rid, rc);
    13651367                        return;
    13661368                }
    … …  
    13681370                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13691371                if (rc != EOK) {
    1370                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1372                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13711373                        (void) fat_node_put(fn);
    1372                         ipc_answer_0(callid, rc);
    1373                         ipc_answer_0(rid, rc);
     1374                        async_answer_0(callid, rc);
     1375                        async_answer_0(rid, rc);
    13741376                        return;
    13751377                }
    1376                 rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL,
     1378                rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
    13771379                    (pos / BPS(bs)) % SPC(bs), flags);
    13781380                if (rc != EOK) {
    1379                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1381                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13801382                        (void) fat_node_put(fn);
    1381                         ipc_answer_0(callid, rc);
    1382                         ipc_answer_0(rid, rc);
     1383                        async_answer_0(callid, rc);
     1384                        async_answer_0(rid, rc);
    13831385                        return;
    13841386                }
    … …  
    13881390                rc = block_put(b);
    13891391                if (rc != EOK) {
    1390                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1392                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13911393                        (void) fat_node_put(fn);
    1392                         ipc_answer_0(rid, rc);
     1394                        async_answer_0(rid, rc);
    13931395                        return;
    13941396                }
    … …  
    13991401                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    14001402                if (rc != EOK) {
    1401                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1403                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    14021404                        (void) fat_node_put(fn);
    1403                         ipc_answer_0(rid, rc);
     1405                        async_answer_0(rid, rc);
    14041406                        return;
    14051407                }
    … …  
    14071409                nodep->dirty = true;            /* need to sync node */
    14081410                rc = fat_node_put(fn);
    1409                 ipc_answer_2(rid, rc, bytes, size);
     1411                async_answer_2(rid, rc, bytes, size);
    14101412                return;
    14111413        }
    … …  
    14141416void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    14151417{
    1416         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1418        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    14171419        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    14181420        aoff64_t size =
    … …  
    14231425        int rc;
    14241426
    1425         rc = fat_node_get(&fn, dev_handle, index);
    1426         if (rc != EOK) {
    1427                 ipc_answer_0(rid, rc);
     1427        rc = fat_node_get(&fn, devmap_handle, index);
     1428        if (rc != EOK) {
     1429                async_answer_0(rid, rc);
    14281430                return;
    14291431        }
    14301432        if (!fn) {
    1431                 ipc_answer_0(rid, ENOENT);
     1433                async_answer_0(rid, ENOENT);
    14321434                return;
    14331435        }
    14341436        nodep = FAT_NODE(fn);
    14351437
    1436         bs = block_bb_get(dev_handle);
     1438        bs = block_bb_get(devmap_handle);
    14371439
    14381440        if (nodep->size == size) {
    … …  
    14611463                } else {
    14621464                        fat_cluster_t lastc;
    1463                         rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
     1465                        rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
    14641466                            &lastc, NULL, (size - 1) / BPC(bs));
    14651467                        if (rc != EOK)
    … …  
    14751477out:
    14761478        fat_node_put(fn);
    1477         ipc_answer_0(rid, rc);
     1479        async_answer_0(rid, rc);
    14781480        return;
    14791481}
    … …  
    14811483void fat_close(ipc_callid_t rid, ipc_call_t *request)
    14821484{
    1483         ipc_answer_0(rid, EOK);
     1485        async_answer_0(rid, EOK);
    14841486}
    14851487
    14861488void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    14871489{
    1488         dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     1490        devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
    14891491        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    14901492        fs_node_t *fn;
     1493        fat_node_t *nodep;
    14911494        int rc;
    14921495
    1493         rc = fat_node_get(&fn, dev_handle, index);
    1494         if (rc != EOK) {
    1495                 ipc_answer_0(rid, rc);
     1496        rc = fat_node_get(&fn, devmap_handle, index);
     1497        if (rc != EOK) {
     1498                async_answer_0(rid, rc);
    14961499                return;
    14971500        }
    14981501        if (!fn) {
    1499                 ipc_answer_0(rid, ENOENT);
    1500                 return;
    1501         }
     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);
    15021512
    15031513        rc = fat_destroy_node(fn);
    1504         ipc_answer_0(rid, rc);
     1514        async_answer_0(rid, rc);
    15051515}
    15061516
    … …  
    15171527void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    15181528{
    1519         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1529        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    15201530        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    15211531       
    15221532        fs_node_t *fn;
    1523         int rc = fat_node_get(&fn, dev_handle, index);
    1524         if (rc != EOK) {
    1525                 ipc_answer_0(rid, rc);
     1533        int rc = fat_node_get(&fn, devmap_handle, index);
     1534        if (rc != EOK) {
     1535                async_answer_0(rid, rc);
    15261536                return;
    15271537        }
    15281538        if (!fn) {
    1529                 ipc_answer_0(rid, ENOENT);
     1539                async_answer_0(rid, ENOENT);
    15301540                return;
    15311541        }
    … …  
    15371547       
    15381548        fat_node_put(fn);
    1539         ipc_answer_0(rid, rc);
     1549        async_answer_0(rid, rc);
    15401550}
    15411551
Note: See TracChangeset for help on using the changeset viewer.