linux_stat 2.5.3 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75ee9aa13037e326a0c04626cd28e0903b06372ce24344ffa38870f98dd6f0dd
-  data.tar.gz: d275807c8a9572fa9faaa1c562102302697f52b6a1cb36907fa71b2576c533b0
+  metadata.gz: f81f89f0e4f50ff1565a5b6dba272c9ac6fab336a4e3c72888355f199fd216e1
+  data.tar.gz: e3d4daabdcacdfa1d54bf899dc5c98b5fc3354ecaee3ead4bfa546462d64cfb2
 SHA512:
-  metadata.gz: 3bd3330e9135cffee27a82fc661462a9c94e421ee5eebe24fb322ad9241e5498bdfd84914fd58dab93481366969f414bf2aa93e9507bb967ca18a462c91fc007
-  data.tar.gz: 686e7f1935fea8cde6ae24624522ef642f41e21304fdae7e758f3249f3b026ea6261a77fca76bbc2f5153d1d8426f9112a1b66f124e7c3d03106c0992ca731aa
+  metadata.gz: 2d8ed40932920cc10ef10a083b2be1d5bad58dfba658f0b14643826e258f4fdc6f5e89aaac1a711e3fbf674feae7d2e9be777608d02c1ab30df4621d56768ee1
+  data.tar.gz: 2fc069a7134118010affd0354aa7bde2615f8183cf7a8b7defd42342084b3f6a7bf0a5e5774e78aa262302b259dc16c542c06f46d1642e8e3376be308343a93e

data/README.md

