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

Fixing stuff. Still broken

This commit is contained in:
secXsQuared 2016-08-28 02:14:22 -07:00
parent e6bbba7b60
commit ba7672dd00
21 changed files with 308 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -15,4 +15,6 @@ typedef int32_t (*k_callback_func_t)(void *kernel_args, void *user_args);
typedef uint32_t k_handle_t;
#define STRUCT_PACKED __attribute__((packed))
#endif

9
x64/src/common/inc/kernel/s_print.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef _S_PRINT_H_
#define _S_PRINT_H_
#include "g_abi.h"
#include "g_type.h"
extern void KAPI ke_printf(const char*, ...);
#endif

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

@ -102,12 +102,12 @@ void KAPI hal_write_segment_descriptor(void *const gdt, uint32_t const base, uin
void *KAPI halloc(uint32_t size)
{
return salloc(kernel_heap, size);
return ke_salloc(kernel_heap, size);
}
void KAPI hfree(void *ptr)
{
sfree(kernel_heap, ptr);
ke_sfree(kernel_heap, ptr);
return;
}
@ -145,6 +145,6 @@ static void KAPI _hal_init_gdt()
void KAPI hal_mem_init()
{
_hal_init_gdt();
salloc_init(kernel_heap, KERNEL_HEAP_SIZE);
ke_salloc_init(kernel_heap, KERNEL_HEAP_SIZE);
return;
}

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

@ -10,14 +10,14 @@ typedef struct
{
uint16_t limit;
uint64_t base;
} __attribute__ ((packed)) hal_gdt_ptr_t;
} STRUCT_PACKED hal_gdt_ptr_t;
typedef struct
{
uint16_t limit;
uint64_t base;
} __attribute__ ((packed)) hal_idt_ptr_t;
} STRUCT_PACKED hal_idt_ptr_t;
extern void KAPI hal_interlocked_increment(uint64_t* dst);

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

@ -7,6 +7,6 @@ void KAPI k_alloc_init();
void* KAPI k_alloc(uint32_t size);
void KAPI k_free(void* ptr);
void KAPI ke_free(void *ptr);
#endif

5
x64/src/kernel/inc/k_assert.h
View File

@ -2,9 +2,10 @@
#define _K_ASSERT_H_
#include "g_type.h"
#include "g_abi.h"
void hw_assert_ex(const char* expr_str, const char* file, int32_t line, int32_t expr);
void KAPI ke_assert_ex(const char* expr_str, const char* file, int32_t line, int32_t expr);
#define hw_assert(expr) hw_assert_ex(#expr, __FILE__, __LINE__, expr)
#define ke_assert(expr) ke_assert_ex(#expr, __FILE__, __LINE__, expr)
#endif

56
x64/src/kernel/inc/k_bit_ops.h
View File

@ -1,56 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _BIT_OPERATION_H_
#define _BIT_OPERATION_H_
#include "g_type.h"
#include "g_abi.h"
static inline uint64_t KAPI ke_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)
{
return ~(~(uint64_t)0 << high << 1) << low;
}
static inline void KAPI ke_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));
*((uint8_t*)(bit_map) + quot) |= (uint8_t) ke_bit_mask(rmd);
}
}
static inline void KAPI ke_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));
*((uint8_t*)(bit_map) + quot) &= ~(uint8_t) ke_bit_mask(rmd);
}
}
static inline uint32_t KAPI ke_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));
return (*((uint8_t*)(bit_map) + quot) & (uint8_t) ke_bit_mask(rmd)) == 0 ? 0 : 1;
}
return 0;
}
#endif

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

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

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

@ -12,27 +12,25 @@ typedef struct
#define K_HANDLE_BASE 0x80000000
//#define K_HANDLE_CURRENT_THREAD 0x1
//
// All functions are hw since users or kernel devs should not be
// All functions are sx since users or kernel devs should not be
// specifying where the allocations take place
//
k_status_t ke_reference_setup();
k_status_t KAPI ke_reference_setup();
k_status_t ke_reference_create(k_ref_node_t *ref,
k_status_t KAPI ke_reference_create(k_ref_node_t *ref,
k_callback_func_t free_func);
k_status_t ke_reference_obj(k_ref_node_t *ref);
k_status_t KAPI ke_reference_obj(k_ref_node_t *ref);
k_status_t ke_dereference_obj(k_ref_node_t *ref);
k_status_t KAPI ke_dereference_obj(k_ref_node_t *ref);
// HANDLES
k_status_t sx_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out);
k_status_t KAPI sx_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out);
k_status_t sx_create_handle(k_ref_node_t *ref, k_handle_t *out);
k_status_t KAPI sx_create_handle(k_ref_node_t *ref, k_handle_t *out);
k_status_t sx_close_handle(k_handle_t handle);
k_status_t KAPI sx_close_handle(k_handle_t handle);
#endif

