PoliEcho/kern
1
0
Fork 0
forked from PoliEcho-holding-org/kern
Code Pull Requests Activity

The great 64-bit rewrite

Browse Source 
* We did loose tasking and only have a paging skeleton, but hey it took like 4 months so i'm happy that there's something :p
This commit is contained in:
Tom-on
2026-02-08 13:04:39 +01:00
parent d9471572b8
commit 50a1d6198e
42 changed files with 2206 additions and 1786 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kernel/src/bootloader.c
+35 -72
View File
@@ -1,86 +1,49 @@
#include <bootloader.h>
#include <multiboot.h>
#include <kernel.h>
#include <string.h>
#include <limine.h>
struct boot_memmap memmap[BOOT_MAX_MMAP_ENTRIES];
struct boot_info bootloader;
struct bootloader bootloader = { 0 };
// TODO:
int boot_init(int type, ...) {
va_list va;
va_start(va, type);
static struct limine_paging_mode_request lim_paging_req = {
.id = LIMINE_PAGING_MODE_REQUEST,
.revision = 4,
.mode = LIMINE_PAGING_MODE_X86_64_4LVL,
};
void* ptr = va_arg(va, void*);
uint32_t magic = va_arg(va, uint32_t);
static struct limine_kernel_address_request lim_kaddr_req =
{ .id = LIMINE_KERNEL_ADDRESS_REQUEST, .revision = 4 };
switch (type) {
case BOOT_MB1: return boot_init_mb1(ptr, magic);
}
return 1;
}
static struct limine_hhdm_request lim_hhdm_req =
{ .id = LIMINE_HHDM_REQUEST, .revision = 4 };
int boot_init_mb1(void* ptr, uint32_t magic) {
multiboot_info_t* mbi = ptr;
static struct limine_memmap_request lim_memmap_req =
{ .id = LIMINE_MEMMAP_REQUEST, .revision = 4 };
if (magic != MULTIBOOT_BOOTLOADER_MAGIC) return 1;
static struct limine_framebuffer_request lim_fbuf_req =
{ .id = LIMINE_FRAMEBUFFER_REQUEST, .revision = 0 };
// mem_* fields are valid
if (mbi->flags & MULTIBOOT_INFO_MEMORY) {
bootloader.mem_lower = mbi->mem_lower;
bootloader.mem_upper = mbi->mem_upper;
int boot_init(void) {
struct limine_paging_mode_response* lim_paging_res = lim_paging_req.response;
struct limine_kernel_address_response* lim_kaddr_res = lim_kaddr_req.response;
struct limine_hhdm_response* lim_hhdm_res = lim_hhdm_req.response;
struct limine_memmap_response* lim_memmap_res = lim_memmap_req.response;
struct limine_framebuffer_response* lim_fbuf_res = lim_fbuf_req.response;
if (lim_paging_res->mode != LIMINE_PAGING_MODE_X86_64_4LVL) return 1;
bootloader.hhdm_offset = lim_hhdm_res->offset;
bootloader.kernel_phys_base = lim_kaddr_res->physical_base;
bootloader.kernel_virt_base = lim_kaddr_res->virtual_base;
bootloader.mm_entries = lim_memmap_res->entries;
bootloader.mm_entry_count = lim_memmap_res->entry_count;
bootloader.mm_total = 0;
for (size_t i = 0; i < bootloader.mm_entry_count; i++) {
struct limine_memmap_entry* entry = bootloader.mm_entries[i];
if (entry->type != LIMINE_MEMMAP_USABLE) bootloader.mm_total += entry->length;
}
// boot_device is valid
if (mbi->flags & MULTIBOOT_INFO_BOOTDEV) {
bootloader.boot_drive = (mbi->boot_device & 0xff000000) >> 24;
bootloader.boot_part1 = (mbi->boot_device & 0x00ff0000) >> 16;
bootloader.boot_part2 = (mbi->boot_device & 0x0000ff00) >> 8;
bootloader.boot_part3 = (mbi->boot_device & 0x000000ff);
}
// cmdline is valid
if (mbi->flags & MULTIBOOT_INFO_CMDLINE) {
bootloader.cmdline = (char*)mbi->cmdline;
}
// TODO: mods
// TODO: a.out symbol table
// TODO: ELF symbol table
// mmap_* fields are valid
if (mbi->flags & MULTIBOOT_INFO_MEM_MAP) {
bootloader.memmap = &memmap[0];
size_t i = 0;
multiboot_memory_map_t* entry = (multiboot_memory_map_t*)mbi->mmap_addr;
uint32_t limit = mbi->mmap_addr + mbi->mmap_length;
while ((uint32_t)entry < limit) {
bootloader.memmap[i].base = entry->addr;
bootloader.memmap[i].size = entry->len;
bootloader.memmap[i].type = (uint8_t)entry->type;
entry++;
i++;
}
bootloader.memmap_size = i;
}
// TODO: drives_*
// TODO: config_table
// boot_loader_name is valid
if (mbi->flags & MULTIBOOT_INFO_BOOT_LOADER_NAME) {
bootloader.bootname = (char*)mbi->boot_loader_name;
}
// TODO: APM table
// TODO: VBE table
// TODO: Framebuffer
debugf("[boot] Initiated with MultiBoot 1\n");
bootloader.fb_entries = lim_fbuf_res->framebuffers;
bootloader.fb_entry_count = lim_fbuf_res->framebuffer_count;
return 0;
}
kernel/src/entry.s
-73
View File
@@ -1,73 +0,0 @@
bits 32
; Flag bits
%define ALIGN 1<<0
%define MEMINFO 1<<1
; Field values
%define MAGIC 0x1BADB002
%define FLAGS (ALIGN | MEMINFO)
%define CHECK -(MAGIC + FLAGS)
; Multiboot 1 header
section .multiboot
align 4
multiboot:
dd MAGIC
dd FLAGS
dd CHECK
; Initialize stack
section .bss
align 16
global __kernel_stack_top
global __kernel_stack_bottom
__kernel_stack_bottom:
resb 16384
__kernel_stack_top:
; Entry point
section .boot
global _start
_start:
; init temporary paging
mov ecx, (init_pagedir - 0xC0000000)
mov cr3, ecx
mov ecx, cr4
or ecx, 0x10
mov cr4, ecx
mov ecx, cr0
or ecx, 0x80000000
mov cr0, ecx
jmp higher_half
section .text
extern kmain
higher_half:
mov esp, __kernel_stack_top
add ebx, 0xC0000000 ; Make it a virtual address
push eax ; Magic
push ebx ; Multiboot info
call kmain ; Call kernel main
; Hang if kernel returns
cli
.hlt: hlt
jmp .hlt
section .data
align 4096
global init_pagedir
init_pagedir:
dd 0b10000011 ; Identity map first 4MB
times 768-1 dd 0
; Map first 16MB of kernel to 0xC0000000
dd (0 << 22) | 0b10000011
dd (1 << 22) | 0b10000011
dd (2 << 22) | 0b10000011
dd (3 << 22) | 0b10000011
times 256-4 dd 0
kernel/src/gdt.c
+85 -33
View File
@@ -2,54 +2,106 @@
#include <string.h>
#include <gdt.h>
static struct gdt_entry gdt[GDT_ENTRIES];
static struct gdt_entries gdt;
static struct gdt_pointer gdtp;
static struct tss_pointer tss;
void gdt_reload(void) {
__asm__ volatile (
"cli\n"
"lgdt (%0)\n"
"movw $0x10, %%ax\n"
"movw %%ax, %%ds\n"
"movw %%ax, %%es\n"
"movw %%ax, %%fs\n"
"movw %%ax, %%gs\n"
"movw %%ax, %%ss\n"
"ljmp $0x08, $1f\n"
"1:"
:
: "m" (gdtp)
: "memory", "rax"
"lgdt %0\n"
"pushq %[kcs]\n"
"lea 1f(%%rip), %%rax\n"
"pushq %%rax\n"
"lretq\n"
"1:\n"
"mov %[kds], %%ax\n"
"mov %%ax, %%ds\n"
"mov %%ax, %%es\n"
"mov %%ax, %%fs\n"
"mov %%ax, %%gs\n"
"mov %%ax, %%ss\n"
:
: "m"(gdtp),
[kcs] "i"(GDT_KERNEL_CODE),
[kds] "i"(GDT_KERNEL_DATA)
: "rax", "memory"
);
}
void tss_reload(void) {
__asm__ volatile ("ltr %0" : : "rm"(GDT_TSS));
void tss_load(struct tss_pointer* tss) {
size_t addr = (size_t)tss;
gdt.tss.length = 104;
gdt.tss.base_low = (uint16_t)addr;
gdt.tss.base_mid = (uint8_t)(addr >> 16);
gdt.tss.access = 0x89;
gdt.tss.flags = 0;
gdt.tss.base_high = (uint8_t)(addr >> 24);
gdt.tss.base_upper32 = (uint32_t)(addr >> 32);
gdt.tss.__reserved = 0;
__asm__ volatile ("ltr %0" : : "rm"(GDT_TSS) : "memory");
}
void tss_esp0(uint32_t esp0) { tss.esp0 = esp0; }
int gdt_init(void) {
// Null descriptor
gdt.entries[0].limit = 0;
gdt.entries[0].base_low = 0;
gdt.entries[0].base_mid = 0;
gdt.entries[0].access = 0;
gdt.entries[0].flags = 0;
gdt.entries[0].base_high = 0;
// Kernel code
gdt.entries[1].limit = 0xFFFF;
gdt.entries[1].base_low = 0;
gdt.entries[1].base_mid = 0;
gdt.entries[1].access = 0x9A;
gdt.entries[1].flags = 0xAF;
gdt.entries[1].base_high = 0;
// Kernel data
gdt.entries[2].limit = 0xFFFF;
gdt.entries[2].base_low = 0;
gdt.entries[2].base_mid = 0;
gdt.entries[2].access = 0x92;
gdt.entries[2].flags = 0xCF;
gdt.entries[2].base_high = 0;
// User data
gdt.entries[3].limit = 0xFFFF;
gdt.entries[3].base_low = 0;
gdt.entries[3].base_mid = 0;
gdt.entries[3].access = 0xF2;
gdt.entries[3].flags = 0xCF;
gdt.entries[3].base_high = 0;
// User code
gdt.entries[4].limit = 0xFFFF;
gdt.entries[4].base_low = 0;
gdt.entries[4].base_mid = 0;
gdt.entries[4].access = 0xFA;
gdt.entries[4].flags = 0xAF;
gdt.entries[4].base_high = 0;
// Task State Segment (TSS)
gdt.tss.length = 104;
gdt.tss.base_low = 0;
gdt.tss.base_mid = 0;
gdt.tss.access = 0x89; //0b10001001;
gdt.tss.flags = 0;
gdt.tss.base_high = 0;
gdt.tss.base_upper32 = 0;
gdt.tss.__reserved = 0;
// GDT Pointer
gdtp.limit = sizeof(gdt) - 1;
gdtp.base = (uint32_t)&gdt;
// Setup TSS
memset(&tss, 0, sizeof(tss));
tss.ss0 = GDT_KERNEL_DATA;
tss.iopb = sizeof(struct tss_pointer);
// Load descriptors
gdt[0] = GDT_DESC(0, 0, 0, 0); // Null descriptor
gdt[1] = GDT_DESC(0xFFFFFFFF, 0, 0x9A, 0xC0); // Kernel code
gdt[2] = GDT_DESC(0xFFFFFFFF, 0, 0x92, 0xC0); // Kernel data
gdt[3] = GDT_DESC(0xFFFFFFFF, 0, 0xFA, 0xC0); // User code
gdt[4] = GDT_DESC(0xFFFFFFFF, 0, 0xF2, 0xC0); // User data
gdt[5] = GDT_DESC(sizeof(tss) - 1, (uint32_t)&tss, 0x89, 0);
gdtp.base = (uint64_t)&gdt;
gdt_reload();
tss_reload();
memset(&tss, 0, sizeof(tss));
tss_load(&tss);
debugf("[gdt] GDT loaded.\n");
kernel/src/idt.c
+12 -12
View File
@@ -3,24 +3,24 @@
#include <gdt.h>
#include <idt.h>
__align(16) // performace :fire:
__align(16) // performace
static struct idt_entry idt[IDT_ENTRIES];
static struct idt_pointer idtp;
void idt_set_gate(uint8_t i, void* handler, uint8_t flags) {
uint32_t offset = (uint32_t)handler;
struct idt_entry* entry = &idt[i];
entry->offset_low = (uint16_t)offset;
entry->selector = GDT_KERNEL_CODE;
entry->flags = flags;
entry->offset_high = (uint16_t)(offset >> 16);
void idt_set_gate(uint8_t i, void* handler, uint8_t attrib) {
size_t addr = (size_t)handler;
idt[i].offset_low = (uint16_t)addr;
idt[i].selector = GDT_KERNEL_CODE;
idt[i].ist = 0;
idt[i].__reserved = 0;
idt[i].attrib = attrib;
idt[i].offset_mid = (uint16_t)(addr >> 16);
idt[i].offset_high = (uint32_t)(addr >> 32);
}
int idt_init(void) {
memset(&idt, 0, sizeof(idt));
idtp.limit = sizeof(idt);
idtp.base = (uint32_t)&idt;
idtp.size = sizeof(idt) - 1;
idtp.offset = (size_t)&idt;
// Load IDT instruction
__asm__ volatile ("lidt %0" : : "m"(idtp));
kernel/src/ipc.c
-16
View File
@@ -1,16 +0,0 @@
#include <kernel.h>
#include <ipc.h>
int ipc_send(pid_t dst, ipc_msg_t* msg) {
(void)dst;
(void)msg;
return 0;
}
int ipc_recv(pid_t src, ipc_msg_t* msg) {
(void)src;
(void)msg;
return 0;
}
kernel/src/isr.c
+42 -31
View File
@@ -1,10 +1,11 @@
#include <syscall.h>
#include <kernel.h>
#include <serial.h>
#include <string.h>
#include <system.h>
#include <idt.h>
#include <isr.h>
isr_handler_ptr irq_handlers[16];
isr_handler_ptr irq_handlers[ISR_COUNT];
const char* exceptions[] = {
"Division By Zero",
@@ -26,9 +27,9 @@ const char* exceptions[] = {
"Coprocessor Fault",
"Alignment Check",
"Machine Check",
"Reserved",
"Reserved",
"Reserved",
"SIMD Floating-Point",
"Virtualization",
"Control Protection",
"Reserved",
"Reserved",
"Reserved",
@@ -41,41 +42,50 @@ const char* exceptions[] = {
"Reserved"
};
// I have no clue how this works or what it does, but it doesn't work without it
void isr_remap_pic(void) {
void pic_disable(void) {
outb(0x21, 0xFF); iowait();
outb(0xA1, 0xFF); iowait();
}
void pic_remap(void) {
outb(0x20, 0x11); iowait();
outb(0xa0, 0x11); iowait();
outb(0xA0, 0x11); iowait();
outb(0x21, 0x20); iowait();
outb(0xa1, 0x28); iowait();
outb(0xA1, 0x28); iowait();
outb(0x21, 0x04); iowait();
outb(0xa1, 0x02); iowait();
outb(0xA1, 0x02); iowait();
outb(0x21, 0x01); iowait();
outb(0xa1, 0x01); iowait();
outb(0xA1, 0x01); iowait();
outb(0x21, 0x00); iowait();
outb(0xa1, 0x00); iowait();
outb(0xA1, 0x00); iowait();
// pic_disable(); For APIC
}
int isr_init(void) {
idt_init();
isr_remap_pic();
memset(irq_handlers, 0, sizeof(irq_handlers));
if (idt_init() != 0) {
debugf("[isr] Could not load IDT.");
return 1;
}
for (int i = 0; i < 48; i++) {
// First 32 IRSs are exceptions (traps) and the next 16 are hardware interrupts
idt_set_gate(i, isr_redirect_table[i], (i < 32) ? IDT_FLAG_TRAP : IDT_FLAG_INT);
idt_set_gate(i, isr_redirect_table[i], IDT_FLAG_INT);
}
idt_set_gate(0x03, isr_redirect_table[3], IDT_FLAG_USER); // Allow breakpoints
idt_set_gate(0x80, isr128, IDT_FLAG_USER); // Syscall
//
pic_remap();
// TODO: apic_init();
// System call (should be callable from userspace)
idt_set_gate(0x80, (void*)(uint32_t)isr128, IDT_FLAG_USER);
// Let interrupts interrupt
sti();
debugf("[isr] ISR initialized.\n");
return 0;
}
void isr_register(uint8_t i, isr_handler_ptr handler) {
if (i > 16) return; // Security
if (i >= ISR_COUNT) return; // secutiry B)
irq_handlers[i] = handler;
}
@@ -85,19 +95,20 @@ void isr_send_eoi(uint8_t irq) {
}
// TODO: Write fault handlers and make this more robust
void isr_handle_interrupt(struct isr_int_frame iframe) {
if (iframe.interrupt < 32) {
// ISRs 0-31 - Exceptions
if (iframe.error) debugf("[kernel] Error code: 0x%08x\n", iframe.error);
panic(exceptions[iframe.interrupt]);
} else if (iframe.interrupt >= 32 && iframe.interrupt < 48) {
void isr_handle_interrupt(size_t rsp) {
struct isr_int_frame* iframe = (void*)rsp;
if (iframe->interrupt < 32) {
if (iframe->error) debugf("[kernel] Error code: 0x%08x\n", iframe->error);
panic(exceptions[iframe->interrupt]);
} else if (iframe->interrupt >= 32 && iframe->interrupt < 48) {
// ISRs 32-47 - Hardware interrupts
uint8_t irq = iframe.interrupt - 32;
uint8_t irq = iframe->interrupt - 32;
isr_send_eoi(irq);
if (irq_handlers[irq]) irq_handlers[irq](&iframe);
} else if (iframe.interrupt == 128) {
if (irq_handlers[irq]) irq_handlers[irq](iframe);
} else if (iframe->interrupt == 128) {
// ISR 128 - System call
syscall_handler(&iframe);
debugf("SYSCALL!\n");
}
}
kernel/src/isr.s
+102 -96
View File
@@ -1,123 +1,129 @@
; ISR Assembly
[bits 32]
[bits 64]
[section .text]
isr_common:
;; Push registers to the int_frame_t struct
pushad
;; push eax
;; push ecx
;; push edx
;; push ebx
;; push esp
;; push ebp
;; push esi
;; push edi
push ds
push es
push fs
push gs
push rax
push rbx
push rcx
push rdx
push rsi
push rdi
push rbp
push r8
push r9
push r10
push r11
push r12
push r13
push r14
push r15
mov rbp, ds
push rbp
mov rdi, rsp
;; Load kernel data segment
push ebx
mov bx, 0x10
mov ds, bx
mov es, bx
mov fs, bx
mov gs, bx
pop ebx
[extern isr_handle_interrupt]
call isr_handle_interrupt
[global isr_return]
isr_return: ; Also used by a newly created task
pop gs
pop fs
pop es
pop ds
popad
add esp, 8 ; Pop interupt number and error code
iret ; Pop CS, EIP & EFLAGS (Also SS & ESP if it's from userspace)
isr_return:
pop rbp
pop r15
pop r14
pop r13
pop r12
pop r11
pop r10
pop r9
pop r8
pop rbp
pop rdi
pop rsi
pop rdx
pop rcx
pop rbx
pop rax
add rsp, 16 ; Pop errno and int number
iretq
%macro ISR_WITH_ERRNO 1
[global isr%1]
isr%1:
push dword %1
push %1
jmp isr_common
%endmacro
%macro ISR_WITHOUT_ERRNO 1
[global isr%1]
isr%1:
push dword 0 ; Instead of error code
push dword %1
push 0
push %1
jmp isr_common
%endmacro
;; Exceptions
ISR_WITHOUT_ERRNO 0
ISR_WITHOUT_ERRNO 1
ISR_WITHOUT_ERRNO 2
ISR_WITHOUT_ERRNO 3
ISR_WITHOUT_ERRNO 4
ISR_WITHOUT_ERRNO 5
ISR_WITHOUT_ERRNO 6
ISR_WITHOUT_ERRNO 7
ISR_WITH_ERRNO 8
ISR_WITHOUT_ERRNO 9
ISR_WITH_ERRNO 10
ISR_WITH_ERRNO 11
ISR_WITH_ERRNO 12
ISR_WITH_ERRNO 13
ISR_WITH_ERRNO 14
ISR_WITHOUT_ERRNO 15
ISR_WITHOUT_ERRNO 16
ISR_WITHOUT_ERRNO 17
ISR_WITHOUT_ERRNO 18
ISR_WITHOUT_ERRNO 19
ISR_WITHOUT_ERRNO 20
ISR_WITHOUT_ERRNO 21
ISR_WITHOUT_ERRNO 22
ISR_WITHOUT_ERRNO 23
ISR_WITHOUT_ERRNO 24
ISR_WITHOUT_ERRNO 25
ISR_WITHOUT_ERRNO 26
ISR_WITHOUT_ERRNO 27
ISR_WITHOUT_ERRNO 28
ISR_WITHOUT_ERRNO 29
ISR_WITHOUT_ERRNO 30
ISR_WITHOUT_ERRNO 31
ISR_WITHOUT_ERRNO 0
ISR_WITHOUT_ERRNO 1
ISR_WITHOUT_ERRNO 2
ISR_WITHOUT_ERRNO 3
ISR_WITHOUT_ERRNO 4
ISR_WITHOUT_ERRNO 5
ISR_WITHOUT_ERRNO 6
ISR_WITHOUT_ERRNO 7
ISR_WITH_ERRNO 8
ISR_WITHOUT_ERRNO 9
ISR_WITH_ERRNO 10
ISR_WITH_ERRNO 11
ISR_WITH_ERRNO 12
ISR_WITH_ERRNO 13
ISR_WITH_ERRNO 14
ISR_WITHOUT_ERRNO 15
ISR_WITHOUT_ERRNO 16
ISR_WITHOUT_ERRNO 17
ISR_WITHOUT_ERRNO 18
ISR_WITHOUT_ERRNO 19
ISR_WITHOUT_ERRNO 20
ISR_WITHOUT_ERRNO 21
ISR_WITHOUT_ERRNO 22
ISR_WITHOUT_ERRNO 23
ISR_WITHOUT_ERRNO 24
ISR_WITHOUT_ERRNO 25
ISR_WITHOUT_ERRNO 26
ISR_WITHOUT_ERRNO 27
ISR_WITHOUT_ERRNO 28
ISR_WITHOUT_ERRNO 29
ISR_WITHOUT_ERRNO 30
ISR_WITHOUT_ERRNO 31
;; IRQs 0-15 (mapped 32-47)
ISR_WITHOUT_ERRNO 32
ISR_WITHOUT_ERRNO 33
ISR_WITHOUT_ERRNO 34
ISR_WITHOUT_ERRNO 35
ISR_WITHOUT_ERRNO 36
ISR_WITHOUT_ERRNO 37
ISR_WITHOUT_ERRNO 38
ISR_WITHOUT_ERRNO 39
ISR_WITHOUT_ERRNO 40
ISR_WITHOUT_ERRNO 41
ISR_WITHOUT_ERRNO 42
ISR_WITHOUT_ERRNO 43
ISR_WITHOUT_ERRNO 44
ISR_WITHOUT_ERRNO 45
ISR_WITHOUT_ERRNO 46
ISR_WITHOUT_ERRNO 47
;; IRQs
ISR_WITHOUT_ERRNO 32
ISR_WITHOUT_ERRNO 33
ISR_WITHOUT_ERRNO 34
ISR_WITHOUT_ERRNO 35
ISR_WITHOUT_ERRNO 36
ISR_WITHOUT_ERRNO 37
ISR_WITHOUT_ERRNO 38
ISR_WITHOUT_ERRNO 39
ISR_WITHOUT_ERRNO 40
ISR_WITHOUT_ERRNO 41
ISR_WITHOUT_ERRNO 42
ISR_WITHOUT_ERRNO 43
ISR_WITHOUT_ERRNO 44
ISR_WITHOUT_ERRNO 45
ISR_WITHOUT_ERRNO 46
ISR_WITHOUT_ERRNO 47
;; Syscall ISR128
[global isr128]
isr128:
cli ; Prevent race condition & other issues
push dword 0
push dword 128
jmp isr_common
; Syscall
ISR_WITHOUT_ERRNO 128
ISR_WITHOUT_ERRNO 255
;; Create table of ISRs
[section .data]
[global isr_redirect_table]
isr_redirect_table:
%assign i 0
%rep 48
dd isr%+i
dq isr%+i
%assign i i+1
%endrep
kernel/src/kernel.c
+17 -15
View File
@@ -1,23 +1,29 @@
#include <bootloader.h>
#include <kmalloc.h>
#include <syscall.h>
#include <kernel.h>
#include <limine.h>
#include <paging.h>
#include <serial.h>
#include <splash.h>
#include <timer.h>
#include <task.h>
#include <gdt.h>
#include <idt.h>
#include <isr.h>
#include <pmm.h>
#include <tty.h>
static volatile LIMINE_BASE_REVISION(4);
__noreturn
void kmain(void* ptr, uint32_t magic) {
void _start(void) {
// Serial console for debugging
if (serial_init(COM1) != 0) panic("Failed to initialize Serial driver.");
if (LIMINE_BASE_REVISION_SUPPORTED == false) panic("Unsuported Limine version.");
// Load structures from bootloader
if (boot_init_mb1(ptr, magic) != 0) panic("Unsupported bootloader.");
if (boot_init() != 0) panic("Failed to parse bootloader structures.");
// The most important function in the world.
splash();
// System init
if (gdt_init() != 0) panic("Failed to initalize GDT.");
@@ -25,16 +31,12 @@ void kmain(void* ptr, uint32_t magic) {
if (pag_init() != 0) panic("Failed to initalize Paging.");
// Memory manager init
if (pmm_init() != 0) panic("Failed to initalize Physical Memory Manager.");
if (kmalloc_init() != 0) panic("Failed to initialize kernel heap.");
//if (pmm_init() != 0) panic("Failed to initalize Physical Memory Manager.");
//if (kmalloc_init() != 0) panic("Failed to initialize kernel heap.");
// VGA TTY
if (tty_init() != 0) panic("Failed to initalize TTY driver.");
tty_puts("kern.\n\n");
if (timer_init() != 0) panic("Failed to initialize timer.");
if (syscall_init() != 0) panic("Failed to initialize syscalls.");
if (task_init() != 0) panic("Failed to initialize tasking.");
//if (timer_init() != 0) panic("Failed to initialize timer.");
//if (syscall_init() != 0) panic("Failed to initialize syscalls.");
//if (task_init() != 0) panic("Failed to initialize tasking.");
// TODO: Load & run /sbin/init
kernel/src/kmalloc.c
-162
View File
@@ -1,162 +0,0 @@
#include <kernel.h>
#include <paging.h>
#include <serial.h>
#include <string.h>
#include <pmm.h>
#include <kmalloc.h>
struct kmalloc_node* kmalloc_head = NULL;
size_t kmalloc_pages;
size_t kmalloc_base;
int kmalloc_init(void) {
kmalloc_base = KERNEL_HEAP_BASE;
kmalloc_pages = KMALLOC_MIN_PAGES;
for (size_t i = 0; i < kmalloc_pages; i++) {
uint32_t paddr = (uint32_t)pmm_alloc();
if (paddr == 0) {
kmalloc_pages = i;
break;
}
pag_map(kmalloc_base + i * PAGE_SIZE, paddr, 0);
}
kmalloc_head = (struct kmalloc_node*)kmalloc_base;
if (kmalloc_pages < KMALLOC_MIN_PAGES) return 1;
kmalloc_head->size = (kmalloc_pages * PAGE_SIZE) - sizeof(*kmalloc_head);
kmalloc_head->free = 1;
kmalloc_head->next = NULL;
debugf("[kmalloc] kmalloc() initialized.\n");
return 0;
}
void kmalloc_split(struct kmalloc_node* node, size_t size) {
if (node->size < size + sizeof(struct kmalloc_node)) return;
struct kmalloc_node* remainder =
(struct kmalloc_node*)((uint32_t)node + size + sizeof(struct kmalloc_node));
remainder->size = node->size - size - sizeof(struct kmalloc_node);
remainder->free = 1;
remainder->next = node->next;
node->size = size;
node->free = 0;
node->next = remainder;
}
void kmalloc_merge() {
struct kmalloc_node* current = kmalloc_head;
while (current != NULL && current->next != NULL) {
if (current->free && current->next->free) {
current->size += current->next->size + sizeof(struct kmalloc_node);
current->next = current->next->next;
continue;
}
current = current->next;
}
}
void* kmalloc(size_t size) {
if (size == 0) return NULL; // Why would you...
struct kmalloc_node* current = kmalloc_head;
while ((current->size <= size || !current->free) && current->next != NULL) {
current = current->next;
}
if (current->size == size) current->free = 0;
else if (current->size > size) kmalloc_split(current, size);
else { // Allocate more pages
size_t found_size = current->free ? current->size : 0;
size_t page_count = 1;
found_size += PAGE_SIZE;
while (found_size < size + sizeof(struct kmalloc_node)) {
page_count++;
found_size += PAGE_SIZE;
}
uint32_t vaddr = kmalloc_base + kmalloc_pages * PAGE_SIZE;
for (size_t i = 0; i < page_count; i++) {
// WARN: This could be a memory leak! It doesn't free after allocating :/
uint32_t paddr = (uint32_t)pmm_alloc();
if (paddr == 0) return NULL;
pag_map(vaddr + i * PAGE_SIZE, paddr, 0);
kmalloc_pages++;
}
if (current->free) {
current->size += PAGE_SIZE * page_count;
} else {
current->next = (struct kmalloc_node*)vaddr;
current = current->next;
current->size = PAGE_SIZE * page_count;
current->free = 1;
current->next = NULL;
}
return kmalloc(size);
}
return (void*)current + sizeof(struct kmalloc_node);
}
void* kzalloc(size_t size) {
void* ptr = kmalloc(size);
if (ptr == NULL) return NULL;
memset(ptr, 0, size);
return ptr;
}
void* kcalloc(size_t size, size_t count) {
size_t siz = size * count;
void* ptr = kmalloc(siz);
if (ptr == NULL) return NULL;
memset(ptr, 0, siz);
return ptr;
}
void* krealloc(size_t size, void* ptr) {
void* new = kmalloc(size);
struct kmalloc_node* current = kmalloc_head;
while (current != NULL) {
if ((void*)current + sizeof(struct kmalloc_node) == ptr) break;
current = current->next;
}
// Tried to realloc non-existent buffer
if (current == NULL) return NULL;
if (size > current->size) size = current->size;
memcpy(ptr, new, size);
kfree(ptr);
return new;
}
void kfree(void* ptr) {
struct kmalloc_node* current = kmalloc_head;
while (current != NULL) {
if ((void*)current + sizeof(struct kmalloc_node) == ptr) {
current->free = 1;
kmalloc_merge();
break;
}
current = current->next;
}
}
kernel/src/paging.c
+20 -223
View File
@@ -1,238 +1,35 @@
#include "serial.h"
#include <bootloader.h>
#include <kernel.h>
#include <string.h>
#include <pmm.h>
#include <paging.h>
#define PAGE_DIR_COUNT 256
static uint32_t pagedirs[PAGE_DIR_COUNT][1024] __align(4096);
static uint8_t pagedir_used[PAGE_DIR_COUNT];
size_t* pag_globalpd = NULL;
// TODO: Should this be initialized? If so, to what?
size_t pag_page_count = 0;
void pag_invalidate(size_t vaddr) { __asm__ volatile ("invlpg %0" ::"m"(vaddr)); }
// Invalidates the pagedir entry in the CPUs TLB cache
static inline void invalidate(uint32_t vaddr) {
__asm__ volatile ("invlpg %0" : : "m"(vaddr));
}
int pag_init() {
size_t pd_phys = 0;
__asm__ volatile ("movq %%cr3, %0" : "=r"(pd_phys));
if (!pd_phys) return 1;
// Temp paging thing
uint32_t temp_frame_start;
void pag_register_temp_frame(uint32_t target) { temp_frame_start = target; }
uint32_t pag_temp_frame(void) {
uint32_t fin = temp_frame_start;
temp_frame_start += PAGE_SIZE;
return fin;
}
size_t pd_virt = pd_phys + bootloader.hhdm_offset;
pag_globalpd = (size_t*)pd_virt;
int pag_init(void) {
// Unmap first MB
init_pagedir[0] = 0;
invalidate(0);
/*
* Recursive table mapping
* We map the last pagetab to the pagedir itself, so it acts
* as a pagetab even though it's a pagedir. This maps it to
* the virtual address 0xFFFFF000.
*/
init_pagedir[1023] = ((uint32_t)init_pagedir - KERNEL_BASE) |
PAGE_FLAG_PRESENT | PAGE_FLAG_WRITE;
invalidate(1023 * PAGE_SIZE);
// TODO: This sometimes causes a #PF
memset(pagedirs, 0, PAGE_SIZE * PAGE_DIR_COUNT);
memset(pagedir_used, 0, PAGE_DIR_COUNT);
debugf("[pag] Paging initalized.\n");
debugf("[pag] Paging initialized.");
return 0;
}
void pag_map(uint32_t vaddr, uint32_t paddr, uint32_t flags) {
// Save the pagedir we were in
uint32_t* prevpd = NULL;
// Switch to the init pagedir if in kernel memory
if (vaddr >= KERNEL_BASE) {
prevpd = pag_get_pagedir();
if (prevpd != init_pagedir) pag_set_pagedir(init_pagedir);
}
// Extract indecies
size_t pdi = vaddr >> 22;
size_t pti = vaddr >> 12 & 0x3FF;
uint32_t* pagedir = PAGEDIR;
uint32_t* pagetab = PAGETAB(pdi);
// Allocate a pagetab if it didn't exist
if (!(pagedir[pdi] & PAGE_FLAG_PRESENT)) {
uint32_t tabaddr = pmm_bitmap.ready ? pmm_alloc() : pag_temp_frame();
pagedir[pdi] = tabaddr |
PAGE_FLAG_PRESENT | PAGE_FLAG_WRITE | PAGE_FLAG_OWNER | flags;
invalidate(vaddr);
for (size_t i = 0; i < 1024; i++) {
pagetab[i] = 0;
}
}
// The actuall mapping
pagetab[pti] = paddr | PAGE_FLAG_PRESENT | flags;
pag_page_count++;
invalidate(vaddr);
// Do we need to return to the original pagedir?
if (prevpd != NULL) {
pag_sync_pagedir(); // Sync it to other pagedirs
if (prevpd != init_pagedir) pag_set_pagedir(prevpd);
}
}
uint32_t pag_umap(uint32_t vaddr) {
// Same saving as in pag_map()
uint32_t* prevpd = NULL;
if (vaddr >= KERNEL_BASE) {
prevpd = pag_get_pagedir();
if (prevpd != init_pagedir) pag_set_pagedir(init_pagedir);
}
// Extract indecies
size_t pdi = vaddr >> 22;
size_t pti = vaddr >> 12 & 0x3FF;
uint32_t* pagedir = PAGEDIR;
uint32_t* pagetab = PAGETAB(pdi);
uint32_t pte = pagetab[pti];
pagetab[pti] = 0;
pag_page_count--;
// Look if we can free the pagetab
int remove = 1;
for (size_t i = 0; i < 1024; i++) {
if (!(pagetab[i] & PAGE_FLAG_PRESENT)) continue;
remove = 0;
break;
}
// Free the pagetab if possible
uint32_t pde = pagedir[pdi];
if (remove && pde & PAGE_FLAG_OWNER) {
uint32_t tabaddr = PHYS_ADDR(pde);
pmm_free(tabaddr);
pagedir[pdi] = 0;
}
invalidate(vaddr);
// Free the page frame
if (pte & PAGE_FLAG_OWNER) pmm_free(PHYS_ADDR(pte));
if (prevpd != NULL) {
pag_sync_pagedir(); // Sync it to other pagedirs
if (prevpd != init_pagedir) pag_set_pagedir(prevpd);
}
return pte;
}
uint32_t pag_virt_to_phys(uint32_t vaddr) {
uint32_t pdi = vaddr >> 22;
uint32_t pti = vaddr >> 12 & 0x3FF;
uint32_t* pagetab = PAGETAB(pdi);
return (pagetab[pti] & ~0xFFF) + ((uint32_t)vaddr & 0xFFF);
}
uint32_t* pag_get_pagedir() {
uint32_t pagedir;
__asm__ volatile ("mov %%cr3, %0" : "=r"(pagedir));
pagedir += KERNEL_BASE;
return (uint32_t*)pagedir;
}
void pag_set_pagedir(uint32_t* pagedir) {
pagedir = (uint32_t*)((uint32_t)pagedir - KERNEL_BASE);
__asm__ volatile (
"mov %0, %%eax\n"
"mov %%eax, %%cr3"
: : "m"(pagedir)
);
}
void pag_sync_pagedir() {
for (size_t i = 0; i < PAGE_DIR_COUNT; i++) {
if (!pagedir_used[i]) continue;
uint32_t* pagedir = pagedirs[i];
// Sync ONLY the kernel pages so 768 has base at 0xC0000000
// Also don't sync the recursive mapping in the last page
for (size_t i = 768; i < 1023; i++) {
pagedir[i] = init_pagedir[i] & ~PAGE_FLAG_OWNER;
}
}
}
uint32_t* pag_alloc_pagedir() {
// Find the first unused page
for (size_t i = 0; i < PAGE_DIR_COUNT; i++) {
if (pagedir_used[i]) continue;
pagedir_used[i] = 1;
uint32_t* pagedir = pagedirs[i];
memset(pagedir, 0, PAGE_SIZE);
// First 768 entries are user pagetabs (3:1 memory split)
for (size_t i = 0; i < 768; i++) pagedir[i] = 0;
// Next 255 are kernel space
for (size_t i = 768; i < 1023; i++) pagedir[i] = init_pagedir[i] & ~PAGE_FLAG_OWNER;
// Last page is the recursive table mapping
pagedir[1023] = ((uint32_t)pagedir - KERNEL_BASE) |
PAGE_FLAG_PRESENT | PAGE_FLAG_WRITE;
return pagedir;
}
// No pages left - out of memory
return NULL;
}
void pag_free_pagedir(uint32_t* pagedir) {
uint32_t* prevpd = pag_get_pagedir();
pag_set_pagedir(pagedir);
uint32_t pdi = (uint32_t)pagedir - (uint32_t)pagedirs;
pdi /= PAGE_SIZE;
// Free all allocated page frames & pagetabs
uint32_t* pd = PAGEDIR;
for (int i = 0; i < 768; i++) {
uint32_t pde = pd[i];
if (pde == 0) continue;
uint32_t* pagetab = PAGETAB(i);
for (size_t j = 0; j < 1024; j++) {
uint32_t pte = pagetab[j];
if (pte & PAGE_FLAG_OWNER) pmm_free(PHYS_ADDR(pte));
}
memset(pagetab, 0, PAGE_SIZE);
if (pde & PAGE_FLAG_OWNER) pmm_free(PHYS_ADDR(pde));
pd[i] = 0;
}
pagedir_used[pdi] = 0;
pag_set_pagedir(prevpd);
}
void pag_map(size_t vaddr, size_t paddr, size_t flags);
size_t pag_umap(size_t vaddr);
size_t pag_virt_to_phys(size_t vaddr);
size_t* pag_get_pagedir();
size_t* pag_get_task_pagedir(void* task);
void pag_set_pagedir(size_t* pagedir);
size_t* pag_alloc_pagedir();
void pag_free_pagedir(size_t* pagedir);
void pag_invalidate(size_t vaddr);
kernel/src/pmm.c
+28 -44
View File
@@ -1,3 +1,4 @@
#include "bitmap.h"
#include <bootloader.h>
#include <kernel.h>
#include <paging.h>
@@ -8,82 +9,65 @@
bitmap_t pmm_bitmap;
int pmm_init(void) {
// Full 32-bit address space
pmm_bitmap.membase = 0x00000000;
pmm_bitmap.blocks = 0x100000; // 0xFFFFFFFF / BLOCK_SIZE
pmm_bitmap.bytes = 0x20000; // blocks / 8
pmm_bitmap.map = NULL;
pmm_bitmap.blocks = dceil(bootloader.mm_total, BLOCK_SIZE);
pmm_bitmap.bytes = dceil(pmm_bitmap.blocks, 8);
// # of pagetabs required to map the bitmap
size_t ptcount = dceil(dceil(pmm_bitmap.bytes, PAGE_SIZE), 1024);
// Find enough space for the bitmap
struct boot_memmap* mmap;
int found = 0;
for (size_t i = 0; i < bootloader.memmap_size; i++) {
mmap = &bootloader.memmap[i];
struct limine_memmap_entry* mm = NULL;
for (size_t i = 0; i < bootloader.mm_entry_count; i++) {
struct limine_memmap_entry* entry = bootloader.mm_entries[i];
if (mmap->type == BOOT_MMAP_AVAILABLE && mmap->size >= pmm_bitmap.bytes) {
found = 1;
break;
}
if (entry->type != LIMINE_MEMMAP_USABLE || entry->length < pmm_bitmap.bytes) continue;
mm = entry;
}
if (!found) return 1; // Not enough memory
uint32_t page_frame_start = mmap->base;
pag_register_temp_frame(page_frame_start);
mmap->base += ptcount * PAGE_SIZE;
uint32_t bitmap_start = KERNEL_HEAP_BASE - dceil(pmm_bitmap.bytes, PAGE_SIZE) * PAGE_SIZE;
uint32_t bitmap_start_phys = mmap->base;
pmm_bitmap.map = (void*)bitmap_start;
size_t page_count = dceil(pmm_bitmap.bytes, PAGE_SIZE);
for (size_t i = 0; i < page_count; i++) {
// NOTE: We can't unmap this with pag_umap(), it's in a tempFrame
pag_map(bitmap_start + i * PAGE_SIZE, mmap->base + i * PAGE_SIZE, 0);
if (!mm) {
debugf("[pmm] Not enough memory! Needs %d bytes.\n", pmm_bitmap.bytes);
return 1;
}
size_t bitmap_start_phys = mm->base;
pmm_bitmap.map = (void*)(bitmap_start_phys + bootloader.hhdm_offset);
// Set all blocks as used
bmap_set_all(&pmm_bitmap, 1);
debugf("[pmm] Memory map:\n"); // Use the loop to also print the memmap
for (size_t i = 0; i < bootloader.mm_entry_count; i++) {
struct limine_memmap_entry* entry = bootloader.mm_entries[i];
if (entry->length == 0) continue; // Ignore dummy entries
for (size_t i = 0; i < bootloader.memmap_size; i++) {
mmap = &bootloader.memmap[i];
if (mmap->size == 0) continue; // Ignore dummy entries
if (mmap->type == BOOT_MMAP_AVAILABLE) {
bmap_set_area(&pmm_bitmap, mmap->base, mmap->size, 0);
if (entry->type == LIMINE_MEMMAP_USABLE) {
bmap_set_area(&pmm_bitmap, entry->base, entry->length, 0);
}
// Print entry
debugf("\tRegion %2d: 0x%08x - 0x%08x (%d bytes) %s\n",
i + 1, mmap->base, mmap->base + mmap->size - 1, mmap->size,
(mmap->type == BOOT_MMAP_AVAILABLE) ? "AVAILABLE" : "RESERVED");
i + 1, entry->base, entry->base + entry->length - 1, entry->length,
(entry->type == LIMINE_MEMMAP_USABLE) ? "AVAILABLE" : "RESERVED");
}
bmap_set_area(&pmm_bitmap, bitmap_start_phys, pmm_bitmap.bytes, 1);
bmap_set_area(&pmm_bitmap, page_frame_start, ptcount * PAGE_SIZE, 1);
pmm_bitmap.used = 0;
bmap_set(&pmm_bitmap, 0, 1); // Reserve block 0 - NULL page
// Beatifull print statement :)
// Beatiful print statement :)
debugf(
"[pmm] Physical memory manager initialized.\n"
"\tAvailable memory: %d blocks free (%d bytes)\n"
"\tBitmap at 0x%08x mapped to 0x%08x\n"
"\tBitmap at 0x%08x in physical memory\n"
"\tBitmap is %d bytes contained in %d pages\n",
pmm_bitmap.blocks - pmm_bitmap.used,
(pmm_bitmap.blocks - pmm_bitmap.used) * BLOCK_SIZE,
bitmap_start_phys, bitmap_start, pmm_bitmap.bytes, page_count
bitmap_start_phys, pmm_bitmap.bytes
);
pmm_bitmap.ready = 1;
return 0;
}
uint32_t pmm_alloc(void) {
size_t pmm_alloc(void) {
if (pmm_bitmap.blocks - pmm_bitmap.used == 0) return 0;
size_t base = bmap_get_area(&pmm_bitmap, 1, 0);
@@ -91,10 +75,10 @@ uint32_t pmm_alloc(void) {
bmap_set(&pmm_bitmap, base, 1);
return (uint32_t)bmap_ptr(&pmm_bitmap, base);
return (size_t)bmap_ptr(&pmm_bitmap, base);
}
void pmm_free(uint32_t page) {
void pmm_free(size_t page) {
size_t base = page / BLOCK_SIZE;
bmap_set_area(&pmm_bitmap, base, 1, 0);
bmap_set(&pmm_bitmap, 0, 1);
kernel/src/sched.c
-26
View File
@@ -1,26 +0,0 @@
#include <kernel.h>
#include <task.h>
#include <gdt.h>
#include <sched.h>
void schedule(void) {
if (task_first == NULL) return;
struct task* next = task_current->next;
if (next == NULL) next = task_first;
while (next->state != TASK_STATE_READY) {
next = next->next;
if (next == NULL) next = task_first;
}
struct task* old = task_current;
task_current = next;
tss_esp0(next->kstack_bottom);
// NOTE: Might not return
task_switch(old, next);
}
kernel/src/serial.c
+4 -4
View File
@@ -63,9 +63,9 @@ int debugf(char* fmt, ...) {
}
int vdebugf(char* fmt, va_list args) {
static char buf[DF_BUF_LEN];
int ret = vsnprintf(buf, DF_BUF_LEN, fmt, args);
serial_puts(COM1, buf);
return ret;
char buf[DF_BUF_LEN];
int len = vsnprintf(buf, DF_BUF_LEN, fmt, args);
serial_write(COM1, buf, len);
return len;
}
kernel/src/ssp.c
+3 -2
View File
@@ -4,8 +4,9 @@
*/
#include <kernel.h>
// TODO: Make this randomized
#define STACK_CHK_GUARD 0x27a1abd8
#ifndef STACK_CHK_GUARD
#error "STACK_CHK_GUARD not defined!"
#endif
uintptr_t __stack_chk_guard = STACK_CHK_GUARD;
__noreturn void __stack_chk_fail(void) {
kernel/src/syscall.c
-70
View File
@@ -1,70 +0,0 @@
#include <kernel.h>
#include <task.h>
#include <ipc.h>
#include <tty.h>
#include <syscall.h>
// Syscall table
void* syscalls[SYSCALL_MAX] = { 0 };
int syscall_init(void) {
syscall_register(SYS_SEND, (void*)sys_send);
syscall_register(SYS_RECV, (void*)sys_recv);
debugf("[syscall] Initiated syscalls!\n");
return 0;
}
int sys_send(pid_t dst, ipc_msg_t* msg) {
msg->sender = task_current->id;
debugf("[syscall] Task #%d sent a message to Task #%d.\n", msg->sender, dst);
return ipc_send(dst, msg);
}
int sys_recv(pid_t src, ipc_msg_t* msg) {
debugf("[syscall] Task #%d is receiving a message from Task #%d.\n", task_current->id, src);
return 0;
}
void syscall_register(size_t idx, void* handler) {
if (idx > SYSCALL_MAX) {
debugf("[syscall] Failed to register syscall #%d.\n", idx);
return;
}
syscalls[idx] = handler;
}
void syscall_handler(struct isr_int_frame* iframe) {
size_t nr = iframe->eax;
if (nr > SYSCALL_MAX || !syscalls[nr]) {
iframe->eax = -1;
debugf("[syscall] Tried to call syscall #%d which doesn't exist.\n", nr);
return;
}
void* handler = syscalls[nr];
int ret;
debugf("0x%08x\n", &ret);
__asm__ volatile(
"push %1\n"
"push %2\n"
"push %3\n"
"push %4\n"
"push %5\n"
"push %6\n"
"call *%7\n"
"add $24, %%esp\n"
"mov %%eax, %0\n"
: "=r"(ret)
: "g"(iframe->ebp), "g"(iframe->edi), "g"(iframe->esi),
"g"(iframe->edx), "g"(iframe->ecx), "g"(iframe->ebx),
"g"(handler)
: "eax", "memory"
);
iframe->eax = ret;
}
kernel/src/task.c
-251
View File
@@ -1,251 +0,0 @@
#include <kmalloc.h>
#include <kernel.h>
#include <paging.h>
#include <string.h>
#include <system.h>
#include <sched.h>
#include <gdt.h>
#include <isr.h>
#include <pmm.h>
#include <task.h>
struct task* task_first;
struct task* task_dummy;
struct task* task_current;
int task_init(void) {
task_first = kzalloc(sizeof(*task_first));
task_dummy = kzalloc(sizeof(*task_dummy));
if (task_first == NULL || task_dummy == NULL) return 1;
// The first task is what's running right now @~@
task_current = task_first;
task_current->id = TASK_KERNEL;
task_current->state = TASK_STATE_READY;
task_current->pagedir = pag_get_pagedir();
task_current->kernel_task = 1;
debugf("[task] Multitasking initiated.\n");
return 0;
}
void task_create(pid_t id, uint32_t eip, int kernel_task, uint32_t* pagedir, int argc, char** argv) {
cli();
uint32_t kstack = (uint32_t)kmalloc(0x1000 - 16) + (0x1000 - 16);
uint8_t* kesp = (uint8_t*)kstack;
kesp -= sizeof(struct isr_int_frame);
struct isr_int_frame* trap = (struct isr_int_frame*)kesp;
memset(trap, 0, sizeof(*trap));
uint16_t codesel = kernel_task ? GDT_KERNEL_CODE : GDT_USER_CODE;
uint16_t datasel = kernel_task ? GDT_KERNEL_DATA : GDT_USER_DATA;
trap->cs = codesel;
trap->ds = datasel;
trap->es = datasel;
trap->fs = datasel;
trap->gs = datasel;
trap->user_ss = datasel;
trap->user_esp = USER_STACK;
trap->eflags = 0x200; // Enable interrupts
trap->eip = eip;
kesp -= sizeof(struct task_switch_ctx);
struct task_switch_ctx* ctx = (struct task_switch_ctx*)kesp;
ctx->edi = 0;
ctx->esi = 0;
ctx->ebx = 0;
ctx->ebp = 0;
ctx->eip = (uint32_t)isr_return;
struct task* current = task_first;
while (current != NULL) {
if (current->next == NULL) break;
current = current->next;
}
struct task* new = kzalloc(sizeof(*new));
current->next = new;
new->kstack_bottom = kstack;
new->kstack_pointer = (size_t)kesp;
new->id = id;
new->kernel_task = kernel_task;
new->state = TASK_STATE_READY;
new->pagedir = pagedir;
new->heap_start = USER_HEAP;
new->heap_end = USER_HEAP;
// We don't need to setup a stack frame
if (kernel_task) {
sti();
return;
}
void* old_pagedir = pag_get_pagedir();
pag_set_pagedir(new->pagedir);
// Setup argc, argv
size_t arg_len = 0;
for (int i = 0; i < argc; i++) arg_len += strlen(argv[i]) + 1;
size_t page_count = dceil(4 + (argc * 4) + 10 + arg_len, PAGE_SIZE);
for (size_t i = 0; i < page_count; i++) {
uint32_t paddr = pmm_alloc();
if (paddr == 0) { // Not enough memory
// TODO: Do pmm_free() for each page
kfree(new);
kfree((void*)kstack);
pag_set_pagedir(old_pagedir);
return;
}
pag_map(USER_STACK + i * PAGE_SIZE, (uint32_t)paddr, 0);
}
int* argc_ptr = (int*)USER_STACK;
char** argv_ptr = (char**)(USER_STACK + 4);
*argc_ptr = argc;
size_t cur = 0;
for (int i = 0; i < argc; i++) {
size_t len = strlen(argv[i]);
char* ptr = (char*)((size_t)argv_ptr + argc * 4 + 4 + cur);
memcpy(ptr, argv[i], len);
ptr[len] = '\0';
argv_ptr[i] = ptr;
cur += len + 1;
}
pag_set_pagedir(old_pagedir);
}
void task_kill(pid_t id) {
cli();
struct task* current = task_first;
while (current != NULL) {
if (current->next && current->next->id == id) break;
current = current->next;
}
struct task* task = current->next;
if (task == NULL || task->state == TASK_STATE_DEAD) return;
current->next = task->next;
void* kstack = (void*)(task->kstack_bottom + 0x1000 - 16);
kfree(kstack);
uint32_t* old_pagedir = pag_get_pagedir();
pag_set_pagedir(task->pagedir);
size_t heap_start = dceil(task->heap_start, PAGE_SIZE);
size_t heap_end = dceil(task->heap_end, PAGE_SIZE);
if (heap_end > heap_start) {
size_t num = heap_end - heap_start;
for (size_t i = 0; i < num; i++) {
uint32_t vaddr = heap_start * PAGE_SIZE + i * PAGE_SIZE;
uint32_t paddr = pag_virt_to_phys(vaddr);
pmm_free(paddr);
}
}
pag_set_pagedir(old_pagedir);
pag_free_pagedir(task->pagedir);
// Workaround so we don't free a task we're in
if (task_current == task) {
memset(task_dummy, 0, sizeof(*task_dummy));
task_current = task_dummy;
}
kfree(task);
schedule();
sti();
}
void task_set_user_heap(pid_t id, size_t heap_end) {
struct task* task = task_get(id);
if (heap_end <= task->heap_start) {
debugf("[task] Task %d tried to shrink heap bellow 0.\n", task->id);
task_kill(task->id);
return;
}
int old_page_top = dceil(task->heap_end, PAGE_SIZE);
int new_page_top = dceil(heap_end, PAGE_SIZE);
if (new_page_top == old_page_top) return;
else if (new_page_top > old_page_top) { // Grow
int num = new_page_top - old_page_top;
for (int i = 0; i < num; i++) {
uint32_t paddr = (uint32_t)pmm_alloc();
if (paddr == 0) {
debugf("[task] Task %d tried to grow heap too much.\n", task->id);
task_kill(task->id);
}
uint32_t vaddr = old_page_top * PAGE_SIZE + i * PAGE_SIZE;
pag_map(vaddr, paddr, PAGE_FLAG_USER);
memset((void*)vaddr, 0, PAGE_SIZE);
}
} else { // Shrink
int num = old_page_top - new_page_top;
for (int i = 0; i < num; i++) {
uint32_t vaddr = old_page_top * PAGE_SIZE + i * PAGE_SIZE;
uint32_t paddr = pag_virt_to_phys(vaddr);
pmm_free(paddr);
pag_umap(vaddr);
}
}
task->heap_end = heap_end;
}
struct task* task_get(pid_t id) {
struct task* find = task_first;
while (find != NULL) {
if (find->id == id) break;
find = find->next;
}
return find;
}
uint8_t task_get_state(pid_t id) {
struct task* t = task_get(id);
if (t == NULL) return TASK_STATE_DEAD;
return t->state;
}
void task_set_state(pid_t id, uint8_t state) {
struct task* t = task_get(id);
if (t == NULL) return;
t->state = state;
}
pid_t task_create_id(void) {
struct task* current = task_first;
pid_t max = current->id;
current = current->next;
while (current != NULL) {
if (max < current->id) max = current->id;
current = current->next;
}
return max + 1;
}
kernel/src/task.s
-35
View File
@@ -1,35 +0,0 @@
bits 32
;; Prototype:
;; void switch_context(struct task* old, struct task* new);
;; Description:
;; Pushes register state onto the old tasks kstack and pops the new state.
global task_switch
task_switch:
mov eax, [esp + 4] ; eax = struct task* old
mov edx, [esp + 8] ; ebx = struct task* new
;; Push registers that weren't pushed by the CDECL call
push ebp
push ebx
push esi
push edi
;; Swap the stack pointers
mov [eax + 4], esp ; old->kstack_pointer = ESP
mov esp, [edx + 4] ; ESP = new->kstack_pointer
;; Change the pagedir
mov eax, [edx + 12] ; EAX = new->pagedir
sub eax, 0xC0000000 ; Convert to physical address
mov cr3, eax
;; Pop register that weren't pushed by the CDECL call
pop edi
pop esi
pop ebx
pop ebp
;; This return will pop task_switch_ctx.eip
ret
kernel/src/timer.c
+2 -3
View File
@@ -1,8 +1,7 @@
#include <kernel.h>
#include <system.h>
#include <sched.h>
//#include <sched.h>
#include <isr.h>
#include <tty.h>
#include <timer.h>
@@ -44,6 +43,6 @@ void pit_handler(struct isr_int_frame* iframe) {
timer_ticks++;
// TODO: This assumes the timer is at 1000 Hz
if (timer_ticks % SCHED_QUANTUM == 0) schedule();
//if (timer_ticks % SCHED_QUANTUM == 0) schedule();
}
kernel/src/tty.c
-114
View File
@@ -1,114 +0,0 @@
#include <kernel.h>
#include <paging.h>
#include <system.h>
#include <tty.h>
struct {
size_t row;
size_t col;
uint8_t attr;
uint8_t* buf;
/*
* This is for the tty_update_cursor() function. It makes sure we don't update
* the cursor if we don't need to, because it's slow due to I/O port writes.
*/
size_t update_wait;
} tty_ctx;
int tty_init(void) {
// Map VGA Text memory to KERNEL_FRAMEBUF
size_t page_count = dceil(VGA_WIDTH * VGA_HEIGHT * 2, PAGE_SIZE);
for (size_t i = 0; i < page_count; i++) {
pag_map(KERNEL_FRAMEBUF + i * PAGE_SIZE, VGA_MEMORY + i * PAGE_SIZE, 0);
}
tty_ctx.row = 0;
tty_ctx.col = 0;
tty_ctx.attr = 0x07;
tty_ctx.buf = (uint8_t*)KERNEL_FRAMEBUF;
tty_clear();
debugf("[tty] Initiated %dx%d VGA display to TTY.\n", VGA_WIDTH, VGA_HEIGHT);
return 0;
}
void tty_clear(void) {
for (int i = 0; i < VGA_WIDTH * VGA_HEIGHT; i++) {
tty_ctx.buf[i * 2] = ' ';
tty_ctx.buf[i * 2 + 1] = tty_ctx.attr;
}
}
void tty_set_attr(uint8_t attr) {
tty_ctx.attr = attr;
}
void tty_show_cursor(uint8_t start, uint8_t end) {
outb(0x3d4, 0x0a);
outb(0x3d5, (inb(0x3d5) & 0xc0) | start);
outb(0x3d4, 0x0b);
outb(0x3d5, (inb(0x3d5) & 0xe0) | end);
}
void tty_hide_cursor(void) {
outb(0x3d4, 0x0a);
outb(0x3d5, 0x20);
}
void tty_update_cursor(void) {
if (tty_ctx.update_wait > 0) {
tty_ctx.update_wait--;
return;
}
uint16_t pos = tty_ctx.row * VGA_WIDTH + tty_ctx.col;
outb(0x3d4, 0x0f);
outb(0x3d5, (uint8_t)pos);
outb(0x3d4, 0x0e);
outb(0x3d5, (uint8_t)(pos >> 8));
}
// TODO:
void tty_scroll(void) {
tty_ctx.row = 0;
tty_ctx.col = 0;
tty_clear();
}
void tty_putat(char c, size_t row, size_t col) {
size_t i = row * VGA_WIDTH + col;
tty_ctx.buf[i * 2] = c;
tty_ctx.buf[i * 2 + 1] = tty_ctx.attr;
}
void tty_putc(char c) {
if (c == '\n') {
tty_ctx.col = 0;
tty_ctx.row++;
goto scroll_check;
}
tty_putat(c, tty_ctx.row, tty_ctx.col++);
if (tty_ctx.col >= VGA_WIDTH) {
tty_ctx.col = 0;
tty_ctx.row++;
}
scroll_check:
if (tty_ctx.row >= VGA_HEIGHT) tty_scroll();
tty_update_cursor();
}
void tty_write(char* buf, size_t len) {
tty_ctx.update_wait = len - 1;
for (size_t i = 0; i < len; i++) tty_putc(buf[i]);
}
void tty_puts(char* s) {
size_t len = 0;
char* p = s;
while (*p++ != '\0') len++;
tty_write(s, len);
}
kernel/src/vsnprintf.c
+179 -78
View File
@@ -3,89 +3,190 @@
#include <vsnprintf.h>
int pf_isdigit(char c) {
if (c >= '0' && c <= '9') return 1;
return 0;
}
static inline int _isdigit(int c) { return (c >= '0' && c <= '9') ? 1 : 0; }
char* pf_itoa(uint32_t num, uint8_t base) {
static char buf[32];
if (base == 0 || base > 16) return NULL;
if (num == 0) {
buf[0] = '0';
buf[1] = '\0';
return &buf[0];
}
static size_t _utoa(char* out, uint64_t v, uint32_t base) {
static char* digits = "0123456789abcdef";
int i;
for (i = 30; num && i; i--, num /= base) {
buf[i] = "0123456789abcdef"[num % base];
}
return &buf[i + 1];
}
int vsnprintf(char* buf, size_t len, char* fmt, va_list args) {
size_t i = 0;
while (*fmt != '\0' && i < len) {
if (*fmt != '%') {
if (i < len) buf[i++] = *fmt++;
continue;
}
fmt++; // Consume the '%'
if (*fmt == '\0') {
if (i < len) buf[i++] = '%';
break;
}
// Parse the format specifier
int width = 0;
char pad = ' ';
if (pf_isdigit(*fmt)) {
if (*fmt == '0') { pad = '0'; fmt++; }
while (pf_isdigit(*fmt)) {
width *= 10;
width += *fmt++ - '0';
}
}
char* s;
switch (*fmt) {
case 'c': // Char
if (i < len) buf[i++] = (char)va_arg(args, int);
break;
case 'd': // Int (TODO: %d for signed, %u for unsigned
s = pf_itoa(va_arg(args, unsigned int), 10);
goto string;
case 'x': // Unsigned hex int
s = pf_itoa(va_arg(args, unsigned int), 16);
goto string;
// TODO: %f for float
case 's': // String
s = va_arg(args, char*);
string: // Prints the string in s
if (s == NULL) s = "(null)";
width -= strlen(s);
while (width-- >= 0 && i < len) buf[i++] = pad;
while (*s != '\0' && i < len) buf[i++] = *s++;
break;
default: // Something else
if (i < len) buf[i++] = '%';
if (i < len) buf[i++] = *fmt;
break;
}
fmt++;
if (v == 0) {
out[i++] = '0';
return i;
}
if (i < len) buf[i++] = '\0';
while (v) {
out[i++] = digits[v % base];
v /= base;
}
return i;
}
static void _putc(char* buf, size_t n, size_t* idx, char c) {
if (*idx < n - 1) buf[*idx] = c;
(*idx)++;
}
static void _puts(char* buf, size_t n, size_t* idx, char* s, size_t len) {
for (size_t i = 0; i < len; i++) _putc(buf, n, idx, s[i]);
}
static void fmt_string(char* buf, size_t n, size_t* idx, char* s, size_t len, int width, char pad, int left) {
int pad_len = width > (int)len ? width - (int)len : 0;
if (!left) { while (pad_len--) _putc(buf, n, idx, pad); }
_puts(buf, n, idx, s, len);
if (left) { while (pad_len--) _putc(buf, n, idx, pad); }
}
static void fmt_int(char* buf, size_t n, size_t* idx, int64_t v, int width, char pad, int left) {
char tmp[32];
size_t len;
int neg = v < 0;
uint64_t uv = neg ? -v : v;
len = _utoa(tmp, uv, 10);
if (neg) tmp[len++] = '-';
for (size_t i = 0; i < len / 2; i++) {
char c = tmp[i];
tmp[i] = tmp[len - 1 - i];
tmp[len - 1 - i] = c;
}
fmt_string(buf, n, idx, tmp, len, width, pad, left);
}
static void fmt_uint(char* buf, size_t n, size_t* idx, uint64_t v, uint32_t base, int width, char pad, int left) {
char tmp[32];
size_t len = _utoa(tmp, v, base);
for (size_t i = 0; i < len / 2; i++) {
char c = tmp[i];
tmp[i] = tmp[len - 1 - i];
tmp[len - 1 - i] = c;
}
fmt_string(buf, n, idx, tmp, len, width, pad, left);
}
// WARN: I took this from somewhere and idk how good it is and i'm too lazy to check
static void fmt_float(char* buf, size_t n, size_t* idx, double v, int prec, int width, char pad, int left) {
if (prec < 0) prec = 6;
if (v < 0) {
_putc(buf, n, idx, '-');
v = -v;
if (width > 0) width--;
}
long long ip = (long long)v;
double frac = v - (double)ip;
char tmp[64];
size_t len = _utoa(tmp, ip, 10);
for (size_t i = 0; i < len / 2; i++) {
char c = tmp[i];
tmp[i] = tmp[len - 1 - i];
tmp[len - 1 - i] = c;
}
size_t total = len + 1 + prec;
int pad_len = width > (int)total ? width - (int)total : 0;
if (!left) { while (pad_len--) _putc(buf, n, idx, pad); }
_puts(buf, n, idx, tmp, len);
_putc(buf, n, idx, '.');
for (int i = 0; i < prec; i++) {
frac *= 10.0;
int d = (int)frac;
_putc(buf, n, idx, '0' + d);
frac -= d;
}
if (left) { while (pad_len--) _putc(buf, n, idx, pad); }
}
int vsnprintf(char* buf, size_t n, char* fmt, va_list ap) {
size_t idx = 0;
for (; *fmt != '\0'; fmt++) {
if (*fmt != '%') {
_putc(buf, n, &idx, *fmt);
continue;
}
fmt++;
int left = 0;
char pad = ' ';
int width = 0;
int prec = -1;
if (*fmt == '-') {
left = 1;
fmt++;
}
if (*fmt == '0') {
pad = '0';
fmt++;
}
while (_isdigit((int)*fmt)) {
width = width * 10 + (*fmt - '0');
fmt++;
}
if (*fmt == '.') {
fmt++;
prec = 0;
while (_isdigit((int)*fmt)) {
prec = prec * 10 + (*fmt - '0');
fmt++;
}
}
switch (*fmt) {
case 'd': fmt_int(buf, n, &idx, va_arg(ap, int), width, pad, left); break;
case 'u': fmt_uint(buf, n, &idx, va_arg(ap, unsigned int), 10, width, pad, left); break;
case 'x': fmt_uint(buf, n, &idx, va_arg(ap, unsigned int), 16, width, pad, left); break;
case 'f': fmt_float(buf, n, &idx, va_arg(ap, double), prec, width, pad, left); break;
case 's': {
char* s = va_arg(ap, char*);
if (s == NULL) s = "(null)";
size_t len = strlen(s);
if (prec >= 0) len = min(len, (size_t)prec);
fmt_string(buf, n, &idx, s, len, width, pad, left);
} break;
case 'c': _putc(buf, n, &idx, (char)va_arg(ap, int)); break;
case '%': _putc(buf, n, &idx, '%'); break;
default:
// Undo all the parsing we just did :')
_putc(buf, n, &idx, '%');
if (left) _putc(buf, n, &idx, '-');
if (pad == '0') _putc(buf, n, &idx, '0');
if (width > 0) fmt_uint(buf, n, &idx, width, 10, 0, 0, 0);
if (prec != -1) {
_putc(buf, n, &idx, '.');
fmt_uint(buf, n, &idx, prec, 10, 0, 0, 0);
}
_putc(buf, n, &idx, *fmt);
break;
}
}
if (n) buf[min(idx, n - 1)] = '\0';
return (int)idx;
}
int snprintf(char *buf, size_t n, char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
int ret = vsnprintf(buf, n, fmt, ap);
va_end(ap);
return ret;
}