@@ -147,6 +147,7 @@ So LinuxStat::USB can be replaced with LS::USB for example.
 | [LinuxStat::CPU](https://github.com/Souravgoswami/linux_stat/blob/master/Usages.md#linuxstatcpu) | System's CPU usage and other related information |
 | [LinuxStat::FS](https://github.com/Souravgoswami/linux_stat/blob/master/Usages.md#linuxstatfs) | System's file system related information. It's used by Filesystem module. |
 | [LinuxStat::Filesystem](https://github.com/Souravgoswami/linux_stat/blob/master/Usages.md#linuxstatfilesystem) | System's file system usage and other related information |
+| [LinuxStat::FTW](https://github.com/Souravgoswami/linux_stat/blob/master/Usages.md#linuxstatftw) | File Tree Walk: Walks through a file and gives you data related to it's own and sub files and directories |
 | [LinuxStat::Kernel](https://github.com/Souravgoswami/linux_stat/blob/master/Usages.md#linuxstatkernel) | System's kernel related information |
 | [LinuxStat::Memory](https://github.com/Souravgoswami/linux_stat/blob/master/Usages.md#linuxstatmemory) | System's memory (RAM) usage and other related information |
 | [LinuxStat::Mounts](https://github.com/Souravgoswami/linux_stat/blob/master/Usages.md#linuxstatmounts) | System's mount point related information |

data/exe/linuxstat.rb

@@ -97,6 +97,7 @@ constants = LinuxStat.constants
 # Modules to delete from documentation and testing
 %i(
 	Nproc
+	NFTW
 ).each(&constants.method(:delete))
 
 execute = constants.map(&:downcase).map.with_index { |x, i|

data/ext/fs_stat/disk_stat.h

@@ -1,25 +1,27 @@
-static VALUE getDiskStats (volatile VALUE obj, volatile VALUE path) {
-	FILE *file = fopen("/proc/diskstats", "r") ;
-	if(!file) return rb_ary_new() ;
+static VALUE getDiskStats (VALUE obj, 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) ;
+	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) ;
+	while (fgets(lines, sizeof(lines) - 1, file)) {
+		if (sscanf(lines, "%*s %*s %119s %*s %*s %llu %*s %*s %*s %llu", lines, &read, &write) == 3) {
+			if(strcmp(lines, p) == 0) {
+				fclose(file);
 
-		if(strcmp(lines, p) == 0) {
-			fclose(file) ;
-
-			return rb_ary_new_from_args(
-				2,
-				ULL2NUM(read),
-				ULL2NUM(write)
-			) ;
+				return rb_ary_new_from_args(
+					2,
+					ULL2NUM(read),
+					ULL2NUM(write)
+				);
+			}
+		} else {
+			return rb_ary_new();
 		}
 	}
 
-	fclose(file) ;
-	return rb_ary_new() ;
+	fclose(file);
+	return rb_ary_new();
 }

data/ext/fs_stat/extconf.rb

@@ -9,4 +9,6 @@ unless have_header('sys/statvfs.h') && have_header('sys/ioctl.h') &&
 	abort('Missing header')
 end
 
+$CFLAGS << ' -O3 -march=native -mtune=native'
+
 create_makefile 'linux_stat/fs_stat'

data/ext/fs_stat/fs_stat.c

@@ -8,41 +8,31 @@
 #include "sector_size.h"
 #include "disk_stat.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 VALUE statfs(VALUE obj, VALUE dir) {
+	struct statvfs buf;
+	char *d = StringValuePtr(dir);
+	VALUE hash = rb_hash_new();
 
-static VALUE statfs(volatile VALUE obj, volatile VALUE dir) {
-	struct statvfs buf ;
-	char *d = StringValuePtr(dir) ;
-	VALUE hash = rb_hash_new() ;
+	if(statvfs(d, &buf) < 0) return hash;
 
-	if(statvfs(d, &buf) < 0) return hash ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_size")), INT2FIX((unsigned int)buf.f_bsize));
+	rb_hash_aset(hash, ID2SYM(rb_intern("fragment_size")), ULL2NUM((unsigned long long)buf.f_frsize));
+	rb_hash_aset(hash, ID2SYM(rb_intern("blocks")), ULL2NUM((unsigned long long)buf.f_blocks));
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_free")), ULL2NUM((unsigned long long)buf.f_bfree));
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_avail_unpriv")), ULL2NUM((unsigned long long)buf.f_bavail));
+	rb_hash_aset(hash, ID2SYM(rb_intern("inodes")), ULL2NUM((unsigned long long)buf.f_files));
+	rb_hash_aset(hash, ID2SYM(rb_intern("free_inodes")), ULL2NUM((unsigned long long)buf.f_ffree));
+	rb_hash_aset(hash, ID2SYM(rb_intern("filesystem_id")), ULL2NUM((unsigned long long)buf.f_fsid));
+	rb_hash_aset(hash, ID2SYM(rb_intern("mount_flags")), ULL2NUM((unsigned long long)buf.f_flag));
+	rb_hash_aset(hash, ID2SYM(rb_intern("max_filename_length")), ULL2NUM((unsigned long long)buf.f_namemax));
 
-	rb_hash_aset(hash, ID2SYM(rb_intern("block_size")), INT2FIX((unsigned int)buf.f_bsize)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("fragment_size")), ULL2NUM((unsigned long long)buf.f_frsize)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("blocks")), ULL2NUM((unsigned long long)buf.f_blocks)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("block_free")), ULL2NUM((unsigned long long)buf.f_bfree)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("block_avail_unpriv")), ULL2NUM((unsigned long long)buf.f_bavail)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("inodes")), ULL2NUM((unsigned long long)buf.f_files)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("free_inodes")), ULL2NUM((unsigned long long)buf.f_ffree)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("filesystem_id")), ULL2NUM((unsigned long long)buf.f_fsid)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("mount_flags")), ULL2NUM((unsigned long long)buf.f_flag)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("max_filename_length")), ULL2NUM((unsigned long long)buf.f_namemax)) ;
-
-	return hash ;
+	return hash;
 }
 
 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) ;
+	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

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

data/ext/misc/integer/extconf.rb

@@ -1,2 +1,5 @@
 require 'mkmf'
+
+$CFLAGS << ' -O3 -march=native -mtune=native'
+
 create_makefile 'linux_stat/misc/integer'

data/ext/misc/integer/integer?.c

@@ -12,52 +12,44 @@
 		- It doesn't raise any error. Handing nil is enough to indicate that it failed.
 */
 
-#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
-
 #include <limits.h>
 #include "ruby.h"
 
