tests: fs: Add test of fs_mkfs

Test is added to common directory and used in LittleFS tests.

Signed-off-by: Franciszek Zdobylak <fzdobylak@internships.antmicro.com>

tests/subsys/fs/common/test_fs_mkfs.c

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2022 Antmicro
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/ztest.h>
+#include <zephyr/fs/fs.h>
+
+/* Mount point and paths must be provided by test runner. */
+extern struct fs_mount_t *fs_mkfs_mp;
+extern const int fs_mkfs_type;
+extern uintptr_t fs_mkfs_dev_id;
+extern int fs_mkfs_flags;
+extern const char *some_file_path;
+extern const char *other_dir_path;
+
+/* This test assumes that storage device is erased. */
+void test_fs_mkfs_simple(void)
+{
+	int ret = 0;
+
+	TC_PRINT("Mount with flag no format\n");
+	fs_mkfs_mp->flags = FS_MOUNT_FLAG_NO_FORMAT;
+	ret = fs_mount(fs_mkfs_mp);
+
+	if (fs_mkfs_mp->type == FS_LITTLEFS) {
+		zassert_equal(ret, -EILSEQ, "Expected EILSEQ got %d", ret);
+	} else if (fs_mkfs_mp->type == FS_FATFS) {
+		zassert_equal(ret, -ENODEV, "Expected ENODEV got %d", ret);
+	}
+
+	TC_PRINT("Try mkfs with RW access\n");
+	ret = fs_mkfs(fs_mkfs_type, fs_mkfs_dev_id, NULL, fs_mkfs_dev_id);
+	zassert_equal(ret, 0, "Expected successful mkfs (%d)", ret);
+
+	TC_PRINT("Mount created file system without formatting\n");
+	fs_mkfs_mp->flags = FS_MOUNT_FLAG_NO_FORMAT;
+	ret = fs_mount(fs_mkfs_mp);
+	zassert_equal(ret, 0, "Expected successful mount (%d)", ret);
+	ret = fs_unmount(fs_mkfs_mp);
+	zassert_equal(ret, 0, "Expected fs_unmount success (%d)", ret);
+}
+
+/* This test assumes that storage device is erased. */
+void test_fs_mkfs_ops(void)
+{
+	int ret = 0;
+	struct fs_file_t fs;
+	struct fs_dir_t dir;
+	struct fs_dirent entry;
+
+	fs_file_t_init(&fs);
+	fs_dir_t_init(&dir);
+
+	/* Format volume and add some files/dirs */
+	TC_PRINT("Mount to prepare tests\n");
+	fs_mkfs_mp->flags = 0;
+	ret = fs_mount(fs_mkfs_mp);
+	zassert_equal(ret, 0, "Expected success (%d)", ret);
+	TC_PRINT("Create some file\n");
+	ret = fs_open(&fs, some_file_path, FS_O_CREATE);
+	zassert_equal(ret, 0, "Expected success fs_open(FS_O_CREATE) (%d)",
+		      ret);
+	ret = fs_close(&fs);
+	zassert_equal(ret, 0, "Expected fs_close success (%d)", ret);
+	TC_PRINT("Create other directory\n");
+	ret = fs_mkdir(other_dir_path);
+	zassert_equal(ret, 0, "Expected fs_mkdir success (%d)", ret);
+	ret = fs_unmount(fs_mkfs_mp);
+	zassert_equal(ret, 0, "Expected fs_umount success (%d)", ret);
+
+	/* Format file system using fs_mkfs and check if it was formatted */
+	TC_PRINT("Try mkfs\n");
+	ret = fs_mkfs(fs_mkfs_type, fs_mkfs_dev_id, NULL, fs_mkfs_dev_id);
+	zassert_equal(ret, 0, "Expected successful format (%d)", ret);
+	fs_mkfs_mp->flags = FS_MOUNT_FLAG_NO_FORMAT;
+	ret = fs_mount(fs_mkfs_mp);
+	zassert_equal(ret, 0, "Expected successful mount (%d)", ret);
+	ret = fs_stat(some_file_path, &entry);
+	zassert_equal(ret, -ENOENT, "Expected ENOENT got %d", ret);
+	ret = fs_stat(other_dir_path, &entry);
+	zassert_equal(ret, -ENOENT, "Expected ENOENT got %d", ret);
+	TC_PRINT("Create some file\n");
+	ret = fs_open(&fs, some_file_path, FS_O_CREATE);
+	zassert_equal(ret, 0, "Expected success fs_open(FS_O_CREATE) (%d)",
+		      ret);
+	ret = fs_close(&fs);
+	zassert_equal(ret, 0, "Expected fs_close success (%d)", ret);
+	TC_PRINT("Create other directory\n");
+	ret = fs_mkdir(other_dir_path);
+	zassert_equal(ret, 0, "Expected fs_mkdir success (%d)", ret);
+	ret = fs_unmount(fs_mkfs_mp);
+	zassert_equal(ret, 0, "Expected fs_unmount success (%d)", ret);
+}

