sys-proctable 1.2.7 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc04e64b1355f4df7eef6d44666c323d45bb3d6dde7ced1d078ab7b3a0108367
-  data.tar.gz: 64227d33681d13797ca0911199d2040f097e32de56656506d28f232d2adb7938
+  metadata.gz: 30b96245d1885b969f8aaa3098d42e38082ef4b3eb221c77aaa009aeff77f6af
+  data.tar.gz: 569dea384f6de6a9c1f1bea3a44cc62295e93f07fb7f6cc81d085a23746cf7c8
 SHA512:
-  metadata.gz: 1fa256e92c462347cabca2d4992c74dc5cbfdf7985159668b74617863b321d663209239d4d5c3e00f3cf4cf8275ace09d464fe1782024b2c21855c7128c4a4f1
-  data.tar.gz: 6c16116b746153a4f75932c5d2f1f5ab560100d648dd5bc904b4f1aca3b434b8667ef41fd89d34e23b303fff38fa6e7a9f089d42be60d8f4628c34e46aeb87af
+  metadata.gz: e16055b962e3d7af78309f5e47286e1def1f391b28a818fd4a8f2937e561b17c5dfcf050a5db0b355846639c7314f9a8c1615db6028bf8f4ba9130832532f84a
+  data.tar.gz: f2b69818ad45bb9e959eff7c9fe9e4137dc7aecc59378c332ef1637011d8ea1c9ec19749a9ea912f19d694502ba1d989eb37a5e0ab0a4cea51c63a304c134c13

data/CHANGES.md

@@ -1,3 +1,8 @@
+## 1.3.0 - 26-Dec-2022
+* Added DragonflyBSD support.
+* Reorganized the BSD code so that FreeBSD and Dragonfly BSD live in their
+  own space for easier maintenance.
+
 ## 1.2.7 - 28-Oct-2022
 * Fix bug on Solaris where it would fail trying to read zero-byte pseudo-kernel
   processes. Thanks go to Robert Waffen for the spot and the patch.

data/MANIFEST.md

@@ -14,7 +14,14 @@
 * lib/sys/proctable/version.rb
 * lib/aix/sys/proctable.rb
 * lib/darwin/sys/proctable.rb
-* lib/freebsd/sys/proctable.rb
+* lib/bsd/sys/dragonfly/sys/proctable.rb
+* lib/bsd/sys/dragonfly/sys/proctable/constants.rb
+* lib/bsd/sys/dragonfly/sys/proctable/functions.rb
+* lib/bsd/sys/dragonfly/sys/proctable/structs.rb
+* lib/bsd/sys/freebsd/sys/proctable.rb
+* lib/bsd/sys/freebsd/sys/proctable/constants.rb
+* lib/bsd/sys/freebsd/sys/proctable/functions.rb
+* lib/bsd/sys/freebsd/sys/proctable/structs.rb
 * lib/linux/sys/proctable.rb
 * lib/sunos/sys/proctable.rb
 * lib/windows/sys/proctable.rb

data/README.md

@@ -18,6 +18,7 @@
 * Windows 2000 or later
 * Linux 2.6+
 * FreeBSD
+* DragonflyBSD
 * Solaris 8+
 * OS X 10.7+
 * AIX 5.3+

data/Rakefile

@@ -63,9 +63,9 @@ RSpec::Core::RakeTask.new(:spec) do |t|
     when /darwin/i
       t.rspec_opts = '-Ilib/darwin'
       t.pattern << 'spec/sys_proctable_darwin_spec.rb'
-    when /freebsd/i
-      t.rspec_opts = '-Ilib/freebsd'
-      t.pattern << 'spec/sys_proctable_freebsd_spec.rb'
+    when /bsd|dragonfly/i
+      t.rspec_opts = '-Ilib/bsd'
+      t.pattern << 'spec/sys_proctable_bsd_spec.rb'
     when /linux/i
       t.rspec_opts = '-Ilib/linux'
       t.pattern << 'spec/sys_proctable_linux_spec.rb'

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

