wlan - send RTM_IEEE80211_SCAN event when scan was cancelled.

wpa_supplicant(8) expects to see 'scan complete' event after every
scan command; in case, when event is not sent it will hang for
indefinite time.

Taken-From: FreeBSD (SVN r300383)

wlan - restore interface state check for IEEE80211_IOC_SCAN_REQ ioctl.

Do not try to start a scan when interface is not running.

How-to-reproduce:
1) ifconfig wlan0 create wlandev urtwn0
2) wlandebug -i wlan0 state
3) ifconfig wlan0 scan

Taken-From: FreeBSD (SVN r300237)

if_iwm - When stopping TX DMA, wait for all channels at once.

* Makes the TX DMA stopping more similar to Linux code, and potentially
  a bit faster. Also, output an error message when TX DMA idling fails.

Taken-From: Linux iwlwifi

iwm: Send PHY DB commands as async commands.

Taken-From: OpenBSD

if_iwm - Set different pm_timeout for action frames.

When building a Tx Command for management frames, we are lacking
a check for action frames, for which we should set a different
pm_timeout.  This cause the fw to stay awake for 100TU after each
such frame is transmitted, resulting an excessive power consumption.

Taken-From: Linux iwlwifi (git b084a35663c3f1f7)

if_iwm - Remove iwmsleep, it's no longer needed. Use just lksleep instead.

kernel - Adjust arp code to not spam all cpus

* Do not spam all cpus if the arp does not change the routing table.

* Supply (for now) a 1-second hysteresis for expiration updates.

* Add a little netisr debugging for kgdb.

kernel - cleanup sys/thread.h

* Cleanup unused TDPRI's

* Add a CPUMASK macro to retrieve the address of an element.

kernel - Do not spam all cpus for ipfrag_slowtimo()

* Only issue the ipfrag_slowtimo() to cpus with non-empty ip fragment
  queues.  This will not impact performance but significantly reduces
  unnecessary IPIs to idle cpus.  It makes for better systat -pv 1
  eye-candy.

* Only allow one ipfrag timeout IPI to be in-flight to any particular target
  cpu.  This will not impact performance but may help reduce degenerate
  ipiq-full conditions if the target cpu becomes cpu-bound in a critical
  section.

<signal.h>: Don't advertise sigqueue(2) availability.

sigqueue(2) is not yet implemented.

efi/loader: Use acdragonfly.h.

acpi.h is not readily includable from sys/boot, so in order to get at
ACPICA definitions etc., the specific ACPICA headers are included
directly, along with whatever acpi.h would include by itself normally.
On DragonFly, this is acdragonfly.h, not acfreebsd.h.

It's just a cosmetic change. The resulting binaries are identical with
one header or the other.

Approved-by: ivadasz

kernel/pc64: Make metadata.h more compatible with FreeBSD again.

* Use the same values as FreeBSD for MODINFOMD_EFI and_MAP MODINFOMD_EFI_FB,
  to keep kernel and bootloader more compatible with FreeBSD.

Pointed-out-by: zrj

kernel - Improve vm.prefault_pages + misc

* vm_prefault_quick() now gives up more quickly when things don't work out.
  This fixes a scaling issue when vm.prefault_pages is set very high.  A
  prefault failure would still test every page and kill performance.
  (example: linear zfod burst).

* Adjust pmap page removal loop to yield every 64 pages.  Before it was
  yielding every 4096*8 pages.

* Adjust vm_object_*() routines to yield every 64 pages as well.

kernel - Reduce stalls, refactor lwkt_switch() core.

* These changes primarily effect programs which have a lot of token
  contention (aka concurrent write VM faults) and exiting programs which
  have very large RSSs (e.g. multiple gigabytes).

* Release proc->p_token around potentially long vmspace destruction ops.
  This avoids stalls in programs like 'ps' and functions like
  fork/exec/wait/exit.

