process_shared 0.0.4 → 0.1.0

data/ext/helper/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+have_header('fcntl.h')
+
+have_header('sys/mman.h')
+
+have_header('semaphore.h')
+have_type('sem_t', 'semaphore.h')
+
+have_header('pthread.h')
+have_type('pthread_mutex_t', 'pthread.h')
+have_type('pthread_mutexattr_t', 'pthread.h')
+
+create_makefile('helper')

data/ext/helper/helper.c

@@ -0,0 +1,70 @@
+/****************************/
+/* File descriptor controls */
+/****************************/
+
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+extern int o_rdwr;
+int o_rdwr = O_RDWR;
+extern int o_creat;
+int o_creat = O_CREAT;
+extern int o_excl;
+int o_excl = O_EXCL;
+#endif
+
+/************************/
+/* Memory Map constants */
+/************************/
+
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+
+extern int prot_read;
+extern int prot_write;
+extern int prot_exec;
+extern int prot_none;
+
+extern void * map_failed;
+extern int map_shared;
+extern int map_private;
+
+int prot_read = PROT_READ;
+int prot_write = PROT_WRITE;
+int prot_exec = PROT_EXEC;
+int prot_none = PROT_NONE;
+
+void * map_failed = MAP_FAILED;
+int map_shared = MAP_SHARED;
+int map_private = MAP_PRIVATE;
+#endif
+
+/****************************************/
+/* PThread and related types and macros */
+/****************************************/
+
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+extern int pthread_process_shared;
+int pthread_process_shared = PTHREAD_PROCESS_SHARED;
+#endif
+
+#ifdef HAVE_TYPE_PTHREAD_MUTEX_T
+extern size_t sizeof_pthread_mutex_t;
+size_t sizeof_pthread_mutex_t = sizeof (pthread_mutex_t);
+size_t sizeof_pthread_mutexattr_t = sizeof (pthread_mutexattr_t);
+#endif
+
+#ifdef HAVE_TYPE_PTHREAD_MUTEXATTR_T
+extern size_t sizeof_pthread_mutexattr_t;
+#endif
+
+/******************/
+/* Semaphore type */
+/******************/
+
+#ifdef HAVE_TYPE_SEM_T
+#include <semaphore.h>
+extern size_t sizeof_sem_t;
+size_t sizeof_sem_t = sizeof (sem_t);
+#endif
+

data/lib/mach.rb

@@ -0,0 +1,12 @@
+require 'mach/port'
+require 'mach/semaphore'
+require 'mach/task'
+require 'mach/functions'
+
+module Mach
+  # @return [Port] the original bootstrap port; different from that
+  # affected by {get,set}_special_port
+  def self.bootstrap_port
+    @bootstrap_port ||= Mach::Port.new(:port => Mach::Functions::bootstrap_port)
+  end
+end

data/lib/mach/clock.rb

@@ -0,0 +1,24 @@
+require 'mach/functions'
+require 'mach/port'
+require 'mach/time_spec'
+
+module Mach
+  class Clock
+    include Functions
+
+    def initialize(clock_id)
+      @clock_id = clock_id
+    end
+
+    def to_s
+      "#<#{self.class} #{@clock_id.to_i}>"
+    end
+
+    def get_time
+      time = TimeSpec.new
+      clock_get_time(@clock_id.to_i, time)
+      time
+    end
+  end
+end
+

data/lib/mach/error.rb