8
x64/src/kernel/inc/k_salloc.h
View File

@ -9,13 +9,13 @@
#include "g_abi.h"
#include "g_type.h"
void KAPI salloc_init(void *base, uint32_t size);
void KAPI ke_salloc_init(void *base, uint32_t size);
void* KAPI salloc(void *base, uint32_t size);
void* KAPI ke_salloc(void *base, uint32_t size);
void KAPI sfree(void *base, void *ptr);
void KAPI ke_sfree(void *base, void *ptr);
bool KAPI salloc_assert(void *base, uint32_t blk_size[], bool blk_free[], uint32_t size);
bool KAPI ke_salloc_assert(void *base, uint32_t *blk_size, bool *blk_free, uint32_t size);
#endif

13
x64/src/kernel/inc/k_status.h
View File

@ -30,7 +30,18 @@
typedef enum _k_status_t
{
STATUS_SUCCESS = SX_MAKE_STATUS(SEVERITY_SUCCESS, FACILITY_GENERIC, 0),
REF_STATUS_UNINITIALIZED = SX_MAKE_STATUS(SEVERITY_ERROR, FACILITY_REF, 1),
REF_STATUS_ALLOCATION_FAILED = SX_MAKE_STATUS(SEVERITY_ERROR, FACILITY_REF, 2),
REF_STATUS_INVALID_ARGUMENTS = SX_MAKE_STATUS(SEVERITY_ERROR, FACILITY_REF, 1),
REF_STATUS_INVALID_HANDLE = SX_MAKE_STATUS(SEVERITY_ERROR, FACILITY_REF, 1),
REF_STATUS_DUPLICATED_HANDLE = SX_MAKE_STATUS(SEVERITY_ERROR, FACILITY_REF, 1),
} k_status_t;
#endif

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

@ -4,6 +4,7 @@
#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
@ -21,15 +22,15 @@ typedef struct
k_spin_lock_t lock;
} k_vmm_descriptor_t;
int32_t k_vmm_init(k_vmm_descriptor_t *desc);
int32_t KAPI k_vmm_init(k_vmm_descriptor_t *desc);
int32_t k_alloc_virtual_address(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 k_query_virtual_address(k_vmm_descriptor_t* desc, k_virtual_addr_t v_addr, uint64_t* out);
int64_t KAPI k_query_virtual_address(k_vmm_descriptor_t* desc, k_virtual_addr_t v_addr, uint64_t* out);
int64_t k_free_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t base);
int64_t KAPI k_free_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t base);
#endif

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

@ -12,20 +12,20 @@ void KAPI k_alloc_init()
{
if (!_k_alloc_initialized)
{
salloc_init(_k_alloc_heap, K_KERNEL_HEAP_SIZE);
ke_salloc_init(_k_alloc_heap, K_KERNEL_HEAP_SIZE);
_k_alloc_initialized = true;
}
}
void *KAPI k_alloc(uint32_t size)
{
return _k_alloc_initialized ? salloc(_k_alloc_heap, size) : NULL;
return _k_alloc_initialized ? ke_salloc(_k_alloc_heap, size) : NULL;
}
void KAPI k_free(void *ptr)
void KAPI ke_free(void *ptr)
{
if (_k_alloc_initialized)
{
sfree(_k_alloc_heap, ptr);
ke_sfree(_k_alloc_heap, ptr);
}
}

10
x64/src/kernel/k_assert.c Normal file
View File

@ -0,0 +1,10 @@
#include "k_assert.h"
#include "k_print.h"
void ke_assert_ex(const char* expr_str, const char* file, int32_t line, int32_t expr)
{
if(!expr)
{
ke_printf("Assertion \"%s\" failed at %s:%d.\n", expr_str, file, line);
}
}

50
x64/src/kernel/k_atomic.c
View File

