sys-filesystem 1.4.3 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b00e624e22bd699630d63b34f90be7758f82630a069f7db2a61e2139cb55888
-  data.tar.gz: 59add440f0203bade0430b2acd410e785b4ab0de416f272755a72db9276aa767
+  metadata.gz: e69ef4806a64a956dfd3b1eb629a17654d7b14a5a8ed8468113f8ee045287682
+  data.tar.gz: 54182b67d58e77fc0c4b0dc8c96aa7ab64f5c7759943e966abd77d1ba212bfb8
 SHA512:
-  metadata.gz: eb24f3c965a15d090fd7fff5800cc4c1829a7ddc7f2cbc4e943bb7e57ae92749a6abfccfecd94e8522287e9700916fc22f57af164afa413459321fa9460ba9a3
-  data.tar.gz: d5d30e84e01f370ac62b77251f2c80c07964a99bebfa0cc30252237bc33830198d3a065c28a546c230327b1b951d45d95bc309f75276d17d7e1e8968ade216f2
+  metadata.gz: 496090ea1ac8ef0b3d3fe55489b3e3f7eeb39f0406135ebdc3dfc650c0ea16c2e010a8eafb8ffb47e837b4be79217311c1d0e7cd71bb0c3ee81d189a8b7e54ca
+  data.tar.gz: fa6242583cf58ea04fa2fc2581030fcc53e62c7871852ffd3105caa8e363685b1521a056ee0a292327a75c497720dd934c23bd7d58d9687157c8265eeac64833

data/CHANGES.md

@@ -1,3 +1,17 @@
+## 1.5.0 - 8-Jun-2024
+* Add support for DragonFlyBSD.
+* Remove Solaris support. It's dead, Jim.
+* Now assumes umount2 function is present on Linux systems, and some
+  corresponding refactoring of the umount method.
+
+## 1.4.5 - 22-May-2024
+* Handle the possibility that a statvs64 alias may not exist on some Linux
+  platforms. Thanks go to Antoine Martin for the report.
+
+## 1.4.4 - 12-Sep-2023
+* Yet another fix for 32-bit vs 64-bit linux, specifically for the Statvfs
+  struct. Thanks go to Josh Cooper for the spot and the patch.
+
 ## 1.4.3 - 20-Oct-2021
 * Another fix for 32-bit vs 64-bit Linux since it was realized we cannot always
   rely on the host architecture information. Handling for JRuby was improved

data/README.md

@@ -78,7 +78,7 @@ Apache-2.0
 
 ## Copyright
 
-(C) 2003-2020 Daniel J. Berger
+(C) 2003-2024 Daniel J. Berger
 All Rights Reserved
 
 ## Warranty

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rake'
 require 'rake/clean'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 CLEAN.include('**/*.gem', '**/*.rbc', '**/*.rbx', '**/*.lock')
 
@@ -25,6 +26,18 @@ task :example do
   sh "ruby -Ilib -Ilib/unix -Ilib/windows examples/example_stat.rb"
 end
 
+RuboCop::RakeTask.new
+
+namespace :rubocop do
+  RuboCop::RakeTask.new(:unix) do |task|
+    task.patterns = ['lib/sys/unix/sys/**/*.rb', 'spec/*unix*']
+  end
+
+  RuboCop::RakeTask.new(:windows) do |task|
+    task.patterns = ['lib/sys/windows/sys/**/*.rb', 'spec/*windows*']
+  end
+end
+
 desc "Run the test suite"
 RSpec::Core::RakeTask.new(:spec)
 

data/lib/sys/filesystem.rb

@@ -1,9 +1,4 @@
-module Sys
-  class Filesystem
-    # The version of the sys-filesystem library
-    VERSION = '1.4.3'.freeze
-  end
-end
+# frozen_string_literal: true
 
 require 'rbconfig'
 
@@ -13,10 +8,18 @@ else
   require_relative 'unix/sys/filesystem'
 end
 
-# Methods universal to all platforms
+# Methods and properties universal to all platforms
 
+# The Sys module serves as a namespace only.
 module Sys
+  # The Filesystem class serves as an abstract base class. Its methods
+  # return objects of other types. Do not instantiate.
   class Filesystem
+    # The version of the sys-filesystem library
+    VERSION = '1.5.0'
+
+    # Stat objects are returned by the Sys::Filesystem.stat method. Here
+    # we're adding universal methods.
     class Stat
       # Returns true if the filesystem is case sensitive for the current path.
       # Typically this will be any path on MS Windows or Macs using HFS.
@@ -26,14 +29,12 @@ module Sys
       # general rule, I do not recommend using this method for a root path.
       #
       def case_insensitive?
-        if path !~ /\w+/
-          if RbConfig::CONFIG['host_os'] =~ /darwin|mac|windows|mswin|mingw/i
-            true # Assumes HFS
-          else
-            false
-          end
-        else
+        if path =~ /\w+/
           File.identical?(path, path.swapcase)
+        elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac|windows|mswin|mingw/i
+          true # Assumes HFS/APFS on Mac
+        else
+          false
         end
       end
 
@@ -46,8 +47,8 @@ module Sys
   end
 end
 
-# Some convenient methods for converting bytes to kb, mb, and gb.
-#
+# Reopen the Numeric class and add some convenient methods
+# for converting bytes to kb, mb, and gb.
 class Numeric
   # call-seq:
   #  <tt>num</tt>.to_kb

data/lib/sys/unix/sys/filesystem/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sys
   class Filesystem
     module Constants
@@ -23,6 +25,8 @@ module Sys
       MNT_DEFWRITE    = 0x02000000 # filesystem should defer writes
       MNT_MULTILABEL  = 0x04000000 # MAC support for individual labels
       MNT_NOATIME     = 0x10000000 # disable update of file access time
