Struct zfs_core::Zfs

pub struct Zfs { /* fields omitted */ }

A handle to work with Zfs pools, datasets, etc

Implementations

impl Zfs

pub fn new() -> Result<Self>

Create a handle to the Zfs subsystem

pub fn create<S: CStrArgument>(
    &self,
    name: S,
    dataset_type: DataSetType,
    props: &NvList
) -> Result<()>

Create a new dataset of the given type with props set as properties

Corresponds to lzc_create()

pub fn clone_dataset<S: CStrArgument, S2: CStrArgument>(
    &self,
    name: S,
    origin: S2,
    props: &mut NvListRef
) -> Result<()>

Corresponds to lzc_clone()

pub fn promote<S: CStrArgument>(
    &self,
    fsname: S,
    snap_name_buf: &mut [u8]
) -> Result<()>

Corresponds to lzc_promote()

pub fn rename<S: CStrArgument, T: CStrArgument>(
    &self,
    source: S,
    target: T
) -> Result<()>

Corresponds to lzc_rename()

pub fn destroy<S: CStrArgument>(&self, name: S) -> Result<()>

Destroy the given dataset (which may be a filesystem, snapshot, bookmark, volume, etc)

Corresponds to lzc_destroy()

pub fn snapshot<I: IntoIterator<Item = S>, S: CStrArgument>(
    &self,
    snaps: I
) -> Result<(), Error>

Create snapshot(s)

The snapshots must be from the same pool, and must not reference the same dataset (iow: cannot create 2 snapshots of the same filesystem).

Corresponds to lzc_snapshot().

pub fn snapshot_raw(
    &self,
    snaps: &NvList,
    props: &NvList
) -> Result<(), Result<Error, NvList>>

Create snapshot(s). snaps is a list of bool (not boolean_value) entries, the names of which correspond to snapshot names.

The snapshots must be from the same pool, and must not reference the same dataset (iow: cannot create 2 snapshots of the same filesystem with a single call).

Corresponds to lzc_snapshot().

pub fn destroy_snaps<I: IntoIterator<Item = S>, S: CStrArgument>(
    &self,
    snaps: I,
    defer: Defer
) -> Result<(), (Error, NvList)>

pub fn destroy_snaps_raw(
    &self,
    snaps: &NvList,
    defer: Defer
) -> Result<(), (Error, NvList)>

Corresponds to lzc_destroy_snaps()

pub fn snaprange_space<F: CStrArgument, L: CStrArgument>(
    &self,
    first_snap: F,
    last_snap: L
) -> Result<u64>

Corresponds to lzc_snaprange_space()

pub fn exists<S: CStrArgument>(&self, name: S) -> bool

Check if a dataset (a filesystem, or a volume, or a snapshot) with the given name exists.

Note: cannot check for bookmarks

Corresponds to lzc_exists().

pub fn sync<S: CStrArgument>(&self, pool_name: S, force: bool) -> Result<()>

Corresponds to lzc_sync().

pub fn hold_raw(
    &self,
    holds: &NvListRef,
    cleanup_fd: Option<RawFd>
) -> Result<(), Result<Error, NvList>>

Create "user holds" on snapshots. If there is a hold on a snapshot, the snapshot can not be destroyed. (However, it can be marked for deletion by lzc_destroy_snaps(defer=B_TRUE).)

The keys in the nvlist are snapshot names.
The snapshots must all be in the same pool. The value is the name of the hold (string type).

pub fn hold<'a, H, S, N>(
    &self,
    holds: H,
    cleanup_fd: Option<RawFd>
) -> Result<(), Error> where
    H: IntoIterator<Item = &'a (S, N)>,
    S: 'a + CStrArgument + Clone,
    N: 'a + CStrArgument + Clone, 

Create a set of holds, each on a given snapshot

Related: [get_holds], [release], [hold_raw], [release_raw].

Corresponds to lzc_hold.

pub fn release_raw(
    &self,
    holds: &NvListRef
) -> Result<(), Result<Error, NvList>>

Release holds from various snapshots

The holds nvlist is [(snap_name, [hold_names])], allowing multiple holds for multiple snapshots to be released with one call.

Related: [release]

Corresponds to lzc_release.

pub fn release<'a, F, C, H, N>(&self, holds: F) -> Result<(), Error> where
    F: IntoIterator<Item = &'a (C, H)>,
    C: 'a + CStrArgument + Clone,
    H: 'a + IntoIterator<Item = N> + Clone,
    N: 'a + CStrArgument + Clone, 

For a list of datasets, release one or more holds by name

Corresponds to lzc_release.

pub fn get_holds<S: CStrArgument>(&self, snapname: S) -> Result<HoldList>

Get the holds for a given snapshot

The returned nvlist is [(hold_name: String, unix_timestamp_seconds: u64)], where the unix timestamp is when the hold was created.

Corresponds to lzc_get_holds()

pub fn send<S: CStrArgument, F: CStrArgument>(
    &self,
    snapname: S,
    from: Option<F>,
    fd: RawFd,
    flags: SendFlags
) -> Result<()>

Send the described stream

Internally, is a wrapper around [send_resume_redacted()]

Corresponds to lzc_send()

pub fn send_resume<S: CStrArgument, F: CStrArgument>(
    &self,
    snapname: S,
    from: F,
    fd: RawFd,
    flags: SendFlags,
    resume_obj: u64,
    resume_off: u64
) -> Result<()>

Send the described stream with resume information

Internally, this is a wrapper around [send_resume_redacted()].

Corresponds to lzc_send_resume()

pub fn send_space<S: CStrArgument, F: CStrArgument>(
    &self,
    snapname: S,
    from: F,
    flags: SendFlags
) -> Result<u64>

Estimate the size of the stream to be sent if [send] were called with the same arguments

Internally, this is a wrapper around [send_space_resume_redacted()].

Corresponds to lzc_send_space()

pub fn receive<S: CStrArgument, O: CStrArgument>(
    &self,
    snapname: S,
    props: Option<&NvListRef>,
    origin: Option<O>,
    force: bool,
    raw: bool,
    fd: RawFd
) -> Result<()>

Corresponds to lzc_receive()

pub fn receive_resumable<S: CStrArgument, O: CStrArgument>(
    &self,
    snapname: S,
    props: &NvListRef,
    origin: O,
    force: bool,
    raw: bool,
    fd: RawFd
) -> Result<()>

Corresponds to lzc_receive_resumable()

pub fn rollback<S: CStrArgument>(&self, fsname: S) -> Result<CString>

Corresponds to lzc_rollback()

pub fn rollback_to<F: CStrArgument, S: CStrArgument>(
    &self,
    fsname: F,
    snapname: S
) -> Result<()>

Corresponds to lzc_rollback_to()

pub fn bookmark<I: IntoIterator<Item = (D, S)>, D: CStrArgument, S: CStrArgument>(
    &self,
    bookmarks: I
) -> Result<(), ErrorList>

Create bookmarks from existing snapshot or bookmark

pub fn bookmark_raw(&self, bookmarks: &NvListRef) -> Result<(), (Error, NvList)>

Create bookmarks from existing snapshot or bookmark

The bookmarks nvlist is [(full_name_of_new_bookmark, full_name_of_source_snap_or_bookmark)].

Corresponds to lzc_bookmark()

pub fn get_bookmarks_raw<F: CStrArgument>(
    &self,
    fsname: F,
    props: &NvListRef
) -> Result<NvList>

Retreive bookmarks for the given filesystem

props is a list of [(prop_name, ())], where prop_name names a property on a bookmark. All the named properties are returned in the return value as the values of each bookmark.

Corresponds to lzc_get_bookmarks()

pub fn get_bookmark_props<B: CStrArgument>(&self, bookmark: B) -> Result<NvList>

Corresponds to lzc_get_bookmark_props()

pub fn destroy_bookmarks(
    &self,
    bookmarks: &NvListRef
) -> Result<(), (Error, NvList)>

Corresponds to lzc_destroy_bookmarks()

pub fn channel_program<P: CStrArgument, R: CStrArgument>(
    &self,
    pool: P,
    program: R,
    instruction_limit: u64,
    memlimit: u64,
    args: &NvListRef
) -> Result<NvList>

Execute a channel program

root privlidges are required to execute a channel program

Corresponds to lzc_channel_program()

pub fn channel_program_nosync<P: CStrArgument, R: CStrArgument>(
    &self,
    pool: P,
    program: R,
    instruction_limit: u64,
    memlimit: u64,
    args: &NvListRef
) -> Result<NvList>

Execute a read-only channel program

root privlidges are required to execute a channel program (even a read-only one)

Corresponds to lzc_channel_program_nosync()

pub fn pool_checkpoint<P: CStrArgument>(&self, pool: P) -> Result<()>

Create a pool checkpoint

Corresponds to lzc_pool_checkpoint()

pub fn pool_checkpoint_discard<P: CStrArgument>(&self, pool: P) -> Result<()>

Discard the pool checkpoint

Corresponds to lzc_pool_checkpoint_discard()

pub fn load_key<F: CStrArgument>(
    &self,
    fsname: F,
    noop: bool,
    keydata: &[u8]
) -> Result<()>

Corresponds to lzc_load_key()

pub fn unload_key<F: CStrArgument>(&self, fsname: F) -> Result<()>

Corresponds to lzc_unload_key()

pub fn change_key<F: CStrArgument>(
    &self,
    fsname: F,
    crypt_cmd: u64,
    props: &NvListRef,
    keydata: Option<&[u8]>
) -> Result<()>

Corresponds to lzc_change_key()

pub fn reopen<P: CStrArgument>(
    &self,
    pool: P,
    scrub_restart: bool
) -> Result<()>

Corresponds to lzc_reopen()

pub fn initialize<P: CStrArgument>(
    &self,
    pool: P,
    initialize_func: PoolInitializeFunc,
    vdevs: &NvListRef
) -> Result<(), (Error, NvList)>

Corresponds to lzc_initialize()

pub fn trim<P: CStrArgument>(
    &self,
    pool: P,
    pool_trim_func: PoolTrimFunc,
    rate: u64,
    secure: bool,
    vdevs: &NvListRef
) -> Result<(), (Error, NvList)>

Corresponds to lzc_trim()

Trait Implementations

impl Debug for Zfs

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Zfs

pub fn drop(&mut self)

Executes the destructor for this type.