fixed memory barrier bug in IDT initialization -- kernel still crashing when interrupts enabled but i think the memory management initialization is correct

git-svn-id: svn://anubis/hos/trunk@102 5b3e749e-e535-0410-8002-a9bb6afbdfca
fixed bug that mapping PAGE_DIR_SELF_REF would incorrectly allocate a new physical page
2010-02-01 05:24:40 +00:00 · 2010-02-01 05:04:39 +00:00 · 2010-02-01 04:21:29 +00:00 · 2010-02-01 01:47:19 +00:00 · 2010-01-28 04:22:02 +00:00 · 2010-01-27 05:25:05 +00:00
85 changed files with 2155 additions and 4696 deletions
@@ -1,276 +0,0 @@
 //Functions.c
 //05/07/03 Josh Holtrop
 //for HOS
 //Modified: 10/30/03
 //Writes a byte out to a port
 inline void outportb(unsigned int port, unsigned char value)		// Output a byte to a port
 {
    asm volatile ("outb %%al,%%dx"::"d" (port), "a" (value));
 };
 //Writes a word out to a port
 inline void outportw(unsigned int port, unsigned int value)		// Output a word to a port
 {
    asm volatile ("outw %%ax,%%dx"::"d" (port), "a" (value));
 };
 //Reads a byte from a port
 inline byte inportb(unsigned short port)
 {
 	unsigned char ret_val;
 	asm volatile("inb %w1,%b0"
 		: "=a"(ret_val)
 		: "d"(port));
 	return ret_val;
 };
 //Enables (SeTs) Interrupt Flag on the processor
 inline void enable_ints()
 {
 	asm("sti");
 };
 //Disables (CLears) Interrupt Flag on the processor
 inline void disable_ints()
 {
 	asm("cli");
 };
 char *strcat(char *dest, char *src)
 {
 	strcpy(dest+strlen(dest), src);
 }
 //converts a binary-coded-decimal byte to its decimal equivalent
 inline byte bcd2byte(byte bcd)
 {
 	return (10* ((bcd & 0xF0) >> 4)) + (bcd & 0x0F);
 }
 //converts a binary-coded-decimal byte to its decimal equivalent
 inline byte byte2bcd(byte bite)
 {
 	return ((bite / 10) << 4) | (bite % 10);
 }
 void	rtrim(char *str)
 {
 	str += strlen(str);	//now points to the null character at the end of the string
 	str--;
 	for (;;)
 	{
 		if ((*str == ' ') || (*str == '\t') || (*str == '\n'))
 			*str-- = 0;
 		else
 			break;
 	}
 }
 char	*ucase(char *str)
 {
 	char *ret = str;
 	for (;;)
 	{
 		if (*str == 0)
 			break;
 		if ((*str >= 'a') && (*str <= 'z'))
 			*str = (*str) - 32;
 		str++;
 	}
 	return ret;
 }
 char	*lcase(char *str)
 {
 	char *ret = str;
 	for (;;)
 	{
 		if (*str == 0)
 			break;
 		if ((*str >= 'A') && (*str <= 'Z'))
 			*str = (*str) + 32;
 		str++;
 	}
 	return ret;
 }
 //Re-maps the Programmable Interrupr Controllers so IRQ0->pic1 base address, IRG8->pic2 base address
 void remap_pics(int pic1, int pic2)
 {
 	byte	a1, a2;
 	a1 = inportb(PIC1_DATA);      //0x21
 	a2 = inportb(PIC2_DATA);      //0xA1
 	outportb(PIC1_COMMAND, ICW1_INIT+ICW1_ICW4);	//0x20, 0x10+0x01 00010001b
 	outportb(PIC2_COMMAND, ICW1_INIT+ICW1_ICW4);	//0xA0, 0x10+0x01 00010001b
 	outportb(PIC1_DATA, pic1);			//0x21, pic1
 	outportb(PIC2_DATA, pic2);			//0xA1, pic2
 	outportb(PIC1_DATA, 4);				//0x21, 0x04      00000100b
 	outportb(PIC2_DATA, 2);				//0xA1, 0x02      00000010b
 	outportb(PIC1_DATA, ICW4_8086);			//0x21, 0x01      00000001b
 	outportb(PIC2_DATA, ICW4_8086);			//0xA1, 0x01      00000001b
 	outportb(PIC1_DATA, a1);			//0x21
 	outportb(PIC2_DATA, a2);			//0xA1
 }
 //Masks interrupts on first Programmable Interrupt Controller
 inline void pic1_mask(byte mask)
 {
 	outportb(PIC1_DATA, mask);			//0x21, maskfield *OCW1*
 }
 //Masks interrupts on second Programmable Interrupt Controller
 inline void pic2_mask(byte mask)
 {
 	outportb(PIC2_DATA, mask);			//0xA1, maskfield *OCW1*
 }
 //Restarts the computer
 inline void restart()
 {
 	enable_ints();
 	byte temp;
 	do
 	{
 		temp = inportb(0x64);
 		if (temp & 1)
 		inportb(0x60);
 	} while(temp & 2);
 	outportb (0x64, 0xfe);
 	for (;;)
 	{
 	}
 }
 //Halts (freezes) the computer
 inline void halt()
 {
 	asm("cli");
 	asm("hlt");
 	while (1)
 	;
 }
 //Initializes 8253 Programmable Interrupt Timer
 inline void init_timer()
 {
 	//set timer : 2e9c = 100hz
 	outportb(0x43, 0x34);
 	outportb(0x40, 0x9c); //lsb
 	outportb(0x40, 0x2e); //msb
 }
 //Signals an End Of Interrupt signal to the first PIC
 inline void eoi()
 {
 	outportb(0x20, 0x20);
 }
 //Signals an End Of Interrupt signal to both the second and first PIC unit
 inline void eoi2()
 {
 	outportb(0xA0, 0x20);
 	outportb(0x20, 0x20);
 }
 //Returns the size of the kernel (code & data)
 // - this does not include the bss section
 // - this should be 4kb aligned per the linker script
 // - this should be the size of kernel.bin
 inline dword kernel_size()
 {
 	return (dword)(&_bss)-(dword)(&_code);
 }
 //These functions are for reading and writing various values stored on the CMOS Real Time Clock
 byte	rtc_readDay()
 {
 	outportb(0x70, 7);
 	return bcd2byte(inportb(0x71));
 }
 byte	rtc_readMonth()
 {
 	outportb(0x70, 8);
 	return bcd2byte(inportb(0x71));
 }
 byte	rtc_readYear()
 {
 	outportb(0x70, 9);
 	return bcd2byte(inportb(0x71));
 }
 byte	rtc_readSecond()
 {
 	outportb(0x70, 0);
 	return bcd2byte(inportb(0x71));
 }
 byte	rtc_readMinute()
 {
 	outportb(0x70, 2);
 	return bcd2byte(inportb(0x71));
 }
 byte	rtc_readHour()
 {
 	outportb(0x70, 4);
 	return bcd2byte(inportb(0x71));
 }
 void	rtc_setDay(byte day)
 {
 	outportb(0x70, 7);
 	outportb(0x71, byte2bcd(day));
 }
 void	rtc_setMonth(byte month)
 {
 	outportb(0x70, 8);
 	outportb(0x71, byte2bcd(month));
 }
 void	rtc_setYear(byte year)
 {
 	outportb(0x70, 9);
 	outportb(0x71, byte2bcd(year));
 }
 void	rtc_setSecond(byte second)
 {
 	outportb(0x70, 0);
 	outportb(0x71, byte2bcd(second));
 }
 void	rtc_setMinute(byte minute)
 {
 	outportb(0x70, 2);
 	outportb(0x71, byte2bcd(minute));
 }
 void	rtc_setHour(byte hour)
 {
 	outportb(0x70, 4);
 	outportb(0x71, byte2bcd(hour));
 }
@@ -0,0 +1,37 @@
 KERNEL_FILE := hos.gz
 MKISOFS     := genisoimage
 ISO         := hos.iso
 QEMU        := qemu-system-x86_64
 BOCHS       := bochs
 # default target: build the kernel and ISO image
 all: kernel iso
 # build the kernel
 .PHONY: kernel
 kernel:
 	$(MAKE) -C $@
 # build the ISO image
 .PHONY: iso
 iso: $(ISO) kernel
 $(ISO): kernel
 	cp kernel/$(KERNEL_FILE) iso/boot
 	-rm -f $(ISO)
 	$(MKISOFS) -R -b boot/grub/stage2_eltorito -no-emul-boot \
 		-boot-load-size 4 -boot-info-table -o $(ISO) iso
 .PHONY: qemu
 qemu: iso
 	$(QEMU) -cdrom $(ISO) -boot d -m 384 -localtime
 .PHONY: bochs
 bochs: iso
 	-$(BOCHS)
 .PHONY: clean
 clean:
 	$(MAKE) -C kernel clean
 	-rm -f $(ISO) iso/boot/$(KERNEL_FILE)
@@ -1,470 +0,0 @@
 ; asmfuncs.asm
 ; Josh Holtrop
 ; Created: 10/23/03
 ; Modified: 12/25/03
 [extern _putc]
 [extern _console_memory]
 [extern _cursorPosition]
 [extern _video_drawConsole]
 [extern _videoMode]
 %macro jzfar 1
 	jnz	%%skip
 	jmp	%1
 %%skip:
 %endmacro
 ;stores the parameter to the CR0 register
 ;extern dword write_cr0(dword cr0);
 [global _write_cr0]
 _write_cr0:
 	push	ebp
 	mov	ebp, esp
 	mov	eax, [ebp+8]
 	mov	cr0, eax
 	pop	ebp
 	ret
 ;returns the value in the CR0 register
 ;extern dword read_cr0();
 [global _read_cr0]
 _read_cr0:
 	mov	eax, cr0;
 	ret
 ;stores the parameter to the CR3 register
 ;extern dword write_cr3(dword cr3);
 [global _write_cr3]
 _write_cr3:
 	push	ebp
 	mov	ebp, esp
 	mov	eax, [ebp+8]
 	mov	cr3, eax
 	pop	ebp
 	ret
 ;returns the value in the CR2 register
 ;extern dword read_cr2();
 [global _read_cr2]
 _read_cr2:
 	mov	eax, cr2;
 	ret
 ;returns the value in the CR3 register
 ;extern dword read_cr3();
 [global _read_cr3]
 _read_cr3:
 	mov	eax, cr3;
 	ret
 ;compares one string to another
 ;returns 0 if the strings are different
 ;extern dword strcmp(char *str1, char *str2);
 [global _strcmp]
 _strcmp:
 	push	ebp
 	mov	ebp, esp
 	push	esi
 	push	edi
 	mov	esi, [ebp+8]
 	mov	edi, [ebp+12]
 strcmp_loop1:
 	lodsb
 	mov	ah, [edi]
 	inc	edi
 	cmp	ah, al
 	jnz	strcmp_ne
 	or	al, al
 	jz	strcmp_e
 	jmp	strcmp_loop1
 strcmp_e:
 	mov	eax, 1
 	jmp short strcmp_done
 strcmp_ne:
 	xor	eax, eax
 strcmp_done:
 	pop	edi
 	pop	esi
 	pop	ebp
 	ret
 ;copies a string from the source to the destination parameter
 ;extern void strcpy(char *dest, char *src);
 [global _strcpy]
 _strcpy:
 	push	ebp
 	mov	ebp, esp
 	push	esi
 	push	edi
 	mov	edi, [ebp+8]
 	mov	esi, [ebp+12]
 strcpyloop:
 	lodsb
 	stosb
 	or	al, al
 	jnz	strcpyloop
 	pop	edi
 	pop	esi
 	pop	ebp
 	ret
 ;copies memory of n bytes from src to destination
 ;extern void memcpy(dword dest, dword src, dword n);
 [global _memcpy]
 _memcpy:
 	push	ebp
 	mov	ebp, esp
 	push	esi
 	push	edi
 	push	ecx
 	mov	edi, [ebp+8]
 	mov	esi, [ebp+12]
 	mov	ecx, [ebp+16]
 	rep	movsb
 	pop	ecx
 	pop	edi
 	pop	esi
 	pop	ebp
 	ret
 ;returns the number of characters in a string
 ;extern dword strlen(char *str);
 [global _strlen]
 _strlen:
 	push	ebp
 	mov	ebp, esp
 	push	esi
 	push	ebx
 	mov	esi, [ebp+8]
 	xor	ebx, ebx
 strlenloop:
 	lodsb
 	or	al, al
 	jz	strlendone
 	inc	ebx
 	jmp	strlenloop
 strlendone:
 	mov	eax, ebx
 	pop	ebx
 	pop	esi
 	pop	ebp
 	ret
 ;this function invalidates the page directory/table entry that
 ; would be used to access the memory address given in the parameter
 ;extern void invlpg(dword addr);
 [global _invlpg]
 _invlpg:
 	mov	eax, [esp+4]
 	invlpg	[eax]
 	ret
 ;
 ;void writeCursorPosition(word pos)
 ;
 [global _writeCursorPosition]
 _writeCursorPosition:
 	push	ebp
 	mov	ebp, esp
 	push	eax
 	push	ebx
 	push	edx
 	mov	eax, [ebp+8]	;cursor position in ax
 	mov	bl, al
 	mov	dx, 0x03D4
 	mov	al, 0x0E
 	out	dx, al
 	inc	dx
 	mov	al, ah
 	out	dx, al
 	dec	dx
 	mov	al, 0x0F
 	out	dx, al
 	inc	dx
 	mov	al, bl
 	out	dx, al
 	pop	edx
 	pop	ebx
 	pop	eax
 	pop	ebp
 	ret
 ;
 ;word getCursorPosition()
 ;
 [global _getCursorPosition]
 _getCursorPosition:
 	push	ebx
 	push	edx
 	xor	eax, eax
 	mov	dx, 0x03D4
 	mov	al, 0x0E
 	out	dx, al
 	inc	dx
 	in	al, dx
 	mov	bl, al
 	dec	dx
 	mov	al, 0x0F
 	out	dx, al
 	inc	dx
 	in	al, dx
 	mov	ah, bl
 	pop	edx
 	pop	ebx
 	ret
 ;
 ;void console_scroll()
 ;
 [global _console_scroll]
 _console_scroll:
 	pusha
 	mov	esi, _console_memory+160
 	mov	edi, _console_memory
 	mov	ecx, 960			;(2000-80)/2
 	rep	movsd
 	mov	ax, 0x0720
 	mov	ecx, 80
 	rep	stosw
 	mov	esi, _console_memory
 	mov	edi, 0xC00B8000
 	mov	ecx, 1000
 	rep	movsd
 	mov	eax, [_videoMode]
 	cmp	eax, 0
 	jz	_console_scroll_end
 	call	_video_drawConsole
 _console_scroll_end:
 	popa
 	ret
 ;
 ;void console_cls()
 ;
 [global _console_cls]
 _console_cls:
 	pusha
 	mov	edi, _console_memory
 	mov	ax, 0x0720
 	mov	ecx, 2000
 	rep	stosw
 	push	dword 0
 	call	_writeCursorPosition
 	add	esp, 4
 	mov	[_cursorPosition], dword 0
 	mov	esi, _console_memory
 	mov	edi, 0xC00B8000
 	mov	ecx, 1000
 	rep	movsd
 	popa
 	ret
 ;
 ;int puts(char *str)
 ;
 [global _puts]
 _puts:
 	push	ebp
 	mov	ebp, esp
 	push	esi
 	push	eax
 	mov	esi, [ebp+8]			;esi = to string
 puts_loop:
 	lodsb
 	cmp	al, 0
 	jz	puts_done
 	push	eax
 	call	_putc
 	add	esp, 4
 	jmp	puts_loop
 puts_done:
 	pop	eax
 	pop	esi
 	pop	ebp
 	ret
 [global _putDecu]
 _putDecu:
 	push	ebp
 	mov	ebp, esp
 	sub	esp, 24
 	mov	DWORD [ebp-4], 1
 	mov	BYTE [ebp-5], 0
 L2:
 	mov	edx, DWORD [ebp+8]
 	mov	eax, -858993459
 	mul	edx
 	mov	eax, edx
 	shr	eax, 3
 	cmp	eax, DWORD [ebp-4]
 	jae	L4
 	jmp	L3
 L4:
 	mov	eax, DWORD [ebp-4]
 	mov	edx, eax
 	sal	edx, 2
 	add	edx, eax
 	lea	eax, [edx+edx]
 	mov	DWORD [ebp-4], eax
 	jmp	L2
 L3:
 	nop
 L5:
 	cmp	DWORD [ebp-4], 1
 	ja	L7
 	jmp	L6
 L7:
 	mov	edx, DWORD [ebp+8]
 	mov	eax, edx
 	mov	edx, 0
 	div	DWORD [ebp-4]
 	mov	DWORD [ebp-12], eax
 	mov	al, BYTE [ebp-12]
 	mov	BYTE [ebp-5], al
 	mov	eax, 0
 	mov	al, BYTE [ebp-5]
 	imul	eax, DWORD [ebp-4]
 	sub	DWORD [ebp+8], eax
 	mov	edx, DWORD [ebp-4]
 	mov	eax, -858993459
 	mul	edx
 	mov	eax, edx
 	shr	eax, 3
 	mov	DWORD [ebp-4], eax
 	lea	eax, [ebp-5]
 	add	BYTE [eax], 48
 	sub	esp, 12
 	mov	eax, 0
 	mov	al, BYTE [ebp-5]
 	push	eax
 	call	_putc
 	add	esp, 16
 	jmp	L5
 L6:
 	sub	esp, 12
 	mov	al, BYTE [ebp+8]
 	add	eax, 48
 	and	eax, 255
 	push	eax
 	call	_putc
 	add	esp, 16
 	leave
 	ret
 [global _putDec]
 _putDec:
 	push	ebp
 	mov	ebp, esp
 	sub	esp, 24
 	cmp	DWORD [ebp+8], 0
 	jns	L9
 	sub	esp, 12
 	push	45
 	call	_putc
 	add	esp, 16
 	neg	DWORD [ebp+8]
 L9:
 	mov	DWORD [ebp-4], 1
 	mov	BYTE [ebp-5], 0
 L10:
 	mov	eax, DWORD [ebp+8]
 	cmp	eax, DWORD [ebp-4]
 	jae	L12
 	jmp	L11
 L12:
 	mov	eax, DWORD [ebp-4]
 	mov	edx, eax
 	sal	edx, 2
 	add	edx, eax
 	lea	eax, [edx+edx]
 	mov	DWORD [ebp-4], eax
 	jmp	L10
 L11:
 	mov	edx, DWORD [ebp-4]
 	mov	eax, -858993459
 	mul	edx
 	mov	eax, edx
 	shr	eax, 3
 	mov	DWORD [ebp-4], eax
 L13:
 	cmp	DWORD [ebp-4], 1
 	ja	L15
 	jmp	L14
 L15:
 	mov	edx, DWORD [ebp+8]
 	mov	eax, edx
 	mov	edx, 0
 	div	DWORD [ebp-4]
 	mov	DWORD [ebp-12], eax
 	mov	al, BYTE [ebp-12]
 	mov	BYTE [ebp-5], al
 	mov	eax, 0
 	mov	al, BYTE [ebp-5]
 	imul	eax, DWORD [ebp-4]
 	sub	DWORD [ebp+8], eax
 	mov	edx, DWORD [ebp-4]
 	mov	eax, -858993459
 	mul	edx
 	mov	eax, edx
 	shr	eax, 3
 	mov	DWORD [ebp-4], eax
 	lea	eax, [ebp-5]
 	add	BYTE [eax], 48
 	sub	esp, 12
 	mov	eax, 0
 	mov	al, BYTE [ebp-5]
 	push	eax
 	call	_putc
 	add	esp, 16
 	jmp	L13
 L14:
 	sub	esp, 12
 	mov	al, BYTE [ebp+8]
 	add	eax, 48
 	and	eax, 255
 	push	eax
 	call	_putc
 	add	esp, 16
 	leave
 	ret
@@ -1,12 +0,0 @@
@echo off
 echo Backing up to .\Backup\%1
 mkdir .\Backup\%1
 copy *.h .\Backup\%1
 copy *.c .\Backup\%1
 copy *.inc .\Backup\%1
 copy *.asm .\Backup\%1
 copy *.ld .\Backup\%1
 copy *.bat .\Backup\%1
@@ -0,0 +1,52 @@
 # configuration file generated by Bochs
 plugin_ctrl: unmapped=1, biosdev=1, speaker=1, extfpuirq=1, gameport=1, pci_ide=1, acpi=1, ioapic=1
 config_interface: textconfig
 display_library: sdl
 megs: 32
 romimage: file="/usr/share/bochs/BIOS-bochs-latest"
 vgaromimage: file="/usr/share/bochs/VGABIOS-lgpl-latest"
 boot: cdrom
 floppy_bootsig_check: disabled=0
 # no floppya
 # no floppyb
 ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
 ata0-master: type=cdrom, path="hos.iso", status=inserted, biosdetect=auto, model="Generic 1234"
 ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15
 ata2: enabled=0
 ata3: enabled=0
 parport1: enabled=1, file=""
 parport2: enabled=0
 com1: enabled=1, mode=null, dev=""
 com2: enabled=0
 com3: enabled=0
 com4: enabled=0
 usb_uhci: enabled=0
 usb_ohci: enabled=0
 i440fxsupport: enabled=1
 vga_update_interval: 50000
 vga: extension=vbe
 cpu: count=1, ips=4000000, reset_on_triple_fault=1, cpuid_limit_winnt=0
 print_timestamps: enabled=0
 # no gdb stub
 port_e9_hack: enabled=0
 text_snapshot_check: enabled=0
 private_colormap: enabled=0
 clock: sync=none, time0=local
 # no cmosimage
 ne2k: enabled=0
 pnic: enabled=0
 sb16: enabled=0
 # no loader
 log: -
 logprefix: %t%e%d
 panic: action=ask
 error: action=report
 info: action=report
 debug: action=ignore
 pass: action=fatal
 keyboard_type: mf
 keyboard_serial_delay: 250
 keyboard_paste_delay: 100000
 keyboard_mapping: enabled=0, map=
 user_shortcut: keys=none
 mouse: enabled=0, type=ps2
@@ -1,26 +0,0 @@
 %define VERSION		"0.13"			;HOS version
 %define BOOT_FAT_SEG	0x07E0			;right after boot sector
 %define BOOT_ROOT_SEG	0x0900			;right after FAT
 %define BOOT_KERNEL_SEG	0x0AC0			;right after ROOT_DIR
 %define BOOT_STAGE2_SEG	0x0B00			;right after KERNEL_SEG
 %define BOOT_STAGE2_ADD	0xB000			;address of stage2 to jump to, org at
 %define BOOT_KERNEL_ADD	0x106000		;final pmode kernel destination - physical
 %define BOOT_RD_ADD	0x200000		;2mb for ram disk
 %define BOOT_DATA_SEG	0x9000			;data gathered by stage2 loader goes here
 %define BOOT_HASRD	0x0000		;1
 %define BOOT_VESA	0x0002		;2 - 0 for console, otherwise VESA mode
 %define BOOT_VESA_OEM	0x0004		;258 - null-terminated OEM identification string
 %define BOOT_VESA_VBE	0x0106		;512 - copy of VESA VBEInfoBlock
 %define	BOOT_VESA_INFO	0x0306		;256 - copy of VESA ModeInfoBlock for selected mode
 %define BOOT_MEMENTRIES	0x040A		;4 - dword = number of memmap entries
 %define BOOT_MEMMAP	0x2000		;? -  memory map information
 %define BOOT_DRIVE	0x7C24		;1 - boot drive
@@ -1,2 +0,0 @@
 nasmw -f aout -o ks.o -l .\lst\kernel.lst kernel.asm
@@ -1 +0,0 @@
 gcc -ffreestanding -fno-builtin -nostdlib -nodefaultlibs -c kernel.c -o kernel.o
@@ -1 +0,0 @@
 nasmw -f aout -o asmfuncs.o -l .\lst\asmfuncs.lst asmfuncs.asm
@@ -1 +0,0 @@
 copy kernel.bin a:
@@ -1,2 +0,0 @@
 rem rawrite -f stage1.bin -d a -n
 partcopy stage1.bin 0 200 -f0
@@ -1 +0,0 @@
 copy stage2.bin a:
@@ -1 +0,0 @@
 nasmw -f bin -o stage1.bin -l .\lst\stage1.lst stage1.asm
@@ -1 +0,0 @@
 nasmw -f bin -o stage2.bin -l .\lst\stage2.lst stage2.asm
