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

Still broken

This commit is contained in:
secXsQuared 2016-08-27 17:20:38 -07:00
parent 5a3d467dbd
commit e6bbba7b60
22 changed files with 860 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,9 +6,6 @@
#ifndef _G_ABI_H_
#define _G_ABI_H_
#include <stddef.h>
#include <stdarg.h>
#define KAPI __attribute__((sysv_abi))
#define UAPI __attribute__((sysv_abi))

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

@ -5,7 +5,14 @@
#ifndef _G_TYPE_H_
#define _G_TYPE_H_
#include <stdint.h>
#include <stdbool.h>
#include <stdarg.h>
#include <stddef.h>
typedef int32_t (*k_callback_func_t)(void *kernel_args, void *user_args);
typedef uint32_t k_handle_t;
#endif

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

@ -13,7 +13,7 @@ typedef struct
uint64_t krnl_start;
uint64_t krnl_end;
k_hal_intr_info_t intr_info;
linked_list_t pmm_info;
k_linked_list_t pmm_info;
char cpu_vd_str[13];
} k_hal_boot_info_t;

10
x64/src/kernel/inc/k_assert.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef _K_ASSERT_H_
#define _K_ASSERT_H_
#include "g_type.h"
void hw_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)
#endif

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

@ -1,21 +1,6 @@
#ifndef _K_ATOMIC_H_
#define _K_ATOMIC_H_
#include "g_abi.h"
#include "k_intr.h"
#include "s_atomic.h"
typedef struct
{
int32_t val;
} k_spin_lock_t;
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

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

@ -3,57 +3,53 @@
* See COPYING under root for details
*/
#ifndef _AVL_TREE_H_
#define _AVL_TREE_H_
#ifndef _K_AVL_TREE_H_
#define _K_AVL_TREE_H_
#include "g_type.h"
#include "g_abi.h"
#include "k_stdlib.h"
typedef struct _avl_tree_node_t
typedef struct _k_avl_tree_node_t
{
struct _avl_tree_node_t *left;
struct _avl_tree_node_t *right;
struct _avl_tree_node_t *parent;
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;
} 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 int32_t (*avl_tree_node_compare_func_t)(avl_tree_node_t* tree_node, avl_tree_node_t* your_node);
typedef struct
* 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
{
avl_tree_node_compare_func_t compare;
avl_tree_node_t *root;
} avl_tree_t;
k_callback_func_t compare;
k_avl_tree_node_t *root;
} k_avl_tree_t;
avl_tree_node_t *KAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t *entry);
k_avl_tree_node_t *KAPI ke_avl_tree_search(k_avl_tree_t *tree, k_avl_tree_node_t *entry);
void KAPI avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *entry);
void KAPI ke_avl_tree_insert(k_avl_tree_t *tree, k_avl_tree_node_t *entry);
avl_tree_node_t* KAPI avl_tree_delete(avl_tree_t *tree, 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 avl_tree_init(avl_tree_t *tree, avl_tree_node_compare_func_t);
void KAPI ke_avl_tree_init(k_avl_tree_t *tree, k_callback_func_t compare);
avl_tree_node_t *KAPI avl_tree_largest(avl_tree_t *tree);
k_avl_tree_node_t *KAPI ke_avl_tree_largest(k_avl_tree_t *tree);
avl_tree_node_t *KAPI avl_tree_smallest(avl_tree_t *tree);
k_avl_tree_node_t *KAPI ke_avl_tree_smallest(k_avl_tree_t *tree);
avl_tree_node_t *KAPI avl_tree_larger(avl_tree_node_t *entry);
k_avl_tree_node_t *KAPI ke_avl_tree_larger(k_avl_tree_node_t *entry);
avl_tree_node_t *KAPI avl_tree_smaller(avl_tree_node_t *entry);
k_avl_tree_node_t *KAPI ke_avl_tree_smaller(k_avl_tree_node_t *entry);
bool KAPI avl_tree_validate(avl_tree_t *tree);
bool KAPI ke_avl_tree_validate(k_avl_tree_t *tree);
int32_t KAPI avl_tree_size(avl_tree_t *tree);
int32_t KAPI ke_avl_tree_size(k_avl_tree_t *tree);
#endif

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

@ -5,6 +5,8 @@
#include "g_type.h"
#include "g_abi.h"
void KAPI k_exc_handler_page_fault(void *context, void *intr_stack);
k_irql_t KAPI ke_raise_irql(k_irql_t irql);
k_irql_t KAPI ke_lower_irql(k_irql_t irql);
#endif

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

@ -3,60 +3,60 @@
* See COPYING under root for details
*/
#ifndef _LINKED_LIST_H_
#define _LINKED_LIST_H_
#ifndef _K_LINKED_LIST_H_
#define _K_LINKED_LIST_H_
#include "g_abi.h"
#include "g_type.h"
typedef struct _linked_list_node_t
typedef struct _k_linked_list_node_t
{
struct _linked_list_node_t *prev;
struct _linked_list_node_t *next;
} 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 _linked_list_t
typedef struct _k_linked_list_t
{
linked_list_node_t *head;
linked_list_node_t *tail;
} linked_list_t;
k_linked_list_node_t *head;
k_linked_list_node_t *tail;
} k_linked_list_t;
/*
* Returns true if other == your node
* Returns true if current list node == your node
* false otherwise
*/
typedef _Bool (*linked_list_node_equals_func_t)(linked_list_node_t * others, linked_list_node_t * yours);
void KAPI linked_list_init(linked_list_t *list);
void KAPI ke_linked_list_init(k_linked_list_t *list);
int KAPI linked_list_size(linked_list_t *list);
int32_t KAPI ke_linked_list_size(k_linked_list_t *list);
void KAPI linked_list_push_front(linked_list_t *list, linked_list_node_t *node);
void KAPI ke_linked_list_push_front(k_linked_list_t *list, k_linked_list_node_t *node);
void KAPI linked_list_push_back(linked_list_t *list, linked_list_node_t *node);
void KAPI ke_linked_list_push_back(k_linked_list_t *list, k_linked_list_node_t *node);
linked_list_node_t *KAPI linked_list_pop_front(linked_list_t *list);
k_linked_list_node_t *KAPI ke_linked_list_pop_front(k_linked_list_t *list);
linked_list_node_t *KAPI linked_list_pop_back(linked_list_t *list);
k_linked_list_node_t *KAPI ke_linked_list_pop_back(k_linked_list_t *list);
void KAPI linked_list_insert_idx(linked_list_t *list, int32_t index, linked_list_node_t *node);
void KAPI ke_linked_list_insert(k_linked_list_t *list, int32_t index, k_linked_list_node_t *node);
void KAPI linked_list_insert_ref(linked_list_t *list, linked_list_node_t *prev_node, 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);
linked_list_node_t *KAPI linked_list_remove_idx(linked_list_t *list, int32_t index);
k_linked_list_node_t *KAPI ke_linked_list_remove(k_linked_list_t *list, int32_t index);
linked_list_node_t *KAPI linked_list_remove_ref(linked_list_t *list, linked_list_node_t *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 *KAPI linked_list_get(linked_list_t *list, int32_t index);
k_linked_list_node_t *KAPI ke_linked_list_get(k_linked_list_t *list, int32_t index);
linked_list_node_t *KAPI linked_list_next(linked_list_node_t *node);
k_linked_list_node_t *KAPI ke_linked_list_next(k_linked_list_node_t *node);
linked_list_node_t *KAPI linked_list_prev(linked_list_node_t *node);
k_linked_list_node_t *KAPI ke_linked_list_prev(k_linked_list_node_t *node);
linked_list_node_t *KAPI linked_list_first(linked_list_t *list);
k_linked_list_node_t *KAPI ke_linked_list_first(k_linked_list_t *list);
linked_list_node_t *KAPI linked_list_last(linked_list_t *list);
k_linked_list_node_t *KAPI ke_linked_list_last(k_linked_list_t *list);
int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t* target, linked_list_node_equals_func_t equals);
int32_t KAPI ke_linked_list_search(k_linked_list_t *list, k_linked_list_node_t *target,
k_callback_func_t equals);
#endif

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

