Initial commit

src/Makefile

@@ -0,0 +1,12 @@
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+subdirs := arch/$(TARGET)/ include video
+OBJPATH=$(OBJDIR)
+export
+
+all: $(subdirs) $(objects)
+	for subdir in $(subdirs) ; do $(MAKE) -C $${subdir} ; done
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ $<
+	mkdir -p $(OBJPATH) 
+	cp $@ $(OBJPATH)/$@

src/arch/x86_64/Makefile

@@ -0,0 +1,13 @@
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+subdirs=boot
+OBJPATH=$(OBJDIR)/arch/${TARGET}/
+export
+
+all: $(objects) $(subdirs)
+	for subdir in $(subdirs) ; do $(MAKE) -C $${subdir} ; done
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ $<
+	mkdir -p $(OBJPATH) 
+	cp $@ $(OBJPATH)/$@
+

src/arch/x86_64/boot/Makefile

@@ -0,0 +1,10 @@
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+OBJPATH=$(OBJDIR)/arch/$(TARGET)/boot
+export
+
+all: $(objects)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ $<
+	mkdir -p $(OBJPATH) 
+	cp $@ $(OBJPATH)/$@

src/arch/x86_64/boot/entry.c

@@ -0,0 +1,9 @@
+extern void kmain();
+
+extern void _start(){
+	
+	kmain();
+	
+	asm("cli;hlt;");
+
+}

src/arch/x86_64/cls.c

@@ -0,0 +1,18 @@
+#include <arch/cls.h>
+#include <arch/msr.h>
+#include <stdint.h>
+
+cls_t bspcls;
+
+
+void arch_setcls(void* addr){
+	wrmsr(MSR_GSBASE, (uint64_t)addr);
+}
+
+void* arch_getcls(){
+	return (void*)rdmsr(MSR_GSBASE);
+}
+
+void bsp_setcls(){
+	arch_setcls(&bspcls);
+}

src/arch/x86_64/gdt.c

@@ -0,0 +1,52 @@
+#include <arch/cls.h>
+#include <arch/gdt.h>
+#include <arch/ist.h>
+
+static void setseg(segdesc __seg_gs *seg, uint32_t limit, uint32_t offset, uint8_t flags, uint8_t access){
+
+}
+
+static void setsys64(sys64 __seg_gs *e, uint32_t limit, uint64_t offset, uint8_t flags, uint8_t access){
+
+}
+
+static void reloadgdtr(){
+	gdtr_t gdtr;	
+	gdtr.offset = (uint64_t)&cls->gdt + arch_getcls();
+	gdtr.size   = sizeof(gdt_t) - 1;
+
+	asm("lgdt (%%rax)" : : "a"(&gdtr) : "memory");
+}
+
+void gdt_bspinit(){
+
+	gdt_t __seg_gs *gdt = &cls->gdt;
+	
+	setseg(&gdt->null, 0, 0, 0, 0);
+
+	setseg(&gdt->kcode16, 0xFFFFF, 0, FLAGS_PAGE_GRANULARITY, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_EXEC | ACCESS_CODE_READ);
+	
+	setseg(&gdt->kdata16, 0xFFFFF, 0, FLAGS_PAGE_GRANULARITY, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_DATA_WRITE);
+	
+	setseg(&gdt->kcode32, 0xFFFFF, 0, FLAGS_PAGE_GRANULARITY | FLAGS_PMODE, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_CODE_READ);
+	
+	setseg(&gdt->kdata32, 0xFFFFF, 0, FLAGS_PAGE_GRANULARITY | FLAGS_PMODE, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_DATA_WRITE);
+	
+	setseg(&gdt->kcode64, 0, 0, FLAGS_PAGE_GRANULARITY | FLAGS_LONG, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_EXEC | ACCESS_CODE_READ);
+	
+	setseg(&gdt->kdata64, 0, 0, FLAGS_PAGE_GRANULARITY | FLAGS_LONG, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_DATA_WRITE);
+	
+
+	setseg(&gdt->kcode64, 0, 0, FLAGS_PAGE_GRANULARITY | FLAGS_LONG, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_EXEC | ACCESS_CODE_READ | ACCESS_DPL3);
+	
+	setseg(&gdt->kdata64, 0, 0, FLAGS_PAGE_GRANULARITY | FLAGS_LONG, ACCESS_PRESENT | ACCESS_SEGMENT | ACCESS_DATA_WRITE | ACCESS_DPL3);
+	
+	// TODO get this working right
+
+	//setsys64(&gdt->ist, sizeof(ist_t), (uint64_t)(arch_getcls()), FLAGS_LONG, SYSTEM_TYPE_IST | ACCESS_PRESENT);
+
+	reloadgdtr();
+
+
+	
+}

