Distinguishing between HAL and Kernel

x64/src/asm/hal/io.asm

@@ -3,6 +3,7 @@ global hal_read_port
 global hal_enable_interrupt
 global hal_disable_interrupt
 global hal_interrupt_handler_wrapper
+global hal_halt_cpu
 extern hal_interrupt_handler_dummy
 
 %macro pushaq 0
@@ -73,4 +74,8 @@ cld
 call hal_interrupt_handler_dummy
 popaq
 xchg bx,bx
-iretq
+iretq
+
+hal_halt_cpu:
+hlt
+ret

x64/src/asm/hal/mem.asm

@@ -2,6 +2,8 @@ global hal_flush_gdt
 global hal_flush_tlb
 global hal_flush_idt
 global hal_cpuid
+global hal_read_page_base
+global hal_write_page_base
 ;Functions preserve the registers rbx, rsp, rbp, r12, r13, r14, and 15
 ;rax, rdi, rsi, rdx, rcx, r8, r9, r10, r11 are scratch registers.
 ;function parameter: rdi,rsi,rdx,rcx,r8,r9
@@ -58,4 +60,12 @@ hal_flush_idt:
 lidt [rdi]
 ret
 
+;read_cr3
+hal_read_page_base:
+mov rax,cr3
+ret
 
+;write_cr3
+hal_write_page_base:
+mov cr3,rdi
+ret

x64/src/c/common/lib/mem.c

@@ -1,5 +1,5 @@
-#include "../type.h"
-#include "../kdef.h"
+#include "../sys/type.h"
+#include "../sys/kdef.h"
 #include "mem.h"
 
 void NATIVE64 mem_copy(void *src, void *dst, uint64_t size)

x64/src/c/common/lib/mem.h

@@ -1,8 +1,8 @@
 #ifndef _HAL_MEM_H_
 #define _HAL_MEM_H_
 
-#include "../type.h"
-#include "../kdef.h"
+#include "../sys/type.h"
+#include "../sys/kdef.h"
 
 void NATIVE64 mem_copy(void *src, void *dst, uint64_t size);
 

x64/src/c/common/lib/str.h

@@ -1,8 +1,8 @@
 #ifndef _STR_H_
 #define _STR_H_
 
-#include "../kdef.h"
-#include "../type.h"
+#include "../sys/kdef.h"
+#include "../sys/type.h"
 
 uint64_t NATIVE64 str_len(char const *str);
 uint64_t NATIVE64 str_cmp(char const *str1, char const *str2);

x64/src/c/common/sys/kdef.h

@@ -2,6 +2,7 @@
 #define _KDEF_H_
 
 #include <stddef.h>
+#include <stdarg.h>
 
 #define NATIVE64 __attribute__((sysv_abi))
 

x64/src/c/common/sys/sys_info.h

@@ -0,0 +1,28 @@
+#ifndef _SYS_INFO_H_
+#define _SYS_INFO_H_
+#include "type.h"
+#include "../util/list/linked_list/linked_list.h"
+
+#define MEMORY_OCCUPIED 0
+#define MEMORY_AVAILABLE 1
+#define MEMORY_RESERVED 2
+
+typedef struct
+{
+    uint64_t base_addr;
+    uint64_t size;
+    uint32_t type;
+    linked_list_node_t list_node;
+} memory_descriptor_node_t;
+
+typedef struct {
+    linked_list_t* mem_seg_list;     // a list containing memory_descriptor_node_t nodes
+    uint64_t mem_reserved;
+    uint64_t mem_available;
+} mem_info_t;
+
+typedef struct {
+    mem_info_t* mem_info;    // all available memory info
+} boot_info_t;
+
+#endif

x64/src/c/common/util/list/linked_list/linked_list.c

@@ -1,4 +1,4 @@
-#include "../../../kdef.h"
+#include "../../../sys/kdef.h"
 #include "linked_list.h"
 
 void NATIVE64 linked_list_node_init(linked_list_node_t * node)

x64/src/c/common/util/list/linked_list/linked_list.h

@@ -1,6 +1,6 @@
 #ifndef _LINKED_LIST_H_
 #define _LINKED_LIST_H_
