Struct SmartCopier 

pub struct SmartCopier {

    pub ring: IoUring,
    pub buffer_pool: BufferPool,
    pub atomic_buffer_pool: Option<BufferPool>,
    pub async_fd: Arc<AsyncFd<RawFd>>,
    pub vdo_opt: bool,
    pub direct_io_ok: bool,
    pub source_caps: Arc<Capabilities>,
    pub target_caps: Arc<Capabilities>,
    pub vdo_stall_threshold: u32,
    pub barrier_callback: Option<Box<dyn Fn(u64) + Send + Sync>>,
    pub source_uncached: bool,
    pub target_uncached: bool,
    pub governor: Option<Arc<Governor>>,
    pub fsync_tracker: FsyncLatencyTracker,
    pub skip_fsync: bool,
    pub segment_stall_timeout_secs: u64,
    pub segment_overall_timeout_secs: u64,
    pub postcopy_ring: IoUring,
    pub postcopy_async_fd: Arc<AsyncFd<RawFd>>,
}

Async copy engine backed by io_uring with auto-adaptive tier selection

Probes source/target capabilities and selects the fastest copy path: reflink (FICLONE), copy_file_range, sendfile, or pipelined io_uring.

Fields

ring: IoUring

io_uring instance for async I/O submission

buffer_pool: BufferPool

Registered buffer pool for io_uring fixed-buffer reads/writes

atomic_buffer_pool: Option<BufferPool>

Separate aligned buffer pool for hardware atomic writes (RWF_ATOMIC)

async_fd: Arc<AsyncFd<RawFd>>

Async wrapper around the io_uring eventfd for tokio integration

vdo_opt: bool

Enable VDO zero-block optimization (punch holes for all-zero blocks)

direct_io_ok: bool

Whether O_DIRECT is safe on the target filesystem

source_caps: Arc<Capabilities>

Detected capabilities of the source filesystem

target_caps: Arc<Capabilities>

Detected capabilities of the target filesystem

vdo_stall_threshold: u32

Number of consecutive zero blocks before triggering VDO stall warning

barrier_callback: Option<Box<dyn Fn(u64) + Send + Sync>>

Optional callback invoked after each file copy with the target inode

source_uncached: bool

Use RWF_UNCACHED for source reads

target_uncached: bool

Use RWF_UNCACHED for target writes

governor: Option<Arc<Governor>>

PSI-based system stress governor

fsync_tracker: FsyncLatencyTracker

Adaptive fsync timeout tracker

skip_fsync: bool

Skip fsync after writes (for batch operations that fsync at the end)

segment_stall_timeout_secs: u64

Seconds without progress before declaring a segment stall

segment_overall_timeout_secs: u64

Maximum seconds for an entire segment copy before timeout

postcopy_ring: IoUring

Separate io_uring ring for postcopy operations (rename, fsync, unlink, link, symlink, truncate, statx). Uses IORING_SETUP_ATTACH_WQ to share the kernel async worker pool with ring.

postcopy_async_fd: Arc<AsyncFd<RawFd>>

Async eventfd wrapper for the postcopy ring.

Implementations

impl SmartCopier

pub async fn optimized_statx_nlink(&mut self, path: PathBuf) -> Result<u64>

Stat a path via io_uring Statx requesting only STATX_NLINK, returning the hard-link count. Falls back to spawn_blocking(std::fs::metadata) when the kernel returns EOPNOTSUPP or EINVAL (e.g. older kernels, NFS).

impl SmartCopier

pub async fn copy( src: &Path, dst: &Path, ring: &mut IoUring, buffer_pool: &mut BufferPool, atomic_pool: Option<&mut BufferPool>, async_fd: Arc<AsyncFd<RawFd>>, vdo_opt: bool, offset: u64, length: u64, direct_io_ok: bool, src_file_size: u64, source_caps: &Arc<Capabilities>, target_caps: &Arc<Capabilities>, vdo_stall_threshold: u32, source_uncached: bool, target_uncached: bool, barrier_callback: &Option<Box<dyn Fn(u64) + Send + Sync>>, governor: Option<Arc<Governor>>, target_label: String, fsync_tracker: &mut FsyncLatencyTracker, skip_fsync: bool, segment_stall_timeout_secs: u64, segment_overall_timeout_secs: u64, is_sparse: bool, postcopy_ring: &mut IoUring, postcopy_async_fd: &Arc<AsyncFd<RawFd>>, ) -> Result<CopyStats>