src/arch/x86_64/include/arch/cls.h

@@ -0,0 +1,22 @@
+#ifndef _CLS_H_INCLUDE
+#define _CLS_H_INCLUDE
+
+#include <arch/gdt.h>
+#include <arch/ist.h>
+
+// cpu level storage
+// this will be pointed to by GS and will contain per cpu info
+
+typedef struct{
+	gdt_t gdt;
+	ist_t ist;
+} cls_t;
+
+void bsp_setcls();
+void arch_setcls(void* addr);
+void* arch_getcls();
+
+static cls_t __seg_gs *cls = 0;
+
+
+#endif

src/arch/x86_64/include/arch/gdt.h

@@ -0,0 +1,57 @@
+#ifndef _GDT_H_INCLUDE
+#define _GDT_H_INCLUDE
+
+#define ACCESS_PRESENT (1 << 7)
+#define ACCESS_DPL3    (3 << 5)
+#define ACCESS_SEGMENT (1 << 4)
+#define ACCESS_EXEC    (1 << 3)
+#define ACCESS_DIR     (1 << 2)
+#define ACCESS_CONFORM (1 << 2)
+#define ACCESS_CODE_READ (1 << 1)
+#define ACCESS_DATA_WRITE (1 << 1)
+
+#define FLAGS_LONG (1 << 1)
+#define FLAGS_PMODE (1 << 2)
+#define FLAGS_PAGE_GRANULARITY (1 << 3)
+
+#define SYSTEM_TYPE_IST 0x9
+
+#include <stdint.h>
+
+typedef struct{
+	uint16_t size;
+	uint64_t offset;
+} __attribute__((packed)) gdtr_t;
+
+typedef struct{
+	uint16_t limit;
+	uint16_t offset1;
+	uint8_t	 offset2;
+	uint8_t	 access;
+	uint8_t	 flags;
+	uint8_t	 offset3;
+} __attribute__((packed)) segdesc;
+
+typedef struct{
+	uint16_t limit;
+	uint16_t offset1;
+	uint8_t  offset2;
+	uint8_t  access;
+	uint8_t flags;
+	uint8_t offset3;
+	uint32_t offset4;
+	uint32_t reserved;
+} __attribute__((packed)) sys64;
+
+typedef struct{ 
+	segdesc null;
+	segdesc kcode16;
+	segdesc kdata16;
+	segdesc kcode32;
+	segdesc kdata32;
+	segdesc kcode64;
+	segdesc kdata64;
+	sys64 ist;
+} gdt_t;
+
+#endif

src/arch/x86_64/include/arch/ist.h

@@ -0,0 +1,23 @@
+#ifndef _IST_H_INCLUDE
+#define _IST_H_INCLUDE
+
+#include <stdint.h>
+
+typedef struct{
+	uint32_t IOPB;
+	uint64_t reserved3;
+	uint64_t ist7;
+	uint64_t ist6;
+	uint64_t ist5;
+	uint64_t ist4;
+	uint64_t ist3;
+	uint64_t ist2;
+	uint64_t ist1;
+	uint64_t reserved2;
+	uint64_t rsp2;
+	uint64_t rsp1;
+	uint64_t rsp0;
+	uint64_t reserved;
+} __attribute((packed)) ist_t;
+
+#endif

src/arch/x86_64/include/arch/msr.h

