ffi-libfuse 0.0.1.pre

data/lib/ffi/libfuse/fuse_config.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative '../accessors'
+module FFI
+  module Libfuse
+    #
+    # Configuration of the high-level API
+    #
+    # 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.
+    #
+    class FuseConfig < FFI::Struct
+      include FFI::Accessors
+      layout(
+        {
+          # @!method set_gid?
+          #   @return [Boolean]
+          # @!attribute [r] gid
+          #   @return [Integer]
+          # If `set_gid?` is true the st_gid attribute of each file is overwritten with the value of `gid`.
+          #
+          set_gid: :int,
+          gid: :uint,
+
+          # @!method set_uid?
+          #   @return [Boolean]
+          # @!attribute [r] uid
+          #   @return [Integer]
+          # If `set_uid?' is true the st_uid attribute of each file is overwritten with the value of `uid`.
+          #
+          set_uid: :int,
+          uid: :uint,
+
+          # @!method set_mode?
+          #   @return [Boolean]
+          # @!attribute [r] mode
+          #   @return [Integer]
+          # If `set_mode?` is true, the any permissions bits set in `umask` are unset in the st_mode attribute of each
+          # file.
+          #
+          set_mode: :int,
+          umask: :uint,
+          #
+          # The timeout in seconds for which name lookups will be
+          # cached.
+          #
+          entry_timeout: :double,
+          #
+          # 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
+          # timeout, and the file/directory will be assumed to not
+          # exist until then. A value of zero means that negative
+          # lookups are not cached.
+          #
+          negative_timeout: :double,
+          #
+          # The timeout in seconds for which file/directory attributes
+          # (as returned by e.g. the `getattr` handler) are cached.
+          #
+          attr_timeout: :double,
+          #
+          # Allow requests to be interrupted
+          #
+          intr: :int,
+          #
+          # Specify which signal number to send to the filesystem when
+          # a request is interrupted.  The default is hardcoded to
+          # USR1.
+          #
+          intr_signal: :int,
+          #
+          # Normally, FUSE assigns inodes to paths only for as long as
+          # the kernel is aware of them. With this option inodes are
+          # instead remembered for at least this many seconds.  This
+          # will require more memory, but may be necessary when using
+          # applications that make use of inode numbers.
+          #
+          # A number of -1 means that inodes will be remembered for the
+          # entire life-time of the file-system process.
+          #
+          remember: :int,
+          #
+          # The default behavior is that if an open file is deleted,
+          # the file is renamed to a hidden file (.fuse_hiddenXXX), and
+          # only removed when the file is finally released.  This
+          # relieves the filesystem implementation of having to deal
+          # with this problem. This option disables the hiding
+          # behavior, and files are removed immediately in an unlink
+          # operation (or in a rename operation which overwrites an
+          # existing file).
+          #
+          # It is recommended that you not use the hard_remove
+          # option. When hard_remove is set, the following libc
+          # functions fail on unlinked files (returning errno of
+          # ENOENT): read(2), write(2), fsync(2), close(2), f*xattr(2),
+          # ftruncate(2), fstat(2), fchmod(2), fchown(2)
+          #
+          hard_remove: :int,
+          #
+          # Honor the st_ino field in the functions getattr() and
+          # fill_dir(). This value is used to fill in the st_ino field
+          # in the stat(2), lstat(2), fstat(2) functions and the d_ino
+          # field in the readdir(2) function. The filesystem does not
+          # have to guarantee uniqueness, however some applications
+          # rely on this value being unique for the whole filesystem.
+          #
+          # Note that this does *not* affect the inode that libfuse
+          # and the kernel use internally (also called the "nodeid").
+          #
+          use_ino: :int,
+          #
+          # 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 will be set to -1.
+          # If use_ino option is given, this option is ignored.
+          #
+          readdir_ino: :int,
+          #
+          # This option disables the use of page cache (file content cache)
+          # in the kernel for this filesystem. This has several affects:
+          #
+          # 1. Each read(2) or write(2) system call will initiate one
+          #    or more read or write operations, data will not be
+          #    cached in the kernel.
+          #
+          # 2. The return value of the read() and write() system calls
+          #    will correspond to the return values of the read and
+          #    write operations. This is useful for example if the
+          #    file size is not known in advance (before reading it).
+          #
+          # Internally, enabling this option causes fuse to set the
+          # `direct_io` field of `struct fuse_file_info` - overwriting
+          # any value that was put there by the file system.
+          #
+          direct_io: :int,
+          #
+          # This option 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 this option is not specified (and neither
+          # direct_io) 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 the
+          # `keep_cache` field of `struct fuse_file_info` - overwriting
+          # any value that was put there by the file system.
+          #
+          kernel_cache: :int,
+          #
+          # This option is an alternative to `kernel_cache`. Instead of
+          # unconditionally keeping cached data, the cached data is
+          # invalidated on open(2) if if the modification time or the
+          # size of the file has changed since it was last opened.
+          #
+          auto_cache: :int,
+          #
+          # 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.
+          #
+          ac_attr_timeout_set: :int,
+          ac_attr_timeout: :double,
+          #
+          # If this option is given the file-system handlers for the
+          # following operations will not receive path information:
+          # read, write, flush, release, fsync, readdir, releasedir,
+          # fsyncdir, lock, ioctl and poll.
+          #
+          # For the truncate, getattr, chmod, chown and utimens
+          # operations the path will be provided only if the struct
+          # fuse_file_info argument is NULL.
+          #
+          nullpath_ok: :int,
+          #
+          # The remaining options are used by libfuse internally and
+          # should not be touched.
+          #
+          show_help: :int,
+          modules: :pointer,
+          debug: :int
+        }
+      )
+
+      BOOL_ATTRS = %i[
+        nullpath_ok ac_attr_timeout_set auto_cache kernel_cache direct_io
+        readdir_ino use_ino hard_remove intr set_mode set_uid set_gid
+      ].freeze
+
+      ffi_attr_reader(*BOOL_ATTRS)
+      ffi_attr_writer(*BOOL_ATTRS) { |v| v && v != 0 ? 1 : 0 }
+      BOOL_ATTRS.each { |a| define_method("#{a}?") { send(a) != 0 } }
+
+      OTHER_ATTRS = %i[ac_attr_timeout remember intr_signal attr_timeout negative_timeout entry_timeout umask uid
+                       gid].freeze
+      ffi_attr_accessor(*OTHER_ATTRS)
+    end
+  end
+end

