sys-proctable 0.9.3-universal-solaris → 0.9.4-universal-solaris

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: 493156f7b41233bb2dc91f61f64d668d681369f2
+  data.tar.gz: 73c3ea02760e2a1038a3cb79b5bc1bdd8a7843f5
+SHA512: 
+  metadata.gz: d47a88803966ff31fbd8b3010ea9856dfe35bb424a18ec87b62972860228bc0467aae6ffdb4cfbb33a07ede4a38938022a6cdce5c11aa9d0497c6e9e621a1abd
+  data.tar.gz: 36c9b04c0f5668a1bd50aa83dc1bec55f2e4fd92178184703db047d805770e85a1c2d6789a0011c29542963b975beed4b18d5969ae4a5a05bbd586f7e1388a75

data/CHANGES

@@ -1,3 +1,14 @@
+== 0.9.4 - 4-Mar-2014
+* Added support for AIX 5.3 or later courtesy of Rick Ohnemus.
+* The Solaris version now uses FFI structs instead of a packed array.
+  It solved issues with 64-bit versions of Ruby and it's self-documenting.
+* The FreeBSD version has been converted to use FFI. In addition, additional
+  struct members have been added, and members that previously returned nil
+  now return meaningful data.
+* Support for NetBSD and OpenBSD has been temporarily dropped. Considering
+  that the C code did not build on those platforms anyway, I doubt most of
+  you will notice. Patches for those platforms are welcome, but only using FFI.
+
 == 0.9.3 - 17-Mar-2013
 * Fixed a bug on OSX where a long command string arg could cause
   a segfault. Thanks go to Nathaniel Bibler for the spot.

data/MANIFEST

@@ -3,6 +3,7 @@
 * Rakefile
 * README
 * sys-proctable.gemspec
+* doc/aix.txt
 * doc/bsd.txt
 * doc/hpux.txt
 * doc/linux.txt
@@ -10,20 +11,21 @@
 * doc/top.txt
 * doc/windows.txt
 * example/example_ps.rb
-* ext/bsd/extconf.rb
-* ext/bsd/sys/proctable.c
 * ext/darwin/extconf.rb
 * ext/darwin/sys/proctable.c
 * ext/hpux/extconf.rb
 * ext/hpux/sys/proctable.c
 * lib/sys/top.rb
+* lib/aix/sys/proctable.rb
+* lib/freebsd/sys/proctable.rb
 * lib/linux/sys/proctable.rb
 * lib/sunos/sys/proctable.rb
 * lib/windows/sys/proctable.rb
+* test/test_sys_proctable_aix.rb
 * test/test_sys_proctable_all.rb
 * test/test_sys_proctable_darwin.rb
+* test/test_sys_proctable_freebsd.rb
 * test/test_sys_proctable_hpux.rb
-* test/test_sys_proctable_bsd.rb
 * test/test_sys_proctable_linux.rb
 * test/test_sys_proctable_sunos.rb
 * test/test_sys_proctable_windows.rb

data/README

@@ -7,7 +7,7 @@
 == Supported Platforms
 * Windows 2000 or later
 * Linux 2.6+
-* BSD (various flavors)
+* FreeBSD
 * Solaris 8+
 * HP-UX 10+
 * OS X 10.4+
@@ -20,7 +20,7 @@
   gem install sys-proctable --platform mswin32 # Windows
   gem install sys-proctable --platform sunos   # Solaris
   gem install sys-proctable --platform linux   # Linux
-  gem install sys-proctable --platform freebsd # BSD (any flavor)
+  gem install sys-proctable --platform freebsd # FreeBSD
 
 == Synopsis
   require 'sys/proctable'
@@ -51,7 +51,7 @@
   information from a different host. This relies on the WMI service running.
 
 == Known Issues
-=== BSD
+=== FreeBSD
   A kvm interface is used. That means the owner of the process using the
   sys-proctable library needs to be a member of the kvm group (or root).
 
@@ -67,13 +67,12 @@
   Using readdir_r() still won't solve all potential thread safety issues anyway.
 
 == Future Plans
-  Research has indicated that the kvm approach is less favored than a sysctl
-  approach on BSD variants. I will try to add this interface in a future
-  release.
+  Add support for NetBSD and OpenBSD.
+  Convert existing C code to FFI.
 
 == Acknowledgements
-  This library is largely based on the Perl module Proc::ProcessTable by
-  Dan Urist. Many ideas, as well as large chunks of code, were taken
+  This library was originally based on the Perl module Proc::ProcessTable
+  by Dan Urist. Many ideas, as well as large chunks of code, were taken
   from his work. So, a big THANK YOU goes out to Dan Urist.
 
   A big thanks also goes out to Mike Hall who was very helpful with ideas,
@@ -105,7 +104,7 @@
   Artistic 2.0
     
 == Copyright
-  (C) 2003-2012 Daniel J. Berger
+  (C) 2003-2014 Daniel J. Berger
   All Rights Reserved.
 
 == Author

data/Rakefile

