ffi-libfuse 0.3.4 → 0.4.0

data/lib/ffi/libfuse/fuse_buf.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'fuse_version'
+require_relative '../struct_wrapper'
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    bitmask :fuse_buf_flags, [:is_fd, 1, :fd_seek, :fd_retry]
+
+    #
+    # Single io buffer
+    #
+    # Generic io buffer for I/O, extended attributes, etc...Data may be supplied as a memory pointer or as a file
+    #  descriptor
+    #
+    class FuseBuf
+      # @!visibility private
+      # Native FuseBuf layout
+      class Native < FFI::Struct
+        layout(
+          size: :size_t, #  Size of io in bytes
+          flags: FFI::Libfuse.find_type(:fuse_buf_flags), # Buffer flags
+          mem: :pointer, # Memory pointer - used if :is_fd flag is not set
+          fd: :int, # File descriptor - used if :is_fd is set
+          pos: :off_t # File position - used if :fd_seek flag is set.
+        )
+      end
+
+      include StructWrapper
+      native_struct(Native)
+
+      ffi_attr_reader(:mem, :fd, :pos)
+      ffi_attr_accessor(:size)
+
+      # @!attribute [r] mem
+      #   @return [FFI::Pointer] the memory in the buffer
+
+      alias memory mem
+
+      # @!attribute [r] fd
+      #   @return [Integer] the file descriptor number
+
+      alias file_descriptor fd
+
+      # @attribute [rw] size
+      #   @return [Integer] the size of the buffer
+
+      # @return [Boolean] true if this a memory buffer
+      def mem?
+        !fd?
+      end
+
+      # @return [Boolean] true if this is a file descriptor buffer
+      def fd?
+        self[:flags].include?(:is_fd)
+      end
+      alias file_descriptor? fd?
+
+      # @overload fill(str:)
+      #   Create a memory buffer from str
+      #   @param [String,#to_s] str
+      #
+      # @overload fill(size:)
+      #   Allocate an empty memory buffer of size bytes
+      #   @param [Integer] size
+      #
+      # @overload fill(mem:, size: mem.size)
+      #   Set the buffer to contain the previously allocated memory
+      #   @param [FFI::Pointer] mem
+      #   @param [Integer] size <= mem.size
+      #
+      # @overload fill(fd:, fd_retry: false, size:, pos: 0)
+      #   Fill as a FileDescriptor buffer
+      #   @param [Integer] fd File descriptor
+      #   @param [Boolean] fd_retry
+      #     Retry operations on file descriptor
+      #
+      #     If this flag is set then retry operation on file descriptor until size bytes have been copied or an error
+      #     or EOF is detected.
+      #
+      #   @param [Integer] size
+      #     number of bytes to read from fd
+      #   @param [nil, Integer] pos
+      #      If set then used to seek to the given offset before performing operation on file descriptor.
+      # @return [self]
+      def fill(
+        str: nil,
+        mem: str ? FFI::MemoryPointer.from_string(str.to_s) : FFI::Pointer::NULL, size: mem.null? ? 0 : mem.size,
+        fd: -1, fd_retry: false, pos: nil # rubocop:disable Naming/MethodParameterName
+
+      )
+
+        # Allocate size bytes if we've been given a null pointer
+        mem = FFI::MemoryPointer.new(:char, size, true) if fd == -1 && mem.null? && size.positive?
+
+        mem.autorelease = to_ptr.autorelease? unless mem.null?
+
+        self[:size] = size
+        self[:mem] = mem
+        self[:fd] = fd
+        flags = []
+        flags << :is_fd if fd != -1
+        flags << :fd_seek if pos
+        flags << :fd_retry if fd_retry
+        self[:flags] = flags
+        self[:pos] = pos || 0
+        self
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/fuse_buf_vec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require_relative 'fuse_version'
+require_relative 'io'
+require_relative 'fuse_buf'
+require_relative '../accessors'
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    #
+    # Data buffer vector
+    #
+    # An list of io buffers, each containing a memory pointer or a file descriptor.
+    #
+    class FuseBufVec < FFI::Struct
+      include Accessors
+
+      layout(
+        count: :size_t,
+        idx: :size_t,
+        off: :size_t,
+        # buf is treated as a variable length array of FuseBuf at size +1 following the struct.
+        buf: [FuseBuf::Native, 1] # struct fuse_buf[1]
+      )
+
+      ffi_attr_reader(:count, :idx, :off)
+
+      # @!attribute [r] count
+      #   @return [Integer] the number of buffers in the array
+
+      # @!attribute [r] idx
+      #   @return [Integer] index of current buffer within the array
+
+      alias index idx
+
+      # @!attribute [r] off
+      #   @return [Integer] current offset within the current buffer
+
+      alias offset off
+
+      # Create and initialise from a ruby object that quacks like {::File}, {::IO}, or {::String}
+      #
+      # @param [Object] io
+      #
+      #   * Integer file descriptor or File like object that returns one via :fileno
+      #   * Otherwise something to pass to {IO.read}(io, size, offset) to create a memory based buffer
+      #
+      # @param [Integer] size
+      # @param [Integer] offset
+      # @return [FuseBufVec]
+      #
+      # @note The returned object's memory is not auto-released, and thus suitable for use with
+      #   {FuseOperations#read_buf} where the buffers are cleared by libfuse library..
+      def self.create(io, size, offset = nil)
+        fd = io.respond_to?(:fileno) ? io.fileno : io
+        return init(autorelease: false, size: size, fd: fd, pos: offset || 0) if fd.is_a?(Integer)
+
+        init(autorelease: false, str: Libfuse::IO.read(io, size, offset))
+      end
+
+      # Create and initialise a new FuseBufVec
+      #
+      # @param [Boolean] autorelease should the struct be freed on GC
+      #
+      #   Use false only if this object is going to be passed to the C library side. eg. {FuseOperations#read_buf}
+      # @param [Hash<Symbol>] buf_options options for configuring the initial buffer (see {FuseBuf#fill})
+      # @return [FuseBufVec]
+      def self.init(autorelease: true, count: 1, **buf_options)
+        bufvec_ptr = FFI::MemoryPointer.new(:uchar, FuseBufVec.size + (FuseBuf::Native.size * (count - 1)), true)
+        bufvec_ptr.autorelease = autorelease
+        bufvec = new(bufvec_ptr)
+        bufvec[:count] = count
+        bufvec[:idx] = 0
+        bufvec[:off] = 0
+        bufvec.buffers[0].fill(**buf_options) unless buf_options.empty?
+        bufvec
+      end
+
+      # @return [Integer] total size of io in a fuse buffer vector (ie the size of all the fuse buffers)
+      def buf_size
+        Libfuse.fuse_buf_size(self)
+      end
+
+      # Set {index}/{offset} for reading/writing from pos
+      # @param [Integer] pos
+      # @return [self]
+      # @raise [Errno::ERANGE] if seek past end of file
+      def seek(pos)
+        buffers.each_with_index do |b, i|
+          if pos < b.size
+            self[:idx] = i
+            self[:off] = pos
+            return self
+          else
+            pos -= b.size
+          end
+        end
+        raise Errno::ERANGE
+      end
+
+      # Copy data from this set of buffers to another set
+      #
+      # @param [FuseBufVec] dst destination buffers
+      # @param [Array<Symbol>] flags Buffer copy flags
+      #
+      #  - :no_splice
+      #    Don't use splice(2)
+      #
+      #    Always fall back to using read and write instead of splice(2) to copy io from one file descriptor to
+      #    another.
+      #
+      #    If this flag is not set, then only fall back if splice is unavailable.
+      #
+      #  - :force_splice
+      #
+      #    Always use splice(2) to copy io from one file descriptor to another.  If splice is not available, return
+      #    -EINVAL.
+      #
+      #  - :splice_move
+      #
+      #    Try to move io with splice.
+      #
+      #    If splice is used, try to move pages from the source to the destination instead of copying. See
+      #    documentation of SPLICE_F_MOVE in splice(2) man page.
+      #
+      #  - :splice_nonblock
+      #
+      #    Don't block on the pipe when copying io with splice
+      #
+      #    Makes the operations on the pipe non-blocking (if the pipe is full or empty).  See SPLICE_F_NONBLOCK in
+      #    the splice(2) man page.
+      #
+      # @return [Integer] actual number of bytes copied or -errno on error
+      #
+      def copy_to(dst, *flags)
+        Libfuse.fuse_buf_copy(dst, self, flags)
+      end
+
+      # Copy direct to file descriptor
+      # @param [Integer] fileno a file descriptor
+      # @param [nil, Integer] offset if non nil will first seek to offset
+      # @param [Array<Symbol>] flags see {copy_to}
+      # @return [Integer] number of bytes copied
+      def copy_to_fd(fileno, offset = nil, *flags)
+        dst = self.class.init(size: buf_size, fd: fileno, pos: offset)
+        copy_to(dst, *flags)
+      end
+
+      # Copy to string via a temporary buffer
+      # @param [Array<Symbol>] flags see {copy_to}
+      # @return [String] the extracted data
+      def copy_to_str(*flags)
+        dst = self.class.init(size: buf_size)
+        copied = copy_to(dst, *flags)
+        dst.buffers.first.memory.read_string(copied)
+      end
+
+      # Copy from another set of buffers to this one
+      # @param [FuseBufVec] src source buffers
+      # @param [Array<Symbol>] flags
+      # @return [Integer] number of bytes written
+      # @see copy_to
+      def copy_from(src, *flags)
+        Libfuse.fuse_buf_copy(self, src, flags)
+      end
+
+      # Store ourself into a pointer location as received by {FuseOperations#read_buf}
+      # @param [FFI::Pointer<FuseBufVec>] bufp
+      # @return [void]
+      def store_to(bufp)
+        bufp.write_pointer(to_ptr)
+      end
+
+      # Write data from these buffers to another object
+      #
+      # @overload copy_to_io(io, *flags)
+      # @overload copy_to_io(io, offset = nil, *flags)
+      # @param [Object] io one of
+      #
+      #   * another {FuseBufVec} via io.{seek}(offset) and {copy_to}(io, *flags)
+      #   * an {::Integer} file descriptor to write via {copy_to_fd}(io, offset, *flags)
+      #   * a {::File} like object that returns a file descriptor via :fileno used as above
+      #   * an {::IO} like object that accepts a string data as {IO.write}(io, {copy_to_str}(*flags), offset)
+      #
+      # @param [nil, Integer] offset position in io to begin writing at, or nil if io is already positioned
+      # @param [Array<Symbol>] flags see {copy_to}
+      #
+      # @return [Integer] number of bytes written
+      # @raise [Errno::EBADF] if io is not a valid target
+      def copy_to_io(io, offset = nil, *flags)
+        if offset.is_a?(Symbol)
+          flags.unshift(offset)
+          offset = nil
+        end
+
+        if io.is_a?(FuseBufVec)
+          io.seek(offset) if offset
+          return copy_to(io, *flags)
+        end
+
+        fd = (io.respond_to?(:fileno) ? io.fileno : io)
+        return copy_to_fd(fd, offset || 0, *flags) if fd.is_a?(Integer)
+
+        Libfuse::IO.write(io, copy_to_str(*flags), offset)
+      end
+
+      # @return [Array<FuseBuf>] list of buffers
+      def buffers
+        @buffers ||= Array.new(count) do |i|
+          native = i.zero? ? self[:buf].first : FuseBuf::Native.new(self[:buf].to_ptr + (i * FuseBuf::Native.size))
+          FuseBuf.new(native)
+        end.freeze
+      end
+    end
+
+    bitmask :fuse_buf_copy_flags, [:no_splice, 1, :force_splice, 2, :splice_move, 4, :splice_nonblock, 8]
+    attach_function :fuse_buf_copy, [FuseBufVec.by_ref, FuseBufVec.by_ref, :fuse_buf_copy_flags], :ssize_t
+    attach_function :fuse_buf_size, [FuseBufVec.by_ref], :size_t
+
+    class << self
+      # @!visibility private
+      # @!method fuse_buf_size
+      # @!method fuse_buf_copy
+      # @!method fuse_buf_size
+    end
+  end
+end

