gdb: Simpler way to load xv6-gdb.py
gdb: $percpu helper function for accessing static percpu variables
gdb: Fix bug in $percpu

Previously this was casting to raw pointer value to the variable's
type, rather than to a pointer to the variable's type.  This happened
to work for cpus on CPU 0 for convoluted reasons.
gdb: Improved interface to $percpu

Now it can handle things like percpus declared in namespaces.
gdb: Pretty-printer for ilists and islists
gdb: Pretty-printer for our std::vector
lib: Add support for deleters to unique_ptr
kcpprt: Print exception.what() on uncaught exceptions
seqcount: Disable copy/move
seqcount: Record holder when SEQLOCK_DEBUG
filetable: Disable copy/move
memlayout: Remove some unused constants
vmalloc: Implement virtual allocator with guard pages
hwvm: Fix safe_read_hw for 4K pages

Previously safe_read_hw was only called for kernel addresses and all
kernel memory was mapped with large pages.  With vmalloc, there are
now 4K page mappings in the kernel portion of the address space and
safe_read_hw's handling of these was broken.
Replace slab_stack with direct kalloc calls
proc: Add KSTACK_DEBUG, which protects against stack under/overflow

When enabled, the kernel uses vmalloc instead of kalloc to allocate
kernel stacks, which surrounds them with guard pages.  Right now, the
machine will double/triple fault if there is a stack under/overflow,
but at least QEMU can point to the culprit.
trap: Call kerneltrap on double faults

Without this, double faults generally become triple faults and both
QEMU and real hardware then silently reboot.  With this, we can
generally get the kernel state when something goes Really Really
Wrong.  For example, this will trigger on kernel stack over/underflow
with KSTACK_DEBUG.
console: Detect and warn on stack overflow in kerneltrap
tools: Report large stack users on kernel build
param: Increase kernel stack size to 32K

Because 32K should be enough for anyone.  We do have several large
stack users; mostly those that keep disk blocks on the stack (which is
probably bad).  The worst of these requires about 16K of stack.