Changed camelCase to snake_case

kernel/src/bitmap.c

@@ -19,21 +19,14 @@ int bmap_get(bitmap_t* map, size_t bit) {
 	return (p[bit / 32] & (1 << (bit % 32))) ? 1 : 0; 
 }
 
-void bmap_setarea(bitmap_t* map, size_t base, size_t len, int val) {
+void bmap_set_area(bitmap_t* map, size_t base, size_t len, int val) {
 	uint32_t align = dceil(base, BLOCK_SIZE);
 	uint32_t count = dceil(len, BLOCK_SIZE);
 
 	while (count-- > 0) bmap_set(map, align++, val);
 }
 
-void bmap_setall(bitmap_t* map, int val) {
-	uint8_t b = (val) ? 0xff : 0;
-	for (size_t i = 0; i < map->bytes; i++) ((uint8_t*)map->map)[i] = b;
-	if (val) map->used = map->blocks;
-	else map->used = 0;
-}
-
-size_t bmap_findarea(bitmap_t* map, size_t len, int val) {
+size_t bmap_get_area(bitmap_t* map, size_t len, int val) {
 	if (len == 0) return BMAP_NOT_FOUND;
 
 	uint32_t found = 0;
@@ -47,3 +40,10 @@ size_t bmap_findarea(bitmap_t* map, size_t len, int val) {
 	return BMAP_NOT_FOUND;
 }
 
+void bmap_set_all(bitmap_t* map, int val) {
+	uint8_t b = (val) ? 0xff : 0;
+	for (size_t i = 0; i < map->bytes; i++) ((uint8_t*)map->map)[i] = b;
+	if (val) map->used = map->blocks;
+	else map->used = 0;
+}
+

kernel/src/bootloader.c

@@ -8,26 +8,36 @@ struct boot_info bootloader;
 
 // TODO:
 int boot_init(int type, ...) {
+	va_list va;
+	va_start(va, type);
+
+	void* ptr = va_arg(va, void*);
+	uint32_t magic = va_arg(va, uint32_t);
+
+	switch (type) {
+	case BOOT_MB1: return boot_init_mb1(ptr, magic);
+	}
+	
 	return 1;
 }
 
-int boot_initMB1(void* ptr, uint32_t magic) {
+int boot_init_mb1(void* ptr, uint32_t magic) {
 	multiboot_info_t* mbi = ptr;
 
 	if (magic != MULTIBOOT_BOOTLOADER_MAGIC) return 1;
 
 	// mem_* fields are valid
 	if (mbi->flags & MULTIBOOT_INFO_MEMORY) {
-		bootloader.memLower = mbi->mem_lower;
-		bootloader.memUpper = mbi->mem_upper;
+		bootloader.mem_lower = mbi->mem_lower;
+		bootloader.mem_upper = mbi->mem_upper;
 	}
 
 	// boot_device is valid
 	if (mbi->flags & MULTIBOOT_INFO_BOOTDEV) {
-		bootloader.bootDrive = (mbi->boot_device & 0xff000000) >> 24;
-		bootloader.bootPart1 = (mbi->boot_device & 0x00ff0000) >> 16;
-		bootloader.bootPart2 = (mbi->boot_device & 0x0000ff00) >> 8;
-		bootloader.bootPart3 = (mbi->boot_device & 0x000000ff);
+		bootloader.boot_drive = (mbi->boot_device & 0xff000000) >> 24;
+		bootloader.boot_part1 = (mbi->boot_device & 0x00ff0000) >> 16;
+		bootloader.boot_part2 = (mbi->boot_device & 0x0000ff00) >> 8;
+		bootloader.boot_part3 = (mbi->boot_device & 0x000000ff);
 	}
 
 	// cmdline is valid
@@ -45,9 +55,9 @@ int boot_initMB1(void* ptr, uint32_t magic) {
 
 		size_t i = 0;
 		multiboot_memory_map_t* entry = (multiboot_memory_map_t*)mbi->mmap_addr;
-		uint32_t mapLim = mbi->mmap_addr + mbi->mmap_length;
+		uint32_t limit = mbi->mmap_addr + mbi->mmap_length;
 
-		while ((uint32_t)entry < mapLim) {
+		while ((uint32_t)entry < limit) {
 			bootloader.memmap[i].base = entry->addr;
 			bootloader.memmap[i].size = entry->len;
 			bootloader.memmap[i].type = (uint8_t)entry->type;
@@ -55,7 +65,7 @@ int boot_initMB1(void* ptr, uint32_t magic) {
 			entry++;
 			i++;
 		}
-		bootloader.memmapLen = i;
+		bootloader.memmap_size = i;
 	}
 
 	// TODO: drives_*

kernel/src/idt.c

@@ -7,14 +7,14 @@ __align(16) // performace :fire:
 static struct idt_entry idt[IDT_ENTRIES];
 static struct idt_pointer idtp;
 
-void idt_setGate(uint8_t i, void* handler, uint8_t flags) {
+void idt_set_gate(uint8_t i, void* handler, uint8_t flags) {
 	uint32_t offset = (uint32_t)handler;
 	struct idt_entry* entry = &idt[i];
 	
-	entry->offsetLow = (uint16_t)offset;
+	entry->offset_low = (uint16_t)offset;
 	entry->selector = GDT_KERNEL_CODE;
 	entry->flags = flags;
-	entry->offsetHigh = (uint16_t)(offset >> 16);
+	entry->offset_high = (uint16_t)(offset >> 16);
 }
 
 int idt_init(void) {

kernel/src/isr.c

@@ -5,7 +5,7 @@
 #include <idt.h>
 #include <isr.h>
 
-isr_handlerPtr irqHandlers[16];
+isr_handler_ptr irq_handlers[16];
 
 const char* exceptions[] = {
 	"Division By Zero",
@@ -43,7 +43,7 @@ const char* exceptions[] = {
 };
 
 // I have no clue how this works or what it does, but it doesn't work without it
-void isr_remapPIC(void) {
+void isr_remap_pic(void) {
 	outb(0x20, 0x11); iowait();
 	outb(0xa0, 0x11); iowait();
 	outb(0x21, 0x20); iowait();
@@ -58,15 +58,15 @@ void isr_remapPIC(void) {
 
 int isr_init(void) {
 	idt_init();
-	isr_remapPIC();
+	isr_remap_pic();
 
 	for (int i = 0; i < 48; i++) {
 		// First 32 IRSs are exceptions (traps) and the next 16 are hardware interrupts
-		idt_setGate(i, isr_redirectTable[i], (i < 32) ? IDT_FLAG_TRAP : IDT_FLAG_INT);
+		idt_set_gate(i, isr_redirect_table[i], (i < 32) ? IDT_FLAG_TRAP : IDT_FLAG_INT);
 	}
 
 	// System call (should be callable from userspace)
-	idt_setGate(0x80, (void*)(uint32_t)isr128, IDT_FLAG_USER);
+	idt_set_gate(0x80, (void*)(uint32_t)isr128, IDT_FLAG_USER);
 
 	// Let interrupts interrupt
 	__asm__ volatile ("sti");
@@ -75,31 +75,31 @@ int isr_init(void) {
 	return 0;
 }
 
-void isr_registerIRQ(uint8_t i, isr_handlerPtr handler) {
-	irqHandlers[i] = handler;
+void isr_register_irq(uint8_t i, isr_handler_ptr handler) {
+	irq_handlers[i] = handler;
 }
 
-void isr_sendEOI(uint8_t irq) {
+void isr_send_eoi(uint8_t irq) {
 	if (irq >= 8) {
 		outb(0xa0, 0x20);
 	}
 	outb(0x20, 0x20);
 }
 
-int isr_handleInterrupt(struct isr_intFrame iframe) {
+int isr_handle_interrupt(struct isr_int_frame iframe) {
 	if (iframe.interrupt < 32) { 
 		// ISRs 0-31 - Exceptions
 		panic(exceptions[iframe.error]);
 	} else if (iframe.interrupt >= 32 && iframe.interrupt < 48) {
 		// ISRs 32-47 - Hardware interrupts
 		uint8_t irq = iframe.interrupt - 32;
-		if (irqHandlers[irq]) {
-			irqHandlers[irq](&iframe);
-			isr_sendEOI(irq);
+		if (irq_handlers[irq]) {
+			irq_handlers[irq](&iframe);
+			isr_send_eoi(irq);
 		}
 	} else if (iframe.interrupt == 128) { 
 		// ISR 128 - System call
-		return syscallHandler(&iframe);
+		return syscall_handler(&iframe);
 	}
 
 	return 0;

kernel/src/isr.s

@@ -2,7 +2,7 @@
 [bits 32]
 
 isr_common:
-	;; Push registers to the intFrame_t struct
+	;; Push registers to the int_frame_t struct
 	push eax
 	push gs
 	push fs
@@ -16,8 +16,8 @@ isr_common:
 	push ebx
 	push esp
 	
-	[extern isr_handleInterrupt]
-	call isr_handleInterrupt
+	[extern isr_handle_interrupt]
+	call isr_handle_interrupt
 isr_return:
 	add esp, 4  ; Keep ESP
 	pop ebx
@@ -109,8 +109,8 @@ isr128:
 	jmp isr_common
 
 ;; Create table of ISRs
-[global isr_redirectTable]
-isr_redirectTable:
+[global isr_redirect_table]
+isr_redirect_table:
 %assign i 0
 %rep 48
 	dd isr%+i

kernel/src/kernel.c

@@ -10,7 +10,7 @@
 
 __noreturn
 void kmain(void* ptr, uint32_t magic) {
-	if (boot_initMB1(ptr, magic) != 0) panic("Unsupported bootloader.");
+	if (boot_init_mb1(ptr, magic) != 0) panic("Unsupported bootloader.");
 
 	// Serial console for debugging
 	if (serial_init(COM1) != 0) panic("Failed to initialize Serial driver.");
@@ -30,7 +30,10 @@ void kmain(void* ptr, uint32_t magic) {
 	tty_puts("kern.\n\n");
 
 	debugf("[kernel] Basic initialization complete!\n");
-	
+
+	// TODO: Init VFS
+	// TODO: 
+
 	panic("kmain() reached end.");
 }
 

kernel/src/paging.c

@@ -6,10 +6,10 @@
 
 #define PAGE_DIR_COUNT	256
 static uint32_t	pagedirs[PAGE_DIR_COUNT][1024] __align(4096);
-static uint8_t	pagedirUsed[PAGE_DIR_COUNT];
+static uint8_t	pagedir_used[PAGE_DIR_COUNT];
 
 // TODO: Should this be initialized? If so, to what?
-size_t pag_pageCount = 0;
+size_t pag_page_count = 0;
 
 // Invalidates the pagedir entry in the CPUs TLB cache
 static inline void invalidate(uint32_t vaddr) {
@@ -17,11 +17,11 @@ static inline void invalidate(uint32_t vaddr) {
 }
 
 // Temp paging thing
-uint32_t tempFrameStart;
-void pag_registerTempFrame(uint32_t target) { tempFrameStart = target; }
-uint32_t pag_tempFrame(void) {
-	uint32_t fin = tempFrameStart;
-	tempFrameStart += PAGE_SIZE;
+uint32_t temp_frame_start;
+void pag_register_temp_frame(uint32_t target) { temp_frame_start = target; }
+uint32_t pag_temp_frame(void) {
+	uint32_t fin = temp_frame_start;
+	temp_frame_start += PAGE_SIZE;
 	return fin;
 }
 
@@ -42,21 +42,21 @@ int pag_init(void) {
 
 	// TODO: This sometimes causes a #PF
 	memset(pagedirs, 0, PAGE_SIZE * PAGE_DIR_COUNT);
-	memset(pagedirUsed, 0, PAGE_DIR_COUNT);
+	memset(pagedir_used, 0, PAGE_DIR_COUNT);
 
 	debugf("[pag] Paging initalized.\n");
 
 	return 0;
 }
 
-void pag_mapPage(uint32_t vaddr, uint32_t paddr, uint32_t flags) {
+void pag_map(uint32_t vaddr, uint32_t paddr, uint32_t flags) {
 	// Save the pagedir we were in
 	uint32_t* prevpd = NULL;
 
 	// Switch to the init pagedir if in kernel memory
 	if (vaddr >= KERNEL_BASE) {
-		prevpd = pag_getPagedir();
-		if (prevpd != init_pagedir) pag_setPagedir(init_pagedir);
+		prevpd = pag_get_pagedir();
+		if (prevpd != init_pagedir) pag_set_pagedir(init_pagedir);
 	}
 
 	// Extract indecies
@@ -68,7 +68,7 @@ void pag_mapPage(uint32_t vaddr, uint32_t paddr, uint32_t flags) {
 
 	// Allocate a pagetab if it didn't exist
 	if (!(pagedir[pdi] & PAGE_FLAG_PRESENT)) {
-		uint32_t tabaddr = pmm_bitmap.ready ? (uint32_t)pmm_allocPage() : pag_tempFrame();
+		uint32_t tabaddr = pmm_bitmap.ready ? (uint32_t)pmm_alloc() : pag_temp_frame();
 
 		pagedir[pdi] = tabaddr |
 			PAGE_FLAG_PRESENT | PAGE_FLAG_WRITE | PAGE_FLAG_OWNER | flags;
@@ -83,23 +83,23 @@ void pag_mapPage(uint32_t vaddr, uint32_t paddr, uint32_t flags) {
 
 	// The actuall mapping
 	pagetab[pti] = paddr | PAGE_FLAG_PRESENT | flags;
-	pag_pageCount++;
+	pag_page_count++;
 	invalidate(vaddr);
 
 	// Do we need to return to the original pagedir?
 	if (prevpd != NULL) {
-		pag_syncPagedir(); // Sync it to other pagedirs
-		if (prevpd != init_pagedir) pag_setPagedir(prevpd);
+		pag_sync_pagedir(); // Sync it to other pagedirs
+		if (prevpd != init_pagedir) pag_set_pagedir(prevpd);
 	}
 }
 
-uint32_t pag_umapPage(uint32_t vaddr) {
-	// Same saving as in pag_mapPage()
+uint32_t pag_umap(uint32_t vaddr) {
+	// Same saving as in pag_map()
 	uint32_t* prevpd = NULL;
 
 	if (vaddr >= KERNEL_BASE) {
-		prevpd = pag_getPagedir();
-		if (prevpd != init_pagedir) pag_setPagedir(init_pagedir);
+		prevpd = pag_get_pagedir();
+		if (prevpd != init_pagedir) pag_set_pagedir(init_pagedir);
 	}
 
 	// Extract indecies
@@ -111,7 +111,7 @@ uint32_t pag_umapPage(uint32_t vaddr) {
 
 	uint32_t pte = pagetab[pti];
 	pagetab[pti] = 0;
-	pag_pageCount--;
+	pag_page_count--;
 
 	// Look if we can free the pagetab
 	int remove = 1;
@@ -125,24 +125,24 @@ uint32_t pag_umapPage(uint32_t vaddr) {
 	uint32_t pde = pagedir[pdi];
 	if (remove && pde & PAGE_FLAG_OWNER) {
 		uint32_t tabaddr = PHYS_ADDR(pde);
-		pmm_freePage((void*)tabaddr);
+		pmm_free((void*)tabaddr);
 		pagedir[pdi] = 0;
 	}
 
 	invalidate(vaddr);
 
 	// Free the page frame
-	if (pte & PAGE_FLAG_OWNER) pmm_freePage((void*)PHYS_ADDR(pte));
+	if (pte & PAGE_FLAG_OWNER) pmm_free((void*)PHYS_ADDR(pte));
 
 	if (prevpd != NULL) {
-		pag_syncPagedir(); // Sync it to other pagedirs
-		if (prevpd != init_pagedir) pag_setPagedir(prevpd);
+		pag_sync_pagedir(); // Sync it to other pagedirs
+		if (prevpd != init_pagedir) pag_set_pagedir(prevpd);
 	}
 
 	return pte;
 }
 
-void* pag_virtToPhys(uint32_t vaddr) {
+void* pag_virt_to_phys(uint32_t vaddr) {
 	uint32_t pdi = vaddr >> 22;
 	uint32_t pti = vaddr >> 12 & 0x3FF;
 
@@ -151,14 +151,14 @@ void* pag_virtToPhys(uint32_t vaddr) {
 	return (void*)((pagetab[pti] & ~0xFFF) + ((uint32_t)vaddr & 0xFFF));
 }
 
-uint32_t* pag_getPagedir() {
+uint32_t* pag_get_pagedir() {
 	uint32_t pagedir;
 	__asm__ volatile ("mov %%cr3, %0" : "=r"(pagedir));
 	pagedir += KERNEL_BASE;
 	return (uint32_t*)pagedir;
 }
 
-void pag_setPagedir(uint32_t* pagedir) {
+void pag_set_pagedir(uint32_t* pagedir) {
 	pagedir = (uint32_t*)((uint32_t)pagedir - KERNEL_BASE);
 	__asm__ volatile (
 		"mov %0, %%eax\n"
@@ -167,9 +167,9 @@ void pag_setPagedir(uint32_t* pagedir) {
 	);
 }
 
-void pag_syncPagedir() {
+void pag_sync_pagedir() {
 	for (size_t i = 0; i < PAGE_DIR_COUNT; i++) {
-		if (!pagedirUsed[i]) continue;
+		if (!pagedir_used[i]) continue;
 
 		uint32_t* pagedir = pagedirs[i];
 
@@ -181,11 +181,11 @@ void pag_syncPagedir() {
 	}
 }
 
-uint32_t* pag_allocPagedir() {
+uint32_t* pag_alloc_pagedir() {
 	// Find the first unused page
 	for (size_t i = 0; i < PAGE_DIR_COUNT; i++) {
-		if (pagedirUsed[i]) continue;
-		pagedirUsed[i] = 1;
+		if (pagedir_used[i]) continue;
+		pagedir_used[i] = 1;
 
 		uint32_t* pagedir = pagedirs[i];
 		memset(pagedir, 0, PAGE_SIZE);
@@ -207,9 +207,9 @@ uint32_t* pag_allocPagedir() {
 	return NULL;
 }
 
-void pag_freePagedir(uint32_t* pagedir) {
-	uint32_t* prevpd = pag_getPagedir();
-	pag_setPagedir(pagedir);
+void pag_free_pagedir(uint32_t* pagedir) {
+	uint32_t* prevpd = pag_get_pagedir();
+	pag_set_pagedir(pagedir);
 
 	uint32_t pdi = (uint32_t)pagedir - (uint32_t)pagedirs;
 	pdi /= PAGE_SIZE;
@@ -224,15 +224,15 @@ void pag_freePagedir(uint32_t* pagedir) {
 		for (size_t j = 0; j < 1024; j++) {
 			uint32_t pte = pagetab[j];
 
-			if (pte & PAGE_FLAG_OWNER) pmm_freePage((void*)PHYS_ADDR(pte));
+			if (pte & PAGE_FLAG_OWNER) pmm_free((void*)PHYS_ADDR(pte));
 		}
 		memset(pagetab, 0, PAGE_SIZE);
 
-		if (pde & PAGE_FLAG_OWNER) pmm_freePage((void*)PHYS_ADDR(pde));
+		if (pde & PAGE_FLAG_OWNER) pmm_free((void*)PHYS_ADDR(pde));
 		pd[i] = 0;
 	}
 
-	pagedirUsed[pdi] = 0;
-	pag_setPagedir(prevpd);
+	pagedir_used[pdi] = 0;
+	pag_set_pagedir(prevpd);
 }
 

kernel/src/pmm.c

@@ -20,7 +20,7 @@ int pmm_init(void) {
 	// Find enough space for the bitmap
 	struct boot_memmap* mmap;
 	int found = 0;
-	for (size_t i = 0; i < bootloader.memmapLen; i++) {
+	for (size_t i = 0; i < bootloader.memmap_size; i++) {
 		mmap = &bootloader.memmap[i];
 
 		if (mmap->type == BOOT_MMAP_AVAILABLE && mmap->size >= pmm_bitmap.bytes) {
@@ -30,31 +30,31 @@ int pmm_init(void) {
 	}
 	if (!found) return 1; // Not enough memory
 
-	uint32_t pageFrameStart = mmap->base;
-	pag_registerTempFrame(pageFrameStart);
+	uint32_t page_frame_start = mmap->base;
+	pag_register_temp_frame(page_frame_start);
 	mmap->base += ptcount * PAGE_SIZE;
 	
-	uint32_t bitmapStart = KERNEL_HEAP_BASE - dceil(pmm_bitmap.bytes, PAGE_SIZE) * PAGE_SIZE;
-	uint32_t bitmapStartPhys = mmap->base;
-	pmm_bitmap.map = (void*)bitmapStart;
+	uint32_t bitmap_start = KERNEL_HEAP_BASE - dceil(pmm_bitmap.bytes, PAGE_SIZE) * PAGE_SIZE;
+	uint32_t bitmap_start_phys = mmap->base;
+	pmm_bitmap.map = (void*)bitmap_start;
 
-	size_t pagecount = dceil(pmm_bitmap.bytes, PAGE_SIZE);
-	for (size_t i = 0; i < pagecount; i++) {
-		// NOTE: We can't unmap this with pag_umapPage(), it's in a tempFrame
-		pag_mapPage(bitmapStart + i * PAGE_SIZE, mmap->base + i * PAGE_SIZE, 0);
+	size_t page_count = dceil(pmm_bitmap.bytes, PAGE_SIZE);
+	for (size_t i = 0; i < page_count; i++) {
+		// NOTE: We can't unmap this with pag_umap(), it's in a tempFrame
+		pag_map(bitmap_start + i * PAGE_SIZE, mmap->base + i * PAGE_SIZE, 0);
 	}
 
 	// Set all blocks as used
-	bmap_setall(&pmm_bitmap, 1);
+	bmap_set_all(&pmm_bitmap, 1);
 
 	debugf("[pmm] Memory map:\n"); // Use the loop to also print the memmap
 
-	for (size_t i = 0; i < bootloader.memmapLen; i++) {
+	for (size_t i = 0; i < bootloader.memmap_size; i++) {
 		mmap = &bootloader.memmap[i];
 		if (mmap->size == 0) continue; // Ignore dummy entries
 
 		if (mmap->type == BOOT_MMAP_AVAILABLE) {
-			bmap_setarea(&pmm_bitmap, mmap->base, mmap->size, 0);
+			bmap_set_area(&pmm_bitmap, mmap->base, mmap->size, 0);
 		}
 
 		// Print entry
@@ -63,8 +63,8 @@ int pmm_init(void) {
 			(mmap->type == BOOT_MMAP_AVAILABLE) ? "AVAILABLE" : "RESERVED");
 	}
 
-	bmap_setarea(&pmm_bitmap, bitmapStartPhys, pmm_bitmap.bytes, 1);
-	bmap_setarea(&pmm_bitmap, pageFrameStart, ptcount * PAGE_SIZE, 1);
+	bmap_set_area(&pmm_bitmap, bitmap_start_phys, pmm_bitmap.bytes, 1);
+	bmap_set_area(&pmm_bitmap, page_frame_start, ptcount * PAGE_SIZE, 1);
 
 	bmap_set(&pmm_bitmap, 0, 1); // Reserve block 0 - NULL page
 
@@ -76,17 +76,17 @@ int pmm_init(void) {
 		"\tBitmap is %d bytes contained in %d pages\n",
 		pmm_bitmap.blocks - pmm_bitmap.used,
 		(pmm_bitmap.blocks - pmm_bitmap.used) * BLOCK_SIZE,
-		bitmapStartPhys, bitmapStart, pmm_bitmap.bytes, pagecount
+		bitmap_start_phys, bitmap_start, pmm_bitmap.bytes, page_count
 	      );
 
 	pmm_bitmap.ready = 1;
 	return 0;
 }
 
-void* pmm_allocPage(void) {
+void* pmm_alloc(void) {
 	if (pmm_bitmap.blocks - pmm_bitmap.used == 0) return NULL;
 
-	size_t base = bmap_findarea(&pmm_bitmap, 1, 0);
+	size_t base = bmap_get_area(&pmm_bitmap, 1, 0);
 	if (base == BMAP_NOT_FOUND) return NULL;
 	
 	bmap_set(&pmm_bitmap, base, 1);
@@ -94,9 +94,9 @@ void* pmm_allocPage(void) {
 	return bmap_ptr(&pmm_bitmap, base);
 }
 
-void pmm_freePage(void* page) {
+void pmm_free(void* page) {
 	size_t base = (size_t)page / BLOCK_SIZE;
-	bmap_setarea(&pmm_bitmap, base, 1, 0);
+	bmap_set_area(&pmm_bitmap, base, 1, 0);
 	bmap_set(&pmm_bitmap, 0, 1);
 }
 

kernel/src/tty.c

@@ -4,24 +4,28 @@
 #include <tty.h>
 
 struct {
-	size_t row;
-	size_t col;
-	uint8_t attr;
+	size_t	 row;
+	size_t	 col;
+	uint8_t  attr;
 	uint8_t* buf;
-	size_t updateWait;
-} ctx;
+	/*
+	 * This is for the tty_update_cursor() function. It makes sure we don't update
+	 * the cursor if we don't need to, because it's slow due to I/O port writes.
+	 */
+	size_t	 update_wait;
+} tty_ctx;
 
 int tty_init(void) {
 	// Map VGA Text memory to KERNEL_FRAMEBUF
-	size_t pagecount = dceil(VGA_WIDTH * VGA_HEIGHT * 2, PAGE_SIZE);
-	for (size_t i = 0; i < pagecount; i++) {
-		pag_mapPage(KERNEL_FRAMEBUF + i * PAGE_SIZE, VGA_MEMORY + i * PAGE_SIZE, 0);
+	size_t page_count = dceil(VGA_WIDTH * VGA_HEIGHT * 2, PAGE_SIZE);
+	for (size_t i = 0; i < page_count; i++) {
+		pag_map(KERNEL_FRAMEBUF + i * PAGE_SIZE, VGA_MEMORY + i * PAGE_SIZE, 0);
 	}
 
-	ctx.row = 0;
-	ctx.col = 0;
-	ctx.attr = 0x07;
-	ctx.buf = (uint8_t*)KERNEL_FRAMEBUF;
+	tty_ctx.row = 0;
+	tty_ctx.col = 0;
+	tty_ctx.attr = 0x07;
+	tty_ctx.buf = (uint8_t*)KERNEL_FRAMEBUF;
 	tty_clear();
 
 	return 0;
@@ -29,34 +33,34 @@ int tty_init(void) {
 
 void tty_clear(void) {
 	for (int i = 0; i < VGA_WIDTH * VGA_HEIGHT; i++) {
-		ctx.buf[i * 2] = ' ';
-		ctx.buf[i * 2 + 1] = ctx.attr;
+		tty_ctx.buf[i * 2] = ' ';
+		tty_ctx.buf[i * 2 + 1] = tty_ctx.attr;
 	}
 }
 
-void tty_setattr(uint8_t attr) {
-	ctx.attr = attr;
+void tty_set_attr(uint8_t attr) {
+	tty_ctx.attr = attr;
 }
 
-void tty_enableCursor(uint8_t start, uint8_t end) {
+void tty_show_cursor(uint8_t start, uint8_t end) {
 	outb(0x3d4, 0x0a);
 	outb(0x3d5, (inb(0x3d5) & 0xc0) | start);
 	outb(0x3d4, 0x0b);
 	outb(0x3d5, (inb(0x3d5) & 0xe0) | end);
 }
 
-void tty_disableCursor(void) {
+void tty_hide_cursor(void) {
 	outb(0x3d4, 0x0a);
 	outb(0x3d5, 0x20);
 }
 
-void tty_updateCursor(void) {
-	if (ctx.updateWait > 0) {
-		ctx.updateWait--;
+void tty_update_cursor(void) {
+	if (tty_ctx.update_wait > 0) {
+		tty_ctx.update_wait--;
 		return;
 	}
 
-	uint16_t pos = ctx.row * VGA_WIDTH + ctx.col;
+	uint16_t pos = tty_ctx.row * VGA_WIDTH + tty_ctx.col;
 	outb(0x3d4, 0x0f);
 	outb(0x3d5, (uint8_t)pos);
 	outb(0x3d4, 0x0e);
@@ -65,37 +69,37 @@ void tty_updateCursor(void) {
 
 // TODO:
 void tty_scroll(void) {
-	ctx.row = 0;
-	ctx.col = 0;
+	tty_ctx.row = 0;
+	tty_ctx.col = 0;
 	tty_clear();
 }
 
 void tty_putat(char c, size_t row, size_t col) {
 	size_t i = row * VGA_WIDTH + col;
-	ctx.buf[i * 2] = c;
-	ctx.buf[i * 2 + 1] = ctx.attr;
+	tty_ctx.buf[i * 2] = c;
+	tty_ctx.buf[i * 2 + 1] = tty_ctx.attr;
 }
 
 void tty_putc(char c) {
 	if (c == '\n') { 
-		ctx.col = 0;
-		ctx.row++;
+		tty_ctx.col = 0;
+		tty_ctx.row++;
 		goto scroll_check;
 	}
 
-	tty_putat(c, ctx.row, ctx.col++);
-	if (ctx.col >= VGA_WIDTH) {
-		ctx.col = 0;
-		ctx.row++;
+	tty_putat(c, tty_ctx.row, tty_ctx.col++);
+	if (tty_ctx.col >= VGA_WIDTH) {
+		tty_ctx.col = 0;
+		tty_ctx.row++;
 	}
 
 scroll_check:
-	if (ctx.row >= VGA_HEIGHT) tty_scroll();
-	tty_updateCursor();
+	if (tty_ctx.row >= VGA_HEIGHT) tty_scroll();
+	tty_update_cursor();
 }
 
 void tty_write(char* buf, size_t len) {
-	ctx.updateWait = len - 1;
+	tty_ctx.update_wait = len - 1;
 	for (size_t i = 0; i < len; i++) tty_putc(buf[i]);
 }
 

kernel/src/vmm.c

@@ -5,8 +5,6 @@
 
 #include <vmm.h>
 
-#include <string.h>
-
 bitmap_t vmm_bitmap;
 
 int vmm_init(void) {
@@ -14,18 +12,18 @@ int vmm_init(void) {
 	vmm_bitmap.membase = KERNEL_HEAP_BASE;
 	vmm_bitmap.blocks = dceil(KERNEL_HEAP_SIZE, BLOCK_SIZE);
 	vmm_bitmap.bytes = dceil(vmm_bitmap.blocks, 8);
-	uint32_t bitmaploc = 0xC6000000;
+	uint32_t bitmap_loc = 0xC6000000;
 
-	size_t pagecount = dceil(vmm_bitmap.bytes, PAGE_SIZE);
-	for (size_t i = 0; i < pagecount; i++) {
-		void* fr = pmm_allocPage();
+	size_t page_count = dceil(vmm_bitmap.bytes, PAGE_SIZE);
+	for (size_t i = 0; i < page_count; i++) {
+		void* fr = pmm_alloc();
 		if (fr == NULL) return 1;
-		pag_mapPage(bitmaploc + i * PAGE_SIZE, (uint32_t)fr, 0);
+		pag_map(bitmap_loc + i * PAGE_SIZE, (uint32_t)fr, 0);
 	}
 
 	// Set all pages as
-	vmm_bitmap.map = (void*)bitmaploc;
-	bmap_setall(&vmm_bitmap, 0);
+	vmm_bitmap.map = (void*)bitmap_loc;
+	bmap_set_all(&vmm_bitmap, 0);
 
 	bmap_set(&vmm_bitmap, 0, 1);
 	bmap_set(&vmm_bitmap, 8, 1);
@@ -36,7 +34,7 @@ int vmm_init(void) {
 		"\tBitmap is at 0x%08x in virtual memory\n"
 		"\tBitmap is %d bytes over %d pages\n",
 		vmm_bitmap.blocks, vmm_bitmap.map,
-		vmm_bitmap.bytes, pagecount
+		vmm_bitmap.bytes, page_count
 	      );
 
 	vmm_bitmap.ready = 1;
@@ -44,16 +42,16 @@ int vmm_init(void) {
 }
 
 void* vmm_alloc(size_t pages) {
-	size_t idx = bmap_findarea(&vmm_bitmap, pages, 0);
+	size_t idx = bmap_get_area(&vmm_bitmap, pages, 0);
 	if (idx == BMAP_NOT_FOUND) return NULL;
 	void* ptr = bmap_ptr(&vmm_bitmap, idx);
 
-	bmap_setarea(&vmm_bitmap, idx * BLOCK_SIZE, pages * PAGE_SIZE, 1);
+	bmap_set_area(&vmm_bitmap, idx * BLOCK_SIZE, pages * PAGE_SIZE, 1);
 
 	for (size_t i = 0; i < pages; i++) {
-		void* fr = pmm_allocPage();
+		void* fr = pmm_alloc();
 		if (fr == NULL) return NULL;
-		pag_mapPage((uint32_t)ptr + i * PAGE_SIZE, (uint32_t)fr, 0);
+		pag_map((uint32_t)ptr + i * PAGE_SIZE, (uint32_t)fr, 0);
 	}
 
 	return ptr;
@@ -62,13 +60,13 @@ void* vmm_alloc(size_t pages) {
 void vmm_free(void* ptr, size_t pages) {
 	for (size_t i = 0; i < pages; i++) {
 		uint32_t vaddr = (uint32_t)ptr + i * PAGE_SIZE;
-		uint32_t paddr = (uint32_t)pag_virtToPhys((uint32_t)ptr);
+		uint32_t paddr = (uint32_t)pag_virt_to_phys((uint32_t)ptr);
 		
-		pmm_freePage((void*)paddr);
-		pag_umapPage(vaddr);
+		pmm_free((void*)paddr);
+		pag_umap(vaddr);
 	}
 
 	size_t base = ((size_t)ptr - KERNEL_BASE) / BLOCK_SIZE;
-	bmap_setarea(&vmm_bitmap, base, pages, 0);
+	bmap_set_area(&vmm_bitmap, base, pages, 0);
 }