crashtst.c

ST5518机顶盒系统文件系统源代码！绝对超值！

/******************************************************************************

    File Name   : crashtst.c

    Description : Implements the crash-recovery test.

******************************************************************************/

/* Includes ---------------------------------------------------------------- */

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <assert.h>

#include <task.h>
#include <ostime.h>

#include "wrapper.h"
#include "crash.h"
#include "hal.h"
#include "stavfs.h"

/* Private Types ----------------------------------------------------------- */

/* Private Constants ------------------------------------------------------- */

/* Use partition 2 (2 sectors per cluster) */
#define PARTITION_NUM   (2)
#define DEV_NAME        "CrashDev"

#define FILLER_FILE_NAME     "crash filler.tst"
#define BACKGROUND_FILE_NAME "crash background.tst"
#define WORKING_FILE_NAME    "crash working.tst"

#define CLUSTER_BYTES   \
    (TestPartitionDefs[PARTITION_NUM].SizeOfCluster * DISK_SECTOR_SIZE)

/* sanity check on the maximum number of iterations */
#define MAX_ITERATIONS  (500)

/* sanity check on the maximum number of chunks to read when checking file */
#define MAX_CHUNKS      (100)

#define BACKGROUND_NUM_CHUNKS       (10)
#define BACKGROUND_CHUNK_SIZE       (900)
#define WORKING_NUM_CHUNKS_PRESYNC  (10)
#define WORKING_NUM_CHUNKS_POSTSYNC (5)
#define WORKING_CHUNK_SIZE          (1000)

#define WORKING_ALLOC_SIZE    (5 * CLUSTER_BYTES)

/* ScanFile return if target doesn't exist */
#define DOESNT_EXIST (-1)


#define MAX_CHUNK_SIZE   (WORKING_CHUNK_SIZE > BACKGROUND_CHUNK_SIZE ? \
                            WORKING_CHUNK_SIZE : BACKGROUND_CHUNK_SIZE)
                            
