nub31/nub-os
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
nub31
2025-09-03 13:13:16 +02:00
parent c338e05648
commit 87d1a291f7
26 changed files with 353 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/arch/x86_64/interrupts.c
View File

@@ -1,5 +1,7 @@
#include "interrupts.h"
#include "../../util.h"
#include "../arch.h"
#include "util.h"
#include <stdio.h>
#define PIC1_COMMAND 0x20
#define PIC1_DATA 0x21
@@ -84,7 +86,7 @@ void disable_pic()
printf("PIC disabled\n");
}
void handle_exception(const isr_frame_t* frame)
static void handle_exception(const isr_frame_t* frame)
{
printf("exception[%d]: %s, error code: %d\n", frame->int_no, exception_messages[frame->int_no], frame->err_code);
panic();
@@ -103,7 +105,7 @@ void register_irq_handler(uint8_t irq, irq_handler_t handler)
}
}
void handle_irq(const isr_frame_t* frame)
static void handle_irq(const isr_frame_t* frame)
{
uint8_t irq = frame->int_no - 32;

3
src/arch/x86_64/interrupts.h
View File

@@ -1,6 +1,5 @@
#pragma once
#include "../../kernel.h"
#include <stdbool.h>
#include <stdint.h>
@@ -26,11 +25,9 @@ void register_irq_handler(uint8_t irq, irq_handler_t handler);
static inline void enable_interrupts()
{
__asm__ volatile("sti");
printf("Interrupts enabled\n");
}
static inline void disable_interrupts()
{
__asm__ volatile("cli");
printf("Interrupts disabled\n");
}

189
src/arch/x86_64/keyboard.c
View File

@@ -1,110 +1,107 @@
#include "keyboard.h"
#include "../../kernel.h"
#include "../../util.h"
#include "interrupts.h"
#include <stddef.h>
// #include "keyboard.h"
// #include "interrupts.h"
// #include "util.h"
// #include <stddef.h>
#define SCANCODE_LEFT_SHIFT 42
#define SCANCODE_RIGHT_SHIFT 54
#define SCANCODE_CAPS_LOCK 58
// #define SCANCODE_LEFT_SHIFT 42
// #define SCANCODE_RIGHT_SHIFT 54
// #define SCANCODE_CAPS_LOCK 58
#define KEYBOARD_HANDLERS_LENGTH 32
// #define KEYBOARD_HANDLERS_LENGTH 32
unsigned const char us_keymap[128] = {
0, 27, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\b', '\t', 'q', 'w',
'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', 0, 'a', 's', 'd', 'f', 'g', 'h',
'j', 'k', 'l', ';', '\'', '`', 0, '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/',
0, '*', 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, '-', 0, 0, 0, '+', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
// unsigned const char us_keymap[128] = {
// 0, 27, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\b', '\t', 'q', 'w',
// 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', 0, 'a', 's', 'd', 'f', 'g', 'h',
// 'j', 'k', 'l', ';', '\'', '`', 0, '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/',
// 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, '-', 0, 0, 0, '+', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// };
unsigned const char us_keymap_shift[128] = {
0, 27, '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '\b', '\t', 'Q', 'W',
'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', 0, 'A', 'S', 'D', 'F', 'G', 'H',
'J', 'K', 'L', ':', '"', '~', 0, '|', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?',
0, '*', 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, '-', 0, 0, 0, '+', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
// unsigned const char us_keymap_shift[128] = {
// 0, 27, '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '\b', '\t', 'Q', 'W',
// 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', 0, 'A', 'S', 'D', 'F', 'G', 'H',
// 'J', 'K', 'L', ':', '"', '~', 0, '|', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?',
// 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, '-', 0, 0, 0, '+', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// };
bool shift = false;
bool caps_lock = false;
// bool shift = false;
// bool caps_lock = false;
// todo(nub): make dynamic when a memory allocator is implemented
static keyboard_handler_t keyboard_handlers[KEYBOARD_HANDLERS_LENGTH];
static size_t handler_index = 0;
// // todo(nub): make dynamic when a memory allocator is implemented
// static keyboard_handler_t keyboard_handlers[KEYBOARD_HANDLERS_LENGTH];
// static size_t handler_index = 0;
char scan_code_to_ascii(uint8_t scan_code)
{
if (scan_code >= 128)
{
return 0;
}
// char scan_code_to_ascii(uint8_t scan_code)
// {
// if (scan_code >= 128)
// {
// return 0;
// }
if ((!caps_lock && shift) || (caps_lock && !shift))
{
return us_keymap_shift[scan_code];
}
else
{
return us_keymap[scan_code];
}
}
// if ((!caps_lock && shift) || (caps_lock && !shift))
// {
// return us_keymap_shift[scan_code];
// }
// else
// {
// return us_keymap[scan_code];
// }
// }
void handle_keyboard(const isr_frame_t* frame)
{
uint8_t code = inb(0x60);
uint8_t scan_code = code & 0x7F;
bool pressed = (code & 0x80) == 0;
// void handle_keyboard(const isr_frame_t* frame)
// {
// uint8_t code = inb(0x60);
// uint8_t scan_code = code & 0x7F;
// bool pressed = (code & 0x80) == 0;
switch (scan_code)
{
case SCANCODE_LEFT_SHIFT:
case SCANCODE_RIGHT_SHIFT:
{
shift = pressed;
break;
}
case SCANCODE_CAPS_LOCK:
{
if (pressed)
{
caps_lock = !caps_lock;
}
break;
}
default:
{
keyboard_event_t event = {
.scan_code = scan_code,
.pressed = pressed,
.caps_lock = caps_lock,
.shift = shift,
.ascii = scan_code_to_ascii(scan_code),
};
// switch (scan_code)
// {
// case SCANCODE_LEFT_SHIFT:
// case SCANCODE_RIGHT_SHIFT:
// {
// shift = pressed;
// break;
// }
// case SCANCODE_CAPS_LOCK:
// {
// if (pressed)
// {
// caps_lock = !caps_lock;
// }
// break;
// }
// default:
// {
// keyboard_event_t event = {
// .scan_code = scan_code,
// .pressed = pressed,
// .caps_lock = caps_lock,
// .shift = shift,
// .ascii = scan_code_to_ascii(scan_code),
// };
for (size_t i = 0; i < handler_index; i++)
{
keyboard_handlers[i](&event);
}
}
}
}
// for (size_t i = 0; i < handler_index; i++)
// {
// keyboard_handlers[i](&event);
// }
// }
// }
// }
void register_keypress_handler(const keyboard_handler_t handler)
{
// todo(nub31): remove when a memory allocator is implemented and
// keyboard_handlers is a dynamic list
if (handler_index >= KEYBOARD_HANDLERS_LENGTH)
{
printf("Maximum keyboard handlers reached\n");
panic();
}
// void register_keypress_handler(const keyboard_handler_t handler)
// {
// // todo(nub31): remove when a memory allocator is implemented and
// // keyboard_handlers is a dynamic list
// if (handler_index >= KEYBOARD_HANDLERS_LENGTH)
// {
// }
keyboard_handlers[handler_index] = handler;
handler_index += 1;
}
// keyboard_handlers[handler_index] = handler;
// handler_index += 1;
// }
void init_keyboard()
{
register_irq_handler(1, handle_keyboard);
}
// void init_keyboard()
// {
// register_irq_handler(1, handle_keyboard);
// }

30
src/arch/x86_64/keyboard.h
View File

@@ -1,19 +1,19 @@
#pragma once
// #pragma once
#include <stdbool.h>
#include <stdint.h>
// #include <stdbool.h>
// #include <stdint.h>
typedef struct
{
uint8_t scan_code;
bool pressed;
bool shift;
bool caps_lock;
char ascii;
} keyboard_event_t;
// typedef struct
// {
// uint8_t scan_code;
// bool pressed;
// bool shift;
// bool caps_lock;
// char ascii;
// } keyboard_event_t;
typedef void (*keyboard_handler_t)(const keyboard_event_t*);
// typedef void (*keyboard_handler_t)(const keyboard_event_t*);
void init_keyboard();
void register_keypress_handler(keyboard_handler_t handler);
char scan_code_to_ascii(uint8_t scan_code);
// void init_keyboard();
// void register_keypress_handler(keyboard_handler_t handler);
// char scan_code_to_ascii(uint8_t scan_code);

44
src/arch/x86_64/mmap.c Normal file
View File

@@ -0,0 +1,44 @@
#include "mmap.h"
#include "../mmap.h"
#include <stddef.h>
#include <stdio.h>
#define USABLE_REGION_SIZE 32
memory_map_t memory_map;
static memory_region_t usable_regions[USABLE_REGION_SIZE];
void map_memory(multiboot_info_t* mbd)
{
if (!(mbd->flags & (1 << 6)))
{
printf("Invalid memory map given by bootloader\n");
panic();
}
size_t num_regions = 0;
uint64_t offset = 0;
while (offset < mbd->mmap_length)
{
multiboot_memory_map_t* mmmt = (multiboot_memory_map_t*)(mbd->mmap_addr + offset);
if (mmmt->type == MULTIBOOT_MEMORY_AVAILABLE && num_regions < USABLE_REGION_SIZE)
{
usable_regions[num_regions] = (memory_region_t){
.base_address = mmmt->addr,
.length = mmmt->len,
};
num_regions++;
}
offset += mmmt->size + sizeof(mmmt->size);
}
memory_map = (memory_map_t){
.num_regions = num_regions,
.regions = usable_regions,
};
}

6
src/arch/x86_64/mmap.h Normal file
View File

@@ -0,0 +1,6 @@
#pragma once
#include "../arch.h"
#include "multiboot.h"
void map_memory(multiboot_info_t* mbd);

124
src/arch/x86_64/pmm.c
View File

@@ -1,124 +0,0 @@
#include "pmm.h"
#include "../../kernel.h"
#include "../../mem.h"
#include <stdbool.h>
#include <stddef.h>
#define BITMAP_SIZE 32768 // Supports up to 1GB of RAM
#define USABLE_REGION_SIZE 32
typedef struct
{
uint64_t base_address;
uint64_t length;
} memory_region_t;
static uint8_t page_bitmap[BITMAP_SIZE];
static uint64_t total_pages = 0;
static uint64_t free_pages = 0;
void init_pmm(multiboot_info_t* mbd)
{
memory_region_t usable_regions[USABLE_REGION_SIZE];
size_t num_regions = 0;
if (!(mbd->flags & (1 << 6)))
{
printf("Invalid memory map given by bootloader\n");
panic();
}
uint64_t offset = 0;
while (offset < mbd->mmap_length)
{
multiboot_memory_map_t* mmmt = (multiboot_memory_map_t*)(mbd->mmap_addr + offset);
if (mmmt->type == MULTIBOOT_MEMORY_AVAILABLE && num_regions < USABLE_REGION_SIZE)
{
usable_regions[num_regions] = (memory_region_t){
.base_address = mmmt->addr,
.length = mmmt->len,
};
num_regions++;
printf("Available memory: 0x%x - 0x%x (%u KB)\n", mmmt->addr, mmmt->addr + mmmt->len, mmmt->len / 1024);
}
offset += mmmt->size + sizeof(mmmt->size);
}
memset(page_bitmap, 0xFF, BITMAP_SIZE);
for (size_t i = 0; i < num_regions; i++)
{
memory_region_t region = usable_regions[i];
uint64_t start_page = region.base_address / PAGE_SIZE;
uint64_t num_pages = region.length / PAGE_SIZE;
for (uint64_t page = start_page; page < start_page + num_pages; page++)
{
if (page < BITMAP_SIZE * 8)
{
page_bitmap[page / 8] &= ~(1 << (page % 8));
free_pages++;
total_pages++;
}
else
{
printf("System has more ram than the bitmap allows!\n");
break;
}
}
}
// Reserve first 64MB which is reserved by boot code
for (uint64_t page = 0; page < (64 * 1024 * 1024) / PAGE_SIZE; page++)
{
if (page < BITMAP_SIZE * 8)
{
if (!(page_bitmap[page / 8] & (1 << (page % 8))))
{
page_bitmap[page / 8] |= (1 << (page % 8));
free_pages--;
}
}
}
printf("PMM initialized\n");
}
uint64_t pmm_alloc_page()
{
for (size_t i = 0; i < BITMAP_SIZE; i++)
{
if (page_bitmap[i] != 0xFF)
{
for (int bit = 0; bit < 8; bit++)
{
if (!(page_bitmap[i] & (1 << bit)))
{
page_bitmap[i] |= (1 << bit);
free_pages--;
return ((i * 8 + bit) * PAGE_SIZE);
}
}
}
}
return 0;
}
void pmm_free_page(uint64_t addr)
{
uint64_t page = addr / PAGE_SIZE;
if (page < BITMAP_SIZE * 8)
{
if (page_bitmap[page / 8] & (1 << (page % 8)))
{
page_bitmap[page / 8] &= ~(1 << (page % 8));
free_pages++;
}
}
}

10
src/arch/x86_64/pmm.h
View File

@@ -1,10 +0,0 @@
#pragma once
#include "multiboot.h"
#include <stdint.h>
#define PAGE_SIZE 4096
void init_pmm(multiboot_info_t* mbd);
uint64_t pmm_alloc_page();
void pmm_free_page(uint64_t addr);

4
src/arch/x86_64/start.asm
View File

@@ -1,5 +1,5 @@
global _start
extern kmain
extern entry
extern handle_isr
extern pml4
@@ -205,7 +205,7 @@ section .text
; Finally, we call in to c
mov rdi, [multiboot_info]
call kmain
call entry
.hang:
hlt
jmp .hang

113
src/arch/x86_64/util.h Normal file
View File

@@ -0,0 +1,113 @@
#pragma once
#include <stdint.h>
enum
{
CPUID_FEAT_ECX_SSE3 = 1 << 0,
CPUID_FEAT_ECX_PCLMUL = 1 << 1,
CPUID_FEAT_ECX_DTES64 = 1 << 2,
CPUID_FEAT_ECX_MONITOR = 1 << 3,
CPUID_FEAT_ECX_DS_CPL = 1 << 4,
CPUID_FEAT_ECX_VMX = 1 << 5,
CPUID_FEAT_ECX_SMX = 1 << 6,
CPUID_FEAT_ECX_EST = 1 << 7,
CPUID_FEAT_ECX_TM2 = 1 << 8,
CPUID_FEAT_ECX_SSSE3 = 1 << 9,
CPUID_FEAT_ECX_CID = 1 << 10,
CPUID_FEAT_ECX_SDBG = 1 << 11,
CPUID_FEAT_ECX_FMA = 1 << 12,
CPUID_FEAT_ECX_CX16 = 1 << 13,
CPUID_FEAT_ECX_XTPR = 1 << 14,
CPUID_FEAT_ECX_PDCM = 1 << 15,
CPUID_FEAT_ECX_PCID = 1 << 17,
CPUID_FEAT_ECX_DCA = 1 << 18,
CPUID_FEAT_ECX_SSE4_1 = 1 << 19,
CPUID_FEAT_ECX_SSE4_2 = 1 << 20,
CPUID_FEAT_ECX_X2APIC = 1 << 21,
CPUID_FEAT_ECX_MOVBE = 1 << 22,
CPUID_FEAT_ECX_POPCNT = 1 << 23,
CPUID_FEAT_ECX_TSC = 1 << 24,
CPUID_FEAT_ECX_AES = 1 << 25,
CPUID_FEAT_ECX_XSAVE = 1 << 26,
CPUID_FEAT_ECX_OSXSAVE = 1 << 27,
CPUID_FEAT_ECX_AVX = 1 << 28,
CPUID_FEAT_ECX_F16C = 1 << 29,
CPUID_FEAT_ECX_RDRAND = 1 << 30,
CPUID_FEAT_ECX_HYPERVISOR = 1 << 31,
CPUID_FEAT_EDX_FPU = 1 << 0,
CPUID_FEAT_EDX_VME = 1 << 1,
CPUID_FEAT_EDX_DE = 1 << 2,
CPUID_FEAT_EDX_PSE = 1 << 3,
CPUID_FEAT_EDX_TSC = 1 << 4,
CPUID_FEAT_EDX_MSR = 1 << 5,
CPUID_FEAT_EDX_PAE = 1 << 6,
CPUID_FEAT_EDX_MCE = 1 << 7,
CPUID_FEAT_EDX_CX8 = 1 << 8,
CPUID_FEAT_EDX_APIC = 1 << 9,
CPUID_FEAT_EDX_SEP = 1 << 11,
CPUID_FEAT_EDX_MTRR = 1 << 12,
CPUID_FEAT_EDX_PGE = 1 << 13,
CPUID_FEAT_EDX_MCA = 1 << 14,
CPUID_FEAT_EDX_CMOV = 1 << 15,
CPUID_FEAT_EDX_PAT = 1 << 16,
CPUID_FEAT_EDX_PSE36 = 1 << 17,
CPUID_FEAT_EDX_PSN = 1 << 18,
CPUID_FEAT_EDX_CLFLUSH = 1 << 19,
CPUID_FEAT_EDX_DS = 1 << 21,
CPUID_FEAT_EDX_ACPI = 1 << 22,
CPUID_FEAT_EDX_MMX = 1 << 23,
CPUID_FEAT_EDX_FXSR = 1 << 24,
CPUID_FEAT_EDX_SSE = 1 << 25,
CPUID_FEAT_EDX_SSE2 = 1 << 26,
CPUID_FEAT_EDX_SS = 1 << 27,
CPUID_FEAT_EDX_HTT = 1 << 28,
CPUID_FEAT_EDX_TM = 1 << 29,
CPUID_FEAT_EDX_IA64 = 1 << 30,
CPUID_FEAT_EDX_PBE = 1 << 31
};
static inline void outb(uint16_t port, uint8_t val)
{
__asm__ volatile("outb %0, %1" : : "a"(val), "Nd"(port));
}
static inline uint8_t inb(uint16_t port)
{
uint8_t ret;
__asm__ volatile("inb %1, %0" : "=a"(ret) : "Nd"(port));
return ret;
}
static inline void io_wait()
{
outb(0x80, 0);
}
static inline void cpuid(uint32_t code, uint32_t* a, uint32_t* d)
{
__asm__ volatile("cpuid" : "=a"(*a), "=d"(*d) : "a"(code) : "ecx", "ebx");
}
static inline uint64_t rdmsr(uint32_t msr)
{
uint32_t lo, hi;
__asm__ volatile("rdmsr" : "=a"(lo), "=d"(hi) : "c"(msr));
return ((uint64_t)hi << 32) | lo;
}
static inline void wrmsr(uint32_t msr, uint64_t value)
{
uint32_t lo = (uint32_t)value;
uint32_t hi = (uint32_t)(value >> 32);
__asm__ volatile("wrmsr" : : "c"(msr), "a"(lo), "d"(hi));
}
static inline void halt()
{
while (true)
{
__asm__ volatile("hlt");
}
}

120
src/arch/x86_64/vga.c Normal file
View File

@@ -0,0 +1,120 @@
#include "vga.h"
#include <stddef.h>
#define ROWS 25
#define COLUMNS 80
typedef struct
{
uint8_t character;
uint8_t color;
} vga_char_t;
static vga_char_t* vga_buffer = (vga_char_t*)0xb8000;
static uint8_t cursor_row = 0;
static uint8_t cursor_col = 0;
void vga_put_char(char character, uint8_t color)
{
switch (character)
{
case '\n':
{
cursor_row += 1;
cursor_col = 0;
break;
}
case '\r':
{
cursor_col = 0;
break;
}
case '\t':
{
uint8_t remainder = 4 - (cursor_col % 4);
cursor_col += remainder;
break;
}
case '\b':
{
if (cursor_col > 0)
{
cursor_col -= 1;
}
else if (cursor_row > 0)
{
cursor_row -= 1;
cursor_col = 0;
for (int col = COLUMNS - 1; col >= 0; col--)
{
vga_char_t cell = vga_buffer[cursor_row * COLUMNS + col];
if (cell.character != ' ')
{
cursor_col = col;
break;
}
}
}
vga_buffer[cursor_row * COLUMNS + cursor_col] = (vga_char_t){
.character = ' ',
.color = VGA_DEFAULT_COLOR,
};
break;
}
default:
{
vga_buffer[COLUMNS * cursor_row + cursor_col] = (vga_char_t){
.character = character,
.color = color,
};
cursor_col += 1;
break;
}
}
if (cursor_col >= COLUMNS)
{
cursor_col = 0;
cursor_row += 1;
}
if (cursor_row >= ROWS)
{
for (size_t row = 1; row < ROWS; row++)
{
for (size_t col = 0; col < COLUMNS; col++)
{
vga_buffer[COLUMNS * (row - 1) + col] = vga_buffer[COLUMNS * row + col];
}
}
for (size_t col = 0; col < COLUMNS; col++)
{
vga_buffer[COLUMNS * (ROWS - 1) + col] = (vga_char_t){
.character = ' ',
.color = VGA_DEFAULT_COLOR,
};
};
cursor_row = ROWS - 1;
}
}
void vga_clear()
{
for (size_t row = 0; row < ROWS; row++)
{
for (size_t col = 0; col < COLUMNS; col++)
{
vga_buffer[COLUMNS * row + col] = (vga_char_t){
.character = ' ',
.color = VGA_DEFAULT_COLOR,
};
}
}
cursor_row = 0;
cursor_col = 0;
}

25
src/arch/x86_64/vga.h Normal file
View File

@@ -0,0 +1,25 @@
#pragma once
#include <stdint.h>
#define VGA_BLACK 0
#define VGA_BLUE 1
#define VGA_GREEN 2
#define VGA_CYAN 3
#define VGA_RED 4
#define VGA_MAGENTA 5
#define VGA_BROWN 6
#define VGA_LIGHT_GRAY 7
#define VGA_DARK_GRAY 8
#define VGA_LIGHT_BLUE 9
#define VGA_LIGHT_GREEN 10
#define VGA_LIGHT_CYAN 11
#define VGA_LIGHT_RED 12
#define VGA_LIGHT_MAGENTA 13
#define VGA_YELLOW 14
#define VGA_WHITE 15
#define VGA_DEFAULT_COLOR VGA_LIGHT_GRAY | VGA_BLACK << 4
void vga_put_char(char character, uint8_t color);
void vga_clear();

37
src/arch/x86_64/x86_64.c Normal file
View File

@@ -0,0 +1,37 @@
#include "../../kernel.h"
#include "../arch.h"
#include "interrupts.h"
#include "mmap.h"
#include "multiboot.h"
#include "util.h"
#include "vga.h"
#include <stddef.h>
#include <stdio.h>
void entry(multiboot_info_t* mbd)
{
vga_clear();
map_memory(mbd);
remap_pic();
enable_interrupts();
kmain();
}
void arch_callback()
{
printf("Kernel panic!\n");
disable_interrupts();
halt();
}
void panic()
{
printf("Kernel panic!");
disable_interrupts();
halt();
}
void put_char(char character)
{
vga_put_char(character, VGA_DEFAULT_COLOR);
}