Foxing aspires to be an eBPF-powered replication engine for Linux filesystems

Foxing: High-Fidelity Filesystem Replication

Foxing is a high-performance filesystem replication system with two components:

fxcp — Standalone smart copy tool. Drop-in replacement for rsync / cp with auto-adaptive CoW/reflink, io_uring, and BLAKE3 Merkle delta detection. No BPF or root required. foxingd — eBPF-powered replication daemon for continuous, event-driven mirroring with sub-millisecond latency.

Performance

fxcp vs rsync vs cp (btrfs-over-LUKS2, NVMe)

| Workload | rsync | cp | fxcp | fxcp vs rsync | | :--- | :--- | :--- | :--- | :--- | | 10K small files (4KB each) | 607ms | 424ms | 607ms | parity | | 10 large files (100MB each) | 1236ms | 4ms | 23ms | 54x faster | | Mixed (5K files, 2.1GB) | 3998ms | 239ms | 383ms | 10x faster | | Sparse files (10x50MB) | 764ms | 3ms | 21ms | 36x faster |

NFS 4.2 Performance (XFS NVMe → NFS HDD)

| Workload | rsync | fxcp | fxcp vs rsync | | :--- | :--- | :--- | :--- | | 5000 tiny files | 12.8s | 11.5s | 1.11x faster | | NFS→NFS 100MB (same server) | 297ms | 82ms | 3.62x faster | | 100MB throughput | 322ms | 386ms | 0.83x (259 MB/s) |

foxingd Daemon Latency (BPF event-driven)

| Workload | XFS→XFS | XFS→NFS | XFS→tmpfs | | :--- | :--- | :--- | :--- | | Single file create (4KB) | 17ms | 19ms | 16ms | | Single file create (64KB) | 16ms | 18ms | 17ms | | Rename propagation | 15ms | 21ms | 16ms | | Batch 10×4KB | 187ms | 209ms | 190ms |

fxcp auto-selects the optimal strategy: NFS compound RPC for small files on NFS, reflink (instant CoW) for same-device, sendfile for small files, io_uring for large cross-device transfers. foxingd adds BPF event capture for 15-21ms single-file replication latency.

See BENCHMARKS.md for comprehensive results including MTTC matrices, tool comparisons, and visual benchmarks.

v0.8.1 Highlights

FXAR v2 archive format — gear-hash variable chunking (2KB-2MB, 64KB average) + BLAKE3 content-addressable storage + binary index. True chunk-level deduplication replaces v1's whole-file dedup (96% dedup ratio for slowly-changing data vs 63%) Seekable archives — random-access file restore without reading the entire archive. Binary chunk index enables O(chunks) restore for any single file Streaming pipe support — fxcp snap export /backup | ssh remote fxcp snap import /restore

Parallel export — rayon-parallelized chunking + compression (123 MB/s on 4 vCPU) Pipelined import — chunk loading overlaps with file writing; rayon parallel reconstruction (61 MB/s on NFS, 64 MB/s on local) NFS session pool — 4 parallel NFSv4.2 compound RPC sessions for import writes with SETATTR (uid/gid/mtime in one round-trip) Format auto-detection — import/inspect/restore auto-detect FXAR v2 vs tar archives --format tar — backward-compatible tar export for legacy workflows Pre-flight disk space checks — abort early if target has insufficient free space target-cpu=native — AVX2/AVX-512 vectorization for all Rust-generated code

v0.8.0 Highlights

fxcp -a --json — structured JSON copy results for machine consumption fxcp -a --progress — live progress reporting (5Hz terminal, 1Hz JSON for agents) Granular exit codes — 0=success, 1=partial (some files failed), 2=complete failure foxingd sd_notify — READY=1 for systemd Type=notify integration

v0.7.1 Highlights

Snapshot management — fxcp snap list/prune/stats/export/import/restore (dirvish-style point-in-time trees) .fxar archive format — content-addressable BLAKE3 chunk dedup for portable snapshot archives CoW storage stats — apparent vs on-disk size reporting with reflink savings percentage Selective restore — extract specific files/dates from archives with glob patterns Full compression matrix — zstd (default), lz4, gzip, xz for both copy and export --snapshot flag — create reflink snapshots before overwriting during copy --throttle flag — PSI-based system stress pacing

