mirror of
https://github.com/Tom-on64/kern.git
synced 2026-11-03 18:22:22 +00:00
The great 64-bit rewrite
* 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:
+16
-51
@@ -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
|
||||
|
||||
+43
-47
@@ -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
|
||||
|
||||
+18
-8
@@ -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);
|
||||
|
||||
@@ -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
|
||||
+12
-8
@@ -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
|
||||
|
||||
+12
-12
@@ -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
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
+26
-31
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user