rwbuffer.c

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

            U8 const  TestPatern[] = {0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08};
        
            switch (TestNo+1)
            {
                default:
                case  8 :
                    INT_I64_SetValue(SECTOR_LBA+1, 0, LocalLBA);
                    ResultData = Pattern+4;
                    Offset     = 4;
                    break;
                    
                case  9 :
                    INT_I64_SetValue(SECTOR_LBA-1, 0, LocalLBA);
                    ResultData = TestPatern;
                    Offset     = 4 + 512;
                    break;
                    
                case 10 :
                    INT_I64_SetValue(SECTOR_LBA, 0, LocalLBA);
                    ResultData = TestPatern;
                    Offset     = 4;
                    break;
                    
                case 11 :
                    INT_I64_SetValue(SECTOR_LBA-2, 0, LocalLBA);
                    ResultData = TestPatern;
                    Offset     = 4 + 2*512;
                    break;
            }
            
            /* Acquire the buffer */
            
            if (NULL == (RWBuffer = stavfs_AcquireRWBuffer(&Device, &BufferLBA, FALSE)))
            {
                STTBX_Print(("Failed Acquiring the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
            
            /* Read the buffer */
            
            else if (ST_NO_ERROR != stavfs_RWBufferWrite(&Device, RWBuffer, 4, 8, (char*)TestPatern, FALSE))
            {
                STTBX_Print(("Failed Reading the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
            
            /* Block Read */
            
            else if (ST_NO_ERROR != stavfs_RWCacheBlockRead(&Device, &LocalLBA, 3, (char*)WorkBuffer, FALSE))
            {
                STTBX_Print(("Failed Writing the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
            
            /* Check the data */
            
            else if (memcmp(WorkBuffer+Offset, ResultData, 8))
            {
                int i;
                for (i = 0; (i < 16); i++)
                {
                    STTBX_Print(("0X%02X ", WorkBuffer[i]));
                }
                STTBX_Print(("Incorrect results (1)\n"));
                Result = TEST_FAILED;
            }
            
            /* Release the buffers */
            
            else if (ST_NO_ERROR != stavfs_DiscardRWBuffer(&Device, &RWBuffer))
            {
                STTBX_Print(("Failed Closing the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
            
            /* Read the sector */
            
            else if (ST_NO_ERROR != ReadTheSector(&Obj, WorkBuffer))
            {
                STTBX_Print(("Failed Reading the Sector\n"));
                Result = TEST_FAILED;
            }
            
            /* Check the data */
            
            else if (memcmp(WorkBuffer+4, TestPatern, 8))
            {
                int i;
                for (i = 0; (i < 16); i++)
                {
                    STTBX_Print(("0X%02X ", WorkBuffer[i]));
                }
                STTBX_Print(("Incorrect results (2)\n"));
                Result = TEST_FAILED;
            }
        
        
        }
        
        /* Close down */
        
        if (ST_NO_ERROR != stavfs_TermRWCache(&Device))
        {
            Result = TEST_FAILED;
        }
        
        if (ST_NO_ERROR != CloseHal(&Obj))
        {
            Result = TEST_FAILED;
        }
    }
    
    return(Result);
}






/******************************************************************************
Function Name : FlushTest
  Description : Buffer Flush
   Parameters :
******************************************************************************/
static TestResult_t FlushTest(int TestNo, TestVariant_t Variant)
{
    TestResult_t Result = TEST_PASSED;
    stavfs_HAL_t Obj;
    
    if (Variant != TEST_VARIANT_A)
    {
        Result = TEST_FAILED;
    }
    else if (ST_NO_ERROR != OpenHal(&Obj))
    {
        Result = TEST_FAILED;
    }
    else
    {
        /* Initialise the data structures */
        
        stavfs_Device_t Device;
        
        Device.HALData         = &Obj;
        Device.MemoryPartition = system_partition;
        Device.RWCache         = NULL;
                
        if (ST_NO_ERROR != InitialiseData(&Obj))
        {
            Result = TEST_FAILED;
        }
        else if (ST_NO_ERROR != stavfs_InitRWCache(&Device))
        {
            Result = TEST_FAILED;
        }
        else
        {
            /* Run the test */
            
            stavfs_RWBufferRef_t RWBuffer = NULL;
            U8  TestPatern[] = {0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08};
            
            /* Acquire the buffer */
            
            if (NULL == (RWBuffer = stavfs_AcquireRWBuffer(&Device, &BufferLBA, FALSE)))
            {
                STTBX_Print(("Failed Acquiring the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
            
            /* Write the buffers */
            
            else if (ST_NO_ERROR != stavfs_RWBufferWrite(&Device, RWBuffer, 4, 8, (char*)TestPatern, FALSE))
            {
                STTBX_Print(("Failed Writing the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
            
            /* Flush the buffers */
            
            else if (ST_NO_ERROR != stavfs_FlushRWCache(&Device))
            {
                STTBX_Print(("Failed Writing the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
            
            /* Read the sector */
            
            else if (ST_NO_ERROR != ReadTheSector(&Obj, WorkBuffer))
            {
                STTBX_Print(("Failed Reading the Sector\n"));
                Result = TEST_FAILED;
            }
            
            /* Check the data */
            
            else if (memcmp(WorkBuffer+4, TestPatern, 8))
            {
                int i;
                for (i = 0; (i < 16); i++)
                {
                    STTBX_Print(("0X%02X ", WorkBuffer[i]));
                }
                STTBX_Print(("Incorrect results (2)\n"));
                Result = TEST_FAILED;
            }
            
            /* Release the buffers */
            
            else if (ST_NO_ERROR != stavfs_DiscardRWBuffer(&Device, &RWBuffer))
            {
                STTBX_Print(("Failed Closing the R/W Buffer\n"));
                Result = TEST_FAILED;
            }
        }
        
        /* Close down */
        
        if (ST_NO_ERROR != stavfs_TermRWCache(&Device))
        {
            Result = TEST_FAILED;
        }
        
        if (ST_NO_ERROR != CloseHal(&Obj))
        {
            Result = TEST_FAILED;
        }
    }
    
    return(Result);
}






/******************************************************************************
Function Name : BufferTest
  Description : Test the R/W Buffering at the file level
   Parameters :
******************************************************************************/
static TestResult_t BufferTest(int TestNo, TestVariant_t Variant)
{
    TestResult_t Result = TEST_PASSED;
    
    STAVFS_InitParams_t  InitParams;
    STAVFS_OpenParams_t  OpenParams;
    STAVFS_Handle_t      Handle;
    STAVFS_TermParams_t  TermParams;
    
    TermParams.Flags = 0;
    
    strcpy(InitParams.EVTName,   EVT_DEVICE_NAME);
    strcpy(InitParams.ATAPIName, ATAPI_DEVICE_NAME);
    
    InitParams.Flags            = 0;
    InitParams.MemoryPartition  = system_partition;
    InitParams.Protocol         = 1;
    InitParams.UnitNumber       = 0;
    InitParams.PartitionNumber  = 0;

    OpenParams.Flags = 0;
    
    if (Variant != TEST_VARIANT_A)
    {
        Result = TEST_FAILED;
    }
    else if (ST_NO_ERROR != STAVFS_Init("Dev1", &InitParams))
    {
        STTBX_Print(("First initialisation failed\n"));
        Result = TEST_FAILED;
    }
    else
    {
        if (ST_NO_ERROR != STAVFS_FileSystemCheck ("Dev1", STAVFS_FSCK_DEFAULT))
        {
            STTBX_Print(("File system check failed\n"));
            Result = TEST_FAILED;
        }
        else if (ST_NO_ERROR != STAVFS_Open ("Dev1", &OpenParams, &Handle))
        {
            STTBX_Print(("Opening a volume on the device failed\n"));
            Result = TEST_FAILED;
        }
        else
        {
            int i;
            
            U32 DataWritten;
            U32 DataRead;
            
            char Data[] = {0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08, 0X09, 0X0A};
            
            STAVFS_FileHandle_t Handle1;
            STAVFS_FileHandle_t Handle2;
            STAVFS_FileHandle_t HandleA;
            STAVFS_FileHandle_t HandleB;
            
            BOOL SectorWrite = FALSE;
            
            U64 FileSize;
            
            /* Open up the file */
            
            I64_SetValue(8*1024, 0, FileSize);
            if (ST_NO_ERROR != STAVFS_OpenFile(Handle, STAVFS_NULL_FILE_HANDLE, "test",
                    STAVFS_READ_MODE|STAVFS_WRITE_MODE, FileSize, &Handle1))
            {
                STTBX_Print(("Error opening file\n"));
                Result = TEST_FAILED;
            }    
                 
            if (ST_NO_ERROR != STAVFS_OpenFile(Handle, STAVFS_NULL_FILE_HANDLE, "test",
                    STAVFS_READ_MODE|STAVFS_WRITE_MODE, FileSize, &Handle2))
            {
                STTBX_Print(("Error opening file\n"));
                Result = TEST_FAILED;
            }  
            
            /* Configure */
            
            switch (TestNo)
            {
                case 0 :
                    HandleA     = Handle1;
                    HandleB     = Handle1;
                    SectorWrite = 0;
                    break;
                    
                case 1 :
                    HandleA     = Handle1;
                    HandleB     = Handle1;
                    SectorWrite = 1;
                    break;
                    
                case 2 :
                    HandleA     = Handle1;
                    HandleB     = Handle1;
                    SectorWrite = 511;
                    break;
                    
                case 3 :
                    HandleA     = Handle1;
                    HandleB     = Handle2;
                    SectorWrite = 0;
                    break;
                    
                case 4 :
                    HandleA     = Handle1;
                    HandleB     = Handle2;
                    SectorWrite = 1;
                    break;
                    
                case 5 :
                    HandleA     = Handle1;
                    HandleB     = Handle2;
                    SectorWrite = 511;
                    break;
                    
            }
            
            for (i = 0; (i < SectorWrite); i++)
            {
                /* Write 512 bytes (push it on a sector) */   
                
                if (ST_NO_ERROR != STAVFS_WriteFile(HandleA, (char*)Pattern, sizeof(Pattern), &DataWritten))
                {
                    STTBX_Print(("Error writing\n"));
                    Result = TEST_FAILED;
                }
            }
            
            for (i = 0; (i < SectorWrite-1); i++)
            {
                /* Read 512 bytes (move it on a sector) */   
                
                if (ST_NO_ERROR != STAVFS_ReadFile(HandleB, (char*)WorkBuffer, sizeof(Pattern), &DataRead))
                {
                    STTBX_Print(("Error reading\n"));
                    Result = TEST_FAILED;
                }
            }
            
            /* Read and write alternatly */
            
            for (i = 0; (i < 52); i++)
            {   
                if (ST_NO_ERROR != STAVFS_WriteFile(HandleA, Data, 10, &DataWritten))
                {
                    STTBX_Print(("Error writing\n"));
                    Result = TEST_FAILED;
                }
                
                if (ST_NO_ERROR != STAVFS_ReadFile(HandleB,WorkBuffer , 10, &DataRead))
                {
                    STTBX_Print(("Error reading\n"));
                    Result = TEST_FAILED;
                }
                
                /* Check the data read */
                
                if (DataWritten != 10)
                {
                    STTBX_Print(("Write error %d\n", DataWritten));
                    Result = TEST_FAILED;
                }
                
                if (DataRead != 10)
                {
                    STTBX_Print(("Read error %d\n", DataRead));
                    Result = TEST_FAILED;
                }
                
                if (SectorWrite)
                {
                    if (i >= 51)
                    {
                        /* Stradles the sectors */
                        
                        if (memcmp("\1\0\1\2\3\4\5\6\7\10", WorkBuffer, 10))
                        {
                            STTBX_Print(("Bad read (1)\n"));
                            Result = TEST_FAILED;
                        }
                    }
                    else if (memcmp(Pattern+i*10, WorkBuffer, 10))
                    {
                        STTBX_Print(("Bad read (2)\n"));
                        Result = TEST_FAILED;
                    }
                }
                else