ruby-libgtop2 0.1.0

data/examples/mountlist.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+$:.unshift('../ext/')
+require 'libgtop'
+
+gtop = LibGTop.new
+
+gtop.init
+
+mount_list = gtop.mountlist(1)
+
+exit if mount_list["mount_entries"].empty?
+
+mount_list["mount_entries"].each do |mount|
+  printf "Mount_Entry: %-30s %-10s %-20s\n", 
+    mount["mountdir"], mount["type"], mount["devname"]
+end
+
+printf "\n\n%-16s %9s %9s %9s %9s %9s %9s\n",
+  "Mount", "Blocks", "Free", "Avail", "Files", "Free", "BlockSz"
+
+mount_list["mount_entries"].each do |mount|
+  fsusage = gtop.fsusage(mount["mountdir"])
+
+  printf "%-16s %9u %9u %9u %9u %9u %9d\n",
+    mount["mountdir"],
+    fsusage["blocks"], fsusage["bfree"],
+    fsusage["bavail"], fsusage["files"],
+    fsusage["ffree"], fsusage["block_size"]
+end

data/examples/netload.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+$:.unshift('../ext/')
+require 'socket'
+require 'libgtop'
+
+gtop = LibGTop.new
+
+unless iface = ARGV.shift
+  puts "Usage: #{$0} interface"
+  exit
+end
+
+gtop.init
+
+netload = gtop.netload(iface)
+
+address_string = TCPSocket.gethostbyname(netload["address"]).last.split('.').reverse.join('.')
+subnet_string = TCPSocket.gethostbyname(netload["subnet"]).last.split('.').reverse.join('.')
+
+printf "Network Load (0x%08x):\n\n" +
+       "\tInterface Flags:\t0x%08x\n" +
+       "\tAddress:\t\t0x%08x - %s\n" +
+       "\tSubnet:\t\t\t0x%08x - %s\n\n" +
+       "\tMTU:\t\t\t%d\n" +
+       "\tCollisions:\t\t%d\n\n" +
+       "\tPackets In:\t\t%d\n" +
+       "\tPackets Out:\t\t%d\n" +
+       "\tPackets Total:\t\t%d\n\n" +
+       "\tBytes In:\t\t%d\n" +
+       "\tBytes Out:\t\t%d\n" +
+       "\tBytes Total:\t\t%d\n\n" +
+       "\tErrors In:\t\t%d\n" +
+       "\tErrors Out:\t\t%d\n" +
+       "\tErrors Total:\t\t%d\n\n",
+       netload["flags"],
+       netload["if_flags"],
+       netload["address"], address_string,
+       netload["subnet"],  subnet_string,
+       netload["mtu"],
+       netload["collisions"],
+       netload["packets_in"],
+       netload["packets_out"],
+       netload["packets_total"],
+       netload["bytes_in"],
+       netload["bytes_out"],
+       netload["bytes_total"],
+       netload["errors_in"],
+       netload["errors_out"],
+       netload["errors_total"]

data/examples/procmap.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+$:.unshift('../ext/')
+require 'libgtop'
+
+gtop = LibGTop.new
+
+gtop.init
+
+unless pid = ARGV.shift
+  puts "Usage: #{$0} pid"
+  exit
+end
+
+STDERR.printf "Getting memory maps for pid %d.\n\n", pid
+
+proc_map = gtop.proc_map(pid.to_i)
+
+proc_map["map_entries"].each do |map|
+  filename = ''
+  if map["flags"] & (1 << LibGTop::MAP_ENTRY_FILENAME)
+    filename = map["filename"]
+  end
+
+  perm = ''
+  perm << ( map["perm"] & LibGTop::MAP_PERM_READ != 0 ? 'r' : '-' )
+  perm << ( map["perm"] & LibGTop::MAP_PERM_WRITE != 0 ? 'w' : '-' )
+  perm << ( map["perm"] & LibGTop::MAP_PERM_EXECUTE != 0 ? 'x' : '-' )
+  perm << ( map["perm"] & LibGTop::MAP_PERM_SHARED != 0 ? 's' : '-' )
+  perm << ( map["perm"] & LibGTop::MAP_PERM_PRIVATE != 0 ? 'p' : '-' )
+
+  device = map["device"]
+  device_minor = device & 255;
+  device_major = (device >> 8) & 255
+
+  format = "%08x-%08x %08x - %02x:%02x %08u - %4s - %s\n"
+  STDERR.printf format,
+    map["start"], map["end"], map["offset"],
+    device_major, device_minor,
+    map["inode"], perm, filename
+end