@@ -1,345 +0,0 @@
 // fat12.c
 // Author: Josh Holtrop
 // Created: 01/04/04
 // Modified: 01/14/04
 byte *fat12_readFile(char *fileName, DiskDevice *dd)
 {
 	char *fileNameUCase = malloc(strlen(fileName) + 1);
 	strcpy(fileNameUCase, fileName);
 	ucase(fileNameUCase);
 	dword iMadeClusterChain = getClusterChain(dd);
 	Fat12Entry fe;
 	if (fat12_getFileHandle(fileNameUCase, dd, &fe))
 	{
 		free(fileNameUCase);
 		if (iMadeClusterChain)
 		{
 			free(clusterChain);
 			clusterChain = 0;
 		}
 		return 0;
 	}
 	byte *fp = (byte *)fat12_readClusterChain(dd, &fe);
 	free(fileNameUCase);
 	if (iMadeClusterChain)
 	{
 		free(clusterChain);
 		clusterChain = 0;
 	}
 	return fp;
 }
 dword	fat12_getFileHandle(char *fileName, DiskDevice *dd, Fat12Entry *destination)
 {
 	if (strlen(fileName) < 1)
 		return 1;
 	if (fileName[strlen(fileName)-1] == '/')
 		return 2;
 	dword iMadeClusterChain = getClusterChain(dd);
 	int fileName_length = strlen(fileName);
 	int a;
 	int entries = 1;
 	for (a = 0; a < fileName_length; a++)
 	{
 		if (fileName[a] == '/')
 		{
 			fileName[a] = 0;
 			entries++;
 		}
 	}
 	char *pointer = fileName;
 	Fat12Entry *workingDirectory = 0;
 	Fat12Entry workingDir;
 	for (a = 0; a < (entries - 1); a++)
 	{
 		if (fat12_getDirectoryHandle(pointer, dd, workingDirectory, &workingDir))	//an error occurred if this returns nonzero
 		{
 			if (iMadeClusterChain)
 			{
 				free(clusterChain);
 				clusterChain = 0;
 			}
 			return 3;
 		}
 		workingDirectory = &workingDir;
 		for (;;)				//advance to the next dir name
 		{
 			pointer++;
 			if (*pointer == 0)
 			{
 				pointer++;
 				break;
 			}
 		}
 	}
 	if (fat12_getFileHandleInDirectory(pointer, dd, workingDirectory, destination))		//an error occurred if this returns nonzero
 	{
 		if (iMadeClusterChain)
 		{
 			free(clusterChain);
 			clusterChain = 0;
 		}
 		return 4;
 	}
 	if (iMadeClusterChain)
 	{
 		free(clusterChain);
 		clusterChain = 0;
 	}
 	return 0;
 }
 dword	fat12_getFileHandleInDirectory(char *fileName, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination)
 {
 	if (!currDir)			// we are working in the root directory
 	{
 		Fat12Entry *rootDir = malloc(14*512);		//root directory is 14 sectors long
 		vfs_readSector(dd, 19, (byte *)rootDir, 14);
 		int a;
 		for (a = 0; a < 224; a++)			//224 max root directory entries in 14 sectors
 		{
 			if (rootDir[a].fileName[0] == 0)
 				break;
 			if ((byte)rootDir[a].fileName[0] != 0xE5)
 			{
 				if ((rootDir[a].attributes & 0x18) == 0)	//this entry is a directory
 				{
 					char dirName[9];
 					char dirExt[4];
 					memcpy(dirName, rootDir[a].fileName, 8);
 					dirName[8] = 0;
 					memcpy(dirExt, rootDir[a].ext, 3);
 					dirExt[3] = 0;
 					rtrim(dirName);
 					rtrim(dirExt);
 					char dirWhole[14];
 					strcpy(dirWhole, dirName);
 					if (strlen(dirExt) > 0)			//the directory has an extension
 					{
 						strcat(dirWhole, ".");
 						strcat(dirWhole, dirExt);
 					}
 					if (strcmp(dirWhole, fileName))	//the entry found is a match
 					{
 						free(rootDir);
 						*destination = rootDir[a];
 						return 0;
 					}
 				}
 			}
 		}
 		free(rootDir);
 		return 1;	//no match found
 	}
 	dword retVal = 2;
 	dword iMadeClusterChain = getClusterChain(dd);
 	Fat12Entry *subDirectory = fat12_readClusterChain(dd, currDir);
 	if (!subDirectory)
 		return 5;
 	dword numberOfClusters = fat12_readClusterChainCount(dd, currDir);
 	int a;
 	for (a = 0; a < (numberOfClusters * 16); a++)
 	{
 		if (subDirectory[a].fileName[0] == 0)
 			break;
 		if ((byte)subDirectory[a].fileName[0] != 0xE5)
 		{
 			if ((subDirectory[a].attributes & 0x18) == 0)	//this entry is a directory
 			{
 				char dirName[9];
 				char dirExt[4];
 				memcpy(dirName, subDirectory[a].fileName, 8);
 				dirName[8] = 0;
 				memcpy(dirExt, subDirectory[a].ext, 3);
 				dirExt[3] = 0;
 				rtrim(dirName);
 				rtrim(dirExt);
 				char dirWhole[14];
 				strcpy(dirWhole, dirName);
 				if (strlen(dirExt) > 0)			//the directory has an extension
 				{
 					strcat(dirWhole, ".");
 					strcat(dirWhole, dirExt);
 				}
 				if (strcmp(dirWhole, fileName))	//the entry found is a match
 				{
 					*destination = subDirectory[a];
 					retVal = 0;
 					break;
 				}
 			}
 		}
 	}
 	free(subDirectory);
 	if (iMadeClusterChain)
 	{
 		free(clusterChain);
 		clusterChain = 0;
 	}
 	return retVal;
 }
 dword	fat12_getDirectoryHandle(char *directory, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination)
 {
 	if (!currDir)			// we are working in the root directory
 	{
 		Fat12Entry *rootDir = malloc(14*512);		//root directory is 14 sectors long
 		vfs_readSector(dd, 19, (byte *)rootDir, 14);
 		int a;
 		for (a = 0; a < 224; a++)			//224 max root directory entries in 14 sectors
 		{
 			if (rootDir[a].fileName[0] == 0)
 				break;
 			if ((byte)rootDir[a].fileName[0] != 0xE5)
 			{
 				if ((rootDir[a].attributes & 0x18) == 0x10)	//this entry is a directory
 				{
 					char dirName[9];
 					char dirExt[4];
 					memcpy(dirName, rootDir[a].fileName, 8);
 					dirName[8] = 0;
 					memcpy(dirExt, rootDir[a].ext, 3);
 					dirExt[3] = 0;
 					rtrim(dirName);
 					rtrim(dirExt);
 					char dirWhole[14];
 					strcpy(dirWhole, dirName);
 					if (strlen(dirExt) > 0)			//the directory has an extension
 					{
 						strcat(dirWhole, ".");
 						strcat(dirWhole, dirExt);
 					}
 					if (strcmp(dirWhole, directory))	//the entry found is a match
 					{
 						free(rootDir);
 						*destination = rootDir[a];
 						return 0;
 					}
 				}
 			}
 		}
 		free(rootDir);
 		return 1;	//no match found
 	}
 	dword retVal = 2;
 	dword iMadeClusterChain = getClusterChain(dd);
 	Fat12Entry *subDirectory = fat12_readClusterChain(dd, currDir);
 	if (!subDirectory)
 		return 5;
 	dword numberOfClusters = fat12_readClusterChainCount(dd, currDir);
 	int a;
 	for (a = 0; a < (numberOfClusters * 16); a++)
 	{
 		if (subDirectory[a].fileName[0] == 0)
 			break;
 		if ((byte)subDirectory[a].fileName[0] != 0xE5)
 		{
 			if ((subDirectory[a].attributes & 0x18) == 0x10)	//this entry is a directory
 			{
 				char dirName[9];
 				char dirExt[4];
 				memcpy(dirName, subDirectory[a].fileName, 8);
 				dirName[8] = 0;
 				memcpy(dirExt, subDirectory[a].ext, 3);
 				dirExt[3] = 0;
 				rtrim(dirName);
 				rtrim(dirExt);
 				char dirWhole[14];
 				strcpy(dirWhole, dirName);
 				if (strlen(dirExt) > 0)			//the directory has an extension
 				{
 					strcat(dirWhole, ".");
 					strcat(dirWhole, dirExt);
 				}
 				if (strcmp(dirWhole, directory))	//the entry found is a match
 				{
 					*destination = subDirectory[a];
 					retVal = 0;
 					break;
 				}
 			}
 		}
 	}
 	free(subDirectory);
 	if (iMadeClusterChain)
 	{
 		free(clusterChain);
 		clusterChain = 0;
 	}
 	return retVal;
 }
 Fat12Entry *fat12_readClusterChain(DiskDevice *dd, Fat12Entry *directory)
 {
 	dword numberOfClusters = fat12_readClusterChainCount(dd, directory);
 	if (numberOfClusters == 0)
 		return 0;
 	byte *bp = malloc(numberOfClusters * 512);
 	Fat12Entry *retVal = (Fat12Entry *)bp;
 	dword cluster = directory->firstCluster;
 	while (cluster < 0xFF0)
 	{
 		vfs_readSector(dd, cluster + 31, bp, 1);
 		cluster = fat12_getNextCluster(cluster);
 		bp += 512;
 	}
 	return retVal;
 }
 dword	fat12_readClusterChainCount(DiskDevice *dd, Fat12Entry *directory)
 {
 	dword numberOfClusters = 0;
 	dword cluster = directory->firstCluster;
 	if (cluster == 0)
 		return 0;
 	while (cluster < 0xFF0)
 	{
 		cluster = fat12_getNextCluster(cluster);
 		numberOfClusters++;
 	}
 	return numberOfClusters;
 }
 dword	fat12_getNextCluster(dword thisCluster)
 {
 	dword nextCluster = *(word *)((dword)clusterChain + ((thisCluster * 3) >> 1));
 	if (thisCluster & 0x01)		//this is an odd cluster
 		return nextCluster >> 4;
 	else				//this is an even cluster
 		return nextCluster & 0x0FFF;
 }
 dword	fat12_getFileSize(char *fileName, DiskDevice *dd)
 {
 	Fat12Entry fe;
 	if (fat12_getFileHandle(fileName, dd, &fe))
 		return 0xFFFFFFFF;
 	return fe.fileSize;
 }
 dword	getClusterChain(DiskDevice *dd)
 {
 	if (!clusterChain)
 	{
 		clusterChain = malloc(9*512);	//9 sectors for File Allocation Table (cluster chain)
 		vfs_readSector(dd, 1, clusterChain, 9);	//sectors 1 through 9 contain the first FAT
 		return 1;			//this call created the cluster chain
 	}
 	else
 		return 0;			//this call did not create the cluster chain
 }
@@ -1,58 +0,0 @@
 // fat12.h
 // Author: Josh Holtrop
 // Created: 01/04/04
 typedef struct	{
 	char	fileName[8];
 	char	ext[3];
 	byte	attributes;
 	dword	createTime;
 	word	createDate;
 	word	accessDate;
 	word	unused0;
 	word	modifiedDate;
 	word	modifiedTime;
 	word	firstCluster;
 	dword	fileSize;
 } __attribute__((packed)) Fat12Entry;
 typedef struct	{
 	byte	jump[3];
 	byte	sysName[8];
 	word    bytesPerSector;
 	byte	sectorsPerCluster;
 	word	reservedSectors;
 	byte	FATcount;
 	word	maxRootEntries;
 	word	totalSectors1;
 	byte	mediaDescriptor;
 	word	sectorsPerFAT;
 	word	sectorsPerTrack;
 	word	headCount;
 	dword	hiddenSectors;
 	dword	totalSectors2;
 	byte	driveNumber;
 	byte	reserved1;
 	byte	extBootSignature;
 	dword	volumeSerial;
 	char	volumeLabel[11];
 	char	fileSystemID[8];
 } __attribute__((packed)) Fat12BootSector;
 byte *fat12_readFile(char *fileName, DiskDevice *dd);
 dword	fat12_getFileHandle(char *fileName, DiskDevice *dd, Fat12Entry *destination);
 dword	fat12_getDirectoryHandle(char *directory, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination);
 Fat12Entry *fat12_readClusterChain(DiskDevice *dd, Fat12Entry *directory);
 dword	fat12_getFileHandleInDirectory(char *fileName, DiskDevice *dd, Fat12Entry *currDir, Fat12Entry *destination);
 dword	fat12_readClusterChainCount(DiskDevice *dd, Fat12Entry *directory);
 dword	fat12_getFileSize(char *fileName, DiskDevice *dd);
 dword	getClusterChain(DiskDevice *dd);
 dword	fat12_getNextCluster(dword thisCluster);
 byte	*clusterChain = 0;
@@ -1,9 +0,0 @@
 //fdc.c
 //Author: Josh Holtrop
 //Date: 10/30/03
 inline	void	fdc_sendDOR(byte dor)
 {
 	outportb(FDC_DOR, dor);
 }
@@ -1,12 +0,0 @@
 //fdc.h
 //Author: Josh Holtrop
 //Date: 10/30/03
 #define FDC_DOR 0x3f2
 #define FDC_MSR 0x3f4
 inline	void	fdc_sendDOR(byte dor);
@@ -1,46 +0,0 @@
 //functions.h
 //05/07/03 Josh Holtrop
 //for HOS
 //Modified: 10/30/03
 extern dword _code;
 extern dword _bss;
 extern dword _end;
 inline void outportb(unsigned int port, unsigned char value);
 inline void outportw(unsigned int port, unsigned int value);
 inline byte inportb(unsigned short port);
 inline void enable_ints();
 inline void disable_ints();
 inline void restart();
 inline void halt();
 void remap_pics(int pic1, int pic2);
 inline void pic1_mask(byte mask);
 inline void pic2_mask(byte mask);
 inline void eoi();
 inline void eoi2();
 inline dword kernel_size();
 inline void init_timer();
 char *strcat(char *dest, char *src);
 void	rtrim(char *str);
 char	*ucase(char *str);
 char	*lcase(char *str);
 inline byte bcd2byte(byte bcd);
 inline byte byte2bcd(byte bite);
 byte	rtc_readDay();
 byte	rtc_readMonth();
 byte	rtc_readYear();
 byte	rtc_readSecond();
 byte	rtc_readMinute();
 byte	rtc_readHour();
 void	rtc_setDay(byte dat);
 void	rtc_setMonth(byte month);
 void	rtc_setYear(byte year);
 void	rtc_setSecond(byte second);
 void	rtc_setMinute(byte minute);
 void	rtc_setHour(byte hour);
@@ -1 +0,0 @@
 gcc -S kernel.c -masm=intel -fno-builtin
@@ -1,71 +0,0 @@
 ;gdt.inc
 ;Author: Josh Holtrop
 ;for HOS
 ;Modified: 10/30/03
 gdtr:
 	dw	gdt_end-gdt-1
 	dd	GDT_P
 gdt:
 	dd	0
 	dd	0
 KERNEL_CODE equ $-gdt
 	dw	0xffff	;limit 15:0
 	dw	0x0000	;base  15:0
 	db	0x00	;base  23:16
 	db	0x9A	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 KERNEL_DATA equ $-gdt
 	dw	0xffff	;limit 15:0
 	dw	0x0000	;base  15:0
 	db	0x00	;base  23:16
 	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 VESA_CODE equ $-gdt
 	dw	0xffff	;limit 15:0
 	dw	0x0000	;base  15:0
 	db	0x00	;base  23:16
 	db	0x9A	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 VESA_DATA equ $-gdt
 	dw	0xffff	;limit 15:0
 	dw	0x0000	;base  15:0
 	db	0x00	;base  23:16
 	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 VIDEO_TEXT equ $-gdt
 	dw	0x7FFF	;limit 15:0
 	dw	0x8000	;base  15:0
 	db	0x0B	;base  23:16
 	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 VIDEO_GRAPHICS equ $-gdt
 	dw	0xFFFF	;limit 15:0
 	dw	0x0000	;base  15:0
 	db	0x0A	;base  23:16
 	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 USER_CODE equ $-gdt
 	dw	0xffff	;limit 15:0
 	dw	0x0000	;base  15:0
 	db	0x00	;base  23:16
 	db	0xFA	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 USER_DATA equ $-gdt
 	dw	0xffff	;limit 15:0
 	dw	0x0000	;base  15:0
 	db	0x00	;base  23:16
 	db	0xF2	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
 	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
 	db	0x00	;base  31:24
 gdt_end:
@@ -1 +0,0 @@
 partcopy -f0 0 168000 flop.img
@@ -1,111 +0,0 @@
 ;idt.inc
 ;Author: Josh Holtrop
 ;for HOS
 ;Modified: 10/30/03
 idtr:
 	dw	50*8-1		;size of idt
 	dd	IDT_V		;address of idt
 %macro isr_label 1
 isr_%1:
 	push	eax
 	mov	eax, %1
 	jmp	isr_main
 %endmacro
 isr_label	0
 isr_label	1
 isr_label	2
 isr_label	3
 isr_label	4
 isr_label	5
 isr_label	6
 isr_label	7
 isr_label	8
 isr_label	9
 isr_label	10
 isr_label	11
 isr_label	12
 isr_label	13
 isr_label	14
 isr_label	15
 isr_label	16
 isr_label	17
 isr_label	18
 isr_label	19
 isr_label	20
 isr_label	21
 isr_label	22
 isr_label	23
 isr_label	24
 isr_label	25
 isr_label	26
 isr_label	27
 isr_label	28
 isr_label	29
 isr_label	30
 isr_label	31
 isr_label	32
 isr_label	33
 isr_label	34
 isr_label	35
 isr_label	36
 isr_label	37
 isr_label	38
 isr_label	39
 isr_label	40
 isr_label	41
 isr_label	42
 isr_label	43
 isr_label	44
 isr_label	45
 isr_label	46
 isr_label	47
 isr_label	48
 isr_label	49
 isr_main:
 	cmp	eax, 0x30
 	jz	isr_syscall
 	pusha
 	push	ds
 	push	es
 	push	eax
 	call	_isr
 	pop	eax
 	pop	es
 	pop	ds
 	popa
 	pop	eax
 	iret
 isr_syscall:
 	pop	eax	;syscall function number
 	pusha
 	push	ds
 	push	es
 	push	ebx
 	call	_putc
 	add	esp, 4
 	pop	es
 	pop	ds
 	popa
 	iret
@@ -0,0 +1,6 @@
 timeout 2
 default 0
 title HOS
 kernel /boot/hos.gz
@@ -1,51 +0,0 @@
 //k_defines.h
 //03/17/03 Josh Holtrop
 //Modified: 10/30/03
 #define	PIC1		0x20
 #define	PIC2		0xA0
 #define	PIC1_COMMAND	PIC1
 #define	PIC1_DATA	(PIC1+1)
 #define	PIC2_COMMAND	PIC2
 #define	PIC2_DATA	(PIC2+1)
 #define	PIC_EOI		0x20
 #define	ICW1_ICW4	0x01		/* ICW4 (not) needed */
 #define	ICW1_SINGLE	0x02		/* Single (cascade) mode */
 #define	ICW1_INTERVAL4	0x04		/* Call address interval 4 (8) */
 #define	ICW1_LEVEL	0x08		/* Level triggered (edge) mode */
 #define	ICW1_INIT	0x10		/* Initialization - required! */
 #define	ICW4_8086	0x01		/* 8086/88 (MCS-80/85) mode */
 #define	ICW4_AUTO	0x02		/* Auto (normal) EOI */
 #define	ICW4_BUF_SLAVE	0x08		/* Buffered mode/slave */
 #define	ICW4_BUF_MASTER	0x0C		/* Buffered mode/master */
 #define	ICW4_SFNM	0x10		/* Special fully nested (not) */
 #define BLUE_TXT	0x01
 #define RED_TXT		0x04
 #define WHITE_TXT	0x07
 #define CYAN_TXT	0x0B
 #define YELLOW_TXT	0x0E
 #define BRWHITE_TXT	0x0F
 #define FREERAM_START	0x368000	// 0x368000 is first available byte (this is right after the initrd @ 2mb, 1440kb.
 #define MAX_RAM		0x40000000	//1gb maximum RAM supported
 #define PID_KERNEL	0x02		//kernel's PID
 #define PID_VMM		0x03
 #define PID_USER	0x10000		//user processes' start PID
 typedef	unsigned char	byte;
 typedef	unsigned short	word;
 typedef	unsigned int	dword;
 typedef struct {
 	dword	lowdword;
 	dword	highdword;
 } __attribute__((packed)) qword;
@@ -1,101 +0,0 @@
 ;kernel.asm
 ;Author: Josh Holtrop
 ;Modified: 10/30/03
 %define GDT_P	0x100000;	;1mb physical - Global Descriptor Table space
 %define GDT_V	GDT_P+0xC0000000
 %define IDT_P	0x102000	;1mb+8kb - Interrupt Descriptor Table space
 %define IDT_V	IDT_P+0xC0000000
 %define PDBR_P	0x104000	;1mb+16kb - Page Directory Base Register (first PD)
 %define PDBR_V	PDBR_P+0xC0000000
 %define LOPT_P	0x105000	;1mb+20kb - LOw Page Table for mapping first 4mb
 %define LOPT_V	LOPT_P+0xC0000000
 %define KERNEL_P 0x106000	;1mb+24kb - the kernel's physical address
 %define KERNEL_V KERNEL_P+0xC0000000	;3gb+1mb+24kb, the virtual address of the kernel
 [global start]
 [extern _isr]
 [extern _k_init]
 [extern _putc]
 bits 32
 ;This is where the kernel begins execution
 ;At this point, the temporary gdt is set up to "map" 0xC000_0000 to 0x0.
 ;We must enable paging with the first 4mb mapped 1:1 virtual:physical
 ; and with the 4mb starting at 0xC000_0000 mapped to the first 4mb physical.
 ;Then we can start using our "real" gdt, then unmap the lower 4mb.
 start:
 	cli					;if they weren't already off
 	xor	eax, eax
 	mov	edi, PDBR_V
 	mov	ecx, 1024			;clear the PDBR
 	rep stosd
 	mov	[PDBR_V], dword LOPT_P|0x03		;store the physical address of the LOw Page Table (read/write, present)
 	mov	[PDBR_V+0xC00], dword LOPT_P|0x03	;store the physical address of the LOw Page Table (read/write, present)
 	mov	edi, LOPT_V
 	mov	ecx, 1024
 	mov	eax, 0x03			;starting physical address = 0x0 (read/write, present flags)
 fill_lopt_loop:					;fill the page table
 	stosd
 	add	eax, 4096			;increment next phsyical address by 4kb
 	loop	fill_lopt_loop
 	mov	eax, PDBR_P
 	mov	cr3, eax			;store the Page Directory Base Address
 	mov	eax, cr0
 	or	eax, 0x80000000			;set page enable bit
 	mov	cr0, eax			;now paging is active!
 	mov	edi, GDT_V
 	mov	esi, gdt
 	mov	ecx, gdt_end-gdt
 copy_gdt:
 	lodsb
 	stosb
 	loop	copy_gdt
 	mov	edi, IDT_V		;destination
 	mov	esi, isr_0		;address of isr0
 	mov	edx, isr_1-isr_0	;distance between isr labels
 	mov	ecx, 50			;number of isrlabels
 fill_idt:
 	mov	ebx, esi
 	mov	ax, si
 	stosw				;0 offset 15:0
 	mov	ax, KERNEL_CODE
 	stosw				;2 selector 15:0
 	mov	ax, 0x8E00
 	stosw				;4 [P][DPL][0][TYPE][0][0][0][0][0][0][0][0]
 	shr	esi, 16
 	mov	ax, si
 	stosw				;6 offset 31:16
 	mov	esi, ebx
 	add	esi, edx
 	loop	fill_idt
 	mov	word	[IDT_V+0x30*8+4], 0xEE00	;interrupt 0x30 has user priviledges
 	lgdt	[gdtr]			;load gdt
 	jmp	KERNEL_CODE:newgdtcontinue
 newgdtcontinue:
 	mov	ax, KERNEL_DATA
 	mov	es, ax
 	mov	ds, ax
 	mov	gs, ax
 	mov	fs, ax
 	mov	ss, ax
 	mov	esp, 0xc01ffffc		;stack just under 3gb+2mb, moves downward
 	lidt	[idtr]			;load idt
 	call	_k_init
 haltit:
 	hlt				;halt processor when k_init is done
 	jmp	haltit			;shouldn't get here...
 %include "gdt.inc"
 %include "idt.inc"
@@ -1,144 +0,0 @@
 //kernel.c
 //08/13/03 Josh Holtrop
 //Holtrop's Operating System
 //Version: 0.12
 //Modified: 12/30/03
 #include "k_defines.h"		//#DEFINE's for kernel
 #include "functions.h"		//general functions
 #include "video.h"		//video functions
 #include "mm.h"			//physical memory management functions
 #include "vmm.h"		//virtual memory management & paging functions
 #include "keyboard.h"		//generic keyboard driver & functions
 #include "mouse.h"		//generic ps/2 mouse driver & functions
 #include "fdc.h"		//Floppy Disk Controller functions
 #include "stdfont.h"		//Standard font bitmask array
 #include "kio.h"
 #include "vfs.h"
 #include "rd.h"
 #include "fat12.h"
 void isr(dword num);
 void k_init();
 /* These functions are defined in asmfuncs.asm */
 extern dword write_cr0(dword cr0);
 extern dword read_cr0();
 extern dword write_cr3(dword cr3);
 extern dword read_cr2();
 extern dword read_cr3();
 extern void writeCursorPosition(dword pos);
 extern dword getCursorPosition();
 extern void console_scroll();
 extern void console_cls();
 extern int puts(char *str);
 extern int putDec(int number);
 extern int putDecu(dword number);
 extern void strcpy(char *dest, char *src);
 extern void memcpy(void *dest, void *src, dword n);
 extern dword strlen(char *str);
 #include "fat12.c"
 #include "rd.c"
 #include "vfs.c"
 #include "kio.c"
 #include "fdc.c"
 #include "mouse.c"
 #include "keyboard.c"
 #include "mm.c"
 #include "vmm.c"
 #include "functions.c"
 #include "video.c"
 dword	timer = 0;
 //Main kernel initialization method
 void k_init()
 {
 		// ===== Initialization
 	fdc_sendDOR(0x0C);		//turn off floppy motor!!
 	console_cls();
 	video_init();
 	mm_init();
 	vmm_init();
 	remap_pics(0x20, 0x28);
 	init_timer();
 	mouse_init();
 	pic1_mask(0);			//unmask IRQ's 0-7
 	pic2_mask(0);			//unmask IRQ's 8-15
 	vfs_init();
 	enable_ints();
 	kbd_resetLEDs();		//after enabling interrupts!!
 	if (videoMode)
 	{
 		int p = video_mode.XResolution*video_mode.YResolution-1;
 		for (; p >= 0; p--)
 			video_psetp(p, 0x00000044);
 		video_drawConsole();
 	}
 	printf("HOS 0.13 - Kernel File Size: %u kb\tData Size: %u bytes\n", kernel_size()>>10, (dword)(&_end)-(dword)(&_code));
 	printf("Memory available to OS: %u MB (%u bytes)\n", mm_megabytes, mm_totalmem);
 	printf("Free memory: %u bytes (%u pages)\n", mm_freemem(), mm_freemem()>>12);
 	printf("%d/%d/%d\t%d:%d:%d\n", rtc_readMonth(), rtc_readDay(), rtc_readYear(), rtc_readHour(), rtc_readMinute(), rtc_readSecond());
 	printf("Root Directory: %s/\n", rootDevice->id);
 /*	int a;
 	byte *addr = 0;
 	for (a = 0; a < 5; a++)
 	{
 		byte *app = mm_palloc();
 		vmm_map1((dword)addr, (dword)app);
 		addr += 4096;
 	}
 	addr = vfs_readFile("/bin/hash.hos");
 	memcpy(0, addr, 4192);
 	asm("call 0");
 	free(addr);
 */
 	dword key = 0;
 	for (;;)
 	{
 		key = kbdWaitKey();
 		if ((key & 0xFF) > 2)	//key is not a control key
 			putc(key);
 	}
 }
 // main Interrupt Service Routine - handles all interrupts unless caught by kernel.asm
 void isr(dword num)
 {
 	switch(num)
 	{
 	case 14:
 		printf("Page fault, CR2 = 0x%x\n", read_cr2());
 		halt();
 		break;
 	case 0x20:         		// IRQ0 - timer interrupt
 		timer++;
 		(*(byte *)(0xc00b8000))++;
 		eoi();
 		break;
 	case 0x21:  			// IRQ1 - keyboard interrupt
 		isr_keyboard();    	//isr_keybard() takes care of calling eoi()
 		break;
 	case 0x2C:			// IRQ12 - PS/2 mouse
 		isr_mouse();
 		eoi2();
 		break;
 	default:
 		printf("Interrupt %d (0x%x) Unhandled!!\n", num, num);
 		halt();
 		break;
 	}
 }
