flanterm PAGE FAULT, tries to access NULL or NULL+small offset

.gitignore

@@ -7,3 +7,6 @@ iso_root
 *.gch
 */*.gch
 */*/*.gch
+.gdb_history
+symbols.map
+symbols.S

DOOM.txt

@@ -0,0 +1,24 @@
+up to doom:
+
+- Return from pedicel_main() normally (to idle)
+
+** Checkpoint: ring0 process working
+
+- VFS layer (open/read/write/...) with USTar filesystem (for initrd)
+
+** Checkpoint: files not linked to but accessible by the kernel
+
+- Ring3 memory mappings 
+- Ring3 privilege switch
+
+** Checkpoint: welcome to userland
+
+- Syscall interface
+- Implement syscalls needed for doom
+
+** Checkpoint: can run simple programs, ring 3, loaded from filesystem 
+
+- Properly handle the keyboard interrupt (keyboard buffer)
+- Port DOOMgeneric (few functions with Framebuffer/ticks/etc.)
+
+** Achievement: It runs doom!

Makefile

@@ -1,4 +1,4 @@
-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
+SOURCES = 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/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
 
@@ -7,6 +7,11 @@ build:
 	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
+	nasm -f elf64 src/entry.S -o entry.o
+	x86_64-elf-ld -o pepperk -T linker.ld *.o
+	nm -n pepperk | awk '$$2 ~ /[TtDdBbRr]/ {print $$1, $$3}' > symbols.map
+	python3 symbols.py
+	nasm -f elf64 symbols.S -o symbols.o
 	x86_64-elf-ld -o pepperk -T linker.ld *.o
 
 limine/limine:
@@ -32,11 +37,15 @@ build-iso: limine/limine build
 	./limine/limine bios-install pepper.iso
 
 debug:
-	qemu-system-x86_64 -drive file=pepper.iso -s -S -d int -no-reboot -no-shutdown &
+	/usr/bin/qemu-system-x86_64 -drive file=pepper.iso -s -S -d int -no-reboot -no-shutdown &
 	gdb pepperk --command=debug.gdb
 
+debug2:
+	/usr/bin/qemu-system-x86_64 -drive file=pepper.iso -s -S -d int -no-reboot -no-shutdown &
+	pwndbg pepperk --command=debug.gdb
+
 run: build-iso
-	qemu-system-x86_64 -cdrom pepper.iso -serial stdio
+	/usr/bin/qemu-system-x86_64 -cdrom pepper.iso -serial stdio
 
 clean:
-	rm -rf *.o pepperk iso_root pepper.iso limine
+	rm -rf *.o symbols.map symbols.S pepperk iso_root pepper.iso limine

README.md

@@ -2,7 +2,7 @@
 
 ## Trying the kernel
 
-First install the dependencies: `sudo apt install xorriso make qemu-system`
+First install the dependencies: `sudo apt install python3 xorriso make qemu-system`
 
 Then, to compile the kernel and make an ISO image file: `make build-iso`
 To run it with QEMU, `make run`

debug.gdb

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

linker.ld

@@ -1,6 +1,6 @@
 OUTPUT_FORMAT(elf64-x86-64)
 
-ENTRY(kmain)
+ENTRY(_start)
 
 PHDRS
 {

src/config.h

@@ -10,12 +10,14 @@
 /* version */
 #define PEPPEROS_VERSION_MAJOR "0"
 #define PEPPEROS_VERSION_MINOR "0"
-#define PEPPEROS_VERSION_PATCH "1"
+#define PEPPEROS_VERSION_PATCH "58"
 #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
@@ -25,6 +27,7 @@
 #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
 
 /* heap */
 #define KHEAP_SIZE (16*1024*1024)

src/debug/panic.c

@@ -0,0 +1,25 @@
+#include <stddef.h>
+#include "idt/idt.h"
+#include "io/serial/serial.h"
+#include "kernel.h"
+
+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('\r');
+		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\r\nSomething went horribly wrong! (%s) 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\rHalting...",
+		ctx->iret_rip,
+		str,
+		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);
+	debug_stack_trace(100);
+	hcf();
+}

src/debug/stacktrace.c

