ffi-libfuse 0.3.4 → 0.4.1

data/lib/ffi/libfuse/test_helper.rb

@@ -9,9 +9,6 @@ module FFI
   module Libfuse
     # Can be included test classes to assist with running/debugging filesystems
     module TestHelper
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/MethodLength
-
       # Runs the fuse loop on a pre configured fuse filesystem
       # @param [FuseOperations] operations
       # @param [Array<String>] args to pass to  {FFI::Libfuse::Main.fuse_create}
@@ -19,7 +16,7 @@ module FFI
       # @yield [mnt]
       #   caller can execute and test file operations using mnt and ruby File/Dir etc
       #   the block is run in a forked process and is successful unless an exception is raised
-      # @yieldparam [String] mnt the temporary direct used as the mount point
+      # @yieldparam [String] mnt the temporary directory used as the mount point
       # @raise [Error] if unexpected state is found during operations
       # @return [void]
       def with_fuse(operations, *args, **options)
@@ -34,34 +31,14 @@ module FFI
             yield mnt
           end
 
-          fuse = FFI::Libfuse::Main.fuse_create(mnt, *args, operations: operations)
-          raise FFI::Libfuse::Error, 'No fuse object returned from fuse_create' unless fuse
-
-          # Rake owns INT
-          fuse.default_traps.delete(:TERM)
-          fuse.default_traps.delete(:INT)
-
-          raise FFI::Libfuse::Error, 'fuse object is not mounted?' unless fuse.mounted?
-
-          t = Thread.new { fuse.run(foreground: true, **options) }
-
-          # TODO: Work out why waitpid2 hangs on mac unless the process has already finished
-          sleep 10 if mac_fuse?
-
-          _pid, block_status = Process.waitpid2(fpid)
-          block_exit = block_status.exitstatus
-          fuse.exit('fuse_helper')&.join
-          run_result = t.value
-
-          raise FFI::Libfuse::Error, 'fuse is still mounted after fuse.exit' if fuse.mounted?
-          raise FFI::Libfuse::Error, "forked file operations failed with #{block_exit}" unless block_exit.zero?
-          raise FFI::Libfuse::Error, "fuse run failed #{run_result}" unless run_result.zero?
+          run_fuse(mnt, *args, operations: operations, **options) do
+            # TODO: Work out why waitpid2 hangs on mac unless the process has already finished
+            sleep 10 if mac_fuse?
 
-          if !mac_fuse? && mounted?(mnt)
-            raise FFI::Libfuse::Error, "OS reports fuse is still mounted at #{mnt} after fuse.exit"
+            _pid, block_status = Process.waitpid2(fpid)
+            block_exit = block_status.exitstatus
+            raise FFI::Libfuse::Error, "forked file operations failed with #{block_exit}" unless block_exit.zero?
           end
-
-          true
         end
       end
 
@@ -77,42 +54,28 @@ module FFI
       # @note if the filesystem is configured to daemonize then no output will be captured
       def run_filesystem(filesystem, *args, env: {})
         fsname = File.basename(filesystem)
