_mfs_error MFS_Flush_data_sector_buffer
(
MFS_DRIVE_STRUCT_PTR drive_ptr /*[IN] the drive on which to operate */
)
{
#if MFSCFG_READ_ONLY
return MFS_NO_ERROR;
#else
_mfs_error error_code = MFS_NO_ERROR;
#if MFSCFG_READ_ONLY_CHECK
if (MFS_is_read_only (NULL, drive_ptr))
{
return error_code;
}
#endif
if ( drive_ptr->DATA_SECTOR_DIRTY )
{
error_code = MFS_Write_device_sector(drive_ptr,drive_ptr->DATA_SECTOR_NUMBER,drive_ptr->DATA_SECTOR_PTR);
if ( error_code == MFS_NO_ERROR )
{
drive_ptr->DATA_SECTOR_DIRTY=FALSE;
}
}
return error_code;
#endif
}
_mfs_error MFS_Clear_cluster
(
MFS_DRIVE_STRUCT_PTR drive_ptr, /*[IN] the drive on which to operate */
uint_32 cluster /*[IN] the # of the cluster to clear*/
)
{
uint_32 sector,i;
_mfs_error error_code;
#if MFSCFG_READ_ONLY_CHECK
if (MFS_is_read_only (NULL, drive_ptr))
{
return MFS_DISK_IS_WRITE_PROTECTED;
}
#endif
error_code = MFS_Flush_directory_sector_buffer(drive_ptr);
sector = CLUSTER_TO_SECTOR(cluster);
_mem_zero(drive_ptr->DIR_SECTOR_PTR, drive_ptr->BPB.SECTOR_SIZE);
for ( i = 0; ((i<drive_ptr->BPB.SECTORS_PER_CLUSTER) && (error_code==MFS_NO_ERROR));i++ )
{
error_code = MFS_Write_device_sector(drive_ptr,sector+i,drive_ptr->DIR_SECTOR_PTR);
}
drive_ptr->DIR_SECTOR_NUMBER = sector;
return(error_code);
}
/*FUNCTION*-------------------------------------------------------------------
*
* Function Name : MFS_Flush_directory_sector_buffer
* Returned Value : MFS error code
* Comments :
* Write the sector buffer back to the disk.
* Assumes the semaphore is already obtained.
*END*---------------------------------------------------------------------*/
_mfs_error MFS_Flush_directory_sector_buffer
(
MFS_DRIVE_STRUCT_PTR drive_ptr
)
{
#if MFSCFG_READ_ONLY
return MFS_NO_ERROR;
#else
_mfs_error error_code= MFS_NO_ERROR;
#if MFSCFG_READ_ONLY_CHECK
if (MFS_is_read_only (NULL, drive_ptr))
{
return error_code;
}
#endif
if ( drive_ptr->DIR_SECTOR_DIRTY )
{
error_code = MFS_Write_device_sector(drive_ptr,drive_ptr->DIR_SECTOR_NUMBER,drive_ptr->DIR_SECTOR_PTR);
drive_ptr->DIR_SECTOR_DIRTY = FALSE;
}
return(error_code);
#endif
}
_mfs_error MFS_Flush_fat_cache
(
MFS_DRIVE_STRUCT_PTR drive_ptr /*[IN] the drive on which to operate */
)
{
#if MFSCFG_READ_ONLY
return MFS_NO_ERROR;
#else
_mfs_error error_code;
uint_32 fat_size,fat,i;
error_code = MFS_NO_ERROR;
#if MFSCFG_READ_ONLY_CHECK
if (MFS_is_read_only (NULL, drive_ptr))
{
return error_code;
}
#endif
if ( drive_ptr->FAT_CACHE_DIRTY )
{
if ( drive_ptr->FAT_TYPE == MFS_FAT32 )
{
fat_size = drive_ptr->BPB32.FAT_SIZE;
}
else
{
fat_size = drive_ptr->BPB.SECTORS_PER_FAT;
}
/* Backup all copies of fat */
for ( fat=0; (fat<drive_ptr->BPB.NUMBER_OF_FAT) && (error_code==MFS_NO_ERROR); fat++ )
{
for ( i=0; (i<drive_ptr->FAT_CACHE_SIZE) && (error_code==MFS_NO_ERROR); i++ )
{
error_code = MFS_Write_device_sector(drive_ptr,
drive_ptr->FAT_START_SECTOR + drive_ptr->FAT_CACHE_START + i + (fat * fat_size),
(pointer) &drive_ptr->FAT_CACHE_PTR[drive_ptr->BPB.SECTOR_SIZE*i]);
}
}
if ( error_code == MFS_NO_ERROR )
{
drive_ptr->FAT_CACHE_DIRTY = FALSE;
}
}
return(error_code);
#endif
}
int_32 MFS_Close_Device
(
MQX_FILE_PTR fd_ptr /* [IN] the MFS file handle for the device being closed */
)
{
MFS_DRIVE_STRUCT_PTR drive_ptr;
FILESYSTEM_INFO_DISK_PTR fsinfo_ptr;
int_32 result = MFS_NO_ERROR;
#if !MFSCFG_READ_ONLY
#if MFSCFG_READ_ONLY_CHECK
if (MFS_is_read_only (fd_ptr, NULL))
{
result = MFS_DISK_IS_WRITE_PROTECTED;
}
#endif
if (result != MFS_DISK_IS_WRITE_PROTECTED)
{
result = _io_ioctl(fd_ptr, IO_IOCTL_FLUSH_OUTPUT, NULL);
}
#endif
MFS_lock(fd_ptr, &drive_ptr);
#if !MFSCFG_READ_ONLY
if (result != MFS_DISK_IS_WRITE_PROTECTED)
{
MFS_Flush_caches(drive_ptr);
}
#endif
if ( _queue_is_empty(&drive_ptr->HANDLE_LIST) )
{
if ( drive_ptr->FAT_TYPE == MFS_FAT32 )
{
#if !MFSCFG_READ_ONLY
if (result != MFS_DISK_IS_WRITE_PROTECTED)
{
fsinfo_ptr = (FILESYSTEM_INFO_DISK_PTR)drive_ptr->DATA_SECTOR_PTR;
if ( fsinfo_ptr != NULL )
{
htodl(fsinfo_ptr->LEAD_SIG, FSI_LEADSIG);
htodl(fsinfo_ptr->STRUCT_SIG, FSI_STRUCTSIG);
htodl(fsinfo_ptr->FREE_COUNT, drive_ptr->FREE_COUNT);
htodl(fsinfo_ptr->NEXT_FREE, drive_ptr->NEXT_FREE_CLUSTER);
htodl(fsinfo_ptr->TRAIL_SIG, FSI_TRAILSIG);
MFS_Write_device_sector(drive_ptr, FSINFO_SECTOR, (char_ptr)fsinfo_ptr);
}
}
#endif
}
MFS_free_drive_data(drive_ptr, TRUE);
drive_ptr->MFS_FILE_PTR = NULL;
result = MFS_NO_ERROR;
}
else
{
/* liutest add for get unclose handle */
MFS_HANDLE_PTR next_handle;
next_handle = (MFS_HANDLE_PTR) _queue_head(&drive_ptr->HANDLE_LIST);
while ( next_handle )
{
printf("unclose handle 0x%X\n",(uint_32)next_handle);
next_handle = (MFS_HANDLE_PTR) _queue_next(&drive_ptr->HANDLE_LIST, (QUEUE_ELEMENT_STRUCT_PTR) next_handle);
}
result = MFS_SHARING_VIOLATION;
/* MFS_free_drive_data(drive_ptr, TRUE);
drive_ptr->MFS_FILE_PTR = NULL;
result = MFS_NO_ERROR;*/
}
MFS_unlock(drive_ptr,FALSE);
return result;
}