@@ -8,7 +8,7 @@ CLEAN.include(
   '**/*.core',              # Core dump files
   '**/*.gem',               # Gem files
   '**/*.rbc',               # Rubinius
-  '.rbx', '**/*/.rbx',      # Rubinius
+  '**/*.rbx',               # Rubinius
   '**/*.o',                 # C object file
   '**/*.log',               # Ruby extension build log
   '**/Makefile',            # C Makefile
@@ -27,9 +27,6 @@ task :build => [:clean] do
   end
 
   case CONFIG['host_os']
-    when /bsd/i
-      dir = 'ext/bsd'
-      ext = '.so'
     when /darwin/i
       dir = 'ext/darwin'
       ext = '.bundle'
@@ -38,7 +35,7 @@ task :build => [:clean] do
       ext = '.sl'
   end
 
-  unless CONFIG['host_os'] =~ /win32|mswin|dos|cygwin|mingw|windows|linux|sunos|solaris/i
+  if CONFIG['host_os'] =~ /darwin|hpux/i
     Dir.chdir(dir) do
       ruby 'extconf.rb'
       sh 'make'
@@ -61,8 +58,10 @@ task :install => [:build] do
       file = 'lib/linux/sys/proctable.rb'
     when /sunos|solaris/i
       file = 'lib/sunos/sys/proctable.rb'
-    when /bsd/i
-      Dir.chdir('ext/bsd'){ sh 'make install' }
+    when /aix/i
+      file = 'lib/aix/sys/proctable.rb'
+    when /freebsd/i
+      file = 'lib/freebsd/sys/proctable.rb'
     when /darwin/i
       Dir.chdir('ext/darwin'){ sh 'make install' }
     when /hpux/i
@@ -75,12 +74,12 @@ end
 desc 'Uninstall the sys-proctable library'
 task :uninstall do
   case CONFIG['host_os']
-    when /win32|mswin|dos|cygwin|mingw|windows|linux|sunos|solaris/i
-      dir  = File.join(CONFIG['sitelibdir'], 'sys')
-      file = File.join(dir, 'proctable.rb')
-    else
+    when /darwin|hpux/i
       dir  = File.join(CONFIG['sitearchdir'], 'sys')
       file = File.join(dir, 'proctable.' + CONFIG['DLEXT'])
+    else
+      dir  = File.join(CONFIG['sitelibdir'], 'sys')
+      file = File.join(dir, 'proctable.rb')
   end
 
   rm(file) 
@@ -111,12 +110,15 @@ Rake::TestTask.new do |t|
     when /sunos|solaris/i
       t.test_files = FileList['test/test_sys_proctable_sunos.rb']
       t.libs << 'lib/sunos'
+    when /aix/i
+      t.test_files = FileList['test/test_sys_proctable_aix.rb']
+      t.libs << 'lib/aix'
+    when /freebsd/i
+      t.test_files = FileList['test/test_sys_proctable_freebsd.rb']  
+      t.libs << 'lib/freebsd'
     when /darwin/i
       t.libs << 'ext/darwin'
       t.test_files = FileList['test/test_sys_proctable_darwin.rb']
-    when /bsd/i
-      t.libs << 'ext/bsd'
-      t.test_files = FileList['test/test_sys_proctable_bsd.rb']  
     when /hpux/i
       t.libs << 'ext/hpux'
       t.test_files = FileList['test/test_sys_proctable_hpux.rb']  
@@ -133,13 +135,12 @@ namespace :gem do
     # of some bugginess in Rubygems' platform.rb.
     #
     case CONFIG['host_os']
-      when /bsd/i
+      when /freebsd/i
          spec.platform = Gem::Platform.new(['universal', 'freebsd'])
-         spec.platform.version = nil
-         spec.files << 'ext/bsd/sys/proctable.c'
-         spec.extra_rdoc_files << 'ext/bsd/sys/proctable.c'
-         spec.test_files << 'test/test_sys_proctable_bsd.rb'
-         spec.extensions = ['ext/bsd/extconf.rb']
+         spec.require_paths = ['lib', 'lib/freebsd']
+         spec.files += ['lib/freebsd/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_freebsd.rb'
+         spec.add_dependency('ffi')
       when /darwin/i
          spec.platform = Gem::Platform.new(['universal', 'darwin'])
          spec.files << 'ext/darwin/sys/proctable.c'
@@ -162,6 +163,11 @@ namespace :gem do
          spec.require_paths = ['lib', 'lib/sunos']
          spec.files += ['lib/sunos/sys/proctable.rb']
          spec.test_files << 'test/test_sys_proctable_sunos.rb'
+      when /aix/i
+         spec.platform = Gem::Platform.new(['universal', 'aix5'])
+         spec.require_paths = ['lib', 'lib/aix']
+         spec.files += ['lib/aix/sys/proctable.rb']
+         spec.test_files << 'test/test_sys_proctable_aix.rb'
       when /mswin|win32|dos|cygwin|mingw|windows/i
          spec.platform = Gem::Platform.new(['universal', 'mingw32'])
          spec.require_paths = ['lib', 'lib/windows']
@@ -172,7 +178,12 @@ namespace :gem do
     # https://github.com/rubygems/rubygems/issues/147
     spec.original_platform = spec.platform
 
-    Gem::Builder.new(spec).build
+    if Gem::VERSION < "2.0"
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
   end
 
   desc 'Install the sys-proctable library as a gem'

data/lib/sunos/sys/proctable.rb

@@ -3,460 +3,448 @@
 #
 # A pure Ruby version of sys-proctable for SunOS 5.8 or later.
 ########################################################################
+require 'ffi'
 
 # The Sys module serves as a namespace only.
 module Sys
 
-   # The ProcTable class encapsulates process table information.
-   class ProcTable
-
-      class Error < StandardError; end
-
-      # There is no constructor
-      private_class_method :new
-
-      # The version of the sys-proctable library
-      VERSION = '0.9.3'
-
-      private
-
-      PRNODEV = -1 # non-existent device
-
-      @fields = [
-         :flag,      # process flags (deprecated)
-         :nlwp,      # number of active lwp's in the process
-         :pid,       # unique process id
-         :ppid,      # process id of parent
-         :pgid,      # pid of session leader
-         :sid,       # session id
-         :uid,       # real user id
-         :euid,      # effective user id
-         :gid,       # real group id
-         :egid,      # effective group id
-         :addr,      # address of the process
-         :size,      # size of process in kbytes
-         :rssize,    # resident set size in kbytes
-         :ttydev,    # tty device (or PRNODEV)
-         :pctcpu,    # % of recent cpu used by all lwp's
-         :pctmem,    # % of system memory used by process
-         :start,     # absolute process start time
-         :time,      # usr + sys cpu time for this process
-         :ctime,     # usr + sys cpu time for reaped children
-         :fname,     # name of the exec'd file
-         :psargs,    # initial characters argument list - same as cmdline
-         :wstat,     # if a zombie, the wait status
-         :argc,      # initial argument count
-         :argv,      # address of initial argument vector
-         :envp,      # address of initial environment vector
-         :dmodel,    # data model of the process
-         :taskid,    # task id
-         :projid,    # project id
-         :nzomb,     # number of zombie lwp's in the process
-         :poolid,    # pool id
-         :zoneid,    # zone id
-         :contract,  # process contract
-         :lwpid,     # lwp id
-         :wchan,     # wait address for sleeping lwp
-         :stype,     # synchronization event type
-         :state,     # numeric lwp state
-         :sname,     # printable character for state
-         :nice,      # nice for cpu usage
-         :syscall,   # system call number (if in syscall)
-         :pri,       # priority
-         :clname,    # scheduling class name
-         :name,      # name of system lwp
-         :onpro,     # processor which last ran thsi lwp
-         :bindpro,   # processor to which lwp is bound
-         :bindpset,  # processor set to which lwp is bound
-         :count,     # number of contributing lwp's
-         :tstamp,    # current time stamp
-         :create,    # process/lwp creation time stamp
-         :term,      # process/lwp termination time stamp
-         :rtime,     # total lwp real (elapsed) time
-         :utime,     # user level cpu time
-         :stime,     # system call cpu time
-         :ttime,     # other system trap cpu time
-         :tftime,    # text page fault sleep time
-         :dftime,    # text page fault sleep time
-         :kftime,    # kernel page fault sleep time
-         :ltime,     # user lock wait sleep time
-         :slptime,   # all other sleep time
-         :wtime,     # wait-cpu (latency) time
-         :stoptime,  # stopped time
-         :minf,      # minor page faults
-         :majf,      # major page faults
-         :nswap,     # swaps
-         :inblk,     # input blocks
-         :oublk,     # output blocks
-         :msnd,      # messages sent
-         :mrcv,      # messages received
-         :sigs,      # signals received
-         :vctx,      # voluntary context switches
-         :ictx,      # involuntary context switches
-         :sysc,      # system calls
-         :ioch,      # chars read and written
-         :path,      # array of symbolic link paths from /proc/<pid>/path
-         :contracts, # array symbolic link paths from /proc/<pid>/contracts
-         :fd,        # array of used file descriptors
-         :cmd_args,  # array of command line arguments
-         :environ,   # hash of environment associated with the process,
-         :cmdline    # joined cmd_args if present, otherwise psargs
-      ]
-
-      @psinfo_pack_directive = [
-         'i',   # pr_flag
-         'i',   # pr_nlwp
-         'i',   # pr_pid
-         'i',   # pr_ppid
-         'i',   # pr_pgid
-         'i',   # pr_sid
-         'i',   # pr_uid
-         'i',   # pr_euid
-         'i',   # pr_gid
-         'i',   # pr_egid
-         'L',   # pr_addr
-         'L',   # pr_size
-         'L',   # pr_rssize
-         'L',   # pr_pad1
-         'i',   # pr_ttydev
-         'S',   # pr_pctcpu
-         'S',   # pr_pctmem
-         'LL',  # pr_start
-         'LL',  # pr_time
-         'LL',  # pr_ctime
-         'A16', # pr_fname[PRFNSZ]
-         'A80', # pr_psargs[PRARGSZ]
-         'i',   # pr_wstat
-         'i',   # pr_argc
-         'L',   # pr_argv
-         'L',   # pr_envp
-         'C',   # pr_dmodel
-         'A3',  # pr_pad2[3]
-         'i',   # pr_taskid
-         'i',   # pr_projid
-         'i',   # pr_nzomb
-         'i',   # pr_poolid
-         'i',   # pr_zoneid
-         'i',   # pr_contract
-         'i',   # pr_filler
-         # --- LWPSINFO ---
-         'i',   # pr_flag
-         'i',   # pr_lwpid
-         'L',   # pr_addr
-         'L',   # pr_wchan
-         'C',   # pr_stype
-         'C',   # pr_state
-         'A',   # pr_sname
-         'C',   # pr_nice
-         's',   # pr_syscall
-         'C',   # pr_oldpri
-         'C',   # pr_cpu
-         'i',   # pr_pri
-         'S',   # pr_pctcpu
-         'S',   # pr_pad
-         'LL',  # pr_start
-         'LL',  # pr_time
-         'A8',  # pr_clname[PRCLSZ]
-         'A16', # pr_name[PRFNSZ]
-         'i',   # pr_onpro
-         'i',   # pr_bindpro
-         'i',   # pr_bindpset
-      ].join
-
-      @prusage_pack_directive = [
-         'i',     # pr_lwpid
-         'i',     # pr_count
-         'L2',    # pr_tstamp
-         'L2',    # pr_create
-         'L2',    # pr_term
-         'L2',    # pr_rtime
-         'L2',    # pr_utime
-         'L2',    # pr_stime
-         'L2',    # pr_ttime
-         'L2',    # pr_tftime
-         'L2',    # pr_dftime
-         'L2',    # pr_kftime
-         'L2',    # pr_ltime
-         'L2',    # pr_slptime
-         'L2',    # pr_wtime
-         'L2',    # pr_stoptime
-         'L12', # pr_filltime
-         'L',     # pr_minf
-         'L',     # pr_majf
-         'L',     # pr_nswap
-         'L',     # pr_inblk
-         'L',     # pr_oublk
-         'L',     # pr_msnd
-         'L',     # pr_mrcv
-         'L',     # pr_sigs
-         'L',     # pr_vctx
-         'L',     # pr_ictx
-         'L',     # pr_sysc
-         'L',     # pr_ioch
-      ].join
-
-      public
-
-      ProcTableStruct = Struct.new("ProcTableStruct", *@fields) do
-         alias comm fname
-      end
-
-      # In block form, yields a ProcTableStruct for each process entry that you
-      # have rights to. This method returns an array of ProcTableStruct's in
-      # non-block form.
-      #
-      # If a +pid+ is provided, then only a single ProcTableStruct is yielded or
-      # returned, or nil if no process information is found for that +pid+.
-      #
-      # Example:
-      #
-      #   # Iterate over all processes
-      #   ProcTable.ps do |proc_info|
-      #      p proc_info
-      #   end
-      #
-      #   # Print process table information for only pid 1001
-      #   p ProcTable.ps(1001)
-      #
-      def self.ps(pid = nil)
-         raise TypeError unless pid.is_a?(Fixnum) if pid
-
-         array  = block_given? ? nil : []
-         struct = nil
-
-         Dir.foreach("/proc") do |file|
-            next if file =~ /\D/ # Skip non-numeric entries under /proc
-
-            # Only return information for a given pid, if provided
-            if pid
-               next unless file.to_i == pid
-            end
-
-            # Skip over any entries we don't have permissions to read
-            next unless File.readable?("/proc/#{file}/psinfo")
-
-            psinfo = IO.read("/proc/#{file}/psinfo") rescue next
-
-            psinfo_array = psinfo.unpack(@psinfo_pack_directive)
-
-            struct = ProcTableStruct.new
-
-            struct.flag   = psinfo_array[0]         # pr_flag
-            struct.nlwp   = psinfo_array[1]         # pr_nlwp
-            struct.pid    = psinfo_array[2]         # pr_pid
-            struct.ppid   = psinfo_array[3]         # pr_ppid
-            struct.pgid   = psinfo_array[4]         # pr_pgid
-            struct.sid    = psinfo_array[5]         # pr_sid
-            struct.uid    = psinfo_array[6]         # pr_uid
-            struct.euid   = psinfo_array[7]         # pr_euid
-            struct.gid    = psinfo_array[8]         # pr_gid
-            struct.egid   = psinfo_array[9]         # pr_egid
-            struct.addr   = psinfo_array[10]        # pr_addr
-            struct.size   = psinfo_array[11] * 1024 # pr_size (in bytes)
-            struct.rssize = psinfo_array[12] * 1024 # pr_rssize (in bytes)
-
-            # skip pr_pad1
-
-            struct.ttydev = psinfo_array[14] # pr_ttydev
-            struct.pctcpu = (psinfo_array[15] * 100).to_f / 0x8000 # pr_pctcpu
-            struct.pctmem = (psinfo_array[16] * 100).to_f / 0x8000 # pr_pctmem
-
-            struct.start = Time.at(psinfo_array[17]) # pr_start (tv_sec)
-            struct.time  = psinfo_array[19]          # pr_time (tv_sec)
-            struct.ctime = psinfo_array[21]          # pr_ctime (tv_sec)
-
-            struct.fname  = psinfo_array[23] # pr_fname
-            struct.psargs = psinfo_array[24] # pr_psargs
-            struct.wstat  = psinfo_array[25] # pr_wstat
-            struct.argc   = psinfo_array[26] # pr_argc
-            struct.argv   = psinfo_array[27] # pr_argv
-            struct.envp   = psinfo_array[28] # pr_envp
-            struct.dmodel = psinfo_array[29] # pr_dmodel
-
-            # skip pr_pad2
-
-            struct.taskid   = psinfo_array[31] # pr_taskid
-            struct.projid   = psinfo_array[32] # pr_projid
-            struct.nzomb    = psinfo_array[33] # pr_nzomb
-            struct.poolid   = psinfo_array[34] # pr_poolid
-            struct.zoneid   = psinfo_array[35] # pr_zoneid
-            struct.contract = psinfo_array[36] # pr_contract
-
-            # skip pr_filler
-
-            ### LWPSINFO struct info
-
-            # skip pr_flag
-
-            struct.lwpid = psinfo_array[39] # pr_lwpid
-
-            # skip pr_addr
-
-            struct.wchan   = psinfo_array[41] # pr_wchan
-            struct.stype   = psinfo_array[42] # pr_stype
-            struct.state   = psinfo_array[43] # pr_state
-            struct.sname   = psinfo_array[44] # pr_sname
-            struct.nice    = psinfo_array[45] # pr_nice
-            struct.syscall = psinfo_array[46] # pr_syscall
-
-            # skip pr_oldpri
-            # skip pr_cpu
-
-            struct.pri = psinfo_array[49] # pr_pri
-
-            # skip pr_pctcpu
-            # skip pr_pad
-            # skip pr_start
-            # skip pr_time
-
-            struct.clname   = psinfo_array[56] # pr_clname
-            struct.name     = psinfo_array[57] # pr_name
-            struct.onpro    = psinfo_array[58] # pr_onpro
-            struct.bindpro  = psinfo_array[59] # pr_bindpro
-            struct.bindpset = psinfo_array[60] # pr_bindpset
-
-            # Get the full command line out of /proc/<pid>/as.
-            begin
-               File.open("/proc/#{file}/as") do |fd|
-                  fd.sysseek(struct.argv, IO::SEEK_SET)
-                  address = fd.sysread(struct.argc * 4).unpack("L")[0]
-
-                  struct.cmd_args = []
-
-                  0.upto(struct.argc - 1){ |i|
-                     fd.sysseek(address, IO::SEEK_SET)
-                     data = fd.sysread(128)[/^[^\0]*/] # Null strip
-                     struct.cmd_args << data
-                     address += data.length + 1 # Add 1 for the space
-                  }
-
-                  # Get the environment hash associated with the process.
-                  struct.environ = {}
-
-                  fd.sysseek(struct.envp, IO::SEEK_SET)
-
-                  env_address = fd.sysread(128).unpack("L")[0]
-
-                  # TODO: Optimization potential here.
-                  loop do
-                     fd.sysseek(env_address, IO::SEEK_SET)
-                     data = fd.sysread(1024)[/^[^\0]*/] # Null strip
-                     break if data.empty?
-                     key, value = data.split('=')
-                     struct.environ[key] = value
-                     env_address += data.length + 1 # Add 1 for the space
-                  end
-               end
-            rescue Errno::EACCES, Errno::EOVERFLOW, EOFError
-               # Skip this if we don't have proper permissions, if there's
-               # no associated environment, or if there's a largefile issue.
-            rescue Errno::ENOENT
-               next # The process has terminated. Bail out!
-            end
-
-            ### struct prusage
-
-            begin
-               prusage = 0.chr * 512
-               prusage = IO.read("/proc/#{file}/usage")
-
-               prusage_array = prusage.unpack(@prusage_pack_directive)
-
-               # skip pr_lwpid
-               struct.count    = prusage_array[1]
-               struct.tstamp   = prusage_array[2]
-               struct.create   = prusage_array[4]
-               struct.term     = prusage_array[6]
-               struct.rtime    = prusage_array[8]
-               struct.utime    = prusage_array[10]
-               struct.stime    = prusage_array[12]
-               struct.ttime    = prusage_array[14]
-               struct.tftime   = prusage_array[16]
-               struct.dftime   = prusage_array[18]
-               struct.kftime   = prusage_array[20]
-               struct.ltime    = prusage_array[22]
-               struct.slptime  = prusage_array[24]
-               struct.wtime    = prusage_array[26]
-               struct.stoptime = prusage_array[28]
-               # skip filltime
-               struct.minf     = prusage_array[42]
-               struct.majf     = prusage_array[43]
-               struct.nswap    = prusage_array[44]
-               struct.inblk    = prusage_array[45]
-               struct.oublk    = prusage_array[46]
-               struct.msnd     = prusage_array[47]
-               struct.mrcv     = prusage_array[48]
-               struct.sigs     = prusage_array[49]
-               struct.vctx     = prusage_array[50]
-               struct.ictx     = prusage_array[51]
-               struct.sysc     = prusage_array[52]
-               struct.ioch     = prusage_array[53]
-            rescue Errno::EACCES
-               # Do nothing if we lack permissions. Just move on.
-            rescue Errno::ENOENT
-               next # The process has terminated. Bail out!
-            end
-
-            # Information from /proc/<pid>/path. This is represented as a hash,
-            # with the symbolic link name as the key, and the file it links to
-            # as the value, or nil if it cannot be found.
-            #--
-            # Note that cwd information can be gathered from here, too.
-            struct.path = {}
-
-            Dir["/proc/#{file}/path/*"].each{ |entry|
-               link = File.readlink(entry) rescue nil
-               struct.path[File.basename(entry)] = link
+  # The ProcTable class encapsulates process table information.
+  class ProcTable
+    extend FFI::Library
+
+    class Error < StandardError; end
+
+    # There is no constructor
+    private_class_method :new
+
+    # The version of the sys-proctable library
+    VERSION = '0.9.4'
+
+    private
+
+    class Timeval < FFI::Struct
+      layout(:tv_sec, :time_t, :tv_usec, :time_t)
+    end
+
+    class LWPSInfo < FFI::Struct
+      layout(
+        :pr_flag, :int,
+        :pr_lwpid, :id_t,
+        :pr_addr, :uintptr_t,
+        :pr_wchan, :uintptr_t,
+        :pr_stype, :char,
+        :pr_state, :char,
+        :pr_sname, :char,
+        :pr_nice, :char,
+        :pr_syscall, :short,
+        :pr_oldpri, :char,
+        :pr_cpu, :char,
+        :pr_pri, :int,
+        :pr_pctcpu, :ushort_t,
+        :pr_pad, :ushort_t,
+        :pr_start, Timeval,
+        :pr_time, Timeval,
+        :pr_clname, [:char, 8],
+        :pr_name, [:char, 16],
+        :pr_onpro, :int,
+        :pr_bindpro, :int,
+        :pr_bindpset, :int,
+        :pr_filler, [:int, 5]
+      )
+    end
+
+    class PSInfo < FFI::Struct
+      layout(
+        :pr_flag, :int,
+        :pr_nlwp, :int,
+        :pr_pid, :pid_t,
+        :pr_ppid, :pid_t,
+        :pr_pgid, :pid_t,
+        :pr_sid, :pid_t,
+        :pr_uid, :uid_t,
+        :pr_euid, :uid_t,
+        :pr_gid, :gid_t,
+        :pr_egid, :gid_t,
+        :pr_addr, :uintptr_t,
+        :pr_size, :size_t,
+        :pr_rssize, :size_t,
+        :pr_pad1, :size_t,
+        :pr_ttydev, :dev_t,
+        :pr_pctcpu, :ushort_t,
+        :pr_pctmem, :ushort_t,
+        :pr_start, Timeval,
+        :pr_time, Timeval,
+        :pr_ctime, Timeval,
+        :pr_fname, [:char, 16],
+        :pr_psargs, [:char, 80],
+        :pr_wstat, :int,
+        :pr_argc, :int,
+        :pr_argv, :uintptr_t,
+        :pr_envp, :uintptr_t,
+        :pr_dmodel, :char,
+        :pr_pad2, [:char, 3],
+        :pr_taskid, :taskid_t,
+        :pr_projid, :projid_t,
+        :pr_nzomb, :int,
+        :pr_poolid, :poolid_t,
+        :pr_zoneid, :zoneid_t,
+        :pr_contract, :id_t,
+        :pr_filler, [:int, 1],
+        :pr_lwp, LWPSInfo
+      )
+    end
+
+    class PRUsage < FFI::Struct
+      layout(
+        :pr_lwpid, :id_t,
+        :pr_count, :int,
+        :pr_tstamp, Timeval,
+        :pr_create, Timeval,
+        :pr_term, Timeval,
+        :pr_rtime, Timeval,
+        :pr_utime, Timeval,
+        :pr_stime, Timeval,
+        :pr_ttime, Timeval,
+        :pr_tftime, Timeval,
+        :pr_dftime, Timeval,
+        :pr_kftime, Timeval,
+        :pr_ltime, Timeval,
+        :pr_slptime, Timeval,
+        :pr_wtime, Timeval,
+        :pr_stoptime, Timeval,
+        :pr_filetime, [Timeval,6],
+        :pr_minf, :ulong_t,
+        :pr_majf, :ulong_t,
+        :pr_nswap, :ulong_t,
+        :pr_inblk, :ulong_t,
+        :pr_oublk, :ulong_t,
+        :pr_msnd, :ulong_t,
+        :pr_mrcv, :ulong_t,
+        :pr_sigs, :ulong_t,
+        :pr_vctx, :ulong_t,
+        :pr_ictx, :ulong_t,
+        :pr_sysc, :ulong_t,
+        :pr_ioch, :ulong_t,
+        :filler, [:ulong_t, 10]
+      )
+    end
+
+    PRNODEV = (1<<FFI::Platform::ADDRESS_SIZE)-1
+
+    @fields = [
+      :flag,      # process flags (deprecated)
+      :nlwp,      # number of active lwp's in the process
+      :pid,       # unique process id
+      :ppid,      # process id of parent
+      :pgid,      # pid of session leader
+      :sid,       # session id
+      :uid,       # real user id
+      :euid,      # effective user id
+      :gid,       # real group id
+      :egid,      # effective group id
+      :addr,      # address of the process
+      :size,      # size of process in kbytes
+      :rssize,    # resident set size in kbytes
+      :ttydev,    # tty device (or PRNODEV)
+      :pctcpu,    # % of recent cpu used by all lwp's
+      :pctmem,    # % of system memory used by process
+      :start,     # absolute process start time
+      :time,      # usr + sys cpu time for this process
+      :ctime,     # usr + sys cpu time for reaped children
+      :fname,     # name of the exec'd file
+      :psargs,    # initial characters argument list - same as cmdline
+      :wstat,     # if a zombie, the wait status
+      :argc,      # initial argument count
+      :argv,      # address of initial argument vector
+      :envp,      # address of initial environment vector
+      :dmodel,    # data model of the process
+      :taskid,    # task id
+      :projid,    # project id
+      :nzomb,     # number of zombie lwp's in the process
+      :poolid,    # pool id
+      :zoneid,    # zone id
+      :contract,  # process contract
+      :lwpid,     # lwp id
+      :wchan,     # wait address for sleeping lwp
+      :stype,     # synchronization event type
+      :state,     # numeric lwp state
+      :sname,     # printable character for state
+      :nice,      # nice for cpu usage
+      :syscall,   # system call number (if in syscall)
+      :pri,       # priority
+      :clname,    # scheduling class name
+      :name,      # name of system lwp
+      :onpro,     # processor which last ran thsi lwp
+      :bindpro,   # processor to which lwp is bound
+      :bindpset,  # processor set to which lwp is bound
+      :count,     # number of contributing lwp's
+      :tstamp,    # current time stamp
+      :create,    # process/lwp creation time stamp
+      :term,      # process/lwp termination time stamp
+      :rtime,     # total lwp real (elapsed) time
+      :utime,     # user level cpu time
+      :stime,     # system call cpu time
+      :ttime,     # other system trap cpu time
+      :tftime,    # text page fault sleep time
+      :dftime,    # text page fault sleep time
+      :kftime,    # kernel page fault sleep time
+      :ltime,     # user lock wait sleep time
+      :slptime,   # all other sleep time
+      :wtime,     # wait-cpu (latency) time
+      :stoptime,  # stopped time
+      :minf,      # minor page faults
+      :majf,      # major page faults
+      :nswap,     # swaps
+      :inblk,     # input blocks
+      :oublk,     # output blocks
+      :msnd,      # messages sent
+      :mrcv,      # messages received
+      :sigs,      # signals received
+      :vctx,      # voluntary context switches
+      :ictx,      # involuntary context switches
+      :sysc,      # system calls
+      :ioch,      # chars read and written
+      :path,      # array of symbolic link paths from /proc/<pid>/path
+      :contracts, # array symbolic link paths from /proc/<pid>/contracts
+      :fd,        # array of used file descriptors
+      :cmd_args,  # array of command line arguments
+      :environ,   # hash of environment associated with the process,
+      :cmdline    # joined cmd_args if present, otherwise psargs
+    ]
+
+    public
+
+    ProcTableStruct = Struct.new("ProcTableStruct", *@fields) do
+      alias comm fname
+    end
+
+    # In block form, yields a ProcTableStruct for each process entry that you
+    # have rights to. This method returns an array of ProcTableStruct's in
+    # non-block form.
+    #
+    # If a +pid+ is provided, then only a single ProcTableStruct is yielded or
+    # returned, or nil if no process information is found for that +pid+.
+    #
+    # Example:
+    #
+    #   # Iterate over all processes
+    #   ProcTable.ps do |proc_info|
+    #      p proc_info
+    #   end
+    #
+    #   # Print process table information for only pid 1001
+    #   p ProcTable.ps(1001)
+    #
+    def self.ps(pid = nil)
+      raise TypeError unless pid.is_a?(Fixnum) if pid
+
+      array  = block_given? ? nil : []
+      struct = nil
+
+      Dir.foreach("/proc") do |file|
+        next if file =~ /\D/ # Skip non-numeric entries under /proc
+
+        # Only return information for a given pid, if provided
+        next unless file.to_i == pid if pid
+
+        # Skip over any entries we don't have permissions to read
+        next unless File.readable?("/proc/#{file}/psinfo")
+
+        data = IO.read("/proc/#{file}/psinfo") rescue next
+        psinfo = PSInfo.new(FFI::MemoryPointer.from_string(data))
+
+        struct = ProcTableStruct.new
+
+        struct.flag   = psinfo[:pr_flag]
+        struct.nlwp   = psinfo[:pr_nlwp]
+        struct.pid    = psinfo[:pr_pid]
+        struct.ppid   = psinfo[:pr_ppid]
+        struct.pgid   = psinfo[:pr_pgid]
+        struct.sid    = psinfo[:pr_sid]
+        struct.uid    = psinfo[:pr_uid]
+        struct.euid   = psinfo[:pr_euid]
+        struct.gid    = psinfo[:pr_gid]
+        struct.egid   = psinfo[:pr_egid]
+        struct.addr   = psinfo[:pr_addr]
+        struct.size   = psinfo[:pr_size] * 1024 # bytes
+        struct.rssize = psinfo[:pr_rssize] * 1024 # bytes
+        struct.ttydev = psinfo[:pr_ttydev] == PRNODEV ? -1 : psinfo[:pr_ttydev]
+        struct.pctcpu = (psinfo[:pr_pctcpu] * 100).to_f / 0x8000
+        struct.pctmem = (psinfo[:pr_pctmem] * 100).to_f / 0x8000
+
+        struct.start = Time.at(psinfo[:pr_start][:tv_sec])
+        struct.time  = psinfo[:pr_time][:tv_sec]
+        struct.ctime = psinfo[:pr_ctime][:tv_sec]
+
+        struct.fname  = psinfo[:pr_fname].to_s
+        struct.psargs = psinfo[:pr_psargs].to_s
+        struct.wstat  = psinfo[:pr_wstat]
+        struct.argc   = psinfo[:pr_argc]
+        struct.argv   = psinfo[:pr_argv]
+        struct.envp   = psinfo[:pr_envp]
+        struct.dmodel = psinfo[:pr_dmodel]
+
+        struct.taskid   = psinfo[:pr_taskid]
+        struct.projid   = psinfo[:pr_projid]
+        struct.nzomb    = psinfo[:pr_nzomb]
+        struct.poolid   = psinfo[:pr_poolid]
+        struct.zoneid   = psinfo[:pr_zoneid]
+        struct.contract = psinfo[:pr_contract]
+
+        ### LWPSINFO struct info
+
+        struct.lwpid    = psinfo[:pr_lwp][:pr_lwpid]
+        struct.wchan    = psinfo[:pr_lwp][:pr_wchan]
+        struct.stype    = psinfo[:pr_lwp][:pr_stype]
+        struct.state    = psinfo[:pr_lwp][:pr_state]
+        struct.sname    = psinfo[:pr_lwp][:pr_sname].chr
+        struct.nice     = psinfo[:pr_lwp][:pr_nice]
+        struct.syscall  = psinfo[:pr_lwp][:pr_syscall]
+        struct.pri      = psinfo[:pr_lwp][:pr_pri]
+        struct.clname   = psinfo[:pr_lwp][:pr_clname].to_s
+        struct.name     = psinfo[:pr_lwp][:pr_name].to_s
+        struct.onpro    = psinfo[:pr_lwp][:pr_onpro]
+        struct.bindpro  = psinfo[:pr_lwp][:pr_bindpro]
+        struct.bindpset = psinfo[:pr_lwp][:pr_bindpset]
+
+        # Get the full command line out of /proc/<pid>/as.
+        begin
+          File.open("/proc/#{file}/as") do |fd|
+            fd.sysseek(struct.argv, IO::SEEK_SET)
+            address = fd.sysread(struct.argc * 4).unpack("L")[0]
+
+            struct.cmd_args = []
+
+            0.upto(struct.argc - 1){ |i|
+              fd.sysseek(address, IO::SEEK_SET)
+              data = fd.sysread(128)[/^[^\0]*/] # Null strip
+              struct.cmd_args << data
+              address += data.length + 1 # Add 1 for the space
             }
 
-            # Information from /proc/<pid>/contracts. This is represented as
-            # a hash, with the symbolic link name as the key, and the file
-            # it links to as the value.
-            struct.contracts = {}
+            # Get the environment hash associated with the process.
+            struct.environ = {}
 
-            Dir["/proc/#{file}/contracts/*"].each{ |entry|
-               link = File.readlink(entry) rescue nil
-               struct.contracts[File.basename(entry)] = link
-            }
+            fd.sysseek(struct.envp, IO::SEEK_SET)
 
-            # Information from /proc/<pid>/fd. This returns an array of
-            # numeric file descriptors used by the process.
-            struct.fd = Dir["/proc/#{file}/fd/*"].map{ |f| File.basename(f).to_i }
-
-            # Use the cmd_args as the cmdline if available. Otherwise use
-            # the psargs. This struct member is provided to provide a measure
-            # of consistency with the other platform implementations.
-            if struct.cmd_args && struct.cmd_args.length > 0
-               struct.cmdline = struct.cmd_args.join(' ')
-            else
-               struct.cmdline = struct.psargs
-            end
-
-            # This is read-only data
-            struct.freeze
+            env_address = fd.sysread(128).unpack("L")[0]
 
-            if block_given?
-               yield struct
-            else
-               array << struct
+            # TODO: Optimization potential here.
+            loop do
+              fd.sysseek(env_address, IO::SEEK_SET)
+              data = fd.sysread(1024)[/^[^\0]*/] # Null strip
+              break if data.empty?
+              key, value = data.split('=')
+              struct.environ[key] = value
+              env_address += data.length + 1 # Add 1 for the space
             end
-         end
-
-         pid ? struct : array
+          end
+        rescue Errno::EACCES, Errno::EOVERFLOW, EOFError, RangeError
+          # Skip this if we don't have proper permissions, if there's
+          # no associated environment, or if there's a largefile issue.
+        rescue Errno::ENOENT
+          next # The process has terminated. Bail out!
+        end
+
+        ### struct prusage
+
+        begin
+          data = IO.read("/proc/#{file}/usage")
+          prusage = PRUsage.new(FFI::MemoryPointer.from_string(data))
+
+          struct.count    = prusage[:pr_count]
+          struct.tstamp   = prusage[:pr_tstamp][:tv_sec]
+          struct.create   = prusage[:pr_create][:tv_sec]
+          struct.term     = prusage[:pr_term][:tv_sec]
+          struct.rtime    = prusage[:pr_rtime][:tv_sec]
+          struct.utime    = prusage[:pr_utime][:tv_sec]
+          struct.stime    = prusage[:pr_stime][:tv_sec]
+          struct.ttime    = prusage[:pr_ttime][:tv_sec]
+          struct.tftime   = prusage[:pr_tftime][:tv_sec]
+          struct.dftime   = prusage[:pr_dftime][:tv_sec]
+          struct.kftime   = prusage[:pr_kftime][:tv_sec]
+          struct.ltime    = prusage[:pr_ltime][:tv_sec]
+          struct.slptime  = prusage[:pr_slptime][:tv_sec]
+          struct.wtime    = prusage[:pr_wtime][:tv_sec]
+          struct.stoptime = prusage[:pr_stoptime][:tv_sec]
+          struct.minf     = prusage[:pr_minf]
+          struct.majf     = prusage[:pr_majf]
+          struct.nswap    = prusage[:pr_nswap]
+          struct.inblk    = prusage[:pr_inblk]
+          struct.oublk    = prusage[:pr_oublk]
+          struct.msnd     = prusage[:pr_msnd]
+          struct.mrcv     = prusage[:pr_mrcv]
+          struct.sigs     = prusage[:pr_sigs]
+          struct.vctx     = prusage[:pr_vctx]
+          struct.ictx     = prusage[:pr_ictx]
+          struct.sysc     = prusage[:pr_sysc]
+          struct.ioch     = prusage[:pr_ioch]
+        rescue Errno::EACCES
+          # Do nothing if we lack permissions. Just move on.
+        rescue Errno::ENOENT
+          next # The process has terminated. Bail out!
+        end
+
+        # Information from /proc/<pid>/path. This is represented as a hash,
+        # with the symbolic link name as the key, and the file it links to
+        # as the value, or nil if it cannot be found.
+        #--
+        # Note that cwd information can be gathered from here, too.
+        struct.path = {}
+
+        Dir["/proc/#{file}/path/*"].each{ |entry|
+          link = File.readlink(entry) rescue nil
+          struct.path[File.basename(entry)] = link
+        }
+
+        # Information from /proc/<pid>/contracts. This is represented as
+        # a hash, with the symbolic link name as the key, and the file
+        # it links to as the value.
+        struct.contracts = {}
+
+        Dir["/proc/#{file}/contracts/*"].each{ |entry|
+          link = File.readlink(entry) rescue nil
+          struct.contracts[File.basename(entry)] = link
+        }
+
+        # Information from /proc/<pid>/fd. This returns an array of
+        # numeric file descriptors used by the process.
+        struct.fd = Dir["/proc/#{file}/fd/*"].map{ |f| File.basename(f).to_i }
+
+        # Use the cmd_args as the cmdline if available. Otherwise use
+        # the psargs. This struct member is provided to provide a measure
+        # of consistency with the other platform implementations.
+        if struct.cmd_args && struct.cmd_args.length > 0
+          struct.cmdline = struct.cmd_args.join(' ')
+        else
+          struct.cmdline = struct.psargs
+        end
+
+        # This is read-only data
+        struct.freeze
+
+        if block_given?
+          yield struct
+        else
+          array << struct
+        end
       end
 
-      # Returns an array of fields that each ProcTableStruct will contain. This
-      # may be useful if you want to know in advance what fields are available
-      # without having to perform at least one read of the /proc table.
-      #
-      # Example:
-      #
-      #   Sys::ProcTable.fields.each{ |field|
-      #      puts "Field: #{field}"
-      #   }
-      #
-      def self.fields
-         @fields.map{ |f| f.to_s }
-      end
-   end
+      pid ? struct : array
+    end
+
+    # Returns an array of fields that each ProcTableStruct will contain. This
+    # may be useful if you want to know in advance what fields are available
+    # without having to perform at least one read of the /proc table.
+    #
+    # Example:
+    #
+    #   Sys::ProcTable.fields.each{ |field|
+    #      puts "Field: #{field}"
+    #   }
+    #
+    def self.fields
+      @fields.map{ |f| f.to_s }
+    end
+  end
 end