Kernel debug shell

Reviewed-on: #15

Makefile

@@ -1,31 +1,41 @@
-SOURCES = src/sched/spinlock.c src/debug/misc.c src/io/term/flanterm_backends/fb.c src/io/term/flanterm.c src/debug/panic.c src/debug/stacktrace.c src/boot/boot.c src/sched/scheduler.c src/sched/process.c src/mem/heap/kheap.c src/mem/paging/vmm.c src/mem/paging/paging.c src/mem/paging/pmm.c src/string/string.c src/io/kbd/ps2.c src/io/serial/serial.c src/io/term/term.c src/idt/idt.c src/mem/gdt/gdt.c src/mem/misc/utils.c src/time/timer.c src/kmain.c
 
+BUILDDIR := build
+ELFFILE := pepperk
+SRC := src
+SOURCES := $(shell find src -name '*.c')
+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_PROBLEMATIC_FLAGS=-Wno-unused-parameter -Wno-unused-variable
 
-.PHONY: build build-iso debug debug2 run clean
+LD := x86_64-elf-ld
 
-build:
-	mkdir -p build
-	rm -f *.o build/*.o
-	x86_64-elf-gcc -g -c -Isrc $(SOURCES) $(CC_PROBLEMATIC_FLAGS) $(CC_FLAGS)
-	mv *.o build/
-	nasm -f elf64 src/idt/idt.S -o build/idt_stub.o
-	x86_64-elf-ld -o pepperk -T linker.ld build/*.o
-	nm -n pepperk | awk '$$2 ~ /[TtDdBbRr]/ {print $$1, $$3}' > symbols.map
+$(ELFFILE): $(BUILDDIR) $(OBJFILES)
+	nasm -f elf64 src/arch/x86/idt.S -o $(BUILDDIR)/idt_stub.o
+	$(LD) -o $(ELFFILE) -T linker.ld $(OBJFILES) $(BUILDDIR)/idt_stub.o
+	# Get the symbols for debugging
+	nm -n $(ELFFILE) | awk '$$2 ~ /[TtDdBbRr]/ {print $$1, $$3}' > symbols.map
 	python3 symbols.py
-	nasm -f elf64 symbols.S -o build/symbols.o
-	x86_64-elf-ld -o pepperk -T linker.ld build/*.o
+	nasm -f elf64 symbols.S -o $(BUILDDIR)/symbols.o
+	$(LD) -o $(ELFFILE) -T linker.ld $(OBJFILES) $(BUILDDIR)/idt_stub.o $(BUILDDIR)/symbols.o
+
+$(BUILDDIR):
+	@mkdir -p $(BUILDDIR)
+
+$(BUILDDIR)/%.o: $(SRC)/%.c
+	mkdir -p $(dir $@)
+	$(CC) -g -c -Iinclude $< $(CC_PROBLEMATIC_FLAGS) $(CC_FLAGS) -o $@
 
 limine/limine:
 	rm -rf limine
 	git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1
 	$(MAKE) -C limine
 
-build-iso: limine/limine build
+build-iso: limine/limine $(ELFFILE)
 	rm -rf iso_root
 	mkdir -p iso_root/boot
-	cp -v pepperk iso_root/boot
+	cp -v $(ELFFILE) iso_root/boot
 	mkdir -p iso_root/boot/limine
 	cp -v limine.conf iso_root/boot/limine
 	mkdir -p iso_root/EFI/BOOT
@@ -39,16 +49,20 @@ build-iso: limine/limine build
 		iso_root -o pepper.iso
 	./limine/limine bios-install pepper.iso
 
+.PHONY: debug
 debug:
 	/usr/bin/qemu-system-x86_64 -drive file=pepper.iso -s -S -d int -D qemu.log -no-reboot -no-shutdown &
-	gdb pepperk --command=debug.gdb
+	gdb $(ELFFILE) --command=debug.gdb
 
+.PHONY: debug2
 debug2:
 	/usr/bin/qemu-system-x86_64 -drive file=pepper.iso -s -S -d int -no-reboot -no-shutdown &
-	pwndbg pepperk --command=debug.gdb
+	pwndbg $(ELFFILE) --command=debug.gdb
 
+.PHONY: run
 run: build-iso
 	/usr/bin/qemu-system-x86_64 -cdrom pepper.iso -serial stdio
 
+.PHONY: clean
 clean:
-	rm -rf *.o symbols.map symbols.S pepperk iso_root pepper.iso limine build/*.o
+	rm -rf $(BUILDDIR) symbols.map symbols.S $(ELFFILE) iso_root pepper.iso limine

README.md

@@ -1,17 +1,38 @@
 # <img width="40" height="40" alt="red-pepper" src="https://i.ibb.co/mrHH6d1m/pixil-frame-0-4.png" /> pepperOS: "will never be done"
 
-## Trying the kernel
+## Description
 
-First install the dependencies: `sudo apt install python3 xorriso make qemu-system`
+PepperOS is a 64-bit freely-licensed monolithic kernel for x86 processors, with round-robin preemptive scheduling and 4-level paging. See the [manual](docs/MANUAL.md) for more.
 
-Also, you have to get an x86_64 toolchain for compilation. The easiest way to do that on most systems is to install it from Homebrew:
+## Trying the kernel in QEMU
+
+### Debian-based distributions
+
+First, install the dependencies: `sudo apt install nasm python3 xorriso make qemu-system`
+
+Then, you can get an x86_64 toolchain for compilation. The easiest way to do that on most systems is to install it from Homebrew:
 
 ```
 brew install x86_64-elf-gcc
 ```
 
-Then, to compile the kernel and make an ISO image file: `make build-iso`
-To run it with QEMU, `make run`
+If you're already on a 64-bit machine (which you probably are), and don't want to install a cross-compiler, you can just override `CC` and `LD` variables in the Makefile, like so:
+
+```
+CC := gcc
+LD := ld
+```
+
+Then, to compile the kernel and make an ISO image file, run: `make build-iso`
+To run it with QEMU, do: `make run`
+
+## Trying the kernel on real hardware
+
+Compile the kernel and generate an ISO image like described above, then burn the image to a USB stick, `/dev/sdX` being the device name (you can get it using `lsblk`):
+
+```
+sudo dd if=pepper.iso of=/dev/sdX
+```
 
 ## TODO
 
@@ -44,7 +65,7 @@ In the future, maybe?
 PepperOS wouldn't be possible without the following freely-licensed software:
 
 - the [Limine](https://codeberg.org/Limine/Limine) portable bootloader
-- Marco Paland's freestanding [printf implementation](https://github.com/mpaland)
+- Charles Nicholson's [nanoprintf](https://github.com/charlesnicholson/nanoprintf)
 - Mintuski's [Flanterm](https://codeberg.org/Mintsuki/Flanterm) terminal emulator
 
 ...and without these amazing resources:
@@ -52,3 +73,4 @@ PepperOS wouldn't be possible without the following freely-licensed software:
 - the [OSDev](https://osdev.org) wiki & forums
 - 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)

docs/MANUAL.md

@@ -0,0 +1,40 @@
+# PepperOS Manual
+
+# Table of Contents
+
+- [Overview](#i-overview)
+    - [Supported Hardware](#a-supported-hardware)
+    - [Features](#b-features)
+- [Kernel architecture](#ii-kernel-architecture)
+    - [Boot process](#a-boot-process)
+    - [Memory management](#b-memory-management)
+    - [Scheduling](#c-scheduling)
+    - [Input/output](#d-inputoutput)
+- [Syscall table](#iii-syscall-table)
+
+## I. Overview
+
+## a. Supported Hardware
+
+The recommended hardware to run PepperOS is the following:
+
+- UEFI/BIOS
+- Any x86 processor, 64-bits only
+- PS/2 Keyboard
+- Minimum 128MB of memory
+
+## b. Features
+
+## II. Kernel architecture
+
+### a. Boot process
+
+### b. Memory management
+
+### c. Scheduling
+
+### d. Input/Output
+
+## III. Syscall table
+
+Not yet implemented.

include/arch/x86.h

@@ -1,14 +1,17 @@
-/*
- * @author  xamidev <xamidev@riseup.net>
- * @brief   Interrupt Descriptor Table setup and dispatching
- * @license GPL-3.0-only
- */
-
-#ifndef IDT_H
-#define IDT_H
+#ifndef X86_H
+#define X86_H
 
