Added PMM feature, Added new types, Updated limine

Author: to268

arch/x86_64/boot/kernel.c

@@ -15,7 +15,7 @@
  */
 #include <phoenix/kernel.h>
 #include <phoenix/serial.h>
-#include <phoenix/vga.h>
+#include <phoenix/mem.h>
 #include <cpuid.h>
 
 void kernel_main(void)

arch/x86_64/boot/stivale2/stivale2.c

@@ -16,14 +16,12 @@
 #include <phoenix/kernel.h>
 #include <phoenix/stivale2.h>
 #include <phoenix/serial.h>
-#include <phoenix/pmm.h>
-#include <phoenix/vga.h>
 #include <stivale2.h>
 #include <stdint.h>
 #include <stddef.h>
 
 /* Stack required by the stivale2 specifications */
-static uint8_t stack[4096];
+static u8 stack[4096];
 
 /*
 static struct stivale2_header_tag_framebuffer framebuffer_tag = {
@@ -41,20 +39,20 @@ static struct stivale2_header_tag_smp smp_tag = {
     .tag = {
         .identifier = STIVALE2_HEADER_TAG_SMP_ID,
         .next = 0,
-        //.next = (uint64_t)&framebuffer_tag,
+        //.next = (u64)&framebuffer_tag,
     },
     .flags = 0
 };
 */
 
 /* Base Stivale2 header */
-__attribute__((section(".stivale2hdr"), used))
+SECTION(".stivale2hdr")
 struct stivale2_header stivale_hdr = {
-    .entry_point = (uintptr_t)&init,
-    .stack = (uintptr_t)stack + sizeof(stack),
+    .entry_point = (uptr)&init,
+    .stack = (uptr)stack + sizeof(stack),
     .flags = 0,
     .tags = 0,
-    /*.tags = (uint64_t)&smp_tag, */
+    /*.tags = (u64)&smp_tag, */
 };
 
 void stivale2_print_fb_tag(struct stivale2_struct_tag_framebuffer* fb_tag)
