Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly

kernel - More tty/pty fixes

* Notify the pty master when the slave closes.

* Fix the zombie state stuff.  Clear the zombie state on initial open of
  either side, prior to running any modem controls.

* This appears to fix screen and tmux.

Reported-by: YONETANI Tomokazu <qhwt+dfly@les.ath.cx>, Antonio Huete Jimenez <tuxillo@crater.dragonflybsd.org>

include - Install smbus headers in the system.

This will fix gkrellm build as it was trying to
include smb.h, which wasn't in /usr/include/machine
anymore.

In-collaboration-with: <swildner@>

truss - Take care of a couple segfaults.

Reported-by: Johannes Hofmann <Johannes.Hofmann@gmx.de>
DragonFly-bug: <http://bugs.dragonflybsd.org/issue1610>

dloader - Fix *_load variable override issue

* Setting a local variable that is already set wasn't working
  due to a programming snafu, so *_load overrides in /boot/loader.conf
  were not working properly.  Fixed!

kernel - Fix multiple tty_token issues related to vt switching and X

* Numerous places where gettoken/reltoken was not matched up

* Of particular note the multi-line macros in fbreg.h did not have
  any do/while() protection and were being used in if() macro()
  situations which caused massive issues.

Reported-by: Everyone

build - Fix kernel / modules install from object dir or module source dir

* Only installkernel from /usr/src was installing the modules in the
  right place.

* Add a default KERNEL?= in kmod.mk to try to correct the problem.

Reported-by: YONETANI Tomokazu <qhwt+dfly@les.ath.cx>

vkernel - Fix early boot seg-fault

* kprintf() needs 'mycpu' to work now, the vkernel was trying to use it
  too early.

Reported-by: Ilya Dryomov

Remove formatted spinlock manpages via 'make upgrade', too.

boot system and buildkernel - Additional work

* Make boot <directory> work.  Note however that dloader does not preload
  the kernel+modules so basically all you get here is the kernel and acpi
  with the current menu system setup.

  The dloader way (for the moment) is:

cd kernel
loadall
boot

* Fix console=<blah>.  dloader was not mirroring the variable to the
  environment.  Also do the same for currdev, loaddev, and bootfile.
  (kernelname and module_path were already mirrored).

* Fix non-numeric menus.  'a' (kernel.alt), 'b' (kernel.bak),
  and 'R' (reboot).

* Space now halts the countdown.

* Add the boot-without ACPI option back into dloader.menu.

* Move the handling of the kernelname kenv variable out of machine
  specific code and into kern/init_main.c

kernel - Fix token mismatch in tty code.

* Fix issue when a tty is stopped/started with ^S/^Q related to
  recent tokenization work.

build - Adjust kern.post.mk warning

* installkernel was blowing away the modules before warning that the
  boot was out of date.  Warn before blowing away anything (and
  abort the installkernel).

build - cleanup

* These files were renamed, remove the originals.

boot system and buildkernel - Remove the thrice damned forth interpreter

* Remove the forth interpreter from the build.  The last straw was when
  I tried to fix the module path and 6 hours later still couldn't get
  it right.

* Write a C based menu system and loader, replacing what the forth code
  used to do.  This is about 85% complete (tftp and boot chaining issues
  are not handled).  This took exactly one day to do, by the way.

* Reformulate installkernel to now create a directory /boot/kernel.blah
  and place the kernel and modules inside that directory.

syscons - more token-related fixes

* Make init_scp explicitly acquiring a token for what it needs.

* Also acquire token for vidsw operation in scinit.

Reported-by: Rumko
Dragonfly-bug: http://bugs.dragonflybsd.org/issue1814

iwi(4): Oops. These changes weren't meant to be committed (yet).

wpi(4): sc is no longer used for locking (fixes LINT).

syscons - sc_set_pixel_mode() returned without releasing tty_token

