syscall/process: Implement getpriority/setpriority

Author: criskell

kernel/src/process/mod.rs

@@ -18,7 +18,10 @@ use crate::{
         task::Task,
     },
     sched::Scheduler,
-    uapi,
+    uapi::{
+        self,
+        resource::{PRIO_MAX, PRIO_MIN},
+    },
     util::{
         event::Event,
         mutex::{Mutex, spin::SpinMutex},
@@ -40,7 +43,7 @@ use alloc::{
 };
 use core::{
     mem,
-    sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering},
+    sync::atomic::{AtomicBool, AtomicI8, AtomicU32, AtomicUsize, Ordering},
     time::Duration,
 };
 
@@ -59,6 +62,8 @@ pub struct Process {
     name: SpinMutex<String>,
     /// The parent of this process, or [`None`], if this is the init process.
     parent: SpinMutex<Option<Weak<Process>>>,
+    /// A value between -20 and 19, where -20 is the highest priority and 0 is a neutral priority.
+    nice: AtomicI8,
     /// A list of [`Task`]s associated with this process.
     pub threads: SpinMutex<Vec<Arc<Task>>>,
     /// The address space for this process.
@@ -137,6 +142,18 @@ impl Process {
         self.parent.lock().as_ref().and_then(Weak::upgrade)
     }
 
+    pub const fn clamp_nice(nice: i32) -> i8 {
+        nice.clamp(PRIO_MIN as i32, PRIO_MAX as i32 - 1) as i8
+    }
+
+    pub fn set_nice(&self, nice: i32) {
+        self.nice.store(Self::clamp_nice(nice), Ordering::Relaxed);
+    }
+
+    pub fn get_nice(&self) -> i8 {
+        self.nice.load(Ordering::Relaxed)
+    }
+
     pub fn new(name: String, parent: Option<Arc<Self>>) -> EResult<Self> {
         Self::new_with_space(name, parent, AddressSpace::new())
     }
@@ -188,6 +205,7 @@ impl Process {
             stop_unwaited: AtomicBool::new(false),
             continue_unwaited: AtomicBool::new(false),
             umask: AtomicU32::new(self.umask.load(Ordering::Relaxed)),
+            nice: AtomicI8::new(self.nice.load(Ordering::Relaxed)),
         });
 
         // Create a heap allocated context that we can pass to the entry point.
@@ -273,6 +291,7 @@ impl Process {
             stop_unwaited: AtomicBool::new(false),
             continue_unwaited: AtomicBool::new(false),
             umask: AtomicU32::new(0o022),
+            nice: AtomicI8::new(0),
         })
     }
 

kernel/src/process/task.rs

