Make sure proc structures are aligned to 16 byte boundaries.  This
ensures that the lower 4 bits of a proc's address are zero.  Forthcoming
new locking primitives rely on this.
First cut implementation of turnstiles, a specialized sleep queue used for
kernel synchronization objects.  A detailed description of turnstiles
can be found in:

	Solaris Internals: Core Kernel Architecture, by Jim Mauro
	   and Richard McDougall, section 3.7.

Note this implementation does not yet implement priority inheritence,
nor does it currently differentiate between reader and writer queues
(though they are provided for in the API).
TURNSTILE_CHAIN_UNLOCK(): Don't reference tc_oldspl after releasing
tc_lock.  From Bill Sommerfeld.
Some suggestions from Bill Sommerfeld:
* Use a pool cache for turnstiles, so you can save the memset().  Add
  some asserts to make sure that inactive turnstiles end up in their
  freshly-constructed state.
* Invalidate p->p_ts before returning p to the proc pool (only done if
  DIAGNOSTIC).
* Fix up some comments in kern_turnstile.c
* Bugfix in turnstile_remque(): typo ("==" should have been "=").
Adjustments for new mutex routines:
* Make all the IPL_* constants meaningful within a single number domain.
* Use new SI_* constants to number the soft interrupt queues, rather than
  IPL_SOFT*.
* Add splraiseipl() for use by kern_mutex.c.  Usage is e.g.
  splraiseipl(IPL_BIO).
Pass a "pri" argument to turnstile_block(), like we do to ltsleep().
This allows the caller of turnstile_block() to decide what to do about
priority and PCATCH (though we still don't handle PCATCH in turnstiles).
Use a pool cache for turnstiles, saving the memset (missed this in
previous commit).
New kernel mutex implementation, modeled after those found in Solaris
and described in:

	Solaris Internals: Core Kernel Architecture, Jim Mauro and
	    Richard McDougall, section 3.5.

Both adaptive (spin/sleep) and spin (spin + block interrupts) mutexes
are implemented.  See <sys/mutex.h> for the support that machine-dependent
code must supply.
Alpha support routines for kernel mutexes.
Install mutex_impl.h
Split the "simplelock" stuff out of lock.h into simplelock.h.  The
new __cpu_simple_lock_t basic atomic primitive is still useful, even
with the new mutex implementation.

In mutex.h, use simplelock.h rather than lock.h.
Install mutex.h and simplelock.h
Use <sys/simplelock.h> rather than <sys/lock.h>.
Fix two bugs pointed out by Bill Sommerfeld:
* MUTEX_RELEASE(): memory barrier goes *before* lock release.
* Fix race condition between mutex_exit() and MUTEX_SET_WAITERS().
Implement mutex_owner().
mutex_exit(): memory barrier *before* clearing the lock.
Document a critical section in mutex_exit().  From the comment:

THIS IS IMPORTANT WHEN WE ADD SUPPORT FOR KERNEL PREEMPTION.

There is a critical section within mutex_exit(); if we are
preempted, between checking for waiters and releasing the
lock, then we must check for waiters again.

On some architectures, we could simply disable interrupts
(and, thus, preemption) for the short duration of this
critical section.

On others, where disabling interrupts might be too expensive,
a restartable sequence could be used; in the interrupt handler,
if the PC is within the critical section, then then PC should
be reset to the beginning of the critical section so that the
sequence will be restarted when we are resumed.  NOTE: In this
case, it is very important that the insn that actually clears
the lock must NEVER be executed twice.

On the Alpha, it'd be nice to be able to use load-locked/store-conditional,
but since we're storing zero, that breaks the store-conditional logic.  On
the alpha, we'll use the restartable sequence method.
Convert sysctl_memlock to an adaptive mutex.
Make syncer_lock an adaptive mutex and rename it to syncer_mutex.
Make acct_lock an adaptive mutex and rename it to acct_mutex.