Changeset 0b749a3 in mainline for uspace/srv/fs/fat/fat_ops.c


Ignore:
Timestamp:
2010-11-22T15:39:53Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0eddb76, aae339e9
Parents:
9a1d8ab (diff), 8cd1aa5e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge development/ changes

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9a1d8ab r0b749a3  
    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) {
    … …  
    356356 */
    357357
    358 int fat_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
    359 {
    360         return fat_node_get(rfn, dev_handle, 0);
     358int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
     359{
     360        return fat_node_get(rfn, devmap_handle, 0);
    361361}
    362362
    … …  
    369369        unsigned blocks;
    370370        fat_dentry_t *d;
     371        devmap_handle_t devmap_handle;
    371372        block_t *b;
    372373        int rc;
    373374
    374375        fibril_mutex_lock(&parentp->idx->lock);
    375         bs = block_bb_get(parentp->idx->dev_handle);
     376        devmap_handle = parentp->idx->devmap_handle;
     377        fibril_mutex_unlock(&parentp->idx->lock);
     378
     379        bs = block_bb_get(devmap_handle);
    376380        blocks = parentp->size / BPS(bs);
    377381        for (i = 0; i < blocks; i++) {
    378382                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
    379                 if (rc != EOK) {
    380                         fibril_mutex_unlock(&parentp->idx->lock);
     383                if (rc != EOK)
    381384                        return rc;
    382                 }
    383385                for (j = 0; j < DPS(bs); j++) {
    384386                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    390392                                /* miss */
    391393                                rc = block_put(b);
    392                                 fibril_mutex_unlock(&parentp->idx->lock);
    393394                                *rfn = NULL;
    394395                                return rc;
    … …  
    401402                                /* hit */
    402403                                fat_node_t *nodep;
    403                                 /*
    404                                  * Assume tree hierarchy for locking.  We
    405                                  * already have the parent and now we are going
    406                                  * to lock the child.  Never lock in the oposite
    407                                  * order.
    408                                  */
    409                                 fat_idx_t *idx = fat_idx_get_by_pos(
    410                                     parentp->idx->dev_handle, parentp->firstc,
    411                                     i * DPS(bs) + j);
    412                                 fibril_mutex_unlock(&parentp->idx->lock);
     404                                fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
     405                                    parentp->firstc, i * DPS(bs) + j);
    413406                                if (!idx) {
    414407                                        /*
    … …  
    433426                }
    434427                rc = block_put(b);
    435                 if (rc != EOK) {
    436                         fibril_mutex_unlock(&parentp->idx->lock);
     428                if (rc != EOK)
    437429                        return rc;
    438                 }
    439         }
    440 
    441         fibril_mutex_unlock(&parentp->idx->lock);
     430        }
     431
    442432        *rfn = NULL;
    443433        return EOK;
    … …  
    445435
    446436/** Instantiate a FAT in-core node. */
    447 int fat_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
     437int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
    448438{
    449439        fat_node_t *nodep;
    … …  
    451441        int rc;
    452442
    453         idxp = fat_idx_get_by_index(dev_handle, index);
     443        idxp = fat_idx_get_by_index(devmap_handle, index);
    454444        if (!idxp) {
    455445                *rfn = NULL;
    … …  
    502492}
    503493
    504 int fat_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int flags)
     494int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
    505495{
    506496        fat_idx_t *idxp;
    … …  
    510500        int rc;
    511501
    512         bs = block_bb_get(dev_handle);
     502        bs = block_bb_get(devmap_handle);
    513503        if (flags & L_DIRECTORY) {
    514504                /* allocate a cluster */
    515                 rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
     505                rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
    516506                if (rc != EOK)
    517507                        return rc;
    518508                /* populate the new cluster with unused dentries */
    519                 rc = fat_zero_cluster(bs, dev_handle, mcl);
     509                rc = fat_zero_cluster(bs, devmap_handle, mcl);
    520510                if (rc != EOK) {
    521                         (void) fat_free_clusters(bs, dev_handle, mcl);
     511                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    522512                        return rc;
    523513                }
    … …  
    526516        rc = fat_node_get_new(&nodep);
    527517        if (rc != EOK) {
    528                 (void) fat_free_clusters(bs, dev_handle, mcl);
     518                (void) fat_free_clusters(bs, devmap_handle, mcl);
    529519                return rc;
    530520        }
    531         rc = fat_idx_get_new(&idxp, dev_handle);
    532         if (rc != EOK) {
    533                 (void) fat_free_clusters(bs, dev_handle, mcl); 
     521        rc = fat_idx_get_new(&idxp, devmap_handle);
     522        if (rc != EOK) {
     523                (void) fat_free_clusters(bs, devmap_handle, mcl);       
    534524                (void) fat_node_put(FS_NODE(nodep));
    535525                return rc;
    … …  
    580570        assert(!has_children);
    581571
    582         bs = block_bb_get(nodep->idx->dev_handle);
     572        bs = block_bb_get(nodep->idx->devmap_handle);
    583573        if (nodep->firstc != FAT_CLST_RES0) {
    584574                assert(nodep->size);
    585575                /* Free all clusters allocated to the node. */
    586                 rc = fat_free_clusters(bs, nodep->idx->dev_handle,
     576                rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
    587577                    nodep->firstc);
    588578        }
    … …  
    630620       
    631621        fibril_mutex_lock(&parentp->idx->lock);
    632         bs = block_bb_get(parentp->idx->dev_handle);
     622        bs = block_bb_get(parentp->idx->devmap_handle);
    633623
    634624        blocks = parentp->size / BPS(bs);
    … …  
    669659                return ENOSPC;
    670660        }
    671         rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
     661        rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
    672662        if (rc != EOK) {
    673663                fibril_mutex_unlock(&parentp->idx->lock);
    674664                return rc;
    675665        }
    676         rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
    677         if (rc != EOK) {
    678                 (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
     666        rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
     667        if (rc != EOK) {
     668                (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
    679669                fibril_mutex_unlock(&parentp->idx->lock);
    680670                return rc;
    … …  
    682672        rc = fat_append_clusters(bs, parentp, mcl, lcl);
    683673        if (rc != EOK) {
    684                 (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
     674                (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
    685675                fibril_mutex_unlock(&parentp->idx->lock);
    686676                return rc;
    … …  
    799789        assert(childp->lnkcnt == 1);
    800790        fibril_mutex_lock(&childp->idx->lock);
    801         bs = block_bb_get(childp->idx->dev_handle);
    802 
    803         rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
     791        bs = block_bb_get(childp->idx->devmap_handle);
     792
     793        rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
    804794            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    805795            BLOCK_FLAGS_NONE);
    … …  
    850840       
    851841        fibril_mutex_lock(&nodep->idx->lock);
    852         bs = block_bb_get(nodep->idx->dev_handle);
     842        bs = block_bb_get(nodep->idx->devmap_handle);
    853843
    854844        blocks = nodep->size / BPS(bs);
    … …  
    924914}
    925915
    926 dev_handle_t fat_device_get(fs_node_t *node)
     916devmap_handle_t fat_device_get(fs_node_t *node)
    927917{
    928918        return 0;
    … …  
    956946void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    957947{
    958         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     948        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    959949        enum cache_mode cmode;
    960950        fat_bs_t *bs;
    … …  
    978968
    979969        /* initialize libblock */
    980         rc = block_init(dev_handle, BS_SIZE);
     970        rc = block_init(devmap_handle, BS_SIZE);
    981971        if (rc != EOK) {
    982972                ipc_answer_0(rid, rc);
    … …  
    985975
    986976        /* prepare the boot block */
    987         rc = block_bb_read(dev_handle, BS_BLOCK);
    988         if (rc != EOK) {
    989                 block_fini(dev_handle);
     977        rc = block_bb_read(devmap_handle, BS_BLOCK);
     978        if (rc != EOK) {
     979                block_fini(devmap_handle);
    990980                ipc_answer_0(rid, rc);
    991981                return;
    … …  
    993983
    994984        /* get the buffer with the boot sector */
    995         bs = block_bb_get(dev_handle);
     985        bs = block_bb_get(devmap_handle);
    996986       
    997987        if (BPS(bs) != BS_SIZE) {
    998                 block_fini(dev_handle);
     988                block_fini(devmap_handle);
    999989                ipc_answer_0(rid, ENOTSUP);
    1000990                return;
    … …  
    1002992
    1003993        /* Initialize the block cache */
    1004         rc = block_cache_init(dev_handle, BPS(bs), 0 /* XXX */, cmode);
    1005         if (rc != EOK) {
    1006                 block_fini(dev_handle);
     994        rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
     995        if (rc != EOK) {
     996                block_fini(devmap_handle);
    1007997                ipc_answer_0(rid, rc);
    1008998                return;
    … …  
    10101000
    10111001        /* Do some simple sanity checks on the file system. */
    1012         rc = fat_sanity_check(bs, dev_handle);
    1013         if (rc != EOK) {
    1014                 (void) block_cache_fini(dev_handle);
    1015                 block_fini(dev_handle);
     1002        rc = fat_sanity_check(bs, devmap_handle);
     1003        if (rc != EOK) {
     1004                (void) block_cache_fini(devmap_handle);
     1005                block_fini(devmap_handle);
    10161006                ipc_answer_0(rid, rc);
    10171007                return;
    10181008        }
    10191009
    1020         rc = fat_idx_init_by_dev_handle(dev_handle);
    1021         if (rc != EOK) {
    1022                 (void) block_cache_fini(dev_handle);
    1023                 block_fini(dev_handle);
     1010        rc = fat_idx_init_by_devmap_handle(devmap_handle);
     1011        if (rc != EOK) {
     1012                (void) block_cache_fini(devmap_handle);
     1013                block_fini(devmap_handle);
    10241014                ipc_answer_0(rid, rc);
    10251015                return;
    … …  
    10291019        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    10301020        if (!rfn) {
    1031                 (void) block_cache_fini(dev_handle);
    1032                 block_fini(dev_handle);
    1033                 fat_idx_fini_by_dev_handle(dev_handle);
     1021                (void) block_cache_fini(devmap_handle);
     1022                block_fini(devmap_handle);
     1023                fat_idx_fini_by_devmap_handle(devmap_handle);
    10341024                ipc_answer_0(rid, ENOMEM);
    10351025                return;
    … …  
    10391029        if (!rootp) {
    10401030                free(rfn);
    1041                 (void) block_cache_fini(dev_handle);
    1042                 block_fini(dev_handle);
    1043                 fat_idx_fini_by_dev_handle(dev_handle);
     1031                (void) block_cache_fini(devmap_handle);
     1032                block_fini(devmap_handle);
     1033                fat_idx_fini_by_devmap_handle(devmap_handle);
    10441034                ipc_answer_0(rid, ENOMEM);
    10451035                return;
    … …  
    10471037        fat_node_initialize(rootp);
    10481038
    1049         fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
     1039        fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
    10501040        if (!ridxp) {
    10511041                free(rfn);
    10521042                free(rootp);
    1053                 (void) block_cache_fini(dev_handle);
    1054                 block_fini(dev_handle);
    1055                 fat_idx_fini_by_dev_handle(dev_handle);
     1043                (void) block_cache_fini(devmap_handle);
     1044                block_fini(devmap_handle);
     1045                fat_idx_fini_by_devmap_handle(devmap_handle);
    10561046                ipc_answer_0(rid, ENOMEM);
    10571047                return;
    … …  
    10821072void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    10831073{
    1084         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1074        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    10851075        fs_node_t *fn;
    10861076        fat_node_t *nodep;
    10871077        int rc;
    10881078
    1089         rc = fat_root_get(&fn, dev_handle);
     1079        rc = fat_root_get(&fn, devmap_handle);
    10901080        if (rc != EOK) {
    10911081                ipc_answer_0(rid, rc);
    … …  
    11151105         * stop using libblock for this instance.
    11161106         */
    1117         (void) fat_node_fini_by_dev_handle(dev_handle);
    1118         fat_idx_fini_by_dev_handle(dev_handle);
    1119         (void) block_cache_fini(dev_handle);
    1120         block_fini(dev_handle);
     1107        (void) fat_node_fini_by_devmap_handle(devmap_handle);
     1108        fat_idx_fini_by_devmap_handle(devmap_handle);
     1109        (void) block_cache_fini(devmap_handle);
     1110        block_fini(devmap_handle);
    11211111
    11221112        ipc_answer_0(rid, EOK);
    … …  
    11351125void fat_read(ipc_callid_t rid, ipc_call_t *request)
    11361126{
    1137         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1127        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    11381128        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    11391129        aoff64_t pos =
    … …  
    11461136        int rc;
    11471137
    1148         rc = fat_node_get(&fn, dev_handle, index);
     1138        rc = fat_node_get(&fn, devmap_handle, index);
    11491139        if (rc != EOK) {
    11501140                ipc_answer_0(rid, rc);
    … …  
    11661156        }
    11671157
    1168         bs = block_bb_get(dev_handle);
     1158        bs = block_bb_get(devmap_handle);
    11691159
    11701160        if (nodep->type == FAT_FILE) {
    … …  
    12721262void fat_write(ipc_callid_t rid, ipc_call_t *request)
    12731263{
    1274         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1264        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    12751265        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    12761266        aoff64_t pos =
    … …  
    12851275        int rc;
    12861276       
    1287         rc = fat_node_get(&fn, dev_handle, index);
     1277        rc = fat_node_get(&fn, devmap_handle, index);
    12881278        if (rc != EOK) {
    12891279                ipc_answer_0(rid, rc);
    … …  
    13051295        }
    13061296
    1307         bs = block_bb_get(dev_handle);
     1297        bs = block_bb_get(devmap_handle);
    13081298
    13091299        /*
    … …  
    13671357                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13681358                /* create an independent chain of nclsts clusters in all FATs */
    1369                 rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
     1359                rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
    13701360                if (rc != EOK) {
    13711361                        /* could not allocate a chain of nclsts clusters */
    … …  
    13781368                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13791369                if (rc != EOK) {
    1380                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1370                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13811371                        (void) fat_node_put(fn);
    13821372                        ipc_answer_0(callid, rc);
    … …  
    13841374                        return;
    13851375                }
    1386                 rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL,
     1376                rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
    13871377                    (pos / BPS(bs)) % SPC(bs), flags);
    13881378                if (rc != EOK) {
    1389                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1379                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13901380                        (void) fat_node_put(fn);
    13911381                        ipc_answer_0(callid, rc);
    … …  
    13981388                rc = block_put(b);
    13991389                if (rc != EOK) {
    1400                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1390                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    14011391                        (void) fat_node_put(fn);
    14021392                        ipc_answer_0(rid, rc);
    … …  
    14091399                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    14101400                if (rc != EOK) {
    1411                         (void) fat_free_clusters(bs, dev_handle, mcl);
     1401                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    14121402                        (void) fat_node_put(fn);
    14131403                        ipc_answer_0(rid, rc);
    … …  
    14241414void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    14251415{
    1426         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1416        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    14271417        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    14281418        aoff64_t size =
    … …  
    14331423        int rc;
    14341424
    1435         rc = fat_node_get(&fn, dev_handle, index);
     1425        rc = fat_node_get(&fn, devmap_handle, index);
    14361426        if (rc != EOK) {
    14371427                ipc_answer_0(rid, rc);
    … …  
    14441434        nodep = FAT_NODE(fn);
    14451435
    1446         bs = block_bb_get(dev_handle);
     1436        bs = block_bb_get(devmap_handle);
    14471437
    14481438        if (nodep->size == size) {
    … …  
    14711461                } else {
    14721462                        fat_cluster_t lastc;
    1473                         rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
     1463                        rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
    14741464                            &lastc, NULL, (size - 1) / BPC(bs));
    14751465                        if (rc != EOK)
    … …  
    14961486void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    14971487{
    1498         dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     1488        devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
    14991489        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    15001490        fs_node_t *fn;
    15011491        int rc;
    15021492
    1503         rc = fat_node_get(&fn, dev_handle, index);
     1493        rc = fat_node_get(&fn, devmap_handle, index);
    15041494        if (rc != EOK) {
    15051495                ipc_answer_0(rid, rc);
    … …  
    15271517void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    15281518{
    1529         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     1519        devmap_handle_t devmap_handle = (devmap_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, dev_handle, index);
     1523        int rc = fat_node_get(&fn, devmap_handle, index);
    15341524        if (rc != EOK) {
    15351525                ipc_answer_0(rid, rc);
Note: See TracChangeset for help on using the changeset viewer.