Merge branch 'memtest' into 'master'

Memtest



See merge request !13

src/head.asm

@@ -56,6 +56,9 @@ _start:
 	; our stack (as it grows downwards).
 	mov esp, stack_top
 
+	push eax 		; Multiboot magic number
+	push ebx		; Multiboot info struct
+
 	; We are now ready to actually execute C code. We cannot embed that in an
 	; assembly file, so we'll create a kernel.c file in a moment. In that file,
 	; we'll create a C entry point called kernel_main and call it here.

src/kern.c

-#include <stdbool.h> /* C doesn't have booleans by default. */
+/*
+  kern.c is where the c code starts, as invoked by our heading
+  assembly. It should only contain high level code
+*/
+
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -8,11 +13,11 @@
 #include "mem.h"
 #include "gdt.h"
 #include "idt.h"
+#include "test.h"
+#include "multiboot.h"
 
-#if defined(__cplusplus)
-extern "C" /* Use C linkage for kernel_main. */
-#endif
-void kernel_main() 
+// The parameters passed here ultimately come through the bootloader
+void kernel_main(multiboot_info* mbt, uint32_t magic)
 {
     /* Initialize terminal and serial interfaces */
     terminal_initialize();
@@ -26,21 +31,25 @@ void kernel_main()
          */
     serial_writestring("IDT initialized\n");
     terminal_writestring("Hello, kernel World!\n");
-    //serial_writestring("Second Serial Test\n");
+
+    // Abort if magic is not correct.
+    if (magic != 0x2badb002)
+    {
+        serial_writestring("Magic number not correct\n");
+        // wait how do we terminate
+    }
 
     // Enable paging of memory. For now there is only one virtual
     // memory space defined by page_dir
-    page_directory_entry* page_dir;
-    page_dir = initiate_directory();
-    initiate_page_table(page_dir);
-    loadPageDirectory(page_dir);
+    page_directory_entry* kern_page_dir;
+    kern_page_dir = mem_init_kern_tables(mbt->mmap_addr, mbt->mmap_addr + mbt->mmap_length);
+    loadPageDirectory(kern_page_dir);
     enablePaging();
 
     serial_writestring("Finished Initilizing memory\n");
-    asm ("int $0x80");
-    asm ("int $0x90");
     int o=0;
     int j=5/o;
     serial_hexword(j);
-    asm ("hlt");
+    test_mem();
+    test_idt();
 }

src/linker.ld

+/* Linker code ripped directly from osdev wiki */
+
 /* The bootloader will look at this image and start execution at the symbol
    designated as the entry point. */
 ENTRY(_start)

src/mem.c

@@ -13,6 +13,103 @@ page_directory_entry page_directory[1024] __attribute__((aligned(4096)));
 // only page table in the page directory
 page_table_entry page_table_one[1024] __attribute__((aligned(4096)));
 
