kata-containers/cloud-hypervisor
1
0
Fork 0
mirror of https://github.com/cloud-hypervisor/cloud-hypervisor.git synced 2026-08-05 02:19:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

vmm: acpi: Take &T instead of &Arc<Mutex<T>>

Browse Source 
Refactor ACPI table creation functions to accept borrowed
references, removing double indirection and moving locking
to callers.

Signed-off-by: Chinmoy <daschinmoyy21@gmail.com>
This commit is contained in:
Chinmoy
2026-02-16 22:28:31 +05:30
committed by Rob Bradford
parent 7461143194
commit ef9133a3ee
3 changed files with 43 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
vmm/src/acpi.rs
View File

@@ -2,7 +2,6 @@
//
// SPDX-License-Identifier: Apache-2.0
//
use std::sync::{Arc, Mutex};
use std::time::Instant;
use acpi_tables::Aml;
@@ -192,7 +191,7 @@ bitflags! {
impl MemoryAffinity {
fn from_region(
region: &Arc<GuestRegionMmap>,
region: &GuestRegionMmap,
proximity_domain: u32,
flags: MemAffinityFlags,
) -> Self {
@@ -258,9 +257,9 @@ struct ViotPciRangeNode {
}
pub fn create_dsdt_table(
device_manager: &Arc<Mutex<DeviceManager>>,
cpu_manager: &Arc<Mutex<CpuManager>>,
memory_manager: &Arc<Mutex<MemoryManager>>,
device_manager: &DeviceManager,
cpu_manager: &CpuManager,
memory_manager: &MemoryManager,
) -> Sdt {
trace_scoped!("create_dsdt_table");
// DSDT
@@ -268,9 +267,9 @@ pub fn create_dsdt_table(
let mut bytes = Vec::new();
device_manager.lock().unwrap().to_aml_bytes(&mut bytes);
cpu_manager.lock().unwrap().to_aml_bytes(&mut bytes);
memory_manager.lock().unwrap().to_aml_bytes(&mut bytes);
device_manager.to_aml_bytes(&mut bytes);
cpu_manager.to_aml_bytes(&mut bytes);
memory_manager.to_aml_bytes(&mut bytes);
dsdt.append_slice(&bytes);
dsdt
@@ -278,14 +277,13 @@ pub fn create_dsdt_table(
const FACP_DSDT_OFFSET: usize = 140;
fn create_facp_table(dsdt_offset: GuestAddress, device_manager: &Arc<Mutex<DeviceManager>>) -> Sdt {
fn create_facp_table(dsdt_offset: GuestAddress, device_manager: &DeviceManager) -> Sdt {
trace_scoped!("create_facp_table");
// Revision 6 of the ACPI FADT table is 276 bytes long
let mut facp = Sdt::new(*b"FACP", 276, 6, *b"CLOUDH", *b"CHFACP ", 1);
{
let device_manager = device_manager.lock().unwrap();
if let Some(address) = device_manager.acpi_platform_addresses().reset_reg_address {
// RESET_REG
facp.write(116, address);
@@ -369,7 +367,7 @@ fn create_tpm2_table() -> Sdt {
fn create_srat_table(
numa_nodes: &NumaNodes,
device_manager: &Arc<Mutex<DeviceManager>>,
device_manager: &DeviceManager,
#[cfg(target_arch = "x86_64")] topology: Option<(u16, u16, u16, u16)>,
) -> Sdt {
let mut srat = Sdt::new(*b"SRAT", 36, 3, *b"CLOUDH", *b"CHSRAT ", 1);
@@ -381,7 +379,6 @@ fn create_srat_table(
assert_eq!(std::mem::size_of::<MemoryAffinity>(), 40);
// Confirm struct size matches ACPI 6.6 spec
assert_eq!(std::mem::size_of::<GenericInitiatorAffinity>(), 32);
let dm = device_manager.lock().unwrap();
for (node_id, node) in numa_nodes.iter() {
let proximity_domain = *node_id;
@@ -436,7 +433,7 @@ fn create_srat_table(
// Add Generic Initiator Affinity structures for device-only NUMA nodes
if let Some(device_id) = &node.device_id {
// Resolve device_id to guest BDF
if let Some(bdf) = dm.get_device_bdf(device_id) {
if let Some(bdf) = device_manager.get_device_bdf(device_id) {
srat.append(GenericInitiatorAffinity::from_pci_bdf(
bdf,
proximity_domain,
@@ -852,9 +849,9 @@ fn create_viot_table(iommu_bdf: &PciBdf, devices_bdf: &[PciBdf]) -> Sdt {
// * `Vec<u64>` contains a list of table pointers stored in XSDT.
fn create_acpi_tables_internal(
dsdt_addr: GuestAddress,
device_manager: &Arc<Mutex<DeviceManager>>,
cpu_manager: &Arc<Mutex<CpuManager>>,
memory_manager: &Arc<Mutex<MemoryManager>>,
device_manager: &DeviceManager,
cpu_manager: &CpuManager,
memory_manager: &MemoryManager,
numa_nodes: &NumaNodes,
tpm_enabled: bool,
) -> (Rsdp, Vec<u8>, Vec<u64>) {
@@ -876,15 +873,13 @@ fn create_acpi_tables_internal(
// MADT
#[cfg(target_arch = "aarch64")]
let vgic = device_manager
.lock()
.unwrap()
.get_interrupt_controller()
.unwrap()
.lock()
.unwrap()
.get_vgic()
.unwrap();
let madt = cpu_manager.lock().unwrap().create_madt(
let madt = cpu_manager.create_madt(
#[cfg(target_arch = "aarch64")]
vgic,
);
@@ -897,7 +892,7 @@ fn create_acpi_tables_internal(
// PPTT
#[cfg(target_arch = "aarch64")]
{
let pptt = cpu_manager.lock().unwrap().create_pptt();
let pptt = cpu_manager.create_pptt();
let pptt_addr = prev_tbl_addr.checked_add(prev_tbl_len).unwrap();
tables_bytes.extend_from_slice(pptt.as_slice());
xsdt_table_pointers.push(pptt_addr.0);
@@ -917,7 +912,7 @@ fn create_acpi_tables_internal(
}
// MCFG
let mcfg = create_mcfg_table(device_manager.lock().unwrap().pci_segments());
let mcfg = create_mcfg_table(device_manager.pci_segments());
let mcfg_addr = prev_tbl_addr.checked_add(prev_tbl_len).unwrap();
tables_bytes.extend_from_slice(mcfg.as_slice());
xsdt_table_pointers.push(mcfg_addr.0);
@@ -928,16 +923,12 @@ fn create_acpi_tables_internal(
#[cfg(target_arch = "aarch64")]
{
let is_serial_on = device_manager
.lock()
.unwrap()
.get_device_info()
.clone()
.contains_key(&(DeviceType::Serial, DeviceType::Serial.to_string()));
let serial_device_addr = arch::layout::LEGACY_SERIAL_MAPPED_IO_START.raw_value();
let serial_device_irq = if is_serial_on {
device_manager
.lock()
.unwrap()
.get_device_info()
.clone()
.get(&(DeviceType::Serial, DeviceType::Serial.to_string()))
@@ -979,7 +970,7 @@ fn create_acpi_tables_internal(
// Only created if the NUMA nodes list is not empty.
if !numa_nodes.is_empty() {
#[cfg(target_arch = "x86_64")]
let topology = cpu_manager.lock().unwrap().get_vcpu_topology();
let topology = cpu_manager.get_vcpu_topology();
// SRAT
let srat = create_srat_table(
numa_nodes,
@@ -1003,7 +994,7 @@ fn create_acpi_tables_internal(
#[cfg(target_arch = "aarch64")]
{
let iort = create_iort_table(device_manager.lock().unwrap().pci_segments());
let iort = create_iort_table(device_manager.pci_segments());
let iort_addr = prev_tbl_addr.checked_add(prev_tbl_len).unwrap();
tables_bytes.extend_from_slice(iort.as_slice());
xsdt_table_pointers.push(iort_addr.0);
@@ -1012,8 +1003,7 @@ fn create_acpi_tables_internal(
}
// VIOT
if let Some((iommu_bdf, devices_bdf)) = device_manager.lock().unwrap().iommu_attached_devices()
{
if let Some((iommu_bdf, devices_bdf)) = device_manager.iommu_attached_devices() {
let viot = create_viot_table(iommu_bdf, devices_bdf);
let viot_addr = prev_tbl_addr.checked_add(prev_tbl_len).unwrap();
@@ -1040,9 +1030,9 @@ fn create_acpi_tables_internal(
#[cfg(feature = "fw_cfg")]
pub fn create_acpi_tables_for_fw_cfg(
device_manager: &Arc<Mutex<DeviceManager>>,
cpu_manager: &Arc<Mutex<CpuManager>>,
memory_manager: &Arc<Mutex<MemoryManager>>,
device_manager: &DeviceManager,
cpu_manager: &CpuManager,
memory_manager: &MemoryManager,
numa_nodes: &NumaNodes,
tpm_enabled: bool,
) -> Result<(), crate::vm::Error> {
@@ -1087,8 +1077,6 @@ pub fn create_acpi_tables_for_fw_cfg(
checksums.push(xsdt_checksum);
device_manager
.lock()
.unwrap()
.fw_cfg()
.expect("fw_cfg must be present")
.lock()
@@ -1099,9 +1087,9 @@ pub fn create_acpi_tables_for_fw_cfg(
pub fn create_acpi_tables(
guest_mem: &GuestMemoryMmap,
device_manager: &Arc<Mutex<DeviceManager>>,
cpu_manager: &Arc<Mutex<CpuManager>>,
memory_manager: &Arc<Mutex<MemoryManager>>,
device_manager: &DeviceManager,
cpu_manager: &CpuManager,
memory_manager: &MemoryManager,
numa_nodes: &NumaNodes,
tpm_enabled: bool,
) -> GuestAddress {
@@ -1139,9 +1127,9 @@ pub fn create_acpi_tables(
#[cfg(feature = "tdx")]
pub fn create_acpi_tables_tdx(
device_manager: &Arc<Mutex<DeviceManager>>,
cpu_manager: &Arc<Mutex<CpuManager>>,
memory_manager: &Arc<Mutex<MemoryManager>>,
device_manager: &DeviceManager,
cpu_manager: &CpuManager,
memory_manager: &MemoryManager,
numa_nodes: &NumaNodes,
) -> Vec<Sdt> {
// DSDT
@@ -1155,18 +1143,16 @@ pub fn create_acpi_tables_tdx(
tables.push(create_facp_table(GuestAddress(0), device_manager));
// MADT
tables.push(cpu_manager.lock().unwrap().create_madt());
tables.push(cpu_manager.create_madt());
// MCFG
tables.push(create_mcfg_table(
device_manager.lock().unwrap().pci_segments(),
));
tables.push(create_mcfg_table(device_manager.pci_segments()));
// SRAT and SLIT
// Only created if the NUMA nodes list is not empty.
if !numa_nodes.is_empty() {
#[cfg(target_arch = "x86_64")]
let topology = cpu_manager.lock().unwrap().get_vcpu_topology();
let topology = cpu_manager.get_vcpu_topology();
// SRAT
tables.push(create_srat_table(
@@ -1181,8 +1167,7 @@ pub fn create_acpi_tables_tdx(
}
// VIOT
if let Some((iommu_bdf, devices_bdf)) = device_manager.lock().unwrap().iommu_attached_devices()
{
if let Some((iommu_bdf, devices_bdf)) = device_manager.iommu_attached_devices() {
tables.push(create_viot_table(iommu_bdf, devices_bdf));
}

4
vmm/src/device_manager.rs
View File

@@ -1756,7 +1756,7 @@ impl DeviceManager {
}
#[cfg(target_arch = "aarch64")]
pub fn get_interrupt_controller(&mut self) -> Option<&Arc<Mutex<gic::Gic>>> {
pub fn get_interrupt_controller(&self) -> Option<&Arc<Mutex<gic::Gic>>> {
self.interrupt_controller.as_ref()
}
@@ -1793,7 +1793,7 @@ impl DeviceManager {
}
#[cfg(target_arch = "riscv64")]
pub fn get_interrupt_controller(&mut self) -> Option<&Arc<Mutex<aia::Aia>>> {
pub fn get_interrupt_controller(&self) -> Option<&Arc<Mutex<aia::Aia>>> {
self.interrupt_controller.as_ref()
}

18
vmm/src/vm.rs
View File

@@ -2514,9 +2514,9 @@ impl Vm {
// Loop over the ACPI tables and copy them to the HOB.
for acpi_table in crate::acpi::create_acpi_tables_tdx(
&self.device_manager,
&self.cpu_manager,
&self.memory_manager,
&self.device_manager.lock().unwrap(),
&self.cpu_manager.lock().unwrap(),
&self.memory_manager.lock().unwrap(),
&self.numa_nodes,
) {
hob.add_acpi_table(&mem, acpi_table.as_slice())
@@ -2576,9 +2576,9 @@ impl Vm {
let tpm_enabled = self.config.lock().unwrap().tpm.is_some();
let rsdp_addr = crate::acpi::create_acpi_tables(
&mem,
&self.device_manager,
&self.cpu_manager,
&self.memory_manager,
&self.device_manager.lock().unwrap(),
&self.cpu_manager.lock().unwrap(),
&self.memory_manager.lock().unwrap(),
&self.numa_nodes,
tpm_enabled,
);
@@ -2643,9 +2643,9 @@ impl Vm {
if fw_cfg_config.acpi_tables {
let tpm_enabled = self.config.lock().unwrap().tpm.is_some();
crate::acpi::create_acpi_tables_for_fw_cfg(
&self.device_manager,
&self.cpu_manager,
&self.memory_manager,
&self.device_manager.lock().unwrap(),
&self.cpu_manager.lock().unwrap(),
&self.memory_manager.lock().unwrap(),
&self.numa_nodes,
tpm_enabled,
)?;