@ -1,50 +0,0 @@
#include <k_spin_lock.h>
#include "k_atomic.h"
#include "k_spin_lock.h"
void KAPI ke_spin_lock_init(k_spin_lock_t *lock)
{
if (lock != NULL)
{
lock->val = 0;
}
}
void KAPI ke_spin_lock(k_spin_lock_t *lock)
{
if (lock != NULL)
{
while (ke_interlocked_compare_exchange(&lock->val, 0, 1) != 0);
}
return;
}
void KAPI ke_spin_unlock(k_spin_lock_t *lock)
{
if (lock != NULL)
{
lock->val = 0;
}
return;
}
k_irql_t KAPI ke_spin_lock_raise_irql(k_spin_lock_t *lock, k_irql_t irql)
{
k_irql_t prev_irql = ke_get_irql();
if (lock != NULL)
{
ke_set_irql(irql);
ke_spin_lock(lock);
}
return prev_irql;
}
void KAPI ke_spin_unlock_lower_irql(k_spin_lock_t *lock, k_irql_t irql)
{
if (lock != NULL)
{
ke_spin_unlock(lock);
ke_set_irql(irql);
}
return;
}

8
x64/src/kernel/k_intr.c
View File

@ -1,12 +1,14 @@
#include <k_assert.h>
#include "k_intr.h"
k_irql_t KAPI ke_raise_irql(k_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)
{
ke_assert(ke_get_irql() >= irql);
return ke_set_irql(irql);
}

203
x64/src/kernel/k_ref.c
View File

