/* 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:              esutter@lucent.com *  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  0xffffffffextern 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);}longdummyLtime(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.*/ulongcrc32(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 voidtfsprflags(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 longtfsflagsatob(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++;    }