@ -1,31 +1,38 @@
#ifndef _K_REF_H_
#define _K_REF_H_
#include "g_abi.h"
#include "g_type.h"
#include "k_avl_tree.h"
#include "k_atomic.h"
typedef void (*k_ref_callback_func_t)(void* ptr, void* context);
#include "k_status.h"
typedef struct
{
avl_tree_t* avl_tree;
_Bool initialized;
k_spin_lock_t lock;
} k_ref_desc_t;
int32_t ref_count;
k_callback_func_t free_routine;
} k_ref_node_t;
#define K_REF_STATUS_SUCCESS 0
#define K_REF_STATUS_INVALID_ARGUMENTS 1
#define K_REF_STATUS_CANNOT_ALLOCATE_MEM 2
#define K_REF_STATUS_REF_NOT_FOUND 3
#define K_HANDLE_BASE 0x80000000
int32_t KAPI k_ref_init(k_ref_desc_t* desc);
//#define K_HANDLE_CURRENT_THREAD 0x1
int32_t KAPI k_ref_create(void* ptr, k_ref_callback_func_t callback, void* context);
//
// All functions are hw since users or kernel devs should not be
// specifying where the allocations take place
//
int32_t KAPI k_ref_inc(void* ptr);
k_status_t ke_reference_setup();
int32_t KAPI k_ref_dec(void* ptr);
k_status_t ke_reference_create(k_ref_node_t *ref,
k_callback_func_t free_func);
#endif
k_status_t ke_reference_obj(k_ref_node_t *ref);
k_status_t 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 sx_create_handle(k_ref_node_t *ref, k_handle_t *out);
k_status_t sx_close_handle(k_handle_t handle);
#endif

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

@ -0,0 +1,23 @@
#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

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

@ -15,9 +15,6 @@
// bits 15-29 - Facility 32768 in total
//
typedef uint32_t k_status_t;
#define SX_SUCCESS(status) (((status) >> 30) == 0)
#define SX_RETURN(status) (((status) & ke_bit_field_mask(15,29)) >> 15)
#define SX_FACILITY(status) ((status) & ke_bit_field_mask(0,14))
@ -28,11 +25,12 @@ typedef uint32_t k_status_t;
#define SEVERITY_SUCCESS 0x0
#define FACILITY_GENERIC 0
#define FACILITY_REF 1
typedef enum
typedef enum _k_status_t
{
STATUS_SUCCESS = SX_MAKE_STATUS(SEVERITY_SUCCESS, FACILITY_GENERIC, 0),
};
} k_status_t;
#endif

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

@ -16,7 +16,7 @@ typedef struct
typedef struct
{
avl_tree_t region_tree;
k_avl_tree_t region_tree;
_Bool initialized;
k_spin_lock_t lock;
} k_vmm_descriptor_t;

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

