linux_stat 1.6.0 → 2.0.1

data/bin/console

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
 $-v = true
-%w(linux_stat irb).each(&method(:require))
+
+begin
+	%w(linux_stat irb).each(&method(:require))
+rescue LoadError
+	abort "LinuxStat and IRB shoud be installed before you can run LinuxStat console"
+end
+
 IRB.start(__FILE__)

data/exe/linuxstat.rb

@@ -7,6 +7,12 @@ rescue LoadError
 	abort "The Gem needs to be installed before this test can be run!"
 end
 
+Integer.class_exec do
+	define_method(:clamp) { |min, max|
+		self < min ? min : self > max ? max : self
+	}
+end unless 1.respond_to?(:clamp)
+
 # Gradient colour to strings
 class String
 	def colourize(colour = 1, flip: false)

data/ext/procfs/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+
+unless have_const('linux') || RbConfig::CONFIG['arch'].to_s[/linux/]
+	abort('Platform is not linux')
+end
+
+unless have_header('unistd.h') && have_header('ruby.h')
+	abort('Missing header')
+end
+
+create_makefile 'linux_stat/procfs'

data/ext/procfs/loadavg_pid.h

@@ -0,0 +1,11 @@
+VALUE last_pid(VALUE obj) {
+	FILE *f = fopen("/proc/loadavg", "r") ;
+	if (!f) return Qnil ;
+
+	unsigned long long _last_pid ;
+	char status = fscanf(f, "%*f %*f %*f %*s %llu", &_last_pid) ;
+	fclose(f) ;
+	if (status != 1) return Qnil ;
+
+	return ULL2NUM(_last_pid) ;
+}

data/ext/procfs/procfs.c

@@ -0,0 +1,42 @@
+// ProcFS doesn't include all the /proc/ files.
+// It includes some of them that can add potential
+// performance boost to the LinuxStat modules.
+//
+// Some LinuxStat modules reads /proc/ files
+// that are not present here. That is because
+// Ruby can handle them well with little wastage.
+// Adding C may be a potential risk in such places.
+//
+// In this ProcFS module, we will define the methods
+// that really gets the benefit.
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include "ruby.h"
+#include "uptime.h"
+#include "statm.h"
+#include "stat.h"
+#include "loadavg_pid.h"
+
+int Init_procfs() {
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE _procfs = rb_define_module_under(_linux_stat, "ProcFS") ;
+
+	// uptime
+	rb_define_module_function(_procfs, "uptime_f", uptime_f, 0) ;
+
+	// statm
+	rb_define_module_function(_procfs, "statm_memory", statm_memory, 1) ;
+	rb_define_module_function(_procfs, "statm", statm, 1) ;
+	rb_define_module_function(_procfs, "statm_virtual", statm_virtual, 1) ;
+	rb_define_module_function(_procfs, "statm_resident", statm_resident, 1) ;
+	rb_define_module_function(_procfs, "statm_shared", statm_shared, 1) ;
+
+	// loadavg last PID
+	rb_define_module_function(_procfs, "last_pid", last_pid, 0) ;
+
+	// stat
+	rb_define_module_function(_procfs, "ps_state", ps_state, 1) ;
+	rb_define_module_function(_procfs, "ps_stat", ps_stat, 1) ;
+}

data/ext/procfs/stat.h

