razor_libzfscore/
lib.rs

1#![cfg_attr(feature = "pedantic", warn(clippy::pedantic))]
2#![warn(clippy::use_self)]
3#![warn(clippy::map_flatten)]
4#![warn(clippy::map_unwrap_or)]
5#![warn(deprecated_in_future)]
6#![warn(future_incompatible)]
7#![warn(noop_method_call)]
8#![warn(unreachable_pub)]
9#![warn(missing_debug_implementations)]
10#![warn(rust_2018_compatibility)]
11#![warn(rust_2021_compatibility)]
12#![warn(rust_2018_idioms)]
13#![warn(unused)]
14#![allow(clippy::missing_safety_doc)]
15#![allow(clippy::too_many_arguments)]
16#![deny(warnings)]
17
18use std::ptr;
19
20use once_cell::sync::Lazy;
21
22use razor_libnvpair as libnvpair;
23use razor_libzfscore_sys as sys;
24
25pub use sys::dmu_replay_record;
26pub use sys::lzc_dataset_type;
27pub use sys::lzc_send_flags;
28pub use sys::pool_initialize_func_t;
29pub use sys::pool_trim_func_t;
30
31#[cfg(feature = "wait")]
32pub use sys::zfs_wait_activity_t;
33
34mod lzc;
35
36pub unsafe fn lzc_snapshot(
37    snaps: *mut libnvpair::nvlist_t,
38    props: *mut libnvpair::nvlist_t,
39    errlist: *mut *mut libnvpair::nvlist_t,
40) -> libc::c_int {
41    Lazy::force(&lzc::LIBZFS_CORE);
42    sys::lzc_snapshot(snaps, props, errlist)
43}
44
45pub unsafe fn lzc_create(
46    name: *const libc::c_char,
47    dataset_type: sys::lzc_dataset_type,
48    props: *mut libnvpair::nvlist_t,
49) -> libc::c_int {
50    Lazy::force(&lzc::LIBZFS_CORE);
51    let wkeydata = ptr::null_mut();
52    let wkeylen = 0;
53    sys::lzc_create(name, dataset_type, props, wkeydata, wkeylen)
54}
55
56pub unsafe fn lzc_clone(
57    fsname: *const libc::c_char,
58    origin: *const libc::c_char,
59    props: *mut libnvpair::nvlist_t,
60) -> libc::c_int {
61    Lazy::force(&lzc::LIBZFS_CORE);
62    sys::lzc_clone(fsname, origin, props)
63}
64
65pub unsafe fn lzc_promote(
66    fsname: *const libc::c_char,
67    snapnamebuf: *mut libc::c_char,
68    snapnamelen: libc::c_int,
69) -> libc::c_int {
70    Lazy::force(&lzc::LIBZFS_CORE);
71    sys::lzc_promote(fsname, snapnamebuf, snapnamelen)
72}
73
74pub unsafe fn lzc_destroy_snaps(
75    snaps: *mut libnvpair::nvlist_t,
76    defer: impl Into<libnvpair::boolean_t>,
77    errlist: *mut *mut libnvpair::nvlist_t,
78) -> libc::c_int {
79    Lazy::force(&lzc::LIBZFS_CORE);
80    let defer = defer.into();
81    sys::lzc_destroy_snaps(snaps, defer, errlist)
82}
83
84pub unsafe fn lzc_bookmark(
85    bookmarks: *mut libnvpair::nvlist_t,
86    errlist: *mut *mut libnvpair::nvlist_t,
87) -> libc::c_int {
88    Lazy::force(&lzc::LIBZFS_CORE);
89    sys::lzc_bookmark(bookmarks, errlist)
90}
91
92pub unsafe fn lzc_get_bookmarks(
93    fsname: *const libc::c_char,
94    props: *mut libnvpair::nvlist_t,
95    bookmarks: *mut *mut libnvpair::nvlist_t,
96) -> libc::c_int {
97    Lazy::force(&lzc::LIBZFS_CORE);
98    sys::lzc_get_bookmarks(fsname, props, bookmarks)
99}
100
101pub unsafe fn lzc_get_bookmark_props(
102    bookmark: *const libc::c_char,
103    props: *mut *mut libnvpair::nvlist_t,
104) -> libc::c_int {
105    Lazy::force(&lzc::LIBZFS_CORE);
106    sys::lzc_get_bookmark_props(bookmark, props)
107}
108
109pub unsafe fn lzc_destroy_bookmarks(
110    bookmarks: *mut libnvpair::nvlist_t,
111    errlist: *mut *mut libnvpair::nvlist_t,
112) -> libc::c_int {
113    Lazy::force(&lzc::LIBZFS_CORE);
114    sys::lzc_destroy_bookmarks(bookmarks, errlist)
115}
116
117pub unsafe fn lzc_load_key(
118    fsname: *const libc::c_char,
119    noop: impl Into<libnvpair::boolean_t>,
120    wkeydata: *mut u8,
121    wkeylen: libc::c_uint,
122) -> libc::c_int {
123    Lazy::force(&lzc::LIBZFS_CORE);
124    let noop = noop.into();
125    sys::lzc_load_key(fsname, noop, wkeydata, wkeylen)
126}
127
128pub unsafe fn lzc_unload_key(fsname: *const libc::c_char) -> libc::c_int {
129    Lazy::force(&lzc::LIBZFS_CORE);
130    sys::lzc_unload_key(fsname)
131}
132
133pub unsafe fn lzc_change_key(
134    fsname: *const libc::c_char,
135    cryptcmd: u64,
136    props: *mut libnvpair::nvlist_t,
137    wkeydata: *mut u8,
138    wkeylen: libc::c_uint,
139) -> libc::c_int {
140    Lazy::force(&lzc::LIBZFS_CORE);
141    sys::lzc_change_key(fsname, cryptcmd, props, wkeydata, wkeylen)
142}
143
144pub unsafe fn lzc_initialize(
145    poolname: *const libc::c_char,
146    cmd_type: pool_initialize_func_t,
147    vdevs: *mut libnvpair::nvlist_t,
148    errlist: *mut *mut libnvpair::nvlist_t,
149) -> libc::c_int {
150    Lazy::force(&lzc::LIBZFS_CORE);
151    sys::lzc_initialize(poolname, cmd_type, vdevs, errlist)
152}
153
154pub unsafe fn lzc_trim(
155    poolname: *const libc::c_char,
156    cmd_type: pool_trim_func_t,
157    rate: u64,
158    secure: impl Into<libnvpair::boolean_t>,
159    vdevs: *mut libnvpair::nvlist_t,
160    errlist: *mut *mut libnvpair::nvlist_t,
161) -> libc::c_int {
162    Lazy::force(&lzc::LIBZFS_CORE);
163    let secure = secure.into();
164    sys::lzc_trim(poolname, cmd_type, rate, secure, vdevs, errlist)
165}
166
167pub unsafe fn lzc_redact(
168    snapshot: *const libc::c_char,
169    bookname: *const libc::c_char,
170    snapnv: *mut libnvpair::nvlist_t,
171) -> libc::c_int {
172    Lazy::force(&lzc::LIBZFS_CORE);
173    sys::lzc_redact(snapshot, bookname, snapnv)
174}
175
176pub unsafe fn lzc_snaprange_space(
177    firstsnap: *const libc::c_char,
178    lastsnap: *const libc::c_char,
179    usedp: *mut u64,
180) -> libc::c_int {
181    Lazy::force(&lzc::LIBZFS_CORE);
182    sys::lzc_snaprange_space(firstsnap, lastsnap, usedp)
183}
184
185pub unsafe fn lzc_hold(
186    holds: *mut libnvpair::nvlist_t,
187    cleanup_fd: libc::c_int,
188    errlist: *mut *mut libnvpair::nvlist_t,
189) -> libc::c_int {
190    Lazy::force(&lzc::LIBZFS_CORE);
191    sys::lzc_hold(holds, cleanup_fd, errlist)
192}
193
194pub unsafe fn lzc_release(
195    holds: *mut libnvpair::nvlist_t,
196    errlist: *mut *mut libnvpair::nvlist_t,
197) -> libc::c_int {
198    Lazy::force(&lzc::LIBZFS_CORE);
199    sys::lzc_release(holds, errlist)
200}
201
202pub unsafe fn lzc_get_holds(
203    snapname: *const libc::c_char,
204    holdsp: *mut *mut libnvpair::nvlist_t,
205) -> libc::c_int {
206    Lazy::force(&lzc::LIBZFS_CORE);
207    sys::lzc_get_holds(snapname, holdsp)
208}
209
210pub unsafe fn lzc_destroy(name: *const libc::c_char) -> libc::c_int {
211    Lazy::force(&lzc::LIBZFS_CORE);
212    sys::lzc_destroy(name)
213}
214
215pub unsafe fn lzc_exists(name: *const libc::c_char) -> bool {
216    Lazy::force(&lzc::LIBZFS_CORE);
217    sys::lzc_exists(name).into()
218}
219
220pub unsafe fn lzc_send(
221    snapname: *const libc::c_char,
222    from: *const libc::c_char,
223    fd: libc::c_int,
224    flags: lzc_send_flags,
225) -> libc::c_int {
226    Lazy::force(&lzc::LIBZFS_CORE);
227    sys::lzc_send(snapname, from, fd, flags)
228}
229
230pub unsafe fn lzc_send_resume(
231    snapname: *const libc::c_char,
232    from: *const libc::c_char,
233    fd: libc::c_int,
234    flags: lzc_send_flags,
235    resumeobj: u64,
236    resumeoff: u64,
237) -> libc::c_int {
238    Lazy::force(&lzc::LIBZFS_CORE);
239    sys::lzc_send_resume(snapname, from, fd, flags, resumeobj, resumeoff)
240}
241
242pub unsafe fn lzc_send_space(
243    snapname: *const libc::c_char,
244    from: *const libc::c_char,
245    flags: lzc_send_flags,
246    spacep: *mut u64,
247) -> libc::c_int {
248    Lazy::force(&lzc::LIBZFS_CORE);
249    sys::lzc_send_space(snapname, from, flags, spacep)
250}
251
252pub unsafe fn lzc_send_redacted(
253    snapname: *const libc::c_char,
254    from: *const libc::c_char,
255    fd: libc::c_int,
256    flags: lzc_send_flags,
257    redactbook: *const libc::c_char,
258) -> libc::c_int {
259    Lazy::force(&lzc::LIBZFS_CORE);
260    sys::lzc_send_redacted(snapname, from, fd, flags, redactbook)
261}
262
263pub unsafe fn lzc_send_resume_redacted(
264    snapname: *const libc::c_char,
265    from: *const libc::c_char,
266    fd: libc::c_int,
267    flags: lzc_send_flags,
268    resumeobj: u64,
269    resumeoff: u64,
270    redactbook: *const libc::c_char,
271) -> libc::c_int {
272    Lazy::force(&lzc::LIBZFS_CORE);
273    sys::lzc_send_resume_redacted(snapname, from, fd, flags, resumeobj, resumeoff, redactbook)
274}
275
276pub unsafe fn lzc_receive(
277    snapname: *const libc::c_char,
278    props: *mut libnvpair::nvlist_t,
279    origin: *const libc::c_char,
280    force: impl Into<libnvpair::boolean_t>,
281    raw: impl Into<libnvpair::boolean_t>,
282    fd: libc::c_int,
283) -> libc::c_int {
284    Lazy::force(&lzc::LIBZFS_CORE);
285    sys::lzc_receive(snapname, props, origin, force.into(), raw.into(), fd)
286}
287
288pub unsafe fn lzc_receive_resumable(
289    snapname: *const libc::c_char,
290    props: *mut libnvpair::nvlist_t,
291    origin: *const libc::c_char,
292    force: impl Into<libnvpair::boolean_t>,
293    raw: impl Into<libnvpair::boolean_t>,
294    fd: libc::c_int,
295) -> libc::c_int {
296    Lazy::force(&lzc::LIBZFS_CORE);
297    sys::lzc_receive_resumable(snapname, props, origin, force.into(), raw.into(), fd)
298}
299
300pub unsafe fn lzc_receive_with_header(
301    snapname: *const libc::c_char,
302    props: *mut libnvpair::nvlist_t,
303    origin: *const libc::c_char,
304    force: impl Into<libnvpair::boolean_t>,
305    resumable: impl Into<libnvpair::boolean_t>,
306    raw: impl Into<libnvpair::boolean_t>,
307    fd: libc::c_int,
308    begin_record: *const dmu_replay_record,
309) -> libc::c_int {
310    Lazy::force(&lzc::LIBZFS_CORE);
311    let force = force.into();
312    let resumable = resumable.into();
313    let raw = raw.into();
314    sys::lzc_receive_with_header(
315        snapname,
316        props,
317        origin,
318        force,
319        resumable,
320        raw,
321        fd,
322        begin_record,
323    )
324}
325
326pub unsafe fn lzc_receive_one(
327    snapname: *const libc::c_char,
328    props: *mut libnvpair::nvlist_t,
329    origin: *const libc::c_char,
330    force: impl Into<libnvpair::boolean_t>,
331    resumable: impl Into<libnvpair::boolean_t>,
332    raw: impl Into<libnvpair::boolean_t>,
333    input_fd: libc::c_int,
334    begin_record: *const dmu_replay_record,
335    cleanup_fd: libc::c_int,
336    read_bytes: *mut u64,
337    errflags: *mut u64,
338    action_handle: *mut u64,
339    errors: *mut *mut libnvpair::nvlist_t,
340) -> libc::c_int {
341    Lazy::force(&lzc::LIBZFS_CORE);
342    let force = force.into();
343    let resumable = resumable.into();
344    let raw = raw.into();
345    sys::lzc_receive_one(
346        snapname,
347        props,
348        origin,
349        force,
350        resumable,
351        raw,
352        input_fd,
353        begin_record,
354        cleanup_fd,
355        read_bytes,
356        errflags,
357        action_handle,
358        errors,
359    )
360}
361
362pub unsafe fn lzc_receive_with_cmdprops(
363    snapname: *const libc::c_char,
364    props: *mut libnvpair::nvlist_t,
365    cmdprops: *mut libnvpair::nvlist_t,
366    wkeydata: *mut u8,
367    wkeylen: libc::c_uint,
368    origin: *const libc::c_char,
369    force: impl Into<libnvpair::boolean_t>,
370    resumable: impl Into<libnvpair::boolean_t>,
371    raw: impl Into<libnvpair::boolean_t>,
372    input_fd: libc::c_int,
373    begin_record: *const dmu_replay_record,
374    cleanup_fd: libc::c_int,
375    read_bytes: *mut u64,
376    errflags: *mut u64,
377    action_handle: *mut u64,
378    errors: *mut *mut libnvpair::nvlist_t,
379) -> libc::c_int {
380    Lazy::force(&lzc::LIBZFS_CORE);
381    let force = force.into();
382    let resumable = resumable.into();
383    let raw = raw.into();
384    sys::lzc_receive_with_cmdprops(
385        snapname,
386        props,
387        cmdprops,
388        wkeydata,
389        wkeylen,
390        origin,
391        force,
392        resumable,
393        raw,
394        input_fd,
395        begin_record,
396        cleanup_fd,
397        read_bytes,
398        errflags,
399        action_handle,
400        errors,
401    )
402}
403
404pub unsafe fn lzc_send_space_resume_redacted(
405    snapname: *const libc::c_char,
406    from: *const libc::c_char,
407    flags: lzc_send_flags,
408    resumeobj: u64,
409    resumeoff: u64,
410    resume_bytes: u64,
411    redactbook: *const libc::c_char,
412    fd: libc::c_int,
413    spacep: *mut u64,
414) -> libc::c_int {
415    Lazy::force(&lzc::LIBZFS_CORE);
416    sys::lzc_send_space_resume_redacted(
417        snapname,
418        from,
419        flags,
420        resumeobj,
421        resumeoff,
422        resume_bytes,
423        redactbook,
424        fd,
425        spacep,
426    )
427}
428
429pub unsafe fn lzc_rollback(
430    fsname: *const libc::c_char,
431    snapnamebuf: *mut libc::c_char,
432    snapnamelen: libc::c_int,
433) -> libc::c_int {
434    Lazy::force(&lzc::LIBZFS_CORE);
435    sys::lzc_rollback(fsname, snapnamebuf, snapnamelen)
436}
437
438pub unsafe fn lzc_rollback_to(
439    fsname: *const libc::c_char,
440    snapname: *const libc::c_char,
441) -> libc::c_int {
442    Lazy::force(&lzc::LIBZFS_CORE);
443    sys::lzc_rollback_to(fsname, snapname)
444}
445
446pub unsafe fn lzc_rename(source: *const libc::c_char, target: *const libc::c_char) -> libc::c_int {
447    Lazy::force(&lzc::LIBZFS_CORE);
448    sys::lzc_rename(source, target)
449}
450
451pub unsafe fn lzc_sync(
452    pool_name: *const libc::c_char,
453    params: *mut libnvpair::nvlist_t,
454) -> libc::c_int {
455    Lazy::force(&lzc::LIBZFS_CORE);
456    sys::lzc_sync(pool_name, params, ptr::null_mut())
457}
458
459pub unsafe fn lzc_reopen(
460    pool_name: *const libc::c_char,
461    scrub_restart: impl Into<libnvpair::boolean_t>,
462) -> libc::c_int {
463    Lazy::force(&lzc::LIBZFS_CORE);
464    let scrub_restart = scrub_restart.into();
465    sys::lzc_reopen(pool_name, scrub_restart)
466}
467
468pub unsafe fn lzc_pool_checkpoint(pool: *const libc::c_char) -> libc::c_int {
469    Lazy::force(&lzc::LIBZFS_CORE);
470    sys::lzc_pool_checkpoint(pool)
471}
472
473pub unsafe fn lzc_pool_checkpoint_discard(pool: *const libc::c_char) -> libc::c_int {
474    Lazy::force(&lzc::LIBZFS_CORE);
475    sys::lzc_pool_checkpoint_discard(pool)
476}
477
478#[cfg(feature = "wait")]
479pub unsafe fn lzc_wait_fs(
480    name: *const libc::c_char,
481    activity: zfs_wait_activity_t,
482    waited: *mut libnvpair::boolean_t,
483) -> libc::c_int {
484    Lazy::force(&lzc::LIBZFS_CORE);
485    sys::lzc_wait_fs(name, activity, waited)
486}
razor_libzfscore/lib.rs

razor_libzfscore/
lib.rs