@@ -0,0 +1,56 @@
+require 'ffi'
+
+require 'mach/functions'
+
+module Mach
+  class Error < StandardError
+    class INVALID_ADDRESS < Error; end
+    class PROTECTION_FAILURE < Error; end
+    class NO_SPACE < Error; end
+    class INVALID_ARGUMENT < Error; end
+    class FAILURE < Error; end
+    class ABORTED < Error; end
+    class INVALID_NAME < Error; end
+    class OPERATION_TIMED_OUT < Error; end
+
+    include Functions
+
+    def self.new(msg, errno)
+      klass = case errno
+              when 1; then INVALID_ADDRESS
+              when 2; then PROTECTION_FAILURE
+              when 3; then NO_SPACE
+              when 4; then INVALID_ARGUMENT
+              when 5; then FAILURE
+              when 14; then ABORTED
+              when 15; then INVALID_NAME
+              when 49; then OPERATION_TIMED_OUT
+              else FAILURE
+              end
+
+      e = klass.allocate
+      e.send(:initialize, msg, errno)
+      e
+    end
+
+    attr_reader :errno
+
+    def initialize(msg, errno)
+      super(msg)
+      @errno = errno
+    end
+
+    def to_s
+      "#{super}: #{error_string(errno)}"
+    end
+
+    protected
+
+    # NOTE: api does not say this string must be freed; assuming it
+    # does not
+    def error_string(errno)
+      ptr = mach_error_string(errno)
+      ptr.null? ? nil : ptr.read_string()
+    end
+  end
+end

data/lib/mach/functions.rb