data/examples/second.rb

@@ -0,0 +1,207 @@
+#!/usr/bin/env ruby
+
+$:.unshift('../ext/')
+require 'libgtop'
+
+def output(gtop, pid)
+  print "\n"
+
+  proc_state = gtop.proc_state(pid)
+  printf "Proc_State   PID  %5d (0x%08x): " +
+         "'%s', %s, %u, %u\n", pid,
+         proc_state["flags"],
+         proc_state["cmd"], proc_state["state"],
+         proc_state["uid"], proc_state["gid"]
+
+  proc_uid = gtop.proc_uid(pid)
+  printf "Proc_Uid     PID  %5d (0x%08x): " +
+         "%d %d %d %d %d %d %d %d %d %d %d %d\n", pid,
+         proc_uid["flags"],
+         proc_uid["uid"], proc_uid["euid"],
+         proc_uid["gid"], proc_uid["egid"],
+         proc_uid["pid"], proc_uid["ppid"],
+         proc_uid["pgrp"], proc_uid["session"],
+         proc_uid["tty"], proc_uid["tpgid"],
+         proc_uid["priority"], proc_uid["nice"]
+
+  proc_mem = gtop.proc_mem(pid)
+  printf "Proc_Mem     PID  %5d (0x%08x): " +
+         "%u %u %u %u %u %u\n", pid,
+          proc_mem["flags"],
+          proc_mem["size"],
+          proc_mem["vsize"],
+          proc_mem["resident"],
+          proc_mem["share"],
+          proc_mem["rss"],
+          proc_mem["rss_rlim"]
+
+  proc_segment = gtop.proc_segment(pid)
+  printf "Proc_Segment PID  %5d (0x%08x): " +
+         "%u %u %u %u %u %u %u %u\n", pid,
+         proc_segment["flags"],
+         proc_segment["text_rss"],
+         proc_segment["shlib_rss"],
+         proc_segment["rss"],
+         proc_segment["stack_rss"],
+         proc_segment["dirty_size"],
+         proc_segment["start_code"],
+         proc_segment["end_code"],
+         proc_segment["start_stack"]
+
+  proc_time = gtop.proc_time(pid)
+  printf "Proc_Time    PID  %5d (0x%08x): " +
+         "%u %u %u %u %u %u %u %u %u\n", pid,
+         proc_time["flags"],
+         proc_time["start_time"],
+         proc_time["rtime"],
+         proc_time["utime"],
+         proc_time["stime"],
+         proc_time["cutime"],
+         proc_time["cstime"],
+         proc_time["timeout"],
+         proc_time["it_real_value"],
+         proc_time["frequency"]
+
+  proc_signal = gtop.proc_signal(pid)
+  printf "Proc_Signal  PID  %5d (0x%08x): " +
+         "%s %s %s %s\n", pid,
+         proc_signal["flags"],
+         proc_signal["signal"].to_s,
+         proc_signal["blocked"].to_s,
+         proc_signal["sigignore"].to_s,
+         proc_signal["sigcatch"].to_s
+
+  proc_kernel = gtop.proc_kernel(pid)
+  printf "Proc_Kernel  PID  %5d (0x%08x): " +
+         "%u %u %u %u %u 0x%x 0x%x 0x%x (%s)\n", pid,
+         proc_kernel["flags"],
+         proc_kernel["k_flags"],
+         proc_kernel["min_flt"],
+         proc_kernel["maj_flt"],
+         proc_kernel["cmin_flt"],
+         proc_kernel["cmaj_flt"],
+         proc_kernel["kstk_esp"],
+         proc_kernel["kstk_eip"],
+         proc_kernel["nwchan"],
+         proc_kernel["wchan"]
+
+  print "\n"
+
+  proc_args = gtop.proc_args(pid)
+  args = proc_args["args"].split(/\000/, -1).join('|')
+  printf "Proc_Args    PID  %5d (0x%08x): %u - '%s'\n", pid,
+         proc_args["flags"],
+         proc_args["size"],
+         args
+
+# SMP
+  ncpu = LibGTop.ncpu
+
+  proc_tome = gtop.proc_time(pid)
+
+  total = proc_time["utime"] + proc_time["stime"]
+
+  p_total = total > 0 ? total.to_f : 1.0
+
+  p_utime = proc_time["utime"] * 100.0 / p_total
+  p_stime = proc_time["stime"] * 100.0 / p_total
+
+  b_total = p_total / ncpu
+  b_utime = proc_time["utime"].to_f / ncpu
+  b_stime = proc_time["stime"].to_f / ncpu
+
+  s_total = s_utime = s_stime = 0
+
+  printf "Proc_Time    PID  %5d (0x%08x): %12u   %12u   %12u\n", pid,
+         proc_time["flags"], total,
+         proc_time["utime"],
+         proc_time["stime"]
+
+  xcpu = proc_time["xcpu"]
+  xcpu.each_with_index do |cpu, i|
+    this_total = cpu["utime"] + cpu["stime"]
+    printf "CPU %3d      PID  %5d (0x%08x): %12u   %12u   %12u\n", i,
+           pid, proc_time["flags"], this_total,
+           cpu["utime"],
+           cpu["stime"]
+
+    s_total += (this_total - b_total).abs
+    s_utime += (cpu["utime"] - b_utime).abs
+    s_stime += (cpu["stime"] - b_stime).abs
+  end
+
+  print "\n"
+
+  printf "Proc_Time    PID  %5d (0x%08x): %12.3f   %12.3f   %12.3f\n", pid,
+         proc_time["flags"], 100.0, p_utime, p_stime
+
+  xcpu.each_with_index do |cpu, i|
+    this_total = cpu["utime"] + cpu["stime"]
+    this_p_total = this_total * 100.0 / p_total
+    this_p_utime = cpu["utime"] * 100.0 / p_total
+    this_p_stime = cpu["stime"] * 100.0 / p_total
+
+    printf "CPU %3d      PID  %5d (0x%08x): %12.3f   %12.3f   %12.3f\n", i,
+           pid, proc_time["flags"],
+           this_p_total, this_p_utime, this_p_stime
+  end
+
+  print "\n"
+
+  my_utime = proc_time["utime"] > 0 ? proc_time["utime"] : 1.0
+  my_stime = proc_time["stime"] > 0 ? proc_time["stime"] : 1.0
+
+  printf "SPIN: %31s %12.3f   %12.3f   %12.3f\n", "", s_total * 100.0 / p_total,
+         s_utime * 100.0 / my_utime, s_stime * 100.0 / my_stime
+
+  print "\n"
+end
+
+
+gtop = LibGTop.new
+
+gtop.init
+  
+sysdeps = gtop.sysdeps
+
+printf "Sysdeps      (0x%08x): %u, %u, %u, %u, %u, " + 
+       "%u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u\n",
+       sysdeps["flags"],
+       sysdeps["cpu"],
+       sysdeps["mem"],
+       sysdeps["swap"],
+       sysdeps["uptime"],
+       sysdeps["loadavg"],
+       sysdeps["shm_limits"],
+       sysdeps["msg_limits"],
+       sysdeps["sem_limits"],
+       sysdeps["proclist"],
+       sysdeps["proc_state"],
+       sysdeps["proc_uid"],
+       sysdeps["proc_mem"],
+       sysdeps["proc_time"],
+       sysdeps["proc_signal"],
+       sysdeps["proc_kernel"],
+       sysdeps["proc_segment"]
+
+if pid = ARGV.shift
+  output(gtop, pid.to_i)
+  exit
+end
+
+print "\n"
+
+proclist = gtop.proclist(0, 0)
+pids = proclist["pids"]
+
+printf "Proclist     (0x%08x): %u, %u, %u\n",
+       proclist["flags"],
+       proclist["number"],
+       proclist["size"],
+       proclist["total"]
+
+exit if pids.empty?
+
+pids.each do |pid|
+  output(gtop, pid)
+end

