blob: c18dd26287c7fa734827579d889462b28c89e746 [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;
Keir Fraser933f0ac2022-10-12 08:23:28 +000021mod swap;
Alice Wang59a9e562022-10-04 15:24:10 +000022mod vm_payload_service;
Jooyung Han347d9f22021-05-28 00:05:14 +090023
Andrew Sculld64ae7d2022-10-05 17:41:43 +000024use crate::dice::{DiceContext, DiceDriver};
Inseob Kime379e7d2022-07-22 18:55:18 +090025use crate::instance::{ApexData, ApkData, InstanceDisk, MicrodroidData, RootHash};
Alice Wang59a9e562022-10-04 15:24:10 +000026use crate::vm_payload_service::register_vm_payload_service;
Alan Stokes2bead0d2022-09-05 16:58:34 +010027use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::ErrorCode::ErrorCode;
Seungjae Yoodd91f0f2022-11-09 15:25:21 +090028use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::{
Seungjae Yoofd9a0622022-10-14 10:01:29 +090029 IVirtualMachineService, VM_BINDER_SERVICE_PORT, VM_STREAM_SERVICE_PORT,
Alan Stokes2bead0d2022-09-05 16:58:34 +010030};
Alice Wang6bbb6da2022-10-26 12:44:06 +000031use android_system_virtualization_payload::aidl::android::system::virtualization::payload::IVmPayloadService::VM_APK_CONTENTS_PATH;
Jooyung Handd0a1732021-11-23 15:26:20 +090032use anyhow::{anyhow, bail, ensure, Context, Error, Result};
Alice Wang1bf3d782022-09-28 07:56:36 +000033use apkverify::{get_public_key_der, verify, V4Signature};
Alice Wang43c884b2022-10-24 09:42:40 +000034use binder::Strong;
Alan Stokes1f417c92022-09-29 15:13:28 +010035use diced_utils::cbor::{encode_header, encode_number};
Inseob Kim197748b2021-12-01 19:49:00 +090036use glob::glob;
Inseob Kim197748b2021-12-01 19:49:00 +090037use itertools::sorted;
David Brazdila07a1792022-10-25 13:37:57 +010038use libc::VMADDR_CID_HOST;
Andrew Scull684590f2022-01-27 16:14:26 +000039use log::{error, info};
Alan Stokes0d1ef782022-09-27 13:46:35 +010040use microdroid_metadata::{write_metadata, Metadata, PayloadMetadata};
Seungjae Yoofd9a0622022-10-14 10:01:29 +090041use microdroid_payload_config::{OsConfig, Task, TaskType, VmPayloadConfig};
Frederick Mayleb5f7b6b2022-11-11 15:24:03 -080042use nix::sys::signal::Signal;
Andrew Sculla0d1b1a2022-05-24 19:32:47 +000043use openssl::sha::Sha512;
Jooyung Han4a9b3bf2021-09-10 17:19:00 +090044use payload::{get_apex_data_from_payload, load_metadata, to_metadata};
Andrew Scull34916a72022-01-30 21:34:24 +000045use rand::Fill;
Andrew Walbran7eb5ca42022-08-08 15:33:34 +000046use rpcbinder::get_vsock_rpc_interface;
Jiyong Parkbb4a9872021-09-06 15:59:21 +090047use rustutils::system_properties;
Joel Galenson482704c2021-07-29 15:53:53 -070048use rustutils::system_properties::PropertyWatcher;
Alan Stokes3ba10fd2022-10-06 15:46:51 +010049use std::borrow::Cow::{Borrowed, Owned};
Andrew Scullb2f44472022-01-21 14:41:34 +000050use std::convert::TryInto;
Inseob Kim7ff121c2022-11-14 18:13:23 +090051use std::env;
Inseob Kim197748b2021-12-01 19:49:00 +090052use std::fs::{self, create_dir, File, OpenOptions};
Inseob Kim11f40d02022-06-13 17:16:00 +090053use std::io::Write;
Inseob Kimc7d28c72021-10-25 14:28:10 +000054use std::os::unix::io::{FromRawFd, IntoRawFd};
Frederick Mayleb5f7b6b2022-11-11 15:24:03 -080055use std::os::unix::process::ExitStatusExt;
Jooyung Hanf48ceb42021-06-01 18:00:04 +090056use std::path::Path;
Inseob Kim217038e2021-11-25 11:15:06 +090057use std::process::{Child, Command, Stdio};
Jiyong Park8611a6c2021-07-09 18:17:44 +090058use std::str;
Jiyong Parkbb4a9872021-09-06 15:59:21 +090059use std::time::{Duration, SystemTime};
Jiyong Park8611a6c2021-07-09 18:17:44 +090060use vsock::VsockStream;
Jooyung Han634e2d72021-06-10 16:27:38 +090061
62const WAIT_TIMEOUT: Duration = Duration::from_secs(10);
Inseob Kim197748b2021-12-01 19:49:00 +090063const MAIN_APK_PATH: &str = "/dev/block/by-name/microdroid-apk";
64const MAIN_APK_IDSIG_PATH: &str = "/dev/block/by-name/microdroid-apk-idsig";
65const MAIN_APK_DEVICE_NAME: &str = "microdroid-apk";
66const EXTRA_APK_PATH_PATTERN: &str = "/dev/block/by-name/extra-apk-*";
67const EXTRA_IDSIG_PATH_PATTERN: &str = "/dev/block/by-name/extra-idsig-*";
Jooyung Han19c1d6c2021-08-06 14:08:16 +090068const DM_MOUNTED_APK_PATH: &str = "/dev/block/mapper/microdroid-apk";
Inseob Kim217038e2021-11-25 11:15:06 +090069const APKDMVERITY_BIN: &str = "/system/bin/apkdmverity";
70const ZIPFUSE_BIN: &str = "/system/bin/zipfuse";
Andrew Scullab72ec52022-03-14 09:10:52 +000071const AVF_STRICT_BOOT: &str = "/sys/firmware/devicetree/base/chosen/avf,strict-boot";
72const AVF_NEW_INSTANCE: &str = "/sys/firmware/devicetree/base/chosen/avf,new-instance";
Inseob Kime379e7d2022-07-22 18:55:18 +090073const DEBUG_MICRODROID_NO_VERIFIED_BOOT: &str =
74 "/sys/firmware/devicetree/base/virtualization/guest/debug-microdroid,no-verified-boot";
Jooyung Han347d9f22021-05-28 00:05:14 +090075
Jiyong Parkbb4a9872021-09-06 15:59:21 +090076const APEX_CONFIG_DONE_PROP: &str = "apex_config.done";
Andrew Scull65ddfc42022-02-14 21:03:58 +000077const APP_DEBUGGABLE_PROP: &str = "ro.boot.microdroid.app_debuggable";
Alan Stokes60f82202022-10-07 16:40:07 +010078const APK_MOUNT_DONE_PROP: &str = "microdroid_manager.apk.mounted";
Jiyong Parkbb4a9872021-09-06 15:59:21 +090079
Inseob Kim11f40d02022-06-13 17:16:00 +090080// SYNC WITH virtualizationservice/src/crosvm.rs
81const FAILURE_SERIAL_DEVICE: &str = "/dev/ttyS1";
82
Jooyung Handd0a1732021-11-23 15:26:20 +090083#[derive(thiserror::Error, Debug)]
84enum MicrodroidError {
Inseob Kim11f40d02022-06-13 17:16:00 +090085 #[error("Cannot connect to virtualization service: {0}")]
86 FailedToConnectToVirtualizationService(String),
Jooyung Handd0a1732021-11-23 15:26:20 +090087 #[error("Payload has changed: {0}")]
88 PayloadChanged(String),
89 #[error("Payload verification has failed: {0}")]
90 PayloadVerificationFailed(String),
Jooyung Han5c6d4172021-12-06 14:17:52 +090091 #[error("Payload config is invalid: {0}")]
92 InvalidConfig(String),
Jooyung Handd0a1732021-11-23 15:26:20 +090093}
94
Alan Stokes2bead0d2022-09-05 16:58:34 +010095fn translate_error(err: &Error) -> (ErrorCode, String) {
Jooyung Handd0a1732021-11-23 15:26:20 +090096 if let Some(e) = err.downcast_ref::<MicrodroidError>() {
97 match e {
Alan Stokes2bead0d2022-09-05 16:58:34 +010098 MicrodroidError::PayloadChanged(msg) => (ErrorCode::PAYLOAD_CHANGED, msg.to_string()),
Jooyung Handd0a1732021-11-23 15:26:20 +090099 MicrodroidError::PayloadVerificationFailed(msg) => {
Alan Stokes2bead0d2022-09-05 16:58:34 +0100100 (ErrorCode::PAYLOAD_VERIFICATION_FAILED, msg.to_string())
Jooyung Handd0a1732021-11-23 15:26:20 +0900101 }
Alan Stokes2bead0d2022-09-05 16:58:34 +0100102 MicrodroidError::InvalidConfig(msg) => {
103 (ErrorCode::PAYLOAD_CONFIG_INVALID, msg.to_string())
104 }
Inseob Kim11f40d02022-06-13 17:16:00 +0900105
106 // Connection failure won't be reported to VS; return the default value
107 MicrodroidError::FailedToConnectToVirtualizationService(msg) => {
Alan Stokes2bead0d2022-09-05 16:58:34 +0100108 (ErrorCode::UNKNOWN, msg.to_string())
Inseob Kim11f40d02022-06-13 17:16:00 +0900109 }
Jooyung Handd0a1732021-11-23 15:26:20 +0900110 }
111 } else {
Alan Stokes2bead0d2022-09-05 16:58:34 +0100112 (ErrorCode::UNKNOWN, err.to_string())
Jooyung Handd0a1732021-11-23 15:26:20 +0900113 }
114}
115
Inseob Kim11f40d02022-06-13 17:16:00 +0900116fn write_death_reason_to_serial(err: &Error) -> Result<()> {
117 let death_reason = if let Some(e) = err.downcast_ref::<MicrodroidError>() {
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100118 Borrowed(match e {
Inseob Kim11f40d02022-06-13 17:16:00 +0900119 MicrodroidError::FailedToConnectToVirtualizationService(_) => {
120 "MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE"
121 }
122 MicrodroidError::PayloadChanged(_) => "MICRODROID_PAYLOAD_HAS_CHANGED",
123 MicrodroidError::PayloadVerificationFailed(_) => {
124 "MICRODROID_PAYLOAD_VERIFICATION_FAILED"
125 }
126 MicrodroidError::InvalidConfig(_) => "MICRODROID_INVALID_PAYLOAD_CONFIG",
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100127 })
Inseob Kim11f40d02022-06-13 17:16:00 +0900128 } else {
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100129 // Send context information back after a separator, to ease diagnosis.
130 // These errors occur before the payload runs, so this should not leak sensitive
131 // information.
132 Owned(format!("MICRODROID_UNKNOWN_RUNTIME_ERROR|{:?}", err))
Inseob Kim11f40d02022-06-13 17:16:00 +0900133 };
134
135 let death_reason_bytes = death_reason.as_bytes();
136 let mut sent_total = 0;
137 while sent_total < death_reason_bytes.len() {
138 // TODO(b/220071963): Sometimes, sending more than 16 bytes at once makes MM hang.
139 let begin = sent_total;
140 let end = std::cmp::min(begin.saturating_add(16), death_reason_bytes.len());
141 OpenOptions::new()
142 .read(false)
143 .write(true)
144 .open(FAILURE_SERIAL_DEVICE)?
145 .write_all(&death_reason_bytes[begin..end])?;
146 sent_total = end;
147 }
148
149 Ok(())
150}
151
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900152fn get_vms_rpc_binder() -> Result<Strong<dyn IVirtualMachineService>> {
Andrew Walbran7eb5ca42022-08-08 15:33:34 +0000153 get_vsock_rpc_interface(VMADDR_CID_HOST, VM_BINDER_SERVICE_PORT as u32)
Andrew Walbranc4ce7872022-07-29 11:26:41 +0000154 .context("Cannot connect to RPC service")
Inseob Kim1b95f2e2021-08-19 13:17:40 +0900155}
156
Inseob Kim437f1052022-06-21 11:30:22 +0900157fn main() -> Result<()> {
Inseob Kim7ff121c2022-11-14 18:13:23 +0900158 // If debuggable, print full backtrace to console log with stdio_to_kmsg
159 if system_properties::read_bool(APP_DEBUGGABLE_PROP, true)? {
160 env::set_var("RUST_BACKTRACE", "full");
161 }
162
Inseob Kim437f1052022-06-21 11:30:22 +0900163 scopeguard::defer! {
164 info!("Shutting down...");
Jooyung Hanbfe086f2021-10-28 10:15:45 +0900165 if let Err(e) = system_properties::write("sys.powerctl", "shutdown") {
166 error!("failed to shutdown {:?}", e);
167 }
Jooyung Han311b1202021-09-14 22:00:16 +0900168 }
Inseob Kim437f1052022-06-21 11:30:22 +0900169
170 try_main().map_err(|e| {
171 error!("Failed with {:?}.", e);
172 if let Err(e) = write_death_reason_to_serial(&e) {
173 error!("Failed to write death reason {:?}", e);
174 }
175 e
176 })
Jooyung Han311b1202021-09-14 22:00:16 +0900177}
178
179fn try_main() -> Result<()> {
Andrew Sculle127cff2022-02-15 15:34:04 +0000180 let _ = kernlog::init();
Jooyung Han347d9f22021-05-28 00:05:14 +0900181 info!("started.");
182
Jiyong Park202856e2022-08-22 16:04:26 +0900183 load_crashkernel_if_supported().context("Failed to load crashkernel")?;
184
Keir Fraser933f0ac2022-10-12 08:23:28 +0000185 swap::init_swap().context("Failed to initialise swap")?;
186 info!("swap enabled.");
187
Inseob Kim11f40d02022-06-13 17:16:00 +0900188 let service = get_vms_rpc_binder()
189 .context("cannot connect to VirtualMachineService")
190 .map_err(|e| MicrodroidError::FailedToConnectToVirtualizationService(e.to_string()))?;
Seungjae Yoofd9a0622022-10-14 10:01:29 +0900191
Jooyung Han5c6d4172021-12-06 14:17:52 +0900192 match try_run_payload(&service) {
193 Ok(code) => {
194 info!("notifying payload finished");
195 service.notifyPayloadFinished(code)?;
196 if code == 0 {
197 info!("task successfully finished");
198 } else {
199 error!("task exited with exit code: {}", code);
200 }
201 Ok(())
202 }
203 Err(err) => {
Jooyung Han5c6d4172021-12-06 14:17:52 +0900204 let (error_code, message) = translate_error(&err);
205 service.notifyError(error_code, &message)?;
206 Err(err)
207 }
Jooyung Handd0a1732021-11-23 15:26:20 +0900208 }
209}
210
Alan Stokes1f417c92022-09-29 15:13:28 +0100211fn dice_derivation(
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000212 dice: DiceDriver,
Alan Stokes1f417c92022-09-29 15:13:28 +0100213 verified_data: &MicrodroidData,
214 payload_metadata: &PayloadMetadata,
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000215) -> Result<DiceContext> {
Andrew Scullb2f44472022-01-21 14:41:34 +0000216 // Calculate compound digests of code and authorities
Andrew Sculla0d1b1a2022-05-24 19:32:47 +0000217 let mut code_hash_ctx = Sha512::new();
218 let mut authority_hash_ctx = Sha512::new();
Andrew Scullb2f44472022-01-21 14:41:34 +0000219 code_hash_ctx.update(verified_data.apk_data.root_hash.as_ref());
220 authority_hash_ctx.update(verified_data.apk_data.pubkey.as_ref());
Inseob Kimb2519c52022-04-14 02:10:09 +0900221 for extra_apk in &verified_data.extra_apks_data {
Andrew Scullb2f44472022-01-21 14:41:34 +0000222 code_hash_ctx.update(extra_apk.root_hash.as_ref());
223 authority_hash_ctx.update(extra_apk.pubkey.as_ref());
224 }
Inseob Kimb2519c52022-04-14 02:10:09 +0900225 for apex in &verified_data.apex_data {
Andrew Scullb2f44472022-01-21 14:41:34 +0000226 code_hash_ctx.update(apex.root_digest.as_ref());
227 authority_hash_ctx.update(apex.public_key.as_ref());
228 }
Andrew Sculla0d1b1a2022-05-24 19:32:47 +0000229 let code_hash = code_hash_ctx.finish();
230 let authority_hash = authority_hash_ctx.finish();
Andrew Scullb2f44472022-01-21 14:41:34 +0000231
232 // {
233 // -70002: "Microdroid payload",
Alan Stokes1f417c92022-09-29 15:13:28 +0100234 // ? -71000: tstr // payload_config_path
235 // ? -71001: PayloadConfig
Andrew Scullb2f44472022-01-21 14:41:34 +0000236 // }
Alan Stokes1f417c92022-09-29 15:13:28 +0100237 // PayloadConfig = {
238 // 1: tstr // payload_binary_path
Alan Stokes1f417c92022-09-29 15:13:28 +0100239 // }
240
Andrew Scullb2f44472022-01-21 14:41:34 +0000241 let mut config_desc = vec![
Alan Stokes1f417c92022-09-29 15:13:28 +0100242 0xa2, // map(2)
243 0x3a, 0x00, 0x01, 0x11, 0x71, // -70002
244 0x72, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x20, 0x70, 0x61, 0x79,
245 0x6c, 0x6f, 0x61, 0x64, // "Microdroid payload"
Andrew Scullb2f44472022-01-21 14:41:34 +0000246 ];
Alan Stokes1f417c92022-09-29 15:13:28 +0100247
248 match payload_metadata {
249 PayloadMetadata::config_path(payload_config_path) => {
250 encode_negative_number(-71000, &mut config_desc)?;
251 encode_tstr(payload_config_path, &mut config_desc)?;
252 }
253 PayloadMetadata::config(payload_config) => {
254 encode_negative_number(-71001, &mut config_desc)?;
255 encode_header(5, 1, &mut config_desc)?; // map(1)
256 encode_number(1, &mut config_desc)?;
257 encode_tstr(&payload_config.payload_binary_path, &mut config_desc)?;
258 }
259 }
Andrew Scullb2f44472022-01-21 14:41:34 +0000260
Andrew Scull65ddfc42022-02-14 21:03:58 +0000261 // Check app debuggability, conervatively assuming it is debuggable
262 let app_debuggable = system_properties::read_bool(APP_DEBUGGABLE_PROP, true)?;
263
Andrew Scullb2f44472022-01-21 14:41:34 +0000264 // Send the details to diced
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000265 let hidden = verified_data.salt.clone().try_into().unwrap();
266 dice.derive(code_hash, &config_desc, authority_hash, app_debuggable, hidden)
Andrew Scullb2f44472022-01-21 14:41:34 +0000267}
268
Alan Stokes1f417c92022-09-29 15:13:28 +0100269fn encode_tstr(tstr: &str, buffer: &mut Vec<u8>) -> Result<()> {
270 let bytes = tstr.as_bytes();
271 encode_header(3, bytes.len().try_into().unwrap(), buffer)?;
272 buffer.extend_from_slice(bytes);
273 Ok(())
274}
275
276fn encode_negative_number(n: i64, buffer: &mut dyn Write) -> Result<()> {
277 ensure!(n < 0);
278 let n = -1 - n;
279 encode_header(1, n.try_into().unwrap(), buffer)
280}
281
Andrew Scullab72ec52022-03-14 09:10:52 +0000282fn is_strict_boot() -> bool {
283 Path::new(AVF_STRICT_BOOT).exists()
284}
285
286fn is_new_instance() -> bool {
287 Path::new(AVF_NEW_INSTANCE).exists()
288}
289
Inseob Kime379e7d2022-07-22 18:55:18 +0900290fn is_verified_boot() -> bool {
291 !Path::new(DEBUG_MICRODROID_NO_VERIFIED_BOOT).exists()
292}
293
Jooyung Han5c6d4172021-12-06 14:17:52 +0900294fn try_run_payload(service: &Strong<dyn IVirtualMachineService>) -> Result<i32> {
Jooyung Han311b1202021-09-14 22:00:16 +0900295 let metadata = load_metadata().context("Failed to load payload metadata")?;
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000296 let dice = DiceDriver::new(Path::new("/dev/open-dice0")).context("Failed to load DICE")?;
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900297
Jooyung Han311b1202021-09-14 22:00:16 +0900298 let mut instance = InstanceDisk::new().context("Failed to load instance.img")?;
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000299 let saved_data =
300 instance.read_microdroid_data(&dice).context("Failed to read identity data")?;
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900301
Andrew Scullab72ec52022-03-14 09:10:52 +0000302 if is_strict_boot() {
303 // Provisioning must happen on the first boot and never again.
304 if is_new_instance() {
305 ensure!(
306 saved_data.is_none(),
307 MicrodroidError::InvalidConfig("Found instance data on first boot.".to_string())
308 );
309 } else {
310 ensure!(
311 saved_data.is_some(),
312 MicrodroidError::InvalidConfig("Instance data not found.".to_string())
313 );
314 };
315 }
316
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900317 // Verify the payload before using it.
Inseob Kim11f40d02022-06-13 17:16:00 +0900318 let verified_data = verify_payload(&metadata, saved_data.as_ref())
319 .context("Payload verification failed")
320 .map_err(|e| MicrodroidError::PayloadVerificationFailed(e.to_string()))?;
Inseob Kime379e7d2022-07-22 18:55:18 +0900321
322 // In case identity is ignored (by debug policy), we should reuse existing payload data, even
323 // when the payload is changed. This is to keep the derived secret same as before.
324 let verified_data = if let Some(saved_data) = saved_data {
325 if !is_verified_boot() {
326 if saved_data != verified_data {
327 info!("Detected an update of the payload, but continue (regarding debug policy)")
328 }
329 } else {
330 ensure!(
331 saved_data == verified_data,
332 MicrodroidError::PayloadChanged(String::from(
333 "Detected an update of the payload which isn't supported yet."
334 ))
335 );
336 info!("Saved data is verified.");
337 }
338 saved_data
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900339 } else {
Jooyung Han7a343f92021-09-08 22:53:11 +0900340 info!("Saving verified data.");
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000341 instance
342 .write_microdroid_data(&verified_data, &dice)
343 .context("Failed to write identity data")?;
Inseob Kime379e7d2022-07-22 18:55:18 +0900344 verified_data
345 };
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900346
Alan Stokes1f417c92022-09-29 15:13:28 +0100347 let payload_metadata = metadata.payload.ok_or_else(|| {
348 MicrodroidError::InvalidConfig("No payload config in metadata".to_string())
349 })?;
Alan Stokes0d1ef782022-09-27 13:46:35 +0100350
Inseob Kimb2519c52022-04-14 02:10:09 +0900351 // To minimize the exposure to untrusted data, derive dice profile as soon as possible.
352 info!("DICE derivation for payload");
Andrew Sculld64ae7d2022-10-05 17:41:43 +0000353 let dice = dice_derivation(dice, &verified_data, &payload_metadata)?;
Inseob Kimb2519c52022-04-14 02:10:09 +0900354
Jooyung Hana6d11eb2021-09-10 11:48:05 +0900355 // Before reading a file from the APK, start zipfuse
Inseob Kim217038e2021-11-25 11:15:06 +0900356 run_zipfuse(
Alan Stokes60f82202022-10-07 16:40:07 +0100357 MountForExec::Allowed,
Inseob Kim217038e2021-11-25 11:15:06 +0900358 "fscontext=u:object_r:zipfusefs:s0,context=u:object_r:system_file:s0",
359 Path::new("/dev/block/mapper/microdroid-apk"),
Alice Wang6bbb6da2022-10-26 12:44:06 +0000360 Path::new(VM_APK_CONTENTS_PATH),
Alan Stokes60f82202022-10-07 16:40:07 +0100361 Some(APK_MOUNT_DONE_PROP),
Inseob Kim217038e2021-11-25 11:15:06 +0900362 )
363 .context("Failed to run zipfuse")?;
Jiyong Park21ce2c52021-08-28 02:32:17 +0900364
Andrew Scull4d262dc2022-10-21 13:14:33 +0000365 // Restricted APIs are only allowed to be used by platform or test components. Infer this from
366 // the use of a VM config file since those can only be used by platform and test components.
367 let allow_restricted_apis = match payload_metadata {
368 PayloadMetadata::config_path(_) => true,
369 PayloadMetadata::config(_) => false,
370 };
371
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100372 let config = load_config(payload_metadata).context("Failed to load payload metadata")?;
Shikha Panwar6f03c942022-04-13 20:26:50 +0000373
Alan Stokes01b3ef02022-09-22 17:43:24 +0100374 let task = config
375 .task
376 .as_ref()
377 .ok_or_else(|| MicrodroidError::InvalidConfig("No task in VM config".to_string()))?;
378
Inseob Kim197748b2021-12-01 19:49:00 +0900379 if config.extra_apks.len() != verified_data.extra_apks_data.len() {
380 return Err(anyhow!(
Alan Stokes1f417c92022-09-29 15:13:28 +0100381 "config expects {} extra apks, but found {}",
Inseob Kim197748b2021-12-01 19:49:00 +0900382 config.extra_apks.len(),
383 verified_data.extra_apks_data.len()
384 ));
385 }
386 mount_extra_apks(&config)?;
Jooyung Han634e2d72021-06-10 16:27:38 +0900387
Jooyung Han5c6d4172021-12-06 14:17:52 +0900388 // Wait until apex config is done. (e.g. linker configuration for apexes)
389 // TODO(jooyung): wait until sys.boot_completed?
390 wait_for_apex_config_done()?;
391
Inseob Kimcd9c1dd2022-07-13 17:13:45 +0900392 // Start tombstone_transmit if enabled
393 if config.export_tombstones {
Alan Stokes01b3ef02022-09-22 17:43:24 +0100394 control_service("start", "tombstone_transmit")?;
Inseob Kimcd9c1dd2022-07-13 17:13:45 +0900395 } else {
Alan Stokes01b3ef02022-09-22 17:43:24 +0100396 control_service("stop", "tombstoned")?;
Inseob Kimcd9c1dd2022-07-13 17:13:45 +0900397 }
398
Alan Stokes01b3ef02022-09-22 17:43:24 +0100399 // Start authfs if enabled
400 if config.enable_authfs {
401 control_service("start", "authfs_service")?;
402 }
403
Alan Stokes60f82202022-10-07 16:40:07 +0100404 // Wait until zipfuse has mounted the APK so we can access the payload
405 wait_for_property_true(APK_MOUNT_DONE_PROP).context("Failed waiting for APK mount done")?;
406
Andrew Scull4d262dc2022-10-21 13:14:33 +0000407 register_vm_payload_service(allow_restricted_apis, service.clone(), dice)?;
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100408
409 system_properties::write("dev.bootcomplete", "1").context("set dev.bootcomplete")?;
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100410 exec_task(task, service).context("Failed to run payload")
Alan Stokes01b3ef02022-09-22 17:43:24 +0100411}
412
413fn control_service(action: &str, service: &str) -> Result<()> {
414 system_properties::write(&format!("ctl.{}", action), service)
415 .with_context(|| format!("Failed to {} {}", action, service))
Jooyung Han347d9f22021-05-28 00:05:14 +0900416}
417
Inseob Kim217038e2021-11-25 11:15:06 +0900418struct ApkDmverityArgument<'a> {
419 apk: &'a str,
420 idsig: &'a str,
421 name: &'a str,
Inseob Kim197748b2021-12-01 19:49:00 +0900422 saved_root_hash: Option<&'a RootHash>,
Inseob Kim217038e2021-11-25 11:15:06 +0900423}
424
425fn run_apkdmverity(args: &[ApkDmverityArgument]) -> Result<Child> {
426 let mut cmd = Command::new(APKDMVERITY_BIN);
427
428 cmd.stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null());
429
430 for argument in args {
431 cmd.arg("--apk").arg(argument.apk).arg(argument.idsig).arg(argument.name);
Inseob Kim197748b2021-12-01 19:49:00 +0900432 if let Some(root_hash) = argument.saved_root_hash {
433 cmd.arg(&to_hex_string(root_hash));
434 } else {
435 cmd.arg("none");
436 }
Inseob Kim217038e2021-11-25 11:15:06 +0900437 }
438
439 cmd.spawn().context("Spawn apkdmverity")
440}
441
Alan Stokes60f82202022-10-07 16:40:07 +0100442enum MountForExec {
443 Allowed,
444 Disallowed,
445}
446
447fn run_zipfuse(
448 noexec: MountForExec,
449 option: &str,
450 zip_path: &Path,
451 mount_dir: &Path,
452 ready_prop: Option<&str>,
453) -> Result<Child> {
Andrew Scullcc339a12022-07-04 12:44:19 +0000454 let mut cmd = Command::new(ZIPFUSE_BIN);
Alan Stokes60f82202022-10-07 16:40:07 +0100455 if let MountForExec::Disallowed = noexec {
Andrew Scullcc339a12022-07-04 12:44:19 +0000456 cmd.arg("--noexec");
457 }
Alan Stokes60f82202022-10-07 16:40:07 +0100458 if let Some(property_name) = ready_prop {
459 cmd.args(["-p", property_name]);
460 }
Andrew Scullcc339a12022-07-04 12:44:19 +0000461 cmd.arg("-o")
Inseob Kim217038e2021-11-25 11:15:06 +0900462 .arg(option)
463 .arg(zip_path)
464 .arg(mount_dir)
465 .stdin(Stdio::null())
466 .stdout(Stdio::null())
467 .stderr(Stdio::null())
468 .spawn()
469 .context("Spawn zipfuse")
470}
471
Inseob Kime379e7d2022-07-22 18:55:18 +0900472fn write_apex_payload_data(
473 saved_data: Option<&MicrodroidData>,
474 apex_data_from_payload: &[ApexData],
475) -> Result<()> {
476 if let Some(saved_apex_data) = saved_data.map(|d| &d.apex_data) {
477 // We don't support APEX updates. (assuming that update will change root digest)
478 ensure!(
479 saved_apex_data == apex_data_from_payload,
480 MicrodroidError::PayloadChanged(String::from("APEXes have changed."))
481 );
482 let apex_metadata = to_metadata(apex_data_from_payload);
483 // Pass metadata(with public keys and root digests) to apexd so that it uses the passed
484 // metadata instead of the default one (/dev/block/by-name/payload-metadata)
485 OpenOptions::new()
486 .create_new(true)
487 .write(true)
488 .open("/apex/vm-payload-metadata")
489 .context("Failed to open /apex/vm-payload-metadata")
490 .and_then(|f| write_metadata(&apex_metadata, f))?;
491 }
492 Ok(())
493}
494
Jooyung Han7a343f92021-09-08 22:53:11 +0900495// Verify payload before executing it. For APK payload, Full verification (which is slow) is done
496// when the root_hash values from the idsig file and the instance disk are different. This function
497// returns the verified root hash (for APK payload) and pubkeys (for APEX payloads) that can be
498// saved to the instance disk.
499fn verify_payload(
500 metadata: &Metadata,
501 saved_data: Option<&MicrodroidData>,
502) -> Result<MicrodroidData> {
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900503 let start_time = SystemTime::now();
504
Inseob Kim197748b2021-12-01 19:49:00 +0900505 // Verify main APK
Jooyung Han7a343f92021-09-08 22:53:11 +0900506 let root_hash = saved_data.map(|d| &d.apk_data.root_hash);
Inseob Kim197748b2021-12-01 19:49:00 +0900507 let root_hash_from_idsig = get_apk_root_hash_from_idsig(MAIN_APK_IDSIG_PATH)?;
Jiyong Parkf7dea252021-09-08 01:42:54 +0900508 let root_hash_trustful = root_hash == Some(&root_hash_from_idsig);
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900509
Jiyong Parkf7dea252021-09-08 01:42:54 +0900510 // 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 +0900511 // instead of the value read from the idsig file.
Inseob Kim197748b2021-12-01 19:49:00 +0900512 let main_apk_argument = {
513 ApkDmverityArgument {
514 apk: MAIN_APK_PATH,
515 idsig: MAIN_APK_IDSIG_PATH,
516 name: MAIN_APK_DEVICE_NAME,
517 saved_root_hash: if root_hash_trustful {
518 Some(root_hash_from_idsig.as_ref())
519 } else {
520 None
521 },
522 }
523 };
524 let mut apkdmverity_arguments = vec![main_apk_argument];
525
526 // Verify extra APKs
527 // For now, we can't read the payload config, so glob APKs and idsigs.
528 // Later, we'll see if it matches with the payload config.
529
530 // sort globbed paths to match apks (extra-apk-{idx}) and idsigs (extra-idsig-{idx})
531 // e.g. "extra-apk-0" corresponds to "extra-idsig-0"
532 let extra_apks =
533 sorted(glob(EXTRA_APK_PATH_PATTERN)?.collect::<Result<Vec<_>, _>>()?).collect::<Vec<_>>();
534 let extra_idsigs =
535 sorted(glob(EXTRA_IDSIG_PATH_PATTERN)?.collect::<Result<Vec<_>, _>>()?).collect::<Vec<_>>();
536 if extra_apks.len() != extra_idsigs.len() {
537 return Err(anyhow!(
538 "Extra apks/idsigs mismatch: {} apks but {} idsigs",
539 extra_apks.len(),
540 extra_idsigs.len()
541 ));
542 }
543 let extra_apks_count = extra_apks.len();
544
545 let (extra_apk_names, extra_root_hashes_from_idsig): (Vec<_>, Vec<_>) = extra_idsigs
546 .iter()
547 .enumerate()
548 .map(|(i, extra_idsig)| {
549 (
550 format!("extra-apk-{}", i),
Alice Wang89cff012022-09-26 10:05:16 +0000551 get_apk_root_hash_from_idsig(extra_idsig)
Inseob Kim197748b2021-12-01 19:49:00 +0900552 .expect("Can't find root hash from extra idsig"),
553 )
554 })
555 .unzip();
556
557 let saved_extra_root_hashes: Vec<_> = saved_data
558 .map(|d| d.extra_apks_data.iter().map(|apk_data| &apk_data.root_hash).collect())
559 .unwrap_or_else(Vec::new);
560 let extra_root_hashes_trustful: Vec<_> = extra_root_hashes_from_idsig
561 .iter()
562 .enumerate()
563 .map(|(i, root_hash_from_idsig)| {
564 saved_extra_root_hashes.get(i).copied() == Some(root_hash_from_idsig)
565 })
566 .collect();
567
568 for i in 0..extra_apks_count {
569 apkdmverity_arguments.push({
570 ApkDmverityArgument {
571 apk: extra_apks[i].to_str().unwrap(),
572 idsig: extra_idsigs[i].to_str().unwrap(),
573 name: &extra_apk_names[i],
574 saved_root_hash: if extra_root_hashes_trustful[i] {
575 Some(&extra_root_hashes_from_idsig[i])
576 } else {
577 None
578 },
579 }
580 });
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900581 }
582
583 // Start apkdmverity and wait for the dm-verify block
Inseob Kim197748b2021-12-01 19:49:00 +0900584 let mut apkdmverity_child = run_apkdmverity(&apkdmverity_arguments)?;
Jooyung Han7a343f92021-09-08 22:53:11 +0900585
Jooyung Hanc8deb472021-09-13 13:48:25 +0900586 // While waiting for apkdmverity to mount APK, gathers public keys and root digests from
587 // APEX payload.
Jooyung Han7a343f92021-09-08 22:53:11 +0900588 let apex_data_from_payload = get_apex_data_from_payload(metadata)?;
Inseob Kime379e7d2022-07-22 18:55:18 +0900589
590 // Writing /apex/vm-payload-metadata is to verify that the payload isn't changed.
591 // Skip writing it if the debug policy ignoring identity is on
592 if is_verified_boot() {
593 write_apex_payload_data(saved_data, &apex_data_from_payload)?;
Jooyung Han4a9b3bf2021-09-10 17:19:00 +0900594 }
Inseob Kime379e7d2022-07-22 18:55:18 +0900595
Jooyung Han4a9b3bf2021-09-10 17:19:00 +0900596 // Start apexd to activate APEXes
597 system_properties::write("ctl.start", "apexd-vm")?;
Jooyung Han7a343f92021-09-08 22:53:11 +0900598
Inseob Kim217038e2021-11-25 11:15:06 +0900599 // TODO(inseob): add timeout
600 apkdmverity_child.wait()?;
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900601
Jiyong Parkf7dea252021-09-08 01:42:54 +0900602 // Do the full verification if the root_hash is un-trustful. This requires the full scanning of
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900603 // 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 +0900604 // 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 +0900605 // of the VM or APK was updated in the host.
606 // TODO(jooyung): consider multithreading to make this faster
Inseob Kim197748b2021-12-01 19:49:00 +0900607 let main_apk_pubkey = get_public_key_from_apk(DM_MOUNTED_APK_PATH, root_hash_trustful)?;
608 let extra_apks_data = extra_root_hashes_from_idsig
609 .into_iter()
610 .enumerate()
611 .map(|(i, extra_root_hash)| {
612 let mount_path = format!("/dev/block/mapper/{}", &extra_apk_names[i]);
613 let apk_pubkey = get_public_key_from_apk(&mount_path, extra_root_hashes_trustful[i])?;
614 Ok(ApkData { root_hash: extra_root_hash, pubkey: apk_pubkey })
615 })
616 .collect::<Result<Vec<_>>>()?;
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900617
618 info!("payload verification successful. took {:#?}", start_time.elapsed().unwrap());
619
Andrew Scull34916a72022-01-30 21:34:24 +0000620 // Use the salt from a verified instance, or generate a salt for a new instance.
621 let salt = if let Some(saved_data) = saved_data {
622 saved_data.salt.clone()
623 } else {
624 let mut salt = vec![0u8; 64];
625 salt.as_mut_slice().try_fill(&mut rand::thread_rng())?;
626 salt
627 };
628
Jiyong Parkf7dea252021-09-08 01:42:54 +0900629 // At this point, we can ensure that the root_hash from the idsig file is trusted, either by
630 // fully verifying the APK or by comparing it with the saved root_hash.
Jooyung Han7a343f92021-09-08 22:53:11 +0900631 Ok(MicrodroidData {
Andrew Scull34916a72022-01-30 21:34:24 +0000632 salt,
Inseob Kim197748b2021-12-01 19:49:00 +0900633 apk_data: ApkData { root_hash: root_hash_from_idsig, pubkey: main_apk_pubkey },
634 extra_apks_data,
Jooyung Han7a343f92021-09-08 22:53:11 +0900635 apex_data: apex_data_from_payload,
636 })
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900637}
638
Inseob Kim197748b2021-12-01 19:49:00 +0900639fn mount_extra_apks(config: &VmPayloadConfig) -> Result<()> {
640 // For now, only the number of apks is important, as the mount point and dm-verity name is fixed
641 for i in 0..config.extra_apks.len() {
642 let mount_dir = format!("/mnt/extra-apk/{}", i);
643 create_dir(Path::new(&mount_dir)).context("Failed to create mount dir for extra apks")?;
644
645 // don't wait, just detach
646 run_zipfuse(
Alan Stokes60f82202022-10-07 16:40:07 +0100647 MountForExec::Disallowed,
Inseob Kim197748b2021-12-01 19:49:00 +0900648 "fscontext=u:object_r:zipfusefs:s0,context=u:object_r:extra_apk_file:s0",
649 Path::new(&format!("/dev/block/mapper/extra-apk-{}", i)),
650 Path::new(&mount_dir),
Alan Stokes60f82202022-10-07 16:40:07 +0100651 None,
Inseob Kim197748b2021-12-01 19:49:00 +0900652 )
653 .context("Failed to zipfuse extra apks")?;
654 }
655
656 Ok(())
657}
658
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900659// Waits until linker config is generated
660fn wait_for_apex_config_done() -> Result<()> {
Alan Stokes60f82202022-10-07 16:40:07 +0100661 wait_for_property_true(APEX_CONFIG_DONE_PROP).context("Failed waiting for apex config done")
662}
663
664fn wait_for_property_true(property_name: &str) -> Result<()> {
665 let mut prop = PropertyWatcher::new(property_name)?;
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900666 loop {
667 prop.wait()?;
Alan Stokes60f82202022-10-07 16:40:07 +0100668 if system_properties::read_bool(property_name, false)? {
Jiyong Parkbb4a9872021-09-06 15:59:21 +0900669 break;
670 }
671 }
Jooyung Han19c1d6c2021-08-06 14:08:16 +0900672 Ok(())
673}
674
Alice Wang89cff012022-09-26 10:05:16 +0000675fn get_apk_root_hash_from_idsig<P: AsRef<Path>>(idsig_path: P) -> Result<Box<RootHash>> {
676 Ok(V4Signature::from_idsig_path(idsig_path)?.hashing_info.raw_root_hash)
Jiyong Park21ce2c52021-08-28 02:32:17 +0900677}
678
Inseob Kim197748b2021-12-01 19:49:00 +0900679fn get_public_key_from_apk(apk: &str, root_hash_trustful: bool) -> Result<Box<[u8]>> {
680 if !root_hash_trustful {
681 verify(apk).context(MicrodroidError::PayloadVerificationFailed(format!(
682 "failed to verify {}",
683 apk
684 )))
685 } else {
686 get_public_key_der(apk)
687 }
688}
689
Alan Stokes1f417c92022-09-29 15:13:28 +0100690fn load_config(payload_metadata: PayloadMetadata) -> Result<VmPayloadConfig> {
691 match payload_metadata {
692 PayloadMetadata::config_path(path) => {
693 let path = Path::new(&path);
694 info!("loading config from {:?}...", path);
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100695 let file = ioutil::wait_for_file(path, WAIT_TIMEOUT)
696 .with_context(|| format!("Failed to read {:?}", path))?;
Alan Stokes1f417c92022-09-29 15:13:28 +0100697 Ok(serde_json::from_reader(file)?)
698 }
699 PayloadMetadata::config(payload_config) => {
700 let task = Task {
701 type_: TaskType::MicrodroidLauncher,
702 command: payload_config.payload_binary_path,
Alan Stokes1f417c92022-09-29 15:13:28 +0100703 };
704 Ok(VmPayloadConfig {
705 os: OsConfig { name: "microdroid".to_owned() },
706 task: Some(task),
707 apexes: vec![],
708 extra_apks: vec![],
709 prefer_staged: false,
710 export_tombstones: false,
711 enable_authfs: false,
712 })
713 }
714 }
Jooyung Han634e2d72021-06-10 16:27:38 +0900715}
716
Jiyong Park202856e2022-08-22 16:04:26 +0900717/// Loads the crashkernel into memory using kexec if the VM is loaded with `crashkernel=' parameter
718/// in the cmdline.
719fn load_crashkernel_if_supported() -> Result<()> {
720 let supported = std::fs::read_to_string("/proc/cmdline")?.contains(" crashkernel=");
721 info!("ramdump supported: {}", supported);
722 if supported {
723 let status = Command::new("/system/bin/kexec_load").status()?;
724 if !status.success() {
725 return Err(anyhow!("Failed to load crashkernel: {:?}", status));
726 }
727 }
728 Ok(())
729}
730
Jiyong Park8611a6c2021-07-09 18:17:44 +0900731/// Executes the given task. Stdout of the task is piped into the vsock stream to the
732/// virtualizationservice in the host side.
Jooyung Han5c6d4172021-12-06 14:17:52 +0900733fn exec_task(task: &Task, service: &Strong<dyn IVirtualMachineService>) -> Result<i32> {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900734 info!("executing main task {:?}...", task);
Inseob Kim86ca0162021-10-20 02:21:02 +0000735 let mut command = build_command(task)?;
Inseob Kim7f61fe72021-08-20 20:50:47 +0900736
737 info!("notifying payload started");
Inseob Kimc7d28c72021-10-25 14:28:10 +0000738 service.notifyPayloadStarted()?;
Inseob Kim7f61fe72021-08-20 20:50:47 +0900739
Inseob Kim86ca0162021-10-20 02:21:02 +0000740 let exit_status = command.spawn()?.wait()?;
Frederick Mayleb5f7b6b2022-11-11 15:24:03 -0800741 match exit_status.code() {
742 Some(exit_code) => Ok(exit_code),
743 None => Err(match exit_status.signal() {
744 Some(signal) => anyhow!(
745 "Payload exited due to signal: {} ({})",
746 signal,
747 Signal::try_from(signal).map_or("unknown", |s| s.as_str())
748 ),
749 None => anyhow!("Payload has neither exit code nor signal"),
750 }),
751 }
Jooyung Han347d9f22021-05-28 00:05:14 +0900752}
Jooyung Han634e2d72021-06-10 16:27:38 +0900753
754fn build_command(task: &Task) -> Result<Command> {
Inseob Kim7f61fe72021-08-20 20:50:47 +0900755 let mut command = match task.type_ {
Alan Stokes52d3c722022-10-04 17:27:13 +0100756 TaskType::Executable => Command::new(&task.command),
Jooyung Han634e2d72021-06-10 16:27:38 +0900757 TaskType::MicrodroidLauncher => {
758 let mut command = Command::new("/system/bin/microdroid_launcher");
Alan Stokes52d3c722022-10-04 17:27:13 +0100759 command.arg(find_library_path(&task.command)?);
Jooyung Han634e2d72021-06-10 16:27:38 +0900760 command
761 }
Inseob Kim7f61fe72021-08-20 20:50:47 +0900762 };
763
Inseob Kimd0587562021-09-01 21:27:32 +0900764 match VsockStream::connect_with_cid_port(VMADDR_CID_HOST, VM_STREAM_SERVICE_PORT as u32) {
Inseob Kim7f61fe72021-08-20 20:50:47 +0900765 Ok(stream) => {
766 // SAFETY: the ownership of the underlying file descriptor is transferred from stream
767 // to the file object, and then into the Command object. When the command is finished,
768 // the file descriptor is closed.
769 let file = unsafe { File::from_raw_fd(stream.into_raw_fd()) };
770 command
771 .stdin(Stdio::from(file.try_clone()?))
772 .stdout(Stdio::from(file.try_clone()?))
773 .stderr(Stdio::from(file));
774 }
775 Err(e) => {
776 error!("failed to connect to virtualization service: {}", e);
777 // Don't fail hard here. Even if we failed to connect to the virtualizationservice,
778 // we keep executing the task. This can happen if the owner of the VM doesn't register
779 // callback to accept the stream. Use /dev/null as the stream so that the task can
780 // make progress without waiting for someone to consume the output.
781 command.stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null());
782 }
783 }
784
785 Ok(command)
Jooyung Han634e2d72021-06-10 16:27:38 +0900786}
787
788fn find_library_path(name: &str) -> Result<String> {
789 let mut watcher = PropertyWatcher::new("ro.product.cpu.abilist")?;
790 let value = watcher.read(|_name, value| Ok(value.trim().to_string()))?;
791 let abi = value.split(',').next().ok_or_else(|| anyhow!("no abilist"))?;
Alice Wang6bbb6da2022-10-26 12:44:06 +0000792 let path = format!("{}/lib/{}/{}", VM_APK_CONTENTS_PATH, abi, name);
Jooyung Han634e2d72021-06-10 16:27:38 +0900793
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100794 let metadata = fs::metadata(&path).with_context(|| format!("Unable to access {}", path))?;
Jooyung Han634e2d72021-06-10 16:27:38 +0900795 if !metadata.is_file() {
796 bail!("{} is not a file", &path);
797 }
798
799 Ok(path)
800}
Jiyong Park21ce2c52021-08-28 02:32:17 +0900801
802fn to_hex_string(buf: &[u8]) -> String {
803 buf.iter().map(|b| format!("{:02X}", b)).collect()
804}