exit(): _Noreturn
Use linux vsnprintf for libc printf
Integrate kerboard driver into console driver

The keyboard driver was already interacting with the console driver;
this makes the connection explicit.

Ideally, a console would be represented as a virtual device on top of
separate keyboard and (text-mode) VGA drivers.  Current control-flow
limitations in Telos make this difficult, however.  So the console
driver drives both the physical keyboard and VGA interface.

The keyboard part of the driver buffers up to 512 characters.
Characters are delivered only after the buffer is full, a newline is
read, or EOF is reached.  The backspace character is understood by the
driver, so the backspace handling code is removed from tsh.
libc: putc()
Prevent overwriting multiboot modules, mmap, etc.

The kernel heap starts after any multiboot modules, ELF section headers,
and the BIOS memory map.  This assumes the bootloader put these in sane
positions, which QEMU/GRUB at least seem to do.

This replaces the code which copied multiboot stuff into predefined
kernel memory locations.  After mem_init(), it should be possible to use
the addresses in the multiboot_info structure, which are translated into
kernel (virtual) addresses.
rules.mk: rule for .s (assembly) files
Remove unused paging functions

Preparation for major overhaul... maybe.
paging.c: use inline functions instead of macros
kmap_tmp_*/kunmap_*: use virtual addresses

These functions were looking through page tables from physical
addresses.  This worked because the bottom end of memory is still
identity-mapped in the kernel.

Also, a system is set up for getting quick, ephemeral mappings.  These
mappings do not have to be unmapped.  Currently 4 such mappings are
possible at a time.  See: kmap_tmp_page_n().
Use process page directories in kernel

Since the kernel is mapped in all page directories, there is no need for
a separate kernel directory after init.
Programmatically determine kernel heap size

The kernel heap ends at the first 4MB aligned address, such that there
is at least 1MB of memory in the heap.
k[z]alloc_page() -> k[z]alloc_frame()

These functions retun unmapped page frames, which are referred to as
frames in Telos.  "Page" refers to a page frame mapping.  So a function
called kalloc_page() should return a page-sized chunk of (virtual)
memory, not a pf_info struct.
kernel/mem.h: miscellaneous improvements
Initial kernel virtual memory management code

The function kalloc_pages(uint n) allocates and returns a pointer to n
pages of memory.  kfree_pages(void *addr, uint n) frees memory allocated
with kalloc_pages().
Slab allocator

"Slab" memory allocator with same basic design as in Linux, etc..  At
the cache level, slabs are stored in linked lists.  At the slab level,
objects are managed by a bitmap.

Also included in this commit is a generic bitmap implementation with
some common operations (set, clear, ffz, ffs) for bitmaps of arbitrary
length.
EXPORT & kernel init system

The EXPORT macro exports a pointer to an object to a given section at
link time.

The EXPORT_KINIT macro uses EXPORT to automagically collect kernel
initialization functions into array, so that initialization can be
accomplished by a dump loop.
Split <kernel/mem.h> into <kernel/mm/*>

Also <kernel/mmap.h>, which has the memory map of the kernel.  "mm"
stands for memory management, and contains kmalloc.h, slab.h and
paging.h.
ktimer and POSIX timer changes

ktimers are no longer reference counted.  ktimer memory can be managed
manually if the TF_STATIC flag is passed to ktimer_init().

ktimer and posix_timer structures are now allocated from the slab layer.

address_space_init() now maps all kernel memory in user address spaces.
Previously only the first 4MB were mapped, so the memory returned by
kalloc_pages() would not be mapped for all processes.
Map process page directory to last page

Process page directories are mapped to the last page in their address
spaces (0xFFFFF000).  This isn't yet used for anything, but should make
stuff like mmap() and copy-on-write easier.
Per-process tmp_pgtab at 0xFFFFE000

The page table mapping the top 4MB of virtual memory is used for
temporary mappings, as well to map the page directory.  tmp_pgtab is
made to be a per-process page table via a self-referential mapping at
0xFFFFE000.  The old, statically allocated tmp_pgtab is renamed
_tmp_pgtab and mapped similarly in kernel_pgdir, so that temporary
mappings can still be obtained during boot.