summaryrefslogtreecommitdiff
path: root/process.c
diff options
context:
space:
mode:
Diffstat (limited to 'process.c')
-rw-r--r--process.c5254
1 files changed, 3789 insertions, 1465 deletions
diff --git a/process.c b/process.c
index 427168de6c..97fa336b56 100644
--- a/process.c
+++ b/process.c
@@ -11,76 +11,117 @@
**********************************************************************/
-#include "ruby/ruby.h"
-#include "ruby/io.h"
-#include "ruby/thread.h"
-#include "ruby/util.h"
-#include "internal.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 "nacl/stat.h"
-# include "nacl/unistd.h"
-#endif
+#ifdef HAVE_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>
+#endif
+
+#ifdef __APPLE__
+# include <mach/mach_time.h>
#endif
-#define numberof(array) (int)(sizeof(array)/sizeof((array)[0]))
+#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
+#define open rb_w32_uopen
+#endif
#if defined(HAVE_TIMES) || defined(_WIN32)
static VALUE rb_cProcessTms;
@@ -133,31 +174,81 @@ 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)
-# ifdef HAVE_GETPWNAM_R
+# 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
+# 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 \
- long getpw_buf_len = sysconf(_SC_GETPW_R_SIZE_MAX); \
- char *getpw_buf = ALLOCA_N(char, (getpw_buf_len < 0 ? (getpw_buf_len = 4096) : getpw_buf_len));
-# define OBJ2UID(id) obj2uid((id), getpw_buf, getpw_buf_len)
-static rb_uid_t obj2uid(VALUE id, char *getpw_buf, size_t getpw_buf_len);
+ VALUE getpw_buf = 0
+# define FINISH_GETPWNAM \
+ (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);
+static inline rb_uid_t
+obj2uid0(VALUE id)
+{
+ rb_uid_t uid;
+ PREPARE_GETPWNAM;
+ uid = OBJ2UID1(id);
+ FINISH_GETPWNAM;
+ return uid;
+}
# else
# define PREPARE_GETPWNAM /* do nothing */
+# define FINISH_GETPWNAM /* do nothing */
+# define OBJ2UID1(id) obj2uid((id))
# define OBJ2UID(id) obj2uid((id))
static rb_uid_t obj2uid(VALUE id);
# endif
#else
# define PREPARE_GETPWNAM /* do nothing */
+# define FINISH_GETPWNAM /* do nothing */
+# define OBJ2UID1(id) NUM2UIDT(id)
# define OBJ2UID(id) NUM2UIDT(id)
# ifdef p_uid_from_name
# undef p_uid_from_name
@@ -166,19 +257,41 @@ static rb_uid_t obj2uid(VALUE id);
#endif
#if defined(HAVE_GRP_H)
-# ifdef HAVE_GETGRNAM_R
+# if defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
+# define USE_GETGRNAM_R
+# define GETGR_R_SIZE_INIT sysconf(_SC_GETGR_R_SIZE_MAX)
+# define GETGR_R_SIZE_DEFAULT 0x1000
+# define GETGR_R_SIZE_LIMIT 0x10000
+# endif
+# ifdef USE_GETGRNAM_R
# define PREPARE_GETGRNAM \
- long getgr_buf_len = sysconf(_SC_GETGR_R_SIZE_MAX); \
- char *getgr_buf = ALLOCA_N(char, (getgr_buf_len < 0 ? (getgr_buf_len = 4096) : getgr_buf_len));
-# define OBJ2GID(id) obj2gid((id), getgr_buf, getgr_buf_len)
-static rb_gid_t obj2gid(VALUE id, char *getgr_buf, size_t getgr_buf_len);
+ VALUE getgr_buf = 0
+# define FINISH_GETGRNAM \
+ (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);
+static inline rb_gid_t
+obj2gid0(VALUE id)
+{
+ rb_gid_t gid;
+ PREPARE_GETGRNAM;
+ gid = OBJ2GID1(id);
+ FINISH_GETGRNAM;
+ return gid;
+}
+static rb_gid_t obj2gid(VALUE id, VALUE *getgr_buf);
# else
# define PREPARE_GETGRNAM /* do nothing */
+# define FINISH_GETGRNAM /* do nothing */
+# define OBJ2GID1(id) obj2gid((id))
# define OBJ2GID(id) obj2gid((id))
static rb_gid_t obj2gid(VALUE id);
# endif
#else
# define PREPARE_GETGRNAM /* do nothing */
+# define FINISH_GETGRNAM /* do nothing */
+# define OBJ2GID1(id) NUM2GIDT(id)
# define OBJ2GID(id) NUM2GIDT(id)
# ifdef p_gid_from_name
# undef p_gid_from_name
@@ -186,9 +299,205 @@ static rb_gid_t obj2gid(VALUE id);
# endif
#endif
+#if SIZEOF_CLOCK_T == SIZEOF_INT
+typedef unsigned int unsigned_clock_t;
+#elif SIZEOF_CLOCK_T == SIZEOF_LONG
+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;
+#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;
+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;
+#ifdef HAVE_TIMES
+static ID id_TIMES_BASED_CLOCK_MONOTONIC;
+static ID id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID;
+#endif
+#ifdef RUSAGE_SELF
+static ID id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID;
+#endif
+static ID id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID;
+#ifdef __APPLE__
+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.
@@ -197,16 +506,20 @@ static rb_gid_t obj2gid(VALUE id);
*/
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.
@@ -221,10 +534,9 @@ get_pid(void)
*/
static VALUE
-get_ppid(void)
+proc_get_ppid(VALUE _)
{
- rb_secure(2);
- return PIDT2NUM(getppid());
+ return get_ppid();
}
@@ -232,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
@@ -252,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.
@@ -260,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_iv_set(th->last_status, "status", INT2FIX(status));
- rb_iv_set(th->last_status, "pid", PIDT2NUM(pid));
+ GET_THREAD()->last_status = rb_process_status_new(pid, status, 0);
}
void
@@ -281,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
@@ -295,16 +698,17 @@ rb_last_status_clear(void)
*/
static VALUE
-pst_to_i(VALUE st)
+pst_to_i(VALUE self)
{
- return rb_iv_get(st, "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.
*
@@ -314,15 +718,24 @@ pst_to_i(VALUE st)
*/
static VALUE
-pst_pid(VALUE st)
+pst_pid_m(VALUE self)
{
- return rb_attr_get(st, rb_intern("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);
@@ -351,6 +764,7 @@ pst_message(VALUE str, rb_pid_t pid, int status)
rb_str_cat2(str, " (core dumped)");
}
#endif
+ return str;
}
@@ -372,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);
@@ -397,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)));
@@ -431,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>.
*
@@ -452,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.
*
@@ -475,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
@@ -485,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).
@@ -524,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
@@ -565,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
@@ -607,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
@@ -617,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);
}
@@ -635,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 *st;
- int flags;
-};
+# 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;
+}
- if (flags) {
- rb_raise(rb_eArgError, "can't do waitpid with flags");
+static VALUE
+waitpid_sleep(VALUE x)
+{
+ struct waitpid_state *w = (struct waitpid_state *)x;
+
+ 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
@@ -782,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_:
*
@@ -803,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.
*
@@ -825,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);
}
@@ -860,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
@@ -870,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;
@@ -884,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
@@ -899,59 +1593,34 @@ 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;
}
-static inline ID
-id_pid(void)
-{
- ID pid;
- CONST_ID(pid, "pid");
- return pid;
-}
+static VALUE rb_cWaiter;
static VALUE
detach_process_pid(VALUE thread)
{
- return rb_thread_local_aref(thread, id_pid());
+ return rb_thread_local_aref(thread, id_pid);
}
static VALUE
@@ -970,8 +1639,8 @@ VALUE
rb_detach_process(rb_pid_t pid)
{
VALUE watcher = rb_thread_create(detach_process_watcher, (void*)(VALUE)pid);
- rb_thread_local_aset(watcher, id_pid(), PIDT2NUM(pid));
- rb_define_singleton_method(watcher, "pid", detach_process_pid, 0);
+ rb_thread_local_aset(watcher, id_pid, PIDT2NUM(pid));
+ RBASIC_SET_CLASS(watcher, rb_cWaiter);
return watcher;
}
@@ -982,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.
@@ -1010,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 }
@@ -1026,50 +1694,60 @@ rb_detach_process(rb_pid_t pid)
static VALUE
proc_detach(VALUE obj, VALUE pid)
{
- rb_secure(2);
return rb_detach_process(NUM2PIDT(pid));
}
-static int forked_child = 0;
-
-#ifdef SIGPIPE
-static RETSIGTYPE (*saved_sigpipe_handler)(int) = 0;
-#endif
-
-#ifdef SIGPIPE
-static RETSIGTYPE
-sig_do_nothing(int sig)
+/* This function should be async-signal-safe. Actually it is. */
+static void
+before_exec_async_signal_safe(void)
{
}
-#endif
-/* This function should be async-signal-safe. Actually it is. */
static void
-before_exec_async_signal_safe(void)
+before_exec_non_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]
+ * On Mac OS X 10.5.x (Leopard) or earlier, exec() may return ENOTSUP
+ * if the process have multiple threads. Therefore we have to kill
+ * 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.
*/
- saved_sigpipe_handler = signal(SIGPIPE, sig_do_nothing); /* async-signal-safe */
+ 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
-before_exec_non_async_signal_safe(void)
+stdfd_clear_nonblock(void)
{
- if (!forked_child) {
- /*
- * On Mac OS X 10.5.x (Leopard) or earlier, exec() may return ENOTSUPP
- * if the process have multiple threads. Therefore we have to kill
- * internal threads temporary. [ruby-core:10583]
- * This is also true on Haiku. It returns Errno::EPERM against exec()
- * in multiple threads.
- */
- rb_thread_stop_timer_thread(0);
+ /* 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 */
}
}
@@ -1084,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
@@ -1094,8 +1769,6 @@ after_exec_non_async_signal_safe(void)
{
rb_thread_reset_timer_thread();
rb_thread_start_timer_thread();
-
- forked_child = 0;
}
static void
@@ -1105,25 +1778,25 @@ after_exec(void)
after_exec_non_async_signal_safe();
}
-#define before_fork() before_exec()
-#define after_fork() (rb_threadptr_async_errinfo_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_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)
{
@@ -1132,134 +1805,48 @@ 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
}
-/* deprecated */
-static int
-proc_exec_v(char **argv, const char *prog)
-{
- char fbuf[MAXPATHLEN];
-
- if (!prog)
- prog = argv[0];
- prog = dln_find_exe_r(prog, 0, fbuf, sizeof(fbuf));
- if (!prog) {
- errno = ENOENT;
- return -1;
- }
- before_exec();
- execv(prog, argv);
- preserving_errno(try_with_sh(prog, argv, 0); after_exec());
- return -1;
-}
-
-/* deprecated */
-int
-rb_proc_exec_n(int argc, VALUE *argv, const char *prog)
-{
-#define ARGV_COUNT(n) ((n)+1)
-#define ARGV_SIZE(n) (sizeof(char*) * ARGV_COUNT(n))
-#define ALLOC_ARGV(n, v) ALLOCV_N(char*, (v), ARGV_COUNT(n))
-
- char **args;
- int i;
- int ret = -1;
- VALUE v;
-
- args = ALLOC_ARGV(argc+1, v);
- for (i=0; i<argc; i++) {
- args[i] = RSTRING_PTR(argv[i]);
- }
- args[i] = 0;
- if (args[0]) {
- ret = proc_exec_v(args, prog);
- }
- ALLOCV_END(v);
- return ret;
-
-#undef ARGV_COUNT
-#undef ARGV_SIZE
-#undef ALLOC_ARGV
-}
-
/* This function should be async-signal-safe. Actually it is. */
static int
proc_exec_sh(const char *str, VALUE envp_str)
{
-#ifdef __native_client__
- rb_notimplement();
- UNREACHABLE;
-#else
const char *s;
s = str;
@@ -1267,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_spawn(P_OVERLAY, (char *)str, 0);
- return -1;
-#else
-#if defined(__CYGWIN32__) || defined(__EMX__)
+ rb_w32_uspawn(P_OVERLAY, (char *)str, 0);
+#elif defined(__CYGWIN32__)
{
char fbuf[MAXPATHLEN];
char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf));
@@ -1289,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
@@ -1304,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
@@ -1330,31 +1913,41 @@ 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);
}
-static void
-free_exec_arg(void *ptr)
-{
- xfree(ptr);
-}
-
static size_t
memsize_exec_arg(const void *ptr)
{
- return ptr ? sizeof(struct rb_execarg) : 0;
+ return sizeof(struct rb_execarg);
}
static const rb_data_type_t exec_arg_data_type = {
- "exec_arg",
- {mark_exec_arg, free_exec_arg, memsize_exec_arg},
+ "exec_arg",
+ {mark_exec_arg, RUBY_TYPED_DEFAULT_FREE, memsize_exec_arg},
+ 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
};
-#if defined(_WIN32)
-#define HAVE_SPAWNV 1
+#ifdef _WIN32
+# define DEFAULT_PROCESS_ENCODING rb_utf8_encoding()
+#endif
+#ifdef DEFAULT_PROCESS_ENCODING
+# define EXPORT_STR(str) rb_str_export_to_enc((str), DEFAULT_PROCESS_ENCODING)
+# define EXPORT_DUP(str) export_dup(str)
+static VALUE
+export_dup(VALUE str)
+{
+ VALUE newstr = EXPORT_STR(str);
+ if (newstr == str) newstr = rb_str_dup(str);
+ return newstr;
+}
+#else
+# define EXPORT_STR(str) (str)
+# define EXPORT_DUP(str) rb_str_dup(str)
#endif
-#if !defined(HAVE_FORK) && defined(HAVE_SPAWNV)
+#if !defined(HAVE_WORKING_FORK) && defined(HAVE_SPAWNV)
# define USE_SPAWNV 1
#else
# define USE_SPAWNV 0
@@ -1365,7 +1958,7 @@ static const rb_data_type_t exec_arg_data_type = {
#if USE_SPAWNV
#if defined(_WIN32)
-#define proc_spawn_cmd_internal(argv, prog) rb_w32_aspawn(P_NOWAIT, (prog), (argv))
+#define proc_spawn_cmd_internal(argv, prog) rb_w32_uaspawn(P_NOWAIT, (prog), (argv))
#else
static rb_pid_t
proc_spawn_cmd_internal(char **argv, char *prog)
@@ -1375,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;
@@ -1389,7 +1981,6 @@ proc_spawn_cmd_internal(char **argv, char *prog)
after_exec();
if (status == -1) errno = ENOEXEC;
}
- rb_last_status_set(status == -1 ? 127 : status, 0);
return status;
}
#endif
@@ -1405,7 +1996,7 @@ proc_spawn_cmd(char **argv, VALUE prog, struct rb_execarg *eargp)
if (eargp->new_pgroup_given && eargp->new_pgroup_flag) {
flags = CREATE_NEW_PROCESS_GROUP;
}
- pid = rb_w32_aspawn_flags(P_NOWAIT, prog ? RSTRING_PTR(prog) : 0, argv, flags);
+ pid = rb_w32_uaspawn_flags(P_NOWAIT, prog ? RSTRING_PTR(prog) : 0, argv, flags);
#else
pid = proc_spawn_cmd_internal(argv, prog ? RSTRING_PTR(prog) : 0);
#endif
@@ -1414,7 +2005,7 @@ proc_spawn_cmd(char **argv, VALUE prog, struct rb_execarg *eargp)
}
#if defined(_WIN32)
-#define proc_spawn_sh(str) rb_w32_spawn(P_NOWAIT, (str), 0)
+#define proc_spawn_sh(str) rb_w32_uspawn(P_NOWAIT, (str), 0)
#else
static rb_pid_t
proc_spawn_sh(char *str)
@@ -1425,7 +2016,6 @@ proc_spawn_sh(char *str)
char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf));
before_exec();
status = spawnl(P_NOWAIT, (shell ? shell : "/bin/sh"), "sh", "-c", str, (char*)NULL);
- rb_last_status_set(status == -1 ? 127 : status, 0);
after_exec();
return status;
}
@@ -1435,7 +2025,7 @@ proc_spawn_sh(char *str)
static VALUE
hide_obj(VALUE obj)
{
- RBASIC(obj)->klass = 0;
+ RBASIC_CLEAR_CLASS(obj);
return obj;
}
@@ -1448,17 +2038,17 @@ check_exec_redirect_fd(VALUE v, int iskey)
fd = FIX2INT(v);
}
else if (SYMBOL_P(v)) {
- ID id = SYM2ID(v);
- if (id == rb_intern("in"))
+ ID id = rb_check_id(&v);
+ if (id == id_in)
fd = 0;
- else if (id == rb_intern("out"))
+ else if (id == id_out)
fd = 1;
- else if (id == rb_intern("err"))
+ else if (id == id_err)
fd = 2;
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)
@@ -1466,10 +2056,9 @@ check_exec_redirect_fd(VALUE v, int iskey)
fd = fptr->fd;
}
else {
- rb_raise(rb_eArgError, "wrong exec redirect");
+ goto wrong;
}
if (fd < 0) {
- wrong:
rb_raise(rb_eArgError, "negative file descriptor");
}
#ifdef _WIN32
@@ -1478,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
@@ -1491,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_PTR(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;
@@ -1512,26 +2104,26 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp)
switch (TYPE(val)) {
case T_SYMBOL:
- id = SYM2ID(val);
- if (id == rb_intern("close")) {
+ id = rb_check_id(&val);
+ if (id == id_close) {
param = Qnil;
eargp->fd_close = check_exec_redirect1(eargp->fd_close, key, param);
}
- else if (id == rb_intern("in")) {
+ else if (id == id_in) {
param = INT2FIX(0);
eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param);
}
- else if (id == rb_intern("out")) {
+ else if (id == id_out) {
param = INT2FIX(1);
eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param);
}
- else if (id == rb_intern("err")) {
+ else if (id == id_err) {
param = INT2FIX(2);
eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param);
}
else {
- rb_raise(rb_eArgError, "wrong exec redirect symbol: %s",
- rb_id2name(id));
+ rb_raise(rb_eArgError, "wrong exec redirect symbol: %"PRIsVALUE,
+ val);
}
break;
@@ -1547,7 +2139,7 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp)
case T_ARRAY:
path = rb_ary_entry(val, 0);
if (RARRAY_LEN(val) == 2 && SYMBOL_P(path) &&
- SYM2ID(path) == rb_intern("child")) {
+ path == ID2SYM(id_child)) {
param = check_exec_redirect_fd(rb_ary_entry(val, 1), 0);
eargp->fd_dup2_child = check_exec_redirect1(eargp->fd_dup2_child, key, param);
}
@@ -1562,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(rb_str_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;
@@ -1575,11 +2167,23 @@ check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp)
key = check_exec_redirect_fd(key, 1);
if (FIXNUM_P(key) && (FIX2INT(key) == 1 || FIX2INT(key) == 2))
flags = INT2NUM(O_WRONLY|O_CREAT|O_TRUNC);
- else
+ else if (RB_TYPE_P(key, T_ARRAY)) {
+ int i;
+ for (i = 0; i < RARRAY_LEN(key); i++) {
+ VALUE v = RARRAY_AREF(key, i);
+ VALUE fd = check_exec_redirect_fd(v, 1);
+ if (FIX2INT(fd) != 1 && FIX2INT(fd) != 2) break;
+ }
+ if (i == RARRAY_LEN(key))
+ flags = INT2NUM(O_WRONLY|O_CREAT|O_TRUNC);
+ else
+ flags = INT2NUM(O_RDONLY);
+ }
+ else
flags = INT2NUM(O_RDONLY);
perm = INT2FIX(0644);
- param = hide_obj(rb_ary_new3(3, hide_obj(rb_str_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;
@@ -1593,27 +2197,61 @@ 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:
- id = SYM2ID(key);
+#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 == rb_intern("pgroup")) {
- pid_t pgroup;
+ if (id == id_pgroup) {
+ rb_pid_t pgroup;
if (eargp->pgroup_given) {
rb_raise(rb_eArgError, "pgroup option specified twice");
}
@@ -1633,60 +2271,32 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
else
#endif
#ifdef _WIN32
- if (id == rb_intern("new_pgroup")) {
+ if (id == id_new_pgroup) {
if (eargp->new_pgroup_given) {
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
- if (id == rb_intern("unsetenv_others")) {
+ if (id == id_unsetenv_others) {
if (eargp->unsetenv_others_given) {
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 == rb_intern("chdir")) {
+ else if (id == id_chdir) {
if (eargp->chdir_given) {
rb_raise(rb_eArgError, "chdir option specified twice");
}
FilePathValue(val);
+ val = rb_str_encode_ospath(val);
eargp->chdir_given = 1;
- eargp->chdir_dir = hide_obj(rb_str_dup(val));
+ eargp->chdir_dir = hide_obj(EXPORT_DUP(val));
}
- else if (id == rb_intern("umask")) {
+ else if (id == id_umask) {
mode_t cmask = NUM2MODET(val);
if (eargp->umask_given) {
rb_raise(rb_eArgError, "umask option specified twice");
@@ -1694,33 +2304,32 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
eargp->umask_given = 1;
eargp->umask_mask = cmask;
}
- else if (id == rb_intern("close_others")) {
+ else if (id == id_close_others) {
if (eargp->close_others_given) {
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 == rb_intern("in")) {
+ else if (id == id_in) {
key = INT2FIX(0);
goto redirect;
}
- else if (id == rb_intern("out")) {
+ else if (id == id_out) {
key = INT2FIX(1);
goto redirect;
}
- else if (id == rb_intern("err")) {
+ else if (id == id_err) {
key = INT2FIX(2);
goto redirect;
}
- else if (id == rb_intern("uid")) {
+ else if (id == id_uid) {
#ifdef HAVE_SETUID
if (eargp->uid_given) {
rb_raise(rb_eArgError, "uid option specified twice");
}
check_uid_switch();
{
- PREPARE_GETPWNAM;
eargp->uid = OBJ2UID(val);
eargp->uid_given = 1;
}
@@ -1729,14 +2338,13 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
"uid option is unimplemented on this machine");
#endif
}
- else if (id == rb_intern("gid")) {
+ else if (id == id_gid) {
#ifdef HAVE_SETGID
if (eargp->gid_given) {
rb_raise(rb_eArgError, "gid option specified twice");
}
check_gid_switch();
{
- PREPARE_GETGRNAM;
eargp->gid = OBJ2GID(val);
eargp->gid_given = 1;
}
@@ -1745,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;
}
@@ -1765,12 +2380,6 @@ redirect:
return ST_CONTINUE;
}
-int
-rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val)
-{
- return rb_execarg_addopt(e->execarg_obj, key, val);
-}
-
static int
check_exec_options_i(st_data_t st_key, st_data_t st_val, st_data_t arg)
{
@@ -1779,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");
}
@@ -1808,21 +2417,21 @@ check_exec_fds_1(struct rb_execarg *eargp, VALUE h, int maxhint, VALUE ary)
if (ary != Qfalse) {
for (i = 0; i < RARRAY_LEN(ary); i++) {
- VALUE elt = RARRAY_PTR(ary)[i];
- int fd = FIX2INT(RARRAY_PTR(elt)[0]);
+ VALUE elt = RARRAY_AREF(ary, i);
+ int fd = FIX2INT(RARRAY_AREF(elt, 0));
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_PTR(elt)[1]);
+ rb_hash_aset(h, INT2FIX(fd), RARRAY_AREF(elt, 1));
else /* ary == eargp->fd_close */
rb_hash_aset(h, INT2FIX(fd), INT2FIX(-1));
if (maxhint < fd)
maxhint = fd;
if (ary == eargp->fd_dup2 || ary == eargp->fd_dup2_child) {
- fd = FIX2INT(RARRAY_PTR(elt)[1]);
+ fd = FIX2INT(RARRAY_AREF(elt, 1));
if (maxhint < fd)
maxhint = fd;
}
@@ -1841,15 +2450,14 @@ 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) {
ary = eargp->fd_dup2_child;
for (i = 0; i < RARRAY_LEN(ary); i++) {
- VALUE elt = RARRAY_PTR(ary)[i];
- int newfd = FIX2INT(RARRAY_PTR(elt)[0]);
- int oldfd = FIX2INT(RARRAY_PTR(elt)[1]);
+ VALUE elt = RARRAY_AREF(ary, i);
+ int newfd = FIX2INT(RARRAY_AREF(elt, 0));
+ int oldfd = FIX2INT(RARRAY_AREF(elt, 1));
int lastfd = oldfd;
VALUE val = rb_hash_lookup(h, INT2FIX(lastfd));
long depth = 0;
@@ -1884,7 +2492,7 @@ rb_check_exec_options(VALUE opthash, VALUE execarg_obj)
{
if (RHASH_EMPTY_P(opthash))
return;
- st_foreach(RHASH_TBL(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
@@ -1895,39 +2503,54 @@ rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash)
return Qnil;
args[0] = execarg_obj;
args[1] = Qnil;
- st_foreach(RHASH_TBL(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);
+ 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(RHASH_TBL(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
@@ -1935,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);
@@ -1945,29 +2567,41 @@ rb_check_argv(int argc, VALUE *argv)
if (RARRAY_LEN(tmp) != 2) {
rb_raise(rb_eArgError, "wrong first argument");
}
- prog = RARRAY_PTR(tmp)[0];
- argv[0] = RARRAY_PTR(tmp)[1];
+ prog = RARRAY_AREF(tmp, 0);
+ argv[0] = RARRAY_AREF(tmp, 1);
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 (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);
+}
+
+static VALUE
rb_exec_getargs(int *argc_p, VALUE **argv_p, int accept_shell, VALUE *env_ret, VALUE *opthash_ret)
{
VALUE hash, prog;
if (0 < *argc_p) {
- hash = rb_check_hash_type((*argv_p)[*argc_p-1]);
+ hash = check_hash((*argv_p)[*argc_p-1]);
if (!NIL_P(hash)) {
*opthash_ret = hash;
(*argc_p)--;
@@ -1975,7 +2609,7 @@ rb_exec_getargs(int *argc_p, VALUE **argv_p, int accept_shell, VALUE *env_ret, V
}
if (0 < *argc_p) {
- hash = rb_check_hash_type((*argv_p)[0]);
+ hash = check_hash((*argv_p)[0]);
if (!NIL_P(hash)) {
*env_ret = hash;
(*argc_p)--;
@@ -2021,10 +2655,11 @@ 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;
}
+ prog = EXPORT_STR(prog);
eargp->use_shell = argc == 0;
if (eargp->use_shell)
eargp->invoke.sh.shell_script = prog;
@@ -2118,7 +2753,7 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL
has_meta = 1;
}
if (!has_meta) {
- /* avoid shell since no shell meta charactor found. */
+ /* avoid shell since no shell meta character found. */
eargp->use_shell = 0;
}
if (!eargp->use_shell) {
@@ -2137,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
@@ -2157,8 +2797,13 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL
argv_buf = rb_str_buf_new(0);
hide_obj(argv_buf);
for (i = 0; i < argc; i++) {
- rb_str_buf_cat2(argv_buf, StringValueCStr(argv[i]));
- rb_str_buf_cat(argv_buf, "", 1); /* append '\0' */
+ VALUE arg = argv[i];
+ const char *s = StringValueCStr(arg);
+#ifdef DEFAULT_PROCESS_ENCODING
+ arg = EXPORT_STR(arg);
+ s = RSTRING_PTR(arg);
+#endif
+ rb_str_buf_cat(argv_buf, s, RSTRING_LEN(arg) + 1); /* include '\0' */
}
eargp->invoke.cmd.argv_buf = argv_buf;
}
@@ -2175,54 +2820,55 @@ 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, 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)
+struct rb_execarg *
+rb_execarg_get(VALUE execarg_obj)
{
struct rb_execarg *eargp;
TypedData_Get_Struct(execarg_obj, struct rb_execarg, &exec_arg_data_type, eargp);
return eargp;
}
-VALUE
-rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj)
+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);
VALUE prog, ret;
VALUE env = Qnil, opthash = Qnil;
+ VALUE argv_buf;
+ VALUE *argv = ALLOCV_N(VALUE, argv_buf, argc);
+ MEMCPY(argv, orig_argv, VALUE, argc);
prog = rb_exec_getargs(&argc, &argv, accept_shell, &env, &opthash);
rb_exec_fillarg(prog, argc, argv, env, opthash, execarg_obj);
+ ALLOCV_END(argv_buf);
ret = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
RB_GC_GUARD(execarg_obj);
return ret;
}
VALUE
-rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e)
+rb_execarg_new(int argc, const VALUE *argv, int accept_shell, int allow_exc_opt)
{
- return rb_execarg_init(argc, argv, accept_shell, e->execarg_obj);
+ 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;
}
@@ -2244,56 +2890,120 @@ 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, rb_intern("ENV"));
- envtbl = rb_convert_type(envtbl, T_HASH, "Hash", "to_hash");
+ envtbl = rb_env_to_hash();
}
hide_obj(envtbl);
if (envopts != Qfalse) {
- st_table *stenv = RHASH_TBL(envtbl);
+ st_table *stenv = RHASH_TBL_RAW(envtbl);
long i;
for (i = 0; i < RARRAY_LEN(envopts); i++) {
- VALUE pair = RARRAY_PTR(envopts)[i];
- VALUE key = RARRAY_PTR(pair)[0];
- VALUE val = RARRAY_PTR(pair)[1];
+ VALUE pair = RARRAY_AREF(envopts, i);
+ VALUE key = RARRAY_AREF(pair, 0);
+ VALUE val = RARRAY_AREF(pair, 1);
if (NIL_P(val)) {
- st_data_t stkey = (st_data_t)key;
- st_delete(stenv, &stkey, NULL);
+ st_data_t stkey = (st_data_t)key;
+ st_delete(stenv, &stkey, NULL);
}
else {
- st_insert(stenv, (st_data_t)key, (st_data_t)val);
+ st_insert(stenv, (st_data_t)key, (st_data_t)val);
+ RB_OBJ_WRITTEN(envtbl, Qundef, key);
+ RB_OBJ_WRITTEN(envtbl, Qundef, val);
}
}
}
envp_buf = rb_str_buf_new(0);
hide_obj(envp_buf);
- st_foreach(RHASH_TBL(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);
@@ -2304,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;
/*
@@ -2315,180 +3026,206 @@ 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);
}
+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_exec_arg_fixup(struct rb_exec_arg *e)
+rb_execarg_fail(VALUE execarg_obj, int err, const char *errmsg)
{
- rb_execarg_fixup(e->execarg_obj);
+ 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);
}
-static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen);
+NORETURN(static VALUE f_exec(int c, const VALUE *a, VALUE _));
/*
* call-seq:
* exec([env,] command... [,options])
*
- * Replaces the current process by running the given external _command_.
- * _command..._ is one of following forms.
+ * Replaces the current process by running the given external _command_, which
+ * can take one of the following forms:
+ *
+ * [<code>exec(commandline)</code>]
+ * command line string which is passed to the standard shell
+ * [<code>exec(cmdname, arg1, ...)</code>]
+ * command name and one or more arguments (no shell)
+ * [<code>exec([cmdname, argv0], arg1, ...)</code>]
+ * command name, argv[0] and zero or more arguments (no shell)
*
- * 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)
+ * In the first form, the string is taken as a command line that is subject to
+ * shell expansion before being executed.
*
- * If single string is given as the command,
- * it is taken as a command line that is subject to shell expansion before being executed.
+ * The standard shell always means <code>"/bin/sh"</code> on Unix-like systems,
+ * 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+.
*
- * The standard shell means always <code>"/bin/sh"</code> on Unix-like systems,
- * <code>ENV["RUBYSHELL"]</code> or <code>ENV["COMSPEC"]</code> on Windows NT series, and
- * similar.
+ * If the string from the first form (<code>exec("command")</code>) follows
+ * these simple rules:
*
- * If two or more +string+ given,
- * the first is taken as a command name and
- * the rest are passed as parameters to command with no shell expansion.
+ * * no meta characters
+ * * not starting with shell reserved word or special built-in
+ * * Ruby invokes the command directly without shell
*
- * If a two-element array at the beginning of the command,
- * the first element is the command to be executed,
- * and the second argument is used as the <code>argv[0]</code> value,
- * which may show up in process listings.
+ * You can force shell invocation by adding ";" to the string (because ";" is
+ * a meta character).
*
- * In order to execute the command, one of the <code>exec(2)</code>
- * system calls is used, so the running command may inherit some of the environment
+ * Note that this behavior is observable by pid obtained
+ * (return value of spawn() and IO#pid for IO.popen) is the pid of the invoked
+ * command, not shell.
+ *
+ * In the second form (<code>exec("command1", "arg1", ...)</code>), the first
+ * is taken as a command name and the rest are passed as parameters to command
+ * with no shell expansion.
+ *
+ * In the third form (<code>exec(["command", "argv0"], "arg1", ...)</code>),
+ * starting a two-element array at the beginning of the command, the first
+ * element is the command to be executed, and the second argument is used as
+ * the <code>argv[0]</code> value, which may show up in process listings.
+ *
+ * In order to execute the command, one of the <code>exec(2)</code> system
+ * calls are used, so the running command may inherit some of the environment
* of the original program (including open file descriptors).
- * This behavior is modified by env and options.
- * See <code>spawn</code> for details.
*
- * Raises SystemCallError if the command couldn't execute (typically
- * <code>Errno::ENOENT</code> when it was not found).
+ * This behavior is modified by the given +env+ and +options+ parameters. See
+ * ::spawn for details.
+ *
+ * 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
+ * <code>exec(2)</code> system call. See ::spawn for more details about the
+ * given +options+.
+ *
+ * The modified attributes may be retained when <code>exec(2)</code> system
+ * call fails.
+ *
+ * For example, hard resource limits are not restorable.
*
- * This method modifies process attributes according to _options_
- * (details described in <code>spawn</code>)
- * before <code>exec(2)</code> system call.
- * The modified attributes may be retained when <code>exec(2)</code> system call fails.
- * For example, hard resource limits is not restorable.
- * If it is not acceptable, consider to create a child process using <code>spawn</code> or <code>system</code>.
+ * Consider to create a child process using ::spawn or Kernel#system if this
+ * is not acceptable.
*
* exec "echo *" # echoes list of files in current directory
* # never get here
*
- *
* exec "echo", "*" # echoes an asterisk
* # never get here
*/
-VALUE
-rb_f_exec(int argc, 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
- rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg));
-#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;
-}
-#else
-#define redirect_dup(oldfd) dup(oldfd)
-#endif
-
-#if defined(DEBUG_REDIRECT) || defined(_WIN32)
-static int
-redirect_dup2(int oldfd, int newfd)
-{
- int ret;
- ret = dup2(oldfd, newfd);
- if (newfd >= 0 && newfd <= 2)
- SetStdHandle(newfd == 0 ? STD_INPUT_HANDLE : newfd == 1 ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE, (HANDLE)rb_w32_get_osfhandle(newfd));
-#if defined(DEBUG_REDIRECT)
- ttyprintf("dup2(%d, %d)\n", oldfd, newfd);
-#endif
- return ret;
-}
-#else
-#define redirect_dup2(oldfd, newfd) dup2((oldfd), (newfd))
-#endif
-
-#if defined(DEBUG_REDIRECT)
-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_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;
@@ -2501,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) {
@@ -2532,6 +3271,7 @@ struct run_exec_dup2_fd_pair {
int newfd;
long older_index;
long num_newer;
+ int cloexec;
};
static long
@@ -2540,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)
@@ -2547,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_PTR(ary)[i];
- pairs[i].oldfd = FIX2INT(RARRAY_PTR(elt)[1]);
- pairs[i].newfd = FIX2INT(RARRAY_PTR(elt)[0]); /* unique */
+ 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;
}
@@ -2595,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;
@@ -2609,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;
}
@@ -2680,8 +3473,8 @@ run_exec_close(VALUE ary, char *errmsg, size_t errmsg_buflen)
int ret;
for (i = 0; i < RARRAY_LEN(ary); i++) {
- VALUE elt = RARRAY_PTR(ary)[i];
- int fd = FIX2INT(RARRAY_PTR(elt)[0]);
+ VALUE elt = RARRAY_AREF(ary, i);
+ int fd = FIX2INT(RARRAY_AREF(elt, 0));
ret = redirect_close(fd); /* async-signal-safe */
if (ret == -1) {
ERRMSG("close");
@@ -2693,65 +3486,15 @@ 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_PTR(ary)[i];
- int fd = FIX2INT(RARRAY_PTR(elt)[0]);
- VALUE param = RARRAY_PTR(elt)[1];
- char *path = RSTRING_PTR(RARRAY_PTR(param)[0]);
- int flags = NUM2INT(RARRAY_PTR(param)[1]);
- int perm = NUM2INT(RARRAY_PTR(param)[2]);
- int need_close = 1;
- int fd2 = redirect_open(path, flags, perm); /* async-signal-safe */
- if (fd2 == -1) {
- ERRMSG("open");
- return -1;
- }
- rb_update_max_fd(fd2);
- while (i < RARRAY_LEN(ary) &&
- (elt = RARRAY_PTR(ary)[i], RARRAY_PTR(elt)[1] == param)) {
- fd = FIX2INT(RARRAY_PTR(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;
int ret;
for (i = 0; i < RARRAY_LEN(ary); i++) {
- VALUE elt = RARRAY_PTR(ary)[i];
- int newfd = FIX2INT(RARRAY_PTR(elt)[0]);
- int oldfd = FIX2INT(RARRAY_PTR(elt)[1]);
+ VALUE elt = RARRAY_AREF(ary, i);
+ int newfd = FIX2INT(RARRAY_AREF(elt, 0));
+ int oldfd = FIX2INT(RARRAY_AREF(elt, 1));
if (save_redirect_fd(newfd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */
return -1;
@@ -2771,13 +3514,14 @@ static int
run_exec_pgroup(const struct rb_execarg *eargp, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
{
/*
- * If FD_CLOEXEC is available, rb_fork waits the child's execve.
- * So setpgid is done in the child when rb_fork is returned in the parent.
+ * If FD_CLOEXEC is available, rb_fork_async_signal_safe waits the child's execve.
+ * So setpgid is done in the child when rb_fork_async_signal_safe is returned in
+ * the parent.
* No race condition, even without setpgid from the parent.
* (Is there an environment which has setpgid but no FD_CLOEXEC?)
*/
int ret;
- pid_t pgroup;
+ rb_pid_t pgroup;
pgroup = eargp->pgroup_pgid;
if (pgroup == -1)
@@ -2805,8 +3549,8 @@ run_exec_rlimit(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg
{
long i;
for (i = 0; i < RARRAY_LEN(ary); i++) {
- VALUE elt = RARRAY_PTR(ary)[i];
- int rtype = NUM2INT(RARRAY_PTR(elt)[0]);
+ VALUE elt = RARRAY_AREF(ary, i);
+ int rtype = NUM2INT(RARRAY_AREF(elt, 0));
struct rlimit rlim;
if (sargp) {
VALUE tmp, newary;
@@ -2814,7 +3558,7 @@ run_exec_rlimit(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg
ERRMSG("getrlimit");
return -1;
}
- tmp = hide_obj(rb_ary_new3(3, RARRAY_PTR(elt)[0],
+ tmp = hide_obj(rb_ary_new3(3, RARRAY_AREF(elt, 0),
RLIM2NUM(rlim.rlim_cur),
RLIM2NUM(rlim.rlim_max)));
if (sargp->rlimit_limits == Qfalse)
@@ -2823,8 +3567,8 @@ run_exec_rlimit(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg
newary = sargp->rlimit_limits;
rb_ary_push(newary, tmp);
}
- rlim.rlim_cur = NUM2RLIM(RARRAY_PTR(elt)[1]);
- rlim.rlim_max = NUM2RLIM(RARRAY_PTR(elt)[2]);
+ rlim.rlim_cur = NUM2RLIM(RARRAY_AREF(elt, 1));
+ rlim.rlim_max = NUM2RLIM(RARRAY_AREF(elt, 2));
if (setrlimit(rtype, &rlim) == -1) { /* hopefully async-signal-safe */
ERRMSG("setrlimit");
return -1;
@@ -2834,9 +3578,9 @@ run_exec_rlimit(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg
}
#endif
-#if !defined(HAVE_FORK)
+#if !defined(HAVE_WORKING_FORK)
static VALUE
-save_env_i(VALUE i, VALUE ary, int argc, VALUE *argv)
+save_env_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
{
rb_ary_push(ary, hide_obj(rb_ary_dup(argv[0])));
return Qnil;
@@ -2848,10 +3592,10 @@ save_env(struct rb_execarg *sargp)
if (!sargp)
return;
if (sargp->env_modification == Qfalse) {
- VALUE env = rb_const_get(rb_cObject, rb_intern("ENV"));
+ VALUE env = rb_envtbl();
if (RTEST(env)) {
VALUE ary = hide_obj(rb_ary_new());
- rb_block_call(env, rb_intern("each"), 0, 0, save_env_i,
+ rb_block_call(env, idEach, 0, 0, save_env_i,
(VALUE)ary);
sargp->env_modification = ary;
}
@@ -2861,6 +3605,11 @@ save_env(struct rb_execarg *sargp)
}
#endif
+#ifdef _WIN32
+#undef chdir
+#define chdir(p) rb_w32_uchdir(p)
+#endif
+
/* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */
int
rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
@@ -2888,7 +3637,7 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp,
}
#endif
-#if !defined(HAVE_FORK)
+#if !defined(HAVE_WORKING_FORK)
if (eargp->unsetenv_others_given && eargp->unsetenv_others_do) {
save_env(sargp);
rb_env_clear();
@@ -2899,9 +3648,9 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp,
long i;
save_env(sargp);
for (i = 0; i < RARRAY_LEN(obj); i++) {
- VALUE pair = RARRAY_PTR(obj)[i];
- VALUE key = RARRAY_PTR(pair)[0];
- VALUE val = RARRAY_PTR(pair)[1];
+ VALUE pair = RARRAY_AREF(obj, i);
+ VALUE key = RARRAY_AREF(pair, 0);
+ VALUE val = RARRAY_AREF(pair, 1);
if (NIL_P(val))
ruby_setenv(StringValueCStr(key), 0);
else
@@ -2935,18 +3684,12 @@ rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp,
}
}
-#ifdef HAVE_FORK
- if (!eargp->close_others_given || eargp->close_others_do) {
+#ifdef HAVE_WORKING_FORK
+ 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 */
@@ -2955,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");
@@ -2986,110 +3727,64 @@ 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;
}
+/* This function should be async-signal-safe. Hopefully it is. */
int
-rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char *errmsg, size_t errmsg_buflen)
-{
- return rb_execarg_run_options(rb_execarg_get(e->execarg_obj), rb_execarg_get(s->execarg_obj), errmsg, errmsg_buflen);
-}
-
-int
-rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
+rb_exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
{
- return rb_execarg_run_options(rb_execarg_get(e->execarg_obj), rb_execarg_get(s->execarg_obj), NULL, 0);
+ errno = exec_async_signal_safe(eargp, errmsg, errmsg_buflen);
+ return -1;
}
-/* This function should be async-signal-safe. Hopefully it is. */
-int
-rb_exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
+static int
+exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
{
-#if !defined(HAVE_FORK)
+#if !defined(HAVE_WORKING_FORK)
struct rb_execarg sarg, *const sargp = &sarg;
#else
struct rb_execarg *const sargp = NULL;
#endif
-
- before_exec_async_signal_safe(); /* async-signal-safe */
+ 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_FORK)
- preserving_errno(rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen));
+#if !defined(HAVE_WORKING_FORK)
+ rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen);
#endif
-failure:
- preserving_errno(after_exec_async_signal_safe()); /* async-signal-safe */
- return -1;
-}
-
-static int
-rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
-{
- int ret;
- before_exec_non_async_signal_safe(); /* async-signal-safe if forked_child is true */
- ret = rb_exec_async_signal_safe(eargp, errmsg, errmsg_buflen); /* hopefully async-signal-safe */
- preserving_errno(after_exec_non_async_signal_safe()); /* not async-signal-safe because it calls rb_thread_start_timer_thread. */
- return ret;
-}
-
-int
-rb_exec_err(const struct rb_exec_arg *e, char *errmsg, size_t errmsg_buflen)
-{
- return rb_exec_without_timer_thread(rb_execarg_get(e->execarg_obj), errmsg, errmsg_buflen);
-}
-
-int
-rb_exec(const struct rb_exec_arg *e)
-{
-#if !defined FD_CLOEXEC && !defined HAVE_SPAWNV
- char errmsg[80] = { '\0' };
- int ret = rb_exec_without_timer_thread(rb_execarg_get(e->execarg_obj), errmsg, sizeof(errmsg));
- preserving_errno(
- if (errmsg[0]) {
- fprintf(stderr, "%s\n", errmsg);
- }
- else {
- fprintf(stderr, "%s:%d: command not found: %s\n",
- rb_sourcefile(), rb_sourceline(),
- RSTRING_PTR(e->use_shell ? e->invoke.sh.shell_script : e->invoke.cmd.command_name));
- }
- );
- return ret;
-#else
- return rb_exec_without_timer_thread(rb_execarg_get(e->execarg_obj), NULL, 0);
-#endif
+ return err;
}
-#ifdef HAVE_FORK
+#ifdef HAVE_WORKING_FORK
/* This function should be async-signal-safe. Hopefully it is. */
static int
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_FORK
#if SIZEOF_INT == SIZEOF_LONG
#define proc_syswait (VALUE (*)(VALUE))rb_syswait
#else
@@ -3143,24 +3838,57 @@ pipe_nocrash(int filedes[2], VALUE fds)
return ret;
}
-struct chfunc_protect_t {
- int (*chfunc)(void*, char *, size_t);
- void *arg;
- char *errmsg;
- size_t buflen;
-};
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
static VALUE
-chfunc_protect(VALUE arg)
+rb_thread_sleep_that_takes_VALUE_as_sole_argument(VALUE n)
{
- struct chfunc_protect_t *p = (struct chfunc_protect_t *)arg;
-
- return (VALUE)(*p->chfunc)(p->arg, p->errmsg, p->buflen);
+ rb_thread_sleep(NUM2INT(n));
+ return Qundef;
}
-#ifndef O_BINARY
-#define O_BINARY 0
+static int
+handle_fork_error(int err, struct rb_process_status *status, int *ep, volatile int *try_gc_p)
+{
+ int state = 0;
+
+ switch (err) {
+ case ENOMEM:
+ if ((*try_gc_p)-- > 0 && !rb_during_gc()) {
+ rb_gc();
+ return 0;
+ }
+ break;
+ case EAGAIN:
+#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
+ case EWOULDBLOCK:
#endif
+ if (!status && !ep) {
+ rb_thread_sleep(1);
+ return 0;
+ }
+ else {
+ 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) {
+ close(ep[0]);
+ close(ep[1]);
+ errno = err;
+ }
+ if (state && !status) rb_jump_tag(state);
+ return -1;
+}
+
+#define prefork() ( \
+ rb_io_flush(rb_stdout), \
+ rb_io_flush(rb_stderr) \
+ )
/*
* Forks child process, and returns the process ID in the parent
@@ -3188,258 +3916,491 @@ chfunc_protect(VALUE arg)
* +chfunc+ must not raise any exceptions.
*/
-static rb_pid_t
-retry_fork(int *status, int *ep, int chfunc_is_async_signal_safe)
+static ssize_t
+write_retry(int fd, const void *buf, size_t len)
{
- rb_pid_t pid;
- int state = 0;
+ ssize_t w;
-#define prefork() ( \
- rb_io_flush(rb_stdout), \
- rb_io_flush(rb_stderr) \
- )
+ do {
+ w = write(fd, buf, len);
+ } while (w < 0 && errno == EINTR);
- while (1) {
- prefork();
- if (!chfunc_is_async_signal_safe)
- before_fork();
- pid = fork();
- if (pid == 0) /* fork succeed, child process */
- return pid;
- if (!chfunc_is_async_signal_safe)
- preserving_errno(after_fork());
- if (0 < pid) /* fork succeed, parent process */
- return pid;
- /* fork failed */
- switch (errno) {
- case EAGAIN:
-#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
+ return w;
+}
+
+static ssize_t
+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
- if (!status && !ep) {
- rb_thread_sleep(1);
- continue;
- }
- else {
- rb_protect((VALUE (*)())rb_thread_sleep, 1, &state);
- if (status) *status = state;
- if (!state) continue;
- }
- /* fall through */
- default:
- if (ep) {
- preserving_errno((close(ep[0]), close(ep[1])));
- }
- if (state && !status) rb_jump_tag(state);
- return -1;
- }
}
+
+ do {
+ r = read(fd, buf, len);
+ } while (r < 0 && errno == EINTR);
+
+ return r;
}
static void
-send_child_error(int fd, int state, char *errmsg, size_t errmsg_buflen, int chfunc_is_async_signal_safe)
+send_child_error(int fd, char *errmsg, size_t errmsg_buflen)
{
- VALUE io = Qnil;
int err;
- if (!chfunc_is_async_signal_safe) {
- if (write(fd, &state, sizeof(state)) == sizeof(state) && state) {
- VALUE errinfo = rb_errinfo();
- io = rb_io_fdopen(fd, O_WRONLY|O_BINARY, NULL);
- rb_marshal_dump(errinfo, io);
- rb_io_flush(io);
- }
- }
err = errno;
- if (write(fd, &err, sizeof(err)) < 0) err = errno;
+ if (write_retry(fd, &err, sizeof(err)) < 0) err = errno;
if (errmsg && 0 < errmsg_buflen) {
errmsg[errmsg_buflen-1] = '\0';
errmsg_buflen = strlen(errmsg);
- if (errmsg_buflen > 0 && write(fd, errmsg, errmsg_buflen) < 0)
+ if (errmsg_buflen > 0 && write_retry(fd, errmsg, errmsg_buflen) < 0)
err = errno;
}
- if (!NIL_P(io)) rb_io_close(io);
}
static int
-recv_child_error(int fd, int *statep, VALUE *excp, int *errp, char *errmsg, size_t errmsg_buflen, int chfunc_is_async_signal_safe)
+recv_child_error(int fd, int *errp, char *errmsg, size_t errmsg_buflen)
{
- int err, state = 0;
- VALUE io = Qnil;
+ int err;
ssize_t size;
- VALUE exc = Qnil;
- if (!chfunc_is_async_signal_safe) {
- if ((read(fd, &state, sizeof(state))) == sizeof(state) && state) {
- io = rb_io_fdopen(fd, O_RDONLY|O_BINARY, NULL);
- exc = rb_marshal_load(io);
- rb_set_errinfo(exc);
- }
- if (!*statep && state) *statep = state;
- *excp = exc;
- }
-#define READ_FROM_CHILD(ptr, len) \
- (NIL_P(io) ? read(fd, (ptr), (len)) : rb_io_bufread(io, (ptr), (len)))
- if ((size = READ_FROM_CHILD(&err, sizeof(err))) < 0) {
+ if ((size = read_retry(fd, &err, sizeof(err))) < 0) {
err = errno;
}
*errp = err;
if (size == sizeof(err) &&
errmsg && 0 < errmsg_buflen) {
- ssize_t ret = READ_FROM_CHILD(errmsg, errmsg_buflen-1);
+ ssize_t ret = read_retry(fd, errmsg, errmsg_buflen-1);
if (0 <= ret) {
errmsg[ret] = '\0';
}
}
- if (NIL_P(io))
- close(fd);
- else
- rb_io_close(io);
+ close(fd);
return size != 0;
}
-static rb_pid_t
-rb_fork_internal(int *status, int (*chfunc)(void*, char *, size_t), void *charg,
- int chfunc_is_async_signal_safe, VALUE fds,
- char *errmsg, size_t errmsg_buflen)
+#ifdef HAVE_WORKING_VFORK
+#if !defined(HAVE_GETRESUID) && defined(HAVE_GETUIDX)
+/* AIX 7.1 */
+static int
+getresuid(rb_uid_t *ruid, rb_uid_t *euid, rb_uid_t *suid)
{
- rb_pid_t pid;
- int err, state = 0;
- int ep[2];
- VALUE exc = Qnil;
- int error_occured;
+ rb_uid_t ret;
+
+ *ruid = getuid();
+ *euid = geteuid();
+ ret = getuidx(ID_SAVED);
+ if (ret == (rb_uid_t)-1)
+ return -1;
+ *suid = ret;
+ return 0;
+}
+#define HAVE_GETRESUID
+#endif
- if (status) *status = 0;
+#if !defined(HAVE_GETRESGID) && defined(HAVE_GETGIDX)
+/* AIX 7.1 */
+static int
+getresgid(rb_gid_t *rgid, rb_gid_t *egid, rb_gid_t *sgid)
+{
+ rb_gid_t ret;
- if (!chfunc) {
- pid = retry_fork(status, NULL, FALSE);
- if (pid < 0)
- return pid;
- if (!pid) {
- forked_child = 1;
- after_fork();
- }
- return pid;
+ *rgid = getgid();
+ *egid = getegid();
+ ret = getgidx(ID_SAVED);
+ if (ret == (rb_gid_t)-1)
+ return -1;
+ *sgid = ret;
+ return 0;
+}
+#define HAVE_GETRESGID
+#endif
+
+static int
+has_privilege(void)
+{
+ /*
+ * has_privilege() is used to choose vfork() or fork().
+ *
+ * If the process has privilege, the parent process or
+ * the child process can change UID/GID.
+ * If vfork() is used to create the child process and
+ * the parent or child process change effective UID/GID,
+ * different privileged processes shares memory.
+ * It is a bad situation.
+ * So, fork() should be used.
+ */
+
+ rb_uid_t ruid, euid;
+ rb_gid_t rgid, egid;
+
+#if defined HAVE_ISSETUGID
+ if (issetugid())
+ return 1;
+#endif
+
+#ifdef HAVE_GETRESUID
+ {
+ int ret;
+ rb_uid_t suid;
+ ret = getresuid(&ruid, &euid, &suid);
+ if (ret == -1)
+ rb_sys_fail("getresuid(2)");
+ if (euid != suid)
+ return 1;
}
- else {
- if (pipe_nocrash(ep, fds)) return -1;
- if (fcntl(ep[1], F_SETFD, FD_CLOEXEC)) {
- preserving_errno((close(ep[0]), close(ep[1])));
+#else
+ ruid = getuid();
+ euid = geteuid();
+#endif
+
+ if (euid == 0 || euid != ruid)
+ return 1;
+
+#ifdef HAVE_GETRESGID
+ {
+ int ret;
+ rb_gid_t sgid;
+ ret = getresgid(&rgid, &egid, &sgid);
+ if (ret == -1)
+ rb_sys_fail("getresgid(2)");
+ if (egid != sgid)
+ return 1;
+ }
+#else
+ rgid = getgid();
+ egid = getegid();
+#endif
+
+ if (egid != rgid)
+ return 1;
+
+ return 0;
+}
+#endif
+
+struct child_handler_disabler_state
+{
+ sigset_t sigmask;
+};
+
+static void
+disable_child_handler_before_fork(struct child_handler_disabler_state *old)
+{
+#ifdef HAVE_PTHREAD_SIGMASK
+ int ret;
+ sigset_t all;
+
+ 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) {
+ rb_syserr_fail(ret, "pthread_sigmask");
+ }
+#else
+# pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous"
+#endif
+}
+
+static void
+disable_child_handler_fork_parent(struct child_handler_disabler_state *old)
+{
+#ifdef HAVE_PTHREAD_SIGMASK
+ int ret;
+
+ ret = pthread_sigmask(SIG_SETMASK, &old->sigmask, NULL); /* not async-signal-safe */
+ if (ret != 0) {
+ rb_syserr_fail(ret, "pthread_sigmask");
+ }
+#else
+# pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous"
+#endif
+}
+
+/* This function should be async-signal-safe. Actually it is. */
+static int
+disable_child_handler_fork_child(struct child_handler_disabler_state *old, char *errmsg, size_t errmsg_buflen)
+{
+ int sig;
+ int ret;
+
+ for (sig = 1; sig < NSIG; sig++) {
+ 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;
}
- pid = retry_fork(status, ep, chfunc_is_async_signal_safe);
- if (pid < 0)
- return pid;
- if (!pid) {
+#ifdef SIGPIPE
+ 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");
+ return -1;
+ }
+ return 0;
+}
+
+static rb_pid_t
+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,
+ 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 = rb_fork();
+#else
+ pid = rb_fork();
+#endif
+ if (pid == 0) {/* fork succeed, child process */
int ret;
- forked_child = 1;
close(ep[0]);
- if (chfunc_is_async_signal_safe)
+ ret = disable_child_handler_fork_child(&old, errmsg, errmsg_buflen); /* async-signal-safe */
+ if (ret == 0) {
ret = chfunc(charg, errmsg, errmsg_buflen);
- else {
- struct chfunc_protect_t arg;
- arg.chfunc = chfunc;
- arg.arg = charg;
- arg.errmsg = errmsg;
- arg.buflen = errmsg_buflen;
- ret = (int)rb_protect(chfunc_protect, (VALUE)&arg, &state);
+ if (!ret) _exit(EXIT_SUCCESS);
}
- if (!ret) _exit(EXIT_SUCCESS);
- send_child_error(ep[1], state, errmsg, errmsg_buflen, chfunc_is_async_signal_safe);
+ send_child_error(ep[1], errmsg, errmsg_buflen);
#if EXIT_SUCCESS == 127
_exit(EXIT_FAILURE);
#else
_exit(127);
#endif
}
- close(ep[1]);
- error_occured = recv_child_error(ep[0], &state, &exc, &err, errmsg, errmsg_buflen, chfunc_is_async_signal_safe);
- if (state || error_occured) {
- if (status) {
- rb_protect(proc_syswait, (VALUE)pid, status);
- if (state) *status = state;
- }
- else {
- rb_syswait(pid);
- if (state) rb_exc_raise(exc);
+ 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);
}
- errno = err;
- return -1;
+ rb_native_mutex_unlock(waitpid_lock);
}
- return pid;
+ disable_child_handler_fork_parent(&old);
+ if (0 < pid) /* fork succeed, parent process */
+ return pid;
+ /* fork failed */
+ if (handle_fork_error(err, status, ep, &try_gc))
+ return -1;
}
}
-rb_pid_t
-rb_fork_err(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)
{
- return rb_fork_internal(status, chfunc, charg, FALSE, fds, errmsg, errmsg_buflen);
+ rb_pid_t pid;
+ int err;
+ int ep[2];
+ int error_occurred;
+
+ 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, 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) {
+ 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 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)
+rb_fork_async_signal_safe(int *status,
+ int (*chfunc)(void*, char *, size_t), void *charg,
+ VALUE fds, char *errmsg, size_t errmsg_buflen)
{
- return rb_fork_internal(status, chfunc, charg, TRUE, fds, errmsg, errmsg_buflen);
-}
+ struct rb_process_status process_status;
-struct chfunc_wrapper_t {
- int (*chfunc)(void*);
- void *arg;
-};
+ rb_pid_t result = fork_check_err(&process_status, chfunc, charg, fds, errmsg, errmsg_buflen, 0);
-static int
-chfunc_wrapper(void *arg_, char *errmsg, size_t errmsg_buflen)
-{
- struct chfunc_wrapper_t *arg = arg_;
- return arg->chfunc(arg->arg);
+ if (status) {
+ *status = process_status.status;
+ }
+
+ return result;
}
-rb_pid_t
-rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds)
+static rb_pid_t
+rb_fork_ruby2(struct rb_process_status *status)
{
- if (chfunc) {
- struct chfunc_wrapper_t warg;
- warg.chfunc = chfunc;
- warg.arg = charg;
- return rb_fork_internal(status, chfunc_wrapper, &warg, FALSE, fds, NULL, 0);
- }
- else {
- return rb_fork_internal(status, NULL, NULL, FALSE, fds, NULL, 0);
- }
+ rb_pid_t pid;
+ 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 = 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(err, status, NULL, &try_gc)) {
+ return -1;
+ }
+ }
}
rb_pid_t
rb_fork_ruby(int *status)
{
- return rb_fork_internal(status, NULL, NULL, FALSE, Qnil, NULL, 0);
+ struct rb_process_status process_status = {0};
+
+ rb_pid_t pid = rb_fork_ruby2(&process_status);
+
+ if (status) *status = process_status.status;
+
+ 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_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD)
+#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.
*
* If fork is not usable, Process.respond_to?(:fork) returns false.
+ *
+ * Note that fork(2) is not available on some platforms like Windows and NetBSD 4.
+ * Therefore you should use spawn() instead of fork().
*/
static VALUE
@@ -3447,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
@@ -3495,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)
@@ -3509,36 +4464,49 @@ exit_status_code(VALUE status)
static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
- VALUE status;
int istatus;
- rb_secure(4);
- 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);
args[1] = rb_str_new2("exit");
rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit));
}
- ruby_finalize();
- exit(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)
@@ -3546,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
@@ -3566,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" })
@@ -3580,57 +4548,56 @@ rb_exit(int status)
* in finalizer
*/
-VALUE
-rb_f_exit(int argc, VALUE *argv)
+static VALUE
+f_exit(int c, const VALUE *a, VALUE _)
{
- VALUE status;
- int istatus;
+ rb_f_exit(c, a);
+ UNREACHABLE_RETURN(Qnil);
+}
- rb_secure(4);
- if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) {
- istatus = exit_status_code(status);
+VALUE
+rb_f_abort(int argc, const VALUE *argv)
+{
+ rb_check_arity(argc, 0, 1);
+ if (argc == 0) {
+ 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);
}
else {
- istatus = EXIT_SUCCESS;
+ VALUE args[2];
+
+ args[1] = args[0] = argv[0];
+ StringValue(args[0]);
+ rb_io_puts(1, args, rb_ractor_stderr());
+ args[0] = INT2NUM(EXIT_FAILURE);
+ rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit));
}
- rb_exit(istatus);
- UNREACHABLE;
+ UNREACHABLE_RETURN(Qnil);
}
+NORETURN(static VALUE f_abort(int c, const VALUE *a, VALUE _));
/*
* call-seq:
* abort
* Kernel::abort([msg])
- * Process::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, VALUE *argv)
+static VALUE
+f_abort(int c, const VALUE *a, VALUE _)
{
- rb_secure(4);
- if (argc == 0) {
- if (!NIL_P(GET_THREAD()->errinfo)) {
- ruby_error_print();
- }
- rb_exit(EXIT_FAILURE);
- }
- else {
- VALUE args[2];
-
- rb_scan_args(argc, argv, "1", &args[1]);
- StringValue(argv[0]);
- rb_io_puts(argc, argv, rb_stderr);
- args[0] = INT2NUM(EXIT_FAILURE);
- rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit));
- }
-
- UNREACHABLE;
+ rb_f_abort(c, a);
+ UNREACHABLE_RETURN(Qnil);
}
void
@@ -3641,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_FORK || USE_SPAWNV
+#if !defined HAVE_WORKING_FORK || USE_SPAWNV
VALUE prog;
struct rb_execarg sarg;
+# if !defined HAVE_SPAWNV
+ int status;
+# endif
#endif
-#if defined HAVE_FORK && !USE_SPAWNV
- pid = rb_fork_async_signal_safe(&status, rb_exec_atfork, eargp, eargp->redirect_fds, errmsg, errmsg_buflen);
+#if defined HAVE_WORKING_FORK && !USE_SPAWNV
+ 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;
@@ -3668,79 +4658,118 @@ 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 defined(_WIN32)
- if (pid == -1)
- rb_last_status_set(0x7f << 8, 0);
-# endif
-# 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, VALUE *argv, char *errmsg, size_t errmsg_buflen)
+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
-rb_spawn_err(int argc, VALUE *argv, char *errmsg, size_t errmsg_buflen)
+rb_spawn_err(int argc, const VALUE *argv, char *errmsg, size_t errmsg_buflen)
{
return rb_spawn_internal(argc, argv, errmsg, errmsg_buflen);
}
rb_pid_t
-rb_spawn(int argc, VALUE *argv)
+rb_spawn(int argc, const VALUE *argv)
{
return rb_spawn_internal(argc, argv, NULL, 0);
}
/*
* 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", "*")
@@ -3750,43 +4779,81 @@ rb_spawn(int argc, 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_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;
}
/*
@@ -3796,11 +4863,19 @@ rb_f_system(int argc, VALUE *argv)
*
* spawn executes specified command and return its pid.
*
- * This method doesn't wait for end of the command.
+ * pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
+ * Process.wait pid
+ *
+ * pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
+ * Process.wait pid
+ *
+ * This method is similar to Kernel#system but it doesn't wait for the command
+ * 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.
*
@@ -3809,9 +4884,11 @@ 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 (no shell)
+ * cmdname, arg1, ... : command name and one or more arguments (This form does not use the shell. See below for caveats.)
* [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
* options: hash
* clearing environment variables:
@@ -3819,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
@@ -3848,10 +4925,19 @@ 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 <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.
* If a pair in +env+ has nil as the value, the variable is deleted.
@@ -3876,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
@@ -3910,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:
@@ -3920,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,
@@ -3939,9 +5025,10 @@ rb_f_system(int argc, VALUE *argv)
* pid = spawn(command, :in=>"/dev/null") # read mode
* pid = spawn(command, :out=>"/dev/null") # write mode
* pid = spawn(command, :err=>"log") # write mode
+ * pid = spawn(command, [:out, :err]=>"/dev/null") # write mode
* pid = spawn(command, 3=>"/dev/null") # read mode
*
- * For stdout and stderr,
+ * For stdout and stderr (and combination of them),
* it is opened in write mode.
* Otherwise read mode is used.
*
@@ -3998,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.
@@ -4035,33 +5122,30 @@ 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_FORK) || defined(HAVE_SPAWNV)
+#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
return PIDT2NUM(pid);
#else
return Qnil;
@@ -4070,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
@@ -4086,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);
}
@@ -4118,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);
@@ -4148,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 */
@@ -4183,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);
@@ -4207,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);
@@ -4219,6 +5304,37 @@ proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp)
#endif
+#ifdef HAVE_GETSID
+/*
+ * call-seq:
+ * Process.getsid() -> integer
+ * Process.getsid(pid) -> integer
+ *
+ * Returns the session ID for the given process id. If not given,
+ * return current process sid. Not available on all platforms.
+ *
+ * Process.getsid() #=> 27422
+ * Process.getsid(0) #=> 27422
+ * Process.getsid(Process.pid()) #=> 27422
+ */
+static VALUE
+proc_getsid(int argc, VALUE *argv, VALUE _)
+{
+ rb_pid_t sid;
+ rb_pid_t pid = 0;
+
+ if (rb_check_arity(argc, 0, 1) == 1 && !NIL_P(argv[0]))
+ pid = NUM2PIDT(argv[0]);
+
+ sid = getsid(pid);
+ if (sid < 0) rb_sys_fail(0);
+ return PIDT2NUM(sid);
+}
+#else
+#define proc_getsid rb_f_notimplement
+#endif
+
+
#if defined(HAVE_SETSID) || (defined(HAVE_SETPGRP) && defined(TIOCNOTTY))
#if !defined(HAVE_SETSID)
static rb_pid_t ruby_setsid(void);
@@ -4226,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
@@ -4236,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);
@@ -4281,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.
@@ -4301,7 +5416,6 @@ proc_getpriority(VALUE obj, VALUE which, VALUE who)
{
int prio, iwhich, iwho;
- rb_secure(2);
iwhich = NUM2INT(which);
iwho = NUM2INT(who);
@@ -4320,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
@@ -4333,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);
@@ -4348,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; \
} \
@@ -4457,27 +5570,48 @@ 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, 0);
+ return rlimit_resource_name2int(name, len, 0);
}
static int
-rlimit_type_by_lname(const char *name)
+rlimit_type_by_lname(const char *name, long len)
{
- return rlimit_resource_name2int(name, 1);
+ return rlimit_resource_name2int(name, len, 1);
+}
+
+static int
+rlimit_type_by_sym(VALUE key)
+{
+ 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;
switch (TYPE(rtype)) {
case T_SYMBOL:
- name = rb_id2name(SYM2ID(rtype));
+ v = rb_sym2str(rtype);
+ name = RSTRING_PTR(v);
+ len = RSTRING_LEN(v);
break;
default:
@@ -4486,6 +5620,7 @@ rlimit_resource_type(VALUE rtype)
rtype = v;
case T_STRING:
name = StringValueCStr(rtype);
+ len = RSTRING_LEN(rtype);
break;
}
/* fall through */
@@ -4495,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: %s", name);
+ rb_raise(rb_eArgError, "invalid resource name: % "PRIsVALUE, rtype);
- UNREACHABLE;
+ UNREACHABLE_RETURN(-1);
}
static rlim_t
@@ -4512,7 +5647,8 @@ rlimit_resource_value(VALUE rval)
switch (TYPE(rval)) {
case T_SYMBOL:
- name = rb_id2name(SYM2ID(rval));
+ v = rb_sym2str(rval);
+ name = RSTRING_PTR(v);
break;
default:
@@ -4539,9 +5675,9 @@ rlimit_resource_value(VALUE rval)
#ifdef RLIM_SAVED_CUR
if (strcmp(name, "SAVED_CUR") == 0) return RLIM_SAVED_CUR;
#endif
- rb_raise(rb_eArgError, "invalid resource value: %s", name);
+ rb_raise(rb_eArgError, "invalid resource value: %"PRIsVALUE, rval);
- UNREACHABLE;
+ UNREACHABLE_RETURN((rlim_t)-1);
}
#endif
@@ -4557,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.
*/
@@ -4571,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");
}
@@ -4597,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.
*
@@ -4620,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.
*
@@ -4640,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);
@@ -4662,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");
}
@@ -4672,28 +5805,267 @@ 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)
static rb_uid_t
obj2uid(VALUE id
-# ifdef HAVE_GETPWNAM_R
- , char *getpw_buf, size_t getpw_buf_len
+# ifdef USE_GETPWNAM_R
+ , VALUE *getpw_tmp
# endif
)
{
@@ -4706,21 +6078,40 @@ obj2uid(VALUE id
else {
const char *usrname = StringValueCStr(id);
struct passwd *pwptr;
-#ifdef HAVE_GETPWNAM_R
+#ifdef USE_GETPWNAM_R
struct passwd pwbuf;
- if (getpwnam_r(usrname, &pwbuf, getpw_buf, getpw_buf_len, &pwptr))
- rb_sys_fail("getpwnam_r");
+ 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_tmp = rb_str_tmp_new(getpw_buf_len);
+ }
+ 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);
+ getpw_buf_len = rb_str_capacity(*getpw_tmp);
+ }
#else
pwptr = getpwnam(usrname);
#endif
if (!pwptr) {
-#ifndef HAVE_GETPWNAM_R
+#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 HAVE_GETPWNAM_R
+#ifndef USE_GETPWNAM_R
endpwent();
#endif
}
@@ -4728,10 +6119,20 @@ obj2uid(VALUE id
}
# ifdef p_uid_from_name
+/*
+ * call-seq:
+ * Process::UID.from_name(name) -> uid
+ *
+ * Get the user ID by the _name_.
+ * If the user is not found, +ArgumentError+ will be raised.
+ *
+ * Process::UID.from_name("root") #=> 0
+ * Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError)
+ */
+
static VALUE
p_uid_from_name(VALUE self, VALUE id)
{
- PREPARE_GETPWNAM
return UIDT2NUM(OBJ2UID(id));
}
# endif
@@ -4740,8 +6141,8 @@ p_uid_from_name(VALUE self, VALUE id)
#if defined(HAVE_GRP_H)
static rb_gid_t
obj2gid(VALUE id
-# ifdef HAVE_GETGRNAM_R
- , char *getgr_buf, size_t getgr_buf_len
+# ifdef USE_GETGRNAM_R
+ , VALUE *getgr_tmp
# endif
)
{
@@ -4754,21 +6155,42 @@ obj2gid(VALUE id
else {
const char *grpname = StringValueCStr(id);
struct group *grptr;
-#ifdef HAVE_GETGRNAM_R
+#ifdef USE_GETGRNAM_R
struct group grbuf;
- if (getgrnam_r(grpname, &grbuf, getgr_buf, getgr_buf_len, &grptr))
- rb_sys_fail("getgrnam_r");
-#else
+ 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_tmp = rb_str_tmp_new(getgr_buf_len);
+ }
+ 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);
+ getgr_buf_len = rb_str_capacity(*getgr_tmp);
+ }
+#elif defined(HAVE_GETGRNAM)
grptr = getgrnam(grpname);
+#else
+ grptr = NULL;
#endif
if (!grptr) {
-#ifndef HAVE_GETGRNAM_R
+#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;
-#ifndef HAVE_GETGRNAM_R
+#if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT)
endgrent();
#endif
}
@@ -4776,10 +6198,20 @@ obj2gid(VALUE id
}
# ifdef p_gid_from_name
+/*
+ * call-seq:
+ * Process::GID.from_name(name) -> gid
+ *
+ * Get the group ID by the _name_.
+ * If the group is not found, +ArgumentError+ will be raised.
+ *
+ * Process::GID.from_name("wheel") #=> 0
+ * Process::GID.from_name("nosuchgroup") #=> can't find group for nosuchgroup (ArgumentError)
+ */
+
static VALUE
p_gid_from_name(VALUE self, VALUE id)
{
- PREPARE_GETGRNAM;
return GIDT2NUM(OBJ2GID(id));
}
# endif
@@ -4798,7 +6230,6 @@ p_gid_from_name(VALUE self, VALUE id)
static VALUE
p_sys_setuid(VALUE obj, VALUE id)
{
- PREPARE_GETPWNAM;
check_uid_switch();
if (setuid(OBJ2UID(id)) != 0) rb_sys_fail(0);
return Qnil;
@@ -4821,7 +6252,6 @@ p_sys_setuid(VALUE obj, VALUE id)
static VALUE
p_sys_setruid(VALUE obj, VALUE id)
{
- PREPARE_GETPWNAM;
check_uid_switch();
if (setruid(OBJ2UID(id)) != 0) rb_sys_fail(0);
return Qnil;
@@ -4844,7 +6274,6 @@ p_sys_setruid(VALUE obj, VALUE id)
static VALUE
p_sys_seteuid(VALUE obj, VALUE id)
{
- PREPARE_GETPWNAM;
check_uid_switch();
if (seteuid(OBJ2UID(id)) != 0) rb_sys_fail(0);
return Qnil;
@@ -4869,9 +6298,13 @@ p_sys_seteuid(VALUE obj, VALUE id)
static VALUE
p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid)
{
+ rb_uid_t ruid, euid;
PREPARE_GETPWNAM;
check_uid_switch();
- if (setreuid(OBJ2UID(rid), OBJ2UID(eid)) != 0) rb_sys_fail(0);
+ ruid = OBJ2UID1(rid);
+ euid = OBJ2UID1(eid);
+ FINISH_GETPWNAM;
+ if (setreuid(ruid, euid) != 0) rb_sys_fail(0);
return Qnil;
}
#else
@@ -4894,9 +6327,14 @@ p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid)
static VALUE
p_sys_setresuid(VALUE obj, VALUE rid, VALUE eid, VALUE sid)
{
+ rb_uid_t ruid, euid, suid;
PREPARE_GETPWNAM;
check_uid_switch();
- if (setresuid(OBJ2UID(rid), OBJ2UID(eid), OBJ2UID(sid)) != 0) rb_sys_fail(0);
+ ruid = OBJ2UID1(rid);
+ euid = OBJ2UID1(eid);
+ suid = OBJ2UID1(sid);
+ FINISH_GETPWNAM;
+ if (setresuid(ruid, euid, suid) != 0) rb_sys_fail(0);
return Qnil;
}
#else
@@ -4906,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.
*
@@ -4936,7 +6374,6 @@ static VALUE
proc_setuid(VALUE obj, VALUE id)
{
rb_uid_t uid;
- PREPARE_GETPWNAM;
check_uid_switch();
@@ -4968,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.
*
@@ -4993,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
@@ -5008,7 +6445,6 @@ static VALUE
p_uid_change_privilege(VALUE obj, VALUE id)
{
rb_uid_t uid;
- PREPARE_GETPWNAM;
check_uid_switch();
@@ -5072,6 +6508,7 @@ p_uid_change_privilege(VALUE obj, VALUE id)
SAVED_USER_ID = uid;
}
#else
+ (void)uid;
rb_notimplement();
#endif
}
@@ -5126,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) {
@@ -5136,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();
@@ -5177,7 +6610,6 @@ p_uid_change_privilege(VALUE obj, VALUE id)
static VALUE
p_sys_setgid(VALUE obj, VALUE id)
{
- PREPARE_GETGRNAM;
check_gid_switch();
if (setgid(OBJ2GID(id)) != 0) rb_sys_fail(0);
return Qnil;
@@ -5200,7 +6632,6 @@ p_sys_setgid(VALUE obj, VALUE id)
static VALUE
p_sys_setrgid(VALUE obj, VALUE id)
{
- PREPARE_GETGRNAM;
check_gid_switch();
if (setrgid(OBJ2GID(id)) != 0) rb_sys_fail(0);
return Qnil;
@@ -5223,7 +6654,6 @@ p_sys_setrgid(VALUE obj, VALUE id)
static VALUE
p_sys_setegid(VALUE obj, VALUE id)
{
- PREPARE_GETGRNAM;
check_gid_switch();
if (setegid(OBJ2GID(id)) != 0) rb_sys_fail(0);
return Qnil;
@@ -5248,9 +6678,11 @@ p_sys_setegid(VALUE obj, VALUE id)
static VALUE
p_sys_setregid(VALUE obj, VALUE rid, VALUE eid)
{
- PREPARE_GETGRNAM;
+ rb_gid_t rgid, egid;
check_gid_switch();
- if (setregid(OBJ2GID(rid), OBJ2GID(eid)) != 0) rb_sys_fail(0);
+ rgid = OBJ2GID(rid);
+ egid = OBJ2GID(eid);
+ if (setregid(rgid, egid) != 0) rb_sys_fail(0);
return Qnil;
}
#else
@@ -5272,9 +6704,12 @@ p_sys_setregid(VALUE obj, VALUE rid, VALUE eid)
static VALUE
p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid)
{
- PREPARE_GETGRNAM;
+ rb_gid_t rgid, egid, sgid;
check_gid_switch();
- if (setresgid(OBJ2GID(rid), OBJ2GID(eid), OBJ2GID(sid)) != 0) rb_sys_fail(0);
+ rgid = OBJ2GID(rid);
+ egid = OBJ2GID(eid);
+ sgid = OBJ2GID(sid);
+ if (setresgid(rgid, egid, sgid) != 0) rb_sys_fail(0);
return Qnil;
}
#else
@@ -5298,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;
}
@@ -5313,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.
*
@@ -5333,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.
*/
@@ -5342,7 +6776,6 @@ static VALUE
proc_setgid(VALUE obj, VALUE id)
{
rb_gid_t gid;
- PREPARE_GETGRNAM;
check_gid_switch();
@@ -5370,7 +6803,7 @@ proc_setgid(VALUE obj, VALUE id)
#endif
-#if defined(HAVE_SETGROUPS) || defined(HAVE_GETGROUPS)
+#if defined(_SC_NGROUPS_MAX) || defined(NGROUPS_MAX)
/*
* Maximum supplementary groups are platform dependent.
* FWIW, 65536 is enough big for our supported OSs.
@@ -5391,7 +6824,6 @@ proc_setgid(VALUE obj, VALUE id)
* HP-UX 20
* Windows 1015
*/
-#define RB_MAX_GROUPS (65536)
static int _maxgroups = -1;
static int
get_sc_ngroups_max(void)
@@ -5424,17 +6856,30 @@ 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
proc_getgroups(VALUE obj)
{
- VALUE ary;
+ VALUE ary, tmp;
int i, ngroups;
rb_gid_t *groups;
@@ -5442,7 +6887,7 @@ proc_getgroups(VALUE obj)
if (ngroups == -1)
rb_sys_fail(0);
- groups = ALLOCA_N(rb_gid_t, ngroups);
+ groups = ALLOCV_N(rb_gid_t, tmp, ngroups);
ngroups = getgroups(ngroups, groups);
if (ngroups == -1)
@@ -5452,6 +6897,8 @@ proc_getgroups(VALUE obj)
for (i = 0; i < ngroups; i++)
rb_ary_push(ary, GIDT2NUM(groups[i]));
+ ALLOCV_END(tmp);
+
return ary;
}
#else
@@ -5465,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]
@@ -5478,6 +6925,7 @@ proc_setgroups(VALUE obj, VALUE ary)
{
int ngroups, i;
rb_gid_t *groups;
+ VALUE tmp;
PREPARE_GETGRNAM;
Check_Type(ary, T_ARRAY);
@@ -5486,17 +6934,20 @@ proc_setgroups(VALUE obj, VALUE ary)
if (ngroups > maxgroups())
rb_raise(rb_eArgError, "too many groups, %d max", maxgroups());
- groups = ALLOCA_N(rb_gid_t, ngroups);
+ groups = ALLOCV_N(rb_gid_t, tmp, ngroups);
for (i = 0; i < ngroups; i++) {
- VALUE g = RARRAY_PTR(ary)[i];
+ VALUE g = RARRAY_AREF(ary, i);
- groups[i] = OBJ2GID(g);
+ groups[i] = OBJ2GID1(g);
}
+ FINISH_GETGRNAM;
if (setgroups(ngroups, groups) == -1) /* ngroups <= maxgroups */
rb_sys_fail(0);
+ ALLOCV_END(tmp);
+
return proc_getgroups(obj);
}
#else
@@ -5512,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.
*
@@ -5525,8 +6976,7 @@ proc_setgroups(VALUE obj, VALUE ary)
static VALUE
proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp)
{
- PREPARE_GETGRNAM;
- if (initgroups(StringValuePtr(uname), OBJ2GID(base_grp)) != 0) {
+ if (initgroups(StringValueCStr(uname), OBJ2GID(base_grp)) != 0) {
rb_sys_fail(0);
}
return proc_getgroups(obj);
@@ -5538,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.
@@ -5558,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.
@@ -5571,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;
@@ -5587,7 +7037,7 @@ proc_setmaxgroups(VALUE obj, VALUE val)
#define proc_setmaxgroups rb_f_notimplement
#endif
-#if defined(HAVE_DAEMON) || (defined(HAVE_FORK) && defined(HAVE_SETSID))
+#if defined(HAVE_DAEMON) || (defined(HAVE_WORKING_FORK) && defined(HAVE_SETSID))
static int rb_daemon(int nochdir, int noclose);
/*
@@ -5605,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);
}
@@ -5624,32 +7075,27 @@ rb_daemon(int nochdir, int noclose)
{
int err = 0;
#ifdef HAVE_DAEMON
- before_fork();
+ if (mjit_enabled) mjit_pause(false); // Don't leave locked mutex to child.
+ before_fork_ruby();
err = daemon(nochdir, noclose);
- after_fork();
+ after_fork_ruby();
+ rb_thread_atfork(); /* calls mjit_resume() */
#else
int n;
- switch (rb_fork_ruby(NULL)) {
- case -1:
- rb_sys_fail("daemon");
- case 0:
- break;
- default:
- _exit(EXIT_SUCCESS);
+#define fork_daemon() \
+ switch (rb_fork_ruby(NULL)) { \
+ case -1: return -1; \
+ case 0: break; \
+ default: _exit(EXIT_SUCCESS); \
}
- proc_setsid();
+ fork_daemon();
+
+ if (setsid() < 0) return -1;
/* must not be process-leader */
- switch (rb_fork_ruby(NULL)) {
- case -1:
- return -1;
- case 0:
- break;
- default:
- _exit(EXIT_SUCCESS);
- }
+ fork_daemon();
if (!nochdir)
err = chdir("/");
@@ -5673,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.
*
@@ -5698,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
@@ -5713,7 +7159,6 @@ static VALUE
p_gid_change_privilege(VALUE obj, VALUE id)
{
rb_gid_t gid;
- PREPARE_GETGRNAM;
check_gid_switch();
@@ -5832,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) {
@@ -5842,26 +7286,24 @@ 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;
rb_notimplement();
#endif
}
@@ -5871,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.
*
@@ -5922,7 +7364,6 @@ proc_seteuid(rb_uid_t uid)
static VALUE
proc_seteuid_m(VALUE mod, VALUE euid)
{
- PREPARE_GETPWNAM;
check_uid_switch();
proc_seteuid(OBJ2UID(euid));
return euid;
@@ -5973,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
@@ -5988,7 +7429,6 @@ rb_seteuid_core(rb_uid_t euid)
static VALUE
p_uid_grant_privilege(VALUE obj, VALUE id)
{
- PREPARE_GETPWNAM;
rb_seteuid_core(OBJ2UID(id));
return id;
}
@@ -5996,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.
@@ -6017,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.
@@ -6028,7 +7468,6 @@ proc_setegid(VALUE obj, VALUE egid)
{
#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID)
rb_gid_t gid;
- PREPARE_GETGRNAM;
#endif
check_gid_switch();
@@ -6105,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
@@ -6120,7 +7559,6 @@ rb_setegid_core(rb_gid_t egid)
static VALUE
p_gid_grant_privilege(VALUE obj, VALUE id)
{
- PREPARE_GETGRNAM;
rb_setegid_core(OBJ2GID(id));
return id;
}
@@ -6136,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;
@@ -6150,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.
@@ -6198,7 +7636,7 @@ p_uid_exchange(VALUE obj)
*/
static VALUE
-p_gid_exchangeable(void)
+p_gid_exchangeable(VALUE _)
{
#if defined(HAVE_SETRESGID)
return Qtrue;
@@ -6212,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.
@@ -6261,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;
@@ -6273,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);
@@ -6283,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
@@ -6325,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
@@ -6350,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()) {
@@ -6377,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;
@@ -6388,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);
@@ -6398,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
@@ -6440,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
@@ -6465,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()) {
@@ -6481,11 +7917,25 @@ p_gid_switch(VALUE obj)
#if defined(HAVE_TIMES)
+static long
+get_clk_tck(void)
+{
+#ifdef HAVE__SC_CLK_TCK
+ return sysconf(_SC_CLK_TCK);
+#elif defined CLK_TCK
+ return CLK_TCK;
+#elif defined HZ
+ return HZ;
+#else
+ return 60;
+#endif
+}
+
/*
* call-seq:
- * Process.times -> aStructTms
+ * Process.times -> aProcessTms
*
- * Returns a <code>Tms</code> structure (see <code>Struct::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.
*
@@ -6496,57 +7946,762 @@ p_gid_switch(VALUE obj)
VALUE
rb_proc_times(VALUE obj)
{
- const double hertz =
-#ifdef HAVE__SC_CLK_TCK
- (double)sysconf(_SC_CLK_TCK);
+ 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
-#ifndef HZ
-# ifdef CLK_TCK
-# define HZ CLK_TCK
-# else
-# define HZ 60
-# endif
-#endif /* HZ */
- HZ;
-#endif
+ const double hertz = (double)get_clk_tck();
struct tms buf;
- volatile VALUE utime, stime, cutime, sctime;
times(&buf);
- return rb_struct_new(rb_cProcessTms,
- utime = DBL2NUM(buf.tms_utime / hertz),
- stime = DBL2NUM(buf.tms_stime / hertz),
- cutime = DBL2NUM(buf.tms_cutime / hertz),
- sctime = DBL2NUM(buf.tms_cstime / hertz));
+ 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);
+ RB_GC_GUARD(cutime);
+ RB_GC_GUARD(cstime);
+ return ret;
}
#else
#define rb_proc_times rb_f_notimplement
#endif
+#ifdef HAVE_LONG_LONG
+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)
+{
+ timetick_int_t t;
+
+ if (a < b) {
+ t = a;
+ a = b;
+ b = t;
+ }
+
+ while (1) {
+ t = a % b;
+ if (t == 0)
+ return b;
+ a = b;
+ b = t;
+ }
+}
+
+static void
+reduce_fraction(timetick_int_t *np, timetick_int_t *dp)
+{
+ timetick_int_t gcd = gcd_timetick_int(*np, *dp);
+ if (gcd != 1) {
+ *np /= gcd;
+ *dp /= gcd;
+ }
+}
+
+static void
+reduce_factors(timetick_int_t *numerators, int num_numerators,
+ timetick_int_t *denominators, int num_denominators)
+{
+ int i, j;
+ for (i = 0; i < num_numerators; i++) {
+ if (numerators[i] == 1)
+ continue;
+ for (j = 0; j < num_denominators; j++) {
+ if (denominators[j] == 1)
+ continue;
+ reduce_fraction(&numerators[i], &denominators[j]);
+ }
+ }
+}
+
+struct timetick {
+ timetick_int_t giga_count;
+ int32_t count; /* 0 .. 999999999 */
+};
+
+static VALUE
+timetick2dblnum(struct timetick *ttp,
+ timetick_int_t *numerators, int num_numerators,
+ timetick_int_t *denominators, int num_denominators)
+{
+ double d;
+ int i;
+
+ reduce_factors(numerators, num_numerators,
+ denominators, num_denominators);
+
+ d = ttp->giga_count * 1e9 + ttp->count;
+
+ for (i = 0; i < num_numerators; i++)
+ d *= numerators[i];
+ for (i = 0; i < num_denominators; i++)
+ d /= denominators[i];
+
+ return DBL2NUM(d);
+}
+
+static VALUE
+timetick2dblnum_reciprocal(struct timetick *ttp,
+ timetick_int_t *numerators, int num_numerators,
+ timetick_int_t *denominators, int num_denominators)
+{
+ double d;
+ int i;
+
+ reduce_factors(numerators, num_numerators,
+ denominators, num_denominators);
+
+ d = 1.0;
+ for (i = 0; i < num_denominators; i++)
+ d *= denominators[i];
+ for (i = 0; i < num_numerators; i++)
+ d /= numerators[i];
+ d /= ttp->giga_count * 1e9 + ttp->count;
+
+ return DBL2NUM(d);
+}
+
+#define NDIV(x,y) (-(-((x)+1)/(y))-1)
+#define DIV(n,d) ((n)<0 ? NDIV((n),(d)) : (n)/(d))
+
+static VALUE
+timetick2integer(struct timetick *ttp,
+ timetick_int_t *numerators, int num_numerators,
+ timetick_int_t *denominators, int num_denominators)
+{
+ VALUE v;
+ int i;
+
+ reduce_factors(numerators, num_numerators,
+ denominators, num_denominators);
+
+ if (!MUL_OVERFLOW_SIGNED_INTEGER_P(1000000000, ttp->giga_count,
+ TIMETICK_INT_MIN, TIMETICK_INT_MAX-ttp->count)) {
+ 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_TIMETICK_P(factor, t))
+ goto generic;
+ t *= factor;
+ }
+ for (i = 0; i < num_denominators; i++) {
+ t = DIV(t, denominators[i]);
+ }
+ return TIMETICK_INT2NUM(t);
+ }
+
+ generic:
+ v = TIMETICK_INT2NUM(ttp->giga_count);
+ v = rb_funcall(v, '*', 1, LONG2FIX(1000000000));
+ v = rb_funcall(v, '+', 1, LONG2FIX(ttp->count));
+ for (i = 0; i < num_numerators; i++) {
+ timetick_int_t factor = numerators[i];
+ if (factor == 1)
+ continue;
+ v = rb_funcall(v, '*', 1, TIMETICK_INT2NUM(factor));
+ }
+ for (i = 0; i < num_denominators; i++) {
+ v = rb_funcall(v, '/', 1, TIMETICK_INT2NUM(denominators[i])); /* Ruby's '/' is div. */
+ }
+ return v;
+}
+
+static VALUE
+make_clock_result(struct timetick *ttp,
+ timetick_int_t *numerators, int num_numerators,
+ timetick_int_t *denominators, int num_denominators,
+ VALUE unit)
+{
+ if (unit == ID2SYM(id_nanosecond)) {
+ numerators[num_numerators++] = 1000000000;
+ return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
+ }
+ else if (unit == ID2SYM(id_microsecond)) {
+ numerators[num_numerators++] = 1000000;
+ return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
+ }
+ else if (unit == ID2SYM(id_millisecond)) {
+ numerators[num_numerators++] = 1000;
+ return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
+ }
+ else if (unit == ID2SYM(id_second)) {
+ return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
+ }
+ else if (unit == ID2SYM(id_float_microsecond)) {
+ numerators[num_numerators++] = 1000000;
+ return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators);
+ }
+ else if (unit == ID2SYM(id_float_millisecond)) {
+ numerators[num_numerators++] = 1000;
+ return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators);
+ }
+ else if (NIL_P(unit) || unit == ID2SYM(id_float_second)) {
+ return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators);
+ }
+ else
+ rb_raise(rb_eArgError, "unexpected unit: %"PRIsVALUE, unit);
+}
+
+#ifdef __APPLE__
+static const mach_timebase_info_data_t *
+get_mach_timebase_info(void)
+{
+ static mach_timebase_info_data_t sTimebaseInfo;
+
+ if ( sTimebaseInfo.denom == 0 ) {
+ (void) mach_timebase_info(&sTimebaseInfo);
+ }
+
+ 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
+
+/*
+ * call-seq:
+ * Process.clock_gettime(clock_id [, unit]) -> number
+ *
+ * Returns a time returned by POSIX clock_gettime() function.
+ *
+ * p Process.clock_gettime(Process::CLOCK_MONOTONIC)
+ * #=> 896053.968060096
+ *
+ * +clock_id+ specifies a kind of clock.
+ * 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, 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
+ * [CLOCK_REALTIME_PRECISE] FreeBSD 8.1
+ * [CLOCK_REALTIME_COARSE] Linux 2.6.32
+ * [CLOCK_REALTIME_ALARM] Linux 3.0
+ * [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, 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.
+ * SUS defines CLOCK_REALTIME mandatory but
+ * CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional.
+ *
+ * Also, several symbols are accepted as +clock_id+.
+ * There are emulations for clock_gettime().
+ *
+ * For example, Process::CLOCK_REALTIME is defined as
+ * +:GETTIMEOFDAY_BASED_CLOCK_REALTIME+ when clock_gettime() is not available.
+ *
+ * Emulations for +CLOCK_REALTIME+:
+ * [:GETTIMEOFDAY_BASED_CLOCK_REALTIME]
+ * Use gettimeofday() defined by SUS.
+ * (SUSv4 obsoleted it, though.)
+ * The resolution is 1 microsecond.
+ * [:TIME_BASED_CLOCK_REALTIME]
+ * Use time() defined by ISO C.
+ * The resolution is 1 second.
+ *
+ * Emulations for +CLOCK_MONOTONIC+:
+ * [:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC]
+ * Use mach_absolute_time(), available on Darwin.
+ * The resolution is CPU dependent.
+ * [:TIMES_BASED_CLOCK_MONOTONIC]
+ * Use the result value of times() defined by POSIX.
+ * POSIX defines it as "times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)".
+ * For example, GNU/Linux returns a value based on jiffies and it is monotonic.
+ * However, 4.4BSD uses gettimeofday() and it is not monotonic.
+ * (FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.)
+ * The resolution is the clock tick.
+ * "getconf CLK_TCK" command shows the clock ticks per second.
+ * (The clock ticks per second is defined by HZ macro in older systems.)
+ * If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and
+ * cannot represent over 497 days.
+ *
+ * Emulations for +CLOCK_PROCESS_CPUTIME_ID+:
+ * [:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID]
+ * Use getrusage() defined by SUS.
+ * getrusage() is used with RUSAGE_SELF to obtain the time only for
+ * the calling process (excluding the time for child processes).
+ * The result is addition of user time (ru_utime) and system time (ru_stime).
+ * The resolution is 1 microsecond.
+ * [:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID]
+ * Use times() defined by POSIX.
+ * The result is addition of user time (tms_utime) and system time (tms_stime).
+ * tms_cutime and tms_cstime are ignored to exclude the time for child processes.
+ * The resolution is the clock tick.
+ * "getconf CLK_TCK" command shows the clock ticks per second.
+ * (The clock ticks per second is defined by HZ macro in older systems.)
+ * If it is 100, the resolution is 10 millisecond.
+ * [:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID]
+ * Use clock() defined by ISO C.
+ * The resolution is 1/CLOCKS_PER_SEC.
+ * CLOCKS_PER_SEC is the C-level macro defined by time.h.
+ * SUS defines CLOCKS_PER_SEC is 1000000.
+ * Non-Unix systems may define it a different value, though.
+ * If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond.
+ * If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes.
+ *
+ * If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+ *
+ * +unit+ specifies a type of the return value.
+ *
+ * [:float_second] number of seconds as a float (default)
+ * [:float_millisecond] number of milliseconds as a float
+ * [:float_microsecond] number of microseconds as a float
+ * [:second] number of seconds as an integer
+ * [:millisecond] number of milliseconds as an integer
+ * [:microsecond] number of microseconds as an integer
+ * [:nanosecond] number of nanoseconds as an integer
+ *
+ * The underlying function, clock_gettime(), returns a number of nanoseconds.
+ * Float object (IEEE 754 double) is not enough to represent
+ * the return value for CLOCK_REALTIME.
+ * If the exact nanoseconds value is required, use +:nanoseconds+ as the +unit+.
+ *
+ * The origin (zero) of the returned value varies.
+ * For example, system start up time, process start up time, the Epoch, etc.
+ *
+ * The origin in CLOCK_REALTIME is defined as the Epoch
+ * (1970-01-01 00:00:00 UTC).
+ * But some systems count leap seconds and others doesn't.
+ * So the result can be interpreted differently across systems.
+ * Time.now is recommended over CLOCK_REALTIME.
+ */
+static VALUE
+rb_clock_gettime(int argc, VALUE *argv, VALUE _)
+{
+ int ret;
+
+ struct timetick tt;
+ timetick_int_t numerators[2];
+ timetick_int_t denominators[2];
+ int num_numerators = 0;
+ int num_denominators = 0;
+
+ 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.
+ */
+#ifdef HAVE_GETTIMEOFDAY
+ /*
+ * GETTIMEOFDAY_BASED_CLOCK_REALTIME is used for
+ * CLOCK_REALTIME if clock_gettime is not available.
+ */
+#define RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME ID2SYM(id_GETTIMEOFDAY_BASED_CLOCK_REALTIME)
+ if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) {
+ struct timeval tv;
+ ret = gettimeofday(&tv, 0);
+ if (ret != 0)
+ rb_sys_fail("gettimeofday");
+ tt.giga_count = tv.tv_sec;
+ tt.count = (int32_t)tv.tv_usec * 1000;
+ 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) {
+ time_t t;
+ t = time(NULL);
+ if (t == (time_t)-1)
+ rb_sys_fail("time");
+ tt.giga_count = t;
+ tt.count = 0;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+ }
+
+#ifdef HAVE_TIMES
+#define RUBY_TIMES_BASED_CLOCK_MONOTONIC \
+ ID2SYM(id_TIMES_BASED_CLOCK_MONOTONIC)
+ if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
+ struct tms buf;
+ clock_t c;
+ unsigned_clock_t uc;
+ c = times(&buf);
+ if (c == (clock_t)-1)
+ rb_sys_fail("times");
+ uc = (unsigned_clock_t)c;
+ tt.count = (int32_t)(uc % 1000000000);
+ tt.giga_count = (uc / 1000000000);
+ denominators[num_denominators++] = get_clk_tck();
+ goto success;
+ }
+#endif
+
+#ifdef RUSAGE_SELF
+#define RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID \
+ ID2SYM(id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID)
+ if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
+ struct rusage usage;
+ int32_t usec;
+ ret = getrusage(RUSAGE_SELF, &usage);
+ if (ret != 0)
+ rb_sys_fail("getrusage");
+ tt.giga_count = usage.ru_utime.tv_sec + usage.ru_stime.tv_sec;
+ usec = (int32_t)(usage.ru_utime.tv_usec + usage.ru_stime.tv_usec);
+ if (1000000 <= usec) {
+ tt.giga_count++;
+ usec -= 1000000;
+ }
+ tt.count = usec * 1000;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+ }
+#endif
+
+#ifdef HAVE_TIMES
+#define RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID \
+ ID2SYM(id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID)
+ if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
+ struct tms buf;
+ unsigned_clock_t utime, stime;
+ if (times(&buf) == (clock_t)-1)
+ rb_sys_fail("times");
+ utime = (unsigned_clock_t)buf.tms_utime;
+ stime = (unsigned_clock_t)buf.tms_stime;
+ tt.count = (int32_t)((utime % 1000000000) + (stime % 1000000000));
+ tt.giga_count = (utime / 1000000000) + (stime / 1000000000);
+ if (1000000000 <= tt.count) {
+ tt.count -= 1000000000;
+ tt.giga_count++;
+ }
+ denominators[num_denominators++] = get_clk_tck();
+ goto success;
+ }
+#endif
+
+#define RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID \
+ ID2SYM(id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID)
+ if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) {
+ clock_t c;
+ unsigned_clock_t uc;
+ errno = 0;
+ c = clock();
+ if (c == (clock_t)-1)
+ rb_sys_fail("clock");
+ uc = (unsigned_clock_t)c;
+ tt.count = (int32_t)(uc % 1000000000);
+ tt.giga_count = uc / 1000000000;
+ denominators[num_denominators++] = CLOCKS_PER_SEC;
+ goto success;
+ }
+
+#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) {
+ 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;
+ numerators[num_numerators++] = info->numer;
+ denominators[num_denominators++] = info->denom;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+ }
+#endif
+ }
+ else {
+#if defined(HAVE_CLOCK_GETTIME)
+ struct timespec ts;
+ clockid_t c;
+ c = NUM2CLOCKID(clk_id);
+ ret = clock_gettime(c, &ts);
+ if (ret == -1)
+ rb_sys_fail("clock_gettime");
+ tt.count = (int32_t)ts.tv_nsec;
+ tt.giga_count = ts.tv_sec;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+#endif
+ }
+ /* EINVAL emulates clock_gettime behavior when clock_id is invalid. */
+ rb_syserr_fail(EINVAL, 0);
+
+ success:
+ return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
+}
+
+/*
+ * call-seq:
+ * Process.clock_getres(clock_id [, unit]) -> number
+ *
+ * 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 for +Process.clock_gettime+.
+ *
+ * If the given +clock_id+ is not supported, Errno::EINVAL is raised.
+ *
+ * +unit+ specifies the type of the return value.
+ * +Process.clock_getres+ accepts +unit+ as +Process.clock_gettime+.
+ * The default value, +:float_second+, is also the same as
+ * +Process.clock_gettime+.
+ *
+ * +Process.clock_getres+ also accepts +:hertz+ as +unit+.
+ * +:hertz+ means the reciprocal of +:float_second+.
+ *
+ * +:hertz+ can be used to obtain the exact value of
+ * the clock ticks per second for the times() function and
+ * CLOCKS_PER_SEC for the clock() function.
+ *
+ * <code>Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)</code>
+ * returns the clock ticks per second.
+ *
+ * <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
+ *
+ */
+static VALUE
+rb_clock_getres(int argc, VALUE *argv, VALUE _)
+{
+ struct timetick tt;
+ timetick_int_t numerators[2];
+ timetick_int_t denominators[2];
+ int num_numerators = 0;
+ int num_denominators = 0;
+
+ 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
+ if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) {
+ tt.giga_count = 0;
+ tt.count = 1000;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+ }
+#endif
+
+#ifdef RUBY_TIME_BASED_CLOCK_REALTIME
+ if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) {
+ tt.giga_count = 1;
+ tt.count = 0;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+ }
+#endif
+
+#ifdef RUBY_TIMES_BASED_CLOCK_MONOTONIC
+ if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
+ tt.count = 1;
+ tt.giga_count = 0;
+ denominators[num_denominators++] = get_clk_tck();
+ goto success;
+ }
+#endif
+
+#ifdef RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID
+ if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
+ tt.giga_count = 0;
+ tt.count = 1000;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+ }
+#endif
+
+#ifdef RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID
+ if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
+ tt.count = 1;
+ tt.giga_count = 0;
+ denominators[num_denominators++] = get_clk_tck();
+ goto success;
+ }
+#endif
+
+#ifdef RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID
+ if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) {
+ tt.count = 1;
+ tt.giga_count = 0;
+ denominators[num_denominators++] = CLOCKS_PER_SEC;
+ goto success;
+ }
+#endif
+
+#ifdef RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC
+ if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
+ const mach_timebase_info_data_t *info = get_mach_timebase_info();
+ tt.count = 1;
+ tt.giga_count = 0;
+ numerators[num_numerators++] = info->numer;
+ denominators[num_denominators++] = info->denom;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+ }
+#endif
+ }
+ else {
+#if defined(HAVE_CLOCK_GETRES)
+ struct timespec ts;
+ clockid_t c = NUM2CLOCKID(clk_id);
+ int ret = clock_getres(c, &ts);
+ if (ret == -1)
+ rb_sys_fail("clock_getres");
+ tt.count = (int32_t)ts.tv_nsec;
+ tt.giga_count = ts.tv_sec;
+ denominators[num_denominators++] = 1000000000;
+ goto success;
+#endif
+ }
+ /* EINVAL emulates clock_getres behavior when clock_id is invalid. */
+ rb_syserr_fail(EINVAL, 0);
+
+ success:
+ if (unit == ID2SYM(id_hertz)) {
+ return timetick2dblnum_reciprocal(&tt, numerators, num_numerators, denominators, num_denominators);
+ }
+ else {
+ return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
+ }
+}
+
+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
-Init_process(void)
+InitVM_process(void)
{
- 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");
@@ -6565,23 +8720,36 @@ Init_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);
@@ -6590,7 +8758,7 @@ Init_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);
@@ -6601,14 +8769,15 @@ Init_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);
rb_define_module_function(rb_mProcess, "getpgid", proc_getpgid, 1);
rb_define_module_function(rb_mProcess, "setpgid", proc_setpgid, 2);
+ rb_define_module_function(rb_mProcess, "getsid", proc_getsid, -1);
rb_define_module_function(rb_mProcess, "setsid", proc_setsid, 0);
rb_define_module_function(rb_mProcess, "getpriority", proc_getpriority, 2);
@@ -6780,8 +8949,117 @@ Init_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)
- rb_cProcessTms = rb_struct_define("Tms", "utime", "stime", "cutime", "cstime", NULL);
+ /* Placeholder for rusage */
+ rb_cProcessTms = rb_struct_define_under(rb_mProcess, "Tms", "utime", "stime", "cutime", "cstime", NULL);
#endif
SAVED_USER_ID = geteuid();
@@ -6838,3 +9116,49 @@ Init_process(void)
rb_define_module_function(rb_mProcID_Syscall, "setresgid", p_sys_setresgid, 3);
rb_define_module_function(rb_mProcID_Syscall, "issetugid", p_sys_issetugid, 0);
}
+
+void
+Init_process(void)
+{
+ 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_const("pgroup");
+#endif
+#ifdef _WIN32
+ 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_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_const("GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID");
+#endif
+ 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_const("MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC");
+#endif
+ id_hertz = rb_intern_const("hertz");
+
+ InitVM(process);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 19:43:05 +0000