/* Standard data, initialised in CrashTest */
static U8 const StdData[] =
{
    0X00, 0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08, 0X09, 0X0A, 0X0B, 0X0C, 0X0D, 0X0E, 0X0F,
    0X10, 0X11, 0X12, 0X13, 0X14, 0X15, 0X16, 0X17, 0X18, 0X19, 0X1A, 0X1B, 0X1C, 0X1D, 0X1E, 0X1F,
    0X20, 0X21, 0X22, 0X23, 0X24, 0X25, 0X26, 0X27, 0X28, 0X29, 0X2A, 0X2B, 0X2C, 0X2D, 0X2E, 0X2F,
    0X30, 0X31, 0X32, 0X33, 0X34, 0X35, 0X36, 0X37, 0X38, 0X39, 0X3A, 0X3B, 0X3C, 0X3D, 0X3E, 0X3F,
    0X40, 0X41, 0X42, 0X43, 0X44, 0X45, 0X46, 0X47, 0X48, 0X49, 0X4A, 0X4B, 0X4C, 0X4D, 0X4E, 0X4F,
    0X50, 0X51, 0X52, 0X53, 0X54, 0X55, 0X56, 0X57, 0X58, 0X59, 0X5A, 0X5B, 0X5C, 0X5D, 0X5E, 0X5F,
    0X60, 0X61, 0X62, 0X63, 0X64, 0X65, 0X66, 0X67, 0X68, 0X69, 0X6A, 0X6B, 0X6C, 0X6D, 0X6E, 0X6F,
    0X70, 0X71, 0X72, 0X73, 0X74, 0X75, 0X76, 0X77, 0X78, 0X79, 0X7A, 0X7B, 0X7C, 0X7D, 0X7E, 0X7F,
    0X80, 0X81, 0X82, 0X83, 0X84, 0X85, 0X86, 0X87, 0X88, 0X89, 0X8A, 0X8B, 0X8C, 0X8D, 0X8E, 0X8F,
    0X90, 0X91, 0X92, 0X93, 0X94, 0X95, 0X96, 0X97, 0X98, 0X99, 0X9A, 0X9B, 0X9C, 0X9D, 0X9E, 0X9F,
    0XA0, 0XA1, 0XA2, 0XA3, 0XA4, 0XA5, 0XA6, 0XA7, 0XA8, 0XA9, 0XAA, 0XAB, 0XAC, 0XAD, 0XAE, 0XAF,
    0XB0, 0XB1, 0XB2, 0XB3, 0XB4, 0XB5, 0XB6, 0XB7, 0XB8, 0XB9, 0XBA, 0XBB, 0XBC, 0XBD, 0XBE, 0XBF,
    0XC0, 0XC1, 0XC2, 0XC3, 0XC4, 0XC5, 0XC6, 0XC7, 0XC8, 0XC9, 0XCA, 0XCB, 0XCC, 0XCD, 0XCE, 0XCF,
    0XD0, 0XD1, 0XD2, 0XD3, 0XD4, 0XD5, 0XD6, 0XD7, 0XD8, 0XD9, 0XDA, 0XDB, 0XDC, 0XDD, 0XDE, 0XDF,
    0XE0, 0XE1, 0XE2, 0XE3, 0XE4, 0XE5, 0XE6, 0XE7, 0XE8, 0XE9, 0XEA, 0XEB, 0XEC, 0XED, 0XEE, 0XEF,
    0XF0, 0XF1, 0XF2, 0XF3, 0XF4, 0XF5, 0XF6, 0XF7, 0XF8, 0XF9, 0XFA, 0XFB, 0XFC, 0XFD, 0XFE, 0XFF,
    
    0X00, 0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08, 0X09, 0X0A, 0X0B, 0X0C, 0X0D, 0X0E, 0X0F,
    0X10, 0X11, 0X12, 0X13, 0X14, 0X15, 0X16, 0X17, 0X18, 0X19, 0X1A, 0X1B, 0X1C, 0X1D, 0X1E, 0X1F,
    0X20, 0X21, 0X22, 0X23, 0X24, 0X25, 0X26, 0X27, 0X28, 0X29, 0X2A, 0X2B, 0X2C, 0X2D, 0X2E, 0X2F,
    0X30, 0X31, 0X32, 0X33, 0X34, 0X35, 0X36, 0X37, 0X38, 0X39, 0X3A, 0X3B, 0X3C, 0X3D, 0X3E, 0X3F,
    0X40, 0X41, 0X42, 0X43, 0X44, 0X45, 0X46, 0X47, 0X48, 0X49, 0X4A, 0X4B, 0X4C, 0X4D, 0X4E, 0X4F,
    0X50, 0X51, 0X52, 0X53, 0X54, 0X55, 0X56, 0X57, 0X58, 0X59, 0X5A, 0X5B, 0X5C, 0X5D, 0X5E, 0X5F,
    0X60, 0X61, 0X62, 0X63, 0X64, 0X65, 0X66, 0X67, 0X68, 0X69, 0X6A, 0X6B, 0X6C, 0X6D, 0X6E, 0X6F,
    0X70, 0X71, 0X72, 0X73, 0X74, 0X75, 0X76, 0X77, 0X78, 0X79, 0X7A, 0X7B, 0X7C, 0X7D, 0X7E, 0X7F,
    0X80, 0X81, 0X82, 0X83, 0X84, 0X85, 0X86, 0X87, 0X88, 0X89, 0X8A, 0X8B, 0X8C, 0X8D, 0X8E, 0X8F,
    0X90, 0X91, 0X92, 0X93, 0X94, 0X95, 0X96, 0X97, 0X98, 0X99, 0X9A, 0X9B, 0X9C, 0X9D, 0X9E, 0X9F,
    0XA0, 0XA1, 0XA2, 0XA3, 0XA4, 0XA5, 0XA6, 0XA7, 0XA8, 0XA9, 0XAA, 0XAB, 0XAC, 0XAD, 0XAE, 0XAF,
    0XB0, 0XB1, 0XB2, 0XB3, 0XB4, 0XB5, 0XB6, 0XB7, 0XB8, 0XB9, 0XBA, 0XBB, 0XBC, 0XBD, 0XBE, 0XBF,
    0XC0, 0XC1, 0XC2, 0XC3, 0XC4, 0XC5, 0XC6, 0XC7, 0XC8, 0XC9, 0XCA, 0XCB, 0XCC, 0XCD, 0XCE, 0XCF,
    0XD0, 0XD1, 0XD2, 0XD3, 0XD4, 0XD5, 0XD6, 0XD7, 0XD8, 0XD9, 0XDA, 0XDB, 0XDC, 0XDD, 0XDE, 0XDF,
    0XE0, 0XE1, 0XE2, 0XE3, 0XE4, 0XE5, 0XE6, 0XE7, 0XE8, 0XE9, 0XEA, 0XEB, 0XEC, 0XED, 0XEE, 0XEF,
    0XF0, 0XF1, 0XF2, 0XF3, 0XF4, 0XF5, 0XF6, 0XF7, 0XF8, 0XF9, 0XFA, 0XFB, 0XFC, 0XFD, 0XFE, 0XFF,
    
    0X00, 0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08, 0X09, 0X0A, 0X0B, 0X0C, 0X0D, 0X0E, 0X0F,
    0X10, 0X11, 0X12, 0X13, 0X14, 0X15, 0X16, 0X17, 0X18, 0X19, 0X1A, 0X1B, 0X1C, 0X1D, 0X1E, 0X1F,
    0X20, 0X21, 0X22, 0X23, 0X24, 0X25, 0X26, 0X27, 0X28, 0X29, 0X2A, 0X2B, 0X2C, 0X2D, 0X2E, 0X2F,
    0X30, 0X31, 0X32, 0X33, 0X34, 0X35, 0X36, 0X37, 0X38, 0X39, 0X3A, 0X3B, 0X3C, 0X3D, 0X3E, 0X3F,
    0X40, 0X41, 0X42, 0X43, 0X44, 0X45, 0X46, 0X47, 0X48, 0X49, 0X4A, 0X4B, 0X4C, 0X4D, 0X4E, 0X4F,
    0X50, 0X51, 0X52, 0X53, 0X54, 0X55, 0X56, 0X57, 0X58, 0X59, 0X5A, 0X5B, 0X5C, 0X5D, 0X5E, 0X5F,
    0X60, 0X61, 0X62, 0X63, 0X64, 0X65, 0X66, 0X67, 0X68, 0X69, 0X6A, 0X6B, 0X6C, 0X6D, 0X6E, 0X6F,
    0X70, 0X71, 0X72, 0X73, 0X74, 0X75, 0X76, 0X77, 0X78, 0X79, 0X7A, 0X7B, 0X7C, 0X7D, 0X7E, 0X7F,
    0X80, 0X81, 0X82, 0X83, 0X84, 0X85, 0X86, 0X87, 0X88, 0X89, 0X8A, 0X8B, 0X8C, 0X8D, 0X8E, 0X8F,
    0X90, 0X91, 0X92, 0X93, 0X94, 0X95, 0X96, 0X97, 0X98, 0X99, 0X9A, 0X9B, 0X9C, 0X9D, 0X9E, 0X9F,
    0XA0, 0XA1, 0XA2, 0XA3, 0XA4, 0XA5, 0XA6, 0XA7, 0XA8, 0XA9, 0XAA, 0XAB, 0XAC, 0XAD, 0XAE, 0XAF,
    0XB0, 0XB1, 0XB2, 0XB3, 0XB4, 0XB5, 0XB6, 0XB7, 0XB8, 0XB9, 0XBA, 0XBB, 0XBC, 0XBD, 0XBE, 0XBF,
    0XC0, 0XC1, 0XC2, 0XC3, 0XC4, 0XC5, 0XC6, 0XC7, 0XC8, 0XC9, 0XCA, 0XCB, 0XCC, 0XCD, 0XCE, 0XCF,
    0XD0, 0XD1, 0XD2, 0XD3, 0XD4, 0XD5, 0XD6, 0XD7, 0XD8, 0XD9, 0XDA, 0XDB, 0XDC, 0XDD, 0XDE, 0XDF,
    0XE0, 0XE1, 0XE2, 0XE3, 0XE4, 0XE5, 0XE6, 0XE7, 0XE8, 0XE9, 0XEA, 0XEB, 0XEC, 0XED, 0XEE, 0XEF,
    0XF0, 0XF1, 0XF2, 0XF3, 0XF4, 0XF5, 0XF6, 0XF7, 0XF8, 0XF9, 0XFA, 0XFB, 0XFC, 0XFD, 0XFE, 0XFF,
    
    0X00, 0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08, 0X09, 0X0A, 0X0B, 0X0C, 0X0D, 0X0E, 0X0F,
    0X10, 0X11, 0X12, 0X13, 0X14, 0X15, 0X16, 0X17, 0X18, 0X19, 0X1A, 0X1B, 0X1C, 0X1D, 0X1E, 0X1F,
    0X20, 0X21, 0X22, 0X23, 0X24, 0X25, 0X26, 0X27, 0X28, 0X29, 0X2A, 0X2B, 0X2C, 0X2D, 0X2E, 0X2F,
    0X30, 0X31, 0X32, 0X33, 0X34, 0X35, 0X36, 0X37, 0X38, 0X39, 0X3A, 0X3B, 0X3C, 0X3D, 0X3E, 0X3F,
    0X40, 0X41, 0X42, 0X43, 0X44, 0X45, 0X46, 0X47, 0X48, 0X49, 0X4A, 0X4B, 0X4C, 0X4D, 0X4E, 0X4F,
    0X50, 0X51, 0X52, 0X53, 0X54, 0X55, 0X56, 0X57, 0X58, 0X59, 0X5A, 0X5B, 0X5C, 0X5D, 0X5E, 0X5F,
    0X60, 0X61, 0X62, 0X63, 0X64, 0X65, 0X66, 0X67, 0X68, 0X69, 0X6A, 0X6B, 0X6C, 0X6D, 0X6E, 0X6F,
    0X70, 0X71, 0X72, 0X73, 0X74, 0X75, 0X76, 0X77, 0X78, 0X79, 0X7A, 0X7B, 0X7C, 0X7D, 0X7E, 0X7F,
    0X80, 0X81, 0X82, 0X83, 0X84, 0X85, 0X86, 0X87, 0X88, 0X89, 0X8A, 0X8B, 0X8C, 0X8D, 0X8E, 0X8F,
    0X90, 0X91, 0X92, 0X93, 0X94, 0X95, 0X96, 0X97, 0X98, 0X99, 0X9A, 0X9B, 0X9C, 0X9D, 0X9E, 0X9F,
    0XA0, 0XA1, 0XA2, 0XA3, 0XA4, 0XA5, 0XA6, 0XA7, 0XA8, 0XA9, 0XAA, 0XAB, 0XAC, 0XAD, 0XAE, 0XAF,
    0XB0, 0XB1, 0XB2, 0XB3, 0XB4, 0XB5, 0XB6, 0XB7, 0XB8, 0XB9, 0XBA, 0XBB, 0XBC, 0XBD, 0XBE, 0XBF,
    0XC0, 0XC1, 0XC2, 0XC3, 0XC4, 0XC5, 0XC6, 0XC7, 0XC8, 0XC9, 0XCA, 0XCB, 0XCC, 0XCD, 0XCE, 0XCF,
    0XD0, 0XD1, 0XD2, 0XD3, 0XD4, 0XD5, 0XD6, 0XD7, 0XD8, 0XD9, 0XDA, 0XDB, 0XDC, 0XDD, 0XDE, 0XDF,
    0XE0, 0XE1, 0XE2, 0XE3, 0XE4, 0XE5, 0XE6, 0XE7, 0XE8, 0XE9, 0XEA, 0XEB, 0XEC, 0XED, 0XEE, 0XEF,
    0XF0, 0XF1, 0XF2, 0XF3, 0XF4, 0XF5, 0XF6, 0XF7, 0XF8, 0XF9, 0XFA, 0XFB, 0XFC, 0XFD, 0XFE, 0XFF,
};