+#include <stdbool.h>
 #include <stdint.h>
 
+uint64_t rdmsr(uint32_t msr);
+void cpuid(uint32_t leaf, uint32_t* eax, uint32_t* ebx, uint32_t* ecx, uint32_t* edx);
+void wrmsr(uint32_t msr, uint64_t value);
+bool x86_has_msr();
+void x86_arch_init();
+
+/* Interrupt Descriptor Table */
+
 void idt_init(void);
 
 struct interrupt_descriptor {
@@ -56,4 +59,6 @@ struct cpu_status_t {
     uint64_t iret_ss;
 };
 
+struct cpu_status_t* syscall_handler(struct cpu_status_t* regs);
+
 #endif

include/config.h

@@ -0,0 +1,59 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   PepperOS configuration file
+ * @license GPL-3.0-only
+ */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/* version */
+#define PEPPEROS_VERSION_MAJOR "0"
+#define PEPPEROS_VERSION_MINOR "0"
+#define PEPPEROS_VERSION_PATCH "58"
+#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"\
+"\x1b[38;5;196m   / __ \\/ _ \\/ __ \\/ __ \\/ _ \\/ ___\x1b[38;5;231m/ / / /\\__ \\ \r\n\x1b[0m"\
+"\x1b[38;5;196m  / /_/ /  __/ /_/ / /_/ /  __/ /  \x1b[38;5;231m/ /_/ /___/ / \r\n\x1b[0m"\
+"\x1b[38;5;196m / .___/\\___/ .___/ .___/\\___/_/   \x1b[38;5;231m\\____//____/  \r\n\x1b[0m"\
+"\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_BASE 0x1000000
+
+/* sched */
+// 1 tick = 1 ms => quantum = 10ms
+#define SCHEDULER_QUANTUM 10
+
+/* kernel */
+#define KERNEL_BASE 0xFFFFFFFF80000000ULL
+// 2 MB should be enough (as of now, the whole kernel ELF is around 75kb)
+#define KERNEL_SIZE 0x200000
+#define KERNEL_STACK_SIZE 65536
+#define KERNEL_IDT_ENTRIES 33
+
+/* paging */
+#define PAGING_MAX_PHYS 0x200000000
+
+/* heap */
+#define KHEAP_SIZE (32*1024*1024)
+
+/* term */
+#define TERM_HISTORY_MAX_LINES 256
+
+/* kbd */
+#define KBD_BUFFER_MAX 256
+
+/* time */
+#define TIMER_FREQUENCY 1000
+
+#endif

include/io/kbd/ps2.h

@@ -7,7 +7,12 @@
 #ifndef PS2_H
 #define PS2_H
 
+#include <stddef.h>
+
 void keyboard_handler(void);
+char keyboard_getchar();
+int keyboard_putchar(char c);
+int keyboard_getline(char* output, size_t size);
 
 #define SHIFT_PRESSED_BIT 0b00000001
 #define ALT_PRESSED_BIT   0b00000010

include/io/term/term.h

@@ -8,8 +8,9 @@
 #define TERM_H
 
 void kputs(const char* str);
-void _putchar(char character);
 void term_init(void);
 int printf(const char* fmt, ...);
+void internal_putc(int c, void *_);
+int kprintf(const char* fmt, ...);
 
 #endif

include/kernel.h

@@ -15,13 +15,13 @@ enum ErrorCodes {
 #define CLEAR_INTERRUPTS __asm__ volatile("cli")
 #define SET_INTERRUPTS __asm__ volatile("sti")
 
-#include "io/serial/serial.h"
-#include "io/term/term.h"
-#include "idt/idt.h"
+#include <io/serial/serial.h>
+#include <io/term/term.h>
+#include <arch/x86.h>
 #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 +38,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);
@@ -58,6 +60,7 @@ struct init_status {
 	bool serial;
 	bool keyboard;
 	bool timer;
+	bool all;
 };
 
 #endif

include/mem/paging.h

@@ -11,7 +11,7 @@
 
 #include <stdint.h>
 #include <limine.h>
-#include "mem/heap/kheap.h"
+#include <mem/kheap.h>
 #include <kernel.h>
 
 void paging_init(struct boot_context boot_ctx);

include/sched/process.h

@@ -8,7 +8,7 @@
 #define PROCESS_H
 
 #include <stddef.h>
-#include "config.h"
+#include <config.h>
 #include <stdint.h>
 
 typedef enum {

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

limine.conf

@@ -1,6 +1,8 @@
 timeout: 3
+interface_branding: Welcome to the PepperOS disk!
 
 /PepperOS
 	protocol: limine
 	
+	comment: Default configuration (warning: spicy)
 	path: boot():/boot/pepperk

src/arch/x86/cpuid.c

@@ -0,0 +1,21 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   x86 CPU identification
+ * @license GPL-3.0-only
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * cpuid - Wrapper for CPUID instruction
+ * @leaf: Requested leaf (input EAX)
+ * @eax: EAX register value (output)
+ * @ebx: EBX register value (output)
+ * @ecx: ECX register value (output)
+ * @edx: EDX register value (output)
+*/
+void cpuid(uint32_t leaf, uint32_t* eax, uint32_t* ebx, uint32_t* ecx, uint32_t* edx)
+{
+    __asm__ volatile("cpuid" : "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx) : "a"(leaf));
+}

src/arch/x86/idt.c

@@ -4,16 +4,16 @@
  * @license GPL-3.0-only
  */
 
-#include "idt.h"
+#include <arch/x86.h>
 #include <stdint.h>
 #include <stddef.h>
-#include "io/serial/serial.h"
-#include "io/kbd/ps2.h"
+#include <io/serial/serial.h>
+#include <io/kbd/ps2.h>
 #include <kernel.h>
 #include <stdbool.h>
-#include "sched/scheduler.h"
-#include "config.h"
-#include "sched/process.h"
+#include <sched/scheduler.h>
+#include <config.h>
+#include <sched/process.h>
 
 struct interrupt_descriptor idt[256];
 struct idtr idt_reg;
@@ -24,6 +24,8 @@ extern char vector_0_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 +74,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, syscall_handler, 0);
+
     idt_load(&idt);
     DEBUG("IDT initialized");
 }
@@ -119,6 +124,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 +172,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,7 +270,7 @@ 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;
 

src/arch/x86/init.c

@@ -0,0 +1,46 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   x86 architecture-dependant initialization
+ * @license GPL-3.0-only
+ */
+
+#include <mem/gdt.h>
+#include <stdint.h>
+#include <arch/x86.h>
+#include <kernel.h>
+
+/*
+ * x86_overwrite_pat - Set PAT to WC
+ *
+ * This function overwrites the 1st Page Attribute
+ * Table entry, to enable the Write-Combining property
+ * when we map memory regions later on.
+ * The framebuffer will be mapped with WC, which makes
+ * memory access significantly faster by using burst
+ * operations. 
+*/
+
+static void x86_overwrite_pat()
+{
+    uint64_t pat = rdmsr(0x277);
+    pat &= ~(0xFFULL << 8); // Clear PAT1
+    pat |= (0x01ULL << 8); // PAT1 = 0x01 (WC)
+    wrmsr(0x277, pat);
+}
+
+/*
+ * x86_arch_init - Initialize x86 CPU structures
+ *
+ * This function is responsible for overriding a PAT entry
+ * (to put the framebuffer area in WC mode) only.
+ *
+ * Later, all architecture-dependant init (GDT, IDT, TSS, ...)
+ * should be initialized here, and separate function pointers
+ * should be set up for each arch.
+ */
+void x86_arch_init()
+{
+    x86_overwrite_pat();
+    idt_init();
+    gdt_init();
+}

src/arch/x86/msr.c

@@ -0,0 +1,66 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   x86 MSR C wrappers
+ * @description
+ * Wrapper functions to access Model Specific Registers
+ *
+ * @license GPL-3.0-only
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <arch/x86.h>
+
+/*
+ * rdmsr - Read from MSR
+ * @msr: model specific register number 
+ *
+ * Read a 64-bit word from a Model Specific Register.
+ * Wrapper for the "rdmsr" instruction. It originally
+ * outputs to two 32-bit registers (EDX:EAX), so the
+ * function does the job of uniting them as a 64-bit
+ * value for us.
+ *
+ * Return:
+ * <value> - value read from MSR
+ */
+uint64_t rdmsr(uint32_t msr)
+{
+    uint32_t low;
+    uint32_t high;
+
+    __asm__ volatile("rdmsr" : "=a"(low), "=d"(high) : "c"(msr));
+
+    return ((uint64_t)high << 32) | low;
+}
+
+/*
+ * wrmsr - Write to MSR
+ * @msr: model specific register number 
+ *
+ * Write a 64-bit value to a Model Specific Register.
+ */
+void wrmsr(uint32_t msr, uint64_t value)
+{
+    uint32_t low = (uint32_t)(value & 0xFFFFFFFF);
+    uint32_t high = (uint32_t)(value >> 32);
+
+    __asm__ volatile("wrmsr" : : "c"(msr), "a"(low), "d"(high) : "memory");
+}
+
+/*
+ * x86_has_msr - Test for MSR support
+ *
+ * Checks if CPU supports Model Specific Registers
+ * using CPUID.01h:EDX[bit 5].
+ *
+ * Return:
+ * true  - MSR are supported
+ * false - MSR are not supported 
+ */
+bool x86_has_msr()
+{
+    uint32_t eax, ebx, ecx, edx;
+    cpuid(1, &eax, &ebx, &ecx, &edx);
+    return (edx & (1 << 5)) != 0;
+}

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/config.h

@@ -1,45 +0,0 @@
-/*
- * @author  xamidev <xamidev@riseup.net>
- * @brief   PepperOS configuration file
- * @license GPL-3.0-only
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-/* version */
-#define PEPPEROS_VERSION_MAJOR "0"
-#define PEPPEROS_VERSION_MINOR "0"
-#define PEPPEROS_VERSION_PATCH "58"
-#define PEPPEROS_SPLASH "\x1b[38;5;196mPepperOS\x1b[0m version "PEPPEROS_VERSION_MAJOR"."PEPPEROS_VERSION_MINOR"."PEPPEROS_VERSION_PATCH"\n"
-
-/* process */
-#define PROCESS_NAME_MAX 64
-#define PROCESS_STACK_SIZE 0x10000 // 64kb
-#define PROCESS_BASE 0x400000
-#define PROCESS_STACK_BASE 0x1000000
-
-/* sched */
-// 1 tick = 1 ms => quantum = 10ms
-#define SCHEDULER_QUANTUM 10
-
-/* kernel */
-#define KERNEL_BASE 0xFFFFFFFF80000000ULL
-// 2 MB should be enough (as of now, the whole kernel ELF is around 75kb)
-#define KERNEL_SIZE 0x200000
-#define KERNEL_STACK_SIZE 65536
-#define KERNEL_IDT_ENTRIES 33
-
-/* paging */
-#define PAGING_MAX_PHYS 0x100000000
-
-/* heap */
-#define KHEAP_SIZE (32*1024*1024)
-
-/* term */
-#define TERM_HISTORY_MAX_LINES 256
-
-/* time */
-#define TIMER_FREQUENCY 1000
-
-#endif

src/debug/misc.c

@@ -5,8 +5,8 @@
  */
 
 #include <kernel.h>
-#include "limine.h"
-#include "string/string.h"
+#include <limine.h>
+#include <string/string.h>
 #include <stddef.h>
 
 extern struct boot_context boot_ctx;

src/debug/panic.c

@@ -5,9 +5,9 @@
  */
 
 #include <stddef.h>
-#include "idt/idt.h"
-#include "io/serial/serial.h"
-#include "kernel.h"
+#include <arch/x86.h>
+#include <io/serial/serial.h>
+#include <kernel.h>
 
 extern struct init_status init;
 extern int panic_count;
@@ -36,27 +36,6 @@ void read_rflags(uint64_t rflags)
 		CHECK_BIT(rflags, 19) ? "VIF " : "", /*virtual interrupt flag*/
 		CHECK_BIT(rflags, 20) ? "VIP " : "", /*virtual interrupt pending*/
 		CHECK_BIT(rflags, 21) ? "ID " : ""); /*id flag*/
-
-	if (init.terminal) {
-		printf("\x1b[38;5;226m%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\x1b[38;5;231m\r\n",
-			CHECK_BIT(rflags, 0) ? "CF " : "",
-			CHECK_BIT(rflags, 2) ? "PF " : "",
-			CHECK_BIT(rflags, 4) ? "AF " : "",
-			CHECK_BIT(rflags, 6) ? "ZF " : "",
-			CHECK_BIT(rflags, 7) ? "SF " : "",
-			CHECK_BIT(rflags, 8) ? "TF " : "",
-			CHECK_BIT(rflags, 9) ? "IF " : "",
-			CHECK_BIT(rflags, 10) ? "DF " : "",
-			CHECK_BIT(rflags, 11) ? "OF " : "",
-			(CHECK_BIT(rflags, 12) && CHECK_BIT(rflags, 13)) ? "IOPL3 " : "IOPL0 ",
-			CHECK_BIT(rflags, 14) ? "NT " : "",
-			CHECK_BIT(rflags, 16) ? "RF " : "",
-			CHECK_BIT(rflags, 17) ? "VM " : "",
-			CHECK_BIT(rflags, 18) ? "AC " : "",
-			CHECK_BIT(rflags, 19) ? "VIF " : "",
-			CHECK_BIT(rflags, 20) ? "VIP " : "",
-			CHECK_BIT(rflags, 21) ? "ID " : "");
-	}
 }
 
 /*

src/debug/stacktrace.c

@@ -5,7 +5,7 @@
  */
 
 #include <stdint.h>
