proc-wait3 1.9.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6e56b25dc085ce18c5808a81d259c4e9f54cb75d1ff985985bb5a575d58ed90
-  data.tar.gz: 65379d28529797369401cc65abb6c234b9cf1995ec7cf92152d03c03c6a89a83
+  metadata.gz: bba2d43b0af474f64ee8879055afc649a62afed46269bafc2bea754eb2ab770b
+  data.tar.gz: 0b5e3a6ebc48e370c32273db28e107c068a70e08f367031011bb0c1d1c2065a8
 SHA512:
-  metadata.gz: 51f2d1148e8fcadb8b9530420ac164e81b4645b04e3f7b8acded43a62acaa3000240f5e5e53b5fda4cc734f0e2f76edbf76d5b325c2cc3fefd450cf0f60ca519
-  data.tar.gz: ce1e71899e8db9c2c74bb5207d3a715e7cf8b355d0c5b6bc203b51608647d90fe53c0414bce48ee38c1c796987df7f9fa2b4a30c9eeebdd35900e34d288be82a
+  metadata.gz: e31e23649b03fcff7e274634536c6c5924ff9e0cecb52141c34a694c71a3817a00dded441394b9dbd3f7266818c4ec2ca41a41e7b347b63cdad148ab43a7a28b
+  data.tar.gz: 86d669dfe0d6e0dcbe3b136c4b857a52039c53f61de0b0a3cbed9f36bc274ce9c6487136c3e52f112e2f8cd2c2414acae64f239426a69e84a3d976047021e1d2

data/CHANGES.md

@@ -1,3 +1,19 @@
+## 2.0.0 - 10-Jan-2026
+* Added fiber scheduler support for wait3 and wait4 methods, allowing them
+  to cooperate with Ruby's fiber scheduler for non-blocking async operations.
+  Note that rusage fields will be zero when using the fiber scheduler path.
+* Added `rb_thread_call_without_gvl` for blocking calls so that other Ruby
+  threads can run while waiting.
+* Added `RB_GC_GUARD` to protect Ruby objects during blocking operations.
+* Replaced deprecated `RSTRING()->len` and `RSTRING()->ptr` with `RSTRING_LEN()`
+  and `RSTRING_PTR()` macros.
+* Added missing `HAVE_STRLCPY` guard in sigsend with strncpy fallback.
+* Fixed some minor whitespace inconsistencies.
+* Now requires Ruby 3.1 or later.
+
+## 1.9.3 - 4-May-2024
+* Some internal refactoring where I bzero C structs before using them.
+
 ## 1.9.2 - 21-Apr-2024
 * Added the P_JAILID constant for BSD platforms.
 * Added some notes to the README for coping with EINTR.
@@ -154,7 +170,7 @@
 * Updated tests and documentation.
 
 ## 1.2.0 - 7-Feb-2005
-* Added the Proc.waitid method (for those platforms that support it). 
+* Added the Proc.waitid method (for those platforms that support it).
 * Made the wait3.c file more rdoc friendly.
 * Added a test_waitid.rb file in the examples directory.
 

data/Rakefile

@@ -7,17 +7,17 @@ require 'rbconfig'
 include RbConfig
 
 CLEAN.include(
-  '**/*.gem',                # Gem files
-  '**/*.rbc',                # Rubinius
-  '**/*.o',                  # C object file
-  '**/*.log',                # Ruby extension build log
-  '**/Makefile',             # C Makefile
-  '**/conftest.dSYM',        # OS X build directory
-  "**/*.#{CONFIG['DLEXT']}", # C shared object
-  '**/*.lock'                # Bundler
+  '**/*.gem',                 # Gem files
+  '**/*.rbc',                 # Rubinius
+  '**/*.o',                   # C object file
+  '**/*.log',                 # Ruby extension build log
+  '**/*.lock',                # Gemfile.lock
+  '**/Makefile',              # C Makefile
+  '**/*.dSYM',                # OS X build directory
+  "**/*.#{CONFIG['DLEXT']}",  # C shared object
+  '**/*.lock'                 # Bundler
 )
 
-
 desc "Build the source (but don't install it)"
 task :build => [:clean] do |t|
   Dir.chdir('ext') do
@@ -72,7 +72,12 @@ end
 
 desc 'Run the test suite'
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = '-Iext'
+  t.rspec_opts = '-Iext -f documentation -w'
+end
+
+# Clean up afterwards
+Rake::Task[:spec].enhance do
+  Rake::Task[:clean].invoke
 end
 
 task :default => [:build, :spec]

data/doc/wait3.md

@@ -80,6 +80,13 @@ Returns a `Proc::SigInfo` struct and sets `$?`.
 
 Not supported on all platforms.
 
+### `Proc.getdtablesize`
+
+Returns the current soft limit of the maximum file descriptor number.
+
+This is effectively the same as calling Process.getrlimit with RLIMIT_NOFILE
+as the resource identifier.
+
 ## Standard Constants
 `Process::WAIT3_VERSION`
 

data/examples/example_waitid.rb

@@ -8,10 +8,20 @@
 #
 # Modify as you see fit.
 #######################################################################
-require 'English'
 require 'proc/wait3'
 
-pid = fork { sleep 2 }
+pid1 = fork { puts "PID1 GRP: #{Process.getpgrp}"; sleep 2 }
+pid2 = fork { puts "PID2 GRP: #{Process.getpgrp}"; sleep 3 }
+pid3 = fork { puts "PID2 GRP: #{Process.getpgrp}"; sleep 4 }
+
+puts "PID1: #{pid1}"
+puts "PID2: #{pid2}"
+puts "PID3: #{pid3}"
+
+puts "MAIN GRP: #{Process.getpgrp}"
 p Time.now
-Process.waitid(Process::P_PID, pid, Process::WEXITED)
-p $CHILD_STATUS
+
+status = Process.waitid(Process::P_PGID, Process.getpgrp, Process::WEXITED)
+
+# status.pid should equal pid1 since it exits first
+p status

data/ext/proc/wait3.c