@ -1,4 +1,8 @@
#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"
typedef struct
@ -7,11 +11,12 @@ typedef struct
k_handle_t handle;
k_ref_node_t *ref;
k_callback_func_t free_routine;
} hw_handle_node_t;
} k_handle_node_t;
static void handle_node_free(void *node, void *up)
static int32_t handle_node_free(void *node, void *up)
{
hw_free(node);
ke_free(node);
return 0;
}
// ===========================
@ -20,13 +25,13 @@ static void handle_node_free(void *node, void *up)
static k_avl_tree_t _handle_tree;
static bool _initialized;
static hw_spin_lock_t _handle_tree_lock;
static k_spin_lock_t _handle_tree_lock;
static int32_t _handle_base;
static int32_t handle_compare(k_avl_tree_node_t *tree_node, k_avl_tree_node_t *my_node)
static int32_t handle_compare(void *tree_node, void *my_node)
{
hw_handle_node_t *tcb = OBTAIN_STRUCT_ADDR(tree_node, tree_node, hw_handle_node_t);
hw_handle_node_t *my_tcb = OBTAIN_STRUCT_ADDR(my_node, tree_node, hw_handle_node_t);
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);
if ((uintptr_t) tcb->handle > (uintptr_t) my_tcb->handle)
return -1;
@ -36,88 +41,80 @@ static int32_t handle_compare(k_avl_tree_node_t *tree_node, k_avl_tree_node_t *m
return 1;
}
static hw_handle_node_t *search_handle_node(hw_handle_t handle)
static k_handle_node_t *search_handle_node(k_handle_t handle)
{
k_avl_tree_node_t *result;
hw_handle_node_t temp;
k_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, tree_node, hw_handle_node_t);
return result == NULL ? NULL : OBTAIN_STRUCT_ADDR(result, k_handle_node_t, tree_node);
}
k_status_t ke_reference_setup()
k_status_t KAPI ke_reference_setup()
{
if (!_initialized)
{
ke_avl_tree_init(&_handle_tree, handle_compare);
ke_spin_lock_init(&_handle_tree_lock);
_handle_base = HW_HANDLE_BASE;
_handle_base = K_HANDLE_BASE;
_initialized = true;
}
return STATUS_SUCCESS;
}
k_status_t ke_reference_create(hw_ref_node_t *ref,
hw_callback_func_t free_func)
k_status_t KAPI ke_reference_create(k_ref_node_t *ref,
k_callback_func_t free_func)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (ref == NULL || free_func == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
ref->callback = free_func;
ref->free_routine = free_func;
ref->ref_count = 1;
return STATUS_SUCCESS;
}
hw_result_t ke_reference_obj(hw_ref_node_t *ref_node)
k_status_t KAPI ke_reference_obj(k_ref_node_t *ref_node)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (ref_node == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
int32_t old_ref_count = ke_interlocked_increment(&ref_node->ref_count, 1);
hw_assert(old_ref_count >= 1);
ke_assert(old_ref_count >= 1);
return STATUS_SUCCESS;
}
hw_result_t ke_dereference_obj(hw_ref_node_t *ref_node)
k_status_t KAPI ke_dereference_obj(k_ref_node_t *ref_node)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
if (ref_node == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
hw_result_t result = STATUS_SUCCESS;
k_status_t result = STATUS_SUCCESS;
int32_t old_ref_count = ke_interlocked_increment(&ref_node->ref_count, -1);
hw_assert(old_ref_count >= 1);
ke_assert(old_ref_count >= 1);
if (old_ref_count == 1)
{
ref_node->callback(ref_node, NULL);
ref_node->free_routine(ref_node, NULL);
}
return result;
}
static hw_result_t ke_open_obj_by_handle(hw_handle_t handle, hw_ref_node_t **out)
static k_status_t KAPI ke_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
{
@ -129,44 +126,40 @@ static hw_result_t ke_open_obj_by_handle(hw_handle_t handle, hw_ref_node_t **out
return REF_STATUS_INVALID_ARGUMENTS;
}
hw_irql_t irql;
hw_result_t result = STATUS_SUCCESS;
hw_ref_node_t *ref = NULL;
k_irql_t irql;
k_status_t status = STATUS_SUCCESS;
k_ref_node_t *ref = NULL;
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, HW_IRQL_DPC_LEVEL);
hw_handle_node_t *handle_node = search_handle_node(handle);
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, K_IRQL_DPC_LEVEL);
k_handle_node_t *handle_node = search_handle_node(handle);
if (handle_node == NULL)
{
result = REF_STATUS_HANDLE_NOT_FOUND;
}
else
status = REF_STATUS_INVALID_HANDLE;
} else
{
ref = handle_node->ref;
}
// PREREQUISITE: Having a handle -> having a reference
// MUST GUARANTEE that handle exists while we reference
if (HW_SUCCESS(result))
if (SX_SUCCESS(status))
{
// reference the object then return the reference
result = ke_reference_obj(ref);
if (HW_SUCCESS(result))
{
*out = ref;
}
ke_reference_obj(ref);
*out = ref;
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
return result;
return status;
}
static hw_result_t ke_create_handle(hw_ref_node_t *ref,
hw_handle_node_t *node,
hw_handle_t *out)
static k_status_t KAPI ke_create_handle(k_ref_node_t *ref,
k_handle_node_t *node,
k_handle_t *out)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
@ -174,75 +167,78 @@ static hw_result_t ke_create_handle(hw_ref_node_t *ref,
if (ref == NULL || node == NULL || out == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
hw_result_t result = STATUS_SUCCESS;
hw_irql_t irql;
k_status_t result = STATUS_SUCCESS;
k_irql_t irql;
if (HW_SUCCESS(result))
if (SX_SUCCESS(result))
{
// TODO: CHECK OVERFLOW
node->handle = (hw_handle_t) ke_interlocked_increment(&_handle_base, 1);
node->handle = (k_handle_t) ke_interlocked_increment(&_handle_base, 1);
node->ref = ref;
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, HW_IRQL_DPC_LEVEL);
hw_handle_node_t *existing_node = search_handle_node(node->handle);
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, K_IRQL_DPC_LEVEL);
k_handle_node_t *existing_node = search_handle_node(node->handle);
if (existing_node == NULL)
{
ke_avl_tree_insert(&_handle_tree, &node->tree_node);
}
else
} else
{
result = REF_STATUS_HANDLE_DUPLICATE;
result = REF_STATUS_DUPLICATED_HANDLE;
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
}
if (HW_SUCCESS(result))
if (SX_SUCCESS(result))
{
ke_reference_obj(ref);
*out = node->handle;
}
else
} else
{
node->free_func(node, NULL);
node->free_routine(node, NULL);
}
return result;
}
static hw_result_t ke_close_handle(hw_handle_t handle)
static k_status_t KAPI ke_close_handle(k_handle_t handle)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
hw_irql_t irql;
hw_result_t result = STATUS_SUCCESS;
hw_ref_node_t *ref = NULL;
k_irql_t irql;
k_status_t status = STATUS_SUCCESS;
k_ref_node_t *ref = NULL;
bool free = false;
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, HW_IRQL_DPC_LEVEL);
hw_handle_node_t *handle_node = search_handle_node(handle);
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, K_IRQL_DPC_LEVEL);
k_handle_node_t *handle_node = search_handle_node(handle);
if (handle_node == NULL)
{
result = REF_STATUS_HANDLE_NOT_FOUND;
}
else
status = REF_STATUS_INVALID_HANDLE;
} else
{
ref = handle_node->ref;
ke_avl_tree_delete(&_handle_tree, &handle_node->tree_node);
handle_node->free_func(handle_node, NULL);
free = true;
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
if (HW_SUCCESS(result))
if (free)
{
// dereference the object
result = ke_dereference_obj(ref);
handle_node->free_routine(handle_node, NULL);
}
return result;
if (SX_SUCCESS(status))
{
// dereference the object
ke_dereference_obj(ref);
}
return status;
}
@ -250,45 +246,40 @@ static hw_result_t ke_close_handle(hw_handle_t handle)
// HW Functions
// ===========================
hw_result_t hw_create_handle(hw_ref_node_t *ref, hw_handle_t *out)
k_status_t KAPI sx_create_handle(k_ref_node_t *ref, k_handle_t *out)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
hw_handle_node_t *node;
node = (hw_handle_node_t *) hw_alloc(sizeof(hw_handle_node_t));
k_handle_node_t *node;
node = (k_handle_node_t *) k_alloc(sizeof(k_handle_node_t));
if (node == NULL)
{
return REF_STATUS_CANNOT_ALLOCATE_MEM;
return REF_STATUS_ALLOCATION_FAILED;
}
node->free_func = handle_node_free;
node->free_routine = handle_node_free;
return ke_create_handle(ref, node, out);
}
hw_result_t hw_close_handle(hw_handle_t handle)
k_status_t KAPI sx_close_handle(k_handle_t handle)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
if (handle == HW_HANDLE_CURRENT_THREAD)
{
return REF_STATUS_NO_EFFECT;
}
// need to keep sx version since need to do handle check here
hw_result_t result = ke_close_handle(handle);
return result;
return ke_close_handle(handle);
}
hw_result_t hw_open_obj_by_handle(hw_handle_t handle, hw_ref_node_t **out)
k_status_t KAPI sx_open_obj_by_handle(k_handle_t handle, k_ref_node_t **out)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
ke_assert(ke_get_irql() <= K_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
@ -297,14 +288,14 @@ hw_result_t hw_open_obj_by_handle(hw_handle_t handle, hw_ref_node_t **out)
return REF_STATUS_INVALID_ARGUMENTS;
// check special handles first
if (handle == HW_HANDLE_CURRENT_THREAD)
{
// no need to ref first since definitely current thread context
hw_tcb_t *tcb = ke_current_thread();
ke_reference_obj(&tcb->ref_node);
*out = &tcb->ref_node;
return STATUS_SUCCESS;
}
// if (handle == K_HANDLE_CURRENT_THREAD)
// {
// // no need to ref first since definitely current thread context
// hw_tcb_t *tcb = ke_current_thread();
// ke_reference_obj(&tcb->ref_node);
// *out = &tcb->ref_node;
// return STATUS_SUCCESS;
// }
return ke_open_obj_by_handle(handle, out);
}

