childprocess 0.2.6 → 0.2.7

data/.travis.yml

@@ -3,4 +3,7 @@ rvm:
   - 1.9.2
   - 1.9.3
   - jruby
-  - rbx
+  # - rbx
+env:
+  - CHILDPROCESS_POSIX_SPAWN=true
+  - CHILDPROCESS_POSIX_SPAWN=false

data/Rakefile

@@ -49,3 +49,14 @@ task :jar => [:clean, :build] do
   sh "jar cf childprocess.jar -C #{tmpdir}/gems/#{gem_name}/lib ."
   sh "jar tf childprocess.jar"
 end
+
+task :env do
+  $:.unshift File.expand_path("../lib", __FILE__)
+  require 'childprocess'
+end
+
+desc 'Calculate size of posix_spawn structs for the current platform'
+task :generate => :env do
+  require 'childprocess/tools/generator'
+  ChildProcess::Tools::Generator.generate
+end

data/lib/childprocess.rb

@@ -16,7 +16,11 @@ module ChildProcess
       when :windows
         Windows::Process.new(args)
       when :macosx, :linux, :unix, :cygwin
-        Unix::Process.new(args)
+        if posix_spawn?
+          Unix::PosixSpawnProcess.new(args)
+        else
+          Unix::ForkExecProcess.new(args)
+        end
       else
         raise Error, "unsupported platform #{platform.inspect}"
       end
@@ -37,10 +41,18 @@ module ChildProcess
       end
     end
 
+    def platform_name
+      @platform_name ||= "#{arch}-#{os}"
+    end
+
     def unix?
       !jruby? && [:macosx, :linux, :unix].include?(os)
     end
 
+    def linux?
+      os == :linux
+    end
+
     def jruby?
       platform == :jruby
     end
@@ -53,10 +65,34 @@ module ChildProcess
       !jruby? && os == :windows
     end
 
+    def posix_spawn?
+      enabled = @posix_spawn || %w[1 true].include?(ENV['CHILDPROCESS_POSIX_SPAWN'])
+      return false unless enabled
+
+      require 'ffi'
+      begin
+        require "childprocess/unix/platform/#{ChildProcess.platform_name}"
+      rescue LoadError
+        raise ChildProcess::MissingPlatformError
+      end
+
+      require "childprocess/unix/lib"
+      require 'childprocess/unix/posix_spawn_process'
+
+      true
+    rescue ChildProcess::MissingPlatformError => ex
+      warn_once ex.message
+      false
+    end
+
+    def posix_spawn=(bool)
+      @posix_spawn = bool
+    end
+
     def os
       @os ||= (
         require "rbconfig"
-        host_os = RbConfig::CONFIG['host_os']
+        host_os = RbConfig::CONFIG['host_os'].downcase
 
         case host_os
         when /mswin|msys|mingw32|cygwin/
@@ -73,6 +109,27 @@ module ChildProcess
       )
     end
 
+    def arch
+      @arch ||= (
+        host_cpu = RbConfig::CONFIG['host_cpu'].downcase
+        case host_cpu
+        when /i[3456]86/
+          # Darwin always reports i686, even when running in 64bit mod
+          if os == :macosx && 0xfee1deadbeef.is_a?(Fixnum)
+            "x86_64"
+          else
+            "i386"
+          end
+        when /amd64|x86_64/
+          "x86_64"
+        when /ppc|powerpc/
+          "powerpc"
+        else
+          host_cpu
+        end
+      )
+    end
+
     #
     # By default, a child process will inherit open file descriptors from the
     # parent process. This helper provides a cross-platform way of making sure
@@ -91,5 +148,16 @@ module ChildProcess
       end
     end
 
+    private
+
+    def warn_once(msg)
+      @warnings ||= {}
+
+      unless @warnings[msg]
+        @warnings[msg] = true
+        $stderr.puts msg
+      end
+    end
+
   end # class << self
 end # ChildProcess

data/lib/childprocess/errors.rb

@@ -4,4 +4,16 @@ module ChildProcess
   class SubclassResponsibility < StandardError; end
   class InvalidEnvironmentVariableName < StandardError; end
   class LaunchError < StandardError; end
