tfs_with_appexit_support.c

flash文件系统实现

/* tfs.c:
    Tiny File System
    TFS supports the ability to store/access files in flash.  The functions
    in this file provide an interface at the monitor's user interface (the
    "tfs" command) as well as a library of functions that are available to
    the monitor/application code on this target (TFS API).
    The files on TFS include the application itself as well as any other file
    that may need to be stored for access by the monitor or application.

    NOTES:
    * This code considers both multiple task access and cache coherency;
      but has not been tested much...

      Dealing with multiple task access:
      The monitors access functions must be provided with a lock/unlock 
      wrapper that will guarantee sequential access to all of the monitor 
      facilities.  Refer to monlib.c in the target-specific code.
      Note that originally this was supported with tfsctrl(TFS_MUTEX ).
      This turned out to be insufficient because it did not prevent other
      tasks from calling other non-tfs functions in the monitor while tfs
      access (and potentially, flash update) was in progress.  This meant
      that a flash update could be in progress and some other task could
      call mon_getenv() and this would screw up the flash update because
      mon_getenv() would fetch out of the same flash device.  The wrapper
      needs to be part of the application (execute in RAM).

      Dealing with cache coherency:
      I believe the only concern here is that Icache must be invalidated
      and Dcache must be flushed whenever TFS does a memory copy that may
      ultimately be executable code.  This is handled at the end of the
      tfsmemcpy function by calling flushDcache() and invalidateIcache().
      It is the application's responsibility to give the monitor the
      appropriate functions (see assigncachefuncs()) if necessary.

 *  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"
#if INCLUDE_TFS
//#include "cpu.h"
#include "stddefs.h"
#include "string.h"
#include "tfs.h"
#include "flash.h"
//#include "aout.h"
#include "coff.h"
#include "elf.h"
#include "tfsprivate.h"
//#include "monapp.h"

#define TFSLOG_ADD  0
#define TFSLOG_DEL  1
#define TFSLOG_IPM  2
#define TFSLOG_ON   3
#define TFSLOG_OFF  4
#define TIME_UNDEFINED  0xffffffff

extern int UserLevel;
extern char *malloc(), *realloc();
extern void docommand(char *,int);

static int getndaoffset(struct defraghdr *dp,int sec,int *retoffset);
static long tfsflagsatob(char *);
long tfsmemuse(void);
long tfsmemdead(void);
static int tfsclean(); 
static int _tfsclean();
static int setdefragstate();
static int tfscheck();
static int tfsloadaout();
static int tfsloadelf();
static int tfsloadcoff();
static int tfsreorder();

static char     *(*tfsGetAtime)(long,char *,int);
static long     (*tfsGetLtime)(void), tfsFmodCount;
static void     (*tfsDocommand)(char *,int);
static char     *ScriptGotoTag, changeLog;
static struct   tfsdat fileslots[TFS_MAXOPEN];
static struct   tfshdr **tfsAlist;
static int      tfsAlistSize, tfsrunbootDone, tfsInaScript;

/* crc32tab[]:
    Used for calculating a 32-bit CRC.
*/
unsigned long crc32tab[] = {
    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
    0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 
    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
    0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 
    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
    0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 
    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
    0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 
    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
    0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 
    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
    0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 
    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
    0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 
    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
    0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 
    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
    0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 
    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
    0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 
    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
    0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 
    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
    0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 
    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
    0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 
    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
    0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 
    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
    0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 
    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
    0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 
    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
    0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 
    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
    0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 
    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
    0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 
    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
    0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 
    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
    0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 
    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};

/* tfslogaction[]:
    Used by the change-log feature in TFS.  This table provides a simple
    look-up between the TFSLOG_XXX definitions (above) and readable text.
*/
static char *tfslogaction[] = { "ADD", "DEL", "IPM", " ON", "OFF" };

