top: tui impl k (kill)

Author: Bluemangoo

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

@@ -7,10 +7,22 @@
 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

@@ -435,6 +435,7 @@ 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) {
@@ -452,10 +453,8 @@ pub(crate) fn get_supplementary_groups(pid: u32) -> String {
                 return groups;
             }
         }
-        String::new()
-    } else {
-        String::new()
     }
+    String::new()
 }
 
 #[cfg(target_os = "linux")]

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

@@ -30,6 +30,10 @@ pub(crate) enum InputEvent {
     ReniceProc,
     #[cfg(target_os = "linux")]
     ReniceValue,
+    #[cfg(unix)]
+    KillProc,
+    #[cfg(unix)]
+    KillSignal,
 }
 
 macro_rules! char {
@@ -169,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;
@@ -607,5 +630,52 @@ fn handle_input_value(
             }
             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,7 @@ 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,