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


Ignore:
Timestamp:
2011-08-21T13:07:35Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
00aece0, f1a9e87
Parents:
86a34d3e (diff), a6480d5 (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

    r86a34d3e rbd5f3b7  
    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 *);
    … …  
    8585static aoff64_t fat_size_get(fs_node_t *);
    8686static unsigned fat_lnkcnt_get(fs_node_t *);
    87 static char fat_plb_get_char(unsigned);
    8887static bool fat_is_directory(fs_node_t *);
    8988static bool fat_is_file(fs_node_t *node);
    90 static devmap_handle_t fat_device_get(fs_node_t *node);
     89static service_id_t fat_device_get(fs_node_t *node);
    9190
    9291/*
    … …  
    120119        assert(node->dirty);
    121120
    122         bs = block_bb_get(node->idx->devmap_handle);
     121        bs = block_bb_get(node->idx->service_id);
    123122       
    124123        /* Read the block that contains the dentry of interest. */
    125         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,
    126125            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    127126            BLOCK_FLAGS_NONE);
    … …  
    145144}
    146145
    147 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)
    148147{
    149148        fat_node_t *nodep;
    … …  
    169168                        goto restart;
    170169                }
    171                 if (nodep->idx->devmap_handle != devmap_handle) {
     170                if (nodep->idx->service_id != service_id) {
    172171                        fibril_mutex_unlock(&nodep->idx->lock);
    173172                        fibril_mutex_unlock(&nodep->lock);
    … …  
    299298                return rc;
    300299
    301         bs = block_bb_get(idxp->devmap_handle);
     300        bs = block_bb_get(idxp->service_id);
    302301
    303302        /* Read the block that contains the dentry of interest. */
    304         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,
    305304            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    306305        if (rc != EOK) {
    … …  
    323322                 */
    324323                uint16_t clusters;
    325                 rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
     324                rc = fat_clusters_get(&clusters, bs, idxp->service_id,
    326325                    uint16_t_le2host(d->firstc));
    327326                if (rc != EOK) {
    … …  
    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, service_id_t service_id)
     359{
     360        return fat_node_get(rfn, service_id, 0);
    362361}
    363362
    … …  
    370369        unsigned blocks;
    371370        fat_dentry_t *d;
    372         devmap_handle_t devmap_handle;
     371        service_id_t service_id;
    373372        block_t *b;
    374373        int rc;
    375374
    376375        fibril_mutex_lock(&parentp->idx->lock);
    377         devmap_handle = parentp->idx->devmap_handle;
     376        service_id = parentp->idx->service_id;
    378377        fibril_mutex_unlock(&parentp->idx->lock);
    379378
    380         bs = block_bb_get(devmap_handle);
     379        bs = block_bb_get(service_id);
    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(service_id,
    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, service_id_t service_id, 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(service_id, 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, service_id_t service_id, int flags)
    496495{
    497496        fat_idx_t *idxp;
    … …  
    501500        int rc;
    502501
    503         bs = block_bb_get(devmap_handle);
     502        bs = block_bb_get(service_id);
    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, service_id, 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, service_id, mcl);
    511510                if (rc != EOK) {
    512                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     511                        (void) fat_free_clusters(bs, service_id, 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);
    520                 return rc;
    521         }
    522         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);
    523522        if (rc != EOK) {
    524                 (void) fat_free_clusters(bs, devmap_handle, mcl);       
     523                (void) fat_free_clusters(bs, service_id, 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->service_id);
    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->service_id,
    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->service_id);
    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->service_id, 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);
     666        rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl);
    668667        if (rc != EOK) {
    669                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     668                (void) fat_free_clusters(bs, parentp->idx->service_id, 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->service_id, mcl);
    676675                fibril_mutex_unlock(&parentp->idx->lock);
    677676                return rc;
    … …  
    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->service_id);
     792
     793        rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc,
    795794            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    796795            BLOCK_FLAGS_NONE);
    … …  
    842841       
    843842        fibril_mutex_lock(&nodep->idx->lock);
    844         bs = block_bb_get(nodep->idx->devmap_handle);
     843        bs = block_bb_get(nodep->idx->service_id);
    845844
    846845        blocks = nodep->size / BPS(bs);
    … …  
    901900}
    902901
    903 char fat_plb_get_char(unsigned pos)
    904 {
    905         return fat_reg.plb_ro[pos % PLB_SIZE];
    906 }
    907 
    908902bool fat_is_directory(fs_node_t *fn)
    909903{
    … …  
    916910}
    917911
    918 devmap_handle_t fat_device_get(fs_node_t *node)
     912service_id_t fat_device_get(fs_node_t *node)
    919913{
    920914        return 0;
    … …  
    936930        .size_get = fat_size_get,
    937931        .lnkcnt_get = fat_lnkcnt_get,
    938         .plb_get_char = fat_plb_get_char,
    939932        .is_directory = fat_is_directory,
    940933        .is_file = fat_is_file,
    … …  
    943936
    944937/*
    945  * VFS operations.
     938 * FAT VFS_OUT operations.
    946939 */
    947940
    948 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    949 {
    950         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     941static int
     942fat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
     943    aoff64_t *size, unsigned *linkcnt)
     944{
    951945        enum cache_mode cmode;
    952946        fat_bs_t *bs;
    953        
    954         /* Accept the mount options */
    955         char *opts;
    956         int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    957        
    958         if (rc != EOK) {
    959                 async_answer_0(rid, rc);
    960                 return;
    961         }
    962 
     947        int rc;
     948       
    963949        /* Check for option enabling write through. */
    964950        if (str_cmp(opts, "wtcache") == 0)
    … …  
    967953                cmode = CACHE_MODE_WB;
    968954
    969         free(opts);
    970 
    971955        /* initialize libblock */
    972         rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
     956        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
     957        if (rc != EOK)
     958                return rc;
     959
     960        /* prepare the boot block */
     961        rc = block_bb_read(service_id, BS_BLOCK);
    973962        if (rc != EOK) {
    974                 async_answer_0(rid, rc);
    975                 return;
    976         }
    977 
    978         /* prepare the boot block */
    979         rc = block_bb_read(devmap_handle, BS_BLOCK);
     963                block_fini(service_id);
     964                return rc;
     965        }
     966
     967        /* get the buffer with the boot sector */
     968        bs = block_bb_get(service_id);
     969       
     970        if (BPS(bs) != BS_SIZE) {
     971                block_fini(service_id);
     972                return ENOTSUP;
     973        }
     974
     975        /* Initialize the block cache */
     976        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
    980977        if (rc != EOK) {
    981                 block_fini(devmap_handle);
    982                 async_answer_0(rid, rc);
    983                 return;
    984         }
    985 
    986         /* get the buffer with the boot sector */
    987         bs = block_bb_get(devmap_handle);
    988        
    989         if (BPS(bs) != BS_SIZE) {
    990                 block_fini(devmap_handle);
    991                 async_answer_0(rid, ENOTSUP);
    992                 return;
    993         }
    994 
    995         /* Initialize the block cache */
    996         rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
     978                block_fini(service_id);
     979                return rc;
     980        }
     981
     982        /* Do some simple sanity checks on the file system. */
     983        rc = fat_sanity_check(bs, service_id);
    997984        if (rc != EOK) {
    998                 block_fini(devmap_handle);
    999                 async_answer_0(rid, rc);
    1000                 return;
    1001         }
    1002 
    1003         /* Do some simple sanity checks on the file system. */
    1004         rc = fat_sanity_check(bs, 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);
    1005991        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);
    1017                 return;
     992                (void) block_cache_fini(service_id);
     993                block_fini(service_id);
     994                return rc;
    1018995        }
    1019996
    … …  
    1021998        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    1022999        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);
    1027                 return;
     1000                (void) block_cache_fini(service_id);
     1001                block_fini(service_id);
     1002                fat_idx_fini_by_service_id(service_id);
     1003                return ENOMEM;
    10281004        }
    10291005        fs_node_initialize(rfn);
    … …  
    10311007        if (!rootp) {
    10321008                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);
    1037                 return;
     1009                (void) block_cache_fini(service_id);
     1010                block_fini(service_id);
     1011                fat_idx_fini_by_service_id(service_id);
     1012                return ENOMEM;
    10381013        }
    10391014        fat_node_initialize(rootp);
    10401015
    1041         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);
    10421017        if (!ridxp) {
    10431018                free(rfn);
    10441019                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);
    1049                 return;
     1020                (void) block_cache_fini(service_id);
     1021                block_fini(service_id);
     1022                fat_idx_fini_by_service_id(service_id);
     1023                return ENOMEM;
    10501024        }
    10511025        assert(ridxp->index == 0);
    … …  
    10641038        fibril_mutex_unlock(&ridxp->lock);
    10651039
    1066         async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    1067 }
    1068 
    1069 void fat_mount(ipc_callid_t rid, ipc_call_t *request)
    1070 {
    1071         libfs_mount(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1072 }
    1073 
    1074 void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    1075 {
    1076         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1040        *index = ridxp->index;
     1041        *size = rootp->size;
     1042        *linkcnt = rootp->lnkcnt;
     1043
     1044        return EOK;
     1045}
     1046
     1047static int fat_unmounted(service_id_t service_id)
     1048{
    10771049        fs_node_t *fn;
    10781050        fat_node_t *nodep;
    10791051        int rc;
    10801052
    1081         rc = fat_root_get(&fn, devmap_handle);
    1082         if (rc != EOK) {
    1083                 async_answer_0(rid, rc);
    1084                 return;
    1085         }
     1053        rc = fat_root_get(&fn, service_id);
     1054        if (rc != EOK)
     1055                return rc;
    10861056        nodep = FAT_NODE(fn);
    10871057
    … …  
    10921062        if (nodep->refcnt != 2) {
    10931063                (void) fat_node_put(fn);
    1094                 async_answer_0(rid, EBUSY);
    1095                 return;
     1064                return EBUSY;
    10961065        }
    10971066       
    … …  
    11071076         * stop using libblock for this instance.
    11081077         */
    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);
    1115 }
    1116 
    1117 void fat_unmount(ipc_callid_t rid, ipc_call_t *request)
    1118 {
    1119         libfs_unmount(&fat_libfs_ops, rid, request);
    1120 }
    1121 
    1122 void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
    1123 {
    1124         libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1125 }
    1126 
    1127 void fat_read(ipc_callid_t rid, ipc_call_t *request)
    1128 {
    1129         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1130         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1131         aoff64_t pos =
    1132             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     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);
     1082
     1083        return EOK;
     1084}
     1085
     1086static int
     1087fat_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1088    size_t *rbytes)
     1089{
    11331090        fs_node_t *fn;
    11341091        fat_node_t *nodep;
    … …  
    11381095        int rc;
    11391096
    1140         rc = fat_node_get(&fn, devmap_handle, index);
    1141         if (rc != EOK) {
    1142                 async_answer_0(rid, rc);
    1143                 return;
    1144         }
    1145         if (!fn) {
    1146                 async_answer_0(rid, ENOENT);
    1147                 return;
    1148         }
     1097        rc = fat_node_get(&fn, service_id, index);
     1098        if (rc != EOK)
     1099                return rc;
     1100        if (!fn)
     1101                return ENOENT;
    11491102        nodep = FAT_NODE(fn);
    11501103
    … …  
    11541107                fat_node_put(fn);
    11551108                async_answer_0(callid, EINVAL);
    1156                 async_answer_0(rid, EINVAL);
    1157                 return;
    1158         }
    1159 
    1160         bs = block_bb_get(devmap_handle);
     1109                return EINVAL;
     1110        }
     1111
     1112        bs = block_bb_get(service_id);
    11611113
    11621114        if (nodep->type == FAT_FILE) {
    … …  
    11781130                                fat_node_put(fn);
    11791131                                async_answer_0(callid, rc);
    1180                                 async_answer_0(rid, rc);
    1181                                 return;
     1132                                return rc;
    11821133                        }
    11831134                        (void) async_data_read_finalize(callid,
    … …  
    11861137                        if (rc != EOK) {
    11871138                                fat_node_put(fn);
    1188                                 async_answer_0(rid, rc);
    1189                                 return;
     1139                                return rc;
    11901140                        }
    11911141                }
    … …  
    12441194                rc = fat_node_put(fn);
    12451195                async_answer_0(callid, rc != EOK ? rc : ENOENT);
    1246                 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    1247                 return;
     1196                *rbytes = 0;
     1197                return rc != EOK ? rc : ENOENT;
    12481198
    12491199err:
    12501200                (void) fat_node_put(fn);
    12511201                async_answer_0(callid, rc);
    1252                 async_answer_0(rid, rc);
    1253                 return;
     1202                return rc;
    12541203
    12551204hit:
    … …  
    12591208
    12601209        rc = fat_node_put(fn);
    1261         async_answer_1(rid, rc, (sysarg_t)bytes);
    1262 }
    1263 
    1264 void fat_write(ipc_callid_t rid, ipc_call_t *request)
    1265 {
    1266         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1267         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1268         aoff64_t pos =
    1269             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1210        *rbytes = bytes;
     1211        return rc;
     1212}
     1213
     1214static int
     1215fat_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1216    size_t *wbytes, aoff64_t *nsize)
     1217{
    12701218        fs_node_t *fn;
    12711219        fat_node_t *nodep;
    12721220        fat_bs_t *bs;
    1273         size_t bytes, size;
     1221        size_t bytes;
    12741222        block_t *b;
    12751223        aoff64_t boundary;
    … …  
    12771225        int rc;
    12781226       
    1279         rc = fat_node_get(&fn, devmap_handle, index);
    1280         if (rc != EOK) {
    1281                 async_answer_0(rid, rc);
    1282                 return;
    1283         }
    1284         if (!fn) {
    1285                 async_answer_0(rid, ENOENT);
    1286                 return;
    1287         }
     1227        rc = fat_node_get(&fn, service_id, index);
     1228        if (rc != EOK)
     1229                return rc;
     1230        if (!fn)
     1231                return ENOENT;
    12881232        nodep = FAT_NODE(fn);
    12891233       
    … …  
    12931237                (void) fat_node_put(fn);
    12941238                async_answer_0(callid, EINVAL);
    1295                 async_answer_0(rid, EINVAL);
    1296                 return;
    1297         }
    1298 
    1299         bs = block_bb_get(devmap_handle);
     1239                return EINVAL;
     1240        }
     1241
     1242        bs = block_bb_get(service_id);
    13001243
    13011244        /*
    … …  
    13221265                        (void) fat_node_put(fn);
    13231266                        async_answer_0(callid, rc);
    1324                         async_answer_0(rid, rc);
    1325                         return;
     1267                        return rc;
    13261268                }
    13271269                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
    … …  
    13291271                        (void) fat_node_put(fn);
    13301272                        async_answer_0(callid, rc);
    1331                         async_answer_0(rid, rc);
    1332                         return;
     1273                        return rc;
    13331274                }
    13341275                (void) async_data_write_finalize(callid,
    … …  
    13381279                if (rc != EOK) {
    13391280                        (void) fat_node_put(fn);
    1340                         async_answer_0(rid, rc);
    1341                         return;
     1281                        return rc;
    13421282                }
    13431283                if (pos + bytes > nodep->size) {
    … …  
    13451285                        nodep->dirty = true;    /* need to sync node */
    13461286                }
    1347                 size = nodep->size;
     1287                *wbytes = bytes;
     1288                *nsize = nodep->size;
    13481289                rc = fat_node_put(fn);
    1349                 async_answer_2(rid, rc, bytes, nodep->size);
    1350                 return;
     1290                return rc;
    13511291        } else {
    13521292                /*
    … …  
    13591299                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13601300                /* create an independent chain of nclsts clusters in all FATs */
    1361                 rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
     1301                rc = fat_alloc_clusters(bs, service_id, nclsts, &mcl, &lcl);
    13621302                if (rc != EOK) {
    13631303                        /* could not allocate a chain of nclsts clusters */
    13641304                        (void) fat_node_put(fn);
    13651305                        async_answer_0(callid, rc);
    1366                         async_answer_0(rid, rc);
    1367                         return;
     1306                        return rc;
    13681307                }
    13691308                /* zero fill any gaps */
    13701309                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13711310                if (rc != EOK) {
    1372                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1311                        (void) fat_free_clusters(bs, service_id, mcl);
    13731312                        (void) fat_node_put(fn);
    13741313                        async_answer_0(callid, rc);
    1375                         async_answer_0(rid, rc);
    1376                         return;
    1377                 }
    1378                 rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
     1314                        return rc;
     1315                }
     1316                rc = _fat_block_get(&b, bs, service_id, lcl, NULL,
    13791317                    (pos / BPS(bs)) % SPC(bs), flags);
    13801318                if (rc != EOK) {
    1381                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1319                        (void) fat_free_clusters(bs, service_id, mcl);
    13821320                        (void) fat_node_put(fn);
    13831321                        async_answer_0(callid, rc);
    1384                         async_answer_0(rid, rc);
    1385                         return;
     1322                        return rc;
    13861323                }
    13871324                (void) async_data_write_finalize(callid,
    … …  
    13901327                rc = block_put(b);
    13911328                if (rc != EOK) {
    1392                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1329                        (void) fat_free_clusters(bs, service_id, mcl);
    13931330                        (void) fat_node_put(fn);
    1394                         async_answer_0(rid, rc);
    1395                         return;
     1331                        return rc;
    13961332                }
    13971333                /*
    … …  
    14011337                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    14021338                if (rc != EOK) {
    1403                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1339                        (void) fat_free_clusters(bs, service_id, mcl);
    14041340                        (void) fat_node_put(fn);
    1405                         async_answer_0(rid, rc);
    1406                         return;
    1407                 }
    1408                 nodep->size = size = pos + bytes;
     1341                        return rc;
     1342                }
     1343                *nsize = nodep->size = pos + bytes;
     1344                rc = fat_node_put(fn);
    14091345                nodep->dirty = true;            /* need to sync node */
    1410                 rc = fat_node_put(fn);
    1411                 async_answer_2(rid, rc, bytes, size);
    1412                 return;
    1413         }
    1414 }
    1415 
    1416 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    1417 {
    1418         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1419         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1420         aoff64_t size =
    1421             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1346                *wbytes = bytes;
     1347                return rc;
     1348        }
     1349}
     1350
     1351static int
     1352fat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
     1353{
    14221354        fs_node_t *fn;
    14231355        fat_node_t *nodep;
    … …  
    14251357        int rc;
    14261358
    1427         rc = fat_node_get(&fn, devmap_handle, index);
    1428         if (rc != EOK) {
    1429                 async_answer_0(rid, rc);
    1430                 return;
    1431         }
    1432         if (!fn) {
    1433                 async_answer_0(rid, ENOENT);
    1434                 return;
    1435         }
     1359        rc = fat_node_get(&fn, service_id, index);
     1360        if (rc != EOK)
     1361                return rc;
     1362        if (!fn)
     1363                return ENOENT;
    14361364        nodep = FAT_NODE(fn);
    14371365
    1438         bs = block_bb_get(devmap_handle);
     1366        bs = block_bb_get(service_id);
    14391367
    14401368        if (nodep->size == size) {
    … …  
    14631391                } else {
    14641392                        fat_cluster_t lastc;
    1465                         rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
     1393                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
    14661394                            &lastc, NULL, (size - 1) / BPC(bs));
    14671395                        if (rc != EOK)
    … …  
    14771405out:
    14781406        fat_node_put(fn);
    1479         async_answer_0(rid, rc);
    1480         return;
    1481 }
    1482 
    1483 void fat_close(ipc_callid_t rid, ipc_call_t *request)
    1484 {
    1485         async_answer_0(rid, EOK);
    1486 }
    1487 
    1488 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    1489 {
    1490         devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
    1491         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     1407        return rc;
     1408}
     1409
     1410static int fat_close(service_id_t service_id, fs_index_t index)
     1411{
     1412        return EOK;
     1413}
     1414
     1415static int fat_destroy(service_id_t service_id, fs_index_t index)
     1416{
    14921417        fs_node_t *fn;
    14931418        fat_node_t *nodep;
    14941419        int rc;
    14951420
    1496         rc = fat_node_get(&fn, devmap_handle, index);
    1497         if (rc != EOK) {
    1498                 async_answer_0(rid, rc);
    1499                 return;
    1500         }
    1501         if (!fn) {
    1502                 async_answer_0(rid, ENOENT);
    1503                 return;
    1504         }
     1421        rc = fat_node_get(&fn, service_id, index);
     1422        if (rc != EOK)
     1423                return rc;
     1424        if (!fn)
     1425                return ENOENT;
    15051426
    15061427        nodep = FAT_NODE(fn);
    … …  
    15121433
    15131434        rc = fat_destroy_node(fn);
    1514         async_answer_0(rid, rc);
    1515 }
    1516 
    1517 void fat_open_node(ipc_callid_t rid, ipc_call_t *request)
    1518 {
    1519         libfs_open_node(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1520 }
    1521 
    1522 void fat_stat(ipc_callid_t rid, ipc_call_t *request)
    1523 {
    1524         libfs_stat(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1525 }
    1526 
    1527 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    1528 {
    1529         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1530         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1531        
     1435        return rc;
     1436}
     1437
     1438static int fat_sync(service_id_t service_id, fs_index_t index)
     1439{
    15321440        fs_node_t *fn;
    1533         int rc = fat_node_get(&fn, devmap_handle, index);
    1534         if (rc != EOK) {
    1535                 async_answer_0(rid, rc);
    1536                 return;
    1537         }
    1538         if (!fn) {
    1539                 async_answer_0(rid, ENOENT);
    1540                 return;
    1541         }
     1441        int rc = fat_node_get(&fn, service_id, index);
     1442        if (rc != EOK)
     1443                return rc;
     1444        if (!fn)
     1445                return ENOENT;
    15421446       
    15431447        fat_node_t *nodep = FAT_NODE(fn);
    … …  
    15471451       
    15481452        fat_node_put(fn);
    1549         async_answer_0(rid, rc);
    1550 }
     1453        return rc;
     1454}
     1455
     1456vfs_out_ops_t fat_ops = {
     1457        .mounted = fat_mounted,
     1458        .unmounted = fat_unmounted,
     1459        .read = fat_read,
     1460        .write = fat_write,
     1461        .truncate = fat_truncate,
     1462        .close = fat_close,
     1463        .destroy = fat_destroy,
     1464        .sync = fat_sync,
     1465};
    15511466
    15521467/**
Note: See TracChangeset for help on using the changeset viewer.