This is an automated email from the ASF dual-hosted git repository.
acassis pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git
The following commit(s) were added to refs/heads/master by this push:
new 9d8b92c481 fs/mnemofs: Autoformat
9d8b92c481 is described below
commit 9d8b92c4812f3299291527932e7acaf644816976
Author: Saurav Pal <[email protected]>
AuthorDate: Sat Aug 17 20:21:32 2024 +0000
fs/mnemofs: Autoformat
Mnemofs autoformat feature
Signed-off-by: Saurav Pal <[email protected]>
---
drivers/mtd/Kconfig | 22 +--
drivers/mtd/mtd_nandram.c | 8 +-
fs/mnemofs/mnemofs.c | 32 ++++-
fs/mnemofs/mnemofs.h | 22 +++
fs/mnemofs/mnemofs_blkalloc.c | 8 +-
fs/mnemofs/mnemofs_fsobj.c | 2 +-
fs/mnemofs/mnemofs_journal.c | 321 +++++++++++++-----------------------------
fs/mnemofs/mnemofs_lru.c | 4 +-
fs/mnemofs/mnemofs_master.c | 52 +++++--
9 files changed, 219 insertions(+), 252 deletions(-)
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index aa6f18eecf..7ed1aae7d5 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -313,16 +313,18 @@ config MTD_NAND_RAM_STATUS
int "Log status of virtual NAND Flash."
depends on MTD_NAND_RAM_DEBUG
default 3
- range 1 8
- ---help---
- 1 - Log every instruction.
- 2 - Log every 5 instructions.
- 3 - Log every 10 instructions.
- 4 - Log every 50 instructions.
- 5 - Log every 100 instructions.
- 6 - Log every 500 instructions.
- 7 - Log every 1000 instructions.
- 8 - Log every 5000 instructions.
+ range 1 10
+ ---help---
+ 1 - Log every instruction.
+ 2 - Log every 5 instructions.
+ 3 - Log every 10 instructions.
+ 4 - Log every 50 instructions.
+ 5 - Log every 100 instructions.
+ 6 - Log every 500 instructions.
+ 7 - Log every 1000 instructions.
+ 8 - Log every 5000 instructions.
+ 9 - Log every 10000 instructions.
+ 10 - Log every 50000 instructions.
endif #MTD_NAND_RAM
diff --git a/drivers/mtd/mtd_nandram.c b/drivers/mtd/mtd_nandram.c
index eeb1a477b2..1f4f4f2a8f 100644
--- a/drivers/mtd/mtd_nandram.c
+++ b/drivers/mtd/mtd_nandram.c
@@ -50,6 +50,8 @@
#define NAND_RAM_STATUS_6 500
#define NAND_RAM_STATUS_7 1000
#define NAND_RAM_STATUS_8 5000
+#define NAND_RAM_STATUS_9 10000
+#define NAND_RAM_STATUS_10 50000
#if CONFIG_MTD_NAND_RAM_DEBUG_LEVEL == 1
#define NAND_RAM_DEBUG_LEVEL NAND_RAM_DEBUG_1
@@ -75,6 +77,10 @@
#define NAND_RAM_STATUS_LEVEL NAND_RAM_STATUS_7
#elif CONFIG_MTD_NAND_RAM_STATUS == 8
#define NAND_RAM_STATUS_LEVEL NAND_RAM_STATUS_8
+#elif CONFIG_MTD_NAND_RAM_STATUS == 9
+#define NAND_RAM_STATUS_LEVEL NAND_RAM_STATUS_9
+#elif CONFIG_MTD_NAND_RAM_STATUS == 10
+#define NAND_RAM_STATUS_LEVEL NAND_RAM_STATUS_10
#endif /* CONFIG_MTD_NAND_RAM_STATUS */
#define NAND_RAM_LOG(str, ...) \
@@ -101,7 +107,7 @@
struct nand_ram_data_s
{
- uint8_t page[NAND_RAM_PAGE_SIZE / 8];
+ uint8_t page[NAND_RAM_PAGE_SIZE];
};
/* 512 B page spare scheme */
diff --git a/fs/mnemofs/mnemofs.c b/fs/mnemofs/mnemofs.c
index 2c022c85c8..bc4a609a3a 100644
--- a/fs/mnemofs/mnemofs.c
+++ b/fs/mnemofs/mnemofs.c
@@ -1578,21 +1578,39 @@ static int mnemofs_bind(FAR struct inode *driver, FAR
const void *data,
{
/* Found journal first block. */
- mfs_jrnl_init(sb, i);
+ ret = mfs_jrnl_init(sb, i);
+ if (predict_false(ret < 0))
+ {
+ goto errout_with_rwbuf;
+ }
+
+ finfo("Journal initialized.");
+
+ ret = mfs_mn_init(sb, i);
+ if (predict_false(ret < 0))
+ {
+ goto errout_with_rwbuf;
+ }
+
+ finfo("Master Node initialized.");
+
+ break;
}
}
if (predict_false(sb->mn.pg == 0))
{
format = true;
+ memset(&MFS_JRNL(sb), 0, sizeof(struct mfs_jrnl_state_s));
+ memset(&MFS_MN(sb), 0, sizeof(struct mfs_mn_s));
finfo("Device needs to formatted.\n");
}
else
{
finfo("Device already formatted.\n");
- mfs_ba_init(sb);
mfs_lru_init(sb);
+ mfs_ba_init(sb);
}
}
@@ -1613,13 +1631,13 @@ static int mnemofs_bind(FAR struct inode *driver, FAR
const void *data,
ret = mfs_jrnl_fmt(sb, &mnblk1, &mnblk2, &jrnl_blk);
if (predict_false(ret < 0))
{
- goto errout_with_sb;
+ goto errout_with_rwbuf;
}
ret = mfs_mn_fmt(sb, mnblk1, mnblk2, jrnl_blk);
if (predict_false(ret < 0))
{
- goto errout_with_sb;
+ goto errout_with_rwbuf;
}
finfo("Device formatted.\n");
@@ -1632,6 +1650,9 @@ static int mnemofs_bind(FAR struct inode *driver, FAR
const void *data,
finfo("Lock released.");
return ret;
+errout_with_rwbuf:
+ kmm_free(sb->rw_buf);
+
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
@@ -1677,6 +1698,7 @@ static int mnemofs_unbind(FAR void *handle, FAR struct
inode **driver,
mfs_jrnl_free(sb);
mfs_ba_free(sb);
+ kmm_free(sb->rw_buf);
kmm_free(sb);
finfo("Successfully unmounted mnemofs!");
@@ -2216,7 +2238,7 @@ errout_with_path:
nxmutex_unlock(&MFS_LOCK(sb));
errout:
- finfo("Ret %d", ret);
+ finfo("Ret %d.", ret);
return ret;
}
diff --git a/fs/mnemofs/mnemofs.h b/fs/mnemofs/mnemofs.h
index b977317595..3415c74ac1 100644
--- a/fs/mnemofs/mnemofs.h
+++ b/fs/mnemofs/mnemofs.h
@@ -164,6 +164,7 @@ struct mfs_mn_s
struct mfs_jrnl_state_s
{
+ mfs_t jrnl_start;
mfs_t mblk1;
mfs_t mblk2;
mfs_t n_logs;
@@ -595,6 +596,27 @@ int mfs_jrnl_flush(FAR struct mfs_sb_s * const sb);
bool mfs_jrnl_isempty(FAR const struct mfs_sb_s * const sb);
+struct mfs_jrnl_log_s
+{
+ /* A field denoting the size of the below elements is added here on-flash.
+ */
+
+ mfs_t depth;
+ mfs_t sz_new;
+ struct mfs_ctz_s loc_new;
+ struct timespec st_mtim_new;
+ struct timespec st_atim_new;
+ struct timespec st_ctim_new;
+ FAR struct mfs_path_s *path;
+ uint16_t hash;
+};
+
+int mfs_jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
+ FAR mfs_t *blkidx, FAR mfs_t *pg_in_blk,
+ FAR struct mfs_jrnl_log_s *log);
+
+void mfs_jrnl_log_free(FAR const struct mfs_jrnl_log_s * const log);
+
/* mnemofs_blkalloc.c */
/****************************************************************************
diff --git a/fs/mnemofs/mnemofs_blkalloc.c b/fs/mnemofs/mnemofs_blkalloc.c
index 7c127b4853..ff2cf80807 100644
--- a/fs/mnemofs/mnemofs_blkalloc.c
+++ b/fs/mnemofs/mnemofs_blkalloc.c
@@ -311,7 +311,7 @@ int mfs_ba_fmt(FAR struct mfs_sb_s * const sb)
/* MFS_BA(sb).k_del_elemsz = ((log + 7) & (-8)) / 8; */
MFS_BA(sb).k_del = kmm_zalloc(sizeof(size_t) * MFS_NBLKS(sb));
- if (!MFS_BA(sb).k_del)
+ if (predict_false(MFS_BA(sb).k_del == NULL))
{
ret = -ENOMEM;
goto errout;
@@ -320,12 +320,14 @@ int mfs_ba_fmt(FAR struct mfs_sb_s * const sb)
MFS_BA(sb).n_bmap_upgs = MFS_UPPER8(MFS_NPGS(sb));
MFS_BA(sb).bmap_upgs = kmm_zalloc(MFS_BA(sb).n_bmap_upgs);
- if (!MFS_BA(sb).bmap_upgs)
+ if (predict_false(MFS_BA(sb).bmap_upgs == NULL))
{
ret = -ENOMEM;
goto errout_with_k_del;
}
+ /* TODO: Do not start from journal blocks. */
+
finfo("mnemofs: Block Allocator initialized, starting at page %d.\n",
MFS_BLK2PG(sb, MFS_BA(sb).s_blk));
return ret;
@@ -357,6 +359,8 @@ int mfs_ba_init(FAR struct mfs_sb_s * const sb)
goto errout_with_ba;
}
+ return ret;
+
errout_with_ba:
mfs_ba_free(sb);
diff --git a/fs/mnemofs/mnemofs_fsobj.c b/fs/mnemofs/mnemofs_fsobj.c
index 121c15aa41..60153e2810 100644
--- a/fs/mnemofs/mnemofs_fsobj.c
+++ b/fs/mnemofs/mnemofs_fsobj.c
@@ -1054,7 +1054,7 @@ int mfs_pitr_traversefs(FAR struct mfs_sb_s * sb, const
struct mfs_ctz_s ctz,
path[0].ctz = MFS_MN(sb).root_ctz;
path[0].sz = MFS_MN(sb).root_sz;
- ret = pitr_traverse(sb, path, 0, &capacity);
+ ret = pitr_traverse(sb, path, 1, &capacity);
mfs_free_patharr(path);
diff --git a/fs/mnemofs/mnemofs_journal.c b/fs/mnemofs/mnemofs_journal.c
index a62214a82f..242cbd1a39 100644
--- a/fs/mnemofs/mnemofs_journal.c
+++ b/fs/mnemofs/mnemofs_journal.c
@@ -102,34 +102,13 @@
* search methods of higher functions.
*/
-/* New journal log structure being phased in. */
-
-struct jrnl_log_s
-{
- /* A field denoting the size of the below elements is added here on-flash.
- */
-
- mfs_t depth;
- mfs_t sz_new;
- struct mfs_ctz_s loc_new;
- struct timespec st_mtim_new;
- struct timespec st_atim_new;
- struct timespec st_ctim_new;
- FAR struct mfs_path_s *path;
- uint16_t hash;
-};
-
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
-static int jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
- FAR mfs_t *blkidx, FAR mfs_t *pg_in_blk,
- FAR struct jrnl_log_s *log);
-
FAR static const char *deser_log(FAR const char * const in,
- FAR struct jrnl_log_s * const x);
-FAR static char *ser_log(FAR const struct jrnl_log_s * const x,
+ FAR struct mfs_jrnl_log_s * const x);
+FAR static char *ser_log(FAR const struct mfs_jrnl_log_s * const x,
FAR char * const out);
/****************************************************************************
@@ -145,7 +124,7 @@ FAR static char *ser_log(FAR const struct jrnl_log_s
* const x,
****************************************************************************/
/****************************************************************************
- * Name: jrnl_rdlog
+ * Name: mfs_jrnl_rdlog
*
* Description:
* Read a log to the journal from given location, and update location to
@@ -175,21 +154,16 @@ FAR static char *ser_log(FAR const struct
jrnl_log_s * const x,
*
****************************************************************************/
-static int jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
+int mfs_jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
FAR mfs_t *blkidx, FAR mfs_t *pg_in_blk,
- FAR struct jrnl_log_s *log)
+ FAR struct mfs_jrnl_log_s *log)
{
int ret = OK;
char tmp[4];
- mfs_t i;
- mfs_t len;
- mfs_t n_pgs;
- mfs_t rd_sz;
mfs_t log_sz;
mfs_t jrnl_pg;
mfs_t jrnl_blk;
FAR char *buf = NULL;
- FAR char *buftmp = NULL;
DEBUGASSERT(*pg_in_blk % MFS_PGSZ(sb) == 0);
@@ -205,7 +179,11 @@ static int jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
}
mfs_deser_mfs(tmp, &log_sz);
- n_pgs = MFS_CEILDIVIDE(log_sz, MFS_PGSZ(sb));
+ if (log_sz == 0)
+ {
+ ret = -ENOSPC;
+ goto errout;
+ }
buf = kmm_zalloc(log_sz);
if (predict_false(buf == NULL))
@@ -214,74 +192,27 @@ static int jrnl_rdlog(FAR const struct mfs_sb_s *const sb,
goto errout;
}
- buftmp = buf;
- rd_sz = 0;
- for (i = 0; i < n_pgs && rd_sz < log_sz; i++)
+ ret = mfs_read_page(sb, buf, log_sz, jrnl_pg, 4);
+ if (predict_false(ret < 0))
{
- /* This if-statement exists to remove calculation behind
- * MIN(MFS_PGSZ(sb), log_sz - rd_sz)
- */
-
- if (i == 0 && i != n_pgs - 1)
- {
- ret = mfs_read_page(sb, buftmp, MFS_PGSZ(sb), jrnl_pg,
- sizeof(mfs_t));
- len = MFS_PGSZ(sb);
- }
- else if (i == 0)
- {
- ret = mfs_read_page(sb, buftmp, log_sz, jrnl_pg, sizeof(mfs_t));
- len = log_sz;
- }
- else if (i == n_pgs - 1)
- {
- ret = mfs_read_page(sb, buftmp, log_sz - rd_sz, jrnl_pg, 0);
- len = log_sz - rd_sz;
- }
- else
- {
- ret = mfs_read_page(sb, buftmp, MFS_PGSZ(sb), jrnl_pg, 0);
- len = MFS_PGSZ(sb);
- }
-
- buftmp += len;
- rd_sz += len;
-
- if (predict_false(ret == 0))
- {
- ret = -EINVAL; /* TODO: Need to check when this occurs. */
- goto errout_with_buf;
- }
-
- /* Move to next block if needed. */
-
- jrnl_pg++;
- if (jrnl_pg - MFS_BLK2PG(sb, jrnl_blk) >= MFS_PGINBLK(sb))
- {
- (*blkidx)++;
-
- if (*blkidx >= MFS_JRNL(sb).n_blks)
- {
- /* Not finished reading log yet, and the journal is over. */
-
- ret = -ENOSPC;
- goto errout_with_buf;
- }
-
- jrnl_blk = mfs_jrnl_blkidx2blk(sb, *blkidx);
- jrnl_pg = MFS_BLK2PG(sb, jrnl_blk);
- }
+ goto errout_with_buf;
}
+ ret = OK;
+
if (predict_false(deser_log(buf, log) == NULL))
{
ret = -ENOMEM;
goto errout_with_buf;
}
- /* blkidx has been up to date throughout the program. */
+ (*pg_in_blk)++;
- *pg_in_blk = jrnl_pg - MFS_BLK2PG(sb, jrnl_blk);
+ if (*pg_in_blk >= MFS_PGINBLK(sb))
+ {
+ *pg_in_blk = 0;
+ (*blkidx)++;
+ }
errout_with_buf:
kmm_free(buf);
@@ -310,7 +241,7 @@ errout:
*
****************************************************************************/
-FAR static char *ser_log(FAR const struct jrnl_log_s * const x,
+FAR static char *ser_log(FAR const struct mfs_jrnl_log_s * const x,
FAR char * const out)
{
char *o = out;
@@ -352,7 +283,7 @@ FAR static char *ser_log(FAR const struct jrnl_log_s *
const x,
****************************************************************************/
FAR static const char *deser_log(FAR const char * const in,
- FAR struct jrnl_log_s * const x)
+ FAR struct mfs_jrnl_log_s * const x)
{
mfs_t k = 0;
const char *i = in;
@@ -366,7 +297,7 @@ FAR static const char *deser_log(FAR const char * const in,
/* Allocates path. Deallocate using mfs_jrnl_log_free. */
- x->path = kmm_zalloc(sizeof(struct jrnl_log_s) * x->depth);
+ x->path = kmm_zalloc(sizeof(struct mfs_jrnl_log_s) * x->depth);
if (predict_false(x->path == NULL))
{
return NULL;
@@ -382,7 +313,7 @@ FAR static const char *deser_log(FAR const char * const in,
}
/****************************************************************************
- * Name: jrnl_log_free
+ * Name: mfs_jrnl_log_free
*
* Description:
* Free the log.
@@ -395,7 +326,7 @@ FAR static const char *deser_log(FAR const char * const in,
*
****************************************************************************/
-static void jrnl_log_free(FAR const struct jrnl_log_s * const log)
+void mfs_jrnl_log_free(FAR const struct mfs_jrnl_log_s * const log)
{
free(log->path);
}
@@ -406,18 +337,17 @@ static void jrnl_log_free(FAR const struct jrnl_log_s *
const log)
int mfs_jrnl_init(FAR struct mfs_sb_s * const sb, mfs_t blk)
{
- char buftmp[2];
- int ret = OK;
- mfs_t sz;
- mfs_t blkidx;
- mfs_t pg_in_blk;
- FAR char *buf = NULL;
- FAR struct jrnl_log_s *log = NULL;
+ char buftmp[2];
+ int ret = OK;
+ mfs_t sz;
+ mfs_t blkidx;
+ mfs_t pg_in_blk;
+ struct mfs_jrnl_log_s log;
/* Magic sequence is already used to find the block, so not required. */
mfs_read_page(sb, buftmp, 2, MFS_BLK2PG(sb, blk), 8);
- mfs_deser_16(buf, &MFS_JRNL(sb).n_blks);
+ mfs_deser_16(buftmp, &MFS_JRNL(sb).n_blks);
if (MFS_JRNL(sb).n_blks == 0)
{
@@ -427,11 +357,12 @@ int mfs_jrnl_init(FAR struct mfs_sb_s * const sb, mfs_t
blk)
sz = MFS_JRNL_SUFFIXSZ + ((CONFIG_MNEMOFS_JOURNAL_NBLKS + 2) * 4);
+ MFS_JRNL(sb).jrnl_start = blk;
MFS_JRNL(sb).log_cpg = (sz + (MFS_PGSZ(sb) - 1)) / MFS_PGSZ(sb);
MFS_JRNL(sb).log_spg = MFS_JRNL(sb).log_cpg;
MFS_JRNL(sb).log_cblkidx = 0;
MFS_JRNL(sb).log_sblkidx = MFS_JRNL(sb).log_cblkidx;
- MFS_JRNL(sb).jrnlarr_pg = 0;
+ MFS_JRNL(sb).jrnlarr_pg = MFS_BLK2PG(sb, blk); /* Assuming pgsz > 10 */
MFS_JRNL(sb).jrnlarr_pgoff = MFS_JRNL_SUFFIXSZ;
/* Number of logs */
@@ -442,9 +373,7 @@ int mfs_jrnl_init(FAR struct mfs_sb_s * const sb, mfs_t blk)
while (true)
{
- /* TODO: Update this to new read log. */
-
- ret = jrnl_rdlog(sb, &blkidx, &pg_in_blk, log);
+ ret = mfs_jrnl_rdlog(sb, &blkidx, &pg_in_blk, &log);
if (predict_false(ret < 0 && ret != -ENOSPC))
{
goto errout;
@@ -460,14 +389,14 @@ int mfs_jrnl_init(FAR struct mfs_sb_s * const sb, mfs_t
blk)
* depth of 1.
*/
- if (!log || log->depth == 0)
+ if (log.depth == 0)
{
- DEBUGASSERT(!log || log->path == NULL);
+ DEBUGASSERT(log.path == NULL);
break;
}
MFS_JRNL(sb).n_logs++;
- jrnl_log_free(log);
+ mfs_jrnl_log_free(&log);
}
/* Master node */
@@ -486,21 +415,20 @@ errout:
int mfs_jrnl_fmt(FAR struct mfs_sb_s * const sb, FAR mfs_t *blk1,
FAR mfs_t *blk2, FAR mfs_t *jrnl_blk)
{
- int i;
- int ret = OK;
- mfs_t sz;
- mfs_t pg;
- mfs_t blk;
- mfs_t n_pgs;
- mfs_t rem_sz;
- mfs_t alloc_blk;
+ int i;
+ int ret = OK;
+ mfs_t sz;
+ mfs_t pg;
+ mfs_t blk;
+ mfs_t alloc_blk;
FAR char *tmp;
FAR char *buf = NULL;
+ /* TODO: Replace jrnl_blk with MFS_JRNL(sb).jrnl_start if possible. */
+
/* Write magic sequence, size of jrnlarr, and then the jrnlarr. */
sz = MFS_JRNL_SUFFIXSZ + ((CONFIG_MNEMOFS_JOURNAL_NBLKS + 2) * 4);
- n_pgs = (sz + (MFS_PGSZ(sb) - 1)) / MFS_PGSZ(sb);
buf = kmm_zalloc(sz);
if (predict_false(buf == NULL))
@@ -542,7 +470,9 @@ int mfs_jrnl_fmt(FAR struct mfs_sb_s * const sb, FAR mfs_t
*blk1,
if (predict_false(i == 0))
{
- blk = alloc_blk;
+ blk = alloc_blk;
+ *jrnl_blk = alloc_blk;
+ MFS_JRNL(sb).jrnl_start = alloc_blk;
}
finfo("Allocated Journal Block %d at Block %d.", i, alloc_blk);
@@ -553,22 +483,13 @@ int mfs_jrnl_fmt(FAR struct mfs_sb_s * const sb, FAR
mfs_t *blk1,
finfo("All Journal Blocks allocated.");
- tmp = buf;
pg = MFS_BLK2PG(sb, blk);
- for (i = 0; i < n_pgs; i++)
+ ret = mfs_write_page(sb, buf, sz, pg, 0); /* Assuming array fits in a
+ * single page.
+ */
+ if (predict_false(ret < 0))
{
- rem_sz = MIN(MFS_PGSZ(sb), buf + sz - tmp);
- ret = mfs_write_page(sb, tmp, rem_sz, pg, 0);
- if (predict_false(ret < 0))
- {
- goto errout_with_buf;
- }
-
- pg++;
-
- DEBUGASSERT(pg < MFS_BLK2PG(sb, blk) + MFS_PGINBLK(sb));
-
- tmp += rem_sz;
+ goto errout_with_buf;
}
ret = OK; /* We reach here, we OK. */
@@ -577,7 +498,7 @@ int mfs_jrnl_fmt(FAR struct mfs_sb_s * const sb, FAR mfs_t
*blk1,
MFS_JRNL(sb).n_logs = 0;
MFS_JRNL(sb).n_blks = CONFIG_MNEMOFS_JOURNAL_NBLKS;
- MFS_JRNL(sb).log_cpg = pg;
+ MFS_JRNL(sb).log_cpg = pg + 1; /* Assumes 1 page for jrnl_arr. */
MFS_JRNL(sb).log_cblkidx = 0;
MFS_JRNL(sb).log_spg = MFS_JRNL(sb).log_cpg;
MFS_JRNL(sb).log_sblkidx = MFS_JRNL(sb).log_cblkidx;
@@ -595,7 +516,12 @@ errout:
void mfs_jrnl_free(FAR struct mfs_sb_s * const sb)
{
- mfs_jrnl_flush(sb);
+ if (!mfs_jrnl_isempty(sb) &&
+ MFS_JRNL(sb).log_cblkidx >= MFS_JRNL_LIM(sb))
+ {
+ mfs_jrnl_flush(sb);
+ }
+
finfo("Journal Freed.");
}
@@ -609,10 +535,9 @@ mfs_t mfs_jrnl_blkidx2blk(FAR const struct mfs_sb_s *
const sb,
mfs_t pgoff;
char buf[4];
- pg = MFS_JRNL(sb).jrnlarr_pg;
- pgoff = MFS_JRNL(sb).jrnlarr_pgoff;
- blk = MFS_PG2BLK(sb, pg);
-
+ pg = MFS_JRNL(sb).jrnlarr_pg;
+ pgoff = MFS_JRNL(sb).jrnlarr_pgoff;
+ blk = MFS_PG2BLK(sb, pg);
pgoff += blk_idx * 4;
if (pgoff > MFS_PGSZ(sb))
@@ -644,11 +569,11 @@ int mfs_jrnl_updatedinfo(FAR const struct mfs_sb_s *
const sb,
FAR struct mfs_path_s * const path,
const mfs_t depth)
{
- int ret = OK;
- mfs_t blkidx;
- mfs_t counter = 0;
- mfs_t pg_in_block;
- struct jrnl_log_s tmplog;
+ int ret = OK;
+ mfs_t blkidx;
+ mfs_t counter = 0;
+ mfs_t pg_in_block;
+ struct mfs_jrnl_log_s tmplog;
/* TODO: Allow optional filling of updated timestamps, etc. */
@@ -659,7 +584,7 @@ int mfs_jrnl_updatedinfo(FAR const struct mfs_sb_s * const
sb,
while (blkidx < MFS_JRNL(sb).n_blks && counter < MFS_JRNL(sb).n_logs)
{
- ret = jrnl_rdlog(sb, &blkidx, &pg_in_block, &tmplog);
+ ret = mfs_jrnl_rdlog(sb, &blkidx, &pg_in_block, &tmplog);
if (predict_false(ret < 0 && ret != -ENOSPC))
{
goto errout;
@@ -687,7 +612,7 @@ int mfs_jrnl_updatedinfo(FAR const struct mfs_sb_s * const
sb,
}
}
- jrnl_log_free(&tmplog);
+ mfs_jrnl_log_free(&tmplog);
counter++;
}
@@ -699,16 +624,13 @@ int mfs_jrnl_wrlog(FAR struct mfs_sb_s * const sb,
FAR const struct mfs_node_s *node,
const struct mfs_ctz_s loc_new, const mfs_t sz_new)
{
- int ret = OK;
- mfs_t i;
- mfs_t n_pgs;
- mfs_t wr_sz;
- mfs_t jrnl_pg;
- mfs_t jrnl_blk;
- FAR char *buf = NULL;
- FAR char *tmp = NULL;
- const mfs_t log_sz = sizeof(mfs_t) + MFS_LOGSZ(node->depth);
- struct jrnl_log_s log;
+ int ret = OK;
+ mfs_t jrnl_pg;
+ mfs_t jrnl_blk;
+ FAR char *buf = NULL;
+ FAR char *tmp = NULL;
+ const mfs_t log_sz = sizeof(mfs_t) + MFS_LOGSZ(node->depth);
+ struct mfs_jrnl_log_s log;
buf = kmm_zalloc(log_sz); /* For size before log. */
if (predict_false(buf == NULL))
@@ -733,70 +655,26 @@ int mfs_jrnl_wrlog(FAR struct mfs_sb_s * const sb,
/* Store */
- n_pgs = MFS_CEILDIVIDE(log_sz, MFS_PGSZ(sb));
jrnl_blk = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).log_cblkidx);
jrnl_pg = MFS_JRNL(sb).log_cpg;
- tmp = buf;
- wr_sz = 0;
- for (i = 0; i < n_pgs && wr_sz < log_sz; i++)
- {
- /* This if-statement exists to remove calculation behind
- * MIN(MFS_PGSZ(sb), log_sz - wr_sz)
- */
- if (i == 0 && i == n_pgs - 1)
- {
- ret = mfs_write_page(sb, tmp, log_sz, jrnl_pg, 0);
- wr_sz += log_sz;
- tmp += log_sz;
- }
- else if (i == 0)
- {
- ret = mfs_write_page(sb, tmp, MFS_PGSZ(sb), jrnl_pg, 0);
- wr_sz += MFS_PGSZ(sb);
- tmp += MFS_PGSZ(sb);
- }
- else if (i == n_pgs - 1)
- {
- ret = mfs_write_page(sb, tmp, log_sz - wr_sz, jrnl_pg, 0);
- wr_sz += MFS_PGSZ(sb);
- tmp += MFS_PGSZ(sb);
- }
- else
- {
- ret = mfs_write_page(sb, tmp, MFS_PGSZ(sb), jrnl_pg, 0);
- wr_sz += MFS_PGSZ(sb);
- tmp += MFS_PGSZ(sb);
- }
-
- if (predict_false(ret == 0))
- {
- ret = -EINVAL;
- goto errout_with_buf;
- }
+ /* TODO: It assumes it takes only one page per log. */
- /* Move to next block if needed. */
-
- jrnl_pg++;
- if (jrnl_pg - MFS_BLK2PG(sb, jrnl_blk) == MFS_PGINBLK(sb))
- {
- MFS_JRNL(sb).log_cblkidx++;
+ ret = mfs_write_page(sb, buf, log_sz, jrnl_pg, 0);
+ if (predict_false(ret < 0))
+ {
+ goto errout_with_buf;
+ }
- if (MFS_JRNL(sb).log_cblkidx == MFS_JRNL(sb).n_blks)
- {
- /* Not finished reading log yet, and the journal is over. */
+ ret = OK;
- ret = -ENOSPC;
- goto errout_with_buf;
- }
+ jrnl_pg++;
- jrnl_blk = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).log_cblkidx);
- jrnl_pg = MFS_BLK2PG(sb, jrnl_blk);
- }
+ if (jrnl_pg % MFS_PGINBLK(sb) == 0)
+ {
+ MFS_JRNL(sb).log_cblkidx++;
}
- /* MFS_JRNL(sb).log_cblkidx is up to date */
-
MFS_JRNL(sb).log_cpg = jrnl_pg;
MFS_JRNL(sb).n_logs++;
@@ -852,15 +730,15 @@ int mfs_jrnl_flush(FAR struct mfs_sb_s * const sb)
mfs_t i;
mfs_t jrnl_blk;
mfs_t blk;
- struct jrnl_log_s log;
- struct jrnl_log_s tmp_log;
+ struct mfs_jrnl_log_s log;
+ struct mfs_jrnl_log_s tmp_log;
FAR struct mfs_path_s *path = NULL;
struct mfs_jrnl_state_s j_state;
struct mfs_mn_s mn_state;
while (log_itr < MFS_JRNL(sb).n_logs)
{
- ret = jrnl_rdlog(sb, &blkidx, &pg_in_blk, &log);
+ ret = mfs_jrnl_rdlog(sb, &blkidx, &pg_in_blk, &log);
if (predict_false(ret < 0))
{
DEBUGASSERT(ret != -ENOSPC); /* While condition is sufficient. */
@@ -888,27 +766,28 @@ int mfs_jrnl_flush(FAR struct mfs_sb_s * const sb)
for (; ; )
{
- ret = jrnl_rdlog(sb, &tmp_blkidx, &tmp_pg_in_blk, &tmp_log);
+ ret = mfs_jrnl_rdlog(sb, &tmp_blkidx, &tmp_pg_in_blk, &tmp_log);
if (ret == -ENOSPC)
{
break;
}
else if (predict_false(ret < 0))
{
- jrnl_log_free(&log);
+ mfs_jrnl_log_free(&log);
+ mfs_free_patharr(path);
goto errout;
}
if (tmp_log.depth > log.depth)
{
- jrnl_log_free(&tmp_log);
+ mfs_jrnl_log_free(&tmp_log);
continue;
}
if (!mfs_path_eq(&path[tmp_log.depth - 1],
&tmp_log.path[tmp_log.depth - 1]))
{
- jrnl_log_free(&tmp_log);
+ mfs_jrnl_log_free(&tmp_log);
continue;
}
@@ -937,13 +816,13 @@ int mfs_jrnl_flush(FAR struct mfs_sb_s * const sb)
if (predict_false(ret < 0))
{
mfs_free_patharr(path);
- jrnl_log_free(&log);
+ mfs_jrnl_log_free(&log);
goto errout;
}
}
mfs_free_patharr(path);
- jrnl_log_free(&log);
+ mfs_jrnl_log_free(&log);
}
if (MFS_MN(sb).mblk_idx == MFS_PGINBLK(sb))
diff --git a/fs/mnemofs/mnemofs_lru.c b/fs/mnemofs/mnemofs_lru.c
index bfd310ce01..cda3cee5c1 100644
--- a/fs/mnemofs/mnemofs_lru.c
+++ b/fs/mnemofs/mnemofs_lru.c
@@ -286,8 +286,8 @@ static void lru_free_delta(FAR struct mfs_delta_s *delta)
* (false).
*
* Returned Value:
- * 0 - OK
- * < 0 - Error
+ * 0 - OK
+ * < 0 - Error
*
****************************************************************************/
diff --git a/fs/mnemofs/mnemofs_master.c b/fs/mnemofs/mnemofs_master.c
index 517df69a6f..d2a69c42a0 100644
--- a/fs/mnemofs/mnemofs_master.c
+++ b/fs/mnemofs/mnemofs_master.c
@@ -195,16 +195,19 @@ int mfs_mn_init(FAR struct mfs_sb_s * const sb, const
mfs_t jrnl_blk)
mfs_t mblk1;
mfs_t mblk2;
mfs_t jrnl_blk_tmp;
+ mfs_t blkidx;
+ mfs_t pg_in_blk;
bool found = false;
uint16_t hash;
struct mfs_mn_s mn;
const mfs_t sz = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
char buftmp[4];
char buf[sz + 1];
+ struct mfs_jrnl_log_s log;
mblk1 = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).n_blks);
mblk2 = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).n_blks + 1);
- mn.jrnl_blk = mn.jrnl_blk;
+ mn.jrnl_blk = jrnl_blk;
mn.mblk_idx = 0;
mn.pg = MFS_BLK2PG(sb, mblk1);
@@ -218,11 +221,6 @@ int mfs_mn_init(FAR struct mfs_sb_s * const sb, const
mfs_t jrnl_blk)
break;
}
- if (jrnl_blk_tmp != jrnl_blk)
- {
- break;
- }
-
found = true;
mn.mblk_idx++;
mn.pg++;
@@ -245,9 +243,6 @@ int mfs_mn_init(FAR struct mfs_sb_s * const sb, const mfs_t
jrnl_blk)
}
mfs_read_page(sb, buf, sz + 1, mn.pg, 0);
-
- /* Deserialize. */
-
deser_mn(buf, &mn, &hash);
if (hash != mfs_hash(buf, sz))
{
@@ -255,12 +250,49 @@ int mfs_mn_init(FAR struct mfs_sb_s * const sb, const
mfs_t jrnl_blk)
goto errout;
}
+ blkidx = MFS_JRNL(sb).log_sblkidx;
+ pg_in_blk = MFS_JRNL(sb).log_spg % MFS_PGINBLK(sb);
+
+ while (true)
+ {
+ ret = mfs_jrnl_rdlog(sb, &blkidx, &pg_in_blk, &log);
+ if (predict_false(ret < 0 && ret != -ENOSPC))
+ {
+ goto errout;
+ }
+ else if (ret == -ENOSPC)
+ {
+ ret = OK;
+ break;
+ }
+
+ /* Assumes checking the depth is enough to check if it's empty, as
+ * theoretically there are no blocks with depth 0, as root has a
+ * depth of 1.
+ */
+
+ if (log.depth == 0)
+ {
+ DEBUGASSERT(log.path == NULL);
+ break;
+ }
+
+ if (log.depth == 1)
+ {
+ mn.root_ctz = log.loc_new;
+ mn.root_sz = log.sz_new;
+ }
+
+ mfs_jrnl_log_free(&log);
+ }
+
/* FUTURE TODO: Recovery in case of hash not matching, or page not
* readable.
*/
- MFS_MN(sb) = mn;
+ mn.root_mode = 0777 | S_IFDIR;
+ MFS_MN(sb) = mn;
errout:
return ret;
}
