blink_tm 0.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db910772825de89e18bf29aa17905561b275accef99af4ce513f7bdee177b531
-  data.tar.gz: d67946a495717d5fb69c0c8a82b0c3af779a59a1afd1384d2a9e2bc172fd2a34
+  metadata.gz: 941ae55ced42e5243dd9a489783f1b02da24fcd9c29a9cf4e3f310ea26080fbc
+  data.tar.gz: bf0c03acd5b71bddd03e0e717b8c1f12acd824668eb6e2e56948db9f055a9a67
 SHA512:
-  metadata.gz: 13d05ea503502ffacdaec63e656dc23bfb11d4f4190a1be9925989d2278d6444547bd659297d8b1f281b421fd8f67ac8ec7ad2a3e80f10ddd5a551838643adbf
-  data.tar.gz: 4966f3fe0180f4b7b366dadf621a29a8d3712ee2e8a5b60e6219be5df5b2902b857d8562920f674d136fb60ecadaeeec992ebe1fffc4d24e715c5e399d733973
+  metadata.gz: 00543e80f694b6a711f55aeacd7ab7175675273b513af336b3e3307c73a07ea21f9960a41a81bd285cd6023ff35fa2a2979552f0a7725d1580328808989ac2e6
+  data.tar.gz: 03f51e941ee7531fd2dd29500383abe4d0d88af40b25208d2b2d5991fccae3a3b67954e2efa7aa6eacbb5ca1690230037220cde6d66ef3c5281385fc4ef1d8bb

data/exe/blink-tm

@@ -1,19 +1,68 @@
 #!/usr/bin/env ruby
 require 'blink_tm'
 
-# Find Device running Blink Taskmanager
-dev = nil
-retry_count = 0
 
-while(!dev)
-	dev = BlinkTM.find_device
+if ARGV.any?(/^\-(\-version|v)$/)
+	puts "BlinkTM Version #{BlinkTM::BOLD}#{BlinkTM::VERSION}#{BlinkTM::RESET}"
+	exit
+end
+
+written_pid = false
 
-	if dev
-		puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Device discovered successfully. Path: #{dev}#{BlinkTM::RESET}"
-	else
-		puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: No device found. Retrying #{retry_count += 1}#{BlinkTM::RESET}"
-		sleep 0.5
+BlinkTM::log "BlinkTM Version #{BlinkTM::VERSION}"
+if File.exist?(BlinkTM::LOCKFILE)
+	BlinkTM.log 'error', "Lock file #{BlinkTM::LOCKFILE} already exists! If it's not running you might manually delete this to make blinktm work."
+
+	pid = IO.read(BlinkTM::LOCKFILE) if File.readable?(BlinkTM::LOCKFILE)
+	process_name = File.readable?("/proc/#{pid}/cmdline") ? IO.read("/proc/#{pid}/cmdline") : 'unknown'
+	stat = File.readable?("/proc/#{pid}/stat") ? IO.read("/proc/#{pid}/stat") : nil
+	state = stat ? stat.gsub(/\(.+\)/, '').split[1] : 'unknown'
+	friendly_state = case state
+		when ?S then 'Sleeping'
+		when ?I then 'Idle'
+		when ?Z then 'Zombie'
+		when ?R then 'Running'
+		when ?T then 'Stopped'
+		else 'Unknown'
+	end
+
+	BlinkTM.log 'info', <<~EOF
+		Process Details:
+		\t- ID: #{pid}
+		\t- Command: #{File.basename(process_name.gsub(?\u0000, ?\s))}
+		\t- Status: #{friendly_state}
+	EOF
+
+	exit!
+else
+	begin
+		IO.write(BlinkTM::LOCKFILE, $$)
+		written_pid = true
+	rescue Exception
+		puts "Can't write to #{BlinkTM::LOCKFILE}"
+		exit!
 	end
 end
 
-BlinkTM.start(dev)
+retry_count = 0
+
+# Find Device running Blink Taskmanager
+dev = BlinkTM::find_device!
+file = nil
+
+begin
+	BlinkTM.start(dev) { |x| file = x }
+rescue BlinkTM::SyncError
+	sleep 1
+	retry
+rescue Errno::ENOENT, Errno::EIO, BlinkTM::NoDeviceError
+	file &.close
+	sleep 0.125
+	dev = BlinkTM::find_device!
+	retry
+rescue Interrupt, SystemExit, SignalException
+	file &.close
+	File.delete(BlinkTM::LOCKFILE)
+rescue Exception
+	File.delete(BlinkTM::LOCKFILE)
+end