-#include "../../../kdef.h"
+#include "../../../sys/kdef.h"
 typedef struct _linked_list_node_t
 {
     struct _linked_list_node_t * prev;

x64/src/c/common/util/tree/avl_tree/avl_tree.c

@@ -1,4 +1,4 @@
-#include "../../../kdef.h"
+#include "../../../sys/kdef.h"
 #include "avl_tree.h"
 
 #define MAX(a, b) (((a) > (b) ? (a) : (b)))

x64/src/c/common/util/tree/avl_tree/avl_tree.h

@@ -1,6 +1,6 @@
 #ifndef _AVL_TREE_H_
 #define _AVL_TREE_H_
-#include "../../../kdef.h"
+#include "../../../sys/kdef.h"
 
 typedef struct _avl_tree_node_t
 {

x64/src/c/common/util/util.h

@@ -1,6 +1,6 @@
 #ifndef _UTIL_H_
 #define _UTIL_H_
-#include "../type.h"
+#include "../sys/type.h"
 #define OBTAIN_STRUCT_ADDR(member_addr, member_name, struct_name) ((struct_name*)((char*)(member_addr)-(uint64_t)(&(((struct_name*)0)->member_name))))
 
 #endif

x64/src/c/hal/hal.c

@@ -1,16 +1,17 @@
 #include "hal.h"
-#include "multiboot.h"
 #include "print.h"
 #include "mem.h"
 #include "io.h"
 #include "var.h"
-#include "../common/util/list/linked_list/linked_list.h"
 #include "../common/util/util.h"
+#include "../common/sys/sys_info.h"
+#include "../common/util/list/linked_list/linked_list.h"
 
-void NATIVE64 hal_init(multiboot_info_t* m_info)
+boot_info_t* NATIVE64 hal_init(multiboot_info_t* m_info)
 {
     text_pos = get_pos(3, 0);
-    hal_printf("Setting up GDT...\n");
+
+    // get gdt ready
     hal_write_segment_descriptor((void *) &g_gdt[0], 0, 0, 0);
     hal_write_segment_descriptor((void *) &g_gdt[8], 0, 0, SEG_DPL_0 | SEG_CODE_DATA | SEG_PRESENT | SEG_LONG | SEG_TYPE_CODE_X);
     hal_write_segment_descriptor((void *) &g_gdt[16], 0, 0, SEG_DPL_0 | SEG_CODE_DATA | SEG_PRESENT | SEG_LONG | SEG_TYPE_DATA_RW);
@@ -25,13 +26,27 @@ void NATIVE64 hal_init(multiboot_info_t* m_info)
     g_gdt_ptr.limit = 8*9-1;
     hal_flush_gdt(&g_gdt_ptr, SEG_SELECTOR(1, 0), SEG_SELECTOR(2, 0));
 
+    // get idt ptr ready
+    g_idt_ptr.base = (uint64_t)g_idt;
+    g_idt_ptr.limit = 21*16-1;
+    hal_flush_idt(&g_idt_ptr);
+
+
+    boot_info_t* boot_info = (boot_info_t*)hal_halloc(sizeof(boot_info_t));
+    boot_info->mem_info = (mem_info_t*)hal_halloc(sizeof(mem_info_t));
+    boot_info->mem_info->mem_available = 0;
+    boot_info->mem_info->mem_reserved = 0;
+    boot_info->mem_info->mem_seg_list = (linked_list_t*)hal_halloc((sizeof(linked_list_t)));
+    boot_info->mem_info->mem_seg_list->head = NULL;
+    boot_info->mem_info->mem_seg_list->size = 0;
+
+    // obtain boot information
+
+    // memory info
     if(m_info->flags & (1 << 6))
     {
         multiboot_memory_map_t const *mem_map = (multiboot_memory_map_t *) m_info->mmap_addr;
         uint64_t const mem_map_size = m_info->mmap_length / sizeof(multiboot_memory_map_t);
-        hal_printf("Initializing memory descriptors...\n");
-        uint64_t total_available_mem = 0;
-        uint64_t total_reserved_mem = 0;
         for (int i = 0; i < mem_map_size; i++)
         {
             memory_descriptor_node_t* each_desc = (memory_descriptor_node_t*)hal_halloc(sizeof(memory_descriptor_node_t));
@@ -40,31 +55,24 @@ void NATIVE64 hal_init(multiboot_info_t* m_info)
             if((mem_map + i)->type == MULTIBOOT_MEMORY_RESERVED)
             {
                 each_desc->type = MEMORY_RESERVED;
-                total_reserved_mem += (mem_map + i)->len;
+                boot_info->mem_info->mem_reserved += (mem_map + i)->len;
             }
             else if ((mem_map + i)->type == MULTIBOOT_MEMORY_AVAILABLE)
             {
                 each_desc->type = MEMORY_AVAILABLE;
-                total_available_mem += (mem_map + i)->len;
+                boot_info->mem_info->mem_available += (mem_map + i)->len;
             }
-            linked_list_add(&mem_desc, &each_desc->list_node);
-        }
-        // TODO: total RAM should be in memory descriptors list
-        hal_printf("Total available memory: %uB, %uKB, %uMB.\n", total_available_mem, total_available_mem / 1024,
-                   total_available_mem / 1024 / 1024);
-        hal_printf("Total reserved memory: %uB, %uKB, %uMB.\n", total_reserved_mem, total_reserved_mem / 1024,
-                   total_reserved_mem / 1024 / 1024);
-        hal_printf("Memory Segments:\nBase - Size - Type\n");
-        for(int i = 0; i < mem_desc.size; i++)
-        {
-            memory_descriptor_node_t* each_node = OBTAIN_STRUCT_ADDR(linked_list_get(&mem_desc,i), list_node, memory_descriptor_node_t);
-            hal_printf("%X - %X - %s\n", each_node->base_addr, each_node->size, each_node->type == MEMORY_AVAILABLE ? "Available" : "Reserved");
+            linked_list_add(boot_info->mem_info->mem_seg_list, &each_desc->list_node);
         }
     }
     else
     {
-        hal_printf("Memory information is currently unavailable.\n");
+        // halt machine
+        hal_printf("HAL: Cannot detect memory information.");
+        hal_halt_cpu();
     }
+
+    // detect APIC
     cpuid_t cpuid_info;
     cpuid_info.eax = 1;
     cpuid_info.ebx = 0;
@@ -73,17 +81,14 @@ void NATIVE64 hal_init(multiboot_info_t* m_info)
     hal_cpuid(&cpuid_info.eax,&cpuid_info.ebx,&cpuid_info.ecx,&cpuid_info.edx);
     if(cpuid_info.edx & 1 << 9)
     {
-        hal_printf("APIC detected...\n");
+        //TODO: detected.
     }
-
-
-    for(uint64_t i = 0; i <= 21; i++)
+    else
     {
-        hal_set_interrupt_handler(i, hal_interrupt_handler_wrapper);
+        // halt machine
+        hal_printf("HAL: Cannot detect APIC.");
+        hal_halt_cpu();
     }
-    g_idt_ptr.base = (uint64_t)g_idt;
-    g_idt_ptr.limit = 21*16-1;
-    hal_flush_idt(&g_idt_ptr);
 
-    return;
+    return boot_info;
 }

x64/src/c/hal/hal.h

@@ -1,15 +1,16 @@
 #ifndef _HAL_HAL_H_
 #define _HAL_HAL_H_
-#include "../common/kdef.h"
-#include "../common/type.h"
+#include "../common/sys/kdef.h"
+#include "../common/sys/type.h"
 #include "multiboot.h"
+#include "../common/sys/sys_info.h"
 
 //concurrency
 extern void NATIVE64 hal_spin_lock(uint32_t * lock);
 extern void NATIVE64 hal_spin_unlock(uint32_t * lock);
 
 //inti
-void NATIVE64 hal_init(multiboot_info_t* m_info);
+boot_info_t* NATIVE64 hal_init(multiboot_info_t* m_info);
 
 //debug
 extern void NATIVE64 HLT_CPU(void);

x64/src/c/hal/io.h

@@ -1,7 +1,7 @@
 #ifndef _HAL_IO_H_
 #define _HAL_IO_H_
-#include "../common/kdef.h"
-#include "../common/type.h"
+#include "../common/sys/kdef.h"
+#include "../common/sys/type.h"
 
 #define GATE_DPL_0 (0ull << 13)
 #define GATE_DPL_1 (1ull << 13)
@@ -20,6 +20,7 @@ void NATIVE64 hal_set_interrupt_handler(uint64_t index, void (*handler)());
 extern void NATIVE64 hal_enable_interrupt();
 extern void NATIVE64 hal_disable_interrupt();
 extern void NATIVE64 hal_interrupt_handler_wrapper();
+extern void NATIVE64 hal_halt_cpu();
 
 void NATIVE64 hal_write_gate(void *const gate, uint64_t const offset, uint32_t const selector, uint32_t const attr);
 

x64/src/c/hal/mem.c

@@ -1,5 +1,5 @@
-#include "../common/kdef.h"
-#include "../common/type.h"
+#include "../common/sys/kdef.h"
+#include "../common/sys/type.h"
 #include "mem.h"
 
 #define kernel_heap_size 4096
@@ -85,6 +85,12 @@ void NATIVE64 hal_write_segment_descriptor(void *const gdt, uint32_t const base,
     ((uint8_t*)gdt)[7] = (uint8_t)((seg_desc >> 56) & 0xFF);
     return;
 }
+
+void NATIVE64 hal_create_initial_page_table(void* const base, uint64_t size)
+{
+
+};
+
 //
 //uint64_t NATIVE64 map_page(void *const base, uint64_t const p_addr, uint64_t const v_addr, uint64_t const attr, uint64_t const availableRam)
 //{

x64/src/c/hal/mem.h

@@ -1,8 +1,8 @@
 #ifndef _MM_H_
 #define _MM_H_
 
-#include "../common/kdef.h"
-#include "../common/type.h"
+#include "../common/sys/kdef.h"
+#include "../common/sys/type.h"
 #include "../common/util/list/linked_list/linked_list.h"
 
 #define PML4_PRESENT (1ull << 0)
@@ -84,17 +84,6 @@ typedef struct __attribute__((packed))
     uint64_t edx;
 } cpuid_t;
 
-#define MEMORY_OCCUPIED 0
-#define MEMORY_AVAILABLE 1
-#define MEMORY_RESERVED 2
-typedef struct
-{
-    uint64_t base_addr;
-    uint64_t size;
-    uint32_t type;
-    linked_list_node_t list_node;
-} memory_descriptor_node_t;
-
 void*NATIVE64 hal_halloc(size_t const size);
 
 void NATIVE64 hal_hfree(void *ptr);
@@ -107,6 +96,10 @@ extern void NATIVE64 hal_cpuid(uint64_t * eax, uint64_t * ebx, uint64_t* ecx, ui
 
 extern void NATIVE64 hal_flush_idt(idt_ptr_t* idt_ptr);
 
+extern void NATIVE64 hal_write_page_base(void* base);
+
+extern void* NATIVE64 hal_read_page_base();
+
 void NATIVE64 hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit, uint64_t const attr);
 
 void NATIVE64 hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr);

