Crate vfsi_core 

Protocol-neutral vectorized filesystem contracts for the VFSI workspace.

Vfsi provides native vector execution; VfsiExt adds blanket scalar conveniences and composed workflows without replacing batching with loops. Portable requests, results, options, and imports live in api. No filesystem backend, RPC library, or async runtime is required. The vnfs crate supplies NFS clients and re-exports these same contracts.

use vfsi_core::{Vfsi, VfsiExt};
fn load_parts(fs: &impl Vfsi) -> vfsi_core::api::Result<Vec<Vec<u8>>> {
    fs.read_files(&["/file-1", "/file-2"])
}

The other root types support backend implementation; application read/write operations should be imported from api for the portable specializations. api::WriteOp and the native WriteOp share one operation definition; their offset types preserve positional versus cursor/append semantics.

Re-exports

pub use api::AsTarget;

pub use api::DirHandle;

pub use api::FileHandle;

pub use api::MkDirOp;

pub use api::SetAttrsOp;

pub use api::Target;

pub use api::Vfsi;

pub use api::VfsiExt;

Modules

api

Portable application contracts, operations, options, and extension workflows. Portable synchronous vectorized filesystem API.

path

Byte-preserving path helpers for Unix-native Path/OsStr types.

Structs

Adb

An Application Data Block (ADB) pattern, mirroring struct tc_adb.

AttrMask

A bitflags set of requested attributes.

Attrs

Idiomatic metadata returned by the Rust-native path API.

Capabilities

Typed backend capabilities. Unlike the legacy integer constants, this rejects accidental mixing with unrelated bit fields.

CopyOptions

Options for whole-file copies through crate::api::Vfsi::vcopy. Source final symlinks are followed by default; ancestor symlinks use normal namespace resolution. This is not a snapshot. When preserving a source symlink, its link text is copied and an existing destination is not replaced. Destination symlinks for data copies retain normal following behavior.

DirEntry

One native directory entry with its already-fetched metadata.

ExtentPair

One extent to copy, mirroring struct tc_extent_pair.

FilesystemStats

Filesystem capacity and limits for the filesystem containing a target. Values are observations, not reservations. None means unknown or unsupported. Byte counts use the filesystem allocation unit, not its preferred I/O size. Getters preserve zero and false as known values. Fluent with_* setters accept None to restore an unknown value.

FsObjId

Filesystem-scoped identifier for an underlying filesystem object.

OpenFlags

Typed file-open behavior for the Rust-native API.

OpenOp

One complete open request. This replaces three error-prone parallel slices of paths, flags, and modes.

Permissions

Rust-native permission bits, independent of protocol wire attributes.

ReadIntoResult

Metadata for a read placed directly into caller-provided storage.

ReadOp

One element of a batched read, replacing the C tc_iovec (which mixed input and output fields in a single mutable struct).

ReadResult

The result of one ReadOp: the data and whether end-of-file was hit. file echoes the request’s file reference so results can be paired back to mixed fd/path inputs without reordering assumptions.

RemoveOptions

Options controlling recursive removal.

RpcError

An error from the low-level client: either an NFS4ERR_* status reported by the server for a compound operation, or a transport/RPC-level failure.

VfAttrs

File attributes, mirroring struct tc_attrs. mode is the full st_mode (permission bits plus S_IFMT file-type bits); the mtime/atime/ctime fields hold seconds and nanoseconds.

VfError

The failure of one operation in a vectorized call.

WalkEntry

A directory and its entries, as returned by a filesystem walk. path is the directory’s root-relative path; entries are its immediate children.

WriteResult

The result of one crate::WriteOp. file echoes the request’s file reference.

Enums

ErrorDomain

Namespace in which a status code is meaningful.

FileOperand

Native backend operand: a File Descriptor, path, or special directory target.

SeekFrom

How filesystem seek operations interpret their offset, mirroring SEEK_SET / SEEK_CUR / SEEK_END as an enum.

StatusCode

Typed protocol/filesystem status. Transport failures have no status.

TransportKind

Transport provenance, not a guarantee that an operation is safe to retry. Unknown failures remain Other; messages are never parsed to classify them.

VfDir

An opaque handle to an open directory.

VfOffset

The offset of a read or write operation.

VfPathBase

The base a path is resolved against, replacing the C VF_FD_CWD / VF_FD_ABS sentinel descriptors.

VfType

The NFSv4 object type, replacing the raw NF4* wire codes in VfAttrs::ftype.

Constants

ERR_ACCES

ERR_EBADF

ERR_EXIST

ERR_INVAL

ERR_IO

ERR_ISDIR

ERR_NOENT

Generic errno-style error codes (they coincide with the NFS4ERR codes for the same conditions, which the NFS backend reports).

ERR_NOTDIR

NF4BLK

NF4CHR

NF4DIR

NF4FIFO

NF4LNK

NF4REG

NFSv4 wire type codes (NF4*), used to decode/encode VfType.

NF4SOCK

STATUS_TRANSPORT

NFS4 status used for transport-level failures (there is no NFS status).

VF_CAP_HARDLINKS

The backend can create hard links and report their shared identity.

VF_CAP_LSTAT

The backend implements no-follow metadata operations (lstat semantics).

VF_CAP_NON_UTF8_PATHS

The backend accepts paths containing arbitrary non-UTF-8 Unix bytes.

VF_CAP_POSIX_METADATA

The backend reports and honors Unix mode/ownership/link-count metadata.

VF_CAP_SERVER_COPY

Capability bit returned by a backend’s capability query when it will currently attempt a server-side copy operation (NFSv4.2 COPY or SMB FSCTL_SRV_COPYCHUNK).

VF_CAP_SYMLINKS

The backend can create, inspect, and copy symbolic links without following them.

VF_CAP_UNIX_SEMANTICS

Capabilities shared by the complete Unix-like NFS and dummy backends.

VF_ERR_RPC

Errors that have no filesystem status (transport / client side).

VF_ERR_UNSUPPORTED

Requested feature is not implemented by this backend.

Functions

error_from_rpc

Convert an RPC error using an explicitly chosen logical request index. None keeps the failure unattributed; it never invents index zero. Transport errors retain their transport category rather than becoming a filesystem status. The RPC’s wire-operation index is not used here.

error_from_rpc_indexed

Convert a semantic RPC failure using its wire-operation index. Transport failures have no trustworthy operation index and remain unattributed. Callers mapping compound operations to logical requests should instead use error_from_rpc with their mapped index.

file_type_from_nfs

file_type_to_nfs

The NFSv4 wire type code.

metadata_from_attrs

Backend attribute conversion; absent fields remain absent.

open_flags_to_libc

Translate the typed flags for compatibility backends.

Type Aliases

Fd

Backend-assigned numeric File Descriptor, represented as a C int.

ReadStreamCallback

Callback used by vectorized streaming reads.

RpcResult

Convenience alias used throughout the low-level client.

VfRes

Result of a compound-style operation: () on success, or the index and error of the first failing operation.

VfResult

WriteOp

A native write with owned or borrowed target and payload storage. Positioning is always VfOffset, with packed create/truncate flags. The fixed policy types let constructors infer storage without annotations.