data/ext/baudrate/baudrate.c

@@ -7,7 +7,7 @@ VALUE setBaudRate(volatile VALUE obj, volatile VALUE dev, volatile VALUE speed)
 	char *device = StringValuePtr(dev) ;
 	unsigned int spd = NUM2UINT(speed) ;
 
-	int serial_port = open(device, O_RDWR) ;
+	int serial_port = open(device, O_RDWR | O_NOCTTY) ;
 	struct termios tty ;
 
 	char status = tcgetattr(serial_port, &tty) ;
@@ -22,7 +22,10 @@ VALUE setBaudRate(volatile VALUE obj, volatile VALUE dev, volatile VALUE speed)
 		-isig -icanon -iexten -echo -echoe -echok -echoctl -echoke
 	*/
 
-	if(status != 0) return Qnil ;
+	if(status != 0) {
+		close(serial_port) ;
+		return Qnil ;
+	}
 
 	tty.c_cflag &= ~CSIZE ;
 	tty.c_cflag |= CS8 ;
@@ -46,18 +49,20 @@ VALUE setBaudRate(volatile VALUE obj, volatile VALUE dev, volatile VALUE speed)
 	cfsetospeed(&tty, spd) ;
 	status = tcsetattr(serial_port, TCSANOW, &tty) ;
 
-	if (status == 0) return Qtrue ;
+	close(serial_port) ;
 