-#include "kernel.h"
+#include <kernel.h>
 #include <stddef.h>
 
 extern struct init_status init;

src/io/kbd/ps2.c

@@ -4,10 +4,11 @@
  * @license GPL-3.0-only
  */
 
-#include "io/serial/serial.h"
-#include "ps2.h"
+#include "config.h"
+#include <io/serial/serial.h>
+#include <io/kbd/ps2.h>
 #include <stdint.h>
-#include "io/term/term.h"
+#include <io/term/term.h>
 #include <kernel.h>
 #include <stddef.h>
 
@@ -18,6 +19,11 @@ uint8_t key_status = 0b00000000;
 unsigned char* keymap;
 unsigned char* keymap_shifted;
 
+// Keyboard buffer
+char keyboard_buffer[KBD_BUFFER_MAX] = {0};
+int write_index = 0;
+int read_index = 0;
+
 extern struct init_status init;
 
 unsigned char kbdus[128] =
@@ -210,10 +216,11 @@ void keyboard_handler()
 
                     if (c) {
                         if (c == '\n') {
-                            _putchar('\r');
+                            internal_putc('\r', NULL);
                         }
-                        // Should probably have a keyboard buffer here... instead of this
-                        _putchar(c);
+
+                        internal_putc(c, NULL);
+                        keyboard_putchar(c);
                     }
                 }
             }
