Merge origin/main: resolve conflict in basic_collector

Merge latest changes from origin/main which added euid check to
basic_collector for better process filtering. Kept mutable borrow
for tty() method as required by PR uutils#533.

Author: naoNao89

Cargo.lock

@@ -58,7 +58,7 @@ clap = { version = "4.5.4", features = ["wrap_help", "cargo", "env"] }
 clap_complete = "4.5.2"
 clap_mangen = "0.2.20"
 crossterm = "0.29.0"
-ctor = "0.5.0"
+ctor = "0.6.0"
 dirs = "6.0.0"
 jiff = "0.2.15"
 libc = "0.2.154"
@@ -75,7 +75,7 @@ terminal_size = "0.4.2"
 textwrap = { version = "0.16.1", features = ["terminal_size"] }
 thiserror = "2.0.4"
 uucore = "0.2.2"
-uutests = "0.2.0"
+uutests = "0.3.0"
 walkdir = "2.5.0"
 windows = { version = "0.62.0" }
 windows-sys = { version = "0.61.0", default-features = false }

Cargo.toml

@@ -3,7 +3,7 @@
 [![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/procps/blob/main/LICENSE)
 [![dependency status](https://deps.rs/repo/github/uutils/procps/status.svg)](https://deps.rs/repo/github/uutils/procps)
 
-[![CodeCov](https://codecov.io/gh/uutils/procps/branch/master/graph/badge.svg)](https://codecov.io/gh/uutils/procps)
+[![CodeCov](https://codecov.io/gh/uutils/procps/branch/main/graph/badge.svg)](https://codecov.io/gh/uutils/procps)
 
 # procps
 

README.md

@@ -35,19 +35,12 @@ pub(crate) fn basic_collector(
 ) -> Vec<Rc<RefCell<ProcessInformation>>> {
     let mut result = Vec::new();
 
-    let current_tty = {
-        // SAFETY: The `libc::getpid` always return i32
-        let proc_path =
-            PathBuf::from_str(&format!("/proc/{}/", unsafe { libc::getpid() })).unwrap();
-        let mut current_proc_info = ProcessInformation::try_new(proc_path).unwrap();
-
-        current_proc_info.tty()
-    };
+    let mut cur = ProcessInformation::current_process_info().unwrap();
+    let tty = cur.tty();
+    let euid = cur.euid().unwrap();
 
     for proc_info in proc_snapshot {
-        let proc_ttys = proc_info.borrow_mut().tty();
-
-        if proc_ttys == current_tty {
+        if proc_info.borrow_mut().tty() == tty && proc_info.borrow_mut().euid().unwrap() == euid {
             result.push(proc_info.clone());
         }
     }

src/uu/ps/src/collector.rs

@@ -38,10 +38,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .collect::<Vec<_>>();
     let mut proc_infos = Vec::new();
 
-    proc_infos.extend(collector::basic_collector(&snapshot));
-    proc_infos.extend(collector::process_collector(&matches, &snapshot));
-    proc_infos.extend(collector::session_collector(&matches, &snapshot));
+    if !matches.get_flag("A") && !matches.get_flag("a") && !matches.get_flag("d") {
+        proc_infos.extend(collector::basic_collector(&snapshot));
+    } else {
+        proc_infos.extend(collector::process_collector(&matches, &snapshot));
+        proc_infos.extend(collector::session_collector(&matches, &snapshot));
+    }
 
+    proc_infos.sort_by(|a, b| a.borrow().pid.cmp(&b.borrow().pid));
     proc_infos.dedup_by(|a, b| a.borrow().pid == b.borrow().pid);
 
     sorting::sort(&mut proc_infos, &matches);

src/uu/ps/src/ps.rs

@@ -11,7 +11,7 @@ license.workspace = true
 version.workspace = true
 
 [dependencies]
-uucore = { workspace = true, features = ["utmpx", "uptime"] }
+uucore = { workspace = true, features = ["utmpx", "uptime", "signals"] }
 clap = { workspace = true }
 crossterm = { workspace = true }
 libc = { workspace = true }

src/uu/top/Cargo.toml

@@ -0,0 +1,28 @@
+// This file is part of the uutils procps package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(target_os = "linux")]
+pub(crate) fn renice(pid: u32, nice_value: i32) -> uucore::error::UResult<()> {
+    use libc::{setpriority, PRIO_PROCESS};
+    use uucore::error::USimpleError;
+
+    let result = unsafe { setpriority(PRIO_PROCESS, pid, nice_value) };
+    if result == -1 {
+        Err(USimpleError::new(0, "Permission Denied"))
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(unix)]
+pub(crate) fn kill_process(pid: u32, sig: usize) -> uucore::error::UResult<()> {
+    use nix::sys::signal;
+    use nix::sys::signal::Signal;
+    use nix::unistd::Pid;
+    use uucore::error::USimpleError;
+
+    signal::kill(Pid::from_raw(pid as i32), Signal::try_from(sig as i32)?)
+        .map_err(|_| USimpleError::new(0, "Permission Denied"))
+}

src/uu/top/src/action.rs

@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::tui::stat::TuiStat;
+use crate::tui::stat::{TimeScale, TuiStat};
 use crate::Settings;
 use std::any::Any;
 use std::cmp::Ordering;
@@ -24,13 +24,13 @@ pub fn sysinfo() -> &'static RwLock<System> {
 }
 
 pub trait Column {
-    fn as_string(&self, show_zeros: bool) -> String;
+    fn as_string(&self, tui_stat: &TuiStat) -> String;
     fn cmp_dyn(&self, other: &dyn Column) -> Ordering;
     fn as_any(&self) -> &dyn Any;
 }
 
 impl Column for String {
-    fn as_string(&self, _show_zeros: bool) -> String {
+    fn as_string(&self, _tui_stat: &TuiStat) -> String {
         self.clone()
     }
 
@@ -47,8 +47,8 @@ impl Column for String {
 }
 
 impl Column for u32 {
-    fn as_string(&self, show_zeros: bool) -> String {
-        if !show_zeros && self == &0 {
+    fn as_string(&self, tui_stat: &TuiStat) -> String {
+        if !tui_stat.show_zeros && self == &0 {
             return String::new();
         }
         self.to_string()
@@ -67,8 +67,8 @@ impl Column for u32 {
 }
 
 impl Column for Option<i32> {
-    fn as_string(&self, show_zeros: bool) -> String {
-        if !show_zeros && self == &Some(0) {
+    fn as_string(&self, tui_stat: &TuiStat) -> String {
+        if !tui_stat.show_zeros && self == &Some(0) {
             return String::new();
         }
         self.map(|v| v.to_string()).unwrap_or_default()
@@ -102,8 +102,8 @@ impl PercentValue {
 }
 
 impl Column for PercentValue {
-    fn as_string(&self, show_zeros: bool) -> String {
-        if !show_zeros && self.value == 0.0 {
+    fn as_string(&self, tui_stat: &TuiStat) -> String {
+        if !tui_stat.show_zeros && self.value == 0.0 {
             return String::new();
         }
         format!("{:.1}", self.value)
@@ -132,8 +132,8 @@ impl MemValue {
 }
 
 impl Column for MemValue {
-    fn as_string(&self, show_zeros: bool) -> String {
-        if !show_zeros && self.value == 0 {
+    fn as_string(&self, tui_stat: &TuiStat) -> String {
+        if !tui_stat.show_zeros && self.value == 0 {
             return String::new();
         }
         let mem_mb = self.value as f64 / bytesize::MIB as f64;
@@ -156,33 +156,63 @@ impl Column for MemValue {
     }
 }
 
-struct TimeMSValue {
-    min: u64,
+struct TimeValue {
     sec: f64,
 }
 
-impl TimeMSValue {
-    fn new_boxed(min: u64, sec: f64) -> Box<Self> {
-        Box::new(Self { min, sec })
+impl TimeValue {
+    fn new_boxed(sec: f64) -> Box<Self> {
+        Box::new(Self { sec })
     }
 }
 
-impl Column for TimeMSValue {
-    fn as_string(&self, show_zeros: bool) -> String {
-        if !show_zeros && self.min == 0 && self.sec < 0.01 {
+impl Column for TimeValue {
+    fn as_string(&self, tui_stat: &TuiStat) -> String {
+        if !tui_stat.show_zeros && self.sec < 0.01 {
             return String::new();
         }
-        format!("{}:{:0>5.2}", self.min, self.sec)
+        match tui_stat.time_scale {
+            TimeScale::MinSecondCent => {
+                let min = (self.sec / 60.0).floor() as u32;
+                let sec = self.sec - (min * 60) as f64;
+                format!("{}:{:0>5.2}", min, sec)
+            }
+            TimeScale::MinSecond => {
+                let min = (self.sec / 60.0).floor() as u32;
+                let sec = (self.sec - (min * 60) as f64).floor() as u32;
+                format!("{}:{:0>2}", min, sec)
+            }
+            TimeScale::HourMin => {
+                let hour = (self.sec / 3600.0).floor() as u32;
+                let min = ((self.sec - (hour * 3600) as f64) / 60.0).floor() as u32;
+                format!("{},{:0>2}", hour, min)
+            }
+            TimeScale::DayHour => {
+                let day = (self.sec / 86400.0).floor() as u32;
+                let hour = ((self.sec - (day * 86400) as f64) / 3600.0).floor() as u32;
+                format!("{}d+{}h", day, hour)
+            }
+            TimeScale::Day => {
+                let day = (self.sec / 86400.0).floor() as u32;
+                format!("{}d", day)
+            }
+            TimeScale::WeekDay => {
+                let week = (self.sec / 604800.0).floor() as u32;
+                let day = ((self.sec - (week * 604800) as f64) / 86400.0).floor() as u32;
+                format!("{}w+{}d", week, day)
+            }
+            TimeScale::Week => {
+                let week = (self.sec / 604800.0).floor() as u32;
+                format!("{}w", week)
+            }
+        }
     }
 
     fn cmp_dyn(&self, other: &dyn Column) -> Ordering {
         other
             .as_any()
-            .downcast_ref::<TimeMSValue>()
-            .map(|o| match self.min.cmp(&o.min) {
-                Ordering::Equal => self.sec.partial_cmp(&o.sec).unwrap_or(Ordering::Equal),
-                ord => ord,
-            })
+            .downcast_ref::<TimeValue>()
+            .map(|o| self.sec.partial_cmp(&o.sec).unwrap_or(Ordering::Equal))
             .unwrap_or(Ordering::Equal)
     }
     fn as_any(&self) -> &dyn Any {
@@ -383,18 +413,12 @@ fn s(pid: u32, _stat: Stat) -> Box<dyn Column> {
 fn time_plus(pid: u32, _stat: Stat) -> Box<dyn Column> {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
-        return TimeMSValue::new_boxed(0, 0.0);
+        return TimeValue::new_boxed(0.0);
     };
 
-    let (min, sec) = {
-        let total = proc.accumulated_cpu_time();
-        let minute = total / (60 * 1000);
-        let second = (total % (60 * 1000)) as f64 / 1000.0;
+    let second = proc.accumulated_cpu_time() as f64 / 1000.0;
 
-        (minute, second)
-    };
-
-    TimeMSValue::new_boxed(min, sec)
+    TimeValue::new_boxed(second)
 }
 
 fn mem(pid: u32, _stat: Stat) -> Box<dyn Column> {
@@ -408,8 +432,42 @@ fn mem(pid: u32, _stat: Stat) -> Box<dyn Column> {
     )
 }
 
-fn command(pid: u32, stat: Stat) -> Box<dyn Column> {
-    let full_command_line = stat.1.full_command_line;
+#[cfg(target_os = "linux")]
+pub(crate) fn get_supplementary_groups(pid: u32) -> String {
+    use sysinfo::{Gid, Groups};
+
+    let groups = Groups::new_with_refreshed_list();
+    let path = PathBuf::from_str(&format!("/proc/{pid}/status")).unwrap();
+    if let Ok(file) = File::open(path) {
+        let content = read_to_string(file).unwrap();
+        for line in content.lines() {
+            if line.starts_with("Groups:") {
+                let groups = line
+                    .split_whitespace()
+                    .skip(1)
+                    .filter_map(|s| Gid::from_str(s).ok())
+                    .filter_map(|gid| groups.iter().find(|g| g.id() == &gid))
+                    .map(|group| group.name())
+                    .collect::<Vec<_>>()
+                    .join(",");
+                return groups;
+            }
+        }
+    }
+    String::new()
+}
+
+#[cfg(target_os = "linux")]
+pub(crate) fn get_cgroup(pid: u32) -> String {
+    let path = PathBuf::from_str(&format!("/proc/{pid}/cgroup")).unwrap();
+    if let Ok(file) = File::open(path) {
+        read_to_string(file).unwrap()
+    } else {
+        String::new()
+    }
+}
+
+pub(crate) fn get_command(pid: u32, full_command_line: bool) -> String {
     let f = |cmd: &[OsString]| -> String {
         let binding = cmd
             .iter()
@@ -444,23 +502,26 @@ fn command(pid: u32, stat: Stat) -> Box<dyn Column> {
 
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
-        return Box::new("?".to_string());
+        return "?".to_string();
     };
 
-    Box::new(
-        proc.exe()
-            .and_then(|it| {
-                if full_command_line {
-                    it.iter().next_back()
-                } else {
-                    it.file_name()
-                }
-            })
-            .map(|it| it.to_str().unwrap().to_string())
-            .unwrap_or(if full_command_line {
-                f(proc.cmd())
+    proc.exe()
+        .and_then(|it| {
+            if full_command_line {
+                it.iter().next_back()
             } else {
-                proc.name().to_str().unwrap().to_string()
-            }),
-    )
+                it.file_name()
+            }
+        })
+        .map(|it| it.to_str().unwrap().to_string())
+        .unwrap_or(if full_command_line {
+            f(proc.cmd())
+        } else {
+            proc.name().to_str().unwrap().to_string()
+        })
+}
+
+fn command(pid: u32, stat: Stat) -> Box<dyn Column> {
+    let full_command_line = stat.1.full_command_line;
+    Box::new(get_command(pid, full_command_line))
 }