+	if (status == 0) return Qtrue ;
 	return Qfalse ;
 }
 
 VALUE getBaudRate(volatile VALUE obj, volatile VALUE dev) {
 	char *device = StringValuePtr(dev) ;
 
-	int serial_port = open(device, O_RDWR) ;
+	int serial_port = open(device, O_RDWR | O_NOCTTY | O_NONBLOCK) ;
 	struct termios tty ;
 
 	char status = tcgetattr(serial_port, &tty) ;
+	close(serial_port) ;
 
 	if(status == 0) {
 		unsigned int in = cfgetispeed(&tty) ;

data/ext/crc32/crc32.c

@@ -0,0 +1,33 @@
+/*
+	Source:
+	https://commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art008
+
+	Note that this obeys the standard and matches with Ruby's Zlib.crc32(...)
+*/
+
+#define CRC32_DIVISOR 0xEDB88320
+#include "ruby.h"
+
+static VALUE getCRC(volatile VALUE obj, volatile VALUE str) {
+	char *input = StringValuePtr(str) ;
+	unsigned char len = strlen(input) ;
+	unsigned long crc = 0xFFFFFFFF ;
+
+	for (unsigned char i = 0 ; i < len ; ++i) {
+		crc ^= input[i] ;
+
+		for (unsigned char k = 8 ; k ; --k) {
+			crc = crc & 1 ? (crc >> 1) ^ CRC32_DIVISOR : crc >> 1 ;
+		}
+	}
+
+	char buffer[11] ;
+	sprintf(buffer, "%lu", crc ^ 0xFFFFFFFF) ;
+
+	return rb_str_new_cstr(buffer) ;
+}
+
+void Init_crc32() {
+	VALUE blinktm = rb_define_module("BlinkTM") ;
+	rb_define_module_function(blinktm, "crc32", getCRC, 1) ;
+}

data/ext/crc32/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'blink_tm/crc32'

data/lib/blink_tm/blink_tm.rb

@@ -1,11 +1,9 @@
-#!/usr/bin/ruby -w
+#!/usr/bin/env ruby
 # Frozen_String_Literal: true
 
 module BlinkTM
 	# Detect device
 	def find_device
-		dev = nil
-
 		Dir.glob('/sys/bus/usb/devices/*').each { |x|
 			v = File.join(x, 'idVendor')
 			vendor = IO.read(v).strip if File.readable?(v)
@@ -14,39 +12,45 @@ module BlinkTM
 			product = IO.read(p).strip if File.readable?(p)
 
 			if vendor == '1a86' && product == '7523'
-				puts "#{BOLD}#{GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: A potential device discovered: #{vendor}:#{product}#{RESET}"
+				log 'warn', "A potential device discovered: #{vendor}:#{product}"
 
 				Dir.glob('/dev/ttyUSB[0-9]*').each { |x|
 					if File.writable?(x)
-						puts "#{BlinkTM::BOLD}#{BlinkTM::BLUE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Changing baudrate to 57600...#{BlinkTM::RESET}"
+						log 'success', "Changing baudrate to 57600..."
 
 						if BlinkTM.set_baudrate(x, BlinkTM::BAUDRATE)
-							puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Successfully Changed baudrate to 57600...#{BlinkTM::RESET}"
+							log 'success', 'Successfully Changed baudrate to 57600...'
 						else
-							puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Cannot change the baudrate#{BlinkTM::RESET}"
+							log 'error', 'Cannot change the baudrate'
 						end
 					else
-						"#{BOLD}#{RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: No permission granted to change Baudrate#{RESET}"
+						log 'error', 'No permission granted to change Baudrate'
 					end
 
 					if File.readable?(x)
 						begin
-							if File.open(x).readpartial(30).to_s.scrub.include?("BTM")
-								puts "#{BOLD}#{ORANGE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Multiple Blink Task "\
-								"Manager Hardware Found! "\
-								"Selecting: #{vendor}:#{product}#{RESET}" if dev
-
-								dev = x
-							end
+							return x if File.open(x).read_nonblock(30).to_s.scrub.include?("BTM")
 						rescue EOFError
-							sleep 0.125
+							sleep 0.05
 							retry
+						rescue Errno::ENOENT, Errno::EIO
 						end
 					end
 				}
 			end
 		}
 
+		nil
+	end
+
+	@@retry_count = 0
+	def find_device!
+		while(!(dev = BlinkTM.find_device))
+			log 'error', "No device found. Retrying #{@@retry_count += 1}"
+			sleep 0.5
+		end
+
+		log 'success', "Device discovered successfully. Path: #{dev}#{BlinkTM::RESET}"
 		dev
 	end
 
@@ -77,7 +81,10 @@ module BlinkTM
 		io_r = io_w = 0
 
 		Thread.new {
-			cpu_u = LS::CPU.total_usage(POLLING).to_f while true
+			while true
+				_cpu_u = LS::CPU.total_usage(POLLING).to_f
+				cpu_u = _cpu_u.nan? ? 0 : _cpu_u.to_i
+			end
 		}
 
 		Thread.new {
@@ -90,106 +97,115 @@ module BlinkTM
 
 		Thread.new {
 			while true
-				io_stat1 = BlinkTM.diskstats(ROOT)
+				io_stat1 = LS::FS.total_io(ROOT)
 				sleep POLLING
-				io_stat2 = BlinkTM.diskstats(ROOT)
+				io_stat2 = LS::FS.total_io(ROOT)
 
 				io_r = io_stat2[0].-(io_stat1[0]).*(SECTORS).fdiv(POLLING)
 				io_w = io_stat2[1].-(io_stat1[1]).*(SECTORS).fdiv(POLLING)
 			end
 		}
 
-		begin
-			raise NoDeviceError unless device
+		prev_crc32 = ''
+		raise NoDeviceError unless device
 
-			in_sync = false
-			fd = IO.sysopen(device, Fcntl::O_RDWR)
-			file = IO.open(fd)
+		in_sync = false
 
-			until in_sync
-				# Clear out any extra zombie bits
-				file.syswrite(?~)
-				# Start the device
-				file.syswrite(?#)
-				file.flush
+		fd = IO.sysopen(
+			device,
+			Fcntl::O_RDWR | Fcntl::O_NOCTTY | Fcntl::O_NONBLOCK | Fcntl::O_TRUNC
+		)
 
-				sleep 0.125
+		file = IO.open(fd)
+		yield file
 
-				begin
-					if file.readpartial(8000).include?(?~)
-						in_sync = true
-						break
-					end
-				rescue EOFError
-					sleep 0.05
-					retry
-				end
+		until in_sync
+			# Clear out any extra zombie bits
+			file.syswrite(?~.freeze)
+			# Start the device
+			file.syswrite(?#.freeze)
+			file.flush
+
+			sleep 0.125
 
+			begin
+				if file.read_nonblock(8000).include?(?~)
+					in_sync = true
+					break
+				end
+			rescue EOFError
 				sleep 0.05
+				retry
 			end
+		end
 
-			puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Device ready!#{BlinkTM::RESET}"
-			refresh = 0
+		sync_error_count = 0
 
-			while true
-				# cpu(01234) memUsed(999993) swapUsed(999992) io_active(0)
-				# netUpload(999991) netDownload(999990)
-				# disktotal(999990) diskused(999990)
+		log 'success', 'Device ready!'
+		file.read
 
-				memstat = LS::Memory.stat
-				mem_u = memstat[:used].to_i.*(1024).*(100).fdiv(memstat[:total].to_i * 1024).round
+		while true
+			# cpu(01234) memUsed(999993) swapUsed(999992) io_active(0)
+			# netUpload(999991) netDownload(999990)
+			# disktotal(999990) diskused(999990)
 
-				swapstat = LS::Swap.stat
-				swap_u = swapstat[:used].to_i.*(1024).*(100).fdiv(swapstat[:total].to_i * 1024).round
+			memstat = LS::Memory.stat
+			mem_u = memstat[:used].to_i.*(1024).*(100).fdiv(memstat[:total].to_i * 1024).round
 
-				# Output has to be exactly this long. If not, blink-taskmanager shows invalid result.
-				# No string is split inside blink-task manager, it just depends on the string length.
-				#
-				# cpu(100) memUsed(100) swapUsed(100)
-				# netDownload(9991) netUpload(9991)
-				# ioWrite(9991) ioRead(9991)
+			swapstat = LS::Swap.stat
+			swap_u = swapstat[:used].to_i.*(1024).*(100).fdiv(swapstat[:total].to_i * 1024).round
 
-				# Debugging string
-				# str = "#{"%03d" % cpu_u} #{"%03d" % mem_u} #{"%03d" % swap_u} "\
-				# "#{convert_bytes(net_u)} #{convert_bytes(net_d)} "\
-				# "#{convert_bytes(io_r)} #{convert_bytes(io_w)}"
+			# Output has to be exactly this long. If not, blink-taskmanager shows invalid result.
+			# No string is split inside blink-task manager, it just depends on the string length.
+			#
+			# cpu(100) memUsed(100) swapUsed(100)
+			# netDownload(9991) netUpload(9991)
+			# ioWrite(9991) ioRead(9991)
 
-				refresh ^= 1
+			# Debugging string
+			str = "#{"%03d" % cpu_u} #{"%03d" % mem_u} #{"%03d" % swap_u} "\
+			"#{convert_bytes(net_u)} #{convert_bytes(net_d)} "\
+			"#{convert_bytes(io_r)} #{convert_bytes(io_w)}"
 
-				str = "!##{cpu_u.nan? ? '000' : "%03d" % cpu_u}#{"%03d" % mem_u}#{"%03d" % swap_u}"\
-				"#{convert_bytes(net_u)}#{convert_bytes(net_d)}"\
-				"#{convert_bytes(io_r)}#{convert_bytes(io_w)}#{refresh}~"
+			str = "!##{"%03d" % cpu_u}#{"%03d" % mem_u}#{"%03d" % swap_u}"\
+			"#{convert_bytes(net_u)}#{convert_bytes(net_d)}"\
+			"#{convert_bytes(io_r)}#{convert_bytes(io_w)}1~"
 
-				# Rescuing from suspend
-				file.syswrite(str)
-				file.flush
+			# Rescuing from suspend
+			file.syswrite(str)
+			file.flush
+			crc32 = file.read.scrub![/\d+/]
 
-				sleep REFRESH
-			end
-		rescue Interrupt, SystemExit, SignalException
-			file &.close
-			exit 0
-		rescue Errno::ENOENT, BlinkTM::NoDeviceError
-			file &.close
-			device = find_device
-
-			unless device
-				puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Error establishing connection. Don't worry if this is a valid device. Retrying...#{BlinkTM::RESET}"
-				sleep 0.1
+			unless crc32 == prev_crc32 || prev_crc32.empty?
+				raise SyncError if sync_error_count > 1
+				sync_error_count += 1
+			else
+				sync_error_count = 0 unless sync_error_count == 0
 			end
 
-			retry
-		rescue BlinkTM::DeviceNotReady
-			file &.close
-			sleep 0.1
-			retry
-		rescue Exception
-			puts $!.full_message
-			file &.close
+			prev_crc32 = BlinkTM.crc32(str[2..-2])
+			sleep REFRESH
+		end
+
+		unless device
+			puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Error establishing connection. Don't worry if this is a valid device. Retrying...#{BlinkTM::RESET}"
 			sleep 0.1
-			retry
 		end
 	end
 
+	def log(type, message = nil)
+		message, type = type, nil if type && !message
+
+		colour = case type
+			when 0, 'fatal', 'error' then BlinkTM::RED
+			when 1, 'warn' then BlinkTM::ORANGE
+			when 2, 'info' then BlinkTM::BLUE
+			when 3, 'success', 'ok' then BlinkTM::GREEN
+			else ''
+		end
+
+		puts "#{BlinkTM::BOLD}#{colour}:: #{Time.now.strftime('%H:%M:%S.%2N')}: #{message}#{BlinkTM::RESET}"
+	end
+
 	extend(self)
 end

data/lib/blink_tm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BlinkTM
-	VERSION = "0.2.0"
+	VERSION = "2.0.0"
 end

data/lib/blink_tm.rb

@@ -1,22 +1,24 @@
 # Frozen_String_Literal: true
 require 'blink_tm/baudrate'
-require 'blink_tm/diskstats'
 require 'linux_stat'
 
+$-v = true
+
 module BlinkTM
 	# Important Constants
-	BAUDRATE = BlinkTM::B57600
+	BAUDRATE = BlinkTM::B38400
 	SCANID = 'BTM'
 
 	# POLLING time, how often should CPU, Net, IO usages should be updated.
 	# Should always be a float.
-	POLLING = 0.375
+	POLLING = 0.250
 
 	# Refresh time, how often the main loop should run
 	REFRESH = 0.5
 
 	# Errors
 	NoDeviceError = Class.new(StandardError)
+	SyncError = Class.new(StandardError)
 	DeviceNotReady = Class.new(StandardError)
 
 	# Units
@@ -32,12 +34,13 @@ module BlinkTM
 	ORANGE = "\e[38;2;245;155;20m"
 	BOLD = "\e[1m"
 	RESET = "\e[0m"
+	LOCKFILE = '/tmp/blinktaskmanager.pid'
 
 	# Other constants
 	ROOT_DEV = ::LinuxStat::Mounts.root
 	ROOT = File.split(ROOT_DEV)[-1]
 
-	SECTORS = get_sector_size(ROOT_DEV)
+	SECTORS = ::LS::Filesystem.sectors(ROOT_DEV)
 
 	abort "#{BOLD}#{RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Can't get root partition#{RESET}" unless ROOT
 	abort "#{BOLD}#{RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Can't get sector size#{RESET}" unless SECTORS
@@ -46,3 +49,4 @@ end
 require 'blink_tm/version'
 require 'fcntl'
 require 'blink_tm/blink_tm'
+require 'blink_tm/crc32'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blink_tm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-29 00:00:00.000000000 Z
+date: 2021-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: linux_stat
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.2
+        version: 2.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.2
+        version: 2.3.0
 description: A controller for Arduino OLED System Monitor, Blink Task Manager
 email:
 - souravgoswami@protonmail.com
@@ -31,15 +31,14 @@ executables:
 - blink-tm
 extensions:
 - ext/baudrate/extconf.rb
-- ext/diskstats/extconf.rb
+- ext/crc32/extconf.rb
 extra_rdoc_files: []
 files:
 - exe/blink-tm
 - ext/baudrate/baudrate.c
 - ext/baudrate/extconf.rb
-- ext/diskstats/diskstats.c
-- ext/diskstats/extconf.rb
-- ext/diskstats/sectors.h
+- ext/crc32/crc32.c
+- ext/crc32/extconf.rb
 - lib/blink_tm.rb
 - lib/blink_tm/blink_tm.rb
 - lib/blink_tm/version.rb
@@ -62,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: A controller for Arduino OLED System Monitor, Blink Task Manager

data/ext/diskstats/diskstats.c

@@ -1,41 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <linux/fs.h>
-
-#include "ruby.h"
-#include "sectors.h"
-
-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() ;
-}
-
-void Init_diskstats() {
-	VALUE blink_tm = rb_define_module("BlinkTM") ;
-	rb_define_module_function(blink_tm, "diskstats", getDiskstats, 1) ;
-	rb_define_module_function(blink_tm, "get_sector_size", getSectorSize, 1) ;
-}

data/ext/diskstats/extconf.rb

@@ -1,2 +0,0 @@
-require 'mkmf'
-create_makefile 'blink_tm/diskstats'

data/ext/diskstats/sectors.h

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