better panic

Reviewed-on: #9

Makefile

@@ -1,8 +1,10 @@
-SOURCES = 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/printf.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
+SOURCES = 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/printf.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
+
+PROBLEMATIC_FLAGS=-Wno-unused-parameter -Wno-unused-variable
 
 build:
 	rm -f *.o
-	x86_64-elf-gcc -g -c -Isrc $(SOURCES) -Wall -Wextra -std=gnu99 -nostdlib -ffreestanding -fno-stack-protector -fno-stack-check -fno-PIC -ffunction-sections -fdata-sections -mcmodel=kernel
+	x86_64-elf-gcc -g -c -Isrc $(SOURCES) $(PROBLEMATIC_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
 	objcopy -O elf64-x86-64 -B i386 -I binary zap-light16.psf zap-light16.o
 	nasm -f elf64 src/idt/idt.S -o idt_stub.o
 	x86_64-elf-ld -o pepperk -T linker.ld *.o

README.md

@@ -11,18 +11,27 @@ To run it with QEMU, `make run`
 
 The basics that I'm targeting are:
 
+### Basic utility of what we call a "kernel"
+
 - Fix terminal driver (backspace issues, scrolling) OR add Flanterm or equivalent
-- Implement paging / see what Limine does at boot with memory management
+- Implement tasks, and task switching + context switching and spinlock acquire/release
-- Implement tasks, and task switching
 - Load an executable
-- Scheduler (round-robin using the PIT timer interrupt)
+- Filesystem (TAR for read-only initfs, then maybe read-write using FAT12/16/32 or easier fs) w/ VFS layer
-- Filesystem (TAR for read-only initfs, then maybe read-write using FAT12/16/32
 - Getting to userspace (syscalls)
 - Porting musl libc or equivalent
 
-In the future, maybe?
+### Scalability/maintenance/expansion features
 
-- SMP support
+- Documentation
+- SOME error handling in functions
+- Unit tests
+- Good error codes (like Linux kernel: ENOMEM, ENOENT, ...)
+- Make the panic function work within itself without dependencies + error message (and still get cpu context?)
+
+### Optional features
+
+In the future, maybe?
+- SMP support (Limine provides functionality to make this easier)
 - Parsing the ACPI tables and using them for something
 - Replacing the PIT timer with APIC
 

debug.gdb

@@ -1,3 +1,3 @@
 target remote localhost:1234
 set disassembly-flavor intel
-display/8i $rip
+display/4i $rip

src/boot/boot.c

@@ -0,0 +1,41 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Limine requests for boot
+ * @license GPL-3.0-only
+ */
+
+#include <limine.h>
+
+// Framebuffer request
+__attribute__((used, section(".limine_requests")))
+volatile struct limine_framebuffer_request framebuffer_request = {
+	.id = LIMINE_FRAMEBUFFER_REQUEST,
+	.revision = 0
+};
+
+// Memory map request
+__attribute__((used, section(".limine_requests")))
+volatile struct limine_memmap_request memmap_request = {
+	.id = LIMINE_MEMMAP_REQUEST,
+	.revision = 0
+};
+
+// Higher Half Direct Map
+__attribute__((used, section(".limine_requests")))
+volatile struct limine_hhdm_request hhdm_request = {
+	.id = LIMINE_HHDM_REQUEST,
+	.revision = 0
+};
+
+// Executable Address/Kernel Address (find base phys/virt address of kernel)
+__attribute__((used, section(".limine_requests")))
+volatile struct limine_kernel_address_request kerneladdr_request = {
+	.id = LIMINE_KERNEL_ADDRESS_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;

src/config.h

@@ -0,0 +1,37 @@
+/*
+ * @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 "1"
+#define PEPPEROS_SPLASH "pepperOS 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
+
+/* heap */
+#define KHEAP_SIZE (16*1024*1024)
+
+/* term */
+#define TERM_HISTORY_MAX_LINES 256
+
+#endif

src/idt/idt.S

@@ -1,4 +1,8 @@
-; Assembly stub for the IDT
+;
+;  @author  xamidev <xamidev@riseup.net>
+;  @brief   Stub for Interrupt Descriptor Table handlers
+;  @license GPL-3.0-only
+;
 
 bits 64
 

src/idt/idt.c

@@ -1,9 +1,18 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Interrupt Descriptor Table setup and dispatching
+ * @license GPL-3.0-only
+ */
+
 #include "idt.h"
 #include <stdint.h>
 #include <stddef.h>
 #include "io/serial/serial.h"
 #include "io/kbd/ps2.h"
 #include <kernel.h>
+#include <stdbool.h>
+#include "sched/scheduler.h"
+#include "config.h"
 
 struct interrupt_descriptor idt[256];
 struct idtr idt_reg;
@@ -53,6 +62,60 @@ void idt_init()
     DEBUG("IDT initialized");
 }
 
+static inline uint64_t read_cr2(void)
+{
+    uint64_t val;
+    asm volatile ("mov %%cr2, %0" : "=r"(val));
+    return val;
+}
+
+static void page_fault_handler(struct cpu_status_t* ctx)
+{
+    // It could be used to remap pages etc. to fix the fault, but right now what I'm more
+    // interested in is getting more info out of those numbers cause i'm lost each time i have 
+    // to read all this mess
+    uint64_t cr2 = read_cr2();
+    
+    DEBUG("\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");
+}
+
+static void gp_fault_handler(struct cpu_status_t* ctx)
+{
+    DEBUG("\x1b[38;5;231mGeneral Protection Fault at rip=0x%p, err=%u (%s)\x1b[0m",
+    ctx->iret_rip,
+    ctx->error_code,
+    (ctx->error_code == 0) ? "NOT_SEGMENT_RELATED" : "SEGMENT_RELATED");
+
+    // Segment-related
+    if (ctx->error_code != 0)
+    {
+        bool is_external = CHECK_BIT(ctx->error_code, 0);
+        // is it IDT, GDT, LDT?
+        uint8_t table = ctx->error_code & 0x6; // 0b110 (isolate table)
+        uint16_t index = ctx->error_code & 0xFFF8; // 13*1 1111111111111 + 000 = 1111111111111000
+    
+        char* table_names[4] = {"GDT", "IDT", "LDT", "IDT"};
+
+        DEBUG("\x1b[38;5;231m%s in %s index %u\x1b[0m",
+        is_external ? "EXTERNAL" : "INTERNAL",
+        table_names[table],
+        index);
+    }
+
+    panic(ctx, "gp fault");
+}
+
 struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context)
 {
     switch(context->vector_number)
@@ -97,10 +160,11 @@ struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context)
             DEBUG("Stack-Segment Fault!");
             break;
         case 13:
-            DEBUG("General Protection Fault!");
+            gp_fault_handler(context);
             break;
         case 14:
-            DEBUG("Page Fault!");
+            // Better debugging for page faults...
+            page_fault_handler(context);
             break;
         case 15:
             DEBUG("Intel Reserved Interrupt! (Achievement unlocked: How Did We Get Here?)");
@@ -124,14 +188,22 @@ struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context)
             DEBUG("Control Protection Exception!");
             break;
 
