feat: add RDMA listener to Mayastor Nvmf target

This adds the capability to listen for rdma connections to the Mayastor
Nvmf target if the rdma feature is enabled during installation. Any Nvmf
subsystem facing the host i.e. the nexus nvmf subsystem will now be able
to support tcp and rdma both.

Signed-off-by: Diwakar Sharma <diwakar.sharma@datacore.com>

Author: dsharma-dc

io-engine/src/bin/io-engine.rs

@@ -108,7 +108,7 @@ fn start_tokio_runtime(args: &MayastorCliArgs) {
 
     if args.rdma {
         env::set_var("ENABLE_RDMA", "true");
-        warn!("RDMA is enabled for Mayastor NVMEoF target");
+        warn!("RDMA is requested to be enabled for Mayastor NVMEoF target");
     }
 
     unsafe {

io-engine/src/core/bdev.rs

@@ -11,7 +11,7 @@ use snafu::ResultExt;
 use spdk_rs::libspdk::{spdk_bdev, spdk_get_ticks_hz};
 
 use crate::{
-    bdev::bdev_event_callback,
+    bdev::{bdev_event_callback, nexus::NEXUS_MODULE_NAME},
     bdev_api::bdev_uri_eq,
     core::{
         share::{NvmfShareProps, Protocol, Share, UpdateProps},
@@ -210,6 +210,7 @@ where
     ) -> Result<Self::Output, Self::Error> {
         let me = unsafe { self.get_unchecked_mut() };
         let props = NvmfShareProps::from(props);
+        let is_nexus_bdev = me.driver() == NEXUS_MODULE_NAME;
 
         let ptpl = props.ptpl().as_ref().map(|ptpl| ptpl.path());
 
@@ -232,7 +233,7 @@ where
             .await
             .context(ShareNvmf {})?;
 
-        subsystem.start().await.context(ShareNvmf {})
+        subsystem.start(is_nexus_bdev).await.context(ShareNvmf {})
     }
 
     fn create_ptpl(&self) -> Result<Option<PtplProps>, Self::Error> {

io-engine/src/core/env.rs

@@ -834,6 +834,11 @@ impl MayastorEnvironment {
             .map(|s| s.clone())
     }
 
+    /// Check if RDMA needs to be enabled for Mayastor nvmf target.
+    pub fn rdma(&self) -> bool {
+        self.rdma
+    }
+
     /// Detects IP address for NVMF target by the interface specified in CLI
     /// arguments.
     fn detect_nvmf_tgt_iface_ip(iface: &str) -> Result<String, String> {

io-engine/src/subsys/config/opts.rs

@@ -28,7 +28,7 @@ use spdk_rs::{
 
 use std::{
     convert::TryFrom,
-    fmt::{Debug, Display},
+    fmt::{Debug, Display, Formatter},
     mem::zeroed,
     ptr::null_mut,
     str::FromStr,
@@ -84,6 +84,93 @@ impl GetOpts for NexusOpts {
 /// Must be equal to the size of `spdk_nvmf_target_opts.crdt`.
 pub const TARGET_CRDT_LEN: usize = 3;
 
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub enum NvmfTgtTransport {
+    Rdma,
+    #[default]
+    Tcp,
+}
+
+impl Display for NvmfTgtTransport {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                NvmfTgtTransport::Rdma => "rdma",
+                NvmfTgtTransport::Tcp => "tcp",
+            }
+        )
+    }
+}
+
+/// Nvmf settings for the transports
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct NvmfTransportOpts {
+    /// max queue depth
+    max_queue_depth: u16,
+    /// max qpairs per controller
+    max_qpairs_per_ctrl: u16,
+    /// encapsulated data size
+    in_capsule_data_size: u32,
+    /// max IO size
+    max_io_size: u32,
+    /// IO unit size
+    io_unit_size: u32,
+    /// max admin queue depth per admin queue
+    max_aq_depth: u32,
+    /// num of shared buffers
+    num_shared_buf: u32,
+    /// cache size
+    buf_cache_size: u32,
+    /// dif
+    dif_insert_or_strip: bool,
+    /// abort execution timeout
+    abort_timeout_sec: u32,
+    /// acceptor poll rate, microseconds
+    acceptor_poll_rate: u32,
+    /// Use zero-copy operations if the underlying bdev supports them
+    zcopy: bool,
+    /// ACK timeout in milliseconds
+    ack_timeout: u32,
+    /// Size of RDMA data WR pool
+    data_wr_pool_size: u32,
+}
+
+impl NvmfTransportOpts {
+    fn for_rdma(mut self) -> Self {
+        self.in_capsule_data_size = 4096;
+        self.io_unit_size = 8192; // SPDK_NVMF_RDMA_MIN_IO_BUFFER_SIZE
+        self.data_wr_pool_size = 4095; // SPDK_NVMF_RDMA_DEFAULT_DATA_WR_POOL_SIZE
+        self
+    }
+}
+
+impl Default for NvmfTransportOpts {
+    fn default() -> Self {
+        Self {
+            max_queue_depth: try_from_env("NVMF_TCP_MAX_QUEUE_DEPTH", 32),
+            in_capsule_data_size: 4096,
+            max_io_size: 131_072,
+            io_unit_size: 131_072,
+            max_qpairs_per_ctrl: try_from_env(
+                "NVMF_TCP_MAX_QPAIRS_PER_CTRL",
+                32,
+            ),
+            num_shared_buf: try_from_env("NVMF_TCP_NUM_SHARED_BUF", 2047),
+            buf_cache_size: try_from_env("NVMF_TCP_BUF_CACHE_SIZE", 64),
+            dif_insert_or_strip: false,
+            max_aq_depth: 32,
+            abort_timeout_sec: 1,
+            acceptor_poll_rate: try_from_env("NVMF_ACCEPTOR_POLL_RATE", 10_000),
+            zcopy: try_from_env("NVMF_ZCOPY", 1) == 1,
+            ack_timeout: try_from_env("NVMF_ACK_TIMEOUT", 0),
+            data_wr_pool_size: try_from_env("NVMF_DATA_WR_POOL_SIZE", 0),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct NvmfTgtConfig {
@@ -94,11 +181,13 @@ pub struct NvmfTgtConfig {
     /// NVMF target Command Retry Delay in x100 ms.
     pub crdt: [u16; TARGET_CRDT_LEN],
     /// TCP transport options
-    pub opts: NvmfTcpTransportOpts,
+    pub opts_tcp: NvmfTransportOpts,
     /// NVMF target interface (ip, mac, name or subnet).
     pub interface: Option<String>,
     /// Enable RDMA for NVMF target or not
     pub rdma: Option<bool>,
+    /// RDMA transport options
+    pub opts_rdma: NvmfTransportOpts,
 }
 
 impl From<NvmfTgtConfig> for Box<spdk_nvmf_target_opts> {
@@ -126,9 +215,10 @@ impl Default for NvmfTgtConfig {
             name: "mayastor_target".to_string(),
             max_namespaces: 2048,
             crdt: args.nvmf_tgt_crdt,
-            opts: NvmfTcpTransportOpts::default(),
+            opts_tcp: NvmfTransportOpts::default(),
             interface: None,
             rdma: None,
+            opts_rdma: NvmfTransportOpts::default().for_rdma(),
         }
     }
 }
@@ -139,40 +229,6 @@ impl GetOpts for NvmfTgtConfig {
     }
 }
 
-/// Settings for the TCP transport
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct NvmfTcpTransportOpts {
-    /// max queue depth
-    max_queue_depth: u16,
-    /// max qpairs per controller
-    max_qpairs_per_ctrl: u16,
-    /// encapsulated data size
-    in_capsule_data_size: u32,
-    /// max IO size
-    max_io_size: u32,
-    /// IO unit size
-    io_unit_size: u32,
-    /// max admin queue depth per admin queue
-    max_aq_depth: u32,
-    /// num of shared buffers
-    num_shared_buf: u32,
-    /// cache size
-    buf_cache_size: u32,
-    /// dif
-    dif_insert_or_strip: bool,
-    /// abort execution timeout
-    abort_timeout_sec: u32,
-    /// acceptor poll rate, microseconds
-    acceptor_poll_rate: u32,
-    /// Use zero-copy operations if the underlying bdev supports them
-    zcopy: bool,
-    /// ACK timeout in milliseconds
-    ack_timeout: u32,
-    /// Size of RDMA data WR pool
-    data_wr_pool_size: u32,
-}
-
 /// try to read an env variable or returns the default when not found
 pub(crate) fn try_from_env<T>(name: &str, default: T) -> T
 where
@@ -264,58 +320,32 @@ where
     }
 }
 
-impl Default for NvmfTcpTransportOpts {
-    fn default() -> Self {
-        Self {
-            max_queue_depth: try_from_env("NVMF_TCP_MAX_QUEUE_DEPTH", 32),
-            in_capsule_data_size: 4096,
-            max_io_size: 131_072,
-            io_unit_size: 131_072,
-            max_qpairs_per_ctrl: try_from_env(
-                "NVMF_TCP_MAX_QPAIRS_PER_CTRL",
-                32,
-            ),
-            num_shared_buf: try_from_env("NVMF_TCP_NUM_SHARED_BUF", 2047),
-            buf_cache_size: try_from_env("NVMF_TCP_BUF_CACHE_SIZE", 64),
-            dif_insert_or_strip: false,
-            max_aq_depth: 32,
-            abort_timeout_sec: 1,
-            acceptor_poll_rate: try_from_env("NVMF_ACCEPTOR_POLL_RATE", 10_000),
-            zcopy: try_from_env("NVMF_ZCOPY", 1) == 1,
-            ack_timeout: try_from_env("NVMF_ACK_TIMEOUT", 0),
-            data_wr_pool_size: try_from_env("NVMF_DATA_WR_POOL_SIZE", 0),
-        }
-    }
-}
-
 /// we cannot add derives for YAML to these structs directly, so we need to
 /// copy them. The upside though, is that if the FFI structures change, we will
 /// know about it during compile time.
-impl From<NvmfTcpTransportOpts> for spdk_nvmf_transport_opts {
-    fn from(o: NvmfTcpTransportOpts) -> Self {
-        struct_size_init!(
-            Self {
-                max_queue_depth: o.max_queue_depth,
-                max_qpairs_per_ctrlr: o.max_qpairs_per_ctrl,
-                in_capsule_data_size: o.in_capsule_data_size,
-                max_io_size: o.max_io_size,
-                io_unit_size: o.io_unit_size,
-                max_aq_depth: o.max_aq_depth,
-                num_shared_buffers: o.num_shared_buf,
-                buf_cache_size: o.buf_cache_size,
-                dif_insert_or_strip: o.dif_insert_or_strip,
-                reserved29: Default::default(),
-                abort_timeout_sec: o.abort_timeout_sec,
-                association_timeout: 120000,
-                transport_specific: std::ptr::null(),
-                acceptor_poll_rate: o.acceptor_poll_rate,
-                zcopy: o.zcopy,
-                reserved61: Default::default(),
-                ack_timeout: o.ack_timeout,
-                data_wr_pool_size: o.data_wr_pool_size,
-            },
-            opts_size
-        )
+impl From<NvmfTransportOpts> for spdk_nvmf_transport_opts {
+    fn from(o: NvmfTransportOpts) -> Self {
+        Self {
+            max_queue_depth: o.max_queue_depth,
+            max_qpairs_per_ctrlr: o.max_qpairs_per_ctrl,
+            in_capsule_data_size: o.in_capsule_data_size,
+            max_io_size: o.max_io_size,
+            io_unit_size: o.io_unit_size,
+            max_aq_depth: o.max_aq_depth,
+            num_shared_buffers: o.num_shared_buf,
+            buf_cache_size: o.buf_cache_size,
+            dif_insert_or_strip: o.dif_insert_or_strip,
+            reserved29: Default::default(),
+            abort_timeout_sec: o.abort_timeout_sec,
+            association_timeout: 120000,
+            transport_specific: std::ptr::null(),
+            opts_size: std::mem::size_of::<spdk_nvmf_transport_opts>() as u64,
+            acceptor_poll_rate: o.acceptor_poll_rate,
+            zcopy: o.zcopy,
+            ack_timeout: o.ack_timeout,
+            data_wr_pool_size: o.data_wr_pool_size,
+            reserved61: Default::default(),
+        }
     }
 }