static rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
printk("\n\n*** TEST BLOCK 2 ***\n");
sc = rtems_disk_io_initialize();
ASSERT_SC(sc);
sc = ramdisk_register(BLOCK_SIZE_A, BLOCK_COUNT_A, false, "/dev/rda", &dev_a);
ASSERT_SC(sc);
sc = ramdisk_register(BLOCK_SIZE_B, BLOCK_COUNT_B, false, "/dev/rdb", &dev_b);
ASSERT_SC(sc);
sc = rtems_task_create(
rtems_build_name(' ', 'L', 'O', 'W'),
PRIORITY_LOW,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_low
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_low, task_low, 0);
ASSERT_SC(sc);
sc = rtems_task_create(
rtems_build_name('H', 'I', 'G', 'H'),
PRIORITY_HIGH,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_high
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_high, task_high, 0);
ASSERT_SC(sc);
sc = rtems_bdbuf_get(dev_a, 0, &bd);
ASSERT_SC(sc);
sc = rtems_bdbuf_sync(bd);
ASSERT_SC(sc);
printk("I: sync done: A0\n");
sync_done = true;
sc = rtems_task_suspend(RTEMS_SELF);
ASSERT_SC(sc);
}
void
init_ramdisk (void)
{
int rc = 0;
rc = rtems_disk_io_initialize ();
rtems_test_assert (rc == 0);
rc = ramdisk_register (RAMDISK_BLOCK_SIZE, RAMDISK_BLOCK_COUNT,
false, RAMDISK_PATH, &dev);
rtems_test_assert (rc == 0);
}
static rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
dev_t dev = 0;
printk("\n\n*** TEST BLOCK 4 ***\n");
sc = rtems_disk_io_initialize();
ASSERT_SC(sc);
sc = ramdisk_register(BLOCK_SIZE, BLOCK_COUNT, false, "/dev/rda", &dev);
ASSERT_SC(sc);
dd = rtems_disk_obtain(dev);
rtems_test_assert(dd != NULL);
sc = rtems_task_create(
rtems_build_name(' ', 'L', 'O', 'W'),
PRIORITY_LOW,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_low
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_low, task_low, 0);
ASSERT_SC(sc);
sc = rtems_task_create(
rtems_build_name('H', 'I', 'G', 'H'),
PRIORITY_HIGH,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_high
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_high, task_high, 0);
ASSERT_SC(sc);
sc = rtems_task_suspend(RTEMS_SELF);
ASSERT_SC(sc);
}
int usbmsc_archinitialize(void)
{
uint8_t *pbuffer;
int ret;
pbuffer = (uint8_t *)kmm_malloc(BUFFER_SIZE);
if (!pbuffer)
{
lowsyslog(LOG_ERR, "ERROR: Failed to allocate ramdisk of size %d\n",
BUFFER_SIZE);
return -ENOMEM;
}
/* Register a RAMDISK device to manage this RAM image */
ret = ramdisk_register(CONFIG_SYSTEM_USBMSC_DEVMINOR1,
pbuffer,
USBMSC_NSECTORS,
USBMSC_SECTORSIZE,
RDFLAG_WRENABLED | RDFLAG_FUNLINK);
if (ret < 0)
{
syslog(LOG_ERR,
"ERROR: create_ramdisk: Failed to register ramdisk at %s: %d\n",
g_source, -ret);
kmm_free(pbuffer);
return ret;
}
/* Create a FAT filesystem on the ramdisk */
ret = mkfatfs(g_source, &g_fmt);
if (ret < 0)
{
syslog(LOG_ERR,
"ERROR: create_ramdisk: Failed to create FAT filesystem on ramdisk at %s\n",
g_source);
/* kmm_free(pbuffer); -- RAM disk is registered */
return ret;
}
return 0;
}
int usbmsc_archinitialize(void)
{
uint8_t *pbuffer;
int ret;
pbuffer = (uint8_t *) malloc (BUFFER_SIZE);
if (!pbuffer)
{
lib_lowprintf ("usbmsc_archinitialize: Failed to allocate ramdisk of size %d\n",
BUFFER_SIZE);
return -ENOMEM;
}
/* Register a RAMDISK device to manage this RAM image */
ret = ramdisk_register(CONFIG_EXAMPLES_USBMSC_DEVMINOR1,
pbuffer,
USBMSC_NSECTORS,
USBMSC_SECTORSIZE,
true);
if (ret < 0)
{
printf("create_ramdisk: Failed to register ramdisk at %s: %d\n",
g_source, -ret);
free(pbuffer);
return ret;
}
/* Create a FAT filesystem on the ramdisk */
ret = mkfatfs(g_source, &g_fmt);
if (ret < 0)
{
printf("create_ramdisk: Failed to create FAT filesystem on ramdisk at %s\n",
g_source);
/* free(pbuffer); -- RAM disk is registered */
return ret;
}
return 0;
}
int cmd_mkrd(FAR struct nsh_vtbl_s *vtbl, int argc, char **argv)
{
const char *fmt;
uint8_t *buffer;
uint32_t nsectors;
bool badarg = false;
int sectsize = 512;
int minor = 0;
int ret;
/* Get the mount options */
int option;
while ((option = getopt(argc, argv, ":m:s:")) != ERROR)
{
switch (option)
{
case 'm':
minor = atoi(optarg);
if (minor < 0 || minor > 255)
{
nsh_output(vtbl, g_fmtargrange, argv[0]);
badarg = true;
}
break;
case 's':
sectsize = atoi(optarg);
if (minor < 0 || minor > 16384)
{
nsh_output(vtbl, g_fmtargrange, argv[0]);
badarg = true;
}
break;
case ':':
nsh_output(vtbl, g_fmtargrequired, argv[0]);
badarg = true;
break;
case '?':
default:
nsh_output(vtbl, g_fmtarginvalid, argv[0]);
badarg = true;
break;
}
}
/* If a bad argument was encountered, then return without processing the command */
if (badarg)
{
return ERROR;
}
/* There should be exactly on parameter left on the command-line */
if (optind == argc-1)
{
nsectors = (uint32_t)atoi(argv[optind]);
}
else if (optind >= argc)
{
fmt = g_fmttoomanyargs;
goto errout_with_fmt;
}
else
{
fmt = g_fmtargrequired;
goto errout_with_fmt;
}
/* Allocate the memory backing up the ramdisk */
buffer = (uint8_t*)malloc(sectsize * nsectors);
if (!buffer)
{
fmt = g_fmtcmdoutofmemory;
goto errout_with_fmt;
}
#ifdef CONFIG_DEBUG_VERBOSE
memset(buffer, 0, sectsize * nsectors);
#endif
dbg("RAMDISK at %p\n", buffer);
/* Then register the ramdisk */
ret = ramdisk_register(minor, buffer, nsectors, sectsize, true);
if (ret < 0)
{
nsh_output(vtbl, g_fmtcmdfailed, argv[0], "ramdisk_register", NSH_ERRNO_OF(-ret));
free(buffer);
return ERROR;
}
return ret;
errout_with_fmt:
nsh_output(vtbl, fmt, argv[0]);
return ERROR;
}
static rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_task_priority cur_prio = 0;
rtems_bdbuf_buffer *bd = NULL;
dev_t dev = 0;
rtems_test_begink();
sc = rtems_disk_io_initialize();
ASSERT_SC(sc);
sc = ramdisk_register(BLOCK_SIZE_A, BLOCK_COUNT, false, "/dev/rda", &dev);
ASSERT_SC(sc);
dd = rtems_disk_obtain(dev);
rtems_test_assert(dd != NULL);
sc = rtems_task_create(
rtems_build_name(' ', 'L', 'O', 'W'),
PRIORITY_LOW,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_low
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_low, task_low, 0);
ASSERT_SC(sc);
sc = rtems_task_create(
rtems_build_name(' ', 'M', 'I', 'D'),
PRIORITY_MID,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_mid
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_mid, task_mid, 0);
ASSERT_SC(sc);
sc = rtems_task_create(
rtems_build_name('H', 'I', 'G', 'H'),
PRIORITY_HIGH,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_high
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_high, task_high, 0);
ASSERT_SC(sc);
sc = rtems_task_suspend(task_id_mid);
ASSERT_SC(sc);
sc = rtems_task_suspend(task_id_high);
ASSERT_SC(sc);
sc = rtems_bdbuf_get(dd, 1, &bd);
ASSERT_SC(sc);
sc = rtems_bdbuf_release(bd);
ASSERT_SC(sc);
printk("I: try access: 0\n");
sc = rtems_bdbuf_get(dd, 0, &bd);
ASSERT_SC(sc);
printk("I: access: 0\n");
sc = rtems_task_set_priority(RTEMS_SELF, PRIORITY_IDLE, &cur_prio);
ASSERT_SC(sc);
sc = rtems_task_resume(task_id_high);
ASSERT_SC(sc);
sc = rtems_task_resume(task_id_mid);
ASSERT_SC(sc);
sc = rtems_task_set_priority(RTEMS_SELF, PRIORITY_INIT, &cur_prio);
ASSERT_SC(sc);
printk("I: release: 0\n");
sc = rtems_bdbuf_release(bd);
ASSERT_SC(sc);
printk("I: release done: 0\n");
rtems_task_delete(RTEMS_SELF);
}
void up_registerblockdevice(void)
{
ramdisk_register(0, (FAR uint8_t *)up_deviceimage(), NSECTORS,
LOGICAL_SECTOR_SIZE, RDFLAG_WRENABLED | RDFLAG_FUNLINK);
}
/****************************************************************************
* Name: tash_mkrd
*
* Description:
* Make RAM or ROM disk if m is not specified, default is '0' and if s is
* not specified, default is 512bytes
*
* Usage:
* mkrd [-m <minor>] [-s <sector-size>] <nsectors> or mkrd <nsectors>
****************************************************************************/
static int tash_mkrd(int argc, char **args)
{
const char *fmt;
uint8_t *buffer;
uint32_t nsectors;
bool badarg = false;
int sectsize = 512;
int minor = 0;
int ret;
/* Get the mkrd options */
int option;
optind = -1;
while ((option = getopt(argc, args, ":m:s:")) != ERROR) {
switch (option) {
case 'm':
minor = atoi(optarg);
if (minor < 0 || minor > 255) {
FSCMD_OUTPUT(OUT_OF_RANGE, args[0]);
badarg = true;
}
break;
case 's':
sectsize = atoi(optarg);
if (minor < 0 || minor > 16384) {
FSCMD_OUTPUT(OUT_OF_RANGE, args[0]);
badarg = true;
}
break;
case ':':
FSCMD_OUTPUT(MISSING_ARGS, args[0]);
badarg = true;
break;
case '?':
default:
FSCMD_OUTPUT(INVALID_ARGS, args[0]);
badarg = true;
break;
}
}
/*
* If a bad argument was encountered,
* then return without processing the command
*/
if (badarg) {
return ERROR;
}
/* There should be exactly one parameter left on the command-line */
if (optind == argc - 1) {
nsectors = (uint32_t)atoi(args[optind]);
} else if (optind >= argc) {
fmt = TOO_MANY_ARGS;
goto errout_with_fmt;
} else {
fmt = MISSING_ARGS;
goto errout_with_fmt;
}
if (nsectors < 1) {
FSCMD_OUTPUT(INVALID_ARGS, args[0]);
return ERROR;
}
/* Allocate the memory backing up the ramdisk */
buffer = (uint8_t *)malloc(sectsize * nsectors);
if (!buffer) {
fmt = OUT_OF_MEMORY;
goto errout_with_fmt;
}
#ifdef CONFIG_DEBUG_VERBOSE
memset(buffer, 0, sectsize * nsectors);
#endif
dbg("RAMDISK at %p\n", buffer);
/* Then register the ramdisk */
ret = ramdisk_register(minor, buffer, nsectors, sectsize, RDFLAG_WRENABLED | RDFLAG_FUNLINK);
if (ret < 0) {
FSCMD_OUTPUT(CMD_FAILED, args[0], "ramdisk_register");
free(buffer);
return ERROR;
}
return ret;
errout_with_fmt:
FSCMD_OUTPUT(fmt, args[0]);
return ERROR;
}