-        case 32:
+        case 32: // Timer Interrupt
-            //DEBUG("Tick!");
             ticks++;
+
+            if (ticks % SCHEDULER_QUANTUM == 0)
+            {
+                CLEAR_INTERRUPTS;
+                scheduler_schedule();
+                SET_INTERRUPTS;
+            }
+
             // Send an EOI so that we can continue having interrupts
             outb(0x20, 0x20);
             break;
 
         case 33:
+            DEBUG("Keyboard Interrupt");
             keyboard_handler();
             break;
 

src/idt/idt.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Interrupt Descriptor Table setup and dispatching
+ * @license GPL-3.0-only
+ */
+
 #ifndef IDT_H
 #define IDT_H
 

src/io/kbd/ps2.c

@@ -1,4 +1,8 @@
-// PS/2 Keyboard support
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   PS/2 Keyboard driver
+ * @license GPL-3.0-only
+ */
 
 #include "io/serial/serial.h"
 #include "ps2.h"
@@ -201,12 +205,11 @@ void keyboard_handler()
 
                 if (c)
                 {
+                    // Should probably have a keyboard buffer here... instead of this
                     putchar(c);
                 }
             }
         }
-
-        skputs("key pressed!\n");
     }
 
     // End of Interrupt (to master PIC)
@@ -233,5 +236,11 @@ void keyboard_init(unsigned char layout)
             skputs("Unsupported layout.");
             return;
     }
+
+    // Unmask IRQ1
+    uint8_t mask = inb(0x21);
+    mask &= ~(1 << 1);
+    outb(0x21, mask);
+
     DEBUG("PS/2 Keyboard initialized");
 }

src/io/kbd/ps2.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   PS/2 Keyboard driver
+ * @license GPL-3.0-only
+ */
+
 #ifndef PS2_H
 #define PS2_H
 

src/io/serial/serial.c

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Debug serial driver
+ * @license GPL-3.0-only
+ */
+ 
 #include <kernel.h>
 #include "serial.h"
 

src/io/serial/serial.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Debug serial driver
+ * @license GPL-3.0-only
+ */
+
 #ifndef SERIAL_H
 #define SERIAL_H
 

