adds some references

REFERENCES.md

@@ -0,0 +1,11 @@
+Websites:
+    OSDev Wiki - https://wiki.osdev.org/
+    bona fide os developer - http://osdever.net/
+    LittleOSBook - https://littleosbook.github.io/
+    http://www.brokenthorn.com/Resources/OSDevIndex.html
+
+References:
+    NASM quick reference - https://www.posix.nl/linuxassembly/nasmdochtml/nasmdoca.html
+    ELF Reference - https://flint.cs.yale.edu/cs422/doc/ELF_Format.pdf
+    Anatomy of a program in memory - https://manybutfinite.com/post/anatomy-of-a-program-in-memory/
+    Linux Buddy System Paging - https://lwn.net/Articles/253361/

TODO.md

@@ -1,34 +1,42 @@
 ## What do I need to do?
 
+- Unit testing
+    (https://wiki.osdev.org/Unit_Testing)
+    (https://wiki.osdev.org/Troubleshooting#Showing_the_stack_content)
+    lets implmeent some better testing functions aswell
+- Paging & virtual memory
+    - Get GRUB to show memory map - DONE
+    - Write a page allocator - WIP
+    - Setup paging
+    - Setup higher half kernel
+- Heap allocator (malloc)
+    - after this, implment some data structures? cleanup queue?
 
+After the above is done, i want to clean up the code and restructure some stuff
+clean up the headers so that we're not exposing kernel functions to the entire c library
+and also only make required functions be exposed to the header
 
+Drivers:
 
+PIC - Done
+PIT - Done
+    - Need sleep and timers implemented, ACPI can help with this
+    - Lets also maybe set up a hardware abstraction for timing interfaces?
+
+ACPI (use ACPICA?)
+PCI, PCIE (i think qemue and bochs dont have legacy PCI, so lets try for PCIE)
 PS/2 controller
--> need to setup some timing device, probably PIT DONE!
--> might need to do a PCI controller first, so that i can discover the controllers, to be enabled
--> need to setup the USB controller first, so i can disable Legacy USB bios shit
--> need to configure ACPI so i can actually detect for the PS/2 controller
--> then we can start configuring the PS/2
-
--> to properly send data to PS/2 controllers, we need some sort of timing interface,
-this way we can timeout if we're being hanged on sending commands to a ps/2 device
-
-
-
-
-PIT timer, or some sort of timer interface
-
-perhaps maybe some more things off of the PIC? im not sure
-
-really after that I want to do more to work towards userspace, so that I can start creating things
-
-scheduler?
-multi processing? threads?
-etc
+Proper KEYB driver
 
+From here, determine whats needed next for pushing into userspace.
+Ideally I would like a shell, and then create some essential userspace posix tools (gnutils?)
 
+POSIX compliant?
 
 ### Features I want
 
 - A kernel bus
     - some kind of driver where I can send messages that can eventually be accessed globally by other drives / applications
+- modularity in terms of drivers:
+    - I want drivers to be optional and to not limit functionality
+    - perhaps this means providing every thing as a hardware abstraction layer, so that when its absent we can have some sort of virtual replacement

kernel/arch/boot.s

@@ -3,7 +3,7 @@
 ; We set up some parameters and then pass the execution to our kmain
 
 global loader 				; entry symbol for ELF
-extern kmain
+extern _main
 
 MAGIC_NUMBER 	equ 0x1BADB002		; magic number constant
 FLAGS		equ 0x3
@@ -30,7 +30,10 @@ section .text
 loader:
 	mov esp, kernel_stack + KERNEL_STACK_SIZE ; move the top of the stack into esp
 
-	call kmain ; pass execution over to our kmain function, where all of the real stuff is done
+	push eax
+	push ebx
+
+	call _main ; pass execution over to our _main function, where all of the real stuff is done
 
 	; Should the system exit, we clear the interrupt flag
 	; and do an infinite loop of nothing

kernel/arch/io/io.s

@@ -10,7 +10,7 @@ outb:
 	ret			; return to the calling function
 
 
-global outb_16
+global outb_16 ; TODO these are probably wrong, eh, the stack might need more bcs the variables are bigger? im not sure
 outb_16:
 	mov ax, [esp + 8]
 	mov dx, [esp + 4]

kernel/arch/link.ld

@@ -19,6 +19,7 @@ SECTIONS
 	 */
 	.text BLOCK(4K) : ALIGN(4K) /* The first section we want is the text section, this is where most code is */
 	{
+		text_start = .;
 		*(.multiboot) /* Multiboot needs to be early in the file, required by grub */
 		*(.text) /* The text section */
 	}
@@ -33,12 +34,16 @@ SECTIONS
 	.data BLOCK(4K) : ALIGN(4K)
 	{
 		*(.data)
+		end_data = .;
 	}
 
 	/* BSS */
 	.bss BLOCK(4K) : ALIGN(4K)
 	{
+		sbss = .;
 		*(COMMON)
 		*(.bss)
+		ebss = .;
+		endkernel = .;
 	}
 }

kernel/arch/paging/paging.c

@@ -0,0 +1,55 @@
+#include <stdint.h>
+
+#include <stdio.h>
+
+#include <kernel/paging.h>
+
+//extern uint32_t endkernel; // found in link.ld
+
+/**
+ * The page table must be page aligned (aligned at 4KiB)
+ *
+ *
+ * This is a temporary solution, as we want a page frame allocator, to properly get page frames.. but this works for now
+ */
+uint32_t page_directory[PAGE_DIRECTORY_ENTRIES] __attribute__((aligned(4096)));
+
+uint32_t first_page_table[PAGE_TABLE_ENTRIES] __attribute__((aligned(4096)));
+
+void setup_page_table(void)
+{
+	uint32_t i;
+	for (i = 0; i < PAGE_TABLE_ENTRIES; i++) {
+		first_page_table[i] = (i * 0x1000) | 3; // supervisor, r/w, present
+	}
+	puts("test");
+}
+
+void setup_page_dir(void)
+{
+	setup_page_table();
+	/**
+	 * Now that we have a page directory, we need to blank it.
+	 *
+	 * The page directory should have exactly 1024 entries. We will set each entry to not present, so that the if the
+	 * MMU looks for that page table, it will see that it is not there yet.
+	 */
+	int i;
+	for (i = 0; i < PAGE_DIRECTORY_ENTRIES; i++) {
+		// This sets the following flags to the pages:
+		// 	Supervisor: Only kernel-mode can access them
+		// 	Write Enabled: It can be both read from and written to
+		// 	Not Present: The page table is not present
+		page_directory[i] = 0x00000002;
+	}
+
+	page_directory[0] = ((uint32_t) first_page_table) | 3;
+}
+
+void setup_paging(void)
+{
+	setup_page_dir();
+
+	load_page_directory(page_directory);
+	enable_paging();
+}

kernel/arch/paging/paging_src.s

@@ -0,0 +1,20 @@
+global load_page_directory
+load_page_directory:
+	push ebp
+	mov esp, ebp
+	mov eax, [esp + 4]
+	mov cr3, eax
+	mov esp, ebp
+	pop ebp
+	ret
+
+global enable_paging
+enable_paging:
+	push ebp
+	mov ebp, esp
+	mov eax, cr0
+	or eax, 0x80000000
+	mov cr0, eax
+	mov esp, ebp
+	pop ebp
+	ret

kernel/arch/pic/pci.c

@@ -3,6 +3,12 @@
 
 #include <stdio.h>
 
+/**
+ * None of this is working. I'm assuming that QEMU (and bochs) are using pcie purely memory mapped, without legacy PCI support
+ *
+ * so we'll need to setup ACPI first :)
+ */
+
 uint16_t pci_config_read_word(uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset)
 {
 	uint32_t address;
@@ -15,20 +21,22 @@ uint16_t pci_config_read_word(uint8_t bus, uint8_t slot, uint8_t func, uint8_t o
 	address = (uint32_t) ((lbus << 16) | (lslot << 11) |
 			(lfunc << 8) | (offset & 0xFC) | ((uint32_t) 0x80000000));
 
+	printf("%b\n", address);
+
 	outb_32(PCI_CONFIG_ADDRESS, address);
 	
-	tmp = (uint16_t)((inb(PCI_CONFIG_DATA) >> ((offset & 2) * 8)) * 0xFFFF);
+	tmp = (uint16_t)((inb(PCI_CONFIG_DATA) >> ((offset & 2) * 8)) & 0xFFFF);
 	return tmp;
 }
 
-uint16_t pci_check_vendor(uint8_t bus, uint8_t slot)
+uint16_t pci_check_vendor(uint8_t bus, uint8_t slot, uint8_t func)
 {
 	uint16_t vendor, device;
 
-	if ((vendor = pci_config_read_word(bus, slot, 0, 0)) != 0xFFFF) {
-		device = pci_config_read_word(bus, slot, 0, 2);
-		printf("Device: %d, Vendor: %d\n", device, vendor);
+	if ((vendor = pci_config_read_word(bus, slot, func, 0)) != 0xFFFF) {
+		device = pci_config_read_word(bus, slot, func, 2);
+		// we'll do something here, store all the pcis in memory or something
+		device++;
 	} 
 	return vendor;
 }
-

kernel/include/kernel/paging.h

@@ -0,0 +1,16 @@
+#include <stdint.h>
+
+#ifndef ARCH_PAGING_H
+#define ARCH_PAGING_H
+
+#define PAGE_TABLE_ENTRIES 1024
+#define PAGE_DIRECTORY_ENTRIES 1024
+
+void load_page_directory(uint32_t*);
+
+void enable_paging();
+
+
+void setup_paging(void);
+
+#endif

kernel/include/kernel/x86/pci.h

@@ -8,6 +8,9 @@
 
 uint16_t pci_config_read_word(uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset);
 
-uint16_t pci_check_vendor(uint8_t bus, uint8_t slot);
+uint16_t pci_check_vendor(uint8_t bus, uint8_t slot, uint8_t func);
+
+void check_all_busses(void);
+
 
 #endif

kernel/kmain.c

@@ -1,24 +1,73 @@
 #include <stdio.h>
 #include <stdint.h>
+#include <stdlib.h>
 
 #include <kernel/_kernel.h>
 #include <kernel/tty.h>
 #include <kernel/serial.h>
+#include <kernel/paging.h>
 #include <kernel/x86/gdt.h>
 #include <kernel/x86/idt.h>
 #include <kernel/x86/io.h>
 #include <kernel/x86/keyb.h>
 #include <kernel/x86/pit.h>
+#include <kernel/x86/pci.h>
 
-#include <kernel/x86/pit.h>
+#include "multiboot.h"
 
+void verify_memmap(multiboot_info_t* mbd, uint32_t magic)
+{
+	if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
+		panic("Invalid magic number!");
+	else
+		printf("%2\n", magic);
 
-void kmain(void)
+	if (!(mbd->flags >> 6 & 0x1))
+		panic("Invalid memory map given by GRUB bootloader!");
+
+#ifdef __TESTING__
+	puts("Printing available memory map...");
+	uint32_t i;
+	for (i = 0; i < mbd->mmap_length; i += sizeof(multiboot_memory_map_t)) {
+		multiboot_memory_map_t* mmmt = (multiboot_memory_map_t*) (mbd->mmap_addr + i);
+
+		printf("Start Addr: %4 | Length: %4 | Size: %2 | Type: ",
+				mmmt->addr, mmmt->len, mmmt->size);
+		switch (mmmt->type) {
+			case MULTIBOOT_MEMORY_AVAILABLE:
+				puts("Available");
+				break;
+			case MULTIBOOT_MEMORY_RESERVED:
+				puts("Reserved");
+				break;
+			case MULTIBOOT_MEMORY_ACPI_RECLAIMABLE:
+				puts("ACPI Reclaimable");
+				break;
+			case MULTIBOOT_MEMORY_NVS:
+				puts("NVS");
+				break;
+			case MULTIBOOT_MEMORY_BADRAM:
+				puts("Bad ram");
+				break;
+			default:
+				puts("Unknown");
+				break;
+		}
+
+		// if (mmmt->type == MULTIBOOT_MEMORY_AVAILABLE) -> DO SOMETHING
+	}
+#endif
+}
+
+void _main(multiboot_info_t* mbd, uint32_t magic)
 {
 #ifdef __TESTING__ // important components should be declared first, but if we're testing we want to log all of that
 	terminal_initialize();
 	serial_initialize();
 #endif
+
+	verify_memmap(mbd, magic);	
+
 	gdt_init();		
 	idt_init();
 
@@ -26,13 +75,13 @@ void kmain(void)
 	terminal_initialize();
 	serial_initialize();
 #endif
-	
+
+	setup_paging();
+
 	init_kb();
 
 	init_pit(0x36, PIT_CHANNEL_0, 0);
 
-	printf("%f\n", get_time_from_divisor(10));
-
 	printf("Entering loop...\n");
 	while (1) {
 		

kernel/multiboot.h

@@ -0,0 +1,274 @@
+/* multiboot.h - Multiboot header file. */
+/* Copyright (C) 1999,2003,2007,2008,2009,2010  Free Software Foundation, Inc.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to
+ *  deal in the Software without restriction, including without limitation the
+ *  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ *  sell copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL ANY
+ *  DEVELOPER OR DISTRIBUTOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+ *  IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef MULTIBOOT_HEADER
+#define MULTIBOOT_HEADER 1
+
+/* How many bytes from the start of the file we search for the header. */
+#define MULTIBOOT_SEARCH                        8192
+#define MULTIBOOT_HEADER_ALIGN                  4
+
+/* The magic field should contain this. */
+#define MULTIBOOT_HEADER_MAGIC                  0x1BADB002
+
+/* This should be in %eax. */
+#define MULTIBOOT_BOOTLOADER_MAGIC              0x2BADB002
+
+/* Alignment of multiboot modules. */
+#define MULTIBOOT_MOD_ALIGN                     0x00001000
+
+/* Alignment of the multiboot info structure. */
+#define MULTIBOOT_INFO_ALIGN                    0x00000004
+
+/* Flags set in the ’flags’ member of the multiboot header. */
+
+/* Align all boot modules on i386 page (4KB) boundaries. */
+#define MULTIBOOT_PAGE_ALIGN                    0x00000001
+
+/* Must pass memory information to OS. */
+#define MULTIBOOT_MEMORY_INFO                   0x00000002
+
+/* Must pass video information to OS. */
+#define MULTIBOOT_VIDEO_MODE                    0x00000004
+
+/* This flag indicates the use of the address fields in the header. */
+#define MULTIBOOT_AOUT_KLUDGE                   0x00010000
+
+/* Flags to be set in the ’flags’ member of the multiboot info structure. */
+
+/* is there basic lower/upper memory information? */
+#define MULTIBOOT_INFO_MEMORY                   0x00000001
+/* is there a boot device set? */
+#define MULTIBOOT_INFO_BOOTDEV                  0x00000002
+/* is the command-line defined? */
+#define MULTIBOOT_INFO_CMDLINE                  0x00000004
+/* are there modules to do something with? */
+#define MULTIBOOT_INFO_MODS                     0x00000008
+
+/* These next two are mutually exclusive */
+
+/* is there a symbol table loaded? */
+#define MULTIBOOT_INFO_AOUT_SYMS                0x00000010
+/* is there an ELF section header table? */
+#define MULTIBOOT_INFO_ELF_SHDR                 0X00000020
+
+/* is there a full memory map? */
+#define MULTIBOOT_INFO_MEM_MAP                  0x00000040
+
+/* Is there drive info? */
+#define MULTIBOOT_INFO_DRIVE_INFO               0x00000080
+
+/* Is there a config table? */
+#define MULTIBOOT_INFO_CONFIG_TABLE             0x00000100
+
+/* Is there a boot loader name? */
+#define MULTIBOOT_INFO_BOOT_LOADER_NAME         0x00000200
+
+/* Is there a APM table? */
+#define MULTIBOOT_INFO_APM_TABLE                0x00000400
+
+/* Is there video information? */
+#define MULTIBOOT_INFO_VBE_INFO                 0x00000800
+#define MULTIBOOT_INFO_FRAMEBUFFER_INFO         0x00001000
+
+#ifndef ASM_FILE
+
+typedef unsigned char           multiboot_uint8_t;
+typedef unsigned short          multiboot_uint16_t;
+typedef unsigned int            multiboot_uint32_t;
+typedef unsigned long long      multiboot_uint64_t;
+
+struct multiboot_header
+{
+  /* Must be MULTIBOOT_MAGIC - see above. */
+  multiboot_uint32_t magic;
+
+  /* Feature flags. */
+  multiboot_uint32_t flags;
+
+  /* The above fields plus this one must equal 0 mod 2^32. */
+  multiboot_uint32_t checksum;
+
+  /* These are only valid if MULTIBOOT_AOUT_KLUDGE is set. */
+  multiboot_uint32_t header_addr;
+  multiboot_uint32_t load_addr;
+  multiboot_uint32_t load_end_addr;
+  multiboot_uint32_t bss_end_addr;
+  multiboot_uint32_t entry_addr;
+
+  /* These are only valid if MULTIBOOT_VIDEO_MODE is set. */
+  multiboot_uint32_t mode_type;
+  multiboot_uint32_t width;
+  multiboot_uint32_t height;
+  multiboot_uint32_t depth;
+};
+
+/* The symbol table for a.out. */
+struct multiboot_aout_symbol_table
+{
+  multiboot_uint32_t tabsize;
+  multiboot_uint32_t strsize;
+  multiboot_uint32_t addr;
+  multiboot_uint32_t reserved;
+};
+typedef struct multiboot_aout_symbol_table multiboot_aout_symbol_table_t;
+
+/* The section header table for ELF. */
+struct multiboot_elf_section_header_table
+{
+  multiboot_uint32_t num;
+  multiboot_uint32_t size;
+  multiboot_uint32_t addr;
+  multiboot_uint32_t shndx;
+};
+typedef struct multiboot_elf_section_header_table multiboot_elf_section_header_table_t;
+
+struct multiboot_info
+{
+  /* Multiboot info version number */
+  multiboot_uint32_t flags;
+
+  /* Available memory from BIOS */
+  multiboot_uint32_t mem_lower;
+  multiboot_uint32_t mem_upper;
+
+  /* "root" partition */
+  multiboot_uint32_t boot_device;
+
+  /* Kernel command line */
+  multiboot_uint32_t cmdline;
+
+  /* Boot-Module list */
+  multiboot_uint32_t mods_count;
+  multiboot_uint32_t mods_addr;
+
+  union
+  {
+    multiboot_aout_symbol_table_t aout_sym;
+    multiboot_elf_section_header_table_t elf_sec;
+  } u;
+
+  /* Memory Mapping buffer */
+  multiboot_uint32_t mmap_length;
+  multiboot_uint32_t mmap_addr;
+
+  /* Drive Info buffer */
+  multiboot_uint32_t drives_length;
+  multiboot_uint32_t drives_addr;
+
+  /* ROM configuration table */
+  multiboot_uint32_t config_table;
+
+  /* Boot Loader Name */
+  multiboot_uint32_t boot_loader_name;
+
+  /* APM table */
+  multiboot_uint32_t apm_table;
+
+  /* Video */
+  multiboot_uint32_t vbe_control_info;
+  multiboot_uint32_t vbe_mode_info;
+  multiboot_uint16_t vbe_mode;
+  multiboot_uint16_t vbe_interface_seg;
+  multiboot_uint16_t vbe_interface_off;
+  multiboot_uint16_t vbe_interface_len;
+
+  multiboot_uint64_t framebuffer_addr;
+  multiboot_uint32_t framebuffer_pitch;
+  multiboot_uint32_t framebuffer_width;
+  multiboot_uint32_t framebuffer_height;
+  multiboot_uint8_t framebuffer_bpp;
+#define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0
+#define MULTIBOOT_FRAMEBUFFER_TYPE_RGB     1
+#define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT     2
+  multiboot_uint8_t framebuffer_type;
+  union
+  {
+    struct
+    {
+      multiboot_uint32_t framebuffer_palette_addr;
+      multiboot_uint16_t framebuffer_palette_num_colors;
+    };
+    struct
+    {
+      multiboot_uint8_t framebuffer_red_field_position;
+      multiboot_uint8_t framebuffer_red_mask_size;
+      multiboot_uint8_t framebuffer_green_field_position;
+      multiboot_uint8_t framebuffer_green_mask_size;
+      multiboot_uint8_t framebuffer_blue_field_position;
+      multiboot_uint8_t framebuffer_blue_mask_size;
+    };
+  };
+};
+typedef struct multiboot_info multiboot_info_t;
+
+struct multiboot_color
+{
+  multiboot_uint8_t red;
+  multiboot_uint8_t green;
+  multiboot_uint8_t blue;
+};
+
+struct multiboot_mmap_entry
+{
+  multiboot_uint32_t size;
+  multiboot_uint64_t addr;
+  multiboot_uint64_t len;
+#define MULTIBOOT_MEMORY_AVAILABLE              1
+#define MULTIBOOT_MEMORY_RESERVED               2
+#define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE       3
+#define MULTIBOOT_MEMORY_NVS                    4
+#define MULTIBOOT_MEMORY_BADRAM                 5
+  multiboot_uint32_t type;
+} __attribute__((packed));
+typedef struct multiboot_mmap_entry multiboot_memory_map_t;
+
+struct multiboot_mod_list
+{
+  /* the memory used goes from bytes ’mod_start’ to ’mod_end-1’ inclusive */
+  multiboot_uint32_t mod_start;
+  multiboot_uint32_t mod_end;
+
+  /* Module command line */
+  multiboot_uint32_t cmdline;
+
+  /* padding to take it to 16 bytes (must be zero) */
+  multiboot_uint32_t pad;
+};
+typedef struct multiboot_mod_list multiboot_module_t;
+
+/* APM BIOS info. */
+struct multiboot_apm_info
+{
+  multiboot_uint16_t version;
+  multiboot_uint16_t cseg;
+  multiboot_uint32_t offset;
+  multiboot_uint16_t cseg_16;
+  multiboot_uint16_t dseg;
+  multiboot_uint16_t flags;
+  multiboot_uint16_t cseg_len;
+  multiboot_uint16_t cseg_16_len;
+  multiboot_uint16_t dseg_len;
+};
+
+#endif /* ! ASM_FILE */
+
+#endif /* ! MULTIBOOT_HEADER */

libc/include/stdlib.h

@@ -8,6 +8,8 @@
 __attribute__((__noreturn__))
 void abort(void);
 
+void panic(const char* str);
+
 char* s64toa(int64_t num, char* buf, int base);
 char* u64toa(uint64_t num, char* buf, int base);
 char* s32toa(int32_t num, char* buf, int base);

libc/stdio/printf.c

@@ -161,6 +161,17 @@ int printf(const char* restrict format, ...) {
 			if (!print(buffer, len))
 				return -1;
 			written += len;
+		} else if (*format == 'b') {
+			format++;
+			uint32_t i = (uint32_t) va_arg(parameters, uint32_t);
+			u32toa(i, buffer, 2);
+			size_t len = strlen(buffer);
+			if (maxrem < len) {
+				return -1;
+			}
+			if (!print(buffer, len))
+				return -1;
+			written += len;
 		} else {
 			format = format_begun_at;
 			size_t len = strlen(format);

libc/stdio/putchar.c

@@ -13,6 +13,10 @@ int putchar(int ic) {
 	terminal_write(&c, sizeof(c));
 #ifdef __TESTING__
 	serial_write(&c, sizeof(c));
+	if (c == '\n') {
+		char tmp = '\r';
+		serial_write(&tmp, sizeof(tmp));
+	}
 #endif
 #else
 	// TODO: Implement stdio and the write system call.

libc/stdlib/abort.c

@@ -13,3 +13,9 @@ void abort(void) {
 	while (1) { }
 	__builtin_unreachable();
 }
+
+void panic(const char* str)
+{
+	printf("%s\n", str);
+	abort();
+}

util/bochsrc.txt

@@ -8,4 +8,4 @@ log:	bochslog.txt
 clock:	sync=realtime, time0=local
 cpu:	count=1, ips=10000000
 com1: enabled=1, mode=file, dev=com1.out
-
+usb_uhci: port1=mouse, port2=disk, options2="path:usbstick.img"