/*
* The test sequence
*/
static
void test( void )
{
rtems_status_code sc;
int rv;
char device_name[] = "/dev/sda1";
uint32_t block_size;
rtems_blkdev_bnum block_number;
rtems_blkdev_bnum blocks_allocated;
int file_descriptor;
uint8_t fill_pattern = 0;
sc = rtems_disk_io_initialize();
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
block_size = 512;
block_number = 4 * 2 * 1024;
blocks_allocated = 8;
sc = rtems_sparse_disk_create_and_register(
"/dev/sda1",
block_size,
blocks_allocated,
block_number,
fill_pattern
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
/* Test reading and writing with sector size 512 and 8 such sectors
* allocated. Block size will default to 512 */
test_device_io(
device_name,
block_size,
block_size,
block_number,
blocks_allocated,
fill_pattern
);
file_descriptor = open( device_name, O_RDWR );
rtems_test_assert( 0 <= file_descriptor );
rv = rtems_disk_fd_set_block_size( file_descriptor,
blocks_allocated * block_size );
rtems_test_assert( 0 == rv );
rv = close( file_descriptor );
rtems_test_assert( 0 == rv );
/* Block size was increased to 4k. Thus all to allocated disk space
* corresponds to one block. Repeat the read write tests */
test_device_io(
device_name,
block_size * blocks_allocated,
block_size,
block_number,
1,
fill_pattern
);
rv = unlink( device_name );
rtems_test_assert( 0 == rv );
/* Do testing with a statically allocated disk. This permits white box
* testing */
test_with_whitebox( device_name );
}
static void test( void )
{
rtems_status_code sc;
int rv;
const char dev_name[] = "/dev/rda";
const char mount_dir[] = "/mnt";
msdos_format_request_param_t rqdata;
rtems_blkdev_bnum media_block_count;
memset( &rqdata, 0, sizeof( rqdata ) );
sc = rtems_disk_io_initialize();
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
rv = mkdir( mount_dir, S_IRWXU | S_IRWXG | S_IRWXO );
rtems_test_assert( 0 == rv );
/* FAT12 */
/* For 1.44 MB disks */
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
64,
2880,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
/* Optimized for disk space */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 1;
rqdata.fat_num = 1;
rqdata.files_per_root_dir = 32;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = true;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name, mount_dir, SECTOR_SIZE, SECTOR_SIZE, 1 );
test_file_creation( dev_name, mount_dir, rqdata.files_per_root_dir );
/* Try formatting with invalid values */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 1;
rqdata.fat_num = 7; /* Invalid number of fats */
rqdata.files_per_root_dir = 32;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = true;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv != 0 );
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 1;
rqdata.fat_num = 1;
rqdata.files_per_root_dir = 32;
rqdata.media = 0x11; /* Invalid media code */
rqdata.quick_format = true;
rqdata.skip_alignment = true;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv != 0 );
/* Optimized for read/write speed */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 8;
rqdata.fat_num = 0;
rqdata.files_per_root_dir = 0;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = false;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * rqdata.sectors_per_cluster,
rqdata.sectors_per_cluster );
/* The same disk formatted with FAT16 because sectors per cluster is too high
* for FAT12 */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 16;
rqdata.fat_num = 1;
rqdata.files_per_root_dir = 32;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = false;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * rqdata.sectors_per_cluster,
rqdata.sectors_per_cluster );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
/* Largest FAT12 disk */
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
64,
( FAT12_MAX_CLN * FAT12_DEFAULT_SECTORS_PER_CLUSTER ) - 1L,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
/* Default parameters (corresponds to optimization for read/write speed) */
rv = msdos_format( dev_name, NULL );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * FAT12_DEFAULT_SECTORS_PER_CLUSTER,
FAT12_DEFAULT_SECTORS_PER_CLUSTER );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
/* FAT16 */
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
1024,
( FAT12_MAX_CLN * FAT12_DEFAULT_SECTORS_PER_CLUSTER ) + 1L,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
/* Optimized for disk space */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 1;
rqdata.fat_num = 1;
rqdata.files_per_root_dir = 32;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = true;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
rqdata.sectors_per_cluster * SECTOR_SIZE,
rqdata.sectors_per_cluster );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
1024,
( FAT16_MAX_CLN * FAT16_DEFAULT_SECTORS_PER_CLUSTER ) - 1L,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
/* Optimized for read/write speed */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 64;
rqdata.fat_num = 0;
rqdata.files_per_root_dir = 0;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = false;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * rqdata.sectors_per_cluster,
rqdata.sectors_per_cluster );
/* Default parameters (corresponds to optimization for read/write speed) */
rv = msdos_format( dev_name, NULL );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * FAT16_DEFAULT_SECTORS_PER_CLUSTER,
FAT16_DEFAULT_SECTORS_PER_CLUSTER );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
1024,
( FAT16_MAX_CLN + 10 ) * 64,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 64;
rqdata.fat_num = 0;
rqdata.files_per_root_dir = 0;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = false;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * rqdata.sectors_per_cluster,
rqdata.sectors_per_cluster );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
/* Format some disks from 1MB up to 128GB */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 64;
rqdata.fat_num = 0;
rqdata.files_per_root_dir = 0;
rqdata.media = 0;
rqdata.quick_format = true;
rqdata.skip_alignment = false;
for (
media_block_count = 1 * 1024 * ( 1024 / SECTOR_SIZE );
media_block_count <= 128 * 1024 * 1024 * ( 1024 / SECTOR_SIZE );
media_block_count *= 2
) {
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
64,
media_block_count,
0
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params(
dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * rqdata.sectors_per_cluster,
rqdata.sectors_per_cluster
);
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
}
/* FAT32 */
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
1024,
( FAT16_MAX_CLN * FAT16_DEFAULT_SECTORS_PER_CLUSTER ) + 41L,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
/* Default parameters */
rv = msdos_format( dev_name, NULL );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name, mount_dir, SECTOR_SIZE, SECTOR_SIZE, 1 );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
1024,
( FAT16_MAX_CLN + 20 ) * 64L,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
/* Optimized for read/write speed */
rqdata.OEMName = NULL;
rqdata.VolLabel = NULL;
rqdata.sectors_per_cluster = 64;
rqdata.fat_num = 0;
rqdata.files_per_root_dir = 0;
rqdata.media = 0; /* Media code. 0 == Default */
rqdata.quick_format = true;
rqdata.skip_alignment = false;
rv = msdos_format( dev_name, &rqdata );
rtems_test_assert( rv == 0 );
test_disk_params( dev_name,
mount_dir,
SECTOR_SIZE,
SECTOR_SIZE * rqdata.sectors_per_cluster,
rqdata.sectors_per_cluster );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
}
static void test_normal_file_write(
const char *dev_name,
const char *mount_dir,
const char *file_name )
{
static const rtems_blkdev_stats complete_block_stats = {
.read_hits = 0,
.read_misses = 0,
.read_ahead_transfers = 0,
.read_blocks = 0,
.read_errors = 0,
.write_transfers = 1,
.write_blocks = 1,
.write_errors = 0
};
static const rtems_blkdev_stats new_block_stats = {
.read_hits = 8,
.read_misses = 2,
.read_ahead_transfers = 0,
.read_blocks = 2,
.read_errors = 0,
.write_transfers = 1,
.write_blocks = 4,
.write_errors = 0
};
int rv;
int fd;
ssize_t num_bytes;
uint8_t cluster_buf[SECTOR_SIZE
* SECTORS_PER_CLUSTER];
uint32_t cluster_size = sizeof( cluster_buf );
off_t off;
memset( cluster_buf, 0xFE, cluster_size );
format_and_mount( dev_name, mount_dir );
fd = create_file( file_name );
rtems_test_assert( fd >= 0 );
num_bytes = write( fd, cluster_buf, cluster_size );
rtems_test_assert( (ssize_t) cluster_size == num_bytes );
off = lseek( fd, 0, SEEK_SET );
rtems_test_assert( off == 0 );
reset_block_stats( dev_name, mount_dir );
/* Write a complete cluster into an existing file space */
num_bytes = write( fd, cluster_buf, cluster_size );
rtems_test_assert( (ssize_t) cluster_size == num_bytes );
check_block_stats( dev_name, mount_dir, &complete_block_stats );
reset_block_stats( dev_name, mount_dir );
num_bytes = write( fd, cluster_buf, cluster_size );
rtems_test_assert( (ssize_t) cluster_size == num_bytes );
/* Write a new partial cluster into a new file space */
num_bytes = write( fd, cluster_buf, 1 );
rtems_test_assert( num_bytes == 1 );
check_block_stats( dev_name, mount_dir, &new_block_stats );
rv = close( fd );
rtems_test_assert( 0 == rv );
rv = unmount( mount_dir );
rtems_test_assert( 0 == rv );
}
static void test_fat12_root_directory_write( const char *dev_name,
const char *mount_dir,
const char *file_name )
{
static const rtems_blkdev_stats fat12_root_dir_stats = {
.read_hits = 11,
.read_misses = 2,
.read_ahead_transfers = 0,
.read_blocks = 2,
.read_errors = 0,
.write_transfers = 1,
.write_blocks = 1,
.write_errors = 0
};
int fd;
int rv;
format_and_mount( dev_name, mount_dir );
reset_block_stats( dev_name, mount_dir );
fd = create_file( file_name );
rtems_test_assert( fd >= 0 );
rv = close( fd );
rtems_test_assert( rv == 0 );
check_block_stats( dev_name, mount_dir, &fat12_root_dir_stats );
rv = unmount( mount_dir );
rtems_test_assert( rv == 0 );
}
static void test( void )
{
static const char dev_name[] = "/dev/sda";
static const char mount_dir[] = "/mnt";
static const char file_name[] = "/mnt/file.txt";
rtems_status_code sc;
int rv;
sc = rtems_disk_io_initialize();
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
rv = mkdir( mount_dir, S_IRWXU | S_IRWXG | S_IRWXO );
rtems_test_assert( 0 == rv );
/* A 1.44 MB disk */
sc = rtems_sparse_disk_create_and_register(
dev_name,
SECTOR_SIZE,
64,
2880,
0
);
rtems_test_assert( RTEMS_SUCCESSFUL == sc );
test_fat12_root_directory_write( dev_name, mount_dir, file_name );
test_normal_file_write( dev_name, mount_dir, file_name );
rv = unlink( dev_name );
rtems_test_assert( rv == 0 );
}
static void Init( rtems_task_argument arg )
{
TEST_BEGIN();
test();
TEST_END();
rtems_test_exit( 0 );
}