@@ -0,0 +1,11 @@
+module Sys
+  module ProcTableConstants
+    WMESGLEN   = 8
+    MAXCOMLEN  = 16
+    NGROUPS    = 16
+    MAXLOGNAME = 33
+
+    KERN_PROC_ALL = 0
+    KERN_PROC_PID = 1
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'ffi'
+
+module Sys
+  module ProcTableFunctions
+    extend FFI::Library
+    ffi_lib :kvm
+
+    attach_function :devname, [:dev_t, :mode_t], :string
+    attach_function :kvm_open, [:string, :string, :string, :int, :string], :pointer
+    attach_function :kvm_close, [:pointer], :int
+    attach_function :kvm_getprocs, [:pointer, :int, :int, :pointer], :pointer
+    attach_function :kvm_getargv, [:pointer, :pointer, :int], :pointer
+  end
+end

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/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/sys/proctable/version.rb

@@ -1,6 +1,6 @@
 module Sys
   class ProcTable
     # The version of the sys-proctable library
-    VERSION = '1.2.7'.freeze
+    VERSION = '1.3.0'.freeze
   end
 end

data/lib/sys/proctable.rb

@@ -5,8 +5,8 @@ case RbConfig::CONFIG['host_os']
     require_relative '../aix/sys/proctable'
   when /darwin/i
     require_relative '../darwin/sys/proctable'
-  when /freebsd/i
-    require_relative '../freebsd/sys/proctable'
+  when /freebsd|dragonfly/i
+    require_relative '../bsd/sys/proctable'
   when /linux/i
     require_relative '../linux/sys/proctable'
   when /sunos|solaris/i

data/lib/sys/top.rb

@@ -20,13 +20,18 @@ module Sys
 
       aix = RbConfig::CONFIG['host_os'] =~ /aix/i
       darwin = RbConfig::CONFIG['host_os'] =~ /darwin/i
+      dragonfly = RbConfig::CONFIG['host_os'] =~ /dragonfly/i
 
       # Sort by pid on Windows and AIX by default
       if (File::ALT_SEPARATOR || aix || darwin) && field == 'pctcpu'
         field = 'pid'
       end
 
-      Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+      if dragonfly && field == 'pctcpu'
+        Sys::ProcTable.ps.sort_by{ |obj| obj.lwp.pctcpu }[0..num-1]
+      else
+        Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -6,7 +6,9 @@ RSpec.configure do |config|
   config.filter_run_excluding(:aix) unless RbConfig::CONFIG['host_os'] =~ /aix/i
   config.filter_run_excluding(:darwin) unless RbConfig::CONFIG['host_os'] =~ /mac|darwin/i
   config.filter_run_excluding(:linux) unless RbConfig::CONFIG['host_os'] =~ /linux/i
+  config.filter_run_excluding(:bsd) unless RbConfig::CONFIG['host_os'] =~ /bsd|dragonfly/i
   config.filter_run_excluding(:freebsd) unless RbConfig::CONFIG['host_os'] =~ /freebsd/i
+  config.filter_run_excluding(:dragonfly) unless RbConfig::CONFIG['host_os'] =~ /dragonfly/i
   config.filter_run_excluding(:sunos) unless RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
   config.filter_run_excluding(:windows) unless Gem.win_platform?
   config.filter_run_excluding(:jruby) if RUBY_PLATFORM == 'java'

data/spec/sys_proctable_all_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe 'common' do
 
   context 'constants' do
     it 'has a VERSION constant set to the expected value' do
-      expect(Sys::ProcTable::VERSION).to eql('1.2.7')
+      expect(Sys::ProcTable::VERSION).to eql('1.3.0')
       expect(Sys::ProcTable::VERSION).to be_frozen
     end
 

data/spec/{sys_proctable_freebsd_spec.rb → sys_proctable_bsd_spec.rb}

@@ -1,13 +1,14 @@
 ################################################################
-# sys_proctable_freebsd_rspec.rb
+# sys_proctable_bsd_rspec.rb
 #