* Refactor lwkt_switch().  This may also fix a bug where we improperly
  called splz_check() after releasing the current thread's tokens.  An
  interrupt or IPI could then sneak in and corrupt a recursive token.

  Remove the infinite loop cycling.  When token contention is present this
  caused scheduler ticks to dock the wrong thread (the current thread instead
  of the target thread).  Heavy token contention could cause higher priority
  processes to stall for very long periods of time.

  Instead, once the spin limit is exhausted we switch through the idle
  thread which places us in a better context from which to continue.

* Adjust the dragonfly process scheduler to detect contention when the
  current thread is the idle thread, and then attribute the tick to the
  correct thread (or at least a more-correct thread).

test - Fix build warnings

* Fix build warnings in the pipe1 and pipe2 tests.

<rpc/svc.h>: Add back comment.

drm/linux: Avoid contention in spinlock_irq routines

* Call crit_enter() first and lockmgr() later

* This helps to avoid unnecessary contention on the same cpu if a
  regular kernel thread holding the lockmgr lock is preempted by
  an interrupt thread which would like to acquire the same lock

* By putting the lockmgr() call in the critical section, we avoid the
  situation where the preempting interrupt routine tries to lock,
  races the main thread lock, and forces an extra two thread switches

Suggested-by: sephe@
Reviewed-by: dillon@ and sephe@

kernel - Yield during VM teardown, fix zfree() contention

* Yield during the teardown of vm_page's related to process exit
  to allow other processes to get some cpu.  Also use lwkt_user_yield()
  instead of lwkt_yield().

* zfree() had no hysteresis once the pcpu cache was full, causing massive
  contention on the pool spin lock.  Generally only effects page-frees
  (returning the pv_entry to the pool).

  Implement hysteresis on free by moving up to 32 elements out of the pcpu
  cache and back into the pool when the pool becomes full.

kernel - Fix stalls during major token contention

* When a set of processes is seriously contending on a token, unrelated
  lower-priority processes scheduled to the same cpu may stall randomly for
  several seconds at a time.  Such contention is rare, but can still occur
  at choke-points (such as multiple threads write-faulting on the same VM
  object) and result in a degenerate condition.

  This occurs because the scheduler has become fixated on the contending
  thread due to its priority.  Because the 'current thread' might not be the
  one that is contending, the scheduler clock does not account for the
  contending thread.

* Add a contention heuristic to the scheduler for now which releases the
  contending thread on the current cpu (allowing the userland scheduler to
  choose another thread to schedule).

* At the moment I have not tried to code the scheduler clock to account for
  the contending thread.  Theoretically doing so would reduce its dynamic
  priority so the scheduler does not fixate on it, but it is a bit of a
  round-about way to solve the problem whereas coding it in lwkt_switch()
  gives us nearly instant detection.

hammer2 - Add feature to allow sector overwrite, fix meta-data check code (2)

* Remove printing of now-deleted fields from debug code (fixes buildworld)

hammer2 - Add feature to allow sector overwrite, fix meta-data check code

* If a file is set to use no check code (hammer2 setcheck none <file>),
  data overwrites will reuse the same sector as long as it does not violate
  the most recent snapshot.

  This allows the program to relax copy-on-write requirements for certain
  files, for example files which might be mmap()'d SHARED+RW and then
  modified constantly where the programmer has determined that the
  possibility of corruption is ok.

* Implement pfs_lsnap_tid in the PFS root inode meta-data.  This records the
  last snapshot TID so the chain code can determine if an overwrite is
  allowed.

* Remove attr_tid and dirent_tid from the inode meta-data for now.

* Only BREF_TYPE_DATA brefs inherit the inode check mode.  Meta-data brefs
  such as indirect blocks, or directory entries, will only use the check
  code type specified in the parent inode if it is not NONE.  Otherwise
  they will use the default check code.

  This fixes a bug where meta-data brefs could wind up being unchecked.  We
  want all meta-data to always be checked (at least for now).

