landlock 0.4 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7494b5195627610f67bb7a41a5adcb99857f19e1639d88b1107d3d5d43a639c
-  data.tar.gz: '065496b9a75a046e91b1d9445dae704bd4531d7de61391d4506c9f480789a32a'
+  metadata.gz: 06c677a70d7c9573f8900255447f3407b917a32d20b431ddf3639660ae410847
+  data.tar.gz: 07a99cefc054bbc33693f9d72531ef2639e8b926895de8f5972cd62a40974413
 SHA512:
-  metadata.gz: 310b8cf56b7906297466b1273d4c5e924dc859148bc0adf143d44825b2c2b68be07d67d7058def44f9551470c48880b37963db2eb48be991b4a07829a03a3e9e
-  data.tar.gz: 362a3ea8d6aaf5115d100adf06524a53cfd87d9a46cfc29f1677c351196fadbffee88fa80d348b433d8d518ad3e517ec3893b6b5a827f9e67b799c5954b093b7
+  metadata.gz: 44ff2dd41500ebfb8751aca02d09582a92a9cbcc5abce973f53ce1981fe579afde5bfe63b739c032404e874654de414ca13c17581a2ec51a34fe9e20c708105f
+  data.tar.gz: d98885b52ebe803ee29d3d5db0ee83ba44417377ddd7f9f6ce47b41576be326b5246b62ebfbd47723f79ae3d3be7c5608916816c86264e6832e7f1bfb515d793

data/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+## [0.4.1] - 2026-08-20
+
+### Fixed
+
+- Remove the 100 ms child-exit polling interval from subprocess capture. Capture now drains stdout and stderr, then monitors the child via pidfd until exit or the wall-clock deadline, retaining polling only as a compatibility fallback when pidfds are unavailable.
+
 ## [0.4] - 2026-08-10
 
 ### Changed

data/ext/landlock/landlock.c

@@ -121,6 +121,20 @@ static VALUE rb_ll_close_fd(VALUE self, VALUE fd_value) {
   return Qnil;
 }
 
