Kernel+LibC: Add sys$perf_register_string()

This syscall allows userspace to register a keyed string that appears in
a new "strings" JSON object in profile output.

This will be used to add custom strings to profile signposts. :^)

Kernel/API/Syscall.h

@@ -131,6 +131,7 @@ enum class NeedsBigProcessLock {
     S(munmap, NeedsBigProcessLock::Yes)                     \
     S(open, NeedsBigProcessLock::Yes)                       \
     S(perf_event, NeedsBigProcessLock::Yes)                 \
+    S(perf_register_string, NeedsBigProcessLock::Yes)       \
     S(pipe, NeedsBigProcessLock::Yes)                       \
     S(pledge, NeedsBigProcessLock::Yes)                     \
     S(poll, NeedsBigProcessLock::Yes)                       \

Kernel/PerformanceEventBuffer.cpp

@@ -166,6 +166,13 @@ PerformanceEvent& PerformanceEventBuffer::at(size_t index)
 template<typename Serializer>
 bool PerformanceEventBuffer::to_json_impl(Serializer& object) const
 {
+    {
+        auto strings = object.add_object("strings");
+        for (auto& it : m_strings) {
+            strings.add(String::number(it.key), it.value->view());
+        }
+    }
+
     auto array = object.add_array("events");
     bool seen_first_sample = false;
     for (size_t i = 0; i < m_count; ++i) {
@@ -298,4 +305,13 @@ void PerformanceEventBuffer::add_process(const Process& process, ProcessEventTyp
     }
 }
 
+KResult PerformanceEventBuffer::register_string(FlatPtr string_id, NonnullOwnPtr<KString> string)
+{
+    m_strings.set(string_id, move(string));
+
+    // FIXME: Switch m_strings to something that can signal allocation failure,
+    //        and then propagate such failures here.
+    return KSuccess;
+}
+
 }

Kernel/PerformanceEventBuffer.h

@@ -120,6 +120,8 @@ public:
 
     void add_process(const Process&, ProcessEventType event_type);
 
+    KResult register_string(FlatPtr string_id, NonnullOwnPtr<KString>);
+
 private:
     explicit PerformanceEventBuffer(NonnullOwnPtr<KBuffer>);
 
@@ -130,6 +132,8 @@ private:
 
     size_t m_count { 0 };
     NonnullOwnPtr<KBuffer> m_buffer;
+
+    HashMap<FlatPtr, NonnullOwnPtr<KString>> m_strings;
 };
 
 extern bool g_profiling_all_threads;

Kernel/Process.h

@@ -400,6 +400,7 @@ public:
     KResultOr<FlatPtr> sys$pledge(Userspace<const Syscall::SC_pledge_params*>);
     KResultOr<FlatPtr> sys$unveil(Userspace<const Syscall::SC_unveil_params*>);
     KResultOr<FlatPtr> sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2);
+    KResultOr<FlatPtr> sys$perf_register_string(FlatPtr string_id, Userspace<char const*>, size_t);
     KResultOr<FlatPtr> sys$get_stack_bounds(Userspace<FlatPtr*> stack_base, Userspace<size_t*> stack_size);
     KResultOr<FlatPtr> sys$ptrace(Userspace<const Syscall::SC_ptrace_params*>);
     KResultOr<FlatPtr> sys$sendfd(int sockfd, int fd);

Kernel/Syscalls/perf_event.cpp

@@ -21,4 +21,18 @@ KResultOr<FlatPtr> Process::sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2)
     return events_buffer->append(type, arg1, arg2, nullptr);
 }
 
+KResultOr<FlatPtr> Process::sys$perf_register_string(FlatPtr string_id, Userspace<char const*> user_string, size_t user_string_length)
+{
+    VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
+    auto* events_buffer = current_perf_events_buffer();
+    if (!events_buffer)
+        return KSuccess;
+
+    auto string_or_error = try_copy_kstring_from_user(user_string, user_string_length);
+    if (string_or_error.is_error())
+        return string_or_error.error();
+
+    return events_buffer->register_string(string_id, string_or_error.release_value());
+}
+
 }