src/io/term/term.c

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Framebuffer-based terminal driver
+ * @license GPL-3.0-only
+ */
+
 // Terminal output
 /*
 There are a couple of bugs here and there but for now I don't care too much
@@ -9,8 +15,10 @@ because this shitty implementation will be replaced one day by Flanterm
 #include <stddef.h>
 #include <kernel.h>
 #include "term.h"
+#include "mem/misc/utils.h"
+#include "config.h"
 
-extern struct limine_framebuffer* framebuffer;
+extern struct boot_context boot_ctx;
 
 // Importing the PSF object file
 extern unsigned char _binary_zap_light16_psf_start[];
@@ -22,61 +30,88 @@ uint8_t* glyphs = _binary_zap_light16_psf_start + sizeof(PSF1_Header);
 #define FONT_WIDTH 8
 #define FONT_HEIGHT font->characterSize
 
+
+
 // Character cursor
 typedef struct
 {
-	unsigned int x;
+	size_t x;
-	unsigned int y;
+	size_t y;
 } Cursor;
 
-Cursor cursor = {0};
+static Cursor cursor = {0, 0};
 
-unsigned char* fb;
+static uint8_t* fb;
+static struct limine_framebuffer* framebuffer;
+
+uint8_t lines_length[TERM_HISTORY_MAX_LINES];
+
+static inline size_t term_max_cols(void)
+{
+	return framebuffer->width / FONT_WIDTH;
+}
+
+static inline size_t term_max_lines(void)
+{
+	return framebuffer->height / FONT_HEIGHT;
+}
 
 int term_init()
 {
 	// Get framebuffer address from Limine struct
 	
-	if (framebuffer)
+	if (!boot_ctx.fb)
 	{
-		fb = framebuffer->address;
-		DEBUG("terminal initialized");
-		return 0;
-	}
 		return -ENOMEM;
 	}
 
+	framebuffer = boot_ctx.fb;
+	fb = (uint8_t*)framebuffer->address;
+
+	memset(lines_length, 0, sizeof(lines_length));
+
+	DEBUG("terminal initialized, fb=0x%p (width=%u height=%u pitch=%u bpp=%u)", fb, framebuffer->width, framebuffer->height, framebuffer->pitch, framebuffer->bpp);
+	return 0;
+}
+
 // These are marked "static" because we don't wanna expose them all around
 // AKA they should just be seen here (kind of like private functions in cpp)
-static void putpixel(int x, int y, int color)
+static inline void putpixel(size_t x, size_t y, uint32_t color)
 {
+	// Guard so we don't write past fb boundaries
+	if (x >= framebuffer->width || y >= framebuffer->height) return;
 	// Depth isn't part of limine_framebuffer attributes so it will be 4
-	unsigned pos = x*4 + y*framebuffer->pitch;
+	size_t pos = x*4 + y*framebuffer->pitch;
 	fb[pos] = color & 255; // blue channel
 	fb[pos+1] = (color >> 8) & 255; // green
 	fb[pos+2] = (color >> 16) & 255; // blue
 }
 
-static void draw_char(char c, int px, int py, int fg, int bg)
+static void draw_char(char c, size_t px, size_t py, uint32_t fg, uint32_t bg)
 {
+	// So we cannot write past fb
+	if (px+FONT_WIDTH > framebuffer->width || py+FONT_HEIGHT > framebuffer->height) return;
+
 	uint8_t* glyph = glyphs + ((unsigned char)c * FONT_HEIGHT);
 
 	for (size_t y=0; y<FONT_HEIGHT; y++)
 	{
 		uint8_t row = glyph[y];
-		for (size_t x=0; x<8; x++)
+		for (size_t x=0; x<FONT_WIDTH; x++)
 		{
-			int color = (row & (0x80 >> x)) ? fg : bg;
+			uint32_t color = (row & (0x80 >> x)) ? fg : bg;
 			putpixel(px+x, py+y, color);
 		}
 	}
 }
 
-static void erase_char(int px, int py)
+static void erase_char(size_t px, size_t py)
 {
+	if (px+FONT_WIDTH > framebuffer->width || py+FONT_HEIGHT > framebuffer->height) return;
+
 	for (size_t y=0; y<FONT_HEIGHT; y++)
 	{
-		for (size_t x=0; x<8; x++)
+		for (size_t x=0; x<FONT_WIDTH; x++)
 		{
 			// Black
 			putpixel(px+x, py+y, 0);
@@ -84,50 +119,81 @@ static void erase_char(int px, int py)
 	}
 }
 
+void term_scroll()
+{
+	// Erase first text line
+	memset(fb, 255, FONT_HEIGHT*framebuffer->pitch);
+
+	// Move whole framebuffer up by one text line
+	memmove(fb, fb+(FONT_HEIGHT*framebuffer->pitch), (framebuffer->height-FONT_HEIGHT)*framebuffer->pitch);
+
+	// Clear last text line
+	size_t clear_start = (framebuffer->height - FONT_HEIGHT) * framebuffer->pitch;
+	memset(fb + clear_start, 255, FONT_HEIGHT * framebuffer->pitch);
+
+	// Shift line lengths by 1 (for backspace handling)
+	size_t max_lines = term_max_lines();
+	for (size_t i = 1; i < max_lines; i++)
+	{
+		lines_length[i - 1] = lines_length[i];
+	}
+	lines_length[max_lines - 1] = 0;
+}
+
 void putchar(char c)
 {
-	if (c == '\n')
+	const size_t max_cols = term_max_cols();
-	{
+	const size_t max_lines = term_max_lines();
+
+	if (c == '\n') {
+		lines_length[cursor.y] = cursor.x;
 		cursor.x = 0;
+
+		if (cursor.y + 1 >= max_lines)
+		{
+			term_scroll();
+		}
+		else
+		{
 			cursor.y++;
+		}
 		return;
 	}
 
-	// TODO: Improperly handled.
-	// When we're on an empty line it should get to the upper line's last character
-	// NOT just the last position possible; we would need to track the last line's character amount for that
 	if (c == '\b') 
 	{
-		if (cursor.x == 0 && cursor.y == 0)
+		if (cursor.x > 0) 
 		{
-			// Top-left corner
-			return;
-		}
-
-		if (cursor.x == 0)
-		{
-			cursor.y--;
-			cursor.x = (framebuffer->width / FONT_WIDTH) -1; // here
-		}
-		else {
 			cursor.x--;
 		}
-
+		else if (cursor.y > 0)
-		int px = cursor.x * FONT_WIDTH;
+		{
-		int py = cursor.y * FONT_HEIGHT;
+			cursor.y--;
-		erase_char(px, py);
+			cursor.x = lines_length[cursor.y];
+		}
+		else
+		{
 			return;
 		}
 
-	if ((cursor.x+1)*FONT_WIDTH >= framebuffer->width)
+		erase_char(cursor.x * FONT_WIDTH, cursor.y * FONT_HEIGHT);
-	{
+		return;
-		cursor.x = 0;
-		cursor.y++;
 	}
 
-	int px = cursor.x * FONT_WIDTH;
+	if (cursor.x >= max_cols) 
-	int py = cursor.y * FONT_HEIGHT;
+	{
-	draw_char(c, px, py, WHITE, BLACK);
+		cursor.x = 0;
+		if (cursor.y + 1 >= max_lines)
+		{
+			term_scroll();
+		}
+		else
+		{
+			cursor.y++;
+		}
+	}
+
+	draw_char(c, cursor.x * FONT_WIDTH, cursor.y * FONT_HEIGHT, WHITE, BLACK);
 	cursor.x++;
 }
 
@@ -140,7 +206,7 @@ void _putchar(char character)
 // Debug-printing
 void kputs(const char* str)
 {
-	unsigned int i=0;
+	size_t i=0;
 	while (str[i] != 0)
 	{
 		putchar(str[i]);

src/io/term/term.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Framebuffer-based terminal driver
+ * @license GPL-3.0-only
+ */
+
 #ifndef TERM_H
 #define TERM_H
 
@@ -20,4 +26,7 @@ typedef struct
     uint8_t characterSize; // height
 } PSF1_Header;
 
+// debug 
+void term_scroll();
+
 #endif

src/kernel.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Kernel global macros
+ * @license GPL-3.0-only
+ */
+
 #ifndef KERNEL_H
 #define KERNEL_H
 
@@ -12,12 +18,26 @@ enum ErrorCodes
 
 #include "io/serial/serial.h"
 #include "io/term/printf.h"
+#include "idt/idt.h"
 
 #define DEBUG(log, ...) fctprintf((void*)&skputc, 0, "debug: [%s]: " log "\r\n", __FILE__, ##__VA_ARGS__)
 
+#define DIE_DEBUG(str) fctprintf((void*)&skputc, 0, str)
+
+#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))
+
 // printf("debug: [%s]: " log "\n", __FILE__, ##__VA_ARGS__);
 
+void panic(struct cpu_status_t* ctx, const char* str);
 void hcf();
 #define assert(check) do { if(!(check)) hcf(); } while(0)
 
+struct boot_context
+{
+	struct limine_framebuffer* fb;
+	struct limine_memmap_response* mmap;
+	struct limine_hhdm_response* hhdm;
+	struct limine_kernel_address_response* kaddr;
+};
+
 #endif

src/kmain.c

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   PepperOS kernel entry point
+ * @license GPL-3.0-only
+ */
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <limine.h>
@@ -14,106 +20,110 @@
 #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"
 
 // Limine version used
 __attribute__((used, section(".limine_requests")))
-static volatile LIMINE_BASE_REVISION(3);
+volatile LIMINE_BASE_REVISION(3);
 
