OrgApache/incubator-nuttx
OrgApache
/
incubator-nuttx
mirror of https://github.com/apache/incubator-nuttx.git
1
0
Fork 0
Code Issues Releases Wiki Activity
incubator-nuttx/fs/mnemofs/mnemofs_master.c

445 lines
13 KiB
C
Raw Blame History

/****************************************************************************
* fs/mnemofs/mnemofs_master.c
* Master node 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 master node points to the root of the file system. It
* contains the information about the root, and when the root is updated,
* the master node needs to point to the updated location, and thus, needs to
* update the master node.
*
* Master nodes sit at the very end of the journal. The last two blocks of
* the journal are called master blocks, and they are filled with a new
* entry for a master node everytime it is updated. They are filled in a
* sequential manner, and thus, the latest master node can be found easily.
* The two master blocks contain identical information, and exist to be as a
* backup.
*
* The stored master nodes are basically `struct mfs_mn_s` without the
* redundant `pg` member.
*
* The master node also points to the start of the journal, and thus, when
* the journal moves, a new master node entry is added.
*
* A master node update, when written to the file system, marks the end of
* an update of the file system tree. Thus, at this point, any obsolete data
* that can be erased, will be erased by the block allocator. Only after
* writing the master block is the file system tree updated. Before this,
* the old file system tree is accessible through the older master node, and
* can be accessed again during power loss.
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/kmalloc.h>
#include <sys/stat.h>
#include "mnemofs.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static FAR char *ser_mn(const struct mfs_mn_s mn,
FAR char * const out);
static FAR const char *deser_mn(FAR const char * const in,
FAR struct mfs_mn_s *mn, FAR uint16_t *hash);
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: ser_mn
*
* Description:
* Serialize master node.
*
* Input Parameters:
* mn - Master node.
* out - Out buffer.
*
* Returned Value:
* Pointer to the end of the serialized data in `out`.
*
* Assumptions/Limitations:
* Out should contain enough space for `mn` and 1 byte extra for the hash.
*
****************************************************************************/
static FAR char *ser_mn(const struct mfs_mn_s mn, FAR char * const out)
{
FAR char *tmp = out;
tmp = mfs_ser_mfs(mn.jrnl_blk, tmp);
tmp = mfs_ser_mfs(mn.mblk_idx, tmp);
tmp = mfs_ser_ctz(&mn.root_ctz, tmp);
tmp = mfs_ser_mfs(mn.root_sz, tmp);
tmp = mfs_ser_timespec(&mn.ts, tmp);
tmp = mfs_ser_16(mfs_hash(out, tmp - out), tmp);
/* TODO: Update this, and the make a macro for size of MN. */
return tmp;
}
/****************************************************************************
* Name: ser_mn
*
* Description:
* Deserialize master node.
*
* Input Parameters:
* in - In buffer.
* mn - Master node to populate.
* hash - Stored hash (of serialized data) to populate.
*
* Returned Value:
* Pointer to the end of the serialized data in `in`.
*
* Assumptions/Limitations:
* In should contain enough space for `mn` and 1 byte extra for the hash.
*
****************************************************************************/
static FAR const char *deser_mn(FAR const char * const in,
FAR struct mfs_mn_s *mn, FAR uint16_t *hash)
{
FAR const char *tmp = in;
tmp = mfs_deser_mfs(tmp, &mn->jrnl_blk);
tmp = mfs_deser_mfs(tmp, &mn->mblk_idx);
tmp = mfs_deser_ctz(tmp, &mn->root_ctz);
tmp = mfs_deser_mfs(tmp, &mn->root_sz);
tmp = mfs_deser_timespec(tmp, &mn->ts);
tmp = mfs_deser_16(tmp, hash);
/* TODO: Update this, and the make a macro for size of MN. */
return tmp;
}
/****************************************************************************
* Public Functions
****************************************************************************/
int mfs_mn_init(FAR struct mfs_sb_s * const sb, const mfs_t jrnl_blk)
{
int ret = OK;
bool found = false;
mfs_t i = 0;
mfs_t mblk1;
mfs_t blkidx;
mfs_t pg_in_blk;
mfs_t jrnl_blk_tmp;
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);
mn.jrnl_blk = jrnl_blk;
mn.mblk_idx = 0;
mn.pg = MFS_BLK2PG(sb, mblk1);
for (i = 0; i < MFS_PGINBLK(sb); i++)
{
mfs_read_page(sb, buftmp, 4, mn.pg, 0);
mfs_deser_mfs(buftmp, &jrnl_blk_tmp);
if (jrnl_blk_tmp == 0)
{
break;
}
found = true;
mn.mblk_idx++;
mn.pg++;
}
if (found == false)
{
ret = -EINVAL;
goto errout;
}
if (i == MFS_PGINBLK(sb))
{
ret = -ENOSPC;
goto errout;
}
else
{
mn.pg--;
}
mfs_read_page(sb, buf, sz + 1, mn.pg, 0);
deser_mn(buf, &mn, &hash);
if (hash != mfs_hash(buf, sz))
{
ret = -EINVAL;
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.
*/
mn.root_mode = 0777 | S_IFDIR;
MFS_MN(sb) = mn;
errout:
return ret;
}
int mfs_mn_fmt(FAR struct mfs_sb_s * const sb, const mfs_t mblk1,
const mfs_t mblk2, const mfs_t jrnl_blk)
{
int ret = OK;
mfs_t pg;
struct mfs_mn_s mn;
struct timespec ts;
const mfs_t sz = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
char buf[sz + 1];
clock_gettime(CLOCK_REALTIME, &ts);
memset(buf, 0, sz + 1);
pg = mfs_ba_getpg(sb);
if (predict_false(pg == 0))
{
ret = -ENOSPC;
goto errout;
}
finfo("Root formatted to be at Page %u", pg);
mn.root_ctz.idx_e = 0;
mn.root_ctz.pg_e = pg;
mn.jrnl_blk = jrnl_blk;
mn.mblk_idx = 0;
mn.pg = MFS_BLK2PG(sb, mblk1);
mn.root_sz = 0;
mn.ts = ts;
mn.root_st_atim = ts;
mn.root_st_ctim = ts;
mn.root_st_mtim = ts;
mn.root_mode = 0777 | S_IFDIR;
/* Serialize. */
ser_mn(mn, buf);
ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, mblk1), 0);
if (predict_false(ret < 0))
{
goto errout;
}
ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, mblk2), 0);
if (predict_false(ret < 0))
{
goto errout;
}
mn.mblk_idx = 1;
MFS_MN(sb) = mn;
finfo("Master node written. Now at page %d, timestamp %lld.%.9ld.",
MFS_MN(sb).pg, (long long)MFS_MN(sb).ts.tv_sec,
MFS_MN(sb).ts.tv_nsec);
errout:
return ret;
}
int mfs_mn_move(FAR struct mfs_sb_s * const sb, struct mfs_ctz_s root,
const mfs_t root_sz)
{
int ret = OK;
struct mfs_mn_s mn;
const mfs_t sz = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
char buf[sz + 1];
if (MFS_MN(sb).mblk_idx == MFS_PGINBLK(sb) - 1)
{
/* TODO: Move journal. Master blocks are full. */
}
mn = MFS_MN(sb);
mn.root_ctz = root;
mn.root_sz = root_sz;
mn.mblk_idx++; /* TODO */
mn.pg++;
ser_mn(mn, buf);
ret = mfs_write_page(sb, buf, sz + 1, mn.pg, 0);
if (predict_false(ret < 0))
{
goto errout;
}
MFS_MN(sb) = mn;
errout:
return ret;
}
int mfs_mn_sync(FAR struct mfs_sb_s *sb,
FAR struct mfs_path_s * const new_loc,
const mfs_t blk1, const mfs_t blk2, const mfs_t jrnl_blk)
{
int ret = OK;
struct timespec ts;
struct mfs_mn_s mn;
const mfs_t sz = sizeof(struct mfs_mn_s) - sizeof(mn.pg);
char buf[sz + 1];
mn = MFS_MN(sb);
clock_gettime(CLOCK_REALTIME, &ts);
if (mn.mblk_idx == MFS_PGINBLK(sb))
{
/* New blocks have been already allocated by the journal. */
mn.mblk_idx = 0;
mn.pg = MFS_BLK2PG(sb, blk1);
}
mn.ts = ts;
mn.root_sz = new_loc->sz;
mn.root_ctz = new_loc->ctz;
mn.root_mode = 0777 | S_IFDIR;
/* TODO: Root timestamps. */
/* Serialize. */
ser_mn(mn, buf);
ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, blk1) + mn.mblk_idx, 0);
if (predict_false(ret < 0))
{
goto errout;
}
ret = mfs_write_page(sb, buf, sz, MFS_BLK2PG(sb, blk2) + mn.mblk_idx, 0);
if (predict_false(ret < 0))
{
goto errout;
}
mn.mblk_idx++;
MFS_MN(sb) = mn;
errout:
return ret;
}
Reference in New Issue View Git Blame Copy Permalink