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

1 files changed, 26 insertions, 0 deletions

diff --git a/Kernel/Profiling.h b/Kernel/Profiling.h
new file mode 100644
index 0000000000..54cb7a0cc8
--- /dev/null
+++ b/Kernel/Profiling.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <AK/Function.h>
+#include <AK/String.h>
+#include <AK/Types.h>
+
+class Process;
+
+namespace Profiling {
+
+constexpr size_t max_stack_frame_count = 30;
+
+struct Sample {
+    i32 pid;
+    i32 tid;
+    u64 timestamp;
+    u32 frames[max_stack_frame_count];
+    String symbolicated_frames[max_stack_frame_count];
+};
+
+Sample& next_sample_slot();
+void start(Process&);
+void stop();
+void for_each_sample(Function<void(Sample&)>);
+
+}