From fe3decb2017af2092d4b2181e27e4cd8f6bbf4fa Mon Sep 17 00:00:00 2001 From: nobu Date: Tue, 14 Nov 2017 04:42:38 +0000 Subject: process.c: removed preserving_errno * process.c (try_with_sh, handle_fork_error): added argument for errno. * process.c (proc_exec_cmd, proc_exec_sh, exec_async_signal_safe): now return errno instead of -1. * process.c (rb_fork_ruby): merged retry_fork_ruby() and unified clean-up after fork regardless failure. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@60762 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- process.c | 112 ++++++++++++++++++++++++++++---------------------------------- 1 file changed, 51 insertions(+), 61 deletions(-) (limited to 'process.c') diff --git a/process.c b/process.c index c055192ba8..895c16e82e 100644 --- a/process.c +++ b/process.c @@ -143,11 +143,9 @@ int setregid(rb_gid_t rgid, rb_gid_t egid); #endif #endif -#define preserving_errno(stmts) \ - do {int saved_errno = errno; stmts; errno = saved_errno;} while (0) - static void check_uid_switch(void); static void check_gid_switch(void); +static int exec_async_signal_safe(const struct rb_execarg *, char *, size_t); #if 1 #define p_uid_from_name p_uid_from_name @@ -1214,7 +1212,7 @@ security(const char *str) #if defined(HAVE_WORKING_FORK) /* try_with_sh and exec_with_sh should be async-signal-safe. Actually it is.*/ -#define try_with_sh(prog, argv, envp) ((saved_errno == ENOEXEC) ? exec_with_sh((prog), (argv), (envp)) : (void)0) +#define try_with_sh(err, prog, argv, envp) ((err == ENOEXEC) ? exec_with_sh((prog), (argv), (envp)) : (void)0) static void exec_with_sh(const char *prog, char **argv, char **envp) { @@ -1237,26 +1235,28 @@ proc_exec_cmd(const char *prog, VALUE argv_str, VALUE envp_str) char **argv; #ifndef _WIN32 char **envp; + int err; #endif argv = ARGVSTR2ARGV(argv_str); if (!prog) { - errno = ENOENT; - return -1; + return ENOENT; } #ifdef _WIN32 rb_w32_uaspawn(P_OVERLAY, prog, argv); + return errno; #else envp = envp_str ? (char **)RSTRING_PTR(envp_str) : NULL; if (envp_str) execve(prog, argv, envp); /* async-signal-safe */ else execv(prog, argv); /* async-signal-safe (since SUSv4) */ - preserving_errno(try_with_sh(prog, argv, envp)); /* try_with_sh() is async-signal-safe. */ + err = errno; + try_with_sh(err, prog, argv, envp); /* try_with_sh() is async-signal-safe. */ + return err; #endif - return -1; } /* This function should be async-signal-safe. Actually it is. */ @@ -1270,15 +1270,12 @@ proc_exec_sh(const char *str, VALUE envp_str) s++; if (!*s) { - errno = ENOENT; - return -1; + return ENOENT; } #ifdef _WIN32 rb_w32_uspawn(P_OVERLAY, (char *)str, 0); - return -1; -#else -#if defined(__CYGWIN32__) +#elif defined(__CYGWIN32__) { char fbuf[MAXPATHLEN]; char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf)); @@ -1295,9 +1292,8 @@ proc_exec_sh(const char *str, VALUE envp_str) execle("/bin/sh", "sh", "-c", str, (char *)NULL, (char **)RSTRING_PTR(envp_str)); /* async-signal-safe */ else execl("/bin/sh", "sh", "-c", str, (char *)NULL); /* async-signal-safe (since SUSv4) */ -#endif - return -1; #endif /* _WIN32 */ + return errno; } int @@ -1306,8 +1302,9 @@ rb_proc_exec(const char *str) int ret; before_exec(); ret = proc_exec_sh(str, Qfalse); - preserving_errno(after_exec()); - return ret; + after_exec(); + errno = ret; + return -1; } static void @@ -2589,9 +2586,7 @@ rb_f_exec(int argc, const VALUE *argv) rb_execarg_parent_start(execarg_obj); fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; - rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg)); - - err = errno; + err = exec_async_signal_safe(eargp, errmsg, sizeof(errmsg)); after_exec(); /* restart timer thread */ rb_exec_fail(eargp, err, errmsg); @@ -3130,32 +3125,39 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, /* This function should be async-signal-safe. Hopefully it is. */ int rb_exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) +{ + errno = exec_async_signal_safe(eargp, errmsg, errmsg_buflen); + return -1; +} + +static int +exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) { #if !defined(HAVE_WORKING_FORK) struct rb_execarg sarg, *const sargp = &sarg; #else struct rb_execarg *const sargp = NULL; #endif + int err; if (rb_execarg_run_options(eargp, sargp, errmsg, errmsg_buflen) < 0) { /* hopefully async-signal-safe */ - goto failure; + return errno; } if (eargp->use_shell) { - proc_exec_sh(RSTRING_PTR(eargp->invoke.sh.shell_script), eargp->envp_str); /* async-signal-safe */ + err = proc_exec_sh(RSTRING_PTR(eargp->invoke.sh.shell_script), eargp->envp_str); /* async-signal-safe */ } else { char *abspath = NULL; if (!NIL_P(eargp->invoke.cmd.command_abspath)) abspath = RSTRING_PTR(eargp->invoke.cmd.command_abspath); - proc_exec_cmd(abspath, eargp->invoke.cmd.argv_str, eargp->envp_str); /* async-signal-safe */ + err = proc_exec_cmd(abspath, eargp->invoke.cmd.argv_str, eargp->envp_str); /* async-signal-safe */ } #if !defined(HAVE_WORKING_FORK) - preserving_errno(rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen)); + rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen); #endif -failure: - return -1; + return err; } #ifdef HAVE_WORKING_FORK @@ -3226,11 +3228,11 @@ pipe_nocrash(int filedes[2], VALUE fds) #endif static int -handle_fork_error(int *status, int *ep, volatile int *try_gc_p) +handle_fork_error(int err, int *status, int *ep, volatile int *try_gc_p) { int state = 0; - switch (errno) { + switch (err) { case ENOMEM: if ((*try_gc_p)-- > 0 && !rb_during_gc()) { rb_gc(); @@ -3253,7 +3255,9 @@ handle_fork_error(int *status, int *ep, volatile int *try_gc_p) break; } if (ep) { - preserving_errno((close(ep[0]), close(ep[1]))); + close(ep[0]); + close(ep[1]); + errno = err; } if (state && !status) rb_jump_tag(state); return -1; @@ -3548,6 +3552,7 @@ retry_fork_async_signal_safe(int *status, int *ep, rb_pid_t pid; volatile int try_gc = 1; struct child_handler_disabler_state old; + int err; while (1) { prefork(); @@ -3575,11 +3580,12 @@ retry_fork_async_signal_safe(int *status, int *ep, _exit(127); #endif } - preserving_errno(disable_child_handler_fork_parent(&old)); + err = errno; + disable_child_handler_fork_parent(&old); if (0 < pid) /* fork succeed, parent process */ return pid; /* fork failed */ - if (handle_fork_error(status, ep, &try_gc)) + if (handle_fork_error(err, status, ep, &try_gc)) return -1; } } @@ -3614,45 +3620,29 @@ rb_fork_async_signal_safe(int *status, int (*chfunc)(void*, char *, size_t), voi return pid; } -static rb_pid_t -retry_fork_ruby(int *status, struct child_handler_disabler_state *old) -{ - rb_pid_t pid; - int try_gc = 1; - - while (1) { - prefork(); - before_fork_ruby(); - disable_child_handler_before_fork(old); - pid = fork(); - if (pid == 0) /* fork succeed, child process */ - return pid; - preserving_errno(after_fork_ruby()); - preserving_errno(disable_child_handler_fork_parent(old)); - if (0 < pid) /* fork succeed, parent process */ - return pid; - /* fork failed */ - if (handle_fork_error(status, NULL, &try_gc)) - return -1; - } -} - rb_pid_t rb_fork_ruby(int *status) { rb_pid_t pid; + int try_gc = 1, err; struct child_handler_disabler_state old; if (status) *status = 0; - pid = retry_fork_ruby(status, &old); - if (pid < 0) - return pid; - if (!pid) { - after_fork_ruby(); - disable_child_handler_fork_parent(&old); /* yes, bad name */ + while (1) { + prefork(); + before_fork_ruby(); + disable_child_handler_before_fork(&old); + pid = fork(); + err = errno; + after_fork_ruby(); + disable_child_handler_fork_parent(&old); /* yes, bad name */ + if (pid >= 0) /* fork succeed */ + return pid; + /* fork failed */ + if (handle_fork_error(err, status, NULL, &try_gc)) + return -1; } - return pid; } #endif -- cgit v1.2.3