From da88d766b2dcaf42c383093a709cd2cffaf3b3b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=B6nke=20Holz?= Date: Thu, 2 Nov 2023 23:21:09 +0100 Subject: [PATCH] Kernel/riscv64: Make the kernel compile This commits inserts TODOs into all necessary places to make the kernel compile on riscv64! --- Kernel/Arch/CPU.h | 2 + Kernel/Arch/IRQController.h | 2 + Kernel/Arch/InterruptManagement.h | 2 + Kernel/Arch/Interrupts.h | 1 + Kernel/Arch/PCIMSI.h | 2 +- Kernel/Arch/PageDirectory.h | 2 + Kernel/Arch/riscv64/CPU.h | 10 ++ Kernel/Arch/riscv64/DebugOutput.cpp | 16 +++ Kernel/Arch/riscv64/Delay.cpp | 16 +++ .../riscv64/Firmware/ACPI/StaticParsing.cpp | 17 +++ Kernel/Arch/riscv64/IRQController.h | 37 ++++++ Kernel/Arch/riscv64/InterruptController.h | 36 ++++++ Kernel/Arch/riscv64/InterruptManagement.cpp | 60 ++++++++++ Kernel/Arch/riscv64/InterruptManagement.h | 37 ++++++ Kernel/Arch/riscv64/Interrupts.cpp | 47 ++++++++ Kernel/Arch/riscv64/PCI.cpp | 19 +++ Kernel/Arch/riscv64/PageDirectory.cpp | 65 +++++++++++ Kernel/Arch/riscv64/Panic.cpp | 24 ++++ Kernel/Arch/riscv64/PowerState.cpp | 21 ++++ Kernel/Arch/riscv64/SafeMem.cpp | 109 ++++++++++++++++++ Kernel/Arch/riscv64/pre_init.cpp | 25 ++++ Kernel/Bus/PCI/Definitions.h | 1 + Kernel/CMakeLists.txt | 13 +++ Kernel/Devices/Storage/StorageManagement.cpp | 5 + .../SysFS/Subsystems/Kernel/CPUInfo.cpp | 4 + Kernel/Heap/kmalloc.cpp | 2 +- Kernel/KSyms.cpp | 2 +- Kernel/Syscalls/SyscallHandler.cpp | 4 + Kernel/Syscalls/execve.cpp | 6 + Kernel/Syscalls/fork.cpp | 4 + Kernel/Syscalls/ptrace.cpp | 7 ++ Kernel/Syscalls/thread.cpp | 2 + Kernel/Syscalls/uname.cpp | 2 + Kernel/Tasks/Coredump.cpp | 4 +- Kernel/Tasks/Process.cpp | 16 +++ Kernel/Time/TimeManagement.cpp | 14 ++- Kernel/Time/TimeManagement.h | 2 + 37 files changed, 633 insertions(+), 5 deletions(-) create mode 100644 Kernel/Arch/riscv64/CPU.h create mode 100644 Kernel/Arch/riscv64/DebugOutput.cpp create mode 100644 Kernel/Arch/riscv64/Delay.cpp create mode 100644 Kernel/Arch/riscv64/Firmware/ACPI/StaticParsing.cpp create mode 100644 Kernel/Arch/riscv64/IRQController.h create mode 100644 Kernel/Arch/riscv64/InterruptController.h create mode 100644 Kernel/Arch/riscv64/InterruptManagement.cpp create mode 100644 Kernel/Arch/riscv64/InterruptManagement.h create mode 100644 Kernel/Arch/riscv64/Interrupts.cpp create mode 100644 Kernel/Arch/riscv64/PCI.cpp create mode 100644 Kernel/Arch/riscv64/PageDirectory.cpp create mode 100644 Kernel/Arch/riscv64/Panic.cpp create mode 100644 Kernel/Arch/riscv64/PowerState.cpp create mode 100644 Kernel/Arch/riscv64/SafeMem.cpp create mode 100644 Kernel/Arch/riscv64/pre_init.cpp diff --git a/Kernel/Arch/CPU.h b/Kernel/Arch/CPU.h index f6a61bb9b5..efe6c5925b 100644 --- a/Kernel/Arch/CPU.h +++ b/Kernel/Arch/CPU.h @@ -20,6 +20,8 @@ # include #elif ARCH(AARCH64) # include +#elif ARCH(RISCV64) +# include #else # error "Unknown architecture" #endif diff --git a/Kernel/Arch/IRQController.h b/Kernel/Arch/IRQController.h index 5b58bfca75..a93414b528 100644 --- a/Kernel/Arch/IRQController.h +++ b/Kernel/Arch/IRQController.h @@ -12,6 +12,8 @@ # include #elif ARCH(AARCH64) # include +#elif ARCH(RISCV64) +# include #else # error "Unknown architecture" #endif diff --git a/Kernel/Arch/InterruptManagement.h b/Kernel/Arch/InterruptManagement.h index f9e3b4908f..2cb188a4eb 100644 --- a/Kernel/Arch/InterruptManagement.h +++ b/Kernel/Arch/InterruptManagement.h @@ -12,6 +12,8 @@ # include #elif ARCH(AARCH64) # include +#elif ARCH(RISCV64) +# include #else # error "Unknown architecture" #endif diff --git a/Kernel/Arch/Interrupts.h b/Kernel/Arch/Interrupts.h index ec90c2b48b..6e0d280823 100644 --- a/Kernel/Arch/Interrupts.h +++ b/Kernel/Arch/Interrupts.h @@ -6,6 +6,7 @@ #pragma once +#include #include #include diff --git a/Kernel/Arch/PCIMSI.h b/Kernel/Arch/PCIMSI.h index fa5b3f4988..0e8738a594 100644 --- a/Kernel/Arch/PCIMSI.h +++ b/Kernel/Arch/PCIMSI.h @@ -14,7 +14,7 @@ u64 msi_address_register(u8 destination_id, bool redirection_hint, bool destinat u32 msi_data_register(u8 vector, bool level_trigger, bool assert); u32 msix_vector_control_register(u32 vector_control, bool mask); void msi_signal_eoi(); -#elif ARCH(AARCH64) +#elif ARCH(AARCH64) || ARCH(RISCV64) [[maybe_unused]] static u64 msi_address_register([[maybe_unused]] u8 destination_id, [[maybe_unused]] bool redirection_hint, [[maybe_unused]] bool destination_mode) { TODO_AARCH64(); diff --git a/Kernel/Arch/PageDirectory.h b/Kernel/Arch/PageDirectory.h index e6c8e14b76..c42c023e1b 100644 --- a/Kernel/Arch/PageDirectory.h +++ b/Kernel/Arch/PageDirectory.h @@ -13,6 +13,8 @@ # include #elif ARCH(AARCH64) # include +#elif ARCH(RISCV64) +# include #else # error "Unknown architecture" #endif diff --git a/Kernel/Arch/riscv64/CPU.h b/Kernel/Arch/riscv64/CPU.h new file mode 100644 index 0000000000..0cc62c6b6b --- /dev/null +++ b/Kernel/Arch/riscv64/CPU.h @@ -0,0 +1,10 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +VALIDATE_IS_RISCV64() diff --git a/Kernel/Arch/riscv64/DebugOutput.cpp b/Kernel/Arch/riscv64/DebugOutput.cpp new file mode 100644 index 0000000000..653e1cc3e0 --- /dev/null +++ b/Kernel/Arch/riscv64/DebugOutput.cpp @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include + +namespace Kernel { + +void debug_output(char) +{ + TODO_RISCV64(); +} + +} diff --git a/Kernel/Arch/riscv64/Delay.cpp b/Kernel/Arch/riscv64/Delay.cpp new file mode 100644 index 0000000000..6abff80721 --- /dev/null +++ b/Kernel/Arch/riscv64/Delay.cpp @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include + +namespace Kernel { + +void microseconds_delay(u32) +{ + TODO_RISCV64(); +} + +} diff --git a/Kernel/Arch/riscv64/Firmware/ACPI/StaticParsing.cpp b/Kernel/Arch/riscv64/Firmware/ACPI/StaticParsing.cpp new file mode 100644 index 0000000000..44685cf34b --- /dev/null +++ b/Kernel/Arch/riscv64/Firmware/ACPI/StaticParsing.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include + +namespace Kernel::ACPI::StaticParsing { + +ErrorOr> find_rsdp_in_platform_specific_memory_locations() +{ + // FIXME: Implement finding RSDP for riscv64. + return Optional {}; +} + +} diff --git a/Kernel/Arch/riscv64/IRQController.h b/Kernel/Arch/riscv64/IRQController.h new file mode 100644 index 0000000000..88f3e848bc --- /dev/null +++ b/Kernel/Arch/riscv64/IRQController.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +#include +#include + +#include + +#include +VALIDATE_IS_RISCV64() + +namespace Kernel { + +class IRQController : public AtomicRefCounted { +public: + virtual ~IRQController() = default; + + virtual void enable(GenericInterruptHandler const&) = 0; + virtual void disable(GenericInterruptHandler const&) = 0; + + virtual void eoi(GenericInterruptHandler const&) const = 0; + + virtual u64 pending_interrupts() const = 0; + + virtual StringView model() const = 0; + +protected: + IRQController() = default; +}; + +} diff --git a/Kernel/Arch/riscv64/InterruptController.h b/Kernel/Arch/riscv64/InterruptController.h new file mode 100644 index 0000000000..98144180ae --- /dev/null +++ b/Kernel/Arch/riscv64/InterruptController.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +#include +#include + +#include +VALIDATE_IS_RISCV64() + +namespace Kernel::RISCV64 { + +class InterruptController : public IRQController { +public: + InterruptController(); + +private: + virtual void enable(GenericInterruptHandler const&) override; + virtual void disable(GenericInterruptHandler const&) override; + + virtual void eoi(GenericInterruptHandler const&) const override; + + virtual u64 pending_interrupts() const override; + + virtual StringView model() const override + { + return "cpu-intc"sv; + } +}; + +} diff --git a/Kernel/Arch/riscv64/InterruptManagement.cpp b/Kernel/Arch/riscv64/InterruptManagement.cpp new file mode 100644 index 0000000000..d6c9bd5250 --- /dev/null +++ b/Kernel/Arch/riscv64/InterruptManagement.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include +#include +#include + +namespace Kernel { + +static InterruptManagement* s_interrupt_management; + +bool InterruptManagement::initialized() +{ + return s_interrupt_management != nullptr; +} + +InterruptManagement& InterruptManagement::the() +{ + VERIFY(InterruptManagement::initialized()); + return *s_interrupt_management; +} + +void InterruptManagement::initialize() +{ + VERIFY(!InterruptManagement::initialized()); + s_interrupt_management = new InterruptManagement; + + the().find_controllers(); +} + +void InterruptManagement::find_controllers() +{ + TODO_RISCV64(); +} + +u8 InterruptManagement::acquire_mapped_interrupt_number(u8) +{ + TODO_RISCV64(); +} + +Vector> const& InterruptManagement::controllers() +{ + return m_interrupt_controllers; +} + +NonnullLockRefPtr InterruptManagement::get_responsible_irq_controller(size_t) +{ + TODO_RISCV64(); +} + +void InterruptManagement::enumerate_interrupt_handlers(Function) +{ + TODO_RISCV64(); +} + +} diff --git a/Kernel/Arch/riscv64/InterruptManagement.h b/Kernel/Arch/riscv64/InterruptManagement.h new file mode 100644 index 0000000000..3e0822df35 --- /dev/null +++ b/Kernel/Arch/riscv64/InterruptManagement.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +#include + +#include +VALIDATE_IS_RISCV64() + +namespace Kernel { + +class InterruptManagement { +public: + static InterruptManagement& the(); + static void initialize(); + static bool initialized(); + + static u8 acquire_mapped_interrupt_number(u8 original_irq); + + Vector> const& controllers(); + NonnullLockRefPtr get_responsible_irq_controller(size_t irq_number); + + void enumerate_interrupt_handlers(Function); + +private: + InterruptManagement() = default; + void find_controllers(); + + Vector> m_interrupt_controllers; +}; + +} diff --git a/Kernel/Arch/riscv64/Interrupts.cpp b/Kernel/Arch/riscv64/Interrupts.cpp new file mode 100644 index 0000000000..620ca4e659 --- /dev/null +++ b/Kernel/Arch/riscv64/Interrupts.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include + +#include +#include + +namespace Kernel { + +void dump_registers(RegisterState const&) +{ +} + +// FIXME: Share the code below with Arch/x86_64/Interrupts.cpp +// While refactoring, the interrupt handlers can also be moved into the InterruptManagement class. +GenericInterruptHandler& get_interrupt_handler(u8) +{ + TODO_RISCV64(); +} + +// Sets the reserved flag on `number_of_irqs` if it finds unused interrupt handler on +// a contiguous range. +ErrorOr reserve_interrupt_handlers(u8) +{ + TODO_RISCV64(); +} + +void register_generic_interrupt_handler(u8, GenericInterruptHandler&) +{ + TODO_RISCV64(); +} + +void unregister_generic_interrupt_handler(u8, GenericInterruptHandler&) +{ +} + +void initialize_interrupts() +{ + TODO_RISCV64(); +} + +} diff --git a/Kernel/Arch/riscv64/PCI.cpp b/Kernel/Arch/riscv64/PCI.cpp new file mode 100644 index 0000000000..83f80bdf82 --- /dev/null +++ b/Kernel/Arch/riscv64/PCI.cpp @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include + +namespace Kernel::PCI { + +bool g_pci_access_io_probe_failed { false }; +bool g_pci_access_is_disabled_from_commandline { true }; + +void initialize() +{ + TODO_RISCV64(); +} + +} diff --git a/Kernel/Arch/riscv64/PageDirectory.cpp b/Kernel/Arch/riscv64/PageDirectory.cpp new file mode 100644 index 0000000000..4e7ab2b0c7 --- /dev/null +++ b/Kernel/Arch/riscv64/PageDirectory.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include + +#include +#include +#include + +namespace Kernel::Memory { + +void PageDirectory::register_page_directory(PageDirectory*) +{ + TODO_RISCV64(); +} + +void PageDirectory::deregister_page_directory(PageDirectory*) +{ + TODO_RISCV64(); +} + +ErrorOr> PageDirectory::try_create_for_userspace(Process&) +{ + TODO_RISCV64(); +} + +LockRefPtr PageDirectory::find_current() +{ + TODO_RISCV64(); +} + +void activate_kernel_page_directory(PageDirectory const&) +{ + TODO_RISCV64(); +} + +void activate_page_directory(PageDirectory const&, Thread*) +{ + TODO_RISCV64(); +} + +UNMAP_AFTER_INIT NonnullLockRefPtr PageDirectory::must_create_kernel_page_directory() +{ + return adopt_lock_ref_if_nonnull(new (nothrow) PageDirectory).release_nonnull(); +} + +PageDirectory::PageDirectory() = default; + +UNMAP_AFTER_INIT void PageDirectory::allocate_kernel_directory() +{ + TODO_RISCV64(); +} + +PageDirectory::~PageDirectory() +{ + if (is_root_table_initialized()) { + deregister_page_directory(this); + } +} + +} diff --git a/Kernel/Arch/riscv64/Panic.cpp b/Kernel/Arch/riscv64/Panic.cpp new file mode 100644 index 0000000000..5b0ddc99c4 --- /dev/null +++ b/Kernel/Arch/riscv64/Panic.cpp @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2022, Timon Kruiper + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include +#include + +// FIXME: Merge the code in this file with Kernel/Library/Panic.cpp once the proper abstractions are in place. + +// Note: This is required here, since __assertion_failed should be out of the Kernel namespace, +// but the PANIC macro uses functions that require the Kernel namespace. +using namespace Kernel; + +[[noreturn]] void __assertion_failed(char const* msg, char const* file, unsigned line, char const* func) +{ + critical_dmesgln("ASSERTION FAILED: {}", msg); + critical_dmesgln("{}:{} in {}", file, line, func); + + // Used for printing a nice backtrace! + PANIC("Aborted"); +} diff --git a/Kernel/Arch/riscv64/PowerState.cpp b/Kernel/Arch/riscv64/PowerState.cpp new file mode 100644 index 0000000000..153a9367a1 --- /dev/null +++ b/Kernel/Arch/riscv64/PowerState.cpp @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include + +namespace Kernel { + +void arch_specific_reboot() +{ + TODO_RISCV64(); +} + +void arch_specific_poweroff() +{ + TODO_RISCV64(); +} + +} diff --git a/Kernel/Arch/riscv64/SafeMem.cpp b/Kernel/Arch/riscv64/SafeMem.cpp new file mode 100644 index 0000000000..aea63c29b7 --- /dev/null +++ b/Kernel/Arch/riscv64/SafeMem.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2022, Timon Kruiper + * Copyright (c) 2023, Daniel Bertalan + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include +#include + +#define CODE_SECTION(section_name) __attribute__((section(section_name))) + +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[]; + +namespace Kernel { + +CODE_SECTION(".text.safemem") +NEVER_INLINE FLATTEN bool safe_memset(void* dest_ptr, int c, size_t n, void*& fault_at) +{ + // FIXME: Actually implement a safe memset. + auto* dest = static_cast(dest_ptr); + for (; n--;) + *dest++ = c; + fault_at = nullptr; + return true; +} + +CODE_SECTION(".text.safemem") +NEVER_INLINE FLATTEN ssize_t safe_strnlen(char const* str, unsigned long max_n, void*& fault_at) +{ + // FIXME: Actually implement a safe strnlen. + size_t len = 0; + for (; len < max_n && *str; str++) + len++; + fault_at = nullptr; + return len; +} + +CODE_SECTION(".text.safemem") +NEVER_INLINE FLATTEN bool safe_memcpy(void* dest_ptr, void const* src_ptr, unsigned long n, void*& fault_at) +{ + // FIXME: Actually implement a safe memcpy. + auto* pd = static_cast(dest_ptr); + auto const* ps = static_cast(src_ptr); + for (; n--;) + *pd++ = *ps++; + fault_at = nullptr; + return true; +} + +CODE_SECTION(".text.safemem.atomic") +NEVER_INLINE FLATTEN Optional safe_atomic_compare_exchange_relaxed(u32 volatile* var, u32& expected, u32 val) +{ + // FIXME: Handle access faults. + return AK::atomic_compare_exchange_strong(var, expected, val, AK::memory_order_relaxed); +} + +CODE_SECTION(".text.safemem.atomic") +NEVER_INLINE FLATTEN Optional safe_atomic_load_relaxed(u32 volatile* var) +{ + // FIXME: Handle access faults. + return AK::atomic_load(var, AK::memory_order_relaxed); +} + +CODE_SECTION(".text.safemem.atomic") +NEVER_INLINE FLATTEN Optional safe_atomic_fetch_add_relaxed(u32 volatile* var, u32 val) +{ + // FIXME: Handle access faults. + return AK::atomic_fetch_add(var, val, AK::memory_order_relaxed); +} + +CODE_SECTION(".text.safemem.atomic") +NEVER_INLINE FLATTEN Optional safe_atomic_exchange_relaxed(u32 volatile* var, u32 val) +{ + // FIXME: Handle access faults. + return AK::atomic_exchange(var, val, AK::memory_order_relaxed); +} + +CODE_SECTION(".text.safemem.atomic") +NEVER_INLINE FLATTEN bool safe_atomic_store_relaxed(u32 volatile* var, u32 val) +{ + // FIXME: Handle access faults. + AK::atomic_store(var, val); + return true; +} + +bool handle_safe_access_fault(RegisterState& regs, FlatPtr fault_address) +{ + FlatPtr ip = regs.ip(); + + if (ip >= (FlatPtr)&start_of_safemem_text && ip < (FlatPtr)&end_of_safemem_text) { + dbgln("FIXME: Faulted while accessing userspace address {:p}.", fault_address); + dbgln(" We need to jump back into the appropriate SafeMem function, set fault_at and return failure."); + TODO_RISCV64(); + } else if (ip >= (FlatPtr)&start_of_safemem_atomic_text && ip < (FlatPtr)&end_of_safemem_atomic_text) { + dbgln("FIXME: Faulted while accessing userspace address {:p}.", fault_address); + dbgln(" We need to jump back into the appropriate atomic SafeMem function and return failure."); + TODO_RISCV64(); + } + + return false; +} + +} diff --git a/Kernel/Arch/riscv64/pre_init.cpp b/Kernel/Arch/riscv64/pre_init.cpp new file mode 100644 index 0000000000..3bbbd7d99f --- /dev/null +++ b/Kernel/Arch/riscv64/pre_init.cpp @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2023, Sönke Holz + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include + +#include +#include + +namespace Kernel { + +extern "C" [[noreturn]] void pre_init(FlatPtr mhartid, PhysicalPtr fdt_phys_addr); +extern "C" [[noreturn]] void pre_init(FlatPtr mhartid, PhysicalPtr fdt_phys_addr) +{ + (void)mhartid; + (void)fdt_phys_addr; + + // FIXME: Implement this + + Processor::halt(); +} + +} diff --git a/Kernel/Bus/PCI/Definitions.h b/Kernel/Bus/PCI/Definitions.h index 3be5693994..f3fa4d5b13 100644 --- a/Kernel/Bus/PCI/Definitions.h +++ b/Kernel/Bus/PCI/Definitions.h @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include diff --git a/Kernel/CMakeLists.txt b/Kernel/CMakeLists.txt index 2ef545929c..cb97b258f0 100644 --- a/Kernel/CMakeLists.txt +++ b/Kernel/CMakeLists.txt @@ -512,9 +512,22 @@ elseif("${SERENITY_ARCH}" STREQUAL "riscv64") Arch/Processor.cpp kprintf.cpp + Arch/riscv64/Firmware/ACPI/StaticParsing.cpp + Arch/riscv64/boot.S + Arch/riscv64/DebugOutput.cpp + Arch/riscv64/Delay.cpp + Arch/riscv64/InterruptManagement.cpp + Arch/riscv64/Interrupts.cpp + Arch/riscv64/PageDirectory.cpp + Arch/riscv64/Panic.cpp + Arch/riscv64/PCI.cpp + Arch/riscv64/PowerState.cpp + Arch/riscv64/pre_init.cpp Arch/riscv64/Processor.cpp + Arch/riscv64/SafeMem.cpp Arch/riscv64/SBI.cpp + Arch/riscv64/SmapDisabler.cpp ) add_compile_options(-fno-stack-protector -fno-sanitize=all) diff --git a/Kernel/Devices/Storage/StorageManagement.cpp b/Kernel/Devices/Storage/StorageManagement.cpp index a5d61260fa..b71e484b5a 100644 --- a/Kernel/Devices/Storage/StorageManagement.cpp +++ b/Kernel/Devices/Storage/StorageManagement.cpp @@ -122,6 +122,11 @@ UNMAP_AFTER_INIT void StorageManagement::enumerate_pci_controllers(bool force_pi #elif ARCH(AARCH64) (void)force_pio; TODO_AARCH64(); +#elif ARCH(RISCV64) + (void)force_pio; + if (subclass_code == SubclassID::IDEController && kernel_command_line().is_ide_enabled()) { + TODO_RISCV64(); + } #else # error Unknown architecture #endif diff --git a/Kernel/FileSystem/SysFS/Subsystems/Kernel/CPUInfo.cpp b/Kernel/FileSystem/SysFS/Subsystems/Kernel/CPUInfo.cpp index 96dc9f1dac..379dd2902c 100644 --- a/Kernel/FileSystem/SysFS/Subsystems/Kernel/CPUInfo.cpp +++ b/Kernel/FileSystem/SysFS/Subsystems/Kernel/CPUInfo.cpp @@ -81,6 +81,10 @@ ErrorOr SysFSCPUInformation::try_generate(KBufferBuilder& builder) (void)builder; dmesgln("TODO: Implement ProcessorInfo for AArch64!"); return Error::from_errno(EINVAL); +#elif ARCH(RISCV64) + (void)builder; + dmesgln("TODO: Implement ProcessorInfo for riscv64!"); + return Error::from_errno(EINVAL); #else # error Unknown architecture #endif diff --git a/Kernel/Heap/kmalloc.cpp b/Kernel/Heap/kmalloc.cpp index 9212c36d4c..8e8d10eba5 100644 --- a/Kernel/Heap/kmalloc.cpp +++ b/Kernel/Heap/kmalloc.cpp @@ -18,7 +18,7 @@ #include #include -#if ARCH(X86_64) || ARCH(AARCH64) +#if ARCH(X86_64) || ARCH(AARCH64) || ARCH(RISCV64) static constexpr size_t CHUNK_SIZE = 64; #else # error Unknown architecture diff --git a/Kernel/KSyms.cpp b/Kernel/KSyms.cpp index 3664a1be9d..6e51adea9c 100644 --- a/Kernel/KSyms.cpp +++ b/Kernel/KSyms.cpp @@ -90,7 +90,7 @@ UNMAP_AFTER_INIT static void load_kernel_symbols_from_data(Bytes buffer) // of zero, so the address of a symbol does not need to be offset by the kernel_load_base. #if ARCH(X86_64) ksym.address = kernel_load_base + address; -#elif ARCH(AARCH64) +#elif ARCH(AARCH64) || ARCH(RISCV64) ksym.address = address; #else # error "Unknown architecture" diff --git a/Kernel/Syscalls/SyscallHandler.cpp b/Kernel/Syscalls/SyscallHandler.cpp index a8f28a740d..4da95059d3 100644 --- a/Kernel/Syscalls/SyscallHandler.cpp +++ b/Kernel/Syscalls/SyscallHandler.cpp @@ -107,6 +107,8 @@ NEVER_INLINE void syscall_handler(TrapFrame* trap) clac(); #elif ARCH(AARCH64) // FIXME: Implement the security mechanism for aarch64 +#elif ARCH(RISCV64) + // FIXME: Implement the security mechanism for riscv64 #else # error Unknown architecture #endif @@ -148,6 +150,8 @@ NEVER_INLINE void syscall_handler(TrapFrame* trap) } #elif ARCH(AARCH64) // FIXME: Implement the security mechanism for aarch64 +#elif ARCH(RISCV64) + // FIXME: Implement the security mechanism for riscv64 #else # error Unknown architecture #endif diff --git a/Kernel/Syscalls/execve.cpp b/Kernel/Syscalls/execve.cpp index 56f5b5d0d5..6dbe86995f 100644 --- a/Kernel/Syscalls/execve.cpp +++ b/Kernel/Syscalls/execve.cpp @@ -156,6 +156,10 @@ static ErrorOr make_userspace_context_for_main_thread([[maybe_unused]] regs.x[0] = argv_entries.size(); regs.x[1] = argv; regs.x[2] = envp; +#elif ARCH(RISCV64) + (void)argv; + (void)envp; + TODO_RISCV64(); #else # error Unknown architecture #endif @@ -737,6 +741,8 @@ static Array generate_auxiliary_vect { ELF::AuxiliaryValue::HwCap, (long)CPUID(1).edx() }, #elif ARCH(AARCH64) { ELF::AuxiliaryValue::HwCap, (long)0 }, +#elif ARCH(RISCV64) + { ELF::AuxiliaryValue::HwCap, (long)0 }, // TODO #else # error "Unknown architecture" #endif diff --git a/Kernel/Syscalls/fork.cpp b/Kernel/Syscalls/fork.cpp index e598bbcfb7..145ed369e8 100644 --- a/Kernel/Syscalls/fork.cpp +++ b/Kernel/Syscalls/fork.cpp @@ -150,6 +150,10 @@ ErrorOr Process::sys$fork(RegisterState& regs) child_regs.spsr_el1 = regs.spsr_el1; child_regs.elr_el1 = regs.elr_el1; child_regs.sp_el0 = regs.sp_el0; +#elif ARCH(RISCV64) + (void)child_regs; + (void)regs; + TODO_RISCV64(); #else # error Unknown architecture #endif diff --git a/Kernel/Syscalls/ptrace.cpp b/Kernel/Syscalls/ptrace.cpp index 77c97ceedf..4646c106bb 100644 --- a/Kernel/Syscalls/ptrace.cpp +++ b/Kernel/Syscalls/ptrace.cpp @@ -258,6 +258,9 @@ ErrorOr Thread::peek_debug_register(u32 register_index) #elif ARCH(AARCH64) (void)register_index; TODO_AARCH64(); +#elif ARCH(RISCV64) + (void)register_index; + TODO_RISCV64(); #else # error "Unknown architecture" #endif @@ -290,6 +293,10 @@ ErrorOr Thread::poke_debug_register(u32 register_index, FlatPtr data) (void)register_index; (void)data; TODO_AARCH64(); +#elif ARCH(RISCV64) + (void)register_index; + (void)data; + TODO_RISCV64(); #else # error "Unknown architecture" #endif diff --git a/Kernel/Syscalls/thread.cpp b/Kernel/Syscalls/thread.cpp index 1567c6d43d..7dcdad4bb3 100644 --- a/Kernel/Syscalls/thread.cpp +++ b/Kernel/Syscalls/thread.cpp @@ -76,6 +76,8 @@ ErrorOr Process::sys$create_thread(void* (*entry)(void*), Userspace Coredump::write_elf_header() elf_file_header.e_ident[EI_MAG1] = 'E'; elf_file_header.e_ident[EI_MAG2] = 'L'; elf_file_header.e_ident[EI_MAG3] = 'F'; -#if ARCH(X86_64) || ARCH(AARCH64) +#if ARCH(X86_64) || ARCH(AARCH64) || ARCH(RISCV64) elf_file_header.e_ident[EI_CLASS] = ELFCLASS64; #else # error Unknown architecture @@ -140,6 +140,8 @@ ErrorOr Coredump::write_elf_header() elf_file_header.e_machine = EM_X86_64; #elif ARCH(AARCH64) elf_file_header.e_machine = EM_AARCH64; +#elif ARCH(RISCV64) + elf_file_header.e_machine = EM_RISCV; #else # error Unknown architecture #endif diff --git a/Kernel/Tasks/Process.cpp b/Kernel/Tasks/Process.cpp index e9ef93a187..7a0fc7f071 100644 --- a/Kernel/Tasks/Process.cpp +++ b/Kernel/Tasks/Process.cpp @@ -457,6 +457,20 @@ void signal_trampoline_dummy() ".global asm_signal_trampoline_end\n" "asm_signal_trampoline_end: \n" ::[sigreturn_syscall_number] "i"(Syscall::SC_sigreturn), [offset_to_first_register_slot] "i"(offset_to_first_register_slot)); +#elif ARCH(RISCV64) + constexpr static auto offset_to_a0_slot = align_up_to(sizeof(__ucontext) + sizeof(siginfo) + sizeof(FPUState) + 3 * sizeof(FlatPtr), 16); + asm( + ".global asm_signal_trampoline\n" + "asm_signal_trampoline:\n" + // stack state: 0, ucontext, signal_info (alignment = 16), fpu_state (alignment = 16), ucontext*, siginfo*, signal, handler + + // FIXME: Implement this + "unimp\n" + + "\n" + ".global asm_signal_trampoline_end\n" + "asm_signal_trampoline_end: \n" ::[sigreturn_syscall_number] "i"(Syscall::SC_sigreturn), + [offset_to_first_register_slot] "i"(offset_to_a0_slot)); #else # error Unknown architecture #endif @@ -500,6 +514,8 @@ void Process::crash(int signal, Optional regs, bool out_of constexpr bool userspace_backtrace = false; #elif ARCH(AARCH64) constexpr bool userspace_backtrace = true; +#elif ARCH(RISCV64) + constexpr bool userspace_backtrace = true; #else # error "Unknown architecture" #endif diff --git a/Kernel/Time/TimeManagement.cpp b/Kernel/Time/TimeManagement.cpp index 24c6869d7e..e5edd6f575 100644 --- a/Kernel/Time/TimeManagement.cpp +++ b/Kernel/Time/TimeManagement.cpp @@ -18,6 +18,7 @@ # include #elif ARCH(AARCH64) # include +#elif ARCH(RISCV64) #else # error Unknown architecture #endif @@ -135,6 +136,8 @@ MonotonicTime TimeManagement::monotonic_time(TimePrecision precision) const #elif ARCH(AARCH64) // FIXME: Get rid of these horrible casts const_cast(static_cast(m_system_timer.ptr()))->update_time(seconds, ticks, true); +#elif ARCH(RISCV64) + TODO_RISCV64(); #else # error Unknown architecture #endif @@ -203,6 +206,8 @@ UNMAP_AFTER_INIT void TimeManagement::initialize([[maybe_unused]] u32 cpu) VERIFY(!s_the.is_initialized()); s_the.ensure_instance(); } +#elif ARCH(RISCV64) + TODO_RISCV64(); #else # error Unknown architecture #endif @@ -231,7 +236,7 @@ UnixDateTime TimeManagement::boot_time() { #if ARCH(X86_64) return RTC::boot_time(); -#elif ARCH(AARCH64) +#elif ARCH(AARCH64) || ARCH(RISCV64) // FIXME: Return correct boot time return UnixDateTime::epoch(); #else @@ -271,6 +276,8 @@ UNMAP_AFTER_INIT TimeManagement::TimeManagement() } #elif ARCH(AARCH64) probe_and_set_aarch64_hardware_timers(); +#elif ARCH(RISCV64) + probe_and_set_riscv64_hardware_timers(); #else # error Unknown architecture #endif @@ -474,6 +481,11 @@ UNMAP_AFTER_INIT bool TimeManagement::probe_and_set_aarch64_hardware_timers() return true; } +#elif ARCH(RISCV64) +UNMAP_AFTER_INIT bool TimeManagement::probe_and_set_riscv64_hardware_timers() +{ + TODO_RISCV64(); +} #else # error Unknown architecture #endif diff --git a/Kernel/Time/TimeManagement.h b/Kernel/Time/TimeManagement.h index 642298e1b0..834117617a 100644 --- a/Kernel/Time/TimeManagement.h +++ b/Kernel/Time/TimeManagement.h @@ -87,6 +87,8 @@ private: static void update_time(RegisterState const&); #elif ARCH(AARCH64) bool probe_and_set_aarch64_hardware_timers(); +#elif ARCH(RISCV64) + bool probe_and_set_riscv64_hardware_timers(); #else # error Unknown architecture #endif