Kernel/LibC: Implement sched_* functionality to set/get process priority

Right now, we allow anything inside a user to raise or lower any other process's
priority. This feels simple enough to me. Linux disallows raising, but
that's annoying in practice.

Kernel/Process.cpp

@@ -2282,6 +2282,49 @@ int Process::sys$getpeername(int sockfd, sockaddr* addr, socklen_t* addrlen)
     return 0;
 }
 
+int Process::sys$sched_setparam(pid_t pid, const struct sched_param* param)
+{
+    if (!validate_read_typed(param))
+        return -EFAULT;
+
+    InterruptDisabler disabler;
+    auto* peer = this;
+    if (pid != 0)
+        peer = Process::from_pid(pid);
+
+    if (!peer)
+        return -ESRCH;
+
+    if (!is_superuser() && m_euid != peer->m_uid && m_uid != peer->m_uid)
+        return -EPERM;
+
+    if (param->sched_priority < Process::FirstPriority || param->sched_priority > Process::LastPriority)
+        return -EINVAL;
+
+    peer->set_priority(Priority(param->sched_priority));
+    return 0;
+}
+
+int Process::sys$sched_getparam(pid_t pid, struct sched_param* param)
+{
+    if (!validate_read_typed(param))
+        return -EFAULT;
+
+    InterruptDisabler disabler;
+    auto* peer = this;
+    if (pid != 0)
+        peer = Process::from_pid(pid);
+
+    if (!peer)
+        return -ESRCH;
+
+    if (!is_superuser() && m_euid != peer->m_uid && m_uid != peer->m_uid)
+        return -EPERM;
+
+    param->sched_priority = peer->priority();
+    return 0;
+}
+
 int Process::sys$getsockopt(const Syscall::SC_getsockopt_params* params)
 {
     if (!validate_read_typed(params))

Kernel/Process.h

@@ -40,9 +40,11 @@ public:
     enum Priority
     {
         IdlePriority,
+        FirstPriority = IdlePriority,
         LowPriority,
         NormalPriority,
         HighPriority,
+        LastPriority = HighPriority,
     };
 
     enum RingLevel
@@ -186,6 +188,8 @@ public:
     int sys$setsockopt(const Syscall::SC_setsockopt_params*);
     int sys$getsockname(int sockfd, sockaddr* addr, socklen_t* addrlen);
     int sys$getpeername(int sockfd, sockaddr* addr, socklen_t* addrlen);
+    int sys$sched_setparam(pid_t pid, const struct sched_param* param);
+    int sys$sched_getparam(pid_t pid, struct sched_param* param);
     int sys$restore_signal_mask(dword mask);
     int sys$create_thread(int (*)(void*), void*);
     void sys$exit_thread(int code);

Kernel/Syscall.cpp

@@ -276,6 +276,10 @@ static dword handle(RegisterDump& regs, dword function, dword arg1, dword arg2,
         return current->process().sys$getsockname((int)arg1, (sockaddr*)arg2, (socklen_t*)arg3);
     case Syscall::SC_getpeername:
         return current->process().sys$getpeername((int)arg1, (sockaddr*)arg2, (socklen_t*)arg3);
+    case Syscall::SC_sched_setparam:
+        return current->process().sys$sched_setparam((pid_t)arg1, (struct sched_param*)arg2);
+    case Syscall::SC_sched_getparam:
+        return current->process().sys$sched_setparam((pid_t)arg1, (struct sched_param*)arg2);
     default:
         kprintf("<%u> int0x82: Unknown function %u requested {%x, %x, %x}\n", current->process().pid(), function, arg1, arg2, arg3);
         return -ENOSYS;

Kernel/Syscall.h

@@ -105,7 +105,9 @@
     __ENUMERATE_SYSCALL(writev)                 \
     __ENUMERATE_SYSCALL(beep)                   \
     __ENUMERATE_SYSCALL(getsockname)            \
-    __ENUMERATE_SYSCALL(getpeername)
+    __ENUMERATE_SYSCALL(getpeername)            \
+    __ENUMERATE_SYSCALL(sched_setparam)          \
+    __ENUMERATE_SYSCALL(sched_getparam)
 
 namespace Syscall {
 

Kernel/UnixTypes.h

@@ -400,3 +400,7 @@ struct iovec {
     void* iov_base;
     size_t iov_len;
 };
+
+struct sched_param {
+    int sched_priority;
+};