@@ -0,0 +1,45 @@
 CROSS_COMPILE   := i586-elf-
 export LD       := $(CROSS_COMPILE)ld
 export CC       := $(CROSS_COMPILE)gcc
 export CXX      := $(CROSS_COMPILE)g++
 export OBJDUMP  := $(CROSS_COMPILE)objdump
 export NASM     := nasm
 export HOS_TOPLEVEL := $(shell pwd)
 LDSCRIPT        := link.ld
 KERNEL          := hos
 export CPPFLAGS := -I$(HOS_TOPLEVEL) -I$(HOS_TOPLEVEL)/include
 export CFLAGS   := -Wall -O2 -g
 export CXXFLAGS := -Wall -O2 -fno-rtti -fno-exceptions -g
 export LDFLAGS  := -T $(LDSCRIPT) -Map $(KERNEL).map
 export LDLIBS   := `$(CC) -print-libgcc-file-name`
 SUBDIRS         := boot mm lang isr sys
 SUBDIRS_clean   := $(SUBDIRS:%=%.clean)
 .PHONY: all
 all: $(KERNEL).gz
 $(KERNEL).gz: $(KERNEL)
 	gzip -c $< > $@
 $(KERNEL): $(KERNEL).o
 	$(LD) $(LDFLAGS) -o $@ $<
 	$(OBJDUMP) --disassemble --source $@ > $@.dump
 #	strip $@
 $(KERNEL).o: $(SUBDIRS)
 	$(LD) -r -o $@ $(foreach subdir,$(SUBDIRS),$(subdir)/$(subdir)_all.o) $(LDLIBS)
 .PHONY: $(SUBDIRS)
 $(SUBDIRS):
 	$(MAKE) -C $@ SUBDIR=$@
 .PHONY: clean
 clean: $(SUBDIRS_clean)
 	-rm -f *~ $(KERNEL) $(KERNEL).{gz,o,elf,dump,map}
 %.clean:
 	$(MAKE) -C $* clean clean=1
@@ -0,0 +1,2 @@
 include $(HOS_TOPLEVEL)/subdir.mak
@@ -0,0 +1,23 @@
 ; boot.asm
 ; Author: Josh Holtrop
 ; Date: 2009-06-25
 ; Adapted from HOS 0.16 source
 %define CONSOLE_MEMORY              0xB8000
 ; Symbols from C
 extern k_bootstrap, bootstrap_stack
 ;**************************************************************************
 ;* This is the entry point for the kernel.                                *
 ;**************************************************************************
 [global start]
 start:
    mov     cx, 0x0700 + 'a'
    mov     [CONSOLE_MEMORY+160*8+0*2], cx
    mov     esp, bootstrap_stack+4096       ; set up temporary stack space
    push    eax                             ; multiboot bootloader magic value
    push    ebx                             ; pointer to multiboot info struct
    call    k_bootstrap
@@ -0,0 +1,85 @@
 #include "k_bootstrap.h"
 #include "k_main.h"
 #include "hos_types.h"
 #include "hos_defines.h"
 #include "multiboot.h"
 #include "sys/cpu.h"
 #include "k_early_panic.h"
 #include "mm/mm.h"
 #include "mm/stack.h"
 #include "lang/kio.h"
 #include "isr/interrupts.h"
 #define DEBUG_LETTER(col,chr) *(u16_t *)(KERNEL_OFFSET + CONSOLE_MEMORY \
                                  + 160 * 8 + (col) * 2) \
                                  = 0x0700 | (chr)
 extern "C" {
 u8_t bootstrap_stack[4096];
 /**************************************************************************
 * Multiboot header data block                                            *
 *************************************************************************/
 u32_t mb_header[] __attribute__ ((section (".multiboot_header") )) = {
    MB_HEADER_MAGIC,                            /* magic */
    MB_HEADER_FLAGS,                            /* flags */
    -(MB_HEADER_MAGIC + MB_HEADER_FLAGS)        /* checksum */
 };
 /**************************************************************************
 * This function is invoked to bootstrap the kernel.                      *
 *************************************************************************/
 void k_bootstrap(mb_info_t * mb_info, u32_t mb_magic)
 {
    DEBUG_LETTER(1, 'b');
    if (mb_magic != MB_BOOTLOADER_MAGIC)
    {
        k_early_panic("Bad multiboot magic identifier!");
    }
    if ( ! (mb_info->flags & MB_BOOTLOADER_MMAP) )
    {
        k_early_panic("No memory map provided by bootloader!");
    }
    for (mb_mmap_t * mmap = (mb_mmap_t *) (mb_info->mmap_addr + KERNEL_OFFSET),
                   * end = (mb_mmap_t *) ((u32_t)mmap + mb_info->mmap_length);
         mmap < end;
         mmap = (mb_mmap_t *) (((u32_t)mmap) + mmap->size + 4))
    {
 //        kprintf(" ** size: %d, type: %d ", mmap->size, mmap->type);
        mm_record_mmap_entry(mmap);
    }
    DEBUG_LETTER(2, 'c');
    /*
     * These functions could destroy the multiboot information block and
     * associated structures, so we must be finished reading those structures
     * before calling them.
     */
    mm_bootstrap();
    DEBUG_LETTER(3, 'd');
    interrupts_bootstrap();
    DEBUG_LETTER(4, 'e');
    kio_bootstrap();
    DEBUG_LETTER(5, 'f');
    /* begin using the permanent stack */
    write_esp(KERNEL_STACK_TOP);
    k_main();
    idle_loop();
 }
 void idle_loop()
 {
    for (;;)
    {
        __asm__ __volatile__ ("hlt");
    }
 }
 } /* extern "C" */
@@ -0,0 +1,17 @@
 #ifndef K_BOOTSTRAP_H
 #define K_BOOTSTRAP_H
 #include "hos_types.h"
 #include "multiboot.h"
 extern "C" {
 void k_bootstrap(mb_info_t * mb_info, u32_t mb_magic)
    __attribute__ ((noreturn));
 void idle_loop()
    __attribute__ ((noreturn));
 }
 #endif
@@ -0,0 +1,18 @@
 #include "hos_types.h"
 #include "hos_defines.h"
 #include "k_early_panic.h"
 void k_early_panic(const char * msg)
 {
    char * dest = (char *) (CONSOLE_MEMORY + KERNEL_OFFSET);
    while (*msg)
    {
        *dest++ = *msg++;
        *dest++ = 0x04;         /* red error message */
    }
    /* infinite loop */
    for (;;)
        ;
 }
@@ -0,0 +1,15 @@
 #ifndef K_EARLY_PANIC_H
 #define K_EARLY_PANIC_H
 #ifdef __cplusplus
 extern "C" {
 #endif
 void k_early_panic(const char * msg);
 #ifdef __cplusplus
 }
 #endif
 #endif
@@ -0,0 +1,28 @@
 #include "k_main.h"
 #include "lang/kio.h"
 #include "mm/mm.h"
 #include "sys/timer.h"
 #include "sys/pic.h"
 #include "isr/interrupts.h"
 extern "C" {
 void k_main()
 {
    kprintf("Kernel load address: 0x%08x\n", KERNEL_CODE);
    kprintf("Kernel code size: %d KB (%d bytes)\n",
            (KERNEL_DATA - KERNEL_CODE) >> 10, KERNEL_DATA - KERNEL_CODE);
    kprintf("Kernel data size: %d KB (%d bytes)\n",
            (KERNEL_BSS - KERNEL_DATA) >> 10, KERNEL_BSS - KERNEL_DATA);
    kprintf("Kernel bss size:  %d KB (%d bytes)\n",
            (KERNEL_END - KERNEL_BSS) >> 10, KERNEL_END - KERNEL_BSS);
    mm_print_memory_map();
    timer_init(KERNEL_TIMER_FREQ);
    pic_remap(0x20, 0x28);
    pic_mask1(0x0);
    pic_mask2(0x0);
    interrupts_enable();
 }
 } /* extern "C" */
@@ -0,0 +1,11 @@
 #ifndef K_MAIN_H
 #define K_MAIN_H
 extern "C" {
 void k_main();
 }
 #endif
@@ -0,0 +1,47 @@
 #ifndef HOS_DEFINES_H
 #define HOS_DEFINES_H
 #include "hos_types.h"
 #define KERNEL_OFFSET           0x00000000
 #define PAGE_LOG_SIZE           12u
 #define PAGE_SIZE               (1 << PAGE_LOG_SIZE)
 #define PAGE_HIGH_MASK          (0xFFFFFFFFu << PAGE_LOG_SIZE)
 #define PAGE_LOW_MASK           (0xFFFFFFFFu >> (32 - PAGE_LOG_SIZE))
 #define CONSOLE_MEMORY          0xB8000
 #define KERNEL_CODE             (&_code)
 #define KERNEL_DATA             (&_data)
 #define KERNEL_BSS              (&_bss)
 #define KERNEL_END              (&_end)
 #define KERNEL_PHYSICAL_ADDRESS ((u32_t)(KERNEL_CODE - KERNEL_OFFSET))
 #define KERNEL_VIRTUAL_ADDRESS  ((u32_t)KERNEL_CODE)
 #define KERNEL_SIZE             ((u32_t)(KERNEL_END - KERNEL_CODE))
 #define KERNEL_TIMER_FREQ       1000
 #define BUILD_BUG_ON(condition) \
    do { \
        typedef struct { int negative_width_test : ((condition)?-1:1); } \
            BUILD_BUG_ON_DUMMY_STRUCT; \
    } \
    while(0)
 #ifdef __cplusplus
 extern "C" {
 #endif
 extern  u8_t    _code;
 extern  u8_t    _data;
 extern  u8_t    _bss;
 extern  u8_t    _end;
 #ifdef __cplusplus
 }
 #endif
 #endif
@@ -0,0 +1,55 @@
 #ifndef HOS_TYPES_H
 #define HOS_TYPES_H
 #ifdef __cplusplus
 extern "C" {
 #endif
 typedef unsigned char       u8_t;
 typedef signed char         s8_t;
 typedef unsigned short      u16_t;
 typedef signed short        s16_t;
 typedef unsigned int        u32_t;
 typedef signed int          s32_t;
 typedef unsigned long long  u64_t;
 typedef signed long long    s64_t;
 typedef struct
 {
    u32_t   gs;
    u32_t   fs;
    u32_t   es;
    u32_t   ds;
    u32_t   edi;
    u32_t   esi;
    u32_t   ebp;
    u32_t   esp_junk;               /* the esp value saved by 'pusha' */
    u32_t   ebx;
    u32_t   edx;
    u32_t   ecx;
    u32_t   eax;
    u32_t   error;                  /* valid on exceptions 8, 10-14 */
    u32_t   eip;
    u32_t   cs;
    u32_t   eflags;
    u32_t   esp;                    /* present if privilege transition */
    u32_t   ss;
 } int_stack_t;
 typedef struct
 {
    u16_t   limit;
    u32_t   base;
 } __attribute__ ((packed)) gdtr_t;
 typedef gdtr_t idtr_t;
 #ifdef __cplusplus
 }
 #endif
 #endif
@@ -0,0 +1,154 @@
 #ifndef MULTIBOOT_H
 #define MULTIBOOT_H
 #include "hos_types.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 /* The magic number for the Multiboot header. */
 #define MB_HEADER_MAGIC             0x1BADB002
 #define MB_HEADER_FLAGS             0x00000003
 #define MB_HEADER_ALIGN_MODULES     (1 << 0)
 #define MB_HEADER_MEM_INFO          (1 << 1)
 #define MB_HEADER_VIDEO_INFO        (1 << 2)
 #define MB_HEADER_KLUDGE_OFFSETS    (1 << 16)
 /* The magic number passed by a Multiboot-compliant boot loader. */
 #define MB_BOOTLOADER_MAGIC         0x2BADB002
 #define MB_BOOTLOADER_MEM_INFO      (1 << 0)
 #define MB_BOOTLOADER_BOOT_DEVICE   (1 << 1)
 #define MB_BOOTLOADER_COMMAND_LINE  (1 << 2)
 #define MB_BOOTLOADER_MODS          (1 << 3)
 #define MB_BOOTLOADER_AOUT          (1 << 4)
 #define MB_BOOTLOADER_ELF           (1 << 5)
 #define MB_BOOTLOADER_MMAP          (1 << 6)
 #define MB_BOOTLOADER_DRIVES        (1 << 7)
 #define MB_BOOTLOADER_CONFIG        (1 << 8)
 #define MB_BOOTLOADER_APM           (1 << 9)
 #define MB_BOOTLOADER_GRAPHICS      (1 << 10)
 #define MB_DRIVE_MODE_CHS           0
 #define MB_DRIVE_MODE_LBA           1
 #define MB_MMAP_TYPE_RAM            1
 /* The Multiboot header. */
 typedef struct
 {
    u32_t   magic;
    u32_t   flags;
    u32_t   checksum;
    u32_t   header_addr;        // if flags[16]
    u32_t   load_addr;          // if flags[16]
    u32_t   load_end_addr;      // if flags[16]
    u32_t   bss_end_addr;       // if flags[16]
    u32_t   entry_addr;         // if flags[16]
    u32_t   mode_type;          // if flags[2]
    u32_t   width;              // if flags[2]
    u32_t   height;             // if flags[2]
    u32_t   depth;              // if flags[2]
 } mb_header_t;
 /* The symbol table for a.out. */
 typedef struct
 {
    u32_t   tabsize;
    u32_t   strsize;
    u32_t   addr;
    u32_t   reserved;
 } mb_aout_symbol_table_t;
 /* The section header table for ELF. */
 typedef struct
 {
    u32_t   num;
    u32_t   size;
    u32_t   addr;
    u32_t   shndx;
 } mb_elf_section_header_table_t;
 /* The Multiboot information. */
 typedef struct
 {
    u32_t   flags;
    u32_t   mem_lower;          // present if flags[0] is set
    u32_t   mem_upper;
    u32_t   boot_device;        // 1
    u32_t   cmdline;            // 2
    u32_t   mods_count;         // 3
    u32_t   mods_addr;          // 3
    union
    {
        mb_aout_symbol_table_t          aout_sym;   // 4
        mb_elf_section_header_table_t   elf_sec;    // 5
    };
    u32_t   mmap_length;        // 6
    u32_t   mmap_addr;          // 6
    u32_t   drives_length;      // 7
    u32_t   drives_addr;        // 7
    u32_t   config_table;       // 8
    u32_t   bootloader_name;    // 9
    u32_t   apm_table;          // 10
    u32_t   vbe_control_info;   // 11
    u32_t   vbe_mode_info;      // 11
    u16_t   vbe_mode;           // 11
    u16_t   vbe_interface_seg;  // 11
    u16_t   vbe_interface_off;  // 11
    u16_t   vbe_interface_len;  // 11
 } mb_info_t;
 /* The module structure. */
 typedef struct
 {
    u32_t   mod_start;
    u32_t   mod_end;
    u32_t   string;
    u32_t   reserved;
 } mb_module_t;
 /* The memory map. Be careful that the offset 0 is base_addr_low, not size. */
 typedef struct
 {
    u32_t   size;                 // offset -4
    u64_t   base;                 // offset 0
    u64_t   length;
    u32_t   type;
 } mb_mmap_t;
 /* The drive structure */
 typedef struct
 {
    u32_t   size;
    u8_t    drive_number;
    u8_t    drive_mode;
    u8_t    drive_cylinders;
    u8_t    drive_heads;
    u8_t    drive_sectors;
    u16_t   drive_ports[1];
 } mb_drive_t;
 /* APM table structure */
 typedef struct
 {
    u16_t   version;
    u16_t   cseg;
    u32_t   offset;
    u16_t   cseg_16;
    u16_t   dseg;
    u16_t   flags;
    u16_t   cseg_len;
    u16_t   cseg_16_len;
    u16_t   dseg_len;
 } mb_apm_t;
 #ifdef __cplusplus
 }
 #endif
 #endif
@@ -0,0 +1,37 @@
 #ifndef PORTIO_H
 #define PORTIO_H
 #include "hos_types.h"
 #define outportb(port, val) \
    __asm__ __volatile__ ("outb %%al, %%dx" : : "a" (val), "d" (port));
 #define outportw(port, val) \
    __asm__ __volatile__ ("outw %%ax, %%dx" : : "a" (val), "d" (port));
 #define outportd(port, val) \
    __asm__ __volatile__ ("outl %%eax, %%dx" : : "a" (val), "d" (port));
 static inline u8_t inportb(u16_t port)
 {
    u8_t val;
    __asm__ __volatile__ ("inb %%dx, %%al" : "=a" (val) : "d" (port));
    return val;
 }
 static inline u16_t inportw(u16_t port)
 {
    u16_t val;
    __asm__ __volatile__ ("inw %%dx, %%al" : "=a" (val) : "d" (port));
    return val;
 }
 static inline u32_t inportd(u16_t port)
 {
    u32_t val;
    __asm__ __volatile__ ("inl %%dx, %%al" : "=a" (val) : "d" (port));
    return val;
 }
 #endif
@@ -0,0 +1,2 @@
 include $(HOS_TOPLEVEL)/subdir.mak
@@ -0,0 +1,110 @@
 #include "hos_types.h"
 #include "interrupts.h"
 #include "mm/mm.h"
 #include "lang/kio.h"
 #include "sys/pic.h"
 #include "sys/cpu.h"
 extern "C" {
 idtr_t idtr;
 void isr(u8_t int_num, int_stack_t * istack)
 {
    switch (int_num)
    {
    case 0x20:                  /* timer interrupt */
        (*(u16_t *)CONSOLE_MEMORY)++;
        pic_eoi();
        break;
    case 0x21:
        /* TODO: keyboard hook */
        pic_eoi();
        break;
    default:
        kputs("--------------------------------------------------------------------------------");
        kprintf("Unhandled Interrupt #%d\n", int_num);
        kprintf("    ds: 0x%08x     es: 0x%08x     fs: 0x%08x     gs: 0x%08x\n",
                istack->ds, istack->es, istack->fs, istack->gs);
        kprintf("   eax: 0x%08x    ebx: 0x%08x    ecx: 0x%08x    edx: 0x%08x\n",
                istack->eax, istack->ebx, istack->ecx, istack->edx);
        kprintf("   ebp: 0x%08x    esi: 0x%08x    edi: 0x%08x eflags: 0x%08x\n",
                istack->ebp, istack->esi, istack->edi, istack->eflags);
        kprintf("    cs: 0x%08x    eip: 0x%08x     ss: 0x%08x    esp: 0x%08x\n",
                istack->cs, istack->eip, istack->ss, istack->esp);
        kprintf("   cr0: 0x%08x    cr2: 0x%08x    cr3: 0x%08x\n",
                read_cr0(), read_cr2(), read_cr3());
        kprintf(" Error: 0x%08x (%d)\n", istack->error, istack->error);
        kputs("--------------------------------------------------------------------------------");
        kprintf("Halting!\n");
        for (;;)
            ;
        break;
    }
 }
 } /* extern "C" */
 void interrupts_bootstrap()
 {
    u32_t idt_phys = mm_page_alloc();
    u32_t idt_virt = mm_early_vpage_alloc();
    mm_map(idt_virt, idt_phys, 0, 1);
    u64_t * idt = (u64_t *) idt_virt;
    idt[0]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_0,  0);
    idt[1]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_1,  0);
    idt[2]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_2,  0);
    idt[3]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_3,  0);
    idt[4]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_4,  0);
    idt[5]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_5,  0);
    idt[6]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_6,  0);
    idt[7]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_7,  0);
    idt[8]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_8,  0);
    idt[9]  = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_9,  0);
    idt[10] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_10, 0);
    idt[11] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_11, 0);
    idt[12] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_12, 0);
    idt[13] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_13, 0);
    idt[14] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_14, 0);
    idt[15] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_15, 0);
    idt[16] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_16, 0);
    idt[17] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_17, 0);
    idt[18] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_18, 0);
    idt[19] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_19, 0);
    idt[20] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_20, 0);
    idt[21] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_21, 0);
    idt[22] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_22, 0);
    idt[23] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_23, 0);
    idt[24] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_24, 0);
    idt[25] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_25, 0);
    idt[26] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_26, 0);
    idt[27] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_27, 0);
    idt[28] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_28, 0);
    idt[29] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_29, 0);
    idt[30] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_30, 0);
    idt[31] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_31, 0);
    idt[32] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_32, 0);
    idt[33] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_33, 0);
    idt[34] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_34, 0);
    idt[35] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_35, 0);
    idt[36] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_36, 0);
    idt[37] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_37, 0);
    idt[38] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_38, 0);
    idt[39] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_39, 0);
    idt[40] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_40, 0);
    idt[41] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_41, 0);
    idt[42] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_42, 0);
    idt[43] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_43, 0);
    idt[44] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_44, 0);
    idt[45] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_45, 0);
    idt[46] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_46, 0);
    idt[47] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_47, 0);
    idt[48] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_48, 0);
    idt[49] = MAKE_IDT_DESCRIPTOR(KERNEL_CODE_SEGMENT, isr_49, 0);
    idtr.base = idt_phys;
    idtr.limit = 49 * sizeof(idt[0]) - 1;
    __asm__ __volatile__ ("lidt (idtr)" : : : "memory");
 }
@@ -0,0 +1,79 @@
 #ifndef INTERRUPTS_H
 #define INTERRUPTS_H
 #ifdef __cplusplus
 extern "C" {
 #endif
 void isr(u8_t int_num, int_stack_t * int_stack);
 extern void isr_0();
 extern void isr_1();
 extern void isr_2();
 extern void isr_3();
 extern void isr_4();
 extern void isr_5();
 extern void isr_6();
 extern void isr_7();
 extern void isr_8();
 extern void isr_9();
 extern void isr_10();
 extern void isr_11();
 extern void isr_12();
 extern void isr_13();
 extern void isr_14();
 extern void isr_15();
 extern void isr_16();
 extern void isr_17();
 extern void isr_18();
 extern void isr_19();
 extern void isr_20();
 extern void isr_21();
 extern void isr_22();
 extern void isr_23();
 extern void isr_24();
 extern void isr_25();
 extern void isr_26();
 extern void isr_27();
 extern void isr_28();
 extern void isr_29();
 extern void isr_30();
 extern void isr_31();
 extern void isr_32();
 extern void isr_33();
 extern void isr_34();
 extern void isr_35();
 extern void isr_36();
 extern void isr_37();
 extern void isr_38();
 extern void isr_39();
 extern void isr_40();
 extern void isr_41();
 extern void isr_42();
 extern void isr_43();
 extern void isr_44();
 extern void isr_45();
 extern void isr_46();
 extern void isr_47();
 extern void isr_48();
 extern void isr_49();
 #ifdef __cplusplus
 }
 #endif
 #define MAKE_IDT_DESCRIPTOR(selector, offset, dpl) \
    (u64_t) ( ( (((u64_t) offset) & 0xFFFF0000ull) << 32 )  /* offset 31:16 */ \
            | ( ( (u64_t) 0x1ull) << 47 )                   /* present */      \
            | ( (((u64_t) dpl) & 0x3) << 45 )               /* DPL */          \
            | ( ( (u64_t) 0xEull) << 40 )                   /* TODO: gate? */  \
            | ( (((u64_t) selector) & 0xFFFFull) << 16 )    /* selector */     \
            | ( (((u64_t) offset) & 0x0000FFFFull) ) )      /* offset 15:0 */
 void interrupts_bootstrap();
 #define interrupts_enable() __asm__ __volatile__ ("sti");
 #define interrupts_disable() __asm__ __volatile__ ("cli");
 #endif
@@ -0,0 +1,56 @@
 ; C ISR routine
 [extern isr]
 ; Macro for creating a single ISR label
 ; We need to push a junk value on the stack first
 ; if the interrupt number is not 8 or 10-14.
 ; This is to properly align the stack for both exceptions
 ; having and not having error codes.
 %macro isr_label 1
 [global isr_%1]
 isr_%1:
    %if ( (%1 != 8) && (%1 < 10 || %1 > 14) )
        push    eax                 ; junk value to take error code stack space
    %endif
    pusha                           ; eax, ecx, edx, ebx, esp, ebp, esi, edi
    mov     al, %1                  ; save interrupt number in al
    %if ($ - isr_common) < 127      ; do a short jump and save 3 bytes if we can
        jmp short isr_common
    %else
        jmp     isr_common
    %endif
 %endmacro
 ; The common ISR routine
 isr_common:
    push    ds
    push    es
    push    fs
    push    gs
    push    esp                     ; pointer to interrupt stack
    push    eax                     ; interrupt number
    call    isr
    pop     eax                     ; restore stack pointer (this is shorter
    pop     eax                     ; than "add esp, 8" and "lea esp, [esp+8]")
    pop     gs
    pop     fs
    pop     es
    pop     ds
    popa                            ; edi, esi, ebp, <null>, ebx, edx, ecx, eax
    lea     esp, [esp+4]            ; bypass error code
    iret
 ; Loop to create all of our ISR entry points
 %assign i 0
 %rep 50
    isr_label i
    %assign i i+1
 %endrep
@@ -0,0 +1,2 @@
 include $(HOS_TOPLEVEL)/subdir.mak