@@ -0,0 +1,75 @@
+#include <stdint.h>
+#include "kernel.h"
+
+void debug_stack_trace(unsigned int max_frames)
+{
+    DEBUG("*** begin stack trace ***");
+    // Thanks GCC :)
+    uintptr_t* rbp = (uintptr_t*)__builtin_frame_address(0);
+
+    for (unsigned int frame=0; frame<max_frames && rbp != NULL; frame++)
+    {
+        // Return address, 1 word above saved rbp
+        uintptr_t rip = rbp[1];
+        uintptr_t offset = 0;
+        const char* name = debug_find_symbol(rip, &offset);
+        DEBUG("[%u] <0x%p> (%s+0x%x)", frame, (void*)rip, name, offset);
+
+        uintptr_t* next_rbp = (uintptr_t*)rbp[0];
+
+        // invalid rbp or we're at the end
+        if (next_rbp <= rbp || next_rbp == NULL)
+        {
+            break;
+        }
+
+        rbp = next_rbp;
+    }
+    DEBUG("*** end stack trace ***");
+}
+
+typedef struct
+{
+    uint64_t addr;
+    const char *name;
+} __attribute__((packed)) kernel_symbol_t;
+
+__attribute__((weak)) extern kernel_symbol_t symbol_table[];
+__attribute__((weak)) extern uint64_t symbol_count;
+
+// binary search
+const char* debug_find_symbol(uintptr_t rip, uintptr_t* offset)
+{
+    if (!symbol_table || symbol_count == 0)
+    {
+        if (offset) *offset = 0;
+        return "???";
+    }
+
+    int low = 0, high = (int)symbol_count - 1;
+    int best = -1;
+
+    while (low <= high)
+    {
+        int mid = (low + high) / 2;
+        if (symbol_table[mid].addr <= rip)
+        {
+            best = mid;
+            low = mid + 1;
+        } else {
+            high = mid - 1;
+        }
+    }
+
+    if (best != -1)
+    {
+        if (offset)
+        {
+            *offset = rip - symbol_table[best].addr;
+        }
+        return symbol_table[best].name;
+    }
+
+    if (offset) *offset = 0;
+    return "unknown";
+}

src/entry.S

@@ -0,0 +1,23 @@
+bits 64
+global _start
+
+extern kmain
+extern kernel_stack
+
+KERNEL_STACK_SIZE equ 65536
+
+section .text
+
+_start:
+    cli
+
+    ; load kernel stack
+    lea rsp, [kernel_stack+KERNEL_STACK_SIZE]
+
+    ; rbp=0 so last frame in stack trace
+    xor rbp, rbp
+
+    ; 16 byte align
+    and rsp, -16
+
+    call kmain

src/idt/idt.c

@@ -13,6 +13,7 @@
 #include <stdbool.h>
 #include "sched/scheduler.h"
 #include "config.h"
+#include "sched/process.h"
 
 struct interrupt_descriptor idt[256];
 struct idtr idt_reg;
@@ -87,11 +88,7 @@ static void page_fault_handler(struct cpu_status_t* ctx)
     CHECK_BIT(ctx->error_code, 7) ? " SGX_VIOLATION" : "",
     cr2);
 
-    /* if (CHECK_BIT(ctx->error_code, 0))
+    panic(ctx, "page fault");
-    {
-        panic(ctx);
-    } */
-    panic(ctx);
 }
 
 static void gp_fault_handler(struct cpu_status_t* ctx)
@@ -117,11 +114,16 @@ static void gp_fault_handler(struct cpu_status_t* ctx)
         index);
     }
 
-    panic(ctx);
+    panic(ctx, "gp fault");
 }
 
 struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context)
 {
+    if (context == NULL)
+    {
+        panic(NULL, "Interrupt dispatch recieved NULL context!");
+    }
+
     switch(context->vector_number)
     {
         case 0:
@@ -144,6 +146,7 @@ struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context)
             break;
         case 6:
             DEBUG("Invalid Opcode!");
+            panic(context, "Invalid Opcode!");
             break;
         case 7:
             DEBUG("Device Not Available!");
@@ -194,16 +197,17 @@ struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context)
 
         case 32: // Timer Interrupt
             ticks++;
+            // Send an EOI so that we can continue having interrupts
+            outb(0x20, 0x20);
 
             if (ticks % SCHEDULER_QUANTUM == 0)
             {
-                CLEAR_INTERRUPTS;
+                return scheduler_schedule(context);
-                scheduler_schedule();
+                //struct cpu_status_t* current_ctx = scheduler_schedule(context);
-                SET_INTERRUPTS;
+                //process_switch(current_ctx->iret_rsp, current_ctx->iret_rip);
+                //SET_INTERRUPTS;
             }
 
-            // Send an EOI so that we can continue having interrupts
-            outb(0x20, 0x20);
             break;
 
         case 33:

