Keyboard buffer + getline

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:
+$(ELFFILE): $(BUILDDIR) $(OBJFILES)
-	mkdir -p build
+	nasm -f elf64 src/idt/idt.S -o $(BUILDDIR)/idt_stub.o
-	rm -f *.o build/*.o
+	$(LD) -o $(ELFFILE) -T linker.ld $(OBJFILES) $(BUILDDIR)/idt_stub.o
-	x86_64-elf-gcc -g -c -Isrc $(SOURCES) $(CC_PROBLEMATIC_FLAGS) $(CC_FLAGS)
+	# Get the symbols for debugging
-	mv *.o build/
+	nm -n $(ELFFILE) | awk '$$2 ~ /[TtDdBbRr]/ {print $$1, $$3}' > symbols.map
-	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
 	python3 symbols.py
-	nasm -f elf64 symbols.S -o build/symbols.o
+	nasm -f elf64 symbols.S -o $(BUILDDIR)/symbols.o
-	x86_64-elf-ld -o pepperk -T linker.ld build/*.o
+	$(LD) -o $(ELFFILE) -T linker.ld $(OBJFILES) $(BUILDDIR)/idt_stub.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`
+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:
-To run it with QEMU, `make run`
+
+```
+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/config.h

@@ -11,7 +11,7 @@
 #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"
+#define PEPPEROS_SPLASH "\x1b[38;5;196mPepperOS\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\n"
 
 /* process */
 #define PROCESS_NAME_MAX 64
@@ -39,6 +39,9 @@
 /* term */
 #define TERM_HISTORY_MAX_LINES 256
 
+/* kbd */
+#define KBD_BUFFER_MAX 256
+
 /* time */
 #define TIMER_FREQUENCY 1000
 

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

@@ -15,9 +15,9 @@ enum ErrorCodes {
 #define CLEAR_INTERRUPTS __asm__ volatile("cli")
 #define SET_INTERRUPTS __asm__ volatile("sti")
 
-#include "io/serial/serial.h"
+#include <io/serial/serial.h>
-#include "io/term/term.h"
+#include <io/term/term.h>
-#include "idt/idt.h"
+#include <idt/idt.h>
 #include <stdbool.h>
 
 extern volatile uint64_t ticks;

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 {

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/debug/misc.c

@@ -5,8 +5,8 @@
  */
 
 #include <kernel.h>
-#include "limine.h"
+#include <limine.h>
-#include "string/string.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 <idt/idt.h>
-#include "io/serial/serial.h"
+#include <io/serial/serial.h>
-#include "kernel.h"
+#include <kernel.h>
 
 extern struct init_status init;
 extern int panic_count;

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

@@ -4,16 +4,16 @@
  * @license GPL-3.0-only
  */
 
-#include "idt.h"
+#include <idt/idt.h>
 #include <stdint.h>
 #include <stddef.h>
-#include "io/serial/serial.h"
+#include <io/serial/serial.h>
-#include "io/kbd/ps2.h"
+#include <io/kbd/ps2.h>
 #include <kernel.h>
 #include <stdbool.h>
-#include "sched/scheduler.h"
+#include <sched/scheduler.h>
-#include "config.h"
+#include <config.h>
-#include "sched/process.h"
+#include <sched/process.h>
 
 struct interrupt_descriptor idt[256];
 struct idtr idt_reg;
@@ -258,7 +258,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/io/kbd/ps2.c

@@ -4,10 +4,11 @@
  * @license GPL-3.0-only
  */
 
-#include "io/serial/serial.h"
+#include "config.h"
-#include "ps2.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] =
@@ -214,6 +220,7 @@ void keyboard_handler()
                         }
                         // Should probably have a keyboard buffer here... instead of this
                         _putchar(c);
+                        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,7 +5,7 @@
  */
  
 #include <kernel.h>
-#include "serial.h"
+#include <io/serial/serial.h>
 
 extern struct init_status init;
 
@@ -61,8 +61,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;
 }
 

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 <io/term/flanterm.h>
-#include "fb.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,18 +13,18 @@ because this shitty implementation will be replaced one day by Flanterm
 
 #include <stddef.h>
 #include <kernel.h>