@@ -0,0 +1,317 @@
 #include "hos_types.h"
 #include "hos_defines.h"
 #include "kio.h"
 #include "string.h"
 #include "portio.h"
 #include <limits.h>
 #include <stdarg.h>                 /* va_*() */
 static void fmt_d2a(char * buf, int val);
 static void fmt_u2a(char * buf, unsigned int val);
 static void fmt_ll2a(char * buf, long long val);
 static void fmt_ull2a(char * buf, unsigned long long val);
 static void fmt_x2a(char * buf, unsigned int val);
 static void fmt_xl2a(char * buf, unsigned long long val);
 static void fmt_o2a(char * buf, unsigned int val);
 static int cursor_x, cursor_y;
 static void writeCursorPosition(int x, int y)
 {
    u16_t pos = 80 * y + x;
    outportb(0x3D4, 0x0E);
    outportb(0x3D5, pos >> 8);
    outportb(0x3D4, 0x0F);
    outportb(0x3D5, pos);
 }
 extern "C" {
 void kio_bootstrap()
 {
    cursor_x = 0;
    cursor_y = 9;
    writeCursorPosition(cursor_x, cursor_y);
 }
 void kprintf(const char * fmt, ...)
 {
    va_list args;
    va_start(args, fmt);
    kvprintf(fmt, args);
    va_end(args);
 }
 void kvprintf(const char * fmt, va_list args)
 {
    char tmpbuf[25];
    for ( ; *fmt; fmt++)
    {
        if (*fmt == '%')
        {
            fmt++;
            if (*fmt)
            {
                int width = 0;
                char pad_char = ' ';
                bool pad_right = false;
                if (*fmt == '0')
                {
                    pad_char = '0';
                    fmt++;
                }
                else if (*fmt == '-')
                {
                    pad_right = true;
                    fmt++;
                }
                for ( ; '0' <= *fmt && *fmt <= '9'; fmt++)
                {
                    if (width == 0)
                    {
                        width = *fmt - '0';
                    }
                    else
                    {
                        width *= 10;
                        width += *fmt - '0';
                    }
                }
                switch (*fmt)
                {
                    case 'c':
                        kputc(va_arg(args, int));
                        break;
                    case 'd':
                        fmt_d2a(tmpbuf, va_arg(args, int));
                        kputs_pad(tmpbuf, width, pad_char, pad_right);
                        break;
                    case 'l':
                        fmt_ll2a(tmpbuf, va_arg(args, long long));
                        kputs_pad(tmpbuf, width, pad_char, pad_right);
                        break;
                    case 'L':
                        fmt_ull2a(tmpbuf, va_arg(args, unsigned long long));
                        kputs_pad(tmpbuf, width, pad_char, pad_right);
                        break;
                    case 'o':
                        fmt_o2a(tmpbuf, va_arg(args, unsigned int));
                        kputs_pad(tmpbuf, width, pad_char, pad_right);
                        break;
                    case 's':
                        kputs_pad(va_arg(args, char *),
                                  width, pad_char, pad_right);
                        break;
                    case 'u':
                        fmt_u2a(tmpbuf, va_arg(args, unsigned int));
                        kputs_pad(tmpbuf, width, pad_char, pad_right);
                        break;
                    case 'x':
                        fmt_x2a(tmpbuf, va_arg(args, unsigned int));
                        kputs_pad(tmpbuf, width, pad_char, pad_right);
                        break;
                    case 'X':
                        fmt_xl2a(tmpbuf, va_arg(args, unsigned long long));
                        kputs_pad(tmpbuf, width, pad_char, pad_right);
                        break;
                    case '%':
                        kputc('%');
                        break;
                }
            }
        }
        else
        {
            kputc(*fmt);
        }
        if (!*fmt)
        {
            break;
        }
    }
 }
 void kputc(char c)
 {
    u16_t * console_memory = (u16_t *) CONSOLE_MEMORY;
    console_memory += 80 * cursor_y + cursor_x;
    switch (c)
    {
        case '\t':
            {
                int to_advance = 8 - (cursor_x & 0x3);
                while (to_advance--)
                {
                    *console_memory++ = 0x0720;
                }
            }
            break;
        case '\n':
            cursor_x = 0;
            cursor_y++;
            break;
        default:
            *console_memory = 0x0700 | (c & 0xFF);
            cursor_x++;
            break;
    }
    if (cursor_x >= 80)
    {
        cursor_x = 0;
        cursor_y++;
    }
    if (cursor_y >= 25)
    {
        memcpy((u8_t *) CONSOLE_MEMORY,
               (u8_t *) (CONSOLE_MEMORY + 80 * 2),
               2 * 80 * 24);
        memsetw((u16_t *) (CONSOLE_MEMORY + 2 * 80 * 24), 0x0720, 80);
        cursor_y = 24;
    }
    writeCursorPosition(cursor_x, cursor_y);
 }
 void kputs(const char * s)
 {
    while (*s)
    {
        kputc(*s);
        s++;
    }
 }
 void kputs_pad(const char * s, int width, char pad_char, bool pad_right)
 {
    int len = strlen(s);
    if (pad_right)
    {
        kputs(s);
    }
    int num_pad_chars = width - len;
    for (int i = 0; i < num_pad_chars; i++)
    {
        kputc(pad_char);
    }
    if (!pad_right)
    {
        kputs(s);
    }
 }
 } /* extern "C" */
 static void fmt_d2a(char * buf, int val)
 {
    if (val < 0)
    {
        *buf++ = '-';
        val = -val;
    }
    fmt_u2a(buf, (unsigned int) val);
 }
 static void fmt_u2a(char * buf, unsigned int val)
 {
    bool printing = false;
    for (unsigned int div = 1000000000; div >= 1; div /= 10)
    {
        unsigned int n = val / div;
        if (n || div == 1)
        {
            printing = true;
        }
        if (printing)
        {
            *buf++ = '0' + n;
        }
        val -= n * div;
    }
    *buf = '\0';
 }
 static void fmt_ll2a(char * buf, long long val)
 {
    if (val < 0)
    {
        *buf++ = '-';
        val = -val;
    }
    fmt_ull2a(buf, (unsigned long long) val);
 }
 static void fmt_ull2a(char * buf, unsigned long long val)
 {
    bool printing = false;
    for (unsigned long long div = 10000000000000000000ull; div >= 1; div /= 10)
    {
        unsigned long long n = val / div;
        if (n || div == 1)
        {
            printing = true;
        }
        if (printing)
        {
            *buf++ = '0' + n;
        }
        val -= n * div;
    }
    *buf = '\0';
 }
 static void fmt_x2a(char * buf, unsigned int val)
 {
    bool printing = false;
    for (int s = 28; s >= 0; s -= 4)
    {
        unsigned int n = (val >> s) & 0xF;
        if (n || s == 0)
        {
            printing = true;
        }
        if (printing)
        {
            *buf++ = "0123456789abcdef"[n];
        }
    }
    *buf = '\0';
 }
 static void fmt_xl2a(char * buf, unsigned long long val)
 {
    bool printing = false;
    for (int s = 60; s >= 0; s -= 4)
    {
        unsigned int n = (val >> s) & 0xF;
        if (n || s == 0)
        {
            printing = true;
        }
        if (printing)
        {
            *buf++ = "0123456789abcdef"[n];
        }
    }
    *buf = '\0';
 }
 static void fmt_o2a(char * buf, unsigned int val)
 {
    bool printing = false;
    for (int s = 30; s >= 0; s -= 3)
    {
        unsigned int n = (val >> s) & 0x7;
        if (n || s == 0)
        {
            printing = true;
        }
        if (printing)
        {
            *buf++ = "01234567"[n];
        }
    }
    *buf = '\0';
 }
@@ -0,0 +1,27 @@
 #ifndef KIO_H
 #define KIO_H
 #include <stdarg.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 void kio_bootstrap();
 void kprintf(const char * fmt, ...);
 void kvprintf(const char * fmt, va_list args);
 void kputc(char c);
 void kputs(const char * s);
 void kputs_pad(const char * s, int width, char pad_char, bool pad_right);
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 #endif
@@ -0,0 +1,73 @@
 #include "string.h"
 extern "C" {
 void strcpy(char * dst, const char * src)
 {
    while (*src)
    {
        *dst++ = *src++;
    }
    *dst = '\0';
 }
 u32_t strlen(const char * s)
 {
    u32_t len = 0;
    while (*s++)
    {
        len++;
    }
    return len;
 }
 void memcpy(u8_t * dst, u8_t * src, u32_t size)
 {
    for (u32_t n = 0; n < size; n++)
    {
        *dst++ = *src++;
    }
 }
 void memcpyw(u16_t * dst, u16_t * src, u32_t size)
 {
    for (u32_t n = 0; n < size; n++)
    {
        *dst++ = *src++;
    }
 }
 void memcpyd(u32_t * dst, u32_t * src, u32_t size)
 {
    for (u32_t n = 0; n < size; n++)
    {
        *dst++ = *src++;
    }
 }
 void memset(u8_t * dst, u8_t val, u32_t size)
 {
    for (u32_t n = 0; n < size; n++)
    {
        *dst++ = val;
    }
 }
 void memsetw(u16_t * dst, u16_t val, u32_t size)
 {
    for (u32_t n = 0; n < size; n++)
    {
        *dst++ = val;
    }
 }
 void memsetd(u32_t * dst, u32_t val, u32_t size)
 {
    for (u32_t n = 0; n < size; n++)
    {
        *dst++ = val;
    }
 }
 } /* extern "C" */
@@ -0,0 +1,27 @@
 #ifndef STRING_H
 #define STRING_H
 #include "hos_defines.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 void strcpy(char * dst, const char * src);
 u32_t strlen(const char * s);
 void memcpy(u8_t * dst, u8_t * src, u32_t size);
 void memcpyw(u16_t * dst, u16_t * src, u32_t size);
 void memcpyd(u32_t * dst, u32_t * src, u32_t size);
 void memset(u8_t * dst, u8_t val, u32_t size);
 void memsetw(u16_t * dst, u16_t val, u32_t size);
 void memsetd(u32_t * dst, u32_t val, u32_t size);
 #ifdef __cplusplus
 }
 #endif
 #endif
@@ -0,0 +1,34 @@
 OUTPUT_FORMAT(elf32-i386)
 ENTRY(start)
 virt = 0x00100000;
 phys = 0x00100000;
 SECTIONS
 {
    .text virt : AT(phys) {
        code = .; _code = .; __code = .;
        *(.multiboot_header*)
        *(.text*)
        *(.gnu.linkonce*)
        . = ALIGN(4096);
    }
    .rodata : {
        *(.rodata*)
        . = ALIGN(4096);
    }
    .other : {
        *(.eh_*)
        *(.rel*)
        . = ALIGN(4096);
    }
    .data : {
        data = .; _data = .; __data = .;
        *(.data*)
        . = ALIGN(4096);
    }
    .bss : {
        bss = .; _bss = .; __bss = .;
        *(.bss*)
        . = ALIGN(4096);
    }
    end = .; _end = .; __end = .;
 }
@@ -0,0 +1,2 @@
 include $(HOS_TOPLEVEL)/subdir.mak
@@ -0,0 +1,405 @@
 #include <stddef.h>
 #include "mm.h"
 #include "stack.h"
 #include "boot/k_early_panic.h"
 #include "lang/string.h"
 #include "lang/kio.h"
 #include "sys/cpu.h"
 #define MM_MAX_MMAP_ENTRIES 64
 /* mmap management */
 static mm_mem_range_t mm_mmap_entries[MM_MAX_MMAP_ENTRIES];
 static int mm_mmap_num_entries = 0;
 /* free/total page statistics */
 static int mm_num_free_pages = 0;
 static int mm_num_total_pages = 0;
 gdtr_t mm_gdtr;
 static u64_t * mm_gdt;              /* NOT mapped into virtual address space */
 static u32_t mm_heap_base;          /* virtual address of start of heap */
 static pagedirectory_t * early_page_directory_ptr;
 /* physical addresses of page allocation pages to map in before the heap */
 static u32_t page_alloc_page_numbers[1025]; /* supports 4GB physical memory */
 static int last_page_alloc_page = -1; /* index of last valid page alloc page */
 static int page_alloc_page_index = -1;
 static mm_page_alloc_page_t * page_alloc_pages;
 static int page_alloc_pages_index = -1;
 /**************************************************************************
 * Internal Functions                                                     *
 *************************************************************************/
 static void record_phys_page(u32_t base_address);
 /**************************************************************************
 * Compile-time tests                                                     *
 *************************************************************************/
 static void build_tests()
 {
    /* check that a mm_page_alloc_page_t fits exactly in a page */
    BUILD_BUG_ON(sizeof(mm_page_alloc_page_t) != PAGE_SIZE);
 }
 /**************************************************************************
 * This function is run in segmented memory before paging is in effect.   *
 * Record an mmap entry from the bootloader into our kernel space.        *
 *************************************************************************/
 void mm_record_mmap_entry(mb_mmap_t * mmap)
 {
    if (mm_mmap_num_entries < MM_MAX_MMAP_ENTRIES)
    {
        if (mmap->type == MB_MMAP_TYPE_RAM)
        {
            mm_mmap_entries[mm_mmap_num_entries].base   = mmap->base;
            mm_mmap_entries[mm_mmap_num_entries].length = mmap->length;
            mm_mmap_num_entries++;
        }
    }
    else
    {
        k_early_panic("Too many mmap_entries!");
    }
 }
 /**************************************************************************
 * This function is run in segmented memory before paging is in effect.   *
 * It is run after the bootloader information has been read, so we can    *
 * overwrite that memory now.                                             *
 *************************************************************************/
 void mm_bootstrap()
 {
    u32_t max_ram_address = KERNEL_PHYSICAL_ADDRESS + KERNEL_SIZE - 1;
    if (mm_mmap_num_entries < 1)
    {
        k_early_panic("No mmap entries read from bootloader!");
    }
    mm_heap_base = (u32_t) KERNEL_END;
    page_alloc_pages = (mm_page_alloc_page_t *) mm_heap_base;
    for (int mmap_idx = 0; mmap_idx < mm_mmap_num_entries; mmap_idx++)
    {
        u32_t base_address = mm_mmap_entries[mmap_idx].base;
        u32_t address_limit = base_address + mm_mmap_entries[mmap_idx].length;
        if (base_address & PAGE_LOW_MASK)
        {
            /* start of this mmap range is not page-aligned */
            base_address = (base_address & PAGE_HIGH_MASK) + PAGE_SIZE;
        }
        if (address_limit & PAGE_LOW_MASK)
        {
            /* end of this mmap range is not page-aligned */
            address_limit &= PAGE_HIGH_MASK;
        }
        /* record the highest RAM address found */
        if ((address_limit - 1) > max_ram_address)
        {
            max_ram_address = (address_limit - 1);
        }
        /*
         * loop through every page in the mmap range and add
         * pages into the free page linked list
         */
        for (; base_address < address_limit; base_address += PAGE_SIZE)
        {
            /* check to make sure the page doesn't overlap the kernel */
            if ( base_address + PAGE_SIZE <= KERNEL_PHYSICAL_ADDRESS
              || base_address >= KERNEL_PHYSICAL_ADDRESS + KERNEL_SIZE )
            {
                record_phys_page(base_address);
                mm_num_free_pages++;
            }
            mm_num_total_pages++;
        }
    }
    if (mm_num_free_pages < 10)
    {
        k_early_panic("Not enough free pages of RAM!");
    }
    /* ok, now mm_early_page_alloc() should be functional */
    /* move the heap back to after the page allocation pages */
    mm_heap_base = (u32_t) &page_alloc_pages[last_page_alloc_page + 1];
    /* ok, now mm_early_vpage_alloc() should be functional */
    /* allocate the page directory */
    u32_t page_directory_phys = mm_early_page_alloc();
    early_page_directory_ptr = (pagedirectory_t *)
        (page_directory_phys + KERNEL_OFFSET);
    /* Clear the page directory */
    for (unsigned int i = 0; i < NUM_PAGETABLE_ENTRIES; i++)
    {
        (*early_page_directory_ptr)[i] = 0;
    }
    /* ok, now mm_early_map() should be functional */
    /* map in the page directory itself so we can modify it once paging is on */
    (*early_page_directory_ptr)[PAGE_DIR_SELF_REF_INDEX] =
        (page_directory_phys) | (0x1 << 1) | (0x1);
    /* map in the physical page allocator pages */
    for (int i = 0; i <= last_page_alloc_page; i++)
    {
        mm_early_map((u32_t) &page_alloc_pages[i],
                page_alloc_page_numbers[i], 0, 1);
    }
    /* map the kernel's virtual address space into RAM */
    for (u32_t page_base = KERNEL_VIRTUAL_ADDRESS;
         page_base < KERNEL_VIRTUAL_ADDRESS + KERNEL_SIZE;
         page_base += PAGE_SIZE)
    {
        /* map page_base to page_base - KERNEL_OFFSET */
        mm_early_map(page_base, page_base - KERNEL_OFFSET, 0, 1);
    }
    /* map console memory */
    mm_early_map(CONSOLE_MEMORY, CONSOLE_MEMORY, 0, 1);
    /* set up the global descriptor table */
    u32_t gdt_base = mm_early_page_alloc();
    mm_gdt = (u64_t *) ((u32_t) gdt_base + (u32_t) KERNEL_OFFSET);
    mm_gdt[0] = 0x0ull;
    mm_gdt[1] = MAKE_DESCRIPTOR(0, 0xFFFFF, 1, 0, 1, 1);    /* kernel code */
    mm_gdt[2] = MAKE_DESCRIPTOR(0, 0xFFFFF, 1, 0, 1, 0);    /* kernel data */
    mm_gdtr.limit = 3 * sizeof(mm_gdt[0]) - 1;
    mm_gdtr.base = gdt_base;
    __asm__ __volatile__ (
            "lgdt (mm_gdtr);\n"
            "jmp $0x08, $42f;\n"
            "42:\n"
            "mov $0x10, %%cx\n"
            "mov %%cx, %%ss\n"
            "mov %%cx, %%ds\n"
            "mov %%cx, %%es\n"
            "mov %%cx, %%fs\n"
            "mov %%cx, %%gs\n"
            : /* no outputs */
            : /* no inputs */
            : "ecx");
    /* set the page directory base register */
    write_cr3(page_directory_phys);
    /* set up permanent stack before enabling paging */
    stack_bootstrap();
    /* turn on paging */
    write_cr0(read_cr0() | (1 << 31));
 }
 /**************************************************************************
 * This function is run in segmented memory before paging is in effect.   *
 * Record a physical page in the page allocation pages.                   *
 *************************************************************************/
 static void record_phys_page(u32_t base_address)
 {
    if (page_alloc_page_index < 0)
    {
        /* allocate a new page alloc page */
        last_page_alloc_page++;
        page_alloc_pages_index++;
        page_alloc_page_numbers[last_page_alloc_page] = base_address;
        page_alloc_page_index = 0;
    }
    else
    {
        mm_page_alloc_page_t * current_page_alloc_page =
            (mm_page_alloc_page_t *)
            (page_alloc_page_numbers[page_alloc_pages_index] + KERNEL_OFFSET);
        page_alloc_page_index++;
        (*current_page_alloc_page)[page_alloc_page_index] = base_address;
        if (page_alloc_page_index == NUM_PAGETABLE_ENTRIES - 1)
        {
            page_alloc_page_index = -1;
        }
    }
 }
 /**************************************************************************
 * Map virtual_address to physical_address.                               *
 * Both addresses should be page-aligned.                                 *
 * This 'early' version can be used during segmented bootstrapping        *
 *************************************************************************/
 int mm_early_map(u32_t virtual_address, u32_t physical_address,
                 u32_t user_mode, u32_t writable)
 {
    u32_t directory_index = (virtual_address >> 22) & 0x3FF;
    u32_t table_index = (virtual_address >> 12) & 0x3FF;
    if ((*early_page_directory_ptr)[directory_index] == 0)
    {
        /* allocate a new page table */
        u32_t page_table_phys = mm_early_page_alloc();
        if (page_table_phys == 0)
        {
            return 0;
        }
        pagedirectory_entry_t * page_table_virt = (pagedirectory_entry_t *)
            (page_table_phys + KERNEL_OFFSET);
        for (unsigned int i = 0; i < NUM_PAGETABLE_ENTRIES; i++)
        {
            page_table_virt[i] = 0;
        }
        (*early_page_directory_ptr)[directory_index] = page_table_phys
                                  | (0x1 << 2)  /* PTs can be user mode */
                                  | (0x1 << 1)  /* writable */
                                  | (0x1);      /* present */
    }
    u32_t page_table_phys =
        (*early_page_directory_ptr)[directory_index] & PAGE_HIGH_MASK;
    pagedirectory_entry_t * page_table =
        (pagedirectory_entry_t *) (page_table_phys + KERNEL_OFFSET);
    page_table[table_index] = (physical_address & PAGE_HIGH_MASK)
                            | ((user_mode & 0x1) << 2)
                            | ((writable & 0x1) << 1)
                            | 0x1;      /* present */
    return 1;
 }
 /**************************************************************************
 * Map virtual_address to physical_address.                               *
 * Both addresses should be page-aligned.                                 *
 *************************************************************************/
 int mm_map(u32_t virtual_address, u32_t physical_address,
           u32_t user_mode, u32_t writable)
 {
    u32_t directory_index = (virtual_address >> 22) & 0x3FF;
    u32_t table_index = (virtual_address >> 12) & 0x3FF;
    pagedirectory_entry_t * page_dir_entry = (pagedirectory_entry_t *)
        (PAGE_DIR_SELF_REF2 | (directory_index << 2));
    if (*page_dir_entry == 0)
    {
        /* allocate a new page table */
        u32_t page_table_phys = mm_page_alloc();
        if (page_table_phys == 0)
        {
            return 0;
        }
        *page_dir_entry = page_table_phys
                        | (0x1 << 2)    /* PTs can be user mode */
                        | (0x1 << 1)    /* writable */
                        | (0x1);        /* present */
        pagedirectory_entry_t * page_table = (pagedirectory_entry_t *)
            (PAGE_DIR_SELF_REF | (directory_index << 12));
        for (unsigned int i = 0; i < NUM_PAGETABLE_ENTRIES; i++)
        {
            page_table[i] = 0;
        }
    }
    pagedirectory_entry_t * page_table_entry = (pagedirectory_entry_t *)
        (PAGE_DIR_SELF_REF | (directory_index << 12) | (table_index << 2));
    *page_table_entry = (physical_address & PAGE_HIGH_MASK)
                      | ((user_mode & 0x1) << 2)
                      | ((writable & 0x1) << 1)
                      | 0x1;      /* present */
    return 1;
 }
 /**************************************************************************
 * Returns the physical base address of a page in RAM                     *
 * or 0 if no pages were available                                        *
 * This 'early' version can be used during segmented bootstrapping        *
 *************************************************************************/
 u32_t mm_early_page_alloc()
 {
    u32_t page_address = 0;
    if (page_alloc_pages_index >= 0)
    {
        if (page_alloc_page_index >= 0)
        {
            mm_page_alloc_page_t * current_pap = (mm_page_alloc_page_t *)
                (page_alloc_page_numbers[page_alloc_pages_index]
                    + KERNEL_OFFSET);
            page_address = (*current_pap)[page_alloc_page_index];
            page_alloc_page_index--;
        }
        else
        {
            /* return the page allocation page itself */
            page_address = page_alloc_page_numbers[page_alloc_pages_index];
            page_alloc_pages_index--;
            page_alloc_page_index = NUM_PAGETABLE_ENTRIES - 1;
        }
        mm_num_free_pages--;
    }
    return page_address;
 }
 /**************************************************************************
 * Returns the physical base address of a page in RAM                     *
 * or 0 if no pages were available                                        *
 *************************************************************************/
 u32_t mm_page_alloc()
 {
    u32_t page_address = 0;
    if (page_alloc_pages_index >= 0)
    {
        if (page_alloc_page_index >= 0)
        {
            page_address =
                page_alloc_pages[page_alloc_pages_index][page_alloc_page_index];
            page_alloc_page_index--;
        }
        else
        {
            /* return the page allocation page itself */
            page_address = page_alloc_page_numbers[page_alloc_pages_index];
            page_alloc_pages_index--;
            page_alloc_page_index = NUM_PAGETABLE_ENTRIES - 1;
        }
        mm_num_free_pages--;
    }
    return page_address;
 }
 /**************************************************************************
 * This function allocates a virtual page. It should only be called       *
 * during the bootstrap process, before the kernel begins its normal      *
 * operation. It adjusts the heap pointer to push it back beyond any      *
 * bootstrap pages allocated.                                             *
 *************************************************************************/
 u32_t mm_early_vpage_alloc()
 {
    u32_t vaddress = mm_heap_base;
    mm_heap_base += PAGE_SIZE;
    return vaddress;
 }
 void mm_print_memory_map()
 {
    kprintf("Bootloader provided memory map:\n");
    kprintf("  Base Address       Length\n");
    for (int i = 0; i < mm_mmap_num_entries; i++)
    {
        kprintf("  0x%016X 0x%016X (%l bytes / %l KB / %l MB)\n",
                mm_mmap_entries[i].base,
                mm_mmap_entries[i].length,
                mm_mmap_entries[i].length,
                mm_mmap_entries[i].length >> 10,
                mm_mmap_entries[i].length >> 20);
    }
    kprintf("Used pages: %d\n", mm_num_total_pages - mm_num_free_pages);
    kprintf("Free pages: %d\n", mm_num_free_pages);
 }
@@ -0,0 +1,65 @@
 #ifndef MM_H
 #define MM_H MM_H
 #include "hos_types.h"
 #include "hos_defines.h"
 #include "multiboot.h"
 #define KERNEL_CODE_SEGMENT 0x08
 #define KERNEL_DATA_SEGMENT 0x10
 typedef u32_t pagedirectory_entry_t;
 #define NUM_PAGETABLE_ENTRIES   (PAGE_SIZE / sizeof(pagedirectory_entry_t))
 #define PAGE_DIR_SELF_REF   (0x20000000u - (PAGE_SIZE * NUM_PAGETABLE_ENTRIES))
 #define PAGE_DIR_SELF_REF_INDEX ((PAGE_DIR_SELF_REF >> 22) & 0x3FF)
 #define PAGE_DIR_SELF_REF2  (PAGE_DIR_SELF_REF | (PAGE_DIR_SELF_REF_INDEX << 12))
 typedef pagedirectory_entry_t pagedirectory_t[NUM_PAGETABLE_ENTRIES];
 typedef struct
 {
    u64_t   base;
    u64_t   length;
 } mm_mem_range_t;
 typedef u32_t mm_page_alloc_page_t[NUM_PAGETABLE_ENTRIES];
 /* http://courses.ece.illinois.edu/ece391/references/descriptors.pdf */
 /* granularity: 0: limit in bytes; 1: limit in pages */
 /* dpl: 0: system mode; 3: user mode */
 /* normal: 0: TSS/LDT/call gate; 1: code/data segment */
 /* code_seg: 0: data segment; 1: code segment */
 #define MAKE_DESCRIPTOR(base, limit, granularity, dpl, normal, code_seg)       \
        (u64_t) ( ( (((u64_t) base) & 0xFF000000ull) << 32 ) /* base 31:24 */  \
                | ( (((u64_t) granularity) & 0x1ull) << 55 ) /* granularity */ \
                | ( ( (u64_t) 0x1ull) << 54 )                /* 32-bit */      \
                | ( (((u64_t) limit) & 0xF0000ull) << 32 )   /* limit 19:16 */ \
                | ( ( (u64_t) 0x1ull) << 47 )                /* present */     \
                | ( (((u64_t) dpl) & 0x3ull) << 45 )         /* dpl */         \
                | ( (((u64_t) normal) & 0x1ull) << 44 )      /* normal */      \
                | ( (((u64_t) code_seg) & 0x1ull) << 43 )    /* code seg */    \
                | ( ( (u64_t) 0x2ull) << 40 )                /* ? */           \
                | ( (((u64_t) base) & 0x00FFFFFFull) << 16)  /* base 23:00 */  \
                | ( (((u64_t) limit) & 0x0000FFFFull) ) )    /* limit 15:00 */
 typedef u64_t descriptor_t;
 void mm_record_mmap_entry(mb_mmap_t * mmap);
 void mm_bootstrap();
 int mm_early_map(u32_t virtual_address, u32_t physical_address,
                 u32_t user_mode, u32_t writable);
 int mm_map(u32_t virtual_address, u32_t physical_address,
           u32_t user_mode, u32_t writable);
 u32_t mm_early_page_alloc();
 u32_t mm_page_alloc();
 u32_t mm_early_vpage_alloc();
 void mm_print_memory_map();
 #endif
