This gets the call PCs instead of the return PCs, since this turns out
to be what we really want everywhere we use this.  This was
particularly annoying for panics: since the compiler knows that panic
doesn't return, when it's the last thing in the function, the compiler
doesn't emit any further code after the call, which means the "return"
PC either doesn't map to anything or maps to another function
entirely.

Apparently we wound up with two equivalent functions for getting the
current CPU's id.  Switch to just myid since that was more common and
is implemented as a static inline instead of an extern.

I got confused by our crazy for-loop retry idiom.

I'm sure it fails for some other naming format..

An xns must fit in a page, but that doesn't allow enough buckets
to avoid physical sharing in dirbench.  This is basically a
work-around for the one page limit.

I'll be changing the dirns implementation soon.

..next step is a namex that takes no refs.

Split the inode space into per-cpu spaces of size IPB that start at
the begining of a block.  Block awareness is important to avoid
contention on blocks themselves when allocating or freeing an inode
and updating on-disk structures.  That is, I don't want to make bio
scalable.

The only unexpected sharing is on the VMA refcount, which is
exactly what we expected.

This eliminates a bunch of confusing scopes that come from thread creation

With the mtrace QEMU, which now switches VCPUs when there's a PAUSE,
this speeds up my lame test (usertests vmoverlap) by a factor of 7 and
certainly makes xv6 feel much faster.

So we can hush up spurious errors.

The user errors stream is disabled by default.

These have the type-safety and extensibility of ostreams, but the
simplicity and almost the terseness of printf.

This might be a mistake because we can't control the order of global
construction, but we already have several global constructors that
were simply not being called before.  As long as we keep all global
constructors simple, this should be okay.

This fixes the deadlock where a thread tries to allocate an inode,
and calls ilock, while another thread is simultaneously freeing
the same inode.