@@ -221,6 +228,79 @@ void keyboard_handler()
     }
 }
 
+/*
+ * keyboard_getchar - Get a character from keyboard
+ *
+ * This function reads one character from the keyboard buffer.
+ * If the keyboard buffer is empty, it will block until a key
+ * is pressed.
+ *
+ * Return:
+ * <char> - character from keyboard buffer
+ */
+char keyboard_getchar()
+{
+    while (read_index == write_index); // Empty buffer
+
+    char c = keyboard_buffer[read_index];
+    read_index = (read_index+1) % KBD_BUFFER_MAX;
+    return c;
+}
+
+/*
+ * keyboard_putchar - Puts a character in the keyboard buffer
+ * @c: character to add
+ *
+ * This function is used in the keyboard handler to add new
+ * characters to the keyboard buffer.
+ *
+ * Return:
+ * %-1 - keyboard buffer is full
+ * %0 - operation completed successfully
+ */
+int keyboard_putchar(char c)
+{
+    if ((write_index+1) % KBD_BUFFER_MAX == read_index) {
+        // Full buffer
+        return -1;
+   }
+   
+   keyboard_buffer[write_index] = c;
+   write_index = (write_index+1) % KBD_BUFFER_MAX;
+   return 0;
+}
+
+/*
+ * keyboard_getline - Gets a line of input from keyboard
+ * @output: Output string
+ * @size:   Size of output string
+ *
+ * Read a line of characters from the keyboard, until the
+ * buffer fills or a newline character is read.
+ * The output string is NULL-terminated.
+ *
+ * Return:
+ * <num> - the number of characters read
+ */
+int keyboard_getline(char* output, size_t size)
+{
+    char c;
+    size_t index = 0;
+    
+    // Read until Enter is pressed
+    while ((c = keyboard_getchar()) != 0x0A) {
+        if (index == size-1) {
+            output[index] = c;
+            output[index+1] = '\0';
+            return index;
+        }
+        output[index] = c;
+        index++;
+    }
+    output[index+1] = '\0';
+    return index;
+}
+
 /*
  * keyboard_init - Keyboard initialization
  * @layout: Desired layout

src/io/serial/serial.c

@@ -5,10 +5,14 @@
  */
  
 #include <kernel.h>
