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

Compiled but does not link

This commit is contained in:
Oscar 2017-01-31 19:26:08 -08:00
parent 97fe8bbe9e
commit 53195f144d
71 changed files with 1677 additions and 1635 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
x64/build/linker.ld
View File

@ -1,28 +1,39 @@
SECTIONS
{
. = 0x1000000;
. = 0xFFFFFFFF80000000;
kernel_start = .;
.entry : ALIGN(0x1000)
.entry ALIGN(0x1000) : AT(ADDR(.entry) - 0xFFFFFFFF80000000)
{
*(.entry)
}
.text : ALIGN(0x1000)
.text ALIGN(0x1000) : AT(ADDR(.text) - 0xFFFFFFFF80000000)
{
*(.text)
}
.data : ALIGN(0x1000)
.data ALIGN(0x1000) : AT(ADDR(.data) - 0xFFFFFFFF80000000)
{
*(.data)
*(.rodata)
}
.bss : ALIGN(0x1000)
.bss ALIGN(0x1000) : AT(ADDR(.bss) - 0xFFFFFFFF80000000)
{
*(.bss)
}
.heap ALIGN(0x1000) : AT(ADDR(.heap) - 0xFFFFFFFF80000000)
{
*(.heap)
}
.stack ALIGN(0x1000) : AT(ADDR(.stack) - 0xFFFFFFFF80000000)
{
*(.stack)
}
kernel_end = .;
}

4
x64/makefile
View File

@ -15,9 +15,9 @@ TEMP_DIR := tmp
HEADER_DIRS := $(call rdircardex, *,*.h)
ALL_TEMP_DIRS := $(addprefix $(TEMP_DIR)/,$(call rdircard,*))
C_FLAGS := -m64 -std=c11 -g -c $(addprefix -I, $(HEADER_DIRS)) -fno-stack-protector -fno-builtin -mno-red-zone -mno-mmx -mno-sse -mno-sse2 -masm=intel -Wall -Wextra -Wno-comment
C_FLAGS := -m64 -std=c11 -g -c $(addprefix -I, $(HEADER_DIRS)) -mcmodel=kernel -fno-stack-protector -fno-builtin -mno-red-zone -mno-mmx -mno-sse -mno-sse2 -masm=intel -Wall -Werror -Wextra -Wno-comment
ASM_FLAGS := -g -f elf64 -I $(ASM_SRC_PATH_64)/
LD_FLAGS := -melf_x86_64
LD_FLAGS := -melf_x86_64 -I
C_SRC := $(call rwildcard, ./, *.c)
ASM_SRC := $(call rwildcard, ./, *.asm)

2
x64/src/common/inc/global/g_abi.h
View File

@ -6,7 +6,7 @@
#ifndef _G_ABI_H_
#define _G_ABI_H_
#define KAPI __attribute__((sysv_abi))
#define KABI __attribute__((sysv_abi))
#define UAPI __attribute__((sysv_abi))
#endif

6
x64/src/common/inc/global/g_type.h
View File

@ -11,10 +11,12 @@
#include <stdarg.h>
#include <stddef.h>
typedef int32_t (*k_callback_func_t)(void *kernel_args, void *user_args);
typedef int32_t (*callback_func_t)(void *kernel_args, void *user_args);
typedef uint32_t k_handle_t;
typedef uint32_t handle_t;
#define STRUCT_PACKED __attribute__((packed))
#define UNREFERENCED(x) {(x) = (x);}
#endif

6
x64/src/common/inc/kernel/s_atomic.h
View File

@ -3,10 +3,10 @@
#include "g_abi.h"
#include "g_type.h"
extern int32_t KAPI ke_interlocked_exchange_32(int32_t *target, int32_t val);
extern int32_t KABI ke_interlocked_exchange_32(int32_t *target, int32_t val);
extern int32_t KAPI ke_interlocked_increment_32(int32_t *target, int32_t increment);
extern int32_t KABI ke_interlocked_increment_32(int32_t *target, int32_t increment);
extern int32_t KAPI ke_interlocked_compare_exchange_32(int32_t *target, int32_t compare, int32_t val);
extern int32_t KABI ke_interlocked_compare_exchange_32(int32_t *target, int32_t compare, int32_t val);
#endif

8
x64/src/common/inc/kernel/s_boot.h
View File

@ -12,11 +12,11 @@ typedef struct
{
uint64_t krnl_start;
uint64_t krnl_end;
k_hal_intr_info_t intr_info;
k_pmm_info_t* pmm_info;
intr_info_t intr_info;
pmm_info_t* pmm_info;
char cpu_vd_str[13];
} k_hal_boot_info_t;
} boot_info_t;
extern void KAPI ke_main(k_hal_boot_info_t *info);
extern void KABI ke_main(boot_info_t *info);
#endif

10
x64/src/common/inc/kernel/s_context.h
View File

@ -8,13 +8,13 @@
// This function should never return and directly context switches to the target
// on x86, it should save the context, switch stack, build exc frame and iret
// This function always assumes interrupt context
extern void KAPI ke_context_switch(void *intr_stack,
extern void KABI ke_context_switch(void *intr_stack,
void *cur_context, void *next_context,
k_physical_addr_t old_addr_space,
k_physical_addr_t next_addr_space);
physical_addr_t old_addr_space,
physical_addr_t next_addr_space);
extern void KAPI ke_create_context(void *context, void *pc, void *sp, void *ksp, k_irql_t irql, void *arg);
extern void KABI ke_create_context(void *context, void *pc, void *sp, void *ksp, irql_t irql, void *arg);
extern void KAPI ke_destroy_context(void *context);
extern void KABI ke_destroy_context(void *context);
#endif

30
x64/src/common/inc/kernel/s_intr.h
View File

@ -9,7 +9,7 @@ typedef struct
uint32_t timer_intr_vec;
uint32_t apc_intr_vec;
uint32_t dpc_intr_vec;
} k_hal_intr_info_t;
} intr_info_t;
typedef enum
{
@ -20,41 +20,41 @@ typedef enum
page_fault_exc,
unsupported_exc,
debug_exc
} k_exc_type_t;
} exc_type_t;
// IRQL APIs
typedef uint32_t k_irql_t;
typedef uint32_t irql_t;
#define K_IRQL_DISABLED_LEVEL 15
#define K_IRQL_DPC_LEVEL 4
#define K_IRQL_APC_LEVEL 2
#define K_IRQL_PASSIVE_LEVEL 0
extern k_irql_t KAPI ke_set_irql(k_irql_t irql);
extern irql_t KABI ke_set_irql(irql_t irql);
extern k_irql_t KAPI ke_get_irql();
extern irql_t KABI ke_get_irql();
extern void KAPI ke_halt_cpu();
extern void KABI ke_halt_cpu();
extern void KAPI ke_set_timer_timeout(uint64_t timeout);
extern void KABI ke_set_timer_timeout(uint64_t timeout);
extern int32_t KAPI ke_get_core_id();
extern int32_t KABI ke_get_core_id();
extern int32_t KAPI ke_issue_interrupt(int32_t core_id, uint32_t vector);
extern int32_t KABI ke_issue_interrupt(int32_t core_id, uint32_t vector);
// Interrupt handler registration
// context is a parameter passed by the kernel. HAL must pass back.
// intr_stack is a parameter passed by the HAL. Used by some HAL interrupt context functions.
typedef void ( KAPI *k_intr_handler_t)(void *context, void *intr_stack);
typedef void ( KABI *k_intr_handler_t)(void *context, void *intr_stack);
extern void KAPI ke_register_intr_handler(uint32_t index, k_intr_handler_t handler, void *context);
extern void KABI ke_register_intr_handler(uint32_t index, k_intr_handler_t handler, void *context);
extern k_intr_handler_t KAPI ke_deregister_intr_handler(uint32_t index);
extern k_intr_handler_t KABI ke_deregister_intr_handler(uint32_t index);
// Exception handler registration
typedef void ( KAPI *k_exc_handler_t)(uint64_t exc_addr, uint64_t exc_stack, uint64_t error_code);
typedef void ( KABI *k_exc_handler_t)(uint64_t exc_addr, uint64_t exc_stack, uint64_t error_code);
extern void KAPI ke_register_exc_handler(k_exc_type_t type, k_exc_handler_t handler);
extern void KABI ke_register_exc_handler(exc_type_t type, k_exc_handler_t handler);
extern k_exc_handler_t KAPI ke_deregister_exc_handler(uint64_t index);
extern k_exc_handler_t KABI ke_deregister_exc_handler(uint64_t index);
#endif

12
x64/src/common/inc/kernel/s_pmm.h
View File

@ -3,11 +3,11 @@
#include "g_abi.h"
#include "g_type.h"
#include "k_linked_list.h"
#include "linked_list.h"
#define K_PAGE_SIZE 4096
typedef uint64_t k_physical_addr_t;
typedef uint64_t physical_addr_t;
// note that these bases must be K_PAGE_SIZE aligned
// the size is the # of pages
@ -16,15 +16,15 @@ typedef uint64_t k_physical_addr_t;
typedef struct
{
k_physical_addr_t base;
physical_addr_t base;
uint64_t size;
uint32_t attr;
} k_pmm_node_t;
} pmm_node_t;
typedef struct
{
uint32_t num_of_nodes;
k_pmm_node_t nodes[];
} k_pmm_info_t;
pmm_node_t nodes[];
} pmm_info_t;
#endif

2
x64/src/common/inc/kernel/s_print.h
View File

@ -4,6 +4,6 @@
#include "g_abi.h"
#include "g_type.h"
extern void KAPI ke_printf(const char*, ...);
extern void KABI ke_printf(const char*, ...);
#endif

30
x64/src/common/inc/kernel/s_vmm.h
View File

@ -5,8 +5,8 @@
#include "g_type.h"
#include "s_pmm.h"
typedef uint64_t k_virtual_addr_t;
typedef k_physical_addr_t k_address_space_t;
typedef uint64_t virtual_addr_t;
typedef physical_addr_t address_space_t;
#define K_BASE_VADDR 0xFFFF800000000000
#define K_END_VADDR 0xFFFFFFFFFFFFFFFF
@ -20,9 +20,9 @@ typedef k_physical_addr_t k_address_space_t;
// which means the kernel area/ as well as the HAL reserved vaddr ranges would be properly mapped
//
typedef k_physical_addr_t (KAPI *k_physical_page_alloc)();
typedef physical_addr_t (KABI *page_alloc_func_t)();
typedef void (KAPI *k_physical_page_free)(k_physical_addr_t page);
typedef void (KABI *page_free_func_t)(physical_addr_t page);
#define K_PAGE_ATTR_KERNEL (1 << 2)
#define K_PAGE_ATTR_CACHED (1 << 3)
@ -30,18 +30,18 @@ typedef void (KAPI *k_physical_page_free)(k_physical_addr_t page);
#define K_PAGE_ATTR_WRITABLE (1 << 1)
// this function should map the v_addr to p_addr for the target address space
extern void KAPI ke_map_virtual_addr(k_physical_addr_t addr_space,
k_virtual_addr_t v_addr,
k_physical_addr_t p_addr,
extern void KABI ke_map_virtual_addr(physical_addr_t addr_space,
virtual_addr_t v_addr,
physical_addr_t p_addr,
uint64_t attribute,
k_physical_page_alloc alloc);
page_alloc_func_t alloc);
typedef struct
{
// the kernel always reserves this much virtual space for HAL
// this is mainly used for recursive page tables or other HAL actions
k_virtual_addr_t reserved_vaddr_base;
k_virtual_addr_t reserved_vaddr_end;
virtual_addr_t reserved_vaddr_base;
virtual_addr_t reserved_vaddr_end;
// the k_vaddr_alignment determines the alignment of the kernel's address space
// the reserved virtual address spaces above is also subject to the alignment
@ -53,16 +53,16 @@ typedef struct
// so that these pages are global (modifying the mapping in this area affects everyone)
// the K_BASE_VADDR to K_END_VADDR includes the reserved virtual addr space by the HAL
// if HAL's reserved virtual addr will be mapped to different physical pages, the HAL should make the change
k_address_space_t KAPI ke_create_address_space(k_address_space_t address_space,
k_physical_page_alloc alloc);
address_space_t KABI ke_create_address_space(address_space_t address_space,
page_alloc_func_t alloc);
// this function destroys the target address space without destroying the K_BASE_VADDR to K_END_VADDR
// target_addr_space is guaranteed to be not the same as the current address space
// when the function returns, the current address space must stay unchanged
void KAPI ke_destroy_address_space(k_address_space_t address_space,
k_physical_page_free free);
void KABI ke_destroy_address_space(address_space_t address_space,
page_free_func_t free);
// as the name implies
void KAPI ke_switch_address_space(k_address_space_t target_addr_space);
void KABI ke_switch_address_space(address_space_t target_addr_space);
#endif

20
x64/src/hal/hal_entry.asm
View File

@ -90,14 +90,14 @@ GDT64: ; Global Descriptor Table (64-bit).
db 0 ; Access.
db 0 ; Granularity.
db 0 ; Base (high).
SLCT_CODE equ $ - GDT64 ; The code descriptor.
SLCT_CODE equ $ - GDT64 ; The code descriptor.
dw 0 ; Limit (low).
dw 0 ; Base (low).
db 0 ; Base (middle)
db 10011010b ; Access.
db 00100000b ; Granularity.
db 0 ; Base (high).
SLCT_DATA equ $ - GDT64 ; The data descriptor.
SLCT_DATA equ $ - GDT64 ; The data descriptor.
dw 0 ; Limit (low).
dw 0 ; Base (low).
db 0 ; Base (middle)
@ -127,7 +127,7 @@ mov esp, KERNEL_STACK
mov esi,ebx
; check x64 support
call ensure_support_x64
call _ensure_support_x64
cmp eax,1
je .init_x64
hlt
@ -186,7 +186,7 @@ lgdt [GDT64.GDT64_PTR]
jmp SLCT_CODE:entry
hlt
ensure_support_x64:
_ensure_support_x64:
push ebp
mov ebp,esp
pushfd
@ -235,6 +235,16 @@ mov rdi,rsi ; multiboot_info*
call hal_main
hlt
KERNEL_HEAP_SIZE equ 8192
KERNEL_STACK_SIZE equ 8192
[SECTION .heap]
[BITS 64]
align 4096 ;4k alignment
times 8192 db 0
times KERNEL_HEAP_SIZE db 0 ; initially 8k heap
[SECTION .stack]
[BITS 64]
align 4096 ;4k alignment
times KERNEL_STACK_SIZE db 0 ; initially 8k stack
KERNEL_STACK:

16
x64/src/hal/hal_init.c
View File

@ -7,27 +7,27 @@
#include "hal_mem.h"
#include "hal_intr.h"
#include "hal_arch.h"
#include "k_stdlib.h"
#include "../lib/inc/sxtdlib.h"
#include "s_boot.h"
extern char kernel_start[];
extern char kernel_end[];
static void KAPI _hal_obtain_cpu_info(k_hal_boot_info_t *hal_info)
static void KABI _hal_obtain_cpu_info(boot_info_t *hal_info)
{
if(hal_info == NULL)
return;
uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
hal_cpuid(&eax,&ebx,&ecx,&edx);
ke_mem_copy(&ebx, &hal_info->cpu_vd_str[0], sizeof(uint32_t));
ke_mem_copy(&edx, &hal_info->cpu_vd_str[4], sizeof(uint32_t));
ke_mem_copy(&ecx, &hal_info->cpu_vd_str[8], sizeof(uint32_t));
lb_mem_copy(&ebx, &hal_info->cpu_vd_str[0], sizeof(uint32_t));
lb_mem_copy(&edx, &hal_info->cpu_vd_str[4], sizeof(uint32_t));
lb_mem_copy(&ecx, &hal_info->cpu_vd_str[8], sizeof(uint32_t));
hal_info->cpu_vd_str[12] = 0;
}
void KAPI hal_main(void *m_info)
void KABI hal_main(void *m_info)
{
if (m_info == NULL || (uint64_t) m_info & ke_bit_field_mask(0, 2))
if (m_info == NULL || (uint64_t) m_info & lb_bit_field_mask(0, 2))
return;
// init HAL infrastructures
@ -35,7 +35,7 @@ void KAPI hal_main(void *m_info)
hal_mem_init();
k_hal_boot_info_t* boot_info = halloc(sizeof(k_hal_boot_info_t));
boot_info_t* boot_info = halloc(sizeof(boot_info_t));
// set up HAL def
boot_info->krnl_start = (uint64_t)kernel_start;

39
x64/src/hal/hal_intr.c
View File

@ -7,6 +7,7 @@
#include "hal_intr.h"
#include "hal_print.h"
#include "hal_mem.h"
#include "sxtdlib.h"
static uint8_t _idts[HAL_CORE_COUNT][IDT_ENTRY_NUM*IDT_ENTRY_SIZE];
hal_idt_ptr_t _idt_ptrs[HAL_CORE_COUNT];
@ -15,7 +16,7 @@ static void* _intr_handler_context_table[HAL_CORE_COUNT][IDT_ENTRY_NUM];
static k_exc_handler_t _exc_handler_table[HAL_CORE_COUNT][IDT_ENTRY_NUM];
void KAPI hal_write_gate(void *const gate,
void KABI hal_write_gate(void *const gate,
uint64_t const offset,
uint32_t const selector,
uint32_t const attr)
@ -39,7 +40,7 @@ void KAPI hal_write_gate(void *const gate,
return;
}
void KAPI hal_set_interrupt_handler(uint64_t index,
void KABI hal_set_interrupt_handler(uint64_t index,
void (*handler)(void))
{
if (index < IDT_ENTRY_NUM)
@ -50,12 +51,15 @@ void KAPI hal_set_interrupt_handler(uint64_t index,
return;
}
void KAPI hal_issue_interrupt(uint32_t target_core, uint32_t vector)
void KABI hal_issue_interrupt(uint32_t target_core, uint32_t vector)
{
// TODO
UNREFERENCED(target_core);
UNREFERENCED(vector);
return;
}
void KAPI hal_register_interrupt_handler(uint32_t coreid, uint32_t index, k_intr_handler_t handler, void* context)
void KABI hal_register_interrupt_handler(uint32_t coreid, uint32_t index, k_intr_handler_t handler, void* context)
{
if (index < IDT_ENTRY_NUM && coreid < HAL_CORE_COUNT)
{
@ -65,7 +69,7 @@ void KAPI hal_register_interrupt_handler(uint32_t coreid, uint32_t index, k_intr
return;
}
void KAPI hal_deregister_interrupt_handler(uint32_t coreid, uint32_t index)
void KABI hal_deregister_interrupt_handler(uint32_t coreid, uint32_t index)
{
if (index < IDT_ENTRY_NUM && coreid < HAL_CORE_COUNT)
{
@ -74,7 +78,7 @@ void KAPI hal_deregister_interrupt_handler(uint32_t coreid, uint32_t index)
return;
}
void KAPI hal_register_exception_handler(uint32_t coreid, uint32_t index, k_exc_handler_t handler)
void KABI hal_register_exception_handler(uint32_t coreid, uint32_t index, k_exc_handler_t handler)
{
if (index < IDT_ENTRY_NUM && coreid < HAL_CORE_COUNT)
{
@ -83,7 +87,7 @@ void KAPI hal_register_exception_handler(uint32_t coreid, uint32_t index, k_exc_
return;
}
void KAPI hal_deregister_exception_handler(uint32_t coreid, uint32_t index)
void KABI hal_deregister_exception_handler(uint32_t coreid, uint32_t index)
{
if (index < IDT_ENTRY_NUM && coreid < HAL_CORE_COUNT)
{
@ -92,7 +96,7 @@ void KAPI hal_deregister_exception_handler(uint32_t coreid, uint32_t index)
return;
}
void KAPI hal_assert(int64_t expression,
void KABI hal_assert(int64_t expression,
char *message)
{
if (!expression)
@ -103,7 +107,7 @@ void KAPI hal_assert(int64_t expression,
return;
}
void KAPI hal_interrupt_dispatcher(uint64_t int_vec, hal_intr_context_t *context)
void KABI hal_interrupt_dispatcher(uint64_t int_vec, hal_intr_context_t *context)
{
uint32_t coreid = hal_get_core_id();
if (_intr_handler_table[int_vec] == NULL)
@ -117,7 +121,7 @@ void KAPI hal_interrupt_dispatcher(uint64_t int_vec, hal_intr_context_t *context
return;
}
void KAPI hal_exception_dispatcher(uint64_t exc_vec, hal_intr_context_t* context, uint64_t errorcode)
void KABI hal_exception_dispatcher(uint64_t exc_vec, hal_intr_context_t* context, uint64_t errorcode)
{
uint32_t coreid = hal_get_core_id();
if (_exc_handler_table[exc_vec] == NULL)
@ -131,7 +135,7 @@ void KAPI hal_exception_dispatcher(uint64_t exc_vec, hal_intr_context_t* context
return;
}
static void KAPI _hal_populate_idt()
static void KABI _hal_populate_idt()
{
hal_set_interrupt_handler(0, hal_interrupt_handler_0);
hal_set_interrupt_handler(1, hal_interrupt_handler_1);
@ -392,18 +396,18 @@ static void KAPI _hal_populate_idt()
return;
}
uint32_t KAPI hal_get_core_id(void)
uint32_t KABI hal_get_core_id(void)
{
return 0;
}
int32_t KAPI hal_interrupt_init(void)
int32_t KABI hal_interrupt_init(void)
{
uint32_t coreid = hal_get_core_id();
uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
eax = 1;
hal_cpuid(&eax, &ebx, &ecx, &edx);
if (!(edx & ke_bit_mask(9)))
if (!(edx & lb_bit_mask(9)))
{
hal_printf("ERROR: APIC not supported by CPU.\n");
return 1;
@ -435,19 +439,18 @@ int32_t KAPI hal_interrupt_init(void)
ecx = MSR_IA32_APIC_BASE;
hal_read_msr(&ecx, &edx, &eax);
apic_base_reg = ((uint64_t) edx << 32) + (uint64_t) eax;
apic_base = apic_base_reg & ke_bit_field_mask(12, 35);
apic_base = apic_base_reg & lb_bit_field_mask(12, 35);
//hal_printf("APIC Base: 0x%X\n", apic_base);
//hal_printf("APIC Enabled: %s\n", apic_base_reg & bit_mask_64(11) ? "Yes" : "No");
//hal_printf("BSP: %s\n", apic_base_reg & bit_mask_64(8) ? "Yes" : "No");
//hal_printf("APIC Spour: 0x%X\n", *(uint32_t *) ((char *) apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET));
// hardware enable APIC
ecx = MSR_IA32_APIC_BASE;
eax = (uint32_t) ((apic_base_reg & ke_bit_field_mask(0, 31)) | ke_bit_mask(11));
eax = (uint32_t) ((apic_base_reg & lb_bit_field_mask(0, 31)) | lb_bit_mask(11));
hal_write_msr(&ecx, &edx, &eax);
// software enable APIC
hal_write_mem_32((char *) apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET,
*(uint32_t *) ((char *) apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET) | ke_bit_mask(8));
hal_write_mem_32((char *) apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET, *(uint32_t *) (apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET) | (uint32_t)lb_bit_mask(8));
// hal_issue_interrupt(1, 255);
// hal_enable_interrupt();

20
x64/src/hal/hal_k_impl.c
View File

@ -5,39 +5,39 @@
#include "s_context.h"
#include "s_intr.h"
int32_t KAPI ke_interlocked_increment_32(int32_t *target, int32_t increment)
int32_t KABI ke_interlocked_increment_32(int32_t *target, int32_t increment)
{
return hal_interlocked_increment_32(target, increment);
}
int32_t KAPI ke_interlocked_compare_exchange_32(int32_t *target, int32_t compare, int32_t val)
int32_t KABI ke_interlocked_compare_exchange_32(int32_t *target, int32_t compare, int32_t val)
{
return hal_interlocked_compare_exchange_32(target, compare, val);
}
int32_t KAPI ke_interlocked_exchange_32(int32_t *target, int32_t val)
int32_t KABI ke_interlocked_exchange_32(int32_t *target, int32_t val)
{
return hal_interlocked_exchange_32(target, val);
}
k_irql_t KAPI ke_set_irql(k_irql_t irql)
irql_t KABI ke_set_irql(irql_t irql)
{
k_irql_t old_irql = (k_irql_t)hal_read_cr8();
hal_write_cr8((k_irql_t)irql);
irql_t old_irql = (irql_t)hal_read_cr8();
hal_write_cr8((irql_t)irql);
return old_irql;
}
k_irql_t KAPI ke_get_irql()
irql_t KABI ke_get_irql()
{
return (k_irql_t)hal_read_cr8();
return (irql_t)hal_read_cr8();
}
void KAPI ke_halt_cpu()
void KABI ke_halt_cpu()
{
hal_halt_cpu();
}
int32_t KAPI ke_get_core_id()
int32_t KABI ke_get_core_id()
{
return hal_get_core_id();
}

26
x64/src/hal/hal_mem.c
View File

@ -6,7 +6,7 @@
#include "g_abi.h"
#include "g_type.h"
#include "hal_mem.h"
#include "k_salloc.h"
#include "../lib/inc/salloc.h"
#include "hal_arch.h"
#include "hal_intr.h"
@ -17,7 +17,7 @@ static hal_gdt_ptr_t _gdt_ptrs[HAL_CORE_COUNT];
char kernel_heap[KERNEL_HEAP_SIZE];
void KAPI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr)
void KABI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -33,7 +33,7 @@ void KAPI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t c
return;
}
void KAPI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr)
void KABI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -49,7 +49,7 @@ void KAPI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t
return;
}
void KAPI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr)
void KABI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -65,7 +65,7 @@ void KAPI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_
return;
}
void KAPI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr)
void KABI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr)
{
if (base == NULL)
return;
@ -81,7 +81,7 @@ void KAPI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint6
return;
}
void KAPI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit,
void KABI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit,
uint64_t const attr)
{
if (gdt == NULL)
@ -100,18 +100,18 @@ void KAPI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uin
return;
}
void *KAPI halloc(uint32_t size)
void *KABI halloc(uint32_t size)
{
return ke_salloc(kernel_heap, size);
return lb_salloc(kernel_heap, size);
}
void KAPI hfree(void *ptr)
void KABI hfree(void *ptr)
{
ke_sfree(kernel_heap, ptr);
lb_sfree(kernel_heap, ptr);
return;
}
static void KAPI _hal_init_gdt()
static void KABI _hal_init_gdt()
{
uint32_t coreid = hal_get_core_id();
// get gdt ready
@ -142,9 +142,9 @@ static void KAPI _hal_init_gdt()
hal_flush_gdt(&_gdt_ptrs[coreid], seg_selector(1, 0), seg_selector(2, 0));
};
void KAPI hal_mem_init()
void KABI hal_mem_init()
{
_hal_init_gdt();
ke_salloc_init(kernel_heap, KERNEL_HEAP_SIZE);
lb_salloc_init(kernel_heap, KERNEL_HEAP_SIZE);
return;
}

24
x64/src/hal/hal_print.c
View File

@ -4,23 +4,23 @@
*/
#include "g_abi.h"
#include "k_stdlib.h"
#include "../lib/inc/sxtdlib.h"
#include "hal_print.h"
static uint64_t text_pos;
void KAPI hal_print_init()
void KABI hal_print_init()
{
text_pos = 0;
}
void KAPI _hal_print_scroll()
void KABI _hal_print_scroll()
{
ke_mem_move((void *) (0xb8000 + get_pos(1, 0) * 2), (void *) (0xb8000 + get_pos(0, 0) * 2), (80 * 24) * 2);
lb_mem_move((void *) (0xb8000 + get_pos(1, 0) * 2), (void *) (0xb8000 + get_pos(0, 0) * 2), (80 * 24) * 2);
return;
}
void KAPI _hal_print_str(char const *str)
void KABI _hal_print_str(char const *str)
{
if(str == NULL)
return;
@ -33,7 +33,7 @@ void KAPI _hal_print_str(char const *str)
{
//can't hold
_hal_print_scroll();
ke_mem_set((void *) (0xb8000 + 80 * 24 * 2), 0, 80 * 2); // clear last row
lb_mem_set((void *) (0xb8000 + 80 * 24 * 2), 0, 80 * 2); // clear last row
text_pos = 80 * 24;
}
str++;
@ -55,7 +55,7 @@ void KAPI _hal_print_str(char const *str)
return;
}
void KAPI _hal_print_uint(uint64_t number)
void KABI _hal_print_uint(uint64_t number)
{
char arr[21]; // do not need to initialize
arr[20] = 0; //zero-terminated
@ -74,7 +74,7 @@ void KAPI _hal_print_uint(uint64_t number)
return;
}
void KAPI _hal_print_int(int64_t number)
void KABI _hal_print_int(int64_t number)
{
char arr[21]; // do not need to initialize
arr[20] = 0; //zero-terminated
@ -103,7 +103,7 @@ void KAPI _hal_print_int(int64_t number)
return;
}
void KAPI _hal_print_hex(uint64_t number, uint64_t capital)
void KABI _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'};
@ -125,14 +125,14 @@ void KAPI _hal_print_hex(uint64_t number, uint64_t capital)
return;
}
void KAPI hal_clear_screen(void)
void KABI hal_clear_screen(void)
{
text_pos = 0; // reset text_pos
ke_mem_set((void *) 0xb8000, 0, 25 * 80 * 2);
lb_mem_set((void *) 0xb8000, 0, 25 * 80 * 2);
return;
}
void KAPI hal_printf(char const *format, ...)
void KABI hal_printf(char const *format, ...)
{
va_list args;
va_start(args, format);

51
x64/src/hal/inc/hal_arch.h
View File

@ -16,58 +16,57 @@ typedef struct
{
uint16_t limit;
uint64_t base;
} STRUCT_PACKED hal_idt_ptr_t;
extern int32_t KAPI hal_interlocked_increment_32(int32_t *target, int32_t increment);
extern int32_t KABI hal_interlocked_increment_32(int32_t *target, int32_t increment);
extern int32_t KAPI hal_interlocked_compare_exchange_32(int32_t *dst, int32_t compare, int32_t val);
extern int32_t KABI hal_interlocked_compare_exchange_32(int32_t *dst, int32_t compare, int32_t val);
extern int32_t KAPI hal_interlocked_exchange_32(int32_t *target, int32_t val);
extern int32_t KABI hal_interlocked_exchange_32(int32_t *target, int32_t val);
extern void KAPI hal_cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
extern void KABI hal_cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
#define MSR_IA32_APIC_BASE 0x1B
extern void KAPI hal_read_msr(uint32_t *ecx, uint32_t *edx, uint32_t *eax);
extern void KABI hal_read_msr(uint32_t *ecx, uint32_t *edx, uint32_t *eax);
extern void KAPI hal_write_msr(uint32_t *ecx, uint32_t *edx, uint32_t *eax);
extern void KABI hal_write_msr(uint32_t *ecx, uint32_t *edx, uint32_t *eax);
extern void KAPI hal_enable_interrupt();
extern void KABI hal_enable_interrupt();
extern void KAPI hal_disable_interrupt();
extern void KABI hal_disable_interrupt();
extern void KAPI hal_halt_cpu();
extern void KABI hal_halt_cpu();
extern int8_t KAPI hal_read_port_8(uint16_t port);
extern int8_t KABI hal_read_port_8(uint16_t port);
extern int16_t KAPI hal_read_port_16(uint16_t port);
extern int16_t KABI hal_read_port_16(uint16_t port);
extern int32_t KAPI hal_read_port_32(uint16_t port);
extern int32_t KABI hal_read_port_32(uint16_t port);
extern void KAPI hal_write_port_8(uint16_t port, uint8_t data);
extern void KABI hal_write_port_8(uint16_t port, uint8_t data);
extern void KAPI hal_write_port_16(uint16_t port, uint16_t data);
extern void KABI hal_write_port_16(uint16_t port, uint16_t data);
extern void KAPI hal_write_port_32(uint16_t port, uint32_t data);
extern void KABI hal_write_port_32(uint16_t port, uint32_t data);
extern void KAPI hal_write_mem_32(void* target, uint32_t data);
extern void KABI hal_write_mem_32(void* target, uint32_t data);
extern void KAPI hal_write_mem_64(void* target, uint64_t data);
extern void KABI hal_write_mem_64(void* target, uint64_t data);
extern void KAPI hal_flush_gdt(hal_gdt_ptr_t *gdt_ptr, uint64_t code_slct, uint64_t data_slct);
extern void KABI hal_flush_gdt(hal_gdt_ptr_t *gdt_ptr, uint64_t code_slct, uint64_t data_slct);
extern void KAPI hal_flush_tlb();
extern void KABI hal_flush_tlb();
extern void KAPI hal_flush_idt(hal_idt_ptr_t *idt_ptr);
extern void KABI hal_flush_idt(hal_idt_ptr_t *idt_ptr);
extern void KAPI hal_read_idt(hal_idt_ptr_t **idt_ptr);
extern void KABI hal_read_idt(hal_idt_ptr_t **idt_ptr);
extern void KAPI hal_write_cr3(uint64_t base);
extern void KABI hal_write_cr3(uint64_t base);
extern uint64_t KAPI hal_read_cr3();
extern uint64_t KABI hal_read_cr3();
extern void KAPI hal_write_cr8(uint64_t pri);
extern void KABI hal_write_cr8(uint64_t pri);
extern uint64_t KAPI hal_read_cr8();
extern uint64_t KABI hal_read_cr8();
#endif

532
x64/src/hal/inc/hal_intr.h
View File

@ -41,537 +41,537 @@ typedef struct
} hal_intr_context_t;
// SYSTEM INTERRUPT HANDLERS
extern void KAPI hal_interrupt_handler_0(void);
extern void KABI hal_interrupt_handler_0(void);
extern void KAPI hal_interrupt_handler_1(void);
extern void KABI hal_interrupt_handler_1(void);
extern void KAPI hal_interrupt_handler_2(void);
extern void KABI hal_interrupt_handler_2(void);
extern void KAPI hal_interrupt_handler_3(void);
extern void KABI hal_interrupt_handler_3(void);
extern void KAPI hal_interrupt_handler_4(void);
extern void KABI hal_interrupt_handler_4(void);
extern void KAPI hal_interrupt_handler_5(void);
extern void KABI hal_interrupt_handler_5(void);
extern void KAPI hal_interrupt_handler_6(void);
extern void KABI hal_interrupt_handler_6(void);
extern void KAPI hal_interrupt_handler_7(void);
extern void KABI hal_interrupt_handler_7(void);
extern void KAPI hal_interrupt_handler_8(void);
extern void KABI hal_interrupt_handler_8(void);
extern void KAPI hal_interrupt_handler_9(void);
extern void KABI hal_interrupt_handler_9(void);
extern void KAPI hal_interrupt_handler_10(void);
extern void KABI hal_interrupt_handler_10(void);
extern void KAPI hal_interrupt_handler_11(void);
extern void KABI hal_interrupt_handler_11(void);
extern void KAPI hal_interrupt_handler_12(void);
extern void KABI hal_interrupt_handler_12(void);
extern void KAPI hal_interrupt_handler_13(void);
extern void KABI hal_interrupt_handler_13(void);
extern void KAPI hal_interrupt_handler_14(void);
extern void KABI hal_interrupt_handler_14(void);
extern void KAPI hal_interrupt_handler_15(void);
extern void KABI hal_interrupt_handler_15(void);
extern void KAPI hal_interrupt_handler_16(void);
extern void KABI hal_interrupt_handler_16(void);
extern void KAPI hal_interrupt_handler_17(void);
extern void KABI hal_interrupt_handler_17(void);
extern void KAPI hal_interrupt_handler_18(void);
extern void KABI hal_interrupt_handler_18(void);
extern void KAPI hal_interrupt_handler_19(void);
extern void KABI hal_interrupt_handler_19(void);
extern void KAPI hal_interrupt_handler_20(void);
extern void KABI hal_interrupt_handler_20(void);
extern void KAPI hal_interrupt_handler_21(void);
extern void KABI hal_interrupt_handler_21(void);
extern void KAPI hal_interrupt_handler_22(void);
extern void KABI hal_interrupt_handler_22(void);
extern void KAPI hal_interrupt_handler_23(void);
extern void KABI hal_interrupt_handler_23(void);
extern void KAPI hal_interrupt_handler_24(void);
extern void KABI hal_interrupt_handler_24(void);
extern void KAPI hal_interrupt_handler_25(void);
extern void KABI hal_interrupt_handler_25(void);
extern void KAPI hal_interrupt_handler_26(void);
extern void KABI hal_interrupt_handler_26(void);
extern void KAPI hal_interrupt_handler_27(void);
extern void KABI hal_interrupt_handler_27(void);
extern void KAPI hal_interrupt_handler_28(void);
extern void KABI hal_interrupt_handler_28(void);
extern void KAPI hal_interrupt_handler_29(void);
extern void KABI hal_interrupt_handler_29(void);
extern void KAPI hal_interrupt_handler_30(void);
extern void KABI hal_interrupt_handler_30(void);
extern void KAPI hal_interrupt_handler_31(void);
extern void KABI hal_interrupt_handler_31(void);
// USER DEFINED INTERRUPT_HANDLERS
extern void KAPI hal_interrupt_handler_32(void);
extern void KABI hal_interrupt_handler_32(void);
extern void KAPI hal_interrupt_handler_33(void);
extern void KABI hal_interrupt_handler_33(void);
extern void KAPI hal_interrupt_handler_34(void);
extern void KABI hal_interrupt_handler_34(void);
extern void KAPI hal_interrupt_handler_35(void);
extern void KABI hal_interrupt_handler_35(void);
extern void KAPI hal_interrupt_handler_36(void);
extern void KABI hal_interrupt_handler_36(void);
extern void KAPI hal_interrupt_handler_37(void);
extern void KABI hal_interrupt_handler_37(void);
extern void KAPI hal_interrupt_handler_38(void);
extern void KABI hal_interrupt_handler_38(void);
extern void KAPI hal_interrupt_handler_39(void);
extern void KABI hal_interrupt_handler_39(void);
extern void KAPI hal_interrupt_handler_40(void);
extern void KABI hal_interrupt_handler_40(void);
extern void KAPI hal_interrupt_handler_41(void);
extern void KABI hal_interrupt_handler_41(void);
extern void KAPI hal_interrupt_handler_42(void);
extern void KABI hal_interrupt_handler_42(void);
extern void KAPI hal_interrupt_handler_43(void);
extern void KABI hal_interrupt_handler_43(void);
extern void KAPI hal_interrupt_handler_44(void);
extern void KABI hal_interrupt_handler_44(void);
extern void KAPI hal_interrupt_handler_45(void);
extern void KABI hal_interrupt_handler_45(void);
extern void KAPI hal_interrupt_handler_46(void);
extern void KABI hal_interrupt_handler_46(void);
extern void KAPI hal_interrupt_handler_47(void);
extern void KABI hal_interrupt_handler_47(void);
extern void KAPI hal_interrupt_handler_48(void);
extern void KABI hal_interrupt_handler_48(void);
extern void KAPI hal_interrupt_handler_49(void);
extern void KABI hal_interrupt_handler_49(void);
extern void KAPI hal_interrupt_handler_50(void);
extern void KABI hal_interrupt_handler_50(void);
extern void KAPI hal_interrupt_handler_51(void);
extern void KABI hal_interrupt_handler_51(void);
extern void KAPI hal_interrupt_handler_52(void);
extern void KABI hal_interrupt_handler_52(void);
extern void KAPI hal_interrupt_handler_53(void);
extern void KABI hal_interrupt_handler_53(void);
extern void KAPI hal_interrupt_handler_54(void);
extern void KABI hal_interrupt_handler_54(void);
extern void KAPI hal_interrupt_handler_55(void);
extern void KABI hal_interrupt_handler_55(void);
extern void KAPI hal_interrupt_handler_56(void);
extern void KABI hal_interrupt_handler_56(void);
extern void KAPI hal_interrupt_handler_57(void);
extern void KABI hal_interrupt_handler_57(void);
extern void KAPI hal_interrupt_handler_58(void);
extern void KABI hal_interrupt_handler_58(void);
extern void KAPI hal_interrupt_handler_59(void);
extern void KABI hal_interrupt_handler_59(void);
extern void KAPI hal_interrupt_handler_60(void);
extern void KABI hal_interrupt_handler_60(void);
extern void KAPI hal_interrupt_handler_61(void);
extern void KABI hal_interrupt_handler_61(void);
extern void KAPI hal_interrupt_handler_62(void);
extern void KABI hal_interrupt_handler_62(void);
extern void KAPI hal_interrupt_handler_63(void);
extern void KABI hal_interrupt_handler_63(void);
extern void KAPI hal_interrupt_handler_64(void);
extern void KABI hal_interrupt_handler_64(void);
extern void KAPI hal_interrupt_handler_65(void);
extern void KABI hal_interrupt_handler_65(void);
extern void KAPI hal_interrupt_handler_66(void);
extern void KABI hal_interrupt_handler_66(void);
extern void KAPI hal_interrupt_handler_67(void);
extern void KABI hal_interrupt_handler_67(void);
extern void KAPI hal_interrupt_handler_68(void);
extern void KABI hal_interrupt_handler_68(void);
extern void KAPI hal_interrupt_handler_69(void);
extern void KABI hal_interrupt_handler_69(void);
extern void KAPI hal_interrupt_handler_70(void);
extern void KABI hal_interrupt_handler_70(void);
extern void KAPI hal_interrupt_handler_71(void);
extern void KABI hal_interrupt_handler_71(void);
extern void KAPI hal_interrupt_handler_72(void);
extern void KABI hal_interrupt_handler_72(void);
extern void KAPI hal_interrupt_handler_73(void);
extern void KABI hal_interrupt_handler_73(void);
extern void KAPI hal_interrupt_handler_74(void);
extern void KABI hal_interrupt_handler_74(void);
extern void KAPI hal_interrupt_handler_75(void);
extern void KABI hal_interrupt_handler_75(void);
extern void KAPI hal_interrupt_handler_76(void);
extern void KABI hal_interrupt_handler_76(void);
extern void KAPI hal_interrupt_handler_77(void);
extern void KABI hal_interrupt_handler_77(void);
extern void KAPI hal_interrupt_handler_78(void);
extern void KABI hal_interrupt_handler_78(void);
extern void KAPI hal_interrupt_handler_79(void);
extern void KABI hal_interrupt_handler_79(void);
extern void KAPI hal_interrupt_handler_80(void);
extern void KABI hal_interrupt_handler_80(void);
extern void KAPI hal_interrupt_handler_81(void);
extern void KABI hal_interrupt_handler_81(void);
extern void KAPI hal_interrupt_handler_82(void);
extern void KABI hal_interrupt_handler_82(void);
extern void KAPI hal_interrupt_handler_83(void);
extern void KABI hal_interrupt_handler_83(void);
extern void KAPI hal_interrupt_handler_84(void);
extern void KABI hal_interrupt_handler_84(void);
extern void KAPI hal_interrupt_handler_85(void);
extern void KABI hal_interrupt_handler_85(void);
extern void KAPI hal_interrupt_handler_86(void);
extern void KABI hal_interrupt_handler_86(void);
extern void KAPI hal_interrupt_handler_87(void);
extern void KABI hal_interrupt_handler_87(void);
extern void KAPI hal_interrupt_handler_88(void);
extern void KABI hal_interrupt_handler_88(void);
extern void KAPI hal_interrupt_handler_89(void);
extern void KABI hal_interrupt_handler_89(void);
extern void KAPI hal_interrupt_handler_90(void);
extern void KABI hal_interrupt_handler_90(void);
extern void KAPI hal_interrupt_handler_91(void);
extern void KABI hal_interrupt_handler_91(void);
extern void KAPI hal_interrupt_handler_92(void);
extern void KABI hal_interrupt_handler_92(void);
extern void KAPI hal_interrupt_handler_93(void);
extern void KABI hal_interrupt_handler_93(void);
extern void KAPI hal_interrupt_handler_94(void);
extern void KABI hal_interrupt_handler_94(void);
extern void KAPI hal_interrupt_handler_95(void);
extern void KABI hal_interrupt_handler_95(void);
extern void KAPI hal_interrupt_handler_96(void);
extern void KABI hal_interrupt_handler_96(void);
extern void KAPI hal_interrupt_handler_97(void);
extern void KABI hal_interrupt_handler_97(void);
extern void KAPI hal_interrupt_handler_98(void);
extern void KABI hal_interrupt_handler_98(void);
extern void KAPI hal_interrupt_handler_99(void);
extern void KABI hal_interrupt_handler_99(void);
extern void KAPI hal_interrupt_handler_100(void);
extern void KABI hal_interrupt_handler_100(void);
extern void KAPI hal_interrupt_handler_101(void);
extern void KABI hal_interrupt_handler_101(void);
extern void KAPI hal_interrupt_handler_102(void);
extern void KABI hal_interrupt_handler_102(void);
extern void KAPI hal_interrupt_handler_103(void);
extern void KABI hal_interrupt_handler_103(void);
extern void KAPI hal_interrupt_handler_104(void);
extern void KABI hal_interrupt_handler_104(void);
extern void KAPI hal_interrupt_handler_105(void);
extern void KABI hal_interrupt_handler_105(void);
extern void KAPI hal_interrupt_handler_106(void);
extern void KABI hal_interrupt_handler_106(void);
extern void KAPI hal_interrupt_handler_107(void);
extern void KABI hal_interrupt_handler_107(void);
extern void KAPI hal_interrupt_handler_108(void);
extern void KABI hal_interrupt_handler_108(void);
extern void KAPI hal_interrupt_handler_109(void);
extern void KABI hal_interrupt_handler_109(void);
extern void KAPI hal_interrupt_handler_110(void);
extern void KABI hal_interrupt_handler_110(void);
extern void KAPI hal_interrupt_handler_111(void);
extern void KABI hal_interrupt_handler_111(void);
extern void KAPI hal_interrupt_handler_112(void);
extern void KABI hal_interrupt_handler_112(void);
extern void KAPI hal_interrupt_handler_113(void);
extern void KABI hal_interrupt_handler_113(void);
extern void KAPI hal_interrupt_handler_114(void);
extern void KABI hal_interrupt_handler_114(void);
extern void KAPI hal_interrupt_handler_115(void);
extern void KABI hal_interrupt_handler_115(void);
extern void KAPI hal_interrupt_handler_116(void);
extern void KABI hal_interrupt_handler_116(void);
extern void KAPI hal_interrupt_handler_117(void);
extern void KABI hal_interrupt_handler_117(void);
extern void KAPI hal_interrupt_handler_118(void);
extern void KABI hal_interrupt_handler_118(void);
extern void KAPI hal_interrupt_handler_119(void);
extern void KABI hal_interrupt_handler_119(void);
extern void KAPI hal_interrupt_handler_120(void);
extern void KABI hal_interrupt_handler_120(void);
extern void KAPI hal_interrupt_handler_121(void);
extern void KABI hal_interrupt_handler_121(void);
extern void KAPI hal_interrupt_handler_122(void);
extern void KABI hal_interrupt_handler_122(void);
extern void KAPI hal_interrupt_handler_123(void);
extern void KABI hal_interrupt_handler_123(void);
extern void KAPI hal_interrupt_handler_124(void);
extern void KABI hal_interrupt_handler_124(void);
extern void KAPI hal_interrupt_handler_125(void);
extern void KABI hal_interrupt_handler_125(void);
extern void KAPI hal_interrupt_handler_126(void);
extern void KABI hal_interrupt_handler_126(void);
extern void KAPI hal_interrupt_handler_127(void);
extern void KABI hal_interrupt_handler_127(void);
extern void KAPI hal_interrupt_handler_128(void);
extern void KABI hal_interrupt_handler_128(void);
extern void KAPI hal_interrupt_handler_129(void);
extern void KABI hal_interrupt_handler_129(void);
extern void KAPI hal_interrupt_handler_130(void);
extern void KABI hal_interrupt_handler_130(void);
extern void KAPI hal_interrupt_handler_131(void);
extern void KABI hal_interrupt_handler_131(void);
extern void KAPI hal_interrupt_handler_132(void);
extern void KABI hal_interrupt_handler_132(void);
extern void KAPI hal_interrupt_handler_133(void);
extern void KABI hal_interrupt_handler_133(void);
extern void KAPI hal_interrupt_handler_134(void);
extern void KABI hal_interrupt_handler_134(void);
extern void KAPI hal_interrupt_handler_135(void);
extern void KABI hal_interrupt_handler_135(void);
extern void KAPI hal_interrupt_handler_136(void);
extern void KABI hal_interrupt_handler_136(void);
extern void KAPI hal_interrupt_handler_137(void);
extern void KABI hal_interrupt_handler_137(void);
extern void KAPI hal_interrupt_handler_138(void);
extern void KABI hal_interrupt_handler_138(void);
extern void KAPI hal_interrupt_handler_139(void);
extern void KABI hal_interrupt_handler_139(void);
extern void KAPI hal_interrupt_handler_140(void);
extern void KABI hal_interrupt_handler_140(void);
extern void KAPI hal_interrupt_handler_141(void);
extern void KABI hal_interrupt_handler_141(void);
extern void KAPI hal_interrupt_handler_142(void);
extern void KABI hal_interrupt_handler_142(void);
extern void KAPI hal_interrupt_handler_143(void);
extern void KABI hal_interrupt_handler_143(void);
extern void KAPI hal_interrupt_handler_144(void);
extern void KABI hal_interrupt_handler_144(void);
extern void KAPI hal_interrupt_handler_145(void);
extern void KABI hal_interrupt_handler_145(void);
extern void KAPI hal_interrupt_handler_146(void);
extern void KABI hal_interrupt_handler_146(void);
extern void KAPI hal_interrupt_handler_147(void);
extern void KABI hal_interrupt_handler_147(void);
extern void KAPI hal_interrupt_handler_148(void);
extern void KABI hal_interrupt_handler_148(void);
extern void KAPI hal_interrupt_handler_149(void);
extern void KABI hal_interrupt_handler_149(void);
extern void KAPI hal_interrupt_handler_150(void);
extern void KABI hal_interrupt_handler_150(void);
extern void KAPI hal_interrupt_handler_151(void);
extern void KABI hal_interrupt_handler_151(void);
extern void KAPI hal_interrupt_handler_152(void);
extern void KABI hal_interrupt_handler_152(void);
extern void KAPI hal_interrupt_handler_153(void);
extern void KABI hal_interrupt_handler_153(void);
extern void KAPI hal_interrupt_handler_154(void);
extern void KABI hal_interrupt_handler_154(void);
extern void KAPI hal_interrupt_handler_155(void);
extern void KABI hal_interrupt_handler_155(void);
extern void KAPI hal_interrupt_handler_156(void);
extern void KABI hal_interrupt_handler_156(void);
extern void KAPI hal_interrupt_handler_157(void);
extern void KABI hal_interrupt_handler_157(void);
extern void KAPI hal_interrupt_handler_158(void);
extern void KABI hal_interrupt_handler_158(void);
extern void KAPI hal_interrupt_handler_159(void);
extern void KABI hal_interrupt_handler_159(void);
extern void KAPI hal_interrupt_handler_160(void);
extern void KABI hal_interrupt_handler_160(void);
extern void KAPI hal_interrupt_handler_161(void);
extern void KABI hal_interrupt_handler_161(void);
extern void KAPI hal_interrupt_handler_162(void);
extern void KABI hal_interrupt_handler_162(void);
extern void KAPI hal_interrupt_handler_163(void);
extern void KABI hal_interrupt_handler_163(void);
extern void KAPI hal_interrupt_handler_164(void);
extern void KABI hal_interrupt_handler_164(void);
extern void KAPI hal_interrupt_handler_165(void);
extern void KABI hal_interrupt_handler_165(void);
extern void KAPI hal_interrupt_handler_166(void);
extern void KABI hal_interrupt_handler_166(void);
extern void KAPI hal_interrupt_handler_167(void);
extern void KABI hal_interrupt_handler_167(void);
extern void KAPI hal_interrupt_handler_168(void);
extern void KABI hal_interrupt_handler_168(void);
extern void KAPI hal_interrupt_handler_169(void);
extern void KABI hal_interrupt_handler_169(void);
extern void KAPI hal_interrupt_handler_170(void);
extern void KABI hal_interrupt_handler_170(void);
extern void KAPI hal_interrupt_handler_171(void);
extern void KABI hal_interrupt_handler_171(void);
extern void KAPI hal_interrupt_handler_172(void);
extern void KABI hal_interrupt_handler_172(void);
extern void KAPI hal_interrupt_handler_173(void);
extern void KABI hal_interrupt_handler_173(void);
extern void KAPI hal_interrupt_handler_174(void);
extern void KABI hal_interrupt_handler_174(void);
extern void KAPI hal_interrupt_handler_175(void);
extern void KABI hal_interrupt_handler_175(void);
extern void KAPI hal_interrupt_handler_176(void);
extern void KABI hal_interrupt_handler_176(void);
extern void KAPI hal_interrupt_handler_177(void);
extern void KABI hal_interrupt_handler_177(void);
extern void KAPI hal_interrupt_handler_178(void);
extern void KABI hal_interrupt_handler_178(void);
extern void KAPI hal_interrupt_handler_179(void);
extern void KABI hal_interrupt_handler_179(void);
extern void KAPI hal_interrupt_handler_180(void);
extern void KABI hal_interrupt_handler_180(void);
extern void KAPI hal_interrupt_handler_181(void);
extern void KABI hal_interrupt_handler_181(void);
extern void KAPI hal_interrupt_handler_182(void);
extern void KABI hal_interrupt_handler_182(void);
extern void KAPI hal_interrupt_handler_183(void);
extern void KABI hal_interrupt_handler_183(void);
extern void KAPI hal_interrupt_handler_184(void);
extern void KABI hal_interrupt_handler_184(void);
extern void KAPI hal_interrupt_handler_185(void);
extern void KABI hal_interrupt_handler_185(void);
extern void KAPI hal_interrupt_handler_186(void);
extern void KABI hal_interrupt_handler_186(void);
extern void KAPI hal_interrupt_handler_187(void);
extern void KABI hal_interrupt_handler_187(void);
extern void KAPI hal_interrupt_handler_188(void);
extern void KABI hal_interrupt_handler_188(void);
extern void KAPI hal_interrupt_handler_189(void);
extern void KABI hal_interrupt_handler_189(void);
extern void KAPI hal_interrupt_handler_190(void);
extern void KABI hal_interrupt_handler_190(void);
extern void KAPI hal_interrupt_handler_191(void);
extern void KABI hal_interrupt_handler_191(void);
extern void KAPI hal_interrupt_handler_192(void);
extern void KABI hal_interrupt_handler_192(void);
extern void KAPI hal_interrupt_handler_193(void);
extern void KABI hal_interrupt_handler_193(void);
extern void KAPI hal_interrupt_handler_194(void);
extern void KABI hal_interrupt_handler_194(void);
extern void KAPI hal_interrupt_handler_195(void);
extern void KABI hal_interrupt_handler_195(void);
extern void KAPI hal_interrupt_handler_196(void);
extern void KABI hal_interrupt_handler_196(void);
extern void KAPI hal_interrupt_handler_197(void);
extern void KABI hal_interrupt_handler_197(void);
extern void KAPI hal_interrupt_handler_198(void);
extern void KABI hal_interrupt_handler_198(void);
extern void KAPI hal_interrupt_handler_199(void);
extern void KABI hal_interrupt_handler_199(void);
extern void KAPI hal_interrupt_handler_200(void);
extern void KABI hal_interrupt_handler_200(void);
extern void KAPI hal_interrupt_handler_201(void);
extern void KABI hal_interrupt_handler_201(void);
extern void KAPI hal_interrupt_handler_202(void);
extern void KABI hal_interrupt_handler_202(void);
extern void KAPI hal_interrupt_handler_203(void);
extern void KABI hal_interrupt_handler_203(void);
extern void KAPI hal_interrupt_handler_204(void);
extern void KABI hal_interrupt_handler_204(void);
extern void KAPI hal_interrupt_handler_205(void);
extern void KABI hal_interrupt_handler_205(void);
extern void KAPI hal_interrupt_handler_206(void);
extern void KABI hal_interrupt_handler_206(void);
extern void KAPI hal_interrupt_handler_207(void);
extern void KABI hal_interrupt_handler_207(void);
extern void KAPI hal_interrupt_handler_208(void);
extern void KABI hal_interrupt_handler_208(void);
extern void KAPI hal_interrupt_handler_209(void);
extern void KABI hal_interrupt_handler_209(void);
extern void KAPI hal_interrupt_handler_210(void);
extern void KABI hal_interrupt_handler_210(void);
extern void KAPI hal_interrupt_handler_211(void);
extern void KABI hal_interrupt_handler_211(void);
extern void KAPI hal_interrupt_handler_212(void);
extern void KABI hal_interrupt_handler_212(void);
extern void KAPI hal_interrupt_handler_213(void);
extern void KABI hal_interrupt_handler_213(void);
extern void KAPI hal_interrupt_handler_214(void);
extern void KABI hal_interrupt_handler_214(void);
extern void KAPI hal_interrupt_handler_215(void);
extern void KABI hal_interrupt_handler_215(void);
extern void KAPI hal_interrupt_handler_216(void);
extern void KABI hal_interrupt_handler_216(void);
extern void KAPI hal_interrupt_handler_217(void);
extern void KABI hal_interrupt_handler_217(void);
extern void KAPI hal_interrupt_handler_218(void);
extern void KABI hal_interrupt_handler_218(void);
extern void KAPI hal_interrupt_handler_219(void);
extern void KABI hal_interrupt_handler_219(void);
extern void KAPI hal_interrupt_handler_220(void);
extern void KABI hal_interrupt_handler_220(void);
extern void KAPI hal_interrupt_handler_221(void);
extern void KABI hal_interrupt_handler_221(void);
extern void KAPI hal_interrupt_handler_222(void);
extern void KABI hal_interrupt_handler_222(void);
extern void KAPI hal_interrupt_handler_223(void);
extern void KABI hal_interrupt_handler_223(void);
extern void KAPI hal_interrupt_handler_224(void);
extern void KABI hal_interrupt_handler_224(void);
extern void KAPI hal_interrupt_handler_225(void);
extern void KABI hal_interrupt_handler_225(void);
extern void KAPI hal_interrupt_handler_226(void);
extern void KABI hal_interrupt_handler_226(void);
extern void KAPI hal_interrupt_handler_227(void);
extern void KABI hal_interrupt_handler_227(void);
extern void KAPI hal_interrupt_handler_228(void);
extern void KABI hal_interrupt_handler_228(void);
extern void KAPI hal_interrupt_handler_229(void);
extern void KABI hal_interrupt_handler_229(void);
extern void KAPI hal_interrupt_handler_230(void);
extern void KABI hal_interrupt_handler_230(void);
extern void KAPI hal_interrupt_handler_231(void);
extern void KABI hal_interrupt_handler_231(void);
extern void KAPI hal_interrupt_handler_232(void);
extern void KABI hal_interrupt_handler_232(void);
extern void KAPI hal_interrupt_handler_233(void);
extern void KABI hal_interrupt_handler_233(void);
extern void KAPI hal_interrupt_handler_234(void);
extern void KABI hal_interrupt_handler_234(void);
extern void KAPI hal_interrupt_handler_235(void);
extern void KABI hal_interrupt_handler_235(void);
extern void KAPI hal_interrupt_handler_236(void);
extern void KABI hal_interrupt_handler_236(void);
extern void KAPI hal_interrupt_handler_237(void);
extern void KABI hal_interrupt_handler_237(void);
extern void KAPI hal_interrupt_handler_238(void);
extern void KABI hal_interrupt_handler_238(void);
extern void KAPI hal_interrupt_handler_239(void);
extern void KABI hal_interrupt_handler_239(void);
extern void KAPI hal_interrupt_handler_240(void);
extern void KABI hal_interrupt_handler_240(void);
extern void KAPI hal_interrupt_handler_241(void);
extern void KABI hal_interrupt_handler_241(void);
extern void KAPI hal_interrupt_handler_242(void);
extern void KABI hal_interrupt_handler_242(void);
extern void KAPI hal_interrupt_handler_243(void);
extern void KABI hal_interrupt_handler_243(void);
extern void KAPI hal_interrupt_handler_244(void);
extern void KABI hal_interrupt_handler_244(void);
extern void KAPI hal_interrupt_handler_245(void);
extern void KABI hal_interrupt_handler_245(void);
extern void KAPI hal_interrupt_handler_246(void);
extern void KABI hal_interrupt_handler_246(void);
extern void KAPI hal_interrupt_handler_247(void);
extern void KABI hal_interrupt_handler_247(void);
extern void KAPI hal_interrupt_handler_248(void);
extern void KABI hal_interrupt_handler_248(void);
extern void KAPI hal_interrupt_handler_249(void);
extern void KABI hal_interrupt_handler_249(void);
extern void KAPI hal_interrupt_handler_250(void);
extern void KABI hal_interrupt_handler_250(void);
extern void KAPI hal_interrupt_handler_251(void);
extern void KABI hal_interrupt_handler_251(void);
extern void KAPI hal_interrupt_handler_252(void);
extern void KABI hal_interrupt_handler_252(void);
extern void KAPI hal_interrupt_handler_253(void);
extern void KABI hal_interrupt_handler_253(void);
extern void KAPI hal_interrupt_handler_254(void);
extern void KABI hal_interrupt_handler_254(void);
extern void KAPI hal_interrupt_handler_255(void);
extern void KABI hal_interrupt_handler_255(void);
void KAPI hal_register_interrupt_handler(uint32_t coreid, uint32_t index, k_intr_handler_t handler, void* context);
void KABI hal_register_interrupt_handler(uint32_t coreid, uint32_t index, k_intr_handler_t handler, void* context);
void KAPI hal_deregister_interrupt_handler(uint32_t coreid, uint32_t index);
void KABI hal_deregister_interrupt_handler(uint32_t coreid, uint32_t index);
void KAPI hal_register_exception_handler(uint32_t coreid, uint32_t index, k_exc_handler_t handler);
void KABI hal_register_exception_handler(uint32_t coreid, uint32_t index, k_exc_handler_t handler);
void KAPI hal_deregister_exception_handler(uint32_t coreid, uint32_t index);
void KABI hal_deregister_exception_handler(uint32_t coreid, uint32_t index);
void KAPI hal_issue_interrupt(uint32_t core_id, uint32_t vector);
void KABI hal_issue_interrupt(uint32_t core_id, uint32_t vector);
void KAPI hal_set_interrupt_handler(uint64_t index, void (*handler)(void));
void KABI hal_set_interrupt_handler(uint64_t index, void (*handler)(void));
void KAPI hal_write_gate(void *const gate, uint64_t const offset, uint32_t const selector, uint32_t const attr);
void KABI hal_write_gate(void *const gate, uint64_t const offset, uint32_t const selector, uint32_t const attr);
void KAPI hal_assert(int64_t exp, char *message);
void KABI hal_assert(int64_t exp, char *message);
int32_t KAPI hal_interrupt_init(void);
int32_t KABI hal_interrupt_init(void);
uint32_t KAPI hal_get_core_id(void);
uint32_t KABI hal_get_core_id(void);
#endif

20
x64/src/hal/inc/hal_mem.h
View File

@ -8,13 +8,13 @@
#include "g_abi.h"
#include "g_type.h"
#include "k_linked_list.h"
#include "../../lib/inc/linked_list.h"
#define GDT_ENTRY_SIZE 8
#define GDT_ENTRY_NUM 9
static inline uint32_t KAPI seg_selector(uint32_t index, uint32_t rpl)
static inline uint32_t KABI seg_selector(uint32_t index, uint32_t rpl)
{
return (index << 3) + rpl;
}
@ -81,20 +81,20 @@ static inline uint32_t KAPI seg_selector(uint32_t index, uint32_t rpl)
#define PHYSICAL_PAGE_SIZE 4096
void* KAPI halloc(uint32_t size);
void* KABI halloc(uint32_t size);
void KAPI hfree(void *ptr);
void KABI hfree(void *ptr);
void KAPI hal_mem_init();
void KABI hal_mem_init();
void KAPI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit, uint64_t const attr);
void KABI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uint32_t const limit, uint64_t const attr);
void KAPI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr);
void KABI hal_write_pml4_entry(void *const base, uint64_t const pdpt_addr, uint64_t const attr);
void KAPI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr);
void KABI hal_write_pdpt_entry(void *const base, uint64_t const pd_addr, uint64_t const attr);
void KAPI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr);
void KABI hal_write_pd_entry(void *const base, uint64_t const pt_addr, uint64_t const attr);
void KAPI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr);
void KABI hal_write_pt_entry(void *const base, uint64_t const p_addr, uint64_t const attr);
#endif

6
x64/src/hal/inc/hal_print.h
View File

@ -12,8 +12,8 @@
#define get_row(pos) (pos / 80)
#define get_pos(row,col) ((row) * 80 + (col))
void KAPI hal_clear_screen();
void KAPI hal_print_init();
void KAPI hal_printf(char const *format, ...);
void KABI hal_clear_screen();
void KABI hal_print_init();
void KABI hal_printf(char const *format, ...);
#endif

12
x64/src/kernel/inc/k_alloc.h
View File

@ -1,12 +0,0 @@
#ifndef _K_ALLOC_H_
#define _K_ALLOC_H_
#include "g_abi.h"
#include "g_type.h"
void KAPI ke_alloc_init();
void* KAPI ke_alloc(uint32_t size);
void KAPI ke_free(void *ptr);
#endif

6
x64/src/kernel/inc/k_atomic.h
View File

@ -1,6 +0,0 @@
#ifndef _K_ATOMIC_H_
#define _K_ATOMIC_H_
#include "s_atomic.h"
#endif

55
x64/src/kernel/inc/k_avl_tree.h
View File

@ -1,55 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _K_AVL_TREE_H_
#define _K_AVL_TREE_H_
#include "g_type.h"
#include "g_abi.h"
#include "k_stdlib.h"
typedef struct _k_avl_tree_node_t
{
struct _k_avl_tree_node_t *left;
struct _k_avl_tree_node_t *right;
struct _k_avl_tree_node_t *parent;
int32_t height;
} k_avl_tree_node_t;
/*
* A comparison function between tree_node and your_node
* Returns:
* < 0 if tree_node < your_node
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
typedef struct _k_avl_tree_t
{
k_callback_func_t compare;
k_avl_tree_node_t *root;
} k_avl_tree_t;
k_avl_tree_node_t *KAPI ke_avl_tree_search(k_avl_tree_t *tree, k_avl_tree_node_t *entry);
void KAPI ke_avl_tree_insert(k_avl_tree_t *tree, k_avl_tree_node_t *entry);
k_avl_tree_node_t *KAPI ke_avl_tree_delete(k_avl_tree_t *tree, k_avl_tree_node_t *entry);
void KAPI ke_avl_tree_init(k_avl_tree_t *tree, k_callback_func_t compare);
k_avl_tree_node_t *KAPI ke_avl_tree_largest(k_avl_tree_t *tree);
k_avl_tree_node_t *KAPI ke_avl_tree_smallest(k_avl_tree_t *tree);
k_avl_tree_node_t *KAPI ke_avl_tree_larger(k_avl_tree_node_t *entry);
k_avl_tree_node_t *KAPI ke_avl_tree_smaller(k_avl_tree_node_t *entry);
bool KAPI ke_avl_tree_validate(k_avl_tree_t *tree);
int32_t KAPI ke_avl_tree_size(k_avl_tree_t *tree);
#endif

4
x64/src/kernel/inc/k_boot.h
View File

@ -1,4 +0,0 @@
#ifndef _K_BOOT_H_
#define _K_BOOT_H_
#include "s_boot.h"
#endif

12
x64/src/kernel/inc/k_intr.h
View File

@ -1,12 +0,0 @@
#ifndef _K_INTR_H_
#define _K_INTR_H_
#include "s_intr.h"
#include "g_type.h"
#include "g_abi.h"
k_irql_t KAPI ke_raise_irql(k_irql_t irql);
k_irql_t KAPI ke_lower_irql(k_irql_t irql);
#endif

62
x64/src/kernel/inc/k_linked_list.h
View File

@ -1,62 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _K_LINKED_LIST_H_
#define _K_LINKED_LIST_H_
#include "g_abi.h"
#include "g_type.h"
typedef struct _k_linked_list_node_t
{
struct _k_linked_list_node_t *prev;
struct _k_linked_list_node_t *next;
} k_linked_list_node_t;
typedef struct _k_linked_list_t
{
k_linked_list_node_t *head;
k_linked_list_node_t *tail;
} k_linked_list_t;
/*
* Returns true if current list node == your node
* false otherwise
*/
void KAPI ke_linked_list_init(k_linked_list_t *list);
int32_t KAPI ke_linked_list_size(k_linked_list_t *list);
void KAPI ke_linked_list_push_front(k_linked_list_t *list, k_linked_list_node_t *node);
void KAPI ke_linked_list_push_back(k_linked_list_t *list, k_linked_list_node_t *node);
k_linked_list_node_t *KAPI ke_linked_list_pop_front(k_linked_list_t *list);
k_linked_list_node_t *KAPI ke_linked_list_pop_back(k_linked_list_t *list);
void KAPI ke_linked_list_insert(k_linked_list_t *list, int32_t index, k_linked_list_node_t *node);
void KAPI ke_linked_list_insert_ref(k_linked_list_t *list, k_linked_list_node_t *prev_node, k_linked_list_node_t *node);
k_linked_list_node_t *KAPI ke_linked_list_remove(k_linked_list_t *list, int32_t index);
k_linked_list_node_t *KAPI ke_linked_list_remove_ref(k_linked_list_t *list, k_linked_list_node_t *node);
k_linked_list_node_t *KAPI ke_linked_list_get(k_linked_list_t *list, int32_t index);
k_linked_list_node_t *KAPI ke_linked_list_next(k_linked_list_node_t *node);
k_linked_list_node_t *KAPI ke_linked_list_prev(k_linked_list_node_t *node);
k_linked_list_node_t *KAPI ke_linked_list_first(k_linked_list_t *list);
k_linked_list_node_t *KAPI ke_linked_list_last(k_linked_list_t *list);
int32_t KAPI ke_linked_list_search(k_linked_list_t *list, k_linked_list_node_t *target,
k_callback_func_t equals);
#endif

31
x64/src/kernel/inc/k_pmm.h
View File

@ -1,31 +0,0 @@
#ifndef _K_PMM_H_
#define _K_PMM_H_
#include "k_avl_tree.h"
#include "k_linked_list.h"
#include "g_abi.h"
#include "s_pmm.h"
#include "k_atomic.h"
//#define PMM_PAGE_ATTR_FREE_BIT 0
//#define PMM_PAGE_ATTR_PAGED_BIT 1
//
//typedef struct
//{
// uint32_t attr;
//} k_physical_page_attr_t;
k_status_t KAPI sx_pmm_init(k_pmm_info_t *info);
k_status_t KAPI k_alloc_page(k_physical_addr_t *out);
k_status_t KAPI k_free_page(k_physical_addr_t base);
// TODO: implement these somehow, i might just reserve the first 16MB for these
int32_t KAPI k_alloc_contiguous_pages(uint64_t num_of_page,
k_physical_addr_t highest_p_addr,
k_physical_addr_t *out);
int32_t KAPI k_free_contiguous_pages(k_physical_addr_t base);
#endif

6
x64/src/kernel/inc/k_print.h
View File

@ -1,6 +0,0 @@
#ifndef _K_PRINTF_H_
#define _K_PRINTF_H_
#include "s_print.h"
#endif

36
x64/src/kernel/inc/k_ref.h
View File

@ -1,36 +0,0 @@
#ifndef _K_REF_H_
#define _K_REF_H_
#include "g_type.h"
#include "k_status.h"
typedef struct
{
int32_t ref_count;
k_callback_func_t free_routine;
} k_ref_node_t;
#define K_HANDLE_BASE 0x80000000
//
// All functions are sx since users or kernel devs should not be
// specifying where the allocations take place
//
k_status_t KAPI ke_reference_setup();
k_status_t KAPI ke_reference_create(k_ref_node_t *ref,
k_callback_func_t free_func);
k_status_t KAPI ke_reference_obj(k_ref_node_t *ref);
k_status_t KAPI ke_dereference_obj(k_ref_node_t *ref);
// HANDLES
k_status_t KAPI sx_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out);
k_status_t KAPI sx_create_handle(k_ref_node_t *ref, k_handle_t *out);
k_status_t KAPI sx_close_handle(k_handle_t handle);
#endif