kernel: Don't use userland's <stdarg.h> from kernel files.

Use <machine/stdarg.h> instead which automatically comes in via
<sys/systm.h>.

<sys/systm.h>: Remove a leftover prototype.

kernel - Change cpu_idle_hlt default for modern amd cpus.

* Set cpu_idle_hlt=3 for AMD Bobcat and later (which includes any Bulldozer
  cpus and apus as well). These cpus do major power management in HLT or ACPI,
  but cpu_idle_hlt=1 would try to use MWAIT. Also wakeup times should be
  fast enough to make cpu_idle_hlt=2 unnecessary.

kernel - New threads should not inherit the sigaltstack

* New threads should not inherit the sigaltstack.  The stack is still
  inherited on a full fork().

* Fixes issue brought up by https://go-review.googlesource.com/#/c/18835/3

Reported-by: Tim Darby

virtio: Fix MSI support; thus unbreak booting on bhyve

I'd like to thank Peter Grehan <grehan freebsd org> very much for
providing various information on bhyve side and helping testing
this patch.

libc/confstr: Fix comment indentation.

sysconf(3): Fix _SC_GET{GR,PW}_R_SIZE_MAX.

The standard allows to return -1 if there is no hard limit on the size
of the buffers.

<unistd.h>: Add more comments to options.

sysconf(3): Add _SC_THREAD_SPORADIC_SERVER.

getconf(1): Add some variables for backward compatibility.

The standard requires all of these.

getconf(1): Fix typo (_POSIX2_EXPR_NEXT_MAX -> _POSIX2_EXPR_NEST_MAX).

getconf(1): Add some missing variables.

_POSIX_ADVISORY_INFO
_POSIX_RAW_SOCKETS
_XOPEN_STREAMS

getconf(1): Fix confstr variable names.

All these don't have an underscore.

cat: Align output from cat(1) between when invoked with -be & -ne flags

Obtained-from: NetBSD
Submitted-by: <venture37 geeklan co uk>
DragonFly-bug: https://bugs.dragonflybsd.org/issues/2922

Remove <varargs.h> from the system.

Similarly as it was done with <malloc.h>
Not standard header, just a symlink to machine/varargs.h and
seems not used by anything in the base (<stdarg.h> is preferred).

Fix <machine/varargs.h> use cases.

First varargs.h depended on namespace pollution to provide typdef of __va_list
to declare va_list. Usually thorugh sys/systm.h including sys/stdarg.h

So short-circuit directly to compiler builtin in case of __GNUC__

Also remove machine/varargs.h usage from other kernel sources:
  sys/kern/kern_dsched.c: Not needed (just 3 dummy functions)

  sys/dev/misc/tbridge/tbridge.c: Both use just __va_smth variants
  sys/kern/subr_taskqueue.c:      and get those through sys/systm.h

This leaves all the kernel code using <stdarg.h> variant consistently.

<stdio.h>: Hide macros that break global :: ns in cxx.

Avoid expanding macros  ::(!__isthreaded ?...) to poorly written
ports that assume some specific libc/stdio.h implementation.
Will help with patching efforts to have less +<cstdio> patches
in dports using c++ codes.

Move __va_size() into freestanding block.

Mainly to match varargs.h layout. No users outside these headers.

<wchar.h>: Reduce namespace pollution in <wchar.h>.

sys/sys: Protect len and inout parameters in _IOC definition.

This should reduce the likelihood of _IOC() macro expanding to something
that wasn't intended and would provide a more flexible interface too.
While there, remove hardcoded value for IOC_DIRMASK

Taken-from: FreeBSD

rpc: Whitespace cleanup.

While there, perform license change as per FreeBSD r258581

rpc: Make few headers more compatible with gcc.

Previously gcc compilers from dports installed patched versions
of rpc headers that override the system ones.
By applying small changes, headers are no longer patched and
does not require rebuilding gcc dports to account for possible
change in include/rpc headers after installworld.
While there perform some minor cleanup.

