Struct NinePClient 

pub struct NinePClient { /* private fields */ }

Implementations

impl NinePClient

pub async fn open_clone( &self, from: u32, newfid: u32, flags: u32, fallback_flags: Option<u32>, ) -> ClientResult<(Qid, u32)>

Opens from on newfid. On error, fallback_flags permits one retry. The caller owns newfid.

pub async fn open_clone_prefetch( &self, from: u32, newfid: u32, flags: u32, prefetch: u32, ) -> ClientResult<(Qid, u32, Option<Bytes>)>

Opens from on newfid and optionally prefetches from offset zero. Returns data only when the prefetch reaches EOF. The caller owns newfid.

impl NinePClient

pub async fn connect_tcp( addr: SocketAddr, requested_msize: u32, ) -> Result<Arc<Self>>

Connect to a 9P server over TCP and negotiate the protocol version.

pub async fn connect_unix( path: impl AsRef<Path>, requested_msize: u32, ) -> Result<Arc<Self>>

Connect to a 9P server over a Unix domain socket and negotiate the version.

pub async fn connect_multi( targets: Vec<Target>, requested_msize: u32, ) -> Result<Arc<Self>>

Connect to the serving leader in a target set and re-probe on reconnect.

pub fn msize(&self) -> u32

The message size negotiated for the logical session.

pub fn is_connected(&self) -> bool

Whether requests currently have a live connection rather than waiting for reconnect/session replay.

pub fn traffic_stats(&self) -> TrafficStats

Cumulative traffic across the lifetime of this logical client.

pub fn max_io(&self) -> u32

Maximum data a single Tread/Treaddir response (Rread/Rreaddir) can carry within the negotiated msize: msize - header - count.

pub fn max_write_payload(&self) -> u32

Maximum data a single Twrite request can carry within the negotiated msize. The Twrite header is larger than the Rread header, so this is smaller than Self::max_io; using max_io here would produce a frame a few bytes over msize that the server rejects.

pub fn alloc_fid(&self) -> u32

Allocate a fresh fid (reusing a freed one when possible).

pub fn free_fid(&self, fid: u32)

Return a fid to the free list. The caller must have clunked it already.

pub fn outstanding_fids(&self) -> usize

Allocated fids not yet returned to the free list. Leak-accounting diagnostic.

pub async fn attach( &self, fid: u32, afid: u32, uname: &str, aname: &str, n_uname: u32, ) -> ClientResult<Qid>

pub async fn rebind( &self, fid: u32, inode_id: u64, n_uname: u32, ) -> ClientResult<Qid>

Bind fid to an inode by id (no path walk), acting as n_uname. Used for per-user fids and reconnect replay.

pub async fn walk( &self, fid: u32, newfid: u32, names: &[&[u8]], ) -> ClientResult<Vec<Qid>>

pub async fn walk_getattr( &self, fid: u32, newfid: u32, names: &[&[u8]], ) -> ClientResult<(Vec<Qid>, Stat)>

Full walk plus the final stat in one round trip. Records newfid like Self::walk.

pub async fn clunk(&self, fid: u32) -> ClientResult<()>

pub async fn getattr(&self, fid: u32, mask: u64) -> ClientResult<Stat>

pub async fn setattr(&self, ts: Tsetattr) -> ClientResult<()>

pub async fn fallocate( &self, fid: u32, offset: u64, length: u64, mode: u32, ) -> ClientResult<()>

Atomically allocate, punch, or zero a file range through the negotiated ZeroFS-private Tfallocate request.

pub async fn setattr_attr(&self, ts: Tsetattr) -> ClientResult<Stat>

Like Self::setattr but the reply carries the post-op stat.

pub async fn lopen(&self, fid: u32, flags: u32) -> ClientResult<(Qid, u32)>

pub async fn lopenat( &self, fid: u32, newfid: u32, flags: u32, ) -> ClientResult<(Qid, u32)>

Open fid’s inode on a fresh newfid in one round trip; fid is untouched.

pub async fn lopenatread( &self, fid: u32, newfid: u32, flags: u32, count: u32, ) -> ClientResult<(Qid, u32, Bytes, bool)>

Open fid’s inode on newfid like Self::lopenat and prefetch up to count bytes from offset 0 in the same round trip. Returns the qid, the iounit, the prefetched bytes, and whether they reach EOF (the whole file fit in count). The inline read is best-effort: a server-side read error yields empty data with eof = false, and the open still succeeds.

pub async fn lcreate( &self, fid: u32, name: &[u8], flags: u32, mode: u32, gid: u32, ) -> ClientResult<(Qid, u32)>