23
x64/src/kernel/inc/k_spin_lock.h
View File

@ -1,23 +0,0 @@
#ifndef _K_SPIN_LOCK_H_
#define _K_SPIN_LOCK_H_
#include "g_type.h"
#include "g_abi.h"
#include "k_intr.h"
typedef struct
{
int32_t val;
} k_spin_lock_t;
void KAPI ke_spin_lock_init(k_spin_lock_t *lock);
void KAPI ke_spin_lock(k_spin_lock_t *lock);
void KAPI ke_spin_unlock(k_spin_lock_t *lock);
k_irql_t KAPI ke_spin_lock_raise_irql(k_spin_lock_t *lock, k_irql_t irql);
void KAPI ke_spin_unlock_lower_irql(k_spin_lock_t *lock, k_irql_t irql);
#endif

36
x64/src/kernel/inc/k_vmm.h
View File

@ -1,36 +0,0 @@
#ifndef _K_VMM_H_
#define _K_VMM_H_
#include "s_vmm.h"
#include "k_avl_tree.h"
#include "k_atomic.h"
#include "k_spin_lock.h"
#define VMM_STATUS_SUCCESS 0
#define VMM_STATUS_INVALID_ARGUMENTS 1
#define VMM_STATUS_CANNOT_ALLOC_NODE 2
typedef struct
{
uint32_t attr;
} k_virtual_addr_attribute_t;
typedef struct
{
k_avl_tree_t region_tree;
_Bool initialized;
k_spin_lock_t lock;
} k_vmm_descriptor_t;
int32_t KAPI k_vmm_init(k_vmm_descriptor_t *desc);
int32_t KAPI k_alloc_virtual_address(k_vmm_descriptor_t *desc,
k_virtual_addr_t base,
uint64_t size,
k_virtual_addr_attribute_t attr);
int64_t KAPI k_query_virtual_address(k_vmm_descriptor_t* desc, k_virtual_addr_t v_addr, uint64_t* out);
int64_t KAPI k_free_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t base);
#endif

