ffi-libfuse 0.0.1.pre

data/lib/ffi/libfuse/test.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'test/operations'

data/lib/ffi/libfuse/thread_pool.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module FFI
+  module Libfuse
+    # A self-expanding and self-limiting ThreadPool
+    #
+    # The first thread is created on ThreadPool.new and additional threads are added through ThreadPool.busy
+    #   called from within a worker iteration
+    #
+    # A pool thread will end when
+    #
+    #   * a worker iteration returns false or nil
+    #   * a worker thread raises an exception (silently for StopIteration)
+    #   * max_idle_threads is exceeded
+    class ThreadPool
+      class << self
+        # Starts a new thread if the current thread is a thread pool member and there are no other idle threads in the
+        # pool. The thread is marked as busy for the duration of the yield.
+        #
+        # If the current thread is not a pool member then simply yields
+        def busy(&block)
+          if (tp = Thread.current[:tp])
+            tp.busy(&block)
+          elsif block_given?
+            yield
+          end
+        end
+      end
+
+      # @return [ThreadGroup] the enclosed thread group to which the pool's threads are added
+      attr_reader :group
+
+      # Create a new ThreadPool
+      #
+      # @param [Integer] max_idle  The maximum number of idle threads (>= 0)
+      # @param [Integer] max_active The maximum number of active threads (> 0)
+      # @param [String] name A prefix used to set Thread.name for pool threads
+      # @param [Proc] worker The worker called repeatedly within each pool thread
+      # @see ThreadPool.busy
+      def initialize(max_idle: nil, max_active: nil, name: nil, &worker)
+        raise ArgumentError, "max_active #{max_active} must be > 0" if max_active && !max_active.positive?
+        raise ArgumentError, "max_idle: #{max_idle} must be >= 0" if max_idle&.negative?
+        raise ArgumentError, 'must have worker block but none given' unless worker
+
+        @max_idle = max_idle
+        @max_active = max_active
+        @name = name
+        @worker = worker
+        @mutex = Mutex.new
+        @size = 0
+        @busy = 0
+        @idle_death = Set.new
+        @completed = Queue.new
+        @group = ThreadGroup.new.add(synchronize { start_thread }).enclose
+      end
+
+      # Join the ThreadPool optionally handling thread completion
+      # @return [void]
+      # @yield (thread, error = nil)
+      # @yieldparam [Thread] thread a Thread that has finished
+      # @yieldparam [StandardError] error if thread raised an exception
+      def join
+        while (t = @completed.pop)
+          begin
+            t.join
+            yield t if block_given?
+          rescue StandardError => e
+            yield t, e if block_given?
+          end
+        end
+        self
+      end
+
+      # @!visibility private
+      def busy
+        mark_busy
+        yield if block_given?
+      ensure
+        ensure_not_busy if block_given?
+      end
+
+      # @return [Array<Thread>,Array<Thread>] busy,idle threads
+      def list
+        group.list.partition { |t| t[:tp_busy] }
+      end
+
+      private
+
+      def mark_busy
+        return if Thread.current[:tp_busy]
+
+        Thread.current[:tp_busy] = true
+        synchronize { start_thread if (@busy += 1) == @size }
+      end
+
+      attr_reader :mutex, :worker, :name
+
+      def start_thread
+        return if @max_active && @size >= @max_active
+
+        @size += 1
+        Thread.new { worker_thread }
+      end
+
+      def worker_thread
+        Thread.current.name = "#{name}-#{Thread.current.object_id.to_s(16)}" if name
+        Thread.current[:tp] = self
+        loop while invoke && !idle_limit_exceeded?
+      ensure
+        @completed << Thread.current
+        @completed.close if decrement_size.zero?
+      end
+
+      def invoke
+        worker.call
+      ensure
+        ensure_not_busy
+      end
+
+      def ensure_not_busy
+        return unless Thread.current[:tp_busy]
+
+        Thread.current[:tp_busy] = false
+        synchronize { @busy -= 1 }
+      end
+
+      def decrement_size
+        synchronize do
+          @idle_death.delete(Thread.current)
+          @size -= 1
+        end
+      end
+
+      def idle_limit_exceeded?
+        return false unless @max_idle
+
+        synchronize { (@size - @busy - @idle_death.size - 1) > @max_idle && @idle_death << Thread.current }
+      end
+
+      def synchronize(&block)
+        @mutex.synchronize(&block)
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    VERSION = '0.0.1'
+  end
+end

data/lib/ffi/libfuse.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'libfuse/fuse_version'
+require_relative 'libfuse/fuse2' if FFI::Libfuse::FUSE_MAJOR_VERSION == 2
+require_relative 'libfuse/fuse3' if FFI::Libfuse::FUSE_MAJOR_VERSION == 3
+require_relative 'libfuse/main'
+require_relative 'libfuse/adapter'
+require_relative 'devt'
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    class << self
+      # Filesystem entry point
+      # @note This main function defaults to single-threaded operation by injecting the '-s' option. Pass `$0,*ARGV`
+      #   if your filesystem can usefully support multi-threaded operation.
+      #
+      # @see Main.fuse_main
+      def fuse_main(*argv, operations:, args: argv.any? ? argv : [$0, '-s', *ARGV], private_data: nil)
+        Main.fuse_main(args: args, operations: operations, private_data: private_data) || -1
+      end
+    end
+  end
+end