-VALUE isNumber(volatile VALUE obj, volatile VALUE val) {
-	// But we don't expect anything other than String though as Argument.
-	// Note that raising ArgumentError or any kind of Error shouldn't be done here
-	// Otherwise Integer(n) is the best method in Ruby.
+VALUE isNumber(VALUE obj, VALUE val) {
+	// Expecting a String as input, return Qnil for any other type
 	if (!RB_TYPE_P(val, T_STRING))
-		return Qnil ;
+		return Qnil;
 
-	char *str = StringValuePtr(val) ;
-	char ch = str[0] ;
+	char *str = StringValuePtr(val);
+	size_t len = RSTRING_LEN(val);
 
 	// If the string is empty, return false
-	if (!ch) return Qfalse ;
+	if (len == 0) return Qfalse;
 
-	unsigned char i = ch == '-' ? 1 : 0 ;
-	if (!str[i]) return Qfalse ;
+	size_t i = 0;
+	char ch = str[0];
 
-	unsigned char max = UCHAR_MAX ;
+	// If the string starts with '-', skip it but ensure there are digits after it
+	if (ch == '-') {
+		i = 1;
+		if (i == len) return Qfalse;
+	}
 
-	# pragma GCC unroll 4
-	while((ch = str[i++])) {
-		if (ch < 48 || ch > 57)
-			return Qfalse ;
+	// Iterate through each character to check if it's a digit
+	for (; i < len; i++) {
+		ch = str[i];
 
-		if (i == max)
-			return Qnil ;
+		if (ch < '0' || ch > '9') {
+			return Qfalse;
+		}
 	}
 
-	return Qtrue ;
+	return Qtrue;
 }
 
 void Init_integer() {
-	VALUE linuxStat = rb_define_module("LinuxStat") ;
-	VALUE misc = rb_define_module_under(linuxStat, "Misc") ;
+	VALUE linuxStat = rb_define_module("LinuxStat");
+	VALUE misc = rb_define_module_under(linuxStat, "Misc");
 
-	rb_define_module_function(misc, "integer?", isNumber, 1) ;
+	rb_define_module_function(misc, "integer?", isNumber, 1);
 }

data/ext/nftw/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+
+unless have_const('linux') || RbConfig::CONFIG['arch'].to_s[/linux/]
+	abort('Platform is not linux')
+end
+
+abort('Missing header') unless have_header('ftw.h')
+
+$CFLAGS << ' -O3 -march=native -mtune=native'
+
+create_makefile 'linux_stat/nftw'

data/ext/nftw/nftw.c

@@ -0,0 +1,306 @@
+#define _GNU_SOURCE 1
+
+#include <ftw.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "ruby.h"
+
+VALUE LIST;
+intmax_t TOTAL_FILES;
+
+static int storeInfo(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) {
+	VALUE hash = rb_hash_new();
+
+	// Raw type flag
+		VALUE typeFlag = (tflag == FTW_D)   ? ID2SYM(rb_intern("FTW_D"))   : (tflag == FTW_DNR) ? ID2SYM(rb_intern("FTW_DNR")) :
+										(tflag == FTW_DP)  ? ID2SYM(rb_intern("FTW_DP"))  : (tflag == FTW_F)   ? ID2SYM(rb_intern("FTW_F"))   :
+										(tflag == FTW_NS)  ? ID2SYM(rb_intern("FTW_NS"))  : (tflag == FTW_SL)  ? ID2SYM(rb_intern("FTW_SL"))  :
+										(tflag == FTW_SLN) ? ID2SYM(rb_intern("FTW_SLN")) : Qnil;
+
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("type_flag")),
+		typeFlag
+	);
+
+	// Depth
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("level")),
+		INT2FIX(ftwbuf -> level)
+	);
+
+	// Size
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("st_size")),
+		INT2FIX((intmax_t) sb->st_size)
+	);
+
+	// Path
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("path")),
+		rb_str_new_cstr(fpath)
+	);
+
+	// Basename
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("basename")),
+		rb_str_new_cstr(fpath + ftwbuf->base)
+	);
+
+	rb_ary_push(LIST, hash);
+	return 0;
+}
+
+static int storeFilesInfo(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) {
+	if (!(tflag == FTW_F || tflag == FTW_SL || tflag == FTW_SLN))
+		return 0;
+
+	VALUE hash = rb_hash_new();
+
+	// Raw type flag
+		VALUE typeFlag = (tflag == FTW_F)   ? ID2SYM(rb_intern("FTW_F"))   :
+						(tflag == FTW_SL)  ? ID2SYM(rb_intern("FTW_SL"))  :
+						(tflag == FTW_SLN) ? ID2SYM(rb_intern("FTW_SLN")) : Qnil;
+
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("type_flag")),
+		typeFlag
+	);
+
+	// Depth
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("level")),
+		INT2FIX(ftwbuf -> level)
+	);
+
+	// Size
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("st_size")),
+		INT2FIX((intmax_t) sb->st_size)
+	);
+
+	// Path
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("path")),
+		rb_str_new_cstr(fpath)
+	);
+
+	// Dirname
+	char dirname[ftwbuf->base];
+	*dirname = '\0';
+	strncat(dirname, fpath, ftwbuf->base - 1);
+
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("dirname")),
+		rb_str_new_cstr(dirname)
+	);
+
+	// Basename
+	rb_hash_aset(
+		hash,
+		ID2SYM(rb_intern("basename")),
+		rb_str_new_cstr(fpath + ftwbuf->base)
+	);
+
+	rb_ary_push(LIST, hash);
+	return 0;
+}
+
+static int countChildren(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) {
+	TOTAL_FILES++;
+	return 0;
+}
+
+static int countFiles(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) {
+	if(tflag == FTW_F || tflag == FTW_SL || tflag == FTW_SLN) TOTAL_FILES++;
+	return 0;
+}
+
+static int countDirectories(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) {
+	if(tflag == FTW_D || tflag == FTW_DNR) TOTAL_FILES++;
+	return 0;
+}
+
+VALUE getChildrenCount(VALUE obj, VALUE rb_dir, VALUE rb_flags) {
+	TOTAL_FILES = 0;
+	rb_ary_clear(LIST);
+
+	int flags = FIX2INT(rb_flags);
+	char *dir = StringValuePtr(rb_dir);
+	VALUE returnValue = rb_hash_new();
+
+	if (nftw(dir, countChildren, 20, flags) == -1) {
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("value")), ULL2NUM(TOTAL_FILES));
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("error")), Qtrue);
+	} else {
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("value")), ULL2NUM(TOTAL_FILES));
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("error")), Qfalse);
+	}
+
+	return returnValue;
+}
+
+VALUE getFilesCount(VALUE obj, VALUE rb_dir) {
+	TOTAL_FILES = 0;
+
+	int flags = FTW_PHYS;
+	#ifdef FTW_CONTINUE
+		flags |= FTW_CONTINUE;
+	#endif
+
+	if (nftw(StringValuePtr(rb_dir), countFiles, 20, flags) == -1)
+		return Qnil;
+
+	return ULL2NUM(TOTAL_FILES);
+}
+
+VALUE getDirectoriesCount(VALUE obj, VALUE rb_dir) {
+	TOTAL_FILES = 0;
+
+	int flags = FTW_PHYS;
+	#ifdef FTW_CONTINUE
+		flags |= FTW_CONTINUE;
+	#endif
+
+	if (nftw(StringValuePtr(rb_dir), countDirectories, 20, flags) == -1)
+		return Qnil;
+
+	return ULL2NUM(--TOTAL_FILES);
+}
+
+VALUE getStat(VALUE obj, VALUE rb_dir, VALUE rb_flags) {
+	rb_ary_clear(LIST);
+
+	int flags = FIX2INT(rb_flags);
+	char *dir = StringValuePtr(rb_dir);
+	VALUE returnValue = rb_hash_new();
+
+	if (nftw(dir, storeInfo, 20, flags) == -1) {
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("value")), LIST);
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("error")), Qtrue);
+	} else {
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("value")), LIST);
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("error")), Qfalse);
+	}
+
+	return returnValue;
+}
+
+VALUE getFilesStat(VALUE obj, VALUE rb_dir) {
+	rb_ary_clear(LIST);
+
+	int flags = FTW_PHYS;
+	#ifdef FTW_CONTINUE
+		flags |= FTW_CONTINUE;
+	#endif
+
+	char *dir = StringValuePtr(rb_dir);
+	VALUE returnValue = rb_hash_new();
+
+	if (nftw(dir, storeFilesInfo, 20, flags) == -1) {
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("value")), LIST);
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("error")), Qtrue);
+	} else {
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("value")), LIST);
+		rb_hash_aset(returnValue, ID2SYM(rb_intern("error")), Qfalse);
+	}
+
+	return returnValue;
+}
+
+// Return all flags as hash
+VALUE flags_hash(VALUE nftw) {
+	VALUE all_flags = rb_hash_new();
+	rb_ary_clear(LIST);
+
+	// All Flags
+	VALUE flags = rb_hash_new();
+	#ifdef FTW_ACTIONRETVAL
+		rb_hash_aset(flags, ID2SYM(rb_intern("FTW_ACTIONRETVAL")), INT2FIX(FTW_ACTIONRETVAL));
+	#endif
+
+	rb_hash_aset(flags, ID2SYM(rb_intern("FTW_CHDIR")), INT2FIX(FTW_CHDIR));
+	rb_hash_aset(flags, ID2SYM(rb_intern("FTW_DEPTH")), INT2FIX(FTW_DEPTH));
+	rb_hash_aset(flags, ID2SYM(rb_intern("FTW_MOUNT")), INT2FIX(FTW_MOUNT));
+	rb_hash_aset(flags, ID2SYM(rb_intern("FTW_PHYS")), INT2FIX(FTW_PHYS));
+	rb_hash_aset(all_flags, ID2SYM(rb_intern("flags")), flags);
+
+	// Actionretval Flags
+	#ifdef FTW_ACTIONRETVAL
+		VALUE actionretval_flags = rb_hash_new();
+		rb_hash_aset(actionretval_flags, ID2SYM(rb_intern("FTW_CONTINUE")), INT2FIX(FTW_CONTINUE));
+		rb_hash_aset(actionretval_flags, ID2SYM(rb_intern("FTW_SKIP_SIBLINGS")), INT2FIX(FTW_SKIP_SIBLINGS));
+		rb_hash_aset(actionretval_flags, ID2SYM(rb_intern("FTW_SKIP_SUBTREE")), INT2FIX(FTW_SKIP_SUBTREE));
+		rb_hash_aset(actionretval_flags, ID2SYM(rb_intern("FTW_STOP")), INT2FIX(FTW_STOP));
+		rb_hash_aset(all_flags, ID2SYM(rb_intern("actionretval_flags")), actionretval_flags);
+	#endif
+
+	// Type Flags
+	VALUE type_flags = rb_hash_new();
+	rb_hash_aset(type_flags, ID2SYM(rb_intern("FTW_D")), INT2FIX(FTW_D));
+	rb_hash_aset(type_flags, ID2SYM(rb_intern("FTW_DNR")), INT2FIX(FTW_DNR));
+	rb_hash_aset(type_flags, ID2SYM(rb_intern("FTW_DP")), INT2FIX(FTW_DP));
+	rb_hash_aset(type_flags, ID2SYM(rb_intern("FTW_F")), INT2FIX(FTW_F));
+	rb_hash_aset(type_flags, ID2SYM(rb_intern("FTW_NS")), INT2FIX(FTW_NS));
+	rb_hash_aset(type_flags, ID2SYM(rb_intern("FTW_SL")), INT2FIX(FTW_SL));
+	rb_hash_aset(type_flags, ID2SYM(rb_intern("FTW_SLN")), INT2FIX(FTW_SLN));
+	rb_hash_aset(all_flags, ID2SYM(rb_intern("type_flags")), type_flags);
+
+	return all_flags;
+}
+
+void Init_nftw() {
+	// Initialize globals
+	LIST = rb_ary_new();
+	rb_global_variable(&LIST);
+
+	// Initialize main LinuxStat and NFTW modules
+	VALUE _linux_stat = rb_define_module("LinuxStat");
+	VALUE nftw = rb_define_module_under(_linux_stat, "NFTW");
+
+	// Methods
+	rb_define_module_function(nftw, "stat", getStat, 2);
+	rb_define_module_function(nftw, "stat_files", getFilesStat, 1);
+	rb_define_module_function(nftw, "count_children", getChildrenCount, 2);
+	rb_define_module_function(nftw, "count_files", getFilesCount, 1);
+	rb_define_module_function(nftw, "count_directories", getDirectoriesCount, 1);
+
+	// Constants
+	rb_define_const(nftw, "FLAGS", flags_hash(nftw));
+
+	// Flags
+	#ifdef FTW_ACTIONRETVAL
+		rb_define_const(nftw, "FTW_ACTIONRETVAL", INT2FIX(FTW_ACTIONRETVAL));
+	#endif
+	rb_define_const(nftw, "FTW_CHDIR", INT2FIX(FTW_CHDIR));
+	rb_define_const(nftw, "FTW_DEPTH", INT2FIX(FTW_DEPTH));
+	rb_define_const(nftw, "FTW_MOUNT", INT2FIX(FTW_MOUNT));
+	rb_define_const(nftw, "FTW_PHYS", INT2FIX(FTW_PHYS));
+
+	// ActionRetval flags
+	#ifdef FTW_ACTIONRETVAL
+		rb_define_const(nftw, "FTW_CONTINUE", INT2FIX(FTW_CONTINUE));
+		rb_define_const(nftw, "FTW_SKIP_SIBLINGS", INT2FIX(FTW_SKIP_SIBLINGS));
+		rb_define_const(nftw, "FTW_SKIP_SUBTREE", INT2FIX(FTW_SKIP_SUBTREE));
+		rb_define_const(nftw, "FTW_STOP", INT2FIX(FTW_STOP));
+	#endif
+
+	// typeflags
+	rb_define_const(nftw, "FTW_D", INT2FIX(FTW_D));
+	rb_define_const(nftw, "FTW_DNR", INT2FIX(FTW_DNR));
+	rb_define_const(nftw, "FTW_DP", INT2FIX(FTW_DP));
+	rb_define_const(nftw, "FTW_F", INT2FIX(FTW_F));
+	rb_define_const(nftw, "FTW_NS", INT2FIX(FTW_NS));
+	rb_define_const(nftw, "FTW_SL", INT2FIX(FTW_SL));
+	rb_define_const(nftw, "FTW_SLN", INT2FIX(FTW_SLN));
+}