data/lib/ffi/libfuse/fuse_common.rb

@@ -52,11 +52,13 @@ module FFI
         teardown
       end
 
-      # @api private
       # @param [Boolean] foreground
       # @param [Boolean] single_thread
-      # @param [Hash<String,Proc>] traps see {Ackbar.trap}
-      #
+      # @param [Hash<String,Proc|nil>] traps as per Signal.trap
+      #   these are merged over {default_traps} for INT, HUP, TERM that unmount and exit filesystem. A nil
+      #   value for these default signals will leave any existing signal handle in place.
+      # @param [Integer] remember fuse cache timeout
+      # @api private
       # Implement fuse loop in ruby
       #
       # Pros:
@@ -71,6 +73,7 @@ module FFI
       #    * clone_fd is ignored
       #    * filesystem interrupts probably can't work
       def run_ruby(foreground: true, single_thread: true, traps: {}, remember: false, **options)
+        traps = default_traps.merge(traps).keep_if { |_, v| v }
         Ackbar.trap(default_traps.merge(traps)) do |signals|
           daemonize unless foreground
 
@@ -112,7 +115,9 @@ module FFI
       end
 
       # Ruby implementation of fuse default traps
-      # @see Ackbar
+      #
+      #  * INT, HUP, TERM, TSTP to unmount and exit filesystem
+      #  * PIPE is ignored
       def default_traps
         exproc = ->(signame) { exit(signame) }
         @default_traps ||= { INT: exproc, HUP: exproc, TERM: exproc, TSTP: exproc, PIPE: 'IGNORE' }