8
x64/src/kernel/k_salloc.c
View File

@ -92,7 +92,7 @@ static void _salloc_join(void *base)
}
}
bool KAPI salloc_assert(void *base, uint32_t blk_size[], bool blk_free[], uint32_t size)
bool KAPI ke_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;
@ -119,7 +119,7 @@ bool KAPI salloc_assert(void *base, uint32_t blk_size[], bool blk_free[], uint32
}
}
void KAPI salloc_init(void *base, uint32_t size)
void KAPI ke_salloc_init(void *base, uint32_t size)
{
if (base != NULL && size >= sizeof(_salloc_header))
{
@ -131,7 +131,7 @@ void KAPI salloc_init(void *base, uint32_t size)
return;
}
void *KAPI salloc(void *base, uint32_t size)
void *KAPI ke_salloc(void *base, uint32_t size)
{
void *result = NULL;
if (base != NULL && size != 0)
@ -186,7 +186,7 @@ void *KAPI salloc(void *base, uint32_t size)
return result;
}
void KAPI sfree(void *base, void *ptr)
void KAPI ke_sfree(void *base, void *ptr)
{
if (base != NULL && ptr != NULL)
{

50
x64/src/kernel/k_spin_lock.c
View File

@ -0,0 +1,50 @@
#include <k_spin_lock.h>
#include "k_atomic.h"
#include "k_spin_lock.h"
void KAPI ke_spin_lock_init(k_spin_lock_t *lock)
{
if (lock != NULL)
{
lock->val = 0;
}
}
void KAPI ke_spin_lock(k_spin_lock_t *lock)
{
if (lock != NULL)
{
while (ke_interlocked_compare_exchange(&lock->val, 0, 1) != 0);
}
return;
}
void KAPI ke_spin_unlock(k_spin_lock_t *lock)
{
if (lock != NULL)
{
lock->val = 0;
}
return;
}
k_irql_t KAPI ke_spin_lock_raise_irql(k_spin_lock_t *lock, k_irql_t irql)
{
k_irql_t prev_irql = ke_get_irql();
if (lock != NULL)
{
ke_raise_irql(irql);
ke_spin_lock(lock);
}
return prev_irql;
}
void KAPI ke_spin_unlock_lower_irql(k_spin_lock_t *lock, k_irql_t irql)
{
if (lock != NULL)
{
ke_spin_unlock(lock);
ke_lower_irql(irql);
}
return;
}

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

@ -34,7 +34,7 @@ static int32_t _avl_compare(k_avl_tree_node_t *tree_node, k_avl_tree_node_t *my_
return 1;
}
int32_t k_vmm_init(k_vmm_descriptor_t *desc)
int32_t KAPI k_vmm_init(k_vmm_descriptor_t *desc)
{
if (desc == NULL || desc->initialized)
{
@ -45,7 +45,7 @@ int32_t k_vmm_init(k_vmm_descriptor_t *desc)
return VMM_STATUS_SUCCESS;
}
int32_t k_alloc_virtual_address(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)
@ -70,12 +70,12 @@ int32_t k_alloc_virtual_address(k_vmm_descriptor_t *desc,
return VMM_STATUS_SUCCESS;
}
int64_t k_query_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t v_addr, uint64_t *out)
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 k_free_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t base)
int64_t KAPI k_free_virtual_address(k_vmm_descriptor_t *desc, k_virtual_addr_t base)
{
return 0;
}

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

@ -13,58 +13,58 @@ static char buffer[1024];
static bool salloc_init_test()
{
salloc_init(buffer, 1024);
ke_salloc_init(buffer, 1024);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
return salloc_assert(buffer,blk_size, blk_free, 1);
return ke_salloc_assert(buffer, blk_size, blk_free, 1);
}
static bool salloc_basic_alloc()
{
bool result = true;
salloc_init(buffer, 1024);
result = result && (salloc(buffer, 10) != NULL);
ke_salloc_init(buffer, 1024);
result = result && (ke_salloc(buffer, 10) != NULL);
uint32_t blk_size[] = {10 + salloc_header_size, 1024-10-salloc_header_size};
bool blk_free[] = {false,true};
result = result && salloc_assert(buffer,blk_size, blk_free, 2);
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 2);
return result;
}
static bool salloc_full_alloc()
{
bool result = true;
salloc_init(buffer, 1024);
result = result && (salloc(buffer, 1024 - salloc_header_size) != NULL);
ke_salloc_init(buffer, 1024);
result = result && (ke_salloc(buffer, 1024 - salloc_header_size) != NULL);
uint32_t blk_size[] = {1024};
bool blk_free[] = {false};
result = result && salloc_assert(buffer,blk_size, blk_free, 1);
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
static bool salloc_overflow_alloc()
{
bool result = true;
salloc_init(buffer, 1024);
result = result && (salloc(buffer, 1024 - salloc_header_size + 1) == NULL);
ke_salloc_init(buffer, 1024);
result = result && (ke_salloc(buffer, 1024 - salloc_header_size + 1) == NULL);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && salloc_assert(buffer,blk_size, blk_free, 1);
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
static bool salloc_multiple_alloc()
{
bool result = true;
salloc_init(buffer, 1024);
result = result && (salloc(buffer, 10) != NULL);
result = result && (salloc(buffer, 10) != NULL);
result = result && (salloc(buffer, 10) != NULL);
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);
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 && salloc_assert(buffer,blk_size, blk_free, 4);
result = result && ke_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;
salloc_init(buffer, salloc_header_size + salloc_header_size + salloc_header_size - 1);
ptr = salloc(buffer, salloc_header_size);
ke_salloc_init(buffer, salloc_header_size + salloc_header_size + salloc_header_size - 1);
ptr = ke_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 && salloc_assert(buffer,blk_size, blk_free, 1);
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
@ -86,14 +86,14 @@ static bool salloc_basic_free()
{
void* ptr;
bool result = true;
salloc_init(buffer, 1024);
ptr = salloc(buffer, 10);
ke_salloc_init(buffer, 1024);
ptr = ke_salloc(buffer, 10);
result = result && (ptr != NULL);
sfree(buffer, ptr);
ke_sfree(buffer, ptr);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && salloc_assert(buffer,blk_size, blk_free, 1);
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}
@ -101,14 +101,14 @@ static bool salloc_full_free()
{
void* ptr;
bool result = true;
salloc_init(buffer, 1024);
ptr = salloc(buffer, 1024 - salloc_header_size);
ke_salloc_init(buffer, 1024);
ptr = ke_salloc(buffer, 1024 - salloc_header_size);
result = result && (ptr != NULL);
sfree(buffer, ptr);
ke_sfree(buffer, ptr);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && salloc_assert(buffer,blk_size, blk_free, 1);
result = result && ke_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;
salloc_init(buffer, 1024);
ptr1 = salloc(buffer, 10);
ptr2 = salloc(buffer, 10);
ptr3 = salloc(buffer, 10);
ptr4 = salloc(buffer, 10);
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);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
sfree(buffer, ptr1);
sfree(buffer, ptr3);
ke_sfree(buffer, ptr1);
ke_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 && salloc_assert(buffer,blk_size, blk_free, 5);
result = result && ke_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;
salloc_init(buffer, 1024);
ptr1 = salloc(buffer, 10);
ptr2 = salloc(buffer, 10);
ptr3 = salloc(buffer, 10);
ptr4 = salloc(buffer, 10);
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);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
sfree(buffer, ptr4);
ke_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 && salloc_assert(buffer,blk_size, blk_free, 4);
result = result && ke_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;
salloc_init(buffer, 1024);
ptr1 = salloc(buffer, 10);
ptr2 = salloc(buffer, 10);
ptr3 = salloc(buffer, 10);
ptr4 = salloc(buffer, 10);
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);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
sfree(buffer, ptr1);
sfree(buffer, ptr2);
ke_sfree(buffer, ptr1);
ke_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 && salloc_assert(buffer,blk_size, blk_free, 4);
result = result && ke_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;
salloc_init(buffer, 1024);
ptr1 = salloc(buffer, 10);
ptr2 = salloc(buffer, 10);
ptr3 = salloc(buffer, 10);
ptr4 = salloc(buffer, 10);
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);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
sfree(buffer, ptr2);
sfree(buffer, ptr3);
ke_sfree(buffer, ptr2);
ke_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 && salloc_assert(buffer,blk_size, blk_free, 4);
result = result && ke_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;
salloc_init(buffer, 1024);
ptr1 = salloc(buffer, 10);
ptr2 = salloc(buffer, 10);
ptr3 = salloc(buffer, 10);
ptr4 = salloc(buffer, 10);
ptr5 = salloc(buffer, 10);
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);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL) && (ptr5 != NULL);
sfree(buffer, ptr2);
sfree(buffer, ptr4);
ke_sfree(buffer, ptr2);
ke_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 && salloc_assert(buffer,blk_size, blk_free, 6);
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 6);
sfree(buffer, ptr3);
ke_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 && salloc_assert(buffer,blk_size2, blk_free2, 4);
result = result && ke_salloc_assert(buffer, blk_size2, blk_free2, 4);
return result;
}
@ -238,20 +238,20 @@ static bool salloc_free_all()
{
void* ptr1, *ptr2, *ptr3, *ptr4;
bool result = true;
salloc_init(buffer, 1024);
ptr1 = salloc(buffer, 10);
ptr2 = salloc(buffer, 10);
ptr3 = salloc(buffer, 10);
ptr4 = salloc(buffer, 10);
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);
result = result && (ptr1 != NULL) && (ptr2 != NULL) && (ptr3 != NULL) && (ptr4 != NULL);
sfree(buffer, ptr1);
sfree(buffer, ptr2);
sfree(buffer, ptr3);
sfree(buffer, ptr4);
ke_sfree(buffer, ptr1);
ke_sfree(buffer, ptr2);
ke_sfree(buffer, ptr3);
ke_sfree(buffer, ptr4);
uint32_t blk_size[] = {1024};
bool blk_free[] = {true};
result = result && salloc_assert(buffer,blk_size, blk_free, 1);
result = result && ke_salloc_assert(buffer, blk_size, blk_free, 1);
return result;
}