blob: 6ac141ddfe88a11f64749ae9f65d72d0195e1a4e [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;
Jiyong Parkb1935ef2023-08-10 17:22:39 +090018use crate::{get_service, RunAppConfig, RunCustomVmConfig, RunMicrodroidConfig};
Jooyung Han21e9b922021-06-26 04:14:16 +090019use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
Alan Stokes0d1ef782022-09-27 13:46:35 +010020 IVirtualizationService::IVirtualizationService,
21 PartitionType::PartitionType,
Nikita Ioffea0eb5ee2023-06-26 18:18:21 +010022 VirtualMachineAppConfig::{
23 CustomConfig::CustomConfig, DebugLevel::DebugLevel, Payload::Payload,
24 VirtualMachineAppConfig,
25 },
Alan Stokes0d1ef782022-09-27 13:46:35 +010026 VirtualMachineConfig::VirtualMachineConfig,
Inseob Kim7b5f65c2022-11-15 14:27:04 +090027 VirtualMachinePayloadConfig::VirtualMachinePayloadConfig,
Andrew Walbranf8d94112021-09-07 11:45:36 +000028 VirtualMachineState::VirtualMachineState,
Jooyung Han21e9b922021-06-26 04:14:16 +090029};
Nikita Ioffeb0b67562022-11-22 15:48:06 +000030use anyhow::{anyhow, bail, Context, Error};
Alan Stokes0e82b502022-08-08 14:44:48 +010031use binder::ParcelFileDescriptor;
Nikita Ioffefc041962023-01-18 00:10:40 +000032use glob::glob;
Inseob Kima5a262f2021-11-17 19:41:03 +090033use microdroid_payload_config::VmPayloadConfig;
Nikita Ioffeb0b67562022-11-22 15:48:06 +000034use rand::{distributions::Alphanumeric, Rng};
35use std::fs;
Andrew Walbranf395b822021-05-05 10:38:59 +000036use std::fs::File;
Alan Stokesf30982b2022-11-18 11:50:32 +000037use std::io;
Andrew Walbranf395b822021-05-05 10:38:59 +000038use std::os::unix::io::{AsRawFd, FromRawFd};
Inseob Kima5a262f2021-11-17 19:41:03 +090039use std::path::{Path, PathBuf};
Alan Stokes2bead0d2022-09-05 16:58:34 +010040use vmclient::{ErrorCode, VmInstance};
Jiyong Park48b354d2021-07-15 15:04:38 +090041use vmconfig::{open_parcel_file, VmConfig};
Inseob Kima5a262f2021-11-17 19:41:03 +090042use zip::ZipArchive;
Andrew Walbranf395b822021-05-05 10:38:59 +000043
Jooyung Han21e9b922021-06-26 04:14:16 +090044/// Run a VM from the given APK, idsig, and config.
Jiyong Parkb1935ef2023-08-10 17:22:39 +090045pub fn command_run_app(config: RunAppConfig) -> Result<(), Error> {
46 let service = get_service()?;
47 let apk = File::open(&config.apk).context("Failed to open APK file")?;
Steven Moreland6a55e2e2022-10-22 00:30:42 +000048
Jiyong Parkb1935ef2023-08-10 17:22:39 +090049 let extra_apks = match config.config_path.as_deref() {
50 Some(path) => parse_extra_apk_list(&config.apk, path)?,
Inseob Kim7b5f65c2022-11-15 14:27:04 +090051 None => vec![],
52 };
53
Jiyong Parkb1935ef2023-08-10 17:22:39 +090054 if extra_apks.len() != config.extra_idsigs.len() {
Inseob Kima5a262f2021-11-17 19:41:03 +090055 bail!(
56 "Found {} extra apks, but there are {} extra idsigs",
57 extra_apks.len(),
Jiyong Parkb1935ef2023-08-10 17:22:39 +090058 config.extra_idsigs.len()
Inseob Kima5a262f2021-11-17 19:41:03 +090059 )
60 }
61
Jiyong Parkb1935ef2023-08-10 17:22:39 +090062 for (i, extra_apk) in extra_apks.iter().enumerate() {
63 let extra_apk_fd = ParcelFileDescriptor::new(File::open(extra_apk)?);
64 let extra_idsig_fd = ParcelFileDescriptor::new(File::create(&config.extra_idsigs[i])?);
Inseob Kima5a262f2021-11-17 19:41:03 +090065 service.createOrUpdateIdsigFile(&extra_apk_fd, &extra_idsig_fd)?;
66 }
67
Jiyong Parkb1935ef2023-08-10 17:22:39 +090068 let idsig = File::create(&config.idsig).context("Failed to create idsig file")?;
Jiyong Park0a248432021-08-20 23:32:39 +090069
Jiyong Parkb1935ef2023-08-10 17:22:39 +090070 let apk_fd = ParcelFileDescriptor::new(apk);
71 let idsig_fd = ParcelFileDescriptor::new(idsig);
Jiyong Park0a248432021-08-20 23:32:39 +090072 service.createOrUpdateIdsigFile(&apk_fd, &idsig_fd)?;
73
Jiyong Parkb1935ef2023-08-10 17:22:39 +090074 let idsig = File::open(&config.idsig).context("Failed to open idsig file")?;
75 let idsig_fd = ParcelFileDescriptor::new(idsig);
Jiyong Park48b354d2021-07-15 15:04:38 +090076
Jiyong Parkb1935ef2023-08-10 17:22:39 +090077 if !config.instance.exists() {
Jiyong Park48b354d2021-07-15 15:04:38 +090078 const INSTANCE_FILE_SIZE: u64 = 10 * 1024 * 1024;
Jiyong Park9dd389e2021-08-23 20:42:59 +090079 command_create_partition(
Jiyong Parkb1935ef2023-08-10 17:22:39 +090080 service.as_ref(),
81 &config.instance,
Jiyong Park9dd389e2021-08-23 20:42:59 +090082 INSTANCE_FILE_SIZE,
83 PartitionType::ANDROID_VM_INSTANCE,
84 )?;
Jiyong Park48b354d2021-07-15 15:04:38 +090085 }
86
Nikita Ioffe631717e2023-09-05 13:38:07 +010087 let storage = if let Some(ref path) = config.microdroid.storage {
Shikha Panwar22e70452022-10-10 18:32:55 +000088 if !path.exists() {
89 command_create_partition(
Jiyong Parkb1935ef2023-08-10 17:22:39 +090090 service.as_ref(),
Nikita Ioffe631717e2023-09-05 13:38:07 +010091 path,
Jiyong Parkb1935ef2023-08-10 17:22:39 +090092 config.microdroid.storage_size.unwrap_or(10 * 1024 * 1024),
Shikha Panwar9fd198f2022-11-18 17:43:43 +000093 PartitionType::ENCRYPTEDSTORE,
Shikha Panwar22e70452022-10-10 18:32:55 +000094 )?;
95 }
Nikita Ioffe631717e2023-09-05 13:38:07 +010096 Some(open_parcel_file(path, true)?)
Shikha Panwar22e70452022-10-10 18:32:55 +000097 } else {
98 None
99 };
100
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900101 let vendor =
Nikita Ioffe631717e2023-09-05 13:38:07 +0100102 config.microdroid.vendor().as_ref().map(|p| open_parcel_file(p, false)).transpose()?;
Nikita Ioffe5dfddf22023-06-29 16:11:26 +0100103
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900104 let extra_idsig_files: Result<Vec<File>, _> =
105 config.extra_idsigs.iter().map(File::open).collect();
Inseob Kima5a262f2021-11-17 19:41:03 +0900106 let extra_idsig_fds = extra_idsig_files?.into_iter().map(ParcelFileDescriptor::new).collect();
107
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900108 let payload = if let Some(config_path) = config.config_path {
109 if config.payload_binary_name.is_some() {
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000110 bail!("Only one of --config-path or --payload-binary-name can be defined")
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900111 }
112 Payload::ConfigPath(config_path)
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900113 } else if let Some(payload_binary_name) = config.payload_binary_name {
Inseob Kim7a1fc8f2023-11-22 18:45:28 +0900114 let os_name = if let Some(ver) = config.microdroid.gki() {
115 format!("microdroid_gki-{ver}")
116 } else {
117 "microdroid".to_owned()
118 };
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000119 Payload::PayloadConfig(VirtualMachinePayloadConfig {
120 payloadBinaryName: payload_binary_name,
Inseob Kim172f9eb2023-11-06 17:02:08 +0900121 osName: os_name,
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000122 })
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900123 } else {
Alan Stokes8f12f2b2023-01-09 09:19:20 +0000124 bail!("Either --config-path or --payload-binary-name must be defined")
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900125 };
126
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900127 let payload_config_str = format!("{:?}!{:?}", config.apk, payload);
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900128
Nikita Ioffea0eb5ee2023-06-26 18:18:21 +0100129 let custom_config = CustomConfig {
Inseob Kim172f9eb2023-11-06 17:02:08 +0900130 customKernelImage: None,
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900131 gdbPort: config.debug.gdb.map(u16::from).unwrap_or(0) as i32, // 0 means no gdb
132 taskProfiles: config.common.task_profiles,
Nikita Ioffe5dfddf22023-06-29 16:11:26 +0100133 vendorImage: vendor,
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900134 devices: config
135 .microdroid
Nikita Ioffe94a8a182023-11-16 16:37:48 +0000136 .devices()
Inseob Kim6ef80972023-07-20 17:23:36 +0900137 .iter()
138 .map(|x| {
139 x.to_str().map(String::from).ok_or(anyhow!("Failed to convert {x:?} to String"))
140 })
141 .collect::<Result<_, _>>()?,
Nikita Ioffea0eb5ee2023-06-26 18:18:21 +0100142 };
143
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900144 let vm_config = VirtualMachineConfig::AppConfig(VirtualMachineAppConfig {
145 name: config.common.name.unwrap_or_else(|| String::from("VmRunApp")),
Jiyong Park0a248432021-08-20 23:32:39 +0900146 apk: apk_fd.into(),
147 idsig: idsig_fd.into(),
Inseob Kima5a262f2021-11-17 19:41:03 +0900148 extraIdsigs: extra_idsig_fds,
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900149 instanceImage: open_parcel_file(&config.instance, true /* writable */)?.into(),
Shikha Panwar22e70452022-10-10 18:32:55 +0000150 encryptedStorageImage: storage,
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900151 payload,
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900152 debugLevel: config.debug.debug,
153 protectedVm: config.common.protected,
154 memoryMib: config.common.mem.unwrap_or(0) as i32, // 0 means use the VM default
155 cpuTopology: config.common.cpu_topology,
Nikita Ioffea0eb5ee2023-06-26 18:18:21 +0100156 customConfig: Some(custom_config),
Jooyung Han21e9b922021-06-26 04:14:16 +0900157 });
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900158 run(
159 service.as_ref(),
160 &vm_config,
161 &payload_config_str,
162 config.debug.console.as_ref().map(|p| p.as_ref()),
163 config.debug.console_in.as_ref().map(|p| p.as_ref()),
164 config.debug.log.as_ref().map(|p| p.as_ref()),
165 )
Jooyung Han21e9b922021-06-26 04:14:16 +0900166}
167
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000168fn find_empty_payload_apk_path() -> Result<PathBuf, Error> {
Cole Faust237ee3e2023-03-01 11:58:01 -0800169 const GLOB_PATTERN: &str = "/apex/com.android.virt/app/**/EmptyPayloadApp*.apk";
Nikita Ioffefc041962023-01-18 00:10:40 +0000170 let mut entries: Vec<PathBuf> =
171 glob(GLOB_PATTERN).context("failed to glob")?.filter_map(|e| e.ok()).collect();
172 if entries.len() > 1 {
173 return Err(anyhow!("Found more than one apk matching {}", GLOB_PATTERN));
174 }
175 match entries.pop() {
176 Some(path) => Ok(path),
177 None => Err(anyhow!("No apks match {}", GLOB_PATTERN)),
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000178 }
179}
180
181fn create_work_dir() -> Result<PathBuf, Error> {
182 let s: String =
183 rand::thread_rng().sample_iter(&Alphanumeric).take(17).map(char::from).collect();
184 let work_dir = PathBuf::from("/data/local/tmp/microdroid").join(s);
185 println!("creating work dir {}", work_dir.display());
186 fs::create_dir_all(&work_dir).context("failed to mkdir")?;
187 Ok(work_dir)
188}
189
190/// Run a VM with Microdroid
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900191pub fn command_run_microdroid(config: RunMicrodroidConfig) -> Result<(), Error> {
Nikita Ioffefc041962023-01-18 00:10:40 +0000192 let apk = find_empty_payload_apk_path()?;
193 println!("found path {}", apk.display());
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000194
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900195 let work_dir = config.work_dir.unwrap_or(create_work_dir()?);
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000196 let idsig = work_dir.join("apk.idsig");
197 println!("apk.idsig path: {}", idsig.display());
198 let instance_img = work_dir.join("instance.img");
199 println!("instance.img path: {}", instance_img.display());
200
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900201 let app_config = RunAppConfig {
202 common: config.common,
203 debug: config.debug,
204 microdroid: config.microdroid,
205 apk,
206 idsig,
207 instance: instance_img,
208 config_path: None,
209 payload_binary_name: Some("MicrodroidEmptyPayloadJniLib.so".to_owned()),
210 extra_idsigs: [].to_vec(),
211 };
212 command_run_app(app_config)
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000213}
214
Andrew Walbranf395b822021-05-05 10:38:59 +0000215/// Run a VM from the given configuration file.
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900216pub fn command_run(config: RunCustomVmConfig) -> Result<(), Error> {
217 let config_file = File::open(&config.config).context("Failed to open config file")?;
218 let mut vm_config =
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000219 VmConfig::load(&config_file).context("Failed to parse config file")?.to_parcelable()?;
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900220 if let Some(mem) = config.common.mem {
221 vm_config.memoryMib = mem as i32;
Jiyong Parkd63cfff2021-09-27 20:10:17 +0900222 }
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900223 if let Some(name) = config.common.name {
224 vm_config.name = name;
Seungjae Yoo62085c02022-08-12 04:44:52 +0000225 } else {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900226 vm_config.name = String::from("VmRun");
Seungjae Yoo62085c02022-08-12 04:44:52 +0000227 }
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900228 if let Some(gdb) = config.debug.gdb {
229 vm_config.gdbPort = gdb.get() as i32;
Nikita Ioffe5776f082023-02-10 21:38:26 +0000230 }
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900231 vm_config.cpuTopology = config.common.cpu_topology;
232 vm_config.taskProfiles = config.common.task_profiles;
Jooyung Han21e9b922021-06-26 04:14:16 +0900233 run(
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900234 get_service()?.as_ref(),
235 &VirtualMachineConfig::RawConfig(vm_config),
236 &format!("{:?}", &config.config),
237 config.debug.console.as_ref().map(|p| p.as_ref()),
238 config.debug.console_in.as_ref().map(|p| p.as_ref()),
239 config.debug.log.as_ref().map(|p| p.as_ref()),
Jooyung Han21e9b922021-06-26 04:14:16 +0900240 )
241}
242
Andrew Walbranf8d94112021-09-07 11:45:36 +0000243fn state_to_str(vm_state: VirtualMachineState) -> &'static str {
244 match vm_state {
245 VirtualMachineState::NOT_STARTED => "NOT_STARTED",
246 VirtualMachineState::STARTING => "STARTING",
247 VirtualMachineState::STARTED => "STARTED",
248 VirtualMachineState::READY => "READY",
249 VirtualMachineState::FINISHED => "FINISHED",
250 VirtualMachineState::DEAD => "DEAD",
251 _ => "(invalid state)",
252 }
253}
254
Jooyung Han21e9b922021-06-26 04:14:16 +0900255fn run(
Andrew Walbran616d13f2022-05-12 18:35:55 +0000256 service: &dyn IVirtualizationService,
Jooyung Han21e9b922021-06-26 04:14:16 +0900257 config: &VirtualMachineConfig,
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900258 payload_config: &str,
Jiyong Parke6fb1672023-06-26 16:45:55 +0900259 console_out_path: Option<&Path>,
260 console_in_path: Option<&Path>,
Jooyung Han21e9b922021-06-26 04:14:16 +0900261 log_path: Option<&Path>,
262) -> Result<(), Error> {
Jiyong Parke6fb1672023-06-26 16:45:55 +0900263 let console_out = if let Some(console_out_path) = console_out_path {
264 Some(File::create(console_out_path).with_context(|| {
265 format!("Failed to open console output file {:?}", console_out_path)
266 })?)
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900267 } else {
Jiyong Parke6fb1672023-06-26 16:45:55 +0900268 Some(duplicate_fd(io::stdout())?)
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900269 };
Jiyong Parke6fb1672023-06-26 16:45:55 +0900270 let console_in =
271 if let Some(console_in_path) = console_in_path {
Inseob Kim6132d812024-01-03 15:47:42 +0900272 Some(File::open(console_in_path).with_context(|| {
Jiyong Parke6fb1672023-06-26 16:45:55 +0900273 format!("Failed to open console input file {:?}", console_in_path)
274 })?)
275 } else {
276 Some(duplicate_fd(io::stdin())?)
277 };
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900278 let log = if let Some(log_path) = log_path {
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000279 Some(
Andrew Walbranbe429242021-06-28 12:22:54 +0000280 File::create(log_path)
281 .with_context(|| format!("Failed to open log file {:?}", log_path))?,
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000282 )
Andrew Walbranbe429242021-06-28 12:22:54 +0000283 } else {
Jiyong Parke6fb1672023-06-26 16:45:55 +0900284 Some(duplicate_fd(io::stdout())?)
Andrew Walbranbe429242021-06-28 12:22:54 +0000285 };
Alan Stokes0e82b502022-08-08 14:44:48 +0100286 let callback = Box::new(Callback {});
Jiyong Parke6fb1672023-06-26 16:45:55 +0900287 let vm = VmInstance::create(service, config, console_out, console_in, log, Some(callback))
Alan Stokes0e82b502022-08-08 14:44:48 +0100288 .context("Failed to create VM")?;
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000289 vm.start().context("Failed to start VM")?;
Andrew Walbranf395b822021-05-05 10:38:59 +0000290
Pierre-Clément Tosi1b691cc2023-06-28 11:40:29 +0000291 let debug_level = match config {
292 VirtualMachineConfig::AppConfig(config) => config.debugLevel,
293 _ => DebugLevel::NONE,
294 };
Andrew Walbranf8d94112021-09-07 11:45:36 +0000295 println!(
Pierre-Clément Tosi1b691cc2023-06-28 11:40:29 +0000296 "Created {} from {} with CID {}, state is {}.",
297 if debug_level == DebugLevel::FULL { "debuggable VM" } else { "VM" },
Inseob Kim7b5f65c2022-11-15 14:27:04 +0900298 payload_config,
Andrew Walbrand0ef4002022-05-16 16:14:10 +0000299 vm.cid(),
300 state_to_str(vm.state()?)
Andrew Walbranf8d94112021-09-07 11:45:36 +0000301 );
Andrew Walbranf395b822021-05-05 10:38:59 +0000302
David Brazdil2b6352f2023-01-12 11:01:17 +0000303 // Wait until the VM or VirtualizationService dies. If we just returned immediately then the
304 // IVirtualMachine Binder object would be dropped and the VM would be killed.
305 let death_reason = vm.wait_for_death();
306 println!("VM ended: {:?}", death_reason);
Andrew Walbranf395b822021-05-05 10:38:59 +0000307 Ok(())
308}
309
Inseob Kima5a262f2021-11-17 19:41:03 +0900310fn parse_extra_apk_list(apk: &Path, config_path: &str) -> Result<Vec<String>, Error> {
311 let mut archive = ZipArchive::new(File::open(apk)?)?;
312 let config_file = archive.by_name(config_path)?;
313 let config: VmPayloadConfig = serde_json::from_reader(config_file)?;
314 Ok(config.extra_apks.into_iter().map(|x| x.path).collect())
315}
316
Alan Stokes0e82b502022-08-08 14:44:48 +0100317struct Callback {}
Andrew Walbranf395b822021-05-05 10:38:59 +0000318
Alan Stokes0e82b502022-08-08 14:44:48 +0100319impl vmclient::VmCallback for Callback {
David Brazdil451cc962022-10-14 14:08:12 +0100320 fn on_payload_started(&self, _cid: i32) {
321 eprintln!("payload started");
322 }
323
Alan Stokes0e82b502022-08-08 14:44:48 +0100324 fn on_payload_ready(&self, _cid: i32) {
Inseob Kim8dbc3222021-09-01 21:50:23 +0900325 eprintln!("payload is ready");
Inseob Kim14cb8692021-08-31 21:50:39 +0900326 }
327
Alan Stokes0e82b502022-08-08 14:44:48 +0100328 fn on_payload_finished(&self, _cid: i32, exit_code: i32) {
Inseob Kim8dbc3222021-09-01 21:50:23 +0900329 eprintln!("payload finished with exit code {}", exit_code);
Inseob Kim2444af92021-08-31 01:22:50 +0900330 }
331
Alan Stokes2bead0d2022-09-05 16:58:34 +0100332 fn on_error(&self, _cid: i32, error_code: ErrorCode, message: &str) {
333 eprintln!("VM encountered an error: code={:?}, message={}", error_code, message);
Andrew Walbranf395b822021-05-05 10:38:59 +0000334 }
335}
336
Jiyong Parke6fb1672023-06-26 16:45:55 +0900337/// Safely duplicate the file descriptor.
338fn duplicate_fd<T: AsRawFd>(file: T) -> io::Result<File> {
339 let fd = file.as_raw_fd();
Andrew Walbranb58d1b42023-07-07 13:54:49 +0100340 // SAFETY: This just duplicates a file descriptor which we know to be valid, and we check for an
341 // an error.
Jiyong Parke6fb1672023-06-26 16:45:55 +0900342 let dup_fd = unsafe { libc::dup(fd) };
Andrew Walbranf395b822021-05-05 10:38:59 +0000343 if dup_fd < 0 {
344 Err(io::Error::last_os_error())
345 } else {
Andrew Walbranb58d1b42023-07-07 13:54:49 +0100346 // SAFETY: We have just duplicated the file descriptor so we own it, and `from_raw_fd` takes
347 // ownership of it.
Andrew Walbranf395b822021-05-05 10:38:59 +0000348 Ok(unsafe { File::from_raw_fd(dup_fd) })
349 }
350}