12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607 |
- /****************************************************************************
- * fs/nxffs/nxffs_pack.c
- *
- * Copyright (C) 2011, 2013 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"
- /****************************************************************************
- * 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: %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 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;
- 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 %d: %d\n", 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 %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 */
- ferr("ERROR: 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)
- {
- ferr("ERROR: 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)
- {
- ferr("ERROR: Failed to write erase block %d [%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;
- }
|