-# Test suite for FreeBSD for the sys-proctable library.
-# You should run these tests via the 'rake spec' task.
+# Specs for BSD related operating systems for the sys-proctable
+# library. You should run these tests via the 'rake spec' task.
 ################################################################
 require 'spec_helper'
+require 'mkmf-lite'
 
-RSpec.describe Sys::ProcTable, :freebsd do
-  let(:fields){
+RSpec.describe Sys::ProcTable, :bsd do
+  let(:fields_freebsd){
     %w[
       pid ppid pgid tpgid sid tsid jobc uid ruid rgid
       ngroups groups size rssize swrss tsize dsize ssize
@@ -19,12 +20,23 @@ RSpec.describe Sys::ProcTable, :freebsd do
     ]
   }
 
+  let(:fields_dragonfly){
+    %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
+    ]
+  }
+
   context 'fields singleton method' do
     it 'responds to a fields method' do
       expect(described_class).to respond_to(:fields)
     end
 
     it 'returns the expected results for the fields method' do
+      fields = RbConfig::CONFIG['host_os'] =~ /freebsd/i ? fields_freebsd : fields_dragonfly
       expect(described_class.fields).to be_kind_of(Array)
       expect(described_class.fields).to eql(fields)
     end
@@ -64,47 +76,47 @@ RSpec.describe Sys::ProcTable, :freebsd do
       expect(process.comm).to be_kind_of(String)
     end
 
-    it 'contains a state member and returns the expected value' do
+    it 'contains a state member and returns the expected value', :freebsd do
       expect(process).to respond_to(:state)
       expect(process.state).to be_kind_of(String)
     end
 
-    it 'contains a pctcpu member and returns the expected value' do
+    it 'contains a pctcpu member and returns the expected value', :freebsd do
       expect(process).to respond_to(:pctcpu)
       expect(process.pctcpu).to be_kind_of(Float)
     end
 
-    it 'contains a oncpu member and returns the expected value' do
+    it 'contains a oncpu member and returns the expected value', :freebsd do
       expect(process).to respond_to(:oncpu)
       expect(process.oncpu).to be_kind_of(Integer)
     end
 
-    it 'contains a ttynum member and returns the expected value' do
+    it 'contains a ttynum member and returns the expected value', :freebsd do
       expect(process).to respond_to(:ttynum)
       expect(process.ttynum).to be_kind_of(Integer)
     end
 
-    it 'contains a ttydev member and returns the expected value' do
+    it 'contains a ttydev member and returns the expected value', :freebsd do
       expect(process).to respond_to(:ttydev)
       expect(process.ttydev).to be_kind_of(String)
     end
 
-    it 'contains a wmesg member and returns the expected value' do
+    it 'contains a wmesg member and returns the expected value', :freebsd do
       expect(process).to respond_to(:wmesg)
       expect(process.wmesg).to be_kind_of(String)
     end
 
-    it 'contains a runtime member and returns the expected value' do
+    it 'contains a runtime member and returns the expected value', :freebsd do
       expect(process).to respond_to(:runtime)
       expect(process.runtime).to be_kind_of(Integer)
     end
 
-    it 'contains a priority member and returns the expected value' do
+    it 'contains a priority member and returns the expected value', :freebsd do
       expect(process).to respond_to(:priority)
       expect(process.priority).to be_kind_of(Integer)
     end
 
-    it 'contains a usrpri member and returns the expected value' do
+    it 'contains a usrpri member and returns the expected value', :freebsd do
       expect(process).to respond_to(:usrpri)
       expect(process.usrpri).to be_kind_of(Integer)
     end
@@ -124,85 +136,109 @@ RSpec.describe Sys::ProcTable, :freebsd do
       expect(process.start).to be_kind_of(Time)
     end
 
-    it 'contains a maxrss member and returns the expected value' do
+    it 'contains a maxrss member and returns the expected value', :freebsd do
       expect(process).to respond_to(:maxrss)
       expect(process.maxrss).to be_kind_of(Integer)
     end
 
