Merge pull request #2091 from hermit-os/to_owned

refactor: consistently use `to_owned` over `to_string` for `str`

Author: mkroening

src/drivers/fs/virtio_fs.rs

@@ -1,5 +1,6 @@
+use alloc::borrow::ToOwned;
 use alloc::boxed::Box;
-use alloc::string::{String, ToString};
+use alloc::string::String;
 use alloc::vec::Vec;
 use core::mem::MaybeUninit;
 use core::str;
@@ -242,7 +243,7 @@ impl FuseInterface for VirtioFsDriver {
 		let tag = self.dev_cfg.raw.as_ptr().tag().read();
 		let tag = str::from_utf8(&tag).unwrap();
 		let tag = tag.split('\0').next().unwrap();
-		tag.to_string()
+		tag.to_owned()
 	}
 }
 

src/env.rs

@@ -1,6 +1,7 @@
 //! Central parsing of the command-line parameters.
 
-use alloc::string::{String, ToString};
+use alloc::borrow::ToOwned;
+use alloc::string::String;
 use alloc::vec::Vec;
 use core::{ptr, str};
 
@@ -99,7 +100,7 @@ impl Default for Cli {
 		while let Some(word) = words.next() {
 			if word.as_str().starts_with("virtio_mmio.device=") {
 				let v: Vec<&str> = word.as_str().split('=').collect();
-				mmio.push(v[1].to_string());
+				mmio.push(v[1].to_owned());
 				continue;
 			}
 
@@ -135,7 +136,7 @@ impl Default for Cli {
 								error!("could not parse bootarg: {word}");
 								continue;
 							};
-							env_vars.insert(key.to_string(), value.to_string());
+							env_vars.insert(key.to_owned(), value.to_owned());
 						}
 						_ => error!("could not parse bootarg: {word}"),
 					}

src/fs/fuse.rs

@@ -16,7 +16,6 @@ use async_trait::async_trait;
 use embedded_io::{ErrorType, Read, Write};
 use fuse_abi::linux::*;
 
-use crate::alloc::string::ToString;
 #[cfg(not(feature = "pci"))]
 use crate::arch::kernel::mmio::get_filesystem_driver;
 #[cfg(feature = "pci")]
@@ -978,9 +977,9 @@ impl FuseDirectoryHandle {
 impl ObjectInterface for FuseDirectoryHandle {
 	async fn getdents(&self, buf: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
 		let path: CString = if let Some(name) = &self.name {
-			CString::new("/".to_string() + name).unwrap()
+			CString::new("/".to_owned() + name).unwrap()
 		} else {
-			CString::new("/".to_string()).unwrap()
+			CString::new("/").unwrap()
 		};
 
 		debug!("FUSE opendir: {path:#?}");
@@ -1214,7 +1213,7 @@ impl VfsNode for FuseDirectory {
 				)
 			};
 			entries.push(DirectoryEntry::new(unsafe {
-				core::str::from_utf8_unchecked(name).to_string()
+				core::str::from_utf8_unchecked(name).to_owned()
 			}));
 		}
 
@@ -1461,7 +1460,7 @@ pub(crate) fn init() {
 						dirent.namelen.try_into().unwrap(),
 					)
 				};
-				entries.push(unsafe { core::str::from_utf8_unchecked(name).to_string() });
+				entries.push(unsafe { core::str::from_utf8_unchecked(name).to_owned() });
 			}
 
 			let (cmd, rsp_payload_len) = ops::Release::create(fuse_nid, fuse_fh);
