fix(cgroup): enforce --memory-reservation/--memory-swap in-guest (#35 Part B) (#114)

Completes #35: with the dead host-side cgroup path removed (#113), these two
flags were left unenforced. Apply them in the in-guest per-container cgroup,
the same way #10 did for the CPU caps:

- ContainerCgroup::create gains memory_low (memory.low) + memory_swap_max
  (memory.swap.max) params, written best-effort like the cpu limits.
- Run path: spec.rs emits A3S_SEC_MEM_LOW (from --memory-reservation) and
  A3S_SEC_MEM_SWAP (from --memory-swap); guest main.rs reads them.
- CRI path: exec_server passes them through (parsed from the env; absent for
  CRI, which has no soft-reservation concept, so they no-op there).

The hard --memory limit stays VM-sized (no A3S_SEC_MEM_LIMIT on the run path).
All cgroup resource limits are now enforced in ONE place (the in-guest cgroup).

Test: test_run_path_plumbs_memory_reservation_and_swap_to_guest asserts the two
A3S_SEC_MEM_* vars are emitted and A3S_SEC_MEM_LIMIT is not.

Co-authored-by: Roy Lin <roylin@a3s.box>

Author: ZhiXiao-Lin

src/guest/init/src/cgroup.rs

@@ -109,18 +109,32 @@ impl ContainerCgroup {
     /// (max process count, `--pids-limit`). Returns `None` when no limit is
     /// requested or cgroup v2 is unavailable, in which case the caller proceeds
     /// without enforcement.
+    #[allow(clippy::too_many_arguments)]
     pub fn create(
         memory_max: Option<u64>,
+        memory_low: Option<u64>,
+        memory_swap_max: Option<i64>,
         cpu_quota: Option<i64>,
         cpu_period: Option<u64>,
         cpu_shares: Option<u64>,
         pids_max: Option<u64>,
     ) -> Option<Self> {
         let want_memory = memory_max.is_some_and(|m| m > 0);
+        let want_memory_low = memory_low.is_some_and(|m| m > 0);
+        // memory.swap.max accepts a byte value or -1 (unlimited); any explicit
+        // value means the limit was requested.
+        let want_memory_swap = memory_swap_max.is_some();
         let want_cpu = cpu_quota.is_some_and(|q| q > 0);
         let want_weight = cpu_shares.is_some_and(|s| s > 0);
         let want_pids = pids_max.is_some_and(|p| p > 0);
-        if (!want_memory && !want_cpu && !want_weight && !want_pids) || !ensure_cgroup2_ready() {
+        if (!want_memory
+            && !want_memory_low
+            && !want_memory_swap
+            && !want_cpu
+            && !want_weight
+            && !want_pids)
+            || !ensure_cgroup2_ready()
+        {
             return None;
         }
         let seq = CGROUP_SEQ.fetch_add(1, Ordering::Relaxed);
@@ -141,6 +155,27 @@ impl ContainerCgroup {
             // even if the over-allocating process was a child (best-effort).
             let _ = write_cgroup_file(&format!("{path}/memory.oom.group"), "1");
         }
+        if want_memory_low {
+            // memory.low = best-effort soft reservation (--memory-reservation):
+            // the kernel reclaims from this cgroup only after unprotected memory
+            // is exhausted. Non-fatal so other limits still apply.
+            let low = memory_low.unwrap_or(0);
+            if let Err(error) = write_cgroup_file(&format!("{path}/memory.low"), &low.to_string()) {
+                warn!(error = %error, low, "cgroup: failed to set memory.low");
+            }
+        }
+        if want_memory_swap {
+            // memory.swap.max (--memory-swap): a byte cap, or "max" for -1
+            // (unlimited swap). Non-fatal.
+            let value = match memory_swap_max {
+                Some(v) if v < 0 => "max".to_string(),
+                Some(v) => v.to_string(),
+                None => "max".to_string(),
+            };
+            if let Err(error) = write_cgroup_file(&format!("{path}/memory.swap.max"), &value) {
+                warn!(error = %error, value, "cgroup: failed to set memory.swap.max");
+            }
+        }
         if want_cpu {
             // cgroup v2 `cpu.max` = "<quota_us> <period_us>"; CRI defaults the
             // period to 100ms when unset.

src/guest/init/src/exec_server.rs

@@ -1243,6 +1243,8 @@ fn execute_command_streaming(
     #[cfg(target_os = "linux")]
     let container_cgroup = crate::cgroup::ContainerCgroup::create(
         parse_sec_mem_limit(spec.env),
+        parse_sec_int(spec.env, "A3S_SEC_MEM_LOW=").map(|value| value as u64),
+        parse_sec_int(spec.env, "A3S_SEC_MEM_SWAP="),
         parse_sec_int(spec.env, "A3S_SEC_CPU_QUOTA="),
         parse_sec_int(spec.env, "A3S_SEC_CPU_PERIOD=").map(|value| value as u64),
         parse_sec_int(spec.env, "A3S_SEC_CPU_SHARES=").map(|value| value as u64),

src/guest/init/src/main.rs

@@ -608,11 +608,18 @@ fn run_init() -> Result<(), Box<dyn std::error::Error>> {
     // Build the per-container cgroup from the runtime's A3S_SEC_* control vars.
     // memory_max stays None on the boot path: `--memory` is enforced by sizing
     // the microVM RAM, not an in-guest cgroup (so the runtime emits no
-    // A3S_SEC_MEM_LIMIT here). The CPU/pids caps DO have to be applied in-guest
-    // and are mirrored from the same env vars the CRI exec path consumes.
+    // A3S_SEC_MEM_LIMIT here). The CPU/pids caps and the memory soft-reservation
+    // (--memory-reservation) / swap cap (--memory-swap) DO have to be applied
+    // in-guest, mirrored from the same A3S_SEC_* env vars.
     #[cfg(target_os = "linux")]
     let container_cgroup = a3s_box_guest_init::cgroup::ContainerCgroup::create(
         None,
+        std::env::var("A3S_SEC_MEM_LOW")
+            .ok()
+            .and_then(|value| value.parse::<u64>().ok()),
+        std::env::var("A3S_SEC_MEM_SWAP")
+            .ok()
+            .and_then(|value| value.parse::<i64>().ok()),
         std::env::var("A3S_SEC_CPU_QUOTA")
             .ok()
             .and_then(|value| value.parse::<i64>().ok()),

src/runtime/src/vm/spec.rs

@@ -278,6 +278,20 @@ impl VmManager {
                 }
             }
 
+            // Memory soft-reservation (--memory-reservation → memory.low) and
+            // swap cap (--memory-swap → memory.swap.max). Like the CPU caps these
+            // are enforced by the in-guest per-container cgroup (the broken
+            // host-side path was removed); the hard --memory limit stays
+            // VM-sized, so no A3S_SEC_MEM_LIMIT is emitted here.
+            if let Some(reservation) = self.config.resource_limits.memory_reservation {
+                if reservation > 0 {
+                    env.push(("A3S_SEC_MEM_LOW".to_string(), reservation.to_string()));
+                }
+            }
+            if let Some(swap) = self.config.resource_limits.memory_swap {
+                env.push(("A3S_SEC_MEM_SWAP".to_string(), swap.to_string()));
+            }
+
             // Signal guest init to remount rootfs read-only after all setup
             if self.config.read_only {
                 env.push(("BOX_READONLY".to_string(), "1".to_string()));
@@ -871,6 +885,26 @@ mod tests {
         assert_eq!(env_value(&spec, "A3S_SEC_PIDS_LIMIT"), Some("100"));
     }
 
+    #[test]
+    fn test_run_path_plumbs_memory_reservation_and_swap_to_guest() {
+        // --memory-reservation (memory.low) and --memory-swap (memory.swap.max)
+        // must reach guest-init as A3S_SEC_MEM_LOW / A3S_SEC_MEM_SWAP so the
+        // in-guest cgroup enforces them (the broken host path was removed).
+        let temp = tempdir().unwrap();
+        let mut config = BoxConfig::default();
+        config.resource_limits.memory_reservation = Some(256 * 1024 * 1024);
+        config.resource_limits.memory_swap = Some(-1);
+
+        let mut vm = test_vm_manager(config);
+        let layout = test_layout(temp.path(), Some(test_oci_config(None, None)), true);
+        let spec = vm.build_instance_spec(&layout).unwrap();
+
+        assert_eq!(env_value(&spec, "A3S_SEC_MEM_LOW"), Some("268435456"));
+        assert_eq!(env_value(&spec, "A3S_SEC_MEM_SWAP"), Some("-1"));
+        // The hard --memory limit is VM-sized, not an in-guest memory.max.
+        assert_eq!(env_value(&spec, "A3S_SEC_MEM_LIMIT"), None);
+    }
+
     #[test]
     fn test_run_path_omits_cpu_limits_when_unset_or_unlimited() {
         // No limits set, plus an explicit unlimited quota (-1): nothing should be