@@ -190,6 +195,7 @@ module FFI
         fuse_process || (sleep(0.1) && false)
       end
 
+      # @!visibility private
       def teardown
         return unless @fuse
 

data/lib/ffi/libfuse/fuse_config.rb

@@ -10,10 +10,12 @@ module FFI
     # This structure is initialized from the arguments passed to fuse_new(), and then passed to the file system's init()
     # handler which should ensure that the configuration is compatible with the file system implementation.
     #
+    # Some options can only be set via the filesystem init method (use_ino etc..) because the filesystem either
+    # supports them or it doesn't.
     class FuseConfig < FFI::Struct
       include FFI::Accessors
 
-      layout(
+      spec =
         {
           # @!attribute [r] gid
           # @return [Integer|nil] if set, this value will be used for the :gid attribute of each file
@@ -158,7 +160,7 @@ module FFI
 
           # @!attribute [rw] ac_attr_timeout
           #  if set the timeout in seconds for which file attributes are cached for the purpose of checking if
-          # auto_cache should flush the file data on open.
+          #  auto_cache should flush the file data on open.
           # @return [Float|nil]
           ac_attr_timeout_set: :bool_int,
           ac_attr_timeout: :double,
@@ -179,18 +181,25 @@ module FFI
           modules: :pointer,
           debug: :bool_int
         }
-      )
 
