sys-proctable 1.2.6 → 1.3.0

data/lib/bsd/sys/dragonfly/sys/proctable/structs.rb

@@ -0,0 +1,298 @@
+require 'ffi'
+require_relative 'constants'
+
+module Sys
+  module ProcTableStructs
+    extend FFI::Library
+
+    class Timeval < FFI::Struct
+      layout(:tv_sec, :time_t, :tv_usec, :suseconds_t)
+    end
+
+    class RTPrio < FFI::Struct
+      layout(:type, :ushort, :prio, :ushort)
+    end
+
+    class Rusage < FFI::Struct
+      layout(
+        :ru_utime, Timeval,
+        :ru_stime, Timeval,
+        :ru_maxrss, :long,
+        :ru_ixrss, :long,
+        :ru_idrss, :long,
+        :ru_isrss, :long,
+        :ru_minflt, :long,
+        :ru_majflt, :long,
+        :ru_nswap, :long,
+        :ru_inblock, :long,
+        :ru_oublock, :long,
+        :ru_msgsnd, :long,
+        :ru_msgrcv, :long,
+        :ru_nsignals, :long,
+        :ru_nvcsw, :long,
+        :ru_nivcsw, :long
+      )
+
+      def utime
+        Time.at(self[:ru_utime][:tv_sec])
+      end
+
+      def stime
+        Time.at(self[:ru_stime][:tv_sec])
+      end
+
+      def maxrss
+        self[:ru_maxrss]
+      end
+
+      def ixrss
+        self[:ru_ixrss]
+      end
+
+      def idrss
+        self[:ru_idrss]
+      end
+
+      def isrss
+        self[:ru_isrss]
+      end
+
+      def minflt
+        self[:ru_minflt]
+      end
+
+      def majflt
+        self[:ru_majflt]
+      end
+
+      def nswap
+        self[:ru_nswap]
+      end
+
+      def inblock
+        self[:ru_inblock]
+      end
+
+      def oublock
+        self[:ru_oublock]
+      end
+
+      def msgsnd
+        self[:ru_msgsnd]
+      end
+
+      def msgrcv
+        self[:ru_msgrcv]
+      end
+
+      def nsignals
+        self[:ru_nsignals]
+      end
+
+      def nvcsw
+        self[:ru_nivcsw]
+      end
+
+      def nivcsw
+        self[:ru_nivcsw]
+      end
+    end
+
+    enum :lwpstat, [:LSRUN, 1, :LSSTOP, :LSSLEEP]
+    enum :procstat, [:SIDL, 1, :SACTIVE, :SSTOP, :SZOMB, :SCORE]
+
+    class Sigset < FFI::Struct
+      layout(:__bits, [:uint, 4])
+
+      def bits
+        self[:__bits].to_a
+      end
+    end
+
+    class KInfoLWP < FFI::Struct
+      include Sys::ProcTableConstants
+
+      layout(
+        :kl_pid, :pid_t,
+        :kl_tid, :lwpid_t,
+        :kl_flags, :int,
+        :kl_stat, :lwpstat,
+        :kl_lock, :int,
+        :kl_tdflags, :int,
+        :kl_mpcount, :int,
+        :kl_prio, :int,
+        :kl_tdprio, :int,
+        :kl_rtprio, RTPrio,
+        :kl_uticks, :uint64_t,
+        :kl_sticks, :uint64_t,
+        :kl_iticks, :uint64_t,
+        :kl_cpticks, :uint64_t,
+        :kl_pctcpu, :uint,
+        :kl_slptime, :uint,
+        :kl_origcpu, :int,
+        :kl_estcpu, :int,
+        :kl_cpuid, :int,
+        :kl_ru, Rusage,
+        :kl_siglist, Sigset,
+        :kl_sigmask, Sigset,
+        :kl_wchan, :uintptr_t,
+        :kl_wmesg, [:char, WMESGLEN+1],
+        :kl_comm, [:char, MAXCOMLEN+1]
+      )
+
+      def pid
+        self[:kl_pid]
+      end
+
+      def tid
+        self[:kl_tid]
+      end
+
+      def flags
+        self[:kl_flags]
+      end
+
+      def stat
+        self[:kl_stat]
+      end
+
+      def lock
+        self[:kl_lock]
+      end
+
+      def tdflags
+        self[:kl_tdflags]
+      end
+
+      def prio
+        self[:kl_prio]
+      end
+
+      def tdprio
+        self[:kl_tdprio]
+      end
+
+      def rtprio
+        self[:kl_rtprio]
+      end
+
+      def uticks
+        self[:kl_uticks]
+      end
+
+      def sticks
+        self[:kl_sticks]
+      end
+
+      def iticks
+        self[:kl_iticks]
+      end
+
+      def cpticks
+        self[:kl_cpticks]
+      end
+
+      def pctcpu
+        self[:kl_pctcpu]
+      end
+
+      def slptime
+        self[:kl_slptime]
+      end
+
+      def origcpu
+        self[:kl_origcpu]
+      end
+
+      def estcpu
+        self[:kl_estcpu]
+      end
+
+      def cpuid
+        self[:kl_cpuid]
+      end
+
+      def ru
+        self[:kl_ru]
+      end
+
+      def siglist
+        self[:kl_siglist]
+      end
+
+      def sigmask
+        self[:kl_sigmask]
+      end
+
+      def wchan
+        self[:kl_wchan]
+      end
+
+      def wmesg
+        self[:kl_wmesg].to_s
+      end
+
+      def comm
+        self[:kl_comm].to_s
+      end
+    end
+
+    class KInfoProc < FFI::Struct
+      include Sys::ProcTableConstants
+
+      def self.roundup(x, y)
+        ((x + y-1) / y) * y
+      end
+
+      layout(
+        :kp_paddr, :uintptr_t,
+        :kp_flags, :int,
+        :kp_stat, :procstat,
+        :kp_lock, :int,
+        :kp_acflag, :int,
+        :kp_traceflag, :int,
+        :kp_fd, :uintptr_t,
+        :kp_siglist, Sigset,
+        :kp_sigignore, Sigset,
+        :kp_sigcatch, Sigset,
+        :kp_sigflag, :int,
+        :kp_start, Timeval,
+        :kp_comm, [:char, MAXCOMLEN+1],
+        :kp_uid, :uid_t,
+        :kp_ngroups, :short,
+        :kp_groups, [:gid_t, NGROUPS],
+        :kp_ruid, :uid_t,
+        :kp_svuid, :uid_t,
+        :kp_rgid, :gid_t,
+        :kp_svgid, :gid_t,
+        :kp_pid, :pid_t,
+        :kp_ppid, :pid_t,
+        :kp_pgid, :pid_t,
+        :kp_jobc, :int,
+        :kp_sid, :pid_t,
+        :kp_login, [:char, roundup(MAXLOGNAME, FFI::Type::LONG.size)],
+        :kp_tdev, :dev_t,
+        :kp_tpgid, :pid_t,
+        :kp_tsid, :pid_t,
+        :kp_exitstat, :ushort,
+        :kp_nthreads, :int,
+        :kp_nice, :int,
+        :kp_swtime, :uint,
+        :kp_vm_map_size, :size_t,
+        :kp_vm_rssize, :segsz_t,
+        :kp_vm_swrss, :segsz_t,
+        :kp_vm_tsize, :segsz_t,
+        :kp_vm_dsize, :segsz_t,
+        :kp_vm_ssize, :segsz_t,
+        :kp_vm_prssize, :uint,
+        :kp_jailid, :int,
+        :kp_ru, Rusage,
+        :kp_cru, Rusage,
+        :kp_auxflags, :int,
+        :kp_lwp, KInfoLWP,
+        :kp_ktaddr, :uintptr_t,
+        :kp_spare, [:int, 2]
+      )
+    end
+  end
+end