No functional change.

<pthread.h>: Include <machine/limits.h> instead of <limits.h> for ULONG_MAX.

Also include <limits.h> in a couple of files that were missing it.

This commit will break 4 ports:

devel/clanlib1
games/orbital_eunuchs_sniper
games/zatacka
sysutils/cdargs

These will be fixed in the next time.

drm/linux: Improve spin_unlock_irqrestore()'s implementation

Prevents compilation failures in functions not using
spin_lock_irqsave() first.

installer: Do not waste too many inodes on /boot

* A fully populated /boot with kernel, kernel.old, kernel.alt
  and associated modules needs aproximately 2K inodes

* With a 1GB /boot partition size, default newfs parameters
  allocate 128K inodes

* Reduce this amount to 15K inodes, thus making an additional
  13MB of disk space available on /boot

sbin/hammer: Make global PFS/accounting variables static

sys/vfs/hammer: Remove validate_zone()

Code becomes less clear with this function and usage of sum of results.
Just check if the given offsets are data zones or not (unless we plan
to support non-data zones, but we don't).

drm: Restore DRM_DEBUG_VBLANK() calls

drm/i915: Use the spin_lock_irq() family of functions (2/2)

Further reducing differences with Linux 4.3.

drm: Use the spin_lock_irq() family of functions

Reducing differences with Linux 4.3

drm/i915: Use the spin_lock_irq() family of functions

Reducing differences with Linux 4.3

kernel - Enhance buffer flush and cluster_write linearity (2)

* Fix bug last commit.  When looping the buffer has to be reset to
  the marker or the iteration can wind up on the wrong queue.

* Also count the INVAL case in the loop instead of breaking out.

hammer2 - Fix inode destroy panic

* Fix a race in hammer2_inode_xop_destroy() when deleting an inode chain.
  The parent can be ripped out from under the code before it gets both
  parent and chain locked, resulting in an assertion in hammer2_chain_delete().

  Properly test the linkage and retry if the parent changes.

kernel - Enhance buffer flush and cluster_write linearity

* flushbufqueues() was iterating between cpus, taking only one buffer off
  of each cpu's queue.  This forced non-linearly on-flush, messing up
  sequential performance for HAMMER1 and HAMMER2.  For HAMMER2 this also
  caused physical blocks to be allocated out of order.

  Add sysctl vfs.flushperqueue to specify the number of buffers to flush
  per cpu before iterating the pcpu queue.  Default 1024.

* cluster_write() no longer requires that a buffer be VOP_BMAP()'d
  successfully in order to issue writes.  This effects HAMMER2, which does
  not assign physical device blocks until the logical buffer is actually
  flushed to the backend device.

* Fixes non-linearity problems for buffer daemon flushbufqueues() calls,
  and for cluster_write() with or without write_behind.

hammer2 - Optimize indirect block algorithm

* Pack indirect blocks for linear files significantly better.

* First level indirect block for directories reduced to 4KB (32 entries).

* For now make the first level indirect block for directories cover the
  entire hash range for either inodes or directory entries (63 bits).

hammer2 - Stabilization pass

* If the HAMMER2_CHAIN_DEDUP flag is set modified_needs_new_allocation()
  must return 1 to force a new allocation.  This fixes a number of dirty
  buffer rewrite cases that broke dedup.

* Do not try to dedup a chain flagged MODIFIED or INITIAL.

* The indirect-block deletion code in the flusher needed to also count
  blockrefs if it hadn't been done yet.  This fixes cases of missing
  directory entries.

* For now use a transaction in hammer2_strategy_write().  We probably don't
  need it due to the way the logical buffer cache is handled, but do it
  anyway.

* Clean-up some of the code documentation.

* Implement sysctls for dedup and buffer invalidation enablement.  dedup
  is turned on by default, invalidation is turned off.  Invalidation is
  not currently working well.

hammer2 - Remove the hidden directory, rework deletions

* Now that inodes are separately indexed we no longer need the hidden
  directory abstraction to handle unlinked-but-open files.  Get rid of
  ALL the hidden directory handling code.

* Rework xop_unlink and hammer2_inode_unlink_finisher().  We cannot safely
  reference the inode chain's inode data to get the nlinks count.  Instead,
  figure it all out on the frontend using the active nlinks in the
  hammer2_inode_t structure.

* Fixes hardlink removal and rename issues.

ifnet: Add oqdrops statistics

hammer2 - Stabilization, fix bulkfree bugs, change 'df' output

* Automatically delete any indirect nodes which become empty.  This is done
  in the flusher.  Verify that a rm -rf cleans everything out.

* Fix three serious bugs in the bulkfree code.

  (1) A range-check of cbinfo->sstop was using '>' instead of '>=', causing
      a one-element overflow during the scan and potentially corrupting
      memory.

  (2) The live bitmap pointer must be reloaded after calling
      hammer2_chain_modify()!  The old pointer points to a buffer
      which must remain clean, or worse points to a buffer completely
      unrelated to the hammer2 filesystem.

  (3) We were zeroing the temporary bmap, but it actually needs to be
      initialized properly (particularly its reserved areas).  Just
      zeroing it led to reserved areas being improperly marked as
      available for allocation.

* Validate that the free space counter is recovered properly after a
  rm -rf and bulkfree.

* Disable the modify_tid test in the bulkfree code for now and go back to
  forcing a flush.

* Change 'df' reporting.  I was trying to be fancy by compensating for dedup
  to report how big the filesystem would be if nothing were deduped, but it
  just caused confusion.  We now report an unchanging total volume size and
  the actual number of 16KB blocks that are fully free.

* The 'hammer2 freemap' dump now includes all indices, including those
  associated with reserved areas.

kernel - Fix panic in error path of nvextendbuf()

* nvextendbuf() was not releasing bp in the error path, leading to
  a hanging lock and 'locking against myself' panic later on.

hammer2 - Stabilization (data corruption)

* Move the check code errors into hammer2_chain_testcheck() and supply
  additional information in the kprintf.

* Reformulate hammer2_io_newq() a bit.

* Fix bugs in the buffer invalidation path.  The hammer2_io_newq() path
  was improperly setting INVALOK.  This path is only used by the freemap
  code to pre-validate a buffer to avoid unnecessary reads.  Fixed by
  not setting INVALOK if IOCB_QUICK is set.

hammer2 - Update error message in hammer2_mount

* Update the error message to reflect the current default labels
  when the '@LABEL' specification is missing.

hammer2 - Enhance freemap output

* Output the base data offset for each freemap line in the freemap
  dump.

* Also provide more check data info in the output.

nvme - Handle full submission queue

* The submission queue is a ring and can be full even if requests are
  available due to out-of-order completion.  Update the submission queue's
  subq_head from the completion queue status and check for a full condition.
  The normal requeue signaling suffices for resume.

* Also note that we allocate maxqe requests, which is actually one more than
  we can have on the ring at once.  But now that we have the queue-full check,
  this becomes a non-issue.  Just leave it at maxqe for convenience.

* Tested by temporarily reducing maxqe to 16 and doing stuff to overload it.
  Maxqe was returned to 256 for the commit.

kernel - Enhance swap allocation failure message

* Output a more appropriate message if the system wants to page to swap
  and no swap is configured.

kernel - Misc bug fixes and enhancements

* Add atomic_*_64() for 64-bit-explicit calls.  This way if a platform
  doesn't support 64-bit atomic ops H2 will at least get a compile error.

* Fix bug in sys/mutex2.h.  mtx_upgrade_try() was not setting mtx_owner
  on success.

* Enhance assertion panic message in lockmgr_kernproc().

hammer2 - Stabilization, optimization

* Increase the hammer2_io.refs field to 64 bits so we can add a few more
  control bits.

* Track whether invalidation is ok at the DIO level for full-sized (64KB)
  data blocks.  We continue to use the slightly less-capable CHAIN_DEDUP
  flag for smaller data blocks (this flag gets set on frontend->backend
  flush whereas the DIO level flag is only cleared when a block is actually
  reused for deduplication).

* Separate vfs.hammer2.cluster_enable into cluster_read and cluster_write.
  Leave cluster_read enabled with a read-ahead of 4 blocks.  Disable
  cluster_write for now, but still set B_CLUSTEROK in the bdwrite().

  This allows the frontend to 'flush' data to the backend without
  initiating disk I/O on the block device, giving us a chance to discard
  the data later if it winds up being temporary.

* Remove an improper BUF_KERNPROC(dio->bp) in the case where a different
  thread owns the in-progress DIO.

* Defer setting of B_INVAL | B_RELBUF to when the DIO is in lastdrop.

* Add missing brelse() in the hammer2_read_file() error path.  Add missing
  B_CLUSTEROK in hammer2_write_file().

* The bulkfree code now ensures that the INVALOK bit in any related DIO
  for a freed block is cleared, preventing accidental invalidations on
  reuse.

Stop building/installing groff's soelim(1).

We have a version in usr.bin which we use since ages, so groff's
version got built/installed just to get overwritten again when
usr.bin was installed afterwards.

drm/linux: Implement some spin_lock_irq* functions

They are not just simple spin_lock/spin_unlock() variants but
disable hardware interrupt processing on the current cpu.

Suggested-by: Matt Macy <mmacy@nextbsd.org>

sys/vfs/hammer: Remove DEDUP_CACHE_SIZE and wrong comment

It is a tunable sysctl since e2ef7a95.

nvme: Use high frequency interrupt for CQ processing

Suggested-by: dillon@
Reviewed-by: dillon@

intr: Allow drivers to register high frequency interrupt.

Only unshared interrupts will be considered, e.g. MSI, MSI-X or
unshared line interrupt.

Fix a couple of logic issues in contributed code (gcc, mpfr, tre).

* The mpfr bug was fixed in mpfr's trunk (r8705).
  Report: (https://sympa.inria.fr/sympa/arc/mpfr/2013-11/msg00009.html)

* The GCC bug was fixed too. This commit applies GCC's 51aab39345ae.

* The TRE bug came in with Apple's code. No idea if there is a simple way
  to report a bug in their libc to them. I've not found any.

drm/linux: Really implement local_irq_disable/enable

Suggested-by: Matt Macy <mmacy@nextbsd.org>

intr: Force unshareble interrupt setting

kern: Also detect KVM via the Hypervisor vendor ID signature.

ipfw3_nat: kmalloc netmsg from M_LWKTMSG

poll.2: Adjust NAME section for ppoll().

<sys/poll.h>: Some namespace cleanup.

Include <sys/signal.h> and <sys/time.h> only when necessary.

While here, cleanup whitespace a bit.

usr.bin/dirname: Accept multiple arguments as basename(1)

While there, expand examples section.

ipfw3: lockless in-kernel NAT

The libalias is used in kernel space for in-kernel NAT, and its alias_link
entries are stored with LIST. so all the packets which need to be NAT will scan
against the LIST and trying to find the matched alias_link. by seperating the
libalias into context of different CPUs, the lock can be removed. and due to the
nature of NAT, the outgoing and incoming packets are possible to be handled by
different CPUs, to ensure the returning packet can be translated properly, the
newly created alias_link is required to be duplicated and inserted into contexts
of both CPUs.

e.g.
ipfw3 nat 1 config if em0
ipfw3 nat 1 all via em0
ipfw3 nat 1 show state

hammer2 - stabilization pass

* Fix a shared/exclusive deadlock.  When adding a ref to a shared lock
  that has already been obtained we must make a slightly different call
  than the normal one because the normal one will block on a pending
  exclusive request, causing a deadlock.

* Add a missing BUF_KERNPROC().  Will hopefully fix a lock ownership
  assertion in the kernel that I've been hitting on heavy use.

* Looks like NFS needs to do inode number lookups on softlinks, so
  add inode indexing to the softlink (and the mknod) code instead
  of embedding the softlink in the directory entry.

hammer2 - Update directory mtime

* Update directory mtime on nmkdir, nlink, ncreate, nmknod, nsymlink,
  nremove, nrmdir, and nrename.

hammer2 - Stabilization pass

* Fix incorrect ip->meta.iparent initializations that were messing up
  NFS.  These fixes are primarily in the hammer2_inode_create() path.
  The 'dip' passed in is not the correct inode to retrieve ip->meta.inum
  from for the new inode's iparent.  Pass a second inode indicating the
  proper parent directory linkage for iparent.

* Remove ip->pip entirely.  Since the actual file/directory inodes are
  no longer heirarchical this field only creates confusion.  The two
  places where we really need it can simply use ip->meta.iparent.

  Also clean-out a considerable amount of code that previously dealt with
  ip->pip linkages and adjustments.

* Do not try to drop data on a 1->0 transition failure, this can race
  increments and cause the data to be improperly dropped.

* Do not try to drop data on lockcnt == 0 unless persist_refs is also 0.
  Fixes several SMP races where chain->data was being lost improperly.

* Cleanup the APIs for recent changes in how inodes work.

* Now passes buildworld test with /usr/src and /usr/obj mounted with NFS
  from a hammer2 volume.

kernel - Enhance debug.ncvp_debug debugging

* Enhance a debug kprintf for debugging a specific server-side situation
  with NFS.

mountd - Turn on SO_REUSEADDR

* Turn on SO_REUSEADDR because its kinda silly to not have it on.

* Fixes startup errors if mountd is restarted, or initially fails
  due to /etc/exports issues and is then restarted a little later.

kernel - Fix typo in ppoll entry in sys/kern/syscalls.

intr: Avoid implicit padding

procfs - Try to workaround issue to fix truss

* If PIOCWAIT is called and no process stops are present, silently return
  0 rather then EINVAL.

* Appears to fix the truss issue.

Reported-by: tkusumi

kernel - Implement PIE (place independent executables)

* Implement PIE placement and sysctl.  Currently disabled by default.
  If the sysctl kern.elf64.pie_base_mmap is set to 1, executable code
  will be mapped with a random shift.

* Also support fixed addresses if requested in the ELF header.

Submitted-by: shamaz
Testing-by: shamaz, dillon, with help from marino

hammer2 - Implement NFS export support

* Allow a hammer2 mount to be exported.  Implement required functionality:
  The export structure, fhtovp, vptofh, checkexp, and hammer2_vfs_vget.
  Uses the recent inode indexing changes.

* Also had to write some code to reconstruct the ip->pip linkages using
  iparent.

  Note that if possible I would like to remove the ip->pip stuff now that
  we have iparent, at least for files.  It won't work for hardlinks so...
  but its still in as of this writing.

hammer2 - Implement hammer2_inode_meta.iparent

* Implement the iparent field, which points to the inode number of
  the parent directory.  Remove the comment as this will be used
  by NFS (at least for directory inodes).

hammer2 - Change XOP feed/collect locking

* Change the way the backend passes chains back to the frontend.  Instead
  of requiring that the chain maintain a shared lock and bumping the lock
  count we use the new data retention feature to pass the chain back
  unlocked.

  This fixes a whole slew of deadlock issues related to multi-node
  synchronization.  Concurrent XOPs could previously obtain and hold
  locks on chains related to different nodes in any order, depending on
  when their related threads were scheduled.  Now that we no longer hold
  a lock in the XOP feed, the potential deadlocks should not be possible.

* Add new hammer2_chain_*() API functions for manipulating the data hold
  count and remove shims that were previously used to deal with the shared
  lock hacks.

* Also fix a chain->flags adjustment that wasn't atomic, fixing a tsleep()
  loop that was not breaking out.

libc/_collate_lookup: Fix segfault seen on ISO-8859-5 locales

The fix for the Russian collation issue seemed to have bug in it.
Segfault was discovered by Lauri Tirkkonen of Illumos and confirmed by
Bapt@FreeBSD.org.  Lauri suggested this as a fix, but as of this writing
Bapt hasn't confirmed that this is final solution for FreeBSD.  Due to
personal reasons, I cannot wait for this confirmation longer.  I believe
this fix is better than what is currently in place, even if it is not
the final solution.

mbsnrtowcs/wcsnrtombs: Fix EILSEQ handling

Originally reported on FreeBSD (PR 209907) by Roel Standaert, RockinRoel
noticed that DragonFly suffered the same bug.  When the title functions
encounter a character that cannot be converted, they should change the
src pointer to point to the character positioned immediately after the
failed character, but no such change was performed.

YellowRabbit improved on the FreeBSD patch addressing the bug with a
new version that eliminates possible NULL pointer dereferences.

Dragonfly-bug: <https://bugs.dragonflybsd.org/issues/2920>

kernel - Implement ppoll system call with precise microseconds timeout.

* Implement a maximum timeout of 2000s, because systimer(9) just accepts an
  int timeout in microseconds.

* Add kern.kv_sleep_threshold sysctl variable for tuning the threshold for
  the ppoll sleep duration (in nanoseconds), below which we will
  busy-loop with DELAY instead of using tsleep for waiting.

hammer2 - Start work on inode indexing - MAJOR CHANGE

A major change to how inodes work is required to allow NFS exports to be
supported and also to make mirroring operations optimal.  Both needs are
met by indexing most inodes so they can be looked up by inode number.  I've
tried to avoid having to do this for well over 2 years now but I finally
came to the conclusion that necessary features and efficiencies are
impossible without it.

+ For NFS exports we have to be able to lookup a file by inode number in
  order to be able to translate NFS file handles.

+ Mirroring, Multi-Master, and other Multi-Node operations are extremely
  inefficient when a large file or (even worse) some high-level directory
  is renamed, because the synchronization code cannot be made aware of the
  rename.  The synchronizer winds up making a copy of the file or the
  directory subhierarchy and that can be disaster if it winds up being
  terrabytes.

To solve these problems we treat nearly ALL directory entries as hardlink
targets and place the hardlink target at the root of the PFS.  This puts
nearly all inodes in a readily accessible place indexed by inode number.
This means we can now implement inode number lookups for NFS, and it also
means that the synchronizer does not have to copy anything when a file or
directory is renamed.

* Implement these changes by using an abbreviated version of the hardlink
  target code that we already have.  Get rid of the common-parent-directory
  code (we will use the PFS iroot), and force almost everything to be a
  hardlink.

* device nodes and softlinks are excepted.  These work as they did before,
  created in the directory entry itself and not as a hardlinked inode.
  I might have to make these hardlink targets in the future too but at
  the moment it looks avoidable.

* Unfortunately, this change creates a number of REGRESSIONS:

  (1) There are now two inodes per file instead of one.  The real inode
      indexed in the PFS root, and the hardlink pointer in the directory
      entry.  This eats another 1KB.

  (2) We lose a bunch of sequential layout optimizations (for the moment),
      particularly when stat()ing directory entries.

  (3) Inode creation and deletion ops will unfortunately cause more SMP
      conflicts due to all the inodes being indexed in one place.

nvme - Remove debugging

* Remove some debugging output.

nvme - Fix composite temperature in nvmectl

* Fix composite temperature reporting in nvmectl.  There are two byte
  fields making up a 16-word, not two separate byte fields.  The confusion
  stemmed from the fact that the 16-bit word is not word-aligned (possibly
  the only field in the entire spec that isn't aligned!).

* Add 'errors' directive to dump error logs.