@@ -0,0 +1,92 @@
+VALUE ps_state(VALUE obj, VALUE pid) {
+	char _path[22] ;
+	sprintf(_path, "/proc/%lu/stat", FIX2UINT(pid)) ;
+
+	FILE *f = fopen(_path, "r") ;
+	if (!f) return rb_str_new_cstr("") ;
+
+	char _s[1] ;
+
+	char status = fscanf(f, "%*llu (%*[^)]%*[)] %s", _s) ;
+	fclose(f) ;
+
+	if (status != 1) return rb_str_new_cstr("") ;
+	return rb_str_new_cstr(_s) ;
+}
+
+VALUE ps_stat(VALUE obj, VALUE pid) {
+	char _path[22] ;
+	sprintf(_path, "/proc/%lu/stat", FIX2UINT(pid)) ;
+
+	FILE *f = fopen(_path, "r") ;
+
+	if (!f)
+		return rb_ary_new() ;
+
+	// ?? JEEZ !!
+	// We need to do this because the datatypes are different
+	// Can't make an array like Ruby out of String
+	// This is hard to write and check, but tested, and works.
+	//
+	// For this struct,
+	// follow https://man7.org/linux/man-pages/man5/proc.5.html
+	int ppid, pgrp, session, tty_nr, tpgid ;
+	unsigned flags ;
+	long unsigned minflt, cminflt, majflt, cmajflt, utime, stime ;
+	long cutime, cstime, priority, nice, num_threads, itrealvalue ;
+	long long unsigned starttime ;
+	long unsigned vsize ;
+	long rss ;
+	long unsigned rsslim, startcode, endcode, startstack, kstkesp, kstkeip ;
+	long unsigned signal, blocked, sigignore, sigcatch, wchan, nswap, cnswap ;
+	int exit_signal, processor ;
+	unsigned rt_priority, policy ;
+	long long unsigned delayacct_blkio_ticks ;
+	long unsigned guest_time ;
+	long cguest_time ;
+	long unsigned start_data, end_data, start_brk, arg_start, arg_end ;
+	long unsigned env_start, env_end ;
+	int exit_code ;
+
+	char status = fscanf(
+		f, "%*llu (%*[^)]%*[)] %*c "
+		"%d %d %d %d %d %u "
+		"%lu %lu %lu %lu %lu %lu "
+		"%ld %ld %ld %ld %ld %ld "
+		"%llu %lu %ld %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu "
+		"%d %d %u %u %llu %lu %ld %lu %lu %lu %lu %lu %lu %lu %d", &ppid, &pgrp,
+		&session, &tty_nr, &tpgid, &flags, &minflt, &cminflt, &majflt, &cmajflt, &utime, &stime, &cutime,
+		&cstime, &priority, &nice, &num_threads, &itrealvalue, &starttime, &vsize, &rss, &rsslim,
+		&startcode, &endcode, &startstack, &kstkesp, &kstkeip, &signal, &blocked, &sigignore,
+		&sigcatch, &wchan, &nswap, &cnswap, &exit_signal, &processor, &rt_priority, &policy,
+		&delayacct_blkio_ticks, &guest_time, &cguest_time, &start_data, &end_data,
+		&start_brk, &arg_start, &arg_end, &env_start, &env_end, &exit_code
+	) ;
+
+	fclose(f) ;
+
+	if (status != 49)
+		return rb_ary_new() ;
+
+	return rb_ary_new_from_args(49,
+	INT2NUM(ppid), INT2NUM(pgrp), INT2NUM(session), INT2NUM(tty_nr), INT2NUM(tpgid),
+	UINT2NUM(flags),
+	ULONG2NUM(minflt), ULONG2NUM(cminflt), ULONG2NUM(majflt), ULONG2NUM(cmajflt),
+	ULONG2NUM(utime), ULONG2NUM(stime),
+	LONG2NUM(cutime), LONG2NUM(cstime), LONG2NUM(priority),
+	LONG2NUM(nice), LONG2NUM(num_threads), LONG2NUM(itrealvalue),
+	ULL2NUM(starttime),
+	ULONG2NUM(vsize),
+	LONG2NUM(rss),
+	ULONG2NUM(rsslim), ULONG2NUM(startcode), ULONG2NUM(endcode),
+	ULONG2NUM(startstack), ULONG2NUM(kstkesp), ULONG2NUM(kstkeip),
+	ULONG2NUM(signal), ULONG2NUM(blocked), ULONG2NUM(sigignore), ULONG2NUM(sigcatch),
+	ULONG2NUM(wchan), ULONG2NUM(nswap), ULONG2NUM(cnswap),
+	INT2NUM(exit_signal), INT2NUM(processor),
+	UINT2NUM(rt_priority), UINT2NUM(policy),
+	ULL2NUM(delayacct_blkio_ticks), ULONG2NUM(guest_time), LONG2NUM(cguest_time), ULONG2NUM(start_data),
+	ULONG2NUM(end_data), ULONG2NUM(start_brk), ULONG2NUM(arg_start), ULONG2NUM(arg_end),
+	ULONG2NUM(env_start), ULONG2NUM(env_end),
+	INT2NUM(exit_code)
+	) ;
+}

