system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-24 03:25:02 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
serenity/Kernel/Tasks/FinalizerTask.cpp

38 lines
1.2 KiB
C++
Raw Normal View History

Kernel: Move sync and finalization tasks into their own files Instead of clogging up the initialization sequence, put these tasks in their own files.
2020-04-08 13:13:49 +00:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
*
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: Move sync and finalization tasks into their own files Instead of clogging up the initialization sequence, put these tasks in their own files.
2020-04-08 13:13:49 +00:00
*/
Kernel: Move special sections into Sections.h This also removes a lot of CPU.h includes infavor for Sections.h
2021-06-22 15:40:16 +00:00
#include <Kernel/Sections.h>
Kernel: Move sync and finalization tasks into their own files Instead of clogging up the initialization sequence, put these tasks in their own files.
2020-04-08 13:13:49 +00:00
#include <Kernel/Tasks/FinalizerTask.h>
Kernel: Move all tasks-related code to the Tasks subdirectory
2023-02-24 17:45:37 +00:00
#include <Kernel/Tasks/Process.h>
#include <Kernel/Tasks/Scheduler.h>
Kernel: Move sync and finalization tasks into their own files Instead of clogging up the initialization sequence, put these tasks in their own files.
2020-04-08 13:13:49 +00:00
namespace Kernel {
Kernel: Unify Kernel task names for consistency This change unifies the naming convention for kernel tasks. The goal of this change is to: - Make the task names more descriptive, so users can more easily understand their purpose in System Monitor. - Unify the naming convention so they are consistent.
2022-06-05 04:44:48 +00:00
static constexpr StringView finalizer_task_name = "Finalizer Task"sv;
Kernel: Pass trampolines instead of lambdas to create_kernel_process With -Og, all calls to create_kernel_process were triggering -Wnonnull when creating these lambdas that get implicitly converted to function pointers. A different design of create_kernel_process to use AK::Function instead might avoid this awkward behavior.
2021-05-23 19:45:58 +00:00
static void finalizer_task(void*)
{
Thread::current()->set_priority(THREAD_PRIORITY_LOW);
Kernel/Tasks: Allow Kernel processes to be shut down Since we never check a kernel process's state like a userland process, it's possible for a kernel process to ignore the fact that someone is trying to kill it, and continue running. This is not desireable if we want to properly shutdown all processes, including Kernel ones.
2023-06-27 13:19:39 +00:00
while (!Process::current().is_dying()) {
Kernel: Ignore allocation failures during thread finalization We ignore allocation failures above the first 32 guaranteed thread slots, and just flag our future-selves to finalize these threads at a later point.
2022-01-26 16:34:31 +00:00
// The order of this if-else is important: We want to continue trying to finalize the threads in case
// Thread::finalize_dying_threads set g_finalizer_has_work back to true due to OOM conditions
Kernel: Pass trampolines instead of lambdas to create_kernel_process With -Og, all calls to create_kernel_process were triggering -Wnonnull when creating these lambdas that get implicitly converted to function pointers. A different design of create_kernel_process to use AK::Function instead might avoid this awkward behavior.
2021-05-23 19:45:58 +00:00
if (g_finalizer_has_work.exchange(false, AK::MemoryOrder::memory_order_acq_rel) == true)
Thread::finalize_dying_threads();
Kernel: Ignore allocation failures during thread finalization We ignore allocation failures above the first 32 guaranteed thread slots, and just flag our future-selves to finalize these threads at a later point.
2022-01-26 16:34:31 +00:00
else
Kernel: Unify Kernel task names for consistency This change unifies the naming convention for kernel tasks. The goal of this change is to: - Make the task names more descriptive, so users can more easily understand their purpose in System Monitor. - Unify the naming convention so they are consistent.
2022-06-05 04:44:48 +00:00
g_finalizer_wait_queue->wait_forever(finalizer_task_name);
Kernel: Pass trampolines instead of lambdas to create_kernel_process With -Og, all calls to create_kernel_process were triggering -Wnonnull when creating these lambdas that get implicitly converted to function pointers. A different design of create_kernel_process to use AK::Function instead might avoid this awkward behavior.
2021-05-23 19:45:58 +00:00
}
Kernel/Tasks: Allow Kernel processes to be shut down Since we never check a kernel process's state like a userland process, it's possible for a kernel process to ignore the fact that someone is trying to kill it, and continue running. This is not desireable if we want to properly shutdown all processes, including Kernel ones.
2023-06-27 13:19:39 +00:00
Process::current().sys$exit(0);
VERIFY_NOT_REACHED();
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-08 02:48:11 +00:00
}
Kernel: Pass trampolines instead of lambdas to create_kernel_process With -Og, all calls to create_kernel_process were triggering -Wnonnull when creating these lambdas that get implicitly converted to function pointers. A different design of create_kernel_process to use AK::Function instead might avoid this awkward behavior.
2021-05-23 19:45:58 +00:00
Kernel: Mark FinalizerTask::spawn() as UNMAP_AFTER_INIT
2021-06-09 07:52:31 +00:00
UNMAP_AFTER_INIT void FinalizerTask::spawn()
Kernel: Move sync and finalization tasks into their own files Instead of clogging up the initialization sequence, put these tasks in their own files.
2020-04-08 13:13:49 +00:00
{
Kernel: Don't allocate memory for names of processes and threads Instead, use the FixedCharBuffer class to ensure we always use a static buffer storage for these names. This ensures that if a Process or a Thread were created, there's a guarantee that setting a new name will never fail, as only copying of strings should be done to that static storage. The limits which are set are 32 characters for processes' names and 64 characters for thread names - this is because threads' names could be more verbose than processes' names.
2023-07-17 15:34:19 +00:00
auto [_, finalizer_thread] = MUST(Process::create_kernel_process(finalizer_task_name, finalizer_task, nullptr));
Kernel: Simplify Process factory functions - Instead of taking the first new thread as an out-parameter, we now bundle the process and its first thread in a struct and use that as the return value. - Make all Process factory functions return ErrorOr. Use this to convert some places to more TRY(). - Drop the "try_" prefix on Process factory functions.
2023-04-02 17:25:36 +00:00
g_finalizer = move(finalizer_thread);
Kernel: Move sync and finalization tasks into their own files Instead of clogging up the initialization sequence, put these tasks in their own files.
2020-04-08 13:13:49 +00:00
}
}
Reference in a new issue Copy permalink