-      setters = { gid: :set_gid, uid: :set_uid, umask: :set_mode, ac_attr_timeout: :ac_attr_timeout_set }
-      setters.each do |(attr, setter)|
-        ffi_attr_reader(attr)
+      layout(spec)
+
+      # Find the attrs that have a corresponding setter (prefix set_ or suffix _set
+      setters = spec.keys
+                    .map { |k| [k, k.to_s.sub(/^set_/, '').sub(/_set$/, '').to_sym] }
+                    .reject { |(s, a)| s == a }.to_h
+
+      setters.each do |(setter, attr)|
+        ffi_attr_reader(attr) { |val| self[setter] ? val : nil }
+
         ffi_attr_writer(attr) do |val|
           self[setter] = !val.nil?
           val || 0
         end
       end
 
-      ffi_attr_accessor(*(members - (setters.keys + setters.values)))
+      remaining = (spec.keys - setters.keys - setters.values).map { |a| spec[a] == :bool_int ? "#{a}?" : a }
+      ffi_attr_accessor(*remaining)
     end
   end
 end

data/lib/ffi/libfuse/fuse_operations.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
 require_relative 'fuse_version'
-require_relative '../ruby_object'
 require_relative 'fuse_conn_info'
-require_relative 'fuse_buffer'
+require_relative 'fuse_config'
+require_relative 'fuse_buf_vec'
 require_relative 'fuse_context'
 require_relative 'fuse_file_info'
 require_relative 'fuse_poll_handle'
+require_relative 'fuse_callbacks'
+require_relative '../ruby_object'
 require_relative '../stat_vfs'
 require_relative '../flock'
-require_relative 'thread_pool'
 require_relative '../stat'
-require_relative '../struct_array'
 require_relative '../encoding'
-require_relative 'fuse_callbacks'
 
 module FFI
   # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