-#include "serial.h"
+#include <io/serial/serial.h>
+#include <sched/spinlock.h>
 
 extern struct init_status init;
 
+extern int panic_count;
+struct spinlock_t serial_lock = {0};
+
 /*
  * outb - Writes a byte to a CPU port
  * @port: CPU port to write to
@@ -61,8 +65,8 @@ int serial_init()
     // Set normal operation mode
     outb(PORT + 4, 0x0F);
 
-    DEBUG("*** Welcome to PepperOS! ***");
     init.serial = true;
+    DEBUG("*** Welcome to PepperOS! (built @ %s %s) ***", __DATE__, __TIME__);
     return 0;
 }
 
@@ -85,9 +89,15 @@ static int is_transmit_empty()
  */
 void skputc(char c)
 {
-    // TODO: Spinlock here (serial access)
+    if (panic_count == 0) {
+        spinlock_acquire(&serial_lock);
         while (!is_transmit_empty()); // wait for free spot
         outb(PORT, c);
+        spinlock_release(&serial_lock);
+    } else {
+        while (!is_transmit_empty());
+        outb(PORT, c);
+    }
 }
 
 /*

src/io/term/flanterm.c

@@ -41,7 +41,7 @@
 #define FLANTERM_IN_FLANTERM
 #endif
 
-#include "flanterm.h"
+#include <io/term/flanterm.h>
 
 // Tries to implement this standard for terminfo
 // https://man7.org/linux/man-pages/man4/console_codes.4.html

src/io/term/flanterm_backends/fb.c

@@ -51,8 +51,8 @@
 #define FLANTERM_IN_FLANTERM
 #endif
 
-#include "../flanterm.h"
-#include "fb.h"
+#include <io/term/flanterm.h>
+#include <io/term/flanterm_backends/fb.h>
 
 void *memset(void *, int, size_t);
 void *memcpy(void *, const void *, size_t);

src/io/term/term.c

@@ -13,36 +13,27 @@ because this shitty implementation will be replaced one day by Flanterm
 
 #include <stddef.h>
 #include <kernel.h>
-#include "term.h"
-#include "config.h"
-#include "flanterm.h"
-#include "flanterm_backends/fb.h"
-#include "mem/heap/kheap.h"
-#include "limine.h"
+#include <io/term/term.h>
+#include <config.h>
+#include <io/term/flanterm.h>
+#include <io/term/flanterm_backends/fb.h>
+#include <mem/kheap.h>
+#include <limine.h>
 #include <stdarg.h>
-#include "sched/spinlock.h"
-#include "io/serial/serial.h"
+#include <sched/spinlock.h>
+#include <io/serial/serial.h>
 
 #define NANOPRINTF_IMPLEMENTATION
-#include "nanoprintf.h"
+#include <io/term/nanoprintf.h>
 
 extern struct flanterm_context* ft_ctx;
 extern struct init_status init;
 
 struct spinlock_t term_lock = {0};
+struct spinlock_t printf_lock = {0};
 
 extern int panic_count;
 
-/*
- * _putchar - Writes a character to terminal (DEPRECATED)
- * @character: character to write
- */
-void _putchar(char character)
-{
-	// TODO: Spinlock here (terminal access)
-	flanterm_write(ft_ctx, &character, 1);
-}
-
 /*
  * internal_putc - Internal putchar function
  * @c: char to print
@@ -74,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
@@ -83,15 +106,59 @@ void internal_putc(int c, void *_)
  *
  * Return:
  * <ret> - number of characters sent to the callback
+ * %-1   - error
  */
 int printf(const char* fmt, ...)
 {
+    if (panic_count == 0) {
+        spinlock_acquire(&printf_lock);
+        va_list args;
+        va_start(args, fmt);
+        int ret = npf_vpprintf(internal_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(internal_putc, NULL, fmt, args);
         va_end(args);
         return ret;
     }
+    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
@@ -103,30 +170,14 @@ void kputs(const char* str)
 {
 	size_t i=0;
 	while (str[i] != 0) {
-		_putchar(str[i]);
+		internal_putc(str[i], NULL);
 		i++;
 	}
-	_putchar('\r');
 }
 
 extern struct flanterm_context* ft_ctx;
 extern struct boot_context boot_ctx;
 
-/*
- * flanterm_free_wrapper - free() wrapper for Flanterm 
- * @ptr:  pointer to free
- * @size: amount of bytes to free
- *
- * This function exists solely because the Flanterm initialization
- * function only accepts a free() function with a size parameter,
- * and the default one doesn't have it.
- */
-void flanterm_free_wrapper(void* ptr, size_t size)
-{
-	(void)size;
-	kfree(ptr);
-}
-
 /*
  * term_init - Video output/terminal initialization
  *
@@ -136,8 +187,8 @@ void term_init()
 {
 	uint32_t bgColor = 0x252525;
 	ft_ctx = flanterm_fb_init(
-        kmalloc,
-        flanterm_free_wrapper,
+        NULL,
+        NULL,
         boot_ctx.fb->address, boot_ctx.fb->width, boot_ctx.fb->height, boot_ctx.fb->pitch,
         boot_ctx.fb->red_mask_size, boot_ctx.fb->red_mask_shift,
         boot_ctx.fb->green_mask_size, boot_ctx.fb->green_mask_shift,

src/kapps/kshell.c

@@ -0,0 +1,56 @@
+/*
+ * @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>
+
+/*
+ * 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\npanic   - trigger a test panic\r\n"
+                            "syscall - trigger int 0x80\r\n"
+                            "pf      - trigger a page fault\r\n");
+            continue;
+        }
+
+        if (strncmp(input_buf, "panic", 5) == 0) {
+            panic(NULL, "test panic");
+        }
+
+        if (strncmp(input_buf, "syscall", 7) == 0) {
+            __asm__ volatile("int $0x80");
+            continue;
+        }
+
+        if (strncmp(input_buf, "pf", 2) == 0) {
+            volatile uint64_t* fault = (uint64_t*)0xdeadbeef;
+            fault[0] = 1;
+        }
+
+        printf("%s: command not found\r\n", input_buf);
+    }
+}

src/kmain.c

@@ -4,27 +4,27 @@
  * @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/term/term.h"
-#include "io/serial/serial.h"
-#include "mem/gdt/gdt.h"
-#include "mem/misc/utils.h"
-#include "idt/idt.h"
-#include "kernel.h"
-#include "time/timer.h"
-#include "io/kbd/ps2.h"
-#include "mem/paging/pmm.h"
-#include "mem/paging/paging.h"
-#include "mem/paging/vmm.h"
-#include "mem/heap/kheap.h"
-#include "sched/process.h"
-#include "sched/scheduler.h"
-#include "config.h"
-#include "io/term/flanterm.h"
-#include "io/term/flanterm_backends/fb.h"
+#include <io/term/term.h>
+#include <io/serial/serial.h>
+#include <mem/gdt.h>
+#include <mem/utils.h>
+#include <kernel.h>
+#include <time/timer.h>
+#include <io/kbd/ps2.h>
+#include <mem/pmm.h>
+#include <mem/paging.h>
+#include <mem/vmm.h>
+#include <mem/kheap.h>
+#include <sched/process.h>
+#include <sched/scheduler.h>
+#include <config.h>
+#include <io/term/flanterm.h>
+#include <io/term/flanterm_backends/fb.h>
+#include <arch/x86.h>
 
 // Limine version used
 __attribute__((used, section(".limine_requests")))
@@ -66,12 +66,6 @@ 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\nWelcome to PepperOS! Pedicel speaking.\r\nNothing left to do, let's go idle!");
-}
-
 void idle_main(void* arg)
 {
 	for (;;) {
@@ -79,6 +73,14 @@ void idle_main(void* arg)
 	}
 }
 
+void thing_main(void* arg)
+{
+	printf("What's your name, pal? ");
+	char name[10];
+	keyboard_getline(name, 10);
+	printf("\r\n{%s} is such a nice name!\r\n", name);
+}
+
 extern uintptr_t kheap_start;
 
 /*
@@ -94,37 +96,33 @@ void kmain()
 	CLEAR_INTERRUPTS;
 	if (!LIMINE_BASE_REVISION_SUPPORTED) hcf();
 
-	serial_init();
-	timer_init();
-
 	// Populate boot context
  	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();
+	timer_init();
+
+	x86_arch_init();
+
 	boot_mem_display();
 	pmm_init(boot_ctx);
 
-	// Remap kernel , HHDM and framebuffer
 	paging_init(boot_ctx);
 	kheap_init();
 
 	keyboard_init(FR);
 	
-	term_init();
-
-	gdt_init();
-	idt_init();
-	
 	process_init();
 	idle_proc = process_create("idle", (void*)idle_main, 0);
-	struct process_t* pedicel = process_create("pedicel", (void*)pedicel_main, 0);
-
-	process_display_list(processes_list);
+	process_create("pedicel", (void*)pedicel_main, 0);
 
 	scheduler_init();
 
-	kputs(PEPPEROS_SPLASH);
+	printf(PEPPEROS_SPLASH);
+	init.all = true;
 	idle();
 }

src/mem/gdt.c

@@ -4,9 +4,9 @@
  * @license GPL-3.0-only
  */
 
-#include "gdt.h"
+#include <mem/gdt.h>
 #include <stdint.h>
-#include "io/serial/serial.h"
+#include <io/serial/serial.h>
 #include <kernel.h>
 
 // Descriptors are 8-byte wide (64bits)

src/mem/kheap.c

@@ -4,13 +4,13 @@
  * @license GPL-3.0-only
  */
 
-#include "kheap.h"
-#include "mem/paging/paging.h"
-#include "mem/paging/pmm.h"
+#include <mem/kheap.h>
+#include <mem/paging.h>
+#include <mem/pmm.h>
 #include <stddef.h>
 #include <kernel.h>
-#include "sched/process.h"
-#include "config.h"
+#include <sched/process.h>
+#include <config.h>
 
 extern uint64_t kernel_phys_base;
 extern uint64_t kernel_virt_base;

src/mem/paging.c

@@ -4,12 +4,12 @@
  * @license GPL-3.0-only
  */
 
-#include "paging.h"
-#include "pmm.h"
+#include <mem/paging.h>
+#include <mem/pmm.h>
 #include <kernel.h>
 #include <stddef.h>
 #include <limine.h>
-#include "config.h"
+#include <config.h>
 
 /*
 Paging on x86 uses four different page table levels:
@@ -173,9 +173,9 @@ void paging_init(struct boot_context boot_ctx)
         }
     }
 
-    // 4GB
+    // 8GB
     if (max_phys > PAGING_MAX_PHYS) {
-        DEBUG("WARNING: max_phys capped to 4GB (%x) (from max_phys=%p)", PAGING_MAX_PHYS, max_phys);
+        DEBUG("WARNING: max_phys capped to PAGING_MAX_PHYS (from max_phys=%p)", max_phys);
         max_phys = PAGING_MAX_PHYS;
     }
 
@@ -202,9 +202,9 @@ void paging_init(struct boot_context boot_ctx)
     uint64_t fb_size = fb->pitch * fb->height;
     uint64_t fb_pages = (fb_size + PAGE_SIZE-1)/PAGE_SIZE;
 
-    // Map the framebuffer (with cache-disable & write-through)
+    // Map the framebuffer (PWT set, and no PCD means PAT1 [Write-Combining] for this region)
     for (uint64_t i=0; i<fb_pages; i++) {
-        paging_map_page(kernel_pml4, fb_virt+i*PAGE_SIZE, fb_phys+i*PAGE_SIZE, PTE_WRITABLE | PTE_PCD | PTE_PWT);
+        paging_map_page(kernel_pml4, fb_virt+i*PAGE_SIZE, fb_phys+i*PAGE_SIZE, PTE_WRITABLE | PTE_PWT);
         page_count++;
     }
     DEBUG("Mapped %u pages for framebuffer", page_count);

src/mem/pmm.c

@@ -11,55 +11,20 @@ it will probably need to get some info from Limine,
 to see which pages are used by kernel/bootloader/mmio/fb etc.
 */
 
-#include "paging.h"
+#include "config.h"
+#include <mem/paging.h>
 #include <limine.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <kernel.h>
-#include "mem/misc/utils.h"
-#include "pmm.h"
+#include <mem/utils.h>
+#include <mem/pmm.h>
 
 /*
 First we'll have to discover the physical memory layout,
 and for that we can use a Limine request.
 */
 
-struct limine_memmap_entry* biggest_entry;
-
-/*
- * pmm_find_biggest_usable_region - Finding the biggest free memory region
- * @memmap: Limine memory map
- * @hhdm:   Limine HHDM offset
- *
- * This function uses the memory map provided by the bootloader
- * to find the single biggest free memory region we can use.
- */
-static void pmm_find_biggest_usable_region(struct limine_memmap_response* memmap, struct limine_hhdm_response* hhdm)
-{
-    // Max length of a usable memory region
-    uint64_t length_max = 0;
-    uint64_t offset = hhdm->offset;
-
-    DEBUG("Usable Memory:");
-    for (size_t i=0; i<memmap->entry_count; i++) {
-        struct limine_memmap_entry* entry = memmap->entries[i];
-
-        if (entry->type == LIMINE_MEMMAP_USABLE) {
-            DEBUG("0x%p-0x%p mapped at 0x%p-0x%p", entry->base, entry->base+entry->length,
-                        entry->base+offset, entry->base+entry->length+offset);
-            if (entry->length > length_max)
-            {
-                length_max = entry->length;
-                biggest_entry = entry;
-            }
-        }
-    }
-
-    DEBUG("Biggest usable memory region:");
-    DEBUG("0x%p-0x%p mapped at 0x%p-0x%p", biggest_entry->base, biggest_entry->base + biggest_entry->length,
-            biggest_entry->base+offset, biggest_entry->base+biggest_entry->length+offset);
-}
-
 // Offset from Higher Half Direct Map
 uint64_t hhdm_off;
 
@@ -99,19 +64,32 @@ void pmm_free(uintptr_t addr)
  * This function marks the biggest memory region as
  * free, so we can use it in pmm_alloc.
  */
-static void pmm_init_freelist()
+static void pmm_init_freelist(struct limine_memmap_response* memmap)
 {
-    // We simply call pmm_free() on each page that is marked USABLE
-    // in our big memory region.
-    uint64_t base = ALIGN_UP(biggest_entry->base, PAGE_SIZE);
-    uint64_t end = ALIGN_DOWN(biggest_entry->base + biggest_entry->length, PAGE_SIZE);
+    uint64_t total_pages = 0;
+
+    for (size_t i=0; i<memmap->entry_count; i++) {
+        struct limine_memmap_entry* entry = memmap->entries[i];
+
+        if (entry->type == LIMINE_MEMMAP_USABLE) {
+            uint64_t base = ALIGN_UP(entry->base, PAGE_SIZE);
+            uint64_t end = ALIGN_DOWN(entry->base + entry->length, PAGE_SIZE);
+
+            if (end > PAGING_MAX_PHYS) {
+                end = PAGING_MAX_PHYS;
+            }
+
+            // Region above PAGING_MAX_PHYS
+            if (base >= end) continue;
 
-    uint64_t page_count=0;
             for (uint64_t addr = base; addr < end; addr += PAGE_SIZE) {
                 pmm_free(addr);
-        page_count++;
+                total_pages++;
             }
-    DEBUG("%u frames in freelist, available for use (%u bytes)", page_count, page_count*PAGE_SIZE);
+        }
+    }
+
+    DEBUG("%u frames in freelist, %u bytes available (%u MB)", total_pages, total_pages*PAGE_SIZE, total_pages*PAGE_SIZE/1000000);
 }
 
 /*
@@ -124,9 +102,9 @@ static void pmm_init_freelist()
 void pmm_init(struct boot_context boot_ctx)
 {
     hhdm_off = boot_ctx.hhdm->offset;
-    pmm_find_biggest_usable_region(boot_ctx.mmap, boot_ctx.hhdm);
+    //pmm_find_biggest_usable_region(boot_ctx.mmap, boot_ctx.hhdm);
 
     // Now we have biggest USABLE region,
     // so to populate the free list we just iterate through it
-    pmm_init_freelist();
+    pmm_init_freelist(boot_ctx.mmap);
 }

src/mem/utils.c

@@ -7,8 +7,8 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <limine.h>
-#include "kernel.h"
-#include "string/string.h"
+#include <kernel.h>
+#include <string/string.h>
 
 // We won't be linked to standard library, but still need the basic mem* functions
 // so everything goes allright with the compiler

src/mem/vmm.c

@@ -13,10 +13,10 @@ in a specified virtual space
 compared to the PMM which allocs/frees 4kb frames ("physical pages").
 */
 
-#include "vmm.h"
-#include "paging.h"
+#include <mem/vmm.h>
+#include <mem/paging.h>
 #include <stddef.h>
-#include "pmm.h"
+#include <mem/pmm.h>
 #include <kernel.h>
 
 void* vmm_pt_root = 0;

src/sched/process.c

@@ -5,15 +5,15 @@
  */
 
 #include <stddef.h>
-#include "process.h"
-#include "mem/heap/kheap.h"
-#include "kernel.h"
-#include "string/string.h"
-#include "mem/gdt/gdt.h"
-#include "config.h"
-#include "io/serial/serial.h"
+#include <sched/process.h>
+#include <mem/kheap.h>
+#include <kernel.h>
+#include <string/string.h>
+#include <mem/gdt.h>
+#include <config.h>
+#include <io/serial/serial.h>
 
-#include "io/term/flanterm.h"
+#include <io/term/flanterm.h>
 extern struct flanterm_context* ft_ctx;
 
 struct process_t* processes_list;

src/sched/scheduler.c

@@ -4,11 +4,11 @@
  * @license GPL-3.0-only
  */
 
-#include "kernel.h"
-#include "process.h"
-#include "mem/paging/paging.h"
+#include <kernel.h>
+#include <sched/process.h>
+#include <mem/paging.h>
 #include <stdint.h>
-#include "io/serial/serial.h"
+#include <io/serial/serial.h>
 
 extern struct process_t* processes_list;
 extern struct process_t* current_process;
@@ -49,7 +49,6 @@ struct cpu_status_t* scheduler_schedule(struct cpu_status_t* context)
     }
 
     current_process->context = context;
-    //current_process->status = READY;
 
     for (;;) {
         struct process_t* prev_process = current_process;
@@ -65,14 +64,17 @@ struct cpu_status_t* scheduler_schedule(struct cpu_status_t* context)
             return idle_proc->context;
         } else {
             current_process->status = RUNNING;
+/*             if (prev_process != current_process) {
+                DEBUG("Changed from {pid=%u, name=%s} to {pid=%u, name=%s}", prev_process->pid, prev_process->name, current_process->pid, current_process->name);
+            } */
             break;
         }
     }
 
-    DEBUG("current_process={pid=%u, name='%s', root_page_table[virt]=%p}", current_process->pid, current_process->name, current_process->root_page_table);
+    //DEBUG("current_process={pid=%u, name='%s', root_page_table[virt]=%p}", current_process->pid, current_process->name, current_process->root_page_table);
 
     load_cr3(VIRT_TO_PHYS((uint64_t)current_process->root_page_table));
-    DEBUG("Loaded process PML4 into CR3");
+    //DEBUG("Loaded process PML4 into CR3");
 
     return current_process->context;
 }

src/sched/spinlock.c

@@ -6,8 +6,8 @@
 
 #include <stdatomic.h>
 #include <stdbool.h>
-#include "kernel.h"
-#include "spinlock.h"
+#include <kernel.h>
+#include <sched/spinlock.h>
 
 /*
  * spinlock_acquire - Lock a lock

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/timer.c

@@ -5,9 +5,9 @@
  */
 
 #include <stdint.h>
-#include "io/serial/serial.h"
+#include <io/serial/serial.h>
 #include <kernel.h>
-#include "config.h"
+#include <config.h>
 
 /*
 For now, the timer module will be using the PIC.