--- busybox-1.9.0/include/libbb.h Fri Dec 21 23:00:31 2007 +++ busybox-1.9.0-hush_nommu_tick/include/libbb.h Sun Feb 10 13:16:38 2008 @@ -641,6 +641,9 @@ void re_exec(char **argv) ATTRIBUTE_NORETURN; void forkexit_or_rexec(char **argv); extern bool re_execed; + int BUG_fork_is_unavailable_on_nommu(void); + int BUG_daemon_is_unavailable_on_nommu(void); + void BUG_bb_daemonize_is_unavailable_on_nommu(void); # define fork() BUG_fork_is_unavailable_on_nommu() # define daemon(a,b) BUG_daemon_is_unavailable_on_nommu() # define bb_daemonize(a) BUG_bb_daemonize_is_unavailable_on_nommu() --- busybox-1.9.0/shell/hush.c Mon Dec 24 15:26:23 2007 +++ busybox-1.9.0-hush_nommu_tick/shell/hush.c Mon Feb 11 09:34:27 2008 @@ -80,18 +80,28 @@ #include /* glob, of course */ #include /* should be pretty obvious */ /* #include */ +extern char **environ; +#include "busybox.h" /* for APPLET_IS_NOFORK/NOEXEC */ -extern char **environ; /* This is in , but protected with __USE_GNU */ -#include "busybox.h" /* for APPLET_IS_NOFORK/NOEXEC */ +#if !BB_MMU && ENABLE_HUSH_TICK +//#undef ENABLE_HUSH_TICK +//#define ENABLE_HUSH_TICK 0 +#warning On NOMMU, hush command substitution is dangerous. +#warning Dont use it for commands which produce lots of output. +#warning For more info see shell/hush.c, generate_stream_from_list(). +#endif +#if !BB_MMU && ENABLE_HUSH_JOB +#undef ENABLE_HUSH_JOB +#define ENABLE_HUSH_JOB 0 +#endif -#if !BB_MMU -/* A bit drastic. Can allow some simpler commands - * by analysing command in generate_stream_from_list() - */ -#undef ENABLE_HUSH_TICK -#define ENABLE_HUSH_TICK 0 +#if !ENABLE_HUSH_INTERACTIVE +#undef ENABLE_FEATURE_EDITING +#define ENABLE_FEATURE_EDITING 0 +#undef ENABLE_FEATURE_EDITING_FANCY_PROMPT +#define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0 #endif @@ -178,13 +188,6 @@ #endif -#if !ENABLE_HUSH_INTERACTIVE -#undef ENABLE_FEATURE_EDITING -#define ENABLE_FEATURE_EDITING 0 -#undef ENABLE_FEATURE_EDITING_FANCY_PROMPT -#define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0 -#endif - #define SPECIAL_VAR_SYMBOL 3 #define PARSEFLAG_EXIT_FROM_LOOP 1 @@ -510,10 +513,10 @@ static int free_pipe(struct pipe *pi, int indent); /* really run the final data structures: */ static int setup_redirects(struct child_prog *prog, int squirrel[]); -static int run_list_real(struct pipe *pi); +static int run_list(struct pipe *pi); static void pseudo_exec_argv(char **argv) ATTRIBUTE_NORETURN; static void pseudo_exec(struct child_prog *child) ATTRIBUTE_NORETURN; -static int run_pipe_real(struct pipe *pi); +static int run_pipe(struct pipe *pi); /* extended glob support: */ static char **globhack(const char *src, char **strings); static int glob_needed(const char *s); @@ -1418,7 +1421,7 @@ } } -/* Called after [v]fork() in run_pipe_real(), or from builtin_exec(). +/* Called after [v]fork() in run_pipe(), or from builtin_exec(). * Never returns. * XXX no exit() here. If you don't exec, use _exit instead. * The at_exit handlers apparently confuse the calling process, @@ -1440,9 +1443,8 @@ /* If a variable is assigned in a forest, and nobody listens, * was it ever really set? */ - if (argv[0] == NULL) { + if (!argv[0]) _exit(EXIT_SUCCESS); - } argv = expand_strvec_to_strvec(argv); @@ -1486,15 +1488,15 @@ _exit(1); } -/* Called after [v]fork() in run_pipe_real() +/* Called after [v]fork() in run_pipe() */ static void pseudo_exec(struct child_prog *child) { // FIXME: buggy wrt NOMMU! Must not modify any global data -// until it does exec/_exit, but currently it does. - if (child->argv) { +// until it does exec/_exit, but currently it does +// (puts malloc'ed stuff into environment) + if (child->argv) pseudo_exec_argv(child->argv); - } if (child->group) { #if !BB_MMU @@ -1503,11 +1505,12 @@ int rcode; #if ENABLE_HUSH_INTERACTIVE - debug_printf_exec("pseudo_exec: setting interactive_fd=0\n"); - interactive_fd = 0; /* crucial!!!! */ +// run_list_level now takes care of it? +// debug_printf_exec("pseudo_exec: setting interactive_fd=0\n"); +// interactive_fd = 0; /* crucial!!!! */ #endif - debug_printf_exec("pseudo_exec: run_list_real\n"); - rcode = run_list_real(child->group); + debug_printf_exec("pseudo_exec: run_list\n"); + rcode = run_list(child->group); /* OK to leak memory by not calling free_pipe_list, * since this process is about to exit */ _exit(rcode); @@ -1649,6 +1652,7 @@ // + killall -STOP cat wait_more: +// TODO: safe_waitpid? while ((childpid = waitpid(-1, &status, attributes)) > 0) { const int dead = WIFEXITED(status) || WIFSIGNALED(status); @@ -1673,7 +1677,7 @@ if (dead) { fg_pipe->progs[i].pid = 0; fg_pipe->running_progs--; - if (i == fg_pipe->num_progs-1) + if (i == fg_pipe->num_progs - 1) /* last process gives overall exitstatus */ rcode = WEXITSTATUS(status); } else { @@ -1754,13 +1758,13 @@ } #endif -/* run_pipe_real() starts all the jobs, but doesn't wait for anything +/* run_pipe() starts all the jobs, but doesn't wait for anything * to finish. See checkjobs(). * * return code is normally -1, when the caller has to wait for children * to finish to determine the exit status of the pipe. If the pipe * is a simple builtin command, however, the action is done by the - * time run_pipe_real returns, and the exit code is provided as the + * time run_pipe returns, and the exit code is provided as the * return value. * * The input of the pipe is always stdin, the output is always @@ -1773,11 +1777,11 @@ * Returns -1 only if started some children. IOW: we have to * mask out retvals of builtins etc with 0xff! */ -static int run_pipe_real(struct pipe *pi) +static int run_pipe(struct pipe *pi) { int i; - int nextin, nextout; - int pipefds[2]; /* pipefds[0] is for reading */ + int nextin; + int pipefds[2]; /* pipefds[0] is for reading */ struct child_prog *child; const struct built_in_command *x; char *p; @@ -1786,9 +1790,8 @@ int rcode; const int single_fg = (pi->num_progs == 1 && pi->followup != PIPE_BG); - debug_printf_exec("run_pipe_real start: single_fg=%d\n", single_fg); + debug_printf_exec("run_pipe start: single_fg=%d\n", single_fg); - nextin = 0; #if ENABLE_HUSH_JOB pi->pgrp = -1; #endif @@ -1803,11 +1806,11 @@ if (single_fg && child->group && child->subshell == 0) { debug_printf("non-subshell grouping\n"); setup_redirects(child, squirrel); - debug_printf_exec(": run_list_real\n"); - rcode = run_list_real(child->group); + debug_printf_exec(": run_list\n"); + rcode = run_list(child->group) & 0xff; restore_redirects(squirrel); - debug_printf_exec("run_pipe_real return %d\n", rcode); - return rcode; // do we need to add '... & 0xff' ? + debug_printf_exec("run_pipe return %d\n", rcode); + return rcode; } if (single_fg && child->argv != NULL) { @@ -1849,7 +1852,7 @@ rcode = x->function(argv_expanded) & 0xff; free(argv_expanded); restore_redirects(squirrel); - debug_printf_exec("run_pipe_real return %d\n", rcode); + debug_printf_exec("run_pipe return %d\n", rcode); return rcode; } } @@ -1866,20 +1869,21 @@ rcode = run_nofork_applet_prime(&nofork_save, a, argv_expanded) & 0xff; free(argv_expanded); restore_redirects(squirrel); - debug_printf_exec("run_pipe_real return %d\n", rcode); + debug_printf_exec("run_pipe return %d\n", rcode); return rcode; } } #endif } - /* Going to fork a child per each pipe member */ - pi->running_progs = 0; - /* Disable job control signals for shell (parent) and * for initial child code after fork */ set_jobctrl_sighandler(SIG_IGN); + /* Going to fork a child per each pipe member */ + pi->running_progs = 0; + nextin = 0; + for (i = 0; i < pi->num_progs; i++) { child = &(pi->progs[i]); if (child->argv) @@ -1888,42 +1892,34 @@ debug_printf_exec(": pipe member with no argv\n"); /* pipes are inserted between pairs of commands */ - if ((i + 1) < pi->num_progs) { - pipe(pipefds); - nextout = pipefds[1]; - } else { - nextout = 1; - pipefds[0] = -1; - } + pipefds[0] = 0; + pipefds[1] = 1; + if ((i + 1) < pi->num_progs) + xpipe(pipefds); - /* XXX test for failed fork()? */ -#if BB_MMU - child->pid = fork(); -#else - child->pid = vfork(); -#endif + child->pid = BB_MMU ? fork() : vfork(); if (!child->pid) { /* child */ - /* Every child adds itself to new process group - * with pgid == pid of first child in pipe */ #if ENABLE_HUSH_JOB + /* Every child adds itself to new process group + * with pgid == pid_of_first_child_in_pipe */ if (run_list_level == 1 && interactive_fd) { + pid_t pgrp; /* Don't do pgrp restore anymore on fatal signals */ set_fatal_sighandler(SIG_DFL); - if (pi->pgrp < 0) /* true for 1st process only */ - pi->pgrp = getpid(); - if (setpgid(0, pi->pgrp) == 0 && pi->followup != PIPE_BG) { + pgrp = pi->pgrp; + if (pgrp < 0) /* true for 1st process only */ + pgrp = getpid(); + if (setpgid(0, pgrp) == 0 && pi->followup != PIPE_BG) { /* We do it in *every* child, not just first, * to avoid races */ - tcsetpgrp(interactive_fd, pi->pgrp); + tcsetpgrp(interactive_fd, pgrp); } } #endif - /* in non-interactive case fatal sigs are already SIG_DFL */ xmove_fd(nextin, 0); - xmove_fd(nextout, 1); - if (pipefds[0] != -1) { - close(pipefds[0]); /* opposite end of our output pipe */ - } + xmove_fd(pipefds[1], 1); /* write end */ + if (pipefds[0] > 1) + close(pipefds[0]); /* read end */ /* Like bash, explicit redirects override pipes, * and the pipe fd is available for dup'ing. */ setup_redirects(child, NULL); @@ -1932,26 +1928,35 @@ set_jobctrl_sighandler(SIG_DFL); set_misc_sighandler(SIG_DFL); signal(SIGCHLD, SIG_DFL); - pseudo_exec(child); + pseudo_exec(child); /* does not return */ } - pi->running_progs++; - + if (child->pid < 0) { /* [v]fork failed */ + /* Clearly indicate, was it fork or vfork */ + bb_perror_msg(BB_MMU ? "fork" : "vfork"); + } else { + pi->running_progs++; #if ENABLE_HUSH_JOB - /* Second and next children need to know pid of first one */ - if (pi->pgrp < 0) - pi->pgrp = child->pid; + /* Second and next children need to know pid of first one */ + if (pi->pgrp < 0) + pi->pgrp = child->pid; #endif - if (nextin != 0) - close(nextin); - if (nextout != 1) - close(nextout); + } - /* If there isn't another process, nextin is garbage - but it doesn't matter */ + if (i) + close(nextin); + if ((i + 1) < pi->num_progs) + close(pipefds[1]); /* write end */ + /* Pass read (output) pipe end to next iteration */ nextin = pipefds[0]; } - debug_printf_exec("run_pipe_real return -1\n"); + + if (!pi->running_progs) { + debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n"); + return 1; + } + + debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->running_progs); return -1; } @@ -2020,7 +2025,7 @@ /* NB: called by pseudo_exec, and therefore must not modify any * global data until exec/_exit (we can be a child after vfork!) */ -static int run_list_real(struct pipe *pi) +static int run_list(struct pipe *pi) { struct pipe *rpipe; #if ENABLE_HUSH_LOOPS @@ -2029,7 +2034,6 @@ char **for_list = NULL; int flag_rep = 0; #endif - int save_num_progs; int flag_skip = 1; int rcode = 0; /* probably for gcc only */ int flag_restore = 0; @@ -2041,7 +2045,7 @@ reserved_style rword; reserved_style skip_more_for_this_rword = RES_XXXX; - debug_printf_exec("run_list_real start lvl %d\n", run_list_level + 1); + debug_printf_exec("run_list start lvl %d\n", run_list_level + 1); #if ENABLE_HUSH_LOOPS /* check syntax for "for" */ @@ -2050,7 +2054,7 @@ && (rpipe->next == NULL) ) { syntax("malformed for"); /* no IN or no commands after IN */ - debug_printf_exec("run_list_real lvl %d return 1\n", run_list_level); + debug_printf_exec("run_list lvl %d return 1\n", run_list_level); return 1; } if ((rpipe->res_word == RES_IN && rpipe->next->res_word == RES_IN && rpipe->next->progs[0].argv != NULL) @@ -2058,7 +2062,7 @@ ) { /* TODO: what is tested in the first condition? */ syntax("malformed for"); /* 2nd condition: not followed by IN */ - debug_printf_exec("run_list_real lvl %d return 1\n", run_list_level); + debug_printf_exec("run_list lvl %d return 1\n", run_list_level); return 1; } } @@ -2106,9 +2110,10 @@ signal_SA_RESTART(SIGTSTP, handler_ctrl_z); signal(SIGINT, handler_ctrl_c); } -#endif +#endif /* JOB */ for (; pi; pi = flag_restore ? rpipe : pi->next) { +//why? int save_num_progs; rword = pi->res_word; #if ENABLE_HUSH_LOOPS if (rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR) { @@ -2181,12 +2186,12 @@ #endif if (pi->num_progs == 0) continue; - save_num_progs = pi->num_progs; /* save number of programs */ - debug_printf_exec(": run_pipe_real with %d members\n", pi->num_progs); - rcode = run_pipe_real(pi); +//why? save_num_progs = pi->num_progs; + debug_printf_exec(": run_pipe with %d members\n", pi->num_progs); + rcode = run_pipe(pi); if (rcode != -1) { /* We only ran a builtin: rcode was set by the return value - * of run_pipe_real(), and we don't need to wait for anything. */ + * of run_pipe(), and we don't need to wait for anything. */ } else if (pi->followup == PIPE_BG) { /* What does bash do with attempts to background builtins? */ /* Even bash 3.2 doesn't do that well with nested bg: @@ -2199,7 +2204,6 @@ rcode = EXIT_SUCCESS; } else { #if ENABLE_HUSH_JOB - /* Paranoia, just "interactive_fd" should be enough? */ if (run_list_level == 1 && interactive_fd) { /* waits for completion, then fg's main shell */ rcode = checkjobs_and_fg_shell(pi); @@ -2213,7 +2217,7 @@ } debug_printf_exec(": setting last_return_code=%d\n", rcode); last_return_code = rcode; - pi->num_progs = save_num_progs; /* restore number of programs */ +//why? pi->num_progs = save_num_progs; #if ENABLE_HUSH_IF if (rword == RES_IF || rword == RES_ELIF) next_if_code = rcode; /* can be overwritten a number of times */ @@ -2244,7 +2248,7 @@ signal(SIGINT, SIG_IGN); } #endif - debug_printf_exec("run_list_real lvl %d return %d\n", run_list_level + 1, rcode); + debug_printf_exec("run_list lvl %d return %d\n", run_list_level + 1, rcode); return rcode; } @@ -2318,19 +2322,19 @@ } /* Select which version we will use */ -static int run_list(struct pipe *pi) +static int run_and_free_list(struct pipe *pi) { int rcode = 0; - debug_printf_exec("run_list entered\n"); - if (fake_mode == 0) { - debug_printf_exec(": run_list_real with %d members\n", pi->num_progs); - rcode = run_list_real(pi); + debug_printf_exec("run_and_free_list entered\n"); + if (!fake_mode) { + debug_printf_exec(": run_list with %d members\n", pi->num_progs); + rcode = run_list(pi); } /* free_pipe_list has the side effect of clearing memory. - * In the long run that function can be merged with run_list_real, + * In the long run that function can be merged with run_list, * but doing that now would hobble the debugging effort. */ - free_pipe_list(pi, 0); - debug_printf_exec("run_list return %d\n", rcode); + free_pipe_list(pi, /* indent: */ 0); + debug_printf_exec("run_nad_free_list return %d\n", rcode); return rcode; } @@ -3224,15 +3228,17 @@ int pid, channel[2]; xpipe(channel); - pid = fork(); - if (pid < 0) { - bb_perror_msg_and_die("fork"); - } else if (pid == 0) { +/* *** NOMMU WARNING *** */ +/* By using vfork here, we suspend parent till child exits or execs. + * If child will not do it before it fills the pipe, it can block forever + * in write(STDOUT_FILENO), and parent (shell) will be also stuck. + */ + pid = BB_MMU ? fork() : vfork(); + if (pid < 0) + bb_perror_msg_and_die(BB_MMU ? "fork" : "vfork"); + if (pid == 0) { /* child */ close(channel[0]); - if (channel[1] != 1) { - dup2(channel[1], 1); - close(channel[1]); - } + xmove_fd(channel[1], 1); /* Prevent it from trying to handle ctrl-z etc */ #if ENABLE_HUSH_JOB run_list_level = 1; @@ -3244,11 +3250,12 @@ * everywhere outside actual command execution. */ /*set_jobctrl_sighandler(SIG_IGN);*/ set_misc_sighandler(SIG_DFL); - _exit(run_list_real(head)); /* leaks memory */ + _exit(run_list(head)); /* leaks memory */ } close(channel[1]); pf = fdopen(channel[0], "r"); return pf; + /* head is freed by the caller */ } /* Return code is exit status of the process that is run. */ @@ -3272,7 +3279,8 @@ b_free(&result); p = generate_stream_from_list(inner.list_head); - if (p == NULL) return 1; + if (p == NULL) + return 1; close_on_exec_on(fileno(p)); setup_file_in_str(&pipe_str, p); @@ -3297,7 +3305,7 @@ * at the same time. That would be a lot of work, and contrary * to the KISS philosophy of this program. */ retcode = fclose(p); - free_pipe_list(inner.list_head, 0); + free_pipe_list(inner.list_head, /* indent: */ 0); debug_printf("closed FILE from child, retcode=%d\n", retcode); return retcode; } @@ -3677,8 +3685,8 @@ done_word(&temp, &ctx); done_pipe(&ctx, PIPE_SEQ); debug_print_tree(ctx.list_head, 0); - debug_printf_exec("parse_stream_outer: run_list\n"); - run_list(ctx.list_head); + debug_printf_exec("parse_stream_outer: run_and_free_list\n"); + run_and_free_list(ctx.list_head); } else { if (ctx.old_flag != 0) { free(ctx.stack); @@ -3687,7 +3695,7 @@ temp.nonnull = 0; temp.o_quote = 0; inp->p = NULL; - free_pipe_list(ctx.list_head, 0); + free_pipe_list(ctx.list_head, /* indent: */ 0); } b_free(&temp); } while (rcode != -1 && !(parse_flag & PARSEFLAG_EXIT_FROM_LOOP)); /* loop on syntax errors, return on EOF */ @@ -3901,14 +3909,14 @@ if (argv[optind] == NULL) { opt = parse_and_run_file(stdin); - goto final_return; + } else { + debug_printf("\nrunning script '%s'\n", argv[optind]); + global_argv = argv + optind; + global_argc = argc - optind; + input = xfopen(argv[optind], "r"); + fcntl(fileno(input), F_SETFD, FD_CLOEXEC); + opt = parse_and_run_file(input); } - - debug_printf("\nrunning script '%s'\n", argv[optind]); - global_argv = argv + optind; - global_argc = argc - optind; - input = xfopen(argv[optind], "r"); - opt = parse_and_run_file(input); final_return: