ffi-libfuse 0.3.4 → 0.4.1

data/lib/ffi/devt.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'ffi'
-
 module FFI
   # Calculate major/minor device numbers for use with mknod etc..
   # @see makedev(3)
@@ -15,22 +14,25 @@ module FFI
     #  @param [Integer] major
     #  @param [Integer] minor
     #  @return [Integer] combined major/minor to a single value to pass to mknod etc
-    attach_function :makedev, "#{prefix}makedev".to_sym, %i[int int], :int
+    attach_function :makedev, :"#{prefix}makedev", %i[int int], :int
 
     # @!method major(dev)
     #  @param [Integer] dev
     #  @return [Integer] the major component of dev
-    attach_function :major, "#{prefix}major".to_sym, [:int], :int
+    attach_function :major, :"#{prefix}major", [:int], :int
 
     # @!method minor(dev)
     #  @param [Integer] dev
     #  @return [Integer] the minor component of dev
-    attach_function :minor, "#{prefix}minor".to_sym, [:int], :int
+    attach_function :minor, :"#{prefix}minor", [:int], :int
   rescue FFI::NotFoundError
-    case Platform::NAME
-    when 'x86_64-darwin'
-      # From https://github.com/golang/go/issues/8106 these functions are not defined on Darwin.
-      class << self
+
+    class << self
+      # rubocop:disable Naming/MethodParameterName
+      case RUBY_PLATFORM
+      when 'x86_64-darwin'
+        # From https://github.com/golang/go/issues/8106 these functions are not defined on Darwin.
+
         # define	major(x)	((int32_t)(((u_int32_t)(x) >> 24) & 0xff))
         def major(dev)
           (dev >> 24) & 0xff
@@ -45,9 +47,33 @@ module FFI
         def makedev(major, minor)
           (major << 24) | minor
         end
+
+      when 'x86_64-linux-musl' # eg alpine linux
+        # #define major(x) \
+        # 	((unsigned)( (((x)>>31>>1) & 0xfffff000) | (((x)>>8) & 0x00000fff) ))
+        def major(x)
+          ((x >> 31 >> 1) & 0xfffff000) | ((x >> 8) & 0x00000fff)
+        end
+
+        # #define minor(x) \
+        # 	((unsigned)( (((x)>>12) & 0xffffff00) | ((x) & 0x000000ff) ))
+        #
+        def minor(x)
+          ((x >> 12) & 0xffffff00) | (x & 0x000000ff)
+        end
+
+        # #define makedev(x,y) ( \
+        #         (((x)&0xfffff000ULL) << 32) | \
+        # 	(((x)&0x00000fffULL) << 8) | \
+        #         (((y)&0xffffff00ULL) << 12) | \
+        # 	(((y)&0x000000ffULL)) )
+        def makedev(x, y)
+          ((x & 0xfffff000) << 32) | ((x & 0x00000fff) << 8) | ((y & 0xffffff00) << 12) | (y & 0x000000ff)
+        end
+      else
+        raise
       end
-    else
-      raise
+      # rubocop:enable Naming/MethodParameterName
     end
   end
 end

data/lib/ffi/flock.rb

@@ -18,32 +18,36 @@ module FFI
 
     include(Accessors)
 
-    layout(l_type: Enums::LockType, l_whence: Enums::SeekWhenceShort, l_start: :off_t, l_len: :off_t, l_pid: :pid_t)
-
-    l_members = members.grep(/^l_/).map { |m| m[2..].to_sym }
-
-    ffi_attr_reader(*l_members, format: 'l_%s')
-
-    # @!attribute [r] type
-    #   @return [Symbol] lock type, :rdlck, :wrlck, :unlck
-
-    # @!attribute [r] whence
-    #   @return [Symbol] specifies what the offset is relative to, one of :seek_set, :seek_cur or :seek_end
-    #    corresponding to the whence argument to fseek(2) or lseek(2),
-
-    # @!attribute [r] start
-    #  @return [Integer] the offset of the start of the region to which the lock applies, and is given in bytes
-    #   relative to the point specified by #{whence} member.
-
-    # @!attribute [r] len
-    #  @return [Integer] the length of the region to be locked.
-    #
-    #    A value of 0 means the region extends to the end of the file.
-
-    # @!attribute [r] pid
-    #  @return [Integer] the process ID (see Process Creation Concepts) of the process holding the lock.
-    #   It is filled in by calling fcntl with the F_GETLK command, but is ignored when making a lock. If the
-    #   conflicting lock is an open file description lock (see Open File Description Locks), then this field will be
-    #   set to -1.
+    layout(
+      # @!attribute [r] type
+      #   @return [Symbol] lock type, :rdlck, :wrlck, :unlck
+      l_type: Enums::LockType,
+
+      # @!attribute [r] whence
+      #   @return [Symbol] specifies what the offset is relative to, one of :seek_set, :seek_cur or :seek_end
+      #    corresponding to the whence argument to fseek(2) or lseek(2),
+      l_whence: Enums::SeekWhenceShort,
+
+      # @!attribute [r] start
+      #  @return [Integer] the offset of the start of the region to which the lock applies, and is given in bytes
+      #   relative to the point specified by #{whence} member.
+      l_start: :off_t,
+
+      # @!attribute [r] len
+      #  @return [Integer] the length of the region to be locked.
+      #
+      #    A value of 0 means the region extends to the end of the file.
+      l_len: :off_t,
+
+      # @!attribute [r] pid
+      #  @return [Integer] the process ID (see Process Creation Concepts) of the process holding the lock.
+      #   It is filled in by calling fcntl with the F_GETLK command, but is ignored when making a lock. If the
+      #   conflicting lock is an open file description lock (see Open File Description Locks), then this field will be
+      #   set to -1.
+      l_pid: :pid_t
+    )
+
+    # Strip leading 'l_' to make attribute names
+    ffi_attr_reader(**members.to_h { |m| [m[2..].to_sym, m] })
   end
 end

data/lib/ffi/libfuse/adapter/context.rb

@@ -18,7 +18,7 @@ module FFI
           )
           return wrappers unless defined?(super)
 
-          super(*wrappers)
+          super
         end
 
         module_function

data/lib/ffi/libfuse/adapter/debug.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
+require_relative 'safe'
+
 module FFI
   module Libfuse
     module Adapter
       # Debug callbacks
       #
       # When included in a filesystem class, and if debugging is enabled via {Main#fuse_debug}, then installs a wrapper
-      #  via #{FuseCallbacks#fuse_wrappers} to log callbacks via #warn
+      #  via #{FuseCallbacks#fuse_wrappers} to log callbacks.
+      #
+      # Simple format options can be handled by #{debug_config}, or override the **Module Functions** on an including
+      # class for more programmatic control of output.
+      #
+      # @note {Debug} includes {Safe} as it expects to handle (and re-raise) exceptions.
       module Debug
+        include Safe
+
+        # Default format
+        # @see debug_callback
         DEFAULT_FORMAT = "%<p>s %<n>s %<t>s %<m>s(%<a>s)\n\t=> %<r>s"
 
         # @return [Boolean] true if debug is enabled
@@ -26,11 +37,11 @@ module FFI
         def fuse_wrappers(*wrappers)
           conf = { prefix: self.class.name }.merge!(debug_config)
           # validate config for bad formats, strftime etc
-          Debug.debug_format(:test_debug, [], :result, **conf)
-          wrappers << proc { |fm, *args, &b| Debug.debug_callback(fm, *args, **conf, &b) } if debug?
+          debug_format(:test_debug, [], :result, **conf)
+          wrappers << proc { |fm, *args, &b| debug_callback(fm, *args, **conf, &b) } if debug?
           return wrappers unless defined?(super)
 
-          super(*wrappers)
+          super
         end
 
         # @!visibility private
@@ -41,10 +52,11 @@ module FFI
 
         module_function
 
-        # Debug fuse method, args and result
+        # Debug fuse method, args and result of yielding args to the block
+        #
         # @param [Symbol] fuse_method the callback name
         # @param [Array] args callback arguments
-        # @param [Hash<Symbol,String>] options see {debug} for defaults
+        # @param [Hash<Symbol,String>] options see {debug_format} for defaults
         # @option options [String] prefix
         # @option options [String] strftime a date time format
         # @option options [String] format  format string with fields
@@ -55,25 +67,49 @@ module FFI
         #   * %<a>: Comma separate list of arguments
         #   * %<r>: Result of the method call (or any error raised)
         #   * %<p>: The value of prefix option
+        # @raise [SystemCallError]
+        #   expected Errors raised from callbacks are logged with their cause (if any)
+        # @raise [StandardError,ScriptError]
+        #   unexpected Errors raised from callbacks are logged with their backtrace
         def debug_callback(fuse_method, *args, **options)
-          debug(fuse_method, args, yield(*args), **options)
-        rescue SystemCallError => e
-          # expected behaviour
-          debug(fuse_method, args, "#{e.class.name}(errno=#{e.errno}): #{e.message}", **options)
-          raise
+          result = yield(*args)
+          debug(fuse_method, args, result, **options)
+          result
         rescue StandardError, ScriptError => e
-          # unexpected, debug with backtrace
-          debug(fuse_method, args, (["#{e.class.name}: #{e.message}"] + e.backtrace).join("\n\t"), **options)
+          debug(fuse_method, args, error_message(e), **options)
+          debug_error(e)
           raise
         end
 
-        # @!visibility private
+        # @!group Module Functions
+
+        # Logs the callback
         def debug(fuse_method, args, result, **options)
           warn debug_format(fuse_method, args, result, **options)
-          result
         end
 
-        # @!visibility private
+        # @param [Exception] err
+        # @return [String] the detailed error message for err
+        def error_message(err)
+          if err.is_a?(SystemCallError)
+            "#{err.class.name}(errno=#{err.errno}): #{err.message}"
+          else
+            "#{err.class.name}: #{err.message}"
+          end
+        end
+
+        # Log additional information for errors (cause/backtrace etc)
+        # @see debug_callback
+        def debug_error(err)
+          if err.is_a?(SystemCallError)
+            warn "Caused by #{error_message(err.cause)}" if err.cause
+          else
+            warn err.backtrace.join("\n\t")
+          end
+        end
+
+        # @return [String] the formatted debug message
+        # @see debug_callback
         def debug_format(fuse_method, args, result, prefix: 'DEBUG', strftime: '%FT%T%:z', format: DEFAULT_FORMAT)
           format(format,
                  p: prefix,
@@ -83,6 +119,8 @@ module FFI
                  a: args.map(&:to_s).join(','),
                  r: result)
         end
+
+        # @!endgroup
       end
     end
   end

data/lib/ffi/libfuse/adapter/fuse2_compat.rb

@@ -12,27 +12,27 @@ module FFI
           if FUSE_MAJOR_VERSION == 2
             # @!visibility private
             def getattr(path, stat, fuse_file_info = nil)
-              super(path, stat, fuse_file_info)
+              super
             end
 
             def truncate(path, size, fuse_file_info = nil)
-              super(path, size, fuse_file_info)
+              super
             end
 
             def init(fuse_conn_info, fuse_config = nil)
-              super(fuse_conn_info, fuse_config)
+              super
             end
 
             def chown(path, uid, gid, fuse_file_info = nil)
-              super(path, uid, gid, fuse_file_info)
+              super
             end
 
             def chmod(path, mode, fuse_file_info = nil)
-              super(path, mode, fuse_file_info)
+              super
             end
 
-            def utimens(path, atime, mtime, fuse_file_info = nil)
-              super(path, atime, mtime, fuse_file_info)
+            def utimens(path, times, fuse_file_info = nil)
+              super
             end
 
             def readdir(path, buffer, filler, offset, fuse_file_info, fuse_readdir_flag = 0)
@@ -40,49 +40,66 @@ module FFI
               super(path, buffer, f3_fill, offset, fuse_file_info, fuse_readdir_flag)
             end
 
-            def fgetattr(path, stat, ffi)
-              stat.clear # For some reason (at least on OSX) the stat is not clear when this is called.
-              getattr(path, stat, ffi)
-              0
-            end
+            def fuse_respond_to?(fuse_method)
+              # getdir is never supported here anyway
+              # fgetattr and ftruncate already fallback to the respective basic method
+              return false if %i[getdir fgetattr ftruncate].include?(fuse_method)
 
-            def ftruncate(*args)
-              truncate(*args)
+              super
             end
 
-            def fuse_respond_to?(fuse_method)
-              fuse_method = fuse_method[1..].to_sym if %i[fgetattr ftruncate].include?(fuse_method)
-              super(fuse_method)
+            def fuse_options(args)
+              super if defined?(super)
+              return unless respond_to?(:init_fuse_config)
+
+              FUSE_CONFIG_ONLY_ATTRIBUTES.each do |opt|
+                args.add("-o#{opt}") if fuse_config.send(opt)
+              end
             end
 
             def fuse_flags
               res = defined?(super) ? super : []