-    it 'contains a ixrss member and returns the expected value' do
+    it 'contains a ixrss member and returns the expected value', :freebsd do
       expect(process).to respond_to(:ixrss)
       expect(process.ixrss).to be_kind_of(Integer)
     end
 
     # TODO: The value returned on PC BSD 10 does not appear to be valid. Investigate.
-    it 'contains a idrss member and returns the expected value' do
+    it 'contains a idrss member and returns the expected value', :freebsd do
       expect(process).to respond_to(:idrss)
       expect(process.idrss).to be_kind_of(Numeric)
     end
 
-    it 'contains a isrss member and returns the expected value' do
+    it 'contains a isrss member and returns the expected value', :freebsd do
       expect(process).to respond_to(:isrss)
       expect(process.isrss).to be_kind_of(Integer)
     end
 
-    it 'contains a minflt member and returns the expected value' do
+    it 'contains a minflt member and returns the expected value', :freebsd do
       expect(process).to respond_to(:minflt)
       expect(process.minflt).to be_kind_of(Integer)
     end
 
-    it 'contains a majflt member and returns the expected value' do
+    it 'contains a majflt member and returns the expected value', :freebsd do
       expect(process).to respond_to(:majflt)
       expect(process.majflt).to be_kind_of(Integer)
     end
 
-    it 'contains a nswap member and returns the expected value' do
+    it 'contains a nswap member and returns the expected value', :freebsd do
       expect(process).to respond_to(:nswap)
       expect(process.nswap).to be_kind_of(Integer)
     end
 
-    it 'contains a inblock member and returns the expected value' do
+    it 'contains a inblock member and returns the expected value', :freebsd do
       expect(process).to respond_to(:inblock)
       expect(process.inblock).to be_kind_of(Integer)
     end
 
-    it 'contains a oublock member and returns the expected value' do
+    it 'contains a oublock member and returns the expected value', :freebsd do
       expect(process).to respond_to(:oublock)
       expect(process.oublock).to be_kind_of(Integer)
     end
 
-    it 'contains a msgsnd member and returns the expected value' do
+    it 'contains a msgsnd member and returns the expected value', :freebsd do
       expect(process).to respond_to(:msgsnd)
       expect(process.msgsnd).to be_kind_of(Integer)
     end
 
-    it 'contains a msgrcv member and returns the expected value' do
+    it 'contains a msgrcv member and returns the expected value', :freebsd do
       expect(process).to respond_to(:msgrcv)
       expect(process.msgrcv).to be_kind_of(Integer)
     end
 
-    it 'contains a nsignals member and returns the expected value' do
+    it 'contains a nsignals member and returns the expected value', :freebsd do
       expect(process).to respond_to(:nsignals)
       expect(process.nsignals).to be_kind_of(Integer)
     end
 
-    it 'contains a nvcsw member and returns the expected value' do
+    it 'contains a nvcsw member and returns the expected value', :freebsd do
       expect(process).to respond_to(:nvcsw)
       expect(process.nvcsw).to be_kind_of(Integer)
     end
 
-    it 'contains a nivcsw member and returns the expected value' do
+    it 'contains a nivcsw member and returns the expected value', :freebsd do
       expect(process).to respond_to(:nivcsw)
       expect(process.nivcsw).to be_kind_of(Integer)
     end
 
-    it 'contains a utime member and returns the expected value' do
+    it 'contains a utime member and returns the expected value', :freebsd do
       expect(process).to respond_to(:utime)
       expect(process.utime).to be_kind_of(Integer)
     end
 
-    it 'contains a stime member and returns the expected value' do
+    it 'contains a stime member and returns the expected value', :freebsd do
       expect(process).to respond_to(:stime)
       expect(process.stime).to be_kind_of(Integer)
     end
   end
