123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990 |
- /****************************************************************************
- * rm/romfs/fs_romfsutil.c
- *
- * Copyright (C) 2008-2009, 2013, 2017 Gregory Nutt. All rights reserved.
- * Author: Gregory Nutt <gnutt@nuttx.org>
- *
- * 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 <nuttx/config.h>
- #include <sys/types.h>
- #include <stdint.h>
- #include <stdbool.h>
- #include <stdlib.h>
- #include <string.h>
- #include <assert.h>
- #include <errno.h>
- #include <assert.h>
- #include <debug.h>
- #include <nuttx/kmalloc.h>
- #include <nuttx/fs/ioctl.h>
- #include <nuttx/fs/dirent.h>
- #include <nuttx/mtd/mtd.h>
- #include "fs_romfs.h"
- /****************************************************************************
- * Private Functions
- ****************************************************************************/
- /****************************************************************************
- * 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)
- {
- return ((((uint32_t)rm->rm_buffer[ndx] & 0xff) << 24) |
- (((uint32_t)rm->rm_buffer[ndx + 1] & 0xff) << 16) |
- (((uint32_t)rm->rm_buffer[ndx + 2] & 0xff) << 8) |
- ((uint32_t)rm->rm_buffer[ndx + 3] & 0xff));
- }
- /****************************************************************************
- * 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
- *
- ****************************************************************************/
- int16_t romfs_devcacheread(struct romfs_mountpt_s *rm, uint32_t offset)
- {
- uint32_t sector;
- int ret;
- /* rm->rm_cachesector holds the current sector that is buffer in or referenced
- * by rm->tm_buffer. If the requested sector is the same as this sector,
- * then we do nothing.
- */
- sector = SEC_NSECTORS(rm, offset);
- if (rm->rm_cachesector != sector)
- {
- /* Check the access mode */
- if (rm->rm_xipbase)
- {
- /* In XIP mode, rf_buffer is just an offset pointer into the device
- * address space.
- */
- rm->rm_buffer = rm->rm_xipbase + SEC_ALIGN(rm, offset);
- }
- else
- {
- /* In non-XIP mode, we will have to read the new sector. */
- ret = romfs_hwread(rm, rm->rm_buffer, sector, 1);
- if (ret < 0)
- {
- return (int16_t)ret;
- }
- }
- /* Update the cached sector number */
- rm->rm_cachesector = sector;
- }
- /* Return the offset */
- return offset & SEC_NDXMASK(rm);
- }
- /****************************************************************************
- * 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;
- int16_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.
- *
- ****************************************************************************/
- static inline int romfs_searchdir(struct romfs_mountpt_s *rm,
- const char *entryname, int entrylen,
- struct romfs_dirinfo_s *dirinfo)
- {
- uint32_t offset;
- uint32_t next;
- int16_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 = dirinfo->rd_dir.fr_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 = nxsem_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)
- {
- nxsem_post(&rm->rm_sem);
- }
- /****************************************************************************
- * Name: romfs_hwread
- *
- * Description: Read the specified sector into the sector buffer
- *
- ****************************************************************************/
- int romfs_hwread(struct romfs_mountpt_s *rm, uint8_t *buffer, uint32_t sector,
- unsigned int nsectors)
- {
- int ret = OK;
- /* Check the access mode */
- if (rm->rm_xipbase)
- {
- /* In XIP mode, we just copy the requested data */
- memcpy(buffer,
- rm->rm_xipbase + sector*rm->rm_hwsectorsize,
- nsectors*rm->rm_hwsectorsize);
- }
- else
- {
- /* In non-XIP mode, we have to read the data from the device */
- struct inode *inode = rm->rm_blkdriver;
- ssize_t nsectorsread = -ENODEV;
- DEBUGASSERT(inode);
- if (INODE_IS_MTD(inode))
- {
- nsectorsread =
- MTD_BREAD(inode->u.i_mtd, sector, nsectors, buffer);
- }
- else if (inode->u.i_bops->read)
- {
- nsectorsread =
- inode->u.i_bops->read(inode, buffer, sector, nsectors);
- }
- if (nsectorsread == (ssize_t)nsectors)
- {
- ret = OK;
- }
- else if (nsectorsread < 0)
- {
- ret = nsectorsread;
- }
- }
- return ret;
- }
- /****************************************************************************
- * Name: romfs_filecacheread
- *
- * Description:
- * Read the specified sector into the sector cache
- *
- ****************************************************************************/
- int romfs_filecacheread(struct romfs_mountpt_s *rm, struct romfs_file_s *rf,
- uint32_t sector)
- {
- int ret;
- finfo("sector: %d cached: %d sectorsize: %d XIP base: %p buffer: %p\n",
- sector, rf->rf_cachesector, rm->rm_hwsectorsize,
- rm->rm_xipbase, rf->rf_buffer);
- /* rf->rf_cachesector holds the current sector that is buffer in or referenced
- * by rf->rf_buffer. If the requested sector is the same as this sector,
- * then we do nothing.
- */
- if (rf->rf_cachesector != sector)
- {
- /* Check the access mode */
- if (rm->rm_xipbase)
- {
- /* In XIP mode, rf_buffer is just an offset pointer into the device
- * address space.
- */
- rf->rf_buffer = rm->rm_xipbase + sector * rm->rm_hwsectorsize;
- finfo("XIP buffer: %p\n", rf->rf_buffer);
- }
- else
- {
- /* In non-XIP mode, we will have to read the new sector. */
- finfo("Calling romfs_hwread\n");
- ret = romfs_hwread(rm, rf->rf_buffer, sector, 1);
- if (ret < 0)
- {
- ferr("ERROR: romfs_hwread failed: %d\n", ret);
- return ret;
- }
- }
- /* Update the cached sector number */
- rf->rf_cachesector = sector;
- }
- return OK;
- }
- /****************************************************************************
- * 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)
- {
- struct inode *inode = rm->rm_blkdriver;
- int ret;
- /* Get the underlying device geometry */
- #ifdef CONFIG_DEBUG_FEATURES
- if (inode == NULL)
- {
- return -ENODEV;
- }
- #endif
- if (INODE_IS_MTD(inode))
- {
- struct mtd_geometry_s mgeo;
- ret = MTD_IOCTL(inode->u.i_mtd, MTDIOC_GEOMETRY,
- (unsigned long)&mgeo);
- if (ret != OK)
- {
- return ret;
- }
- /* Save that information in the mount structure */
- rm->rm_hwsectorsize = mgeo.blocksize;
- rm->rm_hwnsectors = mgeo.neraseblocks *
- (mgeo.erasesize / mgeo.blocksize);
- }
- else
- {
- struct geometry geo;
- ret = inode->u.i_bops->geometry(inode, &geo);
- if (ret != OK)
- {
- return ret;
- }
- if (!geo.geo_available)
- {
- return -EBUSY;
- }
- /* Save that information in the mount structure */
- rm->rm_hwsectorsize = geo.geo_sectorsize;
- rm->rm_hwnsectors = geo.geo_nsectors;
- }
- /* Determine if block driver supports the XIP mode of operation */
- rm->rm_cachesector = (uint32_t)-1;
- if (INODE_IS_MTD(inode))
- {
- ret = MTD_IOCTL(inode->u.i_mtd, MTDIOC_XIPBASE,
- (unsigned long)&rm->rm_xipbase);
- }
- else if (inode->u.i_bops->ioctl != NULL)
- {
- ret = inode->u.i_bops->ioctl(inode, BIOC_XIPBASE,
- (unsigned long)&rm->rm_xipbase);
- }
- else
- {
- ret = -ENOTSUP;
- }
- if (ret == OK && rm->rm_xipbase)
- {
- /* Yes.. Then we will directly access the media (vs.
- * copying into an allocated sector buffer.
- */
- rm->rm_buffer = rm->rm_xipbase;
- rm->rm_cachesector = 0;
- return OK;
- }
- /* Allocate the device cache buffer for normal sector accesses */
- rm->rm_buffer = (FAR uint8_t *)kmm_malloc(rm->rm_hwsectorsize);
- if (!rm->rm_buffer)
- {
- return -ENOMEM;
- }
- 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;
- int16_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;
- }
- /* Then extract the values we need from the header and return success */
- rm->rm_volsize = romfs_devread32(rm, ROMFS_VHDR_SIZE);
- /* 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_fileconfigure
- *
- * Description:
- * This function is called as part of the ROMFS file open operation It
- * sets up the file structure to handle buffer appropriately, depending
- * upon XIP mode or not.
- *
- ****************************************************************************/
- int romfs_fileconfigure(struct romfs_mountpt_s *rm, struct romfs_file_s *rf)
- {
- /* Check if XIP access mode is supported. If so, then we do not need
- * to allocate anything.
- */
- if (rm->rm_xipbase)
- {
- /* We'll put a valid address in rf_buffer just in case. */
- rf->rf_cachesector = 0;
- rf->rf_buffer = rm->rm_xipbase;
- }
- else
- {
- /* Nothing in the cache buffer */
- rf->rf_cachesector = (uint32_t)-1;
- /* Create a file buffer to support partial sector accesses */
- rf->rf_buffer = (FAR uint8_t *)kmm_malloc(rm->rm_hwsectorsize);
- if (!rf->rf_buffer)
- {
- return -ENOMEM;
- }
- }
- 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)
- {
- struct inode *inode;
- struct geometry geo;
- int ret;
- /* If the fs_mounted flag is false, then we have already handled the loss
- * of the mount.
- */
- DEBUGASSERT(rm && rm->rm_blkdriver);
- if (rm->rm_mounted)
- {
- /* We still think the mount is healthy. Check an see if this is
- * still the case
- */
- inode = rm->rm_blkdriver;
- if (INODE_IS_MTD(inode))
- {
- /* It is impossible to remove MTD device */
- return OK;
- }
- else if (inode->u.i_bops->geometry)
- {
- ret = inode->u.i_bops->geometry(inode, &geo);
- if (ret == OK && geo.geo_available && !geo.geo_mediachanged)
- {
- return OK;
- }
- }
- /* If we get here, the mount is NOT healthy */
- rm->rm_mounted = false;
- }
- return -ENODEV;
- }
- /****************************************************************************
- * Name: romfs_finddirentry
- *
- * Description:
- * Given a path to something that may or may not be in the file system,
- * return the directory entry of the item.
- *
- ****************************************************************************/
- int romfs_finddirentry(struct romfs_mountpt_s *rm,
- struct romfs_dirinfo_s *dirinfo, const char *path)
- {
- const char *entryname;
- const char *terminator;
- int entrylen;
- int ret;
- /* Start with the first element after the root directory */
- 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;
- /* The root directory is a special case */
- if (!path || path[0] == '\0')
- {
- return OK;
- }
- /* Then loop for each directory/file component in the full path */
- entryname = path;
- terminator = NULL;
- for (; ; )
- {
- /* Find the start of the next path component */
- while (*entryname == '/') entryname++;
- /* Find the end of the next path component */
- terminator = strchr(entryname, '/');
- if (!terminator)
- {
- entrylen = strlen(entryname);
- }
- else
- {
- entrylen = terminator - entryname;
- }
- /* Long path segment names will be truncated to NAME_MAX */
- if (entrylen > NAME_MAX)
- {
- entrylen = NAME_MAX;
- }
- /* Then find the entry in the current directory with the
- * matching name.
- */
- ret = romfs_searchdir(rm, entryname, entrylen, dirinfo);
- if (ret < 0)
- {
- return ret;
- }
- /* Was that the last path component? */
- if (!terminator)
- {
- /* Yes.. return success */
- return OK;
- }
- /* No... If that was not the last path component, then it had
- * better have been a directory
- */
- if (!IS_DIRECTORY(dirinfo->rd_next))
- {
- return -ENOTDIR;
- }
- /* Setup to search the next directory for the next component
- * of the path
- */
- entryname = terminator;
- }
- return ERROR; /* Won't get here */
- }
- /****************************************************************************
- * 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;
- int16_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 necesssary to get to the real file header */
- ret = romfs_followhardlinks(rm, offset, poffset);
- if (ret < 0)
- {
- return ret;
- }
- /* 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)
- {
- int16_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)
- {
- int16_t ndx;
- int ret;
- /* Traverse hardlinks as necesssary 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 */
- }
|