data/lib/ffi/libfuse/fuse_conn_info.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative 'fuse_version'
+require_relative '../accessors'
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    # These are constants in fuse_common.h but defined like bitmask
+    #
+    #  FUSE_CAP_ASYNC_READ: filesystem supports asynchronous read requests
+    #  FUSE_CAP_POSIX_LOCKS: filesystem supports "remote" locking
+    #  FUSE_CAP_ATOMIC_O_TRUNC: filesystem handles the O_TRUNC open flag
+    #  FUSE_CAP_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
+    #  FUSE_CAP_BIG_WRITES: filesystem can handle write size larger than 4kB
+    #  FUSE_CAP_DONT_MASK: don't apply umask to file mode on create operations
+    #  FUSE_CAP_SPLICE_WRITE: ability to use splice() to write to the fuse device
+    #  FUSE_CAP_SPLICE_MOVE: ability to move data to the fuse device with splice()
+    #  FUSE_CAP_SPLICE_READ: ability to use splice() to read from the fuse device
+    #  FUSE_CAP_FLOCK_LOCKS: ?
+    #  FUSE_CAP_IOCTL_DIR: ioctl support on directories
+
+    #  FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
+    #  FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
+    #  FUSE_IOCTL_RETRY: retry with new iovecs
+    #  FUSE_IOCTL_DIR: is a directory
+    bitmask :fuse_ioctl, %i[compat unrestricted retry dir]
+
+    # #define FUSE_CAP_ASYNC_READ	(1 << 0)
+    # #define FUSE_CAP_POSIX_LOCKS	(1 << 1)
+    # #define FUSE_CAP_ATOMIC_O_TRUNC	(1 << 3)
+    # #define FUSE_CAP_EXPORT_SUPPORT	(1 << 4)
+    # #define FUSE_CAP_BIG_WRITES	(1 << 5)
+    # #define FUSE_CAP_DONT_MASK	(1 << 6)
+    # #define FUSE_CAP_SPLICE_WRITE	(1 << 7)
+    # #define FUSE_CAP_SPLICE_MOVE	(1 << 8)
+    # #define FUSE_CAP_SPLICE_READ	(1 << 9)
+    # #define FUSE_CAP_FLOCK_LOCKS	(1 << 10)
+    # #define FUSE_CAP_IOCTL_DIR	(1 << 11)
+
+    if FUSE_MAJOR_VERSION >= 3
+      bitmask :fuse_cap, %i[
+        async_read posix_locks atomic_o_trunc export_support
+        big_writes dont_mask splice_write splice_move splice_read
+        flock_locks ioctl_dir
+      ]
+    else
+      bitmask :fuse_cap, %i[
+        async_read posix_locks atomic_o_trunc export_support
+        dont_mask splice_write splice_move splice_read flock_locks ioctl_dir
+        auto_inval_data readdirplus readdirplus_auto async_dio writeback_cache no_open_support
+        parallel_dirops posix_acl handle_killpriv explicit_inval_data
+      ]
+    end
+    #
+    # Connection information
+    #
+    # Some of the elements are read-write, these can be changed to
+    # indicate the value requested by the filesystem.  The requested
+    # value must usually be smaller than the indicated value.
+    #
+    # @see FuseOperations#init
+    class FuseConnInfo < FFI::Struct
+      fuse_layout =
+        if FUSE_MAJOR_VERSION >= 3
+          {
+            proto_major: :uint,
+            proto_minor: :uint,
+            max_write: :uint,
+            max_read: :uint,
+            max_readahead: :uint,
+            #
+            # Capability flags that the kernel supports (read-only)
+            #
+            capable: :fuse_cap,
+            #
+            # Capability flags that the filesystem wants to enable.
+            #
+            # libfuse attempts to initialize this field with
+            # reasonable default values before calling the init() handler.
+            #
+            want: :fuse_cap,
+            #
+            # Maximum number of pending "background" requests. A
+            # background request is any type of request for which the
+            # total number is not limited by other means. As of kernel
+            # 4.8, only two types of requests fall into this category:
+            #
+            #   1. Read-ahead requests
+            #   2. Asynchronous direct I/O requests
+            #
+            # Read-ahead requests are generated (if max_readahead is
+            # non-zero) by the kernel to preemptively fill its caches
+            # when it anticipates that userspace will soon read more
+            # data.
+            #
+            # Asynchronous direct I/O requests are generated if
+            # FUSE_CAP_ASYNC_DIO is enabled and userspace submits a large
+            # direct I/O request. In this case the kernel will internally
+            # split it up into multiple smaller requests and submit them
+            # to the filesystem concurrently.
+            #
+            # Note that the following requests are *not* background
+            # requests: writeback requests (limited by the kernel's
+            # flusher algorithm), regular (i.e., synchronous and
+            # buffered) userspace read/write requests (limited to one per
+            # thread), asynchronous read requests (Linux's io_submit(2)
+            # call actually blocks, so these are also limited to one per
+            # thread).
+            #
+            max_background: :uint,
+            #
+            # Kernel congestion threshold parameter. If the number of pending
+            # background requests exceeds this number, the FUSE kernel module will
+            # mark the filesystem as "congested". This instructs the kernel to
+            # expect that queued requests will take some time to complete, and to
+            # adjust its algorithms accordingly (e.g. by putting a waiting thread
+            # to sleep instead of using a busy-loop).
+            #
+            congestion_threshold: :uint,
+            #
+            # When FUSE_CAP_WRITEBACK_CACHE is enabled, the kernel is responsible
+            # for updating mtime and ctime when write requests are received. The
+            # updated values are passed to the filesystem with setattr() requests.
+            # However, if the filesystem does not support the full resolution of
+            # the kernel timestamps (nanoseconds), the mtime and ctime values used
+            # by kernel and filesystem will differ (and result in an apparent
+            # change of times after a cache flush).
+            #
+            # To prevent this problem, this variable can be used to inform the
+            # kernel about the timestamp granularity supported by the file-system.
+            # The value should be power of 10.  The default is 1, i.e. full
+            # nano-second resolution. Filesystems supporting only second resolution
+            # should set this to 1000000000.
+            #
+            time_gran: :uint,
+            #
+            # For future use.
+            #
+            reserved: [:uint, 22]
+          }
+        else
+          {
+            proto_major: :uint,
+            proto_minor: :uint,
+            async_read: :uint, # This slot is max_read in Fuse 3
+            max_write: :uint,
+            max_readahead: :uint,
+            capable: :fuse_cap,
+            want: :fuse_cap,
+            max_background: :uint,
+            congestion_threshold: :uint,
+            reserved: [:uint, 23]
+          }
+        end.freeze
+
+      include(FFI::Accessors)
+
+      layout fuse_layout
+
+      # @!attribute [r] proto_major
+      #  @return [Integer] Major version of the protocol (read-only)
+
+      # @!attribute [r] proto_minor
+      #  @return [Integer] Minor version of the protocol (read-only)
+
+      ffi_attr_reader :proto_major, :proto_minor
+
+      #  Is asynchronous read supported (read-write)
+      ffi_attr_accessor :async_read if FUSE_MAJOR_VERSION < 3
+
+      # @!attribute [rw] max_read
+      #  @return [Integer] Maximum size of read requests.
+      #
+      #   A value of zero indicates no limit. However, even if the filesystem does not specify a limit, the maximum size
+      #   of read requests will still be limited by the kernel.
+      #
+      #  @note For the time being, the maximum size of read requests must be set both here *and* passed to
+      #  using the ``-o max_read=<n>`` mount option. At some point in the future, specifying the mount
+      #  option will no longer be necessary.
+      ffi_attr_accessor :max_read if FUSE_MAJOR_VERSION >= 3
+
+      # @!attribute [rw] max_write
+      #   @return [Integer] Maximum size of the write buffer
+
+      # @!attribute [rw] max_readahead
+      #   @return [Integer] Maximum size of the readahead buffer
+
+      ffi_attr_accessor :max_write, :max_readahead
+
+      # Capability flags that kernel supports
+      ffi_attr_reader :capable
+
+      # Is capable of all of these FUSE_CAPs
+      def capable?(*of)
+        of.all? { |c| self[:capable].include?(c) }
+      end
+
+      # Capability flags that the filesystem wants
+      ffi_attr_accessor :want
+
+      # Maximum number of backgrounded requests
+      ffi_attr_accessor :max_background
+
+      # Kernel congestion threshold parameter
+      ffi_attr_reader :congestion_threshold
+
+      ffi_attr_accessor :time_gran if FUSE_MAJOR_VERSION >= 3
+    end
+  end
+end

