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

Restructure kernel (separate modules to be shared + private) and defined/implemented more HAL interrupt APIs.

This commit is contained in:
secXsQuared 2016-06-15 00:29:46 -07:00
parent 0188fe66a5
commit 22ad3c25c2
37 changed files with 1313 additions and 554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
x64/src/common/inc/k_sys_info.h
View File

@ -1,48 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _K_SYS_INFO_H_
#define _K_SYS_INFO_H_
#include "k_type.h"
#include "linked_list.h"
#define MEMORY_OCCUPIED 0
#define MEMORY_AVAILABLE 1
#define MEMORY_RESERVED 2
typedef struct
{
uint64_t base_addr;
uint64_t page_count;
linked_list_node_t list_node;
} memory_descriptor_node_t;
typedef struct {
linked_list_t* free_page_list; // a list containing memory_descriptor_node_t nodes
linked_list_t* occupied_page_list;
uint64_t mem_installed;
uint64_t mem_available;
} mem_info_t;
typedef struct
{
uint64_t base_addr;
uint64_t size;
char* name;
linked_list_node_t list_node;
} module_descriptor_node_t;
typedef struct {
linked_list_t* module_list;
uint64_t module_count;
} module_info_t;
typedef struct {
char cpu_vendor_string[13];
mem_info_t* mem_info; // all available memory info
module_info_t* module_info; // all kernel modules loaded
} k_hal_info_t;
#endif

21
x64/src/common/inc/kernel/s_boot.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef _S_BOOT_H_
#define _S_BOOT_H_
#include "s_def.h"
//
// Boot Info
//
typedef struct
{
uint32_t priority_low;
uint32_t priority_high;
} k_boot_intr_info_t;
typedef struct
{
uint64_t krnl_start;
uint64_t krnl_end;
k_boot_intr_info_t intr_info;
char cpu_vd_str[13];
} k_boot_info_t;
#endif

16
x64/src/common/inc/kernel/s_intr.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef _S_INTR_H_
#define _S_INTR_H_
typedef enum
{
K_INTR_TIMER,
K_INTR_IO,
K_INTR_SOFTWARE,
K_INTR_NMI,
K_EXC_DIV_BY_ZERO,
K_EXC_MEM_ACCESS,
K_EXC_INV_OP,
K_EXC_GP
} k_handler_type_t;
#endif

6
x64/src/common/inc/k_def.h → x64/src/common/inc/s_def.h
View File

@ -3,12 +3,12 @@
* See COPYING under root for details
*/
#ifndef _K_DEF_H_
#define _K_DEF_H_
#ifndef _S_DEF_H_
#define _S_DEF_H_
#include <stddef.h>
#include <stdarg.h>
#include "k_type.h"
#include "s_type.h"
#define KAPI __attribute__((sysv_abi))
#define UAPI __attribute__((sysv_abi))

63
x64/src/common/inc/s_hal.h Normal file
View File

@ -0,0 +1,63 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
/* This file should be only be included by kernel c source files
* and never any other files
*/
#ifndef _S_HAL_H_
#define _S_HAL_H_
#include "s_def.h"
#include "s_type.h"
#include "linked_list.h"
#include "s_intr.h"
#include "s_boot.h"
//
// HAL Initialization API
//
extern int32_t KAPI hal_init(void *multiboot_info, k_boot_info_t *boot_info);
//
// Interrupt APIs
//
extern void KAPI hal_enable_interrupt();
extern void KAPI hal_disable_interrupt();
extern void KAPI hal_set_interrupt_priority(uint64_t priority);
extern uint64_t KAPI hal_read_interrupt_priority();
extern int32_t KAPI hal_register_interrupt_handler(k_handler_type_t type,
uint64_t priority,
void (*handler)(uint64_t pc,
uint64_t sp,
uint64_t error));
extern void KAPI hal_deregister_interrupt_handler(int32_t index);
extern void KAPI hal_issue_interrupt(uint32_t target_core, uint32_t vector);
//
// HAL Atomic
//
extern uint64_t KAPI hal_interlocked_exchange(uint64_t *dst, uint64_t val);
//
// HAL Arch API
//
extern void KAPI hal_halt_cpu(void);
//
// HAL Print
//
extern void KAPI hal_clear_screen(void);
extern void KAPI hal_printf(char const *format, ...);
#endif

4
x64/src/common/inc/k_type.h → x64/src/common/inc/s_type.h
View File

@ -3,8 +3,8 @@
* See COPYING under root for details
*/
#ifndef _K_TYPE_H_
#define _K_TYPE_H_
#ifndef _S_TYPE_H_
#define _S_TYPE_H_
#include <stdint.h>
#include <stdbool.h>

2
x64/src/common/lib/linked_list/inc/linked_list.h
View File

