linux_stat 1.3.1 → 2.0.1

data/ext/sysinfo/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('sys/sysinfo.h') && have_header('ruby.h')
+	abort('Missing header')
+end
+
+create_makefile 'linux_stat/sysinfo'

data/ext/sysinfo/sysinfo.c

@@ -0,0 +1,177 @@
+#include <sys/sysinfo.h>
+#include "ruby.h"
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+	#pragma GCC optimize ("O3")
+	#pragma GCC diagnostic warning "-Wall"
+#elif defined(__clang__)
+	#pragma clang optimize on
+	#pragma clang diagnostic warning "-Wall"
+#elif defined(__INTEL_COMPILER)
+	#pragma intel optimization_level 3
+#endif
+
+static struct sysinfo info ;
+
+VALUE totalram(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.totalram) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE freeram(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.freeram) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE sharedram(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.sharedram) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE bufferram(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.bufferram) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE totalswap(VALUE obj) {
+	static struct sysinfo info ;
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.totalswap) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE freeswap(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.freeswap) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE totalhigh(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.totalhigh) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE freehigh(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	VALUE _rb_v = ULL2NUM((unsigned long long) info.freehigh) ;
+	VALUE _rb_mem_unit = ULL2NUM((unsigned long long) info.mem_unit) ;
+	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
+}
+
+VALUE uptime(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if (status < 0) return Qnil ;
+
+	unsigned long long v = info.uptime ;
+	return ULL2NUM((unsigned long long) v) ;
+}
+
+VALUE loads(VALUE obj) {
+	char status = sysinfo(&info) ;
+	if(status < 0) return rb_ary_new() ;
+
+	long double load = 1.f / (1 << SI_LOAD_SHIFT) ;
+
+	float l_1 = info.loads[0] * load ;
+	float l_5 = info.loads[1] * load ;
+	float l_15 = info.loads[2] * load ;
+
+	return rb_ary_new_from_args(3,
+		rb_float_new(l_1),
+		rb_float_new(l_5),
+		rb_float_new(l_15)
+	) ;
+}
+
+// Some people may need this function, just keep it to not make unnecessary calls
+VALUE sysinfoStat(VALUE obj) {
+	char status = sysinfo(&info) ;
+	VALUE hash = rb_hash_new() ;
+	if (status < 0) return hash ;
+
+	unsigned long long mem_unit = info.mem_unit ;
+	VALUE _rb_mem_unit = ULL2NUM(mem_unit) ;
+
+	unsigned long long _totalram = info.totalram ;
+	unsigned long long _freeram = info.freeram ;
+	unsigned long long _sharedram = info.sharedram ;
+	unsigned long long _bufferram = info.bufferram ;
+	unsigned long long _totalswap = info.totalswap ;
+	unsigned long long _freeswap = info.freeswap ;
+	unsigned long long _totalhigh = info.totalhigh ;
+	unsigned long long _freehigh = info.freehigh ;
+	unsigned long long _uptime = info.uptime ;
+
+	long double load = 1.f / (1 << SI_LOAD_SHIFT) ;
+
+	float l_1 = info.loads[0] * load ;
+	float l_5 = info.loads[1] * load ;
+	float l_15 = info.loads[2] * load ;
+
+	VALUE loads = rb_ary_new_from_args(3,
+		rb_float_new(l_1),
+		rb_float_new(l_5),
+		rb_float_new(l_15)
+	) ;
+
+	VALUE mul = rb_intern("*") ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("totalram")), rb_funcallv_public(ULL2NUM(_totalram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("freeram")), rb_funcallv_public(ULL2NUM(_freeram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("sharedram")), rb_funcallv_public(ULL2NUM(_sharedram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("bufferram")), rb_funcallv_public(ULL2NUM(_bufferram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("totalswap")), rb_funcallv_public(ULL2NUM(_totalswap), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("freeswap")), rb_funcallv_public(ULL2NUM(_freeswap), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("totalhigh")), rb_funcallv_public(ULL2NUM(_totalhigh), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("freehigh")), rb_funcallv_public(ULL2NUM(_freehigh), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("uptime")), rb_funcallv_public(ULL2NUM(_uptime), mul, 1, &_rb_mem_unit)) ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("loads")), loads) ;
+
+	return hash ;
+}
+
+void Init_sysinfo() {
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE _sysinfo = rb_define_module_under(_linux_stat, "Sysinfo") ;
+
+	rb_define_module_function(_sysinfo, "totalram", totalram, 0) ;
+	rb_define_module_function(_sysinfo, "freeram", freeram, 0) ;
+	rb_define_module_function(_sysinfo, "sharedram", sharedram, 0) ;
+	rb_define_module_function(_sysinfo, "bufferram", bufferram, 0) ;
+	rb_define_module_function(_sysinfo, "totalswap", totalswap, 0) ;
+	rb_define_module_function(_sysinfo, "freeswap", freeswap, 0) ;
+	rb_define_module_function(_sysinfo, "totalhigh", totalhigh, 0) ;
+	rb_define_module_function(_sysinfo, "freehigh", freehigh, 0) ;
+	rb_define_module_function(_sysinfo, "uptime", uptime, 0) ;
+	rb_define_module_function(_sysinfo, "loads", loads, 0) ;
+	rb_define_module_function(_sysinfo, "stat", sysinfoStat, 0) ;
+}

