/***************************************************************************/ /* Copyright (c) 2024 Microsoft Corporation */ /* Copyright (c) 2026 Eclipse ThreadX contributors */ /* */ /* This program and the accompanying materials are made available under */ /* the terms of the MIT License which is available at */ /* https://opensource.org/licenses/MIT. */ /* */ /* SPDX-License-Identifier: MIT */ /***************************************************************************/ /* This FileX test concentrates on the basic media check operation. */ #ifndef FX_STANDALONE_ENABLE #include "tx_api.h" #endif #include "fx_api.h" #include "fx_utility.h" #include "fx_ram_driver_test.h" #include #define DEMO_STACK_SIZE 4096 #define CACHE_SIZE 16*128 #define SCRATCH_MEMORY_SIZE 11000 /* Define the ThreadX and FileX object control blocks... */ #ifndef FX_STANDALONE_ENABLE static TX_THREAD ftest_0; #endif static FX_MEDIA ram_disk; static FX_FILE my_file; static UCHAR raw_sector_buffer[512]; static UCHAR raw_sector_buffer_check[512]; /* Define the counters used in the test application... */ #ifndef FX_STANDALONE_ENABLE static UCHAR *ram_disk_memory; static UCHAR *cache_buffer; static UCHAR *scratch_memory; #else static UCHAR cache_buffer[CACHE_SIZE]; static UCHAR scratch_memory[SCRATCH_MEMORY_SIZE]; #endif /* Define thread prototypes. */ void filex_media_check_application_define(void *first_unused_memory); static void ftest_0_entry(ULONG thread_input); VOID _fx_ram_driver(FX_MEDIA *media_ptr); void test_control_return(UINT status); /* Define what the initial system looks like. */ #ifdef CTEST void test_application_define(void *first_unused_memory) #else void filex_media_check_application_define(void *first_unused_memory) #endif { #ifndef FX_STANDALONE_ENABLE UCHAR *pointer; /* Setup the working pointer. */ pointer = (UCHAR *) first_unused_memory; /* Create the main thread. */ tx_thread_create(&ftest_0, "thread 0", ftest_0_entry, 0, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START); pointer = pointer + DEMO_STACK_SIZE; /* Setup memory for the RAM disk and the sector cache. */ cache_buffer = pointer; pointer = pointer + CACHE_SIZE; ram_disk_memory = pointer; pointer = pointer + (256*128); scratch_memory = pointer; #endif /* Initialize the FileX system. */ fx_system_initialize(); #ifdef FX_STANDALONE_ENABLE ftest_0_entry(0); #endif } /* Define the test threads. */ static void ftest_0_entry(ULONG thread_input) { UINT status; ULONG errors_detected; UINT i, j; // A file name whose first byte is 0xe5. UCHAR specified_ascii_name[] = { 0xe5, 'a', 'b', 'c', 0}; FX_PARAMETER_NOT_USED(thread_input); /* Print out some test information banners. */ printf("FileX Test: Media check test......................................."); /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 256, // Total sectors 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Try to check the media before the media has been opened */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); return_if_fail( status == FX_MEDIA_NOT_OPEN); /* Open the ram_disk. */ status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); return_if_fail( status == FX_SUCCESS); /* Only run this if error checking is enabled */ #ifndef FX_DISABLE_ERROR_CHECKING /* send null pointer to generate an error */ status = fx_media_check(FX_NULL, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); return_if_fail( status == FX_PTR_ERROR); #endif /* FX_DISABLE_ERROR_CHECKING */ /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); return_if_fail( (status == FX_SUCCESS) && (errors_detected == 0)); /* Close the media and reopen. */ status = fx_media_close(&ram_disk); status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); return_if_fail( status == FX_SUCCESS); /* Invalidate the cache. */ status = fx_media_cache_invalidate(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); /* Check the status. */ return_if_fail((status == FX_SUCCESS) && (raw_sector_buffer[0] == 0xF8) && /* _fx_media_format_media_type value set during media format */ (raw_sector_buffer[1] == 0xFF) && (raw_sector_buffer[2] == 0xFF)); /* Change the FAT table to introduce lost clusters! */ raw_sector_buffer[30] = 2; raw_sector_buffer[31] = 3; raw_sector_buffer[32] = 4; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Attempt to check the media but give it a bad scratch_memory_size to throw an error */ status = fx_media_check(&ram_disk, scratch_memory, 0, 0, &errors_detected); return_if_fail( status == FX_NOT_ENOUGH_MEMORY); /* Attempt to check the media but give it a bad scratch_memory_size to throw an error */ status = fx_media_check(&ram_disk, scratch_memory, (ram_disk.fx_media_total_clusters / 8), 0, &errors_detected); return_if_fail( status == FX_NOT_ENOUGH_MEMORY); /* Attempt to check the media but give it another bad scratch_memory_size to throw an error */ status = fx_media_check(&ram_disk, scratch_memory, 977, 0, &errors_detected); return_if_fail( status == FX_NOT_ENOUGH_MEMORY); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); return_if_fail( (status == FX_SUCCESS) && (errors_detected == FX_LOST_CLUSTER_ERROR)); /* Check the media for errors again, but correct them this time! */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, FX_LOST_CLUSTER_ERROR, &errors_detected); return_if_fail( (status == FX_SUCCESS) && (errors_detected == FX_LOST_CLUSTER_ERROR)); /* Check the media for errors again, but this time it should be successful. */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, FX_LOST_CLUSTER_ERROR, &errors_detected); /* Determine if any were found - should not have found any errors at this point. */ return_if_fail( (status == FX_SUCCESS) && (errors_detected == 0)); /* Close the media. */ status = fx_media_close(&ram_disk); status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); return_if_fail( status == FX_SUCCESS); /* Create a file in the root directory. */ status = fx_file_create(&ram_disk, "TEXT.TXT"); // Create the file whose name's first byte is 0xe5. status += fx_file_create(&ram_disk, (CHAR *)specified_ascii_name); status += fx_file_create(&ram_disk, "A somewhat long file name.txt"); status += fx_file_open(&ram_disk, &my_file, "TEXT.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, raw_sector_buffer, 128); status += fx_file_write(&my_file, raw_sector_buffer, 128); status += fx_file_write(&my_file, raw_sector_buffer, 128); status += fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); /* try to check the media while a file is open */ status += fx_file_close(&my_file); status += fx_media_close(&ram_disk); status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); /* Loop to clear the raw sector buffer... */ for (i = 0; i < sizeof(raw_sector_buffer); i++) { raw_sector_buffer[i] = 0; } /* Setup original FAT table to break the File's cluster! */ raw_sector_buffer[0] = 0x0F; raw_sector_buffer[1] = 0x0f; raw_sector_buffer[2] = 0xFF; /* Write the FAT sector back... with the errors. */ status += fx_media_write(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_ACCESS_ERROR); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); /* Determine if any were found - should not have found any errors at this point. */ return_if_fail( (status == FX_SUCCESS) && (errors_detected == (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR))); /* Check the media for errors... and correct them this time! */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR), &errors_detected); /* Determine if any were found - should not have found any errors at this point. */ return_if_fail( (status == FX_SUCCESS) && (errors_detected == (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR))); /* Check the media for errors... there should be none this time! */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR), &errors_detected); /* Determine if any were found - should not have found any errors at this point. */ return_if_fail( (status == FX_SUCCESS) && (errors_detected == 0)); /* Close the media. */ status = fx_media_close(&ram_disk); status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "TEXT.TXT"); status += fx_file_open(&ram_disk, &my_file, "TEXT.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, raw_sector_buffer, 128); status += fx_file_write(&my_file, raw_sector_buffer, 128); status += fx_file_write(&my_file, raw_sector_buffer, 128); status += fx_file_close(&my_file); status += fx_media_close(&ram_disk); status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the size to 1 to generate a file size error. */ raw_sector_buffer[0x1C] = 1; raw_sector_buffer[0x1D] = 0; raw_sector_buffer[0x1E] = 0; raw_sector_buffer[0x1F] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); /* Determine if any were found - should not have found any errors at this point. */ return_if_fail( (status == FX_SUCCESS) && (errors_detected == FX_FILE_SIZE_ERROR)); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 256, // Total sectors 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_directory_create(&ram_disk, "\\SUB1"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB1F1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB1F2.TXT"); status += fx_media_flush(&ram_disk); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB2\\SUB2F1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB2\\SUB2F2.TXT"); return_if_fail( status == FX_SUCCESS); /* Write data to the files... */ status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOT1_CONTENTS", 14); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOT2_CONTENTS", 14); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB1F1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB1F1_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB1F2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB1F2_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB2\\SUB2F1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB2F1_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB2\\SUB2F2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB2F2_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, 0, &errors_detected); return_if_fail( status == FX_SUCCESS); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_directory_create(&ram_disk, "\\SUB1"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB1F1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB1F2.TXT"); status += fx_media_flush(&ram_disk); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB2\\SUB2F1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "\\SUB1\\SUB2\\SUB2F2.TXT"); return_if_fail( status == FX_SUCCESS); /* Write data to the files... */ status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOT1_CONTENTS", 14); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOT2_CONTENTS", 14); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB1F1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB1F1_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB1F2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB1F2_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB2\\SUB2F1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB2F1_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "\\SUB1\\SUB2\\SUB2F2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "SUB2F2_CONTENTS", 15); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, 0, &errors_detected); return_if_fail( status == FX_SUCCESS); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test for two files with the same FAT chain. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT16 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF1_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF2_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF3.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF3_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the second file's FAT chain to the same as the first. */ raw_sector_buffer[0x3A] = raw_sector_buffer[0x1A]; raw_sector_buffer[0x3B] = raw_sector_buffer[0x1B]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the ROOTF1.TXT file. */ raw_sector_buffer[14] = 0; raw_sector_buffer[15] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 4000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail((status == FX_SUCCESS) && (errors_detected == (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR))); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test I/O errors in the two files with the same FAT chain test.... */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Loop to run through multiple tests... */ for (i = 0; i < 1000; i++) { /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT16 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 128 /*CACHE_SIZE*/); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF1_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF2_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF3.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF3_CONTENTS", 130); status += fx_file_close(&my_file); /* Create some more files and sub-directories to give the media check some more work to do. */ status += fx_file_create(&ram_disk, "ROOTF4.TXT"); status += fx_file_create(&ram_disk, "ROOTF5.TXT"); status += fx_file_create(&ram_disk, "ROOTF6.TXT"); status += fx_file_create(&ram_disk, "ROOTF7.TXT"); status += fx_file_create(&ram_disk, "ROOTF8.TXT"); status += fx_file_create(&ram_disk, "ROOTF9.TXT"); status += fx_file_create(&ram_disk, "ROOTF10.TXT"); status += fx_file_create(&ram_disk, "ROOTF11.TXT"); status += fx_file_create(&ram_disk, "ROOTF12.TXT"); status += fx_file_create(&ram_disk, "ROOTF13.TXT"); status += fx_file_create(&ram_disk, "ROOTF14.TXT"); status += fx_file_create(&ram_disk, "ROOTF15.TXT"); status += fx_file_create(&ram_disk, "ROOTF16.TXT"); status += fx_file_create(&ram_disk, "ROOTF17.TXT"); status += fx_file_create(&ram_disk, "ROOTF18.TXT"); status += fx_file_create(&ram_disk, "ROOTF19.TXT"); status += fx_file_create(&ram_disk, "ROOTF20.TXT"); status += fx_directory_create(&ram_disk, "SUB4"); status += fx_directory_create(&ram_disk, "SUB5"); status += fx_directory_create(&ram_disk, "SUB6"); status += fx_directory_create(&ram_disk, "SUB7"); status += fx_directory_create(&ram_disk, "SUB8"); status += fx_directory_create(&ram_disk, "SUB9"); status += fx_directory_create(&ram_disk, "SUB10"); status += fx_directory_create(&ram_disk, "SUB11"); status += fx_directory_create(&ram_disk, "SUB12"); status += fx_directory_create(&ram_disk, "SUB13"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF14.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF15.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF16.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF17.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF18.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF19.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF20.TXT"); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the second file's FAT chain starting cluster to the same as the first. */ raw_sector_buffer[0x3A] = raw_sector_buffer[0x1A]; raw_sector_buffer[0x3B] = raw_sector_buffer[0x1B]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the ROOTF3.TXT file. */ if (i & 1) { /* Break with bad FAT value. */ raw_sector_buffer[14] = 0; raw_sector_buffer[15] = 0; } else { /* Break with reserved fAT value. */ raw_sector_buffer[14] = 0xF0; raw_sector_buffer[15] = 0xFF; } /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Create I/O errors via the RAM driver interface. */ _fx_utility_FAT_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 1, 60000, FX_TRUE); j = (UINT)(rand() % 20); if (j == 0) j = 1; _fx_ram_driver_io_error_request = j; /* Check the media for errors. */ fx_media_check(&ram_disk, scratch_memory, 4000, (((ULONG) i) % 16), &errors_detected); /* Clear the error generation flags. */ _fx_ram_driver_io_error_request = 0; /* Abort the media. */ fx_media_abort(&ram_disk); } /* FAT32 I/O error check. */ /* Loop to run through multiple tests... */ for (i = 0; i < 1000; i++) { /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 128 /*CACHE_SIZE*/); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF1_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF2_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF3.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF3_CONTENTS", 130); status += fx_file_close(&my_file); /* Create some more files and sub-directories to give the media check some more work to do. */ status += fx_file_create(&ram_disk, "ROOTF4.TXT"); status += fx_file_create(&ram_disk, "ROOTF5.TXT"); status += fx_file_create(&ram_disk, "ROOTF6.TXT"); status += fx_file_create(&ram_disk, "ROOTF7.TXT"); status += fx_file_create(&ram_disk, "ROOTF8.TXT"); status += fx_file_create(&ram_disk, "ROOTF9.TXT"); status += fx_file_create(&ram_disk, "ROOTF10.TXT"); status += fx_file_create(&ram_disk, "ROOTF11.TXT"); status += fx_file_create(&ram_disk, "ROOTF12.TXT"); status += fx_file_create(&ram_disk, "ROOTF13.TXT"); status += fx_file_create(&ram_disk, "ROOTF14.TXT"); status += fx_file_create(&ram_disk, "ROOTF15.TXT"); status += fx_file_create(&ram_disk, "ROOTF16.TXT"); status += fx_file_create(&ram_disk, "ROOTF17.TXT"); status += fx_file_create(&ram_disk, "ROOTF18.TXT"); status += fx_file_create(&ram_disk, "ROOTF19.TXT"); status += fx_file_create(&ram_disk, "ROOTF20.TXT"); status += fx_directory_create(&ram_disk, "SUB4"); status += fx_directory_create(&ram_disk, "SUB5"); status += fx_directory_create(&ram_disk, "SUB6"); status += fx_directory_create(&ram_disk, "SUB7"); status += fx_directory_create(&ram_disk, "SUB8"); status += fx_directory_create(&ram_disk, "SUB9"); status += fx_directory_create(&ram_disk, "SUB10"); status += fx_directory_create(&ram_disk, "SUB11"); status += fx_directory_create(&ram_disk, "SUB12"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF14.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF15.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF16.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF17.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF18.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF19.TXT"); status += fx_file_create(&ram_disk, "\\SUB4\\ROOTF20.TXT"); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the second file's FAT chain starting cluster to the same as the first. */ raw_sector_buffer[0x3A] = raw_sector_buffer[0x1A]; raw_sector_buffer[0x3B] = raw_sector_buffer[0x1B]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the ROOTF3.TXT file. */ if (i & 1) { /* Break with NULL FAT value. */ raw_sector_buffer[32] = 0; raw_sector_buffer[33] = 0; raw_sector_buffer[34] = 0; raw_sector_buffer[35] = 0; } else { /* Break with Reserved FAT value. */ raw_sector_buffer[32] = 0xF0; raw_sector_buffer[33] = 0xFF; raw_sector_buffer[34] = 0xFF; raw_sector_buffer[35] = 0xFF; } /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Create I/O errors via the RAM driver interface. */ _fx_utility_FAT_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 1, 60000, FX_TRUE); j = (UINT)(rand() % 10); if (j == 0) j = 1; _fx_ram_driver_io_error_request = j; /* Check the media for errors. */ fx_media_check(&ram_disk, scratch_memory, 4000, (((ULONG) i) % 16), &errors_detected); /* Clear the error generation flags. */ _fx_ram_driver_io_error_request = 0; /* Abort the media. */ fx_media_abort(&ram_disk); } /* FAT32 Test for two files with the same FAT chain. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track /* Determine if the format had an error. */ if (status) { printf("ERROR!\n"); test_control_return(33); } /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF1_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF2_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF3.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF3_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the second file's FAT chain to the same as the first. */ raw_sector_buffer[0x3A] = raw_sector_buffer[0x1A]; raw_sector_buffer[0x3B] = raw_sector_buffer[0x1B]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the ROOTF3.TXT file. */ raw_sector_buffer[32] = 0; raw_sector_buffer[33] = 0; raw_sector_buffer[34] = 0; raw_sector_buffer[35] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); /* Determine if any were found - should not have found any errors at this point. */ return_if_fail((status == FX_SUCCESS) && (errors_detected == (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR))); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* FAT32 Test for two files with the same FAT chain and a broken root directory FAT chain. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF1_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF2_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF3.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF3_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the second file's FAT chain to the same as the first. */ raw_sector_buffer[0x3A] = raw_sector_buffer[0x1A]; raw_sector_buffer[0x3B] = raw_sector_buffer[0x1B]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the root directory in FAT32. */ raw_sector_buffer[8] = 0; raw_sector_buffer[9] = 0; raw_sector_buffer[10] = 0; raw_sector_buffer[11] = 0; /* Break the FAT chain of the ROOTF3.TXT file. */ raw_sector_buffer[32] = 0; raw_sector_buffer[33] = 0; raw_sector_buffer[34] = 0; raw_sector_buffer[35] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_ERROR_NOT_FIXED); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test a full disk with a maximum cluster FAT chain. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); do { status = fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); } while (status == FX_SUCCESS); /* Determine if the write had anything other than a no more space error. */ return_if_fail( status == FX_NO_MORE_SPACE); status = fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Reduce the amount of clusters just to exercise the branch in the FAT chain search. */ ram_disk.fx_media_total_clusters = ram_disk.fx_media_total_clusters - 4; /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); /* Undo the cluster adjustment. */ ram_disk.fx_media_total_clusters = ram_disk.fx_media_total_clusters + 4; return_if_fail( status == FX_SUCCESS); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test sub-directory corruption problems. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT16 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a deep directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_directory_create(&ram_disk, "\\DIR1"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB1"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB2"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB3"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB4"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB5"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB6"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB7"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB8"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB9"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB10"); status += fx_file_create(&ram_disk, "\\DIR1\\SUB11"); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the in the first sub directory. */ raw_sector_buffer[10] = 0; raw_sector_buffer[11] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 4000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); /* Determine if any were found - should not have found any errors at this point. */ return_if_fail((status == FX_SUCCESS) && (errors_detected == FX_FAT_CHAIN_ERROR)); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* FAT32 Test for root directory FAT chain recovery. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF4.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF5.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF6.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF7.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF8.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF9.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF10.TXT"); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the root directory in FAT32. */ raw_sector_buffer[12] = 0; raw_sector_buffer[13] = 0; raw_sector_buffer[14] = 0; raw_sector_buffer[15] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); #if 0 return_if_fail( status == FX_SECTOR_INVALID); #else return_if_fail( status == FX_SUCCESS); #endif /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test a full disk with a FAT chain that has a bad pointer to itself. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); do { status = fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); } while (status == FX_SUCCESS); /* Determine if the write had anything other than a no more space error. */ return_if_fail( status == FX_NO_MORE_SPACE); status = fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Make the FAT chain recursive. */ raw_sector_buffer[6] = raw_sector_buffer[4]; raw_sector_buffer[7] = raw_sector_buffer[5]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Check the media for errors. */ status += fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_SUCCESS); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test a full disk with a sub-directory that has a bad FAT chain. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_directory_create(&ram_disk, "SUB1"); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Make the FAT chain recursive. */ raw_sector_buffer[4] = 0; raw_sector_buffer[5] = 0; /* Write the FAT sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Check the media for errors. */ status += fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_SUCCESS); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test sub-directory depth that exceeds FX_MAX_DIRECTORY_NESTING (which is by default 20). */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_directory_create(&ram_disk, "\\SUB1"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14\\SUB15"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14\\SUB15\\SUB16"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14\\SUB15\\SUB16\\SUB17"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14\\SUB15\\SUB16\\SUB17\\SUB18"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14\\SUB15\\SUB16\\SUB17\\SUB18\\SUB19"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14\\SUB15\\SUB16\\SUB17\\SUB18\\SUB19\\SUB20"); status += fx_directory_create(&ram_disk, "\\SUB1\\SUB2\\SUB3\\SUB4\\SUB5\\SUB6\\SUB7\\SUB8\\SUB9\\SUB10\\SUB11\\SUB12\\SUB13\\SUB14\\SUB15\\SUB16\\SUB17\\SUB18\\SUB19\\SUB20\\SUB21"); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_NOT_ENOUGH_MEMORY); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test a full disk with a sub-directory that has a bad FAT chain, but without directory correction selected. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_directory_create(&ram_disk, "SUB1"); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Make the FAT chain recursive. */ raw_sector_buffer[4] = 0; raw_sector_buffer[5] = 0; /* Write the FAT sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Check the media for errors. */ status += fx_media_check(&ram_disk, scratch_memory, 11000, (FX_FAT_CHAIN_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_SUCCESS); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* FAT32 Test for sixteen files with a broken root directory FAT chain. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF4.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF5.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF6.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF7.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF8.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF9.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF10.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF11.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF12.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF13.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF14.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF15.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF16.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF1_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF2_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF3.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF3_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the second file's FAT chain to the same as the first. */ raw_sector_buffer[0x3A] = raw_sector_buffer[0x1A]; raw_sector_buffer[0x3B] = raw_sector_buffer[0x1B]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the root directory in FAT32. */ raw_sector_buffer[12] = 0; raw_sector_buffer[13] = 0; raw_sector_buffer[14] = 0; raw_sector_buffer[15] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_ERROR_NOT_FIXED); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); #ifndef FX_DISABLE_ERROR_CHECKING /* Test NULL media pointer error checking. */ status = fx_media_check(FX_NULL, scratch_memory, 11000, (FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_PTR_ERROR); /* Test NULL media pointer error checking. */ status = fx_media_check(&ram_disk, FX_NULL, 11000, (FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_PTR_ERROR); #endif //FX_DISABLE_ERROR_CHECKING /* FAT32 Test for sixteen files with a broken root directory FAT chain and 512 byte sectors. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 512, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Setup a new, more complicated directory structure. */ status += fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); status += fx_file_create(&ram_disk, "ROOTF1.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF2.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF3.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF4.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF5.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF6.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF7.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF8.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF9.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF10.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF11.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF12.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF13.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF14.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF15.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF16.TXT"); status += fx_media_flush(&ram_disk); status += fx_file_create(&ram_disk, "ROOTF17.TXT"); /* Ensure the root directory exceeds the 512 byte sector size and thus has a cluster chain! */ status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF1.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF1_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF2.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF2_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); status += fx_file_open(&ram_disk, &my_file, "ROOTF3.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, "ROOTF3_CONTENTS", 130); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Read the root directory's first sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); /* Set the second file's FAT chain to the same as the first. */ raw_sector_buffer[0x3A] = raw_sector_buffer[0x1A]; raw_sector_buffer[0x3B] = raw_sector_buffer[0x1B]; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_root_sector_start, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status += fx_media_read(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); /* Break the FAT chain of the root directory in FAT32. */ raw_sector_buffer[12] = 0; raw_sector_buffer[13] = 0; raw_sector_buffer[14] = 0; raw_sector_buffer[15] = 0; /* Write the root directory sector back... with the errors. */ status += fx_media_write(&ram_disk, ram_disk.fx_media_reserved_sectors, (VOID *) raw_sector_buffer); status += fx_media_flush(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Check the media for errors. */ status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_ERROR_NOT_FIXED); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); #ifndef FX_DISABLE_ERROR_CHECKING /* Test NULL media pointer error checking. */ status = fx_media_check(FX_NULL, scratch_memory, 11000, (FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_PTR_ERROR); /* Test NULL media pointer error checking. */ status = fx_media_check(&ram_disk, FX_NULL, 11000, (FX_DIRECTORY_ERROR | FX_LOST_CLUSTER_ERROR), &errors_detected); return_if_fail( status == FX_PTR_ERROR); #endif //FX_DISABLE_ERROR_CHECKING /* FAT32 Test for formatting with I/O errors. */ /* Clear the initial part of the RAM disk memory. */ for (i = 0; i < 4096; i++) { ram_disk_memory[i] = 0; } for (i = 0; i < 4000; i++) { /* Create I/O errors via the RAM driver interface. */ _fx_utility_FAT_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 1, 60000, FX_TRUE); j = (UINT)(rand() % 10); if (j == 0) j = 1; _fx_ram_driver_io_error_request = j; /* Format the media. This needs to be done before opening it! */ fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MYDISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 512, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track _fx_utility_FAT_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 1, 60000, FX_TRUE); j = (UINT)(rand() % 10); if (j == 0) j = 1; _fx_ram_driver_io_error_request = j; /* Open media with errors. */ fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 512); _fx_utility_FAT_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 1, 60000, FX_TRUE); j = (UINT)(rand() % 10); if (j == 0) j = 1; _fx_ram_driver_io_error_request = j; /* Attempt to close media with errors. */ fx_media_close(&ram_disk); _fx_utility_FAT_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 1, 60000, FX_TRUE); j = (UINT)(rand() % 10); if (j == 0) j = 1; _fx_ram_driver_io_error_request = j; /* Attempt to abort media with errors. */ fx_media_abort(&ram_disk); _fx_ram_driver_io_error_request = 0; } /* Test I/O errors in _fx_media_check_lost_cluster_check. */ /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Open the ram_disk. */ status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 128); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 2, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Change the FAT table to introduce lost clusters! */ raw_sector_buffer[30] = 2; raw_sector_buffer[31] = 3; raw_sector_buffer[32] = 4; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 2, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 3, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Change the FAT table to introduce lost clusters! */ raw_sector_buffer[30] = 5; raw_sector_buffer[31] = 6; raw_sector_buffer[32] = 7; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 3, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 4, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Change the FAT table to introduce lost clusters! */ raw_sector_buffer[30] = 8; raw_sector_buffer[31] = 9; raw_sector_buffer[32] = 10; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 4, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Flush and invalidate the cache. */ _fx_utility_logical_sector_flush(&ram_disk, 0, 4000, FX_TRUE); /* Force media errors. */ _fx_utility_fat_entry_read_error_request = 1; status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, FX_LOST_CLUSTER_ERROR, &errors_detected); _fx_utility_fat_entry_read_error_request = 1000; fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, FX_LOST_CLUSTER_ERROR, &errors_detected); _fx_utility_fat_entry_read_error_request = 0; return_if_fail( status == FX_IO_ERROR); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 6000, // Total sectors 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Open the ram_disk. */ status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 128); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 2, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Change the FAT table to introduce lost clusters! */ raw_sector_buffer[30] = 2; raw_sector_buffer[31] = 3; raw_sector_buffer[32] = 4; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 2, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 3, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Change the FAT table to introduce lost clusters! */ raw_sector_buffer[30] = 5; raw_sector_buffer[31] = 6; raw_sector_buffer[32] = 7; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 3, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 4, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Change the FAT table to introduce lost clusters! */ raw_sector_buffer[30] = 8; raw_sector_buffer[31] = 9; raw_sector_buffer[32] = 10; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 4, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Flush and invalidate the cache. */ _fx_utility_logical_sector_flush(&ram_disk, 0, 4000, FX_TRUE); /* Check the media for errors. */ _fx_utility_fat_entry_write_error_request = 1; status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, FX_LOST_CLUSTER_ERROR, &errors_detected); _fx_utility_fat_entry_write_error_request = 10000; fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, FX_LOST_CLUSTER_ERROR, &errors_detected); _fx_utility_fat_entry_write_error_request = 0; return_if_fail( status == FX_IO_ERROR); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test the error paths in FAT32 root directory traversal. */ /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Open the ram_disk. */ status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 128); return_if_fail( status == FX_SUCCESS); /* Now create a series to sub-directories to expand the root directory FAT chain. */ status = fx_file_create(&ram_disk, "FILE1"); status += fx_file_create(&ram_disk, "FILE2"); status += fx_file_create(&ram_disk, "FILE3"); status += fx_file_create(&ram_disk, "FILE4"); status += fx_file_create(&ram_disk, "FILE5"); status += fx_file_create(&ram_disk, "FILE6"); status += fx_file_create(&ram_disk, "FILE7"); status += fx_file_create(&ram_disk, "FILE8"); status += fx_file_create(&ram_disk, "FILE9"); status += fx_file_create(&ram_disk, "FILE10"); status += fx_file_create(&ram_disk, "FILE11"); status += fx_file_create(&ram_disk, "FILE12"); status += fx_file_create(&ram_disk, "FILE13"); status += fx_file_create(&ram_disk, "FILE14"); status += fx_file_create(&ram_disk, "FILE15"); status += fx_file_create(&ram_disk, "FILE16"); status += fx_file_create(&ram_disk, "FILE17"); status += fx_file_create(&ram_disk, "FILE18"); status += fx_file_create(&ram_disk, "FILE19"); status += fx_file_create(&ram_disk, "FILE20"); status += fx_file_create(&ram_disk, "FILE21"); status += fx_file_create(&ram_disk, "FILE22"); status += fx_file_create(&ram_disk, "FILE23"); status += fx_file_create(&ram_disk, "FILE24"); status += fx_file_create(&ram_disk, "FILE25"); status += fx_file_create(&ram_disk, "FILE26"); status += fx_file_create(&ram_disk, "FILE27"); status += fx_file_create(&ram_disk, "FILE28"); status += fx_file_create(&ram_disk, "FILE29"); status += fx_file_create(&ram_disk, "FILE30"); status += fx_file_create(&ram_disk, "FILE31"); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Break the FAT chain of the root directory! */ raw_sector_buffer[36] = 0; raw_sector_buffer[37] = 0; raw_sector_buffer[38] = 0; raw_sector_buffer[39] = 0; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Flush and invalidate the cache. */ fx_media_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 0, 4000, FX_TRUE); /* Check the media for errors. */ _fx_utility_fat_entry_read_error_request = 1; status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_LOST_CLUSTER_ERROR | FX_DIRECTORY_ERROR | FX_FAT_CHAIN_ERROR), &errors_detected); _fx_utility_fat_entry_read_error_request = 0; return_if_fail( status == FX_IO_ERROR); /* Check the media for errors. */ _fx_utility_fat_entry_write_error_request = 1; status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_LOST_CLUSTER_ERROR | FX_DIRECTORY_ERROR | FX_FAT_CHAIN_ERROR), &errors_detected); _fx_utility_fat_entry_write_error_request = 0; return_if_fail( status == FX_IO_ERROR); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test the error paths in file FAT traversal. */ /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Open the ram_disk. */ status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 128); return_if_fail( status == FX_SUCCESS); /* Now create a series to sub-directories to expand the root directory FAT chain. */ status = fx_file_create(&ram_disk, "FILE1"); /* Flush and invalidate the cache. */ fx_media_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 0, 4000, FX_TRUE); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Open the file. */ status += fx_file_open(&ram_disk, &my_file, "FILE1", FX_OPEN_FOR_WRITE); /* Write to the file. */ status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_write(&my_file, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26); status += fx_file_close(&my_file); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Break the FAT chain of the root directory! */ raw_sector_buffer[36] = 0; raw_sector_buffer[37] = 0; raw_sector_buffer[38] = 0; raw_sector_buffer[39] = 0; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Flush and invalidate the cache. */ fx_media_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 0, 4000, FX_TRUE); /* Check the media for errors. */ _fx_utility_fat_entry_write_error_request = 1; status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_LOST_CLUSTER_ERROR | FX_DIRECTORY_ERROR | FX_FAT_CHAIN_ERROR), &errors_detected); _fx_utility_fat_entry_write_error_request = 0; return_if_fail( status == FX_IO_ERROR); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Test the error paths in sub-directory delete path. */ /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 70000, // Total sectors - FAT32 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Open the ram_disk. */ status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, 128); return_if_fail( status == FX_SUCCESS); /* Now create a sub-directory. */ status = fx_directory_create(&ram_disk, "SUB1"); /* Flush and invalidate the cache. */ fx_media_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 0, 4000, FX_TRUE); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Open the file. */ status += fx_file_open(&ram_disk, &my_file, "FILE1", FX_OPEN_FOR_WRITE); status += fx_media_flush(&ram_disk); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Break the FAT chain of the sub-directory! */ raw_sector_buffer[12] = 0; raw_sector_buffer[13] = 0; raw_sector_buffer[14] = 0; raw_sector_buffer[15] = 0; /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Flush and invalidate the cache. */ fx_media_flush(&ram_disk); _fx_utility_logical_sector_flush(&ram_disk, 0, 4000, FX_TRUE); /* Check the media for errors. */ _fx_ram_driver_io_error_request = 4; status = fx_media_check(&ram_disk, scratch_memory, 11000, (FX_LOST_CLUSTER_ERROR | FX_DIRECTORY_ERROR | FX_FAT_CHAIN_ERROR), &errors_detected); _fx_ram_driver_io_error_request = 0; return_if_fail( status == FX_IO_ERROR); /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); /* Format the media. This needs to be done before opening it! */ status = fx_media_format(&ram_disk, _fx_ram_driver, // Driver entry ram_disk_memory, // RAM disk memory pointer cache_buffer, // Media buffer pointer CACHE_SIZE, // Media buffer size "MY_RAM_DISK", // Volume Name 1, // Number of FATs 32, // Directory Entries 0, // Hidden sectors 256, // Total sectors 128, // Sector size 1, // Sectors per cluster 1, // Heads 1); // Sectors per track return_if_fail( status == FX_SUCCESS); /* Open the ram_disk. */ status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); return_if_fail( status == FX_SUCCESS); /* Create a file in the root directory. */ status = fx_file_create(&ram_disk, "TEXT.TXT"); status += fx_file_open(&ram_disk, &my_file, "TEXT.TXT", FX_OPEN_FOR_WRITE); status += fx_file_write(&my_file, raw_sector_buffer, 128); status += fx_file_close(&my_file); return_if_fail( status == FX_SUCCESS); status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); status = fx_media_open(&ram_disk, "RAM DISK", _fx_ram_driver, ram_disk_memory, cache_buffer, CACHE_SIZE); return_if_fail( status == FX_SUCCESS); /* Read the first FAT sector. */ status = fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Change the FAT table to introduce lost clusters! */ memcpy(raw_sector_buffer_check, raw_sector_buffer, ram_disk.fx_media_bytes_per_sector); raw_sector_buffer[3] = (ram_disk.fx_media_total_clusters + FX_FAT_ENTRY_START) & 0xFF; raw_sector_buffer[4] = (UCHAR)((ram_disk.fx_media_total_clusters + FX_FAT_ENTRY_START) >> 8); /* Write the FAT sector back... with the errors. */ status = fx_media_write(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Attempt to check the media but give it a bad scratch_memory_size to throw an error */ status = fx_media_check(&ram_disk, scratch_memory, SCRATCH_MEMORY_SIZE, FX_FAT_CHAIN_ERROR, &errors_detected); return_if_fail( (status == FX_SUCCESS) && (errors_detected == (FX_FAT_CHAIN_ERROR| FX_DIRECTORY_ERROR| FX_LOST_CLUSTER_ERROR))); #if 0 /* Read the first FAT sector again. */ status = fx_media_read(&ram_disk, 1, (VOID *) raw_sector_buffer); return_if_fail( status == FX_SUCCESS); /* Compare the */ return_if_fail( memcmp(raw_sector_buffer_check, raw_sector_buffer, ram_disk.fx_media_bytes_per_sector) == 0); #endif /* Close the media. */ status = fx_media_close(&ram_disk); return_if_fail( status == FX_SUCCESS); printf("SUCCESS!\n"); test_control_return(0); }