@@ -44,18 +43,80 @@ module FFI
     # All Callback methods are optional, but some are essential for a useful filesystem
     # e.g. {getattr},{readdir}
     #
-    # Almost all callback operations take a path which can be of any length and will return 0 for success, or raise a
-    # {::SystemCallError} on failure
+    # Almost all callback operations take a path which can be of any length and will return 0 for success or a negative
+    # `Errno` value on failure.
     #
     class FuseOperations < FFI::Struct
       include FuseCallbacks
 
+      # Callbacks that have no return value
+      VOID_RETURN = %i[init destroy].freeze
+
       # Callbacks that are expected to return meaningful positive integers
       MEANINGFUL_RETURN = %i[read write write_buf lseek copy_file_range getxattr listxattr].freeze
 
-      # @return [Boolean] true if fuse_callback expects a meaningful integer return
-      def self.meaningful_return?(fuse_callback)
-        MEANINGFUL_RETURN.include?(fuse_callback)
+      # @!visibility private
+      # Methods to handle the path argument for most {path_callbacks}
+      NODE_PATH_METHODS = %i[first shift unshift].freeze
+
+      # @!visibility private
+      # Methods to handle the path argument for {link}, {symlink} and {rename}
+      LINK_PATH_METHODS = %i[last pop push].freeze
+
+      # @!visibility private
+      CALLBACK_PATH_ARG_METHODS = Hash.new(NODE_PATH_METHODS).merge(
+        {
+          link: LINK_PATH_METHODS,
+          symlink: LINK_PATH_METHODS,
+          rename: LINK_PATH_METHODS
+        }
+      ).freeze
+
+      class << self
+        # @return [Boolean] true if fuse_callback expects a meaningful integer return
+        def meaningful_return?(fuse_callback)
+          MEANINGFUL_RETURN.include?(fuse_callback)
+        end
+
+        # @return [Boolean] true if fuse_callback expects a void return
+        def void_return?(fuse_callback)
+          VOID_RETURN.include?(fuse_callback)
+        end
+
+        # Helper to determine how to handle the path argument for a path callback
+        # @param [Symbol] fuse_callback callback method name (must be one of #{path_callbacks})
+        # @return [Symbol, Symbol,Symbol] read, remove, add methods.
+        #   [:last, :push, :pop] for :link, :symlink, :rename,
+        #   [:first, :shift, :unshift] for everything else
+        # @example
+        #   def wrap_callback(fuse_method, *args)
+        #       read, remove, add = FFI::Libfuse::FuseOperations.path_arg_methods(fuse_method)
+        #       path = args.send(read)
+        #       # ... do something with path
+        #
+        #       path = args.send(remove)
+        #       # ... do something to make an alternate path
+        #       args.send(add, adjusted_path)
+        #       delegate.send(fuse_methoed, *args)
+        #   end
+        def path_arg_methods(fuse_callback)
+          CALLBACK_PATH_ARG_METHODS[fuse_callback]
+        end
+
+        # @return [Set<Symbol>] list of callback methods
+        def fuse_callbacks
+          @fuse_callbacks ||= Set.new(members - [:flags])
+        end
+
+        # @return [Set<Symbol>] list of path callback methods
+        def path_callbacks
+          @path_callbacks ||= fuse_callbacks - VOID_RETURN
+        end
+      end
+
+      # @!visibility private
+      def fuse_callbacks
+        self.class.fuse_callbacks
       end
 
       # Container to dynamically build up the operations layout which is dependent on the loaded libfuse version
@@ -151,12 +212,11 @@ module FFI
       # int (*rmdir) (const char *);
       op[:rmdir] = []
 
-      # @!method symlink(path,target)
+      # @!method symlink(target, path)
       #  @abstract
       #  Create a symbolic link
+      #  @param [String] target
       #  @param [String] path
-      #  @param [String] target the link target
-      #
       #  @return [Integer] 0 for success or -ve errno
 
       # int (*symlink) (const char *, const char *);
@@ -173,13 +233,13 @@ module FFI
       # int (*rename) (const char *, const char *);
       op[:rename] = [:fs_string]
 
-      # @!method link(path,target)
+      # @!method link(target, path)
       #  @abstract
       #  Create a hard link to a file
-      #  @param [String] path
       #  @param [String] target
-      #
+      #  @param [String] path
       #  @return [Integer] 0 for success or -ve errno
