ragweed 0.2.0-java

data/lib/ragweed/wraposx/constants.rb

@@ -0,0 +1,114 @@
+module Ragweed; end
+module Ragweed::Wraposx;end
+module Ragweed::Wraposx::Ptrace
+  TRACE_ME = 0 # child declares it's being traced
+  #(READ|WRITE)_[IDU] are not valid in OSX but defined in ptrace.h
+  READ_I = 1 # read word in child's I space
+  READ_D = 2 # read word in child's D space
+  READ_U = 3 # read word in child's user structure
+  WRITE_I = 4 # write word in child's I space
+  WRITE_D = 5 # write word in child's D space
+  WRITE_U = 6 # write word in child's user structure
+  CONTINUE = 7 # continue the child
+  KILL = 8 # kill the child process
+  STEP = 9 # single step the child
+  ATTACH = 10 # trace some running process
+  DETACH = 11 # stop tracing a process
+  SIGEXC = 12 # signals as exceptions for current_proc
+  THUPDATE = 13 # signal for thread
+  ATTACHEXC = 14 # attach to running process with signal exception
+  FORCEQUOTA = 30 # Enforce quota for root
+  DENY_ATTACH = 31 #Prevent process from being traced
+  FIRSTMACH = 32 # for machine-specific requests
+end
+
+module Ragweed::Wraposx::Signal
+  # the Ruby module Signal also has this information.
+  # in reality, that is a better source since it's based on the signals
+  # available at the time ruby was compiled.
+  SIGHUP = 1 # hangup
+  SIGINT = 2 # interrupt
+  SIGQUIT = 3 # quit
+  SIGILL = 4 # illegal instruction (not reset when caught)
+  SIGTRAP = 5 # trace trap (not reset when caught)
+  SIGABRT = 6 # abort()
+  #if  (defined(_POSIX_C_SOURCE) && !defined(_DARWIN_C_SOURCE))
+  SIGPOLL = 7 # pollable event ([XSR] generated, not supported)
+  #else	/* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+  SIGIOT = SIGABRT # compatibility
+  SIGEMT = 7 # EMT instruction
+  #endif	/* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+  SIGFPE = 8 # floating point exception
+  SIGKILL = 9 # kill (cannot be caught or ignored)
+  SIGBUS = 10 # bus error
+  SIGSEGV = 11 # segmentation violation
+  SIGSYS = 12 # bad argument to system call
+  SIGPIPE = 13 # write on a pipe with no one to read it
+  SIGALRM = 14 # alarm clock
+  SIGTERM = 15 # software termination signal from kill
+  SIGURG = 16 # urgent condition on IO channel
+  SIGSTOP = 17 # sendable stop signal not from tty
+  SIGTSTP = 18 # stop signal from tty
+  SIGCONT = 19 # continue a stopped process
+  SIGCHLD = 20 # to parent on child stop or exit
+  SIGTTIN = 21 # to readers pgrp upon background tty read
+  SIGTTOU = 22 # like TTIN for output if (tp->t_local&LTOSTOP)
+  #if  (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
+  SIGIO = 23 # input/output possible signal
+  #endif
+  SIGXCPU = 24 # exceeded CPU time limit
+  SIGXFSZ = 25 # exceeded file size limit
+  SIGVTALRM = 26 # virtual time alarm
+  SIGPROF = 27 # profiling time alarm
+  #if  (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
+  SIGWINCH = 28 # window size changes
+  SIGINFO = 29 # information request
+  #endif
+  SIGUSR1 = 30 # user defined signal 1
+  SIGUSR2 = 31 # user defined signal 2
+end
+
+module Ragweed::Wraposx::Wait
+  NOHANG = 0x01 # [XSI] no hang in wait/no child to reap
+  UNTRACED = 0x02 # [XSI] notify on stop, untraced child
+  EXITED = 0x04 # [XSI] Processes which have exitted
+  STOPPED = 0x08 # [XSI] Any child stopped by signal
+  CONTINUED = 0x10 # [XSI] Any child stopped then continued
+  NOWWAIT = 0x20 # [XSI] Leave process returned waitable
+end
+
+module Ragweed::Wraposx::Vm; end
+module Ragweed::Wraposx::Vm::Prot
+  # vm_protect permission flags for memory spaces
+  READ = 0x1 #read permission
+  WRITE = 0x2 #write permission
+  EXECUTE = 0x4 #execute permission
+  NONE = 0x0 #no rights
+  ALL = 0x7 #all permissions
+end
+
+module Ragweed::Wraposx::Vm::Sm
+  # share mode constants
+  COW = 1
+  PRIVATE = 2
+  EMPTY = 3
+  SHARED = 4
+  TRUESHARED = 5
+  PRIVATE_ALIASED = 6
+  SHARED_ALIASED = 7
+end
+
+module Ragweed::Wraposx::Dl
+  RTLD_LAZY = 0x1
+  RTLD_NOW = 0x2
+  RTLD_LOCAL = 0x4
+  RTLD_GLOBAL = 0x8
+  RTLD_NOLOAD = 0x10
+  RTLD_NODELETE = 0x80
+  RTLD_FIRST = 0x100	#/* Mac OS X 10.5 and later */
+
+  # Special handle arguments for dlsym().
+  #define RTLD_NEXT		((void *) -1)	/* Search subsequent objects. */
+  #define	RTLD_DEFAULT	((void *) -2)	/* Use default search algorithm. */
+  #define	RTLD_SELF		((void *) -3)	/* Search this and subsequent objects (Mac OS X 10.5 and later) */
+end

