grow on demand heap

add simple page fault handler for debugging
correct the accidentally used sti instruction which is too early at this stage

diff --git a/lunaix-os/arch/x86/boot.S b/lunaix-os/arch/x86/boot.S
index ddcd8917989411caf83eceb74e0030d522318c9d..7bf30055a54e13689b11269908a9de937a62346e 100644 (file)
--- a/lunaix-os/arch/x86/boot.S
+++ b/lunaix-os/arch/x86/boot.S
@@ -42,6 +42,7 @@
                                  */
     start_: 
         cld
                                  */
     start_: 
         cld

+        # 确保屏蔽所有外中断，直到我们准备好PIC为止

         cli
         movl $stack_top, %esp
 
         cli
         movl $stack_top, %esp
 

diff --git a/lunaix-os/includes/arch/x86/interrupts.h b/lunaix-os/includes/arch/x86/interrupts.h
index 6265720f0fd5dced88f0d9109045639024af69ee..3fb86d63841f1b0662c419a45a9a5c0dc0caf781 100644 (file)
--- a/lunaix-os/includes/arch/x86/interrupts.h
+++ b/lunaix-os/includes/arch/x86/interrupts.h
@@ -40,6 +40,9 @@ _asm_isr0();
 void
 _asm_isr13();
 
 void
 _asm_isr13();
 

+void
+_asm_isr14();
+

 void
 interrupt_handler(isr_param* param);
 
 void
 interrupt_handler(isr_param* param);
 

diff --git a/lunaix-os/kernel/asm/x86/idt.c b/lunaix-os/kernel/asm/x86/idt.c
index 19b63e0d2ad788589c2fced1024d1593b2affc2c..296fa150828b402f149caaf4d39dddfe7876f2af 100644 (file)
--- a/lunaix-os/kernel/asm/x86/idt.c
+++ b/lunaix-os/kernel/asm/x86/idt.c
@@ -19,4 +19,5 @@ void
 _init_idt() {
     _set_idt_entry(FAULT_DIVISION_ERROR, 0x08, _asm_isr0, 0);
     _set_idt_entry(FAULT_GENERAL_PROTECTION, 0x08, _asm_isr13, 0);
 _init_idt() {
     _set_idt_entry(FAULT_DIVISION_ERROR, 0x08, _asm_isr0, 0);
     _set_idt_entry(FAULT_GENERAL_PROTECTION, 0x08, _asm_isr13, 0);

+    _set_idt_entry(FAULT_PAGE_FAULT, 0x08, _asm_isr14, 0);

 }
\ No newline at end of file
 }
\ No newline at end of file

diff --git a/lunaix-os/kernel/asm/x86/interrupt.S b/lunaix-os/kernel/asm/x86/interrupt.S
index 5f3d333c10d6cf0f50f6ad3c175702e6d34fdc9f..10fa393ace27c0a643d0cc3f07ba2619b3839444 100644 (file)
--- a/lunaix-os/kernel/asm/x86/interrupt.S
+++ b/lunaix-os/kernel/asm/x86/interrupt.S
@@ -12,6 +12,7 @@
 .section .text
     isr_template 0
     isr_template 13, no_error_code=0
 .section .text
     isr_template 0
     isr_template 13, no_error_code=0

+    isr_template 14, no_error_code=0

 
     interrupt_wrapper:
 
 
     interrupt_wrapper:
 

diff --git a/lunaix-os/kernel/asm/x86/interrupts.c b/lunaix-os/kernel/asm/x86/interrupts.c
index 7ed34273d0e2d6abbae1e19ed54b7531d499d816..925c13de340acb108f72b337d27016afbaa11e98 100644 (file)
--- a/lunaix-os/kernel/asm/x86/interrupts.c
+++ b/lunaix-os/kernel/asm/x86/interrupts.c
@@ -3,14 +3,13 @@
 #include <libc/stdio.h>
 
 void panic (const char* msg, isr_param* param) {
 #include <libc/stdio.h>
 
 void panic (const char* msg, isr_param* param) {

-    tty_set_theme(VGA_COLOR_BLACK, VGA_COLOR_LIGHT_RED);
+    tty_set_theme(VGA_COLOR_WHITE, VGA_COLOR_RED);

     tty_clear_line(10);
     tty_clear_line(11);
     tty_clear_line(12);
     tty_set_cpos(0, 11);
     tty_clear_line(10);
     tty_clear_line(11);
     tty_clear_line(12);
     tty_set_cpos(0, 11);

-    printf(" INT %u: [0x%x: 0x%x] %s", param->vector, param->cs, param->eip, msg);
-    __spin:
-        goto __spin;
+    printf(" INT %u: (%x) [0x%x: 0x%x] %s", param->vector, param->err_code, param->cs, param->eip, msg);
+    while(1);

 }
 
 void 
 }
 
 void 


