OrgApache/incubator-nuttx
OrgApache
/
incubator-nuttx
mirror of https://github.com/apache/incubator-nuttx.git
1
0
Fork 0
Code Issues Releases Wiki Activity
incubator-nuttx/fs/nxffs/nxffs_pack.c

1613 lines
50 KiB
C
Raw Blame History

/****************************************************************************
* fs/nxffs/nxffs_pack.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <debug.h>
#include <nuttx/crc32.h>
#include <nuttx/kmalloc.h>
#include "nxffs.h"
/****************************************************************************
* Private 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 */
};
/****************************************************************************
* 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 Value:
* 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 Value:
* 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 to 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 Value:
* 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)
{
ferr("ERROR: 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 Value:
* 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)
{
ferr("ERROR: 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 Value:
* 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 Value:
* 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)
{
ferr("ERROR: Failed to update inode info: %d\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 Value:
* 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 Value:
* 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 Value:
* 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)
{
ferr("ERROR: 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 Value:
* 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)
{
ferr("ERROR: 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
{
ferr("ERROR: 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 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
{
ferr("ERROR: 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 Value:
* 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;
DEBUGASSERT(pack->dest.entry.name != NULL);
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
* implementation is restricted to a single writer. The new inode is not
* written to FLASH until 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 Value:
* 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)
{
ferr("ERROR: 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
{
ferr("ERROR: 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 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 Value:
* 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 = OK;
/* 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 suppress 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 suppress 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
{
ferr("ERROR: 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++)
{
/* Get the starting block number of the erase block */
pack.block0 = eblock * volume->blkper;
#ifndef CONFIG_NXFFS_NAND
/* 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.
*/
ret = MTD_BREAD(volume->mtd, pack.block0, volume->blkper,
volume->pack);
if (ret < 0)
{
ferr("ERROR: Failed to read erase block %jd: %d\n",
(intmax_t)eblock, -ret);
goto errout_with_pack;
}
#else
/* Read the entire erase block into the pack buffer, one-block-at-a-
* time. We need to do this even if we are overwriting the entire
* block so that (1) we skip over previously marked bad blocks, and
* (2) we can handle individual block read failures.
*
* For most FLASH, a read failure indicates a fatal hardware failure.
* But for NAND FLASH, the read failure probably indicates a block
* with uncorrectable bit errors.
*/
/* Read each I/O block */
for (i = 0, block = pack.block0, pack.iobuffer = volume->pack;
i < volume->blkper;
i++, block++, pack.iobuffer += volume->geo.blocksize)
{
/* Read the next block in the erase block */
ret = MTD_BREAD(volume->mtd, block, 1, pack.iobuffer);
if (ret < 0)
{
/* Force a the block to be an NXFFS bad block */
ferr("ERROR: Failed to read block %d: %d\n", block, ret);
nxffs_blkinit(volume, pack.iobuffer, BLOCK_STATE_BAD);
}
}
#endif
/* Now 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 implementation is
* restricted to a single writer. The new
* inode is not written to FLASH until the
* writer is closed and so will not be found
* by nxffs_packblock().
*/
wrfile = nxffs_setupwriter(volume, &pack);
}
else
{
/* Otherwise, something really bad happened */
ferr("ERROR: Failed to pack into block %jd: "
"%d\n",
(intmax_t)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 */
ferr("ERROR: Failed to pack into block %jd: "
"%d\n",
(intmax_t)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)
{
ferr("ERROR: Failed to erase block %jd [%jd]: %d\n",
(intmax_t)eblock, (intmax_t)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)
{
ferr("ERROR: Failed to write erase block %jd [%jd]: %d\n",
(intmax_t)eblock, (intmax_t)pack.block0, -ret);
goto errout_with_pack;
}
}
errout_with_pack:
nxffs_freeentry(&pack.src.entry);
nxffs_freeentry(&pack.dest.entry);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink