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

HAL now reports memory in unit of pages to kernel.

This commit is contained in:
hyperassembler 2015-09-05 17:14:04 -04:00
parent 58c61bae3c
commit 3efb2f7bbd
8 changed files with 123 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
x64/src/c/common/sys/kdef.h
View File

@ -6,6 +6,16 @@
#define NATIVE64 __attribute__((sysv_abi))
#define ALIGN_DOWN(val, alignment) (((val) / (alignment)) * (alignment))
#define ALIGN_UP(val, alignment) ((((val) % (alignment)) == 0) ? (((val) / (alignment)) * (alignment)) : ((((val) / (alignment)) * (alignment)) + 1))
#define IS_OVERLAP(x1,x2,y1,y2) (((x1) <= (y2)) && ((y1) <= (x2)))
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define SEG_SELECTOR(Index,RPL) (((Index) << 3) + (RPL))
#endif

7
x64/src/c/common/sys/sys_info.h
View File

@ -10,13 +10,14 @@
typedef struct
{
uint64_t base_addr;
uint64_t size;
uint64_t page_count;
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;
linked_list_t* free_page_list; // a list containing memory_descriptor_node_t nodes
linked_list_t* occupied_page_list;
uint64_t mem_installed;
uint64_t mem_available;
} mem_info_t;

74
x64/src/c/hal/hal.c
View File

@ -5,6 +5,7 @@
#include "var.h"
#include "../common/lib/str.h"
#include "../common/lib/mem.h"
#include "../common/sys/sys_info.h"
boot_info_t* NATIVE64 hal_init(multiboot_info_t* m_info)
{
@ -40,28 +41,71 @@ boot_info_t* NATIVE64 hal_init(multiboot_info_t* m_info)
boot_info->mem_info = (mem_info_t*)hal_halloc(sizeof(mem_info_t));
hal_assert(boot_info->mem_info != NULL, "Unable to allocate memory for mem_info.");
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)));
hal_assert(boot_info->mem_info->mem_seg_list != NULL, "Unable to allocate memory for mem_seg_list.");
linked_list_init(boot_info->mem_info->mem_seg_list);
boot_info->mem_info->mem_installed = 0;
boot_info->mem_info->free_page_list = (linked_list_t*)hal_halloc((sizeof(linked_list_t)));
boot_info->mem_info->occupied_page_list = (linked_list_t*)hal_halloc((sizeof(linked_list_t)));
hal_assert(boot_info->mem_info->free_page_list != NULL &&
boot_info->mem_info->occupied_page_list != NULL
, "Unable to allocate memory for mem_info_lists.");
linked_list_init(boot_info->mem_info->free_page_list);
linked_list_init(boot_info->mem_info->occupied_page_list);
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);
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));
hal_assert(each_desc != NULL, "Unable to allocate memory for memory_descriptor.");
each_desc->base_addr = (mem_map + i)->addr;
each_desc->size = (mem_map + i)->len;
if((mem_map + i)->type == MULTIBOOT_MEMORY_RESERVED)
hal_printf("\n==Base: 0x%X, Length: %u, Type: %s==", (mem_map + i)->addr, (mem_map + i)->len,
(mem_map + i)->type== MULTIBOOT_MEMORY_AVAILABLE ? "AVL" : "RSV");
if ((mem_map + i)->type == MULTIBOOT_MEMORY_AVAILABLE)
{
uint64_t base_addr = (mem_map + i)->addr;
uint64_t end_addr = base_addr + (mem_map + i)->len;
boot_info->mem_info->mem_reserved += (mem_map + i)->len;
}
else if ((mem_map + i)->type == MULTIBOOT_MEMORY_AVAILABLE)
{
linked_list_add(boot_info->mem_info->mem_seg_list, &each_desc->list_node);
boot_info->mem_info->mem_available += (mem_map + i)->len;
// align head
uint64_t aligned_base_addr = ALIGN_UP(base_addr, PHYSICAL_PAGE_SIZE);
// align tail
uint64_t aligned_end_addr = ALIGN_DOWN(end_addr, PHYSICAL_PAGE_SIZE);
uint64_t page_count = (aligned_end_addr - aligned_base_addr) / PHYSICAL_PAGE_SIZE;
if(page_count == 0)
continue;
// strip kernel-occupied pages
// TODO: Finished this.
// uint64_t aligned_kernel_base = ALIGN_DOWN((uint64_t)kernel_start, PHYSICAL_PAGE_SIZE);
// uint64_t aligned_kernel_end = ALIGN_UP((uint64_t)kernel_end, PHYSICAL_PAGE_SIZE);
// if(IS_OVERLAP(aligned_base_addr,aligned_end_addr,aligned_kernel_base,aligned_kernel_end))
// {
// uint64_t overlap_pages = (MIN(aligned_kernel_end, aligned_end_addr)
// - MAX(aligned_kernel_base, aligned_base_addr)) / PHYSICAL_PAGE_SIZE;
//
// if(overlap_pages != 0)
// {
// // if there is overlap, add to occupied list
// memory_descriptor_node_t *occupied_desc = (memory_descriptor_node_t *) hal_halloc(
// sizeof(memory_descriptor_node_t));
// hal_assert(occupied_desc != NULL, "Unable to allocate memory for memory_descriptor.");
// occupied_desc->base_addr = aligned_kernel_base;
// occupied_desc->page_count = overlap_pages;
// linked_list_add(boot_info->mem_info->occupied_page_list, &occupied_desc->list_node);
//
// // also adjust corresponding segment
// page_count = page_count - overlap_pages;
// if(page_count == 0) // if kernel occupies the whole segment, continue
// continue;
//
// }
// }
memory_descriptor_node_t* each_desc = (memory_descriptor_node_t*)hal_halloc(sizeof(memory_descriptor_node_t));
hal_assert(each_desc != NULL, "Unable to allocate memory for memory_descriptor.");
each_desc->page_count = page_count;
each_desc->base_addr = aligned_base_addr;
linked_list_add(boot_info->mem_info->free_page_list, &each_desc->list_node);
boot_info->mem_info->mem_available += aligned_end_addr-aligned_base_addr;
}
boot_info->mem_info->mem_installed += (mem_map + i)->len;
}
}
else

