Kernel: Implement a simple process time profiler

The kernel now supports basic profiling of all the threads in a process
by calling profiling_enable(pid_t). You finish the profiling by calling
profiling_disable(pid_t).

This all works by recording thread stacks when the timer interrupt
fires and the current thread is in a process being profiled.
Note that symbolication is deferred until profiling_disable() to avoid
adding more noise than necessary to the profile.

A simple "/bin/profile" command is included here that can be used to
start/stop profiling like so:

    $ profile 10 on
    ... wait ...
    $ profile 10 off

After a profile has been recorded, it can be fetched in /proc/profile

There are various limits (or "bugs") on this mechanism at the moment:

- Only one process can be profiled at a time.
- We allocate 8MB for the samples, if you use more space, things will
  not work, and probably break a bit.
- Things will probably fall apart if the profiled process dies during
  profiling, or while extracing /proc/profile

Kernel/Scheduler.cpp

@@ -3,6 +3,7 @@
 #include <Kernel/Devices/PCSpeaker.h>
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/Process.h>
+#include <Kernel/Profiling.h>
 #include <Kernel/RTC.h>
 #include <Kernel/Scheduler.h>
 
@@ -552,6 +553,17 @@ void Scheduler::timer_tick(RegisterDump& regs)
         s_beep_timeout = 0;
     }
 
+    if (current->process().is_profiling()) {
+        auto backtrace = current->raw_backtrace(regs.ebp);
+        auto& sample = Profiling::next_sample_slot();
+        sample.pid = current->pid();
+        sample.tid = current->tid();
+        sample.timestamp = g_uptime;
+        for (size_t i = 0; i < min((size_t)backtrace.size(), Profiling::max_stack_frame_count); ++i) {
+            sample.frames[i] = backtrace[i];
+        }
+    }
+
     if (current->tick())
         return;