ladybird/Kernel/WaitQueue.h

#pragma once

#include <AK/Atomic.h>
#include <AK/SinglyLinkedList.h>
#include <Kernel/Thread.h>

class WaitQueue {
public:
    WaitQueue();
    ~WaitQueue();

    void enqueue(Thread&);
    void wake_one(Atomic<bool>* lock = nullptr);
    void wake_all();

private:
    typedef IntrusiveList<Thread, &Thread::m_wait_queue_node> ThreadList;
    ThreadList m_threads;
};
Kernel: Add a WaitQueue for Thread queueing/waking and use it for Lock The kernel's Lock class now uses a proper wait queue internally instead of just having everyone wake up regularly to try to acquire the lock. We also keep the donation mechanism, so that whenever someone tries to take the lock and fails, that thread donates the remainder of its timeslice to the current lock holder. After unlocking a Lock, the unlocking thread calls WaitQueue::wake_one, which unblocks the next thread in queue. 2019-12-01 11:57:20 +01:00			`#pragma once`

Kernel: Fix Lock racing to the WaitQueue There was a time window between releasing Lock::m_lock and calling into the lock's WaitQueue where someone else could take m_lock and bring two threads into a deadlock situation. Fix this issue by holding Lock::m_lock until interrupts are disabled by either Thread::wait_on() or WaitQueue::wake_one(). 2020-01-12 18:46:41 +01:00			`#include <AK/Atomic.h>`
Kernel: Add a WaitQueue for Thread queueing/waking and use it for Lock The kernel's Lock class now uses a proper wait queue internally instead of just having everyone wake up regularly to try to acquire the lock. We also keep the donation mechanism, so that whenever someone tries to take the lock and fails, that thread donates the remainder of its timeslice to the current lock holder. After unlocking a Lock, the unlocking thread calls WaitQueue::wake_one, which unblocks the next thread in queue. 2019-12-01 11:57:20 +01:00			`#include <AK/SinglyLinkedList.h>`
Kernel: Use IntrusiveList to make WaitQueue allocation-free :^) 2019-12-22 12:23:44 +01:00			`#include <Kernel/Thread.h>`
Kernel: Add a WaitQueue for Thread queueing/waking and use it for Lock The kernel's Lock class now uses a proper wait queue internally instead of just having everyone wake up regularly to try to acquire the lock. We also keep the donation mechanism, so that whenever someone tries to take the lock and fails, that thread donates the remainder of its timeslice to the current lock holder. After unlocking a Lock, the unlocking thread calls WaitQueue::wake_one, which unblocks the next thread in queue. 2019-12-01 11:57:20 +01:00
			`class WaitQueue {`
			`public:`
			`WaitQueue();`
			`~WaitQueue();`

			`void enqueue(Thread&);`
Kernel: Fix Lock racing to the WaitQueue There was a time window between releasing Lock::m_lock and calling into the lock's WaitQueue where someone else could take m_lock and bring two threads into a deadlock situation. Fix this issue by holding Lock::m_lock until interrupts are disabled by either Thread::wait_on() or WaitQueue::wake_one(). 2020-01-12 18:46:41 +01:00			`void wake_one(Atomic<bool>* lock = nullptr);`
Kernel: Add a WaitQueue for Thread queueing/waking and use it for Lock The kernel's Lock class now uses a proper wait queue internally instead of just having everyone wake up regularly to try to acquire the lock. We also keep the donation mechanism, so that whenever someone tries to take the lock and fails, that thread donates the remainder of its timeslice to the current lock holder. After unlocking a Lock, the unlocking thread calls WaitQueue::wake_one, which unblocks the next thread in queue. 2019-12-01 11:57:20 +01:00			`void wake_all();`

			`private:`
Kernel: Use IntrusiveList to make WaitQueue allocation-free :^) 2019-12-22 12:23:44 +01:00			`typedef IntrusiveList<Thread, &Thread::m_wait_queue_node> ThreadList;`
			`ThreadList m_threads;`
Kernel: Add a WaitQueue for Thread queueing/waking and use it for Lock The kernel's Lock class now uses a proper wait queue internally instead of just having everyone wake up regularly to try to acquire the lock. We also keep the donation mechanism, so that whenever someone tries to take the lock and fails, that thread donates the remainder of its timeslice to the current lock holder. After unlocking a Lock, the unlocking thread calls WaitQueue::wake_one, which unblocks the next thread in queue. 2019-12-01 11:57:20 +01:00			`};`