+
+  context 'C struct verification' do
+    let(:dummy){ Class.new{ extend Mkmf::Lite } }
+
+    it 'has a timeval struct of the expected size' do
+      expect(Sys::ProcTableStructs::Timeval.size).to eq(dummy.check_sizeof('struct timeval', 'sys/time.h'))
+    end
+
+    it 'has an rtprio struct of the expected size' do
+      expect(Sys::ProcTableStructs::RTPrio.size).to eq(dummy.check_sizeof('struct rtprio', 'sys/rtprio.h'))
+    end
+
+    it 'has an rusage struct of the expected size' do
+      expect(Sys::ProcTableStructs::Rusage.size).to eq(dummy.check_sizeof('struct rusage', 'sys/resource.h'))
+    end
+
+    it 'has an kinfo_lwp struct of the expected size' do
+      expect(Sys::ProcTableStructs::KInfoLWP.size).to eq(dummy.check_sizeof('struct kinfo_lwp', 'sys/kinfo.h'))
+    end
+
+    it 'has an kinfo_proc struct of the expected size' do
+      expect(Sys::ProcTableStructs::KInfoProc.size).to eq(dummy.check_sizeof('struct kinfo_proc', 'sys/kinfo.h'))
+    end
+  end
 end

data/sys-proctable.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('rake')
   spec.add_development_dependency('rubocop')
   spec.add_development_dependency('rubocop-rspec')
+  spec.add_development_dependency('mkmf-lite')
 
   spec.metadata = {
     'homepage_uri'          => 'https://github.com/djberg96/sys-proctable',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sys-proctable
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.3.0
 platform: ruby
 authors:
 - Daniel J. Berger
@@ -35,7 +35,7 @@ cert_chain:
   ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
   WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
   -----END CERTIFICATE-----
-date: 2022-10-28 00:00:00.000000000 Z
+date: 2022-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -107,6 +107,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mkmf-lite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       The sys-proctable library provides an interface for gathering information
       about processes on your system, i.e. the process table. Most major
@@ -129,8 +143,16 @@ files:
 - certs/djberg96_pub.pem
 - examples/example_ps.rb
 - lib/aix/sys/proctable.rb
+- lib/bsd/sys/dragonfly/sys/proctable.rb
+- lib/bsd/sys/dragonfly/sys/proctable/constants.rb
+- lib/bsd/sys/dragonfly/sys/proctable/functions.rb
+- lib/bsd/sys/dragonfly/sys/proctable/structs.rb
+- lib/bsd/sys/freebsd/sys/proctable.rb
+- lib/bsd/sys/freebsd/sys/proctable/constants.rb
+- lib/bsd/sys/freebsd/sys/proctable/functions.rb
+- lib/bsd/sys/freebsd/sys/proctable/structs.rb
+- lib/bsd/sys/proctable.rb
 - lib/darwin/sys/proctable.rb
-- lib/freebsd/sys/proctable.rb
 - lib/linux/sys/proctable.rb
 - lib/linux/sys/proctable/cgroup_entry.rb
 - lib/linux/sys/proctable/smaps.rb
@@ -144,8 +166,8 @@ files:
 - spec/spec_helper.rb
 - spec/sys_proctable_aix_spec.rb
 - spec/sys_proctable_all_spec.rb
+- spec/sys_proctable_bsd_spec.rb
 - spec/sys_proctable_darwin_spec.rb
-- spec/sys_proctable_freebsd_spec.rb
 - spec/sys_proctable_linux_spec.rb
 - spec/sys_proctable_sunos_spec.rb
 - spec/sys_proctable_windows_spec.rb
@@ -177,7 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: An interface for providing process table information
@@ -185,8 +207,8 @@ test_files:
 - spec/spec_helper.rb
 - spec/sys_proctable_aix_spec.rb
 - spec/sys_proctable_all_spec.rb
+- spec/sys_proctable_bsd_spec.rb
 - spec/sys_proctable_darwin_spec.rb
-- spec/sys_proctable_freebsd_spec.rb
 - spec/sys_proctable_linux_spec.rb
 - spec/sys_proctable_sunos_spec.rb
 - spec/sys_proctable_windows_spec.rb