packages/syscare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
syscare/0037-all-clean-code.patch
renoseven aaca4c9c5f update to 1.2.1-10 
Signed-off-by: renoseven <dev@renoseven.net>
2024-08-16 16:44:21 +08:00

2499 lines
98 KiB
Diff
Raw Blame History

From b1a45cacb15a1259a30452c4593c07a720534f0f Mon Sep 17 00:00:00 2001
From: liuxiaobo <liuxiaobo19@huawei.com>
Date: Thu, 27 Jun 2024 14:38:45 +0800
Subject: [PATCH] all: clean code
Signed-off-by: renoseven <dev@renoseven.net>
---
syscare-abi/build.rs | 33 ++++----
syscare-abi/src/patch_info.rs | 23 +++--
syscare-build/build.rs | 33 ++++----
syscare-build/src/build_root/mod.rs | 4 +-
syscare-build/src/build_root/package_root.rs | 4 +-
syscare-build/src/build_root/patch_root.rs | 4 +-
syscare-build/src/main.rs | 6 +-
syscare-build/src/package/build_root.rs | 4 +-
syscare-build/src/package/rpm/mod.rs | 7 +-
syscare-build/src/package/rpm/spec_builder.rs | 2 +-
syscare-build/src/package/rpm/spec_file.rs | 72 ++++++++--------
syscare-build/src/patch/metadata.rs | 4 +-
syscare-common/build.rs | 33 ++++----
syscare-common/src/ffi/os_str.rs | 11 +--
syscare-common/src/fs/flock.rs | 7 +-
syscare-common/src/fs/fs_impl.rs | 83 +++++++++----------
syscare-common/src/io/select.rs | 5 +-
syscare-common/src/os/cpu.rs | 4 +-
syscare-common/src/os/process.rs | 2 +-
syscare-common/src/os/user.rs | 67 ++++++++-------
syscare-common/src/os_str/iter.rs | 10 ++-
syscare-common/src/os_str/pattern.rs | 28 ++++---
syscare-common/src/os_str/utf8.rs | 2 +-
syscare-common/src/process/child.rs | 6 +-
syscare-common/src/process/stdio.rs | 2 +-
syscare/build.rs | 33 ++++----
syscare/src/executor/patch.rs | 4 +-
syscare/src/main.rs | 14 ++--
syscare/src/rpc/remote.rs | 19 ++---
syscared/build.rs | 33 ++++----
syscared/src/main.rs | 14 ++--
syscared/src/patch/driver/kpatch/sys.rs | 4 +-
syscared/src/patch/driver/mod.rs | 32 +++----
syscared/src/patch/driver/upatch/mod.rs | 4 +-
syscared/src/patch/manager.rs | 19 ++---
syscared/src/patch/monitor.rs | 6 +-
syscared/src/patch/resolver/kpatch.rs | 16 ++--
syscared/src/patch/resolver/mod.rs | 10 +--
syscared/src/patch/resolver/upatch.rs | 12 ++-
syscared/src/rpc/skeleton_impl/patch.rs | 14 ++--
upatch-build/build.rs | 33 ++++----
upatch-build/src/args.rs | 14 ++--
upatch-build/src/build_root.rs | 4 +-
upatch-build/src/compiler.rs | 29 ++++---
upatch-build/src/dwarf/mod.rs | 21 ++---
upatch-build/src/dwarf/relocate.rs | 14 ++--
upatch-build/src/elf/header.rs | 4 -
upatch-build/src/elf/read/elfs.rs | 10 +--
upatch-build/src/elf/read/section.rs | 19 ++---
upatch-build/src/elf/read/symbol.rs | 34 ++++----
upatch-build/src/elf/write/elfs.rs | 10 ++-
upatch-build/src/elf/write/symbol.rs | 40 ++++-----
upatch-build/src/file_relation.rs | 12 +--
upatch-build/src/main.rs | 16 ++--
upatch-build/src/pattern_path.rs | 26 +++---
upatch-build/src/resolve.rs | 79 +++++++++---------
upatch-build/src/rpc/remote.rs | 19 ++---
upatchd/build.rs | 33 ++++----
upatchd/src/helper/elf_resolver.rs | 4 +-
upatchd/src/helper/ioctl.rs | 1 +
upatchd/src/main.rs | 14 ++--
61 files changed, 560 insertions(+), 566 deletions(-)
diff --git a/syscare-abi/build.rs b/syscare-abi/build.rs
index 8a86f63..ed83c43 100644
--- a/syscare-abi/build.rs
+++ b/syscare-abi/build.rs
@@ -12,26 +12,25 @@
* See the Mulan PSL v2 for more details.
*/
-use std::{env, process::Command};
+use std::{env, ffi::OsStr, os::unix::ffi::OsStrExt, process::Command};
fn rewrite_version() {
- const ENV_VERSION_NAME: &str = "BUILD_VERSION";
- const PKG_VERSION_NAME: &str = "CARGO_PKG_VERSION";
+ const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+ const ENV_VERSION: Option<&str> = option_env!("BUILD_VERSION");
- let version = env::var(ENV_VERSION_NAME).unwrap_or_else(|_| {
- let pkg_version = env::var(PKG_VERSION_NAME).expect("Failed to fetch package version");
- let git_output = Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
- .output()
- .map(|output| String::from_utf8(output.stdout).expect("Failed to fetch git version"));
-
- match git_output {
- Ok(git_version) => format!("{}-g{}", pkg_version, git_version),
- Err(_) => pkg_version,
- }
- });
-
- println!("cargo:rustc-env={}={}", PKG_VERSION_NAME, version);
+ println!(
+ "cargo:rustc-env=CARGO_PKG_VERSION={}",
+ ENV_VERSION.map(String::from).unwrap_or_else(|| {
+ Command::new("git")
+ .args(["rev-parse", "--short", "HEAD"])
+ .output()
+ .map(|output| {
+ let git_version = OsStr::from_bytes(&output.stdout).to_string_lossy();
+ format!("{}-g{}", PKG_VERSION, git_version)
+ })
+ .unwrap_or_else(|_| PKG_VERSION.to_string())
+ })
+ );
}
fn main() {
diff --git a/syscare-abi/src/patch_info.rs b/syscare-abi/src/patch_info.rs
index 08cc2c7..246f830 100644
--- a/syscare-abi/src/patch_info.rs
+++ b/syscare-abi/src/patch_info.rs
@@ -96,21 +96,18 @@ impl std::fmt::Display for PatchInfo {
writeln!(f, "patches:")?;
let last_idx = self.patches.len() - 1;
for (patch_idx, patch_file) in self.patches.iter().enumerate() {
- match patch_idx == last_idx {
- false => {
- if patch_idx >= LIST_DISPLAY_LIMIT {
- writeln!(f, "* ......")?;
- break;
- }
- writeln!(f, "* {}", patch_file.name.to_string_lossy())?
+ if patch_idx != last_idx {
+ if patch_idx >= LIST_DISPLAY_LIMIT {
+ writeln!(f, "* ......")?;
+ break;
}
- true => {
- if patch_idx >= LIST_DISPLAY_LIMIT {
- write!(f, "* ......")?;
- break;
- }
- write!(f, "* {}", patch_file.name.to_string_lossy())?
+ writeln!(f, "* {}", patch_file.name.to_string_lossy())?
+ } else {
+ if patch_idx >= LIST_DISPLAY_LIMIT {
+ write!(f, "* ......")?;
+ break;
}
+ write!(f, "* {}", patch_file.name.to_string_lossy())?
}
}
}
diff --git a/syscare-build/build.rs b/syscare-build/build.rs
index b3de093..1ca9609 100644
--- a/syscare-build/build.rs
+++ b/syscare-build/build.rs
@@ -12,26 +12,25 @@
* See the Mulan PSL v2 for more details.
*/
-use std::{env, process::Command};
+use std::{env, ffi::OsStr, os::unix::ffi::OsStrExt, process::Command};
fn rewrite_version() {
- const ENV_VERSION_NAME: &str = "BUILD_VERSION";
- const PKG_VERSION_NAME: &str = "CARGO_PKG_VERSION";
+ const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+ const ENV_VERSION: Option<&str> = option_env!("BUILD_VERSION");
- let version = env::var(ENV_VERSION_NAME).unwrap_or_else(|_| {
- let pkg_version = env::var(PKG_VERSION_NAME).expect("Failed to fetch package version");
- let git_output = Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
- .output()
- .map(|output| String::from_utf8(output.stdout).expect("Failed to fetch git version"));
-
- match git_output {
- Ok(git_version) => format!("{}-g{}", pkg_version, git_version),
- Err(_) => pkg_version,
- }
- });
-
- println!("cargo:rustc-env={}={}", PKG_VERSION_NAME, version);
+ println!(
+ "cargo:rustc-env=CARGO_PKG_VERSION={}",
+ ENV_VERSION.map(String::from).unwrap_or_else(|| {
+ Command::new("git")
+ .args(["rev-parse", "--short", "HEAD"])
+ .output()
+ .map(|output| {
+ let git_version = OsStr::from_bytes(&output.stdout).to_string_lossy();
+ format!("{}-g{}", PKG_VERSION, git_version)
+ })
+ .unwrap_or_else(|_| PKG_VERSION.to_string())
+ })
+ );
}
fn main() {
diff --git a/syscare-build/src/build_root/mod.rs b/syscare-build/src/build_root/mod.rs
index 6a12788..395fead 100644
--- a/syscare-build/src/build_root/mod.rs
+++ b/syscare-build/src/build_root/mod.rs
@@ -36,8 +36,8 @@ pub struct BuildRoot {
}
impl BuildRoot {
- pub fn new<P: AsRef<Path>>(path: P) -> Result<Self> {
- let path = path.as_ref().to_path_buf();
+ pub fn new<P: AsRef<Path>>(directory: P) -> Result<Self> {
+ let path = directory.as_ref().to_path_buf();
let package = PackageRoot::new(path.join(PACKAGE_ROOT_NAME))?;
let patch = PatchRoot::new(path.join(PATCH_ROOT_NAME))?;
let log_file = path.join(BUILD_LOG_NAME);
diff --git a/syscare-build/src/build_root/package_root.rs b/syscare-build/src/build_root/package_root.rs
index 724a42b..75ff65d 100644
--- a/syscare-build/src/build_root/package_root.rs
+++ b/syscare-build/src/build_root/package_root.rs
@@ -32,8 +32,8 @@ pub struct PackageRoot {
}
impl PackageRoot {
- pub fn new<P: AsRef<Path>>(path: P) -> Result<Self> {
- let path = path.as_ref().to_path_buf();
+ pub fn new<P: AsRef<Path>>(directory: P) -> Result<Self> {
+ let path = directory.as_ref().to_path_buf();
let source = path.join(SOURCE_DIR_NAME);
let debuginfo = path.join(DEBUGINFO_DIR_NAME);
let build_root = PackageBuildRoot::new(path.join(BUILD_ROOT_DIR_NAME))?;
diff --git a/syscare-build/src/build_root/patch_root.rs b/syscare-build/src/build_root/patch_root.rs
index af8ec6b..d493233 100644
--- a/syscare-build/src/build_root/patch_root.rs
+++ b/syscare-build/src/build_root/patch_root.rs
@@ -28,8 +28,8 @@ pub struct PatchRoot {
}
impl PatchRoot {
- pub fn new<P: AsRef<Path>>(base_dir: P) -> Result<Self> {
- let path = base_dir.as_ref().to_path_buf();
+ pub fn new<P: AsRef<Path>>(directory: P) -> Result<Self> {
+ let path = directory.as_ref().to_path_buf();
let build = path.join(BUILD_DIR_NAME);
let output = path.join(OUTPUT_DIR_NAME);
diff --git a/syscare-build/src/main.rs b/syscare-build/src/main.rs
index 1faa803..bfff3b4 100644
--- a/syscare-build/src/main.rs
+++ b/syscare-build/src/main.rs
@@ -217,10 +217,10 @@ impl SyscareBuild {
.find(|entry| entry.target_pkg.name == KERNEL_PKG_NAME);
match (pkg_entry, kernel_entry) {
- (Some(entry), Some(kernel_entry)) => Ok((
+ (Some(p_entry), Some(k_entry)) => Ok((
PatchType::KernelPatch,
- entry.clone(),
- Some(kernel_entry.clone()),
+ p_entry.clone(),
+ Some(k_entry.clone()),
)),
(None, Some(entry)) => Ok((PatchType::KernelPatch, entry.clone(), None)),
(Some(entry), None) => Ok((PatchType::UserPatch, entry.clone(), None)),
diff --git a/syscare-build/src/package/build_root.rs b/syscare-build/src/package/build_root.rs
index 6124156..d8ee182 100644
--- a/syscare-build/src/package/build_root.rs
+++ b/syscare-build/src/package/build_root.rs
@@ -36,8 +36,8 @@ pub struct PackageBuildRoot {
}
impl PackageBuildRoot {
- pub fn new<P: AsRef<Path>>(path: P) -> Result<Self> {
- let path = path.as_ref().to_path_buf();
+ pub fn new<P: AsRef<Path>>(directory: P) -> Result<Self> {
+ let path = directory.as_ref().to_path_buf();
let build = path.join(BUILD_DIR_NAME);
let buildroot = path.join(BUILDROOT_DIR_NAME);
let rpms = path.join(RPMS_DIR_NAME);
diff --git a/syscare-build/src/package/rpm/mod.rs b/syscare-build/src/package/rpm/mod.rs
index 0e9f77c..4054f67 100644
--- a/syscare-build/src/package/rpm/mod.rs
+++ b/syscare-build/src/package/rpm/mod.rs
@@ -74,9 +74,10 @@ impl Package for RpmPackage {
}
let name = pkg_info[0].to_owned();
- let kind = match pkg_info[6] == SPEC_TAG_VALUE_NONE {
- true => PackageType::SourcePackage,
- false => PackageType::BinaryPackage,
+ let kind = if pkg_info[6] == SPEC_TAG_VALUE_NONE {
+ PackageType::SourcePackage
+ } else {
+ PackageType::BinaryPackage
};
let arch = pkg_info[1].to_owned();
let epoch = pkg_info[2].to_owned();
diff --git a/syscare-build/src/package/rpm/spec_builder.rs b/syscare-build/src/package/rpm/spec_builder.rs
index 5570c34..a24954f 100644
--- a/syscare-build/src/package/rpm/spec_builder.rs
+++ b/syscare-build/src/package/rpm/spec_builder.rs
@@ -113,7 +113,7 @@ impl RpmSpecBuilder {
patch_info.name
);
let pkg_version = format!("{}-{}", patch_info.version, patch_info.release);
- let pkg_root = Path::new(PKG_INSTALL_DIR).join(&patch_info.uuid.to_string());
+ let pkg_root = Path::new(PKG_INSTALL_DIR).join(patch_info.uuid.to_string());
let mut spec = RpmSpecFile::new(
pkg_name,
diff --git a/syscare-build/src/package/rpm/spec_file.rs b/syscare-build/src/package/rpm/spec_file.rs
index 17dcbe3..bd7b647 100644
--- a/syscare-build/src/package/rpm/spec_file.rs
+++ b/syscare-build/src/package/rpm/spec_file.rs
@@ -62,33 +62,33 @@ impl RpmSpecFile {
description: String,
) -> Self {
Self {
- defines: Default::default(),
+ defines: BTreeSet::default(),
name,
version,
release,
- group: Default::default(),
+ group: Option::default(),
license,
- url: Default::default(),
+ url: Option::default(),
summary,
- build_requires: Default::default(),
- requires: Default::default(),
- conflicts: Default::default(),
- suggests: Default::default(),
- recommends: Default::default(),
+ build_requires: HashSet::default(),
+ requires: HashSet::default(),
+ conflicts: HashSet::default(),
+ suggests: HashSet::default(),
+ recommends: HashSet::default(),
description,
prep: SPEC_SCRIPT_VALUE_NONE.to_string(),
build: SPEC_SCRIPT_VALUE_NONE.to_string(),
install: SPEC_SCRIPT_VALUE_NONE.to_string(),
- check: Default::default(),
- pre: Default::default(),
- post: Default::default(),
- preun: Default::default(),
- postun: Default::default(),
- defattr: Default::default(),
- files: Default::default(),
- source: Default::default(),
- patch: Default::default(),
- change_log: Default::default(),
+ check: Option::default(),
+ pre: Option::default(),
+ post: Option::default(),
+ preun: Option::default(),
+ postun: Option::default(),
+ defattr: Option::default(),
+ files: BTreeSet::default(),
+ source: BTreeSet::default(),
+ patch: BTreeSet::default(),
+ change_log: Option::default(),
}
}
}
@@ -204,33 +204,33 @@ impl RpmSpecFile {
impl Default for RpmSpecFile {
fn default() -> Self {
Self {
- defines: Default::default(),
+ defines: BTreeSet::default(),
name: SPEC_TAG_VALUE_NONE.to_string(),
version: SPEC_TAG_VALUE_NONE.to_string(),
release: SPEC_TAG_VALUE_NONE.to_string(),
- group: Default::default(),
+ group: Option::default(),
license: SPEC_TAG_VALUE_NONE.to_string(),
- url: Default::default(),
+ url: Option::default(),
summary: SPEC_TAG_VALUE_NONE.to_string(),
- build_requires: Default::default(),
- requires: Default::default(),
- conflicts: Default::default(),
- suggests: Default::default(),
- recommends: Default::default(),
+ build_requires: HashSet::default(),
+ requires: HashSet::default(),
+ conflicts: HashSet::default(),
+ suggests: HashSet::default(),
+ recommends: HashSet::default(),
description: SPEC_TAG_VALUE_NONE.to_string(),
prep: SPEC_SCRIPT_VALUE_NONE.to_string(),
build: SPEC_SCRIPT_VALUE_NONE.to_string(),
install: SPEC_SCRIPT_VALUE_NONE.to_string(),
- check: Default::default(),
- pre: Default::default(),
- post: Default::default(),
- preun: Default::default(),
- postun: Default::default(),
- defattr: Default::default(),
- files: Default::default(),
- source: Default::default(),
- patch: Default::default(),
- change_log: Default::default(),
+ check: Option::default(),
+ pre: Option::default(),
+ post: Option::default(),
+ preun: Option::default(),
+ postun: Option::default(),
+ defattr: Option::default(),
+ files: BTreeSet::default(),
+ source: BTreeSet::default(),
+ patch: BTreeSet::default(),
+ change_log: Option::default(),
}
}
}
diff --git a/syscare-build/src/patch/metadata.rs b/syscare-build/src/patch/metadata.rs
index 918b487..0911693 100644
--- a/syscare-build/src/patch/metadata.rs
+++ b/syscare-build/src/patch/metadata.rs
@@ -35,8 +35,8 @@ pub struct PatchMetadata {
}
impl PatchMetadata {
- pub fn new<P: AsRef<Path>>(root_dir: P) -> Self {
- let root_dir = root_dir.as_ref().to_path_buf();
+ pub fn new<P: AsRef<Path>>(directory: P) -> Self {
+ let root_dir = directory.as_ref().to_path_buf();
let metadata_dir = root_dir.join(METADATA_DIR_NAME);
let package_path = root_dir.join(METADATA_PKG_NAME);
let metadata_path = metadata_dir.join(METADATA_FILE_NAME);
diff --git a/syscare-common/build.rs b/syscare-common/build.rs
index 1019998..ca9d78c 100644
--- a/syscare-common/build.rs
+++ b/syscare-common/build.rs
@@ -12,26 +12,25 @@
* See the Mulan PSL v2 for more details.
*/
-use std::{env, process::Command};
+use std::{env, ffi::OsStr, os::unix::ffi::OsStrExt, process::Command};
fn rewrite_version() {
- const ENV_VERSION_NAME: &str = "BUILD_VERSION";
- const PKG_VERSION_NAME: &str = "CARGO_PKG_VERSION";
+ const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+ const ENV_VERSION: Option<&str> = option_env!("BUILD_VERSION");
- let version = env::var(ENV_VERSION_NAME).unwrap_or_else(|_| {
- let pkg_version = env::var(PKG_VERSION_NAME).expect("Failed to fetch package version");
- let git_output = Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
- .output()
- .map(|output| String::from_utf8(output.stdout).expect("Failed to fetch git version"));
-
- match git_output {
- Ok(git_version) => format!("{}-g{}", pkg_version, git_version),
- Err(_) => pkg_version,
- }
- });
-
- println!("cargo:rustc-env={}={}", PKG_VERSION_NAME, version);
+ println!(
+ "cargo:rustc-env=CARGO_PKG_VERSION={}",
+ ENV_VERSION.map(String::from).unwrap_or_else(|| {
+ Command::new("git")
+ .args(["rev-parse", "--short", "HEAD"])
+ .output()
+ .map(|output| {
+ let git_version = OsStr::from_bytes(&output.stdout).to_string_lossy();
+ format!("{}-g{}", PKG_VERSION, git_version)
+ })
+ .unwrap_or_else(|_| PKG_VERSION.to_string())
+ })
+ );
}
fn main() {
diff --git a/syscare-common/src/ffi/os_str.rs b/syscare-common/src/ffi/os_str.rs
index 43a9adc..2db26c8 100644
--- a/syscare-common/src/ffi/os_str.rs
+++ b/syscare-common/src/ffi/os_str.rs
@@ -37,10 +37,7 @@ pub trait OsStrExt: AsRef<OsStr> {
let haystack = self.as_ref().as_bytes();
match haystack.get(index) {
- Some(&b) => {
- // This is bit magic equivalent to: b < 128 || b >= 192
- b as i8 >= -0x40
- }
+ Some(&b) => !(128..192).contains(&b),
None => index == haystack.len(),
}
}
@@ -135,14 +132,12 @@ pub trait OsStrExt: AsRef<OsStr> {
}
fn split_whitespace(&self) -> Filter<Split<SplitFn>, FilterFn> {
- self.split(char::is_whitespace as SplitFn)
+ self.split(SplitFn::from(char::is_whitespace))
.filter(|s| !s.is_empty())
}
fn split_at(&self, mid: usize) -> (&OsStr, &OsStr) {
- if !self.is_char_boundary(mid) {
- panic!("Failed to slice osstring");
- }
+ debug_assert!(self.is_char_boundary(mid), "Split out of char boundary");
let (lhs, rhs) = self.as_ref().as_bytes().split_at(mid);
(OsStr::from_bytes(lhs), OsStr::from_bytes(rhs))
diff --git a/syscare-common/src/fs/flock.rs b/syscare-common/src/fs/flock.rs
index b5639a8..bfd39d7 100644
--- a/syscare-common/src/fs/flock.rs
+++ b/syscare-common/src/fs/flock.rs
@@ -57,9 +57,10 @@ impl FileLock {
impl FileLock {
pub fn new<P: AsRef<Path>>(path: P, kind: FileLockType) -> Result<Self> {
let file_path = path.as_ref();
- let inner = match file_path.exists() {
- true => File::open(file_path),
- false => File::create(file_path),
+ let inner = if file_path.exists() {
+ File::open(file_path)
+ } else {
+ File::create(file_path)
}
.with_context(|| format!("Failed to create flock on {}", file_path.display()))?;
diff --git a/syscare-common/src/fs/fs_impl.rs b/syscare-common/src/fs/fs_impl.rs
index af0f60c..e794c98 100644
--- a/syscare-common/src/fs/fs_impl.rs
+++ b/syscare-common/src/fs/fs_impl.rs
@@ -201,42 +201,50 @@ where
P: AsRef<Path>,
S: AsRef<OsStr>,
{
- let path = path.as_ref().to_cstring()?;
- let name = name.as_ref().to_cstring()?;
+ let file_path = path.as_ref().to_cstring()?;
+ let xattr_name = name.as_ref().to_cstring()?;
/*
* SAFETY:
* This libc function is marked 'unsafe' as unchecked buffer may cause overflow.
* In our implementation, the buffer is checked properly, so that would be safe.
*/
- let ret = unsafe { nix::libc::getxattr(path.as_ptr(), name.as_ptr(), null_mut(), 0) };
+ let mut ret =
+ unsafe { nix::libc::getxattr(file_path.as_ptr(), xattr_name.as_ptr(), null_mut(), 0) };
if ret == -1 {
return Err(std::io::Error::last_os_error()).rewrite_err(format!(
"Cannot get path {} xattr {}",
- path.to_string_lossy(),
- name.to_string_lossy()
+ file_path.to_string_lossy(),
+ xattr_name.to_string_lossy()
));
}
- let mut buf = vec![0; ret as usize];
- let value = buf.as_mut_ptr() as *mut c_void;
+ let mut buf = vec![0; ret.unsigned_abs()];
+ let value_ptr = buf.as_mut_ptr().cast::<c_void>();
/*
* SAFETY:
* This libc function is marked 'unsafe' as unchecked buffer may cause overflow.
* In our implementation, the buffer is checked properly, so that would be safe.
*/
- let ret = unsafe { nix::libc::getxattr(path.as_ptr(), name.as_ptr(), value, buf.len()) };
+ ret = unsafe {
+ nix::libc::getxattr(
+ file_path.as_ptr(),
+ xattr_name.as_ptr(),
+ value_ptr,
+ buf.len(),
+ )
+ };
if ret == -1 {
return Err(std::io::Error::last_os_error()).rewrite_err(format!(
"Cannot get path {} xattr {}",
- path.to_string_lossy(),
- name.to_string_lossy(),
+ file_path.to_string_lossy(),
+ xattr_name.to_string_lossy(),
));
}
- let value = CStr::from_bytes_with_nul(&buf[0..ret as usize])
- .expect("asdf")
+ let value = CStr::from_bytes_with_nul(&buf[0..ret.unsigned_abs()])
+ .unwrap_or_default()
.to_os_string();
Ok(value)
@@ -248,10 +256,10 @@ where
S: AsRef<OsStr>,
T: AsRef<OsStr>,
{
- let path = path.as_ref().to_cstring()?;
- let name = name.as_ref().to_cstring()?;
- let value = value.as_ref().to_cstring()?;
- let size = value.to_bytes_with_nul().len();
+ let file_path = path.as_ref().to_cstring()?;
+ let xattr_name = name.as_ref().to_cstring()?;
+ let xattr_value = value.as_ref().to_cstring()?;
+ let size = xattr_value.to_bytes_with_nul().len();
/*
* SAFETY:
@@ -260,9 +268,9 @@ where
*/
let ret = unsafe {
nix::libc::setxattr(
- path.as_ptr(),
- name.as_ptr(),
- value.as_ptr() as *const c_void,
+ file_path.as_ptr(),
+ xattr_name.as_ptr(),
+ xattr_value.as_ptr().cast::<c_void>(),
size,
0,
)
@@ -270,8 +278,8 @@ where
if ret == -1 {
return Err(std::io::Error::last_os_error()).rewrite_err(format!(
"Cannot set {} xattr {}",
- path.to_string_lossy(),
- name.to_string_lossy()
+ file_path.to_string_lossy(),
+ xattr_name.to_string_lossy()
));
}
@@ -425,13 +433,10 @@ where
return false;
}
if let Some(file_name) = file_path.file_name() {
- match options.fuzz {
- false => {
- return file_name == name.as_ref();
- }
- true => {
- return file_name.contains(name.as_ref());
- }
+ if options.fuzz {
+ return file_name.contains(name.as_ref());
+ } else {
+ return file_name == name.as_ref();
}
}
false
@@ -459,13 +464,10 @@ where
return false;
}
if let Some(file_name) = file_path.file_name() {
- match options.fuzz {
- false => {
- return file_name == name.as_ref();
- }
- true => {
- return file_name.contains(name.as_ref());
- }
+ if options.fuzz {
+ return file_name.contains(name.as_ref());
+ } else {
+ return file_name == name.as_ref();
}
}
false
@@ -526,13 +528,10 @@ where
return false;
}
if let Some(file_name) = file_path.file_name() {
- match options.fuzz {
- false => {
- return file_name == name.as_ref();
- }
- true => {
- return file_name.contains(name.as_ref());
- }
+ if options.fuzz {
+ return file_name.contains(name.as_ref());
+ } else {
+ return file_name == name.as_ref();
}
}
false
diff --git a/syscare-common/src/io/select.rs b/syscare-common/src/io/select.rs
index 59e28ac..5d9400f 100644
--- a/syscare-common/src/io/select.rs
+++ b/syscare-common/src/io/select.rs
@@ -32,7 +32,7 @@ impl Select {
Self::with_timeout(fds, None)
}
- pub fn with_timeout<I, F>(fds: I, timeout: Option<Duration>) -> Self
+ pub fn with_timeout<I, F>(fds: I, duration: Option<Duration>) -> Self
where
I: IntoIterator<Item = F>,
F: AsRawFd,
@@ -44,8 +44,7 @@ impl Select {
let readfds = FdSet::new();
let writefds = FdSet::new();
let errorfds = FdSet::new();
- let timeout = timeout
- .map(|timeout| TimeVal::new(timeout.as_secs() as i64, timeout.subsec_micros() as i64));
+ let timeout = duration.map(|t| TimeVal::new(t.as_secs() as i64, t.subsec_micros() as i64));
Self {
fd_set,
diff --git a/syscare-common/src/os/cpu.rs b/syscare-common/src/os/cpu.rs
index 62baa17..ead7eee 100644
--- a/syscare-common/src/os/cpu.rs
+++ b/syscare-common/src/os/cpu.rs
@@ -30,10 +30,10 @@ pub fn arch() -> &'static OsStr {
pub fn num() -> usize {
lazy_static! {
static ref CPU_NUM: usize = {
- let cpu_set = sched_getaffinity(getpid()).expect("Failed to get thread CPU affinity");
+ let cpu_set = sched_getaffinity(getpid()).unwrap_or_default();
let mut cpu_count = 0;
for i in 0..CpuSet::count() {
- if cpu_set.is_set(i).expect("Failed to check cpu set") {
+ if cpu_set.is_set(i).unwrap_or_default() {
cpu_count += 1;
}
}
diff --git a/syscare-common/src/os/process.rs b/syscare-common/src/os/process.rs
index 2cf4ec9..d992372 100644
--- a/syscare-common/src/os/process.rs
+++ b/syscare-common/src/os/process.rs
@@ -30,7 +30,7 @@ pub fn id() -> i32 {
pub fn path() -> &'static Path {
lazy_static! {
static ref PROCESS_PATH: PathBuf =
- std::env::current_exe().expect("Read process path failed");
+ std::env::current_exe().unwrap_or_else(|_| PathBuf::from("/"));
}
PROCESS_PATH.as_path()
}
diff --git a/syscare-common/src/os/user.rs b/syscare-common/src/os/user.rs
index ebf2a14..db2e10e 100644
--- a/syscare-common/src/os/user.rs
+++ b/syscare-common/src/os/user.rs
@@ -12,71 +12,80 @@
* See the Mulan PSL v2 for more details.
*/
-use std::ffi::OsStr;
-use std::path::Path;
+use std::{
+ ffi::{CString, OsStr},
+ path::{Path, PathBuf},
+};
-use lazy_static::*;
-use nix::unistd::{getuid, User};
+use lazy_static::lazy_static;
+use nix::unistd::{getuid, Gid, Uid, User};
use crate::ffi::CStrExt;
-#[inline(always)]
fn info() -> &'static User {
lazy_static! {
- static ref USER: User = User::from_uid(getuid())
- .expect("Failed to read user info")
- .unwrap();
+ static ref USER_INFO: User = User::from_uid(getuid())
+ .unwrap_or_default()
+ .unwrap_or(User {
+ name: String::from("root"),
+ passwd: CString::default(),
+ uid: Uid::from_raw(0),
+ gid: Gid::from_raw(0),
+ gecos: CString::default(),
+ dir: PathBuf::from("/root"),
+ shell: PathBuf::from("/bin/sh"),
+ });
}
- &USER
+ &USER_INFO
}
pub fn name() -> &'static str {
- info().name.as_str()
+ self::info().name.as_str()
}
pub fn passwd() -> &'static OsStr {
- info().passwd.as_os_str()
+ self::info().passwd.as_os_str()
}
pub fn id() -> u32 {
- info().uid.as_raw()
+ self::info().uid.as_raw()
}
pub fn gid() -> u32 {
- info().gid.as_raw()
+ self::info().gid.as_raw()
}
pub fn gecos() -> &'static OsStr {
- info().gecos.as_os_str()
+ self::info().gecos.as_os_str()
}
pub fn home() -> &'static Path {
- info().dir.as_path()
+ self::info().dir.as_path()
}
pub fn shell() -> &'static Path {
- info().shell.as_path()
+ self::info().shell.as_path()
}
#[test]
fn test() {
- println!("name: {}", name());
- assert!(!name().is_empty());
+ println!("name: {}", self::name());
+ assert!(!self::name().is_empty());
- println!("passwd: {}", passwd().to_string_lossy());
- assert!(!passwd().is_empty());
+ println!("passwd: {}", self::passwd().to_string_lossy());
+ assert!(!self::passwd().is_empty());
- println!("id: {}", id());
- assert!(id() > 0);
+ println!("id: {}", self::id());
+ assert!(id() < u32::MAX);
- println!("gid: {}", gid());
- assert!(gid() > 0);
+ println!("gid: {}", self::gid());
+ assert!(gid() < u32::MAX);
- println!("gecos: {}", gecos().to_string_lossy());
+ println!("gecos: {}", self::gecos().to_string_lossy());
- println!("home: {}", home().display());
- assert!(home().exists());
+ println!("home: {}", self::home().display());
+ assert!(self::home().exists());
- println!("shell: {}", shell().display());
- assert!(shell().exists());
+ println!("shell: {}", self::shell().display());
+ assert!(self::home().exists());
}
diff --git a/syscare-common/src/os_str/iter.rs b/syscare-common/src/os_str/iter.rs
index db48771..2fa5d3b 100644
--- a/syscare-common/src/os_str/iter.rs
+++ b/syscare-common/src/os_str/iter.rs
@@ -44,7 +44,7 @@ impl Iterator for CharIndices<'_> {
}
None => {
// Unable to parse utf-8 char, fallback to byte
- let result = (self.front_idx, char_bytes[0] as char);
+ let result = (self.front_idx, char::from(char_bytes[0]));
self.front_idx += 1;
Some(result)
@@ -68,7 +68,13 @@ impl DoubleEndedIterator for CharIndices<'_> {
None => {
// Unable to parse utf-8 char, fallback to byte
self.back_idx -= 1;
- Some((self.back_idx, *char_bytes.last().unwrap() as char))
+ Some((
+ self.back_idx,
+ char_bytes
+ .last()
+ .map(|b| char::from(*b))
+ .unwrap_or_default(),
+ ))
}
}
}
diff --git a/syscare-common/src/os_str/pattern.rs b/syscare-common/src/os_str/pattern.rs
index 6e0c1f0..fe15c18 100644
--- a/syscare-common/src/os_str/pattern.rs
+++ b/syscare-common/src/os_str/pattern.rs
@@ -108,9 +108,10 @@ impl<'a> Searcher<'a> for CharLiteralSearcher<'a> {
match self.indices.next() {
Some((char_idx, c)) => {
let new_idx = char_idx + c.len_utf8();
- match self.literals.contains(&c) {
- true => SearchStep::Match(char_idx, new_idx),
- false => SearchStep::Reject(char_idx, new_idx),
+ if self.literals.contains(&c) {
+ SearchStep::Match(char_idx, new_idx)
+ } else {
+ SearchStep::Reject(char_idx, new_idx)
}
}
None => SearchStep::Done,
@@ -123,9 +124,10 @@ impl<'a> ReverseSearcher<'a> for CharLiteralSearcher<'a> {
match self.indices.next_back() {
Some((char_idx, c)) => {
let new_idx = char_idx + c.len_utf8();
- match self.literals.contains(&c) {
- true => SearchStep::Match(char_idx, new_idx),
- false => SearchStep::Reject(char_idx, new_idx),
+ if self.literals.contains(&c) {
+ SearchStep::Match(char_idx, new_idx)
+ } else {
+ SearchStep::Reject(char_idx, new_idx)
}
}
None => SearchStep::Done,
@@ -161,9 +163,10 @@ impl<'a, P: FnMut(char) -> bool> Searcher<'a> for CharPredicateSearcher<'a, P> {
match self.indices.next() {
Some((char_idx, c)) => {
let new_idx = char_idx + c.len_utf8();
- match (self.predicate)(c) {
- true => SearchStep::Match(char_idx, new_idx),
- false => SearchStep::Reject(char_idx, new_idx),
+ if (self.predicate)(c) {
+ SearchStep::Match(char_idx, new_idx)
+ } else {
+ SearchStep::Reject(char_idx, new_idx)
}
}
None => SearchStep::Done,
@@ -176,9 +179,10 @@ impl<'a, P: FnMut(char) -> bool> ReverseSearcher<'a> for CharPredicateSearcher<'
match self.indices.next_back() {
Some((char_idx, c)) => {
let new_idx = char_idx + c.len_utf8();
- match (self.predicate)(c) {
- true => SearchStep::Match(char_idx, new_idx),
- false => SearchStep::Reject(char_idx, new_idx),
+ if (self.predicate)(c) {
+ SearchStep::Match(char_idx, new_idx)
+ } else {
+ SearchStep::Reject(char_idx, new_idx)
}
}
None => SearchStep::Done,
diff --git a/syscare-common/src/os_str/utf8.rs b/syscare-common/src/os_str/utf8.rs
index 9a90bc0..8341df2 100644
--- a/syscare-common/src/os_str/utf8.rs
+++ b/syscare-common/src/os_str/utf8.rs
@@ -46,7 +46,7 @@ pub fn next_valid_char(bytes: &[u8]) -> Option<(usize, char)> {
}
let mut code = match char_width {
- 1 => return Some((1, first_byte as char)),
+ 1 => return Some((1, char::from(first_byte))),
2 => u32::from(first_byte & 0x1F) << 0x6,
3 => u32::from(first_byte & 0x0F) << 0xC,
4 => u32::from(first_byte & 0x07) << 0x12,
diff --git a/syscare-common/src/process/child.rs b/syscare-common/src/process/child.rs
index 4ce6664..0e8cf54 100644
--- a/syscare-common/src/process/child.rs
+++ b/syscare-common/src/process/child.rs
@@ -20,7 +20,7 @@ use std::{
thread::JoinHandle,
};
-use anyhow::{ensure, Context, Result};
+use anyhow::{anyhow, ensure, Context, Result};
use log::trace;
use super::{Stdio, StdioLevel};
@@ -81,7 +81,9 @@ impl Child {
pub fn wait_with_output(&mut self) -> Result<Output> {
let stdio_thread = self.capture_stdio()?;
let status = self.wait()?;
- let (stdout, stderr) = stdio_thread.join().expect("Failed to join stdio thread");
+ let (stdout, stderr) = stdio_thread
+ .join()
+ .map_err(|_| anyhow!("Failed to join stdio thread"))?;
Ok(Output {
status,
diff --git a/syscare-common/src/process/stdio.rs b/syscare-common/src/process/stdio.rs
index fca944f..450019a 100644
--- a/syscare-common/src/process/stdio.rs
+++ b/syscare-common/src/process/stdio.rs
@@ -90,7 +90,7 @@ impl Iterator for StdioReader {
match self.select.select().context("Failed to select stdio") {
Ok(result) => {
let stdio_map = &mut self.stdio_map;
- let outputs = result.into_iter().filter_map(|fd| match fd {
+ let outputs = result.into_iter().filter_map(|income| match income {
SelectResult::Readable(fd) => {
stdio_map.get_mut(&fd).and_then(|stdio| match stdio {
StdioLines::Stdout(lines) => {
diff --git a/syscare/build.rs b/syscare/build.rs
index 45eb14a..826ba22 100644
--- a/syscare/build.rs
+++ b/syscare/build.rs
@@ -12,26 +12,25 @@
* See the Mulan PSL v2 for more details.
*/
-use std::{env, process::Command};
+use std::{env, ffi::OsStr, os::unix::ffi::OsStrExt, process::Command};
fn rewrite_version() {
- const ENV_VERSION_NAME: &str = "BUILD_VERSION";
- const PKG_VERSION_NAME: &str = "CARGO_PKG_VERSION";
+ const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+ const ENV_VERSION: Option<&str> = option_env!("BUILD_VERSION");
- let version = env::var(ENV_VERSION_NAME).unwrap_or_else(|_| {
- let pkg_version = env::var(PKG_VERSION_NAME).expect("Failed to fetch package version");
- let git_output = Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
- .output()
- .map(|output| String::from_utf8(output.stdout).expect("Failed to fetch git version"));
-
- match git_output {
- Ok(git_version) => format!("{}-g{}", pkg_version, git_version),
- Err(_) => pkg_version,
- }
- });
-
- println!("cargo:rustc-env={}={}", PKG_VERSION_NAME, version);
+ println!(
+ "cargo:rustc-env=CARGO_PKG_VERSION={}",
+ ENV_VERSION.map(String::from).unwrap_or_else(|| {
+ Command::new("git")
+ .args(["rev-parse", "--short", "HEAD"])
+ .output()
+ .map(|output| {
+ let git_version = OsStr::from_bytes(&output.stdout).to_string_lossy();
+ format!("{}-g{}", PKG_VERSION, git_version)
+ })
+ .unwrap_or_else(|_| PKG_VERSION.to_string())
+ })
+ );
}
fn main() {
diff --git a/syscare/src/executor/patch.rs b/syscare/src/executor/patch.rs
index 1c4109b..98e719d 100644
--- a/syscare/src/executor/patch.rs
+++ b/syscare/src/executor/patch.rs
@@ -14,7 +14,7 @@
use std::{fmt::Write, path::PathBuf};
-use anyhow::{anyhow, Error, Result};
+use anyhow::{anyhow, Context, Error, Result};
use log::info;
use syscare_abi::{PackageInfo, PatchInfo, PatchListRecord, PatchStateRecord};
@@ -39,7 +39,7 @@ impl PatchCommandExecutor {
fn check_error(mut error_list: Vec<Error>) -> Result<()> {
match error_list.len() {
0 => Ok(()),
- 1 => Err(error_list.pop().unwrap()),
+ 1 => Err(error_list.pop().context("Invalid error")?),
_ => {
let mut err_msg = String::new();
for (idx, e) in error_list.into_iter().enumerate() {
diff --git a/syscare/src/main.rs b/syscare/src/main.rs
index dea5717..754307f 100644
--- a/syscare/src/main.rs
+++ b/syscare/src/main.rs
@@ -62,9 +62,10 @@ impl SyscareCLI {
let args = Arguments::new()?;
// Initialize logger
- let log_level_max = match args.verbose {
- false => LevelFilter::Info,
- true => LevelFilter::Trace,
+ let log_level_max = if args.verbose {
+ LevelFilter::Trace
+ } else {
+ LevelFilter::Info
};
let log_spec = LogSpecification::builder().default(log_level_max).build();
let logger = Logger::with(log_spec)
@@ -91,10 +92,9 @@ impl SyscareCLI {
debug!("Initializing command executors...");
let patch_lock_file = self.args.work_dir.join(PATCH_OP_LOCK_NAME);
- let executors = vec![
- Box::new(BuildCommandExecutor) as Box<dyn CommandExecutor>,
- Box::new(PatchCommandExecutor::new(patch_proxy, patch_lock_file))
- as Box<dyn CommandExecutor>,
+ let executors: Vec<Box<dyn CommandExecutor>> = vec![
+ Box::new(BuildCommandExecutor),
+ Box::new(PatchCommandExecutor::new(patch_proxy, patch_lock_file)),
];
let command = &self.args.command;
diff --git a/syscare/src/rpc/remote.rs b/syscare/src/rpc/remote.rs
index bd4c598..f2c9244 100644
--- a/syscare/src/rpc/remote.rs
+++ b/syscare/src/rpc/remote.rs
@@ -61,27 +61,22 @@ impl RpcRemote {
impl RpcRemote {
fn parse_error(&self, error: Error) -> anyhow::Error {
match error {
- Error::Transport(e) => {
+ Error::Transport(err) => {
anyhow!(
"Cannot connect to syscare daemon at unix://{}, {}",
self.socket.display(),
- e.source()
+ err.source()
.map(|e| e.to_string())
.unwrap_or_else(|| "Connection timeout".to_string())
)
}
- Error::Json(e) => {
- debug!("Json parse error: {:?}", e);
+ Error::Json(err) => {
+ debug!("Json parse error: {:?}", err);
anyhow!("Failed to parse response")
}
- Error::Rpc(ref e) => match e.message == "Method not found" {
- true => {
- anyhow!("Method is unimplemented")
- }
- false => {
- anyhow!("{}", e.message)
- }
- },
+ Error::Rpc(err) => {
+ anyhow!("{}", err.message)
+ }
_ => {
debug!("{:?}", error);
anyhow!("Response is invalid")
diff --git a/syscared/build.rs b/syscared/build.rs
index ea4bee7..3a07aa1 100644
--- a/syscared/build.rs
+++ b/syscared/build.rs
@@ -12,26 +12,25 @@
* See the Mulan PSL v2 for more details.
*/
-use std::{env, process::Command};
+use std::{env, ffi::OsStr, os::unix::ffi::OsStrExt, process::Command};
fn rewrite_version() {
- const ENV_VERSION_NAME: &str = "BUILD_VERSION";
- const PKG_VERSION_NAME: &str = "CARGO_PKG_VERSION";
+ const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+ const ENV_VERSION: Option<&str> = option_env!("BUILD_VERSION");
- let version = env::var(ENV_VERSION_NAME).unwrap_or_else(|_| {
- let pkg_version = env::var(PKG_VERSION_NAME).expect("Failed to fetch package version");
- let git_output = Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
- .output()
- .map(|output| String::from_utf8(output.stdout).expect("Failed to fetch git version"));
-
- match git_output {
- Ok(git_version) => format!("{}-g{}", pkg_version, git_version),
- Err(_) => pkg_version,
- }
- });
-
- println!("cargo:rustc-env={}={}", PKG_VERSION_NAME, version);
+ println!(
+ "cargo:rustc-env=CARGO_PKG_VERSION={}",
+ ENV_VERSION.map(String::from).unwrap_or_else(|| {
+ Command::new("git")
+ .args(["rev-parse", "--short", "HEAD"])
+ .output()
+ .map(|output| {
+ let git_version = OsStr::from_bytes(&output.stdout).to_string_lossy();
+ format!("{}-g{}", PKG_VERSION, git_version)
+ })
+ .unwrap_or_else(|_| PKG_VERSION.to_string())
+ })
+ );
}
fn main() {
diff --git a/syscared/src/main.rs b/syscared/src/main.rs
index f13a9f8..42e9564 100644
--- a/syscared/src/main.rs
+++ b/syscared/src/main.rs
@@ -129,9 +129,10 @@ impl Daemon {
// Initialize logger
let max_level = args.log_level;
- let stdout_level = match args.daemon {
- true => LevelFilter::Off,
- false => max_level,
+ let stdout_level = if args.daemon {
+ LevelFilter::Off
+ } else {
+ max_level
};
let log_spec = LogSpecification::builder().default(max_level).build();
let file_spec = FileSpec::default()
@@ -210,9 +211,10 @@ impl Daemon {
fs::set_permissions(
&socket_file,
- match socket_owner.as_raw() == socket_group.as_raw() {
- true => Permissions::from_mode(SOCKET_FILE_PERM_STRICT),
- false => Permissions::from_mode(SOCKET_FILE_PERM),
+ if socket_owner.as_raw() == socket_group.as_raw() {
+ Permissions::from_mode(SOCKET_FILE_PERM_STRICT)
+ } else {
+ Permissions::from_mode(SOCKET_FILE_PERM)
},
)?;
diff --git a/syscared/src/patch/driver/kpatch/sys.rs b/syscared/src/patch/driver/kpatch/sys.rs
index ea6b68f..22efa93 100644
--- a/syscared/src/patch/driver/kpatch/sys.rs
+++ b/syscared/src/patch/driver/kpatch/sys.rs
@@ -92,7 +92,7 @@ pub fn apply_patch(patch: &KernelPatch) -> Result<()> {
CString::new("")?.as_c_str(),
kmod::ModuleInitFlags::MODULE_INIT_IGNORE_VERMAGIC,
)
- .map_err(|e| anyhow!("Kpatch: {}", std::io::Error::from_raw_os_error(e as i32)))
+ .map_err(|e| anyhow!("Kpatch: {}", std::io::Error::from(e)))
}
pub fn remove_patch(patch: &KernelPatch) -> Result<()> {
@@ -105,7 +105,7 @@ pub fn remove_patch(patch: &KernelPatch) -> Result<()> {
patch.module_name.to_cstring()?.as_c_str(),
kmod::DeleteModuleFlags::O_NONBLOCK,
)
- .map_err(|e| anyhow!("Kpatch: {}", std::io::Error::from_raw_os_error(e as i32)))
+ .map_err(|e| anyhow!("Kpatch: {}", std::io::Error::from(e)))
}
pub fn active_patch(patch: &KernelPatch) -> Result<()> {
diff --git a/syscared/src/patch/driver/mod.rs b/syscared/src/patch/driver/mod.rs
index d64c2d4..7a57579 100644
--- a/syscared/src/patch/driver/mod.rs
+++ b/syscared/src/patch/driver/mod.rs
@@ -39,15 +39,15 @@ pub struct PatchDriver {
impl PatchDriver {
fn check_conflict_functions(&self, patch: &Patch) -> Result<()> {
match patch {
- Patch::KernelPatch(patch) => self.kpatch.check_conflict_functions(patch),
- Patch::UserPatch(patch) => self.upatch.check_conflict_functions(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.check_conflict_functions(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.check_conflict_functions(upatch),
}
}
fn check_override_functions(&self, patch: &Patch) -> Result<()> {
match patch {
- Patch::KernelPatch(patch) => self.kpatch.check_override_functions(patch),
- Patch::UserPatch(patch) => self.upatch.check_override_functions(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.check_override_functions(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.check_override_functions(upatch),
}
}
}
@@ -71,8 +71,8 @@ impl PatchDriver {
/// Fetch and return the patch status.
pub fn patch_status(&self, patch: &Patch) -> Result<PatchStatus> {
match patch {
- Patch::KernelPatch(patch) => self.kpatch.status(patch),
- Patch::UserPatch(patch) => self.upatch.status(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.status(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.status(upatch),
}
.with_context(|| format!("Failed to get patch '{}' status", patch))
}
@@ -84,8 +84,8 @@ impl PatchDriver {
return Ok(());
}
match patch {
- Patch::KernelPatch(patch) => self.kpatch.check(patch),
- Patch::UserPatch(patch) => self.upatch.check(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.check(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.check(upatch),
}
.with_context(|| format!("Patch '{}' is not patchable", patch))
}
@@ -104,8 +104,8 @@ impl PatchDriver {
/// After this action, the patch status would be changed to 'DEACTIVED'.
pub fn apply_patch(&mut self, patch: &Patch) -> Result<()> {
match patch {
- Patch::KernelPatch(patch) => self.kpatch.apply(patch),
- Patch::UserPatch(patch) => self.upatch.apply(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.apply(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.apply(upatch),
}
.with_context(|| format!("Failed to apply patch '{}'", patch))
}
@@ -114,8 +114,8 @@ impl PatchDriver {
/// After this action, the patch status would be changed to 'NOT-APPLIED'.
pub fn remove_patch(&mut self, patch: &Patch) -> Result<()> {
match patch {
- Patch::KernelPatch(patch) => self.kpatch.remove(patch),
- Patch::UserPatch(patch) => self.upatch.remove(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.remove(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.remove(upatch),
}
.with_context(|| format!("Failed to remove patch '{}'", patch))
}
@@ -127,8 +127,8 @@ impl PatchDriver {
self.check_conflict_functions(patch)?;
}
match patch {
- Patch::KernelPatch(patch) => self.kpatch.active(patch),
- Patch::UserPatch(patch) => self.upatch.active(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.active(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.active(upatch),
}
.with_context(|| format!("Failed to active patch '{}'", patch))
}
@@ -140,8 +140,8 @@ impl PatchDriver {
self.check_override_functions(patch)?;
}
match patch {
- Patch::KernelPatch(patch) => self.kpatch.deactive(patch),
- Patch::UserPatch(patch) => self.upatch.deactive(patch),
+ Patch::KernelPatch(kpatch) => self.kpatch.deactive(kpatch),
+ Patch::UserPatch(upatch) => self.upatch.deactive(upatch),
}
.with_context(|| format!("Failed to deactive patch '{}'", patch))
}
diff --git a/syscared/src/patch/driver/upatch/mod.rs b/syscared/src/patch/driver/upatch/mod.rs
index 66eecf5..73ef94e 100644
--- a/syscared/src/patch/driver/upatch/mod.rs
+++ b/syscared/src/patch/driver/upatch/mod.rs
@@ -227,8 +227,8 @@ impl UserPatchDriver {
Err(_) => return,
};
- let mut target_map = target_map.write();
- let patch_target = match target_map.get_mut(target_elf) {
+ let mut patch_target_map = target_map.write();
+ let patch_target = match patch_target_map.get_mut(target_elf) {
Some(target) => target,
None => return,
};
diff --git a/syscared/src/patch/manager.rs b/syscared/src/patch/manager.rs
index f633567..d156e4a 100644
--- a/syscared/src/patch/manager.rs
+++ b/syscared/src/patch/manager.rs
@@ -246,12 +246,11 @@ impl PatchManager {
debug!("Reading patch status...");
let status_file = &self.patch_status_file;
- let status_map: HashMap<Uuid, PatchStatus> = match status_file.exists() {
- true => serde::deserialize(status_file).context("Failed to read patch status")?,
- false => {
- warn!("Cannot find patch status file");
- return Ok(());
- }
+ let status_map: HashMap<Uuid, PatchStatus> = if status_file.exists() {
+ serde::deserialize(status_file).context("Failed to read patch status")?
+ } else {
+ warn!("Cannot find patch status file");
+ return Ok(());
};
/*
@@ -301,7 +300,7 @@ impl PatchManager {
pub fn rescan_patches(&mut self) -> Result<()> {
self.patch_map = Self::scan_patches(&self.patch_install_dir)?;
- let status_keys = self.status_map.keys().cloned().collect::<Vec<_>>();
+ let status_keys = self.status_map.keys().copied().collect::<Vec<_>>();
for patch_uuid in status_keys {
if !self.patch_map.contains_key(&patch_uuid) {
trace!("Patch '{}' was removed, remove its status", patch_uuid);
@@ -362,9 +361,9 @@ impl PatchManager {
let mut patch_map = IndexMap::new();
info!("Scanning patches from {}...", directory.as_ref().display());
- for patch_root in fs::list_dirs(directory, TRAVERSE_OPTION)? {
- let resolve_result = PatchResolver::resolve_patch(&patch_root)
- .with_context(|| format!("Failed to resolve patch from {}", patch_root.display()));
+ for patch_dir in fs::list_dirs(directory, TRAVERSE_OPTION)? {
+ let resolve_result = PatchResolver::resolve_patch(&patch_dir)
+ .with_context(|| format!("Failed to resolve patch from {}", patch_dir.display()));
match resolve_result {
Ok(patches) => {
for patch in patches {
diff --git a/syscared/src/patch/monitor.rs b/syscared/src/patch/monitor.rs
index 1798781..c793600 100644
--- a/syscared/src/patch/monitor.rs
+++ b/syscared/src/patch/monitor.rs
@@ -44,13 +44,13 @@ impl PatchMonitor {
patch_root: P,
patch_manager: Arc<RwLock<PatchManager>>,
) -> Result<Self> {
- let patch_root = patch_root.as_ref().join(PATCH_INSTALL_DIR);
+ let patch_install_dir = patch_root.as_ref().join(PATCH_INSTALL_DIR);
let inotify = Arc::new(Mutex::new(Some({
let mut inotify = Inotify::init().context("Failed to initialize inotify")?;
inotify
.add_watch(
- &patch_root,
+ &patch_install_dir,
WatchMask::CREATE | WatchMask::DELETE | WatchMask::ONLYDIR,
)
.context("Failed to monitor patch directory")?;
@@ -59,7 +59,7 @@ impl PatchMonitor {
})));
let monitor_thread = MonitorThread {
- patch_root,
+ patch_root: patch_install_dir,
inotify: inotify.clone(),
patch_manager,
}
diff --git a/syscared/src/patch/resolver/kpatch.rs b/syscared/src/patch/resolver/kpatch.rs
index 524482e..7946c42 100644
--- a/syscared/src/patch/resolver/kpatch.rs
+++ b/syscared/src/patch/resolver/kpatch.rs
@@ -100,8 +100,6 @@ mod ffi {
}
}
-use ffi::*;
-
const KPATCH_FUNCS_SECTION: &str = ".kpatch.funcs";
const KPATCH_STRINGS_SECTION: &str = ".kpatch.strings";
@@ -130,9 +128,9 @@ impl KpatchResolverImpl {
// Resolve patch functions
let patch_functions = &mut patch.functions;
- let kpatch_function_slice = object::slice_from_bytes::<KpatchFunction>(
+ let kpatch_function_slice = object::slice_from_bytes::<ffi::KpatchFunction>(
function_data,
- function_data.len() / KPATCH_FUNCTION_SIZE,
+ function_data.len() / ffi::KPATCH_FUNCTION_SIZE,
)
.map(|(f, _)| f)
.map_err(|_| anyhow!("Invalid data format"))
@@ -150,13 +148,13 @@ impl KpatchResolverImpl {
}
// Relocate patch functions
- for relocation in KpatchRelocationIterator::new(function_section.relocations()) {
+ for relocation in ffi::KpatchRelocationIterator::new(function_section.relocations()) {
let (name_reloc_offset, name_reloc) = relocation.name;
let (object_reloc_offset, obj_reloc) = relocation.object;
// Relocate patch function name
- let name_index =
- (name_reloc_offset as usize - KPATCH_FUNCTION_OFFSET) / KPATCH_FUNCTION_SIZE;
+ let name_index = (name_reloc_offset as usize - ffi::KPATCH_FUNCTION_OFFSET)
+ / ffi::KPATCH_FUNCTION_SIZE;
let name_function = patch_functions
.get_mut(name_index)
.context("Failed to find patch function")?;
@@ -168,8 +166,8 @@ impl KpatchResolverImpl {
name_function.name = name_string;
// Relocate patch function object
- let object_index =
- (object_reloc_offset as usize - KPATCH_OBJECT_OFFSET) / KPATCH_FUNCTION_SIZE;
+ let object_index = (object_reloc_offset as usize - ffi::KPATCH_OBJECT_OFFSET)
+ / ffi::KPATCH_FUNCTION_SIZE;
let object_function = patch_functions
.get_mut(object_index)
.context("Failed to find patch function")?;
diff --git a/syscared/src/patch/resolver/mod.rs b/syscared/src/patch/resolver/mod.rs
index 80e26ea..7c4a504 100644
--- a/syscared/src/patch/resolver/mod.rs
+++ b/syscared/src/patch/resolver/mod.rs
@@ -38,8 +38,8 @@ pub trait PatchResolverImpl {
pub struct PatchResolver;
impl PatchResolver {
- pub fn resolve_patch<P: AsRef<Path>>(patch_root: P) -> Result<Vec<Patch>> {
- let patch_root = patch_root.as_ref();
+ pub fn resolve_patch<P: AsRef<Path>>(directory: P) -> Result<Vec<Patch>> {
+ let patch_root = directory.as_ref();
let patch_info = Arc::new(
serde::deserialize_with_magic::<PatchInfo, _, _>(
patch_root.join(PATCH_INFO_FILE_NAME),
@@ -47,9 +47,9 @@ impl PatchResolver {
)
.context("Failed to resolve patch metadata")?,
);
- let resolver = match patch_info.kind {
- PatchType::UserPatch => &UpatchResolverImpl as &dyn PatchResolverImpl,
- PatchType::KernelPatch => &KpatchResolverImpl as &dyn PatchResolverImpl,
+ let resolver: &dyn PatchResolverImpl = match patch_info.kind {
+ PatchType::UserPatch => &UpatchResolverImpl,
+ PatchType::KernelPatch => &KpatchResolverImpl,
};
let mut patch_list = Vec::with_capacity(patch_info.entities.len());
diff --git a/syscared/src/patch/resolver/upatch.rs b/syscared/src/patch/resolver/upatch.rs
index 5df11db..cb06c24 100644
--- a/syscared/src/patch/resolver/upatch.rs
+++ b/syscared/src/patch/resolver/upatch.rs
@@ -85,8 +85,6 @@ mod ffi {
}
}
-use ffi::*;
-
const UPATCH_FUNCS_SECTION: &str = ".upatch.funcs";
const UPATCH_STRINGS_SECTION: &str = ".upatch.strings";
@@ -115,9 +113,9 @@ impl UpatchResolverImpl {
// Resolve patch functions
let patch_functions = &mut patch.functions;
- let upatch_function_slice = object::slice_from_bytes::<UpatchFunction>(
+ let upatch_function_slice = object::slice_from_bytes::<ffi::UpatchFunction>(
function_data,
- function_data.len() / UPATCH_FUNCTION_SIZE,
+ function_data.len() / ffi::UPATCH_FUNCTION_SIZE,
)
.map(|(f, _)| f)
.map_err(|_| anyhow!("Invalid data format"))
@@ -134,11 +132,11 @@ impl UpatchResolverImpl {
}
// Relocate patch functions
- for relocation in UpatchRelocationIterator::new(function_section.relocations()) {
+ for relocation in ffi::UpatchRelocationIterator::new(function_section.relocations()) {
let (name_reloc_offset, name_reloc) = relocation.name;
- let name_index =
- (name_reloc_offset as usize - UPATCH_FUNCTION_OFFSET) / UPATCH_FUNCTION_SIZE;
+ let name_index = (name_reloc_offset as usize - ffi::UPATCH_FUNCTION_OFFSET)
+ / ffi::UPATCH_FUNCTION_SIZE;
let name_function = patch_functions
.get_mut(name_index)
.context("Failed to find patch function")?;
diff --git a/syscared/src/rpc/skeleton_impl/patch.rs b/syscared/src/rpc/skeleton_impl/patch.rs
index b009d46..8216428 100644
--- a/syscared/src/rpc/skeleton_impl/patch.rs
+++ b/syscared/src/rpc/skeleton_impl/patch.rs
@@ -96,9 +96,10 @@ impl PatchSkeleton for PatchSkeletonImpl {
format!("Apply patch '{}'", identifier),
self.patch_manager.clone(),
PatchManager::apply_patch,
- match force {
- false => PatchOpFlag::Normal,
- true => PatchOpFlag::Force,
+ if force {
+ PatchOpFlag::Force
+ } else {
+ PatchOpFlag::Normal
},
identifier,
)
@@ -131,9 +132,10 @@ impl PatchSkeleton for PatchSkeletonImpl {
format!("Active patch '{}'", identifier),
self.patch_manager.clone(),
PatchManager::active_patch,
- match force {
- false => PatchOpFlag::Normal,
- true => PatchOpFlag::Force,
+ if force {
+ PatchOpFlag::Force
+ } else {
+ PatchOpFlag::Normal
},
identifier,
)
diff --git a/upatch-build/build.rs b/upatch-build/build.rs
index 8cbb156..9ef3a36 100644
--- a/upatch-build/build.rs
+++ b/upatch-build/build.rs
@@ -12,26 +12,25 @@
* See the Mulan PSL v2 for more details.
*/
-use std::{env, process::Command};
+use std::{env, ffi::OsStr, os::unix::ffi::OsStrExt, process::Command};
fn rewrite_version() {
- const ENV_VERSION_NAME: &str = "BUILD_VERSION";
- const PKG_VERSION_NAME: &str = "CARGO_PKG_VERSION";
+ const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+ const ENV_VERSION: Option<&str> = option_env!("BUILD_VERSION");
- let version = env::var(ENV_VERSION_NAME).unwrap_or_else(|_| {
- let pkg_version = env::var(PKG_VERSION_NAME).expect("Failed to fetch package version");
- let git_output = Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
- .output()
- .map(|output| String::from_utf8(output.stdout).expect("Failed to fetch git version"));
-
- match git_output {
- Ok(git_version) => format!("{}-g{}", pkg_version, git_version),
- Err(_) => pkg_version,
- }
- });
-
- println!("cargo:rustc-env={}={}", PKG_VERSION_NAME, version);
+ println!(
+ "cargo:rustc-env=CARGO_PKG_VERSION={}",
+ ENV_VERSION.map(String::from).unwrap_or_else(|| {
+ Command::new("git")
+ .args(["rev-parse", "--short", "HEAD"])
+ .output()
+ .map(|output| {
+ let git_version = OsStr::from_bytes(&output.stdout).to_string_lossy();
+ format!("{}-g{}", PKG_VERSION, git_version)
+ })
+ .unwrap_or_else(|_| PKG_VERSION.to_string())
+ })
+ );
}
fn main() {
diff --git a/upatch-build/src/args.rs b/upatch-build/src/args.rs
index c3b6f48..04790c1 100644
--- a/upatch-build/src/args.rs
+++ b/upatch-build/src/args.rs
@@ -113,13 +113,15 @@ impl Arguments {
args.name.push("-");
}
- args.elf_dir = match args.elf_dir.as_os_str().is_empty() {
- false => fs::normalize(&args.elf_dir)?,
- true => args.source_dir.clone(),
+ args.elf_dir = if args.elf_dir.as_os_str().is_empty() {
+ args.source_dir.clone()
+ } else {
+ fs::normalize(&args.elf_dir)?
};
- args.object_dir = match args.object_dir.as_os_str().is_empty() {
- false => fs::normalize(&args.object_dir)?,
- true => args.source_dir.clone(),
+ args.object_dir = if args.object_dir.as_os_str().is_empty() {
+ args.source_dir.clone()
+ } else {
+ fs::normalize(&args.object_dir)?
};
for elf_path in &mut args.elf {
diff --git a/upatch-build/src/build_root.rs b/upatch-build/src/build_root.rs
index 556231d..5915bbc 100644
--- a/upatch-build/src/build_root.rs
+++ b/upatch-build/src/build_root.rs
@@ -26,8 +26,8 @@ pub struct BuildRoot {
}
impl BuildRoot {
- pub fn new<P: AsRef<Path>>(path: P) -> Result<Self> {
- let path = path.as_ref().to_path_buf();
+ pub fn new<P: AsRef<Path>>(directory: P) -> Result<Self> {
+ let path = directory.as_ref().to_path_buf();
let original_dir = path.join("original");
let patched_dir = path.join("patched");
let temp_dir = path.join("temp");
diff --git a/upatch-build/src/compiler.rs b/upatch-build/src/compiler.rs
index 7778f0b..b4866bd 100644
--- a/upatch-build/src/compiler.rs
+++ b/upatch-build/src/compiler.rs
@@ -178,23 +178,28 @@ impl Compiler {
let mut result = Vec::new();
for compiler in compilers {
- let compiler = compiler.as_ref();
- let compiler_name = compiler
+ let compiler_path = compiler.as_ref();
+ let compiler_name = compiler_path
.file_name()
.context("Failed to parse compiler name")?;
let output_dir = temp_dir.as_ref().join(compiler_name);
fs::create_dir_all(&output_dir)?;
- debug!("- Checking {}", compiler.display());
- let assembler_name =
- Self::get_component_name(compiler, ASSEMBLER_NAME).with_context(|| {
- format!("Failed to get assembler name of {}", compiler.display())
+ debug!("- Checking {}", compiler_path.display());
+ let assembler_name = Self::get_component_name(compiler_path, ASSEMBLER_NAME)
+ .with_context(|| {
+ format!(
+ "Failed to get assembler name of {}",
+ compiler_path.display()
+ )
+ })?;
+ let linker_name =
+ Self::get_component_name(compiler_path, LINKER_NAME).with_context(|| {
+ format!("Failed to get linker name of {}", compiler_path.display())
})?;
- let linker_name = Self::get_component_name(compiler, LINKER_NAME)
- .with_context(|| format!("Failed to get linker name of {}", compiler.display()))?;
- let path = compiler.to_path_buf();
+ let path = compiler_path.to_path_buf();
let assembler = which(assembler_name.trim()).with_context(|| {
format!("Cannot find assembler {}", assembler_name.to_string_lossy())
})?;
@@ -202,17 +207,17 @@ impl Compiler {
.with_context(|| format!("Cannot find linker {}", linker_name.to_string_lossy()))?;
let versions = IndexSet::new();
- let mut compiler = Self {
+ let mut instance = Self {
path,
assembler,
linker,
versions,
};
- compiler
+ instance
.fetch_versions(output_dir)
.context("Failed to fetch supported versions")?;
- result.push(compiler);
+ result.push(instance);
}
Ok(result)
diff --git a/upatch-build/src/dwarf/mod.rs b/upatch-build/src/dwarf/mod.rs
index 35f359e..6a91f7c 100644
--- a/upatch-build/src/dwarf/mod.rs
+++ b/upatch-build/src/dwarf/mod.rs
@@ -49,9 +49,9 @@ pub struct CompileUnit {
pub struct Dwarf;
impl Dwarf {
- pub fn parse<P: AsRef<Path>>(elf: P) -> Result<Vec<CompileUnit>> {
+ pub fn parse<P: AsRef<Path>>(file_path: P) -> Result<Vec<CompileUnit>> {
// use mmap here, but depend on some devices
- let elf = elf.as_ref();
+ let elf = file_path.as_ref();
let file = std::fs::File::open(elf)?;
let mmap = unsafe { memmap2::Mmap::map(&file)? };
@@ -88,6 +88,8 @@ impl Dwarf {
file: &File,
section: &Section,
) {
+ const INVALID_SECTION_NAME: &str = ".invalid";
+
for (offset64, mut relocation) in section.relocations() {
let offset = offset64 as usize;
if offset as u64 != offset64 {
@@ -104,8 +106,7 @@ impl Dwarf {
}
Err(_) => {
trace!("Relocation with invalid symbol for section {} at offset 0x{:08x}",
- section.name().unwrap(),
- offset
+ section.name().unwrap_or(INVALID_SECTION_NAME), offset
);
}
}
@@ -113,7 +114,7 @@ impl Dwarf {
if relocations.insert(offset, relocation).is_some() {
trace!(
"Multiple relocations for section {} at offset 0x{:08x}",
- section.name().unwrap(),
+ section.name().unwrap_or(INVALID_SECTION_NAME),
offset
);
}
@@ -121,7 +122,7 @@ impl Dwarf {
_ => {
trace!(
"Unsupported relocation for section {} at offset 0x{:08x}",
- section.name().unwrap(),
+ section.name().unwrap_or(INVALID_SECTION_NAME),
offset
);
}
@@ -136,12 +137,12 @@ impl Dwarf {
arena_data: &'arena Arena<Cow<'input, [u8]>>,
arena_relocations: &'arena Arena<IndexMap<usize, Relocation>>,
) -> Result<Relocate<'arena, EndianSlice<'arena, Endian>>> {
- let mut relocations = IndexMap::new();
+ let mut relocation_map = IndexMap::new();
let name = Some(id.name());
- let data = match name.and_then(|name| file.section_by_name(name)) {
+ let data = match name.and_then(|section_name| file.section_by_name(section_name)) {
Some(ref section) => {
// DWO sections never have relocations, so don't bother.
- Self::add_relocations(&mut relocations, file, section);
+ Self::add_relocations(&mut relocation_map, file, section);
section.uncompressed_data()?
}
// Use a non-zero capacity so that `ReaderOffsetId`s are unique.
@@ -150,7 +151,7 @@ impl Dwarf {
let data_ref = (*arena_data.alloc(data)).borrow();
let reader = EndianSlice::new(data_ref, endian);
let section = reader;
- let relocations = (*arena_relocations.alloc(relocations)).borrow();
+ let relocations = (*arena_relocations.alloc(relocation_map)).borrow();
Ok(Relocate {
relocations,
section,
diff --git a/upatch-build/src/dwarf/relocate.rs b/upatch-build/src/dwarf/relocate.rs
index 2a6e393..e8c7cdf 100644
--- a/upatch-build/src/dwarf/relocate.rs
+++ b/upatch-build/src/dwarf/relocate.rs
@@ -14,6 +14,7 @@
use std::borrow::Cow;
+use gimli::ReaderOffset;
use indexmap::IndexMap;
use object::Relocation;
@@ -28,10 +29,11 @@ impl<'a, R: gimli::Reader<Offset = usize>> Relocate<'a, R> {
pub fn relocate(&self, offset: usize, value: u64) -> u64 {
if let Some(relocation) = self.relocations.get(&offset) {
if relocation.kind() == object::RelocationKind::Absolute {
- return match relocation.has_implicit_addend() {
+ return if relocation.has_implicit_addend() {
// Use the explicit addend too, because it may have the symbol value.
- true => value.wrapping_add(relocation.addend() as u64),
- false => relocation.addend() as u64,
+ value.wrapping_add(relocation.addend() as u64)
+ } else {
+ relocation.addend() as u64
};
}
};
@@ -52,19 +54,19 @@ impl<'a, R: gimli::Reader<Offset = usize>> gimli::Reader for Relocate<'a, R> {
fn read_length(&mut self, format: gimli::Format) -> gimli::Result<usize> {
let offset = self.reader.offset_from(&self.section);
let value = self.reader.read_length(format)?;
- <usize as gimli::ReaderOffset>::from_u64(self.relocate(offset, value as u64))
+ gimli::ReaderOffset::from_u64(self.relocate(offset, value.into_u64()))
}
fn read_offset(&mut self, format: gimli::Format) -> gimli::Result<usize> {
let offset = self.reader.offset_from(&self.section);
let value = self.reader.read_offset(format)?;
- <usize as gimli::ReaderOffset>::from_u64(self.relocate(offset, value as u64))
+ gimli::ReaderOffset::from_u64(self.relocate(offset, value.into_u64()))
}
fn read_sized_offset(&mut self, size: u8) -> gimli::Result<usize> {
let offset = self.reader.offset_from(&self.section);
let value = self.reader.read_sized_offset(size)?;
- <usize as gimli::ReaderOffset>::from_u64(self.relocate(offset, value as u64))
+ gimli::ReaderOffset::from_u64(self.relocate(offset, value.into_u64()))
}
#[inline]
diff --git a/upatch-build/src/elf/header.rs b/upatch-build/src/elf/header.rs
index ad9f8fd..a4c4ca8 100644
--- a/upatch-build/src/elf/header.rs
+++ b/upatch-build/src/elf/header.rs
@@ -48,10 +48,6 @@ pub trait HeaderWrite: OperateWrite {
fn set_e_ident(&mut self, e_ident: u128) {
self.set(offset_of!(FileHeader64, e_ident), e_ident)
}
-
- fn set_e_shnum(&mut self, e_shnum: u16) {
- self.set(offset_of!(FileHeader64, e_shnum), e_shnum)
- }
}
#[repr(C)]
diff --git a/upatch-build/src/elf/read/elfs.rs b/upatch-build/src/elf/read/elfs.rs
index 11d57e3..52c5e6b 100644
--- a/upatch-build/src/elf/read/elfs.rs
+++ b/upatch-build/src/elf/read/elfs.rs
@@ -19,10 +19,10 @@ use anyhow::bail;
use anyhow::Result;
use memmap2::{Mmap, MmapOptions};
-use super::super::*;
-use super::Header;
-use super::SectionHeaderTable;
-use super::SymbolHeaderTable;
+use super::{
+ super::{check_elf, check_header, Endian, HeaderRead, SectionRead, SymbolHeader64, SHT_SYMTAB},
+ Header, SectionHeaderTable, SymbolHeaderTable,
+};
#[derive(Debug)]
pub struct Elf {
@@ -61,7 +61,7 @@ impl Elf {
pub fn symbols(&self) -> Result<SymbolHeaderTable> {
let sections = self.sections()?;
- for section in sections {
+ for section in sections.clone() {
if section.get_sh_type().eq(&SHT_SYMTAB) {
let offset = section.get_sh_offset() as usize;
let size_sum = section.get_sh_size() as usize;
diff --git a/upatch-build/src/elf/read/section.rs b/upatch-build/src/elf/read/section.rs
index a12c4f3..8f79c8b 100644
--- a/upatch-build/src/elf/read/section.rs
+++ b/upatch-build/src/elf/read/section.rs
@@ -44,7 +44,7 @@ impl OperateRead for SectionHeader<'_> {
}
}
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
pub struct SectionHeaderTable<'a> {
mmap: &'a Mmap,
endian: Endian,
@@ -86,16 +86,13 @@ impl<'a> Iterator for SectionHeaderTable<'a> {
type Item = SectionHeader<'a>;
fn next(&mut self) -> Option<Self::Item> {
- match self.count < self.num {
- true => {
- let offset = self.count * self.size + self.offset;
- self.count += 1;
- Some(SectionHeader::from(self.mmap, self.endian, offset))
- }
- false => {
- self.count = 0;
- None
- }
+ if self.count < self.num {
+ let offset = self.count * self.size + self.offset;
+ self.count += 1;
+ Some(SectionHeader::from(self.mmap, self.endian, offset))
+ } else {
+ self.count = 0;
+ None
}
}
}
diff --git a/upatch-build/src/elf/read/symbol.rs b/upatch-build/src/elf/read/symbol.rs
index 70f03e1..0c05cb6 100644
--- a/upatch-build/src/elf/read/symbol.rs
+++ b/upatch-build/src/elf/read/symbol.rs
@@ -99,9 +99,10 @@ impl<'a> SymbolHeaderTable<'a> {
}
pub fn reset(&mut self, n: usize) {
- match n < self.num {
- true => self.count = n,
- false => self.count = 0,
+ if n < self.num {
+ self.count = n;
+ } else {
+ self.count = 0;
}
}
}
@@ -110,21 +111,18 @@ impl<'a> Iterator for SymbolHeaderTable<'a> {
type Item = SymbolHeader<'a>;
fn next(&mut self) -> Option<Self::Item> {
- match self.count < self.num {
- true => {
- let offset = self.count * self.size + self.offset;
- self.count += 1;
- Some(SymbolHeader::from(
- self.mmap,
- self.endian,
- self.strtab,
- offset,
- ))
- }
- false => {
- self.count = 0;
- None
- }
+ if self.count < self.num {
+ let offset = self.count * self.size + self.offset;
+ self.count += 1;
+ Some(SymbolHeader::from(
+ self.mmap,
+ self.endian,
+ self.strtab,
+ offset,
+ ))
+ } else {
+ self.count = 0;
+ None
}
}
}
diff --git a/upatch-build/src/elf/write/elfs.rs b/upatch-build/src/elf/write/elfs.rs
index e41ad0f..9ce2847 100644
--- a/upatch-build/src/elf/write/elfs.rs
+++ b/upatch-build/src/elf/write/elfs.rs
@@ -15,11 +15,13 @@
use std::fs::{File, OpenOptions};
use std::path::Path;
-use anyhow::{bail, Result};
+use anyhow::{bail, Context, Result};
use memmap2::{Mmap, MmapOptions};
-use super::super::*;
-use super::{Header, SectionHeader, SymbolHeaderTable};
+use super::{
+ super::{check_elf, check_header, Endian, HeaderRead, SectionRead, SymbolHeader64, SHT_SYMTAB},
+ Header, SectionHeader, SymbolHeaderTable,
+};
#[derive(Debug)]
pub struct Elf {
@@ -88,7 +90,7 @@ impl Elf {
return Ok(SymbolHeaderTable::from(
&self.file,
self.endian,
- self.strtab.as_ref().unwrap(),
+ self.strtab.as_ref().context("Invalid strtab")?,
offset,
size,
offset + size_sum,
diff --git a/upatch-build/src/elf/write/symbol.rs b/upatch-build/src/elf/write/symbol.rs
index 5946897..0a2d08a 100644
--- a/upatch-build/src/elf/write/symbol.rs
+++ b/upatch-build/src/elf/write/symbol.rs
@@ -38,13 +38,12 @@ impl<'a> SymbolHeader<'a> {
}
pub fn get_st_name(&mut self) -> &OsStr {
- match self.name.is_empty() {
- false => <&std::ffi::OsStr>::clone(&self.name),
- true => {
- let name_offset = self.get_st_name_offset() as usize;
- self.name = self.read_to_os_string(name_offset);
- self.name
- }
+ if !self.name.is_empty() {
+ self.name
+ } else {
+ let name_offset = self.get_st_name_offset() as usize;
+ self.name = self.read_to_os_string(name_offset);
+ self.name
}
}
}
@@ -120,22 +119,19 @@ impl<'a> Iterator for SymbolHeaderTable<'a> {
fn next(&mut self) -> Option<Self::Item> {
let offset = self.count * self.size + self.start;
- match offset < self.end {
- true => {
- self.count += 1;
- let mmap = unsafe {
- MmapOptions::new()
- .offset(offset as u64)
- .len(self.size)
- .map_mut(self.file)
- .unwrap()
- };
- Some(SymbolHeader::from(mmap, self.endian, self.strtab))
- }
- false => {
- self.count = 0;
- None
+ if offset < self.end {
+ self.count += 1;
+ unsafe {
+ MmapOptions::new()
+ .offset(offset as u64)
+ .len(self.size)
+ .map_mut(self.file)
+ .ok()
+ .map(|mmap_mut| SymbolHeader::from(mmap_mut, self.endian, self.strtab))
}
+ } else {
+ self.count = 0;
+ None
}
}
}
diff --git a/upatch-build/src/file_relation.rs b/upatch-build/src/file_relation.rs
index 5a58d04..eedd7d8 100644
--- a/upatch-build/src/file_relation.rs
+++ b/upatch-build/src/file_relation.rs
@@ -60,14 +60,14 @@ impl FileRelation {
P: AsRef<Path>,
Q: AsRef<Path>,
{
- let mut binaries = binaries.into_iter();
- let mut debuginfos = debuginfos.into_iter();
+ let mut binary_iter = binaries.into_iter();
+ let mut debuginfo_iter = debuginfos.into_iter();
- while let (Some(binary), Some(debuginfo)) = (binaries.next(), debuginfos.next()) {
- let binary = Self::find_binary_file(binary)?;
- let debuginfo = debuginfo.as_ref().to_path_buf();
+ while let (Some(binary), Some(debuginfo)) = (binary_iter.next(), debuginfo_iter.next()) {
+ let binary_file = Self::find_binary_file(binary)?;
+ let debuginfo_file = debuginfo.as_ref().to_path_buf();
- self.debuginfo_map.insert(binary, debuginfo);
+ self.debuginfo_map.insert(binary_file, debuginfo_file);
}
Ok(())
diff --git a/upatch-build/src/main.rs b/upatch-build/src/main.rs
index 769cc6c..5aefd73 100644
--- a/upatch-build/src/main.rs
+++ b/upatch-build/src/main.rs
@@ -333,9 +333,10 @@ impl UpatchBuild {
let binary_name = binary
.file_name()
.with_context(|| format!("Failed to parse binary name of {}", binary.display()))?;
- let patch_name = match name.is_empty() {
- true => binary_name.to_os_string(),
- false => concat_os!(name, "-", binary_name),
+ let patch_name = if name.is_empty() {
+ binary_name.to_os_string()
+ } else {
+ concat_os!(name, "-", binary_name)
};
let output_file = build_info.output_dir.join(&patch_name);
@@ -393,11 +394,10 @@ impl UpatchBuild {
.context("Patch test failed")?;
info!("Checking debuginfo version(s)");
- match self.args.skip_compiler_check {
- false => {
- Self::check_debuginfo(&compilers, debuginfos).context("Debuginfo check failed")?;
- }
- true => warn!("Warning: Skipped compiler version check!"),
+ if self.args.skip_compiler_check {
+ warn!("Warning: Skipped compiler version check!")
+ } else {
+ Self::check_debuginfo(&compilers, debuginfos).context("Debuginfo check failed")?;
}
let mut files = FileRelation::new();
diff --git a/upatch-build/src/pattern_path.rs b/upatch-build/src/pattern_path.rs
index 4ef86e1..f468620 100644
--- a/upatch-build/src/pattern_path.rs
+++ b/upatch-build/src/pattern_path.rs
@@ -40,22 +40,18 @@ pub fn glob<P: AsRef<Path>>(path: P) -> std::io::Result<Vec<PathBuf>> {
let mut path_clone = vec![];
for p in &mut pathes {
let tmp = p.join(components[i]);
- match tmp.exists() {
- true => path_clone.push(tmp),
- false => {
- let all_pathes = match i == (components.len() - 1) {
- true => {
- fs::list_files(&p, fs::TraverseOptions { recursive: false })
- }
- false => {
- fs::list_dirs(&p, fs::TraverseOptions { recursive: false })
- }
- }?;
- for name in find_name(components[i].as_os_str(), all_pathes)? {
- path_clone.push(p.join(name));
- }
+ if tmp.exists() {
+ path_clone.push(tmp);
+ } else {
+ let all_pathes = if i == (components.len() - 1) {
+ fs::list_files(&p, fs::TraverseOptions { recursive: false })
+ } else {
+ fs::list_dirs(&p, fs::TraverseOptions { recursive: false })
+ }?;
+ for name in find_name(components[i].as_os_str(), all_pathes)? {
+ path_clone.push(p.join(name));
}
- };
+ }
}
pathes = path_clone;
}
diff --git a/upatch-build/src/resolve.rs b/upatch-build/src/resolve.rs
index 58947c0..d579901 100644
--- a/upatch-build/src/resolve.rs
+++ b/upatch-build/src/resolve.rs
@@ -17,19 +17,19 @@ use std::path::Path;
use anyhow::Result;
use log::trace;
-use crate::elf::*;
+use crate::elf::{self, HeaderRead, HeaderWrite, SymbolRead, SymbolWrite};
pub fn resolve_upatch<P, Q>(patch: Q, debuginfo: P) -> Result<()>
where
P: AsRef<Path>,
Q: AsRef<Path>,
{
- let mut patch_elf = write::Elf::parse(patch)?;
- let debuginfo_elf = read::Elf::parse(debuginfo)?;
+ let mut patch_elf = elf::write::Elf::parse(patch)?;
+ let debuginfo_elf = elf::read::Elf::parse(debuginfo)?;
let debuginfo_e_ident = debuginfo_elf.header()?.get_e_ident();
let debuginfo_e_type = debuginfo_elf.header()?.get_e_type();
- let ei_osabi = elf_ei_osabi(debuginfo_e_ident);
+ let ei_osabi = elf::elf_ei_osabi(debuginfo_e_ident);
patch_elf.header()?.set_e_ident(debuginfo_e_ident);
@@ -37,28 +37,29 @@ where
for mut symbol in &mut patch_elf.symbols()? {
/* No need to handle section symbol */
- let sym_info = symbol.get_st_info();
- if elf_st_type(sym_info) == STT_SECTION {
+ let sym_st_info = symbol.get_st_info();
+ if elf::elf_st_type(sym_st_info) == elf::STT_SECTION {
continue;
}
let sym_other = symbol.get_st_other();
- if sym_other & SYM_OTHER != 0 {
+ if sym_other & elf::SYM_OTHER != 0 {
// TODO: we can delete these symbol's section here.
- symbol.set_st_other(sym_other & !SYM_OTHER);
+ symbol.set_st_other(sym_other & !elf::SYM_OTHER);
match symbol.get_st_value() {
- 0 => symbol.set_st_shndx(SHN_UNDEF),
- _ => symbol.set_st_shndx(SHN_LIVEPATCH),
+ 0 => symbol.set_st_shndx(elf::SHN_UNDEF),
+ _ => symbol.set_st_shndx(elf::SHN_LIVEPATCH),
};
- } else if symbol.get_st_shndx() == SHN_UNDEF {
- if elf_st_bind(sym_info) == STB_LOCAL {
+ } else if symbol.get_st_shndx() == elf::SHN_UNDEF {
+ if elf::elf_st_bind(sym_st_info) == elf::STB_LOCAL {
/* only partly resolved undefined symbol could have st_value */
if symbol.get_st_value() != 0 {
- symbol.set_st_shndx(SHN_LIVEPATCH);
+ symbol.set_st_shndx(elf::SHN_LIVEPATCH);
}
} else {
__partial_resolve_patch(&mut symbol, debuginfo_syms, ei_osabi)?;
}
+ } else { /* do nothing */
}
/*
@@ -66,21 +67,20 @@ where
* Such code accesses all constant addresses through a global offset table (GOT).
* TODO: consider check PIE
*/
- let sym_info = symbol.get_st_info();
- if debuginfo_e_type == ET_DYN
- && elf_st_bind(sym_info) == STB_GLOBAL
- && elf_st_type(sym_info) == STT_OBJECT
- && symbol.get_st_shndx() == SHN_LIVEPATCH
+ if debuginfo_e_type == elf::ET_DYN
+ && elf::elf_st_bind(sym_st_info) == elf::STB_GLOBAL
+ && elf::elf_st_type(sym_st_info) == elf::STT_OBJECT
+ && symbol.get_st_shndx() == elf::SHN_LIVEPATCH
{
- symbol.set_st_shndx(SHN_UNDEF);
+ symbol.set_st_shndx(elf::SHN_UNDEF);
}
}
Ok(())
}
fn __partial_resolve_patch(
- symbol: &mut write::SymbolHeader,
- debuginfo_syms: &mut read::SymbolHeaderTable,
+ symbol: &mut elf::write::SymbolHeader,
+ debuginfo_syms: &mut elf::read::SymbolHeaderTable,
ei_osabi: u8,
) -> Result<()> {
debuginfo_syms.reset(0);
@@ -88,28 +88,29 @@ fn __partial_resolve_patch(
for debuginfo_sym in debuginfo_syms {
/* No need to handle section symbol */
let sym_info = debuginfo_sym.get_st_info();
- if elf_st_type(sym_info) == STT_SECTION {
+ if elf::elf_st_type(sym_info) == elf::STT_SECTION {
continue;
}
let debuginfo_name = debuginfo_sym.get_st_name();
- if elf_st_bind(sym_info).ne(&elf_st_bind(symbol.get_st_info()))
+ if elf::elf_st_bind(sym_info).ne(&elf::elf_st_bind(symbol.get_st_info()))
|| debuginfo_name.ne(symbol.get_st_name())
{
continue;
}
/* leave it to be handled in running time */
- if debuginfo_sym.get_st_shndx() == SHN_UNDEF {
+ if debuginfo_sym.get_st_shndx() == elf::SHN_UNDEF {
continue;
}
// symbol type is STT_IFUNC, need search st_value in .plt table in upatch.
- let is_ifunc = (ei_osabi.eq(&ELFOSABI_GNU) || ei_osabi.eq(&ELFOSABI_FREEBSD))
- && elf_st_type(sym_info).eq(&STT_IFUNC);
- symbol.set_st_shndx(match is_ifunc {
- true => SHN_UNDEF,
- false => SHN_LIVEPATCH,
+ let is_ifunc = (ei_osabi.eq(&elf::ELFOSABI_GNU) || ei_osabi.eq(&elf::ELFOSABI_FREEBSD))
+ && elf::elf_st_type(sym_info).eq(&elf::STT_IFUNC);
+ symbol.set_st_shndx(if is_ifunc {
+ elf::SHN_UNDEF
+ } else {
+ elf::SHN_LIVEPATCH
});
symbol.set_st_info(sym_info);
symbol.set_st_other(debuginfo_sym.get_st_other());
@@ -131,17 +132,17 @@ fn __partial_resolve_patch(
* then we can't match these symbols, we change these symbols to GLOBAL here.
*/
pub fn resolve_dynamic<P: AsRef<Path>>(debuginfo: P) -> Result<()> {
- let mut debuginfo_elf = write::Elf::parse(debuginfo)?;
+ let mut debuginfo_elf = elf::write::Elf::parse(debuginfo)?;
let debuginfo_header = debuginfo_elf.header()?;
- if debuginfo_header.get_e_type().ne(&ET_DYN) {
+ if debuginfo_header.get_e_type().ne(&elf::ET_DYN) {
return Ok(());
}
let mut debuginfo_symbols = debuginfo_elf.symbols()?;
for mut symbol in &mut debuginfo_symbols {
- if elf_st_type(symbol.get_st_info()).ne(&STT_FILE) {
+ if elf::elf_st_type(symbol.get_st_info()).ne(&elf::STT_FILE) {
continue;
}
@@ -154,23 +155,23 @@ pub fn resolve_dynamic<P: AsRef<Path>>(debuginfo: P) -> Result<()> {
Ok(())
}
-fn _resolve_dynamic(debuginfo_symbols: &mut write::SymbolHeaderTable) -> Result<()> {
+fn _resolve_dynamic(debuginfo_symbols: &mut elf::write::SymbolHeaderTable) -> Result<()> {
for mut symbol in debuginfo_symbols {
- if elf_st_type(symbol.get_st_info()).eq(&STT_FILE) {
+ if elf::elf_st_type(symbol.get_st_info()).eq(&elf::STT_FILE) {
break;
}
- let info = symbol.get_st_info();
- if elf_st_bind(info).ne(&STB_GLOBAL) {
+ let st_info = symbol.get_st_info();
+ if elf::elf_st_bind(st_info).ne(&elf::STB_GLOBAL) {
let symbol_name = symbol.get_st_name();
trace!(
"resolve_dynamic: set {} bind {} to 1",
symbol_name.to_string_lossy(),
- elf_st_bind(info)
+ elf::elf_st_bind(st_info)
);
- let info = elf_st_type(symbol.get_st_info()) | (STB_GLOBAL << 4);
- symbol.set_st_info(info);
+ let new_st_info = elf::elf_st_type(st_info) | (elf::STB_GLOBAL << 4);
+ symbol.set_st_info(new_st_info);
}
}
Ok(())
diff --git a/upatch-build/src/rpc/remote.rs b/upatch-build/src/rpc/remote.rs
index 9927ece..52ea6a3 100644
--- a/upatch-build/src/rpc/remote.rs
+++ b/upatch-build/src/rpc/remote.rs
@@ -54,27 +54,22 @@ impl RpcRemote {
impl RpcRemote {
fn parse_error(&self, error: Error) -> anyhow::Error {
match error {
- Error::Transport(e) => {
+ Error::Transport(err) => {
anyhow!(
"Cannot connect to upatch daemon at unix://{}, {}",
self.socket.display(),
- e.source()
+ err.source()
.map(|e| e.to_string())
.unwrap_or_else(|| "Connection timeout".to_string())
)
}
- Error::Json(e) => {
- debug!("Json parse error: {:?}", e);
+ Error::Json(err) => {
+ debug!("Json parse error: {:?}", err);
anyhow!("Failed to parse response")
}
- Error::Rpc(ref e) => match e.message == "Method not found" {
- true => {
- anyhow!("Method is unimplemented")
- }
- false => {
- anyhow!("{}", e.message)
- }
- },
+ Error::Rpc(err) => {
+ anyhow!("{}", err.message)
+ }
_ => {
debug!("{:?}", error);
anyhow!("Response is invalid")
diff --git a/upatchd/build.rs b/upatchd/build.rs
index 3809c54..6ddb941 100644
--- a/upatchd/build.rs
+++ b/upatchd/build.rs
@@ -12,26 +12,25 @@
* See the Mulan PSL v2 for more details.
*/
-use std::{env, process::Command};
+use std::{env, ffi::OsStr, os::unix::ffi::OsStrExt, process::Command};
fn rewrite_version() {
- const ENV_VERSION_NAME: &str = "BUILD_VERSION";
- const PKG_VERSION_NAME: &str = "CARGO_PKG_VERSION";
+ const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+ const ENV_VERSION: Option<&str> = option_env!("BUILD_VERSION");
- let version = env::var(ENV_VERSION_NAME).unwrap_or_else(|_| {
- let pkg_version = env::var(PKG_VERSION_NAME).expect("Failed to fetch package version");
- let git_output = Command::new("git")
- .args(["rev-parse", "--short", "HEAD"])
- .output()
- .map(|output| String::from_utf8(output.stdout).expect("Failed to fetch git version"));
-
- match git_output {
- Ok(git_version) => format!("{}-g{}", pkg_version, git_version),
- Err(_) => pkg_version,
- }
- });
-
- println!("cargo:rustc-env={}={}", PKG_VERSION_NAME, version);
+ println!(
+ "cargo:rustc-env=CARGO_PKG_VERSION={}",
+ ENV_VERSION.map(String::from).unwrap_or_else(|| {
+ Command::new("git")
+ .args(["rev-parse", "--short", "HEAD"])
+ .output()
+ .map(|output| {
+ let git_version = OsStr::from_bytes(&output.stdout).to_string_lossy();
+ format!("{}-g{}", PKG_VERSION, git_version)
+ })
+ .unwrap_or_else(|_| PKG_VERSION.to_string())
+ })
+ );
}
fn main() {
diff --git a/upatchd/src/helper/elf_resolver.rs b/upatchd/src/helper/elf_resolver.rs
index 9b62b00..c6e5e9f 100644
--- a/upatchd/src/helper/elf_resolver.rs
+++ b/upatchd/src/helper/elf_resolver.rs
@@ -44,8 +44,8 @@ impl ElfResolver<'_> {
let lines = output.stdout.lines();
for line in lines {
let words = line.split_whitespace().collect::<Vec<_>>();
- if let Some(path) = words.get(2) {
- if let Ok(path) = fs::canonicalize(path) {
+ if let Some(lib_path) = words.get(2) {
+ if let Ok(path) = fs::canonicalize(lib_path) {
paths.push(path);
}
}
diff --git a/upatchd/src/helper/ioctl.rs b/upatchd/src/helper/ioctl.rs
index 0efbab4..4002c3a 100644
--- a/upatchd/src/helper/ioctl.rs
+++ b/upatchd/src/helper/ioctl.rs
@@ -46,6 +46,7 @@ pub struct UpatchEnableRequest {
offset: u64,
}
+#[repr(C)]
pub struct UpatchRegisterRequest {
exec_path: [u8; PATH_MAX as usize],
jump_path: [u8; PATH_MAX as usize],
diff --git a/upatchd/src/main.rs b/upatchd/src/main.rs
index 8141679..f73be0e 100644
--- a/upatchd/src/main.rs
+++ b/upatchd/src/main.rs
@@ -117,9 +117,10 @@ impl Daemon {
// Initialize logger
let max_level = args.log_level;
- let stdout_level = match args.daemon {
- true => LevelFilter::Off,
- false => max_level,
+ let stdout_level = if args.daemon {
+ LevelFilter::Off
+ } else {
+ max_level
};
let log_spec = LogSpecification::builder().default(max_level).build();
let file_spec = FileSpec::default()
@@ -199,9 +200,10 @@ impl Daemon {
fs::set_permissions(
&socket_file,
- match socket_owner.as_raw() == socket_group.as_raw() {
- true => Permissions::from_mode(SOCKET_FILE_PERM_STRICT),
- false => Permissions::from_mode(SOCKET_FILE_PERM),
+ if socket_owner.as_raw() == socket_group.as_raw() {
+ Permissions::from_mode(SOCKET_FILE_PERM_STRICT)
+ } else {
+ Permissions::from_mode(SOCKET_FILE_PERM)
},
)?;
--
2.34.1
Reference in New Issue View Git Blame Copy Permalink