void simple_shell()
{ int n_args, i;
//memory space for user command is always the same, freed on quit
char * * sarray = malloc(max_arg_c * sizeof(*sarray));
for (i = 0; i < max_arg_c; i += 1)
sarray[i] = malloc(max_arg_length + 1);
print_commands();
while (1)
{ printf("\n---> ");
for (i = 0; i < max_arg_c; i += 1)
*sarray[i] = (char *)NULL;
n_args = get_command_line(sarray);
if (quit_command(sarray[0]))
{ printf("exiting shell \n");
for (i = 0; i < max_arg_c; i += 1)
free(sarray[i]);
free(sarray);
break; }
else if (!strcmp(sarray[0], "help"))
print_commands();
else if (!strcmp(sarray[0], "echo"))
{ for (i = 1; i < n_args && sarray[i] != NULL; i += 1)
printf("%s ", sarray[i]); }
else if (!strcmp(sarray[0], "run"))
run_program(sarray, n_args);
else
printf("command not found. "); } }
static void
guile_command (char *arg, int from_tty)
{
struct cleanup *cleanup;
cleanup = make_cleanup_restore_integer (&interpreter_async);
interpreter_async = 0;
arg = skip_spaces (arg);
if (arg && *arg)
{
char *msg = gdbscm_safe_eval_string (arg, 1);
if (msg != NULL)
{
make_cleanup (xfree, msg);
error ("%s", msg);
}
}
else
{
struct command_line *l = get_command_line (guile_control, "");
make_cleanup_free_command_lines (&l);
execute_control_command_untraced (l);
}
do_cleanups (cleanup);
}
int main(int argc, char **argv, char **envp)
{
t_ftsh *sh;
sh = NULL;
sh = intialize_sh(argc, argv, envp);
if (!sh)
{
ft_putendl_fd("Error : could'nt initialize shell", 2);
return (1);
}
while (1)
{
catch_signals();
if (sh->line)
free(sh->line);
sh->line = NULL;
write(1, sh->prompt, ft_strlen(sh->prompt));
if ((sh->line = get_command_line()) != NULL)
{
sh->ret = execute_command_line(sh, &(sh->env_dup));
ft_tabfree(sh->path_dir);
sh->path_dir = extract_path_directories(sh->env_dup);
}
else
exit(1);
}
}
/**
* @brief actually does the write to kafka of a string with the given
* file path
* @param path file path to save to kafka
* @param buf write buffer
* @param size size of the buffer to write
* @param offset starting point in the buffer
* @return 0 if the write succeeded, 1 otherwise
**/
static int actual_kafka_write(const char *path, const char *buf,
size_t size, off_t offset)
{
char* ret = NULL;
(void) path;
char timestamp[] = "YYYY-MM-ddTHH:mm:ss.SSS+0000";
char* text = base64(buf, size);
struct fuse_context* context = fuse_get_context();
struct group* sgroup = getgrgid(context->gid);
struct passwd* suser = getpwuid(context->uid);
char* user = suser == NULL ? "":suser->pw_name;
char* group = sgroup == NULL ? "":sgroup->gr_name;
char* command = get_command_line(context->pid);
char* format = "{\"path\": \"%s%s\", \"pid\": %d, \"uid\": %d, "
"\"gid\": %d, \"@message\": \"%s\", \"@timestamp\": \"%s\","
"\"user\": \"%s\", \"group\": \"%s\", \"command\": \"%s\","
"\"@version\": \"%s\", \"@fields\": %s, \"@tags\": %s}";
kafka_t *private_data = (kafka_t*) fuse_get_context()->private_data;
config* conf = (config*)private_data->conf;
set_timestamp(timestamp);
asprintf(&ret, format, conf->directories[conf->directory_n],
path + 1, context->pid, context->uid, context->gid,
text, timestamp, user, group, command, VERSION,
conf->fields_s, conf->tags_s);
free(command);
free(text);
if (ret == NULL) {
fprintf(stderr, "Error in asprintf\n");
return 1;
}
send_kafka(context->private_data, ret, strlen(ret));
free(ret);
return 0;
}
/* returns TRUE if able to fit in one $STACK(level,...) of information in global variable structure "dollar_stack".
* returns FALSE otherwise */
static boolean_t fill_dollar_stack_level(int array_level, int frame_level, int cur_zlevel)
{
mstr *mstrptr;
mval tmpmval;
dollar_stack_struct *dstack;
assert(FALSE == dollar_stack.incomplete); /* we should not have come here if previous $STACK levels were incomplete */
dstack = &dollar_stack.array[array_level];
/* fill in $STACK(level) */
if (frame_level)
get_frame_creation_info(frame_level, cur_zlevel, &tmpmval);
else
get_command_line(&tmpmval, FALSE); /* FALSE to indicate we want actual (not processed) command line */
/* note that tmpmval at this point will most likely point to the stringpool. but we rely on stp_gcol to free it up */
mstrptr = &dstack->mode_str;
if (FALSE == fill_dollar_stack_info(&tmpmval, mstrptr))
return FALSE;
/* fill in $STACK(level,"ECODE") */
dstack->ecode_ptr = (frame_level == (cur_zlevel - 1)) ? &dollar_ecode.array[dollar_ecode.index - 1] : NULL;
/* fill in $STACK(level,"PLACE") */
get_frame_place_mcode(frame_level, DOLLAR_STACK_PLACE, cur_zlevel, &tmpmval);
mstrptr = &dstack->place_str;
if (FALSE == fill_dollar_stack_info(&tmpmval, mstrptr))
return FALSE;
/* fill in $STACK(level,"MCODE") */
get_frame_place_mcode(frame_level, DOLLAR_STACK_MCODE, cur_zlevel, &tmpmval);
mstrptr = &dstack->mcode_str;
if (FALSE == fill_dollar_stack_info(&tmpmval, mstrptr))
return FALSE;
return TRUE;
}
int main(int argc, char **argv, char **env) {
char command_line[128];
init_embedded_perl();
/* Calls Perl to load and construct a new
* Term::ReadLine object.
*/
init_term_readline();
while (1) {
/*
* get_command_line calls Perl to get a scalar from stdin
*/
strncpy(command_line, get_command_line(), 128) ;
/* Perl Term::ReadLine::readline() method chomps the "\n"
* from the end of the input.
*/
run_plugin(command_line) ;
}
deinit_embedded_perl();
}
static void
python_command (char *arg, int from_tty)
{
struct cleanup *cleanup;
cleanup = ensure_python_env (get_current_arch (), current_language);
make_cleanup_restore_integer (&interpreter_async);
interpreter_async = 0;
while (arg && *arg && isspace (*arg))
++arg;
if (arg && *arg)
{
if (PyRun_SimpleString (arg))
error (_("Error while executing Python code."));
}
else
{
struct command_line *l = get_command_line (python_control, "");
make_cleanup_free_command_lines (&l);
execute_control_command_untraced (l);
}
do_cleanups (cleanup);
}
/* check we retained the initrd */
void check_reuse_initrd(void)
{
char *line = get_command_line();
if (strstr(line, "retain_initrd") == NULL)
die("unrecoverable error: current boot didn't "
"retain the initrd for reuse.\n");
free(line);
}
static void
if_command (const char *arg, int from_tty)
{
control_level = 1;
command_line_up command = get_command_line (if_control, arg);
if (command == NULL)
return;
scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
execute_control_command_untraced (command.get ());
}
/*
* Main.
*/
int
main (int argc, char* argv[])
{
struct command_line cmdline;
int rc, finalrc;
/* Find out what we're supposed to do */
rc = get_command_line (argc, argv, &cmdline);
if (rc) {
return 1;
}
rc= check_key_state (&cmdline);
if (rc) {
return 1;
}
/* Check for priority options --help and --version */
if (cmdline.parm[cmd_keyword_help].kw_given) {
print_usage ();
return 0;
} else if (cmdline.parm[cmd_keyword_version].kw_given) {
print_version ();
return 0;
}
/* Make sure we're running as root */
if (check_for_root ()) {
return 1;
}
/* Do each of the commands on each of the devices
* and don't care about the return codes */
if (cmdline.device_id >= argc) {
error_print ("Missing device");
print_usage ();
return 1;
}
finalrc = 0;
while (cmdline.device_id < argc) {
rc = do_command (argv[cmdline.device_id], cmdline);
if (rc && !finalrc)
finalrc = rc;
cmdline.device_id++;
}
return finalrc;
}
static void
guile_command (char *arg, int from_tty)
{
arg = skip_spaces (arg);
if (arg && *arg)
error (_("Guile scripting is not supported in this copy of GDB."));
else
{
/* Even if Guile isn't enabled, we still have to slurp the
command list to the corresponding "end". */
struct command_line *l = get_command_line (guile_control, "");
struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
execute_control_command_untraced (l);
do_cleanups (cleanups);
}
}
dynamic_string_array get_command_line_params()
{
dynamic_string_array params;
#ifdef VOGL_USE_WIN32_API
dynamic_string cmd_line;
split_command_line_params(get_command_line().c_str(), params);
#else
const char *pSrc = get_proc_cmdline();
while (*pSrc)
{
params.push_back(pSrc);
pSrc += strlen(pSrc) + 1;
}
#endif
return params;
}
int key_enterr(t_link *link)
{
if (link->line != NULL)
{
my_putchar('\n');
get_command_line(link, convert_list_to_str(link->line), 1);
link->line = NULL;
if (link->exit_status == 0 && link->term_caps == 1)
display_prompt(link);
}
else
{
my_putchar('\n');
display_prompt(link);
}
sauv_cur();
return (TRUE);
}
void op_fnstack1(int level, mval *result)
{
int cur_zlevel;
result->mvtype = MV_STR;
cur_zlevel = dollar_zlevel();
if (-1 == level)
{
if (!dollar_ecode.index)
{
MV_FORCE_MVAL(result, cur_zlevel - 1);
} else if ((1 < dollar_ecode.index) || (error_frame != dollar_ecode.first_ecode_error_frame))
MV_FORCE_MVAL(result, dollar_stack.index - 1);
else
{ /* we are in first ECODE error-handler */
if (cur_zlevel > dollar_stack.index)
{
MV_FORCE_MVAL(result, cur_zlevel - 1);
} else
{
MV_FORCE_MVAL(result, dollar_stack.index - 1);
}
}
} else if (0 > level)
result->str.len = 0;
else if (0 == level)
get_command_line(result, FALSE); /* FALSE to indicate we want actual (not processed) command line */
else if (!dollar_stack.index)
{
if (level < cur_zlevel)
get_frame_creation_info(level, cur_zlevel, result);
else
result->str.len = 0;
} else if (level < dollar_stack.index)
get_dollar_stack_info(level, DOLLAR_STACK_MODE, result);
else if (!dollar_stack.incomplete && (1 == dollar_ecode.index)
&& (error_frame == dollar_ecode.first_ecode_error_frame) && (level < cur_zlevel))
get_frame_creation_info(level, cur_zlevel, result);
else
result->str.len = 0;
return;
}
void
if_command (char *arg, int from_tty)
{
struct command_line *command = NULL;
struct cleanup *old_chain;
control_level = 1;
command = get_command_line (if_control, arg);
if (command == NULL)
return;
old_chain = make_cleanup_restore_integer (&interpreter_async);
interpreter_async = 0;
execute_control_command_untraced (command);
free_command_lines (&command);
do_cleanups (old_chain);
}
static char *get_input_line(char *mes, int new_cmd)
{
FILE *f = stdin;
char *res;
int len;
if (strlen(input_buf_ptr) > 0) {
res = input_buf_ptr;
input_buf_ptr = find_cmd_end(input_buf_ptr);
return(res);
};
input_buf_ptr = input_buffer;
fflush(stdout);
memset(input_buffer, 0, READ_BUF_SIZE);
current_row = 0;
if (read_stdin) {
if (mes != (char *)NULL) snprintf(Title, READ_BUF_SIZE, "%s", mes);
else strcpy(Title, "hpi_shell> ");
printf("%s", Title);
res = get_command_line(new_cmd, COMPL_CMD);
if (res != (char *)NULL) {
strcpy(input_buffer, res);
res = input_buffer;
}
} else if (read_file) {
f = input_file;
res = fgets(input_buffer, READ_BUF_SIZE - 1, f);
} else {
printf("Internal error: get_input_line:\n"
" No input file\n");
exit(1);
};
if (res != (char *)NULL) {
len = strlen(res);
if ((len > 0) && (res[len - 1] == '\n'))
res[len - 1] = 0;
input_buf_ptr = find_cmd_end(input_buf_ptr);
};
return(res);
}
int main(int argc, char **argv, char **env) {
init_embedded_perl();
/* Calls Perl to load and construct a new
* Term::ReadLine object.
*/
init_term_readline();
while (1) {
/*
* get_command_line calls Perl to get a scalar from stdin
*/
/* Perl Term::ReadLine::readline() method chomps the "\n"
* from the end of the input.
*/
char *cmd,*end;
/* Allow any length command line */
cmd = (get_command_line ()) ;
// Trim leading whitespace
while (isspace (*cmd)) cmd++;
// Trim trailing whitespace
end = cmd + strlen (cmd) - 1;
while (end > cmd && isspace (*end)) end--;
// Write new null terminator
*(end+1) = 0;
run_plugin (cmd) ;
}
deinit_embedded_perl();
}
void zshow_svn(zshow_out *output)
{
mstr x;
mval var, zdir;
io_log_name *tl;
stack_frame *fp;
int count, save_dollar_zlevel;
char *c1, *c2;
char zdir_error[3 * GTM_MAX_DIR_LEN + 128]; /* PATH_MAX + "->" + GTM-W-ZDIROUTOFSYNC, <text of ZDIROUTOFSYNC> */
error_def(ERR_ZDIROUTOFSYNC);
/* SV_DEVICE */
get_dlr_device(&var);
ZS_VAR_EQU(&x, device_text);
mval_write(output, &var, TRUE);
/* SV_ECODE */
ecode_get(-1, &var);
ZS_VAR_EQU(&x, ecode_text);
mval_write(output, &var, TRUE);
/* SV_ESTACK */
save_dollar_zlevel = dollar_zlevel();
count = (save_dollar_zlevel - 1) - dollar_estack_delta.m[0];
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, estack_text);
mval_write(output, &var, TRUE);
/* SV_ETRAP */
var.mvtype = MV_STR;
var.str = dollar_etrap.str;
ZS_VAR_EQU(&x, etrap_text);
mval_write(output, &var, TRUE);
/* SV_HOROLOG */
op_horolog(&var);
ZS_VAR_EQU(&x, horolog_text);
mval_write(output, &var, TRUE);
/* SV_IO */
var.str.addr = io_curr_device.in->name->dollar_io;
var.str.len = io_curr_device.in->name->len;
/*** The following should be in the I/O code ***/
if (ESC == *var.str.addr)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
var.mvtype = MV_STR;
ZS_VAR_EQU(&x, io_text);
mval_write(output, &var, TRUE);
/* SV_JOB */
ZS_VAR_EQU(&x, job_text);
mval_write(output, &dollar_job, TRUE);
/* SV_KEY */
get_dlr_key(&var);
ZS_VAR_EQU(&x, key_text);
mval_write(output, &var, TRUE);
/* SV_PRINCIPAL */
if (dollar_principal)
tl = dollar_principal;
else
tl = io_root_log_name->iod->trans_name;
var.str.addr = tl->dollar_io;
var.str.len = tl->len;
/*** The following should be in the I/O code ***/
if (ESC == *var.str.addr)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
var.mvtype = MV_STR;
ZS_VAR_EQU(&x, principal_text);
mval_write(output, &var, TRUE);
/* SV_QUIT */
count = ((NULL == get_ret_targ()) ? 0 : 1);
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, quit_text);
mval_write(output, &var, TRUE);
/* SV_REFERENCE */
get_reference(&var);
ZS_VAR_EQU(&x, reference_text);
mval_write(output, &var, TRUE);
/* SV_STACK */
count = (save_dollar_zlevel - 1);
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, stack_text);
mval_write(output, &var, TRUE);
/* SV_STORAGE */
i2mval(&var, getstorage());
ZS_VAR_EQU(&x, storage_text);
mval_write(output, &var, TRUE);
/* SV_SYSTEM */
var.mvtype = MV_STR;
var.str = dollar_system.str;
ZS_VAR_EQU(&x, system_text);
mval_write(output, &var, TRUE);
/* SV_TEST */
i2mval(&var, (int)op_dt_get());
ZS_VAR_EQU(&x, test_text);
mval_write(output, &var, TRUE);
/* SV_TLEVEL */
count = (int)dollar_tlevel;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, tlevel_text);
mval_write(output, &var, TRUE);
/* SV_TRESTART */
MV_FORCE_MVAL(&var, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart));
ZS_VAR_EQU(&x, trestart_text);
mval_write(output, &var, TRUE);
/* SV_X */
count = (int)io_curr_device.out->dollar.x;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, x_text);
mval_write(output, &var, TRUE);
/* SV_Y */
count = (int)io_curr_device.out->dollar.y;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, y_text);
mval_write(output, &var, TRUE);
/* SV_ZA */
count = (int)io_curr_device.in->dollar.za;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, za_text);
mval_write(output, &var, TRUE);
/* SV_ZB */
c1 = (char *)io_curr_device.in->dollar.zb;
c2 = c1 + sizeof(io_curr_device.in->dollar.zb);
var.mvtype = MV_STR;
var.str.addr = (char *)io_curr_device.in->dollar.zb;
while (c1 < c2 && *c1)
c1++;
var.str.len = (char *)c1 - var.str.addr;
ZS_VAR_EQU(&x, zb_text);
mval_write(output, &var, TRUE);
/* SV_ZCMDLINE */
get_command_line(&var, TRUE); /* TRUE to indicate we want $ZCMDLINE (i.e. processed not actual command line) */
ZS_VAR_EQU(&x, zcmdline_text);
mval_write(output, &var, TRUE);
/* SV_ZCOMPILE */
var.mvtype = MV_STR;
var.str = dollar_zcompile;
ZS_VAR_EQU(&x, zcompile_text);
mval_write(output, &var, TRUE);
/* SV_ZCSTATUS */
MV_FORCE_MVAL(&var, dollar_zcstatus);
ZS_VAR_EQU(&x, zcstatus_text);
mval_write(output, &var, TRUE);
/* SV_ZDATEFORM */
MV_FORCE_MVAL(&var, zdate_form);
ZS_VAR_EQU(&x, zdate_form_text);
mval_write(output, &var, TRUE);
/* SV_ZDIR */
ZS_VAR_EQU(&x, zdirectory_text);
setzdir(NULL, &zdir);
if (zdir.str.len != dollar_zdir.str.len || 0 != memcmp(zdir.str.addr, dollar_zdir.str.addr, zdir.str.len))
{
memcpy(zdir_error, zdir.str.addr, zdir.str.len);
memcpy(&zdir_error[zdir.str.len], arrow_text, STR_LIT_LEN(arrow_text));
sgtm_putmsg(&zdir_error[zdir.str.len + STR_LIT_LEN(arrow_text)], VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4,
zdir.str.len, zdir.str.addr, dollar_zdir.str.len, dollar_zdir.str.addr);
zdir.str.addr = zdir_error;
zdir.str.len = strlen(zdir_error) - 1; /* eliminate trailing '\n' */
}
SKIP_DEVICE_IF_NOT_NEEDED(&zdir);
mval_write(output, &zdir, TRUE);
/* SV_ZEDITOR */
MV_FORCE_MVAL(&var, dollar_zeditor);
ZS_VAR_EQU(&x, zeditor_text);
mval_write(output, &var, TRUE);
/* SV_ZEOF */
ZS_VAR_EQU(&x, zeof_text);
mval_write(output, io_curr_device.in->dollar.zeof ? (mval *)&literal_one : (mval *)&literal_zero, TRUE);
/* SV_ZERROR */
var.mvtype = MV_STR;
var.str = dollar_zerror.str;
ZS_VAR_EQU(&x, zerror_text);
mval_write(output, &var, TRUE);
/* SV_ZGBLDIR */
ZS_VAR_EQU(&x, zgbldir_text);
mval_write(output, &dollar_zgbldir, TRUE);
/* SV_ZININTERRUPT */
MV_FORCE_MVAL(&var, dollar_zininterrupt);
ZS_VAR_EQU(&x, zininterrupt_text);
mval_write(output, &var, TRUE);
/* SV_ZINTERRUPT */
var.mvtype = MV_STR;
var.str = dollar_zinterrupt.str;
ZS_VAR_EQU(&x, zinterrupt_text);
mval_write(output, &var, TRUE);
/* SV_ZIO */
var.mvtype = MV_STR;
/* NOTE: This is **NOT** equivalent to :
* io_curr_log_name->dollar_io
*/
var.str.addr = io_curr_device.in->trans_name->dollar_io;
var.str.len = io_curr_device.in->trans_name->len;
if (*var.str.addr == ESC)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
ZS_VAR_EQU(&x, zio_text);
mval_write(output, &var, TRUE);
/* SV_ZJOB */
MV_FORCE_ULONG_MVAL(&var, dollar_zjob);
ZS_VAR_EQU(&x, zjob_text);
mval_write(output, &var, TRUE);
/* SV_ZLEVEL */
MV_FORCE_MVAL(&var, save_dollar_zlevel);
ZS_VAR_EQU(&x, zlevel_text);
mval_write(output, &var, TRUE);
/* SV_ZMAXTPTIME */
MV_FORCE_MVAL(&var, dollar_zmaxtptime);
ZS_VAR_EQU(&x, zmaxtptime_text);
mval_write(output, &var, TRUE);
/* SV_ZMODE */
ZS_VAR_EQU(&x, zmode_text);
mval_write(output, &dollar_zmode, TRUE);
/* SV_ZPOS */
getzposition(&var);
ZS_VAR_EQU(&x, zpos_text);
mval_write(output, &var, TRUE);
/* SV_ZPROC */
ZS_VAR_EQU(&x, zproc_text);
mval_write(output, &dollar_zproc, TRUE);
/* SV_PROMPT */
var.mvtype = MV_STR;
var.str.addr = gtmprompt.addr;
var.str.len = gtmprompt.len;
ZS_VAR_EQU(&x, zprompt_text);
mval_write(output, &var, TRUE);
/* SV_ZROUTINES */
if (!zro_root)
zro_init();
var.mvtype = MV_STR;
var.str = dollar_zroutines;
ZS_VAR_EQU(&x, zroutines_text);
mval_write(output, &var, TRUE);
/* SV_ZSOURCE */
var.mvtype = MV_STR;
var.str = dollar_zsource;
ZS_VAR_EQU(&x, zsource_text);
mval_write(output, &var, TRUE);
/* SV_ZSTATUS */
ZS_VAR_EQU(&x, zstatus_text);
mval_write(output, &dollar_zstatus, TRUE);
/* SV_ZSTEP */
ZS_VAR_EQU(&x, zstep_text);
mval_write(output, &dollar_zstep, TRUE);
/* SV_ZSYSTEM */
MV_FORCE_MVAL(&var, dollar_zsystem);
ZS_VAR_EQU(&x, zsystem_text);
mval_write(output, &var, TRUE);
/* SV_ZTEXIT */
var.mvtype = MV_STR;
var.str = dollar_ztexit.str;
ZS_VAR_EQU(&x, ztexit_text);
mval_write(output, &var, TRUE);
/* SV_ZTRAP */
var.mvtype = MV_STR;
var.str = dollar_ztrap.str;
ZS_VAR_EQU(&x, ztrap_text);
mval_write(output, &var, TRUE);
/* SV_ZVERSION */
var.mvtype = MV_STR;
var.str.addr = (char *)>m_release_name[0];
var.str.len = gtm_release_name_len;
ZS_VAR_EQU(&x, zversion_text);
mval_write(output, &var, TRUE);
/* SV_ZYERROR */
var.mvtype = MV_STR;
var.str = dollar_zyerror.str;
ZS_VAR_EQU(&x, zyerror_text);
mval_write(output, &var, TRUE);
}
int main(int argc, char **argv) {
struct sigaction sa;
char *cmdline_str;
char **argv_array;
GMainLoop *loop;
argv_array = argv_to_array(argc, argv);
cmdline_str = get_command_line(argv_array);
set_argv_for_child_process(argv_array);
cps_config_init(argc, argv);
if(global_config.daemonize) {
/* When daemonizing, a child process will be launched with daemonization disabled */
daemonize();
run_watchdog(argv_array);
/* Watchdog should never stop ! */
exit(EXIT_FAILURE);
}
/* The child (or not daemonized process) will continue here. */
L (LOGLEVEL_WARNING, PACKAGE_NAME "-" PACKAGE_VERSION " starting");
L (LOGLEVEL_DEBUG, "Command line : %s", cmdline_str);
g_free(cmdline_str);
/* Signals initialization {{{ */
memset (&sa, 0, sizeof (sa));
sa.sa_sigaction = signal_handler_for_stop;
sa.sa_flags = SA_SIGINFO;
sigemptyset(&(sa.sa_mask));
if(0 != sigaction(SIGTERM, &sa, NULL)) {
L (LOGLEVEL_CRITICAL, "Could not set signal handler for TERM");
exit(EXIT_FAILURE);
}
if(0 != sigaction(SIGINT, &sa, NULL)) {
L (LOGLEVEL_CRITICAL, "Could not set signal handler for INT");
close_all_and_exit(EXIT_FAILURE);
}
if(0 != sigaction(SIGQUIT, &sa, NULL)) {
L (LOGLEVEL_CRITICAL, "Could not set signal handler for QUIT");
close_all_and_exit(EXIT_FAILURE);
}
memset (&sa, 0, sizeof (sa));
sa.sa_handler = SIG_IGN;
sa.sa_flags = SA_RESTART;
sigemptyset(&(sa.sa_mask));
if(0 != sigaction(SIGPIPE, &sa, NULL)) {
L (LOGLEVEL_CRITICAL, "Could not set signal handler for PIPE");
exit(EXIT_FAILURE);
}
/* }}} */
cpsa_init();
loop = g_main_new(TRUE);
g_timeout_add_seconds(global_config.agent__interval, cpsa_get_process, NULL);
g_main_run( loop );
L (LOGLEVEL_WARNING, PACKAGE_NAME "-" PACKAGE_VERSION " ending");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv) {
Settings settings;
int i;
char *bam_file = NULL;
samfile_t *fp_bam = NULL;
const char *override_intensity_dir = NULL;
const char *filter_file = NULL;
int ntiles = 0;
int nreads = 0;
int nst = 0;
SurvTable *sts[(N_TILES+1)*N_READS];
int nct = 0;
CalTable *cts[(N_TILES+1)*N_READS];
settings.prefix = NULL;
settings.quiet = 0;
settings.filter_bad_tiles = 0;
settings.spatial_filter = 0;
settings.region_size = 0;
settings.nregions_x = 0;
settings.nregions_y = 0;
settings.n_bins_left = 2;
settings.n_bins_right = 2;
settings.cstart[0] = 0;
settings.cstart[1] = 0;
settings.cstart[2] = 0;
settings.intensity_dir = NULL;
settings.snp_file = NULL;
settings.snp_hash = NULL;
settings.read_length[0] = 0;
settings.read_length[1] = 0;
settings.read_length[2] = 0;
settings.working_dir = NULL;
settings.cmdline = get_command_line(argc, argv);
/* Parse args */
for (i = 1; i < argc && argv[i][0] == '-'; i++) {
if (!strcmp(argv[i], "-")) {
break;
} else if (!strcmp(argv[i], "-intensity-dir")) {
if(override_intensity_dir != NULL) {
fprintf(stderr, "ERROR: -intensity-dir option specified multiple times\n");
usage(1);
}
check_arg(i,argc,"-intensity-dir");
override_intensity_dir = argv[++i];
} else if (!strcmp(argv[i], "-snp_file")) {
if(settings.snp_file != NULL) {
fprintf(stderr, "ERROR: -snp_file specified multiple times\n");
usage(1);
}
check_arg(i,argc,"-snp_file");
settings.snp_file = argv[++i];
} else if (!strcmp(argv[i], "-filter_file")) {
if(filter_file != NULL) {
fprintf(stderr, "ERROR: -filter_file specified multiple times\n");
usage(1);
}
check_arg(i,argc,"-filter_file");
filter_file = argv[++i];
} else if (!strcmp(argv[i], "-q")) {
settings.quiet = 1;
} else if (!strcmp(argv[i], "-p")) {
if(settings.prefix != NULL) {
fprintf(stderr, "ERROR: -p option specified multiple times\n");
usage(1);
}
check_arg(i,argc,"-p");
settings.prefix = argv[++i];
} else if (!strcmp(argv[i], "-filter-bad-tiles")){
settings.filter_bad_tiles = atoi(argv[++i]);
if(settings.filter_bad_tiles < 1){
fprintf(stderr,"ERROR: invalid argument to -filter_bad_tiles\n");
usage(1);
}
} else if (!strcmp(argv[i], "-cstart1")){
check_arg(i,argc,"-cstart1");
settings.cstart[1] = atoi(argv[++i]);
if(settings.cstart[1] < 1){
fprintf(stderr,"ERROR: invalid argument to -cstart1\n");
usage(1);
}
/* cycles are indexed from 0 not 1 */
--settings.cstart[1];
} else if (!strcmp(argv[i], "-cstart2")){
check_arg(i,argc,"-cstart2");
settings.cstart[2] = atoi(argv[++i]);
if(settings.cstart[2] < 1){
fprintf(stderr,"ERROR: invalid argument to -cstart2\n");
usage(1);
}
/* cycles are indexed from 0 not 1 */
--settings.cstart[2];
} else if (!strcmp(argv[i], "-cstart")){
check_arg(i,argc,"-cstart");
settings.cstart[0] = atoi(argv[++i]);
if(settings.cstart[0] < 1){
fprintf(stderr,"ERROR: invalid argument to -cstart\n");
usage(1);
}
/* cycles are indexed from 0 not 1 */
--settings.cstart[0];
} else if (!strcmp(argv[i], "-nL")){
check_arg(i,argc,"-nL");
settings.n_bins_left = atoi(argv[++i]);
if(settings.n_bins_left < 0){
fprintf(stderr,"ERROR: invalid argument to -nL\n");
usage(1);
}
} else if (!strcmp(argv[i], "-nR")){
check_arg(i,argc,"-nR");
settings.n_bins_right = atoi(argv[++i]);
if(settings.n_bins_right < 0){
fprintf(stderr,"ERROR: invalid argument to -nR\n");
usage(1);
}
} else if (!strcmp(argv[i], "-h")) {
usage(0);
} else {
fprintf(stderr,"ERROR: Unknown option %s\n", argv[i]);
usage(1);
}
}
if ((argc-i) < 1)
usage(0);
/* preserve starting directory b/c makeSurvTable is going to chdir all over the place */
settings.working_dir = alloc_getcwd();
if (NULL == settings.working_dir) {
fprintf(stderr, "ERROR: can't obtain working directory: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
/* get absolute intensity dir*/
if (override_intensity_dir) {
settings.intensity_dir = get_real_path_name(override_intensity_dir);
if (NULL == settings.intensity_dir) {
fprintf(stderr, "ERROR: can't process intensity dir: %s\n",
override_intensity_dir);
exit(EXIT_FAILURE);
}
} else {
fprintf(stderr,"ERROR: you must specify an intensity dir\n");
exit(EXIT_FAILURE);
}
/* read the snp_file */
if (NULL != settings.snp_file) {
settings.snp_hash = readSnpFile(settings.snp_file);
if (NULL == settings.snp_hash) {
fprintf(stderr, "ERROR: reading snp file %s\n", settings.snp_file);
exit(EXIT_FAILURE);
}
}
/* read filter file */
if (NULL != filter_file) {
FILE *fp = fopen(filter_file, "rb");
if (!fp) die("Can't open filter file %s\n", filter_file);
Header filter_header;
readHeader(fp, &filter_header);
readFilterData(fp, &filter_header);
settings.spatial_filter = 1;
settings.region_size = filter_header.region_size;
settings.nregions_x = filter_header.nregions_x;
settings.nregions_y = filter_header.nregions_y;
}
/* Look for CIF directories */
get_cif_dirs(settings.intensity_dir);
/* open the bam file */
bam_file = argv[i++];
fp_bam = samopen(bam_file, "rb", 0);
if (NULL == fp_bam) {
fprintf(stderr, "ERROR: can't open bam file file %s: %s\n",
bam_file, strerror(errno));
exit(EXIT_FAILURE);
}
/* make the survival table */
nst = makeSurvTable(&settings, fp_bam, sts, &ntiles, &nreads);
if (0 == nst) {
fprintf(stderr,"ERROR: failed to make survival table\n");
exit(EXIT_FAILURE);
}
if (!settings.quiet) {
fprintf(stderr, "Processed %8d traces\n", nreads);
if (NULL != settings.snp_hash) {
HashIter *tileIter = HashTableIterCreate();
HashItem *hashItem;
size_t nsnps = 0;
while ((hashItem = HashTableIterNext(settings.snp_hash, tileIter)))
nsnps += hashItem->data.i;
fprintf(stderr, "Ignored %lu snps\n", nsnps);
}
}
/* back to where we belong */
checked_chdir(settings.working_dir);
if (!settings.spatial_filter) makeGlobalSurvTable(&settings, ntiles, sts);
outputSurvTable(&settings, sts);
nct = makeCalTable(&settings, sts, cts);
if (0 == nct) {
fprintf(stderr,"ERROR: failed to make calibration table\n");
exit(EXIT_FAILURE);
}
outputCalTable(&settings, cts);
/* close the bam file */
samclose(fp_bam);
freeCalTable(&settings, cts);
freeSurvTable(&settings, sts);
if (NULL != settings.working_dir) free(settings.working_dir);
return EXIT_SUCCESS;
}
void op_svget(int varnum, mval *v)
{
io_log_name *tl;
int count;
gtm_uint64_t ucount;
char *c1, *c2;
mval *mvp;
# ifdef UNIX
d_rm_struct *d_rm;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
# if defined(UNIX) && defined(DEBUG)
if (gtm_white_box_test_case_enabled && (WBTEST_HUGE_ALLOC == gtm_white_box_test_case_number))
{
if (1 == gtm_white_box_test_case_count)
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xffff;
else if (2 == gtm_white_box_test_case_count)
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff;
else if (3 == gtm_white_box_test_case_count)
{
# ifdef GTM64
if (8 == SIZEOF(size_t))
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta
= totalUsed = totalUsedGta = 0xfffffffffffffff;
else
# endif
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff;
} else
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed
= totalUsedGta = GTM64_ONLY(SIZEOF(size_t)) NON_GTM64_ONLY(SIZEOF(size_t) > 4 ? 4 : SIZEOF(size_t));
}
# endif
switch (varnum)
{
case SV_HOROLOG:
op_horolog(v);
break;
case SV_ZGBLDIR:
v->mvtype = MV_STR;
v->str = dollar_zgbldir.str;
break;
case SV_PRINCIPAL:
tl = dollar_principal ? dollar_principal : io_root_log_name->iod->trans_name;
v->str.addr = tl->dollar_io;
v->str.len = tl->len;
/*** The following should be in the I/O code ***/
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
v->mvtype = MV_STR;
break;
case SV_ZIO:
v->mvtype = MV_STR;
/* NOTE: This is **NOT** equivalent to :
* io_curr_log_name->dollar_io
*/
v->str.addr = io_curr_device.in->trans_name->dollar_io;
v->str.len = io_curr_device.in->trans_name->len;
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
break;
case SV_JOB:
*v = dollar_job;
break;
case SV_REFERENCE:
get_reference(v);
break;
case SV_SYSTEM:
*v = dollar_system;
break;
case SV_STORAGE:
/* double2mval(v, getstorage()); Causes issues with unaligned stack on x86_64 - remove until fixed */
i2mval(v, getstorage());
break;
case SV_TLEVEL:
count = (int)dollar_tlevel;
MV_FORCE_MVAL(v, count);
break;
case SV_TRESTART:
MV_FORCE_MVAL(v, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart));
break;
case SV_X:
count = (int)io_curr_device.out->dollar.x;
MV_FORCE_MVAL(v, count);
break;
case SV_Y:
count = (int)io_curr_device.out->dollar.y;
MV_FORCE_MVAL(v, count);
break;
case SV_ZA:
count = (int)io_curr_device.in->dollar.za;
MV_FORCE_MVAL(v, count);
break;
case SV_ZB:
c1 = (char *)io_curr_device.in->dollar.zb;
c2 = c1 + SIZEOF(io_curr_device.in->dollar.zb);
ENSURE_STP_FREE_SPACE(SIZEOF(io_curr_device.in->dollar.zb));
v->mvtype = MV_STR;
v->str.addr = (char *)stringpool.free;
while (c1 < c2 && *c1)
*stringpool.free++ = *c1++;
v->str.len = INTCAST((char *)stringpool.free - v->str.addr);
break;
case SV_ZC: /****THESE ARE DUMMY VALUES ONLY!!!!!!!!!!!!!!!!!****/
MV_FORCE_MVAL(v, 0);
break;
case SV_ZCMDLINE:
get_command_line(v, TRUE); /* TRUE to indicate we want $ZCMDLINE
(i.e. processed not actual command line) */
break;
case SV_ZEOF:
# ifdef UNIX
if (rm == io_curr_device.in->type)
{
d_rm = (d_rm_struct *)io_curr_device.in->dev_sp;
if (RM_READ != d_rm->lastop)
{
*v = literal_zero;
break;
}
}
# endif
*v = io_curr_device.in->dollar.zeof ? literal_one : literal_zero;
break;
case SV_ZQUIT:
*v = dollar_zquit_anyway ? literal_one : literal_zero;
break;
case SV_IO:
v->str.addr = io_curr_device.in->name->dollar_io;
v->str.len = io_curr_device.in->name->len;
/*** The following should be in the I/O code ***/
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
v->mvtype = MV_STR;
break;
case SV_PROMPT:
v->mvtype = MV_STR;
v->str.addr = (TREF(gtmprompt)).addr;
v->str.len = (TREF(gtmprompt)).len;
s2pool(&v->str);
break;
case SV_ZCOMPILE:
v->mvtype = MV_STR;
v->str = TREF(dollar_zcompile);
s2pool(&(v->str));
break;
case SV_ZDIR:
setzdir(NULL, v);
if (v->str.len != dollar_zdir.str.len || 0 != memcmp(v->str.addr, dollar_zdir.str.addr, v->str.len))
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4, v->str.len, v->str.addr,
dollar_zdir.str.len, dollar_zdir.str.addr);
SKIP_DEVICE_IF_NOT_NEEDED(v);
s2pool(&(v->str));
break;
case SV_ZSTEP:
*v = dollar_zstep;
break;
case SV_ZMODE:
*v = TREF(dollar_zmode);
break;
case SV_ZMAXTPTIME:
i2mval(v, TREF(dollar_zmaxtptime));
break;
case SV_ZPOS:
getzposition(v);
break;
case SV_ZPROC:
getzprocess();
*v = dollar_zproc;
break;
case SV_ZLEVEL:
count = dollar_zlevel();
MV_FORCE_MVAL(v, count);
break;
case SV_ZROUTINES:
if (!TREF(zro_root))
zro_init();
v->mvtype = MV_STR;
v->str = TREF(dollar_zroutines);
s2pool(&(v->str));
break;
case SV_ZSOURCE:
v->mvtype = MV_STR;
v->str = dollar_zsource.str;
break;
case SV_ZSTATUS:
*v = dollar_zstatus;
s2pool(&(v->str));
break;
case SV_ZTRAP:
v->mvtype = MV_STR;
v->str = dollar_ztrap.str;
assert(!v->str.len || !ztrap_explicit_null);
s2pool(&(v->str));
break;
case SV_DEVICE:
get_dlr_device(v);
break;
case SV_KEY:
get_dlr_key(v);
break;
case SV_ZVERSION:
v->mvtype = MV_STR;
v->str.addr = (char *)gtm_release_name;
v->str.len = gtm_release_name_len;
break;
case SV_ZSYSTEM:
MV_FORCE_MVAL(v, dollar_zsystem);
break;
case SV_ZCSTATUS:
/* Maintain the external $ZCSTATUS == 1 for SUCCESS on UNIX while internal good is 0 */
MV_FORCE_MVAL(v, UNIX_ONLY((0 == TREF(dollar_zcstatus)) ? 1 : ) TREF(dollar_zcstatus));
break;
case SV_ZEDITOR:
MV_FORCE_MVAL(v, dollar_zeditor);
break;
case SV_QUIT:
MV_FORCE_MVAL(v, dollar_quit());
break;
case SV_ECODE:
ecode_get(-1, v);
break;
case SV_ESTACK:
count = (dollar_zlevel() - 1) - dollar_estack_delta.m[0];
MV_FORCE_MVAL(v, count);
break;
case SV_ETRAP:
v->mvtype = MV_STR;
v->str = dollar_etrap.str;
assert(!v->str.len || !ztrap_explicit_null);
s2pool(&(v->str));
break;
case SV_STACK:
count = (dollar_zlevel() - 1);
MV_FORCE_MVAL(v, count);
break;
case SV_ZERROR:
v->mvtype = MV_STR;
v->str = dollar_zerror.str;
s2pool(&(v->str));
break;
case SV_ZYERROR:
v->mvtype = MV_STR;
v->str = dollar_zyerror.str;
s2pool(&(v->str));
break;
case SV_ZINTERRUPT:
v->mvtype = MV_STR;
v->str = dollar_zinterrupt.str;
s2pool(&(v->str));
break;
case SV_ZININTERRUPT:
MV_FORCE_MVAL(v, dollar_zininterrupt);
break;
case SV_ZJOB:
MV_FORCE_UMVAL(v, dollar_zjob);
break;
case SV_ZDATE_FORM:
MV_FORCE_MVAL(v, TREF(zdate_form));
break;
case SV_ZTEXIT:
*v = dollar_ztexit;
break;
case SV_ZALLOCSTOR:
ucount = (gtm_uint64_t)totalAlloc + (gtm_uint64_t)totalAllocGta;
ui82mval(v, ucount);
break;
case SV_ZREALSTOR:
ucount = (gtm_uint64_t)totalRmalloc + (gtm_uint64_t)totalRallocGta;
ui82mval(v, ucount);
break;
case SV_ZUSEDSTOR:
ucount = (gtm_uint64_t)totalUsed + (gtm_uint64_t)totalUsedGta;
ui82mval(v, ucount);
break;
case SV_ZCHSET:
v->mvtype = MV_STR;
v->str = dollar_zchset;
break;
case SV_ZPATNUMERIC:
v->mvtype = MV_STR;
v->str = dollar_zpatnumeric;
break;
case SV_ZTNAME:
case SV_ZTCODE: /* deprecated */
# ifdef GTM_TRIGGER
if (NULL == dollar_ztname)
memcpy(v, &literal_null, SIZEOF(mval));
else
{
v->mvtype = MV_STR;
v->str.addr = dollar_ztname->addr;
v->str.len = dollar_ztname->len;
}
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTDATA:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but it might be numeric and need conversion to a string */
assert(!dollar_ztdata || MV_DEFINED(dollar_ztdata));
if (NULL != dollar_ztdata)
MV_FORCE_STR(dollar_ztdata);
memcpy(v, (NULL != dollar_ztdata) ? dollar_ztdata : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTDELIM:
# ifdef GTM_TRIGGER
assert(!dollar_ztdelim || MV_DEFINED(dollar_ztdelim));
if (NULL == dollar_ztdelim || !(MV_STR & dollar_ztdelim->mvtype) || (0 == dollar_ztdelim->str.len))
memcpy(v, &literal_null, SIZEOF(mval));
else
memcpy(v, dollar_ztdelim, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTOLDVAL:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but it might be numeric and need conversion to a string */
assert(!dollar_ztoldval || MV_DEFINED(dollar_ztoldval));
if (NULL != dollar_ztoldval)
MV_FORCE_STR(dollar_ztoldval);
memcpy(v, (NULL != dollar_ztoldval) ? dollar_ztoldval : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTRIGGEROP:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but assert it's a string */
assert(!dollar_ztriggerop || (MV_STR & dollar_ztriggerop->mvtype));
memcpy(v, (NULL != dollar_ztriggerop) ? dollar_ztriggerop : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTUPDATE:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but if there were no delims involved, the value will be undefined, and
* we return a "literal_null".
*/
memcpy(v, ((NULL != dollar_ztupdate && (MV_STR & dollar_ztupdate->mvtype)) ? dollar_ztupdate
: &literal_null), SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTVALUE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
assert(!dollar_ztvalue || MV_DEFINED(dollar_ztvalue));
if (NULL != dollar_ztvalue)
MV_FORCE_STR(dollar_ztvalue);
memcpy(v, (NULL != dollar_ztvalue) ? dollar_ztvalue : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTWORMHOLE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
mvp = &dollar_ztwormhole;
if (MV_DEFINED(mvp))
{
MV_FORCE_STR(mvp);
memcpy(v, mvp, SIZEOF(mval));
} else
memcpy(v, &literal_null, SIZEOF(mval));
ztwormhole_used = TRUE;
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTSLATE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
assert(MV_DEFINED((&dollar_ztslate)));
mvp = &dollar_ztslate;
MV_FORCE_STR(mvp);
memcpy(v, mvp, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTLEVEL:
# ifdef GTM_TRIGGER
MV_FORCE_MVAL(v, gtm_trigger_depth);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZONLNRLBK:
# ifdef UNIX
count = TREF(dollar_zonlnrlbk);
MV_FORCE_MVAL(v, count);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZCLOSE:
# ifdef UNIX
count = TREF(dollar_zclose);
MV_FORCE_MVAL(v, count);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZKEY:
get_dlr_zkey(v);
break;
default:
assertpro(FALSE);
}
}
int multiboot_x86_load(int argc, char **argv, const char *buf, off_t len,
struct kexec_info *info)
/* Marshal up a multiboot-style kernel */
{
struct multiboot_info *mbi;
void *mbi_buf;
struct mod_list *modp;
unsigned long freespace;
unsigned long long mem_lower = 0, mem_upper = 0;
struct mem_ehdr ehdr;
unsigned long mbi_base;
struct entry32_regs regs;
size_t mbi_bytes, mbi_offset;
char *command_line = NULL;
char *imagename, *cp, *append = NULL;;
struct memory_range *range;
int ranges;
struct AddrRangeDesc *mmap;
int command_line_len;
int i;
uint32_t u;
int opt;
int modules, mod_command_line_space;
/* See options.h -- add any more there, too. */
static const struct option options[] = {
KEXEC_ARCH_OPTIONS
{ "command-line", 1, 0, OPT_CL },
{ "append", 1, 0, OPT_CL },
{ "reuse-cmdline", 0, 0, OPT_REUSE_CMDLINE },
{ "module", 1, 0, OPT_MOD },
{ 0, 0, 0, 0 },
};
static const char short_options[] = KEXEC_ARCH_OPT_STR "";
/* Probe for the MB header if it's not already found */
if (mbh == NULL && multiboot_x86_probe(buf, len) != 1)
{
fprintf(stderr, "Cannot find a loadable multiboot header.\n");
return -1;
}
/* Parse the command line */
command_line = "";
command_line_len = 0;
modules = 0;
mod_command_line_space = 0;
while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1)
{
switch(opt) {
default:
/* Ignore core options */
if (opt < OPT_ARCH_MAX) {
break;
}
case '?':
usage();
return -1;
case OPT_CL:
append = optarg;
break;
case OPT_REUSE_CMDLINE:
command_line = get_command_line();
break;
case OPT_MOD:
modules++;
mod_command_line_space += strlen(optarg) + 1;
break;
}
}
imagename = argv[optind];
command_line = concat_cmdline(command_line, append);
command_line_len = strlen(command_line) + strlen(imagename) + 2;
/* Load the ELF executable */
elf_exec_build_load(info, &ehdr, buf, len, 0);
/* Load the setup code */
elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size, 0,
ULONG_MAX, 1, 0);
/* The first segment will contain the multiboot headers:
* =============
* multiboot information (mbi)
* -------------
* kernel command line
* -------------
* bootloader name
* -------------
* module information entries
* -------------
* module command lines
* ==============
*/
mbi_bytes = (sizeof(*mbi) + command_line_len
+ strlen (BOOTLOADER " " BOOTLOADER_VERSION) + 1
+ 3) & ~3;
mbi_buf = xmalloc(mbi_bytes);
mbi = mbi_buf;
memset(mbi, 0, sizeof(*mbi));
sprintf(((char *)mbi) + sizeof(*mbi), "%s %s",
imagename, command_line);
sprintf(((char *)mbi) + sizeof(*mbi) + command_line_len, "%s",
BOOTLOADER " " BOOTLOADER_VERSION);
mbi->flags = MB_INFO_CMDLINE | MB_INFO_BOOT_LOADER_NAME;
/* We'll relocate these to absolute addresses later. For now,
* all addresses within the first segment are relative to the
* start of the MBI. */
mbi->cmdline = sizeof(*mbi);
mbi->boot_loader_name = sizeof(*mbi) + command_line_len;
/* Memory map */
if ((get_memory_ranges(&range, &ranges, info->kexec_flags) < 0)
|| ranges == 0) {
fprintf(stderr, "Cannot get memory information\n");
return -1;
}
mmap = xmalloc(ranges * sizeof(*mmap));
for (i=0; i<ranges; i++) {
unsigned long long length;
length = range[i].end - range[i].start;
/* Translate bzImage mmap to multiboot-speak */
mmap[i].size = sizeof(mmap[i]) - 4;
mmap[i].base_addr_low = range[i].start & 0xffffffff;
mmap[i].base_addr_high = range[i].start >> 32;
mmap[i].length_low = length & 0xffffffff;
mmap[i].length_high = length >> 32;
if (range[i].type == RANGE_RAM) {
mmap[i].Type = 1; /* RAM */
/* Is this the "low" memory? */
if ((range[i].start == 0)
&& (range[i].end > mem_lower))
mem_lower = range[i].end;
/* Is this the "high" memory? */
if ((range[i].start <= 0x100000)
&& (range[i].end > mem_upper + 0x100000))
mem_upper = range[i].end - 0x100000;
}
else
mmap[i].Type = 0xbad; /* Not RAM */
}
if (mbh->flags & MULTIBOOT_MEMORY_INFO) {
/* Provide a copy of the memory map to the kernel */
mbi->flags |= MB_INFO_MEMORY | MB_INFO_MEM_MAP;
freespace = add_buffer(info,
mmap, ranges * sizeof(*mmap), ranges * sizeof(*mmap),
4, 0, 0xFFFFFFFFUL, 1);
mbi->mmap_addr = freespace;
mbi->mmap_length = ranges * sizeof(*mmap);
/* For kernels that care naught for fancy memory maps
* and just want the size of low and high memory */
mbi->mem_lower = MIN(mem_lower>>10, 0xffffffff);
mbi->mem_upper = MIN(mem_upper>>10, 0xffffffff);
/* done */
}
static void process_command_line(int argc, char **argv, AMA_OPTIONS_T *options) {
int option_index = 0;
const int num_options = 16;
struct option ama_options[] = {
{"max-seq-length", required_argument, NULL, OPT_MAX_SEQ_LENGTH},
{"motif", required_argument, NULL, OPT_MOTIF},
{"motif-pseudo", required_argument, NULL, OPT_MOTIF_PSEUDO},
{"rma", no_argument, NULL, OPT_RMA},
{"pvalues", no_argument, NULL, OPT_PVALUES},
{"sdbg", required_argument, NULL, OPT_SDBG},
{"norc", no_argument, NULL, OPT_NORC},
{"cs", no_argument, NULL, OPT_CS},
{"o-format", required_argument, NULL, OPT_O_FORMAT},
{"o", required_argument, NULL, OPT_O},
{"oc", required_argument, NULL, OPT_OC},
{"scoring", required_argument, NULL, OPT_SCORING},
{"verbosity", required_argument, NULL, OPT_VERBOSITY},
{"gcbins", required_argument, NULL, OPT_GCBINS},
{"last", required_argument, NULL, OPT_LAST},
{"version", no_argument, NULL, OPT_VERSION},
{NULL, 0, NULL, 0} //boundary indicator
};
bool out_set = false;
bool format_set = false;
// set option defaults
options->max_seq_length = MAX_SEQ;
options->scan_both_strands = true;
options->combine_duplicates = false;
options->selected_motifs = rbtree_create(rbtree_strcmp, NULL, NULL, NULL, NULL);
options->pseudocount = DEFAULT_PSEUDOCOUNT;
options->output_format = CISML_FORMAT;
options->clobber = false;
options->out_dir = NULL;
options->scoring = AVG_ODDS;
options->pvalues = false;
options->normalize_scores = false;
options->num_gc_bins = 1;
options->sdbg_order = -1;
options->last = 0;
options->motif_filename = NULL;
options->fasta_filename = NULL;
options->bg_filename = NULL;
// parse command line
while (1) {
int opt = getopt_long_only(argc, argv, "", ama_options, NULL);
if (opt == -1) break;
switch (opt) {
case OPT_MAX_SEQ_LENGTH:
options->max_seq_length = atoi(optarg);
break;
case OPT_MOTIF:
rbtree_make(options->selected_motifs, optarg, NULL);
break;
case OPT_MOTIF_PSEUDO:
options->pseudocount = atof(optarg);
break;
case OPT_RMA:
options->normalize_scores = true;
break;
case OPT_PVALUES:
options->pvalues = true;
break;
case OPT_SDBG:
options->sdbg_order = atoi(optarg); // >=0 means use sequence bkg
break;
case OPT_NORC:
options->scan_both_strands = false;
break;
case OPT_CS:
options->combine_duplicates = true;
break;
case OPT_O_FORMAT:
if (out_set) {
usage("Option -o-format is incompatible with option -o/-oc");
} else {
format_set = true;
if (strcmp(optarg, "gff") == 0) {
options->output_format = GFF_FORMAT;
} else if (strcmp(optarg, "cisml") == 0) {
options->output_format = CISML_FORMAT;
} else {
usage("Output format \"%s\" is not recognised. "
"Expected \"gff\" or \"cisml\".", optarg);
}
}
break;
case OPT_OC:
options->clobber = true;
case OPT_O:
if (format_set) {
usage("Option -o/-oc is incompatible with option -o-format");
} else {
out_set = true;
options->out_dir = optarg;
options->output_format = DIRECTORY_FORMAT;
}
break;
case OPT_SCORING:
if (strcmp(optarg, "max-odds") == 0) {
options->scoring = MAX_ODDS;
} else if (strcmp(optarg, "avg-odds") == 0) {
options->scoring = AVG_ODDS;
} else if (strcmp(optarg, "sum-odds") == 0) {
options->scoring = SUM_ODDS;
} else {
usage("Scoring method \"%s\" is not recognised. "
"Expected \"max-odds\", \"avg-odds\" or \"sum-odds\".", optarg);
}
break;
case OPT_VERBOSITY:
verbosity = atoi(optarg);
break;
case OPT_GCBINS:
options->num_gc_bins = atoi(optarg);
options->pvalues = true;
if (options->num_gc_bins <= 1)
usage("Number of bins in --gcbins must be greater than 1.");
break;
case OPT_LAST:
options->last = atoi(optarg);
if (options->last < 0) usage("Option --last must not be negative.");
break;
case OPT_VERSION:
fprintf(stdout, VERSION "\n");
exit(EXIT_SUCCESS);
break;
case '?': //unrecognised or ambiguous argument
usage("Unrecognized or ambiguous option.");
}
}
// --sdbg overrides --pvalues and --gcbins and --rma
if (options->sdbg_order >= 0) {
options->pvalues = false;
options->normalize_scores = false;
options->num_gc_bins = 1;
}
if (argc <= optind) usage("Expected motif file.");
options->motif_filename = argv[optind++];
if (argc <= optind) usage("Expected fasta file.");
options->fasta_filename = argv[optind++];
if (argc > optind) options->bg_filename = argv[optind++];
if (options->sdbg_order >= 0) {
if (options->bg_filename) usage("A background file can not be used together with --sdbg.");
} else {
if (!options->bg_filename) usage("You must provide a background file unless you specify --sdbg.");
}
if (argc > optind) usage("Too many parameters");
// for now, use uniform to mimic old implementation. I will probably remove this later
if (!options->bg_filename) options->bg_filename = "--uniform--";
// Record the command line.
options->command_line = get_command_line(argc, argv);
}
void OutputStream::write_header()
{
this->printf("# File \"%s\": generated at %s by the command:\n"
"# %s\n",
s_filename, get_timestamp(), get_command_line());
}
int builtin_man(t_link *link, char **cmd)
{
(void)cmd;
get_command_line(link, my_strdup("cat < .man42sh | less"), 0);
return (TRUE);
}
int main (int argc, char * argv[])
{
std::streambuf *psbuf = NULL;
std::ofstream log_stream;
std::streambuf *pStreambuf = std::cout.rdbuf();
//--------------RNG INIT STUFF
srand((unsigned)time(0));
long seed;
r = gsl_rng_alloc (gsl_rng_rand48); // pick random number generator
seed = time (NULL) * getpid();
gsl_rng_set (r, seed); // set seed
// TESTING AREA
//---------------
DBN *dbn;
if (command_option_exists(argv, argv+argc, "-n")) {
dbn = return_network();
std::cout << dbn << std::endl;
std::cout << "Ready to learn" << std::endl;
std::cout << "If you are using visualization:" << std::endl;
std::cout << "'V': pauses visualization" << std::endl;
std::cout << "<SPACE>: pauses learning" << std::endl;
std::cout << "'+'/'-' increases/decreases learning rate" << std::endl;
std::cout << "'['/']' increases/decreases output threshold" << std::endl;
std::cout << "'L' stops learning for layer (skips to next if any)" << std::endl;
std::cout << "Current visualization is the features displayed on top with the plot of the reconstruction cost in the box (gl text not supported yet)" << std::endl;
std::cout << "Press <ENTER> to start learning: ";
std::cin.get();
}
else if (command_option_exists(argv, argv+argc, "-l")) {
std::string filename = get_command_line(argv, argv+argc, "-l");
MLP mlp = load_MLP(filename);
dbn = new DBN(mlp);
dbn->data_layers.clear();
dbn->view();
exit(EXIT_SUCCESS);
}
else if (command_option_exists(argv, argv+argc, "-f")) {
if (argc != 3) {
print_usage();
exit(EXIT_FAILURE);
}
//Initialization, time, logfile stuff, etc.
time_t t = time(0); // get time now
struct tm * the_time = localtime( & t );
mkdir(out_path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
out_path += convert_to_string(*the_time) + "/";
mkdir((out_path).c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
std::string filename = get_command_line(argv, argv+argc, "-f");
dbn = return_aod_network(filename, log_stream, psbuf);
}
else if (command_option_exists(argv, argv+argc, "-F")) {
std::string filename = get_command_line(argv, argv+argc, "-F");
MLP mlp = load_MLP(filename);
Autoencoder ae(mlp);
ae.name = (mlp).name + "fine_tuning";
Gradient_Descent gd(0);
gd.teachAE(ae);
MLP ae_mlp;
save(ae);
exit(EXIT_SUCCESS);
}
else if (command_option_exists(argv, argv+argc, "-stack")) {
std::string filename = get_command_line(argv, argv+argc, "-stack");
dbn = load_and_stack(filename, log_stream, psbuf);
}
else {
print_usage();
exit(EXIT_SUCCESS);
}
ContrastiveDivergence cd(1000);
dbn->learn(cd);
std::cout.rdbuf(pStreambuf);
log_stream.close();
exit(1);
return 0;
}
static errno_t __cdecl common_configure_argv(_crt_argv_mode const mode) throw()
{
typedef __crt_char_traits<Character> traits;
_VALIDATE_RETURN_ERRCODE(
mode == _crt_argv_expanded_arguments ||
mode == _crt_argv_unexpanded_arguments, EINVAL);
do_locale_initialization(Character());
static Character program_name[MAX_PATH + 1];
traits::get_module_file_name(nullptr, program_name, MAX_PATH);
traits::set_program_name(&program_name[0]);
// If there's no command line at all, then use the program name as the
// command line to parse, so that argv[0] is initialized with the program
// name. (This won't happen when the program is run by cmd.exe, but it
// could happen if the program is spawned via some other means.)
Character* const raw_command_line = get_command_line(Character());
Character* const command_line = raw_command_line == nullptr || raw_command_line[0] == '\0'
? program_name
: raw_command_line;
size_t argument_count = 0;
size_t character_count = 0;
parse_command_line(
command_line,
static_cast<Character**>(nullptr),
static_cast<Character*>(nullptr),
&argument_count,
&character_count);
__crt_unique_heap_ptr<unsigned char> buffer(__acrt_allocate_buffer_for_argv(
argument_count,
character_count,
sizeof(Character)));
_VALIDATE_RETURN_ERRCODE_NOEXC(buffer, ENOMEM);
Character** const first_argument = reinterpret_cast<Character**>(buffer.get());
Character* const first_string = reinterpret_cast<Character*>(buffer.get() + argument_count * sizeof(Character*));
parse_command_line(command_line, first_argument, first_string, &argument_count, &character_count);
// If we are not expanding wildcards, then we are done...
if (mode == _crt_argv_unexpanded_arguments)
{
__argc = static_cast<int>(argument_count - 1);
get_argv(Character()) = reinterpret_cast<Character**>(buffer.detach());
return 0;
}
// ... otherwise, we try to do the wildcard expansion:
__crt_unique_heap_ptr<Character*> expanded_argv;
errno_t const argv_expansion_status = expand_argv_wildcards(first_argument, expanded_argv.get_address_of());
if (argv_expansion_status != 0)
return argv_expansion_status;
__argc = [&]()
{
size_t n = 0;
for (auto it = expanded_argv.get(); *it; ++it, ++n) { }
return static_cast<int>(n);
}();
get_argv(Character()) = expanded_argv.detach();
return 0;
}
/*******************************************************
Function: ld_compile
*******************************************************/
string
ld_compile (bfd *abfd)
{
string input_path;
string output_path;
int argc;
string *argv;
int child_pid;
int statptr;
string file_name = (string)abfd->filename;
if (tmpdir == 0)
if (create_tmpdir (FALSE) != 0) {
fprintf(stderr,"create_tmpdir() failed for %s\n",abfd->filename);
exit(1);
}
if ((input_path = create_unique_file (file_name, 'B')) == 0) {
fprintf(stderr,"create_unique_file() failed for %s\n",abfd->filename);
exit(1);
}
if (abfd->arelt_data) {
if (extract_archive_member (abfd, input_path) != 0) {
fprintf(stderr,"extract_archive_member() failed for %s\n",abfd->filename);
exit(1);
}
} else {
UNLINK (input_path);
if (make_link (file_name, input_path) != 0) {
fprintf(stderr,"make_link() failed for %s\n",abfd->filename);
exit(1);
}
}
if ((output_path = create_unique_file (file_name, 'o')) == 0) {
fprintf(stderr,"create_unique_file() failed for %s\n",abfd->filename);
exit(1);
}
add_to_tmp_file_list (output_path);
add_to_tmp_file_list (input_path);
argv = get_command_line (abfd, input_path, output_path, &argc);
if (ld_ipa_opt[LD_IPA_VERBOSE].flag || ld_ipa_opt[LD_IPA_SHOW].flag)
fprintf(stderr,"Compiling %s\n",abfd->filename);
child_pid = do_compile (argv);
(void) waitpid (child_pid, &statptr, 0);
if (statptr != 0 && WEXITSTATUS(statptr) != 0)
{
fprintf(stderr,"Compile of %s failed!\n",abfd->filename);
exit(1);
}
active_pid = 0;
FREE (argv);
UNLINK (input_path);
remove_from_tmp_file_list (input_path);
FREE (input_path);
return output_path;
} /* ld_compile */
int elf_x86_load(int argc, char **argv, const char *buf, off_t len,
struct kexec_info *info)
{
struct mem_ehdr ehdr;
char *command_line = NULL, *modified_cmdline = NULL;
const char *append = NULL;
char *tmp_cmdline = NULL;
char *error_msg = NULL;
int result;
int command_line_len;
const char *ramdisk;
unsigned long entry, max_addr;
int arg_style;
#define ARG_STYLE_ELF 0
#define ARG_STYLE_LINUX 1
#define ARG_STYLE_NONE 2
int opt;
/* See options.h -- add any more there, too. */
static const struct option options[] = {
KEXEC_ARCH_OPTIONS
{ "command-line", 1, NULL, OPT_APPEND },
{ "append", 1, NULL, OPT_APPEND },
{ "reuse-cmdline", 0, NULL, OPT_REUSE_CMDLINE },
{ "initrd", 1, NULL, OPT_RAMDISK },
{ "ramdisk", 1, NULL, OPT_RAMDISK },
{ "args-elf", 0, NULL, OPT_ARGS_ELF },
{ "args-linux", 0, NULL, OPT_ARGS_LINUX },
{ "args-none", 0, NULL, OPT_ARGS_NONE },
{ 0, 0, NULL, 0 },
};
static const char short_options[] = KEXEC_OPT_STR "";
/*
* Parse the command line arguments
*/
arg_style = ARG_STYLE_ELF;
ramdisk = 0;
result = 0;
while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) {
switch(opt) {
default:
/* Ignore core options */
if (opt < OPT_ARCH_MAX) {
break;
}
case OPT_APPEND:
append = optarg;
break;
case OPT_REUSE_CMDLINE:
tmp_cmdline = get_command_line();
break;
case OPT_RAMDISK:
ramdisk = optarg;
break;
case OPT_ARGS_ELF:
arg_style = ARG_STYLE_ELF;
break;
case OPT_ARGS_LINUX:
arg_style = ARG_STYLE_LINUX;
break;
case OPT_ARGS_NONE:
#ifdef __i386__
arg_style = ARG_STYLE_NONE;
#else
die("--args-none only works on arch i386\n");
#endif
break;
}
}
command_line = concat_cmdline(tmp_cmdline, append);
if (tmp_cmdline) {
free(tmp_cmdline);
}
command_line_len = 0;
if (command_line) {
command_line_len = strlen(command_line) +1;
} else {
command_line = strdup("\0");
command_line_len = 1;
}
/* Need to append some command line parameters internally in case of
* taking crash dumps.
*/
if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) {
modified_cmdline = xmalloc(COMMAND_LINE_SIZE);
memset((void *)modified_cmdline, 0, COMMAND_LINE_SIZE);
if (command_line) {
strncpy(modified_cmdline, command_line,
COMMAND_LINE_SIZE);
modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0';
}
}
/* Load the ELF executable */
elf_exec_build_load(info, &ehdr, buf, len, 0);
entry = ehdr.e_entry;
max_addr = elf_max_addr(&ehdr);
/* Do we want arguments? */
if (arg_style != ARG_STYLE_NONE) {
/* Load the setup code */
elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size,
0, ULONG_MAX, 1, 0);
}
if (arg_style == ARG_STYLE_NONE) {
info->entry = (void *)entry;
}
else if (arg_style == ARG_STYLE_ELF) {
unsigned long note_base;
struct entry32_regs regs;
uint32_t arg1, arg2;
/* Setup the ELF boot notes */
note_base = elf_boot_notes(info, max_addr,
command_line, command_line_len);
/* Initialize the stack arguments */
arg2 = 0; /* No return address */
arg1 = note_base;
elf_rel_set_symbol(&info->rhdr, "stack_arg32_1", &arg1, sizeof(arg1));
elf_rel_set_symbol(&info->rhdr, "stack_arg32_2", &arg2, sizeof(arg2));
/* Initialize the registers */
elf_rel_get_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs));
regs.eip = entry; /* The entry point */
regs.esp = elf_rel_get_addr(&info->rhdr, "stack_arg32_2");
elf_rel_set_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs));
if (ramdisk) {
error_msg = "Ramdisks not supported with generic elf arguments";
goto out;
}
}
else if (arg_style == ARG_STYLE_LINUX) {
struct x86_linux_faked_param_header *hdr;
unsigned long param_base;
const char *ramdisk_buf;
off_t ramdisk_length;
struct entry32_regs regs;
int rc = 0;
/* Get the linux parameter header */
hdr = xmalloc(sizeof(*hdr));
/* Hack: With some ld versions, vmlinux program headers show
* a gap of two pages between bss segment and data segment
* but effectively kernel considers it as bss segment and
* overwrites the any data placed there. Hence bloat the
* memsz of parameter segment to 16K to avoid being placed
* in such gaps.
* This is a makeshift solution until it is fixed in kernel
*/
param_base = add_buffer(info, hdr, sizeof(*hdr), 16*1024,
16, 0, max_addr, 1);
/* Initialize the parameter header */
memset(hdr, 0, sizeof(*hdr));
init_linux_parameters(&hdr->hdr);
/* Add a ramdisk to the current image */
ramdisk_buf = NULL;
ramdisk_length = 0;
if (ramdisk) {
ramdisk_buf = slurp_file(ramdisk, &ramdisk_length);
}
/* If panic kernel is being loaded, additional segments need
* to be created. */
if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) {
rc = load_crashdump_segments(info, modified_cmdline,
max_addr, 0);
if (rc < 0) {
result = -1;
goto out;
}
/* Use new command line. */
free(command_line);
command_line = modified_cmdline;
command_line_len = strlen(modified_cmdline) + 1;
modified_cmdline = NULL;
}
/* Tell the kernel what is going on */
setup_linux_bootloader_parameters(info, &hdr->hdr, param_base,
offsetof(struct x86_linux_faked_param_header, command_line),
command_line, command_line_len,
ramdisk_buf, ramdisk_length);
/* Fill in the information bios calls would usually provide */
setup_linux_system_parameters(info, &hdr->hdr);
/* Initialize the registers */
elf_rel_get_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs));
regs.ebx = 0; /* Bootstrap processor */
regs.esi = param_base; /* Pointer to the parameters */
regs.eip = entry; /* The entry point */
regs.esp = elf_rel_get_addr(&info->rhdr, "stack_end"); /* Stack, unused */
elf_rel_set_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs));
}
else {
bool
tool_trace_mode(vogl::vector<command_line_param_desc> *desc)
{
arguments_t args;
if (desc)
{
desc->append(g_command_line_param_descs_dump, VOGL_ARRAY_SIZE(g_command_line_param_descs_dump));
desc->append(g_tracer_cmdline_opts, VOGL_ARRAY_SIZE(g_tracer_cmdline_opts));
return true;
}
// Get steam gameid / local application name.
args.gameid = g_command_line_params().get_value_as_string_or_empty("", 1);
if (!args.gameid.size())
errorf(VOGL_FUNCTION_INFO_CSTR, "ERROR: No application or steamid specified.\n");
// Get logfile and tracefile names.
args.vogl_tracefile = g_command_line_params().get_value_as_string("vogl_tracefile");
args.vogl_logfile = g_command_line_params().get_value_as_string("vogl_logfile");
args.dryrun = g_command_line_params().get_value_as_bool("dry-run");
args.xterm = g_command_line_params().get_value_as_bool("xterm");
// Loop through all the arguments looking for "vogl_*".
for (vogl::command_line_params::param_map_const_iterator param = g_command_line_params().begin();
param != g_command_line_params().end();
++param)
{
const dynamic_string &first = param->first;
// If this is a vogl command and it's not logfile / tracefile, add it to the vogl_cmdline.
const dynamic_string prefix = param->first.get_clone().left(5);
if (prefix == "vogl_" && (first != "vogl_logfile" && first != "vogl_tracefile"))
{
args.vogl_cmdline += " --" + first;
for (uint32_t i = 0; i < param->second.m_values.size(); i++)
{
args.vogl_cmdline += " " + param->second.m_values[i];
}
}
}
// Check for -- or --args and add everything after to game_args.
const dynamic_string& command_line = get_command_line();
int args_index = command_line.find_left("-- ");
if (args_index == -1)
args_index = command_line.find_left("--args ");
if (args_index != -1)
{
args_index = command_line.find_left(' ', args_index);
if (args_index != -1)
{
args.game_args += command_line.get_clone().right(args_index + 1);
}
}
bool is_steam_file = true;
if (atoi(args.gameid.c_str()) == 0)
{
if (access(args.gameid.c_str(), F_OK))
errorf(VOGL_FUNCTION_INFO_CSTR, "\nCould not find executable '%s'\n", args.gameid.c_str());
char *filename = realpath(args.gameid.c_str(), NULL);
if (filename)
{
// This is a local executable.
is_steam_file = false;
args.gameid = filename;
free(filename);
}
}
int steam_appid = is_steam_file ? atoi(args.gameid.c_str()) : -1;
if (!steam_appid)
errorf(VOGL_FUNCTION_INFO_CSTR, "ERROR: Could not find game number for %s\n", args.gameid.c_str());
dynamic_string gameid_str;
if (is_steam_file)
{
gameid_str = "appid" + args.gameid;
vogl_printf("\nGame AppID: %d", steam_appid);
const char *game_name = get_game_name(steam_appid);
if (game_name)
{
dynamic_string game_name_str(cVarArg, "%s", game_name);
vogl_printf(" (%s)", game_name_str.c_str());
// Trim some characters that don't go well with filenames.
game_name_str.replace(" ", "_");
game_name_str.replace(":", "");
game_name_str.replace("'", "");
game_name_str.replace("!", "");
game_name_str.replace("?", "");
gameid_str += "_" + game_name_str;
}
vogl_printf("\n");
}
else
{
gameid_str = basename((char *)args.gameid.c_str());
vogl_printf("\nGame: %s\n", args.gameid.c_str());
}
// If a tracefile / logfile wasn't specified, set em up.
if (!args.vogl_tracefile.size() || !args.vogl_logfile.size())
{
char timestr[200];
time_t t = time(NULL);
timestr[0] = 0;
struct tm *tmp = localtime(&t);
if (tmp)
{
strftime(timestr, sizeof(timestr), "%Y_%m_%d-%H_%M_%S", tmp);
}
dynamic_string fname(cVarArg, "%s/vogltrace.%s.%s", P_tmpdir, gameid_str.c_str(), timestr);
if (!args.vogl_tracefile.size())
args.vogl_tracefile = fname + ".bin";
if (!args.vogl_logfile.size())
args.vogl_logfile = fname + ".log";
}
vogl_printf("\n");
vogl_message_printf("Tracefile: %s\n", args.vogl_tracefile.c_str());
vogl_message_printf("Logfile: %s", args.vogl_logfile.c_str());
vogl_printf(" (will have PID appended)\n");
dynamic_string vogltracepath32 = getfullpath("libvogltrace32.so");
dynamic_string vogltracepath64 = getfullpath("libvogltrace64.so");
// set up LD_PRELOAD string
dynamic_string LD_PRELOAD = "LD_PRELOAD=\"";
LD_PRELOAD += vogltracepath32 + ":" + vogltracepath64;
if (is_steam_file || getenv("LD_PRELOAD"))
LD_PRELOAD += ":$LD_PRELOAD";
LD_PRELOAD += "\" ";
vogl_printf("\n%s\n", LD_PRELOAD.c_str());
// set up VOGL_CMD_LINE string
dynamic_string VOGL_CMD_LINE = "VOGL_CMD_LINE=\"";
VOGL_CMD_LINE += "--vogl_tracefile " + args.vogl_tracefile;
VOGL_CMD_LINE += " --vogl_logfile " + args.vogl_logfile;
VOGL_CMD_LINE += args.vogl_cmdline;
VOGL_CMD_LINE += "\"";
vogl_printf("\n%s\n", VOGL_CMD_LINE.c_str());
dynamic_string xterm_str;
if (args.xterm)
{
xterm_str = "xterm -geom 120x80+20+20";
const char *env_user = getenv("USER");
// If this is mikesart, specify using the Consolas font (which he likes).
if (env_user && !strcmp(env_user, "mikesart"))
xterm_str += " -fa Consolas -fs 10";
// Add the xterm command part.
xterm_str += " -e ";
}
if (is_steam_file)
{
// set up xterm string
dynamic_string steam_cmd_str;
steam_cmd_str = xterm_str + "%command% " + args.game_args;
steam_cmd_str.trim();
// set up steam string
dynamic_string steam_str = "steam steam://run/" + args.gameid + "//";
dynamic_string steam_args = VOGL_CMD_LINE + " " + LD_PRELOAD + steam_cmd_str;
dynamic_string steam_fullcmd = steam_str + url_encode(steam_args.c_str());
// Spew this whole mess out.
vogl_printf("\nLaunch string:\n%s\n", (steam_str + steam_args).c_str());
vogl_printf("\nURL encoded launch string:\n%s\n", steam_fullcmd.c_str());
// And launch it...
if (!args.dryrun)
system(steam_fullcmd.c_str());
}
else
{
dynamic_string system_cmd;
system_cmd = VOGL_CMD_LINE + " " + LD_PRELOAD + " " + xterm_str + args.gameid + " " + args.game_args;
vogl_printf("\nlaunch string:\n%s\n", system_cmd.c_str());
if (!args.dryrun)
system(system_cmd.c_str());
}
return true;
}