data/lib/ragweed/wraposx/kernelerrorx.rb

@@ -0,0 +1,147 @@
+# Exception objects for kernel errors likely in Wraposx
+# If this were a C extension I'd use #ifdef on each to only create the required ones.
+
+module Ragweed; end
+module Ragweed::Wraposx; end
+module Ragweed::Wraposx::KernelReturn
+  SUCCESS =               { :value => 0, :message => 'Not an error'}
+  INVALID_ADDRESS =       { :value => 1, :message => 'Specified address is not currently valid.'}
+  PROTECTION_FAILURE =    { :value => 2, :message => 'Specified memory is valid, but does not permit the required forms of access.'}
+  NO_SPACE =              { :value => 3, :message => 'The address range specified is already in use, or no address range of the size specified could be found.'}
+  INVALID_ARGUMENT =      { :value => 4, :message => 'The function requested was not applicable to this type of argument, or an argument is invalid'}
+  FAILURE =               { :value => 5, :message => 'The function could not be performed.  A catch-all.'}
+  RESOURCE_SHORTAGE =     { :value => 6, :message => 'A system resource could not be allocated to fulfill this request.  This failure may not be permanent.'}
+  NOT_RECEIVER =          { :value => 7, :message => 'The task in question does not hold receive rights for the port argument.'}
+  NO_ACCESS =             { :value => 8, :message => 'Bogus access restriction.'}
+  MEMORY_FAILURE =        { :value => 9, :message => 'During a page fault, the target address refers to a memory object that has been destroyed.  This failure is permanent.'}
+  MEMORY_ERROR =          { :value => 10, :message => 'During a page fault, the memory object indicated that the data could not be returned.  This failure may be temporary; future attempts to access this same data may succeed, as defined by the memory object.'}
+  ALREADY_IN_SET =        { :value => 11, :message => 'The receive right is already a member of the portset.'}
+  NOT_IN_SET =            { :value => 12, :message => 'The receive right is not a member of a port set.'}
+  NAME_EXISTS =           { :value => 13, :message => 'The name already denotes a right in the task.'}
+  ABORTED =               { :value => 14, :message => 'The operation was aborted.  Ipc code will catch this and reflect it as a message error.'}
+  INVALID_NAME =          { :value => 15, :message => 'The name doesn\'t denote a right in the task.'}
+  INVALID_TASK =          { :value => 16, :message => 'Target task isn\'t an active task.'}
+  INVALID_RIGHT =         { :value => 17, :message => 'The name denotes a right, but not an appropriate right.'}
+  INVALID_VALUE =         { :value => 18, :message => 'A blatant range error.'}
+  UREFS_OVERFLOW =        { :value => 19, :message => 'Operation would overflow limit on user-references.'}
+  INVALID_CAPABILITY =    { :value => 20, :message => 'The supplied (port) capability is improper.'}
+  RIGHT_EXISTS =          { :value => 21, :message => 'The task already has send or receive rights for the port under another name.'}
+  INVALID_HOST =          { :value => 22, :message => 'Target host isn\'t actually a host.'}
+  MEMORY_PRESENT =        { :value => 23, :message => 'An attempt was made to supply "precious" data for memory that is already present in a memory object.'}
+  MEMORY_DATA_MOVED =     { :value => 24, :message => 'A page was requested of a memory manager via memory_object_data_request for an object using a MEMORY_OBJECT_COPY_CALL strategy, with the VM_PROT_WANTS_COPY flag being used to specify that the page desired is for a copy of the object, and the memory manager has detected the page was pushed into a copy of the object while the kernel was walking the shadow chain from the copy to the object. This error code is delivered via memory_object_data_error and is handled by the kernel (it forces the kernel to restart the fault). It will not be seen by users.'}
+  MEMORY_RESTART_COPY =   { :value => 25, :message => 'A strategic copy was attempted of an object upon which a quicker copy is now possible. The caller should retry the copy using vm_object_copy_quickly. This error code is seen only by the kernel.'}
+  INVALID_PROCESSOR_SET = { :value => 26, :message => 'An argument applied to assert processor set privilege was not a processor set control port.'}
+  POLICY_LIMIT =          { :value => 27, :message => 'The specified scheduling attributes exceed the thread\'s limits.'}
+  INVALID_POLICY =        { :value => 28, :message => 'The specified scheduling policy is not currently enabled for the processor set.'}
+  INVALID_OBJECT =        { :value => 29, :message => 'The external memory manager failed to initialize the memory object.'}
+  ALREADY_WAITING =       { :value => 30, :message => 'A thread is attempting to wait for an event for which  there is already a waiting thread.'}
+  DEFAULT_SET =           { :value => 31, :message => 'An attempt was made to destroy the default processor set.'}
+  EXCEPTION_PROTECTED =   { :value => 32, :message => 'An attempt was made to fetch an exception port that is protected, or to abort a thread while processing a protected exception.'}
+  INVALID_LEDGER =        { :value => 33, :message => 'A ledger was required but not supplied.'}
+  INVALID_MEMORY_CONTROL= { :value => 34, :message => 'The port was not a memory cache control port.'}
+  INVALID_SECURITY =      { :value => 35, :message => 'An argument supplied to assert security privilege was not a host security port.'}
+  NOT_DEPRESSED =         { :value => 36, :message => 'thread_depress_abort was called on a thread which was not currently depressed.'}
+  TERMINATED =            { :value => 37, :message => 'Object has been terminated and is no longer available'}
+  LOCK_SET_DESTROYED =    { :value => 38, :message => 'Lock set has been destroyed and is no longer available.'}
+  LOCK_UNSTABLE =         { :value => 39, :message => 'The thread holding the lock terminated before releasing the lock'}
+  LOCK_OWNED =            { :value => 40, :message => 'The lock is already owned by another thread'}
+  LOCK_OWNED_SELF =       { :value => 41, :message => 'The lock is already owned by the calling thread'}
+  SEMAPHORE_DESTROYED =   { :value => 42, :message => 'Semaphore has been destroyed and is no longer available.'}
+  RPC_SERVER_TERMINATED = { :value => 43, :message => 'Return from RPC indicating the target server was terminated before it successfully replied '}
+  RPC_TERMINATE_ORPHAN =  { :value => 44, :message => 'Terminate an orphaned activation.'}
+  RPC_CONTINUE_ORPHAN =   { :value => 45, :message => 'Allow an orphaned activation to continue executing.'}
+  NOT_SUPPORTED =         { :value => 46, :message => 'Empty thread activation (No thread linked to it)'}
+  NODE_DOWN =             { :value => 47, :message => 'Remote node down or inaccessible.'}
+  NOT_WAITING =           { :value => 48, :message => 'A signalled thread was not actually waiting.'}
+  OPERATION_TIMED_OUT =   { :value => 49, :message => 'Some thread-oriented operation (semaphore_wait) timed out'}
+  RETURN_MAX =            { :value => 0x100, :message => 'Maximum return value allowable'}
+  
+  module_function
+  # Much like Signals.list returns a hash of the possible kernel call return values.
+  def list
+    @@list ||= constants.inject({}){|a, c| a.merge! c => const_get(c)}
+  end
+end
+
+module Ragweed::Wraposx::KErrno; end
+
+# Exception class for mach kernel calls. Works mostly like SystemCallError.
+# Subclasses are individual error conditions and case equality (===) is done by class then error number (KErrno)
+class Ragweed::Wraposx::KernelCallError < StandardError
+  DEFAULT_MESSAGE = "Unknown Error"
+  attr_reader :kerrno
+  
+  # Returns a subclass of KernelCallError based on the KernelReturn value err
+  def self.new(msg = "", err = nil)
+    if msg.kind_of? Fixnum
+      err = msg
+      msg = ""
+    end
+    mesg = ""
+
+    klass = Ragweed::Wraposx::KErrno.constants.detect{|x| Ragweed::Wraposx::KErrno.const_get(x).const_get("KErrno") == err}
+    if (klass.nil? or klass.empty?)
+      o = self.allocate
+      o.instance_variable_set("@kerrno", err)
+      mesg = "Unknown kernel error"
+    else
+      o = Ragweed::Wraposx::KErrno.const_get(klass).allocate
+      mesg = Ragweed::Wraposx::KernelReturn.const_get(klass)[:message]
+    end
+    
+    if o.class.const_defined?("KErrno")
+      o.instance_variable_set("@kerrno", o.class.const_get("KErrno"))
+    else
+      o.instance_variable_set("@kerrno", err)
+      mesg = "#{mesg}: #{err}" if err
+    end
+
+    mesg = "#{mesg} - #{msg}" if !(msg.nil? or msg.to_s.empty?)  
+    o.send(:initialize, mesg)
+    return o
+  end
+
+  # Case equality. Returns true if self and other are KernelCallError or when error numbers match.
+  def self.===(other)
+    return false if not other.kind_of?(Ragweed::Wraposx::KernelCallError)
+    return true if self == Ragweed::Wraposx::KernelCallError
+    
+    begin
+      return self.const_get("KErrno") == other.const_get("KErrno")
+    rescue
+      return false
+    end
+  end
+
+  def initialize(msg)
+    super msg
+  end
+
+  # This block builds the subclasses for KernelCallError
+  Ragweed::Wraposx::KernelReturn.list.each do |k, v|
+    case k.intern
+    when :SUCCESS
+    when :RETURN_MAX
+    else
+      klass = Ragweed::Wraposx::KErrno.const_set(k, Class.new(Ragweed::Wraposx::KernelCallError){
+        def self.new(msg = "")
+          o = self.allocate
+          o.instance_variable_set "@kerrno", self.const_get("KErrno")
+          mesg = ""
+          klass = self.name.split("::").last
+          if Ragweed::Wraposx::KernelReturn.const_defined?(klass)
+            mesg = Ragweed::Wraposx::KernelReturn.const_get(klass)[:message]
+          else
+            mesg = "Unknown kernel error"
+          end
+          mesg = "#{mesg} - #{msg}" if not (msg.nil? or msg.empty?)
+          o.send(:initialize, mesg)
+          puts self
+          return o
+        end
+      })
+      klass.const_set "KErrno", v[:value]
+      klass.const_set "DEFAULT_MESSAGE", v[:message]
+    end
+  end
+end

