static void test(void)
{
rtems_status_code sc;
dev_t dev = 0;
rtems_disk_device *dd;
sc = rtems_disk_io_initialize();
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_disk_create_phys(
dev,
1,
BLOCK_COUNT,
test_disk_ioctl,
NULL,
NULL
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
dd = rtems_disk_obtain(dev);
rtems_test_assert(dd != NULL);
test_actions(dd);
sc = rtems_disk_release(dd);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_disk_delete(dev);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: syncing\n");
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
#else
if (fsync (fs->device) < 0)
{
result = errno;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: closing\n");
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rtems_disk_release (fs->disk);
#else
if (close (fs->device) < 0)
{
rc = errno;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
rc, strerror (rc));
}
#endif
return rc;
}
static rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
dev_t dev = 0;
rtems_disk_device *dd = NULL;
printk("\n\n*** TEST BLOCK 9 ***\n");
sc = rtems_disk_io_initialize();
ASSERT_SC(sc);
sc = disk_register(BLOCK_SIZE, BLOCK_COUNT, &dev);
ASSERT_SC(sc);
dd = rtems_disk_obtain(dev);
assert(dd != NULL);
check_read(dd, BLOCK_READ_IO_ERROR, RTEMS_IO_ERROR);
check_read(dd, BLOCK_READ_UNSATISFIED, RTEMS_UNSATISFIED);
check_read(dd, BLOCK_READ_SUCCESSFUL, RTEMS_SUCCESSFUL);
check_read(dd, BLOCK_WRITE_IO_ERROR, RTEMS_SUCCESSFUL);
/* Check write IO error */
sc = rtems_bdbuf_read(dd, BLOCK_WRITE_IO_ERROR, &bd);
ASSERT_SC(sc);
bd->buffer [0] = 1;
sc = rtems_bdbuf_sync(bd);
ASSERT_SC(sc);
sc = rtems_bdbuf_read(dd, BLOCK_WRITE_IO_ERROR, &bd);
ASSERT_SC(sc);
assert(bd->buffer [0] == 0);
sc = rtems_bdbuf_release(bd);
ASSERT_SC(sc);
/* Check write to deleted disk */
sc = rtems_bdbuf_read(dd, BLOCK_READ_SUCCESSFUL, &bd);
ASSERT_SC(sc);
sc = rtems_disk_delete(dev);
ASSERT_SC(sc);
sc = rtems_bdbuf_sync(bd);
ASSERT_SC(sc);
sc = rtems_disk_release(dd);
ASSERT_SC(sc);
printk("*** END OF TEST BLOCK 9 ***\n");
exit(0);
}
static void test_block_io_control_api(dev_t dev, ramdisk *rd)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
const rtems_disk_device *fd_dd = NULL;
int fd = -1;
int rv = -1;
uint32_t value = 0;
rtems_blkdev_bnum block_count = 0;
sc = rtems_disk_create_phys(dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC(sc);
dd = rtems_disk_obtain(dev);
rtems_test_assert(dd != NULL);
fd = open("/dev/rda", O_RDWR);
rtems_test_assert(fd >= 0);
value = 0;
rv = rtems_disk_fd_get_media_block_size(fd, &value);
rtems_test_assert(rv == 0);
rtems_test_assert(value == BLOCK_SIZE);
value = 0;
rv = rtems_disk_fd_get_block_size(fd, &value);
rtems_test_assert(rv == 0);
rtems_test_assert(value == BLOCK_SIZE);
value = 1024;
rv = rtems_disk_fd_set_block_size(fd, value);
rtems_test_assert(rv == 0);
value = 0;
rv = rtems_disk_fd_get_block_size(fd, &value);
rtems_test_assert(rv == 0);
rtems_test_assert(value == 1024);
block_count = 0;
rv = rtems_disk_fd_get_block_count(fd, &block_count);
rtems_test_assert(rv == 0);
rtems_test_assert(block_count == BLOCK_COUNT);
rv = rtems_disk_fd_get_disk_device(fd, &fd_dd);
rtems_test_assert(rv == 0);
rtems_test_assert(fd_dd == dd);
rv = rtems_disk_fd_sync(fd);
rtems_test_assert(rv == 0);
rv = close(fd);
rtems_test_assert(rv == 0);
sc = rtems_disk_release(dd);
ASSERT_SC(sc);
sc = rtems_disk_delete(dev);
ASSERT_SC(sc);
}
/* blkdev_generic_close --
* Generic block device close primitive.
*/
rtems_device_driver
rtems_blkdev_generic_close(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_libio_open_close_args_t *oc = arg;
rtems_libio_t *iop = oc->iop;
rtems_disk_device *dd = iop->data1;
rtems_disk_release(dd);
return RTEMS_SUCCESSFUL;
}
/* fat_shutdown_drive --
* Free all allocated resources and synchronize all necessary data
*
* PARAMETERS:
* mt_entry - mount table entry
*
* RETURNS:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
fs_info->vol.next_cl);
if ( rc != RC_OK )
rc = -1;
}
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
{
Chain_Node *node = NULL;
Chain_Control *the_chain = fs_info->vhash + i;
while ( (node = _Chain_Get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
Chain_Node *node = NULL;
Chain_Control *the_chain = fs_info->rhash + i;
while ( (node = _Chain_Get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
free(fs_info->sec_buf);
rtems_disk_release(fs_info->vol.dd);
if (rc)
errno = EIO;
return rc;
}
static void test_diskdevs(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_disk_device *physical_dd = NULL;
rtems_disk_device *logical_dd = NULL;
rtems_disk_device *dd = NULL;
dev_t physical_dev = 0;
dev_t logical_dev = 0;
dev_t logical_2_dev = 0;
dev_t const big_major_dev = rtems_filesystem_make_dev_t((rtems_device_major_number) -2, 0);
dev_t const big_minor_dev = rtems_filesystem_make_dev_t(0, (rtems_device_minor_number) -2);
ramdisk *const rd = ramdisk_allocate(NULL, BLOCK_SIZE, BLOCK_COUNT, false);
rtems_test_assert(rd != NULL);
sc = rtems_disk_io_initialize();
ASSERT_SC(sc);
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
ASSERT_SC(sc);
physical_dev = rtems_filesystem_make_dev_t(major, minor);
logical_dev = rtems_filesystem_make_dev_t(major, minor + 1);
logical_2_dev = rtems_filesystem_make_dev_t(major, minor + 2);
/* Consistency checks for physical disks creation */
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, NULL, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_INVALID_ADDRESS);
sc = rtems_disk_create_phys(physical_dev, 0, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_phys(big_major_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_phys(big_minor_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL);
ASSERT_SC(sc);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, NULL);
ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
sc = rtems_disk_delete(physical_dev);
ASSERT_SC(sc);
/* Consistency checks for logical disks creation */
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_ID);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC(sc);
sc = rtems_disk_create_log(big_major_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_log(big_minor_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_NO_MEMORY);
sc = rtems_disk_create_log(logical_dev, physical_dev, BLOCK_COUNT, 0, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, BLOCK_COUNT + 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_log(logical_dev, physical_dev, 1, BLOCK_COUNT, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_NUMBER);
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC(sc);
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
sc = rtems_disk_create_log(logical_2_dev, logical_dev, 0, 1, "/dev/rda1");
ASSERT_SC_EQ(sc, RTEMS_INVALID_ID);
sc = rtems_disk_delete(logical_dev);
ASSERT_SC(sc);
/* Consistency checks delete */
sc = rtems_disk_create_log(logical_dev, physical_dev, 0, 1, "/dev/rda1");
ASSERT_SC(sc);
physical_dd = rtems_disk_obtain(physical_dev);
rtems_test_assert(physical_dd != NULL && physical_dd->uses == 2);
sc = rtems_disk_release(physical_dd);
ASSERT_SC(sc);
logical_dd = rtems_disk_obtain(logical_dev);
rtems_test_assert(logical_dd != NULL && logical_dd->uses == 1);
sc = rtems_disk_delete(physical_dev);
ASSERT_SC(sc);
sc = rtems_disk_create_phys(physical_dev, BLOCK_SIZE, BLOCK_COUNT, ramdisk_ioctl, rd, "/dev/rda");
ASSERT_SC_EQ(sc, RTEMS_RESOURCE_IN_USE);
dd = rtems_disk_obtain(physical_dev);
rtems_test_assert(dd == NULL);
dd = rtems_disk_obtain(logical_dev);
rtems_test_assert(dd == NULL);
sc = rtems_disk_release(logical_dd);
ASSERT_SC(sc);
/* Cleanup */
sc = rtems_io_unregister_driver(major);
ASSERT_SC(sc);
ramdisk_free(rd);
sc = rtems_disk_io_done();
ASSERT_SC(sc);
}
void
run_bdbuf_tests()
{
rtems_disk_device *disk;
rtems_status_code sc;
dev_t dev = -1;
dev_t test_dev;
unsigned int i;
rtems_device_major_number major;
rtems_driver_address_table testdisk = {
test_disk_initialize,
RTEMS_GENERIC_BLOCK_DEVICE_DRIVER_ENTRIES
};
/* Create a message queue to get events from disk driver. */
sc = rtems_message_queue_create(TEST_TASK_RX_MQUEUE_NAME,
TEST_TASK_RX_MQUEUE_COUNT,
sizeof(bdbuf_test_msg),
RTEMS_DEFAULT_ATTRIBUTES,
&g_test_ctx.test_qid);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create message queue for test task: %u\n", sc);
return;
}
/* Register a disk device that is used in tests */
sc = rtems_io_register_driver(0, &testdisk, &major);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to register TEST DEVICE: %d\n", sc);
return;
}
test_dev = -1;
while ((disk = rtems_disk_next(dev)) != NULL)
{
printk("DEV: %s [%lu]\n", disk->name, disk->size);
dev = disk->dev;
if (strcmp(disk->name, TEST_DISK_NAME) == 0)
test_dev = dev;
rtems_disk_release(disk);
}
if (test_dev == (dev_t)-1)
{
printf("Failed to find %s disk\n", TEST_DISK_NAME);
return;
}
test_dd = rtems_disk_obtain(test_dev);
if (test_dd == NULL)
{
printf("Failed to obtain %s disk\n", TEST_DISK_NAME);
return;
}
/*
* On initialization test disk device driver registers
* its RX message queue, so we just need to locate it.
*/
sc = rtems_message_queue_ident(TEST_DRV_RX_MQUEUE_NAME,
RTEMS_SEARCH_ALL_NODES,
&g_test_ctx.test_drv_qid);
if (sc != RTEMS_SUCCESSFUL)
{
printf("Failed to find Test Driver Queue: %u\n", sc);
return;
}
for (i = 0; i < ARRAY_NUM(g_test_ctx.test_sync_main); i++)
{
sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'M', '0' + i),
0, TEST_SEM_ATTRIBS, 0,
&g_test_ctx.test_sync_main[i]);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create sync sem for test task: %u\n", sc);
return;
}
}
for (i = 0; i < ARRAY_NUM(g_test_ctx.test_sync); i++)
{
sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'T', '0' + i),
0, TEST_SEM_ATTRIBS, 0,
&g_test_ctx.test_sync[i]);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create sync sem for test task #%d: %u\n", i + 1, sc);
return;
}
}
sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'M', 'E'),
0, TEST_SEM_ATTRIBS, 0,
&g_test_ctx.test_end_main);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create end sync sem for test task: %u\n", sc);
return;
}
for (i = 0; i < ARRAY_NUM(g_test_ctx.test_task); i++)
g_test_ctx.test_task[i] = OBJECTS_ID_NONE;
for (i = 0; i < sizeof(bdbuf_tests) / sizeof(bdbuf_tests[0]); i++)
{
bdbuf_tests[i].main();
}
}
/* fat_init_volume_info --
* Get inforamtion about volume on which filesystem is mounted on
*
* PARAMETERS:
* mt_entry - mount table entry
*
* RETURNS:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
register fat_vol_t *vol = &fs_info->vol;
uint32_t data_secs = 0;
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
int fd;
struct stat stat_buf;
int i = 0;
rc = stat(mt_entry->dev, &stat_buf);
if (rc == -1)
return rc;
/* rtmes feature: no block devices, all are character devices */
if (!S_ISCHR(stat_buf.st_mode))
set_errno_and_return_minus_one(ENOTBLK);
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_lookup(stat_buf.st_dev);
if (vol->dd == NULL)
set_errno_and_return_minus_one(ENOTBLK);
vol->dev = stat_buf.st_dev;
fd = open(mt_entry->dev, O_RDONLY);
if (fd == -1)
{
rtems_disk_release(vol->dd);
return -1;
}
ret = read(fd, (void *)boot_rec, FAT_MAX_BPB_SIZE);
if ( ret != FAT_MAX_BPB_SIZE )
{
close(fd);
rtems_disk_release(vol->dd);
set_errno_and_return_minus_one( EIO );
}
close(fd);
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
if ( (vol->bps != 512) &&
(vol->bps != 1024) &&
(vol->bps != 2048) &&
(vol->bps != 4096))
{
rtems_disk_release(vol->dd);
set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
{
rtems_disk_release(vol->dd);
set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
i >>= 1, vol->spc_log2++);
/*
* "bytes per cluster" value greater than 32K is invalid
*/
if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
{
rtems_disk_release(vol->dd);
set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
vol->eoc_val = FAT_FAT32_EOC;
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
if( vol->info_sec == 0 )
{
rtems_disk_release(vol->dd);
set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
{
rtems_disk_release(vol->dd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
rtems_disk_release(vol->dd);
set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
0xFFFFFFFF);
if ( rc != RC_OK )
{
rtems_disk_release(vol->dd);
return rc;
}
}
}
}
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
vol->next_cl = 0xFFFFFFFF;
}
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(Chain_Control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
_Chain_Initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(Chain_Control));
if ( fs_info->rhash == NULL )
{
rtems_disk_release(vol->dd);
free(fs_info->vhash);
set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
_Chain_Initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
set_errno_and_return_minus_one( ENOMEM );
}
return RC_OK;
}
static rtems_status_code
rtems_bsd_sim_attach_worker(rtems_media_state state, const char *src, char **dest, void *arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
struct cam_sim *sim = arg;
char *disk = NULL;
if (state == RTEMS_MEDIA_STATE_READY) {
unsigned retries = 0;
struct scsi_inquiry_data inq_data;
uint32_t block_count = 0;
uint32_t block_size = 0;
disk = rtems_media_create_path("/dev", src, cam_sim_unit(sim));
if (disk == NULL) {
BSD_PRINTF("OOPS: create path failed\n");
goto error;
}
sc = rtems_bsd_scsi_inquiry(&sim->ccb, &inq_data);
if (sc != RTEMS_SUCCESSFUL) {
BSD_PRINTF("OOPS: inquiry failed\n");
goto error;
}
scsi_print_inquiry(&inq_data);
for (retries = 0; retries <= 3; ++retries) {
sc = rtems_bsd_scsi_test_unit_ready(&sim->ccb);
if (sc == RTEMS_SUCCESSFUL) {
break;
}
}
if (sc != RTEMS_SUCCESSFUL) {
BSD_PRINTF("OOPS: test unit ready failed\n");
goto error;
}
sc = rtems_bsd_scsi_read_capacity(&sim->ccb, &block_count, &block_size);
if (sc != RTEMS_SUCCESSFUL) {
BSD_PRINTF("OOPS: read capacity failed\n");
goto error;
}
BSD_PRINTF("read capacity: block count %u, block size %u\n", block_count, block_size);
sc = rtems_blkdev_create(disk, block_size, block_count, rtems_bsd_sim_disk_ioctl, sim);
if (sc != RTEMS_SUCCESSFUL) {
goto error;
}
/* FIXME */
#if 0
rtems_disk_device *dd = rtems_disk_obtain(dev);
dd->block_size *= 64;
rtems_disk_release(dd);
#endif
rtems_bsd_sim_disk_initialized(sim, disk);
*dest = strdup(disk, M_RTEMS_HEAP);
}
return RTEMS_SUCCESSFUL;
error:
free(disk, M_RTEMS_HEAP);
rtems_bsd_sim_disk_initialized(sim, NULL);
return RTEMS_IO_ERROR;
}
