solaris-kstat 0.2.2

data/CHANGES

@@ -0,0 +1,29 @@
+== 0.2.2 - 10-Jul-2006
+* Updated the gemspec (and put a gem out on RubyForge).
+
+== 0.2.1 - 31-Mar-2005
+* Added some taint checking for string arguments.
+* Added better error messages for various kstat related C function failures.
+* Made this document rdoc friendly.
+* Modified the test suite slightly because the "ifb" module is not, in fact,
+  found on all Solaris systems.
+* Added a gemspec.
+* Added more tests.
+* Added an acknowledgement.
+* Removed the kstat.txt and kstat.rd files.  The documentation is now
+  located in the README file, though the source files are still rdoc friendly.
+
+== 0.2.0 - 18-Jan-2005
+* Altered the API to accept a module, instance and name.  This release is
+  still backwards compatable with the 0.1.x version.
+* Added Kstat#module, Kstat#instance and Kstat#name.
+* Documentation updates
+* More tests added
+
+== 0.1.1 - 9-Nov-2004
+* Added support for the cpu_stat module.
+* Moved 'examples' to toplevel directory.
+* Some attempts made to make documentation more rdoc friendly.
+
+== 0.1.0 - 6-Oct-2004
+* Initial release

data/MANIFEST

@@ -0,0 +1,12 @@
+CHANGES
+MANIFEST
+README
+extconf.rb
+solaris-kstat.gemspec
+
+examples/test.rb
+
+lib/solaris/rkstat.c
+lib/solaris/rkstat.h
+
+test/tc_kstat.rb

data/README

@@ -0,0 +1,100 @@
+== Description
+   Ruby extension for the Solaris kstat library.
+   
+== Prerequisites
+   Solaris 8 or later.
+   Ruby 1.8.x
+
+== Installation
+   ruby extconf.rb
+   make
+   ruby test/tc_kstat.rb (optional)
+   make site-install
+
+== Synopsis
+   require "solaris/kstat"
+   require "pp"
+   include Solaris
+
+   k = Kstat.new("cpu_info",0,"cpu_info0")
+   pp k
+
+   {"cpu_info"=>
+      {0=>
+      {"cpu_info0"=>
+         {"chip_id"=>0,
+          "fpu_type"=>"sparcv9",
+          "device_ID"=>0,
+          "cpu_type"=>"sparcv9",
+          "implementation"=>"Unknown",
+          "clock_MHz"=>502,
+          "state_begin"=>1105974702,
+          "state"=>"on-line"}}}}
+   
+== Class Methods
+Kstat.new(module=nil, instance=-1, name=nil)
+   Creates and returns a Kstat object.  This does not traverse the kstat
+   chain.  The Kstat#record method uses the values passed to actually
+   retrieve data.
+
+   You may specify a module, an instance and a name.  The module defaults to
+   nil (all modules), the instance defaults to -1 (all instances) and the
+   name defaults to nil (all names).
+   
+== Instance Methods
+Kstat#record
+   Returns a nested hash based on the values passed to the constructor.  How
+   deeply that hash is nested depends on the values passed to the constructor.
+   The more specific your criterion, the less data you will receive.
+
+== Error Classes
+KstatError < StandardError
+   Raised if anything goes wrong.  Typically, this will only occur if you
+   pass bad arguments to the constructor (e.g. a module name that doesn't
+   exist, etc).
+   
+== Unsupported names
+   The following names will not return any meaningful value:
+
+   * kstat_headers
+   * sfmmu_global_stat
+   * sfmmu_percpu_stat
+   
+== Known Bugs
+   You will receive a couple warnings during the build process.  You
+   can ignore these.
+
+== Designer's Notes
+   I have noticed that results from the cpu_stat module differ from the output
+   of the 'kstat' command line tool. I am convinced that my code is correct and
+   that there is a bug in the Solaris::Kstat Perl module.  Unfortunately, the
+   source for the version of Solaris::Kstat that works on Solaris 8 and later is
+   not available (the version on CPAN only works on Solaris 6 and 7).
+
+   See http://tinyurl.com/karxw for more details.
+   
+== Acknowledgements
+   Thanks go to Charlie Mills for help with the 'volatile' issue.
+
+== Future Plans
+   Eliminate warnings that occur during the build process.
+   
+== License
+   Ruby's
+
+== Copyright
+   (C) 2003-2006 Daniel J. Berger
+   All Rights Reserved
+    
+== Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+	 
+== Author
+   Daniel J. Berger
+   djberg96 at gmail dot com
+   imperator on IRC (freenode)
+    
+== See Also
+   kstat(1M)

data/examples/test.rb

@@ -0,0 +1,43 @@
+########################################################
+# test_kstat.rb
+#
+# Sample script for general futzing.
+########################################################
+base = File.basename(Dir.pwd)
+
+if base == "examples" || base =~ /solaris-kstat.*/
+   require "ftools"
+   Dir.chdir ".." if base == "examples"
+   Dir.mkdir("solaris") unless File.exists?("solaris")
+   File.copy("kstat.so","solaris")
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "solaris/kstat"
+require "pp"
+include Solaris
+
+puts "VERSION: " + Kstat::VERSION
+puts
+
+k1 = Kstat.new("cpu_info",0)
+pp k1.record
+
+puts "=" * 40
+
+k2 = Kstat.new("unix",0,"flushmeter")
+pp k2
+
+# Print all modules
+k = Kstat.new
+k.record.each{ |k,v|
+   p k
+}
+
+=begin
+pp k.record["cpu_info"][0]["cpu_info0"]
+puts "=" * 40
+pp k.record["unix"][0]["flushmeter"]
+puts "=" * 40
+pp k.record["cpu_stat"][0]["cpu_stat0"]
+=end

