diff options
Diffstat (limited to 'process.c')
| -rw-r--r-- | process.c | 3587 |
1 files changed, 2392 insertions, 1195 deletions
@@ -11,89 +11,112 @@ **********************************************************************/ -#include "internal.h" -#include "ruby/io.h" -#include "ruby/thread.h" -#include "ruby/util.h" -#include "vm_core.h" +#include "ruby/internal/config.h" -#include <stdio.h> +#include "ruby/fiber/scheduler.h" + +#include <ctype.h> #include <errno.h> #include <signal.h> +#include <stdarg.h> +#include <stdio.h> +#include <time.h> + #ifdef HAVE_STDLIB_H -#include <stdlib.h> +# include <stdlib.h> #endif + #ifdef HAVE_UNISTD_H -#include <unistd.h> +# include <unistd.h> #endif + #ifdef HAVE_FCNTL_H -#include <fcntl.h> +# include <fcntl.h> #endif + #ifdef HAVE_PROCESS_H -#include <process.h> +# include <process.h> #endif -#include <time.h> -#include <ctype.h> - #ifndef EXIT_SUCCESS -#define EXIT_SUCCESS 0 +# define EXIT_SUCCESS 0 #endif + #ifndef EXIT_FAILURE -#define EXIT_FAILURE 1 +# define EXIT_FAILURE 1 #endif #ifdef HAVE_SYS_WAIT_H # include <sys/wait.h> #endif + #ifdef HAVE_SYS_RESOURCE_H # include <sys/resource.h> #endif + #ifdef HAVE_VFORK_H # include <vfork.h> #endif + #ifdef HAVE_SYS_PARAM_H # include <sys/param.h> #endif + #ifndef MAXPATHLEN # define MAXPATHLEN 1024 #endif -#include "ruby/st.h" - -#ifdef __EMX__ -#undef HAVE_GETPGRP -#endif #include <sys/stat.h> -#if defined(__native_client__) && defined(NACL_NEWLIB) -# include <sys/unistd.h> -# include "nacl/stat.h" -# include "nacl/unistd.h" -# include "nacl/resource.h" -# undef HAVE_ISSETUGID -#endif #ifdef HAVE_SYS_TIME_H -#include <sys/time.h> +# include <sys/time.h> #endif + #ifdef HAVE_SYS_TIMES_H -#include <sys/times.h> +# include <sys/times.h> #endif #ifdef HAVE_PWD_H -#include <pwd.h> +# include <pwd.h> #endif + #ifdef HAVE_GRP_H -#include <grp.h> +# include <grp.h> +# ifdef __CYGWIN__ +int initgroups(const char *, rb_gid_t); +# endif #endif + #ifdef HAVE_SYS_ID_H -#include <sys/id.h> +# include <sys/id.h> #endif #ifdef __APPLE__ # include <mach/mach_time.h> #endif +#include "dln.h" +#include "hrtime.h" +#include "internal.h" +#include "internal/bits.h" +#include "internal/dir.h" +#include "internal/error.h" +#include "internal/eval.h" +#include "internal/hash.h" +#include "internal/numeric.h" +#include "internal/object.h" +#include "internal/process.h" +#include "internal/thread.h" +#include "internal/variable.h" +#include "internal/warnings.h" +#include "mjit.h" +#include "ruby/io.h" +#include "ruby/st.h" +#include "ruby/thread.h" +#include "ruby/util.h" +#include "vm_core.h" +#include "ruby/ractor.h" + /* define system APIs */ #ifdef _WIN32 #undef open @@ -151,29 +174,58 @@ 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); + +VALUE rb_envtbl(void); +VALUE rb_env_to_hash(void); #if 1 #define p_uid_from_name p_uid_from_name #define p_gid_from_name p_gid_from_name #endif +#if defined(HAVE_UNISTD_H) +# if defined(HAVE_GETLOGIN_R) +# define USE_GETLOGIN_R 1 +# define GETLOGIN_R_SIZE_DEFAULT 0x100 +# define GETLOGIN_R_SIZE_LIMIT 0x1000 +# if defined(_SC_LOGIN_NAME_MAX) +# define GETLOGIN_R_SIZE_INIT sysconf(_SC_LOGIN_NAME_MAX) +# else +# define GETLOGIN_R_SIZE_INIT GETLOGIN_R_SIZE_DEFAULT +# endif +# elif defined(HAVE_GETLOGIN) +# define USE_GETLOGIN 1 +# endif +#endif + #if defined(HAVE_PWD_H) -# if defined(HAVE_GETPWNAM_R) && defined(_SC_GETPW_R_SIZE_MAX) +# if defined(HAVE_GETPWUID_R) +# define USE_GETPWUID_R 1 +# elif defined(HAVE_GETPWUID) +# define USE_GETPWUID 1 +# endif +# if defined(HAVE_GETPWNAM_R) # define USE_GETPWNAM_R 1 -# define GETPW_R_SIZE_INIT sysconf(_SC_GETPW_R_SIZE_MAX) +# elif defined(HAVE_GETPWNAM) +# define USE_GETPWNAM 1 +# endif +# if defined(HAVE_GETPWNAM_R) || defined(HAVE_GETPWUID_R) # define GETPW_R_SIZE_DEFAULT 0x1000 # define GETPW_R_SIZE_LIMIT 0x10000 +# if defined(_SC_GETPW_R_SIZE_MAX) +# define GETPW_R_SIZE_INIT sysconf(_SC_GETPW_R_SIZE_MAX) +# else +# define GETPW_R_SIZE_INIT GETPW_R_SIZE_DEFAULT +# endif # endif # ifdef USE_GETPWNAM_R # define PREPARE_GETPWNAM \ VALUE getpw_buf = 0 # define FINISH_GETPWNAM \ - ALLOCV_END(getpw_buf) + (getpw_buf ? (void)rb_str_resize(getpw_buf, 0) : (void)0) # define OBJ2UID1(id) obj2uid((id), &getpw_buf) # define OBJ2UID(id) obj2uid0(id) static rb_uid_t obj2uid(VALUE id, VALUE *getpw_buf); @@ -215,7 +267,7 @@ static rb_uid_t obj2uid(VALUE id); # define PREPARE_GETGRNAM \ VALUE getgr_buf = 0 # define FINISH_GETGRNAM \ - ALLOCV_END(getgr_buf) + (getgr_buf ? (void)rb_str_resize(getgr_buf, 0) : (void)0) # define OBJ2GID1(id) obj2gid((id), &getgr_buf) # define OBJ2GID(id) obj2gid0(id) static rb_gid_t obj2gid(VALUE id, VALUE *getgr_buf); @@ -254,16 +306,20 @@ typedef unsigned long unsigned_clock_t; #elif defined(HAVE_LONG_LONG) && SIZEOF_CLOCK_T == SIZEOF_LONG_LONG typedef unsigned LONG_LONG unsigned_clock_t; #endif +#ifndef HAVE_SIG_T +typedef void (*sig_t) (int); +#endif +#define id_exception idException static ID id_in, id_out, id_err, id_pid, id_uid, id_gid; -static ID id_close, id_child, id_status; +static ID id_close, id_child; #ifdef HAVE_SETPGID static ID id_pgroup; #endif #ifdef _WIN32 static ID id_new_pgroup; #endif -static ID id_unsetenv_others, id_chdir, id_umask, id_close_others, id_ENV; +static ID id_unsetenv_others, id_chdir, id_umask, id_close_others; static ID id_nanosecond, id_microsecond, id_millisecond, id_second; static ID id_float_microsecond, id_float_millisecond, id_float_second; static ID id_GETTIMEOFDAY_BASED_CLOCK_REALTIME, id_TIME_BASED_CLOCK_REALTIME; @@ -280,9 +336,168 @@ static ID id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC; #endif static ID id_hertz; +/* execv and execl are async-signal-safe since SUSv4 (POSIX.1-2008, XPG7) */ +#if defined(__sun) && !defined(_XPG7) /* Solaris 10, 9, ... */ +#define execv(path, argv) (rb_async_bug_errno("unreachable: async-signal-unsafe execv() is called", 0)) +#define execl(path, arg0, arg1, arg2, term) do { extern char **environ; execle((path), (arg0), (arg1), (arg2), (term), (environ)); } while (0) +#define ALWAYS_NEED_ENVP 1 +#else +#define ALWAYS_NEED_ENVP 0 +#endif + +static void +assert_close_on_exec(int fd) +{ +#if VM_CHECK_MODE > 0 +#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(FD_CLOEXEC) + int flags = fcntl(fd, F_GETFD); + if (flags == -1) { + static const char m[] = "reserved FD closed unexpectedly?\n"; + (void)!write(2, m, sizeof(m) - 1); + return; + } + if (flags & FD_CLOEXEC) return; + rb_bug("reserved FD did not have close-on-exec set"); +#else + rb_bug("reserved FD without close-on-exec support"); +#endif /* FD_CLOEXEC */ +#endif /* VM_CHECK_MODE */ +} + +static inline int +close_unless_reserved(int fd) +{ + if (rb_reserved_fd_p(fd)) { /* async-signal-safe */ + assert_close_on_exec(fd); + return 0; + } + return close(fd); /* async-signal-safe */ +} + +/*#define DEBUG_REDIRECT*/ +#if defined(DEBUG_REDIRECT) + +static void +ttyprintf(const char *fmt, ...) +{ + va_list ap; + FILE *tty; + int save = errno; +#ifdef _WIN32 + tty = fopen("con", "w"); +#else + tty = fopen("/dev/tty", "w"); +#endif + if (!tty) + return; + + va_start(ap, fmt); + vfprintf(tty, fmt, ap); + va_end(ap); + fclose(tty); + errno = save; +} + +static int +redirect_dup(int oldfd) +{ + int ret; + ret = dup(oldfd); + ttyprintf("dup(%d) => %d\n", oldfd, ret); + return ret; +} + +static int +redirect_dup2(int oldfd, int newfd) +{ + int ret; + ret = dup2(oldfd, newfd); + ttyprintf("dup2(%d, %d) => %d\n", oldfd, newfd, ret); + return ret; +} + +static int +redirect_cloexec_dup(int oldfd) +{ + int ret; + ret = rb_cloexec_dup(oldfd); + ttyprintf("cloexec_dup(%d) => %d\n", oldfd, ret); + return ret; +} + +static int +redirect_cloexec_dup2(int oldfd, int newfd) +{ + int ret; + ret = rb_cloexec_dup2(oldfd, newfd); + ttyprintf("cloexec_dup2(%d, %d) => %d\n", oldfd, newfd, ret); + return ret; +} + +static int +redirect_close(int fd) +{ + int ret; + ret = close_unless_reserved(fd); + ttyprintf("close(%d) => %d\n", fd, ret); + return ret; +} + +static int +parent_redirect_open(const char *pathname, int flags, mode_t perm) +{ + int ret; + ret = rb_cloexec_open(pathname, flags, perm); + ttyprintf("parent_open(\"%s\", 0x%x, 0%o) => %d\n", pathname, flags, perm, ret); + return ret; +} + +static int +parent_redirect_close(int fd) +{ + int ret; + ret = close_unless_reserved(fd); + ttyprintf("parent_close(%d) => %d\n", fd, ret); + return ret; +} + +#else +#define redirect_dup(oldfd) dup(oldfd) +#define redirect_dup2(oldfd, newfd) dup2((oldfd), (newfd)) +#define redirect_cloexec_dup(oldfd) rb_cloexec_dup(oldfd) +#define redirect_cloexec_dup2(oldfd, newfd) rb_cloexec_dup2((oldfd), (newfd)) +#define redirect_close(fd) close_unless_reserved(fd) +#define parent_redirect_open(pathname, flags, perm) rb_cloexec_open((pathname), (flags), (perm)) +#define parent_redirect_close(fd) close_unless_reserved(fd) +#endif + +/* + * Document-module: Process + * + * The module contains several groups of functionality for handling OS processes: + * + * * Low-level property introspection and management of the current process, like + * Process.argv0, Process.pid; + * * Low-level introspection of other processes, like Process.getpgid, Process.getpriority; + * * Management of the current process: Process.abort, Process.exit, Process.daemon, etc. + * (for convenience, most of those are also available as global functions + * and module functions of Kernel); + * * Creation and management of child processes: Process.fork, Process.spawn, and + * related methods; + * * Management of low-level system clock: Process.times and Process.clock_gettime, + * which could be important for proper benchmarking and other elapsed + * time measurement tasks. + */ + +static VALUE +get_pid(void) +{ + return PIDT2NUM(getpid()); +} + /* * call-seq: - * Process.pid -> fixnum + * Process.pid -> integer * * Returns the process id of this process. Not available on all * platforms. @@ -291,16 +506,20 @@ static ID id_hertz; */ static VALUE -get_pid(void) +proc_get_pid(VALUE _) { - rb_secure(2); - return PIDT2NUM(getpid()); + return get_pid(); } +static VALUE +get_ppid(void) +{ + return PIDT2NUM(getppid()); +} /* * call-seq: - * Process.ppid -> fixnum + * Process.ppid -> integer * * Returns the process id of the parent of this process. Returns * untrustworthy value on Win32/64. Not available on all platforms. @@ -315,10 +534,9 @@ get_pid(void) */ static VALUE -get_ppid(void) +proc_get_ppid(VALUE _) { - rb_secure(2); - return PIDT2NUM(getppid()); + return get_ppid(); } @@ -326,10 +544,10 @@ get_ppid(void) * * Document-class: Process::Status * - * <code>Process::Status</code> encapsulates the information on the + * Process::Status encapsulates the information on the * status of a running or terminated system process. The built-in * variable <code>$?</code> is either +nil+ or a - * <code>Process::Status</code> object. + * Process::Status object. * * fork { exit 99 } #=> 26557 * Process.wait #=> 26557 @@ -346,7 +564,7 @@ get_ppid(void) * information (for example the program's return code in the case of * exited processes). Pre Ruby 1.8, these bits were exposed directly * to the Ruby program. Ruby now encapsulates these in a - * <code>Process::Status</code> object. To maximize compatibility, + * Process::Status object. To maximize compatibility, * however, these objects retain a bit-oriented interface. In the * descriptions that follow, when we talk about the integer value of * _stat_, we're referring to this 16 bit value. @@ -354,19 +572,97 @@ get_ppid(void) static VALUE rb_cProcessStatus; +struct rb_process_status { + rb_pid_t pid; + int status; + int error; +}; + +static const rb_data_type_t rb_process_status_type = { + .wrap_struct_name = "Process::Status", + .function = { + .dfree = RUBY_DEFAULT_FREE, + }, + .data = NULL, + .flags = RUBY_TYPED_FREE_IMMEDIATELY, +}; + +static VALUE +rb_process_status_allocate(VALUE klass) +{ + struct rb_process_status *data = NULL; + + return TypedData_Make_Struct(klass, struct rb_process_status, &rb_process_status_type, data); +} + VALUE rb_last_status_get(void) { return GET_THREAD()->last_status; } +/* + * call-seq: + * Process.last_status -> Process::Status or nil + * + * Returns the status of the last executed child process in the + * current thread. + * + * Process.wait Process.spawn("ruby", "-e", "exit 13") + * Process.last_status #=> #<Process::Status: pid 4825 exit 13> + * + * If no child process has ever been executed in the current + * thread, this returns +nil+. + * + * Process.last_status #=> nil + */ +static VALUE +proc_s_last_status(VALUE mod) +{ + return rb_last_status_get(); +} + +VALUE +rb_process_status_new(rb_pid_t pid, int status, int error) +{ + VALUE last_status = rb_process_status_allocate(rb_cProcessStatus); + + struct rb_process_status *data = RTYPEDDATA_DATA(last_status); + data->pid = pid; + data->status = status; + data->error = error; + + rb_obj_freeze(last_status); + return last_status; +} + +static VALUE +process_status_dump(VALUE status) +{ + VALUE dump = rb_class_new_instance(0, 0, rb_cObject); + struct rb_process_status *data = RTYPEDDATA_DATA(status); + if (data->pid) { + rb_ivar_set(dump, id_status, INT2NUM(data->status)); + rb_ivar_set(dump, id_pid, PIDT2NUM(data->pid)); + } + return dump; +} + +static VALUE +process_status_load(VALUE real_obj, VALUE load_obj) +{ + struct rb_process_status *data = rb_check_typeddata(real_obj, &rb_process_status_type); + VALUE status = rb_attr_get(load_obj, id_status); + VALUE pid = rb_attr_get(load_obj, id_pid); + data->pid = NIL_P(pid) ? 0 : NUM2PIDT(pid); + data->status = NIL_P(status) ? 0 : NUM2INT(status); + return real_obj; +} + void rb_last_status_set(int status, rb_pid_t pid) { - rb_thread_t *th = GET_THREAD(); - th->last_status = rb_obj_alloc(rb_cProcessStatus); - rb_ivar_set(th->last_status, id_status, INT2FIX(status)); - rb_ivar_set(th->last_status, id_pid, PIDT2NUM(pid)); + GET_THREAD()->last_status = rb_process_status_new(pid, status, 0); } void @@ -375,12 +671,25 @@ rb_last_status_clear(void) GET_THREAD()->last_status = Qnil; } +static rb_pid_t +pst_pid(VALUE pst) +{ + struct rb_process_status *data = RTYPEDDATA_DATA(pst); + return data->pid; +} + +static int +pst_status(VALUE pst) +{ + struct rb_process_status *data = RTYPEDDATA_DATA(pst); + return data->status; +} + /* * call-seq: - * stat.to_i -> fixnum - * stat.to_int -> fixnum + * stat.to_i -> integer * - * Returns the bits in _stat_ as a <code>Fixnum</code>. Poking + * Returns the bits in _stat_ as an Integer. Poking * around in these bits is platform dependent. * * fork { exit 0xab } #=> 26566 @@ -389,16 +698,17 @@ rb_last_status_clear(void) */ static VALUE -pst_to_i(VALUE st) +pst_to_i(VALUE self) { - return rb_ivar_get(st, id_status); + int status = pst_status(self); + return RB_INT2NUM(status); } -#define PST2INT(st) NUM2INT(pst_to_i(st)) +#define PST2INT(st) pst_status(st) /* * call-seq: - * stat.pid -> fixnum + * stat.pid -> integer * * Returns the process ID that this status object represents. * @@ -408,15 +718,24 @@ pst_to_i(VALUE st) */ static VALUE -pst_pid(VALUE st) +pst_pid_m(VALUE self) { - return rb_attr_get(st, id_pid); + rb_pid_t pid = pst_pid(self); + return PIDT2NUM(pid); } +static VALUE pst_message_status(VALUE str, int status); + static void pst_message(VALUE str, rb_pid_t pid, int status) { rb_str_catf(str, "pid %ld", (long)pid); + pst_message_status(str, status); +} + +static VALUE +pst_message_status(VALUE str, int status) +{ if (WIFSTOPPED(status)) { int stopsig = WSTOPSIG(status); const char *signame = ruby_signal_name(stopsig); @@ -445,6 +764,7 @@ pst_message(VALUE str, rb_pid_t pid, int status) rb_str_cat2(str, " (core dumped)"); } #endif + return str; } @@ -466,7 +786,7 @@ pst_to_s(VALUE st) int status; VALUE str; - pid = NUM2PIDT(pst_pid(st)); + pid = pst_pid(st); status = PST2INT(st); str = rb_str_buf_new(0); @@ -491,13 +811,12 @@ pst_inspect(VALUE st) { rb_pid_t pid; int status; - VALUE vpid, str; + VALUE str; - vpid = pst_pid(st); - if (NIL_P(vpid)) { + pid = pst_pid(st); + if (!pid) { return rb_sprintf("#<%s: uninitialized>", rb_class2name(CLASS_OF(st))); } - pid = NUM2PIDT(vpid); status = PST2INT(st); str = rb_sprintf("#<%s: ", rb_class2name(CLASS_OF(st))); @@ -525,7 +844,7 @@ pst_equal(VALUE st1, VALUE st2) /* * call-seq: - * stat & num -> fixnum + * stat & num -> integer * * Logical AND of the bits in _stat_ with <em>num</em>. * @@ -546,7 +865,7 @@ pst_bitand(VALUE st1, VALUE st2) /* * call-seq: - * stat >> num -> fixnum + * stat >> num -> integer * * Shift the bits in _stat_ right <em>num</em> places. * @@ -569,9 +888,9 @@ pst_rshift(VALUE st1, VALUE st2) * call-seq: * stat.stopped? -> true or false * - * Returns +true+ if this process is stopped. This is only - * returned if the corresponding <code>wait</code> call had the - * <code>WUNTRACED</code> flag set. + * Returns +true+ if this process is stopped. This is only returned + * if the corresponding #wait call had the Process::WUNTRACED flag + * set. */ static VALUE @@ -579,16 +898,13 @@ pst_wifstopped(VALUE st) { int status = PST2INT(st); - if (WIFSTOPPED(status)) - return Qtrue; - else - return Qfalse; + return RBOOL(WIFSTOPPED(status)); } /* * call-seq: - * stat.stopsig -> fixnum or nil + * stat.stopsig -> integer or nil * * Returns the number of the signal that caused _stat_ to stop * (or +nil+ if self is not stopped). @@ -618,16 +934,13 @@ pst_wifsignaled(VALUE st) { int status = PST2INT(st); - if (WIFSIGNALED(status)) - return Qtrue; - else - return Qfalse; + return RBOOL(WIFSIGNALED(status)); } /* * call-seq: - * stat.termsig -> fixnum or nil + * stat.termsig -> integer or nil * * Returns the number of the signal that caused _stat_ to * terminate (or +nil+ if self was not terminated by an @@ -659,20 +972,16 @@ pst_wifexited(VALUE st) { int status = PST2INT(st); - if (WIFEXITED(status)) - return Qtrue; - else - return Qfalse; + return RBOOL(WIFEXITED(status)); } /* * call-seq: - * stat.exitstatus -> fixnum or nil + * stat.exitstatus -> integer or nil * * Returns the least significant eight bits of the return code of - * _stat_. Only available if <code>exited?</code> is - * +true+. + * _stat_. Only available if #exited? is +true+. * * fork { } #=> 26572 * Process.wait #=> 26572 @@ -701,7 +1010,7 @@ pst_wexitstatus(VALUE st) * stat.success? -> true, false or nil * * Returns +true+ if _stat_ is successful, +false+ if not. - * Returns +nil+ if <code>exited?</code> is not +true+. + * Returns +nil+ if #exited? is not +true+. */ static VALUE @@ -711,7 +1020,7 @@ pst_success_p(VALUE st) if (!WIFEXITED(status)) return Qnil; - return WEXITSTATUS(status) == EXIT_SUCCESS ? Qtrue : Qfalse; + return RBOOL(WEXITSTATUS(status) == EXIT_SUCCESS); } @@ -729,136 +1038,449 @@ pst_wcoredump(VALUE st) #ifdef WCOREDUMP int status = PST2INT(st); - if (WCOREDUMP(status)) - return Qtrue; - else - return Qfalse; + return RBOOL(WCOREDUMP(status)); #else return Qfalse; #endif } -#if !defined(HAVE_WAITPID) && !defined(HAVE_WAIT4) -#define NO_WAITPID -static st_table *pid_tbl; +static rb_pid_t +do_waitpid(rb_pid_t pid, int *st, int flags) +{ +#if defined HAVE_WAITPID + return waitpid(pid, st, flags); +#elif defined HAVE_WAIT4 + return wait4(pid, st, flags, NULL); +#else +# error waitpid or wait4 is required. +#endif +} + +#define WAITPID_LOCK_ONLY ((struct waitpid_state *)-1) -struct wait_data { +struct waitpid_state { + struct list_node wnode; + rb_execution_context_t *ec; + rb_nativethread_cond_t *cond; + rb_pid_t ret; rb_pid_t pid; int status; + int options; + int errnum; }; +int rb_sigwait_fd_get(const rb_thread_t *); +void rb_sigwait_sleep(const rb_thread_t *, int fd, const rb_hrtime_t *); +void rb_sigwait_fd_put(const rb_thread_t *, int fd); +void rb_thread_sleep_interruptible(void); + static int -wait_each(rb_pid_t pid, int status, struct wait_data *data) +waitpid_signal(struct waitpid_state *w) { - if (data->status != -1) return ST_STOP; + if (w->ec) { /* rb_waitpid */ + rb_threadptr_interrupt(rb_ec_thread_ptr(w->ec)); + return TRUE; + } + else { /* ruby_waitpid_locked */ + if (w->cond) { + rb_native_cond_signal(w->cond); + return TRUE; + } + } + return FALSE; +} - data->pid = pid; - data->status = status; - return ST_DELETE; +/* + * When a thread is done using sigwait_fd and there are other threads + * sleeping on waitpid, we must kick one of the threads out of + * rb_native_cond_wait so it can switch to rb_sigwait_sleep + */ +static void +sigwait_fd_migrate_sleeper(rb_vm_t *vm) +{ + struct waitpid_state *w = 0; + + list_for_each(&vm->waiting_pids, w, wnode) { + if (waitpid_signal(w)) return; + } + list_for_each(&vm->waiting_grps, w, wnode) { + if (waitpid_signal(w)) return; + } } -static int -waitall_each(rb_pid_t pid, int status, VALUE ary) +void +rb_sigwait_fd_migrate(rb_vm_t *vm) { - rb_last_status_set(status, pid); - rb_ary_push(ary, rb_assoc_new(PIDT2NUM(pid), rb_last_status_get())); - return ST_DELETE; + rb_native_mutex_lock(&vm->waitpid_lock); + sigwait_fd_migrate_sleeper(vm); + rb_native_mutex_unlock(&vm->waitpid_lock); +} + +#if RUBY_SIGCHLD +extern volatile unsigned int ruby_nocldwait; /* signal.c */ +/* called by timer thread or thread which acquired sigwait_fd */ +static void +waitpid_each(rb_vm_t *vm, struct list_head *head) +{ + struct waitpid_state *w = 0, *next; + + list_for_each_safe(head, w, next, wnode) { + rb_pid_t ret = do_waitpid(w->pid, &w->status, w->options | WNOHANG); + + if (!ret) continue; + if (ret == -1) w->errnum = errno; + + if (w->pid <= 0) { + /* when waiting for a group of processes, make sure a waiter for a + * specific pid is given that event in preference */ + struct waitpid_state *w_inner = 0, *next_inner; + list_for_each_safe(&vm->waiting_pids, w_inner, next_inner, wnode) { + if (w_inner->pid == ret) { + /* signal this one instead */ + w = w_inner; + } + } + } + + w->ret = ret; + list_del_init(&w->wnode); + waitpid_signal(w); + } } #else -struct waitpid_arg { - rb_pid_t pid; - int flags; - int *st; -}; +# define ruby_nocldwait 0 #endif -static void * -rb_waitpid_blocking(void *data) +void +ruby_waitpid_all(rb_vm_t *vm) { - rb_pid_t result; -#ifndef NO_WAITPID - struct waitpid_arg *arg = data; +#if RUBY_SIGCHLD + rb_native_mutex_lock(&vm->waitpid_lock); + waitpid_each(vm, &vm->waiting_pids); + waitpid_each(vm, &vm->waiting_grps); + /* emulate SA_NOCLDWAIT */ + if (list_empty(&vm->waiting_pids) && list_empty(&vm->waiting_grps)) { + while (ruby_nocldwait && do_waitpid(-1, 0, WNOHANG) > 0) + ; /* keep looping */ + } + rb_native_mutex_unlock(&vm->waitpid_lock); #endif +} -#if defined NO_WAITPID - result = wait(data); -#elif defined HAVE_WAITPID - result = waitpid(arg->pid, arg->st, arg->flags); -#else /* HAVE_WAIT4 */ - result = wait4(arg->pid, arg->st, arg->flags, NULL); -#endif +static void +waitpid_state_init(struct waitpid_state *w, rb_pid_t pid, int options) +{ + w->ret = 0; + w->pid = pid; + w->options = options; + w->errnum = 0; + w->status = 0; +} + +static const rb_hrtime_t * +sigwait_sleep_time(void) +{ + if (SIGCHLD_LOSSY) { + static const rb_hrtime_t busy_wait = 100 * RB_HRTIME_PER_MSEC; - return (void *)(VALUE)result; + return &busy_wait; + } + return 0; } +/* + * must be called with vm->waitpid_lock held, this is not interruptible + */ rb_pid_t -rb_waitpid(rb_pid_t pid, int *st, int flags) +ruby_waitpid_locked(rb_vm_t *vm, rb_pid_t pid, int *status, int options, + rb_nativethread_cond_t *cond) { - rb_pid_t result; -#ifndef NO_WAITPID - struct waitpid_arg arg; - - retry: - arg.pid = pid; - arg.st = st; - arg.flags = flags; - result = (rb_pid_t)(VALUE)rb_thread_call_without_gvl(rb_waitpid_blocking, &arg, - RUBY_UBF_PROCESS, 0); - if (result < 0) { - if (errno == EINTR) { - RUBY_VM_CHECK_INTS(GET_THREAD()); - goto retry; + struct waitpid_state w; + + assert(!ruby_thread_has_gvl_p() && "must not have GVL"); + + waitpid_state_init(&w, pid, options); + if (w.pid > 0 || list_empty(&vm->waiting_pids)) + w.ret = do_waitpid(w.pid, &w.status, w.options | WNOHANG); + if (w.ret) { + if (w.ret == -1) w.errnum = errno; + } + else { + int sigwait_fd = -1; + + w.ec = 0; + list_add(w.pid > 0 ? &vm->waiting_pids : &vm->waiting_grps, &w.wnode); + do { + if (sigwait_fd < 0) + sigwait_fd = rb_sigwait_fd_get(0); + + if (sigwait_fd >= 0) { + w.cond = 0; + rb_native_mutex_unlock(&vm->waitpid_lock); + rb_sigwait_sleep(0, sigwait_fd, sigwait_sleep_time()); + rb_native_mutex_lock(&vm->waitpid_lock); + } + else { + w.cond = cond; + rb_native_cond_wait(w.cond, &vm->waitpid_lock); + } + } while (!w.ret); + list_del(&w.wnode); + + /* we're done, maybe other waitpid callers are not: */ + if (sigwait_fd >= 0) { + rb_sigwait_fd_put(0, sigwait_fd); + sigwait_fd_migrate_sleeper(vm); } - return (rb_pid_t)-1; - } -#else /* NO_WAITPID */ - if (pid_tbl) { - st_data_t status, piddata = (st_data_t)pid; - if (pid == (rb_pid_t)-1) { - struct wait_data data; - data.pid = (rb_pid_t)-1; - data.status = -1; - st_foreach(pid_tbl, wait_each, (st_data_t)&data); - if (data.status != -1) { - rb_last_status_set(data.status, data.pid); - return data.pid; - } - } - else if (st_delete(pid_tbl, &piddata, &status)) { - rb_last_status_set(*st = (int)status, pid); - return pid; - } } + if (status) { + *status = w.status; + } + if (w.ret == -1) errno = w.errnum; + return w.ret; +} + +static VALUE +waitpid_sleep(VALUE x) +{ + struct waitpid_state *w = (struct waitpid_state *)x; - if (flags) { - rb_raise(rb_eArgError, "can't do waitpid with flags"); + while (!w->ret) { + rb_thread_sleep_interruptible(); } - for (;;) { - result = (rb_pid_t)(VALUE)rb_thread_blocking_region(rb_waitpid_blocking, - st, RUBY_UBF_PROCESS, 0); - if (result < 0) { - if (errno == EINTR) { - rb_thread_schedule(); - continue; - } - return (rb_pid_t)-1; - } - if (result == pid || pid == (rb_pid_t)-1) { - break; - } - if (!pid_tbl) - pid_tbl = st_init_numtable(); - st_insert(pid_tbl, pid, (st_data_t)st); - if (!rb_thread_alone()) rb_thread_schedule(); + return Qfalse; +} + +static VALUE +waitpid_cleanup(VALUE x) +{ + struct waitpid_state *w = (struct waitpid_state *)x; + + /* + * XXX w->ret is sometimes set but list_del is still needed, here, + * Not sure why, so we unconditionally do list_del here: + */ + if (TRUE || w->ret == 0) { + rb_vm_t *vm = rb_ec_vm_ptr(w->ec); + + rb_native_mutex_lock(&vm->waitpid_lock); + list_del(&w->wnode); + rb_native_mutex_unlock(&vm->waitpid_lock); } -#endif - if (result > 0) { - rb_last_status_set(*st, result); + + return Qfalse; +} + +static void +waitpid_wait(struct waitpid_state *w) +{ + rb_vm_t *vm = rb_ec_vm_ptr(w->ec); + int need_sleep = FALSE; + + /* + * Lock here to prevent do_waitpid from stealing work from the + * ruby_waitpid_locked done by mjit workers since mjit works + * outside of GVL + */ + rb_native_mutex_lock(&vm->waitpid_lock); + + if (w->pid > 0 || list_empty(&vm->waiting_pids)) { + w->ret = do_waitpid(w->pid, &w->status, w->options | WNOHANG); } - return result; + + if (w->ret) { + if (w->ret == -1) w->errnum = errno; + } + else if (w->options & WNOHANG) { + } + else { + need_sleep = TRUE; + } + + if (need_sleep) { + w->cond = 0; + /* order matters, favor specified PIDs rather than -1 or 0 */ + list_add(w->pid > 0 ? &vm->waiting_pids : &vm->waiting_grps, &w->wnode); + } + + rb_native_mutex_unlock(&vm->waitpid_lock); + + if (need_sleep) { + rb_ensure(waitpid_sleep, (VALUE)w, waitpid_cleanup, (VALUE)w); + } +} + +static void * +waitpid_blocking_no_SIGCHLD(void *x) +{ + struct waitpid_state *w = x; + + w->ret = do_waitpid(w->pid, &w->status, w->options); + + return 0; +} + +static void +waitpid_no_SIGCHLD(struct waitpid_state *w) +{ + if (w->options & WNOHANG) { + w->ret = do_waitpid(w->pid, &w->status, w->options); + } + else { + do { + rb_thread_call_without_gvl(waitpid_blocking_no_SIGCHLD, w, + RUBY_UBF_PROCESS, 0); + } while (w->ret < 0 && errno == EINTR && (RUBY_VM_CHECK_INTS(w->ec),1)); + } + if (w->ret == -1) + w->errnum = errno; +} + +VALUE +rb_process_status_wait(rb_pid_t pid, int flags) +{ + // We only enter the scheduler if we are "blocking": + if (!(flags & WNOHANG)) { + VALUE scheduler = rb_fiber_scheduler_current(); + VALUE result = rb_fiber_scheduler_process_wait(scheduler, pid, flags); + if (result != Qundef) return result; + } + + struct waitpid_state waitpid_state; + + waitpid_state_init(&waitpid_state, pid, flags); + waitpid_state.ec = GET_EC(); + + if (WAITPID_USE_SIGCHLD) { + waitpid_wait(&waitpid_state); + } + else { + waitpid_no_SIGCHLD(&waitpid_state); + } + + if (waitpid_state.ret == 0) return Qnil; + + if (waitpid_state.ret > 0 && ruby_nocldwait) { + waitpid_state.ret = -1; + waitpid_state.errnum = ECHILD; + } + + return rb_process_status_new(waitpid_state.ret, waitpid_state.status, waitpid_state.errnum); +} + +/* + * call-seq: + * Process::Status.wait(pid=-1, flags=0) -> Process::Status + * + * Waits for a child process to exit and returns a Process::Status object + * containing information on that process. Which child it waits on + * depends on the value of _pid_: + * + * > 0:: Waits for the child whose process ID equals _pid_. + * + * 0:: Waits for any child whose process group ID equals that of the + * calling process. + * + * -1:: Waits for any child process (the default if no _pid_ is + * given). + * + * < -1:: Waits for any child whose process group ID equals the absolute + * value of _pid_. + * + * The _flags_ argument may be a logical or of the flag values + * Process::WNOHANG (do not block if no child available) + * or Process::WUNTRACED (return stopped children that + * haven't been reported). Not all flags are available on all + * platforms, but a flag value of zero will work on all platforms. + * + * Returns +nil+ if there are no child processes. + * Not available on all platforms. + * + * May invoke the scheduler hook _process_wait_. + * + * fork { exit 99 } #=> 27429 + * Process::Status.wait #=> pid 27429 exit 99 + * $? #=> nil + * + * pid = fork { sleep 3 } #=> 27440 + * Time.now #=> 2008-03-08 19:56:16 +0900 + * Process::Status.wait(pid, Process::WNOHANG) #=> nil + * Time.now #=> 2008-03-08 19:56:16 +0900 + * Process::Status.wait(pid, 0) #=> pid 27440 exit 99 + * Time.now #=> 2008-03-08 19:56:19 +0900 + * + * This is an EXPERIMENTAL FEATURE. + */ + +VALUE +rb_process_status_waitv(int argc, VALUE *argv, VALUE _) +{ + rb_check_arity(argc, 0, 2); + + rb_pid_t pid = -1; + int flags = 0; + + if (argc >= 1) { + pid = NUM2PIDT(argv[0]); + } + + if (argc >= 2) { + flags = RB_NUM2INT(argv[1]); + } + + return rb_process_status_wait(pid, flags); +} + +rb_pid_t +rb_waitpid(rb_pid_t pid, int *st, int flags) +{ + VALUE status = rb_process_status_wait(pid, flags); + if (NIL_P(status)) return 0; + + struct rb_process_status *data = RTYPEDDATA_DATA(status); + pid = data->pid; + + if (st) *st = data->status; + + if (pid == -1) { + errno = data->error; + } + else { + GET_THREAD()->last_status = status; + } + + return pid; } +static VALUE +proc_wait(int argc, VALUE *argv) +{ + rb_pid_t pid; + int flags, status; + + flags = 0; + if (rb_check_arity(argc, 0, 2) == 0) { + pid = -1; + } + else { + VALUE vflags; + pid = NUM2PIDT(argv[0]); + if (argc == 2 && !NIL_P(vflags = argv[1])) { + flags = NUM2UINT(vflags); + } + } + + if ((pid = rb_waitpid(pid, &status, flags)) < 0) + rb_sys_fail(0); + + if (pid == 0) { + rb_last_status_clear(); + return Qnil; + } + + return PIDT2NUM(pid); +} /* [MG]:FIXME: I wasn't sure how this should be done, since ::wait() has historically been documented as if it didn't take any arguments @@ -876,12 +1498,12 @@ rb_waitpid(rb_pid_t pid, int *st, int flags) /* * call-seq: - * Process.wait() -> fixnum - * Process.wait(pid=-1, flags=0) -> fixnum - * Process.waitpid(pid=-1, flags=0) -> fixnum + * Process.wait() -> integer + * Process.wait(pid=-1, flags=0) -> integer + * Process.waitpid(pid=-1, flags=0) -> integer * * Waits for a child process to exit, returns its process id, and - * sets <code>$?</code> to a <code>Process::Status</code> object + * sets <code>$?</code> to a Process::Status object * containing information on that process. Which child it waits on * depends on the value of _pid_: * @@ -897,8 +1519,8 @@ rb_waitpid(rb_pid_t pid, int *st, int flags) * value of _pid_. * * The _flags_ argument may be a logical or of the flag values - * <code>Process::WNOHANG</code> (do not block if no child available) - * or <code>Process::WUNTRACED</code> (return stopped children that + * Process::WNOHANG (do not block if no child available) + * or Process::WUNTRACED (return stopped children that * haven't been reported). Not all flags are available on all * platforms, but a flag value of zero will work on all platforms. * @@ -919,31 +1541,9 @@ rb_waitpid(rb_pid_t pid, int *st, int flags) */ static VALUE -proc_wait(int argc, VALUE *argv) +proc_m_wait(int c, VALUE *v, VALUE _) { - VALUE vpid, vflags; - rb_pid_t pid; - int flags, status; - - rb_secure(2); - flags = 0; - if (argc == 0) { - pid = -1; - } - else { - rb_scan_args(argc, argv, "02", &vpid, &vflags); - pid = NUM2PIDT(vpid); - if (argc == 2 && !NIL_P(vflags)) { - flags = NUM2UINT(vflags); - } - } - if ((pid = rb_waitpid(pid, &status, flags)) < 0) - rb_sys_fail(0); - if (pid == 0) { - rb_last_status_clear(); - return Qnil; - } - return PIDT2NUM(pid); + return proc_wait(c, v); } @@ -954,7 +1554,7 @@ proc_wait(int argc, VALUE *argv) * * Waits for a child process to exit (see Process::waitpid for exact * semantics) and returns an array containing the process id and the - * exit status (a <code>Process::Status</code> object) of that + * exit status (a Process::Status object) of that * child. Raises a SystemCallError if there are no child processes. * * Process.fork { exit 99 } #=> 27437 @@ -964,7 +1564,7 @@ proc_wait(int argc, VALUE *argv) */ static VALUE -proc_wait2(int argc, VALUE *argv) +proc_wait2(int argc, VALUE *argv, VALUE _) { VALUE pid = proc_wait(argc, argv); if (NIL_P(pid)) return Qnil; @@ -978,7 +1578,7 @@ proc_wait2(int argc, VALUE *argv) * * Waits for all children, returning an array of * _pid_/_status_ pairs (where _status_ is a - * <code>Process::Status</code> object). + * Process::Status object). * * fork { sleep 0.2; exit 2 } #=> 27432 * fork { sleep 0.1; exit 1 } #=> 27433 @@ -993,42 +1593,23 @@ proc_wait2(int argc, VALUE *argv) */ static VALUE -proc_waitall(void) +proc_waitall(VALUE _) { VALUE result; rb_pid_t pid; int status; - rb_secure(2); result = rb_ary_new(); -#ifdef NO_WAITPID - if (pid_tbl) { - st_foreach(pid_tbl, waitall_each, result); - } -#else rb_last_status_clear(); -#endif for (pid = -1;;) { -#ifdef NO_WAITPID - pid = wait(&status); -#else pid = rb_waitpid(-1, &status, 0); -#endif if (pid == -1) { - if (errno == ECHILD) + int e = errno; + if (e == ECHILD) break; -#ifdef NO_WAITPID - if (errno == EINTR) { - rb_thread_schedule(); - continue; - } -#endif - rb_sys_fail(0); + rb_syserr_fail(e, 0); } -#ifdef NO_WAITPID - rb_last_status_set(status, pid); -#endif rb_ary_push(result, rb_assoc_new(PIDT2NUM(pid), rb_last_status_get())); } return result; @@ -1070,20 +1651,19 @@ rb_detach_process(rb_pid_t pid) * * Some operating systems retain the status of terminated child * processes until the parent collects that status (normally using - * some variant of <code>wait()</code>. If the parent never collects + * some variant of <code>wait()</code>). If the parent never collects * this status, the child stays around as a <em>zombie</em> process. - * <code>Process::detach</code> prevents this by setting up a - * separate Ruby thread whose sole job is to reap the status of the - * process _pid_ when it terminates. Use <code>detach</code> - * only when you do not intent to explicitly wait for the child to - * terminate. + * Process::detach prevents this by setting up a separate Ruby thread + * whose sole job is to reap the status of the process _pid_ when it + * terminates. Use #detach only when you do not intend to explicitly + * wait for the child to terminate. * * The waiting thread returns the exit status of the detached process - * when it terminates, so you can use <code>Thread#join</code> to + * when it terminates, so you can use Thread#join to * know the result. If specified _pid_ is not a valid child process * ID, the thread returns +nil+ immediately. * - * The waiting thread has <code>pid</code> method which returns the pid. + * The waiting thread has #pid method which returns the pid. * * In this first example, we don't reap the first child process, so * it appears as a zombie in the process status display. @@ -1098,7 +1678,7 @@ rb_detach_process(rb_pid_t pid) * * 27389 Z * - * In the next example, <code>Process::detach</code> is used to reap + * In the next example, Process::detach is used to reap * the child automatically. * * p1 = fork { sleep 0.1 } @@ -1114,34 +1694,13 @@ rb_detach_process(rb_pid_t pid) static VALUE proc_detach(VALUE obj, VALUE pid) { - rb_secure(2); return rb_detach_process(NUM2PIDT(pid)); } -#ifdef SIGPIPE -static RETSIGTYPE (*saved_sigpipe_handler)(int) = 0; -#endif - -#ifdef SIGPIPE -static RETSIGTYPE -sig_do_nothing(int sig) -{ -} -#endif - /* This function should be async-signal-safe. Actually it is. */ static void before_exec_async_signal_safe(void) { -#ifdef SIGPIPE - /* - * Some OS commands don't initialize signal handler properly. Thus we have - * to reset signal handler before exec(). Otherwise, system() and similar - * child process interaction might fail. (e.g. ruby -e "system 'yes | ls'") - * [ruby-dev:12261] - */ - saved_sigpipe_handler = signal(SIGPIPE, sig_do_nothing); /* async-signal-safe */ -#endif } static void @@ -1153,8 +1712,43 @@ before_exec_non_async_signal_safe(void) * internal threads temporary. [ruby-core:10583] * This is also true on Haiku. It returns Errno::EPERM against exec() * in multiple threads. + * + * Nowadays, we always stop the timer thread completely to allow redirects. */ - rb_thread_stop_timer_thread(0); + rb_thread_stop_timer_thread(); +} + +#define WRITE_CONST(fd, str) (void)(write((fd),(str),sizeof(str)-1)<0) +#ifdef _WIN32 +int rb_w32_set_nonblock2(int fd, int nonblock); +#endif + +static int +set_blocking(int fd) +{ +#ifdef _WIN32 + return rb_w32_set_nonblock2(fd, 0); +#elif defined(F_GETFL) && defined(F_SETFL) + int fl = fcntl(fd, F_GETFL); /* async-signal-safe */ + + /* EBADF ought to be possible */ + if (fl == -1) return fl; + if (fl & O_NONBLOCK) { + fl &= ~O_NONBLOCK; + return fcntl(fd, F_SETFL, fl); + } + return 0; +#endif +} + +static void +stdfd_clear_nonblock(void) +{ + /* many programs cannot deal with non-blocking stdin/stdout/stderr */ + int fd; + for (fd = 0; fd < 3; fd++) { + (void)set_blocking(fd); /* can't do much about errors anyhow */ + } } static void @@ -1168,9 +1762,6 @@ before_exec(void) static void after_exec_async_signal_safe(void) { -#ifdef SIGPIPE - signal(SIGPIPE, saved_sigpipe_handler); /* async-signal-safe */ -#endif } static void @@ -1187,25 +1778,25 @@ after_exec(void) after_exec_non_async_signal_safe(); } -#define before_fork_ruby() before_exec() -#define after_fork_ruby() (rb_threadptr_pending_interrupt_clear(GET_THREAD()), after_exec()) - -#include "dln.h" +#if defined HAVE_WORKING_FORK || defined HAVE_DAEMON +static void +before_fork_ruby(void) +{ + before_exec(); +} static void -security(const char *str) +after_fork_ruby(void) { - if (rb_env_path_tainted()) { - if (rb_safe_level() > 0) { - rb_raise(rb_eSecurityError, "Insecure PATH - %s", str); - } - } + rb_threadptr_pending_interrupt_clear(GET_THREAD()); + after_exec(); } +#endif -#if defined(HAVE_WORKING_FORK) && !defined(__native_client__) +#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) { @@ -1214,75 +1805,41 @@ exec_with_sh(const char *prog, char **argv, char **envp) if (envp) execve("/bin/sh", argv, envp); /* async-signal-safe */ else - execv("/bin/sh", argv); /* async-signal-safe */ + execv("/bin/sh", argv); /* async-signal-safe (since SUSv4) */ } #else -#define try_with_sh(prog, argv, envp) (void)0 +#define try_with_sh(err, prog, argv, envp) (void)0 #endif /* This function should be async-signal-safe. Actually it is. */ static int proc_exec_cmd(const char *prog, VALUE argv_str, VALUE envp_str) { -#ifdef __native_client__ - rb_notimplement(); - UNREACHABLE; -#else char **argv; +#ifndef _WIN32 char **envp; -# if defined(__EMX__) || defined(OS2) - char **new_argv = NULL; -# endif + int err; +#endif argv = ARGVSTR2ARGV(argv_str); if (!prog) { - errno = ENOENT; - return -1; + return ENOENT; } -# if defined(__EMX__) || defined(OS2) - { -# define COMMAND "cmd.exe" - char *extension; - - if ((extension = strrchr(prog, '.')) != NULL && STRCASECMP(extension, ".bat") == 0) { - char *p; - int n; - - for (n = 0; argv[n]; n++) - /* no-op */; - new_argv = ALLOC_N(char*, n + 2); - for (; n > 0; n--) - new_argv[n + 1] = argv[n]; - new_argv[1] = strcpy(ALLOC_N(char, strlen(argv[0]) + 1), argv[0]); - for (p = new_argv[1]; *p != '\0'; p++) - if (*p == '/') - *p = '\\'; - new_argv[0] = COMMAND; - argv = new_argv; - prog = dln_find_exe_r(argv[0], 0, fbuf, sizeof(fbuf)); - if (!prog) { - errno = ENOENT; - return -1; - } - } - } -# endif /* __EMX__ */ - envp = envp_str ? (char **)RSTRING_PTR(envp_str) : NULL; +#ifdef _WIN32 + rb_w32_uaspawn(P_OVERLAY, prog, argv); + return errno; +#else + envp = envp_str ? RB_IMEMO_TMPBUF_PTR(envp_str) : NULL; if (envp_str) execve(prog, argv, envp); /* async-signal-safe */ else - execv(prog, argv); /* async-signal-safe */ - preserving_errno(try_with_sh(prog, argv, envp)); /* try_with_sh() is async-signal-safe. */ -# if defined(__EMX__) || defined(OS2) - if (new_argv) { - xfree(new_argv[0]); - xfree(new_argv); - } -# endif - return -1; + execv(prog, argv); /* async-signal-safe (since SUSv4) */ + err = errno; + try_with_sh(err, prog, argv, envp); /* try_with_sh() is async-signal-safe. */ + return err; #endif } @@ -1290,10 +1847,6 @@ proc_exec_cmd(const char *prog, VALUE argv_str, VALUE envp_str) static int proc_exec_sh(const char *str, VALUE envp_str) { -#ifdef __native_client__ - rb_notimplement(); - UNREACHABLE; -#else const char *s; s = str; @@ -1301,15 +1854,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__) || defined(__EMX__) +#elif defined(__CYGWIN32__) { char fbuf[MAXPATHLEN]; char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf)); @@ -1323,13 +1873,11 @@ proc_exec_sh(const char *str, VALUE envp_str) } #else if (envp_str) - execle("/bin/sh", "sh", "-c", str, (char *)NULL, (char **)RSTRING_PTR(envp_str)); /* async-signal-safe */ + execle("/bin/sh", "sh", "-c", str, (char *)NULL, RB_IMEMO_TMPBUF_PTR(envp_str)); /* async-signal-safe */ else - execl("/bin/sh", "sh", "-c", str, (char *)NULL); /* async-signal-safe */ -#endif - return -1; + execl("/bin/sh", "sh", "-c", str, (char *)NULL); /* async-signal-safe (since SUSv4) */ #endif /* _WIN32 */ -#endif + return errno; } int @@ -1338,8 +1886,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 @@ -1364,6 +1913,7 @@ mark_exec_arg(void *ptr) rb_gc_mark(eargp->fd_open); rb_gc_mark(eargp->fd_dup2_child); rb_gc_mark(eargp->env_modification); + rb_gc_mark(eargp->path_env); rb_gc_mark(eargp->chdir_dir); } @@ -1418,7 +1968,6 @@ proc_spawn_cmd_internal(char **argv, char *prog) if (!prog) prog = argv[0]; - security(prog); prog = dln_find_exe_r(prog, 0, fbuf, sizeof(fbuf)); if (!prog) return -1; @@ -1499,7 +2048,7 @@ check_exec_redirect_fd(VALUE v, int iskey) else goto wrong; } - else if (!NIL_P(tmp = rb_check_convert_type(v, T_FILE, "IO", "to_io"))) { + else if (!NIL_P(tmp = rb_io_check_io(v))) { rb_io_t *fptr; GetOpenFile(tmp, fptr); if (fptr->tied_io_for_writing) @@ -1507,8 +2056,7 @@ check_exec_redirect_fd(VALUE v, int iskey) fd = fptr->fd; } else { - wrong: - rb_raise(rb_eArgError, "wrong exec redirect"); + goto wrong; } if (fd < 0) { rb_raise(rb_eArgError, "negative file descriptor"); @@ -1519,6 +2067,10 @@ check_exec_redirect_fd(VALUE v, int iskey) } #endif return INT2FIX(fd); + + wrong: + rb_raise(rb_eArgError, "wrong exec redirect"); + UNREACHABLE_RETURN(Qundef); } static VALUE @@ -1532,12 +2084,11 @@ check_exec_redirect1(VALUE ary, VALUE key, VALUE param) rb_ary_push(ary, hide_obj(rb_assoc_new(fd, param))); } else { - int i, n=0; + int i; for (i = 0 ; i < RARRAY_LEN(key); i++) { VALUE v = RARRAY_AREF(key, i); VALUE fd = check_exec_redirect_fd(v, !NIL_P(param)); rb_ary_push(ary, hide_obj(rb_assoc_new(fd, param))); - n++; } } return ary; @@ -1553,7 +2104,7 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp) switch (TYPE(val)) { case T_SYMBOL: - if (!(id = rb_check_id(&val))) goto wrong_symbol; + id = rb_check_id(&val); if (id == id_close) { param = Qnil; eargp->fd_close = check_exec_redirect1(eargp->fd_close, key, param); @@ -1571,7 +2122,6 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp) eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param); } else { - wrong_symbol: rb_raise(rb_eArgError, "wrong exec redirect symbol: %"PRIsVALUE, val); } @@ -1604,8 +2154,8 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp) flags = rb_to_int(flags); perm = rb_ary_entry(val, 2); perm = NIL_P(perm) ? INT2FIX(0644) : rb_to_int(perm); - param = hide_obj(rb_ary_new3(3, hide_obj(EXPORT_DUP(path)), - flags, perm)); + param = hide_obj(rb_ary_new3(4, hide_obj(EXPORT_DUP(path)), + flags, perm, Qnil)); eargp->fd_open = check_exec_redirect1(eargp->fd_open, key, param); } break; @@ -1620,7 +2170,7 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp) else if (RB_TYPE_P(key, T_ARRAY)) { int i; for (i = 0; i < RARRAY_LEN(key); i++) { - VALUE v = RARRAY_PTR(key)[i]; + VALUE v = RARRAY_AREF(key, i); VALUE fd = check_exec_redirect_fd(v, 1); if (FIX2INT(fd) != 1 && FIX2INT(fd) != 2) break; } @@ -1632,8 +2182,8 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp) else flags = INT2NUM(O_RDONLY); perm = INT2FIX(0644); - param = hide_obj(rb_ary_new3(3, hide_obj(EXPORT_DUP(path)), - flags, perm)); + param = hide_obj(rb_ary_new3(4, hide_obj(EXPORT_DUP(path)), + flags, perm, Qnil)); eargp->fd_open = check_exec_redirect1(eargp->fd_open, key, param); break; @@ -1647,23 +2197,57 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp) } #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) -static int rlimit_type_by_lname(const char *name); +static int rlimit_type_by_sym(VALUE key); + +static void +rb_execarg_addopt_rlimit(struct rb_execarg *eargp, int rtype, VALUE val) +{ + VALUE ary = eargp->rlimit_limits; + VALUE tmp, softlim, hardlim; + if (eargp->rlimit_limits == Qfalse) + ary = eargp->rlimit_limits = hide_obj(rb_ary_new()); + else + ary = eargp->rlimit_limits; + tmp = rb_check_array_type(val); + if (!NIL_P(tmp)) { + if (RARRAY_LEN(tmp) == 1) + softlim = hardlim = rb_to_int(rb_ary_entry(tmp, 0)); + else if (RARRAY_LEN(tmp) == 2) { + softlim = rb_to_int(rb_ary_entry(tmp, 0)); + hardlim = rb_to_int(rb_ary_entry(tmp, 1)); + } + else { + rb_raise(rb_eArgError, "wrong exec rlimit option"); + } + } + else { + softlim = hardlim = rb_to_int(val); + } + tmp = hide_obj(rb_ary_new3(3, INT2NUM(rtype), softlim, hardlim)); + rb_ary_push(ary, tmp); +} #endif +#define TO_BOOL(val, name) NIL_P(val) ? 0 : rb_bool_expected((val), name) int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); ID id; -#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) - int rtype; -#endif - - rb_secure(2); switch (TYPE(key)) { case T_SYMBOL: +#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) + { + int rtype = rlimit_type_by_sym(key); + if (rtype != -1) { + rb_execarg_addopt_rlimit(eargp, rtype, val); + RB_GC_GUARD(execarg_obj); + return ST_CONTINUE; + } + } +#endif if (!(id = rb_check_id(&key))) return ST_STOP; #ifdef HAVE_SETPGID if (id == id_pgroup) { @@ -1692,36 +2276,7 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) rb_raise(rb_eArgError, "new_pgroup option specified twice"); } eargp->new_pgroup_given = 1; - eargp->new_pgroup_flag = RTEST(val) ? 1 : 0; - } - else -#endif -#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) - if (strncmp("rlimit_", rb_id2name(id), 7) == 0 && - (rtype = rlimit_type_by_lname(rb_id2name(id)+7)) != -1) { - VALUE ary = eargp->rlimit_limits; - VALUE tmp, softlim, hardlim; - if (eargp->rlimit_limits == Qfalse) - ary = eargp->rlimit_limits = hide_obj(rb_ary_new()); - else - ary = eargp->rlimit_limits; - tmp = rb_check_array_type(val); - if (!NIL_P(tmp)) { - if (RARRAY_LEN(tmp) == 1) - softlim = hardlim = rb_to_int(rb_ary_entry(tmp, 0)); - else if (RARRAY_LEN(tmp) == 2) { - softlim = rb_to_int(rb_ary_entry(tmp, 0)); - hardlim = rb_to_int(rb_ary_entry(tmp, 1)); - } - else { - rb_raise(rb_eArgError, "wrong exec rlimit option"); - } - } - else { - softlim = hardlim = rb_to_int(val); - } - tmp = hide_obj(rb_ary_new3(3, INT2NUM(rtype), softlim, hardlim)); - rb_ary_push(ary, tmp); + eargp->new_pgroup_flag = TO_BOOL(val, "new_pgroup"); } else #endif @@ -1730,7 +2285,7 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) rb_raise(rb_eArgError, "unsetenv_others option specified twice"); } eargp->unsetenv_others_given = 1; - eargp->unsetenv_others_do = RTEST(val) ? 1 : 0; + eargp->unsetenv_others_do = TO_BOOL(val, "unsetenv_others"); } else if (id == id_chdir) { if (eargp->chdir_given) { @@ -1754,7 +2309,7 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) rb_raise(rb_eArgError, "close_others option specified twice"); } eargp->close_others_given = 1; - eargp->close_others_do = RTEST(val) ? 1 : 0; + eargp->close_others_do = TO_BOOL(val, "close_others"); } else if (id == id_in) { key = INT2FIX(0); @@ -1798,6 +2353,13 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) "gid option is unimplemented on this machine"); #endif } + else if (id == id_exception) { + if (eargp->exception_given) { + rb_raise(rb_eArgError, "exception option specified twice"); + } + eargp->exception_given = 1; + eargp->exception = TO_BOOL(val, "exception"); + } else { return ST_STOP; } @@ -1826,7 +2388,7 @@ check_exec_options_i(st_data_t st_key, st_data_t st_val, st_data_t arg) VALUE execarg_obj = (VALUE)arg; if (rb_execarg_addopt(execarg_obj, key, val) != ST_CONTINUE) { if (SYMBOL_P(key)) - rb_raise(rb_eArgError, "wrong exec option symbol: %"PRIsVALUE, + rb_raise(rb_eArgError, "wrong exec option symbol: % "PRIsVALUE, key); rb_raise(rb_eArgError, "wrong exec option"); } @@ -1860,7 +2422,7 @@ check_exec_fds_1(struct rb_execarg *eargp, VALUE h, int maxhint, VALUE ary) if (RTEST(rb_hash_lookup(h, INT2FIX(fd)))) { rb_raise(rb_eArgError, "fd %d specified twice", fd); } - if (ary == eargp->fd_open || ary == eargp->fd_dup2) + if (ary == eargp->fd_dup2) rb_hash_aset(h, INT2FIX(fd), Qtrue); else if (ary == eargp->fd_dup2_child) rb_hash_aset(h, INT2FIX(fd), RARRAY_AREF(elt, 1)); @@ -1888,7 +2450,6 @@ check_exec_fds(struct rb_execarg *eargp) maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_dup2); maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_close); - maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_open); maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_dup2_child); if (eargp->fd_dup2_child) { @@ -1931,7 +2492,7 @@ rb_check_exec_options(VALUE opthash, VALUE execarg_obj) { if (RHASH_EMPTY_P(opthash)) return; - st_foreach(rb_hash_tbl_raw(opthash), check_exec_options_i, (st_data_t)execarg_obj); + rb_hash_stlike_foreach(opthash, check_exec_options_i, (st_data_t)execarg_obj); } VALUE @@ -1942,21 +2503,28 @@ rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash) return Qnil; args[0] = execarg_obj; args[1] = Qnil; - st_foreach(rb_hash_tbl_raw(opthash), check_exec_options_i_extract, (st_data_t)args); + rb_hash_stlike_foreach(opthash, check_exec_options_i_extract, (st_data_t)args); return args[1]; } +#ifdef ENV_IGNORECASE +#define ENVMATCH(s1, s2) (STRCASECMP((s1), (s2)) == 0) +#else +#define ENVMATCH(n1, n2) (strcmp((n1), (n2)) == 0) +#endif + static int check_exec_env_i(st_data_t st_key, st_data_t st_val, st_data_t arg) { VALUE key = (VALUE)st_key; VALUE val = (VALUE)st_val; - VALUE env = (VALUE)arg; + VALUE env = ((VALUE *)arg)[0]; + VALUE *path = &((VALUE *)arg)[1]; char *k; k = StringValueCStr(key); if (strchr(k, '=')) - rb_raise(rb_eArgError, "environment name contains a equal : %s", k); + rb_raise(rb_eArgError, "environment name contains a equal : %"PRIsVALUE, key); if (!NIL_P(val)) StringValueCStr(val); @@ -1964,20 +2532,25 @@ check_exec_env_i(st_data_t st_key, st_data_t st_val, st_data_t arg) key = EXPORT_STR(key); if (!NIL_P(val)) val = EXPORT_STR(val); + if (ENVMATCH(k, PATH_ENV)) { + *path = val; + } rb_ary_push(env, hide_obj(rb_assoc_new(key, val))); return ST_CONTINUE; } static VALUE -rb_check_exec_env(VALUE hash) +rb_check_exec_env(VALUE hash, VALUE *path) { - VALUE env; + VALUE env[2]; - env = hide_obj(rb_ary_new()); - st_foreach(rb_hash_tbl_raw(hash), check_exec_env_i, (st_data_t)env); + env[0] = hide_obj(rb_ary_new()); + env[1] = Qfalse; + rb_hash_stlike_foreach(hash, check_exec_env_i, (st_data_t)env); + *path = env[1]; - return env; + return env[0]; } static VALUE @@ -1985,7 +2558,6 @@ rb_check_argv(int argc, VALUE *argv) { VALUE tmp, prog; int i; - const char *name = 0; rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); @@ -2000,25 +2572,25 @@ rb_check_argv(int argc, VALUE *argv) SafeStringValue(prog); StringValueCStr(prog); prog = rb_str_new_frozen(prog); - name = RSTRING_PTR(prog); } for (i = 0; i < argc; i++) { SafeStringValue(argv[i]); argv[i] = rb_str_new_frozen(argv[i]); StringValueCStr(argv[i]); } - security(name ? name : RSTRING_PTR(argv[0])); return prog; } static VALUE check_hash(VALUE obj) { - if (SPECIAL_CONST_P(obj)) return Qnil; - switch (BUILTIN_TYPE(obj)) { + if (RB_SPECIAL_CONST_P(obj)) return Qnil; + switch (RB_BUILTIN_TYPE(obj)) { case T_STRING: case T_ARRAY: return Qnil; + default: + break; } return rb_check_hash_type(obj); } @@ -2083,7 +2655,7 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL rb_check_exec_options(opthash, execarg_obj); } if (!NIL_P(env)) { - env = rb_check_exec_env(env); + env = rb_check_exec_env(env, &eargp->path_env); eargp->env_modification = env; } @@ -2200,14 +2772,19 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL } } eargp->invoke.cmd.argv_buf = argv_buf; - eargp->invoke.cmd.command_name = hide_obj(rb_str_new_cstr(RSTRING_PTR(argv_buf))); + eargp->invoke.cmd.command_name = + hide_obj(rb_str_subseq(argv_buf, 0, strlen(RSTRING_PTR(argv_buf)))); + rb_enc_copy(eargp->invoke.cmd.command_name, prog); } } #endif if (!eargp->use_shell) { const char *abspath; - abspath = dln_find_exe_r(RSTRING_PTR(eargp->invoke.cmd.command_name), 0, fbuf, sizeof(fbuf)); + const char *path_env = 0; + if (RTEST(eargp->path_env)) path_env = RSTRING_PTR(eargp->path_env); + abspath = dln_find_exe_r(RSTRING_PTR(eargp->invoke.cmd.command_name), + path_env, fbuf, sizeof(fbuf)); if (abspath) eargp->invoke.cmd.command_abspath = rb_str_new_cstr(abspath); else @@ -2243,22 +2820,12 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL p += strlen(p) + 1; } rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* terminator for execve. */ - eargp->invoke.cmd.argv_str = argv_str; + eargp->invoke.cmd.argv_str = + rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(argv_str); } RB_GC_GUARD(execarg_obj); } -VALUE -rb_execarg_new(int argc, const VALUE *argv, int accept_shell) -{ - VALUE execarg_obj; - struct rb_execarg *eargp; - execarg_obj = TypedData_Make_Struct(rb_cData, struct rb_execarg, &exec_arg_data_type, eargp); - hide_obj(execarg_obj); - rb_execarg_init(argc, argv, accept_shell, execarg_obj); - return execarg_obj; -} - struct rb_execarg * rb_execarg_get(VALUE execarg_obj) { @@ -2267,7 +2834,7 @@ rb_execarg_get(VALUE execarg_obj) return eargp; } -VALUE +static VALUE rb_execarg_init(int argc, const VALUE *orig_argv, int accept_shell, VALUE execarg_obj) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); @@ -2284,11 +2851,24 @@ rb_execarg_init(int argc, const VALUE *orig_argv, int accept_shell, VALUE execar return ret; } +VALUE +rb_execarg_new(int argc, const VALUE *argv, int accept_shell, int allow_exc_opt) +{ + VALUE execarg_obj; + struct rb_execarg *eargp; + execarg_obj = TypedData_Make_Struct(0, struct rb_execarg, &exec_arg_data_type, eargp); + rb_execarg_init(argc, argv, accept_shell, execarg_obj); + if (!allow_exc_opt && eargp->exception_given) { + rb_raise(rb_eArgError, "exception option is not allowed"); + } + return execarg_obj; +} + void rb_execarg_setenv(VALUE execarg_obj, VALUE env) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); - env = !NIL_P(env) ? rb_check_exec_env(env) : Qfalse; + env = !NIL_P(env) ? rb_check_exec_env(env, &eargp->path_env) : Qfalse; eargp->env_modification = env; } @@ -2310,35 +2890,97 @@ fill_envp_buf_i(st_data_t st_key, st_data_t st_val, st_data_t arg) static long run_exec_dup2_tmpbuf_size(long n); -void -rb_execarg_fixup(VALUE execarg_obj) +struct open_struct { + VALUE fname; + int oflags; + mode_t perm; + int ret; + int err; +}; + +static void * +open_func(void *ptr) +{ + struct open_struct *data = ptr; + const char *fname = RSTRING_PTR(data->fname); + data->ret = parent_redirect_open(fname, data->oflags, data->perm); + data->err = errno; + return NULL; +} + +static void +rb_execarg_allocate_dup2_tmpbuf(struct rb_execarg *eargp, long len) +{ + VALUE tmpbuf = rb_imemo_tmpbuf_auto_free_pointer(); + rb_imemo_tmpbuf_set_ptr(tmpbuf, ruby_xmalloc(run_exec_dup2_tmpbuf_size(len))); + eargp->dup2_tmpbuf = tmpbuf; +} + +static VALUE +rb_execarg_parent_start1(VALUE execarg_obj) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); int unsetenv_others; VALUE envopts; VALUE ary; + ary = eargp->fd_open; + if (ary != Qfalse) { + long i; + for (i = 0; i < RARRAY_LEN(ary); i++) { + VALUE elt = RARRAY_AREF(ary, i); + int fd = FIX2INT(RARRAY_AREF(elt, 0)); + VALUE param = RARRAY_AREF(elt, 1); + VALUE vpath = RARRAY_AREF(param, 0); + int flags = NUM2INT(RARRAY_AREF(param, 1)); + mode_t perm = NUM2MODET(RARRAY_AREF(param, 2)); + VALUE fd2v = RARRAY_AREF(param, 3); + int fd2; + if (NIL_P(fd2v)) { + struct open_struct open_data; + again: + open_data.fname = vpath; + open_data.oflags = flags; + open_data.perm = perm; + open_data.ret = -1; + open_data.err = EINTR; + rb_thread_call_without_gvl2(open_func, (void *)&open_data, RUBY_UBF_IO, 0); + if (open_data.ret == -1) { + if (open_data.err == EINTR) { + rb_thread_check_ints(); + goto again; + } + rb_syserr_fail_str(open_data.err, vpath); + } + fd2 = open_data.ret; + rb_update_max_fd(fd2); + RARRAY_ASET(param, 3, INT2FIX(fd2)); + rb_thread_check_ints(); + } + else { + fd2 = NUM2INT(fd2v); + } + rb_execarg_addopt(execarg_obj, INT2FIX(fd), INT2FIX(fd2)); + } + } + eargp->redirect_fds = check_exec_fds(eargp); ary = eargp->fd_dup2; if (ary != Qfalse) { - size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary)); - VALUE tmpbuf = hide_obj(rb_str_new(0, len)); - rb_str_set_len(tmpbuf, len); - eargp->dup2_tmpbuf = tmpbuf; + rb_execarg_allocate_dup2_tmpbuf(eargp, RARRAY_LEN(ary)); } unsetenv_others = eargp->unsetenv_others_given && eargp->unsetenv_others_do; envopts = eargp->env_modification; - if (unsetenv_others || envopts != Qfalse) { + if (ALWAYS_NEED_ENVP || unsetenv_others || envopts != Qfalse) { VALUE envtbl, envp_str, envp_buf; char *p, *ep; if (unsetenv_others) { envtbl = rb_hash_new(); } else { - envtbl = rb_const_get(rb_cObject, id_ENV); - envtbl = rb_convert_type(envtbl, T_HASH, "Hash", "to_hash"); + envtbl = rb_env_to_hash(); } hide_obj(envtbl); if (envopts != Qfalse) { @@ -2361,7 +3003,7 @@ rb_execarg_fixup(VALUE execarg_obj) } envp_buf = rb_str_buf_new(0); hide_obj(envp_buf); - st_foreach(RHASH_TBL_RAW(envtbl), fill_envp_buf_i, (st_data_t)envp_buf); + rb_hash_stlike_foreach(envtbl, fill_envp_buf_i, (st_data_t)envp_buf); envp_str = rb_str_buf_new(sizeof(char*) * (RHASH_SIZE(envtbl) + 1)); hide_obj(envp_str); p = RSTRING_PTR(envp_buf); @@ -2372,7 +3014,8 @@ rb_execarg_fixup(VALUE execarg_obj) } p = NULL; rb_str_buf_cat(envp_str, (char *)&p, sizeof(p)); - eargp->envp_str = envp_str; + eargp->envp_str = + rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(envp_str); eargp->envp_buf = envp_buf; /* @@ -2383,13 +3026,111 @@ rb_execarg_fixup(VALUE execarg_obj) } */ } + + RB_GC_GUARD(execarg_obj); + return Qnil; +} + +void +rb_execarg_parent_start(VALUE execarg_obj) +{ + int state; + rb_protect(rb_execarg_parent_start1, execarg_obj, &state); + if (state) { + rb_execarg_parent_end(execarg_obj); + rb_jump_tag(state); + } +} + +static VALUE +execarg_parent_end(VALUE execarg_obj) +{ + struct rb_execarg *eargp = rb_execarg_get(execarg_obj); + int err = errno; + VALUE ary; + + ary = eargp->fd_open; + if (ary != Qfalse) { + long i; + for (i = 0; i < RARRAY_LEN(ary); i++) { + VALUE elt = RARRAY_AREF(ary, i); + VALUE param = RARRAY_AREF(elt, 1); + VALUE fd2v; + int fd2; + fd2v = RARRAY_AREF(param, 3); + if (!NIL_P(fd2v)) { + fd2 = FIX2INT(fd2v); + parent_redirect_close(fd2); + RARRAY_ASET(param, 3, Qnil); + } + } + } + + errno = err; + return execarg_obj; +} + +void +rb_execarg_parent_end(VALUE execarg_obj) +{ + execarg_parent_end(execarg_obj); RB_GC_GUARD(execarg_obj); } -#if defined(__APPLE__) || defined(__HAIKU__) -static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen); +static void +rb_exec_fail(struct rb_execarg *eargp, int err, const char *errmsg) +{ + if (!errmsg || !*errmsg) return; + if (strcmp(errmsg, "chdir") == 0) { + rb_sys_fail_str(eargp->chdir_dir); + } + rb_sys_fail(errmsg); +} + +#if 0 +void +rb_execarg_fail(VALUE execarg_obj, int err, const char *errmsg) +{ + if (!errmsg || !*errmsg) return; + rb_exec_fail(rb_execarg_get(execarg_obj), err, errmsg); + RB_GC_GUARD(execarg_obj); +} #endif +VALUE +rb_f_exec(int argc, const VALUE *argv) +{ + VALUE execarg_obj, fail_str; + struct rb_execarg *eargp; +#define CHILD_ERRMSG_BUFLEN 80 + char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; + int err, state; + + execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE); + eargp = rb_execarg_get(execarg_obj); + if (mjit_enabled) mjit_finish(false); // avoid leaking resources, and do not leave files. XXX: JIT-ed handle can leak after exec error is rescued. + before_exec(); /* stop timer thread before redirects */ + + rb_protect(rb_execarg_parent_start1, execarg_obj, &state); + if (state) { + execarg_parent_end(execarg_obj); + after_exec(); /* restart timer thread */ + rb_jump_tag(state); + } + + fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; + + err = exec_async_signal_safe(eargp, errmsg, sizeof(errmsg)); + after_exec(); /* restart timer thread */ + + rb_exec_fail(eargp, err, errmsg); + RB_GC_GUARD(execarg_obj); + rb_syserr_fail_str(err, fail_str); + UNREACHABLE_RETURN(Qnil); +} + +NORETURN(static VALUE f_exec(int c, const VALUE *a, VALUE _)); + /* * call-seq: * exec([env,] command... [,options]) @@ -2408,14 +3149,15 @@ static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *er * shell expansion before being executed. * * The standard shell always means <code>"/bin/sh"</code> on Unix-like systems, - * same as <code>ENV["RUBYSHELL"]</code> - * (or <code>ENV["COMSPEC"]</code> on Windows NT series), and similar. + * otherwise, <code>ENV["RUBYSHELL"]</code> or <code>ENV["COMSPEC"]</code> on + * Windows and similar. The command is passed as an argument to the + * <code>"-c"</code> switch to the shell, except in the case of +COMSPEC+. * * If the string from the first form (<code>exec("command")</code>) follows * these simple rules: * * * no meta characters - * * no shell reserved word and no special built-in + * * not starting with shell reserved word or special built-in * * Ruby invokes the command directly without shell * * You can force shell invocation by adding ";" to the string (because ";" is @@ -2441,7 +3183,7 @@ static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *er * This behavior is modified by the given +env+ and +options+ parameters. See * ::spawn for details. * - * If the command fails to execute (typically <code>Errno::ENOENT</code> when + * If the command fails to execute (typically Errno::ENOENT when * it was not found) a SystemCallError exception is raised. * * This method modifies process attributes according to given +options+ before @@ -2463,110 +3205,27 @@ static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *er * # never get here */ -VALUE -rb_f_exec(int argc, const VALUE *argv) +static VALUE +f_exec(int c, const VALUE *a, VALUE _) { - VALUE execarg_obj, fail_str; - struct rb_execarg *eargp; -#define CHILD_ERRMSG_BUFLEN 80 - char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; - - execarg_obj = rb_execarg_new(argc, argv, TRUE); - eargp = rb_execarg_get(execarg_obj); - rb_execarg_fixup(execarg_obj); - fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; - -#if defined(__APPLE__) || defined(__HAIKU__) - rb_exec_without_timer_thread(eargp, errmsg, sizeof(errmsg)); -#else - before_exec_async_signal_safe(); /* async-signal-safe */ - rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg)); - preserving_errno(after_exec_async_signal_safe()); /* async-signal-safe */ -#endif - RB_GC_GUARD(execarg_obj); - if (errmsg[0]) - rb_sys_fail(errmsg); - rb_sys_fail_str(fail_str); - return Qnil; /* dummy */ + rb_f_exec(c, a); + UNREACHABLE_RETURN(Qnil); } #define ERRMSG(str) do { if (errmsg && 0 < errmsg_buflen) strlcpy(errmsg, (str), errmsg_buflen); } while (0) +#define ERRMSG1(str, a) do { if (errmsg && 0 < errmsg_buflen) snprintf(errmsg, errmsg_buflen, (str), (a)); } while (0) +#define ERRMSG2(str, a, b) do { if (errmsg && 0 < errmsg_buflen) snprintf(errmsg, errmsg_buflen, (str), (a), (b)); } while (0) -/*#define DEBUG_REDIRECT*/ -#if defined(DEBUG_REDIRECT) - -#include <stdarg.h> - -static void -ttyprintf(const char *fmt, ...) -{ - va_list ap; - FILE *tty; - int save = errno; -#ifdef _WIN32 - tty = fopen("con", "w"); -#else - tty = fopen("/dev/tty", "w"); -#endif - if (!tty) - return; - - va_start(ap, fmt); - vfprintf(tty, fmt, ap); - va_end(ap); - fclose(tty); - errno = save; -} - -static int -redirect_dup(int oldfd) -{ - int ret; - ret = dup(oldfd); - ttyprintf("dup(%d) => %d\n", oldfd, ret); - return ret; -} - -static int -redirect_dup2(int oldfd, int newfd) -{ - int ret; - ret = dup2(oldfd, newfd); - ttyprintf("dup2(%d, %d)\n", oldfd, newfd); - return ret; -} - -static int -redirect_close(int fd) -{ - int ret; - ret = close(fd); - ttyprintf("close(%d)\n", fd); - return ret; -} - -static int -redirect_open(const char *pathname, int flags, mode_t perm) -{ - int ret; - ret = open(pathname, flags, perm); - ttyprintf("open(\"%s\", 0x%x, 0%o) => %d\n", pathname, flags, perm, ret); - return ret; -} - -#else -#define redirect_dup(oldfd) dup(oldfd) -#define redirect_dup2(oldfd, newfd) dup2((oldfd), (newfd)) -#define redirect_close(fd) close(fd) -#define redirect_open(pathname, flags, perm) open((pathname), (flags), (perm)) -#endif +static int fd_get_cloexec(int fd, char *errmsg, size_t errmsg_buflen); +static int fd_set_cloexec(int fd, char *errmsg, size_t errmsg_buflen); +static int fd_clear_cloexec(int fd, char *errmsg, size_t errmsg_buflen); static int save_redirect_fd(int fd, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { if (sargp) { - VALUE newary; - int save_fd = redirect_dup(fd); + VALUE newary, redirection; + int save_fd = redirect_cloexec_dup(fd), cloexec; if (save_fd == -1) { if (errno == EBADF) return 0; @@ -2579,8 +3238,10 @@ save_redirect_fd(int fd, struct rb_execarg *sargp, char *errmsg, size_t errmsg_b newary = hide_obj(rb_ary_new()); sargp->fd_dup2 = newary; } - rb_ary_push(newary, - hide_obj(rb_assoc_new(INT2FIX(fd), INT2FIX(save_fd)))); + cloexec = fd_get_cloexec(fd, errmsg, errmsg_buflen); + redirection = hide_obj(rb_assoc_new(INT2FIX(fd), INT2FIX(save_fd))); + if (cloexec) rb_ary_push(redirection, Qtrue); + rb_ary_push(newary, redirection); newary = sargp->fd_close; if (newary == Qfalse) { @@ -2610,6 +3271,7 @@ struct run_exec_dup2_fd_pair { int newfd; long older_index; long num_newer; + int cloexec; }; static long @@ -2618,6 +3280,68 @@ run_exec_dup2_tmpbuf_size(long n) return sizeof(struct run_exec_dup2_fd_pair) * n; } +/* This function should be async-signal-safe. Actually it is. */ +static int +fd_get_cloexec(int fd, char *errmsg, size_t errmsg_buflen) +{ +#ifdef F_GETFD + int ret = 0; + ret = fcntl(fd, F_GETFD); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("fcntl(F_GETFD)"); + return -1; + } + if (ret & FD_CLOEXEC) return 1; +#endif + return 0; +} + +/* This function should be async-signal-safe. Actually it is. */ +static int +fd_set_cloexec(int fd, char *errmsg, size_t errmsg_buflen) +{ +#ifdef F_GETFD + int ret = 0; + ret = fcntl(fd, F_GETFD); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("fcntl(F_GETFD)"); + return -1; + } + if (!(ret & FD_CLOEXEC)) { + ret |= FD_CLOEXEC; + ret = fcntl(fd, F_SETFD, ret); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("fcntl(F_SETFD)"); + return -1; + } + } +#endif + return 0; +} + +/* This function should be async-signal-safe. Actually it is. */ +static int +fd_clear_cloexec(int fd, char *errmsg, size_t errmsg_buflen) +{ +#ifdef F_GETFD + int ret; + ret = fcntl(fd, F_GETFD); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("fcntl(F_GETFD)"); + return -1; + } + if (ret & FD_CLOEXEC) { + ret &= ~FD_CLOEXEC; + ret = fcntl(fd, F_SETFD, ret); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("fcntl(F_SETFD)"); + return -1; + } + } +#endif + return 0; +} + /* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */ static int run_exec_dup2(VALUE ary, VALUE tmpbuf, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) @@ -2625,16 +3349,17 @@ run_exec_dup2(VALUE ary, VALUE tmpbuf, struct rb_execarg *sargp, char *errmsg, s long n, i; int ret; int extra_fd = -1; - struct run_exec_dup2_fd_pair *pairs = 0; + struct rb_imemo_tmpbuf_struct *buf = (void *)tmpbuf; + struct run_exec_dup2_fd_pair *pairs = (void *)buf->ptr; n = RARRAY_LEN(ary); - pairs = (struct run_exec_dup2_fd_pair *)RSTRING_PTR(tmpbuf); /* initialize oldfd and newfd: O(n) */ for (i = 0; i < n; i++) { VALUE elt = RARRAY_AREF(ary, i); pairs[i].oldfd = FIX2INT(RARRAY_AREF(elt, 1)); pairs[i].newfd = FIX2INT(RARRAY_AREF(elt, 0)); /* unique */ + pairs[i].cloexec = RARRAY_LEN(elt) > 2 && RTEST(RARRAY_AREF(elt, 2)); pairs[i].older_index = -1; } @@ -2673,6 +3398,10 @@ run_exec_dup2(VALUE ary, VALUE tmpbuf, struct rb_execarg *sargp, char *errmsg, s ERRMSG("dup2"); goto fail; } + if (pairs[j].cloexec && + fd_set_cloexec(pairs[j].newfd, errmsg, errmsg_buflen)) { + goto fail; + } rb_update_max_fd(pairs[j].newfd); /* async-signal-safe but don't need to call it in a child process. */ pairs[j].oldfd = -1; j = pairs[j].older_index; @@ -2687,22 +3416,8 @@ run_exec_dup2(VALUE ary, VALUE tmpbuf, struct rb_execarg *sargp, char *errmsg, s if (pairs[i].oldfd == -1) continue; if (pairs[i].oldfd == pairs[i].newfd) { /* self cycle */ -#ifdef F_GETFD - int fd = pairs[i].oldfd; - ret = fcntl(fd, F_GETFD); /* async-signal-safe */ - if (ret == -1) { - ERRMSG("fcntl(F_GETFD)"); + if (fd_clear_cloexec(pairs[i].oldfd, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ goto fail; - } - if (ret & FD_CLOEXEC) { - ret &= ~FD_CLOEXEC; - ret = fcntl(fd, F_SETFD, ret); /* async-signal-safe */ - if (ret == -1) { - ERRMSG("fcntl(F_SETFD)"); - goto fail; - } - } -#endif pairs[i].oldfd = -1; continue; } @@ -2771,59 +3486,6 @@ run_exec_close(VALUE ary, char *errmsg, size_t errmsg_buflen) /* This function should be async-signal-safe when sargp is NULL. Actually it is. */ static int -run_exec_open(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) -{ - long i; - int ret; - - for (i = 0; i < RARRAY_LEN(ary);) { - VALUE elt = RARRAY_AREF(ary, i); - int fd = FIX2INT(RARRAY_AREF(elt, 0)); - VALUE param = RARRAY_AREF(elt, 1); - VALUE vpath = RARRAY_AREF(param, 0); - int flags = NUM2INT(RARRAY_AREF(param, 1)); - int perm = NUM2INT(RARRAY_AREF(param, 2)); - int need_close = 1; - int fd2; - FilePathValue(vpath); - vpath = rb_str_encode_ospath(vpath); - fd2 = redirect_open(RSTRING_PTR(vpath), flags, perm); /* async-signal-safe */ - if (fd2 == -1) { - ERRMSG("open"); - return -1; - } - rb_update_max_fd(fd2); - while (i < RARRAY_LEN(ary) && - (elt = RARRAY_AREF(ary, i), RARRAY_AREF(elt, 1) == param)) { - fd = FIX2INT(RARRAY_AREF(elt, 0)); - if (fd == fd2) { - need_close = 0; - } - else { - if (save_redirect_fd(fd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */ - return -1; - ret = redirect_dup2(fd2, fd); /* async-signal-safe */ - if (ret == -1) { - ERRMSG("dup2"); - return -1; - } - rb_update_max_fd(fd); - } - i++; - } - if (need_close) { - ret = redirect_close(fd2); /* async-signal-safe */ - if (ret == -1) { - ERRMSG("close"); - return -1; - } - } - } - return 0; -} - -/* This function should be async-signal-safe when sargp is NULL. Actually it is. */ -static int run_exec_dup2_child(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { long i; @@ -2930,7 +3592,7 @@ save_env(struct rb_execarg *sargp) if (!sargp) return; if (sargp->env_modification == Qfalse) { - VALUE env = rb_const_get(rb_cObject, id_ENV); + VALUE env = rb_envtbl(); if (RTEST(env)) { VALUE ary = hide_obj(rb_ary_new()); rb_block_call(env, idEach, 0, 0, save_env_i, @@ -3023,17 +3685,11 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, } #ifdef HAVE_WORKING_FORK - if (!eargp->close_others_given || eargp->close_others_do) { + if (eargp->close_others_do) { rb_close_before_exec(3, eargp->close_others_maxhint, eargp->redirect_fds); /* async-signal-safe */ } #endif - obj = eargp->fd_open; - if (obj != Qfalse) { - if (run_exec_open(obj, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ - return -1; - } - obj = eargp->fd_dup2_child; if (obj != Qfalse) { if (run_exec_dup2_child(obj, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ @@ -3042,10 +3698,8 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, if (eargp->chdir_given) { if (sargp) { - char *cwd = my_getcwd(); sargp->chdir_given = 1; - sargp->chdir_dir = hide_obj(rb_str_new2(cwd)); - xfree(cwd); + sargp->chdir_dir = hide_obj(rb_dir_getwd_ospath()); } if (chdir(RSTRING_PTR(eargp->chdir_dir)) == -1) { /* async-signal-safe */ ERRMSG("chdir"); @@ -3073,12 +3727,14 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, if (sargp) { VALUE ary = sargp->fd_dup2; if (ary != Qfalse) { - size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary)); - VALUE tmpbuf = hide_obj(rb_str_new(0, len)); - rb_str_set_len(tmpbuf, len); - sargp->dup2_tmpbuf = tmpbuf; + rb_execarg_allocate_dup2_tmpbuf(sargp, RARRAY_LEN(ary)); } } + { + int preserve = errno; + stdfd_clear_nonblock(); + errno = preserve; + } return 0; } @@ -3087,44 +3743,39 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, 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; -} - -#if defined(__APPLE__) || defined(__HAIKU__) -static int -rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) -{ - int ret; - before_exec(); - ret = rb_exec_async_signal_safe(eargp, errmsg, errmsg_buflen); /* hopefully async-signal-safe */ - preserving_errno(after_exec()); /* not async-signal-safe because it calls rb_thread_start_timer_thread. */ - return ret; + return err; } -#endif #ifdef HAVE_WORKING_FORK /* This function should be async-signal-safe. Hopefully it is. */ @@ -3133,9 +3784,7 @@ rb_exec_atfork(void* arg, char *errmsg, size_t errmsg_buflen) { return rb_exec_async_signal_safe(arg, errmsg, errmsg_buflen); /* hopefully async-signal-safe */ } -#endif -#ifdef HAVE_WORKING_FORK #if SIZEOF_INT == SIZEOF_LONG #define proc_syswait (VALUE (*)(VALUE))rb_syswait #else @@ -3193,12 +3842,19 @@ pipe_nocrash(int filedes[2], VALUE fds) #define O_BINARY 0 #endif +static VALUE +rb_thread_sleep_that_takes_VALUE_as_sole_argument(VALUE n) +{ + rb_thread_sleep(NUM2INT(n)); + return Qundef; +} + static int -handle_fork_error(int *status, int *ep, volatile int *try_gc_p) +handle_fork_error(int err, struct rb_process_status *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(); @@ -3214,14 +3870,16 @@ handle_fork_error(int *status, int *ep, volatile int *try_gc_p) return 0; } else { - rb_protect((VALUE (*)())rb_thread_sleep, 1, &state); - if (status) *status = state; + rb_protect(rb_thread_sleep_that_takes_VALUE_as_sole_argument, INT2FIX(1), &state); + if (status) status->status = state; if (!state) return 0; } 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; @@ -3275,6 +3933,12 @@ read_retry(int fd, void *buf, size_t len) { ssize_t r; + if (set_blocking(fd) != 0) { +#ifndef _WIN32 + rb_async_bug_errno("set_blocking failed reading child error", errno); +#endif + } + do { r = read(fd, buf, len); } while (r < 0 && errno == EINTR); @@ -3420,56 +4084,37 @@ has_privilege(void) struct child_handler_disabler_state { sigset_t sigmask; - int cancelstate; }; static void disable_child_handler_before_fork(struct child_handler_disabler_state *old) { +#ifdef HAVE_PTHREAD_SIGMASK int ret; sigset_t all; -#ifdef HAVE_PTHREAD_SIGMASK ret = sigfillset(&all); if (ret == -1) rb_sys_fail("sigfillset"); ret = pthread_sigmask(SIG_SETMASK, &all, &old->sigmask); /* not async-signal-safe */ if (ret != 0) { - errno = ret; - rb_sys_fail("pthread_sigmask"); + rb_syserr_fail(ret, "pthread_sigmask"); } #else # pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous" #endif - -#ifdef PTHREAD_CANCEL_DISABLE - ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old->cancelstate); - if (ret != 0) { - errno = ret; - rb_sys_fail("pthread_setcancelstate"); - } -#endif } static void disable_child_handler_fork_parent(struct child_handler_disabler_state *old) { +#ifdef HAVE_PTHREAD_SIGMASK int ret; -#ifdef PTHREAD_CANCEL_DISABLE - ret = pthread_setcancelstate(old->cancelstate, NULL); - if (ret != 0) { - errno = ret; - rb_sys_fail("pthread_setcancelstate"); - } -#endif - -#ifdef HAVE_PTHREAD_SIGMASK ret = pthread_sigmask(SIG_SETMASK, &old->sigmask, NULL); /* not async-signal-safe */ if (ret != 0) { - errno = ret; - rb_sys_fail("pthread_sigmask"); + rb_syserr_fail(ret, "pthread_sigmask"); } #else # pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous" @@ -3482,67 +4127,30 @@ disable_child_handler_fork_child(struct child_handler_disabler_state *old, char { int sig; int ret; -#ifdef POSIX_SIGNAL - struct sigaction act, oact; - - act.sa_handler = SIG_DFL; - act.sa_flags = 0; - ret = sigemptyset(&act.sa_mask); /* async-signal-safe */ - if (ret == -1) { - ERRMSG("sigemptyset"); - return -1; - } -#else - sig_t handler; -#endif for (sig = 1; sig < NSIG; sig++) { - int reset = 0; + sig_t handler = signal(sig, SIG_DFL); + + if (handler == SIG_ERR && errno == EINVAL) { + continue; /* Ignore invalid signal number */ + } + if (handler == SIG_ERR) { + ERRMSG("signal to obtain old action"); + return -1; + } #ifdef SIGPIPE - if (sig == SIGPIPE) - reset = 1; -#endif - if (!reset) { -#ifdef POSIX_SIGNAL - ret = sigaction(sig, NULL, &oact); /* async-signal-safe */ - if (ret == -1 && errno == EINVAL) { - continue; /* Ignore invalid signal number. */ - } - if (ret == -1) { - ERRMSG("sigaction to obtain old action"); - return -1; - } - reset = (oact.sa_flags & SA_SIGINFO) || - (oact.sa_handler != SIG_IGN && oact.sa_handler != SIG_DFL); -#else - handler = signal(sig, SIG_DFL); - if (handler == SIG_ERR && errno == EINVAL) { - continue; /* Ignore invalid signal number */ - } - if (handler == SIG_ERR) { - ERRMSG("signal to obtain old action"); - return -1; - } - reset = (handler != SIG_IGN && handler != SIG_DFL); -#endif - } - if (reset) { -#ifdef POSIX_SIGNAL - ret = sigaction(sig, &act, NULL); /* async-signal-safe */ - if (ret == -1) { - ERRMSG("sigaction to set default action"); - return -1; - } -#else - handler = signal(sig, handler); - if (handler == SIG_ERR) { - ERRMSG("signal to set default action"); - return -1; - } + if (sig == SIGPIPE) { + continue; + } #endif - } + /* it will be reset to SIG_DFL at execve time, instead */ + if (handler == SIG_IGN) { + signal(sig, SIG_IGN); + } } + /* non-Ruby child process, ensure cmake can see SIGCHLD */ + sigemptyset(&old->sigmask); ret = sigprocmask(SIG_SETMASK, &old->sigmask, NULL); /* async-signal-safe */ if (ret != 0) { ERRMSG("sigprocmask"); @@ -3552,24 +4160,32 @@ disable_child_handler_fork_child(struct child_handler_disabler_state *old, char } static rb_pid_t -retry_fork_async_signal_safe(int *status, int *ep, +retry_fork_async_signal_safe(struct rb_process_status *status, int *ep, int (*chfunc)(void*, char *, size_t), void *charg, - char *errmsg, size_t errmsg_buflen) + char *errmsg, size_t errmsg_buflen, + struct waitpid_state *w) { rb_pid_t pid; volatile int try_gc = 1; struct child_handler_disabler_state old; + int err; + rb_nativethread_lock_t *const volatile waitpid_lock_init = + (w && WAITPID_USE_SIGCHLD) ? &GET_VM()->waitpid_lock : 0; while (1) { + rb_nativethread_lock_t *waitpid_lock = waitpid_lock_init; prefork(); disable_child_handler_before_fork(&old); + if (waitpid_lock) { + rb_native_mutex_lock(waitpid_lock); + } #ifdef HAVE_WORKING_VFORK if (!has_privilege()) pid = vfork(); else - pid = fork(); + pid = rb_fork(); #else - pid = fork(); + pid = rb_fork(); #endif if (pid == 0) {/* fork succeed, child process */ int ret; @@ -3586,101 +4202,197 @@ retry_fork_async_signal_safe(int *status, int *ep, _exit(127); #endif } - preserving_errno(disable_child_handler_fork_parent(&old)); + err = errno; + waitpid_lock = waitpid_lock_init; + if (waitpid_lock) { + if (pid > 0 && w != WAITPID_LOCK_ONLY) { + w->pid = pid; + list_add(&GET_VM()->waiting_pids, &w->wnode); + } + rb_native_mutex_unlock(waitpid_lock); + } + 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; } } -rb_pid_t -rb_fork_async_signal_safe(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, - char *errmsg, size_t errmsg_buflen) +static rb_pid_t +fork_check_err(struct rb_process_status *status, int (*chfunc)(void*, char *, size_t), void *charg, + VALUE fds, char *errmsg, size_t errmsg_buflen, + struct rb_execarg *eargp) { rb_pid_t pid; int err; int ep[2]; int error_occurred; - if (status) *status = 0; + struct waitpid_state *w = eargp && eargp->waitpid_state ? eargp->waitpid_state : 0; + + if (status) status->status = 0; if (pipe_nocrash(ep, fds)) return -1; - pid = retry_fork_async_signal_safe(status, ep, chfunc, charg, errmsg, errmsg_buflen); - if (pid < 0) + + pid = retry_fork_async_signal_safe(status, ep, chfunc, charg, errmsg, errmsg_buflen, w); + + if (status) status->pid = pid; + + if (pid < 0) { + if (status) status->error = errno; + return pid; + } + close(ep[1]); + error_occurred = recv_child_error(ep[0], &err, errmsg, errmsg_buflen); + if (error_occurred) { if (status) { - rb_protect(proc_syswait, (VALUE)pid, status); + int state = 0; + status->error = err; + + VM_ASSERT((w == 0 || w == WAITPID_LOCK_ONLY) && + "only used by extensions"); + rb_protect(proc_syswait, (VALUE)pid, &state); + + status->status = state; } - else { + else if (!w || w == WAITPID_LOCK_ONLY) { rb_syswait(pid); } + errno = err; return -1; } + return pid; } +/* + * The "async_signal_safe" name is a lie, but it is used by pty.c and + * maybe other exts. fork() is not async-signal-safe due to pthread_atfork + * and future POSIX revisions will remove it from a list of signal-safe + * functions. rb_waitpid is not async-signal-safe since MJIT, either. + * For our purposes, we do not need async-signal-safety, here + */ +rb_pid_t +rb_fork_async_signal_safe(int *status, + int (*chfunc)(void*, char *, size_t), void *charg, + VALUE fds, char *errmsg, size_t errmsg_buflen) +{ + struct rb_process_status process_status; + + rb_pid_t result = fork_check_err(&process_status, chfunc, charg, fds, errmsg, errmsg_buflen, 0); + + if (status) { + *status = process_status.status; + } + + return result; +} + static rb_pid_t -retry_fork_ruby(int *status) +rb_fork_ruby2(struct rb_process_status *status) { rb_pid_t pid; - int try_gc = 1; + int try_gc = 1, err; + struct child_handler_disabler_state old; + + if (status) status->status = 0; while (1) { prefork(); + if (mjit_enabled) mjit_pause(false); // Don't leave locked mutex to child. Note: child_handler must be enabled to pause MJIT. + disable_child_handler_before_fork(&old); before_fork_ruby(); - pid = fork(); - if (pid == 0) /* fork succeed, child process */ - return pid; - preserving_errno(after_fork_ruby()); - if (0 < pid) /* fork succeed, parent process */ + pid = rb_fork(); + err = errno; + if (status) { + status->pid = pid; + status->error = err; + } + after_fork_ruby(); + disable_child_handler_fork_parent(&old); /* yes, bad name */ + + if (mjit_enabled && pid > 0) mjit_resume(); /* child (pid == 0) is cared by rb_thread_atfork */ + + if (pid >= 0) { /* fork succeed */ + if (pid == 0) rb_thread_atfork(); return pid; + } + /* fork failed */ - if (handle_fork_error(status, NULL, &try_gc)) + if (handle_fork_error(err, status, NULL, &try_gc)) { return -1; + } } } rb_pid_t rb_fork_ruby(int *status) { - rb_pid_t pid; + struct rb_process_status process_status = {0}; - if (status) *status = 0; + rb_pid_t pid = rb_fork_ruby2(&process_status); + + if (status) *status = process_status.status; - pid = retry_fork_ruby(status); - if (pid < 0) - return pid; - if (!pid) { - after_fork_ruby(); - } return pid; } +rb_pid_t +rb_call_proc__fork(void) +{ + VALUE pid = rb_funcall(rb_mProcess, rb_intern("_fork"), 0); + + return NUM2PIDT(pid); +} #endif #if defined(HAVE_WORKING_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD) /* * call-seq: - * Kernel.fork [{ block }] -> fixnum or nil - * Process.fork [{ block }] -> fixnum or nil + * Process._fork -> integer + * + * An internal API for fork. Do not call this method directly. + * Currently, this is called via Kernel#fork, Process.fork, and + * IO.popen with <tt>"-"</tt>. + * + * This method is not for casual code but for application monitoring + * libraries. You can add custom code before and after fork events + * by overriding this method. + */ +VALUE +rb_proc__fork(VALUE _obj) +{ + rb_pid_t pid = rb_fork_ruby(NULL); + + if (pid == -1) { + rb_sys_fail("fork(2)"); + } + + return PIDT2NUM(pid); +} + +/* + * call-seq: + * Kernel.fork [{ block }] -> integer or nil + * Process.fork [{ block }] -> integer or nil * * Creates a subprocess. If a block is specified, that block is run * in the subprocess, and the subprocess terminates with a status of - * zero. Otherwise, the +fork+ call returns twice, once in - * the parent, returning the process ID of the child, and once in - * the child, returning _nil_. The child process can exit using - * <code>Kernel.exit!</code> to avoid running any - * <code>at_exit</code> functions. The parent process should - * use <code>Process.wait</code> to collect the termination statuses - * of its children or use <code>Process.detach</code> to register - * disinterest in their status; otherwise, the operating system - * may accumulate zombie processes. + * zero. Otherwise, the +fork+ call returns twice, once in the + * parent, returning the process ID of the child, and once in the + * child, returning _nil_. The child process can exit using + * Kernel.exit! to avoid running any <code>at_exit</code> + * functions. The parent process should use Process.wait to collect + * the termination statuses of its children or use Process.detach to + * register disinterest in their status; otherwise, the operating + * system may accumulate zombie processes. * * The thread calling fork is the only thread in the created child process. * fork doesn't copy other threads. @@ -3696,28 +4408,21 @@ rb_f_fork(VALUE obj) { rb_pid_t pid; - rb_secure(2); + pid = rb_call_proc__fork(); - switch (pid = rb_fork_ruby(NULL)) { - case 0: - rb_thread_atfork(); + if (pid == 0) { if (rb_block_given_p()) { int status; - rb_protect(rb_yield, Qundef, &status); ruby_stop(status); } return Qnil; - - case -1: - rb_sys_fail("fork(2)"); - return Qnil; - - default: - return PIDT2NUM(pid); } + + return PIDT2NUM(pid); } #else +#define rb_proc__fork rb_f_notimplement #define rb_f_fork rb_f_notimplement #endif @@ -3744,6 +4449,7 @@ exit_status_code(VALUE status) return istatus; } +NORETURN(static VALUE rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)); /* * call-seq: * Process.exit!(status=false) @@ -3758,24 +4464,23 @@ exit_status_code(VALUE status) static VALUE rb_f_exit_bang(int argc, VALUE *argv, VALUE obj) { - VALUE status; int istatus; - if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { - istatus = exit_status_code(status); + if (rb_check_arity(argc, 0, 1) == 1) { + istatus = exit_status_code(argv[0]); } else { istatus = EXIT_FAILURE; } _exit(istatus); - UNREACHABLE; + UNREACHABLE_RETURN(Qnil); } void rb_exit(int status) { - if (GET_THREAD()->tag) { + if (GET_EC()->tag) { VALUE args[2]; args[0] = INT2NUM(status); @@ -3785,7 +4490,23 @@ rb_exit(int status) ruby_stop(status); } +VALUE +rb_f_exit(int argc, const VALUE *argv) +{ + int istatus; + + if (rb_check_arity(argc, 0, 1) == 1) { + istatus = exit_status_code(argv[0]); + } + else { + istatus = EXIT_SUCCESS; + } + rb_exit(istatus); + UNREACHABLE_RETURN(Qnil); +} + +NORETURN(static VALUE f_exit(int c, const VALUE *a, VALUE _)); /* * call-seq: * exit(status=true) @@ -3793,7 +4514,7 @@ rb_exit(int status) * Process::exit(status=true) * * Initiates the termination of the Ruby script by raising the - * <code>SystemExit</code> exception. This exception may be caught. The + * SystemExit exception. This exception may be caught. The * optional parameter is used to return a status code to the invoking * environment. * +true+ and +FALSE+ of _status_ means success and failure @@ -3813,9 +4534,9 @@ rb_exit(int status) * rescued a SystemExit exception * after begin block * - * Just prior to termination, Ruby executes any <code>at_exit</code> functions - * (see Kernel::at_exit) and runs any object finalizers (see - * ObjectSpace::define_finalizer). + * Just prior to termination, Ruby executes any <code>at_exit</code> + * functions (see Kernel::at_exit) and runs any object finalizers + * (see ObjectSpace::define_finalizer). * * at_exit { puts "at_exit function" } * ObjectSpace.define_finalizer("string", proc { puts "in finalizer" }) @@ -3827,42 +4548,22 @@ rb_exit(int status) * in finalizer */ -VALUE -rb_f_exit(int argc, const VALUE *argv) +static VALUE +f_exit(int c, const VALUE *a, VALUE _) { - VALUE status; - int istatus; - - if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { - istatus = exit_status_code(status); - } - else { - istatus = EXIT_SUCCESS; - } - rb_exit(istatus); - - UNREACHABLE; + rb_f_exit(c, a); + UNREACHABLE_RETURN(Qnil); } - -/* - * call-seq: - * abort - * Kernel::abort([msg]) - * Process::abort([msg]) - * - * Terminate execution immediately, effectively by calling - * <code>Kernel.exit(false)</code>. If _msg_ is given, it is written - * to STDERR prior to terminating. - */ - VALUE rb_f_abort(int argc, const VALUE *argv) { rb_check_arity(argc, 0, 1); if (argc == 0) { - if (!NIL_P(GET_THREAD()->errinfo)) { - ruby_error_print(); + rb_execution_context_t *ec = GET_EC(); + VALUE errinfo = rb_ec_get_errinfo(ec); + if (!NIL_P(errinfo)) { + rb_ec_error_print(ec, errinfo); } rb_exit(EXIT_FAILURE); } @@ -3871,12 +4572,32 @@ rb_f_abort(int argc, const VALUE *argv) args[1] = args[0] = argv[0]; StringValue(args[0]); - rb_io_puts(1, args, rb_stderr); + rb_io_puts(1, args, rb_ractor_stderr()); args[0] = INT2NUM(EXIT_FAILURE); rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit)); } - UNREACHABLE; + UNREACHABLE_RETURN(Qnil); +} + +NORETURN(static VALUE f_abort(int c, const VALUE *a, VALUE _)); + +/* + * call-seq: + * abort + * Kernel::abort([msg]) + * Process.abort([msg]) + * + * Terminate execution immediately, effectively by calling + * <code>Kernel.exit(false)</code>. If _msg_ is given, it is written + * to STDERR prior to terminating. + */ + +static VALUE +f_abort(int c, const VALUE *a, VALUE _) +{ + rb_f_abort(c, a); + UNREACHABLE_RETURN(Qnil); } void @@ -3887,20 +4608,43 @@ rb_syswait(rb_pid_t pid) rb_waitpid(pid, &status, 0); } +#if !defined HAVE_WORKING_FORK && !defined HAVE_SPAWNV && !defined __EMSCRIPTEN__ +char * +rb_execarg_commandline(const struct rb_execarg *eargp, VALUE *prog) +{ + VALUE cmd = *prog; + if (eargp && !eargp->use_shell) { + VALUE str = eargp->invoke.cmd.argv_str; + VALUE buf = eargp->invoke.cmd.argv_buf; + char *p, **argv = ARGVSTR2ARGV(str); + long i, argc = ARGVSTR2ARGC(str); + const char *start = RSTRING_PTR(buf); + cmd = rb_str_new(start, RSTRING_LEN(buf)); + p = RSTRING_PTR(cmd); + for (i = 1; i < argc; ++i) { + p[argv[i] - start - 1] = ' '; + } + *prog = cmd; + return p; + } + return StringValueCStr(*prog); +} +#endif + static rb_pid_t rb_spawn_process(struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) { rb_pid_t pid; -#if !USE_SPAWNV - int status; -#endif #if !defined HAVE_WORKING_FORK || USE_SPAWNV VALUE prog; struct rb_execarg sarg; +# if !defined HAVE_SPAWNV + int status; +# endif #endif #if defined HAVE_WORKING_FORK && !USE_SPAWNV - pid = rb_fork_async_signal_safe(&status, rb_exec_atfork, eargp, eargp->redirect_fds, errmsg, errmsg_buflen); + pid = fork_check_err(eargp->status, rb_exec_atfork, eargp, eargp->redirect_fds, errmsg, errmsg_buflen, eargp); #else prog = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; @@ -3914,42 +4658,77 @@ rb_spawn_process(struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) } # if defined HAVE_SPAWNV if (eargp->use_shell) { - pid = proc_spawn_sh(RSTRING_PTR(prog)); + pid = proc_spawn_sh(RSTRING_PTR(prog)); } else { char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); - pid = proc_spawn_cmd(argv, prog, eargp); + pid = proc_spawn_cmd(argv, prog, eargp); } - if (pid == -1) - rb_last_status_set(0x7f << 8, 0); -# else - if (!eargp->use_shell) { - char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); - int argc = ARGVSTR2ARGC(eargp->invoke.cmd.argv_str); - prog = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); + + if (pid == -1) { + rb_last_status_set(0x7f << 8, pid); } - status = system(StringValuePtr(prog)); - rb_last_status_set((status & 0xff) << 8, 0); +# else + status = system(rb_execarg_commandline(eargp, &prog)); + pid = 1; /* dummy */ + rb_last_status_set((status & 0xff) << 8, pid); # endif + if (eargp->waitpid_state && eargp->waitpid_state != WAITPID_LOCK_ONLY) { + eargp->waitpid_state->pid = pid; + } + rb_execarg_run_options(&sarg, NULL, errmsg, errmsg_buflen); #endif + return pid; } +struct spawn_args { + VALUE execarg; + struct { + char *ptr; + size_t buflen; + } errmsg; +}; + +static VALUE +do_spawn_process(VALUE arg) +{ + struct spawn_args *argp = (struct spawn_args *)arg; + rb_execarg_parent_start1(argp->execarg); + return (VALUE)rb_spawn_process(DATA_PTR(argp->execarg), + argp->errmsg.ptr, argp->errmsg.buflen); +} + +static rb_pid_t +rb_execarg_spawn(VALUE execarg_obj, char *errmsg, size_t errmsg_buflen) +{ + struct spawn_args args; + struct rb_execarg *eargp = rb_execarg_get(execarg_obj); + + /* + * Prevent a race with MJIT where the compiler process where + * can hold an FD of ours in between vfork + execve + */ + if (!eargp->waitpid_state && mjit_enabled) { + eargp->waitpid_state = WAITPID_LOCK_ONLY; + } + + args.execarg = execarg_obj; + args.errmsg.ptr = errmsg; + args.errmsg.buflen = errmsg_buflen; + return (rb_pid_t)rb_ensure(do_spawn_process, (VALUE)&args, + execarg_parent_end, execarg_obj); +} + static rb_pid_t rb_spawn_internal(int argc, const VALUE *argv, char *errmsg, size_t errmsg_buflen) { VALUE execarg_obj; - struct rb_execarg *eargp; - rb_pid_t ret; - execarg_obj = rb_execarg_new(argc, argv, TRUE); - eargp = rb_execarg_get(execarg_obj); - rb_execarg_fixup(execarg_obj); - ret = rb_spawn_process(eargp, errmsg, errmsg_buflen); - RB_GC_GUARD(execarg_obj); - return ret; + execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE); + return rb_execarg_spawn(execarg_obj, errmsg, errmsg_buflen); } rb_pid_t @@ -3966,25 +4745,31 @@ rb_spawn(int argc, const VALUE *argv) /* * call-seq: - * system([env,] command... [,options]) -> true, false or nil + * system([env,] command... [,options], exception: false) -> true, false or nil * * Executes _command..._ in a subshell. * _command..._ is one of following forms. * - * commandline : command line string which is passed to the standard shell - * cmdname, arg1, ... : command name and one or more arguments (no shell) - * [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell) + * [<code>commandline</code>] + * command line string which is passed to the standard shell + * [<code>cmdname, arg1, ...</code>] + * command name and one or more arguments (no shell) + * [<code>[cmdname, argv0], arg1, ...</code>] + * command name, <code>argv[0]</code> and zero or more arguments (no shell) * * system returns +true+ if the command gives zero exit status, * +false+ for non zero exit status. * Returns +nil+ if command execution fails. * An error status is available in <code>$?</code>. + * + * If the <code>exception: true</code> argument is passed, the method + * raises an exception instead of returning +false+ or +nil+. + * * The arguments are processed in the same way as - * for <code>Kernel.spawn</code>. + * for Kernel#spawn. * - * The hash arguments, env and options, are same as - * <code>exec</code> and <code>spawn</code>. - * See <code>Kernel.spawn</code> for details. + * The hash arguments, env and options, are same as #exec and #spawn. + * See Kernel#spawn for details. * * system("echo *") * system("echo", "*") @@ -3994,43 +4779,81 @@ rb_spawn(int argc, const VALUE *argv) * config.h main.rb * * * - * See <code>Kernel.exec</code> for the standard shell. + * Error handling: + * + * system("cat nonexistent.txt") + * # => false + * system("catt nonexistent.txt") + * # => nil + * + * system("cat nonexistent.txt", exception: true) + * # RuntimeError (Command failed with exit 1: cat) + * system("catt nonexistent.txt", exception: true) + * # Errno::ENOENT (No such file or directory - catt) + * + * See Kernel#exec for the standard shell. */ static VALUE -rb_f_system(int argc, VALUE *argv) +rb_f_system(int argc, VALUE *argv, VALUE _) { - rb_pid_t pid; - int status; - -#if defined(SIGCLD) && !defined(SIGCHLD) -# define SIGCHLD SIGCLD -#endif + VALUE execarg_obj = rb_execarg_new(argc, argv, TRUE, TRUE); + struct rb_execarg *eargp = rb_execarg_get(execarg_obj); -#ifdef SIGCHLD - RETSIGTYPE (*chfunc)(int); + struct rb_process_status status = {0}; + eargp->status = &status; rb_last_status_clear(); - chfunc = signal(SIGCHLD, SIG_DFL); -#endif - pid = rb_spawn_internal(argc, argv, NULL, 0); -#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) + + // This function can set the thread's last status. + // May be different from waitpid_state.pid on exec failure. + rb_pid_t pid = rb_execarg_spawn(execarg_obj, 0, 0); + if (pid > 0) { - int ret, status; - ret = rb_waitpid(pid, &status, 0); - if (ret == (rb_pid_t)-1) - rb_sys_fail("Another thread waited the process started by system()."); + VALUE status = rb_process_status_wait(pid, 0); + struct rb_process_status *data = RTYPEDDATA_DATA(status); + + // Set the last status: + rb_obj_freeze(status); + GET_THREAD()->last_status = status; + + if (data->status == EXIT_SUCCESS) { + return Qtrue; + } + + if (data->error != 0) { + if (eargp->exception) { + VALUE command = eargp->invoke.sh.shell_script; + RB_GC_GUARD(execarg_obj); + rb_syserr_fail_str(data->error, command); + } + else { + return Qnil; + } + } + else if (eargp->exception) { + VALUE command = eargp->invoke.sh.shell_script; + VALUE str = rb_str_new_cstr("Command failed with"); + rb_str_cat_cstr(pst_message_status(str, data->status), ": "); + rb_str_append(str, command); + RB_GC_GUARD(execarg_obj); + rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, str)); + } + else { + return Qfalse; + } + + RB_GC_GUARD(status); } -#endif -#ifdef SIGCHLD - signal(SIGCHLD, chfunc); -#endif - if (pid < 0) { - return Qnil; + + if (eargp->exception) { + VALUE command = eargp->invoke.sh.shell_script; + RB_GC_GUARD(execarg_obj); + rb_syserr_fail_str(errno, command); + } + else { + return Qnil; } - status = PST2INT(rb_last_status_get()); - if (status == EXIT_SUCCESS) return Qtrue; - return Qfalse; } /* @@ -4050,9 +4873,9 @@ rb_f_system(int argc, VALUE *argv) * to finish. * * The parent process should - * use <code>Process.wait</code> to collect + * use Process.wait to collect * the termination status of its child or - * use <code>Process.detach</code> to register + * use Process.detach to register * disinterest in their status; * otherwise, the operating system may accumulate zombie processes. * @@ -4061,6 +4884,8 @@ rb_f_system(int argc, VALUE *argv) * env: hash * name => val : set the environment variable * name => nil : unset the environment variable + * + * the keys and the values except for +nil+ must be strings. * command...: * commandline : command line string which is passed to the standard shell * cmdname, arg1, ... : command name and one or more arguments (This form does not use the shell. See below for caveats.) @@ -4071,7 +4896,7 @@ rb_f_system(int argc, VALUE *argv) * :unsetenv_others => false : don't clear (default) * process group: * :pgroup => true or 0 : make a new process group - * :pgroup => pgid : join to specified process group + * :pgroup => pgid : join the specified process group * :pgroup => nil : don't change the process group (default) * create new process group: Windows only * :new_pgroup => true : the new process is the root process of a new process group @@ -4100,17 +4925,18 @@ rb_f_system(int argc, VALUE *argv) * integer : the file descriptor of specified the integer * io : the file descriptor specified as io.fileno * file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not - * :close_others => true : don't inherit + * :close_others => false : inherit * current directory: * :chdir => str * - * The 'cmdname, arg1, ...' form does not use the shell. However, - * on different OSes, different things are provided as built-in - * commands. An example of this is 'echo', which is a built-in - * on Windows, but is a normal program on Linux and Mac OS X. - * This means that `Process.spawn 'echo', '%Path%'` will display - * the contents of the `%Path%` environment variable on Windows, - * but `Process.spawn 'echo', '$PATH'` prints the literal '$PATH'. + * The <code>cmdname, arg1, ...</code> form does not use the shell. + * However, on different OSes, different things are provided as + * built-in commands. An example of this is +'echo'+, which is a + * built-in on Windows, but is a normal program on Linux and Mac OS X. + * This means that <code>Process.spawn 'echo', '%Path%'</code> will + * display the contents of the <tt>%Path%</tt> environment variable + * on Windows, but <code>Process.spawn 'echo', '$PATH'</code> prints + * the literal <tt>$PATH</tt>. * * If a hash is given as +env+, the environment is * updated by +env+ before <code>exec(2)</code> in the child process. @@ -4136,10 +4962,10 @@ rb_f_system(int argc, VALUE *argv) * pid = spawn({"FOO"=>"BAR"}, command, :unsetenv_others=>true) # FOO only * * The <code>:pgroup</code> key in +options+ specifies a process group. - * The corresponding value should be true, zero or positive integer. - * true and zero means the process should be a process leader of a new - * process group. - * Other values specifies a process group to be belongs. + * The corresponding value should be true, zero, a positive integer, or nil. + * true and zero cause the process to be a process leader of a new process group. + * A non-zero positive integer causes the process to join the provided process group. + * The default value, nil, causes the process to remain in the same process group. * * pid = spawn(command, :pgroup=>true) # process leader * pid = spawn(command, :pgroup=>10) # belongs to the process group 10 @@ -4170,7 +4996,7 @@ rb_f_system(int argc, VALUE *argv) * * pid = spawn(command, :umask=>077) * - * The :in, :out, :err, a fixnum, an IO and an array key specifies a redirection. + * The :in, :out, :err, an integer, an IO and an array key specifies a redirection. * The redirection maps a file descriptor in the child process. * * For example, stderr can be merged into stdout as follows: @@ -4180,12 +5006,12 @@ rb_f_system(int argc, VALUE *argv) * pid = spawn(command, STDERR=>:out) * pid = spawn(command, STDERR=>STDOUT) * - * The hash keys specifies a file descriptor - * in the child process started by <code>spawn</code>. + * The hash keys specifies a file descriptor in the child process + * started by #spawn. * :err, 2 and STDERR specifies the standard error stream (stderr). * - * The hash values specifies a file descriptor - * in the parent process which invokes <code>spawn</code>. + * The hash values specifies a file descriptor in the parent process + * which invokes #spawn. * :out, 1 and STDOUT specifies the standard output stream (stdout). * * In the above example, @@ -4259,7 +5085,7 @@ rb_f_system(int argc, VALUE *argv) * pid = spawn(command, :close_others=>true) # close 3,4,5,... (default) * pid = spawn(command, :close_others=>false) # don't close 3,4,5,... * - * :close_others is true by default for spawn and IO.popen. + * :close_others is false by default for spawn and IO.popen. * * Note that fds which close-on-exec flag is already set are closed * regardless of :close_others option. @@ -4296,31 +5122,28 @@ rb_f_system(int argc, VALUE *argv) * Internally, +spawn+ uses an extra file descriptor to resolve such cyclic * file descriptor mapping. * - * See <code>Kernel.exec</code> for the standard shell. + * See Kernel.exec for the standard shell. */ static VALUE -rb_f_spawn(int argc, VALUE *argv) +rb_f_spawn(int argc, VALUE *argv, VALUE _) { rb_pid_t pid; char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; VALUE execarg_obj, fail_str; struct rb_execarg *eargp; - execarg_obj = rb_execarg_new(argc, argv, TRUE); + execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE); eargp = rb_execarg_get(execarg_obj); - rb_execarg_fixup(execarg_obj); fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; - pid = rb_spawn_process(eargp, errmsg, sizeof(errmsg)); - RB_GC_GUARD(execarg_obj); + pid = rb_execarg_spawn(execarg_obj, errmsg, sizeof(errmsg)); if (pid == -1) { - const char *prog = errmsg; - if (!prog[0]) { - rb_sys_fail_str(fail_str); - } - rb_sys_fail(prog); + int err = errno; + rb_exec_fail(eargp, err, errmsg); + RB_GC_GUARD(execarg_obj); + rb_syserr_fail_str(err, fail_str); } #if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) return PIDT2NUM(pid); @@ -4331,12 +5154,12 @@ rb_f_spawn(int argc, VALUE *argv) /* * call-seq: - * sleep([duration]) -> fixnum + * sleep([duration]) -> integer * * Suspends the current thread for _duration_ seconds (which may be any number, * including a +Float+ with fractional seconds). Returns the actual number of * seconds slept (rounded), which may be less than that asked for if another - * thread calls <code>Thread#run</code>. Called without an argument, sleep() + * thread calls Thread#run. Called without an argument, sleep() * will sleep forever. * * Time.new #=> 2008-03-08 19:56:19 +0900 @@ -4347,22 +5170,27 @@ rb_f_spawn(int argc, VALUE *argv) */ static VALUE -rb_f_sleep(int argc, VALUE *argv) +rb_f_sleep(int argc, VALUE *argv, VALUE _) { - time_t beg, end; + time_t beg = time(0); + VALUE scheduler = rb_fiber_scheduler_current(); - beg = time(0); - if (argc == 0) { - rb_thread_sleep_forever(); + if (scheduler != Qnil) { + rb_fiber_scheduler_kernel_sleepv(scheduler, argc, argv); } else { - rb_check_arity(argc, 0, 1); - rb_thread_wait_for(rb_time_interval(argv[0])); + if (argc == 0) { + rb_thread_sleep_forever(); + } + else { + rb_check_arity(argc, 0, 1); + rb_thread_wait_for(rb_time_interval(argv[0])); + } } - end = time(0) - beg; + time_t end = time(0) - beg; - return INT2FIX(end); + return TIMET2NUM(end); } @@ -4379,11 +5207,10 @@ rb_f_sleep(int argc, VALUE *argv) */ static VALUE -proc_getpgrp(void) +proc_getpgrp(VALUE _) { rb_pid_t pgrp; - rb_secure(2); #if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) pgrp = getpgrp(); if (pgrp < 0) rb_sys_fail(0); @@ -4409,9 +5236,8 @@ proc_getpgrp(void) */ static VALUE -proc_setpgrp(void) +proc_setpgrp(VALUE _) { - rb_secure(2); /* check for posix setpgid() first; this matches the posix */ /* getpgrp() above. It appears that configure will set SETPGRP_VOID */ /* even though setpgrp(0,0) would be preferred. The posix call avoids */ @@ -4444,7 +5270,6 @@ proc_getpgid(VALUE obj, VALUE pid) { rb_pid_t i; - rb_secure(2); i = getpgid(NUM2PIDT(pid)); if (i < 0) rb_sys_fail(0); return PIDT2NUM(i); @@ -4468,7 +5293,6 @@ proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp) { rb_pid_t ipid, ipgrp; - rb_secure(2); ipid = NUM2PIDT(pid); ipgrp = NUM2PIDT(pgrp); @@ -4486,7 +5310,7 @@ proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp) * Process.getsid() -> integer * Process.getsid(pid) -> integer * - * Returns the session ID for for the given process id. If not give, + * Returns the session ID for the given process id. If not given, * return current process sid. Not available on all platforms. * * Process.getsid() #=> 27422 @@ -4494,18 +5318,15 @@ proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp) * Process.getsid(Process.pid()) #=> 27422 */ static VALUE -proc_getsid(int argc, VALUE *argv) +proc_getsid(int argc, VALUE *argv, VALUE _) { rb_pid_t sid; - VALUE pid; - - rb_secure(2); - rb_scan_args(argc, argv, "01", &pid); + rb_pid_t pid = 0; - if (NIL_P(pid)) - pid = INT2FIX(0); + if (rb_check_arity(argc, 0, 1) == 1 && !NIL_P(argv[0])) + pid = NUM2PIDT(argv[0]); - sid = getsid(NUM2PIDT(pid)); + sid = getsid(pid); if (sid < 0) rb_sys_fail(0); return PIDT2NUM(sid); } @@ -4521,7 +5342,7 @@ static rb_pid_t ruby_setsid(void); #endif /* * call-seq: - * Process.setsid -> fixnum + * Process.setsid -> integer * * Establishes this process as a new session and process group * leader, with no controlling tty. Returns the session id. Not @@ -4531,11 +5352,10 @@ static rb_pid_t ruby_setsid(void); */ static VALUE -proc_setsid(void) +proc_setsid(VALUE _) { rb_pid_t pid; - rb_secure(2); pid = setsid(); if (pid < 0) rb_sys_fail(0); return PIDT2NUM(pid); @@ -4576,13 +5396,13 @@ ruby_setsid(void) #ifdef HAVE_GETPRIORITY /* * call-seq: - * Process.getpriority(kind, integer) -> fixnum + * Process.getpriority(kind, integer) -> integer * * Gets the scheduling priority for specified process, process group, * or user. <em>kind</em> indicates the kind of entity to find: one - * of <code>Process::PRIO_PGRP</code>, - * <code>Process::PRIO_USER</code>, or - * <code>Process::PRIO_PROCESS</code>. _integer_ is an id + * of Process::PRIO_PGRP, + * Process::PRIO_USER, or + * Process::PRIO_PROCESS. _integer_ is an id * indicating the particular process, process group, or user (an id * of 0 means _current_). Lower priorities are more favorable * for scheduling. Not available on all platforms. @@ -4596,7 +5416,6 @@ proc_getpriority(VALUE obj, VALUE which, VALUE who) { int prio, iwhich, iwho; - rb_secure(2); iwhich = NUM2INT(which); iwho = NUM2INT(who); @@ -4615,7 +5434,7 @@ proc_getpriority(VALUE obj, VALUE which, VALUE who) * call-seq: * Process.setpriority(kind, integer, priority) -> 0 * - * See <code>Process#getpriority</code>. + * See Process.getpriority. * * Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0 * Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0 @@ -4628,7 +5447,6 @@ proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio) { int iwhich, iwho, iprio; - rb_secure(2); iwhich = NUM2INT(which); iwho = NUM2INT(who); iprio = NUM2INT(prio); @@ -4643,13 +5461,13 @@ proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio) #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) static int -rlimit_resource_name2int(const char *name, int casetype) +rlimit_resource_name2int(const char *name, long len, int casetype) { int resource; const char *p; #define RESCHECK(r) \ do { \ - if (STRCASECMP(name, #r) == 0) { \ + if (len == rb_strlen_lit(#r) && STRCASECMP(name, #r) == 0) { \ resource = RLIMIT_##r; \ goto found; \ } \ @@ -4752,21 +5570,40 @@ rlimit_resource_name2int(const char *name, int casetype) } static int -rlimit_type_by_hname(const char *name) +rlimit_type_by_hname(const char *name, long len) +{ + return rlimit_resource_name2int(name, len, 0); +} + +static int +rlimit_type_by_lname(const char *name, long len) { - return rlimit_resource_name2int(name, 0); + return rlimit_resource_name2int(name, len, 1); } static int -rlimit_type_by_lname(const char *name) +rlimit_type_by_sym(VALUE key) { - return rlimit_resource_name2int(name, 1); + VALUE name = rb_sym2str(key); + const char *rname = RSTRING_PTR(name); + long len = RSTRING_LEN(name); + int rtype = -1; + static const char prefix[] = "rlimit_"; + enum {prefix_len = sizeof(prefix)-1}; + + if (len > prefix_len && strncmp(prefix, rname, prefix_len) == 0) { + rtype = rlimit_type_by_lname(rname + prefix_len, len - prefix_len); + } + + RB_GC_GUARD(key); + return rtype; } static int rlimit_resource_type(VALUE rtype) { const char *name; + long len; VALUE v; int r; @@ -4774,6 +5611,7 @@ rlimit_resource_type(VALUE rtype) case T_SYMBOL: v = rb_sym2str(rtype); name = RSTRING_PTR(v); + len = RSTRING_LEN(v); break; default: @@ -4782,6 +5620,7 @@ rlimit_resource_type(VALUE rtype) rtype = v; case T_STRING: name = StringValueCStr(rtype); + len = RSTRING_LEN(rtype); break; } /* fall through */ @@ -4791,13 +5630,13 @@ rlimit_resource_type(VALUE rtype) return NUM2INT(rtype); } - r = rlimit_type_by_hname(name); + r = rlimit_type_by_hname(name, len); if (r != -1) return r; - rb_raise(rb_eArgError, "invalid resource name: %"PRIsVALUE, rtype); + rb_raise(rb_eArgError, "invalid resource name: % "PRIsVALUE, rtype); - UNREACHABLE; + UNREACHABLE_RETURN(-1); } static rlim_t @@ -4838,7 +5677,7 @@ rlimit_resource_value(VALUE rval) #endif rb_raise(rb_eArgError, "invalid resource value: %"PRIsVALUE, rval); - UNREACHABLE; + UNREACHABLE_RETURN((rlim_t)-1); } #endif @@ -4854,12 +5693,12 @@ rlimit_resource_value(VALUE rval) * _resource_ indicates the kind of resource to limit. * It is specified as a symbol such as <code>:CORE</code>, * a string such as <code>"CORE"</code> or - * a constant such as <code>Process::RLIMIT_CORE</code>. + * a constant such as Process::RLIMIT_CORE. * See Process.setrlimit for details. * - * _cur_limit_ and _max_limit_ may be <code>Process::RLIM_INFINITY</code>, - * <code>Process::RLIM_SAVED_MAX</code> or - * <code>Process::RLIM_SAVED_CUR</code>. + * _cur_limit_ and _max_limit_ may be Process::RLIM_INFINITY, + * Process::RLIM_SAVED_MAX or + * Process::RLIM_SAVED_CUR. * See Process.setrlimit and the system getrlimit(2) manual for details. */ @@ -4868,8 +5707,6 @@ proc_getrlimit(VALUE obj, VALUE resource) { struct rlimit rlim; - rb_secure(2); - if (getrlimit(rlimit_resource_type(resource), &rlim) < 0) { rb_sys_fail("getrlimit"); } @@ -4894,7 +5731,7 @@ proc_getrlimit(VALUE obj, VALUE resource) * _resource_ indicates the kind of resource to limit. * It should be a symbol such as <code>:CORE</code>, * a string such as <code>"CORE"</code> or - * a constant such as <code>Process::RLIMIT_CORE</code>. + * a constant such as Process::RLIMIT_CORE. * The available resources are OS dependent. * Ruby may support following resources. * @@ -4917,10 +5754,10 @@ proc_getrlimit(VALUE obj, VALUE resource) * * _cur_limit_ and _max_limit_ may be * <code>:INFINITY</code>, <code>"INFINITY"</code> or - * <code>Process::RLIM_INFINITY</code>, + * Process::RLIM_INFINITY, * which means that the resource is not limited. - * They may be <code>Process::RLIM_SAVED_MAX</code>, - * <code>Process::RLIM_SAVED_CUR</code> and + * They may be Process::RLIM_SAVED_MAX, + * Process::RLIM_SAVED_CUR and * corresponding symbols and strings too. * See system setrlimit(2) manual for details. * @@ -4937,10 +5774,10 @@ proc_setrlimit(int argc, VALUE *argv, VALUE obj) VALUE resource, rlim_cur, rlim_max; struct rlimit rlim; - rb_secure(2); - - rb_scan_args(argc, argv, "21", &resource, &rlim_cur, &rlim_max); - if (rlim_max == Qnil) + rb_check_arity(argc, 2, 3); + resource = argv[0]; + rlim_cur = argv[1]; + if (argc < 3 || NIL_P(rlim_max = argv[2])) rlim_max = rlim_cur; rlim.rlim_cur = rlimit_resource_value(rlim_cur); @@ -4959,7 +5796,6 @@ static int under_uid_switch = 0; static void check_uid_switch(void) { - rb_secure(2); if (under_uid_switch) { rb_raise(rb_eRuntimeError, "can't handle UID while evaluating block given to Process::UID.switch method"); } @@ -4969,21 +5805,260 @@ static int under_gid_switch = 0; static void check_gid_switch(void) { - rb_secure(2); if (under_gid_switch) { rb_raise(rb_eRuntimeError, "can't handle GID while evaluating block given to Process::UID.switch method"); } } +#if defined(HAVE_PWD_H) +/** + * Best-effort attempt to obtain the name of the login user, if any, + * associated with the process. Processes not descended from login(1) (or + * similar) may not have a logged-in user; returns Qnil in that case. + */ +VALUE +rb_getlogin(void) +{ +#if ( !defined(USE_GETLOGIN_R) && !defined(USE_GETLOGIN) ) + return Qnil; +#else + char MAYBE_UNUSED(*login) = NULL; + +# ifdef USE_GETLOGIN_R + +#if defined(__FreeBSD__) + typedef int getlogin_r_size_t; +#else + typedef size_t getlogin_r_size_t; +#endif + + long loginsize = GETLOGIN_R_SIZE_INIT; /* maybe -1 */ + + if (loginsize < 0) + loginsize = GETLOGIN_R_SIZE_DEFAULT; + + VALUE maybe_result = rb_str_buf_new(loginsize); + + login = RSTRING_PTR(maybe_result); + loginsize = rb_str_capacity(maybe_result); + rb_str_set_len(maybe_result, loginsize); + + int gle; + errno = 0; + while ((gle = getlogin_r(login, (getlogin_r_size_t)loginsize)) != 0) { + + if (gle == ENOTTY || gle == ENXIO || gle == ENOENT) { + rb_str_resize(maybe_result, 0); + return Qnil; + } + + if (gle != ERANGE || loginsize >= GETLOGIN_R_SIZE_LIMIT) { + rb_str_resize(maybe_result, 0); + rb_syserr_fail(gle, "getlogin_r"); + } + + rb_str_modify_expand(maybe_result, loginsize); + login = RSTRING_PTR(maybe_result); + loginsize = rb_str_capacity(maybe_result); + } + + if (login == NULL) { + rb_str_resize(maybe_result, 0); + return Qnil; + } + + return maybe_result; + +# elif USE_GETLOGIN + + errno = 0; + login = getlogin(); + if (errno) { + if (errno == ENOTTY || errno == ENXIO || errno == ENOENT) { + return Qnil; + } + rb_syserr_fail(errno, "getlogin"); + } + + return login ? rb_str_new_cstr(login) : Qnil; +# endif + +#endif +} + +VALUE +rb_getpwdirnam_for_login(VALUE login_name) +{ +#if ( !defined(USE_GETPWNAM_R) && !defined(USE_GETPWNAM) ) + return Qnil; +#else + + if (NIL_P(login_name)) { + /* nothing to do; no name with which to query the password database */ + return Qnil; + } + + char *login = RSTRING_PTR(login_name); + + struct passwd *pwptr; + +# ifdef USE_GETPWNAM_R + + struct passwd pwdnm; + char *bufnm; + long bufsizenm = GETPW_R_SIZE_INIT; /* maybe -1 */ + + if (bufsizenm < 0) + bufsizenm = GETPW_R_SIZE_DEFAULT; + + VALUE getpwnm_tmp = rb_str_tmp_new(bufsizenm); + + bufnm = RSTRING_PTR(getpwnm_tmp); + bufsizenm = rb_str_capacity(getpwnm_tmp); + rb_str_set_len(getpwnm_tmp, bufsizenm); + + int enm; + errno = 0; + while ((enm = getpwnam_r(login, &pwdnm, bufnm, bufsizenm, &pwptr)) != 0) { + + if (enm == ENOENT || enm== ESRCH || enm == EBADF || enm == EPERM) { + /* not found; non-errors */ + rb_str_resize(getpwnm_tmp, 0); + return Qnil; + } + + if (enm != ERANGE || bufsizenm >= GETPW_R_SIZE_LIMIT) { + rb_str_resize(getpwnm_tmp, 0); + rb_syserr_fail(enm, "getpwnam_r"); + } + + rb_str_modify_expand(getpwnm_tmp, bufsizenm); + bufnm = RSTRING_PTR(getpwnm_tmp); + bufsizenm = rb_str_capacity(getpwnm_tmp); + } + + if (pwptr == NULL) { + /* no record in the password database for the login name */ + rb_str_resize(getpwnm_tmp, 0); + return Qnil; + } + + /* found it */ + VALUE result = rb_str_new_cstr(pwptr->pw_dir); + rb_str_resize(getpwnm_tmp, 0); + return result; + +# elif USE_GETPWNAM + + errno = 0; + pwptr = getpwnam(login); + if (pwptr) { + /* found it */ + return rb_str_new_cstr(pwptr->pw_dir); + } + if (errno + /* avoid treating as errors errno values that indicate "not found" */ + && ( errno != ENOENT && errno != ESRCH && errno != EBADF && errno != EPERM)) { + rb_syserr_fail(errno, "getpwnam"); + } + + return Qnil; /* not found */ +# endif + +#endif +} + +/** + * Look up the user's dflt home dir in the password db, by uid. + */ +VALUE +rb_getpwdiruid(void) +{ +# if !defined(USE_GETPWUID_R) && !defined(USE_GETPWUID) + /* Should never happen... </famous-last-words> */ + return Qnil; +# else + uid_t ruid = getuid(); + + struct passwd *pwptr; + +# ifdef USE_GETPWUID_R + + struct passwd pwdid; + char *bufid; + long bufsizeid = GETPW_R_SIZE_INIT; /* maybe -1 */ + + if (bufsizeid < 0) + bufsizeid = GETPW_R_SIZE_DEFAULT; + + VALUE getpwid_tmp = rb_str_tmp_new(bufsizeid); + + bufid = RSTRING_PTR(getpwid_tmp); + bufsizeid = rb_str_capacity(getpwid_tmp); + rb_str_set_len(getpwid_tmp, bufsizeid); + + int eid; + errno = 0; + while ((eid = getpwuid_r(ruid, &pwdid, bufid, bufsizeid, &pwptr)) != 0) { + + if (eid == ENOENT || eid== ESRCH || eid == EBADF || eid == EPERM) { + /* not found; non-errors */ + rb_str_resize(getpwid_tmp, 0); + return Qnil; + } + + if (eid != ERANGE || bufsizeid >= GETPW_R_SIZE_LIMIT) { + rb_str_resize(getpwid_tmp, 0); + rb_syserr_fail(eid, "getpwuid_r"); + } + + rb_str_modify_expand(getpwid_tmp, bufsizeid); + bufid = RSTRING_PTR(getpwid_tmp); + bufsizeid = rb_str_capacity(getpwid_tmp); + } + + if (pwptr == NULL) { + /* no record in the password database for the uid */ + rb_str_resize(getpwid_tmp, 0); + return Qnil; + } + + /* found it */ + VALUE result = rb_str_new_cstr(pwptr->pw_dir); + rb_str_resize(getpwid_tmp, 0); + return result; + +# elif defined(USE_GETPWUID) + + errno = 0; + pwptr = getpwuid(ruid); + if (pwptr) { + /* found it */ + return rb_str_new_cstr(pwptr->pw_dir); + } + if (errno + /* avoid treating as errors errno values that indicate "not found" */ + && ( errno == ENOENT || errno == ESRCH || errno == EBADF || errno == EPERM)) { + rb_syserr_fail(errno, "getpwuid"); + } + + return Qnil; /* not found */ +# endif + +#endif /* !defined(USE_GETPWUID_R) && !defined(USE_GETPWUID) */ +} +#endif /* HAVE_PWD_H */ + + /********************************************************************* * Document-class: Process::Sys * - * The <code>Process::Sys</code> module contains UID and GID + * The Process::Sys module contains UID and GID * functions which provide direct bindings to the system calls of the * same names instead of the more-portable versions of the same - * functionality found in the <code>Process</code>, - * <code>Process::UID</code>, and <code>Process::GID</code> modules. + * functionality found in the Process, + * Process::UID, and Process::GID modules. */ #if defined(HAVE_PWD_H) @@ -5007,21 +6082,20 @@ obj2uid(VALUE id struct passwd pwbuf; char *getpw_buf; long getpw_buf_len; + int e; if (!*getpw_tmp) { getpw_buf_len = GETPW_R_SIZE_INIT; if (getpw_buf_len < 0) getpw_buf_len = GETPW_R_SIZE_DEFAULT; - getpw_buf = rb_alloc_tmp_buffer(getpw_tmp, getpw_buf_len); - } - else { - getpw_buf = RSTRING_PTR(*getpw_tmp); - getpw_buf_len = rb_str_capacity(*getpw_tmp); + *getpw_tmp = rb_str_tmp_new(getpw_buf_len); } - errno = ERANGE; - /* gepwnam_r() on MacOS X doesn't set errno if buffer size is insufficient */ - while (getpwnam_r(usrname, &pwbuf, getpw_buf, getpw_buf_len, &pwptr)) { - if (errno != ERANGE || getpw_buf_len >= GETPW_R_SIZE_LIMIT) { - rb_free_tmp_buffer(getpw_tmp); - rb_sys_fail("getpwnam_r"); + getpw_buf = RSTRING_PTR(*getpw_tmp); + getpw_buf_len = rb_str_capacity(*getpw_tmp); + rb_str_set_len(*getpw_tmp, getpw_buf_len); + errno = 0; + while ((e = getpwnam_r(usrname, &pwbuf, getpw_buf, getpw_buf_len, &pwptr)) != 0) { + if (e != ERANGE || getpw_buf_len >= GETPW_R_SIZE_LIMIT) { + rb_str_resize(*getpw_tmp, 0); + rb_syserr_fail(e, "getpwnam_r"); } rb_str_modify_expand(*getpw_tmp, getpw_buf_len); getpw_buf = RSTRING_PTR(*getpw_tmp); @@ -5034,7 +6108,7 @@ obj2uid(VALUE id #ifndef USE_GETPWNAM_R endpwent(); #endif - rb_raise(rb_eArgError, "can't find user for %s", usrname); + rb_raise(rb_eArgError, "can't find user for %"PRIsVALUE, id); } uid = pwptr->pw_uid; #ifndef USE_GETPWNAM_R @@ -5085,21 +6159,20 @@ obj2gid(VALUE id struct group grbuf; char *getgr_buf; long getgr_buf_len; + int e; if (!*getgr_tmp) { getgr_buf_len = GETGR_R_SIZE_INIT; if (getgr_buf_len < 0) getgr_buf_len = GETGR_R_SIZE_DEFAULT; - getgr_buf = rb_alloc_tmp_buffer(getgr_tmp, getgr_buf_len); + *getgr_tmp = rb_str_tmp_new(getgr_buf_len); } - else { - getgr_buf = RSTRING_PTR(*getgr_tmp); - getgr_buf_len = rb_str_capacity(*getgr_tmp); - } - errno = ERANGE; - /* gegrnam_r() on MacOS X doesn't set errno if buffer size is insufficient */ - while (getgrnam_r(grpname, &grbuf, getgr_buf, getgr_buf_len, &grptr)) { - if (errno != ERANGE || getgr_buf_len >= GETGR_R_SIZE_LIMIT) { - rb_free_tmp_buffer(getgr_tmp); - rb_sys_fail("getgrnam_r"); + getgr_buf = RSTRING_PTR(*getgr_tmp); + getgr_buf_len = rb_str_capacity(*getgr_tmp); + rb_str_set_len(*getgr_tmp, getgr_buf_len); + errno = 0; + while ((e = getgrnam_r(grpname, &grbuf, getgr_buf, getgr_buf_len, &grptr)) != 0) { + if (e != ERANGE || getgr_buf_len >= GETGR_R_SIZE_LIMIT) { + rb_str_resize(*getgr_tmp, 0); + rb_syserr_fail(e, "getgrnam_r"); } rb_str_modify_expand(*getgr_tmp, getgr_buf_len); getgr_buf = RSTRING_PTR(*getgr_tmp); @@ -5114,7 +6187,7 @@ obj2gid(VALUE id #if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) endgrent(); #endif - rb_raise(rb_eArgError, "can't find group for %s", grpname); + rb_raise(rb_eArgError, "can't find group for %"PRIsVALUE, id); } gid = grptr->gr_gid; #if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) @@ -5271,9 +6344,9 @@ p_sys_setresuid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) /* * call-seq: - * Process.uid -> fixnum - * Process::UID.rid -> fixnum - * Process::Sys.getuid -> fixnum + * Process.uid -> integer + * Process::UID.rid -> integer + * Process::Sys.getuid -> integer * * Returns the (real) user ID of this process. * @@ -5332,7 +6405,7 @@ proc_setuid(VALUE obj, VALUE id) * * Document-class: Process::UID * - * The <code>Process::UID</code> module contains a collection of + * The Process::UID module contains a collection of * module functions which can be used to portably get, set, and * switch the current process's real, effective, and saved user IDs. * @@ -5357,7 +6430,7 @@ setreuid(rb_uid_t ruid, rb_uid_t euid) /* * call-seq: - * Process::UID.change_privilege(user) -> fixnum + * Process::UID.change_privilege(user) -> integer * * Change the current process's real and effective user ID to that * specified by _user_. Returns the new user ID. Not @@ -5490,8 +6563,7 @@ p_uid_change_privilege(VALUE obj, VALUE id) if (setruid(uid) < 0) rb_sys_fail(0); } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #elif defined HAVE_44BSD_SETUID if (getuid() == uid) { @@ -5500,24 +6572,21 @@ p_uid_change_privilege(VALUE obj, VALUE id) SAVED_USER_ID = uid; } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #elif defined HAVE_SETEUID if (getuid() == uid && SAVED_USER_ID == uid) { if (seteuid(uid) < 0) rb_sys_fail(0); } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #elif defined HAVE_SETUID if (getuid() == uid && SAVED_USER_ID == uid) { if (setuid(uid) < 0) rb_sys_fail(0); } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #else rb_notimplement(); @@ -5610,11 +6679,9 @@ static VALUE p_sys_setregid(VALUE obj, VALUE rid, VALUE eid) { rb_gid_t rgid, egid; - PREPARE_GETGRNAM; check_gid_switch(); rgid = OBJ2GID(rid); egid = OBJ2GID(eid); - FINISH_GETGRNAM; if (setregid(rgid, egid) != 0) rb_sys_fail(0); return Qnil; } @@ -5638,12 +6705,10 @@ static VALUE p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) { rb_gid_t rgid, egid, sgid; - PREPARE_GETGRNAM; check_gid_switch(); rgid = OBJ2GID(rid); egid = OBJ2GID(eid); sgid = OBJ2GID(sid); - FINISH_GETGRNAM; if (setresgid(rgid, egid, sgid) != 0) rb_sys_fail(0); return Qnil; } @@ -5668,7 +6733,6 @@ p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) static VALUE p_sys_issetugid(VALUE obj) { - rb_secure(2); if (issetugid()) { return Qtrue; } @@ -5683,9 +6747,9 @@ p_sys_issetugid(VALUE obj) /* * call-seq: - * Process.gid -> fixnum - * Process::GID.rid -> fixnum - * Process::Sys.getgid -> fixnum + * Process.gid -> integer + * Process::GID.rid -> integer + * Process::Sys.getgid -> integer * * Returns the (real) group ID for this process. * @@ -5703,7 +6767,7 @@ proc_getgid(VALUE obj) #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETRGID) || defined(HAVE_SETGID) /* * call-seq: - * Process.gid= fixnum -> fixnum + * Process.gid= integer -> integer * * Sets the group ID for this process. */ @@ -5792,11 +6856,24 @@ maxgroups(void) * call-seq: * Process.groups -> array * - * Get an <code>Array</code> of the gids of groups in the + * Get an Array of the group IDs in the * supplemental group access list for this process. * * Process.groups #=> [27, 6, 10, 11] * + * Note that this method is just a wrapper of getgroups(2). + * This means that the following characteristics of + * the result completely depend on your system: + * + * - the result is sorted + * - the result includes effective GIDs + * - the result does not include duplicated GIDs + * + * You can make sure to get a sorted unique GID list of + * the current process by this expression: + * + * Process.groups.uniq.sort + * */ static VALUE @@ -5835,7 +6912,7 @@ proc_getgroups(VALUE obj) * Process.groups= array -> array * * Set the supplemental group access list to the given - * <code>Array</code> of group IDs. + * Array of group IDs. * * Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] * Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11] @@ -5886,7 +6963,7 @@ proc_setgroups(VALUE obj, VALUE ary) * Initializes the supplemental group access list by reading the * system group database and using all groups of which the given user * is a member. The group with the specified <em>gid</em> is also - * added to the list. Returns the resulting <code>Array</code> of the + * added to the list. Returns the resulting Array of the * gids of all the groups in the supplementary group access list. Not * available on all platforms. * @@ -5899,7 +6976,7 @@ proc_setgroups(VALUE obj, VALUE ary) static VALUE proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp) { - if (initgroups(StringValuePtr(uname), OBJ2GID(base_grp)) != 0) { + if (initgroups(StringValueCStr(uname), OBJ2GID(base_grp)) != 0) { rb_sys_fail(0); } return proc_getgroups(obj); @@ -5911,7 +6988,7 @@ proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp) #if defined(_SC_NGROUPS_MAX) || defined(NGROUPS_MAX) /* * call-seq: - * Process.maxgroups -> fixnum + * Process.maxgroups -> integer * * Returns the maximum number of gids allowed in the supplemental * group access list. @@ -5931,7 +7008,7 @@ proc_getmaxgroups(VALUE obj) #ifdef HAVE_SETGROUPS /* * call-seq: - * Process.maxgroups= fixnum -> fixnum + * Process.maxgroups= integer -> integer * * Sets the maximum number of gids allowed in the supplemental group * access list. @@ -5944,7 +7021,7 @@ proc_setmaxgroups(VALUE obj, VALUE val) int ngroups_max = get_sc_ngroups_max(); if (ngroups <= 0) - rb_raise(rb_eArgError, "maxgroups %d shold be positive", ngroups); + rb_raise(rb_eArgError, "maxgroups %d should be positive", ngroups); if (ngroups > RB_MAX_GROUPS) ngroups = RB_MAX_GROUPS; @@ -5978,16 +7055,17 @@ static int rb_daemon(int nochdir, int noclose); */ static VALUE -proc_daemon(int argc, VALUE *argv) +proc_daemon(int argc, VALUE *argv, VALUE _) { - VALUE nochdir, noclose; - int n; + int n, nochdir = FALSE, noclose = FALSE; - rb_secure(2); - rb_scan_args(argc, argv, "02", &nochdir, &noclose); + switch (rb_check_arity(argc, 0, 2)) { + case 2: noclose = TO_BOOL(argv[1], "noclose"); + case 1: nochdir = TO_BOOL(argv[0], "nochdir"); + } prefork(); - n = rb_daemon(RTEST(nochdir), RTEST(noclose)); + n = rb_daemon(nochdir, noclose); if (n < 0) rb_sys_fail("daemon"); return INT2FIX(n); } @@ -5997,17 +7075,18 @@ rb_daemon(int nochdir, int noclose) { int err = 0; #ifdef HAVE_DAEMON + if (mjit_enabled) mjit_pause(false); // Don't leave locked mutex to child. before_fork_ruby(); err = daemon(nochdir, noclose); after_fork_ruby(); - rb_thread_atfork(); + rb_thread_atfork(); /* calls mjit_resume() */ #else int n; #define fork_daemon() \ switch (rb_fork_ruby(NULL)) { \ case -1: return -1; \ - case 0: rb_thread_atfork(); break; \ + case 0: break; \ default: _exit(EXIT_SUCCESS); \ } @@ -6040,7 +7119,7 @@ rb_daemon(int nochdir, int noclose) * * Document-class: Process::GID * - * The <code>Process::GID</code> module contains a collection of + * The Process::GID module contains a collection of * module functions which can be used to portably get, set, and * switch the current process's real, effective, and saved group IDs. * @@ -6065,7 +7144,7 @@ setregid(rb_gid_t rgid, rb_gid_t egid) /* * call-seq: - * Process::GID.change_privilege(group) -> fixnum + * Process::GID.change_privilege(group) -> integer * * Change the current process's real and effective group ID to that * specified by _group_. Returns the new group ID. Not @@ -6198,8 +7277,7 @@ p_gid_change_privilege(VALUE obj, VALUE id) if (setrgid(gid) < 0) rb_sys_fail(0); } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #elif defined HAVE_44BSD_SETGID if (getgid() == gid) { @@ -6208,24 +7286,21 @@ p_gid_change_privilege(VALUE obj, VALUE id) SAVED_GROUP_ID = gid; } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #elif defined HAVE_SETEGID if (getgid() == gid && SAVED_GROUP_ID == gid) { if (setegid(gid) < 0) rb_sys_fail(0); } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #elif defined HAVE_SETGID if (getgid() == gid && SAVED_GROUP_ID == gid) { if (setgid(gid) < 0) rb_sys_fail(0); } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } #else (void)gid; @@ -6238,9 +7313,9 @@ p_gid_change_privilege(VALUE obj, VALUE id) /* * call-seq: - * Process.euid -> fixnum - * Process::UID.eid -> fixnum - * Process::Sys.geteuid -> fixnum + * Process.euid -> integer + * Process::UID.eid -> integer + * Process::Sys.geteuid -> integer * * Returns the effective user ID for this process. * @@ -6339,8 +7414,8 @@ rb_seteuid_core(rb_uid_t euid) /* * call-seq: - * Process::UID.grant_privilege(user) -> fixnum - * Process::UID.eid= user -> fixnum + * Process::UID.grant_privilege(user) -> integer + * Process::UID.eid= user -> integer * * Set the effective user ID, and if possible, the saved user ID of * the process to the given _user_. Returns the new @@ -6361,9 +7436,9 @@ p_uid_grant_privilege(VALUE obj, VALUE id) /* * call-seq: - * Process.egid -> fixnum - * Process::GID.eid -> fixnum - * Process::Sys.geteid -> fixnum + * Process.egid -> integer + * Process::GID.eid -> integer + * Process::Sys.geteid -> integer * * Returns the effective group ID for this process. Not available on * all platforms. @@ -6382,7 +7457,7 @@ proc_getegid(VALUE obj) #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) || defined(_POSIX_SAVED_IDS) /* * call-seq: - * Process.egid = fixnum -> fixnum + * Process.egid = integer -> integer * * Sets the effective group ID for this process. Not available on all * platforms. @@ -6469,8 +7544,8 @@ rb_setegid_core(rb_gid_t egid) /* * call-seq: - * Process::GID.grant_privilege(group) -> fixnum - * Process::GID.eid = group -> fixnum + * Process::GID.grant_privilege(group) -> integer + * Process::GID.eid = group -> integer * * Set the effective group ID, and if possible, the saved group ID of * the process to the given _group_. Returns the new @@ -6499,7 +7574,7 @@ p_gid_grant_privilege(VALUE obj, VALUE id) */ static VALUE -p_uid_exchangeable(void) +p_uid_exchangeable(VALUE _) { #if defined(HAVE_SETRESUID) return Qtrue; @@ -6513,7 +7588,7 @@ p_uid_exchangeable(void) /* * call-seq: - * Process::UID.re_exchange -> fixnum + * Process::UID.re_exchange -> integer * * Exchange real and effective user IDs and return the new effective * user ID. Not available on all platforms. @@ -6561,7 +7636,7 @@ p_uid_exchange(VALUE obj) */ static VALUE -p_gid_exchangeable(void) +p_gid_exchangeable(VALUE _) { #if defined(HAVE_SETRESGID) return Qtrue; @@ -6575,7 +7650,7 @@ p_gid_exchangeable(void) /* * call-seq: - * Process::GID.re_exchange -> fixnum + * Process::GID.re_exchange -> integer * * Exchange real and effective group IDs and return the new effective * group ID. Not available on all platforms. @@ -6624,7 +7699,7 @@ p_gid_exchange(VALUE obj) */ static VALUE -p_uid_have_saved_id(void) +p_uid_have_saved_id(VALUE _) { #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) return Qtrue; @@ -6636,8 +7711,9 @@ p_uid_have_saved_id(void) #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) static VALUE -p_uid_sw_ensure(rb_uid_t id) +p_uid_sw_ensure(VALUE i) { + rb_uid_t id = (rb_uid_t/* narrowing */)i; under_uid_switch = 0; id = rb_seteuid_core(id); return UIDT2NUM(id); @@ -6646,7 +7722,7 @@ p_uid_sw_ensure(rb_uid_t id) /* * call-seq: - * Process::UID.switch -> fixnum + * Process::UID.switch -> integer * Process::UID.switch {|| block} -> object * * Switch the effective and real user IDs of the current process. If @@ -6688,11 +7764,10 @@ p_uid_switch(VALUE obj) } } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } - UNREACHABLE; + UNREACHABLE_RETURN(Qnil); } #else static VALUE @@ -6713,8 +7788,7 @@ p_uid_switch(VALUE obj) euid = geteuid(); if (uid == euid) { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } p_uid_exchange(obj); if (rb_block_given_p()) { @@ -6740,7 +7814,7 @@ p_uid_switch(VALUE obj) */ static VALUE -p_gid_have_saved_id(void) +p_gid_have_saved_id(VALUE _) { #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) return Qtrue; @@ -6751,8 +7825,9 @@ p_gid_have_saved_id(void) #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) static VALUE -p_gid_sw_ensure(rb_gid_t id) +p_gid_sw_ensure(VALUE i) { + rb_gid_t id = (rb_gid_t/* narrowing */)i; under_gid_switch = 0; id = rb_setegid_core(id); return GIDT2NUM(id); @@ -6761,7 +7836,7 @@ p_gid_sw_ensure(rb_gid_t id) /* * call-seq: - * Process::GID.switch -> fixnum + * Process::GID.switch -> integer * Process::GID.switch {|| block} -> object * * Switch the effective and real group IDs of the current process. If @@ -6803,11 +7878,10 @@ p_gid_switch(VALUE obj) } } else { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } - UNREACHABLE; + UNREACHABLE_RETURN(Qnil); } #else static VALUE @@ -6828,8 +7902,7 @@ p_gid_switch(VALUE obj) egid = getegid(); if (gid == egid) { - errno = EPERM; - rb_sys_fail(0); + rb_syserr_fail(EPERM, 0); } p_gid_exchange(obj); if (rb_block_given_p()) { @@ -6847,27 +7920,22 @@ p_gid_switch(VALUE obj) static long get_clk_tck(void) { - long hertz = #ifdef HAVE__SC_CLK_TCK - (double)sysconf(_SC_CLK_TCK); + return sysconf(_SC_CLK_TCK); +#elif defined CLK_TCK + return CLK_TCK; +#elif defined HZ + return HZ; #else -#ifndef HZ -# ifdef CLK_TCK -# define HZ CLK_TCK -# else -# define HZ 60 -# endif -#endif /* HZ */ - HZ; + return 60; #endif - return hertz; } /* * call-seq: * Process.times -> aProcessTms * - * Returns a <code>Tms</code> structure (see <code>Process::Tms</code>) + * Returns a <code>Tms</code> structure (see Process::Tms) * that contains user and system CPU times for this process, * and also for children processes. * @@ -6878,15 +7946,26 @@ get_clk_tck(void) VALUE rb_proc_times(VALUE obj) { - const double hertz = get_clk_tck(); - struct tms buf; VALUE utime, stime, cutime, cstime, ret; +#if defined(RUSAGE_SELF) && defined(RUSAGE_CHILDREN) + struct rusage usage_s, usage_c; + + if (getrusage(RUSAGE_SELF, &usage_s) != 0 || getrusage(RUSAGE_CHILDREN, &usage_c) != 0) + rb_sys_fail("getrusage"); + utime = DBL2NUM((double)usage_s.ru_utime.tv_sec + (double)usage_s.ru_utime.tv_usec/1e6); + stime = DBL2NUM((double)usage_s.ru_stime.tv_sec + (double)usage_s.ru_stime.tv_usec/1e6); + cutime = DBL2NUM((double)usage_c.ru_utime.tv_sec + (double)usage_c.ru_utime.tv_usec/1e6); + cstime = DBL2NUM((double)usage_c.ru_stime.tv_sec + (double)usage_c.ru_stime.tv_usec/1e6); +#else + const double hertz = (double)get_clk_tck(); + struct tms buf; times(&buf); utime = DBL2NUM(buf.tms_utime / hertz); stime = DBL2NUM(buf.tms_stime / hertz); cutime = DBL2NUM(buf.tms_cutime / hertz); cstime = DBL2NUM(buf.tms_cstime / hertz); +#endif ret = rb_struct_new(rb_cProcessTms, utime, stime, cutime, cstime); RB_GC_GUARD(utime); RB_GC_GUARD(stime); @@ -6903,13 +7982,16 @@ typedef LONG_LONG timetick_int_t; #define TIMETICK_INT_MIN LLONG_MIN #define TIMETICK_INT_MAX LLONG_MAX #define TIMETICK_INT2NUM(v) LL2NUM(v) +#define MUL_OVERFLOW_TIMETICK_P(a, b) MUL_OVERFLOW_LONG_LONG_P(a, b) #else typedef long timetick_int_t; #define TIMETICK_INT_MIN LONG_MIN #define TIMETICK_INT_MAX LONG_MAX #define TIMETICK_INT2NUM(v) LONG2NUM(v) +#define MUL_OVERFLOW_TIMETICK_P(a, b) MUL_OVERFLOW_LONG_P(a, b) #endif +CONSTFUNC(static timetick_int_t gcd_timetick_int(timetick_int_t, timetick_int_t)); static timetick_int_t gcd_timetick_int(timetick_int_t a, timetick_int_t b) { @@ -7022,8 +8104,7 @@ timetick2integer(struct timetick *ttp, timetick_int_t t = ttp->giga_count * 1000000000 + ttp->count; for (i = 0; i < num_numerators; i++) { timetick_int_t factor = numerators[i]; - if (MUL_OVERFLOW_SIGNED_INTEGER_P(factor, t, - TIMETICK_INT_MIN, TIMETICK_INT_MAX)) + if (MUL_OVERFLOW_TIMETICK_P(factor, t)) goto generic; t *= factor; } @@ -7086,7 +8167,7 @@ make_clock_result(struct timetick *ttp, } #ifdef __APPLE__ -static mach_timebase_info_data_t * +static const mach_timebase_info_data_t * get_mach_timebase_info(void) { static mach_timebase_info_data_t sTimebaseInfo; @@ -7097,6 +8178,14 @@ get_mach_timebase_info(void) return &sTimebaseInfo; } + +double +ruby_real_ms_time(void) +{ + const mach_timebase_info_data_t *info = get_mach_timebase_info(); + uint64_t t = mach_absolute_time(); + return (double)t * info->numer / info->denom / 1e6; +} #endif /* @@ -7109,16 +8198,16 @@ get_mach_timebase_info(void) * #=> 896053.968060096 * * +clock_id+ specifies a kind of clock. - * It is specifed as a constant which begins with <code>Process::CLOCK_</code> + * It is specified as a constant which begins with <code>Process::CLOCK_</code> * such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC. * * The supported constants depends on OS and version. * Ruby provides following types of +clock_id+ if available. * - * [CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1 - * [CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4 - * [CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, OpenBSD 5.4 - * [CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4 + * [CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12, Windows-8/Server-2012 + * [CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12, Windows-2000 + * [CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3, OpenBSD 5.4, macOS 10.12 + * [CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12 * [CLOCK_VIRTUAL] FreeBSD 3.0, OpenBSD 2.1 * [CLOCK_PROF] FreeBSD 3.0, OpenBSD 2.1 * [CLOCK_REALTIME_FAST] FreeBSD 8.1 @@ -7128,13 +8217,17 @@ get_mach_timebase_info(void) * [CLOCK_MONOTONIC_FAST] FreeBSD 8.1 * [CLOCK_MONOTONIC_PRECISE] FreeBSD 8.1 * [CLOCK_MONOTONIC_COARSE] Linux 2.6.32 - * [CLOCK_MONOTONIC_RAW] Linux 2.6.28 + * [CLOCK_MONOTONIC_RAW] Linux 2.6.28, macOS 10.12 + * [CLOCK_MONOTONIC_RAW_APPROX] macOS 10.12 * [CLOCK_BOOTTIME] Linux 2.6.39 * [CLOCK_BOOTTIME_ALARM] Linux 3.0 * [CLOCK_UPTIME] FreeBSD 7.0, OpenBSD 5.5 * [CLOCK_UPTIME_FAST] FreeBSD 8.1 + * [CLOCK_UPTIME_RAW] macOS 10.12 + * [CLOCK_UPTIME_RAW_APPROX] macOS 10.12 * [CLOCK_UPTIME_PRECISE] FreeBSD 8.1 * [CLOCK_SECOND] FreeBSD 8.1 + * [CLOCK_TAI] Linux 3.10 * * Note that SUS stands for Single Unix Specification. * SUS contains POSIX and clock_gettime is defined in the POSIX part. @@ -7222,10 +8315,9 @@ get_mach_timebase_info(void) * So the result can be interpreted differently across systems. * Time.now is recommended over CLOCK_REALTIME. */ -VALUE -rb_clock_gettime(int argc, VALUE *argv) +static VALUE +rb_clock_gettime(int argc, VALUE *argv, VALUE _) { - VALUE clk_id, unit; int ret; struct timetick tt; @@ -7234,13 +8326,15 @@ rb_clock_gettime(int argc, VALUE *argv) int num_numerators = 0; int num_denominators = 0; - rb_scan_args(argc, argv, "11", &clk_id, &unit); + VALUE unit = (rb_check_arity(argc, 1, 2) == 2) ? argv[1] : Qnil; + VALUE clk_id = argv[0]; if (SYMBOL_P(clk_id)) { /* * Non-clock_gettime clocks are provided by symbol clk_id. - * - * gettimeofday is always available on platforms supported by Ruby. + */ +#ifdef HAVE_GETTIMEOFDAY + /* * GETTIMEOFDAY_BASED_CLOCK_REALTIME is used for * CLOCK_REALTIME if clock_gettime is not available. */ @@ -7255,6 +8349,7 @@ rb_clock_gettime(int argc, VALUE *argv) denominators[num_denominators++] = 1000000000; goto success; } +#endif #define RUBY_TIME_BASED_CLOCK_REALTIME ID2SYM(id_TIME_BASED_CLOCK_REALTIME) if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) { @@ -7347,7 +8442,7 @@ rb_clock_gettime(int argc, VALUE *argv) #ifdef __APPLE__ #define RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC ID2SYM(id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) { - mach_timebase_info_data_t *info = get_mach_timebase_info(); + const mach_timebase_info_data_t *info = get_mach_timebase_info(); uint64_t t = mach_absolute_time(); tt.count = (int32_t)(t % 1000000000); tt.giga_count = t / 1000000000; @@ -7373,8 +8468,7 @@ rb_clock_gettime(int argc, VALUE *argv) #endif } /* EINVAL emulates clock_gettime behavior when clock_id is invalid. */ - errno = EINVAL; - rb_sys_fail(0); + rb_syserr_fail(EINVAL, 0); success: return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit); @@ -7384,52 +8478,55 @@ rb_clock_gettime(int argc, VALUE *argv) * call-seq: * Process.clock_getres(clock_id [, unit]) -> number * - * Returns the time resolution returned by POSIX clock_getres() function. + * Returns an estimate of the resolution of a +clock_id+ using the POSIX + * <code>clock_getres()</code> function. + * + * Note the reported resolution is often inaccurate on most platforms due to + * underlying bugs for this function and therefore the reported resolution + * often differs from the actual resolution of the clock in practice. + * Inaccurate reported resolutions have been observed for various clocks including + * CLOCK_MONOTONIC and CLOCK_MONOTONIC_RAW when using Linux, macOS, BSD or AIX + * platforms, when using ARM processors, or when using virtualization. * * +clock_id+ specifies a kind of clock. * See the document of +Process.clock_gettime+ for details. - * - * +clock_id+ can be a symbol as +Process.clock_gettime+. - * However the result may not be accurate. - * For example, +Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)+ - * returns 1.0e-06 which means 1 microsecond, but actual resolution can be more coarse. + * +clock_id+ can be a symbol as for +Process.clock_gettime+. * * If the given +clock_id+ is not supported, Errno::EINVAL is raised. * - * +unit+ specifies a type of the return value. + * +unit+ specifies the type of the return value. * +Process.clock_getres+ accepts +unit+ as +Process.clock_gettime+. - * The default value, +:float_second+, is also same as + * The default value, +:float_second+, is also the same as * +Process.clock_gettime+. * * +Process.clock_getres+ also accepts +:hertz+ as +unit+. - * +:hertz+ means a the reciprocal of +:float_second+. + * +:hertz+ means the reciprocal of +:float_second+. * * +:hertz+ can be used to obtain the exact value of - * the clock ticks per second for times() function and - * CLOCKS_PER_SEC for clock() function. + * the clock ticks per second for the times() function and + * CLOCKS_PER_SEC for the clock() function. * - * +Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)+ + * <code>Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)</code> * returns the clock ticks per second. * - * +Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)+ + * <code>Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)</code> * returns CLOCKS_PER_SEC. * * p Process.clock_getres(Process::CLOCK_MONOTONIC) * #=> 1.0e-09 * */ -VALUE -rb_clock_getres(int argc, VALUE *argv) +static VALUE +rb_clock_getres(int argc, VALUE *argv, VALUE _) { - VALUE clk_id, unit; - struct timetick tt; timetick_int_t numerators[2]; timetick_int_t denominators[2]; int num_numerators = 0; int num_denominators = 0; - rb_scan_args(argc, argv, "11", &clk_id, &unit); + VALUE unit = (rb_check_arity(argc, 1, 2) == 2) ? argv[1] : Qnil; + VALUE clk_id = argv[0]; if (SYMBOL_P(clk_id)) { #ifdef RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME @@ -7488,7 +8585,7 @@ rb_clock_getres(int argc, VALUE *argv) #ifdef RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) { - mach_timebase_info_data_t *info = get_mach_timebase_info(); + const mach_timebase_info_data_t *info = get_mach_timebase_info(); tt.count = 1; tt.giga_count = 0; numerators[num_numerators++] = info->numer; @@ -7512,8 +8609,7 @@ rb_clock_getres(int argc, VALUE *argv) #endif } /* EINVAL emulates clock_getres behavior when clock_id is invalid. */ - errno = EINVAL; - rb_sys_fail(0); + rb_syserr_fail(EINVAL, 0); success: if (unit == ID2SYM(id_hertz)) { @@ -7524,32 +8620,88 @@ rb_clock_getres(int argc, VALUE *argv) } } +static VALUE +get_CHILD_STATUS(ID _x, VALUE *_y) +{ + return rb_last_status_get(); +} + +static VALUE +get_PROCESS_ID(ID _x, VALUE *_y) +{ + return get_pid(); +} + +/* + * call-seq: + * Process.kill(signal, pid, ...) -> integer + * + * Sends the given signal to the specified process id(s) if _pid_ is positive. + * If _pid_ is zero, _signal_ is sent to all processes whose group ID is equal + * to the group ID of the process. If _pid_ is negative, results are dependent + * on the operating system. _signal_ may be an integer signal number or + * a POSIX signal name (either with or without a +SIG+ prefix). If _signal_ is + * negative (or starts with a minus sign), kills process groups instead of + * processes. Not all signals are available on all platforms. + * The keys and values of Signal.list are known signal names and numbers, + * respectively. + * + * pid = fork do + * Signal.trap("HUP") { puts "Ouch!"; exit } + * # ... do some work ... + * end + * # ... + * Process.kill("HUP", pid) + * Process.wait + * + * <em>produces:</em> + * + * Ouch! + * + * If _signal_ is an integer but wrong for signal, Errno::EINVAL or + * RangeError will be raised. Otherwise unless _signal_ is a String + * or a Symbol, and a known signal name, ArgumentError will be + * raised. + * + * Also, Errno::ESRCH or RangeError for invalid _pid_, Errno::EPERM + * when failed because of no privilege, will be raised. In these + * cases, signals may have been sent to preceding processes. + */ + +static VALUE +proc_rb_f_kill(int c, const VALUE *v, VALUE _) +{ + return rb_f_kill(c, v); +} + VALUE rb_mProcess; -VALUE rb_mProcUID; -VALUE rb_mProcGID; -VALUE rb_mProcID_Syscall; +static VALUE rb_mProcUID; +static VALUE rb_mProcGID; +static VALUE rb_mProcID_Syscall; /* - * The <code>Process</code> module is a collection of methods used to + * The Process module is a collection of methods used to * manipulate processes. */ void InitVM_process(void) { -#undef rb_intern -#define rb_intern(str) rb_intern_const(str) - rb_define_virtual_variable("$?", rb_last_status_get, 0); - rb_define_virtual_variable("$$", get_pid, 0); - rb_define_global_function("exec", rb_f_exec, -1); + rb_define_virtual_variable("$?", get_CHILD_STATUS, 0); + rb_define_virtual_variable("$$", get_PROCESS_ID, 0); + + rb_gvar_ractor_local("$$"); + rb_gvar_ractor_local("$?"); + + rb_define_global_function("exec", f_exec, -1); rb_define_global_function("fork", rb_f_fork, 0); rb_define_global_function("exit!", rb_f_exit_bang, -1); rb_define_global_function("system", rb_f_system, -1); rb_define_global_function("spawn", rb_f_spawn, -1); rb_define_global_function("sleep", rb_f_sleep, -1); - rb_define_global_function("exit", rb_f_exit, -1); - rb_define_global_function("abort", rb_f_abort, -1); + rb_define_global_function("exit", f_exit, -1); + rb_define_global_function("abort", f_abort, -1); rb_mProcess = rb_define_module("Process"); @@ -7568,28 +8720,36 @@ InitVM_process(void) rb_define_const(rb_mProcess, "WUNTRACED", INT2FIX(0)); #endif - rb_define_singleton_method(rb_mProcess, "exec", rb_f_exec, -1); + rb_define_singleton_method(rb_mProcess, "exec", f_exec, -1); rb_define_singleton_method(rb_mProcess, "fork", rb_f_fork, 0); rb_define_singleton_method(rb_mProcess, "spawn", rb_f_spawn, -1); rb_define_singleton_method(rb_mProcess, "exit!", rb_f_exit_bang, -1); - rb_define_singleton_method(rb_mProcess, "exit", rb_f_exit, -1); - rb_define_singleton_method(rb_mProcess, "abort", rb_f_abort, -1); + rb_define_singleton_method(rb_mProcess, "exit", f_exit, -1); + rb_define_singleton_method(rb_mProcess, "abort", f_abort, -1); + rb_define_singleton_method(rb_mProcess, "last_status", proc_s_last_status, 0); + rb_define_singleton_method(rb_mProcess, "_fork", rb_proc__fork, 0); - rb_define_module_function(rb_mProcess, "kill", rb_f_kill, -1); /* in signal.c */ - rb_define_module_function(rb_mProcess, "wait", proc_wait, -1); + rb_define_module_function(rb_mProcess, "kill", proc_rb_f_kill, -1); + rb_define_module_function(rb_mProcess, "wait", proc_m_wait, -1); rb_define_module_function(rb_mProcess, "wait2", proc_wait2, -1); - rb_define_module_function(rb_mProcess, "waitpid", proc_wait, -1); + rb_define_module_function(rb_mProcess, "waitpid", proc_m_wait, -1); rb_define_module_function(rb_mProcess, "waitpid2", proc_wait2, -1); rb_define_module_function(rb_mProcess, "waitall", proc_waitall, 0); rb_define_module_function(rb_mProcess, "detach", proc_detach, 1); + /* :nodoc: */ rb_cWaiter = rb_define_class_under(rb_mProcess, "Waiter", rb_cThread); rb_undef_alloc_func(rb_cWaiter); rb_undef_method(CLASS_OF(rb_cWaiter), "new"); rb_define_method(rb_cWaiter, "pid", detach_process_pid, 0); rb_cProcessStatus = rb_define_class_under(rb_mProcess, "Status", rb_cObject); + rb_define_alloc_func(rb_cProcessStatus, rb_process_status_allocate); rb_undef_method(CLASS_OF(rb_cProcessStatus), "new"); + rb_marshal_define_compat(rb_cProcessStatus, rb_cObject, + process_status_dump, process_status_load); + + rb_define_singleton_method(rb_cProcessStatus, "wait", rb_process_status_waitv, -1); rb_define_method(rb_cProcessStatus, "==", pst_equal, 1); rb_define_method(rb_cProcessStatus, "&", pst_bitand, 1); @@ -7598,7 +8758,7 @@ InitVM_process(void) rb_define_method(rb_cProcessStatus, "to_s", pst_to_s, 0); rb_define_method(rb_cProcessStatus, "inspect", pst_inspect, 0); - rb_define_method(rb_cProcessStatus, "pid", pst_pid, 0); + rb_define_method(rb_cProcessStatus, "pid", pst_pid_m, 0); rb_define_method(rb_cProcessStatus, "stopped?", pst_wifstopped, 0); rb_define_method(rb_cProcessStatus, "stopsig", pst_wstopsig, 0); @@ -7609,8 +8769,8 @@ InitVM_process(void) rb_define_method(rb_cProcessStatus, "success?", pst_success_p, 0); rb_define_method(rb_cProcessStatus, "coredump?", pst_wcoredump, 0); - rb_define_module_function(rb_mProcess, "pid", get_pid, 0); - rb_define_module_function(rb_mProcess, "ppid", get_ppid, 0); + rb_define_module_function(rb_mProcess, "pid", proc_get_pid, 0); + rb_define_module_function(rb_mProcess, "ppid", proc_get_ppid, 0); rb_define_module_function(rb_mProcess, "getpgrp", proc_getpgrp, 0); rb_define_module_function(rb_mProcess, "setpgrp", proc_setpgrp, 0); @@ -7790,77 +8950,116 @@ InitVM_process(void) rb_define_module_function(rb_mProcess, "times", rb_proc_times, 0); #ifdef CLOCK_REALTIME + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_REALTIME", CLOCKID2NUM(CLOCK_REALTIME)); #elif defined(RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_REALTIME", RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME); #endif #ifdef CLOCK_MONOTONIC + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_MONOTONIC", CLOCKID2NUM(CLOCK_MONOTONIC)); #elif defined(RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_MONOTONIC", RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC); #endif #ifdef CLOCK_PROCESS_CPUTIME_ID + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_PROCESS_CPUTIME_ID", CLOCKID2NUM(CLOCK_PROCESS_CPUTIME_ID)); #elif defined(RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_PROCESS_CPUTIME_ID", RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID); #endif #ifdef CLOCK_THREAD_CPUTIME_ID + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_THREAD_CPUTIME_ID", CLOCKID2NUM(CLOCK_THREAD_CPUTIME_ID)); #endif #ifdef CLOCK_VIRTUAL + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_VIRTUAL", CLOCKID2NUM(CLOCK_VIRTUAL)); #endif #ifdef CLOCK_PROF + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_PROF", CLOCKID2NUM(CLOCK_PROF)); #endif #ifdef CLOCK_REALTIME_FAST + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_REALTIME_FAST", CLOCKID2NUM(CLOCK_REALTIME_FAST)); #endif #ifdef CLOCK_REALTIME_PRECISE + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_REALTIME_PRECISE", CLOCKID2NUM(CLOCK_REALTIME_PRECISE)); #endif #ifdef CLOCK_REALTIME_COARSE + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_REALTIME_COARSE", CLOCKID2NUM(CLOCK_REALTIME_COARSE)); #endif #ifdef CLOCK_REALTIME_ALARM + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_REALTIME_ALARM", CLOCKID2NUM(CLOCK_REALTIME_ALARM)); #endif #ifdef CLOCK_MONOTONIC_FAST + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_FAST", CLOCKID2NUM(CLOCK_MONOTONIC_FAST)); #endif #ifdef CLOCK_MONOTONIC_PRECISE + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_PRECISE", CLOCKID2NUM(CLOCK_MONOTONIC_PRECISE)); #endif #ifdef CLOCK_MONOTONIC_RAW + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_RAW", CLOCKID2NUM(CLOCK_MONOTONIC_RAW)); #endif +#ifdef CLOCK_MONOTONIC_RAW_APPROX + /* see Process.clock_gettime */ + rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_RAW_APPROX", CLOCKID2NUM(CLOCK_MONOTONIC_RAW_APPROX)); +#endif #ifdef CLOCK_MONOTONIC_COARSE + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_COARSE", CLOCKID2NUM(CLOCK_MONOTONIC_COARSE)); #endif #ifdef CLOCK_BOOTTIME + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_BOOTTIME", CLOCKID2NUM(CLOCK_BOOTTIME)); #endif #ifdef CLOCK_BOOTTIME_ALARM + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_BOOTTIME_ALARM", CLOCKID2NUM(CLOCK_BOOTTIME_ALARM)); #endif #ifdef CLOCK_UPTIME + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_UPTIME", CLOCKID2NUM(CLOCK_UPTIME)); #endif #ifdef CLOCK_UPTIME_FAST + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_UPTIME_FAST", CLOCKID2NUM(CLOCK_UPTIME_FAST)); #endif #ifdef CLOCK_UPTIME_PRECISE + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_UPTIME_PRECISE", CLOCKID2NUM(CLOCK_UPTIME_PRECISE)); #endif +#ifdef CLOCK_UPTIME_RAW + /* see Process.clock_gettime */ + rb_define_const(rb_mProcess, "CLOCK_UPTIME_RAW", CLOCKID2NUM(CLOCK_UPTIME_RAW)); +#endif +#ifdef CLOCK_UPTIME_RAW_APPROX + /* see Process.clock_gettime */ + rb_define_const(rb_mProcess, "CLOCK_UPTIME_RAW_APPROX", CLOCKID2NUM(CLOCK_UPTIME_RAW_APPROX)); +#endif #ifdef CLOCK_SECOND + /* see Process.clock_gettime */ rb_define_const(rb_mProcess, "CLOCK_SECOND", CLOCKID2NUM(CLOCK_SECOND)); #endif +#ifdef CLOCK_TAI + /* see Process.clock_gettime */ + rb_define_const(rb_mProcess, "CLOCK_TAI", CLOCKID2NUM(CLOCK_TAI)); +#endif rb_define_module_function(rb_mProcess, "clock_gettime", rb_clock_gettime, -1); rb_define_module_function(rb_mProcess, "clock_getres", rb_clock_getres, -1); #if defined(HAVE_TIMES) || defined(_WIN32) + /* Placeholder for rusage */ rb_cProcessTms = rb_struct_define_under(rb_mProcess, "Tms", "utime", "stime", "cutime", "cstime", NULL); - rb_define_const(rb_cStruct, "Tms", rb_cProcessTms); /* for the backward compatibility */ #endif SAVED_USER_ID = geteuid(); @@ -7921,47 +9120,45 @@ InitVM_process(void) void Init_process(void) { - id_in = rb_intern("in"); - id_out = rb_intern("out"); - id_err = rb_intern("err"); - id_pid = rb_intern("pid"); - id_uid = rb_intern("uid"); - id_gid = rb_intern("gid"); - id_close = rb_intern("close"); - id_child = rb_intern("child"); - id_status = rb_intern("status"); + id_in = rb_intern_const("in"); + id_out = rb_intern_const("out"); + id_err = rb_intern_const("err"); + id_pid = rb_intern_const("pid"); + id_uid = rb_intern_const("uid"); + id_gid = rb_intern_const("gid"); + id_close = rb_intern_const("close"); + id_child = rb_intern_const("child"); #ifdef HAVE_SETPGID - id_pgroup = rb_intern("pgroup"); + id_pgroup = rb_intern_const("pgroup"); #endif #ifdef _WIN32 - id_new_pgroup = rb_intern("new_pgroup"); -#endif - id_unsetenv_others = rb_intern("unsetenv_others"); - id_chdir = rb_intern("chdir"); - id_umask = rb_intern("umask"); - id_close_others = rb_intern("close_others"); - id_ENV = rb_intern("ENV"); - id_nanosecond = rb_intern("nanosecond"); - id_microsecond = rb_intern("microsecond"); - id_millisecond = rb_intern("millisecond"); - id_second = rb_intern("second"); - id_float_microsecond = rb_intern("float_microsecond"); - id_float_millisecond = rb_intern("float_millisecond"); - id_float_second = rb_intern("float_second"); - id_GETTIMEOFDAY_BASED_CLOCK_REALTIME = rb_intern("GETTIMEOFDAY_BASED_CLOCK_REALTIME"); - id_TIME_BASED_CLOCK_REALTIME = rb_intern("TIME_BASED_CLOCK_REALTIME"); + id_new_pgroup = rb_intern_const("new_pgroup"); +#endif + id_unsetenv_others = rb_intern_const("unsetenv_others"); + id_chdir = rb_intern_const("chdir"); + id_umask = rb_intern_const("umask"); + id_close_others = rb_intern_const("close_others"); + id_nanosecond = rb_intern_const("nanosecond"); + id_microsecond = rb_intern_const("microsecond"); + id_millisecond = rb_intern_const("millisecond"); + id_second = rb_intern_const("second"); + id_float_microsecond = rb_intern_const("float_microsecond"); + id_float_millisecond = rb_intern_const("float_millisecond"); + id_float_second = rb_intern_const("float_second"); + id_GETTIMEOFDAY_BASED_CLOCK_REALTIME = rb_intern_const("GETTIMEOFDAY_BASED_CLOCK_REALTIME"); + id_TIME_BASED_CLOCK_REALTIME = rb_intern_const("TIME_BASED_CLOCK_REALTIME"); #ifdef HAVE_TIMES - id_TIMES_BASED_CLOCK_MONOTONIC = rb_intern("TIMES_BASED_CLOCK_MONOTONIC"); - id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern("TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID"); + id_TIMES_BASED_CLOCK_MONOTONIC = rb_intern_const("TIMES_BASED_CLOCK_MONOTONIC"); + id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern_const("TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID"); #endif #ifdef RUSAGE_SELF - id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern("GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID"); + id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern_const("GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID"); #endif - id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern("CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID"); + id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern_const("CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID"); #ifdef __APPLE__ - id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC = rb_intern("MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC"); + id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC = rb_intern_const("MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC"); #endif - id_hertz = rb_intern("hertz"); + id_hertz = rb_intern_const("hertz"); InitVM(process); } |