blob: 36edc64a29eeb32425ddbfd02791b0452bfce5bb [file] [log] [blame]
Andrew Walbranf395b822021-05-05 10:38:59 +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
15//! Command to run a VM.
16
Jiyong Park48b354d2021-07-15 15:04:38 +090017use crate::create_partition::command_create_partition;
Jooyung Han21e9b922021-06-26 04:14:16 +090018use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
David Brazdil7d1e5ec2023-02-06 17:56:29 +000019 CpuTopology::CpuTopology,
Alan Stokes0d1ef782022-09-27 13:46:35 +010020 IVirtualizationService::IVirtualizationService,
21 PartitionType::PartitionType,
22 VirtualMachineAppConfig::{DebugLevel::DebugLevel, Payload::Payload, VirtualMachineAppConfig},
23 VirtualMachineConfig::VirtualMachineConfig,
Inseob Kim7b5f65c2022-11-15 14:27:04 +090024 VirtualMachinePayloadConfig::VirtualMachinePayloadConfig,
Andrew Walbranf8d94112021-09-07 11:45:36 +000025 VirtualMachineState::VirtualMachineState,
Jooyung Han21e9b922021-06-26 04:14:16 +090026};
Nikita Ioffeb0b67562022-11-22 15:48:06 +000027use anyhow::{anyhow, bail, Context, Error};
Alan Stokes0e82b502022-08-08 14:44:48 +010028use binder::ParcelFileDescriptor;
Nikita Ioffefc041962023-01-18 00:10:40 +000029use glob::glob;
Inseob Kima5a262f2021-11-17 19:41:03 +090030use microdroid_payload_config::VmPayloadConfig;
Nikita Ioffeb0b67562022-11-22 15:48:06 +000031use rand::{distributions::Alphanumeric, Rng};
32use std::fs;
Andrew Walbranf395b822021-05-05 10:38:59 +000033use std::fs::File;
Alan Stokesf30982b2022-11-18 11:50:32 +000034use std::io;
Nikita Ioffe5776f082023-02-10 21:38:26 +000035use std::num::NonZeroU16;
Andrew Walbranf395b822021-05-05 10:38:59 +000036use std::os::unix::io::{AsRawFd, FromRawFd};
Inseob Kima5a262f2021-11-17 19:41:03 +090037use std::path::{Path, PathBuf};
Alan Stokes2bead0d2022-09-05 16:58:34 +010038use vmclient::{ErrorCode, VmInstance};
Jiyong Park48b354d2021-07-15 15:04:38 +090039use vmconfig::{open_parcel_file, VmConfig};
Inseob Kima5a262f2021-11-17 19:41:03 +090040use zip::ZipArchive;
Andrew Walbranf395b822021-05-05 10:38:59 +000041
Jooyung Han21e9b922021-06-26 04:14:16 +090042/// Run a VM from the given APK, idsig, and config.
Jiyong Park48b354d2021-07-15 15:04:38 +090043#[allow(clippy::too_many_arguments)]
Jooyung Han21e9b922021-06-26 04:14:16 +090044pub fn command_run_app(
Seungjae Yoo62085c02022-08-12 04:44:52 +000045 name: Option<String>,
Andrew Walbran616d13f2022-05-12 18:35:55 +000046 service: &dyn IVirtualizationService,
Jooyung Han21e9b922021-06-26 04:14:16 +090047 apk: &Path,
48 idsig: &Path,
Jiyong Park48b354d2021-07-15 15:04:38 +090049 instance: &Path,
Shikha Panwar22e70452022-10-10 18:32:55 +000050 storage: Option<&Path>,
51 storage_size: Option<u64>,
Inseob Kim7b5f65c2022-11-15 14:27:04 +090052 config_path: Option<String>,
Alan Stokes8f12f2b2023-01-09 09:19:20 +000053 payload_binary_name: Option<String>,
Jiyong Parkb8182bb2021-10-26 22:53:08 +090054 console_path: Option<&Path>,
Jooyung Han21e9b922021-06-26 04:14:16 +090055 log_path: Option<&Path>,
Jiyong Parkc2a49cc2021-10-15 00:02:12 +090056 debug_level: DebugLevel,
Andrew Walbran3994f002022-01-27 17:33:45 +000057 protected: bool,
Jiyong Parkd63cfff2021-09-27 20:10:17 +090058 mem: Option<u32>,
David Brazdil7d1e5ec2023-02-06 17:56:29 +000059 cpu_topology: CpuTopology,
Jiyong Parkdfe16d62022-04-20 17:32:12 +090060 task_profiles: Vec<String>,
Inseob Kima5a262f2021-11-17 19:41:03 +090061 extra_idsigs: &[PathBuf],
Nikita Ioffe5776f082023-02-10 21:38:26 +000062 gdb: Option<NonZeroU16>,
Jooyung Han21e9b922021-06-26 04:14:16 +090063) -> Result<(), Error> {
Steven Moreland6a55e2e2022-10-22 00:30:42 +000064 let apk_file = File::open(apk).context("Failed to open APK file")?;
65
Inseob Kim7b5f65c2022-11-15 14:27:04 +090066 let extra_apks = match config_path.as_deref() {
67 Some(path) => parse_extra_apk_list(apk, path)?,
68 None => vec![],
69 };
70
Inseob Kima5a262f2021-11-17 19:41:03 +090071 if extra_apks.len() != extra_idsigs.len() {
72 bail!(
73 "Found {} extra apks, but there are {} extra idsigs",
74 extra_apks.len(),
75 extra_idsigs.len()
76 )
77 }
78
79 for i in 0..extra_apks.len() {
80 let extra_apk_fd = ParcelFileDescriptor::new(File::open(&extra_apks[i])?);
81 let extra_idsig_fd = ParcelFileDescriptor::new(File::create(&extra_idsigs[i])?);
82 service.createOrUpdateIdsigFile(&extra_apk_fd, &extra_idsig_fd)?;
83 }
84
Jiyong Park0a248432021-08-20 23:32:39 +090085 let idsig_file = File::create(idsig).context("Failed to create idsig file")?;
86
87 let apk_fd = ParcelFileDescriptor::new(apk_file);
88 let idsig_fd = ParcelFileDescriptor::new(idsig_file);
89 service.createOrUpdateIdsigFile(&apk_fd, &idsig_fd)?;
90
Jooyung Han21e9b922021-06-26 04:14:16 +090091 let idsig_file = File::open(idsig).context("Failed to open idsig file")?;
Jiyong Park0a248432021-08-20 23:32:39 +090092 let idsig_fd = ParcelFileDescriptor::new(idsig_file);
Jiyong Park48b354d2021-07-15 15:04:38 +090093
94 if !instance.exists() {
95 const INSTANCE_FILE_SIZE: u64 = 10 * 1024 * 1024;
Jiyong Park9dd389e2021-08-23 20:42:59 +090096 command_create_partition(
Andrew Walbran616d13f2022-05-12 18:35:55 +000097 service,
Jiyong Park9dd389e2021-08-23 20:42:59 +090098 instance,
99 INSTANCE_FILE_SIZE,
100 PartitionType::ANDROID_VM_INSTANCE,
101 )?;
Jiyong Park48b354d2021-07-15 15:04:38 +0900102 }
103
Shikha Panwar22e70452022-10-10 18:32:55 +0000104 let storage = if let Some(path) = storage {
105 if !path.exists() {
106 command_create_partition(
107 service,
108 path,
109 storage_size.unwrap_or(10 * 1024 * 1024),
Shikha Panwar9fd198f2022-11-18 17:43:43 +0000110 PartitionType::ENCRYPTEDSTORE,
Shikha Panwar22e70452022-10-10 18:32:55 +0000111 )?;
112 }
113 Some(open_parcel_file(path, true)?)
114 } else {
115 None
116 };
117
Inseob Kima5a262f2021-11-17 19:41:03 +0900118 let extra_idsig_files: Result<Vec<File>, _> = extra_idsigs.iter().map(File::open).collect();
119 let extra_idsig_fds = extra_idsig_files?.into_iter().map(ParcelFileDescriptor::new).collect();
120
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900121 let payload = if let Some(config_path) = config_path {
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000122 if payload_binary_name.is_some() {
123 bail!("Only one of --config-path or --payload-binary-name can be defined")
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900124 }
125 Payload::ConfigPath(config_path)
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000126 } else if let Some(payload_binary_name) = payload_binary_name {
127 Payload::PayloadConfig(VirtualMachinePayloadConfig {
128 payloadBinaryName: payload_binary_name,
129 })
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900130 } else {
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000131 bail!("Either --config-path or --payload-binary-name must be defined")
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900132 };
133
134 let payload_config_str = format!("{:?}!{:?}", apk, payload);
135
Jooyung Han21e9b922021-06-26 04:14:16 +0900136 let config = VirtualMachineConfig::AppConfig(VirtualMachineAppConfig {
Seungjae Yoo62085c02022-08-12 04:44:52 +0000137 name: name.unwrap_or_else(|| String::from("VmRunApp")),
Jiyong Park0a248432021-08-20 23:32:39 +0900138 apk: apk_fd.into(),
139 idsig: idsig_fd.into(),
Inseob Kima5a262f2021-11-17 19:41:03 +0900140 extraIdsigs: extra_idsig_fds,
Jiyong Park48b354d2021-07-15 15:04:38 +0900141 instanceImage: open_parcel_file(instance, true /* writable */)?.into(),
Shikha Panwar22e70452022-10-10 18:32:55 +0000142 encryptedStorageImage: storage,
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900143 payload,
Jiyong Parkc2a49cc2021-10-15 00:02:12 +0900144 debugLevel: debug_level,
Andrew Walbran3994f002022-01-27 17:33:45 +0000145 protectedVm: protected,
Jiyong Parkd63cfff2021-09-27 20:10:17 +0900146 memoryMib: mem.unwrap_or(0) as i32, // 0 means use the VM default
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000147 cpuTopology: cpu_topology,
Jiyong Parkdfe16d62022-04-20 17:32:12 +0900148 taskProfiles: task_profiles,
Nikita Ioffe5776f082023-02-10 21:38:26 +0000149 gdbPort: gdb.map(u16::from).unwrap_or(0) as i32, // 0 means no gdb
Jooyung Han21e9b922021-06-26 04:14:16 +0900150 });
David Brazdil2b6352f2023-01-12 11:01:17 +0000151 run(service, &config, &payload_config_str, console_path, log_path)
Jooyung Han21e9b922021-06-26 04:14:16 +0900152}
153
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000154fn find_empty_payload_apk_path() -> Result<PathBuf, Error> {
Cole Faust237ee3e2023-03-01 11:58:01 -0800155 const GLOB_PATTERN: &str = "/apex/com.android.virt/app/**/EmptyPayloadApp*.apk";
Nikita Ioffefc041962023-01-18 00:10:40 +0000156 let mut entries: Vec<PathBuf> =
157 glob(GLOB_PATTERN).context("failed to glob")?.filter_map(|e| e.ok()).collect();
158 if entries.len() > 1 {
159 return Err(anyhow!("Found more than one apk matching {}", GLOB_PATTERN));
160 }
161 match entries.pop() {
162 Some(path) => Ok(path),
163 None => Err(anyhow!("No apks match {}", GLOB_PATTERN)),
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000164 }
165}
166
167fn create_work_dir() -> Result<PathBuf, Error> {
168 let s: String =
169 rand::thread_rng().sample_iter(&Alphanumeric).take(17).map(char::from).collect();
170 let work_dir = PathBuf::from("/data/local/tmp/microdroid").join(s);
171 println!("creating work dir {}", work_dir.display());
172 fs::create_dir_all(&work_dir).context("failed to mkdir")?;
173 Ok(work_dir)
174}
175
176/// Run a VM with Microdroid
177#[allow(clippy::too_many_arguments)]
178pub fn command_run_microdroid(
179 name: Option<String>,
180 service: &dyn IVirtualizationService,
181 work_dir: Option<PathBuf>,
182 storage: Option<&Path>,
183 storage_size: Option<u64>,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000184 console_path: Option<&Path>,
185 log_path: Option<&Path>,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000186 debug_level: DebugLevel,
187 protected: bool,
188 mem: Option<u32>,
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000189 cpu_topology: CpuTopology,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000190 task_profiles: Vec<String>,
Nikita Ioffe5776f082023-02-10 21:38:26 +0000191 gdb: Option<NonZeroU16>,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000192) -> Result<(), Error> {
Nikita Ioffefc041962023-01-18 00:10:40 +0000193 let apk = find_empty_payload_apk_path()?;
194 println!("found path {}", apk.display());
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000195
196 let work_dir = work_dir.unwrap_or(create_work_dir()?);
197 let idsig = work_dir.join("apk.idsig");
198 println!("apk.idsig path: {}", idsig.display());
199 let instance_img = work_dir.join("instance.img");
200 println!("instance.img path: {}", instance_img.display());
201
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000202 let payload_binary_name = "MicrodroidEmptyPayloadJniLib.so";
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000203 let extra_sig = [];
204 command_run_app(
205 name,
206 service,
207 &apk,
208 &idsig,
209 &instance_img,
210 storage,
211 storage_size,
212 /* config_path= */ None,
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000213 Some(payload_binary_name.to_owned()),
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000214 console_path,
215 log_path,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000216 debug_level,
217 protected,
218 mem,
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000219 cpu_topology,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000220 task_profiles,
221 &extra_sig,
Nikita Ioffe5776f082023-02-10 21:38:26 +0000222 gdb,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000223 )
224}
225
Andrew Walbranf395b822021-05-05 10:38:59 +0000226/// Run a VM from the given configuration file.
Jooyung Hanb7983a22022-02-22 05:21:27 +0900227#[allow(clippy::too_many_arguments)]
Andrew Walbranf395b822021-05-05 10:38:59 +0000228pub fn command_run(
Seungjae Yoo62085c02022-08-12 04:44:52 +0000229 name: Option<String>,
Andrew Walbran616d13f2022-05-12 18:35:55 +0000230 service: &dyn IVirtualizationService,
Andrew Walbranf395b822021-05-05 10:38:59 +0000231 config_path: &Path,
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900232 console_path: Option<&Path>,
Jooyung Hanb7983a22022-02-22 05:21:27 +0900233 log_path: Option<&Path>,
Jiyong Parkd63cfff2021-09-27 20:10:17 +0900234 mem: Option<u32>,
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000235 cpu_topology: CpuTopology,
Jiyong Parkdfe16d62022-04-20 17:32:12 +0900236 task_profiles: Vec<String>,
Nikita Ioffe5776f082023-02-10 21:38:26 +0000237 gdb: Option<NonZeroU16>,
Andrew Walbranf395b822021-05-05 10:38:59 +0000238) -> Result<(), Error> {
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000239 let config_file = File::open(config_path).context("Failed to open config file")?;
Jiyong Parkd63cfff2021-09-27 20:10:17 +0900240 let mut config =
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000241 VmConfig::load(&config_file).context("Failed to parse config file")?.to_parcelable()?;
Jiyong Parkd63cfff2021-09-27 20:10:17 +0900242 if let Some(mem) = mem {
243 config.memoryMib = mem as i32;
244 }
Seungjae Yoo62085c02022-08-12 04:44:52 +0000245 if let Some(name) = name {
246 config.name = name;
247 } else {
248 config.name = String::from("VmRun");
249 }
Nikita Ioffe5776f082023-02-10 21:38:26 +0000250 if let Some(gdb) = gdb {
251 config.gdbPort = gdb.get() as i32;
252 }
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000253 config.cpuTopology = cpu_topology;
Jiyong Parkdfe16d62022-04-20 17:32:12 +0900254 config.taskProfiles = task_profiles;
Jooyung Han21e9b922021-06-26 04:14:16 +0900255 run(
256 service,
257 &VirtualMachineConfig::RawConfig(config),
258 &format!("{:?}", config_path),
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900259 console_path,
Jooyung Hanb7983a22022-02-22 05:21:27 +0900260 log_path,
Jooyung Han21e9b922021-06-26 04:14:16 +0900261 )
262}
263
Andrew Walbranf8d94112021-09-07 11:45:36 +0000264fn state_to_str(vm_state: VirtualMachineState) -> &'static str {
265 match vm_state {
266 VirtualMachineState::NOT_STARTED => "NOT_STARTED",
267 VirtualMachineState::STARTING => "STARTING",
268 VirtualMachineState::STARTED => "STARTED",
269 VirtualMachineState::READY => "READY",
270 VirtualMachineState::FINISHED => "FINISHED",
271 VirtualMachineState::DEAD => "DEAD",
272 _ => "(invalid state)",
273 }
274}
275
Jooyung Han21e9b922021-06-26 04:14:16 +0900276fn run(
Andrew Walbran616d13f2022-05-12 18:35:55 +0000277 service: &dyn IVirtualizationService,
Jooyung Han21e9b922021-06-26 04:14:16 +0900278 config: &VirtualMachineConfig,
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900279 payload_config: &str,
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900280 console_path: Option<&Path>,
Jooyung Han21e9b922021-06-26 04:14:16 +0900281 log_path: Option<&Path>,
282) -> Result<(), Error> {
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900283 let console = if let Some(console_path) = console_path {
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000284 Some(
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900285 File::create(console_path)
286 .with_context(|| format!("Failed to open console file {:?}", console_path))?,
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000287 )
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900288 } else {
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000289 Some(duplicate_stdout()?)
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900290 };
291 let log = if let Some(log_path) = log_path {
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000292 Some(
Andrew Walbranbe429242021-06-28 12:22:54 +0000293 File::create(log_path)
294 .with_context(|| format!("Failed to open log file {:?}", log_path))?,
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000295 )
Andrew Walbranbe429242021-06-28 12:22:54 +0000296 } else {
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000297 Some(duplicate_stdout()?)
Andrew Walbranbe429242021-06-28 12:22:54 +0000298 };
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900299
Alan Stokes0e82b502022-08-08 14:44:48 +0100300 let callback = Box::new(Callback {});
301 let vm = VmInstance::create(service, config, console, log, Some(callback))
302 .context("Failed to create VM")?;
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000303 vm.start().context("Failed to start VM")?;
Andrew Walbranf395b822021-05-05 10:38:59 +0000304
Andrew Walbranf8d94112021-09-07 11:45:36 +0000305 println!(
306 "Created VM from {} with CID {}, state is {}.",
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900307 payload_config,
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000308 vm.cid(),
309 state_to_str(vm.state()?)
Andrew Walbranf8d94112021-09-07 11:45:36 +0000310 );
Andrew Walbranf395b822021-05-05 10:38:59 +0000311
David Brazdil2b6352f2023-01-12 11:01:17 +0000312 // Wait until the VM or VirtualizationService dies. If we just returned immediately then the
313 // IVirtualMachine Binder object would be dropped and the VM would be killed.
314 let death_reason = vm.wait_for_death();
315 println!("VM ended: {:?}", death_reason);
Andrew Walbranf395b822021-05-05 10:38:59 +0000316 Ok(())
317}
318
Inseob Kima5a262f2021-11-17 19:41:03 +0900319fn parse_extra_apk_list(apk: &Path, config_path: &str) -> Result<Vec<String>, Error> {
320 let mut archive = ZipArchive::new(File::open(apk)?)?;
321 let config_file = archive.by_name(config_path)?;
322 let config: VmPayloadConfig = serde_json::from_reader(config_file)?;
323 Ok(config.extra_apks.into_iter().map(|x| x.path).collect())
324}
325
Alan Stokes0e82b502022-08-08 14:44:48 +0100326struct Callback {}
Andrew Walbranf395b822021-05-05 10:38:59 +0000327
Alan Stokes0e82b502022-08-08 14:44:48 +0100328impl vmclient::VmCallback for Callback {
David Brazdil451cc962022-10-14 14:08:12 +0100329 fn on_payload_started(&self, _cid: i32) {
330 eprintln!("payload started");
331 }
332
Alan Stokes0e82b502022-08-08 14:44:48 +0100333 fn on_payload_ready(&self, _cid: i32) {
Inseob Kim8dbc3222021-09-01 21:50:23 +0900334 eprintln!("payload is ready");
Inseob Kim14cb8692021-08-31 21:50:39 +0900335 }
336
Alan Stokes0e82b502022-08-08 14:44:48 +0100337 fn on_payload_finished(&self, _cid: i32, exit_code: i32) {
Inseob Kim8dbc3222021-09-01 21:50:23 +0900338 eprintln!("payload finished with exit code {}", exit_code);
Inseob Kim2444af92021-08-31 01:22:50 +0900339 }
340
Alan Stokes2bead0d2022-09-05 16:58:34 +0100341 fn on_error(&self, _cid: i32, error_code: ErrorCode, message: &str) {
342 eprintln!("VM encountered an error: code={:?}, message={}", error_code, message);
Andrew Walbranf395b822021-05-05 10:38:59 +0000343 }
344}
345
346/// Safely duplicate the standard output file descriptor.
347fn duplicate_stdout() -> io::Result<File> {
348 let stdout_fd = io::stdout().as_raw_fd();
349 // Safe because this just duplicates a file descriptor which we know to be valid, and we check
350 // for an error.
351 let dup_fd = unsafe { libc::dup(stdout_fd) };
352 if dup_fd < 0 {
353 Err(io::Error::last_os_error())
354 } else {
355 // Safe because we have just duplicated the file descriptor so we own it, and `from_raw_fd`
356 // takes ownership of it.
357 Ok(unsafe { File::from_raw_fd(dup_fd) })
358 }
359}