fixes panic on `vidcontrol MODE_nnn'

kernel - Fixup vkernel64 for build

* Add missing declaration.

kernel - Fixup for UP build

* Conditionalize td_mpcount accesses for SMP only

kernel - Add a workaround for tty_token during low-level boot

* The low level cninit() code dives into dev/video and does a ton
  of tty_token acquisitions and releases, and even after the bug
  fixes there is still something weird going on in there.

  This is a workaround to wrap a master tty_token around the
  cninit() code which prevents an early-boot crash if
  lwkt_gettoken()'s td_mpcount optimization is turned off.
  (the optimization masks the problem).

* Also assert that the mpcount remains correct after the mess
  is done initializing, if it is wrong the SMP/AP boot will
  blow up on us.

kernel - Fix td_xpcount when pushing a preemption

* We have to set xpcount to the sum of the victim thread's mpcount
  and xpcount, rather than just its mpcount.

Reported-by: Rumko

kernel - Fix missing release of tty_token

* Fix one missing release and one misordered release.  These were
  causing the low level SMP AP boot to enter with 2 mplock counts
  instead of 1.

kernel - Fix two mismatched locks in CAM

* cam_periph_alloc() failed to release a lock in one case and had an extra
  unlock in another.

* passregister() had an extra unlock

Reported-by: Rumko

iwi - Convert to wlan_tokens.

Submitted-By: Johannes Hofmann (jh33)
Bug-Id: 1810

ral - Fix calls to bus_dmamap_load_mbuf_segment() to use BUS_DMA_NOWAIT.

Reported-by: Max Herrgard <herrgard@gmail.com>
Tested-by: Max Herrgard <herrgard@gmail.com>

ral - Make sure nodes are properly uninitialized and reinitialized.

Adds rt2661_newassoc() which cleans up the ieee80211_node.

Reported-by: Max Herrgard <herrgard@gmail.com>
Tested-by: Max Herrgard <herrgard@gmail.com>

wpi - Convert to use wlan_token.

kernel - Separate inherited mplocks from td_mplocks and fix a gettoken bug

* Separate out td_mpcount into td_xpcount and td_mpcount.  td_xpcount
  is an inherited mpcount.  A preempting thread inherits the mpcount
  on the thread being preempted until it switches out to guarantee
  that the mplock remains atomic through the preemption (as expected
  by the poor thread that got preempted).

* Fix a serious but hard to reproduce bug in lwkt_gettoken().  This
  function marks the token reference as being MPSAFE if td_mpcount
  is non-zero even when the token is not a MPSAFE token.

  However, until this patch td_mpcount also included inherited mpcounts
  when one thread preempts another and the inherited mpcounts could
  go away if the thread blocks or switches, leaving the token unprotected.

* Fix a less serious bug where a new token reference was being populated
  prior to td_toks_stop being incremented, and where an existing token
  reference was being depopulated after td_toks_stop is decremented.
  Nothing can race us but switch around the index increment/decrement
  to protect the slot being operated upon.

* Add a ton of assertions in the interrupt, trap, and syscall paths
  To assert that the mplock, number of tokens, and critcount remain
  unchanged across driver and other calls.

kernel - Correct missing unlock in SCSI pass device

* Correct a missing sim unlock, which matters more now that
  the sim lock might not be the mp lock.

buildkernel - Order kernel before modules

* Order the kernel before modules so a parallel build builds the kernel
  before diving into the modules.  This makes incremental building more
  convenient.

kernel - Enabled bzeront() (MOVNTI) only on SSE2-capable CPUs.

spinlocks - adjust man pages and *_quick_* routines

* Adjust man pages to reflect the recent changes (removal of shared
  spinlocks, renaming of exclusive spinlocks).

* Remove old man page symlinks and adjust new ones.

* Rename the spin_{un,}lock_wr_quick ro spin_{un,}lock_quick.

cam_xpt - Fix recently introduced typo

* Fix a typo introduced by the previous spinlock commit.

Reported-by: Jonas Trollvik

spinlocks - Rename API to spin_{try,un,}lock

* Rename the API to spin_trylock, spin_unlock and spin_lock instead of
  spin_lock_wr, spin_unlock_wr and spin_trylock_wr now that we only have
  exclusive spinlocks.

* 99% of this patch was generated by a semantic coccinelle patch

syscons MPSAFE - another attempt

* Do another pass on syscons and reduce the number of token
  uses significantly.

* syscons now works with a limited number of tokens, acquired almost
  only around linesw and vidsw routines, but out of the way of tty_cons.

coretemp, sensors - Adjust spinlocks

* In kern_sensors, adjust the spinlocks to not be held across the sysctl
  interface management.

* In coretemp, adjust illegal spinlock across calls to kern_sensors.

Reported-by: Matt Dillon (dillon@)

kernel - poll(2) no longer supports non-standard FreeBSD extensions

Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly

devfs - Do not try printing the name of a null vnode

kernel - remove spin_lock_rd() and spin_unlock_rd()

* Remove shared spinlocks entirely.  We only have exclusive spinlocks
  now.

* Strip out the exclusive/shared contention handling code.

* Slightly rework the initial exponential backoff and test.  Do the
  atomic swap after the exponential backoff instead of before so
  we do not add a superfluous backoff after actually acquiring
  the spinlock.

kernel - Switch to exclusive spinlocks in the coretemp sensor

* No impact on performance.

* TODO: spinlocks are being held across major kernel calls in the
  detach code which is not legal.

kernel - Switch to exclusive spinlocks in kern_descrip.c

* This isn't expected to have much of an effect on performance and I want
  to get rid of shared spinlocks.  If it becomes an issue for descriptor
  lookups we could actually move to a spinless lookup/hold model using
  defered frees.

kernel - Refactor uidinfo a little

* Fix a MP drop race with uidinfo and get rid of the shared spinlock.

  Also fix areas where the spinlock was improperly enclosing complex
  code.

kernel - Refactor plimit a little

* Use only exclusive spinlocks, I will be removing shared spinlocks.

* Refactor the cpu test such that the hot path does not acquire
  any spinlocks.

kernel - Fix spinlock use in syscons

* Spinlocks cannot be held across complex calls, particularly calls
  that might block or switch.

  This fixes a spinlock panic during lwkt.tty_mpsafe testing.

kernel - remove syscall_mpsafe and trap_mpsafe sysctls

* traps and system calls are always mpsafe, we don't need
  these sysctls any more.

kernel - kobj code cleanup

* Cleanup remains of KOBJ_STATS

kernel - Minor documentation

kernel - Possibly fix a bug in aic7xxx

* An attempt to compile -O2 revealed three uninitialized fields
  falling through to call that pokes them into the chip.  Initialize
  the fields.

kernel - Compact KOBJOPLOOKUP() kobj method core macro

* Replace the longish KOBJOPLOOKUP() macro with a procedure call
  to kobj_lookup_method().  Do all the heavy lifting in the procedure.

  Reduces the nominal kernel size by 67K.

aicasm: Mark stop() __dead2.

kernel - Fix usb keyboard problems with ehci & ddb

* Be sure to save the status of the xfer before reissuing the xfer
  in an interrupt pipe callback.

  This fixes an issue where ukbd thought the keyboard events from
  ehci were illegal because the status of the transfer was always
  IN_PROGRESS instead of COMPLETE.

  Interrupt pipes reissue their xfers prior to making the callback
  in order to ensure that the xfer is not somewhere in no-man's land
  if the callback enters the debugger (i.e. ctl-alt-esc).

MPSAFE TTY - Cleanup ukbd and atkbd, fix unregistration bug

* Cleanup code, fix unregistration module.  Fixes panic on usb keyboard
  unplug.

kernel - Fix UP build

* Declare panic_cpu_gd whether UP or SMP.

* Properly reinit the spinlock whether UP or SMP

Reported-by: swildner

MPSAFE TTY - Refactor the keyboard switch code to make all drivers MPSAFE

* Add a per-kbd lock.

* Replace the keyboard kbd_*() macros with function wrappers which acquire
  and release the per-kbd lock on behalf of each keyboard driver.  The
  wrapper code also understands polled mode and will not acquire/release
  locks in polled mode (aka debugger).

* Remove all tokens and locks from the keyboard drivers.

* Do some documenting of non-blocking paths.

iscsi_initiator(4): Fix another potential NULL pointer dereference.

so (which is sp->soc) can be NULL here, so add a check before dereferencing
it.

iscsi_initiator(4): Fix a potential NULL pointer dereference.

If sp can be NULL (as the rest of the code suggests), we can't use sdebug()
since that prints the string with sp->sid prepended (thereby dereferencing
NULL).

Instead, use debug() and add sp->sid to its string (with a check for NULL).

While here, fix some indentation issues.

 MPSAFE TTY - Fix deadlock in reporting of probe errors.

* When sio can't drain it reports the fact, but it was doing it while
  still holding com_lock.  Rearranging the lock fixes the problem.

* Clean up some unnecessary tty_tokens in critical code paths and rearrange
  code to not hold com_lock across tty_token acquisition calls.

* Release the com_lock around breakpoint() (<enter>~^B sequence) to
  avoid a deadlock.

* Detect and ignore a reentrant kprintf() to try to avoid a deadlock.
  The detection flag is also reset by a panic.

MPSAFE TTY - Refactor kprintf()'s spinlock, shutdown, move cons_spin

* Adjust panic assertions to reduce reentrant panics.

* Redo the shutdown code to properly interlock panic_cpu_gd

* Move cons_lock into subr_prf.c and use a normal spinlock instead of
  a deprecated (w/interrupt disablement) spinlock.

  Adjust kvcprintf() when used with kputchar() to acquire cons_spin
  only if the current cpu is not the currently panicing cpu.

  Adjust kvcprintf() when used with kputchar() to acquire a hard
  critical section.

kern_sensors - MPSAFE

* It also seems like all sensor drivers can be run mpsafe as long as
  their tasks are serialized, which happens now anyways via the
  sensor_task_lock.

MPSAFE TTY - get rid of tokens in console path

* The console path (coming through tty_cons.c) can never block, so do
  not try to acquire tokens there.

Reported-by: Jan Lentfer

kernel - Remove unneeded get_mplock() wrappers near tokens

* The xx_tokens replace the mplock functionality (and for now
  they still get the mplock), so clean these up.

kernel - Uninline crit_exit()

* Corrections for DEBUG_CRIT_SECTIONS (LINT build)

kernel - Uninline crit_exit()

* Missing file from last commit.

kernel - Uninline crit_exit()

* Have crit_exit() call an actual procedure instead of inlining it.
  This doesn't seem to effect performance any and it reduces the
  size of the kernel noticeably.

  Modern cpus heavily optimize call/return paths these days and there
  might even be advantages to the smaller code and branch-cache footprint.
  The conditionals inside crit_exit() are nearly perfectly predicted
  now that there is no differentiation between the N->(N-1) and 1->0 case.

kernel - gcc -Os/-O2 warnings pass

* This is just a partial pass on the code to start cleaning up gcc
  warnings at higher optimization levels.

kernel - Introduce hard code sections, simplify critical sections & mplocks

* Introduce hard code sections with crit_enter_hard(), crit_exit_hard(),
  lwkt_gettoken_hard() and lwkt_reltoken_hard().

  These functions create a hard code section that, like an interrupt or ipi,
  does not allow any case which might potentially block or switch threads.
  While in a hard code section any such case will assert and panic the
  system.

  For example, acquiring a token that is not already held would be disallowed
  even if the acquisition could be accomplished without blocking.  However,
  acquiring a token which is already held would be allowed.  Same with the
  mplock, lockmgr locks, etc. (mtx's and serializers have not been dealt
  with yet).

* Introduce ASSERT_LWKT_TOKEN_HARD() and ASSERT_LWKT_TOKEN_CRIT().

  These assert that a token is held and a hard critical section (hard)
  or any critical section (crit) is in place.

* Rework the critical section macros and optimize the crit_exit*() code
  to two conditionals which are usually always false regardless of
  whether critcount is transitioning 1->0 or not.  Also declare
  crit_panic() __dead2 which may produce better code.

* Rework get_mplock() to reduce code generation.  The hard code section
  assertions would have made it too big.  We still optimize the case
  where the mplock is already held.

Fix various mdoc issues in various manual pages.

kernel - make nrandom helper thread mpsafe

* The random number generator helper thread no longer holds the mplock.

kernel - All lwkt thread now start out mpsafe part 2/2

* Remove the TDF_MPSAFE flag entirely.  All thread creation of all
  types now start running the thread without the mplock.

  Drivers which aren't mpsafe immediately acquire the mplock.

kernel - All lwkt thread now start out mpsafe part 1/2

* All callers of lwkt_init_thread(), lwkt_create() and lwkt_alloc_thread()
  now always pass TDF_MPSAFE and the flag is asserted in the low level
  thread creation code.

kernel - Fix telnet ttyp* allocation

* Fix handling of TS_ZOMBIE, which I think I broke a few commits ago.
  This was preventing traditional pty's from being properly reused.

Reported-by: lentferj

kernel - Change lwp_fork() to not hold the mplock in the new thread

* Change lwp_fork() to produce a mpsafe thread at startup instead of
  one with the mplock held.

* Change all fork_trampoline() functions and all kernel callbacks
  via cpu_set_fork_handler() to expect a thread without the
  mplock held.

* Adjust the thread procedures for aio etc (those not yet mpsafe)
  to acquire the mplock.

kernel - make kern/vfs_sync.c MPSAFE

* Syncer queues already tokenized but make the syncer thread MPSAFE

* Mark the source file MPSAFE

Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly

kernel - unwind kthread_create() mplock

* All kthread_create*() calls and kproc_start() calls now create
  threads which do not hold the mplock at startup.

* Add get_mplock()/rel_mplock() to threads which are not yet mpsafe.

* Remove rel_mplock() calls from thread startups which were making
  themselves mpsafe by releasing the mplock.

* Kernel eventhandler API is now MPSAFE

* Kernel kproc API is now MPSAFE

* Rename a few thread procedures to make their function more obvious.

bsd-family-tree: Sync with FreeBSD (for FreeBSD 8.1).

manpages: Fix some more .Dv abuse.

driver.9: Fix .Dv abuse.

syscall.9: Some minor mdoc adjustments.

kernel - CAM mpsafe issues

* Lock the CAM bus when making asynchronous xpt callbacks.  This code
  previously depended on the MP lock but failed to use the correct
  sim lock, and AHCI/SILI now use their own locks.

* Remove a few other unnecessary mplocks.

* Redo the bus counting code to be MPSAFE.

kernel - Mark vm/vm_zeroidle.c and vm/vnode_pager.c MPSAFE

* These modules are MPSAFE.  Also run the vm_zeroidle thread
  MPSAFE.

kernel - make kern/imgact_resident.c MPSAFe

* Get rid of the mplock and use the existing lockmgr lock to deal
  with races.

kernel - Call knote_fdclose() without the mplock.

* knote_fdclose() handles MPSAFE/non-MPSAFE filter callbacks so we
  no longer have to call it with the mplock held.

kernel - procfs_token work

* Cover proc_stop(), proc_unstop(), and setrunnable() with proc_token.
  Remove the MP lock assertion from setrunnable().

* Cover procfs operations with proc_token.

* Cover lwp_signotify() and friends with proc_token.

kernel - Add vmobj_token, misc vm-related tokenization

* Add vmobj_token to protect vm_object_list and vm_object->ref_count and
  related functions.

  Note: coalesce and collapse require both vm_token and vmobj_token,
  and vmspace_fork() requires a bunch of tokens.

* Remove miscellanious mplocks and critical sections that are no longer
  needed.

* Correct potential sysinfo kernel data visibilty issue.

* Optimize some potentially recursive vm_token/vmobj_token situations
  by adding *_locked() procedure variants.  To avoid blowing out the
  token stack.

* Remove unnecessary get_mplock() calls in vm_zone.c

* Bump gd_intr_nesting_level in the IPI processing core and assert
  that it is zero in the gettoken core.  Hard interrupts (vs interrupt
  threads) are not allowed to acquire tokens for obvious reasons.

kernel - Fix badfo_kqfilter for badfileops

* badfo_kqfilter() must return an error to cause the kqueue
  registraton to drop the knote, otherwise a kernel panic
  will occur because the default file_filtops isn't replaced
  and has not detach or event functions.

MPSAFE: MPSAFE kern_sig.c

sio: Fix a typo. lwkt_gettoken -> lwkt_reltoken

Reported-by: alexh

sio - Minor token fix for sio

* comwakeup() can be called from a callout and thus must acquire
  tty_token itself instead of asserting that it is already held.

Reported-by: lentferj

vkernel - Make copyin/copyout mpsafe

* copyin and copyout are mpsafe now that the VM system is locked up,
  so remove the get_mplock()/rel_mplock() wrapper.

kernel - Adjust contention handler

* Simplify handle_cpu_contention_mask() a little.  For vkernels we
  call pthread_yield().

* Just call cpu_pause() in cpu_spinlock_contested().  Don't do anything
  fancier, the routine is called as part of the exponential backoff
  code.

kernel - Add description to static token initializers

* Add a description argument for LWKT_TOKEN_xx_INITIALIZER()

Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly

vkernel - Fix deadlocks with cothread locks

* Callbacks into the main kernel are not allowed when holding a cothread
  lock as this could cause a deadlock between cpus.  If the callback into
  the kernel blocks the cothread lock, being a pthreads lock,
  remains locked.

* Refactor the network and disk pipeline to hold the cothread lock for
  a much shorter period of time, allowing data to be pipelined without
  any stall conditions.

* For vknet if the tx mbuf return fifo is full we wait until it isn't.

kernel - Major MPSAFE Infrastructure 2

* Refactor buffer cache code which assumes content-stable data across
  a non-blocking BUF_LOCK().  This is no longer true.  The content must
  be reverified after the BUF_LOCK() succeeds.

* Make setting and clearing B_DELWRI atomic with buffer reassignment.

* Release cached mplock when looping in the scheduler and run
  check_splz() to avoid livelocking cpus.

* Refactor the mplock contention handling code to handle both the mplock
  and token contention.  Generate a 2uS delay for all but one cpu to
  try to avoid livelocks.

* Do not splz() from inside a spinlock, it will just panic.

* Fix the token description field for 'systat -pv 1'.

* Optimize MP_LOCK macros a bit.

MPSAFE - TTY & related drivers

* Put kern/tty_* under the tty_token (and acquire the proc_token where
  needed).

* MPSAFE all related drivers (users of kbdsw, linesw and vidsw) with the
  same tty_token.

* NOTE: syscons.c and scvgarndr.c are not really under this new lock
  yet as some really strange hangs appear. Some are related to the
  cursor drawing (which stalls the  machine if a token is held) and
  others are in some other syscons.c functions.

kernel - Major MPSAFE Infrastructure

* vm_page_lookup() now requires the vm_token to be held on call instead of
  the MP lock.  And fix the few places where the routine was being called
  without the vm_token.

  Various situations where a vm_page_lookup() is performed followed by
  vm_page_wire(), without busying the page, and other similar situations,
  require the vm_token to be held across the whole block of code.

* bio_done callbacks are now MPSAFE but some drivers (ata, ccd, vinum,
  aio, nfs) are not MPSAFE yet so get the mplock for those.   They will
  be converted to a generic driver-wide token later.

* Remove critical sections that used to protect VM system related
  interrupts, replace with the vm_token.

* Spinlocks now bump thread->td_critcount in addition to
  mycpu->gd_spinlock*.  Note the ordering is important.  Then remove
  gd_spinlock* checks elsewhere that are covered by td_critcount and
  replace with assertions.

  Also use td_critcount in the kern_mutex.c code instead of gd_spinlock*.

  This fixes situations where the last crit_exit() would call splx()
  without checking for spinlocks.  Adding the additional checks would
  have made the crit_*() inlines too complex so instead we just fold
  it into td_critcount.

* lwkt_yield() no longer guarantees that lwkt_switch() will be called
  so call lwkt_switch() instead in places where a switch is required.
  For example, to unwind a preemption.  Otherwise the kernel could end
  up live-locking trying to yield because the new switch code does not
  necessarily schedule a different kernel thread.

* Add the sysctl user_pri_sched (default 0).  Setting this will make
  the LWKT scheduler more aggressively schedule user threads when
  runnable kernel threads are unable to gain token/mplock resources.
  For debugging only.

* Change the bufspin spinlock to bufqspin and bufcspin, and generally
  rework vfs_bio.c to lock numerous fields with bufcspin.  Also use
  bufcspin to interlock waitrunningbufspace() and friends.

  Remove several mplocks in vfs_bio.c that are no longer needed.

  Protect the page manipulation code in vfs_bio.c with vm_token instead
  of the mplock.

* Fix a deadlock with the FINDBLK_TEST/BUF_LOCK sequence which can occur
  due to the fact that the buffer may change its (vp,loffset) during
  the BUF_LOCK call.  Even though the code checks for this after
  the lock succeeds there is still the problem of the locking operation
  itself potentially creating a deadlock betwen two threads by locking
  an unexpected buffer when the caller is already holding other buffers
  locked.

  We do this by adding an interlock refcounter, b_refs.  getnewbuf()
  will avoid reusing such buffers.

* The syncer_token was not protecting all accesses to the syncer list.
  Fix that.

* Make HAMMER MPSAFE.  All major entry points now use a per-mount token,
  hmp->fs_token.  Backend callbacks (bioops, bio_done) use hmp->io_token.
  The cache-case for the read and getattr paths require not tokens at
  all (as before).

  The bitfield flags had to be separated into two groups to deal with
  SMP cache coherency races.

  Certain flags in the hammer_record structure had to be separated for
  the same reason.

  Certain interactions between the frontend and the backend must use
  the hmp->io_token.

  It is important to note that for any given buffer there are two
  locking entities: (1) The hammer structure and (2) The buffer cache
  buffer.  These interactions are very fragile.

  Do not allow the kernel to flush a dirty buffer if we are unable
  to obtain a norefs-interlock on the buffer, which fixes numerous
  frontend/backend MP races on the io structure.

  Add a write interlock in one of the recover_flush_buffer cases.

MPSAFE: MPSAFE kern/kern_plimit.c

No tokens required; vm_map_protect is self-synchronized.