@@ -1481,7 +1480,7 @@ pub(crate) fn init() {
 			);
 
 			for i in entries {
-				let i_cstr = CString::new(i.clone()).unwrap();
+				let i_cstr = CString::new(i.as_str()).unwrap();
 				let (cmd, rsp_payload_len) = ops::Lookup::create(i_cstr);
 				let rsp = get_filesystem_driver()
 					.unwrap()

src/fs/mod.rs

@@ -3,8 +3,9 @@ pub(crate) mod fuse;
 mod mem;
 mod uhyve;
 
+use alloc::borrow::ToOwned;
 use alloc::boxed::Box;
-use alloc::string::{String, ToString};
+use alloc::string::String;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::ops::BitAnd;
@@ -360,7 +361,7 @@ pub(crate) fn init() {
 	}
 
 	let mut cwd = WORKING_DIRECTORY.lock();
-	*cwd = Some("/tmp".to_string());
+	*cwd = Some("/tmp".to_owned());
 	drop(cwd);
 
 	#[cfg(all(feature = "fuse", feature = "pci"))]
@@ -501,7 +502,7 @@ pub fn set_cwd(cwd: &str) -> io::Result<()> {
 
 	let mut working_dir = WORKING_DIRECTORY.lock();
 	if cwd.starts_with("/") {
-		*working_dir = Some(cwd.to_string());
+		*working_dir = Some(cwd.to_owned());
 	} else {
 		let Some(working_dir) = working_dir.as_mut() else {
 			return Err(Errno::Badf);
@@ -589,7 +590,7 @@ impl File {
 
 		Ok(File {
 			fd,
-			path: path.to_string(),
+			path: path.to_owned(),
 		})
 	}
 
@@ -603,7 +604,7 @@ impl File {
 
 		Ok(File {
 			fd,
-			path: path.to_string(),
+			path: path.to_owned(),
 		})
 	}
 

src/fs/uhyve.rs

@@ -1,7 +1,7 @@
 use alloc::borrow::ToOwned;
 use alloc::boxed::Box;
 use alloc::ffi::CString;
-use alloc::string::{String, ToString};
+use alloc::string::String;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 
@@ -264,7 +264,7 @@ pub(crate) fn init() {
 		}
 	} else {
 		// No FDT -> Uhyve legacy mounting (to /root)
-		let mount_point = hermit_var_or!("UHYVE_MOUNT", "/root").to_string();
+		let mount_point = hermit_var_or!("UHYVE_MOUNT", "/root").to_owned();
 		info!("Mounting uhyve filesystem at {mount_point}");
 		fs::FILESYSTEM
 			.get()

xtask/src/cargo_build.rs

@@ -25,21 +25,21 @@ impl CargoBuild {
 		args.extend(
 			self.no_default_features_args()
 				.iter()
-				.map(|s| s.to_string()),
+				.map(|&s| s.to_owned()),
 		);
-		args.extend(self.features_args().map(|s| s.to_string()));
-		args.extend(self.release_args().iter().map(|s| s.to_string()));
+		args.extend(self.features_args().map(|s| s.to_owned()));
+		args.extend(self.release_args().iter().map(|&s| s.to_owned()));
 		if let Some(profile) = &self.artifact.profile {
-			args.push("--profile".to_string());
-			args.push(profile.to_string());
+			args.push("--profile".to_owned());
+			args.push(profile.to_owned());
 		}
 		args
 	}
 
 	pub fn target_dir_args(&self) -> Vec<String> {
 		if self.artifact.target_dir.is_some() {
 			vec![
-				"--target-dir".to_string(),
+				"--target-dir".to_owned(),
 				self.artifact
 					.target_dir()
 					.into_os_string()

xtask/src/ci/firecracker.rs

@@ -28,7 +28,7 @@ impl Firecracker {
 		let config_path = Path::new("firecracker_vm_config.json");
 		sh.write_file(config_path, config)?;
 
-		let firecracker = env::var("FIRECRACKER").unwrap_or_else(|_| "firecracker".to_string());
+		let firecracker = env::var("FIRECRACKER").unwrap_or_else(|_| "firecracker".to_owned());
 		let program = if self.sudo {
 			"sudo"
 		} else {

xtask/src/ci/qemu.rs

@@ -111,7 +111,7 @@ impl Qemu {
 			.args(self.machine_args(arch))
 			.args(self.cpu_args(arch))
 			.args(&["-smp", &effective_smp.to_string()])
-			.args(&["-m".to_string(), format!("{memory}M")])
+			.args(&["-m".to_owned(), format!("{memory}M")])
 			.args(&["-global", "virtio-mmio.force-legacy=off"])
 			.args(self.device_args(memory))
 			.args(self.cmdline_args(image_name));
@@ -199,22 +199,22 @@ impl Qemu {
 			let vars = prebuilt.get_file(Arch::X64, FileType::Vars);
 
 			vec![
-				"-drive".to_string(),
+				"-drive".to_owned(),
 				format!("if=pflash,format=raw,readonly=on,file={}", code.display()),
-				"-drive".to_string(),
+				"-drive".to_owned(),
 				format!("if=pflash,format=raw,readonly=on,file={}", vars.display()),
-				"-drive".to_string(),
-				"format=raw,file=fat:rw:target/esp".to_string(),
+				"-drive".to_owned(),
+				"format=raw,file=fat:rw:target/esp".to_owned(),
 			]
 		} else {
-			let mut image_args = vec!["-kernel".to_string(), loader];
+			let mut image_args = vec!["-kernel".to_owned(), loader];
 			match arch {
 				Arch::X86_64 | Arch::Riscv64 => {
-					image_args.push("-initrd".to_string());
-					image_args.push(image.to_str().unwrap().to_string());
+					image_args.push("-initrd".to_owned());
+					image_args.push(image.to_str().unwrap().to_owned());
 				}
 				Arch::Aarch64 | Arch::Aarch64Be => {
-					image_args.push("-device".to_string());
+					image_args.push("-device".to_owned());
 					image_args.push(format!(
 						"guest-loader,addr=0x48000000,initrd={}",
 						image.display()
@@ -230,18 +230,18 @@ impl Qemu {
 	fn machine_args(&self, arch: Arch) -> Vec<String> {
 		if self.microvm {
 			vec![
-				"-M".to_string(),
+				"-M".to_owned(),
 				"microvm,x-option-roms=off,pit=off,pic=off,rtc=on,auto-kernel-cmdline=off,acpi=off"
-					.to_string(),
-				"-global".to_string(),
-				"virtio-mmio.force-legacy=off".to_string(),
-				"-nodefaults".to_string(),
-				"-no-user-config".to_string(),
+					.to_owned(),
+				"-global".to_owned(),
+				"virtio-mmio.force-legacy=off".to_owned(),
+				"-nodefaults".to_owned(),
+				"-no-user-config".to_owned(),
 			]
 		} else if self.pci_e {
 			vec!["-machine".to_owned(), "q35".to_owned()]
 		} else if arch == Arch::Aarch64 || arch == Arch::Aarch64Be {
-			vec!["-machine".to_string(), "virt,gic-version=3".to_string()]
+			vec!["-machine".to_owned(), "virt,gic-version=3".to_owned()]
 		} else if arch == Arch::Riscv64 {
 			// CadenceGem requires sifive_u
 			let machine = if self.devices.contains(&Device::CadenceGem) {
@@ -250,10 +250,10 @@ impl Qemu {
 				"virt"
 			};
 			vec![
-				"-machine".to_string(),
-				machine.to_string(),
-				"-bios".to_string(),
-				"opensbi-1.7-rv-bin/share/opensbi/lp64/generic/firmware/fw_jump.bin".to_string(),
+				"-machine".to_owned(),
+				machine.to_owned(),
+				"-bios".to_owned(),
+				"opensbi-1.7-rv-bin/share/opensbi/lp64/generic/firmware/fw_jump.bin".to_owned(),
 			]
 		} else {
 			vec![]
@@ -266,27 +266,27 @@ impl Qemu {
 				let mut cpu_args = if self.accel {
 					if cfg!(target_os = "linux") {
 						vec![
-							"-enable-kvm".to_string(),
-							"-cpu".to_string(),
-							"host".to_string(),
+							"-enable-kvm".to_owned(),
+							"-cpu".to_owned(),
+							"host".to_owned(),
 						]
 					} else {
 						todo!()
 					}
 				} else {
-					vec!["-cpu".to_string(), "Skylake-Client".to_string()]
+					vec!["-cpu".to_owned(), "Skylake-Client".to_owned()]
 				};
-				cpu_args.push("-device".to_string());
-				cpu_args.push("isa-debug-exit,iobase=0xf4,iosize=0x04".to_string());
+				cpu_args.push("-device".to_owned());
+				cpu_args.push("isa-debug-exit,iobase=0xf4,iosize=0x04".to_owned());
 				cpu_args
 			}
 			Arch::Aarch64 | Arch::Aarch64Be => {
 				let mut cpu_args = if self.accel {
 					todo!()
 				} else {
-					vec!["-cpu".to_string(), "cortex-a72".to_string()]
+					vec!["-cpu".to_owned(), "cortex-a72".to_owned()]
 				};
-				cpu_args.push("-semihosting".to_string());
+				cpu_args.push("-semihosting".to_owned());
 				cpu_args
 			}
 			Arch::Riscv64 => {
@@ -297,7 +297,7 @@ impl Qemu {
 					// possibly because it requires sifive_u as the machine.
 					vec![]
 				} else {
-					vec!["-cpu".to_string(), "rv64".to_string()]
+					vec!["-cpu".to_owned(), "rv64".to_owned()]
 				}
 			}
 		}
@@ -346,15 +346,15 @@ impl Qemu {
 			.flat_map(|device| match device {
 				Device::CadenceGem => {
 					vec![
-						"-nic".to_string(),
+						"-nic".to_owned(),
 						format!("{netdev_options},model=cadence_gem"),
 					]
 				}
 				device @ (Device::Rtl8139 | Device::VirtioNetMmio | Device::VirtioNetPci) => {
 					let mut netdev_args = vec![
-						"-netdev".to_string(),
-						netdev_options.to_string(),
-						"-device".to_string(),
+						"-netdev".to_owned(),
+						netdev_options.to_owned(),
+						"-device".to_owned(),
 					];
 
 					let mut device_arg = match device {
@@ -363,7 +363,7 @@ impl Qemu {
 						Device::Rtl8139 => "rtl8139,netdev=net0",
 						_ => unreachable!(),
 					}
-					.to_string();
+					.to_owned();
 
 					if !self.no_default_virtio_features
 						&& (device == Device::VirtioNetPci || device == Device::VirtioNetMmio)
@@ -382,18 +382,18 @@ impl Qemu {
 						""
 					};
 					vec![
-						"-chardev".to_string(),
-						"socket,id=char0,path=./vhostqemu".to_string(),
-						"-device".to_string(),
+						"-chardev".to_owned(),
+						"socket,id=char0,path=./vhostqemu".to_owned(),
+						"-device".to_owned(),
 						format!(
 							"vhost-user-fs-pci,queue-size=1024{default_virtio_features},chardev=char0,tag=root"
 						),
-						"-object".to_string(),
+						"-object".to_owned(),
 						format!(
 							"memory-backend-file,id=mem,size={memory}M,mem-path=/dev/shm,share=on"
 						),
-						"-numa".to_string(),
-						"node,memdev=mem".to_string(),
+						"-numa".to_owned(),
+						"node,memdev=mem".to_owned(),
 					]
 				}
 				device @ (Device::VirtioConsoleMmio | Device::VirtioConsolePci) => {

xtask/src/ci/rs.rs

@@ -52,7 +52,7 @@ impl Rs {
 		}
 
 		if self.smp > 1 {
-			self.cargo_build.features.push("hermit/smp".to_string());
+			self.cargo_build.features.push("hermit/smp".to_owned());
 		}
 
 		let mut cargo = crate::cargo();

xtask/src/ci/uhyve.rs

@@ -17,7 +17,7 @@ impl Uhyve {
 	pub fn run(self, image: &Path, smp: usize) -> Result<()> {
 		let sh = crate::sh()?;
 
-		let uhyve = env::var("UHYVE").unwrap_or_else(|_| "uhyve".to_string());
+		let uhyve = env::var("UHYVE").unwrap_or_else(|_| "uhyve".to_owned());
 		let program = if self.sudo { "sudo" } else { uhyve.as_str() };
 		let arg = self.sudo.then_some(uhyve.as_str());
 		let smp_arg = format!("--cpu-count={smp}");