@@ -0,0 +1,19 @@
 #include "stack.h"
 #include "mm.h"
 #include "hos_defines.h"
 void stack_bootstrap()
 {
    /*
     * running from our temporary stack while segmentation is enabled,
     * set up the "permanent" stack for use while paging
     */
    u32_t stack_page_virt = KERNEL_STACK_TOP - PAGE_SIZE;
    for (int i = 0; i < STACK_INITIAL_SIZE; i++)
    {
        u32_t stack_page_phys = mm_early_page_alloc();
        mm_early_map(stack_page_virt, stack_page_phys, 0, 1);
        stack_page_virt -= PAGE_SIZE;
    }
 }
@@ -0,0 +1,13 @@
 #ifndef STACK_H
 #define STACK_H
 #include "mm/mm.h"
 #define KERNEL_STACK_TOP    PAGE_DIR_SELF_REF
 #define STACK_INITIAL_SIZE 2        /* number of initial stack pages */
 void stack_bootstrap();
 #endif
@@ -0,0 +1,54 @@
 ASMOBJS         := $(patsubst %.asm,%.o,$(wildcard *.asm))
 COBJS           := $(patsubst %.c,%.o,$(wildcard *.c))
 CXXOBJS         := $(patsubst %.cc,%.o,$(wildcard *.cc))
 CDEPS           := $(COBJS:.o=.dep)
 CXXDEPS         := $(CXXOBJS:.o=.dep)
 DEPS			:= $(CDEPS) $(CXXDEPS)
 OUTPUT_FILE     := $(SUBDIR)_all.o
 ifdef SUBDIRS
 SUBDIRS_clean   := $(SUBDIRS:%=%.clean)
 endif
 all: $(OUTPUT_FILE)
 $(OUTPUT_FILE): $(ASMOBJS) $(COBJS) $(CXXOBJS) $(SUBDIRS)
 	$(LD) -r -o $@ $(ASMOBJS) $(COBJS) $(CXXOBJS) $(foreach subdir,$(SUBDIRS),$(subdir)/$(subdir)_all.o)
 %.o: %.asm
 	$(NASM) -f elf -o $@ -l $<.lst $<
 %.o: %.c
 	$(CC) -c -o $@ $(CPPFLAGS) $(CFLAGS) $<
 %.o: %.cc
 	$(CXX) -c -o $@ $(CPPFLAGS) $(CXXFLAGS) $<
 ifdef SUBDIRS
 .PHONY: $(SUBDIRS)
 $(SUBDIRS):
 	$(MAKE) -C $@ SUBDIR=$@
 endif
 # Make dependency files
 %.dep: %.c
 	@set -e; rm -f $@; \
 	  $(CC) -MM $(CPPFLAGS) $< | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@
 %.dep: %.cc
 	@set -e; rm -f $@; \
 	  $(CXX) -MM $(CPPFLAGS) $< | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@
 clean: $(SUBDIRS_clean)
 	-rm -f *.o *.dep *.lst *~
 ifdef SUBDIRS
 %.clean:
 	$(MAKE) -C $* clean clean=1
 endif
 # Include dependency files
 ifndef clean
 -include $(DEPS)
 endif
@@ -0,0 +1,2 @@
 include $(HOS_TOPLEVEL)/subdir.mak
@@ -0,0 +1,40 @@
 #ifndef CPU_H
 #define CPU_H
 #include "hos_types.h"
 static u32_t read_cr0() __attribute__ ((unused));
 static u32_t read_cr0()
 {
    u32_t val;
    __asm__ __volatile__ ("movl %%cr0, %0" : "=r" (val));
    return val;
 }
 static u32_t read_cr2() __attribute__ ((unused));
 static u32_t read_cr2()
 {
    u32_t val;
    __asm__ __volatile__ ("movl %%cr2, %0" : "=r" (val));
    return val;
 }
 static u32_t read_cr3() __attribute__ ((unused));
 static u32_t read_cr3()
 {
    u32_t val;
    __asm__ __volatile__ ("movl %%cr3, %0" : "=r" (val));
    return val;
 }
 #define write_cr0(val) \
    __asm__ __volatile__ ("movl %0, %%cr0" : : "r" (val));
 #define write_cr3(val) \
    __asm__ __volatile__ ("movl %0, %%cr3" : : "r" (val));
 #define write_esp(val) \
    __asm__ __volatile__ ("movl %0, %%esp" : : "r" (val));
 #endif
@@ -0,0 +1,29 @@
 #include "pic.h"
 #include "portio.h"
 /*
 * Re-maps the Programmable Interrupr Controllers
 * so IRQ0->pic1 base address, IRG8->pic2 base address
 */
 void pic_remap(u8_t base1, u8_t base2)
 {
    u8_t    a1, a2;
    a1 = inportb(PIC1_DATA);        /* 0x21 */
    a2 = inportb(PIC2_DATA);        /* 0xA1 */
    outportb(PIC1_COMMAND, ICW1_INIT+ICW1_ICW4); /* 0x20, 0x10+0x01 00010001b */
    outportb(PIC2_COMMAND, ICW1_INIT+ICW1_ICW4); /* 0xA0, 0x10+0x01 00010001b */
    outportb(PIC1_DATA, base1);     /* 0x21, pic1 */
    outportb(PIC2_DATA, base2);     /* 0xA1, pic2 */
    outportb(PIC1_DATA, 4);         /* 0x21, 0x04 00000100b */
    outportb(PIC2_DATA, 2);         /* 0xA1, 0x02 00000010b */
    outportb(PIC1_DATA, ICW4_8086); /* 0x21, 0x01 00000001b */
    outportb(PIC2_DATA, ICW4_8086); /* 0xA1, 0x01 00000001b */
    outportb(PIC1_DATA, a1);        /* 0x21 */
    outportb(PIC2_DATA, a2);        /* 0xA1 */
 }
@@ -0,0 +1,46 @@
 #ifndef PIC_H
 #define PIC_H
 #include "hos_types.h"
 #include "portio.h"
 #define PIC1            0x20
 #define PIC2            0xA0
 #define PIC1_COMMAND    PIC1
 #define PIC1_DATA       (PIC1+1)
 #define PIC2_COMMAND    PIC2
 #define PIC2_DATA       (PIC2+1)
 #define PIC_EOI         0x20
 #define ICW1_ICW4       0x01            /* ICW4 (not) needed */
 #define ICW1_SINGLE     0x02            /* Single (cascade) mode */
 #define ICW1_INTERVAL4  0x04            /* Call address interval 4 (8) */
 #define ICW1_LEVEL      0x08            /* Level triggered (edge) mode */
 #define ICW1_INIT       0x10            /* Initialization - required! */
 #define ICW4_8086       0x01            /* 8086/88 (MCS-80/85) mode */
 #define ICW4_AUTO       0x02            /* Auto (normal) EOI */
 #define ICW4_BUF_SLAVE  0x08            /* Buffered mode/slave */
 #define ICW4_BUF_MASTER 0x0C            /* Buffered mode/master */
 #define ICW4_SFNM       0x10            /* Special fully nested (not) */
 void pic_remap(u8_t base1, u8_t base2);
 /* Masks interrupts on first Programmable Interrupt Controller */
 #define pic_mask1(mask) outportb(PIC1_DATA, mask) /* 0x21, maskfield *OCW1* */
 /* Masks interrupts on second Programmable Interrupt Controller */
 #define pic_mask2(mask) outportb(PIC2_DATA, mask) /* 0xA1, maskfield *OCW1* */
 /* Signals an End Of Interrupt signal to the first PIC */
 #define pic_eoi() outportb(0x20, 0x20)
 /* Signals an End Of Interrupt signal to both the second and first PIC unit */
 static inline void pic_eoi2()
 {
        outportb(0xA0, 0x20);
        outportb(0x20, 0x20);
 }
 #endif
@@ -0,0 +1,12 @@
 #include "timer.h"
 #include "portio.h"
 void timer_init(u32_t freq)
 {
    /* how many ticks the PIT must wait before issuing an interrupt */
    u32_t wait = 1193180 / freq;
    outportb(0x43, 0x34);
    outportb(0x40, wait);       /* LSB */
    outportb(0x40, wait >> 8);  /* MSB */
 }
@@ -0,0 +1,9 @@
 #ifndef TIMER_H
 #define TIMER_H
 #include "hos_types.h"
 void timer_init(u32_t freq);
 #endif
@@ -1,254 +0,0 @@
 //Keyboard.c
 // Created: 04/17/03 Josh Holtrop
 // Modified: 10/30/03
 //for HOS
 #define KBD_BUFFER_LENGTH 64
 byte kbdFlags = 0;		//holds current keyboard flags - caps/num/scroll/shift/ctrl/alt
 byte kbdAscii = 0;		//holds ASCII value of a key pressed
 byte kbdScan = 0;		//holds the keyboard scan code of a key pressed
 dword kbdBuffer[KBD_BUFFER_LENGTH];	//a buffer for all keypresses
 int kbdBufferStart = 0;			//position of next key in buffer
 int kbdBufferLen = 0;			//number of keys left in the buffer
 byte kbdExt = 0;			//# of extended key codes left to input
 byte kbdExt2 = 0;                       //# of 2nd-set-extended key codes left to input
 byte ackReason = 0;		//used to record the reason why we would get an acknowledge byte (0xFA)
 //these arrays convert a keyboard scan code to an ASCII character value
                                   //nul esc            bksp tab              lctl            lsft            rsft lalt caps F1  F2  F3  F4  F5  F6  F7  F8  F9  F10 numScrlNumPad-------                                  unknown---- F11 F12 unknown....
 const byte SCAN2ASCII[128]      = "\000\0331234567890-=\010\011qwertyuiop[]\n\001asdfghjkl;'`\001\\zxcvbnm,./\001*\001 \001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001-\001\001\001+\001\001\001\001\001\002\002\002\001\001\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002";
 const byte SCAN2ASCIISHIFT[128] = "\000\033!@#$%^&*()_+\010\011QWERTYUIOP{}\n\001ASDFGHJKL:\"~\001|ZXCVBNM<>?\001*\001 \001\001\001\001\001\001\001\001\001\001\001\001\001789-456+1230.\002\002\002\001\001\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002";
 //====FUNCTIONS:
 // The Keyboard Interrupt Service Routine
 void isr_keyboard()
 {
 	kbdScan = inportb(0x60);
 	//printf("\nKEYBOARD INTERRUPT: 0x%x", kbdScan);
 	byte inState = inportb(0x61);
 	outportb(0x61, inState|0x80);
 	outportb(0x61, inState);
 	//printf("IRQ 1: %x\n", kbdScan);
 	if (kbdScan == 0xFA)	//250					//ACKnowledge
 	{
 		//printf("KBD_ACK 0x%x!\n", ackReason);
 		if (ackReason == 0xED)					//reset LEDs
 		{
 			outportb(0x60, (kbdFlags & 0x07));
 		}
 		ackReason = 0;
 	}
 	if (kbdScan == 224)						//extended key
 	{
 		kbdExt = 1;
 		eoi();
 		return;
 	}
 	if (kbdScan == 225)						//2nd-set-extended key
 	{
 		kbdExt2 = 2;
 		eoi();
 		return;
 	}
 //====handle control keys::
 	kbdAscii = 2;
 	switch (kbdScan)						//control keys
 	{
 		case KBD_SCAN_LSHIFT:
 			kbdFlags |= KBD_SHIFT;
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_RSHIFT:
 			kbdFlags |= KBD_SHIFT;
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_LCTRL:
 			kbdFlags |= KBD_CTRL;
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_LALT:
 			kbdFlags |= KBD_ALT;			
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_LSHIFT + KBD_SCAN_RELEASED:
 			kbdFlags &= (KBD_SHIFT ^ 0xFF);
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_RSHIFT + KBD_SCAN_RELEASED:
 			kbdFlags &= (KBD_SHIFT ^ 0xFF);
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_LCTRL + KBD_SCAN_RELEASED:
 			kbdFlags &= (KBD_CTRL ^ 0xFF);
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_LALT + KBD_SCAN_RELEASED:
 			kbdFlags &= (KBD_ALT ^ 0xFF);
 			kbdAscii = 1;
 			break;
 		case KBD_SCAN_CAPS+KBD_SCAN_RELEASED:
 			kbdFlags ^= KBD_CAPS;
 			kbdAscii = 1;
 			kbd_resetLEDs();				//update LEDs
 			break;
 		case KBD_SCAN_SCROLL+KBD_SCAN_RELEASED:
 			kbdFlags ^= KBD_SCROLL;
 			kbdAscii = 1;
 			kbd_resetLEDs();				//update LEDs
 			break;
 		case KBD_SCAN_NUM+KBD_SCAN_RELEASED:
 			kbdFlags ^= KBD_NUM;
 			kbdAscii = 1;
 			kbd_resetLEDs();				//update LEDs
 			break;
 	}
 	if (kbdAscii == 1)
 	{
 		if (kbdExt > 0)
 			kbdExt--;
 		eoi();
 		return;
 	}
 //====determine ASCII value of key::
 	if (kbdExt > 0)						//extended key, kbdScan holds extended key
 	{
 		kbdExt--;
 		kbdAscii = 1;
 		switch (kbdScan)
 		{
 			case KBD_SCANE_ENTER:
 				kbdAscii = '\n';	break;
 			case 53:				// '/' character (divide on numpad)
 				kbdAscii = '/';		break;
 		}
 	}
 	else if (kbdExt2 > 0)					//extended key 2
 	{
 		kbdExt2--;
 //		if (kbdScan == 69)				// (pause|break)
 //			kbdAscii = 2;				//flag ascii value of 1 means control character (pausebreak)
 //		else
 			kbdAscii = 2;				//flag ascii value of 2 means ignore key (or unknown value)
 	}
 	else							//not an extended key
 	{
 			// if letter key
 		if (((kbdScan >= 16) && (kbdScan <= 25)) || ((kbdScan >= 30) && (kbdScan <= 38)) || ((kbdScan >= 44) && (kbdScan <= 50)))
 		{
 			// if caps and shift are different (either one pressed, not both)
 			if (((kbdFlags & KBD_SHIFT) != 0) & ((kbdFlags & KBD_CAPS) != 0))
 				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
 			else if (((kbdFlags & KBD_SHIFT) == 0) & ((kbdFlags & KBD_CAPS) == 0))
 				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
 			else
 				kbdAscii = SCAN2ASCIISHIFT[kbdScan & 0x7F];
 		}
 			// if numpad key
 		else if ((kbdScan >= 71) && (kbdScan <= 83))
 		{
 			// if numlock on
 			if (kbdFlags & KBD_NUM)
 				kbdAscii = SCAN2ASCIISHIFT[kbdScan & 0x7F];
 			else
 				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
 		}
 			// other key
 		else
 		{
 			if ((kbdFlags & KBD_SHIFT) != 0)
 				kbdAscii = SCAN2ASCIISHIFT[kbdScan & 0x7F];
 			else
 				kbdAscii = SCAN2ASCII[kbdScan & 0x7F];
 		}
 	}
 //====do something with key::
 //	printf("kbdScan == %d\nkbdAscii == %d\nkbdFlags == %d\n", kbdScan, kbdAscii, kbdFlags);
 	if ((kbdScan == 83) && (kbdFlags & KBD_CTRL) && (kbdFlags & KBD_ALT))
 	{
 		printf("Initiating reboot.");
 		restart();
 	}
 	if (kbdAscii == 2)							//unknown key / ignore key
 	{
 		eoi();
 		return;
 	}
 	if (kbdScan < KBD_SCAN_RELEASED)					//a key was pressed, save it
 	{
 		if (kbdBufferLen >= KBD_BUFFER_LENGTH)				//no key slots available
 		{
 			eoi();
 			return;
 		}
 		else
 		{
 			kbdBuffer[(kbdBufferStart+kbdBufferLen++)%KBD_BUFFER_LENGTH] = (dword) ((kbdFlags << 16) | (kbdScan << 8) | kbdAscii);
 //			printf("S:%d\tL:%d\tR:%x\n", kbdBufferStart, kbdBufferLen, kbdBuffer[kbdBufferStart]);
 		}
 	}
 	eoi();
 }
 //Switches the case of an ASCII character
 /*inline byte (byte asciiCode)
 {
 	if ((asciiCode >= 'A') & (asciiCode <= 'Z'))
 		return (asciiCode + ('a' - 'A'));
 	if ((asciiCode >= 'a') & (asciiCode <= 'z'))
 		return (asciiCode - ('a' - 'A'));
 	return asciiCode;
 }*/
 //Gets a key from the buffer, returns 0 if no keys available, returns immediately
 dword kbdGetKey()
 {
 	if (kbdBufferLen == 0)					//buffer empty
 		return 0;
 	dword retVal = kbdBuffer[kbdBufferStart];
 	kbdBufferStart++;
 	kbdBufferLen--;
 	if (kbdBufferStart >= KBD_BUFFER_LENGTH)
 		kbdBufferStart = 0;
 	return retVal;
 }
 //Gets a key from the buffer, if no keys available, waits for one to be entered
 dword kbdWaitKey()
 {
 	for (;;)
 	{
 		if (kbdBufferLen != 0)					//buffer empty
 			break;
 	}		
 	dword retVal = kbdBuffer[kbdBufferStart];
 	kbdBufferStart++;
 	kbdBufferLen--;
 	if (kbdBufferStart >= KBD_BUFFER_LENGTH)
 		kbdBufferStart = 0;
 	return retVal;
 }
 //Resets the keyboard LEDs to reflect the current state of the num lock, caps lock, and scroll lock bits
 inline void kbd_resetLEDs()
 {
 	outportb(0x60, 0xED);
 	//outportb(0x60, (kbdFlags & 0x07));
 	ackReason = 0xED;
 }
@@ -1,47 +0,0 @@
 //Keyboard.h
 // Created: 04/17/03 Josh Holtrop
 // Modified: 05/07/03
 //for HOS
 #define KBD_SCROLL 0x01
 #define KBD_NUM 0x02
 #define KBD_CAPS 0x04
 #define KBD_SHIFT 0x10
 #define KBD_CTRL 0x20
 #define KBD_ALT 0x40
 #define KBD_SCAN_RELEASED 128
 #define KBD_SCAN_LCTRL 29
 #define KBD_SCAN_LSHIFT 42
 #define KBD_SCAN_RSHIFT 54
 #define KBD_SCAN_LALT 56
 #define KBD_SCAN_SCROLL 70
 #define KBD_SCAN_CAPS 58
 #define KBD_SCAN_NUM 69
 #define KBD_SCANE_PRINTSCREEN 55
 #define KBD_SCANE_INS 82
 #define KBD_SCANE_HOME 71
 #define KBD_SCANE_PGUP 73
 #define KBD_SCANE_DEL 83
 #define KBD_SCANE_END 79
 #define KBD_SCANE_PGDN 81
 #define KBD_SCANE_ENTER 28
 #define KBD_SCANE_NULL 42
 //====PROTOTYPES:
 void isr_keyboard();
 inline void kbd_resetLEDs();
 inline byte kbd_ascii(dword keycode);
 inline byte kbd_scancode(dword keycode);
 inline byte kbd_flags(dword keycode);
 inline byte switchCase(byte asciiCode);
 dword kbdGetKey();
 dword kbdWaitKey();
@@ -1,133 +0,0 @@
 //kio.c
 // Author: Josh Holtrop
 // Created: 12/25/03
 // Modified: 12/25/03
 // This is the main output routine, it uses a format string and a variable
 //  number of arguments to print formatted text
 void	printf(char *fmt, ...)
 {
 	dword *params = ((dword *)(&fmt)) + 1;		//points to the first paramater
 	int i;
 	int special = 0;
 	for (i = 0; ; i++)
 	{
 		if (special)
 		{
 			special = 0;
 			switch (fmt[i])
 			{
 			case 0:
 				return;
 			case '%':
 				putc('%');
 				break;
 			case 's': case 'S':
 				puts((char *)*params);
 				params++;
 				break;
 			case 'c': case 'C':
 				putc(*params);
 				params++;
 				break;
 			case 'd': case 'D':
 				putDec(*params);
 				params++;
 				break;
 			case 'u': case 'U':
 				putDecu(*params);
 				params++;
 				break;
 			case 'x': case 'X':
 				putHex(*params);
 				params++;
 				break;
 			}
 		}
 		else
 		{
 			switch (fmt[i])
 			{
 			case '%':
 				special = 1;
 				break;
 			case 0:
 				return;
 			default:
 				putc(fmt[i]);
 			}
 		}
 	}
 }
 // This function draws a single character
 void	putc(dword chr)
 {
 	char charac = (char)chr;
 	word *vidmem = (word *)0xC00B8000;
 	if (charac == '\n')
 	{
 		if (cursorPosition % 80)
 			cursorPosition = cursorPosition + 80 - (cursorPosition % 80);
 		else
 			cursorPosition += 80;
 	}
 	else if (charac == '\t')
 	{
 		if (cursorPosition % 8)
 			cursorPosition = cursorPosition + 8 - (cursorPosition % 8);
 		else
 			cursorPosition += 8;
 	}
 	else
 	{
 		if (videoMode)
 		{
 			console_memory[cursorPosition] = charac | 0x0700;
 			video_drawConsoleChar(cursorPosition);
 		}
 		else
 		{
 			console_memory[cursorPosition] = charac | 0x0700;
 			vidmem[cursorPosition] = charac | 0x0700;
 		}
 		cursorPosition++;
 	}
 	if (cursorPosition >= 2000)
 	{
 		console_scroll();
 		cursorPosition = 2000-80;
 		if (videoMode)
 			video_drawConsole();
 	}
 	if (!videoMode)
 		writeCursorPosition(cursorPosition);
 }
 // This function displays a number in hexadecimal
 int putHex(dword number)
 {
 	int hitNum = 0;
 	int i;
 	for (i = 7; i >= 0; i--)
 	{
 		dword val = (number >> (i*4)) & 0xF;
 		if ((val != 0) || (i == 0))
 			hitNum = 1;
 		if (hitNum)
 		{
 			val = val + '0';
 			if (val > '9')
 				val = val + ('A' - '9' - 1);
 			putc(val);
 		}
 	}
 }
@@ -1,15 +0,0 @@
 //kio.h
 // Author: Josh Holtrop
 // Created: 12/25/03
 // Modified: 12/25/03
 void	printf(char *fmt, ...);
 void	putc(dword chr);
 int	putHex(dword number);
 dword	cursorPosition = 0;		//Caches the current cursor position
@@ -1 +0,0 @@
 ld -nodefaultlibs -nostdlib -T link.ld -o kernel.bin -Map .\lst\LDout.doc ks.o kernel.o asmfuncs.o
@@ -1,22 +0,0 @@
 OUTPUT_FORMAT("binary")
 ENTRY(start)
 SECTIONS
 {
  .text  0xC0106000 : {
    code = .; _code = .; __code = .;
    *(.text)
    . = ALIGN(4096);
  }
  .data  : {
    data = .; _data = .; __data = .;
    *(.data)
    . = ALIGN(4096);
  }
  .bss  :
  {
    bss = .; _bss = .; __bss = .;
    *(.bss)
    . = ALIGN(4096);
  }
  end = .; _end = .; __end = .;
 }
@@ -1,121 +0,0 @@
 // mm.c
 // Author: Josh Holtrop
 // Created: 09/01/03
 // Modified: 12/28/03
 //The total amount of physical memory available (bytes)
 #define BITMAP_SIZE	0x20000
 dword	mm_totalmem = 0;
 dword	mm_megabytes;
 byte	page_bitmap[BITMAP_SIZE];		//used to store a bit for each page that is used, 0 if available
 					//0x20000*(8 bits/byte)=0x100000 pages in 4gb total
 //This function initializes the memory manager's linked list, filling it with the
 // memory areas returned by bios interrupt 0x8E20
 void	mm_init()
 {
 	dword	memmap_entries = *(dword *)0xC009040A;
 	memmap_entry	*maps = (memmap_entry *) 0xC0092000;
 	dword a;
 	for (a = 0; a < BITMAP_SIZE; a++)
 	{
 		page_bitmap[a] = 0xFF;	//all pages used
 	}
 	for (a = 0; a < memmap_entries; a++)
 	{
 		if (maps[a].attributes == 1)		// (1) mem free to OS
 		{
 			mm_totalmem += maps[a].limit.lowdword;
 			if  ((maps[a].base.lowdword + maps[a].limit.lowdword) >= (FREERAM_START+4096))	//goes past where we start freeram
 			{
 				if (maps[a].base.lowdword < FREERAM_START)
 				{
 					mm_pfreen(FREERAM_START, (maps[a].limit.lowdword - (FREERAM_START - maps[a].base.lowdword)) >> 12);
 				}
 				else
 				{
 					mm_pfreen(maps[a].base.lowdword, maps[a].limit.lowdword >> 12);	//set the appropriate bits as "free" in the page bitmap
 				}
 			}
 		}
 	}
 	if (mm_totalmem % 0x100000)
 		mm_megabytes = (mm_totalmem >> 20) + 1;
 	else
 		mm_megabytes = mm_totalmem >> 20;
 }
 // This function frees a certain number of pages starting at the address
 //  specified in base for a length of pages pages
 void	mm_pfreen(dword base, dword pages)
 {
 	dword a;
 	dword max = base + (pages << 12);
 	for (a = base; a < max; a += 4096)
 	{
 		mm_pfree(a);
 	}
 }
 // This function frees a single page
 void	mm_pfree(dword base)
 {
 //	dword pageNumber = base >> 12;	// >>12 == /4096
 	dword byteNumber = base >> 15;	//pageNumber >> 3;	//pageNumber/8
 	dword bitNumber = (base >> 12) % 8; //pageNumber % 8;
 	page_bitmap[byteNumber] = page_bitmap[byteNumber] & ((0x01 << bitNumber) ^ 0xFF);
 }
 // This function allocates a single page, returning its physical address
 void	*mm_palloc()
 {
 	dword bite;
 	for (bite = 0; bite < BITMAP_SIZE; bite++)
 	{
 		if (page_bitmap[bite] != 0xFF)	//there is an available page within this 8-page region
 		{
 			int bit;
 			for (bit = 0; bit < 8; bit++)
 			{
 				if (!(page_bitmap[bite] & (1 << bit)))	//this bite/bit combination is available
 				{
 					page_bitmap[bite] = page_bitmap[bite] | (1 << bit);	//set page as used
 					return (void *)((bite << 15) | (bit << 12));
 				}
 			}
 		}
 	}
 	return 0;	//no free page
 }
 // This function reports the number of bytes of free physical memory
 dword	mm_freemem()
 {
 	dword a;
 	dword pages = 0;
 	for (a = 0; a < BITMAP_SIZE; a++)
 	{
 		int bit;
 		for (bit = 0; bit < 8; bit++)
 		{
 			if (!(page_bitmap[a] & (1 << bit)))
 				pages++;
 		}
 	}
 	return pages << 12;
 }
