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

Development: 

1. Intergrated my salloc allocator
2. hal.c: Got rid of some gcc warnings, mainly int -> pointer.
3. entry.asm: 64-bit int immediate moved to a reg first then anded with another reg.
Refactoring:
1. Got rid of kernel_status_t, IN, OUT, OPT. secX does not have to be Windows does it?
2. Renamed _KERNEL_ABI to SAPI.
3. Refactored library functions / interfaces to as "static" and "_" as possible
4. Restructured "common" folder
This commit is contained in:
Siyao Zhao 2016-05-17 12:03:18 -07:00
parent fc241dc76f
commit 9ca5b1aa16
35 changed files with 505 additions and 602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -2,5 +2,5 @@ cmake_minimum_required(VERSION 2.8.4)
project(Workspace)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
file(GLOB_RECURSE SOURCE_FILES ./x64/src/c/* ./x86/src/c/*)
add_executable(Workspace ${SOURCE_FILES})
file(GLOB_RECURSE SOURCE_FILES ./x64/src/c/*)
add_executable(Workspace ${SOURCE_FILES} x64/src/c/common/lib/alloc/salloc/salloc.h)

253
Test/main.c
View File

@ -1,253 +0,0 @@
#include <stdint.h>
#include <stdio.h>
#include "bit_operation.h"
typedef union {
uint32_t size;
uint32_t flags;
} alloc_header;
#define ALLOC_FLAG_NUM 2
#define ALLOC_HEADER_FLAG_FREE 0
#define ALLOC_HEADER_FLAG_LAST 1
void set_alloc_header_size(alloc_header* header, uint32_t size)
{
// align the integer, ignoring overflowed bits
size <<= ALLOC_FLAG_NUM;
// clear ALLOC_FLAG_NUM-th to 31-th bits
header->size &= ~bit_field_mask_32(ALLOC_FLAG_NUM, 31);
// set bits
header->size |= size;
return;
}
uint32_t read_alloc_header_size(alloc_header* header)
{
return header->size >> ALLOC_FLAG_NUM;
}
uint32_t read_alloc_header_flag(alloc_header* header, uint32_t bit)
{
return (header->flags & bit_mask_32(bit)) == 0 ? 0 : 1;
}
void set_alloc_header_flag(alloc_header* header, uint32_t bit, uint32_t value)
{
value &= bit_mask_32(0);
if(value == 1)
{
header->flags |= bit_mask_32(bit);
}
else
{
header->flags &= ~bit_mask_32(bit);
}
return;
}
int init_alloc(void* base, unsigned int size)
{
if(base != NULL && size >= sizeof(unsigned int))
{
alloc_header* ptr = (alloc_header*)base;
set_alloc_header_size(ptr, size);
set_alloc_header_flag(ptr, ALLOC_HEADER_FLAG_FREE, 1);
set_alloc_header_flag(ptr, ALLOC_HEADER_FLAG_LAST, 1);
return 0;
}
return 1;
}
void alloc_join_free(void *base)
{
if(base != NULL)
{
char* c_ptr = (char*)base;
while(1)
{
uint32_t c_blk_free = read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t c_blk_last = read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t c_blk_size = read_alloc_header_size((alloc_header*)c_ptr);
char* n_ptr = c_blk_last == 1 ? NULL : c_ptr + c_blk_size;
if(n_ptr != NULL && c_blk_free == 1)
{
// if this is not the last block and the prev block is free
uint32_t n_blk_free = read_alloc_header_flag((alloc_header *) n_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t n_blk_last = read_alloc_header_flag((alloc_header *) n_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t n_blk_size = read_alloc_header_size((alloc_header*)n_ptr);
if (n_blk_free == 1)
{
// logically gone
set_alloc_header_size((alloc_header *) c_ptr, n_blk_size + c_blk_size);
set_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST, n_blk_last);
continue;
}
}
// update the c_ptr
if(c_blk_last == 0)
{
c_ptr += c_blk_size;
}
else
{
break;
}
}
}
}
int kfree(void* base, void* ptr)
{
if(base != NULL && ptr != NULL)
{
char* c_ptr = (char*)base;
while(1)
{
uint32_t cur_blk_free = read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_last = read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_size = read_alloc_header_size((alloc_header*)c_ptr);
if (cur_blk_free == 0 && ptr == c_ptr + sizeof(alloc_header))
{
// we found the block, mark it as free
set_alloc_header_flag((alloc_header*)c_ptr, ALLOC_HEADER_FLAG_FREE, 1);
// merge blocks
alloc_join_free(base);
return 0;
}
if(cur_blk_last == 1)
{
break;
}
else
{
c_ptr += cur_blk_size;
}
}
}
return 1;
}
void kalloc_print(void* base)
{
if(base != NULL)
{
printf("=======================================================\n");
char* c_ptr = (char*)base;
while(1)
{
uint32_t cur_blk_free = read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_last = read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_size = read_alloc_header_size((alloc_header*)c_ptr);
printf("Block:0x%llX Size:%d Free:%d Last:%d\n", (unsigned long long)c_ptr, cur_blk_size, cur_blk_free, cur_blk_last);
if(cur_blk_last == 1)
{
break;
}
else
{
c_ptr += cur_blk_size;
}
}
}
return;
}
int kalloc(void* base, unsigned int size, void** ptr)
{
if(base != NULL && size != 0 && ptr != NULL)
{
unsigned int total_size = size + sizeof(alloc_header);
char* c_ptr = (char*)base;
while(1)
{
uint32_t cur_blk_free = read_alloc_header_flag((alloc_header*)c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_size = read_alloc_header_size((alloc_header*)c_ptr);
uint32_t cur_blk_last = read_alloc_header_flag((alloc_header*)c_ptr, ALLOC_HEADER_FLAG_LAST);
if(cur_blk_free == 0 || cur_blk_size < total_size)
{
//if cur block not a free block
//or the current block size is less than the size we want
if(cur_blk_last == 1)
//if last one, break and fail.
break;
else
c_ptr += cur_blk_size;
}
else
{
// we have a free block with enough size
if(total_size == cur_blk_size ||
cur_blk_size - total_size < sizeof(alloc_header))
{
// since the space left is not enough for alloc_header
// we alloc the whole block
set_alloc_header_flag((alloc_header*)c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
}
else
{
// we split the block here
// set properties for the first block
set_alloc_header_size((alloc_header*)c_ptr, total_size);
set_alloc_header_flag((alloc_header*)c_ptr, ALLOC_HEADER_FLAG_LAST, 0);
set_alloc_header_flag((alloc_header*)c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
// set properties for the second block
set_alloc_header_size((alloc_header*)(c_ptr + total_size), cur_blk_size - total_size);
set_alloc_header_flag((alloc_header*)(c_ptr + total_size), ALLOC_HEADER_FLAG_LAST, cur_blk_last);
set_alloc_header_flag((alloc_header*)(c_ptr + total_size), ALLOC_HEADER_FLAG_FREE, 1);
}
// return the pointer, skip the alloc header
*ptr = c_ptr + sizeof(alloc_header);
return 0;
}
}
}
// getting here means did not work
if(ptr != NULL)
*ptr = NULL;
return 1;
}
char buffer[1024];
int main()
{
void *a = NULL, *b = NULL, *c = NULL, *d = NULL;
init_alloc(buffer, 1024);
kalloc(buffer, 10, &a);
kalloc_print(buffer);
kalloc(buffer, 10, &b);
kalloc_print(buffer);
kalloc(buffer, 10, &c);
kalloc_print(buffer);
kalloc(buffer, 10, &d);
kalloc_print(buffer);
kfree(buffer, b);
kalloc_print(buffer);
kfree(buffer,c);
kalloc_print(buffer);
kalloc(buffer,20,&b);
kalloc_print(buffer);
kfree(buffer,b);
kalloc_print(buffer);
kfree(buffer,a);
kfree(buffer,b);
kfree(buffer,c);
kfree(buffer,d);
kalloc_print(buffer);
kalloc(buffer, 1024, &a);
kalloc_print(buffer);
kalloc(buffer, 1024 - sizeof(alloc_header), &a);
kalloc_print(buffer);
kfree(buffer,a);
kalloc_print(buffer);
return 0;
}

2
makefile
View File

@ -82,7 +82,7 @@ ALL_OBJ_FILES_64 := $(addprefix $(OUTPUT_DIR)/,$(C_OBJ_FILES_64)) $(addprefix $(
#Commands
HOS: init compile link buildiso clean
all: init compile link buildiso clean
# buildsymbol
print_source:

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

@ -2,7 +2,6 @@ extern kmain
extern kernel_start
extern kernel_end
global BOCHS_MAGIC_BREAKPOINT
global kernel_heap
; IMPORTANT: This module should be 4k-page aliened
[SECTION .entry]
[BITS 32]
@ -192,7 +191,3 @@ hlt
BOCHS_MAGIC_BREAKPOINT:
xchg bx,bx
ret
align 4096 ;4k alignment
kernel_heap:
times 4096 db 0

8
x64/src/asm/hal/mem.asm
View File

@ -63,11 +63,13 @@ ret
;read_cr3
hal_read_page_base:
mov rax,cr3
and rax,0xFFFFFFFFFF000 ;keep bits 12-51
mov r11,0xFFFFFFFFFF000
and rax,r11 ;keep bits 12-51
ret
;write_cr3
hal_write_page_base:
and rdi,0xFFFFFFFFFF000 ;keep bits 12-51
mov r11,0xFFFFFFFFFF000
and rdi,r11 ;keep bits 12-51
mov cr3,rdi
ret
ret

211
x64/src/c/common/lib/alloc/salloc/salloc.c Normal file
View File

@ -0,0 +1,211 @@
#include "../../../sys/kdef.h"
#include "../../../sys/bit_ops.h"
typedef union {
uint32_t size;
uint32_t flags;
} alloc_header;
#define ALLOC_FLAG_NUM 2
#define ALLOC_HEADER_FLAG_FREE 0
#define ALLOC_HEADER_FLAG_LAST 1
static void SAPI _set_alloc_header_size(alloc_header *header, uint32_t size)
{
// align the integer, ignoring overflowed bits
size <<= ALLOC_FLAG_NUM;
// clear ALLOC_FLAG_NUM-th to 31-th bits
header->size &= ~bit_field_mask_32(ALLOC_FLAG_NUM, 31);
// set bits
header->size |= size;
return;
}
static uint32_t SAPI _read_alloc_header_size(alloc_header *header)
{
return header->size >> ALLOC_FLAG_NUM;
}
static uint32_t SAPI _read_alloc_header_flag(alloc_header *header, uint32_t bit)
{
return (header->flags & bit_mask_32(bit)) == 0 ? 0 : 1;
}
static void SAPI _set_alloc_header_flag(alloc_header *header, uint32_t bit, uint32_t value)
{
value &= bit_mask_32(0);
if(value == 1)
{
header->flags |= bit_mask_32(bit);
}
else
{
header->flags &= ~bit_mask_32(bit);
}
return;
}
static void _alloc_join(void *base)
{
if(base != NULL)
{
char* c_ptr = (char*)base;
while(1)
{
uint32_t c_blk_free = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t c_blk_last = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t c_blk_size = _read_alloc_header_size((alloc_header *) c_ptr);
char* n_ptr = c_blk_last == 1 ? NULL : c_ptr + c_blk_size;
if(n_ptr != NULL && c_blk_free == 1)
{
// if this is not the last block and the prev block is free
uint32_t n_blk_free = _read_alloc_header_flag((alloc_header *) n_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t n_blk_last = _read_alloc_header_flag((alloc_header *) n_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t n_blk_size = _read_alloc_header_size((alloc_header *) n_ptr);
if (n_blk_free == 1)
{
// logically gone
_set_alloc_header_size((alloc_header *) c_ptr, n_blk_size + c_blk_size);
_set_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST, n_blk_last);
continue;
}
}
// update the c_ptr
if(c_blk_last == 0)
{
c_ptr += c_blk_size;
}
else
{
break;
}
}
}
}
//static void salloc_print(void* base)
//{
// if(base != NULL)
// {
// //printf("=======================================================\n");
// char* c_ptr = (char*)base;
// while(1)
// {
// uint32_t cur_blk_free = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
// uint32_t cur_blk_last = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
// uint32_t cur_blk_size = _read_alloc_header_size((alloc_header *) c_ptr);
// //printf("Block:0x%llX Size:%d Free:%d Last:%d\n", (unsigned long long)c_ptr, cur_blk_size, cur_blk_free, cur_blk_last);
//
// if(cur_blk_last == 1)
// {
// break;
// }
// else
// {
// c_ptr += cur_blk_size;
// }
// }
// }
// return;
//}
void salloc_init(void *base, uint32_t size)
{
if(base != NULL && size >= sizeof(alloc_header))
{
alloc_header* ptr = (alloc_header*)base;
_set_alloc_header_size(ptr, size);
_set_alloc_header_flag(ptr, ALLOC_HEADER_FLAG_FREE, 1);
_set_alloc_header_flag(ptr, ALLOC_HEADER_FLAG_LAST, 1);
}
return;
}
void* salloc(void *base, uint32_t size)
{
void* result = NULL;
if(base != NULL && size != 0)
{
uint32_t total_size = size + sizeof(alloc_header);
char* c_ptr = (char*)base;
while(1)
{
uint32_t cur_blk_free = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_size = _read_alloc_header_size((alloc_header *) c_ptr);
uint32_t cur_blk_last = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
if(cur_blk_free == 0 || cur_blk_size < total_size)
{
//if cur block not a free block
//or the current block size is less than the size we want
if(cur_blk_last == 1)
//if last one, break and fail.
break;
else
c_ptr += cur_blk_size;
}
else
{
// we have a free block with enough size
if(total_size == cur_blk_size ||
cur_blk_size - total_size < sizeof(alloc_header))
{
// since the space left is not enough for alloc_header
// we alloc the whole block
_set_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
}
else
{
// we split the block here
// set properties for the first block
_set_alloc_header_size((alloc_header *) c_ptr, total_size);
_set_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST, 0);
_set_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
// set properties for the second block
_set_alloc_header_size((alloc_header *) (c_ptr + total_size), cur_blk_size - total_size);
_set_alloc_header_flag((alloc_header *) (c_ptr + total_size), ALLOC_HEADER_FLAG_LAST, cur_blk_last);
_set_alloc_header_flag((alloc_header *) (c_ptr + total_size), ALLOC_HEADER_FLAG_FREE, 1);
}
// return the pointer, skip the alloc header
result = c_ptr + sizeof(alloc_header);
break;
}
}
}
return result;
}
void sfree(void *base, void *ptr)
{
if(base != NULL && ptr != NULL)
{
char* c_ptr = (char*)base;
while(1)
{
uint32_t cur_blk_free = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_last = _read_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_size = _read_alloc_header_size((alloc_header *) c_ptr);
if (cur_blk_free == 0 && ptr == c_ptr + sizeof(alloc_header))
{
// we found the block, mark it as free
_set_alloc_header_flag((alloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 1);
// merge blocks
_alloc_join(base);
break;
}
if(cur_blk_last == 1)
{
break;
}
else
{
c_ptr += cur_blk_size;
}
}
}
return;
}

12
x64/src/c/common/lib/alloc/salloc/salloc.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef _SALLOC_H_
#define _SALLOC_H_
#include "../../../sys/kdef.h"
void salloc_init(void *base, uint32_t size);
void* salloc(void *base, uint32_t size);
void sfree(void *base, void *ptr);
#endif

24
x64/src/c/common/util/list/linked_list/linked_list.c → x64/src/c/common/lib/list/linked_list/linked_list.c
View File

@ -1,7 +1,7 @@
#include "../../../sys/kdef.h"
#include "linked_list.h"
void _KERNEL_ABI linked_list_node_init(linked_list_node_t * node)
static void SAPI linked_list_node_init(linked_list_node_t * node)
{
if(node != NULL)
{
@ -11,7 +11,7 @@ void _KERNEL_ABI linked_list_node_init(linked_list_node_t * node)
return;
}
linked_list_node_t *_KERNEL_ABI linked_list_node_get(linked_list_node_t * head, int index)
static linked_list_node_t *SAPI linked_list_node_get(linked_list_node_t * head, int index)
{
if(head == NULL || index < 0)
return NULL;
@ -24,7 +24,7 @@ linked_list_node_t *_KERNEL_ABI linked_list_node_get(linked_list_node_t * head,
return head;
}
int _KERNEL_ABI linked_list_node_size(linked_list_node_t * head)
static int SAPI linked_list_node_size(linked_list_node_t * head)
{
int i = 0;
while(head != NULL)
@ -36,7 +36,7 @@ int _KERNEL_ABI linked_list_node_size(linked_list_node_t * head)
}
//returns new head
linked_list_node_t *_KERNEL_ABI linked_list_node_insert(linked_list_node_t * head, int index, linked_list_node_t * node)
static linked_list_node_t *SAPI linked_list_node_insert(linked_list_node_t * head, int index, linked_list_node_t * node)
{
if(head == NULL)
return node;
@ -65,7 +65,7 @@ linked_list_node_t *_KERNEL_ABI linked_list_node_insert(linked_list_node_t * hea
}
}
void _KERNEL_ABI linked_list_node_push_back(linked_list_node_t *head, linked_list_node_t *node)
static void SAPI linked_list_node_push_back(linked_list_node_t *head, linked_list_node_t *node)
{
if(head == NULL || node == NULL)
return;
@ -75,7 +75,7 @@ void _KERNEL_ABI linked_list_node_push_back(linked_list_node_t *head, linked_lis
}
//returns new head
linked_list_node_t *_KERNEL_ABI linked_list_node_remove(linked_list_node_t *head, int index)
static linked_list_node_t *SAPI linked_list_node_remove(linked_list_node_t *head, int index)
{
if(head == NULL || index < 0)
return head;
@ -100,7 +100,7 @@ linked_list_node_t *_KERNEL_ABI linked_list_node_remove(linked_list_node_t *head
}
void _KERNEL_ABI linked_list_init(linked_list_t * list)
void SAPI linked_list_init(linked_list_t * list)
{
if(list != NULL)
{
@ -110,11 +110,12 @@ void _KERNEL_ABI linked_list_init(linked_list_t * list)
return;
}
void _KERNEL_ABI linked_list_push_back(linked_list_t *list, linked_list_node_t *node)
void SAPI linked_list_push_back(linked_list_t *list, linked_list_node_t *node)
{
if(list != NULL && node != NULL)
{
//@ node != NULL
linked_list_node_init(node);
if (list->head == NULL)
{
list->head = node;
@ -126,24 +127,25 @@ void _KERNEL_ABI linked_list_push_back(linked_list_t *list, linked_list_node_t *
return;
}
void _KERNEL_ABI linked_list_insert(linked_list_t * list, int index, linked_list_node_t * node)
void SAPI linked_list_insert(linked_list_t * list, int index, linked_list_node_t * node)
{
if(list != NULL && index > 0 && node != NULL)
{
linked_list_node_init(node);
list->head = linked_list_node_insert(list->head, index, node);
list->size++;
}
return;
}
linked_list_node_t *_KERNEL_ABI linked_list_get(linked_list_t * list, int index)
linked_list_node_t *SAPI linked_list_get(linked_list_t * list, int index)
{
if(list == NULL || index < 0 || index >= list->size)
return NULL;
return linked_list_node_get(list->head,index);
}
void _KERNEL_ABI linked_list_remove(linked_list_t *list, int index)
void SAPI linked_list_remove(linked_list_t *list, int index)
{
if(list != NULL && index >= 0 && index < list->size)
{

26
x64/src/c/common/lib/list/linked_list/linked_list.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef _LINKED_LIST_H_
#define _LINKED_LIST_H_
#include "../../../sys/kdef.h"
typedef struct _linked_list_node_t
{
struct _linked_list_node_t * prev;
struct _linked_list_node_t * next;
} linked_list_node_t;
typedef struct
{
linked_list_node_t * head;
int size;
} linked_list_t;
void SAPI linked_list_init(linked_list_t * list);
void SAPI linked_list_push_back(linked_list_t *list, linked_list_node_t *node);
void SAPI linked_list_insert(linked_list_t * list, int index, linked_list_node_t * node);
linked_list_node_t *SAPI linked_list_get(linked_list_t * list, int index);
void SAPI linked_list_remove(linked_list_t *list, int index);
#endif

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

@ -1,13 +0,0 @@
#ifndef _HAL_MEM_H_
#define _HAL_MEM_H_
#include "../sys/type.h"
#include "../sys/kdef.h"
void _KERNEL_ABI mem_copy(void *src, void *dst, uint64_t size);
void _KERNEL_ABI mem_move(void *src, void *dst, uint64_t size);
void _KERNEL_ABI mem_set(void *src, int8_t const val, uint64_t size);
#endif

10
x64/src/c/common/lib/mem.c → x64/src/c/common/lib/std/mem.c
View File

@ -1,8 +1,8 @@
#include "../sys/type.h"
#include "../sys/kdef.h"
#include "../../sys/type.h"
#include "../../sys/kdef.h"
#include "mem.h"
void _KERNEL_ABI mem_copy(void *src, void *dst, uint64_t size)
void SAPI mem_copy(void *src, void *dst, uint64_t size)
{
if (src == NULL || dst == NULL)
return;
@ -13,7 +13,7 @@ void _KERNEL_ABI mem_copy(void *src, void *dst, uint64_t size)
return;
}
void _KERNEL_ABI mem_set(void *src, int8_t const val, uint64_t size)
void SAPI mem_set(void *src, int8_t const val, uint64_t size)
{
if (src == NULL)
return;
@ -22,7 +22,7 @@ void _KERNEL_ABI mem_set(void *src, int8_t const val, uint64_t size)
return;
}
void _KERNEL_ABI mem_move(void *src, void *dst, uint64_t size)
void SAPI mem_move(void *src, void *dst, uint64_t size)
{
if (src == NULL || dst == NULL)
return;

13
x64/src/c/common/lib/std/mem.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef _HAL_MEM_H_
#define _HAL_MEM_H_
#include "../../sys/type.h"
#include "../../sys/kdef.h"
void SAPI mem_copy(void *src, void *dst, uint64_t size);
void SAPI mem_move(void *src, void *dst, uint64_t size);
void SAPI mem_set(void *src, int8_t const val, uint64_t size);
#endif

4
x64/src/c/common/lib/str.c → x64/src/c/common/lib/std/str.c
View File

@ -1,6 +1,6 @@
#include "str.h"
uint64_t _KERNEL_ABI str_len(char const *str)
uint64_t SAPI str_len(char const *str)
{
uint64_t length = 0;
if(str == NULL)
@ -13,7 +13,7 @@ uint64_t _KERNEL_ABI str_len(char const *str)
return length;
}
uint64_t _KERNEL_ABI str_cmp(char const *str1, char const *str2)
uint64_t SAPI str_cmp(char const *str1, char const *str2)
{
if(str1 == NULL || str2 == NULL)
return 0;

10
x64/src/c/common/lib/std/str.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef _STR_H_
#define _STR_H_
#include "../../sys/kdef.h"
#include "../../sys/type.h"
uint64_t SAPI str_len(char const *str);
uint64_t SAPI str_cmp(char const *str1, char const *str2);
#endif

10
x64/src/c/common/lib/str.h
View File

@ -1,10 +0,0 @@
#ifndef _STR_H_
#define _STR_H_
#include "../sys/kdef.h"
#include "../sys/type.h"
uint64_t _KERNEL_ABI str_len(char const *str);
uint64_t _KERNEL_ABI str_cmp(char const *str1, char const *str2);
#endif

90
x64/src/c/common/util/tree/avl_tree/avl_tree.c → x64/src/c/common/lib/tree/avl_tree/avl_tree.c
View File

@ -1,21 +1,19 @@
#include "../../../sys/kdef.h"
#include "avl_tree.h"
#define MAX(a, b) (((a) > (b) ? (a) : (b)))
int _KERNEL_ABI _avl_tree_node_get_height(avl_tree_node_t *node)
static int SAPI _avl_tree_node_get_height(avl_tree_node_t *node)
{
return node == NULL ? -1 : node->height;
}
int _KERNEL_ABI _avl_tree_node_get_balance_factor(avl_tree_node_t *node)
static int SAPI _avl_tree_node_get_balance_factor(avl_tree_node_t *node)
{
if (node == NULL)
return 0;
return _avl_tree_node_get_height(node->left) - _avl_tree_node_get_height(node->right);
}
avl_tree_node_t *_KERNEL_ABI _avl_tree_node_right_rotate(avl_tree_node_t *root)
static avl_tree_node_t *SAPI _avl_tree_node_right_rotate(avl_tree_node_t *root)
{
avl_tree_node_t *left_children = root->left;
//adjust parents first
@ -27,12 +25,12 @@ avl_tree_node_t *_KERNEL_ABI _avl_tree_node_right_rotate(avl_tree_node_t *root)
root->left = root->left->right;
left_children->right = root;
//adjust height
root->height = MAX(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
left_children->height = MAX(_avl_tree_node_get_height(left_children->left), _avl_tree_node_get_height(left_children->right)) + 1;
root->height = max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
left_children->height = max_32(_avl_tree_node_get_height(left_children->left), _avl_tree_node_get_height(left_children->right)) + 1;
return left_children;
}
avl_tree_node_t *_KERNEL_ABI _avl_tree_node_left_rotate(avl_tree_node_t *root)
static avl_tree_node_t *SAPI _avl_tree_node_left_rotate(avl_tree_node_t *root)
{
avl_tree_node_t *right_children = root->right;
//adjust parents
@ -44,12 +42,12 @@ avl_tree_node_t *_KERNEL_ABI _avl_tree_node_left_rotate(avl_tree_node_t *root)
root->right = root->right->left;
right_children->left = root;
root->height = MAX(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
right_children->height = MAX(_avl_tree_node_get_height(right_children->left), _avl_tree_node_get_height(right_children->right)) + 1;
root->height = max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
right_children->height = max_32(_avl_tree_node_get_height(right_children->left), _avl_tree_node_get_height(right_children->right)) + 1;
return right_children;
}
avl_tree_node_t *_KERNEL_ABI _avl_tree_node_balance(avl_tree_node_t *node)
static avl_tree_node_t *SAPI _avl_tree_node_balance(avl_tree_node_t *node)
{
const int bf = _avl_tree_node_get_balance_factor(node);
@ -86,7 +84,7 @@ avl_tree_node_t *_KERNEL_ABI _avl_tree_node_balance(avl_tree_node_t *node)
}
avl_tree_node_t *_KERNEL_ABI _avl_tree_node_insert(avl_tree_node_t *root, avl_tree_node_t *node, int(*compare)(void *, void *), avl_tree_node_t *parent)
static avl_tree_node_t *SAPI _avl_tree_node_insert(avl_tree_node_t *root, avl_tree_node_t *node, int(*compare)(void *, void *), avl_tree_node_t *parent)
{
if (node == NULL)
return root;
@ -104,12 +102,12 @@ avl_tree_node_t *_KERNEL_ABI _avl_tree_node_insert(avl_tree_node_t *root, avl_tr
else
root->left = _avl_tree_node_insert(root->left, node, compare, root);
root->height = MAX(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
root->height = max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
return _avl_tree_node_balance(root);
}
void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
static void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
{
if (node1 == NULL || node2 == NULL)
return;
@ -157,9 +155,9 @@ void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
parent->parent = child;
if (child == parent->left)
{
// parent
// / \
// children
/* parent
/ \
children */
parent->left = child->left;
child->left = parent;
@ -169,9 +167,9 @@ void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
}
else
{
// parent
// / \
// children
/* parent
/ \
children */
parent->right = child->right;
child->right = parent;
@ -231,21 +229,16 @@ void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
return;
}
//Interface
avl_tree_node_t *_KERNEL_ABI avl_tree_node_insert(avl_tree_node_t * root, avl_tree_node_t * node, int(*compare)(void*, void*))
{
return _avl_tree_node_insert(root, node, compare, NULL);
}
avl_tree_node_t *_KERNEL_ABI avl_tree_node_delete(avl_tree_node_t * root, avl_tree_node_t * node, int (*compare)(void *, void *))
static avl_tree_node_t *SAPI _avl_tree_node_delete(avl_tree_node_t *root, avl_tree_node_t *node,
int (*compare)(void *, void *))
{
if (root == NULL || node == NULL)
return root;
const int comp = compare(root, node);
if (comp < 0)
root->right = avl_tree_node_delete(root->right, node, compare);
root->right = _avl_tree_node_delete(root->right, node, compare);
else if(comp > 0)
root->left = avl_tree_node_delete(root->left, node, compare);
root->left = _avl_tree_node_delete(root->left, node, compare);
else
{
// node with only one child or no child
@ -274,32 +267,33 @@ avl_tree_node_t *_KERNEL_ABI avl_tree_node_delete(avl_tree_node_t * root, avl_tr
_avl_tree_swap_nodes(successor, root);
// Detach the inorder successor
successor->right = avl_tree_node_delete(successor->right, root, compare);
successor->right = _avl_tree_node_delete(successor->right, root, compare);
root = successor;
}
}
if (root == NULL)
return root;
root->height = MAX(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
root->height = max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
root = _avl_tree_node_balance(root);
return root;
}
avl_tree_node_t *_KERNEL_ABI avl_tree_node_search(avl_tree_node_t *root, avl_tree_node_t * node, int(*compare)(void *, void *))
static avl_tree_node_t *SAPI _avl_tree_node_search(avl_tree_node_t *root, avl_tree_node_t *node,
int(*compare)(void *, void *))
{
if(root == NULL)
return NULL;
const int comp = compare(root, node);
if (comp < 0)
return avl_tree_node_search(root->right, node, compare);
return _avl_tree_node_search(root->right, node, compare);
else if (comp == 0)
return root;
else
return avl_tree_node_search(root->left, node, compare);
return _avl_tree_node_search(root->left, node, compare);
}
void _KERNEL_ABI avl_tree_node_init(avl_tree_node_t * it)
static void SAPI _avl_tree_node_init(avl_tree_node_t * it)
{
if(it != NULL)
{
@ -312,7 +306,7 @@ void _KERNEL_ABI avl_tree_node_init(avl_tree_node_t * it)
}
avl_tree_node_t *_KERNEL_ABI avl_tree_node_smallest(avl_tree_node_t *root)
static avl_tree_node_t *SAPI _avl_tree_node_smallest(avl_tree_node_t *root)
{
if (root == NULL)
return NULL;
@ -321,7 +315,7 @@ avl_tree_node_t *_KERNEL_ABI avl_tree_node_smallest(avl_tree_node_t *root)
return root;
}
avl_tree_node_t *_KERNEL_ABI avl_tree_node_largest(avl_tree_node_t *root)
static avl_tree_node_t *SAPI _avl_tree_node_largest(avl_tree_node_t *root)
{
if (root == NULL)
return NULL;
@ -331,7 +325,7 @@ avl_tree_node_t *_KERNEL_ABI avl_tree_node_largest(avl_tree_node_t *root)
}
avl_tree_node_t *_KERNEL_ABI avl_tree_node_next(avl_tree_node_t *it)
static avl_tree_node_t *SAPI _avl_tree_node_next(avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
@ -355,7 +349,7 @@ avl_tree_node_t *_KERNEL_ABI avl_tree_node_next(avl_tree_node_t *it)
}
}
avl_tree_node_t *_KERNEL_ABI avl_tree_node_prev(avl_tree_node_t *it)
static avl_tree_node_t *SAPI _avl_tree_node_prev(avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
@ -379,13 +373,13 @@ avl_tree_node_t *_KERNEL_ABI avl_tree_node_prev(avl_tree_node_t *it)
}
}
avl_tree_node_t * avl_tree_search(avl_tree_t *tree, avl_tree_node_t * node, int (*compare)(void *, void *))
avl_tree_node_t * SAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t * node, int (*compare)(void *, void *))
{
return avl_tree_node_search(tree->root,node,compare);
return _avl_tree_node_search(tree->root, node, compare);
}
void _KERNEL_ABI avl_tree_insert(avl_tree_t *tree, void *data, int (*compare)(void *, void *))
void SAPI avl_tree_insert(avl_tree_t *tree, void *data, int (*compare)(void *, void *))
{
if(tree != NULL && data != NULL && compare != NULL)
{
@ -398,20 +392,20 @@ void _KERNEL_ABI avl_tree_insert(avl_tree_t *tree, void *data, int (*compare)(vo
return;
}
void _KERNEL_ABI avl_tree_delete(avl_tree_t *tree, void *data, int (*compare)(void *, void *))
void SAPI avl_tree_delete(avl_tree_t *tree, void *data, int (*compare)(void *, void *))
{
if(tree != NULL && data != NULL && compare != NULL && tree->size != 0)
{
if(avl_tree_search(tree, data, compare) != NULL)
{
tree->root = avl_tree_node_delete(tree->root, data, compare);
tree->root = _avl_tree_node_delete(tree->root, data, compare);
tree->size--;
}
}
return;
}
void _KERNEL_ABI avl_tree_init(avl_tree_t * tree)
void SAPI avl_tree_init(avl_tree_t * tree)
{
if(tree != NULL)
{
@ -422,14 +416,14 @@ void _KERNEL_ABI avl_tree_init(avl_tree_t * tree)
}
// TESTS
int _KERNEL_ABI avl_tree_node_calculate_height(avl_tree_node_t *tree)
static int SAPI avl_tree_node_calculate_height(avl_tree_node_t *tree)
{
if (tree == NULL)
return -1;
return MAX(avl_tree_node_calculate_height(tree->left), avl_tree_node_calculate_height(tree->right)) + 1;
return max_32(avl_tree_node_calculate_height(tree->left), avl_tree_node_calculate_height(tree->right)) + 1;
}
int _KERNEL_ABI avl_tree_node_test(avl_tree_node_t *tree, int (*compare)(void*, void*))
static int SAPI avl_tree_node_test(avl_tree_node_t *tree, int (*compare)(void*, void*))
{
if (tree == NULL)
return 1;

28
x64/src/c/common/lib/tree/avl_tree/avl_tree.h Normal file
View File

@ -0,0 +1,28 @@
#ifndef _AVL_TREE_H_
#define _AVL_TREE_H_
#include "../../../sys/kdef.h"
typedef struct _avl_tree_node_t
{
struct _avl_tree_node_t * left;
struct _avl_tree_node_t * right;
struct _avl_tree_node_t * parent;
int height;
} avl_tree_node_t;
typedef struct
{
avl_tree_node_t * root;
int size;
} avl_tree_t;
avl_tree_node_t * SAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t * node, int (*compare)(void *, void *));
void SAPI avl_tree_insert(avl_tree_t *tree, void *data, int (*compare)(void *, void *));
void SAPI avl_tree_delete(avl_tree_t *tree, void *data, int (*compare)(void *, void *));
void SAPI avl_tree_init(avl_tree_t * tree);
#endif

0
Test/bit_operation.h → x64/src/c/common/sys/bit_ops.h
View File

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

@ -3,30 +3,51 @@
#include <stddef.h>
#include <stdarg.h>
#include <stdint.h>
#include "type.h"
#define _KERNEL_ABI __attribute__((sysv_abi))
#define SAPI __attribute__((sysv_abi))
#define UAPI __attribute__((sysv_abi))
#define ALIGN_DOWN(val, alignment) (((val) / (alignment)) * (alignment))
static inline uint64_t align_down(uint64_t val, uint64_t alignment)
{
return (val / alignment) * alignment;
}
#define ALIGN_UP(val, alignment) ((((val) % (alignment)) == 0) ? (((val) / (alignment)) * (alignment)) : ((((val) / (alignment)) * (alignment)) + 1))
static inline uint64_t align_up(uint64_t val, uint64_t alignment)
{
return ((((val) % (alignment)) == 0) ? (((val) / (alignment)) * (alignment)) : ((((val) / (alignment)) * (alignment)) + 1));
}
#define IS_OVERLAP(x1,x2,y1,y2) (((x1) <= (y2)) && ((y1) <= (x2)))
static inline uint64_t is_overlap(uint64_t x1, uint64_t x2, uint64_t y1, uint64_t y2)
{
return ((x1 <= y2) && (y1 <= x2)) ? 1 : 0;
}
#define MAX(a,b) ((a) > (b) ? (a) : (b))
static inline int64_t max_64(int64_t a, int64_t b)
{
return (a) > (b) ? a : b;
}
#define MIN(a,b) ((a) < (b) ? (a) : (b))
static inline int64_t min_64(int64_t a, int64_t b)
{
return (a) < (b) ? a : b;
}
#define SEG_SELECTOR(Index,RPL) (((Index) << 3) + (RPL))
static inline int32_t max_32(int32_t a, int32_t b)
{
return (a) > (b) ? a : b;
}
#define _IN_OPT
#define _OUT_OPT
#define _IN
#define _OUT
static inline int32_t min_32(int32_t a, int32_t b)
{
return (a) < (b) ? a : b;
}
typedef enum {
KERNEL_STATUS_SUCCESS = 0,
KERNEL_STATUS_FAIL = 1
} kernel_status_t;
static inline uint32_t seg_selector(uint32_t index, uint32_t rpl)
{
return (index << 3) + rpl;
}
#define OBTAIN_STRUCT_ADDR(member_addr, member_name, struct_name) ((struct_name*)((char*)(member_addr)-(uint64_t)(&(((struct_name*)0)->member_name))))
#endif

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

@ -1,7 +1,7 @@
#ifndef _SYS_INFO_H_
#define _SYS_INFO_H_
#include "type.h"
#include "../util/list/linked_list/linked_list.h"
#include "../lib/list/linked_list/linked_list.h"
#define MEMORY_OCCUPIED 0
#define MEMORY_AVAILABLE 1

27
x64/src/c/common/util/list/linked_list/linked_list.h
View File

@ -1,27 +0,0 @@
#ifndef _LINKED_LIST_H_
#define _LINKED_LIST_H_
#include "../../../sys/kdef.h"
typedef struct _linked_list_node_t
{
struct _linked_list_node_t * prev;
struct _linked_list_node_t * next;
} linked_list_node_t;
typedef struct
{
linked_list_node_t * head;
int size;
} linked_list_t;
void _KERNEL_ABI linked_list_init(linked_list_t * list);
void _KERNEL_ABI linked_list_push_back(linked_list_t *list, linked_list_node_t *node);
void _KERNEL_ABI linked_list_insert(linked_list_t * list, int index, linked_list_node_t * node);
linked_list_node_t *_KERNEL_ABI linked_list_get(linked_list_t * list, int index);
void _KERNEL_ABI linked_list_remove(linked_list_t *list, int index);
void _KERNEL_ABI linked_list_node_init(linked_list_node_t * node);
#endif

51
x64/src/c/common/util/tree/avl_tree/avl_tree.h
View File

@ -1,51 +0,0 @@
#ifndef _AVL_TREE_H_
#define _AVL_TREE_H_
#include "../../../sys/kdef.h"
typedef struct _avl_tree_node_t
{
struct _avl_tree_node_t * left;
struct _avl_tree_node_t * right;
struct _avl_tree_node_t * parent;
int height;
} avl_tree_node_t;
typedef struct
{
avl_tree_node_t * root;
int size;
} avl_tree_t;
avl_tree_node_t *_KERNEL_ABI avl_tree_node_insert(avl_tree_node_t * root, avl_tree_node_t * node, int(*compare)(void*, void*));
avl_tree_node_t *_KERNEL_ABI avl_tree_node_delete(avl_tree_node_t * root, avl_tree_node_t * node, int (*compare)(void *, void *));
avl_tree_node_t *_KERNEL_ABI avl_tree_node_search(avl_tree_node_t *root, avl_tree_node_t * node, int(*compare)(void *, void *));
void _KERNEL_ABI avl_tree_node_init(avl_tree_node_t * it);
avl_tree_node_t *_KERNEL_ABI avl_tree_node_next(avl_tree_node_t *it);
avl_tree_node_t *_KERNEL_ABI avl_tree_node_prev(avl_tree_node_t *it);
avl_tree_node_t *_KERNEL_ABI avl_tree_node_smallest(avl_tree_node_t *root);
avl_tree_node_t *_KERNEL_ABI avl_tree_node_largest(avl_tree_node_t *root);
avl_tree_node_t * avl_tree_search(avl_tree_t *tree, avl_tree_node_t * node, int (*compare)(void *, void *));
void _KERNEL_ABI avl_tree_insert(avl_tree_t *tree, void *data, int (*compare)(void *, void *));
void _KERNEL_ABI avl_tree_delete(avl_tree_t *tree, void *data, int (*compare)(void *, void *));
void _KERNEL_ABI avl_tree_init(avl_tree_t * tree);
// TESTS
int _KERNEL_ABI avl_tree_node_calculate_height(avl_tree_node_t *tree);
int _KERNEL_ABI avl_tree_node_test(avl_tree_node_t *tree, int(*compare)(void *, void *));
#endif

6
x64/src/c/common/util/util.h
View File

@ -1,6 +0,0 @@
#ifndef _UTIL_H_
#define _UTIL_H_
#include "../sys/type.h"
#define OBTAIN_STRUCT_ADDR(member_addr, member_name, struct_name) ((struct_name*)((char*)(member_addr)-(uint64_t)(&(((struct_name*)0)->member_name))))
#endif

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

@ -3,15 +3,15 @@
#include "mem.h"
#include "io.h"
#include "var.h"
#include "../common/lib/str.h"
#include "../common/lib/mem.h"
#include "../common/lib/std/str.h"
#include "../common/lib/std/mem.h"
#include "../common/sys/sys_info.h"
boot_info_t *_KERNEL_ABI hal_init(multiboot_info_t *m_info)
boot_info_t *SAPI hal_init(multiboot_info_t *m_info)
{
if (m_info == NULL)
return NULL;
boot_info_t *boot_info = (boot_info_t *) hal_halloc(sizeof(boot_info_t));
boot_info_t *boot_info = (boot_info_t *) hal_alloc(sizeof(boot_info_t));
text_pos = get_pos(0, 0);
// get gdt ready
@ -39,31 +39,34 @@ boot_info_t *_KERNEL_ABI hal_init(multiboot_info_t *m_info)
SEG_TYPE_DATA_RW);
g_gdt_ptr.base = (uint64_t) g_gdt;
g_gdt_ptr.limit = 8 * 9 - 1;
hal_flush_gdt(&g_gdt_ptr, SEG_SELECTOR(1, 0), SEG_SELECTOR(2, 0));
hal_flush_gdt(&g_gdt_ptr, seg_selector(1, 0), seg_selector(2, 0));
// get idt ptr ready
g_idt_ptr.base = (uint64_t) g_idt;
g_idt_ptr.limit = 21 * 16 - 1;
hal_flush_idt(&g_idt_ptr);
// set up kernel heap;
hal_alloc_init();
mem_set(boot_info, 0, sizeof(boot_info_t));
// obtain boot information
// memory info
if (m_info->flags & (1 << 6))
{
boot_info->mem_info = (mem_info_t *) hal_halloc(sizeof(mem_info_t));
boot_info->mem_info = (mem_info_t *) hal_alloc(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_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)));
boot_info->mem_info->free_page_list = (linked_list_t *) hal_alloc((sizeof(linked_list_t)));
boot_info->mem_info->occupied_page_list = (linked_list_t *) hal_alloc((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++)
multiboot_memory_map_t *mem_map = (multiboot_memory_map_t *) (uint64_t)m_info->mmap_addr;
uint64_t mem_map_size = m_info->mmap_length / sizeof(multiboot_memory_map_t);
for (uint64_t i = 0; i < mem_map_size; i++)
{
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");
@ -73,9 +76,9 @@ boot_info_t *_KERNEL_ABI hal_init(multiboot_info_t *m_info)
uint64_t end_addr = base_addr + (mem_map + i)->len;
// align head
uint64_t aligned_base_addr = ALIGN_UP(base_addr, PHYSICAL_PAGE_SIZE);
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 aligned_end_addr = align_down(end_addr, PHYSICAL_PAGE_SIZE);
uint64_t page_count = (aligned_end_addr - aligned_base_addr) / PHYSICAL_PAGE_SIZE;
@ -95,7 +98,7 @@ boot_info_t *_KERNEL_ABI hal_init(multiboot_info_t *m_info)
// if(overlap_pages != 0)
// {
// // if there is overlap, add to occupied list
// memory_descriptor_node_t *occupied_desc = (memory_descriptor_node_t *) hal_halloc(
// memory_descriptor_node_t *occupied_desc = (memory_descriptor_node_t *) hal_alloc(
// sizeof(memory_descriptor_node_t));
// hal_assert(occupied_desc != NULL, "Unable to allocate memory for memory_descriptor.");
// occupied_desc->base_addr = aligned_kernel_base;
@ -110,7 +113,7 @@ boot_info_t *_KERNEL_ABI hal_init(multiboot_info_t *m_info)
// }
// }
memory_descriptor_node_t *each_desc = (memory_descriptor_node_t *) hal_halloc(
memory_descriptor_node_t *each_desc = (memory_descriptor_node_t *) hal_alloc(
sizeof(memory_descriptor_node_t));
hal_assert(each_desc != NULL, "Unable to allocate memory for memory_descriptor.");
each_desc->page_count = page_count;
@ -131,25 +134,25 @@ boot_info_t *_KERNEL_ABI hal_init(multiboot_info_t *m_info)
// loaded kernel modules
if (m_info->flags & (1 << 3))
{
boot_info->module_info = (module_info_t *) hal_halloc(sizeof(module_info_t));
boot_info->module_info = (module_info_t *) hal_alloc(sizeof(module_info_t));
hal_assert(boot_info->module_info != NULL, "Unable to allocate memory for module_info.");
boot_info->module_info->module_count = 0;
boot_info->module_info->module_list = (linked_list_t *) hal_halloc(sizeof(linked_list_t));
boot_info->module_info->module_list = (linked_list_t *) hal_alloc(sizeof(linked_list_t));
hal_assert(boot_info->module_info->module_list != NULL, "Unable to allocate memory for module_list.");
linked_list_init(boot_info->module_info->module_list);
multiboot_module_t const *mods_list = (multiboot_module_t *) m_info->mods_addr;
multiboot_module_t *mods_list = (multiboot_module_t *) (uint64_t) m_info->mods_addr;
boot_info->module_info->module_count = m_info->mods_count;
for (uint64_t i = 0; i < boot_info->module_info->module_count; i++)
{
module_descriptor_node_t *each_module = (module_descriptor_node_t *) hal_halloc(
module_descriptor_node_t *each_module = (module_descriptor_node_t *) hal_alloc(
sizeof(module_descriptor_node_t));
hal_assert(each_module != NULL, "Unable to allocate memory for module_descriptor.");
each_module->base_addr = (mods_list + i)->mod_start;
each_module->size = (mods_list + i)->mod_end - (mods_list + i)->mod_start;
each_module->name = (char *) hal_halloc((size_t) str_len((char *) (mods_list + i)->cmdline) + 1);
each_module->name = (char *) hal_alloc((size_t) str_len((char *) (uint64_t)(mods_list + i)->cmdline) + 1);
hal_assert(each_module->name != NULL, "Unable to allocate memory for module name string.");
mem_copy((void *) (mods_list + i)->cmdline, each_module->name,
str_len((char *) (mods_list + i)->cmdline) + 1);
mem_copy((void *)(uint64_t)(mods_list + i)->cmdline, each_module->name,
str_len((char *)(uint64_t)(mods_list + i)->cmdline) + 1);
linked_list_push_back(boot_info->module_info->module_list, &each_module->list_node);
}
}
@ -175,7 +178,7 @@ boot_info_t *_KERNEL_ABI hal_init(multiboot_info_t *m_info)
return boot_info;
}
void _KERNEL_ABI hal_spin_lock(uint64_t *lock)
void SAPI hal_spin_lock(uint64_t *lock)
{
if (lock != NULL)
{
@ -185,7 +188,7 @@ void _KERNEL_ABI hal_spin_lock(uint64_t *lock)
return;
}
void _KERNEL_ABI hal_spin_unlock(uint64_t *lock)
void SAPI hal_spin_unlock(uint64_t *lock)
{
if (lock != NULL)
{

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

@ -6,21 +6,21 @@
#include "../common/sys/sys_info.h"
// concurrency
void _KERNEL_ABI hal_spin_lock(uint64_t * lock);
void _KERNEL_ABI hal_spin_unlock(uint64_t * lock);
void SAPI hal_spin_lock(uint64_t * lock);
void SAPI hal_spin_unlock(uint64_t * lock);
// Atomically set *dst = val
// return: the previous value of *dst
extern uint64_t _KERNEL_ABI hal_interlocked_exchange(_IN _OUT uint64_t* dst,
_IN uint64_t val);
extern uint64_t SAPI hal_interlocked_exchange(uint64_t* dst,
uint64_t val);
// loaded kernel addr
extern char kernel_start[];
extern char kernel_end[];
//hal
boot_info_t*_KERNEL_ABI hal_init(multiboot_info_t* m_info);
boot_info_t*SAPI hal_init(multiboot_info_t* m_info);
//debug
extern void _KERNEL_ABI BOCHS_MAGIC_BREAKPOINT();
extern void SAPI BOCHS_MAGIC_BREAKPOINT();
#endif

18
x64/src/c/hal/io.c
View File

@ -8,10 +8,10 @@ void hal_interrupt_handler_dummy(void)
}
void _KERNEL_ABI hal_write_gate(_IN void *const gate,
_IN uint64_t const offset,
_IN uint32_t const selector,
_IN uint32_t const attr)
void SAPI hal_write_gate(void *const gate,
uint64_t const offset,
uint32_t const selector,
uint32_t const attr)
{
((uint8_t *) gate)[0] = (uint8_t) (offset & 0xFF);
((uint8_t *) gate)[1] = (uint8_t) ((offset >> 8) & 0xFF);
@ -32,16 +32,16 @@ void _KERNEL_ABI hal_write_gate(_IN void *const gate,
return;
}
void _KERNEL_ABI hal_set_interrupt_handler(_IN uint64_t index,
_IN void (*handler)(void))
void SAPI hal_set_interrupt_handler(uint64_t index,
void (*handler)(void))
{
hal_write_gate(g_idt + 16 * index, (uint64_t) handler, SEG_SELECTOR(1, 0),
hal_write_gate(g_idt + 16 * index, (uint64_t) handler, seg_selector(1, 0),
GATE_DPL_0 | GATE_PRESENT | GATE_TYPE_INTERRUPT);
return;
}
void _KERNEL_ABI hal_assert(_IN int64_t expression,
_IN_OPT char *message)
void SAPI hal_assert(int64_t expression,
char *message)
{
if (!expression)
{

20
x64/src/c/hal/io.h
View File

@ -12,20 +12,20 @@
#define GATE_TYPE_INTERRUPT (14ull << 8)
#define GATE_TYPE_TRAP (15ull << 8)
extern void _KERNEL_ABI hal_write_port(uint64_t port, int64_t data);
extern int64_t _KERNEL_ABI hal_read_port(uint64_t port);
void _KERNEL_ABI hal_interrupt_handler_dummy();
extern void SAPI hal_write_port(uint64_t port, int64_t data);
extern int64_t SAPI hal_read_port(uint64_t port);
void SAPI hal_interrupt_handler_dummy();
void _KERNEL_ABI hal_set_interrupt_handler(uint64_t index, void (*handler)());
extern void _KERNEL_ABI hal_enable_interrupt();
extern void _KERNEL_ABI hal_disable_interrupt();
extern void _KERNEL_ABI hal_interrupt_handler_wrapper();
extern void _KERNEL_ABI hal_halt_cpu();
void SAPI hal_set_interrupt_handler(uint64_t index, void (*handler)());
extern void SAPI hal_enable_interrupt();
extern void SAPI hal_disable_interrupt();
extern void SAPI hal_interrupt_handler_wrapper();
extern void SAPI hal_halt_cpu();
void _KERNEL_ABI hal_write_gate(void *const gate, uint64_t const offset, uint32_t const selector, uint32_t const attr);
void SAPI hal_write_gate(void *const gate, uint64_t const offset, uint32_t const selector, uint32_t const attr);
//assert
void _KERNEL_ABI hal_assert(int64_t exp, char* message);
void SAPI hal_assert(int64_t exp, char* message);
extern uint8_t g_idt[];
#endif

81
x64/src/c/hal/mem.c
View File

@ -1,15 +1,13 @@
#include "../common/sys/kdef.h"
#include "../common/sys/type.h"
#include "mem.h"
#include "../common/lib/alloc/salloc/salloc.h"
#define KERNEL_HEAP_SIZE 4096
char kernel_heap[KERNEL_HEAP_SIZE];
char *_cur_heap = NULL;
extern char kernel_heap[KERNEL_HEAP_SIZE];
void _KERNEL_ABI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr)
void SAPI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -25,7 +23,7 @@ void _KERNEL_ABI hal_write_pt_entry(void *const base, uint64_t const p_addr, uin
return;
}
void _KERNEL_ABI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr)
void SAPI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -41,7 +39,7 @@ void _KERNEL_ABI hal_write_pd_entry(void *const base, uint64_t const pt_addr, ui
return;
}
void _KERNEL_ABI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr)
void SAPI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -57,7 +55,7 @@ void _KERNEL_ABI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr,
return;
}
void _KERNEL_ABI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr)
void SAPI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -73,7 +71,7 @@ void _KERNEL_ABI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr
return;
}
void _KERNEL_ABI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit,
void SAPI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit,
uint64_t const attr)
{
if (gdt == NULL)
@ -92,67 +90,18 @@ void _KERNEL_ABI hal_write_segment_descriptor(void *const gdt, uint32_t const ba
return;
}
void _KERNEL_ABI hal_create_initial_page_table(void *const base, uint64_t size)
void* SAPI hal_alloc(uint32_t size)
{
};
//uint64_t _KERNEL_ABI hal_map_page(void* const base, uint64_t const p_addr, uint64_t const v_addr, uint64_t const flags)
//{
// // assume the initial page table has already been allocated
//
// // check p_addr and v_addr 4k-aligned
// if(base == NULL || p_addr << 52 || v_addr << 52)
// return 1;
//
// uint64_t const pml4_index = (v_addr >> 39) & 0x1FF;
// uint64_t const pdpt_index = (v_addr >> 30) & 0x1FF;
// uint64_t const pd_index = (v_addr >> 21) & 0x1FF;
// uint64_t const pt_index = (v_addr >> 12) & 0x1FF;
//
// void * const pml4_entry_addr = (void*)((uint64_t*) base + pml4_index);
// if(!(*(uint64_t*)pml4_entry_addr & PML4_PRESENT))
// {
// //PML4 does not exist
// return 1;
// }
// uint64_t const pml4_entry = *(uint64_t*)pml4_entry_addr;
//
// void * const pdpt_entry_addr = (void*)((uint64_t*) PAGE_ENTRY_BASE(pml4_entry) + pdpt_index);
// if(!(*(uint64_t*) pdpt_entry_addr & PDPT_PRESENT))
// {
// //PDPT does not exist
// return 1;
// }
//
// uint64_t const pdpt_entry = *(uint64_t*)pdpt_entry_addr;
//
// void * const pd_entry_addr = (void*)((uint64_t*) PAGE_ENTRY_BASE(pdpt_entry) + pd_index);
// if(!(*(uint64_t*) pd_entry_addr & PD_PRESENT))
// {
// write_pd_entry(pd_entry_addr, (uint64_t)((uint64_t*)pt_base + pml4_index * 512 * 512 * 512 + pdpt_index * 512 * 512 + pd_index*512), PD_PRESENT | PD_WRITE);
// }
// uint64_t const pd_entry = *(uint64_t*)pd_entry_addr;
//
// void * const pt_entry_addr = (void*)((uint64_t*) PAGE_ENTRY_BASE(pd_entry) + pt_index);
// hal_write_pt_entry(pt_entry_addr, p_addr, flags);
// return 0;
//}
void* _KERNEL_ABI hal_halloc(_IN size_t const size)
{
if (_cur_heap == NULL)
_cur_heap = kernel_heap;
if (_cur_heap + size < kernel_heap + KERNEL_HEAP_SIZE)
{
_cur_heap = _cur_heap + size;
return _cur_heap - size;
}
return NULL;
return salloc(kernel_heap,size);
}
void _KERNEL_ABI hal_hfree(_IN void *ptr)
void SAPI hal_free(void *ptr)
{
return sfree(kernel_heap, ptr);
}
void SAPI hal_alloc_init()
{
salloc_init(kernel_heap, KERNEL_HEAP_SIZE);
return;
}

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

@ -3,7 +3,7 @@
#include "../common/sys/kdef.h"
#include "../common/sys/type.h"
#include "../common/util/list/linked_list/linked_list.h"
#include "../common/lib/list/linked_list/linked_list.h"
#define PML4_PRESENT (1ull << 0)
#define PML4_WRITE (1ull << 1)
@ -86,30 +86,32 @@ typedef struct __attribute__((packed))
uint64_t edx;
} cpuid_t;
void* _KERNEL_ABI hal_halloc(_IN size_t const size);
void* SAPI hal_alloc(uint32_t size);
void _KERNEL_ABI hal_hfree(_IN void *ptr);
void SAPI hal_free(void *ptr);
extern void _KERNEL_ABI hal_flush_gdt(gdt_ptr_t *gdt_ptr, uint64_t code_slct, uint64_t data_slct);
void SAPI hal_alloc_init();
extern void _KERNEL_ABI hal_flush_tlb();
extern void SAPI hal_flush_gdt(gdt_ptr_t *gdt_ptr, uint64_t code_slct, uint64_t data_slct);
extern void _KERNEL_ABI hal_cpuid(uint64_t * eax, uint64_t * ebx, uint64_t* ecx, uint64_t* edx);
extern void SAPI hal_flush_tlb();
extern void _KERNEL_ABI hal_flush_idt(idt_ptr_t* idt_ptr);
extern void SAPI hal_cpuid(uint64_t * eax, uint64_t * ebx, uint64_t* ecx, uint64_t* edx);
extern void _KERNEL_ABI hal_write_page_base(void* base);
extern void SAPI hal_flush_idt(idt_ptr_t* idt_ptr);
extern void*_KERNEL_ABI hal_read_page_base();
extern void SAPI hal_write_page_base(void* base);
void _KERNEL_ABI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit, uint64_t const attr);
extern void*SAPI hal_read_page_base();
void _KERNEL_ABI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr);
void SAPI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit, uint64_t const attr);
void _KERNEL_ABI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr);
void SAPI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr);
void _KERNEL_ABI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr);
void SAPI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr);
void _KERNEL_ABI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr);
void SAPI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr);
void SAPI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr);
#endif