src/io/kbd/ps2.c

@@ -206,7 +206,7 @@ void keyboard_handler()
                 if (c)
                 {
                     // Should probably have a keyboard buffer here... instead of this
-                    putchar(c);
+                    _putchar(c);
                 }
             }
         }

src/io/term/flanterm.h

@@ -0,0 +1,72 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/* Copyright (C) 2022-2026 Mintsuki and contributors.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FLANTERM_H
+#define FLANTERM_H 1
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FLANTERM_CB_DEC 10
+#define FLANTERM_CB_BELL 20
+#define FLANTERM_CB_PRIVATE_ID 30
+#define FLANTERM_CB_STATUS_REPORT 40
+#define FLANTERM_CB_POS_REPORT 50
+#define FLANTERM_CB_KBD_LEDS 60
+#define FLANTERM_CB_MODE 70
+#define FLANTERM_CB_LINUX 80
+#define FLANTERM_CB_OSC 90
+
+#ifdef FLANTERM_IN_FLANTERM
+
+#include "flanterm_private.h"
+
+#else
+
+struct flanterm_context;
+
+#endif
+
+void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count);
+void flanterm_flush(struct flanterm_context *ctx);
+void flanterm_full_refresh(struct flanterm_context *ctx);
+void flanterm_deinit(struct flanterm_context *ctx, void (*_free)(void *ptr, size_t size));
+
+void flanterm_get_dimensions(struct flanterm_context *ctx, size_t *cols, size_t *rows);
+void flanterm_set_autoflush(struct flanterm_context *ctx, bool state);
+void flanterm_set_callback(struct flanterm_context *ctx, void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/io/term/flanterm_backends/fb.h

@@ -0,0 +1,79 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/* Copyright (C) 2022-2026 Mintsuki and contributors.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FLANTERM_FB_H
+#define FLANTERM_FB_H 1
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../flanterm.h"
+
+#ifdef FLANTERM_IN_FLANTERM
+
+#include "fb_private.h"
+
+#endif
+
+#define FLANTERM_FB_ROTATE_0 0
+#define FLANTERM_FB_ROTATE_90 1
+#define FLANTERM_FB_ROTATE_180 2
+#define FLANTERM_FB_ROTATE_270 3
+
+struct flanterm_context *flanterm_fb_init(
+    /* If _malloc and _free are nulled, use the bump allocated instance (1 use only). */
+    void *(*_malloc)(size_t size),
+    void (*_free)(void *ptr, size_t size),
+    uint32_t *framebuffer, size_t width, size_t height, size_t pitch,
+    uint8_t red_mask_size, uint8_t red_mask_shift,
+    uint8_t green_mask_size, uint8_t green_mask_shift,
+    uint8_t blue_mask_size, uint8_t blue_mask_shift,
+    uint32_t *canvas, /* If nulled, no canvas. */
+    uint32_t *ansi_colours, uint32_t *ansi_bright_colours, /* If nulled, default. */
+    uint32_t *default_bg, uint32_t *default_fg, /* If nulled, default. */
+    uint32_t *default_bg_bright, uint32_t *default_fg_bright, /* If nulled, default. */
+    /* If font is null, use default font and font_width and font_height ignored. */
+    void *font, size_t font_width, size_t font_height, size_t font_spacing,
+    /* If scale_x and scale_y are 0, automatically scale font based on resolution. */
+    size_t font_scale_x, size_t font_scale_y,
+    size_t margin,
+    /* One of FLANTERM_FB_ROTATE_* values. */
+    int rotation
+);
+
+void flanterm_fb_set_flush_callback(struct flanterm_context *ctx, void (*flush_callback)(volatile void *address, size_t length));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/io/term/flanterm_backends/fb_private.h

