linux_stat 2.2.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a2257dd9d025a05cf31fbfdf06d67933abd1d355678fe23c0ab1d5797fce9e9
-  data.tar.gz: 3898fa563cda7716321f689a64448afb0b46bb7ba1c9bac297c9f3ba0e9e4f38
+  metadata.gz: 56eb9d01b537db6e6dab3a6ee86a391a1076f63cc612ff961e33f7ab8c703129
+  data.tar.gz: 30a3f6df0c51dfb14c28fcbdd7d2298d4f13fa48e15ef9ef63ab13e0fd980e68
 SHA512:
-  metadata.gz: 5b6fede8da5d7a14322253c8c108b56069f0d3089349f23a9b7c207500c240b8a855a847dc9de649797da81466e449911609f3308473a4d8f5c32c1d0622cf46
-  data.tar.gz: 0f61a61920ca364cba0b3e664ff67bab7fcbf45d3d47eaea622b71b2fde7585cb761025f1b02d8f7e80ea0105b66541432cdb7ca12594938a6d5f04c0d648b05
+  metadata.gz: 1f24a5a7fb1d8f32a2c35c7cbc5a7b9bb380efb33a2df23e269ea4ebac565f866b6a399a0361a3f4f325bad13be1b545d59726efccabb4d8d6f8045ed03c3fc6
+  data.tar.gz: 81c1c316b49aaab37f4e300eb597db3a3bcb538549fc6192d9661e7ca5022bd5b6942a257ced51760e2065d7aca82ae465f55e79202ba7a5f8c9e917f53f505c

data/README.md

@@ -38,18 +38,36 @@ It only works on Linux, and detecting the OS is upto the user of this gem.
 2. Ruby: Ruby 2.3.0 and above.
 
 ## Build Dependencies:
-+ You need to have the C compiler installed to be able to compile the C extensions.
-On Arch Linux:
+#### You need to have the C compiler installed to be able to compile the C extensions.
+
++ On Arch Linux / Manjaro / Archlabs / Other Arch Based Distributions
+```
+# pacman -S gcc make ruby
+```
+
++ On Debian / Ubuntu / Linux Mint / Pop!_OS / Raspberry Pi OS / Other Debian Based Distributions
+```
+# apt install gcc build-essential ruby ruby-dev build-essential
+```
+
++ Gentoo / Gentoo Based Distributions
+```
+# emerge --ask dev-lang/ruby
+```
+
++ Fedora / AmazonLinux* / CentOS* / Other RedHat Based Distributions
 ```
-# pacman -S gcc make
+# yum install gcc ruby-devel ruby make
 ```
 
-On Debian based systems:
+You can run linux_stat on *AmazonLinux and *CentOS if you have Ruby 2.3.0+.
+
++ OpenSUSE
 ```
-# apt install gcc build-essential ruby-dev
+# zypper install gcc ruby ruby-devel make
 ```
 
-+ You can remove the packages once the program is installed.
++ You can remove the above packages once the gem is installed.
 
 ---
 
@@ -62,13 +80,28 @@ You can install hwdata simply.
 + Arch:
 
 ```
-sudo pacman -S hwids
+# pacman -S hwids
 ```
 
 + Debian based systems:
 
 ```
-sudo apt install hwdata
+# apt install hwdata
+```
+
++ Gentoo / Gentoo Based Distributions
+```
+# emerge --ask sys-apps/hwids
+```
+
++ Fedora / Amazon Linux / CentOS
+```
+# yum install hwdata
+```
+
++ OpenSUSE
+```
+zypper install hwdata
 ```
 
 But without hwdata, it won't show such information.

data/exe/linuxstat.rb

@@ -7,6 +7,12 @@ rescue LoadError
 	abort "The Gem needs to be installed before this test can be run!"
 end
 