@@ -23,6 +22,9 @@ interrupt_handler(isr_param* param) {
         case FAULT_GENERAL_PROTECTION:
             panic("General Protection", param);
             break;  // never reach
         case FAULT_GENERAL_PROTECTION:
             panic("General Protection", param);
             break;  // never reach

+        case FAULT_PAGE_FAULT:
+            panic("Page Fault", param);
+            break;  // never reach

         default:
             panic("Unknown Interrupt", param);
             break;  // never reach
         default:
             panic("Unknown Interrupt", param);
             break;  // never reach

diff --git a/lunaix-os/kernel/asm/x86/prologue.S b/lunaix-os/kernel/asm/x86/prologue.S
index ca72830b7a6fec17ef4f3ce3680ce4d908055032..fe1b645e54ca2a1f4e2bed238b9d6665e2cfa973 100644 (file)
--- a/lunaix-os/kernel/asm/x86/prologue.S
+++ b/lunaix-os/kernel/asm/x86/prologue.S
@@ -52,8 +52,7 @@
 
         addl $6, %esp
 
 
         addl $6, %esp
 

-        sti
-
+        movl $mb_info, (%esp)

         call _kernel_init
 
         /* 
         call _kernel_init
 
         /* 

diff --git a/lunaix-os/kernel/k_main.c b/lunaix-os/kernel/k_main.c
index 3899336d00950bd5d150611c18ecc2c0726f11ff..3f56166b14f57c659c9920c4156412ac5e0d3237 100644 (file)
--- a/lunaix-os/kernel/k_main.c
+++ b/lunaix-os/kernel/k_main.c
@@ -31,11 +31,14 @@ _kernel_main()
         arr[i] = (uint32_t*) lx_malloc((i + 1) * 2);
     }
 
         arr[i] = (uint32_t*) lx_malloc((i + 1) * 2);
     }
 

+    void* big_ = lx_malloc(8192);
+

     for (size_t i = 0; i < 10; i++)
     {
         lx_free(arr[i]);
     }
     
     lx_free(arr);
     for (size_t i = 0; i < 10; i++)
     {
         lx_free(arr[i]);
     }
     
     lx_free(arr);

+    lx_free(big_);

     // assert(0);
 }
\ No newline at end of file
     // assert(0);
 }
\ No newline at end of file

diff --git a/lunaix-os/kernel/mm/dmm.c b/lunaix-os/kernel/mm/dmm.c
index 81426dae62935c0cff7bcd66bb4dbe456b4616b8..e15e4321bc816a2ea0a87e350c6c9c7274706cc2 100644 (file)
--- a/lunaix-os/kernel/mm/dmm.c
+++ b/lunaix-os/kernel/mm/dmm.c
@@ -2,7 +2,7 @@
  * @file dmm.c
  * @author Lunaixsky
  * @brief Dynamic memory manager dedicated to kernel heap. It is not portable at
  * @file dmm.c
  * @author Lunaixsky
  * @brief Dynamic memory manager dedicated to kernel heap. It is not portable at

- * this moment.
+ * this moment. Implicit free list implementation.

  * @version 0.1
  * @date 2022-02-28
  *
  * @version 0.1
  * @date 2022-02-28
  *


@@ -18,8 +18,6 @@
 #include <lunaix/constants.h>
 #include <lunaix/spike.h>
 
 #include <lunaix/constants.h>
 #include <lunaix/spike.h>
 

-#include <stdbool.h>
-

 #define M_ALLOCATED 0x1
 #define M_PREV_FREE 0x2
 
 #define M_ALLOCATED 0x1
 #define M_PREV_FREE 0x2
 


@@ -53,6 +51,8 @@ coalesce(uint8_t* chunk_ptr);
 void*
 lx_grow_heap(size_t sz);
 
 void*
 lx_grow_heap(size_t sz);
 

+void place_chunk(uint8_t* ptr, size_t size);
+

 int
 dmm_init()
 {
 int
 dmm_init()
 {


@@ -99,9 +99,7 @@ lxbrk(size_t size)
     {
         // if next do require new pages to be allocated
         if (!vmm_alloc_pages(heap_top_pg + PG_SIZE, ROUNDUP(size, PG_SIZE), PG_PRESENT | PG_WRITE)) {
     {
         // if next do require new pages to be allocated
         if (!vmm_alloc_pages(heap_top_pg + PG_SIZE, ROUNDUP(size, PG_SIZE), PG_PRESENT | PG_WRITE)) {

-            // TODO: OOM, panic here! Rather than spinning.
-            spin();
-            // return NULL
+            return NULL;

         }
     
     }
         }
     
     }


@@ -143,34 +141,51 @@ lx_malloc(size_t size)
         size_t chunk_size = CHUNK_S(header);
         if (chunk_size >= size && !CHUNK_A(header)) {
             // found!
         size_t chunk_size = CHUNK_S(header);
         if (chunk_size >= size && !CHUNK_A(header)) {
             // found!

-            *((uint32_t*)ptr) = PACK(size, CHUNK_PF(header) | M_ALLOCATED);
-            uint8_t* n_hdrptr = (uint8_t*)(ptr + size);
-            uint32_t diff = chunk_size - size;
-            if (!diff) {
-                // if the current free block is fully occupied
-                uint32_t n_hdr = LW(n_hdrptr);
-                // notify the next block about our avaliability
-                SW(n_hdrptr, n_hdr & ~0x2);
-            } else {
-                // if there is remaining free space left
-                uint32_t remainder_hdr =
-                  PACK(diff, M_NOT_ALLOCATED | M_PREV_ALLOCATED);
-                SW(n_hdrptr, remainder_hdr);
-                SW(FPTR(n_hdrptr, diff), remainder_hdr);
-
-                coalesce(n_hdrptr);
-            }
+            place_chunk(ptr, size);

             return BPTR(ptr);
         }
         ptr += chunk_size;
     }
 
             return BPTR(ptr);
         }
         ptr += chunk_size;
     }
 

+    // if heap is full (seems to be!), then allocate more space (if it's okay...)
+    if ((ptr = lx_grow_heap(size))) {
+        place_chunk(ptr, size);
+        return BPTR(ptr);
+    }
+
+    // Well, we are officially OOM!

     return NULL;
 }
 
     return NULL;
 }
 

+void place_chunk(uint8_t* ptr, size_t size) {
+    uint32_t header = *((uint32_t*)ptr);
+    size_t chunk_size = CHUNK_S(header);
+    *((uint32_t*)ptr) = PACK(size, CHUNK_PF(header) | M_ALLOCATED);
+    uint8_t* n_hdrptr = (uint8_t*)(ptr + size);
+    uint32_t diff = chunk_size - size;
+    if (!diff) {
+        // if the current free block is fully occupied
+        uint32_t n_hdr = LW(n_hdrptr);
+        // notify the next block about our avaliability
+        SW(n_hdrptr, n_hdr & ~0x2);
+    } else {
+        // if there is remaining free space left
+        uint32_t remainder_hdr =
+            PACK(diff, M_NOT_ALLOCATED | M_PREV_ALLOCATED);
+        SW(n_hdrptr, remainder_hdr);
+        SW(FPTR(n_hdrptr, diff), remainder_hdr);
+
+        coalesce(n_hdrptr);
+    }
+}
+

 void
 lx_free(void* ptr)
 {
 void
 lx_free(void* ptr)
 {

+    if (!ptr) {
+        return;
+    }
+

     uint8_t* chunk_ptr = (uint8_t*)ptr - WSIZE;
     uint32_t hdr = LW(chunk_ptr);
     uint8_t* next_hdr = chunk_ptr + CHUNK_S(hdr);
     uint8_t* chunk_ptr = (uint8_t*)ptr - WSIZE;
     uint32_t hdr = LW(chunk_ptr);
     uint8_t* next_hdr = chunk_ptr + CHUNK_S(hdr);