@@ -0,0 +1,127 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/* Copyright (C) 2022-2026 Mintsuki and contributors.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FLANTERM_FB_PRIVATE_H
+#define FLANTERM_FB_PRIVATE_H 1
+
+#ifndef FLANTERM_IN_FLANTERM
+#error "Do not use fb_private.h. Use interfaces defined in fb.h only."
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FLANTERM_FB_FONT_GLYPHS 256
+
+struct flanterm_fb_char {
+    uint32_t c;
+    uint32_t fg;
+    uint32_t bg;
+};
+
+struct flanterm_fb_queue_item {
+    size_t x, y;
+    struct flanterm_fb_char c;
+};
+
+struct flanterm_fb_context {
+    struct flanterm_context term;
+
+    void (*plot_char)(struct flanterm_context *ctx, struct flanterm_fb_char *c, size_t x, size_t y);
+    void (*flush_callback)(volatile void *address, size_t length);
+
+    size_t font_width;
+    size_t font_height;
+    size_t glyph_width;
+    size_t glyph_height;
+
+    size_t font_scale_x;
+    size_t font_scale_y;
+
+    size_t offset_x, offset_y;
+
+    volatile uint32_t *framebuffer;
+    size_t pitch;
+    size_t width;
+    size_t height;
+    size_t phys_height;
+    size_t bpp;
+
+    uint8_t red_mask_size, red_mask_shift;
+    uint8_t green_mask_size, green_mask_shift;
+    uint8_t blue_mask_size, blue_mask_shift;
+
+    int rotation;
+
+    size_t font_bits_size;
+    uint8_t *font_bits;
+    size_t font_bool_size;
+    bool *font_bool;
+
+    uint32_t ansi_colours[8];
+    uint32_t ansi_bright_colours[8];
+    uint32_t default_fg, default_bg;
+    uint32_t default_fg_bright, default_bg_bright;
+
+    size_t canvas_size;
+    uint32_t *canvas;
+
+    size_t grid_size;
+    size_t queue_size;
+    size_t map_size;
+
+    struct flanterm_fb_char *grid;
+
+    struct flanterm_fb_queue_item *queue;
+    size_t queue_i;
+
+    struct flanterm_fb_queue_item **map;
+
+    uint32_t text_fg;
+    uint32_t text_bg;
+    size_t cursor_x;
+    size_t cursor_y;
+
+    uint32_t saved_state_text_fg;
+    uint32_t saved_state_text_bg;
+    size_t saved_state_cursor_x;
+    size_t saved_state_cursor_y;
+
+    size_t old_cursor_x;
+    size_t old_cursor_y;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/io/term/flanterm_private.h

@@ -0,0 +1,133 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/* Copyright (C) 2022-2026 Mintsuki and contributors.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FLANTERM_PRIVATE_H
+#define FLANTERM_PRIVATE_H 1
+
+#ifndef FLANTERM_IN_FLANTERM
+#error "Do not use flanterm_private.h. Use interfaces defined in flanterm.h only."
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FLANTERM_MAX_ESC_VALUES 16
+
+struct flanterm_context {
+    /* internal use */
+
+    size_t tab_size;
+    bool autoflush;
+    bool cursor_enabled;
+    bool scroll_enabled;
+    bool wrap_enabled;
+    bool origin_mode;
+    bool control_sequence;
+    bool escape;
+    bool osc;
+    bool osc_escape;
+    size_t osc_buf_i;
+    uint8_t osc_buf[256];
+    bool rrr;
+    bool discard_next;
+    bool bold;
+    bool bg_bold;
+    bool reverse_video;
+    bool dec_private;
+    bool insert_mode;
+    bool csi_unhandled;
+    uint64_t code_point;
+    size_t unicode_remaining;
+    uint8_t g_select;
+    uint8_t charsets[2];
+    size_t current_charset;
+    size_t escape_offset;
+    size_t esc_values_i;
+    size_t saved_cursor_x;
+    size_t saved_cursor_y;
+    size_t current_primary;
+    size_t current_bg;
+    size_t scroll_top_margin;
+    size_t scroll_bottom_margin;
+    uint32_t esc_values[FLANTERM_MAX_ESC_VALUES];
+    uint8_t last_printed_char;
+    bool last_was_graphic;
+    bool saved_state_bold;
+    bool saved_state_bg_bold;
+    bool saved_state_reverse_video;
+    bool saved_state_origin_mode;
+    bool saved_state_wrap_enabled;
+    size_t saved_state_current_charset;
+    uint8_t saved_state_charsets[2];
+    size_t saved_state_current_primary;
+    size_t saved_state_current_bg;
+
+    /* to be set by backend */
+
+    size_t rows, cols;
+
+    void (*raw_putchar)(struct flanterm_context *, uint8_t c);
+    void (*clear)(struct flanterm_context *, bool move);
+    void (*set_cursor_pos)(struct flanterm_context *, size_t x, size_t y);
+    void (*get_cursor_pos)(struct flanterm_context *, size_t *x, size_t *y);
+    void (*set_text_fg)(struct flanterm_context *, size_t fg);
+    void (*set_text_bg)(struct flanterm_context *, size_t bg);
+    void (*set_text_fg_bright)(struct flanterm_context *, size_t fg);
+    void (*set_text_bg_bright)(struct flanterm_context *, size_t bg);
+    void (*set_text_fg_rgb)(struct flanterm_context *, uint32_t fg);
+    void (*set_text_bg_rgb)(struct flanterm_context *, uint32_t bg);
+    void (*set_text_fg_default)(struct flanterm_context *);
+    void (*set_text_bg_default)(struct flanterm_context *);
+    void (*set_text_fg_default_bright)(struct flanterm_context *);
+    void (*set_text_bg_default_bright)(struct flanterm_context *);
+    void (*move_character)(struct flanterm_context *, size_t new_x, size_t new_y, size_t old_x, size_t old_y);
+    void (*scroll)(struct flanterm_context *);
+    void (*revscroll)(struct flanterm_context *);
+    void (*swap_palette)(struct flanterm_context *);
+    void (*save_state)(struct flanterm_context *);
+    void (*restore_state)(struct flanterm_context *);
+    void (*double_buffer_flush)(struct flanterm_context *);
+    void (*full_refresh)(struct flanterm_context *);
+    void (*deinit)(struct flanterm_context *, void (*)(void *, size_t));
+
+    /* to be set by client */
+
+    void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t);
+};
+
+void flanterm_context_reinit(struct flanterm_context *ctx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/io/term/term.c

@@ -17,6 +17,7 @@ because this shitty implementation will be replaced one day by Flanterm
 #include "term.h"
 #include "mem/misc/utils.h"
 #include "config.h"
+#include "flanterm.h"
 
 extern struct boot_context boot_ctx;
 
@@ -30,7 +31,7 @@ uint8_t* glyphs = _binary_zap_light16_psf_start + sizeof(PSF1_Header);
 #define FONT_WIDTH 8
 #define FONT_HEIGHT font->characterSize
 
-
+extern struct flanterm_context* ft_ctx;
 
 // Character cursor
 typedef struct
@@ -87,38 +88,6 @@ static inline void putpixel(size_t x, size_t y, uint32_t color)
 	fb[pos+2] = (color >> 16) & 255; // blue
 }
 
