void StateMenu2::update()
{
background.update();
if (screen == 0) mm_update();
else if (screen == 1) om_update();
else if (screen == 2) ls_update();
}
int elf_main(int argc, char *argv[])
#endif
{
struct binary_s bin;
int ret;
int i;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Does the system support the PATH variable? Has the PATH variable
* already been set? If YES and NO, then set the PATH variable to
* the ROMFS mountpoint.
*/
#if defined(CONFIG_BINFMT_EXEPATH) && !defined(CONFIG_PATH_INITIAL)
(void)setenv("PATH", MOUNTPT, 1);
#endif
/* Now excercise every program in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
/* Output a seperated so that we can clearly discrinmate the output of
* this program from the others.
*/
testheader(dirlist[i]);
/* Initialize the binary_s structure */
memset(&bin, 0, sizeof(struct binary_s));
/* If the binary loader does not support the PATH variable, then
* create the full path to the executable program. Otherwise,
* use the relative path so that the binary loader will have to
* search the PATH variable to find the executable.
*/
#ifdef CONFIG_BINFMT_EXEPATH
bin.filename = dirlist[i];
#else
snprintf(fullpath, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = fullpath;
#endif
bin.exports = exports;
bin.nexports = nexports;
/* Load the ELF module */
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
mm_update(&g_mmstep, "after load_module");
/* Execute the ELF module */
ret = exec_module(&bin);
mm_update(&g_mmstep, "after exec_module");
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
}
else
{
message("Wait a bit for test completion\n");
sleep(4);
}
unload_module(&bin);
mm_update(&g_mmstep, "after unload_module");
}
mm_update(&g_mmstep, "End-of-Test");
return 0;
}
int spawn_main(int argc, char *argv[])
{
posix_spawn_file_actions_t file_actions;
posix_spawnattr_t attr;
FAR const char *filepath;
pid_t pid;
int ret;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Does the system support the PATH variable? Has the PATH variable
* already been set? If YES and NO, then set the PATH variable to
* the ROMFS mountpoint.
*/
#if defined(CONFIG_BINFMT_EXEPATH) && !defined(CONFIG_PATH_INITIAL)
(void)setenv("PATH", MOUNTPT, 1);
#endif
/* Make sure that we are using our symbol take */
exec_setsymtab(exports, nexports);
/*************************************************************************
* Case 1: Simple program with arguments
*************************************************************************/
/* Output a seperated so that we can clearly discriminate the output of
* this program from the others.
*/
testheader(g_hello);
/* Initialize the attributes file actions structure */
ret = posix_spawn_file_actions_init(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_init failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_init(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_init failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr init");
/* If the binary loader does not support the PATH variable, then
* create the full path to the executable program. Otherwise,
* use the relative path so that the binary loader will have to
* search the PATH variable to find the executable.
*/
#ifdef CONFIG_BINFMT_EXEPATH
filepath = g_hello;
#else
snprintf(fullpath, 128, "%s/%s", MOUNTPT, g_hello);
filepath = fullpath;
#endif
/* Execute the program */
mm_update(&g_mmstep, "before posix_spawn");
ret = posix_spawn(&pid, filepath, &file_actions, &attr, NULL, (FAR char * const*)&g_argv);
if (ret != 0)
{
err("ERROR: posix_spawn failed: %d\n", ret);
}
sleep(4);
mm_update(&g_mmstep, "after posix_spawn");
/* Free attibutes and file actions */
ret = posix_spawn_file_actions_destroy(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_destroy failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_destroy(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_destroy failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr destruction");
/*************************************************************************
* Case 2: Simple program with redirection of stdin to a file input
*************************************************************************/
/* Output a seperated so that we can clearly discriminate the output of
* this program from the others.
*/
testheader(g_redirect);
/* Initialize the attributes file actions structure */
ret = posix_spawn_file_actions_init(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_init failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_init(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_init failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr init");
/* Set up to close stdin (0) and open testdata.txt as the program input */
ret = posix_spawn_file_actions_addclose(&file_actions, 0);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_addclose failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
snprintf(fullpath, 128, "%s/%s", MOUNTPT, g_data);
ret = posix_spawn_file_actions_addopen(&file_actions, 0, fullpath, O_RDONLY, 0644);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_addopen failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
mm_update(&g_mmstep, "after adding file_actions");
/* If the binary loader does not support the PATH variable, then
* create the full path to the executable program. Otherwise,
* use the relative path so that the binary loader will have to
* search the PATH variable to find the executable.
*/
#ifdef CONFIG_BINFMT_EXEPATH
filepath = g_redirect;
#else
snprintf(fullpath, 128, "%s/%s", MOUNTPT, g_redirect);
filepath = fullpath;
#endif
/* Execute the program */
mm_update(&g_mmstep, "before posix_spawn");
ret = posix_spawn(&pid, filepath, &file_actions, &attr, NULL, NULL);
if (ret != 0)
{
err("ERROR: posix_spawn failed: %d\n", ret);
}
sleep(2);
mm_update(&g_mmstep, "after posix_spawn");
/* Free attibutes and file actions */
ret = posix_spawn_file_actions_destroy(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_destroy failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_destroy(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_destroy failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr destruction");
/* Clean-up */
elf_uninitialize();
mm_update(&g_mmstep, "End-of-Test");
return 0;
}
int elf_main(int argc, char *argv[])
{
struct binary_s bin;
int ret;
int i;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Now excercise every program in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
testheader(dirlist[i]);
memset(&bin, 0, sizeof(struct binary_s));
snprintf(path, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = path;
bin.exports = exports;
bin.nexports = nexports;
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
mm_update(&g_mmstep, "after load_module");
ret = exec_module(&bin, 50);
mm_update(&g_mmstep, "after exec_module");
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
}
else
{
message("Wait a bit for test completion\n");
sleep(4);
}
unload_module(&bin);
mm_update(&g_mmstep, "after unload_module");
}
mm_update(&g_mmstep, "End-of-Test");
return 0;
}
void dse_chng_bhead(void)
{
block_id blk;
block_id *blkid_ptr;
sgm_info *dummysi = NULL;
int4 x;
cache_rec_ptr_t cr;
uchar_ptr_t bp;
sm_uc_ptr_t blkBase;
blk_hdr new_hdr;
blk_segment *bs1, *bs_ptr;
cw_set_element *cse;
int4 blk_seg_cnt, blk_size; /* needed for BLK_INIT,BLK_SEG and BLK_FINI macros */
bool ismap;
bool chng_blk;
uint4 mapsize;
uint4 jnl_status;
error_def(ERR_DSEBLKRDFAIL);
error_def(ERR_DSEFAIL);
error_def(ERR_DBRDONLY);
if (gv_cur_region->read_only)
rts_error(VARLSTCNT(4) ERR_DBRDONLY, 2, DB_LEN_STR(gv_cur_region));
assert(update_array);
/* reset new block mechanism */
update_array_ptr = update_array;
chng_blk = FALSE;
if (cli_present("BLOCK") == CLI_PRESENT)
{
if (!cli_get_hex("BLOCK",&blk))
return;
if (blk < 0 || blk > cs_addrs->ti->total_blks)
{ util_out_print("Error: invalid block number.",TRUE);
return;
}
patch_curr_blk = blk;
}
blk_size = cs_addrs->hdr->blk_size;
ismap = (patch_curr_blk / cs_addrs->hdr->bplmap * cs_addrs->hdr->bplmap == patch_curr_blk);
mapsize = BM_SIZE(cs_addrs->hdr->bplmap);
t_begin_crit (ERR_DSEFAIL);
if (!(bp = t_qread (patch_curr_blk,&dummy_hist.h[0].cycle,&dummy_hist.h[0].cr)))
rts_error(VARLSTCNT(1) ERR_DSEBLKRDFAIL);
new_hdr = *(blk_hdr_ptr_t)bp;
if (cli_present("LEVEL") == CLI_PRESENT)
{
if (!cli_get_num("LEVEL",&x))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
if (ismap && (unsigned char)x != LCL_MAP_LEVL)
{
util_out_print("Error: invalid level for a bit map block.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
if (!ismap && (x < 0 || x > MAX_BT_DEPTH + 1))
{
util_out_print("Error: invalid level.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
new_hdr.levl = (unsigned char)x;
chng_blk = TRUE;
if (new_hdr.bsiz < sizeof(blk_hdr))
new_hdr.bsiz = sizeof(blk_hdr);
if (new_hdr.bsiz > blk_size)
new_hdr.bsiz = blk_size;
}
if (cli_present("BSIZ") == CLI_PRESENT)
{
if (!cli_get_hex("BSIZ",&x))
{
t_abort(gv_cur_region, cs_addrs);
return;
}
if (ismap && x != mapsize)
{
util_out_print("Error: invalid bsiz.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
else if (x < sizeof(blk_hdr) || x > blk_size)
{
util_out_print("Error: invalid bsiz.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
chng_blk = TRUE;
new_hdr.bsiz = x;
}
if (!chng_blk)
t_abort(gv_cur_region, cs_addrs);
else
{
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, bp + sizeof(new_hdr), new_hdr.bsiz - sizeof(new_hdr));
if (!BLK_FINI(bs_ptr, bs1))
{
util_out_print("Error: bad block build.",TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
t_write (patch_curr_blk, (unsigned char *)bs1, 0, 0, bp, new_hdr.levl, TRUE, FALSE);
BUILD_AIMG_IF_JNL_ENABLED(cs_addrs, cs_data, non_tp_jfb_buff_ptr, cse);
t_end(&dummy_hist, 0);
}
if (cli_present("TN") == CLI_PRESENT)
{
if (!cli_get_hex("TN",&x))
return;
t_begin_crit(ERR_DSEFAIL);
assert(cs_addrs->ti->early_tn == cs_addrs->ti->curr_tn);
cs_addrs->ti->early_tn++;
blkBase = t_qread(patch_curr_blk, &dummy_hist.h[0].cycle, &dummy_hist.h[0].cr);
if (NULL == blkBase)
{
rel_crit(gv_cur_region);
util_out_print("Error: Unable to read buffer.", TRUE);
t_abort(gv_cur_region, cs_addrs);
return;
}
/* Create a null update array for a block */
if (ismap)
{
BLK_ADDR(blkid_ptr, sizeof(block_id), block_id);
*blkid_ptr = 0;
t_write_map(patch_curr_blk, blkBase, (unsigned char *)blkid_ptr, cs_addrs->ti->curr_tn);
cr_array_index = 0;
block_saved = FALSE;
} else
{
BLK_INIT(bs_ptr, bs1);
BLK_SEG(bs_ptr, bp + sizeof(new_hdr), new_hdr.bsiz - sizeof(new_hdr));
BLK_FINI(bs_ptr, bs1);
t_write(patch_curr_blk, (unsigned char *)bs1, 0, 0, blkBase,
((blk_hdr_ptr_t)blkBase)->levl, TRUE, FALSE);
cr_array_index = 0;
block_saved = FALSE;
if (JNL_ENABLED(cs_data))
{
JNL_SHORT_TIME(jgbl.gbl_jrec_time); /* needed for jnl_put_jrt_pini() and jnl_write_aimg_rec() */
jnl_status = jnl_ensure_open();
if (0 == jnl_status)
{
cse = (cw_set_element *)(&cw_set[0]);
cse->new_buff = non_tp_jfb_buff_ptr;
gvcst_blk_build(cse, (uchar_ptr_t)cse->new_buff, x);
cse->done = TRUE;
if (0 == cs_addrs->jnl->pini_addr)
jnl_put_jrt_pini(cs_addrs);
jnl_write_aimg_rec(cs_addrs, cse->blk, (blk_hdr_ptr_t)cse->new_buff);
} else
rts_error(VARLSTCNT(6) jnl_status, 4, JNL_LEN_STR(cs_data), DB_LEN_STR(gv_cur_region));
}
}
/* Pass the desired tn "x" as argument to bg_update or mm_update */
if (dba_bg == cs_addrs->hdr->acc_meth)
bg_update(cw_set, cw_set + cw_set_depth, cs_addrs->ti->curr_tn, x, dummysi);
else
mm_update(cw_set, cw_set + cw_set_depth, cs_addrs->ti->curr_tn, x, dummysi);
cs_addrs->ti->curr_tn++;
assert(cs_addrs->ti->early_tn == cs_addrs->ti->curr_tn);
/* the following code is analogous to that in t_end and should be maintained in a similar fashion */
while (cr_array_index)
cr_array[--cr_array_index]->in_cw_set = FALSE;
rel_crit(gv_cur_region);
if (block_saved)
backup_buffer_flush(gv_cur_region);
UNIX_ONLY(
if (unhandled_stale_timer_pop)
process_deferred_stale();
)
wcs_timer_start(gv_cur_region, TRUE);
}