data/extconf.rb

@@ -0,0 +1,14 @@
+require "mkmf"
+require "ftools"
+
+File.copy("lib/solaris/rkstat.c",".")
+File.copy("lib/solaris/rkstat.h",".")
+
+# This package requires Solaris 2.8 or later
+unless have_header("kstat.h")
+   STDERR.puts "The kstat.h header file was not found.  Exiting."
+   exit
+end
+
+have_library("kstat")
+create_makefile("solaris/kstat")

data/lib/solaris/rkstat.c

@@ -0,0 +1,208 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <kstat.h>
+#include <nfs/nfs.h>
+#include <nfs/nfs_clnt.h>
+#include <sys/utsname.h>
+#include <sys/sysinfo.h>
+#include <sys/inttypes.h>
+#include <sys/dnlc.h>
+#include <sys/vmmeter.h>
+#include <sys/var.h>
+#include <errno.h>
+#include <string.h>
+
+#include "ruby.h"
+#include "rkstat.h"
+
+VALUE cKstatError;
+
+static VALUE ks_allocate(VALUE klass){
+   KstatStruct* ptr;
+   return Data_Make_Struct(klass,KstatStruct,0,ks_free,ptr);
+}
+
+/*
+ * call-seq:
+ *    Kstat.new(module=nil, instance=-1, name=nil)
+ *
+ * Creates and returns a Kstat object.  This does not traverse the kstat
+ * chain.  The Kstat#record method uses the values passed to actually
+ * retrieve data.
+ *
+ * You may specify a module, an instance and a name.  The module defaults to
+ * nil (all modules), the instance defaults to -1 (all instances) and the
+ * name defaults to nil (all names).
+ */
+VALUE ks_init(int argc, VALUE* argv, VALUE self){
+   KstatStruct* ptr;
+   VALUE rbModule, rbInstance, rbName;
+
+   Data_Get_Struct(self,KstatStruct,ptr);
+
+   rb_scan_args(argc,argv,"03",&rbModule,&rbInstance,&rbName);
+
+   if(!NIL_P(rbModule)){
+      SafeStringValue(rbModule);
+      rb_iv_set(self,"@module",rbModule);
+   }
+
+   if(!NIL_P(rbName)){
+      SafeStringValue(rbName);
+      rb_iv_set(self,"@name",rbName);
+   }
+
+   if(!NIL_P(rbInstance))
+      rb_iv_set(self,"@instance",rbInstance);
+
+   return self;
+}
+
+/*
+ * Returns a nested hash based on the values passed to the constructor.  How
+ * deeply that hash is nested depends on the values passed to the constructor.
+ * The more specific your criterion, the less data you will receive.
+ */
+VALUE ks_record(VALUE self){
+   volatile VALUE rbMHash, rbIHash, rbNHash, rbSHash;
+   KstatStruct* ptr;
+   kstat_io_t kio;
+   kstat_timer_t kt;
+
+   char* module;
+   char* name;
+   int instance = -1; /* -1 represents all instances (the default) */
+
+   VALUE rbModule, rbInstance, rbName;
+
+   Data_Get_Struct(self,KstatStruct,ptr);
+
+   rbMHash = rb_hash_new(); /* Module name is key, holds rbIHashes   */
+   rbIHash = rb_hash_new(); /* Instance name is key, holds rbNHashes */
+   rbNHash = rb_hash_new(); /* Name is key, holds rbSHashes          */
+
+   rbModule   = rb_iv_get(self,"@module");
+   rbInstance = rb_iv_get(self,"@instance");
+   rbName     = rb_iv_get(self,"@name");
+
+   /* Module is NULL by default (i.e. all modules are returned) */
+   if(NIL_P(rbModule)){
+      module = NULL;
+   }
+   else{
+      module = StringValuePtr(rbModule);
+   }
+
+   /* Instance defaults to -1 (i.e. all instances are returned) */
+   if(!NIL_P(rbInstance)){
+      instance = NUM2INT(rbInstance);
+   }
+
+   /* Name is NULL by default (i.e. all names are returned) */
+   if(NIL_P(rbName)){
+      name = NULL;
+   }
+   else{
+      name = StringValuePtr(rbName);
+   }
+
+   /* A failure probably means the module, instance or name doesn't exist */
+   if((ptr->kc = kstat_open()) == NULL)
+      rb_raise(cKstatError,"kstat_open() failure: %s", strerror(errno));
+
+   /*
+    * Traverse the kstat chain, looking for matches based on supplied data.
+    * A failure likely means a non-existant module or name was provided.
+    */
+   if((ptr->ksp = kstat_lookup(ptr->kc, module, instance, name)) == NULL)
+      rb_raise(cKstatError,"kstat_lookup() failure: %s", strerror(errno));
+
+   /* Sync the chain with the kernel */
+   kstat_chain_update(ptr->kc);
+
+   while(ptr->ksp){
+
+      /* If a module is specified, ignore modules that don't match */
+      if( (module) && (strcmp(module,ptr->ksp->ks_module)) ){
+         ptr->ksp = ptr->ksp->ks_next;
+         continue;
+      }
+
+      /* If an instance is specified, ignore instances that don't match */
+      if( (instance != -1) && (instance != ptr->ksp->ks_instance) ){
+         ptr->ksp = ptr->ksp->ks_next;
+         continue;
+      }
+
+      /* If a name is specified, ignore names that don't match */
+      if( (name) && (strcmp(name,ptr->ksp->ks_name)) ){
+         ptr->ksp = ptr->ksp->ks_next;
+         continue;
+      }
+
+      /* Call the appropriate data mapper based on ks_type */
+      switch(ptr->ksp->ks_type){
+         case KSTAT_TYPE_NAMED:
+            kstat_read(ptr->kc,ptr->ksp,NULL);
+            rbSHash = map_named_data_type(ptr->ksp);
+            break;
+         case KSTAT_TYPE_IO:
+            kstat_read(ptr->kc,ptr->ksp,&kio);
+            rbSHash = map_io_data_type(&kio);
+            break;
+         case KSTAT_TYPE_TIMER:
+            kstat_read(ptr->kc,ptr->ksp,&kt);
+            rbSHash = map_timer_data_type(&kt);
+         case KSTAT_TYPE_INTR:
+            kstat_read(ptr->kc,ptr->ksp,NULL);
+            rbSHash = map_intr_data_type(ptr->ksp);
+            break;
+         case KSTAT_TYPE_RAW:
+            kstat_read(ptr->kc,ptr->ksp,NULL);
+            rbSHash = map_raw_data_type(ptr->ksp);   
+            break;
+         default:
+            rb_raise(cKstatError,"Unknown data record type");
+      }
+
+      rb_hash_aset(rbNHash,rb_str_new2(ptr->ksp->ks_name),rbSHash);
+      rb_hash_aset(rbIHash,INT2FIX(ptr->ksp->ks_instance), rbNHash);
+      rb_hash_aset(rbMHash,rb_str_new2(ptr->ksp->ks_module),rbIHash);
+
+      ptr->ksp = ptr->ksp->ks_next;
+   }
+
+   return rbMHash;
+}
+
+/*
+ * Interface for Solaris kstat data.
+ */
+void Init_kstat(){
+   VALUE mSolaris, cKstat;
+
+   /* Module and Class declarations */
+   mSolaris    = rb_define_module("Solaris");
+   cKstat      = rb_define_class_under(mSolaris,"Kstat",rb_cObject);
+   cKstatError = rb_define_class_under(mSolaris,"KstatError",rb_eStandardError);
+
+   rb_define_alloc_func(cKstat,ks_allocate);
+
+   /* Instance Methods */
+   rb_define_method(cKstat,"initialize",ks_init,-1);
+   rb_define_method(cKstat,"record",ks_record,0);
+
+   /* Attributes */
+   rb_define_attr(cKstat,"module",1,1);
+   rb_define_attr(cKstat,"instance",1,1);
+   rb_define_attr(cKstat,"name",1,1);
+
+   /* Constants */
+   rb_define_const(cKstat,"VERSION",rb_str_new2(SOLARIS_KSTAT_VERSION));
+}
+
+#ifdef __cplusplus
+}
+#endif

