half-broken implementation of syscall/sysret; exec seems to work
fine with syscall/sysret now.

A change in any kernel source may change the syscall definitions, so
those need to be regenerated, but previously this would cause
everything else to be likewise regenerated.  Avoid this by only
updating the generated file if its contents actually change.

This also makes these rules better behaved when there are errors,
since previously they would leave partially-generated files that would
confuse the next make run.

These are no longer necessary because of how we generate the syscall
vector array and removing them discourages calling syscall entry
points from inside the kernel.

Avoid calling sys_halt from inside the kernel.

Now the only thing you need to do to create a new syscall is write the
kernel function and put "//SYSCALL" immediately before it.

There are only two places we depended on these #defines: forkt and
initcode.  We now declare symbolic constants for the syscall numbers
in sysstubs, which makes forkt just work (though it gets filled in at
link time instead of by the preprocessor).  For initcode, we now link
initcode against sysstubs so it can get these constants.

Any instances of userptr<T> in the kernel syscall prototypes are
translated to regular pointers for the user space prototypes.  Also,
this requires marking sys_exit's magic syscall comment with a new flag
to indicate it does not return.

This requires adding flags to the magic syscall comment so that we can
mark sys_exec as using INT instead of SYSCALL for entry.

This uses the special comments marking syscalls to find syscall entry
points and their prototypes.  For now, it also parses
include/syscall.h to get syscall numbers.

Previously these were type-less uptrs.

These are compatible with regular pointers, but can't be dereferenced
without checks.

We don't need these symbols in C code now.

This requires them to be in order, since we can't use C99
initializers, but we're going to autogenerate this list shortly
anyway.  The main advantage is that this lets us use C++ types for
arguments.

Except for the pointer argument to sys_exec, which is an opaque uptr
in the kernel.

Except for the pointer arguments to sys_map and sys_unmap, which are
opaque uptr's in the kernel.

hopefully this fixes the filetable 0x..08 corruption bug

Most of this is propagating the const-ness through the myriad write
functions.

Since the underlying kmem allocator uses the first sizeof(struct run)
bytes as metadata for freed runs, the zero pages put into the zero
page allocator's kmem were coming back with the first few bytes
non-zero.  Fix this by explicitly zero'ing the run header of pages
retrieved from kmem.

usertests now passes the bss test.  It still fails twofiles and
forktest.

Maybe we want vmnode to just take a byte size...

Previously, we mapped it as one node that spanned all of the pages,
but had a smaller size.  This causes a panic when we fault on pages
beyond the size because vmnode::loadpg calls readi with a too-large
offset.  We could "fix" loadpg, but what we have now is actually
POSIX-ish behavior (which says faults beyond the end of the mapped
object should signal SIGBUS), so instead we fix the ELF loader to
create two vmnodes in this situation.

This gets usertests running again for me (it now fails at the BSS
test, but at least it starts).