ffi-libfuse 0.3.4 → 0.4.1

data/lib/ffi/libfuse/fuse_args.rb

@@ -3,13 +3,17 @@
 require_relative 'fuse_version'
 require_relative 'fuse_opt'
 require_relative '../ruby_object'
+require_relative '../boolean_int'
+require_relative '../accessors'
 
 module FFI
   # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
   module Libfuse
     # struct fuse_args
     class FuseArgs < FFI::Struct
-      layout :argc, :int, :argv, :pointer, :allocated, :int
+      include FFI::Accessors
+
+      layout :argc, :int, :argv, :pointer, :allocated, :bool_int
 
       # Create a fuse_args struct from command line options
       # @param [Array<String>] argv command line args
@@ -34,33 +38,17 @@ module FFI
         @arg_vector[argv.size].put_pointer(0, FFI::Pointer::NULL)
         self[:argv] = @arg_vector
         self[:argc] = argv.size
-        self[:allocated] = 0
+        self[:allocated] = false # ie libfuse did not allocate
         self
       end
 
-      # @!attribute [r] argc
-      # @return [Integer] count of args
-      def argc
-        self[:argc]
-      end
-
       # @!attribute [r] argv
       # @return [Array<String>] list of args
-      def argv
+      ffi_attr_reader(:argv) do
         # noinspection RubyResolve
         self[:argv].get_array_of_pointer(0, argc).map(&:read_string)
       end
 
-      # @!visibility private
-      def allocated
-        self[:allocated]
-      end
-
-      # @!visibility private
-      def inspect
-        "#{self.class.name} - #{%i[argc argv allocated].to_h { |m| [m, send(m)] }}"
-      end
-
       # Add an arg to this arg list
       # @param [String] arg
       def add(arg)
@@ -121,7 +109,8 @@ module FFI
       #  - :error            an error, alternatively raise {Error}
       #  - :keep             retain the current argument for further processing
       #  - :handled,:discard remove the current argument from further processing
-      # @return [nil|self] nil on error otherwise self
+      # @raise Error if an error is raised during parsing
+      # @return [self]
       def parse!(opts, data = nil, ignore: %i[non_option unmatched], &block)
         ignore ||= []
 
@@ -140,7 +129,9 @@ module FFI
         end
 
         fop = fuse_opt_proc(symbols, bool_opts, param_opts, ignore, &block)
-        Libfuse.fuse_opt_parse(self, data, int_opts, fop).zero? ? self : nil
+        raise Error unless Libfuse.fuse_opt_parse(self, data, int_opts, fop).zero?
+
+        self
       end
 
       private
@@ -148,6 +139,8 @@ module FFI
       # Valid return values from parse! block
       FUSE_OPT_PROC_RETURN = { error: -1, keep: 1, handled: 0, discard: 0 }.freeze
 
+      ffi_attr_reader(:argc, :allocated?)
+
       def fuse_opt_proc(symbols, bool_opts, param_opts, ignore, &block)
         proc do |data, arg, key, out|
           key = symbols[key]

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_cmdline_opts.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require_relative '../accessors'
+require_relative '../boolean_int'
 require_relative 'fuse_loop_config'
 module FFI
   module Libfuse
-    #
     # struct fuse_cmdline_opts {
     #   int singlethread;
     #   int foreground;
@@ -16,29 +16,32 @@ module FFI
     #   int clone_fd;
     #   unsigned int max_idle_threads;
     # };
+
+    # Command line options
     # @!visibility private
     class FuseCmdlineOpts < FFI::Struct
       include(FFI::Accessors)
 
-      layout(
-        single_thread: :int,
-        foreground: :int,
-        debug: :int,
-        nodefault_subtype: :int,
+      spec = {
+        single_thread: :bool_int,
+        foreground: :bool_int,
+        debug: :bool_int,
+        nodefault_subtype: :bool_int,
         mountpoint: :string,
-        show_version: :int,
-        show_help: :int,
-        clone_fd: :int,
-        max_idle_threads: :int
-      )
+        show_version: :bool_int,
+        show_help: :bool_int,
+        clone_fd: :bool_int,
+        max_idle_threads: :uint
+      }
+      spec[:max_threads] = :uint if FUSE_MINOR_VERSION >= 12
+
+      layout(spec)
 
-      # int to booleans
-      ffi_attr_reader(:single_thread, :foreground, :debug, :nodefault_subtype, :show_version, :show_help,
-                      :clone_fd) do |v|
-        v != 0
-      end
+      bool, = spec.partition { |_, v| v == :bool_int }
+      ffi_attr_reader(*bool.map { |k, _| "#{k}?" })
 
       ffi_attr_reader(:max_idle_threads, :mountpoint)
+      ffi_attr_reader(:max_threads) if FUSE_MINOR_VERSION >= 12
     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
@@ -38,7 +40,7 @@ module FFI
           # @!attribute [rw] negative_timeout
           # The timeout in seconds for which a negative lookup will be cached.
           #
-          # This means, that if file did not exist (lookup retuned ENOENT), the lookup will only be redone after the
+          # This means, that if file did not exist (lookup returned ENOENT), the lookup will only be redone after the
           # timeout, and the file/directory will be assumed to not exist until then. A value of zero means that
           # negative lookups are not cached.
           #