pub async fn lcreateattr( &self, dfid: u32, newfid: u32, name: &[u8], flags: u32, mode: u32, gid: u32, ) -> ClientResult<(Stat, u32)>

Create and open name under dfid, returning the post-op stat in one round trip (Tlcreateattr). Unlike Self::lcreate, dfid is left untouched (the file opens on newfid).

pub async fn read( &self, fid: u32, offset: u64, size: u32, ) -> ClientResult<Vec<u8>>

Read up to size bytes at offset, looping over multiple Tread requests when size exceeds the negotiated msize. Stops early on a short read (EOF).

pub async fn read_bytes( &self, fid: u32, offset: u64, size: u32, ) -> ClientResult<Bytes>

Like Self::read but returns the payload as Bytes. The Rread payload already arrives as Bytes, so a single-round-trip read returns it with no copy; only a multi-chunk read concatenates.

pub async fn write( &self, fid: u32, offset: u64, data: &[u8], ) -> ClientResult<u64>

Write all of data at offset, splitting into multiple Twrite requests when it exceeds the negotiated msize. Returns the total bytes written.

pub async fn readdir( &self, fid: u32, offset: u64, count: u32, ) -> ClientResult<Vec<DirEntry>>

pub async fn readdirplus( &self, fid: u32, offset: u64, count: u32, ) -> ClientResult<Vec<DirEntryPlus>>

Like Self::readdir but each entry carries its full stat (Treaddirattr).

pub async fn mkdir( &self, dfid: u32, name: &[u8], mode: u32, gid: u32, ) -> ClientResult<Qid>

pub async fn mkdir_attr( &self, dfid: u32, name: &[u8], mode: u32, gid: u32, ) -> ClientResult<Stat>

Like Self::mkdir but the reply carries the new directory’s full stat.

pub async fn symlink( &self, dfid: u32, name: &[u8], target: &[u8], gid: u32, ) -> ClientResult<Qid>

pub async fn symlink_attr( &self, dfid: u32, name: &[u8], target: &[u8], gid: u32, ) -> ClientResult<Stat>

Like Self::symlink but the reply carries the new link’s full stat.

pub async fn mknod( &self, dfid: u32, name: &[u8], mode: u32, major: u32, minor: u32, gid: u32, ) -> ClientResult<Qid>

pub async fn mknod_attr( &self, dfid: u32, name: &[u8], mode: u32, major: u32, minor: u32, gid: u32, ) -> ClientResult<Stat>

Like Self::mknod but the reply carries the new node’s full stat.

pub async fn readlink(&self, fid: u32) -> ClientResult<Vec<u8>>

pub async fn link(&self, dfid: u32, fid: u32, name: &[u8]) -> ClientResult<()>

pub async fn link_attr( &self, dfid: u32, fid: u32, name: &[u8], ) -> ClientResult<Stat>

Like Self::link but the reply carries the linked inode’s post-op stat (updated nlink).

pub async fn renameat( &self, olddirfid: u32, oldname: &[u8], newdirfid: u32, newname: &[u8], ) -> ClientResult<()>

pub async fn unlinkat( &self, dirfid: u32, name: &[u8], flags: u32, ) -> ClientResult<()>

pub async fn fsync_inode( &self, fids: &[u32], primary: u32, datasync: u32, ) -> ClientResult<()>

Verifies fsync for all fids associated with one inode. primary carries Tfsyncdur; the oldest recorded lineage token determines the result.

pub async fn fsync(&self, fid: u32, datasync: u32) -> ClientResult<()>

Verified fsync for one fid. Multi-fid inode users call Self::fsync_inode.

pub async fn fsync_all(&self, primary: u32, datasync: u32) -> ClientResult<()>

Filesystem-wide barrier for this client’s outstanding durability obligations.

pub async fn statfs(&self, fid: u32) -> ClientResult<Rstatfs>

pub async fn lock( &self, fid: u32, lock_type: LockType, flags: u32, start: u64, length: u64, proc_id: u32, client_id: &[u8], ) -> ClientResult<LockStatus>

Acquire or release a POSIX record lock. Returns the lock status; note that a non-blocking conflict surfaces as Err(ClientError::Errno(EAGAIN)) (the server replies Rlerror), whereas a blocking request that cannot be granted returns Ok(LockStatus::Blocked).

pub async fn getlock( &self, fid: u32, lock_type: LockType, start: u64, length: u64, proc_id: u32, client_id: &[u8], ) -> ClientResult<Rgetlock>

Test for a conflicting POSIX record lock.

Trait Implementations

impl Drop for NinePClient

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.