+// populate_page_table makes a page table at `table` mapping `num`
+// pages to bytes after `start + offset*4KB`
+// both table and start must be properly aligned
+void populate_page_table(page_table_entry* table, void* start, int num, int offset)
+{
+    // Check that there are the correct number of entries
+    if ((offset + num) > 1024)
+    {
+        serial_writestring("tred to populate past the end of the page table\n");
+    }
+
+    // Check that the table is properly aligned
+    if (((uint32_t)table & 0xfff) != 0)
+    {
+        serial_writestring("tried to populate a table that was not page aligned");
+    }
+
+    // Check that the table is properly aligned
+    if (((uint32_t)start & 0xfff) != 0)
+    {
+        serial_writestring("tried to start mapping on an unaligned address");
+    }
+
+    int i;
+    int stop = num + offset;
+    for (i = offset; i < stop; i++)
+    {
+        table[i] = 0;
+        table[i] |= (uint32_t)start + (i<<12);
+        table[i] |= PAGE_WRITABLE | PAGE_PRESENT;
+    }
+}
+
+// TODO: put this as a label at the end of the code, so we can take
+// its address
+#define KERN_END 0x104000
+
+page_directory_entry* mem_init_kern_tables(multiboot_memory_map* mmap, multiboot_memory_map* mmap_end)
+{
+
+    // Make a page directory structure easily
+    page_directory_entry* kern_page_dir = initiate_directory();
+
+    // This line will change with the above TODO
+    page_table_entry* next_table = (page_table_entry*) KERN_END;
+
+    int current_dir_entry = 0;
+
+    // For each entry in the memory map
+    while (mmap < mmap_end)
+    {
+        // Special case for the first memory segment - it gets its own directory entry
+        if (mmap->base_addr == 0)
+        {
+            // Lower memory should be first in the page directory and
+            // mapped one to one
+            populate_page_table(next_table, 0, 1024, 0);
+            page_directory[0] = (uint32_t) next_table;
+            page_directory[0] |= PAGE_WRITABLE | PAGE_PRESENT;
+
+            current_dir_entry = 1;
+            next_table += 0x1000;
+        }
+        else if (mmap->type == 1)
+        {
+            uint32_t i;
+            for (i = 0; i+0x1000000 < mmap->length; i += 0x1000000)
+            {
+                populate_page_table(next_table, (void*) mmap->base_addr + i, 1024 ,0);
+                page_directory[current_dir_entry] = (uint32_t) next_table;
+                page_directory[current_dir_entry] |= PAGE_WRITABLE | PAGE_PRESENT;
+
+                current_dir_entry += 1;
+                next_table += 0x1000;
+            }
+            // There will be an edge case where there is less than a
+            // full page table to be mapped. This handlis this case.
+            if (i != mmap->length)
+            {
+                populate_page_table(next_table, (void*) mmap->base_addr + i, (mmap->length - i) / 0x1000 ,0);
+                page_directory[current_dir_entry] = (uint32_t) next_table;
+                page_directory[current_dir_entry] |= PAGE_WRITABLE | PAGE_PRESENT;
+
+                current_dir_entry += 1;
+                next_table += 0x1000;
+            }
+
+        }
+        mmap = (multiboot_memory_map*)((uint32_t)mmap + mmap->size + sizeof(uint32_t));
+    }
+
+    // let the memory allocator work freely with all remaining memory
+    memory_mark = next_table;
+
+    return kern_page_dir;
+}
+
 page_directory_entry* initiate_directory()
 {
     // set each entry to not present
@@ -28,28 +125,16 @@ page_directory_entry* initiate_directory()
         page_directory[i] |= PAGE_WRITABLE;
     }
 
+    // Set last directory entry to point back
+    page_directory[1023] = (uint32_t) page_directory;
+    page_directory[1023] |= PAGE_WRITABLE | PAGE_PRESENT;
+
     return page_directory;
 }
 
-void initiate_page_table(page_directory_entry* page_dir) 
+void* malloc(uint32_t bytes)
 {
-    // holds the physical address where we want to start mapping these pages to.
-    // in this case, we want to map these pages to the very beginning of memory.
-    unsigned int i;
-
-    //we will fill all 1024 entries in the table, mapping 4 megabytes
-    for(i = 0; i < 1024; i++)
-    {
-        // As the address is page aligned, it will always leave 12 bits zeroed.
-        // Those bits are used by the attributes:
-        //    -> supervisor level, read/write, present.
-        page_table_one[i] = 0;
-        page_table_one[i] |= i << 12;
-        page_table_one[i] |= PAGE_WRITABLE | PAGE_PRESENT;
-    }
-
-    // attributes: supervisor level, read/write, present
-    page_dir[0] = (uint32_t) page_table_one;
-    page_dir[0] |= PAGE_WRITABLE | PAGE_PRESENT;
-
+    void* old_mark = memory_mark;
+    memory_mark = (void*)((uint32_t)memory_mark + bytes);
+    return old_mark;
 }