data/examples/smp.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+$:.unshift('../ext/')
+require 'libgtop'
+
+gtop = LibGTop.new
+
+gtop.init
+
+cpu = gtop.cpu
+
+ncpu = LibGTop.ncpu
+
+frequency = cpu["frequency"]
+
+total = cpu["total"] > 0 ? cpu["total"].to_f : 1.0
+user = cpu["user"] > 0 ? cpu["user"].to_f : 1.0
+nice = cpu["nice"] > 0 ? cpu["nice"].to_f : 1.0
+sys = cpu["sys"] > 0 ? cpu["sys"].to_f : 1.0
+idle = cpu["idle"] > 0 ? cpu["idle"].to_f : 1.0
+
+s_total = s_user = s_nice = s_sys = s_idle = 0
+
+b_total = total / ncpu
+b_user = user / ncpu
+b_nice = nice / ncpu
+b_sys = sys / ncpu
+b_idle = idle / ncpu
+
+separator = '-' * 91
+buffer = sprintf "Ticks (%d per second):", frequency
+
+printf "\n\n%-26s %12s %12s %12s %12s %12s\n%s\n", buffer,
+       "Total", "User", "Nice", "Sys", "Idle", separator
+
+printf "CPU          (0x%08x): %12.0f %12.0f %12.0f %12.0f %12.0f\n\n",
+       cpu["flags"], cpu["total"], cpu["user"],
+       cpu["nice"], cpu["sys"], cpu["idle"]
+
+cpu["xcpu"].each_with_index do |xcpu, i|
+  printf "CPU %3d      (0x%08x): %12u %12u %12u %12u %12u\n", i,
+         cpu["flags"], xcpu["total"], xcpu["user"],
+         xcpu["nice"], xcpu["sys"], xcpu["idle"] 
+
+  s_total += (xcpu["total"].to_f - b_total).abs
+  s_user += (xcpu["user"].to_f - b_user).abs
+  s_nice += (xcpu["nice"].to_f - b_nice).abs
+  s_sys += (xcpu["sys"].to_f - b_sys).abs
+  s_idle += (xcpu["idle"].to_f - b_idle).abs
+end
+
+printf "%s\n\n\n", separator
+
+printf "%-26s %12s %12s %12s %12s %12s\n%s\n", "Percent:",
+       "Total (%)", "User (%)", "Nice (%)", "Sys (%)",
+       "Idle (%)", separator
+
+printf "CPU          (0x%08x): %12.3f %12.3f %12.3f %12.3f %12.3f\n\n",
+       cpu["flags"], total * 100.0 / total,
+       user * 100.0 / total, nice * 100.0 / total,
+       sys * 100.0 / total, idle * 100.0 / total
+
+cpu["xcpu"].each_with_index do |xcpu, i|
+  p_total = xcpu["total"] * 100.0 / total
+  p_user = xcpu["user"] * 100.0 / user
+  p_nice = xcpu["nice"] * 100.0 / nice
+  p_sys = xcpu["sys"] * 100.0 / sys 
+  p_idle = xcpu["idle"] * 100.0 / idle
+
+  printf "CPU %3d      (0x%08x): %12.3f %12.3f %12.3f %12.3f %12.3f\n", i,
+         cpu["flags"], p_total, p_user, p_nice, p_sys, p_idle
+end
+
+printf "%s\n%-26s %12.3f %12.3f %12.3f %12.3f %12.3f\n\n", separator,
+       "Spin:", s_total * 100.0 / total, s_user * 100.0 / user,
+       s_nice * 100.0 / nice, s_sys * 100.0 / sys, s_idle * 100.0 / idle

