From 41434b5a4a115ffe10332488744cde711fbea9d2 Mon Sep 17 00:00:00 2001 From: licunlong Date: Fri, 1 Dec 2023 10:37:43 +0800 Subject: [PATCH 1/8] feature: enable start a mount --- Cargo.lock | 1 + core/coms/mount/Cargo.toml | 4 +- core/coms/mount/src/comm.rs | 2 +- core/coms/mount/src/config.rs | 116 ++++++++ core/coms/mount/src/lib.rs | 2 + core/coms/mount/src/mng.rs | 163 ++++++++--- core/coms/mount/src/rentry.rs | 59 +++- core/coms/mount/src/spawn.rs | 55 ++++ core/coms/mount/src/unit.rs | 79 +++++- core/coms/service/src/mng.rs | 4 +- core/coms/service/src/rentry.rs | 335 +++-------------------- core/coms/socket/src/rentry.rs | 14 +- core/libcore/src/exec/base.rs | 255 ++++++++++++++++- core/libcore/src/exec/cmd.rs | 26 +- core/libcore/src/exec/mod.rs | 5 +- core/sysmaster/src/unit/entry/uentry.rs | 6 - core/sysmaster/src/unit/execute/spawn.rs | 2 +- libs/basic/src/condition.rs | 17 +- libs/basic/src/fs_util.rs | 61 +++++ libs/basic/src/mount_util.rs | 15 + 20 files changed, 841 insertions(+), 380 deletions(-) create mode 100644 core/coms/mount/src/config.rs create mode 100644 core/coms/mount/src/spawn.rs diff --git a/Cargo.lock b/Cargo.lock index 1310ad7b..60c6b30e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1132,6 +1132,7 @@ dependencies = [ "nix 0.24.3", "once_cell", "serde", + "unit_parser", ] [[package]] diff --git a/core/coms/mount/Cargo.toml b/core/coms/mount/Cargo.toml index 037966ff..80f336a9 100644 --- a/core/coms/mount/Cargo.toml +++ b/core/coms/mount/Cargo.toml @@ -18,6 +18,7 @@ event = { path = "../../../libs/event" } log = { path = "../../../libs/log" } macros = { path = "../../../libs/macros" } constants = { path = "../../../libs/constants", optional = true } +unit_parser = { path = "../../../libs/unit_parser" } epoll = "=4.3.1" libc = { version = "0.2.*", default-features = false } @@ -31,6 +32,7 @@ once_cell = { version = "=1.8.0", default-features = false } serde = { version = "1.0.130", default-features = false } [features] -default = ["noplugin"] +default = ["noplugin", "linux"] noplugin = [] +linux = [] plugin = ["constants"] diff --git a/core/coms/mount/src/comm.rs b/core/coms/mount/src/comm.rs index d58af227..d0068d86 100644 --- a/core/coms/mount/src/comm.rs +++ b/core/coms/mount/src/comm.rs @@ -72,7 +72,7 @@ impl MountUnitComm { self.umcomm.rentry() } - pub(super) fn _um(&self) -> Rc { + pub(super) fn um(&self) -> Rc { self.umcomm.um() } } diff --git a/core/coms/mount/src/config.rs b/core/coms/mount/src/config.rs new file mode 100644 index 00000000..684bd713 --- /dev/null +++ b/core/coms/mount/src/config.rs @@ -0,0 +1,116 @@ +// Copyright (c) 2022 Huawei Technologies Co.,Ltd. All rights reserved. +// +// sysMaster is licensed under Mulan PSL v2. +// You can use this software according to the terms and conditions of the Mulan +// PSL v2. +// You may obtain a copy of Mulan PSL v2 at: +// http://license.coscl.org.cn/MulanPSL2 +// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY +// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO +// NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +// See the Mulan PSL v2 for more details. +// + +use std::{cell::RefCell, path::PathBuf, rc::Rc}; + +use basic::Error; +use unit_parser::prelude::UnitConfig; + +use crate::{comm::MountUnitComm, rentry::SectionMount}; + +#[derive(UnitConfig, Default)] +pub(super) struct MountConfigData { + pub Mount: SectionMount, +} + +pub(super) struct MountConfig { + // associated objects + comm: Rc, + + // owned objects + data: Rc>, +} + +pub(super) struct MountParameters { + pub what: String, + pub options: String, + pub fstype: String, +} + +impl MountConfig { + pub(super) fn new(commr: &Rc) -> Self { + MountConfig { + comm: Rc::clone(commr), + data: Rc::new(RefCell::new(MountConfigData::default())), + } + } + + pub(super) fn load(&self, paths: Vec, name: &str, update: bool) { + log::debug!("Loading {} config from: {:?}", name, paths); + let mount_config = match MountConfigData::load_config(paths, name) { + Ok(v) => v, + Err(e) => { + log::error!("Invalid Configuration: {}", e); + return; + } + }; + *self.data.borrow_mut() = mount_config; + + // if update { + // self.db_update(); + // } + } + + pub(super) fn config_data(&self) -> Rc> { + self.data.clone() + } + + pub(super) fn mount_where(&self) -> String { + self.data.borrow().Mount.Where.clone() + } + + pub(super) fn mount_what(&self) -> String { + self.data.borrow().Mount.What.clone() + } + + pub(super) fn mount_type(&self) -> String { + self.data.borrow().Mount.Type.clone() + } + + pub(super) fn mount_options(&self) -> String { + self.data.borrow().Mount.Options.clone() + } + + pub(super) fn directory_mode(&self) -> u32 { + self.data.borrow().Mount.DirectoryMode + } + + pub(super) fn force_unmount(&self) -> bool { + self.data.borrow().Mount.ForceUnmount + } + + pub(super) fn mount_parameters(&self) -> MountParameters { + MountParameters { + what: self.mount_what(), + options: self.mount_options(), + fstype: self.mount_type(), + } + } +} + +pub(super) fn mount_is_bind(mount_parameters: &MountParameters) -> bool { + // This is a simplified version. + for v in mount_parameters.options.split(',') { + let option = v.trim(); + if option == "bind" || option == "rbind" { + return true; + } + } + if mount_parameters.options.contains("bind|rbind") { + return true; + } + if mount_parameters.fstype == "bind" || mount_parameters.fstype == "rbind" { + return true; + } + false +} diff --git a/core/coms/mount/src/lib.rs b/core/coms/mount/src/lib.rs index 529c82da..4b6524b1 100644 --- a/core/coms/mount/src/lib.rs +++ b/core/coms/mount/src/lib.rs @@ -29,7 +29,9 @@ pub use {manager::__um_obj_create, unit::__subunit_create_with_params}; // dependency: mount_base -> mount_rentry -> mount_comm -> {mount_mng -> mount_unit} -> mount_manager mod base; mod comm; +mod config; mod manager; mod mng; mod rentry; +mod spawn; mod unit; diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index cfb832ac..85ac82dd 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -11,11 +11,20 @@ // See the Mulan PSL v2 for more details. //! The core logic of the mount subclass +use basic::MOUNT_BIN; +use basic::fs_util::{directory_is_empty, mkdir_p_label}; +use basic::mount_util::filter_options; + +use crate::config::{MountConfig, mount_is_bind}; +use crate::spawn::MountSpawn; + use super::comm::MountUnitComm; use super::rentry::MountState; use core::error::*; +use core::exec::{ExecCommand, ExecContext}; use core::rel::ReStation; use core::unit::{UnitActiveState, UnitNotifyFlags}; +use std::path::Path; use std::{cell::RefCell, rc::Rc}; impl MountState { @@ -23,6 +32,7 @@ impl MountState { match *self { MountState::Dead => UnitActiveState::InActive, MountState::Mounted => UnitActiveState::Active, + _ => UnitActiveState::InActive, } } } @@ -30,6 +40,10 @@ impl MountState { pub(super) struct MountMng { comm: Rc, state: RefCell, + + config: Rc, + control_command: RefCell>, + spawn: Rc, } impl ReStation for MountMng { @@ -50,15 +64,66 @@ impl ReStation for MountMng { } impl MountMng { - pub(super) fn new(_comm: &Rc) -> Self { + pub(super) fn new(commr: &Rc, configr: &Rc, exec_ctx: &Rc) -> Self { MountMng { - comm: Rc::clone(_comm), + comm: Rc::clone(commr), state: RefCell::new(MountState::Dead), + config: Rc::clone(configr), + control_command: RefCell::new(None), + spawn: Rc::new(MountSpawn::new(commr, exec_ctx)), + } + } + + pub(super) fn enter_mounting(&self) { + let mount_config = self.config.config_data(); + let mount_config = mount_config.borrow(); + + let mount_where = Path::new(&mount_config.Mount.Where); + let mount_what = Path::new(&mount_config.Mount.What); + let directory_mode = self.config.directory_mode(); + + let _ = mkdir_p_label(mount_where, directory_mode); + if !mount_where.exists() || !mount_where.is_dir() { + log::error!("Failed to create the mount directory: {}", mount_config.Mount.Where); + return; + } + if !directory_is_empty(mount_where) { + log::warn!("The mount directory {} is not empty.", mount_config.Mount.Where); } + + let mount_parameters = self.config.mount_parameters(); + if mount_is_bind(&mount_parameters) { + if let Err(e) = mkdir_p_label(mount_what, directory_mode) { + log::error!("Failed to create mount source {}: {}", mount_config.Mount.What, e); + } + } + let filtered_options = filter_options(&mount_parameters.options, vec!["nofail", "noauto", "auto"]); + + let mut mount_command = ExecCommand::empty(); + if let Err(e) = mount_command.set_path(MOUNT_BIN) { + log::error!("Failed to set mount command: {}", e); + return; + } + mount_command.append_many_argv(vec![&mount_parameters.what, &mount_config.Mount.Where]); + if !mount_parameters.fstype.is_empty() { + mount_command.append_many_argv(vec!["-t", &mount_parameters.fstype]); + } + if !filtered_options.is_empty() { + mount_command.append_many_argv(vec!["-o", &filtered_options]); + } + log::debug!("(whorwe)enter_mounting: 1 | cmd: {}, args: {:?}", mount_command.path(), mount_command.argv()); + + if let Err(e) = self.spawn.spawn_cmd(&mount_command) { + log::error!("Failed to mount {} to {}: {}", &mount_config.Mount.What, &mount_config.Mount.Where, e); + return; + } + + self.set_state(MountState::Mounting, false); } - // process doesn't support manually mount/umount like systemd. - // We only monitor the state of mountpoint. + pub(super) fn enter_signal(&self) {} + + pub(super) fn enter_dead_or_mounted(&self) {} pub(super) fn enter_dead(&self, notify: bool) { self.set_state(MountState::Dead, notify); @@ -68,6 +133,14 @@ impl MountMng { self.set_state(MountState::Mounted, notify); } + pub(super) fn enter_unmounting(&self) {} + + pub(super) fn enter_remounting(&self) {} + + pub(super) fn sigchld_event(&self) {} + + pub(super) fn dispatch_timer(&self) {} + pub(super) fn start_check(&self) -> Result { let ret = self.comm.owner().map_or(false, |u| u.test_start_limit()); if !ret { @@ -78,6 +151,26 @@ impl MountMng { Ok(false) } + pub(super) fn start_action(&self) -> Result<()> { + if [ + MountState::Unmounting, + MountState::UnmountingSigterm, + MountState::UnmountingSigkill, + MountState::Cleaning, + ] + .contains(&self.state()) + { + return Err(Error::UnitActionEAgain); + } + + if [MountState::Mounting, MountState::MountingDone].contains(&self.state()) { + return Ok(()); + } + + self.enter_mounting(); + Ok(()) + } + pub fn get_state(&self) -> String { let state = *self.state.borrow(); state.to_string() @@ -128,34 +221,34 @@ impl MountMng { } } -#[cfg(test)] -mod tests { - use super::MountMng; - use super::MountState; - use super::MountUnitComm; - use std::rc::Rc; - - #[test] - fn test_mount_set_state() { - let _comm = Rc::new(MountUnitComm::new()); - let tm = MountMng::new(&_comm); - tm.set_state(MountState::Mounted, false); - assert_eq!(tm.state(), MountState::Mounted) - } - - #[test] - fn test_mount_enter_dead() { - let _comm = Rc::new(MountUnitComm::new()); - let tm = MountMng::new(&_comm); - tm.enter_dead(false); - assert_eq!(tm.state(), MountState::Dead) - } - - #[test] - fn test_mount_enter_mounted() { - let _comm = Rc::new(MountUnitComm::new()); - let tm = MountMng::new(&_comm); - tm.enter_mounted(false); - assert_eq!(tm.state(), MountState::Mounted) - } -} +// #[cfg(test)] +// mod tests { +// use super::MountMng; +// use super::MountState; +// use super::MountUnitComm; +// use std::rc::Rc; + +// #[test] +// fn test_mount_set_state() { +// let _comm = Rc::new(MountUnitComm::new()); +// let tm = MountMng::new(&_comm); +// tm.set_state(MountState::Mounted, false); +// assert_eq!(tm.state(), MountState::Mounted) +// } + +// #[test] +// fn test_mount_enter_dead() { +// let _comm = Rc::new(MountUnitComm::new()); +// let tm = MountMng::new(&_comm); +// tm.enter_dead(false); +// assert_eq!(tm.state(), MountState::Dead) +// } + +// #[test] +// fn test_mount_enter_mounted() { +// let _comm = Rc::new(MountUnitComm::new()); +// let tm = MountMng::new(&_comm); +// tm.enter_mounted(false); +// assert_eq!(tm.state(), MountState::Mounted) +// } +// } diff --git a/core/coms/mount/src/rentry.rs b/core/coms/mount/src/rentry.rs index 3408c4c6..88ad4000 100644 --- a/core/coms/mount/src/rentry.rs +++ b/core/coms/mount/src/rentry.rs @@ -10,10 +10,10 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -use core::rel::{ReDb, ReDbRwTxn, ReDbTable, ReliSwitch, Reliability}; -use macros::EnumDisplay; +use core::{rel::{ReDb, ReDbRwTxn, ReDbTable, ReliSwitch, Reliability}, exec::{WorkingDirectory, StateDirectory, RuntimeDirectory, PreserveMode, Rlimit}}; +use macros::{EnumDisplay, UnitSection}; use serde::{Deserialize, Serialize}; -use std::rc::Rc; +use std::{rc::Rc, path::PathBuf, collections::HashMap}; const RELI_DB_HMOUNT_MNG: &str = "mntmng"; const RELI_DB_HMOUNTM_FRAME: &str = "mntm-frame"; @@ -23,7 +23,17 @@ const RELI_LAST_KEY: u32 = 0; // singleton #[derive(PartialEq, Eq, Debug, Copy, Clone, Serialize, Deserialize, EnumDisplay)] pub(super) enum MountState { Dead, + Mounting, + MountingDone, Mounted, + Remounting, + Unmounting, + RemountingSigterm, + RemountingSigKill, + UnmountingSigterm, + UnmountingSigkill, + Failed, + Cleaning, } #[derive(Clone, Debug, Serialize, Deserialize)] @@ -137,3 +147,46 @@ impl ReDbTable for MountReDb { self.0.switch_buffer(switch); } } + +#[derive(UnitSection, Default)] +#[allow(non_snake_case)] +pub struct SectionMount { + #[entry(default = String::new())] + pub What: String, + #[entry(default = String::new())] + pub Where: String, + #[entry(default = String::new())] + pub Type: String, + #[entry(default = String::new())] + pub Options: String, + #[entry(default = 0o755)] + pub DirectoryMode: u32, + #[entry(default = false)] + pub ForceUnmount: bool, + + // Exec + #[entry(default = String::new())] + pub User: String, + #[entry(default = String::new())] + pub Group: String, + #[entry(default = String::from("0022"))] + pub UMask: String, + #[entry(parser = basic::fs_util::parse_pathbuf)] + pub RootDirectory: Option, + #[entry(default = WorkingDirectory::default(), parser = core::exec::parse_working_directory)] + pub WorkingDirectory: WorkingDirectory, + #[entry(default = StateDirectory::default(), parser = core::exec::parse_state_directory)] + pub StateDirectory: StateDirectory, + #[entry(default = RuntimeDirectory::default(), parser = core::exec::parse_runtime_directory)] + pub RuntimeDirectory: RuntimeDirectory, + #[entry(default = PreserveMode::No)] + pub RuntimeDirectoryPreserve: PreserveMode, + pub LimitCORE: Option, + pub LimitNOFILE: Option, + pub LimitNPROC: Option, + #[entry(parser = core::exec::parse_environment)] + pub Environment: Option>, + #[entry(append)] + pub EnvironmentFile: Vec, + pub SELinuxContext: Option, +} diff --git a/core/coms/mount/src/spawn.rs b/core/coms/mount/src/spawn.rs new file mode 100644 index 00000000..cc49c9c2 --- /dev/null +++ b/core/coms/mount/src/spawn.rs @@ -0,0 +1,55 @@ +// Copyright (c) 2022 Huawei Technologies Co.,Ltd. All rights reserved. +// +// sysMaster is licensed under Mulan PSL v2. +// You can use this software according to the terms and conditions of the Mulan +// PSL v2. +// You may obtain a copy of Mulan PSL v2 at: +// http://license.coscl.org.cn/MulanPSL2 +// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY +// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO +// NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +// See the Mulan PSL v2 for more details. +// + +use core::error::*; +use core::exec::{ExecCommand, ExecParameters, ExecContext}; +use std::rc::Rc; + +use nix::unistd::Pid; + +use crate::comm::MountUnitComm; + +pub(crate) struct MountSpawn { + comm: Rc, + exec_ctx: Rc, +} + +impl MountSpawn { + pub(super) fn new(comm: &Rc, exec_ctx: &Rc) -> MountSpawn { + MountSpawn { + comm: comm.clone(), + exec_ctx: exec_ctx.clone(), + } + } + + pub(super) fn spawn_cmd(&self, cmdline: &ExecCommand) -> Result { + let mut params = ExecParameters::new(); + + if let Some(unit) = self.comm.owner() { + let um = self.comm.um(); + unit.prepare_exec()?; + match um.exec_spawn(&unit.id(), cmdline, &mut params, self.exec_ctx.clone()) { + Ok(pid) => { + um.child_watch_pid(&unit.id(), pid); + Ok(pid) + } + Err(e) => { + log::error!("Failed to spawn the mount command of {}: {}", unit.id(), e); + Err("spawn mount command error".to_string().into()) + } + } + } else { + Err("spawn mount command error".to_string().into()) + } + } +} diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 704c9571..01c9177a 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -13,9 +13,12 @@ //! mount unit is entry of mount type of unit，need impl //! UnitObj,UnitMngUtil, UnitSubClass trait +use crate::config::MountConfig; + use super::comm::MountUnitComm; use super::mng::MountMng; use core::error::*; +use core::exec::ExecContext; use core::rel::{ReStation, Reliability}; use core::unit::{SubUnit, UmIf, UnitActiveState, UnitBase, UnitMngUtil}; use nix::sys::wait::WaitStatus; @@ -25,6 +28,8 @@ use std::rc::Rc; struct MountUnit { comm: Rc, mng: Rc, + config: Rc, + exec_ctx: Rc, } impl ReStation for MountUnit { @@ -53,11 +58,67 @@ impl ReStation for MountUnit { impl MountUnit { fn new(_um: Rc) -> MountUnit { - let _comm = Rc::new(MountUnitComm::new()); + let comm = Rc::new(MountUnitComm::new()); + let config = Rc::new(MountConfig::new(&comm)); + let exec_ctx = Rc::new(ExecContext::new()); + let mng = Rc::new(MountMng::new(&comm, &config, &exec_ctx)); MountUnit { - comm: Rc::clone(&_comm), - mng: Rc::new(MountMng::new(&_comm)), + comm: comm.clone(), + mng: mng.clone(), + config: config.clone(), + exec_ctx: exec_ctx.clone(), + } + } + + fn parse(&self) -> Result<()> { + let cfg_data = self.config.config_data(); + self.exec_ctx + .insert_envs_files(cfg_data.borrow().Mount.EnvironmentFile.clone()); + + if let Some(rlimit) = cfg_data.borrow().Mount.LimitCORE { + self.exec_ctx.insert_rlimit(libc::RLIMIT_CORE as u8, rlimit); + } + + if let Some(rlimit) = cfg_data.borrow().Mount.LimitNOFILE { + self.exec_ctx + .insert_rlimit(libc::RLIMIT_NOFILE as u8, rlimit); + } + + if let Some(rlimit) = cfg_data.borrow().Mount.LimitNPROC { + self.exec_ctx + .insert_rlimit(libc::RLIMIT_NPROC as u8, rlimit); } + + self.exec_ctx + .set_root_directory(cfg_data.borrow().Mount.RootDirectory.clone()); + self.exec_ctx + .set_working_directory(cfg_data.borrow().Mount.WorkingDirectory.clone()); + self.exec_ctx + .set_runtime_directory(cfg_data.borrow().Mount.RuntimeDirectory.clone()); + self.exec_ctx + .set_state_directory(cfg_data.borrow().Mount.StateDirectory.clone()); + + self.exec_ctx + .set_selinux_context(cfg_data.borrow().Mount.SELinuxContext.clone()); + + #[cfg(feature = "linux")] + if let Err(e) = self.exec_ctx.set_user(&cfg_data.borrow().Mount.User) { + log::error!("Failed to set user: {}", e); + return Err(e); + } + + #[cfg(feature = "linux")] + if let Err(e) = self.exec_ctx.set_group(&cfg_data.borrow().Mount.Group) { + log::error!("Failed to set group: {}", e); + return Err(e); + } + + if let Err(e) = self.exec_ctx.set_umask(&cfg_data.borrow().Mount.UMask) { + log::error!("Failed to set umask: {}", e); + return Err(e); + } + + Ok(()) } } @@ -66,10 +127,10 @@ impl SubUnit for MountUnit { self } - fn load(&self, _paths: Vec) -> Result<()> { - if let Some(u) = self.comm.owner() { - u.set_ignore_on_isolate(true) - } + fn load(&self, paths: Vec) -> Result<()> { + let unit_name = self.comm.get_owner_id(); + self.config.load(paths, &unit_name, true); + self.parse()?; Ok(()) } @@ -93,12 +154,14 @@ impl SubUnit for MountUnit { fn dump(&self) {} fn start(&self) -> Result<()> { + log::info!("Mounting {}", self.comm.get_owner_id()); let started = self.mng.start_check()?; if started { - log::debug!("mount already in starting, just return immediately"); + log::debug!("{} is being mounted, skipping.", self.comm.get_owner_id()); return Ok(()); } + self.mng.start_action(); self.mng.enter_mounted(true); Ok(()) diff --git a/core/coms/service/src/mng.rs b/core/coms/service/src/mng.rs index cf545f4b..eaf54694 100644 --- a/core/coms/service/src/mng.rs +++ b/core/coms/service/src/mng.rs @@ -19,11 +19,11 @@ use super::rentry::{ NotifyState, ServiceCommand, ServiceRestart, ServiceResult, ServiceState, ServiceType, }; use super::spawn::ServiceSpawn; -use crate::rentry::{ExitStatus, NotifyAccess, PreserveMode}; +use crate::rentry::{ExitStatus, NotifyAccess}; use basic::{do_entry_log, fd_util, IN_SET}; use basic::{fs_util, process}; use core::error::*; -use core::exec::{ExecCommand, ExecContext, ExecFlag, ExecFlags}; +use core::exec::{ExecCommand, ExecContext, ExecFlag, ExecFlags, PreserveMode}; use core::rel::ReStation; use core::unit::{KillOperation, UnitActiveState, UnitNotifyFlags}; use event::{EventState, EventType, Events, Source}; diff --git a/core/coms/service/src/rentry.rs b/core/coms/service/src/rentry.rs index 8195cdc5..7eb5b0f8 100644 --- a/core/coms/service/src/rentry.rs +++ b/core/coms/service/src/rentry.rs @@ -14,13 +14,14 @@ use crate::monitor::ServiceMonitor; use basic::fs_util::{ - parse_absolute_path, path_is_abosolute, path_length_is_valid, path_name_is_safe, path_simplify, + path_is_abosolute, path_length_is_valid, path_name_is_safe, path_simplify, }; use macros::{EnumDisplay, UnitSection}; use nix::sys::signal::Signal; use nix::sys::wait::WaitStatus; use nix::unistd::Pid; use serde::{Deserialize, Serialize}; +use core::exec::PreserveMode; use std::collections::HashMap; use std::path::Path; use std::path::PathBuf; @@ -202,40 +203,7 @@ impl UnitEntry for ExitStatusSet { } } -#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)] -pub enum PreserveMode { - No, - Yes, - Restart, -} - -impl Default for PreserveMode { - fn default() -> Self { - Self::No - } -} - -impl UnitEntry for PreserveMode { - type Error = core::error::Error; - - fn parse_from_str>(input: S) -> std::result::Result { - let res = match input.as_ref() { - "no" => PreserveMode::No, - "yes" => PreserveMode::Yes, - "restart" => PreserveMode::Restart, - _ => { - log::error!( - "Failed to parse RuntimeDirectoryPreserve: {}, assuming no", - input.as_ref() - ); - PreserveMode::No - } - }; - Ok(res) - } -} - -fn deserialize_pidfile(s: &str) -> Result { +fn parse_pidfile(s: &str) -> Result { if !path_name_is_safe(s) { return Err(core::error::Error::ConfigureError { msg: "PIDFile contains invalid character".to_string(), @@ -264,129 +232,7 @@ fn deserialize_pidfile(s: &str) -> Result { } } -fn deserialize_pathbuf(s: &str) -> Result { - let path = parse_absolute_path(s).map_err(|_| core::error::Error::ConfigureError { - msg: "Invalid PathBuf".to_string(), - })?; - Ok(PathBuf::from(path)) -} - -fn parse_working_directory(s: &str) -> Result { - if s.is_empty() { - return Ok(WorkingDirectory::new(None, true)); - } - - let mut miss_ok = false; - if s.starts_with('-') { - miss_ok = true; - } - - let mut s: String = s.trim_start_matches('-').to_string(); - - if s == *"~".to_string() { - s = std::env::var("HOME").map_err(|_| basic::Error::Invalid { - what: "can't get HOME environment".to_string(), - })?; - } - - Ok(WorkingDirectory::new(Some(PathBuf::from(&s)), miss_ok)) -} - -#[cfg(test)] -mod test { - use std::path::PathBuf; - - use crate::rentry::parse_working_directory; - - #[test] - fn test_parse_working_directory() { - assert_eq!( - parse_working_directory("/root").unwrap().directory(), - Some(PathBuf::from("/root")) - ); - assert_eq!( - parse_working_directory("-/root/foooooooobarrrrrr") - .unwrap() - .directory(), - Some(PathBuf::from("/root/foooooooobarrrrrr")) - ); - assert_eq!( - parse_working_directory("--------------/usr/lib") - .unwrap() - .directory(), - Some(PathBuf::from("/usr/lib")) - ); - assert_eq!( - parse_working_directory("~").unwrap().directory(), - Some(PathBuf::from(std::env::var("HOME").unwrap())) - ); - assert_eq!(parse_working_directory("").unwrap().directory(), None); - } -} - -fn is_valid_exec_directory(s: &str) -> bool { - if !path_name_is_safe(s) { - return false; - } - if !path_length_is_valid(s) { - return false; - } - if path_is_abosolute(s) { - return false; - } - true -} - -fn deserialize_runtime_directory(s: &str) -> Result { - let mut res = RuntimeDirectory::default(); - for d in s.split_terminator(';') { - if !is_valid_exec_directory(d) { - return Err(Error::ConfigureError { - msg: "invalid runtime directory".to_string(), - }); - } - - let path = match path_simplify(d) { - None => { - return Err(Error::ConfigureError { - msg: "invalid runtime directory".to_string(), - }); - } - Some(v) => v, - }; - - res.add_directory(Path::new("/run").join(path)); - } - - Ok(res) -} - -fn deserialize_state_directory(s: &str) -> Result { - /* Similar with RuntimeDirectory */ - let mut res = StateDirectory::default(); - for d in s.split_terminator(';') { - if !is_valid_exec_directory(d) { - return Err(Error::ConfigureError { - msg: "not valid exec directory".to_string(), - }); - } - - let path = match path_simplify(d) { - None => { - return Err(Error::ConfigureError { - msg: "not valid exec directory".to_string(), - }); - } - Some(v) => v, - }; - - res.add_directory(Path::new("/var/lib").join(path)); - } - - Ok(res) -} - -fn deserialize_timeout(s: &str) -> Result { +fn parse_timeout(s: &str) -> Result { let timeout = s.parse::().unwrap(); if timeout == 0 { return Ok(u64::MAX); @@ -397,182 +243,77 @@ fn deserialize_timeout(s: &str) -> Result { Ok(timeout * USEC_PER_SEC) } -fn parse_environment(s: &str) -> Result> { - #[derive(PartialEq, Clone, Copy)] - enum ParseState { - Init, - Key, - Value, - Quotes, - BackSlash, - WaitSpace, - Invalid, - } - - let mut state = ParseState::Init; - let mut state_before_back_slash = ParseState::Value; - let mut key = String::new(); - let mut value = String::new(); - let mut res: HashMap = HashMap::new(); - for c in s.chars() { - match state { - ParseState::Init => { - if !key.is_empty() && !value.is_empty() { - res.insert(key, value); - } - key = String::new(); - value = String::new(); - if c.is_ascii_alphanumeric() || c == '_' { - key += &c.to_string(); - state = ParseState::Key; - } else if c != ' ' { - state = ParseState::Invalid; - break; - } - } - ParseState::Key => { - if c.is_ascii_alphanumeric() || c == '_' { - key += &c.to_string(); - } else if c == '=' { - state = ParseState::Value; - } else { - /* F-O=foo */ - state = ParseState::Invalid; - break; - } - } - ParseState::Value => { - /* FOO="foo bar" */ - if c == '\"' { - state = ParseState::Quotes; - continue; - } - /* FOO==\"foo */ - if c == '\\' { - state = ParseState::BackSlash; - state_before_back_slash = ParseState::Value; - continue; - } - if c != ' ' { - value += &c.to_string(); - continue; - } - state = ParseState::Init; - } - ParseState::BackSlash => { - /* FOO=\"foo or FOO="\"foo bar" */ - value += &c.to_string(); - state = state_before_back_slash; - } - ParseState::Quotes => { - /* We have got the right ", there must a space after. */ - if c == '\"' { - state = ParseState::WaitSpace; - continue; - } - if c == '\\' { - state = ParseState::BackSlash; - state_before_back_slash = ParseState::Quotes; - continue; - } - value += &c.to_string(); - } - ParseState::WaitSpace => { - if c != ' ' { - /* FOO="foo bar"x */ - state = ParseState::Invalid; - break; - } else { - state = ParseState::Init; - } - } - ParseState::Invalid => { - break; - } - } - } - if state == ParseState::Invalid { - log::warn!("Found invalid Environment, breaking"); - return Ok(res); - } - if !key.is_empty() - && !value.is_empty() - && [ParseState::Init, ParseState::WaitSpace, ParseState::Value].contains(&state) - { - res.insert(key, value); - } - Ok(res) -} - #[derive(UnitSection, Serialize, Deserialize, Debug, Default, Clone)] pub struct SectionService { #[entry(default=ServiceType::Simple)] pub Type: ServiceType, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStart: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStartPre: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStartPost: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStop: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStopPost: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecReload: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecCondition: Vec, #[entry(append)] pub Sockets: Vec, #[entry(default = 0)] pub WatchdogSec: u64, - #[entry(parser = deserialize_pidfile)] + #[entry(parser = parse_pidfile)] pub PIDFile: Option, #[entry(default = false)] pub RemainAfterExit: bool, pub NotifyAccess: Option, #[entry(default = false)] pub NonBlocking: bool, - #[entry(parser = parse_environment)] - pub Environment: Option>, #[entry(default = KillMode::ControlGroup)] pub KillMode: KillMode, - pub SELinuxContext: Option, - #[entry(parser = deserialize_pathbuf)] - pub RootDirectory: Option, - #[entry(default = WorkingDirectory::default(), parser = parse_working_directory)] - pub WorkingDirectory: WorkingDirectory, - #[entry(default = StateDirectory::default(), parser = deserialize_state_directory)] - pub StateDirectory: StateDirectory, - #[entry(default = RuntimeDirectory::default(), parser = deserialize_runtime_directory)] - pub RuntimeDirectory: RuntimeDirectory, - #[entry(default = PreserveMode::No)] - pub RuntimeDirectoryPreserve: PreserveMode, - #[entry(default = String::new())] - pub User: String, - #[entry(default = String::new())] - pub Group: String, - #[entry(default = String::from("0022"))] - pub UMask: String, #[entry(default = ServiceRestart::No)] pub Restart: ServiceRestart, #[entry(default = ExitStatusSet::default())] pub RestartPreventExitStatus: ExitStatusSet, #[entry(default = 1)] pub RestartSec: u64, - #[entry(append)] - pub EnvironmentFile: Vec, #[entry(default = String::from("SIGTERM"))] pub KillSignal: String, - #[entry(default = 10000000, parser = deserialize_timeout)] + #[entry(default = 10000000, parser = parse_timeout)] pub TimeoutSec: u64, - #[entry(default = 10000000, parser = deserialize_timeout)] + #[entry(default = 10000000, parser = parse_timeout)] pub TimeoutStartSec: u64, - #[entry(default = 10000000, parser = deserialize_timeout)] + #[entry(default = 10000000, parser = parse_timeout)] pub TimeoutStopSec: u64, + + // Exec + #[entry(default = String::new())] + pub User: String, + #[entry(default = String::new())] + pub Group: String, + #[entry(default = String::from("0022"))] + pub UMask: String, + #[entry(parser = basic::fs_util::parse_pathbuf)] + pub RootDirectory: Option, + #[entry(default = WorkingDirectory::default(), parser = core::exec::parse_working_directory)] + pub WorkingDirectory: WorkingDirectory, + #[entry(default = StateDirectory::default(), parser = core::exec::parse_state_directory)] + pub StateDirectory: StateDirectory, + #[entry(default = RuntimeDirectory::default(), parser = core::exec::parse_runtime_directory)] + pub RuntimeDirectory: RuntimeDirectory, + #[entry(default = PreserveMode::No)] + pub RuntimeDirectoryPreserve: PreserveMode, pub LimitCORE: Option, pub LimitNOFILE: Option, pub LimitNPROC: Option, + #[entry(parser = core::exec::parse_environment)] + pub Environment: Option>, + #[entry(append)] + pub EnvironmentFile: Vec, + pub SELinuxContext: Option, } impl SectionService { diff --git a/core/coms/socket/src/rentry.rs b/core/coms/socket/src/rentry.rs index 50b0b0e5..6755bbb4 100644 --- a/core/coms/socket/src/rentry.rs +++ b/core/coms/socket/src/rentry.rs @@ -29,7 +29,7 @@ const RELI_DB_HSOCKET_MNG: &str = "sockmng"; const RELI_DB_HSOCKETM_FRAME: &str = "sockm-frame"; const RELI_LAST_KEY: u32 = 0; // singleton -fn deserialize_pathbuf_vec(s: &str) -> Result, core::error::Error> { +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(|_| { @@ -49,15 +49,15 @@ fn deserialize_netlink_vec(s: &str) -> Result, core::error::Error> { #[derive(UnitSection, Default, Clone, Debug, Serialize, Deserialize)] #[allow(dead_code)] pub(super) struct SectionSocket { - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStartPre: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStartChown: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStartPost: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStopPre: Vec, - #[entry(append, parser = core::exec::deserialize_exec_command)] + #[entry(append, parser = core::exec::parse_exec_command)] pub ExecStopPost: Vec, #[entry(append)] @@ -89,7 +89,7 @@ pub(super) struct SectionSocket { pub Broadcast: Option, #[entry(default = false)] pub RemoveOnStop: bool, - #[entry(append, parser = deserialize_pathbuf_vec)] + #[entry(append, parser = parse_pathbuf_vec)] pub Symlinks: Vec, pub PassSecurity: Option, #[entry(default = 0o666)] diff --git a/core/libcore/src/exec/base.rs b/core/libcore/src/exec/base.rs index af64c2e0..07a5887e 100644 --- a/core/libcore/src/exec/base.rs +++ b/core/libcore/src/exec/base.rs @@ -11,6 +11,7 @@ // See the Mulan PSL v2 for more details. use crate::error::*; +use basic::fs_util::{path_simplify, path_name_is_safe, path_length_is_valid, path_is_abosolute}; use basic::rlimit; use bitflags::bitflags; use libc::EPERM; @@ -91,7 +92,7 @@ fn parse_rlimit(limit: &str) -> Result { } impl FromStr for Rlimit { - type Err = Error; + type Err = crate::error::Error; fn from_str(s: &str) -> std::result::Result { let value: Vec<_> = s.trim().split_terminator(':').collect(); let soft: u64; @@ -118,6 +119,52 @@ impl FromStr for Rlimit { } } +#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)] +pub enum PreserveMode { + No, + Yes, + Restart, +} + +impl Default for PreserveMode { + fn default() -> Self { + Self::No + } +} + +impl UnitEntry for PreserveMode { + type Error = Error; + + fn parse_from_str>(input: S) -> std::result::Result { + let res = match input.as_ref() { + "no" => PreserveMode::No, + "yes" => PreserveMode::Yes, + "restart" => PreserveMode::Restart, + _ => { + log::error!( + "Failed to parse RuntimeDirectoryPreserve: {}, assuming no", + input.as_ref() + ); + PreserveMode::No + } + }; + Ok(res) + } +} + +fn is_valid_exec_directory(s: &str) -> bool { + if !path_name_is_safe(s) { + return false; + } + if !path_length_is_valid(s) { + return false; + } + if path_is_abosolute(s) { + return false; + } + true +} + /// WorkingDirectory of ExecContext #[derive(Clone, Debug, Serialize, Deserialize, Default)] pub struct WorkingDirectory { @@ -125,6 +172,27 @@ pub struct WorkingDirectory { miss_ok: bool, } +pub fn parse_working_directory(s: &str) -> Result { + if s.is_empty() { + return Ok(WorkingDirectory::new(None, true)); + } + + let mut miss_ok = false; + if s.starts_with('-') { + miss_ok = true; + } + + let mut s: String = s.trim_start_matches('-').to_string(); + + if s == *"~".to_string() { + s = std::env::var("HOME").map_err(|_| basic::Error::Invalid { + what: "can't get HOME environment".to_string(), + })?; + } + + Ok(WorkingDirectory::new(Some(PathBuf::from(&s)), miss_ok)) +} + impl WorkingDirectory { /// pub fn new(directory: Option, miss_ok: bool) -> Self { @@ -148,6 +216,30 @@ pub struct RuntimeDirectory { directory: Vec, } +pub fn parse_runtime_directory(s: &str) -> Result { + let mut res = RuntimeDirectory::default(); + for d in s.split_terminator(';') { + if !is_valid_exec_directory(d) { + return Err(Error::ConfigureError { + msg: "invalid runtime directory".to_string(), + }); + } + + let path = match path_simplify(d) { + None => { + return Err(Error::ConfigureError { + msg: "invalid runtime directory".to_string(), + }); + } + Some(v) => v, + }; + + res.add_directory(Path::new("/run").join(path)); + } + + Ok(res) +} + impl RuntimeDirectory { /// pub fn add_directory(&mut self, directory: PathBuf) { @@ -166,6 +258,31 @@ pub struct StateDirectory { directory: Vec, } +pub fn parse_state_directory(s: &str) -> Result { + /* Similar with RuntimeDirectory */ + let mut res = StateDirectory::default(); + for d in s.split_terminator(';') { + if !is_valid_exec_directory(d) { + return Err(Error::ConfigureError { + msg: "not valid exec directory".to_string(), + }); + } + + let path = match path_simplify(d) { + None => { + return Err(Error::ConfigureError { + msg: "not valid exec directory".to_string(), + }); + } + Some(v) => v, + }; + + res.add_directory(Path::new("/var/lib").join(path)); + } + + Ok(res) +} + impl StateDirectory { /// pub fn add_directory(&mut self, directory: PathBuf) { @@ -201,6 +318,113 @@ impl Default for ExecContext { } } +pub fn parse_environment(s: &str) -> Result> { + #[derive(PartialEq, Clone, Copy)] + enum ParseState { + Init, + Key, + Value, + Quotes, + BackSlash, + WaitSpace, + Invalid, + } + + let mut state = ParseState::Init; + let mut state_before_back_slash = ParseState::Value; + let mut key = String::new(); + let mut value = String::new(); + let mut res: HashMap = HashMap::new(); + for c in s.chars() { + match state { + ParseState::Init => { + if !key.is_empty() && !value.is_empty() { + res.insert(key, value); + } + key = String::new(); + value = String::new(); + if c.is_ascii_alphanumeric() || c == '_' { + key += &c.to_string(); + state = ParseState::Key; + } else if c != ' ' { + state = ParseState::Invalid; + break; + } + } + ParseState::Key => { + if c.is_ascii_alphanumeric() || c == '_' { + key += &c.to_string(); + } else if c == '=' { + state = ParseState::Value; + } else { + /* F-O=foo */ + state = ParseState::Invalid; + break; + } + } + ParseState::Value => { + /* FOO="foo bar" */ + if c == '\"' { + state = ParseState::Quotes; + continue; + } + /* FOO==\"foo */ + if c == '\\' { + state = ParseState::BackSlash; + state_before_back_slash = ParseState::Value; + continue; + } + if c != ' ' { + value += &c.to_string(); + continue; + } + state = ParseState::Init; + } + ParseState::BackSlash => { + /* FOO=\"foo or FOO="\"foo bar" */ + value += &c.to_string(); + state = state_before_back_slash; + } + ParseState::Quotes => { + /* We have got the right ", there must a space after. */ + if c == '\"' { + state = ParseState::WaitSpace; + continue; + } + if c == '\\' { + state = ParseState::BackSlash; + state_before_back_slash = ParseState::Quotes; + continue; + } + value += &c.to_string(); + } + ParseState::WaitSpace => { + if c != ' ' { + /* FOO="foo bar"x */ + state = ParseState::Invalid; + break; + } else { + state = ParseState::Init; + } + } + ParseState::Invalid => { + break; + } + } + } + if state == ParseState::Invalid { + log::warn!("Found invalid Environment, breaking"); + return Ok(res); + } + if !key.is_empty() + && !value.is_empty() + && [ParseState::Init, ParseState::WaitSpace, ParseState::Value].contains(&state) + { + res.insert(key, value); + } + Ok(res) +} + impl ExecContext { /// create a new instance of exec context pub fn new() -> ExecContext { @@ -360,7 +584,7 @@ impl ExecContext { /// pub fn set_group(&self, group_str: &str) -> Result<()> { - /* add_user should be called before add_group */ + /* set_user should be called before add_group */ assert!(self.user().is_some()); /* group is not configured, use the primary group of user */ @@ -688,4 +912,31 @@ mod tests { let rlimit = Rlimit::from_str(source5); assert!(rlimit.is_err()); } + + use crate::exec::base::parse_working_directory; + use std::path::PathBuf; + #[test] + fn test_parse_working_directory() { + assert_eq!( + parse_working_directory("/root").unwrap().directory(), + Some(PathBuf::from("/root")) + ); + assert_eq!( + parse_working_directory("-/root/foooooooobarrrrrr") + .unwrap() + .directory(), + Some(PathBuf::from("/root/foooooooobarrrrrr")) + ); + assert_eq!( + parse_working_directory("--------------/usr/lib") + .unwrap() + .directory(), + Some(PathBuf::from("/usr/lib")) + ); + assert_eq!( + parse_working_directory("~").unwrap().directory(), + Some(PathBuf::from(std::env::var("HOME").unwrap())) + ); + assert_eq!(parse_working_directory("").unwrap().directory(), None); + } } diff --git a/core/libcore/src/exec/cmd.rs b/core/libcore/src/exec/cmd.rs index c3887035..7c597928 100644 --- a/core/libcore/src/exec/cmd.rs +++ b/core/libcore/src/exec/cmd.rs @@ -14,6 +14,7 @@ use crate::serialize::DeserializeWith; use crate::specifier::{ unit_string_specifier_escape, unit_strings_specifier_escape, UnitSpecifierData, }; +use basic::fs_util::{path_simplify, path_is_abosolute}; use basic::{fs_util::parse_absolute_path, Error, Result}; use bitflags::bitflags; use serde::{ @@ -62,7 +63,7 @@ impl ExecCommand { pub fn empty() -> ExecCommand { ExecCommand { path: String::new(), - argv: vec![String::new()], + argv: Vec::new(), flags: ExecFlag::EXEC_COMMAND_EMPTY, } } @@ -71,10 +72,29 @@ impl ExecCommand { self.flags |= flag; } /// + pub fn append_argv(&mut self, argv: &str) { + self.argv.push(String::from(argv)); + } + /// + pub fn append_many_argv(&mut self, argvs: Vec<&str>) { + self.argv.extend(argvs.iter().map(|x| x.to_string())) + } + /// pub fn get_exec_flag(&self) -> ExecFlag { self.flags } - + /// + pub fn set_path(&mut self, path: &str) -> Result<()> { + if !path_is_abosolute(path) { + return Err(Error::Invalid { what: "ExecCmd path should be absolute".to_string() }); + } + let v = match path_simplify(path) { + None => return Err(Error::Invalid { what: "Invalid ExecCmd path".to_string() }), + Some(v) => v, + }; + self.path = v; + Ok(()) + } /// return the path of the command pub fn path(&self) -> &String { &self.path @@ -102,7 +122,7 @@ impl ExecCommand { } /// -pub fn deserialize_exec_command(s: &str) -> Result> { +pub fn parse_exec_command(s: &str) -> Result> { match parse_exec(s) { Ok(v) => Ok(v), Err(e) => { diff --git a/core/libcore/src/exec/mod.rs b/core/libcore/src/exec/mod.rs index ad8463e4..481c2550 100644 --- a/core/libcore/src/exec/mod.rs +++ b/core/libcore/src/exec/mod.rs @@ -15,8 +15,9 @@ mod base; mod cmd; pub use base::{ ExecContext, ExecDirectoryType, ExecFlags, ExecParameters, Rlimit, RuntimeDirectory, - StateDirectory, WorkingDirectory, + StateDirectory, WorkingDirectory, PreserveMode }; -pub use cmd::deserialize_exec_command; +pub use base::{parse_environment, parse_runtime_directory, parse_state_directory, parse_working_directory}; +pub use cmd::parse_exec_command; pub use cmd::ExecCommand; pub use cmd::ExecFlag; diff --git a/core/sysmaster/src/unit/entry/uentry.rs b/core/sysmaster/src/unit/entry/uentry.rs index 2b1115d3..d8672ae9 100644 --- a/core/sysmaster/src/unit/entry/uentry.rs +++ b/core/sysmaster/src/unit/entry/uentry.rs @@ -603,12 +603,6 @@ impl Unit { pub(super) fn load_unit(&self) -> Result<()> { self.set_in_load_queue(false); - // Mount unit doesn't have config file, set its loadstate to - // UnitLoaded directly. - if self.unit_type() == UnitType::UnitMount { - self.load.set_load_state(UnitLoadState::Loaded); - return Ok(()); - } match self.load.load_unit_confs() { Ok(_) => { let paths = self.load.get_unit_id_fragment_pathbuf(); diff --git a/core/sysmaster/src/unit/execute/spawn.rs b/core/sysmaster/src/unit/execute/spawn.rs index 60a87070..01651289 100644 --- a/core/sysmaster/src/unit/execute/spawn.rs +++ b/core/sysmaster/src/unit/execute/spawn.rs @@ -65,7 +65,7 @@ impl ExecSpawn { fn apply_user_and_group(exec_ctx: Rc, params: &ExecParameters) -> Result<()> { let user = match exec_ctx.user() { - // ExecParameters.add_user() has already assigned valid user if the configuration is correct + // ExecParameters.set_user() has already assigned valid user if the configuration is correct None => { return Err(Error::InvalidData); } diff --git a/libs/basic/src/condition.rs b/libs/basic/src/condition.rs index ab4b8842..be17be0a 100644 --- a/libs/basic/src/condition.rs +++ b/libs/basic/src/condition.rs @@ -21,7 +21,10 @@ use nix::{ use libc::{glob, glob_t, GLOB_NOSORT}; -use crate::{cmdline, fd_util, mount_util::is_mount_point, security, sysfs::SysFs, unistd}; +use crate::{ + cmdline, fd_util, fs_util::directory_is_empty, mount_util::is_mount_point, security, + sysfs::SysFs, unistd, +}; #[cfg(target_env = "musl")] use crate::mount_util::MountInfoParser; @@ -192,17 +195,7 @@ impl Condition { } fn test_directory_not_empty(&self) -> i8 { - let path = Path::new(&self.params); - if path.is_file() { - return 0; - } - let mut iter = match path.read_dir() { - Err(_) => { - return 0; - } - Ok(v) => v, - }; - iter.next().is_some() as i8 + !directory_is_empty(&Path::new(&self.params)) as i8 } fn test_file_is_executable(&self) -> i8 { diff --git a/libs/basic/src/fs_util.rs b/libs/basic/src/fs_util.rs index 4a47eb1d..3dae6f7c 100644 --- a/libs/basic/src/fs_util.rs +++ b/libs/basic/src/fs_util.rs @@ -14,6 +14,7 @@ use crate::Error; use crate::{error::*, format_proc_fd_path}; use libc::{fchownat, mode_t, timespec, AT_EMPTY_PATH, S_IFLNK, S_IFMT}; +use nix::unistd::mkdir; use nix::{ fcntl::{open, readlink, renameat, OFlag}, sys::stat::{fstat, Mode}, @@ -310,6 +311,59 @@ pub fn futimens_opath(fd: RawFd, ts: Option<[timespec; 2]>) -> Result<()> { Ok(()) } +/// mkdir -p with the given directory mode +pub fn mkdir_p_label(path: &Path, mode: u32) -> Result<()> { + let path_str = path.to_string_lossy(); + if path.exists() && path.is_dir() { + if let Err(e) = chmod(&path_str, mode) { + log::error!("Failed to chmod of {}: {}", path_str, e); + return Err(e); + } + } + + let simplified_path = match path_simplify(&path_str) { + None => { + return Err(Error::Invalid { what: format!("Invalid path: {}", path_str) }); + } + Some(v) => v, + }; + + if !path_is_abosolute(&simplified_path) { + return Err(Error::Invalid { what: format!("Invalid Path: {}, only abosolute path is allowed.", path_str)}); + } + + let mode = Mode::from_bits_truncate(mode); + let mut cur_path = PathBuf::from("/"); + // mkdir -p up to down + for e in simplified_path.split('/') { + cur_path = cur_path.join(e); + if cur_path.exists() { + continue; + } + if let Err(e) = mkdir(&cur_path, mode) { + return Err(Error::Nix { source: e }) + } + } + Ok(()) +} + +/// mkdir parents with the given label +pub fn mkdir_parents_label() {} + +/// check if the given directory is empty +pub fn directory_is_empty(path: &Path) -> bool { + if path.is_file() { + return false; + } + let mut iter = match path.read_dir() { + Err(_) => { + return false; + } + Ok(v) => v, + }; + iter.next().is_none() +} + /// recursively remove parent directories until specific directory pub fn remove_dir_until(path: &str, stop: &str) -> Result<()> { let path = Path::new(path); @@ -591,6 +645,13 @@ pub fn parse_absolute_path(s: &str) -> Result { Ok(path) } +pub fn parse_pathbuf(s: &str) -> Result { + let path = parse_absolute_path(s).map_err(|_| Error::Invalid { + what: "Invalid PathBuf".to_string(), + })?; + Ok(PathBuf::from(path)) +} + /// unit lookup path in /etc pub const ETC_SYSTEM_PATH: &str = "/etc/sysmaster/system"; /// unit lookup path in /run diff --git a/libs/basic/src/mount_util.rs b/libs/basic/src/mount_util.rs index b3de62a7..d7ca42e9 100644 --- a/libs/basic/src/mount_util.rs +++ b/libs/basic/src/mount_util.rs @@ -306,6 +306,21 @@ impl Iterator for MountInfoParser { } } +/// filter options we don't need, and return the rest +pub fn filter_options(options: &str, filter_names: Vec<&str>) -> String { + let mut res = String::new(); + for option in options.split(',') { + if filter_names.contains(&option.trim()) { + continue; + } + if !res.is_empty() { + res += "," + } + res += option + } + res +} + ///Read the file of filename into the BufReader for later processing pub fn read_lines