data/lib/bsd/sys/dragonfly/sys/proctable.rb

@@ -0,0 +1,175 @@
+require_relative 'proctable/constants'
+require_relative 'proctable/structs'
+require_relative 'proctable/functions'
+require 'sys/proctable/version'
+
+module Sys
+  class ProcTable
+    include Sys::ProcTableConstants
+    include Sys::ProcTableStructs
+    extend Sys::ProcTableFunctions
+
+    # Error typically raised if the ProcTable.ps method fails.
+    class Error < StandardError; end
+
+    # There is no constructor
+    private_class_method :new
+
+    @fields = %w[
+      paddr flags stat lock acflag traceflag fd siglist sigignore
+      sigcatch sigflag start comm uid ngroups groups ruid svuid
+      rgid svgid pid ppid pgid jobc sid login tdev tpgid tsid exitstat
+      nthreads nice swtime vm_map_size vm_rssize vm_swrss vm_tsize
+      vm_dsize vm_ssize vm_prssize jailid ru cru auxflags lwp ktaddr
+    ]
+
+    ProcTableStruct = Struct.new('ProcTableStruct', *@fields) do
+      alias cmdline comm
+    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)
+    #
+    def self.ps(**kwargs)
+      pid = kwargs[:pid]
+
+      begin
+        kd = kvm_open(nil, nil, nil, 0, nil)
+
+        if kd.null?
+          raise SystemCallError.new('kvm_open', FFI.errno)
+        end
+
+        ptr = FFI::MemoryPointer.new(:int) # count
+
+        if pid
+          procs = kvm_getprocs(kd, KERN_PROC_PID, pid, ptr)
+        else
+          procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, ptr)
+        end
+
+        if procs.null?
+          if pid && FFI.errno == Errno::ESRCH::Errno
+            return nil
+          else
+            raise SystemCallError.new('kvm_getprocs', FFI.errno)
+          end
+        end
+
+        count = ptr.read_int
+        array = []
+
+        0.upto(count-1){ |i|
+          cmd = nil
+          kinfo = KInfoProc.new(procs[i * KInfoProc.size])
+
+          args = kvm_getargv(kd, kinfo, 0)
+
+          unless args.null?
+            cmd = []
+
+            until ((ptr = args.read_pointer).null?)
+              cmd << ptr.read_string
+              args += FFI::Type::POINTER.size
+            end
+
+            cmd = cmd.join(' ')
+          end
+
+          struct = ProcTableStruct.new(
+            kinfo[:kp_paddr],
+            kinfo[:kp_flags],
+            kinfo[:kp_stat],
+            kinfo[:kp_lock],
+            kinfo[:kp_acflag],
+            kinfo[:kp_traceflag],
+            kinfo[:kp_fd],
+            kinfo[:kp_siglist].bits,
+            kinfo[:kp_sigignore].bits,
+            kinfo[:kp_sigcatch].bits,
+            kinfo[:kp_sigflag],
+            Time.at(kinfo[:kp_start][:tv_sec]),
+            kinfo[:kp_comm].to_s,
+            kinfo[:kp_uid],
+            kinfo[:kp_ngroups],
+            kinfo[:kp_groups].to_a[0..kinfo[:kp_ngroups]-1],
+            kinfo[:kp_ruid],
+            kinfo[:kp_svuid],
+            kinfo[:kp_rgid],
+            kinfo[:kp_svgid],
+            kinfo[:kp_pid],
+            kinfo[:kp_ppid],
+            kinfo[:kp_pgid],
+            kinfo[:kp_jobc],
+            kinfo[:kp_sid],
+            kinfo[:kp_login].to_s,
+            kinfo[:kp_tdev],
+            kinfo[:kp_tpgid],
+            kinfo[:kp_tsid],
+            kinfo[:kp_exitstat],
+            kinfo[:kp_nthreads],
+            kinfo[:kp_nice],
+            kinfo[:kp_swtime],
+            kinfo[:kp_vm_map_size],
+            kinfo[:kp_vm_rssize],
+            kinfo[:kp_vm_swrss],
+            kinfo[:kp_vm_tsize],
+            kinfo[:kp_vm_dsize],
+            kinfo[:kp_vm_ssize],
+            kinfo[:kp_vm_prssize],
+            kinfo[:kp_jailid],
+            kinfo[:kp_ru],
+            kinfo[:kp_cru],
+            kinfo[:kp_auxflags],
+            kinfo[:kp_lwp],
+            kinfo[:kp_ktaddr],
+          )
+
+          struct.freeze # This is readonly data
+
+          if block_given?
+            yield struct
+          else
+            array << struct
+          end
+        }
+      ensure
+        kvm_close(kd) unless kd.null?
+      end
+
+      if block_given?
+        nil
+      else
+        pid ? array.first : array
+      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
+    end
+  end
+end

