top: tui impl r (renice)

Author: Bluemangoo

src/uu/top/src/action.rs

@@ -0,0 +1,16 @@
+// 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(())
+    }
+}

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

@@ -26,6 +26,10 @@ pub(crate) enum InputEvent {
     FilterEUser,
     WidthIncrement,
     Delay,
+    #[cfg(target_os = "linux")]
+    ReniceProc,
+    #[cfg(target_os = "linux")]
+    ReniceValue,
 }
 
 macro_rules! char {
@@ -195,6 +199,25 @@ 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();
@@ -539,5 +562,50 @@ 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);
+        }
     }
 }

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
+    pub selected_process: Option<u32>,
 
     pub show_load_avg: bool,
     pub cpu_graph_mode: CpuGraphMode,
@@ -51,6 +52,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(),