ported to C++

at least compiles and runs (with compiler warnings disabled)

.vscode/tasks.json

@@ -91,7 +91,6 @@
                 "-drive", "if=pflash,unit=0,format=raw,file=/opt/ovmf-riscv64.fd", // OVMF UEFI firmware
                 // virtio-scsi disk
                 "-device", "virtio-scsi-pci",
-                "-device", "scsi-hd,drive=hd0",
                 "-drive", "id=hd0,format=raw,file=fat:rw:uefi-files/", // UEFI files
             ],
             "problemMatcher": [ ],

cmake/create_bootable_kernel_binary.cmake

@@ -11,14 +11,14 @@ set(STUB_KALLSYMS_C [=[
 // SPDX-License-Identifier: GPL-3.0-or-later
 // !! This file is generated by CMake, any changes will be overwritten
 
-#include "mos/misc/kallsyms.h"
+#include "mos/misc/kallsyms.hpp"
 
 const kallsyms_t mos_kallsyms[] = {
     { .address = 0, .name = "stub" },
 }\;
 ]=])
 
-file(WRITE ${KALLSYMS_DIR}/stub_kallsyms.c ${STUB_KALLSYMS_C})
+file(WRITE ${KALLSYMS_DIR}/stub_kallsyms.cpp ${STUB_KALLSYMS_C})
 
 function(do_kallsyms TARGET_NAME LINKER_SCRIPT KALLSYMS_C)
     add_executable(${TARGET_NAME} ${KALLSYMS_C})
@@ -70,9 +70,9 @@ function(create_bootable_kernel_binary)
     # no need to publicly link to mos::kernel, see above comment in do_kallsyms
     target_link_libraries(${ARGS_TARGET}_loader PRIVATE mos::kernel)
 
-    set(STEP1_KALLSYMS_C "${KALLSYMS_DIR}/stub_kallsyms.c")
-    set(STEP2_KALLSYMS_C "${KALLSYMS_DIR}/${ARGS_TARGET}.kallsyms.1.c")
-    set(STEP3_KALLSYMS_C "${KALLSYMS_DIR}/${ARGS_TARGET}.kallsyms.2.c")
+    set(STEP1_KALLSYMS_C "${KALLSYMS_DIR}/stub_kallsyms.cpp")
+    set(STEP2_KALLSYMS_C "${KALLSYMS_DIR}/${ARGS_TARGET}.kallsyms.1.cpp")
+    set(STEP3_KALLSYMS_C "${KALLSYMS_DIR}/${ARGS_TARGET}.kallsyms.2.cpp")
 
     # Step 1: Compile the kernel with stub kallsyms
     do_kallsyms(${ARGS_TARGET}.kallsyms.1 ${ARGS_LINKER_SCRIPT} ${STEP1_KALLSYMS_C})

cmake/mos_target_setup.cmake

@@ -20,7 +20,8 @@ list(APPEND MOS_KERNEL_CFLAGS "-ffreestanding")
 list(APPEND MOS_KERNEL_CXXFLAGS "-ffreestanding;-fno-exceptions;-fno-rtti")
 
 # global compiler flags, which should be used for all targets
-set(MOS_GLOBAL_C_CXX_FLAGS "${MOS_GLOBAL_C_CXX_FLAGS} -Wall -Wextra -Wpedantic -pedantic -Werror=div-by-zero")
+# set(MOS_GLOBAL_C_CXX_FLAGS "${MOS_GLOBAL_C_CXX_FLAGS} -Wall -Wextra -Wpedantic -pedantic")
+set(MOS_GLOBAL_C_CXX_FLAGS "${MOS_GLOBAL_C_CXX_FLAGS} -Werror=div-by-zero")
 
 set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   ${MOS_GLOBAL_C_CXX_FLAGS} -Wstrict-prototypes -Wold-style-definition -Werror=implicit-function-declaration")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MOS_GLOBAL_C_CXX_FLAGS}")

kernel/CMakeLists.txt

@@ -95,7 +95,7 @@ add_kernel_submodule(mm)
 add_kernel_submodule(syslog)
 add_kernel_submodule(tasks)
 
-add_kernel_source(kmain.c ksyscall_entry.c ksyscall.c)
+add_kernel_source(kmain.cpp ksyscall_entry.cpp ksyscall.cpp)
 
 target_link_libraries(mos_kernel PRIVATE mos::rpc-protocols)
 add_subdirectory(tests)

kernel/arch/generic/boot/limine/CMakeLists.txt

@@ -8,7 +8,7 @@ create_bootable_kernel_binary(
     FILENAME
         mos_limine.elf
     SOURCES
-        limine.c
+        limine.cpp
 )
 
 set(LIMINE_ROOT "/usr/share/limine" CACHE PATH "Path to limine root directory")

