PoliEcho-holding-org/kern
1
0
Fork 1
mirror of https://github.com/Tom-on64/kern.git synced 2026-11-03 18:22:22 +00:00
Code Issues Packages Projects Releases Wiki 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/include/bootloader.h
+16 -51
View File
@@ -2,60 +2,25 @@
#define _BOOTLOADER_H
#include <kernel.h>
#include <limine.h>
// Boot protocols
#define BOOT_UNKNOWN 0 // Unknown
#define BOOT_MB1 1 // MultiBoot 1
#define BOOT_MB2 2 // MultiBoot 2
#define BOOT_LIMINE 3 // Limine
struct bootloader {
size_t hhdm_offset;
size_t kernel_virt_base;
size_t kernel_phys_base;
size_t mm_total;
uint64_t mm_entry_count;
LIMINE_PTR(struct limine_memmap_entry**) mm_entries;
uint64_t fb_entry_count;
LIMINE_PTR(struct limine_framebuffer**) fb_entries;
};
// Memmap region types
#define BOOT_MMAP_AVAILABLE 1
#define BOOT_MMAP_RESERVED 2
#define BOOT_MMAP_ACPI_RECLAIM 3
#define BOOT_MMAP_NVS 4
#define BOOT_MMAP_BADRAM 5
extern struct bootloader bootloader;
#define BOOT_MAX_MMAP_ENTRIES 128
#define IS_INSIDE_HHDM(_addr) \
((size_t)(_addr) >= bootloader.hhdm_offset && \
(size_t)(_addr) <= (bootloader.hhdm_offset + bootloader.mm_total))
// A memory map entry
struct boot_memmap {
uint64_t base; // Memory region address
uint64_t size; // Memory region length
uint8_t type; // Memory region type
} __packed;
/*
* Some values may not be provided by the bootloader, in this case
* pointers will be NULL and integer values will be 0 if applicable.
* Some unprovided values may also be implied. Eg.:
* If 'memmap = NULL' then 'memmap_size' doesn't matter.
*/
struct boot_info {
uint32_t mem_lower;
uint32_t mem_upper;
uint8_t boot_drive;
uint8_t boot_part1;
uint8_t boot_part2;
uint8_t boot_part3;
struct boot_memmap* memmap;
size_t memmap_size;
char* cmdline;
char* bootname;
} __packed;
extern struct boot_info bootloader;
/*
* This functions arguments depend on the boot protocol provided.
* This is the reason for the varargs thing. It runs on of the functions
* defined after it.
*/
int boot_init(int type, ...);
int boot_init_mb1(void* ptr, uint32_t magic);
// TODO:
// int boot_init_mb2(...);
// int boot_init_limine(...);
int boot_init(void);
#endif
kernel/include/gdt.h
+43 -47
View File
@@ -8,7 +8,7 @@
#define DPL_USER 3
/*
* Segment selector explanation (why kcode is 0x08?)
* Segment selector explanation (why is kcode 0x08?)
*
* Each segment selector must be 16 bits. These bits
* have the following layout: (example is 0x08)
@@ -17,7 +17,7 @@
* | '--- Table indicator
* '------ Index in table
*
* Bits 0-1 are the privilege level. x86 has four,
* Bits 0-1 are the privilege level. x86(_64) has four,
* where 00 is the highest and 11 is the lowest. Only
* these two are widely used. 00 being kernel space &
* 11 being userspace. Bit 3 is the table indicator.
@@ -30,37 +30,23 @@
* s 0 for the GDT and the index is one, because it
* is the second entry in our GDT (after null desc.)
*/
#define SEGMENT_SEL(_idx, _tab, _dpl) (\
(((_dpl) ) & 3) | \
(((_tab) << 2) & 4) | \
(((_idx) << 3) ) \
)
/*
* Entries:
* 0 Null desc.
* 1 Kernel code desc.
* 2 Kernel data desc.
* 3 User code desc.
* 4 User data desc.
* 3 User data desc.
* 4 User code desc.
* 5 Task State Segment
*/
#define GDT_ENTRIES 6
#define GDT_NULL SEGMENT_SEL(0, 0, 0)
#define GDT_KERNEL_CODE SEGMENT_SEL(1, 0, DPL_KERNEL)
#define GDT_KERNEL_DATA SEGMENT_SEL(2, 0, DPL_KERNEL)
#define GDT_USER_CODE SEGMENT_SEL(3, 0, DPL_USER)
#define GDT_USER_DATA SEGMENT_SEL(4, 0, DPL_USER)
#define GDT_TSS SEGMENT_SEL(5, 0, DPL_KERNEL)
#define GDT_DESC(_lim, _base, _access, _flags) (struct gdt_entry) { \
.base_low = (_base) & 0xFFFF, \
.base_mid = ((_base) >> 16) & 0xFF, \
.base_high = ((_base) >> 24) & 0xFF, \
.limit = (_lim) & 0xFFFF, \
.flags = ((_flags) & 0xF0) | (((_lim) >> 16) & 0x0F), \
.access = (_access) \
}
#define GDT_ENTRIES 7
#define GDT_NULL 0x00
#define GDT_KERNEL_CODE 0x08
#define GDT_KERNEL_DATA 0x10
#define GDT_USER_DATA 0x18
#define GDT_USER_CODE 0x20
#define GDT_TSS 0x28
/*
* GDT descriptor/entry explanation
@@ -95,34 +81,44 @@ struct gdt_entry {
struct gdt_pointer {
uint16_t limit;
uint32_t base;
uint64_t base;
} __packed;
struct tss_entry {
uint16_t length;
uint16_t base_low;
uint8_t base_mid;
uint8_t access;
uint8_t flags;
uint8_t base_high;
uint32_t base_upper32;
uint32_t __reserved;
} __packed;
struct tss_pointer {
uint16_t prev_task, __reserved0;
uint32_t esp0;
uint16_t ss0, __reserved1;
uint32_t esp1;
uint16_t ss1, __reserved2;
uint32_t esp2;
uint16_t ss2, __reserved3;
uint32_t cr3;
uint32_t eip;
uint32_t eflags;
uint32_t eax, ecx, edx, ebx, esp, ebp, esi, edi;
uint16_t es, __reserved4;
uint16_t cs, __reserved5;
uint16_t ss, __reserved6;
uint16_t ds, __reserved7;
uint16_t fs, __reserved8;
uint16_t gs, __reserved9;
uint16_t ldtr;
uint32_t __reserved10;
uint32_t __reserved0;
uint64_t rsp0;
uint64_t rsp1;
uint64_t rsp2;
uint64_t __reserved1;
uint64_t ist1;
uint64_t ist2;
uint64_t ist3;
uint64_t ist4;
uint64_t ist5;
uint64_t ist6;
uint64_t ist7;
uint64_t __reserved2;
uint16_t __reserved3;
uint16_t iopb;
uint32_t ssp;
} __packed;
void tss_esp0(uint32_t esp0);
struct gdt_entries {
// GDT_ENTRIES - 2 to leave space for TSS
struct gdt_entry entries[GDT_ENTRIES - 2];
struct tss_entry tss;
} __packed;
int gdt_init(void);
#endif
kernel/include/idt.h
+18 -8
View File
@@ -4,21 +4,31 @@
#include <kernel.h>
#define IDT_ENTRIES 256
#define IDT_FLAG_TRAP 0x8f // P = 1, Priv = 00, S = 0, Type = 1111 (32-bit trap)
#define IDT_FLAG_INT 0x8e // P = 1, Priv = 00, S = 0, Type = 1110 (32-bit int)
#define IDT_FLAG_USER 0xee // P = 1, Priv = 11, S = 0, Type = 1110 (32-bit int)
#define IDT_FLAG_TRAP 0x8F // P = 1, Priv = 00, S = 0, Type = 1111 (32-bit trap)
#define IDT_FLAG_INT 0x8E // P = 1, Priv = 00, S = 0, Type = 1110 (32-bit int)
#define IDT_FLAG_USER 0xEE // P = 1, Priv = 11, S = 0, Type = 1110 (32-bit int)
/*
* Attribute field explanation
* 0..3 Gate type
* 4 Zero (unused)
* 5..6 DPL (privilege)
* 7 Present
*/
struct idt_entry {
uint16_t offset_low;
uint16_t selector;
uint8_t __unused;
uint8_t flags;
uint16_t offset_high;
uint8_t ist; // Only 3 low bits, rest is reserved
uint8_t attrib;
uint16_t offset_mid;
uint32_t offset_high;
uint32_t __reserved;
} __packed;
struct idt_pointer {
uint16_t limit;
uint32_t base;
uint16_t size;
uint64_t offset;
} __packed;
int idt_init(void);
kernel/include/ipc.h
-51
View File
@@ -1,51 +0,0 @@
#ifndef _IPC_H
#define _IPC_H
#include <kernel.h>
/*
* Message contents
*/
// Basic data
struct msg_uint8 { uint8_t data[56]; };
struct msg_uint16 { uint16_t data[28]; };
struct msg_uint32 { uint32_t data[14]; };
struct msg_uint64 { uint64_t data[7]; };
/*
* Message content types
*/
enum {
MSG_UINT8,
MSG_UINT16,
MSG_UINT32,
MSG_UINT64,
};
/*
* Message struct
*/
typedef struct {
pid_t sender;
uint32_t type;
union {
struct msg_uint8 m_uint8;
struct msg_uint16 m_uint16;
struct msg_uint32 m_uint32;
struct msg_uint64 m_uint64;
// Makes sure that ipc_msg_t is at least 64 bytes
uint8_t size[56];
};
} ipc_msg_t __align(16);
// Compile time check that ipc_msg_t is 64 bytes
typedef int __ASSERT_ipc_msg_t[(sizeof(ipc_msg_t) == 64) ? 1 : -1];
/*
* IPC handlers
*/
int ipc_send(pid_t dst, ipc_msg_t* msg);
int ipc_recv(pid_t src, ipc_msg_t* msg);
#endif
kernel/include/isr.h
+12 -8
View File
@@ -3,25 +3,29 @@
#include <kernel.h>
#define ISR_COUNT 16
// Interrupt frame (ie. what's on the stack on interrupt)
struct isr_int_frame {
// Pushed by OS
uint32_t gs, fs, es, ds;
uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax;
uint32_t interrupt, error;
uint64_t ds; // + es
uint64_t r15, r14, r13, r12, r11, r10, r9, r8;
uint64_t rbp, rdi, rsi, rdx, rcx, rbx, rax;
uint64_t interrupt, error;
// Pushed by CPU
uint32_t eip, cs, eflags, user_esp, user_ss;
uint64_t rip, cs, rflags, user_rsp, user_ss;
};
typedef void (*isr_handler_ptr)(struct isr_int_frame* iframe);
int isr_init(void);
int isr_init(void);
void isr_register(uint8_t i, isr_handler_ptr handler);
void isr_handle_interrupt(struct isr_int_frame iframe);
void isr_handle_interrupt(size_t rsp);
// Assembly definitions (isr.s)
extern void isr_return(void);
extern void isr_return(void);
extern void* isr_redirect_table[48]; // ISR Table
extern void isr128(void); // int 0x80 - syscall
extern void isr128(void); // int 0x80 - syscall
extern void isr255(void); // int 0xFF -
#endif
kernel/include/kernel.h
+12 -12
View File
@@ -20,12 +20,11 @@
/*
* Variable arguments
*/
typedef char* va_list;
#define __VA_ALIGN 4
#define __va_align(_t) (((sizeof(_t) + __VA_ALIGN - 1) / __VA_ALIGN) * __VA_ALIGN)
#define va_start(_ap, _arg) ((_ap) = (char*)(&(_arg) + 1))
#define va_arg(_ap, _type) (*(_type*)((_ap += __va_align(_type)) - __va_align(_type)))
#define va_end(_ap) (void)((_ap) = 0)
//typedef struct { unsigned int gp_off; unsigned int fp_off; void *arg_overflow; void *reg_save; } va_list;
typedef __builtin_va_list va_list;
#define va_start(_ap, _last) __builtin_va_start(_ap, _last)
#define va_end(_ap) __builtin_va_end(_ap)
#define va_arg(_ap, _type) __builtin_va_arg(_ap, _type)
/*
* Utility macros
@@ -75,10 +74,10 @@ typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef signed long int64_t;
typedef uint32_t size_t;
typedef int32_t ssize_t;
typedef uint32_t uintptr_t;
typedef int32_t intptr_t;
typedef uint64_t size_t;
typedef int64_t ssize_t;
typedef uint64_t uintptr_t;
typedef int64_t intptr_t;
/*
* Boolean
@@ -95,11 +94,12 @@ typedef uint32_t pid_t;
/*
* Linker defined values
*/
extern uint32_t __kernel_start, __kernel_end;
extern uint32_t __kernel_stack_top, __kernel_stack_bottom;
extern uint64_t __kernel_start, __kernel_text_start, __kernel_rodata_start, __kernel_data_start;
extern uint64_t __kernel_end, __kernel_text_end, __kernel_rodata_end, __kernel_data_end;
/*
* Logging and errors
* TODO: Use something other than debugf()
*/
#include <serial.h>
#define printk debugf
kernel/include/kmalloc.h
-25
View File
@@ -1,25 +0,0 @@
#ifndef _KALLOC_H
#define _KALLOC_H
#include <kernel.h>
// TODO: Set a better minimum that just a random number
#define KMALLOC_MIN_PAGES 4
// kmalloc() singly-linked list node
struct kmalloc_node {
size_t size;
int free;
struct kmalloc_node* next;
};
extern struct kmalloc_node* kmalloc_head;
int kmalloc_init(void);
void* kmalloc(size_t size);
void* kzalloc(size_t size);
void* kcalloc(size_t size, size_t count);
void* krealloc(size_t size, void* ptr);
void kfree(void* ptr);
#endif
kernel/include/limine.h
+771
View File
@@ -0,0 +1,771 @@
/* BSD Zero Clause License */
/* Copyright (C) 2022-2025 Mintsuki and contributors.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef LIMINE_H
#define LIMINE_H 1
#ifdef __cplusplus
extern "C" {
#endif
#include <kernel.h>
/* Misc */
#ifdef LIMINE_NO_POINTERS
# define LIMINE_PTR(TYPE) uint64_t
#else
# define LIMINE_PTR(TYPE) TYPE
#endif
#ifndef LIMINE_API_REVISION
# define LIMINE_API_REVISION 0
#endif
#if LIMINE_API_REVISION > 3
# error "limine.h API revision unsupported"
#endif
#ifdef __GNUC__
# define LIMINE_DEPRECATED __attribute__((__deprecated__))
# define LIMINE_DEPRECATED_IGNORE_START \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
# define LIMINE_DEPRECATED_IGNORE_END \
_Pragma("GCC diagnostic pop")
#else
# define LIMINE_DEPRECATED
# define LIMINE_DEPRECATED_IGNORE_START
# define LIMINE_DEPRECATED_IGNORE_END
#endif
#define LIMINE_REQUESTS_START_MARKER \
uint64_t limine_requests_start_marker[4] = { 0xf6b8f4b39de7d1ae, 0xfab91a6940fcb9cf, \
0x785c6ed015d3e316, 0x181e920a7852b9d9 };
#define LIMINE_REQUESTS_END_MARKER \
uint64_t limine_requests_end_marker[2] = { 0xadc0e0531bb10d03, 0x9572709f31764c62 };
#define LIMINE_REQUESTS_DELIMITER LIMINE_REQUESTS_END_MARKER
#define LIMINE_BASE_REVISION(N) \
uint64_t limine_base_revision[3] = { 0xf9562b2d5c95a6c8, 0x6a7b384944536bdc, (N) };
#define LIMINE_BASE_REVISION_SUPPORTED (limine_base_revision[2] == 0)
#define LIMINE_LOADED_BASE_REV_VALID (limine_base_revision[1] != 0x6a7b384944536bdc)
#define LIMINE_LOADED_BASE_REVISION (limine_base_revision[1])
#define LIMINE_COMMON_MAGIC 0xc7b1dd30df4c8b88, 0x0a82e883a194f07b
struct limine_uuid {
uint32_t a;
uint16_t b;
uint16_t c;
uint8_t d[8];
};
#define LIMINE_MEDIA_TYPE_GENERIC 0
#define LIMINE_MEDIA_TYPE_OPTICAL 1
#define LIMINE_MEDIA_TYPE_TFTP 2
struct limine_file {
uint64_t revision;
LIMINE_PTR(void *) address;
uint64_t size;
LIMINE_PTR(char *) path;
#if LIMINE_API_REVISION >= 3
LIMINE_PTR(char *) string;
#else
LIMINE_PTR(char *) cmdline;
#endif
uint32_t media_type;
uint32_t unused;
uint32_t tftp_ip;
uint32_t tftp_port;
uint32_t partition_index;
uint32_t mbr_disk_id;
struct limine_uuid gpt_disk_uuid;
struct limine_uuid gpt_part_uuid;
struct limine_uuid part_uuid;
};
/* Boot info */
#define LIMINE_BOOTLOADER_INFO_REQUEST { LIMINE_COMMON_MAGIC, 0xf55038d8e2a1202f, 0x279426fcf5f59740 }
struct limine_bootloader_info_response {
uint64_t revision;
LIMINE_PTR(char *) name;
LIMINE_PTR(char *) version;
};
struct limine_bootloader_info_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_bootloader_info_response *) response;
};
/* Executable command line */
#define LIMINE_EXECUTABLE_CMDLINE_REQUEST { LIMINE_COMMON_MAGIC, 0x4b161536e598651e, 0xb390ad4a2f1f303a }
struct limine_executable_cmdline_response {
uint64_t revision;
LIMINE_PTR(char *) cmdline;
};
struct limine_executable_cmdline_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_executable_cmdline_response *) response;
};
/* Firmware type */
#define LIMINE_FIRMWARE_TYPE_REQUEST { LIMINE_COMMON_MAGIC, 0x8c2f75d90bef28a8, 0x7045a4688eac00c3 }
#define LIMINE_FIRMWARE_TYPE_X86BIOS 0
#define LIMINE_FIRMWARE_TYPE_UEFI32 1
#define LIMINE_FIRMWARE_TYPE_UEFI64 2
#define LIMINE_FIRMWARE_TYPE_SBI 3
struct limine_firmware_type_response {
uint64_t revision;
uint64_t firmware_type;
};
struct limine_firmware_type_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_firmware_type_response *) response;
};
/* Stack size */
#define LIMINE_STACK_SIZE_REQUEST { LIMINE_COMMON_MAGIC, 0x224ef0460a8e8926, 0xe1cb0fc25f46ea3d }
struct limine_stack_size_response {
uint64_t revision;
};
struct limine_stack_size_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_stack_size_response *) response;
uint64_t stack_size;
};
/* HHDM */
#define LIMINE_HHDM_REQUEST { LIMINE_COMMON_MAGIC, 0x48dcf1cb8ad2b852, 0x63984e959a98244b }
struct limine_hhdm_response {
uint64_t revision;
uint64_t offset;
};
struct limine_hhdm_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_hhdm_response *) response;
};
/* Framebuffer */
#define LIMINE_FRAMEBUFFER_REQUEST { LIMINE_COMMON_MAGIC, 0x9d5827dcd881dd75, 0xa3148604f6fab11b }
#define LIMINE_FRAMEBUFFER_RGB 1
struct limine_video_mode {
uint64_t pitch;
uint64_t width;
uint64_t height;
uint16_t bpp;
uint8_t memory_model;
uint8_t red_mask_size;
uint8_t red_mask_shift;
uint8_t green_mask_size;
uint8_t green_mask_shift;
uint8_t blue_mask_size;
uint8_t blue_mask_shift;
};
struct limine_framebuffer {
LIMINE_PTR(void *) address;
uint64_t width;
uint64_t height;
uint64_t pitch;
uint16_t bpp;
uint8_t memory_model;
uint8_t red_mask_size;
uint8_t red_mask_shift;
uint8_t green_mask_size;
uint8_t green_mask_shift;
uint8_t blue_mask_size;
uint8_t blue_mask_shift;
uint8_t unused[7];
uint64_t edid_size;
LIMINE_PTR(void *) edid;
/* Response revision 1 */
uint64_t mode_count;
LIMINE_PTR(struct limine_video_mode **) modes;
};
struct limine_framebuffer_response {
uint64_t revision;
uint64_t framebuffer_count;
LIMINE_PTR(struct limine_framebuffer **) framebuffers;
};
struct limine_framebuffer_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_framebuffer_response *) response;
};
/* Terminal */
#define LIMINE_TERMINAL_REQUEST { LIMINE_COMMON_MAGIC, 0xc8ac59310c2b0844, 0xa68d0c7265d38878 }
#define LIMINE_TERMINAL_CB_DEC 10
#define LIMINE_TERMINAL_CB_BELL 20
#define LIMINE_TERMINAL_CB_PRIVATE_ID 30
#define LIMINE_TERMINAL_CB_STATUS_REPORT 40
#define LIMINE_TERMINAL_CB_POS_REPORT 50
#define LIMINE_TERMINAL_CB_KBD_LEDS 60
#define LIMINE_TERMINAL_CB_MODE 70
#define LIMINE_TERMINAL_CB_LINUX 80
#define LIMINE_TERMINAL_CTX_SIZE ((uint64_t)(-1))
#define LIMINE_TERMINAL_CTX_SAVE ((uint64_t)(-2))
#define LIMINE_TERMINAL_CTX_RESTORE ((uint64_t)(-3))
#define LIMINE_TERMINAL_FULL_REFRESH ((uint64_t)(-4))
/* Response revision 1 */
#define LIMINE_TERMINAL_OOB_OUTPUT_GET ((uint64_t)(-10))
#define LIMINE_TERMINAL_OOB_OUTPUT_SET ((uint64_t)(-11))
#define LIMINE_TERMINAL_OOB_OUTPUT_OCRNL (1 << 0)
#define LIMINE_TERMINAL_OOB_OUTPUT_OFDEL (1 << 1)
#define LIMINE_TERMINAL_OOB_OUTPUT_OFILL (1 << 2)
#define LIMINE_TERMINAL_OOB_OUTPUT_OLCUC (1 << 3)
#define LIMINE_TERMINAL_OOB_OUTPUT_ONLCR (1 << 4)
#define LIMINE_TERMINAL_OOB_OUTPUT_ONLRET (1 << 5)
#define LIMINE_TERMINAL_OOB_OUTPUT_ONOCR (1 << 6)
#define LIMINE_TERMINAL_OOB_OUTPUT_OPOST (1 << 7)
LIMINE_DEPRECATED_IGNORE_START
struct LIMINE_DEPRECATED limine_terminal;
typedef void (*limine_terminal_write)(struct limine_terminal *, const char *, uint64_t);
typedef void (*limine_terminal_callback)(struct limine_terminal *, uint64_t, uint64_t, uint64_t, uint64_t);
struct LIMINE_DEPRECATED limine_terminal {
uint64_t columns;
uint64_t rows;
LIMINE_PTR(struct limine_framebuffer *) framebuffer;
};
struct LIMINE_DEPRECATED limine_terminal_response {
uint64_t revision;
uint64_t terminal_count;
LIMINE_PTR(struct limine_terminal **) terminals;
LIMINE_PTR(limine_terminal_write) write;
};
struct LIMINE_DEPRECATED limine_terminal_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_terminal_response *) response;
LIMINE_PTR(limine_terminal_callback) callback;
};
LIMINE_DEPRECATED_IGNORE_END
/* Paging mode */
#define LIMINE_PAGING_MODE_REQUEST { LIMINE_COMMON_MAGIC, 0x95c1a0edab0944cb, 0xa4e5cb3842f7488a }
#if defined (__x86_64__) || defined (__i386__)
#define LIMINE_PAGING_MODE_X86_64_4LVL 0
#define LIMINE_PAGING_MODE_X86_64_5LVL 1
#define LIMINE_PAGING_MODE_MIN LIMINE_PAGING_MODE_X86_64_4LVL
#define LIMINE_PAGING_MODE_DEFAULT LIMINE_PAGING_MODE_X86_64_4LVL
#elif defined (__aarch64__)
#define LIMINE_PAGING_MODE_AARCH64_4LVL 0
#define LIMINE_PAGING_MODE_AARCH64_5LVL 1
#define LIMINE_PAGING_MODE_MIN LIMINE_PAGING_MODE_AARCH64_4LVL
#define LIMINE_PAGING_MODE_DEFAULT LIMINE_PAGING_MODE_AARCH64_4LVL
#elif defined (__riscv) && (__riscv_xlen == 64)
#define LIMINE_PAGING_MODE_RISCV_SV39 0
#define LIMINE_PAGING_MODE_RISCV_SV48 1
#define LIMINE_PAGING_MODE_RISCV_SV57 2
#define LIMINE_PAGING_MODE_MIN LIMINE_PAGING_MODE_RISCV_SV39
#define LIMINE_PAGING_MODE_DEFAULT LIMINE_PAGING_MODE_RISCV_SV48
#elif defined (__loongarch__) && (__loongarch_grlen == 64)
#define LIMINE_PAGING_MODE_LOONGARCH64_4LVL 0
#define LIMINE_PAGING_MODE_MIN LIMINE_PAGING_MODE_LOONGARCH64_4LVL
#define LIMINE_PAGING_MODE_DEFAULT LIMINE_PAGING_MODE_LOONGARCH64_4LVL
#else
#error Unknown architecture
#endif
struct limine_paging_mode_response {
uint64_t revision;
uint64_t mode;
};
struct limine_paging_mode_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_paging_mode_response *) response;
uint64_t mode;
uint64_t max_mode;
uint64_t min_mode;
};
/* 5-level paging */
#define LIMINE_5_LEVEL_PAGING_REQUEST { LIMINE_COMMON_MAGIC, 0x94469551da9b3192, 0xebe5e86db7382888 }
LIMINE_DEPRECATED_IGNORE_START
struct LIMINE_DEPRECATED limine_5_level_paging_response {
uint64_t revision;
};
struct LIMINE_DEPRECATED limine_5_level_paging_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_5_level_paging_response *) response;
};
LIMINE_DEPRECATED_IGNORE_END
/* MP */
#if LIMINE_API_REVISION >= 1
# define LIMINE_MP_REQUEST { LIMINE_COMMON_MAGIC, 0x95a67b819a1b857e, 0xa0b61b723b6a73e0 }
# define LIMINE_MP(TEXT) limine_mp_##TEXT
#else
# define LIMINE_SMP_REQUEST { LIMINE_COMMON_MAGIC, 0x95a67b819a1b857e, 0xa0b61b723b6a73e0 }
# define LIMINE_MP(TEXT) limine_smp_##TEXT
#endif
struct LIMINE_MP(info);
typedef void (*limine_goto_address)(struct LIMINE_MP(info) *);
#if defined (__x86_64__) || defined (__i386__)
#if LIMINE_API_REVISION >= 1
# define LIMINE_MP_X2APIC (1 << 0)
#else
# define LIMINE_SMP_X2APIC (1 << 0)
#endif
struct LIMINE_MP(info) {
uint32_t processor_id;
uint32_t lapic_id;
uint64_t reserved;
LIMINE_PTR(limine_goto_address) goto_address;
uint64_t extra_argument;
};
struct LIMINE_MP(response) {
uint64_t revision;
uint32_t flags;
uint32_t bsp_lapic_id;
uint64_t cpu_count;
LIMINE_PTR(struct LIMINE_MP(info) **) cpus;
};
#elif defined (__aarch64__)
struct LIMINE_MP(info) {
uint32_t processor_id;
uint32_t reserved1;
uint64_t mpidr;
uint64_t reserved;
LIMINE_PTR(limine_goto_address) goto_address;
uint64_t extra_argument;
};
struct LIMINE_MP(response) {
uint64_t revision;
uint64_t flags;
uint64_t bsp_mpidr;
uint64_t cpu_count;
LIMINE_PTR(struct LIMINE_MP(info) **) cpus;
};
#elif defined (__riscv) && (__riscv_xlen == 64)
struct LIMINE_MP(info) {
uint64_t processor_id;
uint64_t hartid;
uint64_t reserved;
LIMINE_PTR(limine_goto_address) goto_address;
uint64_t extra_argument;
};
struct LIMINE_MP(response) {
uint64_t revision;
uint64_t flags;
uint64_t bsp_hartid;
uint64_t cpu_count;
LIMINE_PTR(struct LIMINE_MP(info) **) cpus;
};
#elif defined (__loongarch__) && (__loongarch_grlen == 64)
struct LIMINE_MP(info) {
uint64_t reserved;
};
struct LIMINE_MP(response) {
uint64_t cpu_count;
LIMINE_PTR(struct LIMINE_MP(info) **) cpus;
};
#else
#error Unknown architecture
#endif
struct LIMINE_MP(request) {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct LIMINE_MP(response) *) response;
uint64_t flags;
};
/* Memory map */
#define LIMINE_MEMMAP_REQUEST { LIMINE_COMMON_MAGIC, 0x67cf3d9d378a806f, 0xe304acdfc50c3c62 }
#define LIMINE_MEMMAP_USABLE 0
#define LIMINE_MEMMAP_RESERVED 1
#define LIMINE_MEMMAP_ACPI_RECLAIMABLE 2
#define LIMINE_MEMMAP_ACPI_NVS 3
#define LIMINE_MEMMAP_BAD_MEMORY 4
#define LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE 5
#if LIMINE_API_REVISION >= 2
# define LIMINE_MEMMAP_EXECUTABLE_AND_MODULES 6
#else
# define LIMINE_MEMMAP_KERNEL_AND_MODULES 6
#endif
#define LIMINE_MEMMAP_FRAMEBUFFER 7
struct limine_memmap_entry {
uint64_t base;
uint64_t length;
uint64_t type;
};
struct limine_memmap_response {
uint64_t revision;
uint64_t entry_count;
LIMINE_PTR(struct limine_memmap_entry **) entries;
};
struct limine_memmap_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_memmap_response *) response;
};
/* Entry point */
#define LIMINE_ENTRY_POINT_REQUEST { LIMINE_COMMON_MAGIC, 0x13d86c035a1cd3e1, 0x2b0caa89d8f3026a }
typedef void (*limine_entry_point)(void);
struct limine_entry_point_response {
uint64_t revision;
};
struct limine_entry_point_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_entry_point_response *) response;
LIMINE_PTR(limine_entry_point) entry;
};
/* Executable File */
#if LIMINE_API_REVISION >= 2
# define LIMINE_EXECUTABLE_FILE_REQUEST { LIMINE_COMMON_MAGIC, 0xad97e90e83f1ed67, 0x31eb5d1c5ff23b69 }
#else
# define LIMINE_KERNEL_FILE_REQUEST { LIMINE_COMMON_MAGIC, 0xad97e90e83f1ed67, 0x31eb5d1c5ff23b69 }
#endif
#if LIMINE_API_REVISION >= 2
struct limine_executable_file_response {
#else
struct limine_kernel_file_response {
#endif
uint64_t revision;
#if LIMINE_API_REVISION >= 2
LIMINE_PTR(struct limine_file *) executable_file;
#else
LIMINE_PTR(struct limine_file *) kernel_file;
#endif
};
#if LIMINE_API_REVISION >= 2
struct limine_executable_file_request {
#else
struct limine_kernel_file_request {
#endif
uint64_t id[4];
uint64_t revision;
#if LIMINE_API_REVISION >= 2
LIMINE_PTR(struct limine_executable_file_response *) response;
#else
LIMINE_PTR(struct limine_kernel_file_response *) response;
#endif
};
/* Module */
#define LIMINE_MODULE_REQUEST { LIMINE_COMMON_MAGIC, 0x3e7e279702be32af, 0xca1c4f3bd1280cee }
#define LIMINE_INTERNAL_MODULE_REQUIRED (1 << 0)
#define LIMINE_INTERNAL_MODULE_COMPRESSED (1 << 1)
struct limine_internal_module {
LIMINE_PTR(const char *) path;
#if LIMINE_API_REVISION >= 3
LIMINE_PTR(const char *) string;
#else
LIMINE_PTR(const char *) cmdline;
#endif
uint64_t flags;
};
struct limine_module_response {
uint64_t revision;
uint64_t module_count;
LIMINE_PTR(struct limine_file **) modules;
};
struct limine_module_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_module_response *) response;
/* Request revision 1 */
uint64_t internal_module_count;
LIMINE_PTR(struct limine_internal_module **) internal_modules;
};
/* RSDP */
#define LIMINE_RSDP_REQUEST { LIMINE_COMMON_MAGIC, 0xc5e77b6b397e7b43, 0x27637845accdcf3c }
struct limine_rsdp_response {
uint64_t revision;
#if LIMINE_API_REVISION >= 1
uint64_t address;
#else
LIMINE_PTR(void *) address;
#endif
};
struct limine_rsdp_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_rsdp_response *) response;
};
/* SMBIOS */
#define LIMINE_SMBIOS_REQUEST { LIMINE_COMMON_MAGIC, 0x9e9046f11e095391, 0xaa4a520fefbde5ee }
struct limine_smbios_response {
uint64_t revision;
#if LIMINE_API_REVISION >= 1
uint64_t entry_32;
uint64_t entry_64;
#else
LIMINE_PTR(void *) entry_32;
LIMINE_PTR(void *) entry_64;
#endif
};
struct limine_smbios_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_smbios_response *) response;
};
/* EFI system table */
#define LIMINE_EFI_SYSTEM_TABLE_REQUEST { LIMINE_COMMON_MAGIC, 0x5ceba5163eaaf6d6, 0x0a6981610cf65fcc }
struct limine_efi_system_table_response {
uint64_t revision;
#if LIMINE_API_REVISION >= 1
uint64_t address;
#else
LIMINE_PTR(void *) address;
#endif
};
struct limine_efi_system_table_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_efi_system_table_response *) response;
};
/* EFI memory map */
#define LIMINE_EFI_MEMMAP_REQUEST { LIMINE_COMMON_MAGIC, 0x7df62a431d6872d5, 0xa4fcdfb3e57306c8 }
struct limine_efi_memmap_response {
uint64_t revision;
LIMINE_PTR(void *) memmap;
uint64_t memmap_size;
uint64_t desc_size;
uint64_t desc_version;
};
struct limine_efi_memmap_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_efi_memmap_response *) response;
};
/* Date at boot */
#if LIMINE_API_REVISION >= 3
# define LIMINE_DATE_AT_BOOT_REQUEST { LIMINE_COMMON_MAGIC, 0x502746e184c088aa, 0xfbc5ec83e6327893 }
#else
# define LIMINE_BOOT_TIME_REQUEST { LIMINE_COMMON_MAGIC, 0x502746e184c088aa, 0xfbc5ec83e6327893 }
#endif
#if LIMINE_API_REVISION >= 3
struct limine_date_at_boot_response {
#else
struct limine_boot_time_response {
#endif
uint64_t revision;
#if LIMINE_API_REVISION >= 3
int64_t timestamp;
#else
int64_t boot_time;
#endif
};
#if LIMINE_API_REVISION >= 3
struct limine_date_at_boot_request {
#else
struct limine_boot_time_request {
#endif
uint64_t id[4];
uint64_t revision;
#if LIMINE_API_REVISION >= 3
LIMINE_PTR(struct limine_date_at_boot_response *) response;
#else
LIMINE_PTR(struct limine_boot_time_response *) response;
#endif
};
/* Executable address */
#if LIMINE_API_REVISION >= 2
# define LIMINE_EXECUTABLE_ADDRESS_REQUEST { LIMINE_COMMON_MAGIC, 0x71ba76863cc55f63, 0xb2644a48c516a487 }
#else
# define LIMINE_KERNEL_ADDRESS_REQUEST { LIMINE_COMMON_MAGIC, 0x71ba76863cc55f63, 0xb2644a48c516a487 }
#endif
#if LIMINE_API_REVISION >= 2
struct limine_executable_address_response {
#else
struct limine_kernel_address_response {
#endif
uint64_t revision;
uint64_t physical_base;
uint64_t virtual_base;
};
#if LIMINE_API_REVISION >= 2
struct limine_executable_address_request {
#else
struct limine_kernel_address_request {
#endif
uint64_t id[4];
uint64_t revision;
#if LIMINE_API_REVISION >= 2
LIMINE_PTR(struct limine_executable_address_response *) response;
#else
LIMINE_PTR(struct limine_kernel_address_response *) response;
#endif
};
/* Device Tree Blob */
#define LIMINE_DTB_REQUEST { LIMINE_COMMON_MAGIC, 0xb40ddb48fb54bac7, 0x545081493f81ffb7 }
struct limine_dtb_response {
uint64_t revision;
LIMINE_PTR(void *) dtb_ptr;
};
struct limine_dtb_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_dtb_response *) response;
};
/* RISC-V Boot Hart ID */
#define LIMINE_RISCV_BSP_HARTID_REQUEST { LIMINE_COMMON_MAGIC, 0x1369359f025525f9, 0x2ff2a56178391bb6 }
struct limine_riscv_bsp_hartid_response {
uint64_t revision;
uint64_t bsp_hartid;
};
struct limine_riscv_bsp_hartid_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_riscv_bsp_hartid_response *) response;
};
/* Bootloader Performance */
#define LIMINE_BOOTLOADER_PERFORMANCE_REQUEST { LIMINE_COMMON_MAGIC, 0x6b50ad9bf36d13ad, 0xdc4c7e88fc759e17 }
struct limine_bootloader_performance_response {
uint64_t revision;
uint64_t reset_usec;
uint64_t init_usec;
uint64_t exec_usec;
};
struct limine_bootloader_performance_request {
uint64_t id[4];
uint64_t revision;
LIMINE_PTR(struct limine_bootloader_performance_response *) response;
};
#ifdef __cplusplus
}
#endif
#endif
kernel/include/paging.h
+26 -31
View File
@@ -3,39 +3,34 @@
#include <kernel.h>
#define PHYS_ADDR(_a) ((_a) & ~0xFFF)
#define PAGE_FLAG_PRESENT (1 << 0) // Page is present in the table
#define PAGE_FLAG_WRITE (1 << 1) // Read-write
#define PAGE_FLAG_USER (1 << 2) // User-mode (DPL3) access allowed
#define PAGE_FLAG_PWT (1 << 3) // Page write-thru
#define PAGE_FLAG_NOCACHE (1 << 4) // Cache disable
#define PAGE_FLAG_ACCESSED (1 << 5) // Indicates whether page was accessed
#define PAGE_FLAG_DIRTY (1 << 6) // Page size (valid for PD and PDPT only)
#define PAGE_FLAG_PAT (1 << 7) // Page Attribute Table (valid for PT only)
#define PAGE_FLAG_GLOBAL (1 << 8) // Indicates the page is globally cached
#define PAGE_FLAG_SHARED (1 << 9) // Userland page is shared
// Region caching according to the Limine protocol
#define PAGE_FLAG_CACHE (PAGE_FLAG_PWT | PAGE_FLAG_PAT)
// The kernels pagedir
#define PAGEDIR ((uint32_t*)(0xFFFFF000))
#define PAGETAB(_i) ((uint32_t*)(0xFFC00000 + ((_i) << 12)))
#define PAGE_SIZE 0x1000
#define PAGE_SIZE_LARGE 0x200000
#define PAGE_SIZE_HUGE 0x40000000
#define PAGE_SIZE 4096
#define PHYS_ADDR(_x) ((_x) & ~0xFFF)
#define PAGE_FLAG_PRESENT (1 << 0)
#define PAGE_FLAG_WRITE (1 << 1)
#define PAGE_FLAG_USER (1 << 2)
#define PAGE_FLAG_PWT (1 << 3)
#define PAGE_FLAG_NOCACHE (1 << 4)
#define PAGE_FLAG_ACCESSED (1 << 5)
#define PAGE_FLAG_DIRTY (1 << 6) // AVL in PDE where PS = 0
#define PAGE_FLAG_PS (1 << 7) // If PS = 1 then directly maps a 4MB page
#define PAGE_FLAG_GLOBAL (1 << 8)
// bits 9-11 are AVL - OS is free to use these as its own flags
#define PAGE_FLAG_OWNER (1 << 9)
extern uint32_t init_pagedir[1024]; // Defined in entry.s for initial paging
extern size_t pag_page_count;
int pag_init(void);
void pag_register_temp_frame(uint32_t target);
uint32_t pag_temp_frame(void);
void pag_map(uint32_t vaddr, uint32_t paddr, uint32_t flags);
uint32_t pag_umap(uint32_t vaddr);
uint32_t pag_virt_to_phys(uint32_t vaddr);
uint32_t* pag_get_pagedir();
void pag_set_pagedir(uint32_t* pagedir);
void pag_sync_pagedir();
uint32_t* pag_alloc_pagedir();
void pag_free_pagedir(uint32_t* pagedir);
int pag_init(void);
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);
#endif
kernel/include/pmm.h
+2 -2
View File
@@ -7,7 +7,7 @@
extern bitmap_t pmm_bitmap;
int pmm_init(void);
uint32_t pmm_alloc(void);
void pmm_free(uint32_t page);
size_t pmm_alloc(void);
void pmm_free(size_t page);
#endif
kernel/include/sched.h
-9
View File
@@ -1,9 +0,0 @@
#ifndef _SCHED_H
#define _SCHED_H
// Amount of CPU time each process gets (in ms)
#define SCHED_QUANTUM 40
void schedule(void);
#endif
kernel/include/syscall.h
-22
View File
@@ -1,22 +0,0 @@
#ifndef _SYSCALL_H
#define _SYSCALL_H
#include <kernel.h>
#include <ipc.h>
#include <isr.h>
#define SYSCALL_MAX 16
enum {
SYS_SEND,
SYS_RECV,
};
int syscall_init(void);
void syscall_register(size_t idx, void* handler);
void syscall_handler(struct isr_int_frame* iframe);
// Syscall handlers
int sys_send(pid_t dst, ipc_msg_t* msg);
int sys_recv(pid_t src, ipc_msg_t* msg);
#endif
kernel/include/task.h
-73
View File
@@ -1,73 +0,0 @@
#ifndef _TASK_H
#define _TASK_H
#include <kernel.h>
#define TASK_KERNEL 0 // Main kernel task ID
enum {
TASK_STATE_DEAD,
TASK_STATE_IDLE,
TASK_STATE_READY,
TASK_STATE_RECV,
};
/*
* Each task has an ID. This is used as a reference to the task.
* A task has it's own paging setup, so it must have it's own pagedir.
* Tasks have state. These states are defined as follows:
* TASK_STATE_DEAD - This task has been killed
* TASK_STATE_READY - This task is ready for scheduling
* TASK_STATE_IDLE - This task doesn't need processor time
* Each task has it's own kernel stack to push registers and such to when
* context switching. To switch to a task, you load kstack_pointer into ESP and
* pop the state.
* The kstack_bottom is loaded into ESP using the TSS when switching from user
* to kernel space on interrupts.
* Tasks are stored in a linked list, so it must have a reference to the next
* task.
*
* WARN: Be careful when modifing this struct, it's contents are accessed from
* task.s which uses hardcoded offsets.
*/
struct task {
pid_t id;
size_t kstack_pointer;
size_t kstack_bottom;
uint32_t* pagedir;
uint8_t state;
int kernel_task;
size_t heap_start;
size_t heap_end;
struct task* next;
};
// Describes contents of the kstack when task switching
struct task_switch_ctx {
uint32_t edi;
uint32_t esi;
uint32_t ebx;
uint32_t ebp;
uint32_t eip;
};
extern struct task* task_first;
extern struct task* task_current;
int task_init(void);
void task_create(pid_t id, uint32_t eip, int kernel_task, uint32_t* pagedir, int argc, char** argv);
void task_kill(pid_t id);
void task_set_user_heap(pid_t id, size_t heap_end);
struct task* task_get(pid_t id);
uint8_t task_get_state(pid_t id);
void task_set_state(pid_t id, uint8_t state);
pid_t task_create_id(void);
// Defined in task.s
extern void task_switch(struct task* old, struct task* new);
#endif
kernel/include/tty.h
-19
View File
@@ -1,19 +0,0 @@
#ifndef _TTY_H
#define _TTY_H
/* VGA Text mode */
#define VGA_ATTR(_fg, _bg) ((_fg) | ((_bg) << 4)
#define VGA_WIDTH 80
#define VGA_HEIGHT 25
#define VGA_MEMORY 0xb8000
int tty_init(void);
void tty_clear(void);
void tty_set_attr(uint8_t attr);
void tty_show_cursor(uint8_t start, uint8_t end);
void tty_hide_cursor(void);
void tty_write(char* buf, size_t len);
void tty_putc(char c);
void tty_puts(char* s);
#endif
kernel/include/vsnprintf.h
+2 -1
View File
@@ -3,6 +3,7 @@
#include <kernel.h>
int vsnprintf(char* buf, size_t len, char* fmt, va_list args);
int snprintf(char *buf, size_t n, char *fmt, ...);
int vsnprintf(char* buf, size_t n, char* fmt, va_list ap);
#endif
kernel/linker.ld
+37 -22
View File
@@ -1,35 +1,50 @@
OUTPUT_FORMAT("elf32-i386")
OUTPUT_ARCH("i386");
OUTPUT_FORMAT(elf64-x86-64)
OUTPUT_ARCH(i386:x86-64);
ENTRY(_start)
/* Define sections */
/* Program headers for MMU permissions */
PHDRS {
text PT_LOAD FLAGS((1 << 0) | (1 << 2)); /* xr */
rodata PT_LOAD FLAGS((1 << 2)); /* ro */
data PT_LOAD FLAGS((1 << 1) | (1 << 2)); /* rw */
}
SECTIONS {
. = 0x00100000;
. = 0xffffffff80000000;
__kernel_start = .;
__kernel_text_start = .;
.text : {
*(.text .text.*)
} :text
__kernel_text_end = .;
.boot ALIGN(4K) : {
*(.multiboot)
*(.boot)
}
. = ALIGN(CONSTANT(MAXPAGESIZE));
. += 0xC0000000;
__kernel_rodata_start = .;
.rodata : {
*(.rodata .rodata.*)
} :rodata
__kernel_rodata_end = .;
.text ALIGN(4K) : AT(ADDR(.text) - 0xC0000000) {
*(.text)
}
. = ALIGN(CONSTANT(MAXPAGESIZE));
.rodata ALIGN(4K) : AT(ADDR(.rodata) - 0xC0000000) {
*(.rodata)
}
__kernel_data_start = .;
.data : {
*(.data .data.*)
} :data
.data ALIGN(4K) : AT(ADDR(.data) - 0xC0000000) {
*(.data)
}
.bss ALIGN(4K) : AT(ADDR(.bss) - 0xC0000000) {
/* NOTE: .bss should be the last thing mapped to :data */
.bss : {
*(.bss .bss.*)
*(COMMON)
*(.bss)
}
} :data
__kernel_data_end = .;
/* Discard .note* and .eh_frame* (wtf is an eh_frame??) to prevent issues */
/DISCARD/ : {
*(.eh_frame)
*(.note .note.*)
}
__kernel_end = .;
}
kernel/makefile
+6 -2
View File
@@ -1,4 +1,4 @@
include ../defaults.mk
include ../config.mk
SRC = ./src
BIN = ./bin
@@ -10,6 +10,10 @@ OBJS_S = $(patsubst $(SRC)/%.s, $(BIN)/%.s.o, $(SRCS_S))
OUT = $(SYSROOT)/boot/kernel.elf
LINKER = ./linker.ld
# Stack Canary
SSP := 0x$(shell openssl rand -hex 8)
CCFLAGS += -DSTACK_CHK_GUARD=$(SSP)
.PHONY: all clean
all: $(OUT)
$(OUT): $(OBJS_C) $(OBJS_S)
@@ -21,7 +25,7 @@ $(BIN)/%.c.o: $(SRC)/%.c
$(BIN)/%.s.o: $(SRC)/%.s
@mkdir -p $(dir $@)
$(AS) $(ASFLAGS) -felf32 -o $@ $^
$(AS) $(ASFLAGS) -o $@ $^
clean:
rm -fr $(BIN) $(OUT)
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;
}