From db1071477254830aa7e543bc41aef95b129117d9 Mon Sep 17 00:00:00 2001 From: overweight Date: Thu, 28 Dec 2023 11:12:43 +0800 Subject: [PATCH 1/3] refactor: libs basic --- core/sysmaster/Cargo.toml | 2 +- core/sysmaster/src/manager/mod.rs | 2 +- core/sysmaster/src/mount/setup.rs | 24 +- core/sysmaster/src/unit/manager.rs | 3 +- exts/devmaster/src/bin/devctl/main.rs | 2 +- exts/devmaster/src/lib/rules/exec_mgr.rs | 18 +- exts/hostname_setup/src/main.rs | 34 +- libs/basic/Cargo.toml | 4 +- libs/basic/src/{argv_util.rs => argv.rs} | 16 +- libs/basic/src/capability.rs | 358 ++++++++++-------- libs/basic/src/cargo.rs | 9 +- libs/basic/src/cmdline.rs | 183 ++++++--- libs/basic/src/condition.rs | 56 +-- libs/basic/src/{exec_util.rs => exec.rs} | 49 ++- libs/basic/src/lib.rs | 10 +- libs/basic/src/machine.rs | 8 +- .../src/{namespace_util.rs => namespace.rs} | 0 libs/basic/src/naming_scheme.rs | 15 +- libs/basic/src/{random_util.rs => random.rs} | 2 +- libs/basic/src/uuid.rs | 2 +- 20 files changed, 457 insertions(+), 340 deletions(-) rename libs/basic/src/{argv_util.rs => argv.rs} (70%) rename libs/basic/src/{exec_util.rs => exec.rs} (60%) rename libs/basic/src/{namespace_util.rs => namespace.rs} (100%) rename libs/basic/src/{random_util.rs => random.rs} (99%) diff --git a/core/sysmaster/Cargo.toml b/core/sysmaster/Cargo.toml index 30d7d95b..269ca884 100644 --- a/core/sysmaster/Cargo.toml +++ b/core/sysmaster/Cargo.toml @@ -22,7 +22,7 @@ features = [ "security", "mount", "machine", - "exec_util", + "exec", "unit_name", ] optional = false diff --git a/core/sysmaster/src/manager/mod.rs b/core/sysmaster/src/manager/mod.rs index 46228b77..e93673f2 100644 --- a/core/sysmaster/src/manager/mod.rs +++ b/core/sysmaster/src/manager/mod.rs @@ -488,7 +488,7 @@ impl Manager { fn run_generators(&self) { let paths = vec!["/usr/lib/sysmaster/system-generators"]; - if let Err(err) = basic::exec_util::execute_directories(paths) { + if let Err(err) = basic::exec::execute_directories(paths) { log::error!("run generators err: {}", err); } } diff --git a/core/sysmaster/src/mount/setup.rs b/core/sysmaster/src/mount/setup.rs index f191070f..96f60b1e 100644 --- a/core/sysmaster/src/mount/setup.rs +++ b/core/sysmaster/src/mount/setup.rs @@ -539,22 +539,17 @@ fn symlink_controller(source: String, alias: String) -> Result<()> { } fn cg_unified_wanted() -> bool { - let cg_ver = cgroup::cg_type(); - - if let Ok(v) = cg_ver { + if let Ok(v) = cgroup::cg_type() { return v == CgType::UnifiedV2; } - let ret = cmdline::proc_cmdline_get_bool("sysmaster.unified_cgroup_hierarchy"); - if let Ok(v) = ret { - return v; + if basic::cmdline::Cmdline::default().has_param("systemd.unified_cgroup_hierarchy") { + return true; } - let ret = cmdline::cmdline_get_value("cgroup_no_v1"); - if let Ok(v) = ret { - if v.is_some() && v.unwrap() == "all" { - return true; - } + let v = cmdline::Cmdline::default().get_param("cgroup_no_v1"); + if v.is_some() && v.unwrap() == "all" { + return true; } false @@ -579,10 +574,5 @@ fn cg_unifiedv1_wanted() -> bool { } } - let ret = cmdline::proc_cmdline_get_bool("sysmaster.unified_v1_controller"); - if let Ok(v) = ret { - return v; - } - - false + cmdline::Cmdline::default().has_param("systemd.unified_v1_controller") } diff --git a/core/sysmaster/src/unit/manager.rs b/core/sysmaster/src/unit/manager.rs index 3941d46f..02e2062d 100644 --- a/core/sysmaster/src/unit/manager.rs +++ b/core/sysmaster/src/unit/manager.rs @@ -34,7 +34,6 @@ use crate::manager::pre_install::{Install, PresetMode}; use crate::manager::State; use crate::unit::data::{DataManager, UnitState}; use crate::utils::table::{TableOp, TableSubscribe}; -use basic::cmdline::get_process_cmdline; use basic::fs_util::LookupPaths; use basic::show_table::{CellColor, ShowTable}; use basic::{machine, process, rlimit, signal_util}; @@ -942,7 +941,7 @@ impl UnitManager { } res += &pid.to_string(); res += " "; - res += get_process_cmdline(pid).as_str(); + res += &basic::cmdline::Cmdline::new(*pid).get_cmdline(); } res } diff --git a/exts/devmaster/src/bin/devctl/main.rs b/exts/devmaster/src/bin/devctl/main.rs index a8a821f1..a87f5bf7 100644 --- a/exts/devmaster/src/bin/devctl/main.rs +++ b/exts/devmaster/src/bin/devctl/main.rs @@ -15,7 +15,7 @@ #![allow(deprecated)] mod daemon; mod subcmds; -use basic::argv_util::invoked_as; +use basic::argv::invoked_as; use clap::Parser; use daemon::run_daemon; use libdevmaster::config::devmaster_conf::DEFAULT_CONFIG; diff --git a/exts/devmaster/src/lib/rules/exec_mgr.rs b/exts/devmaster/src/lib/rules/exec_mgr.rs index 3f6cd143..ba9015e9 100644 --- a/exts/devmaster/src/lib/rules/exec_mgr.rs +++ b/exts/devmaster/src/lib/rules/exec_mgr.rs @@ -26,10 +26,7 @@ use crate::{ rules::*, utils::{commons::*, spawn::*}, }; -use basic::{ - cmdline::cmdline_get_item, fs_util::write_string_file, naming_scheme::*, parse::parse_mode, - unistd::*, -}; +use basic::{fs_util::write_string_file, naming_scheme::*, parse::parse_mode, unistd::*}; use device::{Device, DeviceAction}; use fnmatch_sys::fnmatch; use libc::{gid_t, mode_t, uid_t}; @@ -905,17 +902,8 @@ impl ExecuteManager { Ok(token.read().unwrap().as_ref().unwrap().op == OperatorType::Match) } MatchImportCmdline => { - let s = cmdline_get_item(&token_value).map_err(|e| { - log_rule_token!(error, token.read().unwrap().as_ref().unwrap(), e); - Error::RulesExecuteError { - msg: format!( - "Apply '{}' failed: {}", - token.read().unwrap().as_ref().unwrap(), - e - ), - errno: Errno::EINVAL, - } - })?; + let cmdline = basic::cmdline::Cmdline::default(); + let s = cmdline.get_param(&token_value); if s.is_none() { return Ok(token.read().unwrap().as_ref().unwrap().op == OperatorType::Nomatch); diff --git a/exts/hostname_setup/src/main.rs b/exts/hostname_setup/src/main.rs index 80693a4c..fa2fb8e1 100644 --- a/exts/hostname_setup/src/main.rs +++ b/exts/hostname_setup/src/main.rs @@ -38,32 +38,30 @@ impl Hostname { } fn from_cmdline() -> Option { - let systemd_hostname = match cmdline::cmdline_get_value(SYSTEMD_HOSTNAME_KEY) { - Err(e) => { + let mut hostname = match cmdline::Cmdline::default().get_param(SYSTEMD_HOSTNAME_KEY) { + None => { log::warn!( - "Failed to get proc cmdline by key {}: {}", - SYSTEMD_HOSTNAME_KEY, - e + "Failed to get proc cmdline by key {}.", + SYSTEMD_HOSTNAME_KEY ); - None + "".to_string() } - Ok(hostname) => hostname, + Some(h) => h, }; - systemd_hostname.map_or_else( - || match cmdline::cmdline_get_value(SYSMASTER_HOSTNAME_KEY) { - Err(e) => { + if hostname.is_empty() { + hostname = match cmdline::Cmdline::default().get_param(SYSMASTER_HOSTNAME_KEY) { + None => { log::warn!( - "Failed to get proc cmdline by key {}: {}", - SYSMASTER_HOSTNAME_KEY, - e + "Failed to get proc cmdline by key {}.", + SYSMASTER_HOSTNAME_KEY ); - None + "".to_string() } - Ok(hostname) => hostname.and_then(|hostname| Hostname::from_string(&hostname)), - }, - |hostname| Hostname::from_string(&hostname), - ) + Some(h) => h, + }; + } + Hostname::from_string(&hostname) } fn from_etc_hostname() -> Option { diff --git a/libs/basic/Cargo.toml b/libs/basic/Cargo.toml index e2faa0d9..a719afae 100644 --- a/libs/basic/Cargo.toml +++ b/libs/basic/Cargo.toml @@ -63,7 +63,7 @@ full = [ "unit_name", "strbuf", "argv", - "exec_util", + "exec", "random", "id128", "namespace", @@ -89,7 +89,7 @@ argv = [] config = [] cpu = [] disk = [] -exec_util = [] +exec = [] fd = ["stat", "nix/ioctl", "nix/socket"] file = [] fs = ["pathdiff", "rand", "nix/fs", "nix/user"] diff --git a/libs/basic/src/argv_util.rs b/libs/basic/src/argv.rs similarity index 70% rename from libs/basic/src/argv_util.rs rename to libs/basic/src/argv.rs index 69b2d30f..6bb51f23 100644 --- a/libs/basic/src/argv_util.rs +++ b/libs/basic/src/argv.rs @@ -10,11 +10,21 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -//! - +//! Arguments functions use std::path::Path; +/// The function checks if the first argument in the command line contains a specific token. +/// +/// Arguments: +/// +/// * `argv`: A vector of strings representing command line arguments passed to the program. The first +/// element of the vector is expected to be the name of the executable file. +/// * `token`: The `token` parameter is a string that represents a token or keyword that we want to +/// check for in the file name. +/// +/// Returns: /// +/// a boolean value. pub fn invoked_as(argv: Vec, token: &str) -> bool { if argv.is_empty() || token.is_empty() { return false; @@ -31,7 +41,7 @@ pub fn invoked_as(argv: Vec, token: &str) -> bool { #[cfg(test)] mod tests { - use crate::argv_util::invoked_as; + use crate::argv::invoked_as; #[test] fn test_invoked_as() { let argv = vec!["/a/bb////aabbcc".to_string()]; diff --git a/libs/basic/src/capability.rs b/libs/basic/src/capability.rs index ad25ce9d..e1e6ee06 100644 --- a/libs/basic/src/capability.rs +++ b/libs/basic/src/capability.rs @@ -10,141 +10,141 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -//! +//! Capability functions /// from #[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)] #[allow(non_camel_case_types)] #[repr(u8)] pub enum Capability { - /// `CAP_CHOWN` (from POSIX) - CAP_CHOWN = 0, - /// `CAP_DAC_OVERRIDE` (from POSIX) - CAP_DAC_OVERRIDE = 1, - /// `CAP_DAC_READ_SEARCH` (from POSIX) - CAP_DAC_READ_SEARCH = 2, - /// `CAP_FOWNER` (from POSIX) - CAP_FOWNER = 3, - /// `CAP_FSETID` (from POSIX) - CAP_FSETID = 4, - /// `CAP_KILL` (from POSIX) - CAP_KILL = 5, - /// `CAP_SETGID` (from POSIX) - CAP_SETGID = 6, - /// `CAP_SETUID` (from POSIX) - CAP_SETUID = 7, - /// `CAP_SETPCAP` (from Linux) - CAP_SETPCAP = 8, - /// - CAP_LINUX_IMMUTABLE = 9, - /// - CAP_NET_BIND_SERVICE = 10, - /// - CAP_NET_BROADCAST = 11, - /// - CAP_NET_ADMIN = 12, - /// - CAP_NET_RAW = 13, - /// - CAP_IPC_LOCK = 14, - /// - CAP_IPC_OWNER = 15, - /// `CAP_SYS_MODULE` (from Linux) - CAP_SYS_MODULE = 16, - /// `CAP_SYS_RAWIO` (from Linux) - CAP_SYS_RAWIO = 17, - /// `CAP_SYS_CHROOT` (from Linux) - CAP_SYS_CHROOT = 18, - /// `CAP_SYS_PTRACE` (from Linux) - CAP_SYS_PTRACE = 19, - /// `CAP_SYS_PACCT` (from Linux) - CAP_SYS_PACCT = 20, - /// `CAP_SYS_ADMIN` (from Linux) - CAP_SYS_ADMIN = 21, - /// `CAP_SYS_BOOT` (from Linux) - CAP_SYS_BOOT = 22, - /// `CAP_SYS_NICE` (from Linux) - CAP_SYS_NICE = 23, - /// `CAP_SYS_RESOURCE` (from Linux) - CAP_SYS_RESOURCE = 24, - /// `CAP_SYS_TIME` (from Linux) - CAP_SYS_TIME = 25, - /// `CAP_SYS_TTY_CONFIG` (from Linux) - CAP_SYS_TTY_CONFIG = 26, - /// `CAP_SYS_MKNOD` (from Linux, >= 2.4) - CAP_MKNOD = 27, - /// `CAP_LEASE` (from Linux, >= 2.4) - CAP_LEASE = 28, - /// - CAP_AUDIT_WRITE = 29, - /// `CAP_AUDIT_CONTROL` (from Linux, >= 2.6.11) - CAP_AUDIT_CONTROL = 30, - /// - CAP_SETFCAP = 31, - /// - CAP_MAC_OVERRIDE = 32, - /// - CAP_MAC_ADMIN = 33, - /// `CAP_SYSLOG` (from Linux, >= 2.6.37) - CAP_SYSLOG = 34, - /// `CAP_WAKE_ALARM` (from Linux, >= 3.0) - CAP_WAKE_ALARM = 35, - /// - CAP_BLOCK_SUSPEND = 36, - /// `CAP_AUDIT_READ` (from Linux, >= 3.16). - CAP_AUDIT_READ = 37, - /// `CAP_PERFMON` (from Linux, >= 5.8). - CAP_PERFMON = 38, - /// `CAP_BPF` (from Linux, >= 5.8). - CAP_BPF = 39, - /// `CAP_CHECKPOINT_RESTORE` (from Linux, >= 5.9). - CAP_CHECKPOINT_RESTORE = 40, + /// `CHOWN` (from POSIX) + CHOWN = 0, + /// `DAC_OVERRIDE` (from POSIX) + DAC_OVERRIDE = 1, + /// `DAC_READ_SEARCH` (from POSIX) + DAC_READ_SEARCH = 2, + /// `FOWNER` (from POSIX) + FOWNER = 3, + /// `FSETID` (from POSIX) + FSETID = 4, + /// `KILL` (from POSIX) + KILL = 5, + /// `SETGID` (from POSIX) + SETGID = 6, + /// `SETUID` (from POSIX) + SETUID = 7, + /// `SETPCAP` (from Linux) + SETPCAP = 8, + /// + LINUX_IMMUTABLE = 9, + /// + NET_BIND_SERVICE = 10, + /// + NET_BROADCAST = 11, + /// + NET_ADMIN = 12, + /// + NET_RAW = 13, + /// + IPC_LOCK = 14, + /// + IPC_OWNER = 15, + /// `SYS_MODULE` (from Linux) + SYS_MODULE = 16, + /// `SYS_RAWIO` (from Linux) + SYS_RAWIO = 17, + /// `SYS_CHROOT` (from Linux) + SYS_CHROOT = 18, + /// `SYS_PTRACE` (from Linux) + SYS_PTRACE = 19, + /// `SYS_PACCT` (from Linux) + SYS_PACCT = 20, + /// `SYS_ADMIN` (from Linux) + SYS_ADMIN = 21, + /// `SYS_BOOT` (from Linux) + SYS_BOOT = 22, + /// `SYS_NICE` (from Linux) + SYS_NICE = 23, + /// `SYS_RESOURCE` (from Linux) + SYS_RESOURCE = 24, + /// `SYS_TIME` (from Linux) + SYS_TIME = 25, + /// `SYS_TTY_CONFIG` (from Linux) + SYS_TTY_CONFIG = 26, + /// `SYS_MKNOD` (from Linux, >= 2.4) + MKNOD = 27, + /// `LEASE` (from Linux, >= 2.4) + LEASE = 28, + /// + AUDIT_WRITE = 29, + /// `AUDIT_CONTROL` (from Linux, >= 2.6.11) + AUDIT_CONTROL = 30, + /// + SETFCAP = 31, + /// + MAC_OVERRIDE = 32, + /// + MAC_ADMIN = 33, + /// `SYSLOG` (from Linux, >= 2.6.37) + SYSLOG = 34, + /// `WAKE_ALARM` (from Linux, >= 3.0) + WAKE_ALARM = 35, + /// + BLOCK_SUSPEND = 36, + /// `AUDIT_READ` (from Linux, >= 3.16). + AUDIT_READ = 37, + /// `PERFMON` (from Linux, >= 5.8). + PERFMON = 38, + /// `BPF` (from Linux, >= 5.8). + BPF = 39, + /// `CHECKPOINT_RESTORE` (from Linux, >= 5.9). + CHECKPOINT_RESTORE = 40, } impl std::fmt::Display for Capability { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { let name = match *self { - Capability::CAP_CHOWN => "CAP_CHOWN", - Capability::CAP_DAC_OVERRIDE => "CAP_DAC_OVERRIDE", - Capability::CAP_DAC_READ_SEARCH => "CAP_DAC_READ_SEARCH", - Capability::CAP_FOWNER => "CAP_FOWNER", - Capability::CAP_FSETID => "CAP_FSETID", - Capability::CAP_KILL => "CAP_KILL", - Capability::CAP_SETGID => "CAP_SETGID", - Capability::CAP_SETUID => "CAP_SETUID", - Capability::CAP_SETPCAP => "CAP_SETPCAP", - Capability::CAP_LINUX_IMMUTABLE => "CAP_LINUX_IMMUTABLE", - Capability::CAP_NET_BIND_SERVICE => "CAP_NET_BIND_SERVICE", - Capability::CAP_NET_BROADCAST => "CAP_NET_BROADCAST", - Capability::CAP_NET_ADMIN => "CAP_NET_ADMIN", - Capability::CAP_NET_RAW => "CAP_NET_RAW", - Capability::CAP_IPC_LOCK => "CAP_IPC_LOCK", - Capability::CAP_IPC_OWNER => "CAP_IPC_OWNER", - Capability::CAP_SYS_MODULE => "CAP_SYS_MODULE", - Capability::CAP_SYS_RAWIO => "CAP_SYS_RAWIO", - Capability::CAP_SYS_CHROOT => "CAP_SYS_CHROOT", - Capability::CAP_SYS_PTRACE => "CAP_SYS_PTRACE", - Capability::CAP_SYS_PACCT => "CAP_SYS_PACCT", - Capability::CAP_SYS_ADMIN => "CAP_SYS_ADMIN", - Capability::CAP_SYS_BOOT => "CAP_SYS_BOOT", - Capability::CAP_SYS_NICE => "CAP_SYS_NICE", - Capability::CAP_SYS_RESOURCE => "CAP_SYS_RESOURCE", - Capability::CAP_SYS_TIME => "CAP_SYS_TIME", - Capability::CAP_SYS_TTY_CONFIG => "CAP_SYS_TTY_CONFIG", - Capability::CAP_MKNOD => "CAP_MKNOD", - Capability::CAP_LEASE => "CAP_LEASE", - Capability::CAP_AUDIT_WRITE => "CAP_AUDIT_WRITE", - Capability::CAP_AUDIT_CONTROL => "CAP_AUDIT_CONTROL", - Capability::CAP_SETFCAP => "CAP_SETFCAP", - Capability::CAP_MAC_OVERRIDE => "CAP_MAC_OVERRIDE", - Capability::CAP_MAC_ADMIN => "CAP_MAC_ADMIN", - Capability::CAP_SYSLOG => "CAP_SYSLOG", - Capability::CAP_WAKE_ALARM => "CAP_WAKE_ALARM", - Capability::CAP_BLOCK_SUSPEND => "CAP_BLOCK_SUSPEND", - Capability::CAP_AUDIT_READ => "CAP_AUDIT_READ", - Capability::CAP_PERFMON => "CAP_PERFMON", - Capability::CAP_BPF => "CAP_BPF", - Capability::CAP_CHECKPOINT_RESTORE => "CAP_CHECKPOINT_RESTORE", + Capability::CHOWN => "CHOWN", + Capability::DAC_OVERRIDE => "DAC_OVERRIDE", + Capability::DAC_READ_SEARCH => "DAC_READ_SEARCH", + Capability::FOWNER => "FOWNER", + Capability::FSETID => "FSETID", + Capability::KILL => "KILL", + Capability::SETGID => "SETGID", + Capability::SETUID => "SETUID", + Capability::SETPCAP => "SETPCAP", + Capability::LINUX_IMMUTABLE => "LINUX_IMMUTABLE", + Capability::NET_BIND_SERVICE => "NET_BIND_SERVICE", + Capability::NET_BROADCAST => "NET_BROADCAST", + Capability::NET_ADMIN => "NET_ADMIN", + Capability::NET_RAW => "NET_RAW", + Capability::IPC_LOCK => "IPC_LOCK", + Capability::IPC_OWNER => "IPC_OWNER", + Capability::SYS_MODULE => "SYS_MODULE", + Capability::SYS_RAWIO => "SYS_RAWIO", + Capability::SYS_CHROOT => "SYS_CHROOT", + Capability::SYS_PTRACE => "SYS_PTRACE", + Capability::SYS_PACCT => "SYS_PACCT", + Capability::SYS_ADMIN => "SYS_ADMIN", + Capability::SYS_BOOT => "SYS_BOOT", + Capability::SYS_NICE => "SYS_NICE", + Capability::SYS_RESOURCE => "SYS_RESOURCE", + Capability::SYS_TIME => "SYS_TIME", + Capability::SYS_TTY_CONFIG => "SYS_TTY_CONFIG", + Capability::MKNOD => "MKNOD", + Capability::LEASE => "LEASE", + Capability::AUDIT_WRITE => "AUDIT_WRITE", + Capability::AUDIT_CONTROL => "AUDIT_CONTROL", + Capability::SETFCAP => "SETFCAP", + Capability::MAC_OVERRIDE => "MAC_OVERRIDE", + Capability::MAC_ADMIN => "MAC_ADMIN", + Capability::SYSLOG => "SYSLOG", + Capability::WAKE_ALARM => "WAKE_ALARM", + Capability::BLOCK_SUSPEND => "BLOCK_SUSPEND", + Capability::AUDIT_READ => "AUDIT_READ", + Capability::PERFMON => "PERFMON", + Capability::BPF => "BPF", + Capability::CHECKPOINT_RESTORE => "CHECKPOINT_RESTORE", }; write!(f, "{}", name) } @@ -155,47 +155,47 @@ impl std::str::FromStr for Capability { fn from_str(s: &str) -> std::result::Result { match s { - "CAP_CHOWN" => Ok(Capability::CAP_CHOWN), - "CAP_DAC_OVERRIDE" => Ok(Capability::CAP_DAC_OVERRIDE), - "CAP_DAC_READ_SEARCH" => Ok(Capability::CAP_DAC_READ_SEARCH), - "CAP_FOWNER" => Ok(Capability::CAP_FOWNER), - "CAP_FSETID" => Ok(Capability::CAP_FSETID), - "CAP_KILL" => Ok(Capability::CAP_KILL), - "CAP_SETGID" => Ok(Capability::CAP_SETGID), - "CAP_SETUID" => Ok(Capability::CAP_SETUID), - "CAP_SETPCAP" => Ok(Capability::CAP_SETPCAP), - "CAP_LINUX_IMMUTABLE" => Ok(Capability::CAP_LINUX_IMMUTABLE), - "CAP_NET_BIND_SERVICE" => Ok(Capability::CAP_NET_BIND_SERVICE), - "CAP_NET_BROADCAST" => Ok(Capability::CAP_NET_BROADCAST), - "CAP_NET_ADMIN" => Ok(Capability::CAP_NET_ADMIN), - "CAP_NET_RAW" => Ok(Capability::CAP_NET_RAW), - "CAP_IPC_LOCK" => Ok(Capability::CAP_IPC_LOCK), - "CAP_IPC_OWNER" => Ok(Capability::CAP_IPC_OWNER), - "CAP_SYS_MODULE" => Ok(Capability::CAP_SYS_MODULE), - "CAP_SYS_RAWIO" => Ok(Capability::CAP_SYS_RAWIO), - "CAP_SYS_CHROOT" => Ok(Capability::CAP_SYS_CHROOT), - "CAP_SYS_PTRACE" => Ok(Capability::CAP_SYS_PTRACE), - "CAP_SYS_PACCT" => Ok(Capability::CAP_SYS_PACCT), - "CAP_SYS_ADMIN" => Ok(Capability::CAP_SYS_ADMIN), - "CAP_SYS_BOOT" => Ok(Capability::CAP_SYS_BOOT), - "CAP_SYS_NICE" => Ok(Capability::CAP_SYS_NICE), - "CAP_SYS_RESOURCE" => Ok(Capability::CAP_SYS_RESOURCE), - "CAP_SYS_TIME" => Ok(Capability::CAP_SYS_TIME), - "CAP_SYS_TTY_CONFIG" => Ok(Capability::CAP_SYS_TTY_CONFIG), - "CAP_MKNOD" => Ok(Capability::CAP_MKNOD), - "CAP_LEASE" => Ok(Capability::CAP_LEASE), - "CAP_AUDIT_WRITE" => Ok(Capability::CAP_AUDIT_WRITE), - "CAP_AUDIT_CONTROL" => Ok(Capability::CAP_AUDIT_CONTROL), - "CAP_SETFCAP" => Ok(Capability::CAP_SETFCAP), - "CAP_MAC_OVERRIDE" => Ok(Capability::CAP_MAC_OVERRIDE), - "CAP_MAC_ADMIN" => Ok(Capability::CAP_MAC_ADMIN), - "CAP_SYSLOG" => Ok(Capability::CAP_SYSLOG), - "CAP_WAKE_ALARM" => Ok(Capability::CAP_WAKE_ALARM), - "CAP_BLOCK_SUSPEND" => Ok(Capability::CAP_BLOCK_SUSPEND), - "CAP_AUDIT_READ" => Ok(Capability::CAP_AUDIT_READ), - "CAP_PERFMON" => Ok(Capability::CAP_PERFMON), - "CAP_BPF" => Ok(Capability::CAP_BPF), - "CAP_CHECKPOINT_RESTORE" => Ok(Capability::CAP_CHECKPOINT_RESTORE), + "CHOWN" => Ok(Capability::CHOWN), + "DAC_OVERRIDE" => Ok(Capability::DAC_OVERRIDE), + "DAC_READ_SEARCH" => Ok(Capability::DAC_READ_SEARCH), + "FOWNER" => Ok(Capability::FOWNER), + "FSETID" => Ok(Capability::FSETID), + "KILL" => Ok(Capability::KILL), + "SETGID" => Ok(Capability::SETGID), + "SETUID" => Ok(Capability::SETUID), + "SETPCAP" => Ok(Capability::SETPCAP), + "LINUX_IMMUTABLE" => Ok(Capability::LINUX_IMMUTABLE), + "NET_BIND_SERVICE" => Ok(Capability::NET_BIND_SERVICE), + "NET_BROADCAST" => Ok(Capability::NET_BROADCAST), + "NET_ADMIN" => Ok(Capability::NET_ADMIN), + "NET_RAW" => Ok(Capability::NET_RAW), + "IPC_LOCK" => Ok(Capability::IPC_LOCK), + "IPC_OWNER" => Ok(Capability::IPC_OWNER), + "SYS_MODULE" => Ok(Capability::SYS_MODULE), + "SYS_RAWIO" => Ok(Capability::SYS_RAWIO), + "SYS_CHROOT" => Ok(Capability::SYS_CHROOT), + "SYS_PTRACE" => Ok(Capability::SYS_PTRACE), + "SYS_PACCT" => Ok(Capability::SYS_PACCT), + "SYS_ADMIN" => Ok(Capability::SYS_ADMIN), + "SYS_BOOT" => Ok(Capability::SYS_BOOT), + "SYS_NICE" => Ok(Capability::SYS_NICE), + "SYS_RESOURCE" => Ok(Capability::SYS_RESOURCE), + "SYS_TIME" => Ok(Capability::SYS_TIME), + "SYS_TTY_CONFIG" => Ok(Capability::SYS_TTY_CONFIG), + "MKNOD" => Ok(Capability::MKNOD), + "LEASE" => Ok(Capability::LEASE), + "AUDIT_WRITE" => Ok(Capability::AUDIT_WRITE), + "AUDIT_CONTROL" => Ok(Capability::AUDIT_CONTROL), + "SETFCAP" => Ok(Capability::SETFCAP), + "MAC_OVERRIDE" => Ok(Capability::MAC_OVERRIDE), + "MAC_ADMIN" => Ok(Capability::MAC_ADMIN), + "SYSLOG" => Ok(Capability::SYSLOG), + "WAKE_ALARM" => Ok(Capability::WAKE_ALARM), + "BLOCK_SUSPEND" => Ok(Capability::BLOCK_SUSPEND), + "AUDIT_READ" => Ok(Capability::AUDIT_READ), + "PERFMON" => Ok(Capability::PERFMON), + "BPF" => Ok(Capability::BPF), + "CHECKPOINT_RESTORE" => Ok(Capability::CHECKPOINT_RESTORE), _ => Err(crate::Error::Caps { what: format!("invalid capability: {}", s), }), @@ -204,13 +204,41 @@ impl std::str::FromStr for Capability { } impl Capability { + /// The `bitmask` function returns a bitmask where the bit at the position of `self` is set to 1 and + /// all other bits are set to 0. + /// + /// Returns: /// + /// The bitmask function returns a u64 value, which is the result of shifting 1u64 to the left by + /// the value of *self as u8. pub fn bitmask(&self) -> u64 { 1u64 << (*self as u8) } + /// The function returns the index of a value as an unsigned 8-bit integer. + /// + /// Returns: /// + /// The index of the object, converted to an unsigned 8-bit integer. pub fn index(&self) -> u8 { *self as u8 } } +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn bitmask_test() { + let vec = Capability::WAKE_ALARM; + + assert_eq!(vec.bitmask(), 1 << 35); + } + + #[test] + fn index_test() { + let vec = Capability::WAKE_ALARM; + + assert_eq!(vec.index(), 35); + } +} diff --git a/libs/basic/src/cargo.rs b/libs/basic/src/cargo.rs index 4a4f66df..5ba443e2 100644 --- a/libs/basic/src/cargo.rs +++ b/libs/basic/src/cargo.rs @@ -10,7 +10,7 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -//! +//! Cargo functions use crate::error::*; use std::env; @@ -80,4 +80,11 @@ mod tests { fn test_build_libblkid() { build_libblkid(); } + + #[test] + fn env_path_test() { + let result = env_path().unwrap(); + + println!("{:?}", result); + } } diff --git a/libs/basic/src/cmdline.rs b/libs/basic/src/cmdline.rs index 9a97ccea..ae7b0eeb 100644 --- a/libs/basic/src/cmdline.rs +++ b/libs/basic/src/cmdline.rs @@ -10,75 +10,110 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -//! -use crate::config; -use crate::error::*; +//! Cmdline functions use nix::unistd::Pid; +use std::collections::HashMap; use std::collections::HashSet; use std::fs::File; use std::io::{BufReader, Read}; use std::path::Path; -fn cmdline_content() -> Result { - let mut file = File::open("/proc/cmdline").context(IoSnafu)?; - - let mut buf = String::new(); - match file.read_to_string(&mut buf) { - Ok(s) => s, - Err(e) => { - return Err(Error::Io { source: e }); - } - }; - Ok(buf) +/// The `Cmdline` struct represents a command line with parameters and their corresponding values. +/// +/// Properties: +/// +/// * `params`: The `params` property is a `HashMap` that stores key-value pairs. The keys are of type +/// `String`, and the values are of type `Option`. The `Option` type allows for the possibility +/// of a value being present (`Some`) or absent (`None`). +#[derive(Debug)] +pub struct Cmdline { + params: HashMap>, + cmdline: String, } -/// read the content from /proc/cmdline and return the value depend the key -pub fn cmdline_get_value(key: &str) -> Result, Error> { - let buf = cmdline_content()?; - - let cmdline: Vec<&str> = buf.split_whitespace().collect(); - - for cmd in cmdline.iter() { - if let Some(k_val) = cmd.split_once('=') { - if k_val.0 == key { - return Ok(Some(k_val.1.to_string())); +impl Cmdline { + fn read_cmdline(path: String, cmdline: &mut String) -> HashMap> { + let mut params = HashMap::new(); + if let Ok(mut file) = File::open(path) { + let mut data = String::new(); + if file.read_to_string(&mut data).is_ok() { + *cmdline = data.clone(); + for item in data.split_whitespace() { + let mut parts = item.splitn(2, '='); + let key = parts.next().unwrap_or_default().to_string(); + let value = parts.next().map(|v| v.to_string()); + params.insert(key, value); + } } } + params } - Ok(None) -} - -/// read the content from /proc/cmdline and return specified item -///- -/// take `crashkernel=512M ro` for example, given `crashkernel` will -/// return `crashkernel=512M`, given `ro` will return `ro`, given -/// `foo` will return None. -pub fn cmdline_get_item(item: &str) -> Result, Error> { - let buf = cmdline_content()?; - let pair_item = item.to_string() + "="; - let cmdline: Vec<&str> = buf.split_whitespace().collect(); - - for cmd in cmdline.iter() { - if cmd.starts_with(&pair_item) || cmd.eq(&item) { - return Ok(Some(cmd.to_string())); - } + /// The function `get_cmdline` returns a clone of the `cmdline` string. + /// + /// Returns: + /// + /// A String is being returned. + pub fn get_cmdline(&self) -> String { + self.cmdline.clone() } - Ok(None) -} + /// The code defines a struct `Cmdline` with methods to read command line parameters from a process + /// and check if a parameter exists. + /// + /// Arguments: + /// + /// * `pid`: The `pid` parameter represents the process ID (PID) of a running process. It is used to + /// identify a specific process in the system. + /// + /// Returns: + /// + /// In the `new` function, a new instance of the `Cmdline` struct is being returned. + pub fn new(pid: Pid) -> Self { + let cmdfile = format!("/proc/{}/cmdline", pid); + let mut cmdline = String::new(); + let params = Self::read_cmdline(cmdfile, &mut cmdline); + + Cmdline { params, cmdline } + } -/// read the content from /proc/cmdline and return the bool value depend the key -pub fn proc_cmdline_get_bool(key: &str) -> Result { - let val = cmdline_get_value(key)?; + /// The `get_param` function retrieves a parameter value from a map and returns it as an + /// `Option`. + /// + /// Arguments: + /// + /// * `key`: The `key` parameter is a reference to a string that represents the key for which you + /// want to retrieve a value from the `params` map. + /// + /// Returns: + /// + /// The function `get_param` returns an `Option`. + pub fn get_param(&self, key: &str) -> Option { + self.params.get(key).map(|v| v.clone().unwrap_or_default()) + } - if val.is_none() { - return Ok(false); + /// The function `has_param` checks if a given key exists in a map called `params`. + /// + /// Arguments: + /// + /// * `key`: The `key` parameter is of type `&str`, which means it is a reference to a string slice. + /// + /// Returns: + /// + /// The `has_param` function returns a boolean value indicating whether the given `key` is present in + /// the `params` map. + pub fn has_param(&self, key: &str) -> bool { + self.params.contains_key(key) } +} - let r = config::parse_boolean(&val.unwrap())?; +impl Default for Cmdline { + fn default() -> Self { + let mut cmdline = String::new(); + let params = Self::read_cmdline("/proc/cmdline".to_string(), &mut cmdline); - Ok(r) + Cmdline { params, cmdline } + } } /// parse cmdline item, insert module_blacklist's value to data @@ -121,12 +156,10 @@ where } } -/// read /proc/PID/cmdline and return -pub fn get_process_cmdline(pid: &Pid) -> String { - let pid_str = pid.to_string(); - read_file(&Path::new("/proc").join(pid_str).join("cmdline")) -} - +/// The `read_file` function reads the contents of a file located at the specified path and returns +/// the content as a string. It opens the file, reads its contents line by line, and appends each +/// line to the `cmdline_content` string. The function handles any errors that occur during the file +/// reading process and returns an empty string if the file cannot be opened or read. fn read_file(path: &Path) -> String { let cmdline_path = path; let file = match File::open(cmdline_path) { @@ -147,3 +180,41 @@ fn read_file(path: &Path) -> String { } cmdline_content } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_cmdline_new() { + let cmdline = Cmdline::default(); + println!("{:?}", cmdline); + assert!(cmdline.has_param("root")); + assert!(cmdline.get_param("root").is_some()); + } + #[test] + fn test_get_cmdline() { + let mut cmdline = String::new(); + let params = Cmdline::read_cmdline("/proc/cmdline".to_string(), &mut cmdline); + let cmdline_str = cmdline.clone(); + let cmdline = Cmdline { params, cmdline }; + assert_eq!(cmdline.get_cmdline(), cmdline_str); + } + + #[test] + fn test_get_param() { + let mut cmdline = String::new(); + let params = Cmdline::read_cmdline("/proc/cmdline".to_string(), &mut cmdline); + let cmdline = Cmdline { params, cmdline }; + assert!(!cmdline.get_param("argv0").is_some()); + } + + #[test] + fn test_has_param() { + let mut cmdline = String::new(); + let params = Cmdline::read_cmdline("/proc/cmdline".to_string(), &mut cmdline); + let cmdline = Cmdline { params, cmdline }; + assert!(!cmdline.has_param("argv0")); + assert!(!cmdline.has_param("not_a_key")); + } +} diff --git a/libs/basic/src/condition.rs b/libs/basic/src/condition.rs index 39d09e5f..f8ea4bae 100644 --- a/libs/basic/src/condition.rs +++ b/libs/basic/src/condition.rs @@ -222,10 +222,9 @@ impl Condition { } fn test_first_boot(&self) -> i8 { - if let Ok(ret) = cmdline::proc_cmdline_get_bool("sysmaster.condition-first-boot") { - if ret { - return ret as i8; - } + let ret = cmdline::Cmdline::default().has_param("sysmaster.condition-first-boot"); + if ret { + return ret as i8; } let result = self.params.eq("true"); @@ -241,20 +240,20 @@ impl Condition { } else { &self.params }; - let value = match cmdline::cmdline_get_item(search_value) { - Err(_) => { + let value = match cmdline::Cmdline::default().get_param(search_value) { + None => { log::info!("Failed to get cmdline content, assuming ConditionKernelCommandLine check failed."); return 0; } - Ok(v) => { - if v.is_none() { + Some(v) => { + if v.is_empty() { log::info!( "/proc/cmdline doesn't contain the given item: {}", search_value ); return 0; } - v.unwrap() + v } }; log::debug!("Found kernel command line value: {}", value); @@ -450,7 +449,7 @@ mod test { ConditionType::Capability, 0, 0, - String::from("CAP_CHOWN"), + String::from("CHOWN"), ); } @@ -815,19 +814,6 @@ mod test { ); } - #[test] - fn test_kernel_command_line() { - run_test( - |c| { - assert!(c.test(), "test kernel_command_line {}", c.params); - }, - ConditionType::KernelCommandLine, - 0, - 0, - String::from("root"), - ); - } - #[test] fn test_path_is_directory() { run_test( @@ -872,13 +858,11 @@ mod test { fn test_condition_first_boot() { run_test( |c| { - if let Ok(ret) = cmdline::proc_cmdline_get_bool("sysmaster.condition-first-boot") { - if ret { - println!( - "this test cannot be tested because we cannot modify the kernel parameters" - ); - return; - } + if cmdline::Cmdline::default().has_param("sysmaster.condition-first-boot") { + println!( + "this test cannot be tested because we cannot modify the kernel parameters" + ); + return; } let existed = Path::new("/run/sysmaster/first-boot").exists(); @@ -898,13 +882,11 @@ mod test { fn test_condition_first_boot_false() { run_test( |c| { - if let Ok(ret) = cmdline::proc_cmdline_get_bool("sysmaster.condition-first-boot") { - if ret { - println!( - "this test cannot be tested because we cannot modify the kernel parameters" - ); - return; - } + if cmdline::Cmdline::default().has_param("sysmaster.condition-first-boot") { + println!( + "this test cannot be tested because we cannot modify the kernel parameters" + ); + return; } let existed = Path::new("/run/sysmaster/first-boot").exists(); diff --git a/libs/basic/src/exec_util.rs b/libs/basic/src/exec.rs similarity index 60% rename from libs/basic/src/exec_util.rs rename to libs/basic/src/exec.rs index e27c4d62..c6553f22 100644 --- a/libs/basic/src/exec_util.rs +++ b/libs/basic/src/exec.rs @@ -10,12 +10,22 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -//! +//! exec functions use nix::unistd; use std::{fs, os::unix::prelude::PermissionsExt, path::PathBuf, process::Command}; +/// The function `execute_directories` executes a given list of directories in parallel using fork and +/// waits for all child processes to finish. /// +/// Arguments: +/// +/// * `directories`: The `directories` parameter is a vector of string slices (`&str`) representing the +/// directories that need to be executed. +/// +/// Returns: +/// +/// The function `execute_directories` returns a `std::io::Result<()>`. pub fn execute_directories(directories: Vec<&str>) -> std::io::Result<()> { match unsafe { unistd::fork() } { Ok(unistd::ForkResult::Child) => { @@ -29,7 +39,16 @@ pub fn execute_directories(directories: Vec<&str>) -> std::io::Result<()> { } } +/// The function `do_execute` takes a list of directories, spawns child processes for each directory's +/// generator, and waits for them to finish. +/// +/// Arguments: /// +/// * `directories`: A vector of strings representing directories. +/// +/// Returns: +/// +/// The function `do_execute` returns a `std::io::Result<()>`. fn do_execute(directories: Vec<&str>) -> std::io::Result<()> { let mut child = Vec::new(); for generator in get_generator(directories)? { @@ -56,7 +75,12 @@ fn do_execute(directories: Vec<&str>) -> std::io::Result<()> { Ok(()) } -/// +/// The function `get_generator` takes a vector of directory paths (`directories`) as +/// input. It reads each directory and retrieves a list of file paths that have +/// executable permissions (`permissions().mode() & 0x111 != 0`). These file paths are +/// stored in a vector (`result`) and returned as a `std::io::Result>`. If +/// there is an error while reading a directory, an error message is logged and the +/// directory is skipped. fn get_generator(directories: Vec<&str>) -> std::io::Result> { let mut result: Vec = Vec::new(); @@ -83,3 +107,24 @@ fn get_generator(directories: Vec<&str>) -> std::io::Result> { } Ok(result) } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_get_generator() { + let directories = vec!["/usr/bin", "/usr/lib64"]; + let _expected_files = vec![ + PathBuf::from("/usr/bin/ls"), + PathBuf::from("/usr/bin/cat"), + // Add more expected files here + ]; + + let actual_files = get_generator(directories).expect("get_generator() failed"); + + // assert_eq!(actual_files, expected_files); + + println!("get_generator() tests passed.{:?}", actual_files); + } +} diff --git a/libs/basic/src/lib.rs b/libs/basic/src/lib.rs index 9d76b57f..997054ed 100644 --- a/libs/basic/src/lib.rs +++ b/libs/basic/src/lib.rs @@ -12,7 +12,7 @@ //! #[cfg(feature = "argv")] -pub mod argv_util; +pub mod argv; #[cfg(feature = "capability")] pub mod capability; #[cfg(feature = "cargo")] @@ -27,8 +27,8 @@ pub mod config; pub mod cpu; #[cfg(feature = "disk")] pub mod disk; -#[cfg(feature = "exec_util")] -pub mod exec_util; +#[cfg(feature = "exec")] +pub mod exec; #[cfg(feature = "fd")] pub mod fd_util; #[cfg(feature = "fs")] @@ -48,7 +48,7 @@ pub mod mount_util; #[cfg(feature = "murmurhash2")] pub mod murmurhash2; #[cfg(feature = "namespace")] -pub mod namespace_util; +pub mod namespace; #[cfg(feature = "naming_scheme")] pub mod naming_scheme; #[cfg(feature = "network")] @@ -62,7 +62,7 @@ pub mod path_util; #[cfg(feature = "process")] pub mod process; #[cfg(feature = "random")] -pub mod random_util; +pub mod random; #[cfg(feature = "rlimit")] pub mod rlimit; #[cfg(feature = "security")] diff --git a/libs/basic/src/machine.rs b/libs/basic/src/machine.rs index 990fb8ac..f4551379 100644 --- a/libs/basic/src/machine.rs +++ b/libs/basic/src/machine.rs @@ -14,7 +14,7 @@ use crate::{ fs_util, id128_util::{self, Id128FormatFlag}, - mount_util, namespace_util, + mount_util, namespace, }; use libc::syncfs; use log; @@ -379,9 +379,9 @@ pub fn machine_id_commit() -> Result<()> { } } - mnt_fd = namespace_util::namespace_open(&Pid::from_raw(0), Path::new(&"mnt".to_string()))?; + mnt_fd = namespace::namespace_open(&Pid::from_raw(0), Path::new(&"mnt".to_string()))?; - namespace_util::detach_mount_namespace()?; + namespace::detach_mount_namespace()?; if let Err(e) = mount::umount2(etc_machine_id, mount::MntFlags::from_bits(0).unwrap()) { log::error!("Failed to umount {:?}:{}", etc_machine_id, e); @@ -395,7 +395,7 @@ pub fn machine_id_commit() -> Result<()> { Id128FormatFlag::ID128_FORMAT_PLAIN, )?; - namespace_util::namespace_enter(&mnt_fd, sched::CloneFlags::CLONE_NEWNS)?; + namespace::namespace_enter(&mnt_fd, sched::CloneFlags::CLONE_NEWNS)?; mount::umount2(etc_machine_id, mount::MntFlags::MNT_DETACH) } diff --git a/libs/basic/src/namespace_util.rs b/libs/basic/src/namespace.rs similarity index 100% rename from libs/basic/src/namespace_util.rs rename to libs/basic/src/namespace.rs diff --git a/libs/basic/src/naming_scheme.rs b/libs/basic/src/naming_scheme.rs index f22bb534..826bf360 100644 --- a/libs/basic/src/naming_scheme.rs +++ b/libs/basic/src/naming_scheme.rs @@ -116,9 +116,9 @@ impl Display for NamingScheme { /// get the naming scheme according to cmdline and environment variables pub fn naming_scheme() -> NamingScheme { - let cmdline_value = cmdline::cmdline_get_value("net.naming-scheme") - .unwrap_or(None) - .unwrap_or_default(); + let cmdline_value = cmdline::Cmdline::default() + .get_param("net.naming-scheme") + .unwrap_or_else(|| "".to_string()); /* * Environment variable 'NET_NAMING_SCHEME' is prior to cmdline parameter 'net.naming-scheme', @@ -150,7 +150,7 @@ pub fn naming_scheme() -> NamingScheme { /// check whether the naming scheme is enabled pub fn naming_scheme_enabled() -> bool { - if let Ok(Some(v)) = cmdline::cmdline_get_value("net.ifnames") { + if let Some(v) = cmdline::Cmdline::default().get_param("net.ifnames") { if ["0", "false"].contains(&v.as_str()) { return false; } @@ -182,9 +182,8 @@ mod tests { env::set_var("NET_NAMING_SCHEME", "0"); assert_eq!(naming_scheme(), NamingScheme::V000); - let cmdline_value = cmdline::cmdline_get_value("net.naming-scheme") - .unwrap_or(None) - .unwrap_or_default(); + let cmdline = cmdline::Cmdline::default(); + let cmdline_value = cmdline.get_param("net.naming-scheme").unwrap_or_default(); let scheme = cmdline_value .parse::() @@ -202,7 +201,7 @@ mod tests { #[test] fn test_naming_scheme_enabled() { let ret = naming_scheme_enabled(); - if let Ok(Some(v)) = cmdline::cmdline_get_value("net.ifnames") { + if let Some(v) = cmdline::Cmdline::default().get_param("net.ifnames") { if ["0", "false"].contains(&v.as_str()) { assert!(!ret); } else { diff --git a/libs/basic/src/random_util.rs b/libs/basic/src/random.rs similarity index 99% rename from libs/basic/src/random_util.rs rename to libs/basic/src/random.rs index 831bf8ba..32dbd029 100644 --- a/libs/basic/src/random_util.rs +++ b/libs/basic/src/random.rs @@ -10,7 +10,7 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -//! +//! Random functions /// Get random data from getrandom() or '/dev/urandom' pub fn random_bytes(data: &mut [u8]) { diff --git a/libs/basic/src/uuid.rs b/libs/basic/src/uuid.rs index c1bd8030..45ce8fef 100644 --- a/libs/basic/src/uuid.rs +++ b/libs/basic/src/uuid.rs @@ -171,7 +171,7 @@ impl Uuid { pub fn randomize() -> Result { let mut id = Uuid::new(); - crate::random_util::random_bytes(&mut id.0); + crate::random::random_bytes(&mut id.0); /* Turn this into a valid v4 UUID, to be nice. Note that we * only guarantee this for newly generated UUIDs, not for -- Gitee From f983f4b590700f56fe9f3c97c30d4322e7f4db68 Mon Sep 17 00:00:00 2001 From: overweight Date: Tue, 2 Jan 2024 16:22:54 +0800 Subject: [PATCH 2/3] refactor: lib baisic refactor --- core/coms/mount/src/manager.rs | 2 +- core/coms/mount/src/mng.rs | 4 +-- core/coms/mount/src/unit.rs | 2 +- core/coms/service/src/rentry.rs | 6 ++-- core/coms/socket/src/config.rs | 4 +-- core/coms/socket/src/port.rs | 24 +++++++-------- core/sysmaster/src/main.rs | 2 +- core/sysmaster/src/manager/commands.rs | 4 +-- core/sysmaster/src/mount/setup.rs | 9 ++---- core/sysmaster/src/unit/manager.rs | 6 ++-- core/sysmaster/src/unit/notify.rs | 4 +-- .../src/bin/devctl/subcmds/monitor.rs | 2 +- .../src/bin/devctl/subcmds/settle.rs | 2 +- .../src/lib/framework/uevent_monitor.rs | 2 +- exts/fstab/src/fstab_item.rs | 2 +- exts/fstab/src/main.rs | 2 +- exts/machine-id-setup/src/main.rs | 6 ++-- exts/random_seed/src/random_seed.rs | 2 +- exts/switch_root/src/switch_root.rs | 2 +- libs/basic/src/condition.rs | 4 +-- libs/basic/src/fd_util.rs | 2 +- libs/basic/src/{id128_util.rs => id128.rs} | 0 libs/basic/src/{io_util.rs => io.rs} | 0 libs/basic/src/lib.rs | 16 +++++----- libs/basic/src/machine.rs | 30 +++++++++---------- libs/basic/src/{mount_util.rs => mount.rs} | 0 libs/basic/src/{path_util.rs => path.rs} | 0 libs/basic/src/random.rs | 2 +- libs/basic/src/{signal_util.rs => signal.rs} | 0 libs/basic/src/{socket_util.rs => socket.rs} | 0 libs/basic/src/{stat_util.rs => stat.rs} | 0 libs/basic/src/{time_util.rs => time.rs} | 0 libs/device/src/device_monitor.rs | 2 +- libs/event/src/timer.rs | 2 +- 34 files changed, 71 insertions(+), 74 deletions(-) rename libs/basic/src/{id128_util.rs => id128.rs} (100%) rename libs/basic/src/{io_util.rs => io.rs} (100%) rename libs/basic/src/{mount_util.rs => mount.rs} (100%) rename libs/basic/src/{path_util.rs => path.rs} (100%) rename libs/basic/src/{signal_util.rs => signal.rs} (100%) rename libs/basic/src/{socket_util.rs => socket.rs} (100%) rename libs/basic/src/{stat_util.rs => stat.rs} (100%) rename libs/basic/src/{time_util.rs => time.rs} (100%) diff --git a/core/coms/mount/src/manager.rs b/core/coms/mount/src/manager.rs index 6ea063c8..fbcb5d3e 100644 --- a/core/coms/mount/src/manager.rs +++ b/core/coms/mount/src/manager.rs @@ -18,7 +18,7 @@ use constants::LOG_FILE_PATH; use super::comm::MountUmComm; use super::rentry::{MountRe, MountReFrame}; -use basic::mount_util::{mount_point_to_unit_name, MountInfoParser}; +use basic::mount::{mount_point_to_unit_name, MountInfoParser}; use core::error::*; use core::rel::{ReStation, ReliLastFrame, Reliability}; use core::unit::{unit_name_is_valid, UmIf, UnitManagerObj, UnitMngUtil, UnitNameFlags, UnitType}; diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index de00ea52..24288b79 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -12,8 +12,8 @@ //! The core logic of the mount subclass use basic::fs_util::{directory_is_empty, mkdir_p_label}; -use basic::mount_util::filter_options; -use basic::time_util::USEC_PER_SEC; +use basic::mount::filter_options; +use basic::time::USEC_PER_SEC; use basic::{MOUNT_BIN, UMOUNT_BIN}; use event::{EventState, Events}; use event::{EventType, Source}; diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 86b1fc55..f7d93a39 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -18,7 +18,7 @@ use crate::rentry::{MountProcFlags, MountState}; use super::comm::MountUnitComm; use super::mng::MountMng; -use basic::mount_util::mount_point_to_unit_name; +use basic::mount::mount_point_to_unit_name; use core::error::*; use core::exec::ExecContext; use core::rel::{ReStation, Reliability}; diff --git a/core/coms/service/src/rentry.rs b/core/coms/service/src/rentry.rs index 24d2d474..bcdc4d45 100644 --- a/core/coms/service/src/rentry.rs +++ b/core/coms/service/src/rentry.rs @@ -32,8 +32,8 @@ use core::exec::{ExecCommand, Rlimit, RuntimeDirectory, StateDirectory, WorkingD use core::rel::{ReDb, ReDbRwTxn, ReDbTable, ReliSwitch, Reliability}; use core::unit::KillMode; -use basic::time_util::USEC_PER_MSEC; -use basic::time_util::USEC_PER_SEC; +use basic::time::USEC_PER_MSEC; +use basic::time::USEC_PER_SEC; use basic::EXEC_RUNTIME_PREFIX; struct ServiceReDb(ReDb); @@ -232,7 +232,7 @@ fn parse_pidfile(s: &str) -> Result { } fn parse_sec(s: &str) -> Result { - basic::time_util::parse_sec(s).context(NixSnafu) + basic::time::parse_sec(s).context(NixSnafu) } fn parse_timeout(s: &str) -> Result { diff --git a/core/coms/socket/src/config.rs b/core/coms/socket/src/config.rs index c53e275a..11b4b07a 100644 --- a/core/coms/socket/src/config.rs +++ b/core/coms/socket/src/config.rs @@ -16,7 +16,7 @@ use super::comm::SocketUnitComm; use super::rentry::{PortType, SectionSocket, SocketCommand}; use crate::base::NetlinkProtocol; -use basic::{fd_util, socket_util}; +use basic::fd_util; use core::error::*; use core::exec::ExecCommand; use core::rel::ReStation; @@ -630,7 +630,7 @@ fn parse_socket_address(item: &str, socket_type: SockType) -> Result Result<()> { if let Ok(true) = socket::getsockopt(self.fd(), sockopt::AcceptConn) { for _i in 1..1024 { - let events = match io_util::wait_for_events(self.fd(), PollFlags::POLLIN, 0) { + let events = match io::wait_for_events(self.fd(), PollFlags::POLLIN, 0) { Err(e) => { if let basic::Error::Nix { source: Errno::EINTR, @@ -197,7 +197,7 @@ impl SocketPort { pub(super) fn flush_fd(&self) { loop { - let v = io_util::wait_for_events(self.fd(), PollFlags::POLLIN, 0).unwrap_or(0); + let v = io::wait_for_events(self.fd(), PollFlags::POLLIN, 0).unwrap_or(0); if v == 0 { return; }; @@ -214,37 +214,37 @@ impl SocketPort { pub(super) fn apply_sock_opt(&self, fd: RawFd) { if let Some(v) = self.config.config_data().borrow().Socket.PassPacketInfo { - if let Err(e) = socket_util::set_pkginfo(fd, self.family(), v) { + if let Err(e) = basic::socket::set_pkginfo(fd, self.family(), v) { log::warn!("set socket pkginfo errno: {}", e); } } if let Some(v) = self.config.config_data().borrow().Socket.PassCredentials { - if let Err(e) = socket_util::set_pass_cred(fd, v) { + if let Err(e) = basic::socket::set_pass_cred(fd, v) { log::warn!("set socket pass cred errno: {}", e); } } if let Some(v) = self.config.config_data().borrow().Socket.ReceiveBuffer { - if let Err(e) = socket_util::set_receive_buffer(fd, v as usize) { + if let Err(e) = basic::socket::set_receive_buffer(fd, v as usize) { log::warn!("set socket receive buffer errno: {}", e); } } if let Some(v) = self.config.config_data().borrow().Socket.SendBuffer { - if let Err(e) = socket_util::set_send_buffer(fd, v as usize) { + if let Err(e) = basic::socket::set_send_buffer(fd, v as usize) { log::warn!("set socket send buffer errno: {}", e); } } if let Some(v) = self.config.config_data().borrow().Socket.KeepAlive { - if let Err(e) = socket_util::set_keepalive_state(fd, v) { + if let Err(e) = basic::socket::set_keepalive_state(fd, v) { log::warn!("set keepalive state errno: {}", e); } } if let Some(v) = self.config.config_data().borrow().Socket.KeepAliveTimeSec { - if let Err(e) = socket_util::set_keepalive_timesec(fd, v) { + if let Err(e) = basic::socket::set_keepalive_timesec(fd, v) { log::warn!("set keepalive time errno: {}", e); } } @@ -256,19 +256,19 @@ impl SocketPort { .Socket .KeepAliveIntervalSec { - if let Err(e) = socket_util::set_keepalive_intervalsec(fd, v) { + if let Err(e) = basic::socket::set_keepalive_intervalsec(fd, v) { log::warn!("set keepalive interval errno: {}", e); } } if let Some(v) = self.config.config_data().borrow().Socket.KeepAliveProbes { - if let Err(e) = socket_util::set_keepalive_probes(fd, v) { + if let Err(e) = basic::socket::set_keepalive_probes(fd, v) { log::warn!("set keepalive probe count errno: {}", e); } } if let Some(v) = self.config.config_data().borrow().Socket.Broadcast { - if let Err(e) = socket_util::set_broadcast_state(fd, v) { + if let Err(e) = basic::socket::set_broadcast_state(fd, v) { log::warn!("set broadcast state errno: {}", e); } } diff --git a/core/sysmaster/src/main.rs b/core/sysmaster/src/main.rs index 0bc6b9bf..b4d3a55c 100644 --- a/core/sysmaster/src/main.rs +++ b/core/sysmaster/src/main.rs @@ -40,7 +40,7 @@ use crate::manager::config::ManagerConfig; use crate::manager::signals::EVENT_SIGNALS; use crate::manager::{Action, Manager, Mode, MANAGER_ARGS_SIZE_MAX}; use crate::mount::setup; -use basic::{machine, machine::Machine, mount_util::read_lines, FSTAB_PATH, MOUNT_BIN}; +use basic::{machine, machine::Machine, mount::read_lines, FSTAB_PATH, MOUNT_BIN}; use clap::Parser; use constants::LOG_FILE_PATH; use core::error::*; diff --git a/core/sysmaster/src/manager/commands.rs b/core/sysmaster/src/manager/commands.rs index ee5f7e22..a9f06b95 100644 --- a/core/sysmaster/src/manager/commands.rs +++ b/core/sysmaster/src/manager/commands.rs @@ -10,8 +10,8 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. +use basic::do_entry_log; use basic::fs_util::{self, is_symlink}; -use basic::{do_entry_log, socket_util}; use cmdproto::proto::execute::ExecuterAction; use cmdproto::proto::ProstServerStream; use core::rel::{ReliLastFrame, Reliability}; @@ -56,7 +56,7 @@ where ) .unwrap(); /* set SO_PASSCRED, we need it to check whether sctl is running under root */ - socket_util::set_pass_cred(socket_fd, true).unwrap(); + basic::socket::set_pass_cred(socket_fd, true).unwrap(); /* create the socket with mode 666 */ let old_mask = stat::umask(stat::Mode::from_bits_truncate(!0o666)); match socket::bind(socket_fd, &sctl_socket_addr) { diff --git a/core/sysmaster/src/mount/setup.rs b/core/sysmaster/src/mount/setup.rs index 96f60b1e..1938ec10 100644 --- a/core/sysmaster/src/mount/setup.rs +++ b/core/sysmaster/src/mount/setup.rs @@ -12,7 +12,7 @@ //! mount the cgroup systems use basic::machine::Machine; -use basic::{cmdline, machine, mount_util}; +use basic::{cmdline, machine, mount}; use bitflags::bitflags; use cgroup::{self, CgController, CgType, CG_BASE_DIR}; use core::error::*; @@ -393,11 +393,8 @@ impl MountPoint { let last_file_name = path.file_name().unwrap_or_default(); - let ret = mount_util::mount_point_fd_valid( - file.as_raw_fd(), - last_file_name.to_str().unwrap(), - flags, - )?; + let ret = + mount::mount_point_fd_valid(file.as_raw_fd(), last_file_name.to_str().unwrap(), flags)?; Ok(ret) } diff --git a/core/sysmaster/src/unit/manager.rs b/core/sysmaster/src/unit/manager.rs index 02e2062d..824ff6e4 100644 --- a/core/sysmaster/src/unit/manager.rs +++ b/core/sysmaster/src/unit/manager.rs @@ -36,7 +36,7 @@ use crate::unit::data::{DataManager, UnitState}; use crate::utils::table::{TableOp, TableSubscribe}; use basic::fs_util::LookupPaths; use basic::show_table::{CellColor, ShowTable}; -use basic::{machine, process, rlimit, signal_util}; +use basic::{machine, process, rlimit, signal}; use constants::SIG_SWITCH_ROOT_OFFSET; use core::error::*; use core::exec::ExecParameters; @@ -273,8 +273,8 @@ impl UnitManagerX { })?; } - signal_util::reset_all_signal_handlers(); - signal_util::reset_signal_mask(); + signal::reset_all_signal_handlers(); + signal::reset_signal_mask(); rlimit::rlimit_nofile_safe(); let res = unsafe { libc::kill(getppid(), libc::SIGRTMIN() + SIG_SWITCH_ROOT_OFFSET) }; if res == 0 { diff --git a/core/sysmaster/src/unit/notify.rs b/core/sysmaster/src/unit/notify.rs index e6cb6f10..517586e7 100644 --- a/core/sysmaster/src/unit/notify.rs +++ b/core/sysmaster/src/unit/notify.rs @@ -14,7 +14,7 @@ use super::datastore::UnitDb; use super::entry::UnitX; use super::rentry::UnitRe; use crate::job::JobManager; -use basic::{fd_util, socket_util}; +use basic::fd_util; use core::error::*; use core::rel::{ReStation, ReliLastFrame, Reliability}; use event::{EventState, EventType, Events, Source}; @@ -181,7 +181,7 @@ impl Notify { return Err(e); } socket::setsockopt(fd, sockopt::PassCred, &true)?; - if let Err(e) = socket_util::set_receive_buffer(fd, 1024 * 1014 * 8) { + if let Err(e) = basic::socket::set_receive_buffer(fd, 1024 * 1014 * 8) { log::error!("Failed to set the notify socket receive buffer: {}", e); } diff --git a/exts/devmaster/src/bin/devctl/subcmds/monitor.rs b/exts/devmaster/src/bin/devctl/subcmds/monitor.rs index 50f310a2..81cad5fc 100644 --- a/exts/devmaster/src/bin/devctl/subcmds/monitor.rs +++ b/exts/devmaster/src/bin/devctl/subcmds/monitor.rs @@ -14,7 +14,7 @@ //! use crate::Result; -use basic::socket_util::set_receive_buffer; +use basic::socket::set_receive_buffer; use device::{device_monitor::DeviceMonitor, device_monitor::MonitorNetlinkGroup}; use event::{EventState, EventType, Events, Source}; use nix::errno::Errno; diff --git a/exts/devmaster/src/bin/devctl/subcmds/settle.rs b/exts/devmaster/src/bin/devctl/subcmds/settle.rs index 7bbe69fc..4874ca77 100644 --- a/exts/devmaster/src/bin/devctl/subcmds/settle.rs +++ b/exts/devmaster/src/bin/devctl/subcmds/settle.rs @@ -15,7 +15,7 @@ use crate::subcmds::utils::devmaster_queue_is_empty; use crate::Result; -use basic::time_util::{parse_sec, USEC_INFINITY, USEC_PER_SEC}; +use basic::time::{parse_sec, USEC_INFINITY, USEC_PER_SEC}; use event::{EventState, EventType, Events, Source}; use libdevmaster::framework::control_manager::CONTROL_MANAGER_LISTEN_ADDR; use nix::sys::inotify::AddWatchFlags; diff --git a/exts/devmaster/src/lib/framework/uevent_monitor.rs b/exts/devmaster/src/lib/framework/uevent_monitor.rs index 0add91f6..c042d5a0 100644 --- a/exts/devmaster/src/lib/framework/uevent_monitor.rs +++ b/exts/devmaster/src/lib/framework/uevent_monitor.rs @@ -39,7 +39,7 @@ impl UeventMonitor { /// forcely set the size of socket receive buffer pub fn set_receive_buffer(&self, v: usize) { - basic::socket_util::set_receive_buffer(self.device_monitor.fd(), v).unwrap(); + basic::socket::set_receive_buffer(self.device_monitor.fd(), v).unwrap(); } } diff --git a/exts/fstab/src/fstab_item.rs b/exts/fstab/src/fstab_item.rs index a9238d56..9bd92e6b 100644 --- a/exts/fstab/src/fstab_item.rs +++ b/exts/fstab/src/fstab_item.rs @@ -12,7 +12,7 @@ //! fstab_item encapsulates six fields and status of /etc/fstab. -use basic::mount_util::read_lines; +use basic::mount::read_lines; /// FSTabItem structure pub struct FSTabItem { diff --git a/exts/fstab/src/main.rs b/exts/fstab/src/main.rs index 4a8e0660..09d7dd34 100644 --- a/exts/fstab/src/main.rs +++ b/exts/fstab/src/main.rs @@ -19,7 +19,7 @@ //! # limit //! 1. The current device only supports configuration as full directory or UUID. -use basic::mount_util::{is_mount_point, is_swap}; +use basic::mount::{is_mount_point, is_swap}; use basic::{FSTAB_PATH, MOUNT_BIN, SWAP_BIN}; use inotify::{EventMask, Inotify, WatchMask}; use std::collections::HashSet; diff --git a/exts/machine-id-setup/src/main.rs b/exts/machine-id-setup/src/main.rs index 18605eed..8450566f 100644 --- a/exts/machine-id-setup/src/main.rs +++ b/exts/machine-id-setup/src/main.rs @@ -13,7 +13,7 @@ //! use basic::{ - id128_util, + id128, machine::{self, machine_id_setup}, }; use nix::{Error, Result}; @@ -48,9 +48,9 @@ fn main() -> Result<()> { if args.contains(&String::from("--commit")) { let etc_machine_id = "/etc/machine-id".to_string(); machine::machine_id_commit()?; - id = match id128_util::id128_read_by_path( + id = match id128::id128_read_by_path( Path::new(&etc_machine_id), - id128_util::Id128FormatFlag::ID128_FORMAT_PLAIN, + id128::Id128FormatFlag::ID128_FORMAT_PLAIN, ) { Ok(id) => id, Err(e) => { diff --git a/exts/random_seed/src/random_seed.rs b/exts/random_seed/src/random_seed.rs index 74846a6f..ee054a08 100644 --- a/exts/random_seed/src/random_seed.rs +++ b/exts/random_seed/src/random_seed.rs @@ -10,7 +10,7 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -use basic::io_util::loop_read; +use basic::io::loop_read; use nix::ioctl_write_ptr; use std::alloc::{alloc, dealloc, Layout}; use std::ffi::CString; diff --git a/exts/switch_root/src/switch_root.rs b/exts/switch_root/src/switch_root.rs index 6c17c02f..86ba630c 100644 --- a/exts/switch_root/src/switch_root.rs +++ b/exts/switch_root/src/switch_root.rs @@ -10,7 +10,7 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -use basic::{machine, mount_util::MountInfoParser, IN_SET}; +use basic::{machine, mount::MountInfoParser, IN_SET}; use nix::{ dir::Type, errno::Errno, diff --git a/libs/basic/src/condition.rs b/libs/basic/src/condition.rs index f8ea4bae..3ee5c508 100644 --- a/libs/basic/src/condition.rs +++ b/libs/basic/src/condition.rs @@ -22,12 +22,12 @@ use nix::{ use libc::{glob, glob_t, GLOB_NOSORT}; use crate::{ - cmdline, fd_util, fs_util::directory_is_not_empty, mount_util::is_mount_point, security, + cmdline, fd_util, fs_util::directory_is_not_empty, mount::is_mount_point, security, sysfs::SysFs, unistd, }; #[cfg(target_env = "musl")] -use crate::mount_util::MountInfoParser; +use crate::mount::MountInfoParser; use std::{ ffi::CString, diff --git a/libs/basic/src/fd_util.rs b/libs/basic/src/fd_util.rs index 8715891c..e5ef9f6a 100644 --- a/libs/basic/src/fd_util.rs +++ b/libs/basic/src/fd_util.rs @@ -113,7 +113,7 @@ pub fn fd_reopen(fd: RawFd, oflags: OFlag) -> Result { return Err(Error::Nix { source: e }); } - if !crate::stat_util::proc_mounted().map_err(|_| Error::Nix { + if !crate::stat::proc_mounted().map_err(|_| Error::Nix { source: Errno::ENOENT, })? { // if /proc/ is not mounted, this function can not work diff --git a/libs/basic/src/id128_util.rs b/libs/basic/src/id128.rs similarity index 100% rename from libs/basic/src/id128_util.rs rename to libs/basic/src/id128.rs diff --git a/libs/basic/src/io_util.rs b/libs/basic/src/io.rs similarity index 100% rename from libs/basic/src/io_util.rs rename to libs/basic/src/io.rs diff --git a/libs/basic/src/lib.rs b/libs/basic/src/lib.rs index 997054ed..df273288 100644 --- a/libs/basic/src/lib.rs +++ b/libs/basic/src/lib.rs @@ -36,15 +36,15 @@ pub mod fs_util; #[cfg(feature = "host")] pub mod host; #[cfg(feature = "id128")] -pub mod id128_util; +pub mod id128; #[cfg(feature = "io")] -pub mod io_util; +pub mod io; #[cfg(feature = "machine")] pub mod machine; #[cfg(feature = "memory")] pub mod memory; #[cfg(feature = "mount")] -pub mod mount_util; +pub mod mount; #[cfg(feature = "murmurhash2")] pub mod murmurhash2; #[cfg(feature = "namespace")] @@ -58,7 +58,7 @@ pub mod os_release; #[cfg(feature = "parse")] pub mod parse; #[cfg(feature = "path_util")] -pub mod path_util; +pub mod path; #[cfg(feature = "process")] pub mod process; #[cfg(feature = "random")] @@ -72,11 +72,11 @@ pub mod sensors; #[cfg(feature = "show_table")] pub mod show_table; #[cfg(feature = "signal")] -pub mod signal_util; +pub mod signal; #[cfg(feature = "socket")] -pub mod socket_util; +pub mod socket; #[cfg(feature = "stat")] -pub mod stat_util; +pub mod stat; #[cfg(feature = "strbuf")] pub mod strbuf; #[cfg(feature = "string")] @@ -84,7 +84,7 @@ pub mod string; #[cfg(feature = "sysfs")] pub mod sysfs; #[cfg(feature = "time_util")] -pub mod time_util; +pub mod time; #[cfg(feature = "unistd")] pub mod unistd; #[cfg(feature = "unit_name")] diff --git a/libs/basic/src/machine.rs b/libs/basic/src/machine.rs index f4551379..a51184a5 100644 --- a/libs/basic/src/machine.rs +++ b/libs/basic/src/machine.rs @@ -13,8 +13,8 @@ //! use crate::{ fs_util, - id128_util::{self, Id128FormatFlag}, - mount_util, namespace, + id128::{self, Id128FormatFlag}, + namespace, }; use libc::syncfs; use log; @@ -357,7 +357,7 @@ pub fn machine_id_commit() -> Result<()> { sync(); - if !mount_util::is_mount_point(etc_machine_id) { + if !crate::mount::is_mount_point(etc_machine_id) { log::debug!("{:?} is not a mount point. Nothing to do.", etc_machine_id); return Ok(()); } @@ -367,7 +367,7 @@ pub fn machine_id_commit() -> Result<()> { return Err(nix::Error::EROFS); } - match id128_util::id128_read_by_path(etc_machine_id, Id128FormatFlag::ID128_FORMAT_PLAIN) { + match id128::id128_read_by_path(etc_machine_id, Id128FormatFlag::ID128_FORMAT_PLAIN) { Ok(id128_string) => id128 = id128_string, Err(e) => { log::error!( @@ -388,7 +388,7 @@ pub fn machine_id_commit() -> Result<()> { return Err(e); } - id128_util::id128_write( + id128::id128_write( etc_machine_id, &true, &id128, @@ -404,7 +404,7 @@ fn generate_machine_id() -> Result { let dbus_machine_id = Path::new("/var/lib/dbus/machine-id"); if let Ok(id128) = - id128_util::id128_read_by_path(dbus_machine_id, Id128FormatFlag::ID128_FORMAT_PLAIN) + id128::id128_read_by_path(dbus_machine_id, Id128FormatFlag::ID128_FORMAT_PLAIN) { log::info!("Initializing machine ID from D-Bus machine ID (/var/lib/dbus/machine-id)."); return Ok(id128); @@ -412,7 +412,7 @@ fn generate_machine_id() -> Result { if process::id() == 1 { if let Ok(id128) = env::var("container_uuid") { - if id128_util::id128_is_valid(&id128.clone().into_bytes()) { + if id128::id128_is_valid(&id128.clone().into_bytes()) { log::info!( "Initializing machine ID from container UUID (process 1's container_uuid)." ); @@ -427,17 +427,17 @@ fn generate_machine_id() -> Result { let idplain: String = id128.chars().take(32).collect(); let idrfc: String = id128.chars().take(36).collect(); - if id128_util::id128_is_valid(&idplain.clone().into_bytes()) { + if id128::id128_is_valid(&idplain.clone().into_bytes()) { log::info!("Initializing machine ID from environ's container UUID (/proc/1/environ's container_uuid)."); return Ok(idplain); - } else if id128_util::id128_is_valid(&idrfc.clone().into_bytes()) { + } else if id128::id128_is_valid(&idrfc.clone().into_bytes()) { log::info!("Initializing machine ID from environ's container UUID (/proc/1/environ's container_uuid)."); return Ok(idrfc); } } } - match id128_util::id128_read_by_path( + match id128::id128_read_by_path( Path::new("/sys/class/dmi/id/product_uuid"), Id128FormatFlag::ID128_FORMAT_UUID, ) { @@ -447,7 +447,7 @@ fn generate_machine_id() -> Result { } Err(e) => { if e.kind() == ErrorKind::NotFound { - if let Ok(id128) = id128_util::id128_read_by_path( + if let Ok(id128) = id128::id128_read_by_path( Path::new("/proc/device-tree/vm,uuid"), Id128FormatFlag::ID128_FORMAT_UUID, ) { @@ -459,7 +459,7 @@ fn generate_machine_id() -> Result { } log::info!("Initializing machine ID from random generator."); - id128_util::id128_randomize(Id128FormatFlag::ID128_FORMAT_PLAIN) + id128::id128_randomize(Id128FormatFlag::ID128_FORMAT_PLAIN) } /// @@ -511,7 +511,7 @@ Booting up is supported only when: if machine_id.is_empty() { if let Ok(id128) = - id128_util::id128_read_by_path(etc_machine_id, Id128FormatFlag::ID128_FORMAT_PLAIN) + id128::id128_read_by_path(etc_machine_id, Id128FormatFlag::ID128_FORMAT_PLAIN) { return Ok(id128); } @@ -527,7 +527,7 @@ Booting up is supported only when: return Err(e); } } else { - id128_util::id128_write( + id128::id128_write( etc_machine_id, &true, &ret_id128, @@ -545,7 +545,7 @@ Booting up is supported only when: umask(Mode::from_bits_truncate(0o0022)).bits() | SFlag::S_IFMT.bits(), ); while saved_umask.contains(SFlag::S_IFMT) { - id128_util::id128_write( + id128::id128_write( run_machine_id, &false, &ret_id128, diff --git a/libs/basic/src/mount_util.rs b/libs/basic/src/mount.rs similarity index 100% rename from libs/basic/src/mount_util.rs rename to libs/basic/src/mount.rs diff --git a/libs/basic/src/path_util.rs b/libs/basic/src/path.rs similarity index 100% rename from libs/basic/src/path_util.rs rename to libs/basic/src/path.rs diff --git a/libs/basic/src/random.rs b/libs/basic/src/random.rs index 32dbd029..b385a818 100644 --- a/libs/basic/src/random.rs +++ b/libs/basic/src/random.rs @@ -64,7 +64,7 @@ pub fn random_bytes(data: &mut [u8]) { log::error!("Failed to open /dev/urandom, err:{}", err); } Ok(mut file) => { - let _ = crate::io_util::loop_read_exact(&mut file, data); + let _ = crate::io::loop_read_exact(&mut file, data); } }; } diff --git a/libs/basic/src/signal_util.rs b/libs/basic/src/signal.rs similarity index 100% rename from libs/basic/src/signal_util.rs rename to libs/basic/src/signal.rs diff --git a/libs/basic/src/socket_util.rs b/libs/basic/src/socket.rs similarity index 100% rename from libs/basic/src/socket_util.rs rename to libs/basic/src/socket.rs diff --git a/libs/basic/src/stat_util.rs b/libs/basic/src/stat.rs similarity index 100% rename from libs/basic/src/stat_util.rs rename to libs/basic/src/stat.rs diff --git a/libs/basic/src/time_util.rs b/libs/basic/src/time.rs similarity index 100% rename from libs/basic/src/time_util.rs rename to libs/basic/src/time.rs diff --git a/libs/device/src/device_monitor.rs b/libs/device/src/device_monitor.rs index 713cb9bd..710578e2 100644 --- a/libs/device/src/device_monitor.rs +++ b/libs/device/src/device_monitor.rs @@ -15,7 +15,7 @@ use crate::{device::Device, error::Error}; use basic::errno_is_transient; use basic::murmurhash2::murmurhash2; -use basic::socket_util::next_datagram_size_fd; +use basic::socket::next_datagram_size_fd; use libc::*; use nix::{ errno::Errno, diff --git a/libs/event/src/timer.rs b/libs/event/src/timer.rs index bd2e4490..68133cb2 100644 --- a/libs/event/src/timer.rs +++ b/libs/event/src/timer.rs @@ -17,7 +17,7 @@ use std::{ }; use crate::{EventType, Source}; -use basic::time_util::{NSEC_PER_SEC, NSEC_PER_USEC, USEC_INFINITY, USEC_PER_SEC}; +use basic::time::{NSEC_PER_SEC, NSEC_PER_USEC, USEC_INFINITY, USEC_PER_SEC}; #[derive(Debug, Clone, Copy)] pub(crate) struct Timestamp { -- Gitee From 257c16fc64075d23ffc4b4b3e14daf78d83af7d8 Mon Sep 17 00:00:00 2001 From: overweight Date: Tue, 2 Jan 2024 17:04:20 +0800 Subject: [PATCH 3/3] refactor: crate libs/basic --- core/coms/mount/src/manager.rs | 2 +- core/coms/mount/src/mng.rs | 2 +- core/coms/mount/src/rentry.rs | 2 +- core/coms/service/src/mng.rs | 8 ++++---- core/coms/service/src/rentry.rs | 4 ++-- core/coms/service/src/spawn.rs | 4 ++-- core/coms/socket/src/config.rs | 4 ++-- core/coms/socket/src/port.rs | 8 ++++---- core/coms/socket/src/rentry.rs | 7 +++---- core/libcore/src/exec/base.rs | 2 +- core/libcore/src/exec/cmd.rs | 4 ++-- core/libcore/src/serialize.rs | 2 +- core/sysmaster/src/manager/commands.rs | 6 +++--- core/sysmaster/src/manager/mod.rs | 2 +- core/sysmaster/src/manager/pre_install.rs | 10 +++++----- core/sysmaster/src/mount/setup.rs | 6 +++--- core/sysmaster/src/unit/entry/uentry.rs | 2 +- core/sysmaster/src/unit/execute/spawn.rs | 10 +++++----- core/sysmaster/src/unit/manager.rs | 8 ++++---- core/sysmaster/src/unit/notify.rs | 4 ++-- core/sysmaster/src/unit/test/mod.rs | 2 +- core/sysmaster/src/unit/uload.rs | 2 +- core/sysmaster/src/unit/util/unit_file.rs | 7 +++---- exts/devmaster/src/bin/devctl/subcmds/info.rs | 2 +- exts/devmaster/src/lib/framework/job_queue.rs | 2 +- exts/devmaster/src/lib/rules/exec_mgr.rs | 2 +- exts/devmaster/src/lib/rules/node.rs | 8 ++++---- exts/devmaster/src/lib/rules/rules_load.rs | 2 +- exts/getty-generator/src/main.rs | 2 +- libs/basic/src/condition.rs | 7 +++---- libs/basic/src/{fd_util.rs => fd.rs} | 2 +- libs/basic/src/{fs_util.rs => fs.rs} | 0 libs/basic/src/lib.rs | 4 ++-- libs/basic/src/machine.rs | 3 +-- libs/basic/src/mount.rs | 2 +- libs/basic/src/process.rs | 6 +++--- libs/device/src/device.rs | 6 +++--- libs/hwdb/src/sd_hwdb.rs | 4 ++-- 38 files changed, 78 insertions(+), 82 deletions(-) rename libs/basic/src/{fd_util.rs => fd.rs} (99%) rename libs/basic/src/{fs_util.rs => fs.rs} (100%) diff --git a/core/coms/mount/src/manager.rs b/core/coms/mount/src/manager.rs index fbcb5d3e..ab8f3039 100644 --- a/core/coms/mount/src/manager.rs +++ b/core/coms/mount/src/manager.rs @@ -12,7 +12,7 @@ #[cfg(feature = "plugin")] use crate::base::PLUGIN_NAME; -use basic::fs_util::is_path; +use basic::fs::is_path; #[cfg(feature = "plugin")] use constants::LOG_FILE_PATH; diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index 24288b79..9de72d0c 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -11,7 +11,7 @@ // See the Mulan PSL v2 for more details. //! The core logic of the mount subclass -use basic::fs_util::{directory_is_empty, mkdir_p_label}; +use basic::fs::{directory_is_empty, mkdir_p_label}; use basic::mount::filter_options; use basic::time::USEC_PER_SEC; use basic::{MOUNT_BIN, UMOUNT_BIN}; diff --git a/core/coms/mount/src/rentry.rs b/core/coms/mount/src/rentry.rs index db07447e..fa4508e7 100644 --- a/core/coms/mount/src/rentry.rs +++ b/core/coms/mount/src/rentry.rs @@ -242,7 +242,7 @@ pub struct SectionMount { pub Group: String, #[entry(default = String::from("0022"))] pub UMask: String, - #[entry(parser = basic::fs_util::parse_pathbuf)] + #[entry(parser = basic::fs::parse_pathbuf)] pub RootDirectory: Option, #[entry(default = WorkingDirectory::default(), parser = core::exec::parse_working_directory)] pub WorkingDirectory: WorkingDirectory, diff --git a/core/coms/service/src/mng.rs b/core/coms/service/src/mng.rs index eaf54694..65faeb37 100644 --- a/core/coms/service/src/mng.rs +++ b/core/coms/service/src/mng.rs @@ -20,8 +20,8 @@ use super::rentry::{ }; use super::spawn::ServiceSpawn; use crate::rentry::{ExitStatus, NotifyAccess}; -use basic::{do_entry_log, fd_util, IN_SET}; -use basic::{fs_util, process}; +use basic::{do_entry_log, fd, IN_SET}; +use basic::{fs, process}; use core::error::*; use core::exec::{ExecCommand, ExecContext, ExecFlag, ExecFlags, PreserveMode}; use core::rel::ReStation; @@ -1046,7 +1046,7 @@ impl ServiceMng { }); } - let pid = match fs_util::read_first_line(pid_file_path) { + let pid = match fs::read_first_line(pid_file_path) { Ok(line) => line.trim().parse::(), Err(e) => { return Err(Error::Parse { @@ -2307,7 +2307,7 @@ impl PathInotify { } fn unwatch(&self) { - fd_util::close(*self.inotify.borrow()); + fd::close(*self.inotify.borrow()); *self.inotify.borrow_mut() = -1; } diff --git a/core/coms/service/src/rentry.rs b/core/coms/service/src/rentry.rs index bcdc4d45..bc1acccc 100644 --- a/core/coms/service/src/rentry.rs +++ b/core/coms/service/src/rentry.rs @@ -13,7 +13,7 @@ #![allow(non_snake_case)] use crate::monitor::ServiceMonitor; -use basic::fs_util::{path_is_abosolute, path_length_is_valid, path_name_is_safe, path_simplify}; +use basic::fs::{path_is_abosolute, path_length_is_valid, path_name_is_safe, path_simplify}; use core::exec::PreserveMode; use macros::{EnumDisplay, UnitSection}; use nix::sys::signal::Signal; @@ -292,7 +292,7 @@ pub struct SectionService { pub Group: String, #[entry(default = String::from("0022"))] pub UMask: String, - #[entry(parser = basic::fs_util::parse_pathbuf)] + #[entry(parser = basic::fs::parse_pathbuf)] pub RootDirectory: Option, #[entry(default = WorkingDirectory::default(), parser = core::exec::parse_working_directory)] pub WorkingDirectory: WorkingDirectory, diff --git a/core/coms/service/src/spawn.rs b/core/coms/service/src/spawn.rs index f28278b6..fce52942 100644 --- a/core/coms/service/src/spawn.rs +++ b/core/coms/service/src/spawn.rs @@ -16,7 +16,7 @@ use super::comm::ServiceUnitComm; use super::config::ServiceConfig; use super::pid::ServicePid; use super::rentry::ServiceType; -use basic::fd_util; +use basic::fd; use core::error::*; use core::exec::{ExecCommand, ExecContext, ExecFlags, ExecParameters}; use nix::unistd::Pid; @@ -141,7 +141,7 @@ impl ServiceSpawn { } pub(super) fn release_socket_fd(&self, fd: i32) { - fd_util::close(fd); + fd::close(fd); *self.socket_fd.borrow_mut() = -1; } } diff --git a/core/coms/socket/src/config.rs b/core/coms/socket/src/config.rs index 11b4b07a..011b5a56 100644 --- a/core/coms/socket/src/config.rs +++ b/core/coms/socket/src/config.rs @@ -16,7 +16,7 @@ use super::comm::SocketUnitComm; use super::rentry::{PortType, SectionSocket, SocketCommand}; use crate::base::NetlinkProtocol; -use basic::fd_util; +use basic::fd; use core::error::*; use core::exec::ExecCommand; use core::rel::ReStation; @@ -427,7 +427,7 @@ impl SocketPortConf { Ok(v) => v, }; let st = fstat(fd)?; - if !fd_util::stat_is_reg(st.st_mode) && !fd_util::stat_is_char(st.st_mode) { + if !fd::stat_is_reg(st.st_mode) && !fd::stat_is_char(st.st_mode) { return Err(Errno::EEXIST); } Ok(fd) diff --git a/core/coms/socket/src/port.rs b/core/coms/socket/src/port.rs index fbc68c5d..163f7981 100644 --- a/core/coms/socket/src/port.rs +++ b/core/coms/socket/src/port.rs @@ -18,7 +18,7 @@ use crate::{ config::{SocketConfig, SocketPortConf}, rentry::PortType, }; -use basic::{fd_util, io}; +use basic::{fd, io}; use nix::unistd::{Gid, Uid}; use nix::{ errno::Errno, @@ -142,7 +142,7 @@ impl SocketPort { } } - fd_util::close(fd); + fd::close(fd); log::debug!("Successfully closed socket {}", self.p_conf.listen()); self.set_fd(INVALID_FD); } @@ -189,7 +189,7 @@ impl SocketPort { } Ok(v) => v, }; - fd_util::close(cfd); + fd::close(cfd); } } Ok(()) @@ -299,7 +299,7 @@ impl SocketPort { let target = self.listen(); for symlink in &config.borrow().Socket.Symlinks { let symlink_str = symlink.to_str().unwrap(); - if let Err(e) = basic::fs_util::symlink(target, symlink_str, false) { + if let Err(e) = basic::fs::symlink(target, symlink_str, false) { let unit_name = match self.comm.owner() { None => "null".to_string(), Some(v) => v.id().to_string(), diff --git a/core/coms/socket/src/rentry.rs b/core/coms/socket/src/rentry.rs index 1886f970..1de3231e 100644 --- a/core/coms/socket/src/rentry.rs +++ b/core/coms/socket/src/rentry.rs @@ -32,11 +32,10 @@ const RELI_LAST_KEY: u32 = 0; // singleton fn parse_pathbuf_vec(s: &str) -> Result, core::error::Error> { let mut res = Vec::new(); for v in s.split_ascii_whitespace() { - let path = basic::fs_util::parse_absolute_path(v).map_err(|_| { - core::error::Error::ConfigureError { + let path = + basic::fs::parse_absolute_path(v).map_err(|_| core::error::Error::ConfigureError { msg: "Invalid PathBuf".to_string(), - } - })?; + })?; res.push(PathBuf::from(path)); } Ok(res) diff --git a/core/libcore/src/exec/base.rs b/core/libcore/src/exec/base.rs index 134a8c04..4f885663 100644 --- a/core/libcore/src/exec/base.rs +++ b/core/libcore/src/exec/base.rs @@ -11,7 +11,7 @@ // See the Mulan PSL v2 for more details. use crate::error::*; -use basic::fs_util::{path_is_abosolute, path_length_is_valid, path_name_is_safe, path_simplify}; +use basic::fs::{path_is_abosolute, path_length_is_valid, path_name_is_safe, path_simplify}; use basic::rlimit; use bitflags::bitflags; use libc::EPERM; diff --git a/core/libcore/src/exec/cmd.rs b/core/libcore/src/exec/cmd.rs index af1fb7d9..b5b80830 100644 --- a/core/libcore/src/exec/cmd.rs +++ b/core/libcore/src/exec/cmd.rs @@ -14,8 +14,8 @@ use crate::serialize::DeserializeWith; use crate::specifier::{ unit_string_specifier_escape, unit_strings_specifier_escape, UnitSpecifierData, }; -use basic::fs_util::{path_is_abosolute, path_simplify}; -use basic::{fs_util::parse_absolute_path, Error, Result}; +use basic::fs::{path_is_abosolute, path_simplify}; +use basic::{fs::parse_absolute_path, Error, Result}; use bitflags::bitflags; use serde::{ de::{self, Unexpected}, diff --git a/core/libcore/src/serialize.rs b/core/libcore/src/serialize.rs index 0fe40783..7e5dfced 100644 --- a/core/libcore/src/serialize.rs +++ b/core/libcore/src/serialize.rs @@ -13,7 +13,7 @@ //! use std::path::PathBuf; -use basic::fs_util::parse_absolute_path; +use basic::fs::parse_absolute_path; use serde::{ de::{self, Unexpected}, Deserialize, Deserializer, diff --git a/core/sysmaster/src/manager/commands.rs b/core/sysmaster/src/manager/commands.rs index a9f06b95..279eae58 100644 --- a/core/sysmaster/src/manager/commands.rs +++ b/core/sysmaster/src/manager/commands.rs @@ -11,7 +11,7 @@ // See the Mulan PSL v2 for more details. use basic::do_entry_log; -use basic::fs_util::{self, is_symlink}; +use basic::fs::{self, is_symlink}; use cmdproto::proto::execute::ExecuterAction; use cmdproto::proto::ProstServerStream; use core::rel::{ReliLastFrame, Reliability}; @@ -41,7 +41,7 @@ where let sctl_socket_path = Path::new(SCTL_SOCKET); let run_sysmaster = sctl_socket_path.parent().unwrap(); if run_sysmaster.exists() { - let _ = fs_util::chmod("/run/sysmaster", 0o755); + let _ = fs::chmod("/run/sysmaster", 0o755); } /* remove the old socket if it exists */ if sctl_socket_path.exists() && !is_symlink(sctl_socket_path) { @@ -97,7 +97,7 @@ where Ok(_) => (), Err(e) => log::error!("Commands failed: {:?}", e), } - basic::fd_util::close(client); + basic::fd::close(client); 0 } } diff --git a/core/sysmaster/src/manager/mod.rs b/core/sysmaster/src/manager/mod.rs index e93673f2..4483ba36 100644 --- a/core/sysmaster/src/manager/mod.rs +++ b/core/sysmaster/src/manager/mod.rs @@ -25,7 +25,7 @@ pub(crate) mod signals; use self::config::ManagerConfig; use crate::unit::UnitManagerX; use alive_timer::AliveTimer; -use basic::fs_util::LookupPaths; +use basic::fs::LookupPaths; use basic::process::{self}; use basic::{CGROUP_SYSMASTER, MULTI_USER_TARGET}; use cgroup::CgController; diff --git a/core/sysmaster/src/manager/pre_install.rs b/core/sysmaster/src/manager/pre_install.rs index ad0f17d7..69823478 100644 --- a/core/sysmaster/src/manager/pre_install.rs +++ b/core/sysmaster/src/manager/pre_install.rs @@ -12,8 +12,8 @@ // #![allow(non_snake_case)] use crate::unit::{unit_name_to_type, UeConfigInstall, UnitType}; -use basic::fs_util::is_symlink; -use basic::fs_util::LookupPaths; +use basic::fs::is_symlink; +use basic::fs::LookupPaths; use bitflags::bitflags; use core::error::*; use nix::unistd::UnlinkatFlags; @@ -311,7 +311,7 @@ impl InstallContext { let source = install.path(); for symlink in symlinks { let target = format!("{}/{}", target_path, symlink); - if let Err(e) = basic::fs_util::symlink(&source, &target, false) { + if let Err(e) = basic::fs::symlink(&source, &target, false) { log::warn!("Failed to create symlink {} -> {}: {}", &target, &source, e); continue; } @@ -346,7 +346,7 @@ impl InstallContext { } } - if let Err(e) = basic::fs_util::symlink(&source, &target, false) { + if let Err(e) = basic::fs::symlink(&source, &target, false) { log::warn!("Failed to create symlink {} -> {}: {}", &target, &source, e); continue; } @@ -731,7 +731,7 @@ impl Install { #[cfg(test)] mod test { use super::{Install, PresetAction, PresetMode, PresetRule, Presets}; - use basic::fs_util::LookupPaths; + use basic::fs::LookupPaths; use std::rc::Rc; #[test] diff --git a/core/sysmaster/src/mount/setup.rs b/core/sysmaster/src/mount/setup.rs index 1938ec10..7dad6116 100644 --- a/core/sysmaster/src/mount/setup.rs +++ b/core/sysmaster/src/mount/setup.rs @@ -377,7 +377,7 @@ impl MountPoint { } fn invalid_mount_point(&self, flags: AtFlags) -> Result { - if basic::fs_util::path_equal(&self.target, "/") { + if basic::fs::path_equal(&self.target, "/") { return Ok(true); } @@ -385,7 +385,7 @@ impl MountPoint { // symlink let path = Path::new(&self.target); - let file = basic::fs_util::open_parent( + let file = basic::fs::open_parent( path, OFlag::O_PATH | OFlag::O_CLOEXEC, Mode::from_bits(0).unwrap(), @@ -518,7 +518,7 @@ fn pair_controller(controller: &str) -> Option { fn symlink_controller(source: String, alias: String) -> Result<()> { let target_path = Path::new(CG_BASE_DIR).join(alias); let target = target_path.to_str().unwrap(); - match basic::fs_util::symlink(&source, target, false) { + match basic::fs::symlink(&source, target, false) { Ok(()) => Ok(()), Err(basic::Error::Nix { source: Errno::EEXIST, diff --git a/core/sysmaster/src/unit/entry/uentry.rs b/core/sysmaster/src/unit/entry/uentry.rs index f6ba2e0a..975ad7f4 100644 --- a/core/sysmaster/src/unit/entry/uentry.rs +++ b/core/sysmaster/src/unit/entry/uentry.rs @@ -828,7 +828,7 @@ mod tests { use crate::manager::RELI_HISTORY_MAX_DBS; use crate::unit::rentry::UnitRe; use crate::unit::test::test_utils::UmIfD; - use basic::fs_util::LookupPaths; + use basic::fs::LookupPaths; use core::rel::{ReliConf, Reliability}; use core::unit::UnitType; use std::rc::Rc; diff --git a/core/sysmaster/src/unit/execute/spawn.rs b/core/sysmaster/src/unit/execute/spawn.rs index 01651289..d603cac9 100644 --- a/core/sysmaster/src/unit/execute/spawn.rs +++ b/core/sysmaster/src/unit/execute/spawn.rs @@ -11,7 +11,7 @@ // See the Mulan PSL v2 for more details. use super::super::entry::Unit; -use basic::fd_util; +use basic::fd; use core::error::*; use core::exec::{ExecCommand, ExecContext, ExecFlags, ExecParameters, WorkingDirectory}; use nix::fcntl::FcntlArg; @@ -369,7 +369,7 @@ fn close_all_fds(fds: &[i32]) -> bool { continue; } - fd_util::close(fd); + fd::close(fd); } true } @@ -389,7 +389,7 @@ fn shift_fds(fds: &mut [i32]) -> bool { Ok(v) => v, }; - fd_util::close(fds[i as usize]); + fd::close(fds[i as usize]); fds[i as usize] = nfd; @@ -411,11 +411,11 @@ fn shift_fds(fds: &mut [i32]) -> bool { fn flags_fds(fds: &mut Vec, nonblock: bool) -> bool { for fd in fds { - if fd_util::fd_nonblock(*fd, nonblock).is_err() { + if fd::fd_nonblock(*fd, nonblock).is_err() { return false; } - if fd_util::fd_cloexec(*fd, false).is_err() { + if fd::fd_cloexec(*fd, false).is_err() { return false; } } diff --git a/core/sysmaster/src/unit/manager.rs b/core/sysmaster/src/unit/manager.rs index 824ff6e4..e6bce710 100644 --- a/core/sysmaster/src/unit/manager.rs +++ b/core/sysmaster/src/unit/manager.rs @@ -34,7 +34,7 @@ use crate::manager::pre_install::{Install, PresetMode}; use crate::manager::State; use crate::unit::data::{DataManager, UnitState}; use crate::utils::table::{TableOp, TableSubscribe}; -use basic::fs_util::LookupPaths; +use basic::fs::LookupPaths; use basic::show_table::{CellColor, ShowTable}; use basic::{machine, process, rlimit, signal}; use constants::SIG_SWITCH_ROOT_OFFSET; @@ -206,9 +206,9 @@ impl UnitManagerX { pub(crate) fn mask_unit(&self, unit_file: &str) -> Result<()> { log::info!("Masking unit {}.", unit_file); - let link_name_path = std::path::Path::new(basic::fs_util::ETC_SYSTEM_PATH).join(unit_file); + let link_name_path = std::path::Path::new(basic::fs::ETC_SYSTEM_PATH).join(unit_file); let target_path = std::path::Path::new("/dev/null"); - basic::fs_util::symlink( + basic::fs::symlink( target_path.to_str().unwrap(), link_name_path.to_str().unwrap(), false, @@ -218,7 +218,7 @@ impl UnitManagerX { pub(crate) fn unmask_unit(&self, unit_file: &str) -> Result<()> { log::info!("Unmasking unit {}.", unit_file); - let link_name_path = std::path::Path::new(basic::fs_util::ETC_SYSTEM_PATH).join(unit_file); + let link_name_path = std::path::Path::new(basic::fs::ETC_SYSTEM_PATH).join(unit_file); if !link_name_path.exists() { return Ok(()); } diff --git a/core/sysmaster/src/unit/notify.rs b/core/sysmaster/src/unit/notify.rs index 517586e7..fff80ce4 100644 --- a/core/sysmaster/src/unit/notify.rs +++ b/core/sysmaster/src/unit/notify.rs @@ -14,7 +14,7 @@ use super::datastore::UnitDb; use super::entry::UnitX; use super::rentry::UnitRe; use crate::job::JobManager; -use basic::fd_util; +use basic::fd; use core::error::*; use core::rel::{ReStation, ReliLastFrame, Reliability}; use event::{EventState, EventType, Events, Source}; @@ -294,7 +294,7 @@ fn notify_peek_pid(fd: RawFd, flags: MsgFlags) -> Result { // get message information let (received_cred, received_fds) = notify_trans_recvmsg(&msgs); for fd in received_fds.iter() { - fd_util::close(*fd); + fd::close(*fd); } // check diff --git a/core/sysmaster/src/unit/test/mod.rs b/core/sysmaster/src/unit/test/mod.rs index 70c5aa2f..0ddf0b25 100644 --- a/core/sysmaster/src/unit/test/mod.rs +++ b/core/sysmaster/src/unit/test/mod.rs @@ -22,7 +22,7 @@ pub(crate) mod test_utils { util::{self, UnitFile}, }, }; - use basic::fs_util::LookupPaths; + use basic::fs::LookupPaths; use core::rel::Reliability; use core::unit::UmIf; pub(crate) struct UmIfD; diff --git a/core/sysmaster/src/unit/uload.rs b/core/sysmaster/src/unit/uload.rs index ff454dd4..6ae470f9 100644 --- a/core/sysmaster/src/unit/uload.rs +++ b/core/sysmaster/src/unit/uload.rs @@ -19,7 +19,7 @@ use super::runtime::UnitRT; use super::util::UnitFile; use super::util::{self}; use crate::utils::table::{TableOp, TableSubscribe}; -use basic::fs_util::LookupPaths; +use basic::fs::LookupPaths; use core::unit::{unit_name_is_valid, UnitNameFlags, UnitType}; use std::cell::RefCell; use std::rc::{Rc, Weak}; diff --git a/core/sysmaster/src/unit/util/unit_file.rs b/core/sysmaster/src/unit/util/unit_file.rs index ef623edc..127cdeda 100644 --- a/core/sysmaster/src/unit/util/unit_file.rs +++ b/core/sysmaster/src/unit/util/unit_file.rs @@ -10,9 +10,8 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -use basic::fs_util; -use basic::fs_util::is_symlink; -use basic::fs_util::LookupPaths; +use basic::fs::is_symlink; +use basic::fs::LookupPaths; use core::unit::unit_name_is_valid; use core::unit::UnitNameFlags; use siphasher::sip::SipHasher24; @@ -177,7 +176,7 @@ impl UnitFileData { } let file_name = de.file_name().unwrap().to_string_lossy().to_string(); - let target_path = match fs_util::chase_symlink(&de) { + let target_path = match basic::fs::chase_symlink(&de) { Err(e) => { log::debug!("Failed to get the symlink of {:?}: {}, ignoring.", de, e); continue; diff --git a/exts/devmaster/src/bin/devctl/subcmds/info.rs b/exts/devmaster/src/bin/devctl/subcmds/info.rs index 1129fc6a..4f9585cc 100644 --- a/exts/devmaster/src/bin/devctl/subcmds/info.rs +++ b/exts/devmaster/src/bin/devctl/subcmds/info.rs @@ -14,7 +14,7 @@ use crate::subcmds::utils; use crate::Result; -use basic::fd_util::{dot_or_dot_dot, xopendirat}; +use basic::fd::{dot_or_dot_dot, xopendirat}; use device::{device_enumerator::DeviceEnumerator, Device}; use nix::dir::Dir; use nix::fcntl::{AtFlags, OFlag}; diff --git a/exts/devmaster/src/lib/framework/job_queue.rs b/exts/devmaster/src/lib/framework/job_queue.rs index e488f480..9037df17 100644 --- a/exts/devmaster/src/lib/framework/job_queue.rs +++ b/exts/devmaster/src/lib/framework/job_queue.rs @@ -13,7 +13,7 @@ //! job queue //! use crate::{error::*, framework::*}; -use basic::fs_util::touch_file; +use basic::fs::touch_file; use device::device::Device; use event::Events; use nix::unistd::unlink; diff --git a/exts/devmaster/src/lib/rules/exec_mgr.rs b/exts/devmaster/src/lib/rules/exec_mgr.rs index ba9015e9..22b9a2ad 100644 --- a/exts/devmaster/src/lib/rules/exec_mgr.rs +++ b/exts/devmaster/src/lib/rules/exec_mgr.rs @@ -26,7 +26,7 @@ use crate::{ rules::*, utils::{commons::*, spawn::*}, }; -use basic::{fs_util::write_string_file, naming_scheme::*, parse::parse_mode, unistd::*}; +use basic::{fs::write_string_file, naming_scheme::*, parse::parse_mode, unistd::*}; use device::{Device, DeviceAction}; use fnmatch_sys::fnmatch; use libc::{gid_t, mode_t, uid_t}; diff --git a/exts/devmaster/src/lib/rules/node.rs b/exts/devmaster/src/lib/rules/node.rs index 830801ad..a6ac9adc 100644 --- a/exts/devmaster/src/lib/rules/node.rs +++ b/exts/devmaster/src/lib/rules/node.rs @@ -33,9 +33,9 @@ //! directory, the directory will be removed. use crate::{error::*, log_dev, log_dev_option}; -use basic::fs_util::{chmod, path_simplify}; -use basic::fs_util::{fchmod_and_chown, futimens_opath, symlink}; -use basic::{fd_util::xopendirat, fs_util::remove_dir_until}; +use basic::fs::{chmod, path_simplify}; +use basic::fs::{fchmod_and_chown, futimens_opath, symlink}; +use basic::{fd::xopendirat, fs::remove_dir_until}; use cluFlock::ExclusiveFlock; use device::Device; use libc::{mode_t, S_IFBLK, S_IFCHR, S_IFLNK, S_IFMT}; @@ -678,7 +678,7 @@ pub(crate) fn cleanup_prior_dir() -> Result<()> { #[cfg(test)] mod test { use super::*; - use basic::fs_util::{is_symlink, touch_file}; + use basic::fs::{is_symlink, touch_file}; use device::device_enumerator::*; use device::utils::LoopDev; use nix::unistd::unlink; diff --git a/exts/devmaster/src/lib/rules/rules_load.rs b/exts/devmaster/src/lib/rules/rules_load.rs index 49da2d63..438e812f 100644 --- a/exts/devmaster/src/lib/rules/rules_load.rs +++ b/exts/devmaster/src/lib/rules/rules_load.rs @@ -1725,7 +1725,7 @@ impl RuleToken { #[cfg(test)] pub(crate) mod tests { - use basic::fs_util::touch_file; + use basic::fs::touch_file; use log::init_log; use log::Level; diff --git a/exts/getty-generator/src/main.rs b/exts/getty-generator/src/main.rs index dbb0ad13..e99bf6bf 100644 --- a/exts/getty-generator/src/main.rs +++ b/exts/getty-generator/src/main.rs @@ -387,7 +387,7 @@ fn create_getty(tty_type: &str, tty: &str) -> io::Result<()> { } fn concat_from_symlink(file_name: &str) -> String { - basic::fs_util::LIB_SYSTEM_PATH.to_string() + "/" + file_name + basic::fs::LIB_SYSTEM_PATH.to_string() + "/" + file_name } fn concat_to_symlink(file_name: &str) -> String { diff --git a/libs/basic/src/condition.rs b/libs/basic/src/condition.rs index 3ee5c508..43c8bd7a 100644 --- a/libs/basic/src/condition.rs +++ b/libs/basic/src/condition.rs @@ -22,8 +22,7 @@ use nix::{ use libc::{glob, glob_t, GLOB_NOSORT}; use crate::{ - cmdline, fd_util, fs_util::directory_is_not_empty, mount::is_mount_point, security, - sysfs::SysFs, unistd, + cmdline, fd, fs::directory_is_not_empty, mount::is_mount_point, security, sysfs::SysFs, unistd, }; #[cfg(target_env = "musl")] @@ -209,7 +208,7 @@ impl Condition { } Ok(v) => v, }; - (fd_util::stat_is_reg(s.st_mode) && (s.st_mode & 111 > 0)) as i8 + (fd::stat_is_reg(s.st_mode) && (s.st_mode & 111 > 0)) as i8 } fn test_file_not_empty(&self) -> i8 { @@ -386,7 +385,7 @@ mod test { use super::{Condition, ConditionType}; use crate::{ cmdline, - fs_util::write_string_file, + fs::write_string_file, security::{self}, }; use core::panic; diff --git a/libs/basic/src/fd_util.rs b/libs/basic/src/fd.rs similarity index 99% rename from libs/basic/src/fd_util.rs rename to libs/basic/src/fd.rs index e5ef9f6a..41bbbcfd 100644 --- a/libs/basic/src/fd_util.rs +++ b/libs/basic/src/fd.rs @@ -194,7 +194,7 @@ pub fn dot_or_dot_dot(name: &str) -> bool { } #[cfg(test)] mod tests { - use crate::fd_util::{stat_is_char, stat_is_reg}; + use crate::fd::{stat_is_char, stat_is_reg}; use nix::{ fcntl::{open, OFlag}, sys::stat::{fstat, Mode}, diff --git a/libs/basic/src/fs_util.rs b/libs/basic/src/fs.rs similarity index 100% rename from libs/basic/src/fs_util.rs rename to libs/basic/src/fs.rs diff --git a/libs/basic/src/lib.rs b/libs/basic/src/lib.rs index df273288..ba5ad435 100644 --- a/libs/basic/src/lib.rs +++ b/libs/basic/src/lib.rs @@ -30,9 +30,9 @@ pub mod disk; #[cfg(feature = "exec")] pub mod exec; #[cfg(feature = "fd")] -pub mod fd_util; +pub mod fd; #[cfg(feature = "fs")] -pub mod fs_util; +pub mod fs; #[cfg(feature = "host")] pub mod host; #[cfg(feature = "id128")] diff --git a/libs/basic/src/machine.rs b/libs/basic/src/machine.rs index a51184a5..c8b5f1ca 100644 --- a/libs/basic/src/machine.rs +++ b/libs/basic/src/machine.rs @@ -12,7 +12,6 @@ //! use crate::{ - fs_util, id128::{self, Id128FormatFlag}, namespace, }; @@ -362,7 +361,7 @@ pub fn machine_id_commit() -> Result<()> { return Ok(()); } - if !fs_util::check_filesystem(etc_machine_id, statfs::FsType(libc::TMPFS_MAGIC as FsTypeT)) { + if !crate::fs::check_filesystem(etc_machine_id, statfs::FsType(libc::TMPFS_MAGIC as FsTypeT)) { log::error!("{:?} is not on a temporary file system.", etc_machine_id); return Err(nix::Error::EROFS); } diff --git a/libs/basic/src/mount.rs b/libs/basic/src/mount.rs index 9666e751..371a07c4 100644 --- a/libs/basic/src/mount.rs +++ b/libs/basic/src/mount.rs @@ -20,7 +20,7 @@ use std::{ use crate::{ error::*, - fs_util::{chase_symlink, is_symlink}, + fs::{chase_symlink, is_symlink}, }; use nix::{ fcntl::AtFlags, diff --git a/libs/basic/src/process.rs b/libs/basic/src/process.rs index 638eafdd..c6f75c5d 100644 --- a/libs/basic/src/process.rs +++ b/libs/basic/src/process.rs @@ -12,7 +12,7 @@ //! use crate::error::*; -use crate::fs_util; +use crate::fs; use nix::errno::errno; use nix::errno::Errno; use nix::libc::{kill, ESRCH}; @@ -36,7 +36,7 @@ pub fn process_state(pid: Pid) -> Result { let proc_file = format!("/proc/{:?}/stat", pid.as_raw()); let stat_path = Path::new(&proc_file); - let first_line = fs_util::read_first_line(stat_path)?; + let first_line = fs::read_first_line(stat_path)?; let stat: Vec = first_line .split_whitespace() .map(|s| s.to_string()) @@ -234,7 +234,7 @@ fn is_kernel_thread(pid: Pid) -> Result { }); } - let first_line = fs_util::read_first_line(Path::new(&format!("/proc/{}/stat", pid.as_raw())))?; + let first_line = fs::read_first_line(Path::new(&format!("/proc/{}/stat", pid.as_raw())))?; let stat: Vec = first_line .split_whitespace() .map(|s| s.to_string()) diff --git a/libs/device/src/device.rs b/libs/device/src/device.rs index acff9f39..2d8dc1e5 100644 --- a/libs/device/src/device.rs +++ b/libs/device/src/device.rs @@ -14,7 +14,7 @@ //! use crate::utils::readlink_value; use crate::{error::*, DeviceAction}; -use basic::fs_util::{chmod, open_temporary, touch_file}; +use basic::fs::{chmod, open_temporary, touch_file}; use basic::parse::{device_path_parse_devnum, parse_devnum, parse_ifindex}; use basic::string::fnmatch_or_empty; use basic::uuid::{randomize, Uuid}; @@ -1221,7 +1221,7 @@ impl Device { } } - let file2 = basic::fd_util::fd_reopen(file.as_raw_fd(), oflags).context(Basic { + let file2 = basic::fd::fd_reopen(file.as_raw_fd(), oflags).context(Basic { msg: format!("failed to open {}", file.as_raw_fd()), })?; @@ -1229,7 +1229,7 @@ impl Device { return Ok(file2); } - let q = basic::fd_util::fd_get_diskseq(file2.as_raw_fd()).context(Basic { + let q = basic::fd::fd_get_diskseq(file2.as_raw_fd()).context(Basic { msg: format!("failed to get diskseq on fd {}", file2.as_raw_fd()), })?; diff --git a/libs/hwdb/src/sd_hwdb.rs b/libs/hwdb/src/sd_hwdb.rs index 9d4bb5a1..69c64b41 100644 --- a/libs/hwdb/src/sd_hwdb.rs +++ b/libs/hwdb/src/sd_hwdb.rs @@ -1,4 +1,4 @@ -use basic::{fd_util, unistd::timespec_load}; +use basic::{fd, unistd::timespec_load}; use constants::INVALID_FD; use glob::Pattern; use linked_hash_map::LinkedHashMap; @@ -674,7 +674,7 @@ fn hwdb_new(path: &str) -> Result { log::error!("File{:?} is too short", hwdb_path); return Err(Errno::EIO); } - if fd_util::file_offset_beyond_memory_size(hwdb_st.st_size) { + if fd::file_offset_beyond_memory_size(hwdb_st.st_size) { log::error!("File {:?} is too long", hwdb_path); return Err(Errno::EFBIG); } -- Gitee