Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    refcebe1 rb72efe8  
    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);
    … …  
    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{
    … …  
    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        devmap_handle_t devmap_handle = (devmap_handle_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 */
    956972        rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
    957         if (rc != EOK)
    958                 return rc;
     973        if (rc != EOK) {
     974                async_answer_0(rid, rc);
     975                return;
     976        }
    959977
    960978        /* prepare the boot block */
    … …  
    962980        if (rc != EOK) {
    963981                block_fini(devmap_handle);
    964                 return rc;
     982                async_answer_0(rid, rc);
     983                return;
    965984        }
    966985
    … …  
    970989        if (BPS(bs) != BS_SIZE) {
    971990                block_fini(devmap_handle);
    972                 return ENOTSUP;
     991                async_answer_0(rid, ENOTSUP);
     992                return;
    973993        }
    974994
    … …  
    977997        if (rc != EOK) {
    978998                block_fini(devmap_handle);
    979                 return rc;
     999                async_answer_0(rid, rc);
     1000                return;
    9801001        }
    9811002
    … …  
    9851006                (void) block_cache_fini(devmap_handle);
    9861007                block_fini(devmap_handle);
    987                 return rc;
     1008                async_answer_0(rid, rc);
     1009                return;
    9881010        }
    9891011
    … …  
    9921014                (void) block_cache_fini(devmap_handle);
    9931015                block_fini(devmap_handle);
    994                 return rc;
     1016                async_answer_0(rid, rc);
     1017                return;
    9951018        }
    9961019
    … …  
    10011024                block_fini(devmap_handle);
    10021025                fat_idx_fini_by_devmap_handle(devmap_handle);
    1003                 return ENOMEM;
     1026                async_answer_0(rid, ENOMEM);
     1027                return;
    10041028        }
    10051029        fs_node_initialize(rfn);
    … …  
    10101034                block_fini(devmap_handle);
    10111035                fat_idx_fini_by_devmap_handle(devmap_handle);
    1012                 return ENOMEM;
     1036                async_answer_0(rid, ENOMEM);
     1037                return;
    10131038        }
    10141039        fat_node_initialize(rootp);
    … …  
    10211046                block_fini(devmap_handle);
    10221047                fat_idx_fini_by_devmap_handle(devmap_handle);
    1023                 return ENOMEM;
     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        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    10491077        fs_node_t *fn;
    10501078        fat_node_t *nodep;
    … …  
    10521080
    10531081        rc = fat_root_get(&fn, devmap_handle);
    1054         if (rc != EOK)
    1055                 return rc;
     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       
    … …  
    10811112        block_fini(devmap_handle);
    10821113
    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 {
     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        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));
    10901133        fs_node_t *fn;
    10911134        fat_node_t *nodep;
    … …  
    10961139
    10971140        rc = fat_node_get(&fn, devmap_handle, index);
    1098         if (rc != EOK)
    1099                 return rc;
    1100         if (!fn)
    1101                 return ENOENT;
     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;
     1156                async_answer_0(rid, EINVAL);
     1157                return;
    11101158        }
    11111159
    … …  
    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        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));
    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;
    … …  
    12261278       
    12271279        rc = fat_node_get(&fn, devmap_handle, index);
    1228         if (rc != EOK)
    1229                 return rc;
    1230         if (!fn)
    1231                 return ENOENT;
     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;
     1295                async_answer_0(rid, EINVAL);
     1296                return;
    12401297        }
    12411298
    … …  
    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                /*
    … …  
    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 */
    … …  
    13121373                        (void) fat_node_put(fn);
    13131374                        async_answer_0(callid, rc);
    1314                         return rc;
     1375                        async_answer_0(rid, rc);
     1376                        return;
    13151377                }
    13161378                rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
    … …  
    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,
    … …  
    13291392                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13301393                        (void) fat_node_put(fn);
    1331                         return rc;
     1394                        async_answer_0(rid, rc);
     1395                        return;
    13321396                }
    13331397                /*
    … …  
    13391403                        (void) fat_free_clusters(bs, devmap_handle, 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        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));
    13541422        fs_node_t *fn;
    13551423        fat_node_t *nodep;
    … …  
    13581426
    13591427        rc = fat_node_get(&fn, devmap_handle, index);
    1360         if (rc != EOK)
    1361                 return rc;
    1362         if (!fn)
    1363                 return ENOENT;
     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
    … …  
    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        devmap_handle_t devmap_handle = (devmap_handle_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;
    … …  
    14201495
    14211496        rc = fat_node_get(&fn, devmap_handle, index);
    1422         if (rc != EOK)
    1423                 return rc;
    1424         if (!fn)
    1425                 return ENOENT;
     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        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       
    14401532        fs_node_t *fn;
    14411533        int rc = fat_node_get(&fn, devmap_handle, index);
    1442         if (rc != EOK)
    1443                 return rc;
    1444         if (!fn)
    1445                 return ENOENT;
     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.