@@ -1,21 +0,0 @@
 typedef struct {
 	qword	base;
 	qword	limit;
 	dword	attributes;
 } __attribute__((packed)) memmap_entry;
 void	mm_init();
 void	mm_pfreen(dword base, dword pages);
 void	mm_pfree(dword base);
 void	*mm_palloc();
 dword	mm_freemem();
@@ -1,60 +0,0 @@
 // mouse.c
 // 10/03/03
 // Author: Josh Holtrop
 //This method initializes the ps/2 mouse
 void mouse_init()
 {
 	outportb(0x64, 0x20);		//tell keyboard controller we are going to read keyboard controller command byte
 	byte temp = inportb(0x60);	//read keyboard controller command byte
 	outportb(0x64, 0x60);		//tell keyboard controller we are going to write keyboard controller command byte
 	outportb(0x60, 0x03 | (temp&0x40));	//write keyboard controller command byte: enable mouse/keyboard ints, include original XLATE bit from temp (bit6)
 	outportb(0x64, 0xA8);	//enable mouse port
 	outportb(0x64, 0xD4);	//send command to mouse, not kbd
 	outportb(0x60, 0xF4);	//enable data reporting
 	mouse_x = video_mode.XResolution >> 1;
 	mouse_y = video_mode.YResolution >> 1;
 	//outportb(0x64, 0xD4);
 	//outportb(0x60, 0xE7);	//scaling 2:1
 }
 //This method is called when a mouse interrupt occurs
 void isr_mouse()
 {
 	byte inb = inportb(0x60);	//read mouse byte
 	if ((inb == 0xFA) && (mouse_bytesRead < 1))		//ACK
 		return;
 	mouse_inbuffer[mouse_bytesRead] = inb;
 	mouse_bytesRead++;
 	if (mouse_bytesRead == 3)	//complete packet received
 	{
 		mouse_bytesRead = 0;
 		int adjx = (char) mouse_inbuffer[1];
 		int adjy = (char) mouse_inbuffer[2];
 		mouse_x += adjx;
 		mouse_y -= adjy;						//-= because screen y coordinates are opposite mouse y coordinates
 		if (mouse_x < 0)
 			mouse_x = 0;
 		if (mouse_x >= video_mode.XResolution)
 			mouse_x = video_mode.XResolution - 1;
 		if (mouse_y < 0)
 			mouse_y = 0;
 		if (mouse_y >= video_mode.YResolution)
 			mouse_y = video_mode.YResolution - 1;
 		if (mouse_inbuffer[0] & 0x01)	//left button
 			video_pset(mouse_x, mouse_y, 0x00FF8800);
 		else
 			video_pset(mouse_x, mouse_y, 0x00FFFFFF);
 	}
 }
@@ -1,17 +0,0 @@
 // mouse.h
 // 10/03/03
 // Author: Josh Holtrop
 int mouse_x;
 int mouse_y;
 int mouse_bytesRead = 0;
 byte mouse_inbuffer[16];
 void mouse_init();
 void isr_mouse();
@@ -1,14 +0,0 @@
 // rd.c
 // Author: Josh Holtrop
 // Created: 12/31/03
 // Modified: 01/04/04
 byte	*rd_readSector(DiskDevice *rd, dword sector, byte *dest)
 {
 	memcpy(dest, (void *)(rd->location + (sector * 512)), 512);
 	return dest;
 }
@@ -1,9 +0,0 @@
 // rd.h
 // Author: Josh Holtrop
 // Created: 12/31/03
 // Modified: 01/04/04
 byte	*rd_readSector(DiskDevice *rd, dword sector, byte *dest);
@@ -1,228 +0,0 @@
 %include "bootdef.inc"
 [bits 16]
 org 0x7c00
 	jmp short start
 ; --------------------------------------------------
 ; data portion of the "DOS BOOT RECORD"
 ; ----------------------------------------------------------------------
 brINT13Flag     DB      90H             ; 0002h - 0EH for INT13 AH=42 READ
 brOEM           DB      'MSDOS5.0'      ; 0003h - OEM ID - Windows 95B
 brBPS           DW      512             ; 000Bh - Bytes per sector
 brSPC           DB      1               ; 000Dh - Sector per cluster
 brSc_b4_fat	DW      1               ; 000Eh - Reserved sectors
 brFATs          DB      2               ; 0010h - FAT copies
 brRootEntries   DW      0E0H		; 0011h - Root directory entries
 brSectorCount   DW      2880		; 0013h - Sectors in volume, < 32MB
 brMedia         DB      240		; 0015h - Media descriptor
 brSPF           DW      9               ; 0016h - Sectors per FAT
 brSc_p_trk	DW      18              ; 0018h - Sectors per head/track
 brHPC           DW      2		; 001Ah - Heads per cylinder
 brSc_b4_prt	DD      0               ; 001Ch - Hidden sectors
 brSectors       DD      0	        ; 0020h - Total number of sectors
 brDrive		DB      0               ; 0024h - Physical drive no.
 		DB      0               ; 0025h - Reserved (FAT32)
 		DB      29H             ; 0026h - Extended boot record sig (FAT32)
 brSerialNum     DD      404418EAH       ; 0027h - Volume serial number
 brLabel         DB      'Holtrops OS'   ; 002Bh - Volume label
 brFSID          DB      'FAT12   '      ; 0036h - File System ID
 ;------------------------------------------------------------------------
 start:
 	jmp	0:jmphere		;ensure that cs=0 and ip=0x7c00...
 jmphere:
 	;dl=drive number, save it!
 	xor	ax, ax
 	mov	ds, ax
 	mov	[brDrive], dl
 	cli
 	mov	ss, ax
 	mov	sp, 0x7Bfe		;right under boot sector
 	sti
 	mov	ax, 0xb800
 	mov	ds, ax
 	mov	es, ax
 	xor	di, di
 	mov	ax, 0x0700
 	mov	cx, 2000
 cls:
 	stosw
 	loop	cls
 enable_a20:
 	in	al, 0x64
 	test	al, 2
 	jnz	enable_a20
 	mov	al, 0xD1
 	out	0x64, al
 ea20_2:	in	al, 0x64
 	and	ax, byte 2
 	jnz	ea20_2
 	mov	al, 0xDF
 	out	0x60, al
 unreal:
 	xor	ax, ax
 	mov	es, ax
 	mov	ds, ax
 	lgdt	[gdtr]		;load gdt
 	cli
 	push	es
 	push	ds		;save segment values
 	mov	ebx, cr0
 	inc	bl
 	mov	cr0, ebx	;pmode!
 	mov	ax, KERNEL_DATA
 	mov	es, ax
 	mov	ds, ax		;load segment limits
 	dec	bl
 	mov	cr0, ebx	;back to real mode!
 	pop	ds
 	pop	es		;segments back, with 4gb limits!
 	sti
 ;now lets read in the FAT and root directory so we can search for the stage2 file...
 	mov	ax, 0x0209		;FAT1
 	mov	cx, 0x0002
 	xor	dh, dh
 	mov	dl, [brDrive]
 	mov	bx, BOOT_FAT_SEG
 	mov	es, bx
 	xor	bx, bx
 	int	0x13
 	mov	ax, 0x020E		;root directory
 	mov	cx, 0x0002		;cyl/sect
 	mov	dh, 0x01		;head
 	mov	dl, [brDrive]		;drive
 	mov	bx, BOOT_ROOT_SEG
 	mov	es, bx
 	xor	bx, bx
 	int	0x13
 ;k now read root directory
 	mov	bx, BOOT_ROOT_SEG
 	mov	ds, bx
 	xor	si, si			;k now ds:si points to beginning of root directory
 	mov	es, si
 	mov	cx, 224			;max root entries
 loop_compare:
 	mov	di, stage2
 	push	cx
 	push	si			;save pointer to root dir entry
 	mov	cx, 11
 loop_name:
 	cmpsb
 	loopz	loop_name
 	jnz	goon			;cx didn't get to zero, bad file
 	pop	si
 	pop	cx
 	jmp	found_file		;good file, ds:si points to start of root directory entry
 goon:
 	pop	si
 	pop	cx
 	add	si, 32
 	loop	loop_compare
 error:
 	jmp	$			;halt! no kernel file found!
 found_file:				;ds:si points to root dir entry
 	xor	ax, ax
 	mov	gs, ax
 	mov	ax, BOOT_STAGE2_SEG
 	mov	es, ax
 	mov	ax, [ds:si+26]
 	mov	bx, BOOT_FAT_SEG
 	mov	ds, bx			;ds points to beginning of FAT
 	xor	di, di
 readstage2_loop:
 	cmp	ax, 0xff7
 	jg	readstage2_done
 	inc	di
 	push	ax
 	call	getCHSfromCluster
 	mov	ax, 0x0201
 	mov	dl, [gs:BOOT_DRIVE]
 	xor	bx, bx
 	int	0x13
 	mov	bx, es
 	add	bx, 0x0020
 	mov	es, bx
 	pop	ax			;current logical cluster #
 	mov	cx, ax			;cx=logical cluster
 	mov	dx, 3
 	mul	dx
 	shr	ax, 1			;ax=logical cluster * 3 / 2
 	mov	si, ax
 	test	cl, 1			;is bit0 set?
 	jnz	odd_cluster
 even_cluster:
 	lodsw
 	and	ax, 0x0fff
 	jmp	got_cluster
 odd_cluster:
 	lodsw
 	shr	ax, 4
 got_cluster:
 	jmp	readstage2_loop
 readstage2_done:
 	jmp	0:BOOT_STAGE2_ADD
 ;------------------------------------------------------
 getCHSfromCluster:
 	;input: ax=lba of sector on floppy (0-2879)
 	add	ax, 31			;convert logical cluster# to lba#
 	xor	dx, dx			;lba->chs
 	mov	bx, 18
 	div	bx
 	inc	dx
 	mov	cl, dl			;sector# (1-18)
 	xor	dx, dx
 	mov	bx, 2
 	div	bx
 	mov	ch, al			;cylinder# (0-79)
 	mov	dh, dl			;head# (0-1)
 	ret
 ;-------------------------------------------------------
 gdtr:
 	dw	gdt_end-gdt-1
 	dd	gdt
 gdt:
 	dd	0
 	dd	0
 KERNEL_DATA equ $-gdt
 	db	0xff		;segment 16 = 4gb data
 	db	0xff
 	db	0x00
 	db	0x00
 	db	0x00
 	db	0x92
 	db	0xcf		;cf
 	db	0x00
 gdt_end:
 stage2:	db	"STAGE2  BIN"
 times 510-($-$$)	db 0
 db	0x55, 0xaa
@@ -1,971 +0,0 @@
 %include "bootdef.inc"
 %define VESA_MODEINFO_SEG 0x0120
 %define VESA_MODELIST_SEG 0x0140
 %define GOOD_MODELIST_SEG 0x0160
 [bits 16]
 org BOOT_STAGE2_ADD
 ;k now read root directory
 	mov	bx, BOOT_ROOT_SEG
 	mov	ds, bx
 	xor	si, si			;k now ds:si points to beginning of root directory
 	mov	es, si
 	mov	cx, 224			;max root entries
 loop_compare:
 	mov	di, kernel
 	push	cx
 	push	si			;save pointer to root dir entry
 	mov	cx, 11
 loop_name:
 	cmpsb
 	loopz	loop_name
 	jnz	goon			;cx didn't get to zero, bad file
 	pop	si
 	pop	cx
 	jmp	found_file		;good file, ds:si points to start of root directory entry
 goon:
 	pop	si
 	add	si, 32
 	pop	cx
 	loop	loop_compare
 error:
 	jmp	$			;halt! no kernel file found!
 found_file:				;ds:si points to root dir entry of kernel file
 	xor	ax, ax
 	mov	gs, ax
 	mov	ax, [ds:si+26]
 	mov	bx, BOOT_FAT_SEG
 	mov	ds, bx			;ds points to beginning of FAT
 	mov	edi, BOOT_KERNEL_ADD
 readkernel_loop:
 	cmp	ax, 0xff7
 	jg	readkernel_done
 	push	ax
 	call	getCHSfromCluster
 	mov	ax, 0x0201
 	mov	dl, [gs:BOOT_DRIVE]
 	mov	bx, BOOT_KERNEL_SEG
 	mov	es, bx
 	xor	bx, bx
 	int	0x13
 	mov	cx, 256
 	xor	ax, ax
 	mov	es, ax
 	mov	esi, BOOT_KERNEL_SEG*16
 copykernel_loop:
 	mov	ax, [es:esi]
 	mov	[es:edi], ax
 	inc	esi
 	inc	esi
 	inc	edi
 	inc	edi
 	loop	copykernel_loop
 	pop	ax			;current logical cluster #
 	mov	cx, ax			;cx=logical cluster
 	mov	dx, 3
 	mul	dx
 	shr	ax, 1			;ax=logical cluster * 3 / 2
 	mov	si, ax
 	test	cl, 1			;is bit0 set?
 	jnz	odd_cluster
 even_cluster:
 	lodsw
 	and	ax, 0x0fff
 	jmp	got_cluster
 odd_cluster:
 	lodsw
 	shr	ax, 4
 got_cluster:
 	jmp	readkernel_loop
 ;------------------------------------------------------
 readkernel_done:			;-------------put more real mode init stuff here!
 					;----ask to load RD from floppy
 	mov	ax, 0xb800
 	mov	es, ax
 	xor	ax, ax
 	mov	ds, ax
 	xor	di, di
 	mov	cx, 2000
 	mov	ax, 0x0700
 cls_loop:
 	stosw
 	loop	cls_loop
 	mov	dx, 0x3d4		;move cursor off screen...
 	mov	al, 0x0e
 	out	dx, al
 	inc	dx
 	mov	al, 0xff
 	out	dx, al
 	dec	dx
 	mov	al, 0x0f
 	out	dx, al
 	inc	dx
 	out	dx, al
 	xor	di, di
 	mov	si, txt_welcome
 	mov	ah, 0x1f
 	call	puts
 	mov	di, 160
 	mov	si, txt_rd1
 	mov	ah, 7
 	call	puts
 	mov	si, txt_rd2
 	mov	di, 160*2
 	call	puts
 	mov	di, 160*3
 	mov	si, txt_input
 	call	puts
 get_rd:
 	xor	ax, ax
 	int	0x16
 	cmp	al, '1'
 	jz	got_rd
 	cmp	al, '2'
 	jnz	get_rd
 got_rd:	
 	stosb
 	sub	al, '1'
 	push	ds
 	mov	bx, BOOT_DATA_SEG		;segment for data to send kernel
 	mov	ds, bx
 	mov	[ds:BOOT_HASRD], al
 	pop	ds				;ds=0
 	cmp	al, 0				;dont load rd
 	jnz	yes_rd
 	jmp	no_rd
 yes_rd:
 	mov	cx, 80
 	mov	edi, 0xb8000+160*4
 filler_loop:                                    ;draw a red bar
 	mov	word [ds:edi], 0x0400+177
 	inc	edi
 	inc	edi
 	loop	filler_loop
 	mov	cx, 80				;80 cylinders to read
 	xor	si, si                          ;start at cylinder 0
 	mov	edi, BOOT_RD_ADD		;ram disk address
 read_cylinder:
 	push	cx
 	mov	bx, 0x0100			;read sectors from head 0
 	mov	es, bx
 	xor	bx, bx                          ;es:bx = data buffer for read
 	mov	ax, 0x0212			;ah = int 0x13 function 2, al = number of sectors to read
 	mov	cx, si                          ;what cyl. we are on is now in cx
 	mov	ch, cl				;ch = cyl. number
 	mov	cl, 1                           ;cl = sector number 1-63
 	xor	dx, dx				;dh = head number
 	mov	dl, [gs:BOOT_DRIVE]             ;dl = drive number
 	int	0x13
 	mov	bx, 0x0100			;now read sectors from head 1
 	mov	es, bx
 	mov	bx, 9216                        ;es:bx = data buffer for read
 	mov	ax, 0x0212			;ah = int 0x13 function 2, al = number of sectors to read
 	mov	cx, si                          ;what cyl. we are on is now in cx
 	mov	ch, cl				;ch = cyl. number
 	mov	cl, 1                           ;cl = sector number 1-63
 	mov	dh, 1				;dh = head number
 	mov	dl, [gs:BOOT_DRIVE]             ;dl = drive number
 	int	0x13
 	mov	ebx, 0xb8000
 	add	bx, si
 	shl	bl, 1
 	mov	word [ds:ebx+160*4], 0x0200+219
 	push	si
 	mov	esi, 0x1000
 	mov	cx, 0x2400
 copydisk_loop:
 	mov	ax, [ds:esi]
 	inc	esi
 	inc	esi
 	mov	[ds:edi], ax
 	inc	edi
 	inc	edi
 	loop	copydisk_loop
 	pop	si				;what cylinder# we are on...
 	inc	si
 	pop	cx
 	loop	read_cylinder
 ;------------------------------------------------------
 no_rd:
 	mov	ax, BOOT_DATA_SEG
 	mov	es, ax
 	mov	di, BOOT_MEMMAP			;store memmap info in es:di for kernel
 	xor	edx, edx
 	mov	ax, 0x0100
 	mov	ds, ax
 	xor	ebx, ebx
 getmemmap_loop:
 	push	es
 	push	di
 	push	edx
 	mov	ax, 0x0100			;get memory map
 	mov	es, ax
 	xor	di, di
 	mov	eax, 0x0000E820
 	mov	ecx, 0x00000014
 	;mov	ebx, 0x00000000
 	mov	edx, 0x534D4150			;'SMAP'
 	int	0x15
 	jc	getmemmap_carry
 	cmp	eax, 0x534D4150			;eax should be 'SMAP' on return...
 	jnz	getmemmap_error
 	cmp	ebx, 0
 	jz	getmemmap_done
 	pop	edx				;now, copy memmap entry to es:di on the stack
 	pop	di
 	pop	es
 	xor	si, si
 	mov	cx, 20
 getmemmap_copymem_loop:
 	lodsb
 	stosb
 	loop	getmemmap_copymem_loop
 	inc	edx
 	jmp	getmemmap_loop
 getmemmap_error:
 	mov	ax, 0xb800
 	mov	es, ax
 	mov	di, 160*24
 	xor	ax, ax
 	mov	ds, ax
 	mov	si, txt_memerror
 	mov	ah, 0x04
 	call	puts
 	hlt
 	jmp	$
 getmemmap_carry:
 	dec	edx
 getmemmap_done:
 	pop	edx
 	pop	di
 	pop	es
 	xor	si, si
 	mov	cx, 20
 getmemmap_done_copymem_loop:
 	lodsb
 	stosb
 	loop	getmemmap_done_copymem_loop
 	inc	edx
 	mov	di, BOOT_MEMENTRIES
 	mov	[es:di], edx			;save # of memmap entries for kernel
 						;on to vesa info...
 	xor	ax, ax
 	mov	gs, ax
 	mov	ds, ax
 	mov	ax, 0xb800
 	mov	es, ax
 	mov	di, 160
 	mov	cx, 2000-80
 	mov	ax, 0x0700
 cls_vesa_loop:
 	stosw
 	loop	cls_vesa_loop
 	mov	si, txt_vesa
 	mov	di, 160*1
 	mov	ah, 7
 	call	puts
 	push	di
 	mov	ax, 0x0100
 	mov	es, ax
 	xor	di, di
 	mov	dword [es:di], "2EBV"
 	mov	ax, 0x4F00
 	int	0x10
 	pop	di
 	cmp	ax, 0x004F
 	jz	vesa_good
 	mov	si, txt_novesa
 	mov	ax, 0xb800
 	mov	es, ax
 	mov	ah, 7
 	call	puts
 	mov	ax, BOOT_DATA_SEG
 	mov	ds, ax
 	mov	word [ds:BOOT_VESA], 0
 	jmp	vesa_done
 vesa_good:
 	mov	ax, 0xb800
 	mov	es, ax
 	mov	ax, 0x0100
 	mov	ds, ax
 	xor	si, si
 	mov	bx, [4]
 	mov	al, bh
 	call	puthex
 	mov	al, '.'
 	stosb
 	mov	al, 7
 	stosb
 	mov	al, bl
 	call	puthex
 	add	di, 4
 	cmp	bh, 2
 	jge	vesa_good2
 	xor	ax, ax
 	mov	ds, ax
 	mov	si, txt_vesaold
 	mov	ah, 7
 	call	puts
 	mov	ax, BOOT_DATA_SEG
 	mov	ds, ax
 	mov	word [ds:BOOT_VESA], 0
 	jmp	vesa_done
 vesa_good2:
 	mov	ebx, [6]			;something like 0x00000E60
 	mov	edx, [14]
 	mov	si, bx
 	shr	ebx, 16
 	mov	ds, bx				;ds:si points to null-terminated OEM identification string
 	mov	ah, 2
 	push	si
 	call	puts
 	pop	si
 	mov	ax, BOOT_DATA_SEG
 	mov	es, ax
 	mov	di, BOOT_VESA_OEM
 vesa_copyoem:
 	lodsb
 	stosb
 	or	al, al
 	jnz	vesa_copyoem
 	mov	ax, 0x0100
 	mov	ds, ax
 	xor	si, si
 	mov	di, BOOT_VESA_VBE
 	mov	cx, 512
 vesa_copyvbe:
 	lodsb
 	stosb
 	loop	vesa_copyvbe
 	mov	si, dx
 	shr	edx, 16
 	mov	ds, dx				;ds:si points to video mode list
 	mov	ax, VESA_MODELIST_SEG
 	mov	es, ax
 	xor	di, di
 vesa_copymodes:
 	lodsw
 	stosw
 	cmp	ax, 0xffff
 	jnz	vesa_copymodes
 	mov	ax, GOOD_MODELIST_SEG
 	mov	es, ax
 	xor	di, di
 	mov	cx, 256
 	mov	ax, 0xffff
 clear_good_mode_list_loop:
 	stosw
 	loop	clear_good_mode_list_loop
 	mov	ax, VESA_MODELIST_SEG
 	mov	ds, ax
 	xor	si, si				;ds:si points to video mode list where we can edit it :)
 	mov	ax, GOOD_MODELIST_SEG
 	mov	es, ax
 	xor	di, di
 	xor	dx, dx				;dx=what good mode # we are on
 vesa_readmodeinfo_loop:
 	lodsw
 	cmp	ax, 0xffff
 	jz	vesa_endofmodes
 	push	ax				;save mode#
 	call	checkmode
 	cmp	ax, 0
 	jz	vesa_readmodeinfo_good
 	pop	ax
 	jmp	vesa_readmodeinfo_loop
 vesa_readmodeinfo_good:
 	pop	ax				;restore mode#
 	stosw
 	call	vesa_showmodeinfo
 	inc	dx
 	jmp	vesa_readmodeinfo_loop
 vesa_endofmodes:				;here we have a list of good modes at GOOD_MODELIST_SEG:0
 	xor	ax, ax
 	mov	ds, ax
 	mov	si, txt_consolemode
 	mov	ax, 0xb800
 	mov	es, ax
 	mov	di, 160*2
 	mov	ah, 7
 	call	puts
 	mov	di, 160*3
 	mov	cx, dx
 	mov	al, 'b'
 vesa_displaylabels:
 	stosb
 	push	ax
 	mov	al, 7
 	stosb
 	mov	al, '.'
 	stosb
 	mov	al, 7
 	stosb
 	pop	ax
 	inc	al
 	add	di, 160-4
 	loop	vesa_displaylabels		;done drawing screen of VESA choices, now ask for one
 						;valid options are 'a' through (al-1)
 	mov	bl, al
 	xor	ax, ax
 	mov	ds, ax
 	mov	di, 160*24
 	mov	si, txt_input
 	mov	ah, 14
 	call	puts
 vesa_getchoice:
 	xor	ax, ax
 	int	0x16
 	cmp	al, 'a'
 	jl	vesa_getchoice
 	cmp	al, bl
 	jge	vesa_getchoice
 	stosb
 	push	ax
 	mov	al, 14
 	stosb
 	pop	ax
 	xor	ah, ah
 	sub	ax, 'a'
 	cmp	ax, 0
 	jz	vesa_consolemode_only
 	mov	cx, ax				;cx holds good mode# (1=first good vesa mode)
 	dec	cx
 	mov	ax, GOOD_MODELIST_SEG
 	mov	ds, ax
 	shl	cx, 1
 	mov	si, cx				;ds:si points to word containing selected mode#
 	lodsw
 	mov	cx, ax
 	mov	dx, ax				;cx and dx hold mode#
 	mov	ax, VESA_MODEINFO_SEG
 	mov	es, ax
 	xor	di, di
 	mov	ax, 0x4F01
 	int	0x10
 	call	checkvesa
 	mov	ax, VESA_MODEINFO_SEG
 	mov	ds, ax
 	xor	si, si
 	mov	ax, BOOT_DATA_SEG
 	mov	es, ax
 	mov	di, BOOT_VESA_INFO
 	mov	cx, 256
 vesa_copymodeinfo_loop:
 	lodsb
 	stosb
 	loop	vesa_copymodeinfo_loop		;store ModeInfoBlock for current
 	mov	[es:BOOT_VESA], dx		;store mode# for kernel
 ;	mov	ax, 0xb800
 ;	mov	es, ax
 ;	xor	di, di
 ;	mov	al, dh
 ;	call	puthex2
 ;	mov	al, dl
 ;	call	puthex2
 	mov	bx, dx
 	or	bx, 0x4000			;set "use LFB" bit of mode#
 	mov	ax, 0x4F02
 	int	0x10				;switch to graphics mode!!!
 	call	checkvesa
 	jmp	vesa_done
 vesa_consolemode_only:
 	mov	ax, BOOT_DATA_SEG
 	mov	es, ax
 	mov	word [es:BOOT_VESA], 0
 	jmp	vesa_done
 ;------------------------------------------------------
 vesa_showmodeinfo:
 	pusha
 	push	es
 	push	ds
 	mov	ax, VESA_MODEINFO_SEG
 	mov	ds, ax
 	xor	si, si
 	mov	ax, 0xb800
 	mov	es, ax
 	mov	cx, dx
 	mov	ax, 160
 	mul	dx				;ax=160*mod#
 	add	ax, 160*3+6			;offset first line of modes and room on left for label
 	mov	di, ax
 	mov	ax, [ds:18]
 	call	console_putDec
 	add	di, 10
 	mov	al, 'x'
 	call	console_putChar
 	inc	di
 	inc	di
 	mov	ax, [ds:20]
 	call	console_putDec
 	add	di, 10
 	mov	al, 'x'
 	call	console_putChar
 	inc	di
 	inc	di
 	xor	ah, ah
 	mov	al, [ds:25]
 	call	console_putDec
 	add	di, 8
 	mov	al, [ds:0]
 	test	al, 0x80
 	jz	vesa_showmodeinfo_done
 	mov	al, 'L'
 	call	console_putChar
 	mov	al, 'F'
 	call	console_putChar
 	mov	al, 'B'
 	call	console_putChar
 	inc	di
 	inc	di
 	mov	ebx, [ds:40]
 	mov	eax, ebx
 	shr	eax, 24
 	call	puthex2
 	mov	eax, ebx
 	shr	eax, 16
 	call	puthex2
 	mov	al, bh
 	call	puthex2
 	mov	al, bl
 	call	puthex2
 vesa_showmodeinfo_done:
 	pop	ds
 	pop	es
 	popa
 	ret
 ;------------------------------------------------------
 checkmode:
 	push	bx
 	push	cx
 	push	dx
 	push	es
 	push	ds
 	push	di
 	push	si
 	mov	cx, ax				;cx=modenumber
 	mov	ax, VESA_MODEINFO_SEG
 	mov	es, ax
 	xor	di, di
 	mov	ax, 0x4F01
 	int	0x10
 	call	checkvesa
 	xor	di, di				;es:di -> ModeInfoBlock struc
 	mov	ax, [es:di]			;ModeAttributes
 	test	al, 1				;mode supported
 	jz	vesa_modenogood
 	test	al, 8				;color mode
 	jz	vesa_modenogood
 	test	al, 0x10			;graphics mode
 	jz	vesa_modenogood
 	test	al, 0x80			;Linear Frame Buffer supported
 	jz	vesa_modenogood
 	mov	al, [es:di+25]			;BitsPerPixel
 	cmp	al, 16
 	jz	vesa_bppok
 	cmp	al, 24
 	jz	vesa_bppok
 	cmp	al, 32
 	jnz	vesa_modenogood
 vesa_bppok:
 	mov	ax, [es:di+18]			;XResolution
 	mov	bx, [es:di+20]			;YResolution
 	cmp	ax, 640				;640x480
 	jnz	res_goon1
 	cmp	bx, 480
 	jnz	vesa_modenogood
 	jmp	vesa_modegood
 res_goon1:
 	cmp	ax, 800
 	jnz	res_goon2
 	cmp	bx, 600
 	jnz	vesa_modenogood
 	jmp	vesa_modegood
 res_goon2:
 	cmp	ax, 1024
 	jnz	res_goon3
 	cmp	bx, 768
 	jnz	vesa_modenogood
 	jmp	vesa_modegood
 res_goon3:
 	cmp	ax, 1280
 	jnz	res_goon4
 	cmp	bx, 1024
 	jz	vesa_modegood
 	cmp	bx, 960
 	jz	vesa_modegood
 	jmp	vesa_modenogood
 res_goon4:
 	cmp	ax, 1600
 	jnz	vesa_modenogood
 	cmp	bx, 1200
 	jnz	vesa_modenogood
 vesa_modegood:
 	pop	si
 	pop	di
 	pop	ds
 	pop	es
 	pop	dx
 	pop	cx
 	pop	bx
 	xor	ax, ax
 	ret
 vesa_modenogood:
 	pop	si
 	pop	di
 	pop	ds
 	pop	es
 	pop	dx
 	pop	cx
 	pop	bx
 	mov	ax, 0xffff
 	ret
 ;------------------------------------------------------
 vesa_done:
 ;	xor	ax, ax				;wait for keypress...
 ;	int	0x16
 	jmp	go_pm
 ;------------------------------------------------------
 puts:
 	lodsb
 	or	al, al
 	jz	puts_done
 	stosb
 	mov	al, ah
 	stosb
 	jmp	puts
 puts_done:
 	ret
 ;------------------------------------------------------
 checkvesa:
 	cmp	ax, 0x004F
 	jnz	vesaerror
 	ret
 vesaerror:
 	mov	ax, 0xb800
 	mov	es, ax
 	xor	ax, ax
 	mov	ds, ax
 	mov	si, txt_vesaerror
 	mov	di, 160*24
 	mov	ah, 4
 	call	puts
 	cli
 	hlt
 ;-------Function console_putDec
 ;input:
 ; AX = number to display
 ;output:
 ; number written in decimal to es:di
 console_putDec:
 	pusha
 	xor	dx, dx
 	xor	bh, bh			;no characters written yet
 	mov	cx, 10000
 	div	cx			;ax=quotiont, dx=remainder
 	add	ax, '0'
 	cmp	ax, '0'
 	je	.goon1
 	call	console_putChar
 	mov	bh, 1
 .goon1:
 	mov	ax, dx			;load remainder to ax
 	xor	dx, dx
 	mov	cx, 1000
 	div	cx			;ax=quotiont, dx=remainder
 	add	ax, '0'
 	cmp	ax, '0'
 	je	.goon11
 	call	console_putChar
 	mov	bh, 1
 	jmp	.goon2
 .goon11:
 	cmp	bh, 0
 	je	.goon2
 	call	console_putChar
 .goon2:
 	mov	ax, dx			;load remainder to ax
 	xor	dx, dx
 	mov	cx, 100
 	div	cx			;ax=quotiont, dx=remainder
 	add	ax, '0'
 	cmp	ax, '0'
 	je	.goon21
 	call	console_putChar
 	mov	bh, 1
 	jmp	.goon3
 .goon21:
 	cmp	bh, 0
 	je	.goon3
 	call	console_putChar
 .goon3:
 	mov	ax, dx			;load remainder to ax
 	xor	dx, dx
 	mov	cx, 10
 	div	cx			;ax=quotiont, dx=remainder
 	add	ax, '0'
 	cmp	ax, '0'
 	je	.goon31
 	call	console_putChar
 	mov	bh, 1
 	jmp	.goon4
 .goon31:
 	cmp	bh, 0
 	je	.goon4
 	call	console_putChar
 .goon4:					;here dx contains last remainder
 	mov	ax, dx
 	add	ax, '0'
 	call	console_putChar
 	popa
 	ret
 ;------------------------------------------------------
 console_putChar:
 	stosb
 	mov	al, 7
 	stosb
 	ret
 ;------------------------------------------------------
 puthex:
 	;es:di points to video memory
 	;al holds hex value
 	push	ax
 	mov	ah, al
 	shr	ax, 4
 	and	al, 0x0F
 	add	al, '0'
 	cmp	al, '9'
 	jle	puthex_goon1
 	add	al, 'A'-'9'-1
 puthex_goon1:
 	cmp	al, '0'
 	jz	puthex_skipzero
 	stosb
 	mov	al, 7
 	stosb
 puthex_skipzero:
 	pop	ax
 	push	ax
 	and	al, 0x0F
 	add	al, '0'
 	cmp	al, '9'
 	jle	puthex_goon2
 	add	al, 'A'-'9'-1
 puthex_goon2:
 	stosb
 	mov	al, 7
 	stosb
 	pop	ax
 	ret
 ;------------------------------------------------------
 puthex2:
 	;es:di points to video memory, always displays 2 characters!
 	;al holds hex value
 	push	ax
 	mov	ah, al
 	shr	ax, 4
 	and	al, 0x0F
 	add	al, '0'
 	cmp	al, '9'
 	jle	puthex2_goon1
 	add	al, 'A'-'9'-1
 puthex2_goon1:
 	stosb
 	mov	al, 7
 	stosb
 	pop	ax
 	push	ax
 	and	al, 0x0F
 	add	al, '0'
 	cmp	al, '9'
 	jle	puthex2_goon2
 	add	al, 'A'-'9'-1
 puthex2_goon2:
 	stosb
 	mov	al, 7
 	stosb
 	pop	ax
 	ret
 ;------------------------------------------------------
 txt_welcome: db	"                             Welcome to HOS v", VERSION, "!                              ", 0
 txt_rd1: db	"1. Do not load an initial ram disk", 0
 txt_rd2: db	"2. Load initial ram disk from floppy", 0
 txt_input: db	"Enter your selection: ", 0
 txt_vesa: db	"VESA version: ", 0
 txt_vesaerror: db "VESA function call error! Halting system!", 0
 txt_novesa: db	"VESA not found. Starting in console mode...", 0
 txt_vesaold: db	"VESA version 2.0 required. Starting in console mode...", 0
 txt_consolemode: db "a. Console mode only.", 0
 txt_memerror: db "Extended Memory Map information unavailable! Halting system...", 0
 ;------------------------------------------------------
 getCHSfromCluster:
 	;input: ax=lba of sector on floppy (0-2879)
 	add	ax, 31			;convert logical cluster# to lba#
 	xor	dx, dx			;lba->chs
 	mov	bx, 18
 	div	bx
 	inc	dx
 	mov	cl, dl			;sector# (1-18)
 	xor	dx, dx
 	mov	bx, 2
 	div	bx
 	mov	ch, al			;cylinder# (0-79)
 	mov	dh, dl			;head# (0-1)
 	ret
 ;-------------------------------------------------------
 gdtr:
 	dw	gdt_end-gdt-1
 	dd	gdt
 gdt:
 	dd	0
 	dd	0
 KERNEL_CODE equ $-gdt
 	db	0xff		;limit	7:0
 	db	0xff		;limit	15:8
 	db	0x00		;base	7:0
 	db	0x00		;base	15:8
 	db	0x00		;base	23:16
 	db	0x9a		;access
 	db	0xcf		;flags / limit 19:16
 	db	0x00		;base	31:24
 KERNEL_DATA equ $-gdt
 	db	0xff		;segment 16 = 4gb data
 	db	0xff
 	db	0x00
 	db	0x00
 	db	0x00
 	db	0x92
 	db	0xcf
 	db	0x00
 gdt_end:
 ;-------------------------------------------------------
 gdtr32:
 	dw	gdt_end32-gdt32-1
 	dd	gdt32
 gdt32:
 	dd	0
 	dd	0
 	;a base of 0x4000_0000, when added to 0xC000_0000 will produce 0x0000_0000 physical before paging in effect
 KERNEL_CODE32 equ $-gdt32
 	db	0xff		;limit	7:0
 	db	0xff		;limit	15:8
 	db	0x00		;base	7:0
 	db	0x00		;base	15:8
 	db	0x00		;base	23:16
 	db	0x9a		;access
 	db	0xcf		;flags / limit 19:16
 	db	0x40		;base	31:24
 KERNEL_DATA32 equ $-gdt32
 	db	0xff		;segment 16 = 4gb data
 	db	0xff
 	db	0x00
 	db	0x00
 	db	0x00
 	db	0x92
 	db	0xcf
 	db	0x40
 gdt_end32:
 ;------------------------------------------------------
 go_pm:
 	xor	ax, ax
 	mov	ds, ax
 	lgdt	[gdtr]
 	cli
 	mov	eax, cr0
 	inc	eax
 	mov	cr0, eax
 	jmp	KERNEL_CODE:pmode
 bits 32
 pmode:
 	lgdt	[gdtr32]
 	jmp	KERNEL_CODE32:pmode_offsetted+0xC0000000
 pmode_offsetted:
 	mov	ax, KERNEL_DATA32
 	mov	es, ax
 	mov	ds, ax
 	mov	fs, ax
 	mov	gs, ax
 	jmp	KERNEL_CODE:BOOT_KERNEL_ADD+0xC0000000
 kernel:	db	"KERNEL  BIN", 0