-#include "term.h"
+#include <io/term/term.h>
-#include "config.h"
+#include <config.h>
-#include "flanterm.h"
+#include <io/term/flanterm.h>
-#include "flanterm_backends/fb.h"
+#include <io/term/flanterm_backends/fb.h>
-#include "mem/heap/kheap.h"
+#include <mem/kheap.h>
-#include "limine.h"
+#include <limine.h>
 #include <stdarg.h>
-#include "sched/spinlock.h"
+#include <sched/spinlock.h>
-#include "io/serial/serial.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;
@@ -136,8 +136,8 @@ void term_init()
 {
 	uint32_t bgColor = 0x252525;
 	ft_ctx = flanterm_fb_init(
-        kmalloc,
+        NULL,
-        flanterm_free_wrapper,
+        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/kmain.c

@@ -7,24 +7,23 @@
 #include <stdbool.h>	
 #include <stddef.h>
 #include <limine.h>
-#include "io/term/term.h"
+#include <io/term/term.h>
-#include "io/term/term.h"
+#include <io/serial/serial.h>
-#include "io/serial/serial.h"
+#include <mem/gdt.h>
-#include "mem/gdt/gdt.h"
+#include <mem/utils.h>
-#include "mem/misc/utils.h"
+#include <idt/idt.h>
-#include "idt/idt.h"
+#include <kernel.h>
-#include "kernel.h"
+#include <time/timer.h>
-#include "time/timer.h"
+#include <io/kbd/ps2.h>
-#include "io/kbd/ps2.h"
+#include <mem/pmm.h>
-#include "mem/paging/pmm.h"
+#include <mem/paging.h>
-#include "mem/paging/paging.h"
+#include <mem/vmm.h>
-#include "mem/paging/vmm.h"
+#include <mem/kheap.h>
-#include "mem/heap/kheap.h"
+#include <sched/process.h>
-#include "sched/process.h"
+#include <sched/scheduler.h>
-#include "sched/scheduler.h"
+#include <config.h>
-#include "config.h"
+#include <io/term/flanterm.h>
-#include "io/term/flanterm.h"
+#include <io/term/flanterm_backends/fb.h>
-#include "io/term/flanterm_backends/fb.h"
 
 // Limine version used
 __attribute__((used, section(".limine_requests")))
@@ -69,7 +68,7 @@ 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!");
+	printf("\n\nWelcome to PepperOS! Pedicel speaking.\r\nNothing left to do, let's go idle!\r\n");
 }
 
 void idle_main(void* arg)
@@ -79,6 +78,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,15 +101,16 @@ 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();
+
 	boot_mem_display();
 	pmm_init(boot_ctx);
 
@@ -112,15 +120,13 @@ void kmain()
 
 	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_create("thing", thing_main, NULL);
 	process_display_list(processes_list);
 
 	scheduler_init();

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/kheap.h>
-#include "mem/paging/paging.h"
+#include <mem/paging.h>
-#include "mem/paging/pmm.h"
+#include <mem/pmm.h>
 #include <stddef.h>
 #include <kernel.h>
-#include "sched/process.h"
+#include <sched/process.h>
-#include "config.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 <mem/paging.h>
-#include "pmm.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:

src/mem/pmm.c

@@ -11,13 +11,13 @@ 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 <mem/paging.h>
 #include <limine.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <kernel.h>
-#include "mem/misc/utils.h"
+#include <mem/utils.h>
-#include "pmm.h"
+#include <mem/pmm.h>
 
 /*
 First we'll have to discover the physical memory layout,

src/mem/utils.c

@@ -7,8 +7,8 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <limine.h>
-#include "kernel.h"
+#include <kernel.h>
-#include "string/string.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 <mem/vmm.h>
-#include "paging.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 <sched/process.h>
-#include "mem/heap/kheap.h"
+#include <mem/kheap.h>
-#include "kernel.h"
+#include <kernel.h>
-#include "string/string.h"
+#include <string/string.h>
-#include "mem/gdt/gdt.h"
+#include <mem/gdt.h>
-#include "config.h"
+#include <config.h>
-#include "io/serial/serial.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 <kernel.h>
-#include "process.h"
+#include <sched/process.h>
-#include "mem/paging/paging.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;
@@ -69,10 +69,10 @@ struct cpu_status_t* scheduler_schedule(struct cpu_status_t* context)
         }
     }
 
-    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 <kernel.h>
-#include "spinlock.h"
+#include <sched/spinlock.h>
 
 /*
  * spinlock_acquire - Lock a lock

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.