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/Thread.cpp

@@ -707,6 +707,19 @@ String Thread::backtrace_impl() const
     return builder.to_string();
 }
 
+Vector<u32> Thread::raw_backtrace(u32 ebp) const
+{
+    auto& process = const_cast<Process&>(this->process());
+    ProcessPagingScope paging_scope(process);
+    Vector<u32> backtrace;
+    backtrace.append(ebp);
+    for (u32* stack_ptr = (u32*)ebp; process.validate_read_from_kernel(VirtualAddress((u32)stack_ptr)); stack_ptr = (u32*)*stack_ptr) {
+        u32 retaddr = stack_ptr[1];
+        backtrace.append(retaddr);
+    }
+    return backtrace;
+}
+
 void Thread::make_thread_specific_region(Badge<Process>)
 {
     size_t thread_specific_region_alignment = max(process().m_master_tls_alignment, alignof(ThreadSpecificData));