@@ -0,0 +1,23 @@
+#ifndef _MSR_H_INCLUDE
+#define _MSR_H_INCLUDE
+
+#include <stdint.h>
+
+#define MSR_FSBASE 0xC0000100
+#define MSR_GSBASE 0xC0000101
+#define MSR_KERNELGSBASE 0xC0000102
+
+static inline uint64_t rdmsr(uint32_t which){
+	uint64_t low,high;
+	asm volatile("rdmsr" : "=a"(low), "=d"(high) : "c"(which));
+	return (high << 32) | low;
+
+}
+
+static inline void wrmsr(uint32_t which, uint64_t value){
+	uint32_t low = value & 0xFFFFFFFF;
+	uint32_t high = (value >> 32) & 0xFFFFFFFF;
+		asm volatile("wrmsr" : : "a"(low), "d"(high), "c"(which));
+}
+
+#endif

src/arch/x86_64/main.c

@@ -0,0 +1,33 @@
+#include <limine.h>
+#include <kernel/console.h>
+#include <arch/cls.h>
+
+static volatile struct limine_terminal_request liminettyr = {
+    .id = LIMINE_TERMINAL_REQUEST,
+    .revision = 0
+};
+
+struct limine_terminal_response* liminetty;
+
+void liminewrite(char* str, size_t c){
+	
+	liminetty->write(liminetty->terminals[0], str, c);
+
+}
+
+void kmain(){
+	if(!liminettyr.response)
+		return;
+
+	liminetty = liminettyr.response;
+	liminetty->write += 0xFFFF800000000000;
+	
+	console_setwritehook(liminewrite);
+	
+	bsp_setcls();
+
+
+
+}
+
+

src/include/Makefile

@@ -0,0 +1,12 @@
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+subdirs := stdio string
+OBJPATH=$(OBJDIR)/include
+export
+
+all: $(subdirs) $(objects)
+	for subdir in $(subdirs) ; do $(MAKE) -C $${subdir} ; done
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ $<
+	mkdir -p $(OBJPATH) 
+	cp $@ $(OBJPATH)/$@

src/include/ctype.h

@@ -0,0 +1,8 @@
+#ifndef _CTYPE_H_INCLUDE
+#define _CTYPE_H_INCLUDE
+
+static inline int isdigit(int n){
+	return n >= '0' && n <= '9' ? 1 : 0;
+}
+
+#endif

src/include/kernel/console.h

@@ -0,0 +1,10 @@
+#ifndef _CONSOLE_H_INCLUDE
+#define _CONSOLE_H_INCLUDE
+
+#include <stddef.h>
+
+void console_setwritehook(void(*hook)(char*, size_t));
+void console_putc(char c);
+
+
+#endif

src/include/kernel/logging.h

@@ -0,0 +1,9 @@
+#ifndef _LOGGING_H_INCLUDE
+#define _LOGGING_H_INCLUDE
+
+void loginfo(char*);
+void logwarn(char*);
+void logerror(char*);
+void logfatal(char*);
+
+#endif

src/include/limine.h

