rwbuffer.c

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

                {
                    /* Read what was written */
                    
                    if (memcmp(Data, WorkBuffer, 10))
                    {
                        STTBX_Print(("Bad read (3)\n"));
                        Result = TEST_FAILED;
                    }
                }
            }
            
            
            /* Shut down */
                       
            if (ST_NO_ERROR != STAVFS_CloseFile(Handle1))
            {
                STTBX_Print(("Error closing\n"));
                Result = TEST_FAILED;
            }           
            if (ST_NO_ERROR != STAVFS_CloseFile(Handle2))
            {
                STTBX_Print(("Error closing\n"));
                Result = TEST_FAILED;
            }           
            
            /* Delete the file */
            
            if (ST_NO_ERROR != STAVFS_DeleteFile (Handle, STAVFS_NULL_FILE_HANDLE, "test"))
            {
                STTBX_Print(("Error deleting file\n"));
                Result = TEST_FAILED;
            }
            
	    if (ST_NO_ERROR != STAVFS_Close (Handle))
	    {
	        STTBX_Print (("Error Closing partition 3\n"));
	        Result = TEST_FAILED;
	    }
        }
        
        if (ST_NO_ERROR != STAVFS_Term("Dev1", &TermParams))
        {
            STTBX_Print(("Termination failed\n"));
            Result = TEST_FAILED;
        }
    }
    
    return(Result);
}






/******************************************************************************
Function Name : SpanTest
  Description : Test spanning multiple sectors
   Parameters :
******************************************************************************/
static TestResult_t SpanTest(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
        {
            U32 DataWritten;
            U32 DataRead;
            
            char Data[] = {0X01, 0X02, 0X03, 0X04, 0X05, 0X06, 0X07, 0X08, 0X09, 0X0A};
            
            STAVFS_FileHandle_t Handle1;
            
            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;
            } 
            
            /* Write 10 bytes (push it into a sector) */   
            
            if (ST_NO_ERROR != STAVFS_WriteFile(Handle1, (char*)Data, sizeof(Data), &DataWritten))
            {
                STTBX_Print(("Error writing\n"));
                Result = TEST_FAILED;
            }
            
            if (ST_NO_ERROR != STAVFS_ReadFile(Handle1, WorkBuffer, 10, &DataRead))
            {
                STTBX_Print(("Error reading\n"));
                Result = TEST_FAILED;
            }
                
            /* Check the data read */
            
            if (DataWritten != 10)
            {
                STTBX_Print(("Write error\n"));
                Result = TEST_FAILED;
            }
            
            if (DataRead != 10)
            {
                STTBX_Print(("Read error\n"));
                Result = TEST_FAILED;
            }
            
            if (memcmp(Data, WorkBuffer, 10))
            {
                STTBX_Print(("Bad read (1)\n"));
                Result = TEST_FAILED;
            } 
            
            /* Write 1526 bytes (multiple sectors) */   
            
            if (ST_NO_ERROR != STAVFS_WriteFile(Handle1, (char*)BlockPattern, sizeof(BlockPattern), &DataWritten))
            {
                STTBX_Print(("Error writing\n"));
                Result = TEST_FAILED;
            }
            
            if (ST_NO_ERROR != STAVFS_ReadFile(Handle1, WorkBuffer, sizeof(BlockPattern), &DataRead))
            {
                STTBX_Print(("Error reading\n"));
                Result = TEST_FAILED;
            }
                
            /* Check the data read */
            
            if (DataWritten != sizeof(BlockPattern))
            {
                STTBX_Print(("Write error\n"));
                Result = TEST_FAILED;
            }
            
            if (DataRead != sizeof(BlockPattern))
            {
                STTBX_Print(("Read error\n"));
                Result = TEST_FAILED;
            }
            
            if (memcmp(BlockPattern, WorkBuffer, sizeof(BlockPattern)))
            {
                STTBX_Print(("Bad read (2)\n"));
                Result = TEST_FAILED;
            }
            
            
            /* Shut down */
                       
            if (ST_NO_ERROR != STAVFS_CloseFile(Handle1))
            {
                STTBX_Print(("Error closing\n"));
                Result = TEST_FAILED;
            }         
            
            /* Delete the file */
            
            if (ST_NO_ERROR != STAVFS_DeleteFile (Handle, STAVFS_NULL_FILE_HANDLE, "test"))
            {
                STTBX_Print(("Error deleting file\n"));
                Result = TEST_FAILED;
            }
            
	    if (ST_NO_ERROR != STAVFS_Close (Handle))
	    {
	        STTBX_Print (("Error Closing partition 3\n"));
	        Result = TEST_FAILED;
	    }
        }
        
        if (ST_NO_ERROR != STAVFS_Term("Dev1", &TermParams))
        {
            STTBX_Print(("Termination failed\n"));
            Result = TEST_FAILED;
        }
    }
    
    return(Result);
}