6
x64/src/c/hal/hal.h
View File

@ -9,7 +9,11 @@
extern void NATIVE64 hal_spin_lock(uint32_t * lock);
extern void NATIVE64 hal_spin_unlock(uint32_t * lock);
//inti
// loaded kernel addr
extern char kernel_start[];
extern char kernel_end[];
//hal
boot_info_t* NATIVE64 hal_init(multiboot_info_t* m_info);
//debug

2
x64/src/c/hal/mem.h
View File

@ -64,6 +64,8 @@
#define PAGE_ENTRY_BASE(PAGE_ENTRY) ((PAGE_ENTRY) & 0xFFFFFFFFFF000)
#define PHYSICAL_PAGE_SIZE 4096
typedef struct __attribute__ ((packed))
{
uint16_t limit;

47
x64/src/c/kernel/entry.c
View File

@ -3,34 +3,51 @@
#include "../hal/print.h"
#include "../hal/io.h"
#include "../common/util/util.h"
#include "../common/sys/sys_info.h"
#include "../common/util/list/linked_list/linked_list.h"
extern char kernel_start[];
extern char kernel_end[];
void NATIVE64 kmain(multiboot_info_t *multiboot_info)
{
boot_info_t* boot_info = hal_init(multiboot_info);
hal_printf("Kernel Loaded at 0x%X. Size: %uB, %uKB\n\n",kernel_start,(kernel_end-kernel_start),(kernel_end-kernel_start)/1024);
hal_printf("Available Memory: %uKB\n",boot_info->mem_info->mem_available / 1024);
hal_printf("Reserved Memory: %uB\n",boot_info->mem_info->mem_reserved);
hal_printf("Installed Memory: %uKB\n",(boot_info->mem_info->mem_reserved + boot_info->mem_info->mem_available)
/1024);
hal_printf("\nNumber of Modules Loaded: %u", boot_info->module_info->module_count);
for(uint64_t i = 0; i <= boot_info->module_info->module_count; i++)
if(boot_info->mem_info != NULL)
{
module_descriptor_node_t* module_descriptor = OBTAIN_STRUCT_ADDR(linked_list_get(boot_info->module_info->module_list,(int)i),
list_node,
module_descriptor_node_t);
hal_printf("\nModule Name: %s\n Module Addr: 0x%X\n Module Size: %uB, %uKB\n", module_descriptor->name, module_descriptor->base_addr, module_descriptor->size, module_descriptor->size / 1024);
};
hal_printf("Installed Memory: %uB\n", boot_info->mem_info->mem_installed);
hal_printf("Useable Memory: %uB\n", boot_info->mem_info->mem_available);
for(int i = 0; i < boot_info->mem_info->free_page_list->size; i++)
{
memory_descriptor_node_t* each_node = OBTAIN_STRUCT_ADDR(
linked_list_get(boot_info->mem_info->free_page_list,i),
list_node,
memory_descriptor_node_t);
hal_printf("Base Addr:0x%X Num of Pages:%u\n", each_node->base_addr, each_node->page_count);
}
}
if(boot_info->module_info != NULL)
{
hal_printf("\nNumber of Modules Loaded: %u", boot_info->module_info->module_count);
for (uint64_t i = 0; i <= boot_info->module_info->module_count; i++)
{
module_descriptor_node_t *module_descriptor = OBTAIN_STRUCT_ADDR(
linked_list_get(boot_info->module_info->module_list, (int) i),
list_node,
module_descriptor_node_t);
hal_printf("\nModule Name: %s\n Module Addr: 0x%X\n Module Size: %uB, %uKB\n", module_descriptor->name,
module_descriptor->base_addr, module_descriptor->size, module_descriptor->size / 1024);
};
}
// setup interrupt
for(uint64_t i = 0; i <= 21; i++)
{
hal_set_interrupt_handler(i, hal_interrupt_handler_wrapper);
}
hal_enable_interrupt();
// hal_enable_interrupt();
hal_printf("KRNL: Kernel task finished.");
hal_halt_cpu();

22
x64/src/c/kernel/pmm.c
View File

@ -40,17 +40,17 @@ void* pmm_alloc_page()
return NULL;
for(int i = 0; i < available_mem->size; i++)
{
memory_descriptor_node_t* each_node = OBTAIN_STRUCT_ADDR(linked_list_get(available_mem,i),list_node,memory_descriptor_node_t);
if(each_node->size >= PHYSICAL_PAGE_SIZE)
{
uint64_t address = each_node->base_addr;
// found, add to occupied list and return
each_node->size = each_node->size - PHYSICAL_PAGE_SIZE;
each_node->base_addr = each_node->base_addr + PHYSICAL_PAGE_SIZE;
return (void*)address;
}
// memory_descriptor_node_t* each_node = OBTAIN_STRUCT_ADDR(linked_list_get(available_mem,i),list_node,memory_descriptor_node_t);
// if(each_node->size >= PHYSICAL_PAGE_SIZE)
// {
// uint64_t address = each_node->base_addr;
// // found, add to occupied list and return
// each_node->size = each_node->size - PHYSICAL_PAGE_SIZE;
// each_node->base_addr = each_node->base_addr + PHYSICAL_PAGE_SIZE;
//
//
// return (void*)address;
// }
}
// not found

2
x64/src/c/kernel/pmm.h
View File

@ -3,8 +3,6 @@
#include "../common/util/list/linked_list/linked_list.h"
#define PHYSICAL_PAGE_SIZE 4096
void pmm_init(linked_list_t* occupied, linked_list_t* available);
void*pmm_alloc_page();