Copy a file (or range) from src to dst using the full io_uring pipeline

pub async fn copy_with_limit( src: &Path, dst: &Path, ring: &mut IoUring, buffer_pool: &mut BufferPool, atomic_pool: Option<&mut BufferPool>, async_fd: Arc<AsyncFd<RawFd>>, vdo_opt: bool, offset: u64, length: u64, direct_io_ok: bool, src_file_size: u64, source_caps: &Arc<Capabilities>, target_caps: &Arc<Capabilities>, vdo_stall_threshold: u32, source_uncached: bool, target_uncached: bool, barrier_callback: &Option<Box<dyn Fn(u64) + Send + Sync>>, governor: Option<Arc<Governor>>, target_label: String, fsync_tracker: &mut FsyncLatencyTracker, buffer_limit: Option<usize>, skip_fsync: bool, segment_stall_timeout_secs: u64, segment_overall_timeout_secs: u64, is_sparse: bool, postcopy_ring: &mut IoUring, postcopy_async_fd: &Arc<AsyncFd<RawFd>>, ) -> Result<CopyStats>

Copy with an optional buffer count limit for backpressure control

impl SmartCopier

pub async fn copy_delta( &mut self, src: &Path, dst: &Path, dirty_ranges: &[DirtyRange], file_size: u64, label: &str, ) -> Result<CopyStats>

Copy only the specified dirty ranges from src to dst. Each DirtyRange triggers an optimized_copy_range() call.

Trait Implementations

impl OptimizedFs for SmartCopier

fn optimized_copy( &mut self, src: PathBuf, dst: PathBuf, src_file_size: u64, target_label: String, buffer_limit: Option<usize>, skip_fsync: bool, is_sparse: bool, ) -> impl Future<Output = Result<CopyStats>> + Send

Copy an entire file, choosing reflink/sendfile/io_uring as appropriate

fn optimized_rename( &mut self, src: PathBuf, dst: PathBuf, flags: u32, ) -> impl Future<Output = Result<CopyStats>> + Send

Rename a file with optional flags (e.g. RENAME_EXCHANGE)

fn optimized_copy_range( &mut self, src: PathBuf, dst: PathBuf, offset: u64, length: u64, src_file_size: u64, target_label: String, buffer_limit: Option<usize>, skip_fsync: bool, ) -> impl Future<Output = Result<CopyStats>> + Send

Copy a byte range within a file (used for Merkle delta resync)

fn optimized_truncate( &mut self, dst: PathBuf, size: u64, ) -> impl Future<Output = Result<CopyStats>> + Send

Truncate a file to the given size

fn optimized_fallocate( &mut self, dst: PathBuf, mode: i32, offset: u64, length: u64, ) -> impl Future<Output = Result<CopyStats>> + Send

Allocate or punch holes in a file

fn optimized_unlink( &mut self, path: PathBuf, is_dir: bool, ) -> impl Future<Output = Result<CopyStats>> + Send

Unlink a file or remove a directory via io_uring UnlinkAt (AT_REMOVEDIR for dirs). Falls back to spawn_blocking on EOPNOTSUPP.

fn optimized_link( &mut self, existing: PathBuf, new: PathBuf, ) -> impl Future<Output = Result<CopyStats>> + Send

Create a hard link via io_uring LinkAt. Falls back to spawn_blocking on EOPNOTSUPP.

fn optimized_symlink( &mut self, target: PathBuf, linkpath: PathBuf, ) -> impl Future<Output = Result<CopyStats>> + Send

Create a symbolic link via io_uring SymlinkAt. Falls back to spawn_blocking on EOPNOTSUPP.