/* Private Variables ------------------------------------------------------- */

static U8 Buffer[MAX_CHUNK_SIZE];

/* feedback from CrashThreadProc on what it was attempting when it crashed */
typedef enum
{
    CP_INIT,
    CP_OPEN,
    CP_CREATE_FILE,
    CP_WRITE_PRESYNC,
    CP_SYNC_FILE,
    CP_WRITE_POSTSYNC_FIRST,
    CP_WRITE_POSTSYNC,
    CP_CLOSE_FILE,
    CP_DELETE_FILE,
    CP_CLOSE,
    CP_TERM,
    CP_COMPLETE,
    
    CP_ERROR      /* error performing operations; give up test */
} CrashPoint_t;

static CrashPoint_t CrashPoint = CP_INIT;

/* free disk space after background file is created
  - reference for working out working file allocation size */
static U64 BaseDiskSpace;


/* Private Macros ---------------------------------------------------------- */

/* Private Function Prototypes --------------------------------------------- */

static TestResult_t  CrashTest         (int TestNo, TestVariant_t Variant);

static TestResult_t  EstablishBackgroundFile (void);
static TestResult_t  DeleteBackgroundFile    (void);
static void          CrashThreadProc         (void * Param);
static TestResult_t  CheckAfterCrash         (int Interation);
static TestResult_t  CheckBackgroundFile     (STAVFS_Handle_t DiskHandle);
static TestResult_t  CheckWorkingFile        (STAVFS_Handle_t DiskHandle);
static TestResult_t  ValidateFreeSpace       (STAVFS_Handle_t DiskHandle);
static void          DescribeCrashPoint      (void);

