blob: 578960c7b67c023396fc3c49f9810212549c5bd8 [file] [log] [blame]
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001// Copyright 2021, 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
Andrew Walbranf6bf6862021-05-21 12:41:13 +000015//! Implementation of the AIDL interface of the VirtualizationService.
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000016
Seungjae Yoodd91f0f2022-11-09 15:25:21 +090017use crate::atom::{write_vm_booted_stats, write_vm_creation_stats};
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000018use crate::composite::make_composite_image;
Andrew Walbranf8d94112021-09-07 11:45:36 +000019use crate::crosvm::{CrosvmConfig, DiskFile, PayloadState, VmInstance, VmState};
Shikha Panwar22e70452022-10-10 18:32:55 +000020use crate::payload::{add_microdroid_payload_images, add_microdroid_system_images};
Seungjae Yoofd9a0622022-10-14 10:01:29 +090021use crate::selinux::{getfilecon, SeContext};
Jiyong Park753553b2021-07-12 21:21:09 +090022use android_os_permissions_aidl::aidl::android::os::IPermissionController;
Seungjae Yoofd9a0622022-10-14 10:01:29 +090023use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::ErrorCode::ErrorCode;
Jooyung Han21e9b922021-06-26 04:14:16 +090024use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
Andrew Walbranc92d35f2022-01-12 12:45:19 +000025 DeathReason::DeathReason,
Andrew Walbran6b650662021-09-07 13:13:23 +000026 DiskImage::DiskImage,
Alan Stokes0cc59ee2021-09-24 11:20:34 +010027 IVirtualMachine::{BnVirtualMachine, IVirtualMachine},
Andrew Walbran6b650662021-09-07 13:13:23 +000028 IVirtualMachineCallback::IVirtualMachineCallback,
29 IVirtualizationService::IVirtualizationService,
Jiyong Park029977d2021-11-24 21:56:49 +090030 Partition::Partition,
Andrew Walbran6b650662021-09-07 13:13:23 +000031 PartitionType::PartitionType,
Seungjae Yoofd9a0622022-10-14 10:01:29 +090032 VirtualMachineAppConfig::{Payload::Payload, VirtualMachineAppConfig},
Jooyung Han21e9b922021-06-26 04:14:16 +090033 VirtualMachineConfig::VirtualMachineConfig,
Andrew Walbran6b650662021-09-07 13:13:23 +000034 VirtualMachineDebugInfo::VirtualMachineDebugInfo,
Alan Stokes0d1ef782022-09-27 13:46:35 +010035 VirtualMachinePayloadConfig::VirtualMachinePayloadConfig,
Jooyung Han21e9b922021-06-26 04:14:16 +090036 VirtualMachineRawConfig::VirtualMachineRawConfig,
Andrew Walbran6b650662021-09-07 13:13:23 +000037 VirtualMachineState::VirtualMachineState,
Jooyung Han21e9b922021-06-26 04:14:16 +090038};
David Brazdil528e0472022-10-10 15:06:02 +010039use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::{
40 IGlobalVmContext::{BnGlobalVmContext, IGlobalVmContext},
41 IVirtualizationServiceInternal::{BnVirtualizationServiceInternal, IVirtualizationServiceInternal},
42};
Seungjae Yoodd91f0f2022-11-09 15:25:21 +090043use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::{
Seungjae Yoofd9a0622022-10-14 10:01:29 +090044 BnVirtualMachineService, IVirtualMachineService, VM_BINDER_SERVICE_PORT,
David Brazdil451cc962022-10-14 14:08:12 +010045 VM_TOMBSTONES_SERVICE_PORT,
Seungjae Yoofd9a0622022-10-14 10:01:29 +090046};
47use anyhow::{anyhow, bail, Context, Result};
48use apkverify::{HashAlgorithm, V4Signature};
Alan Stokes0e82b502022-08-08 14:44:48 +010049use binder::{
Andrew Walbran46999c92022-08-04 17:33:46 +000050 self, BinderFeatures, ExceptionCode, Interface, LazyServiceGuard, ParcelFileDescriptor,
51 SpIBinder, Status, StatusCode, Strong, ThreadState,
Andrew Walbrana89fc132021-03-17 17:08:36 +000052};
Andrew Walbrandfc953d2021-06-10 13:59:56 +000053use disk::QcowFile;
David Brazdila07a1792022-10-25 13:37:57 +010054use libc::VMADDR_CID_HOST;
Seungjae Yoo0a8c84c2022-07-11 08:19:15 +000055use log::{debug, error, info, warn};
Seungjae Yoofd9a0622022-10-14 10:01:29 +090056use microdroid_payload_config::{OsConfig, Task, TaskType, VmPayloadConfig};
Alice Wang86c88cc2022-10-17 08:10:49 +000057use rpcbinder::run_vsock_rpc_server_with_factory;
Jiyong Parkd50a0242021-09-16 21:00:14 +090058use rustutils::system_properties;
Jiyong Parkdcf17412022-02-08 15:07:23 +090059use semver::VersionReq;
Andrew Walbrandff3b942021-06-09 15:20:36 +000060use std::convert::TryInto;
Shikha Panward8e35422021-10-11 13:51:27 +000061use std::ffi::CStr;
Alan Stokes0cc59ee2021-09-24 11:20:34 +010062use std::fs::{create_dir, File, OpenOptions};
Seungjae Yoofd9a0622022-10-14 10:01:29 +090063use std::io::{Error, ErrorKind, Read, Write};
Andrew Walbranb15cd6e2021-07-05 16:38:07 +000064use std::num::NonZeroU32;
Andrew Walbrand3a84182021-09-07 14:48:52 +000065use std::os::unix::io::{FromRawFd, IntoRawFd};
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000066use std::path::{Path, PathBuf};
Andrew Walbran320b5602021-03-04 16:11:12 +000067use std::sync::{Arc, Mutex, Weak};
Seungjae Yoofd9a0622022-10-14 10:01:29 +090068use tombstoned_client::{DebuggerdDumpType, TombstonedConnection};
Andrew Walbrancc0db522021-07-12 17:03:42 +000069use vmconfig::VmConfig;
Andrew Walbranadd38cb2022-10-06 17:01:03 +000070use vsock::{VsockListener, VsockStream};
Jooyung Han35edb8f2021-07-01 16:17:16 +090071use zip::ZipArchive;
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000072
David Brazdil41d1a872022-10-05 14:44:19 +010073/// The unique ID of a VM used (together with a port number) for vsock communication.
74pub type Cid = u32;
75
Andrew Walbranf6bf6862021-05-21 12:41:13 +000076pub const BINDER_SERVICE_IDENTIFIER: &str = "android.system.virtualizationservice";
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000077
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000078/// Directory in which to write disk image files used while running VMs.
Andrew Walbran488bd072021-07-14 13:29:51 +000079pub const TEMPORARY_DIRECTORY: &str = "/data/misc/virtualizationservice";
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000080
David Brazdil41d1a872022-10-05 14:44:19 +010081/// The first CID to assign to a guest VM managed by the VirtualizationService. CIDs lower than this
82/// are reserved for the host or other usage.
83const FIRST_GUEST_CID: Cid = 10;
84
85const SYSPROP_LAST_CID: &str = "virtualizationservice.state.last_cid";
Jiyong Park8611a6c2021-07-09 18:17:44 +090086
Jooyung Han95884632021-07-06 22:27:54 +090087/// The size of zero.img.
88/// Gaps in composite disk images are filled with a shared zero.img.
89const ZERO_FILLER_SIZE: u64 = 4096;
90
Jiyong Park9dd389e2021-08-23 20:42:59 +090091/// Magic string for the instance image
92const ANDROID_VM_INSTANCE_MAGIC: &str = "Android-VM-instance";
93
94/// Version of the instance image format
95const ANDROID_VM_INSTANCE_VERSION: u16 = 1;
96
Shikha Panwar7afc1392022-03-24 08:54:43 +000097const CHUNK_RECV_MAX_LEN: usize = 1024;
98
Alan Stokes0d1ef782022-09-27 13:46:35 +010099const MICRODROID_OS_NAME: &str = "microdroid";
100
Shikha Panwar9fd198f2022-11-18 17:43:43 +0000101const UNFORMATTED_STORAGE_MAGIC: &str = "UNFORMATTED-STORAGE";
102
David Brazdil528e0472022-10-10 15:06:02 +0100103/// Singleton service for allocating globally-unique VM resources, such as the CID, and running
104/// singleton servers, like tombstone receiver.
Jooyung Han9900f3d2021-07-06 10:27:54 +0900105#[derive(Debug, Default)]
David Brazdil528e0472022-10-10 15:06:02 +0100106pub struct VirtualizationServiceInternal {
107 state: Arc<Mutex<GlobalState>>,
108}
109
110impl VirtualizationServiceInternal {
111 pub fn init() -> VirtualizationServiceInternal {
112 let service = VirtualizationServiceInternal::default();
113
114 std::thread::spawn(|| {
115 if let Err(e) = handle_stream_connection_tombstoned() {
116 warn!("Error receiving tombstone from guest or writing them. Error: {:?}", e);
117 }
118 });
119
120 service
121 }
122}
123
124impl Interface for VirtualizationServiceInternal {}
125
126impl IVirtualizationServiceInternal for VirtualizationServiceInternal {
127 fn allocateGlobalVmContext(&self) -> binder::Result<Strong<dyn IGlobalVmContext>> {
128 let state = &mut *self.state.lock().unwrap();
129 let cid = state.allocate_cid().map_err(|e| {
130 Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string()))
131 })?;
132 Ok(GlobalVmContext::create(cid))
133 }
134}
135
136/// The mutable state of the VirtualizationServiceInternal. There should only be one instance
137/// of this struct.
138#[derive(Debug, Default)]
139struct GlobalState {}
140
141impl GlobalState {
142 /// Get the next available CID, or an error if we have run out. The last CID used is stored in
143 /// a system property so that restart of virtualizationservice doesn't reuse CID while the host
144 /// Android is up.
145 fn allocate_cid(&mut self) -> Result<Cid> {
146 let cid = match system_properties::read(SYSPROP_LAST_CID)? {
147 Some(val) => match val.parse::<Cid>() {
148 Ok(num) => num.checked_add(1).ok_or_else(|| anyhow!("ran out of CIDs"))?,
149 Err(_) => {
150 error!("Invalid value '{}' of property '{}'", val, SYSPROP_LAST_CID);
151 FIRST_GUEST_CID
152 }
153 },
154 None => FIRST_GUEST_CID,
155 };
156 system_properties::write(SYSPROP_LAST_CID, &format!("{}", cid))?;
157 Ok(cid)
158 }
159}
160
161/// Implementation of the AIDL `IGlobalVmContext` interface.
162#[derive(Debug, Default)]
163struct GlobalVmContext {
164 /// The unique CID assigned to the VM for vsock communication.
165 cid: Cid,
166 /// Keeps our service process running as long as this VM instance exists.
167 #[allow(dead_code)]
168 lazy_service_guard: LazyServiceGuard,
169}
170
171impl GlobalVmContext {
172 fn create(cid: Cid) -> Strong<dyn IGlobalVmContext> {
173 let binder = GlobalVmContext { cid, ..Default::default() };
174 BnGlobalVmContext::new_binder(binder, BinderFeatures::default())
175 }
176}
177
178impl Interface for GlobalVmContext {}
179
180impl IGlobalVmContext for GlobalVmContext {
181 fn getCid(&self) -> binder::Result<i32> {
182 Ok(self.cid as i32)
183 }
184}
185
186/// Implementation of `IVirtualizationService`, the entry point of the AIDL service.
187#[derive(Debug)]
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000188pub struct VirtualizationService {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900189 state: Arc<Mutex<State>>,
David Brazdil528e0472022-10-10 15:06:02 +0100190 global_service: Strong<dyn IVirtualizationServiceInternal>,
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000191}
192
Shikha Panward8e35422021-10-11 13:51:27 +0000193impl Interface for VirtualizationService {
194 fn dump(&self, mut file: &File, _args: &[&CStr]) -> Result<(), StatusCode> {
195 check_permission("android.permission.DUMP").or(Err(StatusCode::PERMISSION_DENIED))?;
196 let state = &mut *self.state.lock().unwrap();
197 let vms = state.vms();
198 writeln!(file, "Running {0} VMs:", vms.len()).or(Err(StatusCode::UNKNOWN_ERROR))?;
199 for vm in vms {
200 writeln!(file, "VM CID: {}", vm.cid).or(Err(StatusCode::UNKNOWN_ERROR))?;
201 writeln!(file, "\tState: {:?}", vm.vm_state.lock().unwrap())
202 .or(Err(StatusCode::UNKNOWN_ERROR))?;
203 writeln!(file, "\tPayload state {:?}", vm.payload_state())
204 .or(Err(StatusCode::UNKNOWN_ERROR))?;
205 writeln!(file, "\tProtected: {}", vm.protected).or(Err(StatusCode::UNKNOWN_ERROR))?;
206 writeln!(file, "\ttemporary_directory: {}", vm.temporary_directory.to_string_lossy())
207 .or(Err(StatusCode::UNKNOWN_ERROR))?;
208 writeln!(file, "\trequester_uid: {}", vm.requester_uid)
209 .or(Err(StatusCode::UNKNOWN_ERROR))?;
Shikha Panward8e35422021-10-11 13:51:27 +0000210 writeln!(file, "\trequester_debug_pid: {}", vm.requester_debug_pid)
211 .or(Err(StatusCode::UNKNOWN_ERROR))?;
212 }
213 Ok(())
214 }
215}
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000216
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000217impl IVirtualizationService for VirtualizationService {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000218 /// Creates (but does not start) a new VM with the given configuration, assigning it the next
219 /// available CID.
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000220 ///
221 /// Returns a binder `IVirtualMachine` object referring to it, as a handle for the client.
Andrew Walbranf8d94112021-09-07 11:45:36 +0000222 fn createVm(
Andrew Walbrana89fc132021-03-17 17:08:36 +0000223 &self,
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000224 config: &VirtualMachineConfig,
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900225 console_fd: Option<&ParcelFileDescriptor>,
Andrew Walbrana89fc132021-03-17 17:08:36 +0000226 log_fd: Option<&ParcelFileDescriptor>,
227 ) -> binder::Result<Strong<dyn IVirtualMachine>> {
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000228 let mut is_protected = false;
229 let ret = self.create_vm_internal(config, console_fd, log_fd, &mut is_protected);
Seungjae Yoo0a8c84c2022-07-11 08:19:15 +0000230 write_vm_creation_stats(config, is_protected, &ret);
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000231 ret
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000232 }
Andrew Walbran320b5602021-03-04 16:11:12 +0000233
Andrew Walbrandff3b942021-06-09 15:20:36 +0000234 /// Initialise an empty partition image of the given size to be used as a writable partition.
235 fn initializeWritablePartition(
236 &self,
237 image_fd: &ParcelFileDescriptor,
238 size: i64,
Jiyong Park9dd389e2021-08-23 20:42:59 +0900239 partition_type: PartitionType,
Andrew Walbrandff3b942021-06-09 15:20:36 +0000240 ) -> binder::Result<()> {
Jiyong Park753553b2021-07-12 21:21:09 +0900241 check_manage_access()?;
Andrew Walbrandfc953d2021-06-10 13:59:56 +0000242 let size = size.try_into().map_err(|e| {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000243 Status::new_exception_str(
Andrew Walbran806f1542021-06-10 14:07:12 +0000244 ExceptionCode::ILLEGAL_ARGUMENT,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100245 Some(format!("Invalid size {}: {:?}", size, e)),
Andrew Walbran806f1542021-06-10 14:07:12 +0000246 )
Andrew Walbrandff3b942021-06-09 15:20:36 +0000247 })?;
Andrew Walbrandfc953d2021-06-10 13:59:56 +0000248 let image = clone_file(image_fd)?;
Jooyung Han1edd5b92021-10-28 10:58:05 +0900249 // initialize the file. Any data in the file will be erased.
250 image.set_len(0).map_err(|e| {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000251 Status::new_service_specific_error_str(
252 -1,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100253 Some(format!("Failed to reset a file: {:?}", e)),
Jooyung Han1edd5b92021-10-28 10:58:05 +0900254 )
255 })?;
Jiyong Park9dd389e2021-08-23 20:42:59 +0900256 let mut part = QcowFile::new(image, size).map_err(|e| {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000257 Status::new_service_specific_error_str(
258 -1,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100259 Some(format!("Failed to create QCOW2 image: {:?}", e)),
Andrew Walbran806f1542021-06-10 14:07:12 +0000260 )
Andrew Walbrandfc953d2021-06-10 13:59:56 +0000261 })?;
Andrew Walbrandff3b942021-06-09 15:20:36 +0000262
Jiyong Park9dd389e2021-08-23 20:42:59 +0900263 match partition_type {
264 PartitionType::RAW => Ok(()),
265 PartitionType::ANDROID_VM_INSTANCE => format_as_android_vm_instance(&mut part),
Shikha Panwar9fd198f2022-11-18 17:43:43 +0000266 PartitionType::ENCRYPTEDSTORE => format_as_encryptedstore(&mut part),
Jiyong Park9dd389e2021-08-23 20:42:59 +0900267 _ => Err(Error::new(
268 ErrorKind::Unsupported,
269 format!("Unsupported partition type {:?}", partition_type),
270 )),
271 }
272 .map_err(|e| {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000273 Status::new_service_specific_error_str(
274 -1,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100275 Some(format!("Failed to initialize partition as {:?}: {:?}", partition_type, e)),
Jiyong Park9dd389e2021-08-23 20:42:59 +0900276 )
277 })?;
278
Andrew Walbrandff3b942021-06-09 15:20:36 +0000279 Ok(())
280 }
281
Jiyong Park0a248432021-08-20 23:32:39 +0900282 /// Creates or update the idsig file by digesting the input APK file.
283 fn createOrUpdateIdsigFile(
284 &self,
285 input_fd: &ParcelFileDescriptor,
286 idsig_fd: &ParcelFileDescriptor,
287 ) -> binder::Result<()> {
288 // TODO(b/193504400): do this only when (1) idsig_fd is empty or (2) the APK digest in
289 // idsig_fd is different from APK digest in input_fd
290
Jiyong Parkc3ca24f2022-06-28 10:45:15 +0900291 check_manage_access()?;
292
Jiyong Park0a248432021-08-20 23:32:39 +0900293 let mut input = clone_file(input_fd)?;
294 let mut sig = V4Signature::create(&mut input, 4096, &[], HashAlgorithm::SHA256).unwrap();
295
296 let mut output = clone_file(idsig_fd)?;
297 output.set_len(0).unwrap();
298 sig.write_into(&mut output).unwrap();
299 Ok(())
300 }
301
Andrew Walbran320b5602021-03-04 16:11:12 +0000302 /// Get a list of all currently running VMs. This method is only intended for debug purposes,
303 /// and as such is only permitted from the shell user.
304 fn debugListVms(&self) -> binder::Result<Vec<VirtualMachineDebugInfo>> {
Andrew Walbran806f1542021-06-10 14:07:12 +0000305 check_debug_access()?;
Andrew Walbran320b5602021-03-04 16:11:12 +0000306
307 let state = &mut *self.state.lock().unwrap();
308 let vms = state.vms();
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000309 let cids = vms
310 .into_iter()
311 .map(|vm| VirtualMachineDebugInfo {
312 cid: vm.cid as i32,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000313 temporaryDirectory: vm.temporary_directory.to_string_lossy().to_string(),
Andrew Walbran1ef19ae2021-04-07 11:31:57 +0000314 requesterUid: vm.requester_uid as i32,
Andrew Walbran02034492021-04-13 15:05:07 +0000315 requesterPid: vm.requester_debug_pid,
Andrew Walbran6b650662021-09-07 13:13:23 +0000316 state: get_state(&vm),
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000317 })
318 .collect();
Andrew Walbran320b5602021-03-04 16:11:12 +0000319 Ok(cids)
320 }
David Brazdil3c2ddef2021-03-18 13:09:57 +0000321
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000322 /// Hold a strong reference to a VM in VirtualizationService. This method is only intended for
323 /// debug purposes, and as such is only permitted from the shell user.
Andrei Homescu1415c132021-03-24 02:39:55 +0000324 fn debugHoldVmRef(&self, vmref: &Strong<dyn IVirtualMachine>) -> binder::Result<()> {
Andrew Walbran806f1542021-06-10 14:07:12 +0000325 check_debug_access()?;
David Brazdil3c2ddef2021-03-18 13:09:57 +0000326
David Brazdil3c2ddef2021-03-18 13:09:57 +0000327 let state = &mut *self.state.lock().unwrap();
Andrei Homescu1415c132021-03-24 02:39:55 +0000328 state.debug_hold_vm(vmref.clone());
David Brazdil3c2ddef2021-03-18 13:09:57 +0000329 Ok(())
330 }
331
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000332 /// Drop reference to a VM that is being held by VirtualizationService. Returns the reference if
333 /// the VM was found and None otherwise. This method is only intended for debug purposes, and as
334 /// such is only permitted from the shell user.
David Brazdil3c2ddef2021-03-18 13:09:57 +0000335 fn debugDropVmRef(&self, cid: i32) -> binder::Result<Option<Strong<dyn IVirtualMachine>>> {
Andrew Walbran806f1542021-06-10 14:07:12 +0000336 check_debug_access()?;
David Brazdil3c2ddef2021-03-18 13:09:57 +0000337
338 let state = &mut *self.state.lock().unwrap();
339 Ok(state.debug_drop_vm(cid))
340 }
Andrew Walbran320b5602021-03-04 16:11:12 +0000341}
342
Shikha Panwar7afc1392022-03-24 08:54:43 +0000343fn handle_stream_connection_tombstoned() -> Result<()> {
344 let listener =
345 VsockListener::bind_with_cid_port(VMADDR_CID_HOST, VM_TOMBSTONES_SERVICE_PORT as u32)?;
Shikha Panwar7afc1392022-03-24 08:54:43 +0000346 for incoming_stream in listener.incoming() {
347 let mut incoming_stream = match incoming_stream {
348 Err(e) => {
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100349 warn!("invalid incoming connection: {:?}", e);
Shikha Panwar7afc1392022-03-24 08:54:43 +0000350 continue;
351 }
352 Ok(s) => s,
353 };
354 std::thread::spawn(move || {
355 if let Err(e) = handle_tombstone(&mut incoming_stream) {
356 error!("Failed to write tombstone- {:?}", e);
357 }
358 });
359 }
360 Ok(())
361}
362
363fn handle_tombstone(stream: &mut VsockStream) -> Result<()> {
Andrew Walbranadd38cb2022-10-06 17:01:03 +0000364 if let Ok(addr) = stream.peer_addr() {
Shikha Panwar7afc1392022-03-24 08:54:43 +0000365 info!("Vsock Stream connected to cid={} for tombstones", addr.cid());
366 }
367 let tb_connection =
368 TombstonedConnection::connect(std::process::id() as i32, DebuggerdDumpType::Tombstone)
369 .context("Failed to connect to tombstoned")?;
370 let mut text_output = tb_connection
371 .text_output
372 .as_ref()
373 .ok_or_else(|| anyhow!("Could not get file to write the tombstones on"))?;
374 let mut num_bytes_read = 0;
375 loop {
376 let mut chunk_recv = [0; CHUNK_RECV_MAX_LEN];
377 let n = stream
378 .read(&mut chunk_recv)
379 .context("Failed to read tombstone data from Vsock stream")?;
380 if n == 0 {
381 break;
382 }
383 num_bytes_read += n;
384 text_output.write_all(&chunk_recv[0..n]).context("Failed to write guests tombstones")?;
385 }
386 info!("Received {} bytes from guest & wrote to tombstone file", num_bytes_read);
387 tb_connection.notify_completion()?;
388 Ok(())
389}
390
Jiyong Park8611a6c2021-07-09 18:17:44 +0900391impl VirtualizationService {
392 pub fn init() -> VirtualizationService {
David Brazdil528e0472022-10-10 15:06:02 +0100393 let global_service = VirtualizationServiceInternal::init();
394 let global_service =
395 BnVirtualizationServiceInternal::new_binder(global_service, BinderFeatures::default());
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900396
David Brazdil528e0472022-10-10 15:06:02 +0100397 let service = VirtualizationService { global_service, state: Default::default() };
Shikha Panwar7afc1392022-03-24 08:54:43 +0000398
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900399 // binder server for vm
Shikha Panwar7afc1392022-03-24 08:54:43 +0000400 // reference to state (not the state itself) is copied
Andrew Walbran0fd0ff02022-07-29 15:59:17 +0000401 let state = service.state.clone();
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900402 std::thread::spawn(move || {
Andrew Walbran0fd0ff02022-07-29 15:59:17 +0000403 debug!("VirtualMachineService is starting as an RPC service.");
Alice Wang86c88cc2022-10-17 08:10:49 +0000404 if run_vsock_rpc_server_with_factory(VM_BINDER_SERVICE_PORT as u32, |cid| {
Andrew Walbran0fd0ff02022-07-29 15:59:17 +0000405 VirtualMachineService::factory(cid, &state)
406 }) {
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900407 debug!("RPC server has shut down gracefully");
408 } else {
Andrew Walbran0fd0ff02022-07-29 15:59:17 +0000409 panic!("Premature termination of RPC server");
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900410 }
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900411 });
Jiyong Park8611a6c2021-07-09 18:17:44 +0900412 service
413 }
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000414
415 fn create_vm_internal(
416 &self,
417 config: &VirtualMachineConfig,
418 console_fd: Option<&ParcelFileDescriptor>,
419 log_fd: Option<&ParcelFileDescriptor>,
420 is_protected: &mut bool,
421 ) -> binder::Result<Strong<dyn IVirtualMachine>> {
422 check_manage_access()?;
Inseob Kim1119d702022-05-02 18:01:58 +0900423
Alan Stokes7bc146c2022-10-20 17:10:32 +0100424 let is_custom = match config {
425 VirtualMachineConfig::RawConfig(_) => true,
426 VirtualMachineConfig::AppConfig(config) => {
427 // Some features are reserved for platform apps only, even when using
428 // VirtualMachineAppConfig:
429 // - controlling CPUs;
430 // - specifying a config file in the APK.
431 !config.taskProfiles.is_empty() || matches!(config.payload, Payload::ConfigPath(_))
Inseob Kim1119d702022-05-02 18:01:58 +0900432 }
Alan Stokes7bc146c2022-10-20 17:10:32 +0100433 };
434 if is_custom {
435 check_use_custom_virtual_machine()?;
Inseob Kim1119d702022-05-02 18:01:58 +0900436 }
437
David Brazdil528e0472022-10-10 15:06:02 +0100438 let vm_context = self.global_service.allocateGlobalVmContext()?;
439 let cid = vm_context.getCid()? as Cid;
440
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000441 let state = &mut *self.state.lock().unwrap();
442 let console_fd = console_fd.map(clone_file).transpose()?;
443 let log_fd = log_fd.map(clone_file).transpose()?;
444 let requester_uid = ThreadState::get_calling_uid();
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000445 let requester_debug_pid = ThreadState::get_calling_pid();
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000446
447 // Counter to generate unique IDs for temporary image files.
448 let mut next_temporary_image_id = 0;
449 // Files which are referred to from composite images. These must be mapped to the crosvm
450 // child process, and not closed before it is started.
451 let mut indirect_files = vec![];
452
453 // Make directory for temporary files.
454 let temporary_directory: PathBuf = format!("{}/{}", TEMPORARY_DIRECTORY, cid).into();
455 create_dir(&temporary_directory).map_err(|e| {
456 // At this point, we do not know the protected status of Vm
457 // setting it to false, though this may not be correct.
458 error!(
Alan Stokes70ccf162022-07-08 11:05:03 +0100459 "Failed to create temporary directory {:?} for VM files: {:?}",
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000460 temporary_directory, e
461 );
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000462 Status::new_service_specific_error_str(
463 -1,
464 Some(format!(
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100465 "Failed to create temporary directory {:?} for VM files: {:?}",
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000466 temporary_directory, e
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000467 )),
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000468 )
469 })?;
470
Alan Stokes7bc146c2022-10-20 17:10:32 +0100471 let (is_app_config, config) = match config {
472 VirtualMachineConfig::RawConfig(config) => (false, BorrowedOrOwned::Borrowed(config)),
473 VirtualMachineConfig::AppConfig(config) => {
474 let config = load_app_config(config, &temporary_directory).map_err(|e| {
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000475 *is_protected = config.protectedVm;
Alan Stokes0d1ef782022-09-27 13:46:35 +0100476 let message = format!("Failed to load app config: {:?}", e);
477 error!("{}", message);
478 Status::new_service_specific_error_str(-1, Some(message))
Alan Stokes7bc146c2022-10-20 17:10:32 +0100479 })?;
480 (true, BorrowedOrOwned::Owned(config))
481 }
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000482 };
483 let config = config.as_ref();
484 *is_protected = config.protectedVm;
485
486 // Check if partition images are labeled incorrectly. This is to prevent random images
487 // which are not protected by the Android Verified Boot (e.g. bits downloaded by apps) from
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100488 // being loaded in a pVM. This applies to everything in the raw config, and everything but
489 // the non-executable, generated partitions in the app config.
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000490 config
491 .disks
492 .iter()
493 .flat_map(|disk| disk.partitions.iter())
494 .filter(|partition| {
495 if is_app_config {
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100496 !is_safe_app_partition(&partition.label)
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000497 } else {
498 true // all partitions are checked
499 }
500 })
501 .try_for_each(check_label_for_partition)
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100502 .map_err(|e| Status::new_service_specific_error_str(-1, Some(format!("{:?}", e))))?;
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000503
504 let zero_filler_path = temporary_directory.join("zero.img");
505 write_zero_filler(&zero_filler_path).map_err(|e| {
Alan Stokes70ccf162022-07-08 11:05:03 +0100506 error!("Failed to make composite image: {:?}", e);
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000507 Status::new_service_specific_error_str(
508 -1,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100509 Some(format!("Failed to make composite image: {:?}", e)),
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000510 )
511 })?;
512
513 // Assemble disk images if needed.
514 let disks = config
515 .disks
516 .iter()
517 .map(|disk| {
518 assemble_disk_image(
519 disk,
520 &zero_filler_path,
521 &temporary_directory,
522 &mut next_temporary_image_id,
523 &mut indirect_files,
524 )
525 })
526 .collect::<Result<Vec<DiskFile>, _>>()?;
527
Jiyong Parke558ab12022-07-07 20:18:55 +0900528 // Creating this ramdump file unconditionally is not harmful as ramdump will be created
529 // only when the VM is configured as such. `ramdump_write` is sent to crosvm and will
Jiyong Park4afe2012022-07-08 05:38:49 +0900530 // be the backing store for the /dev/hvc1 where VM will emit ramdump to. `ramdump_read`
Jiyong Parke558ab12022-07-07 20:18:55 +0900531 // will be sent back to the client (i.e. the VM owner) for readout.
532 let ramdump_path = temporary_directory.join("ramdump");
533 let ramdump = prepare_ramdump_file(&ramdump_path).map_err(|e| {
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100534 error!("Failed to prepare ramdump file: {:?}", e);
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000535 Status::new_service_specific_error_str(
536 -1,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100537 Some(format!("Failed to prepare ramdump file: {:?}", e)),
Jiyong Parke558ab12022-07-07 20:18:55 +0900538 )
539 })?;
540
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000541 // Actually start the VM.
542 let crosvm_config = CrosvmConfig {
543 cid,
Seungjae Yoo62085c02022-08-12 04:44:52 +0000544 name: config.name.clone(),
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000545 bootloader: maybe_clone_file(&config.bootloader)?,
546 kernel: maybe_clone_file(&config.kernel)?,
547 initrd: maybe_clone_file(&config.initrd)?,
548 disks,
549 params: config.params.to_owned(),
550 protected: *is_protected,
551 memory_mib: config.memoryMib.try_into().ok().and_then(NonZeroU32::new),
552 cpus: config.numCpus.try_into().ok().and_then(NonZeroU32::new),
Jiyong Parkdfe16d62022-04-20 17:32:12 +0900553 task_profiles: config.taskProfiles.clone(),
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000554 console_fd,
555 log_fd,
Jiyong Parke558ab12022-07-07 20:18:55 +0900556 ramdump: Some(ramdump),
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000557 indirect_files,
558 platform_version: parse_platform_version_req(&config.platformVersion)?,
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900559 detect_hangup: is_app_config,
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000560 };
561 let instance = Arc::new(
David Brazdil528e0472022-10-10 15:06:02 +0100562 VmInstance::new(
563 crosvm_config,
564 temporary_directory,
565 requester_uid,
566 requester_debug_pid,
567 vm_context,
568 )
569 .map_err(|e| {
570 error!("Failed to create VM with config {:?}: {:?}", config, e);
571 Status::new_service_specific_error_str(
572 -1,
573 Some(format!("Failed to create VM: {:?}", e)),
574 )
575 })?,
Shikha Panwar061aa2c2022-04-05 12:52:56 +0000576 );
577 state.add_vm(Arc::downgrade(&instance));
578 Ok(VirtualMachine::create(instance))
579 }
Jiyong Park8611a6c2021-07-09 18:17:44 +0900580}
581
Andrew Walbranfbb39d22021-07-28 17:01:25 +0000582fn write_zero_filler(zero_filler_path: &Path) -> Result<()> {
Jooyung Han95884632021-07-06 22:27:54 +0900583 let file = OpenOptions::new()
584 .create_new(true)
585 .read(true)
586 .write(true)
587 .open(zero_filler_path)
588 .with_context(|| "Failed to create zero.img")?;
589 file.set_len(ZERO_FILLER_SIZE)?;
Andrew Walbranfbb39d22021-07-28 17:01:25 +0000590 Ok(())
Jooyung Han95884632021-07-06 22:27:54 +0900591}
592
Jiyong Park9dd389e2021-08-23 20:42:59 +0900593fn format_as_android_vm_instance(part: &mut dyn Write) -> std::io::Result<()> {
594 part.write_all(ANDROID_VM_INSTANCE_MAGIC.as_bytes())?;
595 part.write_all(&ANDROID_VM_INSTANCE_VERSION.to_le_bytes())?;
596 part.flush()
597}
598
Shikha Panwar9fd198f2022-11-18 17:43:43 +0000599fn format_as_encryptedstore(part: &mut dyn Write) -> std::io::Result<()> {
600 part.write_all(UNFORMATTED_STORAGE_MAGIC.as_bytes())?;
601 part.flush()
602}
603
Jiyong Parke558ab12022-07-07 20:18:55 +0900604fn prepare_ramdump_file(ramdump_path: &Path) -> Result<File> {
Chris Wailes9b866f02022-11-16 15:17:16 -0800605 File::create(ramdump_path).context(format!("Failed to create ramdump file {:?}", &ramdump_path))
Jiyong Parke558ab12022-07-07 20:18:55 +0900606}
607
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000608/// Given the configuration for a disk image, assembles the `DiskFile` to pass to crosvm.
609///
610/// This may involve assembling a composite disk from a set of partition images.
611fn assemble_disk_image(
612 disk: &DiskImage,
Jooyung Han95884632021-07-06 22:27:54 +0900613 zero_filler_path: &Path,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000614 temporary_directory: &Path,
615 next_temporary_image_id: &mut u64,
616 indirect_files: &mut Vec<File>,
Andrew Walbran806f1542021-06-10 14:07:12 +0000617) -> Result<DiskFile, Status> {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000618 let image = if !disk.partitions.is_empty() {
619 if disk.image.is_some() {
620 warn!("DiskImage {:?} contains both image and partitions.", disk);
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000621 return Err(Status::new_exception_str(
Andrew Walbran806f1542021-06-10 14:07:12 +0000622 ExceptionCode::ILLEGAL_ARGUMENT,
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000623 Some("DiskImage contains both image and partitions."),
Andrew Walbran806f1542021-06-10 14:07:12 +0000624 ));
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000625 }
626
Andrew Walbran3eca16c2021-06-14 11:15:14 +0000627 let composite_image_filenames =
628 make_composite_image_filenames(temporary_directory, next_temporary_image_id);
629 let (image, partition_files) = make_composite_image(
630 &disk.partitions,
Jooyung Han95884632021-07-06 22:27:54 +0900631 zero_filler_path,
Andrew Walbran3eca16c2021-06-14 11:15:14 +0000632 &composite_image_filenames.composite,
633 &composite_image_filenames.header,
634 &composite_image_filenames.footer,
635 )
636 .map_err(|e| {
Alan Stokes70ccf162022-07-08 11:05:03 +0100637 error!("Failed to make composite image with config {:?}: {:?}", disk, e);
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000638 Status::new_service_specific_error_str(
639 -1,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100640 Some(format!("Failed to make composite image: {:?}", e)),
Andrew Walbran3eca16c2021-06-14 11:15:14 +0000641 )
642 })?;
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000643
644 // Pass the file descriptors for the various partition files to crosvm when it
645 // is run.
646 indirect_files.extend(partition_files);
647
648 image
649 } else if let Some(image) = &disk.image {
650 clone_file(image)?
651 } else {
652 warn!("DiskImage {:?} didn't contain image or partitions.", disk);
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000653 return Err(Status::new_exception_str(
Andrew Walbran806f1542021-06-10 14:07:12 +0000654 ExceptionCode::ILLEGAL_ARGUMENT,
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000655 Some("DiskImage didn't contain image or partitions."),
Andrew Walbran806f1542021-06-10 14:07:12 +0000656 ));
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000657 };
658
659 Ok(DiskFile { image, writable: disk.writable })
660}
661
Jooyung Han21e9b922021-06-26 04:14:16 +0900662fn load_app_config(
663 config: &VirtualMachineAppConfig,
664 temporary_directory: &Path,
Jooyung Hanadfb76c2021-06-28 17:29:30 +0900665) -> Result<VirtualMachineRawConfig> {
Andrew Walbrancc0db522021-07-12 17:03:42 +0000666 let apk_file = clone_file(config.apk.as_ref().unwrap())?;
667 let idsig_file = clone_file(config.idsig.as_ref().unwrap())?;
Jiyong Park8d081812021-07-23 17:45:04 +0900668 let instance_file = clone_file(config.instanceImage.as_ref().unwrap())?;
Jooyung Han21e9b922021-06-26 04:14:16 +0900669
Shikha Panwar22e70452022-10-10 18:32:55 +0000670 let storage_image = if let Some(file) = config.encryptedStorageImage.as_ref() {
671 Some(clone_file(file)?)
672 } else {
673 None
674 };
675
Alan Stokes0d1ef782022-09-27 13:46:35 +0100676 let vm_payload_config = match &config.payload {
677 Payload::ConfigPath(config_path) => {
678 load_vm_payload_config_from_file(&apk_file, config_path.as_str())
679 .with_context(|| format!("Couldn't read config from {}", config_path))?
680 }
681 Payload::PayloadConfig(payload_config) => create_vm_payload_config(payload_config),
682 };
Jooyung Han21e9b922021-06-26 04:14:16 +0900683
Alan Stokes0d1ef782022-09-27 13:46:35 +0100684 // For now, the only supported OS is Microdroid
685 let os_name = vm_payload_config.os.name.as_str();
686 if os_name != MICRODROID_OS_NAME {
Andrew Walbrancc0db522021-07-12 17:03:42 +0000687 bail!("Unknown OS \"{}\"", os_name);
Jooyung Han35edb8f2021-07-01 16:17:16 +0900688 }
Andrew Walbrancc0db522021-07-12 17:03:42 +0000689
690 // It is safe to construct a filename based on the os_name because we've already checked that it
691 // is one of the allowed values.
Jooyung Han21e9b922021-06-26 04:14:16 +0900692 let vm_config_path = PathBuf::from(format!("/apex/com.android.virt/etc/{}.json", os_name));
693 let vm_config_file = File::open(vm_config_path)?;
Andrew Walbrancc0db522021-07-12 17:03:42 +0000694 let mut vm_config = VmConfig::load(&vm_config_file)?.to_parcelable()?;
Jooyung Han21e9b922021-06-26 04:14:16 +0900695
Andrew Walbrancc045902021-07-27 16:06:17 +0000696 if config.memoryMib > 0 {
697 vm_config.memoryMib = config.memoryMib;
Andrew Walbran45bcb0c2021-07-14 15:02:06 +0000698 }
699
Seungjae Yoo62085c02022-08-12 04:44:52 +0000700 vm_config.name = config.name.clone();
Andrew Walbran3994f002022-01-27 17:33:45 +0000701 vm_config.protectedVm = config.protectedVm;
Jiyong Park032615f2022-01-10 13:55:34 +0900702 vm_config.numCpus = config.numCpus;
Jiyong Parkdfe16d62022-04-20 17:32:12 +0900703 vm_config.taskProfiles = config.taskProfiles.clone();
Jiyong Park032615f2022-01-10 13:55:34 +0900704
Shikha Panwar22e70452022-10-10 18:32:55 +0000705 // Microdroid takes additional init ramdisk & (optionally) storage image
706 add_microdroid_system_images(config, instance_file, storage_image, &mut vm_config)?;
707
708 // Include Microdroid payload disk (contains apks, idsigs) in vm config
709 add_microdroid_payload_images(
Alan Stokes0d1ef782022-09-27 13:46:35 +0100710 config,
711 temporary_directory,
712 apk_file,
713 idsig_file,
Alan Stokes0d1ef782022-09-27 13:46:35 +0100714 &vm_payload_config,
715 &mut vm_config,
716 )?;
Jooyung Han21e9b922021-06-26 04:14:16 +0900717
Andrew Walbrancc0db522021-07-12 17:03:42 +0000718 Ok(vm_config)
Jooyung Han21e9b922021-06-26 04:14:16 +0900719}
720
Alan Stokes0d1ef782022-09-27 13:46:35 +0100721fn load_vm_payload_config_from_file(apk_file: &File, config_path: &str) -> Result<VmPayloadConfig> {
722 let mut apk_zip = ZipArchive::new(apk_file)?;
723 let config_file = apk_zip.by_name(config_path)?;
724 Ok(serde_json::from_reader(config_file)?)
725}
726
727fn create_vm_payload_config(payload_config: &VirtualMachinePayloadConfig) -> VmPayloadConfig {
728 // There isn't an actual config file. Construct a synthetic VmPayloadConfig from the explicit
729 // parameters we've been given. Microdroid will do something equivalent inside the VM using the
730 // payload config that we send it via the metadata file.
Alan Stokes52d3c722022-10-04 17:27:13 +0100731 let task =
732 Task { type_: TaskType::MicrodroidLauncher, command: payload_config.payloadPath.clone() };
Alan Stokes0d1ef782022-09-27 13:46:35 +0100733 VmPayloadConfig {
734 os: OsConfig { name: MICRODROID_OS_NAME.to_owned() },
735 task: Some(task),
736 apexes: vec![],
737 extra_apks: vec![],
738 prefer_staged: false,
Alan Stokes1f417c92022-09-29 15:13:28 +0100739 export_tombstones: false,
Alan Stokes0d1ef782022-09-27 13:46:35 +0100740 enable_authfs: false,
741 }
742}
743
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000744/// Generates a unique filename to use for a composite disk image.
Andrew Walbran3eca16c2021-06-14 11:15:14 +0000745fn make_composite_image_filenames(
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000746 temporary_directory: &Path,
747 next_temporary_image_id: &mut u64,
Andrew Walbran3eca16c2021-06-14 11:15:14 +0000748) -> CompositeImageFilenames {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000749 let id = *next_temporary_image_id;
750 *next_temporary_image_id += 1;
Andrew Walbran3eca16c2021-06-14 11:15:14 +0000751 CompositeImageFilenames {
752 composite: temporary_directory.join(format!("composite-{}.img", id)),
753 header: temporary_directory.join(format!("composite-{}-header.img", id)),
754 footer: temporary_directory.join(format!("composite-{}-footer.img", id)),
755 }
756}
757
758/// Filenames for a composite disk image, including header and footer partitions.
759#[derive(Clone, Debug, Eq, PartialEq)]
760struct CompositeImageFilenames {
761 /// The composite disk image itself.
762 composite: PathBuf,
763 /// The header partition image.
764 header: PathBuf,
765 /// The footer partition image.
766 footer: PathBuf,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000767}
768
Jiyong Park753553b2021-07-12 21:21:09 +0900769/// Checks whether the caller has a specific permission
770fn check_permission(perm: &str) -> binder::Result<()> {
771 let calling_pid = ThreadState::get_calling_pid();
772 let calling_uid = ThreadState::get_calling_uid();
773 // Root can do anything
774 if calling_uid == 0 {
775 return Ok(());
776 }
777 let perm_svc: Strong<dyn IPermissionController::IPermissionController> =
778 binder::get_interface("permission")?;
779 if perm_svc.checkPermission(perm, calling_pid, calling_uid as i32)? {
Andrew Walbran806f1542021-06-10 14:07:12 +0000780 Ok(())
781 } else {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000782 Err(Status::new_exception_str(
Jiyong Park753553b2021-07-12 21:21:09 +0900783 ExceptionCode::SECURITY,
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000784 Some(format!("does not have the {} permission", perm)),
Jiyong Park753553b2021-07-12 21:21:09 +0900785 ))
Andrew Walbran806f1542021-06-10 14:07:12 +0000786 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000787}
788
Jiyong Park753553b2021-07-12 21:21:09 +0900789/// Check whether the caller of the current Binder method is allowed to call debug methods.
790fn check_debug_access() -> binder::Result<()> {
791 check_permission("android.permission.DEBUG_VIRTUAL_MACHINE")
792}
793
794/// Check whether the caller of the current Binder method is allowed to manage VMs
795fn check_manage_access() -> binder::Result<()> {
796 check_permission("android.permission.MANAGE_VIRTUAL_MACHINE")
797}
798
Inseob Kim1119d702022-05-02 18:01:58 +0900799/// Check whether the caller of the current Binder method is allowed to create custom VMs
800fn check_use_custom_virtual_machine() -> binder::Result<()> {
801 check_permission("android.permission.USE_CUSTOM_VIRTUAL_MACHINE")
802}
803
Jiyong Park029977d2021-11-24 21:56:49 +0900804/// Check if a partition has selinux labels that are not allowed
805fn check_label_for_partition(partition: &Partition) -> Result<()> {
806 let ctx = getfilecon(partition.image.as_ref().unwrap().as_ref())?;
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100807 check_label_is_allowed(&ctx).with_context(|| format!("Partition {} invalid", &partition.label))
808}
809
810// Return whether a partition is exempt from selinux label checks, because we know that it does
811// not contain code and is likely to be generated in an app-writable directory.
812fn is_safe_app_partition(label: &str) -> bool {
813 // See make_payload_disk in payload.rs.
814 label == "vm-instance"
815 || label == "microdroid-apk-idsig"
816 || label == "payload-metadata"
817 || label.starts_with("extra-idsig-")
818}
819
820fn check_label_is_allowed(ctx: &SeContext) -> Result<()> {
821 // We only want to allow code in a VM payload to be sourced from places that apps, and the
822 // system, do not have write access to.
823 // (Note that sepolicy must also grant read access for these types to both virtualization
824 // service and crosvm.)
825 // App private data files are deliberately excluded, to avoid arbitrary payloads being run on
826 // user devices (W^X).
827 match ctx.selinux_type()? {
828 | "system_file" // immutable dm-verity protected partition
829 | "apk_data_file" // APKs of an installed app
830 | "staging_data_file" // updated/staged APEX imagess
831 | "shell_data_file" // test files created via adb shell
832 => Ok(()),
833 _ => bail!("Label {} is not allowed", ctx),
Jiyong Park029977d2021-11-24 21:56:49 +0900834 }
835}
836
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000837/// Implementation of the AIDL `IVirtualMachine` interface. Used as a handle to a VM.
838#[derive(Debug)]
839struct VirtualMachine {
840 instance: Arc<VmInstance>,
Alan Stokes0cc59ee2021-09-24 11:20:34 +0100841 /// Keeps our service process running as long as this VM instance exists.
Chris Wailes641fc4a2021-12-01 15:03:21 -0800842 #[allow(dead_code)]
Alan Stokes0cc59ee2021-09-24 11:20:34 +0100843 lazy_service_guard: LazyServiceGuard,
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000844}
845
846impl VirtualMachine {
847 fn create(instance: Arc<VmInstance>) -> Strong<dyn IVirtualMachine> {
Alan Stokes0cc59ee2021-09-24 11:20:34 +0100848 let binder = VirtualMachine { instance, lazy_service_guard: Default::default() };
Andrew Walbran4de28782021-04-13 14:51:43 +0000849 BnVirtualMachine::new_binder(binder, BinderFeatures::default())
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000850 }
851}
852
853impl Interface for VirtualMachine {}
854
855impl IVirtualMachine for VirtualMachine {
856 fn getCid(&self) -> binder::Result<i32> {
Jiyong Park753553b2021-07-12 21:21:09 +0900857 // Don't check permission. The owner of the VM might have passed this binder object to
858 // others.
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000859 Ok(self.instance.cid as i32)
860 }
Andrew Walbrandae07162021-03-12 17:05:20 +0000861
Andrew Walbran6b650662021-09-07 13:13:23 +0000862 fn getState(&self) -> binder::Result<VirtualMachineState> {
Jiyong Park753553b2021-07-12 21:21:09 +0900863 // Don't check permission. The owner of the VM might have passed this binder object to
864 // others.
Andrew Walbran6b650662021-09-07 13:13:23 +0000865 Ok(get_state(&self.instance))
Andrew Walbrandae07162021-03-12 17:05:20 +0000866 }
867
868 fn registerCallback(
869 &self,
870 callback: &Strong<dyn IVirtualMachineCallback>,
871 ) -> binder::Result<()> {
Jiyong Park753553b2021-07-12 21:21:09 +0900872 // Don't check permission. The owner of the VM might have passed this binder object to
873 // others.
874 //
Andrew Walbrandae07162021-03-12 17:05:20 +0000875 // TODO: Should this give an error if the VM is already dead?
876 self.instance.callbacks.add(callback.clone());
877 Ok(())
878 }
Andrew Walbrancbe8b082021-08-06 15:42:11 +0000879
Andrew Walbranf8d94112021-09-07 11:45:36 +0000880 fn start(&self) -> binder::Result<()> {
881 self.instance.start().map_err(|e| {
882 error!("Error starting VM with CID {}: {:?}", self.instance.cid, e);
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000883 Status::new_service_specific_error_str(-1, Some(e.to_string()))
Andrew Walbranf8d94112021-09-07 11:45:36 +0000884 })
885 }
886
Inseob Kima446f802022-07-11 19:46:37 +0900887 fn stop(&self) -> binder::Result<()> {
888 self.instance.kill().map_err(|e| {
889 error!("Error stopping VM with CID {}: {:?}", self.instance.cid, e);
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000890 Status::new_service_specific_error_str(-1, Some(e.to_string()))
Inseob Kima446f802022-07-11 19:46:37 +0900891 })
892 }
893
Andrew Walbrancbe8b082021-08-06 15:42:11 +0000894 fn connectVsock(&self, port: i32) -> binder::Result<ParcelFileDescriptor> {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000895 if !matches!(&*self.instance.vm_state.lock().unwrap(), VmState::Running { .. }) {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000896 return Err(Status::new_service_specific_error_str(-1, Some("VM is not running")));
Andrew Walbrancbe8b082021-08-06 15:42:11 +0000897 }
898 let stream =
899 VsockStream::connect_with_cid_port(self.instance.cid, port as u32).map_err(|e| {
Andrew Walbrandcf9d582022-08-03 11:25:24 +0000900 Status::new_service_specific_error_str(
901 -1,
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100902 Some(format!("Failed to connect: {:?}", e)),
Andrew Walbrancbe8b082021-08-06 15:42:11 +0000903 )
904 })?;
905 Ok(vsock_stream_to_pfd(stream))
906 }
Andrew Walbrandae07162021-03-12 17:05:20 +0000907}
908
909impl Drop for VirtualMachine {
910 fn drop(&mut self) {
911 debug!("Dropping {:?}", self);
Inseob Kima446f802022-07-11 19:46:37 +0900912 if let Err(e) = self.instance.kill() {
913 debug!("Error stopping dropped VM with CID {}: {:?}", self.instance.cid, e);
914 }
Andrew Walbrandae07162021-03-12 17:05:20 +0000915 }
916}
917
918/// A set of Binders to be called back in response to various events on the VM, such as when it
919/// dies.
920#[derive(Debug, Default)]
921pub struct VirtualMachineCallbacks(Mutex<Vec<Strong<dyn IVirtualMachineCallback>>>);
922
923impl VirtualMachineCallbacks {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900924 /// Call all registered callbacks to notify that the payload has started.
David Brazdil451cc962022-10-14 14:08:12 +0100925 pub fn notify_payload_started(&self, cid: Cid) {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900926 let callbacks = &*self.0.lock().unwrap();
Jiyong Park8611a6c2021-07-09 18:17:44 +0900927 for callback in callbacks {
David Brazdil451cc962022-10-14 14:08:12 +0100928 if let Err(e) = callback.onPayloadStarted(cid as i32) {
Alan Stokes70ccf162022-07-08 11:05:03 +0100929 error!("Error notifying payload start event from VM CID {}: {:?}", cid, e);
Jiyong Park8611a6c2021-07-09 18:17:44 +0900930 }
931 }
932 }
933
Inseob Kim14cb8692021-08-31 21:50:39 +0900934 /// Call all registered callbacks to notify that the payload is ready to serve.
935 pub fn notify_payload_ready(&self, cid: Cid) {
936 let callbacks = &*self.0.lock().unwrap();
937 for callback in callbacks {
938 if let Err(e) = callback.onPayloadReady(cid as i32) {
Alan Stokes70ccf162022-07-08 11:05:03 +0100939 error!("Error notifying payload ready event from VM CID {}: {:?}", cid, e);
Inseob Kim14cb8692021-08-31 21:50:39 +0900940 }
941 }
942 }
943
Inseob Kim2444af92021-08-31 01:22:50 +0900944 /// Call all registered callbacks to notify that the payload has finished.
945 pub fn notify_payload_finished(&self, cid: Cid, exit_code: i32) {
946 let callbacks = &*self.0.lock().unwrap();
947 for callback in callbacks {
948 if let Err(e) = callback.onPayloadFinished(cid as i32, exit_code) {
Alan Stokes70ccf162022-07-08 11:05:03 +0100949 error!("Error notifying payload finish event from VM CID {}: {:?}", cid, e);
Inseob Kim2444af92021-08-31 01:22:50 +0900950 }
951 }
952 }
953
Jooyung Handd0a1732021-11-23 15:26:20 +0900954 /// Call all registered callbacks to say that the VM encountered an error.
Alan Stokes2bead0d2022-09-05 16:58:34 +0100955 pub fn notify_error(&self, cid: Cid, error_code: ErrorCode, message: &str) {
Jooyung Handd0a1732021-11-23 15:26:20 +0900956 let callbacks = &*self.0.lock().unwrap();
957 for callback in callbacks {
958 if let Err(e) = callback.onError(cid as i32, error_code, message) {
Alan Stokes70ccf162022-07-08 11:05:03 +0100959 error!("Error notifying error event from VM CID {}: {:?}", cid, e);
Jooyung Handd0a1732021-11-23 15:26:20 +0900960 }
961 }
962 }
963
Andrew Walbrandae07162021-03-12 17:05:20 +0000964 /// Call all registered callbacks to say that the VM has died.
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000965 pub fn callback_on_died(&self, cid: Cid, reason: DeathReason) {
Andrew Walbrandae07162021-03-12 17:05:20 +0000966 let callbacks = &*self.0.lock().unwrap();
967 for callback in callbacks {
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000968 if let Err(e) = callback.onDied(cid as i32, reason) {
Alan Stokes70ccf162022-07-08 11:05:03 +0100969 error!("Error notifying exit of VM CID {}: {:?}", cid, e);
Andrew Walbrandae07162021-03-12 17:05:20 +0000970 }
971 }
972 }
973
Jiyong Parke558ab12022-07-07 20:18:55 +0900974 /// Call all registered callbacks to say that there was a ramdump to download.
975 pub fn callback_on_ramdump(&self, cid: Cid, ramdump: File) {
976 let callbacks = &*self.0.lock().unwrap();
977 let pfd = ParcelFileDescriptor::new(ramdump);
978 for callback in callbacks {
979 if let Err(e) = callback.onRamdump(cid as i32, &pfd) {
Alan Stokes53cc5ca2022-08-30 14:28:19 +0100980 error!("Error notifying ramdump of VM CID {}: {:?}", cid, e);
Jiyong Parke558ab12022-07-07 20:18:55 +0900981 }
982 }
983 }
984
Andrew Walbrandae07162021-03-12 17:05:20 +0000985 /// Add a new callback to the set.
986 fn add(&self, callback: Strong<dyn IVirtualMachineCallback>) {
987 self.0.lock().unwrap().push(callback);
988 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000989}
990
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000991/// The mutable state of the VirtualizationService. There should only be one instance of this
992/// struct.
Chris Wailes641fc4a2021-12-01 15:03:21 -0800993#[derive(Debug, Default)]
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000994struct State {
Andrew Walbran320b5602021-03-04 16:11:12 +0000995 /// The VMs which have been started. When VMs are started a weak reference is added to this list
996 /// while a strong reference is returned to the caller over Binder. Once all copies of the
997 /// Binder client are dropped the weak reference here will become invalid, and will be removed
998 /// from the list opportunistically the next time `add_vm` is called.
999 vms: Vec<Weak<VmInstance>>,
David Brazdil3c2ddef2021-03-18 13:09:57 +00001000
1001 /// Vector of strong VM references held on behalf of users that cannot hold them themselves.
1002 /// This is only used for debugging purposes.
1003 debug_held_vms: Vec<Strong<dyn IVirtualMachine>>,
Andrew Walbran320b5602021-03-04 16:11:12 +00001004}
1005
1006impl State {
Andrew Walbrandae07162021-03-12 17:05:20 +00001007 /// Get a list of VMs which still have Binder references to them.
Andrew Walbran320b5602021-03-04 16:11:12 +00001008 fn vms(&self) -> Vec<Arc<VmInstance>> {
1009 // Attempt to upgrade the weak pointers to strong pointers.
1010 self.vms.iter().filter_map(Weak::upgrade).collect()
1011 }
1012
1013 /// Add a new VM to the list.
1014 fn add_vm(&mut self, vm: Weak<VmInstance>) {
1015 // Garbage collect any entries from the stored list which no longer exist.
1016 self.vms.retain(|vm| vm.strong_count() > 0);
1017
1018 // Actually add the new VM.
1019 self.vms.push(vm);
1020 }
David Brazdil3c2ddef2021-03-18 13:09:57 +00001021
Jiyong Park8611a6c2021-07-09 18:17:44 +09001022 /// Get a VM that corresponds to the given cid
1023 fn get_vm(&self, cid: Cid) -> Option<Arc<VmInstance>> {
1024 self.vms().into_iter().find(|vm| vm.cid == cid)
1025 }
1026
David Brazdil3c2ddef2021-03-18 13:09:57 +00001027 /// Store a strong VM reference.
1028 fn debug_hold_vm(&mut self, vm: Strong<dyn IVirtualMachine>) {
1029 self.debug_held_vms.push(vm);
1030 }
1031
1032 /// Retrieve and remove a strong VM reference.
1033 fn debug_drop_vm(&mut self, cid: i32) -> Option<Strong<dyn IVirtualMachine>> {
1034 let pos = self.debug_held_vms.iter().position(|vm| vm.getCid() == Ok(cid))?;
Alan Stokes7e54e292021-09-09 11:37:56 +01001035 let vm = self.debug_held_vms.swap_remove(pos);
Alan Stokes7e54e292021-09-09 11:37:56 +01001036 Some(vm)
David Brazdil3c2ddef2021-03-18 13:09:57 +00001037 }
Jiyong Parkd50a0242021-09-16 21:00:14 +09001038}
1039
Andrew Walbran6b650662021-09-07 13:13:23 +00001040/// Gets the `VirtualMachineState` of the given `VmInstance`.
1041fn get_state(instance: &VmInstance) -> VirtualMachineState {
Andrew Walbranf8d94112021-09-07 11:45:36 +00001042 match &*instance.vm_state.lock().unwrap() {
1043 VmState::NotStarted { .. } => VirtualMachineState::NOT_STARTED,
1044 VmState::Running { .. } => match instance.payload_state() {
Andrew Walbran6b650662021-09-07 13:13:23 +00001045 PayloadState::Starting => VirtualMachineState::STARTING,
1046 PayloadState::Started => VirtualMachineState::STARTED,
1047 PayloadState::Ready => VirtualMachineState::READY,
1048 PayloadState::Finished => VirtualMachineState::FINISHED,
Jiyong Parka4eebde2022-07-12 18:01:12 +09001049 PayloadState::Hangup => VirtualMachineState::DEAD,
Andrew Walbranf8d94112021-09-07 11:45:36 +00001050 },
1051 VmState::Dead => VirtualMachineState::DEAD,
1052 VmState::Failed => VirtualMachineState::DEAD,
Andrew Walbran6b650662021-09-07 13:13:23 +00001053 }
1054}
1055
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +00001056/// Converts a `&ParcelFileDescriptor` to a `File` by cloning the file.
Seungjae Yoo0a8c84c2022-07-11 08:19:15 +00001057pub fn clone_file(file: &ParcelFileDescriptor) -> Result<File, Status> {
Andrew Walbran806f1542021-06-10 14:07:12 +00001058 file.as_ref().try_clone().map_err(|e| {
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001059 Status::new_exception_str(
Andrew Walbran806f1542021-06-10 14:07:12 +00001060 ExceptionCode::BAD_PARCELABLE,
Alan Stokes53cc5ca2022-08-30 14:28:19 +01001061 Some(format!("Failed to clone File from ParcelFileDescriptor: {:?}", e)),
Andrew Walbran806f1542021-06-10 14:07:12 +00001062 )
1063 })
1064}
1065
Andrew Walbrand3a84182021-09-07 14:48:52 +00001066/// Converts an `&Option<ParcelFileDescriptor>` to an `Option<File>` by cloning the file.
1067fn maybe_clone_file(file: &Option<ParcelFileDescriptor>) -> Result<Option<File>, Status> {
1068 file.as_ref().map(clone_file).transpose()
1069}
1070
Andrew Walbrancbe8b082021-08-06 15:42:11 +00001071/// Converts a `VsockStream` to a `ParcelFileDescriptor`.
1072fn vsock_stream_to_pfd(stream: VsockStream) -> ParcelFileDescriptor {
1073 // SAFETY: ownership is transferred from stream to f
1074 let f = unsafe { File::from_raw_fd(stream.into_raw_fd()) };
1075 ParcelFileDescriptor::new(f)
1076}
1077
Jiyong Parkdcf17412022-02-08 15:07:23 +09001078/// Parses the platform version requirement string.
1079fn parse_platform_version_req(s: &str) -> Result<VersionReq, Status> {
1080 VersionReq::parse(s).map_err(|e| {
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001081 Status::new_exception_str(
Jiyong Parkdcf17412022-02-08 15:07:23 +09001082 ExceptionCode::BAD_PARCELABLE,
Alan Stokes53cc5ca2022-08-30 14:28:19 +01001083 Some(format!("Invalid platform version requirement {}: {:?}", s, e)),
Jiyong Parkdcf17412022-02-08 15:07:23 +09001084 )
1085 })
1086}
1087
Jooyung Han35edb8f2021-07-01 16:17:16 +09001088/// Simple utility for referencing Borrowed or Owned. Similar to std::borrow::Cow, but
1089/// it doesn't require that T implements Clone.
1090enum BorrowedOrOwned<'a, T> {
1091 Borrowed(&'a T),
1092 Owned(T),
1093}
1094
1095impl<'a, T> AsRef<T> for BorrowedOrOwned<'a, T> {
1096 fn as_ref(&self) -> &T {
1097 match self {
1098 Self::Borrowed(b) => b,
Chris Wailes68c39f82021-07-27 16:03:44 -07001099 Self::Owned(o) => o,
Jooyung Han35edb8f2021-07-01 16:17:16 +09001100 }
1101 }
1102}
Inseob Kim1b95f2e2021-08-19 13:17:40 +09001103
1104/// Implementation of `IVirtualMachineService`, the entry point of the AIDL service.
1105#[derive(Debug, Default)]
1106struct VirtualMachineService {
1107 state: Arc<Mutex<State>>,
Inseob Kimc7d28c72021-10-25 14:28:10 +00001108 cid: Cid,
Inseob Kim1b95f2e2021-08-19 13:17:40 +09001109}
1110
1111impl Interface for VirtualMachineService {}
1112
1113impl IVirtualMachineService for VirtualMachineService {
Inseob Kimc7d28c72021-10-25 14:28:10 +00001114 fn notifyPayloadStarted(&self) -> binder::Result<()> {
1115 let cid = self.cid;
Inseob Kim7f61fe72021-08-20 20:50:47 +09001116 if let Some(vm) = self.state.lock().unwrap().get_vm(cid) {
David Brazdil415097c2022-10-21 14:17:05 +01001117 info!("VM with CID {} started payload", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001118 vm.update_payload_state(PayloadState::Started).map_err(|e| {
1119 Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string()))
1120 })?;
David Brazdil451cc962022-10-14 14:08:12 +01001121 vm.callbacks.notify_payload_started(cid);
Seungjae Yoo62085c02022-08-12 04:44:52 +00001122
Seungjae Yoo6d265d92022-11-15 10:51:33 +09001123 let vm_start_timestamp = vm.vm_metric.lock().unwrap().start_timestamp;
1124 write_vm_booted_stats(vm.requester_uid as i32, &vm.name, vm_start_timestamp);
Inseob Kim7f61fe72021-08-20 20:50:47 +09001125 Ok(())
1126 } else {
Jooyung Handd0a1732021-11-23 15:26:20 +09001127 error!("notifyPayloadStarted is called from an unknown CID {}", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001128 Err(Status::new_service_specific_error_str(
1129 -1,
1130 Some(format!("cannot find a VM with CID {}", cid)),
Inseob Kim7f61fe72021-08-20 20:50:47 +09001131 ))
Inseob Kim1b95f2e2021-08-19 13:17:40 +09001132 }
Inseob Kim1b95f2e2021-08-19 13:17:40 +09001133 }
Inseob Kim2444af92021-08-31 01:22:50 +09001134
Inseob Kimc7d28c72021-10-25 14:28:10 +00001135 fn notifyPayloadReady(&self) -> binder::Result<()> {
1136 let cid = self.cid;
Inseob Kim14cb8692021-08-31 21:50:39 +09001137 if let Some(vm) = self.state.lock().unwrap().get_vm(cid) {
David Brazdil415097c2022-10-21 14:17:05 +01001138 info!("VM with CID {} reported payload is ready", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001139 vm.update_payload_state(PayloadState::Ready).map_err(|e| {
1140 Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string()))
1141 })?;
Inseob Kim14cb8692021-08-31 21:50:39 +09001142 vm.callbacks.notify_payload_ready(cid);
1143 Ok(())
1144 } else {
Jooyung Handd0a1732021-11-23 15:26:20 +09001145 error!("notifyPayloadReady is called from an unknown CID {}", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001146 Err(Status::new_service_specific_error_str(
1147 -1,
1148 Some(format!("cannot find a VM with CID {}", cid)),
Inseob Kim14cb8692021-08-31 21:50:39 +09001149 ))
1150 }
1151 }
1152
Inseob Kimc7d28c72021-10-25 14:28:10 +00001153 fn notifyPayloadFinished(&self, exit_code: i32) -> binder::Result<()> {
1154 let cid = self.cid;
Inseob Kim2444af92021-08-31 01:22:50 +09001155 if let Some(vm) = self.state.lock().unwrap().get_vm(cid) {
David Brazdil415097c2022-10-21 14:17:05 +01001156 info!("VM with CID {} finished payload", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001157 vm.update_payload_state(PayloadState::Finished).map_err(|e| {
1158 Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string()))
1159 })?;
Inseob Kim2444af92021-08-31 01:22:50 +09001160 vm.callbacks.notify_payload_finished(cid, exit_code);
1161 Ok(())
1162 } else {
Jooyung Handd0a1732021-11-23 15:26:20 +09001163 error!("notifyPayloadFinished is called from an unknown CID {}", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001164 Err(Status::new_service_specific_error_str(
1165 -1,
1166 Some(format!("cannot find a VM with CID {}", cid)),
Jooyung Handd0a1732021-11-23 15:26:20 +09001167 ))
1168 }
1169 }
1170
Alan Stokes2bead0d2022-09-05 16:58:34 +01001171 fn notifyError(&self, error_code: ErrorCode, message: &str) -> binder::Result<()> {
Jooyung Handd0a1732021-11-23 15:26:20 +09001172 let cid = self.cid;
1173 if let Some(vm) = self.state.lock().unwrap().get_vm(cid) {
David Brazdil415097c2022-10-21 14:17:05 +01001174 info!("VM with CID {} encountered an error", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001175 vm.update_payload_state(PayloadState::Finished).map_err(|e| {
1176 Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string()))
1177 })?;
Jooyung Handd0a1732021-11-23 15:26:20 +09001178 vm.callbacks.notify_error(cid, error_code, message);
1179 Ok(())
1180 } else {
Seungjae Yooec8c1602022-06-20 05:28:00 +00001181 error!("notifyError is called from an unknown CID {}", cid);
Andrew Walbrandcf9d582022-08-03 11:25:24 +00001182 Err(Status::new_service_specific_error_str(
1183 -1,
1184 Some(format!("cannot find a VM with CID {}", cid)),
Inseob Kim2444af92021-08-31 01:22:50 +09001185 ))
1186 }
1187 }
Inseob Kim1b95f2e2021-08-19 13:17:40 +09001188}
1189
1190impl VirtualMachineService {
Andrew Walbran0fd0ff02022-07-29 15:59:17 +00001191 fn factory(cid: Cid, state: &Arc<Mutex<State>>) -> Option<SpIBinder> {
Inseob Kimc7d28c72021-10-25 14:28:10 +00001192 if let Some(vm) = state.lock().unwrap().get_vm(cid) {
1193 let mut vm_service = vm.vm_service.lock().unwrap();
1194 let service = vm_service.get_or_insert_with(|| Self::new_binder(state.clone(), cid));
Andrew Walbran0fd0ff02022-07-29 15:59:17 +00001195 Some(service.as_binder())
Inseob Kimc7d28c72021-10-25 14:28:10 +00001196 } else {
1197 error!("connection from cid={} is not from a guest VM", cid);
Andrew Walbran0fd0ff02022-07-29 15:59:17 +00001198 None
Inseob Kimc7d28c72021-10-25 14:28:10 +00001199 }
1200 }
1201
1202 fn new_binder(state: Arc<Mutex<State>>, cid: Cid) -> Strong<dyn IVirtualMachineService> {
Inseob Kim1b95f2e2021-08-19 13:17:40 +09001203 BnVirtualMachineService::new_binder(
Inseob Kimc7d28c72021-10-25 14:28:10 +00001204 VirtualMachineService { state, cid },
Inseob Kim1b95f2e2021-08-19 13:17:40 +09001205 BinderFeatures::default(),
1206 )
1207 }
1208}
Alan Stokes53cc5ca2022-08-30 14:28:19 +01001209
1210#[cfg(test)]
1211mod tests {
1212 use super::*;
1213
1214 #[test]
1215 fn test_is_allowed_label_for_partition() -> Result<()> {
1216 let expected_results = vec![
1217 ("u:object_r:system_file:s0", true),
1218 ("u:object_r:apk_data_file:s0", true),
1219 ("u:object_r:app_data_file:s0", false),
1220 ("u:object_r:app_data_file:s0:c512,c768", false),
1221 ("u:object_r:privapp_data_file:s0:c512,c768", false),
1222 ("invalid", false),
1223 ("user:role:apk_data_file:severity:categories", true),
1224 ("user:role:apk_data_file:severity:categories:extraneous", false),
1225 ];
1226
1227 for (label, expected_valid) in expected_results {
1228 let context = SeContext::new(label)?;
1229 let result = check_label_is_allowed(&context);
1230 if expected_valid {
1231 assert!(result.is_ok(), "Expected label {} to be allowed, got {:?}", label, result);
1232 } else if result.is_ok() {
1233 bail!("Expected label {} to be disallowed", label);
1234 }
1235 }
1236 Ok(())
1237 }
1238}