@@ -1,258 +0,0 @@
 const byte stdfont[] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xE0, 0xC0, 0x80, 
 	0x00, 0x08, 0x18, 0x38, 0x78, 0x38, 0x18, 0x08, 
 	0x00, 0x20, 0x70, 0xA8, 0x20, 0xA8, 0x70, 0x20, 
 	0x00, 0xA0, 0xA0, 0xA0, 0xA0, 0x00, 0xA0, 0xA0, 
 	0x00, 0x78, 0xA8, 0xA8, 0x78, 0x28, 0x28, 0x68, 
 	0x00, 0x78, 0x80, 0x70, 0x88, 0x70, 0x08, 0xF0, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xF8, 
 	0x00, 0x20, 0x70, 0xA8, 0x20, 0xA8, 0x70, 0xF8, 
 	0x00, 0x20, 0x70, 0xA8, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x20, 0x20, 0x20, 0x20, 0xA8, 0x70, 0x20, 
 	0x00, 0x00, 0x20, 0x10, 0xF8, 0x10, 0x20, 0x00, 
 	0x00, 0x00, 0x20, 0x40, 0xF8, 0x40, 0x20, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 
 	0x00, 0x60, 0x90, 0x60, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x20, 0x70, 0xF8, 0xF8, 0x00, 0x00, 
 	0x00, 0x00, 0xF8, 0xF8, 0x70, 0x20, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x20, 0x20, 
 	0x00, 0x50, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x50, 0xF8, 0x50, 0x50, 0x50, 0xF8, 0x50, 
 	0x00, 0x20, 0x78, 0xA0, 0x70, 0x28, 0xF0, 0x20, 
 	0x00, 0x00, 0x08, 0x90, 0x20, 0x48, 0x80, 0x00, 
 	0x00, 0x20, 0x50, 0x50, 0x20, 0x58, 0x90, 0x68, 
 	0x00, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40, 0x20, 
 	0x00, 0x40, 0x20, 0x20, 0x20, 0x20, 0x20, 0x40, 
 	0x00, 0x00, 0xA8, 0x70, 0xF8, 0x70, 0xA8, 0x00, 
 	0x00, 0x00, 0x20, 0x20, 0xF8, 0x20, 0x20, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x40, 
 	0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 
 	0x00, 0x00, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 
 	0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0x20, 0x60, 0xA0, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x70, 0x88, 0x08, 0x10, 0x20, 0x40, 0xF8, 
 	0x00, 0x70, 0x88, 0x08, 0x10, 0x08, 0x88, 0x70, 
 	0x00, 0x30, 0x50, 0x90, 0x90, 0xF8, 0x10, 0x10, 
 	0x00, 0xF8, 0x80, 0x80, 0xF8, 0x08, 0x88, 0x70, 
 	0x00, 0x38, 0x40, 0x80, 0xF0, 0x88, 0x88, 0x70, 
 	0x00, 0xF8, 0x08, 0x10, 0x20, 0x40, 0x40, 0x40, 
 	0x00, 0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70, 
 	0x00, 0x70, 0x88, 0x88, 0x78, 0x08, 0x10, 0x60, 
 	0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 
 	0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x40, 
 	0x00, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 
 	0x00, 0x00, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x00, 
 	0x00, 0x80, 0x40, 0x20, 0x10, 0x20, 0x40, 0x80, 
 	0x00, 0x70, 0x88, 0x08, 0x10, 0x20, 0x00, 0x20, 
 	0x00, 0x70, 0x88, 0x88, 0xB8, 0xB0, 0x80, 0x78, 
 	0x00, 0x70, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
 	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 
 	0x00, 0x70, 0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 
 	0x00, 0xF0, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 
 	0x00, 0xF8, 0x80, 0x80, 0xF0, 0x80, 0x80, 0xF8, 
 	0x00, 0xF8, 0x80, 0x80, 0xF0, 0x80, 0x80, 0x80, 
 	0x00, 0x70, 0x88, 0x80, 0xB8, 0x88, 0x88, 0x70, 
 	0x00, 0x88, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
 	0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x90, 0x60, 
 	0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 
 	0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xF8, 
 	0x00, 0x88, 0xD8, 0xA8, 0x88, 0x88, 0x88, 0x88, 
 	0x00, 0x88, 0xC8, 0xE8, 0xB8, 0x98, 0x88, 0x88, 
 	0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 0x80, 
 	0x00, 0x70, 0x88, 0x88, 0x88, 0xA8, 0x98, 0x70, 
 	0x00, 0xF0, 0x88, 0x88, 0xF0, 0xA0, 0x90, 0x88, 
 	0x00, 0x70, 0x88, 0x80, 0x70, 0x08, 0x88, 0x70, 
 	0x00, 0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0x50, 0x20, 
 	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0xA8, 0x50, 
 	0x00, 0x88, 0x50, 0x20, 0x20, 0x50, 0x88, 0x88, 
 	0x00, 0x88, 0x88, 0x50, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0xF8, 0x08, 0x10, 0x20, 0x40, 0x80, 0xF8, 
 	0x00, 0x70, 0x40, 0x40, 0x40, 0x40, 0x40, 0x70, 
 	0x00, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x08, 0x00, 
 	0x00, 0xE0, 0x20, 0x20, 0x20, 0x20, 0x20, 0xE0, 
 	0x00, 0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 
 	0x00, 0x60, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x70, 0x08, 0x78, 0x88, 0x78, 
 	0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0x88, 0xF0, 
 	0x00, 0x00, 0x00, 0x70, 0x88, 0x80, 0x88, 0x70, 
 	0x00, 0x08, 0x08, 0x78, 0x88, 0x88, 0x88, 0x78, 
 	0x00, 0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x78, 
 	0x00, 0x30, 0x40, 0x40, 0xE0, 0x40, 0x40, 0x40, 
 	0x00, 0x00, 0x00, 0x78, 0x88, 0x78, 0x08, 0x70, 
 	0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0x88, 0x88, 
 	0x00, 0x20, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x10, 0x00, 0x10, 0x10, 0x10, 0x90, 0x60, 
 	0x00, 0x80, 0x80, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 
 	0x00, 0xC0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 
 	0x00, 0x00, 0x00, 0xD0, 0xA8, 0xA8, 0xA8, 0xA8, 
 	0x00, 0x00, 0x00, 0xF0, 0x88, 0x88, 0x88, 0x88, 
 	0x00, 0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0x00, 0x00, 0xF0, 0x88, 0xF0, 0x80, 0x80, 
 	0x00, 0x00, 0x00, 0x78, 0x88, 0x78, 0x08, 0x38, 
 	0x00, 0x00, 0x00, 0x70, 0x48, 0x40, 0x40, 0x40, 
 	0x00, 0x00, 0x00, 0x78, 0x80, 0x70, 0x08, 0xF0, 
 	0x00, 0x40, 0x40, 0xE0, 0x40, 0x40, 0x40, 0x20, 
 	0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0x88, 0x78, 
 	0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 
 	0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0xA8, 0x50, 
 	0x00, 0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 
 	0x00, 0x00, 0x00, 0x88, 0x88, 0x78, 0x08, 0xF0, 
 	0x00, 0x00, 0x00, 0xF8, 0x10, 0x20, 0x40, 0xF8, 
 	0x00, 0x30, 0x40, 0x40, 0x80, 0x40, 0x40, 0x30, 
 	0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0xC0, 0x20, 0x20, 0x10, 0x20, 0x20, 0xC0, 
 	0x00, 0x00, 0x68, 0x90, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x70, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
 	0x00, 0xF8, 0x88, 0x80, 0xF0, 0x88, 0x88, 0xF0, 
 	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 
 	0x00, 0xF8, 0x48, 0x40, 0x40, 0x40, 0x40, 0xE0, 
 	0x00, 0xF0, 0x50, 0x50, 0x50, 0x50, 0x78, 0x88, 
 	0x00, 0xF8, 0x80, 0x80, 0xF0, 0x80, 0x80, 0xF8, 
 	0x00, 0xA8, 0xA8, 0x70, 0x20, 0x70, 0xA8, 0xA8, 
 	0x00, 0x70, 0x88, 0x08, 0x30, 0x08, 0x88, 0x70, 
 	0x00, 0x88, 0x98, 0xA8, 0xA8, 0xA8, 0xC8, 0x88, 
 	0x00, 0xA8, 0xC8, 0x98, 0xA8, 0xA8, 0xC8, 0x88, 
 	0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 
 	0x00, 0xF8, 0x50, 0x50, 0x50, 0x50, 0x50, 0x90, 
 	0x00, 0x88, 0xD8, 0xA8, 0x88, 0x88, 0x88, 0x88, 
 	0x00, 0x88, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
 	0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 
 	0x00, 0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 0x80, 
 	0x00, 0x70, 0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 
 	0x00, 0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x40, 0x80, 
 	0x00, 0x70, 0x20, 0xF8, 0xA8, 0xF8, 0x20, 0x70, 
 	0x00, 0x88, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 
 	0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF8, 0x08, 
 	0x00, 0x88, 0x88, 0x88, 0xF8, 0x08, 0x08, 0x38, 
 	0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 
 	0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 0x08, 
 	0x00, 0xC0, 0x40, 0x40, 0x78, 0x48, 0x48, 0x78, 
 	0x00, 0x88, 0x88, 0xC8, 0xA8, 0xA8, 0xA8, 0xE8, 
 	0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0x88, 0xF0, 
 	0x00, 0xF0, 0x88, 0x08, 0x78, 0x08, 0x88, 0xF0, 
 	0x00, 0x90, 0xA8, 0xA8, 0xE8, 0xA8, 0xA8, 0x90, 
 	0x00, 0x78, 0x88, 0x88, 0x78, 0x28, 0x48, 0x88, 
 	0x00, 0x00, 0x70, 0x08, 0x78, 0x88, 0x88, 0x78, 
 	0x00, 0x00, 0xF8, 0x80, 0xF0, 0x88, 0x88, 0xF0, 
 	0x00, 0x00, 0xF0, 0x88, 0xF0, 0x88, 0x88, 0xF0, 
 	0x00, 0x00, 0xF8, 0x48, 0x48, 0x40, 0x40, 0xE0, 
 	0x00, 0x00, 0x78, 0x50, 0x50, 0x50, 0x70, 0x88, 
 	0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x88, 0x70, 
 	0x00, 0x00, 0xA8, 0x70, 0x20, 0x70, 0xA8, 0xA8, 
 	0x00, 0x00, 0x00, 0xF0, 0x88, 0x30, 0x88, 0x70, 
 	0x00, 0x00, 0x88, 0x98, 0xA8, 0xC8, 0x88, 0x88, 
 	0x00, 0x50, 0x20, 0x88, 0x98, 0xA8, 0xC8, 0x88, 
 	0x00, 0x00, 0x88, 0x90, 0xA0, 0xE0, 0x90, 0x88, 
 	0x00, 0x00, 0xF8, 0x48, 0x48, 0x48, 0x48, 0xC8, 
 	0x00, 0x00, 0x88, 0xD8, 0xA8, 0x88, 0x88, 0x88, 
 	0x00, 0x00, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 
 	0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0x00, 0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x70, 0x50, 0x70, 0x08, 0x78, 0x88, 0x78, 
 	0x00, 0x88, 0x00, 0x70, 0x08, 0x78, 0x88, 0x78, 
 	0x00, 0x88, 0x00, 0x70, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0x88, 0x00, 0x88, 0x88, 0x88, 0x88, 0x78, 
 	0x00, 0x90, 0x00, 0xF0, 0x80, 0xE0, 0x80, 0xF0, 
 	0x00, 0x00, 0x70, 0x48, 0x70, 0x48, 0x48, 0xF0, 
 	0x00, 0x88, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x88, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x78, 
 	0x00, 0x70, 0x50, 0x70, 0x88, 0xF8, 0x88, 0x88, 
 	0x00, 0x88, 0x70, 0x88, 0x88, 0xF8, 0x88, 0x88, 
 	0x00, 0x88, 0x70, 0x88, 0x88, 0x88, 0x88, 0x70, 
 	0x00, 0x88, 0x00, 0x88, 0x88, 0x88, 0x88, 0x78, 
 	0x00, 0x88, 0xF8, 0x80, 0xE0, 0x80, 0x80, 0xF8, 
 	0x00, 0x40, 0x20, 0x70, 0x88, 0xF8, 0x80, 0x78, 
 	0x00, 0x10, 0x20, 0x70, 0x88, 0xF8, 0x80, 0x78, 
 	0x00, 0x20, 0x50, 0x70, 0x88, 0xF8, 0x80, 0x78, 
 	0x00, 0x40, 0x20, 0x70, 0x08, 0x78, 0x88, 0x78, 
 	0x00, 0x20, 0x50, 0x00, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x20, 0x10, 0x88, 0x88, 0x88, 0x88, 0x78, 
 	0x00, 0x00, 0x00, 0x70, 0x80, 0x80, 0x70, 0x20, 
 	0x00, 0x70, 0x88, 0x40, 0xF0, 0x40, 0x40, 0xF8, 
 	0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x88, 0x88, 0x88, 0xF0, 0x80, 0x80, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 
 	0x00, 0x00, 0x70, 0x88, 0x80, 0x80, 0x88, 0x70,
 	0x00, 0x00, 0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 
 	0x00, 0x00, 0x88, 0x88, 0x50, 0x20, 0x40, 0x80, 
 	0x00, 0x00, 0x70, 0x20, 0xF8, 0xF8, 0x20, 0x70, 
 	0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 
 	0x00, 0x00, 0x88, 0x88, 0x88, 0x88, 0xF8, 0x08, 
 	0x00, 0x00, 0x88, 0x88, 0x88, 0xF8, 0x08, 0x38, 
 	0x00, 0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 
 	0x00, 0x00, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 0x08, 
 	0x00, 0x00, 0xC0, 0x40, 0x70, 0x48, 0x48, 0x70, 
 	0x00, 0x00, 0x88, 0x88, 0xC8, 0xA8, 0xA8, 0xE8, 
 	0x00, 0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0xF0, 
 	0x00, 0x00, 0x70, 0x88, 0x38, 0x08, 0x88, 0x70, 
 	0x00, 0x00, 0x90, 0xA8, 0xA8, 0xE8, 0xA8, 0x90, 
 	0x00, 0x00, 0x38, 0x48, 0x48, 0x38, 0x28, 0x48, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00	};
@@ -0,0 +1,100 @@
 #!/bin/bash -x
 BINUTILS_VERSION=${BINUTILS_VERSION:-"2.20"}
 GCC_VERSION=${GCC_VERSION:-"4.4.2"}
 TARGET=${TARGET:-"i586-elf"}
 PREFIX=${PREFIX:-"$HOME/local/$TARGET"}
 GNUFTP=ftp://ftp.gnu.org/gnu
 export PATH=$PREFIX/bin:$PATH
 mkdir -p build-binutils build-gcc
 if [ ! -f "binutils-$BINUTILS_VERSION.tar.bz2" ]; then
    wget "$GNUFTP/binutils/binutils-$BINUTILS_VERSION.tar.bz2"
    if [ $? != 0 ]; then
        echo "Error downloading binutils"
        exit 1
    fi
 fi
 if [ ! -f "gcc-$GCC_VERSION.tar.bz2" ]; then
    wget "$GNUFTP/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.bz2"
    if [ $? != 0 ]; then
        echo "Error downloading gcc"
        exit 1
    fi
 fi
 if [ ! -d "binutils-$BINUTILS_VERSION" ]; then
    tar xvjf "binutils-$BINUTILS_VERSION.tar.bz2"
    if [ $? != 0 ]; then
        echo "Error extracting binutils"
        exit 1
    fi
 fi
 if [ ! -d "gcc-$GCC_VERSION" ]; then
    tar xvjf "gcc-$GCC_VERSION.tar.bz2"
    if [ $? != 0 ]; then
        echo "Error extracting gcc"
        exit 1
    fi
 fi
 # build binutils
 dum=`which $TARGET-ar`
 if [ $? != 0 ]; then
    pushd build-binutils
    ../binutils-$BINUTILS_VERSION/configure --target=$TARGET --prefix=$PREFIX --disable-nls
    if [ $? != 0 ]; then
        echo "Error configuring binutils"
        exit 1
    fi
    make all
    if [ $? != 0 ]; then
        echo "Error building binutils"
        exit 1
    fi
    make install
    if [ $? != 0 ]; then
        echo "Error installing binutils"
        exit 1
    fi
    popd
 fi
 # build gcc
 dum=`which $TARGET-gcc`
 if [ $? != 0 ]; then
    pushd build-gcc
    ../gcc-$GCC_VERSION/configure --target=$TARGET --prefix=$PREFIX --disable-nls --enable-languages=c,c++ --without-headers
    if [ $? != 0 ]; then
        echo "Error configuring gcc"
        exit 1
    fi
    make all-gcc
    if [ $? != 0 ]; then
        echo "Error building gcc"
        exit 1
    fi
    make install-gcc
    if [ $? != 0 ]; then
        echo "Error installing gcc"
        exit 1
    fi
    make all-target-libgcc
    if [ $? != 0 ]; then
        echo "Error building libgcc"
        exit 1
    fi
    make install-target-libgcc
    if [ $? != 0 ]; then
        echo "Error installing libgcc"
        exit 1
    fi
    popd
 fi
 exit 0
