Merge "Replace use of deprecated logging functions" into main
diff --git a/Android.bp b/Android.bp
index 54919d4..696a963 100644
--- a/Android.bp
+++ b/Android.bp
@@ -28,6 +28,7 @@
"release_avf_enable_multi_tenant_microdroid_vm",
"release_avf_enable_remote_attestation",
"release_avf_enable_vendor_modules",
+ "release_avf_enable_virt_cpufreq",
],
properties: [
"cfgs",
@@ -55,6 +56,9 @@
release_avf_enable_vendor_modules: {
cfgs: ["vendor_modules"],
},
+ release_avf_enable_virt_cpufreq: {
+ cfgs: ["virt_cpufreq"],
+ },
},
}
diff --git a/compos/composd/src/instance_manager.rs b/compos/composd/src/instance_manager.rs
index d7c0f9a..510ad11 100644
--- a/compos/composd/src/instance_manager.rs
+++ b/compos/composd/src/instance_manager.rs
@@ -90,7 +90,7 @@
fn compos_memory_mib() -> Result<i32> {
// Enough memory to complete odrefresh in the VM, for older versions of ART that don't set the
// property explicitly.
- const DEFAULT_MEMORY_MIB: u32 = 400;
+ const DEFAULT_MEMORY_MIB: u32 = 600;
let art_requested_mib =
read_property("composd.vm.art.memory_mib.config")?.unwrap_or(DEFAULT_MEMORY_MIB);
diff --git a/javalib/Android.bp b/javalib/Android.bp
index cbc2a17..e3cb2e3 100644
--- a/javalib/Android.bp
+++ b/javalib/Android.bp
@@ -64,39 +64,3 @@
"//packages/modules/Virtualization:__subpackages__",
],
}
-
-java_api_contribution {
- name: "framework-virtualization-public-stubs",
- api_surface: "public",
- api_file: "api/current.txt",
- visibility: [
- "//build/orchestrator/apis",
- ],
-}
-
-java_api_contribution {
- name: "framework-virtualization-system-stubs",
- api_surface: "system",
- api_file: "api/system-current.txt",
- visibility: [
- "//build/orchestrator/apis",
- ],
-}
-
-java_api_contribution {
- name: "framework-virtualization-test-stubs",
- api_surface: "test",
- api_file: "api/test-current.txt",
- visibility: [
- "//build/orchestrator/apis",
- ],
-}
-
-java_api_contribution {
- name: "framework-virtualization-module-lib-stubs",
- api_surface: "module-lib",
- api_file: "api/module-lib-current.txt",
- visibility: [
- "//build/orchestrator/apis",
- ],
-}
diff --git a/javalib/src/android/system/virtualmachine/VirtualMachineConfig.java b/javalib/src/android/system/virtualmachine/VirtualMachineConfig.java
index 474c2f2..a6381ac 100644
--- a/javalib/src/android/system/virtualmachine/VirtualMachineConfig.java
+++ b/javalib/src/android/system/virtualmachine/VirtualMachineConfig.java
@@ -126,7 +126,7 @@
/**
* Run VM with vCPU topology matching the physical CPU topology of the host. Usually takes
- * longer to boot and cosumes more resources compared to a single vCPU. Typically a good option
+ * longer to boot and consumes more resources compared to a single vCPU. Typically a good option
* for long-running workloads that benefit from parallel execution.
*
* @hide
diff --git a/javalib/src/android/system/virtualmachine/VirtualizationService.java b/javalib/src/android/system/virtualmachine/VirtualizationService.java
index 1cf97b5..57990a9 100644
--- a/javalib/src/android/system/virtualmachine/VirtualizationService.java
+++ b/javalib/src/android/system/virtualmachine/VirtualizationService.java
@@ -57,13 +57,13 @@
private VirtualizationService() throws VirtualMachineException {
int clientFd = nativeSpawn();
if (clientFd < 0) {
- throw new VirtualMachineException("Could not spawn VirtualizationService");
+ throw new VirtualMachineException("Could not spawn Virtualization Manager");
}
mClientFd = ParcelFileDescriptor.adoptFd(clientFd);
IBinder binder = nativeConnect(mClientFd.getFd());
if (binder == null) {
- throw new VirtualMachineException("Could not connect to VirtualizationService");
+ throw new VirtualMachineException("Could not connect to Virtualization Manager");
}
mBinder = IVirtualizationService.Stub.asInterface(binder);
}
diff --git a/libs/libfdt/src/iterators.rs b/libs/libfdt/src/iterators.rs
index 7406164..e818c68 100644
--- a/libs/libfdt/src/iterators.rs
+++ b/libs/libfdt/src/iterators.rs
@@ -304,7 +304,7 @@
}
impl<'a> SubnodeIterator<'a> {
- pub(crate) fn new(node: &'a FdtNode) -> Result<Self, FdtError> {
+ pub(crate) fn new(node: &FdtNode<'a>) -> Result<Self, FdtError> {
let subnode = node.first_subnode()?;
Ok(Self { subnode })
diff --git a/libs/libfdt/src/lib.rs b/libs/libfdt/src/lib.rs
index d90f5f0..8a4e251 100644
--- a/libs/libfdt/src/lib.rs
+++ b/libs/libfdt/src/lib.rs
@@ -468,7 +468,7 @@
}
/// Returns an iterator of subnodes
- pub fn subnodes(&'a self) -> Result<SubnodeIterator<'a>> {
+ pub fn subnodes(&self) -> Result<SubnodeIterator<'a>> {
SubnodeIterator::new(self)
}
@@ -750,6 +750,14 @@
FdtNode { fdt: self.fdt, offset: self.offset }
}
+ /// Adds new subnodes to the given node.
+ pub fn add_subnodes(&mut self, names: &[&CStr]) -> Result<()> {
+ for name in names {
+ self.add_subnode_offset(name.to_bytes())?;
+ }
+ Ok(())
+ }
+
/// Adds a new subnode to the given node and return it as a FdtNodeMut on success.
pub fn add_subnode(&'a mut self, name: &CStr) -> Result<Self> {
let offset = self.add_subnode_offset(name.to_bytes())?;
diff --git a/libs/libfdt/tests/api_test.rs b/libs/libfdt/tests/api_test.rs
index 08fb8a5..cafbf97 100644
--- a/libs/libfdt/tests/api_test.rs
+++ b/libs/libfdt/tests/api_test.rs
@@ -19,6 +19,7 @@
use core::ffi::CStr;
use cstr::cstr;
use libfdt::{Fdt, FdtError, FdtNodeMut, Phandle};
+use std::collections::HashSet;
use std::ffi::CString;
use std::fs;
use std::ops::Range;
@@ -451,6 +452,22 @@
}
#[test]
+fn node_mut_add_subnodes() {
+ let mut data = vec![0_u8; 1000];
+ let fdt = Fdt::create_empty_tree(&mut data).unwrap();
+
+ let mut root = fdt.root_mut().unwrap();
+ let names = [cstr!("a"), cstr!("b")];
+ root.add_subnodes(&names).unwrap();
+
+ let expected: HashSet<_> = names.into_iter().collect();
+ let subnodes = fdt.root().unwrap().subnodes().unwrap();
+ let names: HashSet<_> = subnodes.map(|node| node.name().unwrap()).collect();
+
+ assert_eq!(expected, names);
+}
+
+#[test]
#[ignore] // Borrow checker test. Compilation success is sufficient.
fn node_subnode_lifetime() {
let data = fs::read(TEST_TREE_PHANDLE_PATH).unwrap();
@@ -471,6 +488,28 @@
#[test]
#[ignore] // Borrow checker test. Compilation success is sufficient.
+fn node_subnodess_lifetime() {
+ let data = fs::read(TEST_TREE_PHANDLE_PATH).unwrap();
+ let fdt = Fdt::from_slice(&data).unwrap();
+
+ let first_subnode_name = {
+ let first_subnode = {
+ let mut subnodes_iter = {
+ let root = fdt.root().unwrap();
+ root.subnodes().unwrap()
+ // Make root to be dropped
+ };
+ subnodes_iter.next().unwrap()
+ // Make subnodess_iter to be dropped
+ };
+ first_subnode.name()
+ // Make first_subnode to be dropped
+ };
+ assert_eq!(Ok(cstr!("node_a")), first_subnode_name);
+}
+
+#[test]
+#[ignore] // Borrow checker test. Compilation success is sufficient.
fn node_descendants_lifetime() {
let data = fs::read(TEST_TREE_PHANDLE_PATH).unwrap();
let fdt = Fdt::from_slice(&data).unwrap();
diff --git a/microdroid_manager/Android.bp b/microdroid_manager/Android.bp
index 1696aae..81bb409 100644
--- a/microdroid_manager/Android.bp
+++ b/microdroid_manager/Android.bp
@@ -29,7 +29,7 @@
"libclient_vm_csr",
"libciborium",
"libcoset",
- "libdice_policy",
+ "libdice_policy_builder",
"libdiced_open_dice",
"libdiced_sample_inputs",
"libglob",
diff --git a/microdroid_manager/src/vm_secret.rs b/microdroid_manager/src/vm_secret.rs
index 9b7d4f1..35acdd3 100644
--- a/microdroid_manager/src/vm_secret.rs
+++ b/microdroid_manager/src/vm_secret.rs
@@ -20,7 +20,7 @@
use secretkeeper_comm::data_types::request::Request;
use binder::{Strong};
use coset::CborSerializable;
-use dice_policy::{ConstraintSpec, ConstraintType, DicePolicy, MissingAction};
+use dice_policy_builder::{ConstraintSpec, ConstraintType, policy_for_dice_chain, MissingAction};
use diced_open_dice::{DiceArtifacts, OwnedDiceArtifacts};
use keystore2_crypto::ZVec;
use openssl::hkdf::hkdf;
@@ -173,7 +173,7 @@
),
];
- DicePolicy::from_dice_chain(dice, &constraint_spec)?
+ policy_for_dice_chain(dice, &constraint_spec)?
.to_vec()
.map_err(|e| format!("DicePolicy construction failed {e:?}"))
}
diff --git a/tests/benchmark_hostside/java/android/avf/test/AVFHostTestCase.java b/tests/benchmark_hostside/java/android/avf/test/AVFHostTestCase.java
index b176cfc..f01a76b 100644
--- a/tests/benchmark_hostside/java/android/avf/test/AVFHostTestCase.java
+++ b/tests/benchmark_hostside/java/android/avf/test/AVFHostTestCase.java
@@ -231,7 +231,7 @@
android.tryRun("rm", "-rf", MicrodroidHostTestCaseBase.TEST_ROOT);
// Donate 80% of the available device memory to the VM
- final String configPath = "assets/vm_config.json";
+ final String configPath = "assets/microdroid/vm_config.json";
final int vm_mem_mb = getFreeMemoryInfoMb(android) * 80 / 100;
ITestDevice microdroidDevice =
MicrodroidBuilder.fromDevicePath(getPathForPackage(PACKAGE_NAME), configPath)
diff --git a/tests/hostside/helper/java/com/android/microdroid/test/host/MicrodroidHostTestCaseBase.java b/tests/hostside/helper/java/com/android/microdroid/test/host/MicrodroidHostTestCaseBase.java
index 848b43b..9e19b7d 100644
--- a/tests/hostside/helper/java/com/android/microdroid/test/host/MicrodroidHostTestCaseBase.java
+++ b/tests/hostside/helper/java/com/android/microdroid/test/host/MicrodroidHostTestCaseBase.java
@@ -33,12 +33,17 @@
import com.android.tradefed.util.CommandResult;
import com.android.tradefed.util.RunUtil;
+import org.json.JSONArray;
+
import java.io.File;
import java.io.FileNotFoundException;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
public abstract class MicrodroidHostTestCaseBase extends BaseHostJUnit4Test {
protected static final String TEST_ROOT = "/data/local/tmp/virt/";
@@ -164,4 +169,35 @@
.that(pathLine).startsWith("package:");
return pathLine.substring("package:".length());
}
+
+ public List<String> parseStringArrayFieldsFromVmInfo(String header) throws Exception {
+ CommandRunner android = new CommandRunner(getDevice());
+ String result = android.run("/apex/com.android.virt/bin/vm", "info");
+ List<String> ret = new ArrayList<>();
+ for (String line : result.split("\n")) {
+ if (!line.startsWith(header)) continue;
+
+ JSONArray jsonArray = new JSONArray(line.substring(header.length()));
+ for (int i = 0; i < jsonArray.length(); i++) {
+ ret.add(jsonArray.getString(i));
+ }
+ break;
+ }
+ return ret;
+ }
+
+ public List<String> getAssignableDevices() throws Exception {
+ return parseStringArrayFieldsFromVmInfo("Assignable devices: ");
+ }
+
+ public List<String> getSupportedOSList() throws Exception {
+ return parseStringArrayFieldsFromVmInfo("Available OS list: ");
+ }
+
+ public List<String> getSupportedGKIVersions() throws Exception {
+ return getSupportedOSList().stream()
+ .filter(os -> os.startsWith("microdroid_gki-"))
+ .map(os -> os.replaceFirst("^microdroid_gki-", ""))
+ .collect(Collectors.toList());
+ }
}
diff --git a/tests/hostside/java/com/android/microdroid/test/MicrodroidHostTests.java b/tests/hostside/java/com/android/microdroid/test/MicrodroidHostTests.java
index 21abdaa..1739eab 100644
--- a/tests/hostside/java/com/android/microdroid/test/MicrodroidHostTests.java
+++ b/tests/hostside/java/com/android/microdroid/test/MicrodroidHostTests.java
@@ -1075,37 +1075,6 @@
&& device.doesFileExist("/sys/bus/platform/drivers/vfio-platform"));
}
- private List<String> parseStringArrayFieldsFromVmInfo(String header) throws Exception {
- CommandRunner android = new CommandRunner(getDevice());
- String result = android.run("/apex/com.android.virt/bin/vm", "info");
- List<String> ret = new ArrayList<>();
- for (String line : result.split("\n")) {
- if (!line.startsWith(header)) continue;
-
- JSONArray jsonArray = new JSONArray(line.substring(header.length()));
- for (int i = 0; i < jsonArray.length(); i++) {
- ret.add(jsonArray.getString(i));
- }
- break;
- }
- return ret;
- }
-
- private List<String> getAssignableDevices() throws Exception {
- return parseStringArrayFieldsFromVmInfo("Assignable devices: ");
- }
-
- private List<String> getSupportedOSList() throws Exception {
- return parseStringArrayFieldsFromVmInfo("Available OS list: ");
- }
-
- private List<String> getSupportedGKIVersions() throws Exception {
- return getSupportedOSList().stream()
- .filter(os -> os.startsWith("microdroid_gki-"))
- .map(os -> os.replaceFirst("^microdroid_gki-", ""))
- .collect(Collectors.toList());
- }
-
private TestDevice getAndroidDevice() {
TestDevice androidDevice = (TestDevice) getDevice();
assertThat(androidDevice).isNotNull();
diff --git a/virtualizationmanager/fsfdt/Android.bp b/virtualizationmanager/fsfdt/Android.bp
new file mode 100644
index 0000000..3a42bf3
--- /dev/null
+++ b/virtualizationmanager/fsfdt/Android.bp
@@ -0,0 +1,32 @@
+package {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+rust_binary {
+ name: "fsfdt",
+ crate_name: "fsfdt",
+ defaults: ["avf_build_flags_rust"],
+ edition: "2021",
+ srcs: ["src/main.rs"],
+ prefer_rlib: true,
+ rustlibs: [
+ "libanyhow",
+ "libclap",
+ "libfsfdt",
+ "liblibfdt",
+ ],
+}
+
+rust_library_rlib {
+ name: "libfsfdt",
+ crate_name: "fsfdt",
+ defaults: ["avf_build_flags_rust"],
+ edition: "2021",
+ srcs: ["src/lib.rs"],
+ prefer_rlib: true,
+ rustlibs: [
+ "liblibfdt",
+ "libanyhow",
+ ],
+ apex_available: ["com.android.virt"],
+}
diff --git a/virtualizationmanager/fsfdt/src/lib.rs b/virtualizationmanager/fsfdt/src/lib.rs
new file mode 100644
index 0000000..cda2fe1
--- /dev/null
+++ b/virtualizationmanager/fsfdt/src/lib.rs
@@ -0,0 +1,90 @@
+// Copyright 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Implements converting file system to FDT blob
+
+use anyhow::{anyhow, Context, Result};
+use libfdt::Fdt;
+use std::ffi::CString;
+use std::fs;
+use std::os::unix::ffi::OsStrExt;
+use std::path::Path;
+
+/// Trait for Fdt's file system support
+pub trait FsFdt<'a> {
+ /// Creates a Fdt from /proc/device-tree style directory by wrapping a mutable slice
+ fn from_fs(fs_path: &Path, fdt_buffer: &'a mut [u8]) -> Result<&'a mut Self>;
+}
+
+impl<'a> FsFdt<'a> for Fdt {
+ fn from_fs(fs_path: &Path, fdt_buffer: &'a mut [u8]) -> Result<&'a mut Fdt> {
+ let fdt = Fdt::create_empty_tree(fdt_buffer)
+ .map_err(|e| anyhow!("Failed to create FDT, {e:?}"))?;
+
+ // Recursively traverse fs_path with DFS algorithm.
+ let mut stack = vec![fs_path.to_path_buf()];
+ while let Some(dir_path) = stack.pop() {
+ let relative_path = dir_path
+ .strip_prefix(fs_path)
+ .context("Internal error. Path does not have expected prefix")?
+ .as_os_str();
+ let fdt_path =
+ CString::from_vec_with_nul([b"/", relative_path.as_bytes(), b"\0"].concat())
+ .context("Internal error. Path is not a valid Fdt path")?;
+
+ let mut node = fdt
+ .node_mut(&fdt_path)
+ .map_err(|e| anyhow!("Failed to write FDT, {e:?}"))?
+ .ok_or_else(|| anyhow!("Internal error when writing VM reference DT"))?;
+
+ let mut subnode_names = vec![];
+ let entries =
+ fs::read_dir(&dir_path).with_context(|| format!("Failed to read {dir_path:?}"))?;
+ for entry in entries {
+ let entry =
+ entry.with_context(|| format!("Failed to get an entry in {dir_path:?}"))?;
+ let entry_type =
+ entry.file_type().with_context(|| "Unsupported entry type, {entry:?}")?;
+ let entry_name = entry.file_name(); // binding to keep name below.
+ if !entry_name.is_ascii() {
+ return Err(anyhow!("Unsupported entry name for FDT, {entry:?}"));
+ }
+ // Safe to unwrap because validated as an ascii string above.
+ let name = CString::new(entry_name.as_bytes()).unwrap();
+ if entry_type.is_dir() {
+ stack.push(entry.path());
+ subnode_names.push(name);
+ } else if entry_type.is_file() {
+ let value = fs::read(&entry.path())?;
+
+ node.setprop(&name, &value)
+ .map_err(|e| anyhow!("Failed to set FDT property, {e:?}"))?;
+ } else {
+ return Err(anyhow!(
+ "Failed to handle {entry:?}. FDT only uses file or directory"
+ ));
+ }
+ }
+ // Note: sort() is necessary to prevent FdtError::Exists from add_subnodes().
+ // FDT library may omit address in node name when comparing their name, so sort to add
+ // node without address first.
+ subnode_names.sort();
+ let subnode_names_c_str: Vec<_> = subnode_names.iter().map(|x| x.as_c_str()).collect();
+ node.add_subnodes(&subnode_names_c_str)
+ .map_err(|e| anyhow!("Failed to add node, {e:?}"))?;
+ }
+
+ Ok(fdt)
+ }
+}
diff --git a/virtualizationmanager/fsfdt/src/main.rs b/virtualizationmanager/fsfdt/src/main.rs
new file mode 100644
index 0000000..2fe71e7
--- /dev/null
+++ b/virtualizationmanager/fsfdt/src/main.rs
@@ -0,0 +1,42 @@
+// Copyright 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! CLI for converting file system to FDT
+
+use clap::Parser;
+use fsfdt::FsFdt;
+use libfdt::Fdt;
+use std::fs;
+use std::path::PathBuf;
+
+const FDT_MAX_SIZE: usize = 1_000_000_usize;
+
+/// Option parser
+#[derive(Parser, Debug)]
+struct Opt {
+ /// File system path (directory path) to parse from
+ fs_path: PathBuf,
+
+ /// FDT file path for writing
+ fdt_file_path: PathBuf,
+}
+
+fn main() {
+ let opt = Opt::parse();
+
+ let mut data = vec![0_u8; FDT_MAX_SIZE];
+ let fdt = Fdt::from_fs(&opt.fs_path, &mut data).unwrap();
+ fdt.pack().unwrap();
+ fs::write(&opt.fdt_file_path, fdt.as_slice()).unwrap();
+}
diff --git a/virtualizationmanager/src/aidl.rs b/virtualizationmanager/src/aidl.rs
index 2603e77..34994f8 100644
--- a/virtualizationmanager/src/aidl.rs
+++ b/virtualizationmanager/src/aidl.rs
@@ -82,7 +82,7 @@
use std::convert::TryInto;
use std::ffi::{CStr, CString};
use std::fs::{canonicalize, read_dir, remove_file, File, OpenOptions};
-use std::io::{BufRead, BufReader, Error, ErrorKind, Write};
+use std::io::{BufRead, BufReader, Error, ErrorKind, Seek, SeekFrom, Write};
use std::iter;
use std::num::{NonZeroU16, NonZeroU32};
use std::os::unix::io::{FromRawFd, IntoRawFd};
@@ -159,6 +159,9 @@
// We will anyway overwrite the file to the v4signature generated from input_fd.
}
+ output
+ .seek(SeekFrom::Start(0))
+ .context("failed to move cursor to start on the idsig output")?;
output.set_len(0).context("failed to set_len on the idsig output")?;
sig.write_into(&mut output).context("failed to write idsig")?;
Ok(())
@@ -243,9 +246,14 @@
.with_context(|| format!("Invalid size: {}", size_bytes))
.or_binder_exception(ExceptionCode::ILLEGAL_ARGUMENT)?;
let size_bytes = round_up(size_bytes, PARTITION_GRANULARITY_BYTES);
- let image = clone_file(image_fd)?;
+ let mut image = clone_file(image_fd)?;
// initialize the file. Any data in the file will be erased.
+ image
+ .seek(SeekFrom::Start(0))
+ .context("failed to move cursor to start")
+ .or_service_specific_exception(-1)?;
image.set_len(0).context("Failed to reset a file").or_service_specific_exception(-1)?;
+
let mut part = QcowFile::new(image, size_bytes)
.context("Failed to create QCOW2 image")
.or_service_specific_exception(-1)?;
@@ -1545,6 +1553,40 @@
}
#[test]
+ fn test_create_or_update_idsig_on_non_empty_file() -> Result<()> {
+ use std::io::Read;
+
+ // Pick any APK
+ let mut apk = File::open("/system/priv-app/Shell/Shell.apk").unwrap();
+ let idsig_empty = tempfile::tempfile().unwrap();
+ let mut idsig_invalid = tempfile::tempfile().unwrap();
+ idsig_invalid.write_all(b"Oops")?;
+
+ // Create new idsig
+ create_or_update_idsig_file(
+ &ParcelFileDescriptor::new(apk.try_clone()?),
+ &ParcelFileDescriptor::new(idsig_empty.try_clone()?),
+ )?;
+ apk.rewind()?;
+
+ // Update idsig_invalid
+ create_or_update_idsig_file(
+ &ParcelFileDescriptor::new(apk.try_clone()?),
+ &ParcelFileDescriptor::new(idsig_invalid.try_clone()?),
+ )?;
+
+ // Ensure the 2 idsig files have same size!
+ assert!(
+ idsig_empty.metadata()?.len() == idsig_invalid.metadata()?.len(),
+ "idsig files differ in size"
+ );
+ // Ensure the 2 idsig files have same content!
+ for (b1, b2) in idsig_empty.bytes().zip(idsig_invalid.bytes()) {
+ assert!(b1.unwrap() == b2.unwrap(), "idsig files differ")
+ }
+ Ok(())
+ }
+ #[test]
fn test_append_kernel_param_first_param() {
let mut vm_config = VirtualMachineRawConfig { ..Default::default() };
append_kernel_param("foo=1", &mut vm_config);
diff --git a/virtualizationmanager/src/crosvm.rs b/virtualizationmanager/src/crosvm.rs
index 4b3478e..fe8a587 100644
--- a/virtualizationmanager/src/crosvm.rs
+++ b/virtualizationmanager/src/crosvm.rs
@@ -810,8 +810,10 @@
}
if config.host_cpu_topology {
- // TODO(b/266664564): replace with --host-cpu-topology once available
- if let Some(cpus) = get_num_cpus() {
+ if cfg!(virt_cpufreq) {
+ command.arg("--host-cpu-topology");
+ command.arg("--virt-cpufreq");
+ } else if let Some(cpus) = get_num_cpus() {
command.arg("--cpus").arg(cpus.to_string());
} else {
bail!("Could not determine the number of CPUs in the system");