diff options
Diffstat (limited to 'nuttx/fs/nxffs/nxffs_pack.c')
| -rw-r--r-- | nuttx/fs/nxffs/nxffs_pack.c | 1572 |
1 files changed, 0 insertions, 1572 deletions
diff --git a/nuttx/fs/nxffs/nxffs_pack.c b/nuttx/fs/nxffs/nxffs_pack.c deleted file mode 100644 index 5a82ae4fd..000000000 --- a/nuttx/fs/nxffs/nxffs_pack.c +++ /dev/null @@ -1,1572 +0,0 @@ -/**************************************************************************** - * fs/nxffs/nxffs_pack.c - * - * Copyright (C) 2011 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 <string.h> -#include <errno.h> -#include <assert.h> -#include <crc32.h> -#include <debug.h> - -#include <nuttx/kmalloc.h> - -#include "nxffs.h" - -/**************************************************************************** - * Pre-processor Definitions - ****************************************************************************/ - -/**************************************************************************** - * Public Types - ****************************************************************************/ -/* This structure supports access to one inode data stream */ - -struct nxffs_packstream_s -{ - struct nxffs_entry_s entry; /* Describes the inode header */ - off_t fpos; /* Current file position */ - off_t blkoffset; /* Offset to the current data block */ - uint16_t blklen; /* Size of this block */ - uint16_t blkpos; /* Position in block corresponding to fpos */ -}; - -/* The structure supports the overall packing operation */ - -struct nxffs_pack_s -{ - /* These describe the source and destination streams */ - - struct nxffs_packstream_s src; - struct nxffs_packstream_s dest; - - /* These describe the state of the current contents of the (destination) - * volume->pack buffer. - */ - - FAR uint8_t *iobuffer; /* I/O block start position */ - off_t ioblock; /* I/O block number */ - off_t block0; /* First I/O block number in the erase block */ - uint16_t iooffset; /* I/O block offset */ -}; - -/**************************************************************************** - * Public Variables - ****************************************************************************/ - -/**************************************************************************** - * Private Functions - ****************************************************************************/ - -/**************************************************************************** - * Name: nxffs_getblock - * - * Description: - * Return the I/O block number that includes the provided offset. - * - * Input Parameters: - * volume - Describes the NXFFS volume - * offset - FLASH offset - * - * Returned Value: - * The I/O block number. - * - ****************************************************************************/ - -static off_t nxffs_getblock(FAR struct nxffs_volume_s *volume, off_t offset) -{ - return offset / volume->geo.blocksize; -} - -/**************************************************************************** - * Name: nxffs_getoffset - * - * Description: - * Given an I/O block number return the block offset corresponding to the - * FLASH offset; - * - * Input Parameters: - * volume - Describes the NXFFS volume - * offset - FLASH offset - * - * Returned Value: - * The I/O block number. - * - ****************************************************************************/ - -static off_t nxffs_getoffset(FAR struct nxffs_volume_s *volume, - off_t offset, off_t block) -{ - return offset - block * volume->geo.blocksize; -} - -/**************************************************************************** - * Name: nxffs_packtell - * - * Description: - * Report the current destination position in the pack buffer. - * - * Input Parameters: - * volume - Describes the NXFFS volume - * pack - The volume packing state structure. - * - * Returned Value: - * The offset from the beginning of FLASH to the current seek position. - * - ****************************************************************************/ - -static off_t nxffs_packtell(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - return pack->ioblock * volume->geo.blocksize + pack->iooffset; -} - -/**************************************************************************** - * Name: nxffs_packvalid - * - * Description: - * Check if the current destination block is valid. - * - * Input Parameters: - * pack - The volume packing state structure. - * - * Returned Values: - * None - * - ****************************************************************************/ - -static inline bool nxffs_packvalid(FAR struct nxffs_pack_s *pack) -{ - FAR struct nxffs_block_s *blkhdr; - - blkhdr = (FAR struct nxffs_block_s *)pack->iobuffer; - return (memcmp(blkhdr->magic, g_blockmagic, NXFFS_MAGICSIZE) == 0 && - blkhdr->state == BLOCK_STATE_GOOD); -} - -/**************************************************************************** - * Name: nxffs_mediacheck - * - * Description: - * Verify that there is at least one valid block and at least one valid - * inode header on the media. On successful return, the volume packing - * structure is initialized and contains the offset to the first valid - * inode header is returned. - * - * Input Parameters: - * volume - The volume to be packed. - * pack - The volume packing state structure. - * - * Returned Values: - * The offset to the data area on the first valid block. Zero is return - * if there are no valid blocks or if there are no valid inode headers - * after the first valid block. - * - ****************************************************************************/ - -static inline off_t nxffs_mediacheck(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - off_t froffset; - int ret; - - /* Initialize the packing structure to all zero */ - - memset(pack, 0, sizeof(struct nxffs_pack_s)); - - /* Find the FLASH offset to the first valid block */ - - volume->ioblock = 0; - ret = nxffs_validblock(volume, &volume->ioblock); - if (ret < 0) - { - /* No valid blocks? Return offset zero. */ - - return 0; - } - - /* The offset to the free location to pack is then just after the block - * header in this block. - */ - - volume->iooffset = SIZEOF_NXFFS_BLOCK_HDR; - froffset = nxffs_iotell(volume); - - /* Get the offset to the first valid inode entry after this free offset */ - - ret = nxffs_nextentry(volume, froffset, &pack->src.entry); - if (ret < 0) - { - /* No valid entries on the media -- Return offset zero */ - - return 0; - } - - /* Okay.. the start block and first entry have been found */ - - return froffset; -} - -/**************************************************************************** - * Name: nxffs_startpos - * - * Description: - * Find the position in FLASH memory where we should begin packing. That - * position is the place where there is a gap between the last and the next - * valid inode. On entry, the volume packing structure should be as it - * was initialized by nxffx_mediacheck. on successful return, the volume - * packing state structure will be updated to begin the packing operation. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * froffset - On input, this is the location where we should be searching - * for the location to begin packing. On successful return, froffset - * will be set the the offset in FLASH where the first inode should be - * copied to. If -ENOSPC is returned -- meaning that the FLASH is full - * -- then no packing can be performed. In this case, then the free - * flash offset is returned through this location. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. If -ENOSPC is returned then the - * free FLASH offset is also returned. - * - ****************************************************************************/ - -static inline int nxffs_startpos(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack, - off_t *froffset) -{ - struct nxffs_blkentry_s blkentry; - off_t offset = *froffset; - off_t wasted; - off_t nbytes; - int ret; - - /* Loop until we find a gap of unused FLASH large enough to warrant - * compacting. - */ - - for(;;) - { - /* Is there wasted space between the offset where the we could have - * valid data and the offset to the beginning of the first valid - * inode header? NOTE: The threshold check is not accurate, there - * may or may not be intervening block headers making the separation - * seem larger than it is. - */ - - DEBUGASSERT(pack->src.entry.hoffset >= offset); - wasted = pack->src.entry.hoffset - offset; - if (wasted > CONFIG_NXFFS_PACKTHRESHOLD) - { - /* This is where we must begin packing. Describe the destination - * inode header (only non-zero entries need to be initialized). - */ - - pack->dest.entry.name = pack->src.entry.name; - pack->dest.entry.utc = pack->src.entry.utc; - pack->dest.entry.datlen = pack->src.entry.datlen; - - /* The destination entry now "owns" the name string */ - - pack->src.entry.name = NULL; - - /* Return the FLASH offset to the destination inode header */ - - *froffset = offset; - return OK; - } - - /* Free the allocated memory in the entry */ - - nxffs_freeentry(&pack->src.entry); - - /* Update the offset to the first byte at the end of the last data - * block. - */ - - nbytes = 0; - offset = pack->src.entry.doffset; - - while (nbytes < pack->src.entry.datlen) - { - /* Read the next data block header */ - - ret = nxffs_nextblock(volume, offset, &blkentry); - if (ret < 0) - { - fdbg("Failed to find next data block: %d\n", -ret); - return ret; - } - - /* Get the number of blocks and pointer to where the next - * data block might lie. - */ - - nbytes += blkentry.datlen; - offset = blkentry.hoffset + SIZEOF_NXFFS_DATA_HDR + blkentry.datlen; - } - - /* Make sure there is space at this location for an inode header */ - - nxffs_ioseek(volume, offset); - if (volume->iooffset + SIZEOF_NXFFS_INODE_HDR > volume->geo.blocksize) - { - /* No.. not enough space here. Find the next valid block */ - - volume->ioblock++; - ret = nxffs_validblock(volume, &volume->ioblock); - if (ret < 0) - { - /* No valid blocks? Then there is nothing we can do. Return - * the end-of-flash indication. - */ - - *froffset = volume->froffset; - return -ENOSPC; - } - - volume->iooffset = SIZEOF_NXFFS_BLOCK_HDR; - offset = nxffs_iotell(volume); - } - - /* Get the offset to the next valid inode entry */ - - ret = nxffs_nextentry(volume, offset, &pack->src.entry); - if (ret < 0) - { - /* No more valid inode entries. Just return an end-of-flash error - * indication. However, there could be many deleted inodes; set - * volume->froffset to indicate the true free FLASH position. - */ - - *froffset = offset; - return -ENOSPC; - } - } - - /* We won't get here */ - - return -ENOSYS; -} - -/**************************************************************************** - * Name: nxffs_srcsetup - * - * Description: - * Given a valid src inode, configure the src data stream. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * offset - FLASH offset to the data block header (will be zero for zero- - * files. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. - * - ****************************************************************************/ - -static int nxffs_srcsetup(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack, off_t offset) -{ - /* Start with the first data block */ - - pack->src.blkoffset = offset; - pack->src.blkpos = 0; - - /* Zero-length files have no valid data block offset */ - - if (offset > 0) - { - /* Seek to the data block header, read and verify the block header */ - - int ret = nxffs_rdblkhdr(volume, offset, &pack->src.blklen); - if (ret < 0) - { - fdbg("Failed to verify the data block header: %d\n", -ret); - } - return ret; - } - - DEBUGASSERT(pack->src.entry.datlen == 0); - return OK; -} - -/**************************************************************************** - * Name: nxffs_destsetup - * - * Description: - * Given a valid dest inode, configure the dest data stream. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. - * - ****************************************************************************/ - -static int nxffs_destsetup(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - size_t mindata; - int namlen; - int ret; - - /* The destination can be in one of three of states: - * - * State 1: The inode position was not yet been found. This condition can - * only occur on initial entry into nxffs_packblock() when there we no space - * for the inode header at the end of the previous block. We must now be - * at the beginning of a shiny new I/O block, so we should always have - * space for a new inode header right here. - */ - - if (pack->dest.entry.hoffset == 0) - { - /* Is there room for an inode structure in this block? */ - - if(pack->iooffset + SIZEOF_NXFFS_INODE_HDR > volume->geo.blocksize) - { - /* No.. that inode name will not fit in this block. Return an - * indication that we are at the end of the block and try again - * later. - */ - - return -ENOSPC; - } - - /* The inode header will be placed at this position (but not until - * we are finished. - */ - - pack->dest.entry.hoffset = nxffs_packtell(volume, pack); - - /* Make sure that the initialize state of the inode header memory is - * erased. This is important because we may not write to inode header - * until it has already been written to FLASH. - */ - - memset(&pack->iobuffer[pack->iooffset], CONFIG_NXFFS_ERASEDSTATE, - SIZEOF_NXFFS_INODE_HDR); - - /* Then set the new FLASH offset */ - - pack->iooffset += SIZEOF_NXFFS_INODE_HDR; - } - - /* State 2: inode position found, inode header not written, inode name - * position not determined. - */ - - if (pack->dest.entry.noffset == 0) - { - /* Find the offset to the string memory. Will if fit in this block? - * Note: iooffset has already been incremented to account for the - * size of the inode header. - */ - - namlen = strlen(pack->dest.entry.name); - if (pack->iooffset + namlen > volume->geo.blocksize) - { - /* No.. that inode name will not fit in this block. Return an - * indication that we are at the end of the block and try again - * later. - */ - - return -ENOSPC; - } - - /* Yes.. Write the inode name to the volume packing buffer now, but do - * not free the name string memory yet; it will be needed later to\ - * calculate the header CRC. - */ - - memcpy(&pack->iobuffer[pack->iooffset], pack->dest.entry.name, namlen); - - /* Reserve space for the inode name */ - - pack->dest.entry.noffset = nxffs_packtell(volume, pack); - pack->iooffset += namlen; - } - - /* State 3: Inode header not-written, inode name written. Still need the position - * of the first data block. - * - * Deal with the special case where the source inode is a zero length file - * with no data blocks to be transferred. - */ - - if (pack->src.entry.doffset > 0) - { - if (pack->dest.entry.doffset == 0) - { - /* Will the data block header plus a minimal amount of data fit in this - * block? (or the whole file if the file is very small). - */ - - mindata = MIN(NXFFS_MINDATA, pack->dest.entry.datlen); - if (pack->iooffset + SIZEOF_NXFFS_DATA_HDR + mindata > volume->geo.blocksize) - { - /* No.. return an indication that we are at the end of the block - * and try again later. - */ - - ret = -ENOSPC; - goto errout; - } - - /* Yes.. reserve space for the data block header */ - - pack->dest.entry.doffset = nxffs_packtell(volume, pack); - pack->iooffset += SIZEOF_NXFFS_DATA_HDR; - - /* Initialize the output data stream to start with the first data block */ - - pack->dest.blkoffset = pack->dest.entry.doffset; - pack->dest.blklen = 0; - pack->dest.blkpos = 0; - } - - /* State 4: Starting a new block. Verify that there is space in the current - * block for another (minimal sized) block - */ - - if (pack->dest.blkoffset == 0) - { - /* Will the data block header plus a minimal amount of data fit in this - * block? (or the whole file if the file is very small). - */ - - mindata = MIN(NXFFS_MINDATA, pack->dest.entry.datlen); - if (pack->iooffset + SIZEOF_NXFFS_DATA_HDR + mindata > volume->geo.blocksize) - { - /* No.. return an indication that we are at the end of the block - * and try again later. - */ - - ret = -ENOSPC; - goto errout; - } - - /* Yes.. reserve space for the data block header */ - - pack->dest.blkoffset = nxffs_packtell(volume, pack); - pack->iooffset += SIZEOF_NXFFS_DATA_HDR; - pack->dest.blklen = 0; - pack->dest.blkpos = 0; - } - } - - ret = OK; - -errout: - volume->froffset = nxffs_packtell(volume, pack); - return ret; -} - -/**************************************************************************** - * Name: nxffs_wrinodehdr - * - * Description: - * Write the destination inode header (only) to FLASH. Note that the inode - * name has already been written to FLASH (thus greatly simplifying the - * the complexity of this operation). - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure (not used). - * - ****************************************************************************/ - -static int nxffs_wrinodehdr(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - FAR struct nxffs_inode_s *inode; - off_t ioblock; - uint16_t iooffset; - uint32_t crc; - int namlen; - int ret; - - /* Get seek positions corresponding to the inode header location */ - - ioblock = nxffs_getblock(volume, pack->dest.entry.hoffset); - iooffset = nxffs_getoffset(volume, pack->dest.entry.hoffset, ioblock); - - /* The inode header is not written until all of the inode data has been - * packed into its new location. As a result, there are two possibilities: - * - * 1. The inode header lies in the current, unwritten erase block, - * 2. The inode header resides in an earlier erase block and has already - * been written to FLASH. - * - * Recall that the inode name has already been written to FLASH. If that - * were not the case, then there would be other complex possibilities. - * - * Case 2: Does the inode header reside in a block before the beginning - * of the current erase block? - */ - - if (ioblock < pack->block0) - { - /* Case 2: The inode header lies in an earlier erase block that has - * already been written to FLASH. In this case, if we are very - * careful, we can just use the standard routine to write the inode - * header that is called during the normal file close operation: - */ - - ret = nxffs_wrinode(volume, &pack->dest.entry); - } - else - { - /* Cases 1: Both the inode header and name are in the unwritten cache - * memory. - * - * Initialize the inode header. - */ - - iooffset += (ioblock - pack->block0) * volume->geo.blocksize; - inode = (FAR struct nxffs_inode_s *)&volume->pack[iooffset]; - memcpy(inode->magic, g_inodemagic, NXFFS_MAGICSIZE); - - nxffs_wrle32(inode->noffs, pack->dest.entry.noffset); - nxffs_wrle32(inode->doffs, pack->dest.entry.doffset); - nxffs_wrle32(inode->utc, pack->dest.entry.utc); - nxffs_wrle32(inode->crc, 0); - nxffs_wrle32(inode->datlen, pack->dest.entry.datlen); - - /* Get the length of the inode name */ - - namlen = strlen(pack->dest.entry.name); - DEBUGASSERT(namlen < CONFIG_NXFFS_MAXNAMLEN); - - inode->state = CONFIG_NXFFS_ERASEDSTATE; - inode->namlen = namlen; - - /* Calculate the CRC */ - - crc = crc32((FAR const uint8_t *)inode, SIZEOF_NXFFS_INODE_HDR); - crc = crc32part((FAR const uint8_t *)pack->dest.entry.name, namlen, crc); - - /* Finish the inode header */ - - inode->state = INODE_STATE_FILE; - nxffs_wrle32(inode->crc, crc); - - /* If any open files reference this inode, then update the open file - * state. - */ - - ret = nxffs_updateinode(volume, &pack->dest.entry); - if (ret < 0) - { - fdbg("Failed to update inode info: %s\n", -ret); - } - } - - /* Reset the dest inode information */ - - nxffs_freeentry(&pack->dest.entry); - memset(&pack->dest, 0, sizeof(struct nxffs_packstream_s)); - return ret; -} - -/**************************************************************************** - * Name: nxffs_wrdatthdr - * - * Description: - * Write the destination data block header to FLASH. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. - * - ****************************************************************************/ - -static void nxffs_wrdathdr(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - FAR struct nxffs_data_s *dathdr; - off_t ioblock; - uint16_t iooffset; - uint32_t crc; - - if (pack->dest.blklen > 0) - { - /* Get the offset in the block corresponding to the location of the data - * block header. NOTE: This must lie in the same block as we currently have - * buffered. - */ - - ioblock = nxffs_getblock(volume, pack->dest.blkoffset); - iooffset = nxffs_getoffset(volume, pack->dest.blkoffset, ioblock); - DEBUGASSERT(pack->dest.blkoffset && ioblock == pack->ioblock); - - /* Write the data block header to memory */ - - dathdr = (FAR struct nxffs_data_s *)&pack->iobuffer[iooffset]; - memcpy(dathdr->magic, g_datamagic, NXFFS_MAGICSIZE); - nxffs_wrle32(dathdr->crc, 0); - nxffs_wrle16(dathdr->datlen, pack->dest.blklen); - - /* Update the entire data block CRC (including the header) */ - - crc = crc32(&pack->iobuffer[iooffset], pack->dest.blklen + SIZEOF_NXFFS_DATA_HDR); - nxffs_wrle32(dathdr->crc, crc); - } - - /* Setup state to allocate the next data block */ - - pack->dest.blkoffset = 0; - pack->dest.blklen = 0; - pack->dest.blkpos = 0; -} - -/**************************************************************************** - * Name: nxffs_packtransfer - * - * Description: - * Transfer data from the source to the destination buffer. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * None. - * - ****************************************************************************/ - -static void nxffs_packtransfer(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - /* Determine how much data is available in the dest pack buffer */ - - uint16_t destlen = volume->geo.blocksize - pack->iooffset; - - /* Dermined how much data is available in the src data block */ - - uint16_t srclen = pack->src.blklen - pack->src.blkpos; - - /* Transfer the smaller of the two amounts data */ - - uint16_t xfrlen = MIN(srclen, destlen); - if (xfrlen > 0) - { - nxffs_ioseek(volume, pack->src.blkoffset + SIZEOF_NXFFS_DATA_HDR + pack->src.blkpos); - memcpy(&pack->iobuffer[pack->iooffset], &volume->cache[volume->iooffset], xfrlen); - - /* Increment counts and offset for this data transfer */ - - pack->src.fpos += xfrlen; /* Source data offsets */ - pack->src.blkpos += xfrlen; - pack->dest.fpos += xfrlen; /* Destination data offsets */ - pack->dest.blkpos += xfrlen; - pack->dest.blklen += xfrlen; /* Destination data block size */ - pack->iooffset += xfrlen; /* Destination I/O block offset */ - volume->iooffset += xfrlen; /* Source I/O block offset */ - volume->froffset += xfrlen; /* Free FLASH offset */ - } -} - -/**************************************************************************** - * Name: nxffs_endsrcblock - * - * Description: - * The end of a source data block has been encountered. Locate the next - * source block and setup to continue the transfer. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. - * - ****************************************************************************/ - -static int nxffs_endsrcblock(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - struct nxffs_blkentry_s blkentry; - off_t offset; - int ret; - - /* Yes.. find the next data block in the source input stream. */ - - offset = pack->src.blkoffset + SIZEOF_NXFFS_DATA_HDR + pack->src.blklen; - ret = nxffs_nextblock(volume, offset, &blkentry); - if (ret < 0) - { - fdbg("Failed to find next data block: %d\n", -ret); - return ret; - } - - /* Set up the source stream */ - - pack->src.blkoffset = blkentry.hoffset; - pack->src.blklen = blkentry.datlen; - pack->src.blkpos = 0; - return OK; -} - -/**************************************************************************** - * Name: nxffs_packblock - * - * Description: - * Resume packing from the source stream into the newly identified - * destination block. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. - * - ****************************************************************************/ - -static inline int nxffs_packblock(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - off_t offset; - int ret; - - /* Are we currently processing a block from the source stream? */ - - if (pack->src.blkoffset == 0) - { - /* No.. setup the source stream */ - - ret = nxffs_srcsetup(volume, pack, pack->src.entry.doffset); - if (ret < 0) - { - fdbg("Failed to configure the src stream: %d\n", -ret); - return ret; - } - } - - /* We enter here on a new block every time, so we always have to setup - * the dest data stream. There should never be data block allocated at - * this point in time. - */ - - DEBUGASSERT(pack->dest.blkoffset == 0 && pack->dest.blkpos == 0); - - ret = nxffs_destsetup(volume, pack); - if (ret < 0) - { - /* -ENOSPC is a special return value which simply means that all of - * the FLASH has been used up to the end of the current. We need to - * return OK in this case and resume at the next block. - */ - - if (ret == -ENOSPC) - { - return OK; - } - else - { - fdbg("Failed to configure the dest stream: %d\n", -ret); - return ret; - } - } - - /* Loop, transferring data from the source block to the destination pack - * buffer until either (1) the source stream is exhausted, (2) the destination - * block is full, or (3) an error occurs. - */ - - for (;;) - { - /* Transfer data from the source buffer to the destination buffer */ - - nxffs_packtransfer(volume, pack); - - /* Now, either the (1) src block has been fully transferred, (2) all - * of the source data has been transferred, or (3) the the destination - * block is full, .. or all three. - * - * Check if all of the bytes in the source inode have been transferred. - */ - - if (pack->src.fpos >= pack->src.entry.datlen) - { - /* Write the final destination data block header and inode - * headers. - */ - - nxffs_wrdathdr(volume, pack); - nxffs_wrinodehdr(volume, pack); - - /* Find the next valid source inode */ - - offset = pack->src.blkoffset + pack->src.blklen; - memset(&pack->src, 0, sizeof(struct nxffs_packstream_s)); - - ret = nxffs_nextentry(volume, offset, &pack->src.entry); - if (ret < 0) - { - /* No more valid inode entries. Just return an end-of-flash error - * indication. - */ - - return -ENOSPC; - } - - /* Setup the new source stream */ - - ret = nxffs_srcsetup(volume, pack, pack->src.entry.doffset); - if (ret < 0) - { - return ret; - } - - /* Setup the dest stream */ - - memset(&pack->dest, 0, sizeof(struct nxffs_packstream_s)); - pack->dest.entry.name = pack->src.entry.name; - pack->dest.entry.utc = pack->src.entry.utc; - pack->dest.entry.datlen = pack->src.entry.datlen; - pack->src.entry.name = NULL; - - /* Is there sufficient space at the end of the I/O block to hold - * the inode header? - */ - - if (pack->iooffset + SIZEOF_NXFFS_INODE_HDR > volume->geo.blocksize) - { - /* No, just return success... we will handle this condition when - * this function is called on the next I/O block. - */ - - return OK; - } - - /* Configure the destination stream */ - - ret = nxffs_destsetup(volume, pack); - if (ret < 0) - { - /* -ENOSPC is a special return value which simply means that all of the - * has been used up to the end. We need to return OK in this case and - * resume at the next block. - */ - - if (ret == -ENOSPC) - { - return OK; - } - else - { - fdbg("Failed to configure the dest stream: %d\n", -ret); - return ret; - } - } - } - - /* Not at the end of the source data stream. Check if we are at the - * end of the current source data block. - */ - - else if (pack->src.blkpos >= pack->src.blklen) - { - ret = nxffs_endsrcblock(volume, pack); - if (ret < 0) - { - return ret; - } - } - - /* Check if the destination block is full */ - - if (pack->iooffset >= volume->geo.blocksize) - { - /* Yes.. Write the destination data block header and return success */ - - nxffs_wrdathdr(volume, pack); - return OK; - } - } - - return -ENOSYS; -} - -/**************************************************************************** - * Name: nxffs_setupwriter - * - * Description: - * Writing is performed at the end of the free FLASH region. When we - * finish packing the other inodes, we still need to pack the partially - * written file at the end of FLASH. This function performs the setup - * necessary to perform that packing phase. - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * If there is an active writer of the volume, its open file instance is - * returned. NULL is returned otherwise. - * - ****************************************************************************/ - -static FAR struct nxffs_wrfile_s * -nxffs_setupwriter(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack) -{ - FAR struct nxffs_wrfile_s *wrfile; - - /* Is there a writer? */ - - wrfile = nxffs_findwriter(volume); - if (wrfile) - { - /* Yes... It is the activity of this write that probably initiated - * this packing activity. The writer may have failed in one of several - * different stages: - * - * hoffset == 0: The write failed early before even FLASH for the inode - * header was set aside. - * noffset == 0: The write failed after the inode header was set aside, - * but before the inode name was written. - * doffset == 0: The write failed after writing the inode name, bue - * before any data blocks were written to FLASH. - * - * If no FLASH has been set aside for the write, then we don't need to - * do anything here. - */ - - if (wrfile->ofile.entry.hoffset > 0) - { - /* Initialize for the packing operation. */ - - memset(&pack->dest, 0, sizeof(struct nxffs_packstream_s)); - pack->dest.entry.name = strdup(wrfile->ofile.entry.name); - pack->dest.entry.utc = wrfile->ofile.entry.utc; - pack->dest.entry.datlen = wrfile->ofile.entry.datlen; - - memset(&pack->src, 0, sizeof(struct nxffs_packstream_s)); - memcpy(&pack->src.entry, &wrfile->ofile.entry, sizeof(struct nxffs_entry_s)); - pack->src.entry.name = NULL; - return wrfile; - } - } - - return NULL; -} - -/**************************************************************************** - * Name: nxffs_packwriter - * - * Description: - * There is a write in progress at the time that the volume is packed. - * This is the normal case because it is the write failures that trigger - * the packing operation to begin with. - * - * Writing is performed at the end of the free FLASH region and this - * implemenation is restricted to a single writer. The new inode is not - * written to FLASH until the the writer is closed and so will not be - * found by nxffs_packblock(). - * - * Input Parameters: - * volume - The volume to be packed - * pack - The volume packing state structure. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. - * - ****************************************************************************/ - -static inline int nxffs_packwriter(FAR struct nxffs_volume_s *volume, - FAR struct nxffs_pack_s *pack, - FAR struct nxffs_wrfile_s *wrfile) -{ - int ret; - - /* Are we currently processing a block from the source stream? */ - - if (pack->src.blkoffset == 0) - { - /* No.. setup the source stream */ - - ret = nxffs_srcsetup(volume, pack, pack->src.entry.doffset); - if (ret < 0) - { - fdbg("Failed to configure the src stream: %d\n", -ret); - return ret; - } - } - - /* We enter here on a new block every time, so we always have to setup - * the dest data stream. There should never be data block allocated at - * this point in time. - */ - - DEBUGASSERT(pack->dest.blkoffset == 0 && pack->dest.blkpos == 0); - - ret = nxffs_destsetup(volume, pack); - if (ret < 0) - { - /* -ENOSPC is a special return value which simply means that all of the - * has been used up to the end. We need to return OK in this case and - * resume at the next block. - */ - - if (ret == -ENOSPC) - { - return OK; - } - else - { - fdbg("Failed to configure the dest stream: %d\n", -ret); - return ret; - } - } - - /* Loop, transferring data from the source block to the destination pack - * buffer until either (1) the source stream is exhausted, (2) the destination - * block is full, or (3) an error occurs. - */ - - for (;;) - { - /* Transfer data from the source buffer to the destination buffer */ - - nxffs_packtransfer(volume, pack); - - /* Now, either the (1) src block has been fully transferred, (2) all - * of the source data has been transferred, or (3) the the destination - * block is full, .. or all three. - * - * Check if all of the bytes in the source inode have been transferred. - */ - - if (pack->src.fpos >= pack->src.entry.datlen) - { - /* Write the final destination data block header and inode - * headers. - */ - - nxffs_wrdathdr(volume, pack); - - /* Set the new offsets in the open file instance. */ - - wrfile->ofile.entry.hoffset = pack->dest.entry.hoffset; - wrfile->ofile.entry.noffset = pack->dest.entry.noffset; - wrfile->ofile.entry.doffset = pack->dest.entry.doffset; - - /* Return an end-of-flash error to indicate that all of the write - * data has been transferred. - */ - - return -ENOSPC; - } - - /* Not at the end of the source data stream. Check if we are at the - * end of the current source data block. - */ - - else if (pack->src.blkpos >= pack->src.blklen) - { - ret = nxffs_endsrcblock(volume, pack); - if (ret < 0) - { - return ret; - } - } - - /* Check if the destination block is full */ - - if (pack->iooffset >= volume->geo.blocksize) - { - /* Yes.. Write the destination data block header and return success */ - - nxffs_wrdathdr(volume, pack); - return OK; - } - } - - return -ENOSYS; -} - -/**************************************************************************** - * Public Functions - ****************************************************************************/ - -/**************************************************************************** - * Name: nxffs_pack - * - * Description: - * Pack and re-write the filesystem in order to free up memory at the end - * of FLASH. - * - * Input Parameters: - * volume - The volume to be packed. - * - * Returned Values: - * Zero on success; Otherwise, a negated errno value is returned to - * indicate the nature of the failure. - * - ****************************************************************************/ - -int nxffs_pack(FAR struct nxffs_volume_s *volume) -{ - struct nxffs_pack_s pack; - FAR struct nxffs_wrfile_s *wrfile; - off_t iooffset; - off_t eblock; - off_t block; - bool packed; - int i; - int ret; - - /* Get the offset to the first valid inode entry */ - - wrfile = NULL; - packed = false; - - iooffset = nxffs_mediacheck(volume, &pack); - if (iooffset == 0) - { - /* Offset zero is only returned if no valid blocks were found on the - * FLASH media or if there are no valid inode entries on the FLASH after - * the first valid block. There are two possibilities: (1) there - * really is nothing on the FLASH, or (2) there is a file being written - * to the FLASH now. - */ - - /* Is there a writer? */ - - wrfile = nxffs_setupwriter(volume, &pack); - if (wrfile) - { - /* If there is a write, just set ioffset to the offset of data in - * first block. Setting 'packed' to true will supress normal inode - * packing operation. Then we can start compacting the FLASH. - */ - - iooffset = SIZEOF_NXFFS_BLOCK_HDR; - packed = true; - goto start_pack; - } - else - { - /* No, there is no write in progress. We just have an empty flash - * full of deleted files. In this case, the media needs to be re- - * formatted. - */ - - ret = nxffs_reformat(volume); - if (ret == OK) - { - /* The free flash offset will be in the first valid block of - * the FLASH. - */ - - block = 0; - ret = nxffs_validblock(volume, &block); - if (ret == OK) - { - /* Set to the offset past the block header in the first - * valid block - */ - - volume->froffset = - block * volume->geo.blocksize + SIZEOF_NXFFS_BLOCK_HDR; - } - } - - return ret; - } - } - - /* There is a valid format and valid inodes on the media.. setup up to - * begin the packing operation. - */ - - ret = nxffs_startpos(volume, &pack, &iooffset); - if (ret < 0) - { - /* This is a normal situation if the volume is full */ - - if (ret == -ENOSPC) - { - /* In the case where the volume is full, nxffs_startpos() will - * recalculate the free FLASH offset and store it in iooffset. There - * may be deleted files at the end of FLASH. In this case, we don't - * have to pack any files, we simply have to erase FLASH at the end. - * But don't do this unless there is some particularly big FLASH - * savings (otherwise, we risk wearing out these final blocks). - */ - - if (iooffset + CONFIG_NXFFS_TAILTHRESHOLD < volume->froffset) - { - /* Setting 'packed' to true will supress normal inode packing - * operation. - */ - - packed = true; - - /* Writing is performed at the end of the free FLASH region. - * If we are not packing files, we could still need to pack - * the partially written file at the end of FLASH. - */ - - wrfile = nxffs_setupwriter(volume, &pack); - } - - /* Otherwise return OK.. meaning that there is nothing more we can - * do to recover FLASH space. - */ - - else - { - return OK; - } - } - else - { - fvdbg("Failed to find a packing position: %d\n", -ret); - return ret; - } - } - - /* Otherwise, begin pack at this src/dest block combination. Initialize - * ioblock and iooffset with the position of the first inode header. In - * this case, the FLASH offset to the first inode header is return in - * iooffset. - */ - -start_pack: - - pack.ioblock = nxffs_getblock(volume, iooffset); - pack.iooffset = nxffs_getoffset(volume, iooffset, pack.ioblock); - volume->froffset = iooffset; - - /* Then pack all erase blocks starting with the erase block that contains - * the ioblock and through the final erase block on the FLASH. - */ - - for (eblock = pack.ioblock / volume->blkper; - eblock < volume->geo.neraseblocks; - eblock++) - { - /* Read the erase block into the pack buffer. We need to do this even - * if we are overwriting the entire block so that we skip over - * previously marked bad blocks. - */ - - pack.block0 = eblock * volume->blkper; - ret = MTD_BREAD(volume->mtd, pack.block0, volume->blkper, volume->pack); - if (ret < 0) - { - fdbg("Failed to read erase block %d: %d\n", eblock, -ret); - goto errout_with_pack; - } - - /* Pack each I/O block */ - - for (i = 0, block = pack.block0, pack.iobuffer = volume->pack; - i < volume->blkper; - i++, block++, pack.iobuffer += volume->geo.blocksize) - { - /* The first time here, the ioblock may point to an offset into - * the erase block. We just need to skip over those cases. - */ - - if (block >= pack.ioblock) - { - /* Set the I/O position. Note on the first time we get - * pack.iooffset will hold the offset in the first I/O block - * to the first inode header. After that, it will always - * refer to the first byte after the block header. - */ - - pack.ioblock = block; - - /* If this is not a valid block or if we have already - * finished packing the valid inode entries, then just fall - * through, reset the FLASH memory to the erase state, and - * write the reset values to FLASH. (The first block that - * we want to process will always be valid -- we have - * already verified that). - */ - - if (nxffs_packvalid(&pack)) - { - /* Have we finished packing inodes? */ - - if (!packed) - { - DEBUGASSERT(wrfile == NULL); - - /* Pack inode data into this block */ - - ret = nxffs_packblock(volume, &pack); - if (ret < 0) - { - /* The error -ENOSPC is a special value that simply - * means that there is nothing further to be packed. - */ - - if (ret == -ENOSPC) - { - packed = true; - - /* Writing is performed at the end of the free - * FLASH region and this implemenation is restricted - * to a single writer. The new inode is not - * written to FLASH until the the writer is closed - * and so will not be found by nxffs_packblock(). - */ - - wrfile = nxffs_setupwriter(volume, &pack); - } - else - { - /* Otherwise, something really bad happened */ - - fdbg("Failed to pack into block %d: %d\n", - block, ret); - goto errout_with_pack; - } - } - } - - /* If all of the "normal" inodes have been packed, then check if - * we need to pack the current, in-progress write operation. - */ - - if (wrfile) - { - DEBUGASSERT(packed == true); - - /* Pack write data into this block */ - - ret = nxffs_packwriter(volume, &pack, wrfile); - if (ret < 0) - { - /* The error -ENOSPC is a special value that simply - * means that there is nothing further to be packed. - */ - - if (ret == -ENOSPC) - { - wrfile = NULL; - } - else - { - /* Otherwise, something really bad happened */ - - fdbg("Failed to pack into block %d: %d\n", - block, ret); - goto errout_with_pack; - } - } - } - } - - /* Set any unused portion at the end of the block to the - * erased state. - */ - - if (pack.iooffset < volume->geo.blocksize) - { - memset(&pack.iobuffer[pack.iooffset], - CONFIG_NXFFS_ERASEDSTATE, - volume->geo.blocksize - pack.iooffset); - } - - /* Next time through the loop, pack.iooffset will point to the - * first byte after the block header. - */ - - pack.iooffset = SIZEOF_NXFFS_BLOCK_HDR; - } - } - - /* We now have an in-memory image of how we want this erase block to - * appear. Now it is safe to erase the block. - */ - - ret = MTD_ERASE(volume->mtd, eblock, 1); - if (ret < 0) - { - fdbg("Failed to erase block %d [%d]: %d\n", - eblock, pack.block0, -ret); - goto errout_with_pack; - } - - /* Write the packed I/O block to FLASH */ - - ret = MTD_BWRITE(volume->mtd, pack.block0, volume->blkper, volume->pack); - if (ret < 0) - { - fdbg("Failed to write erase block %d [%]: %d\n", - eblock, pack.block0, -ret); - goto errout_with_pack; - } - } - -errout_with_pack: - nxffs_freeentry(&pack.src.entry); - nxffs_freeentry(&pack.dest.entry); - return ret; -} |