-// Framebuffer request
+// Halt and catch fire (makes machine stall)
-__attribute__((used, section(".limine_requests")))
-static volatile struct limine_framebuffer_request framebuffer_request = {
-	.id = LIMINE_FRAMEBUFFER_REQUEST,
-	.revision = 0
-};
-
-// Memory map request
-__attribute__((used, section(".limine_requests")))
-static volatile struct limine_memmap_request memmap_request = {
-	.id = LIMINE_MEMMAP_REQUEST,
-	.revision = 0
-};
-
-// Higher Half Direct Map
-__attribute__((used, section(".limine_requests")))
-static volatile struct limine_hhdm_request hhdm_request = {
-	.id = LIMINE_HHDM_REQUEST,
-	.revision = 0
-};
-
-// Executable Address/Kernel Address (find base phys/virt address of kernel)
-__attribute__((used, section(".limine_requests")))
-static volatile struct limine_kernel_address_request kerneladdr_request = {
-	.id = LIMINE_KERNEL_ADDRESS_REQUEST,
-	.revision = 0
-};
-
-__attribute__((used, section(".limine_requests_start")))
-static volatile LIMINE_REQUESTS_START_MARKER;
-
-__attribute__((used, section(".limine_requests_end")))
-static volatile LIMINE_REQUESTS_END_MARKER;
-
-struct limine_framebuffer* framebuffer;
-
-// Panic (should dump registers etc. in the future)
 void hcf()
 {
-	for (;;)
+	CLEAR_INTERRUPTS; for (;;)asm("hlt");
-	{
-		asm("hlt");
 }
+
+// Doing nothing (can be interrupted)
+void idle() {for(;;)asm("hlt");}
+
+void panic(struct cpu_status_t* ctx, const char* str)
+{
+	CLEAR_INTERRUPTS;
+	if (ctx == NULL)
+	{
+		DEBUG("\x1b[38;5;231m\x1b[48;5;196mKernel panic!!!\x1b[0m Something went horribly wrong! (no cpu ctx)");
+		DIE_DEBUG(str);
+		skputc('\n');
+		DEBUG("\x1b[38;5;231m\x1b[48;5;196mend Kernel panic - halting...\x1b[0m");
+		hcf();
+	}
+	DEBUG("\x1b[38;5;231m\x1b[48;5;196mKernel panic!!!\x1b[0m at rip=%p\nSomething went horribly wrong! vect=0x%.2x errcode=0x%x\n\rrax=%p rbx=%p rcx=%p rdx=%p\n\rrsi=%p rdi=%p  r8=%p  r9=%p\n\rr10=%p r11=%p r12=%p r13=%p\n\rr14=%p r15=%p\n\n\rflags=%p\n\rstack at rbp=%p\n\rHalting...",
+		ctx->iret_rip,
+		ctx->vector_number, ctx->error_code, ctx->rax, ctx->rbx, ctx->rcx, ctx->rdx, ctx->rsi, ctx->rdi,
+		ctx->r8, ctx->r9, ctx->r10, ctx->r11, ctx->r12, ctx->r13, ctx->r14, ctx->r15, ctx->iret_flags,
+		ctx->rbp);
+	hcf();
+}
+
+struct boot_context boot_ctx;
+
+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 struct process_t* processes_list;
+extern struct process_t* current_process;
+
+void pedicel_main(void* arg)
+{
+	panic(NULL, "we did it!");
+}
+
+void two_main(void* arg)
+{
+
+}
+
+void three_main(void* arg)
+{
+
 }
 
 // This is our entry point
 void kmain()
 {
 	if (!LIMINE_BASE_REVISION_SUPPORTED) hcf();
-	if (framebuffer_request.response == NULL || framebuffer_request.response->framebuffer_count < 1) hcf();
 
-	// We should probably grab all the boot info in a boot context struct
+	// Populate boot context
-	// that would be a bit cleaner than this mess
+ 	boot_ctx.fb = framebuffer_request.response ? framebuffer_request.response->framebuffers[0] : NULL;
-
+	boot_ctx.mmap = memmap_request.response ? memmap_request.response : NULL;
-	// Get the first framebuffer from the response
+	boot_ctx.hhdm = hhdm_request.response ? hhdm_request.response : NULL;
-	framebuffer = framebuffer_request.response->framebuffers[0];
+	boot_ctx.kaddr = kerneladdr_request.response ? kerneladdr_request.response : NULL;
 
 	serial_init();
 
-	if (memmap_request.response == NULL) hcf();
+	memmap_display(boot_ctx.mmap);
-	memmap_display(memmap_request.response);
+	hhdm_display(boot_ctx.hhdm);
-
+	DEBUG("kernel: phys_base=0x%p virt_base=0x%p", boot_ctx.kaddr->physical_base, boot_ctx.kaddr->virtual_base);
-	if (hhdm_request.response == NULL) hcf();
-	hhdm_display(hhdm_request.response);
-
-	if (kerneladdr_request.response == NULL) hcf();
-	DEBUG("kernel: phys_base=0x%p virt_base=0x%p", kerneladdr_request.response->physical_base, kerneladdr_request.response->virtual_base);
 
 	CLEAR_INTERRUPTS;
 	gdt_init();
 	idt_init();
 	timer_init();
-	SET_INTERRUPTS;
 
-	pmm_init(memmap_request.response, hhdm_request.response);
+	pmm_init(boot_ctx.mmap, boot_ctx.hhdm);
 
 	// Remap kernel , HHDM and framebuffer
-	paging_init(kerneladdr_request.response, framebuffer);
+	paging_init(boot_ctx.kaddr, boot_ctx.fb);
 	
 	kheap_init();
 
-	void* ptr = kmalloc(10); DEBUG("(KMALLOC TEST) Allocated 10 bytes at 0x%p", ptr);
-	void* ptr2 = kmalloc(200); DEBUG("(KMALLOC TEST) Allocated 200 bytes at 0x%p", ptr2);
-	kfree(ptr);
-	void* ptr3 = kmalloc(5); DEBUG("(KMALLOC TEST) Allocated 5 bytes at 0x%p", ptr3);
-
 	vmm_init();
 	
-	keyboard_init(FR);
+	struct process_t* pedicel = process_create("pedicel", (void*)pedicel_main, 0);
+	//struct process_t* two = process_create("two", (void*)two_main, 0);
+	//struct process_t* three = process_create("three", (void*)three_main, 0);
+	process_display_list(processes_list);
 
+	scheduler_init();
+
+	SET_INTERRUPTS;
+
+	keyboard_init(FR);
 	term_init();
-	// Draw something
+	kputs(PEPPEROS_SPLASH);
-	printf("%s, %s!\n", "Hello", "world");
+
-	// Yoohoooooo!
+	idle();
-	//DEBUG("kernel initialized successfully! hanging... wow=%d", 42);
-	printf("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non justo a magna bibendum auctor viverra rutrum diam. In hac habitasse platea dictumst. Vestibulum suscipit ipsum eget tortor maximus lobortis. Donec vel ipsum id lacus fringilla bibendum id eget risus. Fusce vestibulum diam sit amet nunc ultricies, nec rutrum nibh congue. Donec fringilla a dui sit amet ullamcorper. Donec pharetra quis tortor id congue. Aliquam erat volutpat. Duis suscipit nulla vel ligula iaculis, in gravida mauris pellentesque. Vestibulum nunc nisl, posuere eu eros et, dictum molestie dolor. Donec posuere laoreet hendrerit. Suspendisse potenti. Proin fringilla vehicula malesuada. Quisque a dui est. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Curabitur nec aliquam lacus, at lacinia enim. ");
-	hcf();
 }

src/mem/gdt/gdt.c

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Global Descriptor Table (for legacy reasons)
+ * @license GPL-3.0-only
+ */
+
 #include "gdt.h"
 #include <stdint.h>
 #include "io/serial/serial.h"

src/mem/gdt/gdt.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Global Descriptor Table (for legacy reasons)
+ * @license GPL-3.0-only
+ */
+
 #ifndef GDT_H
 #define GDT_H
 

src/mem/heap/kheap.c

@@ -1,8 +1,16 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Kernel heap
+ * @license GPL-3.0-only
+ */
+
 #include "kheap.h"
 #include "mem/paging/paging.h"
 #include "mem/paging/pmm.h"
 #include <stddef.h>
 #include <kernel.h>
+#include "sched/process.h"
+#include "config.h"
 
 extern uint64_t kernel_phys_base;
 extern uint64_t kernel_virt_base;
@@ -15,12 +23,24 @@ static uintptr_t end;
 // Kernel root table (level 4)
 extern uint64_t *kernel_pml4;
 
-static void kheap_map_page()
+static void kheap_grow(size_t size)
+{
+    size_t pages = ALIGN_UP(size + sizeof(struct heap_block_t), PAGE_SIZE) / PAGE_SIZE;
+    
+    if (pages == 0) pages = 1;
+    
+    for (size_t i = 0; i < pages; i++)
+    {
+        kheap_map_page();
+    }
+}
+
+void kheap_map_page()
 {
     uintptr_t phys = pmm_alloc();
     paging_map_page(kernel_pml4, end, phys, PTE_PRESENT | PTE_WRITABLE | PTE_NOEXEC);
     end += PAGE_SIZE;
-    DEBUG("Mapped first kheap page");
+    //DEBUG("Mapped first kheap page");
 }
 
 void kheap_init()
@@ -43,6 +63,7 @@ void* kmalloc(size_t size)
 {
     // No size, no memory allocated!
     if (!size) return NULL;
+    size = ALIGN(size);
 
     struct heap_block_t* curr = head;
 
@@ -52,17 +73,16 @@ void* kmalloc(size_t size)
         if (curr->free && curr->size >= size)
         {
             // We split the block if it is big enough
-            if (curr->size > size + sizeof(struct heap_block_t))
+            if (curr->size >= size + BLOCK_MIN_SIZE)
             {
-                struct heap_block_t* new_block = (struct heap_block_t*)((uintptr_t)curr + sizeof(struct heap_block_t) + size);
+                //struct heap_block_t* new_block = (struct heap_block_t*)((uintptr_t)curr + sizeof(struct heap_block_t) + size);
-                // We have to subtract the size of our block struct
+                struct heap_block_t* split = (struct heap_block_t*)((uintptr_t)curr + sizeof(*curr) + size);
-                new_block->size = curr->size - size - sizeof(struct heap_block_t);
-                new_block->free = true;
                 
-                // Then we chain up the block in the list
+                split->size = curr->size - size - sizeof(*curr);
-                new_block->next = curr->next;
+                split->free = true;
-                curr->next = new_block;
+                split->next = curr->next;
 
+                curr->next = split;
                 curr->size = size;
             }
 
@@ -74,14 +94,14 @@ void* kmalloc(size_t size)
         curr = curr->next;
     }
 
-    // If we're hear it means we didn't have enough memory
+    // If we're here it means we didn't have enough memory
     // for the block allocation. So we will allocate more..
     uintptr_t old_end = end;
-    kheap_map_page();
+    kheap_grow(size + sizeof(struct heap_block_t));
 
     struct heap_block_t* block = (struct heap_block_t*)old_end;
-    block->size = PAGE_SIZE - sizeof(struct heap_block_t);
+    block->size = ALIGN_UP(end - old_end - sizeof(struct heap_block_t), 16);
-    block->free = false;
+    block->free = true;
     block->next = NULL;
 
     // Put the block at the end of the list
@@ -92,7 +112,7 @@ void* kmalloc(size_t size)
     }
     curr->next = block;
 
-    return (void*)((uintptr_t)block + sizeof(struct heap_block_t));
+    return kmalloc(size);
 }
 
 void kfree(void* ptr)