31
x64/src/kernel/k_alloc.c
View File

@ -1,31 +0,0 @@
#include "g_abi.h"
#include "g_type.h"
#include "k_alloc.h"
#include "k_salloc.h"
#define K_KERNEL_HEAP_SIZE 8192
static _Bool _k_alloc_initialized;
static uint8_t _k_alloc_heap[K_KERNEL_HEAP_SIZE];
void KAPI ke_alloc_init()
{
if (!_k_alloc_initialized)
{
ke_salloc_init(_k_alloc_heap, K_KERNEL_HEAP_SIZE);
_k_alloc_initialized = true;
}
}
void *KAPI ke_alloc(uint32_t size)
{
return _k_alloc_initialized ? ke_salloc(_k_alloc_heap, size) : NULL;
}
void KAPI ke_free(void *ptr)
{
if (_k_alloc_initialized)
{
ke_sfree(_k_alloc_heap, ptr);
}
}

81
x64/src/kernel/k_vmm.c
View File

@ -1,81 +0,0 @@
#include "k_alloc.h"
#include "k_vmm.h"
typedef struct
{
k_avl_tree_node_t tree_node;
k_virtual_addr_attribute_t attribute;
k_virtual_addr_t base;
uint64_t size;
} k_virtual_addr_descriptor_t;
/*
* A comparison function between tree_node and your_node
* Returns:
* < 0 if tree_node < your_node
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
static int32_t base_addr_compare(void *tree_node, void *my_node)
{
k_virtual_addr_descriptor_t *that = OBTAIN_STRUCT_ADDR(tree_node,
k_virtual_addr_descriptor_t,
tree_node);
k_virtual_addr_descriptor_t *mine = OBTAIN_STRUCT_ADDR(my_node,
k_virtual_addr_descriptor_t,
tree_node);
// if overlap, consider them to be the same
if (ke_is_overlap(that->base, that->base + that->size, mine->base, mine->base + mine->size) == 1)
return 0;
else if (that->base < mine->base)
return -1;
else
return 1;
}
int32_t KAPI k_vmm_init(k_vmm_descriptor_t *desc)
{
if (desc == NULL || desc->initialized)
{
return VMM_STATUS_INVALID_ARGUMENTS;
}
ke_avl_tree_init(&desc->region_tree, base_addr_compare);
return VMM_STATUS_SUCCESS;
}
int32_t KAPI k_alloc_virtual_address(k_vmm_descriptor_t *desc,
k_virtual_addr_t base,
uint64_t size,
k_virtual_addr_attribute_t attr)
{
if(desc == NULL || !desc->initialized)
{
return VMM_STATUS_INVALID_ARGUMENTS;
}
k_virtual_addr_descriptor_t* node = ke_alloc(sizeof(k_virtual_addr_descriptor_t));
if(node == NULL)
{
return VMM_STATUS_CANNOT_ALLOC_NODE;
}
node->base =base;
node->size = size;
node->attribute = attr;
ke_avl_tree_insert(&desc->region_tree, &node->tree_node);
return VMM_STATUS_SUCCESS;
}
int64_t KAPI k_query_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t v_addr, uint64_t *out)
{
return 0;
}
int64_t KAPI k_free_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t base)
{
return 0;
}

32
x64/src/kernel/ke/alloc.c Normal file
View File

@ -0,0 +1,32 @@
#include "g_abi.h"
#include "g_type.h"
#include "alloc.h"
#include "salloc.h"
#include "atomic.h"
#define K_KERNEL_HEAP_SIZE 8192
static _Bool alloc_initialized;
static uint8_t alloc_heap[K_KERNEL_HEAP_SIZE];
void KABI ke_alloc_init()
{
if (!alloc_initialized)
{
lb_salloc_init(alloc_heap, K_KERNEL_HEAP_SIZE);
alloc_initialized = true;
}
}
void *KABI ke_alloc(uint32_t size)
{
return alloc_initialized ? lb_salloc(alloc_heap, size) : NULL;
}
void KABI ke_free(void *ptr)
{
if (alloc_initialized)
{
lb_sfree(alloc_heap, ptr);
}
}

4
x64/src/kernel/k_assert.c → x64/src/kernel/ke/assert.c
View File

@ -1,5 +1,5 @@
#include "k_assert.h"
#include "k_print.h"
#include "assert.h"
#include "print.h"
void ke_assert_ex(const char* expr_str, const char* file, int32_t line, int32_t expr)
{

16
x64/src/kernel/k_boot.c → x64/src/kernel/ke/boot.c
View File

@ -3,16 +3,15 @@
* See COPYING under root for details
*/
#include "k_pmm.h"
#include "k_boot.h"
#include "k_alloc.h"
#include "k_intr.h"
#include "pmm.h"
#include "boot.h"
#include "alloc.h"
#include "k_lib_test.h"
extern void KAPI hal_printf(char const *, ...);
extern void KABI hal_printf(char const *, ...);
// returning from this function results in halting the cpu
void KAPI ke_main(k_hal_boot_info_t *boot_info)
void KABI ke_main(boot_info_t *boot_info)
{
if (boot_info == NULL)
{
@ -21,9 +20,8 @@ void KAPI ke_main(k_hal_boot_info_t *boot_info)
return;
}
// init kernel heap
sx_pmm_init(boot_info
->pmm_info);
// init kernel heap
//sx_pmm_init(boot_info->pmm_info);
ke_alloc_init();

6
x64/src/kernel/k_bug_check.c → x64/src/kernel/ke/bug_check.c
View File

@ -1,9 +1,9 @@
#include "k_print.h"
#include "print.h"
#include "g_abi.h"
#include "g_type.h"
#include "k_bug_check.h"
#include "bug_check.h"
void KAPI ke_bug_check(uint64_t reason)
void KABI ke_bug_check(uint64_t reason)
{
ke_printf("BugCheck: Reason - %ul\n", reason);
ke_halt_cpu();

12
x64/src/kernel/ke/inc/alloc.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef _ALLOC_H_
#define _ALLOC_H_
#include "g_abi.h"
#include "g_type.h"
void KABI ke_alloc_init();
void* KABI ke_alloc(uint32_t size);
void KABI ke_free(void *ptr);
#endif

6
x64/src/kernel/inc/k_assert.h → x64/src/kernel/ke/inc/assert.h
View File

@ -1,10 +1,10 @@
#ifndef _K_ASSERT_H_
#define _K_ASSERT_H_
#ifndef _ASSERT_H_
#define _ASSERT_H_
#include "g_type.h"
#include "g_abi.h"
void KAPI ke_assert_ex(const char* expr_str, const char* file, int32_t line, int32_t expr);
void KABI ke_assert_ex(const char* expr_str, const char* file, int32_t line, int32_t expr);
#define ke_assert(expr) ke_assert_ex(#expr, __FILE__, __LINE__, expr)

6
x64/src/kernel/ke/inc/atomic.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef _ATOMIC_H_
#define _ATOMIC_H_
#include "s_atomic.h"
#endif

4
x64/src/kernel/ke/inc/boot.h Normal file
View File

@ -0,0 +1,4 @@
#ifndef _BOOT_H_
#define _BOOT_H_
#include "s_boot.h"
#endif

8
x64/src/kernel/inc/k_bug_check.h → x64/src/kernel/ke/inc/bug_check.h
View File

@ -1,13 +1,13 @@
#ifndef _K_BUG_CHECK_H_
#define _K_BUG_CHECK_H_
#ifndef _BUG_CHECK_H_
#define _BUG_CHECK_H_
#include "g_type.h"
#include "g_abi.h"
#include "k_intr.h"
#include "intr.h"
#define K_BUG_CHECK_IRQL_MISMATCH 0
#define K_BUG_CHECK_PMM_UNALIGNED 1
void KAPI ke_bug_check(uint64_t reason);
void KABI ke_bug_check(uint64_t reason);
#endif

12
x64/src/kernel/ke/inc/intr.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef _INTR_H_
#define _INTR_H_
#include "s_intr.h"
#include "g_type.h"
#include "g_abi.h"
irql_t KABI ke_raise_irql(irql_t irql);
irql_t KABI ke_lower_irql(irql_t irql);
#endif

6
x64/src/kernel/ke/inc/print.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef _PRINTF_H_
#define _PRINTF_H_
#include "s_print.h"
#endif

14
x64/src/kernel/inc/k_rwwlock.h → x64/src/kernel/ke/inc/rwwlock.h
View File

@ -1,6 +1,6 @@
#ifndef _K_RWLOCK_H_
#define _K_RWLOCK_H_
#include "k_spin_lock.h"
#ifndef _RWLOCK_H_
#define _RWLOCK_H_
#include "spin_lock.h"
#include "g_type.h"
typedef struct
@ -23,12 +23,12 @@ void ke_rwwlock_writer_lock(k_rwwlock_t *lock);
void ke_rwwlock_writer_unlock(k_rwwlock_t *lock);
k_irql_t ke_rwwlock_reader_lock_raise_irql(k_rwwlock_t *lock, k_irql_t irql);
irql_t ke_rwwlock_reader_lock_raise_irql(k_rwwlock_t *lock, irql_t irql);
void ke_rwwlock_reader_unlock_lower_irql(k_rwwlock_t *lock, k_irql_t irql);
void ke_rwwlock_reader_unlock_lower_irql(k_rwwlock_t *lock, irql_t irql);
k_irql_t ke_rwwlock_writer_lock_raise_irql(k_rwwlock_t *lock, k_irql_t irql);
irql_t ke_rwwlock_writer_lock_raise_irql(k_rwwlock_t *lock, irql_t irql);
void ke_rwwlock_writer_unlock_lower_irql(k_rwwlock_t *lock, k_irql_t irql);
void ke_rwwlock_writer_unlock_lower_irql(k_rwwlock_t *lock, irql_t irql);
#endif

23
x64/src/kernel/ke/inc/spin_lock.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef _SPIN_LOCK_H_
#define _SPIN_LOCK_H_
#include "g_type.h"
#include "g_abi.h"
#include "intr.h"
typedef struct
{
int32_t val;
} k_spin_lock_t;
void KABI ke_spin_lock_init(k_spin_lock_t *lock);
void KABI ke_spin_lock(k_spin_lock_t *lock);
void KABI ke_spin_unlock(k_spin_lock_t *lock);
irql_t KABI ke_spin_lock_raise_irql(k_spin_lock_t *lock, irql_t irql);
void KABI ke_spin_unlock_lower_irql(k_spin_lock_t *lock, irql_t irql);
#endif

12
x64/src/kernel/inc/k_status.h → x64/src/kernel/ke/inc/status.h
View File

@ -1,8 +1,8 @@
#ifndef _K_STATUS_H_
#define _K_STATUS_H_
#ifndef _STATUS_H_
#define _STATUS_H_
#include "g_type.h"
#include "k_stdlib.h"
#include "sxtdlib.h"
//
// 32 bit ints
@ -28,7 +28,7 @@
#define FACILITY_REF 1
#define FACILITY_PMM 2
typedef enum _k_status_t
enum _status_t
{
STATUS_SUCCESS = SX_MAKE_STATUS(SEVERITY_SUCCESS, FACILITY_GENERIC, 0),
@ -49,6 +49,8 @@ typedef enum _k_status_t
PMM_STATUS_UNINITIALIZED = SX_MAKE_STATUS(SEVERITY_ERROR, FACILITY_PMM, 4),
PMM_STATUS_NOT_ENOUGH_PAGE = SX_MAKE_STATUS(SEVERITY_ERROR, FACILITY_PMM, 5),
} k_status_t;
};
typedef uint32_t status_t;
#endif

8
x64/src/kernel/k_intr.c → x64/src/kernel/ke/intr.c
View File

@ -1,13 +1,13 @@
#include <k_assert.h>
#include "k_intr.h"
#include <assert.h>
#include "intr.h"
k_irql_t KAPI ke_raise_irql(k_irql_t irql)
irql_t KABI ke_raise_irql(irql_t irql)
{
ke_assert(ke_get_irql() <= irql);
return ke_set_irql(irql);
}
k_irql_t KAPI ke_lower_irql(k_irql_t irql)
irql_t KABI ke_lower_irql(irql_t irql)
{
ke_assert(ke_get_irql() >= irql);
return ke_set_irql(irql);

14
x64/src/kernel/k_rwwlock.c → x64/src/kernel/ke/rwwlock.c
View File

@ -1,4 +1,4 @@
#include "k_rwwlock.h"
#include "rwwlock.h"
void ke_rwwlock_init(k_rwwlock_t *lock)
{
@ -70,28 +70,28 @@ void ke_rwwlock_writer_unlock(k_rwwlock_t *lock)
ke_spin_unlock(&lock->w_mutex);
}
k_irql_t ke_rwwlock_reader_lock_raise_irql(k_rwwlock_t *lock, k_irql_t irql)
irql_t ke_rwwlock_reader_lock_raise_irql(k_rwwlock_t *lock, irql_t irql)
{
k_irql_t old_irql = ke_raise_irql(irql);
irql_t old_irql = ke_raise_irql(irql);
ke_rwwlock_reader_lock(lock);
return old_irql;
}
void ke_rwwlock_reader_unlock_lower_irql(k_rwwlock_t *lock, k_irql_t irql)
void ke_rwwlock_reader_unlock_lower_irql(k_rwwlock_t *lock, irql_t irql)
{
ke_rwwlock_reader_unlock(lock);
ke_lower_irql(irql);
return;
}
k_irql_t ke_rwwlock_writer_lock_raise_irql(k_rwwlock_t *lock, k_irql_t irql)
irql_t ke_rwwlock_writer_lock_raise_irql(k_rwwlock_t *lock, irql_t irql)
{
k_irql_t old_irql = ke_raise_irql(irql);
irql_t old_irql = ke_raise_irql(irql);
ke_rwwlock_writer_lock(lock);
return old_irql;
}
void ke_rwwlock_writer_unlock_lower_irql(k_rwwlock_t *lock, k_irql_t irql)
void ke_rwwlock_writer_unlock_lower_irql(k_rwwlock_t *lock, irql_t irql)
{
ke_rwwlock_writer_unlock(lock);
ke_lower_irql(irql);

18
x64/src/kernel/k_spin_lock.c → x64/src/kernel/ke/spin_lock.c
View File

@ -1,8 +1,8 @@
#include <k_spin_lock.h>
#include "k_atomic.h"
#include "k_spin_lock.h"
#include <spin_lock.h>
#include "atomic.h"
#include "spin_lock.h"
void KAPI ke_spin_lock_init(k_spin_lock_t *lock)
void KABI ke_spin_lock_init(k_spin_lock_t *lock)
{
if (lock != NULL)
{
@ -10,7 +10,7 @@ void KAPI ke_spin_lock_init(k_spin_lock_t *lock)
}
}
void KAPI ke_spin_lock(k_spin_lock_t *lock)
void KABI ke_spin_lock(k_spin_lock_t *lock)
{
if (lock != NULL)
{
@ -19,7 +19,7 @@ void KAPI ke_spin_lock(k_spin_lock_t *lock)
return;
}
void KAPI ke_spin_unlock(k_spin_lock_t *lock)
void KABI ke_spin_unlock(k_spin_lock_t *lock)
{
if (lock != NULL)
{
@ -28,9 +28,9 @@ void KAPI ke_spin_unlock(k_spin_lock_t *lock)
return;
}
k_irql_t KAPI ke_spin_lock_raise_irql(k_spin_lock_t *lock, k_irql_t irql)
irql_t KABI ke_spin_lock_raise_irql(k_spin_lock_t *lock, irql_t irql)
{
k_irql_t prev_irql = ke_get_irql();
irql_t prev_irql = ke_get_irql();
if (lock != NULL)
{
ke_raise_irql(irql);
@ -39,7 +39,7 @@ k_irql_t KAPI ke_spin_lock_raise_irql(k_spin_lock_t *lock, k_irql_t irql)
return prev_irql;
}
void KAPI ke_spin_unlock_lower_irql(k_spin_lock_t *lock, k_irql_t irql)
void KABI ke_spin_unlock_lower_irql(k_spin_lock_t *lock, irql_t irql)
{
if (lock != NULL)
{

35
x64/src/kernel/mm/inc/pmm.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef _PMM_H_
#define _PMM_H_
#include "avl_tree.h"
#include "linked_list.h"
#include "g_abi.h"
#include "s_pmm.h"
#include "atomic.h"
#include "status.h"
//#define PMM_PAGE_ATTR_FREE_BIT 0
//#define PMM_PAGE_ATTR_PAGED_BIT 1
//
//typedef struct
//{
// uint32_t attr;
//} k_physical_page_attr_t;
status_t KABI sx_pmm_init(pmm_info_t *info);
status_t KABI mm_alloc_page(physical_addr_t *out);
status_t KABI mm_free_page(physical_addr_t base);
status_t KABI mm_query_page_attr(physical_addr_t base,
int32_t *out);
// TODO: implement these somehow, i might just reserve the first 16MB for these
int32_t KABI mm_alloc_contiguous_pages(uint64_t num_of_page,
physical_addr_t highest_p_addr,
physical_addr_t *out);
int32_t KABI mm_free_contiguous_pages(physical_addr_t base);
#endif

36
x64/src/kernel/mm/inc/vmm.h Normal file
View File

@ -0,0 +1,36 @@
#ifndef _K_VMM_H_
#define _K_VMM_H_
#include "s_vmm.h"
#include "avl_tree.h"
#include "atomic.h"
#include "spin_lock.h"
#define VMM_STATUS_SUCCESS 0
#define VMM_STATUS_INVALID_ARGUMENTS 1
#define VMM_STATUS_CANNOT_ALLOC_NODE 2
typedef struct
{
uint32_t attr;
} virtual_addr_attribute_t;
typedef struct
{
avl_tree_t region_tree;
_Bool initialized;
k_spin_lock_t lock;
} vmm_descriptor_t;
int32_t KABI mm_vmm_init(vmm_descriptor_t *desc);
int32_t KABI mm_alloc_virtual_address(vmm_descriptor_t *desc,
virtual_addr_t base,
uint64_t size,
virtual_addr_attribute_t attr);
int64_t KABI mm_query_virtual_address(vmm_descriptor_t *desc, virtual_addr_t v_addr, uint64_t *out);
int64_t KABI mm_free_virtual_address(vmm_descriptor_t *desc, virtual_addr_t base);
#endif

90
x64/src/kernel/k_pmm.c → x64/src/kernel/mm/pmm.c
View File

@ -1,19 +1,19 @@
#include <k_assert.h>
#include "k_rwwlock.h"
#include "k_status.h"
#include "k_alloc.h"
#include "k_pmm.h"
#include "assert.h"
#include "rwwlock.h"
#include "status.h"
#include "alloc.h"
#include "pmm.h"
typedef struct
{
k_linked_list_node_t free_list_node;
k_avl_tree_node_t avl_tree_node;
k_physical_addr_t base;
linked_list_node_t free_list_node;
avl_tree_node_t avl_tree_node;
physical_addr_t base;
int32_t attr;
} k_physical_page_descriptor_t;
} physical_page_descriptor_t;
static k_avl_tree_t active_tree;
static k_linked_list_t free_list;
static avl_tree_t active_tree;
static linked_list_t free_list;
static k_rwwlock_t lock;
static _Bool initialized;
@ -24,13 +24,13 @@ static _Bool initialized;
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
static int32_t base_addr_compare(void *tree_node, void *my_node)
static int32_t mmp_base_paddr_compare(void *tree_node, void *my_node)
{
k_physical_addr_t tree_base = OBTAIN_STRUCT_ADDR(tree_node,
k_physical_page_descriptor_t,
physical_addr_t tree_base = OBTAIN_STRUCT_ADDR(tree_node,
physical_page_descriptor_t,
avl_tree_node)->base;
k_physical_addr_t my_base = OBTAIN_STRUCT_ADDR(my_node,
k_physical_page_descriptor_t,
physical_addr_t my_base = OBTAIN_STRUCT_ADDR(my_node,
physical_page_descriptor_t,
avl_tree_node)->base;
if (tree_base > my_base)
return 1;
@ -40,7 +40,7 @@ static int32_t base_addr_compare(void *tree_node, void *my_node)
return 0;
}
k_status_t KAPI sx_pmm_init(k_pmm_info_t *info)
status_t KABI sx_pmm_init(pmm_info_t *info)
{
if (info == NULL)
{
@ -53,12 +53,12 @@ k_status_t KAPI sx_pmm_init(k_pmm_info_t *info)
}
ke_rwwlock_init(&lock);
ke_linked_list_init(&free_list);
ke_avl_tree_init(&active_tree, base_addr_compare);
lb_linked_list_init(&free_list);
lb_avl_tree_init(&active_tree, mmp_base_paddr_compare);
for (uint32_t i = 0; i < info->num_of_nodes; i++)
{
k_pmm_node_t *each_node = &info->nodes[i];
pmm_node_t *each_node = &info->nodes[i];
ke_assert (each_node->base % K_PAGE_SIZE != 0);
@ -68,7 +68,7 @@ k_status_t KAPI sx_pmm_init(k_pmm_info_t *info)
// however it's fine as long as we don't touch linked list just yet
// it will use the pages that are already on file to enlarge the kernel heap
// don't worry, be happy :)
k_physical_page_descriptor_t *page_info = ke_alloc(sizeof(k_physical_page_descriptor_t));
physical_page_descriptor_t *page_info = ke_alloc(sizeof(physical_page_descriptor_t));
if (page_info == NULL)
{
@ -76,7 +76,7 @@ k_status_t KAPI sx_pmm_init(k_pmm_info_t *info)
}
page_info->base = each_node->base;
ke_linked_list_push_back(&free_list, &page_info->free_list_node);
lb_linked_list_push_back(&free_list, &page_info->free_list_node);
}
}
initialized = true;
@ -88,7 +88,7 @@ k_status_t KAPI sx_pmm_init(k_pmm_info_t *info)
// potential callers of these, since timer/interrupts queue DPC, which might trigger
// page fault (kernel heap), therefore, it must set IRQL to DISABLED
k_status_t KAPI ke_alloc_page(k_physical_addr_t *out)
status_t KABI mm_alloc_page(physical_addr_t *out)
{
if (!initialized)
{
@ -100,17 +100,17 @@ k_status_t KAPI ke_alloc_page(k_physical_addr_t *out)
return PMM_STATUS_INVALID_ARGUMENTS;
}
k_irql_t irql = ke_rwwlock_writer_lock_raise_irql(&lock, K_IRQL_DISABLED_LEVEL);
k_status_t result = STATUS_SUCCESS;
k_linked_list_node_t *node = NULL;
k_physical_page_descriptor_t *page_info = NULL;
node = ke_linked_list_pop_front(&free_list);
irql_t irql = ke_rwwlock_writer_lock_raise_irql(&lock, K_IRQL_DISABLED_LEVEL);
status_t result = STATUS_SUCCESS;
linked_list_node_t *node = NULL;
physical_page_descriptor_t *page_info = NULL;
node = lb_linked_list_pop_front(&free_list);
if (node != NULL)
{
page_info = OBTAIN_STRUCT_ADDR(node,
k_physical_page_descriptor_t,
physical_page_descriptor_t,
free_list_node);
ke_avl_tree_insert(&active_tree, &page_info->avl_tree_node);
lb_avl_tree_insert(&active_tree, &page_info->avl_tree_node);
*out = page_info->base;
} else
{
@ -121,7 +121,7 @@ k_status_t KAPI ke_alloc_page(k_physical_addr_t *out)
return result;
}
k_status_t KAPI ke_query_page_attr(k_physical_addr_t base,
status_t KABI mm_query_page_attr(physical_addr_t base,
int32_t *out)
{
if (!initialized)
@ -134,18 +134,18 @@ k_status_t KAPI ke_query_page_attr(k_physical_addr_t base,
return PMM_STATUS_INVALID_ARGUMENTS;
}
k_irql_t irql = ke_rwwlock_reader_lock_raise_irql(&lock, K_IRQL_DISABLED_LEVEL);
k_status_t result = STATUS_SUCCESS;
k_avl_tree_node_t *node = NULL;
irql_t irql = ke_rwwlock_reader_lock_raise_irql(&lock, K_IRQL_DISABLED_LEVEL);
status_t result = STATUS_SUCCESS;
avl_tree_node_t *node = NULL;
// search for dummy
k_physical_page_descriptor_t dummy, *page_info = NULL;
physical_page_descriptor_t dummy, *page_info = NULL;
dummy.base = base;
node = ke_avl_tree_delete(&active_tree, &dummy.avl_tree_node);
node = lb_avl_tree_delete(&active_tree, &dummy.avl_tree_node);
if (node != NULL)
{
page_info = OBTAIN_STRUCT_ADDR(node, k_physical_page_descriptor_t, avl_tree_node);
page_info = OBTAIN_STRUCT_ADDR(node, physical_page_descriptor_t, avl_tree_node);
*out = page_info->attr;
} else
{
@ -157,7 +157,7 @@ k_status_t KAPI ke_query_page_attr(k_physical_addr_t base,
return result;
}
k_status_t KAPI ke_free_page(k_physical_addr_t base)
status_t KABI mm_free_page(physical_addr_t base)
{
if (!initialized)
{
@ -165,18 +165,18 @@ k_status_t KAPI ke_free_page(k_physical_addr_t base)
}
// just lock since not sharing with anyone
k_irql_t irql = ke_rwwlock_writer_lock_raise_irql(&lock, K_IRQL_DISABLED_LEVEL);
k_status_t result = STATUS_SUCCESS;
k_avl_tree_node_t *node = NULL;
irql_t irql = ke_rwwlock_writer_lock_raise_irql(&lock, K_IRQL_DISABLED_LEVEL);
status_t result = STATUS_SUCCESS;
avl_tree_node_t *node = NULL;
// search for dummy
k_physical_page_descriptor_t dummy, *page_info;
physical_page_descriptor_t dummy, *page_info;
dummy.base = base;
node = ke_avl_tree_delete(&active_tree, &dummy.avl_tree_node);
node = lb_avl_tree_delete(&active_tree, &dummy.avl_tree_node);
if (node != NULL)
{
page_info = OBTAIN_STRUCT_ADDR(node, k_physical_page_descriptor_t, avl_tree_node);
ke_linked_list_push_back(&free_list, &page_info->free_list_node);
page_info = OBTAIN_STRUCT_ADDR(node, physical_page_descriptor_t, avl_tree_node);
lb_linked_list_push_back(&free_list, &page_info->free_list_node);
} else
{
result = PMM_STATUS_INVALID_ARGUMENTS;

86
x64/src/kernel/mm/vmm.c Normal file
View File

@ -0,0 +1,86 @@
#include "alloc.h"
#include "vmm.h"
typedef struct
{
avl_tree_node_t tree_node;
virtual_addr_attribute_t attribute;
virtual_addr_t base;
uint64_t size;
} virtual_addr_descriptor_t;
/*
* A comparison function between tree_node and your_node
* Returns:
* < 0 if tree_node < your_node
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
static int32_t mmp_base_addr_compare(void *tree_node, void *my_node)
{
virtual_addr_descriptor_t *that = OBTAIN_STRUCT_ADDR(tree_node,
virtual_addr_descriptor_t,
tree_node);
virtual_addr_descriptor_t *mine = OBTAIN_STRUCT_ADDR(my_node,
virtual_addr_descriptor_t,
tree_node);
// if overlap, consider them to be the same
if (lb_is_overlap(that->base, that->base + that->size, mine->base, mine->base + mine->size) == 1)
return 0;
else if (that->base < mine->base)
return -1;
else
return 1;
}
int32_t KABI mm_vmm_init(vmm_descriptor_t *desc)
{
if (desc == NULL || desc->initialized)
{
return VMM_STATUS_INVALID_ARGUMENTS;
}
lb_avl_tree_init(&desc->region_tree, mmp_base_addr_compare);
return VMM_STATUS_SUCCESS;
}
int32_t KABI mm_alloc_virtual_address(vmm_descriptor_t *desc,
virtual_addr_t base,
uint64_t size,
virtual_addr_attribute_t attr)
{
if(desc == NULL || !desc->initialized)
{
return VMM_STATUS_INVALID_ARGUMENTS;
}
virtual_addr_descriptor_t* node = ke_alloc(sizeof(virtual_addr_descriptor_t));
if(node == NULL)
{
return VMM_STATUS_CANNOT_ALLOC_NODE;
}
node->base =base;
node->size = size;
node->attribute = attr;
lb_avl_tree_insert(&desc->region_tree, &node->tree_node);
return VMM_STATUS_SUCCESS;
}
int64_t KABI mm_query_virtual_address(vmm_descriptor_t *desc, virtual_addr_t v_addr, uint64_t *out)
{
UNREFERENCED(desc);
UNREFERENCED(v_addr);
UNREFERENCED(out);
return 0;
}
int64_t KABI mm_free_virtual_address(vmm_descriptor_t *desc, virtual_addr_t base)
{
UNREFERENCED(desc);
UNREFERENCED(base);
return 0;
}

36
x64/src/kernel/rf/inc/ref.h Normal file
View File

@ -0,0 +1,36 @@
#ifndef _K_REF_H_
#define _K_REF_H_
#include "g_type.h"
#include "status.h"
typedef struct
{
int32_t ref_count;
callback_func_t free_routine;
} ref_node_t;
#define K_HANDLE_BASE 0x80000000
//
// All functions are sx since users or kernel devs should not be
// specifying where the allocations take place
//
status_t KABI rf_reference_setup();
status_t KABI rf_reference_create(ref_node_t *ref,
callback_func_t free_func);
status_t KABI rf_reference_obj(ref_node_t *ref);
status_t KABI rf_dereference_obj(ref_node_t *ref);
// HANDLES
status_t KABI sx_open_obj_by_handle(handle_t handle, ref_node_t **out);
status_t KABI sx_create_handle(ref_node_t *ref, handle_t *out);
status_t KABI sx_close_handle(handle_t handle);
#endif

159
x64/src/kernel/k_ref.c → x64/src/kernel/rf/ref.c
View File

@ -1,20 +1,21 @@
#include <k_ref.h>
#include <k_alloc.h>
#include <k_spin_lock.h>
#include <k_assert.h>
#include <k_atomic.h>
#include "k_avl_tree.h"
#include "ref.h"
#include "alloc.h"
#include "spin_lock.h"
#include "assert.h"
#include "atomic.h"
#include "avl_tree.h"
typedef struct
{
k_avl_tree_node_t tree_node;
k_handle_t handle;
k_ref_node_t *ref;
k_callback_func_t free_routine;
} k_handle_node_t;
avl_tree_node_t tree_node;
handle_t handle;
ref_node_t *ref;
callback_func_t free_routine;
} handle_node_t;
static int32_t handle_node_free(void *node, void *up)
static int32_t rfp_handle_node_free(void *node, void *up)
{
UNREFERENCED(up);
ke_free(node);
return 0;
}
@ -23,15 +24,15 @@ static int32_t handle_node_free(void *node, void *up)
// Ke Functions
// ===========================
static k_avl_tree_t _handle_tree;
static bool _initialized;
static k_spin_lock_t _handle_tree_lock;
static int32_t _handle_base;
static avl_tree_t handle_tree;
static bool initialized;
static k_spin_lock_t handle_tree_lock;
static int32_t handle_base;
static int32_t handle_compare(void *tree_node, void *my_node)
static int32_t rfp_handle_compare(void *tree_node, void *my_node)
{
k_handle_node_t *tcb = OBTAIN_STRUCT_ADDR(tree_node, k_handle_node_t, tree_node);
k_handle_node_t *my_tcb = OBTAIN_STRUCT_ADDR(my_node, k_handle_node_t, tree_node);
handle_node_t *tcb = OBTAIN_STRUCT_ADDR(tree_node, handle_node_t, tree_node);
handle_node_t *my_tcb = OBTAIN_STRUCT_ADDR(my_node, handle_node_t, tree_node);
if ((uintptr_t) tcb->handle > (uintptr_t) my_tcb->handle)
return -1;
@ -41,29 +42,29 @@ static int32_t handle_compare(void *tree_node, void *my_node)
return 1;
}
static k_handle_node_t *search_handle_node(k_handle_t handle)
static handle_node_t *rfp_search_handle_node(handle_t handle)
{
k_avl_tree_node_t *result;
k_handle_node_t temp;
avl_tree_node_t *result;
handle_node_t temp;
temp.handle = handle;
result = ke_avl_tree_search(&_handle_tree, &temp.tree_node);
return result == NULL ? NULL : OBTAIN_STRUCT_ADDR(result, k_handle_node_t, tree_node);
result = lb_avl_tree_search(&handle_tree, &temp.tree_node);
return result == NULL ? NULL : OBTAIN_STRUCT_ADDR(result, handle_node_t, tree_node);
}
k_status_t KAPI ke_reference_setup()
status_t KABI rf_reference_setup()
{
if (!_initialized)
if (!initialized)
{
ke_avl_tree_init(&_handle_tree, handle_compare);
ke_spin_lock_init(&_handle_tree_lock);
_handle_base = K_HANDLE_BASE;
_initialized = true;
lb_avl_tree_init(&handle_tree, rfp_handle_compare);
ke_spin_lock_init(&handle_tree_lock);
handle_base = K_HANDLE_BASE;
initialized = true;
}
return STATUS_SUCCESS;
}
k_status_t KAPI ke_reference_create(k_ref_node_t *ref,
k_callback_func_t free_func)
status_t KABI rf_reference_create(ref_node_t *ref,
callback_func_t free_func)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
@ -76,7 +77,7 @@ k_status_t KAPI ke_reference_create(k_ref_node_t *ref,
return STATUS_SUCCESS;
}
k_status_t KAPI ke_reference_obj(k_ref_node_t *ref_node)
status_t KABI rf_reference_obj(ref_node_t *ref_node)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
@ -90,14 +91,14 @@ k_status_t KAPI ke_reference_obj(k_ref_node_t *ref_node)
return STATUS_SUCCESS;
}
k_status_t KAPI ke_dereference_obj(k_ref_node_t *ref_node)
status_t KABI rf_dereference_obj(ref_node_t *ref_node)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (ref_node == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
k_status_t result = STATUS_SUCCESS;
status_t result = STATUS_SUCCESS;
int32_t old_ref_count = ke_interlocked_increment_32(&ref_node->ref_count, -1);
@ -112,11 +113,11 @@ k_status_t KAPI ke_dereference_obj(k_ref_node_t *ref_node)
}
static k_status_t KAPI ke_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out)
static status_t KABI rf_open_obj_by_handle(handle_t handle, ref_node_t **out)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
if (!initialized)
{
return REF_STATUS_UNINITIALIZED;
}
@ -126,13 +127,13 @@ static k_status_t KAPI ke_open_obj_by_handle(k_handle_t handle, k_ref_node_t **o
return REF_STATUS_INVALID_ARGUMENTS;
}
k_irql_t irql;
k_status_t status = STATUS_SUCCESS;
k_ref_node_t *ref = NULL;
irql_t irql;
status_t status = STATUS_SUCCESS;
ref_node_t *ref = NULL;
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, K_IRQL_DPC_LEVEL);
k_handle_node_t *handle_node = search_handle_node(handle);
irql = ke_spin_lock_raise_irql(&handle_tree_lock, K_IRQL_DPC_LEVEL);
handle_node_t *handle_node = rfp_search_handle_node(handle);
if (handle_node == NULL)
{
status = REF_STATUS_INVALID_HANDLE;
@ -146,53 +147,53 @@ static k_status_t KAPI ke_open_obj_by_handle(k_handle_t handle, k_ref_node_t **o
if (SX_SUCCESS(status))
{
// reference the object then return the reference
ke_reference_obj(ref);
rf_reference_obj(ref);
*out = ref;
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
ke_spin_unlock_lower_irql(&handle_tree_lock, irql);
return status;
}
static k_status_t KAPI ke_create_handle(k_ref_node_t *ref,
k_handle_node_t *node,
k_handle_t *out)
static status_t KABI rf_create_handle(ref_node_t *ref,
handle_node_t *node,
handle_t *out)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
if (!initialized)
return REF_STATUS_UNINITIALIZED;
if (ref == NULL || node == NULL || out == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
k_status_t result = STATUS_SUCCESS;
k_irql_t irql;
status_t result = STATUS_SUCCESS;
irql_t irql;
if (SX_SUCCESS(result))
{
// TODO: CHECK OVERFLOW
node->handle = (k_handle_t) ke_interlocked_increment_32(&_handle_base, 1);
node->handle = (handle_t) ke_interlocked_increment_32(&handle_base, 1);
node->ref = ref;
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, K_IRQL_DPC_LEVEL);
k_handle_node_t *existing_node = search_handle_node(node->handle);
irql = ke_spin_lock_raise_irql(&handle_tree_lock, K_IRQL_DPC_LEVEL);
handle_node_t *existing_node = rfp_search_handle_node(node->handle);
if (existing_node == NULL)
{
ke_avl_tree_insert(&_handle_tree, &node->tree_node);
lb_avl_tree_insert(&handle_tree, &node->tree_node);
} else
{
result = REF_STATUS_DUPLICATED_HANDLE;
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
ke_spin_unlock_lower_irql(&handle_tree_lock, irql);
}
if (SX_SUCCESS(result))
{
ke_reference_obj(ref);
rf_reference_obj(ref);
*out = node->handle;
} else
{
@ -202,30 +203,30 @@ static k_status_t KAPI ke_create_handle(k_ref_node_t *ref,
return result;
}
static k_status_t KAPI ke_close_handle(k_handle_t handle)
static status_t KABI rf_close_handle(handle_t handle)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
if (!initialized)
return REF_STATUS_UNINITIALIZED;
k_irql_t irql;
k_status_t status = STATUS_SUCCESS;
k_ref_node_t *ref = NULL;
irql_t irql;
status_t status = STATUS_SUCCESS;
ref_node_t *ref = NULL;
bool free = false;
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, K_IRQL_DPC_LEVEL);
k_handle_node_t *handle_node = search_handle_node(handle);
irql = ke_spin_lock_raise_irql(&handle_tree_lock, K_IRQL_DPC_LEVEL);
handle_node_t *handle_node = rfp_search_handle_node(handle);
if (handle_node == NULL)
{
status = REF_STATUS_INVALID_HANDLE;
} else
{
ref = handle_node->ref;
ke_avl_tree_delete(&_handle_tree, &handle_node->tree_node);
lb_avl_tree_delete(&handle_tree, &handle_node->tree_node);
free = true;
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
ke_spin_unlock_lower_irql(&handle_tree_lock, irql);
if (free)
{
@ -235,7 +236,7 @@ static k_status_t KAPI ke_close_handle(k_handle_t handle)
if (SX_SUCCESS(status))
{
// dereference the object
ke_dereference_obj(ref);
rf_dereference_obj(ref);
}
return status;
@ -243,45 +244,45 @@ static k_status_t KAPI ke_close_handle(k_handle_t handle)
// ===========================
// HW Functions
// SX Functions
// ===========================
k_status_t KAPI sx_create_handle(k_ref_node_t *ref, k_handle_t *out)
status_t KABI sx_create_handle(ref_node_t *ref, handle_t *out)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
if (!initialized)
return REF_STATUS_UNINITIALIZED;
k_handle_node_t *node;
node = (k_handle_node_t *) ke_alloc(sizeof(k_handle_node_t));
handle_node_t *node;
node = (handle_node_t *) ke_alloc(sizeof(handle_node_t));
if (node == NULL)
{
return REF_STATUS_ALLOCATION_FAILED;
}
node->free_routine = handle_node_free;
node->free_routine = rfp_handle_node_free;
return ke_create_handle(ref, node, out);
return rf_create_handle(ref, node, out);
}
k_status_t KAPI sx_close_handle(k_handle_t handle)
status_t KABI sx_close_handle(handle_t handle)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
if (!initialized)
return REF_STATUS_UNINITIALIZED;
// need to keep sx version since need to do handle check here
return ke_close_handle(handle);
return rf_close_handle(handle);
}
k_status_t KAPI sx_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out)
status_t KABI sx_open_obj_by_handle(handle_t handle, ref_node_t **out)
{
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
if (!initialized)
return REF_STATUS_UNINITIALIZED;
if (out == NULL)
@ -297,5 +298,5 @@ k_status_t KAPI sx_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out)
// return STATUS_SUCCESS;
// }
return ke_open_obj_by_handle(handle, out);
return rf_open_obj_by_handle(handle, out);
}

158
x64/src/kernel/k_avl_tree.c → x64/src/lib/avl_tree.c
View File

@ -3,23 +3,23 @@
* See COPYING under root for details
*/
#include "k_avl_tree.h"
#include "avl_tree.h"
static inline int32_t KAPI _avl_tree_node_get_height(k_avl_tree_node_t *node)
static inline int32_t KABI lbp_avl_tree_node_get_height(avl_tree_node_t *node)
{
return node == NULL ? -1 : node->height;
}
static inline int32_t KAPI _avl_tree_node_get_balance_factor(k_avl_tree_node_t *node)
static inline int32_t KABI lbp_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);
return lbp_avl_tree_node_get_height(node->left) - lbp_avl_tree_node_get_height(node->right);
}
static k_avl_tree_node_t *KAPI _avl_tree_node_right_rotate(k_avl_tree_node_t *root)
static avl_tree_node_t *KABI lbp_avl_tree_node_right_rotate(avl_tree_node_t *root)
{
k_avl_tree_node_t *left_children = root->left;
avl_tree_node_t *left_children = root->left;
//adjust parents first
left_children->parent = root->parent;
root->parent = left_children;
@ -29,15 +29,16 @@ static k_avl_tree_node_t *KAPI _avl_tree_node_right_rotate(k_avl_tree_node_t *ro
root->left = root->left->right;
left_children->right = root;
//adjust height
root->height = ke_max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
root->height = lb_max_32(lbp_avl_tree_node_get_height(root->left), lbp_avl_tree_node_get_height(root->right)) + 1;
left_children->height =
ke_max_32(_avl_tree_node_get_height(left_children->left), _avl_tree_node_get_height(left_children->right)) + 1;
lb_max_32(lbp_avl_tree_node_get_height(left_children->left),
lbp_avl_tree_node_get_height(left_children->right)) + 1;
return left_children;
}
static k_avl_tree_node_t *KAPI _avl_tree_node_left_rotate(k_avl_tree_node_t *root)
static avl_tree_node_t *KABI lbp_avl_tree_node_left_rotate(avl_tree_node_t *root)
{
k_avl_tree_node_t *right_children = root->right;
avl_tree_node_t *right_children = root->right;
//adjust parents
right_children->parent = root->parent;
root->parent = right_children;
@ -47,43 +48,44 @@ static k_avl_tree_node_t *KAPI _avl_tree_node_left_rotate(k_avl_tree_node_t *roo
root->right = root->right->left;
right_children->left = root;
root->height = ke_max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
root->height = lb_max_32(lbp_avl_tree_node_get_height(root->left), lbp_avl_tree_node_get_height(root->right)) + 1;
right_children->height =
ke_max_32(_avl_tree_node_get_height(right_children->left), _avl_tree_node_get_height(right_children->right)) +
lb_max_32(lbp_avl_tree_node_get_height(right_children->left),
lbp_avl_tree_node_get_height(right_children->right)) +
1;
return right_children;
}
static k_avl_tree_node_t *KAPI _avl_tree_node_balance(k_avl_tree_node_t *node)
static avl_tree_node_t *KABI lbp_avl_tree_node_balance(avl_tree_node_t *node)
{
const int32_t bf = _avl_tree_node_get_balance_factor(node);
const int32_t bf = lbp_avl_tree_node_get_balance_factor(node);
if (bf > 1)
{
const int32_t left_bf = _avl_tree_node_get_balance_factor(node->left);
const int32_t left_bf = lbp_avl_tree_node_get_balance_factor(node->left);
if (left_bf >= 0)
//left left
return _avl_tree_node_right_rotate(node);
return lbp_avl_tree_node_right_rotate(node);
else
{
//left right
node->left = _avl_tree_node_left_rotate(node->left);
return _avl_tree_node_right_rotate(node);
node->left = lbp_avl_tree_node_left_rotate(node->left);
return lbp_avl_tree_node_right_rotate(node);
}
}
else if (bf < -1)
{
const int32_t right_bf = _avl_tree_node_get_balance_factor(node->right);
const int32_t right_bf = lbp_avl_tree_node_get_balance_factor(node->right);
if (right_bf <= 0)
{
// right right
return _avl_tree_node_left_rotate(node);
return lbp_avl_tree_node_left_rotate(node);
}
else
{
// right left
node->right = _avl_tree_node_right_rotate(node->right);
return _avl_tree_node_left_rotate(node);
node->right = lbp_avl_tree_node_right_rotate(node->right);
return lbp_avl_tree_node_left_rotate(node);
}
}
else
@ -91,9 +93,9 @@ static k_avl_tree_node_t *KAPI _avl_tree_node_balance(k_avl_tree_node_t *node)
}
static k_avl_tree_node_t *KAPI _avl_tree_node_insert(k_avl_tree_node_t *root, k_avl_tree_node_t *node,
k_callback_func_t compare,
k_avl_tree_node_t *parent)
static avl_tree_node_t *KABI lbp_avl_tree_node_insert(avl_tree_node_t *root, avl_tree_node_t *node,
callback_func_t compare,
avl_tree_node_t *parent)
{
if (node == NULL || compare == NULL)
return root;
@ -105,24 +107,24 @@ static k_avl_tree_node_t *KAPI _avl_tree_node_insert(k_avl_tree_node_t *root, k_
const int32_t comp = compare(root, node);
if (comp < 0)
root->right = _avl_tree_node_insert(root->right, node, compare, root);
root->right = lbp_avl_tree_node_insert(root->right, node, compare, root);
else if (comp == 0)
return root;
else
root->left = _avl_tree_node_insert(root->left, node, compare, root);
root->left = lbp_avl_tree_node_insert(root->left, node, compare, root);
root->height = ke_max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
root->height = lb_max_32(lbp_avl_tree_node_get_height(root->left), lbp_avl_tree_node_get_height(root->right)) + 1;
return _avl_tree_node_balance(root);
return lbp_avl_tree_node_balance(root);
}
static void _avl_tree_swap_nodes(k_avl_tree_node_t *node1, k_avl_tree_node_t *node2)
static void lbp_avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
{
if (node1 == NULL || node2 == NULL)
return;
k_avl_tree_node_t *parent = NULL;
k_avl_tree_node_t *child = NULL;
k_avl_tree_node_t *temp = NULL;
avl_tree_node_t *parent = NULL;
avl_tree_node_t *child = NULL;
avl_tree_node_t *temp = NULL;
//swap node but does not change anything else other than node1,node2
if (node1->parent != NULL && node1->parent == node2)
{
@ -238,25 +240,25 @@ static void _avl_tree_swap_nodes(k_avl_tree_node_t *node1, k_avl_tree_node_t *no
return;
}
static k_avl_tree_node_t *KAPI _avl_tree_node_delete(k_avl_tree_node_t *root,
k_avl_tree_node_t *node,
k_callback_func_t compare,
k_avl_tree_node_t **deleted_node)
static avl_tree_node_t *KABI lbp_avl_tree_node_delete(avl_tree_node_t *root,
avl_tree_node_t *node,
callback_func_t compare,
avl_tree_node_t **deleted_node)
{
if (root == NULL || node == NULL || compare == NULL || deleted_node == NULL)
return root;
const int32_t comp = compare(root, node);
if (comp < 0)
root->right = _avl_tree_node_delete(root->right, node, compare, deleted_node);
root->right = lbp_avl_tree_node_delete(root->right, node, compare, deleted_node);
else if (comp > 0)
root->left = _avl_tree_node_delete(root->left, node, compare, deleted_node);
root->left = lbp_avl_tree_node_delete(root->left, node, compare, deleted_node);
else
{
*deleted_node = root;
// node with only one child or no child
if ((root->left == NULL) || (root->right == NULL))
{
k_avl_tree_node_t *child = root->left != NULL ? root->left : root->right;
avl_tree_node_t *child = root->left != NULL ? root->left : root->right;
if (child == NULL)
{ // 0 child
@ -272,39 +274,39 @@ static k_avl_tree_node_t *KAPI _avl_tree_node_delete(k_avl_tree_node_t *root,
{
// node with two children: Get the inorder successor (smallest
// in the right subtree)
k_avl_tree_node_t *successor = ke_avl_tree_larger(root);
avl_tree_node_t *successor = lb_avl_tree_larger(root);
//swap fields
_avl_tree_swap_nodes(successor, root);
lbp_avl_tree_swap_nodes(successor, root);
// Detach the inorder successor
successor->right = _avl_tree_node_delete(successor->right, root, compare, deleted_node);
successor->right = lbp_avl_tree_node_delete(successor->right, root, compare, deleted_node);
root = successor;
}
}
if (root == NULL)
return root;
root->height = ke_max_32(_avl_tree_node_get_height(root->left), _avl_tree_node_get_height(root->right)) + 1;
root = _avl_tree_node_balance(root);
root->height = lb_max_32(lbp_avl_tree_node_get_height(root->left), lbp_avl_tree_node_get_height(root->right)) + 1;
root = lbp_avl_tree_node_balance(root);
return root;
}
static k_avl_tree_node_t *KAPI _avl_tree_node_search(k_avl_tree_node_t *root, k_avl_tree_node_t *node,
k_callback_func_t compare)
static avl_tree_node_t *KABI lbp_avl_tree_node_search(avl_tree_node_t *root, avl_tree_node_t *node,
callback_func_t compare)
{
if (root == NULL || compare == NULL)
return NULL;
const int32_t comp = compare(root, node);
if (comp < 0)
return _avl_tree_node_search(root->right, node, compare);
return lbp_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 lbp_avl_tree_node_search(root->left, node, compare);
}
static void KAPI _avl_tree_node_init(k_avl_tree_node_t *it)
static void KABI lbp_avl_tree_node_init(avl_tree_node_t *it)
{
if (it != NULL)
{
@ -317,11 +319,11 @@ static void KAPI _avl_tree_node_init(k_avl_tree_node_t *it)
}
k_avl_tree_node_t *KAPI ke_avl_tree_smallest(k_avl_tree_t *tree)
avl_tree_node_t *KABI lb_avl_tree_smallest(avl_tree_t *tree)
{
if (tree == NULL)
return NULL;
k_avl_tree_node_t *entry = tree->root;
avl_tree_node_t *entry = tree->root;
if (entry == NULL)
return NULL;
while (entry->left != NULL)
@ -329,11 +331,11 @@ k_avl_tree_node_t *KAPI ke_avl_tree_smallest(k_avl_tree_t *tree)
return entry;
}
k_avl_tree_node_t *KAPI ke_avl_tree_largest(k_avl_tree_t *tree)
avl_tree_node_t *KABI lb_avl_tree_largest(avl_tree_t *tree)
{
if (tree == NULL)
return NULL;
k_avl_tree_node_t *entry = tree->root;
avl_tree_node_t *entry = tree->root;
if (entry == NULL)
return NULL;
while (entry->right != NULL)
@ -342,11 +344,11 @@ k_avl_tree_node_t *KAPI ke_avl_tree_largest(k_avl_tree_t *tree)
}
k_avl_tree_node_t *KAPI ke_avl_tree_larger(k_avl_tree_node_t *it)
avl_tree_node_t *KABI lb_avl_tree_larger(avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
k_avl_tree_node_t *root = it;
avl_tree_node_t *root = it;
if (root->right != NULL)
{
root = root->right;
@ -366,11 +368,11 @@ k_avl_tree_node_t *KAPI ke_avl_tree_larger(k_avl_tree_node_t *it)
}
}
k_avl_tree_node_t *KAPI ke_avl_tree_smaller(k_avl_tree_node_t *it)
avl_tree_node_t *KABI lb_avl_tree_smaller(avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
k_avl_tree_node_t *root = it;
avl_tree_node_t *root = it;
if (root->left != NULL)
{
root = root->left;
@ -390,49 +392,49 @@ k_avl_tree_node_t *KAPI ke_avl_tree_smaller(k_avl_tree_node_t *it)
}
}
k_avl_tree_node_t *KAPI ke_avl_tree_search(k_avl_tree_t *tree, k_avl_tree_node_t *node)
avl_tree_node_t *KABI lb_avl_tree_search(avl_tree_t *tree, avl_tree_node_t *node)
{
return _avl_tree_node_search(tree->root, node, tree->compare);
return lbp_avl_tree_node_search(tree->root, node, tree->compare);
}
void KAPI ke_avl_tree_insert(k_avl_tree_t *tree, k_avl_tree_node_t *data)
void KABI lb_avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *data)
{
if (tree != NULL && data != NULL)
{
_avl_tree_node_init(data);
tree->root = _avl_tree_node_insert(tree->root, data, tree->compare, NULL);
lbp_avl_tree_node_init(data);
tree->root = lbp_avl_tree_node_insert(tree->root, data, tree->compare, NULL);
}
return;
}
k_avl_tree_node_t *KAPI ke_avl_tree_delete(k_avl_tree_t *tree, k_avl_tree_node_t *data)
avl_tree_node_t *KABI lb_avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *data)
{
k_avl_tree_node_t *node = NULL;
avl_tree_node_t *node = NULL;
if (tree != NULL && data != NULL)
{
tree->root = _avl_tree_node_delete(tree->root, data, tree->compare, &node);
tree->root = lbp_avl_tree_node_delete(tree->root, data, tree->compare, &node);
}
return node;
}
int32_t KAPI ke_avl_tree_size(k_avl_tree_t *tree)
int32_t KABI lb_avl_tree_size(avl_tree_t *tree)
{
if (tree == NULL)
return -1;
if (tree->root == NULL)
return 0;
int32_t size = 0;
k_avl_tree_node_t *entry = ke_avl_tree_smallest(tree);
avl_tree_node_t *entry = lb_avl_tree_smallest(tree);
while (entry != NULL)
{
size++;
entry = ke_avl_tree_larger(entry);
entry = lb_avl_tree_larger(entry);
}
return size;
}
void KAPI ke_avl_tree_init(k_avl_tree_t *tree, k_callback_func_t compare)
void KABI lb_avl_tree_init(avl_tree_t *tree, callback_func_t compare)
{
if (tree != NULL)
{
@ -446,19 +448,19 @@ void KAPI ke_avl_tree_init(k_avl_tree_t *tree, k_callback_func_t compare)
// TESTING STUFF
static int32_t KAPI _avl_tree_node_calculate_height(k_avl_tree_node_t *tree)
static int32_t KABI lbp_avl_tree_node_calculate_height(avl_tree_node_t *tree)
{
if (tree == NULL)
return -1;
return ke_max_32(_avl_tree_node_calculate_height(tree->left), _avl_tree_node_calculate_height(tree->right)) + 1;
return lb_max_32(lbp_avl_tree_node_calculate_height(tree->left), lbp_avl_tree_node_calculate_height(tree->right)) + 1;
}
static bool KAPI _avl_tree_node_test(k_avl_tree_node_t *tree, int32_t (*compare)(k_avl_tree_node_t *, k_avl_tree_node_t *))
static bool KABI lbp_avl_tree_node_test(avl_tree_node_t *tree, callback_func_t compare)
{
if (tree == NULL)
return true;
if (_avl_tree_node_get_balance_factor(tree) < -1 || _avl_tree_node_get_balance_factor(tree) > 1 ||
_avl_tree_node_calculate_height(tree) != tree->height)
if (lbp_avl_tree_node_get_balance_factor(tree) < -1 || lbp_avl_tree_node_get_balance_factor(tree) > 1 ||
lbp_avl_tree_node_calculate_height(tree) != tree->height)
return false;
if (tree->left != NULL)
{
@ -476,12 +478,12 @@ static bool KAPI _avl_tree_node_test(k_avl_tree_node_t *tree, int32_t (*compare)
(tree->left != NULL && compare(tree, tree->left) < 0))
return false;
}
return _avl_tree_node_test(tree->left, compare) && _avl_tree_node_test(tree->right, compare);
return lbp_avl_tree_node_test(tree->left, compare) && lbp_avl_tree_node_test(tree->right, compare);
}
bool KAPI ke_avl_tree_validate(k_avl_tree_t *tree)
bool KABI lb_avl_tree_validate(avl_tree_t *tree)
{
if (tree == NULL)
return true;
return _avl_tree_node_test(tree->root, tree->compare);
return lbp_avl_tree_node_test(tree->root, tree->compare);
}

55
x64/src/lib/inc/avl_tree.h Normal file
View File

@ -0,0 +1,55 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _K_AVL_TREE_H_
#define _K_AVL_TREE_H_
#include "g_type.h"
#include "g_abi.h"
#include "sxtdlib.h"
typedef struct _k_avl_tree_node_t
{
struct _k_avl_tree_node_t *left;
struct _k_avl_tree_node_t *right;
struct _k_avl_tree_node_t *parent;
int32_t height;
} avl_tree_node_t;
/*
* A comparison function between tree_node and your_node
* Returns:
* < 0 if tree_node < your_node
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
typedef struct _k_avl_tree_t
{
callback_func_t compare;
avl_tree_node_t *root;
} avl_tree_t;
avl_tree_node_t *KABI lb_avl_tree_search(avl_tree_t *tree, avl_tree_node_t *entry);
void KABI lb_avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *entry);
avl_tree_node_t *KABI lb_avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *entry);
void KABI lb_avl_tree_init(avl_tree_t *tree, callback_func_t compare);
avl_tree_node_t *KABI lb_avl_tree_largest(avl_tree_t *tree);
avl_tree_node_t *KABI lb_avl_tree_smallest(avl_tree_t *tree);
avl_tree_node_t *KABI lb_avl_tree_larger(avl_tree_node_t *entry);
avl_tree_node_t *KABI lb_avl_tree_smaller(avl_tree_node_t *entry);
bool KABI lb_avl_tree_validate(avl_tree_t *tree);
int32_t KABI lb_avl_tree_size(avl_tree_t *tree);
#endif

62
x64/src/lib/inc/linked_list.h Normal file
View File

@ -0,0 +1,62 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _K_LINKED_LIST_H_
#define _K_LINKED_LIST_H_
#include "g_abi.h"
#include "g_type.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_t
{
linked_list_node_t *head;
linked_list_node_t *tail;
} linked_list_t;
/*
* Returns true if current list node == your node
* false otherwise
*/
void KABI lb_linked_list_init(linked_list_t *list);
int32_t KABI lb_linked_list_size(linked_list_t *list);
void KABI lb_linked_list_push_front(linked_list_t *list, linked_list_node_t *node);
void KABI lb_linked_list_push_back(linked_list_t *list, linked_list_node_t *node);
linked_list_node_t *KABI lb_linked_list_pop_front(linked_list_t *list);
linked_list_node_t *KABI lb_linked_list_pop_back(linked_list_t *list);
void KABI lb_linked_list_insert(linked_list_t *list, int32_t index, linked_list_node_t *node);
void KABI lb_linked_list_insert_ref(linked_list_t *list, linked_list_node_t *prev_node, linked_list_node_t *node);
linked_list_node_t *KABI lb_linked_list_remove(linked_list_t *list, int32_t index);
linked_list_node_t *KABI lb_linked_list_remove_ref(linked_list_t *list, linked_list_node_t *node);
linked_list_node_t *KABI lb_linked_list_get(linked_list_t *list, int32_t index);
linked_list_node_t *KABI lb_linked_list_next(linked_list_node_t *node);
linked_list_node_t *KABI lb_linked_list_prev(linked_list_node_t *node);
linked_list_node_t *KABI lb_linked_list_first(linked_list_t *list);
linked_list_node_t *KABI lb_linked_list_last(linked_list_t *list);
int32_t KABI lb_linked_list_search(linked_list_t *list, linked_list_node_t *target,
callback_func_t equals);
#endif

8
x64/src/kernel/inc/k_salloc.h → x64/src/lib/inc/salloc.h
View File

@ -9,13 +9,13 @@
#include "g_abi.h"
#include "g_type.h"
void KAPI ke_salloc_init(void *base, uint32_t size);
void KABI lb_salloc_init(void *base, uint32_t size);
void* KAPI ke_salloc(void *base, uint32_t size);
void* KABI lb_salloc(void *base, uint32_t size);
void KAPI ke_sfree(void *base, void *ptr);
void KABI lb_sfree(void *base, void *ptr);
bool KAPI ke_salloc_assert(void *base, uint32_t *blk_size, bool *blk_free, uint32_t size);
bool KABI lb_salloc_assert(void *base, uint32_t *blk_size, bool *blk_free, uint32_t size);
#endif

52
x64/src/kernel/inc/k_stdlib.h → x64/src/lib/inc/sxtdlib.h
View File

@ -9,55 +9,55 @@
#include "g_abi.h"
#include "g_type.h"
uint32_t KAPI rand( void );
uint32_t KABI rand( void );
void KAPI srand(uint32_t _seed );
void KABI srand(uint32_t _seed );
void KAPI mrand(uint32_t max);
void KABI mrand(uint32_t max);
uint64_t KAPI ke_str_len(char const *str);
uint64_t KABI lb_str_len(char const *str);
uint64_t KAPI ke_str_cmp(char const *str1, char const *str2);
uint64_t KABI lb_str_cmp(char const *str1, char const *str2);
void KAPI ke_mem_copy(void *src, void *dst, uint64_t size);
void KABI lb_mem_copy(void *src, void *dst, uint64_t size);
void KAPI ke_mem_move(void *src, void *dst, uint64_t size);
void KABI lb_mem_move(void *src, void *dst, uint64_t size);
void KAPI ke_mem_set(void *src, int8_t const val, uint64_t size);
void KABI lb_mem_set(void *src, int8_t const val, uint64_t size);
static inline uint64_t KAPI ke_align_down(uint64_t val, uint64_t alignment)
static inline uint64_t KABI lb_align_down(uint64_t val, uint64_t alignment)
{
return (val / alignment) * alignment;
}
static inline uint64_t KAPI ke_align_up(uint64_t val, uint64_t alignment)
static inline uint64_t KABI lb_align_up(uint64_t val, uint64_t alignment)
{
return ((((val) % (alignment)) == 0) ? (((val) / (alignment)) * (alignment)) : (
(((val) / (alignment)) * (alignment)) + 1));
}
static inline uint64_t KAPI ke_is_overlap(uint64_t x1, uint64_t x2, uint64_t y1, uint64_t y2)
static inline uint64_t KABI lb_is_overlap(uint64_t x1, uint64_t x2, uint64_t y1, uint64_t y2)
{
return ((x1 <= y2) && (y1 <= x2)) ? 1 : 0;
}
static inline int64_t KAPI ke_max_64(int64_t a, int64_t b)
static inline int64_t KABI lb_max_64(int64_t a, int64_t b)
{
return (a) > (b) ? a : b;
}
static inline int64_t KAPI ke_min_64(int64_t a, int64_t b)
static inline int64_t KABI lb_min_64(int64_t a, int64_t b)
{
return (a) < (b) ? a : b;
}
static inline int32_t KAPI ke_max_32(int32_t a, int32_t b)
static inline int32_t KABI lb_max_32(int32_t a, int32_t b)
{
return (a) > (b) ? a : b;
}
static inline int32_t KAPI ke_min_32(int32_t a, int32_t b)
static inline int32_t KABI lb_min_32(int32_t a, int32_t b)
{
return (a) < (b) ? a : b;
}
@ -89,46 +89,46 @@ static inline int32_t KAPI ke_min_32(int32_t a, int32_t b)
#define OBTAIN_STRUCT_ADDR(member_addr, struct_name, member_name) ((struct_name*)((void*)(member_addr)-(void*)(&(((struct_name*)0)->member_name))))
static inline uint64_t KAPI ke_bit_mask(uint32_t bit)
static inline uint64_t KABI lb_bit_mask(uint32_t bit)
{
return (uint64_t)1 << bit;
}
static inline uint64_t KAPI ke_bit_field_mask(uint32_t low, uint32_t high)
static inline uint64_t KABI lb_bit_field_mask(uint32_t low, uint32_t high)
{
return ~(~(uint64_t)0 << high << 1) << low;
}
static inline void KAPI ke_bit_map_set(void *bit_map, uint64_t bit)
static inline void KABI lb_bit_map_set(void *bit_map, uint64_t bit)
{
if(bit_map != NULL)
{
uint64_t quot = bit >> 3;
uint32_t rmd = (uint32_t)(bit & ke_bit_field_mask(0, 2));
uint32_t rmd = (uint32_t)(bit & lb_bit_field_mask(0, 2));
*((uint8_t*)(bit_map) + quot) |= (uint8_t) ke_bit_mask(rmd);
*((uint8_t*)(bit_map) + quot) |= (uint8_t) lb_bit_mask(rmd);
}
}
static inline void KAPI ke_bit_map_clear(void *bit_map, uint64_t bit)
static inline void KABI lb_bit_map_clear(void *bit_map, uint64_t bit)
{
if(bit_map != NULL)
{
uint64_t quot = bit >> 3;
uint32_t rmd = (uint32_t)(bit & ke_bit_field_mask(0, 2));
uint32_t rmd = (uint32_t)(bit & lb_bit_field_mask(0, 2));
*((uint8_t*)(bit_map) + quot) &= ~(uint8_t) ke_bit_mask(rmd);
*((uint8_t*)(bit_map) + quot) &= ~(uint8_t) lb_bit_mask(rmd);
}
}
static inline uint32_t KAPI ke_bit_map_read(void *bit_map, uint64_t bit)
static inline uint32_t KABI lb_bit_map_read(void *bit_map, uint64_t bit)
{
if(bit_map != NULL)
{
uint64_t quot = bit >> 3;
uint32_t rmd = (uint32_t)(bit & ke_bit_field_mask(0, 2));
uint32_t rmd = (uint32_t)(bit & lb_bit_field_mask(0, 2));
return (*((uint8_t*)(bit_map) + quot) & (uint8_t) ke_bit_mask(rmd)) == 0 ? 0 : 1;
return (*((uint8_t*)(bit_map) + quot) & (uint8_t) lb_bit_mask(rmd)) == 0 ? 0 : 1;
}
return 0;
}

96
x64/src/kernel/k_linked_list.c → x64/src/lib/linked_list.c
View File

@ -3,9 +3,9 @@
* See COPYING under root for details
*/
#include "k_linked_list.h"
#include "linked_list.h"
static void KAPI _init_linked_list_node(k_linked_list_node_t *node)
static void KABI lbp_init_linked_list_node(linked_list_node_t *node)
{
if (node != NULL)
{
@ -15,12 +15,12 @@ static void KAPI _init_linked_list_node(k_linked_list_node_t *node)
return;
}
static void KAPI _append_node(k_linked_list_node_t *target, k_linked_list_node_t *node)
static void KABI lbp_append_node(linked_list_node_t *target, linked_list_node_t *node)
{
if(target == NULL || node == NULL)
return;
k_linked_list_node_t* next = target->next;
linked_list_node_t* next = target->next;
// update the next node
if(next != NULL)
{
@ -38,12 +38,12 @@ static void KAPI _append_node(k_linked_list_node_t *target, k_linked_list_node_t
}
// link target with node, suppose target is in the current list
static void KAPI _prepend_node(k_linked_list_node_t *target, k_linked_list_node_t *node)
static void KABI lbp_prepend_node(linked_list_node_t *target, linked_list_node_t *node)
{
if(target == NULL || node == NULL)
return;
k_linked_list_node_t* prev = target->prev;
linked_list_node_t* prev = target->prev;
// update the prev node
if(prev != NULL)
{
@ -60,7 +60,7 @@ static void KAPI _prepend_node(k_linked_list_node_t *target, k_linked_list_node_
return;
}
static void KAPI _unlink_node(k_linked_list_node_t* node)
static void KABI lbp_unlink_node(linked_list_node_t *node)
{
if(node == NULL)
return;
@ -78,7 +78,7 @@ static void KAPI _unlink_node(k_linked_list_node_t* node)
return;
}
void KAPI ke_linked_list_init(k_linked_list_t *list)
void KABI lb_linked_list_init(linked_list_t *list)
{
if (list != NULL)
{
@ -88,7 +88,7 @@ void KAPI ke_linked_list_init(k_linked_list_t *list)
return;
}
int32_t KAPI ke_linked_list_size(k_linked_list_t *list)
int32_t KABI lb_linked_list_size(linked_list_t *list)
{
if (list == NULL)
return -1;
@ -96,8 +96,8 @@ int32_t KAPI ke_linked_list_size(k_linked_list_t *list)
return 0;
int32_t size = 1;
k_linked_list_node_t *cur_node = list->head;
k_linked_list_node_t *tail = list->tail;
linked_list_node_t *cur_node = list->head;
linked_list_node_t *tail = list->tail;
while ((cur_node != tail) && ((cur_node = cur_node->next) != NULL))
{
size++;
@ -105,57 +105,57 @@ int32_t KAPI ke_linked_list_size(k_linked_list_t *list)
return size;
}
void KAPI ke_linked_list_push_front(k_linked_list_t *list, k_linked_list_node_t *node)
void KABI lb_linked_list_push_front(linked_list_t *list, linked_list_node_t *node)
{
if (list == NULL || node == NULL)
return;
_init_linked_list_node(node);
lbp_init_linked_list_node(node);
ke_linked_list_insert_ref(list, NULL, node);
lb_linked_list_insert_ref(list, NULL, node);
return;
}
void KAPI ke_linked_list_push_back(k_linked_list_t *list, k_linked_list_node_t *node)
void KABI lb_linked_list_push_back(linked_list_t *list, linked_list_node_t *node)
{
if (list == NULL || node == NULL)
return;
_init_linked_list_node(node);
lbp_init_linked_list_node(node);
ke_linked_list_insert_ref(list, list->tail, node);
lb_linked_list_insert_ref(list, list->tail, node);
return;
}
k_linked_list_node_t *KAPI ke_linked_list_pop_front(k_linked_list_t *list)
linked_list_node_t *KABI lb_linked_list_pop_front(linked_list_t *list)
{
if (list == NULL)
return NULL;
return ke_linked_list_remove_ref(list, list->head);
return lb_linked_list_remove_ref(list, list->head);
}
k_linked_list_node_t *KAPI ke_linked_list_pop_back(k_linked_list_t *list)
linked_list_node_t *KABI lb_linked_list_pop_back(linked_list_t *list)
{
if (list == NULL)
return NULL;
return ke_linked_list_remove_ref(list, list->tail);
return lb_linked_list_remove_ref(list, list->tail);
}
void KAPI ke_linked_list_insert_ref(k_linked_list_t *list, k_linked_list_node_t *prev_node, k_linked_list_node_t *node)
void KABI lb_linked_list_insert_ref(linked_list_t *list, linked_list_node_t *prev_node, linked_list_node_t *node)
{
if (list == NULL || node == NULL)
return;
_init_linked_list_node(node);
lbp_init_linked_list_node(node);
if (prev_node == NULL)
{
// if prev_node is NULL, then we are inserting to the head
// linked node with list->head
_prepend_node(list->head, node);
lbp_prepend_node(list->head, node);
if (list->tail == NULL)
{
@ -170,7 +170,7 @@ void KAPI ke_linked_list_insert_ref(k_linked_list_t *list, k_linked_list_node_t
// if prev_node is not NULL, we are inserting to the middle or the end
// linked node with the prev_node
_append_node(prev_node, node);
lbp_append_node(prev_node, node);
if (node->next == NULL)
{
@ -180,46 +180,46 @@ void KAPI ke_linked_list_insert_ref(k_linked_list_t *list, k_linked_list_node_t
}
}
void KAPI ke_linked_list_insert(k_linked_list_t *list, int32_t index, k_linked_list_node_t *node)
void KABI lb_linked_list_insert(linked_list_t *list, int32_t index, linked_list_node_t *node)
{
if (list == NULL || index < 0 || node == NULL)
return;
k_linked_list_node_t *prev_node = ke_linked_list_get(list, index - 1);
_init_linked_list_node(node);
linked_list_node_t *prev_node = lb_linked_list_get(list, index - 1);
lbp_init_linked_list_node(node);
if (prev_node == NULL)
{
if (index == 0)
{
ke_linked_list_insert_ref(list, NULL, node);
lb_linked_list_insert_ref(list, NULL, node);
}
}
else
{
ke_linked_list_insert_ref(list, prev_node, node);
lb_linked_list_insert_ref(list, prev_node, node);
}
return;
}
k_linked_list_node_t *KAPI ke_linked_list_remove(k_linked_list_t *list, int32_t index)
linked_list_node_t *KABI lb_linked_list_remove(linked_list_t *list, int32_t index)
{
if (list == NULL || index < 0)
return NULL;
k_linked_list_node_t *cur_node = ke_linked_list_get(list, index);
linked_list_node_t *cur_node = lb_linked_list_get(list, index);
if (cur_node == NULL)
return NULL;
return ke_linked_list_remove_ref(list, cur_node);
return lb_linked_list_remove_ref(list, cur_node);
}
k_linked_list_node_t *KAPI ke_linked_list_remove_ref(k_linked_list_t *list, k_linked_list_node_t *node)
linked_list_node_t *KABI lb_linked_list_remove_ref(linked_list_t *list, linked_list_node_t *node)
{
if (list == NULL || node == NULL)
return NULL;
_unlink_node(node);
lbp_unlink_node(node);
if(node->next == NULL)
{
@ -231,21 +231,21 @@ k_linked_list_node_t *KAPI ke_linked_list_remove_ref(k_linked_list_t *list, k_li
list->head = node->next;
}
_init_linked_list_node(node);
lbp_init_linked_list_node(node);
return node;
}
k_linked_list_node_t *KAPI ke_linked_list_get(k_linked_list_t *list, int32_t index)
linked_list_node_t *KABI lb_linked_list_get(linked_list_t *list, int32_t index)
{
if (list == NULL || index < 0 || list->head == NULL)
return NULL;
k_linked_list_node_t *cur_node = list->head;
linked_list_node_t *cur_node = list->head;
while (index-- && (cur_node = cur_node->next) != NULL);
return cur_node;
}
k_linked_list_node_t *KAPI ke_linked_list_next(k_linked_list_node_t *node)
linked_list_node_t *KABI lb_linked_list_next(linked_list_node_t *node)
{
if (node != NULL)
{
@ -254,7 +254,7 @@ k_linked_list_node_t *KAPI ke_linked_list_next(k_linked_list_node_t *node)
return node;
}
k_linked_list_node_t *KAPI ke_linked_list_prev(k_linked_list_node_t *node)
linked_list_node_t *KABI lb_linked_list_prev(linked_list_node_t *node)
{
if (node != NULL)
{
@ -263,9 +263,9 @@ k_linked_list_node_t *KAPI ke_linked_list_prev(k_linked_list_node_t *node)
return node;
}
k_linked_list_node_t *KAPI ke_linked_list_first(k_linked_list_t *list)
linked_list_node_t *KABI lb_linked_list_first(linked_list_t *list)
{
k_linked_list_node_t *result = NULL;
linked_list_node_t *result = NULL;
if (list != NULL)
{
result = list->head;
@ -273,9 +273,9 @@ k_linked_list_node_t *KAPI ke_linked_list_first(k_linked_list_t *list)
return result;
}
k_linked_list_node_t *KAPI ke_linked_list_last(k_linked_list_t *list)
linked_list_node_t *KABI lb_linked_list_last(linked_list_t *list)
{
k_linked_list_node_t *result = NULL;
linked_list_node_t *result = NULL;
if (list != NULL)
{
result = list->tail;
@ -283,13 +283,13 @@ k_linked_list_node_t *KAPI ke_linked_list_last(k_linked_list_t *list)
return result;
}
int32_t KAPI ke_linked_list_search(k_linked_list_t *list, k_linked_list_node_t *target,
k_callback_func_t equals)
int32_t KABI lb_linked_list_search(linked_list_t *list, linked_list_node_t *target,
callback_func_t equals)
{
if(list == NULL || target == NULL)
return -1;
int32_t result = 0;
k_linked_list_node_t* node = ke_linked_list_first(list);
linked_list_node_t* node = lb_linked_list_first(list);
while(node != NULL)
{
if(equals != NULL)
@ -307,7 +307,7 @@ int32_t KAPI ke_linked_list_search(k_linked_list_t *list, k_linked_list_node_t *
}
}
result++;
node = ke_linked_list_next(node);
node = lb_linked_list_next(node);
}
return -1;

90
x64/src/kernel/k_salloc.c → x64/src/lib/salloc.c
View File

@ -5,7 +5,7 @@
#include "g_abi.h"
#include "g_type.h"
#include "k_stdlib.h"
#include "sxtdlib.h"
typedef union
{
@ -17,65 +17,65 @@ typedef union
#define ALLOC_HEADER_FLAG_FREE 0
#define ALLOC_HEADER_FLAG_LAST 1
static void _set_salloc_header_size(_salloc_header *header, uint32_t size)
static void lbp_set_salloc_header_size(_salloc_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 &= ~(uint32_t) ke_bit_field_mask(ALLOC_FLAG_NUM, 31);
header->size &= ~(uint32_t) lb_bit_field_mask(ALLOC_FLAG_NUM, 31);
// set bits
header->size |= size;
return;
}
static uint32_t _read_salloc_header_size(_salloc_header *header)
static uint32_t lbp_read_salloc_header_size(_salloc_header *header)
{
return header->size >> ALLOC_FLAG_NUM;
}
static uint32_t _read_salloc_header_flag(_salloc_header *header, uint32_t bit)
static uint32_t lbp_read_salloc_header_flag(_salloc_header *header, uint32_t bit)
{
return (header->flags & (uint32_t) ke_bit_mask(bit)) == 0 ? 0 : 1;
return (header->flags & (uint32_t) lb_bit_mask(bit)) == 0 ? 0 : 1;
}
static void _set_salloc_header_flag(_salloc_header *header, uint32_t bit, uint32_t value)
static void lbp_set_salloc_header_flag(_salloc_header *header, uint32_t bit, uint32_t value)
{
value &= (uint32_t) ke_bit_mask(0);
value &= (uint32_t) lb_bit_mask(0);
if (value == 1)
{
header->flags |= (uint32_t) ke_bit_mask(bit);
header->flags |= (uint32_t) lb_bit_mask(bit);
}
else
{
header->flags &= ~(uint32_t) ke_bit_mask(bit);
header->flags &= ~(uint32_t) lb_bit_mask(bit);
}
return;
}
static void _salloc_join(void *base)
static void lbp_salloc_join(void *base)
{
if (base != NULL)
{
char *c_ptr = (char *) base;
while (1)
{
uint32_t c_blk_free = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t c_blk_last = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t c_blk_size = _read_salloc_header_size((_salloc_header *) c_ptr);
uint32_t c_blk_free = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t c_blk_last = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t c_blk_size = lbp_read_salloc_header_size((_salloc_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_salloc_header_flag((_salloc_header *) n_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t n_blk_last = _read_salloc_header_flag((_salloc_header *) n_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t n_blk_size = _read_salloc_header_size((_salloc_header *) n_ptr);
uint32_t n_blk_free = lbp_read_salloc_header_flag((_salloc_header *) n_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t n_blk_last = lbp_read_salloc_header_flag((_salloc_header *) n_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t n_blk_size = lbp_read_salloc_header_size((_salloc_header *) n_ptr);
if (n_blk_free == 1)
{
// logically gone
_set_salloc_header_size((_salloc_header *) c_ptr, n_blk_size + c_blk_size);
_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST, n_blk_last);
lbp_set_salloc_header_size((_salloc_header *) c_ptr, n_blk_size + c_blk_size);
lbp_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST, n_blk_last);
continue;
}
}
@ -92,7 +92,7 @@ static void _salloc_join(void *base)
}
}
bool KAPI ke_salloc_assert(void *base, uint32_t *blk_size, bool *blk_free, uint32_t size)
bool KABI lb_salloc_assert(void *base, uint32_t *blk_size, bool *blk_free, uint32_t size)
{
if (base == NULL || blk_free == NULL || blk_size == NULL)
return NULL;
@ -100,9 +100,9 @@ bool KAPI ke_salloc_assert(void *base, uint32_t *blk_size, bool *blk_free, uint3
char *c_ptr = (char *) base;
while (1)
{
uint32_t cur_blk_free = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_last = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_size = _read_salloc_header_size((_salloc_header *) c_ptr);
uint32_t cur_blk_free = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_last = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_size = lbp_read_salloc_header_size((_salloc_header *) c_ptr);
if (cur_blk_free != blk_free[i] || cur_blk_size != blk_size[i])
{
return false;
@ -119,19 +119,19 @@ bool KAPI ke_salloc_assert(void *base, uint32_t *blk_size, bool *blk_free, uint3
}
}
void KAPI ke_salloc_init(void *base, uint32_t size)
void KABI lb_salloc_init(void *base, uint32_t size)
{
if (base != NULL && size >= sizeof(_salloc_header))
{
_salloc_header *ptr = (_salloc_header *) base;
_set_salloc_header_size(ptr, size);
_set_salloc_header_flag(ptr, ALLOC_HEADER_FLAG_FREE, 1);
_set_salloc_header_flag(ptr, ALLOC_HEADER_FLAG_LAST, 1);
lbp_set_salloc_header_size(ptr, size);
lbp_set_salloc_header_flag(ptr, ALLOC_HEADER_FLAG_FREE, 1);
lbp_set_salloc_header_flag(ptr, ALLOC_HEADER_FLAG_LAST, 1);
}
return;
}
void *KAPI ke_salloc(void *base, uint32_t size)
void *KABI lb_salloc(void *base, uint32_t size)
{
void *result = NULL;
if (base != NULL && size != 0)
@ -140,9 +140,9 @@ void *KAPI ke_salloc(void *base, uint32_t size)
char *c_ptr = (char *) base;
while (1)
{
uint32_t cur_blk_free = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_size = _read_salloc_header_size((_salloc_header *) c_ptr);
uint32_t cur_blk_last = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_free = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_size = lbp_read_salloc_header_size((_salloc_header *) c_ptr);
uint32_t cur_blk_last = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
if (cur_blk_free == 0 || cur_blk_size < total_size)
{
//if cur block not a free block
@ -161,21 +161,21 @@ void *KAPI ke_salloc(void *base, uint32_t size)
{
// since the space left is not enough for salloc_header
// we alloc the whole block
_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
lbp_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
}
else
{
// we split the block here
// set properties for the first block
_set_salloc_header_size((_salloc_header *) c_ptr, total_size);
_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST, 0);
_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
lbp_set_salloc_header_size((_salloc_header *) c_ptr, total_size);
lbp_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST, 0);
lbp_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 0);
// set properties for the second block
_set_salloc_header_size((_salloc_header *) (c_ptr + total_size), cur_blk_size - total_size);
_set_salloc_header_flag((_salloc_header *) (c_ptr + total_size), ALLOC_HEADER_FLAG_LAST,
cur_blk_last);
_set_salloc_header_flag((_salloc_header *) (c_ptr + total_size), ALLOC_HEADER_FLAG_FREE, 1);
lbp_set_salloc_header_size((_salloc_header *) (c_ptr + total_size), cur_blk_size - total_size);
lbp_set_salloc_header_flag((_salloc_header *) (c_ptr + total_size), ALLOC_HEADER_FLAG_LAST,
cur_blk_last);
lbp_set_salloc_header_flag((_salloc_header *) (c_ptr + total_size), ALLOC_HEADER_FLAG_FREE, 1);
}
// return the pointer, skip the alloc header
result = c_ptr + sizeof(_salloc_header);
@ -186,22 +186,22 @@ void *KAPI ke_salloc(void *base, uint32_t size)
return result;
}
void KAPI ke_sfree(void *base, void *ptr)
void KABI lb_sfree(void *base, void *ptr)
{
if (base != NULL && ptr != NULL)
{
char *c_ptr = (char *) base;
while (1)
{
uint32_t cur_blk_free = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_last = _read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_size = _read_salloc_header_size((_salloc_header *) c_ptr);
uint32_t cur_blk_free = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE);
uint32_t cur_blk_last = lbp_read_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_LAST);
uint32_t cur_blk_size = lbp_read_salloc_header_size((_salloc_header *) c_ptr);
if (cur_blk_free == 0 && ptr == c_ptr + sizeof(_salloc_header))
{
// we found the block, mark it as free
_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 1);
lbp_set_salloc_header_flag((_salloc_header *) c_ptr, ALLOC_HEADER_FLAG_FREE, 1);
// merge blocks
_salloc_join(base);
lbp_salloc_join(base);
break;
}

24
x64/src/kernel/k_stdlib.c → x64/src/lib/sxtdlib.c
View File

@ -5,9 +5,9 @@
#include "g_type.h"
#include "g_abi.h"
#include "k_stdlib.h"
#include "sxtdlib.h"
void KAPI ke_mem_copy(void *src, void *dst, uint64_t size)
void KABI lb_mem_copy(void *src, void *dst, uint64_t size)
{
if (src == NULL || dst == NULL)
return;
@ -18,7 +18,7 @@ void KAPI ke_mem_copy(void *src, void *dst, uint64_t size)
return;
}
void KAPI ke_mem_set(void *src, int8_t const val, uint64_t size)
void KABI lb_mem_set(void *src, int8_t const val, uint64_t size)
{
if (src == NULL)
return;
@ -27,13 +27,13 @@ void KAPI ke_mem_set(void *src, int8_t const val, uint64_t size)
return;
}
void KAPI ke_mem_move(void *src, void *dst, uint64_t size)
void KABI lb_mem_move(void *src, void *dst, uint64_t size)
{
if (src == NULL || dst == NULL)
return;
if (src >= dst)
{
return ke_mem_copy(src, dst, size);
return lb_mem_copy(src, dst, size);
}
src += size;
dst += size;
@ -48,18 +48,18 @@ void KAPI ke_mem_move(void *src, void *dst, uint64_t size)
static uint32_t seed = 1;
static uint32_t max = 16777215;
uint32_t KAPI rand( void )
uint32_t KABI rand( void )
{
seed = seed * 1103512986 + 29865;
return (unsigned int)(seed / 65536) % (max+1);
}
void KAPI srand( uint32_t _seed )
void KABI srand( uint32_t _seed )
{
seed = _seed;
}
void KAPI mrand(uint32_t _max)
void KABI mrand(uint32_t _max)
{
max = _max;
}
@ -68,7 +68,7 @@ void KAPI mrand(uint32_t _max)
// String Library
//
uint64_t KAPI ke_str_len(char const *str)
uint64_t KABI lb_str_len(char const *str)
{
uint64_t length = 0;
if(str == NULL)
@ -81,12 +81,12 @@ uint64_t KAPI ke_str_len(char const *str)
return length;
}
uint64_t KAPI ke_str_cmp(char const *str1, char const *str2)
uint64_t KABI rtl_str_cmp(char const *str1, char const *str2)
{
if(str1 == NULL || str2 == NULL)
return 0;
uint64_t length = ke_str_len(str1);
if(length != ke_str_len(str2))
uint64_t length = lb_str_len(str1);
if(length != lb_str_len(str2))
return 0;
while(length--)
{

6
x64/src/test/inc/k_lib_test.h
View File

@ -1,10 +1,10 @@
#ifndef _LIB_TEST_H_
#define _LIB_TEST_H_
void KAPI linked_list_test(void);
void KABI linked_list_test(void);
void KAPI avl_tree_test(void);
void KABI avl_tree_test(void);
void KAPI salloc_test(void);
void KABI salloc_test(void);
#endif

8
x64/src/test/inc/k_test_driver.h
View File

@ -4,12 +4,12 @@
#include "g_type.h"
#include "g_abi.h"
void KAPI test_begin(char *name);
void KABI test_begin(char *name);
void KAPI test_end();
void KABI test_end();
void *KAPI talloc(uint32_t size);
void *KABI talloc(uint32_t size);
void KAPI run_case(char *name, bool result);
void KABI run_case(char *name, bool result);
#endif

474
x64/src/test/k_avl_tree_test.c
View File

@ -1,9 +1,9 @@
#include "k_test_driver.h"
#include "k_avl_tree.h"
#include "../lib/inc/avl_tree.h"
typedef struct
{
k_avl_tree_node_t tree_entry;
avl_tree_node_t tree_entry;
int val;
} int_tree_node;
@ -14,8 +14,10 @@ static int_tree_node *create_tree_node(int val)
return rs;
}
static int compare(k_avl_tree_node_t *root, k_avl_tree_node_t *node)
static int32_t compare(void *root1, void *node1)
{
avl_tree_node_t *root = (avl_tree_node_t*)node1;
avl_tree_node_t *node = (avl_tree_node_t*)root1;
int_tree_node *rooti = OBTAIN_STRUCT_ADDR(root, int_tree_node, tree_entry);
int_tree_node *nodei = OBTAIN_STRUCT_ADDR(node, int_tree_node, tree_entry);
return rooti->val - nodei->val;
@ -40,7 +42,7 @@ static int compare(k_avl_tree_node_t *root, k_avl_tree_node_t *node)
static int counter = 0;
static bool _pre_order_assert(k_avl_tree_node_t *node, int order[], int size)
static bool _pre_order_assert(avl_tree_node_t *node, int order[], int size)
{
if (node == NULL)
return true;
@ -59,7 +61,7 @@ static bool _pre_order_assert(k_avl_tree_node_t *node, int order[], int size)
return result;
}
static bool pre_order_assert(k_avl_tree_t *node, int order[], int size)
static bool pre_order_assert(avl_tree_t *node, int order[], int size)
{
counter = 0;
return _pre_order_assert(node->root, order, size);
@ -76,19 +78,19 @@ static bool insert_simple_l()
// 3
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
int val1[] = {1, 2};
result = result && pre_order_assert(&tree, val1, 2);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_simple_r()
@ -100,19 +102,19 @@ static bool insert_simple_r()
//1
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
int val1[] = {3, 2};
result = result && pre_order_assert(&tree, val1, 2);
ke_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_simple_ll()
@ -123,19 +125,19 @@ static bool insert_simple_ll()
// /
//3
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
int val1[] = {2, 4};
result = result && pre_order_assert(&tree, val1, 2);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_simple_rr()
@ -146,19 +148,19 @@ static bool insert_simple_rr()
// \
// 3
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
int val1[] = {4, 2};
result = result && pre_order_assert(&tree, val1, 2);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_complex_1()
@ -171,22 +173,22 @@ static bool insert_complex_1()
// \ /
// 15 3
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
int val1[] = {20, 4, 3, 9, 26};
result = result && pre_order_assert(&tree, val1, 5);
ke_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
int val2[] = {9, 4, 3, 20, 15, 26};
result = result && pre_order_assert(&tree, val2, 6);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_complex_2()
@ -199,22 +201,22 @@ static bool insert_complex_2()
// / / \
// 8 3 8
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
int val1[] = {20, 4, 3, 9, 26};
result = result && pre_order_assert(&tree, val1, 5);
ke_avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
int val2[] = {9, 4, 3, 8, 20, 26};
result = result && pre_order_assert(&tree, val2, 6);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_complex_3()
@ -229,27 +231,27 @@ static bool insert_complex_3()
// \ /
// 15 2
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
ke_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
int val2[] = {9, 4, 3, 2, 7, 20, 11, 15, 26, 21, 30};
result = result && pre_order_assert(&tree, val2, 11);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_complex_4()
@ -264,27 +266,27 @@ static bool insert_complex_4()
// \ / \
// 8 2 8
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
ke_avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
int val2[] = {9, 4, 3, 2, 7, 8, 20, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val2, 11);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool insert_duplicate()
@ -299,29 +301,29 @@ static bool insert_duplicate()
// \ / \
// 8 2 8
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
result = result && pre_order_assert(&tree, val1, 10);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
@ -334,23 +336,23 @@ static bool delete_simple_l()
// 4
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(1);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
int val1[] = {2, 1, 3, 4};
result = result && pre_order_assert(&tree, val1, 4);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_simple_r()
@ -362,23 +364,23 @@ static bool delete_simple_r()
//1
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(4);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
int val1[] = {3, 2, 1, 4};
result = result && pre_order_assert(&tree, val1, 4);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_simple_ll()
@ -389,23 +391,23 @@ static bool delete_simple_ll()
// /
// 3
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(1);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
int val1[] = {2, 1, 4, 3};
result = result && pre_order_assert(&tree, val1, 4);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_simple_rr()
@ -416,23 +418,23 @@ static bool delete_simple_rr()
// \
// 1
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(4);
ke_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
int val1[] = {3, 2, 1, 4};
result = result && pre_order_assert(&tree, val1, 4);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_complex_1()
@ -447,19 +449,19 @@ static bool delete_complex_1()
// Result:
// empty tree
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(10);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
int val1[] = {10};
result = result && pre_order_assert(&tree, val1, 1);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
result = result && pre_order_assert(&tree, val1, 0);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_complex_2()
@ -485,24 +487,24 @@ static bool delete_complex_2()
// 35
//
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(20);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
int val1[] = {20, 10, 30, 25, 35};
result = result && pre_order_assert(&tree, val1, 5);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {25, 10, 30, 35};
result = result && pre_order_assert(&tree, val2, 4);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_complex_3()
@ -524,25 +526,25 @@ static bool delete_complex_3()
// / /
// 5 25
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(10);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {20, 15, 5, 30, 25};
result = result && pre_order_assert(&tree, val2, 5);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_complex_4()
@ -563,8 +565,8 @@ static bool delete_complex_4()
// 20
//
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *delete5 = create_tree_node(5);
int_tree_node *delete10 = create_tree_node(10);
@ -573,25 +575,25 @@ static bool delete_complex_4()
int_tree_node *delete30 = create_tree_node(30);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &delete10->tree_entry);
ke_avl_tree_insert(&tree, &delete30->tree_entry);
ke_avl_tree_insert(&tree, &delete5->tree_entry);
ke_avl_tree_insert(&tree, &delete15->tree_entry);
ke_avl_tree_insert(&tree, &delete25->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &delete10->tree_entry);
lb_avl_tree_insert(&tree, &delete30->tree_entry);
lb_avl_tree_insert(&tree, &delete5->tree_entry);
lb_avl_tree_insert(&tree, &delete15->tree_entry);
lb_avl_tree_insert(&tree, &delete25->tree_entry);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
ke_avl_tree_delete(&tree, &delete5->tree_entry);
ke_avl_tree_delete(&tree, &delete15->tree_entry);
ke_avl_tree_delete(&tree, &delete25->tree_entry);
ke_avl_tree_delete(&tree, &delete10->tree_entry);
ke_avl_tree_delete(&tree, &delete30->tree_entry);
lb_avl_tree_delete(&tree, &delete5->tree_entry);
lb_avl_tree_delete(&tree, &delete15->tree_entry);
lb_avl_tree_delete(&tree, &delete25->tree_entry);
lb_avl_tree_delete(&tree, &delete10->tree_entry);
lb_avl_tree_delete(&tree, &delete30->tree_entry);
int val2[] = {20};
result = result && pre_order_assert(&tree, val2, 1);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_complex_single_rotation()
@ -622,31 +624,31 @@ static bool delete_complex_single_rotation()
//
//
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(50);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {20, 10, 5, 15, 12, 30, 25, 22, 35, 31, 40};
result = result && pre_order_assert(&tree, val2, 11);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_complex_double_rotation()
@ -677,31 +679,31 @@ static bool delete_complex_double_rotation()
//
//
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(22);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {20, 10, 5, 15, 12, 35, 30, 25, 31, 40, 50};
result = result && pre_order_assert(&tree, val2, 11);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_complex_multiple_rotation()
@ -732,31 +734,31 @@ static bool delete_complex_multiple_rotation()
//
//
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(5);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &deleted->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
lb_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {30, 20, 12, 10, 15, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val2, 11);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
static bool delete_DNE()
@ -780,26 +782,26 @@ static bool delete_DNE()
// 5 15 25
//
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
int_tree_node *delete100 = create_tree_node(100);
int_tree_node *delete24 = create_tree_node(24);
ke_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
lb_avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
ke_avl_tree_delete(&tree, &delete24->tree_entry);
ke_avl_tree_delete(&tree, &delete100->tree_entry);
lb_avl_tree_delete(&tree, &delete24->tree_entry);
lb_avl_tree_delete(&tree, &delete100->tree_entry);
result = result && pre_order_assert(&tree, val1, 6);
return result && ke_avl_tree_validate(&tree);
return result && lb_avl_tree_validate(&tree);
}
#define AVL_APOCALYPSE_NUM 500
@ -809,26 +811,26 @@ static int_tree_node apocalypse[AVL_APOCALYPSE_NUM];
static bool test_apocalypse()
{
bool result = true;
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_t tree;
lb_avl_tree_init(&tree, compare);
// insert test
for(int i = 0; i < AVL_APOCALYPSE_NUM; i++)
{
apocalypse[i].val = rand();
while(ke_avl_tree_search(&tree, &apocalypse[i].tree_entry) != NULL)
while(lb_avl_tree_search(&tree, &apocalypse[i].tree_entry) != NULL)
{
apocalypse[i].val += rand() % 32765;
}
ke_avl_tree_insert(&tree, &apocalypse[i].tree_entry);
lb_avl_tree_insert(&tree, &apocalypse[i].tree_entry);
}
// integrity test
result = result && ke_avl_tree_validate(&tree);
result = result && ke_avl_tree_size(&tree) == AVL_APOCALYPSE_NUM;
result = result && lb_avl_tree_validate(&tree);
result = result && lb_avl_tree_size(&tree) == AVL_APOCALYPSE_NUM;
// smaller and bigger test
k_avl_tree_node_t* entry = ke_avl_tree_smallest(&tree);
avl_tree_node_t* entry = lb_avl_tree_smallest(&tree);
uint32_t size = 0;
int32_t prev = -1;
int32_t cur = OBTAIN_STRUCT_ADDR(entry, int_tree_node, tree_entry)->val;
@ -840,7 +842,7 @@ static bool test_apocalypse()
break;
}
size++;
entry = ke_avl_tree_larger(entry);
entry = lb_avl_tree_larger(entry);
prev = cur;
if(entry != NULL)
{
@ -851,7 +853,7 @@ static bool test_apocalypse()
result = result && size == AVL_APOCALYPSE_NUM;
// larger test
entry = ke_avl_tree_largest(&tree);
entry = lb_avl_tree_largest(&tree);
size = 0;
cur = OBTAIN_STRUCT_ADDR(entry, int_tree_node, tree_entry)->val;
prev = cur;
@ -863,7 +865,7 @@ static bool test_apocalypse()
break;
}
size++;
entry = ke_avl_tree_smaller(entry);
entry = lb_avl_tree_smaller(entry);
prev = cur;
if(entry != NULL)
{
@ -877,13 +879,13 @@ static bool test_apocalypse()
// delete and search test
for(int i = 0; i < AVL_APOCALYPSE_NUM; i++)
{
result = result && (ke_avl_tree_search(&tree, &apocalypse[i].tree_entry) != NULL);
ke_avl_tree_delete(&tree, &apocalypse[i].tree_entry);
result = result && (ke_avl_tree_search(&tree, &apocalypse[i].tree_entry) == NULL);
result = result && ke_avl_tree_validate(&tree);
result = result && (lb_avl_tree_search(&tree, &apocalypse[i].tree_entry) != NULL);
lb_avl_tree_delete(&tree, &apocalypse[i].tree_entry);
result = result && (lb_avl_tree_search(&tree, &apocalypse[i].tree_entry) == NULL);
result = result && lb_avl_tree_validate(&tree);
}
result = result && (ke_avl_tree_size(&tree) == 0);
result = result && (lb_avl_tree_size(&tree) == 0);
return result;
}

186
x64/src/test/k_linked_list_test.c
View File

@ -1,15 +1,15 @@
#include "k_test_driver.h"
#include "k_linked_list.h"
#include "../lib/inc/linked_list.h"
#include "k_lib_test.h"
#include "k_stdlib.h"
#include "../lib/inc/sxtdlib.h"
typedef struct
{
k_linked_list_node_t lnode;
linked_list_node_t lnode;
int val;
} my_list_node;
static bool validate_list(k_linked_list_t *list)
static bool validate_list(linked_list_t *list)
{
bool result = true;
// list_head_test
@ -35,9 +35,9 @@ static bool validate_list(k_linked_list_t *list)
}
static bool assert_list(k_linked_list_t *list, int val[], int size)
static bool assert_list(linked_list_t *list, int val[], int size)
{
k_linked_list_node_t *node = ke_linked_list_first(list);
linked_list_node_t *node = lb_linked_list_first(list);
int i = 0;
if (!validate_list(list))
@ -51,7 +51,7 @@ static bool assert_list(k_linked_list_t *list, int val[], int size)
return false;
}
i++;
node = ke_linked_list_next(node);
node = lb_linked_list_next(node);
}
if (i != size)
@ -59,7 +59,7 @@ static bool assert_list(k_linked_list_t *list, int val[], int size)
return false;
}
node = ke_linked_list_last(list);
node = lb_linked_list_last(list);
while (node != NULL && i >= 0)
{
my_list_node *enode = OBTAIN_STRUCT_ADDR(node, my_list_node, lnode);
@ -68,7 +68,7 @@ static bool assert_list(k_linked_list_t *list, int val[], int size)
return false;
}
i--;
node = ke_linked_list_prev(node);
node = lb_linked_list_prev(node);
}
return i == 0;
@ -96,32 +96,32 @@ static bool assert_list(k_linked_list_t *list, int val[], int size)
// return;
//}
static void insert_val(k_linked_list_t *list, int index, int val)
static void insert_val(linked_list_t *list, int index, int val)
{
my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
a->val = val;
ke_linked_list_insert(list, index, &a->lnode);
lb_linked_list_insert(list, index, &a->lnode);
}
static void push_back_val(k_linked_list_t *list, int val)
static void push_back_val(linked_list_t *list, int val)
{
my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
a->val = val;
ke_linked_list_push_back(list, &a->lnode);
lb_linked_list_push_back(list, &a->lnode);
}
static void push_front_val(k_linked_list_t *list, int val)
static void push_front_val(linked_list_t *list, int val)
{
my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
a->val = val;
ke_linked_list_push_front(list, &a->lnode);
lb_linked_list_push_front(list, &a->lnode);
}
static bool insert_test_beginning()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 0, 1);
insert_val(&list, 0, 2);
@ -134,8 +134,8 @@ static bool insert_test_beginning()
static bool insert_test_middle()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 0, 1);
@ -151,8 +151,8 @@ static bool insert_test_middle()
static bool insert_test_end()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 1, 1);
@ -165,8 +165,8 @@ static bool insert_test_end()
static bool insert_test_invalid()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 3);
insert_val(&list, 0, 2);
@ -185,8 +185,8 @@ static bool insert_test_invalid()
// NULL
insert_val(NULL, 1, 4);
ke_linked_list_insert_ref(NULL, list.head, list.tail);
ke_linked_list_insert_ref(&list, list.head, NULL);
lb_linked_list_insert_ref(NULL, list.head, list.tail);
lb_linked_list_insert_ref(&list, list.head, NULL);
int val[] = {0, 1, 2, 3};
return assert_list(&list, val, 4);
@ -195,15 +195,15 @@ static bool insert_test_invalid()
static bool remove_test_beginning()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 0, 1);
insert_val(&list, 0, 2);
insert_val(&list, 0, 3);
ke_linked_list_remove(&list, 0);
ke_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 0);
// 10==01
int val[] = {1, 0};
@ -212,8 +212,8 @@ static bool remove_test_beginning()
static bool remove_test_middle()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 0, 1);
@ -223,8 +223,8 @@ static bool remove_test_middle()
insert_val(&list, 0, 4);
insert_val(&list, 0, 5);
ke_linked_list_remove(&list, 1);
ke_linked_list_remove(&list, 2);
lb_linked_list_remove(&list, 1);
lb_linked_list_remove(&list, 2);
// 5310=====0135
int val[] = {5, 3, 1, 0};
@ -233,16 +233,16 @@ static bool remove_test_middle()
static bool remove_test_end()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 1, 1);
insert_val(&list, 2, 2);
insert_val(&list, 3, 3);
ke_linked_list_remove(&list, 3);
ke_linked_list_remove(&list, 2);
lb_linked_list_remove(&list, 3);
lb_linked_list_remove(&list, 2);
int val[] = {0, 1};
return assert_list(&list, val, 2);
@ -251,18 +251,18 @@ static bool remove_test_end()
static bool remove_test_all()
{
bool result = true;
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 1, 1);
insert_val(&list, 2, 2);
insert_val(&list, 3, 3);
ke_linked_list_remove(&list, 0);
ke_linked_list_remove(&list, 0);
ke_linked_list_remove(&list, 0);
ke_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 0);
result = result && assert_list(&list, NULL, 0);
@ -271,10 +271,10 @@ static bool remove_test_all()
insert_val(&list, 2, 2);
insert_val(&list, 3, 3);
ke_linked_list_remove(&list, 3);
ke_linked_list_remove(&list, 2);
ke_linked_list_remove(&list, 1);
ke_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 3);
lb_linked_list_remove(&list, 2);
lb_linked_list_remove(&list, 1);
lb_linked_list_remove(&list, 0);
result = result && assert_list(&list, NULL, 0);
@ -283,10 +283,10 @@ static bool remove_test_all()
insert_val(&list, 2, 2);
insert_val(&list, 3, 3);
ke_linked_list_remove(&list, 1);
ke_linked_list_remove(&list, 1);
ke_linked_list_remove(&list, 1);
ke_linked_list_remove(&list, 0);
lb_linked_list_remove(&list, 1);
lb_linked_list_remove(&list, 1);
lb_linked_list_remove(&list, 1);
lb_linked_list_remove(&list, 0);
result = result && assert_list(&list, NULL, 0);
@ -295,8 +295,8 @@ static bool remove_test_all()
static bool remove_test_invalid()
{
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
insert_val(&list, 0, 3);
insert_val(&list, 0, 2);
@ -304,19 +304,19 @@ static bool remove_test_invalid()
insert_val(&list, 0, 0);
// large index
ke_linked_list_remove(&list, 5);
ke_linked_list_remove(&list, 6);
ke_linked_list_remove(&list, 999);
lb_linked_list_remove(&list, 5);
lb_linked_list_remove(&list, 6);
lb_linked_list_remove(&list, 999);
// small index
ke_linked_list_remove(&list, -1);
ke_linked_list_remove(&list, -2);
ke_linked_list_remove(&list, -999);
lb_linked_list_remove(&list, -1);
lb_linked_list_remove(&list, -2);
lb_linked_list_remove(&list, -999);
// NULL
ke_linked_list_remove(NULL, 1);
ke_linked_list_remove_ref(NULL, list.head);
ke_linked_list_remove_ref(&list, NULL);
lb_linked_list_remove(NULL, 1);
lb_linked_list_remove_ref(NULL, list.head);
lb_linked_list_remove_ref(&list, NULL);
// 0123=====3210
int val[] = {0, 1, 2, 3};
@ -326,17 +326,18 @@ static bool remove_test_invalid()
static bool size_test()
{
bool result = true;
k_linked_list_t list;
ke_linked_list_init(&list);
k_linked_list_t list2;
ke_linked_list_init(&list2);
linked_list_t list;
lb_linked_list_init(&list);
linked_list_t list2;
lb_linked_list_init(&list2);
insert_val(&list, 0, 0);
insert_val(&list, 1, 1);
insert_val(&list, 2, 2);
insert_val(&list, 3, 3);
result = result && (ke_linked_list_size(&list) == 4 && ke_linked_list_size(&list2) == 0 && ke_linked_list_size(NULL) == -1);
result = result && (lb_linked_list_size(&list) == 4 && lb_linked_list_size(&list2) == 0 &&
lb_linked_list_size(NULL) == -1);
int val[] = {0, 1, 2, 3};
result = result && assert_list(&list, val, 4);
return result;
@ -345,8 +346,8 @@ static bool size_test()
static bool push_pop_front_test()
{
bool result = true;
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
push_front_val(&list, 1);
push_front_val(&list, 2);
@ -357,14 +358,14 @@ static bool push_pop_front_test()
int val1[] = {4, 3, 2, 1};
result = result && assert_list(&list, val1, 4);
ke_linked_list_pop_front(&list);
lb_linked_list_pop_front(&list);
//321==123
int val2[] = {3, 2, 1};
result = result && assert_list(&list, val2, 3);
ke_linked_list_pop_front(&list);
ke_linked_list_pop_front(&list);
ke_linked_list_pop_front(&list);
lb_linked_list_pop_front(&list);
lb_linked_list_pop_front(&list);
lb_linked_list_pop_front(&list);
result = result && assert_list(&list, NULL, 0);
return result;
@ -373,8 +374,8 @@ static bool push_pop_front_test()
static bool push_pop_back_test()
{
bool result = true;
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
push_back_val(&list, 1);
push_back_val(&list, 2);
@ -385,29 +386,30 @@ static bool push_pop_back_test()
int val1[] = {1, 2, 3, 4};
result = result && assert_list(&list, val1, 4);
ke_linked_list_pop_back(&list);
lb_linked_list_pop_back(&list);
//123==321
int val2[] = {1, 2, 3};
result = result && assert_list(&list, val2, 3);
ke_linked_list_pop_back(&list);
ke_linked_list_pop_back(&list);
ke_linked_list_pop_back(&list);
lb_linked_list_pop_back(&list);
lb_linked_list_pop_back(&list);
lb_linked_list_pop_back(&list);
result = result && assert_list(&list, NULL, 0);
return result;
}
static bool equals(k_linked_list_node_t *a, k_linked_list_node_t *b)
static int32_t equals(void *a, void *b)
{
return (int64_t) b == OBTAIN_STRUCT_ADDR(a, my_list_node, lnode)->val;
return ((int64_t) (linked_list_node_t*)b) ==
OBTAIN_STRUCT_ADDR((linked_list_node_t*)a, my_list_node, lnode)->val;
}
static bool search_test()
{
bool result = true;
k_linked_list_t list;
ke_linked_list_init(&list);
linked_list_t list;
lb_linked_list_init(&list);
push_back_val(&list, 1);
push_back_val(&list, 2);
@ -417,16 +419,16 @@ static bool search_test()
int val1[] = {1, 2, 3, 4};
result = result && assert_list(&list, val1, 4);
result = result && (ke_linked_list_search(&list, (k_linked_list_node_t *) 4, equals) == 3);
result = result && (ke_linked_list_search(&list, (k_linked_list_node_t *) 3, equals) == 2);
result = result && (ke_linked_list_search(&list, (k_linked_list_node_t *) 2, equals) == 1);
result = result && (ke_linked_list_search(&list, (k_linked_list_node_t *) 1, equals) == 0);
result = result && (lb_linked_list_search(&list, (void *) 4, equals) == 3);
result = result && (lb_linked_list_search(&list, (linked_list_node_t *) 3, equals) == 2);
result = result && (lb_linked_list_search(&list, (linked_list_node_t *) 2, equals) == 1);
result = result && (lb_linked_list_search(&list, (linked_list_node_t *) 1, equals) == 0);
result = result && (ke_linked_list_search(&list, NULL, equals) == -1);
result = result && (ke_linked_list_search(NULL, (k_linked_list_node_t *) 1, equals) == -1);
result = result && (lb_linked_list_search(&list, NULL, equals) == -1);
result = result && (lb_linked_list_search(NULL, (linked_list_node_t *) 1, equals) == -1);
k_linked_list_node_t *node = ke_linked_list_get(&list, 1);
result = result && (ke_linked_list_search(&list, node, NULL) == 1);
linked_list_node_t *node = lb_linked_list_get(&list, 1);
result = result && (lb_linked_list_search(&list, node, NULL) == 1);
result = result && assert_list(&list, val1, 4);
@ -435,7 +437,7 @@ static bool search_test()
}
void KAPI linked_list_test(void)
void KABI linked_list_test(void)
{
test_begin("Linked list test");
run_case("insert_test_beginning", insert_test_beginning());

162
x64/src/test/k_salloc_test.c
View File

@ -1,5 +1,5 @@
#include "k_test_driver.h"
#include "k_salloc.h"
#include "../lib/inc/salloc.h"
typedef union
{
@ -13,58 +13,58 @@ static char buffer[1024];
static bool salloc_init_test()
{
ke_salloc_init(buffer, 1024);
lb_salloc_init(buffer, 1024);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
return ke_salloc_assert(buffer, blk_size, blk_free, 1);
return lb_salloc_assert(buffer, blk_size, blk_free, 1);
}
static bool salloc_basic_alloc()
{
bool result = true;
ke_salloc_init(buffer, 1024);
result = result && (ke_salloc(buffer, 10) != NULL);
lb_salloc_init(buffer, 1024);
result = result && (lb_salloc(buffer, 10) != NULL);
uint32_t blk_size[] = {10 + salloc_header_size, 1024-10-salloc_header_size};
bool blk_free[] = {false,true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 2);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 2);
return result;
}
static bool salloc_full_alloc()
{
bool result = true;
ke_salloc_init(buffer, 1024);
result = result && (ke_salloc(buffer, 1024 - salloc_header_size) != NULL);
lb_salloc_init(buffer, 1024);
result = result && (lb_salloc(buffer, 1024 - salloc_header_size) != NULL);
uint32_t blk_size[] = {1024};
bool blk_free[] = {false};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
static bool salloc_overflow_alloc()
{
bool result = true;
ke_salloc_init(buffer, 1024);
result = result && (ke_salloc(buffer, 1024 - salloc_header_size + 1) == NULL);
lb_salloc_init(buffer, 1024);
result = result && (lb_salloc(buffer, 1024 - salloc_header_size + 1) == NULL);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
static bool salloc_multiple_alloc()
{
bool result = true;
ke_salloc_init(buffer, 1024);
result = result && (ke_salloc(buffer, 10) != NULL);
result = result && (ke_salloc(buffer, 10) != NULL);
result = result && (ke_salloc(buffer, 10) != NULL);
lb_salloc_init(buffer, 1024);
result = result && (lb_salloc(buffer, 10) != NULL);
result = result && (lb_salloc(buffer, 10) != NULL);
result = result && (lb_salloc(buffer, 10) != NULL);
uint32_t blk_size[] = {10 + salloc_header_size,
10 + salloc_header_size,
10 + salloc_header_size,
1024-3*(10+salloc_header_size)};
bool blk_free[] = {false,false,false,true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 4);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
return result;
}
@ -72,12 +72,12 @@ static bool salloc_alloc_not_enough()
{
void* ptr;
bool result = true;
ke_salloc_init(buffer, salloc_header_size + salloc_header_size + salloc_header_size - 1);
ptr = ke_salloc(buffer, salloc_header_size);
lb_salloc_init(buffer, salloc_header_size + salloc_header_size + salloc_header_size - 1);
ptr = lb_salloc(buffer, salloc_header_size);
result = result && (ptr != NULL);
uint32_t blk_size[] = {salloc_header_size + salloc_header_size + salloc_header_size - 1};
bool blk_free[] = {false};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
@ -86,14 +86,14 @@ static bool salloc_basic_free()
{
void* ptr;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr = ke_salloc(buffer, 10);
lb_salloc_init(buffer, 1024);
ptr = lb_salloc(buffer, 10);
result = result && (ptr != NULL);
ke_sfree(buffer, ptr);
lb_sfree(buffer, ptr);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
@ -101,14 +101,14 @@ static bool salloc_full_free()
{
void* ptr;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr = ke_salloc(buffer, 1024 - salloc_header_size);
lb_salloc_init(buffer, 1024);
ptr = lb_salloc(buffer, 1024 - salloc_header_size);
result = result && (ptr != NULL);
ke_sfree(buffer, ptr);
lb_sfree(buffer, ptr);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
@ -116,14 +116,14 @@ static bool salloc_multiple_free()
{
void* ptr1, *ptr2, *ptr3, *ptr4;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr1 = ke_salloc(buffer, 10);
ptr2 = ke_salloc(buffer, 10);
ptr3 = ke_salloc(buffer, 10);
ptr4 = ke_salloc(buffer, 10);
lb_salloc_init(buffer, 1024);
ptr1 = lb_salloc(buffer, 10);
ptr2 = lb_salloc(buffer, 10);
ptr3 = lb_salloc(buffer, 10);
ptr4 = lb_salloc(buffer, 10);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
ke_sfree(buffer, ptr1);
ke_sfree(buffer, ptr3);
lb_sfree(buffer, ptr1);
lb_sfree(buffer, ptr3);
uint32_t blk_size[] = {10 + salloc_header_size,
10 + salloc_header_size,
@ -131,7 +131,7 @@ static bool salloc_multiple_free()
10 + salloc_header_size,
1024-4*(10+salloc_header_size)};
bool blk_free[] = {true,false,true,false,true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 5);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 5);
return result;
}
@ -139,20 +139,20 @@ static bool salloc_free_join_tail()
{
void* ptr1, *ptr2, *ptr3, *ptr4;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr1 = ke_salloc(buffer, 10);
ptr2 = ke_salloc(buffer, 10);
ptr3 = ke_salloc(buffer, 10);
ptr4 = ke_salloc(buffer, 10);
lb_salloc_init(buffer, 1024);
ptr1 = lb_salloc(buffer, 10);
ptr2 = lb_salloc(buffer, 10);
ptr3 = lb_salloc(buffer, 10);
ptr4 = lb_salloc(buffer, 10);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
ke_sfree(buffer, ptr4);
lb_sfree(buffer, ptr4);
uint32_t blk_size[] = {10 + salloc_header_size,
10 + salloc_header_size,
10 + salloc_header_size,
1024-3*(10+salloc_header_size)};
bool blk_free[] = {false,false,false,true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 4);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
return result;
}
@ -160,21 +160,21 @@ static bool salloc_free_join_head()
{
void* ptr1, *ptr2, *ptr3, *ptr4;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr1 = ke_salloc(buffer, 10);
ptr2 = ke_salloc(buffer, 10);
ptr3 = ke_salloc(buffer, 10);
ptr4 = ke_salloc(buffer, 10);
lb_salloc_init(buffer, 1024);
ptr1 = lb_salloc(buffer, 10);
ptr2 = lb_salloc(buffer, 10);
ptr3 = lb_salloc(buffer, 10);
ptr4 = lb_salloc(buffer, 10);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
ke_sfree(buffer, ptr1);
ke_sfree(buffer, ptr2);
lb_sfree(buffer, ptr1);
lb_sfree(buffer, ptr2);
uint32_t blk_size[] = {2*(10 + salloc_header_size),
10 + salloc_header_size,
10 + salloc_header_size,
1024-4*(10+salloc_header_size)};
bool blk_free[] = {true,false,false,true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 4);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
return result;
}
@ -182,21 +182,21 @@ static bool salloc_free_join_mid()
{
void* ptr1, *ptr2, *ptr3, *ptr4;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr1 = ke_salloc(buffer, 10);
ptr2 = ke_salloc(buffer, 10);
ptr3 = ke_salloc(buffer, 10);
ptr4 = ke_salloc(buffer, 10);
lb_salloc_init(buffer, 1024);
ptr1 = lb_salloc(buffer, 10);
ptr2 = lb_salloc(buffer, 10);
ptr3 = lb_salloc(buffer, 10);
ptr4 = lb_salloc(buffer, 10);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
ke_sfree(buffer, ptr2);
ke_sfree(buffer, ptr3);
lb_sfree(buffer, ptr2);
lb_sfree(buffer, ptr3);
uint32_t blk_size[] = {10 + salloc_header_size,
2*(10 + salloc_header_size),
10 + salloc_header_size,
1024-4*(10+salloc_header_size)};
bool blk_free[] = {false,true,false,true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 4);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 4);
return result;
}
@ -204,15 +204,15 @@ static bool salloc_free_join_consecutive()
{
void* ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr1 = ke_salloc(buffer, 10);
ptr2 = ke_salloc(buffer, 10);
ptr3 = ke_salloc(buffer, 10);
ptr4 = ke_salloc(buffer, 10);
ptr5 = ke_salloc(buffer, 10);
lb_salloc_init(buffer, 1024);
ptr1 = lb_salloc(buffer, 10);
ptr2 = lb_salloc(buffer, 10);
ptr3 = lb_salloc(buffer, 10);
ptr4 = lb_salloc(buffer, 10);
ptr5 = lb_salloc(buffer, 10);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL) && (ptr5 != NULL);
ke_sfree(buffer, ptr2);
ke_sfree(buffer, ptr4);
lb_sfree(buffer, ptr2);
lb_sfree(buffer, ptr4);
uint32_t blk_size[] = {10 + salloc_header_size,
10 + salloc_header_size,
@ -221,16 +221,16 @@ static bool salloc_free_join_consecutive()
10 + salloc_header_size,
1024-5*(10+salloc_header_size)};
bool blk_free[] = {false,true,false,true,false,true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 6);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 6);
ke_sfree(buffer, ptr3);
lb_sfree(buffer, ptr3);
uint32_t blk_size2[] = {10 + salloc_header_size,
3*(10 + salloc_header_size),
10 + salloc_header_size,
1024-5*(10+salloc_header_size)};
bool blk_free2[] = {false,true,false,true};
result = result && ke_salloc_assert(buffer, blk_size2, blk_free2, 4);
result = result && lb_salloc_assert(buffer, blk_size2, blk_free2, 4);
return result;
}
@ -238,25 +238,25 @@ static bool salloc_free_all()
{
void* ptr1, *ptr2, *ptr3, *ptr4;
bool result = true;
ke_salloc_init(buffer, 1024);
ptr1 = ke_salloc(buffer, 10);
ptr2 = ke_salloc(buffer, 10);
ptr3 = ke_salloc(buffer, 10);
ptr4 = ke_salloc(buffer, 10);
lb_salloc_init(buffer, 1024);
ptr1 = lb_salloc(buffer, 10);
ptr2 = lb_salloc(buffer, 10);
ptr3 = lb_salloc(buffer, 10);
ptr4 = lb_salloc(buffer, 10);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
ke_sfree(buffer, ptr1);
ke_sfree(buffer, ptr2);
ke_sfree(buffer, ptr3);
ke_sfree(buffer, ptr4);
lb_sfree(buffer, ptr1);
lb_sfree(buffer, ptr2);
lb_sfree(buffer, ptr3);
lb_sfree(buffer, ptr4);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
result = result && lb_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
void KAPI salloc_test()
void KABI salloc_test()
{
test_begin("salloc test");

8
x64/src/test/k_test_driver.c
View File

@ -84,7 +84,7 @@ static void ginfo_push(char *case_name, bool success)
hal_printf("GINFO full, [%s] result not recorded.\n", r_case_name);
}
void KAPI test_begin(char *name)
void KABI test_begin(char *name)
{
test_name = (name == NULL ? "Anonymous Test" : name);
for (int i = 0; i < GAT_SIZE; i++)
@ -97,7 +97,7 @@ void KAPI test_begin(char *name)
}
}
void KAPI test_end()
void KABI test_end()
{
gat_free();
int32_t total = 0, failed = 0, success = 0;
@ -135,7 +135,7 @@ void KAPI test_end()
}
}
void KAPI *talloc(uint32_t size)
void KABI *talloc(uint32_t size)
{
if (!gat_full())
{
@ -151,7 +151,7 @@ void KAPI *talloc(uint32_t size)
return NULL;
}
void KAPI run_case(char *name, bool result)
void KABI run_case(char *name, bool result)
{
ginfo_push(name, result);
}