src/mem.h

@@ -8,6 +8,8 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "multiboot.h"
+
 // Flags for pages directory entries and table entries
 #define PAGE_PRESENT        0x1
 #define PAGE_WRITABLE       0x2
@@ -27,6 +29,13 @@ extern void enablePaging();
 
 // Defined in the file mem.c
 page_directory_entry* initiate_directory();
-void initiate_page_table(page_directory_entry* page_dir);
+page_directory_entry* mem_init_kern_tables(multiboot_memory_map* mmap, multiboot_memory_map* mmap_end);
+
+// memory mark stores a counter of bytes for the most recently used
+// memory. Everything before it is used and all valid memory after it
+// is free
+void* memory_mark;
+
+void* malloc(uint32_t bytes);
 
 #endif

src/multiboot.h

+/*
+  multiboot.h defines structures used in the multiboot standard
+
+  much of this file was closely inspired by the gnu version
+*/
+
+#ifndef _MULTIBOOT_INC
+#define _MULTIBOOT_INC
+
+#include <stdint.h>
+
+typedef struct
+{
+    uint32_t size;
+    uint64_t base_addr;
+    uint64_t length;
+    uint32_t type;
+} multiboot_memory_map;
+
+typedef struct
+{
+    uint32_t tabsize;
+    uint32_t strsize;
+    uint32_t addr;
+    uint32_t reserved;
+} aout_symbol_table;
+
+typedef struct
+{
+    uint32_t flags;
+    uint32_t mem_lower;
+    uint32_t mem_upper;
+    uint32_t boot_device;
+    uint32_t cmdline;
+    uint32_t mods_count;
+    uint32_t mods_addr;
+    union
+    {
+        aout_symbol_table aout_sym;
+    } u;
+    uint32_t mmap_length;
+    multiboot_memory_map* mmap_addr;
+
+} multiboot_info;
+
+
+
+#endif

src/serial.c

@@ -41,7 +41,15 @@ void serial_writestring(char* s)
 const char* hexchars = "0123456789abcdef";
 void serial_hexword(uint32_t x)
 {
-    for (int i = 8; i != 0; i--) 
+    for (int i = 7; i >= 0; i--)
+    {
+        serial_writechar(hexchars[x>>i*4&0xf]);
+    }
+}
+
+void serial_hexqword(uint64_t x)
+{
+    for (int i = 15; i >= 0; i--)
     {
         serial_writechar(hexchars[x>>i*4&0xf]);
     }

src/serial.h

@@ -22,6 +22,7 @@ void serial_writestring(char* s);
 
 // Function to write a 4 byte word toserial in hex
 void serial_hexword(uint32_t x);
+void serial_hexqword(uint64_t x);
 void serial_hexstring(void* s, uint32_t n);
 
 #endif

src/test.c

+/*
+  test.c implements functions used for testing
+*/
+
+#include "test.h"
+
+void test_idt()
+{
+    asm ("int $0x80");
+    asm ("int $0x90");
+    asm ("hlt");
+}
+
+void test_mem()
+{
+    // try writing a bunch of bytes starting at 0
+    int i = 0x0;
+    for(i=0; i < 0x4000; i++)
+    {
+        *(int*)(i<<2) = i;
+    }
+
+    // read it back in and make sure its all stored
+
+    for (i=0; i < 0x4000; i++)
+    {
+        if (*(int*)(i<<2) != i)
+        {
+            serial_writestring("Memory error\n");
+        }
+    }
+
+    serial_writestring("Wrote a bunch of memory\n");
+}

src/test.h

+/*
+  test.h defines functions used for testing
+ */
+
+#ifndef INC_TEST
+#define INC_TEST
+
+#include "serial.h"
+
+// test_idt calls a couple of interrupts. Should be done after kernel
+// has been set up
+void test_idt();
+
+// test_mem writes some stuff to moem
+void test_mem();
+
+#endif