system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-09-06 17:06:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
serenity/Kernel/PerformanceEventBuffer.cpp

377 lines
14 KiB
C++
Raw Normal View History

Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
/*
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
*/
#include <AK/JsonArraySerializer.h>
Kernel: Run clang-format on files Let's rip off the band-aid
2020-03-22 00:12:45 +00:00
#include <AK/JsonObjectSerializer.h>
Kernel: Generate page fault events from the kernel profiler Hook the kernel page fault handler and capture page fault events when the fault has a current thread attached in TLS. We capture the eip and ebp so we can unwind the stack and locate which pieces of code are generating the most page faults. Co-authored-by: Gunnar Beutner <gbeutner@serenityos.org>
2021-05-18 09:26:11 +00:00
#include <AK/ScopeGuard.h>
Kernel: Add cross platform RegisterState header and Aarch64 version A new RegisterState header includes the platform specific RegisterState header based on the platform being compiled. The Aarch64 RegisterState header contains stubs for Debug
2021-10-14 22:01:29 +00:00
#include <Kernel/Arch/RegisterState.h>
Kernel: Move Kernel/Arch/x86/SafeMem.h to Kernel/Arch/SafeMem.h The file does not contain any specific architectural code, thus it can be moved to the Kernel/Arch directory.
2022-05-02 20:46:43 +00:00
#include <Kernel/Arch/SafeMem.h>
Kernel: Split SmapDisabler so header is platform independent A new header file has been created in the Arch/ folder while the implementation has been moved into a CPP living in the X86 folder.
2021-10-14 21:53:48 +00:00
#include <Kernel/Arch/SmapDisabler.h>
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
#include <Kernel/FileSystem/Custody.h>
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
#include <Kernel/KBufferBuilder.h>
#include <Kernel/PerformanceEventBuffer.h>
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
#include <Kernel/Process.h>
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
namespace Kernel {
Kernel: Better handling of allocation failure in profiling If we can't allocate a PerformanceEventBuffer to store the profiling events, we now fail sys$profiling_enable() and sys$perf_event() with ENOMEM instead of carrying on with a broken buffer.
2021-03-02 15:55:54 +00:00
PerformanceEventBuffer::PerformanceEventBuffer(NonnullOwnPtr<KBuffer> buffer)
: m_buffer(move(buffer))
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
{
}
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
NEVER_INLINE ErrorOr<void> PerformanceEventBuffer::append(int type, FlatPtr arg1, FlatPtr arg2, StringView arg3, Thread* current_thread, FlatPtr arg4, u64 arg5, ErrorOr<FlatPtr> arg6)
Kernel: Prune uninteresting kernel frames from profiling samples Start capturing the sample stacks at the EIP/EBP of the pre-empted thread instead of capturing EBP in the sampling function itself.
2021-01-17 09:53:18 +00:00
{
Kernel: Fetch the frame pointer using __builtin_frame_address() This compiler builtin abstracts away the specifics of fetching the frame pointer. This will allow the KSyms.cpp to be build for the aarch64 target. While we're here, lets also change the PerformanceEventBuffer.cpp to not rely on x86_64 specifics.
2022-05-02 20:22:33 +00:00
FlatPtr base_pointer = (FlatPtr)__builtin_frame_address(0);
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
return append_with_ip_and_bp(current_thread->pid(), current_thread->tid(), 0, base_pointer, type, 0, arg1, arg2, arg3, arg4, arg5, arg6);
Kernel: Prune uninteresting kernel frames from profiling samples Start capturing the sample stacks at the EIP/EBP of the pre-empted thread instead of capturing EBP in the sampling function itself.
2021-01-17 09:53:18 +00:00
}
Kernel: Rename PerformanceEvent methods to be more ARCH independent
2021-07-18 23:54:45 +00:00
static Vector<FlatPtr, PerformanceEvent::max_stack_frame_count> raw_backtrace(FlatPtr bp, FlatPtr ip)
Kernel: Move perf event backtrace capture out of Thread class There's no need for this to be generic and support running from an arbitrary thread context. Perf events are always generated from within the thread being profiled, so take advantage of that to simplify the code. Also use Vector capacity to avoid heap allocations.
2021-02-03 10:51:13 +00:00
{
Vector<FlatPtr, PerformanceEvent::max_stack_frame_count> backtrace;
Kernel: Rename PerformanceEvent methods to be more ARCH independent
2021-07-18 23:54:45 +00:00
if (ip != 0)
Kernel: Use unchecked_append in PerformanceEventBuffer `raw_backtrace()` We always validate the size before we append, so there is no reason to use the checked append.
2022-01-03 11:33:47 +00:00
backtrace.unchecked_append(ip);
Kernel: Move perf event backtrace capture out of Thread class There's no need for this to be generic and support running from an arbitrary thread context. Perf events are always generated from within the thread being profiled, so take advantage of that to simplify the code. Also use Vector capacity to avoid heap allocations.
2021-02-03 10:51:13 +00:00
FlatPtr stack_ptr_copy;
Kernel: Rename PerformanceEvent methods to be more ARCH independent
2021-07-18 23:54:45 +00:00
FlatPtr stack_ptr = bp;
Kernel: Move perf event backtrace capture out of Thread class There's no need for this to be generic and support running from an arbitrary thread context. Perf events are always generated from within the thread being profiled, so take advantage of that to simplify the code. Also use Vector capacity to avoid heap allocations.
2021-02-03 10:51:13 +00:00
// FIXME: Figure out how to remove this SmapDisabler without breaking profile stacks.
SmapDisabler disabler;
Kernel: Stop perf event stack walk on bogus userspace->kernel traversal When walking the stack to generate a perf_event sample, we now check if a userspace stack frame points back into kernel memory. It was possible to use this as an arbitrary kernel memory read. :^)
2021-12-19 15:38:46 +00:00
// NOTE: The stack should always have kernel frames first, followed by userspace frames.
// If a userspace frame points back into kernel memory, something is afoot.
bool is_walking_userspace_stack = false;
Kernel: Move perf event backtrace capture out of Thread class There's no need for this to be generic and support running from an arbitrary thread context. Perf events are always generated from within the thread being profiled, so take advantage of that to simplify the code. Also use Vector capacity to avoid heap allocations.
2021-02-03 10:51:13 +00:00
while (stack_ptr) {
void* fault_at;
if (!safe_memcpy(&stack_ptr_copy, (void*)stack_ptr, sizeof(FlatPtr), fault_at))
break;
Kernel: Stop perf event stack walk on bogus userspace->kernel traversal When walking the stack to generate a perf_event sample, we now check if a userspace stack frame points back into kernel memory. It was possible to use this as an arbitrary kernel memory read. :^)
2021-12-19 15:38:46 +00:00
if (!Memory::is_user_address(VirtualAddress { stack_ptr })) {
if (is_walking_userspace_stack) {
dbgln("SHENANIGANS! Userspace stack points back into kernel memory");
break;
}
} else {
is_walking_userspace_stack = true;
}
Kernel: Move perf event backtrace capture out of Thread class There's no need for this to be generic and support running from an arbitrary thread context. Perf events are always generated from within the thread being profiled, so take advantage of that to simplify the code. Also use Vector capacity to avoid heap allocations.
2021-02-03 10:51:13 +00:00
FlatPtr retaddr;
if (!safe_memcpy(&retaddr, (void*)(stack_ptr + sizeof(FlatPtr)), sizeof(FlatPtr), fault_at))
break;
Kernel: Stop walking the stack when we encounter return address 0
2021-04-25 11:39:11 +00:00
if (retaddr == 0)
break;
Kernel: Use unchecked_append in PerformanceEventBuffer `raw_backtrace()` We always validate the size before we append, so there is no reason to use the checked append.
2022-01-03 11:33:47 +00:00
backtrace.unchecked_append(retaddr);
Kernel: Move perf event backtrace capture out of Thread class There's no need for this to be generic and support running from an arbitrary thread context. Perf events are always generated from within the thread being profiled, so take advantage of that to simplify the code. Also use Vector capacity to avoid heap allocations.
2021-02-03 10:51:13 +00:00
if (backtrace.size() == PerformanceEvent::max_stack_frame_count)
break;
stack_ptr = stack_ptr_copy;
}
return backtrace;
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> PerformanceEventBuffer::append_with_ip_and_bp(ProcessID pid, ThreadID tid, RegisterState const& regs,
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
int type, u32 lost_samples, FlatPtr arg1, FlatPtr arg2, StringView arg3, FlatPtr arg4, u64 arg5, ErrorOr<FlatPtr> arg6)
Kernel: Accept RegisterState in append_with_ip_and_bp
2021-10-11 22:52:03 +00:00
{
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
return append_with_ip_and_bp(pid, tid, regs.ip(), regs.bp(), type, lost_samples, arg1, arg2, arg3, arg4, arg5, arg6);
Kernel: Accept RegisterState in append_with_ip_and_bp
2021-10-11 22:52:03 +00:00
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> PerformanceEventBuffer::append_with_ip_and_bp(ProcessID pid, ThreadID tid,
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
FlatPtr ip, FlatPtr bp, int type, u32 lost_samples, FlatPtr arg1, FlatPtr arg2, StringView arg3, FlatPtr arg4, u64 arg5, ErrorOr<FlatPtr> arg6)
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
{
if (count() >= capacity())
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return ENOBUFS;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
Kernel+LibC: Add support for filtering profiling events This adds the -t command-line argument for the profile tool. Using this argument you can filter which event types you want in your profile.
2021-05-14 06:10:43 +00:00
if ((g_profiling_event_mask & type) == 0)
return EINVAL;
Kernel: Add some implied auto qualifiers
2021-12-29 00:01:27 +00:00
auto* current_thread = Thread::current();
Kernel: Generate page fault events from the kernel profiler Hook the kernel page fault handler and capture page fault events when the fault has a current thread attached in TLS. We capture the eip and ebp so we can unwind the stack and locate which pieces of code are generating the most page faults. Co-authored-by: Gunnar Beutner <gbeutner@serenityos.org>
2021-05-18 09:26:11 +00:00
u32 enter_count = 0;
if (current_thread)
enter_count = current_thread->enter_profiler();
ScopeGuard leave_profiler([&] {
if (current_thread)
current_thread->leave_profiler();
});
if (enter_count > 0)
return EINVAL;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
PerformanceEvent event;
event.type = type;
Kernel+Profiler: Track lost time between profiler timer ticks We can lose profiling timer events for a few reasons, for example disabled interrupts or system slowness. This accounts for lost time between CPU samples by adding a field lost_samples to each profiling event which tracks how many samples were lost immediately preceding the event.
2021-05-13 20:14:07 +00:00
event.lost_samples = lost_samples;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
switch (type) {
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
case PERF_EVENT_SAMPLE:
break;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
case PERF_EVENT_MALLOC:
event.data.malloc.size = arg1;
event.data.malloc.ptr = arg2;
break;
case PERF_EVENT_FREE:
event.data.free.ptr = arg1;
break;
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
case PERF_EVENT_MMAP:
event.data.mmap.ptr = arg1;
event.data.mmap.size = arg2;
memset(event.data.mmap.name, 0, sizeof(event.data.mmap.name));
if (!arg3.is_empty())
memcpy(event.data.mmap.name, arg3.characters_without_null_termination(), min(arg3.length(), sizeof(event.data.mmap.name) - 1));
break;
case PERF_EVENT_MUNMAP:
Kernel: Use the correct union member for unmap events
2021-04-26 21:05:59 +00:00
event.data.munmap.ptr = arg1;
event.data.munmap.size = arg2;
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
case PERF_EVENT_PROCESS_CREATE:
event.data.process_create.parent_pid = arg1;
memset(event.data.process_create.executable, 0, sizeof(event.data.process_create.executable));
if (!arg3.is_empty()) {
memcpy(event.data.process_create.executable, arg3.characters_without_null_termination(),
min(arg3.length(), sizeof(event.data.process_create.executable) - 1));
}
break;
case PERF_EVENT_PROCESS_EXEC:
memset(event.data.process_exec.executable, 0, sizeof(event.data.process_exec.executable));
if (!arg3.is_empty()) {
memcpy(event.data.process_exec.executable, arg3.characters_without_null_termination(),
min(arg3.length(), sizeof(event.data.process_exec.executable) - 1));
}
break;
case PERF_EVENT_PROCESS_EXIT:
break;
case PERF_EVENT_THREAD_CREATE:
event.data.thread_create.parent_tid = arg1;
break;
case PERF_EVENT_THREAD_EXIT:
break;
Kernel: Track performance events for context switches
2021-05-14 05:48:53 +00:00
case PERF_EVENT_CONTEXT_SWITCH:
event.data.context_switch.next_pid = arg1;
event.data.context_switch.next_tid = arg2;
break;
Kernel: Add support for profiling kmalloc()/kfree()
2021-05-13 11:09:00 +00:00
case PERF_EVENT_KMALLOC:
event.data.kmalloc.size = arg1;
event.data.kmalloc.ptr = arg2;
break;
case PERF_EVENT_KFREE:
event.data.kfree.size = arg1;
event.data.kfree.ptr = arg2;
break;
Kernel: Generate page fault events from the kernel profiler Hook the kernel page fault handler and capture page fault events when the fault has a current thread attached in TLS. We capture the eip and ebp so we can unwind the stack and locate which pieces of code are generating the most page faults. Co-authored-by: Gunnar Beutner <gbeutner@serenityos.org>
2021-05-18 09:26:11 +00:00
case PERF_EVENT_PAGE_FAULT:
break;
Kernel: Add syscall performance event type This allows tracing the syscalls made by a thread through the kernel's performance event framework, which is similar in principle to strace. Currently, this merely logs a stack backtrace to the current thread's performance event buffer whenever a syscall is made, if profiling is enabled. Future improvements could include tracing the arguments and the return value, for example.
2021-08-10 19:02:59 +00:00
case PERF_EVENT_SYSCALL:
break;
Kernel+LibC: Add PERF_EVENT_SIGNPOST This event will be used by userspace programs wanting to mark interesting high-level events in the profile. :^)
2021-08-11 18:04:03 +00:00
case PERF_EVENT_SIGNPOST:
event.data.signpost.arg1 = arg1;
event.data.signpost.arg2 = arg2;
break;
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
case PERF_EVENT_READ:
event.data.read.fd = arg1;
event.data.read.size = arg2;
event.data.read.filename_index = arg4;
event.data.read.start_timestamp = arg5;
event.data.read.success = !arg6.is_error();
break;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
default:
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return EINVAL;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
}
Kernel: Rename PerformanceEvent methods to be more ARCH independent
2021-07-18 23:54:45 +00:00
auto backtrace = raw_backtrace(bp, ip);
AK: Add global FlatPtr typedef. It's u32 or u64, based on sizeof(void*) Use this instead of uintptr_t throughout the codebase. This makes it possible to pass a FlatPtr to something that has u32 and u64 overloads.
2020-03-08 09:36:51 +00:00
event.stack_size = min(sizeof(event.stack) / sizeof(FlatPtr), static_cast<size_t>(backtrace.size()));
memcpy(event.stack, backtrace.data(), event.stack_size * sizeof(FlatPtr));
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
event.pid = pid.value();
event.tid = tid.value();
Kernel: Move some time related code from Scheduler into TimeManagement Use the TimerQueue to expire blocking operations, which is one less thing the Scheduler needs to check on every iteration. Also, add a BlockTimeout class that will automatically handle relative or absolute timeouts as well as overriding timeouts (e.g. socket timeouts) more consistently. Also, rework the TimerQueue class to be able to fire events from any processor, which requires Timer to be RefCounted. Also allow creating id-less timers for use by blocking operations.
2020-11-15 18:58:19 +00:00
event.timestamp = TimeManagement::the().uptime_ms();
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
at(m_count++) = event;
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
}
PerformanceEvent& PerformanceEventBuffer::at(size_t index)
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(index < capacity());
Kernel: Use fallible KBuffer API in PerformanceEventBuffer
2020-12-18 19:43:39 +00:00
auto* events = reinterpret_cast<PerformanceEvent*>(m_buffer->data());
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
return events[index];
}
Kernel: Start work on full system profiling :^) The superuser can now call sys$profiling_enable() with PID -1 to enable profiling of all running threads in the system. The perf events are collected in a global PerformanceEventBuffer (currently 32 MiB in size.) The events can be accessed via /proc/profile
2021-03-02 16:19:35 +00:00
template<typename Serializer>
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> PerformanceEventBuffer::to_json_impl(Serializer& object) const
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
{
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. :^)
2021-08-11 18:28:29 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
auto strings = TRY(object.add_array("strings"));
Kernel: Fixed behavior of repeated calls to register_string Previously register_string would return incorrect values when called multiple times with the same input. This patch makes this function return the same index, identical strings. This change was required, as this functionality is now being used with read syscall profiling, (#12465), which uses 'register_string' to registers file path on every read syscall.
2022-02-26 21:59:26 +00:00
Vector<KString*> strings_sorted_by_index;
TRY(strings_sorted_by_index.try_resize(m_strings.size()));
for (auto& entry : m_strings) {
strings_sorted_by_index[entry.value] = const_cast<Kernel::KString*>(entry.key.ptr());
}
for (size_t i = 0; i < m_strings.size(); i++) {
TRY(strings.add(strings_sorted_by_index[i]->view()));
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(strings.finish());
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. :^)
2021-08-11 18:28:29 +00:00
}
Kernel: Don't include kmalloc perf events in JSON for non-superuser These events contain sensitive kernel information and should not be available to regular users.
2021-12-19 15:40:11 +00:00
bool show_kernel_addresses = Process::current().is_superuser();
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
auto array = TRY(object.add_array("events"));
Kernel: Correctly set the lost_samples field for the first sample This ensures that the lost_samples field is set to zero for the first sample. We didn't lose any samples before the first sample so this is the correct value. Without this Profiler gets confused and draws the graph for the process which contains the first CPU sample incorrectly (all zeroes usually).
2021-05-13 22:43:08 +00:00
bool seen_first_sample = false;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
for (size_t i = 0; i < m_count; ++i) {
Kernel: Don't include kmalloc perf events in JSON for non-superuser These events contain sensitive kernel information and should not be available to regular users.
2021-12-19 15:40:11 +00:00
auto const& event = at(i);
if (!show_kernel_addresses) {
if (event.type == PERF_EVENT_KMALLOC || event.type == PERF_EVENT_KFREE)
continue;
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
auto event_object = TRY(array.add_object());
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
switch (event.type) {
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
case PERF_EVENT_SAMPLE:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "sample"));
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
break;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
case PERF_EVENT_MALLOC:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "malloc"));
TRY(event_object.add("ptr", static_cast<u64>(event.data.malloc.ptr)));
TRY(event_object.add("size", static_cast<u64>(event.data.malloc.size)));
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
break;
case PERF_EVENT_FREE:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "free"));
TRY(event_object.add("ptr", static_cast<u64>(event.data.free.ptr)));
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
break;
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
case PERF_EVENT_MMAP:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "mmap"));
TRY(event_object.add("ptr", static_cast<u64>(event.data.mmap.ptr)));
TRY(event_object.add("size", static_cast<u64>(event.data.mmap.size)));
TRY(event_object.add("name", event.data.mmap.name));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
case PERF_EVENT_MUNMAP:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "munmap"));
TRY(event_object.add("ptr", static_cast<u64>(event.data.munmap.ptr)));
TRY(event_object.add("size", static_cast<u64>(event.data.munmap.size)));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
case PERF_EVENT_PROCESS_CREATE:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "process_create"));
TRY(event_object.add("parent_pid", static_cast<u64>(event.data.process_create.parent_pid)));
TRY(event_object.add("executable", event.data.process_create.executable));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
case PERF_EVENT_PROCESS_EXEC:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "process_exec"));
TRY(event_object.add("executable", event.data.process_exec.executable));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
case PERF_EVENT_PROCESS_EXIT:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "process_exit"));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
case PERF_EVENT_THREAD_CREATE:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "thread_create"));
TRY(event_object.add("parent_tid", static_cast<u64>(event.data.thread_create.parent_tid)));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
case PERF_EVENT_THREAD_EXIT:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "thread_exit"));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
break;
Kernel: Track performance events for context switches
2021-05-14 05:48:53 +00:00
case PERF_EVENT_CONTEXT_SWITCH:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "context_switch"));
TRY(event_object.add("next_pid", static_cast<u64>(event.data.context_switch.next_pid)));
TRY(event_object.add("next_tid", static_cast<u64>(event.data.context_switch.next_tid)));
Kernel: Track performance events for context switches
2021-05-14 05:48:53 +00:00
break;
Kernel: Add support for profiling kmalloc()/kfree()
2021-05-13 11:09:00 +00:00
case PERF_EVENT_KMALLOC:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "kmalloc"));
TRY(event_object.add("ptr", static_cast<u64>(event.data.kmalloc.ptr)));
TRY(event_object.add("size", static_cast<u64>(event.data.kmalloc.size)));
Kernel: Add support for profiling kmalloc()/kfree()
2021-05-13 11:09:00 +00:00
break;
case PERF_EVENT_KFREE:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "kfree"));
TRY(event_object.add("ptr", static_cast<u64>(event.data.kfree.ptr)));
TRY(event_object.add("size", static_cast<u64>(event.data.kfree.size)));
Kernel: Add support for profiling kmalloc()/kfree()
2021-05-13 11:09:00 +00:00
break;
Kernel: Generate page fault events from the kernel profiler Hook the kernel page fault handler and capture page fault events when the fault has a current thread attached in TLS. We capture the eip and ebp so we can unwind the stack and locate which pieces of code are generating the most page faults. Co-authored-by: Gunnar Beutner <gbeutner@serenityos.org>
2021-05-18 09:26:11 +00:00
case PERF_EVENT_PAGE_FAULT:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "page_fault"));
Kernel: Generate page fault events from the kernel profiler Hook the kernel page fault handler and capture page fault events when the fault has a current thread attached in TLS. We capture the eip and ebp so we can unwind the stack and locate which pieces of code are generating the most page faults. Co-authored-by: Gunnar Beutner <gbeutner@serenityos.org>
2021-05-18 09:26:11 +00:00
break;
Kernel: Add syscall performance event type This allows tracing the syscalls made by a thread through the kernel's performance event framework, which is similar in principle to strace. Currently, this merely logs a stack backtrace to the current thread's performance event buffer whenever a syscall is made, if profiling is enabled. Future improvements could include tracing the arguments and the return value, for example.
2021-08-10 19:02:59 +00:00
case PERF_EVENT_SYSCALL:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "syscall"));
Kernel: Add syscall performance event type This allows tracing the syscalls made by a thread through the kernel's performance event framework, which is similar in principle to strace. Currently, this merely logs a stack backtrace to the current thread's performance event buffer whenever a syscall is made, if profiling is enabled. Future improvements could include tracing the arguments and the return value, for example.
2021-08-10 19:02:59 +00:00
break;
Kernel+LibC: Add PERF_EVENT_SIGNPOST This event will be used by userspace programs wanting to mark interesting high-level events in the profile. :^)
2021-08-11 18:04:03 +00:00
case PERF_EVENT_SIGNPOST:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type"sv, "signpost"sv));
TRY(event_object.add("arg1"sv, event.data.signpost.arg1));
TRY(event_object.add("arg2"sv, event.data.signpost.arg2));
Kernel+LibC: Add PERF_EVENT_SIGNPOST This event will be used by userspace programs wanting to mark interesting high-level events in the profile. :^)
2021-08-11 18:04:03 +00:00
break;
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
case PERF_EVENT_READ:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("type", "read"));
TRY(event_object.add("fd", event.data.read.fd));
TRY(event_object.add("size"sv, event.data.read.size));
TRY(event_object.add("filename_index"sv, event.data.read.filename_index));
TRY(event_object.add("start_timestamp"sv, event.data.read.start_timestamp));
TRY(event_object.add("success"sv, event.data.read.success));
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
break;
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(event_object.add("pid", event.pid));
TRY(event_object.add("tid", event.tid));
TRY(event_object.add("timestamp", event.timestamp));
TRY(event_object.add("lost_samples", seen_first_sample ? event.lost_samples : 0));
Kernel: Correctly set the lost_samples field for the first sample This ensures that the lost_samples field is set to zero for the first sample. We didn't lose any samples before the first sample so this is the correct value. Without this Profiler gets confused and draws the graph for the process which contains the first CPU sample incorrectly (all zeroes usually).
2021-05-13 22:43:08 +00:00
if (event.type == PERF_EVENT_SAMPLE)
seen_first_sample = true;
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
auto stack_array = TRY(event_object.add_array("stack"));
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
for (size_t j = 0; j < event.stack_size; ++j) {
Kernel: Mask kernel addresses in perf event streams for non-superuser We now turn kernel addresses into 0xdeadc0de, same as /proc/PID/stacks/
2021-12-19 15:41:07 +00:00
auto address = event.stack[j];
if (!show_kernel_addresses && !Memory::is_user_address(VirtualAddress { address }))
address = 0xdeadc0de;
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(stack_array.add(address));
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(stack_array.finish());
TRY(event_object.finish());
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(array.finish());
TRY(object.finish());
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
}
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> PerformanceEventBuffer::to_json(KBufferBuilder& builder) const
Kernel: Start work on full system profiling :^) The superuser can now call sys$profiling_enable() with PID -1 to enable profiling of all running threads in the system. The perf events are collected in a global PerformanceEventBuffer (currently 32 MiB in size.) The events can be accessed via /proc/profile
2021-03-02 16:19:35 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
auto object = TRY(JsonObjectSerializer<>::try_create(builder));
Kernel: Start work on full system profiling :^) The superuser can now call sys$profiling_enable() with PID -1 to enable profiling of all running threads in the system. The perf events are collected in a global PerformanceEventBuffer (currently 32 MiB in size.) The events can be accessed via /proc/profile
2021-03-02 16:19:35 +00:00
return to_json_impl(object);
}
Kernel: Better handling of allocation failure in profiling If we can't allocate a PerformanceEventBuffer to store the profiling events, we now fail sys$profiling_enable() and sys$perf_event() with ENOMEM instead of carrying on with a broken buffer.
2021-03-02 15:55:54 +00:00
OwnPtr<PerformanceEventBuffer> PerformanceEventBuffer::try_create_with_size(size_t buffer_size)
{
Kernel: Annotate all `KBuffer` and `DoubleBuffer` with a custom name
2022-04-10 22:08:07 +00:00
auto buffer_or_error = KBuffer::try_create_with_size("Performance events"sv, buffer_size, Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow);
Kernel: Make KBuffer::try_create_with_size() return KResultOr This allows us to use TRY() in a lot of new places.
2021-09-07 13:15:08 +00:00
if (buffer_or_error.is_error())
Kernel: Better handling of allocation failure in profiling If we can't allocate a PerformanceEventBuffer to store the profiling events, we now fail sys$profiling_enable() and sys$perf_event() with ENOMEM instead of carrying on with a broken buffer.
2021-03-02 15:55:54 +00:00
return {};
Kernel: Make KBuffer::try_create_with_size() return KResultOr This allows us to use TRY() in a lot of new places.
2021-09-07 13:15:08 +00:00
return adopt_own_if_nonnull(new (nothrow) PerformanceEventBuffer(buffer_or_error.release_value()));
Kernel: Better handling of allocation failure in profiling If we can't allocate a PerformanceEventBuffer to store the profiling events, we now fail sys$profiling_enable() and sys$perf_event() with ENOMEM instead of carrying on with a broken buffer.
2021-03-02 15:55:54 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> PerformanceEventBuffer::add_process(Process const& process, ProcessEventType event_type)
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
{
Kernel: Rename ScopedSpinlock => SpinlockLocker This matches MutexLocker, and doesn't sound like it's a lock itself.
2021-08-21 23:49:22 +00:00
SpinlockLocker locker(process.address_space().get_lock());
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
Kernel: Use try_serialize_absolute_path in PerformanceEventBuffer This only moves the issue, as PerformanceEventBuffer::add_process can't fail yet, but this will allow us to remove the non-failable Custody::absolute_path API.
2022-01-11 19:34:16 +00:00
OwnPtr<KString> executable;
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
if (process.executable())
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
executable = TRY(process.executable()->try_serialize_absolute_path());
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
else
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
executable = TRY(KString::formatted("<{}>", process.name()));
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
TRY(append_with_ip_and_bp(process.pid(), 0, 0, 0,
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
event_type == ProcessEventType::Create ? PERF_EVENT_PROCESS_CREATE : PERF_EVENT_PROCESS_EXEC,
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
0, process.pid().value(), 0, executable->view()));
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
ErrorOr<void> result;
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
process.for_each_thread([&](auto& thread) {
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
result = append_with_ip_and_bp(process.pid(), thread.tid().value(),
Kernel+Profiler: Track lost time between profiler timer ticks We can lose profiling timer events for a few reasons, for example disabled interrupts or system slowness. This accounts for lost time between CPU samples by adding a field lost_samples to each profiling event which tracks how many samples were lost immediately preceding the event.
2021-05-13 20:14:07 +00:00
0, 0, PERF_EVENT_THREAD_CREATE, 0, 0, 0, nullptr);
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
return result.is_error() ? IterationDecision::Break : IterationDecision::Continue;
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
});
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
TRY(result);
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
Kernel: Add some implied auto qualifiers
2021-12-29 00:01:27 +00:00
for (auto const& region : process.address_space().regions()) {
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
TRY(append_with_ip_and_bp(process.pid(), 0,
Kernel: Store AddressSpace memory regions in an IntrusiveRedBlackTree This means we never need to allocate when inserting/removing regions from the address space.
2022-04-01 23:28:01 +00:00
0, 0, PERF_EVENT_MMAP, 0, region.range().base().get(), region.range().size(), region.name()));
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
}
Kernel: Make PerformanceEventBuffer::add_process fallible with ErrorOr
2022-01-11 19:50:12 +00:00
return {};
Kernel+Profiler: Capture metadata about all profiled processes The perfcore file format was previously limited to a single process since the pid/executable/regions data was top-level in the JSON. This patch moves the process-specific data into a top-level array named "processes" and we now add entries for each process that has been sampled during the profile run. This makes it possible to see samples from multiple threads when viewing a perfcore file with Profiler. This is extremely cool! :^)
2021-03-02 18:01:02 +00:00
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> PerformanceEventBuffer::register_string(NonnullOwnPtr<KString> string)
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. :^)
2021-08-11 18:28:29 +00:00
{
Kernel: Fixed behavior of repeated calls to register_string Previously register_string would return incorrect values when called multiple times with the same input. This patch makes this function return the same index, identical strings. This change was required, as this functionality is now being used with read syscall profiling, (#12465), which uses 'register_string' to registers file path on every read syscall.
2022-02-26 21:59:26 +00:00
auto it = m_strings.find(string);
if (it != m_strings.end()) {
return it->value;
}
auto new_index = m_strings.size();
TRY(m_strings.try_set(move(string), move(new_index)));
return new_index;
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. :^)
2021-08-11 18:28:29 +00:00
}
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
}
Reference in a new issue Copy permalink