sys-proctable 0.7.3 → 0.7.4

data/ext/extconf.rb

@@ -0,0 +1,101 @@
+#############################################################################
+# Installation script for sys-proctable.
+#
+# By running this file, it is assumed that you want a C extension, and not
+# a pure Ruby version.  If you want a pure Ruby version (and you're on a 
+# platform for which it's supported), run install.rb instead.
+#############################################################################
+require 'mkmf'
+require 'fileutils'
+
+c_file  = nil
+h_file  = nil
+tc_file = nil
+
+########################################################################
+# Ruby 1.8.3 and later mandates the use of rb_pid_t over pid_t because
+# some libraries define their own pid_t.  So, we check for that.
+########################################################################
+have_type('rb_pid_t', 'ruby.h')
+
+##########################################################################
+# Determine appropriate source files based on platform.  Also, check for
+# certain header files and/or libraries on some platforms.
+#
+# On FreeBSD a different source file is used if the /proc filesystem is
+# not found (kvm is used instead).  For OpenBSD or NetBSD, the kvm
+# interface is always used for now.
+##########################################################################
+case RUBY_PLATFORM
+   when /hpux/i
+      c_file  = 'hpux/hpux.c'
+      h_file  = 'hpux/hpux.h'
+      tc_file = 'tc_hpux'
+   when /freebsd/i
+      if File.exists?('/proc') && Dir['/proc/*'].length > 0
+         c_file  = 'freebsd/freebsd.c'
+         h_file  = 'freebsd/freebsd.h'
+         tc_file = 'tc_freebsd'
+      else
+         have_library('kvm')
+         have_struct_member('struct kinfo_proc', 'kp_proc', 'sys/user.h')
+         have_struct_member('struct kinfo_proc', 'kp_eproc', 'sys/user.h')
+         c_file  = 'bsd/bsd.c'
+         tc_file = 'tc_kvm_bsd.rb'
+      end
+   when /openbsd|netbsd/
+      have_library('kvm')
+      c_file  = 'bsd/bsd.c'
+      tc_file = 'tc_kvm_bsd.rb'
+   when /solaris|sunos/i
+      c_file  = 'sunos/sunos.c'
+      h_file  = 'sunos/sunos.h'
+      tc_file = 'tc_sunos'
+      have_header('procfs.h') # false means Solaris 2.5.x
+   when /linux/i
+      c_file  = 'linux/linux.c'
+      h_file  = 'linux/linux.h'
+      tc_file = 'tc_linux'
+   when /darwin/i
+      c_file = 'darwin/darwin.c'
+      tc_file = 'tc_darwin'
+   when /windows|win32|cygwin|mingw|dos/i
+      msg = 'Use the install_pure_ruby.rb script to install on MS Windows'
+      STDERR.puts msg
+      exit
+   else
+      puts 'This platform not currently supported.  Exiting...'
+      exit
+end
+
+#####################################################################
+# Move the 'windows.rb' file under 'lib/sys/' to '.orig' to prevent
+# mkmf from installing it during the 'make install' phase.
+#####################################################################
+if File.exists?('../lib/sys/windows.rb')
+   File.rename('../lib/sys/windows.rb', '../lib/sys/windows.orig')
+end
+
+###################
+# build ts_all.rb
+###################
+test_file = '../test/ts_all.rb'
+File.open(test_file, 'w'){ |fh|
+   fh.puts '$LOAD_PATH.unshift Dir.pwd'
+   fh.puts '$LOAD_PATH.unshift Dir.pwd + "/lib"'
+   fh.puts '$LOAD_PATH.unshift Dir.pwd + "/ext"'
+   fh.puts "require 'tc_all'"
+   fh.puts "require '#{tc_file}'"
+   fh.puts "require 'tc_top'"
+}
+
+########################################################################
+# Copy or link files to current directory for create_makefile to work.
+######################################################################## 
+File.delete('proctable.c') rescue nil
+File.delete(File.basename(h_file)) rescue nil
+
+File.symlink(c_file, 'proctable.c')
+File.symlink(h_file, File.basename(h_file)) if h_file
+
+create_makefile('sys/proctable')

data/ext/sunos/sunos.c

