process_shared 0.0.4 → 0.1.0

data/lib/mach/host.rb

@@ -0,0 +1,28 @@
+require 'mach/functions'
+require 'mach/port'
+require 'mach/clock'
+
+module Mach
+  class Host < Port
+    include Functions
+
+    # @return [Task]
+    def self.self
+      new(Functions.mach_host_self)
+    end
+
+    def initialize(host)
+      super(:port => host)
+    end
+
+    alias_method :host, :port
+
+    def get_clock_service
+      mem = new_memory_pointer(:clock_id_t)
+      host_get_clock_service(host, 0, mem)
+      clock_id = Port.new(:port => mem.read_int)
+      Clock.new clock_id
+    end
+  end
+end
+

data/lib/mach/port.rb

@@ -0,0 +1,143 @@
+require 'ffi'
+require 'mach/functions'
+
+module Mach
+  # Michael Weber's "Some Fun with Mach Ports" was an indispensable
+  # resource in learning the Mach ports API.
+  #
+  # @see http://www.foldr.org/~michaelw/log/computers/macosx/task-info-fun-with-mach
+  class Port
+    include Functions
+
+    class SendRightMsg < FFI::Struct
+      include Functions
+
+      layout(:header, MsgHeader,
+             :body, MsgBody,
+             :port, MsgPortDescriptor)
+    end
+
+    class ReceiveRightMsg < FFI::Struct
+      include Functions
+
+      layout(:header, MsgHeader,
+             :body, MsgBody,
+             :port, MsgPortDescriptor,
+             :trailer, MsgTrailer)
+    end
+
+    attr_reader :ipc_space, :port
+
+    # @param [Hash] opts
+    #
+    # @option opts [Integer] :ipc_space defaults to +mach_task_self+
+    #
+    # @option opts [MachPortRight] :right defaults to +:receive+
+    #
+    # @option opts [Port, Integer] :port if given, the existing port
+    # is wrapped in a new Port object; otherwise a new port is
+    # allocated according to the other options
+    def initialize(opts = {})
+      @ipc_space = opts[:ipc_space] || mach_task_self
+      right = opts[:right] || :receive
+
+      @port = if opts[:port]
+                opts[:port].to_i
+              else
+                mem = new_memory_pointer(:mach_port_right_t)
+                mach_port_allocate(@ipc_space.to_i, right, mem)
+                mem.get_uint(0)
+              end
+    end
+
+    # With this alias, we can call #to_i on either bare Integer ports
+    # or wrapped Port objects when passing the arg to a foreign
+    # function.
+    alias_method :to_i, :port
+
+    def to_s
+      "#<#{self.class} #{to_i}>"
+    end
+
+    def ==(other)
+      (port == other.port) && (ipc_space == other.ipc_space)
+    end
+
+    def destroy(opts = {})
+      ipc_space = opts[:ipc_space] || @ipc_space
+      mach_port_destroy(ipc_space, @port)
+    end
+
+    def deallocate(opts = {})
+      ipc_space = opts[:ipc_space] || @ipc_space
+      mach_port_deallocate(ipc_space.to_i, @port)
+    end
+
+    # Insert +right+ into another ipc space.  The current task must
+    # have sufficient rights to insert the requested right.
+    #
+    # @param [MachMsgType] right
+    #
+    # @param [Hash] opts
+    #
+    # @option opts [Port,Integer] :ipc_space the space (task port) into which
+    # +right+ will be inserted; defaults to this port's ipc_space
+    #
+    # @option opts [Port,Integer] :port the name the port right should
+    # have in :ipc_space; defaults to the same name as this port
+    def insert_right(right, opts = {})
+      ipc_space = opts[:ipc_space] || @ipc_space
+      port_name = opts[:port_name] || @port
+      
+      mach_port_insert_right(ipc_space.to_i, port_name.to_i, @port, right)
+    end
+
+    # Send +right+ on this Port to +remote_port+.  The current task
+    # must already have the requisite rights allowing it to send
+    # +right+.
+    def send_right(right, remote_port)
+      msg = SendRightMsg.new
+
+      msg[:header].tap do |h|
+        h[:remote_port] = remote_port.to_i
+        h[:local_port] = MACH_PORT_NULL
+        h[:bits] =
+          (MachMsgType[right] | (0 << 8)) | 0x80000000 # MACH_MSGH_BITS_COMPLEX
+        h[:size] = 40 # msg.size
+      end
+
+      msg[:body][:descriptor_count] = 1
+
+      msg[:port].tap do |p|
+        p[:name] = port
+        p[:disposition] = MachMsgType[right]
+        p[:type] = 0 # MACH_MSG_PORT_DESCRIPTOR;
+      end
+      
+      mach_msg_send msg
+    end
+
+    # Copy the send right on this port and send it in a message to
+    # +remote_port+.  The current task must have an existing send
+    # right on this Port.
+    def copy_send(remote_port)
+      send_right(:copy_send, remote_port)
+    end
+
+    # Create a new Port by receiving a port right message on this
+    # port.
+    def receive_right
+      msg = ReceiveRightMsg.new
+  
+      mach_msg(msg,
+               2, # MACH_RCV_MSG,
+               0,
+               msg.size,
+               port,
+               MACH_MSG_TIMEOUT_NONE,
+               MACH_PORT_NULL)
+
+      self.class.new :port => msg[:port][:name]
+    end
+  end
+end