@@ -103,4 +123,25 @@ void kfree(void* ptr)
     // Set it free!
     struct heap_block_t* block = (struct heap_block_t*)((uintptr_t)ptr - sizeof(struct heap_block_t));
     block->free = true;
+
+    // merge adjacent free blocks (coalescing)
+    struct heap_block_t* curr = head;
+    while (curr && curr->next)
+    {
+        if (curr->free && curr->next->free)
+        {
+            curr->size += sizeof(*curr) + curr->next->size;
+            curr->next = curr->next->next;
+            continue;
+        }
+        curr = curr->next;
+    }
+}
+
+// Should alloc enough for a stack (at least 64kb) to be used for a process.
+// Should return a pointer to top of the stack (as stack grows DOWNWARDS)
+void* kalloc_stack()
+{
+    uint8_t* ptr = kmalloc(PROCESS_STACK_SIZE);
+    return ptr ? ptr+PROCESS_STACK_SIZE : NULL;
 }

src/mem/heap/kheap.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Kernel heap
+ * @license GPL-3.0-only
+ */
+
 #ifndef KHEAP_H
 #define KHEAP_H
 
@@ -6,9 +12,6 @@
 // When the kernel heap is ready, we can alloc our VM object linked list
 // and then continue working on the VMM.
 
-// 16MB should be enough for some linked lists
-#define KHEAP_SIZE (16*1024*1024)
-
 #include <stdbool.h>
 #include <stddef.h>
 