/* tfsflgtbl, tfserrtbl & tfsdfgmsgtbl:
    Tables that establish an easy lookup mechanism to convert from
    bitfield to string or character.
    Note that TFS_ULVL0 is commented out.  I leave it in here as a place
    holder (comment), but it actually is not needed becasue ulvl_0 is the
    default if no other ulvl is specified.
*/
static struct tfsflg tfsflgtbl[] = {
    TFS_BRUN,           'b',    "run_at_boot",          TFS_BRUN,
    TFS_QRYBRUN,        'B',    "qry_run_at_boot",      TFS_QRYBRUN,
    TFS_EXEC,           'e',    "executable",           TFS_EXEC,
    TFS_AOUT,           'A',    "aout",                 TFS_AOUT,
    TFS_COFF,           'C',    "coff",                 TFS_COFF,
    TFS_ELF,            'E',    "elf",                  TFS_ELF,
    TFS_IPMOD,          'i',    "inplace_modifiable",   TFS_IPMOD,
    TFS_UNREAD,         'u',    "ulvl_unreadable",      TFS_UNREAD,
/*  TFS_ULVL0,          '0',    "ulvl_0",               TFS_ULVLMSK, */
    TFS_ULVL1,          '1',    "ulvl_1",               TFS_ULVLMSK,
    TFS_ULVL2,          '2',    "ulvl_2",               TFS_ULVLMSK,
    TFS_ULVL3,          '3',    "ulvl_3",               TFS_ULVLMSK,
#if INCLUDE_UNPACK
    TFS_CPRS,           'c',    "compressed",           TFS_CPRS,
#endif
        0, 0, 0
};

static struct tfserr tfserrtbl[] = {
        TFS_OKAY,               "no error",
        TFSERR_NOFILE,          "file not found",
        TFSERR_NOSLOT,          "max fps opened",
        TFSERR_EOF,             "end of file",
        TFSERR_BADARG,          "bad argument",
        TFSERR_NOTEXEC,         "not executable",
        TFSERR_BADCRC,          "bad crc",
        TFSERR_FILEEXISTS,      "file already exists",
        TFSERR_FLASHFAILURE,    "flash operation failed",
        TFSERR_WRITEMAX,        "max write count exceeded",
        TFSERR_RDONLY,          "file is read-only",
        TFSERR_BADFD,           "invalid descriptor",
        TFSERR_BADHDR,          "bad coff|elf|aout header",
        TFSERR_CORRUPT,         "corrupt file",
        TFSERR_MEMFAIL,         "memory failure",
        TFSERR_NOTIPMOD,        "file is not in-place-modifiable",
        TFSERR_FLASHFULL,       "out of flash space",
        TFSERR_USERDENIED,      "user level access denied",
        0,0
};

static struct tfsdfg tfsdfgmsgtbl[] = {
    SECTOR_DEFRAG_INACTIVE,         "DefragInactive",
    BUILDING_HEADER_TABLE,          "BuildingHeaderTable",
    HEADER_TABLE_READY,             "HeaderTblReady",
    SECTOR_COPIED_TO_SPARE,         "SectorCopiedToSpare",
    SECTOR_UPDATE_STARTED,          "SectorUpdateStarted",
    SECTOR_UPDATE_COMPLETE,         "SectorUpdateComplete",
    SECTOR_DEFRAG_COMPLETE,         "SectorDefragComplete",
    ERASING_LAST_SECTOR,            "ErasingLastSector",
    TOTAL_DEFRAG_COMPLETE,          "TotalDefragComplete",
    COPY_HDRS_TO_SPARE,             "CopyingHdrsToSpare",
    HDRS_IN_SPARE,                  "HeadersInSpare",
    ERASING_DEAD_SECTOR,            "ErasingDeadSector",
    ERASED_DEAD_SECTOR,             "ErasedDeadSector",
    LASTSECTOR_IN_SPARE,            "LastSectorInSpare",
    0,0
};

/* dummyAtime() & dummyLtime():
    These two functions are loaded into the function pointers as defaults
    for the time-retrieval stuff used in TFS.
*/
char *
dummyAtime(long tval,char *buf,int buflen)
{
/*  strcpy(buf,"Fri Sep 13 00:00:00 1986"); */
    *buf = 0;
    return(buf);
}

