Enable FPU

Makefile

@@ -2,12 +2,21 @@
 BUILDDIR := build
 ELFFILE := pepperk
 SRC := src
+
+CC_PROBLEMATIC_FLAGS:=-Wno-unused-parameter -Wno-unused-variable
+
+ifeq ($(UBSAN),true)
 SOURCES := $(shell find src -name '*.c')
+CC_PROBLEMATIC_FLAGS:= -fsanitize=undefined
+else
+SOURCES := $(shell find src -name '*.c')
+SOURCES := $(filter-out src/security/ubsan.c, $(SOURCES))
+endif
+
 OBJFILES := $(patsubst $(SRC)/%.c, $(BUILDDIR)/%.o, $(SOURCES))
 
 CC := x86_64-elf-gcc
-CC_FLAGS=-Wall -Wextra -std=gnu99 -nostdlib -ffreestanding -fno-stack-protector -fno-omit-frame-pointer -fno-stack-check -fno-PIC -ffunction-sections -fdata-sections -mcmodel=kernel
+CC_FLAGS=-Wall -Wextra -std=gnu99 -nostdlib -ffreestanding -fstack-protector -fno-omit-frame-pointer -fno-stack-check -fno-PIC -ffunction-sections -fdata-sections -mcmodel=kernel
-CC_PROBLEMATIC_FLAGS=-Wno-unused-parameter -Wno-unused-variable
 
 LD := x86_64-elf-ld
 

README.md

