Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    refcebe1 r15f3c3f  
    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 *);
     87static char fat_plb_get_char(unsigned);
    8788static bool fat_is_directory(fs_node_t *);
    8889static bool fat_is_file(fs_node_t *node);
    89 static devmap_handle_t fat_device_get(fs_node_t *node);
     90static service_id_t fat_device_get(fs_node_t *node);
    9091
    9192/*
    … …  
    119120        assert(node->dirty);
    120121
    121         bs = block_bb_get(node->idx->devmap_handle);
     122        bs = block_bb_get(node->idx->service_id);
    122123       
    123124        /* Read the block that contains the dentry of interest. */
    124         rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
     125        rc = _fat_block_get(&b, bs, node->idx->service_id, node->idx->pfc,
    125126            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    126127            BLOCK_FLAGS_NONE);
    … …  
    144145}
    145146
    146 static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
     147static int fat_node_fini_by_service_id(service_id_t service_id)
    147148{
    148149        fat_node_t *nodep;
    … …  
    168169                        goto restart;
    169170                }
    170                 if (nodep->idx->devmap_handle != devmap_handle) {
     171                if (nodep->idx->service_id != service_id) {
    171172                        fibril_mutex_unlock(&nodep->idx->lock);
    172173                        fibril_mutex_unlock(&nodep->lock);
    … …  
    298299                return rc;
    299300
    300         bs = block_bb_get(idxp->devmap_handle);
     301        bs = block_bb_get(idxp->service_id);
    301302
    302303        /* Read the block that contains the dentry of interest. */
    303         rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
     304        rc = _fat_block_get(&b, bs, idxp->service_id, idxp->pfc, NULL,
    304305            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
    305306        if (rc != EOK) {
    … …  
    322323                 */
    323324                uint16_t clusters;
    324                 rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
     325                rc = fat_clusters_get(&clusters, bs, idxp->service_id,
    325326                    uint16_t_le2host(d->firstc));
    326327                if (rc != EOK) {
    … …  
    356357 */
    357358
    358 int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    359 {
    360         return fat_node_get(rfn, devmap_handle, 0);
     359int fat_root_get(fs_node_t **rfn, service_id_t service_id)
     360{
     361        return fat_node_get(rfn, service_id, 0);
    361362}
    362363
    … …  
    369370        unsigned blocks;
    370371        fat_dentry_t *d;
    371         devmap_handle_t devmap_handle;
     372        service_id_t service_id;
    372373        block_t *b;
    373374        int rc;
    374375
    375376        fibril_mutex_lock(&parentp->idx->lock);
    376         devmap_handle = parentp->idx->devmap_handle;
     377        service_id = parentp->idx->service_id;
    377378        fibril_mutex_unlock(&parentp->idx->lock);
    378379
    379         bs = block_bb_get(devmap_handle);
     380        bs = block_bb_get(service_id);
    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(devmap_handle,
     405                                fat_idx_t *idx = fat_idx_get_by_pos(service_id,
    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, devmap_handle_t devmap_handle, fs_index_t index)
     438int fat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    438439{
    439440        fat_node_t *nodep;
    … …  
    441442        int rc;
    442443
    443         idxp = fat_idx_get_by_index(devmap_handle, index);
     444        idxp = fat_idx_get_by_index(service_id, index);
    444445        if (!idxp) {
    445446                *rfn = NULL;
    … …  
    492493}
    493494
    494 int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
     495int fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    495496{
    496497        fat_idx_t *idxp;
    … …  
    500501        int rc;
    501502
    502         bs = block_bb_get(devmap_handle);
     503        bs = block_bb_get(service_id);
    503504        if (flags & L_DIRECTORY) {
    504505                /* allocate a cluster */
    505                 rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
     506                rc = fat_alloc_clusters(bs, service_id, 1, &mcl, &lcl);
    506507                if (rc != EOK)
    507508                        return rc;
    508509                /* populate the new cluster with unused dentries */
    509                 rc = fat_zero_cluster(bs, devmap_handle, mcl);
     510                rc = fat_zero_cluster(bs, service_id, mcl);
    510511                if (rc != EOK) {
    511                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     512                        (void) fat_free_clusters(bs, service_id, mcl);
    512513                        return rc;
    513514                }
    … …  
    516517        rc = fat_node_get_new(&nodep);
    517518        if (rc != EOK) {
    518                 (void) fat_free_clusters(bs, devmap_handle, mcl);
     519                (void) fat_free_clusters(bs, service_id, mcl);
    519520                return rc;
    520521        }
    521         rc = fat_idx_get_new(&idxp, devmap_handle);
    522         if (rc != EOK) {
    523                 (void) fat_free_clusters(bs, devmap_handle, mcl);       
     522        rc = fat_idx_get_new(&idxp, service_id);
     523        if (rc != EOK) {
     524                (void) fat_free_clusters(bs, service_id, mcl); 
    524525                (void) fat_node_put(FS_NODE(nodep));
    525526                return rc;
    … …  
    570571        assert(!has_children);
    571572
    572         bs = block_bb_get(nodep->idx->devmap_handle);
     573        bs = block_bb_get(nodep->idx->service_id);
    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->devmap_handle,
     577                rc = fat_free_clusters(bs, nodep->idx->service_id,
    577578                    nodep->firstc);
    578579        }
    … …  
    620621       
    621622        fibril_mutex_lock(&parentp->idx->lock);
    622         bs = block_bb_get(parentp->idx->devmap_handle);
     623        bs = block_bb_get(parentp->idx->service_id);
    623624
    624625        blocks = parentp->size / BPS(bs);
    … …  
    659660                return ENOSPC;
    660661        }
    661         rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
     662        rc = fat_alloc_clusters(bs, parentp->idx->service_id, 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->devmap_handle, mcl);
    667         if (rc != EOK) {
    668                 (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
     667        rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl);
     668        if (rc != EOK) {
     669                (void) fat_free_clusters(bs, parentp->idx->service_id, 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->devmap_handle, mcl);
     675                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
    675676                fibril_mutex_unlock(&parentp->idx->lock);
    676677                return rc;
    … …  
    789790        assert(childp->lnkcnt == 1);
    790791        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,
     792        bs = block_bb_get(childp->idx->service_id);
     793
     794        rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc,
    794795            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
    795796            BLOCK_FLAGS_NONE);
    … …  
    841842       
    842843        fibril_mutex_lock(&nodep->idx->lock);
    843         bs = block_bb_get(nodep->idx->devmap_handle);
     844        bs = block_bb_get(nodep->idx->service_id);
    844845
    845846        blocks = nodep->size / BPS(bs);
    … …  
    900901}
    901902
     903char fat_plb_get_char(unsigned pos)
     904{
     905        return fat_reg.plb_ro[pos % PLB_SIZE];
     906}
     907
    902908bool fat_is_directory(fs_node_t *fn)
    903909{
    … …  
    910916}
    911917
    912 devmap_handle_t fat_device_get(fs_node_t *node)
     918service_id_t fat_device_get(fs_node_t *node)
    913919{
    914920        return 0;
    … …  
    930936        .size_get = fat_size_get,
    931937        .lnkcnt_get = fat_lnkcnt_get,
     938        .plb_get_char = fat_plb_get_char,
    932939        .is_directory = fat_is_directory,
    933940        .is_file = fat_is_file,
    … …  
    936943
    937944/*
    938  * FAT VFS_OUT operations.
     945 * VFS operations.
    939946 */
    940947
    941 static int
    942 fat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index,
    943     aoff64_t *size, unsigned *linkcnt)
    944 {
     948void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
     949{
     950        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    945951        enum cache_mode cmode;
    946952        fat_bs_t *bs;
    947         int rc;
    948        
     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
    949963        /* Check for option enabling write through. */
    950964        if (str_cmp(opts, "wtcache") == 0)
    … …  
    953967                cmode = CACHE_MODE_WB;
    954968
     969        free(opts);
     970
    955971        /* initialize libblock */
    956         rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
    957         if (rc != EOK)
    958                 return rc;
     972        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
     973        if (rc != EOK) {
     974                async_answer_0(rid, rc);
     975                return;
     976        }
    959977
    960978        /* prepare the boot block */
    961         rc = block_bb_read(devmap_handle, BS_BLOCK);
    962         if (rc != EOK) {
    963                 block_fini(devmap_handle);
    964                 return rc;
     979        rc = block_bb_read(service_id, BS_BLOCK);
     980        if (rc != EOK) {
     981                block_fini(service_id);
     982                async_answer_0(rid, rc);
     983                return;
    965984        }
    966985
    967986        /* get the buffer with the boot sector */
    968         bs = block_bb_get(devmap_handle);
     987        bs = block_bb_get(service_id);
    969988       
    970989        if (BPS(bs) != BS_SIZE) {
    971                 block_fini(devmap_handle);
    972                 return ENOTSUP;
     990                block_fini(service_id);
     991                async_answer_0(rid, ENOTSUP);
     992                return;
    973993        }
    974994
    975995        /* Initialize the block cache */
    976         rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
    977         if (rc != EOK) {
    978                 block_fini(devmap_handle);
    979                 return rc;
     996        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
     997        if (rc != EOK) {
     998                block_fini(service_id);
     999                async_answer_0(rid, rc);
     1000                return;
    9801001        }
    9811002
    9821003        /* Do some simple sanity checks on the file system. */
    983         rc = fat_sanity_check(bs, devmap_handle);
    984         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);
    991         if (rc != EOK) {
    992                 (void) block_cache_fini(devmap_handle);
    993                 block_fini(devmap_handle);
    994                 return rc;
     1004        rc = fat_sanity_check(bs, service_id);
     1005        if (rc != EOK) {
     1006                (void) block_cache_fini(service_id);
     1007                block_fini(service_id);
     1008                async_answer_0(rid, rc);
     1009                return;
     1010        }
     1011
     1012        rc = fat_idx_init_by_service_id(service_id);
     1013        if (rc != EOK) {
     1014                (void) block_cache_fini(service_id);
     1015                block_fini(service_id);
     1016                async_answer_0(rid, rc);
     1017                return;
    9951018        }
    9961019
    … …  
    9981021        fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
    9991022        if (!rfn) {
    1000                 (void) block_cache_fini(devmap_handle);
    1001                 block_fini(devmap_handle);
    1002                 fat_idx_fini_by_devmap_handle(devmap_handle);
    1003                 return ENOMEM;
     1023                (void) block_cache_fini(service_id);
     1024                block_fini(service_id);
     1025                fat_idx_fini_by_service_id(service_id);
     1026                async_answer_0(rid, ENOMEM);
     1027                return;
    10041028        }
    10051029        fs_node_initialize(rfn);
    … …  
    10071031        if (!rootp) {
    10081032                free(rfn);
    1009                 (void) block_cache_fini(devmap_handle);
    1010                 block_fini(devmap_handle);
    1011                 fat_idx_fini_by_devmap_handle(devmap_handle);
    1012                 return ENOMEM;
     1033                (void) block_cache_fini(service_id);
     1034                block_fini(service_id);
     1035                fat_idx_fini_by_service_id(service_id);
     1036                async_answer_0(rid, ENOMEM);
     1037                return;
    10131038        }
    10141039        fat_node_initialize(rootp);
    10151040
    1016         fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
     1041        fat_idx_t *ridxp = fat_idx_get_by_pos(service_id, FAT_CLST_ROOTPAR, 0);
    10171042        if (!ridxp) {
    10181043                free(rfn);
    10191044                free(rootp);
    1020                 (void) block_cache_fini(devmap_handle);
    1021                 block_fini(devmap_handle);
    1022                 fat_idx_fini_by_devmap_handle(devmap_handle);
    1023                 return ENOMEM;
     1045                (void) block_cache_fini(service_id);
     1046                block_fini(service_id);
     1047                fat_idx_fini_by_service_id(service_id);
     1048                async_answer_0(rid, ENOMEM);
     1049                return;
    10241050        }
    10251051        assert(ridxp->index == 0);
    … …  
    10381064        fibril_mutex_unlock(&ridxp->lock);
    10391065
    1040         *index = ridxp->index;
    1041         *size = rootp->size;
    1042         *linkcnt = rootp->lnkcnt;
    1043 
    1044         return EOK;
    1045 }
    1046 
    1047 static int fat_unmounted(devmap_handle_t devmap_handle)
    1048 {
     1066        async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
     1067}
     1068
     1069void 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
     1074void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
     1075{
     1076        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    10491077        fs_node_t *fn;
    10501078        fat_node_t *nodep;
    10511079        int rc;
    10521080
    1053         rc = fat_root_get(&fn, devmap_handle);
    1054         if (rc != EOK)
    1055                 return rc;
     1081        rc = fat_root_get(&fn, service_id);
     1082        if (rc != EOK) {
     1083                async_answer_0(rid, rc);
     1084                return;
     1085        }
    10561086        nodep = FAT_NODE(fn);
    10571087
    … …  
    10621092        if (nodep->refcnt != 2) {
    10631093                (void) fat_node_put(fn);
    1064                 return EBUSY;
     1094                async_answer_0(rid, EBUSY);
     1095                return;
    10651096        }
    10661097       
    … …  
    10761107         * stop using libblock for this instance.
    10771108         */
    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);
    1082 
    1083         return EOK;
    1084 }
    1085 
    1086 static int
    1087 fat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
    1088     size_t *rbytes)
    1089 {
     1109        (void) fat_node_fini_by_service_id(service_id);
     1110        fat_idx_fini_by_service_id(service_id);
     1111        (void) block_cache_fini(service_id);
     1112        block_fini(service_id);
     1113
     1114        async_answer_0(rid, EOK);
     1115}
     1116
     1117void fat_unmount(ipc_callid_t rid, ipc_call_t *request)
     1118{
     1119        libfs_unmount(&fat_libfs_ops, rid, request);
     1120}
     1121
     1122void 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
     1127void fat_read(ipc_callid_t rid, ipc_call_t *request)
     1128{
     1129        service_id_t service_id = (service_id_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));
    10901133        fs_node_t *fn;
    10911134        fat_node_t *nodep;
    … …  
    10951138        int rc;
    10961139
    1097         rc = fat_node_get(&fn, devmap_handle, index);
    1098         if (rc != EOK)
    1099                 return rc;
    1100         if (!fn)
    1101                 return ENOENT;
     1140        rc = fat_node_get(&fn, service_id, 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        }
    11021149        nodep = FAT_NODE(fn);
    11031150
    … …  
    11071154                fat_node_put(fn);
    11081155                async_answer_0(callid, EINVAL);
    1109                 return EINVAL;
    1110         }
    1111 
    1112         bs = block_bb_get(devmap_handle);
     1156                async_answer_0(rid, EINVAL);
     1157                return;
     1158        }
     1159
     1160        bs = block_bb_get(service_id);
    11131161
    11141162        if (nodep->type == FAT_FILE) {
    … …  
    11301178                                fat_node_put(fn);
    11311179                                async_answer_0(callid, rc);
    1132                                 return rc;
     1180                                async_answer_0(rid, rc);
     1181                                return;
    11331182                        }
    11341183                        (void) async_data_read_finalize(callid,
    … …  
    11371186                        if (rc != EOK) {
    11381187                                fat_node_put(fn);
    1139                                 return rc;
     1188                                async_answer_0(rid, rc);
     1189                                return;
    11401190                        }
    11411191                }
    … …  
    11941244                rc = fat_node_put(fn);
    11951245                async_answer_0(callid, rc != EOK ? rc : ENOENT);
    1196                 *rbytes = 0;
    1197                 return rc != EOK ? rc : ENOENT;
     1246                async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
     1247                return;
    11981248
    11991249err:
    12001250                (void) fat_node_put(fn);
    12011251                async_answer_0(callid, rc);
    1202                 return rc;
     1252                async_answer_0(rid, rc);
     1253                return;
    12031254
    12041255hit:
    … …  
    12081259
    12091260        rc = fat_node_put(fn);
    1210         *rbytes = bytes;
    1211         return rc;
    1212 }
    1213 
    1214 static int
    1215 fat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
    1216     size_t *wbytes, aoff64_t *nsize)
    1217 {
     1261        async_answer_1(rid, rc, (sysarg_t)bytes);
     1262}
     1263
     1264void fat_write(ipc_callid_t rid, ipc_call_t *request)
     1265{
     1266        service_id_t service_id = (service_id_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));
    12181270        fs_node_t *fn;
    12191271        fat_node_t *nodep;
    12201272        fat_bs_t *bs;
    1221         size_t bytes;
     1273        size_t bytes, size;
    12221274        block_t *b;
    12231275        aoff64_t boundary;
    … …  
    12251277        int rc;
    12261278       
    1227         rc = fat_node_get(&fn, devmap_handle, index);
    1228         if (rc != EOK)
    1229                 return rc;
    1230         if (!fn)
    1231                 return ENOENT;
     1279        rc = fat_node_get(&fn, service_id, 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        }
    12321288        nodep = FAT_NODE(fn);
    12331289       
    … …  
    12371293                (void) fat_node_put(fn);
    12381294                async_answer_0(callid, EINVAL);
    1239                 return EINVAL;
    1240         }
    1241 
    1242         bs = block_bb_get(devmap_handle);
     1295                async_answer_0(rid, EINVAL);
     1296                return;
     1297        }
     1298
     1299        bs = block_bb_get(service_id);
    12431300
    12441301        /*
    … …  
    12651322                        (void) fat_node_put(fn);
    12661323                        async_answer_0(callid, rc);
    1267                         return rc;
     1324                        async_answer_0(rid, rc);
     1325                        return;
    12681326                }
    12691327                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
    … …  
    12711329                        (void) fat_node_put(fn);
    12721330                        async_answer_0(callid, rc);
    1273                         return rc;
     1331                        async_answer_0(rid, rc);
     1332                        return;
    12741333                }
    12751334                (void) async_data_write_finalize(callid,
    … …  
    12791338                if (rc != EOK) {
    12801339                        (void) fat_node_put(fn);
    1281                         return rc;
     1340                        async_answer_0(rid, rc);
     1341                        return;
    12821342                }
    12831343                if (pos + bytes > nodep->size) {
    … …  
    12851345                        nodep->dirty = true;    /* need to sync node */
    12861346                }
    1287                 *wbytes = bytes;
    1288                 *nsize = nodep->size;
     1347                size = nodep->size;
    12891348                rc = fat_node_put(fn);
    1290                 return rc;
     1349                async_answer_2(rid, rc, bytes, nodep->size);
     1350                return;
    12911351        } else {
    12921352                /*
    … …  
    12991359                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
    13001360                /* create an independent chain of nclsts clusters in all FATs */
    1301                 rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
     1361                rc = fat_alloc_clusters(bs, service_id, nclsts, &mcl, &lcl);
    13021362                if (rc != EOK) {
    13031363                        /* could not allocate a chain of nclsts clusters */
    13041364                        (void) fat_node_put(fn);
    13051365                        async_answer_0(callid, rc);
    1306                         return rc;
     1366                        async_answer_0(rid, rc);
     1367                        return;
    13071368                }
    13081369                /* zero fill any gaps */
    13091370                rc = fat_fill_gap(bs, nodep, mcl, pos);
    13101371                if (rc != EOK) {
    1311                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1372                        (void) fat_free_clusters(bs, service_id, mcl);
    13121373                        (void) fat_node_put(fn);
    13131374                        async_answer_0(callid, rc);
    1314                         return rc;
    1315                 }
    1316                 rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
     1375                        async_answer_0(rid, rc);
     1376                        return;
     1377                }
     1378                rc = _fat_block_get(&b, bs, service_id, lcl, NULL,
    13171379                    (pos / BPS(bs)) % SPC(bs), flags);
    13181380                if (rc != EOK) {
    1319                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1381                        (void) fat_free_clusters(bs, service_id, mcl);
    13201382                        (void) fat_node_put(fn);
    13211383                        async_answer_0(callid, rc);
    1322                         return rc;
     1384                        async_answer_0(rid, rc);
     1385                        return;
    13231386                }
    13241387                (void) async_data_write_finalize(callid,
    … …  
    13271390                rc = block_put(b);
    13281391                if (rc != EOK) {
    1329                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1392                        (void) fat_free_clusters(bs, service_id, mcl);
    13301393                        (void) fat_node_put(fn);
    1331                         return rc;
     1394                        async_answer_0(rid, rc);
     1395                        return;
    13321396                }
    13331397                /*
    … …  
    13371401                rc = fat_append_clusters(bs, nodep, mcl, lcl);
    13381402                if (rc != EOK) {
    1339                         (void) fat_free_clusters(bs, devmap_handle, mcl);
     1403                        (void) fat_free_clusters(bs, service_id, mcl);
    13401404                        (void) fat_node_put(fn);
    1341                         return rc;
    1342                 }
    1343                 *nsize = nodep->size = pos + bytes;
     1405                        async_answer_0(rid, rc);
     1406                        return;
     1407                }
     1408                nodep->size = size = pos + bytes;
     1409                nodep->dirty = true;            /* need to sync node */
    13441410                rc = fat_node_put(fn);
    1345                 nodep->dirty = true;            /* need to sync node */
    1346                 *wbytes = bytes;
    1347                 return rc;
    1348         }
    1349 }
    1350 
    1351 static int
    1352 fat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
    1353 {
     1411                async_answer_2(rid, rc, bytes, size);
     1412                return;
     1413        }
     1414}
     1415
     1416void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
     1417{
     1418        service_id_t service_id = (service_id_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));
    13541422        fs_node_t *fn;
    13551423        fat_node_t *nodep;
    … …  
    13571425        int rc;
    13581426
    1359         rc = fat_node_get(&fn, devmap_handle, index);
    1360         if (rc != EOK)
    1361                 return rc;
    1362         if (!fn)
    1363                 return ENOENT;
     1427        rc = fat_node_get(&fn, service_id, 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        }
    13641436        nodep = FAT_NODE(fn);
    13651437
    1366         bs = block_bb_get(devmap_handle);
     1438        bs = block_bb_get(service_id);
    13671439
    13681440        if (nodep->size == size) {
    … …  
    13911463                } else {
    13921464                        fat_cluster_t lastc;
    1393                         rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
     1465                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
    13941466                            &lastc, NULL, (size - 1) / BPC(bs));
    13951467                        if (rc != EOK)
    … …  
    14051477out:
    14061478        fat_node_put(fn);
    1407         return rc;
    1408 }
    1409 
    1410 static int fat_close(devmap_handle_t devmap_handle, fs_index_t index)
    1411 {
    1412         return EOK;
    1413 }
    1414 
    1415 static int fat_destroy(devmap_handle_t devmap_handle, fs_index_t index)
    1416 {
     1479        async_answer_0(rid, rc);
     1480        return;
     1481}
     1482
     1483void fat_close(ipc_callid_t rid, ipc_call_t *request)
     1484{
     1485        async_answer_0(rid, EOK);
     1486}
     1487
     1488void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
     1489{
     1490        service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
     1491        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    14171492        fs_node_t *fn;
    14181493        fat_node_t *nodep;
    14191494        int rc;
    14201495
    1421         rc = fat_node_get(&fn, devmap_handle, index);
    1422         if (rc != EOK)
    1423                 return rc;
    1424         if (!fn)
    1425                 return ENOENT;
     1496        rc = fat_node_get(&fn, service_id, 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        }
    14261505
    14271506        nodep = FAT_NODE(fn);
    … …  
    14331512
    14341513        rc = fat_destroy_node(fn);
    1435         return rc;
    1436 }
    1437 
    1438 static int fat_sync(devmap_handle_t devmap_handle, fs_index_t index)
    1439 {
     1514        async_answer_0(rid, rc);
     1515}
     1516
     1517void 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
     1522void 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
     1527void fat_sync(ipc_callid_t rid, ipc_call_t *request)
     1528{
     1529        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     1530        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     1531       
    14401532        fs_node_t *fn;
    1441         int rc = fat_node_get(&fn, devmap_handle, index);
    1442         if (rc != EOK)
    1443                 return rc;
    1444         if (!fn)
    1445                 return ENOENT;
     1533        int rc = fat_node_get(&fn, service_id, 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        }
    14461542       
    14471543        fat_node_t *nodep = FAT_NODE(fn);
    … …  
    14511547       
    14521548        fat_node_put(fn);
    1453         return rc;
    1454 }
    1455 
    1456 vfs_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 };
     1549        async_answer_0(rid, rc);
     1550}
    14661551
    14671552/**
Note: See TracChangeset for help on using the changeset viewer.