static void handle_builtin(int argc, const char **argv)
{
const char *cmd = argv[0];
int i;
static const char ext[] = STRIP_EXTENSION;
struct cmd_struct *builtin;
if (sizeof(ext) > 1) {
i = strlen(argv[0]) - strlen(ext);
if (i > 0 && !strcmp(argv[0] + i, ext)) {
char *argv0 = xstrdup(argv[0]);
argv[0] = cmd = argv0;
argv0[i] = '\0';
}
}
/* Turn "git cmd --help" into "git help cmd" */
if (argc > 1 && !strcmp(argv[1], "--help")) {
argv[1] = argv[0];
argv[0] = cmd = "help";
}
builtin = get_builtin(cmd);
if (builtin) {
if (saved_environment && (builtin->option & NO_SETUP))
restore_env();
else
exit(run_builtin(builtin, argc, argv));
}
}
static int ckpt_cb(void *arg)
{
int rc, ret;
const struct cr_restart_info* ri;
if (MPIDI_Process.my_pg_rank == 0) {
MPIDI_nem_ckpt_start_checkpoint = TRUE;
/* poke the progress engine in case we're waiting in a blocking recv */
MPIDI_CH3_Progress_signal_completion();
}
do {
ret = sem_wait(&ckpt_sem);
} while (ret == -1 && errno == EINTR);
CHECK_ERR(ret, "sem_wait");
if (MPID_nem_netmod_func->ckpt_precheck) {
int mpi_errno;
mpi_errno = MPID_nem_netmod_func->ckpt_precheck();
CHECK_ERR_MPI(mpi_errno, mpi_errno, "ckpt_precheck failed");
}
rc = cr_checkpoint(0);
if (rc < 0) {
ckpt_result = CKPT_ERROR;
} else if (rc) {
ckpt_result = CKPT_RESTART;
ri = cr_get_restart_info();
CHECK_ERR(!ri, "cr_get_restart_info");
ret = restore_env(ri->requester, MPIDI_Process.my_pg_rank);
CHECK_ERR(ret, "restore_env");
ret = restore_stdinouterr(MPIDI_Process.my_pg_rank);
CHECK_ERR(ret, "restore_stdinouterr");
ret = reinit_pmi();
CHECK_ERR(ret, "reinit_pmi");
if (MPID_nem_netmod_func->ckpt_restart) {
int mpi_errno;
mpi_errno = MPID_nem_netmod_func->ckpt_restart();
CHECK_ERR_MPI(mpi_errno, mpi_errno, "ckpt_restart failed");
}
} else {
ckpt_result = CKPT_CONTINUE;
if (MPID_nem_netmod_func->ckpt_continue) {
int mpi_errno;
mpi_errno = MPID_nem_netmod_func->ckpt_continue();
CHECK_ERR_MPI(mpi_errno, mpi_errno, "ckpt_continue failed");
}
}
do {
ret = sem_post(&cont_sem);
} while (ret == -1 && errno == EINTR);
CHECK_ERR(ret, "sem_post");
return 0;
}
void method_return_value(Optr value)
{
uns_int size = GET_SIZE(current_env());
restore_env();
ZAPN_EXP(CONTEXT_SIZE + size);
POKE_EXP(0, value);
t_return();
}
static bool test_socket_wrapper_default_iface(struct torture_context *tctx)
{
backup_env();
unsetenv("SOCKET_WRAPPER_DEFAULT_IFACE");
torture_assert_int_equal(tctx, socket_wrapper_default_iface(), 1, "unset");
setenv("SOCKET_WRAPPER_DEFAULT_IFACE", "2", 1);
torture_assert_int_equal(tctx, socket_wrapper_default_iface(), 2, "unset");
setenv("SOCKET_WRAPPER_DEFAULT_IFACE", "bla", 1);
torture_assert_int_equal(tctx, socket_wrapper_default_iface(), 1, "unset");
restore_env();
return true;
}
static bool test_socket_wrapper_dir(struct torture_context *tctx)
{
backup_env();
setenv("SOCKET_WRAPPER_DIR", "foo", 1);
torture_assert_str_equal(tctx, socket_wrapper_dir(), "foo", "setting failed");
setenv("SOCKET_WRAPPER_DIR", "./foo", 1);
torture_assert_str_equal(tctx, socket_wrapper_dir(), "foo", "setting failed");
unsetenv("SOCKET_WRAPPER_DIR");
torture_assert_str_equal(tctx, socket_wrapper_dir(), NULL, "resetting failed");
restore_env();
return true;
}
static bool test_swrap_socket(struct torture_context *tctx)
{
backup_env();
setenv("SOCKET_WRAPPER_DIR", "foo", 1);
torture_assert_int_equal(tctx, swrap_socket(1337, 1337, 0), -1, "unknown address family fails");
torture_assert_int_equal(tctx, errno, EAFNOSUPPORT, "correct errno set");
torture_assert_int_equal(tctx, swrap_socket(AF_INET, 1337, 0), -1, "unknown type fails");
torture_assert_int_equal(tctx, errno, EPROTONOSUPPORT, "correct errno set");
torture_assert_int_equal(tctx, swrap_socket(AF_INET, SOCK_DGRAM, 10), -1, "unknown protocol fails");
torture_assert_int_equal(tctx, errno, EPROTONOSUPPORT, "correct errno set");
restore_env();
return true;
}
int sh_exit(char **req, char ***env)
{
int val;
(void)env;
val = 0;
if (req[1] && req[2] && req[2] != '\0')
{
write(2, "exit: too many arguments\n", 25);
return (-1);
}
val = ft_atoi(req[1]);
restore_env(1);
write(1, "exit\n", 5);
exit(val);
return (0);
}
int deal_with_env(t_lst *node, char *line)
{
char **save;
char **arg;
arg = ft_strsplit(line, ' ');
arg++;
if (*arg)
{
if (*arg[0] == '-')
save = deal_with_opt(node, arg);
else
save = deal_with_arg(node, arg);
if (!save || !*save)
return (-1);
restore_env(node, save);
free(save);
}
else
print_env(node);
return (-1);
}
static int handle_alias(int *argcp, const char ***argv)
{
int envchanged = 0, ret = 0, saved_errno = errno;
int count, option_count;
const char **new_argv;
const char *alias_command;
char *alias_string;
int unused_nongit;
save_env_before_alias();
setup_git_directory_gently(&unused_nongit);
alias_command = (*argv)[0];
alias_string = alias_lookup(alias_command);
if (alias_string) {
if (alias_string[0] == '!') {
struct child_process child = CHILD_PROCESS_INIT;
commit_pager_choice();
restore_env(1);
child.use_shell = 1;
argv_array_push(&child.args, alias_string + 1);
argv_array_pushv(&child.args, (*argv) + 1);
ret = run_command(&child);
if (ret >= 0) /* normal exit */
exit(ret);
die_errno("While expanding alias '%s': '%s'",
alias_command, alias_string + 1);
}
count = split_cmdline(alias_string, &new_argv);
if (count < 0)
die("Bad alias.%s string: %s", alias_command,
split_cmdline_strerror(count));
option_count = handle_options(&new_argv, &count, &envchanged);
if (envchanged)
die("alias '%s' changes environment variables\n"
"You can use '!git' in the alias to do this.",
alias_command);
memmove(new_argv - option_count, new_argv,
count * sizeof(char *));
new_argv -= option_count;
if (count < 1)
die("empty alias for %s", alias_command);
if (!strcmp(alias_command, new_argv[0]))
die("recursive alias: %s", alias_command);
trace_argv_printf(new_argv,
"trace: alias expansion: %s =>",
alias_command);
REALLOC_ARRAY(new_argv, count + *argcp);
/* insert after command name */
memcpy(new_argv + count, *argv + 1, sizeof(char *) * *argcp);
*argv = new_argv;
*argcp += count - 1;
ret = 1;
}
restore_env(0);
errno = saved_errno;
return ret;
}
static int handle_alias(int *argcp, const char ***argv)
{
int envchanged = 0, ret = 0, saved_errno = errno;
int count, option_count;
const char **new_argv;
const char *alias_command;
char *alias_string;
int unused_nongit;
save_env_before_alias();
setup_git_directory_gently(&unused_nongit);
alias_command = (*argv)[0];
alias_string = alias_lookup(alias_command);
if (alias_string) {
if (alias_string[0] == '!') {
const char **alias_argv;
int argc = *argcp, i;
commit_pager_choice();
restore_env(1);
/* build alias_argv */
alias_argv = xmalloc(sizeof(*alias_argv) * (argc + 1));
alias_argv[0] = alias_string + 1;
for (i = 1; i < argc; ++i)
alias_argv[i] = (*argv)[i];
alias_argv[argc] = NULL;
ret = run_command_v_opt(alias_argv, RUN_USING_SHELL);
if (ret >= 0) /* normal exit */
exit(ret);
die_errno("While expanding alias '%s': '%s'",
alias_command, alias_string + 1);
}
count = split_cmdline(alias_string, &new_argv);
if (count < 0)
die("Bad alias.%s string: %s", alias_command,
split_cmdline_strerror(count));
option_count = handle_options(&new_argv, &count, &envchanged);
if (envchanged)
die("alias '%s' changes environment variables\n"
"You can use '!git' in the alias to do this.",
alias_command);
memmove(new_argv - option_count, new_argv,
count * sizeof(char *));
new_argv -= option_count;
if (count < 1)
die("empty alias for %s", alias_command);
if (!strcmp(alias_command, new_argv[0]))
die("recursive alias: %s", alias_command);
trace_argv_printf(new_argv,
"trace: alias expansion: %s =>",
alias_command);
REALLOC_ARRAY(new_argv, count + *argcp);
/* insert after command name */
memcpy(new_argv + count, *argv + 1, sizeof(char *) * *argcp);
*argv = new_argv;
*argcp += count - 1;
ret = 1;
}
restore_env(0);
errno = saved_errno;
return ret;
}
int do_stage_boot(cmd_tbl_t * cmdtb, int flag, int argc, char *argv[])
{
char *path_to_image, *path_to_scr, *path_to_initrd, *all_partions;
ulong addr;
int j,i=1,step=0,len,index,device,initrd=0;
char * kernel_addr, *bootargs;
char * args_to_func[5];
char device_prt[4];
if(argc < 2){
printf("No args, try help stage_boot\n");
return 0;
}
path_to_initrd = (char *)malloc((strlen(SCRIPT_PATH)+strlen(getenv("initrd_name")))*sizeof(char));
strcpy(path_to_initrd,SCRIPT_PATH);
strcat(path_to_initrd,getenv("initrd_name"));
path_to_image = (char *)malloc((strlen(SCRIPT_PATH)+strlen(getenv("image_name")))*sizeof(char));
strcpy(path_to_image,SCRIPT_PATH);
strcat(path_to_image,getenv("image_name"));
path_to_scr = (char *)malloc((strlen(SCRIPT_PATH)+strlen(getenv("script_name")))*sizeof(char));
strcpy(path_to_scr,SCRIPT_PATH);
strcat(path_to_scr,getenv("script_name"));
all_partions = (char *)malloc(strlen(getenv("device_partition"))*sizeof(char));
strcpy(all_partions,getenv("device_partition"));
kernel_addr = getenv("kernel_addr_r");
#if !defined(CONFIG_MACH_AVANTA_LP_FPGA)
ide_init();
#endif
for(device=1;device<argc;device++)
{
#if !defined(CONFIG_MACH_AVANTA_LP_FPGA)
/* step 1 load script from ide */
len=strlen(all_partions);
for(index=0;index<len && i==1 && strcmp(argv[device],"hd_scr")==0 ;index++)
{
step=1;
for(j=0;j<3;j++,index++)
device_prt[j]=all_partions[index];
device_prt[3]='\0';
printf("\ntry to load script from ide %s\n",device_prt);
args_to_func[0]="ext2load";
args_to_func[1]=INTERFACE_HD;
args_to_func[2]=device_prt;
args_to_func[3]=LOAD_ADDR;
args_to_func[4]=path_to_scr;
i = do_ext2load(cmdtb, 1, 5 , args_to_func);
addr = simple_strtoul(args_to_func[3], NULL, 16);
}
/* finish step 1 */
/* step 2 boot PXE */
if (i== 1 && strcmp(argv[device],"pxe") == 0)
{
step = 2;
save_env();
setenv("boot_from_pxe","1");
setenv("autoload","no");
setenv("pxefile_addr_r",LOAD_ADDR);
args_to_func[0]="dhcp";
args_to_func[1]=getenv("pxefile_addr_r");
i = do_dhcp(cmdtb, 1, 1, args_to_func);
if(i==0)
i = do_pxe_get(cmdtb, 1 , 1, args_to_func);
setenv("boot_from_pxe","0");
if(i==1)
restore_env();
}
/* finish step 2 */
/* step 3 load linux image from ide */
if( i == 1 && strcmp(argv[device],"hd_img")==0 )
{
step = 3;
len=strlen(all_partions);
for(index=0;index<len && i==1 ;index++)
{
for(j=0;j<3;j++,index++)
device_prt[j]=all_partions[index];
device_prt[3]='\0';
printf("\ntry to load image from ide %s\n", device_prt);
args_to_func[0]="ext2load";
args_to_func[1]=INTERFACE_HD;
args_to_func[2]=device_prt;
args_to_func[3]=getenv("kernel_addr_r");
args_to_func[4]=path_to_image;
i = do_ext2load(cmdtb, 1, 5 , args_to_func);
addr = simple_strtoul(args_to_func[3], NULL, 16);
if( i==0 ){
int temp;
args_to_func[3]=getenv("ramdisk_addr_r");
args_to_func[4]=path_to_initrd;
temp = do_ext2load(cmdtb, 1, 5 , args_to_func);
if(temp == 0)
{
initrd = 1;
args_to_func[1] = getenv("kernel_addr_r");
args_to_func[2] = getenv("ramdisk_addr_r");
}
}
}
}
/* finish step 3 */
/*step 4 load script from tftp */
if( i == 1 && strcmp(argv[device],"net_scr")==0 )
{
printf("\ntry to load script from tftp\n");
step = 4;
args_to_func[0]="tftp";
args_to_func[1]=LOAD_ADDR;
args_to_func[2]=getenv("script_name");
i = do_tftpb(cmdtb, 1, 3,args_to_func);
addr = simple_strtoul(args_to_func[1], NULL, 16);
}
#endif
/* finish step 4 */
/*step 5 load linux image from tftp */
if( i == 1 && strcmp(argv[device],"net_img")==0 )
{
printf("\ntry to load image from tftp\n");
step = 5;
args_to_func[0]="tftp";
args_to_func[1]=getenv("kernel_addr_r");
args_to_func[2]=getenv("image_name");
i = do_tftpb(cmdtb, 1, 3,args_to_func);
addr = simple_strtoul(args_to_func[1], NULL, 16);
}
/* finish step 5 */
}
free(path_to_image);
free(path_to_scr);
path_to_image = getenv("bootargs_dflt");
if(!path_to_image) {
printf("missing environment variable: bootargs_dflt\n");
return 0;
}
if (step == 3 && initrd ==1){
setenv("bootargs_dflt","console=ttyS0,115200 earlyprintk=ttyS0 root=/dev/sda2 ro pm_disable");
}
bootargs = (char *)malloc(sizeof(char)*(strlen(getenv("bootargs_dflt"))+17));
strcpy(bootargs,"setenv bootargs ");
#ifndef CONFIG_SYS_HUSH_PARSER
if (run_command(strcat(bootargs,getenv("bootargs_dflt")), flag) < 0) {
printf("missing environment variable: bootargs_dflt\n");
return 0;
}
#else
marvell_recursive_parse = 1;
if (parse_string_outer(strcat(bootargs,getenv("bootargs_dflt")),
FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP) != 0){
printf("missing environment variable: bootargs_dflt\n");
marvell_recursive_parse = 0;
return 0;
}
marvell_recursive_parse = 0;
#endif
if(i==0)
{
if(step == 1 || step == 4)
source(addr,NULL);
else if ((step == 3 && initrd ==0 )|| step == 5)
do_bootm(cmdtb, 1,1,(char * const*)kernel_addr);
else if (step ==2)
do_pxe_boot(cmdtb, 2, 1,(char * const *)NULL);
else if (step == 3 && initrd ==1){
do_bootm(cmdtb, 1,2,args_to_func);
}
}
else {
printf("Unable to load image/script\n");
}
return 1;
}
