RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 09:48:11 +00:00
Code Issues Activity Actions

Kernel: Propagate OOM conditions out of sys$futex

Browse source
This commit is contained in:
Idan Horowitz 2022-07-13 09:29:51 +03:00 • committed by Andreas Kling
parent 364f6a9bf0
commit 55c7496200
4 changed files with 20 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Kernel/FutexQueue.cpp
View file

@ -30,7 +30,7 @@ bool FutexQueue::should_add_blocker(Thread::Blocker& b, void*)
return true; return true;
} }
u32 FutexQueue::wake_n_requeue(u32 wake_count, Function<FutexQueue*()> const& get_target_queue, u32 requeue_count, bool& is_empty, bool& is_empty_target) ErrorOr<u32> FutexQueue::wake_n_requeue(u32 wake_count, Function<ErrorOr<FutexQueue*>()> const& get_target_queue, u32 requeue_count, bool& is_empty, bool& is_empty_target)
{ {
is_empty_target = false; is_empty_target = false;
SpinlockLocker lock(m_lock); SpinlockLocker lock(m_lock);
@ -55,7 +55,7 @@ u32 FutexQueue::wake_n_requeue(u32 wake_count, Function<FutexQueue*()> const& ge
if (requeue_count > 0) { if (requeue_count > 0) {
auto blockers_to_requeue = do_take_blockers(requeue_count); auto blockers_to_requeue = do_take_blockers(requeue_count);
if (!blockers_to_requeue.is_empty()) { if (!blockers_to_requeue.is_empty()) {
if (auto* target_futex_queue = get_target_queue()) { if (auto* target_futex_queue = TRY(get_target_queue())) {
dbgln_if(FUTEXQUEUE_DEBUG, "FutexQueue @ {}: wake_n_requeue requeueing {} blockers to {}", this, blockers_to_requeue.size(), target_futex_queue); dbgln_if(FUTEXQUEUE_DEBUG, "FutexQueue @ {}: wake_n_requeue requeueing {} blockers to {}", this, blockers_to_requeue.size(), target_futex_queue);
// While still holding m_lock, notify each blocker // While still holding m_lock, notify each blocker

2
Kernel/FutexQueue.h
View file

@ -21,7 +21,7 @@ public:
FutexQueue(); FutexQueue();
virtual ~FutexQueue(); virtual ~FutexQueue();
u32 wake_n_requeue(u32, Function<FutexQueue*()> const&, u32, bool&, bool&); ErrorOr<u32> wake_n_requeue(u32, Function<ErrorOr<FutexQueue*>()> const&, u32, bool&, bool&);
u32 wake_n(u32, Optional<u32> const&, bool&); u32 wake_n(u32, Optional<u32> const&, bool&);
u32 wake_all(bool&); u32 wake_all(bool&);

2
Kernel/Process.h
View file

@ -82,7 +82,7 @@ enum class VeilState {
Locked, Locked,
}; };
using FutexQueues = HashMap<FlatPtr, RefPtr<FutexQueue>>; using FutexQueues = HashMap<FlatPtr, NonnullRefPtr<FutexQueue>>;
struct LoadResult; struct LoadResult;

33
Kernel/Syscalls/futex.cpp
View file

@ -56,20 +56,19 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
} }
} }
auto find_futex_queue = [&](FlatPtr user_address, bool create_if_not_found, bool* did_create = nullptr) -> RefPtr<FutexQueue> { auto find_futex_queue = [&](FlatPtr user_address, bool create_if_not_found, bool* did_create = nullptr) -> ErrorOr<RefPtr<FutexQueue>> {
VERIFY(!create_if_not_found || did_create != nullptr); VERIFY(!create_if_not_found || did_create != nullptr);
auto* queues = &m_futex_queues;
auto it = m_futex_queues.find(user_address); auto it = m_futex_queues.find(user_address);
if (it != m_futex_queues.end()) if (it != m_futex_queues.end())
return it->value; return it->value;
if (create_if_not_found) { if (create_if_not_found) {
*did_create = true; *did_create = true;
auto futex_queue = adopt_ref(*new FutexQueue); auto futex_queue = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) FutexQueue));
auto result = queues->set(user_address, futex_queue); auto result = TRY(m_futex_queues.try_set(user_address, futex_queue));
VERIFY(result == AK::HashSetResult::InsertedNewEntry); VERIFY(result == AK::HashSetResult::InsertedNewEntry);
return futex_queue; return futex_queue;
} }
return {}; return nullptr;
}; };
auto remove_futex_queue = [&](FlatPtr user_address) { auto remove_futex_queue = [&](FlatPtr user_address) {
@ -80,11 +79,11 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
} }
}; };
auto do_wake = [&](FlatPtr user_address, u32 count, Optional<u32> bitmask) -> int { auto do_wake = [&](FlatPtr user_address, u32 count, Optional<u32> bitmask) -> ErrorOr<int> {
if (count == 0) if (count == 0)
return 0; return 0;
SpinlockLocker locker(m_futex_lock); SpinlockLocker locker(m_futex_lock);
auto futex_queue = find_futex_queue(user_address, false); auto futex_queue = TRY(find_futex_queue(user_address, false));
if (!futex_queue) if (!futex_queue)
return 0; return 0;
bool is_empty; bool is_empty;
@ -114,7 +113,7 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
SpinlockLocker locker(m_futex_lock); SpinlockLocker locker(m_futex_lock);
did_create = false; did_create = false;
futex_queue = find_futex_queue(user_address, true, &did_create); futex_queue = TRY(find_futex_queue(user_address, true, &did_create));
VERIFY(futex_queue); VERIFY(futex_queue);
// We need to try again if we didn't create this queue and the existing queue // We need to try again if we didn't create this queue and the existing queue
// was removed before we were able to queue an imminent wait. // was removed before we were able to queue an imminent wait.
@ -146,18 +145,18 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
int woken_or_requeued = 0; int woken_or_requeued = 0;
SpinlockLocker locker(m_futex_lock); SpinlockLocker locker(m_futex_lock);
if (auto futex_queue = find_futex_queue(user_address, false)) { if (auto futex_queue = TRY(find_futex_queue(user_address, false))) {
RefPtr<FutexQueue> target_futex_queue; RefPtr<FutexQueue> target_futex_queue;
bool is_empty, is_target_empty; bool is_empty, is_target_empty;
woken_or_requeued = futex_queue->wake_n_requeue( woken_or_requeued = TRY(futex_queue->wake_n_requeue(
params.val, [&]() -> FutexQueue* { params.val, [&]() -> ErrorOr<FutexQueue*> {
// NOTE: futex_queue's lock is being held while this callback is called // NOTE: futex_queue's lock is being held while this callback is called
// The reason we're doing this in a callback is that we don't want to always // The reason we're doing this in a callback is that we don't want to always
// create a target queue, only if we actually have anything to move to it! // create a target queue, only if we actually have anything to move to it!
target_futex_queue = find_futex_queue(user_address2, true); target_futex_queue = TRY(find_futex_queue(user_address2, true));
return target_futex_queue.ptr(); return target_futex_queue.ptr();
}, },
params.val2, is_empty, is_target_empty); params.val2, is_empty, is_target_empty));
if (is_empty) if (is_empty)
remove_futex_queue(user_address); remove_futex_queue(user_address);
if (is_target_empty && target_futex_queue) if (is_target_empty && target_futex_queue)
@ -171,7 +170,7 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
return do_wait(0); return do_wait(0);
case FUTEX_WAKE: case FUTEX_WAKE:
return do_wake(user_address, params.val, {}); return TRY(do_wake(user_address, params.val, {}));
case FUTEX_WAKE_OP: { case FUTEX_WAKE_OP: {
Optional<u32> oldval; Optional<u32> oldval;
@ -204,7 +203,7 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
if (!oldval.has_value()) if (!oldval.has_value())
return EFAULT; return EFAULT;
atomic_thread_fence(AK::MemoryOrder::memory_order_acquire); atomic_thread_fence(AK::MemoryOrder::memory_order_acquire);
auto result = do_wake(user_address, params.val, {}); auto result = TRY(do_wake(user_address, params.val, {}));
if (params.val2 > 0) { if (params.val2 > 0) {
bool compare_result; bool compare_result;
switch (_FUTEX_CMP(params.val3)) { switch (_FUTEX_CMP(params.val3)) {
@ -230,7 +229,7 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
return EINVAL; return EINVAL;
} }
if (compare_result) if (compare_result)
result += do_wake(user_address2, params.val2, {}); result += TRY(do_wake(user_address2, params.val2, {}));
} }
return result; return result;
} }
@ -251,7 +250,7 @@ ErrorOr<FlatPtr> Process::sys$futex(Userspace<Syscall::SC_futex_params const*> u
VERIFY(params.val3 != FUTEX_BITSET_MATCH_ANY); // we should have turned it into FUTEX_WAKE VERIFY(params.val3 != FUTEX_BITSET_MATCH_ANY); // we should have turned it into FUTEX_WAKE
if (params.val3 == 0) if (params.val3 == 0)
return EINVAL; return EINVAL;
return do_wake(user_address, params.val, params.val3); return TRY(do_wake(user_address, params.val, params.val3));
} }
return ENOSYS; return ENOSYS;
} }