(filename: P) -> io::Result>> where -- Gitee From 2018c4dc6738b866bc0f057fda3d62bf2af269c6 Mon Sep 17 00:00:00 2001 From: licunlong Date: Tue, 28 Nov 2023 20:05:33 +0800 Subject: [PATCH 2/8] feature: make stop command work --- core/coms/mount/src/manager.rs | 2 + core/coms/mount/src/mng.rs | 67 ++++++++++++++++++++++++++++++---- core/coms/mount/src/rentry.rs | 12 ++++++ core/coms/mount/src/unit.rs | 6 ++- libs/basic/src/lib.rs | 3 ++ 5 files changed, 82 insertions(+), 8 deletions(-) diff --git a/core/coms/mount/src/manager.rs b/core/coms/mount/src/manager.rs index 5bc660e3..7afa9004 100644 --- a/core/coms/mount/src/manager.rs +++ b/core/coms/mount/src/manager.rs @@ -327,6 +327,8 @@ impl MountMonitorData { } pub fn dispatch_mountinfo(&self) -> Result<()> { + // Quick return for now + return Ok(()); // First mark all active mount point we have as dead. let mut dead_mount_set: HashSet = HashSet::new(); let unit_type = Some(UnitType::UnitMount); diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index 85ac82dd..115b3e31 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -11,11 +11,14 @@ // See the Mulan PSL v2 for more details. //! The core logic of the mount subclass -use basic::MOUNT_BIN; +use basic::{MOUNT_BIN, UMOUNT_BIN}; use basic::fs_util::{directory_is_empty, mkdir_p_label}; use basic::mount_util::filter_options; +use libc::umount; +use nix::sys::wait::WaitStatus; use crate::config::{MountConfig, mount_is_bind}; +use crate::rentry::{MountRe, MountResult}; use crate::spawn::MountSpawn; use super::comm::MountUnitComm; @@ -111,17 +114,16 @@ impl MountMng { if !filtered_options.is_empty() { mount_command.append_many_argv(vec!["-o", &filtered_options]); } - log::debug!("(whorwe)enter_mounting: 1 | cmd: {}, args: {:?}", mount_command.path(), mount_command.argv()); if let Err(e) = self.spawn.spawn_cmd(&mount_command) { log::error!("Failed to mount {} to {}: {}", &mount_config.Mount.What, &mount_config.Mount.Where, e); return; } - self.set_state(MountState::Mounting, false); + self.set_state(MountState::Mounting, true); } - pub(super) fn enter_signal(&self) {} + pub(super) fn enter_signal(&self, state: MountState, res: MountResult) {} pub(super) fn enter_dead_or_mounted(&self) {} @@ -133,12 +135,23 @@ impl MountMng { self.set_state(MountState::Mounted, notify); } - pub(super) fn enter_unmounting(&self) {} + pub(super) fn enter_unmounting(&self) { + // retry_umount + let mut umount_command = ExecCommand::empty(); + if let Err(e) = umount_command.set_path(UMOUNT_BIN) { + log::error!("Failed to set umount command: {}", e); + } + let mount_where = self.config.mount_where(); + umount_command.append_many_argv(vec![&mount_where, "-c"]); + if let Err(e) = self.spawn.spawn_cmd(&umount_command) { + log::error!("Failed to umount {}: {}", mount_where, e); + return; + } + self.set_state(MountState::Unmounting, true); + } pub(super) fn enter_remounting(&self) {} - pub(super) fn sigchld_event(&self) {} - pub(super) fn dispatch_timer(&self) {} pub(super) fn start_check(&self) -> Result { @@ -171,6 +184,34 @@ impl MountMng { Ok(()) } + pub(super) fn stop_action(&self) -> Result { + let state = self.state(); + if [MountState::Unmounting, MountState::UnmountingSigkill, MountState::UnmountingSigterm].contains(&state) { + return Ok(0); + } + if [MountState::Mounting, MountState::MountingDone, MountState::Remounting].contains(&state) { + self.enter_signal(MountState::UnmountingSigterm, MountResult::Success); + return Ok(0); + } + if state == MountState::RemountingSigterm { + self.set_state(MountState::UnmountingSigterm, true); + return Ok(0); + } + if state == MountState::RemountingSigKill { + self.set_state(MountState::UnmountingSigkill, true); + return Ok(0); + } + if state == MountState::Mounted { + self.enter_unmounting(); + return Ok(1); + } + if state == MountState::Cleaning { + self.enter_signal(MountState::UnmountingSigkill, MountResult::Success); + return Ok(0); + } + Ok(0) + } + pub fn get_state(&self) -> String { let state = *self.state.borrow(); state.to_string() @@ -221,6 +262,18 @@ impl MountMng { } } +impl MountMng { + pub(super) fn sigchld_event(&self, wait_status: WaitStatus) { + self.do_sigchld_event(wait_status); + // self.db_update(); + } + + fn do_sigchld_event(&self, wait_status: WaitStatus) { + log::info!("Got a mount process sigchld, status: {:?}", wait_status); + return; + } +} + // #[cfg(test)] // mod tests { // use super::MountMng; diff --git a/core/coms/mount/src/rentry.rs b/core/coms/mount/src/rentry.rs index 88ad4000..55c21acf 100644 --- a/core/coms/mount/src/rentry.rs +++ b/core/coms/mount/src/rentry.rs @@ -36,6 +36,18 @@ pub(super) enum MountState { Cleaning, } +#[derive(PartialEq, Eq, Debug, Clone, Copy, Serialize, Deserialize)] +pub(super) enum MountResult { + Success, + FailureResources, + FailureTimeout, + FailureExitCode, + FailureSignal, + FailureCoreDump, + FailureStartLimitHit, + FailureProtocol, +} + #[derive(Clone, Debug, Serialize, Deserialize)] struct MountReMng { state: MountState, diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 01c9177a..8c5c894d 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -14,6 +14,7 @@ //! UnitObj,UnitMngUtil, UnitSubClass trait use crate::config::MountConfig; +use crate::rentry::{MountState, MountResult}; use super::comm::MountUnitComm; use super::mng::MountMng; @@ -168,6 +169,7 @@ impl SubUnit for MountUnit { } fn stop(&self, _force: bool) -> Result<()> { + self.mng.stop_action(); self.mng.enter_dead(true); Ok(()) } @@ -176,7 +178,9 @@ impl SubUnit for MountUnit { fn release_resources(&self) {} - fn sigchld_events(&self, _wait_status: WaitStatus) {} + fn sigchld_events(&self, wait_status: WaitStatus) { + // self.sigchld_events(wait_status); + } fn reset_failed(&self) {} } diff --git a/libs/basic/src/lib.rs b/libs/basic/src/lib.rs index 3aabd021..5007047c 100644 --- a/libs/basic/src/lib.rs +++ b/libs/basic/src/lib.rs @@ -124,6 +124,9 @@ pub const EXEC_RUNTIME_PREFIX: &str = "/run"; /// the default mount command path pub const MOUNT_BIN: &str = "/usr/bin/mount"; +/// the default umount command path +pub const UMOUNT_BIN: &str = "/usr/bin/umount"; + /// the default swapon path pub const SWAP_BIN: &str = "/usr/sbin/swapon"; -- Gitee From a5a607c4ed26321dd084160b40fefbfb744a4c1b Mon Sep 17 00:00:00 2001 From: licunlong Date: Tue, 28 Nov 2023 20:33:42 +0800 Subject: [PATCH 3/8] fix: unit name match mount_where --- core/coms/mount/src/manager.rs | 12 +----------- core/coms/mount/src/mng.rs | 2 +- core/coms/mount/src/unit.rs | 14 ++++++++++++-- libs/basic/src/mount_util.rs | 9 +++++++++ 4 files changed, 23 insertions(+), 14 deletions(-) diff --git a/core/coms/mount/src/manager.rs b/core/coms/mount/src/manager.rs index 7afa9004..941b9a3b 100644 --- a/core/coms/mount/src/manager.rs +++ b/core/coms/mount/src/manager.rs @@ -17,7 +17,7 @@ use constants::LOG_FILE_PATH; use super::comm::MountUmComm; use super::rentry::{MountRe, MountReFrame}; -use basic::mount_util::MountInfoParser; +use basic::mount_util::{MountInfoParser, mount_point_to_unit_name}; use core::error::*; use core::rel::{ReStation, ReliLastFrame, Reliability}; use core::unit::{UmIf, UnitActiveState, UnitManagerObj, UnitMngUtil, UnitType}; @@ -327,8 +327,6 @@ impl MountMonitorData { } pub fn dispatch_mountinfo(&self) -> Result<()> { - // Quick return for now - return Ok(()); // First mark all active mount point we have as dead. let mut dead_mount_set: HashSet = HashSet::new(); let unit_type = Some(UnitType::UnitMount); @@ -393,14 +391,6 @@ fn drain_out(epfd: i32) { while epoll::wait(epfd, 0, &mut me_events).unwrap() > 0 {} } -fn mount_point_to_unit_name(mount_point: &str) -> String { - let mut res = String::from(mount_point).replace('/', "-") + ".mount"; - if res != "-.mount" { - res = String::from(&res[1..]) - } - res -} - impl UnitMngUtil for MountManager { fn attach_um(&self, um: Rc) { self.comm.attach_um(um); diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index 115b3e31..1f5a83fe 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -265,7 +265,7 @@ impl MountMng { impl MountMng { pub(super) fn sigchld_event(&self, wait_status: WaitStatus) { self.do_sigchld_event(wait_status); - // self.db_update(); + self.db_update(); } fn do_sigchld_event(&self, wait_status: WaitStatus) { diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 8c5c894d..75c5ed21 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -22,6 +22,7 @@ use core::error::*; use core::exec::ExecContext; use core::rel::{ReStation, Reliability}; use core::unit::{SubUnit, UmIf, UnitActiveState, UnitBase, UnitMngUtil}; +use basic::mount_util::mount_point_to_unit_name; use nix::sys::wait::WaitStatus; use std::path::PathBuf; use std::rc::Rc; @@ -121,6 +122,15 @@ impl MountUnit { Ok(()) } + + fn mount_verify(&self) -> Result<()> { + let mount_where = self.config.mount_where(); + if !mount_point_to_unit_name(&mount_where).eq(&self.comm.get_owner_id()) { + log::error!("Failed to load unit {}: unit name doesn't match Where", self.comm.get_owner_id()); + return Err(Error::ConfigureError { msg: "unit name doesn't match Where".to_string() }); + } + Ok(()) + } } impl SubUnit for MountUnit { @@ -132,7 +142,7 @@ impl SubUnit for MountUnit { let unit_name = self.comm.get_owner_id(); self.config.load(paths, &unit_name, true); self.parse()?; - Ok(()) + self.mount_verify() } fn current_active_state(&self) -> UnitActiveState { @@ -179,7 +189,7 @@ impl SubUnit for MountUnit { fn release_resources(&self) {} fn sigchld_events(&self, wait_status: WaitStatus) { - // self.sigchld_events(wait_status); + self.mng.sigchld_event(wait_status); } fn reset_failed(&self) {} diff --git a/libs/basic/src/mount_util.rs b/libs/basic/src/mount_util.rs index d7ca42e9..004386d5 100644 --- a/libs/basic/src/mount_util.rs +++ b/libs/basic/src/mount_util.rs @@ -306,6 +306,15 @@ impl Iterator for MountInfoParser { } } +/// return the unit name of a mount point +pub fn mount_point_to_unit_name(mount_point: &str) -> String { + let mut res = String::from(mount_point).replace('/', "-") + ".mount"; + if res != "-.mount" { + res = String::from(&res[1..]) + } + res +} + /// filter options we don't need, and return the rest pub fn filter_options(options: &str, filter_names: Vec<&str>) -> String { let mut res = String::new(); -- Gitee From 41e2411c8054de3caa40d060c61cdaabad08c6da Mon Sep 17 00:00:00 2001 From: licunlong Date: Wed, 29 Nov 2023 10:44:01 +0800 Subject: [PATCH 4/8] feature: enable sigchld dispatch --- core/coms/mount/src/mng.rs | 117 ++++++++++++++++++++++++++++++---- core/coms/mount/src/rentry.rs | 2 +- core/coms/mount/src/unit.rs | 2 +- libs/basic/src/process.rs | 6 ++ 4 files changed, 113 insertions(+), 14 deletions(-) diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index 1f5a83fe..3798df4f 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -14,11 +14,10 @@ use basic::{MOUNT_BIN, UMOUNT_BIN}; use basic::fs_util::{directory_is_empty, mkdir_p_label}; use basic::mount_util::filter_options; -use libc::umount; use nix::sys::wait::WaitStatus; use crate::config::{MountConfig, mount_is_bind}; -use crate::rentry::{MountRe, MountResult}; +use crate::rentry::MountResult; use crate::spawn::MountSpawn; use super::comm::MountUnitComm; @@ -47,6 +46,10 @@ pub(super) struct MountMng { config: Rc, control_command: RefCell>, spawn: Rc, + + result: RefCell, + reload_result: RefCell, + find_in_mountinfo: RefCell, } impl ReStation for MountMng { @@ -74,6 +77,9 @@ impl MountMng { config: Rc::clone(configr), control_command: RefCell::new(None), spawn: Rc::new(MountSpawn::new(commr, exec_ctx)), + result: RefCell::new(MountResult::Success), + reload_result: RefCell::new(MountResult::Success), + find_in_mountinfo: RefCell::new(false), } } @@ -114,7 +120,7 @@ impl MountMng { if !filtered_options.is_empty() { mount_command.append_many_argv(vec!["-o", &filtered_options]); } - + *self.control_command.borrow_mut() = Some(mount_command.clone()); if let Err(e) = self.spawn.spawn_cmd(&mount_command) { log::error!("Failed to mount {} to {}: {}", &mount_config.Mount.What, &mount_config.Mount.Where, e); return; @@ -125,9 +131,9 @@ impl MountMng { pub(super) fn enter_signal(&self, state: MountState, res: MountResult) {} - pub(super) fn enter_dead_or_mounted(&self) {} + pub(super) fn enter_dead_or_mounted(&self, res: MountResult) {} - pub(super) fn enter_dead(&self, notify: bool) { + pub(super) fn enter_dead(&self, res: MountResult, notify: bool) { self.set_state(MountState::Dead, notify); } @@ -143,6 +149,7 @@ impl MountMng { } let mount_where = self.config.mount_where(); umount_command.append_many_argv(vec![&mount_where, "-c"]); + *self.control_command.borrow_mut() = Some(umount_command.clone()); if let Err(e) = self.spawn.spawn_cmd(&umount_command) { log::error!("Failed to umount {}: {}", mount_where, e); return; @@ -157,7 +164,7 @@ impl MountMng { pub(super) fn start_check(&self) -> Result { let ret = self.comm.owner().map_or(false, |u| u.test_start_limit()); if !ret { - self.enter_dead(true); + self.enter_dead(MountResult::Success, true); return Err(Error::UnitActionECanceled); } @@ -169,7 +176,6 @@ impl MountMng { MountState::Unmounting, MountState::UnmountingSigterm, MountState::UnmountingSigkill, - MountState::Cleaning, ] .contains(&self.state()) { @@ -205,10 +211,6 @@ impl MountMng { self.enter_unmounting(); return Ok(1); } - if state == MountState::Cleaning { - self.enter_signal(MountState::UnmountingSigkill, MountResult::Success); - return Ok(0); - } Ok(0) } @@ -260,6 +262,29 @@ impl MountMng { pub(super) fn mount_state_to_unit_state(&self) -> UnitActiveState { self.state().mount_state_to_unit_state() } + + fn result(&self) -> MountResult { + *self.result.borrow() + } + + fn set_result(&self, r: MountResult) { + *self.result.borrow_mut() = r + } + + fn set_reload_result(&self, r: MountResult) { + if *self.reload_result.borrow() != MountResult::Success { + return; + } + *self.reload_result.borrow_mut() = r + } + + fn find_in_mountinfo(&self) -> bool { + *self.find_in_mountinfo.borrow() + } + + fn set_find_in_mountinfo(&self, find: bool) { + *self.find_in_mountinfo.borrow_mut() = find + } } impl MountMng { @@ -269,9 +294,77 @@ impl MountMng { } fn do_sigchld_event(&self, wait_status: WaitStatus) { - log::info!("Got a mount process sigchld, status: {:?}", wait_status); + log::debug!("Got a mount process sigchld, status: {:?}", wait_status); + let mut f = self.sigchld_result(wait_status); + let state = self.state(); + + if [MountState::Remounting, MountState::RemountingSigKill, MountState::RemountingSigterm].contains(&state) { + self.set_reload_result(f); + } else if self.result() == MountResult::Success { + self.set_result(f); + } + if self.control_command.borrow().is_some() { + *self.control_command.borrow_mut() = None; + } + + // mount process has exited, but the mount point is not mounted + if state == MountState::Mounting { + if f == MountResult::Success { + log::warn!("Mount process of {} has exited, but there is no mount.", self.comm.get_owner_id()); + f = MountResult::FailureProtocol; + } + self.enter_dead(f, true); + return; + } + + // we have seen this mountpoint in /p/s/mountinfo + if state == MountState::MountingDone { + self.enter_mounted(true); + return; + } + + if [MountState::Remounting, MountState::RemountingSigKill, MountState::RemountingSigterm].contains(&state) { + self.enter_dead_or_mounted(MountResult::Success); + return; + } + + if state == MountState::Unmounting { + // umount process has exited, but we can still see the mountpoint in /p/s/mountinfo + if f == MountResult::Success && self.find_in_mountinfo() { + self.enter_mounted(true); + } else { + self.enter_dead_or_mounted(f); + } + return; + } + + if [MountState::UnmountingSigkill, MountState::UnmountingSigterm].contains(&state) { + self.enter_dead_or_mounted(f); + return; + } + return; } + + fn sigchld_result(&self, wait_status: WaitStatus) -> MountResult { + match wait_status { + WaitStatus::Exited(_, status) => { + if status == 0 { + MountResult::Success + } else { + MountResult::FailureExitCode + } + } + WaitStatus::Signaled(_pid, _sig, core_dump) => { + if core_dump { + MountResult::FailureCoreDump + } else { + MountResult::FailureSignal + } + } + _ => unreachable!(), + } + } } // #[cfg(test)] diff --git a/core/coms/mount/src/rentry.rs b/core/coms/mount/src/rentry.rs index 55c21acf..dbc749ef 100644 --- a/core/coms/mount/src/rentry.rs +++ b/core/coms/mount/src/rentry.rs @@ -33,7 +33,7 @@ pub(super) enum MountState { UnmountingSigterm, UnmountingSigkill, Failed, - Cleaning, + // Cleaning currently not used } #[derive(PartialEq, Eq, Debug, Clone, Copy, Serialize, Deserialize)] diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 75c5ed21..1f4a8033 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -180,7 +180,7 @@ impl SubUnit for MountUnit { fn stop(&self, _force: bool) -> Result<()> { self.mng.stop_action(); - self.mng.enter_dead(true); + self.mng.enter_dead(MountResult::Success, true); Ok(()) } diff --git a/libs/basic/src/process.rs b/libs/basic/src/process.rs index 638eafdd..485f73d8 100644 --- a/libs/basic/src/process.rs +++ b/libs/basic/src/process.rs @@ -17,6 +17,7 @@ use nix::errno::errno; use nix::errno::Errno; use nix::libc::{kill, ESRCH}; use nix::sys::signal::Signal; +use nix::sys::wait::WaitStatus; use nix::sys::wait::{waitpid, WaitPidFlag}; use nix::unistd::Pid; use procfs::process::Stat; @@ -254,6 +255,11 @@ fn is_kernel_thread(pid: Pid) -> Result { } } +/// return true if the wait result is ok +pub fn is_clean_exit(wait_status: WaitStatus) -> bool { + false +} + #[cfg(test)] mod tests { use nix::libc::kill; -- Gitee From 16b493b7fbb174d255fb108dd46c57a3dcf98dd2 Mon Sep 17 00:00:00 2001 From: licunlong Date: Thu, 30 Nov 2023 11:42:46 +0800 Subject: [PATCH 5/8] fix: enable setup_mount interface, this is helpful to update the unit state according to /p/s/mountinfo --- core/coms/mount/src/manager.rs | 81 ++++++++++++++++++++++++- core/coms/mount/src/unit.rs | 8 +++ core/libcore/src/error.rs | 6 ++ core/libcore/src/unit/base.rs | 24 +++++--- core/libcore/src/unit/umif.rs | 7 +++ core/sysmaster/src/unit/entry/uentry.rs | 8 +++ core/sysmaster/src/unit/manager.rs | 24 ++++++++ libs/basic/src/fs_util.rs | 5 ++ 8 files changed, 152 insertions(+), 11 deletions(-) diff --git a/core/coms/mount/src/manager.rs b/core/coms/mount/src/manager.rs index 941b9a3b..013a76d7 100644 --- a/core/coms/mount/src/manager.rs +++ b/core/coms/mount/src/manager.rs @@ -12,15 +12,18 @@ #[cfg(feature = "plugin")] use crate::base::PLUGIN_NAME; +use basic::fs_util::is_path; #[cfg(feature = "plugin")] use constants::LOG_FILE_PATH; use super::comm::MountUmComm; use super::rentry::{MountRe, MountReFrame}; -use basic::mount_util::{MountInfoParser, mount_point_to_unit_name}; +use basic::mount_util::{mount_point_to_unit_name, MountInfoParser}; use core::error::*; use core::rel::{ReStation, ReliLastFrame, Reliability}; -use core::unit::{UmIf, UnitActiveState, UnitManagerObj, UnitMngUtil, UnitType}; +use core::unit::{ + unit_name_is_valid, UmIf, UnitActiveState, UnitManagerObj, UnitMngUtil, UnitNameFlags, UnitType, +}; use event::{EventState, EventType, Events, Source}; use std::collections::HashSet; use std::fs::File; @@ -326,7 +329,81 @@ impl MountMonitorData { } } + pub fn setup_new_mount( + &self, + unit_name: &str, + what: &str, + mount_where: &str, + options: &str, + fstype: &str, + ) -> Result<()> { + self.comm.um().setup_new_mount(unit_name, what, mount_where, options, fstype); + Ok(()) + } + + pub fn setup_existing_mount( + &self, + unit_name: &str, + what: &str, + mount_where: &str, + options: &str, + fstype: &str, + ) -> Result<()> { + self.comm.um().setup_existing_mount(unit_name, what, mount_where, options, fstype); + Ok(()) + } + + pub fn setup_mount( + &self, + what: &str, + mount_where: &str, + options: &str, + fstype: &str, + ) -> Result<()> { + if fstype == "autofs" { + return Ok(()); + } + if !is_path(mount_where) { + return Ok(()); + } + let unit_name = mount_point_to_unit_name(mount_where); + if !unit_name_is_valid(&unit_name, UnitNameFlags::PLAIN) { + return Err(Error::InvalidName { + what: "mount point can't convert to unit name".to_string(), + }); + } + if self.comm.um().load_unit_success(&unit_name) { + self.setup_existing_mount(&unit_name, what, mount_where, options, fstype)?; + } else { + self.setup_new_mount(&unit_name, what, mount_where, options, fstype)?; + } + Ok(()) + } + + pub fn load_mountinfo(&self) -> Result<()> { + // Then start mount point we don't know. + let mut mountinfo_content = String::new(); + File::open("/proc/self/mountinfo") + .unwrap() + .read_to_string(&mut mountinfo_content) + .unwrap(); + let parser = MountInfoParser::new(mountinfo_content); + for mount in parser { + if let Err(e) = self.setup_mount( + &mount.mount_source, + &mount.mount_point, + &mount.mount_options, + &mount.fstype, + ) { + log::error!("Failed to setup mount {}: {}", mount.mount_point, e); + } + } + Ok(()) + } + pub fn dispatch_mountinfo(&self) -> Result<()> { + self.load_mountinfo()?; + return Ok(()); // First mark all active mount point we have as dead. let mut dead_mount_set: HashSet = HashSet::new(); let unit_type = Some(UnitType::UnitMount); diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 1f4a8033..49e943fc 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -193,6 +193,14 @@ impl SubUnit for MountUnit { } fn reset_failed(&self) {} + + fn setup_existing_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { + log::info!("(whorwe)setup_existing_mount: 1 | unit: {}", self.comm.get_owner_id()); + } + + fn setup_new_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { + log::info!("(whorwe)setup_new_mount: 1 | unit: {}", self.comm.get_owner_id()); + } } impl UnitMngUtil for MountUnit { diff --git a/core/libcore/src/error.rs b/core/libcore/src/error.rs index 197d9ccb..28a47d32 100644 --- a/core/libcore/src/error.rs +++ b/core/libcore/src/error.rs @@ -103,6 +103,11 @@ pub enum Error { source: Arc, }, + #[snafu(display("Invalid Name: {}", what))] + InvalidName { + what: String, + }, + #[snafu(display("ConvertError"))] ConvertToSysmaster, @@ -190,6 +195,7 @@ impl From for nix::Error { Error::NotFound { what: _ } => nix::Error::ENOENT, Error::Other { msg: _ } => nix::Error::EIO, Error::Shared { source: _ } => nix::Error::EIO, + Error::InvalidName { what: _ } => nix::Error::EINVAL, Error::ConvertToSysmaster => nix::Error::EIO, Error::Input => nix::Error::EIO, Error::Conflict => nix::Error::EBADR, diff --git a/core/libcore/src/unit/base.rs b/core/libcore/src/unit/base.rs index dfe073ab..7df88853 100644 --- a/core/libcore/src/unit/base.rs +++ b/core/libcore/src/unit/base.rs @@ -131,12 +131,6 @@ pub trait SubUnit: ReStation + UnitMngUtil { Vec::new() } - /// - fn set_socket_fd(&self, _fd: i32) {} - - /// - fn release_socket_fd(&self, _fd: i32) {} - /// fn trigger(&self, _other: &str) {} @@ -166,6 +160,21 @@ pub trait SubUnit: ReStation + UnitMngUtil { fn get_perpetual(&self) -> bool { false } + + // ================ ONLY VALID FOR SERVICE ================ + /// + fn set_socket_fd(&self, _fd: i32) {} + + /// + fn release_socket_fd(&self, _fd: i32) {} + + + // ================ ONLY VALID FOR MOUNT ================ + /// + fn setup_existing_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) {} + + /// + fn setup_new_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) {} } /// the macro for create a sub unit instance with dyn ref of UmIf, @@ -219,16 +228,13 @@ pub fn unit_name_is_valid(name: &str, flag: UnitNameFlags) -> bool { None => return false, Some(v) => (v.0, v.1), }; - let unit_type = match unit_type_from_string(last_name) { Err(_) => return false, Ok(v) => v, }; - if unit_type == UnitType::UnitTypeInvalid { return false; } - match first_name.split_once('@') { None => flag.contains(UnitNameFlags::PLAIN), Some(v) => { diff --git a/core/libcore/src/unit/umif.rs b/core/libcore/src/unit/umif.rs index 89b41dac..b580a91c 100644 --- a/core/libcore/src/unit/umif.rs +++ b/core/libcore/src/unit/umif.rs @@ -205,6 +205,13 @@ pub trait UmIf { /// release the service's socket fd fn service_release_socket_fd(&self, _service_name: &str, _fd: i32) {} + + /* ========== ONLY VALID IN MOUNT ========== */ + /// setup existing mount + fn setup_existing_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) {} + + /// setup new mount + fn setup_new_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) {} } /// the trait used for attach UnitManager to sub unit diff --git a/core/sysmaster/src/unit/entry/uentry.rs b/core/sysmaster/src/unit/entry/uentry.rs index d8672ae9..03ebb366 100644 --- a/core/sysmaster/src/unit/entry/uentry.rs +++ b/core/sysmaster/src/unit/entry/uentry.rs @@ -787,6 +787,14 @@ impl Unit { self.sub.release_socket_fd(fd) } + pub(crate) fn setup_existing_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { + self.sub.setup_existing_mount(what, mount_where, options, fstype); + } + + pub(crate) fn setup_new_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { + self.sub.setup_new_mount(what, mount_where, options, fstype); + } + pub(crate) fn notify_message( &self, ucred: &UnixCredentials, diff --git a/core/sysmaster/src/unit/manager.rs b/core/sysmaster/src/unit/manager.rs index 3f2da448..539ec657 100644 --- a/core/sysmaster/src/unit/manager.rs +++ b/core/sysmaster/src/unit/manager.rs @@ -657,6 +657,30 @@ impl UmIf for UnitManager { }; service.release_socket_fd(fd); } + + /// setup existing mount + fn setup_existing_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) { + let mount = match self.units_get(unit_name) { + None => { + log::error!("Failed to get unit: {}", unit_name); + return; + } + Some(v) => v, + }; + mount.setup_existing_mount(what, mount_where, options, fstype); + } + + /// setup new mount + fn setup_new_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) { + let mount = match self.units_get(unit_name) { + None => { + log::warn!("Unit {} doesn't exist for now, probably we should load it.", unit_name); + return; + } + Some(v) => v, + }; + mount.setup_new_mount(what, mount_where, options, fstype); + } } /// the declaration "pub(self)" is for identification only. diff --git a/libs/basic/src/fs_util.rs b/libs/basic/src/fs_util.rs index 3dae6f7c..23381e6f 100644 --- a/libs/basic/src/fs_util.rs +++ b/libs/basic/src/fs_util.rs @@ -608,6 +608,11 @@ pub fn path_simplify(p: &str) -> Option { Some(res) } +/// check if the given string is a path +pub fn is_path(s: &str) -> bool { + s.contains('/') +} + /// check if the given path is abololute path pub fn path_is_abosolute(s: &str) -> bool { s.starts_with('/') -- Gitee From dd883e120709e1c988b2cfa064eea1d54ba3dd0a Mon Sep 17 00:00:00 2001 From: licunlong Date: Thu, 30 Nov 2023 17:20:45 +0800 Subject: [PATCH 6/8] fix: simple mountinfo state change --- core/coms/mount/src/config.rs | 10 ++++++++ core/coms/mount/src/manager.rs | 16 ++++++------- core/coms/mount/src/mng.rs | 4 ++-- core/coms/mount/src/unit.rs | 31 +++++++++++++++++++++---- core/libcore/src/unit/base.rs | 3 +++ core/libcore/src/unit/umif.rs | 3 +++ core/sysmaster/src/unit/entry/uentry.rs | 4 ++++ core/sysmaster/src/unit/manager.rs | 20 ++++++++++++++-- libs/basic/src/process.rs | 6 ----- 9 files changed, 74 insertions(+), 23 deletions(-) diff --git a/core/coms/mount/src/config.rs b/core/coms/mount/src/config.rs index 684bd713..2e6a3f82 100644 --- a/core/coms/mount/src/config.rs +++ b/core/coms/mount/src/config.rs @@ -69,6 +69,10 @@ impl MountConfig { self.data.borrow().Mount.Where.clone() } + pub(super) fn set_mount_where(&self, mount_where: &str) { + (*self.data.borrow_mut()).Mount.Group = mount_where.to_string(); + } + pub(super) fn mount_what(&self) -> String { self.data.borrow().Mount.What.clone() } @@ -96,6 +100,12 @@ impl MountConfig { fstype: self.mount_type(), } } + + pub(super) fn update_mount_parameters(&self, what: &str, options: &str, fstype: &str) { + (*self.data.borrow_mut()).Mount.What = what.to_string(); + (*self.data.borrow_mut()).Mount.Options = options.to_string(); + (*self.data.borrow_mut()).Mount.Type = fstype.to_string(); + } } pub(super) fn mount_is_bind(mount_parameters: &MountParameters) -> bool { diff --git a/core/coms/mount/src/manager.rs b/core/coms/mount/src/manager.rs index 013a76d7..e4a3f16e 100644 --- a/core/coms/mount/src/manager.rs +++ b/core/coms/mount/src/manager.rs @@ -402,17 +402,16 @@ impl MountMonitorData { } pub fn dispatch_mountinfo(&self) -> Result<()> { - self.load_mountinfo()?; - return Ok(()); - // First mark all active mount point we have as dead. - let mut dead_mount_set: HashSet = HashSet::new(); let unit_type = Some(UnitType::UnitMount); for unit in self.comm.um().units_get_all(unit_type).iter() { - if self.comm.um().current_active_state(unit) == UnitActiveState::Active { - dead_mount_set.insert(String::from(unit)); - } + self.comm.um().update_mount_state(unit, "dead"); } - + self.load_mountinfo()?; + for unit in self.comm.um().units_get_all(unit_type).iter() { + self.comm.um().update_mount_state(unit, "mounted"); + } + return Ok(()); + /* // Then start mount point we don't know. let mut mountinfo_content = String::new(); File::open("/proc/self/mountinfo") @@ -459,6 +458,7 @@ impl MountMonitorData { } } Ok(()) + */ } } diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index 3798df4f..2b94a1dc 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -278,11 +278,11 @@ impl MountMng { *self.reload_result.borrow_mut() = r } - fn find_in_mountinfo(&self) -> bool { + pub fn find_in_mountinfo(&self) -> bool { *self.find_in_mountinfo.borrow() } - fn set_find_in_mountinfo(&self, find: bool) { + pub fn set_find_in_mountinfo(&self, find: bool) { *self.find_in_mountinfo.borrow_mut() = find } } diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 49e943fc..8b9ec8c3 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -14,7 +14,7 @@ //! UnitObj,UnitMngUtil, UnitSubClass trait use crate::config::MountConfig; -use crate::rentry::{MountState, MountResult}; +use crate::rentry::MountResult; use super::comm::MountUnitComm; use super::mng::MountMng; @@ -172,14 +172,14 @@ impl SubUnit for MountUnit { return Ok(()); } - self.mng.start_action(); + self.mng.start_action()?; self.mng.enter_mounted(true); Ok(()) } fn stop(&self, _force: bool) -> Result<()> { - self.mng.stop_action(); + self.mng.stop_action()?; self.mng.enter_dead(MountResult::Success, true); Ok(()) } @@ -195,11 +195,32 @@ impl SubUnit for MountUnit { fn reset_failed(&self) {} fn setup_existing_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { - log::info!("(whorwe)setup_existing_mount: 1 | unit: {}", self.comm.get_owner_id()); + if self.config.mount_where().is_empty() { + self.config.set_mount_where(mount_where); + } + self.config.update_mount_parameters(what, options, fstype); + self.mng.set_find_in_mountinfo(true); } fn setup_new_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { - log::info!("(whorwe)setup_new_mount: 1 | unit: {}", self.comm.get_owner_id()); + self.config.set_mount_where(mount_where); + self.config.update_mount_parameters(what, options, fstype); + self.mng.set_find_in_mountinfo(true); + } + + fn update_mount_state(&self, state: &str) { + match state { + "dead" => { + self.mng.set_find_in_mountinfo(false); + self.mng.enter_dead(MountResult::Success, true); + } + "mounted" => { + if self.mng.find_in_mountinfo() { + self.mng.enter_mounted(true); + } + } + _ => {} + } } } diff --git a/core/libcore/src/unit/base.rs b/core/libcore/src/unit/base.rs index 7df88853..29399e48 100644 --- a/core/libcore/src/unit/base.rs +++ b/core/libcore/src/unit/base.rs @@ -175,6 +175,9 @@ pub trait SubUnit: ReStation + UnitMngUtil { /// fn setup_new_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) {} + + /// + fn update_mount_state(&self, state: &str) {} } /// the macro for create a sub unit instance with dyn ref of UmIf, diff --git a/core/libcore/src/unit/umif.rs b/core/libcore/src/unit/umif.rs index b580a91c..e5edc0e0 100644 --- a/core/libcore/src/unit/umif.rs +++ b/core/libcore/src/unit/umif.rs @@ -212,6 +212,9 @@ pub trait UmIf { /// setup new mount fn setup_new_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) {} + + /// update mount state + fn update_mount_state(&self, unit_name: &str, state: &str) {} } /// the trait used for attach UnitManager to sub unit diff --git a/core/sysmaster/src/unit/entry/uentry.rs b/core/sysmaster/src/unit/entry/uentry.rs index 03ebb366..fa5ead74 100644 --- a/core/sysmaster/src/unit/entry/uentry.rs +++ b/core/sysmaster/src/unit/entry/uentry.rs @@ -795,6 +795,10 @@ impl Unit { self.sub.setup_new_mount(what, mount_where, options, fstype); } + pub(crate) fn update_mount_state(&self, state: &str) { + self.sub.update_mount_state(state); + } + pub(crate) fn notify_message( &self, ucred: &UnixCredentials, diff --git a/core/sysmaster/src/unit/manager.rs b/core/sysmaster/src/unit/manager.rs index 539ec657..8f693d2f 100644 --- a/core/sysmaster/src/unit/manager.rs +++ b/core/sysmaster/src/unit/manager.rs @@ -672,14 +672,30 @@ impl UmIf for UnitManager { /// setup new mount fn setup_new_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) { + let mount = match self.load_unitx(unit_name) { + None => { + log::error!("Failed to load a new mount {}", unit_name); + return; + } + Some(v) => { + log::info!("Created a new mount {}", unit_name); + v + } + }; + mount.setup_new_mount(what, mount_where, options, fstype); + mount.set_load_state(UnitLoadState::Loaded); + } + + /// update mount state + fn update_mount_state(&self, unit_name: &str, state: &str) { let mount = match self.units_get(unit_name) { None => { - log::warn!("Unit {} doesn't exist for now, probably we should load it.", unit_name); + log::error!("Failed to update the mount state of {}", unit_name); return; } Some(v) => v, }; - mount.setup_new_mount(what, mount_where, options, fstype); + mount.update_mount_state(state); } } diff --git a/libs/basic/src/process.rs b/libs/basic/src/process.rs index 485f73d8..638eafdd 100644 --- a/libs/basic/src/process.rs +++ b/libs/basic/src/process.rs @@ -17,7 +17,6 @@ use nix::errno::errno; use nix::errno::Errno; use nix::libc::{kill, ESRCH}; use nix::sys::signal::Signal; -use nix::sys::wait::WaitStatus; use nix::sys::wait::{waitpid, WaitPidFlag}; use nix::unistd::Pid; use procfs::process::Stat; @@ -255,11 +254,6 @@ fn is_kernel_thread(pid: Pid) -> Result { } } -/// return true if the wait result is ok -pub fn is_clean_exit(wait_status: WaitStatus) -> bool { - false -} - #[cfg(test)] mod tests { use nix::libc::kill; -- Gitee From 64f49047aba7d605352b49ac32db36d674808cc5 Mon Sep 17 00:00:00 2001 From: licunlong Date: Fri, 1 Dec 2023 10:39:55 +0800 Subject: [PATCH 7/8] fix: cargo fmt --- core/coms/mount/src/config.rs | 6 +- core/coms/mount/src/manager.rs | 61 +++--------------- core/coms/mount/src/mng.rs | 84 +++++++++++++++++++------ core/coms/mount/src/rentry.rs | 7 ++- core/coms/mount/src/spawn.rs | 2 +- core/coms/mount/src/unit.rs | 19 +++--- core/coms/service/src/rentry.rs | 6 +- core/libcore/src/exec/base.rs | 10 ++- core/libcore/src/exec/cmd.rs | 12 +++- core/libcore/src/exec/mod.rs | 8 ++- core/libcore/src/unit/base.rs | 8 +-- core/libcore/src/unit/umif.rs | 22 ++++++- core/sysmaster/src/unit/entry/uentry.rs | 19 +++++- core/sysmaster/src/unit/manager.rs | 18 +++++- libs/basic/src/condition.rs | 2 +- libs/basic/src/fs_util.rs | 14 ++++- 16 files changed, 186 insertions(+), 112 deletions(-) diff --git a/core/coms/mount/src/config.rs b/core/coms/mount/src/config.rs index 2e6a3f82..1bad5dde 100644 --- a/core/coms/mount/src/config.rs +++ b/core/coms/mount/src/config.rs @@ -13,16 +13,17 @@ use std::{cell::RefCell, path::PathBuf, rc::Rc}; -use basic::Error; use unit_parser::prelude::UnitConfig; use crate::{comm::MountUnitComm, rentry::SectionMount}; #[derive(UnitConfig, Default)] +#[allow(non_snake_case)] pub(super) struct MountConfigData { pub Mount: SectionMount, } +#[allow(unused)] pub(super) struct MountConfig { // associated objects comm: Rc, @@ -45,7 +46,7 @@ impl MountConfig { } } - pub(super) fn load(&self, paths: Vec, name: &str, update: bool) { + pub(super) fn load(&self, paths: Vec, name: &str, _update: bool) { log::debug!("Loading {} config from: {:?}", name, paths); let mount_config = match MountConfigData::load_config(paths, name) { Ok(v) => v, @@ -89,6 +90,7 @@ impl MountConfig { self.data.borrow().Mount.DirectoryMode } + #[allow(unused)] pub(super) fn force_unmount(&self) -> bool { self.data.borrow().Mount.ForceUnmount } diff --git a/core/coms/mount/src/manager.rs b/core/coms/mount/src/manager.rs index e4a3f16e..5a0345bf 100644 --- a/core/coms/mount/src/manager.rs +++ b/core/coms/mount/src/manager.rs @@ -21,11 +21,8 @@ use super::rentry::{MountRe, MountReFrame}; use basic::mount_util::{mount_point_to_unit_name, MountInfoParser}; use core::error::*; use core::rel::{ReStation, ReliLastFrame, Reliability}; -use core::unit::{ - unit_name_is_valid, UmIf, UnitActiveState, UnitManagerObj, UnitMngUtil, UnitNameFlags, UnitType, -}; +use core::unit::{unit_name_is_valid, UmIf, UnitManagerObj, UnitMngUtil, UnitNameFlags, UnitType}; use event::{EventState, EventType, Events, Source}; -use std::collections::HashSet; use std::fs::File; use std::io::Read; use std::os::unix::io::{AsRawFd, RawFd}; @@ -337,7 +334,9 @@ impl MountMonitorData { options: &str, fstype: &str, ) -> Result<()> { - self.comm.um().setup_new_mount(unit_name, what, mount_where, options, fstype); + self.comm + .um() + .setup_new_mount(unit_name, what, mount_where, options, fstype); Ok(()) } @@ -349,7 +348,9 @@ impl MountMonitorData { options: &str, fstype: &str, ) -> Result<()> { - self.comm.um().setup_existing_mount(unit_name, what, mount_where, options, fstype); + self.comm + .um() + .setup_existing_mount(unit_name, what, mount_where, options, fstype); Ok(()) } @@ -410,55 +411,7 @@ impl MountMonitorData { for unit in self.comm.um().units_get_all(unit_type).iter() { self.comm.um().update_mount_state(unit, "mounted"); } - return Ok(()); - /* - // Then start mount point we don't know. - let mut mountinfo_content = String::new(); - File::open("/proc/self/mountinfo") - .unwrap() - .read_to_string(&mut mountinfo_content) - .unwrap(); - let parser = MountInfoParser::new(mountinfo_content); - for mount in parser { - // pop - // We don't process autofs for now, because it is not - // .mount but .automount in systemd. - if mount.fstype == "autofs" { - continue; - } - let unit_name = mount_point_to_unit_name(&mount.mount_point); - if dead_mount_set.contains(unit_name.as_str()) { - dead_mount_set.remove(unit_name.as_str()); - } else if self.comm.um().load_unit_success(unit_name.as_str()) { - // record + action - self.comm.reli().set_last_unit(&unit_name); - let start_ok = self.comm.um().unit_start_directly(&unit_name).is_ok(); - self.comm.reli().clear_last_unit(); - - if start_ok { - log::debug!("{} change to mounted.", unit_name); - } else { - log::error!("Failed to start {}", unit_name); - } - } - } - - // Finally stop mount point in dead_mount_set. - for unit_name in dead_mount_set.into_iter() { - // pop - // record + action - self.comm.reli().set_last_unit(&unit_name); - let ret = self.comm.um().unit_stop(&unit_name, false); - self.comm.reli().clear_last_unit(); - - if ret.is_ok() { - log::debug!("{} change to dead.", unit_name); - } else { - log::error!("Failed to stop {}.", unit_name); - } - } Ok(()) - */ } } diff --git a/core/coms/mount/src/mng.rs b/core/coms/mount/src/mng.rs index 2b94a1dc..1bbdabee 100644 --- a/core/coms/mount/src/mng.rs +++ b/core/coms/mount/src/mng.rs @@ -11,12 +11,12 @@ // See the Mulan PSL v2 for more details. //! The core logic of the mount subclass -use basic::{MOUNT_BIN, UMOUNT_BIN}; use basic::fs_util::{directory_is_empty, mkdir_p_label}; use basic::mount_util::filter_options; +use basic::{MOUNT_BIN, UMOUNT_BIN}; use nix::sys::wait::WaitStatus; -use crate::config::{MountConfig, mount_is_bind}; +use crate::config::{mount_is_bind, MountConfig}; use crate::rentry::MountResult; use crate::spawn::MountSpawn; @@ -70,7 +70,11 @@ impl ReStation for MountMng { } impl MountMng { - pub(super) fn new(commr: &Rc, configr: &Rc, exec_ctx: &Rc) -> Self { + pub(super) fn new( + commr: &Rc, + configr: &Rc, + exec_ctx: &Rc, + ) -> Self { MountMng { comm: Rc::clone(commr), state: RefCell::new(MountState::Dead), @@ -93,20 +97,31 @@ impl MountMng { let _ = mkdir_p_label(mount_where, directory_mode); if !mount_where.exists() || !mount_where.is_dir() { - log::error!("Failed to create the mount directory: {}", mount_config.Mount.Where); + log::error!( + "Failed to create the mount directory: {}", + mount_config.Mount.Where + ); return; } if !directory_is_empty(mount_where) { - log::warn!("The mount directory {} is not empty.", mount_config.Mount.Where); + log::warn!( + "The mount directory {} is not empty.", + mount_config.Mount.Where + ); } let mount_parameters = self.config.mount_parameters(); if mount_is_bind(&mount_parameters) { if let Err(e) = mkdir_p_label(mount_what, directory_mode) { - log::error!("Failed to create mount source {}: {}", mount_config.Mount.What, e); + log::error!( + "Failed to create mount source {}: {}", + mount_config.Mount.What, + e + ); } } - let filtered_options = filter_options(&mount_parameters.options, vec!["nofail", "noauto", "auto"]); + let filtered_options = + filter_options(&mount_parameters.options, vec!["nofail", "noauto", "auto"]); let mut mount_command = ExecCommand::empty(); if let Err(e) = mount_command.set_path(MOUNT_BIN) { @@ -122,18 +137,23 @@ impl MountMng { } *self.control_command.borrow_mut() = Some(mount_command.clone()); if let Err(e) = self.spawn.spawn_cmd(&mount_command) { - log::error!("Failed to mount {} to {}: {}", &mount_config.Mount.What, &mount_config.Mount.Where, e); + log::error!( + "Failed to mount {} to {}: {}", + &mount_config.Mount.What, + &mount_config.Mount.Where, + e + ); return; } self.set_state(MountState::Mounting, true); } - pub(super) fn enter_signal(&self, state: MountState, res: MountResult) {} + pub(super) fn enter_signal(&self, _state: MountState, _res: MountResult) {} - pub(super) fn enter_dead_or_mounted(&self, res: MountResult) {} + pub(super) fn enter_dead_or_mounted(&self, _res: MountResult) {} - pub(super) fn enter_dead(&self, res: MountResult, notify: bool) { + pub(super) fn enter_dead(&self, _res: MountResult, notify: bool) { self.set_state(MountState::Dead, notify); } @@ -157,8 +177,10 @@ impl MountMng { self.set_state(MountState::Unmounting, true); } + #[allow(unused)] pub(super) fn enter_remounting(&self) {} + #[allow(unused)] pub(super) fn dispatch_timer(&self) {} pub(super) fn start_check(&self) -> Result { @@ -192,10 +214,22 @@ impl MountMng { pub(super) fn stop_action(&self) -> Result { let state = self.state(); - if [MountState::Unmounting, MountState::UnmountingSigkill, MountState::UnmountingSigterm].contains(&state) { + if [ + MountState::Unmounting, + MountState::UnmountingSigkill, + MountState::UnmountingSigterm, + ] + .contains(&state) + { return Ok(0); } - if [MountState::Mounting, MountState::MountingDone, MountState::Remounting].contains(&state) { + if [ + MountState::Mounting, + MountState::MountingDone, + MountState::Remounting, + ] + .contains(&state) + { self.enter_signal(MountState::UnmountingSigterm, MountResult::Success); return Ok(0); } @@ -298,7 +332,13 @@ impl MountMng { let mut f = self.sigchld_result(wait_status); let state = self.state(); - if [MountState::Remounting, MountState::RemountingSigKill, MountState::RemountingSigterm].contains(&state) { + if [ + MountState::Remounting, + MountState::RemountingSigKill, + MountState::RemountingSigterm, + ] + .contains(&state) + { self.set_reload_result(f); } else if self.result() == MountResult::Success { self.set_result(f); @@ -310,7 +350,10 @@ impl MountMng { // mount process has exited, but the mount point is not mounted if state == MountState::Mounting { if f == MountResult::Success { - log::warn!("Mount process of {} has exited, but there is no mount.", self.comm.get_owner_id()); + log::warn!( + "Mount process of {} has exited, but there is no mount.", + self.comm.get_owner_id() + ); f = MountResult::FailureProtocol; } self.enter_dead(f, true); @@ -323,7 +366,13 @@ impl MountMng { return; } - if [MountState::Remounting, MountState::RemountingSigKill, MountState::RemountingSigterm].contains(&state) { + if [ + MountState::Remounting, + MountState::RemountingSigKill, + MountState::RemountingSigterm, + ] + .contains(&state) + { self.enter_dead_or_mounted(MountResult::Success); return; } @@ -340,10 +389,7 @@ impl MountMng { if [MountState::UnmountingSigkill, MountState::UnmountingSigterm].contains(&state) { self.enter_dead_or_mounted(f); - return; } - - return; } fn sigchld_result(&self, wait_status: WaitStatus) -> MountResult { diff --git a/core/coms/mount/src/rentry.rs b/core/coms/mount/src/rentry.rs index dbc749ef..ef19514f 100644 --- a/core/coms/mount/src/rentry.rs +++ b/core/coms/mount/src/rentry.rs @@ -10,10 +10,13 @@ // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. // See the Mulan PSL v2 for more details. -use core::{rel::{ReDb, ReDbRwTxn, ReDbTable, ReliSwitch, Reliability}, exec::{WorkingDirectory, StateDirectory, RuntimeDirectory, PreserveMode, Rlimit}}; +use core::{ + exec::{PreserveMode, Rlimit, RuntimeDirectory, StateDirectory, WorkingDirectory}, + rel::{ReDb, ReDbRwTxn, ReDbTable, ReliSwitch, Reliability}, +}; use macros::{EnumDisplay, UnitSection}; use serde::{Deserialize, Serialize}; -use std::{rc::Rc, path::PathBuf, collections::HashMap}; +use std::{collections::HashMap, path::PathBuf, rc::Rc}; const RELI_DB_HMOUNT_MNG: &str = "mntmng"; const RELI_DB_HMOUNTM_FRAME: &str = "mntm-frame"; diff --git a/core/coms/mount/src/spawn.rs b/core/coms/mount/src/spawn.rs index cc49c9c2..5a536536 100644 --- a/core/coms/mount/src/spawn.rs +++ b/core/coms/mount/src/spawn.rs @@ -12,7 +12,7 @@ // use core::error::*; -use core::exec::{ExecCommand, ExecParameters, ExecContext}; +use core::exec::{ExecCommand, ExecContext, ExecParameters}; use std::rc::Rc; use nix::unistd::Pid; diff --git a/core/coms/mount/src/unit.rs b/core/coms/mount/src/unit.rs index 8b9ec8c3..17768c6d 100644 --- a/core/coms/mount/src/unit.rs +++ b/core/coms/mount/src/unit.rs @@ -18,11 +18,11 @@ use crate::rentry::MountResult; use super::comm::MountUnitComm; use super::mng::MountMng; +use basic::mount_util::mount_point_to_unit_name; use core::error::*; use core::exec::ExecContext; use core::rel::{ReStation, Reliability}; use core::unit::{SubUnit, UmIf, UnitActiveState, UnitBase, UnitMngUtil}; -use basic::mount_util::mount_point_to_unit_name; use nix::sys::wait::WaitStatus; use std::path::PathBuf; use std::rc::Rc; @@ -65,10 +65,10 @@ impl MountUnit { let exec_ctx = Rc::new(ExecContext::new()); let mng = Rc::new(MountMng::new(&comm, &config, &exec_ctx)); MountUnit { - comm: comm.clone(), - mng: mng.clone(), - config: config.clone(), - exec_ctx: exec_ctx.clone(), + comm, + mng, + config, + exec_ctx, } } @@ -126,8 +126,13 @@ impl MountUnit { fn mount_verify(&self) -> Result<()> { let mount_where = self.config.mount_where(); if !mount_point_to_unit_name(&mount_where).eq(&self.comm.get_owner_id()) { - log::error!("Failed to load unit {}: unit name doesn't match Where", self.comm.get_owner_id()); - return Err(Error::ConfigureError { msg: "unit name doesn't match Where".to_string() }); + log::error!( + "Failed to load unit {}: unit name doesn't match Where", + self.comm.get_owner_id() + ); + return Err(Error::ConfigureError { + msg: "unit name doesn't match Where".to_string(), + }); } Ok(()) } diff --git a/core/coms/service/src/rentry.rs b/core/coms/service/src/rentry.rs index 7eb5b0f8..798a2724 100644 --- a/core/coms/service/src/rentry.rs +++ b/core/coms/service/src/rentry.rs @@ -13,15 +13,13 @@ #![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_util::{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; use nix::sys::wait::WaitStatus; use nix::unistd::Pid; use serde::{Deserialize, Serialize}; -use core::exec::PreserveMode; use std::collections::HashMap; use std::path::Path; use std::path::PathBuf; diff --git a/core/libcore/src/exec/base.rs b/core/libcore/src/exec/base.rs index 07a5887e..134a8c04 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_simplify, path_name_is_safe, path_length_is_valid, path_is_abosolute}; +use basic::fs_util::{path_is_abosolute, path_length_is_valid, path_name_is_safe, path_simplify}; use basic::rlimit; use bitflags::bitflags; use libc::EPERM; @@ -120,9 +120,13 @@ impl FromStr for Rlimit { } #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)] +/// pub enum PreserveMode { + /// No, + /// Yes, + /// Restart, } @@ -172,6 +176,7 @@ pub struct WorkingDirectory { miss_ok: bool, } +/// pub fn parse_working_directory(s: &str) -> Result { if s.is_empty() { return Ok(WorkingDirectory::new(None, true)); @@ -216,6 +221,7 @@ pub struct RuntimeDirectory { directory: Vec, } +/// pub fn parse_runtime_directory(s: &str) -> Result { let mut res = RuntimeDirectory::default(); for d in s.split_terminator(';') { @@ -258,6 +264,7 @@ pub struct StateDirectory { directory: Vec, } +/// pub fn parse_state_directory(s: &str) -> Result { /* Similar with RuntimeDirectory */ let mut res = StateDirectory::default(); @@ -318,6 +325,7 @@ impl Default for ExecContext { } } +/// pub fn parse_environment(s: &str) -> Result> { #[derive(PartialEq, Clone, Copy)] enum ParseState { diff --git a/core/libcore/src/exec/cmd.rs b/core/libcore/src/exec/cmd.rs index 7c597928..af1fb7d9 100644 --- a/core/libcore/src/exec/cmd.rs +++ b/core/libcore/src/exec/cmd.rs @@ -14,7 +14,7 @@ use crate::serialize::DeserializeWith; use crate::specifier::{ unit_string_specifier_escape, unit_strings_specifier_escape, UnitSpecifierData, }; -use basic::fs_util::{path_simplify, path_is_abosolute}; +use basic::fs_util::{path_is_abosolute, path_simplify}; use basic::{fs_util::parse_absolute_path, Error, Result}; use bitflags::bitflags; use serde::{ @@ -86,10 +86,16 @@ impl ExecCommand { /// pub fn set_path(&mut self, path: &str) -> Result<()> { if !path_is_abosolute(path) { - return Err(Error::Invalid { what: "ExecCmd path should be absolute".to_string() }); + return Err(Error::Invalid { + what: "ExecCmd path should be absolute".to_string(), + }); } let v = match path_simplify(path) { - None => return Err(Error::Invalid { what: "Invalid ExecCmd path".to_string() }), + None => { + return Err(Error::Invalid { + what: "Invalid ExecCmd path".to_string(), + }) + } Some(v) => v, }; self.path = v; diff --git a/core/libcore/src/exec/mod.rs b/core/libcore/src/exec/mod.rs index 481c2550..ba009f61 100644 --- a/core/libcore/src/exec/mod.rs +++ b/core/libcore/src/exec/mod.rs @@ -14,10 +14,12 @@ mod base; mod cmd; pub use base::{ - ExecContext, ExecDirectoryType, ExecFlags, ExecParameters, Rlimit, RuntimeDirectory, - StateDirectory, WorkingDirectory, PreserveMode + parse_environment, parse_runtime_directory, parse_state_directory, parse_working_directory, +}; +pub use base::{ + ExecContext, ExecDirectoryType, ExecFlags, ExecParameters, PreserveMode, Rlimit, + RuntimeDirectory, StateDirectory, WorkingDirectory, }; -pub use base::{parse_environment, parse_runtime_directory, parse_state_directory, parse_working_directory}; pub use cmd::parse_exec_command; pub use cmd::ExecCommand; pub use cmd::ExecFlag; diff --git a/core/libcore/src/unit/base.rs b/core/libcore/src/unit/base.rs index 29399e48..3f0df840 100644 --- a/core/libcore/src/unit/base.rs +++ b/core/libcore/src/unit/base.rs @@ -168,16 +168,16 @@ pub trait SubUnit: ReStation + UnitMngUtil { /// fn release_socket_fd(&self, _fd: i32) {} - // ================ ONLY VALID FOR MOUNT ================ /// - fn setup_existing_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) {} + fn setup_existing_mount(&self, _what: &str, _mount_where: &str, _options: &str, _fstype: &str) { + } /// - fn setup_new_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) {} + fn setup_new_mount(&self, _what: &str, _mount_where: &str, _options: &str, _fstype: &str) {} /// - fn update_mount_state(&self, state: &str) {} + fn update_mount_state(&self, _state: &str) {} } /// the macro for create a sub unit instance with dyn ref of UmIf, diff --git a/core/libcore/src/unit/umif.rs b/core/libcore/src/unit/umif.rs index e5edc0e0..62df8215 100644 --- a/core/libcore/src/unit/umif.rs +++ b/core/libcore/src/unit/umif.rs @@ -208,13 +208,29 @@ pub trait UmIf { /* ========== ONLY VALID IN MOUNT ========== */ /// setup existing mount - fn setup_existing_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) {} + fn setup_existing_mount( + &self, + _unit_name: &str, + _what: &str, + _mount_where: &str, + _options: &str, + _fstype: &str, + ) { + } /// setup new mount - fn setup_new_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) {} + fn setup_new_mount( + &self, + _unit_name: &str, + _what: &str, + _mount_where: &str, + _options: &str, + _fstype: &str, + ) { + } /// update mount state - fn update_mount_state(&self, unit_name: &str, state: &str) {} + fn update_mount_state(&self, _unit_name: &str, _state: &str) {} } /// the trait used for attach UnitManager to sub unit diff --git a/core/sysmaster/src/unit/entry/uentry.rs b/core/sysmaster/src/unit/entry/uentry.rs index fa5ead74..25d2adf2 100644 --- a/core/sysmaster/src/unit/entry/uentry.rs +++ b/core/sysmaster/src/unit/entry/uentry.rs @@ -787,11 +787,24 @@ impl Unit { self.sub.release_socket_fd(fd) } - pub(crate) fn setup_existing_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { - self.sub.setup_existing_mount(what, mount_where, options, fstype); + pub(crate) fn setup_existing_mount( + &self, + what: &str, + mount_where: &str, + options: &str, + fstype: &str, + ) { + self.sub + .setup_existing_mount(what, mount_where, options, fstype); } - pub(crate) fn setup_new_mount(&self, what: &str, mount_where: &str, options: &str, fstype: &str) { + pub(crate) fn setup_new_mount( + &self, + what: &str, + mount_where: &str, + options: &str, + fstype: &str, + ) { self.sub.setup_new_mount(what, mount_where, options, fstype); } diff --git a/core/sysmaster/src/unit/manager.rs b/core/sysmaster/src/unit/manager.rs index 8f693d2f..18cfb231 100644 --- a/core/sysmaster/src/unit/manager.rs +++ b/core/sysmaster/src/unit/manager.rs @@ -659,7 +659,14 @@ impl UmIf for UnitManager { } /// setup existing mount - fn setup_existing_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) { + fn setup_existing_mount( + &self, + unit_name: &str, + what: &str, + mount_where: &str, + options: &str, + fstype: &str, + ) { let mount = match self.units_get(unit_name) { None => { log::error!("Failed to get unit: {}", unit_name); @@ -671,7 +678,14 @@ impl UmIf for UnitManager { } /// setup new mount - fn setup_new_mount(&self, unit_name: &str, what: &str, mount_where: &str, options: &str, fstype: &str) { + fn setup_new_mount( + &self, + unit_name: &str, + what: &str, + mount_where: &str, + options: &str, + fstype: &str, + ) { let mount = match self.load_unitx(unit_name) { None => { log::error!("Failed to load a new mount {}", unit_name); diff --git a/libs/basic/src/condition.rs b/libs/basic/src/condition.rs index be17be0a..923f0002 100644 --- a/libs/basic/src/condition.rs +++ b/libs/basic/src/condition.rs @@ -195,7 +195,7 @@ impl Condition { } fn test_directory_not_empty(&self) -> i8 { - !directory_is_empty(&Path::new(&self.params)) as i8 + !directory_is_empty(Path::new(&self.params)) as i8 } fn test_file_is_executable(&self) -> i8 { diff --git a/libs/basic/src/fs_util.rs b/libs/basic/src/fs_util.rs index 23381e6f..2ad2a8aa 100644 --- a/libs/basic/src/fs_util.rs +++ b/libs/basic/src/fs_util.rs @@ -323,13 +323,20 @@ pub fn mkdir_p_label(path: &Path, mode: u32) -> Result<()> { let simplified_path = match path_simplify(&path_str) { None => { - return Err(Error::Invalid { what: format!("Invalid path: {}", path_str) }); + return Err(Error::Invalid { + what: format!("Invalid path: {}", path_str), + }); } Some(v) => v, }; if !path_is_abosolute(&simplified_path) { - return Err(Error::Invalid { what: format!("Invalid Path: {}, only abosolute path is allowed.", path_str)}); + return Err(Error::Invalid { + what: format!( + "Invalid Path: {}, only abosolute path is allowed.", + path_str + ), + }); } let mode = Mode::from_bits_truncate(mode); @@ -341,7 +348,7 @@ pub fn mkdir_p_label(path: &Path, mode: u32) -> Result<()> { continue; } if let Err(e) = mkdir(&cur_path, mode) { - return Err(Error::Nix { source: e }) + return Err(Error::Nix { source: e }); } } Ok(()) @@ -650,6 +657,7 @@ pub fn parse_absolute_path(s: &str) -> Result { Ok(path) } +/// pub fn parse_pathbuf(s: &str) -> Result { let path = parse_absolute_path(s).map_err(|_| Error::Invalid { what: "Invalid PathBuf".to_string(), -- Gitee From 026f6ed29c8524a30c81bfa04ba7f2871af66c2c Mon Sep 17 00:00:00 2001 From: licunlong Date: Fri, 1 Dec 2023 17:26:40 +0800 Subject: [PATCH 8/8] fix: add directory_is_not_empty directory_is_not_empty doen't equal to !directory_is_empty. If the given path is a file, both directory_is_not_empty and directory_is_empty should return false --- libs/basic/src/condition.rs | 4 ++-- libs/basic/src/fs_util.rs | 16 +++++++++++++--- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/libs/basic/src/condition.rs b/libs/basic/src/condition.rs index 923f0002..39d09e5f 100644 --- a/libs/basic/src/condition.rs +++ b/libs/basic/src/condition.rs @@ -22,7 +22,7 @@ use nix::{ use libc::{glob, glob_t, GLOB_NOSORT}; use crate::{ - cmdline, fd_util, fs_util::directory_is_empty, mount_util::is_mount_point, security, + cmdline, fd_util, fs_util::directory_is_not_empty, mount_util::is_mount_point, security, sysfs::SysFs, unistd, }; @@ -195,7 +195,7 @@ impl Condition { } fn test_directory_not_empty(&self) -> i8 { - !directory_is_empty(Path::new(&self.params)) as i8 + directory_is_not_empty(Path::new(&self.params)) as i8 } fn test_file_is_executable(&self) -> i8 { diff --git a/libs/basic/src/fs_util.rs b/libs/basic/src/fs_util.rs index 2ad2a8aa..dcc110ae 100644 --- a/libs/basic/src/fs_util.rs +++ b/libs/basic/src/fs_util.rs @@ -357,15 +357,25 @@ pub fn mkdir_p_label(path: &Path, mode: u32) -> Result<()> { /// mkdir parents with the given label pub fn mkdir_parents_label() {} +/// check if the given directory is not empty +pub fn directory_is_not_empty(path: &Path) -> bool { + if path.is_file() { + return false; + } + let mut iter = match path.read_dir() { + Err(_) => return false, + Ok(v) => v, + }; + iter.next().is_some() +} + /// check if the given directory is empty pub fn directory_is_empty(path: &Path) -> bool { if path.is_file() { return false; } let mut iter = match path.read_dir() { - Err(_) => { - return false; - } + Err(_) => return false, Ok(v) => v, }; iter.next().is_none() -- Gitee