data/lib/mach/semaphore.rb

@@ -0,0 +1,74 @@
+require 'mach/functions'
+require 'mach/port'
+require 'mach/host'
+require 'mach/clock'
+
+module Mach
+  class Semaphore < Port
+    include Functions
+
+    # Create a new Semaphore.
+    #
+    # @param [Hash] opts
+    #
+    # @option opts [Integer] :value the initial value of the
+    # semaphore; defaults to 1
+    #
+    # @option opts [Integer] :task the Mach task that owns the
+    # semaphore (defaults to Mach.task_self)
+    #
+    # @options opts [Integer] :sync_policy the sync policy for this
+    # semaphore (defaults to SyncPolicy::FIFO)
+    #
+    # @options opts [Integer] :port existing port to wrap with a
+    # Semaphore object; otherwise a new semaphore is created
+    #
+    # @return [Integer] a semaphore port name
+    def initialize(opts = {})
+      value = opts[:value] || 1
+      task = (opts[:task] && opts[:task].to_i) || ipc_space || mach_task_self
+      sync_policy = opts[:sync_policy] || :fifo
+
+      port = if opts[:port]
+               opts[:port].to_i
+             else
+               mem = new_memory_pointer(:semaphore_t)
+               semaphore_create(task, mem, sync_policy, value)
+               mem.get_uint(0)
+             end
+
+      super(:port => port, :ipc_space => task)
+    end
+
+    # Destroy a Semaphore.
+    #
+    # @param [Hash] opts
+    #
+    # @option opts [Integer] :task the Mach task that owns the
+    # semaphore (defaults to the owning task)
+    def destroy(opts = {})
+      task = opts[:task] || ipc_space || mach_task_self
+      semaphore_destroy(task.to_i, port)
+    end
+
+    def signal
+      semaphore_signal(port)
+    end
+
+    def signal_all
+      semaphore_signal_all(port)
+    end
+
+    def wait
+      semaphore_wait(port)
+    end
+
+    # @see http://pkaudio.blogspot.com/2010/05/mac-os-x-no-timed-semaphore-waits.html
+    def timedwait(secs)
+      timespec = TimeSpec.new
+      timespec.add_seconds!(secs)
+
+      semaphore_timedwait(port, timespec)
+    end
+  end
+end

data/lib/mach/task.rb

@@ -0,0 +1,42 @@
+require 'mach/functions'
+require 'mach/port'
+
+module Mach
+  class Task < Port
+    include Functions
+
+    # @return [Task]
+    def self.self
+      new(Functions.mach_task_self)
+    end
+
+    def initialize(task)
+      super(:port => task)
+    end
+
+    alias_method :task, :port
+
+    # @param [MachSpecialPort] which_port
+    def get_special_port(which_port)
+      mem = new_memory_pointer(:mach_port_t)
+      task_get_special_port(task, which_port, mem)
+      Port.new(:port => mem.get_uint(0))
+    end
+
+    # @param [MachSpecialPort] which_port
+    #
+    # @param [Port,Integer] newport
+    def set_special_port(which_port, newport)
+      task_set_special_port(task, which_port, newport.to_i)
+    end
+
+    def get_bootstrap_port
+      get_special_port(:bootstrap)
+    end
+
+    def set_bootstrap_port(port)
+      set_special_port(:bootstrap, port)
+    end
+  end
+end
+

data/lib/mach/time_spec.rb

@@ -0,0 +1,16 @@
+require 'ffi'
+
+module Mach
+  class TimeSpec < FFI::Struct
+    layout(:tv_sec, :uint,
+           :tv_nsec, :int)      # clock_res_t
+
+    def to_s
+      "#<%s tv_sec=%d tv_nsec=%d>" % [self.class,
+                                      self[:tv_sec],
+                                      self[:tv_nsec]]
+      
+    end
+  end
+end
+

data/lib/process_shared.rb

@@ -19,7 +19,23 @@ if RUBY_VERSION =~ /^1.8/
 end
 
 require 'process_shared/semaphore'
-require 'process_shared/bounded_semaphore'
+require 'process_shared/binary_semaphore'
 require 'process_shared/mutex'
 require 'process_shared/shared_memory'
 
