Initial Import
Added printk functionality with almost complete printf style inputs (no double/float yet).
Added GDT setup code
Starting to add IDT code
Added basic memcpy and memset implementation
Set start.s as the "startup" file in the linker script
Fixed some small typos/errors in initial_printk
Added Scrolling to initial_printk
Finished basic Interrupt Service Routine code. You can now catch interrupts 0-32 (errors, traps, faults, etc...)

I also added a feature to initial_printk where %#V will set the output level to # where 0 is white on black
text, 1 is blue on black and 2 is red on black.
Fixed the output to be a little nicer.
Added IRQ setup code, and a interrupt callback registeration method.
Added a C interface into the CPUID instruction, and displayed the
	vendor string at boot time.
Finished IRQ setup and initialization
Added a PIT driver, including a timer callback functionality in which
	you can register callbacks for certain times.
Added some miscellanious functions like disablei, and restore which
	are used to disable interrupts and re-enable them when the
	current state of the interrupt flag is unknown.
Fixed the scroll_screen function for initial_printk in regards to issue 2.
Fixed an odd parameter misordering in the memset function.
Added paging initialization code.
Added an initial (placement) version of kmalloc and friends
Added a basic bitmap based physical memory manager
Fixed the ISR handler, so that you can register ISR callbacks,
	as well as IRQ callbacks.
Started implementation of a kernel heap allocator.
Commiting now in order to begin work putting the kernel in the higher half. I feel this is more important
	than the heap allocator as it will get harder and harder to change as time goes on.
Moved kernel to higher half address 0xC0000000.
Fixed symbol output format so GDB stopped outputting "can't compute CFA address for this frame."

This took a lot of work. I tried to follow a tutorial on OSDev, but it didn't work,
so there is now a seperate section called .init.text and .init.data which are linked
and loaded at physical address 0x00100000 while the rest of the kernel is linked at
0xC0100000 and loaded at 0x00100000.
Finalized the kmalloc/kfree implementation, and initialized it at 0xE0000000-0xF0000000.
Added a linked list implementation similar to that of the linux list.h (although all original code)
Added a fix_vhd make target in order to fix an odd error that pops up from make install every once in a while
Edited various source files to remove annoying warnings (in other words be standards compliant :P)
Intermediate commit. I am currently working on implementing the filesystem code
I have completed a large chunk including an initial mount/umount functions, some
inode allocation code and dentry allocation, and also the basic structures for
filesystems structures and driver structures. Most functions have yet to be
written, yet what is written so far compiles.
Finished up the bulk of the virtual file system code.
There is a test for a simple filesystem, and we are able to mount and lookup
a directory entry.

Further VFS implementation needs things like processes to store the file table
so I am going to move on to multitasking implementation now.
This is a big revision. The main work was put in to get multitasking up and running, but small modifications were made
throughout the kernel. Including, a new debug_message function which will output only when KERNEL_DEBUGGING is defined
and will give file, line, and function information along with a formatted message, all in blue. Also, the filesystem
code was improved, and, the big one, tasking was added. Forking and exiting are currently implemented with a basic
round-robin task selection and VERY basic preemption (needs a lot of work).

Along with tasking, came the copying and more use of page directories. Currently, after tasking we no longer directly
use kerndir, but instead use the tasks directory (which has all kernel tables linked into it), and a kernel stack at
0xFFFFE000 (or more correctly at TASK_KSTACK_ADDR). There is also a temporary page mapping function called
temporary_map which will map a page from one directory into the current directory at 0xFFFFF000. This is useful for
cross task copying.

Few, I think that's it. Long time no see, Subversion.
This commit marks the first well working multitasking version.
I have a working waitpid implementation, and fork seems to be
working well. This commit changed a lot of memory management
which had a lot bugs including implementing the heap_expand
functionality, and I realized I was accidently linking to
the C library I ported recently, and stopped that.
This revision has some new block device code, although it is not fully functional.
I'm in the middle of writing it, but I took a side track into writing a simple
spinlock implementation, therefore I decided to make a quick commit here in the
middle.
This version has a lot of additions/fixes. It's been a while since I had the time to work on the kernel. Heres the things I remember doing (mainly
things that heppend recently).

* Fixed the paging initialization. It wasn't protected the loaded modules.
* Added the beginnings of an executable loader capable of loading different executable types.
* Added basically everything needed for module loading. Things that are completed:
	- Understand the ELF Relocatable format
	- Correctly Relocate object files
	- Resolve symbols local to the object file (including COMMON symbols)
	- Extract the module_t structure from a custom .module_info section
 Some things that still need done:
	- Create the system to keep track of loaded modules (including insmod/rmmod type functions)
	- Load kernel symbols and link undefined module symbols to kernel functions/variables for
		full integration.
* Added a block device interface for the file system.
* While you can't see it in this repository, I've made significant improvements on the custom toolchain
	I fixed some problems which allowed me to correctly compile newlib without libgloss, therefore
	I was able to provide my own custom sys/ header files (which are needed to compile the kernel
	correclty).
Finished the module interface. I also removed the stew_shell project and replaced it with the test_mod as a test module and a template module.
This commit adds a much better module creation interface with integrated Makefiles. See the
module_template under the modules directory and the Makefile under the modules directory.
for more information. It's really simple and will automatically recompile when the kernel is
updated. Also, I've tested the kernel on real hardware again (my little Atom D525) and it
worked well (with some small bug fixes). 

With the new module interface, I have started on an IDE driver module, and with that I have
implemented PCI enumeration and PCI bus searching. Currently, the IDE module simply searches
and finds the IDE controller on the PCI bus (based on PCI class/subclass pair). More to come.
Haha
This commit adds a lot of functionality. The ATA Driver has been moved into the
kernel itself and out of an external module. It is a fully working block driver
now. I have also added a sprintf function (found a small implementation online).

Lastly, and most amazingly, I have written a small, fairly crude, read only ext2
driver that is actually fully working at the moment. I am able to traverse
directories and read files. It also handles device files correctly. This is a
huge step toward a working system.