-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<FONT_WIDTH; x++)
-		{
-			uint32_t color = (row & (0x80 >> x)) ? fg : bg;
-			putpixel(px+x, py+y, color);
-		}
-	}
-}
-
-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<FONT_WIDTH; x++)
-		{
-			// Black
-			putpixel(px+x, py+y, 0);
-		}
-	}
-}
-
 void term_scroll()
 {
 	// Erase first text line
@@ -140,67 +109,10 @@ void term_scroll()
 	lines_length[max_lines - 1] = 0;
 }
 
-void putchar(char c)
-{
-	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;
-	}
-
-	if (c == '\b') 
-	{
-		if (cursor.x > 0) 
-		{
-			cursor.x--;
-		}
-		else if (cursor.y > 0)
-		{
-			cursor.y--;
-			cursor.x = lines_length[cursor.y];
-		}
-		else
-		{
-			return;
-		}
-
-		erase_char(cursor.x * FONT_WIDTH, cursor.y * FONT_HEIGHT);
-		return;
-	}
-
-	if (cursor.x >= max_cols) 
-	{
-		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++;
-}
-
 // Overhead that could be avoided, right? (for printf)
 void _putchar(char character)
 {
-	putchar(character);
+	flanterm_write(ft_ctx, &character, 1);
 }
 
 // Debug-printing
@@ -209,7 +121,7 @@ void kputs(const char* str)
 	size_t i=0;
 	while (str[i] != 0)
 	{
-		putchar(str[i]);
+		_putchar(str[i]);
 		i++;
 	}
 }

src/io/term/term.h

@@ -9,7 +9,7 @@
 
 int term_init();
 void kputs(const char* str);