data/lib/ragweed/wraposx/region_info.rb

@@ -0,0 +1,275 @@
+module Ragweed; end
+module Ragweed::Wraposx; end
+module Ragweed::Wraposx::Vm
+  # these are flavor arguments for vm_region
+  # only basic info is supported by apple
+  REGION_BASIC_INFO_64 = 9
+  REGION_BASIC_INFO = 10
+  REGION_EXTENDED_INFO = 11
+  REGION_TOP_INFO = 12
+
+  # behavior identifiers
+  BEHAVIOR_DEFAULT = 0    # /* default */
+  BEHAVIOR_RANDOM = 1     # /* random */
+  BEHAVIOR_SEQUENTIAL = 2 # /* forward sequential */
+  BEHAVIOR_RSEQNTL = 3    # /* reverse sequential */
+  BEHAVIOR_WILLNEED = 4   # /* will need in near future */
+  BEHAVIOR_DONTNEED = 5   # /* dont need in near future */
+
+  #Virtual memory map inheritance values for vm_inherit_t
+  INHERIT_SHARE = 0       # /* share with child */
+  INHERIT_COPY = 1        # /* copy into child */
+  INHERIT_NONE = 2        # /* absent from child */
+  INHERIT_DONATE_COPY = 3 # /* copy and delete */
+  INHERIT_DEFAULT = 1     # VM_INHERIT_COPY
+  INHERIT_LAST_VALID = 2  # VM_INHERIT_NONE
+
+  module Pflags
+    READ = 0x1 #read permission
+    WRITE = 0x2 #write permission
+    EXECUTE = 0x4 #execute permission
+  end
+
+  # Memory region info base class.
+  #
+  class RegionInfo < FFI::Struct
+    include Ragweed::FFIStructInclude
+    attr_accessor :region_size
+    attr_accessor :base_address
+  end
+
+  class RegionBasicInfo < RegionInfo
+
+    layout :protection, Ragweed::Wraposx::Libc.find_type(:vm_prot_t),
+           :max_protection, Ragweed::Wraposx::Libc.find_type(:vm_prot_t),
+           :inheritance, Ragweed::Wraposx::Libc.find_type(:vm_inherit_t),
+           :shared, Ragweed::Wraposx::Libc.find_type(:boolean_t),
+           :reserved, Ragweed::Wraposx::Libc.find_type(:boolean_t),
+           :offset, :uint32,
+           :behavior, Ragweed::Wraposx::Libc.find_type(:vm_behavior_t),
+           :user_wired_count, :ushort
+
+
+    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
+      -----------------------------------------------------------------------
+      BASIC INFO:
+      base address:     #{self.base_address.to_s(16).rjust(8, "0")}
+    
+      protection:       #{self.protection.to_s(2).rjust(8, "0")} #{Ragweed::Wraposx::Vm::Pflags.flag_dump(self.protection)}
+      max_protection:   #{self.max_protection.to_s(2).rjust(8, "0")} #{Ragweed::Wraposx::Vm::Pflags.flag_dump(self.max_protection)}
+      inheritance:      #{self.inheritance.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.inheritance)}
+      shared:           #{self.shared.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.shared)}
+      reserved:         #{self.reserved.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.reserved)}
+      offset:           #{self.offset.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.offset)}
+      behavior:         #{self.behavior.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.behavior)}
+      user_wired_count: #{self.user_wired_count.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.user_wired_count)}
+      size:             #{self.size.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.size)}
+EOM
+    end
+  end
+
+  class RegionBasicInfo64 < RegionInfo
+
+    layout :protection, Ragweed::Wraposx::Libc.find_type(:vm_prot_t),
+           :max_protection, Ragweed::Wraposx::Libc.find_type(:vm_prot_t),
+           :inheritance, Ragweed::Wraposx::Libc.find_type(:vm_inherit_t),
+           :shared, Ragweed::Wraposx::Libc.find_type(:boolean_t),
+           :reserved, Ragweed::Wraposx::Libc.find_type(:boolean_t),
+           :offset, Ragweed::Wraposx::Libc.find_type(:memory_object_offset_t),
+           :behavior, Ragweed::Wraposx::Libc.find_type(:vm_behavior_t),
+           :user_wired_count, :ushort
+
+    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
+      -----------------------------------------------------------------------
+      BASIC INFO:
+      base address:     #{self.base_address.to_s(16).rjust(8, "0")}
+    
+      protection:       #{self.protection.to_s(2).rjust(8, "0")} #{Ragweed::Wraposx::Vm::Pflags.flag_dump(self.protection)}
+      max_protection:   #{self.max_protection.to_s(2).rjust(8, "0")} #{Ragweed::Wraposx::Vm::Pflags.flag_dump(self.max_protection)}
+      inheritance:      #{self.inheritance.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.inheritance)}
+      shared:           #{self.shared.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.shared)}
+      reserved:         #{self.reserved.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.reserved)}
+      offset:           #{self.offset.to_s(16).rjust(16, "0")} #{maybe_hex.call(self.offset)}
+      behavior:         #{self.behavior.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.behavior)}
+      user_wired_count: #{self.user_wired_count.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.user_wired_count)}
+      size:             #{self.size.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.size)}
+EOM
+    end
+  end
+
+  # struct vm_region_extended_info {
+  #         vm_prot_t               protection;
+  #         unsigned int            user_tag;
+  #         unsigned int            pages_resident;
+  #         unsigned int            pages_shared_now_private;
+  #         unsigned int            pages_swapped_out;
+  #         unsigned int            pages_dirtied;
+  #         unsigned int            ref_count;
+  #         unsigned short          shadow_depth;
+  #         unsigned char           external_pager;
+  #         unsigned char           share_mode;
+  # };
+  class RegionExtendedInfo < RegionInfo
+    layout :protection, Ragweed::Wraposx::Libc.find_type(:vm_prot_t),
+           :user_tag, :uint,
+           :pages_resident, :uint,
+           :pages_shared_now_private, :uint,
+           :pages_swapped_out, :uint,
+           :pages_dirtied, :uint,
+           :ref_count, :uint,
+           :shadow_depth, :ushort,
+           :external_pager, :uchar,
+           :share_mode, :uchar
+
+    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
+      -----------------------------------------------------------------------
+      EXTENDED INFO:
+      base address:             #{self.base_address.to_s(16).rjust(8, "0")}
+    
+      protection:               #{self.protection.to_s(2).rjust(8, "0")} #{Ragweed::Wraposx::Vm::Pflags.flag_dump(self.protection)}
+      user_tag:                 #{self.user_tag.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.user_tag)}
+      pages_resident:           #{self.pages_resident.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.pages_resident)}
+      pages_shared_now_private: #{self.pages_shared_now_private.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.pages_shared_now_private)}
+      pages_swapped_out:        #{self.pages_swapped_out.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.pages_swapped_out)}
+      pages_dirtied:            #{self.pages_dirtied.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.pages_dirtied)}
+      ref_count:                #{self.ref_count.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.ref_count)}
+      shadow_depth:             #{self.shadow_depth.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.shadow_depth)}
+      external_pager:           #{self.external_pager.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.external_pager)}
+      share_mode:               #{self.share_mode.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.share_mode)}
+      size:                     #{self.size.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.size)}
+EOM
+    end
+  end
+
+  # struct vm_region_top_info {
+  #         unsigned int            obj_id;
+  #         unsigned int            ref_count;
+  #         unsigned int            private_pages_resident;
+  #         unsigned int            shared_pages_resident;
+  #         unsigned char           share_mode;
+  # };
+  class RegionTopInfo < RegionInfo
+    layout :obj_id, :uint,
+           :ref_count, :uint,
+           :private_pages_resident, :uint,
+           :shared_pages_resident, :uint,
+           :share_mode, :uchar
+
+    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
+      -----------------------------------------------------------------------
+      TOP INFO:
+      base address:           #{self.base_address.to_s(16).rjust(8, "0")}
+    
+      obj_id:                 #{self.obj_id.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.obj_id)}
+      ref_count:              #{self.ref_count.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.ref_count)}
+      private_pages_resident: #{self.private_pages_resident.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.private_pages_resident)}
+      shared_pages_resident:  #{self.shared_pages_resident.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.shared_pages_resident)}
+      share_mode:             #{self.share_mode.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.share_mode)}
+      size:                   #{self.size.to_s(16).rjust(8, "0")} #{maybe_hex.call(self.size)}
+EOM
+    end
+  end
+
+  #define VM_REGION_BASIC_INFO_COUNT ((mach_msg_type_number_t) (sizeof(vm_region_basic_info_data_t)/sizeof(int)))
+  #define VM_REGION_BASIC_INFO_COUNT_64 ((mach_msg_type_number_t) (sizeof(vm_region_basic_info_data_64_t)/sizeof(int)))
+  #define VM_REGION_EXTENDED_INFO_COUNT   ((mach_msg_type_number_t) (sizeof(vm_region_extended_info_data_t)/sizeof(int)))
+  #define VM_REGION_TOP_INFO_COUNT ((mach_msg_type_number_t) (sizeof(vm_region_top_info_data_t)/sizeof(int)))
+  FLAVORS = { REGION_BASIC_INFO => {:size => 30, :count => 8, :class => RegionBasicInfo},
+      REGION_BASIC_INFO_64 => {:size => 30, :count => 9, :class => RegionBasicInfo64},
+      REGION_EXTENDED_INFO => {:size => 32, :count => 8, :class => RegionExtendedInfo},
+      REGION_TOP_INFO => {:size => 17,:count => 5, :class => RegionTopInfo}
+  }
+end
+
+module Ragweed::Wraposx
+  module Libc
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    
+    # determine if a function is defined in the attached libraries
+    def self.find_function func
+      ffi_libraries.detect{|lib| lib.find_function(func)}
+    end
+
+    attach_function :vm_region, [:vm_map_t, :pointer, :pointer, :vm_region_flavor_t, :pointer, :pointer, :pointer], :int if find_function "vm_region"
+    attach_function :vm_region_64, [:vm_map_t, :pointer, :pointer, :vm_region_flavor_t, :pointer, :pointer, :pointer], :int if find_function "vm_region_64"
+  end
+
+  class << self
+
+    # Returns the base address, size, and a pointer to the requested information
+    # about the memory region at address in the target_task.
+    #
+    # Currently, only VM_REGION_BASIC_INFO is supported by Apple.
+    # Unless this is being run in 32bits, use vm_region_64 instead.
+    #
+    # kern_return_t   vm_region
+    #                  (vm_map_t                   target_task,
+    #                   vm_address_t                  *address,
+    #                   vm_size_t                        *size,
+    #                   vm_region_flavor_t              flavor,
+    #                   vm_region_info_t                  info,
+    #                   mach_msg_type_number_t     *info_count,
+    #                   mach_port_t               *object_name);
+    def vm_region(task, addr, flavor)
+      info = FFI::MemoryPointer.new(Vm::FLAVORS[flavor][:class], 1)
+      count = FFI::MemoryPointer.new(:int, 1).write_int(Vm::FLAVORS[flavor][:count])
+      address = FFI::MemoryPointer.new(:vm_address_t, 1).write_ulong(addr)
+      sz = FFI::MemoryPointer.new(:vm_size_t, 1)
+      objn = FFI::MemoryPointer.new(:mach_port_t, 1)
+      
+      r = Libc.vm_region(task, address, sz, flavor, info, count, objn)
+      raise KernelCallError.new(:vm_region, r) if r != 0
+      ret = Vm::Flavors[flavor][:class].new info
+      ret.region_size = size.read_ulong
+      ret.base_address = address.read_ulong
+      ret
+    end if Libc.find_function "vm_region"
+
+    # Returns the base address, size, and a pointer to the requested information
+    # about the memory region at address in the target_task.
+    #
+    # Currently, only VM_REGION_BASIC_INFO is supported by Apple.
+    #
+    # kern_return_t   vm_region
+    #                  (vm_map_t                   target_task,
+    #                   vm_address_t                  *address,
+    #                   vm_size_t                        *size,
+    #                   vm_region_flavor_t              flavor,
+    #                   vm_region_info_t                  info,
+    #                   mach_msg_type_number_t     *info_count,
+    #                   mach_port_t               *object_name);
+    def vm_region_64(task, addr, flavor)
+      # OSX does this as well, so we need to do it ourselves
+      flavor = Vm::REGION_BASIC_INFO_64 if flavor == Vm::REGION_BASIC_INFO
+      info = FFI::MemoryPointer.new(:uint8, Vm::FLAVORS[flavor][:size])
+      count = FFI::MemoryPointer.new(Libc.find_type(:mach_msg_type_number_t), 1).write_uint(Vm::FLAVORS[flavor][:count])
+      address = FFI::MemoryPointer.new(Libc.find_type(:vm_address_t), 1).write_ulong(addr)
+      sz = FFI::MemoryPointer.new(Libc.find_type(:vm_size_t), 1)
+      objn = FFI::MemoryPointer.new(Libc.find_type(:mach_port_t), 1)
+      
+      r = Libc.vm_region_64(task, address, sz, flavor, info, count, objn)
+      raise KernelCallError.new(:vm_region_64, r) if r != 0
+      ret = Vm::Flavors[flavor][:class].new info
+      ret.region_size = size.read_ulong
+      ret.base_address = address.read_ulong
+      ret
+    end if Libc.find_function "vm_region_64"
+  end
+end