kernel/arch/generic/boot/limine/limine.c → kernel/arch/generic/boot/limine/limine.cpp

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include <algorithm>
 #define pr_fmt(fmt) "limine: " fmt
 
-#include "limine.h"
+#include "limine.hpp"
+#include "mos/device/console.hpp"
+#include "mos/misc/cmdline.hpp"
+#include "mos/misc/setup.hpp"
+#include "mos/mm/mm.hpp"
+#include "mos/syslog/printk.hpp"
 
-#include "mos/device/console.h"
-#include "mos/misc/cmdline.h"
-#include "mos/misc/setup.h"
-#include "mos/mm/mm.h"
-#include "mos/syslog/printk.h"
-
-#include <mos_stdlib.h>
+#include <mos_stdlib.hpp>
 
 #define limine_request __section(".limine.requests") __used static volatile
 
@@ -22,6 +22,8 @@ __used __section(".limine.markers.requests_end") static volatile LIMINE_REQUESTS
 limine_request LIMINE_BASE_REVISION(2);
 MOS_WARNING_POP
 
+MOS_WARNING_PUSH
+MOS_WARNING_DISABLE("-Wmissing-field-initializers")
 limine_request struct limine_bootloader_info_request bootloader_info = { .id = LIMINE_BOOTLOADER_INFO_REQUEST, .revision = 0 };
 limine_request struct limine_dtb_request dtb = { .id = LIMINE_DTB_REQUEST, .revision = 0 };
 limine_request struct limine_efi_system_table_request efi_system_table = { .id = LIMINE_EFI_SYSTEM_TABLE_REQUEST, .revision = 0 };