@@ -0,0 +1,342 @@
+require 'ffi'
+
+require 'mach/time_spec'
+
+module Mach
+  # FFI wrapper around a subset of the Mach API (likely Mac OS X
+  # specific).
+  module Functions
+    extend FFI::Library
+
+    ffi_lib 'c'
+
+    typedef :__darwin_mach_port_t, :mach_port_t
+    typedef :__darwin_natural_t, :natural_t
+
+    typedef :int, :integer_t
+    typedef :int, :kern_return_t # true for 64 bit??
+    typedef :int, :mach_error_t
+    typedef :int, :sync_policy_t # SyncPolicy
+    typedef :int, :clock_id_t
+    typedef :int, :clock_res_t
+
+    typedef :string, :name_t
+
+    typedef :mach_port_t, :host_t
+    typedef :mach_port_t, :task_t
+    typedef :mach_port_t, :ipc_space_t
+    typedef :mach_port_t, :semaphore_t
+    typedef :pointer, :mach_port_pointer_t
+
+    typedef :natural_t, :mach_port_name_t
+    typedef :natural_t, :mach_port_right_t # MachPortRight
+    typedef :pointer, :mach_port_name_array_t
+    typedef :pointer, :mach_port_name_pointer_t
+
+    typedef :uint, :mach_msg_type_name_t
+    typedef :uint, :mach_msg_bits_t
+    typedef :uint, :mach_msg_trailer_type_t
+    typedef :uint, :mach_msg_trailer_size_t
+    typedef :uint, :mach_msg_descriptor_type_t
+    typedef :natural_t, :mach_msg_timeout_t
+
+    typedef :natural_t, :mach_msg_size_t
+    typedef :integer_t, :mach_msg_id_t
+    typedef :integer_t, :mach_msg_options_t
+    typedef :integer_t, :mach_msg_option_t
+
+    class MsgHeader < FFI::Struct
+      layout(:bits, :mach_msg_bits_t,
+             :size, :mach_msg_size_t,
+             :remote_port, :mach_port_t,
+             :local_port, :mach_port_t,
+             :reserved, :mach_msg_size_t,
+             :id, :mach_msg_id_t)
+    end
+
+    class MsgBody < FFI::Struct
+      layout(:descriptor_count, :mach_msg_size_t)
+    end
+
+    class MsgBase < FFI::Struct
+      layout(:header, MsgHeader,
+             :body, MsgBody)
+    end
+
+    class MsgTrailer < FFI::Struct
+      layout(:type, :mach_msg_trailer_type_t,
+             :size, :mach_msg_trailer_size_t)
+    end
+
+    class MsgPortDescriptor < FFI::Struct
+      layout(:name, :mach_port_t,
+             :pad1, :mach_msg_size_t, # FIXME: leave oout on __LP64__
+             :pad2, :uint16, # :uint
+             :disposition, :uint8, # :mach_msg_type_name_t
+             :type, :uint8) # :mach_msg_descriptor_type_t
+    end
+
+    SyncPolicy = enum( :fifo, 0x0,
+                       :fixed_priority, 0x1,
+                       :reversed, 0x2,
+                       :order_mask, 0x3,
+                       :lifo, 0x0 | 0x2, # um...
+                       :max, 0x7 )
+
+    MachPortRight = enum( :send, 0,
+                          :receive,
+                          :send_once,
+                          :port_set,
+                          :dead_name,
+                          :labelh,
+                          :number )
+
+    # port type
+    def self.pt(*syms)
+      acc = 0
+      syms.each do |sym|
+        acc |= (1 << (MachPortRight[sym] + 16))
+      end
+      acc
+    end
+
+    MACH_PORT_NULL = 0
+    MACH_MSG_TIMEOUT_NONE = 0
+    
+    MachPortType =
+      enum(:none, 0,
+           :send, pt(:send),
+           :receive, pt(:receive),
+           :send_once, pt(:send_once),
+           :port_set, pt(:port_set),
+           :dead_name, pt(:dead_name),
+           :labelh, pt(:labelh),
+           
+           :send_receive, pt(:send, :receive),
+           :send_rights, pt(:send, :send_once),
+           :port_rights, pt(:send, :send_once, :receive),
+           :port_or_dead, pt(:send, :send_once, :receive, :dead_name),
+           :all_rights, pt(:send, :send_once, :receive, :dead_name, :port_set))
+
+    MachMsgType =
+      enum( :move_receive, 16, # must hold receive rights
+            :move_send,        # must hold send rights
+            :move_send_once,   # must hold sendonce rights
+            :copy_send,        # must hold send rights
+            :make_send,        # must hold receive rights
+            :make_send_once,   # must hold receive rights
+            :copy_receive )    # must hold receive rights
+
+    MachSpecialPort =
+      enum( :kernel, 1,
+            :host,
+            :name,
+            :bootstrap )
+
+    KERN_SUCCESS = 0
+
+    # Replace methods in +syms+ with error checking wrappers that
+    # invoke the original method and raise a {SystemCallError}.
+    #
+    # The original method is invoked, and it's return value is passed
+    # to the block (or a default check).  The block should return true
+    # if the return value indicates an error state.
+    def self.error_check(*syms, &is_err)
+      unless block_given?
+        is_err = lambda { |v| (v != KERN_SUCCESS) }
+      end
+
+      syms.each do |sym|
+        method = self.method(sym)
+
+        new_method_body = proc do |*args|
+          ret = method.call(*args)
+          if is_err.call(ret)
+            raise Error.new("error in #{sym}", ret)
+          else
+            ret
+          end
+        end
+
+        define_singleton_method(sym, &new_method_body)
+        define_method(sym, &new_method_body)
+       end
+    end
+
+    # Replace methods in +syms+ with error checking wrappers that
+    # invoke the original method and raise a {SystemCallError}.
+    #
+    # The original method is invoked, and it's return value is passed
+    # to the block (or a default check).  The block should return true
+    # if the return value indicates an error state.
+    def self.error_check_bootstrap(*syms, &is_err)
+      unless block_given?
+        is_err = lambda { |v| (v != KERN_SUCCESS) }
+      end
+
+      syms.each do |sym|
+        method = self.method(sym)
+
+        new_method_body = proc do |*args|
+          ret = method.call(*args)
+          if is_err.call(ret)
+            ptr = bootstrap_strerror(ret)
+            msg = ptr.null? ? nil : ptr.read_string()
+            raise "error in #{sym}: #{msg}"
+          else
+            ret
+          end
+        end
+        
+        define_singleton_method(sym, &new_method_body)
+        define_method(sym, &new_method_body)
+      end
+    end
+
+    # Attach a function as with +attach_function+, but check the
+    # return value and raise an exception on errors.
+    def self.attach_mach_function(sym, argtypes, rettype)
+      attach_function(sym, argtypes, rettype)
+      error_check(sym)
+    end
+
+    def self.new_memory_pointer(type)
+      FFI::MemoryPointer.new(find_type(type))
+    end
+
+    def new_memory_pointer(type)
+      Mach::Functions.new_memory_pointer(type)
+    end
+
+    attach_function :mach_task_self, [], :task_t
+    attach_function :mach_error_string, [:mach_error_t], :pointer
+
+    #######################
+    # Bootstrap functions #
+    #######################
+
+    attach_variable :bootstrap_port, :mach_port_t
+
+    attach_function(:bootstrap_strerror,
+                    [:kern_return_t],
+                    :pointer)
+
+    attach_function(:bootstrap_register,
+                    [:mach_port_t, :name_t, :mach_port_t],
+                    :kern_return_t)
+    error_check_bootstrap :bootstrap_register
+
+    ##################
+    # Port functions #
+    ##################
+
+    attach_mach_function(:mach_port_allocate,
+                         [:ipc_space_t,
+                          MachPortRight,
+                          :mach_port_name_pointer_t],
+                         :kern_return_t)
+    
+    attach_mach_function(:mach_port_destroy,
+                         [:ipc_space_t,
+                          :mach_port_name_t],
+                         :kern_return_t)
+    
+    attach_mach_function(:mach_port_deallocate,
+                         [:ipc_space_t,
+                          :mach_port_name_t],
+                         :kern_return_t)
+    
+    attach_mach_function(:mach_port_insert_right,
+                         [:ipc_space_t,
+                          :mach_port_name_t,
+                          :mach_port_t,
+                          MachMsgType],
+                         :kern_return_t)
+
+    ##################
+    # Host functions #
+    ##################
+
+    attach_function :mach_host_self, [], :mach_port_t
+
+    attach_mach_function(:host_get_clock_service,
+                         [:host_t,
+                          :clock_id_t,
+                          :pointer],
+                         :kern_return_t)
+
+    ##################
+    # Task functions #
+    ##################
+
+    attach_mach_function(:task_get_special_port,
+                         [:task_t,
+                          MachSpecialPort,
+                          :mach_port_pointer_t],
+                         :kern_return_t)
+
+    attach_mach_function(:task_set_special_port,
+                         [:task_t,
+                          MachSpecialPort,
+                          :mach_port_t],
+                         :kern_return_t)
+
+    ###################
+    # Clock functions #
+    ###################
+
+    attach_mach_function(:clock_get_time,
+                         [:clock_id_t,
+                          TimeSpec],
+                         :kern_return_t)
+
+    #####################
+    # Message functions #
+    #####################
+
+    attach_mach_function(:mach_msg_send,
+                         [:pointer], # msg_header_t
+                         :kern_return_t)
+
+    attach_mach_function(:mach_msg,
+                         [:pointer, # msg_header_t
+                          :mach_msg_option_t,
+                          :mach_msg_size_t,
+                          :mach_msg_size_t,
+                          :mach_port_name_t,
+                          :mach_msg_timeout_t,
+                          :mach_port_name_t],
+                         :kern_return_t)
+
+    attach_mach_function(:mach_msg_receive,
+                         [:pointer], # msg_header_t
+                         :kern_return_t)
+
+    #######################
+    # Semaphore functions #
+    #######################
+
+    attach_mach_function(:semaphore_create,
+                         [:task_t, :pointer, SyncPolicy, :int],
+                         :kern_return_t)
+    attach_mach_function(:semaphore_destroy,
+                         [:task_t, :semaphore_t],
+                         :kern_return_t)
+
+    attach_mach_function(:semaphore_signal,
+                         [:semaphore_t],
+                         :kern_return_t)
+    attach_mach_function(:semaphore_signal_all,
+                         [:semaphore_t],
+                         :kern_return_t)
+    attach_mach_function(:semaphore_wait,
+                         [:semaphore_t],
+                         :kern_return_t)
+    attach_mach_function(:semaphore_timedwait,
+                         [:semaphore_t, TimeSpec.val],
+                         :kern_return_t)
+
+  end
+end
+
+require 'mach/error'