First implementation of kernel level timers

AK/SinglyLinkedList.h

@@ -128,7 +128,7 @@ class SinglyLinkedList {
  m_tail->next = node;
  m_tail = node;
  }
-
+ 
  bool contains_slow(const T& value) const
  {
  for (auto* node = m_head; node; node = node->next) {
@@ -138,6 +138,7 @@ class SinglyLinkedList {
  return false;
  }
 
+
  using Iterator = SinglyLinkedListIterator<SinglyLinkedList, T>;
  friend Iterator;
  Iterator begin() { return Iterator(m_head); }

Kernel/Scheduler.cpp

@@ -1,3 +1,4 @@
+#include <AK/SinglyLinkedList.h>
 #include <AK/TemporaryChange.h>
 #include <Kernel/Arch/i386/PIT.h>
 #include <Kernel/Devices/PCSpeaker.h>
@@ -48,12 +49,13 @@ Thread* g_last_fpu_thread;
 Thread* g_finalizer;
 static Process* s_colonel_process;
 u64 g_uptime;
-static u64 s_beep_timeout;
+static u64 s_next_timer_due;
 
 struct TaskRedirectionData {
  u16 selector;
  TSS32 tss;
 };
+
 static TaskRedirectionData s_redirection;
 static bool s_active;
 
@@ -65,7 +67,14 @@ bool Scheduler::is_active()
 void Scheduler::beep()
 {
  PCSpeaker::tone_on(440);
- s_beep_timeout = g_uptime + 100;
+
+ auto timer = Timer();
+ timer.expires = g_uptime + 100;
+ timer.callback = []() {
+ PCSpeaker::tone_off();
+ dbgprintf("tone off");
+ };
+ add_timer(timer);
 }
 
 Thread::FileDescriptionBlocker::FileDescriptionBlocker(const FileDescription& description)
@@ -523,6 +532,8 @@ void Scheduler::initialize()
  // Make sure the colonel uses a smallish time slice.
  s_colonel_process->set_priority(Process::IdlePriority);
  load_task_register(s_redirection.selector);
+
+ g_timer_queue = new SinglyLinkedList<Timer>();
 }
 
 void Scheduler::timer_tick(RegisterDump& regs)
@@ -531,10 +542,9 @@ void Scheduler::timer_tick(RegisterDump& regs)
  return;
 
  ++g_uptime;
-
- if (s_beep_timeout && g_uptime > s_beep_timeout) {
- PCSpeaker::tone_off();
- s_beep_timeout = 0;
+
+ if ( TimerQueue::s_next_timer_due && g_uptime > TimerQueue::s_next_timer_due) {
+ TimerQueue::fire_timer();
  }
 
  if (current->tick())

Kernel/Scheduler.h

@@ -7,6 +7,7 @@
 
 class Process;
 class Thread;
+struct Timer;
 struct RegisterDump;
 struct SchedulerData;
 

Kernel/TimerQueue.cpp

@@ -0,0 +1,71 @@
+#include <AK/SinglyLinkedList.h>
+#include <Kernel/Scheduler.h>
+#include <Kernel/TimerQueue.h>
+
+
+SinglyLinkedList<Timer>* g_timer_queue;
+
+static u64 s_next_timer_due;
+static u64 s_timer_id_count;
+void TimerQueue::initialize()
+{
+
+ g_timer_queue = new SinglyLinkedList<Timer>();
+}
+
+
+u64 TimerQueue::add_timer(Timer& timer)
+{
+ ASSERT(timer.expires > Scheduler::g_uptime);
+ timer.id = ++s_timer_id_count;
+ g_timer_queue->sorted_insert_slow(timer);
+ s_next_timer_due = g_timer_queue->first().expires;
+ return s_timer_id_count;
+}
+
+u64 add_timer(u64 duration, TimeUnit unit, void (callback)())
+{
+ atuo timer = Timer();
+ timer.expires = g_uptime + duration * unit;
+ timer.callback = callback;
+ return add_timer(timer);
+}
+
+void TimerQueue::sorted_insert_slow(T&& value)
+{
+ auto* new_node = new Node(move(value));
+ new_node->value = value;
+
+ if (!g_timer_queue->m_head || g_timer_queue->m_head->value > new_node->value) {
+ new_node->next = g_timer_queue->m_head;
+ if (!m_head)
+ m_tail = new_node;
+ m_head = new_node;
+ return;
+ }
+
+ Node* curr = m_head;
+ while (curr->next && curr->next->value < new_node->value)
+ {
+ curr = curr->next;
+ }
+
+ new_node->next = curr->next;
+ curr->next = new_node;
+ if(g_timer_queue->m_tail == curr)
+ g_timer_queue->m_tail = new_node;
+}
+
+void TimerQueue::fire_timer()
+{
+ ASSERT(s_next_timer_due == g_timer_queue->first().expires);
+ while (! g_timer_queue->is_empty() && Scheduler::g_uptime > g_timer_queue->first().expires)
+ {
+ auto timer = g_timer_queue->take_first();
+ timer.callback();
+ }
+ if (! g_timer_queue->is_empty())
+ s_next_timer_due = g_timer_queue->first().expires;
+ else
+ s_next_timer_due = 0;
+}

Kernel/TimerQueue.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <Kernel/Arch/i386/PIT.h>
+
+struct Timer {
+ u64 id;
+ u64 expires;
+ 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 X& rhs) const
+ {
+ return id == rhs.id;
+ }
+};
+
+enum TimeUnit {
+ MS = TICKS_PER_SECOND / 1000,
+ S = TICKS_PER_SECOND,
+ M = TICKS_PER_SECOND * 60
+};
+
+
+class TimerQueue {
+friend class SinglyLinkedList;
+public:
+ static void initialize();
+ static u64 add_timer(Timer&);
+ static u64 add_timer(u64 duration, TimeUnit, void (callback)());
+ static Timer& get_timer(u64 id);
+ static bool update_timer(Timer&)
+ static bool cancel_timer(u64 id);
+private:
+ static void fire_timer();
+ static void sorted_list_insert_slow()
+};