ragweed 0.2.0-java

data/lib/ragweed/wraposx/thread_info.rb

@@ -0,0 +1,160 @@
+module Ragweed; end
+module Ragweed::Wraposx::ThreadInfo
+  # info interfaces
+  BASIC_INFO = 3  #basic information
+
+  # following are obsolete interfaces
+  # according to the source @ fxr they still work except FIFO
+  SCHED_TIMESHARE_INFO = 10
+  SCHED_RR_INFO = 11
+  # SCHED_FIFO_INFO = 12
+
+  module State
+    #Thread run states
+    RUNNING = 1 #/* thread is running normally */
+    STOPPED = 2 #/* thread is stopped */
+    WAITING = 3 #/* thread is waiting normally */
+    UNINTERRUPTIBLE = 4 #/* thread is in an uninterruptible wait */
+    HALTED = 5 #/* thread is halted at a clean point */
+  end
+
+  # struct thread_basic_info
+  # {
+  #        time_value_t     user_time;
+  #        time_value_t   system_time;
+  #        integer_t        cpu_usage;
+  #        policy_t            policy;
+  #        integer_t        run_state;
+  #        integer_t            flags;
+  #        integer_t    suspend_count;
+  #        integer_t       sleep_time;
+  # };
+  class Basic < FFI::Struct
+    include Ragweed::FFIStructInclude
+    module Flags
+      #Thread flags (flags field).
+      SWAPPED = 0x1 #/* thread is swapped out */
+      IDLE = 0x2 #/* thread is an idle thread */
+    end
+
+    FLAVOR = Ragweed::Wraposx::ThreadInfo::BASIC_INFO
+    layout :user_time, Ragweed::Wraposx::TimeValue,
+           :system_time, Ragweed::Wraposx::TimeValue,
+           :cpu_usage, :int,
+           :policy, Ragweed::Wraposx::Libc.find_type(:policy_t),
+           :run_state, :int,
+           :flags, :int,
+           :suspend_count, :int,
+           :sleep_time, :int
+
+    def dump(&block)
+      maybe_hex = lambda {|a| begin; "\n" + (" " * 9) + block.call(a, 16).hexdump(true)[10..-2]; rescue; ""; end }
+      maybe_dis = lambda {|a| begin; "\n" + block.call(a, 16).distorm.map {|i| "         " + i.mnem}.join("\n"); rescue; ""; end }
+
+      string =<<EOM
+      -----------------------------------------------------------------------
+      INFO:
+      user_time:     #{self.user_time.to_s.rjust(8, "0")} #{maybe_hex.call(self.user_time)}
+      system_time:   #{self.system_time.to_s.rjust(8, "0")} #{maybe_hex.call(self.system_time)}
+      cpu_usage:     #{self.cpu_usage.to_s.rjust(8, "0")} #{maybe_hex.call(self.cpu_usage)}
+      policy:        #{self.policy.to_s.rjust(8, "0")} #{maybe_hex.call(self.policy)}
+      run_state:     #{self.run_state.to_s.rjust(8, "0")} #{maybe_hex.call(self.run_state)}
+      suspend_count: #{self.suspend_count.to_s.rjust(8, "0")} #{maybe_hex.call(self.suspend_count)}
+      sleep_time:    #{self.sleep_time.to_s.rjust(8, "0")} #{maybe_hex.call(self.sleep_time)}
+      flags:         #{self.flags.to_s(2).rjust(32, "0")} #{Flags.flag_dump(self.flags)}
+EOM
+    end
+  end
+
+  # struct policy_timeshare_info
+  # {
+  #        int            max_priority;
+  #        int           base_priority;
+  #        int            cur_priority;
+  #        boolean_t         depressed;
+  #        int        depress_priority;
+  # };
+  class SchedTimeshare < FFI::Struct
+    include Ragweed::FFIStructInclude
+    layout :max_priority, :int,
+           :base_priority, :int,
+           :cur_priority, :int,
+           :depress_priority, :int
+
+    def dump(&block)
+      maybe_hex = lambda {|a| begin; "\n" + (" " * 9) + block.call(a, 16).hexdump(true)[10..-2]; rescue; ""; end }
+
+      string =<<EOM
+      -----------------------------------------------------------------------
+      Timeshare Info:
+      max_priority:     #{self.max_priority.to_s.rjust(8, "0")} #{maybe_hex.call(self.max_priority)}
+      base_priority:    #{self.base_priority.to_s.rjust(8, "0")} #{maybe_hex.call(self.base_priority)}
+      cur_priority:     #{self.cpu_usage.to_s.rjust(8, "0")} #{maybe_hex.call(self.cur_priority)}
+      depressed:        #{(!self.depressed.zero?).to_s.rjust(8, " ")} #{maybe_hex.call(self.depressed)}
+      depress_priority: #{self.depress_priority.to_s.rjust(8, "0")} #{maybe_hex.call(self.depressed_priority)}
+EOM
+    end
+  end
+
+  # struct policy_rr_info
+  # {
+  #        int          max_priority;
+  #        int         base_priority;
+  #        int               quantum;
+  #        boolean_t       depressed;
+  #        int      depress_priority;
+  # };
+  class SchedRr < FFI::Struct
+    include Ragweed::FFIStructInclude
+    layout :max_priority, :int,
+           :base_priority, :int,
+           :quantum, :int,
+           :depressed, Ragweed::Wraposx::Libc.find_type(:boolean_t),
+           :depress_priority, :int
+
+    def dump(&block)
+      maybe_hex = lambda {|a| begin; "\n" + (" " * 9) + block.call(a, 16).hexdump(true)[10..-2]; rescue; ""; end }
+
+      string =<<EOM
+      -----------------------------------------------------------------------
+      Round Robin Info:
+      max_priority:     #{self.max_priority.to_s.rjust(8, "0")} #{maybe_hex.call(self.max_priority)}
+      base_priority:    #{self.base_priority.to_s.rjust(8, "0")} #{maybe_hex.call(self.base_priority)}
+      quantum:          #{self.quantum.to_s.rjust(8, "0")} #{maybe_hex.call(self.quantum)}
+      depressed:        #{(!self.depressed.zero?).to_s.rjust(8, " ")} #{maybe_hex.call(self.depressed)}
+      depress_priority: #{self.depress_priority.to_s.rjust(8, "0")} #{maybe_hex.call(self.depressed_priority)}
+EOM
+    end
+  end
+
+  FLAVORS = {
+      # define THREAD_BASIC_INFO_COUNT   ((mach_msg_type_number_t)(sizeof(thread_basic_info_data_t) / sizeof(natural_t)))
+      BASIC_INFO => {:size => 30, :count => 10, :class => Basic},
+      # define POLICY_TIMESHARE_INFO_COUNT     ((mach_msg_type_number_t)(sizeof(struct policy_timeshare_info)/sizeof(integer_t)))
+      SCHED_TIMESHARE_INFO => {:size => 20, :count => 5, :class => SchedTimeshare},
+      # define POLICY_RR_INFO_COUNT    ((mach_msg_type_number_t)(sizeof(struct policy_rr_info)/sizeof(integer_t)))
+      SCHED_RR_INFO => {:size => 20,:count => 5, :class => SchedRr},
+      # define POLICY_FIFO_INFO_COUNT  ((mach_msg_type_number_t)(sizeof(struct policy_fifo_info)/sizeof(integer_t)))
+      # SCHED_FIFO_INFO => {:size => 16,:count => 4} # immediately returns KERNEL_INVALID_POLICY on osx
+  }
+end
+
+module Ragweed::Wraposx
+  class << self
+
+    # Returns the packed string representation of the thread_info_t struct for later parsing.
+    #
+    # kern_return_t   thread_info
+    #                (thread_act_t                     target_thread,
+    #                 thread_flavor_t                         flavor,
+    #                 thread_info_t                      thread_info,
+    #                 mach_msg_type_number_t       thread_info_count);
+    def thread_info(thread, flavor)
+      info = FFI::MemoryPointer.new(ThreadInfo::FLAVORS[flavor][:class], 1)
+      count = FFI::MemoryPointer.new(:int, 1).write_int(ThreadInfo::FLAVORS[flavor][:count])
+      r = Libc.thread_info(thread, flavor, info, count)
+      raise KernelCallError.new(r) if r != 0
+      ThreadInfo::FLAVORS[flavor][:class].new info
+    end
+  end
+end