@@ -34,6 +34,20 @@ Compile the kernel and generate an ISO image like described above, then burn the
 sudo dd if=pepper.iso of=/dev/sdX
 ```
 
+## Compilation options
+
+By default, PepperOS is compiled without the following features:
+
+```
+UBSAN - undefined behavior sanitization
+```
+
+These features can be activated by setting them to "true" at the end of the make command, for example:
+
+```
+make UBSAN=true
+```
+
 ## TODO
 
 The basics that I'm targeting are:
@@ -74,3 +88,5 @@ PepperOS wouldn't be possible without the following freely-licensed software:
 - Intel 64 and IA-32 Architectures Software Developer's Manual
 - Documentation for the [GNU Compiler Collection](https://gcc.gnu.org/onlinedocs/gcc/)
 - dreamos82's [OSDev Notes](https://github.com/dreamportdev/Osdev-Notes/tree/master)
+- the [Sortix UBsan hook implementations](https://gitlab.com/sortix/sortix/-/blob/main/libc/ubsan/ubsan.c)
+- the [CSC 395](https://curtsinger.cs.grinnell.edu/teaching/2022S/CSC395/kernel/) Kernel Development course from Grinnell College

include/arch/gdt.h

@@ -1,6 +1,6 @@
 /*
  * @author  xamidev <xamidev@riseup.net>
- * @brief   Global Descriptor Table (for legacy reasons)
+ * @brief   Global Descriptor Table
  * @license GPL-3.0-only
  */
 

include/arch/x86.h

@@ -10,6 +10,10 @@ void wrmsr(uint32_t msr, uint64_t value);
 bool x86_has_msr();
 void x86_arch_init();
 
+
+void x86_cpu_identification();
+int cpuid_get_vendor_string(char* str);
+
 /* Interrupt Descriptor Table */
 
 void idt_init(void);
@@ -59,4 +63,6 @@ struct cpu_status_t {
     uint64_t iret_ss;
 };
 
+struct cpu_status_t* syscall_handler(struct cpu_status_t* regs);
+
 #endif

include/boot/boot.h

@@ -0,0 +1,14 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Boot routines
+ * @license GPL-3.0-only
+ */
+
+#ifndef BOOT_H
+#define BOOT_H
+
+#include <kernel.h>
+
+void populate_boot_context(struct boot_context* boot_ctx);
+
+#endif

include/config.h

@@ -10,7 +10,7 @@
 /* version */
 #define PEPPEROS_VERSION_MAJOR "0"
 #define PEPPEROS_VERSION_MINOR "0"
-#define PEPPEROS_VERSION_PATCH "58"
+#define PEPPEROS_VERSION_PATCH "109"
 #define PEPPEROS_SPLASH \
 "\x1b[38;5;196m                                      \x1b[38;5;231m____  _____\r\n\x1b[0m"\
 "\x1b[38;5;196m    ____  ___  ____  ____  ___  _____\x1b[38;5;231m/ __ \\/ ___/\r\n\x1b[0m"\
@@ -20,11 +20,14 @@
 "\x1b[38;5;196m/_/        /_/   /_/                             \r\n\x1b[0m"\
 "     --- version \x1b[38;5;220m"PEPPEROS_VERSION_MAJOR"."PEPPEROS_VERSION_MINOR"."PEPPEROS_VERSION_PATCH"\x1b[0m built on \x1b[38;5;40m"__DATE__" "__TIME__"\x1b[0m\r\n"
 
+/* pedicel */
+#define PEDICEL_PROMPT "pedicel$ "
+#define PEDICEL_INPUT_SIZE 128
+
 /* process */
 #define PROCESS_NAME_MAX 64
 #define PROCESS_STACK_SIZE 0x10000 // 64kb
-#define PROCESS_BASE 0x400000
+#define PROCESS_STACK_TOP 0x80000000
-#define PROCESS_STACK_BASE 0x1000000
 
 /* sched */
 // 1 tick = 1 ms => quantum = 10ms
@@ -52,4 +55,7 @@
 /* time */
 #define TIMER_FREQUENCY 1000
 
+/* ssp */
+#define STACK_CHK_GUARD 0x7ABA5C007ABA5C00
+
 #endif

include/io/term/term.h

@@ -11,5 +11,6 @@ void kputs(const char* str);
 void term_init(void);
 int printf(const char* fmt, ...);
 void internal_putc(int c, void *_);
+int kprintf(const char* fmt, ...);
 
 #endif

include/kernel.h

@@ -7,6 +7,7 @@
 #ifndef KERNEL_H
 #define KERNEL_H
 
+#include "limine.h"
 enum ErrorCodes {
 	ENOMEM,
 	EIO
@@ -21,7 +22,7 @@ enum ErrorCodes {
 #include <stdbool.h>
 
 extern volatile uint64_t ticks;
-#define DEBUG(log, ...) printf("[%8u] debug: <%s>: " log "\r\n", ticks, __func__, ##__VA_ARGS__)
+#define DEBUG(log, ...) kprintf("[%8u] debug: <%s>: " log "\r\n", ticks, __func__, ##__VA_ARGS__)
 
 /* #define DEBUG(log, ...) \
 	printf("debug: [%s]: " log "\r\n", __FILE__, ##__VA_ARGS__); \
@@ -38,6 +39,8 @@ void panic(struct cpu_status_t* ctx, const char* str);
 void hcf(void);
 void idle(void);
 
+void pedicel_main(void* arg);
+
 /* debug */
 void debug_stack_trace(unsigned int max_frames);
 const char* debug_find_symbol(uintptr_t rip, uintptr_t* offset);
@@ -50,6 +53,7 @@ struct boot_context {
 	struct limine_memmap_response* mmap;
 	struct limine_hhdm_response* hhdm;
 	struct limine_kernel_address_response* kaddr;
+	struct limine_boot_time_response* bootdate;
 };
 
 // Are these modules initialized yet?
@@ -58,6 +62,7 @@ struct init_status {
 	bool serial;
 	bool keyboard;
 	bool timer;
+	bool all;
 };
 
 #endif

include/mem/kheap.h

@@ -28,5 +28,6 @@ void* kmalloc(size_t size);
 void kfree(void* ptr);
 void* kalloc_stack(void);
 void kheap_map_page(void);
+void kheap_info();
 
 #endif

include/mem/paging.h

@@ -16,9 +16,11 @@
 
 void paging_init(struct boot_context boot_ctx);
 void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_t flags);
+uint64_t* alloc_page_table();
 
 // To swap root page tables
 void load_cr3(uint64_t value);
+void invlpg(void *addr);
 
 extern uint64_t hhdm_off;
 

include/mem/utils.h

@@ -8,6 +8,7 @@
 #define MEM_UTILS_H
 
 #include <stddef.h>
+#include <limine.h>
 
 void* memcpy(void* restrict dest, const void* restrict src, size_t n);
 void* memset(void* s, int c, size_t n);

include/mem/vmm.h

@@ -9,26 +9,21 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include <stdbool.h>
 
-/*
+struct vmm_context {
-This will be our linked list of virtual memory objects.
+    uint64_t* pml4;
-Flags here aren't x86 flags, they are platform-agnostic
-kernel-defined flags.
-*/
-
-struct vm_object {
-    uintptr_t base;
-    size_t length;
-    size_t flags;
-    struct vm_object* next;
 };
 
-// Flags bitfield
-#define VM_FLAG_NONE 0
-#define VM_FLAG_WRITE (1 << 0)
-#define VM_FLAG_EXEC (1 << 1)
-#define VM_FLAG_USER (1 << 2)
-
 void vmm_init(void);
+void* vmm_alloc_region(uint64_t* pml4, size_t pages, uint64_t flags);
+bool vmm_is_mapped(uint64_t* pml4, uint64_t virt);
+void vmm_unmap(uint64_t* pml4, uint64_t virt);
+void* vmm_map(uint64_t* pml4, uint64_t virt, uint64_t flags);
+uint64_t* vmm_create_address_space();
+uint64_t vmm_virt_to_phys(uint64_t* pml4, uint64_t virt);
+
+#define VMM_USER_SPACE_START 0x0000000000001000 
+#define VMM_USER_SPACE_END   0x00007FFFFFFFF000
 
 #endif

include/sched/spinlock.h

@@ -1,4 +1,4 @@
-/*
+        /*
  * @author  xamidev <xamidev@riseup.net>
  * @brief   Spinlock implementation
  * @license GPL-3.0-only

include/security/ubsan.h

@@ -0,0 +1,65 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Undefined behavior sanitization hooks
+ * @license GPL-3.0-only
+ */
+
+#ifndef UBSAN_H
+#define UBSAN_H
+
+#include <stdint.h>
+
+struct ubsan_source_location
+{
+	const char* filename;
+	uint32_t line;
+	uint32_t column;
+};
+
+struct ubsan_type_descriptor
+{
+	uint16_t type_kind;
+	uint16_t type_info;
+	char type_name[];
+};
+
+struct ubsan_type_mismatch_v1_data
+{
+	struct ubsan_source_location location;
+	struct ubsan_type_descriptor* type;
+	unsigned char log_alignment;
+	unsigned char type_check_kind;
+};
+
+struct ubsan_pointer_overflow_data
+{
+	struct ubsan_source_location location;
+};
+
+struct ubsan_shift_out_of_bounds_data
+{
+	struct ubsan_source_location location;
+	struct ubsan_type_descriptor* lhs_type;
+	struct ubsan_type_descriptor* rhs_type;
+};
+
+struct ubsan_invalid_value_data
+{
+	struct ubsan_source_location location;
+	struct ubsan_type_descriptor* type;
+};
+
+struct ubsan_out_of_bounds_data
+{
+	struct ubsan_source_location location;
+	struct ubsan_type_descriptor* array_type;
+	struct ubsan_type_descriptor* index_type;
+};
+
+struct ubsan_overflow_data
+{
+	struct ubsan_source_location location;
+	struct ubsan_type_descriptor* type;
+};
+
+#endif

include/string/string.h

@@ -12,5 +12,6 @@
 char *strcpy(char *dest, const char *src);
 char *strcat(char *dest, const char *src);
 void strncpy(char* dst, const char* src, size_t n);
+int strncmp(const char* s1, const char* s2, size_t n);
 
 #endif

include/time/date.h

@@ -0,0 +1,25 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Date helper functions
+ * @license GPL-3.0-only
+ */
+
+#ifndef DATE_H
+#define DATE_H
+
+#include <stdint.h>
+
+struct date {
+    uint64_t year;
+    uint8_t month;
+    uint8_t day;
+
+    uint8_t hour;
+    uint8_t minute;
+    uint8_t second;
+};
+
+struct date date_timestamp_to_date(uint64_t timestamp);
+struct date date_now();
+
+#endif

src/arch/x86/cpuid.c

@@ -6,6 +6,8 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include <kernel.h>
+#include <string/string.h>
 
 /*
  * cpuid - Wrapper for CPUID instruction
@@ -19,3 +21,28 @@ void cpuid(uint32_t leaf, uint32_t* eax, uint32_t* ebx, uint32_t* ecx, uint32_t*
 {
     __asm__ volatile("cpuid" : "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx) : "a"(leaf));
 }
+
+/*
+ * cpuid_get_vendor_string - Get the CPU vendor string
+ * @str: String at least 13 bytes long (for output)
+ *
+ * Return:
+ * %0 - on success
+ */
+int cpuid_get_vendor_string(char* str)
+{
+    uint32_t eax, ebx, ecx, edx;
+    
+    cpuid(0, &eax, &ebx, &ecx, &edx);
+    char output[13] = {0};
+
+    uint32_t regs[3] = {ebx, edx, ecx};
+    for (unsigned int j=0; j<3; j++) {
+        for (unsigned int i=0; i<4; i++) {
+            output[4*j+i] = (char)((regs[j] >> 8*i) & 0xff);
+        }   
+    }
+
+    strncpy(str, output, 13);
+    return 0;
+}

src/arch/x86/gdt.c

@@ -4,7 +4,7 @@
  * @license GPL-3.0-only
  */
 
-#include <mem/gdt.h>
+#include <arch/gdt.h>
 #include <stdint.h>
 #include <io/serial/serial.h>
 #include <kernel.h>

src/arch/x86/idt.S

@@ -32,6 +32,8 @@ global vector_19_handler
 global vector_20_handler
 global vector_21_handler
 
+global vector_128_handler
+
 interrupt_stub:
     ; We'll push all general-purpose registers to the stack,
     ; so they're intact and don't bother the code that was
@@ -313,3 +315,10 @@ vector_33_handler:
     push qword 0
     push qword 33
     jmp interrupt_stub
+
+; Syscall Interrupt (0x80)
+align 16
+vector_128_handler:
+    push qword 0
+    push qword 128
+    jmp interrupt_stub

src/arch/x86/idt.c

@@ -21,9 +21,13 @@ struct idtr idt_reg;
 // Address to our first interrupt handler
 extern char vector_0_handler[];
 
+extern char vector_128_handler[];
+
 // Timer ticks
 extern volatile uint64_t ticks;
 
+extern struct init_status init;
+
 /*
  * idt_set_entry - Sets an Interrupt Descriptor Table entry
  * @vector:  Vector number in the IDT
@@ -72,6 +76,9 @@ void idt_init()
         // Each vector handler is 16-byte aligned, so <vector_no>*16 = address of that handler
         idt_set_entry(i, vector_0_handler + (i*16), 0);
     }
+
+    idt_set_entry(0x80, vector_128_handler, 0);
+
     idt_load(&idt);
     DEBUG("IDT initialized");
 }
@@ -119,6 +126,19 @@ static void page_fault_handler(struct cpu_status_t* ctx)
     CHECK_BIT(ctx->error_code, 7) ? " SGX_VIOLATION" : "",
     cr2);
 
+    if (init.all) {
+        printf("\x1b[38;5;231mPage Fault at rip=0x%p, err=%u (%s%s%s%s%s%s%s%s) when accessing addr=0x%p\x1b[0m", ctx->iret_rip, ctx->error_code,
+        CHECK_BIT(ctx->error_code, 0) ? "PAGE_PROTECTION_VIOLATION " : "PAGE_NOT_PRESENT ",
+        CHECK_BIT(ctx->error_code, 1) ? "ON_WRITE " : "ON_READ ",
+        CHECK_BIT(ctx->error_code, 2) ? "IN_USER_MODE" : "IN_KERNEL_MODE",
+        CHECK_BIT(ctx->error_code, 3) ? " WAS_RESERVED" : "",
+        CHECK_BIT(ctx->error_code, 4) ? " ON_INSTRUCTION_FETCH" : "",
+        CHECK_BIT(ctx->error_code, 5) ? " PK_VIOLATION" : "",
+        CHECK_BIT(ctx->error_code, 6) ? " ON_SHADOWSTACK_ACCESS" : "",
+        CHECK_BIT(ctx->error_code, 7) ? " SGX_VIOLATION" : "",
+        cr2);
+    }
+
     panic(ctx, "page fault");
 }
 
@@ -154,12 +174,6 @@ static void gp_fault_handler(struct cpu_status_t* ctx)
     panic(ctx, "gp fault");
 }
 
-// DEBUG
-void kbdproc_main(void* arg)
-{
-    printf("Key pressed/released.\r\n");
-}
-
 /*
  * interrupt_dispatch - Interrupt dispatcher
  * @context: CPU context
@@ -258,10 +272,14 @@ struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context)
 
         case 33: // Keyboard Interrupt
             keyboard_handler();
-            process_create("keyboard-initiated", kbdproc_main, NULL); // DEBUG
+            //process_create("keyboard-initiated", kbdproc_main, NULL); // DEBUG
             outb(0x20, 0x20);
             break;
         
+        case 128: // Syscall Interrupt (0x80)
+            syscall_handler(context);
+            break;
+
         default:
             DEBUG("Unexpected Interrupt");
             break;

src/arch/x86/init.c

@@ -4,10 +4,11 @@
  * @license GPL-3.0-only
  */
 
-#include <mem/gdt.h>
+#include <arch/gdt.h>
 #include <stdint.h>
 #include <arch/x86.h>
 #include <kernel.h>
+#include <mem/utils.h>
 
 /*
  * x86_overwrite_pat - Set PAT to WC
@@ -28,6 +29,26 @@ static void x86_overwrite_pat()
     wrmsr(0x277, pat);
 }
 
+/*
+ * x86_enable_fpu - Enable Floating Point Unit
+ *
+ * This function enables the Floating Point Unit,
+ * which allows the CPU to do floating point
+ * operations.
+ *
+ * Here we do not check for FPU support but we
+ * should. However most processors support it.
+ */
+static void x86_enable_fpu()
+{
+    size_t cr4;
+	__asm__ volatile("mov %%cr4, %0" : "=r"(cr4));
+	cr4 |= 0x200;
+	__asm__ volatile("mov %0, %%cr4" :: "r"(cr4));
+    uint16_t cw = 0x37F;
+    asm volatile("fldcw %0" :: "m"(cw));
+}
+
 /*
  * x86_arch_init - Initialize x86 CPU structures
  *
@@ -41,6 +62,53 @@ static void x86_overwrite_pat()
 void x86_arch_init()
 {
     x86_overwrite_pat();
+    x86_enable_fpu();
+    x86_cpu_identification();
     idt_init();
     gdt_init();
 }
+
+/*
+ * cpu_supports_brandstring - Does the CPU support brand strings?
+ *
+ * Return:
+ * true  - if it does
+ * false - if it doesn't
+*/
+bool cpu_supports_brandstring() {
+    uint32_t eax, ebx, ecx, edx;
+    cpuid(0x80000000, &eax, &ebx, &ecx, &edx);
+
+    if (eax < 0x80000004) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+/*
+ * x86_cpu_idenfitication - get info about the CPU
+ *
+ * This function displays the CPU vendor name or the
+ * extended "brand string" if it's supported, on
+ * debug output.
+*/
+void x86_cpu_identification()
+{
+    if (cpu_supports_brandstring()) {
+        uint32_t regs[12];
+        // Some CPUs don't return null-terminated values so we do it as a failsafe default
+        char str[sizeof(regs)+1] = {0};
+        cpuid(0x80000002, &regs[0], &regs[1], &regs[2], &regs[3]);
+        cpuid(0x80000003, &regs[4], &regs[5], &regs[6], &regs[7]);
+        cpuid(0x80000004, &regs[8], &regs[9], &regs[10], &regs[11]);
+
+        memcpy(str, regs, sizeof(regs));
+        str[sizeof(regs)] = '\0';
+        DEBUG("CPU: %s", str);
+    } else {
+        char vendor_string[13] = {0};
+        cpuid_get_vendor_string(vendor_string);
+        DEBUG("CPU vendor is: %s", vendor_string);
+    }
+}

src/arch/x86/syscall.c

@@ -0,0 +1,26 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   System call handling
+ * @license GPL-3.0-only
+ */
+
+#include <arch/x86.h>
+#include <kernel.h>
+
+struct cpu_status_t* syscall_handler(struct cpu_status_t* regs)
+{
+    DEBUG("Syscall %lx with argument %lx", regs->rdi, regs->rsi);
+
+    switch (regs->rdi)
+    {
+        case 0:
+            break;
+        case 1:
+            break;
+        default:
+            regs->rsi = 0xdeadbeef;
+            break;
+    }
+
+    return regs;
+}

src/boot/boot.c

@@ -9,7 +9,9 @@
  * @license GPL-3.0-only
  */
 
+#include <kernel.h>
 #include <limine.h>
+#include <stddef.h>
 
 __attribute__((used, section(".limine_requests")))
 volatile struct limine_framebuffer_request framebuffer_request = {
@@ -35,8 +37,25 @@ volatile struct limine_kernel_address_request kerneladdr_request = {
 	.revision = 0
 };
 
+__attribute__((used, section(".limine_requests")))
+volatile struct limine_boot_time_request date_request = {
+	.id = LIMINE_BOOT_TIME_REQUEST,
+	.revision = 0
+};
+
 __attribute__((used, section(".limine_requests_start")))
 volatile LIMINE_REQUESTS_START_MARKER;
 
 __attribute__((used, section(".limine_requests_end")))
 volatile LIMINE_REQUESTS_END_MARKER;
+
+void populate_boot_context(struct boot_context* ctx)
+{
+	// Populate boot context
+	// This stays valid only if the BOOTLOADER_RECLAIMABLE regions are preserved
+ 	ctx->fb = framebuffer_request.response ? framebuffer_request.response->framebuffers[0] : NULL;
+	ctx->mmap = memmap_request.response ? memmap_request.response : NULL;
+	ctx->hhdm = hhdm_request.response ? hhdm_request.response : NULL;
+	ctx->kaddr = kerneladdr_request.response ? kerneladdr_request.response : NULL;
+	ctx->bootdate = date_request.response ? date_request.response : NULL;
+}

src/io/kbd/ps2.c

@@ -289,15 +289,21 @@ int keyboard_getline(char* output, size_t size)
     
     // Read until Enter is pressed
     while ((c = keyboard_getchar()) != 0x0A) {
-        if (index == size-1) {
+        if (c == '\b') {
-            output[index] = c;
+            if (index > 0) {
-            output[index+1] = '\0';
+                index--;
-            return index;
+                output[index] = '\0';
+                printf(" \b");
             }
-        output[index] = c;
+            continue;
-        index++;
         }
-    output[index+1] = '\0';
+
+        if (index >= size-1) {
+            continue;
+        }
+        output[index++] = c;
+    }
+    output[index] = '\0';
     return index;
 }
 

src/io/term/term.c

@@ -65,6 +65,38 @@ void internal_putc(int c, void *_)
     }
 }
 
+/*
+ * debug_putc - Internal DEBUG putchar function
+ * @c: char to print
+ * @_: (unused, for nanoprintf)
+ *
+ * Prints a character to the terminal if it's ready and if 
+ * the kernel is still initializing, and also always to the
+ * serial interface if it's ready.
+ */
+void debug_putc(int c, void *_)
+{
+    (void)_;
+    char ch = (char)c;
+
+    if (init.terminal && (!init.all || panic_count > 0)) {
+        if (panic_count == 0) {
+            spinlock_acquire(&term_lock);
+            flanterm_write(ft_ctx, &ch, 1);
+            spinlock_release(&term_lock);
+        } else {
+            flanterm_write(ft_ctx, &ch, 1);
+        }
+    }
+
+    if (init.serial) {
+        if (ch == '\n') {
+            skputc('\r');
+        }
+        skputc(ch);
+    }
+}
+
 /*
  * printf - Fromatted printing
  * @fmt: format string
@@ -96,6 +128,38 @@ int printf(const char* fmt, ...)
     return -1;
 }
 
+/*
+ * kprintf - Fromatted DEBUG printing 
+ * @fmt: format string
+ * @...: variadic arguments
+ *
+ * Wrapper for nanoprintf; to be used only for
+ * kernel/debug messages.
+ *
+ * Return:
+ * <ret> - number of characters sent to the callback
+ * %-1   - error
+ */
+int kprintf(const char* fmt, ...)
+{
+    if (panic_count == 0) {
+        spinlock_acquire(&printf_lock);
+        va_list args;
+        va_start(args, fmt);
+        int ret = npf_vpprintf(debug_putc, NULL, fmt, args);
+        va_end(args);
+        spinlock_release(&printf_lock);
+        return ret;
+    } else {
+        va_list args;
+        va_start(args, fmt);
+        int ret = npf_vpprintf(debug_putc, NULL, fmt, args);
+        va_end(args);
+        return ret;
+    }
+    return -1;
+}
+
 /*
  * kputs - Kernel puts
  * @str: String to write

src/kapps/kshell.c

@@ -0,0 +1,101 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   PepperOS kernel shell
+ * @license GPL-3.0-only
+ */
+
+#include <io/term/term.h>
+#include <config.h>
+#include <io/kbd/ps2.h>
+#include <string/string.h>
+#include <stdint.h>
+#include <kernel.h>
+#include <time/date.h>
+#include <mem/kheap.h>
+
+__attribute__((noinline))
+void smash_it()
+{
+    char buf[16]; (void)buf;
+    for (size_t i=0; i<256; i++) {
+        buf[i] = (char)i;
+    }
+}
+
+/*
+ * pedicel_main - Kernel shell main function
+ * @arg: argument (optional)
+ *
+ * This is the entry point for the kernel shell process.
+ * It is used to start programs and to test different things
+ * on different real hardware easily.
+ *
+ * Named after the root part of the pepper.
+ */
+void pedicel_main(void* arg)
+{
+    printf("Welcome to the kernel shell!\r\nType 'help' for a list of commands.\r\n");
+
+    for (;;) {
+        char input_buf[PEDICEL_INPUT_SIZE] = {0};
+        printf(PEDICEL_PROMPT);
+        keyboard_getline(input_buf, PEDICEL_INPUT_SIZE);
+        
+        if (strncmp(input_buf, "help", 4) == 0) {
+            printf("\r\nYou are currently running the test kernel shell. This is not\r\n"
+                        "a fully-fledged shell like you'd find in a complete operating system,\r\n"
+                        "but rather a toy to play around in the meantime.\r\n\r\n"
+                            "clear   - clear the screen\r\n"
+                            "panic   - trigger a test panic\r\n"
+                            "syscall - trigger int 0x80\r\n"
+                            "pf      - trigger a page fault\r\n"
+                            "now     - get current date\r\n"
+                            "smash   - smash the stack\r\n"
+                            "mem     - get used heap info\r\n");
+            continue;
+        }
+
+        if (strncmp(input_buf, "", 1) == 0) {
+            continue;
+        } 
+
+        if (strncmp(input_buf, "clear", 5) == 0) {
+            printf("\x1b[2J\x1b[H");
+            continue;
+        }
+
+        if (strncmp(input_buf, "panic", 5) == 0) {
+            panic(NULL, "test panic");
+        }
+
+        if (strncmp(input_buf, "syscall", 7) == 0) {
+            __asm__ volatile("mov $0x00, %rdi");
+            __asm__ volatile("int $0x80");
+            continue;
+        }
+
+        if (strncmp(input_buf, "pf", 2) == 0) {
+            volatile uint64_t* fault = (uint64_t*)0xdeadbeef;
+            fault[0] = 1;
+        }
+
+        if (strncmp(input_buf, "now", 3) == 0) {
+            struct date now = date_now();
+            printf("Now is %02u:%02u:%02u on %u/%u/%u\r\n", now.hour, now.minute,
+                now.second, now.day, now.month, now.year);
+            continue;
+        }
+
+        if (strncmp(input_buf, "smash", 5) == 0) {
+            smash_it();
+            continue;
+        }
+
+        if (strncmp(input_buf, "mem", 3) == 0) {
+            kheap_info();
+            continue;
+        }
+
+        printf("%s: command not found\r\n", input_buf);
+    }
+}

src/kmain.c

@@ -4,13 +4,12 @@
  * @license GPL-3.0-only
  */
 
-#include "arch/x86.h"
 #include <stdbool.h>	
 #include <stddef.h>
 #include <limine.h>
 #include <io/term/term.h>
 #include <io/serial/serial.h>
-#include <mem/gdt.h>
+#include <arch/gdt.h>
 #include <mem/utils.h>
 #include <kernel.h>
 #include <time/timer.h>
@@ -25,6 +24,7 @@
 #include <io/term/flanterm.h>
 #include <io/term/flanterm_backends/fb.h>
 #include <arch/x86.h>
+#include <boot/boot.h>
 
 // Limine version used
 __attribute__((used, section(".limine_requests")))
@@ -61,17 +61,12 @@ extern volatile struct limine_framebuffer_request framebuffer_request;
 extern volatile struct limine_memmap_request memmap_request;
 extern volatile struct limine_hhdm_request hhdm_request;
 extern volatile struct limine_kernel_address_request kerneladdr_request;
+extern volatile struct limine_boot_time_request date_request;
 
 extern struct process_t* processes_list;
 extern struct process_t* current_process;
 struct process_t* idle_proc;
 
-// Never gets executed although pedicel is scheduled?
-void pedicel_main(void* arg)
-{
-	printf("\n\n\rWelcome to PepperOS! Pedicel speaking.\r\nNothing left to do, let's go idle!\r\n");
-}
-
 void idle_main(void* arg)
 {
 	for (;;) {
@@ -102,11 +97,7 @@ void kmain()
 	CLEAR_INTERRUPTS;
 	if (!LIMINE_BASE_REVISION_SUPPORTED) hcf();
 
-	// Populate boot context
+	populate_boot_context(&boot_ctx);
- 	boot_ctx.fb = framebuffer_request.response ? framebuffer_request.response->framebuffers[0] : NULL;
-	boot_ctx.mmap = memmap_request.response ? memmap_request.response : NULL;
-	boot_ctx.hhdm = hhdm_request.response ? hhdm_request.response : NULL;
-	boot_ctx.kaddr = kerneladdr_request.response ? kerneladdr_request.response : NULL;
 
 	term_init();
 	serial_init();
@@ -125,10 +116,11 @@ void kmain()
 	process_init();
 	idle_proc = process_create("idle", (void*)idle_main, 0);
 	process_create("pedicel", (void*)pedicel_main, 0);
-	process_create("thing", thing_main, NULL);
 
 	scheduler_init();
 
 	printf(PEPPEROS_SPLASH);
+	init.all = true;
+
 	idle();
 }

src/mem/kheap.c

@@ -158,3 +158,32 @@ void* kalloc_stack()
     uint8_t* ptr = kmalloc(PROCESS_STACK_SIZE); // As it's out of kmalloc, stack is already mapped into kernel space
     return ptr ? ptr+PROCESS_STACK_SIZE : NULL;
 }
+
+/*
+ * kheap_info - Display heap info
+ *
+ * This function writes the size of the heap (total),
+ * the number of allocated bytes, and the number of
+ * free bytes to the standard output.
+ */
+void kheap_info()
+{
+    uint64_t free_bytes = 0;
+    struct heap_block_t* curr = (struct heap_block_t*)kheap_start;
+
+    while (curr) {
+        if (curr->free == true) {
+            free_bytes += curr->size;
+        }
+        curr = curr->next;
+    }
+
+    uint64_t total = end-kheap_start;
+
+    printf("total=% 8u bytes (%u kB)\r\n"
+                "alloc=% 8u bytes (%u kB)\r\n"
+                " free=% 8u bytes (%u kB)\r\n",
+                total, (total)/1000,
+                total-free_bytes, (total-free_bytes)/1000,
+                free_bytes, free_bytes/1000);
+}

src/mem/paging.c

@@ -43,7 +43,7 @@ void load_cr3(uint64_t value) {
  * This function is used to flush at least the TLB entrie(s)
  * for the page that contains the <addr> address.
  */
-static inline void invlpg(void *addr)
+void invlpg(void *addr)
 {
     asm volatile("invlpg (%0)" :: "r"(addr) : "memory");
 }
@@ -59,7 +59,7 @@ static inline void invlpg(void *addr)
  * Return:
  * <virt> - Pointer to allocated page table
  */
-static uint64_t* alloc_page_table()
+uint64_t* alloc_page_table()
 {
     uint64_t* virt = (uint64_t*)PHYS_TO_VIRT(pmm_alloc());
 

src/mem/vmm.c

@@ -19,60 +19,211 @@ compared to the PMM which allocs/frees 4kb frames ("physical pages").
 #include <mem/pmm.h>
 #include <kernel.h>
 
-void* vmm_pt_root = 0;
-
-// Linked list head for virtual memory objects
-struct vm_object* vm_objs = NULL;
-
-/*
- * Will have to be rewritten and expanded,
- * to prepare for userspace.
- * The platform-agnostic flags will be removed
- * because as long as the kernel is x86 only,
- * we don't need over complication.
- * Plus I don't plan to port to other architectures
-*/
-
-uint64_t convert_x86_vm_flags(size_t flags)
-{
-    uint64_t value = 0;
-    if (flags & VM_FLAG_WRITE)
-    {
-        value |= PTE_WRITABLE;
-    }
-    if (flags & VM_FLAG_USER)
-    {
-        value |= PTE_USER;
-    }
-    if ((flags & VM_FLAG_EXEC) == 0)
-    {
-        value |= PTE_NOEXEC;
-    }
-    return value;
-}
-
 extern uint64_t *kernel_pml4;
 
-void vmm_setup_pt_root()
+/*
+ * vmm_switch_to - Switch to a different VMM context
+ * @ctx: VMM context to switch to
+ *
+ * This function makes the CPU switch to another
+ * virtual memory context, by using the PML4 address
+ * specified in the VMM context pointed to by @ctx.
+ */
+void vmm_switch_to(struct vmm_context* ctx)
 {
-    // We alloc a physical page (frame) for the pointer, then map it
+    if (!ctx || !ctx->pml4) {
-    // to virt (pointer)
+        panic(NULL, "Attempted to switch to bad PML4!");
-    uintptr_t phys = pmm_alloc();
+    }
-    vmm_pt_root = (void*)kernel_pml4;
+    uint64_t pml4 = VIRT_TO_PHYS(ctx->pml4);
-    paging_map_page(kernel_pml4, (uint64_t)vmm_pt_root, phys, convert_x86_vm_flags(VM_FLAG_WRITE | VM_FLAG_EXEC));
+    asm volatile ("mov %0, %%cr3" :: "r"(pml4) : "memory");
-    DEBUG("VMM setup: vmm_pt_root=0x%p (phys=0x%p)", vmm_pt_root, phys);
 }
 
-/* void* vmm_alloc(size_t length, size_t flags)
+/*
+ * vmm_virt_to_phys - Translate from virtual to physical address
+ * @pml4: virtual address of the Page Map Level 4 (root page table)
+ * @virt: virtual address to translate
+ *
+ * This function goes through page table structures, beginning at
+ * the root page table which lives at @pml4, and translates @virt
+ * to a physical address, if it's found in the tables.
+ *
+ * Return:
+ * <phys> - physical address
+ * %-1     - address is not present in page tables pointed to by @pml4
+ */
+uint64_t vmm_virt_to_phys(uint64_t* pml4, uint64_t virt)
 {
-    // We will try to allocate at least length bytes, which have to be rounded UP to
+    uint64_t pml4_i = PML4_INDEX(virt);
-    // the next page so its coherent with the PMM
+    uint64_t pdpt_i = PDPT_INDEX(virt);
-    size_t len = ALIGN_UP(length, PAGE_SIZE);
+    uint64_t pd_i = PD_INDEX(virt);
+    uint64_t pt_i = PT_INDEX(virt);
 
-    // Need to implement this (as linked list)
+    if (!(pml4[pml4_i] & PTE_PRESENT)) return -1;
-    // but for now kernel heap is sufficient
+    uint64_t* pdpt = (uint64_t*)PHYS_TO_VIRT(pml4[pml4_i] & PTE_ADDR_MASK);
-    // The VMM will prob be more useful when we have userspace
+
-} */
+    if (!(pdpt[pdpt_i] & PTE_PRESENT)) return -1;
+    uint64_t* pd = (uint64_t*)PHYS_TO_VIRT(pdpt[pdpt_i] & PTE_ADDR_MASK);
+
+    if (!(pd[pd_i] & PTE_PRESENT)) return -1;
+    uint64_t* pt = (uint64_t*)PHYS_TO_VIRT(pd[pd_i] & PTE_ADDR_MASK);
+
+    if (!(pt[pt_i] & PTE_PRESENT)) return -1;
+
+    uint64_t phys = (pt[pt_i] & PTE_ADDR_MASK) + (virt & 0xFFF);
+    return phys;
+}
+
+/*
+ * vmm_create_address_space - Create a new address space
+ *
+ * This function allocates a PML4, and then copies the kernel
+ * page tables into it.
+ *
+ * Return:
+ * <pml4>  - address of the new PML4
+ * NULL    - on error (couldn't allocate a page table)
+ */
+uint64_t* vmm_create_address_space()
+{
+    uint64_t* pml4 = alloc_page_table();
+    if (!pml4) return NULL;
+
+    for (size_t i=256; i<512; i++) {
+        pml4[i] = kernel_pml4[i];
+    }
+
+    return pml4;
+}
+
+/*
+ * vmm_map - Map & allocate a page
+ * @pml4:  Page Map Level 4 (root table)
+ * @virt:  Virtual address to map
+ * @flags: Flags to apply on page
+ *
+ * This function allocates a page frame with the PMM,
+ * and maps this page to the provided @virt address,
+ * with the corresponding @flags.
+ *
+ * Return:
+ * <virt> - virtual address
+ */
+void* vmm_map(uint64_t* pml4, uint64_t virt, uint64_t flags)
+{
+    uint64_t phys = pmm_alloc();
+    if (!phys) {
+        panic(NULL, "VMM/PMM out of memory!");
+    }
+
+    paging_map_page(pml4, virt, phys, flags | PTE_PRESENT);
+    return (void*)virt;
+}
+
+/*
+ * vmm_unmap - Unmap & free a page
+ * @pml4:  Page Map Level 4 (root table)
+ * @virt:  Virtual address to unmap
+ *
+ * This function frees a page frame with the PMM,
+ * and unmaps the virtual page at @virt.
+ */
+void vmm_unmap(uint64_t* pml4, uint64_t virt)
+{
+    uint64_t pml4_i = PML4_INDEX(virt);
+    uint64_t pdpt_i = PDPT_INDEX(virt);
+    uint64_t pd_i   = PD_INDEX(virt);
+    uint64_t pt_i   = PT_INDEX(virt);
+
+    if (!(pml4[pml4_i] & PTE_PRESENT)) return;
+    uint64_t* pdpt = (uint64_t*)PHYS_TO_VIRT(pml4[pml4_i] & PTE_ADDR_MASK);
+
+    if (!(pdpt[pdpt_i] & PTE_PRESENT)) return;
+    uint64_t* pd = (uint64_t*)PHYS_TO_VIRT(pdpt[pdpt_i] & PTE_ADDR_MASK);
+
+    if (!(pd[pd_i] & PTE_PRESENT)) return;
+    uint64_t* pt = (uint64_t*)PHYS_TO_VIRT(pd[pd_i] & PTE_ADDR_MASK);
+
+    if (!(pt[pt_i] & PTE_PRESENT)) return;
+
+    uint64_t phys = pt[pt_i] & PTE_ADDR_MASK;
+    pmm_free(phys);
+
+    pt[pt_i] = 0;
+
+    invlpg((void*)virt);
+}
+
+/*
+ * vmm_is_mapped - Check if an address is mapped
+ * @pml4:  Page Map Level 4 (root table)
+ * @virt:  Virtual address to check
+ *
+ * This function checks if the @virt address is
+ * mapped in the tables pointed to by @pml4.
+ *
+ * Return:
+ * true  - @virt is mapped in tables of @pml4
+ * false - @virt is not mapped there
+ */
+bool vmm_is_mapped(uint64_t* pml4, uint64_t virt)
+{
+    uint64_t pml4_i = PML4_INDEX(virt);
+    uint64_t pdpt_i = PDPT_INDEX(virt);
+    uint64_t pd_i   = PD_INDEX(virt);
+    uint64_t pt_i   = PT_INDEX(virt);
+
+    if (!(pml4[pml4_i] & PTE_PRESENT)) return false;
+    uint64_t* pdpt = (uint64_t*)PHYS_TO_VIRT(pml4[pml4_i] & PTE_ADDR_MASK);
+
+    if (!(pdpt[pdpt_i] & PTE_PRESENT)) return false;
+    uint64_t* pd = (uint64_t*)PHYS_TO_VIRT(pdpt[pdpt_i] & PTE_ADDR_MASK);
+
+    if (!(pd[pd_i] & PTE_PRESENT)) return false;
+    uint64_t* pt = (uint64_t*)PHYS_TO_VIRT(pd[pd_i] & PTE_ADDR_MASK);
+
+    return (pt[pt_i] & PTE_PRESENT);
+}
+
+/*
+ * vmm_alloc_range - Map and allocate a memory range
+ * @pml4:  Page Map Level 4 (root table)
+ * @pages: Amount of pages to allocate/map
+ * @flags: Flags to put on mapped pages
+ *
+ * This function looks for enough space in page tables
+ * to map @pages pages, then maps them into the provided
+ * @pml4 with the provided @flags and allocates them.
+ *
+ * Return:
+ * <start_virt> - the starting virtual address for the mapped range
+ */
+void* vmm_alloc_region(uint64_t* pml4, size_t pages, uint64_t flags)
+{
+    uint64_t found_pages = 0;
+    uint64_t start_virt = VMM_USER_SPACE_START;
+
+    for (uint64_t curr = VMM_USER_SPACE_START; curr < VMM_USER_SPACE_END; curr += PAGE_SIZE) {
+        if (!vmm_is_mapped(pml4, curr)) {
+            if (found_pages == 0) start_virt = curr;
+            found_pages++;
+        } else {
+            found_pages = 0;
+        }
+
+        if (found_pages == pages) {
+            for (size_t i = 0; i < pages; i++) {
+                uint64_t addr_to_map = start_virt + (i * PAGE_SIZE);
+                if (!vmm_map(pml4, addr_to_map, flags)) {
+                    panic(NULL, "VMM out of memory!");
+                }
+            }
+            return (void*)start_virt;
+        }
+    }
+
+    panic(NULL, "VMM out of memory!");
+    return NULL;
+}
 
 void vmm_init()
 {

src/sched/process.c

@@ -9,11 +9,11 @@
 #include <mem/kheap.h>
 #include <kernel.h>
 #include <string/string.h>
-#include <mem/gdt.h>
+#include <arch/gdt.h>
 #include <config.h>
 #include <io/serial/serial.h>
-
 #include <io/term/flanterm.h>
+
 extern struct flanterm_context* ft_ctx;
 
 struct process_t* processes_list;

src/security/ssp.c

@@ -0,0 +1,17 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Stack Smashing Protection feature
+ * @license GPL-3.0-only
+ */
+
+#include <config.h>
+#include <stdint.h>
+#include <kernel.h>
+#include <stddef.h>
+
+uint64_t __stack_chk_guard = STACK_CHK_GUARD;
+
+void __stack_chk_fail(void)
+{
+	panic(NULL, "SSP: Stask Smashing Detected!!! (very spicy)");
+}

src/security/ubsan.c

@@ -0,0 +1,293 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Undefined behavior sanitization hooks
+ * @license GPL-3.0-only
+ */
+
+#include <stdint.h>
+#include <security/ubsan.h>
+#include <kernel.h>
+#include <stddef.h>
+
+/*
+ * Hooks were inspired from the Sortix implementation:
+ * https://gitlab.com/sortix/sortix/-/blob/main/libc/ubsan/ubsan.c
+ *
+ * Not all hooks are implemented here.
+ */
+
+extern struct init_status init;
+
+/*
+ * __ubsan_handle_type_mismatch_v1 - Hook for UBSan
+ * @data_raw:    pointer to error data
+ * @pointer_raw: faulty pointer
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: type mismatch, null pointer
+ * access, and unaligned access. It halts the system and
+ * gives the location of the code that triggered it.
+ */
+void __ubsan_handle_type_mismatch_v1(void* data_raw, void* pointer_raw)
+{
+	struct ubsan_type_mismatch_v1_data* data = (struct ubsan_type_mismatch_v1_data*) data_raw;
+	uintptr_t pointer = (uintptr_t)pointer_raw;
+	uintptr_t alignment = (uintptr_t)1UL << data->log_alignment;
+	const char* violation = "type mismatch";
+	if ( !pointer ) {
+        violation = "null pointer access";
+    }
+	else if ( alignment && (pointer & (alignment - 1)) ) {
+        violation = "unaligned access";
+    }
+	
+    struct ubsan_source_location* loc = &data->location;
+
+    DEBUG("\x1b[38;5;231mUBSan: %s (ptr=%p) at %s:%u:%u\x1b[0m", violation, pointer, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: %s (ptr=%p) at %s:%u:%u\x1b[0m\r\n", violation, pointer, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error");
+}
+
+/*
+ * __ubsan_handle_pointer_overflow - Hook for UBSan
+ * @data_raw:   pointer to error data
+ * @base_raw:   base pointer
+ * @result_raw: pointer after faulty operation
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: pointer overflow.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_pointer_overflow(void* data_raw, void* base_raw, void* result_raw)
+{
+	struct ubsan_pointer_overflow_data* data = (struct ubsan_pointer_overflow_data*) data_raw;
+	uintptr_t base = (uintptr_t)base_raw;
+	uintptr_t result = (uintptr_t)result_raw;
+    
+    struct ubsan_source_location* loc = &data->location;
+
+    DEBUG("\x1b[38;5;231mUBSan: pointer overflow (base=%p, result=%p) at %s:%u:%u\x1b[0m", base, result, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: pointer overflow (base=%p, result=%p) at %s:%u:%u\x1b[0m", base, result, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: pointer overflow");
+}
+
+/*
+ * __ubsan_handle_shift_out_of_bounds - Hook for UBSan
+ * @data_raw: pointer to error data
+ * @lhs_raw:  left hand side (value being shifted)
+ * @rhs_raw:  right hand side (shift amount)
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: shift out of bounds.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_shift_out_of_bounds(void* data_raw, void* lhs_raw, void* rhs_raw)
+{
+	struct ubsan_shift_out_of_bounds_data* data = (struct ubsan_shift_out_of_bounds_data*) data_raw;
+	uintptr_t lhs = (uintptr_t) lhs_raw;
+	uintptr_t rhs = (uintptr_t) rhs_raw;
+	
+    struct ubsan_source_location* loc = &data->location;
+
+    DEBUG("\x1b[38;5;231mUBSan: shift out of bounds (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: shift out of bounds (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: shift out of bounds");
+}
+
+/*
+ * __ubsan_handle_load_invalid_value - Hook for UBSan
+ * @data_raw:    pointer to error data
+ * @value_raw:   value loaded
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: invalid value load.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_load_invalid_value(void* data_raw, void* value_raw)
+{
+	struct ubsan_invalid_value_data* data = (struct ubsan_invalid_value_data*) data_raw;
+	uintptr_t value = (uintptr_t) value_raw;
+
+    struct ubsan_source_location* loc = &data->location;
+
+    DEBUG("\x1b[38;5;231mUBSan: invalid value load (value=%p) at %s:%u:%u\x1b[0m", value, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: invalid value load (value=%p) at %s:%u:%u\x1b[0m", value, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: invalid value load");
+}
+
+/*
+ * __ubsan_handle_out_of_bounds - Hook for UBSan
+ * @data_raw:    pointer to error data
+ * @index_raw:   out-of-bounds index in array
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: access out of bounds.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_out_of_bounds(void* data_raw, void* index_raw)
+{
+	struct ubsan_out_of_bounds_data* data = (struct ubsan_out_of_bounds_data*) data_raw;
+	uintptr_t index = (uintptr_t) index_raw;
+    struct ubsan_source_location* loc = &data->location;
+
+    DEBUG("\x1b[38;5;231mUBSan: out of bounds (index=%p) at %s:%u:%u\x1b[0m", index, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: out of bounds (index=%p) at %s:%u:%u\x1b[0m", index, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: out of bounds");
+}
+
+/*
+ * __ubsan_handle_divrem_overflow - Hook for UBSan
+ * @data_raw:    pointer to error data
+ * @lhs_raw:     left hand side operator
+ * @rhs_raw:     right hand side operator
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: division remainder overflow.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_divrem_overflow(void* data_raw, void* lhs_raw, void* rhs_raw)
+{
+	struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw;
+	uintptr_t lhs = (uintptr_t) lhs_raw;
+	uintptr_t rhs = (uintptr_t) rhs_raw;
+    struct ubsan_source_location* loc = &data->location;
+
+	DEBUG("\x1b[38;5;231mUBSan: division remainder overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: division remainder overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: division remainder overflow");
+}
+
+/*
+ * __ubsan_handle_sub_overflow - Hook for UBSan
+ * @data_raw:    pointer to error data
+ * @lhs_raw:     left hand side operator
+ * @rhs_raw:     right hand side operator
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: subtraction overflow.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_sub_overflow(void* data_raw, void* lhs_raw, void* rhs_raw)
+{
+	struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw;
+	uintptr_t lhs = (uintptr_t) lhs_raw;
+	uintptr_t rhs = (uintptr_t) rhs_raw;
+	struct ubsan_source_location* loc = &data->location;
+
+	DEBUG("\x1b[38;5;231mUBSan: subtraction overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: subtraction overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: subtraction overflow");
+}
+
+/*
+ * __ubsan_handle_add_overflow - Hook for UBSan
+ * @data_raw:    pointer to error data
+ * @lhs_raw:     left hand side operator
+ * @rhs_raw:     right hand side operator
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: addition overflow.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_add_overflow(void* data_raw, void* lhs_raw, void* rhs_raw)
+{
+	struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw;
+	uintptr_t lhs = (uintptr_t) lhs_raw;
+	uintptr_t rhs = (uintptr_t) rhs_raw;
+    struct ubsan_source_location* loc = &data->location;
+
+	DEBUG("\x1b[38;5;231mUBSan: addition overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: addition overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: addition overflow");
+}
+
+/*
+ * __ubsan_handle_mul_overflow - Hook for UBSan
+ * @data_raw:    pointer to error data
+ * @lhs_raw:     left hand side operator
+ * @rhs_raw:     right hand side operator
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: multiplication overflow.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_mul_overflow(void* data_raw, void* lhs_raw, void* rhs_raw)
+{
+	struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw;
+	uintptr_t lhs = (uintptr_t) lhs_raw;
+	uintptr_t rhs = (uintptr_t) rhs_raw;
+	struct ubsan_source_location* loc = &data->location;
+
+	DEBUG("\x1b[38;5;231mUBSan: multiplication overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: multiplication overflow (lhs=%p, rhs=%p) at %s:%u:%u\x1b[0m", lhs, rhs, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: multiplication overflow");
+}
+
+/*
+ * __ubsan_handle_negate_overflow - Hook for UBSan
+ * @data_raw:      pointer to error data
+ * @old_value_raw: value before overflow
+ *
+ * This function is executed when the UBSan library detects
+ * following undefined behavior: negation overflow.
+ * It halts the system and gives the location of the code
+ * that triggered it.
+ */
+void __ubsan_handle_negate_overflow(void* data_raw, void* old_value_raw)
+{
+	struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw;
+	uintptr_t old_value = (uintptr_t) old_value_raw;
+    struct ubsan_source_location* loc = &data->location;
+
+	DEBUG("\x1b[38;5;231mUBSan: negation overflow (old_value=%p) at %s:%u:%u\x1b[0m", old_value, loc->filename, loc->line, loc->column);
+
+    if (init.all) {
+        printf("\x1b[38;5;231mUBSan: negation overflow (old_value=%p) at %s:%u:%u\x1b[0m", old_value, loc->filename, loc->line, loc->column);
+    }
+
+    panic(NULL, "Undefined Behavior Sanitization error: negation overflow");
+}

src/string/string.c

@@ -70,3 +70,32 @@ void strncpy(char* dst, const char* src, size_t n)
    size_t i = 0;
    while(i++ != n && (*dst++ = *src++));
 }
+
+
+/*
+ * strncmp - compare two strings up to n characters
+ * @s1: first string
+ * @s2: second string
+ * @n:  number of bytes to compare
+ *
+ * Taken from: https://github.com/DevSolar/pdclib/blob/master/functions/string/strncmp.c
+ *
+ * Return:
+ * $0  - @s1 and @s2 are equal
+ * $<0 - @s1 is less than @s2
+ * $>0 - @s1 is greater than @s2 
+ */
+int strncmp(const char* s1, const char* s2, size_t n)
+{
+    while ( n && *s1 && ( *s1 == *s2 ) ) {
+        ++s1;
+        ++s2;
+        --n;
+    }
+    if ( n == 0 ) {
+        return 0;
+    }
+    else {
+        return ( *(unsigned char *)s1 - *(unsigned char *)s2 );
+    }
+}

src/time/date.c

@@ -0,0 +1,89 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Date helper functions
+ * @license GPL-3.0-only
+ */
+
+#include <stdint.h>
+#include <time/date.h>
+#include <mem/utils.h>
+#include <kernel.h>
+
+extern struct boot_context boot_ctx;
+
+// Unix epoch used as reference: Jan 1st 1970, 00:00:00 UTC
+struct date epoch = {
+    .year = 1970,
+    .month = 1,
+    .day = 1,
+    .hour = 0,
+    .minute = 0,
+    .second = 0
+};
+
+/*
+ * date_timestamp_to_date - Convert UNIX timestamp to a date structure
+ * @timestamp: UNIX timestamp
+ * 
+ * Return:
+ * <date> - date structure
+ */
+struct date date_timestamp_to_date(uint64_t timestamp)
+{
+    struct date result;
+    memcpy(&result, &epoch, sizeof(struct date));
+    uint64_t nr_days = timestamp / 86400;
+
+    while (nr_days > 0) {
+        unsigned int nr_month = 0;
+        int leap_year = 0;
+
+        if (result.year % 4 == 0 && (result.year % 100 != 0 || result.year % 400 == 0)) {
+            leap_year = 1;
+        } else {
+            leap_year = 0;
+        }
+
+        if (result.month == 2) {
+            if (leap_year != 0) {
+                nr_month = 29;
+            } else {
+                nr_month = 28;
+            }
+        } else {
+            nr_month = 31 - ((result.month -1) % 7 % 2);
+        }
+        
+        if (nr_days >= nr_month) {
+            nr_days -= nr_month;
+            result.month++;
+            if (result.month > 12) {
+                result.month = 1;
+                result.year++;
+            }
+        } else {
+            result.day += nr_days;
+            nr_days = 0;
+        }
+    }
+
+    result.second = timestamp % 60;
+    timestamp /= 60;
+    result.minute = timestamp % 60;
+    timestamp /= 60;
+    result.hour = timestamp % 24;
+
+    return result;
+}
+
+/*
+ * date_now - Get the current date (time at boot + timer ticks)
+ *
+ * Return:
+ * <date> - date structure
+ */
+struct date date_now()
+{
+    uint64_t timestamp_now = boot_ctx.bootdate->boot_time + (ticks/1000);
+    return date_timestamp_to_date(timestamp_now);
+}