data/lib/ragweed/wraposx/structs.rb

@@ -0,0 +1,102 @@
+# miscelaneous structs needed for other calls/structures
+
+module Ragweed; end
+module Ragweed::Wraposx
+  class FpControl < FFI::Struct
+    layout :value, :ushort
+    
+    def invalid
+      self.value >> 15
+    end
+    def denorm
+      (self.value >> 14) & 1
+    end
+    def zdiv
+      (self.value >> 13) & 1
+    end
+    def ovrfl
+      (self.value >> 12) & 1
+    end
+    def undfl
+      (self.value >> 11) & 1
+    end
+    def precis
+      (self.value >> 10) & 1
+    end
+    def res0
+      (self.value >> 8) & 3
+    end
+    def pc
+      (self.value >> 6) & 3
+    end
+    def rc
+      (self.value >> 4) & 3
+    end
+    def res1
+      (self.value >> 3) & 1
+    end
+    def res2
+      self.value & 7
+    end
+  end
+  
+  class FpStatus < FFI::Struct
+    layout :value, :ushort
+    def invalid
+      self.value >> 15
+    end
+    def denorm
+      (self.value >> 14) & 1
+    end
+    def zdiv
+      (self.value >> 13) & 1
+    end
+    def ovrfl
+      (self.value >> 12) & 1
+    end
+    def undfl
+      (self.value >> 11) & 1
+    end
+    def precis
+      (self.value >> 10) & 1
+    end
+    def stkflt
+      (self.value >> 9) & 1
+    end
+    def errsumm
+      (self.value >> 8) & 1
+    end
+    def c0
+      (self.value >> 7) & 1
+    end
+    def c1
+      (self.value >> 6) & 1
+    end
+    def c2
+      (self.value >> 5) & 1
+    end
+    def tos
+      (self.value >> 2) & 7
+    end
+    def c2
+      (self.value >> 1) & 1
+    end
+    def busy
+      self.value & 1
+    end
+  end
+
+  class MmstReg < FFI::Struct
+    layout :mmst_reg, [:char, 10],
+           :mmst_rsrv, [:char, 6]
+  end
+
+  class XmmReg < FFI::Struct
+    layout :xmm_reg, [:char, 16]
+  end
+  
+  class TimeValue < FFI::Struct
+    layout :seconds, :int,
+           :microseconds, :int
+  end
+end