@ -1,10 +1,20 @@
#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_exchange(&lock->val, 1) == 1);
while (ke_interlocked_compare_exchange(&lock->val, 0, 1) != 0);
}
return;
}
@ -21,7 +31,7 @@ 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)
{
k_irql_t prev_irql = ke_get_irql();
if(lock != NULL)
if (lock != NULL)
{
ke_set_irql(irql);
ke_spin_lock(lock);
@ -31,7 +41,7 @@ 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)
{
if(lock != NULL)
if (lock != NULL)
{
ke_spin_unlock(lock);
ke_set_irql(irql);

84
x64/src/kernel/k_avl_tree.c
View File

@ -5,21 +5,21 @@
#include "k_avl_tree.h"
static inline int32_t KAPI _avl_tree_node_get_height(avl_tree_node_t *node)
static inline int32_t KAPI _avl_tree_node_get_height(k_avl_tree_node_t *node)
{
return node == NULL ? -1 : node->height;
}
static inline int32_t KAPI _avl_tree_node_get_balance_factor(avl_tree_node_t *node)
static inline int32_t KAPI _avl_tree_node_get_balance_factor(k_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);
}
static avl_tree_node_t *KAPI _avl_tree_node_right_rotate(avl_tree_node_t *root)
static k_avl_tree_node_t *KAPI _avl_tree_node_right_rotate(k_avl_tree_node_t *root)
{
avl_tree_node_t *left_children = root->left;
k_avl_tree_node_t *left_children = root->left;
//adjust parents first
left_children->parent = root->parent;
root->parent = left_children;
@ -35,9 +35,9 @@ static avl_tree_node_t *KAPI _avl_tree_node_right_rotate(avl_tree_node_t *root)
return left_children;
}
static avl_tree_node_t *KAPI _avl_tree_node_left_rotate(avl_tree_node_t *root)
static k_avl_tree_node_t *KAPI _avl_tree_node_left_rotate(k_avl_tree_node_t *root)
{
avl_tree_node_t *right_children = root->right;
k_avl_tree_node_t *right_children = root->right;
//adjust parents
right_children->parent = root->parent;
root->parent = right_children;
@ -54,7 +54,7 @@ static avl_tree_node_t *KAPI _avl_tree_node_left_rotate(avl_tree_node_t *root)
return right_children;
}
static avl_tree_node_t *KAPI _avl_tree_node_balance(avl_tree_node_t *node)
static k_avl_tree_node_t *KAPI _avl_tree_node_balance(k_avl_tree_node_t *node)
{
const int32_t bf = _avl_tree_node_get_balance_factor(node);
@ -91,9 +91,9 @@ static avl_tree_node_t *KAPI _avl_tree_node_balance(avl_tree_node_t *node)
}
static avl_tree_node_t *KAPI _avl_tree_node_insert(avl_tree_node_t *root, avl_tree_node_t *node,
avl_tree_node_compare_func_t compare,
avl_tree_node_t *parent)
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)
{
if (node == NULL || compare == NULL)
return root;
@ -116,13 +116,13 @@ static avl_tree_node_t *KAPI _avl_tree_node_insert(avl_tree_node_t *root, avl_tr
return _avl_tree_node_balance(root);
}
static void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
static void _avl_tree_swap_nodes(k_avl_tree_node_t *node1, k_avl_tree_node_t *node2)
{
if (node1 == NULL || node2 == NULL)
return;
avl_tree_node_t *parent = NULL;
avl_tree_node_t *child = NULL;
avl_tree_node_t *temp = NULL;
k_avl_tree_node_t *parent = NULL;
k_avl_tree_node_t *child = NULL;
k_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,10 +238,10 @@ static void _avl_tree_swap_nodes(avl_tree_node_t *node1, avl_tree_node_t *node2)
return;
}
static avl_tree_node_t *KAPI _avl_tree_node_delete(avl_tree_node_t *root,
avl_tree_node_t *node,
avl_tree_node_compare_func_t compare,
avl_tree_node_t **deleted_node)
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)
{
if (root == NULL || node == NULL || compare == NULL || deleted_node == NULL)
return root;
@ -256,7 +256,7 @@ static avl_tree_node_t *KAPI _avl_tree_node_delete(avl_tree_node_t *root,
// node with only one child or no child
if ((root->left == NULL) || (root->right == NULL))
{
avl_tree_node_t *child = root->left != NULL ? root->left : root->right;
k_avl_tree_node_t *child = root->left != NULL ? root->left : root->right;
if (child == NULL)
{ // 0 child
@ -272,7 +272,7 @@ static avl_tree_node_t *KAPI _avl_tree_node_delete(avl_tree_node_t *root,
{
// node with two children: Get the inorder successor (smallest
// in the right subtree)
avl_tree_node_t *successor = avl_tree_larger(root);
k_avl_tree_node_t *successor = ke_avl_tree_larger(root);
//swap fields
_avl_tree_swap_nodes(successor, root);
@ -289,8 +289,8 @@ static avl_tree_node_t *KAPI _avl_tree_node_delete(avl_tree_node_t *root,
return root;
}
static avl_tree_node_t *KAPI _avl_tree_node_search(avl_tree_node_t *root, avl_tree_node_t *node,
avl_tree_node_compare_func_t compare)
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)
{
if (root == NULL || compare == NULL)
return NULL;
@ -304,7 +304,7 @@ static avl_tree_node_t *KAPI _avl_tree_node_search(avl_tree_node_t *root, avl_tr
}
static void KAPI _avl_tree_node_init(avl_tree_node_t *it)
static void KAPI _avl_tree_node_init(k_avl_tree_node_t *it)
{
if (it != NULL)
{
@ -317,11 +317,11 @@ static void KAPI _avl_tree_node_init(avl_tree_node_t *it)
}
avl_tree_node_t *KAPI avl_tree_smallest(avl_tree_t *tree)
k_avl_tree_node_t *KAPI ke_avl_tree_smallest(k_avl_tree_t *tree)
{
if (tree == NULL)
return NULL;
avl_tree_node_t *entry = tree->root;
k_avl_tree_node_t *entry = tree->root;
if (entry == NULL)
return NULL;
while (entry->left != NULL)
@ -329,11 +329,11 @@ avl_tree_node_t *KAPI avl_tree_smallest(avl_tree_t *tree)
return entry;
}
avl_tree_node_t *KAPI avl_tree_largest(avl_tree_t *tree)
k_avl_tree_node_t *KAPI ke_avl_tree_largest(k_avl_tree_t *tree)
{
if (tree == NULL)
return NULL;
avl_tree_node_t *entry = tree->root;
k_avl_tree_node_t *entry = tree->root;
if (entry == NULL)
return NULL;
while (entry->right != NULL)
@ -342,11 +342,11 @@ avl_tree_node_t *KAPI avl_tree_largest(avl_tree_t *tree)
}
avl_tree_node_t *KAPI avl_tree_larger(avl_tree_node_t *it)
k_avl_tree_node_t *KAPI ke_avl_tree_larger(k_avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
avl_tree_node_t *root = it;
k_avl_tree_node_t *root = it;
if (root->right != NULL)
{
root = root->right;
@ -366,11 +366,11 @@ avl_tree_node_t *KAPI avl_tree_larger(avl_tree_node_t *it)
}
}
avl_tree_node_t *KAPI avl_tree_smaller(avl_tree_node_t *it)
k_avl_tree_node_t *KAPI ke_avl_tree_smaller(k_avl_tree_node_t *it)
{
if (it == NULL)
return NULL;
avl_tree_node_t *root = it;
k_avl_tree_node_t *root = it;
if (root->left != NULL)
{
root = root->left;
@ -390,13 +390,13 @@ avl_tree_node_t *KAPI avl_tree_smaller(avl_tree_node_t *it)
}
}
avl_tree_node_t *KAPI avl_tree_search(avl_tree_t *tree, avl_tree_node_t *node)
k_avl_tree_node_t *KAPI ke_avl_tree_search(k_avl_tree_t *tree, k_avl_tree_node_t *node)
{
return _avl_tree_node_search(tree->root, node, tree->compare);
}
void KAPI avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *data)
void KAPI ke_avl_tree_insert(k_avl_tree_t *tree, k_avl_tree_node_t *data)
{
if (tree != NULL && data != NULL)
{
@ -406,9 +406,9 @@ void KAPI avl_tree_insert(avl_tree_t *tree, avl_tree_node_t *data)
return;
}
avl_tree_node_t *KAPI avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *data)
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 *node = NULL;
k_avl_tree_node_t *node = NULL;
if (tree != NULL && data != NULL)
{
tree->root = _avl_tree_node_delete(tree->root, data, tree->compare, &node);
@ -416,23 +416,23 @@ avl_tree_node_t *KAPI avl_tree_delete(avl_tree_t *tree, avl_tree_node_t *data)
return node;
}
int32_t KAPI avl_tree_size(avl_tree_t *tree)
int32_t KAPI ke_avl_tree_size(k_avl_tree_t *tree)
{
if (tree == NULL)
return -1;
if (tree->root == NULL)
return 0;
int32_t size = 0;
avl_tree_node_t *entry = avl_tree_smallest(tree);
k_avl_tree_node_t *entry = ke_avl_tree_smallest(tree);
while (entry != NULL)
{
size++;
entry = avl_tree_larger(entry);
entry = ke_avl_tree_larger(entry);
}
return size;
}
void KAPI avl_tree_init(avl_tree_t *tree, avl_tree_node_compare_func_t compare)
void KAPI ke_avl_tree_init(k_avl_tree_t *tree, k_callback_func_t compare)
{
if (tree != NULL)
{
@ -446,14 +446,14 @@ void KAPI avl_tree_init(avl_tree_t *tree, avl_tree_node_compare_func_t compare)
// TESTING STUFF
static int32_t KAPI _avl_tree_node_calculate_height(avl_tree_node_t *tree)
static int32_t KAPI _avl_tree_node_calculate_height(k_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;
}
static bool KAPI _avl_tree_node_test(avl_tree_node_t *tree, int32_t (*compare)(avl_tree_node_t *, avl_tree_node_t *))
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 *))
{
if (tree == NULL)
return true;
@ -479,7 +479,7 @@ static bool KAPI _avl_tree_node_test(avl_tree_node_t *tree, int32_t (*compare)(a
return _avl_tree_node_test(tree->left, compare) && _avl_tree_node_test(tree->right, compare);
}
bool KAPI avl_tree_validate(avl_tree_t *tree)
bool KAPI ke_avl_tree_validate(k_avl_tree_t *tree)
{
if (tree == NULL)
return true;

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

@ -1,6 +1,12 @@
#include "k_intr.h"
void KAPI k_exc_handler_page_fault(void *context, void *intr_stack)
k_irql_t KAPI ke_raise_irql(k_irql_t irql)
{
}
k_irql_t KAPI ke_lower_irql(k_irql_t irql)
{
}

77
x64/src/kernel/k_linked_list.c
View File

@ -5,7 +5,7 @@
#include "k_linked_list.h"
static void KAPI _init_linked_list_node(linked_list_node_t *node)
static void KAPI _init_linked_list_node(k_linked_list_node_t *node)
{
if (node != NULL)
{
@ -15,12 +15,12 @@ static void KAPI _init_linked_list_node(linked_list_node_t *node)
return;
}
static void KAPI _append_node(linked_list_node_t *target, linked_list_node_t *node)
static void KAPI _append_node(k_linked_list_node_t *target, k_linked_list_node_t *node)
{
if(target == NULL || node == NULL)
return;
linked_list_node_t* next = target->next;
k_linked_list_node_t* next = target->next;
// update the next node
if(next != NULL)
{
@ -38,12 +38,12 @@ static void KAPI _append_node(linked_list_node_t *target, linked_list_node_t *no
}
// link target with node, suppose target is in the current list
static void KAPI _prepend_node(linked_list_node_t *target, linked_list_node_t *node)
static void KAPI _prepend_node(k_linked_list_node_t *target, k_linked_list_node_t *node)
{
if(target == NULL || node == NULL)
return;
linked_list_node_t* prev = target->prev;
k_linked_list_node_t* prev = target->prev;
// update the prev node
if(prev != NULL)
{
@ -60,7 +60,7 @@ static void KAPI _prepend_node(linked_list_node_t *target, linked_list_node_t *n
return;
}
static void KAPI _unlink_node(linked_list_node_t* node)
static void KAPI _unlink_node(k_linked_list_node_t* node)
{
if(node == NULL)
return;
@ -78,7 +78,7 @@ static void KAPI _unlink_node(linked_list_node_t* node)
return;
}
void KAPI linked_list_init(linked_list_t *list)
void KAPI ke_linked_list_init(k_linked_list_t *list)
{
if (list != NULL)
{
@ -88,7 +88,7 @@ void KAPI linked_list_init(linked_list_t *list)
return;
}
int32_t KAPI linked_list_size(linked_list_t *list)
int32_t KAPI ke_linked_list_size(k_linked_list_t *list)
{
if (list == NULL)
return -1;
@ -96,8 +96,8 @@ int32_t KAPI linked_list_size(linked_list_t *list)
return 0;
int32_t size = 1;
linked_list_node_t *cur_node = list->head;
linked_list_node_t *tail = list->tail;
k_linked_list_node_t *cur_node = list->head;
k_linked_list_node_t *tail = list->tail;
while ((cur_node != tail) && ((cur_node = cur_node->next) != NULL))
{
size++;
@ -105,47 +105,47 @@ int32_t KAPI linked_list_size(linked_list_t *list)
return size;
}
void KAPI linked_list_push_front(linked_list_t *list, linked_list_node_t *node)
void KAPI ke_linked_list_push_front(k_linked_list_t *list, k_linked_list_node_t *node)
{
if (list == NULL || node == NULL)
return;
_init_linked_list_node(node);
linked_list_insert_ref(list, NULL, node);
ke_linked_list_insert_ref(list, NULL, node);
return;
}
void KAPI linked_list_push_back(linked_list_t *list, linked_list_node_t *node)
void KAPI ke_linked_list_push_back(k_linked_list_t *list, k_linked_list_node_t *node)
{
if (list == NULL || node == NULL)
return;
_init_linked_list_node(node);
linked_list_insert_ref(list, list->tail, node);
ke_linked_list_insert_ref(list, list->tail, node);
return;
}
linked_list_node_t *KAPI linked_list_pop_front(linked_list_t *list)
k_linked_list_node_t *KAPI ke_linked_list_pop_front(k_linked_list_t *list)
{
if (list == NULL)
return NULL;
return linked_list_remove_ref(list, list->head);
return ke_linked_list_remove_ref(list, list->head);
}
linked_list_node_t *KAPI linked_list_pop_back(linked_list_t *list)
k_linked_list_node_t *KAPI ke_linked_list_pop_back(k_linked_list_t *list)
{
if (list == NULL)
return NULL;
return linked_list_remove_ref(list, list->tail);
return ke_linked_list_remove_ref(list, list->tail);
}
void KAPI linked_list_insert_ref(linked_list_t *list, linked_list_node_t *prev_node, 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)
{
if (list == NULL || node == NULL)
return;
@ -180,41 +180,41 @@ void KAPI linked_list_insert_ref(linked_list_t *list, linked_list_node_t *prev_n
}
}
void KAPI linked_list_insert_idx(linked_list_t *list, int32_t index, linked_list_node_t *node)
void KAPI ke_linked_list_insert(k_linked_list_t *list, int32_t index, k_linked_list_node_t *node)
{
if (list == NULL || index < 0 || node == NULL)
return;
linked_list_node_t *prev_node = linked_list_get(list, index - 1);
k_linked_list_node_t *prev_node = ke_linked_list_get(list, index - 1);
_init_linked_list_node(node);
if (prev_node == NULL)
{
if (index == 0)
{
linked_list_insert_ref(list, NULL, node);
ke_linked_list_insert_ref(list, NULL, node);
}
}
else
{
linked_list_insert_ref(list, prev_node, node);
ke_linked_list_insert_ref(list, prev_node, node);
}
return;
}
linked_list_node_t *KAPI linked_list_remove_idx(linked_list_t *list, int32_t index)
k_linked_list_node_t *KAPI ke_linked_list_remove(k_linked_list_t *list, int32_t index)
{
if (list == NULL || index < 0)
return NULL;
linked_list_node_t *cur_node = linked_list_get(list, index);
k_linked_list_node_t *cur_node = ke_linked_list_get(list, index);
if (cur_node == NULL)
return NULL;
return linked_list_remove_ref(list, cur_node);
return ke_linked_list_remove_ref(list, cur_node);
}
linked_list_node_t *KAPI linked_list_remove_ref(linked_list_t *list, linked_list_node_t *node)
k_linked_list_node_t *KAPI ke_linked_list_remove_ref(k_linked_list_t *list, k_linked_list_node_t *node)
{
if (list == NULL || node == NULL)
return NULL;
@ -236,16 +236,16 @@ linked_list_node_t *KAPI linked_list_remove_ref(linked_list_t *list, linked_list
return node;
}
linked_list_node_t *KAPI linked_list_get(linked_list_t *list, int32_t index)
k_linked_list_node_t *KAPI ke_linked_list_get(k_linked_list_t *list, int32_t index)
{
if (list == NULL || index < 0 || list->head == NULL)
return NULL;
linked_list_node_t *cur_node = list->head;
k_linked_list_node_t *cur_node = list->head;
while (index-- && (cur_node = cur_node->next) != NULL);
return cur_node;
}
linked_list_node_t *KAPI linked_list_next(linked_list_node_t *node)
k_linked_list_node_t *KAPI ke_linked_list_next(k_linked_list_node_t *node)
{
if (node != NULL)
{
@ -254,7 +254,7 @@ linked_list_node_t *KAPI linked_list_next(linked_list_node_t *node)
return node;
}
linked_list_node_t *KAPI linked_list_prev(linked_list_node_t *node)
k_linked_list_node_t *KAPI ke_linked_list_prev(k_linked_list_node_t *node)
{
if (node != NULL)
{
@ -263,9 +263,9 @@ linked_list_node_t *KAPI linked_list_prev(linked_list_node_t *node)
return node;
}
linked_list_node_t *KAPI linked_list_first(linked_list_t *list)
k_linked_list_node_t *KAPI ke_linked_list_first(k_linked_list_t *list)
{
linked_list_node_t *result = NULL;
k_linked_list_node_t *result = NULL;
if (list != NULL)
{
result = list->head;
@ -273,9 +273,9 @@ linked_list_node_t *KAPI linked_list_first(linked_list_t *list)
return result;
}
linked_list_node_t *KAPI linked_list_last(linked_list_t *list)
k_linked_list_node_t *KAPI ke_linked_list_last(k_linked_list_t *list)
{
linked_list_node_t *result = NULL;
k_linked_list_node_t *result = NULL;
if (list != NULL)
{
result = list->tail;
@ -283,12 +283,13 @@ linked_list_node_t *KAPI linked_list_last(linked_list_t *list)
return result;
}
int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t *target, linked_list_node_equals_func_t equals)
int32_t KAPI ke_linked_list_search(k_linked_list_t *list, k_linked_list_node_t *target,
k_callback_func_t equals)
{
if(list == NULL || target == NULL)
return -1;
int32_t result = 0;
linked_list_node_t* node = linked_list_first(list);
k_linked_list_node_t* node = ke_linked_list_first(list);
while(node != NULL)
{
if(equals != NULL)
@ -306,7 +307,7 @@ int32_t KAPI linked_list_search(linked_list_t *list, linked_list_node_t *target,
}
}
result++;
node = linked_list_next(node);
node = ke_linked_list_next(node);
}
return -1;

28
x64/src/kernel/k_pmm.c
View File

@ -4,16 +4,16 @@
typedef struct
{
linked_list_node_t free_list_node;
avl_tree_node_t avl_tree_node;
k_linked_list_node_t free_list_node;
k_avl_tree_node_t avl_tree_node;
k_physical_addr_t base;
//k_physical_page_attr_t attr;
} k_physical_page_descriptor_t;
typedef struct
{
avl_tree_t active_tree;
linked_list_t free_list;
k_avl_tree_t active_tree;
k_linked_list_t free_list;
k_spin_lock_t lock;
_Bool initialized;
} k_pmm_descriptor_t;
@ -27,7 +27,7 @@ static k_pmm_descriptor_t _pmm_desc;
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
static int32_t _avl_compare(avl_tree_node_t *tree_node, avl_tree_node_t *my_node)
static int32_t _avl_compare(k_avl_tree_node_t *tree_node, k_avl_tree_node_t *my_node)
{
k_physical_addr_t tree_base = OBTAIN_STRUCT_ADDR(tree_node,
k_physical_page_descriptor_t,
@ -50,8 +50,8 @@ int32_t KAPI k_pmm_init(k_pmm_info_t *info)
return PMM_STATUS_INVALID_ARGUMENTS;
}
linked_list_init(&desc->free_list);
avl_tree_init(&desc->active_tree, _avl_compare);
ke_linked_list_init(&desc->free_list);
ke_avl_tree_init(&desc->active_tree, _avl_compare);
for (uint32_t i = 0; i < info->num_of_nodes; i++)
{
k_pmm_node_t *each_node = &info->nodes[i];
@ -76,7 +76,7 @@ int32_t KAPI k_pmm_init(k_pmm_info_t *info)
}
page_info->base = each_node->base;
linked_list_push_back(&desc->free_list, &page_info->free_list_node);
ke_linked_list_push_back(&desc->free_list, &page_info->free_list_node);
}
}
desc->initialized = true;
@ -95,15 +95,15 @@ int32_t KAPI k_alloc_page(k_pmm_descriptor_t *desc, k_physical_addr_t *out)
k_irql_t irql = ke_spin_lock_raise_irql(&desc->lock, K_IRQL_DISABLED_LEVEL);
int32_t result = PMM_STATUS_SUCCESS;
linked_list_node_t *node = NULL;
k_linked_list_node_t *node = NULL;
k_physical_page_descriptor_t *page_info = NULL;
node = linked_list_pop_front(&desc->free_list);
node = ke_linked_list_pop_front(&desc->free_list);
if (node != NULL)
{
page_info = OBTAIN_STRUCT_ADDR(node,
k_physical_page_descriptor_t,
free_list_node);
avl_tree_insert(&desc->active_tree, &page_info->avl_tree_node);
ke_avl_tree_insert(&desc->active_tree, &page_info->avl_tree_node);
*out = page_info->base;
}
else
@ -156,16 +156,16 @@ int32_t KAPI k_free_page(k_pmm_descriptor_t* desc, k_physical_addr_t base)
// just lock since not sharing with anyone
k_irql_t irql = ke_spin_lock_raise_irql(&desc->lock, K_IRQL_DISABLED_LEVEL);
int32_t result = PMM_STATUS_SUCCESS;
avl_tree_node_t *node = NULL;
k_avl_tree_node_t *node = NULL;
// search for dummy
k_physical_page_descriptor_t dummy, *page_info;
dummy.base = base;
node = avl_tree_delete(&desc->active_tree, &dummy.avl_tree_node);
node = ke_avl_tree_delete(&desc->active_tree, &dummy.avl_tree_node);
if (node != NULL)
{
page_info = OBTAIN_STRUCT_ADDR(node, k_physical_page_descriptor_t, avl_tree_node);
linked_list_push_back(&desc->free_list, &page_info->free_list_node);
ke_linked_list_push_back(&desc->free_list, &page_info->free_list_node);
}
else
{

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

@ -1,57 +1,310 @@
#include "k_ref.h"
#include <k_ref.h>
#include "k_avl_tree.h"
typedef struct
{
avl_tree_node_t tree_node;
void* ref_ptr;
uint32_t ref_count;
k_ref_callback_func_t callback;
} k_ref_node_t;
k_avl_tree_node_t tree_node;
k_handle_t handle;
k_ref_node_t *ref;
k_callback_func_t free_routine;
} hw_handle_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
*/
static int32_t _avl_compare(avl_tree_node_t *tree_node, avl_tree_node_t *my_node)
static void handle_node_free(void *node, void *up)
{
k_physical_addr_t tree_base = OBTAIN_STRUCT_ADDR(tree_node,
k_physical_page_descriptor_t,
avl_tree_node)->base;
k_physical_addr_t my_base = OBTAIN_STRUCT_ADDR(my_node,
k_physical_page_descriptor_t,
avl_tree_node)->base;
if (tree_base > my_base)
return 1;
else if (tree_base < my_base)
hw_free(node);
}
// ===========================
// Ke Functions
// ===========================
static k_avl_tree_t _handle_tree;
static bool _initialized;
static hw_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)
{
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);
if ((uintptr_t) tcb->handle > (uintptr_t) my_tcb->handle)
return -1;
else
else if ((uintptr_t) tcb->handle == (uintptr_t) my_tcb->handle)
return 0;
else
return 1;
}
int32_t KAPI k_ref_init(k_ref_desc_t *desc)
static hw_handle_node_t *search_handle_node(hw_handle_t handle)
{
if(desc == NULL)
return K_REF_STATUS_INVALID_ARGUMENTS;
avl_tree_init(&desc->avl_tree);
k_avl_tree_node_t *result;
hw_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);
}
int32_t KAPI k_ref_create(void *ptr, k_ref_callback_func_t callback, void *context)
k_status_t ke_reference_setup()
{
return 0;
if (!_initialized)
{
ke_avl_tree_init(&_handle_tree, handle_compare);
ke_spin_lock_init(&_handle_tree_lock);
_handle_base = HW_HANDLE_BASE;
_initialized = true;
}
return STATUS_SUCCESS;
}
int32_t KAPI k_ref_inc(void *ptr)
k_status_t ke_reference_create(hw_ref_node_t *ref,
hw_callback_func_t free_func)
{
return 0;
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
if (ref == NULL || free_func == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
ref->callback = free_func;
ref->ref_count = 1;
return STATUS_SUCCESS;
}
int32_t KAPI k_ref_dec(void *ptr)
hw_result_t ke_reference_obj(hw_ref_node_t *ref_node)
{
return 0;
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
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);
return STATUS_SUCCESS;
}
hw_result_t ke_dereference_obj(hw_ref_node_t *ref_node)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
if (ref_node == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
hw_result_t result = STATUS_SUCCESS;
int32_t old_ref_count = ke_interlocked_increment(&ref_node->ref_count, -1);
hw_assert(old_ref_count >= 1);
if (old_ref_count == 1)
{
ref_node->callback(ref_node, NULL);
}
return result;
}
static hw_result_t ke_open_obj_by_handle(hw_handle_t handle, hw_ref_node_t **out)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
{
return REF_STATUS_UNINITIALIZED;
}
if (out == NULL)
{
return REF_STATUS_INVALID_ARGUMENTS;
}
hw_irql_t irql;
hw_result_t result = STATUS_SUCCESS;
hw_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);
if (handle_node == NULL)
{
result = REF_STATUS_HANDLE_NOT_FOUND;
}
else
{
ref = handle_node->ref;
}
// PREREQUISITE: Having a handle -> having a reference
// MUST GUARANTEE that handle exists while we reference
if (HW_SUCCESS(result))
{
// reference the object then return the reference
result = ke_reference_obj(ref);
if (HW_SUCCESS(result))
{
*out = ref;
}
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
return result;
}
static hw_result_t ke_create_handle(hw_ref_node_t *ref,
hw_handle_node_t *node,
hw_handle_t *out)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
if (ref == NULL || node == NULL || out == NULL)
return REF_STATUS_INVALID_ARGUMENTS;
hw_result_t result = STATUS_SUCCESS;
hw_irql_t irql;
if (HW_SUCCESS(result))
{
// TODO: CHECK OVERFLOW
node->handle = (hw_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);
if (existing_node == NULL)
{
ke_avl_tree_insert(&_handle_tree, &node->tree_node);
}
else
{
result = REF_STATUS_HANDLE_DUPLICATE;
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
}
if (HW_SUCCESS(result))
{
ke_reference_obj(ref);
*out = node->handle;
}
else
{
node->free_func(node, NULL);
}
return result;
}
static hw_result_t ke_close_handle(hw_handle_t handle)
{
hw_assert(ke_get_irql() <= HW_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;
irql = ke_spin_lock_raise_irql(&_handle_tree_lock, HW_IRQL_DPC_LEVEL);
hw_handle_node_t *handle_node = search_handle_node(handle);
if (handle_node == NULL)
{
result = REF_STATUS_HANDLE_NOT_FOUND;
}
else
{
ref = handle_node->ref;
ke_avl_tree_delete(&_handle_tree, &handle_node->tree_node);
handle_node->free_func(handle_node, NULL);
}
ke_spin_unlock_lower_irql(&_handle_tree_lock, irql);
if (HW_SUCCESS(result))
{
// dereference the object
result = ke_dereference_obj(ref);
}
return result;
}
// ===========================
// HW Functions
// ===========================
hw_result_t hw_create_handle(hw_ref_node_t *ref, hw_handle_t *out)
{
hw_assert(ke_get_irql() <= HW_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));
if (node == NULL)
{
return REF_STATUS_CANNOT_ALLOCATE_MEM;
}
node->free_func = handle_node_free;
return ke_create_handle(ref, node, out);
}
hw_result_t hw_close_handle(hw_handle_t handle)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
if (handle == HW_HANDLE_CURRENT_THREAD)
{
return REF_STATUS_NO_EFFECT;
}
hw_result_t result = ke_close_handle(handle);
return result;
}
hw_result_t hw_open_obj_by_handle(hw_handle_t handle, hw_ref_node_t **out)
{
hw_assert(ke_get_irql() <= HW_IRQL_DPC_LEVEL);
if (!_initialized)
return REF_STATUS_UNINITIALIZED;
if (out == NULL)
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;
}
return ke_open_obj_by_handle(handle, out);
}

0
x64/src/kernel/k_spin_lock.c Normal file
View File

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

@ -3,7 +3,7 @@
typedef struct
{
avl_tree_node_t tree_node;
k_avl_tree_node_t tree_node;
k_virtual_addr_attribute_t attribute;
k_virtual_addr_t base;
uint64_t size;
@ -16,7 +16,7 @@ typedef struct
* = 0 if tree_node == your_node
* > 0 if tree_node > your_node
*/
static int32_t _avl_compare(avl_tree_node_t *tree_node, avl_tree_node_t *my_node)
static int32_t _avl_compare(k_avl_tree_node_t *tree_node, k_avl_tree_node_t *my_node)
{
k_virtual_addr_descriptor_t *that = OBTAIN_STRUCT_ADDR(tree_node,
k_virtual_addr_descriptor_t,
@ -40,7 +40,7 @@ int32_t k_vmm_init(k_vmm_descriptor_t *desc)
{
return VMM_STATUS_INVALID_ARGUMENTS;
}
avl_tree_init(&desc->region_tree, _avl_compare);
ke_avl_tree_init(&desc->region_tree, _avl_compare);
return VMM_STATUS_SUCCESS;
}
@ -65,7 +65,7 @@ int32_t k_alloc_virtual_address(k_vmm_descriptor_t *desc,
node->size = size;
node->attribute = attr;
avl_tree_insert(&desc->region_tree, &node->tree_node);
ke_avl_tree_insert(&desc->region_tree, &node->tree_node);
return VMM_STATUS_SUCCESS;
}

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

@ -3,7 +3,7 @@
typedef struct
{
avl_tree_node_t tree_entry;
k_avl_tree_node_t tree_entry;
int val;
} int_tree_node;
@ -14,7 +14,7 @@ static int_tree_node *create_tree_node(int val)
return rs;
}
static int compare(avl_tree_node_t *root, avl_tree_node_t *node)
static int compare(k_avl_tree_node_t *root, k_avl_tree_node_t *node)
{
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);
@ -40,7 +40,7 @@ static int compare(avl_tree_node_t *root, avl_tree_node_t *node)
static int counter = 0;
static bool _pre_order_assert(avl_tree_node_t *node, int order[], int size)
static bool _pre_order_assert(k_avl_tree_node_t *node, int order[], int size)
{
if (node == NULL)
return true;
@ -59,7 +59,7 @@ static bool _pre_order_assert(avl_tree_node_t *node, int order[], int size)
return result;
}
static bool pre_order_assert(avl_tree_t *node, int order[], int size)
static bool pre_order_assert(k_avl_tree_t *node, int order[], int size)
{
counter = 0;
return _pre_order_assert(node->root, order, size);
@ -76,19 +76,19 @@ static bool insert_simple_l()
// 3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
int val1[] = {1, 2};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_simple_r()
@ -100,19 +100,19 @@ static bool insert_simple_r()
//1
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
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, &create_tree_node(2)->tree_entry);
int val1[] = {3, 2};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_simple_ll()
@ -123,19 +123,19 @@ static bool insert_simple_ll()
// /
//3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
ke_avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
int val1[] = {2, 4};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_simple_rr()
@ -146,19 +146,19 @@ static bool insert_simple_rr()
// \
// 3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
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, &create_tree_node(2)->tree_entry);
int val1[] = {4, 2};
result = result && pre_order_assert(&tree, val1, 2);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_complex_1()
@ -171,22 +171,22 @@ static bool insert_complex_1()
// \ /
// 15 3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
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);
int val1[] = {20, 4, 3, 9, 26};
result = result && pre_order_assert(&tree, val1, 5);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_complex_2()
@ -199,22 +199,22 @@ static bool insert_complex_2()
// / / \
// 8 3 8
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
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);
int val1[] = {20, 4, 3, 9, 26};
result = result && pre_order_assert(&tree, val1, 5);
avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_complex_3()
@ -229,27 +229,27 @@ static bool insert_complex_3()
// \ /
// 15 2
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
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);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_complex_4()
@ -264,27 +264,27 @@ static bool insert_complex_4()
// \ / \
// 8 2 8
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
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);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
avl_tree_insert(&tree, &create_tree_node(8)->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool insert_duplicate()
@ -299,29 +299,29 @@ static bool insert_duplicate()
// \ / \
// 8 2 8
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(26)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(9)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(21)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(11)->tree_entry);
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);
int val1[] = {20, 4, 3, 2, 9, 7, 11, 26, 21, 30};
result = result && pre_order_assert(&tree, val1, 10);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(7)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
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);
result = result && pre_order_assert(&tree, val1, 10);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
@ -334,23 +334,23 @@ static bool delete_simple_l()
// 4
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(1);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
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);
int val1[] = {2, 1, 3, 4};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_simple_r()
@ -362,23 +362,23 @@ static bool delete_simple_r()
//1
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(4);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
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);
int val1[] = {3, 2, 1, 4};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_simple_ll()
@ -389,23 +389,23 @@ static bool delete_simple_ll()
// /
// 3
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(1);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(4)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
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, &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);
int val1[] = {2, 1, 4, 3};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {3, 2, 4};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_simple_rr()
@ -416,23 +416,23 @@ static bool delete_simple_rr()
// \
// 1
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(4);
avl_tree_insert(&tree, &create_tree_node(3)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(2)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(1)->tree_entry);
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);
int val1[] = {3, 2, 1, 4};
result = result && pre_order_assert(&tree, val1, 4);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {2, 1, 3};
result = result && pre_order_assert(&tree, val2, 3);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_complex_1()
@ -447,19 +447,19 @@ static bool delete_complex_1()
// Result:
// empty tree
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(10);
avl_tree_insert(&tree, &deleted->tree_entry);
ke_avl_tree_insert(&tree, &deleted->tree_entry);
int val1[] = {10};
result = result && pre_order_assert(&tree, val1, 1);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
result = result && pre_order_assert(&tree, val1, 0);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_complex_2()
@ -485,24 +485,24 @@ static bool delete_complex_2()
// 35
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(20);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
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(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);
int val1[] = {20, 10, 30, 25, 35};
result = result && pre_order_assert(&tree, val1, 5);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {25, 10, 30, 35};
result = result && pre_order_assert(&tree, val2, 4);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_complex_3()
@ -524,25 +524,25 @@ static bool delete_complex_3()
// / /
// 5 25
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(10);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
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);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_avl_tree_delete(&tree, &deleted->tree_entry);
int val2[] = {20, 15, 5, 30, 25};
result = result && pre_order_assert(&tree, val2, 5);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_complex_4()
@ -563,8 +563,8 @@ static bool delete_complex_4()
// 20
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *delete5 = create_tree_node(5);
int_tree_node *delete10 = create_tree_node(10);
@ -573,25 +573,25 @@ static bool delete_complex_4()
int_tree_node *delete30 = create_tree_node(30);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &delete10->tree_entry);
avl_tree_insert(&tree, &delete30->tree_entry);
avl_tree_insert(&tree, &delete5->tree_entry);
avl_tree_insert(&tree, &delete15->tree_entry);
avl_tree_insert(&tree, &delete25->tree_entry);
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);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
avl_tree_delete(&tree, &delete5->tree_entry);
avl_tree_delete(&tree, &delete15->tree_entry);
avl_tree_delete(&tree, &delete25->tree_entry);
avl_tree_delete(&tree, &delete10->tree_entry);
avl_tree_delete(&tree, &delete30->tree_entry);
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);
int val2[] = {20};
result = result && pre_order_assert(&tree, val2, 1);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_complex_single_rotation()
@ -622,31 +622,31 @@ static bool delete_complex_single_rotation()
//
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(50);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
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);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_complex_double_rotation()
@ -677,31 +677,31 @@ static bool delete_complex_double_rotation()
//
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(22);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
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);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_complex_multiple_rotation()
@ -732,31 +732,31 @@ static bool delete_complex_multiple_rotation()
//
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *deleted = create_tree_node(5);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &deleted->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(40)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(12)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(22)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(35)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(50)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(31)->tree_entry);
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);
int val1[] = {20, 10, 5, 15, 12, 30, 25, 22, 40, 35, 31, 50};
result = result && pre_order_assert(&tree, val1, 12);
avl_tree_delete(&tree, &deleted->tree_entry);
ke_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 && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
static bool delete_DNE()
@ -780,26 +780,26 @@ static bool delete_DNE()
// 5 15 25
//
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
int_tree_node *delete100 = create_tree_node(100);
int_tree_node *delete24 = create_tree_node(24);
avl_tree_insert(&tree, &create_tree_node(20)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(10)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(30)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(5)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(15)->tree_entry);
avl_tree_insert(&tree, &create_tree_node(25)->tree_entry);
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);
int val1[] = {20, 10, 5, 15, 30, 25};
result = result && pre_order_assert(&tree, val1, 6);
avl_tree_delete(&tree, &delete24->tree_entry);
avl_tree_delete(&tree, &delete100->tree_entry);
ke_avl_tree_delete(&tree, &delete24->tree_entry);
ke_avl_tree_delete(&tree, &delete100->tree_entry);
result = result && pre_order_assert(&tree, val1, 6);
return result && avl_tree_validate(&tree);
return result && ke_avl_tree_validate(&tree);
}
#define AVL_APOCALYPSE_NUM 500
@ -809,26 +809,26 @@ static int_tree_node apocalypse[AVL_APOCALYPSE_NUM];
static bool test_apocalypse()
{
bool result = true;
avl_tree_t tree;
avl_tree_init(&tree, compare);
k_avl_tree_t tree;
ke_avl_tree_init(&tree, compare);
// insert test
for(int i = 0; i < AVL_APOCALYPSE_NUM; i++)
{
apocalypse[i].val = rand();
while(avl_tree_search(&tree, &apocalypse[i].tree_entry) != NULL)
while(ke_avl_tree_search(&tree, &apocalypse[i].tree_entry) != NULL)
{
apocalypse[i].val += rand() % 32765;
}
avl_tree_insert(&tree, &apocalypse[i].tree_entry);
ke_avl_tree_insert(&tree, &apocalypse[i].tree_entry);
}
// integrity test
result = result && avl_tree_validate(&tree);
result = result && avl_tree_size(&tree) == AVL_APOCALYPSE_NUM;
result = result && ke_avl_tree_validate(&tree);
result = result && ke_avl_tree_size(&tree) == AVL_APOCALYPSE_NUM;
// smaller and bigger test
avl_tree_node_t* entry = avl_tree_smallest(&tree);
k_avl_tree_node_t* entry = ke_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 +840,7 @@ static bool test_apocalypse()
break;
}
size++;
entry = avl_tree_larger(entry);
entry = ke_avl_tree_larger(entry);
prev = cur;
if(entry != NULL)
{
@ -851,7 +851,7 @@ static bool test_apocalypse()
result = result && size == AVL_APOCALYPSE_NUM;
// larger test
entry = avl_tree_largest(&tree);
entry = ke_avl_tree_largest(&tree);
size = 0;
cur = OBTAIN_STRUCT_ADDR(entry, int_tree_node, tree_entry)->val;
prev = cur;
@ -863,7 +863,7 @@ static bool test_apocalypse()
break;
}
size++;
entry = avl_tree_smaller(entry);
entry = ke_avl_tree_smaller(entry);
prev = cur;
if(entry != NULL)
{
@ -877,13 +877,13 @@ static bool test_apocalypse()
// delete and search test
for(int i = 0; i < AVL_APOCALYPSE_NUM; i++)
{
result = result && (avl_tree_search(&tree,&apocalypse[i].tree_entry) != NULL);
avl_tree_delete(&tree,&apocalypse[i].tree_entry);
result = result && (avl_tree_search(&tree,&apocalypse[i].tree_entry) == NULL);
result = result && avl_tree_validate(&tree);
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 && (avl_tree_size(&tree) == 0);
result = result && (ke_avl_tree_size(&tree) == 0);
return result;
}

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

@ -5,11 +5,11 @@
typedef struct
{
linked_list_node_t lnode;
k_linked_list_node_t lnode;
int val;
} my_list_node;
static bool validate_list(linked_list_t *list)
static bool validate_list(k_linked_list_t *list)
{
bool result = true;
// list_head_test
@ -35,9 +35,9 @@ static bool validate_list(linked_list_t *list)
}
static bool assert_list(linked_list_t *list, int val[], int size)
static bool assert_list(k_linked_list_t *list, int val[], int size)
{
linked_list_node_t *node = linked_list_first(list);
k_linked_list_node_t *node = ke_linked_list_first(list);
int i = 0;
if (!validate_list(list))
@ -51,7 +51,7 @@ static bool assert_list(linked_list_t *list, int val[], int size)
return false;
}
i++;
node = linked_list_next(node);
node = ke_linked_list_next(node);
}
if (i != size)
@ -59,7 +59,7 @@ static bool assert_list(linked_list_t *list, int val[], int size)
return false;
}
node = linked_list_last(list);
node = ke_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(linked_list_t *list, int val[], int size)
return false;
}
i--;
node = linked_list_prev(node);
node = ke_linked_list_prev(node);
}
return i == 0;
@ -96,32 +96,32 @@ static bool assert_list(linked_list_t *list, int val[], int size)
// return;
//}
static void insert_val(linked_list_t *list, int index, int val)
static void insert_val(k_linked_list_t *list, int index, int val)
{
my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
a->val = val;
linked_list_insert_idx(list, index, &a->lnode);
ke_linked_list_insert(list, index, &a->lnode);
}
static void push_back_val(linked_list_t *list, int val)
static void push_back_val(k_linked_list_t *list, int val)
{
my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
a->val = val;
linked_list_push_back(list, &a->lnode);
ke_linked_list_push_back(list, &a->lnode);
}
static void push_front_val(linked_list_t *list, int val)
static void push_front_val(k_linked_list_t *list, int val)
{
my_list_node *a = (my_list_node *) talloc(sizeof(my_list_node));
a->val = val;
linked_list_push_front(list, &a->lnode);
ke_linked_list_push_front(list, &a->lnode);
}
static bool insert_test_beginning()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_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()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_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()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_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()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_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);
linked_list_insert_ref(NULL, list.head, list.tail);
linked_list_insert_ref(&list, list.head, NULL);
ke_linked_list_insert_ref(NULL, list.head, list.tail);
ke_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()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 0, 1);
insert_val(&list, 0, 2);
insert_val(&list, 0, 3);
linked_list_remove_idx(&list, 0);
linked_list_remove_idx(&list, 0);
ke_linked_list_remove(&list, 0);
ke_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()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_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);
linked_list_remove_idx(&list, 1);
linked_list_remove_idx(&list, 2);
ke_linked_list_remove(&list, 1);
ke_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()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 1, 1);
insert_val(&list, 2, 2);
insert_val(&list, 3, 3);
linked_list_remove_idx(&list, 3);
linked_list_remove_idx(&list, 2);
ke_linked_list_remove(&list, 3);
ke_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;
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_linked_list_init(&list);
insert_val(&list, 0, 0);
insert_val(&list, 1, 1);
insert_val(&list, 2, 2);
insert_val(&list, 3, 3);
linked_list_remove_idx(&list, 0);
linked_list_remove_idx(&list, 0);
linked_list_remove_idx(&list, 0);
linked_list_remove_idx(&list, 0);
ke_linked_list_remove(&list, 0);
ke_linked_list_remove(&list, 0);
ke_linked_list_remove(&list, 0);
ke_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);
linked_list_remove_idx(&list, 3);
linked_list_remove_idx(&list, 2);
linked_list_remove_idx(&list, 1);
linked_list_remove_idx(&list, 0);
ke_linked_list_remove(&list, 3);
ke_linked_list_remove(&list, 2);
ke_linked_list_remove(&list, 1);
ke_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);
linked_list_remove_idx(&list, 1);
linked_list_remove_idx(&list, 1);
linked_list_remove_idx(&list, 1);
linked_list_remove_idx(&list, 0);
ke_linked_list_remove(&list, 1);
ke_linked_list_remove(&list, 1);
ke_linked_list_remove(&list, 1);
ke_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()
{
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_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
linked_list_remove_idx(&list, 5);
linked_list_remove_idx(&list, 6);
linked_list_remove_idx(&list, 999);
ke_linked_list_remove(&list, 5);
ke_linked_list_remove(&list, 6);
ke_linked_list_remove(&list, 999);
// small index
linked_list_remove_idx(&list, -1);
linked_list_remove_idx(&list, -2);
linked_list_remove_idx(&list, -999);
ke_linked_list_remove(&list, -1);
ke_linked_list_remove(&list, -2);
ke_linked_list_remove(&list, -999);
// NULL
linked_list_remove_idx(NULL, 1);
linked_list_remove_ref(NULL, list.head);
linked_list_remove_ref(&list, NULL);
ke_linked_list_remove(NULL, 1);
ke_linked_list_remove_ref(NULL, list.head);
ke_linked_list_remove_ref(&list, NULL);
// 0123=====3210
int val[] = {0, 1, 2, 3};
@ -326,17 +326,17 @@ static bool remove_test_invalid()
static bool size_test()
{
bool result = true;
linked_list_t list;
linked_list_init(&list);
linked_list_t list2;
linked_list_init(&list2);
k_linked_list_t list;
ke_linked_list_init(&list);
k_linked_list_t list2;
ke_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 && (linked_list_size(&list) == 4 && linked_list_size(&list2) == 0 && linked_list_size(NULL) == -1);
result = result && (ke_linked_list_size(&list) == 4 && ke_linked_list_size(&list2) == 0 && ke_linked_list_size(NULL) == -1);
int val[] = {0, 1, 2, 3};
result = result && assert_list(&list, val, 4);
return result;
@ -345,8 +345,8 @@ static bool size_test()
static bool push_pop_front_test()
{
bool result = true;
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_linked_list_init(&list);
push_front_val(&list, 1);
push_front_val(&list, 2);
@ -357,14 +357,14 @@ static bool push_pop_front_test()
int val1[] = {4, 3, 2, 1};
result = result && assert_list(&list, val1, 4);
linked_list_pop_front(&list);
ke_linked_list_pop_front(&list);
//321==123
int val2[] = {3, 2, 1};
result = result && assert_list(&list, val2, 3);
linked_list_pop_front(&list);
linked_list_pop_front(&list);
linked_list_pop_front(&list);
ke_linked_list_pop_front(&list);
ke_linked_list_pop_front(&list);
ke_linked_list_pop_front(&list);
result = result && assert_list(&list, NULL, 0);
return result;
@ -373,8 +373,8 @@ static bool push_pop_front_test()
static bool push_pop_back_test()
{
bool result = true;
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_linked_list_init(&list);
push_back_val(&list, 1);
push_back_val(&list, 2);
@ -385,20 +385,20 @@ static bool push_pop_back_test()
int val1[] = {1, 2, 3, 4};
result = result && assert_list(&list, val1, 4);
linked_list_pop_back(&list);
ke_linked_list_pop_back(&list);
//123==321
int val2[] = {1, 2, 3};
result = result && assert_list(&list, val2, 3);
linked_list_pop_back(&list);
linked_list_pop_back(&list);
linked_list_pop_back(&list);
ke_linked_list_pop_back(&list);
ke_linked_list_pop_back(&list);
ke_linked_list_pop_back(&list);
result = result && assert_list(&list, NULL, 0);
return result;
}
static bool equals(linked_list_node_t *a, linked_list_node_t *b)
static bool equals(k_linked_list_node_t *a, k_linked_list_node_t *b)
{
return (int64_t) b == OBTAIN_STRUCT_ADDR(a, my_list_node, lnode)->val;
}
@ -406,8 +406,8 @@ static bool equals(linked_list_node_t *a, linked_list_node_t *b)
static bool search_test()
{
bool result = true;
linked_list_t list;
linked_list_init(&list);
k_linked_list_t list;
ke_linked_list_init(&list);
push_back_val(&list, 1);
push_back_val(&list, 2);
@ -417,16 +417,16 @@ static bool search_test()
int val1[] = {1, 2, 3, 4};
result = result && assert_list(&list, val1, 4);
result = result && (linked_list_search(&list, (linked_list_node_t *) 4, equals) == 3);
result = result && (linked_list_search(&list, (linked_list_node_t *) 3, equals) == 2);
result = result && (linked_list_search(&list, (linked_list_node_t *) 2, equals) == 1);
result = result && (linked_list_search(&list, (linked_list_node_t *) 1, equals) == 0);
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 && (linked_list_search(&list, NULL, equals) == -1);
result = result && (linked_list_search(NULL, (linked_list_node_t *) 1, equals) == -1);
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);
linked_list_node_t *node = linked_list_get(&list, 1);
result = result && (linked_list_search(&list, node, NULL) == 1);
k_linked_list_node_t *node = ke_linked_list_get(&list, 1);
result = result && (ke_linked_list_search(&list, node, NULL) == 1);
result = result && assert_list(&list, val1, 4);