data/ext/utsname/utsname.c

@@ -17,7 +17,7 @@ static char *sysname = "", *nodename = "" ;
 static char *release = "", *version = "", *machine = "" ;
 
 void init_buf() {
-	short status = uname(&buf) ;
+	char status = uname(&buf) ;
 
 	if (status > -1) {
 		sysname = buf.sysname ;

data/lib/linux_stat.rb

@@ -23,20 +23,26 @@ require "linux_stat/version"
 # But might be required by other module functions in "Dependent Modules" section
 require "linux_stat/battery"
 require "linux_stat/bios"
-require "linux_stat/memory"
 require "linux_stat/net"
 require "linux_stat/pci"
-require "linux_stat/process"
-require "linux_stat/swap"
 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"
+require "linux_stat/memory"
+
 # LinuxStat::CPU.nproc dependent modules
-require "linux_stat/cpu"
 require "linux_stat/nproc"
+require "linux_stat/cpu"
 
 # LinuxStat::Uname dependent modules
 require 'linux_stat/utsname'

data/lib/linux_stat/memory.rb

@@ -35,13 +35,23 @@ module LinuxStat
 			end
 
 			##
-			# Returns the total memory details reported by /proc/meminfo.
+			# Returns the total memory reported by LS::Sysinfo.totalram()
 			# The value is in Kilobyte.
 			#
 			# It retuns an Integer but if the info is not available, it will return nil.
 			def total
-				return nil unless meminfo?
-				IO.foreach('/proc/meminfo'.freeze).first.split[1].to_i
+				v = LinuxStat::Sysinfo.totalram
+				v ? v.fdiv(1024).to_i : nil
+			end
+
+			##
+			# Returns the free memory reported by LS::Sysinfo.freeram()
+			# The value is in Kilobyte.
+			#
+			# It retuns an Integer but if the info is not available, it will return nil.
+			def free
+				v = LinuxStat::Sysinfo.freeram
+				v ? v.fdiv(1024).to_i : nil
 			end
 
 			##

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

@@ -140,22 +140,73 @@ module LinuxStat
 			#
 			#    => {:hour=>10, :minute=>34, :second=>12.59}
 			#
+			# 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.%(3600).%(60).round(2)
 
 				{
 					hour: h,
 					minute: m,
 					second: s
-				}.freeze
+				}
+			end
+
+			##
+			# Returns Float uptime of the system reported by /proc/uptime
+			#    LinuxStat::OS.uptime_f
+			#
+			#    => 28956.34
+			#
+			# The value is generally rounded to 2 decimal places.
+			#
+			# Using uptime_f is 10x slower than using uptime_i
+			#
+			# If the stat isn't available, nil is returned.
+			def uptime_f
+				LinuxStat::ProcFS.uptime_f
+			end
+
+			##
+			# Returns uptime of the system reported by LinuxStat::Sysinfo.uptime()
+			#    LinuxStat::OS.uptime_i
+			#
+			#    => 28956
+			#
+			# If the stat isn't available, nil is returned.
+			def uptime_i
+				LinuxStat::Sysinfo.uptime
+			end
+
+			##
+			# The first three fields in this file are load average
+              		# figures giving the number of jobs in the run queue (state R)
+			# or waiting for disk I/O (state D) averaged over 1, 5,
+			# and 15 minutes.  They are the same as the load average
+			# numbers given by uptime(1) and other programs.
+			# https://man7.org/linux/man-pages/man5/procfs.5.html
+			#
+			# The return type is an Hash containing the values
+			# that maps to 1, 5, and 15.
+			# This method calls LinuxStat::Sysinfo.loads() directly.
+			#
+			# However, if the info isn't available, it will return nil as values.
+			def loadavg
+				loads = LinuxStat::Sysinfo.loads
+
+				{
+					1 => loads[0],
+					5 => loads[1],
+					15 => loads[2]
+				}
 			end
 
 			alias distrib_version version
@@ -180,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

@@ -31,7 +31,8 @@ module LinuxStat
 			end
 
 			##
-			# Returns all the id of processes mapped with their names as a Hash.
+			# Returns all the id of processes mapped with their executable names (comm) as a Hash.
+			# The names can be truncated to TASK_COMM_LEN or (16 - 1 = 15) places.
 			def names
 				h, i = {}, -1
 
@@ -42,7 +43,30 @@ module LinuxStat
 					x = l[i]
 
 					begin
-						h.merge!( x => IO.foreach("/proc/#{x}/status").first.split[1])
+						h.merge!( x => IO.read("/proc/#{x}/comm").strip)
+					rescue StandardError
+					end
+				end
+				h
+			end
+
+			##
+			# Returns all the id of processes mapped with their cmdline info as a Hash.
+			# The cmdlines aren't usually truncated like names, but they can contain
+			# arguments with the command.
+			def cmdlines
+				h, i = {}, -1
+
+				l = list
+				count = l.length
+
+				while(i += 1) < count
+					x = l[i]
+
+					begin
+						cmdlines = IO.read("/proc/#{x}/cmdline").strip
+						cmdlines.gsub!(?\u0000.freeze, ?\s.freeze)
+						h.merge!( x => cmdlines)
 					rescue StandardError
 					end
 				end
@@ -62,11 +86,15 @@ module LinuxStat
 
 					begin
 						h.merge!(x =>
-							case IO.foreach("/proc/#{x}/stat", ' '.freeze).first(3)[-1][0]
+							case LinuxStat::ProcFS.ps_state(x)
 								when ?S.freeze then :sleeping
 								when ?I.freeze then :idle
 								when ?Z.freeze then :zombie
 								when ?R.freeze then :running
+								when ?T.freeze then :stopped
+								when ?X.freeze then :dead
+								when ?D.freeze then :sleeping
+								when ?t.freeze then :stopped
 								else :unknown
 							end
 						)
@@ -82,11 +110,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def sleeping
 				list.select { |x|
-					begin
-						IO.foreach("/proc/#{x}/stat", ' '.freeze).first(3)[-1][0] == ?S.freeze
-					rescue StandardError
-						nil
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?S.freeze
 				}
 			end
 
@@ -95,11 +119,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def idle
 				list.select { |x|
-					begin
-						IO.foreach("/proc/#{x}/stat", ' '.freeze).first(3)[-1][0] == ?I.freeze
-					rescue StandardError
-						nil
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?I.freeze
 				}
 			end
 
@@ -108,11 +128,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def zombie
 				list.select { |x|
-					begin
-						IO.foreach("/proc/#{x}/stat", ' '.freeze).first(3)[-1][0] == ?Z.freeze
-					rescue StandardError
-						nil
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?Z.freeze
 				}
 			end
 
@@ -121,13 +137,29 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def running
 				list.select { |x|
-					begin
-						IO.foreach("/proc/#{x}/stat", ' '.freeze).first(3)[-1][0] == ?R.freeze
-					rescue StandardError
-						nil
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?R.freeze
 				}
 			end
+
+			##
+			# Returns all the id of processes that are stopped.
+			# The return type is an Array of Integers.
+			def stopped
+				list.select { |x|
+					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