/******************************************************************************
Function Name : FileFlushTest
  Description : Check that the buffers are flushed when the file is closed
   Parameters :
******************************************************************************/
static TestResult_t FileFlushTest(int TestNo, TestVariant_t Variant)
{
    TestResult_t        Result;

    STAVFS_Handle_t     DiskHandle;
        
    Result = OpenPartition(0, 1, "Dev1", &DiskHandle);
    if (TEST_PASSED == Result)
    {
        STAVFS_FileHandle_t FileHandle;
        
        U64 FileSize;
        U32 DataSize = 10;
        U32 DataWritten, DataRead;
        
        I64_SetValue (DISK_SECTOR_SIZE, 0, FileSize);
        if (ST_NO_ERROR != STAVFS_OpenFile (DiskHandle, STAVFS_NULL_FILE_HANDLE, "test",
                STAVFS_WRITE_MODE | STAVFS_READ_MODE, FileSize, &FileHandle))
        {
            STTBX_Print (("Error opening file (1)\n"));
            Result = TEST_FAILED;
        }
        else
        {
            /* write and read 10 bytes */
            if (ST_NO_ERROR != STAVFS_WriteFile (FileHandle, BlockPattern, DataSize, &DataWritten))
            {
                STTBX_Print (("Error writing file\n"));
                Result = TEST_FAILED;
            }
            else if (ST_NO_ERROR != STAVFS_ReadFile (FileHandle, WorkBuffer + DataSize, DataSize, &DataRead))
            {
                STTBX_Print (("Error reading file (1)\n"));
                Result = TEST_FAILED;
            }
            
            /* close file, and reopen if no errors so far */
            
            if (ST_NO_ERROR != STAVFS_CloseFile (FileHandle))
            {
                STTBX_Print (("Error closing file (1)\n"));
                Result = TEST_FAILED;
            }
            
            if (Result == TEST_PASSED)
            {
                if(ST_NO_ERROR != STAVFS_OpenFile (DiskHandle, STAVFS_NULL_FILE_HANDLE, "test",
                        STAVFS_READ_MODE, FileSize, &FileHandle))
                {
                    STTBX_Print (("Error opening file (2)\n"));
                    Result = TEST_FAILED;
                }
                else
                {
                    if (ST_NO_ERROR != STAVFS_ReadFile (FileHandle, WorkBuffer, DataSize, &DataRead)
                        || DataRead != DataSize)
                    {
                        STTBX_Print (("Error reading file (2)\n"));
                        Result = TEST_FAILED;
                    }
                    else if (memcmp(WorkBuffer, BlockPattern, DataSize))
                    {
                        STTBX_Print (("Write-read mismatch\n"));
                        Result = TEST_FAILED;
                    }

                    if (ST_NO_ERROR != STAVFS_CloseFile (FileHandle))
                    {
                        STTBX_Print (("Error closing file (2)\n"));
                        Result = TEST_FAILED;
                    }
                }
            }
            
            /* delete file in all cases where we sucessfully created it */
            
            if (ST_NO_ERROR != STAVFS_DeleteFile (DiskHandle, STAVFS_NULL_FILE_HANDLE, "test"))
            {
                STTBX_Print (("Error deleting file\n"));
                Result = TEST_FAILED;
            }
        }
        
        if (TEST_PASSED != ClosePartition("Dev1", DiskHandle))
        {
            Result = TEST_FAILED; /* message already displayed */
        }
    }

    return (Result);
}









/******************************************************************************
Function Name :
  Description :
   Parameters :
******************************************************************************/
static ST_ErrorCode_t OpenHal(stavfs_HAL_t *Obj)
{   
    Obj->Initialised = FALSE;
    Obj->Protocol    = PROTOCOL_ATA;
    Obj->UnitNumber  = 0;
    
    strcpy(Obj->EVTName,   EVT_DEVICE_NAME);
    strcpy(Obj->ATAPIName, ATAPI_DEVICE_NAME);
    
    return (stavfs_HalInit(Obj));
}
        








/******************************************************************************
Function Name : 
  Description : 
   Parameters :
******************************************************************************/
static ST_ErrorCode_t InitialiseData(stavfs_HAL_t *Obj)
{   
    ST_ErrorCode_t Error = ST_NO_ERROR;
    int  i;
    U64  FirstSector;
    
    for (i = -8; (i < 8); i++)
    {
        I64_SetValue(SECTOR_LBA+i, 0, FirstSector); /* Arbitary location */
 
        if (ST_NO_ERROR != stavfs_HalWrite (Obj, &FirstSector, 1, (char*)Pattern, FALSE))
        {
            STTBX_Print(("Write failed\n"));
            Error = TEST_FAILED;
        }
    }
    
    return (Error);
}
        








/******************************************************************************
Function Name : 
  Description : 
   Parameters :
******************************************************************************/
static ST_ErrorCode_t ReadTheSector(stavfs_HAL_t *Obj, char *Data)
{   
    ST_ErrorCode_t Error = ST_NO_ERROR;
    
    if (ST_NO_ERROR != stavfs_HalRead (Obj, &BufferLBA, 1, Data, FALSE))
    {
        STTBX_Print(("Read failed\n"));
        Error = TEST_FAILED;
    }
    
    return (Error);
}









/******************************************************************************
Function Name :
  Description :
   Parameters :
******************************************************************************/
static ST_ErrorCode_t CloseHal(stavfs_HAL_t *Obj)
{   
    return (stavfs_HalTerm(Obj));
}