Merge pull request #549 from Bluemangoo/feature/top-tui-sg-action

top: impl `^u` `r` `k`

Author: cakebaker

src/uu/top/Cargo.toml

@@ -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/src/action.rs

@@ -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/picker.rs

@@ -432,6 +432,32 @@ fn mem(pid: u32, _stat: Stat) -> Box<dyn Column> {
     )
 }
 
+#[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) {

src/uu/top/src/top.rs

@@ -24,6 +24,7 @@ use uucore::{
 const ABOUT: &str = help_about!("top.md");
 const USAGE: &str = help_usage!("top.md");
 
+mod action;
 mod field;
 mod header;
 mod picker;

src/uu/top/src/tui/input.rs

@@ -4,7 +4,7 @@
 // file that was distributed with this source code.
 
 use crate::header::Header;
-use crate::picker::{get_cgroup, get_command};
+use crate::picker::get_command;
 use crate::platform::get_numa_nodes;
 use crate::tui::stat::{CpuValueMode, TuiStat};
 use crate::Filter::{EUser, User};
@@ -26,6 +26,14 @@ pub(crate) enum InputEvent {
     FilterEUser,
     WidthIncrement,
     Delay,
+    #[cfg(target_os = "linux")]
+    ReniceProc,
+    #[cfg(target_os = "linux")]
+    ReniceValue,
+    #[cfg(unix)]
+    KillProc,
+    #[cfg(unix)]
+    KillSignal,
 }
 
 macro_rules! char {
@@ -98,6 +106,7 @@ pub fn handle_input(
                 data.write().unwrap().1 = ProcList::new(settings, &tui_stat.read().unwrap());
                 should_update.store(true, Ordering::Relaxed);
             }
+            #[cfg(target_os = "linux")]
             Event::Key(KeyEvent {
                 code: KeyCode::Char('g'),
                 modifiers: KeyModifiers::CONTROL,
@@ -121,7 +130,7 @@ pub fn handle_input(
                         pid,
                         get_command(pid, false)
                     );
-                    let content = get_cgroup(pid);
+                    let content = crate::picker::get_cgroup(pid);
                     data.2 = Some(InfoBar { title, content });
                 }
                 should_update.store(true, Ordering::Relaxed);
@@ -164,6 +173,25 @@ pub fn handle_input(
                 }
                 should_update.store(true, Ordering::Relaxed);
             }
+            #[cfg(unix)]
+            char!('k') => {
+                let data = data.read().unwrap();
+                let mut tui_stat = tui_stat.write().unwrap();
+                let mut nth = tui_stat.list_offset;
+                if data.1.collected.is_empty() {
+                    return false;
+                }
+                if data.1.collected.len() <= nth {
+                    nth = data.1.collected.len() - 1;
+                }
+                let pid = data.1.collected[nth].0;
+                tui_stat.input_value.clear();
+                tui_stat.input_label = format!("PID to signal/kill [default pid = {}]", pid);
+                tui_stat.selected_process = Some(pid);
+                tui_stat.input_mode = InputMode::Input(InputEvent::KillProc);
+
+                should_update.store(true, Ordering::Relaxed);
+            }
             char!('l') => {
                 let mut stat = tui_stat.write().unwrap();
                 stat.show_load_avg = !stat.show_load_avg;
@@ -194,11 +222,59 @@ pub fn handle_input(
                 data.write().unwrap().1 = ProcList::new(settings, &tui_stat.read().unwrap());
                 should_update.store(true, Ordering::Relaxed);
             }
+            #[cfg(target_os = "linux")]
+            char!('r') => {
+                let data = data.read().unwrap();
+                let mut tui_stat = tui_stat.write().unwrap();
+                let mut nth = tui_stat.list_offset;
+                if data.1.collected.is_empty() {
+                    return false;
+                }
+                if data.1.collected.len() <= nth {
+                    nth = data.1.collected.len() - 1;
+                }
+                let pid = data.1.collected[nth].0;
+                tui_stat.input_value.clear();
+                tui_stat.input_label = format!("PID to renice [default pid = {}]", pid);
+                tui_stat.selected_process = Some(pid);
+                tui_stat.input_mode = InputMode::Input(InputEvent::ReniceProc);
+
+                should_update.store(true, Ordering::Relaxed);
+            }
             char!('t') => {
                 let mut stat = tui_stat.write().unwrap();
                 stat.cpu_graph_mode = stat.cpu_graph_mode.next();
                 should_update.store(true, Ordering::Relaxed);
             }
+            #[cfg(target_os = "linux")]
+            Event::Key(KeyEvent {
+                code: KeyCode::Char('u'),
+                modifiers: KeyModifiers::CONTROL,
+                ..
+            }) => {
+                let mut data = data.write().unwrap();
+                if data.2.is_some() {
+                    data.2 = None;
+                } else {
+                    let tui_stat = tui_stat.read().unwrap();
+                    let mut nth = tui_stat.list_offset;
+                    if data.1.collected.is_empty() {
+                        return false;
+                    }
+                    if data.1.collected.len() <= nth {
+                        nth = data.1.collected.len() - 1;
+                    }
+                    let pid = data.1.collected[nth].0;
+                    let title = format!(
+                        "supplementary groups for pid {}, {}",
+                        pid,
+                        get_command(pid, false)
+                    );
+                    let content = crate::picker::get_supplementary_groups(pid);
+                    data.2 = Some(InfoBar { title, content });
+                }
+                should_update.store(true, Ordering::Relaxed);
+            }
             char!('U') => {
                 let mut stat = tui_stat.write().unwrap();
                 stat.input_label = "Which user (blank for all) ".into();
@@ -509,5 +585,97 @@ fn handle_input_value(
             stat.reset_input();
             should_update.store(true, Ordering::Relaxed);
         }
+        #[cfg(target_os = "linux")]
+        InputEvent::ReniceProc => {
+            let input_value = { tui_stat.read().unwrap().input_value.parse::<u32>() };
+            let mut stat = tui_stat.write().unwrap();
+            if let Ok(pid) = input_value {
+                stat.selected_process = Some(pid);
+            } else {
+                let is_empty = stat.input_value.trim().is_empty();
+                stat.reset_input();
+                if !is_empty {
+                    stat.input_message = Some(" Unacceptable integer ".into());
+                    should_update.store(true, Ordering::Relaxed);
+                    return;
+                }
+            };
+            stat.input_value.clear();
+            stat.input_label = format!("Renice pid {} to value", stat.selected_process.unwrap());
+            stat.input_mode = InputMode::Input(InputEvent::ReniceValue);
+            should_update.store(true, Ordering::Relaxed);
+        }
+        #[cfg(target_os = "linux")]
+        InputEvent::ReniceValue => {
+            let mut stat = tui_stat.write().unwrap();
+            let input_value = stat.input_value.parse::<i32>();
+            stat.input_mode = InputMode::Command;
+            stat.reset_input();
+            if input_value.is_err() || input_value.as_ref().is_ok_and(|v| *v < -20 || *v > 19) {
+                let is_empty = { tui_stat.read().unwrap().input_value.trim().is_empty() };
+                let mut stat = tui_stat.write().unwrap();
+                if !is_empty {
+                    stat.input_message = Some(" Unacceptable nice value ".into());
+                }
+                should_update.store(true, Ordering::Relaxed);
+                return;
+            }
+            let input_value = input_value.unwrap();
+            let pid = stat.selected_process.unwrap();
+            if let Err(e) = crate::action::renice(pid, input_value) {
+                stat.input_message = Some(format!(
+                    " Failed renice of PID {} to {}: {} ",
+                    pid, input_value, e
+                ));
+            }
+            should_update.store(true, Ordering::Relaxed);
+        }
+        #[cfg(unix)]
+        InputEvent::KillProc => {
+            let input_value = { tui_stat.read().unwrap().input_value.parse::<u32>() };
+            let mut stat = tui_stat.write().unwrap();
+            if let Ok(pid) = input_value {
+                stat.selected_process = Some(pid);
+            } else {
+                let is_empty = stat.input_value.trim().is_empty();
+                stat.reset_input();
+                if !is_empty {
+                    stat.input_message = Some(" Unacceptable integer ".into());
+                    should_update.store(true, Ordering::Relaxed);
+                    return;
+                }
+            };
+            stat.input_value.clear();
+            stat.input_label = format!(
+                "Send pid {} signal [15/sigterm]",
+                stat.selected_process.unwrap()
+            );
+            stat.input_mode = InputMode::Input(InputEvent::KillSignal);
+            should_update.store(true, Ordering::Relaxed);
+        }
+        #[cfg(unix)]
+        InputEvent::KillSignal => {
+            use uucore::signals::signal_by_name_or_value;
+            let mut stat = tui_stat.write().unwrap();
+            stat.input_mode = InputMode::Command;
+            stat.reset_input();
+            let signal = if stat.input_value.is_empty() {
+                15
+            } else if let Some(sig) = signal_by_name_or_value(&stat.input_value) {
+                sig
+            } else {
+                stat.input_message = Some(" Unacceptable signal value".into());
+                should_update.store(true, Ordering::Relaxed);
+                return;
+            };
+            let pid = stat.selected_process.unwrap();
+            if let Err(e) = crate::action::kill_process(pid, signal) {
+                stat.input_message = Some(format!(
+                    " Failed signal pid {} with {}: {} ",
+                    pid, signal, e
+                ));
+            }
+            should_update.store(true, Ordering::Relaxed);
+        }
     }
 }

src/uu/top/src/tui/stat.rs

@@ -12,6 +12,8 @@ pub(crate) struct TuiStat {
     pub input_label: String,
     pub input_value: String,
     pub input_message: Option<String>, // Info or error
+    #[allow(dead_code)]
+    pub selected_process: Option<u32>,
 
     pub show_load_avg: bool,
     pub cpu_graph_mode: CpuGraphMode,
@@ -51,6 +53,7 @@ impl TuiStat {
             input_label: String::new(),
             input_value: String::new(),
             input_message: None,
+            selected_process: None,
 
             show_load_avg: true,
             cpu_graph_mode: CpuGraphMode::default(),