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; }