data/lib/ragweed/wraposx/thread_info.rb.old

@@ -0,0 +1,121 @@
+module Ragweed; end
+module Ragweed::Wraposx::ThreadState
+  #Thread run states
+  RUNNING = 1 #/* thread is running normally */
+  STOPPED = 2 #/* thread is stopped */
+  WAITING = 3 #/* thread is waiting normally */
+  UNINTERRUPTIBLE = 4 #/* thread is in an uninterruptible wait */
+  HALTED = 5 #/* thread is halted at a clean point */
+end
+
+module Ragweed::Wraposx::TFlags
+  #Thread flags (flags field).
+  SWAPPED = 0x1 #/* thread is swapped out */
+  IDLE = 0x2 #/* thread is an idle thread */
+end
+    
+class Ragweed::Wraposx::ThreadInfo
+  include Ragweed
+  attr_accessor :user_time
+  attr_accessor :system_time
+  (FIELDS = [ [:user_time_s, "I"],
+              [:user_time_us, "I"],
+              [:system_time_s, "I"],
+              [:system_time_us, "I"],
+              [:cpu_usage, "I"],
+              [:policy, "I"],
+              [:run_state, "I"],
+              [:flags, "I"],
+              [:suspend_count, "I"],
+              [:sleep_time, "I"]]).each {|x| attr_accessor x[0]}
+
+  def initialize(str=nil)
+    refresh(str) if str
+  end
+
+  #(re)loads the data from str
+  def refresh(str)
+    if str and not str.empty?
+      str.unpack(FIELDS.map {|x| x[1]}.join("")).each_with_index do |val, i|
+        raise "i is nil" if i.nil?
+        instance_variable_set "@#{ FIELDS[i][0] }".intern, val
+      end
+    end
+    @user_time = @user_time_s + (@user_time_us/1000000.0)
+    @system_time = @system_time_s + (@system_time_us/1000000.0)
+  end
+
+  def to_s
+    FIELDS.map {|f| send(f[0])}.pack(FIELDS.map {|x| x[1]}.join(""))
+  end
+
+  def self.get(t)
+    self.new(Wraposx::thread_info_raw(t))
+  end
+
+  def get(t)
+    refresh(Wraposx::thread_info_raw(t))
+  end
+
+  def inspect
+    body = lambda do
+      FIELDS.map do |f|
+        "#{f[0]}=#{send(f[0]).to_s}"
+      end.join(", ")
+    end
+    "#<ThreadInfo #{body.call}>"
+  end
+
+  def dump(&block)
+    maybe_hex = lambda {|a| begin; "\n" + (" " * 9) + block.call(a, 16).hexdump(true)[10..-2]; rescue; ""; end }
+    maybe_dis = lambda {|a| begin; "\n" + block.call(a, 16).distorm.map {|i| "         " + i.mnem}.join("\n"); rescue; ""; end }
+
+    string =<<EOM
+    -----------------------------------------------------------------------
+    INFO:
+    user_time:     #{self.user_time.to_s.rjust(8, "0")} #{maybe_hex.call(self.user_time)}
+    system_time:   #{self.system_time.to_s.rjust(8, "0")} #{maybe_hex.call(self.system_time)}
+    cpu_usage:     #{self.cpu_usage.to_s.rjust(8, "0")} #{maybe_hex.call(self.cpu_usage)}
+    policy:        #{self.policy.to_s.rjust(8, "0")} #{maybe_hex.call(self.policy)}
+    run_state:     #{self.run_state.to_s.rjust(8, "0")} #{maybe_hex.call(self.run_state)}
+    suspend_count: #{self.suspend_count.to_s.rjust(8, "0")} #{maybe_hex.call(self.suspend_count)}
+    sleep_time:    #{self.sleep_time.to_s.rjust(8, "0")} #{maybe_hex.call(self.sleep_time)}
+    flags:         #{self.flags.to_s(2).rjust(32, "0")} #{Wraposx::TFlags.flag_dump(self.flags)}
+EOM
+  end
+end
+
+module Ragweed::Wraposx
+
+  # FIXME - constants should be under separate sub-modules
+  # XXX - implement more thread info flavors (if possible)
+  # XXX - move to class based implementation a la region_info
+  # info interfaces
+  THREAD_BASIC_INFO = 3  #basic information
+
+  # following are obsolete interfaces
+  THREAD_SCHED_TIMESHARE_INFO = 10
+  THREAD_SCHED_RR_INFO = 11
+  THREAD_SCHED_FIFO_INFO = 12
+
+  # define THREAD_BASIC_INFO_COUNT   ((mach_msg_type_number_t)(sizeof(thread_basic_info_data_t) / sizeof(natural_t)))
+  # the two time fields are each two ints
+  THREAD_BASIC_INFO_COUNT = 10
+
+  class << self
+
+    # Returns the packed string representation of the thread_info_t struct for later parsing.
+    # kern_return_t   thread_info
+    #                (thread_act_t                     target_thread,
+    #                 thread_flavor_t                         flavor,
+    #                 thread_info_t                      thread_info,
+    #                 mach_msg_type_number_t       thread_info_count);
+    def thread_info_raw(thread)
+      info = ("\x00"*1024).to_ptr
+      count = ([THREAD_BASIC_INFO_COUNT].pack("I_")).to_ptr
+      r = CALLS["libc!thread_info:IIPP=I"].call(thread,THREAD_BASIC_INFO,info,count).first
+      raise KernelCallError.new(:thread_info, r) if r != 0
+      return info.to_s(SIZEOFINT*THREAD_BASIC_INFO_COUNT)
+    end
+  end
+end