18
x64/src/c/hal/print.c
View File

@ -1,16 +1,16 @@
#include "../common/sys/kdef.h"
#include "../common/sys/type.h"
#include "../common/lib/mem.h"
#include "../common/lib/std/mem.h"
#include "print.h"
#include "var.h"
#include "var.h"
void _KERNEL_ABI _hal_print_scroll()
void SAPI _hal_print_scroll()
{
mem_move((void *) (0xb8000 + get_pos(1, 0) * 2), (void *) (0xb8000 + get_pos(0, 0) * 2), (80 * 24) * 2);
return;
}
void _KERNEL_ABI _hal_print_str(char const *str)
void SAPI _hal_print_str(char const *str)
{
if(str == NULL)
return;
@ -45,7 +45,7 @@ void _KERNEL_ABI _hal_print_str(char const *str)
return;
}
void _KERNEL_ABI _hal_print_uint(uint64_t number)
void SAPI _hal_print_uint(uint64_t number)
{
char arr[21]; // do not need to initialize
arr[20] = 0; //zero-terminated
@ -64,7 +64,7 @@ void _KERNEL_ABI _hal_print_uint(uint64_t number)
return;
}
void _KERNEL_ABI _hal_print_int(int64_t number)
void SAPI _hal_print_int(int64_t number)
{
char arr[21]; // do not need to initialize
arr[20] = 0; //zero-terminated
@ -93,7 +93,7 @@ void _KERNEL_ABI _hal_print_int(int64_t number)
return;
}
void _KERNEL_ABI _hal_print_hex(uint64_t number, uint64_t capital)
void SAPI _hal_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'};
@ -115,14 +115,14 @@ void _KERNEL_ABI _hal_print_hex(uint64_t number, uint64_t capital)
return;
}
void _KERNEL_ABI hal_clear_screen(void)
void SAPI hal_clear_screen(void)
{
text_pos = 0; // reset text_pos
mem_set((void *) 0xb8000, 0, 25 * 80 * 2);
return;
}
void _KERNEL_ABI hal_printf(char const *format, ...)
void SAPI hal_printf(char const *format, ...)
{
va_list args;
va_start(args, format);

4
x64/src/c/hal/print.h
View File

@ -7,7 +7,7 @@
#define get_row(pos) (pos / 80)
#define get_pos(row,col) ((row) * 80 + (col))
void _KERNEL_ABI hal_clear_screen(void);
void _KERNEL_ABI hal_printf(char const *format, ...);
void SAPI hal_clear_screen(void);
void SAPI hal_printf(char const *format, ...);
#endif

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

@ -2,7 +2,7 @@
#define _VAR_H_
#include "mem.h"
#include "../common/util/list/linked_list/linked_list.h"
#include "../common/lib/list/linked_list/linked_list.h"
extern uint8_t g_gdt[8*9];
extern uint8_t g_idt[21*16];

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

@ -2,12 +2,9 @@
#include "../hal/hal.h"
#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"
void _KERNEL_ABI kmain(multiboot_info_t *multiboot_info)
void SAPI kmain(multiboot_info_t *multiboot_info)
{
boot_info_t* boot_info = hal_init(multiboot_info);

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

@ -1,8 +1,6 @@
#include "pmm.h"
#include "../common/sys/sys_info.h"
#include "../hal/io.h"
#include "../common/util/list/linked_list/linked_list.h"
#include "../common/util/util.h"
linked_list_t* occupied_mem;
linked_list_t* available_mem;

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

@ -1,7 +1,7 @@
#ifndef _PMM_H_
#define _PMM_H_
#include "../common/util/list/linked_list/linked_list.h"
#include "../common/lib/list/linked_list/linked_list.h"
void pmm_init(linked_list_t* occupied, linked_list_t* available);