Extract internal Process.block_signals helper (#16402)

Extract common behaviour between the two fork methods and encapsulates the signal blocking behaviour.
As a result, the call site is much cleaner now.

Author: straight-shoota

src/crystal/system/unix/process.cr

@@ -197,6 +197,25 @@ struct Crystal::System::Process
   def self.fork
     {% raise("Process fork is unsupported with multithreaded mode") if flag?(:preview_mt) %}
 
+    block_signals do
+      case pid = lock_write { LibC.fork }
+      when 0
+        # forked process
+
+        ::Process.after_fork_child_callbacks.each(&.call)
+
+        nil
+      when -1
+        # forking process: error
+        raise RuntimeError.from_errno("fork")
+      else
+        # forking process: success
+        pid
+      end
+    end
+  end
+
+  private def self.block_signals(&)
     newmask = uninitialized LibC::SigsetT
     oldmask = uninitialized LibC::SigsetT
 
@@ -211,26 +230,11 @@ struct Crystal::System::Process
     ret = LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(newmask), pointerof(oldmask))
     raise RuntimeError.from_errno("Failed to disable signals") unless ret == 0
 
-    case pid = lock_write { LibC.fork }
-    when 0
-      # child:
-      pid = nil
-
-      ::Process.after_fork_child_callbacks.each(&.call)
-
-      # restore sigmask
-      LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(oldmask), nil)
-    when -1
-      # error:
-      errno = Errno.value
-      LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(oldmask), nil)
-      raise RuntimeError.from_os_error("fork", errno)
-    else
-      # parent:
+    begin
+      yield pointerof(oldmask)
+    ensure
       LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(oldmask), nil)
     end
-
-    pid
   end
 
   # Duplicates the current process.

src/crystal/system/unix/spawn.cr

@@ -59,41 +59,25 @@ struct Crystal::System::Process
   end
 
   private def self.fork_for_exec
-    newmask = uninitialized LibC::SigsetT
-    oldmask = uninitialized LibC::SigsetT
-
-    # block signals while we fork, so the child process won't forward signals it
-    # may receive to the parent through the signal pipe, but make sure to not
-    # block stop-the-world signals as it appears to create deadlocks in glibc
-    # for example; this is safe because these signal handlers musn't be
-    # registered through `Signal.trap` but directly through `sigaction`.
-    LibC.sigfillset(pointerof(newmask))
-    LibC.sigdelset(pointerof(newmask), System::Thread.sig_suspend)
-    LibC.sigdelset(pointerof(newmask), System::Thread.sig_resume)
-    ret = LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(newmask), pointerof(oldmask))
-    raise RuntimeError.from_errno("Failed to disable signals") unless ret == 0
+    block_signals do |sigmask|
+      case pid = lock_write { LibC.fork }
+      when 0
+        # forked process
 
-    case pid = lock_write { LibC.fork }
-    when 0
-      # child:
-      pid = nil
+        Crystal::System::Signal.after_fork_before_exec
 
-      Crystal::System::Signal.after_fork_before_exec
+        # reset sigmask (inherited on exec)
+        LibC.sigemptyset(sigmask)
 
-      # reset sigmask (inherited on exec)
-      LibC.sigemptyset(pointerof(newmask))
-      LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(newmask), nil)
-    when -1
-      # error:
-      errno = Errno.value
-      LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(oldmask), nil)
-      raise RuntimeError.from_os_error("fork", errno)
-    else
-      # parent:
-      LibC.pthread_sigmask(LibC::SIG_SETMASK, pointerof(oldmask), nil)
+        nil
+      when -1
+        # forking process: error
+        raise RuntimeError.from_errno("fork")
+      else
+        # forking process: success
+        pid
+      end
     end
-
-    pid
   end
 
   # This method is similar to `.replace` (used for `Process.exec`) with some