Fork us on GitHub Follow us on Facebook Follow us on Twitter

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


Ignore:
Timestamp:
2011-08-16T18:53:00Z (10 years ago)
Author:
Petr Koupy <petr.koupy@…>
Branches:
lfn, master
Children:
49160c4
Parents:
e0e922d (diff), 45058baa (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 mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/fat/fat_ops.c

    re0e922d rdb6e419  
    4343#include <libblock.h>
    4444#include <ipc/services.h>
    45 #include <ipc/devmap.h>
     45#include <ipc/loc.h>
    4646#include <macros.h>
    4747#include <async.h>
     
    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 **, service_id_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 **, service_id_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 **, service_id_t, int);
    8080static int fat_destroy_node(fs_node_t *);
    8181static int fat_link(fs_node_t *, fs_node_t *, const char *);
     
    8787static bool fat_is_directory(fs_node_t *);
    8888static bool fat_is_file(fs_node_t *node);
    89 static devmap_handle_t fat_device_get(fs_node_t *node);
     89static service_id_t fat_device_get(fs_node_t *node);
    9090
    9191/*
     
    119119        assert(node->dirty);
    120120
    121         bs = block_bb_get(node->idx->devmap_handle);
     121        bs = block_bb_get(node->idx->service_id);
    122122       
    123123        /* Read the block that contains the dentry of interest. */
    124         rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
     124        rc = _fat_block_get(&b, bs, node->idx->service_id, node->idx->pfc,
    125125            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    126126            BLOCK_FLAGS_NONE);
     
    144144}
    145145
    146 static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
     146static int fat_node_fini_by_service_id(service_id_t service_id)
    147147{
    148148        fat_node_t *nodep;
     
    168168                        goto restart;
    169169                }
    170                 if (nodep->idx->devmap_handle != devmap_handle) {
     170                if (nodep->idx->service_id != service_id) {
    171171                        fibril_mutex_unlock(&nodep->idx->lock);
    172172                        fibril_mutex_unlock(&nodep->lock);
     
    298298                return rc;
    299299
    300         bs = block_bb_get(idxp->devmap_handle);
     300        bs = block_bb_get(idxp->service_id);
    301301
    302302        /* Read the block that contains the dentry of interest. */
    303         rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
     303        rc = _fat_block_get(&b, bs, idxp->service_id, idxp->pfc, NULL,
    304304            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    305305        if (rc != EOK) {
     
    322322                 */
    323323                uint16_t clusters;
    324                 rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
     324                rc = fat_clusters_get(&clusters, bs, idxp->service_id,
    325325                    uint16_t_le2host(d->firstc));
    326326                if (rc != EOK) {
     
    356356 */
    357357
    358 int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    359 {
    360         return fat_node_get(rfn, devmap_handle, 0);
     358int fat_root_get(fs_node_t **rfn, service_id_t service_id)
     359{
     360        return fat_node_get(rfn, service_id, 0);
    361361}
    362362
     
    369369        unsigned blocks;
    370370        fat_dentry_t *d;
    371         devmap_handle_t devmap_handle;
     371        service_id_t service_id;
    372372        block_t *b;
    373373        int rc;
    374374
    375375        fibril_mutex_lock(&parentp->idx->lock);
    376         devmap_handle = parentp->idx->devmap_handle;
     376        service_id = parentp->idx->service_id;
    377377        fibril_mutex_unlock(&parentp->idx->lock);
    378378
    379         bs = block_bb_get(devmap_handle);
     379        bs = block_bb_get(service_id);
    380380        blocks = parentp->size / BPS(bs);
    381381        for (i = 0; i < blocks; i++) {
     
    402402                                /* hit */
    403403                                fat_node_t *nodep;
    404                                 fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
     404                                fat_idx_t *idx = fat_idx_get_by_pos(service_id,
    405405                                    parentp->firstc, i * DPS(bs) + j);
    406406                                if (!idx) {
     
    435435
    436436/** Instantiate a FAT in-core node. */
    437 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, service_id_t service_id, fs_index_t index)
    438438{
    439439        fat_node_t *nodep;
     
    441441        int rc;
    442442
    443         idxp = fat_idx_get_by_index(devmap_handle, index);
     443        idxp = fat_idx_get_by_index(service_id, index);
    444444        if (!idxp) {
    445445                *rfn = NULL;
     
    492492}
    493493
    494 int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
     494int fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    495495{
    496496        fat_idx_t *idxp;
     
    500500        int rc;
    501501
    502         bs = block_bb_get(devmap_handle);
     502        bs = block_bb_get(service_id);
    503503        if (flags & L_DIRECTORY) {
    504504                /* allocate a cluster */
    505                 rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
     505                rc = fat_alloc_clusters(bs, service_id, 1, &mcl, &lcl);
    506506                if (rc != EOK)
    507507                        return rc;
    508508                /* populate the new cluster with unused dentries */
    509                 rc = fat_zero_cluster(bs, devmap_handle, mcl);
     509                rc = fat_zero_cluster(bs, service_id, mcl);
    510510                if (rc != EOK) {
    511                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     511                        (void) fat_free_clusters(bs, service_id, mcl);
    512512                        return rc;
    513513                }
     
    516516        rc = fat_node_get_new(&nodep);
    517517        if (rc != EOK) {
    518                 (void) fat_free_clusters(bs, devmap_handle, mcl);
    519                 return rc;
    520         }
    521         rc = fat_idx_get_new(&idxp, devmap_handle);
     518                (void) fat_free_clusters(bs, service_id, mcl);
     519                return rc;
     520        }
     521        rc = fat_idx_get_new(&idxp, service_id);
    522522        if (rc != EOK) {
    523                 (void) fat_free_clusters(bs, devmap_handle, mcl);       
     523                (void) fat_free_clusters(bs, service_id, mcl); 
    524524                (void) fat_node_put(FS_NODE(nodep));
    525525                return rc;
     
    570570        assert(!has_children);
    571571
    572         bs = block_bb_get(nodep->idx->devmap_handle);
     572        bs = block_bb_get(nodep->idx->service_id);
    573573        if (nodep->firstc != FAT_CLST_RES0) {
    574574                assert(nodep->size);
    575575                /* Free all clusters allocated to the node. */
    576                 rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
     576                rc = fat_free_clusters(bs, nodep->idx->service_id,
    577577                    nodep->firstc);
    578578        }
     
    620620       
    621621        fibril_mutex_lock(&parentp->idx->lock);
    622         bs = block_bb_get(parentp->idx->devmap_handle);
     622        bs = block_bb_get(parentp->idx->service_id);
    623623
    624624        blocks = parentp->size / BPS(bs);
     
    659659                return ENOSPC;
    660660        }
    661         rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
     661        rc = fat_alloc_clusters(bs, parentp->idx->service_id, 1, &mcl, &lcl);
    662662        if (rc != EOK) {
    663663                fibril_mutex_unlock(&parentp->idx->lock);
    664664                return rc;
    665665        }
    666         rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
     666        rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl);
    667667        if (rc != EOK) {
    668                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     668                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
    669669                fibril_mutex_unlock(&parentp->idx->lock);
    670670                return rc;
     
    672672        rc = fat_append_clusters(bs, parentp, mcl, lcl);
    673673        if (rc != EOK) {
    674                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     674                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
    675675                fibril_mutex_unlock(&parentp->idx->lock);
    676676                return rc;
     
    789789        assert(childp->lnkcnt == 1);
    790790        fibril_mutex_lock(&childp->idx->lock);
    791         bs = block_bb_get(childp->idx->devmap_handle);
    792 
    793         rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
     791        bs = block_bb_get(childp->idx->service_id);
     792
     793        rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc,
    794794            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    795795            BLOCK_FLAGS_NONE);
     
    841841       
    842842        fibril_mutex_lock(&nodep->idx->lock);
    843         bs = block_bb_get(nodep->idx->devmap_handle);
     843        bs = block_bb_get(nodep->idx->service_id);
    844844
    845845        blocks = nodep->size / BPS(bs);
     
    910910}
    911911
    912 devmap_handle_t fat_device_get(fs_node_t *node)
     912service_id_t fat_device_get(fs_node_t *node)
    913913{
    914914        return 0;
     
    940940
    941941static int
    942 fat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index,
     942fat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    943943    aoff64_t *size, unsigned *linkcnt)
    944944{
     
    954954
    955955        /* initialize libblock */
    956         rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
     956        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
    957957        if (rc != EOK)
    958958                return rc;
    959959
    960960        /* prepare the boot block */
    961         rc = block_bb_read(devmap_handle, BS_BLOCK);
     961        rc = block_bb_read(service_id, BS_BLOCK);
    962962        if (rc != EOK) {
    963                 block_fini(devmap_handle);
     963                block_fini(service_id);
    964964                return rc;
    965965        }
    966966
    967967        /* get the buffer with the boot sector */
    968         bs = block_bb_get(devmap_handle);
     968        bs = block_bb_get(service_id);
    969969       
    970970        if (BPS(bs) != BS_SIZE) {
    971                 block_fini(devmap_handle);
     971                block_fini(service_id);
    972972                return ENOTSUP;
    973973        }
    974974
    975975        /* Initialize the block cache */
    976         rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
     976        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
    977977        if (rc != EOK) {
    978                 block_fini(devmap_handle);
     978                block_fini(service_id);
    979979                return rc;
    980980        }
    981981
    982982        /* Do some simple sanity checks on the file system. */
    983         rc = fat_sanity_check(bs, devmap_handle);
     983        rc = fat_sanity_check(bs, service_id);
    984984        if (rc != EOK) {
    985                 (void) block_cache_fini(devmap_handle);
    986                 block_fini(devmap_handle);
    987                 return rc;
    988         }
    989 
    990         rc = fat_idx_init_by_devmap_handle(devmap_handle);
     985                (void) block_cache_fini(service_id);
     986                block_fini(service_id);
     987                return rc;
     988        }
     989
     990        rc = fat_idx_init_by_service_id(service_id);
    991991        if (rc != EOK) {
    992                 (void) block_cache_fini(devmap_handle);
    993                 block_fini(devmap_handle);
     992                (void) block_cache_fini(service_id);
     993                block_fini(service_id);
    994994                return rc;
    995995        }
     
    998998        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    999999        if (!rfn) {
    1000                 (void) block_cache_fini(devmap_handle);
    1001                 block_fini(devmap_handle);
    1002                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1000                (void) block_cache_fini(service_id);
     1001                block_fini(service_id);
     1002                fat_idx_fini_by_service_id(service_id);
    10031003                return ENOMEM;
    10041004        }
     
    10071007        if (!rootp) {
    10081008                free(rfn);
    1009                 (void) block_cache_fini(devmap_handle);
    1010                 block_fini(devmap_handle);
    1011                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1009                (void) block_cache_fini(service_id);
     1010                block_fini(service_id);
     1011                fat_idx_fini_by_service_id(service_id);
    10121012                return ENOMEM;
    10131013        }
    10141014        fat_node_initialize(rootp);
    10151015
    1016         fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
     1016        fat_idx_t *ridxp = fat_idx_get_by_pos(service_id, FAT_CLST_ROOTPAR, 0);
    10171017        if (!ridxp) {
    10181018                free(rfn);
    10191019                free(rootp);
    1020                 (void) block_cache_fini(devmap_handle);
    1021                 block_fini(devmap_handle);
    1022                 fat_idx_fini_by_devmap_handle(devmap_handle);
     1020                (void) block_cache_fini(service_id);
     1021                block_fini(service_id);
     1022                fat_idx_fini_by_service_id(service_id);
    10231023                return ENOMEM;
    10241024        }
     
    10451045}
    10461046
    1047 static int fat_unmounted(devmap_handle_t devmap_handle)
     1047static int fat_unmounted(service_id_t service_id)
    10481048{
    10491049        fs_node_t *fn;
     
    10511051        int rc;
    10521052
    1053         rc = fat_root_get(&fn, devmap_handle);
     1053        rc = fat_root_get(&fn, service_id);
    10541054        if (rc != EOK)
    10551055                return rc;
     
    10761076         * stop using libblock for this instance.
    10771077         */
    1078         (void) fat_node_fini_by_devmap_handle(devmap_handle);
    1079         fat_idx_fini_by_devmap_handle(devmap_handle);
    1080         (void) block_cache_fini(devmap_handle);
    1081         block_fini(devmap_handle);
     1078        (void) fat_node_fini_by_service_id(service_id);
     1079        fat_idx_fini_by_service_id(service_id);
     1080        (void) block_cache_fini(service_id);
     1081        block_fini(service_id);
    10821082
    10831083        return EOK;
     
    10851085
    10861086static int
    1087 fat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1087fat_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    10881088    size_t *rbytes)
    10891089{
     
    10951095        int rc;
    10961096
    1097         rc = fat_node_get(&fn, devmap_handle, index);
     1097        rc = fat_node_get(&fn, service_id, index);
    10981098        if (rc != EOK)
    10991099                return rc;
     
    11101110        }
    11111111
    1112         bs = block_bb_get(devmap_handle);
     1112        bs = block_bb_get(service_id);
    11131113
    11141114        if (nodep->type == FAT_FILE) {
     
    12131213
    12141214static int
    1215 fat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1215fat_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    12161216    size_t *wbytes, aoff64_t *nsize)
    12171217{
     
    12251225        int rc;
    12261226       
    1227         rc = fat_node_get(&fn, devmap_handle, index);
     1227        rc = fat_node_get(&fn, service_id, index);
    12281228        if (rc != EOK)
    12291229                return rc;
     
    12401240        }
    12411241
    1242         bs = block_bb_get(devmap_handle);
     1242        bs = block_bb_get(service_id);
    12431243
    12441244        /*
     
    12991299                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13001300                /* create an independent chain of nclsts clusters in all FATs */
    1301                 rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
     1301                rc = fat_alloc_clusters(bs, service_id, nclsts, &mcl, &lcl);
    13021302                if (rc != EOK) {
    13031303                        /* could not allocate a chain of nclsts clusters */
     
    13091309                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13101310                if (rc != EOK) {
    1311                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1311                        (void) fat_free_clusters(bs, service_id, mcl);
    13121312                        (void) fat_node_put(fn);
    13131313                        async_answer_0(callid, rc);
    13141314                        return rc;
    13151315                }
    1316                 rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
     1316                rc = _fat_block_get(&b, bs, service_id, lcl, NULL,
    13171317                    (pos / BPS(bs)) % SPC(bs), flags);
    13181318                if (rc != EOK) {
    1319                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1319                        (void) fat_free_clusters(bs, service_id, mcl);
    13201320                        (void) fat_node_put(fn);
    13211321                        async_answer_0(callid, rc);
     
    13271327                rc = block_put(b);
    13281328                if (rc != EOK) {
    1329                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1329                        (void) fat_free_clusters(bs, service_id, mcl);
    13301330                        (void) fat_node_put(fn);
    13311331                        return rc;
     
    13371337                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    13381338                if (rc != EOK) {
    1339                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1339                        (void) fat_free_clusters(bs, service_id, mcl);
    13401340                        (void) fat_node_put(fn);
    13411341                        return rc;
     
    13501350
    13511351static int
    1352 fat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
     1352fat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    13531353{
    13541354        fs_node_t *fn;
     
    13571357        int rc;
    13581358
    1359         rc = fat_node_get(&fn, devmap_handle, index);
     1359        rc = fat_node_get(&fn, service_id, index);
    13601360        if (rc != EOK)
    13611361                return rc;
     
    13641364        nodep = FAT_NODE(fn);
    13651365
    1366         bs = block_bb_get(devmap_handle);
     1366        bs = block_bb_get(service_id);
    13671367
    13681368        if (nodep->size == size) {
     
    13911391                } else {
    13921392                        fat_cluster_t lastc;
    1393                         rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
     1393                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
    13941394                            &lastc, NULL, (size - 1) / BPC(bs));
    13951395                        if (rc != EOK)
     
    14081408}
    14091409
    1410 static int fat_close(devmap_handle_t devmap_handle, fs_index_t index)
     1410static int fat_close(service_id_t service_id, fs_index_t index)
    14111411{
    14121412        return EOK;
    14131413}
    14141414
    1415 static int fat_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     1415static int fat_destroy(service_id_t service_id, fs_index_t index)
    14161416{
    14171417        fs_node_t *fn;
     
    14191419        int rc;
    14201420
    1421         rc = fat_node_get(&fn, devmap_handle, index);
     1421        rc = fat_node_get(&fn, service_id, index);
    14221422        if (rc != EOK)
    14231423                return rc;
     
    14361436}
    14371437
    1438 static int fat_sync(devmap_handle_t devmap_handle, fs_index_t index)
     1438static int fat_sync(service_id_t service_id, fs_index_t index)
    14391439{
    14401440        fs_node_t *fn;
    1441         int rc = fat_node_get(&fn, devmap_handle, index);
     1441        int rc = fat_node_get(&fn, service_id, index);
    14421442        if (rc != EOK)
    14431443                return rc;
Note: See TracChangeset for help on using the changeset viewer.