+module ProcessShared
+  case FFI::Platform::OS
+  when 'linux'
+    require 'process_shared/posix/shared_memory'
+    require 'process_shared/posix/semaphore'
+
+    SharedMemory.impl = Posix::SharedMemory
+    Semaphore.impl = Posix::Semaphore
+  when 'darwin'
+    require 'process_shared/posix/shared_memory'
+    require 'process_shared/mach/semaphore'
+
+    SharedMemory.impl = Posix::SharedMemory
+    Semaphore.impl = Mach::Semaphore
+  end
+end

data/lib/process_shared/binary_semaphore.rb

@@ -1,4 +1,7 @@
-require 'process_shared/psem'
+require 'forwardable'
+
+require 'process_shared'
+require 'process_shared/with_self'
 require 'process_shared/semaphore'
 require 'process_shared/process_error'
 
@@ -9,7 +12,16 @@ module ProcessShared
   # exception.
   #
   # This is identical to a Semaphore but with extra error checking.
-  class BinarySemaphore < Semaphore
+  class BinarySemaphore
+    extend Forwardable
+    include ProcessShared::WithSelf
+
+    def_delegators :@sem, :wait, :try_wait, :synchronize, :value, :close
+
+    def self.open(value = 1, &block)
+      new(value).with_self(&block)
+    end
+
     # Create a new semaphore with initial value +value+.  After
     # {Kernel#fork}, the semaphore will be shared across two (or more)
     # processes. The semaphore must be closed with {#close} in each
@@ -20,10 +32,9 @@ module ProcessShared
     # resort).
     #
     # @param [Integer] value the initial semaphore value
-    # @param [String] name not currently supported
-    def initialize(value = 1, name = nil)
+    def initialize(value = 1)
       raise ArgumentErrror 'value must be 0 or 1' if (value < 0 or value > 1)
-      super(value, name)
+      @sem = Semaphore.new(value)
     end
 
     # Increment from zero to one.
@@ -37,11 +48,11 @@ module ProcessShared
       begin
         try_wait
         # oops, value was not zero...
-        psem_post(sem, err)
+        @sem.post
         raise ProcessError, 'post would raise value over bound'
       rescue Errno::EAGAIN
         # ok, value was zero
-        psem_post(sem, err)
+        @sem.post
       end
     end
   end

data/lib/process_shared/mach.rb

@@ -0,0 +1,93 @@
+require 'set'
+require 'mach'
+
+module ProcessShared
+  module Mach
+    include ::Mach
+
+    # The set of ports that should be shared to forked child
+    # processes.
+    #
+    # FIXME: protect with (original ruby) mutex?
+    def self.shared_ports
+      @shared_ports ||= Set.new
+    end
+
+    def self.after_fork_child
+      parent_port = Task.self.get_bootstrap_port
+
+      # give parent permission to send to child's task port
+      Task.self.copy_send(parent_port)
+
+      # create a second port and give the parent permission to send
+      port = Port.new
+      port.insert_right(:make_send)
+      port.copy_send(parent_port)
+
+      # parent copies sem, mutex port permissions directly to child
+      # task port
+
+      # wait for parent to send orig bootstrap port
+      orig_bootstrap = port.receive_right
+      Task.self.set_special_port(:bootstrap, orig_bootstrap)
+    end
+
+    def self.after_fork_parent(port)
+      child_task_port = port.receive_right
+      shared_ports.each do |p|
+        p.insert_right(:copy_send, :ipc_space => child_task_port)
+      end
+
+      child_port = port.receive_right
+      ::Mach::bootstrap_port.copy_send(child_port)
+    end
+  end
+end
+
+module Kernel
+  # Override to call Process::fork.
+  def fork(*args, &block)
+    Process.fork(*args, &block)
+  end
+end
+
+module Process
+  class << self
+    unless respond_to? :__mach_original_fork__
+      alias_method :__mach_original_fork__, :fork
+    end
+
+    # Override to first copy all shared ports (semaphores, etc.) from
+    # parent process to child process.
+    def fork
+      # make a port for receiving message from child
+      port = Mach::Port.new
+      port.insert_right(:make_send)
+      Mach::Task.self.set_bootstrap_port(port)
+      
+      if block_given?
+        pid = __mach_original_fork__ do
+          ProcessShared::Mach.after_fork_child
+          yield
+        end
+
+        ProcessShared::Mach.after_fork_parent(port)
+        pid
+      else
+        if pid = __mach_original_fork__
+          ProcessShared::Mach.after_fork_parent(port)
+          pid
+        else
+          ProcessShared::Mach.after_fork_child
+          nil
+        end
+      end
+    end
+  end
+end
+
+require 'mach/time_spec'
+require 'process_shared/time_spec'
+
+# Monkey patch to add #add_seconds! method
+Mach::TimeSpec.send(:include, ProcessShared::TimeSpec)