@@ -53,7 +55,7 @@ module FFI
           # @return [Float]
           attr_timeout: :double,
 
-          # @!attribute [rw] intr
+          # @!attribute [rw] intr?
           # Allow requests to be interrupted
           # @return [Boolean]
           intr: :bool_int,
@@ -78,7 +80,7 @@ module FFI
           # @return [Integer]
           remember: :int,
 
-          # @!attribute [rw] hard_remove
+          # @!attribute [rw] hard_remove?
           # should open files be removed immediately
           #
           # The default behavior is that if an open file is deleted, the file is renamed to a hidden file
@@ -93,7 +95,7 @@ module FFI
           # @return [Boolean]
           hard_remove: :bool_int,
 
-          # @!attribute [rw] use_ino
+          # @!attribute [rw] use_ino?
           # use filesystem provided inode values
           #
           # Honor the st_ino field in the functions getattr() and fill_dir(). This value is used to fill in the st_ino
@@ -107,8 +109,8 @@ module FFI
           # @return [Boolean]
           use_ino: :bool_int,
 
-          # @!attribute [rw] readdir_ino
-          # generate inodes for readdir even if {#use_ino} is set
+          # @!attribute [rw] readdir_ino?
+          # generate inodes for readdir even if {#use_ino?} is set
           #
           # If use_ino option is not given, still try to fill in the d_ino field in readdir(2). If the name was
           # previously looked up, and is still in the cache, the inode number found there will be used.  Otherwise it
@@ -116,7 +118,7 @@ module FFI
           # @return [Boolean]
           readdir_ino: :bool_int,
 
-          # @!attribute [rw] direct_io
+          # @!attribute [rw] direct_io?
           # disables the use of kernel page cache (file content cache) in the kernel for this filesystem.
           #
           # This has several affects:
@@ -133,13 +135,13 @@ module FFI
           # @return [Boolean]
           direct_io: :bool_int,
 
-          # @!attribute [rw] kernel_cache
+          # @!attribute [rw] kernel_cache?
           # disables flushing the cache of the file contents on every open(2).
           #
           # This should only be enabled on filesystem where the file data is never changed externally (not through the
           # mounted FUSE filesystem).  Thus it is not suitable for network filesystem and other intermediate filesystem.
           #
-          # **Note**:  if neither this option or {#direct_io} is specified data is still cached after the open(2),
+          # **Note**:  if neither this option or {#direct_io?} is specified data is still cached after the open(2),
           # so a read(2) system call will not always initiate a read operation.
           #
           # Internally, enabling this option causes fuse to set {FuseFileInfo#keep_cache} overwriting any value that was
@@ -147,7 +149,7 @@ module FFI
           # @return [Boolean]
           kernel_cache: :bool_int,
 
-          # @!attribute [rw] auto_cache
+          # @!attribute [rw] auto_cache?
           # invalidate cached data on open based on changes in file attributes
           #
           # This option is an alternative to `kernel_cache`. Instead of unconditionally keeping cached data, the cached
@@ -158,12 +160,12 @@ 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,
 
-          # @!attribute [rw] nullpath_ok
+          # @!attribute [rw] nullpath_ok?
           # operations on open files and directories are ok to receive nil paths
           #
           # If this option is given the file-system handlers for the following operations will not receive path
@@ -179,18 +181,28 @@ 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)
-        ffi_attr_writer(attr) do |val|
-          self[setter] = !val.nil?
-          val || 0
-        end
+
+      layout(spec)
+
+      # Find the attrs that have a corresponding setter (prefix set_ or suffix _set
+      # map attr => setter
+      setters = spec.keys
+                    .map { |k| [k.to_s.sub(/^set_/, '').sub(/_set$/, '').to_sym, k] }
+                    .reject { |(s, a)| s == a }
+                    .to_h
+
+      ffi_attr_reader_method(*setters.keys) do
+        self[setters[__method__]] ? self[__method__] : nil
+      end
+
+      ffi_attr_writer_method(*setters.keys) do |val|
+        self[setters[__method__]] = !val.nil?
+        self[__method__] = val || 0
       end
 
-      ffi_attr_accessor(*(members - (setters.keys + setters.values)))
+      ffi_attr_reader(:show_help?, :debug?)
+      remaining = (spec.keys - setters.keys - setters.values - %i[show_help modules debug])
+      ffi_attr_accessor(*remaining.map { |a| spec[a] == :bool_int ? "#{a}?" : a })
     end
   end
 end

data/lib/ffi/libfuse/fuse_conn_info.rb

@@ -326,7 +326,7 @@ module FFI
       #   or unwanted
       # @return [Array<Symbol>]
       # @see capable
-      ffi_attr_reader(:want, simple: false) do |*caps, **h|
+      ffi_attr_reader_method(:want) do |*caps, **h|
         next self[:want] if caps.empty? && h.empty?
 
         h.merge!(caps.pop) if caps.last.is_a?(Hash)

data/lib/ffi/libfuse/fuse_context.rb

@@ -15,7 +15,8 @@ module FFI
       base[:umask] = :mode_t if FUSE_VERSION >= 28
       layout base
 
-      ffi_attr_reader(*members, simple: false) do
+      # Define readers, safe from null access
+      ffi_attr_reader_method(*members) do
         m = __method__
 
         # Use overrides if they are available, or the default context if the underlying memory is invalid