data/lib/ffi/libfuse/fuse_context.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'fuse_common'
+require_relative '../ruby_object'
+require_relative '../accessors'
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    # Context for each callback operation
+    # @see get
+    class FuseContext < FFI::Struct
+      include FFI::Accessors
+      base = { fuse: :fuse, uid: :uid_t, gid: :gid_t, pid: :pid_t, private_data: RubyObject }
+      base[:umask] = :mode_t if FUSE_VERSION >= 28
+      layout base
+
+      ffi_attr_reader(:uid, :gid, :pid, :mode, :private_data)
+
+      ffi_attr_reader(:umask) if FUSE_VERSION >= 28
+
+      # @!attribute [r] uid
+      #   @return [Integer] user id of the calling process
+
+      # @!attribute [r] gid
+      #  @return [Integer] group id of the calling process
+
+      # @!attribute [r] pid
+      #  @return [Integer] process id of the calling thread
+
+      # @!attribute [r] private_data
+      #  @return [Object] private filesystem data
+      #  @see FuseOperations#init
+
+      # @!attribute [r] umask
+      #  @return [Integer] umask of the calling process
+
+      # @return [Boolean]
+      # @see Libfuse.fuse_interrupted?
+      def interrupted?
+        Libfuse.fuse_interrupted?
+      end
+
+      # @return [void]
+      # @raise [Errno::EINTR]
+      # @see Libfuse.raise_interrupt
+      def raise_interrupt
+        Libfuse.raise_interrupt
+      end
+
+      class << self
+        # @return [FuseContext] the context for the current filesystem operation
+        def fuse_get_context
+          Libfuse.fuse_get_context
+        end
+        alias get fuse_get_context
+      end
+    end
+
+    attach_function :fuse_get_context, [], FuseContext.by_ref
+    attach_function :fuse_interrupted, [], :int
+    class << self
+      # @return [Boolean] if the fuse request is marked as interrupted
+      def fuse_interrupted?
+        fuse_interrupted != 0
+      end
+
+      # @return [void]
+      # @raise [Errno::EINTR] if fuse request is marked as interrupted
+      def raise_interrupt
+        raise Errno::EINTR if fuse_interrupted?
+      end
+
+      # @!visibility private
+      # @!method fuse_get_context
+      # @!method fuse_interrupted
+    end
+  end
+end