-void putchar(char c);
+void _putchar(char character);
 
 enum TermColors
 {

src/kernel.h

@@ -22,12 +22,25 @@ enum ErrorCodes
 
 #define DEBUG(log, ...) fctprintf((void*)&skputc, 0, "debug: [%s]: " log "\r\n", __FILE__, ##__VA_ARGS__)
 
+
+/* #define DEBUG(log, ...) \
+	printf("debug: [%s]: " log "\r\n", __FILE__, ##__VA_ARGS__); \
+	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);
+void panic(struct cpu_status_t* ctx, const char* str);
 void hcf();
+void idle();
+
+void debug_stack_trace(unsigned int max_frames);
+const char* debug_find_symbol(uintptr_t rip, uintptr_t* offset);
+
 #define assert(check) do { if(!(check)) hcf(); } while(0)
 
 struct boot_context

src/kmain.c

@@ -23,11 +23,15 @@
 #include "sched/process.h"
 #include "sched/scheduler.h"
 #include "config.h"
+#include "io/term/flanterm.h"
+#include "io/term/flanterm_backends/fb.h"
 
 // Limine version used
 __attribute__((used, section(".limine_requests")))
 volatile LIMINE_BASE_REVISION(3);
 
+struct flanterm_context *ft_ctx;
+
 // Halt and catch fire (makes machine stall)
 void hcf()
 {
@@ -35,17 +39,9 @@ void hcf()
 }
 
 // Doing nothing (can be interrupted)
-void idle() {for(;;)asm("hlt");}
+void idle() {SET_INTERRUPTS; for(;;)asm("hlt");}
 
-void panic(struct cpu_status_t* ctx)
+uint8_t kernel_stack[KERNEL_STACK_SIZE] __attribute__((aligned(16)));
-{
-	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;
 
@@ -59,17 +55,17 @@ extern struct process_t* current_process;
 
 void pedicel_main(void* arg)
 {
-	
+	//printf("Hello, world from a KERNEL PROCESS!");
 }
 
 void two_main(void* arg)
 {
-
+	//printf("...process 2 speaking!!!");
 }
 
-void three_main(void* arg)
+void idle_main(void* arg)
 {
-
+	for(;;)asm("hlt");
 }
 
 // This is our entry point
@@ -83,6 +79,29 @@ void kmain()
 	boot_ctx.hhdm = hhdm_request.response ? hhdm_request.response : NULL;
 	boot_ctx.kaddr = kerneladdr_request.response ? kerneladdr_request.response : NULL;
 
+	pmm_init(boot_ctx.mmap, boot_ctx.hhdm);
+
+	// Remap kernel , HHDM and framebuffer
+	paging_init(boot_ctx.kaddr, boot_ctx.fb);
+
+	uint32_t bgColor = 0x252525;
+	ft_ctx = flanterm_fb_init(
+        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,
+        boot_ctx.fb->blue_mask_size, boot_ctx.fb->blue_mask_shift,
+        NULL,
+        NULL, NULL,
+        &bgColor, NULL, // &bgColor
+        NULL, NULL,
+        NULL, 0, 0, 1,
+        0, 0,
+        0,
+        0
+    );
+
 	serial_init();
 
 	memmap_display(boot_ctx.mmap);
@@ -94,27 +113,31 @@ void kmain()
 	idt_init();
 	timer_init();
 	
-	pmm_init(boot_ctx.mmap, boot_ctx.hhdm);
-
-	// Remap kernel , HHDM and framebuffer
-	paging_init(boot_ctx.kaddr, boot_ctx.fb);
-	
 	kheap_init();
 
 	vmm_init();
 	
+	struct process_t* idle_proc = process_create("idle", (void*)idle_main, 0);
 	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();
 
+	current_process = idle_proc; 
+    current_process->status = RUNNING;
+
 	SET_INTERRUPTS;
 
 	keyboard_init(FR);
-	term_init();
+	//term_init();
-	kputs(PEPPEROS_SPLASH);
+
+	//printf(PEPPEROS_SPLASH);
+
+	//printf("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur eu diam id sem tincidunt vestibulum. Etiam sed congue nisl, vitae aliquet orci. Donec magna turpis, semper sed ipsum eget, semper blandit dolor. Morbi faucibus posuere sapien. Vestibulum aliquet mi vel orci finibus, vestibulum rhoncus tellus sagittis. Vivamus a arcu suscipit sem iaculis volutpat vel nec est. Nulla malesuada, urna vel pretium pretium, enim tortor pulvinar velit, porttitor dictum lectus turpis id tortor. Quisque egestas ultricies lorem, egestas ultrices tellus elementum porta. Fusce consequat nisi in diam placerat fermentum. Suspendisse tempus turpis nec turpis condimentum fringilla. Maecenas nec orci pharetra, feugiat enim vel, viverra neque. Vivamus placerat purus in tincidunt ultricies. Pellentesque vel mi molestie, congue nibh nec, cursus nisl. Cras dapibus lectus mauris, sed interdum risus tristique non. ");
+
+	flanterm_write(ft_ctx, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur eu diam id sem tincidunt vestibulum. Etiam sed congue nisl, vitae aliquet orci. Donec magna turpis, semper sed ipsum eget, semper blandit dolor. Morbi faucibus posuere sapien. Vestibulum aliquet mi vel orci finibus, vestibulum rhoncus tellus sagittis. Vivamus a arcu suscipit sem iaculis volutpat vel nec est. Nulla malesuada, urna vel pretium pretium, enim tortor pulvinar velit, porttitor dictum lectus turpis id tortor. Quisque egestas ultricies lorem, egestas ultrices tellus elementum porta. Fusce consequat nisi in diam placerat fermentum. Suspendisse tempus turpis nec turpis condimentum fringilla. Maecenas nec orci pharetra, feugiat enim vel, viverra neque. Vivamus placerat purus in tincidunt ultricies. Pellentesque vel mi molestie, congue nibh nec, cursus nisl. Cras dapibus lectus mauris, sed interdum risus tristique non.", sizeof("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur eu diam id sem tincidunt vestibulum. Etiam sed congue nisl, vitae aliquet orci. Donec magna turpis, semper sed ipsum eget, semper blandit dolor. Morbi faucibus posuere sapien. Vestibulum aliquet mi vel orci finibus, vestibulum rhoncus tellus sagittis. Vivamus a arcu suscipit sem iaculis volutpat vel nec est. Nulla malesuada, urna vel pretium pretium, enim tortor pulvinar velit, porttitor dictum lectus turpis id tortor. Quisque egestas ultricies lorem, egestas ultrices tellus elementum porta. Fusce consequat nisi in diam placerat fermentum. Suspendisse tempus turpis nec turpis condimentum fringilla. Maecenas nec orci pharetra, feugiat enim vel, viverra neque. Vivamus placerat purus in tincidunt ultricies. Pellentesque vel mi molestie, congue nibh nec, cursus nisl. Cras dapibus lectus mauris, sed interdum risus tristique non. "));
 
 	idle();
 }

src/mem/heap/kheap.c

@@ -142,6 +142,6 @@ void kfree(void* ptr)
 // Should return a pointer to top of the stack (as stack grows DOWNWARDS)
 void* kalloc_stack()
 {
-    uint8_t* ptr = kmalloc(PROCESS_STACK_SIZE);
+    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;
 }

src/mem/paging/paging.c

@@ -24,7 +24,7 @@ If we use 1GB huge pages: PML4 -> PDPT -> 1gb pages
 4KB (regular size): PML4 -> PDPT -> PD -> PT -> 4kb pages
 */
 
-static inline void load_cr3(uint64_t value) {
+void load_cr3(uint64_t value) {
     asm volatile ("mov %0, %%cr3" :: "r"(value) : "memory");
 }
 
@@ -187,6 +187,14 @@ void paging_init()
     }
     DEBUG("Mapped %u pages for framebuffer", page_count);
 
+    // test for flanterm
+    // When 10 pages are mapped, SOMETIMES (1 out of 50 times) it prints everything without problem!
+    // Other times it prints garbage (almost full cursors) and/or panics.
+/*     for (uint64_t i=0; i<10; i++)
+    {
+        paging_map_page(kernel_pml4, 0, kernel_phys_base+KERNEL_SIZE+i*PAGE_SIZE, PTE_WRITABLE);
+    } */
+
     // Finally, we load the physical address of our PML4 (root table) into cr3
     load_cr3(VIRT_TO_PHYS(kernel_pml4));
     DEBUG("cr3 loaded, we're still alive");

src/mem/paging/paging.h

@@ -16,6 +16,9 @@
 void paging_init();
 void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_t flags);
 
