d
/
bond
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added kernel size and kernel heap management

This commit is contained in:
HyperAssembler 2015-02-08 00:18:22 -08:00
parent 3dd081316b
commit 4271c61388
9 changed files with 113 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
build/link32.ld
View File

@ -1,19 +1,39 @@
OUTPUT_FORMAT(binary)
SECTIONS
{
.text.start(0x1000000) :
. = 0x1000000;
kernel_start = .;
.entry :
{
*(.entry)
}
.text :
{
*(.text)
}
.data :
{
*(.data)
*(.rodata)
}
.bss :
{
*(.bss)
}
.stack :
{
*(.stack)
}
.heap :
{
*(.heap)
}
kernel_end = .;
}

22
build/link64.ld
View File

@ -1,19 +1,39 @@
OUTPUT_FORMAT(binary)
SECTIONS
{
.text.start(0x100000) :
. = 0x100000;
kernel_start = .;
.entry :
{
*(.entry)
}
.text :
{
*(.text)
}
.data :
{
*(.data)
*(.rodata)
}
.bss :
{
*(.bss)
}
.stack :
{
*(.stack)
}
.heap :
{
*(.heap)
}
kernel_end = .;
}

10
x64/src/asm/entry.asm
View File

@ -1,12 +1,11 @@
extern hk_main
global HLT_CPU
global BOCHS_MAGIC_BREAKPOINT
global kernel_heap
;IMPORTANT: Before entering this, CPU should be in protected mode.
;IMPORTANT: This module should be 4k-page aliened
[SECTION .entry]
[BITS 32]
;on stack: multiboot_info*
;skip data definition
jmp start
; here we need to construct a dummy gdt as well as a dummy page table(As simple as possible, maps 1G page sounds good)
@ -122,4 +121,9 @@ hlt
BOCHS_MAGIC_BREAKPOINT:
xchg bx,bx
ret
ret
[SECTION .heap]
[BITS 64]
kernel_heap:
times 4096 db 0

33
x64/src/c/entry.c
View File

@ -6,12 +6,15 @@
uint8_t g_gdt[8*9];
gdt_ptr_t g_gdt_ptr;
extern uint64_t text_pos;
extern char kernel_start[];
extern char kernel_end[];
extern void HYPKERNEL64 HLT_CPU(void);
extern void HYPKERNEL64 BOCHS_MAGIC_BREAKPOINT();
extern void HYPKERNEL64 hk_flush_gdt(gdt_ptr_t* gdt_ptr, uint64_t code_slct, uint64_t data_slct);
void HYPKERNEL64 hk_main(multiboot_info_t* multiboot_info)
{
text_pos = 0;
text_pos = get_pos(3, 0);
hk_printf("Kernel Start: 0x%X. End: 0x%X. Size: %dB, %dKB\n\n", (uint64_t)kernel_start, (uint64_t)kernel_end, (uint64_t)kernel_end - (uint64_t)kernel_start,((uint64_t)kernel_end - (uint64_t)kernel_start)/1024);
hk_printf("*Setting up GDT...");
hk_write_segment_descriptor((void*)&g_gdt[0], 0, 0, 0);
hk_write_segment_descriptor((void*)&g_gdt[8], 0, 0, SEG_DPL_0 | SEG_CODE_DATA | SEG_PRESENT | SEG_LONG | SEG_TYPE_CODE_X);
@ -28,5 +31,33 @@ void HYPKERNEL64 hk_main(multiboot_info_t* multiboot_info)
g_gdt_ptr.limit = 8*9-1;
hk_flush_gdt(&g_gdt_ptr, SEG_SELECTOR(1, 0), SEG_SELECTOR(2, 0));
hk_printf("Done.\n\n");
hk_printf("*Checking memory information...\n");
if(multiboot_info->flags & (1 << 6))
{
multiboot_memory_map_t const *mem_map = (multiboot_memory_map_t *) multiboot_info->mmap_addr;
uint64_t const mem_map_size = multiboot_info->mmap_length / sizeof(multiboot_memory_map_t);
hk_printf("BaseAddr - Length - Type\n");
uint64_t total_available_mem = 0;
uint64_t total_reserved_mem = 0;
for (uint64_t i = 0; i < mem_map_size; i++)
{
hk_printf("0x%X - 0x%X - 0x%x\n",(mem_map + i)->addr,(mem_map + i)->len,(mem_map + i)->type);
if((mem_map + i)->type == MULTIBOOT_MEMORY_RESERVED)
{
total_reserved_mem += (mem_map + i)->len;
}
else if ((mem_map + i)->type == MULTIBOOT_MEMORY_AVAILABLE)
{
total_available_mem += (mem_map + i)->len;
}
}
hk_printf("Total available memory: %uB, %uKB, %uMB.\n",total_available_mem,total_available_mem/1024,total_available_mem/1024/1024);
hk_printf("Total reserved memory: %uB, %uKB, %uMB.\n\n", total_reserved_mem, total_reserved_mem/1024, total_reserved_mem/1024/1024);
}
else
{
hk_printf("Memory information is currently unavailable.\n\n");
}
HLT_CPU();
}