@@ -0,0 +1,374 @@
+/**************************************************************************
+ * sunos.c (proctable.c)
+ *
+ * Solaris specific code for the Ruby ps extension.  Some code
+ * has been copied directly from Dan Urist's Proc::ProcessTable
+ * Perl module.
+ *
+ * The portion of code that grabs data out of /proc/xxx/as is based
+ * on a post by Roger Faulkner on comp.unix.questions.
+ **************************************************************************/
+#include "ruby.h"
+#include "sunos.h"
+#include "version.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+VALUE sProcStruct, cProcError;
+
+/*
+ * Private method that converts a psinfo struct into a Ruby struct.
+ */
+#ifdef HAVE_PROCFS_H
+static VALUE proctable_getprocstruct(struct psinfo *p, VALUE v_cmd_array)
+#else
+static VALUE proctable_getprocstruct(struct prpsinfo *p, VALUE v_cmd_array)
+#endif
+{
+   char state[STATE_MAX];
+   char comm[COMM_MAX];
+   prusage_t pbuf;
+   VALUE cmdline;
+   VALUE rbTTY = Qnil;
+
+   /*
+    * If we were unable to get the full command line, resort to the limited
+    * pr_psargs struct member.
+    */
+   if(RARRAY(v_cmd_array)->len == 0)
+      cmdline = rb_str_new2(p->pr_psargs);
+   else
+      cmdline = rb_ary_join(v_cmd_array,rb_str_new2(" "));
+
+   if(PRNODEV != p->pr_ttydev)
+      rbTTY = UINT2NUM(p->pr_ttydev);
+   else
+      rbTTY = INT2NUM(-1);
+
+#ifndef HAVE_PROCFS_H
+   char wchan[WCHAN_MAX];
+   sprintf(wchan, "%x", (unsigned int)p->pr_wchan);
+#endif
+
+#ifdef HAVE_PROCFS_H
+   switch(p->pr_lwp.pr_state)
+#else
+   switch(p->pr_state)
+#endif
+   {
+      case SSLEEP: 
+         strcpy(state, SLEEP);
+         break;
+      case SRUN:
+         strcpy(state, RUN);
+         break;
+      case SZOMB:
+         strcpy(state, ZOMBIE);
+         break;
+      case SSTOP:
+         strcpy(state, STOP);
+         break;
+      case SIDL:
+         strcpy(state, IDLE);
+         break;
+      case SONPROC:
+         strcpy(state, ONPROC);
+         break;
+   }
+
+   strcpy(comm, p->pr_fname);
+
+   getprusage(p->pr_pid,&pbuf); /* Get the process usage info */
+
+   return rb_struct_new(sProcStruct,
+      INT2FIX(p->pr_flag),
+#ifdef HAVE_PROCFS_H
+      INT2FIX(p->pr_nlwp),
+#endif
+      UINT2NUM(p->pr_pid),
+      UINT2NUM(p->pr_ppid),
+#ifdef HAVE_PROCFS_H
+      UINT2NUM(p->pr_pgid),
+#else
+      UINT2NUM(p->pr_pgrp),
+#endif
+      UINT2NUM(p->pr_sid),
+      UINT2NUM(p->pr_uid),
+      UINT2NUM(p->pr_euid),
+      UINT2NUM(p->pr_gid),
+      UINT2NUM(p->pr_egid),
+#ifdef HAVE_PROCFS_H
+      INT2FIX(p->pr_lwp.pr_pri),
+      INT2FIX(p->pr_lwp.pr_nice),
+#else
+      INT2FIX(p->pr_pri),
+      INT2FIX(p->pr_nice),
+#endif
+      rbTTY,
+      INT2FIX(p->pr_time.tv_sec),
+      INT2FIX(p->pr_ctime.tv_sec),
+#ifdef HAVE_PROCFS_H
+      INT2FIX(p->pr_size * 1024),
+      INT2FIX(p->pr_rssize * 1024),
+      UINT2NUM(p->pr_lwp.pr_wchan),
+#else
+      INT2FIX(p->pr_bysize),
+      INT2FIX(p->pr_rssize),
+      rb_str_new2(wchan),
+#endif
+      rb_float_new(((double)p->pr_pctcpu)/0x8000*100),
+      rb_float_new(((double)p->pr_pctmem)/0x8000*100),
+      rb_str_new2(state),
+      rb_str_new2(p->pr_fname),
+      cmdline,
+      rb_time_new(p->pr_start.tv_sec,0),
+#ifdef HAVE_PROCFS_H
+      INT2NUM(p->pr_lwp.pr_onpro),
+#endif
+      rb_str_new2(comm),
+      INT2FIX(p->pr_argc),
+      v_cmd_array,
+      LONG2FIX(pbuf.pr_lwpid),
+      INT2FIX(pbuf.pr_count),
+      LONG2FIX(pbuf.pr_tstamp.tv_sec),
+      LONG2FIX(pbuf.pr_create.tv_sec),
+      LONG2FIX(pbuf.pr_term.tv_sec),
+      LONG2FIX(pbuf.pr_rtime.tv_sec),
+      LONG2FIX(pbuf.pr_utime.tv_sec),
+      LONG2FIX(pbuf.pr_stime.tv_sec),
+      LONG2FIX(pbuf.pr_ttime.tv_sec),
+      LONG2FIX(pbuf.pr_tftime.tv_sec),
+      LONG2FIX(pbuf.pr_dftime.tv_sec),
+      LONG2FIX(pbuf.pr_kftime.tv_sec),
+      LONG2FIX(pbuf.pr_ltime.tv_sec),
+      LONG2FIX(pbuf.pr_slptime.tv_sec),
+      LONG2FIX(pbuf.pr_wtime.tv_sec),
+      LONG2FIX(pbuf.pr_stoptime.tv_sec),
+      ULONG2NUM(pbuf.pr_minf),
+      ULONG2NUM(pbuf.pr_majf),
+      ULONG2NUM(pbuf.pr_nswap),
+      ULONG2NUM(pbuf.pr_inblk),
+      ULONG2NUM(pbuf.pr_oublk),
+      ULONG2NUM(pbuf.pr_msnd),
+      ULONG2NUM(pbuf.pr_mrcv),
+      ULONG2NUM(pbuf.pr_sigs),
+      ULONG2NUM(pbuf.pr_vctx),
+      ULONG2NUM(pbuf.pr_ictx),
+      ULONG2NUM(pbuf.pr_sysc),
+      ULONG2NUM(pbuf.pr_ioch)
+   );
+}
+
+/*
+ * call-seq:
+ *    ProcTable.ps(pid=nil)
+ *    ProcTable.ps(pid=nil){ |ps| ... }
+ *
+ * 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+.
+ */
+static VALUE proctable_ps(int argc, VALUE *argv, VALUE klass)
+{
+   DIR *procdir;
+   struct dirent *procdirp;
+   int psdata;
+   char pathbuf[PATH_MAX];
+
+   char* arg;
+   uintptr_t addr_args;
+   uintptr_t* arg_vec;
+   size_t arg_len;
+   int fd, arg_count, i, pid;
+
+   VALUE v_pid;
+   VALUE v_ps_struct = Qnil;
+   VALUE v_array = Qnil;
+   VALUE v_cmd_array = rb_ary_new();
+
+#ifdef HAVE_PROCFS_H
+   struct psinfo p;
+   char as_file[MAXPATHLEN];
+#else
+   struct prpsinfo p;
+#endif
+
+   rb_scan_args(argc, argv, "01", &v_pid);
+
+   if(!rb_block_given_p())
+      v_array = rb_ary_new();
+
+   if( (procdir = opendir( "/proc" )) == NULL )
+      rb_raise(cProcError,"/proc filesystem unreadable");
+
+   while( (procdirp = readdir(procdir)) != NULL )
+   {
+      /* Only look at this file if it's a proc id; that is, all numbers */
+      if(strtok(procdirp->d_name, "0123456789") != NULL ){ continue; }
+
+      /* If a pid is provided, only return info on that pid */
+      if(!NIL_P(v_pid)){
+         pid = NUM2INT(v_pid);
+         if(atoi(procdirp->d_name) != pid)
+            continue;
+      }
+    
+      /* Construct path of the form /proc/proc_number */
+      strcpy(pathbuf, "/proc/"); 
+      strcpy(as_file, "/proc/");
+      strcat(pathbuf, procdirp->d_name);
+      strcat(as_file, procdirp->d_name);
+    
+#ifdef HAVE_PROCFS_H
+      strcat(pathbuf, "/psinfo"); /* Solaris 2.6+ has process info here */
+      strcat(as_file, "/as");
+#endif
+
+      if( (psdata = open( pathbuf, O_RDONLY )) == -1 )
+         continue;
+
+#ifdef HAVE_PROCFS_H
+      read(psdata, (void *) &p, sizeof(struct psinfo));
+#else
+      if(ioctl(psdata, PIOCPSINFO, &p) == -1)
+         continue;
+#endif
+
+#ifdef HAVE_PROCFS_H
+      /*
+       * For those processes where it is possible to read /proc/xxx/as
+       * get the entire command line string.
+       */
+      addr_args = p.pr_argv;
+      arg_count = p.pr_argc;
+
+      if((fd = open(as_file, O_RDONLY)) < 0){
+         /* Do nothing - you can only get info on processes you rights to */
+      }
+      else
+      {
+         arg_vec = malloc(arg_count * sizeof(uintptr_t));
+         
+         /* We need this here to pick up args properly on 2.8+ */
+#ifdef PR_MODEL_NATIVE         
+         if(p.pr_dmodel == PR_MODEL_NATIVE){
+            (void)pread(fd, arg_vec, arg_count * sizeof (uintptr_t), addr_args);
+         }
+         else{
+            caddr32_t *arg_vec32 = (caddr32_t *)arg_vec;
+            (void)pread(fd, arg_vec32, arg_count * sizeof (caddr32_t), addr_args);
+            for (i = arg_count - 1; i >= 0; --i)
+            {
+               arg_vec[i] = arg_vec32[i];
+            }
+         }
+#else
+         /* Need a better patch for 2.6 here */
+         (void)pread(fd, arg_vec, arg_count * sizeof (uintptr_t), addr_args);
+#endif
+
+         arg_len = 16;
+         arg = malloc(arg_len+1);
+         for(i = 0; i < arg_count; i++) {
+
+            if(pread(fd, arg, arg_len, arg_vec[i]) < 0)
+               continue;
+
+            arg[arg_len] = '\0';
+            if(strlen(arg) == arg_len){
+               arg_len *= 2;
+               arg = realloc(arg, arg_len + 1);
+               i--;
+               continue;
+            }
+            rb_ary_push(v_cmd_array, rb_str_new2(arg));
+         }
+         free(arg);
+         free(arg_vec);
+      }
+      close(fd);
+#endif
+
+      close(psdata);
+      v_ps_struct = proctable_getprocstruct(&p, v_cmd_array);
+
+      if(rb_block_given_p()){
+         rb_yield(v_ps_struct);
+      }
+      else{
+         rb_ary_push(v_array, v_ps_struct);
+      }
+      rb_ary_clear(v_cmd_array);
+   }
+   closedir(procdir);
+
+   /* If a process ID was provided and found, return a single struct */
+   if(!NIL_P(v_pid))
+      return v_ps_struct;
+   
+   return v_array; /* nil if block was provided */
+}
+
+/*
+ * call-seq:
+ *    ProcTable.fields
+ *
+ * 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.
+ */
+static VALUE proctable_fields(VALUE klass){
+   uint_t i;
+   VALUE rbFarray = rb_ary_new();
+
+   for(i = 0; i < (sizeof(fields) / sizeof(fields[0])); i++)
+      rb_ary_push(rbFarray, rb_str_new2(fields[i]));
+
+   return rbFarray;
+}
+
+/*
+ * A Ruby interface for gathering process table information.
+ */
+void Init_proctable(){
+   VALUE mSys, cProcTable;
+
+   /* Modules and Classes */
+   mSys = rb_define_module("Sys");
+   cProcTable = rb_define_class_under(mSys, "ProcTable", rb_cObject);
+   cProcError = rb_define_class_under(mSys, "ProcTableError", rb_eStandardError);
+   
+   /* Class methods */
+   rb_define_singleton_method(cProcTable, "fields", proctable_fields, 0);
+   rb_define_singleton_method(cProcTable, "ps", proctable_ps, -1);
+
+   /* Constants */
+   rb_define_const(cProcTable, "VERSION", rb_str_new2(SYS_PROCTABLE_VERSION));
+
+   /* Structs */
+   sProcStruct = rb_struct_define("ProcTableStruct","flag",
+#ifdef HAVE_PROCFS_H
+"nlwp",
+#endif
+      "pid","ppid","pgid","sid","uid","euid","gid","egid","priority","nice",
+      "ttydev","time","ctime","size","rss","wchan","pctcpu","pctmem","state",
+      "fname","cmdline","start",
+#ifdef HAVE_PROCFS_H
+"processor",
+#endif
+      "comm","num_args","cmd_args","lwpid","count","tstamp","create","term",
+      "rtime","utime","stime","ttime","tftime","dftime","kftime","ltime",
+      "slptime","wtime","stoptime","minf","majf","nswap","inblk","oublk",
+      "msnd","mrcv","sigs","vctx","ictx","sysc","ioch",NULL
+      ); 
+}
+
+#ifdef __cplusplus
+}
+#endif