+      #  @see rename(2)
 
       # int (*link) (const char *, const char *);
       op[:link] = [:fs_string]
@@ -486,7 +546,6 @@ module FFI
         # fuse3: void *(*init) (struct fuse_conn_info *conn, struct fuse_config *cfg);
         op[:init] =
           if FUSE_MAJOR_VERSION >= 3
-            require_relative 'fuse_config'
             callback([FuseConnInfo.by_ref, FuseConfig.by_ref], RubyObject)
           else
             callback([FuseConnInfo.by_ref], RubyObject)
@@ -618,7 +677,7 @@ module FFI
         #
 
         # int (*utimens) (const char *, const struct timespec tv[2]);
-        op[:utimens] = [FFI::Stat::TimeSpec.array(2)]
+        op[:utimens] = [FFI::Stat::TimeSpec[2]]
         op[:utimens] << FuseFileInfo.by_ref if FUSE_MAJOR_VERSION >= 3
 
         # @!method bmap(path,blocksize,index)
@@ -655,17 +714,19 @@ module FFI
       #     release, fsync, readdir, releasedir, fsyncdir, ftruncate, fgetattr, lock, ioctl and poll
       #
       #     Closely related to flag_nullpath_ok, but if this flag is set then the path will not be calculaged even if
-      #     the file wasnt unlinked.  However the path can still be non-NULL if it needs to be calculated for some other
-      #     reason.
+      #     the file wasn't unlinked.  However the path can still be non-NULL if it needs to be calculated for some
+      #     other reason.
       #
       #   - :utime_omit_ok
       #
       #     Flag indicating that the filesystem accepts special UTIME_NOW and UTIME_OMIT values in its utimens
       #     operation.
       #
-      #   @return [Array[]Symbol>] a list of flags to set capabilities
+      #   @return [Array<Symbol>] a list of flags to set capabilities
       #   @note Not available in Fuse3
       #   @deprecated in Fuse3 use fuse_config object in {init}
+
+      # flags
       op[:flags] = :flags_mask if FUSE_MAJOR_VERSION < 3
 
       if FUSE_VERSION >= 28
@@ -717,7 +778,7 @@ module FFI
         #  @abstract
         #  Write contents of buffer to an open file
         #
-        #  Similar to the write() method, but data is supplied in a generic buffer.
+        #  Similar to the {write} method, but data is supplied in a generic buffer.
         #  Use {FuseBufVec#copy_to_fd} to copy data to an open file descriptor, or {FuseBufVec#copy_to_str} to extract
         #  string data from the buffer
         #
@@ -734,16 +795,15 @@ module FFI
         # @!method read_buf(path,bufp,size,offset,fuse_file_info)
         #  @abstract
         #
-        #  Similar to the read() method, but data is stored and returned in a generic buffer.
+        #  Similar to the {read} method, but data is stored and returned in a generic buffer.
         #
         #  No actual copying of data has to take place, the source file descriptor may simply be stored in the buffer
         #  for later data transfer.
         #
         #  @param [String] path
         #  @param [FFI::Pointer<FuseBufVec>] bufp
-        #   The buffer must be allocated dynamically and stored at the location pointed to by bufp.  If the buffer
-        #   contains memory regions, they too must be allocated using malloc().  The allocated memory will be freed by
-        #   the caller.
+        #   The buffer must be allocated dynamically ({FuseBufVec.init})
+        #   and stored at the location pointed to by bufp (see {FuseBufVec#store_to}(bufp)).
         #  @param [Integer] size
         #  @param [Integer] offset
         #  @param [FuseFileInfo] fuse_file_info
@@ -886,21 +946,6 @@ module FFI
         fuse_flags.concat(delegate.fuse_flags) if delegate.respond_to?(:fuse_flags)
         send(:[]=, :flags, fuse_flags.uniq)
       end
-
-      # @!visibility private
-      def fuse_callbacks
-        self.class.fuse_callbacks
-      end
-
-      # @return [Set<Symbol>] list of callback methods
-      def self.fuse_callbacks
-        @fuse_callbacks ||= Set.new(members - [:flags])
-      end
-
-      # @return [Set<Symbol>] list of path callback methods
-      def self.path_callbacks
-        @path_callbacks ||= fuse_callbacks - %i[init destroy]
-      end
     end
   end
 end