The existing Rust bindings for nbdkit aren't very idiomatic Rust, and they
are missing a lot of features. So I've rewritten them. The new bindings
aren't backwards compatible, but I doubt that's a problem. Most likely,
nobody has tried to use them yet, since the crate hasn't even published to
crates.io. Please review the attached patch.
-Alan
commit 01a7f6644b4c94ebb764a81ee27b971f3a8cc218
Author: Alan Somers <[email protected]>
Date: Thu Jun 4 16:22:47 2020 -0600
plugins/rust: rewrite the Rust bindings
The new bindings:
* Are idiomatic Rust. They don't require the users to manipulate raw
pointers, use unsafe code, or define C ABI functions, and they use
standard Rust mechanisms for reporting errors.
* Log error messages.
* Support the previously-unsupport .extents, .preconnect, and .get_ready
callbacks.
* Use Semver versioning. Rust users will expect the crate to use
semver, not to track the version number of the nbdkit binary.
* Include tests.
* Include complete Rustdoc documentation.
* Support nbdkit_peer_name, nbdkit_shutdown, and nbdkit_stdio_safe.
* Destroy resources using the standard Drop trait, rather than a close
callback.
* Is publishable to crates.io.
diff --git a/configure.ac b/configure.ac
index 220b9b0a..c6ae27bd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1077,7 +1077,6 @@ AC_CONFIG_FILES([Makefile
plugins/python/Makefile
plugins/random/Makefile
plugins/ruby/Makefile
- plugins/rust/Cargo.toml
plugins/rust/Makefile
plugins/sh/Makefile
plugins/ssh/Makefile
diff --git a/plugins/rust/Cargo.toml b/plugins/rust/Cargo.toml
new file mode 100644
index 00000000..4c9cac35
--- /dev/null
+++ b/plugins/rust/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "nbdkit"
+version = "0.1.0"
+authors = ["Alan Somers <[email protected]>"]
+license = "BSD-2-Clause"
+edition = "2018"
+readme = "README.md"
+repository = "https://github.com/libguestfs/nbdkit";
+categories = ["api-bindings", "filesystem"]
+keywords = ["network-block-device", "nbd"]
+homepage = "http://libguestfs.org/";
+exclude = ["nbdkit-rust-plugin.*", "Cargo.toml.in", "Makefile*"]
+description = """
+Rust bindings to the NBDKit framework for creating Network Block Device servers
+"""
+
+[package.metadata.docs.rs]
+features = ["nix", "nightly-docs"]
+
+[features]
+# For building documentation only; no functional change to the library.
+nightly-docs = []
+
+[dependencies]
+bitflags = "1.2.1"
+libc = "0.2.71"
+nix = { version = "0.17.0", optional = true }
+
+[dev-dependencies]
+errno = "0.2.5"
+lazy_static = "1.2.0"
+# Need Mockall's PR #141, which hasn't yet been released
+mockall = { git = "https://github.com/asomers/mockall.git";, rev = "7c23b5cab5eca8a40ee3ab3270155f52bea4d658" }
+
+[[example]]
+name = "ramdisk"
+crate-type = ["cdylib"]
diff --git a/plugins/rust/Cargo.toml.in b/plugins/rust/Cargo.toml.in
deleted file mode 100644
index bb20adab..00000000
--- a/plugins/rust/Cargo.toml.in
+++ /dev/null
@@ -1,13 +0,0 @@
-[package]
-name = "nbdkit"
-version = "@VERSION@"
-authors = ["Richard W.M. Jones <[email protected]>"]
-edition = "2018"
-
-[dependencies]
-# lazy_static is used by the example.
-lazy_static = "1.2.0"
-
-[[example]]
-name = "ramdisk"
-crate-type = ["cdylib"]
diff --git a/plugins/rust/LICENSE b/plugins/rust/LICENSE
new file mode 100644
index 00000000..d900ae39
--- /dev/null
+++ b/plugins/rust/LICENSE
@@ -0,0 +1,25 @@
+Copyright 2020 Axcient
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
diff --git a/plugins/rust/Makefile.am b/plugins/rust/Makefile.am
index e3063231..2aa16235 100644
--- a/plugins/rust/Makefile.am
+++ b/plugins/rust/Makefile.am
@@ -32,7 +32,7 @@
include $(top_srcdir)/common-rules.mk
EXTRA_DIST = \
- Cargo.toml.in \
+ Cargo.toml \
examples/ramdisk.rs \
nbdkit-rust-plugin.pod \
src/lib.rs \
diff --git a/plugins/rust/README.md b/plugins/rust/README.md
new file mode 100644
index 00000000..aae523ef
--- /dev/null
+++ b/plugins/rust/README.md
@@ -0,0 +1,47 @@
+# NBDKit
+
+Rust bindings to the Network Block Device Kit library.
+
+[](https://crates.io/crates/nbdkit)
+[](https://docs.rs/nbdkit)
+
+## Overview
+
+NBDKit is a framework for developing Network Block Device servers. Most of
+the logic lives in the C code, but there are plugins to implement a server
+in another language, such as Rust.
+
+## Usage
+
+To create an NBD server in Rust, you must implement the `nbdkit::Server`
+trait, and register it with `nbdkit::plugin!`, like this:
+
+```toml
+[dependencies]
+nbdkit = "0.1.0"
+```
+
+```rust
+use nbdkit::*;
+
+#[derive(Default)]
+struct MyPlugin {
+ // ...
+}
+
+impl Server for MyPlugin {
+ // ...
+}
+
+plugin!(MyPlugin {write_at, trim, ...});
+```
+
+# Minimum Supported Rust Version (MSRV)
+
+`nbdkit` is supported on Rust 1.40.0 and higher. The MSRV will not be
+changed in the future without raising the major or minor version.
+
+# License
+
+`nbdkit` is primarily distributed under the 2-clause BSD liense. See
+LICENSE for details.
diff --git a/plugins/rust/examples/ramdisk.rs b/plugins/rust/examples/ramdisk.rs
index e9462fca..f92271ee 100644
--- a/plugins/rust/examples/ramdisk.rs
+++ b/plugins/rust/examples/ramdisk.rs
@@ -1,121 +1,52 @@
-// nbdkit
-// Copyright (C) 2019 Red Hat Inc.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// * Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// * Neither the name of Red Hat nor the names of its contributors may be
-// used to endorse or promote products derived from this software without
-// specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-// SUCH DAMAGE.
-
-extern crate nbdkit;
-
-#[macro_use]
-extern crate lazy_static;
-
-use std::ptr;
-use std::os::raw::{c_char, c_int, c_void};
+use lazy_static::lazy_static;
use std::sync::Mutex;
-
use nbdkit::*;
-use nbdkit::ThreadModel::*;
// The RAM disk.
lazy_static! {
static ref DISK: Mutex<Vec<u8>> = Mutex::new (vec![0; 100 * 1024 * 1024]);
}
-struct Handle {
+#[derive(Default)]
+struct RamDisk {
// Box::new doesn't allocate anything unless we put some dummy
// fields here. In a real implementation you would put per-handle
// data here as required.
_not_used: i32,
}
-extern fn ramdisk_thread_model () -> ThreadModel {
- Parallel
-}
+impl Server for RamDisk {
+ fn get_size(&self) -> Result<i64> {
+ Ok(DISK.lock().unwrap().len() as i64)
+ }
-extern fn ramdisk_open (_readonly: c_int) -> *mut c_void {
- let h = Handle {_not_used: 0};
- let h = Box::new(h);
- return Box::into_raw(h) as *mut c_void;
-}
+ fn name() -> &'static str {
+ "ramdisk"
+ }
-extern fn ramdisk_close (h: *mut c_void) {
- let h = unsafe { Box::from_raw(h as *mut Handle) };
- drop (h);
-}
+ fn open(_readonly: bool) -> Box<dyn Server> {
+ Box::new(RamDisk::default())
+ }
-extern fn ramdisk_get_size (_h: *mut c_void) -> i64 {
- return DISK.lock().unwrap().capacity() as i64;
-}
+ fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<()> {
+ let disk = DISK.lock().unwrap();
+ let ofs = offset as usize;
+ let end = ofs + buf.len();
+ buf.copy_from_slice(&disk[ofs..end]);
+ Ok(())
+ }
-extern fn ramdisk_pread (_h: *mut c_void, buf: *mut c_char, count: u32,
- offset: u64, _flags: u32) -> c_int {
- let offset = offset as usize;
- let count = count as usize;
- let disk = DISK.lock().unwrap();
- unsafe {
- ptr::copy_nonoverlapping (&disk[offset], buf as *mut u8, count);
+ fn thread_model() -> Result<ThreadModel> where Self: Sized {
+ Ok(ThreadModel::Parallel)
}
- return 0;
-}
-extern fn ramdisk_pwrite (_h: *mut c_void, buf: *const c_char, count: u32,
- offset: u64, _flags: u32) -> c_int {
- let offset = offset as usize;
- let count = count as usize;
- let mut disk = DISK.lock().unwrap();
- unsafe {
- ptr::copy_nonoverlapping (buf as *const u8, &mut disk[offset], count);
+ fn write_at(&self, buf: &[u8], offset: u64, _flags: Flags) -> Result<()> {
+ let mut disk = DISK.lock().unwrap();
+ let ofs = offset as usize;
+ let end = ofs + buf.len();
+ disk[ofs..end].copy_from_slice(buf);
+ Ok(())
}
- return 0;
}
-// Every plugin must define a public, C-compatible plugin_init
-// function which returns a pointer to a Plugin struct.
-#[no_mangle]
-pub extern fn plugin_init () -> *const Plugin {
- // Plugin name.
- // https://github.com/rust-lang/rfcs/issues/400
- let name = "ramdisk\0" as *const str as *const [c_char] as *const c_char;
-
- // Create a mutable plugin, setting the 4 required fields.
- let mut plugin = Plugin::new (
- name,
- ramdisk_open,
- ramdisk_get_size,
- ramdisk_pread
- );
- // Update any other fields as required.
- plugin.close = Some (ramdisk_close);
- plugin.pwrite = Some (ramdisk_pwrite);
- plugin.thread_model = Some (ramdisk_thread_model);
-
- // Return the pointer.
- let plugin = Box::new(plugin);
- // XXX Memory leak.
- return Box::into_raw(plugin);
-}
+plugin!(RamDisk {thread_model, write_at});
diff --git a/plugins/rust/nbdkit-rust-plugin.pod b/plugins/rust/nbdkit-rust-plugin.pod
index 77eb0c41..662f4240 100644
--- a/plugins/rust/nbdkit-rust-plugin.pod
+++ b/plugins/rust/nbdkit-rust-plugin.pod
@@ -24,46 +24,21 @@ L<https://github.com/libguestfs/nbdkit/blob/master/plugins/rust/examples/ramdisk
in the nbdkit source tree. The first describes the plugin interface
for Rust plugins and the second provides a simple example.
-We may change how Rust plugins are written in future to make them more
-idiomatic. At the moment each callback corresponds directly to a C
-callback - in fact each is called directly from the server.
+Your Rust code should define a public implementation of the C<Server> trait,
+and register it using the C<plugin!> macro.
-Your Rust code should define a public C<plugin_init> function which
-returns a pointer to a C<Plugin> struct. This struct is exactly
-compatible with the C struct used by C plugins.
-
- extern crate nbdkit;
use nbdkit::*;
- use nbdkit::ThreadModel::*;
- #[no_mangle]
- extern fn myplugin_thread_model () -> ThreadModel {
- SerializeAllRequests
+ #[derive(Default)]
+ struct MyPlugin {
+ // ...
}
- //... more functions
-
- pub extern fn plugin_init () -> *const Plugin {
- // Plugin name.
- let name = "myplugin\0"
- as *const str as *const [c_char] as *const c_char;
-
- // Create a mutable plugin, setting the 4 required fields.
- let mut plugin = Plugin::new (
- name,
- myplugin_open,
- myplugin_get_size,
- myplugin_pread
- );
- // Update any other fields as required.
- plugin.close = Some (myplugin_close);
- plugin.pwrite = Some (myplugin_pwrite);
- plugin.thread_model = Some (myplugin_thread_model);
-
- // Return the pointer.
- let plugin = Box::new(plugin);
- return Box::into_raw(plugin);
-}
+ impl Server for MyPlugin {
+ // ...
+ }
+
+ plugin!(MyPlugin {write_at, trim, ...});
=head2 Compiling a Rust nbdkit plugin
@@ -80,7 +55,7 @@ L<nbdkit-plugin(3)>):
=head2 Threads
-One of the members in C<Plugin> returned by C<plugin_init> is
+One of the methods of C<Server> is
C<thread_model>, which must return one of the values in the table
below. For more information on thread models, see
L<nbdkit-plugin(3)/THREADS>. If this optional function is not
@@ -101,17 +76,14 @@ C<nbdkit::ThreadModel::Parallel>.
=head2 Missing callbacks
-=over 4
-
-=item Missing: C<can_extents> and C<extents>
-
-These are not yet supported.
-
-=back
+All NBDKit callbacks are supported. However, the C<Server> trait has no
+C<close> method. Instead, you should implement C<Drop> if you need to clean
+up resources during destruction.
=head1 VERSION
-Rust plugins first appeared in nbdkit 1.12.
+Rust plugins first appeared in nbdkit 1.12. The crate was completely
+rewritten for nbdkit 1.21.9.
=head1 SEE ALSO
@@ -121,8 +93,8 @@ L<cargo(1)>.
=head1 AUTHORS
-Richard W.M. Jones
+Alan Somers
=head1 COPYRIGHT
-Copyright (C) 2019 Red Hat Inc.
+Copyright (C) 2020 Axcient.
diff --git a/plugins/rust/src/lib.rs b/plugins/rust/src/lib.rs
index 2d691e78..10eeded3 100644
--- a/plugins/rust/src/lib.rs
+++ b/plugins/rust/src/lib.rs
@@ -1,5 +1,5 @@
-// nbdkit
-// Copyright (C) 2019 Red Hat Inc.
+// vim: tw=80
+// Copyright (C) 2020 Axcient
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
@@ -12,10 +12,6 @@
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
-// * Neither the name of Red Hat nor the names of its contributors may be
-// used to endorse or promote products derived from this software without
-// specific prior written permission.
-//
// THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
@@ -29,17 +25,1057 @@
// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
-use std::mem;
-use std::os::raw::{c_char, c_int, c_void};
+//! Rust bindings to NBDKit.
+//!
+//! NBDKit is a toolkit for building Network Block Device servers.
+//!
+//! [https://github.com/libguestfs/nbdkit](https://github.com/libguestfs/nbdkit)
+#![cfg_attr(feature = "nightly-docs", feature(doc_cfg))]
+#![deny(missing_docs)]
+
+use bitflags::bitflags;
+#[cfg(feature = "nix")]
+#[cfg_attr(feature = "nightly-docs", doc(cfg(feature = "nix")))]
+pub use nix::sys::socket::{SockAddr, sockaddr_storage_to_addr};
+use std::{
+ ffi::{CStr, CString},
+ error,
+ fmt,
+ io,
+ mem,
+ os::raw::{c_char, c_int, c_void},
+ ptr,
+ slice,
+ sync::Once,
+};
+
+/// The error type used by [`Result`].
+#[derive(Debug)]
+pub struct Error {
+ source: Box<dyn error::Error + 'static>,
+ errno: i32
+}
+impl Error {
+ fn errno(&self) -> i32 {
+ self.errno
+ }
+
+ /// Create a new Error with a supplied errno.
+ ///
+ /// # Examples
+ /// ```
+ /// # use nbdkit::Error;
+ /// let e = Error::new(libc::EINVAL, "Invalid value for option foo");
+ /// ```
+ pub fn new<E>(errno: i32, error: E) -> Error
+ where E: Into<Box<dyn error::Error + 'static>>
+ {
+ Error {
+ source: error.into(),
+ errno
+ }
+ }
+}
+impl error::Error for Error {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ Some(&*self.source)
+ }
+}
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.source.fmt(f)
+ }
+}
+impl From<io::Error> for Error {
+ fn from(e: io::Error) -> Error {
+ Error {
+ errno: e.raw_os_error().unwrap_or(0),
+ source: Box::new(e),
+ }
+ }
+}
+
+/// The Result type returned by all [`Server`] callbacks.
+pub type Result<T> = std::result::Result<T, Error>;
+
+static mut INITIALIZED: bool = false;
+
+mod unreachable {
+ use super::*;
+ pub(super) fn config(_k: &str, _v: &str) -> Result<()> { unreachable!() }
+ pub(super) fn config_complete() -> Result<()> { unreachable!() }
+ pub(super) fn dump_plugin() { unreachable!() }
+ pub(super) fn open(_: bool) -> Box<dyn Server> { unreachable!() }
+ pub(super) fn preconnect(_: bool) -> Result<()> { unreachable!() }
+ pub(super) fn thread_model() -> Result<ThreadModel> { unreachable!() }
+}
+
+static mut CONFIG: fn(k: &str, v: &str) -> Result<()> = unreachable::config;
+static mut CONFIG_COMPLETE: fn() -> Result<()> = unreachable::config_complete;
+static mut CONFIG_HELP: Vec<u8> = Vec::new();
+static mut DESCRIPTION: Vec<u8> = Vec::new();
+static mut DUMP_PLUGIN: fn() = unreachable::dump_plugin;
+static mut GET_READY: fn() -> Result<()> = unreachable::config_complete;
+static mut LOAD: fn() = unreachable::dump_plugin;
+static mut LONGNAME: Vec<u8> = Vec::new();
+static mut MAGIC_CONFIG_KEY: Vec<u8> = Vec::new();
+static mut NAME: Vec<u8> = Vec::new();
+static mut OPEN: fn(readonly: bool) -> Box<dyn Server> = unreachable::open;
+static mut PRECONNECT: fn(readonly: bool) -> Result<()> = unreachable::preconnect;
+static mut THREAD_MODEL: fn() -> Result<ThreadModel> = unreachable::thread_model;
+static mut UNLOAD: fn() = unreachable::dump_plugin;
+static mut VERSION: Vec<u8> = Vec::new();
+static INIT: Once = Once::new();
+
+bitflags! {
+ /// Flags used by multiple [`Server`] methods
+ pub struct Flags: u32 {
+ /// This flag is used by the [`Server::zero`] callback.
+ ///
+ /// Indicates that the plugin may punch a hole instead of writing actual
+ /// zeros, but only if subsequent reads from that region will return
+ /// zeros. There is no way to disable this flag, although a plugin that
+ /// does not support trim as a way to write zeroes may ignore the flag
+ /// without violating expected semantics.
+ const MAY_TRIM = 0b00000001;
+
+ /// This flag represents Forced Unit Access semantics.
+ ///
+ /// It is used by the [`Server::write_at`], [`Server::zero`], and
+ /// [`Server::trim`] callbacks to indicate that the plugin must not
+ /// return a result until the action has landed in persistent storage.
+ /// This flag will not be sent to the plugin unless `can_fua` is
+ /// provided to [`plugin!`] and [`Server::can_fua`] returns
+ /// [`FuaFlags::Native`].
+ const FUA = 0b00000010;
+
+ /// Used with [`Server::extents`] to indicate that the client is only
+ /// requesting information about a single extent. The plugin may ignore
+ /// this flag, or as an optimization it may return
+ /// just a single extent.
+ const REQ_ONE = 0b00000100;
+
+ /// This flag is used by [`Server::zero`].
+ ///
+ /// If supplied, the plugin must decide up front if the implementation
+ /// is likely to be faster than a corresponding [`Server::write_at`]; if
+ /// not, then it must immediately fail with `ENOTSUP` or
+ /// `EOPNOTSUPP` and preferably without modifying the exported
+ /// image. It is acceptable to always fail a fast zero request (as a
+ /// fast failure is better than attempting the write only to find out
+ /// after the fact that it was not fast after all). Note that on Linux,
+ /// support for `ioctl(BLKZEROOUT)` is insufficient for determining
+ /// whether a zero request to a block device will be fast (because the
+ /// kernel will perform a slow fallback when needed).
+ const FAST_ZERO = 0b00001000;
+ }
+}
+
+/// Return values for [`Server::can_cache`]
+#[repr(i32)]
+pub enum CacheFlags {
+ /// Cache support is not advertised to the client.
+ None = 0,
+ /// Caching is emulated by the server calling [`Server::read_at`] and
+ /// ignoring the results.
+ Emulate = 1,
+ /// The [`Server::cache`] callback will be used.
+ Native = 2,
+}
+
+impl Into<i32> for CacheFlags {
+ fn into(self) -> i32 {
+ self as i32
+ }
+}
+
+/// Return values for [`Server::can_fua`]
+#[repr(i32)]
+pub enum FuaFlags {
+ /// FUA support is not advertised to the client
+ None = 0,
+ /// The [`Server::flush`] callback must work (even if [`Server::can_flush`]
+ /// returns false), and FUA support is emulated by calling `Server::flush`
+ /// after any write operation;
+ Emulate = 1,
+ /// The [`Server::write_at`], [`Server::zero`], and [`Server::trim`]
+ /// callbacks (if implemented) must handle the flag [`Flags::FUA`], by not
+ /// returning until that action has landed in persistent storage.
+ Native = 2,
+}
+
+impl Into<i32> for FuaFlags {
+ fn into(self) -> i32 {
+ self as i32
+ }
+}
+
+/// A plugin's maximum thread safety model
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(i32)]
+pub enum ThreadModel {
+ /// Only a single handle can be open at any time, and all requests happen
+ /// from one thread.
+ SerializeConnections = 0,
+
+ /// Multiple handles can be open at the same time, but requests are
+ /// serialized so that for the plugin as a whole only one
+ /// open/read/write/close (etc) request will be in progress at any time.
+ ///
+ /// This is a useful setting if the library you are using is not
+ /// thread-safe. However performance may not be good.
+ SerializeAllRequests = 1,
+
+ /// Multiple handles can be open and multiple data requests can happen in
+ /// parallel. However only one request will happen per handle at a time (but
+ /// requests on different handles might happen concurrently).
+ SerializeRequests = 2,
+
+ /// Multiple handles can be open and multiple data requests can happen in
+ /// parallel (even on the same handle). The server may reorder replies,
+ /// answering a later request before an earlier one.
+ ///
+ /// All the libraries you use must be thread-safe and reentrant, and any
+ /// code that creates a file descriptor should atomically set `FD_CLOEXEC`
+ /// if you do not want it accidentally leaked to another thread's child
+ /// process. You may also need to provide mutexes for fields in your
+ /// connection handle.
+ Parallel = 3,
+}
+
+/// Used by [`Server::extents`] to report extents to the client
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u32)]
+pub enum ExtentType {
+ /// A normal, allocated data extent
+ Allocated = 0,
+ /// An unallocated extent (hole) which does not read back as zeroes. Note
+ /// this should only be used in specialized circumstances such as when
+ /// writing a plugin for (or to emulate) certain SCSI drives which do not
+ /// guarantee that trimmed blocks read back as zeroes.
+ Hole = 1,
+ /// An allocated extent which is known to contain only zeroes.
+ Zero = 2,
+ /// An unallocated extent, a.k.a. a “hole”, which reads back as zeroes. This
+ /// is the normal type of hole applicable to most disks.
+ HoleZero = 3
+}
+
+/// Used by [`Server::extents`] to report extents to the client
+#[derive(Debug)]
+pub struct ExtentHandle(*mut c_void);
+
+impl ExtentHandle {
+ /// Report a single extent spanning `[offset .. offset + len)` back to the
+ /// client.
+ pub fn add(&mut self, offset: u64, len: u64, et: ExtentType) -> Result<()> {
+ let r = unsafe { nbdkit_add_extent(self.0, offset, len, et as u32) };
+ match r {
+ 0 => Ok(()),
+ -1 => Err(io::Error::last_os_error().into()),
+ x => panic!("Undocumented return value {} from nbdkit_add_extent", x)
+ }
+ }
+}
+
+/// All the FFI functions called by C code
+mod ffi {
+ use super::*;
+
+ macro_rules! can_method {
+ ( $meth:ident ) => {
+ pub(super) extern fn $meth(h: *mut c_void) -> c_int {
+ let server = unsafe { downcast(h) };
+ match server.$meth() {
+ Err(e) => {
+ set_error(e);
+ -1
+ },
+ Ok(x) => x.into(),
+ }
+ }
+ }
+ }
+
+ macro_rules! trim_like {
+ ( $meth:ident) => {
+ pub(super) extern fn $meth(h: *mut c_void,
+ count: u32,
+ offset: u64,
+ rawflags: u32) -> c_int
+ {
+ let server = unsafe { downcast(h) };
+ let flags = Flags::from_bits(rawflags)
+ .expect(&format!("Unknown flags value {:#x?}", rawflags));
+ match server.$meth(count, offset, flags) {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+ }
+ }
+
+ pub(super) extern fn cache(h: *mut c_void,
+ count: u32,
+ offset: u64,
+ _rawflags: u32) -> c_int
+ {
+ let server = unsafe { downcast(h) };
+ match server.cache(count, offset) {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ pub(super) extern fn close(selfp: *mut c_void) {
+ unsafe {
+ Box::from_raw(selfp as *mut Box<dyn Server>);
+ }
+ }
+
+ can_method!(can_cache);
+ can_method!(can_extents);
+ can_method!(can_flush);
+ can_method!(can_fua);
+ can_method!(can_fast_zero);
+ can_method!(can_multi_conn);
+ can_method!(can_write);
+ can_method!(can_trim);
+ can_method!(can_zero);
+
+ pub(super) extern fn config(k: *const c_char, v: *const c_char) -> c_int {
+ let key = match unsafe { CStr::from_ptr(k) }.to_str() {
+ Ok(s) => s,
+ Err(e) => {
+ let error = Error::new(libc::EINVAL, e.to_string());
+ set_error(error);
+ return -1;
+ }
+ };
+ let value = match unsafe { CStr::from_ptr(v) }.to_str() {
+ Ok(s) => s,
+ Err(e) => {
+ let error = Error::new(libc::EINVAL, e.to_string());
+ set_error(error);
+ return -1;
+ }
+ };
+ match unsafe { CONFIG(key, value) } {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ pub(super) extern fn config_complete() -> c_int {
+ match unsafe { CONFIG_COMPLETE() } {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ /// Deference the pointer into a trait object reference
+ ///
+ /// # Safety
+ ///
+ /// The pointer must be a valid pointer to `Box<Box<dyn Server>>`. The
+ /// pointer's lifetime must be valid for the duration of the returned
+ /// reference.
+ unsafe fn downcast<'a>(p: *const c_void) -> &'a dyn Server {
+ &**(p as *const Box<dyn Server>)
+ }
+
+ pub(super) extern fn dump_plugin() {
+ unsafe { DUMP_PLUGIN() }
+ }
+
+ // TODO: document REQ_ONE
+ pub(super) extern fn extents(h: *mut c_void,
+ count: u32,
+ offset: u64,
+ rawflags: u32,
+ extents: *mut c_void ) -> c_int
+ {
+ let server = unsafe { downcast(h) };
+ let mut exh = ExtentHandle(extents);
+ let flags = Flags::from_bits(rawflags).expect("Unknown extents flags");
+ match server.extents(count, offset, flags, &mut exh) {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ pub(super) extern fn flush(h: *mut c_void, _rawflags: u32) -> c_int {
+ let server = unsafe { downcast(h) };
+ match server.flush() {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
-// This struct describes the plugin ABI which your plugin_init()
-// function must return.
+ pub(super) extern fn get_ready() -> c_int {
+ match unsafe { GET_READY() } {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ pub(super) extern fn get_size(h: *mut c_void) -> i64 {
+ let server = unsafe { downcast(h) };
+ match server.get_size() {
+ Ok(size) => size,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ can_method!(is_rotational);
+
+ pub(super) extern fn load() {
+ unsafe { LOAD() }
+ }
+
+ pub(super) extern fn open(readonly: c_int) -> *mut c_void {
+ // We need to double-box to turn the trait object (fat pointer) into a
+ // thin pointer
+ let server = Box::new(unsafe{OPEN(readonly != 0)});
+ // Leak the memory to C. We'll get it back in close
+ Box::into_raw(server) as *mut c_void
+ }
+
+ pub(super) extern fn pread(h: *mut c_void,
+ bufp: *mut c_char,
+ count: u32,
+ offset: u64,
+ _flags: u32) -> c_int
+ {
+ let server = unsafe { downcast(h) };
+ let buf = unsafe {
+ slice::from_raw_parts_mut(bufp as *mut u8, count as usize)
+ };
+ match server.read_at(buf, offset) {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ pub(super) extern fn preconnect(readonly: c_int) -> c_int {
+ match unsafe { PRECONNECT(readonly != 0) } {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ pub(super) extern fn pwrite(h: *mut c_void,
+ bufp: *const c_char,
+ count: u32,
+ offset: u64,
+ rawflags: u32) -> c_int
+ {
+ let server = unsafe { downcast(h) };
+ let buf = unsafe {
+ slice::from_raw_parts(bufp as *mut u8, count as usize)
+ };
+ let flags = Flags::from_bits(rawflags).expect("Unknown pwrite flags");
+ match server.write_at(buf, offset, flags) {
+ Ok(()) => 0,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ fn set_error(e: Error) {
+ let fmt = CString::new("%s").unwrap();
+ let msg = CString::new(e.to_string()).expect("CString::new");
+ unsafe {
+ nbdkit_error(fmt.as_ptr(), msg.as_ptr());
+ nbdkit_set_error(e.errno());
+ }
+ }
+
+ pub(super) extern fn thread_model() -> c_int {
+ match unsafe { THREAD_MODEL() } {
+ Ok(x) => x as c_int,
+ Err(e) => {
+ set_error(e);
+ -1
+ }
+ }
+ }
+
+ trim_like!(trim);
+
+ pub(super) extern fn unload() {
+ unsafe { UNLOAD() }
+ }
+
+ trim_like!(zero);
+}
+
+
+/// Define the entry point for your plugin.
+///
+/// Any of the optional methods may be implemented. If so, each must be
+/// registered with [`plugin!`]. It is an error to register any method that you
+/// don't implement.
+// We want the argument names to show up without underscores in the API docs
+#[allow(unused_variables)]
+pub trait Server {
+ /// Indicates that the client intends to make further accesses to the given
+ /// data region.
+ ///
+ /// The nature of caching is not specified further by the NBD specification
+ /// (for example, a server may place limits on how much may be cached at
+ /// once, and there is no way to control if writes to a cached area have
+ /// write-through or write-back semantics). In fact, the cache command can
+ /// always fail and still be compliant, and success might not guarantee a
+ /// performance gain. If this callback is omitted, then the results of
+ /// [`Server::can_cache`] determine whether nbdkit will reject cache
+ /// requests, treat them as instant success, or emulate caching by calling
+ /// [`Server::pread` over the same region and ignoring the results.
+ fn cache(&self, count: u32, offset: u64) -> Result<()> {
+ unimplemented!()
+ }
+
+ /// Indicate level of cacheing support to the client.
+ ///
+ /// This is called during the option negotiation phase to find out if the
+ /// plugin supports a cache operation. The nature of the caching is
+ /// unspecified (including whether there are limits on how much can be
+ /// cached at once, and whether writes to a cached region have write-through
+ /// or write-back semantics), but the command exists to let clients issue a
+ /// hint to the server that they will be accessing that region of the
+ /// export.
+ fn can_cache(&self) -> Result<CacheFlags> { unimplemented!() }
+
+ /// Indicate to the client whether the plugin supports detecting allocated
+ /// (non-sparse) regions of the disk with the [`Server::extents`]
+ fn can_extents(&self) -> Result<bool> { unimplemented!() }
+
+ /// Indicate to the client wheter the plugin supports the flush-to-disk
+ /// operation.
+ fn can_flush(&self) -> Result<bool> { unimplemented!() }
+
+ /// Indicate to the client whether the plugin supports fast-zero requests.
+ fn can_fast_zero(&self) -> Result<bool> { unimplemented!() }
+
+ /// Indicate to the client whether the plugin supports Forced Unit Access
+ /// (FUA) flag on write, trim, and zero requests.
+ ///
+ /// If this callback is not implemented, then nbdkit checks whether
+ /// [`Server::flush`] is implemented,
+ /// exists, and behaves as if this function returns [`FuaFlags::None`] or
+ /// [`FuaFlags::Emulate`] as appropriate.
+ fn can_fua(&self) -> Result<FuaFlags> { unimplemented!() }
+
+ /// Indicate to the client whether the plugin is prepared to handle multiple
+ /// connections from a single client.
+ ///
+ /// If thie method returns `true` then a
+ /// client may try to open multiple connections to the nbdkit server and
+ /// spread requests across all connections to maximize parallelism. If it
+ /// returns `false` false (which is the default) then well-behaved clients
+ /// should only open a single connection, although we cannot control what
+ /// clients do in practice.
+ ///
+ /// Specifically it means that either the plugin does not cache requests at
+ /// all, or if it does cache them then the effects of a [`Server::flush`]
+ /// request or setting [`Flags::FUA`] on a write/trim/zero must be visible
+ /// across all connections to the plugin before the plugin replies to that
+ /// request.
+ fn can_multi_conn(&self) -> Result<bool> { unimplemented!() }
+
+ /// Indicate to the client whether the plugin supports the trim/discard
+ /// operation for punching holes in the backing store.
+ fn can_trim(&self) -> Result<bool> { unimplemented!() }
+
+ /// Indicates to the client whether the plugin supports writes
+ fn can_write(&self) -> Result<bool> { unimplemented!() }
+
+ /// Indicates to the client whether the [`Server::zero`] callback should be
+ /// used.
+ ///
+ /// Support for writing zeroes is still advertised to the client, so
+ /// returning false merely serves as a way to avoid complicating the
+ /// [`Server::zero`] callback to have to fail with `ENOTSUP` or
+ /// `EOPNOTSUPP` on the connections where it will never be more efficient
+ /// than using [`Server::write_at`] up front.
+ fn can_zero(&self) -> Result<bool> { unimplemented!() }
+
+ /// Supplies command-line parameters, one at a time, to the plugin.
+ ///
+ /// On the nbdkit command line, after the plugin filename, come an optional
+ /// list of key=value arguments. These are passed to the plugin through this
+ /// callback when the plugin is first loaded and before any connections are
+ /// accepted.
+ ///
+ /// This callback may be called zero or more times.
+ ///
+ /// The key will be a non-empty string beginning with an ASCII alphabetic
+ /// character (A-Z a-z). The rest of the key must contain only ASCII
+ /// alphanumeric plus period, underscore or dash characters (A-Z a-z 0-9 . _
+ /// -). The value may be an arbitrary string, including an empty string.
+ ///
+ /// The names of keys accepted by plugins is up to the plugin, but you
+ /// should probably look at other plugins and follow the same conventions.
+ fn config(key: &str, value: &str) -> Result<()> where Self: Sized {
+ unimplemented!()
+ }
+
+ /// This optional callback is called after all the configuration has been
+ /// passed to the plugin.
+ ///
+ /// It is a good place to do checks, for example that the user has passed
+ /// the required parameters to the plugin.
+ fn config_complete() -> Result<()> where Self: Sized { unimplemented!() }
+
+ /// This optional callback is called when the `nbdkit plugin --dump-plugin`
+ /// command is used. It should print any additional informative key=value
+ /// fields to stdout as needed. Prefixing the keys with the name of the
+ /// plugin will avoid conflicts.
+ fn dump_plugin() where Self: Sized { unimplemented!() }
+
+ /// This optional multi-line help message should summarize any key=value
+ /// parameters that it takes. It does not need to repeat what already
+ /// appears in [`Server::description`].
+ fn config_help() -> Option<&'static str> where Self: Sized { None }
+
+ /// An optional multi-line description of the plugin.
+ fn description() -> Option<&'static str> where Self: Sized { None }
+
+ /// During the data serving phase, this callback is used to detect
+ /// allocated, sparse and zeroed regions of the disk.
+ ///
+ /// This function will not be called if [`Server::can_extents`] returned `false`.
+ /// nbdkit's default behaviour in this case is to treat the whole virtual
+ /// disk as if it were allocated. Also, this function will not be called by
+ /// a client that does not request structured replies (the `--no-sr` option
+ /// of nbdkit can be used to test behavior when `extents` is unavailable to
+ /// the client).
+ ///
+ /// The callback should detect and return the list of extents overlapping
+ /// the range `[offset...offset+count)`. Each extent should be reported
+ /// by calling [`ExtentHandle::add`].
+ ///
+ /// The flags parameter of the `extents` callback may contain
+ /// [`Flags::REQ_ONE`]. This means that the client is only requesting
+ /// information about the extent overlapping `offset`. The plugin may ignore
+ /// this flag, or as an optimization it may return just a single extent for
+ /// offset.
+ // Alternatively, the method could be defined as returning a Vec of extent
+ // objects, rather than using the ExtentHandle. I'm not sure which would be
+ // more ergonomic, but this way requires fewer memory allocations.
+ fn extents(&self,
+ count: u32,
+ offset: u64,
+ flags: Flags,
+ extent_handle: &mut ExtentHandle)
+ -> Result<()>
+ {
+ unimplemented!()
+ }
+
+ /// During the data serving phase, this callback is used to sync the
+ /// backing store, ie. to ensure it has been completely written to a
+ /// permanent medium. If that is not possible then you can omit this
+ /// callback.
+ ///
+ /// This function will not be called directly by the client if
+ /// [`Server::can_flush`] returned `false`; however, it may still be called
+ /// by nbdkit if [`Server::can_fua`] returned [`FuaFlags::Emulate`].
+ fn flush(&self) -> Result<()> { unimplemented!() }
+
+ /// This optional callback is called before the server starts serving.
+ ///
+ /// It is called before the server forks or changes directory. It is the
+ /// last chance to do any global preparation that is needed to serve
+ /// connections.
+ fn get_ready() -> Result<()> where Self: Sized { unimplemented!() }
+
+ /// Return the size in bytes of the exported block device
+ fn get_size(&self) -> Result<i64>;
+
+ /// Return `true` if the backing store is a rotational medium (like a
+ /// traditional hard disk) as opposed to a non-rotating one like an SSD.
+ ///
+ /// This may cause the client to reorder requests to make them more
+ /// efficient for a slow rotating disk.
+ fn is_rotational(&self) -> Result<bool> { unimplemented!() }
+
+ /// This is called once just after the plugin is loaded into memory. You can
+ /// use this to perform any global initialization needed by the plugin.
+ fn load() where Self: Sized { unimplemented!() }
+
+ /// An optional free text name of the plugin. This field is used in error
+ /// messages.
+ fn longname() -> Option<&'static str> where Self: Sized { None }
+
+ /// This optional string can be used to set a "magic" key used when parsing
+ /// plugin parameters. It affects how "bare parameters" (those which do not
+ /// contain an = character) are parsed on the command line.
+ ///
+ /// If `magic_config_key().is_some()` then any bare parameters are passed to
+ /// the [`Server::config`] method as: `config (magic_config_key, argv[i]);`.
+ ///
+ /// If `magic_config_key().is_none()` then we behave as in nbdkit < 1.7: If
+ /// the first parameter on the command line is bare then it is passed to the
+ /// `Server::config` method as: `config("script", value);`. Any other bare
+ /// parameters give errors.
+ fn magic_config_key() -> Option<&'static str> where Self: Sized { None }
+
+ /// The name of the plugin.
+ ///
+ /// It must contain only ASCII alphanumeric characters and be unique amongst
+ /// all plugins.
+ fn name() -> &'static str where Self: Sized;
+
+ /// Allocate and return a new `Server` handle to the client.
+ ///
+ /// Called whenever a new client connects to the server. The `readonly`
+ /// flag informs the plugin that the server was started with the -r flag on
+ /// the command line which forces connections to be read-only. Note that the
+ /// plugin may *additionally* force the connection to be readonly (even if
+ /// this flag is false) by returning false from the [`Server::can_write`]
+ /// callback. So if your plugin can only serve read-only, you can ignore
+ /// this parameter.
+ fn open(readonly: bool) -> Box<dyn Server> where Self: Sized;
+
+ /// This optional callback is called when a TCP connection has been made to
+ /// the server. This happens early, before NBD or TLS negotiation. If TLS
+ /// authentication is required to access the server, then it has not been
+ /// negotiated at this point.
+ ///
+ /// For security reasons (to avoid denial of service attacks) this callback
+ /// should be written to be as fast and take as few resources as possible.
+ /// If you use this callback, only use it to do basic access control, such
+ /// as checking [`peername`] against a whitelist. It may be better to do
+ /// access control outside the server, for example using TCP wrappers or a
+ /// firewall.
+ ///
+ /// The `readonly` flag informs the plugin that the server was started with
+ /// the `-r` flag on the command line.
+ ///
+ /// Returning `Ok(())` will allow the connection to continue. If there is an
+ /// error or you want to deny the connection, return an error.
+ fn preconnect(readonly: bool) -> Result<()> where Self: Sized {
+ unimplemented!()
+ }
+
+ /// Read data from the backing store, starting at `offset`.
+ ///
+ /// The callback must read the entire range if it can. If it, it should
+ /// return an error.
+ fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<()>;
+
+ /// This optional callback is called after all the configuration has been
+ /// passed to the plugin.
+ ///
+ /// It can be used to force a stricter thread model than the default
+ /// ([`ThreadModel::Parallel`]).
+ fn thread_model() -> Result<ThreadModel> where Self: Sized { unimplemented!() }
+
+ /// Punch a hole in the backing store.
+ ///
+ /// This function will not be called if [`Server::can_trim`] returned
+ /// `false`. The parameter flags may include `Flags::FUA` on input based on
+ /// the result of [`Server::can_fua`].
+ fn trim(&self, count: u32, offset: u64, flags: Flags) -> Result<()> {
+ unimplemented!()
+ }
+
+ /// This may be called once just before the plugin is unloaded from memory.
+ fn unload() where Self: Sized { unimplemented!() }
+
+ /// An optional version string which is displayed in help and debugging
+ /// output.
+ fn version() -> Option<&'static str> where Self: Sized { None }
+
+ /// Write data to the backing store.
+ ///
+ /// The `flags` argument may include [`Flags::FUA`] based on the result of
+ /// [`Server::can_fua`].
+ ///
+ /// The callback must write the entire range if it can. If it, it should
+ /// return an error.
+ fn write_at(&self, buf: &[u8], offset: u64, flags: Flags) -> Result<()> {
+ unimplemented!()
+ }
+
+ /// Write consecutive zeros to the backing store.
+ ///
+ /// The callback must write the whole region if it can. The NBD protocol
+ /// doesn't allow partial writes (instead, these are errors).
+ ///
+ /// If this callback is omitted, or if it fails with `ENOTSUP` or
+ /// `EOPNOTSUPP` , then [`Server::write_at`] will be used as an
+ /// automatic fallback except when the client requested a fast zero.
+ ///
+ /// # Arguments
+ ///
+ /// * `count`: Length of the region to write in bytes
+ /// * `offset`: Offset of the region to write in the backing store.
+ /// * `flags`: May include [`Flags::MAY_TRIM`], [`Flags::FAST_ZERO`],
+ /// and/or [`Flags::FUA`].
+ fn zero(&self, count: u32, offset: u64, flags: Flags) -> Result<()> {
+ unimplemented!()
+ }
+}
+
+macro_rules! opt_method {
+ ( $self:ident, $method:ident ) => {
+ if $self.$method {Some(ffi::$method)} else {None}
+ };
+ ( $self:ident, $method:ident, $ffi_method:ident ) => {
+ if $self.$method {Some(ffi::$ffi_method)} else {None}
+ }
+}
+
+/// Used by (`plugin!`)[macro.plugin.html], but should never be accessed
+/// directly by the user.
+#[doc(hidden)]
+#[derive(Default)]
+pub struct Builder {
+ pub cache: bool,
+ pub can_cache: bool,
+ pub can_extents: bool,
+ pub can_flush: bool,
+ pub can_fast_zero: bool,
+ pub can_fua: bool,
+ pub can_multi_conn: bool,
+ pub can_trim: bool,
+ pub can_write: bool,
+ pub can_zero: bool,
+ pub config: bool,
+ pub config_complete: bool,
+ pub config_help: bool,
+ pub dump_plugin: bool,
+ pub extents: bool,
+ pub flush: bool,
+ pub get_ready: bool,
+ pub is_rotational: bool,
+ pub load: bool,
+ pub preconnect: bool,
+ pub thread_model: bool,
+ pub trim: bool,
+ pub unload: bool,
+ pub write_at: bool,
+ pub zero: bool,
+}
+
+impl Builder {
+ #[doc(hidden)]
+ pub fn into_ptr<S: Server>(self) -> *const Plugin {
+ INIT.call_once(|| {
+ unsafe {
+ assert!(!INITIALIZED);
+ INITIALIZED = true;
+ CONFIG = S::config;
+ CONFIG_COMPLETE = S::config_complete;
+ DUMP_PLUGIN = S::dump_plugin;
+ GET_READY = S::get_ready;
+ LOAD = S::load;
+ OPEN = S::open;
+ PRECONNECT = S::preconnect;
+ THREAD_MODEL = S::thread_model;
+ UNLOAD = S::unload;
+ NAME = CString::new(S::name()).unwrap().into_bytes_with_nul();
+ if let Some(s) = S::config_help() {
+ CONFIG_HELP = CString::new(s).unwrap().into_bytes_with_nul();
+ }
+ if let Some(s) = S::description() {
+ DESCRIPTION = CString::new(s).unwrap().into_bytes_with_nul();
+ }
+ if let Some(s) = S::longname() {
+ LONGNAME = CString::new(s).unwrap().into_bytes_with_nul();
+ }
+ if let Some(s) = S::magic_config_key() {
+ MAGIC_CONFIG_KEY = CString::new(s).unwrap()
+ .into_bytes_with_nul();
+ }
+ if let Some(s) = S::version() {
+ VERSION = CString::new(s).unwrap().into_bytes_with_nul();
+ }
+ };
+ });
+
+ let config_help = S::config_help()
+ .map(|_| unsafe {CONFIG_HELP.as_ptr()} as *const i8)
+ .unwrap_or(ptr::null());
+ let description = S::description()
+ .map(|_| unsafe {DESCRIPTION.as_ptr()} as *const i8)
+ .unwrap_or(ptr::null());
+ let longname = S::longname()
+ .map(|_| unsafe {LONGNAME.as_ptr()} as *const i8)
+ .unwrap_or(ptr::null());
+ let magic_config_key = S::magic_config_key()
+ .map(|_| unsafe {MAGIC_CONFIG_KEY.as_ptr()} as *const i8)
+ .unwrap_or(ptr::null());
+ let version = S::version()
+ .map(|_| unsafe {VERSION.as_ptr()} as *const i8)
+ .unwrap_or(ptr::null());
+ let plugin = Plugin {
+ _struct_size: mem::size_of::<Plugin>() as u64,
+ _api_version: 2,
+ _thread_model: ThreadModel::Parallel as c_int,
+ name: unsafe{ NAME.as_ptr() } as *const i8,
+ longname,
+ version,
+ description,
+ load: opt_method!(self, load),
+ unload: opt_method!(self, unload),
+ config: opt_method!(self, config),
+ config_complete: opt_method!(self, config_complete),
+ config_help,
+ open: ffi::open,
+ close: ffi::close,
+ get_size: ffi::get_size,
+ can_write: opt_method!(self, can_write),
+ can_flush: opt_method!(self, can_flush),
+ is_rotational: opt_method!(self, is_rotational),
+ can_trim: opt_method!(self, can_trim),
+ _pread_v1: None,
+ _pwrite_v1: None,
+ _flush_v1: None,
+ _trim_v1: None,
+ _zero_v1: None,
+ errno_is_preserved: 0,
+ dump_plugin: opt_method!(self, dump_plugin),
+ can_zero: opt_method!(self, can_zero),
+ can_fua: opt_method!(self, can_fua),
+ pread: ffi::pread,
+ pwrite: opt_method!(self, write_at, pwrite),
+ flush: opt_method!(self, flush),
+ trim: opt_method!(self, trim),
+ zero: opt_method!(self, zero),
+ magic_config_key,
+ can_multi_conn: opt_method!(self, can_multi_conn),
+ can_extents: opt_method!(self, can_extents),
+ extents: opt_method!(self, extents),
+ can_cache: opt_method!(self, can_cache),
+ cache: opt_method!(self, cache),
+ thread_model: opt_method!(self, thread_model),
+ can_fast_zero: opt_method!(self, can_fast_zero),
+ preconnect: opt_method!(self, preconnect),
+ get_ready: opt_method!(self, get_ready)
+ };
+ // Leak the memory to C. NBDKit will never give it back.
+ Box::into_raw(Box::new(plugin))
+ }
+
+ #[doc(hidden)]
+ pub fn new() -> Builder
+ {
+ Builder::default()
+ }
+
+}
+
+// C functions provided by the nbdkit binary
+// TODO: nbdkit_peer_name
+extern "C" {
+ fn nbdkit_add_extent(extents: *mut c_void, offset: u64, length: u64,
+ ty: u32) -> c_int;
+ fn nbdkit_error(fmt: *const c_char, ...);
+ fn nbdkit_export_name() -> *const c_char;
+ fn nbdkit_set_error(errno: c_int);
+ #[cfg(feature = "nix")]
+ fn nbdkit_peer_name( addr: *mut libc::sockaddr,
+ addrlen: *mut libc::socklen_t) -> c_int;
+ fn nbdkit_shutdown();
+ fn nbdkit_stdio_safe() -> c_int;
+}
+
+/// Return the optional NBD export name if one was negotiated with the current
+/// client
+///
+/// Note that this function must be called from one of nbdkit's own threads.
+/// That is, it can only be called in the same thread as one of the `Server`
+/// callbacks.
+pub fn export_name() -> std::result::Result<String, Box<dyn error::Error>> {
+ unsafe {
+ let p = nbdkit_export_name();
+ if p.is_null() {
+ return Err("No export name available".into());
+ }
+ CStr::from_ptr(p)
+ }.to_str()
+ .map(|s| s.to_owned())
+ .map_err(|e| Box::new(e) as Box<dyn error::Error>)
+}
+
+/// Is it safe to interact with stdin and stdout during the configuration phase?
+///
+/// This function is only relevant up through `config_complete`. After the
+/// configuration phase, the client should assume that stdin and stdout have
+/// been closed.
+pub fn is_stdio_safe() -> bool {
+ unsafe { nbdkit_stdio_safe() == 1 }
+}
+
+/// Return the peer (client) address, if available.
+///
+/// Note that this function must be called from one of nbdkit's own threads.
+/// That is, it can only be called in the same thread as one of the `Server`
+/// callbacks.
+#[cfg(any(feature = "nix", all(feature = "nightly-docs", rustdoc)))]
+#[cfg_attr(feature = "nightly-docs", doc(cfg(feature = "nix")))]
+pub fn peername() -> std::result::Result<SockAddr, Box<dyn error::Error>> {
+ let mut ss = mem::MaybeUninit::<libc::sockaddr_storage>::uninit();
+ let mut len = mem::size_of_val(&ss) as libc::socklen_t;
+ unsafe {
+ let sa = ss.as_mut_ptr() as *mut libc::sockaddr;
+ let r = nbdkit_peer_name(sa, &mut len as *mut _);
+ if r == -1 {
+ // Note that nbdkit_peer_name does _not_ set errno
+ return Err("No peer name available".into());
+ }
+ sockaddr_storage_to_addr(&ss.assume_init(), len as usize)
+ .map_err(|e| Box::new(e) as Box<dyn error::Error>)
+ }
+}
+
+/// Request nbdkit to asynchronously and safely shutdown the server.
+pub fn shutdown() {
+ unsafe { nbdkit_shutdown() };
+}
+
+#[doc(hidden)]
#[repr(C)]
pub struct Plugin {
// Do not modify these three fields directly.
- _struct_size: u64,
- _api_version: c_int,
- _thread_model: c_int,
+ #[doc(hidden)] pub _struct_size: u64,
+ #[doc(hidden)] pub _api_version: c_int,
+ #[doc(hidden)] pub _thread_model: c_int,
pub name: *const c_char,
pub longname: *const c_char,
@@ -49,12 +1085,12 @@ pub struct Plugin {
pub load: Option<extern fn ()>,
pub unload: Option<extern fn ()>,
- pub config: Option<extern fn (*const c_char, *const c_char)>,
+ pub config: Option<extern fn (*const c_char, *const c_char) -> c_int>,
pub config_complete: Option<extern fn () -> c_int>,
pub config_help: *const c_char,
pub open: extern fn (c_int) -> *mut c_void,
- pub close: Option<extern fn (*mut c_void)>,
+ pub close: extern fn (*mut c_void),
pub get_size: extern fn (*mut c_void) -> i64,
@@ -64,13 +1100,13 @@ pub struct Plugin {
pub can_trim: Option<extern fn (*mut c_void) -> c_int>,
// Slots for old v1 API functions.
- _pread_v1: Option<extern fn ()>,
- _pwrite_v1: Option<extern fn ()>,
- _flush_v1: Option<extern fn ()>,
- _trim_v1: Option<extern fn ()>,
- _zero_v1: Option<extern fn ()>,
+ #[doc(hidden)] pub _pread_v1: Option<extern fn ()>,
+ #[doc(hidden)] pub _pwrite_v1: Option<extern fn ()>,
+ #[doc(hidden)] pub _flush_v1: Option<extern fn ()>,
+ #[doc(hidden)] pub _trim_v1: Option<extern fn ()>,
+ #[doc(hidden)] pub _zero_v1: Option<extern fn ()>,
- errno_is_preserved: c_int,
+ #[doc(hidden)] pub errno_is_preserved: c_int,
pub dump_plugin: Option<extern fn ()>,
@@ -95,77 +1131,199 @@ pub struct Plugin {
pub can_multi_conn: Option<extern fn (h: *mut c_void) -> c_int>,
- // Slots for extents functions, which needs more integration.
- _can_extents: Option<extern fn ()>,
- _extents: Option<extern fn ()>,
+ pub can_extents: Option<extern fn (h: *mut c_void) -> c_int>,
+ pub extents: Option<extern fn (h: *mut c_void,
+ count: u32,
+ offset: u64,
+ rawflags: u32,
+ extent_handle: *mut c_void) -> c_int>,
pub can_cache: Option<extern fn (h: *mut c_void) -> c_int>,
pub cache: Option<extern fn (h: *mut c_void,
count: u32, offset: u64,
flags: u32) -> c_int>,
- pub thread_model: Option<extern fn () -> ThreadModel>,
+ pub thread_model: Option<extern fn () -> c_int>,
pub can_fast_zero: Option<extern fn (h: *mut c_void) -> c_int>,
+ pub preconnect: Option<extern fn(readonly: c_int) -> c_int>,
+ pub get_ready: Option<extern fn() -> c_int>,
}
-#[repr(C)]
-pub enum ThreadModel {
- SerializeConnections = 0,
- SerializeAllRequests = 1,
- SerializeRequests = 2,
- Parallel = 3,
+/// Register your plugin with NBDKit.
+///
+/// Declare which optional methods it supports by supplying each as an argument.
+///
+/// # Examples
+///
+/// ```
+/// # use nbdkit::*;
+/// struct MyPlugin{
+/// // ...
+/// }
+/// impl Server for MyPlugin {
+/// fn get_size(&self) -> Result<i64> {
+/// # unimplemented!();
+/// // ...
+/// }
+///
+/// fn name() -> &'static str {
+/// "my_plugin"
+/// }
+///
+/// fn open(_readonly: bool) -> Box<dyn Server> {
+/// # unimplemented!();
+/// // ...
+/// }
+///
+/// fn read_at(&self, buf: &mut [u8], offs: u64) -> Result<()> {
+/// # unimplemented!();
+/// // ...
+/// }
+/// fn write_at(&self, buf: &[u8], offs: u64, flags: Flags) -> Result<()> {
+/// # unimplemented!();
+/// // ...
+/// }
+/// }
+///
+/// plugin!(MyPlugin {write_at});
+/// ```
+#[macro_export]
+macro_rules! plugin {
+ ( $cls:path { $($feat:ident),* } ) => {
+ #[no_mangle]
+ pub extern fn plugin_init () -> *const Plugin {
+ let mut plugin = Builder::new();
+ $(plugin.$feat = true;)*
+ plugin.into_ptr::<$cls>()
+ }
+ }
}
-impl Plugin {
- pub fn new (name: *const c_char,
- open: extern fn (c_int) -> *mut c_void,
- get_size: extern fn (*mut c_void) -> i64,
- pread: extern fn (h: *mut c_void, buf: *mut c_char,
- count: u32, offset: u64,
- flags: u32) -> c_int) -> Plugin {
- Plugin {
- _struct_size: mem::size_of::<Plugin>() as u64,
- _api_version: 2,
- _thread_model: ThreadModel::Parallel as c_int,
- name: name,
- longname: std::ptr::null(),
- version: std::ptr::null(),
- description: std::ptr::null(),
- load: None,
- unload: None,
- config: None,
- config_complete: None,
- config_help: std::ptr::null(),
- open: open,
- close: None,
- get_size: get_size,
- can_write: None,
- can_flush: None,
- is_rotational: None,
- can_trim: None,
- _pread_v1: None,
- _pwrite_v1: None,
- _flush_v1: None,
- _trim_v1: None,
- _zero_v1: None,
- errno_is_preserved: 0,
- dump_plugin: None,
- can_zero: None,
- can_fua: None,
- pread: pread,
- pwrite: None,
- flush: None,
- trim: None,
- zero: None,
- magic_config_key: std::ptr::null(),
- can_multi_conn: None,
- _can_extents: None,
- _extents: None,
- can_cache: None,
- cache: None,
- thread_model: None,
- can_fast_zero: None,
+#[cfg(test)]
+mod t {
+ #[cfg(feature = "nix")]
+ mod peername {
+ use super::super::*;
+ use lazy_static::lazy_static;
+ use mockall::{mock, predicate::*};
+ use std::sync::Mutex;
+
+ lazy_static! {
+ /// Mediates access to MockNbdkit's global expectations
+ /// Any test that sets an expectation on a static method
+ /// grab this mutex
+ static ref MOCK_NBDKIT_MTX: Mutex<()> = Mutex::new(());
+ }
+
+ mock! {
+ pub Nbdkit {
+ fn peer_name(addr: *mut libc::sockaddr,
+ addrlen: *mut libc::socklen_t) -> c_int;
+ }
+ }
+
+ #[no_mangle]
+ extern fn nbdkit_peer_name( addr: *mut libc::sockaddr,
+ addrlen: *mut libc::socklen_t) -> c_int
+ {
+ MockNbdkit::peer_name(addr, addrlen)
+ }
+
+ #[test]
+ fn error() {
+ let _m = MOCK_NBDKIT_MTX.lock().unwrap();
+ let ctx = MockNbdkit::peer_name_context();
+ ctx.expect()
+ // Since nbdkit_peer_name does not set errno, all types of
+ // errors are indistinguishable to a plugin
+ .return_const(-1);
+ let e = peername().unwrap_err();
+ ctx.checkpoint();
+ assert_eq!("No peer name available", e.to_string());
+ }
+
+ #[test]
+ fn in4() {
+ let _m = MOCK_NBDKIT_MTX.lock().unwrap();
+ let ctx = MockNbdkit::peer_name_context();
+ ctx.expect()
+ .withf(|_, len| {
+ let l = unsafe {**len as usize};
+ l == mem::size_of::<libc::sockaddr_storage>()
+ }).returning(|sa, sl| {
+ let sin = sa as *mut libc::sockaddr_in;
+ unsafe {
+ *sin = libc::sockaddr_in {
+ sin_family: libc::AF_INET as libc::sa_family_t,
+ sin_port: u16::from_le_bytes([4, 0xd2]),
+ sin_addr: libc::in_addr {
+ s_addr: u32::from_le_bytes([127, 0, 0, 1])
+ },
+ .. mem::zeroed()
+ };
+ *sl = mem::size_of::<libc::sockaddr_in>()
+ as libc::socklen_t;
+ }
+ 0
+ });
+ assert_eq!("127.0.0.1:1234", peername().unwrap().to_str());
+ ctx.checkpoint();
+ }
+
+ #[test]
+ fn in6() {
+ let _m = MOCK_NBDKIT_MTX.lock().unwrap();
+ let ctx = MockNbdkit::peer_name_context();
+ ctx.expect()
+ .withf(|_, len| {
+ let l = unsafe {**len as usize};
+ l == mem::size_of::<libc::sockaddr_storage>()
+ }).returning(|sa, sl| {
+ let sin6 = sa as *mut libc::sockaddr_in6;
+ unsafe {
+ *sin6 = libc::sockaddr_in6 {
+ sin6_family: libc::AF_INET6 as libc::sa_family_t,
+ sin6_port: u16::from_le_bytes([4, 0xd2]),
+ sin6_addr: libc::in6_addr {
+ s6_addr: [0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1],
+ },
+ .. mem::zeroed()
+ };
+ *sl = mem::size_of::<libc::sockaddr_in6>()
+ as libc::socklen_t;
+ }
+ 0
+ });
+ assert_eq!("[::1]:1234", peername().unwrap().to_str());
+ ctx.checkpoint();
+ }
+
+ #[test]
+ fn un() {
+ let _m = MOCK_NBDKIT_MTX.lock().unwrap();
+ let ctx = MockNbdkit::peer_name_context();
+ ctx.expect()
+ .withf(|_, len| {
+ let l = unsafe {**len as usize};
+ l == mem::size_of::<libc::sockaddr_storage>()
+ }).returning(|sa, sl| {
+ let sun = sa as *mut libc::sockaddr_un;
+
+ unsafe {
+ *sun = mem::zeroed();
+ (*sun).sun_family = libc::AF_UNIX as libc::sa_family_t;
+ ptr::copy_nonoverlapping(
+ b"/tmp/foo.sock\0".as_ptr() as *const i8,
+ (*sun).sun_path.as_mut_ptr(), 14);
+ *sl = mem::size_of::<libc::sockaddr_un>()
+ as libc::socklen_t;
+ }
+ 0
+ });
+ assert_eq!("/tmp/foo.sock", peername().unwrap().to_str());
+ ctx.checkpoint();
}
}
}
diff --git a/plugins/rust/tests/bare_bones.rs b/plugins/rust/tests/bare_bones.rs
new file mode 100644
index 00000000..c77e1036
--- /dev/null
+++ b/plugins/rust/tests/bare_bones.rs
@@ -0,0 +1,121 @@
+//vim: tw=80
+//! A bare bones plugin that only defines the minimum callbacks
+// Test cases for different plugins must be run in separate processes due to the
+// one-time initialized global state.
+
+use nbdkit::*;
+use std::os::raw::c_char;
+use std::sync::Once;
+
+mod common;
+use common::*;
+
+static mut PLUGIN: Option<*const Plugin> = None;
+static INIT: Once = Once::new();
+
+plugin!(MockServer{});
+
+// One-time initialization of the plugin
+pub fn initialize() {
+ INIT.call_once(|| {
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+ let config_help_ctx = MockServer::config_help_context();
+ config_help_ctx.expect()
+ .return_const(None);
+ let desc_ctx = MockServer::description_context();
+ desc_ctx.expect()
+ .return_const(None);
+ let longname_ctx = MockServer::longname_context();
+ longname_ctx.expect()
+ .return_const(None);
+ let magic_config_key_ctx = MockServer::magic_config_key_context();
+ magic_config_key_ctx.expect()
+ .return_const(Some("magic_config_key"));
+ let name_ctx = MockServer::name_context();
+ name_ctx.expect()
+ .return_const("Mock NBD Server");
+ let version_ctx = MockServer::version_context();
+ version_ctx.expect()
+ .return_const(None);
+ unsafe {
+ PLUGIN = Some(plugin_init());
+ }
+ });
+}
+
+fn with_fixture<F: FnMut(&mut Fixture)>(mut f: F) {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let mut mock = Box::new(MockServer::default());
+ mock.expect_get_size()
+ .returning(|| Ok(0x4200));
+ let mockp = (&mut mock) as *mut Box<MockServer>;
+ let open_ctx = MockServer::open_context();
+ open_ctx.expect()
+ .return_once(|_| mock);
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+ let handle = ((*plugin).open)(0);
+ let mut fixture = Fixture {
+ mockp,
+ plugin,
+ handle
+ };
+
+ f(&mut fixture);
+
+ ((*plugin).close)(handle);
+}
+
+
+#[test]
+fn open_close() {
+ with_fixture(|fixture| {
+ let size = (fixture.plugin.get_size)(fixture.handle);
+ assert_eq!(0x4200, size);
+ });
+}
+
+mod pread {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_read_at()
+ .returning(|_, _| Err(Error::new(libc::EIO, "Mock error")));
+ let mut buf = vec![0u8; 512];
+ assert_eq!(-1, (fixture.plugin.pread)(fixture.handle,
+ buf.as_mut_ptr() as *mut c_char,
+ buf.len() as u32,
+ 1024,
+ 0));
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("Mock error", *e.borrow()));
+
+ });
+ }
+
+ #[test]
+ fn ok() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_read_at()
+ .withf(|buf, offset|
+ buf.len() == 512 &&
+ *offset == 1024
+ ).returning(|buf, _offset| {
+ buf[0..10].copy_from_slice(b"0123456789");
+ Ok(())
+ });
+ let mut buf = vec![0u8; 512];
+ assert_eq!(0, (fixture.plugin.pread)(fixture.handle,
+ buf.as_mut_ptr() as *mut c_char,
+ buf.len() as u32,
+ 1024,
+ 0));
+ assert_eq!(&buf[0..10], b"0123456789");
+ });
+ }
+}
diff --git a/plugins/rust/tests/common/mod.rs b/plugins/rust/tests/common/mod.rs
new file mode 100644
index 00000000..46c9b0ac
--- /dev/null
+++ b/plugins/rust/tests/common/mod.rs
@@ -0,0 +1,104 @@
+//vim: tw=80
+use lazy_static::lazy_static;
+use mockall::mock;
+use std::{
+ cell::RefCell,
+ ffi::{CString, CStr},
+ os::raw::{c_char, c_int, c_void},
+ sync::Mutex
+};
+
+use nbdkit::*;
+
+thread_local!(pub static ERRMSG: RefCell<String> = RefCell::new(String::new()));
+thread_local!(pub static ERRNO: RefCell<i32> = RefCell::new(0));
+
+lazy_static! {
+ /// Mediates access to MockServer's global expectations
+ /// Any test that sets an expectation on a static method (like `open`) must
+ /// grab this mutex
+ pub static ref MOCK_SERVER_MTX: Mutex<()> = Mutex::new(());
+}
+
+mock!{
+ pub Server {}
+ trait Server {
+ fn cache(&self, count: u32, offset: u64) -> Result<()>;
+ fn can_cache(&self) -> Result<CacheFlags>;
+ fn can_extents(&self) -> Result<bool>;
+ fn can_fast_zero(&self) -> Result<bool>;
+ fn can_flush(&self) -> Result<bool>;
+ fn can_fua(&self) -> Result<FuaFlags>;
+ fn can_multi_conn(&self) -> Result<bool>;
+ fn can_trim(&self) -> Result<bool>;
+ fn can_write(&self) -> Result<bool>;
+ fn can_zero(&self) -> Result<bool>;
+ fn config(k: &str, v: &str) -> Result<()> where Self: Sized;
+ fn config_complete() -> Result<()> where Self: Sized;
+ fn config_help() -> Option<&'static str> where Self: Sized;
+ fn description() -> Option<&'static str> where Self: Sized;
+ fn dump_plugin() where Self: Sized;
+ fn extents(&self, c: u32, o: u64, f: Flags, e: &mut ExtentHandle)
+ -> Result<()>;
+ fn flush(&self) -> Result<()>;
+ fn get_ready() -> Result<()> where Self: Sized;
+ fn get_size(&self) -> Result<i64>;
+ fn is_rotational(&self) -> Result<bool>;
+ fn load() where Self: Sized;
+ fn longname() -> Option<&'static str> where Self: Sized;
+ fn magic_config_key() -> Option<&'static str> where Self: Sized;
+ fn name() -> &'static str where Self: Sized;
+ fn open(readonly: bool) -> Box<dyn Server> where Self: Sized;
+ fn preconnect(readonly: bool) -> Result<()> where Self: Sized;
+ fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<()>;
+ fn thread_model() -> Result<ThreadModel> where Self: Sized;
+ fn trim(&self, count: u32, offset: u64, flags: Flags) -> Result<()>;
+ fn unload() where Self: Sized;
+ fn version() -> Option<&'static str> where Self: Sized;
+ fn write_at(&self, _buf: &[u8], _offset: u64, _flags: Flags) -> Result<()>;
+ fn zero(&self, count: u32, offset: u64, flags: Flags) -> Result<()>;
+ }
+}
+
+mock! {
+ pub NbdkitAddExtent {
+ fn add(extents: *mut c_void, offset: u64, len: u64, ty: u32) -> c_int;
+
+ }
+}
+
+#[no_mangle]
+extern fn nbdkit_add_extent(extents: *mut c_void, offset: u64, len: u64, ty: u32)
+ -> c_int
+{
+ MockNbdkitAddExtent::add(extents, offset, len, ty)
+}
+
+// XXX The actual C function is variadic, but stable Rust can't create variadic
+// extern functions yet. So we pretend that it has two arguments.
+// https://github.com/rust-lang/rust/issues/44930
+// extern fn nbdkit_error(fmt: *const c_char, ...);
+#[no_mangle]
+extern fn nbdkit_error(fmt: *const c_char, msg: *const c_char) {
+ assert_eq!(
+ unsafe {CStr::from_ptr(fmt) },
+ CString::new("%s").unwrap().as_c_str()
+ );
+ ERRMSG.with(|m| *m.borrow_mut() = unsafe {
+ CStr::from_ptr(msg)
+ }.to_str()
+ .unwrap()
+ .to_owned()
+ );
+}
+#[no_mangle]
+extern fn nbdkit_set_error(errno: c_int) {
+ ERRNO.with(|e| *e.borrow_mut() = errno);
+}
+
+/// Holds common setup stuff needed by most test cases
+pub struct Fixture<'a> {
+ pub mockp: *mut Box<MockServer>,
+ pub plugin: &'a Plugin,
+ pub handle: *mut c_void
+}
diff --git a/plugins/rust/tests/full_featured.rs b/plugins/rust/tests/full_featured.rs
new file mode 100644
index 00000000..c8f5df0a
--- /dev/null
+++ b/plugins/rust/tests/full_featured.rs
@@ -0,0 +1,669 @@
+//vim: tw=80
+//! A full-featured plugin that implements all optional callbacks
+// Test cases for different plugins must be run in separate processes due to the
+// one-time initialized global state.
+
+use errno::{Errno, set_errno};
+use mockall::predicate::*;
+use nbdkit::*;
+use std::{
+ ffi::CStr,
+ sync::Once,
+ os::raw::c_char,
+ ptr
+};
+
+mod common;
+use common::*;
+
+static mut PLUGIN: Option<*const Plugin> = None;
+static INIT: Once = Once::new();
+
+plugin!(MockServer{
+ cache,
+ can_cache,
+ can_extents,
+ can_fast_zero,
+ can_flush,
+ can_fua,
+ can_multi_conn,
+ can_trim,
+ can_write,
+ can_zero,
+ config,
+ config_complete,
+ config_help,
+ dump_plugin,
+ extents,
+ flush,
+ get_ready,
+ is_rotational,
+ load,
+ preconnect,
+ thread_model,
+ trim,
+ unload,
+ write_at,
+ zero
+});
+
+// One-time initialization of the plugin
+pub fn initialize() {
+ INIT.call_once(|| {
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+ let config_help_ctx = MockServer::config_help_context();
+ config_help_ctx.expect()
+ .return_const(Some("Mock config help"));
+ let desc_ctx = MockServer::description_context();
+ desc_ctx.expect()
+ .return_const(Some("Mock description"));
+ let longname_ctx = MockServer::longname_context();
+ longname_ctx.expect()
+ .return_const(Some("Mock long name"));
+ let magic_config_key_ctx = MockServer::magic_config_key_context();
+ magic_config_key_ctx.expect()
+ .return_const(Some("magic_config_key"));
+ let name_ctx = MockServer::name_context();
+ name_ctx.expect()
+ .return_const("Mock NBD Server");
+ let version_ctx = MockServer::version_context();
+ version_ctx.expect()
+ .return_const("3.14.159");
+ unsafe {
+ PLUGIN = Some(plugin_init());
+ }
+ });
+}
+
+fn with_fixture<F: FnMut(&mut Fixture)>(mut f: F) {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let mut mock = Box::new(MockServer::default());
+ mock.expect_get_size()
+ .returning(|| Ok(0x4200));
+ let mockp = (&mut mock) as *mut Box<MockServer>;
+ let open_ctx = MockServer::open_context();
+ open_ctx.expect()
+ .return_once(|_| mock);
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+ let handle = ((*plugin).open)(0);
+ open_ctx.checkpoint(); // clear expectations for MockServer::open
+ let mut fixture = Fixture {
+ mockp,
+ plugin,
+ handle
+ };
+
+ f(&mut fixture);
+
+ ((*plugin).close)(handle);
+}
+
+/// Helper for testing methods that take a handle and return a boolean
+macro_rules! can_method {
+ ( $meth:ident, $expect_meth:ident ) => {
+ mod $meth {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.$expect_meth()
+ .returning(|| Err(Error::new(libc::EIO, "I/O Schmerror")));
+ let $meth = fixture.plugin.$meth.as_ref().unwrap();
+ assert_eq!(-1, ($meth)(fixture.handle));
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("I/O Schmerror", *e.borrow()));
+ });
+ }
+
+ #[test]
+ fn ok() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.$expect_meth()
+ .returning(|| Ok(true));
+ let $meth = fixture.plugin.$meth.as_ref().unwrap();
+ assert_ne!(0, ($meth)(fixture.handle));
+ });
+ }
+ }
+ }
+}
+
+/// Helper for testing methods that take a handle and return a special Flags
+macro_rules! can_cache_like {
+ ( $meth:ident, $flags_ty:ident, $expect_meth:ident ) => {
+ mod $meth {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.$expect_meth()
+ .returning(|| Err(Error::new(libc::EIO, "I/O Schmerror")));
+ let $meth = fixture.plugin.$meth.as_ref().unwrap();
+ assert_eq!(-1, ($meth)(fixture.handle));
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("I/O Schmerror", *e.borrow()));
+ });
+ }
+
+ #[test]
+ fn ok() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.$expect_meth()
+ .returning(|| Ok($flags_ty::Emulate));
+ let $meth = fixture.plugin.$meth.as_ref().unwrap();
+ assert_eq!(1, ($meth)(fixture.handle));
+ });
+ }
+ }
+ }
+}
+
+/// Helper for testing methods with signatures like trim
+macro_rules! trim_like {
+ ( $meth:ident, $expect_meth:ident ) => {
+ mod $meth {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.$expect_meth()
+ .with(eq(42), eq(1024), eq(Flags::FUA))
+ .returning(|_, _, _| {
+ Err(Error::new(libc::EIO, "I/O Schmerror"))
+ });
+ let $meth = fixture.plugin.$meth.as_ref().unwrap();
+ assert_eq!(-1, ($meth)(fixture.handle,42, 1024, 2));
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("I/O Schmerror", *e.borrow()));
+ });
+ }
+
+ #[test]
+ fn ok() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.$expect_meth()
+ .with(eq(42), eq(1024), eq(Flags::FUA))
+ .returning(|_, _, _| Ok(()));
+ let $meth = fixture.plugin.$meth.as_ref().unwrap();
+ assert_eq!(0, ($meth)(fixture.handle, 42, 1024, 2));
+ });
+ }
+ }
+ }
+}
+
+/// Helper for testing methods with signatures like unload
+macro_rules! unload_like {
+ ( $meth:ident, $ctx_meth:ident ) => {
+ mod $meth {
+ use super::*;
+
+ #[test]
+ fn ok() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let ctx = MockServer::$ctx_meth();
+ ctx.expect()
+ .return_const(());
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let $meth = plugin.$meth.as_ref().unwrap();
+ $meth();
+ ctx.checkpoint();
+ }
+ }
+ }
+}
+
+can_cache_like!(can_cache, CacheFlags, expect_can_cache);
+can_method!(can_extents, expect_can_extents);
+can_method!(can_fast_zero, expect_can_fast_zero);
+can_method!(can_flush, expect_can_flush);
+can_cache_like!(can_fua, FuaFlags, expect_can_fua);
+can_method!(can_multi_conn, expect_can_multi_conn);
+can_method!(can_trim, expect_can_trim);
+can_method!(can_write, expect_can_write);
+can_method!(can_zero, expect_can_zero);
+
+mod cache {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_cache()
+ .with(eq(42), eq(1024))
+ .returning(|_, _| {
+ Err(Error::new(libc::EIO, "I/O Schmerror"))
+ });
+ let cache = fixture.plugin.cache.as_ref().unwrap();
+ assert_eq!(-1, (cache)(fixture.handle, 42, 1024, 0));
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("I/O Schmerror", *e.borrow()));
+ });
+ }
+
+ #[test]
+ fn ok() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_cache()
+ .with(eq(42), eq(1024))
+ .returning(|_, _| Ok(()));
+ let cache = fixture.plugin.cache.as_ref().unwrap();
+ assert_eq!(0, (cache)(fixture.handle, 42, 1024, 0));
+ });
+ }
+}
+
+mod config {
+ use super::*;
+
+ #[test]
+ fn einval() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let config_ctx = MockServer::config_context();
+ config_ctx.expect()
+ .with(eq("foo"), eq("bar"))
+ .returning(|_, _| Err(Error::new(libc::EINVAL, "Invalid value for foo")));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let config = plugin.config.as_ref().unwrap();
+ assert_eq!(
+ -1,
+ config(b"foo\0".as_ptr() as *const c_char,
+ b"bar\0".as_ptr() as *const c_char)
+ );
+ ERRNO.with(|e| assert_eq!(libc::EINVAL, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("Invalid value for foo", *e.borrow()));
+ }
+
+ #[test]
+ fn ok() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let config_ctx = MockServer::config_context();
+ config_ctx.expect()
+ .with(eq("foo"), eq("bar"))
+ .returning(|_, _| Ok(()));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let config = plugin.config.as_ref().unwrap();
+ assert_eq!(
+ 0,
+ config(b"foo\0".as_ptr() as *const c_char,
+ b"bar\0".as_ptr() as *const c_char)
+ );
+ }
+}
+
+mod config_complete {
+ use super::*;
+
+ #[test]
+ fn einval() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let config_complete_ctx = MockServer::config_complete_context();
+ config_complete_ctx.expect()
+ .returning(|| Err(Error::new(libc::EINVAL, "foo is required")));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let config_complete = plugin.config_complete.as_ref().unwrap();
+ assert_eq!( -1, config_complete());
+ ERRNO.with(|e| assert_eq!(libc::EINVAL, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("foo is required", *e.borrow()));
+ }
+
+ #[test]
+ fn ok() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let config_complete_ctx = MockServer::config_complete_context();
+ config_complete_ctx.expect()
+ .returning(|| Ok(()));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let config_complete = plugin.config_complete.as_ref().unwrap();
+ assert_eq!( 0, config_complete());
+ }
+}
+
+#[test]
+fn config_help() {
+ initialize();
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let help = unsafe { CStr::from_ptr(plugin.config_help) };
+ assert_eq!(help.to_str().unwrap(), "Mock config help");
+}
+
+#[test]
+fn description() {
+ initialize();
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let description = unsafe { CStr::from_ptr(plugin.description) };
+ assert_eq!(description.to_str().unwrap(), "Mock description");
+}
+
+unload_like!(dump_plugin, dump_plugin_context);
+
+mod extents {
+ use super::*;
+
+ #[test]
+ fn eopnotsupp() {
+ with_fixture(|fixture| {
+ let msg = "Backing store does not support extents";
+ unsafe{ &mut *fixture.mockp }.expect_extents()
+ .with(eq(512), eq(10240), eq(Flags::empty()), always())
+ .returning(move |_, _, _, _| Err(Error::new(libc::EOPNOTSUPP, msg)));
+ let extents = fixture.plugin.extents.as_ref().unwrap();
+ assert_eq!(-1, (extents)(fixture.handle,
+ 512,
+ 10240,
+ 0,
+ ptr::null_mut()));
+ ERRNO.with(|e| assert_eq!(libc::EOPNOTSUPP, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!(msg, *e.borrow()));
+ });
+ }
+
+ #[test]
+ fn extent_error() {
+ with_fixture(|fixture| {
+ let ctx = MockNbdkitAddExtent::add_context();
+ ctx.expect()
+ .with(always(), eq(8192), eq(4096), eq(2))
+ .returning(|_, _, _, _| {
+ set_errno(Errno(libc::ERANGE));
+ -1
+ });
+
+ unsafe{ &mut *fixture.mockp }.expect_extents()
+ .with(eq(512), eq(10240), eq(Flags::empty()), always())
+ .returning(|_, _, _, exh| {
+ exh.add(8192, 4096, ExtentType::Zero)
+ });
+ let extents = fixture.plugin.extents.as_ref().unwrap();
+ assert_eq!(-1, (extents)(fixture.handle,
+ 512,
+ 10240,
+ 0,
+ ptr::null_mut()));
+ ERRNO.with(|e| assert_eq!(libc::ERANGE, *e.borrow()));
+ ctx.checkpoint();
+ });
+ }
+
+ #[test]
+ fn req_one() {
+ with_fixture(|fixture| {
+ let ctx = MockNbdkitAddExtent::add_context();
+ ctx.expect()
+ .with(always(), eq(8192), eq(4096), eq(2))
+ .return_const(0);
+
+ unsafe{ &mut *fixture.mockp }.expect_extents()
+ .with(eq(512), eq(10240), eq(Flags::REQ_ONE), always())
+ .returning(|_, _, _, exh| {
+ exh.add(8192, 4096, ExtentType::Zero).unwrap();
+ Ok(())
+ });
+ let extents = fixture.plugin.extents.as_ref().unwrap();
+ assert_eq!(0, (extents)(fixture.handle,
+ 512,
+ 10240,
+ 4,
+ ptr::null_mut()));
+
+ ctx.checkpoint();
+ });
+ }
+}
+
+mod flush {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_flush()
+ .returning(|| Err(Error::new(libc::EIO, "I/O Schmerror")));
+ let flush = fixture.plugin.flush.as_ref().unwrap();
+ assert_eq!(-1, (flush)(fixture.handle, 0));
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("I/O Schmerror", *e.borrow()));
+ });
+ }
+
+ #[test]
+ fn ok() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_flush()
+ .returning(|| Ok(()));
+ let flush = fixture.plugin.flush.as_ref().unwrap();
+ assert_eq!(0, (flush)(fixture.handle, 0));
+ });
+ }
+}
+
+mod get_ready {
+ use super::*;
+
+ #[test]
+ fn einval() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let get_ready_ctx = MockServer::get_ready_context();
+ get_ready_ctx.expect()
+ .returning(|| Err(Error::new(libc::EINVAL, "foo is required")));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let get_ready = plugin.get_ready.as_ref().unwrap();
+ assert_eq!( -1, get_ready());
+ ERRNO.with(|e| assert_eq!(libc::EINVAL, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("foo is required", *e.borrow()));
+ }
+
+ #[test]
+ fn ok() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let get_ready_ctx = MockServer::get_ready_context();
+ get_ready_ctx.expect()
+ .returning(|| Ok(()));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let get_ready = plugin.get_ready.as_ref().unwrap();
+ assert_eq!( 0, get_ready());
+ }
+}
+
+can_method!(is_rotational, expect_is_rotational);
+
+unload_like!(load, load_context);
+
+#[test]
+fn longname() {
+ initialize();
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let longname = unsafe { CStr::from_ptr(plugin.longname) };
+ assert_eq!(longname.to_str().unwrap(), "Mock long name");
+}
+
+#[test]
+fn magic_config_key() {
+ initialize();
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let magic_config_key = unsafe { CStr::from_ptr(plugin.magic_config_key) };
+ assert_eq!(magic_config_key.to_str().unwrap(), "magic_config_key");
+}
+
+#[test]
+fn name() {
+ initialize();
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let name = unsafe { CStr::from_ptr(plugin.name) };
+ assert_eq!(name.to_str().unwrap(), "Mock NBD Server");
+}
+
+mod preconnect {
+ use super::*;
+
+ #[test]
+ fn einval() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let preconnect_ctx = MockServer::preconnect_context();
+ preconnect_ctx.expect()
+ .returning(|_| Err(Error::new(libc::EINVAL, "foo is required")));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let preconnect = plugin.preconnect.as_ref().unwrap();
+ assert_eq!( -1, preconnect(0));
+ ERRNO.with(|e| assert_eq!(libc::EINVAL, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("foo is required", *e.borrow()));
+ }
+
+ #[test]
+ fn ok() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let preconnect_ctx = MockServer::preconnect_context();
+ preconnect_ctx.expect()
+ .with(eq(true))
+ .returning(|_| Ok(()));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let preconnect = plugin.preconnect.as_ref().unwrap();
+ assert_eq!( 0, preconnect(1));
+ }
+}
+
+mod pwrite {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_write_at()
+ .with(eq(&b"0123456789"[..]), eq(1024), eq(Flags::empty()))
+ .returning(|_, _, _| Err(Error::new(libc::EIO, "I/O Schmerror")));
+ let buf = b"0123456789";
+ let pwrite = fixture.plugin.pwrite.as_ref().unwrap();
+ assert_eq!(-1, (pwrite)(fixture.handle,
+ buf.as_ptr() as *mut c_char,
+ buf.len() as u32,
+ 1024,
+ 0));
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("I/O Schmerror", *e.borrow()));
+ });
+ }
+
+ #[test]
+ fn ok() {
+ with_fixture(|fixture| {
+ unsafe{ &mut *fixture.mockp }.expect_write_at()
+ .with(eq(&b"0123456789"[..]), eq(1024), eq(Flags::FUA))
+ .returning(|_, _, _| Ok(()));
+ let buf = b"0123456789";
+ let pwrite = fixture.plugin.pwrite.as_ref().unwrap();
+ assert_eq!(0, (pwrite)(fixture.handle,
+ buf.as_ptr() as *mut c_char,
+ buf.len() as u32,
+ 1024,
+ 2));
+ });
+ }
+}
+
+mod thread_model {
+ use super::*;
+
+ #[test]
+ fn eio() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let thread_model_ctx = MockServer::thread_model_context();
+ thread_model_ctx.expect()
+ .returning(|| Err(Error::new(libc::EIO, "Mock error")));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ assert_eq!(-1, (plugin.thread_model.as_ref().unwrap())());
+ ERRNO.with(|e| assert_eq!(libc::EIO, *e.borrow()));
+ ERRMSG.with(|e| assert_eq!("Mock error", *e.borrow()));
+ }
+
+ #[test]
+ fn ok() {
+ initialize();
+ let _m = MOCK_SERVER_MTX.lock().unwrap();
+
+ let thread_model_ctx = MockServer::thread_model_context();
+ thread_model_ctx.expect()
+ .returning(|| Ok(ThreadModel::SerializeAllRequests ));
+
+ let pluginp = unsafe { PLUGIN.unwrap()};
+ let plugin = unsafe {&*pluginp};
+
+ let thread_model = (plugin.thread_model.as_ref().unwrap())();
+ assert_eq!(thread_model, 1);
+ }
+}
+
+trim_like!(trim, expect_trim);
+unload_like!(unload, unload_context);
+trim_like!(zero, expect_zero);
_______________________________________________
Libguestfs mailing list
[email protected]
https://www.redhat.com/mailman/listinfo/libguestfs