@@ -80,8 +80,6 @@ pub struct Task {
     pub user_stack: AtomicUsize,
     /// The amount of time that this task can live on.
     pub ticks: usize,
-    /// A value between -20 and 19, where -20 is the highest priority and 0 is a neutral priority.
-    pub priority: i8,
     /// Used to handle [`UserPtr`] page faults.
     pub uar: AtomicPtr<UserAccessRegion>,
     /// Per-thread signal state (pending signals and signal mask).
@@ -212,7 +210,6 @@ impl Task {
             kernel_stack: KernelStack::new()?,
             user_stack: AtomicUsize::new(0),
             ticks: 0,
-            priority: 0,
             name: SpinMutex::new(String::new()),
             last_cpu: AtomicU32::new(u32::MAX),
             sched_cpu: AtomicU32::new(u32::MAX),

kernel/src/syscall/mod.rs

@@ -297,8 +297,8 @@ pub(crate) fn dispatch(frame: &mut Context) {
         // Scheduling
         numbers::SLEEP => system::sleep,
         numbers::YIELD => system::sched_yield,
-        numbers::GETPRIORITY => sys_unimpl!("getpriority", Err(Errno::ENOSYS)),
-        numbers::SETPRIORITY => sys_unimpl!("setpriority", Err(Errno::ENOSYS)),
+        numbers::GETPRIORITY => process::getpriority,
+        numbers::SETPRIORITY => process::setpriority,
         numbers::SCHED_GETPARAM => sys_unimpl!("sched_getparam", Err(Errno::ENOSYS)),
         numbers::SCHED_SETPARAM => sys_unimpl!("sched_setparam", Err(Errno::ENOSYS)),
         numbers::GETENTROPY => system::getentropy,

kernel/src/syscall/process.rs

@@ -10,11 +10,15 @@ use crate::{
         to_user,
     },
     sched::Scheduler,
-    uapi::{self, gid_t, limits::PATH_MAX, pid_t, uid_t},
+    uapi::{self, gid_t, limits::PATH_MAX, pid_t, resource::*, uid_t},
     vfs::{File, file::OpenFlags, inode::Mode},
     wrap_syscall,
 };
-use alloc::{string::String, sync::Arc, vec::Vec};
+use alloc::{
+    string::String,
+    sync::{Arc, Weak},
+    vec::Vec,
+};
 
 #[wrap_syscall]
 pub fn gettid() -> usize {
@@ -361,6 +365,109 @@ pub fn setsid() -> EResult<pid_t> {
     Ok(pid)
 }
 
+fn parse_processes(which: u32, who: pid_t) -> EResult<Vec<Arc<Process>>> {
+    let current = Scheduler::get_current().get_process();
+
+    if which == PRIO_PROCESS {
+        let proc = if who == 0 {
+            current
+        } else {
+            let table = crate::process::PROCESS_TABLE.lock();
+
+            table
+                .get(&who)
+                .cloned()
+                .ok_or(Errno::ESRCH)?
+                .upgrade()
+                .ok_or(Errno::ESRCH)?
+        };
+
+        return Ok(vec![proc]);
+    }
+
+    let table = crate::process::PROCESS_TABLE
+        .lock()
+        .values()
+        .filter_map(Weak::upgrade)
+        .collect::<Vec<_>>();
+
+    let procs = match which {
+        PRIO_PGRP => {
+            let pgrp = if who == 0 { *current.pgrp.lock() } else { who };
+
+            table
+                .into_iter()
+                .filter(|proc| *proc.pgrp.lock() == pgrp)
+                .collect::<Vec<_>>()
+        }
+
+        PRIO_USER => {
+            let uid = if who == 0 {
+                current.identity.lock().user_id
+            } else {
+                who as uid_t
+            };
+
+            table
+                .into_iter()
+                .filter(|proc| proc.identity.lock().user_id == uid)
+                .collect::<Vec<_>>()
+        }
+
+        _ => return Err(Errno::EINVAL),
+    };
+
+    if procs.is_empty() {
+        return Err(Errno::ESRCH);
+    }
+
+    Ok(procs)
+}
+
+#[wrap_syscall]
+pub fn getpriority(which: u32, who: pid_t) -> EResult<i32> {
+    Ok(parse_processes(which, who)?
+        .iter()
+        .map(|p| p.get_nice() as i32)
+        .min()
+        .unwrap())
+}
+
+#[wrap_syscall]
+pub fn setpriority(which: u32, who: pid_t, prio: i32) -> EResult<()> {
+    let procs = parse_processes(which, who)?;
+
+    let nice = Process::clamp_nice(prio);
+
+    let euid = Scheduler::get_current()
+        .get_process()
+        .identity
+        .lock()
+        .effective_user_id;
+
+    let mut last_result = Ok(());
+
+    for proc in procs {
+        let identity = proc.identity.lock();
+
+        if euid != 0 && euid != identity.user_id && euid != identity.effective_user_id {
+            last_result = Err(Errno::EPERM);
+            continue;
+        }
+
+        let current_nice = proc.get_nice();
+
+        if nice < current_nice && euid != 0 {
+            last_result = Err(Errno::EACCES);
+            continue;
+        }
+
+        proc.set_nice(nice as i32);
+    }
+
+    last_result
+}
+
 pub fn exit(error: usize) -> ! {
     Process::exit(State::Exited(error as _));
 }