@@ -0,0 +1,448 @@
+// LIMINE.H
+//
+// Useful structures for communicating with the Limine bootloader protocol.
+
+#ifndef _LIMINE_H
+#define _LIMINE_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/* Misc */
+
+#ifdef LIMINE_NO_POINTERS
+#  define LIMINE_PTR(TYPE) uint64_t
+#else
+#  define LIMINE_PTR(TYPE) TYPE
+#endif
+
+#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;
+    LIMINE_PTR(char *) cmdline;
+    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;
+};
+
+/* 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_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;
+};
+
+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;
+};
+
+/* Framebuffer (legacy) */
+
+#define LIMINE_FRAMEBUFFER_LEGACY_REQUEST { LIMINE_COMMON_MAGIC, 0xcbfe81d7dd2d1977, 0x063150319ebc9b71 }
+
+struct limine_framebuffer_legacy {
+    LIMINE_PTR(void *) address;
+    uint16_t width;
+    uint16_t height;
+    uint16_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;
+    uint64_t edid_size;
+    LIMINE_PTR(void *) edid;
+};
+
+struct limine_framebuffer_legacy_response {
+    uint64_t revision;
+    uint64_t framebuffer_count;
+    LIMINE_PTR(struct limine_framebuffer_legacy **) framebuffers;
+};
+
+struct limine_framebuffer_legacy_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_framebuffer_legacy_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))
+
+struct 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_terminal {
+    uint64_t columns;
+    uint64_t rows;
+    LIMINE_PTR(struct limine_framebuffer *) framebuffer;
+};
+
+struct limine_terminal_response {
+    uint64_t revision;
+    uint64_t terminal_count;
+    LIMINE_PTR(struct limine_terminal **) terminals;
+    LIMINE_PTR(limine_terminal_write) write;
+};
+
+struct limine_terminal_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_terminal_response *) response;
+    LIMINE_PTR(limine_terminal_callback) callback;
+};
+
+/* Terminal (legacy) */
+
+#define LIMINE_TERMINAL_LEGACY_REQUEST { LIMINE_COMMON_MAGIC, 0x0785a0aea5d0750f, 0x1c1936fee0d6cf6e }
+
+struct limine_terminal_legacy;
+
+typedef void (*limine_terminal_legacy_write)(struct limine_terminal_legacy *, const char *, uint64_t);
+typedef void (*limine_terminal_legacy_callback)(struct limine_terminal_legacy *, uint64_t, uint64_t, uint64_t, uint64_t);
+
+struct limine_terminal_legacy {
+    uint32_t columns;
+    uint32_t rows;
+    LIMINE_PTR(struct limine_framebuffer_legacy *) framebuffer;
+};
+
+struct limine_terminal_legacy_response {
+    uint64_t revision;
+    uint64_t terminal_count;
+    LIMINE_PTR(struct limine_terminal_legacy **) terminals;
+    LIMINE_PTR(limine_terminal_legacy_write) write;
+};
+
+struct limine_terminal_legacy_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_terminal_legacy_response *) response;
+    LIMINE_PTR(limine_terminal_legacy_callback) callback;
+};
+
+/* 5-level paging */
+
+#define LIMINE_5_LEVEL_PAGING_REQUEST { LIMINE_COMMON_MAGIC, 0x94469551da9b3192, 0xebe5e86db7382888 }
+
+struct limine_5_level_paging_response {
+    uint64_t revision;
+};
+
+struct limine_5_level_paging_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_5_level_paging_response *) response;
+};
+
+/* SMP */
+
+#define LIMINE_SMP_REQUEST { LIMINE_COMMON_MAGIC, 0x95a67b819a1b857e, 0xa0b61b723b6a73e0 }
+
+#define LIMINE_SMP_X2APIC (1 << 0)
+
+struct limine_smp_info;
+
+typedef void (*limine_goto_address)(struct limine_smp_info *);
+
+struct limine_smp_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_smp_response {
+    uint64_t revision;
+    uint32_t flags;
+    uint32_t bsp_lapic_id;
+    uint64_t cpu_count;
+    LIMINE_PTR(struct limine_smp_info **) cpus;
+};
+
+struct limine_smp_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_smp_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
+#define LIMINE_MEMMAP_KERNEL_AND_MODULES     6
+#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;
+};
+
+/* Kernel File */
+
+#define LIMINE_KERNEL_FILE_REQUEST { LIMINE_COMMON_MAGIC, 0xad97e90e83f1ed67, 0x31eb5d1c5ff23b69 }
+
+struct limine_kernel_file_response {
+    uint64_t revision;
+    LIMINE_PTR(struct limine_file *) kernel_file;
+};
+
+struct limine_kernel_file_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_kernel_file_response *) response;
+};
+
+/* Module */
+
+#define LIMINE_MODULE_REQUEST { LIMINE_COMMON_MAGIC, 0x3e7e279702be32af, 0xca1c4f3bd1280cee }
+
+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;
+};
+
+/* RSDP */
+
+#define LIMINE_RSDP_REQUEST { LIMINE_COMMON_MAGIC, 0xc5e77b6b397e7b43, 0x27637845accdcf3c }
+
+struct limine_rsdp_response {
+    uint64_t revision;
+    LIMINE_PTR(void *) address;
+};
+
+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;
+    LIMINE_PTR(void *) entry_32;
+    LIMINE_PTR(void *) entry_64;
+};
+
+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;
+    LIMINE_PTR(void *) address;
+};
+
+struct limine_efi_system_table_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_efi_system_table_response *) response;
+};
+
+/* Boot time */
+
+#define LIMINE_BOOT_TIME_REQUEST { LIMINE_COMMON_MAGIC, 0x502746e184c088aa, 0xfbc5ec83e6327893 }
+
+struct limine_boot_time_response {
+    uint64_t revision;
+    int64_t boot_time;
+};
+
+struct limine_boot_time_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_boot_time_response *) response;
+};
+
+/* Kernel address */
+
+#define LIMINE_KERNEL_ADDRESS_REQUEST { LIMINE_COMMON_MAGIC, 0x71ba76863cc55f63, 0xb2644a48c516a487 }
+
+struct limine_kernel_address_response {
+    uint64_t revision;
+    uint64_t physical_base;
+    uint64_t virtual_base;
+};
+
+struct limine_kernel_address_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_kernel_address_response *) response;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

