system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-23 19:15:55 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
serenity/Kernel/Arch/init.cpp

516 lines
19 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
* Copyright (c) 2018-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
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*/
Kernel: Exclude individual functions from coverage instrumentation Sticking this to the function source has multiple benefits: - We instrument more code, by not excluding entire files. - NO_SANITIZE_COVERAGE can be used in Header files. - Keeping the info with the source code, means if a function or file is moved around, the NO_SANITIZE_COVERAGE moves with it.
2024-04-08 00:52:13 +00:00
#include <AK/Platform.h>
Kernel: Use the AK SetOnce container class in various cases We have many places in the kernel code that we have boolean flags that are only set once, and never reset again but are checked multiple times before and after the time they're being set, which matches the purpose of the SetOnce class.
2024-04-22 10:30:09 +00:00
#include <AK/SetOnce.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <AK/Types.h>
Kernel/riscv64: Take the memory map from the FDT and dump it For this the BootInfo struct was made architecture specific
2024-01-26 13:37:36 +00:00
#include <Kernel/Arch/CPU.h>
Kernel: Move IRQController and InterruptManagement to Arch directory These 2 classes currently contain much code that is x86(_64) specific. Move them to the architecture specific directory. This also allows for a simpler implementation for aarch64.
2022-05-30 07:04:37 +00:00
#include <Kernel/Arch/InterruptManagement.h>
Kernel: Add per platform Processor.h headers The platform independent Processor.h file includes the shared processor code and includes the specific platform header file. All references to the Arch/x86/Processor.h file have been replaced with a reference to Arch/Processor.h.
2021-10-13 23:07:37 +00:00
#include <Kernel/Arch/Processor.h>
Kernel: Move all boot-related code to the new Boot subdirectory
2023-02-24 18:21:53 +00:00
#include <Kernel/Boot/BootInfo.h>
#include <Kernel/Boot/CommandLine.h>
#include <Kernel/Boot/Multiboot.h>
Kernel/PCI: Move the PCI components as a subfolder to the Bus directory
2021-06-25 06:46:17 +00:00
#include <Kernel/Bus/PCI/Access.h>
#include <Kernel/Bus/PCI/Initializer.h>
Kernel: Call USB Driver initialize functions during init
2022-05-17 11:47:57 +00:00
#include <Kernel/Bus/USB/Drivers/USBDriver.h>
Kernel/USB: Create controller base class and introduce USBManagement This removes Pipes dependency on the UHCIController by introducing a controller base class. This will be used to implement other controllers such as OHCI. Additionally, there can be multiple instances of a UHCI controller. For example, multiple UHCI instances can be required for systems with EHCI controllers. EHCI relies on using multiple of either UHCI or OHCI controllers to drive USB 1.x devices. This means UHCIController can no longer be a singleton. Multiple instances of it can now be created and passed to the device and then to the pipe. To handle finding and creating these instances, USBManagement has been introduced. It has the same pattern as the other management classes such as NetworkManagement.
2021-08-08 18:50:20 +00:00
#include <Kernel/Bus/USB/USBManagement.h>
Kernel/VirtIO: Remove redundant VirtIO word from filenames Now that all related VirtIO classes are in the VirtIO namespace, let's just remove the redundant VirtIO word from filenames.
2021-08-27 09:24:50 +00:00
#include <Kernel/Bus/VirtIO/Device.h>
Kernel/VirtIO: Introduce the concept of transport options The VirtIO specification defines many types of devices with different purposes, and it also defines 3 possible transport mediums where devices could be connected to the host machine. We only care about the PCIe transport, but this commit puts the actual foundations for supporting the lean MMIO transport too in the future. To ensure things are kept abstracted but still functional, the VirtIO transport code is responsible for what is deemed as related to an actual transport type - allocation of interrupt handlers and tinkering with low level transport-related registers, etc.
2023-06-10 11:46:47 +00:00
#include <Kernel/Bus/VirtIO/Transport/PCIe/Detect.h>
Kernel/Audio: Introduce a new design architecture for the subsystem We have 3 new components: 1. The AudioManagement singleton. This class like in other subsystems, is responsible to find hardware audio controllers and keep a reference to them. 2. AudioController class - this class is the parent class for hardware controllers like the Sound Blaster 16 or Intel 82801AA (AC97). For now, this class has simple interface for getting and controlling sample rate of audio channels, as well a write interface for specific audio channel but not reading from it. One AudioController object might have multiple AudioChannel "child" objects to hold with reference counting. 3. AudioChannel class - this is based on the CharacterDevice class, and represents hardware PCM audio channel. It facilitates an ioctl interface which should be consistent across all supported hardware currently. It has a weak reference to a parent AudioController, and when trying to write to a channel, it redirects the data to the parent AudioController. Each audio channel device should be added into a new directory under the /dev filesystem called "audio".
2022-02-11 19:47:45 +00:00
#include <Kernel/Devices/Audio/Management.h>
Kernel: Introduce the DeviceManagement singleton This singleton simplifies many aspects that we struggled with before: 1. There's no need to make derived classes of Device expose the constructor as public anymore. The singleton is a friend of them, so he can call the constructor. This solves the issue with try_create_device helper neatly, hopefully for good. 2. Getting a reference of the NullDevice is now being done from this singleton, which means that NullDevice no longer needs to use its own singleton, and we can apply the try_create_device helper on it too :) 3. We can now defer registration completely after the Device constructor which means the Device constructor is merely assigning the major and minor numbers of the Device, and the try_create_device helper ensures it calls the after_inserting method immediately after construction. This creates a great opportunity to make registration more OOM-safe.
2021-09-11 06:19:20 +00:00
#include <Kernel/Devices/DeviceManagement.h>
Kernel: Add FUSE support This adds both the fuse device (used for communication between the kernel and the filesystem) and filesystem implementation itself.
2024-02-04 13:26:38 +00:00
#include <Kernel/Devices/FUSEDevice.h>
Kernel: Move all Graphics-related code into Devices/GPU directory Like the HID, Audio and Storage subsystem, the Graphics subsystem (which handles GPUs technically) exposes unix device files (typically in /dev). To ensure consistency across the repository, move all related files to a new directory under Kernel/Devices called "GPU". Also remove the redundant "GPU" word from the VirtIO driver directory, and the word "Graphics" from GraphicsManagement.{h,cpp} filenames.
2023-06-03 11:47:47 +00:00
#include <Kernel/Devices/GPU/Console/BootFramebufferConsole.h>
#include <Kernel/Devices/GPU/Management.h>
Kernel: Move a bunch of generic devices code into new subdirectory
2023-03-18 11:17:13 +00:00
#include <Kernel/Devices/Generic/DeviceControlDevice.h>
#include <Kernel/Devices/Generic/FullDevice.h>
#include <Kernel/Devices/Generic/MemoryDevice.h>
#include <Kernel/Devices/Generic/NullDevice.h>
Kernel+Userland: Replace the beep syscall with the new /dev/beep device There's no need to have separate syscall for this kind of functionality, as we can just have a device node in /dev, called "beep", that allows writing tone generation packets to emulate the same behavior. In addition to that, we remove LibC sysbeep function, as this function was never being used by any C program nor it was standardized in any way. Instead, we move the userspace implementation to LibCore.
2023-08-25 16:48:46 +00:00
#include <Kernel/Devices/Generic/PCSpeakerDevice.h>
Kernel: Move a bunch of generic devices code into new subdirectory
2023-03-18 11:17:13 +00:00
#include <Kernel/Devices/Generic/RandomDevice.h>
#include <Kernel/Devices/Generic/SelfTTYDevice.h>
#include <Kernel/Devices/Generic/ZeroDevice.h>
Kernel: Remove redundant HID name from all associated files
2022-12-19 21:53:51 +00:00
#include <Kernel/Devices/HID/Management.h>
Kernel: Only build kcov object files, if feature is enabled
2024-04-08 00:33:58 +00:00
#ifdef ENABLE_KERNEL_COVERAGE_COLLECTION
# include <Kernel/Devices/KCOVDevice.h>
#endif
Kernel: Implement a PCI Serial Device driver This simple driver simply finds a device in a device definitions list and then sets up a SerialDevice instance based on the definition. The driver currently only supports "WCH CH382 2S" pci serial boards, as that is the only device available for me to test with, but most other pci serial devices should be as easily addable as adding a board_definitions entry.
2021-04-23 14:26:52 +00:00
#include <Kernel/Devices/PCISerialDevice.h>
Kernel: Implement serial port driver This implements a basic 8250 UART serial port driver. It does not currently handle (or enable) interrupts, nor any runtime configuration.
2019-06-08 13:24:34 +00:00
#include <Kernel/Devices/SerialDevice.h>
Kernel: Move the Storage directory to be a new directory under Devices The Storage subsystem, like the Audio and HID subsystems, exposes Unix device files (for example, in the /dev directory). To ensure consistency across the repository, we should make the Storage subsystem to reside in the Kernel/Devices directory like the two other mentioned subsystems.
2023-03-18 11:32:12 +00:00
#include <Kernel/Devices/Storage/StorageManagement.h>
Kernel: Move TTY-related code to a new subdirectory under Devices The TTY subsystem is represented with unix devices, so it should be under the Devices directory like the Audio, Storage, GPU and HID subsystems.
2023-07-08 11:18:32 +00:00
#include <Kernel/Devices/TTY/ConsoleManagement.h>
#include <Kernel/Devices/TTY/PTYMultiplexer.h>
#include <Kernel/Devices/TTY/VirtualConsole.h>
Kernel: Split the SysFS core files into smaller components
2022-10-23 18:51:56 +00:00
#include <Kernel/FileSystem/SysFS/Registry.h>
Kernel/SysFS: Stop cluttering the codebase with pieces of SysFS parts Instead, start to put everything in one place to resemble the directory structure of the SysFS when actually using it.
2022-04-22 06:44:31 +00:00
#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/Directory.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/FileSystem/VirtualFileSystem.h>
Kernel: Move ACPI and BIOS code into the new Firmware directory This will somwhat help unify them also under the same SysFS directory in the commit. Also, it feels much more like this change reflects the reality that both ACPI and the BIOS are part of the firmware on x86 computers.
2021-09-11 07:39:47 +00:00
#include <Kernel/Firmware/ACPI/Initialize.h>
#include <Kernel/Firmware/ACPI/Parser.h>
Kernel: Move kmalloc() into a Kernel/Heap/ directory
2019-09-16 07:01:44 +00:00
#include <Kernel/Heap/kmalloc.h>
Kernel: Move more things from init() to init_stage2() The purpose of init() is to get multi-tasking up and running. We don't want to do anything in init() that doesn't advance that goal. This patch moves some things from init() to init_stage2(), and adds a comment block explaining the split.
2020-04-08 12:07:12 +00:00
#include <Kernel/KSyms.h>
Everywhere: Move global Kernel pattern code to Kernel/Library directory This has KString, KBuffer, DoubleBuffer, KBufferBuilder, IOWindow, UserOrKernelBuffer and ScopedCritical classes being moved to the Kernel/Library subdirectory. Also, move the panic and assertions handling code to that directory.
2023-02-24 18:10:59 +00:00
#include <Kernel/Library/Panic.h>
Kernel: Rename Kernel/VM/ to Kernel/Memory/ This directory isn't just about virtual memory, it's about all kinds of memory management.
2021-08-06 08:45:34 +00:00
#include <Kernel/Memory/MemoryManager.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 17:54:38 +00:00
#include <Kernel/Net/NetworkTask.h>
Kernel: Introduce the NetworkingManagement singleton Instead of initializing network adapters in init.cpp, let's move that logic into a separate class to handle this. Also, it seems like a good idea to shift responsiblity on enumeration of network adapters after the boot process, so this singleton will take care of finding the appropriate network adapter when asked to with an IPv4 address or interface name. With this change being merged, we simplify the creation logic of NetworkAdapter derived classes, so we enumerate the PCI bus only once, searching for driver candidates when doing so, and we let each driver to test if it is resposible for the specified PCI device.
2021-06-04 04:43:16 +00:00
#include <Kernel/Net/NetworkingManagement.h>
Kernel: Move boot info declarations to a header file Instead of manually redeclaring those variables in various files this now adds a header file for them.
2021-07-19 15:54:51 +00:00
#include <Kernel/Prekernel/Prekernel.h>
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 Random.{h,cpp} code to Security subdirectory
2023-02-24 17:49:37 +00:00
#include <Kernel/Security/Random.h>
Kernel: Simplify VMWareBackdoor somewhat - If there is no VMWare backdoor, don't allocate memory for it. - Remove the "unsupported" state, instead just don't instantiate. - Move the command-line parsing from init to the driver. - Move mouse packet reception from PS2MouseDevice to VMWareBackdoor.
2020-04-08 14:35:00 +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: Simplify VMWareBackdoor somewhat - If there is no VMWare backdoor, don't allocate memory for it. - Remove the "unsupported" state, instead just don't instantiate. - Move the command-line parsing from init to the driver. - Move mouse packet reception from PS2MouseDevice to VMWareBackdoor.
2020-04-08 14:35:00 +00:00
#include <Kernel/Tasks/SyncTask.h>
Kernel: Move all tasks-related code to the Tasks subdirectory
2023-02-24 17:45:37 +00:00
#include <Kernel/Tasks/WorkQueue.h>
Kernel: Introduce the new Time management subsystem This new subsystem includes better abstractions of how time will be handled in the OS. We take advantage of the existing RTC timer to aid in keeping time synchronized. This is standing in contrast to how we handled time-keeping in the kernel, where the PIT was responsible for that function in addition to update the scheduler about ticks. With that new advantage, we can easily change the ticking dynamically and still keep the time synchronized. In the process context, we no longer use a fixed declaration of TICKS_PER_SECOND, but we call the TimeManagement singleton class to provide us the right value. This allows us to use dynamic ticking in the future, a feature known as tickless kernel. The scheduler no longer does by himself the calculation of real time (Unix time), and just calls the TimeManagment singleton class to provide the value. Also, we can use 2 new boot arguments: - the "time" boot argument accpets either the value "modern", or "legacy". If "modern" is specified, the time management subsystem will try to setup HPET. Otherwise, for "legacy" value, the time subsystem will revert to use the PIT & RTC, leaving HPET disabled. If this boot argument is not specified, the default pattern is to try to setup HPET. - the "hpet" boot argumet accepts either the value "periodic" or "nonperiodic". If "periodic" is specified, the HPET will scan for periodic timers, and will assert if none are found. If only one is found, that timer will be assigned for the time-keeping task. If more than one is found, both time-keeping task & scheduler-ticking task will be assigned to periodic timers. If this boot argument is not specified, the default pattern is to try to scan for HPET periodic timers. This boot argument has no effect if HPET is disabled. In hardware context, PIT & RealTimeClock classes are merely inheriting from the HardwareTimer class, and they allow to use the old i8254 (PIT) and RTC devices, managing them via IO ports. By default, the RTC will be programmed to a frequency of 1024Hz. The PIT will be programmed to a frequency close to 1000Hz. About HPET, depending if we need to scan for periodic timers or not, we try to set a frequency close to 1000Hz for the time-keeping timer and scheduler-ticking timer. Also, if possible, we try to enable the Legacy replacement feature of the HPET. This feature if exists, instructs the chipset to disconnect both i8254 (PIT) and RTC. This behavior is observable on QEMU, and was verified against the source code: https://github.com/qemu/qemu/commit/ce967e2f33861b0e17753f97fa4527b5943c94b6 The HPETComparator class is inheriting from HardwareTimer class, and is responsible for an individual HPET comparator, which is essentially a timer. Therefore, it needs to call the singleton HPET class to perform HPET-related operations. The new abstraction of Hardware timers brings an opportunity of more new features in the foreseeable future. For example, we can change the callback function of each hardware timer, thus it makes it possible to swap missions between hardware timers, or to allow to use a hardware timer for other temporary missions (e.g. calibrating the LAPIC timer, measuring the CPU frequency, etc).
2020-03-09 15:03:27 +00:00
#include <Kernel/Time/TimeManagement.h>
Everywhere: Remove klog(), dbg() and purge all LogStream usage :^) Good-bye LogStream. Long live AK::Format!
2021-03-12 16:29:37 +00:00
#include <Kernel/kstdio.h>
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
# include <Kernel/Arch/x86_64/Hypervisor/VMWareBackdoor.h>
# include <Kernel/Arch/x86_64/Interrupts/APIC.h>
# include <Kernel/Arch/x86_64/Interrupts/PIC.h>
Kernel: Move VGATextModeConsole code to the Arch/x86_64/ISABus directory This code is specific to x86 machines, as virtually no other computer architecture has any compatibility with old VGA legacy functionality.
2024-03-15 22:20:12 +00:00
# include <Kernel/Arch/x86_64/VGA/TextModeConsole.h>
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#elif ARCH(AARCH64)
# include <Kernel/Arch/aarch64/RPi/Framebuffer.h>
# include <Kernel/Arch/aarch64/RPi/Mailbox.h>
Kernel: Add character device driver for the RPi "mini UART" (UART1) While the PL011-based UART0 is currently reserved for the kernel console, UART1 is free to be exposed to the userspace as `/dev/ttyS0`. This will be used as the stdout of `run-tests-and-shutdown.sh` when testing the AArch64 kernel.
2023-05-15 05:51:46 +00:00
# include <Kernel/Arch/aarch64/RPi/MiniUART.h>
Kernel/riscv64: Implement microseconds_delay This simple delay loop uses the time CSR to wait for the given amount of time. The tick frequency of the CSR is read from the /cpus/timebase-frequency devicetree property.
2024-02-27 00:22:37 +00:00
#elif ARCH(RISCV64)
# include <Kernel/Arch/riscv64/Delay.h>
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
// Defined in the linker script
typedef void (*ctor_func_t)();
Kernel: Fix the variable declaration for some linker script symbols Despite what the declaration would have us believe these are not "u8*". If they were we wouldn't have to use the & operator to get the address of them and then cast them to "u8*"/FlatPtr afterwards.
2021-07-22 20:11:17 +00:00
extern ctor_func_t start_heap_ctors[];
extern ctor_func_t end_heap_ctors[];
extern ctor_func_t start_ctors[];
extern ctor_func_t end_ctors[];
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
LibC: Use uintptr_t for __stack_chk_guard We used size_t, which is a type that is guarenteed to be large enough to hold an array index, but uintptr_t is designed to be used to hold pointer values, which is the case of stack guards.
2022-11-26 18:17:32 +00:00
extern uintptr_t __stack_chk_guard;
READONLY_AFTER_INIT uintptr_t __stack_chk_guard __attribute__((used));
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
Kernel: Fix the variable declaration for some linker script symbols Despite what the declaration would have us believe these are not "u8*". If they were we wouldn't have to use the & operator to get the address of them and then cast them to "u8*"/FlatPtr afterwards.
2021-07-22 20:11:17 +00:00
extern "C" u8 start_of_safemem_text[];
extern "C" u8 end_of_safemem_text[];
extern "C" u8 start_of_safemem_atomic_text[];
extern "C" u8 end_of_safemem_atomic_text[];
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
Kernel: Call USB Driver initialize functions during init
2022-05-17 11:47:57 +00:00
extern "C" USB::DriverInitFunction driver_init_table_start[];
extern "C" USB::DriverInitFunction driver_init_table_end[];
Kernel: Fix the variable declaration for some linker script symbols Despite what the declaration would have us believe these are not "u8*". If they were we wouldn't have to use the & operator to get the address of them and then cast them to "u8*"/FlatPtr afterwards.
2021-07-22 20:11:17 +00:00
extern "C" u8 end_of_kernel_image[];
Kernel: Panic early if the kernel gets too big for its memory slot Let's help our future selves find this problem sooner next time it happens. Hopefully we'll come up with a nicer loader before then, but who knows. :^)
2021-02-24 19:57:47 +00:00
Kernel: Use the AK SetOnce container class in various cases We have many places in the kernel code that we have boolean flags that are only set once, and never reset again but are checked multiple times before and after the time they're being set, which matches the purpose of the SetOnce class.
2024-04-22 10:30:09 +00:00
READONLY_AFTER_INIT SetOnce g_not_in_early_boot;
Kernel: Copy the kernel command line to a good location at boot When building the kernel with -O2, we somehow ended up with the kernel command line outside of the lower 8MB of physical memory. Since we don't map that area in our initial page table setup, we would triple fault when trying to parse the command line. This patch sidesteps the issue by copying the (first 4KB of) the kernel command line to a buffer in a known safe location at boot.
2021-02-23 18:25:58 +00:00
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
namespace Kernel {
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 03:51:34 +00:00
[[noreturn]] static void init_stage2(void*);
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
static void setup_serial_debug();
Kernel: init: Make comment clearer
2021-03-03 13:16:14 +00:00
// boot.S expects these functions to exactly have the following signatures.
// We declare them here to ensure their signatures don't accidentally change.
Kernel: Enable building the kernel with -flto GCC with -flto is more aggressive when it comes to inlining and discarding functions which is why we must mark some of the functions as NEVER_INLINE (because they contain asm labels which would be duplicated in the object files if the compiler decides to inline the function elsewhere) and __attribute__((used)) for others so that GCC doesn't discard them.
2021-04-29 12:54:15 +00:00
extern "C" void init_finished(u32 cpu) __attribute__((used));
Kernel: Support starting up secondary processors on x86_64
2021-06-30 12:24:37 +00:00
extern "C" [[noreturn]] void init_ap(FlatPtr cpu, Processor* processor_info);
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
extern "C" [[noreturn]] void init(BootInfo const&);
Kernel: Tell compiler about invisible calls This makes the Kernel build cleanly with -Wmissing-declarations.
2020-08-11 21:33:37 +00:00
Kernel: Mark a handful of things in init.cpp as READONLY_AFTER_INIT
2021-02-14 16:40:52 +00:00
READONLY_AFTER_INIT VirtualConsole* tty0;
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
Kernel: Panic if the init process dies If init crashes, all other userspace processes exit too, thus rendering the system unusable. Previously, the kernel would still keep running even without a userland, showing just a black screen without any indication of the issue. We now panic the kernel, which shows a message on the console. In the case of the CI runners, it shuts down the virtual machine, so we don't have to wait for the 1 hour timeout if an issue arises with SystemServer.
2022-03-05 20:01:06 +00:00
ProcessID g_init_pid { 0 };
Kernel: Change the BSP Processor instance to not have a constructor This solves a problem where any non-trivial member in the global BSP Processor instance would get re-initialized (improperly), losing data that was already initialized earlier.
2022-03-27 11:48:51 +00:00
ALWAYS_INLINE static Processor& bsp_processor()
{
// This solves a problem where the bsp Processor instance
// gets "re"-initialized in init() when we run all global constructors.
alignas(Processor) static u8 bsp_processor_storage[sizeof(Processor)];
return (Processor&)bsp_processor_storage;
}
Kernel: Split initialization of Processor structure We need to very early on initialize the Processor structure so that we can use RecursiveSpinLock early on.
2020-07-02 14:34:00 +00:00
Kernel: Move more things from init() to init_stage2() The purpose of init() is to get multi-tasking up and running. We don't want to do anything in init() that doesn't advance that goal. This patch moves some things from init() to init_stage2(), and adds a comment block explaining the split.
2020-04-08 12:07:12 +00:00
// SerenityOS Kernel C++ entry point :^)
//
// This is where C++ execution begins, after boot.S transfers control here.
//
// The purpose of init() is to start multi-tasking. It does the bare minimum
// amount of work needed to start the scheduler.
//
// Once multi-tasking is ready, we spawn a new thread that starts in the
// init_stage2() function. Initialization continues there.
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
extern "C" {
Kernel: Annotate kernel_base and friends as READONLY_AFTER_INIT We don't want kernel_base to be modifiable by an attacker or a stray memory scribbler bug, so lets mark it as READONLY_AFTER_INIT.
2021-07-23 15:24:55 +00:00
READONLY_AFTER_INIT PhysicalAddress start_of_prekernel_image;
READONLY_AFTER_INIT PhysicalAddress end_of_prekernel_image;
Kernel: Make the kernel independent from specific physical addresses Previously the kernel relied on a fixed offset between virtual and physical addresses based on the kernel's load address. This allows us to specify an independent offset.
2021-07-22 11:05:04 +00:00
READONLY_AFTER_INIT size_t physical_to_virtual_offset;
Kernel: Support loading the kernel at almost arbitrary virtual addresses This enables further work on implementing KASLR by adding relocation support to the pre-kernel and updating the kernel to be less dependent on specific virtual memory layouts.
2021-07-26 13:10:51 +00:00
READONLY_AFTER_INIT FlatPtr kernel_mapping_base;
READONLY_AFTER_INIT FlatPtr kernel_load_base;
Kernel: Mark a few more things as READONLY_AFTER_INIT
2021-07-23 18:01:59 +00:00
READONLY_AFTER_INIT PhysicalAddress boot_pml4t;
READONLY_AFTER_INIT PhysicalAddress boot_pdpt;
READONLY_AFTER_INIT PhysicalAddress boot_pd0;
READONLY_AFTER_INIT PhysicalAddress boot_pd_kernel;
Kernel: Move Memory/PageDirectory.{cpp,h} to arch-specific directory The handling of page tables is very architecture specific, so belongs in the Arch directory. Some parts were already architecture-specific, however this commit moves the rest of the PageDirectory class into the Arch directory. While we're here the aarch64/PageDirectory.{h,cpp} files are updated to be aarch64 specific, by renaming some members and removing x86_64 specific code.
2023-01-19 21:36:48 +00:00
READONLY_AFTER_INIT Memory::PageTableEntry* boot_pd_kernel_pt1023;
Kernel: Store the kernel command line in a `StringView` The Raspberry Pi's mailbox interface does not guarantee that the returned command line is null-terminated. This commit removes that assumption from the current code, allowing the next commit to add support for reading it on the Pi. This also lets us eliminate a few manual `strlen()` calls :^)
2023-04-24 18:14:44 +00:00
READONLY_AFTER_INIT StringView kernel_cmdline;
Prekernel: Export some multiboot parameters in our own BootInfo struct This allows us to specify virtual addresses for things the kernel should access via virtual addresses later on. By doing this we can make the kernel independent from specific physical addresses.
2021-07-26 13:09:36 +00:00
READONLY_AFTER_INIT u32 multiboot_flags;
READONLY_AFTER_INIT multiboot_memory_map_t* multiboot_memory_map;
READONLY_AFTER_INIT size_t multiboot_memory_map_count;
READONLY_AFTER_INIT PhysicalAddress multiboot_framebuffer_addr;
READONLY_AFTER_INIT u32 multiboot_framebuffer_pitch;
READONLY_AFTER_INIT u32 multiboot_framebuffer_width;
READONLY_AFTER_INIT u32 multiboot_framebuffer_height;
READONLY_AFTER_INIT u8 multiboot_framebuffer_bpp;
READONLY_AFTER_INIT u8 multiboot_framebuffer_type;
Kernel/x86: Bake the Prekernel and the Kernel into one image The new baked image is a Prekernel and a Kernel baked together now, so essentially we no longer need to pass the Prekernel as -kernel and the actual kernel image as -initrd to QEMU, leaving the option to pass an actual initrd or initramfs module later on with multiboot.
2023-03-24 17:31:53 +00:00
READONLY_AFTER_INIT PhysicalAddress multiboot_module_physical_ptr;
READONLY_AFTER_INIT size_t multiboot_module_length;
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
}
Kernel: Instantiate a TextModeConsole early on if there's no framebuffer If the bootloader that loaded us is providing a framebuffer details from the Multiboot protocol then we can instantiate a framebuffer console. Otherwise, we should use a text mode console, assuming that the BIOS and the bootloader didn't try to modeset the screen resolution so we have is a VGA 80x25 text mode being displayed on screen. Since "boot_framebuffer_console" is no longer a good representative as a global variable name, it's changed to g_boot_console to match the fact that it can be assigned with a text mode console and not framebuffer console if needed.
2022-02-09 19:09:41 +00:00
Atomic<Graphics::Console*> g_boot_console;
Kernel: Set up an initial boot framebuffer console Instead of seeing a black screen until GraphicsManagement was fully initialized, this allows us to see the console output much earlier. So, if the bootloader provided us with a framebuffer, set up a console as early as possible.
2022-01-29 03:42:23 +00:00
Kernel/aarch64: Support reading the command line via the RPi Mailbox This reuses the existing `RPi::Mailbox` interface to read the command line via a VideoCore-specific mailbox message. This will have to be replaced if that interface starts being smarter, as this is needed very early, and nothing guarantees that a smarter Mailbox interface wouldn't need to allocate or log, which is a no-no during early boot. As the response string can be arbitrarily long, it's the caller's job to provide a long enough buffer for `Mailbox::query_kernel_command_line`. This commit chose 512 bytes, as it provides a large enough headroom over the 150-200 characters implicitly added by the VC firmware. The portable way would be to parse the `/chosen/bootargs` property of the device tree, but we currently lack the scaffolding for doing that. Support for this in QEMU relies on a patch that has not yet been accepted upstream, but is available via our `Toolchain/BuildQEMU.sh` script. It should, however, work on bare metal. Tested-By: Timon Kruiper <timonkruiper@gmail.com>
2023-04-24 18:35:29 +00:00
#if ARCH(AARCH64)
READONLY_AFTER_INIT static u8 s_command_line_buffer[512];
#endif
Kernel: Exclude individual functions from coverage instrumentation Sticking this to the function source has multiple benefits: - We instrument more code, by not excluding entire files. - NO_SANITIZE_COVERAGE can be used in Header files. - Keeping the info with the source code, means if a function or file is moved around, the NO_SANITIZE_COVERAGE moves with it.
2024-04-08 00:52:13 +00:00
extern "C" [[noreturn]] UNMAP_AFTER_INIT NO_SANITIZE_COVERAGE void init([[maybe_unused]] BootInfo const& boot_info)
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
{
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
Prekernel: Use physical addresses for some of the BootInfo parameters The kernel would just turn those virtual addresses into physical addresses later on, so let's just use physical addresses right from the start.
2021-07-19 16:24:15 +00:00
start_of_prekernel_image = PhysicalAddress { boot_info.start_of_prekernel_image };
end_of_prekernel_image = PhysicalAddress { boot_info.end_of_prekernel_image };
Kernel: Make the kernel independent from specific physical addresses Previously the kernel relied on a fixed offset between virtual and physical addresses based on the kernel's load address. This allows us to specify an independent offset.
2021-07-22 11:05:04 +00:00
physical_to_virtual_offset = boot_info.physical_to_virtual_offset;
Kernel: Support loading the kernel at almost arbitrary virtual addresses This enables further work on implementing KASLR by adding relocation support to the pre-kernel and updating the kernel to be less dependent on specific virtual memory layouts.
2021-07-26 13:10:51 +00:00
kernel_mapping_base = boot_info.kernel_mapping_base;
kernel_load_base = boot_info.kernel_load_base;
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
gdt64ptr = boot_info.gdt64ptr;
code64_sel = boot_info.code64_sel;
Prekernel: Use physical addresses for some of the BootInfo parameters The kernel would just turn those virtual addresses into physical addresses later on, so let's just use physical addresses right from the start.
2021-07-19 16:24:15 +00:00
boot_pml4t = PhysicalAddress { boot_info.boot_pml4t };
boot_pdpt = PhysicalAddress { boot_info.boot_pdpt };
boot_pd0 = PhysicalAddress { boot_info.boot_pd0 };
boot_pd_kernel = PhysicalAddress { boot_info.boot_pd_kernel };
Kernel: Move Memory/PageDirectory.{cpp,h} to arch-specific directory The handling of page tables is very architecture specific, so belongs in the Arch directory. Some parts were already architecture-specific, however this commit moves the rest of the PageDirectory class into the Arch directory. While we're here the aarch64/PageDirectory.{h,cpp} files are updated to be aarch64 specific, by renaming some members and removing x86_64 specific code.
2023-01-19 21:36:48 +00:00
boot_pd_kernel_pt1023 = (Memory::PageTableEntry*)boot_info.boot_pd_kernel_pt1023;
Kernel: Store the kernel command line in a `StringView` The Raspberry Pi's mailbox interface does not guarantee that the returned command line is null-terminated. This commit removes that assumption from the current code, allowing the next commit to add support for reading it on the Pi. This also lets us eliminate a few manual `strlen()` calls :^)
2023-04-24 18:14:44 +00:00
char const* cmdline = (char const*)boot_info.kernel_cmdline;
kernel_cmdline = StringView { cmdline, strlen(cmdline) };
Prekernel: Export some multiboot parameters in our own BootInfo struct This allows us to specify virtual addresses for things the kernel should access via virtual addresses later on. By doing this we can make the kernel independent from specific physical addresses.
2021-07-26 13:09:36 +00:00
multiboot_flags = boot_info.multiboot_flags;
multiboot_memory_map = (multiboot_memory_map_t*)boot_info.multiboot_memory_map;
multiboot_memory_map_count = boot_info.multiboot_memory_map_count;
Kernel/x86: Bake the Prekernel and the Kernel into one image The new baked image is a Prekernel and a Kernel baked together now, so essentially we no longer need to pass the Prekernel as -kernel and the actual kernel image as -initrd to QEMU, leaving the option to pass an actual initrd or initramfs module later on with multiboot.
2023-03-24 17:31:53 +00:00
multiboot_module_physical_ptr = PhysicalAddress { boot_info.multiboot_module_physical_ptr };
multiboot_module_length = boot_info.multiboot_module_length;
Prekernel: Export some multiboot parameters in our own BootInfo struct This allows us to specify virtual addresses for things the kernel should access via virtual addresses later on. By doing this we can make the kernel independent from specific physical addresses.
2021-07-26 13:09:36 +00:00
multiboot_framebuffer_addr = PhysicalAddress { boot_info.multiboot_framebuffer_addr };
multiboot_framebuffer_pitch = boot_info.multiboot_framebuffer_pitch;
multiboot_framebuffer_width = boot_info.multiboot_framebuffer_width;
multiboot_framebuffer_height = boot_info.multiboot_framebuffer_height;
multiboot_framebuffer_bpp = boot_info.multiboot_framebuffer_bpp;
multiboot_framebuffer_type = boot_info.multiboot_framebuffer_type;
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#elif ARCH(AARCH64)
// FIXME: For the aarch64 platforms, we should get the information by parsing a device tree instead of using multiboot.
Kernel/aarch64: Account for reserved VideoCore range in the memory map Instead of having a single available memory range that encompasses the whole 0x00000000-0x3EFFFFFF range of physical memory, create a separate reserved entry for the RAM range used by the VideoCore. This fixes a crash that happens when we try to allocate physical pages in the GPU's reserved range. This will eventually be replaced with parsing the data from the device tree, but for now, this should solve some of the recurring CI failures.
2023-06-06 10:32:10 +00:00
auto [ram_base, ram_size] = RPi::Mailbox::the().query_lower_arm_memory_range();
auto [vcmem_base, vcmem_size] = RPi::Mailbox::the().query_videocore_memory_range();
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
multiboot_memory_map_t mmap[] = {
Kernel/aarch64: Account for reserved VideoCore range in the memory map Instead of having a single available memory range that encompasses the whole 0x00000000-0x3EFFFFFF range of physical memory, create a separate reserved entry for the RAM range used by the VideoCore. This fixes a crash that happens when we try to allocate physical pages in the GPU's reserved range. This will eventually be replaced with parsing the data from the device tree, but for now, this should solve some of the recurring CI failures.
2023-06-06 10:32:10 +00:00
{
sizeof(struct multiboot_mmap_entry) - sizeof(u32),
(u64)ram_base,
(u64)ram_size,
MULTIBOOT_MEMORY_AVAILABLE,
},
{
sizeof(struct multiboot_mmap_entry) - sizeof(u32),
(u64)vcmem_base,
(u64)vcmem_size,
MULTIBOOT_MEMORY_RESERVED,
},
// FIXME: VideoCore only reports the first 1GB of RAM, the rest only shows up in the device tree.
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
};
multiboot_memory_map = mmap;
Kernel/aarch64: Account for reserved VideoCore range in the memory map Instead of having a single available memory range that encompasses the whole 0x00000000-0x3EFFFFFF range of physical memory, create a separate reserved entry for the RAM range used by the VideoCore. This fixes a crash that happens when we try to allocate physical pages in the GPU's reserved range. This will eventually be replaced with parsing the data from the device tree, but for now, this should solve some of the recurring CI failures.
2023-06-06 10:32:10 +00:00
multiboot_memory_map_count = 2;
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
Kernel/x86: Bake the Prekernel and the Kernel into one image The new baked image is a Prekernel and a Kernel baked together now, so essentially we no longer need to pass the Prekernel as -kernel and the actual kernel image as -initrd to QEMU, leaving the option to pass an actual initrd or initramfs module later on with multiboot.
2023-03-24 17:31:53 +00:00
multiboot_module_length = 0;
Kernel/aarch64: Support reading the command line via the RPi Mailbox This reuses the existing `RPi::Mailbox` interface to read the command line via a VideoCore-specific mailbox message. This will have to be replaced if that interface starts being smarter, as this is needed very early, and nothing guarantees that a smarter Mailbox interface wouldn't need to allocate or log, which is a no-no during early boot. As the response string can be arbitrarily long, it's the caller's job to provide a long enough buffer for `Mailbox::query_kernel_command_line`. This commit chose 512 bytes, as it provides a large enough headroom over the 150-200 characters implicitly added by the VC firmware. The portable way would be to parse the `/chosen/bootargs` property of the device tree, but we currently lack the scaffolding for doing that. Support for this in QEMU relies on a patch that has not yet been accepted upstream, but is available via our `Toolchain/BuildQEMU.sh` script. It should, however, work on bare metal. Tested-By: Timon Kruiper <timonkruiper@gmail.com>
2023-04-24 18:35:29 +00:00
// FIXME: Read the /chosen/bootargs property.
kernel_cmdline = RPi::Mailbox::the().query_kernel_command_line(s_command_line_buffer);
Kernel/riscv64: Implement `debug_output` and change cmdline to use it Just implementing `debug_output` (and adding "serial_debug" to the cmdline) makes the kernel print its first assertion failure!
2023-11-23 00:36:12 +00:00
#elif ARCH(RISCV64)
Kernel/riscv64: Get the kernel command line from the device tree This also hides the fdt dump by default now, it can be activated by adding `dump_fdt` to the kernel command line
2024-02-11 14:32:27 +00:00
auto maybe_command_line = get_command_line_from_fdt();
if (maybe_command_line.is_error())
kernel_cmdline = "serial_debug"sv;
else
kernel_cmdline = maybe_command_line.value();
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 12:47:32 +00:00
Kernel: Initialize serial debug after setting kernel command-line
2021-07-20 01:03:49 +00:00
setup_serial_debug();
Kernel: Copy command line to a safe place This avoids kmalloc overwriting it because it may be within the kmalloc or eternal pool.
2020-08-25 01:35:27 +00:00
// We need to copy the command line before kmalloc is initialized,
// as it may overwrite parts of multiboot!
Kernel: Copy the kernel command line to a good location at boot When building the kernel with -O2, we somehow ended up with the kernel command line outside of the lower 8MB of physical memory. Since we don't map that area in our initial page table setup, we would triple fault when trying to parse the command line. This patch sidesteps the issue by copying the (first 4KB of) the kernel command line to a buffer in a known safe location at boot.
2021-02-23 18:25:58 +00:00
CommandLine::early_initialize(kernel_cmdline);
Kernel: Change the BSP Processor instance to not have a constructor This solves a problem where any non-trivial member in the global BSP Processor instance would get re-initialized (improperly), losing data that was already initialized earlier.
2022-03-27 11:48:51 +00:00
new (&bsp_processor()) Processor();
bsp_processor().early_initialize(0);
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
Kernel: Verify we are running on hart 0 This is already an implicit assumption when we initialize our CPU id.
2024-04-23 17:22:21 +00:00
#if ARCH(RISCV64)
// We implicitly assume the boot hart is hart 0 above and below
VERIFY(boot_info.mhartid == 0);
#endif
Kernel: Invoke heap constructors separately early on By having a separate list of constructors for the kernel heap code, we can properly use constructors without re-running them after the heap was already initialized. This solves some problems where values were wiped out because they were overwritten by running their constructors later in the initialization process.
2020-08-10 15:44:35 +00:00
// Invoke the constructors needed for the kernel heap
Kernel: Fix the variable declaration for some linker script symbols Despite what the declaration would have us believe these are not "u8*". If they were we wouldn't have to use the & operator to get the address of them and then cast them to "u8*"/FlatPtr afterwards.
2021-07-22 20:11:17 +00:00
for (ctor_func_t* ctor = start_heap_ctors; ctor < end_heap_ctors; ctor++)
Kernel: Invoke heap constructors separately early on By having a separate list of constructors for the kernel heap code, we can properly use constructors without re-running them after the heap was already initialized. This solves some problems where values were wiped out because they were overwritten by running their constructors later in the initialization process.
2020-08-10 15:44:35 +00:00
(*ctor)();
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
kmalloc_init();
Kernel: Make kernel symbols available much earlier in the boot process This adds a new section .ksyms at the end of the linker map, reserves 5MiB for it (which are after end_of_kernel_image so they get re-used once MemoryManager is initialized) and then embeds the symbol map into the kernel binary with objcopy. This also shrinks the .ksyms section to the real size of the symbol file (around 900KiB at the moment). By doing this we can make the symbol map available much earlier in the boot process, i.e. even before VFS is available.
2021-07-14 19:04:18 +00:00
load_kernel_symbol_table();
Kernel: Change the BSP Processor instance to not have a constructor This solves a problem where any non-trivial member in the global BSP Processor instance would get re-initialized (improperly), losing data that was already initialized earlier.
2022-03-27 11:48:51 +00:00
bsp_processor().initialize(0);
Kernel: Perform DeviceManagement initialization after MM is initialized There's no need to perform it this early, and until the MemoryManager is initialized we have very limited kmalloc capacity, so let's try and keep anything that's not required to be there out of there.
2022-01-25 18:45:38 +00:00
CommandLine::initialize();
Memory::MemoryManager::initialize(0);
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(AARCH64)
auto firmware_version = RPi::Mailbox::the().query_firmware_version();
dmesgln("RPi: Firmware version: {}", firmware_version);
RPi::Framebuffer::initialize();
#endif
Kernel: Instantiate a TextModeConsole early on if there's no framebuffer If the bootloader that loaded us is providing a framebuffer details from the Multiboot protocol then we can instantiate a framebuffer console. Otherwise, we should use a text mode console, assuming that the BIOS and the bootloader didn't try to modeset the screen resolution so we have is a VGA 80x25 text mode being displayed on screen. Since "boot_framebuffer_console" is no longer a good representative as a global variable name, it's changed to g_boot_console to match the fact that it can be assigned with a text mode console and not framebuffer console if needed.
2022-02-09 19:09:41 +00:00
// NOTE: If the bootloader provided a framebuffer, then set up an initial console.
// If the bootloader didn't provide a framebuffer, then set up an initial text console.
// We do so we can see the output on the screen as soon as possible.
Kernel: Allow to disable early boot console This aid debugging on bare metal when we suspect that the boot console does something wrong that interferes with other kernel components.
2022-03-15 20:04:12 +00:00
if (!kernel_command_line().is_early_boot_console_disabled()) {
Kernel: Don't use framebuffer if flag is not set According to multiboot spec if flag for framebuffer isn't set then corresponding fields are invalid. In reality they're set to 0 but let's be defensive.
2023-07-20 06:35:38 +00:00
if ((multiboot_flags & MULTIBOOT_INFO_FRAMEBUFFER_INFO) && !multiboot_framebuffer_addr.is_null() && multiboot_framebuffer_type == MULTIBOOT_FRAMEBUFFER_TYPE_RGB) {
Kernel: Make self-contained locking smart pointers their own classes Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
2022-08-19 18:53:40 +00:00
g_boot_console = &try_make_lock_ref_counted<Graphics::BootFramebufferConsole>(multiboot_framebuffer_addr, multiboot_framebuffer_width, multiboot_framebuffer_height, multiboot_framebuffer_pitch).value().leak_ref();
Kernel: Allow to disable early boot console This aid debugging on bare metal when we suspect that the boot console does something wrong that interferes with other kernel components.
2022-03-15 20:04:12 +00:00
} else {
Kernel: Only try to use VGA text mode on x86_64
2023-11-30 17:35:40 +00:00
#if ARCH(X86_64)
Kernel/Graphics: Rename TextModeConsole => VGATextModeConsole This change represents well the fact that the text mode console is based on VGA text mode.
2022-07-13 17:11:28 +00:00
g_boot_console = &Graphics::VGATextModeConsole::initialize().leak_ref();
Kernel: Only try to use VGA text mode on x86_64
2023-11-30 17:35:40 +00:00
#else
dbgln("No early framebuffer console available");
#endif
Kernel: Allow to disable early boot console This aid debugging on bare metal when we suspect that the boot console does something wrong that interferes with other kernel components.
2022-03-15 20:04:12 +00:00
}
Kernel: Set up an initial boot framebuffer console Instead of seeing a black screen until GraphicsManagement was fully initialized, this allows us to see the console output much earlier. So, if the bootloader provided us with a framebuffer, set up a console as early as possible.
2022-01-29 03:42:23 +00:00
}
dmesgln("Starting SerenityOS...");
Kernel: Only unmap prekernel on x86_64 Other arches don't use the prekernel, so don't try to unmap it on non-x86 platforms. For some reason, this didn't cause aarch64 to crash, but on riscv64 this would cause a panic.
2023-11-30 17:09:26 +00:00
#if ARCH(X86_64)
Kernel: Unmap Prekernel pages after they are no longer needed The Prekernel's memory is only accessed until MemoryManager has been initialized. Keeping them around afterwards is both unnecessary and bad, as it prevents the userland from using the 0x100000-0x155000 virtual address range. Co-authored-by: Idan Horowitz <idan.horowitz@gmail.com>
2021-12-19 00:15:12 +00:00
MM.unmap_prekernel();
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
// Ensure that the safemem sections are not empty. This could happen if the linker accidentally discards the sections.
Kernel: Fix deprecated array comparison The Clang error message reads like this (`-Wdeprecated-array-compare`): > error: comparison between two arrays is deprecated; to compare > array addresses, use unary '+' to decay operands to pointers.
2021-07-22 21:02:33 +00:00
VERIFY(+start_of_safemem_text != +end_of_safemem_text);
VERIFY(+start_of_safemem_atomic_text != +end_of_safemem_atomic_text);
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
Kernel: Move global constructor invocation a bit earlier
2020-04-08 13:18:12 +00:00
// Invoke all static global constructors in the kernel.
// Note that we want to do this as early as possible.
Kernel: Fix the variable declaration for some linker script symbols Despite what the declaration would have us believe these are not "u8*". If they were we wouldn't have to use the & operator to get the address of them and then cast them to "u8*"/FlatPtr afterwards.
2021-07-22 20:11:17 +00:00
for (ctor_func_t* ctor = start_ctors; ctor < end_ctors; ctor++)
Kernel: Move global constructor invocation a bit earlier
2020-04-08 13:18:12 +00:00
(*ctor)();
Kernel/riscv64: Take the memory map from the FDT and dump it For this the BootInfo struct was made architecture specific
2024-01-26 13:37:36 +00:00
#if ARCH(RISCV64)
Kernel/riscv64: Unflatten the DeviceTree
2024-02-14 14:01:21 +00:00
MUST(unflatten_fdt());
Kernel/riscv64: Get the kernel command line from the device tree This also hides the fdt dump by default now, it can be activated by adding `dump_fdt` to the kernel command line
2024-02-11 14:32:27 +00:00
if (kernel_command_line().contains("dump_fdt"sv))
dump_fdt();
Kernel/riscv64: Implement microseconds_delay This simple delay loop uses the time CSR to wait for the given amount of time. The tick frequency of the CSR is read from the /cpus/timebase-frequency devicetree property.
2024-02-27 00:22:37 +00:00
init_delay_loop();
Kernel/riscv64: Take the memory map from the FDT and dump it For this the BootInfo struct was made architecture specific
2024-01-26 13:37:36 +00:00
#endif
Kernel: Support the RISC-V PLIC By supporting the RISC-V PLIC (Platform-Level Interrupt Controller) we can now handle device (external) interrupts.
2024-04-23 17:28:11 +00:00
InterruptManagement::initialize();
ACPI::initialize();
Kernel: Initialize TimeManagement before using KernelRNG We should initialize the timers before KernelRNG as the RNG may want to utilize system time as an entropy source. Fixes #8710
2021-07-16 20:57:44 +00:00
// Initialize TimeManagement before using randomness!
TimeManagement::initialize(0);
Kernel: Fix SipHash aarch64 boot regression Moving the DeviceManagement initialization, which is only needed by userland in the first place, to after interrupt and time management initialization (like other things that require randomness) allows the SipHash initialization to access good randomness without problems. Note: There currently is another, unrelated boot problem on aarch64, which is not caused by SipHash as far as we know. This commit therefore only fixes the SipHash regression.
2023-10-14 12:56:57 +00:00
DeviceManagement::initialize();
SysFSComponentRegistry::initialize();
DeviceManagement::the().attach_null_device(*NullDevice::must_initialize());
DeviceManagement::the().attach_console_device(*ConsoleDevice::must_create());
DeviceManagement::the().attach_device_control_device(*DeviceControlDevice::must_create());
LibC: Use uintptr_t for __stack_chk_guard We used size_t, which is a type that is guarenteed to be large enough to hold an array index, but uintptr_t is designed to be used to hold pointer values, which is the case of stack guards.
2022-11-26 18:17:32 +00:00
__stack_chk_guard = get_fast_random<uintptr_t>();
Kernel: Ensure that HPET is initialized before using random the first time
2021-01-23 10:42:19 +00:00
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
Process::initialize();
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
Scheduler::initialize();
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
// FIXME: Add an abstraction for the smp related functions, instead of using ifdefs in this file.
Kernel: Setup APIC AP cores boot environment before init_stage2 Since this range is mapped in already in the kernel page directory, we can initialize it before jumping into the first kernel process which lets us avoid mapping in the range into init_stage2's address space. This brings us half-way to removing the shared bottom 2 MiB mapping in every process, leaving only the Prekernel.
2021-12-19 16:04:55 +00:00
if (APIC::initialized() && APIC::the().enabled_processor_count() > 1) {
// We must set up the AP boot environment before switching to a kernel process,
Everywhere: Fix a variety of typos Spelling fixes found by `codespell`.
2022-09-09 21:53:53 +00:00
// as pages below address USER_RANGE_BASE are only accessible through the kernel
Kernel: Setup APIC AP cores boot environment before init_stage2 Since this range is mapped in already in the kernel page directory, we can initialize it before jumping into the first kernel process which lets us avoid mapping in the range into init_stage2's address space. This brings us half-way to removing the shared bottom 2 MiB mapping in every process, leaving only the Prekernel.
2021-12-19 16:04:55 +00:00
// page directory.
APIC::the().setup_ap_boot_environment();
}
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Setup APIC AP cores boot environment before init_stage2 Since this range is mapped in already in the kernel page directory, we can initialize it before jumping into the first kernel process which lets us avoid mapping in the range into init_stage2's address space. This brings us half-way to removing the shared bottom 2 MiB mapping in every process, leaving only the Prekernel.
2021-12-19 16:04:55 +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
MUST(Process::create_kernel_process("init_stage2"sv, init_stage2, nullptr, THREAD_AFFINITY_DEFAULT, Process::RegisterProcess::No));
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
Kernel: Implement software context switching and Processor structure Moving certain globals into a new Processor structure for each CPU allows us to eventually run an instance of the scheduler on each CPU.
2020-06-27 19:42:28 +00:00
Scheduler::start();
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_NOT_REACHED();
Kernel: Move more things from init() to init_stage2() The purpose of init() is to get multi-tasking up and running. We don't want to do anything in init() that doesn't advance that goal. This patch moves some things from init() to init_stage2(), and adds a comment block explaining the split.
2020-04-08 12:07:12 +00:00
}
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
Kernel: Detect APs and boot them into protected mode This isn't fully working, the APs pretend like they're fully initialized and are just halted permanently for now.
2020-06-04 15:10:16 +00:00
//
// This is where C++ execution begins for APs, after boot.S transfers control here.
//
// The purpose of init_ap() is to initialize APs for multi-tasking.
//
Kernel: Support starting up secondary processors on x86_64
2021-06-30 12:24:37 +00:00
extern "C" [[noreturn]] UNMAP_AFTER_INIT void init_ap(FlatPtr cpu, Processor* processor_info)
Kernel: Detect APs and boot them into protected mode This isn't fully working, the APs pretend like they're fully initialized and are just halted permanently for now.
2020-06-04 15:10:16 +00:00
{
Kernel: Split initialization of Processor structure We need to very early on initialize the Processor structure so that we can use RecursiveSpinLock early on.
2020-07-02 14:34:00 +00:00
processor_info->early_initialize(cpu);
Kernel: Implement software context switching and Processor structure Moving certain globals into a new Processor structure for each CPU allows us to eventually run an instance of the scheduler on each CPU.
2020-06-27 19:42:28 +00:00
processor_info->initialize(cpu);
Kernel: Move Kernel/Memory/ code into Kernel::Memory namespace
2021-08-06 11:49:36 +00:00
Memory::MemoryManager::initialize(cpu);
Kernel: Implement software context switching and Processor structure Moving certain globals into a new Processor structure for each CPU allows us to eventually run an instance of the scheduler on each CPU.
2020-06-27 19:42:28 +00:00
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
Scheduler::set_idle_thread(APIC::the().get_idle_thread(cpu));
Kernel: Make Random work on CPUs without rdrand - If rdseed is not available, fallback to rdrand. - If rdrand is not available, block for entropy, or use insecure prng depending on if user wants fast or good random.
2020-06-27 17:10:01 +00:00
Kernel: Boot all APS all the way into their own idle loop
2020-06-29 04:36:12 +00:00
Scheduler::start();
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_NOT_REACHED();
Kernel: Detect APs and boot them into protected mode This isn't fully working, the APs pretend like they're fully initialized and are just halted permanently for now.
2020-06-04 15:10:16 +00:00
}
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
//
// This method is called once a CPU enters the scheduler and its idle thread
// At this point the initial boot stack can be freed
//
Kernel: Slap UNMAP_AFTER_INIT on a whole bunch of functions There's no real system here, I just added it to various functions that I don't believe we ever want to call after initialization has finished. With these changes, we're able to unmap 60 KiB of kernel text after init. :^)
2021-02-19 17:41:50 +00:00
extern "C" UNMAP_AFTER_INIT void init_finished(u32 cpu)
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
{
if (cpu == 0) {
// TODO: we can reuse the boot stack, maybe for kmalloc()?
} else {
APIC::the().init_finished(cpu);
Kernel: Set up and calibrate APIC timer, and enable timer on all CPUs This enables the APIC timer on all CPUs, which means Scheduler::timer_tick is now called on all CPUs independently. We still don't do anything on the APs as it instantly crashes due to a number of other problems.
2020-10-25 15:13:47 +00:00
TimeManagement::initialize(cpu);
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
}
}
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 03:51:34 +00:00
void init_stage2(void*)
Kernel: Move more things from init() to init_stage2() The purpose of init() is to get multi-tasking up and running. We don't want to do anything in init() that doesn't advance that goal. This patch moves some things from init() to init_stage2(), and adds a comment block explaining the split.
2020-04-08 12:07:12 +00:00
{
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
// This is a little bit of a hack. We can't register our process at the time we're
// creating it, but we need to be registered otherwise finalization won't be happy.
// The colonel process gets away without having to do this because it never exits.
Kernel: Make Process::current() return a Process& instead of Process* This has several benefits: 1) We no longer just blindly derefence a null pointer in various places 2) We will get nicer runtime error messages if the current process does turn out to be null in the call location 3) GCC no longer complains about possible nullptr dereferences when compiling without KUBSAN
2021-08-19 19:45:07 +00:00
Process::register_new(Process::current());
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
WorkQueue::initialize();
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
Kernel: Allow switching to IOAPIC mode even without enabling SMP This small change allows to use the IOAPIC by default without to enable SMP mode, which emulates Uni-Processor setup with IOAPIC instead of using the PIC. This opens the opportunity to utilize other types of interrupts like MSI and MSI-X interrupts.
2021-11-28 15:38:10 +00:00
if (kernel_command_line().is_smp_enabled() && APIC::initialized() && APIC::the().enabled_processor_count() > 1) {
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
// We can't start the APs until we have a scheduler up and running.
// We need to be able to process ICI messages, otherwise another
// core may send too many and end up deadlocking once the pool is
// exhausted
APIC::the().boot_aps();
}
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
// Initialize the PCI Bus as early as possible, for early boot (PCI based) serial logging
Kernel/PCI: Unify disable checks under PCI::Access::is_disabled method To declare that we don't have a PCI bus in the system we do two things: 1. Probe IO ports before enabling access - In case we are using the QEMU ISA-PC machine type, IO probing results in floating bus condition (returning 0xFF values), thus, we know we don't have PCI bus on the system. 2. Allow the user to specify to not use the PCI bus at all in the kernel commandline.
2022-01-21 15:06:39 +00:00
PCI::initialize();
if (!PCI::Access::is_disabled()) {
Kernel: Change PCI access commandline option to also represent no access This change allow the user to request the kernel to not use any PCI resources/devices at all. Also, don't try to initialize devices that rely on PCI if disabled.
2022-01-21 14:09:05 +00:00
PCISerialDevice::detect();
}
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
VirtualFileSystem::initialize();
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
Kernel: Changed serial debug functions and variables for readability Change the name of set_serial_debug(bool on_or_off) to set_serial_debug_enabled(bool desired_state). This is to make the names more expressive and less unclear as to what the function does, as it only sets the enabled state. Likewise, change the name of get_serial_debug() to is_serial_debug_enabled() in order to make clear from the name that this is simply the state of s_serial_debug_enabled. Change the name of serial_debug to s_serial_debug_enabled since this is a static bool describing this state. Finally, change the signature of set_serial_debug_enabled to return a bool, as this is more logical and understandable.
2022-08-24 21:49:23 +00:00
if (!is_serial_debug_enabled())
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
(void)SerialDevice::must_create(0).leak_ref();
(void)SerialDevice::must_create(1).leak_ref();
(void)SerialDevice::must_create(2).leak_ref();
(void)SerialDevice::must_create(3).leak_ref();
Kernel: Add character device driver for the RPi "mini UART" (UART1) While the PL011-based UART0 is currently reserved for the kernel console, UART1 is free to be exposed to the userspace as `/dev/ttyS0`. This will be used as the stdout of `run-tests-and-shutdown.sh` when testing the AArch64 kernel.
2023-05-15 05:51:46 +00:00
#elif ARCH(AARCH64)
(void)MUST(RPi::MiniUART::create()).leak_ref();
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
Kernel+Userland: Replace the beep syscall with the new /dev/beep device There's no need to have separate syscall for this kind of functionality, as we can just have a device node in /dev, called "beep", that allows writing tone generation packets to emulate the same behavior. In addition to that, we remove LibC sysbeep function, as this function was never being used by any C program nor it was standardized in any way. Instead, we move the userspace implementation to LibCore.
2023-08-25 16:48:46 +00:00
(void)PCSpeakerDevice::must_create().leak_ref();
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#if ARCH(X86_64)
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
VMWareBackdoor::the(); // don't wait until first mouse packet
Kernel: Merge x86_64 and aarch64 init.cpp files
2023-04-01 00:10:19 +00:00
#endif
Kernel: Propagate HIDManagement initialisation error to init Initialisation errors for HIDManagement are now returned to the init. In the init we assert by MUST if we get an error.
2022-02-23 21:14:09 +00:00
MUST(HIDManagement::initialize());
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
Kernel: Add VirtIOGPU graphics device
2021-06-12 13:07:44 +00:00
GraphicsManagement::the().initialize();
ConsoleManagement::the().initialize();
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
SyncTask::spawn();
FinalizerTask::spawn();
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
Kernel: Add 'boot_prof' option to enable full system profiling on boot The full system profiling functionality is useful for profiling the boot performance of the system. Add a new kernel boot option to start the system with profiling enabled. This lets you disable and view a profile once the system is booted. You can use it by running: ``` $ run.sh qcmd boot_prof ```
2021-03-03 09:00:41 +00:00
auto boot_profiling = kernel_command_line().is_boot_profiling_enabled();
Kernel: Introduce a new graphics subsystem This new subsystem is replacing the old code that was used to create device nodes of framebuffer devices in /dev. This subsystem includes for now 3 roles: 1. GraphicsManagement singleton object that is used in the boot process to enumerate and initialize display devices. 2. GraphicsDevice(s) that are used to control the display adapter. 3. FramebufferDevice(s) that are used to control the device node in /dev. For now, we support the Bochs display adapter and any other generic VGA compatible adapter that was configured by the boot loader to a known and fixed resolution. Two improvements in the Bochs display adapter code are that we can support native bochs-display device (this device doesn't expose any VGA capabilities) and also that we use the MMIO region, to configure the device, instead of setting IO ports for such tasks.
2021-03-05 12:23:08 +00:00
Kernel/PCI: Unify disable checks under PCI::Access::is_disabled method To declare that we don't have a PCI bus in the system we do two things: 1. Probe IO ports before enabling access - In case we are using the QEMU ISA-PC machine type, IO probing results in floating bus condition (returning 0xFF values), thus, we know we don't have PCI bus on the system. 2. Allow the user to specify to not use the PCI bus at all in the kernel commandline.
2022-01-21 15:06:39 +00:00
if (!PCI::Access::is_disabled()) {
Kernel: Change PCI access commandline option to also represent no access This change allow the user to request the kernel to not use any PCI resources/devices at all. Also, don't try to initialize devices that rely on PCI if disabled.
2022-01-21 14:09:05 +00:00
USB::USBManagement::initialize();
}
Kernel: Rename FirmwareSysFSDirectory => SysFSFirmwareDirectory This matches how we give the pattern names for other classses for SysFS components.
2023-06-09 18:17:02 +00:00
SysFSFirmwareDirectory::initialize();
Kernel/USB: Start fleshing out a basic UHCI controller driver :^) Let's see if we can talk to some USB devices. We will now detect a UHCI controller if present on the PCI bus.
2020-09-04 07:59:38 +00:00
Kernel/PCI: Unify disable checks under PCI::Access::is_disabled method To declare that we don't have a PCI bus in the system we do two things: 1. Probe IO ports before enabling access - In case we are using the QEMU ISA-PC machine type, IO probing results in floating bus condition (returning 0xFF values), thus, we know we don't have PCI bus on the system. 2. Allow the user to specify to not use the PCI bus at all in the kernel commandline.
2022-01-21 15:06:39 +00:00
if (!PCI::Access::is_disabled()) {
Kernel/VirtIO: Introduce the concept of transport options The VirtIO specification defines many types of devices with different purposes, and it also defines 3 possible transport mediums where devices could be connected to the host machine. We only care about the PCIe transport, but this commit puts the actual foundations for supporting the lean MMIO transport too in the future. To ensure things are kept abstracted but still functional, the VirtIO transport code is responsible for what is deemed as related to an actual transport type - allocation of interrupt handlers and tinkering with low level transport-related registers, etc.
2023-06-10 11:46:47 +00:00
VirtIO::detect_pci_instances();
Kernel: Change PCI access commandline option to also represent no access This change allow the user to request the kernel to not use any PCI resources/devices at all. Also, don't try to initialize devices that rely on PCI if disabled.
2022-01-21 14:09:05 +00:00
}
Kernel: Add base support for VirtIO devices Based on pull #3236 by tomuta, this adds helper methods for generic device initialization, and partily-broken virtqueue helper methods Co-authored-by: Tom <tomut@yahoo.com> Co-authored-by: Sahan <sahan.h.fernando@gmail.com>
2021-01-02 17:53:05 +00:00
Kernel: Introduce the NetworkingManagement singleton Instead of initializing network adapters in init.cpp, let's move that logic into a separate class to handle this. Also, it seems like a good idea to shift responsiblity on enumeration of network adapters after the boot process, so this singleton will take care of finding the appropriate network adapter when asked to with an IPv4 address or interface name. With this change being merged, we simplify the creation logic of NetworkAdapter derived classes, so we enumerate the PCI bus only once, searching for driver candidates when doing so, and we let each driver to test if it is resposible for the specified PCI device.
2021-06-04 04:43:16 +00:00
NetworkingManagement::the().initialize();
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
Kernel: Add option to build with coverage instrumentation and KCOV GCC and Clang allow us to inject a call to a function named __sanitizer_cov_trace_pc on every edge. This function has to be defined by us. By noting down the caller in that function we can trace the code we have encountered during execution. Such information is used by coverage guided fuzzers like AFL and LibFuzzer to determine if a new input resulted in a new code path. This makes fuzzing much more effective. Additionally this adds a basic KCOV implementation. KCOV is an API that allows user space to request the kernel to start collecting coverage information for a given user space thread. Furthermore KCOV then exposes the collected program counters to user space via a BlockDevice which can be mmaped from user space. This work is required to add effective support for fuzzing SerenityOS to the Syzkaller syscall fuzzer. :^) :^)
2021-06-06 23:15:07 +00:00
#ifdef ENABLE_KERNEL_COVERAGE_COLLECTION
(void)KCOVDevice::must_create().leak_ref();
#endif
Kernel: Don't use naked new statements in init process Instead, try to create the device objects in separate static methods, and if we fail for some odd reason to allocate memory for such devices, just panic with that reason.
2021-06-18 08:37:26 +00:00
(void)MemoryDevice::must_create().leak_ref();
(void)ZeroDevice::must_create().leak_ref();
(void)FullDevice::must_create().leak_ref();
Kernel: Add FUSE support This adds both the fuse device (used for communication between the kernel and the filesystem) and filesystem implementation itself.
2024-02-04 13:26:38 +00:00
(void)FUSEDevice::must_create().leak_ref();
Kernel: Don't use naked new statements in init process Instead, try to create the device objects in separate static methods, and if we fail for some odd reason to allocate memory for such devices, just panic with that reason.
2021-06-18 08:37:26 +00:00
(void)RandomDevice::must_create().leak_ref();
Kernel: Create SelfTTYDevice class to help replace /dev/tty symlink This will replace the /dev/tty symlink created by SystemServer, so instead of a symlink, a character device will be created. When doing read(2), write(2) and ioctl(2) on this device, it will "redirect" these operations to the attached TTY of the current process.
2022-02-15 19:24:31 +00:00
(void)SelfTTYDevice::must_create().leak_ref();
Kernel: Switch singletons to use new Singleton class MemoryManager cannot use the Singleton class because MemoryManager::initialize is called before the global constructors are run. That caused the Singleton to be re-initialized, causing it to create another MemoryManager instance. Fixes #3226
2020-08-25 01:35:19 +00:00
PTYMultiplexer::initialize();
Kernel/Devices: Use try_create_device helper for SB16
2021-09-16 19:24:55 +00:00
Kernel/Audio: Introduce a new design architecture for the subsystem We have 3 new components: 1. The AudioManagement singleton. This class like in other subsystems, is responsible to find hardware audio controllers and keep a reference to them. 2. AudioController class - this class is the parent class for hardware controllers like the Sound Blaster 16 or Intel 82801AA (AC97). For now, this class has simple interface for getting and controlling sample rate of audio channels, as well a write interface for specific audio channel but not reading from it. One AudioController object might have multiple AudioChannel "child" objects to hold with reference counting. 3. AudioChannel class - this is based on the CharacterDevice class, and represents hardware PCM audio channel. It facilitates an ioctl interface which should be consistent across all supported hardware currently. It has a weak reference to a parent AudioController, and when trying to write to a channel, it redirects the data to the parent AudioController. Each audio channel device should be added into a new directory under the /dev filesystem called "audio".
2022-02-11 19:47:45 +00:00
AudioManagement::the().initialize();
Kernel: Implement MBR partition loader (#168) This implements a basic MBR partition loader, which removes the reliance on a hard-coded filesystem offset in the stage2 init.
2019-06-02 12:57:44 +00:00
Kernel: Load drivers before looking for the boot drive
2023-09-30 19:14:40 +00:00
// Initialize all USB Drivers
for (auto* init_function = driver_init_table_start; init_function != driver_init_table_end; init_function++)
(*init_function)();
Kernel/Storage: Remove ATA IDE support Nobody uses this functionality. I used this code on my old 2007 ICH7 test machine about a year ago, but bare metal is a small aspect of the project, so it's safe to assume that nobody really tests this piece of code. Therefore, let's drop this for good and focus on more modern hardware.
2024-04-29 17:57:16 +00:00
StorageManagement::the().initialize(kernel_command_line().is_nvme_polling_enabled());
Kernel: Try 5 times to find the root boot drive This gives us enough time to discover more devices, such as USB drives
2023-09-30 19:18:44 +00:00
for (int i = 0; i < 5; ++i) {
if (StorageManagement::the().determine_boot_device(kernel_command_line().root_device()))
break;
dbgln_if(STORAGE_DEVICE_DEBUG, "Boot device {} not found, sleeping 2 seconds", kernel_command_line().root_device());
(void)Thread::current()->sleep(Duration::from_seconds(2));
}
Kernel: Tidy up VirtualFileSystem::mount_root() a little bit - Return KResult instead of bool - Use TRY()
2021-09-05 12:46:44 +00:00
if (VirtualFileSystem::the().mount_root(StorageManagement::the().root_filesystem()).is_error()) {
Kernel: Rename VFS => VirtualFileSystem
2021-07-10 22:25:24 +00:00
PANIC("VirtualFileSystem::mount_root failed");
Kernel: Just hang if VFS::mount_root() fails
2019-11-17 17:58:25 +00:00
}
VFS mounts an ext2fs root! :^)
2018-10-17 09:44:06 +00:00
Kernel: Make the "in early boot" flag read-only-after-init
2021-06-18 14:40:56 +00:00
// Switch out of early boot mode.
Kernel: Use the AK SetOnce container class in various cases We have many places in the kernel code that we have boolean flags that are only set once, and never reset again but are checked multiple times before and after the time they're being set, which matches the purpose of the SetOnce class.
2024-04-22 10:30:09 +00:00
g_not_in_early_boot.set();
Kernel: Make the "in early boot" flag read-only-after-init
2021-06-18 14:40:56 +00:00
Kernel: Add mechanism to make some memory read-only after init finishes You can now use the READONLY_AFTER_INIT macro when declaring a variable and we will put it in a special ".ro_after_init" section in the kernel. Data in that section remains writable during the boot and init process, and is then marked read-only just before launching the SystemServer. This is based on an idea from the Linux kernel. :^)
2021-02-14 16:35:07 +00:00
// NOTE: Everything marked READONLY_AFTER_INIT becomes non-writable after this point.
MM.protect_readonly_after_init_memory();
Kernel: Use ksyms in-place instead of duplicating them into eternal heap We can leave the .ksyms section mapped-but-read-only and then have the symbols index simply point into it. Note that we manually insert null-terminators into the symbols section while parsing it. This gets rid of ~950 KiB of kmalloc_eternal() at startup. :^)
2021-12-17 08:52:06 +00:00
// NOTE: Everything in the .ksyms section becomes read-only after this point.
MM.protect_ksyms_after_init();
Kernel: Add .unmap_after_init section for code we don't need after init You can now declare functions with UNMAP_AFTER_INIT and they'll get segregated into a separate kernel section that gets completely unmapped at the end of initialization. This can be used for anything we don't need to call once we've booted into userspace. There are two nice things about this mechanism: - It allows us to free up entire pages of memory for other use. (Note that this patch does not actually make use of the freed pages yet, but in the future we totally could!) - It allows us to get rid of obviously dangerous gadgets like write-to-CR0 and write-to-CR4 which are very useful for an attacker trying to disable SMAP/SMEP/etc. I've also made sure to include a helpful panic message in case you hit a kernel crash because of this protection. :^)
2021-02-19 17:21:54 +00:00
Kernel: Make MemoryManager::protect_ksyms_after_init UNMAP_AFTER_INIT The function to protect ksyms after initialization, is only used during boot of the system, so it can be UNMAP_AFTER_INIT as well. This requires we switch the order of the init sequence, so we now call `MM.protect_ksyms_after_init()` before `MM.unmap_text_after_init()`.
2021-12-24 13:21:08 +00:00
// NOTE: Everything marked UNMAP_AFTER_INIT becomes inaccessible after this point.
MM.unmap_text_after_init();
Kernel: Move Kernel CommandLine parsing to strongly typed API. Previously all of the CommandLine parsing was spread out around the Kernel. Instead move it all into the Kernel CommandLine class, and expose a strongly typed API for querying the state of options.
2021-03-03 08:51:55 +00:00
auto userspace_init = kernel_command_line().userspace_init();
auto init_args = kernel_command_line().userspace_init_args();
Kernel: Tidy up Process::try_create_user_process() This function is currently only ever used to create the init process (SystemServer). It had a few idiosyncratic things about it that this patch cleans up: - Errors were returned in an int& out-param. - It had a path for non-0 process PIDs which was never taken.
2021-09-04 20:36:06 +00:00
Kernel: Print to the log what is the first user process & its arguments
2023-10-28 09:12:27 +00:00
dmesgln("Running first user process: {}", userspace_init);
dmesgln("Init (first) process args: {}", init_args);
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
auto init_or_error = Process::create_user_process(userspace_init, UserID(0), GroupID(0), move(init_args), {}, tty0);
Kernel: Tidy up Process::try_create_user_process() This function is currently only ever used to create the init process (SystemServer). It had a few idiosyncratic things about it that this patch cleans up: - Errors were returned in an int& out-param. - It had a path for non-0 process PIDs which was never taken.
2021-09-04 20:36:06 +00:00
if (init_or_error.is_error())
PANIC("init_stage2: Error spawning init process: {}", init_or_error.error());
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
auto [init_process, init_thread] = init_or_error.release_value();
Kernel: Panic if the init process dies If init crashes, all other userspace processes exit too, thus rendering the system unusable. Previously, the kernel would still keep running even without a userland, showing just a black screen without any indication of the issue. We now panic the kernel, which shows a message on the console. In the case of the CI runners, it shuts down the virtual machine, so we don't have to wait for the 1 hour timeout if an issue arises with SystemServer.
2022-03-05 20:01:06 +00:00
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_init_pid = init_process->pid();
init_thread->set_priority(THREAD_PRIORITY_HIGH);
Kernel: Move NetworkTask startup into NetworkTask::spawn()
2020-04-09 11:31:05 +00:00
Kernel: Create all kernel processes before enabling boot profiling Process created performance events for kernel processes are only ever emitted for the kernel processes that exist when profiling is enabled. Any new kernel processes created after profiling is enabled will not have corresponding process created performance events, so all kernel processes should be created before enabling profiling. NetworkTask was the only kernel process being created after enabling profiling, so we now just create it before enabling profiling. This fixes an issue where Profiler was failing to parse boot profiles as a result of NetworkTask not having a process created event.
2022-08-27 02:01:25 +00:00
NetworkTask::spawn();
// NOTE: All kernel processes must be created before enabling boot profiling.
// This is so profiling_enable() can emit process created performance events for them.
Kernel: Add 'boot_prof' option to enable full system profiling on boot The full system profiling functionality is useful for profiling the boot performance of the system. Add a new kernel boot option to start the system with profiling enabled. This lets you disable and view a profile once the system is booted. You can use it by running: ``` $ run.sh qcmd boot_prof ```
2021-03-03 09:00:41 +00:00
if (boot_profiling) {
dbgln("Starting full system boot profiling");
Kernel: Make Process::current() return a Process& instead of Process* This has several benefits: 1) We no longer just blindly derefence a null pointer in various places 2) We will get nicer runtime error messages if the current process does turn out to be null in the call location 3) GCC no longer complains about possible nullptr dereferences when compiling without KUBSAN
2021-08-19 19:45:07 +00:00
MutexLocker mutex_locker(Process::current().big_lock());
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
auto const enable_all = ~(u64)0;
Kernel: Fix boot profiling Boot profiling was previously broken due to init_stage2() passing the event mask to sys$profiling_enable() via kernel pointer, but a user pointer is expected. To fix this, I added Process::profiling_enable() as an alternative to Process::sys$profiling_enable which takes a u64 rather than a Userspace<u64 const*>. It's a bit of a hack, but it works.
2022-08-21 01:55:55 +00:00
auto result = Process::current().profiling_enable(-1, enable_all);
Kernel: Add 'boot_prof' option to enable full system profiling on boot The full system profiling functionality is useful for profiling the boot performance of the system. Add a new kernel boot option to start the system with profiling enabled. This lets you disable and view a profile once the system is booted. You can use it by running: ``` $ run.sh qcmd boot_prof ```
2021-03-03 09:00:41 +00:00
VERIFY(!result.is_error());
}
Kernel: Make Process::current() return a Process& instead of Process* This has several benefits: 1) We no longer just blindly derefence a null pointer in various places 2) We will get nicer runtime error messages if the current process does turn out to be null in the call location 3) GCC no longer complains about possible nullptr dereferences when compiling without KUBSAN
2021-08-19 19:45:07 +00:00
Process::current().sys$exit(0);
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_NOT_REACHED();
A lot of hacking: - More work on funneling console output through Console. - init() now breaks off into a separate task ASAP. - ..this leaves the "colonel" task as a simple hlt idle loop. - Mask all IRQs on startup (except IRQ2 for slave passthru) - Fix underallocation bug in Task::allocateRegion(). - Remember how many times each Task has been scheduled. The panel and scheduling banner are disabled until I get things working nicely in the (brave) new Console world.
2018-10-22 09:15:16 +00:00
}
Kernel: Slap UNMAP_AFTER_INIT on a whole bunch of functions There's no real system here, I just added it to various functions that I don't believe we ever want to call after initialization has finished. With these changes, we're able to unmap 60 KiB of kernel text after init. :^)
2021-02-19 17:41:50 +00:00
UNMAP_AFTER_INIT void setup_serial_debug()
A lot of hacking: - More work on funneling console output through Console. - init() now breaks off into a separate task ASAP. - ..this leaves the "colonel" task as a simple hlt idle loop. - Mask all IRQs on startup (except IRQ2 for slave passthru) - Fix underallocation bug in Task::allocateRegion(). - Remember how many times each Task has been scheduled. The panel and scheduling banner are disabled until I get things working nicely in the (brave) new Console world.
2018-10-22 09:15:16 +00:00
{
Everywhere: Remove klog(), dbg() and purge all LogStream usage :^) Good-bye LogStream. Long live AK::Format!
2021-03-12 16:29:37 +00:00
// serial_debug will output all the dbgln() data to COM1 at
Kernel: Add serial_debug cmdline parameter serial_debug will output all the kprintf and dbgprintf data to COM1 at 8-N-1 57600 baud. this is particularly useful for debugging the boot process on live hardware. Note: it must be the first parameter in the boot cmdline.
2019-08-11 04:43:38 +00:00
// 8-N-1 57600 baud. this is particularly useful for debugging the boot
// process on live hardware.
Kernel: Store the kernel command line in a `StringView` The Raspberry Pi's mailbox interface does not guarantee that the returned command line is null-terminated. This commit removes that assumption from the current code, allowing the next commit to add support for reading it on the Pi. This also lets us eliminate a few manual `strlen()` calls :^)
2023-04-24 18:14:44 +00:00
if (kernel_cmdline.contains("serial_debug"sv)) {
Kernel: Changed serial debug functions and variables for readability Change the name of set_serial_debug(bool on_or_off) to set_serial_debug_enabled(bool desired_state). This is to make the names more expressive and less unclear as to what the function does, as it only sets the enabled state. Likewise, change the name of get_serial_debug() to is_serial_debug_enabled() in order to make clear from the name that this is simply the state of s_serial_debug_enabled. Change the name of serial_debug to s_serial_debug_enabled since this is a static bool describing this state. Finally, change the signature of set_serial_debug_enabled to return a bool, as this is more logical and understandable.
2022-08-24 21:49:23 +00:00
set_serial_debug_enabled(true);
Kernel: Copy the kernel command line to a good location at boot When building the kernel with -O2, we somehow ended up with the kernel command line outside of the lower 8MB of physical memory. Since we don't map that area in our initial page table setup, we would triple fault when trying to parse the command line. This patch sidesteps the issue by copying the (first 4KB of) the kernel command line to a buffer in a known safe location at boot.
2021-02-23 18:25:58 +00:00
}
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
}
Kernel: Add serial_debug cmdline parameter serial_debug will output all the kprintf and dbgprintf data to COM1 at 8-N-1 57600 baud. this is particularly useful for debugging the boot process on live hardware. Note: it must be the first parameter in the boot cmdline.
2019-08-11 04:43:38 +00:00
Kernel: Group C++ ABI functions together As suggested in #3096.
2020-08-11 21:37:27 +00:00
// Define some Itanium C++ ABI methods to stop the linker from complaining.
Kernel: Clean up and reorganize init.cpp This is where we first enter into the kernel, so we should make at least some effort to keep things nice and understandable.
2020-01-18 09:19:31 +00:00
// If we actually call these something has gone horribly wrong
void* __dso_handle __attribute__((visibility("hidden")));
A lot of hacking: - More work on funneling console output through Console. - init() now breaks off into a separate task ASAP. - ..this leaves the "colonel" task as a simple hlt idle loop. - Mask all IRQs on startup (except IRQ2 for slave passthru) - Fix underallocation bug in Task::allocateRegion(). - Remember how many times each Task has been scheduled. The panel and scheduling banner are disabled until I get things working nicely in the (brave) new Console world.
2018-10-22 09:15:16 +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