data/examples/sysdeps.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+$:.unshift('../ext/')
+require 'libgtop'
+
+def feature_check(sysdeps, f)
+  const = eval "LibGTop::SYSDEPS_#{f}"
+  sysdeps['feature'] & (1 << const) != 0 ? 1 : 0
+end
+
+gtop = LibGTop.new
+
+gtop.init
+
+sysdeps = gtop.sysdeps
+
+printf "Sysdeps (0x%08x):\n\n" +
+       "\tfeature:\t\t0x%08x\n\n" +
+       "\tcpu:\t\t%d\t0x%08x\n" +
+       "\tmem:\t\t%d\t0x%08x\n" +
+       "\tswap:\t\t%d\t0x%08x\n\n" +
+       "\tuptime:\t\t%d\t0x%08x\n" +
+       "\tloadavg:\t%d\t0x%08x\n\n" +
+       "\tshm_limits:\t%d\t0x%08x\n" +
+       "\tmsg_limits:\t%d\t0x%08x\n" +
+       "\tsem_limits:\t%d\t0x%08x\n\n" +
+       "\tproclist:\t%d\t0x%08x\n\n" +
+       "\tproc_state:\t%d\t0x%08x\n" +
+       "\tproc_uid:\t%d\t0x%08x\n" +
+       "\tproc_mem:\t%d\t0x%08x\n" +
+       "\tproc_time:\t%d\t0x%08x\n" +
+       "\tproc_signal:\t%d\t0x%08x\n" +
+       "\tproc_kernel:\t%d\t0x%08x\n" +
+       "\tproc_segment:\t%d\t0x%08x\n\n" +
+       "\tproc_args:\t%d\t0x%08x\n" +
+       "\tproc_map:\t%d\t0x%08x\n\n" +
+       "\tmountlist:\t%d\t0x%08x\n" +
+       "\tfsusage:\t%d\t0x%08x\n\n" +
+       "\tnetload:\t%d\t0x%08x\n" +
+       "\tppp:\t\t%d\t0x%08x\n\n",
+       sysdeps["flags"],
+       sysdeps["feature"],
+       feature_check(sysdeps, "CPU"),
+       sysdeps["cpu"],
+       feature_check(sysdeps, "MEM"),
+       sysdeps["mem"],
+       feature_check(sysdeps, "SWAP"),
+       sysdeps["swap"],
+       feature_check(sysdeps, "UPTIME"),
+       sysdeps["uptime"],
+       feature_check(sysdeps, "LOADAVG"),
+       sysdeps["loadavg"],
+       feature_check(sysdeps, "SHM_LIMITS"),
+       sysdeps["shm_limits"],
+       feature_check(sysdeps, "MSG_LIMITS"),
+       sysdeps["msg_limits"],
+       feature_check(sysdeps, "SEM_LIMITS"),
+       sysdeps["sem_limits"],
+       feature_check(sysdeps, "PROCLIST"),
+       sysdeps["proclist"],
+       feature_check(sysdeps, "PROC_STATE"),
+       sysdeps["proc_state"],
+       feature_check(sysdeps, "PROC_UID"),
+       sysdeps["proc_uid"],
+       feature_check(sysdeps, "PROC_MEM"),
+       sysdeps["proc_mem"],
+       feature_check(sysdeps, "PROC_TIME"),
+       sysdeps["proc_time"],
+       feature_check(sysdeps, "PROC_SIGNAL"),
+       sysdeps["proc_signal"],
+       feature_check(sysdeps, "PROC_KERNEL"),
+       sysdeps["proc_kernel"],
+       feature_check(sysdeps, "PROC_SEGMENT"),
+       sysdeps["proc_segment"],
+       feature_check(sysdeps, "PROC_ARGS"),
+       sysdeps["proc_args"],
+       feature_check(sysdeps, "PROC_MAP"),
+       sysdeps["proc_map"],
+       feature_check(sysdeps, "MOUNTLIST"),
+       sysdeps["mountlist"],
+       feature_check(sysdeps, "FSUSAGE"),
+       sysdeps["fsusage"],
+       feature_check(sysdeps, "NETLOAD"),
+       sysdeps["netload"],
+       feature_check(sysdeps, "PPP"),
+       sysdeps["ppp"]