From 2db7204d360925d44342188da5431c8db4469791 Mon Sep 17 00:00:00 2001 From: chenwei Date: Wed, 19 May 2021 14:38:09 +0800 Subject: [PATCH] feat(file system): add memory-based romfs 1, this RomFS's codebase is Nuttx romfs, then it is compatible with Linux RomFS and you can create such a file system using the tool genromfs. 2, there are two major changes against with the original Nuttx romfs: 1), it is memory-based: all contents of the fs are stored in the memory in the very first stage of "mount". 2), this version of romfs is altered to be compatible with our version of VFS to take advantage of vnode cache and path cache. close: #I3S0CP --- fs/romfs/Kconfig | 15 + fs/romfs/Make.defs | 47 +++ fs/romfs/fs_romfs.c | 861 ++++++++++++++++++++++++++++++++++++++++ fs/romfs/fs_romfs.h | 237 +++++++++++ fs/romfs/fs_romfsutil.c | 615 ++++++++++++++++++++++++++++ 5 files changed, 1775 insertions(+) create mode 100644 fs/romfs/Kconfig create mode 100644 fs/romfs/Make.defs create mode 100644 fs/romfs/fs_romfs.c create mode 100644 fs/romfs/fs_romfs.h create mode 100644 fs/romfs/fs_romfsutil.c diff --git a/fs/romfs/Kconfig b/fs/romfs/Kconfig new file mode 100644 index 0000000..4014cf6 --- /dev/null +++ b/fs/romfs/Kconfig @@ -0,0 +1,15 @@ +# +# For a description of the syntax of this configuration file, +# see the file kconfig-language.txt in the NuttX tools repository. +# + +config FS_ROMFS + bool "ROMFS file system" + default n + depends on !DISABLE_MOUNTPOINT + select FS_READABLE + ---help--- + Enable ROMFS filesystem support + +if FS_ROMFS +endif diff --git a/fs/romfs/Make.defs b/fs/romfs/Make.defs new file mode 100644 index 0000000..b4c6ebc --- /dev/null +++ b/fs/romfs/Make.defs @@ -0,0 +1,47 @@ +############################################################################ +# fs/romfs/Make.defs +# +# Copyright (C) 2008, 2011, 2013 Gregory Nutt. All rights reserved. +# Author: Gregory Nutt +# +# 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 Nuttx nor the names of its contributors may be +# used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 +# COPYRIGHT OWNER 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. +# +############################################################################ + +ifeq ($(CONFIG_FS_ROMFS),y) +# Files required for ROMFS file system support + +ASRCS += +CSRCS += fs_romfs.c fs_romfsutil.c + +# Include ROMFS build support + +DEPPATH += --dep-path romfs +VPATH += :romfs + +endif diff --git a/fs/romfs/fs_romfs.c b/fs/romfs/fs_romfs.c new file mode 100644 index 0000000..13c03c2 --- /dev/null +++ b/fs/romfs/fs_romfs.c @@ -0,0 +1,861 @@ +/**************************************************************************** + * rm/romfs/fs_romfs.h + * + * Copyright (C) 2008-2009, 2011, 2017-2018 Gregory Nutt. All rights + * reserved. + * Author: Gregory Nutt + * + * References: Linux/Documentation/filesystems/romfs.txt + * + * 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 NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 + * COPYRIGHT OWNER 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. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "fs_romfs.h" + +#include "los_tables.h" +#include "user_copy.h" +#include "los_vm_filemap.h" + +#ifdef LOSCFG_FS_ROMFS + +/* forward define */ +struct VnodeOps g_romfsVops; +struct file_operations_vfs g_romfsFops; + +/**************************************************************************** + * Name: romfs_lookup + ****************************************************************************/ + +int romfs_lookup(struct Vnode *parentVnode, const char *path, int len, struct Vnode **ppVnode) +{ + int ret; + struct Vnode *newVnode = NULL; + struct romfs_dirinfo_s *dirinfo = NULL; + struct romfs_dirinfo_s *parent_dirinfo = NULL; + struct romfs_mountpt_s *rm = NULL; + struct romfs_file_s *rf = NULL; + + /* Get mountpoint private data from the inode reference from the file + * structure + */ + + rm = (struct romfs_mountpt_s *)parentVnode->originMount->data; + + /* Check if the mount is still healthy */ + + romfs_semtake(rm); + ret = romfs_checkmount(rm); + if (ret != OK) + { + PRINTK("ERROR: romfs_checkmount failed: %d\n", ret); + goto errout_with_semaphore; + } + + parent_dirinfo = (struct romfs_dirinfo_s *)parentVnode->data; + /* Initialize the directory info structure */ + + dirinfo = (struct romfs_dirinfo_s *)zalloc(sizeof(struct romfs_dirinfo_s)); + if (!dirinfo) + { + ret = -ENOMEM; + PRINTK("ERROR: Failed to allocate dirinfo structure, error: %d\n", -ret); + goto errout_with_semaphore; + } + + /* Locate the directory entry for this path */ + + ret = romfs_searchdir(rm, path, len, parent_dirinfo->rd_dir.fr_firstoffset, dirinfo); + if (ret < 0) + { + goto errout_with_semaphore; + } + + /* The full path exists -- but is the final component a file + * or a directory? Or some other Unix file type that is not + * appropriate in this contex. + * + * REVISIT: This logic should follow hard/soft link file + * types. At present, it returns the ENXIO. + */ + + if (!IS_DIRECTORY(dirinfo->rd_next) && !IS_FILE(dirinfo->rd_next)) + { + /* ENXIO indicates "The named file is a character special or + * block special file, and the device associated with this + * special file does not exist." + * + * Here we also return ENXIO if the file is not a directory + * or a regular file. + */ + + ret = -ENXIO; + PRINTK("ERROR: '%s' is a special file\n", path); + goto errout_with_semaphore; + } + + if (IS_DIRECTORY(dirinfo->rd_next)) + { + ret = VnodeAlloc(&g_romfsVops, &newVnode); + if (ret != 0) + { + PRINTK("%s-%d: can't alloc vnode, error: %d\n", __FUNCTION__, __LINE__, ret); + goto errout_with_semaphore; + } + newVnode->type = VNODE_TYPE_DIR; + newVnode->parent = parentVnode; + newVnode->fop = &g_romfsFops; + newVnode->data = dirinfo; + newVnode->originMount = parentVnode->originMount; + newVnode->uid = parentVnode->uid; + newVnode->gid = parentVnode->gid; + newVnode->mode = parentVnode->mode | (S_IFDIR | S_IROTH | S_IXOTH | S_IRGRP | S_IXGRP | + S_IRUSR | S_IXUSR); + } + else + { + rf = (struct romfs_file_s *)zalloc(sizeof(struct romfs_file_s)); + if (!rf) + { + ret = -ENOMEM; + PRINTK("ERROR: Failed to allocate private data: %d\n", ret); + goto errout_with_semaphore; + } + + /* Initialize the file private data (only need to initialize + * non-zero elements) + */ + + rf->rf_size = dirinfo->rd_size; + rf->rf_type = (uint8_t)(dirinfo->rd_next & RFNEXT_ALLMODEMASK); + + /* Get the start of the file data */ + + ret = romfs_datastart(rm, dirinfo->rd_dir.fr_curroffset, + &rf->rf_startoffset); + if (ret < 0) + { + PRINTK("ERROR: Failed to locate start of file data: %d\n", ret); + goto errout_with_mem; + } + + /* Then insert the new instance into the mountpoint structure. + * It needs to be there (1) to handle error conditions that effect + * all files, and (2) to inform the umount logic that we are busy + * (but a simple reference count could have done that). + */ + + rf->rf_next = rm->rm_head; + rm->rm_head = rf->rf_next; + + ret = VnodeAlloc(&g_romfsVops, &newVnode); + if (ret != 0) + { + PRINTK("%s-%d: can't alloc vnode, error: %d\n", __FUNCTION__, __LINE__, ret); + goto errout_with_mem; + } + + newVnode->originMount = parentVnode->originMount; + newVnode->type = VNODE_TYPE_REG; + newVnode->parent = parentVnode; + newVnode->fop = &g_romfsFops; + newVnode->data = rf; + newVnode->uid = parentVnode->uid; + newVnode->gid = parentVnode->gid; + newVnode->mode = S_IFREG | S_IROTH | S_IXOTH | S_IRGRP | S_IXGRP | S_IRUSR | S_IXUSR; + + free(dirinfo); + } + + *ppVnode = newVnode; + + romfs_semgive(rm); + return OK; + + /* Error exits */ + +errout_with_mem: + free(rf); + +errout_with_semaphore: + romfs_semgive(rm); + return ret; +} + +/**************************************************************************** + * Name: romfs_close + ****************************************************************************/ + +int romfs_close(struct file *filep) +{ + return 0; +} + +int romfs_reclaim(struct Vnode *vp) +{ + struct romfs_file_s *rf = vp->data; + if (rf->rf_buffer) + { + free(rf->rf_buffer); + } + + /* Then free the file structure itself. */ + + free(rf); + vp->data = NULL; + + return 0; +} + +/**************************************************************************** + * Name: romfs_read + ****************************************************************************/ + +static ssize_t romfs_read(struct file *filep, char *buffer, + size_t buflen) +{ + struct romfs_mountpt_s *rm = NULL; + struct romfs_file_s *rf = NULL; + uint32_t offset; + size_t bytesleft; + int ret; + + /* Recover our private data from the struct file instance */ + + rf = (struct romfs_file_s *)filep->f_vnode->data; + rm = (struct romfs_mountpt_s *)filep->f_vnode->originMount->data; + + /* Make sure that the mount is still healthy */ + + romfs_semtake(rm); + ret = romfs_checkmount(rm); + if (ret != OK) + { + PRINTK("ERROR: romfs_checkmount failed: %d\n", ret); + goto errout_with_semaphore; + } + + /* Get the number of bytes left in the file */ + + bytesleft = rf->rf_size - filep->f_pos; + + /* Truncate read count so that it does not exceed the number + * of bytes left in the file. + */ + + if (buflen > bytesleft) + { + buflen = bytesleft; + } + + offset = rf->rf_startoffset + filep->f_pos; + LOS_CopyFromKernel(buffer, buflen, &rm->rm_buffer[offset], buflen); + filep->f_pos += buflen; + + romfs_semgive(rm); + return buflen; + +errout_with_semaphore: + romfs_semgive(rm); + return ret; +} + +/**************************************************************************** + * Name: romfs_seek + ****************************************************************************/ + +off_t romfs_seek(struct file *filep, off_t offset, int whence) +{ + struct romfs_file_s *rf = NULL; + loff_t position; + + /* Recover our private data from the struct file instance */ + + rf = (struct romfs_file_s *)filep->f_vnode->data; + position = filep->f_pos; + + /* Map the offset according to the whence option */ + + switch (whence) + { + case SEEK_SET: /* The offset is set to offset bytes. */ + position = offset; + break; + + case SEEK_CUR: /* The offset is set to its current location plus + * offset bytes. */ + + position += offset; + break; + + case SEEK_END: /* The offset is set to the size of the file plus + * offset bytes. */ + + position = offset + rf->rf_size; + break; + + default: + PRINTK("ERROR: Whence is invalid: %d\n", whence); + return -EINVAL; + } + + /* Limit positions to the end of the file. */ + + if (position > rf->rf_size) + { + /* Otherwise, the position is limited to the file size */ + + position = rf->rf_size; + } + + if (position < 0) + { + return -EINVAL; + } + return position; +} + +/**************************************************************************** + * Name: romfs_seek64 + ****************************************************************************/ + +loff_t romfs_seek64(struct file *filep, loff_t offset, int whence) +{ + return (loff_t)romfs_seek(filep, (off_t)offset, whence); +} + +/**************************************************************************** + * Name: romfs_ioctl + ****************************************************************************/ + +static int romfs_ioctl(struct file *filep, int cmd, unsigned long arg) +{ + return -ENOSYS; +} + +/**************************************************************************** + * Name: romfs_opendir + * + * Description: + * Open a directory for read access + * + ****************************************************************************/ + +int romfs_opendir(struct Vnode *vp, struct fs_dirent_s *dir) +{ + int ret; + struct romfs_mountpt_s *rm = NULL; + struct romfs_dirinfo_s *dirinfo = NULL; + struct fs_romfsdir_s *ptr = NULL; + + /* Recover our private data from the vnode instance */ + + rm = (struct romfs_mountpt_s *)vp->originMount->data; + + /* Make sure that the mount is still healthy */ + + romfs_semtake(rm); + ret = romfs_checkmount(rm); + if (ret != OK) + { + PRINTK("ERROR: romfs_checkmount failed: %d\n", ret); + goto errout_with_semaphore; + } + + ptr = (struct fs_romfsdir_s *)zalloc(sizeof(struct fs_romfsdir_s)); + if (ptr == NULL) + { + ret = -ENOMEM; + PRINTK("ERROR: zalloc error for romfsdir. error: %d\n", ret); + goto errout_with_semaphore; + } + + dirinfo = (struct romfs_dirinfo_s *)vp->data; + memcpy(ptr, &dirinfo->rd_dir, sizeof(struct fs_romfsdir_s)); + dir->u.fs_dir = (fs_dir_s *)ptr; + + romfs_semgive(rm); + return OK; + +errout_with_semaphore: + romfs_semgive(rm); + return ret; +} + +/**************************************************************************** + * Name: romfs_closedir + * + * Description: + * Close a directory for read access + * + ****************************************************************************/ + +int romfs_closedir(struct Vnode *vp, struct fs_dirent_s *dir) +{ + struct fs_romfsdir_s *ptr = NULL; + + ptr = (struct fs_romfsdir_s *)dir->u.fs_dir; + if (ptr == NULL) + { + PRINTK("ERROR: romfs_closedir failed, fs_romfsdir_s is NULL.\n"); + return -EINVAL; + } + free(ptr); + dir->u.fs_dir = NULL; + return 0; +} + +/**************************************************************************** + * Name: romfs_readdir + * + * Description: Read the next directory entry + * + ****************************************************************************/ + +static int romfs_readdir(struct Vnode *vp, struct fs_dirent_s *dir) +{ + struct romfs_mountpt_s *rm = NULL; + struct fs_romfsdir_s *romfsdir = NULL; + uint32_t linkoffset; + uint32_t next; + uint32_t info; + uint32_t size; + int ret; + int i = 0; + + /* Recover our private data from the vnode instance */ + + rm = (struct romfs_mountpt_s *)vp->originMount->data; + + /* Make sure that the mount is still healthy */ + + romfs_semtake(rm); + ret = romfs_checkmount(rm); + if (ret != OK) + { + PRINTK("ERROR: omfs_checkmount failed: %d\n", ret); + goto errout_with_semaphore; + } + + romfsdir = (struct fs_romfsdir_s *)dir->u.fs_dir; + /* Loop, skipping over unsupported items in the file system */ + + while (i < dir->read_cnt) + { + /* Have we reached the end of the directory */ + + if (!romfsdir->fr_curroffset) + { + /* We signal the end of the directory by returning the + * special error -ENOENT + */ + + ret = -ENOENT; + break; + } + + /* Parse the directory entry */ + + ret = romfs_parsedirentry(rm, romfsdir->fr_curroffset, &linkoffset, + &next, &info, &size); + if (ret < 0) + { + PRINTK("ERROR: romfs_parsedirentry failed: %d\n", ret); + goto errout_with_semaphore; + } + + /* Save the filename */ + + ret = romfs_parsefilename(rm, (uint32_t)romfsdir->fr_curroffset, dir->fd_dir[i].d_name); + if (ret < 0) + { + PRINTK("ERROR: romfs_parsefilename failed: %d\n", ret); + goto errout_with_semaphore; + } + + /* Set up the next directory entry offset */ + + romfsdir->fr_curroffset = (off_t)next & RFNEXT_OFFSETMASK; + + if (!strcmp(dir->fd_dir[i].d_name, ".") || !strcmp(dir->fd_dir[i].d_name, "..")) + { + continue; + } + + /* Check the file type */ + + if (IS_DIRECTORY(next)) + { + dir->fd_dir[i].d_type = DT_DIR; + } + else if (IS_FILE(next)) + { + dir->fd_dir[i].d_type = DT_REG; + } + + dir->fd_position++; + dir->fd_dir[i].d_off = dir->fd_position; + dir->fd_dir[i].d_reclen = (uint16_t)sizeof(struct dirent); + + i++; + } + romfs_semgive(rm); + return i; + +errout_with_semaphore: + romfs_semgive(rm); + return ret; +} + +/**************************************************************************** + * Name: romfs_rewindir + * + * Description: Reset directory read to the first entry + * + ****************************************************************************/ + +static int romfs_rewinddir(struct Vnode *vp, struct fs_dirent_s *dir) +{ + int ret; + struct romfs_mountpt_s *rm = NULL; + struct fs_romfsdir_s *romfsdir = NULL; + + /* Recover our private data from the vnode instance */ + + rm = (struct romfs_mountpt_s *)vp->originMount->data; + + /* Make sure that the mount is still healthy */ + + romfs_semtake(rm); + ret = romfs_checkmount(rm); + if (ret == OK) + { + romfsdir = (struct fs_romfsdir_s *)dir->u.fs_dir; + romfsdir->fr_curroffset = romfsdir->fr_firstoffset; + } + + romfs_semgive(rm); + return ret; +} + +/**************************************************************************** + * Name: romfs_bind + * + * Description: This implements a portion of the mount operation. This + * function allocates and initializes the mountpoint private data and + * binds the blockdriver inode to the filesystem private data. The final + * binding of the private data (containing the blockdriver) to the + * mountpoint is performed by mount(). + * + ****************************************************************************/ + +int romfs_bind(struct Mount *mnt, struct Vnode *blkDriver, const void *data) +{ + struct romfs_mountpt_s *rm = NULL; + struct romfs_dirinfo_s *dirinfo = NULL; + struct Vnode *pv = NULL; + int ret; + + rm = (struct romfs_mountpt_s *)zalloc(sizeof(struct romfs_mountpt_s)); + if (!rm) + { + PRINTK("ERROR: Failed to allocate mountpoint structure, error: %d\n", -ENOMEM); + return -ENOMEM; + } + + /* Initialize the allocated mountpt state structure. The filesystem is + * responsible for one reference ont the blkdriver inode and does not + * have to addref() here (but does have to release in ubind(). + */ + + (void)sem_init(&rm->rm_sem, 0, 0); /* Initialize the semaphore that controls access */ + + /* Get the hardware configuration and setup buffering appropriately */ + + ret = romfs_hwconfigure(rm); + if (ret) + { + PRINTK("ERROR: romfs_hwconfigure failed: %d\n", ret); + goto errout_with_sem; + } + + /* Then complete the mount by getting the ROMFS configuratrion from + * the ROMF header + */ + + ret = romfs_fsconfigure(rm); + if (ret < 0) + { + PRINTK("ERROR: romfs_fsconfigure failed: %d\n", ret); + goto errout_with_buffer; + } + + dirinfo = (struct romfs_dirinfo_s *)zalloc(sizeof(struct romfs_dirinfo_s)); + if (!dirinfo) + { + PRINTK("ERROR: Failed to allocate dirinfo structure, error: %d\n", -ENOMEM); + goto errout_with_buffer; + } + + dirinfo->rd_dir.fr_firstoffset = rm->rm_rootoffset; + dirinfo->rd_dir.fr_curroffset = rm->rm_rootoffset; + dirinfo->rd_next = RFNEXT_DIRECTORY; + dirinfo->rd_size = 0; + + /* Mounted! */ + + ret = VnodeAlloc(&g_romfsVops, &pv); + if (ret) + { + goto errout_with_dirinfo; + } + + pv->type = VNODE_TYPE_DIR; + pv->data = dirinfo; + pv->originMount = mnt; + pv->fop = &g_romfsFops; + pv->uid = mnt->vnodeBeCovered->uid; + pv->gid = mnt->vnodeBeCovered->gid; + pv->mode = S_IFDIR | S_IROTH | S_IXOTH | S_IRGRP | S_IXGRP | S_IRUSR | S_IXUSR; + mnt->data = rm; + mnt->vnodeCovered = pv; + + romfs_semgive(rm); + return OK; + +errout_with_dirinfo: + free(dirinfo); + +errout_with_buffer: + free(rm->rm_buffer); + +errout_with_sem: + (void)sem_destroy(&rm->rm_sem); + free(rm); + return ret; +} + +/**************************************************************************** + * Name: romfs_unbind + * + * Description: This implements the filesystem portion of the umount + * operation. + * + ****************************************************************************/ + +static int romfs_unbind(struct Mount *mnt, struct Vnode **blkDriver) +{ + struct romfs_mountpt_s *rm = (struct romfs_mountpt_s *)mnt->data; + + if (!rm) + { + return -EINVAL; + } + + /* VFS can assure the mountpoint can be umounted. */ + + romfs_semtake(rm); + /* Release the mountpoint private data */ + + if (rm->rm_buffer) + { + free(rm->rm_buffer); + } + + (void)sem_destroy(&rm->rm_sem); + free(rm); + return OK; +} + +/**************************************************************************** + * Name: romfs_statfs + * + * Description: Return filesystem statistics + * + ****************************************************************************/ + +static int romfs_statfs(struct Mount *mnt, struct statfs *buf) +{ + struct romfs_mountpt_s *rm; + int ret; + + rm = (struct romfs_mountpt_s *)mnt->data; + + /* Check if the mount is still healthy */ + + romfs_semtake(rm); + ret = romfs_checkmount(rm); + if (ret < 0) + { + PRINTK("ERROR: romfs_checkmount failed: %d\n", ret); + goto errout_with_semaphore; + } + + /* Fill in the statfs info */ + + memset(buf, 0, sizeof(struct statfs)); + buf->f_type = ROMFS_MAGIC; + + /* We will claim that the optimal transfer size is the size of one sector */ + + buf->f_bsize = rm->rm_hwsectorsize; + + /* Everything else follows in units of sectors */ + + buf->f_blocks = SEC_NSECTORS(rm, rm->rm_volsize + SEC_NDXMASK(rm)); + buf->f_bfree = 0; + buf->f_bavail = rm->rm_volsize; + buf->f_namelen = NAME_MAX; + + romfs_semgive(rm); + return OK; + +errout_with_semaphore: + romfs_semgive(rm); + return ret; +} + +/**************************************************************************** + * Name: romfs_stat + * + * Description: Return information about a file or directory + * + ****************************************************************************/ + +static int romfs_stat(struct Vnode *vp, struct stat *buf) +{ + struct romfs_mountpt_s *rm = NULL; + struct romfs_dirinfo_s *dirinfo = NULL; + struct romfs_file_s *rf = NULL; + int ret; + + rm = (struct romfs_mountpt_s *)vp->originMount->data; + + /* Check if the mount is still healthy */ + + romfs_semtake(rm); + ret = romfs_checkmount(rm); + if (ret != OK) + { + PRINTK("ERROR: romfs_checkmount failed: %d\n", ret); + goto errout_with_semaphore; + } + + if (vp->type == VNODE_TYPE_DIR) + { + dirinfo = (struct romfs_dirinfo_s *)vp->data; + buf->st_mode = vp->mode; + buf->st_size = dirinfo->rd_size; + } + else if (vp->type == VNODE_TYPE_REG) + { + rf = (struct romfs_file_s *)vp->data; + buf->st_mode = vp->mode; + buf->st_size = rf->rf_size; + } + else + { + PRINTK("ERROR: Unsupported file type: %d\n", vp->type); + ret = -EINVAL; + goto errout_with_semaphore; + } + + buf->st_blksize = rm->rm_hwsectorsize; + buf->st_dev = 0; + buf->st_ino = 0; + buf->st_nlink = 0; + buf->st_uid = vp->uid; + buf->st_gid = vp->gid; + buf->st_atime = 0; + buf->st_mtime = 0; + buf->st_ctime = 0; + +errout_with_semaphore: + romfs_semgive(rm); + return ret; +} + +const struct MountOps romfs_operations = +{ + .Mount = romfs_bind, + .Unmount = romfs_unbind, + .Statfs = romfs_statfs, +}; + +struct VnodeOps g_romfsVops = +{ + .Lookup = romfs_lookup, + .Create = NULL, + .Rename = NULL, + .Mkdir = NULL, + .Getattr = romfs_stat, + .Opendir = romfs_opendir, + .Readdir = romfs_readdir, + .Closedir = romfs_closedir, + .Rewinddir = romfs_rewinddir, + .Unlink = NULL, + .Rmdir = NULL, + .Chattr = NULL, + .Reclaim = romfs_reclaim, + .Truncate = NULL, + .Truncate64 = NULL, +}; + +struct file_operations_vfs g_romfsFops = +{ + .read = romfs_read, + .write = NULL, + .mmap = OsVfsFileMmap, + .seek = romfs_seek, + .ioctl = romfs_ioctl, + .close = romfs_close, + .fsync = NULL, +}; + +FSMAP_ENTRY(romfs_fsmap, "romfs", romfs_operations, FALSE, FALSE); + +#endif diff --git a/fs/romfs/fs_romfs.h b/fs/romfs/fs_romfs.h new file mode 100644 index 0000000..6f8102a --- /dev/null +++ b/fs/romfs/fs_romfs.h @@ -0,0 +1,237 @@ +/**************************************************************************** + * fs/romfs/fs_romfs.h + * + * Copyright (C) 2008-2009, 2011 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * References: Linux/Documentation/filesystems/romfs.txt + * + * 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 NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 + * COPYRIGHT OWNER 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. + * + ****************************************************************************/ + +#ifndef __FS_ROMFS_FS_ROMFS_H +#define __FS_ROMFS_FS_ROMFS_H + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#include + +#include + +#include "disk.h" + +/**************************************************************************** + * Pre-processor Definitions + ****************************************************************************/ + +/* Volume header (multi-byte values are big-endian) */ +#define ROMFS_MAGIC 0x7275 + +#define ROMFS_VHDR_ROM1FS 0 /* 0-7: "-rom1fs-" */ +#define ROMFS_VHDR_SIZE 8 /* 8-11: Number of accessible bytes in this fs. */ +#define ROMFS_VHDR_CHKSUM 12 /* 12-15: Checksum of the first 512 bytes. */ +#define ROMFS_VHDR_VOLNAME 16 /* 16-..: Zero terminated volume name, padded to + * 16 byte boundary. */ + +#define ROMFS_VHDR_MAGIC "-rom1fs-" + +/* File header offset (multi-byte values are big-endian) */ + +#define ROMFS_FHDR_NEXT 0 /* 0-3: Offset of the next file header + * (zero if no more files) */ +#define ROMFS_FHDR_INFO 4 /* 4-7: Info for directories/hard links/ + * devices */ +#define ROMFS_FHDR_SIZE 8 /* 8-11: Size of this file in bytes */ +#define ROMFS_FHDR_CHKSUM 12 /* 12-15: Checksum covering the meta data, + * including the file name, and + * padding. */ +#define ROMFS_FHDR_NAME 16 /* 16-..: Zero terminated volume name, padded + * to 16 byte boundary. */ + +/* Bits 0-3 of the rf_next offset provide mode information. These are the + * values specified in */ + +#define RFNEXT_MODEMASK 7 /* Bits 0-2: Mode; bit 3: Executable */ +#define RFNEXT_ALLMODEMASK 15 /* Bits 0-3: All mode bits */ +#define RFNEXT_OFFSETMASK (~15) /* Bits n-3: Offset to next entry */ + +#define RFNEXT_HARDLINK 0 /* rf_info = Link destination file header */ +#define RFNEXT_DIRECTORY 1 /* rf_info = First file's header */ +#define RFNEXT_FILE 2 /* rf_info = Unused, must be zero */ +#define RFNEXT_SOFTLINK 3 /* rf_info = Unused, must be zero */ +#define RFNEXT_BLOCKDEV 4 /* rf_info = 16/16 bits major/minor number */ +#define RFNEXT_CHARDEV 5 /* rf_info = 16/16 bits major/minor number */ +#define RFNEXT_SOCKET 6 /* rf_info = Unused, must be zero */ +#define RFNEXT_FIFO 7 /* rf_info = Unused, must be zero */ +#define RFNEXT_EXEC 8 /* Modifier of RFNEXT_DIRECTORY and RFNEXT_FILE */ + +#define IS_MODE(rfn,mode) ((((uint32_t)(rfn))&RFNEXT_MODEMASK)==(mode)) +#define IS_HARDLINK(rfn) IS_MODE(rfn,RFNEXT_HARDLINK) +#define IS_DIRECTORY(rfn) IS_MODE(rfn,RFNEXT_DIRECTORY) +#define IS_FILE(rfn) IS_MODE(rfn,RFNEXT_FILE) +#define IS_EXECUTABLE(rfn) (((rfn) & RFNEXT_EXEC) != 0) + +/* RFNEXT_SOFTLINK, RFNEXT_BLOCKDEV, RFNEXT_CHARDEV, RFNEXT_SOCKET, and + * RFNEXT_FIFO are not presently supported. + */ + +/* Alignment macros */ + +#define ROMFS_ALIGNMENT 16 +#define ROMFS_MAXPADDING (ROMFS_ALIGNMENT-1) +#define ROMFS_ALIGNMASK (~ROMFS_MAXPADDING) +#define ROMFS_ALIGNUP(addr) ((((uint32_t)(addr))+ROMFS_MAXPADDING)&ROMFS_ALIGNMASK) +#define ROMFS_ALIGNDOWN(addr) (((uint32_t)(addr))&ROMFS_ALIGNMASK) + +/* Offset and sector conversions */ + +#define SEC_NDXMASK(r) ((r)->rm_hwsectorsize - 1) +#define SEC_NSECTORS(r,o) ((o) / (r)->rm_hwsectorsize) +#define SEC_ALIGN(r,o) ((o) & ~SEC_NDXMASK(r)) + +/* Maximum numbr of links that will be followed before we decide that there + * is a problem. + */ + +#define ROMF_MAX_LINKS 64 + +/**************************************************************************** + * Public Types + ****************************************************************************/ + +/* This structure represents the overall mountpoint state. An instance of this + * structure is retained as inode private data on each mountpoint that is + * mounted with a fat32 filesystem. + */ + +struct romfs_file_s; +struct romfs_mountpt_s +{ + struct inode *rm_blkdriver; /* The block driver inode that hosts the FAT32 fs */ + struct romfs_file_s *rm_head; /* A list to all files opened on this mountpoint */ + + bool rm_mounted; /* true: The file system is ready */ + uint16_t rm_hwsectorsize; /* HW: Sector size reported by block driver*/ + sem_t rm_sem; /* Used to assume thread-safe access */ + uint32_t rm_rootoffset; /* Saved offset to the first root directory entry */ + uint32_t rm_hwnsectors; /* HW: The number of sectors reported by the hardware */ + uint32_t rm_volsize; /* Size of the ROMFS volume */ + uint32_t rm_cachesector; /* Current sector in the rm_buffer */ + uint8_t *rm_xipbase; /* Base address of directly accessible media */ + uint8_t *rm_buffer; /* Device sector buffer, allocated if rm_xipbase==0 */ +}; + +/* This structure represents on open file under the mountpoint. An instance + * of this structure is retained as struct file specific information on each + * opened file. + */ + +struct romfs_file_s +{ + FAR struct romfs_file_s *rf_next; /* Retained in a singly linked list */ + uint32_t rf_startoffset; /* Offset to the start of the file data */ + uint32_t rf_size; /* Size of the file in bytes */ + uint32_t rf_cachesector; /* Current sector in the rf_buffer */ + uint8_t *rf_buffer; /* File sector buffer, allocated if rm_xipbase==0 */ + uint8_t rf_type; /* File type (for fstat()) */ +}; + +/* This structure is used internally for describing the result of + * walking a path + */ + +struct fs_romfsdir_s +{ + off_t fr_firstoffset; + off_t fr_curroffset; +}; +struct romfs_dirinfo_s +{ + /* These values describe the directory containing the terminal + * path component (of the terminal component itself if it is + * a directory. + */ + + struct fs_romfsdir_s rd_dir; /* Describes directory. */ + + /* Values from the ROMFS file entry */ + + uint32_t rd_next; /* Offset of the next file header+flags */ + uint32_t rd_size; /* Size (if file) */ +}; + +/**************************************************************************** + * Public Data + ****************************************************************************/ + +#undef EXTERN +#if defined(__cplusplus) +#define EXTERN extern "C" +extern "C" +{ +#else +#define EXTERN extern +#endif + +/**************************************************************************** + * Public Function Prototypes + ****************************************************************************/ + +void romfs_semtake(FAR struct romfs_mountpt_s *rm); +void romfs_semgive(FAR struct romfs_mountpt_s *rm); +int romfs_hwread(FAR struct romfs_mountpt_s *rm, FAR uint8_t *buffer, + uint32_t sector, unsigned int nsectors); +int romfs_filecacheread(FAR struct romfs_mountpt_s *rm, + FAR struct romfs_file_s *rf, uint32_t sector); +int romfs_hwconfigure(FAR struct romfs_mountpt_s *rm); +int romfs_fsconfigure(FAR struct romfs_mountpt_s *rm); +int romfs_checkmount(FAR struct romfs_mountpt_s *rm); +int romfs_finddirentry(FAR struct romfs_mountpt_s *rm, + FAR struct romfs_dirinfo_s *dirinfo, + FAR const char *path); +int romfs_parsedirentry(FAR struct romfs_mountpt_s *rm, + uint32_t offset, FAR uint32_t *poffset, FAR uint32_t *pnext, + FAR uint32_t *pinfo, FAR uint32_t *psize); +int romfs_parsefilename(FAR struct romfs_mountpt_s *rm, uint32_t offset, + FAR char *pname); +int romfs_datastart(FAR struct romfs_mountpt_s *rm, uint32_t offset, + FAR uint32_t *start); +int romfs_searchdir(struct romfs_mountpt_s *rm, + const char *entryname, int entrylen, uint32_t firstoffset, + struct romfs_dirinfo_s *dirinfo); + +#undef EXTERN +#if defined(__cplusplus) +} +#endif + +#endif /* __FS_ROMFS_FS_ROMFS_H */ diff --git a/fs/romfs/fs_romfsutil.c b/fs/romfs/fs_romfsutil.c new file mode 100644 index 0000000..3f61e6c --- /dev/null +++ b/fs/romfs/fs_romfsutil.c @@ -0,0 +1,615 @@ +/**************************************************************************** + * rm/romfs/fs_romfsutil.c + * + * Copyright (C) 2008-2009, 2013, 2017 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * References: Linux/Documentation/filesystems/romfs.txt + * + * 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 NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 + * COPYRIGHT OWNER 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. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef LOSCFG_FS_ROMFS +#include "fs_romfs.h" + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: romfs_swap32 + * + * Description: + * Convert the 32-bit big-endian value to little endian + * + ****************************************************************************/ + +inline uint32_t romfs_swap32(uint32_t value) +{ + return ((((value) & 0x000000ff) << 24) | (((value) & 0x0000ff00) << 8) | + (((value) & 0x00ff0000) >> 8) | (((value) & 0xff000000) >> 24)); +} + +/**************************************************************************** + * Name: romfs_devread32 + * + * Description: + * Read the big-endian 32-bit value from the mount device buffer + * + * Assumption: + * All values are aligned to 32-bit boundaries + * + ****************************************************************************/ + +static uint32_t romfs_devread32(struct romfs_mountpt_s *rm, int ndx) +{ + /* Extract the value */ + + uint32_t value = *(uint32_t *)&rm->rm_buffer[ndx]; + + /* Convert the big-endian value to native host endianness. */ + + return romfs_swap32(value); +} + +/**************************************************************************** + * Name: romfs_checkentry + * + * Description: + * Check if the entry at offset is a directory or file path segment + * + ****************************************************************************/ + +static inline int romfs_checkentry(struct romfs_mountpt_s *rm, + uint32_t offset, const char *entryname, + int entrylen, + struct romfs_dirinfo_s *dirinfo) +{ + char name[NAME_MAX + 1]; + uint32_t linkoffset; + uint32_t next; + uint32_t info; + uint32_t size; + int ret; + + /* Parse the directory entry at this offset (which may be re-directed + * to some other entry if HARLINKED). + */ + + ret = romfs_parsedirentry(rm, offset, &linkoffset, &next, &info, &size); + if (ret < 0) + { + return ret; + } + + /* Now we are pointing to the real entry of interest. Is it a + * directory? Or a file? + */ + + if (IS_DIRECTORY(next) || IS_FILE(next)) + { + /* Get the name of the directory entry. */ + + ret = romfs_parsefilename(rm, offset, name); + if (ret < 0) + { + return ret; + } + + /* Then check if this the name segment we are looking for. The + * string comparison is awkward because there is no terminator + * on entryname (there is a terminator on name, however) + */ + + if (memcmp(entryname, name, entrylen) == 0 && + strlen(name) == entrylen) + { + /* Found it -- save the component info and return success */ + + if (IS_DIRECTORY(next)) + { + dirinfo->rd_dir.fr_firstoffset = info; + dirinfo->rd_dir.fr_curroffset = info; + dirinfo->rd_size = 0; + } + else + { + dirinfo->rd_dir.fr_curroffset = offset; + dirinfo->rd_size = size; + } + + dirinfo->rd_next = next; + return OK; + } + } + + /* The entry is not a directory or it does not have the matching name */ + + return -ENOENT; +} + +/**************************************************************************** + * Name: romfs_devcacheread + * + * Description: + * Read the specified sector for specified offset into the sector cache. + * Return the index into the sector corresponding to the offset + * + ****************************************************************************/ + +uint32_t romfs_devcacheread(struct romfs_mountpt_s *rm, uint32_t offset) +{ + return offset; +} + +/**************************************************************************** + * Name: romfs_followhardlinks + * + * Description: + * Given the offset to a file header, check if the file is a hardlink. + * If so, traverse the hard links until the terminal, non-linked header + * so found and return that offset. + * + ****************************************************************************/ + +static int romfs_followhardlinks(struct romfs_mountpt_s *rm, uint32_t offset, + uint32_t *poffset) +{ + uint32_t next; + uint32_t ndx; + int i; + + /* Loop while we are redirected by hardlinks */ + + for (i = 0; i < ROMF_MAX_LINKS; i++) + { + /* Read the sector containing the offset into memory */ + + ndx = romfs_devcacheread(rm, offset); + if (ndx < 0) + { + return ndx; + } + + /* Check if this is a hard link */ + + next = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT); + if (!IS_HARDLINK(next)) + { + *poffset = offset; + return OK; + } + + /* Follow the hard-link */ + + offset = romfs_devread32(rm, ndx + ROMFS_FHDR_INFO); + } + + return -ELOOP; +} + +/**************************************************************************** + * Name: romfs_searchdir + * + * Description: + * This is part of the romfs_finddirentry log. Search the directory + * beginning at dirinfo->fr_firstoffset for entryname. + * + ****************************************************************************/ + +int romfs_searchdir(struct romfs_mountpt_s *rm, + const char *entryname, int entrylen, uint32_t firstoffset, + struct romfs_dirinfo_s *dirinfo) +{ + uint32_t offset; + uint32_t next; + uint32_t ndx; + int ret; + + /* Then loop through the current directory until the directory + * with the matching name is found. Or until all of the entries + * the directory have been examined. + */ + + offset = firstoffset; + do + { + /* Read the sector into memory (do this before calling + * romfs_checkentry() so we won't have to read the sector + * twice in the event that the offset refers to a hardlink). + */ + + ndx = romfs_devcacheread(rm, offset); + if (ndx < 0) + { + return ndx; + } + + /* Because everything is chunked and aligned to 16-bit boundaries, + * we know that most the basic node info fits into the sector. + */ + + next = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT) & RFNEXT_OFFSETMASK; + + /* Check if the name this entry is a directory with the matching + * name + */ + + ret = romfs_checkentry(rm, offset, entryname, entrylen, dirinfo); + if (ret == OK) + { + /* Its a match! Return success */ + + return OK; + } + + /* No match... select the offset to the next entry */ + + offset = next; + } + while (next != 0); + + /* There is nothing in this directory with that name */ + + return -ENOENT; +} + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: romfs_semtake + ****************************************************************************/ + +void romfs_semtake(struct romfs_mountpt_s *rm) +{ + int ret; + + do + { + /* Take the semaphore (perhaps waiting) */ + + ret = sem_wait(&rm->rm_sem); + + /* The only case that an error should occur here is if the wait was + * awakened by a signal. + */ + + DEBUGASSERT(ret == OK || ret == -EINTR); + } + while (ret == -EINTR); +} + +/**************************************************************************** + * Name: romfs_semgive + ****************************************************************************/ + +void romfs_semgive(struct romfs_mountpt_s *rm) +{ + (void)sem_post(&rm->rm_sem); +} + +/**************************************************************************** + * Name: romfs_hwconfigure + * + * Description: + * This function is called as part of the ROMFS mount operation It + * configures the ROMFS filestem for use on this block driver. This includes + * the accounting for the geometry of the device, setting up any XIP modes + * of operation, and/or allocating any cache buffers. + * + ****************************************************************************/ + +int romfs_hwconfigure(struct romfs_mountpt_s *rm) +{ + uint32_t total_size; + + rm->rm_buffer = (uint8_t *)DMA_TO_VMM_ADDR(RAMDISK_ADDR); + total_size = romfs_devread32(rm, ROMFS_VHDR_SIZE); + + rm->rm_hwnsectors = total_size; + rm->rm_hwsectorsize = 1; + rm->rm_cachesector = (uint32_t)-1; + rm->rm_volsize = total_size; + + rm->rm_buffer = (uint8_t *)malloc(total_size); + if (!rm->rm_buffer) + { + return -ENOMEM; + } + + memcpy(rm->rm_buffer, (void *)DMA_TO_VMM_ADDR(RAMDISK_ADDR), total_size); + + return OK; +} + +/**************************************************************************** + * Name: romfs_fsconfigure + * + * Description: + * This function is called as part of the ROMFS mount operation It + * sets up the mount structure to include configuration information contained + * in the ROMFS header. This is the place where we actually determine if + * the media contains a ROMFS filesystem. + * + ****************************************************************************/ + +int romfs_fsconfigure(struct romfs_mountpt_s *rm) +{ + const char *name; + uint32_t ndx; + + /* Then get information about the ROMFS filesystem on the devices managed + * by this block driver. Read sector zero which contains the volume header. + */ + + ndx = romfs_devcacheread(rm, 0); + if (ndx < 0) + { + return ndx; + } + + /* Verify the magic number at that identifies this as a ROMFS filesystem */ + + if (memcmp(rm->rm_buffer, ROMFS_VHDR_MAGIC, 8) != 0) + { + return -EINVAL; + } + + /* The root directory entry begins right after the header */ + + name = (FAR const char *)&rm->rm_buffer[ROMFS_VHDR_VOLNAME]; + rm->rm_rootoffset = ROMFS_ALIGNUP(ROMFS_VHDR_VOLNAME + strlen(name) + 1); + + /* and return success */ + + rm->rm_mounted = true; + return OK; +} + +/**************************************************************************** + * Name: romfs_checkmount + * + * Description: Check if the mountpoint is still valid. + * + * The caller should hold the mountpoint semaphore + * + ****************************************************************************/ + +int romfs_checkmount(struct romfs_mountpt_s *rm) +{ + return OK; +} + +/**************************************************************************** + * Name: romfs_parsedirentry + * + * Description: + * Return the directory entry at this offset. If rf is NULL, then the + * mount device resources are used. Otherwise, file resources are used. + * + ****************************************************************************/ + +int romfs_parsedirentry(struct romfs_mountpt_s *rm, uint32_t offset, + uint32_t *poffset, uint32_t *pnext, uint32_t *pinfo, + uint32_t *psize) +{ + uint32_t save; + uint32_t next; + uint32_t ndx; + int ret; + + /* Read the sector into memory */ + + ndx = romfs_devcacheread(rm, offset); + if (ndx < 0) + { + return ndx; + } + + /* Yes.. Save the first 'next' value. That has the offset needed to + * traverse the parent directory. But we may need to change the type + * after we follow the hard links. + */ + + save = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT); + + /* Traverse hardlinks as necessary to get to the real file header */ + + ret = romfs_followhardlinks(rm, offset, poffset); + if (ret < 0) + { + return ret; + } + + if (*poffset != offset) + { + ndx = romfs_devcacheread(rm, *poffset); + if (ndx < 0) + { + return ndx; + } + } + + /* Because everything is chunked and aligned to 16-bit boundaries, + * we know that most the basic node info fits into the sector. The + * associated name may not, however. + */ + + next = romfs_devread32(rm, ndx + ROMFS_FHDR_NEXT); + *pnext = (save & RFNEXT_OFFSETMASK) | (next & RFNEXT_ALLMODEMASK); + *pinfo = romfs_devread32(rm, ndx + ROMFS_FHDR_INFO); + *psize = romfs_devread32(rm, ndx + ROMFS_FHDR_SIZE); + + return OK; +} + +/**************************************************************************** + * Name: romfs_parsefilename + * + * Description: + * Return the filename from directory entry at this offset + * + ****************************************************************************/ + +int romfs_parsefilename(struct romfs_mountpt_s *rm, uint32_t offset, + char *pname) +{ + uint32_t ndx; + uint16_t namelen; + uint16_t chunklen; + bool done; + + /* Loop until the whole name is obtained or until NAME_MAX characters + * of the name have been parsed. + */ + + offset += ROMFS_FHDR_NAME; + for (namelen = 0, done = false; namelen < NAME_MAX && !done; ) + { + /* Read the sector into memory */ + + ndx = romfs_devcacheread(rm, offset + namelen); + if (ndx < 0) + { + return ndx; + } + + /* Is the name terminated in this 16-byte block */ + + if (rm->rm_buffer[ndx + 15] == '\0') + { + /* Yes.. then this chunk is less than 16 */ + + chunklen = strlen((FAR char *)&rm->rm_buffer[ndx]); + done = true; + } + else + { + /* No.. then this chunk is 16 bytes in length */ + + chunklen = 16; + } + + /* Check if we would exceed the NAME_MAX */ + + if (namelen + chunklen > NAME_MAX) + { + chunklen = NAME_MAX - namelen; + done = true; + } + + /* Copy the chunk */ + + memcpy(&pname[namelen], &rm->rm_buffer[ndx], chunklen); + namelen += chunklen; + } + + /* Terminate the name (NAME_MAX+1 chars total) and return success */ + + pname[namelen] = '\0'; + + return OK; +} + +/**************************************************************************** + * Name: romfs_datastart + * + * Description: + * Given the offset to a file header, return the offset to the start of + * the file data + * + ****************************************************************************/ + +int romfs_datastart(struct romfs_mountpt_s *rm, uint32_t offset, + uint32_t *start) +{ + uint32_t ndx; + int ret; + + /* Traverse hardlinks as necessary to get to the real file header */ + + ret = romfs_followhardlinks(rm, offset, &offset); + if (ret < 0) + { + return ret; + } + + /* Loop until the header size is obtained. */ + + offset += ROMFS_FHDR_NAME; + for (; ; ) + { + /* Read the sector into memory */ + + ndx = romfs_devcacheread(rm, offset); + if (ndx < 0) + { + return ndx; + } + + /* Get the offset to the next chunk */ + + offset += 16; + if (offset >= rm->rm_volsize) + { + return -EIO; + } + + /* Is the name terminated in this 16-byte block */ + + if (rm->rm_buffer[ndx + 15] == '\0') + { + /* Yes.. then the data starts at the next chunk */ + + *start = offset; + return OK; + } + } + + return -EINVAL; /* Won't get here */ +} + +#endif \ No newline at end of file -- Gitee