runtime-rs: support memory resize

Fixes:#6875
Signed-off-by: Zhongtao Hu <zhongtaohu.tim@linux.alibaba.com>

src/runtime-rs/crates/hypervisor/src/dragonball/inner.rs

@@ -385,12 +385,12 @@ impl DragonballInner {
         req_mem_mb: u32,
         curr_mem_mb: u32,
     ) -> Result<(u32, MemoryConfig)> {
-        let mem_device_to_insert = match req_mem_mb.cmp(&curr_mem_mb) {
+        match req_mem_mb.cmp(&curr_mem_mb) {
             Ordering::Greater => {
                 // We need to insert a new memory device
-                let add_mem_mb = req_mem_mb - curr_mem_mb;
                 if self.config.memory_info.enable_virtio_mem {
-                    Some(MemDeviceConfigInfo {
+                    let add_mem_mb = req_mem_mb - curr_mem_mb;
+                    self.vmm_instance.insert_mem_device(MemDeviceConfigInfo {
                         mem_id: format!("mem{}", curr_mem_mb),
                         size_mib: add_mem_mb as u64,
                         capacity_mib: add_mem_mb as u64,
@@ -399,9 +399,7 @@ impl DragonballInner {
                         guest_numa_node_id: None,
                         use_shared_irq: None,
                         use_generic_irq: None,
-                    })
-                } else {
-                    None
+                    })?;
                 }
             }
             Ordering::Less => {
@@ -417,18 +415,16 @@ impl DragonballInner {
                 self.vmm_instance
                     .insert_balloon_device(balloon_config)
                     .context("failed to insert balloon device")?;
-                None
             }
-            Ordering::Equal => None, // Everything is already set up
+            Ordering::Equal => {
+                // Everything is already set up
+                warn!(
+                    sl!(),
+                    "memory size unchanged, no need to do memory resizing"
+                );
+            }
         };
 
-        // If we have a memory device to insert, do it now
-        if let Some(mem_config) = mem_device_to_insert {
-            self.vmm_instance
-                .insert_mem_device(mem_config)
-                .context("failed to insert memory device")?;
-        }
-
         Ok((
             req_mem_mb,
             MemoryConfig {

src/runtime-rs/crates/hypervisor/src/lib.rs

@@ -87,6 +87,8 @@ pub trait Hypervisor: Send + Sync {
     async fn save_vm(&self) -> Result<()>;
     async fn resume_vm(&self) -> Result<()>;
     async fn resize_vcpu(&self, old_vcpus: u32, new_vcpus: u32) -> Result<(u32, u32)>; // returns (old_vcpus, new_vcpus)
+    async fn resize_memory(&self, req_mem_mb: u32, curr_mem_mb: u32)
+        -> Result<(u32, MemoryConfig)>;
 
     // device manager
     async fn add_device(&self, device: DeviceType) -> Result<()>;
@@ -108,6 +110,4 @@ pub trait Hypervisor: Send + Sync {
     async fn set_capabilities(&self, flag: CapabilityBits);
     async fn set_guest_memory_block_size(&self, size: u32);
     async fn guest_memory_block_size(&self) -> u32;
-    async fn resize_memory(&self, req_mem_mb: u32, curr_mem_mb: u32)
-        -> Result<(u32, MemoryConfig)>;
 }

src/runtime-rs/crates/resource/src/cpu_mem/cpu.rs

@@ -11,7 +11,6 @@ use std::{
     sync::Arc,
 };
 
-use agent::{Agent, OnlineCPUMemRequest};
 use anyhow::{Context, Ok, Result};
 use hypervisor::Hypervisor;
 use kata_types::{config::TomlConfig, cpu::LinuxContainerCpuResources};
@@ -52,7 +51,6 @@ impl CpuResource {
         linux_cpus: Option<&LinuxCpu>,
         op: ResourceUpdateOp,
         hypervisor: &dyn Hypervisor,
-        agent: &dyn Agent,
     ) -> Result<()> {
         self.update_container_cpu_resources(cid, linux_cpus, op)
             .await
@@ -67,13 +65,13 @@ impl CpuResource {
         }
 
         let curr_vcpus = self
-            .do_update_cpu_resources(vcpu_required, op, hypervisor, agent)
+            .do_update_cpu_resources(vcpu_required, op, hypervisor)
             .await?;
         self.update_current_vcpu(curr_vcpus).await;
         Ok(())
     }
 
-    async fn current_vcpu(&self) -> u32 {
+    pub(crate) async fn current_vcpu(&self) -> u32 {
         let current_vcpu = self.current_vcpu.read().await;
         *current_vcpu
     }
@@ -148,7 +146,6 @@ impl CpuResource {
         new_vcpus: u32,
         op: ResourceUpdateOp,
         hypervisor: &dyn Hypervisor,
-        agent: &dyn Agent,
     ) -> Result<u32> {
         let old_vcpus = self.current_vcpu().await;
 
@@ -164,25 +161,11 @@ impl CpuResource {
         // the number of vcpus would not be lower than the default size
         let new_vcpus = cmp::max(new_vcpus, self.default_vcpu);
 
-        let (old, new) = hypervisor
+        let (_, new) = hypervisor
             .resize_vcpu(old_vcpus, new_vcpus)
             .await
             .context("resize vcpus")?;
 
-        if old < new {
-            let add = new - old;
-            info!(sl!(), "request to onlineCpuMem with {:?} cpus", add);
-
-            agent
-                .online_cpu_mem(OnlineCPUMemRequest {
-                    wait: false,
-                    nb_cpus: new,
-                    cpu_only: true,
-                })
-                .await
-                .context("online vcpus")?;
-        }
-
         Ok(new)
     }
 }