+// To swap root page tables
+void load_cr3(uint64_t value);
+
 extern uint64_t hhdm_off;
 
 #define PHYS_TO_VIRT(x) ((void*)((uintptr_t)(x) + hhdm_off))

src/mem/paging/pmm.c

@@ -66,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/sched/process.c

@@ -11,10 +11,13 @@
 #include "string/string.h"
 #include "mem/gdt/gdt.h"
 #include "config.h"
+#include "io/serial/serial.h"
 
 struct process_t* processes_list;
 struct process_t* current_process;
 
+extern uint64_t *kernel_pml4;
+
 size_t next_free_pid = 0;
 
 void process_init()
@@ -52,15 +55,23 @@ struct process_t* process_create(char* name, void(*function)(void*), void* arg)
     proc->pid = next_free_pid++;
     proc->status = READY;
 
+    uint64_t* stack_top = (uint64_t*)kalloc_stack();
+    // push return address to the stack so when "ret" hits we jmp to exit instead of idk what
+    // stack grows DOWNWARDS!!
+    *(--stack_top) = (uint64_t)process_exit;
+
     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_rsp = (uint64_t)stack_top;
     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; 
 
+    // Kernel PML4 as it already maps code/stack (when switching to userland we'll have to change that)
+    proc->root_page_table = kernel_pml4;
+
     proc->next = 0;
 
     process_add(&processes_list, proc);
