phone-side
/
nuttx-bb
9
0
Fork 0
Code Releases Activity

Progress on NXFFS packing logic 

git-svn-id: https://nuttx.svn.sourceforge.net/svnroot/nuttx/trunk@3555 7fd9a85b-ad96-42d3-883c-3090e2eb8679
This commit is contained in:
patacongo 2011-05-03 16:46:57 +00:00
parent 27a5a2eb87
commit 109fa7d14e
5 changed files with 410 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
nuttx/fs/nxffs/nxffs.h
View File

@ -782,28 +782,6 @@ extern FAR struct nxffs_ofile_s *nxffs_findofile(FAR struct nxffs_volume_s *volu
extern int nxffs_wrreserve(FAR struct nxffs_volume_s *volume, size_t size);
/****************************************************************************
* Name: nxffs_nextblock
*
* Description:
* Search for the next valid data block starting at the provided
* FLASH offset.
*
* Input Parameters:
* volume - Describes the NXFFS volume.
* datlen - A memory location to return the data block length.
*
* Returned Value:
* Zero is returned on success. Otherwise, a negated errno is returned
* that indicates the nature of the failure.
*
* Defined in nxffs_read.c
*
****************************************************************************/
extern int nxffs_nextblock(FAR struct nxffs_volume_s *volume, off_t offset,
FAR struct nxffs_blkentry_s *blkentry);
/****************************************************************************
* Name: nxffs_wrverify
*
@ -870,7 +848,52 @@ extern int nxffs_wrverify(FAR struct nxffs_volume_s *volume, size_t size);
extern int nxffs_wrblkhdr(FAR struct nxffs_volume_s *volume,
FAR struct nxffs_wrfile_s *wrfile);
/****************************************************************************
* Name: nxffs_nextblock
*
* Description:
* Search for the next valid data block starting at the provided
* FLASH offset.
*
* Input Parameters:
* volume - Describes the NXFFS volume.
* datlen - A memory location to return the data block length.
*
* Returned Value:
* Zero is returned on success. Otherwise, a negated errno is returned
* that indicates the nature of the failure.
*
* Defined in nxffs_read.c
*
****************************************************************************/
extern int nxffs_nextblock(FAR struct nxffs_volume_s *volume, off_t offset,
FAR struct nxffs_blkentry_s *blkentry);
/****************************************************************************
* Name: nxffs_rdblkhdr
*
* Description:
* Read and verify the data block header at the specified offset.
*
* Input Parameters:
* volume - Describes the current volume.
* offset - The byte offset from the beginning of FLASH where the data block
* header is expected.
* datlen - A memory location to return the data block length.
*
* Returned Value:
* Zero on success. Otherwise, a negated errno value is returned
* indicating the nature of the failure.
*
* Defined in nxffs_read.c
*
****************************************************************************/
extern int nxffs_rdblkhdr(FAR struct nxffs_volume_s *volume, off_t offset,
FAR uint16_t *datlen);
/****************************************************************************
* Name: nxffs_rminode
*

2
nuttx/fs/nxffs/nxffs_block.c
View File

@ -109,7 +109,7 @@ int nxffs_verifyblock(FAR struct nxffs_volume_s *volume, off_t block)
*/
blkhdr = (FAR struct nxffs_block_s *)volume->cache;
if (memcmp(blkhdr->magic, g_blockmagic, 4) == 0 &&
if (memcmp(blkhdr->magic, g_blockmagic, NXFFS_MAGICSIZE) == 0 &&
blkhdr->state == BLOCK_STATE_GOOD)
{
/* The block is valid */

333
nuttx/fs/nxffs/nxffs_pack.c
View File

@ -70,8 +70,18 @@ struct nxffs_packstream_s
struct nxffs_pack_s
{
struct nxffs_packstream_s src; /* Describes the src stream */
struct nxffs_packstream_s dest; /* Describes the destination stream */
/* 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 */
uint16_t iooffset; /* I/O block offset */
};
/****************************************************************************
@ -83,32 +93,76 @@ struct nxffs_pack_s
****************************************************************************/
/****************************************************************************
* Name: nxffs_startblock
* Name: nxffs_packseek
*
* 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.
* Seek to the destination offset in the pack buffer
*
* Input Parameters:
* volume - The volume to be packed.
* pack - The volume packing state structure.
* offset - The desired offset
*
* Returned Values:
* Zero on success; Otherwise, a negated errno value is returned to
* indicate the nature of the failure.
* None
*
****************************************************************************/
static int nxffs_startblock(FAR struct nxffs_volume_s *volume,
FAR struct nxffs_pack_s *pack)
static void nxffs_packseek(FAR struct nxffs_volume_s *volume,
FAR struct nxffs_pack_s *pack, off_t offset)
{
struct nxffs_blkentry_s blkentry;
off_t wasted;
off_t offset;
off_t nbytes;
int ret;
pack->ioblock = offset / volume->geo.blocksize;
pack->iooffset = offset - pack->ioblock * volume->geo.blocksize;
}
memset(pack, 0, sizeof(struct nxffs_pack_s));
/****************************************************************************
* 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;
/* Find the FLASH offset to the first valid block */
@ -116,13 +170,62 @@ static int nxffs_startblock(FAR struct nxffs_volume_s *volume,
ret = nxffs_validblock(volume, &volume->ioblock);
if (ret < 0)
{
/* No valid blocks? */
/* No valid blocks? Return offset zero. */
return nxffs_reformat(volume);
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;
offset = nxffs_iotell(volume);
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 -ENOSPC;
}
/* Okay.. the start block and first entry have been found */
return froffset;
}
/****************************************************************************
* Name: nxffs_startblock
*
* 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.
* offset - location to return the pointer to first valid inode header.
*
* Returned Values:
* Zero on success; Otherwise, a negated errno value is returned to
* indicate the nature of the failure.
*
****************************************************************************/
static inline int nxffs_startblock(FAR struct nxffs_volume_s *volume,
FAR struct nxffs_pack_s *pack,
off_t offset)
{
struct nxffs_blkentry_s blkentry;
off_t wasted;
off_t nbytes;
int ret;
/* Loop until we find a gap of unused FLASH large enough to warrant the
* compression.
@ -130,16 +233,6 @@ static int nxffs_startblock(FAR struct nxffs_volume_s *volume,
for(;;)
{
/* Get the offset to the first valid inode entry */
ret = nxffs_nextentry(volume, offset, &pack->src.entry);
if (ret < 0)
{
/* No valid entries -- reformat the flash */
return nxffs_reformat(volume);
}
/* 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
@ -195,13 +288,15 @@ static int nxffs_startblock(FAR struct nxffs_volume_s *volume,
nxffs_ioseek(volume, offset);
if (volume->iooffset + SIZEOF_NXFFS_INODE_HDR > volume->geo.blocksize)
{
/* Find the next valid block */
/* 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 */
/* No valid blocks? Then there is nothing we can do. Return
* the end-of-flash indication.
*/
return -ENOSPC;
}
@ -209,6 +304,18 @@ static int nxffs_startblock(FAR struct nxffs_volume_s *volume,
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.
*/
return -ENOSPC;
}
}
/* We won't get here */
@ -216,6 +323,67 @@ static int nxffs_startblock(FAR struct nxffs_volume_s *volume,
return -ENOSYS;
}
/****************************************************************************
* 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)
{
int ret;
/* Are we currently processing a block from the source stream? */
if (pack->src.blkoffset)
{
/* No, start with the first data block */
pack->src.blkoffset = pack->src.entry.doffset;
pack->src.fpos = 0;
pack->src.blkpos = 0;
/* Seek to the data block header, read and verify the block header */
ret = nxffs_rdblkhdr(volume, pack->src.blkoffset, &pack->src.blklen);
if (ret < 0)
{
fdbg("Failed to verify the data block header: %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 (;;)
{
/* Determine how much data is available in the dest pack buffer */
/* Dermined how much data is available in the src data block */
/* Transfer the data */
#warning "Missing logic"
return -ENOSYS;
}
return -ENOSYS;
}
/****************************************************************************
* Public Functions
****************************************************************************/
@ -239,28 +407,109 @@ static int nxffs_startblock(FAR struct nxffs_volume_s *volume,
int nxffs_pack(FAR struct nxffs_volume_s *volume)
{
struct nxffs_pack_s pack;
off_t iooffset;
off_t eblock;
off_t block0;
off_t block;
int i;
int ret;
/* Get the offset to the first valid inode entry */
ret = nxffs_startblock(volume, &pack);
if (ret < 0)
iooffset = nxffs_mediacheck(volume, &pack);
if (iooffset == 0)
{
fdbg("Failed to find a start block: %d\n", -ret);
return ret;
/* 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. In this case, the media needs to be re-
* formatted.
*/
return nxffs_reformat(volume);
}
/* A special case is where the entire FLASH needs to be reformatted. In
* this case, the source and destination offsets will both be zero.
/* There is a valid format and valid inodes on the media.. setup up to
* begin the packing operation.
*/
if (pack.src.entry.hoffset == 0 && pack.dest.entry.hoffset == 0)
ret = nxffs_startblock(volume, &pack, iooffset);
if (ret < 0)
{
return OK;
/* This is a normal situation if the volume is full */
if (ret == -ENOSPC)
{
return OK;
}
else
{
fvdbg("Failed to find a packing position: %d\n", -ret);
return ret;
}
}
/* Otherwise, begin pack at this src/dest block combination */
/* Otherwise, begin pack at this src/dest block combination. Get the erase
* block associated with the destination header offset.
*/
# warning "Missing logic"
return -ENOSYS;
nxffs_packseek(volume, &pack, pack.dest.entry.hoffset);
for (eblock = pack.ioblock / volume->blkper;
eblock < volume->geo.neraseblocks;
eblock++)
{
/* Read the erase block into the pack buffer. */
block0 = eblock * volume->blkper;
ret = MTD_BREAD(volume->mtd, 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 = 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)
{
pack.ioblock = block;
/* Check if this is a valid block */
if (nxffs_packvalid(&pack))
{
/* Yes.. pack data into this block */
ret = nxffs_packblock(volume, &pack);
if (ret < 0)
{
fdbg("Failed to pack into block %d: %d\n", block, ret);
goto errout_with_pack;
}
}
}
}
/* Write the packed I/O block to FLASH */
ret = MTD_BWRITE(volume->mtd, block0, volume->blkper, volume->pack);
if (ret < 0)
{
fdbg("Failed to write erase block %d: %d\n", eblock, -ret);
goto errout_with_pack;
}
}
errout_with_pack:
nxffs_freeentry(&pack.src.entry);
nxffs_freeentry(&pack.dest.entry);
return ret;
}

139
nuttx/fs/nxffs/nxffs_read.c
View File

@ -69,75 +69,6 @@
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: nxffs_rdblkhdr
*
* Description:
* Read the dataa block header at this offset. Called only from nxffs_nextblock().
*
* Input Parameters:
* volume - Describes the current volume.
* offset - The byte offset from the beginning of FLASH where the data block
* header is expected.
* datlen - A memory location to return the data block length.
*
* Returned Value:
* Zero on success. Otherwise, a negater errno value is returned
* indicating the nature of the failure.
*
****************************************************************************/
static int nxffs_rdblkhdr(FAR struct nxffs_volume_s *volume, off_t offset,
FAR uint16_t *datlen)
{
struct nxffs_data_s blkhdr;
uint32_t ecrc;
uint32_t crc;
uint16_t doffset;
uint16_t dlen;
/* Read the header at the FLASH offset */
nxffs_ioseek(volume, offset);
doffset = volume->iooffset;
memcpy(&blkhdr, &volume->cache[doffset], SIZEOF_NXFFS_DATA_HDR);
/* Extract the data length */
dlen = nxffs_rdle16(blkhdr.datlen);
/* Get the offset to the beginning of the data */
doffset += SIZEOF_NXFFS_DATA_HDR;
/* Make sure that all of the data fits within the block */
if ((uint32_t)doffset + (uint32_t)dlen > (uint32_t)volume->geo.blocksize)
{
fdbg("Data length=%d is unreasonable at offset=%d\n", dlen, doffset);
return -EIO;
}
/* Extract the expected CRC and calculate the CRC of the data block */
ecrc = nxffs_rdle32(blkhdr.crc);
nxffs_wrle32(blkhdr.crc, 0);
crc = crc32((FAR const uint8_t *)&blkhdr, SIZEOF_NXFFS_DATA_HDR);
crc = crc32part(&volume->cache[doffset], dlen, crc);
if (crc != ecrc)
{
fdbg("CRC failure\n");
return -EIO;
}
/* Looks good! Return the data length and success */
*datlen = dlen;
return OK;
}
/****************************************************************************
* Name: nxffs_rdseek
*
@ -437,4 +368,74 @@ int nxffs_nextblock(FAR struct nxffs_volume_s *volume, off_t offset,
return -ENOENT;
}
/****************************************************************************
* Name: nxffs_rdblkhdr
*
* Description:
* Read and verify the data block header at the specified offset.
*
* Input Parameters:
* volume - Describes the current volume.
* offset - The byte offset from the beginning of FLASH where the data block
* header is expected.
* datlen - A memory location to return the data block length.
*
* Returned Value:
* Zero on success. Otherwise, a negated errno value is returned
* indicating the nature of the failure.
*
****************************************************************************/
int nxffs_rdblkhdr(FAR struct nxffs_volume_s *volume, off_t offset,
FAR uint16_t *datlen)
{
struct nxffs_data_s blkhdr;
uint32_t ecrc;
uint32_t crc;
uint16_t doffset;
uint16_t dlen;
/* Read the header at the FLASH offset */
nxffs_ioseek(volume, offset);
doffset = volume->iooffset;
memcpy(&blkhdr, &volume->cache[doffset], SIZEOF_NXFFS_DATA_HDR);
/* Extract the data length */
dlen = nxffs_rdle16(blkhdr.datlen);
/* Get the offset to the beginning of the data */
doffset += SIZEOF_NXFFS_DATA_HDR;
/* Make sure that all of the data fits within the block */
if ((uint32_t)doffset + (uint32_t)dlen > (uint32_t)volume->geo.blocksize)
{
fdbg("Data length=%d is unreasonable at offset=%d\n", dlen, doffset);
return -EIO;
}
/* Extract the expected CRC and calculate the CRC of the data block */
ecrc = nxffs_rdle32(blkhdr.crc);
nxffs_wrle32(blkhdr.crc, 0);
crc = crc32((FAR const uint8_t *)&blkhdr, SIZEOF_NXFFS_DATA_HDR);
crc = crc32part(&volume->cache[doffset], dlen, crc);
if (crc != ecrc)
{
fdbg("CRC failure\n");
return -EIO;
}
/* Looks good! Return the data length and success */
*datlen = dlen;
return OK;
}

4
nuttx/fs/nxffs/nxffs_write.c
View File

@ -715,7 +715,7 @@ int nxffs_wrverify(FAR struct nxffs_volume_s *volume, size_t size)
iooffset = volume->iooffset;
nerased = 0;
for (i = volume->iooffset; i <= volume->geo.blocksize - size; i++)
for (i = volume->iooffset; i < volume->geo.blocksize; i++)
{
/* Is this byte erased? */
@ -745,7 +745,7 @@ int nxffs_wrverify(FAR struct nxffs_volume_s *volume, size_t size)
else
{
nerased = 0;
iooffset = volume->iooffset + 1;
iooffset = i + 1;
}
}