Kernel: Add kernel-level timer queue (heavily based on @juliusf's work)

PR #591 defines the rationale for kernel-level timers. They're most
immediately useful for TCP retransmission, but will most likely see use
in many other areas as well.

Kernel/Makefile

@@ -80,6 +80,7 @@ OBJS = \
     SharedBuffer.o \
     StdLib.o \
     Syscall.o \
+    TimerQueue.o \
     TTY/MasterPTY.o \
     TTY/PTYMultiplexer.o \
     TTY/SlavePTY.o \

Kernel/Scheduler.cpp

@@ -5,6 +5,7 @@
 #include <Kernel/Profiling.h>
 #include <Kernel/RTC.h>
 #include <Kernel/Scheduler.h>
+#include <Kernel/TimerQueue.h>
 
 //#define LOG_EVERY_CONTEXT_SWITCH
 //#define SCHEDULER_DEBUG
@@ -579,6 +580,8 @@ void Scheduler::timer_tick(RegisterDump& regs)
         }
     }
 
+    TimerQueue::the().fire();
+
     if (current->tick())
         return;
 

Kernel/TimerQueue.cpp

@@ -0,0 +1,72 @@
+#include <AK/Function.h>
+#include <AK/NonnullOwnPtr.h>
+#include <AK/OwnPtr.h>
+#include <Kernel/Scheduler.h>
+#include <Kernel/TimerQueue.h>
+
+static TimerQueue* s_the;
+
+TimerQueue& TimerQueue::the()
+{
+    if (!s_the)
+        s_the = new TimerQueue;
+    return *s_the;
+}
+
+u64 TimerQueue::add_timer(NonnullOwnPtr<Timer>&& timer)
+{
+    ASSERT(timer->expires > g_uptime);
+
+    timer->id = ++m_timer_id_count;
+
+    auto following_timer = m_timer_queue.find([&timer](auto& other) { return other->expires > timer->expires; });
+    if (following_timer.is_end())
+        m_timer_queue.append(move(timer));
+    else
+        m_timer_queue.insert_before(following_timer, move(timer));
+
+    update_next_timer_due();
+
+    return m_timer_id_count;
+}
+
+u64 TimerQueue::add_timer(u64 duration, TimeUnit unit, Function<void()>&& callback)
+{
+    NonnullOwnPtr timer = make<Timer>();
+    timer->expires = g_uptime + duration * unit;
+    timer->callback = move(callback);
+    return add_timer(move(timer));
+}
+
+bool TimerQueue::cancel_timer(u64 id)
+{
+    auto it = m_timer_queue.find([id](auto& timer) { return timer->id == id; });
+    if (it.is_end())
+        return false;
+    m_timer_queue.remove(it);
+    update_next_timer_due();
+    return true;
+}
+
+void TimerQueue::fire()
+{
+    if (m_timer_queue.is_empty())
+        return;
+
+    ASSERT(m_next_timer_due == m_timer_queue.first()->expires);
+
+    while (!m_timer_queue.is_empty() && g_uptime > m_timer_queue.first()->expires) {
+        auto timer = m_timer_queue.take_first();
+        timer->callback();
+    }
+
+    update_next_timer_due();
+}
+
+void TimerQueue::update_next_timer_due()
+{
+    if (m_timer_queue.is_empty())
+        m_next_timer_due = 0;
+    else
+        m_next_timer_due = m_timer_queue.first()->expires;
+}

Kernel/TimerQueue.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <AK/Function.h>
+#include <AK/NonnullOwnPtr.h>
+#include <AK/OwnPtr.h>
+#include <AK/SinglyLinkedList.h>
+#include <Kernel/Arch/i386/PIT.h>
+
+struct Timer {
+    u64 id;
+    u64 expires;
+    Function<void()> callback;
+    bool operator<(const Timer& rhs) const
+    {
+        return expires < rhs.expires;
+    }
+    bool operator>(const Timer& rhs) const
+    {
+        return expires > rhs.expires;
+    }
+    bool operator==(const Timer& rhs) const
+    {
+        return id == rhs.id;
+    }
+};
+
+enum TimeUnit {
+    MS = TICKS_PER_SECOND / 1000,
+    S = TICKS_PER_SECOND,
+    M = TICKS_PER_SECOND * 60
+};
+
+class TimerQueue {
+public:
+    static TimerQueue& the();
+
+    u64 add_timer(NonnullOwnPtr<Timer>&&);
+    u64 add_timer(u64 duration, TimeUnit, Function<void()>&& callback);
+    bool cancel_timer(u64 id);
+    void fire();
+
+private:
+    void update_next_timer_due();
+
+    u64 m_next_timer_due { 0 };
+    u64 m_timer_id_count { 0 };
+    SinglyLinkedList<NonnullOwnPtr<Timer>> m_timer_queue;
+};