+
+  class MissingPlatformError < StandardError
+    def initialize
+      platform = ChildProcess.platform_name
+
+      message = "posix_spawn is not yet supported on #{ChildProcess.platform_name} (#{RUBY_PLATFORM}), falling back to fork/exec. " +
+                "Please file a bug at http://github.com/jarib/childprocess/issues"
+
+      super(message)
+    end
+
+  end
 end

data/lib/childprocess/tools/generator.rb

@@ -0,0 +1,140 @@
+require 'ffi'
+require 'fileutils'
+
+module ChildProcess
+  module Tools
+    class Generator
+      EXE_NAME         = "childprocess-sizeof-generator"
+      TMP_PROGRAM      = "childprocess-sizeof-generator.c"
+      DEFAULT_INCLUDES = %w[stdio.h stddef.h]
+
+      def self.generate
+        new.generate
+      end
+
+      def initialize
+        @cc        = ENV['CC'] || 'gcc'
+        @out       = File.expand_path("../../unix/platform/#{ChildProcess.platform_name}.rb", __FILE__)
+        @sizeof    = {}
+        @constants = {}
+      end
+
+      def generate
+        fetch_size 'posix_spawn_file_actions_t', :include => "spawn.h"
+        fetch_size 'posix_spawnattr_t', :include => "spawn.h"
+        fetch_size 'sigset_t', :include => "signal.h"
+
+        fetch_constant 'POSIX_SPAWN_RESETIDS',   :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETPGROUP',  :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETSIGDEF',  :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETSIGMASK', :include  => 'spawn.h'
+
+        if ChildProcess.linux?
+          fetch_constant 'POSIX_SPAWN_USEVFORK', :include => 'spawn.h', :define => {'_GNU_SOURCE' => nil}
+        end
+
+        write
+      end
+
+      def write
+        FileUtils.mkdir_p(File.dirname(@out))
+        File.open(@out, 'w') do |io|
+          io.puts result
+        end
+
+        puts "wrote #{@out}"
+      end
+
+      def fetch_size(type_name, opts = {})
+        src = <<-EOF
+int main() {
+  printf("%d", (unsigned int)sizeof(#{type_name}));
+  return 0;
+}
+        EOF
+
+        output = execute(src, opts)
+
+        if output.to_i < 1
+          raise "sizeof(#{type_name}) == #{output.to_i} (output=#{output})"
+        end
+
+        @sizeof[type_name] = output.to_i
+      end
+
+      def fetch_constant(name, opts)
+        src = <<-EOF
+int main() {
+  printf("%d", (unsigned int)#{name});
+  return 0;
+}
+        EOF
+
+        output = execute(src, opts)
+        @constants[name] = Integer(output)
+      end
+
+
+      def execute(src, opts)
+
+        program = Array(opts[:define]).map do |key, value|
+          <<-SRC
+#ifndef #{key}
+#define #{key} #{value}
+#endif
+          SRC
+        end.join("\n")
+        program << "\n"
+
+        includes = Array(opts[:include]) + DEFAULT_INCLUDES
+        program << includes.map { |include| "#include <#{include}>" }.join("\n")
+        program << "\n#{src}"
+
+        File.open(TMP_PROGRAM, 'w') do |file|
+          file << program
+        end
+
+        cmd = "#{@cc} #{TMP_PROGRAM} -o #{EXE_NAME}"
+        system cmd
+        unless $?.success?
+          raise "failed to compile program: #{cmd.inspect}\n#{program}"
+        end
+
+        output = `./#{EXE_NAME} 2>&1`
+
+        unless $?.success?
+          raise "failed to run program: #{cmd.inspect}\n#{output}"
+        end
+
+        output.chomp
+      ensure
+        File.delete TMP_PROGRAM if File.exist?(TMP_PROGRAM)
+        File.delete EXE_NAME if File.exist?(EXE_NAME)
+      end
+
+      def result
+        if @sizeof.empty?
+          raise "no sizes collected, nothing to do"
+        end
+
+        out =  ['module ChildProcess::Unix::Platform']
+        out << '  SIZEOF = {'
+
+        max = @sizeof.keys.map { |e| e.length }.max
+        @sizeof.each_with_index do |(type, size), idx|
+          out << "     :#{type.ljust max} => #{size}#{',' unless idx == @sizeof.size - 1}"
+        end
+        out << '  }'
+
+        max = @constants.keys.map { |e| e.length }.max
+        @constants.each do |name, val|
+          out << "  #{name.ljust max} = #{val}"
+        end
+        out << 'end'
+
+        out.join "\n"
+      end
+
+    end
+  end
+end

data/lib/childprocess/unix.rb

@@ -4,4 +4,6 @@ module ChildProcess
 end
 
 require "childprocess/unix/io"
-require "childprocess/unix/process"
+require "childprocess/unix/process"
+require "childprocess/unix/fork_exec_process"
+# PosixSpawnProcess + ffi is required on demand.

data/lib/childprocess/unix/fork_exec_process.rb

@@ -0,0 +1,60 @@
+module ChildProcess
+  module Unix
+    class ForkExecProcess < Process
+      private
+
+      def launch_process
+        if @io
+          stdout = @io.stdout
+          stderr = @io.stderr
+        end
+
+        # pipe used to detect exec() failure
+        exec_r, exec_w = ::IO.pipe
+        ChildProcess.close_on_exec exec_w
+
+        if duplex?
+          reader, writer = ::IO.pipe
+        end
+
+        @pid = fork {
+          exec_r.close
+          set_env
+
+          STDOUT.reopen(stdout || "/dev/null")
+          STDERR.reopen(stderr || "/dev/null")
+
+          if duplex?
+            STDIN.reopen(reader)
+            writer.close
+          end
+
+          begin
+            exec(*@args)
+          rescue SystemCallError => ex
+            exec_w << ex.message
+          end
+        }
+
+        exec_w.close
+
+        if duplex?
+          io._stdin = writer
+          reader.close
+        end
+
+        # if we don't eventually get EOF, exec() failed
+        unless exec_r.eof?
+          raise LaunchError, exec_r.read || "executing command with #{@args.inspect} failed"
+        end
+
+        ::Process.detach(@pid) if detach?
+      end
+
+      def set_env
+        @environment.each { |k, v| ENV[k.to_s] = v.to_s }
+      end
+
+    end # Process
+  end # Unix
+end # ChildProcess

data/lib/childprocess/unix/lib.rb

@@ -0,0 +1,171 @@
+module ChildProcess
+  module Unix
+    module Lib
+      extend FFI::Library
+
+      ffi_lib FFI::Library::LIBC
+
+      attach_function :strerror, [:int], :string
+
+      # int posix_spawnp(
+      #   pid_t *restrict pid,
+      #   const char *restrict file,
+      #   const posix_spawn_file_actions_t *file_actions,
+      #   const posix_spawnattr_t *restrict attrp,
+      #   char *const argv[restrict],
+      #   char *const envp[restrict]
+      # );
+
+      attach_function :posix_spawnp, [
+        :pointer,
+        :string,
+        :pointer,
+        :pointer,
+        :pointer,
+        :pointer
+      ], :int
+
+      # int posix_spawn_file_actions_init(posix_spawn_file_actions_t *file_actions);
+      attach_function :posix_spawn_file_actions_init, [:pointer], :int
+
+      # int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *file_actions);
+      attach_function :posix_spawn_file_actions_destroy, [:pointer], :int
+
+      # int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *file_actions, int filedes);
+      attach_function :posix_spawn_file_actions_addclose, [:pointer, :int], :int
+
+      # int posix_spawn_file_actions_addopen(
+      #   posix_spawn_file_actions_t *restrict file_actions,
+      #   int filedes,
+      #   const char *restrict path,
+      #   int oflag,
+      #   mode_t mode
+      # );
+      attach_function :posix_spawn_file_actions_addopen, [:pointer, :int, :string, :int, :mode_t], :int
+
+      # int posix_spawn_file_actions_adddup2(
+      #   posix_spawn_file_actions_t *file_actions,
+      #   int filedes,
+      #   int newfiledes
+      # );
+      attach_function :posix_spawn_file_actions_adddup2, [:pointer, :int, :int], :int
+
+      # int posix_spawnattr_init(posix_spawnattr_t *attr);
+      attach_function :posix_spawnattr_init, [:pointer], :int
+
+      # int posix_spawnattr_destroy(posix_spawnattr_t *attr);
+      attach_function :posix_spawnattr_destroy, [:pointer], :int
+
+      # int posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags);
+      attach_function :posix_spawnattr_setflags, [:pointer, :short], :int
+
+      # int posix_spawnattr_getflags(const posix_spawnattr_t *restrict attr, short *restrict flags);
+      attach_function :posix_spawnattr_getflags, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_setpgroup(posix_spawnattr_t *attr, pid_t pgroup);
+      attach_function :posix_spawnattr_setpgroup, [:pointer, :pid_t], :int
+
+      # int posix_spawnattr_getpgroup(const posix_spawnattr_t *restrict attr, pid_t *restrict pgroup);
+      attach_function :posix_spawnattr_getpgroup, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_setsigdefault(posix_spawnattr_t *restrict attr, const sigset_t *restrict sigdefault);
+      attach_function :posix_spawnattr_setsigdefault, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_getsigdefault(const posix_spawnattr_t *restrict attr, sigset_t *restrict sigdefault);
+      attach_function :posix_spawnattr_getsigdefault, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_setsigmask(posix_spawnattr_t *restrict attr, const sigset_t *restrict sigmask);
+      attach_function :posix_spawnattr_setsigmask, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_getsigmask(const posix_spawnattr_t *restrict attr, sigset_t *restrict sigmask);
+      attach_function :posix_spawnattr_getsigmask, [:pointer, :pointer], :int
+
+      def self.check(errno)
+        if errno != 0
+          raise Error, Lib.strerror(errno)
+        end
+      end
+
+      class FileActions
+        def initialize
+          @ptr = FFI::MemoryPointer.new(1, Platform::SIZEOF.fetch(:posix_spawn_file_actions_t), false)
+          Lib.check Lib.posix_spawn_file_actions_init(@ptr)
+        end
+
+        def add_close(fileno)
+          Lib.check Lib.posix_spawn_file_actions_addclose(
+            @ptr,
+            fileno
+          )
+        end
+
+        def add_open(fileno, path, oflag, mode)
+          Lib.check Lib.posix_spawn_file_actions_addopen(
+            @ptr,
+            fileno,
+            path,
+            oflag,
+            mode
+          )
+        end
+
+        def add_dup(fileno, new_fileno)
+          Lib.check Lib.posix_spawn_file_actions_adddup2(
+            @ptr,
+            fileno,
+            new_fileno
+          )
+        end
+
+        def free
+          Lib.check Lib.posix_spawn_file_actions_destroy(@ptr)
+          @ptr = nil
+        end
+
+        def to_ptr
+          @ptr
+        end
+      end # FileActions
+
+      class Attrs
+        def initialize
+          @ptr = FFI::MemoryPointer.new(1, Platform::SIZEOF.fetch(:posix_spawnattr_t), false)
+          Lib.check Lib.posix_spawnattr_init(@ptr)
+        end
+
+        def free
+          Lib.check Lib.posix_spawnattr_destroy(@ptr)
+          @ptr = nil
+        end
+
+        def flags=(flags)
+          Lib.check Lib.posix_spawnattr_setflags(@ptr, flags)
+        end
+
+        def flags
+          ptr = FFI::MemoryPointer.new(:short)
+          Lib.check Lib.posix_spawnattr_getflags(@ptr, ptr)
+
+          ptr.read_short
+        end
+
+        def to_ptr
+          @ptr
+        end
+      end # Attrs
+
+    end
+  end
+end
+
+# missing on rubinius
+class FFI::MemoryPointer
+  unless method_defined?(:from_string)
+    def self.from_string(str)
+      ptr = new(1, str.bytesize + 1)
+      ptr.write_string("#{str}\0")
+
+      ptr
+    end
+  end
+end

data/lib/childprocess/unix/platform/i386-linux.rb

@@ -0,0 +1,12 @@
+module ChildProcess::Unix::Platform
+  SIZEOF = {
+     :posix_spawn_file_actions_t => 76,
+     :posix_spawnattr_t          => 336,
+     :sigset_t                   => 128
+  }
+  POSIX_SPAWN_RESETIDS   = 1
+  POSIX_SPAWN_SETPGROUP  = 2
+  POSIX_SPAWN_SETSIGDEF  = 4
+  POSIX_SPAWN_SETSIGMASK = 8
+  POSIX_SPAWN_USEVFORK   = 64
+end

data/lib/childprocess/unix/platform/x86_64-linux.rb

@@ -0,0 +1,11 @@
+module ChildProcess::Unix::Platform
+  SIZEOF = {
+     :posix_spawn_file_actions_t => 80,
+     :posix_spawnattr_t          => 336
+  }
+  POSIX_SPAWN_RESETIDS   = 1
+  POSIX_SPAWN_SETPGROUP  = 2
+  POSIX_SPAWN_SETSIGDEF  = 4
+  POSIX_SPAWN_SETSIGMASK = 8
+  POSIX_SPAWN_USEVFORK   = 64
+end

data/lib/childprocess/unix/platform/x86_64-macosx.rb

@@ -0,0 +1,11 @@
+module ChildProcess::Unix::Platform
+  SIZEOF = {
+     :posix_spawn_file_actions_t => 8,
+     :posix_spawnattr_t          => 8,
+     :sigset_t                   => 4
+  }
+  POSIX_SPAWN_RESETIDS   = 1
+  POSIX_SPAWN_SETPGROUP  = 2
+  POSIX_SPAWN_SETSIGDEF  = 4
+  POSIX_SPAWN_SETSIGMASK = 8
+end

data/lib/childprocess/unix/posix_spawn_process.rb

@@ -0,0 +1,99 @@
+require 'ffi'
+
+module ChildProcess
+  module Unix
+    class PosixSpawnProcess < Process
+      private
+
+      def launch_process
+        pid_ptr = FFI::MemoryPointer.new(:pid_t)
+        actions = Lib::FileActions.new
+        attrs   = Lib::Attrs.new
+        flags   = 0
+
+        if @io
+          if @io.stdout
+            actions.add_dup @io.stdout.fileno, $stdout.fileno
+          else
+            actions.add_open $stdout.fileno, "/dev/null", File::WRONLY, 0644
+          end
+
+          if @io.stderr
+            actions.add_dup @io.stderr.fileno, $stderr.fileno
+          else
+            actions.add_open $stderr.fileno, "/dev/null", File::WRONLY, 0644
+          end
+        end
+
+        if duplex?
+          reader, writer = ::IO.pipe
+          actions.add_dup reader.fileno, $stdin.fileno
+          actions.add_close writer.fileno
+        end
+
+        if defined? Platform::POSIX_SPAWN_USEVFORK
+          flags |= Platform::POSIX_SPAWN_USEVFORK
+        end
+
+        attrs.flags = flags
+
+        ret = Lib.posix_spawnp(
+          pid_ptr,
+          @args.first, # TODO: not sure this matches exec() behaviour
+          actions,
+          attrs,
+          argv,
+          env
+        )
+
+        if duplex?
+          io._stdin = writer
+          reader.close
+        end
+
+        actions.free
+        attrs.free
+
+        if ret != 0
+          raise LaunchError, "#{Lib.strerror(ret)} (#{ret})"
+        end
+
+        @pid = pid_ptr.read_int
+        ::Process.detach(@pid) if detach?
+      end
+
+      def argv
+        arg_ptrs = @args.map do |e|
+          if e.include?("\0")
+            raise ArgumentError, "argument cannot contain null bytes: #{e.inspect}"
+          end
+          FFI::MemoryPointer.from_string(e.to_s)
+        end
+        arg_ptrs << nil
+
+        argv = FFI::MemoryPointer.new(:pointer, arg_ptrs.size)
+        argv.put_array_of_pointer(0, arg_ptrs)
+
+        argv
+      end
+
+      def env
+        env_ptrs = ENV.to_hash.merge(@environment).map do |key, val|
+          if key.include?("=")
+            raise InvalidEnvironmentVariableName, key
+          end
+
+          FFI::MemoryPointer.from_string("#{key}=#{val}")
+        end
+
+        env_ptrs << nil
+
+        env = FFI::MemoryPointer.new(:pointer, env_ptrs.size)
+        env.put_array_of_pointer(0, env_ptrs)
+
+        env
+      end
+
+    end
+  end
+end

data/lib/childprocess/unix/process.rb

@@ -41,6 +41,7 @@ module ChildProcess
       end
 
       def wait
+        assert_started
         pid, status = ::Process.waitpid2 @pid
 
         @exit_code = status.exitstatus || status.termsig
@@ -63,58 +64,6 @@ module ChildProcess
         ::Process.kill sig, @pid
       end
 
-      def launch_process
-        if @io
-          stdout = @io.stdout
-          stderr = @io.stderr
-        end
-
-        # pipe used to detect exec() failure
-        exec_r, exec_w = ::IO.pipe
-        ChildProcess.close_on_exec exec_w
-
-        if duplex?
-          reader, writer = ::IO.pipe
-        end
-
-        @pid = fork {
-          exec_r.close
-          set_env
-
-          STDOUT.reopen(stdout || "/dev/null")
-          STDERR.reopen(stderr || "/dev/null")
-
-          if duplex?
-            STDIN.reopen(reader)
-            writer.close
-          end
-
-          begin
-            exec(*@args)
-          rescue SystemCallError => ex
-            exec_w << ex.message
-          end
-        }
-
-        exec_w.close
-
-        if duplex?
-          io._stdin = writer
-          reader.close
-        end
-
-        # if we don't eventually get EOF, exec() failed
-        unless exec_r.eof?
-          raise LaunchError, exec_r.read || "executing command with #{@args.inspect} failed"
-        end
-
-        ::Process.detach(@pid) if detach?
-      end
-
-      def set_env
-        @environment.each { |k, v| ENV[k.to_s] = v.to_s }
-      end
-
     end # Process
   end # Unix
 end # ChildProcess

data/lib/childprocess/version.rb

@@ -1,3 +1,3 @@
 module ChildProcess
-  VERSION = "0.2.6"
+  VERSION = "0.2.7"
 end

data/lib/childprocess/windows/lib.rb

@@ -20,11 +20,10 @@ module ChildProcess
     DETACHED_PROCESS              = 0x00000008
 
     STARTF_USESTDHANDLES          = 0x00000100
-    INVALID_HANDLE_VALUE          = 0xFFFFFFFF
+    INVALID_HANDLE_VALUE          = -1
     HANDLE_FLAG_INHERIT           = 0x00000001
 
     DUPLICATE_SAME_ACCESS         = 0x00000002
-
     CREATE_UNICODE_ENVIRONMENT    = 0x00000400
 
     module Lib
@@ -161,14 +160,14 @@ module ChildProcess
       #   __in  DWORD dwFlags
       # );
 
-      attach_function :set_handle_information, :SetHandleInformation, [:long, :ulong, :ulong], :bool
+      attach_function :set_handle_information, :SetHandleInformation, [:pointer, :ulong, :ulong], :bool
 
       # BOOL WINAPI GetHandleInformation(
       #   __in   HANDLE hObject,
       #   __out  LPDWORD lpdwFlags
       # );
 
-      attach_function :get_handle_information, :GetHandleInformation, [:long, :pointer], :bool
+      attach_function :get_handle_information, :GetHandleInformation, [:pointer, :pointer], :bool
 
       # BOOL WINAPI CreatePipe(
       #   __out     PHANDLE hReadPipe,
@@ -248,8 +247,8 @@ module ChildProcess
           buf = FFI::MemoryPointer.new :char, 512
 
           size = format_message(
-          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
-          nil, errnum, 0, buf, buf.size, nil
+            FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+            nil, errnum, 0, buf, buf.size, nil
           )
 
           str = buf.read_string(size).strip
@@ -280,7 +279,7 @@ module ChildProcess
             raise Error, last_error_message
           end
 
-          handle
+          FFI::Pointer.new handle
         end
 
         def io_for(handle, flags = File::RDONLY)
@@ -289,7 +288,7 @@ module ChildProcess
             raise Error, last_error_message
           end
 
-          ::IO.for_fd fd, flags
+          FFI::IO.for_fd fd, flags
         end
 
         def duplicate_handle(handle)

data/lib/childprocess/windows/process_builder.rb

@@ -60,7 +60,7 @@ module ChildProcess
         env_str = strings.join
 
         @env_ptr = FFI::MemoryPointer.new(:long, env_str.bytesize)
-        @env_ptr.write_bytes env_str, 0, env_str.bytesize
+        @env_ptr.put_bytes 0, env_str, 0, env_str.bytesize
       end
 
       def create_process
@@ -124,24 +124,15 @@ module ChildProcess
         @read_pipe  = read_pipe_ptr.read_pointer
         @write_pipe = write_pipe_ptr.read_pointer
 
-        Lib.set_handle_inheritance @write_pipe.address, false
+        @inherit = true
+        Lib.set_handle_inheritance @read_pipe, true
+        Lib.set_handle_inheritance @write_pipe, false
 
         startup_info[:hStdInput] = @read_pipe
       end
 
-      def close_handles
-        Lib.close_handle process_info[:hProcess]
-        Lib.close_handle process_info[:hThread]
-
-        if @duplex
-          @stdin = Lib.io_for(Lib.duplicate_handle(@write_pipe), File::WRONLY)
-          Lib.close_handle @read_pipe
-          Lib.close_handle @write_pipe
-        end
-      end
-
       def std_stream_handle_for(io)
-        handle = Lib.handle_for(io.fileno)
+        handle = Lib.handle_for(io)
 
         begin
           Lib.set_handle_inheritance handle, true
@@ -155,6 +146,17 @@ module ChildProcess
         handle
       end
 
+      def close_handles
+        Lib.close_handle process_info[:hProcess]
+        Lib.close_handle process_info[:hThread]
+
+        if @duplex
+          @stdin = Lib.io_for(Lib.duplicate_handle(@write_pipe), File::WRONLY)
+          Lib.close_handle @read_pipe
+          Lib.close_handle @write_pipe
+        end
+      end
+
       def quote_if_necessary(str)
         quote = str.start_with?('"') ? "'" : '"'
 

data/spec/childprocess_spec.rb

@@ -10,7 +10,14 @@ describe ChildProcess do
     process.should be_started
   end
 
-  it "raises ChildProcess::LaunchError if the process can't be started" do
+  # We can't detect failure to execve() when using posix_spawn() on Linux
+  # without waiting for the child to exit with code 127.
+  #
+  # See e.g. http://repo.or.cz/w/glibc.git/blob/669704fd:/sysdeps/posix/spawni.c#l34
+  #
+  # We could work around this by doing the PATH search ourselves, but not sure
+  # it's worth it.
+  it "raises ChildProcess::LaunchError if the process can't be started", :posix_spawn_on_linux => false do
     lambda { invalid_process.start }.should raise_error(ChildProcess::LaunchError)
   end
 

data/spec/spec_helper.rb

@@ -128,4 +128,8 @@ RSpec.configure do |c|
   if defined?(JRUBY_VERSION)
     c.filter_run_excluding :jruby => false
   end
+
+  if ChildProcess.linux? && ChildProcess.posix_spawn?
+    c.filter_run_excluding :posix_spawn_on_linux => false
+  end
 end

data/spec/unix_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../spec_helper', __FILE__)
 require "pid_behavior"
 
-if ChildProcess.unix?
+if ChildProcess.unix? && !ChildProcess.posix_spawn?
   describe ChildProcess::Unix::Process do
     it_behaves_like "a platform that provides the child's pid"
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: childprocess
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 2
-  - 6
-  version: 0.2.6
+  - 7
+  version: 0.2.7
 platform: ruby
 authors: 
 - Jari Bakken
@@ -15,10 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-07 00:00:00 Z
+date: 2012-01-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  type: :development
+  name: rspec
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -30,11 +31,11 @@ dependencies:
         - 0
         - 0
         version: 2.0.0
-  prerelease: false
-  name: rspec
+  type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  type: :development
+  name: yard
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -44,11 +45,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  prerelease: false
-  name: yard
+  type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  type: :development
+  name: rake
+  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -60,11 +61,11 @@ dependencies:
         - 9
         - 2
         version: 0.9.2
-  prerelease: false
-  name: rake
+  type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  type: :runtime
+  name: ffi
+  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -76,8 +77,7 @@ dependencies:
         - 0
         - 6
         version: 1.0.6
-  prerelease: false
-  name: ffi
+  type: :runtime
   version_requirements: *id004
 description: This gem aims at being a simple and reliable solution for controlling external programs running in the background on any Ruby / OS combination.
 email: 
@@ -106,8 +106,15 @@ files:
 - lib/childprocess/jruby/io.rb
 - lib/childprocess/jruby/process.rb
 - lib/childprocess/jruby/pump.rb
+- lib/childprocess/tools/generator.rb
 - lib/childprocess/unix.rb
+- lib/childprocess/unix/fork_exec_process.rb
 - lib/childprocess/unix/io.rb
+- lib/childprocess/unix/lib.rb
+- lib/childprocess/unix/platform/i386-linux.rb
+- lib/childprocess/unix/platform/x86_64-linux.rb
+- lib/childprocess/unix/platform/x86_64-macosx.rb
+- lib/childprocess/unix/posix_spawn_process.rb
 - lib/childprocess/unix/process.rb
 - lib/childprocess/version.rb
 - lib/childprocess/windows.rb