data/lib/ffi/ruby_object.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'weakref'
+require 'ffi'
+
+module FFI
+  # FFI::DataConverter to pass ruby objects as void*
+  #
+  # Objects are held in a global map of object id to WeakRef of the object.
+  #
+  # ie caller that puts a RubyObject into a library is responsible for keeping that object from the GC.
+  #
+  # Note this relies on the GVL to be threadsafe(ish)
+  module RubyObject
+    # Convert to cast ruby object *long to arbitrary integer type
+    # @!visibility private
+    class CastAsInt
+      include DataConverter
+      attr_reader :native_type
+
+      def initialize(int_type)
+        @native_type = FFI.find_type(int_type)
+      end
+
+      def to_native(obj, context)
+        return 0 if obj.nil?
+
+        RubyObject.to_native(obj, context).get(:long, 0)
+      end
+
+      def from_native(object_id, _context)
+        return nil if object_id.zero?
+
+        _ptr, obj = RubyObject.cache[object_id]
+        obj
+      end
+    end
+
+    extend FFI::DataConverter
+    native_type FFI::Type::POINTER
+
+    # rubocop:disable Lint/HashCompareByIdentity
+    class << self
+      # Store a ruby object reference in an integer type
+      # @param [FFI::Type] int_type
+      def by_object_id(int_type = :long)
+        CastAsInt.new(int_type)
+      end
+
+      # @!visibility private
+
+      # convert pointer to ruby object
+      def to_native(obj, _context)
+        return FFI::Pointer::NULL if obj.nil?
+
+        # return previous pointer if we've stored this object already
+        # not threadsafe!
+        ptr, _ref = cache[obj.object_id] ||= store(obj)
+        # Keep the pointer address as a type safety check, so we don't read memory we didn't store
+        cache[ptr.address.object_id] = true
+        ptr
+      end
+
+      def from_native(ptr, _context)
+        return nil if ptr.null?
+        raise TypeError, "No RubyObject stored at #{ptr.address}" unless cache.key?(ptr.address.object_id)
+
+        _ptr, obj = cache[ptr.get(:long, 0)]
+        obj
+      end
+
+      def cache
+        @cache ||= {}
+      end
+
+      def finalizer(*keys)
+        proc { keys.each { cache.delete(key) } }
+      end
+
+      def store(obj)
+        ptr = FFI::MemoryPointer.new(:long)
+        ptr.put(:long, 0, obj.object_id)
+
+        unless obj.frozen?
+          # Clean the cache when obj is finalised
+          ObjectSpace.define_finalizer(obj, finalizer(obj.object_id, ptr.address.object_id))
+          obj = WeakRef.new(obj)
+        end
+
+        [ptr, obj]
+      end
+    end
+    # rubocop:enable Lint/HashCompareByIdentity
+  end
+end

data/lib/ffi/stat/constants.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FFI
+  class Stat
+    # File type mask
+    S_IFMT   = 0o170000
+
+    # FIFO
+    S_IFIFO  = 0o010000
+
+    # Character device
+    S_IFCHR  = 0o020000
+
+    # Directory
+    S_IFDIR  = 0o040000
+
+    # Block device
+    S_IFBLK  = 0o060000
+
+    # Regular file
+    S_IFREG  = 0o100000
+
+    # Symbolic link
+    S_IFLNK  = 0o120000
+
+    # Socket
+    S_IFSOCK = 0o140000
+  end
+end

data/lib/ffi/stat/native.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require_relative 'time_spec'
+
+module FFI
+  class Stat
+    # Native (and naked) stat from stat.h
+    # @!visibility private
+    class Native < Struct
+      case Platform::NAME
+
+      when 'x86_64-linux'
+        layout :st_dev,     :dev_t,
+               :st_ino,     :ino_t,
+               :st_nlink,   :nlink_t,
+               :st_mode,    :mode_t,
+               :st_uid,     :uid_t,
+               :st_gid,     :gid_t,
+               :__pad0,     :int,
+               :st_rdev,    :dev_t,
+               :st_size,    :off_t,
+               :st_blksize, :blksize_t,
+               :st_blocks,  :blkcnt_t,
+               :st_atimespec, TimeSpec,
+               :st_mtimespec, TimeSpec,
+               :st_ctimespec, TimeSpec
+
+      when 'x65_64-darwin'
+        layout :st_dev,       :dev_t,
+               :st_ino,       :uint32,
+               :st_mode,      :mode_t,
+               :st_nlink,     :nlink_t,
+               :st_uid,       :uid_t,
+               :st_gid,       :gid_t,
+               :st_rdev,      :dev_t,
+               :st_atimespec, TimeSpec,
+               :st_mtimespec, TimeSpec,
+               :st_ctimespec, TimeSpec,
+               :st_size,      :off_t,
+               :st_blocks,    :blkcnt_t,
+               :st_blksize,   :blksize_t,
+               :st_flags,     :uint32,
+               :st_gen,       :uint32
+      else
+        raise NotImplementedError, "FFI::Stat not implemented for FFI::Platform #{Platform::NAME}"
+      end
+    end
+  end
+end

