devices/x86_64: add cmos legacy device

u-boot uses a legacy CMOS device to obtain the ram size, so do a minimal
implementation ourselves.

Signed-off-by: Sergio Lopez <slp@redhat.com>

Author: slp

src/devices/src/legacy/mod.rs

@@ -30,6 +30,8 @@ mod vcpu;
 #[cfg(target_arch = "x86_64")]
 mod x86_64;
 #[cfg(target_arch = "x86_64")]
+use x86_64::cmos;
+#[cfg(target_arch = "x86_64")]
 use x86_64::serial;
 #[cfg(target_arch = "aarch64")]
 mod aarch64;
@@ -42,6 +44,8 @@ mod riscv64;
 #[cfg(target_arch = "riscv64")]
 use riscv64::serial;
 
+#[cfg(target_arch = "x86_64")]
+pub use self::cmos::Cmos;
 #[cfg(target_os = "macos")]
 pub use self::gicv3::GicV3;
 #[cfg(target_arch = "aarch64")]

src/devices/src/legacy/x86_64/cmos.rs

@@ -0,0 +1,79 @@
+// Copyright 2025 Red Hat, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+use std::cmp::min;
+
+use crate::bus::BusDevice;
+
+const INDEX_MASK: u8 = 0x7f;
+const INDEX_OFFSET: u64 = 0x0;
+const DATA_OFFSET: u64 = 0x1;
+const DATA_LEN: usize = 128;
+
+pub struct Cmos {
+    index: u8,
+    data: [u8; DATA_LEN],
+}
+
+impl Cmos {
+    pub fn new(mem_below_4g: u64, mem_above_4g: u64) -> Cmos {
+        debug!("cmos: mem_below_4g={mem_below_4g} mem_above_4g={mem_above_4g}");
+
+        let mut data = [0u8; DATA_LEN];
+
+        // Extended memory from 16 MB to 4 GB in units of 64 KB
+        let ext_mem = min(
+            0xFFFF,
+            mem_below_4g.saturating_sub(16 * 1024 * 1024) / (64 * 1024),
+        );
+        data[0x34] = ext_mem as u8;
+        data[0x35] = (ext_mem >> 8) as u8;
+
+        // High memory (> 4GB) in units of 64 KB
+        let high_mem = min(0xFFFFFF, mem_above_4g / (64 * 1024));
+        data[0x5b] = high_mem as u8;
+        data[0x5c] = (high_mem >> 8) as u8;
+        data[0x5d] = (high_mem >> 16) as u8;
+
+        Cmos { index: 0, data }
+    }
+}
+
+impl BusDevice for Cmos {
+    fn read(&mut self, _vcpuid: u64, offset: u64, data: &mut [u8]) {
+        if data.len() != 1 {
+            error!("cmos: unsupported read length");
+            return;
+        }
+
+        data[0] = match offset {
+            INDEX_OFFSET => {
+                debug!("cmos: read index offset");
+                self.index
+            }
+            DATA_OFFSET => {
+                debug!("cmos: read data offset from index={:x}", self.index);
+                self.data[(self.index & INDEX_MASK) as usize]
+            }
+            _ => {
+                debug!("cmos: unsupported read offset");
+                0
+            }
+        };
+    }
+
+    fn write(&mut self, _vcpuid: u64, offset: u64, data: &[u8]) {
+        if data.len() != 1 {
+            error!("cmos: unsupported write length");
+            return;
+        }
+
+        match offset {
+            INDEX_OFFSET => {
+                debug!("cmos: update index");
+                self.index = data[0] & INDEX_MASK;
+            }
+            _ => debug!("cmos: ignoring unsupported write to CMOS"),
+        }
+    }
+}

src/devices/src/legacy/x86_64/mod.rs

@@ -1 +1,2 @@
+pub mod cmos;
 pub mod serial;

src/vmm/src/builder.rs

@@ -29,6 +29,8 @@ use crate::resources::{
 use crate::vmm_config::external_kernel::{ExternalKernel, KernelFormat};
 #[cfg(feature = "net")]
 use crate::vmm_config::net::NetBuilder;
+#[cfg(target_arch = "x86_64")]
+use devices::legacy::Cmos;
 #[cfg(all(target_os = "linux", target_arch = "riscv64"))]
 use devices::legacy::KvmAia;
 #[cfg(target_arch = "x86_64")]
@@ -757,6 +759,10 @@ pub fn build_microvm(
     // Safe to unwrap 'serial_device' as it's always 'Some' on x86_64.
     // x86_64 uses the i8042 reset event as the Vmm exit event.
     let mut pio_device_manager = PortIODeviceManager::new(
+        Arc::new(Mutex::new(Cmos::new(
+            arch_memory_info.ram_below_gap,
+            arch_memory_info.ram_above_gap,
+        ))),
         serial_devices,
         exit_evt
             .try_clone()

src/vmm/src/device_manager/legacy.rs

@@ -39,6 +39,7 @@ type Result<T> = ::std::result::Result<T, Error>;
 /// The `LegacyDeviceManger` should be initialized only by using the constructor.
 pub struct PortIODeviceManager {
     pub io_bus: devices::Bus,
+    pub cmos: Arc<Mutex<devices::legacy::Cmos>>,
     pub stdio_serial: Vec<Arc<Mutex<devices::legacy::Serial>>>,
     pub i8042: Arc<Mutex<devices::legacy::I8042Device>>,
 
@@ -52,6 +53,7 @@ pub struct PortIODeviceManager {
 impl PortIODeviceManager {
     /// Create a new DeviceManager handling legacy devices (uart, i8042).
     pub fn new(
+        cmos: Arc<Mutex<devices::legacy::Cmos>>,
         stdio_serial: Vec<Arc<Mutex<devices::legacy::Serial>>>,
         i8042_reset_evfd: EventFd,
     ) -> Result<Self> {
@@ -79,6 +81,7 @@ impl PortIODeviceManager {
 
         Ok(PortIODeviceManager {
             io_bus,
+            cmos,
             stdio_serial,
             i8042,
             com_evt_1: evts[0].try_clone().map_err(Error::EventFd)?,
@@ -91,6 +94,10 @@ impl PortIODeviceManager {
 
     /// Register supported legacy devices.
     pub fn register_devices(&mut self) -> Result<()> {
+        self.io_bus
+            .insert(self.cmos.clone(), 0x70, 0x8)
+            .map_err(Error::BusError)?;
+
         if let Some(serial) = self.stdio_serial.first() {
             self.io_bus
                 .insert(serial.clone(), 0x3f8, 0x8)
@@ -147,7 +154,9 @@ mod tests {
     fn test_register_legacy_devices() {
         let serial =
             devices::legacy::Serial::new_sink(EventFd::new(utils::eventfd::EFD_NONBLOCK).unwrap());
+        let cmos = devices::legacy::Cmos::new(0, 0);
         let ldm = PortIODeviceManager::new(
+            Arc::new(Mutex::new(cmos)),
             vec![Arc::new(Mutex::new(serial))],
             EventFd::new(utils::eventfd::EFD_NONBLOCK).unwrap(),
         );