@@ -127,3 +138,39 @@ struct process_t* process_get_next(struct process_t* process)
     if (!process) return NULL;
     return process->next;
 }
+
+// (from gdt) This will switch tasks ONLY in ring 0
+// KERNEL CS = 0x08
+// KERNEL SS = 0x10
+__attribute__((naked, noreturn))
+void process_switch(uint64_t stack_addr, uint64_t code_addr)
+{
+    asm volatile(" \
+        push $0x10 \n\
+        push %0 \n\
+        push $0x202 \n\
+        push $0x08 \n\
+        push %1 \n\
+        iretq \n\
+        " :: "r"(stack_addr), "r"(code_addr));
+}
+
+
+// Will be used to clean up resources (if any, when we implement it)
+// Just mark as DEAD then idle. Scheduler will delete process at next timer interrupt % quantum.
+void process_exit()
+{
+    DEBUG("Exiting from process '%s'", current_process->name);
+    CLEAR_INTERRUPTS;
+    if (current_process)
+    {
+        current_process->status = DEAD;
+    }
+    SET_INTERRUPTS;
+    
+    outb(0x20, 0x20);
+    for (;;)
+    {
+        asm("hlt");
+    }
+}

src/sched/process.h

@@ -9,6 +9,7 @@
 
 #include <stddef.h>
 #include "config.h"
+#include <stdint.h>
 
 typedef enum 
 {
@@ -24,6 +25,7 @@ struct process_t
 
     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;
 };
 
@@ -32,6 +34,8 @@ 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_switch(uint64_t stack_addr, uint64_t code_addr);
+void process_exit();
 
 void process_display_list(struct process_t* processes_list);
 

src/sched/scheduler.c

@@ -6,6 +6,9 @@
 
 #include "kernel.h"
 #include "process.h"
+#include "mem/paging/paging.h"
+#include <stdint.h>
+#include "io/serial/serial.h"
 
 extern struct process_t* processes_list;
 extern struct process_t* current_process;
@@ -19,7 +22,7 @@ void scheduler_init()
 struct cpu_status_t* scheduler_schedule(struct cpu_status_t* context)
 {
     current_process->context = context;
-    current_process->status = READY;
+    //current_process->status = READY;
 
     for (;;) {
         struct process_t* prev_process = current_process;
@@ -41,6 +44,12 @@ struct cpu_status_t* scheduler_schedule(struct cpu_status_t* context)
         }
     }
     
-    DEBUG("current_process={pid=%u name='%s'}", current_process->pid, current_process->name);
+
+    // Current_process gets wrong context?? (iret_rip points to other stuff than process function; like putpixel() for example)
+    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");
+
     return current_process->context;
 }

src/sched/scheduler.h

@@ -7,7 +7,7 @@
 #ifndef SCHEDULER_H
 #define SCHEDULER_H
 
-void scheduler_schedule();
+struct cpu_status_t* scheduler_schedule(struct cpu_status_t* context);
 void scheduler_init();
 
 #endif

src/sched/task.S

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

symbols.py

@@ -0,0 +1,33 @@
+# Make assembly file from ELF symbols map
+# Then link it to kernel so it's aware of symbol names
+# then we can use that for the stack trace.
+
+print("Extracting symbols from map file to assembly...")
+
+with open("symbols.map", "r") as f:
+    lines = f.readlines()
+
+    symbols = []
+    for line in lines:
+        parts = line.split()
+        # output is formed like "address name"
+        symbols.append((parts[0], parts[1]))
+
+with open("symbols.S", "w") as f:
+    f.write("section .rodata\n")
+    f.write("global symbol_table\n")
+    f.write("global symbol_count\n")
+    f.write("symbol_table:\n")
+
+    for i, (addr, name) in enumerate(symbols):
+        f.write(f"    dq 0x{addr}\n")
+        f.write(f"    dq sym_name_{i}\n")
+
+    f.write("\nsymbol_count: dq " + str(len(symbols)) + "\n\n")
+
+    for i, (addr, name) in enumerate(symbols):
+        # escaping quotes
+        safe_name = name.replace('"', '\\"')
+        f.write(f'sym_name_{i}: db "{safe_name}", 0\n')
+
+print("Done!")