data/lib/solaris/rkstat.h

@@ -0,0 +1,365 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SOLARIS_KSTAT_VERSION "0.2.2"
+
+/* Function prototypes */
+static VALUE map_named_data_type(kstat_t* ksp);
+static VALUE map_io_data_type(kstat_io_t* kio);
+static VALUE map_intr_data_type(kstat_t* ksp);
+static VALUE map_timer_data_type(kstat_timer_t* kt);
+static VALUE map_raw_data_type(kstat_t* ksp);
+static VALUE map_raw_vminfo(kstat_t* ksp);
+static VALUE map_raw_flushmeter(kstat_t* ksp);
+static VALUE map_raw_var(kstat_t* ksp);
+static VALUE map_raw_ncstats(kstat_t* ksp);
+static VALUE map_raw_sysinfo(kstat_t* ksp);
+static VALUE map_raw_cpu_sysinfo(kstat_t* ksp);
+static VALUE map_raw_mntinfo(kstat_t* ksp);
+
+/* Structure wrapped as our Kstat class */
+struct kstruct{
+   kstat_ctl_t* kc;
+   kstat_t* ksp;
+};
+
+typedef struct kstruct KstatStruct;
+
+static void ks_free(KstatStruct* p){
+   if(p->kc){
+      kstat_close(p->kc);
+   }
+   free(p);
+}
+
+/* Helps reduce GC for String key/value pairs in a hash */
+void hash_add_pair(VALUE rbHash, const char *key, const char *value)
+{
+   volatile VALUE key_obj = rb_str_new2(key);
+   rb_hash_aset(rbHash, key_obj, rb_str_new2(value));
+}
+
+/* Helper functions */
+
+static VALUE map_raw_mntinfo(kstat_t* ksp){
+   struct mntinfo_kstat *mptr; 
+   mptr = (struct mntinfo_kstat*)(ksp->ks_data);
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("mik_proto"),rb_str_new2(mptr->mik_proto));
+   rb_hash_aset(rbHash,rb_str_new2("mik_vers"),UINT2NUM(mptr->mik_vers));
+   rb_hash_aset(rbHash,rb_str_new2("mik_flags"),UINT2NUM(mptr->mik_flags));
+   rb_hash_aset(rbHash,rb_str_new2("mik_secmod"),UINT2NUM(mptr->mik_secmod));
+   rb_hash_aset(rbHash,rb_str_new2("mik_curread"),UINT2NUM(mptr->mik_curread));
+   rb_hash_aset(rbHash,rb_str_new2("mik_curwrite"),
+      UINT2NUM(mptr->mik_curwrite));
+   rb_hash_aset(rbHash,rb_str_new2("mik_timeo"),UINT2NUM(mptr->mik_timeo));
+   rb_hash_aset(rbHash,rb_str_new2("mik_retrans"),UINT2NUM(mptr->mik_retrans));
+   rb_hash_aset(rbHash,rb_str_new2("mik_acregmin"),
+      UINT2NUM(mptr->mik_acregmin));
+   rb_hash_aset(rbHash,rb_str_new2("mik_acregmax"),
+      UINT2NUM(mptr->mik_acregmax));
+   rb_hash_aset(rbHash,rb_str_new2("mik_acdirmin"),
+      UINT2NUM(mptr->mik_acdirmin));
+   rb_hash_aset(rbHash,rb_str_new2("mik_acdirmax"),
+      UINT2NUM(mptr->mik_acdirmax));
+   rb_hash_aset(rbHash,rb_str_new2("mik_noresponse"),
+      UINT2NUM(mptr->mik_noresponse));
+   rb_hash_aset(rbHash,rb_str_new2("mik_failover"),
+      UINT2NUM(mptr->mik_failover));
+   rb_hash_aset(rbHash,rb_str_new2("mik_remap"), UINT2NUM(mptr->mik_remap));
+   rb_hash_aset(rbHash,rb_str_new2("mik_curserver"),
+      rb_str_new2(mptr->mik_curserver));
+
+   return rbHash;
+}
+
+static VALUE map_raw_vminfo(kstat_t* ksp){
+   vminfo_t *vminfop;
+   vminfop = (vminfo_t *)ksp->ks_data;
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("freemem"),ULL2NUM(vminfop->freemem));
+   rb_hash_aset(rbHash,rb_str_new2("swap_resv"),ULL2NUM(vminfop->swap_resv));
+   rb_hash_aset(rbHash,rb_str_new2("swap_alloc"),ULL2NUM(vminfop->swap_alloc));
+   rb_hash_aset(rbHash,rb_str_new2("swap_avail"),ULL2NUM(vminfop->swap_avail));
+   rb_hash_aset(rbHash,rb_str_new2("swap_free"),ULL2NUM(vminfop->swap_free));
+
+   return rbHash;
+}
+
+static VALUE map_raw_var(kstat_t* ksp){
+   struct var* v; 
+   v = (struct var *)ksp->ks_data;
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("v_buf"),INT2NUM(v->v_buf));
+   rb_hash_aset(rbHash,rb_str_new2("v_call"),INT2NUM(v->v_call));
+   rb_hash_aset(rbHash,rb_str_new2("v_proc"),INT2NUM(v->v_proc));
+   rb_hash_aset(rbHash,rb_str_new2("v_maxupttl"),INT2NUM(v->v_maxupttl));
+   rb_hash_aset(rbHash,rb_str_new2("v_nglobpris"),INT2NUM(v->v_nglobpris));
+   rb_hash_aset(rbHash,rb_str_new2("v_maxsyspri"),INT2NUM(v->v_maxsyspri));
+   rb_hash_aset(rbHash,rb_str_new2("v_clist"),INT2NUM(v->v_clist));
+   rb_hash_aset(rbHash,rb_str_new2("v_maxup"),INT2NUM(v->v_maxup));
+   rb_hash_aset(rbHash,rb_str_new2("v_hbuf"),INT2NUM(v->v_hbuf));
+   rb_hash_aset(rbHash,rb_str_new2("v_hmask"),INT2NUM(v->v_hmask));
+   rb_hash_aset(rbHash,rb_str_new2("v_pbuf"),INT2NUM(v->v_pbuf));
+   rb_hash_aset(rbHash,rb_str_new2("v_sptmap"),INT2NUM(v->v_sptmap));
+   rb_hash_aset(rbHash,rb_str_new2("v_maxpmem"),INT2NUM(v->v_maxpmem));
+   rb_hash_aset(rbHash,rb_str_new2("v_autoup"),INT2NUM(v->v_autoup));
+   rb_hash_aset(rbHash,rb_str_new2("v_bufhwm"),INT2NUM(v->v_bufhwm));
+
+   return rbHash;
+}
+
+static VALUE map_raw_flushmeter(kstat_t* ksp){
+   struct flushmeter* fp;
+   fp = (struct flushmeter *)ksp->ks_data;
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("f_ctx"),ULL2NUM(fp->f_ctx));
+   rb_hash_aset(rbHash,rb_str_new2("f_segment"),ULL2NUM(fp->f_segment));
+   rb_hash_aset(rbHash,rb_str_new2("f_page"),ULL2NUM(fp->f_page));
+   rb_hash_aset(rbHash,rb_str_new2("f_partial"),ULL2NUM(fp->f_partial));
+   rb_hash_aset(rbHash,rb_str_new2("f_usr"),ULL2NUM(fp->f_usr));
+   rb_hash_aset(rbHash,rb_str_new2("f_region"),ULL2NUM(fp->f_region));
+
+   return rbHash;
+}
+
+static VALUE map_raw_ncstats(kstat_t* ksp){
+   struct ncstats* np;
+   np = (struct ncstats *)ksp->ks_data;
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("hits"),INT2NUM(np->hits));
+   rb_hash_aset(rbHash,rb_str_new2("misses"),INT2NUM(np->misses));
+   rb_hash_aset(rbHash,rb_str_new2("enters"),INT2NUM(np->enters));
+   rb_hash_aset(rbHash,rb_str_new2("dbl_enters"),INT2NUM(np->dbl_enters));
+   rb_hash_aset(rbHash,rb_str_new2("long_enter"),INT2NUM(np->long_enter));
+   rb_hash_aset(rbHash,rb_str_new2("long_look"),INT2NUM(np->long_look));
+   rb_hash_aset(rbHash,rb_str_new2("move_to_front"),INT2NUM(np->move_to_front));
+   rb_hash_aset(rbHash,rb_str_new2("purges"),INT2NUM(np->purges));
+
+   return rbHash;
+}
+
+static VALUE map_raw_sysinfo(kstat_t* ksp){
+   sysinfo_t* sp;
+   sp = (sysinfo_t *)ksp->ks_data;
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("updates"),UINT2NUM(sp->updates));
+   rb_hash_aset(rbHash,rb_str_new2("runque"),UINT2NUM(sp->runque));
+   rb_hash_aset(rbHash,rb_str_new2("runocc"),UINT2NUM(sp->runocc));
+   rb_hash_aset(rbHash,rb_str_new2("swpque"),UINT2NUM(sp->swpque));
+   rb_hash_aset(rbHash,rb_str_new2("swpocc"),UINT2NUM(sp->swpocc));
+   rb_hash_aset(rbHash,rb_str_new2("waiting"),UINT2NUM(sp->waiting));
+
+   return rbHash;
+}
+
+
+/*
+ * Maps the cpu_sysinfo struct from sys/sysinfo.h into a hash.
+ */
+static VALUE map_raw_cpu_sysinfo(kstat_t* ksp){
+   cpu_sysinfo_t* cptr;
+   cptr = (cpu_sysinfo_t *)ksp->ks_data;
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("cpu_idle"),UINT2NUM(cptr->cpu[CPU_IDLE]));
+   rb_hash_aset(rbHash,rb_str_new2("cpu_user"),UINT2NUM(cptr->cpu[CPU_USER]));
+   rb_hash_aset(rbHash,rb_str_new2("cpu_kernel"),UINT2NUM(cptr->cpu[CPU_KERNEL]));
+   rb_hash_aset(rbHash,rb_str_new2("cpu_wait"),UINT2NUM(cptr->cpu[CPU_WAIT]));
+   rb_hash_aset(rbHash,rb_str_new2("wait_io"),UINT2NUM(cptr->wait[W_IO]));
+   rb_hash_aset(rbHash,rb_str_new2("wait_swap"),UINT2NUM(cptr->wait[W_SWAP]));
+   rb_hash_aset(rbHash,rb_str_new2("wait_pio"),UINT2NUM(cptr->wait[W_PIO]));
+   rb_hash_aset(rbHash,rb_str_new2("bread"),UINT2NUM(cptr->bread));
+   rb_hash_aset(rbHash,rb_str_new2("bwrite"),UINT2NUM(cptr->bwrite));
+   rb_hash_aset(rbHash,rb_str_new2("lread"),UINT2NUM(cptr->lread));
+   rb_hash_aset(rbHash,rb_str_new2("lwrite"),UINT2NUM(cptr->lwrite));
+   rb_hash_aset(rbHash,rb_str_new2("phread"),UINT2NUM(cptr->phread));
+   rb_hash_aset(rbHash,rb_str_new2("phwrite"),UINT2NUM(cptr->phwrite));
+   rb_hash_aset(rbHash,rb_str_new2("pswitch"),UINT2NUM(cptr->pswitch));
+   rb_hash_aset(rbHash,rb_str_new2("trap"),UINT2NUM(cptr->trap));
+   rb_hash_aset(rbHash,rb_str_new2("intr"),UINT2NUM(cptr->intr));
+   rb_hash_aset(rbHash,rb_str_new2("syscall"),UINT2NUM(cptr->syscall));
+   rb_hash_aset(rbHash,rb_str_new2("sysread"),UINT2NUM(cptr->sysread));
+   rb_hash_aset(rbHash,rb_str_new2("syswrite"),UINT2NUM(cptr->syswrite));
+   rb_hash_aset(rbHash,rb_str_new2("sysfork"),UINT2NUM(cptr->sysfork));
+   rb_hash_aset(rbHash,rb_str_new2("sysvfork"),UINT2NUM(cptr->sysvfork));
+   rb_hash_aset(rbHash,rb_str_new2("sysexec"),UINT2NUM(cptr->sysexec));
+   rb_hash_aset(rbHash,rb_str_new2("readch"),UINT2NUM(cptr->readch));
+   rb_hash_aset(rbHash,rb_str_new2("writech"),UINT2NUM(cptr->writech));
+   rb_hash_aset(rbHash,rb_str_new2("rcvint"),UINT2NUM(cptr->rcvint));
+   rb_hash_aset(rbHash,rb_str_new2("xmtint"),UINT2NUM(cptr->xmtint));
+   rb_hash_aset(rbHash,rb_str_new2("mdmint"),UINT2NUM(cptr->mdmint));
+   rb_hash_aset(rbHash,rb_str_new2("rawch"),UINT2NUM(cptr->rawch));
+   rb_hash_aset(rbHash,rb_str_new2("canch"),UINT2NUM(cptr->canch));
+   rb_hash_aset(rbHash,rb_str_new2("outch"),UINT2NUM(cptr->outch));
+   rb_hash_aset(rbHash,rb_str_new2("msg"),UINT2NUM(cptr->msg));
+   rb_hash_aset(rbHash,rb_str_new2("sema"),UINT2NUM(cptr->sema));
+   rb_hash_aset(rbHash,rb_str_new2("namei"),UINT2NUM(cptr->namei));
+   rb_hash_aset(rbHash,rb_str_new2("ufsiget"),UINT2NUM(cptr->ufsiget));
+   rb_hash_aset(rbHash,rb_str_new2("ufsdirblk"),UINT2NUM(cptr->ufsdirblk));
+   rb_hash_aset(rbHash,rb_str_new2("ufsipage"),UINT2NUM(cptr->ufsipage));
+   rb_hash_aset(rbHash,rb_str_new2("ufsinopage"),UINT2NUM(cptr->ufsinopage));
+   rb_hash_aset(rbHash,rb_str_new2("inodeovf"),UINT2NUM(cptr->inodeovf));
+   rb_hash_aset(rbHash,rb_str_new2("fileovf"),UINT2NUM(cptr->fileovf));
+   rb_hash_aset(rbHash,rb_str_new2("procovf"),UINT2NUM(cptr->procovf));
+   rb_hash_aset(rbHash,rb_str_new2("intrthread"),UINT2NUM(cptr->intrthread));
+   rb_hash_aset(rbHash,rb_str_new2("intrblk"),UINT2NUM(cptr->intrblk));
+   rb_hash_aset(rbHash,rb_str_new2("idlethread"),UINT2NUM(cptr->idlethread));
+   rb_hash_aset(rbHash,rb_str_new2("inv_swtch"),UINT2NUM(cptr->inv_swtch));
+   rb_hash_aset(rbHash,rb_str_new2("nthreads"),UINT2NUM(cptr->nthreads));
+   rb_hash_aset(rbHash,rb_str_new2("cpumigrate"),UINT2NUM(cptr->cpumigrate));
+   rb_hash_aset(rbHash,rb_str_new2("xcalls"),UINT2NUM(cptr->xcalls));
+   rb_hash_aset(rbHash,rb_str_new2("mutex_adenters"),
+      UINT2NUM(cptr->mutex_adenters));
+   rb_hash_aset(rbHash,rb_str_new2("rw_rdfails"),UINT2NUM(cptr->rw_rdfails));
+   rb_hash_aset(rbHash,rb_str_new2("rw_wrfails"),UINT2NUM(cptr->rw_wrfails));
+   rb_hash_aset(rbHash,rb_str_new2("modload"),UINT2NUM(cptr->modload));
+   rb_hash_aset(rbHash,rb_str_new2("modunload"),UINT2NUM(cptr->modunload));
+   rb_hash_aset(rbHash,rb_str_new2("bawrite"),UINT2NUM(cptr->bawrite));
+#ifdef STATISTICS
+   rb_hash_aset(rbHash,rb_str_new2("rw_enters"),UINT2NUM(cptr->rw_enters));
+   rb_hash_aset(rbHash,rb_str_new2("win_uo_cnt"),UINT2NUM(cptr->win_uo_cnt));
+   rb_hash_aset(rbHash,rb_str_new2("win_uu_cnt"),UINT2NUM(cptr->win_uu_cnt));
+   rb_hash_aset(rbHash,rb_str_new2("win_so_cnt"),UINT2NUM(cptr->win_so_cnt));
+   rb_hash_aset(rbHash,rb_str_new2("win_su_cnt"),UINT2NUM(cptr->win_su_cnt));
+   rb_hash_aset(rbHash,rb_str_new2("win_suo_cnt"),UINT2NUM(cptr->win_suo_cnt));
+#endif
+
+   return rbHash;
+}
+
+ /* There are several different structs possible here.  We'll forward this
+  * call to the appropriate mapper based on the module and name.
+  *
+  * A few names are not yet being handled.
+  */
+static VALUE map_raw_data_type(kstat_t* ksp){
+   VALUE rbHash = rb_hash_new();
+
+   if(!strcmp(ksp->ks_module,"unix")){
+      if(!strcmp(ksp->ks_name,"vminfo")){
+         rbHash = map_raw_vminfo(ksp);
+      }
+      else if(!strcmp(ksp->ks_name,"flushmeter")){
+         rbHash = map_raw_flushmeter(ksp);
+      }
+      else if(!strcmp(ksp->ks_name,"ncstats")){
+         rbHash = map_raw_ncstats(ksp);
+      }
+      else if(!strcmp(ksp->ks_name,"sysinfo")){
+         rbHash = map_raw_sysinfo(ksp);
+      }
+      else if(!strcmp(ksp->ks_name,"var")){
+         rbHash = map_raw_var(ksp);
+      }
+      else{
+         /* Return an empty hash for unhandled names for now */
+         rbHash = rb_hash_new();
+      }
+   }
+
+   if(!strcmp(ksp->ks_module,"cpu_stat")){
+      rbHash = map_raw_cpu_sysinfo(ksp);
+   }
+
+   if(!strcmp(ksp->ks_module,"nfs")){
+      if(!strcmp(ksp->ks_name,"mntinfo")){
+         rbHash = map_raw_mntinfo(ksp);
+      }
+   }
+   return rbHash;
+}
+
+static VALUE map_timer_data_type(kstat_timer_t* t){
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("name"),rb_str_new2(t->name));
+   rb_hash_aset(rbHash,rb_str_new2("num_events"),ULL2NUM(t->num_events));
+   rb_hash_aset(rbHash,rb_str_new2("elapsed_time"),ULL2NUM(t->elapsed_time));
+   rb_hash_aset(rbHash,rb_str_new2("min_time"),ULL2NUM(t->min_time));
+   rb_hash_aset(rbHash,rb_str_new2("max_time"),ULL2NUM(t->max_time));
+   rb_hash_aset(rbHash,rb_str_new2("start_time"),ULL2NUM(t->start_time));
+   rb_hash_aset(rbHash,rb_str_new2("stop_time"),ULL2NUM(t->stop_time));
+
+   return rbHash;
+}
+
+static VALUE map_intr_data_type(kstat_t* ksp){
+   int i;
+   kstat_intr_t* kp;
+   kp = (kstat_intr_t *)ksp->ks_data;
+   VALUE rbHash = rb_hash_new();
+   static char* intr_names[] =
+      {"hard", "soft", "watchdog", "spurious", "multiple_service"};
+
+   for(i = 0; i < KSTAT_NUM_INTRS; i++){
+      rb_hash_aset(rbHash,rb_str_new2(intr_names[i]),UINT2NUM(kp->intrs[i]));
+   }
+
+   return rbHash;
+}
+
+static VALUE map_io_data_type(kstat_io_t* k){
+   volatile VALUE rbHash = rb_hash_new();
+
+   rb_hash_aset(rbHash,rb_str_new2("nread"),ULL2NUM(k->nread));
+   rb_hash_aset(rbHash,rb_str_new2("nwritten"),ULL2NUM(k->nwritten));
+   rb_hash_aset(rbHash,rb_str_new2("reads"),UINT2NUM(k->reads));
+   rb_hash_aset(rbHash,rb_str_new2("writes"),UINT2NUM(k->writes));
+   rb_hash_aset(rbHash,rb_str_new2("wtime"),ULL2NUM(k->wtime));
+   rb_hash_aset(rbHash,rb_str_new2("wlentime"),ULL2NUM(k->wlentime));
+   rb_hash_aset(rbHash,rb_str_new2("wlastupdate"),ULL2NUM(k->wlastupdate));
+   rb_hash_aset(rbHash,rb_str_new2("rtime"),ULL2NUM(k->rtime));
+   rb_hash_aset(rbHash,rb_str_new2("rlentime"),ULL2NUM(k->rlentime));
+   rb_hash_aset(rbHash,rb_str_new2("rlastupdate"),ULL2NUM(k->rlastupdate));
+   rb_hash_aset(rbHash,rb_str_new2("wcnt"),UINT2NUM(k->wcnt));
+   rb_hash_aset(rbHash,rb_str_new2("rcnt"),UINT2NUM(k->rcnt));
+
+   return rbHash;
+}
+
+static VALUE map_named_data_type(kstat_t* ksp){
+   volatile VALUE rbHash;
+   kstat_named_t* knp;
+   knp = (kstat_named_t *)ksp->ks_data;
+   int i;
+
+   rbHash = rb_hash_new();
+
+   for(i = 0; i < ksp->ks_ndata; i++, knp++)
+   {
+      switch (knp->data_type)
+      {
+         case KSTAT_DATA_CHAR:
+            hash_add_pair(rbHash,knp->name,knp->value.c);
+            break;
+         case KSTAT_DATA_INT32:
+            rb_hash_aset(rbHash,rb_str_new2(knp->name),INT2NUM(knp->value.i32));
+            break;
+         case KSTAT_DATA_UINT32:
+            rb_hash_aset(rbHash,rb_str_new2(knp->name),UINT2NUM(knp->value.ui32));
+            break;
+         case KSTAT_DATA_INT64:
+            rb_hash_aset(rbHash,rb_str_new2(knp->name),LL2NUM(knp->value.i64));
+            break;
+         case KSTAT_DATA_UINT64:
+            rb_hash_aset(rbHash,rb_str_new2(knp->name),ULL2NUM(knp->value.ui64));
+            break;
+         default:
+            hash_add_pair(rbHash,knp->name,"Unknown");
+            break;
+      }
+   }
+   return rbHash;
+}
+
+#ifdef __cplusplus
+}
+#endif