data/lib/{freebsd → bsd/sys/freebsd}/sys/proctable.rb

@@ -77,7 +77,7 @@ module Sys
       layout(
         :ar_ref, :uint,
         :ar_length, :uint,
-        :ar_args, [:uchar,1]
+        :ar_args, [:uchar, 1]
       )
     end
 

data/lib/bsd/sys/proctable.rb

@@ -0,0 +1,8 @@
+case RbConfig::CONFIG['host_os']
+  when /freebsd/i
+    require_relative 'freebsd/sys/proctable'
+  when /dragonfly/i
+    require_relative 'dragonfly/sys/proctable'
+  else
+    raise "Unsupported version of BSD"
+end

data/lib/darwin/sys/proctable.rb

@@ -11,21 +11,32 @@ module Sys
     # There is no constructor
     private_class_method :new
 
-    private
-
     PROC_PIDTASKALLINFO = 2
     PROC_PIDTHREADINFO  = 5
     PROC_PIDLISTTHREADS = 6
 
+    private_constant :PROC_PIDTASKALLINFO
+    private_constant :PROC_PIDTHREADINFO
+    private_constant :PROC_PIDLISTTHREADS
+
     CTL_KERN       = 1
     KERN_PROCARGS  = 38
     KERN_PROCARGS2 = 49
     MAXCOMLEN      = 16
     MAXPATHLEN     = 256
 
