The only locking is "point-to-point" between condvar sleep in one proc
and condvar wakeup in another.

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.