16
x64/src/c/mem.c
View File

@ -2,6 +2,9 @@
#include "mem.h"
#define kernel_heap_size 4096
char* _cur_heap = NULL;
extern char kernel_heap[kernel_heap_size];
void HYPKERNEL64 hk_write_pt_entry(void * const base, uint64_t const p_addr, uint64_t const attr)
{
@ -156,4 +159,17 @@ void HYPKERNEL64 hk_mem_move(void* src, void* dst, uint64_t size)
while (size--)
*((char*)--dst) = *((char*)--src);
return;
}
void* HYPKERNEL64 hk_heap_alloc(uint64_t const size)
{
if(_cur_heap == NULL)
_cur_heap = kernel_heap;
if(_cur_heap + size < kernel_heap + kernel_heap_size)
{
void * temp_heap = (void*)_cur_heap;
_cur_heap = _cur_heap + size;
return temp_heap;
}
return NULL;
}

13
x64/src/c/mem.h
View File

@ -68,11 +68,16 @@ typedef struct __attribute__ ((packed))
uint64_t base;
} gdt_ptr_t;
typedef struct __attribute__ ((packed))
typedef struct __attribute__((packed)) _mem_block
{
uint16_t limit;
uint64_t base;
} idt_ptr_t;
struct _mem_block * prev;
uint64_t start_addr;
uint64_t end_addr;
uint64_t size;
struct _mem_block * next;
} mem_block;
void* HYPKERNEL64 hk_heap_alloc(uint64_t const size);
void HYPKERNEL64 hk_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit, uint64_t const attr);

10
x64/src/c/print.c
View File

@ -128,9 +128,9 @@ void HYPKERNEL64 _print_hex(uint64_t number, uint64_t capital)
char const lookup_table_cap[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
char const lookup_table[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
char const * const look_up = capital == 1 ? lookup_table_cap : lookup_table;
char arr[19];
arr[18] = 0; //zero-terminated
uint32_t index = 17;
char arr[17];
arr[16] = 0; //zero-terminated
uint32_t index = 15;
uint32_t const div = 16;
while (1)
{
@ -141,9 +141,7 @@ void HYPKERNEL64 _print_hex(uint64_t number, uint64_t capital)
if (number == 0)
break;
}
arr[index--] = 'x';
arr[index] = '0';
_print_str(&(arr[index]));
_print_str(&(arr[index + 1]));
return;
}

0
x86/src/asm/multiboot.asm → x86/src/asm/entry.asm
View File

4
x86/src/c/entry.c
View File

@ -12,6 +12,8 @@ extern uint32_t text_pos;
extern void hk_init_x64(multiboot_info_t* multiboot_info);
extern void BOCHS_MAGIC_BREAKPOINT(void);
extern void HLT_CPU(void);
extern char kernel_start[];
extern char kernel_end[];
void HYPKERNEL32 hk_main(multiboot_info_t* multiboot_info)
{
@ -26,7 +28,7 @@ void HYPKERNEL32 hk_main(multiboot_info_t* multiboot_info)
hk_init_x64(multiboot_info);
}
hk_printf("Arch: x86.\n\n");
hk_printf("Kernel Start: 0x%X. End: 0x%X. Size: 0x%X.\n\n", (uint32_t)kernel_start, (uint32_t)kernel_end, (uint32_t)kernel_end - (uint32_t)kernel_start);
hk_printf("*Setting up GDT...");
//dummy descriptor
hk_write_segment_descriptor((void*)(&g_gdt[0]), 0, 0, 0);