Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 1 | // Copyright 2022, The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
| 15 | //! Integration test for VM bootloader. |
| 16 | |
| 17 | use android_system_virtualizationservice::{ |
| 18 | aidl::android::system::virtualizationservice::{ |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 19 | CpuTopology::CpuTopology, DiskImage::DiskImage, VirtualMachineConfig::VirtualMachineConfig, |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 20 | VirtualMachineRawConfig::VirtualMachineRawConfig, |
| 21 | }, |
| 22 | binder::{ParcelFileDescriptor, ProcessState}, |
| 23 | }; |
| 24 | use anyhow::{Context, Error}; |
| 25 | use log::info; |
| 26 | use std::{ |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 27 | collections::{HashSet, VecDeque}, |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 28 | fs::File, |
Andrew Walbran | 8d05dae | 2023-03-22 16:42:55 +0000 | [diff] [blame] | 29 | io::{self, BufRead, BufReader, Read, Write}, |
Pierre-Clément Tosi | 0d1aed0 | 2022-11-17 17:06:28 +0000 | [diff] [blame] | 30 | panic, thread, |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 31 | }; |
| 32 | use vmclient::{DeathReason, VmInstance}; |
| 33 | |
Nikita Putikhin | cf9c24e | 2024-07-16 12:42:14 +0200 | [diff] [blame] | 34 | const VMBASE_EXAMPLE_PATH: &str = "vmbase_example.bin"; |
| 35 | const TEST_DISK_IMAGE_PATH: &str = "test_disk.img"; |
| 36 | const EMPTY_DISK_IMAGE_PATH: &str = "empty_disk.img"; |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 37 | |
| 38 | /// Runs the vmbase_example VM as an unprotected VM via VirtualizationService. |
| 39 | #[test] |
| 40 | fn test_run_example_vm() -> Result<(), Error> { |
Pierre-Clément Tosi | 0d1aed0 | 2022-11-17 17:06:28 +0000 | [diff] [blame] | 41 | android_logger::init_once( |
Jeff Vander Stoep | d9dda0c | 2024-02-07 14:27:06 +0100 | [diff] [blame] | 42 | android_logger::Config::default() |
| 43 | .with_tag("vmbase") |
| 44 | .with_max_level(log::LevelFilter::Debug), |
Pierre-Clément Tosi | 0d1aed0 | 2022-11-17 17:06:28 +0000 | [diff] [blame] | 45 | ); |
| 46 | |
| 47 | // Redirect panic messages to logcat. |
| 48 | panic::set_hook(Box::new(|panic_info| { |
| 49 | log::error!("{}", panic_info); |
| 50 | })); |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 51 | |
| 52 | // We need to start the thread pool for Binder to work properly, especially link_to_death. |
| 53 | ProcessState::start_thread_pool(); |
| 54 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 55 | let virtmgr = |
| 56 | vmclient::VirtualizationService::new().context("Failed to spawn VirtualizationService")?; |
| 57 | let service = virtmgr.connect().context("Failed to connect to VirtualizationService")?; |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 58 | |
| 59 | // Start example VM. |
| 60 | let bootloader = ParcelFileDescriptor::new( |
| 61 | File::open(VMBASE_EXAMPLE_PATH) |
| 62 | .with_context(|| format!("Failed to open VM image {}", VMBASE_EXAMPLE_PATH))?, |
| 63 | ); |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 64 | |
Andrew Walbran | b713baa | 2022-12-07 14:34:49 +0000 | [diff] [blame] | 65 | // Make file for test disk image. |
| 66 | let mut test_image = File::options() |
| 67 | .create(true) |
| 68 | .read(true) |
| 69 | .write(true) |
| 70 | .truncate(true) |
| 71 | .open(TEST_DISK_IMAGE_PATH) |
| 72 | .with_context(|| format!("Failed to open test disk image {}", TEST_DISK_IMAGE_PATH))?; |
| 73 | // Write 4 sectors worth of 4-byte numbers counting up. |
| 74 | for i in 0u32..512 { |
| 75 | test_image.write_all(&i.to_le_bytes())?; |
| 76 | } |
| 77 | let test_image = ParcelFileDescriptor::new(test_image); |
| 78 | let disk_image = DiskImage { image: Some(test_image), writable: false, partitions: vec![] }; |
| 79 | |
Andrew Walbran | 6ac174e | 2023-06-23 14:58:51 +0000 | [diff] [blame] | 80 | // Make file for empty test disk image. |
| 81 | let empty_image = File::options() |
| 82 | .create(true) |
| 83 | .read(true) |
| 84 | .write(true) |
| 85 | .truncate(true) |
| 86 | .open(EMPTY_DISK_IMAGE_PATH) |
| 87 | .with_context(|| format!("Failed to open empty disk image {}", EMPTY_DISK_IMAGE_PATH))?; |
| 88 | let empty_image = ParcelFileDescriptor::new(empty_image); |
| 89 | let empty_disk_image = |
| 90 | DiskImage { image: Some(empty_image), writable: false, partitions: vec![] }; |
| 91 | |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 92 | let config = VirtualMachineConfig::RawConfig(VirtualMachineRawConfig { |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 93 | name: String::from("VmBaseTest"), |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 94 | kernel: None, |
| 95 | initrd: None, |
| 96 | params: None, |
| 97 | bootloader: Some(bootloader), |
Andrew Walbran | 6ac174e | 2023-06-23 14:58:51 +0000 | [diff] [blame] | 98 | disks: vec![disk_image, empty_disk_image], |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 99 | protectedVm: false, |
| 100 | memoryMib: 300, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 101 | cpuTopology: CpuTopology::ONE_CPU, |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 102 | platformVersion: "~1.0".to_string(), |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 103 | gdbPort: 0, // no gdb |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 104 | ..Default::default() |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 105 | }); |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 106 | let (handle, console) = android_log_fd()?; |
Andrew Walbran | 8d05dae | 2023-03-22 16:42:55 +0000 | [diff] [blame] | 107 | let (mut log_reader, log_writer) = pipe()?; |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 108 | let vm = VmInstance::create( |
| 109 | service.as_ref(), |
| 110 | &config, |
| 111 | Some(console), |
| 112 | /* consoleIn */ None, |
| 113 | Some(log_writer), |
| 114 | None, |
| 115 | ) |
| 116 | .context("Failed to create VM")?; |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 117 | vm.start().context("Failed to start VM")?; |
| 118 | info!("Started example VM."); |
| 119 | |
| 120 | // Wait for VM to finish, and check that it shut down cleanly. |
| 121 | let death_reason = vm.wait_for_death(); |
| 122 | assert_eq!(death_reason, DeathReason::Shutdown); |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 123 | handle.join().unwrap(); |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 124 | |
Andrew Walbran | 8d05dae | 2023-03-22 16:42:55 +0000 | [diff] [blame] | 125 | // Check that the expected string was written to the log VirtIO console device. |
| 126 | let expected = "Hello VirtIO console\n"; |
| 127 | let mut log_output = String::new(); |
| 128 | assert_eq!(log_reader.read_to_string(&mut log_output)?, expected.len()); |
| 129 | assert_eq!(log_output, expected); |
| 130 | |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 131 | Ok(()) |
| 132 | } |
| 133 | |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 134 | fn android_log_fd() -> Result<(thread::JoinHandle<()>, File), io::Error> { |
Andrew Walbran | 8d05dae | 2023-03-22 16:42:55 +0000 | [diff] [blame] | 135 | let (reader, writer) = pipe()?; |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 136 | let handle = thread::spawn(|| VmLogProcessor::new(reader).run().unwrap()); |
| 137 | Ok((handle, writer)) |
Andrew Walbran | 94bbf2f | 2022-05-12 18:35:42 +0000 | [diff] [blame] | 138 | } |
Andrew Walbran | 8d05dae | 2023-03-22 16:42:55 +0000 | [diff] [blame] | 139 | |
| 140 | fn pipe() -> io::Result<(File, File)> { |
| 141 | let (reader_fd, writer_fd) = nix::unistd::pipe()?; |
Frederick Mayle | fbbcfcd | 2024-04-08 16:31:54 -0700 | [diff] [blame] | 142 | Ok((reader_fd.into(), writer_fd.into())) |
Andrew Walbran | 8d05dae | 2023-03-22 16:42:55 +0000 | [diff] [blame] | 143 | } |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 144 | |
| 145 | struct VmLogProcessor { |
| 146 | reader: Option<File>, |
| 147 | expected: VecDeque<String>, |
| 148 | unexpected: HashSet<String>, |
| 149 | had_unexpected: bool, |
| 150 | } |
| 151 | |
| 152 | impl VmLogProcessor { |
| 153 | fn messages() -> (VecDeque<String>, HashSet<String>) { |
| 154 | let mut expected = VecDeque::new(); |
| 155 | let mut unexpected = HashSet::new(); |
| 156 | for log_lvl in ["[ERROR]", "[WARN]", "[INFO]", "[DEBUG]"] { |
| 157 | expected.push_back(format!("{log_lvl} Unsuppressed message")); |
| 158 | unexpected.insert(format!("{log_lvl} Suppressed message")); |
| 159 | } |
| 160 | (expected, unexpected) |
| 161 | } |
| 162 | |
| 163 | fn new(reader: File) -> Self { |
| 164 | let (expected, unexpected) = Self::messages(); |
| 165 | Self { reader: Some(reader), expected, unexpected, had_unexpected: false } |
| 166 | } |
| 167 | |
| 168 | fn verify(&mut self, msg: &str) { |
| 169 | if self.expected.front() == Some(&msg.to_owned()) { |
| 170 | self.expected.pop_front(); |
| 171 | } |
| 172 | if !self.had_unexpected && self.unexpected.contains(msg) { |
| 173 | self.had_unexpected = true; |
| 174 | } |
| 175 | } |
| 176 | |
| 177 | fn run(mut self) -> Result<(), &'static str> { |
| 178 | for line in BufReader::new(self.reader.take().unwrap()).lines() { |
| 179 | let msg = line.unwrap(); |
| 180 | info!("{msg}"); |
| 181 | self.verify(&msg); |
| 182 | } |
| 183 | if !self.expected.is_empty() { |
| 184 | Err("missing expected log message") |
| 185 | } else if self.had_unexpected { |
| 186 | Err("unexpected log message") |
| 187 | } else { |
| 188 | Ok(()) |
| 189 | } |
| 190 | } |
| 191 | } |