trapexit/mergerfs

Features

• Union Filesystem Mounting - Combines multiple filesystems or directories into a single unified mount point, acting as a proxy to underlying storage.
• FUSE-Based Filesystem Mounts - Forwards filesystem operations to underlying storage through a FUSE layer, enabling near-native performance and POSIX compatibility.
• Filesystem - Provides policy-driven file placement selecting which underlying branch stores new files based on configurable rules.
• Storage Branch Selection Policies - Selects a storage branch for filesystem operations using algorithms that consider space, path existence, or randomness.
• Incremental Drive Additions - Expands the storage pool by adding new filesystems at any time without reformatting or redistributing existing data.
• Writable Pooled Views - Provides a live, writable, always-updated filesystem view of the pooled storage.
• Filesystem Freeze Blocking - Implements synchronous POSIX call behavior that halts all threads when an underlying branch filesystem blocks.
• Fault Tolerant Storage - Continues serving the pool and remaining data when an individual underlying filesystem becomes unavailable.
• Storage Pool Managers - Aggregates drives of any size into a single writable pool without reformatting or redistributing data.
• Runtime Branch List Managers - Dynamically adds, removes, or reorders storage paths in the pool at runtime without disruption.
• Filesystem Agnostic Compatibilities - Works at the filesystem level, compatible with any physical storage device without special configuration.
• Storage Path Listings - Provides dynamic branch list management for adding, removing, or reordering storage paths at runtime.
• Storage Branch Listings - Manages a dynamic list of storage paths that can be added, removed, or reordered at runtime without disrupting the pool.
• Dynamic List Manipulations - Dynamically adds, removes, prepends, or appends storage branches to the union using simple list manipulation instructions.
• Direct I/O Access - Bypasses the FUSE layer to perform reads and writes directly on the underlying filesystem for near-native performance.
• FUSE Layer Bypass for File I/O - Bypasses the FUSE union layer to perform file I/O directly on underlying filesystems for near-native performance.
• Filesystem Operation Proxies - Passes file I/O directly to underlying filesystems for near-native performance while merging directory listings.
• Union Mount Configurations - Configures a FUSE-based union mount with command-line options, config files, and runtime controls.
• Local and Remote Mount Pooling - Unifies locally attached filesystems with remote mounts under a single pool directory.
• Dynamic Filesystem Attachments and Detachments - Dynamically attaches or detaches filesystem paths from the pool without disrupting existing data.
• Copy-on-Write Filesystems - Provides copy-on-write behavior by breaking hard links and duplicating files on write operations.
• Mixed-Capacity Drive Pools - Aggregates drives of any size into a single writable pool without reformatting.
• Filesystem Failure Isolations - Isolates individual drive failures so the pool continues serving data from remaining filesystems.
• Pool Failure Isolations - Isolates individual drive failures so the pool continues serving data from remaining filesystems.
• Automatic Write Relocations - Automatically relocates files to another branch when a write fails due to insufficient space.
• Minimum Free Space Thresholds - Specifies the minimum available space a branch must have to be considered for new file creation.
• Direct Underlying Filesystem Accesses - Allows reading and writing files directly on underlying filesystems for independent recovery or inspection.
• Extended Attribute Branch Manipulations - Dynamically adds, removes, or replaces storage branches in the union by writing to a branch extended attribute.
• Command-Line Configurations - Sets branch paths and mount options directly in the terminal when starting the union filesystem.
• Cross-Filesystem Rename Copies - Copies file data and metadata between branches when a rename fails due to cross-device limitations.
• Union Filesystem Config Files - Defines storage paths and mount point settings in a configuration file using key-value pairs or colon-delimited lists.
• Container User Identity Mapping - Maps container user and group identifiers to host-level IDs for correct file ownership on the union filesystem.
• Runtime Configurations - Changes filesystem options and triggers commands at runtime through extended attribute calls on a pseudo file.
• Storage Branch Constraint Filters - Excludes branches that are read-only, lack free space, or are in a no-create mode before file placement.
• User Permission Mapping - Passes host-level UID/GID values from user namespaces to the union mount for container permission bridging.
• Filesystem Operation Categorizations - Groups POSIX filesystem functions into action, create, and search categories for unified policy assignment.
• Extended File Attributes - Passes through extended attributes, file attributes, and POSIX ACLs to the underlying filesystem.
• Command Extended Attributes - Ships an extended attribute command interface for runtime configuration changes and action triggering.
• Path Existence Branch Restrictions - Restricts branch selection to those where the target relative path already exists.
• Copy-on-Write File Copies - Creates new files that share storage with the original until one is modified, saving disk space.
• Copy-on-Write File Duplications - Duplicates files on write to preserve separate identities when hard links are broken or cross-device renames occur.
• Hard Link Break Copies - Implements copy-on-write behavior by breaking hard links and duplicating files on write operations.
• Hard Link Copy-on-Write - Creates a copy of a hardlinked file before modifying it, preserving the original link and saving space.
• POSIX Permission Enforcement - Enforces POSIX file permissions by leveraging kernel default_permissions and adjusting process credentials.
• Kernel-Side Permission Handling - Enforces file permissions using kernel-side checks with root-level UID/GID management for container support.
• User Namespace Mappings - Translates user and group identifiers between namespaces for correct file ownership in container environments.

Star history