blob: e42f159cf98a0499a1ce44faefd2ddeac6ed0d97 [file] [log] [blame]
Jooyung Han347d9f22021-05-28 00:05:14 +09001// 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
15//! Microdroid Manager
16
Andrew Sculld64ae7d2022-10-05 17:41:43 +000017mod dice;
Jiyong Park21ce2c52021-08-28 02:32:17 +090018mod instance;
Jooyung Hanf48ceb42021-06-01 18:00:04 +090019mod ioutil;
Jooyung Han7a343f92021-09-08 22:53:11 +090020mod payload;
Seungjae Yoofd9a0622022-10-14 10:01:29 +090021mod procutil;
Keir Fraser933f0ac2022-10-12 08:23:28 +000022mod swap;
Alice Wang59a9e562022-10-04 15:24:10 +000023mod vm_payload_service;
Jooyung Han347d9f22021-05-28 00:05:14 +090024
Andrew Sculld64ae7d2022-10-05 17:41:43 +000025use crate::dice::{DiceContext, DiceDriver};
Inseob Kime379e7d2022-07-22 18:55:18 +090026use crate::instance::{ApexData, ApkData, InstanceDisk, MicrodroidData, RootHash};
Alice Wang59a9e562022-10-04 15:24:10 +000027use crate::vm_payload_service::register_vm_payload_service;
Alan Stokes2bead0d2022-09-05 16:58:34 +010028use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::ErrorCode::ErrorCode;
Seungjae Yoofd9a0622022-10-14 10:01:29 +090029use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::{
30 IVirtualMachineService::{
31 IVirtualMachineService, VM_BINDER_SERVICE_PORT, VM_STREAM_SERVICE_PORT,
32 },
33 VirtualMachineCpuStatus::VirtualMachineCpuStatus,
34 VirtualMachineMemStatus::VirtualMachineMemStatus,
Alan Stokes2bead0d2022-09-05 16:58:34 +010035};
Jooyung Handd0a1732021-11-23 15:26:20 +090036use anyhow::{anyhow, bail, ensure, Context, Error, Result};
Alice Wang1bf3d782022-09-28 07:56:36 +000037use apkverify::{get_public_key_der, verify, V4Signature};
Andrew Sculld64ae7d2022-10-05 17:41:43 +000038use binder::{ProcessState, Strong};
Alan Stokes1f417c92022-09-29 15:13:28 +010039use diced_utils::cbor::{encode_header, encode_number};
Inseob Kim197748b2021-12-01 19:49:00 +090040use glob::glob;
Inseob Kim197748b2021-12-01 19:49:00 +090041use itertools::sorted;
David Brazdila07a1792022-10-25 13:37:57 +010042use libc::VMADDR_CID_HOST;
Andrew Scull684590f2022-01-27 16:14:26 +000043use log::{error, info};
Alan Stokes0d1ef782022-09-27 13:46:35 +010044use microdroid_metadata::{write_metadata, Metadata, PayloadMetadata};
Seungjae Yoofd9a0622022-10-14 10:01:29 +090045use microdroid_payload_config::{OsConfig, Task, TaskType, VmPayloadConfig};
Andrew Sculla0d1b1a2022-05-24 19:32:47 +000046use openssl::sha::Sha512;
Jooyung Han4a9b3bf2021-09-10 17:19:00 +090047use payload::{get_apex_data_from_payload, load_metadata, to_metadata};
Seungjae Yoofd9a0622022-10-14 10:01:29 +090048use procutil::{get_cpu_time, get_mem_info};
Andrew Scull34916a72022-01-30 21:34:24 +000049use rand::Fill;
Andrew Walbran7eb5ca42022-08-08 15:33:34 +000050use rpcbinder::get_vsock_rpc_interface;
Jiyong Parkbb4a9872021-09-06 15:59:21 +090051use rustutils::system_properties;
Joel Galenson482704c2021-07-29 15:53:53 -070052use rustutils::system_properties::PropertyWatcher;
Alan Stokes3ba10fd2022-10-06 15:46:51 +010053use std::borrow::Cow::{Borrowed, Owned};
Andrew Scullb2f44472022-01-21 14:41:34 +000054use std::convert::TryInto;
Inseob Kim197748b2021-12-01 19:49:00 +090055use std::fs::{self, create_dir, File, OpenOptions};
Inseob Kim11f40d02022-06-13 17:16:00 +090056use std::io::Write;
Inseob Kimc7d28c72021-10-25 14:28:10 +000057use std::os::unix::io::{FromRawFd, IntoRawFd};
Jooyung Hanf48ceb42021-06-01 18:00:04 +090058use std::path::Path;
Inseob Kim217038e2021-11-25 11:15:06 +090059use std::process::{Child, Command, Stdio};
Jiyong Park8611a6c2021-07-09 18:17:44 +090060use std::str;
Seungjae Yoofd9a0622022-10-14 10:01:29 +090061use std::thread;
Jiyong Parkbb4a9872021-09-06 15:59:21 +090062use std::time::{Duration, SystemTime};
Jiyong Park8611a6c2021-07-09 18:17:44 +090063use vsock::VsockStream;
Jooyung Han634e2d72021-06-10 16:27:38 +090064
65const WAIT_TIMEOUT: Duration = Duration::from_secs(10);
Seungjae Yoo2b893b92022-10-26 14:29:27 +090066const SENDING_VM_STATUS_CYCLE_PERIOD: Duration = Duration::from_secs(60);
Inseob Kim197748b2021-12-01 19:49:00 +090067const MAIN_APK_PATH: &str = "/dev/block/by-name/microdroid-apk";
68const MAIN_APK_IDSIG_PATH: &str = "/dev/block/by-name/microdroid-apk-idsig";
69const MAIN_APK_DEVICE_NAME: &str = "microdroid-apk";
70const EXTRA_APK_PATH_PATTERN: &str = "/dev/block/by-name/extra-apk-*";
71const EXTRA_IDSIG_PATH_PATTERN: &str = "/dev/block/by-name/extra-idsig-*";
Jooyung Han19c1d6c2021-08-06 14:08:16 +090072const DM_MOUNTED_APK_PATH: &str = "/dev/block/mapper/microdroid-apk";
Inseob Kim217038e2021-11-25 11:15:06 +090073const APKDMVERITY_BIN: &str = "/system/bin/apkdmverity";
74const ZIPFUSE_BIN: &str = "/system/bin/zipfuse";
Andrew Scullab72ec52022-03-14 09:10:52 +000075const AVF_STRICT_BOOT: &str = "/sys/firmware/devicetree/base/chosen/avf,strict-boot";
76const AVF_NEW_INSTANCE: &str = "/sys/firmware/devicetree/base/chosen/avf,new-instance";
Inseob Kime379e7d2022-07-22 18:55:18 +090077const DEBUG_MICRODROID_NO_VERIFIED_BOOT: &str =
78 "/sys/firmware/devicetree/base/virtualization/guest/debug-microdroid,no-verified-boot";
Jooyung Han347d9f22021-05-28 00:05:14 +090079
Jiyong Parkbb4a9872021-09-06 15:59:21 +090080const APEX_CONFIG_DONE_PROP: &str = "apex_config.done";
Andrew Scull65ddfc42022-02-14 21:03:58 +000081const APP_DEBUGGABLE_PROP: &str = "ro.boot.microdroid.app_debuggable";
Alan Stokes60f82202022-10-07 16:40:07 +010082const APK_MOUNT_DONE_PROP: &str = "microdroid_manager.apk.mounted";
Jiyong Parkbb4a9872021-09-06 15:59:21 +090083
Inseob Kim11f40d02022-06-13 17:16:00 +090084// SYNC WITH virtualizationservice/src/crosvm.rs
85const FAILURE_SERIAL_DEVICE: &str = "/dev/ttyS1";
86
Jooyung Handd0a1732021-11-23 15:26:20 +090087#[derive(thiserror::Error, Debug)]
88enum MicrodroidError {
Inseob Kim11f40d02022-06-13 17:16:00 +090089 #[error("Cannot connect to virtualization service: {0}")]
90 FailedToConnectToVirtualizationService(String),
Jooyung Handd0a1732021-11-23 15:26:20 +090091 #[error("Payload has changed: {0}")]
92 PayloadChanged(String),
93 #[error("Payload verification has failed: {0}")]
94 PayloadVerificationFailed(String),
Jooyung Han5c6d4172021-12-06 14:17:52 +090095 #[error("Payload config is invalid: {0}")]
96 InvalidConfig(String),
Jooyung Handd0a1732021-11-23 15:26:20 +090097}
98
Seungjae Yoo2b893b92022-10-26 14:29:27 +090099fn send_vm_status(service: &Strong<dyn IVirtualMachineService>) -> Result<()> {
100 // Collect VM CPU time information and creating VmCpuStatus atom for metrics.
101 let cpu_time = get_cpu_time()?;
102 let vm_cpu_status = VirtualMachineCpuStatus {
103 cpu_time_user: cpu_time.user,
104 cpu_time_nice: cpu_time.nice,
105 cpu_time_sys: cpu_time.sys,
106 cpu_time_idle: cpu_time.idle,
107 };
108 service.notifyCpuStatus(&vm_cpu_status).expect("Can't send information about VM CPU status");
109
110 // Collect VM memory information and creating VmMemStatus atom for metrics.
111 let mem_info = get_mem_info()?;
112 let vm_mem_status = VirtualMachineMemStatus {
113 mem_total: mem_info.total,
114 mem_free: mem_info.free,
115 mem_available: mem_info.available,
116 mem_buffer: mem_info.buffer,
117 mem_cached: mem_info.cached,
118 };
119 service.notifyMemStatus(&vm_mem_status).expect("Can't send information about VM memory status");
120
121 Ok(())
122}
123
124fn send_vm_status_periodically() -> Result<()> {
Seungjae Yoofd9a0622022-10-14 10:01:29 +0900125 let service = get_vms_rpc_binder()
126 .context("cannot connect to VirtualMachineService")
127 .map_err(|e| MicrodroidError::FailedToConnectToVirtualizationService(e.to_string()))?;
128
Seungjae Yoofd9a0622022-10-14 10:01:29 +0900129 loop {
Seungjae Yoo2b893b92022-10-26 14:29:27 +0900130 send_vm_status(&service)?;
131 thread::sleep(SENDING_VM_STATUS_CYCLE_PERIOD);
Seungjae Yoofd9a0622022-10-14 10:01:29 +0900132 }
133}
134
Alan Stokes2bead0d2022-09-05 16:58:34 +0100135fn translate_error(err: &Error) -> (ErrorCode, String) {
Jooyung Handd0a1732021-11-23 15:26:20 +0900136 if let Some(e) = err.downcast_ref::<MicrodroidError>() {
137 match e {
Alan Stokes2bead0d2022-09-05 16:58:34 +0100138 MicrodroidError::PayloadChanged(msg) => (ErrorCode::PAYLOAD_CHANGED, msg.to_string()),
Jooyung Handd0a1732021-11-23 15:26:20 +0900139 MicrodroidError::PayloadVerificationFailed(msg) => {
Alan Stokes2bead0d2022-09-05 16:58:34 +0100140 (ErrorCode::PAYLOAD_VERIFICATION_FAILED, msg.to_string())
Jooyung Handd0a1732021-11-23 15:26:20 +0900141 }
Alan Stokes2bead0d2022-09-05 16:58:34 +0100142 MicrodroidError::InvalidConfig(msg) => {
143 (ErrorCode::PAYLOAD_CONFIG_INVALID, msg.to_string())
144 }
Inseob Kim11f40d02022-06-13 17:16:00 +0900145
146 // Connection failure won't be reported to VS; return the default value
147 MicrodroidError::FailedToConnectToVirtualizationService(msg) => {
Alan Stokes2bead0d2022-09-05 16:58:34 +0100148 (ErrorCode::UNKNOWN, msg.to_string())
Inseob Kim11f40d02022-06-13 17:16:00 +0900149 }
Jooyung Handd0a1732021-11-23 15:26:20 +0900150 }
151 } else {
Alan Stokes2bead0d2022-09-05 16:58:34 +0100152 (ErrorCode::UNKNOWN, err.to_string())
Jooyung Handd0a1732021-11-23 15:26:20 +0900153 }
154}
155
Inseob Kim11f40d02022-06-13 17:16:00 +0900156fn write_death_reason_to_serial(err: &Error) -> Result<()> {
157 let death_reason = if let Some(e) = err.downcast_ref::<MicrodroidError>() {
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100158 Borrowed(match e {
Inseob Kim11f40d02022-06-13 17:16:00 +0900159 MicrodroidError::FailedToConnectToVirtualizationService(_) => {
160 "MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE"
161 }
162 MicrodroidError::PayloadChanged(_) => "MICRODROID_PAYLOAD_HAS_CHANGED",
163 MicrodroidError::PayloadVerificationFailed(_) => {
164 "MICRODROID_PAYLOAD_VERIFICATION_FAILED"
165 }
166 MicrodroidError::InvalidConfig(_) => "MICRODROID_INVALID_PAYLOAD_CONFIG",
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100167 })
Inseob Kim11f40d02022-06-13 17:16:00 +0900168 } else {
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100169 // Send context information back after a separator, to ease diagnosis.
170 // These errors occur before the payload runs, so this should not leak sensitive
171 // information.
172 Owned(format!("MICRODROID_UNKNOWN_RUNTIME_ERROR|{:?}", err))
Inseob Kim11f40d02022-06-13 17:16:00 +0900173 };
174
175 let death_reason_bytes = death_reason.as_bytes();
176 let mut sent_total = 0;
177 while sent_total < death_reason_bytes.len() {
178 // TODO(b/220071963): Sometimes, sending more than 16 bytes at once makes MM hang.
179 let begin = sent_total;
180 let end = std::cmp::min(begin.saturating_add(16), death_reason_bytes.len());
181 OpenOptions::new()
182 .read(false)
183 .write(true)
184 .open(FAILURE_SERIAL_DEVICE)?
185 .write_all(&death_reason_bytes[begin..end])?;
186 sent_total = end;
187 }
188
189 Ok(())
190}
191
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900192fn get_vms_rpc_binder() -> Result<Strong<dyn IVirtualMachineService>> {
Andrew Walbran7eb5ca42022-08-08 15:33:34 +0000193 get_vsock_rpc_interface(VMADDR_CID_HOST, VM_BINDER_SERVICE_PORT as u32)
Andrew Walbranc4ce7872022-07-29 11:26:41 +0000194 .context("Cannot connect to RPC service")
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900195}
196
Inseob Kim437f1052022-06-21 11:30:22 +0900197fn main() -> Result<()> {
198 scopeguard::defer! {
199 info!("Shutting down...");
Jooyung Hanbfe086f2021-10-28 10:15:45 +0900200 if let Err(e) = system_properties::write("sys.powerctl", "shutdown") {
201 error!("failed to shutdown {:?}", e);
202 }
Jooyung Han311b1202021-09-14 22:00:16 +0900203 }
Inseob Kim437f1052022-06-21 11:30:22 +0900204
205 try_main().map_err(|e| {
206 error!("Failed with {:?}.", e);
207 if let Err(e) = write_death_reason_to_serial(&e) {
208 error!("Failed to write death reason {:?}", e);
209 }
210 e
211 })
Jooyung Han311b1202021-09-14 22:00:16 +0900212}
213
214fn try_main() -> Result<()> {
Andrew Sculle127cff2022-02-15 15:34:04 +0000215 let _ = kernlog::init();
Jooyung Han347d9f22021-05-28 00:05:14 +0900216 info!("started.");
217
Jiyong Park202856e2022-08-22 16:04:26 +0900218 load_crashkernel_if_supported().context("Failed to load crashkernel")?;
219
Keir Fraser933f0ac2022-10-12 08:23:28 +0000220 swap::init_swap().context("Failed to initialise swap")?;
221 info!("swap enabled.");
222
Inseob Kim11f40d02022-06-13 17:16:00 +0900223 let service = get_vms_rpc_binder()
224 .context("cannot connect to VirtualMachineService")
225 .map_err(|e| MicrodroidError::FailedToConnectToVirtualizationService(e.to_string()))?;
Seungjae Yoofd9a0622022-10-14 10:01:29 +0900226
227 thread::spawn(move || {
Seungjae Yoo2b893b92022-10-26 14:29:27 +0900228 if let Err(e) = send_vm_status_periodically() {
Seungjae Yoofd9a0622022-10-14 10:01:29 +0900229 error!("failed to get virtual machine status: {:?}", e);
230 }
231 });
232
Jooyung Han5c6d4172021-12-06 14:17:52 +0900233 match try_run_payload(&service) {
234 Ok(code) => {
235 info!("notifying payload finished");
236 service.notifyPayloadFinished(code)?;
237 if code == 0 {
238 info!("task successfully finished");
239 } else {
240 error!("task exited with exit code: {}", code);
241 }
242 Ok(())
243 }
244 Err(err) => {
Jooyung Han5c6d4172021-12-06 14:17:52 +0900245 let (error_code, message) = translate_error(&err);
246 service.notifyError(error_code, &message)?;
247 Err(err)
248 }
Jooyung Handd0a1732021-11-23 15:26:20 +0900249 }
250}
251
Alan Stokes1f417c92022-09-29 15:13:28 +0100252fn dice_derivation(
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000253 dice: DiceDriver,
Alan Stokes1f417c92022-09-29 15:13:28 +0100254 verified_data: &MicrodroidData,
255 payload_metadata: &PayloadMetadata,
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000256) -> Result<DiceContext> {
Andrew Scullb2f44472022-01-21 14:41:34 +0000257 // Calculate compound digests of code and authorities
Andrew Sculla0d1b1a2022-05-24 19:32:47 +0000258 let mut code_hash_ctx = Sha512::new();
259 let mut authority_hash_ctx = Sha512::new();
Andrew Scullb2f44472022-01-21 14:41:34 +0000260 code_hash_ctx.update(verified_data.apk_data.root_hash.as_ref());
261 authority_hash_ctx.update(verified_data.apk_data.pubkey.as_ref());
Inseob Kimb2519c52022-04-14 02:10:09 +0900262 for extra_apk in &verified_data.extra_apks_data {
Andrew Scullb2f44472022-01-21 14:41:34 +0000263 code_hash_ctx.update(extra_apk.root_hash.as_ref());
264 authority_hash_ctx.update(extra_apk.pubkey.as_ref());
265 }
Inseob Kimb2519c52022-04-14 02:10:09 +0900266 for apex in &verified_data.apex_data {
Andrew Scullb2f44472022-01-21 14:41:34 +0000267 code_hash_ctx.update(apex.root_digest.as_ref());
268 authority_hash_ctx.update(apex.public_key.as_ref());
269 }
Andrew Sculla0d1b1a2022-05-24 19:32:47 +0000270 let code_hash = code_hash_ctx.finish();
271 let authority_hash = authority_hash_ctx.finish();
Andrew Scullb2f44472022-01-21 14:41:34 +0000272
273 // {
274 // -70002: "Microdroid payload",
Alan Stokes1f417c92022-09-29 15:13:28 +0100275 // ? -71000: tstr // payload_config_path
276 // ? -71001: PayloadConfig
Andrew Scullb2f44472022-01-21 14:41:34 +0000277 // }
Alan Stokes1f417c92022-09-29 15:13:28 +0100278 // PayloadConfig = {
279 // 1: tstr // payload_binary_path
Alan Stokes1f417c92022-09-29 15:13:28 +0100280 // }
281
Andrew Scullb2f44472022-01-21 14:41:34 +0000282 let mut config_desc = vec![
Alan Stokes1f417c92022-09-29 15:13:28 +0100283 0xa2, // map(2)
284 0x3a, 0x00, 0x01, 0x11, 0x71, // -70002
285 0x72, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x20, 0x70, 0x61, 0x79,
286 0x6c, 0x6f, 0x61, 0x64, // "Microdroid payload"
Andrew Scullb2f44472022-01-21 14:41:34 +0000287 ];
Alan Stokes1f417c92022-09-29 15:13:28 +0100288
289 match payload_metadata {
290 PayloadMetadata::config_path(payload_config_path) => {
291 encode_negative_number(-71000, &mut config_desc)?;
292 encode_tstr(payload_config_path, &mut config_desc)?;
293 }
294 PayloadMetadata::config(payload_config) => {
295 encode_negative_number(-71001, &mut config_desc)?;
296 encode_header(5, 1, &mut config_desc)?; // map(1)
297 encode_number(1, &mut config_desc)?;
298 encode_tstr(&payload_config.payload_binary_path, &mut config_desc)?;
299 }
300 }
Andrew Scullb2f44472022-01-21 14:41:34 +0000301
Andrew Scull65ddfc42022-02-14 21:03:58 +0000302 // Check app debuggability, conervatively assuming it is debuggable
303 let app_debuggable = system_properties::read_bool(APP_DEBUGGABLE_PROP, true)?;
304
Andrew Scullb2f44472022-01-21 14:41:34 +0000305 // Send the details to diced
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000306 let hidden = verified_data.salt.clone().try_into().unwrap();
307 dice.derive(code_hash, &config_desc, authority_hash, app_debuggable, hidden)
Andrew Scullb2f44472022-01-21 14:41:34 +0000308}
309
Alan Stokes1f417c92022-09-29 15:13:28 +0100310fn encode_tstr(tstr: &str, buffer: &mut Vec<u8>) -> Result<()> {
311 let bytes = tstr.as_bytes();
312 encode_header(3, bytes.len().try_into().unwrap(), buffer)?;
313 buffer.extend_from_slice(bytes);
314 Ok(())
315}
316
317fn encode_negative_number(n: i64, buffer: &mut dyn Write) -> Result<()> {
318 ensure!(n < 0);
319 let n = -1 - n;
320 encode_header(1, n.try_into().unwrap(), buffer)
321}
322
Andrew Scullab72ec52022-03-14 09:10:52 +0000323fn is_strict_boot() -> bool {
324 Path::new(AVF_STRICT_BOOT).exists()
325}
326
327fn is_new_instance() -> bool {
328 Path::new(AVF_NEW_INSTANCE).exists()
329}
330
Inseob Kime379e7d2022-07-22 18:55:18 +0900331fn is_verified_boot() -> bool {
332 !Path::new(DEBUG_MICRODROID_NO_VERIFIED_BOOT).exists()
333}
334
Jooyung Han5c6d4172021-12-06 14:17:52 +0900335fn try_run_payload(service: &Strong<dyn IVirtualMachineService>) -> Result<i32> {
Jooyung Han311b1202021-09-14 22:00:16 +0900336 let metadata = load_metadata().context("Failed to load payload metadata")?;
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000337 let dice = DiceDriver::new(Path::new("/dev/open-dice0")).context("Failed to load DICE")?;
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900338
Jooyung Han311b1202021-09-14 22:00:16 +0900339 let mut instance = InstanceDisk::new().context("Failed to load instance.img")?;
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000340 let saved_data =
341 instance.read_microdroid_data(&dice).context("Failed to read identity data")?;
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900342
Andrew Scullab72ec52022-03-14 09:10:52 +0000343 if is_strict_boot() {
344 // Provisioning must happen on the first boot and never again.
345 if is_new_instance() {
346 ensure!(
347 saved_data.is_none(),
348 MicrodroidError::InvalidConfig("Found instance data on first boot.".to_string())
349 );
350 } else {
351 ensure!(
352 saved_data.is_some(),
353 MicrodroidError::InvalidConfig("Instance data not found.".to_string())
354 );
355 };
356 }
357
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900358 // Verify the payload before using it.
Inseob Kim11f40d02022-06-13 17:16:00 +0900359 let verified_data = verify_payload(&metadata, saved_data.as_ref())
360 .context("Payload verification failed")
361 .map_err(|e| MicrodroidError::PayloadVerificationFailed(e.to_string()))?;
Inseob Kime379e7d2022-07-22 18:55:18 +0900362
363 // In case identity is ignored (by debug policy), we should reuse existing payload data, even
364 // when the payload is changed. This is to keep the derived secret same as before.
365 let verified_data = if let Some(saved_data) = saved_data {
366 if !is_verified_boot() {
367 if saved_data != verified_data {
368 info!("Detected an update of the payload, but continue (regarding debug policy)")
369 }
370 } else {
371 ensure!(
372 saved_data == verified_data,
373 MicrodroidError::PayloadChanged(String::from(
374 "Detected an update of the payload which isn't supported yet."
375 ))
376 );
377 info!("Saved data is verified.");
378 }
379 saved_data
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900380 } else {
Jooyung Han7a343f92021-09-08 22:53:11 +0900381 info!("Saving verified data.");
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000382 instance
383 .write_microdroid_data(&verified_data, &dice)
384 .context("Failed to write identity data")?;
Inseob Kime379e7d2022-07-22 18:55:18 +0900385 verified_data
386 };
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900387
Alan Stokes1f417c92022-09-29 15:13:28 +0100388 let payload_metadata = metadata.payload.ok_or_else(|| {
389 MicrodroidError::InvalidConfig("No payload config in metadata".to_string())
390 })?;
Alan Stokes0d1ef782022-09-27 13:46:35 +0100391
Inseob Kimb2519c52022-04-14 02:10:09 +0900392 // To minimize the exposure to untrusted data, derive dice profile as soon as possible.
393 info!("DICE derivation for payload");
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000394 let dice = dice_derivation(dice, &verified_data, &payload_metadata)?;
Inseob Kimb2519c52022-04-14 02:10:09 +0900395
Jooyung Hana6d11eb2021-09-10 11:48:05 +0900396 // Before reading a file from the APK, start zipfuse
Inseob Kim217038e2021-11-25 11:15:06 +0900397 run_zipfuse(
Alan Stokes60f82202022-10-07 16:40:07 +0100398 MountForExec::Allowed,
Inseob Kim217038e2021-11-25 11:15:06 +0900399 "fscontext=u:object_r:zipfusefs:s0,context=u:object_r:system_file:s0",
400 Path::new("/dev/block/mapper/microdroid-apk"),
401 Path::new("/mnt/apk"),
Alan Stokes60f82202022-10-07 16:40:07 +0100402 Some(APK_MOUNT_DONE_PROP),
Inseob Kim217038e2021-11-25 11:15:06 +0900403 )
404 .context("Failed to run zipfuse")?;
Jiyong Park21ce2c52021-08-28 02:32:17 +0900405
Andrew Scull4d262dc2022-10-21 13:14:33 +0000406 // Restricted APIs are only allowed to be used by platform or test components. Infer this from
407 // the use of a VM config file since those can only be used by platform and test components.
408 let allow_restricted_apis = match payload_metadata {
409 PayloadMetadata::config_path(_) => true,
410 PayloadMetadata::config(_) => false,
411 };
412
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100413 let config = load_config(payload_metadata).context("Failed to load payload metadata")?;
Shikha Panwar6f03c942022-04-13 20:26:50 +0000414
Alan Stokes01b3ef02022-09-22 17:43:24 +0100415 let task = config
416 .task
417 .as_ref()
418 .ok_or_else(|| MicrodroidError::InvalidConfig("No task in VM config".to_string()))?;
419
Inseob Kim197748b2021-12-01 19:49:00 +0900420 if config.extra_apks.len() != verified_data.extra_apks_data.len() {
421 return Err(anyhow!(
Alan Stokes1f417c92022-09-29 15:13:28 +0100422 "config expects {} extra apks, but found {}",
Inseob Kim197748b2021-12-01 19:49:00 +0900423 config.extra_apks.len(),
424 verified_data.extra_apks_data.len()
425 ));
426 }
427 mount_extra_apks(&config)?;
Jooyung Han634e2d72021-06-10 16:27:38 +0900428
Jooyung Han5c6d4172021-12-06 14:17:52 +0900429 // Wait until apex config is done. (e.g. linker configuration for apexes)
430 // TODO(jooyung): wait until sys.boot_completed?
431 wait_for_apex_config_done()?;
432
Inseob Kimcd9c1dd2022-07-13 17:13:45 +0900433 // Start tombstone_transmit if enabled
434 if config.export_tombstones {
Alan Stokes01b3ef02022-09-22 17:43:24 +0100435 control_service("start", "tombstone_transmit")?;
Inseob Kimcd9c1dd2022-07-13 17:13:45 +0900436 } else {
Alan Stokes01b3ef02022-09-22 17:43:24 +0100437 control_service("stop", "tombstoned")?;
Inseob Kimcd9c1dd2022-07-13 17:13:45 +0900438 }
439
Alan Stokes01b3ef02022-09-22 17:43:24 +0100440 // Start authfs if enabled
441 if config.enable_authfs {
442 control_service("start", "authfs_service")?;
443 }
444
Alan Stokes60f82202022-10-07 16:40:07 +0100445 // Wait until zipfuse has mounted the APK so we can access the payload
446 wait_for_property_true(APK_MOUNT_DONE_PROP).context("Failed waiting for APK mount done")?;
447
Andrew Scull4d262dc2022-10-21 13:14:33 +0000448 register_vm_payload_service(allow_restricted_apis, service.clone(), dice)?;
Alice Wang59a9e562022-10-04 15:24:10 +0000449 ProcessState::start_thread_pool();
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100450
451 system_properties::write("dev.bootcomplete", "1").context("set dev.bootcomplete")?;
Seungjae Yoo2b893b92022-10-26 14:29:27 +0900452 send_vm_status(service)?;
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100453
454 exec_task(task, service).context("Failed to run payload")
Alan Stokes01b3ef02022-09-22 17:43:24 +0100455}
456
457fn control_service(action: &str, service: &str) -> Result<()> {
458 system_properties::write(&format!("ctl.{}", action), service)
459 .with_context(|| format!("Failed to {} {}", action, service))
Jooyung Han347d9f22021-05-28 00:05:14 +0900460}
461
Inseob Kim217038e2021-11-25 11:15:06 +0900462struct ApkDmverityArgument<'a> {
463 apk: &'a str,
464 idsig: &'a str,
465 name: &'a str,
Inseob Kim197748b2021-12-01 19:49:00 +0900466 saved_root_hash: Option<&'a RootHash>,
Inseob Kim217038e2021-11-25 11:15:06 +0900467}
468
469fn run_apkdmverity(args: &[ApkDmverityArgument]) -> Result<Child> {
470 let mut cmd = Command::new(APKDMVERITY_BIN);
471
472 cmd.stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null());
473
474 for argument in args {
475 cmd.arg("--apk").arg(argument.apk).arg(argument.idsig).arg(argument.name);
Inseob Kim197748b2021-12-01 19:49:00 +0900476 if let Some(root_hash) = argument.saved_root_hash {
477 cmd.arg(&to_hex_string(root_hash));
478 } else {
479 cmd.arg("none");
480 }
Inseob Kim217038e2021-11-25 11:15:06 +0900481 }
482
483 cmd.spawn().context("Spawn apkdmverity")
484}
485
Alan Stokes60f82202022-10-07 16:40:07 +0100486enum MountForExec {
487 Allowed,
488 Disallowed,
489}
490
491fn run_zipfuse(
492 noexec: MountForExec,
493 option: &str,
494 zip_path: &Path,
495 mount_dir: &Path,
496 ready_prop: Option<&str>,
497) -> Result<Child> {
Andrew Scullcc339a12022-07-04 12:44:19 +0000498 let mut cmd = Command::new(ZIPFUSE_BIN);
Alan Stokes60f82202022-10-07 16:40:07 +0100499 if let MountForExec::Disallowed = noexec {
Andrew Scullcc339a12022-07-04 12:44:19 +0000500 cmd.arg("--noexec");
501 }
Alan Stokes60f82202022-10-07 16:40:07 +0100502 if let Some(property_name) = ready_prop {
503 cmd.args(["-p", property_name]);
504 }
Andrew Scullcc339a12022-07-04 12:44:19 +0000505 cmd.arg("-o")
Inseob Kim217038e2021-11-25 11:15:06 +0900506 .arg(option)
507 .arg(zip_path)
508 .arg(mount_dir)
509 .stdin(Stdio::null())
510 .stdout(Stdio::null())
511 .stderr(Stdio::null())
512 .spawn()
513 .context("Spawn zipfuse")
514}
515
Inseob Kime379e7d2022-07-22 18:55:18 +0900516fn write_apex_payload_data(
517 saved_data: Option<&MicrodroidData>,
518 apex_data_from_payload: &[ApexData],
519) -> Result<()> {
520 if let Some(saved_apex_data) = saved_data.map(|d| &d.apex_data) {
521 // We don't support APEX updates. (assuming that update will change root digest)
522 ensure!(
523 saved_apex_data == apex_data_from_payload,
524 MicrodroidError::PayloadChanged(String::from("APEXes have changed."))
525 );
526 let apex_metadata = to_metadata(apex_data_from_payload);
527 // Pass metadata(with public keys and root digests) to apexd so that it uses the passed
528 // metadata instead of the default one (/dev/block/by-name/payload-metadata)
529 OpenOptions::new()
530 .create_new(true)
531 .write(true)
532 .open("/apex/vm-payload-metadata")
533 .context("Failed to open /apex/vm-payload-metadata")
534 .and_then(|f| write_metadata(&apex_metadata, f))?;
535 }
536 Ok(())
537}
538
Jooyung Han7a343f92021-09-08 22:53:11 +0900539// Verify payload before executing it. For APK payload, Full verification (which is slow) is done
540// when the root_hash values from the idsig file and the instance disk are different. This function
541// returns the verified root hash (for APK payload) and pubkeys (for APEX payloads) that can be
542// saved to the instance disk.
543fn verify_payload(
544 metadata: &Metadata,
545 saved_data: Option<&MicrodroidData>,
546) -> Result<MicrodroidData> {
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900547 let start_time = SystemTime::now();
548
Inseob Kim197748b2021-12-01 19:49:00 +0900549 // Verify main APK
Jooyung Han7a343f92021-09-08 22:53:11 +0900550 let root_hash = saved_data.map(|d| &d.apk_data.root_hash);
Inseob Kim197748b2021-12-01 19:49:00 +0900551 let root_hash_from_idsig = get_apk_root_hash_from_idsig(MAIN_APK_IDSIG_PATH)?;
Jiyong Parkf7dea252021-09-08 01:42:54 +0900552 let root_hash_trustful = root_hash == Some(&root_hash_from_idsig);
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900553
Jiyong Parkf7dea252021-09-08 01:42:54 +0900554 // If root_hash can be trusted, pass it to apkdmverity so that it uses the passed root_hash
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900555 // instead of the value read from the idsig file.
Inseob Kim197748b2021-12-01 19:49:00 +0900556 let main_apk_argument = {
557 ApkDmverityArgument {
558 apk: MAIN_APK_PATH,
559 idsig: MAIN_APK_IDSIG_PATH,
560 name: MAIN_APK_DEVICE_NAME,
561 saved_root_hash: if root_hash_trustful {
562 Some(root_hash_from_idsig.as_ref())
563 } else {
564 None
565 },
566 }
567 };
568 let mut apkdmverity_arguments = vec![main_apk_argument];
569
570 // Verify extra APKs
571 // For now, we can't read the payload config, so glob APKs and idsigs.
572 // Later, we'll see if it matches with the payload config.
573
574 // sort globbed paths to match apks (extra-apk-{idx}) and idsigs (extra-idsig-{idx})
575 // e.g. "extra-apk-0" corresponds to "extra-idsig-0"
576 let extra_apks =
577 sorted(glob(EXTRA_APK_PATH_PATTERN)?.collect::<Result<Vec<_>, _>>()?).collect::<Vec<_>>();
578 let extra_idsigs =
579 sorted(glob(EXTRA_IDSIG_PATH_PATTERN)?.collect::<Result<Vec<_>, _>>()?).collect::<Vec<_>>();
580 if extra_apks.len() != extra_idsigs.len() {
581 return Err(anyhow!(
582 "Extra apks/idsigs mismatch: {} apks but {} idsigs",
583 extra_apks.len(),
584 extra_idsigs.len()
585 ));
586 }
587 let extra_apks_count = extra_apks.len();
588
589 let (extra_apk_names, extra_root_hashes_from_idsig): (Vec<_>, Vec<_>) = extra_idsigs
590 .iter()
591 .enumerate()
592 .map(|(i, extra_idsig)| {
593 (
594 format!("extra-apk-{}", i),
Alice Wang89cff012022-09-26 10:05:16 +0000595 get_apk_root_hash_from_idsig(extra_idsig)
Inseob Kim197748b2021-12-01 19:49:00 +0900596 .expect("Can't find root hash from extra idsig"),
597 )
598 })
599 .unzip();
600
601 let saved_extra_root_hashes: Vec<_> = saved_data
602 .map(|d| d.extra_apks_data.iter().map(|apk_data| &apk_data.root_hash).collect())
603 .unwrap_or_else(Vec::new);
604 let extra_root_hashes_trustful: Vec<_> = extra_root_hashes_from_idsig
605 .iter()
606 .enumerate()
607 .map(|(i, root_hash_from_idsig)| {
608 saved_extra_root_hashes.get(i).copied() == Some(root_hash_from_idsig)
609 })
610 .collect();
611
612 for i in 0..extra_apks_count {
613 apkdmverity_arguments.push({
614 ApkDmverityArgument {
615 apk: extra_apks[i].to_str().unwrap(),
616 idsig: extra_idsigs[i].to_str().unwrap(),
617 name: &extra_apk_names[i],
618 saved_root_hash: if extra_root_hashes_trustful[i] {
619 Some(&extra_root_hashes_from_idsig[i])
620 } else {
621 None
622 },
623 }
624 });
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900625 }
626
627 // Start apkdmverity and wait for the dm-verify block
Inseob Kim197748b2021-12-01 19:49:00 +0900628 let mut apkdmverity_child = run_apkdmverity(&apkdmverity_arguments)?;
Jooyung Han7a343f92021-09-08 22:53:11 +0900629
Jooyung Hanc8deb472021-09-13 13:48:25 +0900630 // While waiting for apkdmverity to mount APK, gathers public keys and root digests from
631 // APEX payload.
Jooyung Han7a343f92021-09-08 22:53:11 +0900632 let apex_data_from_payload = get_apex_data_from_payload(metadata)?;
Inseob Kime379e7d2022-07-22 18:55:18 +0900633
634 // Writing /apex/vm-payload-metadata is to verify that the payload isn't changed.
635 // Skip writing it if the debug policy ignoring identity is on
636 if is_verified_boot() {
637 write_apex_payload_data(saved_data, &apex_data_from_payload)?;
Jooyung Han4a9b3bf2021-09-10 17:19:00 +0900638 }
Inseob Kime379e7d2022-07-22 18:55:18 +0900639
Jooyung Han4a9b3bf2021-09-10 17:19:00 +0900640 // Start apexd to activate APEXes
641 system_properties::write("ctl.start", "apexd-vm")?;
Jooyung Han7a343f92021-09-08 22:53:11 +0900642
Inseob Kim217038e2021-11-25 11:15:06 +0900643 // TODO(inseob): add timeout
644 apkdmverity_child.wait()?;
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900645
Jiyong Parkf7dea252021-09-08 01:42:54 +0900646 // Do the full verification if the root_hash is un-trustful. This requires the full scanning of
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900647 // the APK file and therefore can be very slow if the APK is large. Note that this step is
Jiyong Parkf7dea252021-09-08 01:42:54 +0900648 // taken only when the root_hash is un-trustful which can be either when this is the first boot
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900649 // of the VM or APK was updated in the host.
650 // TODO(jooyung): consider multithreading to make this faster
Inseob Kim197748b2021-12-01 19:49:00 +0900651 let main_apk_pubkey = get_public_key_from_apk(DM_MOUNTED_APK_PATH, root_hash_trustful)?;
652 let extra_apks_data = extra_root_hashes_from_idsig
653 .into_iter()
654 .enumerate()
655 .map(|(i, extra_root_hash)| {
656 let mount_path = format!("/dev/block/mapper/{}", &extra_apk_names[i]);
657 let apk_pubkey = get_public_key_from_apk(&mount_path, extra_root_hashes_trustful[i])?;
658 Ok(ApkData { root_hash: extra_root_hash, pubkey: apk_pubkey })
659 })
660 .collect::<Result<Vec<_>>>()?;
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900661
662 info!("payload verification successful. took {:#?}", start_time.elapsed().unwrap());
663
Andrew Scull34916a72022-01-30 21:34:24 +0000664 // Use the salt from a verified instance, or generate a salt for a new instance.
665 let salt = if let Some(saved_data) = saved_data {
666 saved_data.salt.clone()
667 } else {
668 let mut salt = vec![0u8; 64];
669 salt.as_mut_slice().try_fill(&mut rand::thread_rng())?;
670 salt
671 };
672
Jiyong Parkf7dea252021-09-08 01:42:54 +0900673 // At this point, we can ensure that the root_hash from the idsig file is trusted, either by
674 // fully verifying the APK or by comparing it with the saved root_hash.
Jooyung Han7a343f92021-09-08 22:53:11 +0900675 Ok(MicrodroidData {
Andrew Scull34916a72022-01-30 21:34:24 +0000676 salt,
Inseob Kim197748b2021-12-01 19:49:00 +0900677 apk_data: ApkData { root_hash: root_hash_from_idsig, pubkey: main_apk_pubkey },
678 extra_apks_data,
Jooyung Han7a343f92021-09-08 22:53:11 +0900679 apex_data: apex_data_from_payload,
680 })
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900681}
682
Inseob Kim197748b2021-12-01 19:49:00 +0900683fn mount_extra_apks(config: &VmPayloadConfig) -> Result<()> {
684 // For now, only the number of apks is important, as the mount point and dm-verity name is fixed
685 for i in 0..config.extra_apks.len() {
686 let mount_dir = format!("/mnt/extra-apk/{}", i);
687 create_dir(Path::new(&mount_dir)).context("Failed to create mount dir for extra apks")?;
688
689 // don't wait, just detach
690 run_zipfuse(
Alan Stokes60f82202022-10-07 16:40:07 +0100691 MountForExec::Disallowed,
Inseob Kim197748b2021-12-01 19:49:00 +0900692 "fscontext=u:object_r:zipfusefs:s0,context=u:object_r:extra_apk_file:s0",
693 Path::new(&format!("/dev/block/mapper/extra-apk-{}", i)),
694 Path::new(&mount_dir),
Alan Stokes60f82202022-10-07 16:40:07 +0100695 None,
Inseob Kim197748b2021-12-01 19:49:00 +0900696 )
697 .context("Failed to zipfuse extra apks")?;
698 }
699
700 Ok(())
701}
702
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900703// Waits until linker config is generated
704fn wait_for_apex_config_done() -> Result<()> {
Alan Stokes60f82202022-10-07 16:40:07 +0100705 wait_for_property_true(APEX_CONFIG_DONE_PROP).context("Failed waiting for apex config done")
706}
707
708fn wait_for_property_true(property_name: &str) -> Result<()> {
709 let mut prop = PropertyWatcher::new(property_name)?;
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900710 loop {
711 prop.wait()?;
Alan Stokes60f82202022-10-07 16:40:07 +0100712 if system_properties::read_bool(property_name, false)? {
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900713 break;
714 }
715 }
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900716 Ok(())
717}
718
Alice Wang89cff012022-09-26 10:05:16 +0000719fn get_apk_root_hash_from_idsig<P: AsRef<Path>>(idsig_path: P) -> Result<Box<RootHash>> {
720 Ok(V4Signature::from_idsig_path(idsig_path)?.hashing_info.raw_root_hash)
Jiyong Park21ce2c52021-08-28 02:32:17 +0900721}
722
Inseob Kim197748b2021-12-01 19:49:00 +0900723fn get_public_key_from_apk(apk: &str, root_hash_trustful: bool) -> Result<Box<[u8]>> {
724 if !root_hash_trustful {
725 verify(apk).context(MicrodroidError::PayloadVerificationFailed(format!(
726 "failed to verify {}",
727 apk
728 )))
729 } else {
730 get_public_key_der(apk)
731 }
732}
733
Alan Stokes1f417c92022-09-29 15:13:28 +0100734fn load_config(payload_metadata: PayloadMetadata) -> Result<VmPayloadConfig> {
735 match payload_metadata {
736 PayloadMetadata::config_path(path) => {
737 let path = Path::new(&path);
738 info!("loading config from {:?}...", path);
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100739 let file = ioutil::wait_for_file(path, WAIT_TIMEOUT)
740 .with_context(|| format!("Failed to read {:?}", path))?;
Alan Stokes1f417c92022-09-29 15:13:28 +0100741 Ok(serde_json::from_reader(file)?)
742 }
743 PayloadMetadata::config(payload_config) => {
744 let task = Task {
745 type_: TaskType::MicrodroidLauncher,
746 command: payload_config.payload_binary_path,
Alan Stokes1f417c92022-09-29 15:13:28 +0100747 };
748 Ok(VmPayloadConfig {
749 os: OsConfig { name: "microdroid".to_owned() },
750 task: Some(task),
751 apexes: vec![],
752 extra_apks: vec![],
753 prefer_staged: false,
754 export_tombstones: false,
755 enable_authfs: false,
756 })
757 }
758 }
Jooyung Han634e2d72021-06-10 16:27:38 +0900759}
760
Jiyong Park202856e2022-08-22 16:04:26 +0900761/// Loads the crashkernel into memory using kexec if the VM is loaded with `crashkernel=' parameter
762/// in the cmdline.
763fn load_crashkernel_if_supported() -> Result<()> {
764 let supported = std::fs::read_to_string("/proc/cmdline")?.contains(" crashkernel=");
765 info!("ramdump supported: {}", supported);
766 if supported {
767 let status = Command::new("/system/bin/kexec_load").status()?;
768 if !status.success() {
769 return Err(anyhow!("Failed to load crashkernel: {:?}", status));
770 }
771 }
772 Ok(())
773}
774
Jiyong Park8611a6c2021-07-09 18:17:44 +0900775/// Executes the given task. Stdout of the task is piped into the vsock stream to the
776/// virtualizationservice in the host side.
Jooyung Han5c6d4172021-12-06 14:17:52 +0900777fn exec_task(task: &Task, service: &Strong<dyn IVirtualMachineService>) -> Result<i32> {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900778 info!("executing main task {:?}...", task);
Inseob Kim86ca0162021-10-20 02:21:02 +0000779 let mut command = build_command(task)?;
Inseob Kim7f61fe72021-08-20 20:50:47 +0900780
781 info!("notifying payload started");
Inseob Kimc7d28c72021-10-25 14:28:10 +0000782 service.notifyPayloadStarted()?;
Inseob Kim7f61fe72021-08-20 20:50:47 +0900783
Inseob Kim86ca0162021-10-20 02:21:02 +0000784 let exit_status = command.spawn()?.wait()?;
Seungjae Yoo2b893b92022-10-26 14:29:27 +0900785 send_vm_status(service)?;
Jooyung Han5c6d4172021-12-06 14:17:52 +0900786 exit_status.code().ok_or_else(|| anyhow!("Failed to get exit_code from the paylaod."))
Jooyung Han347d9f22021-05-28 00:05:14 +0900787}
Jooyung Han634e2d72021-06-10 16:27:38 +0900788
789fn build_command(task: &Task) -> Result<Command> {
Inseob Kim7f61fe72021-08-20 20:50:47 +0900790 let mut command = match task.type_ {
Alan Stokes52d3c722022-10-04 17:27:13 +0100791 TaskType::Executable => Command::new(&task.command),
Jooyung Han634e2d72021-06-10 16:27:38 +0900792 TaskType::MicrodroidLauncher => {
793 let mut command = Command::new("/system/bin/microdroid_launcher");
Alan Stokes52d3c722022-10-04 17:27:13 +0100794 command.arg(find_library_path(&task.command)?);
Jooyung Han634e2d72021-06-10 16:27:38 +0900795 command
796 }
Inseob Kim7f61fe72021-08-20 20:50:47 +0900797 };
798
Inseob Kimd0587562021-09-01 21:27:32 +0900799 match VsockStream::connect_with_cid_port(VMADDR_CID_HOST, VM_STREAM_SERVICE_PORT as u32) {
Inseob Kim7f61fe72021-08-20 20:50:47 +0900800 Ok(stream) => {
801 // SAFETY: the ownership of the underlying file descriptor is transferred from stream
802 // to the file object, and then into the Command object. When the command is finished,
803 // the file descriptor is closed.
804 let file = unsafe { File::from_raw_fd(stream.into_raw_fd()) };
805 command
806 .stdin(Stdio::from(file.try_clone()?))
807 .stdout(Stdio::from(file.try_clone()?))
808 .stderr(Stdio::from(file));
809 }
810 Err(e) => {
811 error!("failed to connect to virtualization service: {}", e);
812 // Don't fail hard here. Even if we failed to connect to the virtualizationservice,
813 // we keep executing the task. This can happen if the owner of the VM doesn't register
814 // callback to accept the stream. Use /dev/null as the stream so that the task can
815 // make progress without waiting for someone to consume the output.
816 command.stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null());
817 }
818 }
819
820 Ok(command)
Jooyung Han634e2d72021-06-10 16:27:38 +0900821}
822
823fn find_library_path(name: &str) -> Result<String> {
824 let mut watcher = PropertyWatcher::new("ro.product.cpu.abilist")?;
825 let value = watcher.read(|_name, value| Ok(value.trim().to_string()))?;
826 let abi = value.split(',').next().ok_or_else(|| anyhow!("no abilist"))?;
827 let path = format!("/mnt/apk/lib/{}/{}", abi, name);
828
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100829 let metadata = fs::metadata(&path).with_context(|| format!("Unable to access {}", path))?;
Jooyung Han634e2d72021-06-10 16:27:38 +0900830 if !metadata.is_file() {
831 bail!("{} is not a file", &path);
832 }
833
834 Ok(path)
835}
Jiyong Park21ce2c52021-08-28 02:32:17 +0900836
837fn to_hex_string(buf: &[u8]) -> String {
838 buf.iter().map(|b| format!("{:02X}", b)).collect()
839}