static void    TryBadFileOpen    (STAVFS_Handle_t DiskHandle, char * PathName,
                                  STAVFS_OpenMode_t OpenMode, U64 Size,
                                  char * Descr, TestResult_t * Result_p);
static TestResult_t  WriteChunks (STAVFS_FileHandle_t FileHandle, U32 NumChunks,
                                  U32 ChunkSize, char * Prefix_p);
static TestResult_t  ReadChunks  (STAVFS_FileHandle_t FileHandle, U32 ChunkSize,
                                  char * Prefix_p, U32 * NumChunks_p, BOOL BadLastSector);
static TestResult_t  ScanFile    (STAVFS_Handle_t DiskHandle, char * FileName,
                                  U32 ChunkSize, char * Prefix_p,
                                  S32 * NumChunks_p, BOOL BadLastSector);


/* Functions --------------------------------------------------------------- */


/******************************************************************************
Function Name : Crash
  Description : Crash-recovery test section function.
   Parameters :
******************************************************************************/
BOOL Crash (parse_t * pars_p, char *result_sym_p)
{
    char *Description = "Crash-recovery test";
    
    TestCall_t TestList[] =
    {
         CrashTest,          /* Test 001 */
    };
    
    GenericTest (pars_p, result_sym_p,
                 Description,
                 TestList, TABLE_LEN(TestList)-1,
		 TEST_VARIANT_A);
                 
    return (FALSE);
}