+      MNT_NOCLUSTERR  = 0x40000000 # disable cluster read
+      MNT_NOCLUSTERW  = 0x80000000 # disable cluster write
 
       MNT_VISFLAGMASK = (
         MNT_RDONLY | MNT_SYNCHRONOUS | MNT_NOEXEC |

data/lib/sys/unix/sys/filesystem/functions.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'ffi'
 
 module Sys
   class Filesystem
+    # A scoped module for internal FFI functions to be used by the main code.
     module Functions
       extend FFI::Library
 
@@ -9,7 +12,8 @@ module Sys
 
       def self.linux64?
         if RUBY_PLATFORM == 'java'
-          ENV_JAVA['sun.arch.data.model'].to_i == 64
+          RbConfig::CONFIG['host_os'] =~ /linux/i &&
+            ENV_JAVA['sun.arch.data.model'].to_i == 64
         else
           RbConfig::CONFIG['host_os'] =~ /linux/i &&
             (RbConfig::CONFIG['arch'] =~ /64/ || RbConfig::CONFIG['DEFS'] =~ /64/)
@@ -18,10 +22,12 @@ module Sys
 
       private_class_method :linux64?
 
-      if RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
-        attach_function(:statvfs, :statvfs64, %i[string pointer], :int)
-      elsif linux64?
-        attach_function(:statvfs, :statvfs64, %i[string pointer], :int)
+      if linux64?
+        begin
+          attach_function(:statvfs, :statvfs64, %i[string pointer], :int)
+        rescue FFI::NotFoundError # Not every Linux distro has an alias
+          attach_function(:statvfs, %i[string pointer], :int)
+        end
       else
         attach_function(:statvfs, %i[string pointer], :int)
       end
@@ -29,29 +35,19 @@ module Sys
       attach_function(:strerror, [:int], :string)
       attach_function(:mount_c, :mount, %i[string string string ulong string], :int)
 
-      begin
-        attach_function(:umount_c, :umount, [:string], :int)
-      rescue FFI::NotFoundError
-        if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach|bsd/i
-          attach_function(:umount_c, :unmount, [:string], :int)
-        end
+      if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach|bsd|dragonfly/i
+        attach_function(:umount_c, :unmount, %i[string int], :int)
+      else
+        attach_function(:umount_c, :umount2, %i[string int], :int)
       end
 
       private_class_method :statvfs, :strerror, :mount_c, :umount_c
 
       begin
-        if RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
-          attach_function(:fopen, %i[string string], :pointer)
-          attach_function(:fclose, [:pointer], :int)
-          attach_function(:getmntent, %i[pointer pointer], :int)
-          private_class_method :fopen, :fclose, :getmntent
-        else
-          attach_function(:getmntent, [:pointer], :pointer)
-          attach_function(:setmntent, %i[string string], :pointer)
-          attach_function(:endmntent, [:pointer], :int)
-          attach_function(:umount2, %i[string int], :int)
-          private_class_method :getmntent, :setmntent, :endmntent, :umount2
-        end
+        attach_function(:getmntent, [:pointer], :pointer)
+        attach_function(:setmntent, %i[string string], :pointer)
+        attach_function(:endmntent, [:pointer], :int)
+        private_class_method :getmntent, :setmntent, :endmntent
       rescue FFI::NotFoundError
         if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach/i
           begin

data/lib/sys/unix/sys/filesystem/structs.rb

@@ -1,11 +1,28 @@
+# frozen_string_literal: true
+
 require 'ffi'
 require 'rbconfig'
 
 module Sys
   class Filesystem
     module Structs
-      class Statfs < FFI::Struct
+      # Used by DragonFlyBSD
+      class UUID < FFI::Struct
+        UUID_NODE_LEN = 6
+
+        layout(
+          :time_low, :uint32,
+          :time_mid, :uint16,
+          :time_hi_and_version, :uint16,
+          :clock_seq_hi_and_reserved, :uint8,
+          :clock_seq_low, :uint8,
+          :node, [:uint8, UUID_NODE_LEN]
+        )
+      end
 
+      # The Statfs struct is a subclass of FFI::Struct that corresponds to a struct statfs.
+      class Statfs < FFI::Struct
+        # Private method that will determine the layout of the struct on Linux.
         def self.linux64?
           if RUBY_PLATFORM == 'java'
             ENV_JAVA['sun.arch.data.model'].to_i == 64
@@ -20,92 +37,128 @@ module Sys
         # FreeBSD 12.0 MNAMELEN from 88 => 1024.
         MNAMELEN =
           if RbConfig::CONFIG['host_os'] =~ /freebsd(.*)/i
-            $1.to_f < 12.0 ? 88 : 1024
+            Regexp.last_match(1).to_f < 12.0 ? 88 : 1024
           else
             88
           end
 
-        if RbConfig::CONFIG['host_os'] =~ /bsd/i
-          layout(
-            :f_version, :uint32,
-            :f_type, :uint32,
-            :f_flags, :uint64,
-            :f_bsize, :uint64,
-            :f_iosize, :int64,
-            :f_blocks, :uint64,
-            :f_bfree, :uint64,
-            :f_bavail, :int64,
-            :f_files, :uint64,
-            :f_ffree, :uint64,
-            :f_syncwrites, :uint64,
-            :f_asyncwrites, :uint64,
-            :f_syncreads, :uint64,
-            :f_asyncreads, :uint64,
-            :f_spare, [:uint64, 10],
-            :f_namemax, :uint32,
-            :f_owner, :int32,
-            :f_fsid,  [:int32, 2],
-            :f_charspare, [:char, 80],
-            :f_fstypename, [:char, 16],
-            :f_mntfromname, [:char, MNAMELEN],
-            :f_mntonname, [:char, MNAMELEN]
-          )
-        elsif RbConfig::CONFIG['host_os'] =~ /linux/i
-          if linux64?
+        case RbConfig::CONFIG['host_os']
+          when /bsd/i
             layout(
-              :f_type, :ulong,
-              :f_bsize, :ulong,
+              :f_version, :uint32,
+              :f_type, :uint32,
+              :f_flags, :uint64,
+              :f_bsize, :uint64,
+              :f_iosize, :int64,
               :f_blocks, :uint64,
               :f_bfree, :uint64,
-              :f_bavail, :uint64,
+              :f_bavail, :int64,
               :f_files, :uint64,
               :f_ffree, :uint64,
-              :f_fsid, [:int, 2],
-              :f_namelen, :ulong,
-              :f_frsize, :ulong,
-              :f_flags, :ulong,
-              :f_spare, [:ulong, 4]
+              :f_syncwrites, :uint64,
+              :f_asyncwrites, :uint64,
+              :f_syncreads, :uint64,
+              :f_asyncreads, :uint64,
+              :f_spare, [:uint64, 10],
+              :f_namemax, :uint32,
+              :f_owner, :int32,
+              :f_fsid,  [:int32, 2],
+              :f_charspare, [:char, 80],
+              :f_fstypename, [:char, 16],
+              :f_mntfromname, [:char, MNAMELEN],
+              :f_mntonname, [:char, MNAMELEN]
+            )
+          when /linux/i
+            if linux64?
+              layout(
+                :f_type, :ulong,
+                :f_bsize, :ulong,
+                :f_blocks, :uint64,
+                :f_bfree, :uint64,
+                :f_bavail, :uint64,
+                :f_files, :uint64,
+                :f_ffree, :uint64,
+                :f_fsid, [:int, 2],
+                :f_namelen, :ulong,
+                :f_frsize, :ulong,
+                :f_flags, :ulong,
+                :f_spare, [:ulong, 4]
+              )
+            else
+              layout(
+                :f_type, :ulong,
+                :f_bsize, :ulong,
+                :f_blocks, :uint32,
+                :f_bfree, :uint32,
+                :f_bavail, :uint32,
+                :f_files, :uint32,
+                :f_ffree, :uint32,
+                :f_fsid, [:int, 2],
+                :f_namelen, :ulong,
+                :f_frsize, :ulong,
+                :f_flags, :ulong,
+                :f_spare, [:ulong, 4]
+              )
+            end
+          when /dragonfly/i
+            layout(
+              :f_spare2, :long,
+              :f_bsize, :long,
+              :f_iosize, :long,
+              :f_blocks, :long,
+              :f_bfree, :long,
+              :f_bavail, :long,
+              :f_files, :long,
+              :f_ffree, :long,
+              :f_fsid, [:int32_t, 2],
+              :f_owner, :uid_t,
+              :f_type, :int,
+              :f_flags, :int,
+              :f_syncwrites, :long,
+              :f_asyncwrites, :long,
+              :f_fstypename, [:char, 16],
+              :f_mntonname, [:char, 80],
+              :f_syncreads, :long,
+              :f_asyncreads, :long,
+              :f_spares1, :short,
+              :f_mntfromname, [:char, 80],
+              :f_spares2, :short,
+              :f_spare, [:long,2]
             )
           else
             layout(
-              :f_type, :ulong,
-              :f_bsize, :ulong,
-              :f_blocks, :uint32,
-              :f_bfree, :uint32,
-              :f_bavail, :uint32,
-              :f_files, :uint32,
-              :f_ffree, :uint32,
-              :f_fsid, [:int, 2],
-              :f_namelen, :ulong,
-              :f_frsize, :ulong,
-              :f_flags, :ulong,
-              :f_spare, [:ulong, 4]
+              :f_bsize, :uint32,
+              :f_iosize, :int32,
+              :f_blocks, :uint64,
+              :f_bfree, :uint64,
+              :f_bavail, :uint64,
+              :f_files, :uint64,
+              :f_ffree, :uint64,
+              :f_fsid, [:int32, 2],
+              :f_owner, :int32,
+              :f_type, :uint32,
+              :f_flags, :uint32,
+              :f_fssubtype, :uint32,
+              :f_fstypename, [:char, 16],
+              :f_mntonname, [:char, 1024],
+              :f_mntfromname, [:char, 1024],
+              :f_reserved, [:uint32, 8]
             )
-          end
-        else
-          layout(
-            :f_bsize, :uint32,
-            :f_iosize, :int32,
-            :f_blocks, :uint64,
-            :f_bfree, :uint64,
-            :f_bavail, :uint64,
-            :f_files, :uint64,
-            :f_ffree, :uint64,
-            :f_fsid, [:int32, 2],
-            :f_owner, :int32,
-            :f_type, :uint32,
-            :f_flags, :uint32,
-            :f_fssubtype, :uint32,
-            :f_fstypename, [:char, 16],
-            :f_mntonname, [:char, 1024],
-            :f_mntfromname, [:char, 1024],
-            :f_reserved, [:uint32, 8]
-          )
         end
       end
 
       # The Statvfs struct represents struct statvfs from sys/statvfs.h.
       class Statvfs < FFI::Struct
+        # Private method that will determine the layout of the struct on Linux.
+        def self.linux64?
+          if RUBY_PLATFORM == 'java'
+            ENV_JAVA['sun.arch.data.model'].to_i == 64
+          else
+            RbConfig::CONFIG['host_os'] =~ /linux/i &&
+              (RbConfig::CONFIG['arch'] =~ /64/ || RbConfig::CONFIG['DEFS'] =~ /64/)
+          end
+        end
+
         if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach/i
           layout(
             :f_bsize, :ulong,
@@ -134,24 +187,29 @@ module Sys
             :f_fsid, :ulong,
             :f_namemax, :ulong
           )
-        elsif RbConfig::CONFIG['host'] =~ /sunos|solaris/i
+        elsif RbConfig::CONFIG['host'] =~ /dragonfly/i
           layout(
             :f_bsize, :ulong,
             :f_frsize, :ulong,
-            :f_blocks, :uint64_t,
-            :f_bfree, :uint64_t,
-            :f_bavail, :uint64_t,
-            :f_files, :uint64_t,
-            :f_ffree, :uint64_t,
-            :f_favail, :uint64_t,
+            :f_blocks, :uint64,
+            :f_bfree, :uint64,
+            :f_bavail, :uint64,
+            :f_files, :uint64,
+            :f_ffree, :uint64,
+            :f_favail, :uint64,
             :f_fsid, :ulong,
-            :f_basetype, [:char, 16],
             :f_flag, :ulong,
             :f_namemax, :ulong,
-            :f_fstr, [:char, 32],
-            :f_filler, [:ulong, 16]
+            :f_owner, :uid_t,
+            :f_type, :uint,
+            :f_syncreads, :uint64,
+            :f_syncwrites, :uint64,
+            :f_asyncreads, :uint64,
+            :f_asyncwrites, :uint64,
+            :f_fsid_uuid, UUID,
+            :f_uid_uuid, UUID
           )
-        elsif RbConfig::CONFIG['host'] =~ /i686/i
+        elsif !linux64?
           layout(
             :f_bsize, :ulong,
             :f_frsize, :ulong,
@@ -185,17 +243,6 @@ module Sys
         end
       end
 
-      # The Mnttab struct represents struct mnnttab from sys/mnttab.h on Solaris.
-      class Mnttab < FFI::Struct
-        layout(
-          :mnt_special, :string,
-          :mnt_mountp, :string,
-          :mnt_fstype, :string,
-          :mnt_mntopts, :string,
-          :mnt_time, :string
-        )
-      end
-
       # The Mntent struct represents struct mntent from sys/mount.h on Unix.
       class Mntent < FFI::Struct
         layout(

data/lib/sys/unix/sys/filesystem.rb

@@ -105,6 +105,27 @@ module Sys
       # The filesystem type, e.g. UFS.
       attr_accessor :base_type
 
+      # The filesystem ID
+      attr_accessor :filesystem_id
+
+      # The filesystem type
+      attr_accessor :filesystem_type
+
+      # The user that mounted the filesystem
+      attr_accessor :owner
+
+      # Count of sync reads since mount
+      attr_accessor :sync_reads
+
+      # Count of sync writes since mount
+      attr_accessor :sync_writes
+
+      # Count of async reads since mount
+      attr_accessor :async_reads
+
+      # Count of async writes since mount
+      attr_accessor :async_writes
+
       alias inodes files
       alias inodes_free files_free
       alias inodes_available files_available
@@ -224,7 +245,7 @@ module Sys
       fs = Statvfs.new
 
       if statvfs(path, fs) < 0
-        raise Error, 'statvfs() function failed: ' + strerror(FFI.errno)
+        raise Error, "statvfs() function failed: #{strerror(FFI.errno)}"
       end
 
       obj = Sys::Filesystem::Stat.new
@@ -250,6 +271,16 @@ module Sys
         obj.base_type = fs[:f_basetype].to_s
       end
 
+      # DragonFlyBSD has additional struct members
+      if RbConfig::CONFIG['host_os'] =~ /dragonfly/i
+        obj.owner = fs[:f_owner]
+        obj.filesystem_type = fs[:f_type]
+        obj.sync_reads= fs[:f_syncreads]
+        obj.async_reads= fs[:f_asyncreads]
+        obj.sync_writes = fs[:f_syncwrites]
+        obj.async_writes = fs[:f_asyncwrites]
+      end
+
       obj.freeze
     end
 
@@ -275,7 +306,7 @@ module Sys
         num = getmntinfo(buf, 2)
 
         if num == 0
-          raise Error, 'getmntinfo() function failed: ' + strerror(FFI.errno)
+          raise Error, "getmntinfo() function failed: #{strerror(FFI.errno)}"
         end
 
         ptr = buf.get_pointer(0)
@@ -325,41 +356,23 @@ module Sys
             raise SystemCallError.new(method_name, FFI.errno)
           end
 
-          if RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
-            mt = Mnttab.new
-            while getmntent(fp, mt) == 0
-              obj = Sys::Filesystem::Mount.new
-              obj.name = mt[:mnt_special].to_s
-              obj.mount_point = mt[:mnt_mountp].to_s
-              obj.mount_type = mt[:mnt_fstype].to_s
-              obj.options = mt[:mnt_mntopts].to_s
-              obj.mount_time = Time.at(Integer(mt[:mnt_time]))
-
-              if block_given?
-                yield obj.freeze
-              else
-                array << obj.freeze
-              end
-            end
-          else
-            while ptr = getmntent(fp)
-              break if ptr.null?
-              mt = Mntent.new(ptr)
-
-              obj = Sys::Filesystem::Mount.new
-              obj.name = mt[:mnt_fsname]
-              obj.mount_point = mt[:mnt_dir]
-              obj.mount_type = mt[:mnt_type]
-              obj.options = mt[:mnt_opts]
-              obj.mount_time = nil
-              obj.dump_frequency = mt[:mnt_freq]
-              obj.pass_number = mt[:mnt_passno]
-
-              if block_given?
-                yield obj.freeze
-              else
-                array << obj.freeze
-              end
+          while ptr = getmntent(fp)
+            break if ptr.null?
+            mt = Mntent.new(ptr)
+
+            obj = Sys::Filesystem::Mount.new
+            obj.name = mt[:mnt_fsname]
+            obj.mount_point = mt[:mnt_dir]
+            obj.mount_type = mt[:mnt_type]
+            obj.options = mt[:mnt_opts]
+            obj.mount_time = nil
+            obj.dump_frequency = mt[:mnt_freq]
+            obj.pass_number = mt[:mnt_passno]
+
+            if block_given?
+              yield obj.freeze
+            else
+              array << obj.freeze
             end
           end
         ensure
@@ -419,29 +432,31 @@ module Sys
     #
     def self.mount(source, target, fstype = 'ext2', flags = 0, data = nil)
       if mount_c(source, target, fstype, flags, data) != 0
-        raise Error, 'mount() function failed: ' + strerror(FFI.errno)
+        raise Error, "mount() function failed: #{strerror(FFI.errno)}"
       end
 
       self
     end
 
     # Removes the attachment of the (topmost) filesystem mounted on target.
-    # Additional flags may be provided for operating systems that support
-    # the umount2 function. Otherwise this argument is ignored.
+    # You may also specify bitwise OR'd +flags+ to control the precise behavior.
+    # The possible flags on Linux are:
     #
-    # Typically requires admin privileges.
+    # * MNT_FORCE  - Abort pending requests, may cause data loss.
+    # * MNT_DETACH - Lazy umount, waits until the mount point is no longer busy.
+    # * MNT_EXPIRE - Mark mount point as expired, but don't actually remove it until
+    #                a second call MNT_EXPIRE call is made.
     #
-    def self.umount(target, flags = nil)
-      if flags && respond_to?(:umount2)
-        function = 'umount2'
-        rv = umount2_c(target, flags)
-      else
-        function = 'umount'
-        rv = umount_c(target)
-      end
-
-      if rv != 0
-        raise Error, "#{function} function failed: " + strerror(FFI.errno)
+    # * UMOUNT_NOFOLLOW - Don't dereference the target if it's a symbolic link.
+    #
+    # Note that BSD platforms may support different flags. Please see the man
+    # pages for details.
+    #
+    # Typically this method requires admin privileges.
+    #
+    def self.umount(target, flags = 0)
+      if umount_c(target, flags) != 0
+        raise Error, "umount function failed: #{strerror(FFI.errno)}"
       end
 
       self