vhost_user: support variable shmem_config regions

Add serialize/deserialize methods to VhostUserShMemConfig
to be able to send and receive variable payloads in the
replies from the backend to the SHMEM_CONFIG messages.

Signed-off-by: Albert Esteve <aesteve@redhat.com>

Author: aesteve-rh

vhost/src/vhost_user/backend_req_handler.rs

@@ -687,8 +687,10 @@ impl<S: VhostUserBackendReqHandler> BackendReqHandler<S> {
             }
             Ok(FrontendReq::GET_SHMEM_CONFIG) => {
                 self.check_proto_feature(VhostUserProtocolFeatures::SHMEM)?;
-                let msg = self.backend.get_shmem_config().unwrap_or_default();
-                self.send_reply_message(&hdr, &msg)?;
+                let config = self.backend.get_shmem_config().unwrap_or_default();
+                let msg = VhostUserU64::new(config.nregions as u64);
+                let payload = config.payload();
+                self.send_reply_with_payload(&hdr, &msg, &payload)?;
             }
             #[cfg(feature = "postcopy")]
             Ok(FrontendReq::POSTCOPY_ADVISE) => {
@@ -1057,11 +1059,13 @@ mod tests {
         let hdr = VhostUserMsgHeader::new(FrontendReq::GET_SHMEM_CONFIG, 0, 0);
         endpoint.send_message(&hdr, &VhostUserEmpty, None).unwrap();
 
-        let (reply_hdr, reply_config, rfds) = endpoint.recv_body::<VhostUserShMemConfig>().unwrap();
+        let (reply_hdr, _count, payload, rfds) =
+            endpoint.recv_payload_into_buf::<VhostUserU64>().unwrap();
         assert_eq!(reply_hdr.get_code().unwrap(), FrontendReq::GET_SHMEM_CONFIG);
         assert!(reply_hdr.is_reply());
         assert!(rfds.is_none());
-        reply_config
+
+        VhostUserShMemConfig::from_payload(&payload).unwrap()
     }
 
     // Helper to create handler with SHMEM protocol feature enabled

vhost/src/vhost_user/frontend.rs

@@ -575,7 +575,9 @@ impl VhostUserFrontend for Frontend {
         node.check_proto_feature(VhostUserProtocolFeatures::SHMEM)?;
 
         let hdr = node.send_request_header(FrontendReq::GET_SHMEM_CONFIG, None)?;
-        let config = node.recv_reply::<VhostUserShMemConfig>(&hdr)?;
+        let (_count, payload, _) = node.recv_reply_with_payload::<VhostUserU64>(&hdr)?;
+        let config = VhostUserShMemConfig::from_payload(&payload)
+            .map_err(|_| VhostUserError::InvalidMessage)?;
 
         Ok(config)
     }
@@ -1210,12 +1212,15 @@ mod tests {
         let (mut frontend, mut peer) = create_pair2();
 
         let expected_config = VhostUserShMemConfig::new(2, &[0x1000, 0x2000]);
+        let count = VhostUserU64::new(expected_config.nregions as u64);
+        let payload = expected_config.payload();
         let hdr = VhostUserMsgHeader::new(
             FrontendReq::GET_SHMEM_CONFIG,
             0x4,
-            std::mem::size_of::<VhostUserShMemConfig>() as u32,
+            (std::mem::size_of::<VhostUserU64>() + payload.len()) as u32,
         );
-        peer.send_message(&hdr, &expected_config, None).unwrap();
+        peer.send_message_with_payload(&hdr, &count, &payload, None)
+            .unwrap();
 
         let config = frontend.get_shmem_config().unwrap();
         assert_eq!(config.nregions, 2);
@@ -1232,12 +1237,15 @@ mod tests {
         let (mut frontend, mut peer) = create_pair2();
 
         let expected_config = VhostUserShMemConfig::default();
+        let count = VhostUserU64::new(expected_config.nregions as u64);
+        let payload = expected_config.payload();
         let hdr = VhostUserMsgHeader::new(
             FrontendReq::GET_SHMEM_CONFIG,
             0x4,
-            std::mem::size_of::<VhostUserShMemConfig>() as u32,
+            (std::mem::size_of::<VhostUserU64>() + payload.len()) as u32,
         );
-        peer.send_message(&hdr, &expected_config, None).unwrap();
+        peer.send_message_with_payload(&hdr, &count, &payload, None)
+            .unwrap();
 
         let config = frontend.get_shmem_config().unwrap();
         assert_eq!(config.nregions, 0);

vhost/src/vhost_user/message.rs

@@ -697,7 +697,7 @@ impl VhostUserMsgValidator for VhostUserSingleMemoryRegion {}
 #[repr(C)]
 #[derive(Debug, Clone, Copy)]
 pub struct VhostUserShMemConfig {
-    /// Total number of shared memory regions
+    /// Total number of shared memory regions sent
     pub nregions: u32,
     /// Padding for correct alignment
     padding: u32,
@@ -725,6 +725,48 @@ impl VhostUserShMemConfig {
             memory_sizes,
         }
     }
+
+    /// Serialize memory_sizes to bytes for the wire protocol payload
+    pub fn payload(&self) -> Vec<u8> {
+        let num_elements = self
+            .memory_sizes
+            .iter()
+            .rposition(|&x| x != 0)
+            .map(|i| i + 1)
+            .unwrap_or(0);
+
+        let mut payload = Vec::with_capacity(num_elements * 8);
+        for i in 0..num_elements {
+            payload.extend_from_slice(&self.memory_sizes[i].to_ne_bytes());
+        }
+        payload
+    }
+
+    /// Deserialize from payload bytes
+    pub fn from_payload(payload: &[u8]) -> Result<Self> {
+        if !payload.len().is_multiple_of(8) {
+            return Err(Error::InvalidMessage);
+        }
+
+        let num_elements = payload.len() / 8;
+        if num_elements > 256 {
+            return Err(Error::InvalidMessage);
+        }
+
+        let mut memory_sizes = [0u64; 256];
+        for (i, chunk) in payload.chunks_exact(8).enumerate() {
+            memory_sizes[i] = u64::from_ne_bytes(chunk.try_into().unwrap());
+        }
+
+        // Count non-zero elements to determine nregions
+        let nregions = memory_sizes.iter().filter(|&&x| x != 0).count() as u32;
+
+        Ok(Self {
+            nregions,
+            padding: 0,
+            memory_sizes,
+        })
+    }
 }
 
 // SAFETY: Safe because all fields of VhostUserSingleMemoryRegion are POD.