linux_stat 1.6.0 → 2.2.0

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,43 @@
+// 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_times", ps_times, 1) ;
+	rb_define_module_function(_procfs, "ps_stat", ps_stat, 1) ;
+}

data/ext/procfs/stat.h

@@ -0,0 +1,119 @@
+VALUE ps_state(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return rb_str_new_cstr("") ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/stat", _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_times(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/stat", _pid) ;
+
+	FILE *f = fopen(_path, "r") ;
+	if (!f) return Qnil ;
+
+	unsigned long utime, stime ;
+
+	char status = fscanf(f, "%*llu (%*[^)]%*[)] %*c %*d %*d %*d %*d %*d %*u %*lu %*lu %*lu %*lu %lu %lu", &utime, &stime) ;
+	fclose(f) ;
+
+	if (status != 2) return Qnil ;
+	double total_time = (utime + stime) / (float)sysconf(_SC_CLK_TCK);
+
+	return DBL2NUM(total_time) ;
+}
+
+VALUE ps_stat(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return rb_str_new_cstr("") ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/stat", _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,109 @@
+#define PAGESIZE sysconf(_SC_PAGESIZE)
+
+VALUE statm(VALUE obj, VALUE pid) {
+	VALUE hash = rb_hash_new() ;
+
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return hash ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
+
+	FILE *f = fopen(_path, "r") ;
+	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) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
+
+	FILE *f = fopen(_path, "r") ;
+	if (!f) return Qnil ;
+
+	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) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
+
+	FILE *f = fopen(_path, "r") ;
+	if (!f) return Qnil ;
+
+	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) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
+
+	FILE *f = fopen(_path, "r") ;
+	if (!f) return Qnil ;
+
+	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) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/statm", _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/battery.rb

@@ -178,7 +178,14 @@ module LinuxStat
 			# For example, a sample output can be like this (taken on a test system):
 			#
 			#    LinuxStat::Battery.devices_stat
-			#    => {:AC=>{:type=>"Mains", :online=>1}, :BAT0=>{:model=>"DELL CYMGM77", :manufacturer=>"Samsung SDI", :type=>"Battery", :status=>"Full", :capacity=>100, :voltage_min_design=>11.4, :charge_full_design=>3.684, :charge_full_design_wh=>42.0, :voltage_now=>12.558, :charge_now=>2.087, :charge_now_wh=>26.21, :charge_full_wh=>23.79, :charge_percentage=>100.0}, :hidpp_battery_0=>{:model=>"Wireless Keyboard", :manufacturer=>"Logitech", :type=>"Battery", :status=>"Discharging", :online=>1}}
+			#    => {:AC=>{:type=>"Mains", :online=>1},
+			# :BAT0=>{:model=>"DELL CYMGM77", :manufacturer=>"Samsung SDI",
+			# :type=>"Battery", :status=>"Full", :capacity=>100, :voltage_min_design=>11.4,
+			# :charge_full_design=>3.684, :charge_full_design_wh=>42.0,
+			# :voltage_now=>12.558, :charge_now=>2.087, :charge_now_wh=>26.21,
+			# :charge_full_wh=>23.79, :charge_percentage=>100.0},
+			# :hidpp_battery_0=>{:model=>"Wireless Keyboard", :manufacturer=>"Logitech",
+			# :type=>"Battery", :status=>"Discharging", :online=>1}}
 			#
 			# If you need info about lots of batteries, use this method.
 			# If the informations are not available, it will return empty Hash for each devices.

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

@@ -7,7 +7,11 @@ module LinuxStat
 			# Reads /etc/os-release and returns a Hash. For example:
 			#    LinuxStat::OS.os_release
 			#
-			#    => {:NAME=>"Arch Linux", :PRETTY_NAME=>"Arch Linux", :ID=>"arch", :BUILD_ID=>"rolling", :ANSI_COLOR=>"38;2;23;147;209", :HOME_URL=>"https://www.archlinux.org/", :DOCUMENTATION_URL=>"https://wiki.archlinux.org/", :SUPPORT_URL=>"https://bbs.archlinux.org/", :BUG_REPORT_URL=>"https://bugs.archlinux.org/", :LOGO=>"archlinux"}
+			#    => {:NAME=>"Arch Linux", :PRETTY_NAME=>"Arch Linux", :ID=>"arch", :BUILD_ID=>"rolling",
+			# :ANSI_COLOR=>"38;2;23;147;209", :HOME_URL=>"https://www.archlinux.org/",
+			# :DOCUMENTATION_URL=>"https://wiki.archlinux.org/",
+			# :SUPPORT_URL=>"https://bbs.archlinux.org/", :BUG_REPORT_URL=>"https://bugs.archlinux.org/",
+			# :LOGO=>"archlinux"}
 			#
 			# If the info isn't available, it will return an empty Hash.
 			#
@@ -127,7 +131,7 @@ module LinuxStat
 			#
 			# The return type is strictly Integer and doesn't fail.
 			def bits
-				@@bits ||= if RbConfig::CONFIG['host_cpu'].end_with?('64') || RUBY_PLATFORM.end_with?('64') || machine.end_with?('64')
+				@@bits ||= if machine.end_with?('64') || RbConfig::CONFIG['host_cpu'].end_with?('64') || RUBY_PLATFORM.end_with?('64')
 					64
 				else
 					32
@@ -138,26 +142,28 @@ module LinuxStat
 			# Reads /proc/uptime and returns the system uptime:
 			#    LinuxStat::OS.uptime
 			#
-			#    => {:hour=>10, :minute=>34, :second=>12.59}
+			#    => {:hour=>16, :minute=>10, :second=>11, :jiffy=>20}
 			#
 			# Using uptime is 10x slower than using uptime_i
 			#
 			# 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_i.%(60)
+				j = _uptime.-(uptime_i) * 100
 
 				{
 					hour: h,
 					minute: m,
-					second: s
-				}.freeze
+					second: s,
+					jiffy: j.to_i
+				}
 			end
 
 			##
@@ -172,8 +178,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 +237,6 @@ module LinuxStat
 					h.merge!( key.to_sym => value )
 				}
 			end
-
-			def uptime_readable?
-				@@uptime_readable ||= File.readable?('/proc/uptime')
-			end
 		end
 	end
 end