data/ext/nproc/extconf.rb

@@ -8,4 +8,6 @@ unless have_header('sched.h') && have_header('ruby.h')
 	abort('Missing header')
 end
 
+$CFLAGS << ' -O3 -march=native -mtune=native'
+
 create_makefile 'linux_stat/nproc'

data/ext/nproc/nproc.c

@@ -5,27 +5,19 @@
 #include <sched.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 VALUE count_cpu_for_pid(VALUE obj, VALUE pid) {
+	cpu_set_t set;
+	CPU_ZERO(&set);
+	pid_t pid_int = (pid_t)NUM2LONG(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) ;
+    if (sched_getaffinity(pid_int, sizeof(set), &set) == -1)
+        return Qnil;
 
-	if (status < 0) return Qnil ;
-	return INT2FIX(CPU_COUNT(&set)) ;
+	return INT2FIX(CPU_COUNT(&set));
 }
 
 void Init_nproc() {
-	VALUE _linux_stat = rb_define_module("LinuxStat") ;
-	VALUE _nproc = rb_define_module_under(_linux_stat, "Nproc") ;
-	rb_define_module_function(_nproc, "count_cpu_for_pid", count_cpu_for_pid, 1) ;
+	VALUE _linux_stat = rb_define_module("LinuxStat");
+	VALUE _nproc = rb_define_module_under(_linux_stat, "Nproc");
+	rb_define_module_function(_nproc, "count_cpu_for_pid", count_cpu_for_pid, 1);
 }

data/ext/procfs/extconf.rb

@@ -8,4 +8,6 @@ unless have_header('unistd.h') && have_header('ruby.h')
 	abort('Missing header')
 end
 
+$CFLAGS << ' -O3 -march=native -mtune=native'
+
 create_makefile 'linux_stat/procfs'

data/ext/procfs/loadavg_pid.h

@@ -1,11 +1,11 @@
-static VALUE last_pid(volatile VALUE obj) {
-	FILE *f = fopen("/proc/loadavg", "r") ;
-	if (!f) return Qnil ;
+static 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 ;
+	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) ;
+	return ULL2NUM(_last_pid);
 }