@@ -22,5 +25,7 @@ struct heap_block_t
 void kheap_init();
 void* kmalloc(size_t size);
 void kfree(void* ptr);
+void* kalloc_stack();
+void kheap_map_page();
 
 #endif

src/mem/misc/utils.c

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Common memory utilities
+ * @license GPL-3.0-only
+ */
+
 #include <stddef.h>
 #include <stdint.h>
 #include <limine.h>

src/mem/misc/utils.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Common memory utilities
+ * @license GPL-3.0-only
+ */
+
 #ifndef MEM_UTILS_H
 #define MEM_UTILS_H
 
@@ -8,6 +14,7 @@ void* memset(void* s, int c, size_t n);
 void* memmove(void *dest, const void* src, size_t n);
 int memcmp(const void* s1, const void* s2, size_t n);
 
+// DEBUG
 void memmap_display(struct limine_memmap_response* response);
 void hhdm_display(struct limine_hhdm_response* hhdm);
 

src/mem/paging/paging.c

@@ -1,8 +1,15 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   x64 4-level paging implementation
+ * @license GPL-3.0-only
+ */
+
 #include "paging.h"
 #include "pmm.h"
 #include <kernel.h>
 #include <stddef.h>
 #include <limine.h>
+#include "config.h"
 
 /*
 Paging on x86 uses four different page table levels:
@@ -69,7 +76,7 @@ void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_
         root_table[pml4_i] = VIRT_TO_PHYS(pdpt) | PTE_PRESENT | PTE_WRITABLE;
     }
     else {
-        pdpt = (uint64_t *)PHYS_TO_VIRT(root_table[pml4_i] & ~0xFFFULL);
+        pdpt = (uint64_t *)PHYS_TO_VIRT(root_table[pml4_i] & PTE_ADDR_MASK);
     }
 
     // PDPT: same here
@@ -79,7 +86,7 @@ void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_
         pdpt[pdpt_i] = VIRT_TO_PHYS(pd) | PTE_PRESENT | PTE_WRITABLE;
     } 
     else {
-        pd = (uint64_t *)PHYS_TO_VIRT(pdpt[pdpt_i] & ~0xFFFULL);
+        pd = (uint64_t *)PHYS_TO_VIRT(pdpt[pdpt_i] & PTE_ADDR_MASK);
     }
 
     // PD: and here
@@ -89,7 +96,7 @@ void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_
         pd[pd_i] = VIRT_TO_PHYS(pt) | PTE_PRESENT | PTE_WRITABLE;
     }
     else {
-        pt = (uint64_t *)PHYS_TO_VIRT(pd[pd_i] & ~0xFFFULL);
+        pt = (uint64_t *)PHYS_TO_VIRT(pd[pd_i] & PTE_ADDR_MASK);
     }
 
     // PT: finally, populate the page table entry
@@ -102,13 +109,16 @@ void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_
 uint64_t kernel_phys_base;
 uint64_t kernel_virt_base;
 
-void paging_init(struct limine_kernel_address_response* kaddr, struct limine_framebuffer* fb)
+extern struct boot_context boot_ctx;
+
+void paging_init()
 {
     // We should map the kernel, GDT, IDT, stack, framebuffer.
     // Optionally we could map ACPI tables (we can find them in the Limine memmap)
 
-    kernel_phys_base = kaddr->physical_base;
+    kernel_phys_base = boot_ctx.kaddr->physical_base;
-    kernel_virt_base = kaddr->virtual_base;
+    kernel_virt_base = boot_ctx.kaddr->virtual_base;
+    struct limine_framebuffer* fb = boot_ctx.fb;
 
     DEBUG("Kernel lives at virt=0x%p phys=0x%p", kernel_virt_base, kernel_phys_base);
 
@@ -117,14 +127,38 @@ void paging_init(struct limine_kernel_address_response* kaddr, struct limine_fra
     // for debug
     uint64_t page_count = 0;
 
-    // HHDM map first 1 GB using given offset
+    // Find max physical address from limine memmap
-    for (uint64_t i=0; i<0x40000000; i += PAGE_SIZE)
+    uint64_t max_phys = 0;
+    for (uint64_t i=0; i<boot_ctx.mmap->entry_count; i++)
+    {
+        struct limine_memmap_entry* entry = boot_ctx.mmap->entries[i];
+        if (entry->length == 0)
+        {
+            continue;
+        }
+        uint64_t top = entry->base + entry->length;
+        if (top > max_phys)
+        {
+            max_phys = top;
+        }
+        //DEBUG("max_phys=0x%p", max_phys);
+    }
+
+    // 4GB
+    if (max_phys > 0x100000000)
+    {
+        DEBUG("WARNING: max_phys capped to 4GB (0x100000000) (from max_phys=%p)", max_phys);
+        max_phys = 0x100000000;
+    }
+
+    // HHDM map up to max_phys or 4GB, whichever is smaller, using given offset
+    for (uint64_t i=0; i<max_phys; i += PAGE_SIZE)
     {
         //paging_kmap_page(i+hhdm_off, i, PTE_WRITABLE);
-        paging_map_page(kernel_pml4, i+hhdm_off, i, PTE_WRITABLE);
+        paging_map_page(kernel_pml4, i+hhdm_off, i, PTE_WRITABLE | PTE_PRESENT);
         page_count++;
     }
-    DEBUG("Mapped %u pages for first 1GB (HHDM)", page_count); page_count = 0;
+    DEBUG("Mapped %u pages up to 0x%p (HHDM)", page_count, max_phys); page_count = 0;
 
     // Map the kernel (according to virt/phys_base given by Limine)
     // SOME DAY when we want a safer kernel we should map .text as Read/Exec

src/mem/paging/paging.h

@@ -1,13 +1,19 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   x64 4-level paging implementation
+ * @license GPL-3.0-only
+ */
+
 #ifndef PAGING_H
 #define PAGING_H
 
 #define PAGE_SIZE 4096