@ -6,7 +6,7 @@
#ifndef _LINKED_LIST_H_
#define _LINKED_LIST_H_
#include "k_def.h"
#include "s_def.h"
typedef struct _linked_list_node_t
{

2
x64/src/common/lib/salloc/inc/salloc.h
View File

@ -6,7 +6,7 @@
#ifndef _SALLOC_H_
#define _SALLOC_H_
#include "k_def.h"
#include "s_def.h"
void KAPI salloc_init(void *base, uint32_t size);

2
x64/src/common/lib/salloc/salloc.c
View File

@ -3,7 +3,7 @@
* See COPYING under root for details
*/
#include "k_def.h"
#include "s_def.h"
#include "bit_ops.h"
typedef union

4
x64/src/common/lib/std/inc/bit_ops.h
View File

@ -6,8 +6,8 @@
#ifndef _BIT_OPERATION_H_
#define _BIT_OPERATION_H_
#include "k_type.h"
#include "k_def.h"
#include "s_type.h"
#include "s_def.h"
static inline uint64_t KAPI bit_mask_64(uint32_t bit)
{

4
x64/src/common/lib/std/inc/std_lib.h
View File

@ -6,8 +6,8 @@
#ifndef _STD_LIB_H_
#define _STD_LIB_H_
#include "k_def.h"
#include "k_type.h"
#include "s_def.h"
#include "s_type.h"
uint32_t KAPI rand( void );

4
x64/src/common/lib/std/mem.c
View File

@ -3,8 +3,8 @@
* See COPYING under root for details
*/
#include "k_type.h"
#include "k_def.h"
#include "s_type.h"
#include "s_def.h"
#include "std_lib.h"
void KAPI mem_cpy(void *src, void *dst, uint64_t size)

17
x64/src/hal/hal_arch.asm
View File

@ -66,6 +66,17 @@ hal_write_cr3:
mov cr3,rdi
ret
;======================
global hal_read_cr8
hal_read_cr8:
mov rax,cr8
ret
;======================
global hal_write_cr8
hal_write_cr8:
mov cr8,rdi
ret
; ============================
; uint64_t KAPI hal_interlocked_exchange(uint64_t* dst, uint64_t val);
@ -201,12 +212,6 @@ hal_halt_cpu:
hlt
jmp .loop
;====================
global hal_bochs_magic_breakpoint
hal_bochs_magic_breakpoint:
xchg bx,bx
ret
;====================
;(uint32_t *ecx, uint32_t* edx, uint32_t* eax)
global hal_read_msr

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

@ -4,25 +4,23 @@
*/
#include "bit_ops.h"
#include "hal_multiboot.h"
#include "hal_print.h"
#include "hal_mem.h"
#include "hal_intr.h"
#include "hal_var.h"
#include "k_sys_info.h"
#include "std_lib.h"
#include "hal_arch.h"
#include "s_boot.h"
static void KAPI _hal_obtain_cpu_info(k_hal_info_t *hal_info)
static void KAPI _hal_obtain_cpu_info(k_boot_info_t *hal_info)
{
if(hal_info == NULL)
return;
uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
hal_cpuid(&eax,&ebx,&ecx,&edx);
mem_cpy(&ebx, &hal_info->cpu_vendor_string[0], sizeof(uint32_t));
mem_cpy(&edx, &hal_info->cpu_vendor_string[4], sizeof(uint32_t));
mem_cpy(&ecx, &hal_info->cpu_vendor_string[8], sizeof(uint32_t));
hal_info->cpu_vendor_string[12] = 0;
mem_cpy(&ebx, &hal_info->cpu_vd_str[0], sizeof(uint32_t));
mem_cpy(&edx, &hal_info->cpu_vd_str[4], sizeof(uint32_t));
mem_cpy(&ecx, &hal_info->cpu_vd_str[8], sizeof(uint32_t));
hal_info->cpu_vd_str[12] = 0;
}
static void KAPI _hal_init_gdt()
@ -56,155 +54,31 @@ static void KAPI _hal_init_gdt()
hal_flush_gdt(&g_gdt_ptr, seg_selector(1, 0), seg_selector(2, 0));
};
k_hal_info_t *KAPI hal_init(char *m_info)
int32_t KAPI hal_init(void *m_info, k_boot_info_t* boot_info)
{
if (m_info == NULL || (uint64_t) m_info & bit_field_mask_64(0, 2))
return NULL;
if (m_info == NULL || boot_info == NULL || (uint64_t) m_info & bit_field_mask_64(0, 2))
return 1;
text_pos = get_pos(0, 0);
// set up GDT
_hal_init_gdt();
// set up kernel heap;
// set up HAL heap;
hal_alloc_init();
// set up HAL def
boot_info->krnl_start = (uint64_t)kernel_start;
boot_info->krnl_end = (uint64_t)kernel_end;
// obtain cpu info
_hal_obtain_cpu_info(boot_info);
// init interrupt
if(hal_interrupt_init() != 0)
{
hal_halt_cpu();
return 1;
}
k_hal_info_t *hal_info = (k_hal_info_t *) halloc(sizeof(k_hal_info_t));
mem_set(hal_info, 0, sizeof(k_hal_info_t));
_hal_obtain_cpu_info(hal_info);
// obtain boot information
// memory info
// if (m_info->flags & (1 << 6))
// {
// boot_info->mem_info = (mem_info_t *) halloc(sizeof(mem_info_t));
// hal_assert(boot_info->mem_info != NULL, "Unable to allocate memory for mem_info.");
// boot_info->mem_info->mem_available = 0;
// boot_info->mem_info->mem_installed = 0;
// boot_info->mem_info->free_page_list = (linked_list_t *) halloc((sizeof(linked_list_t)));
// boot_info->mem_info->occupied_page_list = (linked_list_t *) halloc((sizeof(linked_list_t)));
// hal_assert(boot_info->mem_info->free_page_list != NULL &&
// boot_info->mem_info->occupied_page_list != NULL, "Unable to allocate memory for mem_info_lists.");
// linked_list_init(boot_info->mem_info->free_page_list);
// linked_list_init(boot_info->mem_info->occupied_page_list);
// multiboot_memory_map_t *mem_map = (multiboot_memory_map_t *) (uint64_t) m_info->mmap_addr;
// uint64_t mem_map_size = m_info->mmap_length / sizeof(multiboot_memory_map_t);
// for (uint64_t i = 0; i < mem_map_size; i++)
// {
// hal_printf("==Base: 0x%X, Length: %u, Type: %s==\n", (mem_map + i)->addr, (mem_map + i)->len,
// (mem_map + i)->type == MULTIBOOT_MEMORY_AVAILABLE ? "AVL" : "RSV");
// if ((mem_map + i)->type == MULTIBOOT_MEMORY_AVAILABLE)
// {
// uint64_t base_addr = (mem_map + i)->addr;
// uint64_t end_addr = base_addr + (mem_map + i)->len;
//
// // align head
// uint64_t aligned_base_addr = align_up(base_addr, PHYSICAL_PAGE_SIZE);
// // align tail
// uint64_t aligned_end_addr = align_down(end_addr, PHYSICAL_PAGE_SIZE);
//
//
// uint64_t page_count = (aligned_end_addr - aligned_base_addr) / PHYSICAL_PAGE_SIZE;
//
// if (page_count == 0)
// continue;
//
// // strip kernel-occupied pages
// // TODO: Finished this.
// uint64_t aligned_kernel_base = ALIGN_DOWN((uint64_t) kernel_start, PHYSICAL_PAGE_SIZE);
// uint64_t aligned_kernel_end = ALIGN_UP((uint64_t) kernel_end, PHYSICAL_PAGE_SIZE);
// if (IS_OVERLAP(aligned_base_addr, aligned_end_addr, aligned_kernel_base, aligned_kernel_end))
// {
// uint64_t overlap_pages = (MIN(aligned_kernel_end, aligned_end_addr)
// - MAX(aligned_kernel_base, aligned_base_addr)) / PHYSICAL_PAGE_SIZE;
//
// if (overlap_pages != 0)
// {
// // if there is overlap, add to occupied list
// memory_descriptor_node_t *occupied_desc = (memory_descriptor_node_t *) hal_alloc(
// sizeof(memory_descriptor_node_t));
// hal_assert(occupied_desc != NULL, "Unable to allocate memory for memory_descriptor.");
// occupied_desc->base_addr = aligned_kernel_base;
// occupied_desc->page_count = overlap_pages;
// linked_list_add(boot_info->mem_info->occupied_page_list, &occupied_desc->list_node);
//
// // also adjust corresponding segment
// page_count = page_count - overlap_pages;
// if (page_count == 0) // if kernel occupies the whole segment, continue
// continue;
//
// }
// }
//
// memory_descriptor_node_t *each_desc = (memory_descriptor_node_t *) halloc(
// sizeof(memory_descriptor_node_t));
// hal_assert(each_desc != NULL, "Unable to allocate memory for memory_descriptor.");
// each_desc->page_count = page_count;
// each_desc->base_addr = aligned_base_addr;
// linked_list_push_back(boot_info->mem_info->free_page_list, &each_desc->list_node);
// boot_info->mem_info->mem_available += aligned_end_addr - aligned_base_addr;
// }
// boot_info->mem_info->mem_installed += (mem_map + i)->len;
// }
// }
// else
// {
// // halt machine
// hal_printf("HAL: Cannot detect memory information.");
// hal_halt_cpu();
// }
//
// // loaded kernel modules
// if (m_info->flags & (1 << 3))
// {
// boot_info->module_info = (module_info_t *) halloc(sizeof(module_info_t));
// hal_assert(boot_info->module_info != NULL, "Unable to allocate memory for module_info.");
// boot_info->module_info->module_count = 0;
// boot_info->module_info->module_list = (linked_list_t *) halloc(sizeof(linked_list_t));
// hal_assert(boot_info->module_info->module_list != NULL, "Unable to allocate memory for module_list.");
// linked_list_init(boot_info->module_info->module_list);
// multiboot_module_t *mods_list = (multiboot_module_t * )(uint64_t)
// m_info->mods_addr;
// boot_info->module_info->module_count = m_info->mods_count;
// for (uint64_t i = 0; i < boot_info->module_info->module_count; i++)
// {
// module_descriptor_node_t *each_module = (module_descriptor_node_t *) halloc(
// sizeof(module_descriptor_node_t));
// hal_assert(each_module != NULL, "Unable to allocate memory for module_descriptor.");
// each_module->base_addr = (mods_list + i)->mod_start;
// each_module->size = (mods_list + i)->mod_end - (mods_list + i)->mod_start;
// each_module->name = (char *) halloc((size_t) str_len((char *) (uint64_t) (mods_list + i)->cmdline) + 1);
// hal_assert(each_module->name != NULL, "Unable to allocate memory for module name string.");
// mem_cpy((void *) (uint64_t) (mods_list + i)->cmdline, each_module->name,
// str_len((char *) (uint64_t) (mods_list + i)->cmdline) + 1);
// linked_list_push_back(boot_info->module_info->module_list, &each_module->list_node);
// }
// }
//
// // detect APIC
// cpuid_t cpuid_info;
// cpuid_info.eax = 1;
// cpuid_info.ebx = 0;
// cpuid_info.ecx = 0;
// cpuid_info.edx = 0;
// hal_cpuid(&cpuid_info.eax, &cpuid_info.ebx, &cpuid_info.ecx, &cpuid_info.edx);
// if (cpuid_info.edx & 1 << 9)
// {
// //TODO: detected.
// }
// else
// {
// // halt machine
// hal_printf("HAL: Cannot detect APIC.");
// hal_halt_cpu();
// }
return hal_info;
return 0;
}

234
x64/src/hal/hal_intr.asm
View File

@ -104,16 +104,32 @@ hal_interrupt_handler 5
hal_interrupt_handler 6
hal_interrupt_handler 7
hal_interrupt_err_handler 8
; unused
hal_interrupt_handler 9
hal_interrupt_err_handler 10
hal_interrupt_err_handler 11
hal_interrupt_err_handler 12
hal_interrupt_err_handler 13
hal_interrupt_err_handler 14
; unused
hal_interrupt_handler 15
hal_interrupt_handler 16
hal_interrupt_err_handler 17
hal_interrupt_handler 18
hal_interrupt_handler 19
hal_interrupt_handler 20
; 21-31 unused
hal_interrupt_handler 21
hal_interrupt_handler 22
hal_interrupt_handler 23
hal_interrupt_handler 24
hal_interrupt_handler 25
hal_interrupt_handler 26
hal_interrupt_handler 27
hal_interrupt_handler 28
hal_interrupt_handler 29
hal_interrupt_handler 30
hal_interrupt_handler 31
; user defined
hal_interrupt_handler 32
@ -123,4 +139,220 @@ hal_interrupt_handler 35
hal_interrupt_handler 36
hal_interrupt_handler 37
hal_interrupt_handler 38
hal_interrupt_handler 39
hal_interrupt_handler 39
hal_interrupt_handler 40
hal_interrupt_handler 41
hal_interrupt_handler 42
hal_interrupt_handler 43
hal_interrupt_handler 44
hal_interrupt_handler 45
hal_interrupt_handler 46
hal_interrupt_handler 47
hal_interrupt_handler 48
hal_interrupt_handler 49
hal_interrupt_handler 50
hal_interrupt_handler 51
hal_interrupt_handler 52
hal_interrupt_handler 53
hal_interrupt_handler 54
hal_interrupt_handler 55
hal_interrupt_handler 56
hal_interrupt_handler 57
hal_interrupt_handler 58
hal_interrupt_handler 59
hal_interrupt_handler 60
hal_interrupt_handler 61
hal_interrupt_handler 62
hal_interrupt_handler 63
hal_interrupt_handler 64
hal_interrupt_handler 65
hal_interrupt_handler 66
hal_interrupt_handler 67
hal_interrupt_handler 68
hal_interrupt_handler 69
hal_interrupt_handler 70
hal_interrupt_handler 71
hal_interrupt_handler 72
hal_interrupt_handler 73
hal_interrupt_handler 74
hal_interrupt_handler 75
hal_interrupt_handler 76
hal_interrupt_handler 77
hal_interrupt_handler 78
hal_interrupt_handler 79
hal_interrupt_handler 80
hal_interrupt_handler 81
hal_interrupt_handler 82
hal_interrupt_handler 83
hal_interrupt_handler 84
hal_interrupt_handler 85
hal_interrupt_handler 86
hal_interrupt_handler 87
hal_interrupt_handler 88
hal_interrupt_handler 89
hal_interrupt_handler 90
hal_interrupt_handler 91
hal_interrupt_handler 92
hal_interrupt_handler 93
hal_interrupt_handler 94
hal_interrupt_handler 95
hal_interrupt_handler 96
hal_interrupt_handler 97
hal_interrupt_handler 98
hal_interrupt_handler 99
hal_interrupt_handler 100
hal_interrupt_handler 101
hal_interrupt_handler 102
hal_interrupt_handler 103
hal_interrupt_handler 104
hal_interrupt_handler 105
hal_interrupt_handler 106
hal_interrupt_handler 107
hal_interrupt_handler 108
hal_interrupt_handler 109
hal_interrupt_handler 110
hal_interrupt_handler 111
hal_interrupt_handler 112
hal_interrupt_handler 113
hal_interrupt_handler 114
hal_interrupt_handler 115
hal_interrupt_handler 116
hal_interrupt_handler 117
hal_interrupt_handler 118
hal_interrupt_handler 119
hal_interrupt_handler 120
hal_interrupt_handler 121
hal_interrupt_handler 122
hal_interrupt_handler 123
hal_interrupt_handler 124
hal_interrupt_handler 125
hal_interrupt_handler 126
hal_interrupt_handler 127
hal_interrupt_handler 128
hal_interrupt_handler 129
hal_interrupt_handler 130
hal_interrupt_handler 131
hal_interrupt_handler 132
hal_interrupt_handler 133
hal_interrupt_handler 134
hal_interrupt_handler 135
hal_interrupt_handler 136
hal_interrupt_handler 137
hal_interrupt_handler 138
hal_interrupt_handler 139
hal_interrupt_handler 140
hal_interrupt_handler 141
hal_interrupt_handler 142
hal_interrupt_handler 143
hal_interrupt_handler 144
hal_interrupt_handler 145
hal_interrupt_handler 146
hal_interrupt_handler 147
hal_interrupt_handler 148
hal_interrupt_handler 149
hal_interrupt_handler 150
hal_interrupt_handler 151
hal_interrupt_handler 152
hal_interrupt_handler 153
hal_interrupt_handler 154
hal_interrupt_handler 155
hal_interrupt_handler 156
hal_interrupt_handler 157
hal_interrupt_handler 158
hal_interrupt_handler 159
hal_interrupt_handler 160
hal_interrupt_handler 161
hal_interrupt_handler 162
hal_interrupt_handler 163
hal_interrupt_handler 164
hal_interrupt_handler 165
hal_interrupt_handler 166
hal_interrupt_handler 167
hal_interrupt_handler 168
hal_interrupt_handler 169
hal_interrupt_handler 170
hal_interrupt_handler 171
hal_interrupt_handler 172
hal_interrupt_handler 173
hal_interrupt_handler 174
hal_interrupt_handler 175
hal_interrupt_handler 176
hal_interrupt_handler 177
hal_interrupt_handler 178
hal_interrupt_handler 179
hal_interrupt_handler 180
hal_interrupt_handler 181
hal_interrupt_handler 182
hal_interrupt_handler 183
hal_interrupt_handler 184
hal_interrupt_handler 185
hal_interrupt_handler 186
hal_interrupt_handler 187
hal_interrupt_handler 188
hal_interrupt_handler 189
hal_interrupt_handler 190
hal_interrupt_handler 191
hal_interrupt_handler 192
hal_interrupt_handler 193
hal_interrupt_handler 194
hal_interrupt_handler 195
hal_interrupt_handler 196
hal_interrupt_handler 197
hal_interrupt_handler 198
hal_interrupt_handler 199
hal_interrupt_handler 200
hal_interrupt_handler 201
hal_interrupt_handler 202
hal_interrupt_handler 203
hal_interrupt_handler 204
hal_interrupt_handler 205
hal_interrupt_handler 206
hal_interrupt_handler 207
hal_interrupt_handler 208
hal_interrupt_handler 209
hal_interrupt_handler 210
hal_interrupt_handler 211
hal_interrupt_handler 212
hal_interrupt_handler 213
hal_interrupt_handler 214
hal_interrupt_handler 215
hal_interrupt_handler 216
hal_interrupt_handler 217
hal_interrupt_handler 218
hal_interrupt_handler 219
hal_interrupt_handler 220
hal_interrupt_handler 221
hal_interrupt_handler 222
hal_interrupt_handler 223
hal_interrupt_handler 224
hal_interrupt_handler 225
hal_interrupt_handler 226
hal_interrupt_handler 227
hal_interrupt_handler 228
hal_interrupt_handler 229
hal_interrupt_handler 230
hal_interrupt_handler 231
hal_interrupt_handler 232
hal_interrupt_handler 233
hal_interrupt_handler 234
hal_interrupt_handler 235
hal_interrupt_handler 236
hal_interrupt_handler 237
hal_interrupt_handler 238
hal_interrupt_handler 239
hal_interrupt_handler 240
hal_interrupt_handler 241
hal_interrupt_handler 242
hal_interrupt_handler 243
hal_interrupt_handler 244
hal_interrupt_handler 245
hal_interrupt_handler 246
hal_interrupt_handler 247
hal_interrupt_handler 248
hal_interrupt_handler 249
hal_interrupt_handler 250
hal_interrupt_handler 251
hal_interrupt_handler 252
hal_interrupt_handler 253
hal_interrupt_handler 254
hal_interrupt_handler 255

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

@ -3,18 +3,18 @@
* See COPYING under root for details
*/
#include <hal_arch.h>
#include "bit_ops.h"
#include "hal_arch.h"
#include "hal_intr.h"
#include "hal_print.h"
#include "hal_mem.h"
#include "hal_var.h"
#include "s_intr.h"
void KAPI hal_write_gate(void *const gate,
uint64_t const offset,
uint32_t const selector,
uint32_t const attr)
uint64_t const offset,
uint32_t const selector,
uint32_t const attr)
{
((uint8_t *) gate)[0] = (uint8_t) (offset & 0xFF);
((uint8_t *) gate)[1] = (uint8_t) ((offset >> 8) & 0xFF);
@ -35,10 +35,20 @@ void KAPI hal_write_gate(void *const gate,
return;
}
void KAPI hal_set_interrupt_handler(uint64_t index,
void (*handler)(void))
void KAPI hal_set_interrupt_priority(uint64_t priority)
{
if(index < IDT_ENTRY_NUM)
hal_write_cr8(priority & bit_field_mask_32(0,3));
}
uint64_t KAPI hal_read_interrupt_priority()
{
return (uint64_t)hal_read_cr8() & bit_field_mask_32(0,3);
}
void KAPI hal_set_interrupt_handler(uint64_t index,
void (*handler)(void))
{
if (index < IDT_ENTRY_NUM)
{
hal_write_gate(g_idt + 16 * index, (uint64_t) handler, seg_selector(1, 0),
GATE_DPL_0 | GATE_PRESENT | GATE_TYPE_INTERRUPT);
@ -46,21 +56,28 @@ void KAPI hal_set_interrupt_handler(uint64_t index,
return;
}
void KAPI hal_register_interrupt_handler(uint64_t index,
void (*handler)(uint64_t pc,
uint64_t sp,
uint64_t error))
void KAPI hal_issue_interrupt(uint32_t target_core, uint32_t vector)
{
if(index < IDT_ENTRY_NUM)
{
g_intr_handler_table[index] = handler;
}
return;
// TODO
}
void KAPI hal_deregister_interrupt_handler(uint64_t index)
int32_t KAPI hal_register_interrupt_handler(k_handler_type_t type,
uint32_t priority,
void (*handler)(uint64_t pc,
uint64_t sp,
uint64_t error))
{
if(index < IDT_ENTRY_NUM)
if (type == K_INTR_SOFTWARE)
{
// TODO
g_intr_handler_table[0] = handler;
}
return 0;
}
void KAPI hal_deregister_interrupt_handler(int32_t index)
{
if (index < IDT_ENTRY_NUM && index >= 0)
{
g_intr_handler_table[index] = NULL;
}
@ -68,7 +85,7 @@ void KAPI hal_deregister_interrupt_handler(uint64_t index)
}
void KAPI hal_assert(int64_t expression,
char *message)
char *message)
{
if (!expression)
{
@ -78,9 +95,9 @@ void KAPI hal_assert(int64_t expression,
return;
}
void KAPI hal_interrupt_dispatcher(uint64_t int_vec, hal_intr_context_t* context, uint64_t error_code)
void KAPI hal_interrupt_dispatcher(uint64_t int_vec, hal_intr_context_t *context, uint64_t error_code)
{
if(g_intr_handler_table[int_vec] == NULL)
if (g_intr_handler_table[int_vec] == NULL)
{
hal_printf("Unhandled interrupt %d at 0x%X. Err: %d.\n", int_vec, context->rip, error_code);
}
@ -102,17 +119,29 @@ static void KAPI _hal_populate_idt()
hal_set_interrupt_handler(6, hal_interrupt_handler_6);
hal_set_interrupt_handler(7, hal_interrupt_handler_7);
hal_set_interrupt_handler(8, hal_interrupt_handler_8);
hal_set_interrupt_handler(9, hal_interrupt_handler_9);
hal_set_interrupt_handler(10, hal_interrupt_handler_10);
hal_set_interrupt_handler(11, hal_interrupt_handler_11);
hal_set_interrupt_handler(12, hal_interrupt_handler_12);
hal_set_interrupt_handler(13, hal_interrupt_handler_13);
hal_set_interrupt_handler(14, hal_interrupt_handler_14);
hal_set_interrupt_handler(15, hal_interrupt_handler_15);
hal_set_interrupt_handler(16, hal_interrupt_handler_16);
hal_set_interrupt_handler(17, hal_interrupt_handler_17);
hal_set_interrupt_handler(18, hal_interrupt_handler_18);
hal_set_interrupt_handler(19, hal_interrupt_handler_19);
hal_set_interrupt_handler(20, hal_interrupt_handler_20);
hal_set_interrupt_handler(21, hal_interrupt_handler_21);
hal_set_interrupt_handler(22, hal_interrupt_handler_22);
hal_set_interrupt_handler(23, hal_interrupt_handler_23);
hal_set_interrupt_handler(24, hal_interrupt_handler_24);
hal_set_interrupt_handler(25, hal_interrupt_handler_25);
hal_set_interrupt_handler(26, hal_interrupt_handler_26);
hal_set_interrupt_handler(27, hal_interrupt_handler_27);
hal_set_interrupt_handler(28, hal_interrupt_handler_28);
hal_set_interrupt_handler(29, hal_interrupt_handler_29);
hal_set_interrupt_handler(30, hal_interrupt_handler_30);
hal_set_interrupt_handler(31, hal_interrupt_handler_31);
hal_set_interrupt_handler(32, hal_interrupt_handler_32);
hal_set_interrupt_handler(33, hal_interrupt_handler_33);
hal_set_interrupt_handler(34, hal_interrupt_handler_34);
@ -121,6 +150,222 @@ static void KAPI _hal_populate_idt()
hal_set_interrupt_handler(37, hal_interrupt_handler_37);
hal_set_interrupt_handler(38, hal_interrupt_handler_38);
hal_set_interrupt_handler(39, hal_interrupt_handler_39);
hal_set_interrupt_handler(40, hal_interrupt_handler_40);
hal_set_interrupt_handler(41, hal_interrupt_handler_41);
hal_set_interrupt_handler(42, hal_interrupt_handler_42);
hal_set_interrupt_handler(43, hal_interrupt_handler_43);
hal_set_interrupt_handler(44, hal_interrupt_handler_44);
hal_set_interrupt_handler(45, hal_interrupt_handler_45);
hal_set_interrupt_handler(46, hal_interrupt_handler_46);
hal_set_interrupt_handler(47, hal_interrupt_handler_47);
hal_set_interrupt_handler(48, hal_interrupt_handler_48);
hal_set_interrupt_handler(49, hal_interrupt_handler_49);
hal_set_interrupt_handler(50, hal_interrupt_handler_50);
hal_set_interrupt_handler(51, hal_interrupt_handler_51);
hal_set_interrupt_handler(52, hal_interrupt_handler_52);
hal_set_interrupt_handler(53, hal_interrupt_handler_53);
hal_set_interrupt_handler(54, hal_interrupt_handler_54);
hal_set_interrupt_handler(55, hal_interrupt_handler_55);
hal_set_interrupt_handler(56, hal_interrupt_handler_56);
hal_set_interrupt_handler(57, hal_interrupt_handler_57);
hal_set_interrupt_handler(58, hal_interrupt_handler_58);
hal_set_interrupt_handler(59, hal_interrupt_handler_59);
hal_set_interrupt_handler(60, hal_interrupt_handler_60);
hal_set_interrupt_handler(61, hal_interrupt_handler_61);
hal_set_interrupt_handler(62, hal_interrupt_handler_62);
hal_set_interrupt_handler(63, hal_interrupt_handler_63);
hal_set_interrupt_handler(64, hal_interrupt_handler_64);
hal_set_interrupt_handler(65, hal_interrupt_handler_65);
hal_set_interrupt_handler(66, hal_interrupt_handler_66);
hal_set_interrupt_handler(67, hal_interrupt_handler_67);
hal_set_interrupt_handler(68, hal_interrupt_handler_68);
hal_set_interrupt_handler(69, hal_interrupt_handler_69);
hal_set_interrupt_handler(70, hal_interrupt_handler_70);
hal_set_interrupt_handler(71, hal_interrupt_handler_71);
hal_set_interrupt_handler(72, hal_interrupt_handler_72);
hal_set_interrupt_handler(73, hal_interrupt_handler_73);
hal_set_interrupt_handler(74, hal_interrupt_handler_74);
hal_set_interrupt_handler(75, hal_interrupt_handler_75);
hal_set_interrupt_handler(76, hal_interrupt_handler_76);
hal_set_interrupt_handler(77, hal_interrupt_handler_77);
hal_set_interrupt_handler(78, hal_interrupt_handler_78);
hal_set_interrupt_handler(79, hal_interrupt_handler_79);
hal_set_interrupt_handler(80, hal_interrupt_handler_80);
hal_set_interrupt_handler(81, hal_interrupt_handler_81);
hal_set_interrupt_handler(82, hal_interrupt_handler_82);
hal_set_interrupt_handler(83, hal_interrupt_handler_83);
hal_set_interrupt_handler(84, hal_interrupt_handler_84);
hal_set_interrupt_handler(85, hal_interrupt_handler_85);
hal_set_interrupt_handler(86, hal_interrupt_handler_86);
hal_set_interrupt_handler(87, hal_interrupt_handler_87);
hal_set_interrupt_handler(88, hal_interrupt_handler_88);
hal_set_interrupt_handler(89, hal_interrupt_handler_89);
hal_set_interrupt_handler(90, hal_interrupt_handler_90);
hal_set_interrupt_handler(91, hal_interrupt_handler_91);
hal_set_interrupt_handler(92, hal_interrupt_handler_92);
hal_set_interrupt_handler(93, hal_interrupt_handler_93);
hal_set_interrupt_handler(94, hal_interrupt_handler_94);
hal_set_interrupt_handler(95, hal_interrupt_handler_95);
hal_set_interrupt_handler(96, hal_interrupt_handler_96);
hal_set_interrupt_handler(97, hal_interrupt_handler_97);
hal_set_interrupt_handler(98, hal_interrupt_handler_98);
hal_set_interrupt_handler(99, hal_interrupt_handler_99);
hal_set_interrupt_handler(100, hal_interrupt_handler_100);
hal_set_interrupt_handler(101, hal_interrupt_handler_101);
hal_set_interrupt_handler(102, hal_interrupt_handler_102);
hal_set_interrupt_handler(103, hal_interrupt_handler_103);
hal_set_interrupt_handler(104, hal_interrupt_handler_104);
hal_set_interrupt_handler(105, hal_interrupt_handler_105);
hal_set_interrupt_handler(106, hal_interrupt_handler_106);
hal_set_interrupt_handler(107, hal_interrupt_handler_107);
hal_set_interrupt_handler(108, hal_interrupt_handler_108);
hal_set_interrupt_handler(109, hal_interrupt_handler_109);
hal_set_interrupt_handler(110, hal_interrupt_handler_110);
hal_set_interrupt_handler(111, hal_interrupt_handler_111);
hal_set_interrupt_handler(112, hal_interrupt_handler_112);
hal_set_interrupt_handler(113, hal_interrupt_handler_113);
hal_set_interrupt_handler(114, hal_interrupt_handler_114);
hal_set_interrupt_handler(115, hal_interrupt_handler_115);
hal_set_interrupt_handler(116, hal_interrupt_handler_116);
hal_set_interrupt_handler(117, hal_interrupt_handler_117);
hal_set_interrupt_handler(118, hal_interrupt_handler_118);
hal_set_interrupt_handler(119, hal_interrupt_handler_119);
hal_set_interrupt_handler(120, hal_interrupt_handler_120);
hal_set_interrupt_handler(121, hal_interrupt_handler_121);
hal_set_interrupt_handler(122, hal_interrupt_handler_122);
hal_set_interrupt_handler(123, hal_interrupt_handler_123);
hal_set_interrupt_handler(124, hal_interrupt_handler_124);
hal_set_interrupt_handler(125, hal_interrupt_handler_125);
hal_set_interrupt_handler(126, hal_interrupt_handler_126);
hal_set_interrupt_handler(127, hal_interrupt_handler_127);
hal_set_interrupt_handler(128, hal_interrupt_handler_128);
hal_set_interrupt_handler(129, hal_interrupt_handler_129);
hal_set_interrupt_handler(130, hal_interrupt_handler_130);
hal_set_interrupt_handler(131, hal_interrupt_handler_131);
hal_set_interrupt_handler(132, hal_interrupt_handler_132);
hal_set_interrupt_handler(133, hal_interrupt_handler_133);
hal_set_interrupt_handler(134, hal_interrupt_handler_134);
hal_set_interrupt_handler(135, hal_interrupt_handler_135);
hal_set_interrupt_handler(136, hal_interrupt_handler_136);
hal_set_interrupt_handler(137, hal_interrupt_handler_137);
hal_set_interrupt_handler(138, hal_interrupt_handler_138);
hal_set_interrupt_handler(139, hal_interrupt_handler_139);
hal_set_interrupt_handler(140, hal_interrupt_handler_140);
hal_set_interrupt_handler(141, hal_interrupt_handler_141);
hal_set_interrupt_handler(142, hal_interrupt_handler_142);
hal_set_interrupt_handler(143, hal_interrupt_handler_143);
hal_set_interrupt_handler(144, hal_interrupt_handler_144);
hal_set_interrupt_handler(145, hal_interrupt_handler_145);
hal_set_interrupt_handler(146, hal_interrupt_handler_146);
hal_set_interrupt_handler(147, hal_interrupt_handler_147);
hal_set_interrupt_handler(148, hal_interrupt_handler_148);
hal_set_interrupt_handler(149, hal_interrupt_handler_149);
hal_set_interrupt_handler(150, hal_interrupt_handler_150);
hal_set_interrupt_handler(151, hal_interrupt_handler_151);
hal_set_interrupt_handler(152, hal_interrupt_handler_152);
hal_set_interrupt_handler(153, hal_interrupt_handler_153);
hal_set_interrupt_handler(154, hal_interrupt_handler_154);
hal_set_interrupt_handler(155, hal_interrupt_handler_155);
hal_set_interrupt_handler(156, hal_interrupt_handler_156);
hal_set_interrupt_handler(157, hal_interrupt_handler_157);
hal_set_interrupt_handler(158, hal_interrupt_handler_158);
hal_set_interrupt_handler(159, hal_interrupt_handler_159);
hal_set_interrupt_handler(160, hal_interrupt_handler_160);
hal_set_interrupt_handler(161, hal_interrupt_handler_161);
hal_set_interrupt_handler(162, hal_interrupt_handler_162);
hal_set_interrupt_handler(163, hal_interrupt_handler_163);
hal_set_interrupt_handler(164, hal_interrupt_handler_164);
hal_set_interrupt_handler(165, hal_interrupt_handler_165);
hal_set_interrupt_handler(166, hal_interrupt_handler_166);
hal_set_interrupt_handler(167, hal_interrupt_handler_167);
hal_set_interrupt_handler(168, hal_interrupt_handler_168);
hal_set_interrupt_handler(169, hal_interrupt_handler_169);
hal_set_interrupt_handler(170, hal_interrupt_handler_170);
hal_set_interrupt_handler(171, hal_interrupt_handler_171);
hal_set_interrupt_handler(172, hal_interrupt_handler_172);
hal_set_interrupt_handler(173, hal_interrupt_handler_173);
hal_set_interrupt_handler(174, hal_interrupt_handler_174);
hal_set_interrupt_handler(175, hal_interrupt_handler_175);
hal_set_interrupt_handler(176, hal_interrupt_handler_176);
hal_set_interrupt_handler(177, hal_interrupt_handler_177);
hal_set_interrupt_handler(178, hal_interrupt_handler_178);
hal_set_interrupt_handler(179, hal_interrupt_handler_179);
hal_set_interrupt_handler(180, hal_interrupt_handler_180);
hal_set_interrupt_handler(181, hal_interrupt_handler_181);
hal_set_interrupt_handler(182, hal_interrupt_handler_182);
hal_set_interrupt_handler(183, hal_interrupt_handler_183);
hal_set_interrupt_handler(184, hal_interrupt_handler_184);
hal_set_interrupt_handler(185, hal_interrupt_handler_185);
hal_set_interrupt_handler(186, hal_interrupt_handler_186);
hal_set_interrupt_handler(187, hal_interrupt_handler_187);
hal_set_interrupt_handler(188, hal_interrupt_handler_188);
hal_set_interrupt_handler(189, hal_interrupt_handler_189);
hal_set_interrupt_handler(190, hal_interrupt_handler_190);
hal_set_interrupt_handler(191, hal_interrupt_handler_191);
hal_set_interrupt_handler(192, hal_interrupt_handler_192);
hal_set_interrupt_handler(193, hal_interrupt_handler_193);
hal_set_interrupt_handler(194, hal_interrupt_handler_194);
hal_set_interrupt_handler(195, hal_interrupt_handler_195);
hal_set_interrupt_handler(196, hal_interrupt_handler_196);
hal_set_interrupt_handler(197, hal_interrupt_handler_197);
hal_set_interrupt_handler(198, hal_interrupt_handler_198);
hal_set_interrupt_handler(199, hal_interrupt_handler_199);
hal_set_interrupt_handler(200, hal_interrupt_handler_200);
hal_set_interrupt_handler(201, hal_interrupt_handler_201);
hal_set_interrupt_handler(202, hal_interrupt_handler_202);
hal_set_interrupt_handler(203, hal_interrupt_handler_203);
hal_set_interrupt_handler(204, hal_interrupt_handler_204);
hal_set_interrupt_handler(205, hal_interrupt_handler_205);
hal_set_interrupt_handler(206, hal_interrupt_handler_206);
hal_set_interrupt_handler(207, hal_interrupt_handler_207);
hal_set_interrupt_handler(208, hal_interrupt_handler_208);
hal_set_interrupt_handler(209, hal_interrupt_handler_209);
hal_set_interrupt_handler(210, hal_interrupt_handler_210);
hal_set_interrupt_handler(211, hal_interrupt_handler_211);
hal_set_interrupt_handler(212, hal_interrupt_handler_212);
hal_set_interrupt_handler(213, hal_interrupt_handler_213);
hal_set_interrupt_handler(214, hal_interrupt_handler_214);
hal_set_interrupt_handler(215, hal_interrupt_handler_215);
hal_set_interrupt_handler(216, hal_interrupt_handler_216);
hal_set_interrupt_handler(217, hal_interrupt_handler_217);
hal_set_interrupt_handler(218, hal_interrupt_handler_218);
hal_set_interrupt_handler(219, hal_interrupt_handler_219);
hal_set_interrupt_handler(220, hal_interrupt_handler_220);
hal_set_interrupt_handler(221, hal_interrupt_handler_221);
hal_set_interrupt_handler(222, hal_interrupt_handler_222);
hal_set_interrupt_handler(223, hal_interrupt_handler_223);
hal_set_interrupt_handler(224, hal_interrupt_handler_224);
hal_set_interrupt_handler(225, hal_interrupt_handler_225);
hal_set_interrupt_handler(226, hal_interrupt_handler_226);
hal_set_interrupt_handler(227, hal_interrupt_handler_227);
hal_set_interrupt_handler(228, hal_interrupt_handler_228);
hal_set_interrupt_handler(229, hal_interrupt_handler_229);
hal_set_interrupt_handler(230, hal_interrupt_handler_230);
hal_set_interrupt_handler(231, hal_interrupt_handler_231);
hal_set_interrupt_handler(232, hal_interrupt_handler_232);
hal_set_interrupt_handler(233, hal_interrupt_handler_233);
hal_set_interrupt_handler(234, hal_interrupt_handler_234);
hal_set_interrupt_handler(235, hal_interrupt_handler_235);
hal_set_interrupt_handler(236, hal_interrupt_handler_236);
hal_set_interrupt_handler(237, hal_interrupt_handler_237);
hal_set_interrupt_handler(238, hal_interrupt_handler_238);
hal_set_interrupt_handler(239, hal_interrupt_handler_239);
hal_set_interrupt_handler(240, hal_interrupt_handler_240);
hal_set_interrupt_handler(241, hal_interrupt_handler_241);
hal_set_interrupt_handler(242, hal_interrupt_handler_242);
hal_set_interrupt_handler(243, hal_interrupt_handler_243);
hal_set_interrupt_handler(244, hal_interrupt_handler_244);
hal_set_interrupt_handler(245, hal_interrupt_handler_245);
hal_set_interrupt_handler(246, hal_interrupt_handler_246);
hal_set_interrupt_handler(247, hal_interrupt_handler_247);
hal_set_interrupt_handler(248, hal_interrupt_handler_248);
hal_set_interrupt_handler(249, hal_interrupt_handler_249);
hal_set_interrupt_handler(250, hal_interrupt_handler_250);
hal_set_interrupt_handler(251, hal_interrupt_handler_251);
hal_set_interrupt_handler(252, hal_interrupt_handler_252);
hal_set_interrupt_handler(253, hal_interrupt_handler_253);
hal_set_interrupt_handler(254, hal_interrupt_handler_254);
hal_set_interrupt_handler(255, hal_interrupt_handler_255);
return;
}
@ -128,8 +373,8 @@ int32_t KAPI hal_interrupt_init(void)
{
uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
eax = 1;
hal_cpuid(&eax,&ebx,&ecx,&edx);
if(!(edx & bit_mask_32(9)))
hal_cpuid(&eax, &ebx, &ecx, &edx);
if (!(edx & bit_mask_32(9)))
{
hal_printf("ERROR: APIC not supported by CPU.\n");
return 1;
@ -140,7 +385,7 @@ int32_t KAPI hal_interrupt_init(void)
g_idt_ptr.limit = IDT_ENTRY_NUM * IDT_ENTRY_SIZE - 1;
// clear dispatch table
for(uint64_t i = 0; i < IDT_ENTRY_NUM; i++)
for (uint64_t i = 0; i < IDT_ENTRY_NUM; i++)
{
g_intr_handler_table[i] = NULL;
}
@ -158,27 +403,23 @@ int32_t KAPI hal_interrupt_init(void)
uint64_t apic_base = 0;
ecx = MSR_IA32_APIC_BASE;
hal_read_msr(&ecx, &edx, &eax);
apic_base_reg = ((uint64_t)edx << 32) + (uint64_t)eax;
apic_base = apic_base_reg & bit_field_mask_64(12,35);
hal_printf("APIC Base: 0x%X\n", apic_base);
hal_printf("APIC Enabled: %s\n", apic_base_reg & bit_mask_64(11) ? "Yes" : "No");
hal_printf("BSP: %s\n", apic_base_reg & bit_mask_64(8) ? "Yes" : "No");
hal_printf("APIC Spour: 0x%X\n", *(uint32_t*)((char*)apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET));
apic_base_reg = ((uint64_t) edx << 32) + (uint64_t) eax;
apic_base = apic_base_reg & bit_field_mask_64(12, 35);
//hal_printf("APIC Base: 0x%X\n", apic_base);
//hal_printf("APIC Enabled: %s\n", apic_base_reg & bit_mask_64(11) ? "Yes" : "No");
//hal_printf("BSP: %s\n", apic_base_reg & bit_mask_64(8) ? "Yes" : "No");
//hal_printf("APIC Spour: 0x%X\n", *(uint32_t *) ((char *) apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET));
// hardware enable APIC
ecx = MSR_IA32_APIC_BASE;
eax = (uint32_t)(apic_base_reg & bit_field_mask_64(0,31)) | bit_mask_32(11);
eax = (uint32_t) (apic_base_reg & bit_field_mask_64(0, 31)) | bit_mask_32(11);
hal_write_msr(&ecx, &edx, &eax);
// software enable APIC
hal_write_mem_32((char*)apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET,
*(uint32_t*)((char*)apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET) | bit_mask_32(8));
hal_write_mem_32((char *) apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET,
*(uint32_t *) ((char *) apic_base + APIC_SPURIOUS_INT_VEC_REG_OFFSET) | bit_mask_32(8));
// for(int i = 0; i < IDT_ENTRY_NUM; i++)
// {
// hal_printf("IDT%d: %d,%d,%d,%d",i, (uint64_t)g_idt);
// }
hal_trigger_interrupt(33);
hal_enable_interrupt();
// hal_issue_interrupt(1, 255);
// hal_enable_interrupt();
return 0;
}

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

@ -3,8 +3,8 @@
* See COPYING under root for details
*/
#include "k_def.h"
#include "k_type.h"
#include "s_def.h"
#include "s_type.h"
#include "hal_mem.h"
#include "salloc.h"

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

@ -3,7 +3,7 @@
* See COPYING under root for details
*/
#include "k_def.h"
#include "s_def.h"
#include "std_lib.h"
#include "hal_print.h"
#include "hal_var.h"

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

@ -1,7 +1,7 @@
#ifndef _HAL_ARCH_H_
#define _HAL_ARCH_H_
#include "k_def.h"
#include "s_def.h"
typedef struct
{
@ -50,8 +50,6 @@ extern void KAPI hal_flush_gdt(hal_gdt_ptr_t *gdt_ptr, uint64_t code_slct, uint6
extern void KAPI hal_flush_tlb();
#define hal_trigger_interrupt(x) __asm__ __volatile__ ("int "#x);
extern void KAPI hal_flush_idt(hal_idt_ptr_t *idt_ptr);
extern void KAPI hal_read_idt(hal_idt_ptr_t **idt_ptr);
@ -60,4 +58,8 @@ extern void KAPI hal_write_cr3(uint64_t base);
extern uint64_t KAPI hal_read_cr3();
extern void KAPI hal_write_cr8(uint64_t pri);
extern uint64_t KAPI hal_read_cr8();
#endif

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

@ -6,8 +6,9 @@
#ifndef _HAL_IO_H_
#define _HAL_IO_H_
#include "k_def.h"
#include "k_type.h"
#include "s_intr.h"
#include "s_def.h"
#include "s_type.h"
#define GATE_DPL_0 (0ull << 13)
#define GATE_DPL_1 (1ull << 13)
@ -18,7 +19,7 @@
#define GATE_TYPE_INTERRUPT (14ull << 8)
#define GATE_TYPE_TRAP (15ull << 8)
#define IDT_ENTRY_NUM 40
#define IDT_ENTRY_NUM 256
#define IDT_ENTRY_SIZE 16
#define APIC_SPURIOUS_INT_VEC_REG_OFFSET 0xF0
@ -30,37 +31,6 @@
#define APIC_LVT_LINT1_REG 0x360
#define APIC_LVT_ERROR_REG 0x370
// SYSTEM INTERRUPT HANDLERS
extern void hal_interrupt_handler_0(void);
extern void hal_interrupt_handler_1(void);
extern void hal_interrupt_handler_2(void);
extern void hal_interrupt_handler_3(void);
extern void hal_interrupt_handler_4(void);
extern void hal_interrupt_handler_5(void);
extern void hal_interrupt_handler_6(void);
extern void hal_interrupt_handler_7(void);
extern void hal_interrupt_handler_8(void);
extern void hal_interrupt_handler_10(void);
extern void hal_interrupt_handler_11(void);
extern void hal_interrupt_handler_12(void);
extern void hal_interrupt_handler_13(void);
extern void hal_interrupt_handler_14(void);
extern void hal_interrupt_handler_16(void);
extern void hal_interrupt_handler_17(void);
extern void hal_interrupt_handler_18(void);
extern void hal_interrupt_handler_19(void);
extern void hal_interrupt_handler_20(void);
// USER DEFINED INTERRUPT_HANDLERS
extern void hal_interrupt_handler_32(void);
extern void hal_interrupt_handler_33(void);
extern void hal_interrupt_handler_34(void);
extern void hal_interrupt_handler_35(void);
extern void hal_interrupt_handler_36(void);
extern void hal_interrupt_handler_37(void);
extern void hal_interrupt_handler_38(void);
extern void hal_interrupt_handler_39(void);
typedef struct
{
const uint64_t rip;
@ -70,12 +40,529 @@ typedef struct
const uint64_t ss;
} hal_intr_context_t;
void KAPI hal_register_interrupt_handler(uint64_t index,
void (*handler)(uint64_t pc,
uint64_t sp,
uint64_t error));
// SYSTEM INTERRUPT HANDLERS
extern void KAPI hal_interrupt_handler_0(void);
void KAPI hal_deregister_interrupt_handler(uint64_t index);
extern void KAPI hal_interrupt_handler_1(void);
extern void KAPI hal_interrupt_handler_2(void);
extern void KAPI hal_interrupt_handler_3(void);
extern void KAPI hal_interrupt_handler_4(void);
extern void KAPI hal_interrupt_handler_5(void);
extern void KAPI hal_interrupt_handler_6(void);
extern void KAPI hal_interrupt_handler_7(void);
extern void KAPI hal_interrupt_handler_8(void);
extern void KAPI hal_interrupt_handler_9(void);
extern void KAPI hal_interrupt_handler_10(void);
extern void KAPI hal_interrupt_handler_11(void);
extern void KAPI hal_interrupt_handler_12(void);
extern void KAPI hal_interrupt_handler_13(void);
extern void KAPI hal_interrupt_handler_14(void);
extern void KAPI hal_interrupt_handler_15(void);
extern void KAPI hal_interrupt_handler_16(void);
extern void KAPI hal_interrupt_handler_17(void);
extern void KAPI hal_interrupt_handler_18(void);
extern void KAPI hal_interrupt_handler_19(void);
extern void KAPI hal_interrupt_handler_20(void);
extern void KAPI hal_interrupt_handler_21(void);
extern void KAPI hal_interrupt_handler_22(void);
extern void KAPI hal_interrupt_handler_23(void);
extern void KAPI hal_interrupt_handler_24(void);
extern void KAPI hal_interrupt_handler_25(void);
extern void KAPI hal_interrupt_handler_26(void);
extern void KAPI hal_interrupt_handler_27(void);
extern void KAPI hal_interrupt_handler_28(void);
extern void KAPI hal_interrupt_handler_29(void);
extern void KAPI hal_interrupt_handler_30(void);
extern void KAPI hal_interrupt_handler_31(void);
// USER DEFINED INTERRUPT_HANDLERS
extern void KAPI hal_interrupt_handler_32(void);
extern void KAPI hal_interrupt_handler_33(void);
extern void KAPI hal_interrupt_handler_34(void);
extern void KAPI hal_interrupt_handler_35(void);
extern void KAPI hal_interrupt_handler_36(void);
extern void KAPI hal_interrupt_handler_37(void);
extern void KAPI hal_interrupt_handler_38(void);
extern void KAPI hal_interrupt_handler_39(void);
extern void KAPI hal_interrupt_handler_40(void);
extern void KAPI hal_interrupt_handler_41(void);
extern void KAPI hal_interrupt_handler_42(void);
extern void KAPI hal_interrupt_handler_43(void);
extern void KAPI hal_interrupt_handler_44(void);
extern void KAPI hal_interrupt_handler_45(void);
extern void KAPI hal_interrupt_handler_46(void);
extern void KAPI hal_interrupt_handler_47(void);
extern void KAPI hal_interrupt_handler_48(void);
extern void KAPI hal_interrupt_handler_49(void);
extern void KAPI hal_interrupt_handler_50(void);
extern void KAPI hal_interrupt_handler_51(void);
extern void KAPI hal_interrupt_handler_52(void);
extern void KAPI hal_interrupt_handler_53(void);
extern void KAPI hal_interrupt_handler_54(void);
extern void KAPI hal_interrupt_handler_55(void);
extern void KAPI hal_interrupt_handler_56(void);
extern void KAPI hal_interrupt_handler_57(void);
extern void KAPI hal_interrupt_handler_58(void);
extern void KAPI hal_interrupt_handler_59(void);
extern void KAPI hal_interrupt_handler_60(void);
extern void KAPI hal_interrupt_handler_61(void);
extern void KAPI hal_interrupt_handler_62(void);
extern void KAPI hal_interrupt_handler_63(void);
extern void KAPI hal_interrupt_handler_64(void);
extern void KAPI hal_interrupt_handler_65(void);
extern void KAPI hal_interrupt_handler_66(void);
extern void KAPI hal_interrupt_handler_67(void);
extern void KAPI hal_interrupt_handler_68(void);
extern void KAPI hal_interrupt_handler_69(void);
extern void KAPI hal_interrupt_handler_70(void);
extern void KAPI hal_interrupt_handler_71(void);
extern void KAPI hal_interrupt_handler_72(void);
extern void KAPI hal_interrupt_handler_73(void);
extern void KAPI hal_interrupt_handler_74(void);
extern void KAPI hal_interrupt_handler_75(void);
extern void KAPI hal_interrupt_handler_76(void);
extern void KAPI hal_interrupt_handler_77(void);
extern void KAPI hal_interrupt_handler_78(void);
extern void KAPI hal_interrupt_handler_79(void);
extern void KAPI hal_interrupt_handler_80(void);
extern void KAPI hal_interrupt_handler_81(void);
extern void KAPI hal_interrupt_handler_82(void);
extern void KAPI hal_interrupt_handler_83(void);
extern void KAPI hal_interrupt_handler_84(void);
extern void KAPI hal_interrupt_handler_85(void);
extern void KAPI hal_interrupt_handler_86(void);
extern void KAPI hal_interrupt_handler_87(void);
extern void KAPI hal_interrupt_handler_88(void);
extern void KAPI hal_interrupt_handler_89(void);
extern void KAPI hal_interrupt_handler_90(void);
extern void KAPI hal_interrupt_handler_91(void);
extern void KAPI hal_interrupt_handler_92(void);
extern void KAPI hal_interrupt_handler_93(void);
extern void KAPI hal_interrupt_handler_94(void);
extern void KAPI hal_interrupt_handler_95(void);
extern void KAPI hal_interrupt_handler_96(void);
extern void KAPI hal_interrupt_handler_97(void);
extern void KAPI hal_interrupt_handler_98(void);
extern void KAPI hal_interrupt_handler_99(void);
extern void KAPI hal_interrupt_handler_100(void);
extern void KAPI hal_interrupt_handler_101(void);
extern void KAPI hal_interrupt_handler_102(void);
extern void KAPI hal_interrupt_handler_103(void);
extern void KAPI hal_interrupt_handler_104(void);
extern void KAPI hal_interrupt_handler_105(void);
extern void KAPI hal_interrupt_handler_106(void);
extern void KAPI hal_interrupt_handler_107(void);
extern void KAPI hal_interrupt_handler_108(void);
extern void KAPI hal_interrupt_handler_109(void);
extern void KAPI hal_interrupt_handler_110(void);
extern void KAPI hal_interrupt_handler_111(void);
extern void KAPI hal_interrupt_handler_112(void);
extern void KAPI hal_interrupt_handler_113(void);
extern void KAPI hal_interrupt_handler_114(void);
extern void KAPI hal_interrupt_handler_115(void);
extern void KAPI hal_interrupt_handler_116(void);
extern void KAPI hal_interrupt_handler_117(void);
extern void KAPI hal_interrupt_handler_118(void);
extern void KAPI hal_interrupt_handler_119(void);
extern void KAPI hal_interrupt_handler_120(void);
extern void KAPI hal_interrupt_handler_121(void);
extern void KAPI hal_interrupt_handler_122(void);
extern void KAPI hal_interrupt_handler_123(void);
extern void KAPI hal_interrupt_handler_124(void);
extern void KAPI hal_interrupt_handler_125(void);
extern void KAPI hal_interrupt_handler_126(void);
extern void KAPI hal_interrupt_handler_127(void);
extern void KAPI hal_interrupt_handler_128(void);
extern void KAPI hal_interrupt_handler_129(void);
extern void KAPI hal_interrupt_handler_130(void);
extern void KAPI hal_interrupt_handler_131(void);
extern void KAPI hal_interrupt_handler_132(void);
extern void KAPI hal_interrupt_handler_133(void);
extern void KAPI hal_interrupt_handler_134(void);
extern void KAPI hal_interrupt_handler_135(void);
extern void KAPI hal_interrupt_handler_136(void);
extern void KAPI hal_interrupt_handler_137(void);
extern void KAPI hal_interrupt_handler_138(void);
extern void KAPI hal_interrupt_handler_139(void);
extern void KAPI hal_interrupt_handler_140(void);
extern void KAPI hal_interrupt_handler_141(void);
extern void KAPI hal_interrupt_handler_142(void);
extern void KAPI hal_interrupt_handler_143(void);
extern void KAPI hal_interrupt_handler_144(void);
extern void KAPI hal_interrupt_handler_145(void);
extern void KAPI hal_interrupt_handler_146(void);
extern void KAPI hal_interrupt_handler_147(void);
extern void KAPI hal_interrupt_handler_148(void);
extern void KAPI hal_interrupt_handler_149(void);
extern void KAPI hal_interrupt_handler_150(void);
extern void KAPI hal_interrupt_handler_151(void);
extern void KAPI hal_interrupt_handler_152(void);
extern void KAPI hal_interrupt_handler_153(void);
extern void KAPI hal_interrupt_handler_154(void);
extern void KAPI hal_interrupt_handler_155(void);
extern void KAPI hal_interrupt_handler_156(void);
extern void KAPI hal_interrupt_handler_157(void);
extern void KAPI hal_interrupt_handler_158(void);
extern void KAPI hal_interrupt_handler_159(void);
extern void KAPI hal_interrupt_handler_160(void);
extern void KAPI hal_interrupt_handler_161(void);
extern void KAPI hal_interrupt_handler_162(void);
extern void KAPI hal_interrupt_handler_163(void);
extern void KAPI hal_interrupt_handler_164(void);
extern void KAPI hal_interrupt_handler_165(void);
extern void KAPI hal_interrupt_handler_166(void);
extern void KAPI hal_interrupt_handler_167(void);
extern void KAPI hal_interrupt_handler_168(void);
extern void KAPI hal_interrupt_handler_169(void);
extern void KAPI hal_interrupt_handler_170(void);
extern void KAPI hal_interrupt_handler_171(void);
extern void KAPI hal_interrupt_handler_172(void);
extern void KAPI hal_interrupt_handler_173(void);
extern void KAPI hal_interrupt_handler_174(void);
extern void KAPI hal_interrupt_handler_175(void);
extern void KAPI hal_interrupt_handler_176(void);
extern void KAPI hal_interrupt_handler_177(void);
extern void KAPI hal_interrupt_handler_178(void);
extern void KAPI hal_interrupt_handler_179(void);
extern void KAPI hal_interrupt_handler_180(void);
extern void KAPI hal_interrupt_handler_181(void);
extern void KAPI hal_interrupt_handler_182(void);
extern void KAPI hal_interrupt_handler_183(void);
extern void KAPI hal_interrupt_handler_184(void);
extern void KAPI hal_interrupt_handler_185(void);
extern void KAPI hal_interrupt_handler_186(void);
extern void KAPI hal_interrupt_handler_187(void);
extern void KAPI hal_interrupt_handler_188(void);
extern void KAPI hal_interrupt_handler_189(void);
extern void KAPI hal_interrupt_handler_190(void);
extern void KAPI hal_interrupt_handler_191(void);
extern void KAPI hal_interrupt_handler_192(void);
extern void KAPI hal_interrupt_handler_193(void);
extern void KAPI hal_interrupt_handler_194(void);
extern void KAPI hal_interrupt_handler_195(void);
extern void KAPI hal_interrupt_handler_196(void);
extern void KAPI hal_interrupt_handler_197(void);
extern void KAPI hal_interrupt_handler_198(void);
extern void KAPI hal_interrupt_handler_199(void);
extern void KAPI hal_interrupt_handler_200(void);
extern void KAPI hal_interrupt_handler_201(void);
extern void KAPI hal_interrupt_handler_202(void);
extern void KAPI hal_interrupt_handler_203(void);
extern void KAPI hal_interrupt_handler_204(void);
extern void KAPI hal_interrupt_handler_205(void);
extern void KAPI hal_interrupt_handler_206(void);
extern void KAPI hal_interrupt_handler_207(void);
extern void KAPI hal_interrupt_handler_208(void);
extern void KAPI hal_interrupt_handler_209(void);
extern void KAPI hal_interrupt_handler_210(void);
extern void KAPI hal_interrupt_handler_211(void);
extern void KAPI hal_interrupt_handler_212(void);
extern void KAPI hal_interrupt_handler_213(void);
extern void KAPI hal_interrupt_handler_214(void);
extern void KAPI hal_interrupt_handler_215(void);
extern void KAPI hal_interrupt_handler_216(void);
extern void KAPI hal_interrupt_handler_217(void);
extern void KAPI hal_interrupt_handler_218(void);
extern void KAPI hal_interrupt_handler_219(void);
extern void KAPI hal_interrupt_handler_220(void);
extern void KAPI hal_interrupt_handler_221(void);
extern void KAPI hal_interrupt_handler_222(void);
extern void KAPI hal_interrupt_handler_223(void);
extern void KAPI hal_interrupt_handler_224(void);
extern void KAPI hal_interrupt_handler_225(void);
extern void KAPI hal_interrupt_handler_226(void);
extern void KAPI hal_interrupt_handler_227(void);
extern void KAPI hal_interrupt_handler_228(void);
extern void KAPI hal_interrupt_handler_229(void);
extern void KAPI hal_interrupt_handler_230(void);
extern void KAPI hal_interrupt_handler_231(void);
extern void KAPI hal_interrupt_handler_232(void);
extern void KAPI hal_interrupt_handler_233(void);
extern void KAPI hal_interrupt_handler_234(void);
extern void KAPI hal_interrupt_handler_235(void);
extern void KAPI hal_interrupt_handler_236(void);
extern void KAPI hal_interrupt_handler_237(void);
extern void KAPI hal_interrupt_handler_238(void);
extern void KAPI hal_interrupt_handler_239(void);
extern void KAPI hal_interrupt_handler_240(void);
extern void KAPI hal_interrupt_handler_241(void);
extern void KAPI hal_interrupt_handler_242(void);
extern void KAPI hal_interrupt_handler_243(void);
extern void KAPI hal_interrupt_handler_244(void);
extern void KAPI hal_interrupt_handler_245(void);
extern void KAPI hal_interrupt_handler_246(void);
extern void KAPI hal_interrupt_handler_247(void);
extern void KAPI hal_interrupt_handler_248(void);
extern void KAPI hal_interrupt_handler_249(void);
extern void KAPI hal_interrupt_handler_250(void);
extern void KAPI hal_interrupt_handler_251(void);
extern void KAPI hal_interrupt_handler_252(void);
extern void KAPI hal_interrupt_handler_253(void);
extern void KAPI hal_interrupt_handler_254(void);
extern void KAPI hal_interrupt_handler_255(void);
int32_t KAPI hal_register_interrupt_handler(k_handler_type_t type,
uint32_t priority,
void (*handler)(uint64_t pc,
uint64_t sp,
uint64_t error));
void KAPI hal_deregister_interrupt_handler(int32_t index);
void KAPI hal_issue_interrupt(uint32_t target_core, uint32_t vector);
void KAPI hal_set_interrupt_handler(uint64_t index, void (*handler)(void));

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

@ -6,8 +6,8 @@
#ifndef _HAL_MEM_H_
#define _HAL_MEM_H_
#include "k_def.h"
#include "k_type.h"
#include "s_def.h"
#include "s_type.h"
#include "linked_list.h"
#define GDT_ENTRY_SIZE 8

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

@ -5,8 +5,8 @@
#ifndef _HAL_PRINT_H_
#define _HAL_PRINT_H_
#include "k_def.h"
#include "k_type.h"
#include "s_def.h"
#include "s_type.h"
#define get_column(pos) (pos % 80)
#define get_row(pos) (pos / 80)

2
x64/src/hal/inc/hal_var.h
View File

@ -17,5 +17,7 @@ extern void (*g_intr_handler_table[IDT_ENTRY_NUM])(uint64_t pc, uint64_t sp, uin
extern hal_gdt_ptr_t g_gdt_ptr;
extern hal_idt_ptr_t g_idt_ptr;
extern uint64_t text_pos;
extern char kernel_start[];
extern char kernel_end[];
#endif

11
x64/src/kernel/inc/k_alloc.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef _K_ALLOC_H_
#define _K_ALLOC_H_
#include "s_def.h"
void KAPI k_alloc_init();
void* KAPI k_alloc(uint32_t size);
void KAPI k_free(void* ptr);
#endif

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

@ -1,7 +1,7 @@
#ifndef _ATOMIC_H_
#define _ATOMIC_H_
#include "k_def.h"
#include "s_def.h"
#include "k_intr.h"
typedef struct

48
x64/src/kernel/inc/k_hal.h
View File

@ -1,48 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _K_HAL_H_
#define _K_HAL_H_
#include "k_def.h"
#include "k_type.h"
#include "k_sys_info.h"
// hal interrupt
extern void KAPI hal_enable_interrupt();
extern void KAPI hal_disable_interrupt();
extern void KAPI hal_mask_interrupt();
extern void KAPI hal_unmask_interrupt();
extern void KAPI hal_register_interrupt_handler(uint64_t index,
void (*handler)(uint64_t pc,
uint64_t sp,
uint64_t error));
extern void KAPI hal_deregister_interrupt_handler(uint64_t index);
#define hal_trigger_interrupt(x) __asm__ __volatile__ ("int "#x);
// concurrency
extern uint64_t KAPI hal_interlocked_exchange(uint64_t* dst, uint64_t val);
// loaded kernel addr
extern char kernel_start[];
extern char kernel_end[];
// hal init
extern k_hal_info_t* KAPI hal_init(char* m_info);
// hal output
extern void KAPI hal_printf(char const *format, ...);
extern void KAPI hal_clear_screen(void);
// hal CPU control
extern void KAPI hal_halt_cpu(void);
// hal memory
//debug
extern void KAPI hal_bochs_magic_breakpoint();
#endif

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

@ -1,24 +1,24 @@
#ifndef _K_INTR_H_
#define _K_INTR_H_
#include "k_type.h"
#include "k_def.h"
#include "s_intr.h"
#include "s_type.h"
#include "s_def.h"
typedef uint64_t k_irql_t;
#define INTR_VEC_DPC 1
#define INVR_VEC_APC 2
#define INVR_VEC_TIMER 3
int32_t KAPI k_register_interrupt_handler(k_handler_type_t type,
uint32_t priority,
void (*handler)(uint64_t pc, uint64_t sp, uint64_t error));
#define IRQL_DISABLED 0
#define IRQL_DPC 1
#define IRQL_APC 2
#define IRQL_USER 3
void KAPI k_register_interrupt_handler(uint64_t index, void (*handler)(uint64_t pc, uint64_t sp, uint64_t error));
void KAPI k_deregister_interrupt_handler(int32_t index);
void KAPI k_disable_interrupt();
void KAPI k_enable_interrupt();
k_irql_t KAPI k_get_current_irql();
void KAPI k_set_current_irql(k_irql_t irql);
#endif

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

@ -1,17 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _K_PMM_H_
#define _K_PMM_H_
#include "linked_list.h"
void pmm_init(linked_list_t* occupied, linked_list_t* available);
void*pmm_alloc_page();
void pmm_free_page(void *p_addr);
#endif

29
x64/src/kernel/inc/k_proc.h
View File

@ -1,29 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#ifndef _PROC_H
#define _PROC_H
#include "k_def.h"
typedef struct
{
uint64_t rax;
uint64_t rbx;
uint64_t rcx;
uint64_t rdx;
} __attribute__((packed)) process_context_t;
typedef struct
{
uint32_t process_id;
uint32_t priority;
process_context_t context;
} __attribute__((packed)) process_control_block_t;
#endif

29
x64/src/kernel/k_alloc.c Normal file
View File

@ -0,0 +1,29 @@
#include "s_def.h"
#include "salloc.h"
#define K_KERNEL_HEAP_SIZE 8192
static _Bool _k_alloc_initialized;
static uint8_t _k_alloc_heap[K_KERNEL_HEAP_SIZE];
void KAPI k_alloc_init()
{
if(!_k_alloc_initialized)
{
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;
}
void KAPI k_free(void* ptr)
{
if(_k_alloc_initialized)
{
sfree(_k_alloc_heap, ptr);
}
}

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

@ -1,5 +1,5 @@
#include "k_atomic.h"
#include "k_hal.h"
#include "s_hal.h"
void KAPI k_spin_lock(k_spin_lock_t *lock)
{

43
x64/src/kernel/k_boot.c Normal file
View File

@ -0,0 +1,43 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#include "k_alloc.h"
#include "s_hal.h"
#include "k_lib_test.h"
// returning from this function results in halting the cpu
void KAPI kmain(void *multiboot_info)
{
// init kernel heap
k_alloc_init();
k_boot_info_t* boot_info = (k_boot_info_t*)k_alloc(sizeof(boot_info));
if(boot_info == NULL)
{
hal_printf("KERNEL: Unable to allocated memory for boot info struct.\n");
hal_halt_cpu();
}
if(hal_init(multiboot_info, boot_info) != 0)
{
hal_printf("KERNEL: HAL initialization failed.\n");
hal_halt_cpu();
}
hal_printf("KERNEL: Base Addr is 0x%X. Size is %uB, %uKB.\n",
boot_info->krnl_start,
(boot_info->krnl_end-boot_info->krnl_start),
(boot_info->krnl_end-boot_info->krnl_start)/1024);
hal_printf("KERNEL: CPU Vendor is \"%s\".\n", boot_info->cpu_vd_str);
linked_list_test();
avl_tree_test();
salloc_test();
hal_printf("KERNEL: Kernel tasks finished.\n");
hal_halt_cpu();
}

64
x64/src/kernel/k_entry.c
View File

@ -1,64 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#include <k_sys_info.h>
#include "k_def.h"
#include "k_hal.h"
#include "std_lib.h"
#include "k_lib_test.h"
// returning from this function results in halting the cpu
void KAPI kmain(void *multiboot_info)
{
k_hal_info_t* boot_info = hal_init(multiboot_info);
if(boot_info == NULL)
{
hal_printf("HAL failed.\n");
hal_halt_cpu();
}
hal_printf("Kernel Loaded at 0x%X. Size: %uB, %uKB\n\n",kernel_start,(kernel_end-kernel_start),(kernel_end-kernel_start)/1024);
hal_printf("CPU Vendor:%s\n", boot_info->cpu_vendor_string);
linked_list_test();
avl_tree_test();
salloc_test();
hal_printf("KRNL: Kernel task finished.");
hal_halt_cpu();
if(boot_info->mem_info != NULL)
{
hal_printf("Installed Memory: %uB\n", boot_info->mem_info->mem_installed);
hal_printf("Useable Memory: %uB\n", boot_info->mem_info->mem_available);
for(int i = 0; i < linked_list_size(boot_info->mem_info->free_page_list); i++)
{
memory_descriptor_node_t* each_node = OBTAIN_STRUCT_ADDR(
linked_list_get(boot_info->mem_info->free_page_list,i),
list_node,
memory_descriptor_node_t);
hal_printf("Base Addr:0x%X Num of Pages:%u\n", each_node->base_addr, each_node->page_count);
}
}
if(boot_info->module_info != NULL)
{
hal_printf("\nNumber of Modules Loaded: %u", boot_info->module_info->module_count);
for (uint64_t i = 0; i <= boot_info->module_info->module_count; i++)
{
module_descriptor_node_t *module_descriptor = OBTAIN_STRUCT_ADDR(
linked_list_get(boot_info->module_info->module_list, (int) i),
list_node,
module_descriptor_node_t);
hal_printf("\nModule Name: %s\n Module Addr: 0x%X\n Module Size: %uB, %uKB\n", module_descriptor->name,
module_descriptor->base_addr, module_descriptor->size, module_descriptor->size / 1024);
};
}
hal_printf("KRNL: Kernel task finished.");
hal_halt_cpu();
}

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

@ -1,14 +1,26 @@
#include "k_intr.h"
#include "k_hal.h"
#include "s_hal.h"
void KAPI k_register_interrupt_handler(uint64_t index, void (*handler)(uint64_t pc, uint64_t sp, uint64_t error))
int32_t KAPI k_register_interrupt_handler(k_handler_type_t type,
uint32_t priority,
void (*handler)(uint64_t pc, uint64_t sp, uint64_t error))
{
hal_register_interrupt_handler(index, handler);
return hal_register_interrupt_handler(type, priority, handler);
}
void KAPI k_deregister_interrupt_handler(uint64_t index, void (*handler)(uint64_t pc, uint64_t sp, uint64_t error))
void KAPI k_deregister_interrupt_handler(int32_t index)
{
hal_register_interrupt_handler(index, handler);
hal_deregister_interrupt_handler(index);
}
k_irql_t KAPI k_get_current_irql()
{
return hal_read_interrupt_priority();
}
void KAPI k_set_current_irql(k_irql_t irql)
{
hal_set_interrupt_priority(irql);
}
void KAPI k_disable_interrupt()

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

@ -1,67 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#include "k_pmm.h"
#include "k_sys_info.h"
#include "hal_intr.h"
#include "std_lib.h"
linked_list_t* occupied_mem;
linked_list_t* available_mem;
void pmm_init(linked_list_t* occupied, linked_list_t* available)
{
hal_assert(occupied_mem != NULL && available_mem != NULL, NULL);
occupied_mem = occupied;
available_mem = available;
return;
}
void _pmm_add_page(linked_list_t* list,uint64_t base_addr, uint64_t size)
{
hal_assert(list != NULL,NULL);
base_addr = (base_addr >> 12) << 12;
if(linked_list_size(list) == 0)
{
return;
}
else
{
for (int i = 0; i < linked_list_size(list); i++) {
memory_descriptor_node_t *each_node = OBTAIN_STRUCT_ADDR(linked_list_get(list, i), list_node,
memory_descriptor_node_t);
}
}
}
void* pmm_alloc_page()
{
hal_assert(occupied_mem != NULL && available_mem != NULL, NULL);
if(linked_list_size(available_mem) == 0)
return NULL;
for(int i = 0; i < linked_list_size(available_mem); i++)
{
// memory_descriptor_node_t* each_node = OBTAIN_STRUCT_ADDR(linked_list_get(available_mem,i),list_node,memory_descriptor_node_t);
// if(each_node->size >= PHYSICAL_PAGE_SIZE)
// {
// uint64_t address = each_node->base_addr;
// // found, add to occupied list and return
// each_node->size = each_node->size - PHYSICAL_PAGE_SIZE;
// each_node->base_addr = each_node->base_addr + PHYSICAL_PAGE_SIZE;
//
//
// return (void*)address;
// }
}
// not found
return NULL;
}
void pmm_free_page(void *physical_addr)
{
}

6
x64/src/kernel/k_proc.c
View File

@ -1,6 +0,0 @@
/* Copyright 2016 secXsQuared
* Distributed under GPL license
* See COPYING under root for details
*/
#include "k_proc.h"

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

@ -1,8 +1,8 @@
#ifndef _K_TEST_DRIVER_H_
#define _K_TEST_DRIVER_H_
#include "k_type.h"
#include "k_def.h"
#include "s_type.h"
#include "s_def.h"
void KAPI test_begin(char *name);