data/lib/ffi/stat/time_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'ffi/struct_array'
+
+module FFI
+  class Stat
+    # Timespec from stat.h
+    class TimeSpec < FFI::Struct
+      extend StructArray
+
+      # Special nsec value representing the current time - see utimensat(2)
+      UTIME_NOW = (1 << 30) - 1
+      # Special nsec value representing a request to omit setting this time - see utimensat(2)
+      UTIME_OMIT = (1 << 30) - 2
+
+      # A fixed TimeSpec representing the current time
+      def self.now
+        @now ||= new.set_time(0, UTIME_NOW)
+      end
+
+      # A fixed TimeSpec representing a request to omit setting this time
+      def self.omit
+        @omit ||= new.set_time(0, UTIME_OMIT)
+      end
+
+      layout(
+        tv_sec: :time_t,
+        tv_nsec: :long
+      )
+
+      # @!attribute [r] tv_sec
+      # @return [Integer] number of seconds since epoch
+      def tv_sec
+        self[:tv_sec]
+      end
+      alias sec tv_sec
+
+      # @!attribute [r] tv_nsec
+      # @return [Integer] additional number of nanoseconds
+      def tv_nsec
+        self[:tv_nsec]
+      end
+      alias nsec tv_nsec
+
+      # @overload set_time(time)
+      #  @param [Time] time
+      #  @return [TimeSpec] self
+      # @overload set_time(sec,nsec=0)
+      #  @param [Integer] sec number of (nano/micro)seconds from epoch, precision depending on nsec
+      #  @param [Symbol|Integer] nsec
+      #   - :nsec to treat sec as number of nanoseconds since epoch
+      #   - :usec to treat sec as number of microseconds since epoch
+      #   - Integer to treat sec as number of seconds since epoch, and nsec as additional nanoseconds
+      #
+      #  @return [TimeSpec] self
+      def set_time(sec, nsec = 0)
+        return set_time(sec.to_i, sec.nsec) if sec.is_a?(Time)
+
+        case nsec
+        when :nsec
+          return set_time(sec / (10**9), sec % (10**9))
+        when :usec
+          return set_time(sec / (10**6), sec % (10**6))
+        when Integer
+          self[:tv_sec] = sec
+          self[:tv_nsec] = nsec
+        else
+          raise ArgumentError, "Invalid nsec=#{nsec}"
+        end
+
+        self
+      end
+      alias :time= set_time
+
+      # @return [Boolean] true if this value represents the special value {UTIME_NOW}
+      def now?
+        tv_nsec == UTIME_NOW
+      end
+
+      # @return [Boolean] true if this value represents the special value {UTIME_OMIT}
+      def omit?
+        tv_nsec == UTIME_OMIT
+      end
+
+      # Convert to Time
+      # @param [Time|nil] now
+      #   optional value to use if {now?} is true.  If not set then Time.now will be used
+      # @return [nil] if {omit?} is true
+      # @return [Time] this value as ruby Time in UTC
+      def time(now = nil)
+        return nil if omit?
+        return (now || Time.now).utc if now?
+
+        Time.at(sec, nsec, :nsec, in: 0).utc
+      end
+
+      # Convert to Integer
+      # @param [Time|nil] now
+      #   optional value to use if {now?} is true.  If not set then Time.now will be used
+      # @return [nil] if {omit?} is true
+      # @return [Integer] number of nanoseconds since epoch
+      def nanos(now = nil)
+        return nil if omit?
+
+        t = now? ? (now || Time.now) : self
+        t.tv_sec * 10**9 + t.tv_nsec
+      end
+
+      # Convert to Float
+      # @param [Time|nil] now
+      #   optional value to use if {now?} is true.  If not set then Time.now will be used
+      # @return [nil] if {omit?} is true
+      # @return [Float] seconds and fractional seconds since epoch
+      def to_f(now = nil)
+        return nil if omit?
+
+        t = now? ? (now || Time.now) : self
+        t.tv_sec.to_f + t.tv_nsec.to_f / (10**9)
+      end
+
+      # @!visibility private
+      def inspect
+        ns =
+          case nsec
+          when UTIME_NOW
+            'NOW'
+          when UTIME_OMIT
+            'OMIT'
+          else
+            nsec
+          end
+        "#{self.class.name}:#{sec}.#{ns}"
+      end
+    end
+  end
+end