long
dummyLtime(void)
{
    return(TIME_UNDEFINED);
}

/* crc32():
    The common CRC-32 code.  I got this out of the "Practical Algorithms
    for Programmers" book, but it can be found all over the place.
*/
ulong
crc32(buffer,nbytes)
uchar *buffer;
ulong nbytes;
{
    int temp;
    unsigned long crc_rslt;

    crc_rslt = 0xffffffff;
    while(nbytes) {
        temp = (crc_rslt ^ *buffer++) & 0x000000FFL;
        crc_rslt = ((crc_rslt >> 8) & 0x00FFFFFFL) ^ crc32tab[temp];
        nbytes--;
    }
    return(~crc_rslt);
}

/* tfsflasherase(), tfsflasheraseall() & tfsflashwrite():
    Wrappers for corresponding flash operations.  The wrappers are used
    to provide one place for the incrmentation of tfsFmodCount.
*/
tfsflasheraseall(void)
{
    tfsFmodCount++;
    return(AppFlashEraseAll());
}

tfsflasherase(snum)
int snum;
{
    tfsFmodCount++;
    return(AppFlashErase(snum));
}

tfsflashwrite(dest,src,bytecnt)
ulong   *src, *dest;
long bytecnt;
{
    tfsFmodCount++;
    return(AppFlashWrite(dest,src,bytecnt));
}

/* tfserrmsg():
    Return the error message string that corresponds to the incoming
    tfs error number.
*/
static char *
tfserrmsg(errno)
int errno;
{
    struct  tfserr  *tep;
    
    tep = tfserrtbl;
    while(tep->msg) {
        if (errno == tep->err)
            return(tep->msg);
        tep++;
    }
    return("unknown tfs errno");
}

/* tfsdefragmsg():
    Return the  message string that corresponds to the incoming
    tfs defragmentation state number.
*/
static char *
tfsdefragmsg(state)
int state;
{
    struct tfsdfg *tdp;

    tdp = tfsdfgmsgtbl;
    while(tdp->msg) {
        if (tdp->state == state)
            return(tdp->msg);
        tdp++;
    }
    return("unknown tfs defrag state");
}

/* tfsprflags():
   Print the specified set of flags.
*/
static void
tfsprflags(flags, verbose)
long flags;
int verbose;
{
    struct  tfsflg  *tfp;

    if (verbose)
        printf(" Flags: ");
    tfp = tfsflgtbl;
    while(tfp->sdesc) {
        if ((flags & tfp->mask) == tfp->flag) {
            if (verbose) {
                printf("%s", tfp->ldesc);
                if ((tfp+1)->flag)
                    printf(", ");
            }
            else
                putchar(tfp->sdesc);
        }
        tfp++;
    }
    if (verbose)
        printf("\n");
}

/* tfsflagsbtoa():
   Convert binary flags to ascii and return the string.
*/
static char *
tfsflagsbtoa(flags,fstr)
long    flags;
char    *fstr;
{
    int i;
    struct  tfsflg  *tfp;

    if ((!flags) || (!fstr))
        return((char *)0);

    i = 0;
    tfp = tfsflgtbl;
    *fstr = 0;
    while(tfp->sdesc) {
        if ((flags & tfp->mask) == tfp->flag)
            fstr[i++] = tfp->sdesc;
        tfp++;
    }
    fstr[i] = 0;
    return(fstr);
}

/* tfsflagsatob():
   Convert ascii flags to binary and return the long.
*/
static long
tfsflagsatob(fstr)
char *fstr;
{
    long    flag;
    struct  tfsflg  *tfp;

    if (!fstr)
        return(0);

    flag = 0;
    while(*fstr) {
        tfp = tfsflgtbl;
        while(tfp->sdesc) {
            if (*fstr == tfp->sdesc) {
                flag |= tfp->flag;
                break;
            }
            tfp++;
        }
        if (!tfp->flag)
            return(-1);
        fstr++;
    }