data/lib/ragweed/wraposx/wraposx.rb

@@ -0,0 +1,356 @@
+require 'ffi'
+
+module Ragweed; end
+module Ragweed::Wraposx
+
+  module Libc
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    typedef :int, :kern_return_t
+
+    typedef :ulong_long, :memory_object_offset_t
+    typedef :uint, :vm_inherit_t
+    typedef :uint, :natural_t
+    typedef :natural_t, :mach_msg_type_number_t
+    typedef :natural_t, :mach_port_name_t
+    typedef :mach_port_name_t, :mach_port_t
+    typedef :mach_port_t, :vm_map_t
+    typedef :mach_port_t, :task_t
+    typedef :mach_port_t, :thread_act_t
+    typedef :int, :vm_region_flavor_t
+    typedef :int, :vm_prot_t
+    typedef :int, :vm_behavior_t
+    typedef :int, :policy_t
+    typedef :int, :boolean_t
+    typedef :int, :thread_state_flavor_t
+    case FFI::Platform::LONG_SIZE
+    when 64
+      # ifdef __LP64__
+      typedef :uintptr_t, :vm_size_t
+      typedef :uintptr_t, :vm_offset_t
+    when 32
+      # else   /* __LP64__ */
+      typedef :natural_t, :vm_size_t
+      typedef :natural_t, :vm_offset_t
+    else
+      raise "Unsupported Platform"
+    end
+    
+    typedef :vm_offset_t, :vm_address_t
+    
+    attach_function :getpid, [], :pid_t
+    attach_function :ptrace, [:int, :pid_t, :ulong, :int], :int
+    attach_function :wait, [:pointer], :pid_t
+    attach_function :waitpid, [:pid_t, :pointer, :int], :pid_t
+    attach_function :mach_task_self, [], :mach_port_t
+    attach_function :task_for_pid, [:mach_port_name_t, :int, :pointer], :kern_return_t
+    attach_function :task_threads, [:task_t, :pointer, :pointer], :kern_return_t
+    attach_function :kill, [:pid_t, :int], :int
+    attach_function :vm_read_overwrite, [:vm_map_t, :vm_address_t, :vm_size_t, :vm_address_t, :pointer], :kern_return_t
+    attach_function :vm_write, [:vm_map_t, :vm_address_t, :vm_offset_t, :mach_msg_type_number_t], :kern_return_t
+    attach_function :vm_protect, [:vm_map_t, :vm_address_t, :vm_size_t, :boolean_t, :vm_prot_t], :kern_return_t
+    attach_function :vm_allocate, [:vm_map_t, :pointer, :vm_size_t, :int], :kern_return_t
+    attach_function :vm_deallocate, [:vm_map_t, :vm_address_t, :vm_size_t], :kern_return_t
+    attach_function :thread_resume, [:thread_act_t], :kern_return_t
+    attach_function :thread_suspend, [:thread_act_t], :kern_return_t
+    attach_function :task_suspend, [:int], :kern_return_t
+    attach_function :task_resume, [:int], :kern_return_t
+    attach_function :sysctl, [:pointer, :int, :pointer, :pointer, :pointer, :int], :int
+    attach_function :execv, [:string, :pointer], :int
+  end
+
+  class << self
+
+    # pid_t
+    # getpid(void);
+    #
+    # see also getpid(2)
+    def getpid
+      Libc.getpid
+    end
+
+    # Apple's ptrace is fairly gimped. The memory read and write functionality has been
+    # removed. We will be using mach kernel calls for that. see vm_read and vm_write.
+    # for details on ptrace and the process for the Wraposx/debuggerosx port see:
+    # http://www.matasano.com/log/1100/what-ive-been-doing-on-my-summer-vacation-or-it-has-to-work-otherwise-gdb-wouldnt/
+    #
+    #int
+    #ptrace(int request, pid_t pid, caddr_t addr, int data);
+    #
+    # see also ptrace(2)
+    def ptrace(request, pid, addr, data)
+      FFI.errno = 0
+      r = Libc.ptrace(request, pid, addr, data)
+      raise SystemCallError.new("ptrace", FFI.errno) if r == -1 and FFI.errno != 0
+      [r, data]
+    end
+
+    # ptrace(PT_TRACE_ME, ...)
+    def pt_trace_me pid
+      ptrace(Ragweed::Wraposx::Ptrace::TRACE_ME, pid, nil, nil).first
+    end
+
+    # ptrace(PT_DENY_ATTACH, ... )
+    def pt_deny_attach pid
+      ptrace(Ragweed::Wraposx::Ptrace::DENY_ATTACH, pid, nil, nil).first
+    end
+
+    # ptrace(PT_CONTINUE, pid, addr, signal)
+    def pt_continue pid, addr = 1, sig = 0
+      ptrace(Ragweed::Wraposx::Ptrace::CONTINUE, pid, addr, sig).first
+    end
+
+    # ptrace(PT_STEP, pid, addr, signal)
+    def pt_step pid, addr = 1, sig = 0
+      ptrace(Ragweed::Wraposx::Ptrace::STEP, pid, addr, sig).first
+    end
+
+    # ptrace(PT_KILL, ... )
+    def pt_kill pid
+      ptrace(Ragweed::Wraposx::Ptrace::KILL, pid, nil, nil).first
+    end
+
+    # ptrace(PT_ATTACH, ... )
+    def pt_attach pid
+      ptrace(Ragweed::Wraposx::Ptrace::ATTACH, pid, nil, nil).first
+    end
+
+    # ptrace(PT_DETACH, ... )
+    def pt_detach pid
+      ptrace(Ragweed::Wraposx::Ptrace::DETACH, pid, nil, nil).first
+    end
+
+    # Originally coded for use in debuggerosx but I've switched to waitpid for 
+    # usability and debugging purposes.
+    #
+    # Returns status of child when child recieves a signal.
+    #
+    # pid_t
+    # wait(int *stat_loc);
+    #
+    # see also wait(2)
+    def wait
+      stat = FFI::MemoryPointer.new :int, 1
+      FFI.errno = 0
+      pid = Libc.wait stat
+      raise SystemCallError.new "wait", FFI.errno if pid == -1
+      [pid, stat.read_int]
+    end
+
+    # The wait used in debuggerosx.
+    # opt is an OR of the options to be used.
+    #
+    # Returns an array. The first element is the pid of the child process
+    # as returned by the waitpid system call. The second, the status as
+    # an integer of that pid.
+    #
+    # pid_t
+    # waitpid(pid_t pid, int *stat_loc, int options);
+    #
+    # see also wait(2)
+    def waitpid pid, opts = 0
+      stat = FFI::MemoryPointer.new :int, 1
+      FFI.errno = 0
+      r = Libc.waitpid(pid, stat, opts)
+      raise SystemCallError.new "waitpid", FFI.errno if r == -1
+      [r, stat.read_int]
+    end
+
+    # From docs at http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/mach_task_self.html
+    # Returns send rights to the task's kernel port.
+    #
+    # mach_port_t
+    # mach_task_self(void)
+    #
+    # There is no man page for this call.
+    def mach_task_self
+      Libc.mach_task_self
+    end
+    
+    # Requires sudo to use as of 10.5 or 10.4.11(ish)
+    # Returns the task id for a process.
+    #
+    # kern_return_t task_for_pid(
+    #                           mach_port_name_t target_tport,
+    #                           int pid,
+    #                           mach_port_name_t *t);
+    #
+    # There is no man page for this call.
+    def task_for_pid(pid, target=nil)
+      target ||= mach_task_self
+      port = FFI::MemoryPointer.new :int, 1
+      r = Libc.task_for_pid(target, pid, port)
+      raise KernelCallError.new(:task_for_pid, r) if r != 0
+      port.read_int
+    end  
+
+    # Returns an Array of thread IDs for the given task
+    #
+    # kern_return_t   task_threads
+    #                (task_t                                    task,
+    #                 thread_act_port_array_t            thread_list,
+    #                 mach_msg_type_number_t*           thread_count);
+    #
+    #There is no man page for this funtion.    
+    def task_threads(port)
+      threads = FFI::MemoryPointer.new :int, 1
+      count = FFI::MemoryPointer.new :int, 1
+      r = Libc.task_threads(port, threads, count)
+      raise KernelCallError.new(:task_threads, r) if r != 0
+      threads.read_array_of_int(count.read_int)
+    end
+
+    # Decrement the target tasks suspend count
+    # kern_return_t   task_resume
+    #                 (task_t          task);
+    def task_resume(task)
+      r = Libc.task_resume(task)
+      raise KernelCallError.new(r) if r != 0
+      r
+    end
+
+    # Increment the target tasks suspend count
+    # kern_return_t   task_suspend
+    #                 (task_t          task);
+    def task_suspend(task)
+      r = Libc.task_suspend(task)
+      raise KernelCallError.new(r) if r != 0
+    end
+
+    # Sends a signal to a process
+    #
+    # int
+    # kill(pid_t pid, int sig);
+    #
+    # See kill(2)
+    def kill(pid, sig)
+      FFI::errno = 0
+      r = Libc.kill(pid, sig)
+      raise SystemCallError.new "kill", FFI::errno if r != 0
+    end
+
+    # Reads sz bytes from task's address space starting at addr.
+    #
+    # kern_return_t   vm_read_overwrite
+    #                (vm_task_t                           target_task,
+    #                 vm_address_t                        address,
+    #                 vm_size_t                           size,
+    #                 vm_address_t                        *data_out,
+    #                 mach_msg_type_number_t              *data_size);
+    #
+    # There is no man page for this function.
+    def vm_read(task, addr, sz=256)
+      buf = FFI::MemoryPointer.new(sz)
+      len = FFI::MemoryPointer(sz.to_l32)
+      r = Libc.vm_read_overwrite(task, addr, sz, buf, len)
+      raise KernelCallError.new(:vm_read, r) if r != 0
+      return buf.to_str(len.to_str(4).to_l32)
+    end
+
+    # Writes val to task's memory space at address addr.
+    # It is necessary for val.size to report the size of val in bytes
+    #
+    # kern_return_t   vm_write
+    #                (vm_task_t                          target_task,
+    #                 vm_address_t                           address,
+    #                 pointer_t                                 data,
+    #                 mach_msg_type_number_t              data_count);
+    #
+    # There is no man page for this function.
+    def vm_write(task, addr, val)
+      val = FFI::MemoryPointer.new
+      r = Libc.vm_write(task, addr, val, val.size)
+      raise KernelCallError.new(:vm_write, r) if r != 0
+      return nil
+    end
+
+    # Changes the protection state beginning at addr for size bytes to the mask prot.
+    # If setmax is true this will set the maximum permissions, otherwise it will set FIXME
+    #
+    # kern_return_t   vm_protect
+    #                 (vm_task_t           target_task,
+    #                  vm_address_t            address,
+    #                  vm_size_t                  size,
+    #                  boolean_t           set_maximum,
+    #                  vm_prot_t        new_protection);
+    #
+    # There is no man page for this function.
+    def vm_protect(task, addr, size, setmax, prot)
+      setmax = setmax ? 1 : 0
+      r = Libc.vm_protect(task, addr, size, setmax, prot)
+      raise KernelCallError.new(:vm_protect, r) if r != 0
+      return nil
+    end
+
+    # Allocates a page in the memory space of the target task.
+    #
+    # kern_return_t   vm_allocate
+    #                 (vm_task_t                          target_task,
+    #                  vm_address_t                           address,
+    #                  vm_size_t                                 size,
+    #                  boolean_t                             anywhere);
+    #
+    def vm_allocate(task, address, size, anywhere)
+      addr = FFI::MemoryPointer.new :int, 1
+      addr.write_int(address)
+      anywhere = anywhere ? 1 : 0
+      r = Libc.vm_allocate(task, addr, size, anywhere)
+      raise KernelCallError.new(r) if r != 0
+      addr.address
+    end
+
+    # deallocates a page in the memoryspace of target task.
+    #
+    # kern_return_t   vm_deallocate
+    #                     (vm_task_t                          target_task,
+    #                      vm_address_t                           address,
+    #                      vm_size_t                                 size);
+    #
+    def vm_deallocate(task, address, size)
+      addr = FFI::MemoryPointer.new :int, 1
+      addr.write_int(address)
+      r = Libc.vm_deallocate(task, addr, size)
+      raise KernelCallError.new(r) if r != 0
+    end
+
+    # Resumes a suspended thread by id.
+    #
+    # kern_return_t   thread_resume
+    #                (thread_act_t                     target_thread);
+    #
+    # There is no man page for this function.
+    def thread_resume(thread)
+      r = Libc.thread_resume(thread)
+      raise KernelCallError.new(:thread_resume, r) if r != 0
+    end
+
+    # Suspends a thread by id.
+    #
+    # kern_return_t   thread_suspend
+    #                (thread_act_t                     target_thread);
+    #
+    # There is no man page for this function.
+    def thread_suspend(thread)
+      r = Libc.thread_suspend(thread)
+      raise KernelCallError.new(:thread_suspend, r) if r != 0
+    end
+
+    # Changes execution to file in path with *args as though called from command line.
+    #
+    # int
+    # execv(const char *path, char *const argv[]);
+    def execv(path, *args)
+      FFI.errno = 0
+      args.flatten!
+      argv = FFI::MemoryPointer.new(:pointer, args.size + 1)
+      args.each_with_index do |arg, i|
+        argv[i].put_pointer(0, FFI::MemoryPointer.from_string(arg.to_s))
+      end
+      argv[args.size].put_pointer(0, nil)
+
+      r = Libc.execv(path, argv)
+      # if this ever returns, there's been an error
+      raise SystemCallError(:execv, FFI.errno)
+    end
+  end
+end

data/lib/ragweed/wraposx.rb

@@ -0,0 +1,60 @@
+# Dir[File.expand_path("#{File.dirname(__FILE__)}/wraposx/*.rb")].each do |file|
+#   require file
+# end
+module Ragweed; end
+module Ragweed::Wraposx
+
+  # :stopdoc:
+  VERSION = File.read(File.join(File.dirname(__FILE__),"..","..","VERSION")).strip
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility function to load utility classes and extensions
+  def self.require_utils
+    %w{utils}.each{|r| require self.libpath(r)+'.rb'}
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    self.require_utils
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+    
+    Dir.glob(search_me).reject{|rb| rb =~ /#{__FILE__}/}.sort.each {|rb| require rb}
+    # require File.dirname(File.basename(__FILE__)) + "/#{x}"
+
+  end
+end  # module Ragweed::Wraposx
+
+require 'ragweed/wraposx/wraposx'
+Ragweed::Wraposx.require_all_libs_relative_to(__FILE__)
+
+# EOF