data/test/tc_kstat.rb

@@ -0,0 +1,155 @@
+###############################################################################
+# tc_kstat.rb
+#
+# Test suite for the solaris-kstat Ruby package.
+###############################################################################
+base = File.basename(Dir.pwd)
+if base == "test" || base =~ /solaris-kstat.*/
+   require "ftools"
+   Dir.chdir("..") if base == "test"
+   Dir.mkdir("solaris") unless File.exists?("solaris")
+   File.copy("kstat.so","solaris")
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "solaris/kstat"
+require "test/unit"
+require "set"
+include Solaris
+
+class TC_Kstat < Test::Unit::TestCase
+   def setup
+      @k = Kstat.new
+   end
+
+   def test_version
+      assert_equal("0.2.2", Kstat::VERSION)
+   end
+
+   def test_name
+      assert_respond_to(@k, :name)
+      assert_respond_to(@k, :name=)
+      assert_nil(@k.name)
+      assert_nothing_raised{ @k.name }
+      assert_nothing_raised{ @k.name = "foo" }
+   end
+
+   def test_module
+      assert_respond_to(@k, :module)
+      assert_respond_to(@k, :module=)
+      assert_nil(@k.module)
+      assert_nothing_raised{ @k.module }
+      assert_nothing_raised{ @k.module = "bar" }
+   end
+
+   def test_instance
+      assert_respond_to(@k, :instance)
+      assert_respond_to(@k, :instance=)
+      assert_nil(@k.instance)
+      assert_nothing_raised{ @k.instance }
+      assert_nothing_raised{ @k.instance = 0 }
+   end
+
+   def test_constructor_valid_values
+      assert_nothing_raised{ Kstat.new("cpu_info",0,"cpu_info0").record }
+      assert_nothing_raised{ Kstat.new(nil,0,"cpu_info0").record }
+      assert_nothing_raised{ Kstat.new("cpu_info",0,nil).record }
+   end
+
+   def test_constructor_invalid_values
+      assert_raises(KstatError){ Kstat.new("bogus").record }
+      assert_raises(KstatError){ Kstat.new("cpu_info",99).record }
+      assert_raises(KstatError){ Kstat.new("cpu_info",0,"bogus").record }
+      assert_raises(TypeError){ Kstat.new("cpu_info","x").record }
+   end
+
+   def test_record_basic
+      assert_respond_to(@k, :record)
+   end
+
+   def test_record_named
+      assert_nothing_raised{ @k.record["cpu_info"][0]["cpu_info0"] }
+      assert_kind_of(Hash, @k.record["cpu_info"][0]["cpu_info0"])
+   end
+
+   def test_record_io
+      assert_nothing_raised{ @k.record["nfs"][1]["nfs1"] }
+      assert_kind_of(Hash, @k.record["nfs"][1]["nfs1"])
+   end
+
+   def test_record_intr
+      assert_nothing_raised{ @k.record["fd"][0]["fd0"] }
+      assert_kind_of(Hash, @k.record["fd"][0]["fd0"])
+   end
+
+   def test_record_raw_vminfo
+      keys = %w/freemem swap_alloc swap_avail swap_free swap_resv/
+
+      assert_nothing_raised{ @k.record["unix"][0]["vminfo"] }
+      assert_kind_of(Hash, @k.record["unix"][0]["vminfo"])
+      assert_equal(keys, @k.record["unix"][0]["vminfo"].keys.sort)
+   end
+
+   def test_record_raw_var
+      keys = %w/v_autoup v_buf v_bufhwm v_call v_clist v_hbuf v_hmask/
+      keys.push %w/v_maxpmem v_maxsyspri v_maxup v_maxupttl v_nglobpris v_pbuf/
+      keys.push %w/v_proc v_sptmap/
+      keys.flatten!
+
+      assert_nothing_raised{ @k.record["unix"][0]["var"] }
+      assert_kind_of(Hash, @k.record["unix"][0]["var"])
+      assert_equal(keys,  @k.record["unix"][0]["var"].keys.sort)
+   end
+
+   def test_record_raw_flushmeter
+      keys = %w/f_ctx f_page f_partial f_region f_segment f_usr/
+
+      assert_nothing_raised{ @k.record["unix"][0]["flushmeter"] }
+      assert_kind_of(Hash, @k.record["unix"][0]["flushmeter"])
+      assert_equal(keys,  @k.record["unix"][0]["flushmeter"].keys.sort)
+   end
+
+   def test_record_raw_cpu_stat
+      keys = %w/cpu_idle cpu_user cpu_kernel cpu_wait wait_io wait_swap/
+      keys << %w/wait_pio bread bwrite lread lwrite phread phwrite pswitch/
+      keys << %w/trap intr syscall sysread syswrite sysfork sysvfork sysexec/
+      keys << %w/readch writech rcvint xmtint mdmint rawch canch outch msg/
+      keys << %w/sema namei ufsiget ufsdirblk ufsipage ufsinopage inodeovf/
+      keys << %w/fileovf procovf intrthread intrblk idlethread inv_swtch/
+      keys << %w/nthreads cpumigrate xcalls mutex_adenters rw_rdfails/
+      keys << %w/rw_wrfails modload modunload bawrite/
+      keys.flatten!
+
+      assert_nothing_raised{ @k.record["cpu_stat"][0]["cpu_stat0"] }
+      assert_kind_of(Hash, @k.record["cpu_stat"][0]["cpu_stat0"])
+
+      # Too big and difficult to sort manually - so use a Set
+      set1 = Set.new(keys)
+      set2 = Set.new(@k.record["cpu_stat"][0]["cpu_stat0"].keys)
+      diff = set1 - set2
+
+      assert_equal(set1,set2,"Diff was: #{diff.to_a}")
+   end
+
+   def test_record_ncstats
+      keys = %w/dbl_enters enters hits long_enter long_look misses/
+      keys.push %w/move_to_front purges/
+      keys.flatten!
+
+      assert_nothing_raised{ @k.record["unix"][0]["ncstats"] }
+      assert_kind_of(Hash, @k.record["unix"][0]["ncstats"])
+      assert_equal(keys, @k.record["unix"][0]["ncstats"].keys.sort)
+   end
+
+   def test_record_sysinfo
+      keys = %w/runocc runque swpocc swpque updates waiting/
+
+      assert_nothing_raised{ @k.record["unix"][0]["sysinfo"] }
+      assert_kind_of(Hash, @k.record["unix"][0]["sysinfo"])
+      assert_equal(keys, @k.record["unix"][0]["sysinfo"].keys.sort)
+   end
+
+   def teardown
+      @k = nil
+   end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: solaris-kstat
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+date: 2006-07-11 00:00:00 -06:00
+summary: Interface for the Solaris kstat library
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/solarisutils
+rubyforge_project: solarisutils
+description: Interface for the Solaris kstat library
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- CHANGES
+- README
+- MANIFEST
+- extconf.rb
+- lib/solaris/rkstat.c
+- lib/solaris/rkstat.h
+- test/tc_kstat.rb
+- examples/test.rb
+test_files: 
+- test/tc_kstat.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+executables: []
+
+extensions: 
+- extconf.rb
+requirements: []
+
+dependencies: []
+