x64/src/c/hal/print.c

@@ -1,7 +1,6 @@
-#include <stdarg.h>
-#include "../common/kdef.h"
-#include "../common/type.h"
-#include "../common/sys/mem.h"
+#include "../common/sys/kdef.h"
+#include "../common/sys/type.h"
+#include "../common/lib/mem.h"
 #include "print.h"
 #include "var.h"
 

x64/src/c/hal/print.h

@@ -1,7 +1,7 @@
 #ifndef _PRINT_H_
 #define _PRINT_H_
-#include "../common/kdef.h"
-#include "../common/type.h"
+#include "../common/sys/kdef.h"
+#include "../common/sys/type.h"
 
 #define get_column(pos) (pos % 80)
 #define get_row(pos) (pos / 80)

x64/src/c/hal/var.c

@@ -7,5 +7,4 @@ uint8_t g_gdt[8*9];
 uint8_t g_idt[21*16];
 gdt_ptr_t g_gdt_ptr;
 idt_ptr_t g_idt_ptr;
-uint64_t text_pos;
-linked_list_t mem_desc;
+uint64_t text_pos;

x64/src/c/hal/var.h

@@ -9,6 +9,5 @@ extern uint8_t g_idt[21*16];
 extern gdt_ptr_t g_gdt_ptr;
 extern idt_ptr_t g_idt_ptr;
 extern uint64_t text_pos;
