RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-28 04:15:07 +00:00
Code Issues Activity Actions

Kernel: Use Userspace<T> for the futex syscall

Browse source 
Utilizie Userspace<T> for the syscall argument itself, as well
as internally in the SC_futex_params struct.

We were double validating the SC_futex_params.timeout validation,
that was removed as well.
This commit is contained in:
Brian Gianforcaro 2020-08-04 23:53:23 -07:00 • committed by Andreas Kling
parent a7a7e6245f
commit fa666f6897
3 changed files with 18 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Kernel/API/Syscall.h
View file

@ -331,10 +331,10 @@ struct SC_getpeername_params {
}; };
struct SC_futex_params { struct SC_futex_params {
i32* userspace_address; Userspace<const i32*> userspace_address;
int futex_op; int futex_op;
i32 val; i32 val;
const timespec* timeout; Userspace<const timespec*> timeout;
}; };
struct SC_setkeymap_params { struct SC_setkeymap_params {

4
Kernel/Process.h
View file

@ -321,7 +321,7 @@ public:
int sys$module_unload(const char* name, size_t name_length); int sys$module_unload(const char* name, size_t name_length);
int sys$profiling_enable(pid_t); int sys$profiling_enable(pid_t);
int sys$profiling_disable(pid_t); int sys$profiling_disable(pid_t);
int sys$futex(const Syscall::SC_futex_params*); int sys$futex(Userspace<const Syscall::SC_futex_params*>);
int sys$set_thread_boost(int tid, int amount); int sys$set_thread_boost(int tid, int amount);
int sys$set_process_boost(pid_t, int amount); int sys$set_process_boost(pid_t, int amount);
int sys$chroot(const char* path, size_t path_length, int mount_flags); int sys$chroot(const char* path, size_t path_length, int mount_flags);
@ -688,7 +688,7 @@ private:
VeilState m_veil_state { VeilState::None }; VeilState m_veil_state { VeilState::None };
Vector<UnveiledPath> m_unveiled_paths; Vector<UnveiledPath> m_unveiled_paths;
WaitQueue& futex_queue(i32*); WaitQueue& futex_queue(Userspace<const i32*>);
HashMap<u32, OwnPtr<WaitQueue>> m_futex_queues; HashMap<u32, OwnPtr<WaitQueue>> m_futex_queues;
OwnPtr<PerformanceEventBuffer> m_perf_event_buffer; OwnPtr<PerformanceEventBuffer> m_perf_event_buffer;

36
Kernel/Syscalls/futex.cpp
View file

@ -42,15 +42,15 @@ void compute_relative_timeout_from_absolute(const timespec& absolute_time, timev
compute_relative_timeout_from_absolute(tv_absolute_time, relative_time); compute_relative_timeout_from_absolute(tv_absolute_time, relative_time);
} }
WaitQueue& Process::futex_queue(i32* userspace_address) WaitQueue& Process::futex_queue(Userspace<const i32*> userspace_address)
{ {
auto& queue = m_futex_queues.ensure((FlatPtr)userspace_address); auto& queue = m_futex_queues.ensure(userspace_address.ptr());
if (!queue) if (!queue)
queue = make<WaitQueue>(); queue = make<WaitQueue>();
return *queue; return *queue;
} }
int Process::sys$futex(const Syscall::SC_futex_params* user_params) int Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
{ {
REQUIRE_PROMISE(thread); REQUIRE_PROMISE(thread);
@ -58,37 +58,29 @@ int Process::sys$futex(const Syscall::SC_futex_params* user_params)
if (!validate_read_and_copy_typed(&params, user_params)) if (!validate_read_and_copy_typed(&params, user_params))
return -EFAULT; return -EFAULT;
i32* userspace_address = params.userspace_address; if (!validate_read_typed(params.userspace_address))
int futex_op = params.futex_op;
i32 value = params.val;
const timespec* user_timeout = params.timeout;
if (!validate_read_typed(userspace_address))
return -EFAULT; return -EFAULT;
if (user_timeout && !validate_read_typed(user_timeout)) switch (params.futex_op) {
return -EFAULT;
switch (futex_op) {
case FUTEX_WAIT: { case FUTEX_WAIT: {
i32 user_value; i32 user_value;
copy_from_user(&user_value, userspace_address); copy_from_user(&user_value, params.userspace_address);
if (user_value != value) if (user_value != params.val)
return -EAGAIN; return -EAGAIN;
timespec ts_abstimeout { 0, 0 }; timespec ts_abstimeout { 0, 0 };
if (user_timeout && !validate_read_and_copy_typed(&ts_abstimeout, user_timeout)) if (params.timeout && !validate_read_and_copy_typed(&ts_abstimeout, params.timeout))
return -EFAULT; return -EFAULT;
WaitQueue& wait_queue = futex_queue(userspace_address);
timeval* optional_timeout = nullptr; timeval* optional_timeout = nullptr;
timeval relative_timeout { 0, 0 }; timeval relative_timeout { 0, 0 };
if (user_timeout) { if (params.timeout) {
compute_relative_timeout_from_absolute(ts_abstimeout, relative_timeout); compute_relative_timeout_from_absolute(ts_abstimeout, relative_timeout);
optional_timeout = &relative_timeout; optional_timeout = &relative_timeout;
} }
// FIXME: This is supposed to be interruptible by a signal, but right now WaitQueue cannot be interrupted. // FIXME: This is supposed to be interruptible by a signal, but right now WaitQueue cannot be interrupted.
WaitQueue& wait_queue = futex_queue(params.userspace_address);
Thread::BlockResult result = Thread::current()->wait_on(wait_queue, "Futex", optional_timeout); Thread::BlockResult result = Thread::current()->wait_on(wait_queue, "Futex", optional_timeout);
if (result == Thread::BlockResult::InterruptedByTimeout) { if (result == Thread::BlockResult::InterruptedByTimeout) {
return -ETIMEDOUT; return -ETIMEDOUT;
@ -97,12 +89,12 @@ int Process::sys$futex(const Syscall::SC_futex_params* user_params)
break; break;
} }
case FUTEX_WAKE: case FUTEX_WAKE:
if (value == 0) if (params.val == 0)
return 0; return 0;
if (value == 1) { if (params.val == 1) {
futex_queue(userspace_address).wake_one(); futex_queue(params.userspace_address).wake_one();
} else { } else {
futex_queue(userspace_address).wake_n(value); futex_queue(params.userspace_address).wake_n(params.val);
} }
break; break;
} }