+    private_constant :CTL_KERN
+    private_constant :KERN_PROCARGS
+    private_constant :KERN_PROCARGS2
+    private_constant :MAXCOMLEN
+    private_constant :MAXPATHLEN
+
     MAXTHREADNAMESIZE = 64
     PROC_PIDPATHINFO_MAXSIZE = MAXPATHLEN * 4
 
+    private_constant :MAXTHREADNAMESIZE
+    private_constant :PROC_PIDPATHINFO_MAXSIZE
+
     # JRuby/Truffleruby on Mac
     unless defined? FFI::StructLayout::CharArray
       if defined? FFI::StructLayout::CharArrayProxy
@@ -62,6 +73,8 @@ module Sys
       )
     end
 
+    private_constant :ProcBsdInfo
+
     class ProcTaskInfo < FFI::Struct
       layout(
         :pti_virtual_size, :uint64_t,
@@ -85,6 +98,8 @@ module Sys
       )
     end
 
+    private_constant :ProcTaskInfo
+
     class ProcThreadInfo < FFI::Struct
       layout(
         :pth_user_time, :uint64_t,
@@ -101,28 +116,37 @@ module Sys
       )
     end
 
+    private_constant :ProcThreadInfo
+
     # Map the fields from the FFI::Structs to the Sys::ProcTable struct on
     # class load to reduce the amount of objects needing to be generated for
     # each invocation of Sys::ProcTable.ps
-    all_members           = ProcBsdInfo.members + ProcTaskInfo.members + ProcThreadInfo.members
-    PROC_STRUCT_FIELD_MAP = all_members.map { |member|
+    all_members = ProcBsdInfo.members + ProcTaskInfo.members + ProcThreadInfo.members
+
+    PROC_STRUCT_FIELD_MAP = all_members.map do |member|
                               temp = member.to_s.split('_')
                               sproperty = temp.size > 1 ? temp[1..-1].join('_') : temp.first
                               [member, sproperty.to_sym]
-                            }.to_h
+                            end.to_h
 
     class ProcTaskAllInfo < FFI::Struct
       layout(:pbsd, ProcBsdInfo, :ptinfo, ProcTaskInfo)
     end
 
+    private_constant :ProcTaskAllInfo
+
     ffi_lib 'proc'
 
-    attach_function :proc_listallpids, [:pointer, :int], :int
-    attach_function :proc_pidinfo, [:int, :int, :uint64_t, :pointer, :int], :int
+    attach_function :proc_listallpids, %i[pointer int], :int
+    attach_function :proc_pidinfo, %i[int int uint64_t pointer int], :int
 
     ffi_lib FFI::Library::LIBC
 