-extern linked_list_t mem_desc;
 
 #endif

x64/src/c/kernel/entry.c

@@ -1,14 +1,28 @@
-#include "../common/kdef.h"
+#include "../common/sys/kdef.h"
 #include "../hal/hal.h"
 #include "../hal/print.h"
 #include "../hal/io.h"
+#include "../common/sys/sys_info.h"
 
 extern char kernel_start[];
 extern char kernel_end[];
 void NATIVE64 kmain(multiboot_info_t *multiboot_info)
 {
-    hal_init(multiboot_info);
-    hal_printf("Finished setting up HAL\n");
+    boot_info_t* boot_info = hal_init(multiboot_info);
+
+
+    hal_printf("Available Memory: %uMB\n",boot_info->mem_info->mem_available / 1024 / 1024);
+    hal_printf("Reserved Memory: %uMB\n",boot_info->mem_info->mem_reserved / 1024 / 1024);
+    hal_printf("Installed Memory: %uMB\n",(boot_info->mem_info->mem_reserved + boot_info->mem_info->mem_available)
+                                          /1024 /1024);
+
+
+    for(uint64_t i = 0; i <= 21; i++)
+    {
+        hal_set_interrupt_handler(i, hal_interrupt_handler_wrapper);
+    }
     hal_enable_interrupt();
-    while(1);
+
+    hal_printf("KRNL: Kernel task finished.");
+    hal_halt_cpu();
 }