| /**************************************************************************** |
| * fs/mnemofs/mnemofs_journal.c |
| * Journal of mnemofs. |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. The |
| * ASF licenses this file to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance with the |
| * License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations |
| * under the License. |
| * |
| * Alternatively, the contents of this file may be used under the terms of |
| * the BSD-3-Clause license: |
| * |
| * SPDX-License-Identifier: BSD-3-Clause |
| * |
| * Copyright (c) 2024 Saurav Pal |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the author nor the names of its contributors may |
| * be used to endorse or promote products derived from this software |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * In mnemofs, the journal stores the path, depth and the new location of the |
| * CTZ file called logs, and also the location of the master block. The first |
| * n blocks of the journal store the logs, while the last two blocks contain |
| * master nodes, and the blocks are called as master blocks. The two master |
| * blocks are identical copies for backup. |
| * |
| * Due to LRU, and the structure of mnemofs, the first n blocks of the |
| * journal get filled up much faster than the master blocks, and move more. |
| * There will be certain point where the entire journal (the n+2 blocks) |
| * move, but mostly, its the first n blocks that move. |
| * |
| * The first block starts with an 8 byte magic sequence, a 2 bytes long |
| * number denoting number of blocks in the journal, and then follows up |
| * with an array containing the block numbers of all blocks in the journal |
| * including the first block. Then the logs start. |
| * |
| * The logs take up size in multiples of pages. There might be unitilzed |
| * space at the end of a log. |
| * |
| * All logs are followed by a byte-long hash of the log. |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Included Files |
| ****************************************************************************/ |
| |
| #include <endian.h> |
| #include <nuttx/kmalloc.h> |
| #include <nuttx/list.h> |
| #include <sys/param.h> |
| |
| #include "mnemofs.h" |
| |
| /**************************************************************************** |
| * Pre-processor Definitions |
| ****************************************************************************/ |
| |
| #define MFS_JRNL_SUFFIXSZ (8 + 2) /* 8 byte magic sequence + no. of blks */ |
| #define MFS_LOGSZ(depth) (sizeof(mfs_t) * 2 + sizeof(struct mfs_ctz_s) + \ |
| sizeof(struct mfs_path_s) * depth + \ |
| sizeof(struct timespec) * 3 + sizeof(uint16_t)) |
| |
| /**************************************************************************** |
| * Private Types |
| ****************************************************************************/ |
| |
| /* NOTE: Even if higher level functions use path as struct mfs_path_s, |
| * journal only uses struct mfs_ctz_s to avoid problems during write and |
| * read of logs. The offsets in struct mfs_path_s will be applied by the |
| * 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 char * const out); |
| |
| /**************************************************************************** |
| * Private Data |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Public Data |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Private Functions |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Name: jrnl_rdlog |
| * |
| * Description: |
| * Read a log to the journal from given location, and update location to |
| * point to next log location. |
| * |
| * Input Parameters: |
| * sb - Superblock instance of the device. |
| * blkidx - Journal Block Index of the current block. |
| * pg_in_blk - Page offset in the block. |
| * log - To populate with the log. |
| * |
| * Returned Value: |
| * 0 - OK |
| * < 0 - Error |
| * |
| * Assumptions/Limitations: |
| * This function does NOT care about start of the journal, or even, if |
| * the initial requested area is inside the journal. It will malfunction |
| * if not used properly. Usually this is used in an iterative manner, and |
| * hence the first time blkidx and pg_in_blk are initialized, they should |
| * be derived from the values in MFS_JRNL(sb) respectively. |
| * |
| * This updates the blkidx and pg_in_blk to point to the next log, and |
| * returns an -ENOSPC when end of journal is reached in traversal. |
| * |
| * Free the log after use. |
| * |
| ****************************************************************************/ |
| |
| 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) |
| { |
| 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); |
| |
| jrnl_blk = mfs_jrnl_blkidx2blk(sb, *blkidx); |
| jrnl_pg = MFS_BLK2PG(sb, jrnl_blk) + *pg_in_blk; |
| |
| /* First 4 bytes contain the size of the entire log. */ |
| |
| ret = mfs_read_page(sb, tmp, 4, jrnl_pg, 0); |
| if (predict_false(ret < 0)) |
| { |
| goto errout; |
| } |
| |
| mfs_deser_mfs(tmp, &log_sz); |
| n_pgs = MFS_CEILDIVIDE(log_sz, MFS_PGSZ(sb)); |
| |
| buf = kmm_zalloc(log_sz); |
| if (predict_false(buf == NULL)) |
| { |
| ret = -ENOMEM; |
| goto errout; |
| } |
| |
| buftmp = buf; |
| rd_sz = 0; |
| for (i = 0; i < n_pgs && rd_sz < log_sz; i++) |
| { |
| /* 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); |
| } |
| } |
| |
| 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 = jrnl_pg - MFS_BLK2PG(sb, jrnl_blk); |
| |
| errout_with_buf: |
| kmm_free(buf); |
| |
| errout: |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: ser_log |
| * |
| * Description: |
| * Serialize a log. |
| * |
| * Input Parameters: |
| * n - Log to serialize |
| * out - Output array where to serialize. |
| * |
| * Returned Value: |
| * Pointer to byte after the end of serialized value. |
| * |
| * Assumptions/Limitations: |
| * This assumes the out buffer has enough space to hold the inline path. |
| * |
| * This doesn't require the hash to be pre-calculated. |
| * |
| ****************************************************************************/ |
| |
| FAR static char *ser_log(FAR const struct jrnl_log_s * const x, |
| FAR char * const out) |
| { |
| char *o = out; |
| mfs_t i = 0; |
| |
| o = mfs_ser_mfs(x->depth, o); |
| o = mfs_ser_mfs(x->sz_new, o); |
| o = mfs_ser_ctz(&x->loc_new, o); |
| o = mfs_ser_timespec(&x->st_mtim_new, o); |
| o = mfs_ser_timespec(&x->st_atim_new, o); |
| o = mfs_ser_timespec(&x->st_ctim_new, o); |
| |
| for (i = 0; i < x->depth; i++) |
| { |
| o = mfs_ser_path(&x->path[i], o); |
| } |
| |
| o = mfs_ser_16(mfs_hash(out, o - out), o); |
| return o; |
| } |
| |
| /**************************************************************************** |
| * Name: deser_log |
| * |
| * Description: |
| * Deserialize a log. |
| * |
| * Input Parameters: |
| * in - Input array from where to deserialize. |
| * n - Log to deserialize |
| * |
| * Returned Value: |
| * NULL - Error. |
| * Pointer to byte after the end of serialized value. |
| * |
| * Assumptions/Limitations: |
| * This allocates space for the path, and the log should freed after use. |
| * |
| ****************************************************************************/ |
| |
| FAR static const char *deser_log(FAR const char * const in, |
| FAR struct jrnl_log_s * const x) |
| { |
| mfs_t k = 0; |
| const char *i = in; |
| |
| i = mfs_deser_mfs(i, &x->depth); |
| i = mfs_deser_mfs(i, &x->sz_new); |
| i = mfs_deser_ctz(i, &x->loc_new); |
| i = mfs_deser_timespec(i, &x->st_mtim_new); |
| i = mfs_deser_timespec(i, &x->st_atim_new); |
| i = mfs_deser_timespec(i, &x->st_ctim_new); |
| |
| /* Allocates path. Deallocate using mfs_jrnl_log_free. */ |
| |
| x->path = kmm_zalloc(sizeof(struct jrnl_log_s) * x->depth); |
| if (predict_false(x->path == NULL)) |
| { |
| return NULL; |
| } |
| |
| for (k = 0; k < x->depth; k++) |
| { |
| i = mfs_deser_path(i, &x->path[k]); |
| } |
| |
| i = mfs_deser_16(i, &x->hash); |
| return i; |
| } |
| |
| /**************************************************************************** |
| * Name: jrnl_log_free |
| * |
| * Description: |
| * Free the log. |
| * |
| * Input Parameters: |
| * log - Log |
| * |
| * Assumptions/Limitations: |
| * This allocates space for the path, and the log should freed after use. |
| * |
| ****************************************************************************/ |
| |
| static void jrnl_log_free(FAR const struct jrnl_log_s * const log) |
| { |
| free(log->path); |
| } |
| |
| /**************************************************************************** |
| * Public Functions |
| ****************************************************************************/ |
| |
| 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; |
| |
| /* 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); |
| |
| if (MFS_JRNL(sb).n_blks == 0) |
| { |
| ret = -EINVAL; |
| goto errout; |
| } |
| |
| sz = MFS_JRNL_SUFFIXSZ + ((CONFIG_MNEMOFS_JOURNAL_NBLKS + 2) * 4); |
| |
| 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_pgoff = MFS_JRNL_SUFFIXSZ; |
| |
| /* Number of logs */ |
| |
| MFS_JRNL(sb).n_logs = 0; |
| blkidx = MFS_JRNL(sb).log_sblkidx; |
| pg_in_blk = MFS_JRNL(sb).log_spg % MFS_PGINBLK(sb); |
| |
| while (true) |
| { |
| /* TODO: Update this to new read log. */ |
| |
| ret = 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 || log->depth == 0) |
| { |
| DEBUGASSERT(!log || log->path == NULL); |
| break; |
| } |
| |
| MFS_JRNL(sb).n_logs++; |
| jrnl_log_free(log); |
| } |
| |
| /* Master node */ |
| |
| MFS_JRNL(sb).mblk1 = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).n_blks); |
| MFS_JRNL(sb).mblk2 = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).n_blks + 1); |
| |
| /* TODO: Read all pages in master blocks to find the last master node |
| * update. |
| */ |
| |
| errout: |
| return ret; |
| } |
| |
| 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; |
| FAR char *tmp; |
| FAR char *buf = NULL; |
| |
| /* 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)) |
| { |
| ret = -ENOMEM; |
| goto errout; |
| } |
| |
| if (*blk1 == 0 && *blk2 == 0) |
| { |
| *blk1 = mfs_ba_getblk(sb); |
| if (predict_false(blk1 == 0)) |
| { |
| ret = -ENOSPC; |
| goto errout_with_buf; |
| } |
| |
| finfo("Allocated Master Block 1: %d.", *blk1); |
| |
| *blk2 = mfs_ba_getblk(sb); |
| if (predict_false(blk2 == 0)) |
| { |
| ret = -ENOSPC; |
| goto errout_with_buf; |
| } |
| |
| finfo("Allocated Master Block 1: %d.", *blk2); |
| finfo("New locations for Master Blocks %d & %d.", *blk1, *blk2); |
| } |
| |
| tmp = buf; |
| |
| tmp = mfs_ser_str(MFS_JRNL_MAGIC, 8, tmp); |
| tmp = mfs_ser_16(CONFIG_MNEMOFS_JOURNAL_NBLKS, tmp); |
| for (i = 0; i < CONFIG_MNEMOFS_JOURNAL_NBLKS; i++) |
| { |
| alloc_blk = mfs_ba_getblk(sb); |
| tmp = mfs_ser_mfs(alloc_blk, tmp); |
| |
| if (predict_false(i == 0)) |
| { |
| blk = alloc_blk; |
| } |
| |
| finfo("Allocated Journal Block %d at Block %d.", i, alloc_blk); |
| } |
| |
| tmp = mfs_ser_mfs(*blk1, tmp); |
| tmp = mfs_ser_mfs(*blk2, tmp); |
| |
| finfo("All Journal Blocks allocated."); |
| |
| tmp = buf; |
| pg = MFS_BLK2PG(sb, blk); |
| for (i = 0; i < n_pgs; i++) |
| { |
| 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; |
| } |
| |
| ret = OK; /* We reach here, we OK. */ |
| |
| finfo("Written magic sequence, size and journal array into the journal."); |
| |
| 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_cblkidx = 0; |
| MFS_JRNL(sb).log_spg = MFS_JRNL(sb).log_cpg; |
| MFS_JRNL(sb).log_sblkidx = MFS_JRNL(sb).log_cblkidx; |
| MFS_JRNL(sb).jrnlarr_pg = MFS_BLK2PG(sb, blk); |
| MFS_JRNL(sb).jrnlarr_pgoff = MFS_JRNL_SUFFIXSZ; |
| MFS_JRNL(sb).mblk1 = *blk1; |
| MFS_JRNL(sb).mblk2 = *blk2; |
| |
| errout_with_buf: |
| kmm_free(buf); |
| |
| errout: |
| return ret; |
| } |
| |
| void mfs_jrnl_free(FAR struct mfs_sb_s * const sb) |
| { |
| mfs_jrnl_flush(sb); |
| finfo("Journal Freed."); |
| } |
| |
| mfs_t mfs_jrnl_blkidx2blk(FAR const struct mfs_sb_s * const sb, |
| const mfs_t blk_idx) |
| { |
| int ret = OK; |
| mfs_t pg; |
| mfs_t idx; |
| mfs_t blk; |
| mfs_t pgoff; |
| char buf[4]; |
| |
| 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)) |
| { |
| pg += pgoff / MFS_PGSZ(sb); |
| pgoff %= MFS_PGSZ(sb); |
| } |
| |
| /* No pg overflow. The blocks have to be big enough. */ |
| |
| DEBUGASSERT(pg < (MFS_BLK2PG(sb, blk) + MFS_PGINBLK(sb))); |
| |
| ret = mfs_read_page(sb, buf, 4, pg, pgoff); |
| if (predict_false(ret < 0)) |
| { |
| return 0; |
| } |
| |
| mfs_deser_mfs(buf, &idx); |
| |
| /* FUTURE TODO: Make it such that the entire jrnlarr doesn't need to be in |
| * a single block. |
| */ |
| |
| return idx; |
| } |
| |
| 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; |
| |
| /* TODO: Allow optional filling of updated timestamps, etc. */ |
| |
| DEBUGASSERT(depth > 0); |
| |
| blkidx = MFS_JRNL(sb).log_sblkidx; |
| pg_in_block = MFS_JRNL(sb).log_spg % MFS_PGINBLK(sb); |
| |
| while (blkidx < MFS_JRNL(sb).n_blks && counter < MFS_JRNL(sb).n_logs) |
| { |
| ret = jrnl_rdlog(sb, &blkidx, &pg_in_block, &tmplog); |
| if (predict_false(ret < 0 && ret != -ENOSPC)) |
| { |
| goto errout; |
| } |
| else if (ret == -ENOSPC) |
| { |
| break; |
| } |
| |
| DEBUGASSERT(tmplog.depth > 0); |
| |
| if (tmplog.depth > depth) |
| { |
| /* Not suitable. */ |
| } |
| else |
| { |
| DEBUGASSERT(tmplog.depth > 0); |
| |
| if (mfs_path_eq(&tmplog.path[tmplog.depth - 1], |
| &path[tmplog.depth - 1])) |
| { |
| path[tmplog.depth - 1].ctz = tmplog.loc_new; |
| path[tmplog.depth - 1].sz = tmplog.sz_new; |
| } |
| } |
| |
| jrnl_log_free(&tmplog); |
| counter++; |
| } |
| |
| errout: |
| return ret; |
| } |
| |
| 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; |
| |
| buf = kmm_zalloc(log_sz); /* For size before log. */ |
| if (predict_false(buf == NULL)) |
| { |
| ret = -ENOMEM; |
| goto errout; |
| } |
| |
| /* Serialize */ |
| |
| log.depth = node->depth; |
| log.sz_new = sz_new; |
| log.loc_new = loc_new; |
| log.st_mtim_new = node->st_mtim; |
| log.st_atim_new = node->st_atim; |
| log.st_ctim_new = node->st_ctim; |
| log.path = node->path; /* Fine as temporarily usage. */ |
| |
| tmp = buf; |
| tmp = mfs_ser_mfs(log_sz - sizeof(mfs_t), tmp); /* First 4 bytes have sz */ |
| tmp = ser_log(&log, tmp); |
| |
| /* 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; |
| } |
| |
| /* Move to next block if needed. */ |
| |
| jrnl_pg++; |
| if (jrnl_pg - MFS_BLK2PG(sb, jrnl_blk) == MFS_PGINBLK(sb)) |
| { |
| MFS_JRNL(sb).log_cblkidx++; |
| |
| if (MFS_JRNL(sb).log_cblkidx == 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, MFS_JRNL(sb).log_cblkidx); |
| jrnl_pg = MFS_BLK2PG(sb, jrnl_blk); |
| } |
| } |
| |
| /* MFS_JRNL(sb).log_cblkidx is up to date */ |
| |
| MFS_JRNL(sb).log_cpg = jrnl_pg; |
| MFS_JRNL(sb).n_logs++; |
| |
| errout_with_buf: |
| kmm_free(buf); |
| |
| errout: |
| return ret; |
| } |
| |
| int mfs_jrnl_flush(FAR struct mfs_sb_s * const sb) |
| { |
| /* When a file or a directory is deleted. |
| * |
| * It will be modified to an entry in the LRU which details the deletion |
| * of all bytes from the child... as in, offset 0, deleted bytes is the |
| * size of the file. |
| * |
| * The new "location" can be used as (0, 0) to signify a deletion, even in |
| * its journal log. |
| * |
| * Also ensure if the size gets updated to 0. |
| * |
| * Then the flush operation problem will be solved for removal of files or |
| * directories. |
| * |
| * Move operation will not empty the child, but only the parent from the |
| * old parent. |
| */ |
| |
| /* Time complexity is going to be horrendous. Hint: O(n^2). HOWEVER, as |
| * littlefs points out....if n is constant, it's essentially a O(k), or |
| * O(1) :D |
| */ |
| |
| /* TODO: Need to consider how the LRU and Journal interact with each other |
| * for newly created fs object's entries. |
| */ |
| |
| /* We're using updatectz to update the LRU inside the journal. Think |
| * about how that might affect the iteration attempts. |
| */ |
| |
| int ret = OK; |
| mfs_t blkidx = MFS_JRNL(sb).log_sblkidx; |
| mfs_t log_itr = 0; |
| mfs_t pg_in_blk = MFS_JRNL(sb).log_spg \ |
| % MFS_PGINBLK(sb); |
| mfs_t tmp_blkidx; |
| mfs_t tmp_pg_in_blk; |
| mfs_t mn_blk1; |
| mfs_t mn_blk2; |
| mfs_t i; |
| mfs_t jrnl_blk; |
| mfs_t blk; |
| struct jrnl_log_s log; |
| struct 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); |
| if (predict_false(ret < 0)) |
| { |
| DEBUGASSERT(ret != -ENOSPC); /* While condition is sufficient. */ |
| goto errout; |
| } |
| |
| if (log.loc_new.pg_e == 0 && log.loc_new.idx_e == 0) |
| { |
| /* Entry is deleted, do not bother with it. */ |
| |
| break; |
| } |
| |
| tmp_blkidx = blkidx; |
| tmp_pg_in_blk = pg_in_blk; |
| |
| path = kmm_zalloc(log.depth * sizeof(struct mfs_path_s)); |
| if (predict_false(path == NULL)) |
| { |
| goto errout; |
| } |
| |
| memcpy(path, log.path, log.depth * sizeof(struct mfs_path_s)); |
| path[log.depth - 1].ctz = log.loc_new; |
| |
| for (; ; ) |
| { |
| ret = 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); |
| goto errout; |
| } |
| |
| if (tmp_log.depth > log.depth) |
| { |
| 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); |
| continue; |
| } |
| |
| path[tmp_log.depth - 1] = tmp_log.path[tmp_log.depth - 1]; |
| |
| if (tmp_log.loc_new.pg_e == 0 && tmp_log.loc_new.idx_e == 0) |
| { |
| /* Entry is deleted, do not bother with it. */ |
| |
| break; |
| } |
| } |
| |
| if (log.depth == 1) |
| { |
| MFS_MN(sb).root_ctz = path[log.depth - 1].ctz; |
| MFS_MN(sb).root_sz = path[log.depth - 1].sz; |
| |
| /* TODO: Other parameters. */ |
| } |
| else |
| { |
| ret = mfs_lru_updatectz(sb, path, log.depth, |
| path[log.depth - 1].ctz, |
| path[log.depth - 1].sz); |
| if (predict_false(ret < 0)) |
| { |
| mfs_free_patharr(path); |
| jrnl_log_free(&log); |
| goto errout; |
| } |
| } |
| |
| mfs_free_patharr(path); |
| jrnl_log_free(&log); |
| } |
| |
| if (MFS_MN(sb).mblk_idx == MFS_PGINBLK(sb)) |
| { |
| mn_blk1 = 0; |
| mn_blk2 = 0; |
| } |
| else |
| { |
| /* FUTURE TODO: Save the two block numbers in master node structure to |
| * be faster. |
| */ |
| |
| mn_blk1 = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).n_blks); |
| mn_blk2 = mfs_jrnl_blkidx2blk(sb, MFS_JRNL(sb).n_blks + 1); |
| } |
| |
| /* Reallocate journal. */ |
| |
| j_state = MFS_JRNL(sb); |
| mn_state = MFS_MN(sb); |
| |
| ret = mfs_jrnl_fmt(sb, &mn_blk1, &mn_blk2, &jrnl_blk); |
| if (predict_false(ret < 0)) |
| { |
| MFS_JRNL(sb) = j_state; |
| goto errout; |
| } |
| |
| /* Write master node entry. */ |
| |
| ret = mfs_mn_sync(sb, &path[0], mn_blk1, mn_blk2, jrnl_blk); |
| if (predict_false(ret < 0)) |
| { |
| MFS_MN(sb) = mn_state; |
| goto errout; |
| } |
| |
| /* Mark all old blocks of journal (and master blocks) as deletable. */ |
| |
| for (i = 0; i < MFS_JRNL(sb).n_blks + 2; i++) |
| { |
| blk = mfs_jrnl_blkidx2blk(sb, i); |
| mfs_ba_blkmarkdel(sb, blk); |
| } |
| |
| /* Delete outdated blocks. */ |
| |
| ret = mfs_ba_delmarked(sb); |
| if (predict_false(ret < 0)) |
| { |
| goto errout; |
| } |
| |
| errout: |
| return ret; |
| } |
| |
| bool mfs_jrnl_isempty(FAR const struct mfs_sb_s * const sb) |
| { |
| return MFS_JRNL(sb).n_logs == 0; |
| } |