tests/subsys/fs/fat_fs_api/CMakeLists.txt

@@ -5,4 +5,7 @@ find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
 project(fat_fs_api)
 
 FILE(GLOB app_sources src/*.c)
-target_sources(app PRIVATE ${app_sources} ../common/test_fs_open_flags.c)
+target_sources(app PRIVATE
+  ${app_sources}
+  ../common/test_fs_open_flags.c
+  ../common/test_fs_mkfs.c)

tests/subsys/fs/fat_fs_api/prj.conf

@@ -1,4 +1,5 @@
 CONFIG_FILE_SYSTEM=y
+CONFIG_FILE_SYSTEM_MKFS=y
 CONFIG_LOG=y
 CONFIG_FAT_FILESYSTEM_ELM=y
 CONFIG_DISK_DRIVER_FLASH=y
@@ -6,3 +7,5 @@ CONFIG_SPI=y
 CONFIG_GPIO=y
 CONFIG_ZTEST=y
 CONFIG_ZTEST_NEW_API=y
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y

tests/subsys/fs/fat_fs_api/prj_lfn.conf

@@ -1,7 +1,10 @@
 CONFIG_FILE_SYSTEM=y
+CONFIG_FILE_SYSTEM_MKFS=y
 CONFIG_LOG=y
 CONFIG_FAT_FILESYSTEM_ELM=y
 CONFIG_FS_FATFS_LFN=y
 CONFIG_DISK_DRIVER_FLASH=y
 CONFIG_ZTEST=y
 CONFIG_ZTEST_NEW_API=y
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y

tests/subsys/fs/fat_fs_api/prj_native_posix.conf

@@ -1,6 +1,9 @@
 CONFIG_FILE_SYSTEM=y
+CONFIG_FILE_SYSTEM_MKFS=y
 CONFIG_LOG=y
 CONFIG_FAT_FILESYSTEM_ELM=y
 CONFIG_DISK_DRIVER_FLASH=y
 CONFIG_ZTEST=y
 CONFIG_ZTEST_NEW_API=y
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y

tests/subsys/fs/fat_fs_api/prj_native_posix_64.conf

@@ -1,6 +1,9 @@
 CONFIG_FILE_SYSTEM=y
+CONFIG_FILE_SYSTEM_MKFS=y
 CONFIG_LOG=y
 CONFIG_FAT_FILESYSTEM_ELM=y
 CONFIG_DISK_DRIVER_FLASH=y
 CONFIG_ZTEST=y
 CONFIG_ZTEST_NEW_API=y
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y

tests/subsys/fs/fat_fs_api/src/test_fat_mkfs.c

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2022 Antmicro
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+#include "test_fat.h"
+#include <ff.h>
+#include <zephyr/storage/flash_map.h>
+
+/* FatFs work area */
+static FATFS fat_fs;
+
+/* mounting info */
+static struct fs_mount_t fatfs_mnt = {
+	.type = FS_FATFS,
+	.mnt_point = "/NAND:",
+	.fs_data = &fat_fs,
+};
+
+void test_fs_mkfs_simple(void);
+void test_fs_mkfs_ops(void);
+
+struct fs_mount_t *fs_mkfs_mp = &fatfs_mnt;
+const int fs_mkfs_type = FS_FATFS;
+uintptr_t fs_mkfs_dev_id = (uintptr_t) "NAND:";
+int fs_mkfs_flags;
+const char *some_file_path = "/NAND:/SOME";
+const char *other_dir_path = "/NAND:/OTHER";
+
+static int wipe_partition(void)
+{
+	/* In this test the first partition on flash device is used for FAT */
+	unsigned int id = 0;
+	const struct flash_area *pfa;
+	int rc = flash_area_open(id, &pfa);
+
+	if (rc < 0) {
+		TC_PRINT("Error accessing flash area %u [%d]\n",
+			 id, rc);
+		return TC_FAIL;
+	}
+
+	TC_PRINT("Erasing %zu (0x%zx) bytes\n", pfa->fa_size, pfa->fa_size);
+	rc = flash_area_erase(pfa, 0, pfa->fa_size);
+	(void)flash_area_close(pfa);
+
+	if (rc < 0) {
+		TC_PRINT("Error wiping flash area %u [%d]\n",
+			 id, rc);
+		return TC_FAIL;
+	}
+
+	return TC_PASS;
+}
+
+ZTEST(fat_fs_mkfs, test_mkfs_simple)
+{
+	int ret;
+
+	ret = wipe_partition();
+	zassert_equal(ret, TC_PASS, "wipe partition failed %d", ret);
+
+	test_fs_mkfs_simple();
+}
+
+ZTEST(fat_fs_mkfs, test_mkfs_ops)
+{
+	int ret;
+
+	ret = wipe_partition();
+	zassert_equal(ret, TC_PASS, "wipe partition failed %d", ret);
+
+	test_fs_mkfs_ops();
+}
+
+static MKFS_PARM custom_cfg = {
+	.fmt = FM_ANY | FM_SFD,	/* Any suitable FAT */
+	.n_fat = 1,		/* One FAT fs table */
+	.align = 0,		/* Get sector size via diskio query */
+	.n_root = CONFIG_FS_FATFS_MAX_ROOT_ENTRIES,
+	.au_size = 0		/* Auto calculate cluster size */
+};
+
+ZTEST(fat_fs_mkfs, test_mkfs_custom)
+{
+	int ret;
+	struct fs_mount_t mp = fatfs_mnt;
+	struct fs_statvfs sbuf;
+
+	ret = wipe_partition();
+	zassert_equal(ret, 0, "wipe partition failed %d", ret);
+
+	ret = fs_mkfs(FS_FATFS, fs_mkfs_dev_id, &custom_cfg, 0);
+	zassert_equal(ret, 0, "mkfs failed %d", ret);
+
+
+	mp.flags = FS_MOUNT_FLAG_NO_FORMAT;
+	ret = fs_mount(&mp);
+	zassert_equal(ret, 0, "mount failed %d", ret);
+
+	ret = fs_statvfs(mp.mnt_point, &sbuf);
+	zassert_equal(ret, 0, "statvfs failed %d", ret);
+
+	TC_PRINT("statvfs: %lu %lu %lu %lu",
+			sbuf.f_bsize, sbuf.f_frsize, sbuf.f_blocks, sbuf.f_bfree);
+
+	ret = fs_unmount(&mp);
+	zassert_equal(ret, 0, "unmount failed %d", ret);
+}
+
+ZTEST_SUITE(fat_fs_mkfs, NULL, NULL, NULL, NULL, NULL);

tests/subsys/fs/littlefs/CMakeLists.txt

@@ -12,4 +12,7 @@ target_compile_definitions(app PRIVATE
 		BYPASS_FS_OPEN_FLAGS_LFS_ASSERT_CRASH
 		BYPASS_FS_OPEN_FLAGS_LFS_RW_IS_DEFAULT
 )
-target_sources(app PRIVATE ${app_sources} ../common/test_fs_open_flags.c)
+target_sources(app PRIVATE
+  ${app_sources}
+  ../common/test_fs_open_flags.c
+  ../common/test_fs_mkfs.c)

tests/subsys/fs/littlefs/prj.conf

@@ -1,4 +1,5 @@
 CONFIG_FILE_SYSTEM=y
+CONFIG_FILE_SYSTEM_MKFS=y
 CONFIG_FILE_SYSTEM_LITTLEFS=y
 CONFIG_ZTEST_NEW_API=y
 CONFIG_MAIN_STACK_SIZE=4096

tests/subsys/fs/littlefs/src/testfs_mkfs.c

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2022 Antmicro
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/ztest.h>
+#include <zephyr/fs/littlefs.h>
+#include "testfs_tests.h"
+#include "testfs_lfs.h"
+
+void test_fs_mkfs_ops(void);
+void test_fs_mkfs_simple(void);
+/* Using smallest partition for this tests as they do not write
+ * a lot of data, basically they just check flags.
+ */
+struct fs_mount_t *fs_mkfs_mp = &testfs_small_mnt;
+const int fs_mkfs_type = FS_LITTLEFS;
+uintptr_t fs_mkfs_dev_id;
+int fs_mkfs_flags;
+const char *some_file_path = "/sml/some";
+const char *other_dir_path = "/sml/other";
+
+static void cleanup(struct fs_mount_t *mp)
+{
+	TC_PRINT("Clean %s\n", mp->mnt_point);
+
+	zassert_equal(testfs_lfs_wipe_partition(mp), TC_PASS,
+		      "Failed to clean partition");
+}
+
+ZTEST(littlefs, test_fs_mkfs_simple_lfs)
+{
+	cleanup(fs_mkfs_mp);
+
+	fs_mkfs_dev_id = (uintptr_t) testfs_small_mnt.storage_dev;
+	test_fs_mkfs_simple();
+}
+
+ZTEST(littlefs, test_fs_mkfs_ops_lfs)
+{
+	cleanup(fs_mkfs_mp);
+
+	fs_mkfs_dev_id = (uintptr_t) testfs_small_mnt.storage_dev;
+	test_fs_mkfs_ops();
+}
+
+/* Custom config with doubled the prog size */
+FS_LITTLEFS_DECLARE_CUSTOM_CONFIG(custom_cfg,
+		CONFIG_FS_LITTLEFS_READ_SIZE,
+		CONFIG_FS_LITTLEFS_PROG_SIZE * 2,
+		CONFIG_FS_LITTLEFS_CACHE_SIZE,
+		CONFIG_FS_LITTLEFS_LOOKAHEAD_SIZE);
+
+ZTEST(littlefs, test_fs_mkfs_custom)
+{
+	int ret = 0;
+	struct fs_statvfs sbuf;
+	struct fs_mount_t mnt = testfs_small_mnt;
+
+	cleanup(fs_mkfs_mp);
+
+	ret = fs_mkfs(FS_LITTLEFS, (uintptr_t)testfs_small_mnt.storage_dev, &custom_cfg, 0);
+	zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
+
+	mnt.flags = FS_MOUNT_FLAG_NO_FORMAT;
+	mnt.fs_data = &custom_cfg;
+	ret = fs_mount(&mnt);
+	zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
+
+	ret = fs_statvfs(mnt.mnt_point, &sbuf);
+	zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
+
+	TC_PRINT("f_bsize= %lu", sbuf.f_bsize);
+	/* Prog size is returned in f_bsize field. */
+	zassert_equal(sbuf.f_bsize, 2 * CONFIG_FS_LITTLEFS_PROG_SIZE);
+
+	ret = fs_unmount(&mnt);
+	zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
+}