tfsclean2.c

flash文件系统实现

/* tfsclean2.c:
 *  This version of defragmentation is not power-hit safe and does not
 *  require any flash overhead.  The defragmentation simply copies all
 *  good files to an allocated block of ram erases the flash, then copies
 *  the concatenated data back to the flash.  Simple but dangerous.
 *
 *  If automatic defragmentation (through tfsadd()) is to be used in this
 *  mode, then the application must reside in ram space that is above 
 *  APPRAMSTART + SIZEOF_TFSFLASH.  This version of defragmentation assumes
 *  that the ram space needed for defrag will start at APPRAMBASE.
 *
 *  General notice:
 *  This code is part of a boot-monitor package developed as a generic base
 *  platform for embedded system designs.  As such, it is likely to be
 *  distributed to various projects beyond the control of the original
 *  author.  Please notify the author of any enhancements made or bugs found
 *  so that all may benefit from the changes.  In addition, notification back
 *  to the author will allow the new user to pick up changes that may have
 *  been made by other users after this version of the code was distributed.
 *
 *  Note1: the majority of this code was edited with 4-space tabs.
 *  Note2: as more and more contributions are accepted, the term "author"
 *         is becoming a mis-representation of credit.
 *
 *  Original author:    Ed Sutter
 *  Email:              [e-mail]
 *  Phone:              908-582-2351
 */
#include "config.h"
#include "cpu.h"
#include "stddefs.h"
#include "genlib.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "flash.h"
//#include "monflags.h"

#if INCLUDE_TFS
/*
int
tfsfixup(int verbose, int dontquery)
{
    return(TFSERR_NOTAVAILABLE);
}
*/
#if DEFRAG_TEST_ENABLED
int
dumpDhdr(DEFRAGHDR *dhp)
{
    return(TFSERR_NOTAVAILABLE);
}

int
dumpDhdrTbl(DEFRAGHDR *dhp, int ftot)
{
    return(TFSERR_NOTAVAILABLE);
}
#endif


/* _tfsclean():
 *  This is an alternative to the complicated defragmentation above.
 *  It simply scans through the file list and copies all valid files
 *  to RAM; then flash is erased and the RAM is copied back to flash.
 *  <<< WARNING >>>
 *  THIS FUNCTION SHOULD NOT BE INTERRUPTED AND IT WILL BLOW AWAY
 *  ANY APPLICATION CURRENTLY IN CLIENT RAM SPACE.
 */
/*
int
_tfsclean(TDEV *tdp, int notused, int verbose)
{
    TFILE   *tfp;
    uchar   *tbuf;
    ulong   appramstart;
    int     dtot, nfadd, len, err, chkstat;

    if (TfsCleanEnable < 0)
        return(TFSERR_CLEANOFF);

    appramstart = getAppRamStart();

     Determine how many "dead" files exist. 
    dtot = 0;
    tfp = (TFILE *)tdp->start;
    while(validtfshdr(tfp)) {
        if (!TFS_FILEEXISTS(tfp))
            dtot++;
        tfp = nextfp(tfp,tdp);
    }

    if (dtot == 0)
        return(TFS_OKAY);

    printf("TFS device '%s' non-powersafe defragmentation\n",tdp->prefix);

    tbuf = (uchar *)appramstart;
    tfp = (TFILE *)(tdp->start);
    nfadd = tdp->start;
    while(validtfshdr(tfp)) {
        if (TFS_FILEEXISTS(tfp)) {
            len = TFS_SIZE(tfp) + sizeof(struct tfshdr);
            if (len % TFS_FSIZEMOD)
                len += TFS_FSIZEMOD - (len % TFS_FSIZEMOD);
            nfadd += len;
            err = tfsmemcpy(tbuf,(uchar *)tfp,len,0,0);
            if (err != TFS_OKAY)
                return(err);
            
            ((struct tfshdr *)tbuf)->next = (struct tfshdr *)nfadd;
            tbuf += len;
        }
        tfp = nextfp(tfp,tdp);
    }

    // Erase the flash device: 
    printf("Erasing flash...\n");
    err = _tfsinit(tdp);
    if (err != TFS_OKAY)
        return(err);

    // Copy data placed in RAM back to flash: 
    printf("Restoring flash...\n");
    err = AppFlashWrite((ulong *)(tdp->start),(ulong *)appramstart,
        (tbuf-(uchar*)appramstart));
    if (err < 0)
        return(TFSERR_FLASHFAILURE);

    // All defragmentation is done, so verify sanity of files... 
    chkstat = tfscheck(tdp,verbose);

    return(chkstat);
}
*/
#endif