+# Time reporting format
+T_FMT = '%d'.freeze
+
+# Check the number of iterations
+iterations = (ARGV.find { |x| x.to_i.to_s == x } || 1).to_i
+
 Integer.class_exec do
 	define_method(:clamp) { |min, max|
 		self < min ? min : self > max ? max : self
@@ -100,122 +106,166 @@ execute = constants.map(&:downcase).map.with_index { |x, i|
 execute.replace(constants) if execute.empty?
 HEXAGONS = %W(\u2b22 \u2b23 \u2B53 \u2B1F)
 
-execute.sort.each do |c|
-	e = eval("LinuxStat::#{c}")
+puts " #{HEXAGONS.rotate![0]} LinuxStat: #{LinuxStat::VERSION}"
+puts " #{HEXAGONS.rotate![0]} Test Modules: #{execute.size}"
+puts " #{HEXAGONS.rotate![0]} Iterations: #{iterations}"
 
-	next if e.class != Module && e.class != Class
+puts " #{HEXAGONS.rotate![0]} Format: Markdown" if MARKDOWN
+puts " #{HEXAGONS.rotate![0]} Format: HTML" if HTML
 
-	meths = e.methods(false).sort
+sleep 2
+puts
 
-	if meths.length > 0
-		if MARKDOWN
-			puts "### LinuxStat::#{c}\n```"
-		elsif HTML
-			puts "<h3>LinuxStat::#{c}</h3>\n<pre>"
-		else
-			puts "\e[1;4;38;2;255;240;0mLinuxStat::#{c}\e[0m"
-		end
+def get_colour(n)
+	if n > 10_000
+		"\e[1;38;2;255;50;50m"
+	elsif n > 5_000
+		"\e[1;38;2;255;170;0m"
+	else
+		"\e[1;38;2;0;170;0m"
 	end
+end
+
+total_real_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+total_cpu_time = Process.times
+
+iterations.times do
+	execute.sort.each do |c|
+		e = eval("LinuxStat::#{c}")
+
+		next if e.class != Module && e.class != Class
 
-	meths.each do |meth|
-		arg = nil
+		meths = e.methods(false).sort
 
-		arity = e.method(meth).arity
-		if arity > 0 || arity == -2
-			if c == :PrettifyBytes
-				arg = rand(10 ** 15)
-			elsif c == :FS
-				arg = '/'
+		if meths.length > 0
+			if MARKDOWN
+				puts "### LinuxStat::#{c}\n```"
+			elsif HTML
+				puts "<h3>LinuxStat::#{c}</h3>\n<pre>"
 			else
-				next
+				puts "\e[1;4;38;2;255;240;0mLinuxStat::#{c}\e[0m"
 			end
 		end
 
-		params = e.method(meth).parameters
-		param = ''
-		params.each do |p|
-			case p[0]
-				when :opt
-					param << "#{p[1]}, "
-				when :key
-					param << "#{p[1]}:, "
-				when :req
-					_arg = arg ? " = #{arg.inspect}" : ''.freeze
-					param << "#{p[1] || 'arg'}#{_arg}, "
+		meths.each do |meth|
+			arg = nil
+
+			arity = e.method(meth).arity
+			if arity > 0 || arity == -2
+				if c == :PrettifyBytes
+					arg = rand(10 ** 15)
+				elsif c == :FS
+					arg = '/'
+				else
+					next
+				end
 			end
-		end
 
-		param.chomp!(", ")
-
-		disp_meth = "#{meth}"
-		disp_meth.concat(arg ? "(#{param})" : "(#{param})")
-
-		time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-		ret = arg ? e.send(meth, arg) : e.send(meth)
-		time2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-		time = time2.-(time).*(1_000_000).round(3)
-
-		v = ret.inspect
-		dis = v.length > 253 ? v[0..250].strip + '...'.freeze : v
-
-		source = e.singleton_method(meth).source_location.to_a
-		src, src_meth, src_ret = '', '', ''
-
-		unless source.empty?
-			src << " File:\t\t#{File.split(source[0])[-1]} | Line: #{source[1]}\n"
-			src_meth << " Definition:\t#{IO.foreach(source[0]).first(source[1])[-1].strip}\n"
-
-			src_ret << " Returns:\t" << case ret
-				when Array then 'Array | Empty Array'
-				when Complex then 'Complex | nil'
-				when Float then 'Float | nil'
-				when Hash then 'Hash | Empty Hash'
-				when Integer then 'Integer | nil'
-				when Rational then 'Rational | nil'
-				when String then "String | (Frozen) Empty String"
-				when Time then 'Time | nil'
-				when true, false then 'True or False | nil'
-				when nil then 'nil'
-				else ''
-			end << ?\n.freeze if PRINT_TYPE
-
-			if MARKDOWN || HTML
-				src.prepend('#'.freeze)
-				src_meth.prepend('#'.freeze)
-				src_ret.prepend(?#.freeze) if PRINT_TYPE
-			else
-				src.prepend(HEXAGONS.rotate![0].freeze)
-				src_meth.prepend(HEXAGONS.rotate![0].freeze)
-				src_ret.prepend(HEXAGONS.rotate![0].freeze) if PRINT_TYPE
+			params = e.method(meth).parameters
+			param = ''
+			params.each do |p|
+				case p[0]
+					when :opt
+						param << "#{p[1]}, "
+					when :key
+						param << "#{p[1]}:, "
+					when :req
+						_arg = arg ? " = #{arg.inspect}" : ''.freeze
+						param << "#{p[1] || 'arg'}#{_arg}, "
+				end
 			end
-		end
 
-		if MARKDOWN
-			puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
-		elsif HTML
-			puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
-		else
-			puts "\e[1m#{src.colourize}\e[1m#{src_meth.colourize(6)}\e[1m#{src_ret.colourize(1)}\e[0m\e[1;38;2;80;80;255m#{e}.#{disp_meth}\e[0m\n=> #{dis}"
-		end
+			param.chomp!(", ")
+
+			disp_meth = "#{meth}"
+			disp_meth.concat(arg ? "(#{param})" : "(#{param})")
+
+			time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+			cputime = Process.times
+
+			ret = arg ? e.send(meth, arg) : e.send(meth)
+
+			time2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+			cputime2 = Process.times
+
+			time = time2.-(time).*(1_000_000)
+			cputime = cputime2.stime.+(cputime2.utime).-(cputime.stime + cputime.utime).*(1_000_000)
+
+			v = ret.inspect
+			dis = v.length > 253 ? v[0..250].strip + '...'.freeze : v
+
+			source = e.singleton_method(meth).source_location.to_a
+			src, src_meth, src_ret = '', '', ''
+
+			unless source.empty?
+				src << " File:\t\t#{File.split(source[0])[-1]} | Line: #{source[1]}\n"
+				src_meth << " Definition:\t#{IO.foreach(source[0]).first(source[1])[-1].strip}\n"
+
+				src_ret << " Returns:\t" << case ret
+					when Array then 'Array | Empty Array'
+					when Complex then 'Complex | nil'
+					when Float then 'Float | nil'
+					when Hash then 'Hash | Empty Hash'
+					when Integer then 'Integer | nil'
+					when Rational then 'Rational | nil'
+					when String then "String | (Frozen) Empty String"
+					when Time then 'Time | nil'
+					when true, false then 'True or False | nil'
+					when nil then 'nil'
+					else ''
+				end << ?\n.freeze if PRINT_TYPE
+
+				if MARKDOWN || HTML
+					src.prepend('#'.freeze)
+					src_meth.prepend('#'.freeze)
+					src_ret.prepend(?#.freeze) if PRINT_TYPE
+				else
+					src.prepend(HEXAGONS.rotate![0].freeze)
+					src_meth.prepend(HEXAGONS.rotate![0].freeze)
+					src_ret.prepend(HEXAGONS.rotate![0].freeze) if PRINT_TYPE
+				end
+			end
 
-		puts( "(" +
-			if time > 10_000
-				"\e[1;38;2;255;50;50m"
-			elsif time > 5_000
-				"\e[1;38;2;255;170;0m"
+			if MARKDOWN
+				puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
+			elsif HTML
+				puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
 			else
-				"\e[1;38;2;0;170;0m"
-			end + "Time taken: #{time}\u03BCs\e[0m)"
-		) if PRINT_TIME
+				puts "\e[1m#{src.colourize}\e[1m#{src_meth.colourize(6)}\e[1m#{src_ret.colourize(1)}\e[0m\e[1;38;2;80;80;255m#{e}.#{disp_meth}\e[0m\n=> #{dis}"
+			end
 
-		puts
-	end
+			if PRINT_TIME
+				time_colour = get_colour(time)
+				cputime_colour = get_colour(cputime)
+
+				puts "[Real Time: #{time_colour}#{T_FMT % time}\u03BCs\e[0m, "\
+				"CPU Time: #{cputime_colour}#{T_FMT % cputime}\u03BCs\e[0m]"
+			end
+
+			puts
+		end
 
-	if meths.length > 0
-		if MARKDOWN
-			puts "```\n\n"
-		elsif HTML
-			puts "</pre>"
+		if meths.length > 0
+			if MARKDOWN
+				puts "```\n\n"
+			elsif HTML
+				puts "</pre>"
+			end
 		end
 	end
 end
+
+if PRINT_TIME
+	total_real_time2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+	total_cpu_time2 = Process.times
+
+	total_real_t = total_real_time2.-(total_real_time).*(1_000_000)
+
+	total_cpu_t = total_cpu_time2.stime.+(total_cpu_time2.utime).-(
+		total_cpu_time.stime + total_cpu_time.utime
+	).*(1_000_000)
+
+	puts "\e[38;2;255;255;0m:: Warning total time also depends on your terminal speed!\e[0m"
+	puts "Total Real Time: #{T_FMT % total_real_t}\u03BCs"
+	puts "Total CPU Time: #{T_FMT % total_cpu_t}\u03BCs"
+end

data/ext/fs_stat/disk_stat.h

@@ -0,0 +1,25 @@
+static VALUE getDiskStats (volatile VALUE obj, volatile VALUE path) {
+	FILE *file = fopen("/proc/diskstats", "r") ;
+	if(!file) return rb_ary_new() ;
+
+	char lines[120] ;
+	unsigned long long read, write ;
+	char *p = StringValuePtr(path) ;
+
+	while(fgets(lines, 119, file)) {
+		sscanf(lines, "%*s %*s %s %*s %*s %llu %*s %*s %*s %llu", lines, &read, &write) ;
+
+		if(strcmp(lines, p) == 0) {
+			fclose(file) ;
+
+			return rb_ary_new_from_args(
+				2,
+				ULL2NUM(read),
+				ULL2NUM(write)
+			) ;
+		}
+	}
+
+	fclose(file) ;
+	return rb_ary_new() ;
+}

data/ext/fs_stat/extconf.rb

@@ -4,7 +4,8 @@ unless have_const('linux') || RbConfig::CONFIG['arch'].to_s[/linux/]
 	abort('Platform is not linux')
 end
 
-unless have_header('sys/statvfs.h') && have_header('ruby.h')
+unless have_header('sys/statvfs.h') && have_header('sys/ioctl.h') &&
+	have_header('fcntl.h') && have_header('linux/fs.h') && have_header('unistd.h')
 	abort('Missing header')
 end
 

data/ext/fs_stat/fs_stat.c

@@ -1,5 +1,12 @@
 #include <sys/statvfs.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <unistd.h>
+
 #include "ruby.h"
+#include "sector_size.h"
+#include "disk_stat.h"
 
 #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 	#pragma GCC optimize ("O3")
@@ -11,7 +18,7 @@
 	#pragma intel optimization_level 3
 #endif
 
-static VALUE statfs(VALUE obj, VALUE dir) {
+static VALUE statfs(volatile VALUE obj, volatile VALUE dir) {
 	struct statvfs buf ;
 	char *d = StringValuePtr(dir) ;
 	VALUE hash = rb_hash_new() ;
@@ -36,4 +43,6 @@ void Init_fs_stat() {
 	VALUE _linux_stat = rb_define_module("LinuxStat") ;
 	VALUE fs = rb_define_module_under(_linux_stat, "FS") ;
 	rb_define_module_function(fs, "stat", statfs, 1) ;
+	rb_define_module_function(fs, "sectors", getSectorSize, 1) ;
+	rb_define_module_function(fs, "total_io", getDiskStats, 1) ;
 }

data/ext/fs_stat/sector_size.h

@@ -0,0 +1,13 @@
+static VALUE getSectorSize(volatile VALUE obj, volatile VALUE path) {
+	char *dev = StringValuePtr(path) ;
+
+	unsigned int fd = open(dev, O_RDONLY | O_NONBLOCK) ;
+	if(fd < 0) return Qnil ;
+
+	unsigned int sSize = 0 ;
+	short status = ioctl(fd, BLKSSZGET, &sSize) ;
+	close(fd) ;
+	if(status < 0)  return Qnil ;
+
+	return UINT2NUM(sSize) ;
+}

data/ext/nproc/nproc.c

@@ -15,7 +15,7 @@
 	#pragma intel optimization_level 3
 #endif
 
-static VALUE count_cpu_for_pid(VALUE obj, VALUE pid) {
+static VALUE count_cpu_for_pid(volatile VALUE obj, volatile VALUE pid) {
 	cpu_set_t set ;
 	CPU_ZERO(&set) ;
 	char status = sched_getaffinity(FIX2INT(pid), sizeof(set), &set) ;

data/ext/procfs/loadavg_pid.h

@@ -1,4 +1,4 @@
-VALUE last_pid(VALUE obj) {
+static VALUE last_pid(volatile VALUE obj) {
 	FILE *f = fopen("/proc/loadavg", "r") ;
 	if (!f) return Qnil ;
 

data/ext/procfs/procfs.c

@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
+#include <glob.h>
 #include "ruby.h"
 #include "uptime.h"
 #include "statm.h"
@@ -22,6 +23,8 @@
 int Init_procfs() {
 	VALUE _linux_stat = rb_define_module("LinuxStat") ;
 	VALUE _procfs = rb_define_module_under(_linux_stat, "ProcFS") ;
+	VALUE _cpu = rb_define_module_under(_linux_stat, "CPU") ;
+	VALUE _process = rb_define_module_under(_linux_stat, "Process") ;
 
 	// uptime
 	rb_define_module_function(_procfs, "uptime_f", uptime_f, 0) ;
@@ -40,4 +43,7 @@ int Init_procfs() {
 	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) ;
+	rb_define_module_function(_procfs, "cpu_times", cpuTimes, 0) ;
+	rb_define_module_function(_procfs, "list_process", listProcess, 0) ;
+
 }

data/ext/procfs/stat.h

@@ -1,4 +1,4 @@
-VALUE ps_state(VALUE obj, VALUE pid) {
+static VALUE ps_state(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return rb_str_new_cstr("") ;
 
@@ -17,7 +17,30 @@ VALUE ps_state(VALUE obj, VALUE pid) {
 	return rb_str_new_cstr(_s) ;
 }
 
-VALUE ps_times(VALUE obj, VALUE pid) {
+static VALUE listProcess(volatile VALUE obj) {
+	VALUE ary = rb_ary_new() ;
+
+	glob_t globlist ;
+	int status = glob("/proc/[0-9]*/", GLOB_NOSORT, NULL, &globlist) ;
+
+	if (status == GLOB_NOSPACE || status == GLOB_ABORTED || status == GLOB_NOMATCH) {
+		globfree(&globlist) ;
+		return ary ;
+	}
+
+	char *v, *token ;
+	unsigned int i = 0 ;
+	unsigned int num ;
+
+	while(v = globlist.gl_pathv[i++]) {
+		if (sscanf(v, "/proc/%u", &num) == 1) rb_ary_push(ary, UINT2NUM(num)) ;
+	}
+
+	globfree(&globlist) ;
+	return ary ;
+}
+
+static VALUE ps_times(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return Qnil ;
 
@@ -38,7 +61,7 @@ VALUE ps_times(VALUE obj, VALUE pid) {
 	return DBL2NUM(total_time) ;
 }
 
-VALUE ps_stat(VALUE obj, VALUE pid) {
+static VALUE ps_stat(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return rb_str_new_cstr("") ;
 
@@ -117,3 +140,46 @@ VALUE ps_stat(VALUE obj, VALUE pid) {
 	INT2NUM(exit_code)
 	) ;
 }
+
+static VALUE cpuTimes(volatile VALUE obj) {
+	VALUE ary = rb_ary_new() ;
+	FILE *f = fopen("/proc/stat", "r") ;
+
+	if (!f) return ary ;
+
+	unsigned long user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice ;
+	char line[1024] ;
+	char cpuCode[7] ;
+	float ticks = sysconf(_SC_CLK_TCK) ;
+	char scanStatus ;
+
+	while(fgets(line, 1023, f)) {
+		if (!(line[0] == 'c' && line[1] == 'p' && line[2] == 'u')) break ;
+
+		scanStatus = sscanf(line,
+			"%7[cpu0-9] %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
+			cpuCode, &user, &nice, &system, &idle, &iowait, &irq, &softirq, &steal, &guest, &guest_nice
+		) ;
+
+		if (scanStatus != 11) break ;
+
+		VALUE innerHash = rb_hash_new() ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("cpu")), rb_str_new_cstr(cpuCode)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("user")), rb_float_new(user / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("nice")), rb_float_new(nice / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("system")), rb_float_new(system / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("idle")), rb_float_new(idle / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("iowait")), rb_float_new(iowait / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("irq")), rb_float_new(irq / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("softirq")), rb_float_new(softirq / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("steal")), rb_float_new(steal / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("guest")), rb_float_new(guest / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("guest_nice")), rb_float_new(guest_nice / ticks)) ;
+
+		rb_ary_push(ary, innerHash) ;
+	}
+
+	fclose(f) ;
+
+	return ary ;
+}

data/ext/procfs/statm.h

@@ -1,6 +1,6 @@
 #define PAGESIZE sysconf(_SC_PAGESIZE)
 
-VALUE statm(VALUE obj, VALUE pid) {
+static VALUE statm(volatile VALUE obj, volatile VALUE pid) {
 	VALUE hash = rb_hash_new() ;
 
 	int _pid = FIX2INT(pid) ;
@@ -34,7 +34,7 @@ VALUE statm(VALUE obj, VALUE pid) {
 	return hash ;
 }
 
-VALUE statm_virtual(VALUE obj, VALUE pid) {
+static VALUE statm_virtual(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return Qnil ;
 
@@ -52,7 +52,7 @@ VALUE statm_virtual(VALUE obj, VALUE pid) {
 	return UINT2NUM(_virtual * PAGESIZE) ;
 }
 
-VALUE statm_resident(VALUE obj, VALUE pid) {
+static VALUE statm_resident(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return Qnil ;
 
@@ -70,7 +70,7 @@ VALUE statm_resident(VALUE obj, VALUE pid) {
 	return UINT2NUM(resident * PAGESIZE) ;
 }
 
-VALUE statm_shared(VALUE obj, VALUE pid) {
+static VALUE statm_shared(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return Qnil ;
 
@@ -88,7 +88,7 @@ VALUE statm_shared(VALUE obj, VALUE pid) {
 	return UINT2NUM(shared * PAGESIZE) ;
 }
 
-VALUE statm_memory(VALUE obj, VALUE pid) {
+static VALUE statm_memory(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return Qnil ;
 

data/ext/procfs/uptime.h

@@ -1,4 +1,4 @@
-VALUE uptime_f(VALUE obj) {
+static VALUE uptime_f(volatile VALUE obj) {
 	FILE *f = fopen("/proc/uptime", "r") ;
 	if (!f) return Qnil ;
 

data/ext/sysconf/sysconf.c

@@ -11,103 +11,103 @@
 	#pragma intel optimization_level 3
 #endif
 
-static VALUE getTick(VALUE obj) {
+static VALUE getTick(volatile VALUE obj) {
 	int val = sysconf(_SC_CLK_TCK) ;
 	if (val < 0) return Qnil ;
 
 	return INT2FIX(val) ;
 }
 
-static VALUE getChildMax(VALUE obj) {
+static VALUE getChildMax(volatile VALUE obj) {
 	long long int val = sysconf(_SC_CHILD_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getHostnameMax(VALUE obj) {
+static VALUE getHostnameMax(volatile VALUE obj) {
 	long long val = sysconf(_SC_HOST_NAME_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getLoginNameMax(VALUE obj) {
+static VALUE getLoginNameMax(volatile VALUE obj) {
 	long long val = sysconf(_SC_LOGIN_NAME_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getOpenMax(VALUE obj) {
+static VALUE getOpenMax(volatile VALUE obj) {
 	long long val = sysconf(_SC_OPEN_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getPageSize(VALUE obj) {
+static VALUE getPageSize(volatile VALUE obj) {
 	int val = sysconf(_SC_PAGESIZE) ;
 	if (val < 0) return Qnil ;
 
 	return INT2FIX(val) ;
 }
 
-static VALUE getStreamMax(VALUE obj) {
+static VALUE getStreamMax(volatile VALUE obj) {
 	long long val = sysconf(_SC_STREAM_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getTTYNameMax(VALUE obj) {
+static VALUE getTTYNameMax(volatile VALUE obj) {
 	long long val = sysconf(_SC_TTY_NAME_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getPosixVersion(VALUE obj) {
+static VALUE getPosixVersion(volatile VALUE obj) {
 	long long val = sysconf(_SC_VERSION) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getLineMax(VALUE obj) {
+static VALUE getLineMax(volatile VALUE obj) {
 	long long val = sysconf(_SC_LINE_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getExprNestMax(VALUE obj) {
+static VALUE getExprNestMax(volatile VALUE obj) {
 	long long val = sysconf(_SC_EXPR_NEST_MAX) ;
 	if (val < 0) return Qnil ;
 
 	return LL2NUM(val) ;
 }
 
-static VALUE getProcessorConfigured(VALUE obj) {
+static VALUE getProcessorConfigured(volatile VALUE obj) {
 	long val = sysconf(_SC_NPROCESSORS_CONF) ;
 	if (val < 0) return Qnil ;
 
 	return LONG2NUM(val) ;
 }
 
-static VALUE getProcessorOnline(VALUE obj) {
+static VALUE getProcessorOnline(volatile VALUE obj) {
 	long val = sysconf(_SC_NPROCESSORS_ONLN) ;
 	if (val < 0) return Qnil ;
 
 	return LONG2NUM(val) ;
 }
 
-static VALUE getUser(VALUE obj) {
+static VALUE getUser(volatile VALUE obj) {
 	char *name = getlogin() ;
 	return name ? rb_str_new_cstr(name) : rb_str_new_cstr("") ;
 }
 
-static VALUE getUID(VALUE obj) {
+static VALUE getUID(volatile VALUE obj) {
 	return UINT2NUM((unsigned int) getuid()) ;
 }
 
@@ -115,11 +115,11 @@ static VALUE getGID(VALUE obj) {
 	return UINT2NUM((unsigned int) getgid()) ;
 }
 
-static VALUE getEUID(VALUE obj) {
+static VALUE getEUID(volatile VALUE obj) {
 	return UINT2NUM((unsigned int) geteuid()) ;
 }
 
-static VALUE getHostname(VALUE obj) {
+static VALUE getHostname(volatile VALUE obj) {
 	int h_max = sysconf(_SC_HOST_NAME_MAX) + 1 ;
 	char hostname[h_max] ;
 

data/ext/sysinfo/sysinfo.c

@@ -13,7 +13,7 @@
 
 static struct sysinfo info ;
 
-VALUE totalram(VALUE obj) {
+static VALUE totalram(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -22,7 +22,7 @@ VALUE totalram(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE freeram(VALUE obj) {
+static VALUE freeram(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -31,7 +31,7 @@ VALUE freeram(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE sharedram(VALUE obj) {
+static VALUE sharedram(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -40,7 +40,7 @@ VALUE sharedram(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE bufferram(VALUE obj) {
+static VALUE bufferram(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -49,7 +49,7 @@ VALUE bufferram(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE totalswap(VALUE obj) {
+static VALUE totalswap(volatile VALUE obj) {
 	static struct sysinfo info ;
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
@@ -59,7 +59,7 @@ VALUE totalswap(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE freeswap(VALUE obj) {
+static VALUE freeswap(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -68,7 +68,7 @@ VALUE freeswap(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE totalhigh(VALUE obj) {
+static VALUE totalhigh(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -77,7 +77,7 @@ VALUE totalhigh(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE freehigh(VALUE obj) {
+static VALUE freehigh(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -86,7 +86,7 @@ VALUE freehigh(VALUE obj) {
 	return rb_funcallv_public(_rb_v, rb_intern("*"), 1, &_rb_mem_unit) ;
 }
 
-VALUE uptime(VALUE obj) {
+static VALUE uptime(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
@@ -94,7 +94,7 @@ VALUE uptime(VALUE obj) {
 	return ULL2NUM((unsigned long long) v) ;
 }
 
-VALUE loads(VALUE obj) {
+static VALUE loads(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	if(status < 0) return rb_ary_new() ;
 
@@ -112,7 +112,7 @@ VALUE loads(VALUE obj) {
 }
 
 // Some people may need this function, just keep it to not make unnecessary calls
-VALUE sysinfoStat(VALUE obj) {
+static VALUE sysinfoStat(volatile VALUE obj) {
 	char status = sysinfo(&info) ;
 	VALUE hash = rb_hash_new() ;
 	if (status < 0) return hash ;

data/ext/utsname/utsname.c

@@ -28,23 +28,23 @@ void init_buf() {
 	}
 }
 
-static VALUE getSysname(VALUE obj) {
+static VALUE getSysname(volatile VALUE obj) {
 	return rb_str_new_cstr(sysname) ;
 }
 
-static VALUE getNodename(VALUE obj) {
+static VALUE getNodename(volatile VALUE obj) {
 	return rb_str_new_cstr(nodename) ;
 }
 
-static VALUE getRelease(VALUE obj) {
+static VALUE getRelease(volatile VALUE obj) {
 	return rb_str_new_cstr(release) ;
 }
 
-static VALUE getVersion(VALUE obj) {
+static VALUE getVersion(volatile VALUE obj) {
 	return rb_str_new_cstr(version) ;
 }
 
-static VALUE getMachine(VALUE obj) {
+static VALUE getMachine(volatile VALUE obj) {
 	return rb_str_new_cstr(machine) ;
 }
 

data/lib/linux_stat/cpu.rb

@@ -209,6 +209,10 @@ module LinuxStat
 				h
 			end
 
+			def times
+				LinuxStat::ProcFS.cpu_times
+			end
+
 			##
 			# Returns a Hash with max core frequencies corresponding to the CPUs.
 			#

data/lib/linux_stat/filesystem.rb

@@ -110,6 +110,51 @@ module LinuxStat
 			def stat_raw(fs = ?..freeze)
 				LinuxStat::FS.stat(fs)
 			end
+
+			def sector_size(path = LinuxStat::Mounts.root)
+				LinuxStat::FS.sectors(path)
+			end
+
+			def io_total(path = LinuxStat::Mounts.root)
+				p = File.split(path)[-1]
+				_io_total = LinuxStat::FS.total_io(p)
+
+				return {} if _io_total.empty?
+
+				sector_size = LinuxStat::FS.sectors(path)
+				return {} unless sector_size
+
+				{
+					read: _io_total[0] &.*(sector_size),
+					write: _io_total[1] &.*(sector_size),
+				}
+			end
+
+			def io_usage(path = LinuxStat::Mounts.root, interval = 0.1)
+				p = File.split(path)[-1]
+
+				measure1 = LinuxStat::FS.total_io(p)
+				sleep(interval)
+				measure2 = LinuxStat::FS.total_io(p)
+
+				return {} if measure1.empty? || measure2.empty?
+
+				sector_size = LinuxStat::FS.sectors(path)
+				return {} unless sector_size
+
+				m1r = measure1[0]
+				m1w = measure1[1]
+
+				m2r = measure2[0]
+				m2w = measure2[1]
+
+				{
+					read: m2r.-(m1r).*(sector_size).fdiv(interval),
+					write: m2w.-(m1w).*(sector_size).fdiv(interval)
+				}
+			end
+
+			alias sectors sector_size
 		end
 	end
 end

data/lib/linux_stat/prettify_bytes.rb

@@ -7,6 +7,28 @@ module LinuxStat
 	# 4. kiB, MiB, GiB, TiB, PiB, EiB, ZiB, YiB
 
 	module PrettifyBytes
+		# Kilo = Kilobyte (1000 - 1), and so on...
+		# 8.times { |x| puts 1000.**(x.next).to_s << '.00' }
+		KILO = 1000.00
+		MEGA = 1000000.00
+		GIGA = 1000000000.00
+		TERA = 1000000000000.00
+		PETA = 1000000000000000.00
+		EXA = 1000000000000000000.00
+		ZETTA = 1000000000000000000000.00
+		YOTTA = 1000000000000000000000000.00
+
+		# Binary suffixes
+		# 8.times { |x| puts 1024.**(x.next).to_s << '.00' }
+		KIBI = 1024.00
+		MEBI = 1048576.00
+		GIBI = 1073741824.00
+		TEBI = 1099511627776.00
+		PEBI = 1125899906842624.00
+		EXBI = 1152921504606846976.00
+		ZEBI = 1180591620717411303424.00
+		YOBI = 1208925819614629174706176.00
+
 		class << self
 			##
 			# Converts a number to decimal byte units and outputs with the metric prefix
@@ -24,12 +46,33 @@ module LinuxStat
 			#
 			# => "1.07 gigabytes"
 			def convert_decimal(n, precision: 2)
-				@@d_units ||= %W(#{''} kilo mega giga tera peta exa zetta)
-					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
-				unit = @@d_units.find { |x| n < x[1] } || ['yotta'.freeze, 10 ** 27]
-
-				converted = n.fdiv(unit[1] / 1000).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+				if n < KILO
+					"#{"%.#{precision}f" % n} byte#{?s.freeze if n != 1}"
+				elsif n < MEGA
+					n /= KILO
+					"#{"%.#{precision}f" % n} kilobyte#{?s.freeze if n != 1}"
+				elsif n < GIGA
+					n /= MEGA
+					"#{"%.#{precision}f" % n} megabyte#{?s.freeze if n != 1}"
+				elsif n < TERA
+					n /= GIGA
+					"#{"%.#{precision}f" % n} gigabyte#{?s.freeze if n != 1}"
+				elsif n < PETA
+					n /= TERA
+					"#{"%.#{precision}f" % n} terabyte#{?s.freeze if n != 1}"
+				elsif n < EXA
+					n /= PETA
+					"#{"%.#{precision}f" % n} petabyte#{?s.freeze if n != 1}"
+				elsif n < ZETTA
+					n /= EXA
+					"#{"%.#{precision}f" % n} exabyte#{?s.freeze if n != 1}"
+				elsif n < YOTTA
+					n /= ZETTA
+					"#{"%.#{precision}f" % n} zettabyte#{?s.freeze if n != 1}"
+				else
+					n /= YOTTA
+					"#{"%.#{precision}f" % n} yottabyte#{?s.freeze if n != 1}"
+				end
 			end
 
 			# Converts a number to binary byte units and outputs with the IEC prefix
@@ -47,12 +90,33 @@ module LinuxStat
 			#
 			# => "1.0 gibibyte"
 			def convert_binary(n, precision: 2)
-				@@b_units ||= %W(#{''} kibi mebi gibi tebi pebi exbi zebi)
-					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
-				unit = @@b_units.find { |x| n < x[1] } || ['yobi'.freeze, 10 ** 27]
-
-				converted = n.fdiv(unit[1] / 1024).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+				if n < KIBI
+					"#{"%.#{precision}f" % n} byte#{?s.freeze if n != 1}"
+				elsif n < MEBI
+					n /= KIBI
+					"#{"%.#{precision}f" % n} kibibyte#{?s.freeze if n != 1}"
+				elsif n < GIBI
+					n /= MEBI
+					"#{"%.#{precision}f" % n} mebibyte#{?s.freeze if n != 1}"
+				elsif n < TEBI
+					n /= GIBI
+					"#{"%.#{precision}f" % n} gibibyte#{?s.freeze if n != 1}"
+				elsif n < PEBI
+					n /= TEBI
+					"#{"%.#{precision}f" % n} tebibyte#{?s.freeze if n != 1}"
+				elsif n < EXBI
+					n /= PEBI
+					"#{"%.#{precision}f" % n} pebibyte#{?s.freeze if n != 1}"
+				elsif n < ZEBI
+					n /= EXBI
+					"#{"%.#{precision}f" % n} exbiyte#{?s.freeze if n != 1}"
+				elsif n < YOBI
+					n /= ZEBI
+					"#{"%.#{precision}f" % n} zebibyte#{?s.freeze if n != 1}"
+				else
+					n /= YOBI
+					"#{"%.#{precision}f" % n} yobibyte#{?s.freeze if n != 1}"
+				end
 			end
 
 			# Converts a number to decimal byte units
@@ -70,12 +134,33 @@ module LinuxStat
 			#
 			# => "1.07 GB"
 			def convert_short_decimal(n, precision: 2)
-				@@sd_units ||= %W(#{''} k M G T P E Z)
-					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
-				unit = @@sd_units.find { |x| n < x[1] } || [?Y.freeze, 10 ** 27]
-
-				converted = n.fdiv(unit[1] / 1000).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}B"
+				if n < KILO
+					"#{"%.#{precision}f" % n} B"
+				elsif n < MEGA
+					n /= KILO
+					"#{"%.#{precision}f" % n} kB"
+				elsif n < GIGA
+					n /= MEGA
+					"#{"%.#{precision}f" % n} MB"
+				elsif n < TERA
+					n /= GIGA
+					"#{"%.#{precision}f" % n} GB"
+				elsif n < PETA
+					n /= TERA
+					"#{"%.#{precision}f" % n} TB"
+				elsif n < EXA
+					n /= PETA
+					"#{"%.#{precision}f" % n} PB"
+				elsif n < ZETTA
+					n /= EXA
+					"#{"%.#{precision}f" % n} EB"
+				elsif n < YOTTA
+					n /= ZETTA
+					"#{"%.#{precision}f" % n} ZB"
+				else
+					n /= YOTTA
+					"#{"%.#{precision}f" % n} YB"
+				end
 			end
 
 			##
@@ -95,19 +180,33 @@ module LinuxStat
 			#
 			# => "1.0 GiB"
 			def convert_short_binary(n, precision: 2)
-				return "#{pad_left(n, precision)} B" if n < 1024
-
-				@@sb_units ||= %W(#{''} K M G T P E Z)
-					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
-				unit = @@sb_units.find { |x| n < x[1] } || [?Y.freeze, 1024 ** 9]
-
-				converted = n.fdiv(unit[1] / 1024).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}iB"
-			end
-
-			private
-			def pad_left(n, mantissa_length = 2)
-				sprintf("%.#{mantissa_length}f".freeze, n)
+				if n < KIBI
+					"#{"%.#{precision}f" % n} B"
+				elsif n < MEBI
+					n /= KIBI
+					"#{"%.#{precision}f" % n} KiB"
+				elsif n < GIBI
+					n /= MEBI
+					"#{"%.#{precision}f" % n} MiB"
+				elsif n < TEBI
+					n /= GIBI
+					"#{"%.#{precision}f" % n} GiB"
+				elsif n < PEBI
+					n /= TEBI
+					"#{"%.#{precision}f" % n} TiB"
+				elsif n < EXBI
+					n /= PEBI
+					"#{"%.#{precision}f" % n} PiB"
+				elsif n < ZEBI
+					n /= EXBI
+					"#{"%.#{precision}f" % n} EiB"
+				elsif n < YOBI
+					n /= ZEBI
+					"#{"%.#{precision}f" % n} ZiB"
+				else
+					n /= YOBI
+					"#{"%.#{precision}f" % n} YiB"
+				end
 			end
 		end
 	end

data/lib/linux_stat/process.rb

@@ -1,25 +1,15 @@
 module LinuxStat
 	# Shows various information about a process that is either
 	# running, sleeping, idle or a zombie.
-
 	module Process
 		class << self
 			##
 			# Returns the list of processes from /proc/.
+			# The output doesn't guarantee a sorted list, in fact it's shuffled most of the time.
 			#
 			# The return type is an Array of Integers.
 			def list
-				d = Dir['/proc/*'.freeze]
-				ret, i = [], -1
-				count = d.length
-
-				while(i += 1) < count
-					pid = File.split(d[i])[1]
-					pid_i = pid.to_i
-					ret << pid_i if pid_i.to_s == pid
-				end
-
-				ret
+				LinuxStat::ProcFS.list_process
 			end
 
 			##
@@ -27,7 +17,7 @@ module LinuxStat
 			#
 			# The return type is Integer.
 			def count
-				list.length
+				LinuxStat::ProcFS.list_process.length
 			end
 
 			##
@@ -36,7 +26,7 @@ module LinuxStat
 			def names
 				h, i = {}, -1
 
-				l = list
+				l = LinuxStat::ProcFS.list_process
 				count = l.length
 
 				while(i += 1) < count
@@ -57,7 +47,7 @@ module LinuxStat
 			def cmdlines
 				h, i = {}, -1
 
-				l = list
+				l = LinuxStat::ProcFS.list_process
 				count = l.length
 
 				while(i += 1) < count
@@ -66,7 +56,7 @@ module LinuxStat
 					begin
 						cmdlines = IO.read("/proc/#{x}/cmdline").strip
 						cmdlines.gsub!(?\u0000.freeze, ?\s.freeze)
-						h.merge!( x => cmdlines)
+						h.merge!(x => cmdlines)
 					rescue StandardError
 					end
 				end
@@ -78,7 +68,7 @@ module LinuxStat
 			def types
 				h, i = {}, -1
 
-				l = list
+				l = LinuxStat::ProcFS.list_process
 				count = l.length
 
 				while(i += 1) < count
@@ -109,7 +99,7 @@ module LinuxStat
 			# Returns all the id of processes that are sleeping.
 			# The return type is an Array of Integers.
 			def sleeping
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?S.freeze
 				}
 			end
@@ -118,7 +108,7 @@ module LinuxStat
 			# Returns all the id of processes that are idle.
 			# The return type is an Array of Integers.
 			def idle
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?I.freeze
 				}
 			end
@@ -127,7 +117,7 @@ module LinuxStat
 			# Returns all the id of processes that are zombies.
 			# The return type is an Array of Integers.
 			def zombie
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?Z.freeze
 				}
 			end
@@ -136,7 +126,7 @@ module LinuxStat
 			# Returns all the id of processes that are running.
 			# The return type is an Array of Integers.
 			def running
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?R.freeze
 				}
 			end
@@ -145,7 +135,7 @@ module LinuxStat
 			# Returns all the id of processes that are stopped.
 			# The return type is an Array of Integers.
 			def stopped
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					v = LinuxStat::ProcFS.ps_state(x)
 					v == ?T.freeze || v == ?t.freeze
 				}

data/lib/linux_stat/process_info.rb

@@ -521,7 +521,9 @@ module LinuxStat
 			def start_time(pid = $$)
 				# Getting two Time objects and dealing with floating point numbers
 				# Just to make sure the time goes monotonically
-				Time.at(start_time_epoch(pid))
+				_ste = start_time_epoch(pid)
+				return nil unless _ste
+				Time.at(_ste)
 			end
 
 			##

data/lib/linux_stat/swap.rb

@@ -22,6 +22,7 @@ module LinuxStat
 			#
 			# If the info isn't available, it will return an empty Hash.
 			def any?
+				return nil unless File.readable?('/proc/swaps'.freeze)
 				!!IO.foreach('/proc/swaps'.freeze).first(2)[1]
 			end
 

data/lib/linux_stat/version.rb

@@ -1,3 +1,3 @@
 module LinuxStat
-	VERSION ||= "2.2.1"
+	VERSION = "2.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linux_stat
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-12 00:00:00.000000000 Z
+date: 2021-08-27 00:00:00.000000000 Z
 dependencies: []
 description: Linux only, efficient linux system utilization reporting and system monitoring
   gem
@@ -31,8 +31,10 @@ files:
 - bin/console
 - bin/setup
 - exe/linuxstat.rb
+- ext/fs_stat/disk_stat.h
 - ext/fs_stat/extconf.rb
 - ext/fs_stat/fs_stat.c
+- ext/fs_stat/sector_size.h
 - ext/nproc/extconf.rb
 - ext/nproc/nproc.c
 - ext/procfs/extconf.rb
@@ -85,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.7
+rubygems_version: 3.2.21
 signing_key:
 specification_version: 4
 summary: Efficient linux system reporting gem