@@ -94,7 +92,7 @@ void stivale2_print_smp_tag(struct stivale2_struct_tag_smp* smp_tag)
 void stivale2_print_memmap(struct stivale2_struct_tag_memmap* memmap_tag)
 {
     info("Memmap Entries: %d\n", memmap_tag->entries);
-    for (uint64_t i = 0; i < memmap_tag->entries; i++) {
+    for (u64 i = 0; i < memmap_tag->entries; i++) {
         struct stivale2_mmap_entry* current_entry = &memmap_tag->memmap[i];
         switch (current_entry->type) {
 
@@ -140,7 +138,7 @@ void stivale2_print_memmap(struct stivale2_struct_tag_memmap* memmap_tag)
     info("\n");
 }
 
-void* stivale2_get_tag(struct stivale2_struct* hdr, uint64_t id)
+void* stivale2_get_tag(struct stivale2_struct* hdr, u64 id)
 {
     struct stivale2_tag* current_tag = (void*)hdr->tags;
     for (;;) {
@@ -159,8 +157,8 @@ void* stivale2_get_tag(struct stivale2_struct* hdr, uint64_t id)
     }
 }
 
-struct usable_memory_hdr
-stivale2_get_usable_memory(struct stivale2_struct* hdr)
+struct free_memory_hdr
+stivale2_get_free_memory(struct stivale2_struct* hdr)
 {
     /* Get memmap tag */
     struct stivale2_struct_tag_memmap* memmap_tag;
@@ -172,39 +170,46 @@ stivale2_get_usable_memory(struct stivale2_struct* hdr)
         panic("No stivale2 memmap tag has been found !\n");
     }
 
-    /* Get Usable Entries */
-    struct usable_memory_hdr usable_hdr;
-    struct usable_memory entry;
-    usable_hdr.entries = 0;
-    uint64_t i;
-    for (i = 0; i < memmap_tag->entries; i++) {
+    /* Get free entries */
+    struct free_memory_hdr free_hdr;
+    struct free_memory entry;
+    uptr highest_memory = 0;
+    free_hdr.entries = 0;
+
+    for (u64 i = 0; i < memmap_tag->entries; i++) {
         struct stivale2_mmap_entry* current_entry = &memmap_tag->memmap[i];
 
-        usable_hdr.total_memory += entry.length;
+        free_hdr.total_memory += entry.length;
 
         if (current_entry->type == STIVALE2_MMAP_USABLE ||
             current_entry->type == STIVALE2_MMAP_KERNEL_AND_MODULES ||
-        current_entry->type == STIVALE2_MMAP_BOOTLOADER_RECLAIMABLE) {
+            current_entry->type == STIVALE2_MMAP_BOOTLOADER_RECLAIMABLE) {
 
             /* Found an Usable Entry */
             entry.base = current_entry->base;
             entry.length = current_entry->length;
-        entry.type = current_entry->type;
-            usable_hdr.segments[usable_hdr.entries] = entry;
+            entry.type = current_entry->type;
+            free_hdr.segments[free_hdr.entries] = entry;
+
+            debug("[STIVALE2_MEMMAP] Stored a free memory entry\n");
+
+            highest_memory = entry.base + entry.length;
 
-            debug("[STIVALE2_MEMMAP] Found an usable entry\n");
+            /* Store the highest free memory */
+            if (highest_memory > free_hdr.highest_memory)
+                free_hdr.highest_memory = highest_memory;
 
-            usable_hdr.usable_memory += entry.length;
-            usable_hdr.entries++;
+            free_hdr.free_memory += entry.length;
+            free_hdr.entries++;
         }
     }
 
     /* Panic if no entries are found */
-    if (usable_hdr.entries <= 0) {
-        panic("No usable memory has been found !\n");
+    if (free_hdr.entries <= 0) {
+        panic("No free memory has been found !\n");
     }
 
-    return usable_hdr;
+    return free_hdr;
 }
 
 char* stivale2_get_cmdline(struct stivale2_struct* hdr)

drivers/serial.c

@@ -19,11 +19,11 @@
 #include <phoenix/io.h>
 #include <stddef.h>
 
-static int serial_port_check(const uint16_t serial_port);
-static uint8_t serial_initialized = 0;
+static int serial_port_check(const u16 serial_port);
+static u8 serial_initialized = 0;
 
 /* Initialize serial connexion */
-int serial_init(const uint16_t serial_port, uint16_t baud_divisor)
+int serial_init(const u16 serial_port, uint16_t baud_divisor)
 {
     /* Check is the serial port is supported */
     if (serial_port_check(serial_port)) return 1;
@@ -50,7 +50,7 @@ int serial_init(const uint16_t serial_port, uint16_t baud_divisor)
 }
 
 /* Check if a serial port is valid */
-static int serial_port_check(const uint16_t serial_port)
+static int serial_port_check(const u16 serial_port)
 {
     if (serial_port == SERIAL_COM1 || serial_port == SERIAL_COM2 ||
         serial_port == SERIAL_COM3 || serial_port == SERIAL_COM4) {
@@ -60,7 +60,7 @@ static int serial_port_check(const uint16_t serial_port)
 }
 
 /* Check if we can receive data */
-int serial_received(const uint16_t serial_port)
+int serial_received(const u16 serial_port)
 {
     /* Check is the serial port is supported */
     if (!serial_initialized || serial_port_check(serial_port)) return -1;
@@ -69,7 +69,7 @@ int serial_received(const uint16_t serial_port)
 }
 
 /* Read data thought serial */
-char serial_read(const uint16_t serial_port)
+char serial_read(const u16 serial_port)
 {
     /* Check is the serial port is supported */
     if (!serial_initialized || serial_port_check(serial_port)) return -1;
@@ -80,7 +80,7 @@ char serial_read(const uint16_t serial_port)
 }
 
 /* Read a string thought serial */
-void serial_readstring(const uint16_t serial_port, char* buff, size_t size)
+void serial_readstring(const u16 serial_port, char* buff, size_t size)
 {
     size_t i = 0;
     char c = serial_read(serial_port);
@@ -98,7 +98,7 @@ void serial_readstring(const uint16_t serial_port, char* buff, size_t size)
 }
 
 /* Check the end of the received data */
-static int serial_is_transmit_empty(const uint16_t serial_port)
+static int serial_is_transmit_empty(const u16 serial_port)
 {
     /* Check is the serial port is supported */
     if (!serial_initialized || serial_port_check(serial_port)) return -1;
@@ -107,7 +107,7 @@ static int serial_is_transmit_empty(const uint16_t serial_port)
 }
 
 /* Write a char thought serial */
-void serial_write(const uint16_t serial_port, const char c)
+void serial_write(const u16 serial_port, const char c)
 {
     /* Check is the serial port is supported */
     if (!serial_initialized || serial_port_check(serial_port)) return;
@@ -118,7 +118,7 @@ void serial_write(const uint16_t serial_port, const char c)
 }
 
 /* Write a string thought serial */
-void serial_writestring(const uint16_t serial_port, const char* string)
+void serial_writestring(const u16 serial_port, const char* string)
 {
     while (*string) {
         serial_write(serial_port, *(string++));

drivers/vga.c

@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <phoenix/serial.h>
+#include <phoenix/types.h>
 #include <phoenix/mem.h>
 #include <phoenix/vga.h>
 #include <phoenix/io.h>
@@ -24,12 +25,12 @@
 static const size_t VGA_WIDTH = 80;
 static const size_t VGA_HEIGHT = 25;
 static const size_t TAB_LENGTH = 4;
-static uint16_t* const VGA_MEMORY = (uint16_t*) 0xB8000;
+static u16* const VGA_MEMORY = (u16*) 0xB8000;
 
 static size_t vga_row;
 static size_t vga_column;
-static uint8_t vga_color;
-static uint16_t* vga_buffer = VGA_MEMORY;
+static u8 vga_color;
+static u16* vga_buffer = VGA_MEMORY;
 
 void vga_cursor_enable(void)
 {
@@ -45,23 +46,23 @@ void vga_cursor_disable(void)
     outb(0x3d5, 0x20);
 }
 
-uint16_t vga_cursor_get_pos(void)
+u16 vga_cursor_get_pos(void)
 {
-    uint16_t pos = 0;
+    u16 pos = 0;
     outb(0x3d4, 0x0f);
     pos |= inb(0x3d5);
     outb(0x3d4, 0x0e);
-    pos |= ((uint16_t) inb(0x3d5)) << 8;
+    pos |= ((u16) inb(0x3d5)) << 8;
     return pos;
 }
 
-void vga_cursor_set_pos(uint8_t x, uint8_t y)
+void vga_cursor_set_pos(u8 x, uint8_t y)
 {
-    uint16_t pos = y * VGA_WIDTH + x;
+    u16 pos = y * VGA_WIDTH + x;
     outb(0x3d4, 0x0f);
-    outb(0x3d5, (uint8_t) (pos & 0xff));
+    outb(0x3d5, (u8) (pos & 0xff));
     outb(0x3d4, 0x0e);
-    outb(0x3d5, (uint8_t) ((pos >> 8) & 0xff));
+    outb(0x3d5, (u8) ((pos >> 8) & 0xff));
 }
 
 void vga_clear(void)
@@ -90,12 +91,12 @@ void vga_init(void)
     debug("[VGA] Initialized\n");
 }
 
-void vga_setcolor(uint8_t color)
+void vga_setcolor(u8 color)
 {
 	vga_color = color;
 }
 
-void vga_putentryat(unsigned char c, uint8_t color, size_t x, size_t y)
+void vga_putentryat(unsigned char c, u8 color, size_t x, size_t y)
 {
 	const size_t index = y * VGA_WIDTH + x;
 	vga_buffer[index] = vga_entry(c, color);

include/phoenix/boot.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2021 Guillot Tony <tony.guillot@protonmail.com>
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _BOOT_H_
+#define _BOOT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <phoenix/stivale2.h>
+#include <phoenix/types.h>
+#include <stivale2.h>
+#include <stdint.h>
+
+#define LIMIT_SEGMENTS 64
+
+struct free_memory {
+    u64 base;
+    u64 length;
+    u32 type;
+} PACKED;
+
+struct free_memory_hdr {
+    u64 entries;
+    u64 free_memory;
+    u64 total_memory;
+    uptr highest_memory;
+    struct free_memory segments[LIMIT_SEGMENTS];
+} PACKED;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BOOT_H_ */

include/phoenix/gdt.h

@@ -20,22 +20,23 @@
 extern "C" {
 #endif
 
+#include <phoenix/types.h>
 #include <stdint.h>
 
 struct gdt_pointer {
-    uint16_t    limit;
-    uint64_t    base;
-} __attribute__((packed));
+    u16 limit;
+    u64 base;
+} PACKED;
 
 struct gdt_descriptor {
-    uint16_t    limit_low;      /* The low 16 bits of the limit of the segment */
-    uint16_t    base_low;       /* The low 16 bits of the base of the segment */
-    uint8_t     base_mid;       /* The middle 8 bits of the base of the segment */
-
-    uint8_t     access;         /* The 8 bits descriptor type */
-    uint8_t     limit_flags;    /* The high 4 bits of the limit and The 4 bits flags */
-    uint8_t     base_high;      /* The high 8 bits of the base of the segment */
-} __attribute__((packed));
+    u16 limit_low;   /* The low 16 bits of the limit of the segment */
+    u16 base_low;    /* The low 16 bits of the base of the segment */
+    u8  base_mid;    /* The middle 8 bits of the base of the segment */
+
+    u8  access;      /* The 8 bits descriptor type */
+    u8  limit_flags; /* The high 4 bits of the limit and The 4 bits flags */
+    u8  base_high;   /* The high 8 bits of the base of the segment */
+} PACKED;
 
 void gdt_init(void);