sys-proctable 0.7.6 → 1.2.0

data/lib/sunos/sys/proctable.rb

@@ -0,0 +1,456 @@
+########################################################################
+# proctable.rb
+#
+# A pure Ruby version of sys-proctable for SunOS 5.8 or later.
+########################################################################
+require 'ffi'
+require 'sys/proctable/version'
+
+# The Sys module serves as a namespace only.
+module Sys
+
+  # The ProcTable class encapsulates process table information.
+  class ProcTable
+    extend FFI::Library
+
+    class Error < StandardError; end
+
+    # There is no constructor
+    private_class_method :new
+
+    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(pid: 1001)
+    #
+    #   # Skip prusage information
+    #   p ProcTable.ps(prusage: false)
+    #
+    def self.ps(**kwargs)
+      pid = kwargs[:pid]
+      prusage_info = kwargs[:prusage]
+
+      raise TypeError unless pid.is_a?(Numeric) 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
+            }
+
+            # 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, 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
+
+        if prusage_info != false
+          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
+        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
+
+      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(&:to_s)
+    end
+  end
+end