-#define BITS_PER_ROW 64
 
 #include <stdint.h>
 #include <limine.h>
+#include "mem/heap/kheap.h"
 
-void paging_init(struct limine_kernel_address_response* kaddr, struct limine_framebuffer* fb);
+void paging_init();
 void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_t flags);
 
 extern uint64_t hhdm_off;
@@ -15,10 +21,14 @@ extern uint64_t hhdm_off;
 #define PHYS_TO_VIRT(x) ((void*)((uintptr_t)(x) + hhdm_off))
 #define VIRT_TO_PHYS(x) ((uintptr_t)(x) - hhdm_off)
 
+#define PTE_ADDR_MASK 0x000FFFFFFFFFF000
 // Stole it
 #define ALIGN_UP(x, align)   (((x) + ((align) - 1)) & ~((align) - 1))
 #define ALIGN_DOWN(x, align) ((x) & ~((align) - 1))
-#define PAGE_ALIGN_DOWN(x) ((x) & ~0xFFFULL)
+#define PAGE_ALIGN_DOWN(x) ((x) & PTE_ADDR_MASK)
+
+#define ALIGN(size) ALIGN_UP(size, 16)
+#define BLOCK_MIN_SIZE (sizeof(struct heap_block_t) + 16)
 
 #define PML4_INDEX(x) (((x) >> 39) & 0x1FF)
 #define PDPT_INDEX(x) (((x) >> 30) & 0x1FF)
@@ -35,10 +45,4 @@ extern uint64_t hhdm_off;
 #define PTE_HUGE        (1ULL << 7)
 #define PTE_NOEXEC      (1ULL << 63)
 
-// Specified in linker.ld
-#define KERNEL_BASE 0xFFFFFFFF80000000ULL
-
-// 2 MB should be enough (as of now, the whole kernel ELF is around 75kb)
-#define KERNEL_SIZE 0x200000
-
 #endif

src/mem/paging/pmm.c

@@ -1,4 +1,8 @@
-// OMG here we are. I'm cooked.
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Physical memory manager from freelist
+ * @license GPL-3.0-only
+ */
 
 /*
 pmm - Physical Memory Manager
@@ -62,7 +66,10 @@ static uintptr_t g_freelist = 0;
 
 uintptr_t pmm_alloc()
 {
-    if (!g_freelist) return 0;
+    if (!g_freelist)
+	{
+		panic(NULL, "PMM is out of memory!");		
+	}
     uintptr_t addr = g_freelist;
     g_freelist = *(uintptr_t*) PHYS_TO_VIRT(g_freelist);
     return addr;

src/mem/paging/pmm.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Physical memory manager from freelist
+ * @license GPL-3.0-only
+ */
+
 #ifndef PAGING_PMM_H
 #define PAGING_PMM_H
 

src/mem/paging/vmm.c

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Virtual memory manager
+ * @license GPL-3.0-only
+ */
+
 /*
 The VMM (virtual memory manager) will have two roles:
 - mapping pages
@@ -49,7 +55,7 @@ void vmm_setup_pt_root()
     DEBUG("VMM setup: vmm_pt_root=0x%p (phys=0x%p)", vmm_pt_root, phys);
 }
 
-void* vmm_alloc(size_t length, size_t flags)
+/* void* vmm_alloc(size_t length, size_t flags)
 {
     // We will try to allocate at least length bytes, which have to be rounded UP to
     // the next page so its coherent with the PMM
@@ -58,7 +64,7 @@ void* vmm_alloc(size_t length, size_t flags)
     // Need to implement this (as linked list)
     // but for now kernel heap is sufficient
     // The VMM will prob be more useful when we have userspace
-}
+} */
 
 void vmm_init()
 {

src/mem/paging/vmm.h

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Virtual memory manager
+ * @license GPL-3.0-only
+ */
+
 #ifndef VMM_H
 #define VMM_H
 

src/sched/process.c

@@ -0,0 +1,129 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Process linked list implementation
+ * @license GPL-3.0-only
+ */
+
+#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"
+
+struct process_t* processes_list;
+struct process_t* current_process;
+
+size_t next_free_pid = 0;
+
+void process_init()
+{
+    processes_list = NULL;
+    current_process = NULL;
+}
+
+// Only for debug
+void process_display_list(struct process_t* processes_list)
+{
+    int process_view_id = 0;
+    struct process_t* tmp = processes_list;
+    while (tmp != NULL)
+    {
+        DEBUG("{%d: %p} -> ", process_view_id, tmp);
+        tmp = tmp->next;
+        process_view_id++;
+    }
+    DEBUG("NULL");
+}
+
+struct process_t* process_create(char* name, void(*function)(void*), void* arg)
+{
+    CLEAR_INTERRUPTS;
+    struct process_t* proc = (struct process_t*)kmalloc(sizeof(struct process_t));
+    
+    struct cpu_status_t* ctx = (struct cpu_status_t*)kmalloc(sizeof(struct cpu_status_t));
+
+    // No more memory?
+    if (!proc) return NULL;
+    if (!ctx) return NULL;
+
+    strncpy(proc->name, name, PROCESS_NAME_MAX);
+    proc->pid = next_free_pid++;
+    proc->status = READY;
+
+    proc->context = ctx;
+    proc->context->iret_ss = KERNEL_DATA_SEGMENT; // process will live in kernel mode
+    proc->context->iret_rsp = (uint64_t)kalloc_stack();
+    proc->context->iret_flags = 0x202; //bit 2 and 9 set (Interrupt Flag)
+    proc->context->iret_cs = KERNEL_CODE_SEGMENT;
+    proc->context->iret_rip = (uint64_t)function; // beginning of executable code
+    proc->context->rdi = (uint64_t)arg; // 1st arg is in rdi (as per x64 calling convention)
+    proc->context->rbp = 0;
+
+    proc->next = 0;
+
+    process_add(&processes_list, proc);
+
+    SET_INTERRUPTS;
+    return proc;
+}
+
+void process_add(struct process_t** processes_list, struct process_t* process)
+{
+    if (!process) return;
+    process->next = NULL;
+
+    if (*processes_list == NULL)
+    {
+        // List is empty
+        *processes_list = process;
+        return;
+    }
+
+    struct process_t* tmp = *processes_list;
+    while (tmp->next != NULL)
+    {
+        tmp = tmp->next;
+    }
+    // We're at last process before NULL
+    tmp->next = process;
+    // process->next = NULL;
+}
+
+void process_delete(struct process_t** processes_list, struct process_t* process)
+{
+    if (!processes_list || !*processes_list || !process) return;
+
+    if (*processes_list == process)
+    {
+        // process to delete is at head
+        *processes_list = process->next;
+        process->next = NULL;
+        kfree(process);
+        return;
+    }
+
+    struct process_t* tmp = *processes_list;
+    while (tmp->next && tmp->next != process)
+    {
+        tmp = tmp->next;
+    }
+
+    if (tmp->next == NULL)
+    {
+        // Didn't find the process
+        return;
+    }
+
+    // We're at process before the one we want to delete
+    tmp->next = process->next;
+    process->next = NULL;
+    kfree(process);
+}
+
+struct process_t* process_get_next(struct process_t* process)
+{
+    if (!process) return NULL;
+    return process->next;
+}

src/sched/process.h

@@ -0,0 +1,39 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Process definition
+ * @license GPL-3.0-only
+ */
+
+#ifndef PROCESS_H
+#define PROCESS_H
+
+#include <stddef.h>
+#include "config.h"
+
+typedef enum 
+{
+    READY,
+    RUNNING,
+    DEAD
+} status_t;
+
+struct process_t
+{
+    size_t pid;
+    char name[PROCESS_NAME_MAX];
+
+    status_t status;
+    struct cpu_status_t* context;
+	void* root_page_table; // Process PML4 (should contain kernel PML4 in higher half [256-511]
+    struct process_t* next;
+};
+
+void process_init();
+struct process_t* process_create(char* name, void(*function)(void*), void* arg);
+void process_add(struct process_t** processes_list, struct process_t* process);
+void process_delete(struct process_t** processes_list, struct process_t* process);
+struct process_t* process_get_next(struct process_t* process);
+
+void process_display_list(struct process_t* processes_list);
+
+#endif

src/sched/scheduler.c

@@ -0,0 +1,46 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Round-robin scheduler
+ * @license GPL-3.0-only
+ */
+
+#include "kernel.h"
+#include "process.h"
+
+extern struct process_t* processes_list;
+extern struct process_t* current_process;
+
+void scheduler_init()
+{
+    // Choose first process?
+    current_process = processes_list;
+}
+
+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;
+        if (current_process->next != NULL)
+        {
+            current_process = current_process->next;
+        } else
+        {
+            current_process = processes_list;
+        }
+        
+        if (current_process != NULL && current_process->status == DEAD)
+        {
+            process_delete(&prev_process, current_process);
+        } else
+        {
+            current_process->status = RUNNING;
+            break;
+        }
+    }
+    
+    DEBUG("current_process={pid=%u name='%s'}", current_process->pid, current_process->name);
+    return current_process->context;
+}

src/sched/scheduler.h

@@ -0,0 +1,13 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Round-robin scheduler
+ * @license GPL-3.0-only
+ */
+
+#ifndef SCHEDULER_H
+#define SCHEDULER_H
+
+void scheduler_schedule();
+void scheduler_init();
+
+#endif

src/sched/task.S

@@ -0,0 +1,7 @@
+; Task (process) switching
+
+bits 64
+
+global switch_to_task
+switch_to_task:
+

src/string/string.c

@@ -1,6 +1,32 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   String manipulation utilities
+ * @license GPL-3.0-only
+ */
+
+#include <stddef.h>
+
 char* strcpy(char *dest, const char *src)
 {
     char *temp = dest;
     while((*dest++ = *src++));
     return temp;
 }
+
+// https://stackoverflow.com/questions/2488563/strcat-implementation
+char *strcat(char *dest, const char *src){
+    size_t i,j;
+    for (i = 0; dest[i] != '\0'; i++)
+        ;
+    for (j = 0; src[j] != '\0'; j++)
+        dest[i+j] = src[j];
+    dest[i+j] = '\0';
+    return dest;
+}
+
+// https://stackoverflow.com/questions/14159625/implementation-of-strncpy
+void strncpy(char* dst, const char* src, size_t n)
+{
+   size_t i = 0;
+   while(i++ != n && (*dst++ = *src++));
+}

src/string/string.h

@@ -1,6 +1,14 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   String manipulation functions
+ * @license GPL-3.0-only
+ */
+
 #ifndef STRING_H
 #define STRING_H
 
 char *strcpy(char *dest, const char *src);
+char *strcat(char *dest, const char *src);
+void strncpy(char* dst, const char* src, size_t n);
 
 #endif

src/time/timer.c

@@ -1,3 +1,9 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Programmable Interval Timer init and enabling
+ * @license GPL-3.0-only
+ */
+
 #include <stdint.h>
 #include "io/serial/serial.h"
 #include <kernel.h>
@@ -44,7 +50,7 @@ void pic_enable()
     // Enabling IRQ0 (unmasking it) but not the others
     uint8_t mask = inb(0x21);
     mask &= ~(1 << 0);  // Set IRQ0 (timer, clear bit 0)
-    mask &= ~(1 << 1); // Set IRQ1 (PS/2 Keyboard, clear bit 1)
+    //mask &= ~(1 << 1); // Set IRQ1 (PS/2 Keyboard, clear bit 1)
     outb(0x21, mask);
 }
 
@@ -65,6 +71,17 @@ void pit_init()
     outb(0x40, (divisor >> 8) & 0xFF);
 }
 
+// Wait n ticks
+// Given that there's a tick every 1ms, wait n milliseconds
+void timer_wait(uint64_t wait_ticks)
+{
+    uint64_t then = ticks + wait_ticks;
+    while (ticks < then)
+    {
+        asm("hlt");
+    };
+}
+
 void timer_init()
 {
     // Remapping the PIC, because at startup it conflicts with

src/time/timer.h

@@ -1,6 +1,13 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   PIT functions
+ * @license GPL-3.0-only
+ */
+
 #ifndef TIMER_H
 #define TIMER_H
 
 void timer_init();
+void timer_wait(unsigned int wait_ticks);
 
 #endif

test.bin

@@ -0,0 +1 @@
+ｸ<EFBFBD>ｭﾞ<EFBFBD>