1573 lines
50 KiB
C
1573 lines
50 KiB
C
/****************************************************************************
|
|
* 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;
|
|
}
|