Improve kernel info

kernel/info.c

@@ -12,7 +12,8 @@ void kernel_info_init_start(
     const size_t size,
     const size_t phys_base,
     const size_t virt_base,
-    const size_t stack_top
+    const size_t stack_start,
+    const size_t stack_size
 ) {
     KERNAUX_NOTNULL_RETURN(kinfo);
 
@@ -24,7 +25,8 @@ void kernel_info_init_start(
     kinfo->kernel_phys_base = phys_base;
     kinfo->kernel_virt_base = virt_base;
 
-    kinfo->kernel_stack_top = stack_top;
+    kinfo->kernel_stack_start = stack_start;
+    kinfo->kernel_stack_size  = stack_size;
 }
 
 void kernel_info_init_finish(struct Kernel_Info *const kinfo)
@@ -59,15 +61,15 @@ void kernel_info_print(const struct Kernel_Info *const kinfo)
     kernaux_console_printf("  areas: %lu\n", kinfo->areas_count);
     kernaux_console_printf("\n");
     kernaux_console_printf("  offset: %lu\n", kinfo->kernel_offset);
-    kernaux_console_printf("\n");
+    kernaux_console_printf("  size: %lu\n", kinfo->kernel_size);
     kernaux_console_printf("  phys base: %lu\n", kinfo->kernel_phys_base);
     kernaux_console_printf("  virt base: %lu\n", kinfo->kernel_virt_base);
     kernaux_console_printf("\n");
-    kernaux_console_printf("  size: %lu\n", kinfo->kernel_size);
     kernaux_console_printf("  modules size: %lu\n", kinfo->modules_total_size);
     kernaux_console_printf("  kernel & modules size: %lu\n", kinfo->kernel_and_modules_total_size);
     kernaux_console_printf("\n");
-    kernaux_console_printf("  stack top: %lu\n", kinfo->kernel_stack_top);
+    kernaux_console_printf("  stack start: %lu\n", kinfo->kernel_stack_start);
+    kernaux_console_printf("  stack size: %lu\n", kinfo->kernel_stack_size);
 }
 
 bool kernel_info_is_valid(const struct Kernel_Info *const kinfo)
@@ -88,6 +90,24 @@ bool kernel_info_is_valid(const struct Kernel_Info *const kinfo)
         return false;
     }
 
+    if (kinfo->kernel_stack_size != 16 * 1024) return false;
+
+    if (!(kinfo->kernel_stack_start >= kinfo->kernel_phys_base &&
+          kinfo->kernel_stack_start <
+          kinfo->kernel_phys_base + kinfo->kernel_size))
+    {
+        return false;
+    }
+
+    const size_t stack_end =
+        kinfo->kernel_stack_start + kinfo->kernel_stack_size;
+
+    if (!(stack_end - 1 >= kinfo->kernel_phys_base &&
+          stack_end - 1 < kinfo->kernel_phys_base + kinfo->kernel_size))
+    {
+        return false;
+    }
+
     size_t modules_total_size = 0;
 
     for (size_t i = 0; i < kinfo->modules_count; ++i) {

kernel/info.h

@@ -43,15 +43,15 @@ struct Kernel_Info {
 
     // Higher-half offset, typically 3 GiB
     size_t kernel_offset;
-
+    size_t kernel_size;
     size_t kernel_phys_base;
     size_t kernel_virt_base;
 
-    size_t kernel_size;
     size_t modules_total_size;
     size_t kernel_and_modules_total_size;
 
-    size_t kernel_stack_top;
+    size_t kernel_stack_start;
+    size_t kernel_stack_size;
 };
 
 void kernel_info_init_start(
@@ -60,7 +60,8 @@ void kernel_info_init_start(
     size_t size,
     size_t phys_base,
     size_t virt_base,
-    size_t stack_top
+    size_t stack_start,
+    size_t stack_size
 );
 
 void kernel_info_init_finish(struct Kernel_Info *kinfo);

kernel/linker.ld

@@ -6,6 +6,8 @@ _kernel_offset = 0xC0000000; /* 3 GB */
 _kernel_phys_base = 4M;
 _kernel_virt_base = (_kernel_phys_base + _kernel_offset);
 
+_kernel_stack_size = _kernel_stack_end - _kernel_stack_start;
+
 SECTIONS
 {
     . = _kernel_phys_base;

kernel/main.c

@@ -14,12 +14,15 @@
 #include <kernaux/pfa.h>
 #include <kernaux/stdlib.h>
 
+#include <stdint.h>
+
 // Defined in linker script
-extern char _kernel_offset;
-extern char _kernel_size;
-extern char _kernel_phys_base;
-extern char _kernel_virt_base;
-extern char _kernel_stack_top;
+extern uint8_t _kernel_offset;
+extern uint8_t _kernel_size;
+extern uint8_t _kernel_phys_base;
+extern uint8_t _kernel_virt_base;
+extern uint8_t _kernel_stack_start;
+extern uint8_t _kernel_stack_size;
 
 static struct Kernel_Info kinfo;
 static struct KernAux_PFA pfa;
@@ -47,7 +50,8 @@ void main(
         (size_t)&_kernel_size,
         (size_t)&_kernel_phys_base,
         (size_t)&_kernel_virt_base,
-        (size_t)&_kernel_stack_top
+        (size_t)&_kernel_stack_start,
+        (size_t)&_kernel_stack_size
     );
 
     KernAux_PFA_initialize(&pfa);

kernel/start.s

@@ -3,6 +3,8 @@
 .set MULTIBOOT_LENGTH, 16 + 8
 .set MULTIBOOT_CHECKSUM, -(MULTIBOOT_MAGIC + MULTIBOOT_ARCH + MULTIBOOT_LENGTH)
 
+
+
 .section .multiboot
 .align 4
 .long MULTIBOOT_MAGIC
@@ -12,12 +14,19 @@
 .long 0
 .long 8
 
-.section .bss
-.align 16
-.skip 16384 # 16 KiB
-_kernel_stack_top:
 
-.global _kernel_stack_top
+
+.section .bss
+
+.global _kernel_stack_start
+.global _kernel_stack_end
+
+.align 16
+_kernel_stack_start:
+.skip 16384 # 16 KiB
+_kernel_stack_end:
+
+
 
 .section .text
 
@@ -27,7 +36,7 @@ _kernel_stack_top:
 .type halt,   @function
 
 _start:
-    mov $_kernel_stack_top, %esp // Initialize stack
+    mov $_kernel_stack_end, %esp // Initialize stack
 
     push %ebx // Multiboot information pointer
     push %eax // Multiboot magic number

kernel/tss.c

@@ -84,5 +84,5 @@ void tss_write_to_gdt(const struct Kernel_Info *const kinfo, void *gdt_entry_ptr
     memset(&tss, 0, sizeof(tss));
 
     tss.ss0 = GDT_KERNEL_DS_SELECTOR;
-    tss.esp0 = kinfo->kernel_stack_top;
+    tss.esp0 = kinfo->kernel_stack_start + kinfo->kernel_stack_size;
 }