@@ -35,6 +37,7 @@ limine_request struct limine_paging_mode_request paging_mode = { .id = LIMINE_PA
 limine_request struct limine_rsdp_request rsdp = { .id = LIMINE_RSDP_REQUEST, .revision = 0 };
 limine_request struct limine_smp_request smp = { .id = LIMINE_SMP_REQUEST, .revision = 0, .flags = 0 };
 limine_request struct limine_stack_size_request stack_size = { .id = LIMINE_STACK_SIZE_REQUEST, .revision = 0, .stack_size = 16 MB };
+MOS_WARNING_POP
 
 static void add_to_memmap(pfn_t start, size_t npages, bool reserved, u32 type, const char *typestr)
 {
@@ -53,7 +56,7 @@ static void add_to_memmap(pfn_t start, size_t npages, bool reserved, u32 type, c
 
     if (entry->type == LIMINE_MEMMAP_USABLE || entry->type == LIMINE_MEMMAP_KERNEL_AND_MODULES || entry->type == LIMINE_MEMMAP_FRAMEBUFFER ||
         entry->type == LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE || entry->type == LIMINE_MEMMAP_ACPI_RECLAIMABLE || entry->type == LIMINE_MEMMAP_ACPI_NVS)
-        platform_info->max_pfn = MAX(platform_info->max_pfn, entry->pfn_start + entry->nframes);
+        platform_info->max_pfn = std::max(platform_info->max_pfn, entry->pfn_start + entry->nframes);
 }
 
 static void ap_entry(struct limine_smp_info *info)
@@ -63,7 +66,7 @@ static void ap_entry(struct limine_smp_info *info)
     platform_ap_entry(info->extra_argument);
 }
 
-void limine_entry(void)
+extern "C" void limine_entry(void)
 {
     if (hhdm.response->offset)
         platform_info->direct_map_base = hhdm.response->offset; // early-populate direct_map_base
@@ -97,7 +100,7 @@ void limine_entry(void)
         if (info->processor_id == 0)
             continue; // skip BSP
 
-        __atomic_store_n(&info->goto_address, ap_entry, __ATOMIC_SEQ_CST);
+        __atomic_store_n(&info->goto_address, &ap_entry, __ATOMIC_SEQ_CST);
     }
 
     if (kernel_file.response == NULL)

kernel/arch/generic/devicetree/dt_dump.cpp

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "libfdt++.hpp"
-#include "mos/syslog/printk.h"
+#include "mos/syslog/printk.hpp"
 
-#include <mos_string.h>
+#include <mos_string.hpp>
 
 #define INDENT "    "
 

kernel/arch/riscv64/CMakeLists.txt

@@ -1,14 +1,14 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 add_kernel_source(
-    riscv64_platform.c
-    riscv64_platform_api.c
-    sbi/sbi-call.c
-    mm/mm.c
-    cpu/trap.c
-    cpu/plic.c
+    riscv64_platform.cpp
+    riscv64_platform_api.cpp
+    sbi/sbi-call.cpp
+    mm/mm.cpp
+    cpu/trap.cpp
+    cpu/plic.cpp
     cpu/interrupt.S
     cpu/context_switch.S
-    devices/sbi_console.c
-    devices/uart_driver.c
+    devices/sbi_console.cpp
+    devices/uart_driver.cpp
 )

kernel/arch/riscv64/cpu/plic.c → kernel/arch/riscv64/cpu/plic.cpp

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "mos/riscv64/cpu/plic.h"
+#include "mos/riscv64/cpu/plic.hpp"
 
-#include "mos/mm/mm.h"
+#include "mos/mm/mm.hpp"
 
-#include <mos/types.h>
+#include <mos/types.hpp>
 
 // qemu puts platform-level interrupt controller (PLIC) here.
 #define PLIC                 pa_va(0x0c000000L)

kernel/arch/riscv64/cpu/trap.c → kernel/arch/riscv64/cpu/trap.cpp

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "mos/interrupt/interrupt.h"
-#include "mos/ksyscall_entry.h"
-#include "mos/mm/paging/table_ops.h"
-#include "mos/platform/platform.h"
-#include "mos/riscv64/cpu/cpu.h"
-#include "mos/riscv64/cpu/plic.h"
-#include "mos/tasks/schedule.h"
-#include "mos/tasks/signal.h"
+#include "mos/interrupt/interrupt.hpp"
+#include "mos/ksyscall_entry.hpp"
+#include "mos/mm/paging/table_ops.hpp"
+#include "mos/platform/platform.hpp"
+#include "mos/riscv64/cpu/cpu.hpp"
+#include "mos/riscv64/cpu/plic.hpp"
+#include "mos/tasks/schedule.hpp"
+#include "mos/tasks/signal.hpp"
 
-void riscv64_trap_handler(platform_regs_t *regs, reg_t scause, reg_t stval, reg_t sepc)
+extern "C" void riscv64_trap_handler(platform_regs_t *regs, reg_t scause, reg_t stval, reg_t sepc)
 {
     write_csr(stvec, __riscv64_trap_entry);
     current_cpu->interrupt_regs = regs;
@@ -18,6 +18,7 @@ void riscv64_trap_handler(platform_regs_t *regs, reg_t scause, reg_t stval, reg_
     const bool is_userspace = (regs->sstatus & SSTATUS_SPP) == 0;
     const bool is_interrupt = scause & BIT(63);
     const long exception = scause & ~BIT(63);
+    long ret = 0;
 
     const char *name = "<unknown>";
     if (is_interrupt)
@@ -58,28 +59,36 @@ void riscv64_trap_handler(platform_regs_t *regs, reg_t scause, reg_t stval, reg_
     MOS_ASSERT(!"Unhandled exception");
 
 handle_irq:
+{
     const u32 irq = plic_claim_irq();
     interrupt_entry(irq);
     plic_complete(irq);
     goto leave;
-
+}
 handle_bp:
+{
     signal_send_to_thread(current_thread, SIGTRAP);
     goto leave;
+}
 
 handle_timer:
+{
     const reg_t stime = read_csr(time);
     write_csr(stimecmp, stime + 500 * 1000); // 0.5 ms
     spinlock_acquire(&current_thread->state_lock);
     reschedule();
     goto leave;
+}
 
 handle_syscall:
+{
     regs->sepc += 4; // increase sepc to the next instruction
-    const long ret = ksyscall_enter(regs->a7, regs->a0, regs->a1, regs->a2, regs->a3, regs->a4, regs->a5);
+    ret = ksyscall_enter(regs->a7, regs->a0, regs->a1, regs->a2, regs->a3, regs->a4, regs->a5);
     goto leave;
+}
 
 handle_ii:
+{
     if (sepc > MOS_KERNEL_START_VADDR)
     {
         try_handle_kernel_panics(sepc);
@@ -88,22 +97,25 @@ void riscv64_trap_handler(platform_regs_t *regs, reg_t scause, reg_t stval, reg_
 
     signal_send_to_process(current_process, SIGILL);
     goto leave;
+}
 
 handle_pf:
+{
     MOS_ASSERT_X(!is_interrupt, "Page faults should not be interrupts");
 
     const bool present = mm_do_get_present(current_cpu->mm_context->pgd, stval);
 
     pagefault_t pfinfo = {
-        .ip = sepc,
-        .is_exec = exception == 12,
-        .is_write = exception == 15,
         .is_present = present,
+        .is_write = exception == 15,
         .is_user = is_userspace,
+        .is_exec = exception == 12,
+        .ip = sepc,
         .regs = regs,
     };
     mm_handle_fault(stval, &pfinfo);
     goto leave;
+}
 
 leave:
     if (is_userspace)

kernel/arch/riscv64/devices/sbi_console.c → kernel/arch/riscv64/devices/sbi_console.cpp

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "mos/riscv64/devices/sbi_console.h"
+#include "mos/riscv64/devices/sbi_console.hpp"
 
-#include "mos/device/console.h"
-#include "mos/riscv64/sbi/sbi-call.h"
+#include "mos/device/console.hpp"
+#include "mos/riscv64/sbi/sbi-call.hpp"
 
 #include <ansi_colors.h>
-#include <mos/types.h>
+#include <mos/types.hpp>
 
 static standard_color_t sbi_console_bg = Black, sbi_console_fg = White;
 

kernel/arch/riscv64/devices/uart_driver.c → kernel/arch/riscv64/devices/uart_driver.cpp

@@ -1,32 +1,32 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "mos/riscv64/devices/uart_driver.h"
+#include "mos/riscv64/devices/uart_driver.hpp"
 
-#include "mos/device/serial.h"
+#include "mos/device/serial.hpp"
 
-#include <mos/types.h>
+#include <mos/types.hpp>
 
 static u8 riscv64_serial_read_register(serial_device_t *dev, serial_register_t reg)
 {
-    volatile u8 *const ptr = dev->driver_data;
+    volatile u8 *const ptr = (volatile u8 *) dev->driver_data;
     return READ_ONCE(ptr[reg]);
 }
 
 static void riscv64_serial_write_register(serial_device_t *dev, serial_register_t reg, u8 value)
 {
-    volatile u8 *const ptr = dev->driver_data;
+    volatile u8 *const ptr = (volatile u8 *) dev->driver_data;
     ptr[reg] = value;
 }
 
 static u8 riscv64_serial_read_data(serial_device_t *dev)
 {
-    volatile u8 *const ptr = dev->driver_data;
+    volatile u8 *const ptr = (volatile u8 *) dev->driver_data;
     return ptr[0];
 }
 
 static void riscv64_serial_write_data(serial_device_t *dev, u8 data)
 {
-    volatile u8 *const ptr = dev->driver_data;
+    volatile u8 *const ptr = (volatile u8 *) dev->driver_data;
     ptr[0] = data;
 }
 

kernel/arch/riscv64/include/private/mos/platform/platform_defs.h → kernel/arch/riscv64/include/private/mos/platform/platform_defs.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <mos/types.h>
+#include <mos/types.hpp>
 
 #define MOS_PLATFORM_PAGING_LEVELS 4
 

kernel/arch/riscv64/include/private/mos/riscv64/cpu/cpu.h → kernel/arch/riscv64/include/private/mos/riscv64/cpu/cpu.hpp

@@ -3,7 +3,7 @@
 #pragma once
 
 #include <mos/mos_global.h>
-#include <mos/types.h>
+#include <mos/types.hpp>
 
 typedef struct _platform_regs
 {
@@ -43,7 +43,7 @@ MOS_STATIC_ASSERT(sizeof(platform_regs_t) == 264, "please also change cpu/interr
 #define SIE_STIE BIT(5)
 #define SIE_SSIE BIT(1)
 
-[[noreturn]] extern void riscv64_trap_exit(platform_regs_t *regs);
+extern "C" [[noreturn]] void riscv64_trap_exit(platform_regs_t *regs);
 
 extern const char __riscv64_trap_entry[];
 extern const char __riscv64_usermode_trap_entry[];

kernel/arch/riscv64/include/private/mos/riscv64/cpu/plic.h → kernel/arch/riscv64/include/private/mos/riscv64/cpu/plic.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <mos/types.h>
+#include <mos/types.hpp>
 
 void plic_enable_irq(u32 irq);
 

kernel/arch/riscv64/include/private/mos/riscv64/devices/sbi_console.h → kernel/arch/riscv64/include/private/mos/riscv64/devices/sbi_console.hpp

@@ -2,6 +2,6 @@
 
 #pragma once
 
-#include "mos/device/console.h"
+#include "mos/device/console.hpp"
 
 extern console_t sbi_console;

kernel/arch/riscv64/include/private/mos/riscv64/devices/uart_driver.h → kernel/arch/riscv64/include/private/mos/riscv64/devices/uart_driver.hpp

@@ -2,6 +2,6 @@
 
 #pragma once
 
-#include "mos/device/serial.h"
+#include "mos/device/serial.hpp"
 
 extern const serial_driver_t riscv64_uart_driver;