Otherwise they'll bounce on reference counts.

descend will still break. Also we don't create them yet. But descend
probably needs to change.

Still assuming that the leaf is at level 0, but we're getting there.

When large chunks of tree get RCU-freed, we'll detach them and only
gc_delayed() the root.

Need a silly radix_ptr to deal with our std::atomic not accepting
(integer-sized) object types. We're also not using entry_dead anywhere.

Also results in way more code since we don't have markptr's convenience
methods anymore. Appropriate methods will be added when the full locking
scheme is implemented.

Possibly this just wants to live in the radix_node destructor. Right now
we need level information, but we can stick that in without increasing
the malloc size, and we'll have a bit to use instead later.

Not actually doing anything with RCU yet, but we will at some point.

Gives us room to make radix_node rcu_freed.

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.