@@ -1,91 +0,0 @@
 // vfs.c
 // Author: Josh Holtrop
 // Created: 12/31/03
 // Modified: 01/04/04
 void	vfs_init()
 {
 	firstDiskDevice = malloc(sizeof(DiskDevice));
 	firstDiskDevice->type = VFS_DISK_FD;
 	firstDiskDevice->fileSystem = VFS_FS_FAT12;
 	firstDiskDevice->location = VFS_LOC_FD0;
 	firstDiskDevice->link = 0;
 	strcpy(firstDiskDevice->id, "fd0");
 	rootDevice = firstDiskDevice;
 	if (*(byte *)0xC0090000)			// the user chose to load an initial ram disk from the floppy
 	{
 		DiskDevice *rd = malloc(sizeof(DiskDevice));
 		firstDiskDevice->link = (dword)rd;
 		rd->type = VFS_DISK_RD;
 		rd->fileSystem = VFS_FS_FAT12;
 		rd->location = 0xC0200000;
 		rd->link = 0;
 		strcpy(rd->id, "rd0");
 		rootDevice = rd;
 	}
 }
 byte *vfs_readFile(char *fileName)
 {
 	DiskDevice *dd;
 	dword	fileStartPosition;
 	if (fileName[0] == '/')
 	{
 		dd = rootDevice;
 		fileStartPosition = 1;
 	}
 	else
 	{
 		if (strlen(fileName) < 5)	//not a long enough file name
 			return 0;
 		if (!((fileName[3] == ':') && (fileName[4] == '/')))	//if we aren't using the root directory, then there must be a 3 character device explicitly specified
 			return 0;					// followed by a colon and then a slash
 		char device[4];
 		memcpy(device, fileName, 3);	//copy the 3 digit device id to device
 		device[3] = 0;			//null-terminating character for device string
 		dd = vfs_getDiskDeviceByID(device);
 		if (!dd)			//the specified device was not found
 			return 0;
 		fileStartPosition = 5;
 	}
 	switch (dd->fileSystem)
 	{
 	case VFS_FS_FAT12:
 		return fat12_readFile(fileName+fileStartPosition, dd);
 	}
 	return 0;
 }
 byte *vfs_readSector(DiskDevice *dd, dword sector, byte *dest, dword sectors)
 {
 	byte	*origDest = dest;
 	switch (dd->type)
 	{
 	case VFS_DISK_RD:
 		for (; sectors > 0; sectors--, dest += 512, sector++)
 			rd_readSector(dd, sector, dest);
 		return origDest;
 	}
 	return 0;
 }
 DiskDevice *vfs_getDiskDeviceByID(char *id)
 {
 	DiskDevice *dd = firstDiskDevice;
 	for (;;)
 	{
 		if (strcmp(dd->id, id))
 			return dd;
 		dd = (DiskDevice *)dd->link;
 		if (!dd)
 			break;
 	}
 	return 0;
 }
@@ -1,33 +0,0 @@
 // vfs.h
 // Author: Josh Holtrop
 // Created: 12/31/03
 // Modified: 01/04/04
 #define	VFS_DISK_RD	1
 #define	VFS_DISK_FD	2
 #define	VFS_DISK_HD	3
 #define	VFS_FS_FAT12	1
 #define	VFS_LOC_FD0	1
 typedef struct	{
 	dword	type;
 	dword	fileSystem;
 	dword	location;
 	dword	link;
 	char	id[4];
 } __attribute__((packed)) DiskDevice;
 void	vfs_init();
 byte *vfs_readFile(char *fileName);
 byte *vfs_readSector(DiskDevice *dd, dword sector, byte *dest, dword sectors);
 DiskDevice *vfs_getDiskDeviceByID(char *id);
 DiskDevice *rootDevice = 0;
 DiskDevice *firstDiskDevice = 0;
@@ -1,176 +0,0 @@
 //video.c
 // 08/13/03 Josh Holtrop
 // Modified: 11/12/03
 //Initialized the video mode information block video_mode and allocated double-buffer memory for graphics display
 void	video_init()
 {
 	videoMode = *(word *)0xC0090002;
        if (!videoMode)	//we are in console mode
 		return;
 	video_mode = *(ModeInfoBlock *) 0xC0090306;
 	switch(video_mode.BitsPerPixel)
 	{
 	case 16:
 		video_psetp = &video_psetp16;
 		break;
 	case 24:
 		video_psetp = &video_psetp24;
 		break;
 	case 32:
 		video_psetp = &video_psetp32;
 	}
 }
 //Renders a character using stdfont[] as a bitmask
 void	video_renderChar(int x, int y, int character, dword color)
 {
 	int charpos = (character & 0xFF) * 8;
 	int row;
 	int col;
 	for (row = 0; row < 8; row++)
 	{
 		for (col = 0; col < 5; col++)
 		{
 			if ((stdfont[charpos+row] >> (col+3)) & 0x01)
 				video_pset(x+(5-col), y+row, color);
 		}
 	}
 }
 //Draws a horizontal line
 void	video_horiz(int y, int x1, int x2, dword color)
 {
 	if (x1 > x2)
 	{
 		int tmp = x2;
 		x2 = x1;
 		x1 = tmp;		//x2 >= x1 now
 	}
 	if (x2 < 0)
 		return;
 	if (x1 > video_mode.XResolution)
 		return;
 	if (x1 < 0)
 		x1 = 0;
 	if (x2 > video_mode.XResolution)
 		x2 = video_mode.XResolution;
 	int pixel = y*video_mode.XResolution+x1;
 	for (; x1 <= x2; x1++)
 	{
 		video_psetp(pixel++, color);
 	}
 }
 //Draws a vertical line
 void	video_vert(int x, int y1, int y2, dword color)
 {
 	if (y1 > y2)
 	{
 		int tmp = y2;
 		y2 = y1;
 		y1 = tmp;		//y2 >= y1 now
 	}
 	if (y2 < 0)
 		return;
 	if (y1 > video_mode.YResolution)
 		return;
 	if (y1 < 0)
 		y1 = 0;
 	if (y2 > video_mode.YResolution)
 		y2 = video_mode.YResolution;
 	int pixel = y1*video_mode.XResolution+x;
 	for (; y1 <= y2; y1++)
 	{
 		video_psetp(pixel, color);
 		pixel+=video_mode.XResolution;
 	}
 }
 //Draws a rectangle
 void	video_rect(int x1, int y1, int x2, int y2, dword color)
 {
 	video_horiz(y1, x1, x2, color);
 	video_horiz(y2, x1, x2, color);
 	video_vert(x1, y1, y2, color);
 	video_vert(x2, y1, y2, color);
 }
 //Draws a filled rectangle
 void	video_rectf(int x1, int y1, int x2, int y2, dword color)
 {
 	if (y2 < y1)
 	{
 		int tmp = y2;
 		y2 = y1;
 		y1 = tmp;
 	}
 	for (; y1 <= y2; y1++)
 		video_horiz(y1, x1, x2, color);
 }
 //Draws a single pixel
 inline void video_pset(int x, int y, dword color)
 {
 	if ((x < 0) || (x > video_mode.XResolution) || (y < 0) || (y > video_mode.YResolution))
 		return;
 	video_psetp(y*video_mode.XResolution+x, color);
 }
 //Draws a pixel at the specified pixel position
 void	video_psetp16(int pixel, dword color)
 {
 	vid_ptr16[pixel] = ((color&0xFF)>>3) | ((((color>>8)&0xFF)>>2)<<5) | ((((color>>16)&0xFF)>>3)<<11);
 }
 //Draws a pixel at the specified pixel position
 void	video_psetp24(int pixel, dword color)
 {
 	vid_ptr24[pixel*3] = color & 0xFF;
 	vid_ptr24[pixel*3+1] = (color>>8) & 0xFF;
 	vid_ptr24[pixel*3+2] = (color>>16) & 0xFF;
 }
 //Draws a pixel at the specified pixel position
 void	video_psetp32(int pixel, dword color)
 {
 	vid_ptr32[pixel] = color;
 }
 //Dummy function to not draw anything if there is no graphical mode enabled
 void	video_psetpnull(int pixel, dword color) {}
 // This function draws a simple "console" window in graphical mode to display text
 void	video_drawConsole()
 {
 	video_rectf(9, 9, 490, 260, 0);
 	video_rect(8, 8, 491, 261, 0x00777777);
 	int x, y;
 	for (x = 0; x < 80; x++)
 	{
 		for (y = 0; y < 25; y++)
 		{
 			video_renderChar(x*6+10, y*10+10, console_memory[y*80+x], 0x00FFFFFF);
 		}
 	}
 }
 // This function draws a "console" character to the graphical video screen
 void	video_drawConsoleChar(dword position)
 {
 	int x = position % 80;
 	int y = position / 80;
 	video_renderChar(x*6+10, y*10+10, console_memory[y*80+x], 0x00FFFFFF);
 }
@@ -1,72 +0,0 @@
 //video.h
 // 08/18/03 Josh Holtrop
 // Modified: 12/28/03
 void	video_init();
 void	video_horiz(int y, int x1, int x2, dword color);
 void	video_vert(int x, int y1, int y2, dword color);
 void	video_rect(int x1, int y1, int x2, int y2, dword color);
 void	video_rectf(int x1, int y1, int x2, int y2, dword color);
 inline void video_pset(int x, int y, dword color);
 void	video_psetp16(int pixel, dword color);
 void	video_psetp24(int pixel, dword color);
 void	video_psetp32(int pixel, dword color);
 void	video_psetpnull(int pixel, dword color);
 void	video_renderChar(int x, int y, int character, dword color);
 void	video_drawConsole();
 void	video_drawConsoleChar(dword position);
 typedef struct{
 	word	ModeAttributes;
 	byte	WinAAttributes;
 	byte	WinBAttributes;
 	word	WinGranularity;
 	word	WinSize;
 	word	WinASegment;
 	word	WinBSegment;
 	dword	WinFuncPtr;
 	word	BytesPerScanLine;
 	word	XResolution;
 	word	YResolution;
 	byte	XCharSize;
 	byte	YCharSize;
 	byte	NumberOfPlanes;
 	byte	BitsPerPixel;
 	byte	NumberOfBanks;
 	byte	MemoryModel;
 	byte	BankSize;
 	byte	NumberOfImagePages;
 	byte	Reserved1;
 	byte	RedMaskSize;
 	byte	RedFieldPosition;
 	byte	GreenMaskSize;
 	byte	GreenFieldPosition;
 	byte	BlueMaskSize;
 	byte	BlueFieldPosition;
 	byte	RsvdMaskSize;
 	byte	RsvdFieldPosition;
 	byte	DirectColorModeInfo;
 	dword	PhysBasePtr;
 	dword	OffScreenMemOffset;
 	word	OffScreenMemSize;
 	byte	Reserved[206];
 } ModeInfoBlock;
 ModeInfoBlock	video_mode;
 dword	videoMode = 0;			//what video mode # we are in, 0 for console mode
 word	*vid_ptr16 = (word *)0xF0000000;
 byte	*vid_ptr24 = (byte *)0xF0000000;
 dword	*vid_ptr32 = (dword *)0xF0000000;
 word	console_memory[2000];		//holds a copy of the console's memory
 void (*video_psetp)(int, dword) = video_psetpnull;	//function pointer to set a pixel
@@ -1,354 +0,0 @@
 // vmm.c
 // Author: Josh Holtrop
 // Date: 09/30/03
 // Rewritten from scratch: 12/23/03
 // Modified: 12/30/03
 // This is the initialization procedure for the Virtual Memory Manager
 //  It sets up the final page directory/page table setup and maps video memory, if present
 void	vmm_init()
 {
 	dword *pageTables = (dword *)0xC0104000;	//this is the location of the page directory
 	pageTables[0x3FF] = 0x104000|0x03;		//the last page directory entry points to the page directory itself
 	pageTables[0] = 0;
 	invlpg(0);
 	if (videoMode)	//we are in a graphical mode
 	{
 		dword vidPages = video_mode.XResolution * video_mode.YResolution * (video_mode.BitsPerPixel >> 3);
 		if (vidPages % 4096)
 			vidPages = (vidPages >> 12) + 1;
 		else
 			vidPages = (vidPages >> 12);
 		vmm_mapn(0xF0000000, video_mode.PhysBasePtr, vidPages);
 	}
 	dword firstHeapEntryBlock = (dword)mm_palloc();
 	vmm_map1((dword)firstHeapEntry, firstHeapEntryBlock);
 	HeapEntryBlock *heb = (HeapEntryBlock *)firstHeapEntry;
 	vmm_heb_init(heb);
 	heb->entry[0].base = (dword)firstHeapEntry;	//start of kernel's heap memory
 	heb->entry[0].size = 4096;			//the first HeapEntryBlock is 1 page long
 	heb->entry[0].attributes = VMM_HE_HEB;		//this is a HeapEntryBlock
 	heb->entry[1].base = (dword)firstHeapEntry+4096;	//this is the start of the rest of the kernel's heap memory
 	heb->entry[1].size = 0x10000000-4096;		//the rest of the kernel's heap memory: 256mb - 4kb
 	heb->entry[1].attributes = VMM_HE_HOLE;		//this is a hold - an unmapped section of heap memory
 }
 // This function initialzes a Heap Entry Block to unused entries linked together
 void	vmm_heb_init(HeapEntryBlock *heb)
 {
 	int a;
 	for (a = 0; a < 256; a++)
 	{
 		heb->entry[a].base = 0;
 		heb->entry[a].size = 0;
 		heb->entry[a].attributes = VMM_HE_UNUSED;
 		heb->entry[a].link = (dword)&(heb->entry[a+1]);
 	}
 	heb->entry[255].link = 0;
 }
 // This function maps a virtual address to a physical address using the page directory / page table
 void	vmm_map1(dword virt, dword physical)
 {
 	dword pde = virt >> 22;
 	dword pte = (virt & 0x003FF000) >> 12;
 	dword *pageTables = (dword *)0xC0104000;	//this is the location of the page directory
 	if (!(pageTables[pde] & 0x01))		//the page directory entry does not exist, we must allocate a page for it
 	{
 		dword *newpagetable = mm_palloc();
 		pageTables[pde] = ((dword)newpagetable) | 0x03;
 		invlpg(virt);
 		dword *newpteptr = (dword *)(0xFFC00000 | (pde << 12));	//points to first dword of newly allocated page table
 		int a;
 		for (a = 0; a < 1024; a++)
 		{
 			newpteptr[a] = 0;
 		}
 	}
 	dword *pteptr = (dword *)(0xFFC00000 | (pde << 12) | (pte << 2));
 	*pteptr = physical | 0x03;
 	invlpg(virt);
 }
 // This function maps a variable number of pages in a row
 void	vmm_mapn(dword virt, dword physical, dword n)
 {
 	for (; n > 0; n--)
 	{
 		vmm_map1(virt, physical);
 		virt += 4096;
 		physical += 4096;
 	}
 }
 // This function removes the virtual address's entry in the page directory / page table
 void	vmm_unmap1(dword virt)
 {
 	dword *pteptr = (dword *)(0xFFC00000 | ((virt & 0xFFC00000) >> 10) | ((virt & 0x003FF000) >> 10));
 	*pteptr = 0;
 	invlpg(virt);
 }
 // This function removes multiple pages' entries
 void	vmm_unmapn(dword virt, dword n)
 {
 	for (; n > 0; n--)
 	{
 		vmm_unmap1(virt);
 		virt += 4096;
 	}
 }
 // Virtual Memory allocator function
 void	*malloc(dword bytes)
 {
 	if (bytes % VMM_MALLOC_GRANULARITY)
 		bytes = bytes + VMM_MALLOC_GRANULARITY - (bytes % VMM_MALLOC_GRANULARITY);
 	void *attempt = vmm_getFreeChunk(bytes);
 	if (attempt)
 		return attempt;
 	if(vmm_moreCore(bytes))
 		return 0;			//we could not get any more heap memory
 	return vmm_getFreeChunk(bytes);
 }
 // This function returns a pointer if a free chunk of memory exists
 void	*vmm_getFreeChunk(dword bytes)
 {
 	HeapEntry *he = firstHeapEntry;
 	for (;;)
 	{
 		if (he->attributes == VMM_HE_FREE)
 		{
 			if (he->size > bytes)
 			{
 				HeapEntry *nhe = vmm_nextHeapEntry();
 				nhe->base = he->base;
 				nhe->size = bytes;
 				nhe->attributes = VMM_HE_USED;
 				he->base += bytes;
 				he->size -= bytes;
 				return (void *)(nhe->base);
 			}
 			if (he->size == bytes)
 			{
 				he->attributes = VMM_HE_USED;
 				return (void *)(he->base);
 			}
 		}
 		he = (HeapEntry *)he->link;
 		if (!he)
 			break;
 	}
 	return 0;
 }
 // This function coalesces any two adjacent heap entries into one entry
 void	vmm_coalesceHeapEntry(HeapEntry *he)
 {
 	if (!(he->attributes == VMM_HE_FREE || he->attributes == VMM_HE_HOLE))
 		return;
 	if (he->size == 0)
 	{
 		he->attributes = VMM_HE_UNUSED;
 		return;
 	}
 	HeapEntry *hec = firstHeapEntry;
 	for (;;)
 	{
 		if (hec->attributes == he->attributes)
 		{
 			if ((hec->base + hec->size) == he->base)	//hec ends where he begins
 			{
 				he->base = hec->base;
 				he->size += hec->size;
 				hec->attributes = VMM_HE_UNUSED;
 			}
 			if ((he->base + he->size) == hec->base)		//he ends where hec begins
 			{
 				he->size += hec->size;
 				hec->attributes = VMM_HE_UNUSED;
 			}
 		}
 		hec = (HeapEntry *)hec->link;
 		if (!hec)
 			break;
 	}
 }
 // This function retrieves more physical memory for the heap
 int	vmm_moreCore(dword bytes)
 {
 	dword pages = (bytes >> 12) + 1;
 	bytes = pages << 12;
 	HeapEntry *he = vmm_getFirstHoleHeapEntry(bytes);
 	dword virt = he->base;
 	for (; pages > 0; pages--)
 	{
 		dword phys = (dword)mm_palloc();
 		if (!phys)
 			return 1;
 		vmm_map1(virt, phys);
 		virt += 4096;
 	}
 	if (he->size == bytes)
 	{
 		he->attributes = VMM_HE_FREE;
 		vmm_coalesceHeapEntry(he);
 	}
 	else
 	{
 		HeapEntry *nhe = vmm_nextHeapEntry();
 		nhe->base = he->base;
 		nhe->size = bytes;
 		nhe->attributes = VMM_HE_FREE;
 		he->base += bytes;
 		he->size -= bytes;
 		vmm_coalesceHeapEntry(nhe);
 	}
 	return 0;
 }
 // This function returns the next available heap entry, creates more entries if we are running low
 HeapEntry *vmm_nextHeapEntry()
 {
 	if (vmm_heapEntriesLeft() < 10)
 		vmm_addHeapEntryBlock();
 	return vmm_getFirstUnusedHeapEntry();
 }
 // This function creates a new block (page) of heap entries (256)
 void	vmm_addHeapEntryBlock()
 {
 	HeapEntry *he = vmm_getFirstHoleHeapEntry(4096);
 	HeapEntry *newBlock = vmm_getFirstUnusedHeapEntry();
 	dword heb = (dword)mm_palloc();
 	vmm_map1(he->base, heb);
 	vmm_heb_init((HeapEntryBlock *)he->base);
 	HeapEntry *lhe = vmm_getLastHeapEntry();
 	if (he->size == 4096)
 	{
 		he->attributes = VMM_HE_HEB;
 		lhe->link = (dword)he->base;
 	}
 	else
 	{
 		newBlock->base = he->base;
 		newBlock->size = 4096;
 		newBlock->attributes = VMM_HE_HEB;
 		he->base += 4096;
 		he->size -= 4096;
 		lhe->link = (dword)newBlock->base;
 	}
 	return;
 }
 // This function returns the last heap entry in the linked list, useful for setting
 //  its link field to point to the first entry of a newly allocated list
 HeapEntry *vmm_getLastHeapEntry()
 {
 	HeapEntry *he = firstHeapEntry;
 	for (;;)
 	{
 		if (he->link == 0)
 			return he;
 		he = (HeapEntry *)he->link;
 	}
 }
 // This function returns the first heap entry corresponding to a memory "hole"
 HeapEntry *vmm_getFirstHoleHeapEntry(dword minBytes)
 {
 	HeapEntry *he = firstHeapEntry;
 	for (;;)
 	{
 		if ((he->attributes == VMM_HE_HOLE) && (he->size >= minBytes))
 			return he;
 		he = (HeapEntry *)he->link;
 		if (!he)
 			break;
 	}
 	return 0;
 }
 // This function returns the first heap entry that is not being used
 HeapEntry *vmm_getFirstUnusedHeapEntry()
 {
 	HeapEntry *he = firstHeapEntry;
 	for (;;)
 	{
 		if (he->attributes == VMM_HE_UNUSED)
 			return he;
 		he = (HeapEntry *)he->link;
 		if (!he)
 			break;
 	}
 	return 0;
 }
 // This function returns the number of heap entries available for use
 dword	vmm_heapEntriesLeft()
 {
 	HeapEntry *he = firstHeapEntry;
 	dword entries = 0;
 	for (;;)
 	{
 		if (he->attributes == VMM_HE_UNUSED)
 			entries++;
 		he = (HeapEntry *)he->link;
 		if (!he)
 			break;
 	}
 	return entries;
 }
 // This function "frees" an area of memory previously allocated with malloc()
 int	free(void *ptr)
 {
 	HeapEntry *he = vmm_getHeapEntryByBase((dword)ptr);
 	if (!he)
 		return 1;	//a heap entry starting at the given address was not found
 	he->attributes = VMM_HE_FREE;
 	vmm_coalesceHeapEntry(he);
 	return 0;
 }
 // This function scans the heap entry linked list for an entry that begins at the given address
 HeapEntry *vmm_getHeapEntryByBase(dword base)
 {
 	HeapEntry *he = firstHeapEntry;
 	for (;;)
 	{
 		if (he->base == base)
 			return he;
 		he = (HeapEntry *)he->link;
 		if (!he)
 			break;
 	}
 	return 0;
 }
@@ -1,55 +0,0 @@
 // vmm.h
 // Author: Josh Holtrop
 // Date: 09/30/03
 // Rewritten from scratch: 12/23/03
 // Modified: 12/30/03
 #define	VMM_HE_UNUSED	0		//available entry
 #define	VMM_HE_FREE	1		//free section of memory
 #define	VMM_HE_USED	2		//used section of memory
 #define	VMM_HE_HOLE	3		//a "hole" (unmapped) section of virtual memory
 #define	VMM_HE_HEB	4		//HeapEntryBlock
 #define	VMM_MALLOC_GRANULARITY	4	//granularity for all memory requests
 typedef struct {
 	dword	base;			//virtual base address
 	dword	size;			//size in bytes
 	dword	attributes;		//free/used/hole
 	dword	link;			//link to next HeapEntry
 } __attribute__((packed)) HeapEntry;
 typedef struct {
 	HeapEntry	entry[256];	//256 HeapEntry objects = 4kb (1 page)
 } __attribute__((packed)) HeapEntryBlock;
 void	vmm_init();
 void   *malloc(dword bytes);
 int	free(void *ptr);
 void	vmm_map1(dword virt, dword physical);
 void	vmm_mapn(dword virt, dword physical, dword n);
 void	vmm_unmap1(dword virt);
 void	vmm_unmapn(dword virt, dword n);
 void	vmm_heb_init(HeapEntryBlock *heb);
 void	*vmm_getFreeChunk(dword bytes);
 HeapEntry *vmm_nextHeapEntry();
 dword	vmm_heapEntriesLeft();
 HeapEntry *vmm_getLastHeapEntry();
 HeapEntry *vmm_getFirstUnusedHeapEntry();
 HeapEntry *vmm_getFirstHoleHeapEntry(dword minBytes);
 void	vmm_addHeapEntryBlock();
 int	vmm_moreCore(dword bytes);
 void	vmm_coalesceHeapEntry(HeapEntry *he);
 HeapEntry *vmm_getHeapEntryByBase(dword base);
 HeapEntry *firstHeapEntry = (HeapEntry *)0xD0000000;	//this is where heap memory starts
		`@@ -1,2 +0,0 @@`
			`nasmw -f aout -o ks.o -l .\lst\kernel.lst kernel.asm`
		`@@ -1 +0,0 @@`
			`gcc -ffreestanding -fno-builtin -nostdlib -nodefaultlibs -c kernel.c -o kernel.o`
		`@@ -1 +0,0 @@`
			`nasmw -f aout -o asmfuncs.o -l .\lst\asmfuncs.lst asmfuncs.asm`
		`@@ -1,2 +0,0 @@`
			`rem rawrite -f stage1.bin -d a -n`
			`partcopy stage1.bin 0 200 -f0`
		`@@ -1 +0,0 @@`
			`nasmw -f bin -o stage1.bin -l .\lst\stage1.lst stage1.asm`
		`@@ -1 +0,0 @@`
			`nasmw -f bin -o stage2.bin -l .\lst\stage2.lst stage2.asm`
		`@@ -1 +0,0 @@`
			`ld -nodefaultlibs -nostdlib -T link.ld -o kernel.bin -Map .\lst\LDout.doc ks.o kernel.o asmfuncs.o`