src/include/stdio.h

@@ -0,0 +1,11 @@
+#ifndef _STDIO_H_INCLUDE
+#define _STDIO_H_INCLUDE
+
+#include <stdarg.h>
+
+int putchar(char c);
+int printf(const char* format, ...);
+int vprintf(const char* format, va_list arg);
+
+
+#endif

src/include/stdio/Makefile

@@ -0,0 +1,11 @@
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+subdirs := 
+OBJPATH=$(OBJDIR)/include/stdio/
+export
+
+all: $(subdirs) $(objects)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ $<
+	mkdir -p $(OBJPATH) 
+	cp $@ $(OBJPATH)/$@

src/include/stdio/printf.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+__attribute__ ((format (printf, 1, 2))) int printf (const char* format, ...)
+{
+    va_list list;
+    va_start (list, format);
+    int i = vprintf (format, list);
+    va_end (list);
+    return i;
+
+}

src/include/stdio/putchar.c

@@ -0,0 +1,9 @@
+#include <kernel/console.h>
+
+
+int putchar(char c){
+	
+	console_putc(c);
+
+	return c;
+}

src/include/stdio/vprintf.c

@@ -0,0 +1,439 @@
+#include <stdio.h>         //putchar
+#include <string.h>        //strcpy, strcat, memcpy, memset
+#include <ctype.h>         //isdigit
+#include <stdbool.h> 
+#include <stdint.h>
+#include <stdarg.h>
+
+// There should probably be a better implementation for this soon.
+// I got this from https://wiki.osdev.org/User:A22347/Printf
+// because I was too lazy to write my own. Oh well. For now it works.
+
+typedef int wint_t;
+
+bool ignoresign = false;
+
+char* __int_str(uintmax_t i, char b[], int base, bool plusSignIfNeeded, bool spaceSignIfNeeded,
+                int paddingNo, bool justify, bool zeroPad) {
+ 
+    char digit[32] = {0};
+    memset(digit, 0, 32);
+    strcpy(digit, "0123456789");
+ 
+    if (base == 16) {
+        strcat(digit, "ABCDEF");
+    } else if (base == 17) {
+        strcat(digit, "abcdef");
+        base = 16;
+    }
+ 
+    char* p = b;
+    if (i < 0) {
+        *p++ = '-';
+        i *= -1;
+    } else if (plusSignIfNeeded) {
+        *p++ = '+';
+    } else if (!plusSignIfNeeded && spaceSignIfNeeded) {
+        *p++ = ' ';
+    }
+ 
+    uintmax_t shifter = i;
+    do {
+        ++p;
+        shifter = shifter / base;
+    } while (shifter);
+ 
+    *p = '\0';
+    do {
+        *--p = digit[i % base];
+        i = i / base;
+    } while (i);
+ 
+    int padding = paddingNo - (int)strlen(b);
+    if (padding < 0) padding = 0;
+ 
+    if (justify) {
+        while (padding--) {
+            if (zeroPad) {
+                b[strlen(b)] = '0';
+            } else {
+                b[strlen(b)] = ' ';
+            }
+        }
+ 
+    } else {
+        char a[256] = {0};
+        while (padding--) {
+            if (zeroPad) {
+                a[strlen(a)] = '0';
+            } else {
+                a[strlen(a)] = ' ';
+            }
+        }
+        strcat(a, b);
+        strcpy(b, a);
+    }
+ 
+    return b;
+}
+ 
+void displayCharacter(char c, int* a) {
+    putchar(c);
+    *a += 1;
+}
+ 
+void displayString(char* c, int* a) {
+    for (int i = 0; c[i]; ++i) {
+        displayCharacter(c[i], a);
+    }
+}
+ 
+int vprintf (const char* format, va_list list)
+{
+    int chars        = 0;
+    char intStrBuffer[256] = {0};
+ 
+    for (int i = 0; format[i]; ++i) {
+ 
+        char specifier   = '\0';
+        char length      = '\0';
+ 
+        int  lengthSpec  = 0; 
+        int  precSpec    = 0;
+        bool leftJustify = false;
+        bool zeroPad     = false;
+        bool spaceNoSign = false;
+        bool altForm     = false;
+        bool plusSign    = false;
+        bool emode       = false;
+        int  expo        = 0;
+ 
+        if (format[i] == '%') {
+            ++i;
+ 
+            bool extBreak = false;
+            while (1) {
+ 
+                switch (format[i]) {
+                    case '-':
+                        leftJustify = true;
+                        ++i;
+                        break;
+ 
+                    case '+':
+                        plusSign = true;
+                        ++i;
+                        break;
+ 
+                    case '#':
+                        altForm = true;
+                        ++i;
+                        break;
+ 
+                    case ' ':
+                        spaceNoSign = true;
+                        ++i;
+                        break;
+ 
+                    case '0':
+                        zeroPad = true;
+                        ++i;
+                        break;
+ 
+                    default:
+                        extBreak = true;
+                        break;
+                }
+ 
+                if (extBreak) break;
+            }
+ 
+            while (isdigit(format[i])) {
+                lengthSpec *= 10;
+                lengthSpec += format[i] - 48;
+                ++i;
+            }
+ 
+            if (format[i] == '*') {
+                lengthSpec = va_arg(list, int);
+                ++i;
+            }
+ 
+            if (format[i] == '.') {
+                ++i;
+                while (isdigit(format[i])) {
+                    precSpec *= 10;
+                    precSpec += format[i] - 48;
+                    ++i;
+                }
+ 
+                if (format[i] == '*') {
+                    precSpec = va_arg(list, int);
+                    ++i;
+                }
+            } else {
+                precSpec = 6;
+            }
+ 
+            if (format[i] == 'h' || format[i] == 'l' || format[i] == 'j' ||
+                   format[i] == 'z' || format[i] == 't' || format[i] == 'L') {
+                length = format[i];
+                ++i;
+                if (format[i] == 'h') {
+                    length = 'H';
+                } else if (format[i] == 'l') {
+                    length = 'q';
+                    ++i;
+                }
+            }
+            specifier = format[i];
+ 
+            memset(intStrBuffer, 0, 256);
+ 
+            int base = 10;
+            if (specifier == 'o') {
+                base = 8;
+                specifier = 'u';
+                if (altForm) {
+                    displayString("0", &chars);
+                }
+            }
+            if (specifier == 'p') {
+                base = 16;
+                length = 'z';
+                specifier = 'u';
+            }
+
+            switch (specifier) {
+                case 'X':
+                    base = 16;
+                case 'x':
+                    base = base == 10 ? 17 : base;
+                    if (altForm) {
+                        displayString("0x", &chars);
+                    }
+ 
+                case 'u':
+                {
+                    switch (length) {
+                        case 0:
+                        {
+                            unsigned int integer = va_arg(list, unsigned int);
+                            __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            break;
+                        }
+                        case 'H':
+                        {
+                            unsigned char integer = (unsigned char) va_arg(list, unsigned int);
+                            __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            break;
+                        }
+                        case 'h':
+                        {
+                            unsigned short int integer = va_arg(list, unsigned int);
+                            __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            break;
+                        }
+                        case 'l':
+                        {
+                            unsigned long integer = va_arg(list, unsigned long);
+                            __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            break;
+                        }
+                        case 'q':
+                        {
+                            unsigned long long integer = va_arg(list, unsigned long long);
+                            __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            break;
+                        }
+                        case 'j':
+                        {
+                            uintmax_t integer = va_arg(list, uintmax_t);
+                            __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            break;
+                        }
+                        case 'z':
+                        {
+
+                            size_t integer = va_arg(list, size_t);
+                        ignoresign = true;
+			__int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            ignoresign = false;
+			    break;
+                        }
+                        case 't':
+                        {
+                            ptrdiff_t integer = va_arg(list, ptrdiff_t);
+                            __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                            displayString(intStrBuffer, &chars);
+                            break;
+                        }
+                        default:
+                            break;
+                    }
+                    break;
+                }
+ 
+                case 'd':
+                case 'i':
+                {
+                    switch (length) {
+                    case 0:
+                    {
+                        int integer = va_arg(list, int);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    case 'H':
+                    {
+                        signed char integer = (signed char) va_arg(list, int);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    case 'h':
+                    {
+                        short int integer = va_arg(list, int);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    case 'l':
+                    {
+                        long integer = va_arg(list, long);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    case 'q':
+                    {
+                        long long integer = va_arg(list, long long);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    case 'j':
+                    {
+                        intmax_t integer = va_arg(list, intmax_t);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    case 'z':
+                    {
+                        size_t integer = va_arg(list, size_t);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    case 't':
+                    {
+                        ptrdiff_t integer = va_arg(list, ptrdiff_t);
+                        __int_str(integer, intStrBuffer, base, plusSign, spaceNoSign, lengthSpec, leftJustify, zeroPad);
+                        displayString(intStrBuffer, &chars);
+                        break;
+                    }
+                    default:
+                        break;
+                    }
+                    break;
+                }
+ 
+                case 'c':
+                {
+                    if (length == 'l') {
+                        displayCharacter(va_arg(list, wint_t), &chars);
+                    } else {
+                        displayCharacter(va_arg(list, int), &chars);
+                    }
+ 
+                    break;
+                }
+ 
+                case 's':
+                {
+                    displayString(va_arg(list, char*), &chars);
+                    break;
+                }
+ 
+                case 'n':
+                {
+                    switch (length) {
+                        case 'H':
+                            *(va_arg(list, signed char*)) = chars;
+                            break;
+                        case 'h':
+                            *(va_arg(list, short int*)) = chars;
+                            break;
+ 
+                        case 0: {
+                            int* a = va_arg(list, int*);
+                            *a = chars;
+                            break;
+                        }
+ 
+                        case 'l':
+                            *(va_arg(list, long*)) = chars;
+                            break;
+                        case 'q':
+                            *(va_arg(list, long long*)) = chars;
+                            break;
+                        case 'j':
+                            *(va_arg(list, intmax_t*)) = chars;
+                            break;
+                        case 'z':
+                            *(va_arg(list, size_t*)) = chars;
+                            break;
+                        case 't':
+                            *(va_arg(list, ptrdiff_t*)) = chars;
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                }
+ 
+                case 'e':
+                case 'E':
+                    emode = true;
+ 
+                case 'f':
+                case 'F':
+                case 'g':
+ 
+ 
+                case 'a':
+                case 'A':
+                    //ACK! Hexadecimal floating points...
+                    break;
+ 
+                default:
+                    break;
+            }
+ 
+            if (specifier == 'e') {
+                displayString("e+", &chars);
+            } else if (specifier == 'E') {
+                displayString("E+", &chars);
+            }
+ 
+            if (specifier == 'e' || specifier == 'E') {
+                __int_str(expo, intStrBuffer, 10, false, false, 2, false, true);
+                displayString(intStrBuffer, &chars);
+            }
+ 
+        } else {
+            displayCharacter(format[i], &chars);
+        }
+    }
+ 
+    return chars;
+}

src/include/string.h

@@ -0,0 +1,15 @@
+#ifndef _STRING_H_INCLUDE
+#define _STRING_H_INCLUDE
+
+#include <stddef.h>
+
+size_t strlen(char* str);
+char *strcpy(char *dest, const char* src);
+char *strcat(char *dest, const char* str);
+void *memcpy(void* dest, void* src, size_t size);
+void *memset(void* dest, unsigned long what, size_t size);
+int   strcmp(const char *a, const char* b);
+int   strncmp(const char* a, const char* b, size_t c);
+
+
+#endif 

src/include/string/Makefile

@@ -0,0 +1,12 @@
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+subdirs := 
+OBJPATH=$(OBJDIR)/include/string
+export
+
+all: $(subdirs) $(objects)
+	for subdir in $(subdirs) ; do $(MAKE) -C $${subdir} ; done
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ $<
+	mkdir -p $(OBJPATH) 
+	cp $@ $(OBJPATH)/$@

src/include/string/memcpy.c

@@ -0,0 +1,15 @@
+#include <stddef.h>
+#include <stdint.h>
+
+void* memcpy(void* d, void* s, size_t c){
+
+        uint8_t* sc = (uint8_t*)s;
+        uint8_t* dc = (uint8_t*)d;
+
+        while(c--)
+                *dc++ = *sc++;
+
+        return d;
+
+}
+

src/include/string/memset.c

@@ -0,0 +1,9 @@
+#include <stddef.h>
+
+void* memset(void* ptr, unsigned long value, size_t num){
+        char* p = (char*)ptr;
+        while(num--)
+                *p++ = value;
+
+        return ptr;
+}

src/include/string/strcat.c

@@ -0,0 +1,12 @@
+#include <string.h>
+
+
+char *strcat(char *dest, const char * src){
+	
+	dest += strlen(dest);
+
+	strcpy(dest, src);
+
+	return dest;
+	
+}

src/include/string/strcmp.c

@@ -0,0 +1,8 @@
+int strcmp(const char* a, const char* b){
+
+        while(*a && (*a++ == *b++));
+
+        return  *(const unsigned char*)a - *(const unsigned char*)b;
+
+}
+

src/include/string/strcpy.c

@@ -0,0 +1,13 @@
+void strcpy(char* p, const char * s)
+{
+        const char * temp1 = s;
+        char * temp2 = p;
+        while(*temp1 != '\0')
+        {
+                *temp2 = *temp1;
+                temp1++;
+                temp2++;
+        }
+        *temp2 = '\0';
+}
+

src/include/string/strlen.c

@@ -0,0 +1,10 @@
+#include <stddef.h>
+
+size_t strlen(const char* a){
+
+        size_t s = 0;
+        while(a[s] != '\0') ++s;
+        return s;
+
+}
+

src/include/string/strncmp.c

@@ -0,0 +1,13 @@
+#include <stddef.h>
+
+int strncmp(const char *a, const char *b, size_t c){
+
+        int diff = 0;
+
+        while(c--)
+                diff += *a++ - *b++;
+
+
+        return diff;
+
+}

src/video/Makefile

@@ -0,0 +1,12 @@
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+subdirs :=
+OBJPATH=$(OBJDIR)/video
+export
+
+all: $(subdirs) $(objects)
+	for subdir in $(subdirs) ; do $(MAKE) -C $${subdir} ; done
+
+%.o: %.c
+	$(CC) $(CFLAGS) -o $@ $<
+	mkdir -p $(OBJPATH) 
+	cp $@ $(OBJPATH)/$@

src/video/console.c

@@ -0,0 +1,20 @@
+// console.c
+//
+// provides the kernel with an abstraction over other possible console drivers.
+// for example, console_putc is called by putchar() from stdio.h
+//
+
+#include <kernel/console.h>
+#include <stddef.h>
+
+static  void(*writehook)(char*, size_t);
+
+void console_setwritehook(void(*hook)(char*, size_t)){
+	writehook = hook;
+}
+
+void console_putc(char c){
+
+	writehook(&c, 1);
+
+}

src/video/logging.c

@@ -0,0 +1,26 @@
+// logging.c
+//
+// provides a few preformatted logging functions for the kernel
+//
+
+#include <stdio.h>
+
+// TODO
+//
+// allow it to be formated using a call for vprintf
+
+void loginfo(char* str){
+	printf("[\033[94mINFO\033[0m] %s", str);
+}
+
+void logwarn(char* str){	
+	printf("[\033[93mWARN\033[0m] %s", str);
+}
+
+void logerror(char* str){
+	printf("[\033[91mERROR\033[0m] %s", str);
+}
+
+void logfatal(char* str){
+	printf("[\033[31mFATAL\033[0m] %s", str);
+}