-    attach_function :sysctl, [:pointer, :uint, :pointer, :pointer, :pointer, :size_t], :int
+    attach_function :sysctl, %i[pointer uint pointer pointer pointer size_t], :int
+
+    private_class_method :proc_listallpids
+    private_class_method :proc_pidinfo
+    private_class_method :sysctl
 
     # These mostly mimic the struct members, but we've added a few custom ones as well.
     @fields = %w[
@@ -136,16 +160,18 @@ module Sys
 
     # Add a couple aliases to make it similar to Linux
     ProcTableStruct = Struct.new("ProcTableStruct", *@fields) do
-      alias vsize virtual_size
-      alias rss resident_size
+      alias_method :vsize, :virtual_size
+      alias_method :rss, :resident_size
     end
 
+    private_constant :ProcTableStruct
+
     ThreadInfoStruct = Struct.new("ThreadInfo", :user_time, :system_time,
       :cpu_usage, :policy, :run_state, :flags, :sleep_time, :curpri,
       :priority, :maxpriority, :name
     )
 
-    public
+    private_constant :ThreadInfoStruct
 
     # 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
@@ -222,7 +248,7 @@ module Sys
         array = block_given? ? nil : []
 
         pids.each do |lpid|
-          next unless pid == lpid if pid
+          next if pid && pid != lpid
           info = ProcTaskAllInfo.new
 
           nb = proc_pidinfo(lpid, PROC_PIDTASKALLINFO, 0, info, info.size)
@@ -258,8 +284,6 @@ module Sys
       end
     end
 
-    private
-
     # Pass by reference method that updates the Ruby struct based on the FFI struct.
     #
     def self.apply_info_to_struct(info, struct)
@@ -275,6 +299,8 @@ module Sys
       end
     end
 
+    private_class_method :apply_info_to_struct
+
     # Returns an array of ThreadInfo objects for the given pid.
     #
     def self.get_thread_info(pid, struct, ptinfo)
@@ -292,7 +318,7 @@ module Sys
       max = ptinfo[:pti_threadnum]
       struct[:threadinfo] = []
 
-      0.upto(max-1) do |index|
+      0.upto(max - 1) do |index|
         tinfo = ProcThreadInfo.new
 
         # Use read_array_of_uint64 for compatibility with JRuby if necessary.
@@ -304,7 +330,7 @@ module Sys
 
         if nb <= 0
           if [Errno::EPERM::Errno, Errno::ESRCH::Errno].include?(FFI.errno)
-            return # Either we don't have permission, or the pid no longer exists
+            next # Either we don't have permission, or the pid no longer exists
           else
             raise SystemCallError.new('proc_pidinfo', FFI.errno)
           end
@@ -321,15 +347,21 @@ module Sys
           tinfo[:pth_curpri],
           tinfo[:pth_priority],
           tinfo[:pth_maxpriority],
-          tinfo[:pth_name].to_s,
+          tinfo[:pth_name].to_s
         )
 
         struct[:threadinfo] << tinfo_struct
       end
     end
 
+    private_class_method :get_thread_info
+
     # Get the command line arguments, as well as the environment settings,
     # for the given PID.
+    #--
+    # Note that on Big Sur and later it seems that you cannot get environment
+    # variable information on spawned processes except in certain circumstances,
+    # e.g. SIP has been disabled, the kernel is in debug mode, etc.
     #
     def self.get_cmd_args_and_env(pid, struct)
       len = FFI::MemoryPointer.new(:size_t)
@@ -389,22 +421,23 @@ module Sys
 
       # Extract the full command line and its arguments from the array
       argc.times do
-        cmdline << ' ' + array.shift
+        cmdline << ' ' << array.shift
       end
 
       struct[:cmdline] = cmdline.strip
 
       # Anything remaining at this point is a collection of key=value
       # pairs which we convert into a hash.
-      environ = array.inject({}) do |hash, string|
+      environ = array.each_with_object({}) do |string, hash|
         if string && string.include?('=')
           key, value = string.split('=')
           hash[key] = value
         end
-        hash
       end
 
       struct[:environ] = environ
     end
+
+    private_class_method :get_cmd_args_and_env
   end
 end