data/ext/procfs/statm.h

@@ -0,0 +1,99 @@
+#define PAGESIZE sysconf(_SC_PAGESIZE)
+
+VALUE statm(VALUE obj, VALUE pid) {
+	char _path[22] ;
+	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+
+	FILE *f = fopen(_path, "r") ;
+
+	VALUE hash = rb_hash_new() ;
+
+	if (!f) return hash ;
+
+	unsigned int _virtual, resident, shared ;
+	char status = fscanf(f, "%u %u %u", &_virtual, &resident, &shared) ;
+	fclose(f) ;
+
+	if (status != 3) return hash ;
+
+	int pagesize = PAGESIZE ;
+
+	_virtual *= pagesize ;
+	resident *= pagesize ;
+	shared *= pagesize ;
+
+	unsigned int v = resident - shared ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("memory")), UINT2NUM(v)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("virtual_memory")), UINT2NUM(_virtual)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("resident_memory")), UINT2NUM(resident)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("shared_memory")), UINT2NUM(shared)) ;
+
+	return hash ;
+}
+
+VALUE statm_virtual(VALUE obj, VALUE pid) {
+	char _path[22] ;
+	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+
+	FILE *f = fopen(_path, "r") ;
+	VALUE hash = rb_hash_new() ;
+
+	if (!f) return hash ;
+	unsigned int _virtual ;
+	char status = fscanf(f, "%u", &_virtual) ;
+	fclose(f) ;
+
+	if (status != 1) return Qnil ;
+	return UINT2NUM(_virtual * PAGESIZE) ;
+}
+
+VALUE statm_resident(VALUE obj, VALUE pid) {
+	char _path[22] ;
+	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+
+	FILE *f = fopen(_path, "r") ;
+	VALUE hash = rb_hash_new() ;
+
+	if (!f) return hash ;
+	unsigned int resident ;
+	char status = fscanf(f, "%*u %u", &resident) ;
+	fclose(f) ;
+
+	if (status != 1) return Qnil ;
+	return UINT2NUM(resident * PAGESIZE) ;
+}
+
+VALUE statm_shared(VALUE obj, VALUE pid) {
+	char _path[22] ;
+	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+
+	FILE *f = fopen(_path, "r") ;
+	VALUE hash = rb_hash_new() ;
+
+	if (!f) return hash ;
+	unsigned int shared ;
+	char status = fscanf(f, "%*u %*u %u", &shared) ;
+	fclose(f) ;
+
+	if (status != 1) return Qnil ;
+	return UINT2NUM(shared * PAGESIZE) ;
+}
+
+VALUE statm_memory(VALUE obj, VALUE pid) {
+	char _path[22] ;
+	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+
+	FILE *f = fopen(_path, "r") ;
+
+	if (!f) return Qnil ;
+
+	unsigned int resident, shared ;
+	char status = fscanf(f, "%*u %u %u", &resident, &shared) ;
+	fclose(f) ;
+
+	if (status != 2) return Qnil ;
+
+	unsigned int v = (resident - shared) * PAGESIZE ;
+	return UINT2NUM(v) ;
+}

data/ext/procfs/uptime.h

@@ -0,0 +1,12 @@
+VALUE uptime_f(VALUE obj) {
+	FILE *f = fopen("/proc/uptime", "r") ;
+	if (!f) return Qnil ;
+
+	double up_f ;
+	char status = fscanf(f, "%lf", &up_f) ;
+	fclose(f) ;
+
+	if (status != 1) return Qnil ;
+
+	return DBL2NUM(up_f) ;
+}

data/lib/linux_stat.rb

@@ -25,13 +25,16 @@ require "linux_stat/battery"
 require "linux_stat/bios"
 require "linux_stat/net"
 require "linux_stat/pci"
-require "linux_stat/process"
 require "linux_stat/thermal"
 require "linux_stat/usb"
 
 # Dependent Modules
 # Modules that can have reverse dependency
 
+# LinuxStat::ProcFS dependent modules
+require "linux_stat/procfs"
+require "linux_stat/process"
+
 # LinuxStat::CPU.sysinfo dependent modules
 require "linux_stat/sysinfo"
 require "linux_stat/swap"