-              if respond_to?(:init_fuse_config)
-                fuse_config = FuseConfig.new
-                init_fuse_config(fuse_config, :fuse2)
-                res << :nullpath_ok if fuse_config.nullpath_ok?
-              end
+              return res unless respond_to?(:init_fuse_config)
 
+              FUSE_CONFIG_FLAGS.each { |opt| res << opt if fuse_config.send(opt) }
               res
             end
 
+            private
+
+            def fuse_config
+              @fuse_config ||= begin
+                fuse_config = FuseConfig.new
+                init_fuse_config(fuse_config, :fuse2) if respond_to?(:init_fuse_config)
+                fuse_config
+              end
+            end
+
           else
             def init(*args)
-              init_fuse_config(args.detect { |a| a.is_a?(FuseConfig) }) if respond_to?(:init_fuse_config)
+              init_fuse_config(args.detect { |a| a.is_a?(FuseConfig) }, :fuse3) if respond_to?(:init_fuse_config)
               super if defined?(super)
             end
           end
         end
 
+        # Attributes in Fuse3 config that cannot be set by Fuse3 options. If set via {init_fuse_config} the
+        # equivalent options will be force set under Fuse 2
+        FUSE_CONFIG_ONLY_ATTRIBUTES = %i[hard_remove use_ino readdir_ino direct_io].freeze
+
+        # Attributes in Fuse3 config that were {FuseOperations#fuse_flags} in Fuse2. If set via {init_fuse_config} the
+        # equivalent flags will be added
+        FUSE_CONFIG_FLAGS = %i[nullpath_ok].freeze
+
         # @!visibility private
         def self.included(mod)
-          mod.prepend(Prepend)
+          mod.prepend(Prepend) if FUSE_MAJOR_VERSION < 3
         end
 
         # @!method init_fuse_config(fuse_config,compat)
         # @abstract
-        # Define this method to configure the fuse config object so that under Fuse2 the config options
-        # can be converted to appropriate flags.
+        # Define this method to configure the {FuseConfig} object so that under Fuse2 the config options
+        # can be converted to appropriate flags or options
         #
         # @param [FuseConfig] fuse_config the fuse config object
         # @param [Symbol] compat either :fuse2 or :fuse3

data/lib/ffi/libfuse/adapter/fuse3_support.rb

@@ -24,24 +24,24 @@ module FFI
             fi = args.pop
             return fgetattr(*args, fi) if fi && fuse_super_respond_to?(:fgetattr)
 
-            super(*args)
+            super
           end
 
           def truncate(*args)
             fi = args.pop
             return ftruncate(*args, fi) if fi && fuse_super_respond_to?(:ftruncate)
 
-            super(*args)
+            super
           end
 
           def chown(*args)
             args.pop
-            super(*args)
+            super
           end
 
           def chmod(*args)
             args.pop
-            super(*args)
+            super
           end
 
           # TODO: Fuse3 deprecated flag utime_omit_ok - which meant that UTIME_OMIT and UTIME_NOW are passed through
@@ -50,14 +50,14 @@ module FFI
           #  but there is no way to handle OMIT
           def utimens(*args)
             args.pop
-            super(*args) if defined?(super)
+            super if defined?(super)
           end
 
           def init(*args)
             args.pop
 
             # TODO: populate FuseConfig with output from fuse_flags/FuseConnInfo where appropriate
-            super(*args)
+            super
           end
 
           def readdir(*args, &block)
@@ -71,7 +71,7 @@ module FFI
               proc { |buf, name, stat, off| a.call(buf, name, stat, off, 0) }
             end
 
-            super(*args, &block)
+            super
           end
 
           def fuse_respond_to(fuse_callback)
@@ -81,7 +81,6 @@ module FFI
 
         # @!visibility private
         def self.included(mod)
-          # We prepend our shim module so caller doesn't have to call super
           mod.prepend(Prepend) if FUSE_MAJOR_VERSION > 2
         end
       end

data/lib/ffi/libfuse/adapter/interrupt.rb

@@ -20,7 +20,7 @@ module FFI
           }
           return wrappers unless defined?(super)
 
-          super(*wrappers)
+          super
         end
 
         module_function

data/lib/ffi/libfuse/adapter/pathname.rb

@@ -15,7 +15,7 @@ module FFI
           }
           return wrappers unless defined?(super)
 
-          super(*wrappers)
+          super
         end
       end
     end