Paging (#38)

* page entries

* rename file

* present setter

* missspel...

* paging unstable identity mapping

* add to header

* rename to `paging_init`

* fix global asm export

* dereference esp

* add paging init to kernel main

* fix kernel logs

* bitmap funcs

* make multiple page dirs

* move init funcs to the bottom & unwrap eaw data from the struct

* register page fault

* simple frame allocators

* high-half kernel mapping

* add kernel end symbol

* add some  defines to `paging.h`

* remove transfering func

* fix bootstrap end symbol rename

* unstatic arrays

* add `serial_write_hex_uint32`

* make `load_page_directory` auto detect virt addr

* remove some unused commented code

* pre ebp fix state commit

* memmove

* fix move stack

* gdt

* BUGGED add kernel gdt init

* fix no irq's

* packed improvement

* fix gdt incorect init

* bootstrap_qemu_serial

* remove bootstrap_qemu_serial commented code from `bootstarp/lib`

* `bootstrap_dump_mappings`

* add intended `sti` before mouse driver init

* BUGGED remap vga vram

* add comment with useful debug qemu args

* messing around in kernel main

* add this to separate option

* rename it

* kernel high half mapping now works
I GODDAMN DO IT.

* remove static from func that should not

* wow, theres was a bug all that time

* page/dir alloc and mappinf system

* fix missed include

* fix warns

* Update README

* rename `bootstrap_rodata` section

* remove generated tag from linker script
actualy the lastone i wroteby myself

Author: Remenod

.gitattributes

@@ -1,2 +1 @@
 Makefile linguist-generated
-*.ld linguist-generated

Makefile

@@ -2,7 +2,7 @@
 
 A bare-metal educational operating system project for x86, originally created to implement the classic **Snake** game in protected mode without any external dependencies. The project boots from the **MBR** via BIOS and runs directly on the hardware (or QEMU).  
 
-Over time it has grown into a small experimental OS with exception handling, keyboard input, VGA text/graphics modes, custom fonts, palette control, a stack guard mechanism, and multiple demo applications.
+Over time it has grown into a small experimental OS with exception handling, keyboard input, VGA text/graphics modes, custom fonts, palette control, paging, and multiple demo applications.
 
 ---
 
@@ -19,9 +19,7 @@ Over time it has grown into a small experimental OS with exception handling, key
   - VGA driver with support for text mode `0x03` and graphics mode `0x13`.
   - DAC palette setup and custom font loading.
   - Global settings system
-  - Expand-down stack segment with **Stack Guard**:
-    - Warns at 75% stack usage.
-    - Triggers a custom **Stack Overflow Interrupt** at 100%.
+  - High-half kernel mapping
   - **Red Screen of Death (RSoD)** kernel panic screen.
 - No dependency on `libc` or any external libraries.
 - Fully freestanding kernel (written in C, C++ and assembly).
@@ -45,14 +43,42 @@ Over time it has grown into a small experimental OS with exception handling, key
 ## Repository Structure
 
 ```
-boot/         - Bootloader (boot.asm, MBR)
-include/      - Public headers (arch, drivers, kernel, lib)
-src/          - Kernel, architecture-specific code, drivers, applications
-  apps/       - Demo programs (Snake, Sandbox, Roulette, etc.)
-  arch/x86/   - Interrupt handling, ports, PIC, PIT
-  kernel/     - Core kernel and drivers
-  lib/        - Custom C standard library replacement
-Makefile      - Build system
+boot/                     - Early boot code (MBR)
+
+include/                  - Public kernel headers
+  arch/x86/               - x86-specific headers
+    interrupts/           - IDT, ISR, PIC
+    paging/               - Paging, bootstrap paging, GDT
+    timer/                - PIT timer
+    ports.h               - I/O port access
+  drivers/                - Keyboard, mouse, screen, VGA, serial
+  kernel/                 - Diagnostics, memory, settings
+  lib/                    - Custom C library headers
+
+src/                      - Kernel sources
+  apps/                   - User-facing demo applications
+    app_selector/         - Application switcher
+    mouse_playground/     - Mouse interaction demo
+    rsod_roulette/        - RSOD roulette easter egg
+    segment_test/         - Segment register test
+    settings_manager/     - Kernel settings app
+    snake/                - Snake game
+    text_sandbox/         - Text demo sandbox
+  arch/x86/               - Architecture-specific implementation
+    diagnostics/          - RSOD and warning routines
+    interrupts/           - IDT, ISR, PIC, CPU exception handlers
+    paging/               - Paging system, bootstrap paging
+    timer/                - PIT implementation
+    ports.c               - port I/O
+  kernel/                 - Core kernel logic and entry point
+    core/                 - Kernel bootstrap and memory init
+    drivers/              - Driver implementations
+    kernel_entry.asm      - Kernel entry point
+    linker.ld             - Linker script
+  lib/                    - Custom libc-like implementation (string, mem, math, etc.)
+
+Makefile                  - Build rules
+
 ```
 
 ---
@@ -126,7 +152,7 @@ sudo apt install nasm qemu-system-i386
 make
 ```
 
-This produces `build/snake.img`, a bootable raw image.
+This produces `build/metabar.img`, a bootable raw image.
 
 ### Run in QEMU
 ```bash
@@ -142,9 +168,9 @@ make clean
 
 ## Running on Real Hardware
 
-1. Write `build/snake.img` to the beginning of a storage device (e.g. USB stick) since the bootloader is in the MBR:
+1. Write `build/metabar.img` to the beginning of a storage device (e.g. USB stick) since the bootloader is in the MBR:
    ```bash
-   sudo dd if=build/snake.img of=/dev/sdX bs=512
+   sudo dd if=build/metabar.img of=/dev/sdX bs=512
    ```
 2. Boot from it using BIOS (legacy boot).
 3. A **PS/2 keyboard** is required. If using USB, make sure **USB-PS/2 emulation** is enabled in BIOS/UEFI.
@@ -182,10 +208,15 @@ make clean
 ## Future Plans
 
 - Dynamic memory allocation.
-- Paging support.
 - Additional demo applications (possibly **Tetris**).
 - Snake AI mode using pre-trained weights.
 - Further expansion of VGA graphics features.
+- USB driver
+- Hard drive driver
+- File System driver
+- ELF executor
+- Paging based Stack Guard
+- User mode (CPL3)
 
 ---
 
@@ -200,10 +231,3 @@ External sources:
   License: Public domain.  
 
 Many theoretical references were taken from [OSDev Wiki](https://wiki.osdev.org).
-
----
-
-## Disclaimer
-
-This project is experimental and intended as a learning resource.  
-It runs in **ring 0 only** (CPL0), with no user mode (CPL3).  

README.md

@@ -172,7 +172,7 @@ init_pm:
   jmp $
 
 ; ===== STRINGS =====
-msg_loading_kernel db "Loading kernel...", 0
+msg_loading_kernel db "Loading kernel... ", 0
 msg_kernel_loaded  db "Kernel loaded!", 0
 msg_disk_error     db "Disk read error", 0
 

boot/boot.asm

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <lib/types.h>
+#include <paging/page_directory.h>
+
+void bootstrap_setup_mapping(void);
+void bootstrap_enable_global_pages(void);
+void bootstrap_enable_paging(void);

include/arch/x86/paging/bootstrap/bootstrap_paging.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <lib/types.h>
+
+uint8_t bootstrap_inb(uint16_t port);
+void bootstrap_outb(uint16_t port, uint8_t data);
+int bootstrap_serial_is_transmit_empty();
+void bootstrap_serial_write_char(char c);
+void bootstrap_serial_write_uint8(uint8_t value);
+void bootstrap_serial_write_uint32(uint32_t value);
+void bootstrap_serial_write_hex_uint8(unsigned char byte);
+void bootstrap_serial_write_hex_uint32(uint32_t value);

include/arch/x86/paging/bootstrap/bootstrap_qemu_serial.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <lib/types.h>
+
+void bootstrap_set_bitmap8_val(uint8_t bitmap[], size_t index, bool_t val);
+bool_t bootstrap_get_bitmap8_val(uint8_t bitmap[], size_t index);
+void *bootstrap_memcpy(void *dest, const void *src, uint32_t n);

include/arch/x86/paging/bootstrap/lib.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <lib/types.h>
+
+typedef enum __attribute__((packed))
+{
+    tss_16_avl = 1,
+    ldt = 2,
+    tss_16_busy = 3,
+    call_gate_16 = 4,
+    task_gate = 5,
+    int_gate_16 = 6,
+    trap_gate_16 = 7,
+    tss_32_avl = 8,
+    tss_32_busy = 10,
+    call_gate_32 = 11,
+    int_gate_32 = 12,
+    trap_gate_32 = 13
+} system_descriptor_type_t;
+
+typedef struct
+{
+    uint8_t present : 1;
+    uint8_t cpl : 2;
+    // should be 0
+    uint8_t desc_type : 1;
+    system_descriptor_type_t type : 4;
+} __attribute__((packed)) system_access_byte_t;
+
+typedef struct
+{
+    uint8_t present : 1;
+    uint8_t cpl : 2;
+    // should be 1
+    uint8_t desc_type : 1;
+    // should be 0
+    uint8_t datacode_desc_type : 1;
+    uint8_t conforming : 1;
+    uint8_t readable : 1;
+    uint8_t accessed : 1;
+} __attribute__((packed)) code_access_byte_t;
+
+typedef struct
+{
+    uint8_t present : 1;
+    uint8_t cpl : 2;
+    // should be 1
+    uint8_t desc_type : 1;
+    // should be 1
+    uint8_t datacode_desc_type : 1;
+    uint8_t expand_down : 1;
+    uint8_t writeable : 1;
+    uint8_t accessed : 1;
+} __attribute__((packed)) data_access_byte_t;
+
+typedef struct
+{
+    // 16 bits
+    uint16_t limit_low;
+    // 16 bits
+    uint16_t base_low;
+    // 8 bits
+    uint8_t base_mid;
+    union
+    {
+        system_access_byte_t system;
+        code_access_byte_t code;
+        data_access_byte_t data;
+    } access;
+    /*
+    4 bits
+    1 - Granularity
+    1 - Default/Big (0 - 16bit, 1 - 32bit)
+    0 - 64bit
+    0 - Available for use by system software
+    */
+    uint8_t flags : 4;
+    // 4 bits
+    uint8_t limit_high : 4;
+    // 8 bits
+    uint8_t base_high;
+} __attribute__((packed)) gdt_entry_t;
+
+typedef struct
+{
+    uint16_t limit;
+    gdt_entry_t *base;
+} __attribute__((packed)) gdt_ptr_t;
+
+void gdte_set_limit(gdt_entry_t *inst, uint32_t lim);
+void gdte_set_base(gdt_entry_t *inst, uint32_t base);
+void gdte_init_code(gdt_entry_t *inst, uint32_t base, uint32_t limit, bool_t conforming, bool_t readable);
+void gdte_init_data(gdt_entry_t *inst, uint32_t base, uint32_t limit, bool_t expand_down, bool_t writeable);
+void gdte_init_system(gdt_entry_t *inst, uint32_t base, uint32_t limit, system_descriptor_type_t type);

include/arch/x86/paging/gdt.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <lib/types.h>
+
+typedef struct
+{
+    union
+    {
+        struct
+        {
+            uint32_t present : 1;  // 0 = not present, 1 = present
+            uint32_t rw : 1;       // 0 = read only, 1 = read/write
+            uint32_t us : 1;       // 0 = kernel, 1 = user
+            uint32_t pwt : 1;      // Write-through
+            uint32_t pcd : 1;      // Cache disable
+            uint32_t accessed : 1; // CPU sets on access
+            uint32_t ps : 1;       // Page size: 0 = 4 KiB, 1 = 4 MiB
+            uint32_t reserved : 1; // reserved
+            uint32_t avl : 4;      // available for OS
+            uint32_t addr : 20;    // [31:12] physical address (aligned)
+        } fields;
+        uint32_t raw_data;
+    };
+
+} pde_t;
+
+/* addr format is addrs from 0x00000000 to 0xFFFFF000 range */
+inline void pde_set_addr(pde_t *entry, uint32_t phys_addr) { entry->fields.addr = phys_addr >> 12; }
+
+/* set flags (lower 12 bits) */
+inline void pde_set_flags(pde_t *entry, uint16_t flags) { entry->raw_data = (entry->raw_data & 0xFFFFF000) | (flags & 0x0FFF); }
+
+/* Present
+ true = present | false = not present */
+inline void pde_set_present_flag(pde_t *entry, bool_t val) { entry->fields.present = val != 0; };
+
+/* ReadWrite
+ true = read/write | false = readonly */
+inline void pde_set_rw_flag(pde_t *entry, bool_t val) { entry->fields.rw = val != 0; }
+
+/* User/Supervisor
+false = ring 0 only | true = allow ring 3 */
+inline void pde_set_us_flag(pde_t *entry, bool_t val) { entry->fields.us = val != 0; }
+
+/* Page-level Write-Through
+false = Write-back(more effective) | true = Write-through(direct ram write) */
+inline void pde_set_pwt_flag(pde_t *entry, bool_t val) { entry->fields.pwt = val != 0; }
+
+/* Page-level Cache Disable - used for MMIO
+false = caching | true = no caching */
+inline void pde_set_pcd_flag(pde_t *entry, bool_t val) { entry->fields.pcd = val != 0; }
+
+/* User/Supervisor
+false = ring 0 only | true = allow ring 3 */
+inline void pde_set_ps_flag(pde_t *entry, bool_t val) { entry->fields.ps = val != 0; }
+
+/* Available for OS - any info. CPU will ignore that
+Any 4(!) bits*/
+inline void pde_set_avl_flag(pde_t *entry, uint8_t val) { entry->fields.avl = (val & 0xF); }
+
+inline uint8_t pde_get_avl_flag(pde_t *entry) { return entry->fields.avl; }
+inline bool_t pde_get_accesed_flag(pde_t *entry) { return entry->fields.accessed; }
+
+/* addr may be in 0x00000000 to 0xFFFFF000 range */
+inline void pde_init(pde_t *entry, uint32_t addr, bool_t rw, bool_t us, bool_t pwt, bool_t pcd, bool_t ps, uint8_t avl)
+{
+    pde_set_addr(entry, addr);
+    pde_set_rw_flag(entry, rw);
+    pde_set_us_flag(entry, us);
+    pde_set_pwt_flag(entry, pwt);
+    pde_set_pcd_flag(entry, pcd);
+    pde_set_ps_flag(entry, ps);
+    pde_set_avl_flag(entry, avl);
+    pde_set_present_flag(entry, 1);
+    entry->fields.accessed = 0;
+    entry->fields.reserved = 0;
+}