4 files changed, 48 insertions(+), 11 deletions(-)

M module-vfs/drivers/src/purefs/fs/filesystem_littlefs.cpp
M module-vfs/drivers/src/thirdparty/littlefs/lfs_glue.cpp
M module-vfs/src/purefs/fs/filesystem.cpp
M module-vfs/tests/unittest_filesystem_littlefs.cpp

@@ 108,8 108,13 @@ namespace
         cfg->block_cycles   = 512;
         cfg->block_size     = 0; // Read later from superblock
         cfg->block_count    = 0; // Read later from super block
-        cfg->cache_size     = 32768;
         cfg->lookahead_size = 8192;
+        // TODO: Read lfs configuration from the superblock
+        cfg->block_size  = 4096;
+        cfg->read_size   = cfg->block_size;
+        cfg->prog_size   = cfg->block_size;
+        cfg->cache_size  = cfg->block_size;
+        cfg->block_count = 261887;
     }
 } // namespace
 

@@ 77,8 77,12 @@ namespace purefs::fs::drivers::littlefs::internal
                     LOG_ERROR("Partial offset not supported");
                     return LFS_ERR_IO;
                 }
-                const std::size_t lba_sz = (size * lfsc->block_size) / ctx->sector_size;
-                const auto err           = diskmm->read(ctx->disk_h, buffer, lba, lba_sz);
+                const std::size_t lba_sz = size / ctx->sector_size;
+                if (size % ctx->sector_size) {
+                    LOG_ERROR("Bounary read sz error");
+                    return LFS_ERR_IO;
+                }
+                const auto err = diskmm->read(ctx->disk_h, buffer, lba, lba_sz);
                 if (err) {
                     LOG_ERROR("Sector read error %i", err);
                 }


@@ 157,10 161,6 @@ namespace purefs::fs::drivers::littlefs::internal
             LOG_ERROR("Unable to get sector size %li", long(sect_size));
             return sect_size;
         }
-        if (sect_size % lfsc->block_size || lfsc->block_size < sect_size) {
-            LOG_ERROR("Sector size doesn't match block size");
-            return -ERANGE;
-        }
         auto ctx      = new lfs_io::io_context(diskmm, diskh, sect_size);
         lfsc->context = ctx;
         lfsc->read    = lfs_io::read;

@@ 120,11 120,11 @@ namespace purefs::fs
             LOG_ERROR("Unable to lock filesystem operation");
             return -EIO;
         }
+        const auto diskh    = mnti->second->disk();
         const auto umnt_ret = fsops->umount(mnti->second);
         if (umnt_ret) {
             return umnt_ret;
         }
-        const auto diskh = mnti->second->disk();
         if (diskh) {
             m_partitions.erase(std::string(diskh->name()));
         }

@@ 5,9 5,41 @@
 #include <purefs/fs/filesystem.hpp>
 #include <purefs/blkdev/disk_manager.hpp>
 #include <purefs/blkdev/disk_image.hpp>
-#include <purefs/fs/drivers/filesystem_vfat.hpp>
+#include <purefs/fs/drivers/filesystem_littlefs.hpp>
 #include <sys/statvfs.h>
 #include <sys/stat.h>
 
-TEST_CASE("Littlefs: Basic tests")
-{}
+namespace
+{
+    constexpr auto disk_image = "lfstest.img";
+}
+
+TEST_CASE("Littlefs: Basic mount and functionality")
+{
+    using namespace purefs;
+    auto dm   = std::make_shared<blkdev::disk_manager>();
+    auto disk = std::make_shared<blkdev::disk_image>(disk_image);
+    REQUIRE(disk);
+    REQUIRE(dm->register_device(disk, "emmc0") == 0);
+    purefs::fs::filesystem fscore(dm);
+    const auto vfs_vfat = std::make_shared<fs::drivers::filesystem_littlefs>();
+    REQUIRE(vfs_vfat->mount_count() == 0);
+    auto ret = fscore.register_filesystem("littlefs", vfs_vfat);
+    REQUIRE(ret == 0);
+    ret = fscore.mount("emmc0part0", "/sys", "littlefs");
+    REQUIRE(ret == 0);
+    REQUIRE(vfs_vfat->mount_count() == 1);
+    REQUIRE(fscore.umount("/ala") == -ENOENT);
+    ret = fscore.mount("emmc0part0", "/sys", "vfat");
+    REQUIRE(ret == -EBUSY);
+    ret = fscore.mount("emmc0part0", "/path", "vfat");
+    REQUIRE(ret == -EBUSY);
+    ret = fscore.umount("/sys");
+    REQUIRE(ret == 0);
+    REQUIRE(vfs_vfat->mount_count() == 0);
+    ret = fscore.mount("emmc0part0", "/path", "littlefs");
+    REQUIRE(ret == 0);
+    REQUIRE(vfs_vfat->mount_count() == 1);
+    ret = fscore.umount("/path");
+    REQUIRE(ret == 0);
+}