@@ -1,4 +1,6 @@
 #include <ruby.h>
+#include <ruby/thread.h>
+#include <ruby/fiber/scheduler.h>
 #include <string.h>
 #include <unistd.h>
 
@@ -31,6 +33,67 @@ VALUE v_procstat_struct, v_siginfo_struct, v_usage_struct;
 
 static void sigproc(int signum, siginfo_t* info, void* ucontext);
 
+/* Structs for rb_thread_call_without_gvl wrappers */
+struct wait3_args {
+   int status;
+   int flags;
+   struct rusage rusage;
+   pid_t pid;
+};
+
+#ifdef HAVE_WAIT4
+struct wait4_args {
+   pid_t pid;
+   int status;
+   int flags;
+   struct rusage rusage;
+   pid_t result;
+};
+#endif
+
+#ifdef HAVE_WAITID
+struct waitid_args {
+   idtype_t idtype;
+   id_t id;
+   siginfo_t infop;
+   int options;
+   int result;
+};
+#endif
+
+struct pause_args {
+   int result;
+};
+
+/* GVL-free wrapper functions */
+static void* wait3_without_gvl(void* data) {
+   struct wait3_args* args = (struct wait3_args*)data;
+   args->pid = wait3(&args->status, args->flags, &args->rusage);
+   return NULL;
+}
+
+#ifdef HAVE_WAIT4
+static void* wait4_without_gvl(void* data) {
+   struct wait4_args* args = (struct wait4_args*)data;
+   args->result = wait4(args->pid, &args->status, args->flags, &args->rusage);
+   return NULL;
+}
+#endif
+
+#ifdef HAVE_WAITID
+static void* waitid_without_gvl(void* data) {
+   struct waitid_args* args = (struct waitid_args*)data;
+   args->result = waitid(args->idtype, args->id, &args->infop, args->options);
+   return NULL;
+}
+#endif
+
+static void* pause_without_gvl(void* data) {
+   struct pause_args* args = (struct pause_args*)data;
+   args->result = pause();
+   return NULL;
+}
+
 /*
  * Returns true if this process is stopped. This is only returned
  * returned if the corresponding wait() call had the WUNTRACED flag
@@ -38,10 +101,10 @@ static void sigproc(int signum, siginfo_t* info, void* ucontext);
  */
 static VALUE pst_wifstopped(int status)
 {
-   if(WIFSTOPPED(status))
-      return Qtrue;
-   else
-      return Qfalse;
+  if(WIFSTOPPED(status))
+    return Qtrue;
+  else
+    return Qfalse;
 }
 
 /*
@@ -50,7 +113,7 @@ static VALUE pst_wifstopped(int status)
 static VALUE pst_wifsignaled(int status)
 {
   if (WIFSIGNALED(status))
-	  return Qtrue;
+    return Qtrue;
   else
     return Qfalse;
 }
@@ -131,6 +194,42 @@ static VALUE pst_wstopsig(int status)
   return Qnil;
 }
 
+/*
+ * Helper to build ProcStat struct from pid and status.
+ * Used by fiber scheduler path where rusage is not available.
+ * All rusage fields are set to 0.
+ */
+static VALUE build_procstat_without_rusage(pid_t pid, int status) {
+   return rb_struct_new(v_procstat_struct,
+      INT2FIX(pid),
+      INT2FIX(status),
+      rb_float_new(0.0),  /* utime - not available via fiber scheduler */
+      rb_float_new(0.0),  /* stime - not available via fiber scheduler */
+      LONG2NUM(0),        /* maxrss */
+      LONG2NUM(0),        /* ixrss */
+      LONG2NUM(0),        /* idrss */
+      LONG2NUM(0),        /* isrss */
+      LONG2NUM(0),        /* minflt */
+      LONG2NUM(0),        /* majflt */
+      LONG2NUM(0),        /* nswap */
+      LONG2NUM(0),        /* inblock */
+      LONG2NUM(0),        /* oublock */
+      LONG2NUM(0),        /* msgsnd */
+      LONG2NUM(0),        /* msgrcv */
+      LONG2NUM(0),        /* nsignals */
+      LONG2NUM(0),        /* nvcsw */
+      LONG2NUM(0),        /* nivcsw */
+      pst_wifstopped(status),
+      pst_wifsignaled(status),
+      pst_wifexited(status),
+      pst_success_p(status),
+      pst_wcoredump(status),
+      pst_wexitstatus(status),
+      pst_wtermsig(status),
+      pst_wstopsig(status)
+   );
+}
+
 /*
  * call-seq:
  *    Process.wait3(flags=nil)
@@ -140,13 +239,15 @@ static VALUE pst_wstopsig(int status)
  *
  * The return value is a ProcStat structure. The special global $? is also
  * set. Raises a SystemError if there are no child processes.
+ *
+ * Note: When a fiber scheduler is active (Ruby 3.0+), this method will
+ * cooperate with the scheduler. However, rusage information will not be
+ * available and those fields will be set to 0 in the returned struct.
  */
 static VALUE proc_wait3(int argc, VALUE *argv, VALUE mod){
-   int status;
-   int flags = 0;
-   struct rusage r;
-   pid_t pid;
+   struct wait3_args args;
    VALUE v_flags = Qnil;
+   int flags = 0;
 
    rb_scan_args(argc,argv,"01",&v_flags);
 
@@ -154,42 +255,68 @@ static VALUE proc_wait3(int argc, VALUE *argv, VALUE mod){
       flags = NUM2INT(v_flags);
    }
 
-   pid = wait3(&status, flags, &r);
+   VALUE scheduler = rb_fiber_scheduler_current();
+   if (!NIL_P(scheduler)) {
+      /* Use fiber scheduler - wait for any child (pid = -1) */
+      VALUE result = rb_fiber_scheduler_process_wait(scheduler, (rb_pid_t)-1, flags);
+
+      if (NIL_P(result)) {
+         return Qnil;
+      }
+
+      /* Extract pid and status from Process::Status object */
+      pid_t pid = NUM2PIDT(rb_funcall(result, rb_intern("pid"), 0));
+      int status = NUM2INT(rb_funcall(result, rb_intern("to_i"), 0));
+
+      RB_GC_GUARD(result);
+
+      v_last_status = build_procstat_without_rusage(pid, status);
+      rb_last_status_set(status, pid);
+      OBJ_FREEZE(v_last_status);
+
+      return v_last_status;
+   }
+
+   /* No fiber scheduler - use thread-based blocking */
+   bzero(&args, sizeof(args));
+   args.flags = flags;
+
+   rb_thread_call_without_gvl(wait3_without_gvl, &args, RUBY_UBF_PROCESS, NULL);
 
-   if(pid < 0){
+   if(args.pid < 0){
       rb_sys_fail("wait3");
    }
-   else if(pid > 0){
+   else if(args.pid > 0){
       v_last_status = rb_struct_new(v_procstat_struct,
-         INT2FIX(pid),
-         INT2FIX(status),
-         rb_float_new((double)r.ru_utime.tv_sec+(double)r.ru_utime.tv_usec/1e6),
-         rb_float_new((double)r.ru_stime.tv_sec+(double)r.ru_stime.tv_usec/1e6),
-         LONG2NUM(r.ru_maxrss),
-         LONG2NUM(r.ru_ixrss),
-         LONG2NUM(r.ru_idrss),
-         LONG2NUM(r.ru_isrss),
-         LONG2NUM(r.ru_minflt),
-         LONG2NUM(r.ru_majflt),
-         LONG2NUM(r.ru_nswap),
-         LONG2NUM(r.ru_inblock),
-         LONG2NUM(r.ru_oublock),
-         LONG2NUM(r.ru_msgsnd),
-         LONG2NUM(r.ru_msgrcv),
-         LONG2NUM(r.ru_nsignals),
-         LONG2NUM(r.ru_nvcsw),
-         LONG2NUM(r.ru_nivcsw),
-         pst_wifstopped(status),
-         pst_wifsignaled(status),
-         pst_wifexited(status),
-         pst_success_p(status),
-         pst_wcoredump(status),
-         pst_wexitstatus(status),
-         pst_wtermsig(status),
-         pst_wstopsig(status)
+         INT2FIX(args.pid),
+         INT2FIX(args.status),
+         rb_float_new((double)args.rusage.ru_utime.tv_sec+(double)args.rusage.ru_utime.tv_usec/1e6),
+         rb_float_new((double)args.rusage.ru_stime.tv_sec+(double)args.rusage.ru_stime.tv_usec/1e6),
+         LONG2NUM(args.rusage.ru_maxrss),
+         LONG2NUM(args.rusage.ru_ixrss),
+         LONG2NUM(args.rusage.ru_idrss),
+         LONG2NUM(args.rusage.ru_isrss),
+         LONG2NUM(args.rusage.ru_minflt),
+         LONG2NUM(args.rusage.ru_majflt),
+         LONG2NUM(args.rusage.ru_nswap),
+         LONG2NUM(args.rusage.ru_inblock),
+         LONG2NUM(args.rusage.ru_oublock),
+         LONG2NUM(args.rusage.ru_msgsnd),
+         LONG2NUM(args.rusage.ru_msgrcv),
+         LONG2NUM(args.rusage.ru_nsignals),
+         LONG2NUM(args.rusage.ru_nvcsw),
+         LONG2NUM(args.rusage.ru_nivcsw),
+         pst_wifstopped(args.status),
+         pst_wifsignaled(args.status),
+         pst_wifexited(args.status),
+         pst_success_p(args.status),
+         pst_wcoredump(args.status),
+         pst_wexitstatus(args.status),
+         pst_wtermsig(args.status),
+         pst_wstopsig(args.status)
       );
 
-      rb_last_status_set(status, pid);
+      rb_last_status_set(args.status, args.pid);
       OBJ_FREEZE(v_last_status);
 
       return v_last_status;
@@ -210,58 +337,88 @@ static VALUE proc_wait3(int argc, VALUE *argv, VALUE mod){
  * This method is not supported on all platforms.
  *
  * Some +flags+ are not supported on all platforms.
+ *
+ * Note: When a fiber scheduler is active (Ruby 3.0+), this method will
+ * cooperate with the scheduler. However, rusage information will not be
+ * available and those fields will be set to 0 in the returned struct.
  */
 static VALUE proc_wait4(int argc, VALUE *argv, VALUE mod){
-   int status;
-   int flags = 0;
-   struct rusage r;
-   pid_t pid;
+   struct wait4_args args;
    VALUE v_pid;
    VALUE v_flags = Qnil;
+   pid_t pid;
+   int flags = 0;
 
    rb_scan_args(argc, argv, "11", &v_pid, &v_flags);
 
-   pid = NUM2INT(v_pid);
+   pid = NUM2PIDT(v_pid);
 
    if(RTEST(v_flags))
       flags = NUM2INT(v_flags);
 
-   pid = wait4(pid, &status, flags, &r);
+   VALUE scheduler = rb_fiber_scheduler_current();
+   if (!NIL_P(scheduler)) {
+      /* Use fiber scheduler */
+      VALUE result = rb_fiber_scheduler_process_wait(scheduler, pid, flags);
+
+      if (NIL_P(result)) {
+         return Qnil;
+      }
+
+      /* Extract pid and status from Process::Status object */
+      pid_t rpid = NUM2PIDT(rb_funcall(result, rb_intern("pid"), 0));
+      int status = NUM2INT(rb_funcall(result, rb_intern("to_i"), 0));
 
-   if(pid < 0){
+      RB_GC_GUARD(result);
+
+      v_last_status = build_procstat_without_rusage(rpid, status);
+      rb_last_status_set(status, rpid);
+      OBJ_FREEZE(v_last_status);
+
+      return v_last_status;
+   }
+
+   /* No fiber scheduler - use thread-based blocking */
+   bzero(&args, sizeof(args));
+   args.pid = pid;
+   args.flags = flags;
+
+   rb_thread_call_without_gvl(wait4_without_gvl, &args, RUBY_UBF_PROCESS, NULL);
+
+   if(args.result < 0){
       rb_sys_fail("wait4");
    }
-   else if(pid > 0){
+   else if(args.result > 0){
       v_last_status = rb_struct_new(v_procstat_struct,
-         INT2FIX(pid),
-         INT2FIX(status),
-         rb_float_new((double)r.ru_utime.tv_sec+(double)r.ru_utime.tv_usec/1e6),
-         rb_float_new((double)r.ru_stime.tv_sec+(double)r.ru_stime.tv_usec/1e6),
-         LONG2NUM(r.ru_maxrss),
-         LONG2NUM(r.ru_ixrss),
-         LONG2NUM(r.ru_idrss),
-         LONG2NUM(r.ru_isrss),
-         LONG2NUM(r.ru_minflt),
-         LONG2NUM(r.ru_majflt),
-         LONG2NUM(r.ru_nswap),
-         LONG2NUM(r.ru_inblock),
-         LONG2NUM(r.ru_oublock),
-         LONG2NUM(r.ru_msgsnd),
-         LONG2NUM(r.ru_msgrcv),
-         LONG2NUM(r.ru_nsignals),
-         LONG2NUM(r.ru_nvcsw),
-         LONG2NUM(r.ru_nivcsw),
-         pst_wifstopped(status),
-         pst_wifsignaled(status),
-         pst_wifexited(status),
-         pst_success_p(status),
-         pst_wcoredump(status),
-         pst_wexitstatus(status),
-         pst_wtermsig(status),
-         pst_wstopsig(status)
+         INT2FIX(args.result),
+         INT2FIX(args.status),
+         rb_float_new((double)args.rusage.ru_utime.tv_sec+(double)args.rusage.ru_utime.tv_usec/1e6),
+         rb_float_new((double)args.rusage.ru_stime.tv_sec+(double)args.rusage.ru_stime.tv_usec/1e6),
+         LONG2NUM(args.rusage.ru_maxrss),
+         LONG2NUM(args.rusage.ru_ixrss),
+         LONG2NUM(args.rusage.ru_idrss),
+         LONG2NUM(args.rusage.ru_isrss),
+         LONG2NUM(args.rusage.ru_minflt),
+         LONG2NUM(args.rusage.ru_majflt),
+         LONG2NUM(args.rusage.ru_nswap),
+         LONG2NUM(args.rusage.ru_inblock),
+         LONG2NUM(args.rusage.ru_oublock),
+         LONG2NUM(args.rusage.ru_msgsnd),
+         LONG2NUM(args.rusage.ru_msgrcv),
+         LONG2NUM(args.rusage.ru_nsignals),
+         LONG2NUM(args.rusage.ru_nvcsw),
+         LONG2NUM(args.rusage.ru_nivcsw),
+         pst_wifstopped(args.status),
+         pst_wifsignaled(args.status),
+         pst_wifexited(args.status),
+         pst_success_p(args.status),
+         pst_wcoredump(args.status),
+         pst_wexitstatus(args.status),
+         pst_wtermsig(args.status),
+         pst_wstopsig(args.status)
       );
 
-      rb_last_status_set(status, pid);
+      rb_last_status_set(args.status, args.result);
       OBJ_FREEZE(v_last_status);
 
       return v_last_status;
@@ -312,20 +469,18 @@ static VALUE proc_wait4(int argc, VALUE *argv, VALUE mod){
  */
 static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
    VALUE v_type, v_id, v_options;
-   siginfo_t infop;
-   idtype_t idtype;
-   id_t id = 0;
-   int options = 0;
+   struct waitid_args args;
 
    rb_scan_args(argc, argv, "12", &v_type, &v_id, &v_options);
 
-   idtype = NUM2INT(v_type);
+   bzero(&args, sizeof(args));
+   args.idtype = NUM2INT(v_type);
 
    if(RTEST(v_id))
-      id = NUM2INT(v_id);
+      args.id = NUM2INT(v_id);
 
    if(RTEST(v_options))
-      options = NUM2INT(v_options);
+      args.options = NUM2INT(v_options);
 
    /* The Linux man page for waitid() says to zero out the pid field and check
     * its value after the call to waitid() to detect if there were children in
@@ -333,10 +488,12 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
     * simply check the infop.si_signo struct member against SI_NOINFO.
     */
 #ifndef SI_NOINFO
-   infop.si_pid = 0;
+   args.infop.si_pid = 0;
 #endif
 
-   if(waitid(idtype, id, &infop, options) == -1)
+   rb_thread_call_without_gvl(waitid_without_gvl, &args, RUBY_UBF_PROCESS, NULL);
+
+   if(args.result == -1)
       rb_sys_fail("waitid");
 
     /* If the si_code struct member returns SI_NOINFO, or the si_pid member
@@ -350,13 +507,13 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
      */
 
 #ifdef SI_NOINFO
-   if(infop.si_code == SI_NOINFO){
+   if(args.infop.si_code == SI_NOINFO){
 #else
-   if(infop.si_pid == 0){
+   if(args.infop.si_pid == 0){
 #endif
       v_last_status = rb_struct_new(v_siginfo_struct,
-         INT2FIX(infop.si_signo),
-         INT2FIX(infop.si_errno),
+         INT2FIX(args.infop.si_signo),
+         INT2FIX(args.infop.si_errno),
          Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, /* code, pid, uid, utime, status, stime */
 #ifdef HAVE_ST_SI_TRAPNO
          Qnil,
@@ -422,8 +579,8 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
       VALUE v_state = Qnil;
 #endif
       VALUE v_band = Qnil, v_entity = Qnil;
-      int sig = infop.si_signo;
-      int code = infop.si_code;
+      int sig = args.infop.si_signo;
+      int code = args.infop.si_code;
 
 #if defined(HAVE_ST_SI_SYSARG) || defined(HAVE_ST_SI_MSTATE)
       int i = 0;
@@ -435,13 +592,13 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
        */
       if(sig == SIGCHLD){
 #ifdef HAVE_ST_SI_UTIME
-         v_utime  = ULL2NUM(infop.si_utime);
+         v_utime  = ULL2NUM(args.infop.si_utime);
 #endif
 #ifdef HAVE_ST_SI_STATUS
-         v_status = ULL2NUM(infop.si_status);
+         v_status = ULL2NUM(args.infop.si_status);
 #endif
 #ifdef HAVE_ST_SI_STIME
-         v_stime  = ULL2NUM(infop.si_stime);
+         v_stime  = ULL2NUM(args.infop.si_stime);
 #endif
       }
 
@@ -449,66 +606,66 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
          sig == SIGTRAP)
       {
 #ifdef HAVE_ST_SI_TRAPNO
-         v_trapno = INT2FIX(infop.si_trapno);
+         v_trapno = INT2FIX(args.infop.si_trapno);
 #endif
 #ifdef HAVE_ST_SI_PC
-         v_pc = INT2FIX(infop.si_pc);
+         v_pc = INT2FIX(args.infop.si_pc);
 #endif
       }
 
       if(sig == SIGXFSZ){
 #ifdef HAVE_ST_SI_FD
-         v_fd = INT2FIX(infop.si_fd);
+         v_fd = INT2FIX(args.infop.si_fd);
 #endif
          if(code == POLL_IN || code == POLL_OUT || code == POLL_MSG){
-            v_band = LONG2FIX(infop.si_band);
+            v_band = LONG2FIX(args.infop.si_band);
          }
       }
 
       if(sig == SIGPROF){
 #ifdef HAVE_ST_SI_SYSARG
-         int ssize = sizeof(infop.si_sysarg) / sizeof(infop.si_sysarg[0]);
+         int ssize = sizeof(args.infop.si_sysarg) / sizeof(args.infop.si_sysarg[0]);
          v_sysarg  = rb_ary_new();
 
          for(i = 0; i < ssize; i++)
-            rb_ary_push(v_sysarg, LONG2FIX(infop.si_sysarg[i]));
+            rb_ary_push(v_sysarg, LONG2FIX(args.infop.si_sysarg[i]));
 #endif
 #ifdef HAVE_ST_SI_MSTATE
-         int msize = sizeof(infop.si_mstate) / sizeof(infop.si_mstate[0]);
+         int msize = sizeof(args.infop.si_mstate) / sizeof(args.infop.si_mstate[0]);
          v_state  = rb_ary_new();
 
          for(i = 0; i < msize; i++)
-            rb_ary_push(v_state, INT2FIX(infop.si_mstate[i]));
+            rb_ary_push(v_state, INT2FIX(args.infop.si_mstate[i]));
 #endif
 #ifdef HAVE_ST_SI_FADDR
-         v_addr   = INT2FIX(infop.si_faddr);
+         v_addr   = INT2FIX(args.infop.si_faddr);
 #endif
 #ifdef HAVE_ST_SI_SYSCALL
-         v_syscall = INT2FIX(infop.si_syscall);
+         v_syscall = INT2FIX(args.infop.si_syscall);
 #endif
 #ifdef HAVE_ST_SI_NSYSARG
-         v_nsysarg = INT2FIX(infop.si_nsysarg);
+         v_nsysarg = INT2FIX(args.infop.si_nsysarg);
 #endif
 #ifdef HAVE_ST_SI_FAULT
-         v_fault   = INT2FIX(infop.si_fault);
+         v_fault   = INT2FIX(args.infop.si_fault);
 #endif
 #ifdef HAVE_ST_SI_TSTAMP
-         v_time = rb_time_new(infop.si_tstamp.tv_sec,infop.si_tstamp.tv_nsec);
+         v_time = rb_time_new(args.infop.si_tstamp.tv_sec,args.infop.si_tstamp.tv_nsec);
 #endif
       }
 
 #ifdef SIGXRES
       if(sig == SIGXRES){
-         v_entity = INT2FIX(infop.si_entity);
+         v_entity = INT2FIX(args.infop.si_entity);
       }
 #endif
 
       v_last_status = rb_struct_new(v_siginfo_struct,
-         INT2FIX(infop.si_signo),   // Probably SIGCHLD
-         INT2FIX(infop.si_errno),   // 0 means no error
-         INT2FIX(infop.si_code),    // Should be anything but SI_NOINFO
-         INT2FIX(infop.si_pid),     // Real PID that sent the signal
-         INT2FIX(infop.si_uid),     // Real UID of process that sent signal
+         INT2FIX(args.infop.si_signo),   // Probably SIGCHLD
+         INT2FIX(args.infop.si_errno),   // 0 means no error
+         INT2FIX(args.infop.si_code),    // Should be anything but SI_NOINFO
+         INT2FIX(args.infop.si_pid),     // Real PID that sent the signal
+         INT2FIX(args.infop.si_uid),     // Real UID of process that sent signal
          v_utime,
          v_status,
          v_stime,
@@ -564,7 +721,7 @@ static VALUE proc_waitid(int argc, VALUE* argv, VALUE mod){
  * be sure to leave off the leading 'SIG' substring, e.g. use 'INT' instead
  * of 'SIGINT'.
  *
- * Note that not all platforms (notably Linux) do not support automatically
+ * Note that not all platforms (notably Linux) support automatically
  * converting strings to their corresponding signal values, so it is
  * recommended that you always use an array of numeric values.
  *
@@ -587,6 +744,9 @@ static VALUE proc_pause(int argc, VALUE* argv, VALUE mod){
       int signum;
       struct sigaction act, sa;
 
+      bzero(&act, sizeof(act));
+      bzero(&sa, sizeof(sa));
+
       for(i = 0; i < len; i++){
          v_val = rb_ary_shift(v_signals);
 
@@ -595,10 +755,12 @@ static VALUE proc_pause(int argc, VALUE* argv, VALUE mod){
             if(strlcpy(signame, StringValuePtr(v_val), max) >= max)
                rb_raise(rb_eArgError, "string too large");
 #else
-            if(RSTRING(v_val)->len > max)
+            if(RSTRING_LEN(v_val) >= max)
                rb_raise(rb_eArgError, "string too large");
-            else
-               strncpy(signame, RSTRING(v_val)->ptr, max);
+            else{
+               strncpy(signame, RSTRING_PTR(v_val), max);
+               signame[max-1] = '\0';
+            }
 #endif
 
 #ifdef HAVE_STR2SIG
@@ -614,17 +776,22 @@ static VALUE proc_pause(int argc, VALUE* argv, VALUE mod){
             signum = NUM2INT(v_val);
          }
 
-         memset(&act, 0, sizeof(act));
+         bzero(&act, sizeof(act));
          act.sa_flags = SA_SIGINFO;
          act.sa_sigaction = sigproc;
          res = sigaction(signum, &act, &sa);
 
          if(res)
-          rb_sys_fail("sigaction");
+            rb_sys_fail("sigaction");
       }
    }
 
-   return INT2FIX(pause()); /* Should always be -1 */
+   {
+      struct pause_args pargs;
+      rb_thread_call_without_gvl(pause_without_gvl, &pargs, RUBY_UBF_PROCESS, NULL);
+      RB_GC_GUARD(v_signals);
+      return INT2FIX(pargs.result); /* Should always be -1 */
+   }
 }
 
 /*
@@ -691,8 +858,17 @@ static VALUE proc_sigsend(int argc, VALUE* argv, VALUE mod){
       char signame[SIG2STR_MAX];
       unsigned int max = SIG2STR_MAX;
 
+#ifdef HAVE_STRLCPY
       if(strlcpy(signame, StringValuePtr(v_signal), max) >= max)
         rb_raise(rb_eArgError, "string too large");
+#else
+      if(RSTRING_LEN(v_signal) >= max)
+        rb_raise(rb_eArgError, "string too large");
+      else{
+        strncpy(signame, RSTRING_PTR(v_signal), max);
+        signame[max-1] = '\0';
+      }
+#endif
 
       if(str2sig(signame,&sig) != 0)
         rb_sys_fail("str2sig");
@@ -752,6 +928,8 @@ static VALUE proc_getrusage(int argc, VALUE* argv, VALUE mod){
   else if(RTEST(v_children))
     who = RUSAGE_CHILDREN;
 
+  bzero(&r, sizeof(r));
+
   if(getrusage(who,&r) == -1)
     rb_sys_fail("getrusage");
 
@@ -966,8 +1144,8 @@ void Init_wait3(void)
   rb_define_const(rb_mProcess, "RUSAGE_THREAD", INT2FIX(RUSAGE_THREAD));
 #endif
 
-  /* 1.9.2: The version of the proc-wait3 library */
-  rb_define_const(rb_mProcess, "WAIT3_VERSION", rb_str_freeze(rb_str_new2("1.9.2")));
+  /* 2.0.0: The version of the proc-wait3 library */
+  rb_define_const(rb_mProcess, "WAIT3_VERSION", rb_str_freeze(rb_str_new2("2.0.0")));
 
   /* Define this last in our Init_wait3 function */
   rb_define_readonly_variable("$last_status", &v_last_status);

data/proc-wait3.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'proc-wait3'
-  spec.version    = '1.9.2'
+  spec.version    = '2.0.0'
   spec.author     = 'Daniel J. Berger'
   spec.license    = 'Apache-2.0'
   spec.email      = 'djberg96@gmail.com'
@@ -26,7 +26,8 @@ Gem::Specification.new do |spec|
     'source_code_uri'       => 'https://github.com/djberg96/proc-wait3',
     'wiki_uri'              => 'https://github.com/djberg96/proc-wait3/wiki',
     'rubygems_mfa_required' => 'true',
-    'github_repo'           => 'https://github.com/djberg96/proc-wait3'
+    'github_repo'           => 'https://github.com/djberg96/proc-wait3',
+    'funding_uri'           => 'https://github.com/sponsors/djberg96'
   }
 
   spec.description = <<-EOF

data/spec/proc_wait3_spec.rb

@@ -1,26 +1,21 @@
 # frozen_string_literal: true
 
-#######################################################################
+##############################################################################
 # proc_wait3_spec.rb
 #
-# Test suite for the Ruby proc-wait3 library. You should run these
-# via the 'rake spec' task.
-#######################################################################
+# Test suite for the Ruby proc-wait3 library. You should run these via the
+# 'rake spec' task.
+#
+# Note that several specs are deliberately wrapped in EINTR rescue handlers
+# because I think the Ruby interpreter is sending a signal to the process
+# from somewhere in the guts of its core code. Originally I thought this was
+# a SIGCHLD but it doesn't always appear to be.
+##############################################################################
 require 'English'
-require 'proc/wait3'
-require 'rspec'
+require 'spec_helper'
 require 'rbconfig'
 
 RSpec.describe Process do
-  # Something in the guts of Ruby was being a pain.
-  Signal.trap('CHLD', 'IGNORE') if RUBY_VERSION.to_f < 3
-
-  let(:solaris) { RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i }
-  let(:darwin)  { RbConfig::CONFIG['host_os'] =~ /darwin|osx/i }
-  let(:hpux)    { RbConfig::CONFIG['host_os'] =~ /hpux/i }
-  let(:linux)   { RbConfig::CONFIG['host_os'] =~ /linux/i }
-  let(:bsd)     { RbConfig::CONFIG['host_os'] =~ /bsd|dragonfly/i }
-
   let(:proc_stat_members) {
     %i[
       pid status utime stime maxrss ixrss idrss isrss minflt majflt nswap
@@ -34,8 +29,26 @@ RSpec.describe Process do
     @pid = nil
   end
 
+  def call_wait3
+    described_class.wait3
+  rescue Errno::EINTR
+    retry
+  end
+
+  def call_wait4(*args)
+    described_class.wait4(*args)
+  rescue Errno::EINTR
+    retry
+  end
+
+  def call_waitid(*args)
+    described_class.waitid(*args)
+  rescue Errno::EINTR
+    retry
+  end
+
   example 'version constant is set to expected value' do
-    expect(Process::WAIT3_VERSION).to eq('1.9.2')
+    expect(Process::WAIT3_VERSION).to eq('2.0.0')
     expect(Process::WAIT3_VERSION).to be_frozen
   end
 
@@ -44,15 +57,13 @@ RSpec.describe Process do
   end
 
   example 'wait3 works as expected' do
-    skip 'wait3 test skipped on this platform' if darwin
     @pid = fork { sleep 0.5 }
-    expect { described_class.wait3 }.not_to raise_error
+    expect { call_wait3 }.not_to raise_error
   end
 
   example 'wait3 returns the expected proc status members' do
-    skip 'wait3 test skipped on this platform' if darwin
     @pid = fork { sleep 0.5 }
-    expect { @proc_stat = described_class.wait3 }.not_to raise_error
+    expect { @proc_stat = call_wait3 }.not_to raise_error
     expect(@proc_stat.members).to eq(proc_stat_members)
   end
 
@@ -62,116 +73,89 @@ RSpec.describe Process do
   end
 
   example 'wait3 sets and returns $last_status to expected values' do
-    skip 'wait3 test skipped on this platform' if darwin
     @pid = fork { sleep 0.5 }
-    described_class.wait3
+    call_wait3
     expect($last_status).to be_a(Struct::ProcStat)
     expect($last_status).not_to be_nil
   end
 
   example 'wait3 sets pid and status members of $?' do
-    skip 'wait3 test skipped on this platform' if darwin
     @pid = fork { sleep 0.5 }
-    described_class.wait3
+    call_wait3
     expect($CHILD_STATUS).not_to be_nil
   end
 
   example 'wait3 returns frozen struct' do
-    skip 'wait3 test skipped on this platform' if darwin
     @pid = fork { sleep 0.5 }
-    struct = described_class.wait3
+    struct = call_wait3
     expect(struct).to be_frozen
   end
 
-  example 'getdtablesize works as expected' do
-    skip 'getdtablesize skipped on this platform' unless solaris
-
+  example 'getdtablesize works as expected', :solaris do
     expect(described_class).to respond_to(:getdtablesize)
     expect(described_class.getdtablesize).to be_a(Integer)
     assert(described_class.getdtablesize > 0)
   end
 
-  example 'wait4 method is defined' do
-    skip 'wait4 test skipped on this platform' if hpux
+  example 'wait4 method is defined', :skip_hpux do
     expect(described_class).to respond_to(:wait4)
   end
 
-  example 'wait4 requires at least one argument' do
-    skip 'wait4 test skipped on this platform' if hpux
-    expect { described_class.wait4 }.to raise_error(ArgumentError)
+  example 'wait4 requires at least one argument', :skip_hpux do
+    expect { call_wait4 }.to raise_error(ArgumentError)
   end
 
-  example 'wait4 works as expected' do
-    skip 'wait4 test skipped on this platform' if hpux || darwin
-
+  example 'wait4 works as expected', :skip_hpux do
     @pid = fork { sleep 0.5 }
-    expect { @proc_stat = described_class.wait4(@pid) }.not_to raise_error
+    expect { @proc_stat = call_wait4(@pid) }.not_to raise_error
     expect(@proc_stat).to be_a(Struct::ProcStat)
   end
 
-  example 'wait4 sets and returns $last_status to expected values' do
-    skip 'wait4 test skipped on this platform' if hpux || darwin
-
+  example 'wait4 sets and returns $last_status to expected values', :skip_hpux do
     @pid = fork { sleep 0.5 }
-    described_class.wait4(@pid)
+    call_wait4(@pid)
     expect($last_status).to be_a(Struct::ProcStat)
     expect($last_status).not_to be_nil
   end
 
-  example 'wait4 sets pid and status members of $?' do
-    skip 'wait4 test skipped on this platform' if hpux || darwin
-
+  example 'wait4 sets pid and status members of $?', :skip_hpux do
     @pid = fork { sleep 0.5 }
-    described_class.wait4(@pid)
+    call_wait4(@pid)
     expect($CHILD_STATUS).not_to be_nil
   end
 
-  example 'wait4 returns frozen struct' do
-    skip 'wait4 test skipped on this platform' if hpux || darwin
-
+  example 'wait4 returns frozen struct', :skip_hpux do
     @pid = fork { sleep 0.5 }
-    struct = described_class.wait4(@pid)
+    struct = call_wait4(@pid)
     expect(struct).to be_frozen
   end
 
-  example 'waitid method is defined' do
-    skip 'waitid test skipped on this platform' if hpux || darwin || bsd
-
+  example 'waitid method is defined', :skip_hpux do
     expect(described_class).to respond_to(:waitid)
   end
 
-  example 'waitid method works as expected' do
-    skip 'waitid test skipped on this platform' if hpux || darwin || bsd
-
+  example 'waitid method works as expected', :skip_hpux do
     @pid = fork { sleep 0.5 }
-    expect { described_class.waitid(Process::P_PID, @pid, Process::WEXITED) }.not_to raise_error
+    expect { call_waitid(Process::P_PID, @pid, Process::WEXITED) }.not_to raise_error
   end
 
-  example 'waitid method raises expected errors if wrong argument type is passed' do
-    skip 'waitid test skipped on this platform' if hpux || darwin || bsd
-
+  example 'waitid method raises expected errors if wrong argument type is passed', :skip_hpux do
     @pid = fork { sleep 0.5 }
-    expect { described_class.waitid('foo', @pid, Process::WEXITED) }.to raise_error(TypeError)
-    expect { described_class.waitid(Process::P_PID, @pid, 'foo') }.to raise_error(TypeError)
-    expect { described_class.waitid(Process::P_PID, 'foo', Process::WEXITED) }.to raise_error(TypeError)
+    expect { call_waitid('foo', @pid, Process::WEXITED) }.to raise_error(TypeError)
+    expect { call_waitid(Process::P_PID, @pid, 'foo') }.to raise_error(TypeError)
+    expect { call_waitid(Process::P_PID, 'foo', Process::WEXITED) }.to raise_error(TypeError)
   end
 
-  example 'waitid method raises expected error if invalid argument is passed' do
-    skip 'waitid test skipped on this platform' if hpux || darwin || bsd
-
+  example 'waitid method raises expected error if invalid argument is passed', :skip_hpux do
     @pid = fork { sleep 0.5 }
     expect { described_class.waitid(Process::P_PID, 99999999, Process::WEXITED) }.to raise_error(Errno::ECHILD)
   end
 
-  example 'sigsend method is defined' do
-    skip 'sigsend test skipped on this platform' unless solaris
-
+  example 'sigsend method is defined', :solaris do
     expect(described_class).to respond_to(:sigsend)
   end
 
-  example 'sigsend works as expected' do
-    skip 'sigsend test skipped on this platform' unless solaris
-
+  example 'sigsend works as expected', :solaris do
     @pid = fork { sleep 0.5 }
     expect { described_class.sigsend(Process::P_PID, @pid, 0) }.not_to raise_error
   end
@@ -187,14 +171,11 @@ RSpec.describe Process do
     expect { described_class.getrusage(true) }.not_to raise_error
   end
 
-  example 'getrusage can get thread info on Linux' do
-    skip 'getrusage only tested on Linux' unless linux
+  example 'getrusage can get thread info on Linux', :linux do
     expect { described_class.getrusage(Process::RUSAGE_THREAD) }.not_to raise_error
   end
 
-  example 'getrusage returns the expected struct' do
-    skip 'getrusage only tested on Linux' unless linux
-
+  example 'getrusage returns the expected struct', :linux do
     @pid = fork { sleep 0.5 }
     expect(described_class.getrusage).to be_a(Struct::RUsage)
     expect(described_class.getrusage.stime).to be_a(Float)
@@ -205,21 +186,18 @@ RSpec.describe Process do
     expect(described_class).to respond_to(:pause)
   end
 
-  example 'expected constants are defined' do
-    skip 'wait constant check skipped on this platform' if darwin || bsd
-
+  example 'expected constants are defined', :skip_darwin, :skip_bsd do
     expect(Process::WCONTINUED).not_to be_nil
     expect(Process::WEXITED).not_to be_nil
     expect(Process::WNOWAIT).not_to be_nil
     expect(Process::WSTOPPED).not_to be_nil
+  end
 
-    skip 'WTRAPPED constant check skipped on this platform' if linux
+  example 'expected constant WTRAPPED is defined', :bsd do
     expect(Process::WTRAPPED).not_to be_nil
   end
 
-  example 'expected process type flag constants are defined' do
-    skip 'process type flag check skipped on this platform' if linux || darwin || bsd
-
+  example 'expected process type flag constants are defined', :solaris do
     expect(Process::P_ALL).not_to be_nil
     expect(Process::P_CID).not_to be_nil
     expect(Process::P_GID).not_to be_nil
@@ -227,20 +205,15 @@ RSpec.describe Process do
     expect(Process::P_PID).not_to be_nil
     expect(Process::P_SID).not_to be_nil
     expect(Process::P_UID).not_to be_nil
-
-    skip 'P_MYID constant check skipped on this platform' unless solaris
     expect(Process::P_MYID).not_to be_nil
   end
 
-  example 'solaris-specific process type flags are defined on solaris' do
-    skip 'P_TASKID and P_PROJID constant check skipped on this platform' unless solaris
-
+  example 'solaris-specific process type flags are defined on solaris', :solaris do
     expect(Process::P_TASKID).not_to be_nil
     expect(Process::P_PROJID).not_to be_nil
   end
 
-  example 'bsd-specific process type flags are defined on BSD platforms' do
-    skip 'P_JAILID constant check skipped on this platform' unless bsd
+  example 'bsd-specific process type flags are defined on BSD platforms', :bsd do
     expect(Process::P_JAILID).not_to be_nil
   end
 

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require 'proc-wait3'
+
+RSpec.configure do |config|
+  config.filter_run_excluding(:darwin) if Gem::Platform.local.os !~ /darwin|macos/i
+  config.filter_run_excluding(:solaris) if Gem::Platform.local.os !~ /sunos|solaris/i
+  config.filter_run_excluding(:bsd) if Gem::Platform.local.os !~ /bsd|dragonfly/i
+  config.filter_run_excluding(:linux) if Gem::Platform.local.os !~ /linux/i
+
+  config.filter_run_excluding(:skip_hpux) if Gem::Platform.local.os =~ /hpux/i
+  config.filter_run_excluding(:skip_darwin) if Gem::Platform.local.os =~ /darwin|macos/i
+  config.filter_run_excluding(:skip_bsd) if Gem::Platform.local.os =~ /bsd|dragonfly/i
+  config.filter_run_excluding(:skip_linux) if Gem::Platform.local.os =~ /linux/i
+end

metadata

@@ -1,11 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: proc-wait3
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Daniel J. Berger
-autorequire:
 bindir: bin
 cert_chain:
 - |
@@ -35,7 +34,7 @@ cert_chain:
   ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
   WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
   -----END CERTIFICATE-----
-date: 2024-04-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -120,6 +119,7 @@ files:
 - lib/proc-wait3.rb
 - proc-wait3.gemspec
 - spec/proc_wait3_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/djberg96/proc-wait3
 licenses:
 - Apache-2.0
@@ -132,7 +132,7 @@ metadata:
   wiki_uri: https://github.com/djberg96/proc-wait3/wiki
   rubygems_mfa_required: 'true'
   github_repo: https://github.com/djberg96/proc-wait3
-post_install_message:
+  funding_uri: https://github.com/sponsors/djberg96
 rdoc_options: []
 require_paths:
 - lib
@@ -147,8 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Adds wait3, wait4 and other methods to the Process module
 test_files: