Feat: send mr and support latest rustc

KRdmaKit/src/lib.rs

@@ -2,7 +2,7 @@
 #![allow(non_snake_case)]
 #![feature(
     get_mut_unchecked,
-    new_uninit,
+    new_zeroed_alloc,
     allocator_api,
     trusted_random_access,
     stmt_expr_attributes,

KRdmaKit/src/queue_pairs/handshake_user.rs

@@ -220,6 +220,34 @@ impl QueuePair {
         Ok(data)
     }
 
+    pub fn send_mr_info(&self, mr_infos: MRInfos) -> Result<MRInfos, ControlpathError> {
+        let addr = match self.comm {
+            None => {
+                return Err(ControlpathError::CreationError(
+                    "None value on `comm`",
+                    Error::from_kernel_errno(0),
+                ))
+            }
+            Some(comm) => comm.addr,
+        };
+        let mut stream = std::net::TcpStream::connect(addr).map_err(|_| {
+            ControlpathError::CreationError("Failed to connect server", Error::from_kernel_errno(0))
+        })?;
+
+        let serialized = serde_json::to_string(&mr_infos).unwrap();
+
+        let req = CMMessage {
+            message_type: CMMessageType::SendMRReq,
+            serialized,
+        };
+
+        let _ = then_send_sync(&mut stream, req).map_err(|_| {
+            ControlpathError::CreationError("Failed to send message", Error::from_kernel_errno(0))
+        })?;
+
+        Ok(mr_infos)
+    }
+
     #[inline]
     pub fn comm_struct(&self) -> Option<CommStruct> {
         self.comm

KRdmaKit/src/services_user/cm.rs

@@ -65,6 +65,7 @@ impl Into<ib_gid> for ibv_gid_wrapper {
 pub struct DefaultConnectionManagerHandler {
     pub registered_rc: Arc<Mutex<HashMap<u64, Arc<QueuePair>>>>,
     pub registered_mr: MRWrapper,
+    pub remote_mr: Arc<Mutex<MRInfos>>,
     pub port_num: u8,
     pub ctx: Arc<Context>,
 }
@@ -86,6 +87,7 @@ impl DefaultConnectionManagerHandler {
         Self {
             registered_rc: Arc::new(Default::default()),
             registered_mr: Default::default(),
+            remote_mr: Arc::new(Default::default()),
             port_num,
             ctx: ctx.clone(),
         }
@@ -111,6 +113,11 @@ impl DefaultConnectionManagerHandler {
         self.registered_mr.inner.iter().map(|(_, mr)| mr).collect()
     }
 
+    #[inline]
+    pub fn exp_get_remote_mrs(&self) -> Arc<Mutex<MRInfos>> {
+        Arc::clone(&self.remote_mr)
+    }
+
     #[inline]
     pub fn ctx(&self) -> &Arc<Context> {
         &self.ctx
@@ -188,6 +195,16 @@ impl ConnectionManagerHandler for DefaultConnectionManagerHandler {
         })
     }
 
+    fn handle_send_mr_req(&self, raw: String) -> Result<CMMessage, CMError> {
+        let mrs: MRInfos = serde_json::from_str(raw.as_str())
+            .map_err(|_| CMError::InvalidArg("Failed to do deserialization", "".to_string()))?;
+        self.remote_mr.lock().unwrap().set_inner(mrs.inner);
+        Ok(CMMessage {
+            message_type: CMMessageType::NeverSend,
+            serialized: Default::default(),
+        })
+    }
+
     fn handle_error(&self, _raw: String) -> Result<CMMessage, CMError> {
         return Ok(CMMessage {
             message_type: CMMessageType::NeverSend,
@@ -216,6 +233,11 @@ impl MRInfos {
     pub fn inner(&self) -> &HashMap<String, MRInfo> {
         &self.inner
     }
+
+    #[inline]
+    pub fn set_inner(&mut self, inner: HashMap<String, MRInfo>) {
+        self.inner = inner;
+    }
 }
 
 #[derive(Default)]

KRdmaKit/src/services_user/mod.rs

@@ -39,6 +39,9 @@ pub trait ConnectionManagerHandler: Send + Sync {
     fn handle_query_mr_req(&self, raw: String) -> Result<CMMessage, CMError> {
         unimplemented!()
     }
+    fn handle_send_mr_req(&self, raw: String) -> Result<CMMessage, CMError> {
+        unimplemented!()
+    }
     fn handle_error(&self, raw: String) -> Result<CMMessage, CMError> {
         unimplemented!()
     }
@@ -71,6 +74,8 @@ pub enum CMMessageType {
     RegRCRes,
     QueryMRRes,
 
+    SendMRReq,
+
     Error,
     NeverSend, // Never send back this type of message
 
@@ -247,6 +252,7 @@ impl<T: ConnectionManagerHandler + 'static> ConnectionManagerServer<T> {
                 CMMessageType::RegRCReq => handler.handle_reg_rc_req(raw),
                 CMMessageType::DeregRCReq => handler.handle_dereg_rc_req(raw),
                 CMMessageType::QueryMRReq => handler.handle_query_mr_req(raw),
+                CMMessageType::SendMRReq => handler.handle_send_mr_req(raw),
                 CMMessageType::UserSlotA => handler.handle_user_slot_a(raw),
                 CMMessageType::UserSlotB => handler.handle_user_slot_b(raw),
                 CMMessageType::UserSlotC => handler.handle_user_slot_c(raw),
@@ -263,6 +269,11 @@ impl<T: ConnectionManagerHandler + 'static> ConnectionManagerServer<T> {
     pub fn handler(&self) -> &T {
         &self.handler
     }
+
+    #[inline]
+    pub fn into_handler(self) -> T {
+        self.handler
+    }
 }
 
 #[inline]

rust-user-rdma/Cargo.toml

@@ -13,7 +13,7 @@ no-std-net = {path = "../rust-kernel-rdma/deps/no-std-net"}
 [build-dependencies]
 bindgen = "0.59.1" ## FIXME: update
 cc = "1.0"
-shlex = "0.1"
+shlex ="1"
 
 [features]
 OFED_5_4 = []