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


Ignore:
Timestamp:
2011-08-03T17:34:57Z (13 years ago)
Author:
Oleg Romanenko <romanenko.oleg@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1940326
Parents:
52a79081 (diff), 3fab770 (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 from mainline

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r52a79081 ra33f0a6  
    7070
    7171/** List of cached free FAT nodes. */
    72 static LIST_INITIALIZE(ffn_head);
     72static LIST_INITIALIZE(ffn_list);
    7373
    7474/*
    … …  
    8888static aoff64_t fat_size_get(fs_node_t *);
    8989static unsigned fat_lnkcnt_get(fs_node_t *);
    90 static char fat_plb_get_char(unsigned);
    9190static bool fat_is_directory(fs_node_t *);
    9291static bool fat_is_file(fs_node_t *node);
    … …  
    150149static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
    151150{
    152         link_t *lnk;
    153151        fat_node_t *nodep;
    154152        int rc;
    … …  
    162160restart:
    163161        fibril_mutex_lock(&ffn_mutex);
    164         for (lnk = ffn_head.next; lnk != &ffn_head; lnk = lnk->next) {
     162        list_foreach(ffn_list, lnk) {
    165163                nodep = list_get_instance(lnk, fat_node_t, ffn_link);
    166164                if (!fibril_mutex_trylock(&nodep->lock)) {
    … …  
    199197                free(nodep);
    200198
    201                 /* Need to restart because we changed the ffn_head list. */
     199                /* Need to restart because we changed ffn_list. */
    202200                goto restart;
    203201        }
    … …  
    214212
    215213        fibril_mutex_lock(&ffn_mutex);
    216         if (!list_empty(&ffn_head)) {
     214        if (!list_empty(&ffn_list)) {
    217215                /* Try to use a cached free node structure. */
    218216                fat_idx_t *idxp_tmp;
    219                 nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
     217                nodep = list_get_instance(list_first(&ffn_list), fat_node_t,
     218                    ffn_link);
    220219                if (!fibril_mutex_trylock(&nodep->lock))
    221220                        goto skip_cache;
    … …  
    464463                if (nodep->idx) {
    465464                        fibril_mutex_lock(&ffn_mutex);
    466                         list_append(&nodep->ffn_link, &ffn_head);
     465                        list_append(&nodep->ffn_link, &ffn_list);
    467466                        fibril_mutex_unlock(&ffn_mutex);
    468467                } else {
    … …  
    823822}
    824823
    825 char fat_plb_get_char(unsigned pos)
    826 {
    827         return fat_reg.plb_ro[pos % PLB_SIZE];
    828 }
    829 
    830824bool fat_is_directory(fs_node_t *fn)
    831825{
    … …  
    858852        .size_get = fat_size_get,
    859853        .lnkcnt_get = fat_lnkcnt_get,
    860         .plb_get_char = fat_plb_get_char,
    861854        .is_directory = fat_is_directory,
    862855        .is_file = fat_is_file,
    … …  
    865858
    866859/*
    867  * VFS operations.
     860 * FAT VFS_OUT operations.
    868861 */
    869862
    870 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    871 {
    872         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     863static int
     864fat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index,
     865    aoff64_t *size, unsigned *linkcnt)
     866{
    873867        enum cache_mode cmode;
    874868        fat_bs_t *bs;
    875 
    876         /* Accept the mount options */
    877         char *opts;
    878         int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    879 
    880         if (rc != EOK) {
    881                 async_answer_0(rid, rc);
    882                 return;
    883         }
     869        int rc;
    884870
    885871        /* Check for option enabling write through. */
    … …  
    889875                cmode = CACHE_MODE_WB;
    890876
    891         free(opts);
    892 
    893877        /* initialize libblock */
    894         rc = block_init(devmap_handle, BS_SIZE);
    895         if (rc != EOK) {
    896                 async_answer_0(rid, rc);
    897                 return;
    898         }
     878        rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
     879        if (rc != EOK)
     880                return rc;
    899881
    900882        /* prepare the boot block */
    … …  
    902884        if (rc != EOK) {
    903885                block_fini(devmap_handle);
    904                 async_answer_0(rid, rc);
    905                 return;
     886                return rc;
    906887        }
    907888
    … …  
    911892        if (BPS(bs) != BS_SIZE) {
    912893                block_fini(devmap_handle);
    913                 async_answer_0(rid, ENOTSUP);
    914                 return;
     894                return ENOTSUP;
    915895        }
    916896
    … …  
    919899        if (rc != EOK) {
    920900                block_fini(devmap_handle);
    921                 async_answer_0(rid, rc);
    922                 return;
     901                return rc;
    923902        }
    924903
    … …  
    928907                (void) block_cache_fini(devmap_handle);
    929908                block_fini(devmap_handle);
    930                 async_answer_0(rid, rc);
    931                 return;
     909                return rc;
    932910        }
    933911
    … …  
    936914                (void) block_cache_fini(devmap_handle);
    937915                block_fini(devmap_handle);
    938                 async_answer_0(rid, rc);
    939                 return;
     916                return rc;
    940917        }
    941918
    … …  
    946923                block_fini(devmap_handle);
    947924                fat_idx_fini_by_devmap_handle(devmap_handle);
    948                 async_answer_0(rid, ENOMEM);
    949                 return;
     925                return ENOMEM;
    950926        }
    951927
    … …  
    957933                block_fini(devmap_handle);
    958934                fat_idx_fini_by_devmap_handle(devmap_handle);
    959                 async_answer_0(rid, ENOMEM);
    960                 return;
     935                return ENOMEM;
    961936        }
    962937        fat_node_initialize(rootp);
    … …  
    969944                block_fini(devmap_handle);
    970945                fat_idx_fini_by_devmap_handle(devmap_handle);
    971                 async_answer_0(rid, ENOMEM);
    972                 return;
     946                return ENOMEM;
    973947        }
    974948        assert(ridxp->index == 0);
    … …  
    1004978        fibril_mutex_unlock(&ridxp->lock);
    1005979
    1006         async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    1007 }
    1008 
    1009 void fat_mount(ipc_callid_t rid, ipc_call_t *request)
    1010 {
    1011         libfs_mount(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1012 }
    1013 
    1014 void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    1015 {
    1016         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     980        *index = ridxp->index;
     981        *size = rootp->size;
     982        *linkcnt = rootp->lnkcnt;
     983
     984        return EOK;
     985}
     986
     987static int fat_unmounted(devmap_handle_t devmap_handle)
     988{
    1017989        fs_node_t *fn;
    1018990        fat_node_t *nodep;
    … …  
    1020992
    1021993        rc = fat_root_get(&fn, devmap_handle);
    1022         if (rc != EOK) {
    1023                 async_answer_0(rid, rc);
    1024                 return;
    1025         }
     994        if (rc != EOK)
     995                return rc;
    1026996        nodep = FAT_NODE(fn);
    1027997
    … …  
    10321002        if (nodep->refcnt != 2) {
    10331003                (void) fat_node_put(fn);
    1034                 async_answer_0(rid, EBUSY);
    1035                 return;
     1004                return EBUSY;
    10361005        }
    10371006
    … …  
    10521021        block_fini(devmap_handle);
    10531022
    1054         async_answer_0(rid, EOK);
    1055 }
    1056 
    1057 void fat_unmount(ipc_callid_t rid, ipc_call_t *request)
    1058 {
    1059         libfs_unmount(&fat_libfs_ops, rid, request);
    1060 }
    1061 
    1062 void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
    1063 {
    1064         libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1065 }
    1066 
    1067 void fat_read(ipc_callid_t rid, ipc_call_t *request)
    1068 {
    1069         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1070         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1071         aoff64_t pos =
    1072             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1023        return EOK;
     1024}
     1025
     1026static int
     1027fat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1028    size_t *rbytes)
     1029{
    10731030        fs_node_t *fn;
    10741031        fat_node_t *nodep;
    … …  
    10791036
    10801037        rc = fat_node_get(&fn, devmap_handle, index);
    1081         if (rc != EOK) {
    1082                 async_answer_0(rid, rc);
    1083                 return;
    1084         }
    1085         if (!fn) {
    1086                 async_answer_0(rid, ENOENT);
    1087                 return;
    1088         }
     1038        if (rc != EOK)
     1039                return rc;
     1040        if (!fn)
     1041                return ENOENT;
    10891042        nodep = FAT_NODE(fn);
    10901043
    … …  
    10941047                fat_node_put(fn);
    10951048                async_answer_0(callid, EINVAL);
    1096                 async_answer_0(rid, EINVAL);
    1097                 return;
     1049                return EINVAL;
    10981050        }
    10991051
    … …  
    11181070                                fat_node_put(fn);
    11191071                                async_answer_0(callid, rc);
    1120                                 async_answer_0(rid, rc);
    1121                                 return;
     1072                                return rc;
    11221073                        }
    11231074                        (void) async_data_read_finalize(callid,
    … …  
    11261077                        if (rc != EOK) {
    11271078                                fat_node_put(fn);
    1128                                 async_answer_0(rid, rc);
    1129                                 return;
     1079                                return rc;
    11301080                        }
    11311081                }
    … …  
    11551105                (void) fat_node_put(fn);
    11561106                async_answer_0(callid, rc);
    1157                 async_answer_0(rid, rc);
    1158                 return;
     1107                return rc;
    11591108
    11601109miss:
    … …  
    11641113                rc = fat_node_put(fn);
    11651114                async_answer_0(callid, rc != EOK ? rc : ENOENT);
    1166                 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    1167                 return;
     1115                *rbytes = 0;
     1116                return rc != EOK ? rc : ENOENT;
    11681117
    11691118hit:
    … …  
    11771126
    11781127        rc = fat_node_put(fn);
    1179         async_answer_1(rid, rc, (sysarg_t)bytes);
    1180 }
    1181 
    1182 void fat_write(ipc_callid_t rid, ipc_call_t *request)
    1183 {
    1184         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1185         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1186         aoff64_t pos =
    1187             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1128        *rbytes = bytes;
     1129        return rc;
     1130}
     1131
     1132static int
     1133fat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1134    size_t *wbytes, aoff64_t *nsize)
     1135{
    11881136        fs_node_t *fn;
    11891137        fat_node_t *nodep;
    11901138        fat_bs_t *bs;
    1191         size_t bytes, size;
     1139        size_t bytes;
    11921140        block_t *b;
    11931141        aoff64_t boundary;
    … …  
    11961144
    11971145        rc = fat_node_get(&fn, devmap_handle, index);
    1198         if (rc != EOK) {
    1199                 async_answer_0(rid, rc);
    1200                 return;
    1201         }
    1202         if (!fn) {
    1203                 async_answer_0(rid, ENOENT);
    1204                 return;
    1205         }
     1146        if (rc != EOK)
     1147                return rc;
     1148        if (!fn)
     1149                return ENOENT;
    12061150        nodep = FAT_NODE(fn);
    12071151
    … …  
    12111155                (void) fat_node_put(fn);
    12121156                async_answer_0(callid, EINVAL);
    1213                 async_answer_0(rid, EINVAL);
    1214                 return;
     1157                return EINVAL;
    12151158        }
    12161159
    … …  
    12401183                        (void) fat_node_put(fn);
    12411184                        async_answer_0(callid, rc);
    1242                         async_answer_0(rid, rc);
    1243                         return;
     1185                        return rc;
    12441186                }
    12451187                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
    … …  
    12471189                        (void) fat_node_put(fn);
    12481190                        async_answer_0(callid, rc);
    1249                         async_answer_0(rid, rc);
    1250                         return;
     1191                        return rc;
    12511192                }
    12521193                (void) async_data_write_finalize(callid,
    … …  
    12561197                if (rc != EOK) {
    12571198                        (void) fat_node_put(fn);
    1258                         async_answer_0(rid, rc);
    1259                         return;
     1199                        return rc;
    12601200                }
    12611201                if (pos + bytes > nodep->size) {
    … …  
    12631203                        nodep->dirty = true;    /* need to sync node */
    12641204                }
    1265                 size = nodep->size;
     1205                *wbytes = bytes;
     1206                *nsize = nodep->size;
    12661207                rc = fat_node_put(fn);
    1267                 async_answer_2(rid, rc, bytes, nodep->size);
    1268                 return;
     1208                return rc;
    12691209        } else {
    12701210                /*
    … …  
    12821222                        (void) fat_node_put(fn);
    12831223                        async_answer_0(callid, rc);
    1284                         async_answer_0(rid, rc);
    1285                         return;
     1224                        return rc;
    12861225                }
    12871226                /* zero fill any gaps */
    … …  
    12911230                        (void) fat_node_put(fn);
    12921231                        async_answer_0(callid, rc);
    1293                         async_answer_0(rid, rc);
    1294                         return;
     1232                        return rc;
    12951233                }
    12961234                rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
    … …  
    13001238                        (void) fat_node_put(fn);
    13011239                        async_answer_0(callid, rc);
    1302                         async_answer_0(rid, rc);
    1303                         return;
     1240                        return rc;
    13041241                }
    13051242                (void) async_data_write_finalize(callid,
    … …  
    13101247                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13111248                        (void) fat_node_put(fn);
    1312                         async_answer_0(rid, rc);
    1313                         return;
     1249                        return rc;
    13141250                }
    13151251                /*
    … …  
    13211257                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13221258                        (void) fat_node_put(fn);
    1323                         async_answer_0(rid, rc);
    1324                         return;
    1325                 }
    1326                 nodep->size = size = pos + bytes;
     1259                        return rc;
     1260                }
     1261                *nsize = nodep->size = pos + bytes;
     1262                rc = fat_node_put(fn);
    13271263                nodep->dirty = true;            /* need to sync node */
    1328                 rc = fat_node_put(fn);
    1329                 async_answer_2(rid, rc, bytes, size);
    1330                 return;
    1331         }
    1332 }
    1333 
    1334 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    1335 {
    1336         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1337         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1338         aoff64_t size =
    1339             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1264                *wbytes = bytes;
     1265                return rc;
     1266        }
     1267}
     1268
     1269static int
     1270fat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
     1271{
    13401272        fs_node_t *fn;
    13411273        fat_node_t *nodep;
    … …  
    13441276
    13451277        rc = fat_node_get(&fn, devmap_handle, index);
    1346         if (rc != EOK) {
    1347                 async_answer_0(rid, rc);
    1348                 return;
    1349         }
    1350         if (!fn) {
    1351                 async_answer_0(rid, ENOENT);
    1352                 return;
    1353         }
     1278        if (rc != EOK)
     1279                return rc;
     1280        if (!fn)
     1281                return ENOENT;
    13541282        nodep = FAT_NODE(fn);
    13551283
    … …  
    13951323out:
    13961324        fat_node_put(fn);
    1397         async_answer_0(rid, rc);
    1398         return;
    1399 }
    1400 
    1401 void fat_close(ipc_callid_t rid, ipc_call_t *request)
    1402 {
    1403         async_answer_0(rid, EOK);
    1404 }
    1405 
    1406 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    1407 {
    1408         devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
    1409         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     1325        return rc;
     1326}
     1327
     1328static int fat_close(devmap_handle_t devmap_handle, fs_index_t index)
     1329{
     1330        return EOK;
     1331}
     1332
     1333static int fat_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     1334{
    14101335        fs_node_t *fn;
    14111336        fat_node_t *nodep;
    … …  
    14131338
    14141339        rc = fat_node_get(&fn, devmap_handle, index);
    1415         if (rc != EOK) {
    1416                 async_answer_0(rid, rc);
    1417                 return;
    1418         }
    1419         if (!fn) {
    1420                 async_answer_0(rid, ENOENT);
    1421                 return;
    1422         }
     1340        if (rc != EOK)
     1341                return rc;
     1342        if (!fn)
     1343                return ENOENT;
    14231344
    14241345        nodep = FAT_NODE(fn);
    … …  
    14301351
    14311352        rc = fat_destroy_node(fn);
    1432         async_answer_0(rid, rc);
    1433 }
    1434 
    1435 void fat_open_node(ipc_callid_t rid, ipc_call_t *request)
    1436 {
    1437         libfs_open_node(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1438 }
    1439 
    1440 void fat_stat(ipc_callid_t rid, ipc_call_t *request)
    1441 {
    1442         libfs_stat(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1443 }
    1444 
    1445 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    1446 {
    1447         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1448         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1449 
     1353        return rc;
     1354}
     1355
     1356static int fat_sync(devmap_handle_t devmap_handle, fs_index_t index)
     1357{
    14501358        fs_node_t *fn;
    14511359        int rc = fat_node_get(&fn, devmap_handle, index);
    1452         if (rc != EOK) {
    1453                 async_answer_0(rid, rc);
    1454                 return;
    1455         }
    1456         if (!fn) {
    1457                 async_answer_0(rid, ENOENT);
    1458                 return;
    1459         }
     1360        if (rc != EOK)
     1361                return rc;
     1362        if (!fn)
     1363                return ENOENT;
    14601364
    14611365        fat_node_t *nodep = FAT_NODE(fn);
    … …  
    14651369
    14661370        fat_node_put(fn);
    1467         async_answer_0(rid, rc);
    1468 }
     1371        return rc;
     1372}
     1373
     1374vfs_out_ops_t fat_ops = {
     1375        .mounted = fat_mounted,
     1376        .unmounted = fat_unmounted,
     1377        .read = fat_read,
     1378        .write = fat_write,
     1379        .truncate = fat_truncate,
     1380        .close = fat_close,
     1381        .destroy = fat_destroy,
     1382        .sync = fat_sync,
     1383};
    14691384
    14701385/**
Note: See TracChangeset for help on using the changeset viewer.