v0.7.0 Features

Multi-source fxcp — fxcp src1 src2 src3 dest/ (cp/rsync-compatible positional args) Include/exclude filtering — --include, --exclude-from FILE, --include-from FILE (rsync-compatible) Hydration stale file cleanup — foxingd deletes target files not present on source during resync Post-recovery full scan — NFS reconnect triggers full source walk after journal replay WAL storm detection — pre-registration rename storm registry suppresses ghost creation during rapid rename chains

v0.6.0 Features

Adaptive dir-hash pruning — resync skips unchanged directory subtrees (9-11x faster than rsync at 10K files) Adaptive Merkle chunks — signatures scale with file size (no >130MB cliff) NFS batch_stat prescan — compound RPCs bulk-fetch target metadata Targeted recovery scan — O(journal) with dir-hash signature pruning Worker-side mount detection — 500ms lazy unmount detection (was 10s) ENOSPC Safe Stall — survives disk pressure without crash

Quick Start: fxcp (No Root, No BPF)

# Build (no BPF toolchain needed)
cargo build --release -p fxcp
# Basic copy (like cp -a)
fxcp -a /source /destination
# Multiple sources (like cp/rsync)
fxcp -a /src1 /src2 /src3 /destination/
# With delete (like rsync --delete)
fxcp -a --delete /source /destination
# Include/exclude filtering
fxcp -a --exclude '*.tmp' --include 'important.tmp' /source /destination
fxcp -a --exclude-from patterns.txt /source /destination
# Dry run
fxcp -a -n /source /destination
# Generate foxingd-compatible signatures (for later fast resync)
fxcp -a --generate-sigs /source /destination

fxcp detects the storage stack (dm-crypt, btrfs, XFS, containers) and adapts automatically.

fxcp + foxingd Integration

fxcp --generate-sigs writes the same xattr/sidecar signatures that foxingd uses for fast resync. This enables the workflow:

# 1. Fast initial seed with fxcp (no BPF, no root needed for local)
fxcp -a --generate-sigs /source /target
# 2. Start foxingd — hydration scan sees signatures, skips matched files
foxingd daemon -c config.toml
# Log: "Hydration: 0 files require synchronization"

Also enables sneakernet: copy to USB with fxcp, ship it, plug into target host, foxingd recognizes the signatures and only syncs changes since the copy.

Quick Start: foxingd (eBPF Daemon)

# Install BPF dependencies (Fedora/RHEL)
sudo dnf install clang llvm libbpf-devel bpftool
# Build
cargo build --release -p foxingd
# Run with TUI
sudo ./target/release/foxingd daemon --config config.toml --tui
# One-shot sync (like rsync)
./target/release/foxingd sync -a /source /destination
# Check status
foxingd status
# View metrics
foxingd metrics

Installation

Fedora / RHEL (COPR)

# Enable the COPR repository
sudo dnf copr enable aenertia/foxing
# Install fxcp only (no BPF/root needed)
sudo dnf install fxcp
# Install the daemon (requires kernel 6.12+)
sudo dnf install foxingd
# Enable and start the daemon
sudo systemctl enable --now foxingd

Debian / Ubuntu

.deb packages are available — see Releases.

From Source

# fxcp only (no BPF deps needed)
cargo build --release -p fxcp
# foxingd only (requires BPF toolchain)
cargo build --release -p foxingd
# Full workspace
cargo build --release --workspace
# Install (binaries, man pages, shell completions, systemd units)
make install DESTDIR=/usr/local

Requirements

Kernel: Linux 6.12+ (BPF security_inode_create + d_instantiate fallbacks) Architectures: x86_64, aarch64 Build Tools: cargo (nightly), clang, llvm, bpftool, libbpf-dev Target Filesystem: XFS, btrfs, ext4, F2FS, NFS 4.2 (for reflink/CoW support)

Shell Completions

Completions are installed automatically with packages. For source builds:

# Generate and install manually
cargo run -p xtask -- completions
source dist/completions/fxcp.bash # bash
source dist/completions/foxingd.bash

Zsh and fish completions are also generated.