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/Process.h

@@ -44,6 +44,9 @@ public:
     static Vector<pid_t> all_pids();
     static Vector<Process*> all_processes();
 
+    bool is_profiling() const { return m_profiling; }
+    void set_profiling(bool profiling) { m_profiling = profiling; }
+
     enum RingLevel : u8 {
         Ring0 = 0,
         Ring3 = 3,
@@ -228,6 +231,8 @@ public:
     int sys$setkeymap(char* map, char* shift_map, char* alt_map);
     int sys$module_load(const char* path, size_t path_length);
     int sys$module_unload(const char* name, size_t name_length);
+    int sys$profiling_enable(pid_t);
+    int sys$profiling_disable(pid_t);
 
     static void initialize();
 
@@ -352,6 +357,7 @@ private:
 
     bool m_being_inspected { false };
     bool m_dead { false };
+    bool m_profiling { false };
 
     RefPtr<Custody> m_executable;
     RefPtr<Custody> m_cwd;