/******************************************************************************
Function Name : CrashTest
  Description : Main function controlling the crash test
   Parameters :
******************************************************************************/
static TestResult_t CrashTest(int TestNo, TestVariant_t Variant)
{
    TestResult_t  Result       = TEST_PASSED;
    task_t       *CrashThread;

#ifndef STAVFS_CRASH_TEST
    STTBX_Print (("Crash test not possible"
                  " without STAVFS_CRASH_TEST defined\n"));
    return (TEST_NOT_RUN);
#endif

    if (TEST_PASSED != EstablishBackgroundFile())
    {
        Result = TEST_FAILED;
    }
    else
    {
        int IterationIdx = 0;
        
        while ((CrashPoint != CP_COMPLETE) && (CrashPoint != CP_ERROR))
        {
            /* Set up the number of writes to allow before crashing */

            stavfs_SetCrash (IterationIdx++);
            

            /* Run the test sequence on a separate thread */

            CrashThread =
              task_create (CrashThreadProc,       /* thread procedure */
                           NULL,                  /* param - unused */
                           10*1024,               /* stack size */
                           task_priority(NULL),   /* priority - same as us */
                           "STAVFS Crash thread", /* debugger name */
                           0);                    /* flags */

            if (CrashThread == NULL)
            {
                STTBX_Print
                    (("Failed to create second thread for crash test\n"));
                Result = TEST_FAILED;
                break; /* this one is fairly terminal */
            }
            
            /* Wait for thread to terminate, either by crashing
              or finishing the test sequence */
              
            task_wait (&CrashThread, 1, TIMEOUT_INFINITY);

            /* Disable crashing */
            stavfs_SetCrash (NOCRASH);
            
            if (-1 == task_delete (CrashThread))
            {
                STTBX_Print
                    (("Failed to delete second thread during crash test\n"));
                Result = TEST_FAILED;
            }
            
            
            /* separate the output a bit and make
              the crash point description a header */
              
            STTBX_Print (("\n%i: ", IterationIdx));
            DescribeCrashPoint();

            
            /* Check results and clean up working file */

            if (TEST_PASSED != CheckAfterCrash(IterationIdx))
            {
                Result = TEST_FAILED;
                /* but keep trying subsequent iterations
                  to gather more data ... */
            }
        }
        
        if (CrashPoint == CP_ERROR)
        {
            /* Something through a wobbly */
            
            Result = TEST_FAILED;
        }

        if (TEST_PASSED != DeleteBackgroundFile())
        {
            Result = TEST_FAILED;
        }
    }

    return (Result);
}


/******************************************************************************
Function Name : EstablishBackgroundFile
  Description : Initial creation of the 'background' file that crashes should
                leave untouched
   Parameters :
******************************************************************************/
static TestResult_t EstablishBackgroundFile(void)
{
    TestResult_t        Result;
    ST_ErrorCode_t      Error;

    STAVFS_Handle_t     DiskHandle;
    STAVFS_FileHandle_t FileHandle;
    
    U64 FileSize;