diff --git a/fs/romfs/Kconfig b/fs/romfs/Kconfig new file mode 100644 index 0000000000000000000000000000000000000000..4014cf6d1d1fea3ea32cdee9773d332109525dc1 --- /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 0000000000000000000000000000000000000000..b4c6ebca82f427f9e263346f64554e9592aec474 --- /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 0000000000000000000000000000000000000000..13c03c297f76c845da4190e350d6d5d63ce5e89b --- /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 0000000000000000000000000000000000000000..6f8102a1c97e655ad8a046b573c9100f5bd6c5f8 --- /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 0000000000000000000000000000000000000000..3f61e6c5573ae4d735e0667dbf5cc0aaa1023f9c --- /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