-        safe_fuse do |mnt|
-          t = Thread.new do
-            if defined?(Bundler)
-              Bundler.with_unbundled_env do
-                Open3.capture3(env, 'bundle', 'exec', filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
-              end
-            else
-              Open3.capture3(env, filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
-            end
-          end
+
+        t, err = safe_fuse do |mnt|
+          t = Thread.new { open3_filesystem(args, env, filesystem, fsname, mnt) }
           sleep 1
 
           begin
-            if block_given?
-              raise Error, "#{fsname} not mounted at #{mnt}" unless mounted?(mnt, fsname)
-
-              yield mnt
-            end
-            # rubocop:disable Lint/RescueException
-            # Minitest::Assertion and other test assertion classes are not derived from StandardError
-          rescue Exception => _err
-            # rubocop:enable Lint/RescueException
-            unmount(mnt) if mounted?(mnt)
-            o, e, _s = t.value
-            warn "Errors\n#{e}" unless e.empty?
-            warn "Output\n#{o}" unless o.empty?
-            raise
-          end
+            raise Error, "#{fsname} not mounted at #{mnt}" if block_given? && !mounted?(mnt, fsname)
 
-          unmount(mnt) if mounted?(mnt)
-          o, e, s = t.value
-          [o, e, s.exitstatus]
+            yield mnt if block_given?
+            [t, nil]
+          rescue Minitest::Assertion, StandardError => e
+            [t, e]
+          end
         end
+
+        o, e, s = t.value
+        return [o, e, s.exitstatus] unless err
+
+        warn "Errors\n#{e}" unless e.empty?
+        warn "Output\n#{o}" unless o.empty?
+        raise err
       end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/MethodLength
 
       def mounted?(mnt, _filesystem = '.*')
         type, prefix = mac_fuse? ? %w[macfuse /private] : %w[fuse]
@@ -124,7 +87,7 @@ module FFI
         if mac_fuse?
           system("diskutil unmount force #{mnt} >/dev/null 2>&1")
         else
-          system("fusermount -zu #{mnt} >/dev/null 2>&1")
+          system("fusermount#{FUSE_MAJOR_VERSION == 3 ? '3' : ''} -zu #{mnt} >/dev/null 2>&1")
         end
       end
 
@@ -140,6 +103,49 @@ module FFI
       def mac_fuse?
         FFI::Platform::IS_MAC
       end
+
+      private
+
+      def open3_filesystem(args, env, filesystem, fsname, mnt)
+        if ENV['BUNDLER_GEMFILE']
+          Open3.capture3(env, 'bundle', 'exec', filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
+        else
+          Open3.capture3(env, filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
+        end
+      end
+
+      def run_fuse(mnt, *args, operations:, **options)
+        fuse = mount_fuse(mnt, *args, operations: operations)
+        begin
+          t = Thread.new do
+            Thread.current.name = 'Fuse Run'
+            # Rake owns INT
+            fuse.run(foreground: true, traps: { INT: nil, TERM: nil }, **options)
+          end
+
+          yield
+        ensure
+          fuse.exit('fuse_helper')&.join
+          run_result = t.value
+
+          raise FFI::Libfuse::Error, 'fuse is still mounted after fuse.exit' if fuse.mounted?
+          raise FFI::Libfuse::Error, "fuse run failed #{run_result}" unless run_result.zero?
+
+          if !mac_fuse? && mounted?(mnt)
+            raise FFI::Libfuse::Error, "OS reports fuse is still mounted at #{mnt} after fuse.exit"
+          end
+        end
+      end
+
+      def mount_fuse(mnt, *args, operations:)
+        operations.fuse_debug(args.include?('-d')) if operations.respond_to?(:fuse_debug)
+
+        fuse = FFI::Libfuse::Main.fuse_create(mnt, *args, operations: operations)
+        raise FFI::Libfuse::Error, 'No fuse object returned from fuse_create' unless fuse
+        raise FFI::Libfuse::Error, 'fuse object is not mounted?' unless fuse.mounted?
+
+        fuse
+      end
     end
   end
 end

data/lib/ffi/libfuse/version.rb

@@ -3,6 +3,6 @@
 module FFI
   # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
   module Libfuse
-    VERSION = '0.3.4'
+    VERSION = '0.4.1'
   end
 end

data/lib/ffi/libfuse.rb

@@ -11,7 +11,7 @@ require_relative 'devt'
 module FFI
   # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
   module Libfuse
-    # Filesystems can raise this error to indicate errors from filesystem users
+    # Filesystems can raise this error to indicate misconfiguration issues etc...
     class Error < StandardError; end
 
     # Opinionated default args for {.main}.

data/lib/ffi/stat/native.rb

@@ -27,14 +27,14 @@ module FFI
                :unused, [:long, 3]
 
         [['', :string], ['l', :string], ['f', :int]].each do |(prefix, ftype)|
-          native_func = "native_#{prefix}stat".to_sym
-          lib_func = "#{prefix}stat".to_sym
+          native_func = :"native_#{prefix}stat"
+          lib_func = :"#{prefix}stat"
           begin
             ::FFI::Stat.attach_function native_func, lib_func, [ftype, by_ref], :int
           rescue FFI::NotFoundError
             # gLibc 2.31 (Ubuntu focal) does not export these functions, it maps them to __xstat variants
-            native_xfunc = "native_#{prefix}xstat".to_sym
-            lib_xfunc = "__#{prefix}xstat".to_sym
+            native_xfunc = :"native_#{prefix}xstat"
+            lib_xfunc = :"__#{prefix}xstat"
             ::FFI::Stat.attach_function native_xfunc, lib_xfunc, [:int, ftype, by_ref], :int
             # 1 is 64 bit versions of struct stat,  3 is 32 bit
             ::FFI::Stat.define_singleton_method(native_func) { |file, buf| send(native_xfunc, 1, file, buf) }

data/lib/ffi/stat.rb

@@ -34,9 +34,9 @@ module FFI
     int_members = Native
                   .members
                   .select { |m| m.to_s.start_with?('st_') && !m.to_s.end_with?('timespec') }
-                  .map { |m| m[3..].to_sym }
+                  .to_h { |m| [:"#{m[3..]}", m] }
 
-    ffi_attr_accessor(*int_members, format: 'st_%s')
+    ffi_attr_accessor(**int_members)
 
     # @!attribute [rw] atime
     #   @return [Time] time of last access
@@ -47,12 +47,13 @@ module FFI
     # @!attribute [rw] ctime
     #   @return [Time] time of last status change
 
-    time_members = Native.members.select { |m| m.to_s =~ /^st_.*timespec$/ }.map { |m| m[3..-5].to_sym }
+    time_members = Native.members.select { |m| m.to_s =~ /^st_.*timespec$/ }.to_h { |m| [:"#{m[3..-5]}", m] }
 
-    ffi_attr_reader(*time_members, format: 'st_%sspec', &:time)
+    ffi_attr_reader(**time_members, &:time)
 
-    ffi_attr_writer(*time_members, format: 'st_%sspec', simple: false) do |sec, nsec = 0|
-      self[__method__[0..-2].to_sym].set_time(sec, nsec)
+    ffi_attr_writer_method(**time_members) do |sec, nsec = 0|
+      _attr, member = ffi_attr_writer_member(__method__)
+      self[member].set_time(sec, nsec)
     end
 
     # Fill content for a regular file
@@ -62,9 +63,9 @@ module FFI
     # @param [Integer] gid
     # @param [Hash] args additional system specific stat fields
     # @return [self]
-    def file(mode:, size:, uid: Process.uid, gid: Process.gid, **args)
+    def file(mode:, size:, nlink: 1, uid: Process.uid, gid: Process.gid, **args)
       mode = ((S_IFREG & S_IFMT) | (mode & 0o777))
-      fill(mode: mode, size: size, uid: uid, gid: gid, **args)
+      fill(mode: mode, size: size, nlink: nlink, uid: uid, gid: gid, **args)
     end
 
     # Fill content for a directory
@@ -80,6 +81,18 @@ module FFI
     end
     alias directory dir
 
+    # Fill content for a symbolic link
+    # @param [Integer] size length of the target name (including null terminator)
+    # @param [Integer] mode
+    # @param [Integer] uid
+    # @param [Integer] gid
+    # @param [Hash] args additional system specific stat fields
+    # @return [self]
+    def symlink(size:, mode: 0o777, nlink: 1, uid: Process.uid, gid: Process.gid, **args)
+      mode = ((S_IFLNK & S_IFMT) | (mode & 0o777))
+      fill(mode: mode, nlink: nlink, size: size, uid: uid, gid: gid, **args)
+    end
+
     # Fill attributes from file (using native LIBC calls)
     # @param [Integer|:to_s] file descriptor or a file path
     # @param [Boolean] follow links
@@ -123,7 +136,7 @@ module FFI
     # @param [Integer] mask (see umask)
     # @param [Hash] overrides see {fill}
     # @return self
-    def mask(mask = 0o4000, **overrides)
+    def mask(mask = S_ISUID, **overrides)
       fill(mode: mode & (~mask), **overrides)
     end
 
@@ -147,17 +160,27 @@ module FFI
       mode & S_ISVTX != 0
     end
 
+    def symlink?
+      mode & S_IFLNK != 0
+    end
+
     class << self
-      # @!method file(stat,**fields)
+      # @!method file(**fields)
       # @return [Stat]
       # @raise [SystemCallError]
       # @see Stat#file
 
-      # @!method dir(stat,**fields)
+      # @!method dir(**fields)
       # @return [Stat]
       # @raise [SystemCallError]
       # @see Stat#dir
-      %i[file dir].each { |m| define_method(m) { |stat = new, **args| stat.send(m, **args) } }
+
+      # @!method symlink(**fields)
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#symlink
+
+      %i[file dir symlink].each { |m| define_method(m) { |stat = new, **args| stat.send(m, **args) } }
       alias directory dir
 
       # @!method from(file, stat = new(), follow: false)

data/lib/ffi/stat_vfs.rb

@@ -75,8 +75,7 @@ module FFI
     # @!attribute [rw] namemax
     #  @return [Integer] Maximum filename length
 
-    int_members = members.grep(/^f_/).map { |m| m[2..].to_sym }
-    ffi_attr_accessor(*int_members, format: 'f_%s')
+    ffi_attr_accessor(**members.grep(/^f_/).to_h { |m| [m[2..].to_sym, m] })
 
     extend FFI::Library
     ffi_lib FFI::Library::LIBC

data/lib/ffi/struct_array.rb

@@ -10,6 +10,7 @@ module FFI
     def array(size)
       ArrayConverter.new(self, size)
     end
+    alias [] array
 
     # @!visibility private
     # Helper to handle callbacks containing fixed length array of struct
@@ -28,7 +29,7 @@ module FFI
       def from_native(ptr, _ctx)
         return [] if ptr.null?
 
-        Array.new(@size) { |i| @type.new(ptr + (i * @type.size)) }
+        Array.new(@size) { |i| @type.new(ptr + (i * @type.size)) }.freeze
       end
 
       def to_native(ary, _ctx)

data/lib/ffi/struct_wrapper.rb

@@ -27,13 +27,13 @@ module FFI
         return Pointer::NULL if value.nil?
 
         value = value.native if value.is_a?(StructWrapper)
-        super(value, ctx)
+        super
       end
 
       def from_native(value, ctx)
         return nil if value.null?
 
-        native = super(value, ctx)
+        native = super
         @wrapper_class.new(native)
       end
     end
@@ -100,12 +100,14 @@ module FFI
 
     # Get attribute
     def [](member_or_attr)
-      @native[self.class.ffi_attr_readers.fetch(member_or_attr, member_or_attr)]
+      _attr, member = ffi_attr_reader_member(member_or_attr, member_or_attr)
+      @native[member]
     end
 
     # Set attribute
     def []=(member_or_attr, val)
-      @native[self.class.ffi_attr_writers.fetch(member_or_attr, member_or_attr)] = val
+      _attr, member = ffi_attr_writer_member(member_or_attr, member_or_attr)
+      @native[member] = val
     end
 
     # Pass unimplemented methods on to {#native} underlying struct

data/sample/hello_fs.rb

@@ -51,4 +51,4 @@ class HelloFS
 end
 
 # Start the file system
-FFI::Libfuse.fuse_main(operations: HelloFS.new) if __FILE__ == $0
+exit(FFI::Libfuse.fuse_main(operations: HelloFS.new)) if __FILE__ == $0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-libfuse
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.1
 platform: ruby
 authors:
 - Grant Gardner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-08 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -161,11 +161,13 @@ files:
 - lib/ffi/libfuse/filesystem/virtual_dir.rb
 - lib/ffi/libfuse/filesystem/virtual_file.rb
 - lib/ffi/libfuse/filesystem/virtual_fs.rb
+- lib/ffi/libfuse/filesystem/virtual_link.rb
 - lib/ffi/libfuse/filesystem/virtual_node.rb
 - lib/ffi/libfuse/fuse2.rb
 - lib/ffi/libfuse/fuse3.rb
 - lib/ffi/libfuse/fuse_args.rb
-- lib/ffi/libfuse/fuse_buffer.rb
+- lib/ffi/libfuse/fuse_buf.rb
+- lib/ffi/libfuse/fuse_buf_vec.rb
 - lib/ffi/libfuse/fuse_callbacks.rb
 - lib/ffi/libfuse/fuse_cmdline_opts.rb
 - lib/ffi/libfuse/fuse_common.rb
@@ -180,6 +182,7 @@ files:
 - lib/ffi/libfuse/fuse_version.rb
 - lib/ffi/libfuse/gem_helper.rb
 - lib/ffi/libfuse/gem_version.rb
+- lib/ffi/libfuse/io.rb
 - lib/ffi/libfuse/job_pool.rb
 - lib/ffi/libfuse/main.rb
 - lib/ffi/libfuse/test_helper.rb

data/lib/ffi/libfuse/fuse_buffer.rb

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'fuse_version'
-
-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]
-    bitmask :fuse_buf_copy_flags, [:no_splice, 1, :force_splice, 2, :splice_move, 4, :splice_nonblock, 8]
-
-    #
-    # Single data buffer
-    #
-    # Generic data buffer for I/O, extended attributes, etc...Data may be supplied as a memory pointer or as a file
-    #  descriptor
-    #
-    class FuseBuf < FFI::Struct
-      layout(
-        size: :size_t, #  Size of data in bytes
-        flags: :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.
-      )
-
-      # rubocop:disable  Naming/MethodParameterName
-
-      # @!attribute [r] mem
-      #   @return [FFI::Pointer] the memory in the buffer
-      def mem
-        self[:mem]
-      end
-      alias memory mem
-
-      # @!attribute [r] fd
-      #   @return [Integer] the file descriptor number
-      def fd
-        self[:fd]
-      end
-      alias file_descriptor fd
-
-      #  @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?
-
-      # Resize mem to smaller than initially allocated
-      # @param [Integer] new_size
-      # @return [void]
-      def resize(new_size)
-        self[:size] = new_size
-      end
-
-      # @overload fill(size:, mem:, auto_release)
-      #   Fill as a Memory buffer
-      #   @param [Integer] size Size of data in bytes
-      #   @param [FFI::Pointer] mem Memory pointer allocated to size if required
-      #   @param [Boolean] autorelease
-      #
-      # @overload fill(fd:, fd_retry:, pos:)
-      #   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] pos
-      #      If > 0 then used to seek to the given offset before performing operation on file descriptor.
-      # @return [self]
-      def fill(mem: FFI::Pointer::NULL, size: mem.null? ? 0 : mem.size, fd: -1, fd_retry: false, pos: 0)
-        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.positive?
-        flags << :fd_retry if fd_retry
-        self[:flags] = flags
-        self[:pos] = pos
-        self
-      end
-    end
-    # rubocop:enable Naming/MethodParameterName
-
-    #
-    # Data buffer vector
-    #
-    # An array of data buffers, each containing a memory pointer or a file descriptor.
-    #
-    # Allocate dynamically to add more than one buffer.
-    #
-    class FuseBufVec < FFI::Struct
-      layout(
-        count: :size_t,
-        idx: :size_t,
-        off: :size_t,
-        # but is treated as a variable length array of FuseBuf at size +1 following the struct.
-        buf: [FuseBuf, 1] # struct fuse_buf[1]
-      )
-
-      # @!attribute [r] count
-      #   @return [Integer] the number of buffers in the array
-      def count
-        self[:count]
-      end
-
-      # @!attribute [r] index
-      #   @return [Integer] index of current buffer within the array
-      def index
-        self[:idx]
-      end
-      alias idx index
-
-      # @!attribute [r] offset
-      #   @return [Integer] current offset within the current buffer
-      def offset
-        self[:off]
-      end
-      alias off offset
-
-      # @!attribute [r] buffers
-      #   @return [Array<FuseBuf>] array of buffers
-      def buffers
-        @buffers ||= Array.new(count) do |i|
-          next self[:buf].first if i.zero?
-
-          FuseBuf.new(self[:buf].to_ptr + (i * FuseBuf.size))
-        end
-      end
-
-      # @!attribute [r] current
-      #  @return [FuseBuf] the current buffer
-      def current
-        return self[:buf].first if index.zero?
-
-        FuseBuf.new(self[:buf].to_ptr + (index * FuseBuf.size))
-      end
-
-      # Create and initialise a new FuseBufVec
-      # @param [Boolean] autorelease should the struct be freed on GC (default NO!!!)
-      # @param [Hash] buf_options options for configuring the initial buffer. See {#init}
-      # @yield(buf,index)
-      # @yieldparam [FuseBuf] buf
-      # @yieldparam [Integer] index
-      # @yieldreturn [void]
-      # @return [FuseBufVec]
-      def self.init(autorelease: true, count: 1, **buf_options)
-        bufvec_ptr = FFI::MemoryPointer.new(:uchar, FuseBufVec.size + (FuseBuf.size * (count - 1)), true)
-        bufvec_ptr.autorelease = autorelease
-        bufvec = new(bufvec_ptr)
-        bufvec[:count] = count
-        bufvec.init(**buf_options)
-
-        buffers.each_with_index { |b, i| yield i, b } if block_given?
-        bufvec
-      end
-
-      # Set and initialise a specific buffer
-      #
-      # See fuse_common.h FUSE_BUFVEC_INIT macro
-      # @param [Integer] index the index of the buffer
-      #   @param [Hash<Symbol,Object>] buf_options see {FuseBuf#fill}
-      #   @return [FuseBuf] the initial buffer
-      def init(index: 0, **buf_options)
-        self[:idx] = index
-        self[:off] = 0
-        current.fill(**buf_options) unless buf_options.empty?
-        self
-      end
-
-      # Would pref this to be called #size but clashes with FFI::Struct, might need StructWrapper
-      # @return [Integer] total size of data in a fuse buffer vector
-      def buf_size
-        Libfuse.fuse_buf_size(self)
-      end
-
-      # Copy data from one buffer vector to another
-      # @param [FuseBufVec] dst Destination buffer vector
-      # @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 data 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 data from one file descriptor to another.  If splice is not available, return
-      #    -EINVAL.
-      #
-      #  - :splice_move
-      #
-      #    Try to move data 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 data 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 our data direct to file descriptor
-      # @param [Integer] fileno a file descriptor
-      # @param [Integer] offset
-      # @param [Array<Symbol>] flags - see {copy_to}
-      # @return [Integer] number of bytes copied
-      def copy_to_fd(fileno, offset = 0, *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 = FuseBufVec.init(size: buf_size)
-        copied = copy_to(dst, *flags)
-        dst.current.memory.read_string(copied)
-      end
-
-      def copy_from(src, *flags)
-        Libfuse.fuse_buf_copy(self, src, flags)
-      end
-    end
-
-    attach_function :fuse_buf_size, [FuseBufVec.by_ref], :size_t
-    attach_function :fuse_buf_copy, [FuseBufVec.by_ref, FuseBufVec.by_ref, :fuse_buf_copy_flags], :ssize_t
-
-    class << self
-      # @!visibility private
-      # @!method fuse_buf_size
-      # @!method fuse_buf_copy
-    end
-  end
-end