+static VALUE rb_ll_pidfd_open(VALUE self, VALUE pid_value) {
+#ifdef SYS_pidfd_open
+  int fd = syscall(SYS_pidfd_open, NUM2PIDT(pid_value), 0);
+  if (fd < 0) {
+    raise_syscall_error("pidfd_open");
+  }
+  return INT2NUM(fd);
+#else
+  errno = ENOSYS;
+  raise_syscall_error("pidfd_open");
+  return Qnil;
+#endif
+}
+
 static VALUE rb_ll_seccomp_deny_network(VALUE self) {
   const char *error_message = "seccomp(SECCOMP_SET_MODE_FILTER)";
   if (rb_landlock_seccomp_deny_network(&error_message) != 0) {
@@ -150,6 +164,7 @@ void Init_landlock(void) {
   rb_define_singleton_method(mLandlock, "_add_net_rule", rb_ll_add_net_rule, 3);
   rb_define_singleton_method(mLandlock, "_restrict_self", rb_ll_restrict_self, 1);
   rb_define_singleton_method(mLandlock, "_close_fd", rb_ll_close_fd, 1);
+  rb_define_singleton_method(mLandlock, "_pidfd_open", rb_ll_pidfd_open, 1);
   rb_define_singleton_method(mLandlock, "seccomp_deny_network!", rb_ll_seccomp_deny_network, 0);
 
   rb_define_const(mLandlock, "ACCESS_FS_EXECUTE", ULL2NUM(LANDLOCK_ACCESS_FS_EXECUTE));

data/ext/landlock/landlock_native.h

@@ -35,6 +35,10 @@
 #endif
 #endif
 
+#if defined(__linux__) && !defined(SYS_pidfd_open) && defined(__NR_pidfd_open)
+#define SYS_pidfd_open __NR_pidfd_open
+#endif
+
 #ifndef LANDLOCK_CREATE_RULESET_VERSION
 #define LANDLOCK_CREATE_RULESET_VERSION (1U << 0)
 #endif

data/lib/landlock/native.rb

@@ -31,6 +31,10 @@ module Landlock
       Landlock.__send__(:_close_fd, fd)
     end
 
+    def pidfd_open(pid)
+      Landlock.__send__(:_pidfd_open, pid)
+    end
+
     def seccomp_deny_network!
       Landlock.seccomp_deny_network!
     end

data/lib/landlock/process_io.rb

@@ -5,7 +5,7 @@ require_relative "result"
 
 module Landlock
   READ_CHUNK_BYTES = 16 * 1024
-  PROCESS_POLL_SECONDS = 0.1
+  PID_WAIT_FALLBACK_INTERVAL_SECONDS = 0.1
   STDIN_THREAD_JOIN_SECONDS = 0.1
   POST_TIMEOUT_DRAIN_SECONDS = 0.05
 
@@ -91,45 +91,16 @@ module Landlock
       timed_out = false
       status = nil
 
-      until streams.empty? && status
+      until streams.empty?
         if deadline
           remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
           if remaining <= 0
             timed_out = true
-            terminate_process(pid)
-            status = wait_for_pid(pid)
-            drain_streams_until(
-              streams,
-              ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + POST_TIMEOUT_DRAIN_SECONDS,
-              max_output_bytes,
-              truncate_output,
-              state,
-              pid
-            )
-            close_streams(streams)
             break
           end
         end
 
-        status ||= poll_pid(pid)
-
-        break if streams.empty? && status
-
-        wait =
-          (
-            if deadline
-              [deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC), PROCESS_POLL_SECONDS].min
-            else
-              PROCESS_POLL_SECONDS
-            end
-          )
-        wait = 0 if wait.negative?
-        if streams.empty?
-          sleep wait
-          next
-        end
-
-        readable, = IO.select(streams.keys, nil, nil, wait)
+        readable, = IO.select(streams.keys, nil, nil, remaining)
         next unless readable
 
         readable.each do |io|
@@ -145,16 +116,81 @@ module Landlock
         end
       end
 
-      status ||= wait_for_pid(pid)
+      if deadline
+        status, timed_out = wait_for_pid_until(pid, deadline:)
+      else
+        status = wait_for_pid(pid)
+      end
+
+      if timed_out
+        drain_streams_until(
+          streams,
+          ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + POST_TIMEOUT_DRAIN_SECONDS,
+          max_output_bytes,
+          truncate_output,
+          state,
+          pid
+        )
+        close_streams(streams)
+      end
+
       [status, timed_out]
     end
 
-    def poll_pid(pid)
-      result = ::Process.wait2(pid, ::Process::WNOHANG)
-      result&.last
+    def wait_for_pid_until(pid, deadline:)
+      remaining = deadline - monotonic_time
+      if remaining <= 0
+        terminate_process(pid)
+        return wait_for_pid(pid), true
+      end
+
+      pidfd = Native.pidfd_open(pid)
+      pid_monitor = IO.for_fd(pidfd, autoclose: false)
+      readable, = IO.select([pid_monitor], nil, nil, remaining)
+      if !readable || monotonic_time >= deadline
+        terminate_process(pid)
+        return wait_for_pid(pid), true
+      end
+
+      [wait_for_pid(pid), false]
+    rescue Landlock::SyscallError
+      wait_for_pid_until_by_polling(pid, deadline:)
+    ensure
+      close_stream(pid_monitor) if pid_monitor
+      Native.close_fd(pidfd) if pidfd
+    end
+    private_class_method :wait_for_pid_until
+
+    def wait_for_pid_until_by_polling(pid, deadline:)
+      loop do
+        remaining = deadline - monotonic_time
+        if remaining <= 0
+          terminate_process(pid)
+          return wait_for_pid(pid), true
+        end
+
+        result = ::Process.wait2(pid, ::Process::WNOHANG)
+        if result
+          status = result.last
+          if monotonic_time >= deadline
+            terminate_process_group(pid)
+            return status, true
+          end
+
+          return status, false
+        end
+
+        IO.select(nil, nil, nil, [remaining, PID_WAIT_FALLBACK_INTERVAL_SECONDS].min)
+      end
     rescue Errno::ECHILD
-      nil
+      [nil, false]
+    end
+    private_class_method :wait_for_pid_until_by_polling
+
+    def monotonic_time
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
     end
+    private_class_method :monotonic_time
 
     def wait_for_pid(pid)
       ::Process.wait2(pid).last
@@ -237,6 +273,12 @@ module Landlock
       signal_process("KILL", pid)
     end
 
+    def terminate_process_group(pid)
+      ::Process.kill("KILL", -pid)
+    rescue Errno::ESRCH, Errno::EPERM
+    end
+    private_class_method :terminate_process_group
+
     def signal_process(signal, pid)
       ::Process.kill(signal, -pid)
     rescue Errno::ESRCH, Errno::EPERM

data/lib/landlock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Landlock
-  VERSION = "0.4"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: landlock
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: 0.4.1
 platform: ruby
 authors:
 - Sam Saffron