sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
c35e25b7e5
nuttx/fs/mnemofs/mnemofs.c
chenrun1 3f47fd767a fs/xxfs:Replace kmm with fs heap 
Summary:
  1.Add configuration to allocate memory from the specified section
  2.Replace all memory operations (kmm_) in the vfs with
    fs_heap_. When FS_HEAPSIZE > 0, memory is requested for the file system by specifying a configured heap location. By default (i.e. FS_HEAPSIZE=0) fs_heap_ is equivalent to kmm_

Signed-off-by: chenrun1 <chenrun1@xiaomi.com>
2024-10-10 15:30:41 +02:00

2302 lines
60 KiB
C
Raw Blame History

/****************************************************************************
* fs/mnemofs/mnemofs.c
* mnemofs: Filesystem for NAND Flash storage devices.
*
* 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.
*
****************************************************************************/
/* mnemofs has these components:
* - Block Allocator
* - Journal
* - LRU
* - Master Node
*
* All the files and directories are stored as a reversed CTZ skip list, a
* data structure defined by littlefs. CTZs list have multiple nodes
* connected by pointers stored in the nodes. So, each node has a pointer
* area, which is at the end of the CTZ node (CTZ block), and a data area,
* which forms the rest of the area, which stores the actual file data. The
* size of the data area can be deterministically found given the index of
* the node in the CTZ list. In mnemofs, each CTZ node/CTZ block takes up one
* page in the NAND flash.
*
* Due to the presence of a data area, the mnemofs VFS methods can only view
* an abstracted view of the CTZ list they are interacting with. VFS methods
* work with CTZ methods (mnemofs_ctz.c), and can not see the existence of
* the pointer area, nor do they have to care about it. They work with
* offsets in the data area from the beginning of the list, and the CTZ
* methods take care of converting that offset into actual NAND flash
* coordinates (block number, or page number).
*
* More info in mnemofs_ctz.c, mnemofs_lru.c, mnemofs_journal.c and
* mnemofs_master.c.
*/
/* TODO:
* - LRU and journal store multiple deltas/commits together respectively.
* These are supposed to be applied together atomically.
* - Journal moves.
* - Return values of all functions.
*/
/****************************************************************************
* Included Files
****************************************************************************/
#include <fcntl.h>
#include <math.h>
#include <nuttx/fs/fs.h>
#include <nuttx/kmalloc.h>
#include <stdio.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include "mnemofs.h"
#include "fs_heap.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int mnemofs_open(FAR struct file *filep, FAR const char *relpath,
int oflags, mode_t mode);
static int mnemofs_close(FAR struct file *filep);
static ssize_t mnemofs_read(FAR struct file *filep, FAR char *buffer,
size_t buflen);
static ssize_t mnemofs_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen);
static off_t mnemofs_seek(FAR struct file *filep, off_t offset,
int whence);
static int mnemofs_ioctl(FAR struct file *filep, int cmd,
unsigned long arg);
static int mnemofs_truncate(FAR struct file *filep, off_t length);
static int mnemofs_sync(FAR struct file *filep);
static int mnemofs_dup(FAR const struct file *oldp,
FAR struct file *newp);
static int mnemofs_fstat(FAR const struct file *filep,
FAR struct stat *buf);
static int mnemofs_opendir(FAR struct inode *mountpt,
FAR const char *relpath,
FAR struct fs_dirent_s **dir);
static int mnemofs_closedir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir);
static int mnemofs_readdir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir,
FAR struct dirent *entry);
static int mnemofs_rewinddir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir);
static int mnemofs_bind(FAR struct inode *driver, FAR const void *data,
FAR void** handle);
static int mnemofs_unbind(FAR void *handle, FAR struct inode **driver,
unsigned int flags);
static int mnemofs_statfs(FAR struct inode *mountpt,
FAR struct statfs *buf);
static int mnemofs_unlink(FAR struct inode *mountpt,
FAR const char *relpath);
static int mnemofs_mkdir(FAR struct inode *mountpt,
FAR const char *relpath, mode_t mode);
static int mnemofs_rmdir(FAR struct inode *mountpt,
FAR const char *relpath);
static int mnemofs_rename(FAR struct inode *mountpt,
FAR const char *oldrelpath,
FAR const char *newrelpath);
static int mnemofs_stat(FAR struct inode *mountpt,
FAR const char *relpath, FAR struct stat *buf);
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Name: g_mnemofs_operations
*
* Description:
* The global list of VFS methods implemented by mnemofs
*
****************************************************************************/
const struct mountpt_operations g_mnemofs_operations =
{
mnemofs_open, /* open */
mnemofs_close, /* close */
mnemofs_read, /* read */
mnemofs_write, /* write */
mnemofs_seek, /* seek */
mnemofs_ioctl, /* ioctl */
NULL, /* mmap */
mnemofs_truncate, /* truncate */
NULL, /* poll */
mnemofs_sync, /* sync */
mnemofs_dup, /* dup */
mnemofs_fstat, /* fstat */
NULL, /* fchstat */
mnemofs_opendir, /* opendir */
mnemofs_closedir, /* closedir */
mnemofs_readdir, /* readdir */
mnemofs_rewinddir, /* rewinddir */
mnemofs_bind, /* bind */
mnemofs_unbind, /* unbind */
mnemofs_statfs, /* statfs */
mnemofs_unlink, /* unlink */
mnemofs_mkdir, /* mkdir */
mnemofs_rmdir, /* rmdir */
mnemofs_rename, /* rename */
mnemofs_stat, /* stat */
NULL /* chstat */
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: mnemofs_open
*
* Description:
* Open a file given its path and populate its file pointer. The file
* pointer's private field is filled with information about the open file.
* See `open(2)` for details on the work and parameters of this function.
*
* File pointers' private member have two parts...`mfs_ofd_d` is the actual
* entry for the file descriptor (fd), while the inner part is a reference
* counted shared portion formed from `mfs_ocom_s`. This way, multiple fds
* can point to the same file without problems. The shared portion is
* shared among the fds of the same file, while the upper part is different
* for each fd, regardless of whether they belong to the same file or not.
* A list of upper parts of files is stored in `sb` as a kernel linked
* list.
*
* Input Parameters:
* filep - File pointer.
* relpath - Relative path to the file from the mount root.
* oflags - Flags for opening the file.
* mode - Access Mode (User|Group|All) if creating the file.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_open(FAR struct file *filep, FAR const char *relpath,
int oflags, mode_t mode)
{
int ret = OK;
int flags;
FAR const char *child = NULL;
FAR struct inode *inode;
struct mfs_pitr_s pitr;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
FAR struct mfs_ocom_s *fcom;
FAR struct mfs_dirent_s *dirent = NULL;
finfo("Mnemofs open on path \"%s\" with flags %x and mode %x.",
relpath, oflags, mode);
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (predict_false(ret < 0))
{
goto errout;
}
finfo("Lock Acquired.");
f = fs_heap_zalloc(sizeof(*f));
if (predict_false(f == NULL))
{
ret = -ENOMEM;
goto errout_with_lock;
}
fcom = fs_heap_zalloc(sizeof(*fcom));
if (predict_false(fcom == NULL))
{
ret = -ENOMEM;
goto errout_with_f;
}
finfo("Memory allocations done.");
f->com = fcom;
f->com->refcount++;
/* Check creation flags. */
flags = mfs_get_patharr(sb, relpath, &f->com->path, &f->com->depth);
if ((flags & MFS_EXIST) == 0)
{
if ((flags & MFS_P_ISDIR) != 0)
{
if ((oflags & O_CREAT) != 0)
{
/* Add direntry to parent's directory file. */
f->com->new_ent = true;
mfs_pitr_init(sb, f->com->path, f->com->depth, &pitr, true);
child = mfs_path2childname(relpath);
finfo("Child is: %s.", child);
mfs_pitr_appendnew(sb, f->com->path, f->com->depth, &pitr,
child, mode);
mfs_pitr_free(&pitr);
finfo("Created new file.");
/* OK */
}
}
else
{
ret = -EISDIR;
goto errout_with_fcom;
}
}
else if ((flags & MFS_ISFILE) != 0)
{
if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
{
ret = -EEXIST;
goto errout_with_fcom;
}
else
{
/* OK */
}
}
else
{
ret = -EISDIR;
goto errout_with_fcom;
}
/* Check r/w permission flags. */
/* TODO: Update mtime and atime. */
mfs_pitr_init(sb, f->com->path, f->com->depth, &pitr, true);
mfs_pitr_readdirent(sb, f->com->path, &pitr, &dirent);
if (dirent != NULL)
{
if ((oflags & O_WRONLY) != 0 && (dirent->mode & O_WRONLY) == 0)
{
ret = -EACCES;
goto errout_with_dirent;
}
mfs_free_dirent(dirent);
dirent = NULL;
}
f->com->sz = mfs_get_fsz(sb, f->com->path, f->com->depth);
f->com->off = 0;
f->com->oflags = oflags;
mfs_pitr_free(&pitr);
finfo("Direntry processing done.");
/* Check Offset flags. */
if ((oflags & (O_TRUNC | O_WRONLY)) == (O_TRUNC | O_WRONLY) ||
(oflags & (O_TRUNC | O_RDONLY)) == (O_TRUNC | O_RDONLY))
{
/* Truncate to size 0. If write and truncate are mentioned only
* then it's truncated. Else, the truncate flag is ignored.
*/
ret = mfs_lru_del(sb, 0, f->com->sz, f->com->path, f->com->depth);
if (predict_false(ret < 0))
{
finfo("Error while truncating file. Ret: %d.", ret);
goto errout_with_dirent;
}
}
if ((oflags & O_APPEND) != 0)
{
f->com->off = f->com->sz;
}
list_add_tail(&MFS_OFILES(sb), &f->list);
filep->f_priv = f;
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock Released.");
finfo("Mnemofs open exited with %d.", ret);
return ret;
errout_with_dirent:
if (dirent != NULL)
{
mfs_free_dirent(dirent);
}
errout_with_fcom:
fs_heap_free(fcom);
errout_with_f:
fs_heap_free(f);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock Released.");
errout:
finfo("Mnemofs open exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_close
*
* Description:
* Closes a file, and frees up the allocated space for the open file's
* representation in the file pointer's private field. mnemofs also syncs
* up the on-flash data after closing of a file (unlike a typical fs as
* mentioned in `man`). This is to be prepared for random power loss at all
* possible times. See `close(2)` for details on the work and parameters
* of this function.
*
* Input Parameters:
* filep - File pointer.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_close(FAR struct file *filep)
{
int ret = OK;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
finfo("Mnemofs close.");
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock Acquired.");
f = filep->f_priv;
DEBUGASSERT(f != NULL);
/* Flushing in-memory data to on-flash journal. */
finfo("Original refcount is %u.", f->com->refcount);
f->com->refcount--;
if (f->com->refcount == 0)
{
ret = mnemofs_flush(sb);
if (predict_false(ret < 0))
{
finfo("Error while flushing. Ret: %d.", ret);
goto errout_with_lock;
}
fs_heap_free(f->com->path);
fs_heap_free(f->com);
finfo("Open file structure freed.");
ret = mnemofs_flush(sb);
if (predict_false(ret < 0))
{
goto errout_with_fcom;
}
}
errout_with_fcom:
list_delete(&f->list);
fs_heap_free(f);
filep->f_priv = NULL;
finfo("File entry removed from the open files list.");
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock Released.");
errout:
finfo("Mnemofs close exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_read
*
* Description:
* This reads an open file at the current offset into the provided `buffer`
* and puts in at most `buflen` bytes of data from the file. See `read(2)`
* for details on the work and parameters of this function.
*
* Files (and directories) are just inverted CTZ skip lists. The CTZ
* methods provide a seamless interface to abstract away the data structure
* to provide an interface which allows the caller to only focus on the
* offset of the data from the start of the file, and not worry about the
* underlying details, pointers, blocks/pages, etc.
*
* Input Parameters:
* filep - File pointer.
* buffer - Buffer where to put read data.
* buflen - Length of the buffer.
*
* Returned Value:
* 0 - OK
* <= 0 - Bytes read.
*
****************************************************************************/
static ssize_t mnemofs_read(FAR struct file *filep, FAR char *buffer,
size_t buflen)
{
ssize_t ret = 0;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
finfo("Mnemofs read.");
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
f = filep->f_priv;
DEBUGASSERT(f != NULL);
finfo("Mnemofs read %zu bytes from %" PRIu32 " offset", buflen,
f->com->off);
/* Check if allowed to read. */
if ((f->com->oflags & O_RDONLY) == 0)
{
finfo("Not allowed to read.");
ret = -EINVAL;
goto errout_with_lock;
}
/* Read data in CTZ from the current offset. */
buflen = MIN(buflen, f->com->sz - f->com->off); /* TODO: Need to consider
* if this needs to be
* lower down the chain.
*/
ret = mfs_lru_rdfromoff(sb, f->com->off, f->com->path, f->com->depth,
buffer, buflen);
if (ret < 0)
{
finfo("Error while reading. Ret: %zd.", ret);
goto errout_with_lock;
}
ret = buflen;
/* Update offset. */
f->com->off += buflen;
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
errout:
finfo("Mnemofs read exited with %zd.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_write
*
* Description:
* This writes to an open file at the current offset from the provided
* `buffer` and puts in at most `buflen` bytes of data from the buffer. See
* `write(2)` for details on the work and parameters of this function.
*
* Input Parameters:
* filep - File pointer.
* buffer - Buffer from where to write data.
* buflen - Length of the buffer.
*
* Returned Value:
* 0 - OK
* <= 0 - Bytes written.
*
****************************************************************************/
static ssize_t mnemofs_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen)
{
ssize_t ret = OK;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
finfo("Mnemofs write.");
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
f = filep->f_priv;
DEBUGASSERT(f != NULL);
finfo("Mnemofs write %zu bytes at offset %" PRIu32, buflen,
f->com->off);
/* Check if allowed to write. */
if ((f->com->oflags & O_WRONLY) == 0)
{
ret = -EINVAL;
goto errout_with_lock;
}
/* Write data to CTZ at the current offset. */
ret = mfs_lru_wr(sb, f->com->off, buflen, f->com->path, f->com->depth,
buffer);
if (ret < 0)
{
goto errout_with_lock;
}
/* Update offset and size. */
f->com->off += buflen;
f->com->sz = MAX(f->com->sz, f->com->off);
ret = buflen;
finfo("Offset updated to %u and size to %u", f->com->off, f->com->sz);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs write exited with %zd.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_seek
*
* Description:
* Repositions the current offset of the file pointed by the file
* descriptor. See `lseek(2)` for details on the work and parameters of
* this function.
*
* The new offset may be beyond the current file size. If that's the case,
* then on any subsequent writes, it will be such that there are bytes with
* '\0' in the gap/hole. In mnemofs, the whole hole situation is that the
* LRU doesn't know about the existence of holes, but comitting a file from
* LRU to the journal does write all the holes to the flash.
*
* Input Parameters:
* filep - File pointer.
* offset - Offset.
* whence - From where the offset should be applied.
*
* Returned Value:
* 0 - OK
* <= 0 - Final position.
*
****************************************************************************/
static off_t mnemofs_seek(FAR struct file *filep, off_t offset, int whence)
{
int ret = OK;
mfs_t pos;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
finfo("Mnemofs seek.");
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
f = filep->f_priv;
DEBUGASSERT(f != NULL);
finfo("Mnemofs seek from %u offset to %u using whence %d.",
f->com->off, offset, whence);
pos = f->com->off;
switch (whence)
{
case SEEK_SET:
pos = offset;
break;
case SEEK_CUR:
pos += offset;
break;
case SEEK_END:
pos = f->com->sz + offset;
break;
default:
ret = -EINVAL;
goto errout_with_lock;
}
/* Check bounds of the position data type. */
if ((pos < f->com->off && offset > 0) ||
(pos > f->com->off && offset < 0))
{
finfo("Out of bounds seek.");
ret = -EINVAL;
goto errout_with_lock;
}
f->com->off = pos;
ret = pos;
finfo("Final position %u.", pos);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
return ret;
}
/****************************************************************************
* Name: mnemofs_ioctl
*
* Description:
* Allows caller to directly control the underlying storage device. See
* `ioctl(2)` for details on the work and parameters of this function.
*
* Input Parameters:
* filep - File pointer.
* cmd - Command.
* arg - Arguments to the command.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
int ret = OK;
FAR struct inode *inode;
FAR struct inode *drv;
FAR struct mfs_sb_s *sb;
finfo("Mnemofs ioctl with cmd %" PRIu32 "and arg %zu.", cmd, arg);
inode = filep->f_inode;
sb = inode->i_private;
drv = sb->drv;
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
if (INODE_IS_MTD(drv))
{
ret = MTD_IOCTL(drv->u.i_mtd, cmd, arg);
}
else
{
finfo("Not an MTD driver.");
ret = -ENOTTY;
}
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs ioctl exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_truncate
*
* Description:
* Truncates file specified to specified length. See `truncate(2)` for
* details on the work and parameters of this function.
*
* Input Parameters:
* filep - File pointer.
* length - Final size of the truncated file.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
* Assumptions/Limitations:
* If the length specified is bigger than the file, it won't increase the
* file size in itself. Only when there is a subsequent write to the offset
* will there be an increase in the file size. This can be changed, but is
* kept for efficiency.
*
****************************************************************************/
static int mnemofs_truncate(FAR struct file *filep, off_t length)
{
int ret = OK;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
finfo("Mnemofs truncate to length %d.", length);
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
f = filep->f_priv;
DEBUGASSERT(f != NULL);
if (length < f->com->sz)
{
ret = mfs_lru_del(sb, length, f->com->sz - length, f->com->path,
f->com->depth);
if (predict_false(ret < 0))
{
finfo("Error during truncate. Ret: %d.", ret);
goto errout_with_lock;
}
}
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs truncate exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_sync
*
* Description:
* Causes all pending modifications that are in memory for a file
* descriptor to be written to the device. See `sync(2)` for details on
* the work and parameters of this function.
*
* For mnemofs, this means that the LRU entry for the file corresponding to
* the fd is committed to the journal.
*
* Input Parameters:
* filep - File pointer.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_sync(FAR struct file *filep)
{
int ret = OK;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
finfo("Mnemofs sync.");
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
f = filep->f_priv;
DEBUGASSERT(f != NULL);
ret = mnemofs_flush(sb);
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs sync exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_dup
*
* Description:
* Creates a duplicate file descriptor. The new and old fds must be
* interchangeable and they share file offsets and file status flags.
* See `dup(2)` for details on the work and parameters of this function.
*
* The file descriptors have file pointers behind them. In mnemofs,
* the file pointers have different upper halves. But duplicate file
* pointers share a reference counted common part among themselves.
*
* Input Parameters:
* oldp - Old file pointer.
* newp - New file pointer.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_dup(FAR const struct file *oldp, FAR struct file *newp)
{
int ret = OK;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *of;
FAR struct mfs_ofd_s *nf;
finfo("Mnemofs dup.");
inode = oldp->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
of = oldp->f_priv;
DEBUGASSERT(of != NULL);
nf = fs_heap_zalloc(sizeof(*nf));
if (predict_false(nf == NULL))
{
finfo("No memory left.");
ret = -ENOMEM;
goto errout_with_lock;
}
nf->com = of->com;
/* Refcount limit. */
if (nf->com->refcount == UINT8_MAX)
{
finfo("Refcount limit reached.");
ret = -EMFILE;
goto errout_with_nf;
}
nf->com->refcount++;
/* Add the new upper half to the list of open fds. */
list_add_tail(&MFS_OFILES(sb), &nf->list);
newp->f_priv = nf;
finfo("New file descriptor added to the end of the list of open files.");
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
return ret;
errout_with_nf:
fs_heap_free(nf);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs dup exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_fstat
*
* Description:
* Get file's status. See `fstat(2)` for details on the work and
* parameters of this function.
*
* In mnemofs, most of the metadata of a file is stored in the directory
* entry of the file inside the parent directories. The directory entries
* are stored in the form of a CTZ, and this is what a directory refers to.
*
* Input Parameters:
* filep - File pointer.
* buf - Stat result.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_fstat(FAR const struct file *filep, FAR struct stat *buf)
{
int ret = OK;
struct mfs_pitr_s pitr;
FAR struct inode *inode;
FAR struct mfs_sb_s *sb;
FAR struct mfs_ofd_s *f;
FAR struct mfs_dirent_s *dirent = NULL;
finfo("Mnemofs fstat.");
inode = filep->f_inode;
DEBUGASSERT(inode != NULL);
sb = inode->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
f = filep->f_priv;
DEBUGASSERT(f != NULL);
mfs_pitr_init(sb, f->com->path, f->com->depth, &pitr, true);
mfs_pitr_adv_tochild(&pitr, f->com->path);
mfs_pitr_readdirent(sb, f->com->path, &pitr, &dirent);
mfs_pitr_free(&pitr);
DEBUGASSERT(dirent != NULL);
buf->st_mode = dirent->mode;
buf->st_nlink = 1; /* mnemofs doesn't yet support links. */
buf->st_size = dirent->sz;
buf->st_atim = dirent->st_atim;
buf->st_ctim = dirent->st_ctim;
buf->st_blksize = sb->pg_sz;
buf->st_blocks = ((dirent->sz + (sb->pg_sz - 1)) / sb->pg_sz); /* Ceil */
mfs_free_dirent(dirent);
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs fstat exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_opendir
*
* Description:
* Opens a directory for traversal. See `opendir(3)` for details on the
* work and parameters of this function.
*
* In mnemofs, the directories are in the form of a CTZ list like files,
* but the content in the list is the directory entries of its children.
* There is mfs_fsdirent->count which exists due to the fact that the first
* entry in readdir is `.`, second is `..` and then the actual contents. To
* save space, this count never goes above 2 because it's not needed as
* above 2, the offset in the CTZ list is sufficient for traversal.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* relpath - Relative path of the directory.
* dir - To populate this with open directory data structure.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
* Assumptions/Limitations:
* There is no attempt to `unlink` or `rmdir` when a directory is open.
* This will mess up the iterator, and mnemofs does not yet store a list
* of open directories to prevent unlink or rmdir when open or something
* like that. This is yet to be tested if mnemofs can handle such a case.
* This bug is marked in code in `readdir`.
*
****************************************************************************/
static int mnemofs_opendir(FAR struct inode *mountpt,
FAR const char *relpath,
FAR struct fs_dirent_s **dir)
{
int ret = OK;
int flags;
mfs_t depth;
FAR struct mfs_sb_s *sb;
FAR struct mfs_path_s *path;
FAR struct mfs_pitr_s *pitr;
FAR struct mfs_fsdirent *fsdirent;
finfo("Mnemofs opendir for directory %s.", relpath);
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(mountpt->i_private);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
flags = mfs_get_patharr(sb, relpath, &path, &depth);
if ((flags & MFS_ISDIR) == 0)
{
ret = -ENOTDIR;
goto errout_with_lock;
}
ret = mfs_lru_updatedinfo(sb, path, depth);
if (predict_false(ret < 0))
{
goto errout_with_path;
}
pitr = fs_heap_zalloc(sizeof(*pitr));
if (predict_false(pitr == NULL))
{
ret = -ENOMEM;
goto errout_with_path;
}
fsdirent = fs_heap_zalloc(sizeof(*fsdirent));
if (predict_false(fsdirent == NULL))
{
ret = -ENOMEM;
goto errout_with_pitr;
}
ret = mfs_pitr_init(sb, path, depth, pitr, false);
if (predict_false(ret < 0))
{
finfo("Failed PITR initialization.");
goto errout_with_fsdirent;
}
fsdirent->idx = 0;
fsdirent->path = path;
fsdirent->depth = depth;
fsdirent->pitr = pitr;
*dir = (FAR struct fs_dirent_s *) fsdirent;
finfo("Opened directory with index %u at depth %u.", fsdirent->idx,
fsdirent->depth);
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
return ret;
errout_with_fsdirent:
fs_heap_free(fsdirent);
errout_with_pitr:
fs_heap_free(pitr);
errout_with_path:
mfs_free_patharr(path);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs opendir exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_closedir
*
* Description:
* Closes an opened directory. See `closedir(3)` for details on the
* work and parameters of this function.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* dir - Open directory data structure.
*
* Returned Value:
* 0 - OK
*
****************************************************************************/
static int mnemofs_closedir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir)
{
struct mfs_fsdirent *fsdirent = (struct mfs_fsdirent *) dir;
finfo("Mnemofs closedir.");
mfs_free_patharr(fsdirent->path);
mfs_pitr_free(fsdirent->pitr);
fs_heap_free(fsdirent->pitr);
fs_heap_free(fsdirent);
return OK;
}
/****************************************************************************
* Name: mnemofs_readdir
*
* Description:
* Gives the directory entry of where the directory iterator currently
* points to and advances the iterator to the next directory entry. See
* `readdir(3)` for details on the work and parameters of this function.
*
* The first two entries are `.` and `..` respectively. The way mnemofs
* keeps a track of the current directory entry is through offset in the
* directory entry file. This offset is an unsigned integer, and to know
* when to return the "dots" and when to return actual directory entries,
* a counter is used that gives `.` when 0, `..` when 1, and the actual
* directory entries when 2. The offset increases only when counter is 2.
* The counter never increases above 2.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* dir - Open directory data structure.
* entry - To populate structure with directory entry.
*
* Returned Value:
* 0 - OK
*
****************************************************************************/
static int mnemofs_readdir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir,
FAR struct dirent *entry)
{
int ret = OK;
FAR struct mfs_sb_s *sb;
FAR struct mfs_dirent_s *dirent;
FAR struct mfs_fsdirent *fsdirent = (FAR struct mfs_fsdirent *) dir;
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
finfo("Mnemofs readdir with dirent idx %u.", fsdirent->idx);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
if (fsdirent->idx == 0)
{
/* . */
snprintf(entry->d_name, NAME_MAX + 1, ".");
entry->d_type = DTYPE_DIRECTORY;
fsdirent->idx++;
goto errout_with_lock;
}
else if (fsdirent->idx == 1)
{
/* .. */
snprintf(entry->d_name, NAME_MAX + 1, "..");
entry->d_type = DTYPE_DIRECTORY;
fsdirent->idx++;
goto errout_with_lock;
}
/* Regular direntries from here. */
/* TODO: Need to think why *exactly* below line is needed. The LRU node
* seems to contain wrong size during opendir, but updating it here
* updates it to correct size, even though this updatedinfo is also
* called in opendir?
*/
ret = mfs_lru_updatedinfo(sb, fsdirent->path, fsdirent->depth);
if (predict_false(ret < 0))
{
goto errout_with_lock;
}
ret = mfs_pitr_readdirent(sb, fsdirent->path, fsdirent->pitr, &dirent);
if (predict_false(ret < 0))
{
goto errout_with_lock;
}
else if (dirent == NULL)
{
/* End of Directory. */
finfo("End of directory.");
ret = -ENOENT;
goto errout_with_lock;
}
memset(entry->d_name, 0, NAME_MAX + 1);
memcpy(entry->d_name, dirent->name, dirent->namelen);
entry->d_type = (S_ISDIR(dirent->mode) ? DTYPE_DIRECTORY: DTYPE_FILE);
finfo("Size of direntry %u, current off %u.", MFS_DIRENTSZ(dirent),
fsdirent->pitr->c_off);
mfs_pitr_adv_bydirent(fsdirent->pitr, dirent);
mfs_free_dirent(dirent);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs readdir exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_rewinddir
*
* Description:
* Rewinds the directory iterator to the start of the directory. See
* `rewinddir(3)` for details on the work and parameters of this function.
*
* In mnemofs, this means resetting offset of CTZ list of directory to 0 and
* counter to 0;
*
* Input Parameters:
* mountpt - Mount point of the file system.
* dir - Open directory data structure.
*
* Returned Value:
* 0 - OK
*
****************************************************************************/
static int mnemofs_rewinddir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir)
{
int ret = OK;
FAR struct mfs_sb_s *sb;
struct mfs_fsdirent *fsdirent = (struct mfs_fsdirent *) dir;
finfo("Rewind dir.");
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
mfs_pitr_reset(fsdirent->pitr);
fsdirent->idx = 0;
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs rewinddir exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_bind
*
* Description:
* Mounts the file system. This is responsible for initializing all the
* in-memory data structures, which may including scanning the storage
* for serialized information, or formatting the storage, depending on the
* options provided during mount.
*
* See `mount(2)` and `mount(8)` for more information.
*
* In mnemofs, the superblock is not stored on disk. It does not contain
* any information about the current state of the device, but rather just
* the information about the storage device, which is obtained from the
* driver anyway. To know if the device is formatted, the entire device
* is scanned, block by block, for the existence of the first block of the
* journal. This is quicker than searching page by page, as there are much
* fewer blocks than pages. The first 8 bytes of the first journal block
* are a special sequence. The journal contains the location of the master
* node (and vice versa, but it's easier to find/use journal and then
* master node).
*
* Input Parameters:
* driver - MTD driver
* data - Mount options
* handle - To be updated with file system information.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_bind(FAR struct inode *driver, FAR const void *data,
FAR void** handle)
{
int ret = OK;
bool format = false;
FAR char buf[8];
mfs_t i = 0;
mfs_t mnblk1;
mfs_t mnblk2;
mfs_t jrnl_blk;
FAR struct mfs_sb_s *sb = NULL;
struct mtd_geometry_s geo;
finfo("Mnemofs bind.");
memset(buf, 0, 8);
sb = fs_heap_zalloc(sizeof(*sb));
if (!sb)
{
ret = -ENOMEM;
goto errout;
}
/* Currently only supports NAND flashes (MTD devices). */
if (driver && INODE_IS_MTD(driver))
{
if (!driver || !driver->u.i_mtd || !driver->u.i_mtd->ioctl)
{
ret = -ENODEV;
finfo("MTD driver not supported.\n");
goto errout_with_sb;
}
ret = MTD_IOCTL(driver->u.i_mtd, MTDIOC_GEOMETRY,
(unsigned long) &geo);
finfo("MTD Driver Geometry read. "
"Page size: %d, Block size: %d, Pages/Block: %d, Blocks: %d\n",
geo.blocksize, geo.erasesize, geo.erasesize / geo.blocksize,
geo.neraseblocks);
}
else
{
finfo("Not an MTD device.\n");
ret = -ENODEV;
goto errout_with_sb;
}
nxmutex_init(&MFS_LOCK(sb));
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout_with_sb;
}
finfo("Lock acquired.");
sb->drv = driver;
sb->pg_sz = geo.blocksize;
sb->blk_sz = geo.erasesize;
sb->n_blks = geo.neraseblocks;
sb->pg_in_blk = MFS_BLKSZ(sb) / sb->pg_sz;
#ifdef CONFIG_MNEMOFS_JOURNAL_NBLKS
MFS_JRNL(sb).n_blks = CONFIG_MNEMOFS_JOURNAL_NBLKS;
#else
MFS_JRNL(sb).n_blks = MIN(5, MFS_NBLKS(sb) / 2);
#endif
sb->log_blk_sz = log2(MFS_BLKSZ(sb));
sb->log_pg_sz = log2(sb->pg_sz);
sb->log_pg_in_blk = log2(sb->pg_in_blk);
sb->log_n_blks = log2(MFS_NBLKS(sb));
MFS_FLUSH(sb) = false;
list_initialize(&MFS_OFILES(sb));
sb->rw_buf = fs_heap_zalloc(MFS_PGSZ(sb));
if (predict_false(sb->rw_buf == NULL))
{
goto errout_with_lock;
}
/* TODO: Print the super block in Block 0. */
srand(time(NULL));
if (!strncmp(data, "autoformat", 11))
{
/* Format if not formatted already. */
finfo("Auto format.\n");
/* Look for journal and maybe hopefully, the master node
* if it comes first.
*/
for (i = 0; i < MFS_NBLKS(sb); i++)
{
mfs_read_page(sb, buf, 8, MFS_BLK2PG(sb, i), 0);
if (!strncmp(buf, MFS_JRNL_MAGIC, 8))
{
/* Found journal first block. */
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_lru_init(sb);
mfs_ba_init(sb);
}
}
if (format || !strncmp(data, "forceformat", 12))
{
/* Format. */
if (!format)
{
finfo("Force format.\n");
}
mfs_ba_fmt(sb);
mfs_lru_init(sb);
mnblk1 = 0;
mnblk2 = 0;
ret = mfs_jrnl_fmt(sb, &mnblk1, &mnblk2, &jrnl_blk);
if (predict_false(ret < 0))
{
goto errout_with_rwbuf;
}
ret = mfs_mn_fmt(sb, mnblk1, mnblk2, jrnl_blk);
if (predict_false(ret < 0))
{
goto errout_with_rwbuf;
}
finfo("Device formatted.\n");
}
*handle = (FAR void *)sb;
finfo("Successfully mounted mnemofs! Super Block %p\n", sb);
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
return ret;
errout_with_rwbuf:
fs_heap_free(sb->rw_buf);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout_with_sb:
fs_heap_free(sb);
errout:
finfo("Mnemofs bind exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_unbind
*
* Description:
* Unmounts the file system.
*
* See `umount(2)` and `umount(8)` for more information.
*
* Input Parameters:
* handle - File system information.
* driver - To be populated with the MTD driver
* flags - Flags for unmounting.
*
* Returned Value:
* 0 - OK
*
****************************************************************************/
static int mnemofs_unbind(FAR void *handle, FAR struct inode **driver,
unsigned int flags)
{
FAR struct mfs_sb_s *sb;
finfo("Mnemofs unbind.");
DEBUGASSERT(handle);
sb = handle;
*driver = sb->drv;
mfs_jrnl_free(sb);
mfs_ba_free(sb);
fs_heap_free(sb->rw_buf);
fs_heap_free(sb);
finfo("Successfully unmounted mnemofs!");
return OK;
}
/****************************************************************************
* Name: mnemofs_statfs
*
* Description:
* Get file system statistics. See `statfs(2)` for more information.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* buf - To populate with file system statistics.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_statfs(FAR struct inode *mountpt, FAR struct statfs *buf)
{
int ret = OK;
FAR struct mfs_sb_s *sb;
finfo("Mnemofs statfs.");
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
buf->f_type = MNEMOFS_SUPER_MAGIC;
buf->f_bsize = sb->pg_sz;
buf->f_blocks = MFS_NBLKS(sb) * sb->pg_in_blk;
buf->f_bavail = mfs_ba_getavailpgs(sb);
buf->f_namelen = UINT8_MAX;
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs statfs exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_unlink
*
* Description:
* Remove a file's entry from the file system. This might delete the file
* as well. See `unlink(2)` for more information.
*
* In mnemofs, the directory entry of the file is removed from its parent's
* directory file (CTZ list). The pages used by the file are marked for
* delete to the block allocator. When the master node is moved, and if the
* blocks of which the pages are part of is ready for erase, then the
* block allocator erases those blocks.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* buf - To populate with file system statistics.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_unlink(FAR struct inode *mountpt, FAR const char *relpath)
{
int ret = OK;
int ret_flags;
mfs_t depth;
FAR struct mfs_sb_s *sb;
FAR struct mfs_path_s *path;
finfo("Mnemofs unlink at path \"%s\".", relpath);
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
ret_flags = mfs_get_patharr(sb, relpath, &path, &depth);
if ((ret_flags & MFS_ISFILE) == 0)
{
ret = -EISDIR;
goto errout_with_lock;
}
mfs_pitr_rm(sb, path, depth, true);
mfs_free_patharr(path);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs unlink exited with %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_mkdir
*
* Description:
* Create a directory at given relpath. See `mkdir(2)` for more
* information.
*
* In mnemofs, the directory entry of the file is appended to its parent's
* directory file (CTZ list).
*
* Input Parameters:
* mountpt - Mount point of the file system.
* relpath - Relative path of the new directory.
* mode - Mode of the new directory (ACL).
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_mkdir(FAR struct inode *mountpt, FAR const char *relpath,
mode_t mode)
{
int ret = OK;
int flags;
mfs_t depth;
struct mfs_pitr_s pitr;
FAR struct mfs_sb_s *sb;
FAR struct mfs_path_s *path;
finfo("Mnemofs mkdir at %s.", relpath);
mode |= S_IFDIR;
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
flags = mfs_get_patharr(sb, relpath, &path, &depth);
if ((flags & MFS_EXIST) != 0)
{
finfo("File exists.");
ret = -EEXIST;
goto errout_with_path;
}
else
{
if ((flags & MFS_P_EXIST) != 0)
{
if ((flags & MFS_P_ISDIR) != 0)
{
/* OK */
finfo("OK");
}
else
{
ret = -ENOTDIR;
goto errout_with_path;
}
}
else
{
ret = -ENOENT;
goto errout_with_path;
}
}
memset(&path[depth - 1], 0, sizeof(struct mfs_path_s));
mfs_pitr_init(sb, path, depth, &pitr, true);
/* The last incomplete direntry will be added by mfs_pitr_appendnew. */
ret = mfs_pitr_appendnew(sb, path, depth, &pitr, relpath, mode);
if (predict_false(ret < 0))
{
goto errout_with_path;
}
mfs_pitr_free(&pitr);
finfo("Directory created at %s", relpath);
mfs_free_patharr(path);
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
finfo("Mnemofs mkdir exited with ret %d.", ret);
return ret;
errout_with_path:
mfs_free_patharr(path);
mfs_pitr_free(&pitr);
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs mkdir exited with ret %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_rmdir
*
* Description:
* Removes a directory from given relpath. See `rmdir(2)` for more
* information.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* relpath - Relative path of the new directory.
* mode - Mode of the new directory (ACL).
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_rmdir(FAR struct inode *mountpt, FAR const char *relpath)
{
int ret = OK;
int flags;
mfs_t depth;
struct mfs_pitr_s pitr;
FAR struct mfs_sb_s *sb;
FAR struct mfs_path_s *path;
finfo("Mnemofs rmdir for path \"%s\".", relpath);
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
flags = mfs_get_patharr(sb, relpath, &path, &depth);
if ((flags & MFS_ISDIR) == 0)
{
ret = -EISDIR;
goto errout_with_lock;
}
mfs_pitr_init(sb, path, depth, &pitr, true);
mfs_pitr_adv_tochild(&pitr, path);
if (!mfs_obj_isempty(sb, path, &pitr))
{
ret = -ENOTEMPTY;
goto errout_with_pitr;
}
mfs_pitr_free(&pitr);
mfs_pitr_rm(sb, path, depth, true);
errout_with_pitr:
mfs_free_patharr(path);
errout_with_lock:
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs rmdir exited with ret %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_rename
*
* Description:
* Moves a file or directory between paths. See `rename(2)` for more
* information.
*
* In mnemofs, this involves erasing a direntry from old path, and adding
* it to the new path. There are some further complications regarding
* directories and files, as mentioned in `rename(2)`.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* relpath - Relative path of the new directory.
* mode - Mode of the new directory (ACL).
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_rename(FAR struct inode *mountpt,
FAR const char *oldrelpath,
FAR const char *newrelpath)
{
int ret = OK;
int oflags;
int nflags;
bool nexists;
bool odir = false;
bool ndir = false;
mfs_t odepth;
mfs_t ndepth;
struct mfs_pitr_s opitr;
struct mfs_pitr_s npitr;
FAR struct mfs_sb_s *sb;
FAR struct mfs_path_s *opath;
FAR struct mfs_path_s *npath;
FAR struct mfs_dirent_s *odirent = NULL;
finfo("Mnemofs rename \"%s\" to \"%s\".", oldrelpath, newrelpath);
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
oflags = mfs_get_patharr(sb, oldrelpath, &opath, &odepth);
if ((oflags & MFS_EXIST) == 0)
{
ret = -ENOENT;
goto errout_with_opath;
}
nflags = mfs_get_patharr(sb, newrelpath, &npath, &ndepth);
if ((nflags & MFS_P_EXIST) == 0)
{
ret = -ENONET;
goto errout_with_npath;
}
odir = ((oflags & MFS_ISDIR) != 0);
ndir = ((nflags & MFS_ISDIR) != 0);
nexists = ((nflags & MFS_EXIST) != 0);
if (nexists && odir && !ndir)
{
ret = -ENOTDIR;
goto errout_with_npath;
}
if (nexists && !odir && ndir)
{
ret = -EISDIR;
goto errout_with_npath;
}
mfs_pitr_init(sb, npath, ndepth, &npitr, nexists);
mfs_pitr_init(sb, opath, odepth, &opitr, true);
/* If new path already exists, remove the direntry. If it's a non-empty
* directory, then raise error.
*/
if (nexists)
{
mfs_pitr_adv_tochild(&opitr, opath);
mfs_pitr_adv_tochild(&npitr, npath);
mfs_pitr_readdirent(sb, opath, &opitr, &odirent);
if (ndir && !mfs_obj_isempty(sb, npath, &npitr))
{
ret = -ENOTEMPTY;
goto errout_with_pitr;
}
mfs_pitr_reset(&npitr);
mfs_pitr_rm(sb, npath, ndepth, false);
}
mfs_pitr_adv_tochild(&npitr, npath);
mfs_pitr_appenddirent(sb, npath, ndepth, &npitr, odirent);
mfs_pitr_rmdirent(sb, opath, odepth, &opitr, odirent);
errout_with_pitr:
mfs_free_dirent(odirent);
mfs_pitr_free(&opitr);
mfs_pitr_free(&npitr);
errout_with_npath:
mfs_free_patharr(npath);
errout_with_opath:
mfs_free_patharr(opath);
nxmutex_unlock(&MFS_LOCK(sb));
finfo("Lock released.");
errout:
finfo("Mnemofs rename exited with ret %d.", ret);
return ret;
}
/****************************************************************************
* Name: mnemofs_stat
*
* Description:
* Get stats of a file. See `stat(2)` for more information.
*
* In mnemofs, most of the relevant information is stored in the dirent
* of the file in its parent's directory file. The stats of the root are
* available in the master node.
*
* Input Parameters:
* mountpt - Mount point of the file system.
* relpath - Relative path of the new directory.
* buf - File stats to populate.
*
* Returned Value:
* 0 - OK
* < 0 - Error
*
****************************************************************************/
static int mnemofs_stat(FAR struct inode *mountpt, FAR const char *relpath,
FAR struct stat *buf)
{
int ret = OK;
int ret_flags;
mfs_t depth;
struct mfs_pitr_s pitr;
FAR struct mfs_sb_s *sb;
FAR struct mfs_path_s *path;
FAR struct mfs_dirent_s *dirent = NULL;
finfo("Mnemofs stat for path \"%s\".", relpath);
DEBUGASSERT(mountpt != NULL);
sb = mountpt->i_private;
DEBUGASSERT(sb != NULL);
ret = nxmutex_lock(&MFS_LOCK(sb));
if (ret < 0)
{
goto errout;
}
finfo("Lock acquired.");
finfo("Master node: Root (%u, %u), Size %u", MFS_MN(sb).root_ctz.idx_e,
MFS_MN(sb).root_ctz.pg_e, MFS_MN(sb).root_sz);
ret_flags = mfs_get_patharr(sb, relpath, &path, &depth);
if ((ret_flags & MFS_EXIST) == 0)
{
ret = -ENOENT;
goto errout_with_path;
}
finfo("Got path array. Depth %u for path \"%s\". Return flags %u.", depth,
relpath, ret_flags);
ret = mfs_lru_updatedinfo(sb, path, depth);
if (predict_false(ret < 0))
{
goto errout_with_path;
}
mfs_pitr_init(sb, path, depth, &pitr, true);
mfs_pitr_adv_tochild(&pitr, path);
ret = mfs_pitr_readdirent(sb, path, &pitr, &dirent);
if (predict_false(ret < 0))
{
goto errout_with_path;
}
else if (dirent == NULL)
{
ret = -ENOENT;
goto errout_with_path;
}
finfo("Read stats.");
buf->st_nlink = 1;
buf->st_blksize = sb->pg_sz;
buf->st_size = dirent->sz;
buf->st_mode = dirent->mode;
buf->st_atim = dirent->st_atim;
buf->st_ctim = dirent->st_ctim;
buf->st_mtim = dirent->st_mtim;
buf->st_blocks = dirent->ctz.idx_e + 1;
mfs_free_dirent(dirent);
mfs_pitr_free(&pitr);
errout_with_path:
mfs_free_patharr(path);
finfo("Lock released.");
nxmutex_unlock(&MFS_LOCK(sb));
errout:
finfo("Ret %d.", ret);
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
int mnemofs_flush(FAR struct mfs_sb_s *sb)
{
int ret = OK;
bool change;
/* Emtpy the LRU, and maybe the journal as well. */
finfo("Flush operation started.");
for (; ; )
{
change = false;
if (!mfs_lru_isempty(sb))
{
finfo("LRU needs to be flushed.");
change = true;
ret = mfs_lru_flush(sb);
if (predict_false(ret < 0))
{
goto errout;
}
}
if (!mfs_jrnl_isempty(sb) &&
MFS_JRNL(sb).log_cblkidx >= MFS_JRNL_LIM(sb))
{
finfo("Journal needs to be flushed.");
change = true;
ret = mfs_jrnl_flush(sb);
if (predict_false(ret < 0))
{
goto errout;
}
}
if (!change)
{
break;
}
finfo("Finished Iteration.");
}
errout:
return ret;
}
/* TODO: Superblock still doesn't exist. Plus bug fixes. */
Reference in New Issue View Git Blame Copy Permalink