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

Userland/profile.cpp

@@ -0,0 +1,29 @@
+#include <serenity.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char** argv)
+{
+    if (argc != 3) {
+        printf("usage: profile <pid> <on|off>\n");
+        return 0;
+    }
+
+    pid_t pid = atoi(argv[1]);
+    bool enabled = !strcmp(argv[2], "on");
+
+    if (enabled) {
+        if (profiling_enable(pid) < 0) {
+            perror("profiling_enable");
+            return 1;
+        }
+        return 0;
+    }
+
+    if (profiling_disable(pid) < 0) {
+        perror("profiling_disable");
+        return 1;
+    }
+    return 0;
+}