data/lib/linux_stat/net.rb

@@ -30,7 +30,7 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				indices = find_index_of_bytes
 				data.reject! { |x| x.strip.start_with?('lo:') }
-				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map(&:sum)
+				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }
 
 				{
 					received: r,
@@ -48,7 +48,7 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				index = find_index_of_bytes[0]
 				data.reject! { |x| x.strip.start_with?('lo:') }
-				data.map { |x| x.split[index].to_i }.sum
+				data.map { |x| x.split[index].to_i }.reduce(:+)
 			end
 
 			##
@@ -61,7 +61,7 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				index = find_index_of_bytes[-1]
 				data.reject! { |x| x.strip.start_with?('lo:') }
-				data.map { |x| x.split[index].to_i }.sum
+				data.map { |x| x.split[index].to_i }.reduce(:+)
 			end
 
 			##
@@ -89,13 +89,13 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				indices = find_index_of_bytes
 				data.reject! { |x| x.strip.start_with?('lo:'.freeze) }
-				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map(&:sum)
+				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }
 
 				sleep(interval)
 
 				data2 = IO.readlines(DEV).drop(2)
 				data2.reject! { |x| x.strip.start_with?('lo:'.freeze) }
-				r2, t2 = data2.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map(&:sum)
+				r2, t2 = data2.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }
 
 				# Measure the difference
 				dr, dt = r2.-(r).fdiv(interval), t2.-(t).fdiv(interval)

data/lib/linux_stat/os.rb

@@ -144,20 +144,20 @@ module LinuxStat
 			#
 			# If the stat isn't available, an empty hash is returned.
 			def uptime
-				return {} unless uptime_readable?
+				_uptime = LinuxStat::ProcFS.uptime_f
+				return {} unless _uptime
 
-				uptime = IO.read('/proc/uptime'.freeze).to_f
-				uptime_i = uptime.to_i
+				uptime_i = _uptime.to_i
 
 				h = uptime_i / 3600
 				m = uptime_i % 3600 / 60
-				s = uptime.%(3600).%(60).round(2)
+				s = _uptime.%(3600).%(60).round(2)
 
 				{
 					hour: h,
 					minute: m,
 					second: s
-				}.freeze
+				}
 			end
 
 			##
@@ -172,8 +172,7 @@ module LinuxStat
 			#
 			# If the stat isn't available, nil is returned.
 			def uptime_f
-				return nil unless uptime_readable?
-				IO.foreach('/proc/uptime'.freeze, ' ').next.to_f
+				LinuxStat::ProcFS.uptime_f
 			end
 
 			##
@@ -232,10 +231,6 @@ module LinuxStat
 					h.merge!( key.to_sym => value )
 				}
 			end
-
-			def uptime_readable?
-				@@uptime_readable ||= File.readable?('/proc/uptime')
-			end
 		end
 	end
 end

data/lib/linux_stat/process.rb

@@ -86,7 +86,7 @@ module LinuxStat
 
 					begin
 						h.merge!(x =>
-							case IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip
+							case LinuxStat::ProcFS.ps_state(x)
 								when ?S.freeze then :sleeping
 								when ?I.freeze then :idle
 								when ?Z.freeze then :zombie
@@ -110,11 +110,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def sleeping
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?S.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?S.freeze
 				}
 			end
 
@@ -123,11 +119,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def idle
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?I.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?I.freeze
 				}
 			end
 
@@ -136,11 +128,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def zombie
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?Z.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?Z.freeze
 				}
 			end
 
@@ -149,11 +137,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def running
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?R.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?R.freeze
 				}
 			end
 
@@ -162,14 +146,20 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def stopped
 				list.select { |x|
-					begin
-						v = IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip
-						v == ?T.freeze || v == ?t.freeze
-					rescue StandardError
-						false
-					end
+					v = LinuxStat::ProcFS.ps_state(x)
+					v == ?T.freeze || v == ?t.freeze
 				}
 			end
+
+			##
+			# Returns the last_pid of the system.
+			# It directly calls LS::ProcFS.last_pid
+			#
+			# The return value is Integer, but if the status
+			# isn't available, it will return nil
+			def last_pid
+				LinuxStat::ProcFS.last_pid
+			end
 		end
 	end
 end