Index: stable/11/Makefile.inc1
===================================================================
--- stable/11/Makefile.inc1	(revision 337332)
+++ stable/11/Makefile.inc1	(revision 337333)
@@ -1,2691 +1,2691 @@
 #
 # $FreeBSD$
 #
 # Make command line options:
 #	-DNO_CLEANDIR run ${MAKE} clean, instead of ${MAKE} cleandir
 #	-DNO_CLEAN do not clean at all
 #	-DDB_FROM_SRC use the user/group databases in src/etc instead of
 #	    the system database when installing.
 #	-DNO_SHARE do not go into share subdir
 #	-DKERNFAST define NO_KERNEL{CONFIG,CLEAN,OBJ}
 #	-DNO_KERNELCONFIG do not run config in ${MAKE} buildkernel
 #	-DNO_KERNELCLEAN do not run ${MAKE} clean in ${MAKE} buildkernel
 #	-DNO_KERNELOBJ do not run ${MAKE} obj in ${MAKE} buildkernel
 #	-DNO_PORTSUPDATE do not update ports in ${MAKE} update
 #	-DNO_ROOT install without using root privilege
 #	-DNO_DOCUPDATE do not update doc in ${MAKE} update
 #	-DWITHOUT_CTF do not run the DTrace CTF conversion tools on built objects
 #	LOCAL_DIRS="list of dirs" to add additional dirs to the SUBDIR list
 #	LOCAL_ITOOLS="list of tools" to add additional tools to the ITOOLS list
 #	LOCAL_LIB_DIRS="list of dirs" to add additional dirs to libraries target
 #	LOCAL_MTREE="list of mtree files" to process to allow local directories
 #	    to be created before files are installed
 #	LOCAL_TOOL_DIRS="list of dirs" to add additional dirs to the build-tools
 #	    list
 #	METALOG="path to metadata log" to write permission and ownership
 #	    when NO_ROOT is set.  (default: ${DESTDIR}/METALOG)
 #	TARGET="machine" to crossbuild world for a different machine type
 #	TARGET_ARCH= may be required when a TARGET supports multiple endians
 #	BUILDENV_SHELL= shell to launch for the buildenv target (def:${SHELL})
 #	WORLD_FLAGS= additional flags to pass to make(1) during buildworld
 #	KERNEL_FLAGS= additional flags to pass to make(1) during buildkernel
 #	SUBDIR_OVERRIDE="list of dirs" to build rather than everything.
 #	    All libraries and includes, and some build tools will still build.
 
 #
 # The intended user-driven targets are:
 # buildworld  - rebuild *everything*, including glue to help do upgrades
 # installworld- install everything built by "buildworld"
 # checkworld  - run test suite on installed world
 # doxygen     - build API documentation of the kernel
 # update      - convenient way to update your source tree (eg: svn/svnup)
 #
 # Standard targets (not defined here) are documented in the makefiles in
 # /usr/share/mk.  These include:
 #		obj depend all install clean cleandepend cleanobj
 
 .if !defined(TARGET) || !defined(TARGET_ARCH)
 .error "Both TARGET and TARGET_ARCH must be defined."
 .endif
 
 SRCDIR?=	${.CURDIR}
 LOCALBASE?=	/usr/local
 
 # Cross toolchain changes must be in effect before bsd.compiler.mk
 # so that gets the right CC, and pass CROSS_TOOLCHAIN to submakes.
 .if defined(CROSS_TOOLCHAIN)
 .include "${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk"
 CROSSENV+=CROSS_TOOLCHAIN="${CROSS_TOOLCHAIN}"
 .endif
 .if defined(CROSS_TOOLCHAIN_PREFIX)
 CROSS_COMPILER_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
 .endif
 
 XCOMPILERS=	CC CXX CPP
 .for COMPILER in ${XCOMPILERS}
 .if defined(CROSS_COMPILER_PREFIX)
 X${COMPILER}?=	${CROSS_COMPILER_PREFIX}${${COMPILER}}
 .else
 X${COMPILER}?=	${${COMPILER}}
 .endif
 .endfor
 # If a full path to an external cross compiler is given, don't build
 # a cross compiler.
 .if ${XCC:N${CCACHE_BIN}:M/*}
 MK_CLANG_BOOTSTRAP=	no
 MK_GCC_BOOTSTRAP=	no
 .endif
 
 MAKEOBJDIRPREFIX?=	/usr/obj
 .if ${MACHINE} == ${TARGET} && ${MACHINE_ARCH} == ${TARGET_ARCH} && !defined(CROSS_BUILD_TESTING)
 OBJTREE=	${MAKEOBJDIRPREFIX}
 .else
 OBJTREE=	${MAKEOBJDIRPREFIX}/${TARGET}.${TARGET_ARCH}
 .endif
 
 # Pull in compiler metadata from buildworld/toolchain if possible to avoid
 # running CC from bsd.compiler.mk.
 .if make(installworld) || make(install)
 .-include "${OBJTREE}${.CURDIR}/compiler-metadata.mk"
 .endif
 
 # Pull in COMPILER_TYPE and COMPILER_FREEBSD_VERSION early.
 .include <bsd.compiler.mk>
 .include "share/mk/src.opts.mk"
 
 # Check if there is a local compiler that can satisfy as an external compiler.
 # Which compiler is expected to be used?
 .if ${MK_CLANG_BOOTSTRAP} == "yes"
 WANT_COMPILER_TYPE=	clang
 .elif ${MK_GCC_BOOTSTRAP} == "yes"
 WANT_COMPILER_TYPE=	gcc
 .else
 WANT_COMPILER_TYPE=
 .endif
 .if !defined(WANT_COMPILER_FREEBSD_VERSION)
 .if ${WANT_COMPILER_TYPE} == "clang"
 WANT_COMPILER_FREEBSD_VERSION_FILE= lib/clang/freebsd_cc_version.h
 WANT_COMPILER_FREEBSD_VERSION!= \
 	awk '$$2 == "FREEBSD_CC_VERSION" {printf("%d\n", $$3)}' \
 	${SRCDIR}/${WANT_COMPILER_FREEBSD_VERSION_FILE} || echo unknown
 WANT_COMPILER_VERSION_FILE= lib/clang/include/clang/Basic/Version.inc
 WANT_COMPILER_VERSION!= \
 	awk '$$2 == "CLANG_VERSION" {split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
 	${SRCDIR}/${WANT_COMPILER_VERSION_FILE} || echo unknown
 .elif ${WANT_COMPILER_TYPE} == "gcc"
 WANT_COMPILER_FREEBSD_VERSION_FILE= gnu/usr.bin/cc/cc_tools/freebsd-native.h
 WANT_COMPILER_FREEBSD_VERSION!= \
 	awk '$$2 == "FBSD_CC_VER" {printf("%d\n", $$3)}' \
 	${SRCDIR}/${WANT_COMPILER_FREEBSD_VERSION_FILE} || echo unknown
 WANT_COMPILER_VERSION_FILE= contrib/gcc/BASE-VER
 WANT_COMPILER_VERSION!= \
 	awk -F. '{print $$1 * 10000 + $$2 * 100 + $$3}' \
 	${SRCDIR}/${WANT_COMPILER_VERSION_FILE} || echo unknown
 .endif
 .export WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_VERSION
 .endif	# !defined(WANT_COMPILER_FREEBSD_VERSION)
 # It needs to be the same revision as we would build for the bootstrap.
 # If the expected vs CC is different then we can't skip.
 # GCC cannot be used for cross-arch yet.  For clang we pass -target later if
 # TARGET_ARCH!=MACHINE_ARCH.
 .if ${MK_SYSTEM_COMPILER} == "yes" && \
     (${MK_CLANG_BOOTSTRAP} == "yes" || ${MK_GCC_BOOTSTRAP} == "yes") && \
     !make(showconfig) && !make(native-xtools) && !make(xdev*) && \
     ${WANT_COMPILER_TYPE} == ${COMPILER_TYPE} && \
     (${COMPILER_TYPE} == "clang" || ${TARGET_ARCH} == ${MACHINE_ARCH}) && \
     ${COMPILER_VERSION} == ${WANT_COMPILER_VERSION} && \
     ${COMPILER_FREEBSD_VERSION} == ${WANT_COMPILER_FREEBSD_VERSION}
 # Everything matches, disable the bootstrap compiler.
 MK_CLANG_BOOTSTRAP=	no
 MK_GCC_BOOTSTRAP=	no
 USING_SYSTEM_COMPILER=	yes
 .endif	# ${WANT_COMPILER_TYPE} == ${COMPILER_TYPE}
 USING_SYSTEM_COMPILER?=	no
 TEST_SYSTEM_COMPILER_VARS= \
 	USING_SYSTEM_COMPILER MK_SYSTEM_COMPILER \
 	MK_CROSS_COMPILER MK_CLANG_BOOTSTRAP MK_GCC_BOOTSTRAP \
 	WANT_COMPILER_TYPE WANT_COMPILER_VERSION WANT_COMPILER_VERSION_FILE \
 	WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_FREEBSD_VERSION_FILE \
 	CC COMPILER_TYPE COMPILER_FEATURES COMPILER_VERSION \
 	COMPILER_FREEBSD_VERSION \
 	LINKER_TYPE LINKER_FEATURES LINKER_VERSION
 test-system-compiler: .PHONY
 .for v in ${TEST_SYSTEM_COMPILER_VARS}
 	${_+_}@printf "%-35s= %s\n" "${v}" "${${v}}"
 .endfor
 .if ${USING_SYSTEM_COMPILER} == "yes" && \
     (make(buildworld) || make(buildkernel) || make(kernel-toolchain) || \
     make(toolchain) || make(_cross-tools))
 .info SYSTEM_COMPILER: Determined that CC=${CC} matches the source tree.  Not bootstrapping a cross-compiler.
 .endif
 
 # For installworld need to ensure that the looked-up compiler metadata is
 # passed along rather than trying to run cc from the restricted
 # STRICTTMPPATH.
 .if ${MK_CLANG_BOOTSTRAP} == "no" && ${MK_GCC_BOOTSTRAP} == "no"
 .if !defined(X_COMPILER_TYPE)
 CROSSENV+=	COMPILER_VERSION=${COMPILER_VERSION} \
 		COMPILER_TYPE=${COMPILER_TYPE} \
 		COMPILER_FEATURES="${COMPILER_FEATURES}" \
 		COMPILER_FREEBSD_VERSION=${COMPILER_FREEBSD_VERSION}
 .else
 CROSSENV+=	COMPILER_VERSION=${X_COMPILER_VERSION} \
 		COMPILER_FEATURES="${X_COMPILER_FEATURES}" \
 		COMPILER_TYPE=${X_COMPILER_TYPE} \
 		COMPILER_FREEBSD_VERSION=${X_COMPILER_FREEBSD_VERSION}
 .endif
 .endif
 # Store some compiler metadata for use in installworld where we don't
 # want to invoke CC at all.
 _COMPILER_METADATA_VARS=	COMPILER_VERSION \
 				COMPILER_TYPE \
 				COMPILER_FEATURES \
 				COMPILER_FREEBSD_VERSION \
 				LINKER_VERSION \
 				LINKER_FEATURES \
 				LINKER_TYPE
 compiler-metadata.mk: .PHONY .META
 	@: > ${.TARGET}
 	@echo ".info Using cached compiler metadata from build at $$(hostname) on $$(date)" \
 	    > ${.TARGET}
 .for v in ${_COMPILER_METADATA_VARS}
 	@echo "${v}=${${v}}" >> ${.TARGET}
 .endfor
 	@echo ".export ${_COMPILER_METADATA_VARS}" >> ${.TARGET}
 
 # Handle external binutils.
 .if defined(CROSS_TOOLCHAIN_PREFIX)
 CROSS_BINUTILS_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
 .endif
 # If we do not have a bootstrap binutils (because the in-tree one does not
 # support the target architecture), provide a default cross-binutils prefix.
 # This allows riscv64 builds, for example, to automatically use the
 # riscv64-binutils port or package.
 .if !make(showconfig)
 .if !empty(BROKEN_OPTIONS:MBINUTILS_BOOTSTRAP) && \
     ${MK_LLD_BOOTSTRAP} == "no" && \
     !defined(CROSS_BINUTILS_PREFIX)
 CROSS_BINUTILS_PREFIX=/usr/local/${TARGET_ARCH}-freebsd/bin/
 .if !exists(${CROSS_BINUTILS_PREFIX})
 .error In-tree binutils does not support the ${TARGET_ARCH} architecture. Install the ${TARGET_ARCH}-binutils port or package or set CROSS_BINUTILS_PREFIX.
 .endif
 .endif
 .endif
 XBINUTILS=	AS AR LD NM OBJCOPY OBJDUMP RANLIB SIZE STRINGS
 .for BINUTIL in ${XBINUTILS}
 .if defined(CROSS_BINUTILS_PREFIX) && \
     exists(${CROSS_BINUTILS_PREFIX}${${BINUTIL}})
 X${BINUTIL}?=	${CROSS_BINUTILS_PREFIX}${${BINUTIL}}
 .else
 X${BINUTIL}?=	${${BINUTIL}}
 .endif
 .endfor
 
 
 # We must do lib/ and libexec/ before bin/ in case of a mid-install error to
 # keep the users system reasonably usable.  For static->dynamic root upgrades,
 # we don't want to install a dynamic binary without rtld and the needed
 # libraries.  More commonly, for dynamic root, we don't want to install a
 # binary that requires a newer library version that hasn't been installed yet.
 # This ordering is not a guarantee though.  The only guarantee of a working
 # system here would require fine-grained ordering of all components based
 # on their dependencies.
 .if !empty(SUBDIR_OVERRIDE)
 SUBDIR=	${SUBDIR_OVERRIDE}
 .else
 SUBDIR=	lib libexec
 # Add LOCAL_LIB_DIRS, but only if they will not be picked up as a SUBDIR
 # of a LOCAL_DIRS directory.  This allows LOCAL_DIRS=foo and
 # LOCAL_LIB_DIRS=foo/lib to behave as expected.
 .for _DIR in ${LOCAL_DIRS:M*/} ${LOCAL_DIRS:N*/:S|$|/|}
 _REDUNDANT_LIB_DIRS+=    ${LOCAL_LIB_DIRS:M${_DIR}*}
 .endfor
 .for _DIR in ${LOCAL_LIB_DIRS}
 .if ${_DIR} == ".WAIT" || (empty(_REDUNDANT_LIB_DIRS:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile))
 SUBDIR+=	${_DIR}
 .endif
 .endfor
 .if !defined(NO_ROOT) && (make(installworld) || make(install))
 # Ensure libraries are installed before progressing.
 SUBDIR+=.WAIT
 .endif
 SUBDIR+=bin
 .if ${MK_CDDL} != "no"
 SUBDIR+=cddl
 .endif
 SUBDIR+=gnu include
 .if ${MK_KERBEROS} != "no"
 SUBDIR+=kerberos5
 .endif
 .if ${MK_RESCUE} != "no"
 SUBDIR+=rescue
 .endif
 SUBDIR+=sbin
 .if ${MK_CRYPT} != "no"
 SUBDIR+=secure
 .endif
 .if !defined(NO_SHARE)
 SUBDIR+=share
 .endif
 .if ${MK_BOOT} != "no"
 SUBDIR+=stand
 .endif
 SUBDIR+=sys usr.bin usr.sbin
 .if ${MK_TESTS} != "no"
 SUBDIR+=	tests
 .endif
 
 # Local directories are built in parallel with the base system directories.
 # Users may insert a .WAIT directive at the beginning or elsewhere within
 # the LOCAL_DIRS and LOCAL_LIB_DIRS lists as needed.
 .for _DIR in ${LOCAL_DIRS}
 .if ${_DIR} == ".WAIT" || exists(${.CURDIR}/${_DIR}/Makefile)
 SUBDIR+=	${_DIR}
 .endif
 .endfor
 
 # We must do etc/ last as it hooks into building the man whatis file
 # by calling 'makedb' in share/man.  This is only relevant for
 # install/distribute so they build the whatis file after every manpage is
 # installed.
 .if make(installworld) || make(install)
 SUBDIR+=.WAIT
 .endif
 SUBDIR+=etc
 
 .endif	# !empty(SUBDIR_OVERRIDE)
 
 .if defined(NOCLEAN)
 .warning NOCLEAN option is deprecated. Use NO_CLEAN instead.
 NO_CLEAN=	${NOCLEAN}
 .endif
 .if defined(NO_CLEANDIR)
 CLEANDIR=	clean cleandepend
 .else
 CLEANDIR=	cleandir
 .endif
 
 .if ${MK_META_MODE} == "yes"
 # If filemon is used then we can rely on the build being incremental-safe.
 # The .meta files will also track the build command and rebuild should
 # it change.
 .if empty(.MAKE.MODE:Mnofilemon)
 NO_CLEAN=	t
 .endif
 .endif
 
 LOCAL_TOOL_DIRS?=
 PACKAGEDIR?=	${DESTDIR}/${DISTDIR}
 
 .if empty(SHELL:M*csh*)
 BUILDENV_SHELL?=${SHELL}
 .else
 BUILDENV_SHELL?=/bin/sh
 .endif
 
 .if !defined(SVN) || empty(SVN)
 . for _P in /usr/bin /usr/local/bin
 .  for _S in svn svnlite
 .   if exists(${_P}/${_S})
 SVN=   ${_P}/${_S}
 .   endif
 .  endfor
 . endfor
 .endif
 SVNFLAGS?=	-r HEAD
 
 .if !defined(OSRELDATE)
 .if exists(/usr/include/osreldate.h)
 OSRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
 		/usr/include/osreldate.h
 .else
 OSRELDATE=	0
 .endif
 .export OSRELDATE
 .endif
 
 # Set VERSION for CTFMERGE to use via the default CTFFLAGS=-L VERSION.
 .if !defined(_REVISION)
 _REVISION!=	MK_AUTO_OBJ=no ${MAKE} -C ${SRCDIR}/release -V REVISION
 .export _REVISION
 .endif
 .if !defined(_BRANCH)
 _BRANCH!=	MK_AUTO_OBJ=no ${MAKE} -C ${SRCDIR}/release -V BRANCH
 .export _BRANCH
 .endif
 .if !defined(SRCRELDATE)
 SRCRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
 		${SRCDIR}/sys/sys/param.h
 .export SRCRELDATE
 .endif
 .if !defined(VERSION)
 VERSION=	FreeBSD ${_REVISION}-${_BRANCH:C/-p[0-9]+$//} ${TARGET_ARCH} ${SRCRELDATE}
 .export VERSION
 .endif
 
 .if !defined(PKG_VERSION)
 .if ${_BRANCH:MSTABLE*} || ${_BRANCH:MCURRENT*} || ${_BRANCH:MALPHA*}
 TIMENOW=	%Y%m%d%H%M%S
 EXTRA_REVISION=	.s${TIMENOW:gmtime}
 .endif
 .if ${_BRANCH:M*-p*}
 EXTRA_REVISION=	_${_BRANCH:C/.*-p([0-9]+$)/\1/}
 .endif
 PKG_VERSION=	${_REVISION}${EXTRA_REVISION}
 .endif
 
 KNOWN_ARCHES?=	aarch64/arm64 \
 		amd64 \
 		arm \
 		armeb/arm \
 		armv6/arm \
 		i386 \
 		i386/pc98 \
 		mips \
 		mipsel/mips \
 		mips64el/mips \
 		mipsn32el/mips \
 		mips64/mips \
 		mipsn32/mips \
 		powerpc \
 		powerpc64/powerpc \
 		riscv64/riscv \
 		sparc64
 
 .if ${TARGET} == ${TARGET_ARCH}
 _t=		${TARGET}
 .else
 _t=		${TARGET_ARCH}/${TARGET}
 .endif
 .for _t in ${_t}
 .if empty(KNOWN_ARCHES:M${_t})
 .error Unknown target ${TARGET_ARCH}:${TARGET}.
 .endif
 .endfor
 
 .if ${TARGET} == ${MACHINE}
 TARGET_CPUTYPE?=${CPUTYPE}
 .else
 TARGET_CPUTYPE?=
 .endif
 
 .if !empty(TARGET_CPUTYPE)
 _TARGET_CPUTYPE=${TARGET_CPUTYPE}
 .else
 _TARGET_CPUTYPE=dummy
 .endif
 _CPUTYPE!=	MK_AUTO_OBJ=no MAKEFLAGS= CPUTYPE=${_TARGET_CPUTYPE} ${MAKE} \
 		-f /dev/null -m ${.CURDIR}/share/mk -V CPUTYPE
 .if ${_CPUTYPE} != ${_TARGET_CPUTYPE}
 .error CPUTYPE global should be set with ?=.
 .endif
 .if make(buildworld)
 BUILD_ARCH!=	uname -p
 .if ${MACHINE_ARCH} != ${BUILD_ARCH}
 .error To cross-build, set TARGET_ARCH.
 .endif
 .endif
 WORLDTMP=	${OBJTREE}${.CURDIR}/tmp
 BPATH=		${WORLDTMP}/legacy/usr/sbin:${WORLDTMP}/legacy/usr/bin:${WORLDTMP}/legacy/bin
 XPATH=		${WORLDTMP}/usr/sbin:${WORLDTMP}/usr/bin
 STRICTTMPPATH=	${BPATH}:${XPATH}
 TMPPATH=	${STRICTTMPPATH}:${PATH}
 
 #
 # Avoid running mktemp(1) unless actually needed.
 # It may not be functional, e.g., due to new ABI
 # when in the middle of installing over this system.
 #
 .if make(distributeworld) || make(installworld) || make(stageworld)
 INSTALLTMP!=	/usr/bin/mktemp -d -u -t install
 .endif
 
 .if make(stagekernel) || make(distributekernel)
 TAGS+=		kernel
 PACKAGE=	kernel
 .endif
 
 #
 # Building a world goes through the following stages
 #
 # 1. legacy stage [BMAKE]
 #	This stage is responsible for creating compatibility
 #	shims that are needed by the bootstrap-tools,
 #	build-tools and cross-tools stages. These are generally
 #	APIs that tools from one of those three stages need to
 #	build that aren't present on the host.
 # 1. bootstrap-tools stage [BMAKE]
 #	This stage is responsible for creating programs that
 #	are needed for backward compatibility reasons. They
 #	are not built as cross-tools.
 # 2. build-tools stage [TMAKE]
 #	This stage is responsible for creating the object
 #	tree and building any tools that are needed during
 #	the build process. Some programs are listed during
 #	this phase because they build binaries to generate
 #	files needed to build these programs. This stage also
 #	builds the 'build-tools' target rather than 'all'.
 # 3. cross-tools stage [XMAKE]
 #	This stage is responsible for creating any tools that
 #	are needed for building the system. A cross-compiler is one
 #	of them. This differs from build tools in two ways:
 #	1. the 'all' target is built rather than 'build-tools'
 #	2. these tools are installed into TMPPATH for stage 4.
 # 4. world stage [WMAKE]
 #	This stage actually builds the world.
 # 5. install stage (optional) [IMAKE]
 #	This stage installs a previously built world.
 #
 
 BOOTSTRAPPING?=	0
 # Keep these in sync
 MINIMUM_SUPPORTED_OSREL?= 900044
 MINIMUM_SUPPORTED_REL?= 9.1
 
 # Common environment for world related stages
 CROSSENV+=	MAKEOBJDIRPREFIX=${OBJTREE} \
 		MACHINE_ARCH=${TARGET_ARCH} \
 		MACHINE=${TARGET} \
 		CPUTYPE=${TARGET_CPUTYPE}
 .if ${MK_META_MODE} != "no"
 # Don't rebuild build-tools targets during normal build.
 CROSSENV+=	BUILD_TOOLS_META=.NOMETA
 .endif
 .if ${MK_GROFF} != "no"
 CROSSENV+=	GROFF_BIN_PATH=${WORLDTMP}/legacy/usr/bin \
 		GROFF_FONT_PATH=${WORLDTMP}/legacy/usr/share/groff_font \
 		GROFF_TMAC_PATH=${WORLDTMP}/legacy/usr/share/tmac
 .endif
 .if defined(TARGET_CFLAGS)
 CROSSENV+=	${TARGET_CFLAGS}
 .endif
 
 # bootstrap-tools stage
 BMAKEENV=	INSTALL="sh ${.CURDIR}/tools/install.sh" \
 		TOOLS_PREFIX=${WORLDTMP} \
 		PATH=${BPATH}:${PATH} \
 		WORLDTMP=${WORLDTMP} \
 		MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}"
 # need to keep this in sync with targets/pseudo/bootstrap-tools/Makefile
 BSARGS= 	DESTDIR= \
 		BOOTSTRAPPING=${OSRELDATE} \
 		SSP_CFLAGS= \
 		MK_HTML=no NO_LINT=yes MK_MAN=no \
 		-DNO_PIC MK_PROFILE=no -DNO_SHARED \
 		-DNO_CPU_CFLAGS MK_WARNS=no MK_CTF=no \
 		MK_CLANG_EXTRAS=no MK_CLANG_FULL=no \
 		MK_LLDB=no MK_TESTS=no \
 		MK_INCLUDES=yes
 
 BMAKE=		MAKEOBJDIRPREFIX=${WORLDTMP} \
 		${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
 		${BSARGS}
 
 # build-tools stage
 TMAKE=		MAKEOBJDIRPREFIX=${OBJTREE} \
 		${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
 		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
 		DESTDIR= \
 		BOOTSTRAPPING=${OSRELDATE} \
 		SSP_CFLAGS= \
 		-DNO_LINT \
 		-DNO_CPU_CFLAGS MK_WARNS=no MK_CTF=no \
 		MK_CLANG_EXTRAS=no MK_CLANG_FULL=no \
 		MK_LLDB=no MK_TESTS=no
 
 # cross-tools stage
 XMAKE=		TOOLS_PREFIX=${WORLDTMP} ${BMAKE} \
 		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
 		MK_GDB=no MK_TESTS=no
 
 # kernel-tools stage
 KTMAKEENV=	INSTALL="sh ${.CURDIR}/tools/install.sh" \
 		PATH=${BPATH}:${PATH} \
 		WORLDTMP=${WORLDTMP}
 KTMAKE=		TOOLS_PREFIX=${WORLDTMP} MAKEOBJDIRPREFIX=${WORLDTMP} \
 		${KTMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
 		DESTDIR= \
 		BOOTSTRAPPING=${OSRELDATE} \
 		SSP_CFLAGS= \
 		MK_HTML=no -DNO_LINT MK_MAN=no \
 		-DNO_PIC MK_PROFILE=no -DNO_SHARED \
 		-DNO_CPU_CFLAGS MK_WARNS=no MK_CTF=no
 
 # world stage
 WMAKEENV=	${CROSSENV} \
 		INSTALL="sh ${.CURDIR}/tools/install.sh" \
 		PATH=${TMPPATH}
 
 # make hierarchy
 HMAKE=		PATH=${TMPPATH} ${MAKE} LOCAL_MTREE=${LOCAL_MTREE:Q}
 .if defined(NO_ROOT)
 HMAKE+=		PATH=${TMPPATH} METALOG=${METALOG} -DNO_ROOT
 .endif
 
 CROSSENV+=	CC="${XCC} ${XCFLAGS}" CXX="${XCXX} ${XCXXFLAGS} ${XCFLAGS}" \
 		CPP="${XCPP} ${XCFLAGS}" \
 		AS="${XAS}" AR="${XAR}" LD="${XLD}" NM=${XNM} \
 		OBJDUMP=${XOBJDUMP} OBJCOPY="${XOBJCOPY}" \
 		RANLIB=${XRANLIB} STRINGS=${XSTRINGS} \
 		SIZE="${XSIZE}"
 
 .if defined(CROSS_BINUTILS_PREFIX) && exists(${CROSS_BINUTILS_PREFIX})
 # In the case of xdev-build tools, CROSS_BINUTILS_PREFIX won't be a
 # directory, but the compiler will look in the right place for its
 # tools so we don't need to tell it where to look.
 BFLAGS+=	-B${CROSS_BINUTILS_PREFIX}
 .endif
 
 # External compiler needs sysroot and target flags.
 .if ${MK_CLANG_BOOTSTRAP} == "no" && ${MK_GCC_BOOTSTRAP} == "no"
 .if !defined(CROSS_BINUTILS_PREFIX) || !exists(${CROSS_BINUTILS_PREFIX})
 BFLAGS+=	-B${WORLDTMP}/usr/bin
 .endif
 .if ${TARGET} == "arm"
 .if ${TARGET_ARCH:Marmv6*} != "" && ${TARGET_CPUTYPE:M*soft*} == ""
 TARGET_ABI=	gnueabihf
 .else
 TARGET_ABI=	gnueabi
 .endif
 .endif
 .if defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc
 # GCC requires -isystem and -L when using a cross-compiler.  --sysroot
 # won't set header path and -L is used to ensure the base library path
 # is added before the port PREFIX library path.
 XCFLAGS+=	-isystem ${WORLDTMP}/usr/include -L${WORLDTMP}/usr/lib
 # Force using libc++ for external GCC.
 .if ${X_COMPILER_TYPE} == gcc && ${X_COMPILER_VERSION} >= 40800
 XCXXFLAGS+=	-isystem ${WORLDTMP}/usr/include/c++/v1 -std=c++11 \
 		-nostdinc++ -L${WORLDTMP}/../lib/libc++
 .endif
 .else
 TARGET_ABI?=	unknown
 TARGET_TRIPLE?=	${TARGET_ARCH:C/amd64/x86_64/}-${TARGET_ABI}-freebsd11.2
 XCFLAGS+=	-target ${TARGET_TRIPLE}
 .endif
 XCFLAGS+=	--sysroot=${WORLDTMP}
 .endif # ${MK_CLANG_BOOTSTRAP} == "no" && ${MK_GCC_BOOTSTRAP} == "no"
 
 .if !empty(BFLAGS)
 XCFLAGS+=	${BFLAGS}
 .endif
 
 .if ${MK_LIB32} != "no" && (${TARGET_ARCH} == "amd64" || \
     ${TARGET_ARCH} == "powerpc64")
 LIBCOMPAT= 32
 .include "Makefile.libcompat"
 .elif ${MK_LIBSOFT} != "no" && ${TARGET_ARCH} == "armv6"
 LIBCOMPAT= SOFT
 .include "Makefile.libcompat"
 .endif
 
 WMAKE=		${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 DESTDIR=${WORLDTMP}
 
 IMAKEENV=	${CROSSENV}
 IMAKE=		${IMAKEENV} ${MAKE} -f Makefile.inc1 \
 		${IMAKE_INSTALL} ${IMAKE_MTREE}
 .if empty(.MAKEFLAGS:M-n)
 IMAKEENV+=	PATH=${STRICTTMPPATH}:${INSTALLTMP} \
 		LD_LIBRARY_PATH=${INSTALLTMP} \
 		PATH_LOCALE=${INSTALLTMP}/locale
 IMAKE+=		__MAKE_SHELL=${INSTALLTMP}/sh
 .else
 IMAKEENV+=	PATH=${TMPPATH}:${INSTALLTMP}
 .endif
 .if defined(DB_FROM_SRC)
 INSTALLFLAGS+=	-N ${.CURDIR}/etc
 MTREEFLAGS+=	-N ${.CURDIR}/etc
 .endif
 _INSTALL_DDIR=	${DESTDIR}/${DISTDIR}
 INSTALL_DDIR=	${_INSTALL_DDIR:S://:/:g:C:/$::}
 .if defined(NO_ROOT)
 METALOG?=	${DESTDIR}/${DISTDIR}/METALOG
 METALOG:=	${METALOG:C,//+,/,g}
 IMAKE+=		-DNO_ROOT METALOG=${METALOG}
 INSTALLFLAGS+=	-U -M ${METALOG} -D ${INSTALL_DDIR}
 MTREEFLAGS+=	-W
 .endif
 .if defined(BUILD_PKGS)
 INSTALLFLAGS+=	-h sha256
 .endif
 .if defined(DB_FROM_SRC) || defined(NO_ROOT)
 IMAKE_INSTALL=	INSTALL="install ${INSTALLFLAGS}"
 IMAKE_MTREE=	MTREE_CMD="mtree ${MTREEFLAGS}"
 .endif
 
 # kernel stage
 KMAKEENV=	${WMAKEENV}
 KMAKE=		${KMAKEENV} ${MAKE} ${.MAKEFLAGS} ${KERNEL_FLAGS} KERNEL=${INSTKERNNAME}
 
 #
 # buildworld
 #
 # Attempt to rebuild the entire system, with reasonable chance of
 # success, regardless of how old your existing system is.
 #
 _worldtmp: .PHONY
 .if ${.CURDIR:C/[^,]//g} != ""
 #	The m4 build of sendmail files doesn't like it if ',' is used
 #	anywhere in the path of it's files.
 	@echo
 	@echo "*** Error: path to source tree contains a comma ','"
 	@echo
 	false
 .endif
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Rebuilding the temporary build tree"
 	@echo "--------------------------------------------------------------"
 .if !defined(NO_CLEAN)
 	rm -rf ${WORLDTMP}
 .if defined(LIBCOMPAT)
 	rm -rf ${LIBCOMPATTMP}
 .endif
 .else
 	rm -rf ${WORLDTMP}/legacy/usr/include
 .if ${USING_SYSTEM_COMPILER} == "yes"
 .for cc in cc c++
 	if [ -x ${WORLDTMP}/usr/bin/${cc} ]; then \
 		inum=$$(stat -f %i ${WORLDTMP}/usr/bin/${cc}); \
 		find ${WORLDTMP}/usr/bin -inum $${inum} -delete; \
 	fi
 .endfor
 .endif	# ${USING_SYSTEM_COMPILER} == "yes"
 .endif	# !defined(NO_CLEAN)
 .for _dir in \
     lib lib/casper usr legacy/bin legacy/usr
 	mkdir -p ${WORLDTMP}/${_dir}
 .endfor
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${WORLDTMP}/legacy/usr >/dev/null
 .if ${MK_GROFF} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.groff.dist \
 	    -p ${WORLDTMP}/legacy/usr >/dev/null
 .endif
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${WORLDTMP}/legacy/usr/include >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${WORLDTMP}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${WORLDTMP}/usr/include >/dev/null
 	ln -sf ${.CURDIR}/sys ${WORLDTMP}
 .if ${MK_DEBUG_FILES} != "no"
 	# We could instead disable debug files for these build stages
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${WORLDTMP}/legacy/usr/lib >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${WORLDTMP}/usr/lib >/dev/null
 .endif
 .if defined(LIBCOMPAT)
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
 	    -p ${WORLDTMP}/usr >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
 	    -p ${WORLDTMP}/legacy/usr/lib/debug/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
 	    -p ${WORLDTMP}/usr/lib/debug/usr >/dev/null
 .endif
 .endif
 .if ${MK_TESTS} != "no"
 	mkdir -p ${WORLDTMP}${TESTSBASE}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
 	    -p ${WORLDTMP}${TESTSBASE} >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mkdir -p ${WORLDTMP}/usr/lib/debug/${TESTSBASE}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
 	    -p ${WORLDTMP}/usr/lib/debug/${TESTSBASE} >/dev/null
 .endif
 .endif
 .for _mtree in ${LOCAL_MTREE}
 	mtree -deU -f ${.CURDIR}/${_mtree} -p ${WORLDTMP} > /dev/null
 .endfor
 _legacy:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 1.1: legacy release compatibility shims"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${BMAKE} legacy
 _bootstrap-tools:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 1.2: bootstrap tools"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${BMAKE} bootstrap-tools
 _cleanobj:
 .if !defined(NO_CLEAN)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.1: cleaning up the object tree"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} ${CLEANDIR}
 .if defined(LIBCOMPAT)
 	${_+_}cd ${.CURDIR}; ${LIBCOMPATWMAKE} -f Makefile.inc1 ${CLEANDIR}
 .endif
 .endif
 _obj:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.2: rebuilding the object tree"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} obj
 _build-tools:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.3: build tools"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${TMAKE} build-tools
 _cross-tools:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 3: cross tools"
 	@echo "--------------------------------------------------------------"
 	@rm -f ${.OBJDIR}/compiler-metadata.mk
 	${_+_}cd ${.CURDIR}; ${XMAKE} cross-tools
 	${_+_}cd ${.CURDIR}; ${XMAKE} kernel-tools
 _compiler-metadata:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 3.1: recording compiler metadata"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} compiler-metadata.mk
 _includes:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 4.1: building includes"
 	@echo "--------------------------------------------------------------"
 # Special handling for SUBDIR_OVERRIDE in buildworld as they most likely need
 # headers from default SUBDIR.  Do SUBDIR_OVERRIDE includes last.
 	${_+_}cd ${.CURDIR}; ${WMAKE} SUBDIR_OVERRIDE= SHARED=symlinks \
 	    MK_INCLUDES=yes includes
 .if !empty(SUBDIR_OVERRIDE) && make(buildworld)
 	${_+_}cd ${.CURDIR}; ${WMAKE} MK_INCLUDES=yes SHARED=symlinks includes
 .endif
 _libraries:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 4.2: building libraries"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; \
 	    ${WMAKE} -DNO_FSCHG MK_HTML=no -DNO_LINT MK_MAN=no \
 	    MK_PROFILE=no MK_TESTS=no MK_TESTS_SUPPORT=${MK_TESTS} libraries
 everything: .PHONY
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 4.3: building everything"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; _PARALLEL_SUBDIR_OK=1 ${WMAKE} all
 
 WMAKE_TGTS=
 WMAKE_TGTS+=	_worldtmp _legacy
 .if empty(SUBDIR_OVERRIDE)
 WMAKE_TGTS+=	_bootstrap-tools
 .endif
 WMAKE_TGTS+=	_cleanobj _obj _build-tools _cross-tools
 WMAKE_TGTS+=	_compiler-metadata
 WMAKE_TGTS+=	_includes _libraries
 WMAKE_TGTS+=	everything
 .if defined(LIBCOMPAT) && empty(SUBDIR_OVERRIDE)
 WMAKE_TGTS+=	build${libcompat}
 .endif
 
 buildworld: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue .PHONY
 .ORDER: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue
 
 buildworld_prologue: .PHONY
 	@echo "--------------------------------------------------------------"
 	@echo ">>> World build started on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 
 buildworld_epilogue: .PHONY
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> World build completed on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 
 #
 # We need to have this as a target because the indirection between Makefile
 # and Makefile.inc1 causes the correct PATH to be used, rather than a
 # modification of the current environment's PATH.  In addition, we need
 # to quote multiword values.
 #
 buildenvvars: .PHONY
 	@echo ${WMAKEENV:Q} ${.MAKE.EXPORTED:@v@$v=\"${$v}\"@}
 
 .if ${.TARGETS:Mbuildenv}
 .if ${.MAKEFLAGS:M-j}
 .error The buildenv target is incompatible with -j
 .endif
 .endif
 BUILDENV_DIR?=	${.CURDIR}
 #
 # Note: make will report any errors the shell reports. This can
 # be odd if the last command in an interactive shell generates an
 # error or is terminated by SIGINT. These reported errors look bad,
 # but are harmless. Allowing them also allows BUIDLENV_SHELL to
 # be a complex command whose status will be returned to the caller.
 # Some scripts in tools rely on this behavior to report build errors.
 #
 buildenv: .PHONY
 	@echo Entering world for ${TARGET_ARCH}:${TARGET}
 .if ${BUILDENV_SHELL:M*zsh*}
 	@echo For ZSH you must run: export CPUTYPE=${TARGET_CPUTYPE}
 .endif
 	@cd ${BUILDENV_DIR} && env ${WMAKEENV} BUILDENV=1 ${BUILDENV_SHELL}
 
 TOOLCHAIN_TGTS=	${WMAKE_TGTS:Neverything:Nbuild${libcompat}}
 toolchain: ${TOOLCHAIN_TGTS} .PHONY
 kernel-toolchain: ${TOOLCHAIN_TGTS:N_includes:N_libraries} .PHONY
 
 #
 # installcheck
 #
 # Checks to be sure system is ready for installworld/installkernel.
 #
 installcheck: _installcheck_world _installcheck_kernel .PHONY
 _installcheck_world: .PHONY
 _installcheck_kernel: .PHONY
 
 #
 # Require DESTDIR to be set if installing for a different architecture or
 # using the user/group database in the source tree.
 #
 .if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${TARGET} != ${MACHINE} || \
     defined(DB_FROM_SRC)
 .if !make(distributeworld)
 _installcheck_world: __installcheck_DESTDIR
 _installcheck_kernel: __installcheck_DESTDIR
 __installcheck_DESTDIR: .PHONY
 .if !defined(DESTDIR) || empty(DESTDIR)
 	@echo "ERROR: Please set DESTDIR!"; \
 	false
 .endif
 .endif
 .endif
 
 .if !defined(DB_FROM_SRC)
 #
 # Check for missing UIDs/GIDs.
 #
 CHECK_UIDS=	auditdistd
 CHECK_GIDS=	audit
 .if ${MK_SENDMAIL} != "no"
 CHECK_UIDS+=	smmsp
 CHECK_GIDS+=	smmsp
 .endif
 .if ${MK_PF} != "no"
 CHECK_UIDS+=	proxy
 CHECK_GIDS+=	proxy authpf
 .endif
 .if ${MK_UNBOUND} != "no"
 CHECK_UIDS+=	unbound
 CHECK_GIDS+=	unbound
 .endif
 _installcheck_world: __installcheck_UGID
 __installcheck_UGID: .PHONY
 .for uid in ${CHECK_UIDS}
 	@if ! `id -u ${uid} >/dev/null 2>&1`; then \
 		echo "ERROR: Required ${uid} user is missing, see /usr/src/UPDATING."; \
 		false; \
 	fi
 .endfor
 .for gid in ${CHECK_GIDS}
 	@if ! `find / -prune -group ${gid} >/dev/null 2>&1`; then \
 		echo "ERROR: Required ${gid} group is missing, see /usr/src/UPDATING."; \
 		false; \
 	fi
 .endfor
 .endif
 #
 # If installing over the running system (DESTDIR is / or unset) and the install
 # includes rescue, try running rescue from the objdir as a sanity check.  If
 # rescue is not functional (e.g., because it depends on a system call not
 # supported by the currently running kernel), abort the installation.
 #
 .if !make(distributeworld) && ${MK_RESCUE} != "no" && \
     (empty(DESTDIR) || ${DESTDIR} == "/") && empty(BYPASS_INSTALLCHECK_SH)
 _installcheck_world: __installcheck_sh_check
 __installcheck_sh_check: .PHONY
 	@if [ "`${OBJTREE}${.CURDIR}/rescue/rescue/rescue sh -c 'echo OK'`" != \
 	    OK ]; then \
 		echo "rescue/sh check failed, installation aborted" >&2; \
 		false; \
 	fi
 .endif
 
 #
 # Required install tools to be saved in a scratch dir for safety.
 #
 .if ${MK_ZONEINFO} != "no"
 _zoneinfo=	zic tzsetup
 .endif
 
 ITOOLS=	[ awk cap_mkdb cat chflags chmod chown cmp cp \
 	date echo egrep find grep id install ${_install-info} \
 	ln make mkdir mtree mv pwd_mkdb \
 	rm sed services_mkdb sh strip sysctl test true uname wc ${_zoneinfo} \
 	${LOCAL_ITOOLS}
 
 # Needed for share/man
 .if ${MK_MAN_UTILS} != "no"
 ITOOLS+=makewhatis
 .endif
 
 #
 # distributeworld
 #
 # Distributes everything compiled by a `buildworld'.
 #
 # installworld
 #
 # Installs everything compiled by a 'buildworld'.
 #
 
 # Non-base distributions produced by the base system
 EXTRA_DISTRIBUTIONS=	doc
 .if defined(LIBCOMPAT)
 EXTRA_DISTRIBUTIONS+=	lib${libcompat}
 .endif
 .if ${MK_TESTS} != "no"
 EXTRA_DISTRIBUTIONS+=	tests
 .endif
 
 DEBUG_DISTRIBUTIONS=
 .if ${MK_DEBUG_FILES} != "no"
 DEBUG_DISTRIBUTIONS+=	base ${EXTRA_DISTRIBUTIONS:S,doc,,:S,tests,,}
 .endif
 
 MTREE_MAGIC?=	mtree 2.0
 
 distributeworld installworld stageworld: _installcheck_world .PHONY
 	mkdir -p ${INSTALLTMP}
 	progs=$$(for prog in ${ITOOLS}; do \
 		if progpath=`which $$prog`; then \
 			echo $$progpath; \
 		else \
 			echo "Required tool $$prog not found in PATH." >&2; \
 			exit 1; \
 		fi; \
 	    done); \
 	libs=$$(ldd -f "%o %p\n" -f "%o %p\n" $$progs 2>/dev/null | sort -u | \
 	    while read line; do \
 		set -- $$line; \
 		if [ "$$2 $$3" != "not found" ]; then \
 			echo $$2; \
 		else \
 			echo "Required library $$1 not found." >&2; \
 			exit 1; \
 		fi; \
 	    done); \
 	cp $$libs $$progs ${INSTALLTMP}
 	cp -R $${PATH_LOCALE:-"/usr/share/locale"} ${INSTALLTMP}/locale
 .if defined(NO_ROOT)
 	-mkdir -p ${METALOG:H}
 	echo "#${MTREE_MAGIC}" > ${METALOG}
 .endif
 .if make(distributeworld)
 .for dist in ${EXTRA_DISTRIBUTIONS}
 	-mkdir ${DESTDIR}/${DISTDIR}/${dist}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.root.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist} >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/include >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib >/dev/null
 .endif
 .if defined(LIBCOMPAT)
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib/debug/usr >/dev/null
 .endif
 .endif
 .if ${MK_TESTS} != "no" && ${dist} == "tests"
 	-mkdir -p ${DESTDIR}/${DISTDIR}/${dist}${TESTSBASE}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}${TESTSBASE} >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib/debug/${TESTSBASE} >/dev/null
 .endif
 .endif
 .if defined(NO_ROOT)
 	${IMAKEENV} mtree -C -f ${.CURDIR}/etc/mtree/BSD.root.dist | \
 	    sed -e 's#^\./#./${dist}/#' >> ${METALOG}
 	${IMAKEENV} mtree -C -f ${.CURDIR}/etc/mtree/BSD.usr.dist | \
 	    sed -e 's#^\./#./${dist}/usr/#' >> ${METALOG}
 	${IMAKEENV} mtree -C -f ${.CURDIR}/etc/mtree/BSD.include.dist | \
 	    sed -e 's#^\./#./${dist}/usr/include/#' >> ${METALOG}
 .if defined(LIBCOMPAT)
 	${IMAKEENV} mtree -C -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist | \
 	    sed -e 's#^\./#./${dist}/usr/#' >> ${METALOG}
 .endif
 .endif
 .endfor
 	-mkdir ${DESTDIR}/${DISTDIR}/base
 	${_+_}cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
 	    METALOG=${METALOG} ${IMAKE_INSTALL} ${IMAKE_MTREE} \
 	    DISTBASE=/base DESTDIR=${DESTDIR}/${DISTDIR}/base \
 	    LOCAL_MTREE=${LOCAL_MTREE:Q} distrib-dirs
 .endif
 	${_+_}cd ${.CURDIR}; ${IMAKE} re${.TARGET:S/world$//}; \
 	    ${IMAKEENV} rm -rf ${INSTALLTMP}
 .if make(distributeworld)
 .for dist in ${EXTRA_DISTRIBUTIONS}
 	find ${DESTDIR}/${DISTDIR}/${dist} -mindepth 1 -type d -empty -delete
 .endfor
 .if defined(NO_ROOT)
 .for dist in base ${EXTRA_DISTRIBUTIONS}
 	@# For each file that exists in this dist, print the corresponding
 	@# line from the METALOG.  This relies on the fact that
 	@# a line containing only the filename will sort immediately before
 	@# the relevant mtree line.
 	cd ${DESTDIR}/${DISTDIR}; \
 	find ./${dist} | sort -u ${METALOG} - | \
 	awk 'BEGIN { print "#${MTREE_MAGIC}" } !/ type=/ { file = $$1 } / type=/ { if ($$1 == file) { sub(/^\.\/${dist}\//, "./"); print } }' > \
 	${DESTDIR}/${DISTDIR}/${dist}.meta
 .endfor
 .for dist in ${DEBUG_DISTRIBUTIONS}
 	@# For each file that exists in this dist, print the corresponding
 	@# line from the METALOG.  This relies on the fact that
 	@# a line containing only the filename will sort immediately before
 	@# the relevant mtree line.
 	cd ${DESTDIR}/${DISTDIR}; \
 	find ./${dist}/usr/lib/debug | sort -u ${METALOG} - | \
 	awk 'BEGIN { print "#${MTREE_MAGIC}" } !/ type=/ { file = $$1 } / type=/ { if ($$1 == file) { sub(/^\.\/${dist}\//, "./"); print } }' > \
 	${DESTDIR}/${DISTDIR}/${dist}.debug.meta
 .endfor
 .endif
 .endif
 
 packageworld: .PHONY
 .for dist in base ${EXTRA_DISTRIBUTIONS}
 .if defined(NO_ROOT)
 	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
 	    tar cvf - --exclude usr/lib/debug \
 	    @${DESTDIR}/${DISTDIR}/${dist}.meta | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}.txz
 .else
 	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
 	    tar cvf - --exclude usr/lib/debug . | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}.txz
 .endif
 .endfor
 
 .for dist in ${DEBUG_DISTRIBUTIONS}
 . if defined(NO_ROOT)
 	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
 	    tar cvf - @${DESTDIR}/${DISTDIR}/${dist}.debug.meta | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}-dbg.txz
 . else
 	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
 	    tar cvLf - usr/lib/debug | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}-dbg.txz
 . endif
 .endfor
 
 #
 # reinstall
 #
 # If you have a build server, you can NFS mount the source and obj directories
 # and do a 'make reinstall' on the *client* to install new binaries from the
 # most recent server build.
 #
 restage reinstall: .MAKE .PHONY
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Making hierarchy"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 \
 	    LOCAL_MTREE=${LOCAL_MTREE:Q} hierarchy
 .if make(restage)
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Making distribution"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 \
 	    LOCAL_MTREE=${LOCAL_MTREE:Q} distribution
 .endif
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Installing everything"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install
 .if defined(LIBCOMPAT)
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install${libcompat}
 .endif
 
 redistribute: .MAKE .PHONY
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Distributing everything"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute
 .if defined(LIBCOMPAT)
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute${libcompat} \
 	    DISTRIBUTION=lib${libcompat}
 .endif
 
 distrib-dirs distribution: .MAKE .PHONY
 	${_+_}cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
 	    ${IMAKE_INSTALL} ${IMAKE_MTREE} METALOG=${METALOG} ${.TARGET}
 .if make(distribution)
 	${_+_}cd ${.CURDIR}; ${CROSSENV} PATH=${TMPPATH} \
 		${MAKE} -f Makefile.inc1 ${IMAKE_INSTALL} \
 		METALOG=${METALOG} MK_TESTS=no installconfig
 .endif
 
 #
 # buildkernel and installkernel
 #
 # Which kernels to build and/or install is specified by setting
 # KERNCONF. If not defined a GENERIC kernel is built/installed.
 # Only the existing (depending TARGET) config files are used
 # for building kernels and only the first of these is designated
 # as the one being installed.
 #
 # Note that we have to use TARGET instead of TARGET_ARCH when
 # we're in kernel-land. Since only TARGET_ARCH is (expected) to
 # be set to cross-build, we have to make sure TARGET is set
 # properly.
 
 .if defined(KERNFAST)
 NO_KERNELCLEAN=	t
 NO_KERNELCONFIG=	t
 NO_KERNELOBJ=		t
 # Shortcut for KERNCONF=Blah -DKERNFAST is now KERNFAST=Blah
 .if !defined(KERNCONF) && ${KERNFAST} != "1"
 KERNCONF=${KERNFAST}
 .endif
 .endif
 .if ${TARGET_ARCH} == "powerpc64"
 KERNCONF?=	GENERIC64
 .else
 KERNCONF?=	GENERIC
 .endif
 INSTKERNNAME?=	kernel
 
 KERNSRCDIR?=	${.CURDIR}/sys
 KRNLCONFDIR=	${KERNSRCDIR}/${TARGET}/conf
 KRNLOBJDIR=	${OBJTREE}${KERNSRCDIR}
 KERNCONFDIR?=	${KRNLCONFDIR}
 
 BUILDKERNELS=
 INSTALLKERNEL=
 .if defined(NO_INSTALLKERNEL)
 # All of the BUILDKERNELS loops start at index 1.
 BUILDKERNELS+= dummy
 .endif
 .for _kernel in ${KERNCONF}
 .if exists(${KERNCONFDIR}/${_kernel})
 BUILDKERNELS+=	${_kernel}
 .if empty(INSTALLKERNEL) && !defined(NO_INSTALLKERNEL)
 INSTALLKERNEL= ${_kernel}
 .endif
 .else
 .if make(buildkernel)
 .error Missing KERNCONF ${KERNCONFDIR}/${_kernel}
 .endif
 .endif
 .endfor
 
 ${WMAKE_TGTS:N_worldtmp:Nbuild${libcompat}} ${.ALLTARGETS:M_*:N_worldtmp}: .MAKE .PHONY
 
 #
 # buildkernel
 #
 # Builds all kernels defined by BUILDKERNELS.
 #
 buildkernel: .MAKE .PHONY
 .if empty(BUILDKERNELS:Ndummy)
 	@echo "ERROR: Missing kernel configuration file(s) (${KERNCONF})."; \
 	false
 .endif
 	@echo
 .for _kernel in ${BUILDKERNELS:Ndummy}
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Kernel build for ${_kernel} started on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 	@echo "===> ${_kernel}"
 	mkdir -p ${KRNLOBJDIR}
 .if !defined(NO_KERNELCONFIG)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 1: configuring the kernel"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLCONFDIR}; \
 		PATH=${TMPPATH} \
 		    config ${CONFIGARGS} -d ${KRNLOBJDIR}/${_kernel} \
 			-I '${KERNCONFDIR}' '${KERNCONFDIR}/${_kernel}'
 .endif
 .if !defined(NO_CLEAN) && !defined(NO_KERNELCLEAN)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.1: cleaning up the object tree"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} ${CLEANDIR}
 .endif
 .if !defined(NO_KERNELOBJ)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.2: rebuilding the object tree"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} obj
 .endif
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.3: build tools"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${KTMAKE} kernel-tools
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 3.1: building everything"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} all -DNO_MODULES_OBJ
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Kernel build for ${_kernel} completed on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 .endfor
 
 NO_INSTALLEXTRAKERNELS?=	yes
 
 #
 # installkernel, etc.
 #
 # Install the kernel defined by INSTALLKERNEL
 #
 installkernel installkernel.debug \
 reinstallkernel reinstallkernel.debug: _installcheck_kernel .PHONY
 .if !defined(NO_INSTALLKERNEL)
 .if empty(INSTALLKERNEL)
 	@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
 	false
 .endif
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Installing kernel ${INSTALLKERNEL}"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
 	    ${CROSSENV} PATH=${TMPPATH} \
 	    ${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME} ${.TARGET:S/kernel//}
 .endif
 .if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
 .for _kernel in ${BUILDKERNELS:[2..-1]}
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Installing kernel ${_kernel}"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${_kernel}; \
 	    ${CROSSENV} PATH=${TMPPATH} \
 	    ${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME}.${_kernel} ${.TARGET:S/kernel//}
 .endfor
 .endif
 
 distributekernel distributekernel.debug: .PHONY
 .if !defined(NO_INSTALLKERNEL)
 .if empty(INSTALLKERNEL)
 	@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
 	false
 .endif
 	mkdir -p ${DESTDIR}/${DISTDIR}
 .if defined(NO_ROOT)
 	@echo "#${MTREE_MAGIC}" > ${DESTDIR}/${DISTDIR}/kernel.premeta
 .endif
 	cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
 	    ${IMAKEENV} ${IMAKE_INSTALL:S/METALOG/kernel.premeta/} \
 	    ${IMAKE_MTREE} PATH=${TMPPATH} ${MAKE} KERNEL=${INSTKERNNAME} \
 	    DESTDIR=${INSTALL_DDIR}/kernel \
 	    ${.TARGET:S/distributekernel/install/}
 .if defined(NO_ROOT)
 	@sed -e 's|^./kernel|.|' ${DESTDIR}/${DISTDIR}/kernel.premeta > \
 	    ${DESTDIR}/${DISTDIR}/kernel.meta
 .endif
 .endif
 .if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
 .for _kernel in ${BUILDKERNELS:[2..-1]}
 .if defined(NO_ROOT)
 	@echo "#${MTREE_MAGIC}" > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.premeta
 .endif
 	cd ${KRNLOBJDIR}/${_kernel}; \
 	    ${IMAKEENV} ${IMAKE_INSTALL:S/METALOG/kernel.${_kernel}.premeta/} \
 	    ${IMAKE_MTREE} PATH=${TMPPATH} ${MAKE} \
 	    KERNEL=${INSTKERNNAME}.${_kernel} \
 	    DESTDIR=${INSTALL_DDIR}/kernel.${_kernel} \
 	    ${.TARGET:S/distributekernel/install/}
 .if defined(NO_ROOT)
 	@sed -e "s|^./kernel.${_kernel}|.|" \
 	    ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.premeta > \
 	    ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta
 .endif
 .endfor
 .endif
 
 packagekernel: .PHONY
 .if defined(NO_ROOT)
 .if !defined(NO_INSTALLKERNEL)
 	cd ${DESTDIR}/${DISTDIR}/kernel; \
 	    tar cvf - --exclude '*.debug' \
 	    @${DESTDIR}/${DISTDIR}/kernel.meta | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
 .endif
 .if ${MK_DEBUG_FILES} != "no"
 	cd ${DESTDIR}/${DISTDIR}/kernel; \
 	    tar cvf - --include '*/*/*.debug' \
 	    @${DESTDIR}/${DISTDIR}/kernel.meta | \
 	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
 .endif
 .if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
 .for _kernel in ${BUILDKERNELS:[2..-1]}
 	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
 	    tar cvf - --exclude '*.debug' \
 	    @${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
 .if ${MK_DEBUG_FILES} != "no"
 	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
 	    tar cvf - --include '*/*/*.debug' \
 	    @${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
 	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
 .endif
 .endfor
 .endif
 .else
 .if !defined(NO_INSTALLKERNEL)
 	cd ${DESTDIR}/${DISTDIR}/kernel; \
 	    tar cvf - --exclude '*.debug' . | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
 .endif
 .if ${MK_DEBUG_FILES} != "no"
 	cd ${DESTDIR}/${DISTDIR}/kernel; \
 	    tar cvf - --include '*/*/*.debug' $$(eval find .) | \
 	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
 .endif
 .if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
 .for _kernel in ${BUILDKERNELS:[2..-1]}
 	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
 	    tar cvf - --exclude '*.debug' . | \
 	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
 .if ${MK_DEBUG_FILES} != "no"
 	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
 	    tar cvf - --include '*/*/*.debug' $$(eval find .) | \
 	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
 .endif
 .endfor
 .endif
 .endif
 
 stagekernel: .PHONY
 	${_+_}${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} distributekernel
 
 PORTSDIR?=	/usr/ports
 WSTAGEDIR?=	${MAKEOBJDIRPREFIX}${.CURDIR}/${TARGET}.${TARGET_ARCH}/worldstage
 KSTAGEDIR?=	${MAKEOBJDIRPREFIX}${.CURDIR}/${TARGET}.${TARGET_ARCH}/kernelstage
 REPODIR?=	${MAKEOBJDIRPREFIX}${.CURDIR}/repo
 PKGSIGNKEY?=	# empty
 
 .ORDER:		stage-packages create-packages
 .ORDER:		create-packages create-world-packages
 .ORDER:		create-packages create-kernel-packages
 .ORDER:		create-packages sign-packages
 
 _pkgbootstrap: .PHONY
 .if !exists(${LOCALBASE}/sbin/pkg)
 	@env ASSUME_ALWAYS_YES=YES pkg bootstrap
 .endif
 
 packages: .PHONY
 	${_+_}${MAKE} -C ${.CURDIR} PKG_VERSION=${PKG_VERSION} real-packages
 
 package-pkg: .PHONY
 	rm -rf /tmp/ports.${TARGET} || :
 	env ${WMAKEENV:Q} SRCDIR=${.CURDIR} PORTSDIR=${PORTSDIR} REVISION=${_REVISION} \
 		PKG_CMD=${PKG_CMD} PKG_VERSION=${PKG_VERSION} REPODIR=${REPODIR} \
 		WSTAGEDIR=${WSTAGEDIR} \
 		sh ${.CURDIR}/release/scripts/make-pkg-package.sh
 
 real-packages:	stage-packages create-packages sign-packages .PHONY
 
 stage-packages: .PHONY
 	@mkdir -p ${REPODIR} ${WSTAGEDIR} ${KSTAGEDIR}
 	${_+_}@cd ${.CURDIR}; \
 		${MAKE} DESTDIR=${WSTAGEDIR} -DNO_ROOT -B stageworld ; \
 		${MAKE} DESTDIR=${KSTAGEDIR} -DNO_ROOT -B stagekernel
 
 create-packages:	_pkgbootstrap .PHONY
 	@mkdir -p ${REPODIR}
 	${_+_}@cd ${.CURDIR}; \
 		${MAKE} DESTDIR=${WSTAGEDIR} \
 			PKG_VERSION=${PKG_VERSION} create-world-packages ; \
 		${MAKE} DESTDIR=${KSTAGEDIR} \
 			PKG_VERSION=${PKG_VERSION} DISTDIR=kernel \
 			create-kernel-packages
 
 create-world-packages:	_pkgbootstrap .PHONY
 	@rm -f ${WSTAGEDIR}/*.plist 2>/dev/null || :
 	@cd ${WSTAGEDIR} ; \
 		awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk \
 		${WSTAGEDIR}/METALOG
 	@for plist in ${WSTAGEDIR}/*.plist; do \
 		plist=$${plist##*/} ; \
 		pkgname=$${plist%.plist} ; \
 		sh ${SRCDIR}/release/packages/generate-ucl.sh -o $${pkgname} \
 			-s ${SRCDIR} -u ${WSTAGEDIR}/$${pkgname}.ucl ; \
 	done
 	@for plist in ${WSTAGEDIR}/*.plist; do \
 		plist=$${plist##*/} ; \
 		pkgname=$${plist%.plist} ; \
 		awk -F\" ' \
 			/^name/ { printf("===> Creating %s-", $$2); next } \
 			/^version/ { print $$2; next } \
 			' ${WSTAGEDIR}/$${pkgname}.ucl ; \
 		${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh -o ALLOW_BASE_SHLIBS=yes \
 			create -M ${WSTAGEDIR}/$${pkgname}.ucl \
 			-p ${WSTAGEDIR}/$${pkgname}.plist \
 			-r ${WSTAGEDIR} \
 			-o ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI)/${PKG_VERSION} ; \
 	done
 
 create-kernel-packages:	_pkgbootstrap .PHONY
 .if exists(${KSTAGEDIR}/kernel.meta)
 .if ${MK_DEBUG_FILES} != "no"
 _debug=-debug
 .endif
 .for flavor in "" ${_debug}
 	@cd ${KSTAGEDIR}/${DISTDIR} ; \
 	awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk \
 		-v kernel=yes -v _kernconf=${INSTALLKERNEL} \
 		${KSTAGEDIR}/kernel.meta ; \
 	cap_arg=`cd ${SRCDIR}/etc ; ${MAKE} -VCAP_MKDB_ENDIAN` ; \
 	pwd_arg=`cd ${SRCDIR}/etc ; ${MAKE} -VPWD_MKDB_ENDIAN` ; \
 	sed -e "s/%VERSION%/${PKG_VERSION}/" \
 		-e "s/%PKGNAME%/kernel-${INSTALLKERNEL:tl}${flavor}/" \
 		-e "s/%KERNELDIR%/kernel/" \
 		-e "s/%COMMENT%/FreeBSD ${INSTALLKERNEL} kernel ${flavor}/" \
 		-e "s/%DESC%/FreeBSD ${INSTALLKERNEL} kernel ${flavor}/" \
 		-e "s/%CAP_MKDB_ENDIAN%/$${cap_arg}/g" \
 		-e "s/%PWD_MKDB_ENDIAN%/$${pwd_arg}/g" \
 		${SRCDIR}/release/packages/kernel.ucl \
 		> ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl ; \
 	awk -F\" ' \
 		/name/ { printf("===> Creating %s-", $$2); next } \
 		/version/ {print $$2; next } ' \
 		${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl ; \
 	${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh -o ALLOW_BASE_SHLIBS=yes \
 		create -M ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl \
 		-p ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.plist \
 		-r ${KSTAGEDIR}/${DISTDIR} \
 		-o ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI)/${PKG_VERSION}
 .endfor
 .endif
 .if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
 .for _kernel in ${BUILDKERNELS:[2..-1]}
 .if exists(${KSTAGEDIR}/kernel.${_kernel}.meta)
 .if ${MK_DEBUG_FILES} != "no"
 _debug=-debug
 .endif
 .for flavor in "" ${_debug}
 	@cd ${KSTAGEDIR}/kernel.${_kernel} ; \
 	awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk \
 		-v kernel=yes -v _kernconf=${_kernel} \
 		${KSTAGEDIR}/kernel.${_kernel}.meta ; \
 	cap_arg=`cd ${SRCDIR}/etc ; ${MAKE} -VCAP_MKDB_ENDIAN` ; \
 	pwd_arg=`cd ${SRCDIR}/etc ; ${MAKE} -VPWD_MKDB_ENDIAN` ; \
 	sed -e "s/%VERSION%/${PKG_VERSION}/" \
 		-e "s/%PKGNAME%/kernel-${_kernel:tl}${flavor}/" \
 		-e "s/%KERNELDIR%/kernel.${_kernel}/" \
 		-e "s/%COMMENT%/FreeBSD ${_kernel} kernel ${flavor}/" \
 		-e "s/%DESC%/FreeBSD ${_kernel} kernel ${flavor}/" \
 		-e "s/%CAP_MKDB_ENDIAN%/$${cap_arg}/g" \
 		-e "s/%PWD_MKDB_ENDIAN%/$${pwd_arg}/g" \
 		${SRCDIR}/release/packages/kernel.ucl \
 		> ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl ; \
 	awk -F\" ' \
 		/name/ { printf("===> Creating %s-", $$2); next } \
 		/version/ {print $$2; next } ' \
 		${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl ; \
 	${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh -o ALLOW_BASE_SHLIBS=yes \
 		create -M ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl \
 		-p ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.plist \
 		-r ${KSTAGEDIR}/kernel.${_kernel} \
 		-o ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI)/${PKG_VERSION}
 .endfor
 .endif
 .endfor
 .endif
 
 sign-packages:	_pkgbootstrap .PHONY
 	@[ -L "${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI)/latest" ] && \
 		unlink ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI)/latest ; \
 	${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh repo \
 		-o ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI)/${PKG_VERSION} \
 		${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI)/${PKG_VERSION} \
 		${PKGSIGNKEY} ; \
 	cd ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/bin/sh config ABI); \
 	ln -s ${PKG_VERSION} latest
 
 #
 #
 # checkworld
 #
 # Run test suite on installed world.
 #
 checkworld: .PHONY
 	@if [ ! -x "${LOCALBASE}/bin/kyua" ]; then \
 		echo "You need kyua (devel/kyua) to run the test suite." | /usr/bin/fmt; \
 		exit 1; \
 	fi
 	${_+_}PATH="$$PATH:${LOCALBASE}/bin" kyua test -k ${TESTSBASE}/Kyuafile
 
 #
 #
 # doxygen
 #
 # Build the API documentation with doxygen
 #
 doxygen: .PHONY
 	@if [ ! -x "${LOCALBASE}/bin/doxygen" ]; then \
 		echo "You need doxygen (devel/doxygen) to generate the API documentation of the kernel." | /usr/bin/fmt; \
 		exit 1; \
 	fi
 	${_+_}cd ${.CURDIR}/tools/kerneldoc/subsys; ${MAKE} obj all
 
 #
 # update
 #
 # Update the source tree(s), by running svn/svnup to update to the
 # latest copy.
 #
 update: .PHONY
 .if defined(SVN_UPDATE)
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Updating ${.CURDIR} using Subversion"
 	@echo "--------------------------------------------------------------"
 	@(cd ${.CURDIR}; ${SVN} update ${SVNFLAGS})
 .endif
 
 #
 # ------------------------------------------------------------------------
 #
 # From here onwards are utility targets used by the 'make world' and
 # related targets.  If your 'world' breaks, you may like to try to fix
 # the problem and manually run the following targets to attempt to
 # complete the build.  Beware, this is *not* guaranteed to work, you
 # need to have a pretty good grip on the current state of the system
 # to attempt to manually finish it.  If in doubt, 'make world' again.
 #
 
 #
 # legacy: Build compatibility shims for the next three targets. This is a
 # minimal set of tools and shims necessary to compensate for older systems
 # which don't have the APIs required by the targets built in bootstrap-tools,
 # build-tools or cross-tools.
 #
 
 # ELF Tool Chain libraries are needed for ELF tools and dtrace tools.
 # r296685 fix cross-endian objcopy
 .if ${BOOTSTRAPPING} < 1100102
 _elftoolchain_libs= lib/libelf lib/libdwarf
 .endif
 
 legacy: .PHONY
 .if ${BOOTSTRAPPING} < ${MINIMUM_SUPPORTED_OSREL} && ${BOOTSTRAPPING} != 0
 	@echo "ERROR: Source upgrades from versions prior to ${MINIMUM_SUPPORTED_REL} are not supported."; \
 	false
 .endif
-.for _tool in tools/build ${_elftoolchain_libs}
+.for _tool in tools/build ${_elftoolchain_libs} lib/libnv
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,includes,all,install)"; \
 	    cd ${.CURDIR}/${_tool}; \
 	    ${MAKE} DIRPRFX=${_tool}/ obj; \
 	    ${MAKE} DIRPRFX=${_tool}/ DESTDIR=${MAKEOBJDIRPREFIX}/legacy includes; \
 	    ${MAKE} DIRPRFX=${_tool}/ MK_INCLUDES=no all; \
 	    ${MAKE} DIRPRFX=${_tool}/ MK_INCLUDES=no \
 	        DESTDIR=${MAKEOBJDIRPREFIX}/legacy install
 .endfor
 
 #
 # bootstrap-tools: Build tools needed for compatibility. These are binaries that
 # are built to build other binaries in the system. However, the focus of these
 # binaries is usually quite narrow. Bootstrap tools use the host's compiler and
 # libraries, augmented by -legacy.
 #
 _bt=		_bootstrap-tools
 
 .if ${MK_GAMES} != "no"
 _strfile=	usr.bin/fortune/strfile
 .endif
 
 .if ${MK_GCC} != "no" && ${MK_CXX} != "no"
 _gperf=		gnu/usr.bin/gperf
 .endif
 
 .if ${MK_SHAREDOCS} != "no" && ${MK_GROFF} != "no"
 _groff=		gnu/usr.bin/groff \
 		usr.bin/soelim
 .endif
 
 .if ${MK_VT} != "no"
 _vtfontcvt=	usr.bin/vtfontcvt
 .endif
 
 .if ${BOOTSTRAPPING} < 1000033
 _libopenbsd=	lib/libopenbsd
 _m4=		usr.bin/m4
 _lex=		usr.bin/lex
 
 ${_bt}-usr.bin/m4: ${_bt}-lib/libopenbsd
 ${_bt}-usr.bin/lex: ${_bt}-usr.bin/m4
 .endif
 
 # r245440 mtree -N support added
 # r313404 requires sha384.h for libnetbsd, added to libmd in r292782
 .if ${BOOTSTRAPPING} < 1100093
 _nmtree=	lib/libmd \
 		lib/libnetbsd \
 		usr.sbin/nmtree
 
 ${_bt}-lib/libnetbsd: ${_bt}-lib/libmd
 ${_bt}-usr.sbin/nmtree: ${_bt}-lib/libnetbsd
 .endif
 
 .if ${BOOTSTRAPPING} < 1000027
 _cat=		bin/cat
 .endif
 
 # r277259 crunchide: Correct 64-bit section header offset
 # r281674 crunchide: always include both 32- and 64-bit ELF support
 .if ${BOOTSTRAPPING} < 1100078
 _crunchide=	usr.sbin/crunch/crunchide
 .endif
 
 # r285986 crunchen: use STRIPBIN rather than STRIP
 # 1100113: Support MK_AUTO_OBJ
 # 1100509: META_MODE fixes
 .if ${BOOTSTRAPPING} < 1100078 || \
     (${MK_AUTO_OBJ} == "yes" && ${BOOTSTRAPPING} < 1100114) || \
     (${MK_META_MODE} == "yes" && ${BOOTSTRAPPING} < 1200006)
 _crunchgen=	usr.sbin/crunch/crunchgen
 .endif
 
 # r296926 -P keymap search path, MFC to stable/10 in r298297
 .if ${BOOTSTRAPPING} < 1003501 || \
 	(${BOOTSTRAPPING} >= 1100000 && ${BOOTSTRAPPING} < 1100103)
 _kbdcontrol=	usr.sbin/kbdcontrol
 .endif
 
 _yacc=		lib/liby \
 		usr.bin/yacc
 
 ${_bt}-usr.bin/yacc: ${_bt}-lib/liby
 
 .if ${MK_BSNMP} != "no"
 _gensnmptree=	usr.sbin/bsnmpd/gensnmptree
 .endif
 
 # We need to build tblgen when we're building clang or lld, either as
 # bootstrap tools, or as the part of the normal build.
 .if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_CLANG} != "no" || \
     ${MK_LLD_BOOTSTRAP} != "no" || ${MK_LLD} != "no"
 _clang_tblgen= \
 	lib/clang/libllvmminimal \
 	usr.bin/clang/llvm-tblgen \
 	usr.bin/clang/clang-tblgen
 
 ${_bt}-usr.bin/clang/clang-tblgen: ${_bt}-lib/clang/libllvmminimal
 ${_bt}-usr.bin/clang/llvm-tblgen: ${_bt}-lib/clang/libllvmminimal
 .endif
 
 # Default to building the GPL DTC, but build the BSDL one if users explicitly
 # request it.
 _dtc= usr.bin/dtc
 .if ${MK_GPL_DTC} != "no"
 _dtc= gnu/usr.bin/dtc
 .endif
 
 .if ${MK_KERBEROS} != "no"
 _kerberos5_bootstrap_tools= \
 	kerberos5/tools/make-roken \
 	kerberos5/lib/libroken \
 	kerberos5/lib/libvers \
 	kerberos5/tools/asn1_compile \
 	kerberos5/tools/slc \
 	usr.bin/compile_et
 
 .ORDER: ${_kerberos5_bootstrap_tools:C/^/${_bt}-/g}
 .endif
 
 # r283777 makewhatis(1) replaced with mandoc version which builds a database.
 .if ${MK_MANDOCDB} != "no"
 _libopenbsd?=	lib/libopenbsd
 _makewhatis=	usr.bin/mandoc
 ${_bt}-usr.bin/mandoc: ${_bt}-lib/libopenbsd
 .endif
 
 bootstrap-tools: .PHONY
 
 #	Please document (add comment) why something is in 'bootstrap-tools'.
 #	Try to bound the building of the bootstrap-tool to just the
 #	FreeBSD versions that need the tool built at this stage of the build.
 .for _tool in \
     ${_clang_tblgen} \
     ${_kerberos5_bootstrap_tools} \
     ${_strfile} \
     ${_gperf} \
     ${_groff} \
     ${_dtc} \
     ${_cat} \
     ${_kbdcontrol} \
     usr.bin/lorder \
     ${_libopenbsd} \
     ${_makewhatis} \
     usr.bin/rpcgen \
     ${_yacc} \
     ${_m4} \
     ${_lex} \
     usr.bin/xinstall \
     ${_gensnmptree} \
     usr.sbin/config \
     ${_crunchide} \
     ${_crunchgen} \
     ${_nmtree} \
     ${_vtfontcvt} \
     usr.bin/localedef
 ${_bt}-${_tool}: .PHONY .MAKE
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ all; \
 		${MAKE} DIRPRFX=${_tool}/ DESTDIR=${MAKEOBJDIRPREFIX}/legacy install
 
 bootstrap-tools: ${_bt}-${_tool}
 .endfor
 
 #
 # build-tools: Build special purpose build tools
 #
 .if !defined(NO_SHARE)
 _share=	share/syscons/scrnmaps
 .endif
 
 .if ${MK_GCC} != "no"
 _gcc_tools= gnu/usr.bin/cc/cc_tools
 .endif
 
 .if ${MK_RESCUE} != "no"
 # rescue includes programs that have build-tools targets
 _rescue=rescue/rescue
 .endif
 
 .if ${MK_TCSH} != "no"
 _tcsh=bin/csh
 .endif
 
 .for _tool in \
     ${_tcsh} \
     bin/sh \
     ${LOCAL_TOOL_DIRS} \
     lib/ncurses/ncurses \
     lib/ncurses/ncursesw \
     ${_rescue} \
     ${_share} \
     usr.bin/awk \
     lib/libmagic \
     usr.bin/mkesdb_static \
     usr.bin/mkcsmapper_static \
     usr.bin/vi/catalog
 build-tools_${_tool}: .PHONY
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,build-tools)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ build-tools
 build-tools: build-tools_${_tool}
 .endfor
 .for _tool in \
     ${_gcc_tools}
 build-tools_${_tool}: .PHONY
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,all)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ all
 build-tools: build-tools_${_tool}
 .endfor
 
 #
 # kernel-tools: Build kernel-building tools
 #
 kernel-tools: .PHONY
 	mkdir -p ${MAKEOBJDIRPREFIX}/usr
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${MAKEOBJDIRPREFIX}/usr >/dev/null
 
 #
 # cross-tools: All the tools needed to build the rest of the system after
 # we get done with the earlier stages. It is the last set of tools needed
 # to begin building the target binaries.
 #
 .if ${TARGET_ARCH} != ${MACHINE_ARCH}
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "i386"
 _btxld=		usr.sbin/btxld
 .endif
 .endif
 
 # Rebuild ctfconvert and ctfmerge to avoid difficult-to-diagnose failures
 # resulting from missing bug fixes or ELF Toolchain updates.
 .if ${MK_CDDL} != "no"
 _dtrace_tools= cddl/lib/libctf cddl/usr.bin/ctfconvert \
     cddl/usr.bin/ctfmerge
 .endif
 
 # If we're given an XAS, don't build binutils.
 .if ${XAS:M/*} == ""
 .if ${MK_BINUTILS_BOOTSTRAP} != "no"
 _binutils=	gnu/usr.bin/binutils
 .endif
 .if ${MK_ELFTOOLCHAIN_BOOTSTRAP} != "no"
 _elftctools=	lib/libelftc \
 		lib/libpe \
 		usr.bin/elfcopy \
 		usr.bin/nm \
 		usr.bin/size \
 		usr.bin/strings
 # These are not required by the build, but can be useful for developers who
 # cross-build on a FreeBSD 10 host:
 _elftctools+=	usr.bin/addr2line
 .endif
 .elif ${TARGET_ARCH} != ${MACHINE_ARCH} && ${MK_ELFTOOLCHAIN_BOOTSTRAP} != "no"
 # If cross-building with an external binutils we still need to build strip for
 # the target (for at least crunchide).
 _elftctools=	lib/libelftc \
 		lib/libpe \
 		usr.bin/elfcopy
 .endif
 
 .if ${MK_CLANG_BOOTSTRAP} != "no"
 _clang=		usr.bin/clang
 .endif
 .if ${MK_LLD_BOOTSTRAP} != "no"
 _lld=		usr.bin/clang/lld
 .endif
 .if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_LLD_BOOTSTRAP} != "no"
 _clang_libs=	lib/clang
 .endif
 .if ${MK_GCC_BOOTSTRAP} != "no"
 _gcc=		gnu/usr.bin/cc
 .endif
 .if ${MK_USB} != "no"
 _usb_tools=	stand/usb/tools
 .endif
 
 cross-tools: .MAKE .PHONY
 .for _tool in \
     ${_clang_libs} \
     ${_clang} \
     ${_lld} \
     ${_binutils} \
     ${_elftctools} \
     ${_dtrace_tools} \
     ${_gcc} \
     ${_btxld} \
     ${_usb_tools}
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ all; \
 		${MAKE} DIRPRFX=${_tool}/ DESTDIR=${MAKEOBJDIRPREFIX} install
 .endfor
 
 NXBDESTDIR=	${OBJTREE}/nxb-bin
 NXBENV=		MAKEOBJDIRPREFIX=${OBJTREE}/nxb \
 		TOOLS_PREFIX= \
 		INSTALL="sh ${.CURDIR}/tools/install.sh" \
 		PATH=${PATH}:${OBJTREE}/gperf_for_gcc/usr/bin
 NXBMAKE=	${NXBENV} ${MAKE} \
 		LLVM_TBLGEN=${NXBDESTDIR}/usr/bin/llvm-tblgen \
 		CLANG_TBLGEN=${NXBDESTDIR}/usr/bin/clang-tblgen \
 		MACHINE=${TARGET} MACHINE_ARCH=${TARGET_ARCH} \
 		MK_GDB=no MK_TESTS=no \
 		SSP_CFLAGS= \
 		MK_HTML=no NO_LINT=yes MK_MAN=no \
 		-DNO_PIC MK_PROFILE=no -DNO_SHARED \
 		-DNO_CPU_CFLAGS MK_WARNS=no MK_CTF=no \
 		MK_CLANG_EXTRAS=no MK_CLANG_FULL=no \
 		MK_LLDB=no MK_DEBUG_FILES=no
 
 # native-xtools is the current target for qemu-user cross builds of ports
 # via poudriere and the imgact_binmisc kernel module.
 # For non-clang enabled targets that are still using the in tree gcc
 # we must build a gperf binary for one instance of its Makefiles.  On
 # clang-enabled systems, the gperf binary is obsolete.
 native-xtools: .PHONY
 .if ${MK_GCC_BOOTSTRAP} != "no"
 	mkdir -p ${OBJTREE}/gperf_for_gcc/usr/bin
 	${_+_}@${ECHODIR} "===> ${_gperf} (obj,all,install)"; \
 	cd ${.CURDIR}/${_gperf}; \
 	${NXBMAKE} DIRPRFX=${_gperf}/ obj; \
 	${NXBMAKE} DIRPRFX=${_gperf}/ all; \
 	${NXBMAKE} DIRPRFX=${_gperf}/ DESTDIR=${OBJTREE}/gperf_for_gcc install
 .endif
 	mkdir -p ${NXBDESTDIR}/bin ${NXBDESTDIR}/sbin ${NXBDESTDIR}/usr
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${NXBDESTDIR}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${NXBDESTDIR}/usr/include >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${NXBDESTDIR}/usr/lib >/dev/null
 .endif
 .for _tool in \
     bin/cat \
     bin/chmod \
     bin/cp \
     ${_tcsh} \
     bin/echo \
     bin/expr \
     bin/hostname \
     bin/ln \
     bin/ls \
     bin/mkdir \
     bin/mv \
     bin/ps \
     bin/realpath \
     bin/rm \
     bin/rmdir \
     bin/sh \
     bin/sleep \
     ${_clang_tblgen} \
     usr.bin/ar \
     ${_binutils} \
     ${_elftctools} \
     ${_gcc} \
     ${_gcc_tools} \
     ${_clang_libs} \
     ${_clang} \
     sbin/md5 \
     sbin/sysctl \
     gnu/usr.bin/diff \
     usr.bin/awk \
     usr.bin/basename \
     usr.bin/bmake \
     usr.bin/bzip2 \
     usr.bin/cmp \
     usr.bin/dirname \
     usr.bin/env \
     usr.bin/fetch \
     usr.bin/find \
     usr.bin/grep \
     usr.bin/gzip \
     usr.bin/id \
     usr.bin/lex \
     usr.bin/lorder \
     usr.bin/mktemp \
     usr.bin/mt \
     usr.bin/patch \
     usr.bin/readelf \
     usr.bin/sed \
     usr.bin/sort \
     usr.bin/tar \
     usr.bin/touch \
     usr.bin/tr \
     usr.bin/true \
     usr.bin/uniq \
     usr.bin/unzip \
     usr.bin/xargs \
     usr.bin/xinstall \
     usr.bin/xz \
     usr.bin/yacc \
     usr.sbin/chown
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${NXBMAKE} DIRPRFX=${_tool}/ obj; \
 		${NXBMAKE} DIRPRFX=${_tool}/ all; \
 		${NXBMAKE} DIRPRFX=${_tool}/ DESTDIR=${NXBDESTDIR} install
 .endfor
 
 #
 # hierarchy - ensure that all the needed directories are present
 #
 hierarchy hier: .MAKE .PHONY
 	${_+_}cd ${.CURDIR}/etc; ${HMAKE} distrib-dirs
 
 #
 # libraries - build all libraries, and install them under ${DESTDIR}.
 #
 # The list of libraries with dependents (${_prebuild_libs}) and their
 # interdependencies (__L) are built automatically by the
 # ${.CURDIR}/tools/make_libdeps.sh script.
 #
 libraries: .MAKE .PHONY
 	${_+_}cd ${.CURDIR}; \
 	    ${MAKE} -f Makefile.inc1 _prereq_libs; \
 	    ${MAKE} -f Makefile.inc1 _startup_libs; \
 	    ${MAKE} -f Makefile.inc1 _prebuild_libs; \
 	    ${MAKE} -f Makefile.inc1 _generic_libs
 
 #
 # static libgcc.a prerequisite for shared libc
 #
 _prereq_libs= gnu/lib/libssp/libssp_nonshared gnu/lib/libgcc lib/libcompiler_rt
 
 # These dependencies are not automatically generated:
 #
 # gnu/lib/csu, gnu/lib/libgcc, lib/csu and lib/libc must be built before
 # all shared libraries for ELF.
 #
 _startup_libs=	gnu/lib/csu
 _startup_libs+=	lib/csu
 _startup_libs+=	gnu/lib/libgcc
 _startup_libs+=	lib/libcompiler_rt
 _startup_libs+=	lib/libc
 _startup_libs+=	lib/libc_nonshared
 .if ${MK_LIBCPLUSPLUS} != "no"
 _startup_libs+=	lib/libcxxrt
 .endif
 
 gnu/lib/libgcc__L: lib/libc__L
 gnu/lib/libgcc__L: lib/libc_nonshared__L
 .if ${MK_LIBCPLUSPLUS} != "no"
 lib/libcxxrt__L: gnu/lib/libgcc__L
 .endif
 
 _prebuild_libs=	${_kerberos5_lib_libasn1} \
 		${_kerberos5_lib_libhdb} \
 		${_kerberos5_lib_libheimbase} \
 		${_kerberos5_lib_libheimntlm} \
 		${_libsqlite3} \
 		${_kerberos5_lib_libheimipcc} \
 		${_kerberos5_lib_libhx509} ${_kerberos5_lib_libkrb5} \
 		${_kerberos5_lib_libroken} \
 		${_kerberos5_lib_libwind} \
 		lib/libbz2 ${_libcom_err} lib/libcrypt \
 		lib/libelf lib/libexpat \
 		lib/libfigpar \
 		${_lib_libgssapi} \
 		lib/libkiconv lib/libkvm lib/liblzma lib/libmd lib/libnv \
 		${_lib_casper} \
 		lib/ncurses/ncurses lib/ncurses/ncursesw \
 		lib/libopie lib/libpam/libpam ${_lib_libthr} \
 		${_lib_libradius} lib/libsbuf lib/libtacplus \
 		lib/libgeom \
 		${_cddl_lib_libumem} ${_cddl_lib_libnvpair} \
 		${_cddl_lib_libuutil} \
 		${_cddl_lib_libavl} \
 		${_cddl_lib_libzfs_core} \
 		${_cddl_lib_libctf} \
 		lib/libutil lib/libpjdlog ${_lib_libypclnt} lib/libz lib/msun \
 		${_secure_lib_libcrypto} ${_lib_libldns} \
 		${_secure_lib_libssh} ${_secure_lib_libssl}
 
 .if ${MK_GNUCXX} != "no"
 _prebuild_libs+= gnu/lib/libstdc++ gnu/lib/libsupc++
 gnu/lib/libstdc++__L: lib/msun__L
 gnu/lib/libsupc++__L: gnu/lib/libstdc++__L
 .endif
 
 .if ${MK_DIALOG} != "no"
 _prebuild_libs+= gnu/lib/libdialog
 gnu/lib/libdialog__L: lib/msun__L lib/ncurses/ncursesw__L
 .endif
 
 .if ${MK_LIBCPLUSPLUS} != "no"
 _prebuild_libs+= lib/libc++
 .endif
 
 lib/libgeom__L: lib/libexpat__L
 lib/libkvm__L: lib/libelf__L
 
 .if ${MK_LIBTHR} != "no"
 _lib_libthr=	lib/libthr
 .endif
 
 .if ${MK_RADIUS_SUPPORT} != "no"
 _lib_libradius=	lib/libradius
 .endif
 
 .if ${MK_OFED} != "no"
 _prebuild_libs+= \
 	lib/ofed/libibverbs \
 	lib/ofed/libibmad \
 	lib/ofed/libibumad \
 	lib/ofed/complib \
 	lib/ofed/libmlx5
 
 lib/ofed/libibmad__L:	lib/ofed/libibumad__L
 lib/ofed/complib__L:	lib/libthr__L
 lib/ofed/libmlx5__L:	lib/ofed/libibverbs__L lib/libthr__L
 .endif
 
 .if ${MK_CASPER} != "no"
 _lib_casper=	lib/libcasper
 .endif
 
 lib/libpjdlog__L: lib/libutil__L
 lib/libcasper__L: lib/libnv__L
 lib/liblzma__L: lib/libthr__L
 
 _generic_libs=	${_cddl_lib} gnu/lib ${_kerberos5_lib} lib ${_secure_lib} usr.bin/lex/lib
 .for _DIR in ${LOCAL_LIB_DIRS}
 .if ${_DIR} == ".WAIT"  || (empty(_generic_libs:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile))
 _generic_libs+= ${_DIR}
 .endif
 .endfor
 
 lib/libopie__L lib/libtacplus__L: lib/libmd__L
 
 .if ${MK_CDDL} != "no"
 _cddl_lib_libumem= cddl/lib/libumem
 _cddl_lib_libnvpair= cddl/lib/libnvpair
 _cddl_lib_libavl= cddl/lib/libavl
 _cddl_lib_libuutil= cddl/lib/libuutil
 _cddl_lib_libzfs_core= cddl/lib/libzfs_core
 _cddl_lib_libctf= cddl/lib/libctf
 _cddl_lib= cddl/lib
 cddl/lib/libzfs_core__L: cddl/lib/libnvpair__L
 cddl/lib/libzfs__L: lib/libgeom__L
 cddl/lib/libctf__L: lib/libz__L
 .endif
 # cddl/lib/libdtrace requires lib/libproc and lib/librtld_db; it's only built
 # on select architectures though (see cddl/lib/Makefile)
 .if ${MACHINE_CPUARCH} != "sparc64"
 _prebuild_libs+=	lib/libproc lib/librtld_db
 .endif
 
 .if ${MK_CRYPT} != "no"
 .if ${MK_OPENSSL} != "no"
 _secure_lib_libcrypto= secure/lib/libcrypto
 _secure_lib_libssl= secure/lib/libssl
 lib/libradius__L secure/lib/libssl__L: secure/lib/libcrypto__L
 .if ${MK_LDNS} != "no"
 _lib_libldns= lib/libldns
 lib/libldns__L: secure/lib/libcrypto__L
 .endif
 .if ${MK_OPENSSH} != "no"
 _secure_lib_libssh= secure/lib/libssh
 secure/lib/libssh__L: lib/libz__L secure/lib/libcrypto__L lib/libcrypt__L
 .if ${MK_LDNS} != "no"
 secure/lib/libssh__L: lib/libldns__L
 .endif
 .if ${MK_GSSAPI} != "no" && ${MK_KERBEROS_SUPPORT} != "no"
 secure/lib/libssh__L: lib/libgssapi__L kerberos5/lib/libkrb5__L \
     kerberos5/lib/libhx509__L kerberos5/lib/libasn1__L lib/libcom_err__L \
     lib/libmd__L kerberos5/lib/libroken__L
 .endif
 .endif
 .endif
 _secure_lib=	secure/lib
 .endif
 
 .if ${MK_KERBEROS} != "no"
 kerberos5/lib/libasn1__L: lib/libcom_err__L kerberos5/lib/libroken__L
 kerberos5/lib/libhdb__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
     kerberos5/lib/libkrb5__L kerberos5/lib/libroken__L \
     kerberos5/lib/libwind__L lib/libsqlite3__L
 kerberos5/lib/libheimntlm__L: secure/lib/libcrypto__L kerberos5/lib/libkrb5__L \
     kerberos5/lib/libroken__L lib/libcom_err__L
 kerberos5/lib/libhx509__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
     secure/lib/libcrypto__L kerberos5/lib/libroken__L kerberos5/lib/libwind__L
 kerberos5/lib/libkrb5__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
     lib/libcrypt__L secure/lib/libcrypto__L kerberos5/lib/libhx509__L \
     kerberos5/lib/libroken__L kerberos5/lib/libwind__L \
     kerberos5/lib/libheimbase__L kerberos5/lib/libheimipcc__L
 kerberos5/lib/libroken__L: lib/libcrypt__L
 kerberos5/lib/libwind__L: kerberos5/lib/libroken__L lib/libcom_err__L
 kerberos5/lib/libheimbase__L: lib/libthr__L
 kerberos5/lib/libheimipcc__L: kerberos5/lib/libroken__L kerberos5/lib/libheimbase__L lib/libthr__L
 .endif
 
 lib/libsqlite3__L: lib/libthr__L
 
 .if ${MK_GSSAPI} != "no"
 _lib_libgssapi=	lib/libgssapi
 .endif
 
 .if ${MK_KERBEROS} != "no"
 _kerberos5_lib=	kerberos5/lib
 _kerberos5_lib_libasn1= kerberos5/lib/libasn1
 _kerberos5_lib_libhdb= kerberos5/lib/libhdb
 _kerberos5_lib_libheimbase= kerberos5/lib/libheimbase
 _kerberos5_lib_libkrb5= kerberos5/lib/libkrb5
 _kerberos5_lib_libhx509= kerberos5/lib/libhx509
 _kerberos5_lib_libroken= kerberos5/lib/libroken
 _kerberos5_lib_libheimntlm= kerberos5/lib/libheimntlm
 _libsqlite3= lib/libsqlite3
 _kerberos5_lib_libheimipcc= kerberos5/lib/libheimipcc
 _kerberos5_lib_libwind= kerberos5/lib/libwind
 _libcom_err= lib/libcom_err
 .endif
 
 .if ${MK_NIS} != "no"
 _lib_libypclnt=	lib/libypclnt
 .endif
 
 .if ${MK_OPENSSL} == "no"
 lib/libradius__L: lib/libmd__L
 .endif
 
 lib/libproc__L: \
     ${_cddl_lib_libctf:D${_cddl_lib_libctf}__L} lib/libelf__L lib/librtld_db__L lib/libutil__L
 .if ${MK_CXX} != "no"
 .if ${MK_LIBCPLUSPLUS} != "no"
 lib/libproc__L: lib/libcxxrt__L
 .else # This implies MK_GNUCXX != "no"; see lib/libproc
 lib/libproc__L: gnu/lib/libsupc++__L
 .endif
 .endif
 
 .for _lib in ${_prereq_libs}
 ${_lib}__PL: .PHONY .MAKE
 .if exists(${.CURDIR}/${_lib})
 	${_+_}@${ECHODIR} "===> ${_lib} (obj,all,install)"; \
 		cd ${.CURDIR}/${_lib}; \
 		${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ obj; \
 		${MAKE} MK_TESTS=no MK_PROFILE=no -DNO_PIC \
 		    DIRPRFX=${_lib}/ all; \
 		${MAKE} MK_TESTS=no MK_PROFILE=no -DNO_PIC \
 		    DIRPRFX=${_lib}/ install
 .endif
 .endfor
 
 .for _lib in ${_startup_libs} ${_prebuild_libs} ${_generic_libs}
 ${_lib}__L: .PHONY .MAKE
 .if exists(${.CURDIR}/${_lib})
 	${_+_}@${ECHODIR} "===> ${_lib} (obj,all,install)"; \
 		cd ${.CURDIR}/${_lib}; \
 		${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ obj; \
 		${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ all; \
 		${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ install
 .endif
 .endfor
 
 _prereq_libs: ${_prereq_libs:S/$/__PL/}
 _startup_libs: ${_startup_libs:S/$/__L/}
 _prebuild_libs: ${_prebuild_libs:S/$/__L/}
 _generic_libs: ${_generic_libs:S/$/__L/}
 
 # Enable SUBDIR_PARALLEL when not calling 'make all', unless called from
 # 'everything' with _PARALLEL_SUBDIR_OK set.  This is because it is unlikely
 # that running 'make all' from the top-level, especially with a SUBDIR_OVERRIDE
 # or LOCAL_DIRS set, will have a reliable build if SUBDIRs are built in
 # parallel.  This is safe for the world stage of buildworld though since it has
 # already built libraries in a proper order and installed includes into
 # WORLDTMP. Special handling is done for SUBDIR ordering for 'install*' to
 # avoid trashing a system if it crashes mid-install.
 .if !make(all) || defined(_PARALLEL_SUBDIR_OK)
 SUBDIR_PARALLEL=
 .endif
 
 .include <bsd.subdir.mk>
 
 .if make(check-old) || make(check-old-dirs) || \
     make(check-old-files) || make(check-old-libs) || \
     make(delete-old) || make(delete-old-dirs) || \
     make(delete-old-files) || make(delete-old-libs)
 
 #
 # check for / delete old files section
 #
 
 .include "ObsoleteFiles.inc"
 
 OLD_LIBS_MESSAGE="Please be sure no application still uses those libraries, \
 else you can not start such an application. Consult UPDATING for more \
 information regarding how to cope with the removal/revision bump of a \
 specific library."
 
 .if !defined(BATCH_DELETE_OLD_FILES)
 RM_I=-i
 .else
 RM_I=-v
 .endif
 
 delete-old-files: .PHONY
 	@echo ">>> Removing old files (only deletes safe to delete libs)"
 # Ask for every old file if the user really wants to remove it.
 # It's annoying, but better safe than sorry.
 # NB: We cannot pass the list of OLD_FILES as a parameter because the
 # argument list will get too long. Using .for/.endfor make "loops" will make
 # the Makefile parser segfault.
 	@exec 3<&0; \
 	cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_FILES -V "OLD_FILES:Musr/share/*.gz:R" | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 			chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
 			rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
 		fi; \
 		for ext in debug symbols; do \
 		  if ! [ -e "${DESTDIR}/$${file}" ] && [ -f \
 		      "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
 			  rm ${RM_I} "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" \
 			      <&3; \
 		  fi; \
 		done; \
 	done
 # Remove catpages without corresponding manpages.
 	@exec 3<&0; \
 	find ${DESTDIR}/usr/share/man/cat* ! -type d | \
 	sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
 	while read catpage; do \
 		read manpage; \
 		if [ ! -e "$${manpage}" ]; then \
 			rm ${RM_I} $${catpage} <&3; \
 	        fi; \
 	done
 	@echo ">>> Old files removed"
 
 check-old-files: .PHONY
 	@echo ">>> Checking for old files"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_FILES -V "OLD_FILES:Musr/share/*.gz:R" | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 		 	echo "${DESTDIR}/$${file}"; \
 		fi; \
 		for ext in debug symbols; do \
 		  if [ -f "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
 			  echo "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}"; \
 		  fi; \
 		done; \
 	done
 # Check for catpages without corresponding manpages.
 	@find ${DESTDIR}/usr/share/man/cat* ! -type d | \
 	sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
 	while read catpage; do \
 		read manpage; \
 		if [ ! -e "$${manpage}" ]; then \
 			echo $${catpage}; \
 	        fi; \
 	done
 
 delete-old-libs: .PHONY
 	@echo ">>> Removing old libraries"
 	@echo "${OLD_LIBS_MESSAGE}" | fmt
 	@exec 3<&0; \
 	cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_LIBS | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 			chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
 			rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
 		fi; \
 		for ext in debug symbols; do \
 		  if ! [ -e "${DESTDIR}/$${file}" ] && [ -f \
 		      "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
 			  rm ${RM_I} "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" \
 			      <&3; \
 		  fi; \
 		done; \
 	done
 	@echo ">>> Old libraries removed"
 
 check-old-libs: .PHONY
 	@echo ">>> Checking for old libraries"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_LIBS | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 			echo "${DESTDIR}/$${file}"; \
 		fi; \
 		for ext in debug symbols; do \
 		  if [ -f "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
 			  echo "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}"; \
 		  fi; \
 		done; \
 	done
 
 delete-old-dirs: .PHONY
 	@echo ">>> Removing old directories"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_DIRS | xargs -n1 | sort -r | \
 	while read dir; do \
 		if [ -d "${DESTDIR}/$${dir}" ]; then \
 			rmdir -v "${DESTDIR}/$${dir}" || true; \
 		elif [ -L "${DESTDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
 		fi; \
 		if [ -d "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
 			rmdir -v "${DESTDIR}${DEBUGDIR}/$${dir}" || true; \
 		elif [ -L "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}${DEBUGDIR}/$${dir} is a link, please remove everything manually."; \
 		fi; \
 	done
 	@echo ">>> Old directories removed"
 
 check-old-dirs: .PHONY
 	@echo ">>> Checking for old directories"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_DIRS | xargs -n1 | \
 	while read dir; do \
 		if [ -d "${DESTDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}/$${dir}"; \
 		elif [ -L "${DESTDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
 		fi; \
 		if [ -d "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}${DEBUGDIR}/$${dir}"; \
 		elif [ -L "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}${DEBUGDIR}/$${dir} is a link, please remove everything manually."; \
 		fi; \
 	done
 
 delete-old: delete-old-files delete-old-dirs .PHONY
 	@echo "To remove old libraries run '${MAKE_CMD} delete-old-libs'."
 
 check-old: check-old-files check-old-libs check-old-dirs .PHONY
 	@echo "To remove old files and directories run '${MAKE_CMD} delete-old'."
 	@echo "To remove old libraries run '${MAKE_CMD} delete-old-libs'."
 
 .endif
 
 #
 # showconfig - show build configuration.
 #
 showconfig: .PHONY
 	@(${MAKE} -n -f ${.CURDIR}/sys/conf/kern.opts.mk -V dummy -dg1; \
 	  ${MAKE} -n -f ${.CURDIR}/share/mk/src.opts.mk -V dummy -dg1) 2>&1 | grep ^MK_ | sort -u
 
 .if !empty(KRNLOBJDIR) && !empty(KERNCONF)
 DTBOUTPUTPATH= ${KRNLOBJDIR}/${KERNCONF}/
 
 .if !defined(FDT_DTS_FILE) || empty(FDT_DTS_FILE)
 .if exists(${KERNCONFDIR}/${KERNCONF})
 FDT_DTS_FILE!= awk 'BEGIN {FS="="} /^makeoptions[[:space:]]+FDT_DTS_FILE/ {print $$2}' \
 	'${KERNCONFDIR}/${KERNCONF}' ; echo
 .endif
 .endif
 
 .endif
 
 .if !defined(DTBOUTPUTPATH) || !exists(${DTBOUTPUTPATH})
 DTBOUTPUTPATH= ${.CURDIR}
 .endif
 
 #
 # Build 'standalone' Device Tree Blob
 #
 builddtb: .PHONY
 	@PATH=${TMPPATH} MACHINE=${TARGET} \
 	${.CURDIR}/sys/tools/fdt/make_dtb.sh ${.CURDIR}/sys \
 	    "${FDT_DTS_FILE}" ${DTBOUTPUTPATH}
 
 ###############
 
 # cleanworld
 # In the following, the first 'rm' in a series will usually remove all
 # files and directories.  If it does not, then there are probably some
 # files with file flags set, so this unsets them and tries the 'rm' a
 # second time.  There are situations where this target will be cleaning
 # some directories via more than one method, but that duplication is
 # needed to correctly handle all the possible situations.  Removing all
 # files without file flags set in the first 'rm' instance saves time,
 # because 'chflags' will need to operate on fewer files afterwards.
 #
 # It is expected that BW_CANONICALOBJDIR == the CANONICALOBJDIR as would be
 # created by bsd.obj.mk, except that we don't want to .include that file
 # in this makefile.
 #
 BW_CANONICALOBJDIR:=${OBJTREE}${.CURDIR}
 cleanworld: .PHONY
 .if exists(${BW_CANONICALOBJDIR}/)
 	-rm -rf ${BW_CANONICALOBJDIR}/*
 	-chflags -R 0 ${BW_CANONICALOBJDIR}
 	rm -rf ${BW_CANONICALOBJDIR}/*
 .endif
 .if ${.CURDIR} == ${.OBJDIR} || ${.CURDIR}/obj == ${.OBJDIR}
 	#   To be safe in this case, fall back to a 'make cleandir'
 	${_+_}@cd ${.CURDIR}; ${MAKE} cleandir
 .endif
 
 .if defined(TARGET) && defined(TARGET_ARCH)
 
 .if ${TARGET} == ${MACHINE} && ${TARGET_ARCH} == ${MACHINE_ARCH}
 XDEV_CPUTYPE?=${CPUTYPE}
 .else
 XDEV_CPUTYPE?=${TARGET_CPUTYPE}
 .endif
 
 NOFUN=-DNO_FSCHG MK_HTML=no -DNO_LINT \
 	MK_MAN=no MK_NLS=no MK_PROFILE=no \
 	MK_KERBEROS=no MK_RESCUE=no MK_TESTS=no MK_WARNS=no \
 	TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
 	CPUTYPE=${XDEV_CPUTYPE}
 
 XDDIR=${TARGET_ARCH}-freebsd
 XDTP?=/usr/${XDDIR}
 .if ${XDTP:N/*}
 .error XDTP variable should be an absolute path
 .endif
 
 CDBENV=MAKEOBJDIRPREFIX=${MAKEOBJDIRPREFIX}/${XDDIR} \
 	INSTALL="sh ${.CURDIR}/tools/install.sh"
 CDENV= ${CDBENV} \
 	TOOLS_PREFIX=${XDTP}
 
 .if ${WANT_COMPILER_TYPE} == gcc || \
     (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc)
 # GCC requires -isystem and -L when using a cross-compiler.  --sysroot
 # won't set header path and -L is used to ensure the base library path
 # is added before the port PREFIX library path.
 CD2CFLAGS+=	-isystem ${XDDESTDIR}/usr/include -L${XDDESTDIR}/usr/lib
 # GCC requires -B to find /usr/lib/crti.o when using a cross-compiler
 # combined with --sysroot.
 CD2CFLAGS+=	-B${XDDESTDIR}/usr/lib
 # Force using libc++ for external GCC.
 .if ${X_COMPILER_TYPE} == gcc && ${X_COMPILER_VERSION} >= 40800
 CD2CXXFLAGS+=	-isystem ${XDDESTDIR}/usr/include/c++/v1 -std=c++11 \
 		-nostdinc++
 .endif
 .endif
 CD2CFLAGS+=	--sysroot=${XDDESTDIR}/
 CD2ENV=${CDENV} CC="${CC} ${CD2CFLAGS}" CXX="${CXX} ${CD2CXXFLAGS} ${CD2CFLAGS}" \
 	CPP="${CPP} ${CD2CFLAGS}" \
 	MACHINE=${TARGET} MACHINE_ARCH=${TARGET_ARCH}
 
 CDTMP=	${MAKEOBJDIRPREFIX}/${XDDIR}/${.CURDIR}/tmp
 CDMAKE=${CDENV} PATH=${CDTMP}/usr/bin:${PATH} ${MAKE} ${NOFUN}
 CD2MAKE=${CD2ENV} PATH=${CDTMP}/usr/bin:${XDDESTDIR}/usr/bin:${PATH} ${MAKE} ${NOFUN}
 .if ${MK_META_MODE} != "no"
 # Don't rebuild build-tools targets during normal build.
 CD2MAKE+=	BUILD_TOOLS_META=.NOMETA
 .endif
 XDDESTDIR=${DESTDIR}/${XDTP}
 
 .ORDER: xdev-build xdev-install xdev-links
 xdev: xdev-build xdev-install .PHONY
 
 .ORDER: _xb-worldtmp _xb-bootstrap-tools _xb-build-tools _xb-cross-tools
 xdev-build: _xb-worldtmp _xb-bootstrap-tools _xb-build-tools _xb-cross-tools .PHONY
 
 _xb-worldtmp: .PHONY
 	mkdir -p ${CDTMP}/usr
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${CDTMP}/usr >/dev/null
 
 _xb-bootstrap-tools: .PHONY
 .for _tool in \
     ${_clang_tblgen} \
     ${_gperf} \
     ${_yacc}
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
 	cd ${.CURDIR}/${_tool}; \
 	${CDMAKE} DIRPRFX=${_tool}/ obj; \
 	${CDMAKE} DIRPRFX=${_tool}/ all; \
 	${CDMAKE} DIRPRFX=${_tool}/ DESTDIR=${CDTMP} install
 .endfor
 
 _xb-build-tools: .PHONY
 	${_+_}@cd ${.CURDIR}; \
 	${CDBENV} ${MAKE} -f Makefile.inc1 ${NOFUN} build-tools
 
 _xb-cross-tools: .PHONY
 .for _tool in \
     ${_binutils} \
     ${_elftctools} \
     usr.bin/ar \
     ${_clang_libs} \
     ${_clang} \
     ${_gcc}
 	${_+_}@${ECHODIR} "===> xdev ${_tool} (obj,all)"; \
 	cd ${.CURDIR}/${_tool}; \
 	${CDMAKE} DIRPRFX=${_tool}/ obj; \
 	${CDMAKE} DIRPRFX=${_tool}/ all
 .endfor
 
 _xi-mtree: .PHONY
 	${_+_}@${ECHODIR} "mtree populating ${XDDESTDIR}"
 	mkdir -p ${XDDESTDIR}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.root.dist \
 	    -p ${XDDESTDIR} >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${XDDESTDIR}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${XDDESTDIR}/usr/include >/dev/null
 .if defined(LIBCOMPAT)
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
 	    -p ${XDDESTDIR}/usr >/dev/null
 .endif
 .if ${MK_TESTS} != "no"
 	mkdir -p ${XDDESTDIR}${TESTSBASE}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
 	    -p ${XDDESTDIR}${TESTSBASE} >/dev/null
 .endif
 
 .ORDER: xdev-build _xi-mtree _xi-cross-tools _xi-includes _xi-libraries
 xdev-install: xdev-build _xi-mtree _xi-cross-tools _xi-includes _xi-libraries .PHONY
 
 _xi-cross-tools: .PHONY
 	@echo "_xi-cross-tools"
 .for _tool in \
     ${_binutils} \
     ${_elftctools} \
     usr.bin/ar \
     ${_clang_libs} \
     ${_clang} \
     ${_gcc}
 	${_+_}@${ECHODIR} "===> xdev ${_tool} (install)"; \
 	cd ${.CURDIR}/${_tool}; \
 	${CDMAKE} DIRPRFX=${_tool}/ install DESTDIR=${XDDESTDIR}
 .endfor
 
 _xi-includes: .PHONY
 	${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 includes \
 		DESTDIR=${XDDESTDIR}
 
 _xi-libraries: .PHONY
 	${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 libraries \
 		DESTDIR=${XDDESTDIR}
 
 xdev-links: .PHONY
 	${_+_}cd ${XDDESTDIR}/usr/bin; \
 	mkdir -p ../../../../usr/bin; \
 		for i in *; do \
 			ln -sf ../../${XDTP}/usr/bin/$$i \
 			    ../../../../usr/bin/${XDDIR}-$$i; \
 			ln -sf ../../${XDTP}/usr/bin/$$i \
 			    ../../../../usr/bin/${XDDIR}${_REVISION}-$$i; \
 		done
 .else
 xdev xdev-build xdev-install xdev-links: .PHONY
 	@echo "*** Error: Both TARGET and TARGET_ARCH must be defined for \"${.TARGET}\" target"
 .endif
Index: stable/11/sys/kern/kern_environment.c
===================================================================
--- stable/11/sys/kern/kern_environment.c	(revision 337332)
+++ stable/11/sys/kern/kern_environment.c	(revision 337333)
@@ -1,848 +1,928 @@
 /*-
  * Copyright (c) 1998 Michael Smith
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 /*
  * The unified bootloader passes us a pointer to a preserved copy of
  * bootstrap/kernel environment variables.  We convert them to a
  * dynamic array of strings later when the VM subsystem is up.
  *
  * We make these available through the kenv(2) syscall for userland
  * and through kern_getenv()/freeenv() kern_setenv() kern_unsetenv() testenv() for
  * the kernel.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
 #include <sys/mutex.h>
 #include <sys/priv.h>
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
 #include <sys/libkern.h>
 #include <sys/kenv.h>
 #include <sys/limits.h>
 
 #include <security/mac/mac_framework.h>
 
+static char *_getenv_dynamic_locked(const char *name, int *idx);
+static char *_getenv_dynamic(const char *name, int *idx);
+
 static MALLOC_DEFINE(M_KENV, "kenv", "kernel environment");
 
 #define KENV_SIZE	512	/* Maximum number of environment strings */
 
-/* pointer to the static environment */
+/* pointer to the config-generated static environment */
 char		*kern_envp;
-static int	env_len;
-static int	env_pos;
+
+/* pointer to the md-static environment */
+char		*md_envp;
+static int	md_env_len;
+static int	md_env_pos;
+
 static char	*kernenv_next(char *);
 
 /* dynamic environment variables */
 char		**kenvp;
 struct mtx	kenv_lock;
 
 /*
  * No need to protect this with a mutex since SYSINITS are single threaded.
  */
 int	dynamic_kenv = 0;
 
 #define KENV_CHECK	if (!dynamic_kenv) \
 			    panic("%s: called before SI_SUB_KMEM", __func__)
 
 int
 sys_kenv(td, uap)
 	struct thread *td;
 	struct kenv_args /* {
 		int what;
 		const char *name;
 		char *value;
 		int len;
 	} */ *uap;
 {
 	char *name, *value, *buffer = NULL;
 	size_t len, done, needed, buflen;
 	int error, i;
 
 	KASSERT(dynamic_kenv, ("kenv: dynamic_kenv = 0"));
 
 	error = 0;
 	if (uap->what == KENV_DUMP) {
 #ifdef MAC
 		error = mac_kenv_check_dump(td->td_ucred);
 		if (error)
 			return (error);
 #endif
 		done = needed = 0;
 		buflen = uap->len;
 		if (buflen > KENV_SIZE * (KENV_MNAMELEN + KENV_MVALLEN + 2))
 			buflen = KENV_SIZE * (KENV_MNAMELEN +
 			    KENV_MVALLEN + 2);
 		if (uap->len > 0 && uap->value != NULL)
 			buffer = malloc(buflen, M_TEMP, M_WAITOK|M_ZERO);
 		mtx_lock(&kenv_lock);
 		for (i = 0; kenvp[i] != NULL; i++) {
 			len = strlen(kenvp[i]) + 1;
 			needed += len;
 			len = min(len, buflen - done);
 			/*
 			 * If called with a NULL or insufficiently large
 			 * buffer, just keep computing the required size.
 			 */
 			if (uap->value != NULL && buffer != NULL && len > 0) {
 				bcopy(kenvp[i], buffer + done, len);
 				done += len;
 			}
 		}
 		mtx_unlock(&kenv_lock);
 		if (buffer != NULL) {
 			error = copyout(buffer, uap->value, done);
 			free(buffer, M_TEMP);
 		}
 		td->td_retval[0] = ((done == needed) ? 0 : needed);
 		return (error);
 	}
 
 	switch (uap->what) {
 	case KENV_SET:
 		error = priv_check(td, PRIV_KENV_SET);
 		if (error)
 			return (error);
 		break;
 
 	case KENV_UNSET:
 		error = priv_check(td, PRIV_KENV_UNSET);
 		if (error)
 			return (error);
 		break;
 	}
 
 	name = malloc(KENV_MNAMELEN + 1, M_TEMP, M_WAITOK);
 
 	error = copyinstr(uap->name, name, KENV_MNAMELEN + 1, NULL);
 	if (error)
 		goto done;
 
 	switch (uap->what) {
 	case KENV_GET:
 #ifdef MAC
 		error = mac_kenv_check_get(td->td_ucred, name);
 		if (error)
 			goto done;
 #endif
 		value = kern_getenv(name);
 		if (value == NULL) {
 			error = ENOENT;
 			goto done;
 		}
 		len = strlen(value) + 1;
 		if (len > uap->len)
 			len = uap->len;
 		error = copyout(value, uap->value, len);
 		freeenv(value);
 		if (error)
 			goto done;
 		td->td_retval[0] = len;
 		break;
 	case KENV_SET:
 		len = uap->len;
 		if (len < 1) {
 			error = EINVAL;
 			goto done;
 		}
 		if (len > KENV_MVALLEN + 1)
 			len = KENV_MVALLEN + 1;
 		value = malloc(len, M_TEMP, M_WAITOK);
 		error = copyinstr(uap->value, value, len, NULL);
 		if (error) {
 			free(value, M_TEMP);
 			goto done;
 		}
 #ifdef MAC
 		error = mac_kenv_check_set(td->td_ucred, name, value);
 		if (error == 0)
 #endif
 			kern_setenv(name, value);
 		free(value, M_TEMP);
 		break;
 	case KENV_UNSET:
 #ifdef MAC
 		error = mac_kenv_check_unset(td->td_ucred, name);
 		if (error)
 			goto done;
 #endif
 		error = kern_unsetenv(name);
 		if (error)
 			error = ENOENT;
 		break;
 	default:
 		error = EINVAL;
 		break;
 	}
 done:
 	free(name, M_TEMP);
 	return (error);
 }
 
 /*
  * Populate the initial kernel environment.
  *
  * This is called very early in MD startup, either to provide a copy of the
  * environment obtained from a boot loader, or to provide an empty buffer into
  * which MD code can store an initial environment using kern_setenv() calls.
  *
- * When a copy of an initial environment is passed in, we start by scanning that
- * env for overrides to the compiled-in envmode and hintmode variables.
+ * kern_envp is set to the static_env generated by config(8).  This implements
+ * the env keyword described in config(5).
  *
- * If the global envmode is 1, the environment is initialized from the global
- * static_env[], regardless of the arguments passed.  This implements the env
- * keyword described in config(5).  In this case env_pos is set to env_len,
- * causing kern_setenv() to return -1 (if len > 0) or panic (if len == 0) until
- * the dynamic environment is available.  The envmode and static_env variables
- * are defined in env.c which is generated by config(8).
- *
  * If len is non-zero, the caller is providing an empty buffer.  The caller will
  * subsequently use kern_setenv() to add up to len bytes of initial environment
  * before the dynamic environment is available.
  *
  * If len is zero, the caller is providing a pre-loaded buffer containing
  * environment strings.  Additional strings cannot be added until the dynamic
  * environment is available.  The memory pointed to must remain stable at least
- * until sysinit runs init_dynamic_kenv().  If no initial environment is
- * available from the boot loader, passing a NULL pointer allows the static_env
- * to be installed if it is configured.
+ * until sysinit runs init_dynamic_kenv() and preferably until after SI_SUB_KMEM
+ * is finished so that subr_hints routines may continue to use it until the
+ * environments have been fully merged at the end of the pass.  If no initial
+ * environment is available from the boot loader, passing a NULL pointer allows
+ * the static_env to be installed if it is configured.  In this case, any call
+ * to kern_setenv() prior to the setup of the dynamic environment will result in
+ * a panic.
  */
 void
 init_static_kenv(char *buf, size_t len)
 {
-	char *cp;
-	
-	for (cp = buf; cp != NULL && cp[0] != '\0'; cp += strlen(cp) + 1) {
-		if (strcmp(cp, "static_env.disabled=1") == 0)
-			envmode = 0;
-		if (strcmp(cp, "static_hints.disabled=1") == 0)
-			hintmode = 0;
-	}
+	char *eval;
 
-	if (envmode == 1) {
-		kern_envp = static_env;
-		env_len = len;
-		env_pos = len;
-	} else {
-		kern_envp = buf;
-		env_len = len;
-		env_pos = 0;
+	/*
+	 * Give the static environment a chance to disable the loader(8)
+	 * environment first.  This is done with loader_env.disabled=1.
+	 *
+	 * static_env and static_hints may both be disabled, but in slightly
+	 * different ways.  For static_env, we just don't setup kern_envp and
+	 * it's as if a static env wasn't even provided.  For static_hints,
+	 * we effectively zero out the buffer to stop the rest of the kernel
+	 * from being able to use it.
+	 *
+	 * We're intentionally setting this up so that static_hints.disabled may
+	 * be specified in either the MD env or the static env. This keeps us
+	 * consistent in our new world view.
+	 *
+	 * As a warning, the static environment may not be disabled in any way
+	 * if the static environment has disabled the loader environment.
+	 */
+	kern_envp = static_env;
+	eval = kern_getenv("loader_env.disabled");
+	if (*kern_envp == '\0' || (eval != NULL && strcmp(eval, "0") == 0)) {
+		md_envp = buf;
+		md_env_len = len;
+		md_env_pos = 0;
+
+		eval = kern_getenv("static_env.disabled");
+		if (eval != NULL && strcmp(eval, "1") == 0)
+			*kern_envp = '\0';
 	}
+	eval = kern_getenv("static_hints.disabled");
+	if (eval != NULL && strcmp(eval, "1") == 0)
+		*static_hints = '\0';
 }
 
-/*
- * Setup the dynamic kernel environment.
- */
 static void
-init_dynamic_kenv(void *data __unused)
+init_dynamic_kenv_from(char *init_env, int *curpos)
 {
-	char *cp, *cpnext;
+	char *cp, *cpnext, *eqpos, *found;
 	size_t len;
 	int i;
 
-	kenvp = malloc((KENV_SIZE + 1) * sizeof(char *), M_KENV,
-		M_WAITOK | M_ZERO);
-	i = 0;
-	if (kern_envp && *kern_envp != '\0') {
-		for (cp = kern_envp; cp != NULL; cp = cpnext) {
+	if (init_env && *init_env != '\0') {
+		found = NULL;
+		i = *curpos;
+		for (cp = init_env; cp != NULL; cp = cpnext) {
 			cpnext = kernenv_next(cp);
 			len = strlen(cp) + 1;
 			if (len > KENV_MNAMELEN + 1 + KENV_MVALLEN + 1) {
 				printf(
 				"WARNING: too long kenv string, ignoring %s\n",
 				    cp);
-				continue;
+				goto sanitize;
 			}
-			if (i < KENV_SIZE) {
-				kenvp[i] = malloc(len, M_KENV, M_WAITOK);
-				strcpy(kenvp[i++], cp);
-				explicit_bzero(cp, strlen(cp));
-			} else
+			eqpos = strchr(cp, '=');
+			if (eqpos == NULL) {
 				printf(
+				"WARNING: malformed static env value, ignoring %s\n",
+				    cp);
+				goto sanitize;
+			}
+			*eqpos = 0;
+			/*
+			 * De-dupe the environment as we go.  We don't add the
+			 * duplicated assignments because config(8) will flip
+			 * the order of the static environment around to make
+			 * kernel processing match the order of specification
+			 * in the kernel config.
+			 */
+			found = _getenv_dynamic_locked(cp, NULL);
+			*eqpos = '=';
+			if (found != NULL)
+				goto sanitize;
+			if (i > KENV_SIZE) {
+				printf(
 				"WARNING: too many kenv strings, ignoring %s\n",
 				    cp);
+				goto sanitize;
+			}
+
+			kenvp[i] = malloc(len, M_KENV, M_WAITOK);
+			strcpy(kenvp[i++], cp);
+sanitize:
+			explicit_bzero(cp, len - 1);
 		}
+		*curpos = i;
 	}
-	kenvp[i] = NULL;
+}
 
+/*
+ * Setup the dynamic kernel environment.
+ */
+static void
+init_dynamic_kenv(void *data __unused)
+{
+	int dynamic_envpos;
+
+	kenvp = malloc((KENV_SIZE + 1) * sizeof(char *), M_KENV,
+		M_WAITOK | M_ZERO);
+
+	dynamic_envpos = 0;
+	init_dynamic_kenv_from(md_envp, &dynamic_envpos);
+	init_dynamic_kenv_from(kern_envp, &dynamic_envpos);
+	kenvp[dynamic_envpos] = NULL;
+
 	mtx_init(&kenv_lock, "kernel environment", NULL, MTX_DEF);
 	dynamic_kenv = 1;
 }
-SYSINIT(kenv, SI_SUB_KMEM, SI_ORDER_ANY, init_dynamic_kenv, NULL);
+SYSINIT(kenv, SI_SUB_KMEM + 1, SI_ORDER_FIRST, init_dynamic_kenv, NULL);
 
 void
 freeenv(char *env)
 {
 
 	if (dynamic_kenv && env != NULL) {
 		explicit_bzero(env, strlen(env));
 		free(env, M_KENV);
 	}
 }
 
 /*
  * Internal functions for string lookup.
  */
 static char *
-_getenv_dynamic(const char *name, int *idx)
+_getenv_dynamic_locked(const char *name, int *idx)
 {
 	char *cp;
 	int len, i;
 
-	mtx_assert(&kenv_lock, MA_OWNED);
 	len = strlen(name);
 	for (cp = kenvp[0], i = 0; cp != NULL; cp = kenvp[++i]) {
 		if ((strncmp(cp, name, len) == 0) &&
 		    (cp[len] == '=')) {
 			if (idx != NULL)
 				*idx = i;
 			return (cp + len + 1);
 		}
 	}
 	return (NULL);
 }
 
 static char *
-_getenv_static(const char *name)
+_getenv_dynamic(const char *name, int *idx)
 {
+
+	mtx_assert(&kenv_lock, MA_OWNED);
+	return (_getenv_dynamic_locked(name, idx));
+}
+
+static char *
+_getenv_static_from(char *chkenv, const char *name)
+{
 	char *cp, *ep;
 	int len;
 
-	for (cp = kern_envp; cp != NULL; cp = kernenv_next(cp)) {
+	for (cp = chkenv; cp != NULL; cp = kernenv_next(cp)) {
 		for (ep = cp; (*ep != '=') && (*ep != 0); ep++)
 			;
 		if (*ep != '=')
 			continue;
 		len = ep - cp;
 		ep++;
 		if (!strncmp(name, cp, len) && name[len] == 0)
 			return (ep);
 	}
 	return (NULL);
 }
 
+static char *
+_getenv_static(const char *name)
+{
+	char *val;
+
+	val = _getenv_static_from(md_envp, name);
+	if (val != NULL)
+		return (val);
+	val = _getenv_static_from(kern_envp, name);
+	if (val != NULL)
+		return (val);
+	return (NULL);
+}
+
 /*
  * Look up an environment variable by name.
  * Return a pointer to the string if found.
  * The pointer has to be freed with freeenv()
  * after use.
  */
 char *
 kern_getenv(const char *name)
 {
 	char buf[KENV_MNAMELEN + 1 + KENV_MVALLEN + 1];
 	char *ret;
 
 	if (dynamic_kenv) {
 		if (getenv_string(name, buf, sizeof(buf))) {
 			ret = strdup(buf, M_KENV);
 		} else {
 			ret = NULL;
 			WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
 			    "getenv");
 		}
 	} else
 		ret = _getenv_static(name);
 	return (ret);
 }
 
 /*
  * Test if an environment variable is defined.
  */
 int
 testenv(const char *name)
 {
 	char *cp;
 
 	if (dynamic_kenv) {
 		mtx_lock(&kenv_lock);
 		cp = _getenv_dynamic(name, NULL);
 		mtx_unlock(&kenv_lock);
 	} else
 		cp = _getenv_static(name);
 	if (cp != NULL)
 		return (1);
 	return (0);
 }
 
+/*
+ * Set an environment variable in the MD-static environment.  This cannot
+ * feasibly be done on config(8)-generated static environments as they don't
+ * generally include space for extra variables.
+ */
 static int
 setenv_static(const char *name, const char *value)
 {
 	int len;
 
-	if (env_pos >= env_len)
+	if (md_env_pos >= md_env_len)
 		return (-1);
 
 	/* Check space for x=y and two nuls */
 	len = strlen(name) + strlen(value);
-	if (len + 3 < env_len - env_pos) {
-		len = sprintf(&kern_envp[env_pos], "%s=%s", name, value);
-		env_pos += len+1;
-		kern_envp[env_pos] = '\0';
+	if (len + 3 < md_env_len - md_env_pos) {
+		len = sprintf(&md_envp[md_env_pos], "%s=%s", name, value);
+		md_env_pos += len+1;
+		md_envp[md_env_pos] = '\0';
 		return (0);
 	} else
 		return (-1);
 
 }
 
 /*
  * Set an environment variable by name.
  */
 int
 kern_setenv(const char *name, const char *value)
 {
 	char *buf, *cp, *oldenv;
 	int namelen, vallen, i;
 
-	if (dynamic_kenv == 0 && env_len > 0)
+	if (dynamic_kenv == 0 && md_env_len > 0)
 		return (setenv_static(name, value));
 
 	KENV_CHECK;
 
 	namelen = strlen(name) + 1;
 	if (namelen > KENV_MNAMELEN + 1)
 		return (-1);
 	vallen = strlen(value) + 1;
 	if (vallen > KENV_MVALLEN + 1)
 		return (-1);
 	buf = malloc(namelen + vallen, M_KENV, M_WAITOK);
 	sprintf(buf, "%s=%s", name, value);
 
 	mtx_lock(&kenv_lock);
 	cp = _getenv_dynamic(name, &i);
 	if (cp != NULL) {
 		oldenv = kenvp[i];
 		kenvp[i] = buf;
 		mtx_unlock(&kenv_lock);
 		free(oldenv, M_KENV);
 	} else {
 		/* We add the option if it wasn't found */
 		for (i = 0; (cp = kenvp[i]) != NULL; i++)
 			;
 
 		/* Bounds checking */
 		if (i < 0 || i >= KENV_SIZE) {
 			free(buf, M_KENV);
 			mtx_unlock(&kenv_lock);
 			return (-1);
 		}
 
 		kenvp[i] = buf;
 		kenvp[i + 1] = NULL;
 		mtx_unlock(&kenv_lock);
 	}
 	return (0);
 }
 
 /*
  * Unset an environment variable string.
  */
 int
 kern_unsetenv(const char *name)
 {
 	char *cp, *oldenv;
 	int i, j;
 
 	KENV_CHECK;
 
 	mtx_lock(&kenv_lock);
 	cp = _getenv_dynamic(name, &i);
 	if (cp != NULL) {
 		oldenv = kenvp[i];
 		for (j = i + 1; kenvp[j] != NULL; j++)
 			kenvp[i++] = kenvp[j];
 		kenvp[i] = NULL;
 		mtx_unlock(&kenv_lock);
 		explicit_bzero(oldenv, strlen(oldenv));
 		free(oldenv, M_KENV);
 		return (0);
 	}
 	mtx_unlock(&kenv_lock);
 	return (-1);
 }
 
 /*
  * Return a string value from an environment variable.
  */
 int
 getenv_string(const char *name, char *data, int size)
 {
 	char *cp;
 
 	if (dynamic_kenv) {
 		mtx_lock(&kenv_lock);
 		cp = _getenv_dynamic(name, NULL);
 		if (cp != NULL)
 			strlcpy(data, cp, size);
 		mtx_unlock(&kenv_lock);
 	} else {
 		cp = _getenv_static(name);
 		if (cp != NULL)
 			strlcpy(data, cp, size);
 	}
 	return (cp != NULL);
 }
 
 /*
  * Return an array of integers at the given type size and signedness.
  */
 int
 getenv_array(const char *name, void *pdata, int size, int *psize,
     int type_size, bool allow_signed)
 {
 	char buf[KENV_MNAMELEN + 1 + KENV_MVALLEN + 1];
 	uint8_t shift;
 	int64_t value;
 	int64_t old;
 	char *end;
 	char *ptr;
 	int n;
 
 	if (getenv_string(name, buf, sizeof(buf)) == 0)
 		return (0);
 
 	/* get maximum number of elements */
 	size /= type_size;
 
 	n = 0;
 
 	for (ptr = buf; *ptr != 0; ) {
 
 		value = strtoq(ptr, &end, 0);
 
 		/* check if signed numbers are allowed */
 		if (value < 0 && !allow_signed)
 			goto error;
 
 		/* check for invalid value */
 		if (ptr == end)
 			goto error;
 		
 		/* check for valid suffix */
 		switch (*end) {
 		case 't':
 		case 'T':
 			shift = 40;
 			end++;
 			break;
 		case 'g':
 		case 'G':
 			shift = 30;
 			end++;
 			break;
 		case 'm':
 		case 'M':
 			shift = 20;
 			end++;
 			break;
 		case 'k':
 		case 'K':
 			shift = 10;
 			end++;
 			break;
 		case ' ':
 		case '\t':
 		case ',':
 		case 0:
 			shift = 0;
 			break;
 		default:
 			/* garbage after numeric value */
 			goto error;
 		}
 
 		/* skip till next value, if any */
 		while (*end == '\t' || *end == ',' || *end == ' ')
 			end++;
 
 		/* update pointer */
 		ptr = end;
 
 		/* apply shift */
 		old = value;
 		value <<= shift;
 
 		/* overflow check */
 		if ((value >> shift) != old)
 			goto error;
 
 		/* check for buffer overflow */
 		if (n >= size)
 			goto error;
 
 		/* store value according to type size */
 		switch (type_size) {
 		case 1:
 			if (allow_signed) {
 				if (value < SCHAR_MIN || value > SCHAR_MAX)
 					goto error;
 			} else {
 				if (value < 0 || value > UCHAR_MAX)
 					goto error;
 			}
 			((uint8_t *)pdata)[n] = (uint8_t)value;
 			break;
 		case 2:
 			if (allow_signed) {
 				if (value < SHRT_MIN || value > SHRT_MAX)
 					goto error;
 			} else {
 				if (value < 0 || value > USHRT_MAX)
 					goto error;
 			}
 			((uint16_t *)pdata)[n] = (uint16_t)value;
 			break;
 		case 4:
 			if (allow_signed) {
 				if (value < INT_MIN || value > INT_MAX)
 					goto error;
 			} else {
 				if (value > UINT_MAX)
 					goto error;
 			}
 			((uint32_t *)pdata)[n] = (uint32_t)value;
 			break;
 		case 8:
 			((uint64_t *)pdata)[n] = (uint64_t)value;
 			break;
 		default:
 			goto error;
 		}
 		n++;
 	}
 	*psize = n * type_size;
 
 	if (n != 0)
 		return (1);	/* success */
 error:
 	return (0);	/* failure */
 }
 
 /*
  * Return an integer value from an environment variable.
  */
 int
 getenv_int(const char *name, int *data)
 {
 	quad_t tmp;
 	int rval;
 
 	rval = getenv_quad(name, &tmp);
 	if (rval)
 		*data = (int) tmp;
 	return (rval);
 }
 
 /*
  * Return an unsigned integer value from an environment variable.
  */
 int
 getenv_uint(const char *name, unsigned int *data)
 {
 	quad_t tmp;
 	int rval;
 
 	rval = getenv_quad(name, &tmp);
 	if (rval)
 		*data = (unsigned int) tmp;
 	return (rval);
 }
 
 /*
  * Return an int64_t value from an environment variable.
  */
 int
 getenv_int64(const char *name, int64_t *data)
 {
 	quad_t tmp;
 	int64_t rval;
 
 	rval = getenv_quad(name, &tmp);
 	if (rval)
 		*data = (int64_t) tmp;
 	return (rval);
 }
 
 /*
  * Return an uint64_t value from an environment variable.
  */
 int
 getenv_uint64(const char *name, uint64_t *data)
 {
 	quad_t tmp;
 	uint64_t rval;
 
 	rval = getenv_quad(name, &tmp);
 	if (rval)
 		*data = (uint64_t) tmp;
 	return (rval);
 }
 
 /*
  * Return a long value from an environment variable.
  */
 int
 getenv_long(const char *name, long *data)
 {
 	quad_t tmp;
 	int rval;
 
 	rval = getenv_quad(name, &tmp);
 	if (rval)
 		*data = (long) tmp;
 	return (rval);
 }
 
 /*
  * Return an unsigned long value from an environment variable.
  */
 int
 getenv_ulong(const char *name, unsigned long *data)
 {
 	quad_t tmp;
 	int rval;
 
 	rval = getenv_quad(name, &tmp);
 	if (rval)
 		*data = (unsigned long) tmp;
 	return (rval);
 }
 
 /*
  * Return a quad_t value from an environment variable.
  */
 int
 getenv_quad(const char *name, quad_t *data)
 {
 	char	value[KENV_MNAMELEN + 1 + KENV_MVALLEN + 1];
 	char	*vtp;
 	quad_t	iv;
 
 	if (!getenv_string(name, value, sizeof(value)))
 		return (0);
 	iv = strtoq(value, &vtp, 0);
 	if (vtp == value || (vtp[0] != '\0' && vtp[1] != '\0'))
 		return (0);
 	switch (vtp[0]) {
 	case 't': case 'T':
 		iv *= 1024;
 	case 'g': case 'G':
 		iv *= 1024;
 	case 'm': case 'M':
 		iv *= 1024;
 	case 'k': case 'K':
 		iv *= 1024;
 	case '\0':
 		break;
 	default:
 		return (0);
 	}
 	*data = iv;
 	return (1);
 }
 
 /*
  * Find the next entry after the one which (cp) falls within, return a
  * pointer to its start or NULL if there are no more.
  */
 static char *
 kernenv_next(char *cp)
 {
 
 	if (cp != NULL) {
 		while (*cp != 0)
 			cp++;
 		cp++;
 		if (*cp == 0)
 			cp = NULL;
 	}
 	return (cp);
 }
 
 void
 tunable_int_init(void *data)
 {
 	struct tunable_int *d = (struct tunable_int *)data;
 
 	TUNABLE_INT_FETCH(d->path, d->var);
 }
 
 void
 tunable_long_init(void *data)
 {
 	struct tunable_long *d = (struct tunable_long *)data;
 
 	TUNABLE_LONG_FETCH(d->path, d->var);
 }
 
 void
 tunable_ulong_init(void *data)
 {
 	struct tunable_ulong *d = (struct tunable_ulong *)data;
 
 	TUNABLE_ULONG_FETCH(d->path, d->var);
 }
 
 void
 tunable_int64_init(void *data)
 {
 	struct tunable_int64 *d = (struct tunable_int64 *)data;
 
 	TUNABLE_INT64_FETCH(d->path, d->var);
 }
 
 void
 tunable_uint64_init(void *data)
 {
 	struct tunable_uint64 *d = (struct tunable_uint64 *)data;
 
 	TUNABLE_UINT64_FETCH(d->path, d->var);
 }
 
 void
 tunable_quad_init(void *data)
 {
 	struct tunable_quad *d = (struct tunable_quad *)data;
 
 	TUNABLE_QUAD_FETCH(d->path, d->var);
 }
 
 void
 tunable_str_init(void *data)
 {
 	struct tunable_str *d = (struct tunable_str *)data;
 
 	TUNABLE_STR_FETCH(d->path, d->var, d->size);
 }
Index: stable/11/sys/kern/subr_hints.c
===================================================================
--- stable/11/sys/kern/subr_hints.c	(revision 337332)
+++ stable/11/sys/kern/subr_hints.c	(revision 337333)
@@ -1,477 +1,506 @@
 /*-
  * Copyright (c) 2000,2001 Peter Wemm <peter@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/lock.h>
+#include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/mutex.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/bus.h>
 
-#define	HINTMODE_KENV		0
-#define	HINTMODE_STATIC		1
-#define	HINTMODE_FALLBACK	2
+#define	FBACK_MDENV	0	/* MD env (e.g. loader.conf) */
+#define	FBACK_STENV	1	/* Static env */
+#define	FBACK_STATIC	2	/* static_hints */
 
 /*
- * Access functions for device resources.
+ * We'll use hintenv_merged to indicate that the dynamic environment has been
+ * properly prepared for hint usage.  This implies that the dynamic environment
+ * has already been setup (dynamic_kenv) and that we have added any supplied
+ * static_hints to the dynamic environment.
  */
+static int	hintenv_merged;
 
-static int checkmethod = 1;
-static char *hintp;
-
 /*
- * Define kern.hintmode sysctl, which only accept value 2, that cause to
- * switch from Static KENV mode to Dynamic KENV. So systems that have hints
- * compiled into kernel will be able to see/modify KENV (and hints too).
+ * Access functions for device resources.
  */
 
-static int
-sysctl_hintmode(SYSCTL_HANDLER_ARGS)
+static void
+static_hints_to_env(void *data __unused)
 {
 	const char *cp;
 	char *line, *eq;
-	int eqidx, error, i, value;
+	int eqidx, i;
 
-	value = hintmode;
-
-	/* Fetch candidate for new hintmode value */
-	error = sysctl_handle_int(oidp, &value, 0, req);
-	if (error || req->newptr == NULL)
-		return (error);
-
-	if (value != HINTMODE_FALLBACK)
-		/* Only accept swithing to hintmode 2 */
-		return (EINVAL);
-
-	/*
-	 * The rest of the sysctl handler is just making sure that our
-	 * environment is consistent with the world we've already seen.
-	 * If we came from kenv at all, then we have nothing to do: static
-	 * kenv will get merged into dynamic kenv as soon as kmem becomes
-	 * available, dynamic kenv is the environment we'd be setting these
-	 * things in anyways. Therefore, we have nothing left to do unless
-	 * we came from a static hints configuration.
-	 */
-	if (hintmode != HINTMODE_STATIC) {
-		hintmode = value;
-		return (0);
-	}
-
 	cp = static_hints;
 	while (cp && *cp != '\0') {
 		eq = strchr(cp, '=');
 		if (eq == NULL)
 			/* Bad hint value */
 			continue;
 		eqidx = eq - cp;
 
 		i = strlen(cp);
-		line = malloc(i+1, M_TEMP, M_WAITOK);
+		line = malloc(i + 1, M_TEMP, M_WAITOK);
 		strcpy(line, cp);
-		line[eqidx] = '\0';
-		kern_setenv(line, line + eqidx + 1);
+		line[eqidx] = line[i] = '\0';
+		/*
+		 * Before adding a hint to the dynamic environment, check if
+		 * another value for said hint has already been added.  This is
+		 * needed because static environment overrides static hints and
+		 * dynamic environment overrides all.
+		 */
+		if (testenv(line) == 0)
+			kern_setenv(line, line + eqidx + 1);
 		free(line, M_TEMP);
 		cp += i + 1;
 	}
-
-	hintmode = value;
-	return (0);
+	hintenv_merged = 1;
 }
 
-SYSCTL_PROC(_kern, OID_AUTO, hintmode, CTLTYPE_INT|CTLFLAG_RW,
-    &hintmode, 0, sysctl_hintmode, "I", "Get/set current hintmode");
+/* Any time after dynamic env is setup */
+SYSINIT(hintenv, SI_SUB_KMEM + 1, SI_ORDER_SECOND, static_hints_to_env, NULL);
 
 /*
+ * Checks the environment to see if we even have any hints.  If it has no hints,
+ * then res_find can take the hint that there's no point in searching it and
+ * either move on to the next environment or fail early.
+ */
+static bool
+_res_checkenv(char *envp)
+{
+	char *cp;
+
+	cp = envp;
+	while (cp) {
+		if (strncmp(cp, "hint.", 5) == 0)
+			return (true);
+		while (*cp != '\0')
+			cp++;
+		cp++;
+		if (*cp == '\0')
+			break;
+	}
+	return (false);
+}
+
+/*
  * Evil wildcarding resource string lookup.
  * This walks the supplied env string table and returns a match.
  * The start point can be remembered for incremental searches.
  */
 static int
-res_find(int *line, int *startln,
+res_find(char **hintp_cookie, int *line, int *startln,
     const char *name, int *unit, const char *resname, const char *value,
     const char **ret_name, int *ret_namelen, int *ret_unit,
     const char **ret_resname, int *ret_resnamelen, const char **ret_value)
 {
-	int n = 0, hit, i = 0;
+	int dyn_used = 0, fbacklvl = FBACK_MDENV, hit, i = 0, n = 0;
 	char r_name[32];
-	int r_unit, use_kenv = (hintmode != HINTMODE_STATIC && dynamic_kenv);
+	int r_unit;
 	char r_resname[32];
 	char r_value[128];
 	const char *s, *cp;
-	char *p;
+	char *hintp, *p;
 
-	if (checkmethod) {
-		hintp = NULL;
 
-		switch (hintmode) {
-		case HINTMODE_KENV:	/* loader hints in environment only */
-			break;
-		case HINTMODE_STATIC:	/* static hints only */
-			hintp = static_hints;
-			checkmethod = 0;
-			break;
-		case HINTMODE_FALLBACK:		/* fallback mode */
-			if (dynamic_kenv) {
-				mtx_lock(&kenv_lock);
-				cp = kenvp[0];
-				for (i = 0; cp != NULL; cp = kenvp[++i]) {
-					if (!strncmp(cp, "hint.", 5)) {
-						use_kenv = 1;
-						checkmethod = 0;
-						break;
-					}
+	/*
+	 * We are expecting that the caller will pass us a hintp_cookie that
+	 * they are tracking.  Upon entry, if *hintp_cookie is *not* set, this
+	 * indicates to us that we should be figuring out based on the current
+	 * environment where to search.  This keeps us sane throughout the
+	 * entirety of a single search.
+	 */
+	if (*hintp_cookie == NULL) {
+		hintp = NULL;
+		if (hintenv_merged) {
+			/*
+			 * static_hints, if it was previously used, has
+			 * already been folded in to the environment
+			 * by this point.
+			 */
+			mtx_lock(&kenv_lock);
+			cp = kenvp[0];
+			for (i = 0; cp != NULL; cp = kenvp[++i]) {
+				if (!strncmp(cp, "hint.", 5)) {
+					hintp = kenvp[0];
+					break;
 				}
-				mtx_unlock(&kenv_lock);
-			} else {
-				cp = kern_envp;
-				while (cp) {
-					if (strncmp(cp, "hint.", 5) == 0) {
-						cp = NULL;
-						hintp = kern_envp;
-						break;
-					}
-					while (*cp != '\0')
-						cp++;
-					cp++;
-					if (*cp == '\0') {
-						cp = NULL;
-						hintp = static_hints;
-						break;
-					}
-				}
 			}
-			break;
-		default:
-			break;
-		}
-		if (hintp == NULL) {
-			if (dynamic_kenv) {
-				use_kenv = 1;
-				checkmethod = 0;
-			} else
+			mtx_unlock(&kenv_lock);
+			dyn_used = 1;
+		} else {
+			/*
+			 * We'll have a chance to keep coming back here until
+			 * we've actually exhausted all of our possibilities.
+			 * We might have chosen the MD/Static env because it
+			 * had some kind of hints, but perhaps it didn't have
+			 * the hint we are looking for.  We don't provide any
+			 * fallback when searching the dynamic environment.
+			 */
+fallback:
+			if (dyn_used || fbacklvl >= FBACK_STATIC)
+				return (ENOENT);
+
+			if (fbacklvl <= FBACK_MDENV &&
+			    _res_checkenv(md_envp)) {
+				hintp = md_envp;
+				goto found;
+			}
+			fbacklvl++;
+
+			if (fbacklvl <= FBACK_STENV &&
+			    _res_checkenv(kern_envp)) {
 				hintp = kern_envp;
+				goto found;
+			}
+			fbacklvl++;
+
+			/* We'll fallback to static_hints if needed/can */
+			if (fbacklvl <= FBACK_STATIC &&
+			    _res_checkenv(static_hints))
+				hintp = static_hints;
+found:
+			fbacklvl++;
 		}
+
+		if (hintp == NULL)
+			return (ENOENT);
+		*hintp_cookie = hintp;
+	} else {
+		hintp = *hintp_cookie;
+		if (hintenv_merged && hintp == kenvp[0])
+			dyn_used = 1;
+		else
+			/*
+			 * If we aren't using the dynamic environment, we need
+			 * to run through the proper fallback procedure again.
+			 * This is so that we do continuations right if we're
+			 * working with *line and *startln.
+			 */
+			goto fallback;
 	}
 
-	if (use_kenv) {
+	if (dyn_used) {
 		mtx_lock(&kenv_lock);
 		i = 0;
-		cp = kenvp[0];
-		if (cp == NULL) {
-			mtx_unlock(&kenv_lock);
-			return (ENOENT);
-		}
-	} else
-		cp = hintp;
+	}
+
+	cp = hintp;
 	while (cp) {
 		hit = 1;
 		(*line)++;
 		if (strncmp(cp, "hint.", 5) != 0)
 			hit = 0;
 		else
 			n = sscanf(cp, "hint.%32[^.].%d.%32[^=]=%127s",
 			    r_name, &r_unit, r_resname, r_value);
-		if (hit && n != 4) {
-			printf("CONFIG: invalid hint '%s'\n", cp);
-			p = strchr(cp, 'h');
-			*p = 'H';
-			hit = 0;
+		/* We'll circumvent all of the checks if we already know */
+		if (hit) {
+			if (n != 4) {
+				printf("CONFIG: invalid hint '%s'\n", cp);
+				p = strchr(cp, 'h');
+				*p = 'H';
+				hit = 0;
+			}
+			if (hit && startln && *startln >= 0 && *line < *startln)
+				hit = 0;
+			if (hit && name && strcmp(name, r_name) != 0)
+				hit = 0;
+			if (hit && unit && *unit != r_unit)
+				hit = 0;
+			if (hit && resname && strcmp(resname, r_resname) != 0)
+				hit = 0;
+			if (hit && value && strcmp(value, r_value) != 0)
+				hit = 0;
+			if (hit)
+				break;
 		}
-		if (hit && startln && *startln >= 0 && *line < *startln)
-			hit = 0;
-		if (hit && name && strcmp(name, r_name) != 0)
-			hit = 0;
-		if (hit && unit && *unit != r_unit)
-			hit = 0;
-		if (hit && resname && strcmp(resname, r_resname) != 0)
-			hit = 0;
-		if (hit && value && strcmp(value, r_value) != 0)
-			hit = 0;
-		if (hit)
-			break;
-		if (use_kenv) {
+		if (dyn_used) {
 			cp = kenvp[++i];
 			if (cp == NULL)
 				break;
 		} else {
 			while (*cp != '\0')
 				cp++;
 			cp++;
 			if (*cp == '\0') {
 				cp = NULL;
 				break;
 			}
 		}
 	}
-	if (use_kenv)
+	if (dyn_used)
 		mtx_unlock(&kenv_lock);
 	if (cp == NULL)
-		return ENOENT;
+		goto fallback;
 
 	s = cp;
 	/* This is a bit of a hack, but at least is reentrant */
 	/* Note that it returns some !unterminated! strings. */
 	s = strchr(s, '.') + 1;		/* start of device */
 	if (ret_name)
 		*ret_name = s;
 	s = strchr(s, '.') + 1;		/* start of unit */
 	if (ret_namelen && ret_name)
 		*ret_namelen = s - *ret_name - 1; /* device length */
 	if (ret_unit)
 		*ret_unit = r_unit;
 	s = strchr(s, '.') + 1;		/* start of resname */
 	if (ret_resname)
 		*ret_resname = s;
 	s = strchr(s, '=') + 1;		/* start of value */
 	if (ret_resnamelen && ret_resname)
 		*ret_resnamelen = s - *ret_resname - 1; /* value len */
 	if (ret_value)
 		*ret_value = s;
 	if (startln)			/* line number for anchor */
 		*startln = *line + 1;
 	return 0;
 }
 
 /*
  * Search all the data sources for matches to our query.  We look for
  * dynamic hints first as overrides for static or fallback hints.
  */
 static int
 resource_find(int *line, int *startln,
     const char *name, int *unit, const char *resname, const char *value,
     const char **ret_name, int *ret_namelen, int *ret_unit,
     const char **ret_resname, int *ret_resnamelen, const char **ret_value)
 {
 	int i;
 	int un;
+	char *hintp;
 
 	*line = 0;
+	hintp = NULL;
 
 	/* Search for exact unit matches first */
-	i = res_find(line, startln, name, unit, resname, value,
+	i = res_find(&hintp, line, startln, name, unit, resname, value,
 	    ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
 	    ret_value);
 	if (i == 0)
 		return 0;
 	if (unit == NULL)
 		return ENOENT;
 	/* If we are still here, search for wildcard matches */
 	un = -1;
-	i = res_find(line, startln, name, &un, resname, value,
+	i = res_find(&hintp, line, startln, name, &un, resname, value,
 	    ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
 	    ret_value);
 	if (i == 0)
 		return 0;
 	return ENOENT;
 }
 
 int
 resource_int_value(const char *name, int unit, const char *resname, int *result)
 {
 	int error;
 	const char *str;
 	char *op;
 	unsigned long val;
 	int line;
 
 	line = 0;
 	error = resource_find(&line, NULL, name, &unit, resname, NULL,
 	    NULL, NULL, NULL, NULL, NULL, &str);
 	if (error)
 		return error;
 	if (*str == '\0') 
 		return EFTYPE;
 	val = strtoul(str, &op, 0);
 	if (*op != '\0') 
 		return EFTYPE;
 	*result = val;
 	return 0;
 }
 
 int
 resource_long_value(const char *name, int unit, const char *resname,
     long *result)
 {
 	int error;
 	const char *str;
 	char *op;
 	unsigned long val;
 	int line;
 
 	line = 0;
 	error = resource_find(&line, NULL, name, &unit, resname, NULL,
 	    NULL, NULL, NULL, NULL, NULL, &str);
 	if (error)
 		return error;
 	if (*str == '\0') 
 		return EFTYPE;
 	val = strtoul(str, &op, 0);
 	if (*op != '\0') 
 		return EFTYPE;
 	*result = val;
 	return 0;
 }
 
 int
 resource_string_value(const char *name, int unit, const char *resname,
     const char **result)
 {
 	int error;
 	const char *str;
 	int line;
 
 	line = 0;
 	error = resource_find(&line, NULL, name, &unit, resname, NULL,
 	    NULL, NULL, NULL, NULL, NULL, &str);
 	if (error)
 		return error;
 	*result = str;
 	return 0;
 }
 
 /*
  * This is a bit nasty, but allows us to not modify the env strings.
  */
 static const char *
 resource_string_copy(const char *s, int len)
 {
 	static char stringbuf[256];
 	static int offset = 0;
 	const char *ret;
 
 	if (len == 0)
 		len = strlen(s);
 	if (len > 255)
 		return NULL;
 	if ((offset + len + 1) > 255)
 		offset = 0;
 	bcopy(s, &stringbuf[offset], len);
 	stringbuf[offset + len] = '\0';
 	ret = &stringbuf[offset];
 	offset += len + 1;
 	return ret;
 }
 
 /*
  * err = resource_find_match(&anchor, &name, &unit, resname, value)
  * Iteratively fetch a list of devices wired "at" something
  * res and value are restrictions.  eg: "at", "scbus0".
  * For practical purposes, res = required, value = optional.
  * *name and *unit are set.
  * set *anchor to zero before starting.
  */
 int
 resource_find_match(int *anchor, const char **name, int *unit,
     const char *resname, const char *value)
 {
 	const char *found_name;
 	int found_namelen;
 	int found_unit;
 	int ret;
 	int newln;
 
 	newln = *anchor;
 	ret = resource_find(anchor, &newln, NULL, NULL, resname, value,
 	    &found_name, &found_namelen, &found_unit, NULL, NULL, NULL);
 	if (ret == 0) {
 		*name = resource_string_copy(found_name, found_namelen);
 		*unit = found_unit;
 	}
 	*anchor = newln;
 	return ret;
 }
 
 
 /*
  * err = resource_find_dev(&anchor, name, &unit, res, value);
  * Iterate through a list of devices, returning their unit numbers.
  * res and value are optional restrictions.  eg: "at", "scbus0".
  * *unit is set to the value.
  * set *anchor to zero before starting.
  */
 int
 resource_find_dev(int *anchor, const char *name, int *unit,
     const char *resname, const char *value)
 {
 	int found_unit;
 	int newln;
 	int ret;
 
 	newln = *anchor;
 	ret = resource_find(anchor, &newln, name, NULL, resname, value,
 	    NULL, NULL, &found_unit, NULL, NULL, NULL);
 	if (ret == 0) {
 		*unit = found_unit;
 	}
 	*anchor = newln;
 	return ret;
 }
 
 /*
  * Check to see if a device is disabled via a disabled hint.
  */
 int
 resource_disabled(const char *name, int unit)
 {
 	int error, value;
 
 	error = resource_int_value(name, unit, "disabled", &value);
 	if (error)
 	       return (0);
 	return (value);
 }
 
 /*
  * Clear a value associated with a device by removing it from
  * the kernel environment.  This only removes a hint for an
  * exact unit.
  */
 int
 resource_unset_value(const char *name, int unit, const char *resname)
 {
 	char varname[128];
 	const char *retname, *retvalue;
 	int error, line;
 	size_t len;
 
 	line = 0;
 	error = resource_find(&line, NULL, name, &unit, resname, NULL,
 	    &retname, NULL, NULL, NULL, NULL, &retvalue);
 	if (error)
 		return (error);
 
 	retname -= strlen("hint.");
 	len = retvalue - retname - 1;
 	if (len > sizeof(varname) - 1)
 		return (ENAMETOOLONG);
 	memcpy(varname, retname, len);
 	varname[len] = '\0';
 	return (kern_unsetenv(varname));
 }
Index: stable/11/sys/sys/systm.h
===================================================================
--- stable/11/sys/sys/systm.h	(revision 337332)
+++ stable/11/sys/sys/systm.h	(revision 337333)
@@ -1,489 +1,488 @@
 /*-
  * Copyright (c) 1982, 1988, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	@(#)systm.h	8.7 (Berkeley) 3/29/95
  * $FreeBSD$
  */
 
 #ifndef _SYS_SYSTM_H_
 #define	_SYS_SYSTM_H_
 
 #include <machine/atomic.h>
 #include <machine/cpufunc.h>
 #include <sys/callout.h>
 #include <sys/cdefs.h>
 #include <sys/queue.h>
 #include <sys/stdint.h>		/* for people using printf mainly */
 
 __NULLABILITY_PRAGMA_PUSH
 
 extern int cold;		/* nonzero if we are doing a cold boot */
 extern int suspend_blocked;	/* block suspend due to pending shutdown */
 extern int rebooting;		/* kern_reboot() has been called. */
 extern const char *panicstr;	/* panic message */
 extern char version[];		/* system version */
 extern char compiler_version[];	/* compiler version */
 extern char copyright[];	/* system copyright */
 extern int kstack_pages;	/* number of kernel stack pages */
 
 extern u_long pagesizes[];	/* supported page sizes */
 extern long physmem;		/* physical memory */
 extern long realmem;		/* 'real' memory */
 
 extern char *rootdevnames[2];	/* names of possible root devices */
 
 extern int boothowto;		/* reboot flags, from console subsystem */
 extern int bootverbose;		/* nonzero to print verbose messages */
 
 extern int maxusers;		/* system tune hint */
 extern int ngroups_max;		/* max # of supplemental groups */
 extern int vm_guest;		/* Running as virtual machine guest? */
 
 /*
  * Detected virtual machine guest types. The intention is to expand
  * and/or add to the VM_GUEST_VM type if specific VM functionality is
  * ever implemented (e.g. vendor-specific paravirtualization features).
  * Keep in sync with vm_guest_sysctl_names[].
  */
 enum VM_GUEST { VM_GUEST_NO = 0, VM_GUEST_VM, VM_GUEST_XEN, VM_GUEST_HV,
 		VM_GUEST_VMWARE, VM_GUEST_KVM, VM_GUEST_BHYVE, VM_LAST };
 
 #if defined(WITNESS) || defined(INVARIANT_SUPPORT)
 void	kassert_panic(const char *fmt, ...)  __printflike(1, 2);
 #endif
 
 #ifdef	INVARIANTS		/* The option is always available */
 #define	KASSERT(exp,msg) do {						\
 	if (__predict_false(!(exp)))					\
 		kassert_panic msg;					\
 } while (0)
 #define	VNASSERT(exp, vp, msg) do {					\
 	if (__predict_false(!(exp))) {					\
 		vn_printf(vp, "VNASSERT failed\n");			\
 		kassert_panic msg;					\
 	}								\
 } while (0)
 #else
 #define	KASSERT(exp,msg) do { \
 } while (0)
 
 #define	VNASSERT(exp, vp, msg) do { \
 } while (0)
 #endif
 
 #ifndef CTASSERT	/* Allow lint to override */
 #define	CTASSERT(x)	_Static_assert(x, "compile-time assertion failed")
 #endif
 
 /*
  * Assert that a pointer can be loaded from memory atomically.
  *
  * This assertion enforces stronger alignment than necessary.  For example,
  * on some architectures, atomicity for unaligned loads will depend on
  * whether or not the load spans multiple cache lines.
  */
 #define	ASSERT_ATOMIC_LOAD_PTR(var, msg)				\
 	KASSERT(sizeof(var) == sizeof(void *) &&			\
 	    ((uintptr_t)&(var) & (sizeof(void *) - 1)) == 0, msg)
 
 /*
  * Assert that a thread is in critical(9) section.
  */
 #define	CRITICAL_ASSERT(td)						\
 	KASSERT((td)->td_critnest >= 1, ("Not in critical section"));
  
 /*
  * If we have already panic'd and this is the thread that called
  * panic(), then don't block on any mutexes but silently succeed.
  * Otherwise, the kernel will deadlock since the scheduler isn't
  * going to run the thread that holds any lock we need.
  */
 #define	SCHEDULER_STOPPED_TD(td)  ({					\
 	MPASS((td) == curthread);					\
 	__predict_false((td)->td_stopsched);				\
 })
 #define	SCHEDULER_STOPPED() SCHEDULER_STOPPED_TD(curthread)
 
 /*
  * Align variables.
  */
 #define	__read_mostly		__section(".data.read_mostly")
 #define	__read_frequently	__section(".data.read_frequently")
 #define	__exclusive_cache_line	__aligned(CACHE_LINE_SIZE) \
 				    __section(".data.exclusive_cache_line")
 /*
  * XXX the hints declarations are even more misplaced than most declarations
  * in this file, since they are needed in one file (per arch) and only used
  * in two files.
  * XXX most of these variables should be const.
  */
 extern int osreldate;
-extern int envmode;
-extern int hintmode;		/* 0 = off. 1 = config, 2 = fallback */
 extern int dynamic_kenv;
 extern struct mtx kenv_lock;
 extern char *kern_envp;
+extern char *md_envp;
 extern char static_env[];
 extern char static_hints[];	/* by config for now */
 
 extern char **kenvp;
 
 extern const void *zero_region;	/* address space maps to a zeroed page	*/
 
 extern int unmapped_buf_allowed;
 
 #ifdef __LP64__
 #define	IOSIZE_MAX		iosize_max()
 #define	DEVFS_IOSIZE_MAX	devfs_iosize_max()
 #else
 #define	IOSIZE_MAX		SSIZE_MAX
 #define	DEVFS_IOSIZE_MAX	SSIZE_MAX
 #endif
 
 /*
  * General function declarations.
  */
 
 struct inpcb;
 struct lock_object;
 struct malloc_type;
 struct mtx;
 struct proc;
 struct socket;
 struct thread;
 struct tty;
 struct ucred;
 struct uio;
 struct _jmp_buf;
 struct trapframe;
 struct eventtimer;
 
 int	setjmp(struct _jmp_buf *) __returns_twice;
 void	longjmp(struct _jmp_buf *, int) __dead2;
 int	dumpstatus(vm_offset_t addr, off_t count);
 int	nullop(void);
 int	eopnotsupp(void);
 int	ureadc(int, struct uio *);
 void	hashdestroy(void *, struct malloc_type *, u_long);
 void	*hashinit(int count, struct malloc_type *type, u_long *hashmask);
 void	*hashinit_flags(int count, struct malloc_type *type,
     u_long *hashmask, int flags);
 #define	HASH_NOWAIT	0x00000001
 #define	HASH_WAITOK	0x00000002
 
 void	*phashinit(int count, struct malloc_type *type, u_long *nentries);
 void	*phashinit_flags(int count, struct malloc_type *type, u_long *nentries,
     int flags);
 void	g_waitidle(void);
 
 void	panic(const char *, ...) __dead2 __printflike(1, 2);
 void	vpanic(const char *, __va_list) __dead2 __printflike(1, 0);
 
 void	cpu_boot(int);
 void	cpu_flush_dcache(void *, size_t);
 void	cpu_rootconf(void);
 void	critical_enter(void);
 void	critical_exit(void);
 void	init_param1(void);
 void	init_param2(long physpages);
 void	init_static_kenv(char *, size_t);
 void	tablefull(const char *);
 #ifdef  EARLY_PRINTF
 typedef void early_putc_t(int ch);
 extern early_putc_t *early_putc;
 #endif
 int	kvprintf(char const *, void (*)(int, void*), void *, int,
 	    __va_list) __printflike(1, 0);
 void	log(int, const char *, ...) __printflike(2, 3);
 void	log_console(struct uio *);
 void	vlog(int, const char *, __va_list) __printflike(2, 0);
 int	asprintf(char **ret, struct malloc_type *mtp, const char *format, 
 	    ...) __printflike(3, 4);
 int	printf(const char *, ...) __printflike(1, 2);
 int	snprintf(char *, size_t, const char *, ...) __printflike(3, 4);
 int	sprintf(char *buf, const char *, ...) __printflike(2, 3);
 int	uprintf(const char *, ...) __printflike(1, 2);
 int	vprintf(const char *, __va_list) __printflike(1, 0);
 int	vasprintf(char **ret, struct malloc_type *mtp, const char *format,
 	    __va_list ap) __printflike(3, 0);
 int	vsnprintf(char *, size_t, const char *, __va_list) __printflike(3, 0);
 int	vsnrprintf(char *, size_t, int, const char *, __va_list) __printflike(4, 0);
 int	vsprintf(char *buf, const char *, __va_list) __printflike(2, 0);
 int	ttyprintf(struct tty *, const char *, ...) __printflike(2, 3);
 int	sscanf(const char *, char const * _Nonnull, ...) __scanflike(2, 3);
 int	vsscanf(const char * _Nonnull, char const * _Nonnull, __va_list)  __scanflike(2, 0);
 long	strtol(const char *, char **, int);
 u_long	strtoul(const char *, char **, int);
 quad_t	strtoq(const char *, char **, int);
 u_quad_t strtouq(const char *, char **, int);
 void	tprintf(struct proc *p, int pri, const char *, ...) __printflike(3, 4);
 void	vtprintf(struct proc *, int, const char *, __va_list) __printflike(3, 0);
 void	hexdump(const void *ptr, int length, const char *hdr, int flags);
 #define	HD_COLUMN_MASK	0xff
 #define	HD_DELIM_MASK	0xff00
 #define	HD_OMIT_COUNT	(1 << 16)
 #define	HD_OMIT_HEX	(1 << 17)
 #define	HD_OMIT_CHARS	(1 << 18)
 
 #define ovbcopy(f, t, l) bcopy((f), (t), (l))
 void	bcopy(const void * _Nonnull from, void * _Nonnull to, size_t len);
 void	bzero(void * _Nonnull buf, size_t len);
 void	explicit_bzero(void * _Nonnull, size_t);
 
 void	*memcpy(void * _Nonnull to, const void * _Nonnull from, size_t len);
 void	*memmove(void * _Nonnull dest, const void * _Nonnull src, size_t n);
 
 int	copystr(const void * _Nonnull __restrict kfaddr,
 	    void * _Nonnull __restrict kdaddr, size_t len,
 	    size_t * __restrict lencopied);
 int	copyinstr(const void * __restrict udaddr,
 	    void * _Nonnull __restrict kaddr, size_t len,
 	    size_t * __restrict lencopied);
 int	copyin(const void * __restrict udaddr,
 	    void * _Nonnull __restrict kaddr, size_t len);
 int	copyin_nofault(const void * __restrict udaddr,
 	    void * _Nonnull __restrict kaddr, size_t len);
 int	copyout(const void * _Nonnull __restrict kaddr,
 	    void * __restrict udaddr, size_t len);
 int	copyout_nofault(const void * _Nonnull __restrict kaddr,
 	    void * __restrict udaddr, size_t len);
 
 int	fubyte(volatile const void *base);
 long	fuword(volatile const void *base);
 int	fuword16(volatile const void *base);
 int32_t	fuword32(volatile const void *base);
 int64_t	fuword64(volatile const void *base);
 int	fueword(volatile const void *base, long *val);
 int	fueword32(volatile const void *base, int32_t *val);
 int	fueword64(volatile const void *base, int64_t *val);
 int	subyte(volatile void *base, int byte);
 int	suword(volatile void *base, long word);
 int	suword16(volatile void *base, int word);
 int	suword32(volatile void *base, int32_t word);
 int	suword64(volatile void *base, int64_t word);
 uint32_t casuword32(volatile uint32_t *base, uint32_t oldval, uint32_t newval);
 u_long	casuword(volatile u_long *p, u_long oldval, u_long newval);
 int	casueword32(volatile uint32_t *base, uint32_t oldval, uint32_t *oldvalp,
 	    uint32_t newval);
 int	casueword(volatile u_long *p, u_long oldval, u_long *oldvalp,
 	    u_long newval);
 
 void	realitexpire(void *);
 
 int	sysbeep(int hertz, int period);
 
 void	hardclock(int usermode, uintfptr_t pc);
 void	hardclock_cnt(int cnt, int usermode);
 void	hardclock_cpu(int usermode);
 void	hardclock_sync(int cpu);
 void	softclock(void *);
 void	statclock(int usermode);
 void	statclock_cnt(int cnt, int usermode);
 void	profclock(int usermode, uintfptr_t pc);
 void	profclock_cnt(int cnt, int usermode, uintfptr_t pc);
 
 int	hardclockintr(void);
 
 void	startprofclock(struct proc *);
 void	stopprofclock(struct proc *);
 void	cpu_startprofclock(void);
 void	cpu_stopprofclock(void);
 void	suspendclock(void);
 void	resumeclock(void);
 sbintime_t 	cpu_idleclock(void);
 void	cpu_activeclock(void);
 void	cpu_new_callout(int cpu, sbintime_t bt, sbintime_t bt_opt);
 void	cpu_et_frequency(struct eventtimer *et, uint64_t newfreq);
 extern int	cpu_disable_c2_sleep;
 extern int	cpu_disable_c3_sleep;
 
 int	cr_cansee(struct ucred *u1, struct ucred *u2);
 int	cr_canseesocket(struct ucred *cred, struct socket *so);
 int	cr_canseeinpcb(struct ucred *cred, struct inpcb *inp);
 
 char	*kern_getenv(const char *name);
 void	freeenv(char *env);
 int	getenv_int(const char *name, int *data);
 int	getenv_uint(const char *name, unsigned int *data);
 int	getenv_long(const char *name, long *data);
 int	getenv_ulong(const char *name, unsigned long *data);
 int	getenv_string(const char *name, char *data, int size);
 int	getenv_int64(const char *name, int64_t *data);
 int	getenv_uint64(const char *name, uint64_t *data);
 int	getenv_quad(const char *name, quad_t *data);
 int	kern_setenv(const char *name, const char *value);
 int	kern_unsetenv(const char *name);
 int	testenv(const char *name);
 
 int	getenv_array(const char *name, void *data, int size, int *psize,
     int type_size, bool allow_signed);
 #define	GETENV_UNSIGNED	false	/* negative numbers not allowed */
 #define	GETENV_SIGNED	true	/* negative numbers allowed */
 
 typedef uint64_t (cpu_tick_f)(void);
 void set_cputicker(cpu_tick_f *func, uint64_t freq, unsigned var);
 extern cpu_tick_f *cpu_ticks;
 uint64_t cpu_tickrate(void);
 uint64_t cputick2usec(uint64_t tick);
 
 #ifdef APM_FIXUP_CALLTODO
 struct timeval;
 void	adjust_timeout_calltodo(struct timeval *time_change);
 #endif /* APM_FIXUP_CALLTODO */
 
 #include <sys/libkern.h>
 
 /* Initialize the world */
 void	consinit(void);
 void	cpu_initclocks(void);
 void	cpu_initclocks_bsp(void);
 void	cpu_initclocks_ap(void);
 void	usrinfoinit(void);
 
 /* Finalize the world */
 void	kern_reboot(int) __dead2;
 void	shutdown_nice(int);
 
 /* Timeouts */
 typedef void timeout_t(void *);	/* timeout function type */
 #define CALLOUT_HANDLE_INITIALIZER(handle)	\
 	{ NULL }
 
 void	callout_handle_init(struct callout_handle *);
 struct	callout_handle timeout(timeout_t *, void *, int);
 void	untimeout(timeout_t *, void *, struct callout_handle);
 
 /* Stubs for obsolete functions that used to be for interrupt management */
 static __inline intrmask_t	splbio(void)		{ return 0; }
 static __inline intrmask_t	splcam(void)		{ return 0; }
 static __inline intrmask_t	splclock(void)		{ return 0; }
 static __inline intrmask_t	splhigh(void)		{ return 0; }
 static __inline intrmask_t	splimp(void)		{ return 0; }
 static __inline intrmask_t	splnet(void)		{ return 0; }
 static __inline intrmask_t	spltty(void)		{ return 0; }
 static __inline void		splx(intrmask_t ipl __unused)	{ return; }
 
 /*
  * Common `proc' functions are declared here so that proc.h can be included
  * less often.
  */
 int	_sleep(void * _Nonnull chan, struct lock_object *lock, int pri,
 	   const char *wmesg, sbintime_t sbt, sbintime_t pr, int flags);
 #define	msleep(chan, mtx, pri, wmesg, timo)				\
 	_sleep((chan), &(mtx)->lock_object, (pri), (wmesg),		\
 	    tick_sbt * (timo), 0, C_HARDCLOCK)
 #define	msleep_sbt(chan, mtx, pri, wmesg, bt, pr, flags)		\
 	_sleep((chan), &(mtx)->lock_object, (pri), (wmesg), (bt), (pr),	\
 	    (flags))
 int	msleep_spin_sbt(void * _Nonnull chan, struct mtx *mtx,
 	    const char *wmesg, sbintime_t sbt, sbintime_t pr, int flags);
 #define	msleep_spin(chan, mtx, wmesg, timo)				\
 	msleep_spin_sbt((chan), (mtx), (wmesg), tick_sbt * (timo),	\
 	    0, C_HARDCLOCK)
 int	pause_sbt(const char *wmesg, sbintime_t sbt, sbintime_t pr,
 	    int flags);
 #define	pause(wmesg, timo)						\
 	pause_sbt((wmesg), tick_sbt * (timo), 0, C_HARDCLOCK)
 #define	pause_sig(wmesg, timo)						\
 	pause_sbt((wmesg), tick_sbt * (timo), 0, C_HARDCLOCK | C_CATCH)
 #define	tsleep(chan, pri, wmesg, timo)					\
 	_sleep((chan), NULL, (pri), (wmesg), tick_sbt * (timo),		\
 	    0, C_HARDCLOCK)
 #define	tsleep_sbt(chan, pri, wmesg, bt, pr, flags)			\
 	_sleep((chan), NULL, (pri), (wmesg), (bt), (pr), (flags))
 void	wakeup(void * chan);
 void	wakeup_one(void * chan);
 
 /*
  * Common `struct cdev *' stuff are declared here to avoid #include poisoning
  */
 
 struct cdev;
 dev_t dev2udev(struct cdev *x);
 const char *devtoname(struct cdev *cdev);
 
 #ifdef __LP64__
 size_t	devfs_iosize_max(void);
 size_t	iosize_max(void);
 #endif
 
 int poll_no_poll(int events);
 
 /* XXX: Should be void nanodelay(u_int nsec); */
 void	DELAY(int usec);
 
 /* Root mount holdback API */
 struct root_hold_token;
 
 struct root_hold_token *root_mount_hold(const char *identifier);
 void root_mount_rel(struct root_hold_token *h);
 int root_mounted(void);
 
 
 /*
  * Unit number allocation API. (kern/subr_unit.c)
  */
 struct unrhdr;
 struct unrhdr *new_unrhdr(int low, int high, struct mtx *mutex);
 void init_unrhdr(struct unrhdr *uh, int low, int high, struct mtx *mutex);
 void delete_unrhdr(struct unrhdr *uh);
 void clean_unrhdr(struct unrhdr *uh);
 void clean_unrhdrl(struct unrhdr *uh);
 int alloc_unr(struct unrhdr *uh);
 int alloc_unr_specific(struct unrhdr *uh, u_int item);
 int alloc_unrl(struct unrhdr *uh);
 void free_unr(struct unrhdr *uh, u_int item);
 
 void	intr_prof_stack_use(struct thread *td, struct trapframe *frame);
 
 void counted_warning(unsigned *counter, const char *msg);
 
 /*
  * APIs to manage deprecation and obsolescence.
  */
 struct device;
 void _gone_in(int major, const char *msg);
 void _gone_in_dev(struct device *dev, int major, const char *msg);
 #ifdef NO_OBSOLETE_CODE
 #define __gone_ok(m, msg)					 \
 	_Static_assert(m < P_OSREL_MAJOR(__FreeBSD_version)),	 \
 	    "Obsolete code" msg);
 #else
 #define	__gone_ok(m, msg)
 #endif
 #define gone_in(major, msg)		__gone_ok(major, msg) _gone_in(major, msg)
 #define gone_in_dev(dev, major, msg)	__gone_ok(major, msg) _gone_in_dev(dev, major, msg)
 
 __NULLABILITY_PRAGMA_POP
 
 #endif /* !_SYS_SYSTM_H_ */
Index: stable/11/tools/build/Makefile
===================================================================
--- stable/11/tools/build/Makefile	(revision 337332)
+++ stable/11/tools/build/Makefile	(revision 337333)
@@ -1,52 +1,55 @@
 # $FreeBSD$
 
 .PATH: ${.CURDIR}/../../include
 
 LIB=		egacy
 SRC=
 INCSGROUPS=	INCS SYSINCS
 INCS=
 
 SYSINCSDIR=	${INCLUDEDIR}/sys
 
 BOOTSTRAPPING?=	0
 
 _WITH_PWCACHEDB!= grep -c pwcache_groupdb /usr/include/grp.h || true
 .if ${_WITH_PWCACHEDB} == 0
 .PATH: ${.CURDIR}/../../contrib/libc-pwcache
 CFLAGS+=	-I${.CURDIR}/../../contrib/libc-pwcache \
 		-I${.CURDIR}/../../lib/libc/include
 SRCS+=		pwcache.c
 .endif
 
 _WITH_STRSVIS!=	grep -c strsvis /usr/include/vis.h || true
 .if ${_WITH_STRSVIS} == 0
 .PATH: ${.CURDIR}/../../contrib/libc-vis
 SRCS+=		vis.c
 CFLAGS+=	-I${.CURDIR}/../../contrib/libc-vis \
 		-I${.CURDIR}/../../lib/libc/include
 .endif
 
 _WITH_REALLOCARRAY!= grep -c reallocarray /usr/include/stdlib.h || true
 .if ${_WITH_REALLOCARRAY} == 0
 .PATH: ${.CURDIR}/../../lib/libc/stdlib
 INCS+=		stdlib.h
 SRCS+=		reallocarray.c
 CFLAGS+=	-I${.CURDIR}/../../lib/libc/include
 .endif
 
 _WITH_UTIMENS!= grep -c utimensat /usr/include/sys/stat.h || true
 .if ${_WITH_UTIMENS} == 0
 SYSINCS+=	stat.h
 SRCS+=		futimens.c utimensat.c
 .endif
 
 .if empty(SRCS)
 SRCS=		dummy.c
 .endif
 
 .if defined(CROSS_BUILD_TESTING)
 SUBDIR=		cross-build
 .endif
 
+# Needed to build config (since it uses libnv)
+SYSINCS+=	${SRCTOP}/sys/sys/nv.h ${SRCTOP}/sys/sys/cnv.h
+
 .include <bsd.lib.mk>
Index: stable/11/usr.sbin/config/Makefile
===================================================================
--- stable/11/usr.sbin/config/Makefile	(revision 337332)
+++ stable/11/usr.sbin/config/Makefile	(revision 337333)
@@ -1,27 +1,27 @@
 # 	@(#)Makefile	8.1 (Berkeley) 6/6/93
 # $FreeBSD$
 
 SRCDIR:=${.PARSEDIR:tA}
 
 PROG=	config
 MAN=	config.5 config.8
 SRCS=	config.y main.c lang.l mkmakefile.c mkheaders.c \
 	mkoptions.c y.tab.h kernconf.c
 
 FILE2C?=file2c
 
 kernconf.c: kernconf.tmpl
 	${FILE2C} 'char kernconfstr[] = {' ',0};' < \
 	    ${SRCDIR}/kernconf.tmpl > kernconf.c
 
 CFLAGS+= -I. -I${SRCDIR}
 
 NO_WMISSING_VARIABLE_DECLARATIONS=
 
-LIBADD=	l sbuf
+LIBADD=	l nv sbuf
 
 CLEANFILES+=	kernconf.c
 
 mkmakefile.o: configvers.h
 
 .include <bsd.prog.mk>
Index: stable/11/usr.sbin/config/config.5
===================================================================
--- stable/11/usr.sbin/config/config.5	(revision 337332)
+++ stable/11/usr.sbin/config/config.5	(revision 337333)
@@ -1,440 +1,482 @@
 .\" Copyright (c) 2003 Joseph Koshy
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions and the following disclaimer.
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 .\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
 .\" $FreeBSD$
 .\"
-.Dd June 26, 2018
+.Dd July 11, 2018
 .Dt CONFIG 5
 .Os
 .Sh NAME
 .Nm config
 .Nd kernel configuration file format
 .Sh DESCRIPTION
 A kernel configuration file specifies the configuration of a
 .Fx
 kernel.
 It is processed by
 .Xr config 8
 to create a build environment where a kernel may be built using
 .Xr make 1 .
 .Ss Lexical Structure
 A kernel configuration file comprises a sequence of specification
 directives.
 .Pp
 A specification directive starts with a keyword at the beginning
 of the line and is followed by additional parameters.
 .Pp
 A specification directive may be terminated by a semicolon
 .Ql \&;
 or by a newline.
 Long input lines may be broken into shorter lines by starting the
 second and subsequent lines with a white space character.
 .Pp
 Case is significant,
 .Dq Li machine
 and
 .Dq Li MACHINE
 are different tokens.
 .Pp
 A double quote character
 .Ql \[dq]
 starts a quoted string.
 All characters up to the next quote character form the value
 of the quoted string.
 A
 .Ql \[dq]
 character may be inserted into a quoted string by
 using the sequence
 .Ql \e\[dq] .
 .Pp
 Numbers are specified using
 .Tn C Ns -style
 syntax.
 .Pp
 A
 .Ql #
 character starts a comment; all characters from the
 .Ql #
 character till the end of the current line are ignored.
 .Pp
 Whitespace between tokens is ignored, except inside quoted strings.
 Whitespace following a comment line is ignored.
 .Ss Configuration Directives
 Kernel configuration directives may appear in any order
 in a kernel configuration file.
 Directives are processed in order of appearance with subsequent
 directive lines overriding the effect of prior ones.
 .Pp
 The list of keywords and their meanings are as follows:
 .Pp
 .Bl -tag -width indent -compact
 .\" -------- CPU --------
 .It Ic cpu Ar cputype
 Specify the CPU this kernel will run on.
 There can be more than one
 .Ic cpu
 directive in a configuration file.
 The allowed list of CPU names is architecture specific and is
 defined in the file
 .Pa sys/conf/options. Ns Aq Ar arch .
 .\" -------- DEVICE --------
 .Pp
 .It Ic device Ar name Op , Ar name Op ...
 .It Ic devices Ar name Op , Ar name Op ...
 Configures the specified devices
 for inclusion into the kernel image.
 Devices that are common to all architectures are
 defined in the file
 .Pa sys/conf/files .
 Devices that are specific to architecture
 .Ar arch
 are defined in the file
 .Pa sys/conf/files. Ns Aq Ar arch .
 .\" -------- ENV --------
 .Pp
 .It Ic env Ar filename
 Specifies a filename containing a kernel environment definition.
-The kernel normally uses an environment prepared for it at boot time
-by
+.Pp
+The kernel will augment this compiled-in environment with the environment
+prepared for it at boot time by
 .Xr loader 8 .
-This directive makes the kernel ignore the boot environment and use
-the compiled-in environment instead, unless the boot environment contains
-.Va static_env.disabled=1 .
+Environment variables specified in the
+.Xr loader 8
+environment will take precedence over environment variables specified in
+.Ar filename ,
+and environment variables specified in the dynamic environment take precedence
+over both of these.
 .Pp
+.Va loader_env.disabled=1
+may be specified in the static environment to disable the
+.Xr loader 8
+environment.
+Disabling the
+.Xr loader 8
+should be done with caution and due consideration for whether or not it supplies
+environment variables needed for properly booting the system.
+.Pp
+.Va static_env.disabled=1
+may be specified in the
+.Xr loader 8
+environment to disable use of the static environment.
+This option has no effect if specified in any environment after the
+.Xr loader 8
+environment is processed.
+This option is not usable in conjunction with
+.Va loader_env.disabled .
+.Pp
 This directive is useful for setting kernel tunables in
 embedded environments that do not start from
 .Xr loader 8 .
 .Pp
 All
 .Ic env
 and
 .Ic envvar
 directives will be processed and added to the static environment in reversed
 order of appearance so that later specified variables properly override earlier
 specified variables.
 Note that within
 .Ar filename ,
 the first appearance of a given variable will be the first one seen by the
 kernel, effectively shadowing any later appearances of the same variable within
 .Ar filename .
 .\" -------- ENVVAR --------
 .Pp
 .It Ic envvar Ar setting
 Specifies an individual environment setting to be added to the kernel's
 compiled-in environment.
 .Ar setting
 must be of the form
 .Dq Va name=value .
 Optional quotes are supported in both name and value.
 .Pp
 All
 .Ic env
 and
 .Ic envvar
 directives will be processed and added to the static environment in reversed
 order of appearance so that later specified variables properly override earlier
 specified variables.
 .\" -------- FILES --------
 .Pp
 .It Ic files Ar filename
 Specifies a file containing a list of files specific to that kernel
 configuration file (a la
 .Pa files. Ns Aq Ar arch ) .
 .\" -------- HINTS --------
 .Pp
 .It Ic hints Ar filename
 Specifies a file to load a static device configuration specification
 from.
 From
 .Fx 5.0
 onwards, the kernel reads the system's device configuration at boot
 time (see
 .Xr device.hints 5 ) .
 This directive configures the kernel to use the static device configuration
 listed in
-.Ar filename ,
-unless the boot environment contains
-.Va static_hints.disabled=1 .
+.Ar filename .
+.Pp
+Hints provided in this static device configuration will be overwritten in the
+order in which they're encountered.
+Hints in the compiled-in environment takes precedence over compiled-in hints,
+and hints in the environment prepared for the kernel by
+.Xr loader 8
+takes precedence over hints in the compiled-in environment.
+.Pp
+Once the dynamic environment becomes available, all compiled-in hints will be
+added to the dynamic environment if they do not already have an override in
+the dynamic environment.
+The dynamic environment will then be used for all searches of hints.
+.Pp
+.Va static_hints.disabled=1
+may be specified in either a compiled-in environment or the
+.Xr loader 8
+environment to disable use of these hints files.
+This option has no effect if specified in any environment after the
+.Xr loader 8
+environment is processed.
+.Pp
 The file
 .Ar filename
 must conform to the syntax specified by
 .Xr device.hints 5 .
 Multiple hints lines are allowed.
 The resulting hints will be the files concatenated in reverse order of
 appearance so that hints in later files properly override hints in earlier
 files.
 .\" -------- IDENT --------
 .Pp
 .It Ic ident Ar name
 Set the kernel name to
 .Ar name .
 At least one
 .Ic ident
 directive is required.
 .\" -------- INCLUDE --------
 .Pp
 .It Ic include Ar filename
 Read subsequent text from file
 .Ar filename
 and return to the current file after
 .Ar filename
 is successfully processed.
 .\" -------- MACHINE --------
 .Pp
 .It Ic machine Ar arch Op Ar cpuarch
 Specifies the architecture of the machine the kernel is being
 compiled for.
 Legal values for
 .Ar arch
 include:
 .Pp
 .Bl -tag -width ".Cm powerpc" -compact
 .It Cm alpha
 The DEC Alpha architecture.
 .It Cm arm
 The ARM architecture.
 .It Cm amd64
 The AMD x86-64 architecture.
 .It Cm i386
 The Intel x86 based PC architecture.
 .It Cm mips
 The MIPS architecture.
 .It Cm pc98
 The PC98 architecture.
 .It Cm powerpc
 The IBM PowerPC architecture.
 .It Cm sparc64
 The Sun Sparc64 architecture.
 .El
 .Pp
 If argument
 .Ar cpuarch
 is specified, it points
 .Xr config 8
 to the cpu architecture of the machine.
 Currently the
 .Cm pc98
 architecture requires its cpu architecture
 to be set to
 .Cm i386 .
 When
 .Ar cpuarch
 is not specified, it is assumed to be the same as
 .Ar arch .
 .Ar arch
 corresponds to MACHINE.
 .Ar cpuarch
 corresponds to MACHINE_ARCH.
 .Pp
 A kernel configuration file may have only one
 .Ic machine
 directive.
 .\" -------- MAKEOPTION --------
 .Pp
 .It Ic makeoption Ar options
 .It Ic makeoptions Ar options
 Add
 .Ar options
 to the generated makefile.
 .Pp
 The
 .Ar options
 argument is a comma separated list of one or more option
 specifications.
 Each option specification has the form
 .Pp
 .D1 Ar MakeVariableName Ns Op = Ns Ar Value
 .D1 Ar MakeVariableName Ns += Ns Ar Value
 .Pp
 and results in the appropriate
 .Xr make 1
 variable definition being inserted into the generated makefile.
 If only the name of the
 .Xr make 1
 variable is specified,
 .Ar value
 is assumed to be the empty string.
 .Pp
 Example:
 .Bd -literal -offset indent -compact
 makeoptions MYMAKEOPTION="foo"
 makeoptions MYMAKEOPTION+="bar"
 makeoptions MYNULLMAKEOPTION
 .Ed
 .\" -------- MAXUSERS --------
 .Pp
 .It Ic maxusers Ar number
 This optional directive is used to configure the size
 of some kernel data structures.
 The parameter
 .Ar number
 can be 0 (the default) or an integer greater than or equal to 2.
 A value of 0 indicates that the kernel should configure
 its data structures according to the size of available
 physical memory.
 If auto configuration is requested, the kernel will set
 this tunable to a value between 32 and 384.
 .Pp
 As explained in
 .Xr tuning 7 ,
 this tunable can also be set at boot time using
 .Xr loader 8 .
 .\" -------- NOCPU --------
 .Pp
 .It Ic nocpu Ar cputype
 Remove the specified CPU
 from the list of previously selected CPUs.
 This directive can be used to cancel the effect of
 .Ic cpu
 directives in files included using
 .Ic include .
 .\" -------- NODEVICE --------
 .Pp
 .It Ic nodevice Ar name Op , Ar name Op ...
 .It Ic nodevices Ar name Op , Ar name Op ...
 Remove the specified devices
 from the list of previously selected devices.
 This directive can be used to cancel the effects of
 .Ic device
 or
 .Ic devices
 directives in files included using
 .Ic include .
 .\" -------- NOMAKEOPTION --------
 .Pp
 .It Ic nomakeoption Ar name
 .It Ic nomakeoptions Ar name
 Removes previously defined
 .Xr make 1
 option
 .Ar name
 from the kernel build.
 This directive can be used to cancel the effects of
 .Ic makeoption
 directives in files included using
 .Ic include .
 .\" -------- NOOPTION --------
 .Pp
 .It Ic nooption Ar name Op , Ar name Op ...
 .It Ic nooptions Ar name Op , Ar name Op ...
 Remove the specified kernel options
 from the list of previously defined options.
 This directive can be used to cancel the effects of
 .Ic option
 or
 .Ic options
 directives in files included using
 .Ic include .
 .\" -------- OPTIONS --------
 .Pp
 .It Ic option Ar optionspec Op , Ar optionspec Op ...
 .It Ic options Ar optionspec Op , Ar optionspec Op ...
 Add compile time kernel options to the kernel build.
 Each option specification has the form
 .Pp
 .D1 Ar name Ns Op = Ns Ar value
 .Pp
 If
 .Ar value
 is not specified, it is assumed to be
 .Dv NULL .
 Options common to all architectures are specified in
 the file
 .Pa sys/conf/options .
 Options specific to architecture
 .Ar arch
 are specified in the file
 .Pa sys/conf/options. Ns Aq Ar arch .
 .\" -------- PROFILE --------
 .Pp
 .It Ic profile Ar number
 Enables kernel profiling if
 .Ar number
 is non-zero.
 If
 .Ar number
 is 2 or greater, the kernel is configured for
 high-resolution profiling.
 Kernels can also be built for profiling using the
 .Fl p
 option to
 .Xr config 8 .
 .El
 .Ss Obsolete Directives
 The following kernel configuration directives are obsolete.
 .Bl -tag -width indent
 .\" -------- CONFIG --------
 .It Ic config
 This directive was used to specify the device to be used for the root
 file system.
 From
 .Fx 4.0
 onwards, this information is passed to a booting kernel by
 .Xr loader 8 .
 .El
 .Sh FILES
 .Bl -tag -width ".Pa sys/conf/Makefile. Ns Ar arch" -compact
 .It Pa sys/compile/ Ns Ar NAME
 Compile directory created from a kernel configuration.
 .It Pa sys/conf/Makefile. Ns Ar arch
 .Pa Makefile
 fragments for architecture
 .Ar arch .
 .It Pa sys/conf/files
 Devices common to all architectures.
 .It Pa sys/conf/files. Ns Ar arch
 Devices for architecture
 .Ar arch .
 .It Pa sys/conf/options
 Options common to all architectures.
 .It Pa sys/conf/options. Ns Ar arch
 Options for architecture
 .Ar arch .
 .El
 .Sh SEE ALSO
 .Xr kenv 1 ,
 .Xr make 1 ,
 .Xr device.hints 5 ,
 .Xr loader.conf 5 ,
 .Xr config 8 ,
 .Xr kldload 8 ,
 .Xr loader 8
 .Rs
 .%T "Building 4.4BSD Kernels with Config"
 .%A "Samuel J. Leffler"
 .%A "Michael J. Karels"
 .Re
 .Sh HISTORY
 The
 .Xr config 8
 utility first appeared in
 .Bx 4.1 ,
 and was subsequently revised in
 .Bx 4.4 .
 .Pp
 The kernel configuration mechanism changed further in
 .Fx 4.0
 and
 .Fx 5.0 ,
 moving toward an architecture supporting dynamic kernel
 configuration.
Index: stable/11/usr.sbin/config/config.h
===================================================================
--- stable/11/usr.sbin/config/config.h	(revision 337332)
+++ stable/11/usr.sbin/config/config.h	(revision 337333)
@@ -1,220 +1,219 @@
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	@(#)config.h	8.1 (Berkeley) 6/6/93
  * $FreeBSD$
  */
 
 /*
  * Config.
  */
 #include <sys/types.h>
 #include <sys/queue.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 
 struct cfgfile {
 	STAILQ_ENTRY(cfgfile)	cfg_next;
 	char	*cfg_path;
 };
 STAILQ_HEAD(, cfgfile) cfgfiles;
 
 struct file_list {
 	STAILQ_ENTRY(file_list) f_next;
 	char	*f_fn;			/* the name */
 	int     f_type;                 /* type */
 	u_char	f_flags;		/* see below */
 	char	*f_compilewith;		/* special make rule if present */
 	char	*f_depends;		/* additional dependencies */
 	char	*f_clean;		/* File list to add to clean rule */
 	char	*f_warn;		/* warning message */
 	const char *f_objprefix;	/* prefix string for object name */
 	const char *f_srcprefix;	/* source prefix such as $S/ */
 };
 
 struct files_name {
 	char *f_name;
 	STAILQ_ENTRY(files_name) f_next;
 };
 
 /*
  * Types.
  */
 #define NORMAL		1
 #define	PROFILING	3
 #define NODEPEND	4
 #define LOCAL		5
 #define DEVDONE		0x80000000
 #define TYPEMASK	0x7fffffff
 
 /*
  * Attributes (flags).
  */
 #define NO_IMPLCT_RULE	1
 #define NO_OBJ		2
 #define BEFORE_DEPEND	4
 #define NOWERROR	16
 
 struct device {
 	int	d_done;			/* processed */
 	char	*d_name;		/* name of device (e.g. rk11) */
 #define	UNKNOWN -2	/* -2 means not set yet */
 	STAILQ_ENTRY(device) d_next;	/* Next one in list */
 };
 
 struct config {
 	char	*s_sysname;
 };
 
 /*
  * Config has a global notion of which machine type is
  * being used.  It uses the name of the machine in choosing
  * files and directories.  Thus if the name of the machine is ``i386'',
  * it will build from ``Makefile.i386'' and use ``../i386/inline''
  * in the makerules, etc.  machinearch is the global notion of the
  * MACHINE_ARCH for this MACHINE.
  */
 char	*machinename;
 char	*machinearch;
 
 /*
  * For each machine, a set of CPU's may be specified as supported.
  * These and the options (below) are put in the C flags in the makefile.
  */
 struct cputype {
 	char	*cpu_name;
 	SLIST_ENTRY(cputype) cpu_next;
 };
 
 SLIST_HEAD(, cputype) cputype;
 
 /*
  * A set of options may also be specified which are like CPU types,
  * but which may also specify values for the options.
  * A separate set of options may be defined for make-style options.
  */
 struct opt {
 	char	*op_name;
 	char	*op_value;
 	int	op_ownfile;	/* true = own file, false = makefile */
 	SLIST_ENTRY(opt) op_next;
 	SLIST_ENTRY(opt) op_append;
 };
 
 SLIST_HEAD(opt_head, opt) opt, mkopt, rmopts;
 
 struct opt_list {
 	char *o_name;
 	char *o_file;
 	int o_flags;
 #define OL_ALIAS	1
 	SLIST_ENTRY(opt_list) o_next;
 };
 
 SLIST_HEAD(, opt_list) otab;
 
 struct envvar {
 	char	*env_str;
 	bool	env_is_file;
 	STAILQ_ENTRY(envvar) envvar_next;
 };
 
 STAILQ_HEAD(envvar_head, envvar) envvars;
 
 struct hint {
 	char	*hint_name;
 	STAILQ_ENTRY(hint) hint_next;
 };
 
 STAILQ_HEAD(hint_head, hint) hints;
 
 struct includepath {
 	char	*path;
 	SLIST_ENTRY(includepath) path_next;
 };
 
 SLIST_HEAD(, includepath) includepath;
 
 /*
  * Tag present in the kernconf.tmpl template file. It's mandatory for those
  * two strings to be the same. Otherwise you'll get into trouble.
  */
 #define	KERNCONFTAG	"%%KERNCONFFILE%%"
 
 /*
  * Faked option to note, that the configuration file has been taken from the
  * kernel file and inclusion of DEFAULTS etc.. isn't nessesery, because we
  * already have a list of all required devices.
  */
 #define OPT_AUTOGEN	"CONFIG_AUTOGENERATED"
 
 extern char	*ident;
 extern char	kernconfstr[];
 extern int	do_trace;
-extern int	envmode;
-extern int	hintmode;
 extern int	incignore;
 
 char	*get_word(FILE *);
 char	*get_quoted_word(FILE *);
 char	*path(const char *);
 char	*raisestr(char *);
 void	remember(const char *);
 void	moveifchanged(const char *, const char *);
 int	yylex(void);
 void	options(void);
 void	makefile(void);
 void	makeenv(void);
 void	makehints(void);
 void	headers(void);
 void	cfgfile_add(const char *);
 void	cfgfile_removeall(void);
 FILE	*open_makefile_template(void);
 
 extern STAILQ_HEAD(device_head, device) dtab;
 
 extern char	errbuf[80];
 extern int	yyline;
 extern const	char *yyfile;
 
 extern STAILQ_HEAD(file_list_head, file_list) ftab;
 
 extern STAILQ_HEAD(files_name_head, files_name) fntab;
 
 extern int	profiling;
 extern int	debugging;
 extern int	found_defaults;
 
 extern int	maxusers;
+extern int	versreq;
 
 extern char *PREFIX;		/* Config file name - for error messages */
 extern char srcdir[];		/* root of the kernel source tree */
 
 #define eq(a,b)	(!strcmp(a,b))
 #define ns(s)	strdup(s)
Index: stable/11/usr.sbin/config/config.y
===================================================================
--- stable/11/usr.sbin/config/config.y	(revision 337332)
+++ stable/11/usr.sbin/config/config.y	(revision 337333)
@@ -1,483 +1,480 @@
 %union {
 	char	*str;
 	int	val;
 	struct	file_list *file;
 }
 
 %token	ARCH
 %token	COMMA
 %token	CONFIG
 %token	CPU
 %token	NOCPU
 %token	DEVICE
 %token	NODEVICE
 %token	ENV
 %token	ENVVAR
 %token	EQUALS
 %token	PLUSEQUALS
 %token	HINTS
 %token	IDENT
 %token	MAXUSERS
 %token	PROFILE
 %token	OPTIONS
 %token	NOOPTION
 %token	MAKEOPTIONS
 %token	NOMAKEOPTION 
 %token	SEMICOLON
 %token	INCLUDE
 %token	FILES
 
 %token	<str>	ENVLINE
 %token	<str>	ID
 %token	<val>	NUMBER
 
 %type	<str>	Save_id
 %type	<str>	Opt_value
 %type	<str>	Dev
 %token	<str>	PATH
 
 %{
 
 /*
  * Copyright (c) 1988, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	@(#)config.y	8.1 (Berkeley) 6/6/93
  * $FreeBSD$
  */
 
 #include <assert.h>
 #include <ctype.h>
 #include <err.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "config.h"
 
 struct	device_head dtab;
 char	*ident;
-int	envmode;
-int	hintmode;
+char	*env;
 int	yyline;
 const	char *yyfile;
 struct  file_list_head ftab;
 struct  files_name_head fntab;
 char	errbuf[80];
 int	maxusers;
 
 #define ns(s)	strdup(s)
 int include(const char *, int);
 void yyerror(const char *s);
 int yywrap(void);
 
 static void newdev(char *name);
 static void newfile(char *name);
 static void newenvvar(char *name, bool is_file);
 static void rmdev_schedule(struct device_head *dh, char *name);
 static void newopt(struct opt_head *list, char *name, char *value, int append);
 static void rmopt_schedule(struct opt_head *list, char *name);
 
 static char *
 devopt(char *dev)
 {
 	char *ret = malloc(strlen(dev) + 5);
 	
 	sprintf(ret, "DEV_%s", dev);
 	raisestr(ret);
 	return ret;
 }
 
 %}
 %%
 Configuration:
 	Many_specs
 		;
 
 Many_specs:
 	Many_specs Spec
 		|
 	/* lambda */
 		;
 
 Spec:
 	Device_spec SEMICOLON
 		|
 	Config_spec SEMICOLON
 		|
 	INCLUDE PATH SEMICOLON {
 		if (incignore == 0)
 			include($2, 0);
 		};
 		|
 	INCLUDE ID SEMICOLON {
 	          if (incignore == 0)
 		  	include($2, 0);
 		};
 		|
 	FILES ID SEMICOLON { newfile($2); };
 	        |
 	SEMICOLON
 		|
 	error SEMICOLON
 		;
 
 Config_spec:
 	ARCH Save_id {
 		if (machinename != NULL && !eq($2, machinename))
 		    errx(1, "%s:%d: only one machine directive is allowed",
 			yyfile, yyline);
 		machinename = $2;
 		machinearch = $2;
 	      } |
 	ARCH Save_id Save_id {
 		if (machinename != NULL &&
 		    !(eq($2, machinename) && eq($3, machinearch)))
 		    errx(1, "%s:%d: only one machine directive is allowed",
 			yyfile, yyline);
 		machinename = $2;
 		machinearch = $3;
 	      } |
 	CPU Save_id {
 		struct cputype *cp =
 		    (struct cputype *)calloc(1, sizeof (struct cputype));
 		if (cp == NULL)
 			err(EXIT_FAILURE, "calloc");
 		cp->cpu_name = $2;
 		SLIST_INSERT_HEAD(&cputype, cp, cpu_next);
 	      } |
 	NOCPU Save_id {
 		struct cputype *cp, *cp2;
 		SLIST_FOREACH_SAFE(cp, &cputype, cpu_next, cp2) {
 			if (eq(cp->cpu_name, $2)) {
 				SLIST_REMOVE(&cputype, cp, cputype, cpu_next);
 				free(cp);
 			}
 		}
 	      } |
 	OPTIONS Opt_list
 		|
 	NOOPTION NoOpt_list |
 	MAKEOPTIONS Mkopt_list
 		|
 	NOMAKEOPTION Save_id { rmopt_schedule(&mkopt, $2); } |
 	IDENT ID { ident = $2; } |
 	System_spec
 		|
 	MAXUSERS NUMBER { maxusers = $2; } |
 	PROFILE NUMBER { profiling = $2; } |
 	ENV ID { newenvvar($2, true); } |
 	ENVVAR ENVLINE { newenvvar($2, false); } |
 	HINTS ID {
 		struct hint *hint;
 
 		hint = (struct hint *)calloc(1, sizeof (struct hint));
 		if (hint == NULL)
 			err(EXIT_FAILURE, "calloc");	
 		hint->hint_name = $2;
 		STAILQ_INSERT_HEAD(&hints, hint, hint_next);
-		hintmode = 1;
 	        }
 
 System_spec:
 	CONFIG System_id System_parameter_list {
 		errx(1, "%s:%d: root/dump/swap specifications obsolete",
 		      yyfile, yyline);
 		}
 	  |
 	CONFIG System_id
 	  ;
 
 System_id:
 	Save_id { newopt(&mkopt, ns("KERNEL"), $1, 0); };
 
 System_parameter_list:
 	  System_parameter_list ID
 	| ID
 	;
 
 Opt_list:
 	Opt_list COMMA Option
 		|
 	Option
 		;
 
 NoOpt_list:
 	NoOpt_list COMMA NoOption
 	  	|
 	NoOption
 		;
 Option:
 	Save_id {
 		newopt(&opt, $1, NULL, 0);
 		if (strchr($1, '=') != NULL)
 			errx(1, "%s:%d: The `=' in options should not be "
 			    "quoted", yyfile, yyline);
 	      } |
 	Save_id EQUALS Opt_value {
 		newopt(&opt, $1, $3, 0);
 	      } ;
 
 NoOption:
 	Save_id {
 		rmopt_schedule(&opt, $1);
 		};
 
 Opt_value:
 	ID { $$ = $1; } |
 	NUMBER {
 			char buf[80];
 
 			(void) snprintf(buf, sizeof(buf), "%d", $1);
 			$$ = ns(buf);
 		} ;
 
 Save_id:
 	ID { $$ = $1; }
 	;
 
 Mkopt_list:
 	Mkopt_list COMMA Mkoption
 		|
 	Mkoption
 		;
 
 Mkoption:
 	Save_id { newopt(&mkopt, $1, ns(""), 0); } |
 	Save_id EQUALS { newopt(&mkopt, $1, ns(""), 0); } |
 	Save_id EQUALS Opt_value { newopt(&mkopt, $1, $3, 0); } |
 	Save_id PLUSEQUALS Opt_value { newopt(&mkopt, $1, $3, 1); } ;
 
 Dev:
 	ID { $$ = $1; }
 	;
 
 Device_spec:
 	DEVICE Dev_list
 		|
 	NODEVICE NoDev_list
 		;
 
 Dev_list:
 	Dev_list COMMA Device
 		|
 	Device
 		;
 
 NoDev_list:
 	NoDev_list COMMA NoDevice
 		|
 	NoDevice
 		;
 
 Device:
 	Dev {
 		newopt(&opt, devopt($1), ns("1"), 0);
 		/* and the device part */
 		newdev($1);
 		}
 
 NoDevice:
 	Dev {
 		char *s = devopt($1);
 
 		rmopt_schedule(&opt, s);
 		free(s);
 		/* and the device part */
 		rmdev_schedule(&dtab, $1);
 		} ;
 
 %%
 
 void
 yyerror(const char *s)
 {
 
 	errx(1, "%s:%d: %s", yyfile, yyline + 1, s);
 }
 
 int
 yywrap(void)
 {
 	if (found_defaults) {
 		if (freopen(PREFIX, "r", stdin) == NULL)
 			err(2, "%s", PREFIX);		
 		yyfile = PREFIX;
 		yyline = 0;
 		found_defaults = 0;
 		return 0;
 	}
 	return 1;
 }
 
 /*
  * Add a new file to the list of files.
  */
 static void
 newfile(char *name)
 {
 	struct files_name *nl;
 	
 	nl = (struct files_name *) calloc(1, sizeof *nl);
 	if (nl == NULL)
 		err(EXIT_FAILURE, "calloc");
 	nl->f_name = name;
 	STAILQ_INSERT_TAIL(&fntab, nl, f_next);
 }
 
 static void
 newenvvar(char *name, bool is_file)
 {
 	struct envvar *envvar;
 
 	envvar = (struct envvar *)calloc(1, sizeof (struct envvar));
 	if (envvar == NULL)
 		err(EXIT_FAILURE, "calloc");
 	envvar->env_str = name;
 	envvar->env_is_file = is_file;
 	STAILQ_INSERT_HEAD(&envvars, envvar, envvar_next);
-	envmode = 1;
 }
 
 /*
  * Find a device in the list of devices.
  */
 static struct device *
 finddev(struct device_head *dlist, char *name)
 {
 	struct device *dp;
 
 	STAILQ_FOREACH(dp, dlist, d_next)
 		if (eq(dp->d_name, name))
 			return (dp);
 
 	return (NULL);
 }
 	
 /*
  * Add a device to the list of devices.
  */
 static void
 newdev(char *name)
 {
 	struct device *np;
 
 	if (finddev(&dtab, name)) {
 		fprintf(stderr,
 		    "WARNING: duplicate device `%s' encountered.\n", name);
 		return;
 	}
 
 	np = (struct device *) calloc(1, sizeof *np);
 	if (np == NULL)
 		err(EXIT_FAILURE, "calloc");
 	np->d_name = name;
 	STAILQ_INSERT_TAIL(&dtab, np, d_next);
 }
 
 /*
  * Schedule a device to removal.
  */
 static void
 rmdev_schedule(struct device_head *dh, char *name)
 {
 	struct device *dp;
 
 	dp = finddev(dh, name);
 	if (dp != NULL) {
 		STAILQ_REMOVE(dh, dp, device, d_next);
 		free(dp->d_name);
 		free(dp);
 	}
 }
 
 /*
  * Find an option in the list of options.
  */
 static struct opt *
 findopt(struct opt_head *list, char *name)
 {
 	struct opt *op;
 
 	SLIST_FOREACH(op, list, op_next)
 		if (eq(op->op_name, name))
 			return (op);
 
 	return (NULL);
 }
 
 /*
  * Add an option to the list of options.
  */
 static void
 newopt(struct opt_head *list, char *name, char *value, int append)
 {
 	struct opt *op, *op2;
 
 	/*
 	 * Ignore inclusions listed explicitly for configuration files.
 	 */
 	if (eq(name, OPT_AUTOGEN)) {
 		incignore = 1;
 		return;
 	}
 
 	op2 = findopt(list, name);
 	if (op2 != NULL && !append) {
 		fprintf(stderr,
 		    "WARNING: duplicate option `%s' encountered.\n", name);
 		return;
 	}
 
 	op = (struct opt *)calloc(1, sizeof (struct opt));
 	if (op == NULL)
 		err(EXIT_FAILURE, "calloc");
 	op->op_name = name;
 	op->op_ownfile = 0;
 	op->op_value = value;
 	if (op2 != NULL) {
 		while (SLIST_NEXT(op2, op_append) != NULL)
 			op2 = SLIST_NEXT(op2, op_append);
 		SLIST_NEXT(op2, op_append) = op;
 	} else
 		SLIST_INSERT_HEAD(list, op, op_next);
 }
 
 /*
  * Remove an option from the list of options.
  */
 static void
 rmopt_schedule(struct opt_head *list, char *name)
 {
 	struct opt *op;
 
 	op = findopt(list, name);
 	if (op != NULL) {
 		SLIST_REMOVE(list, op, opt, op_next);
 		free(op->op_name);
 		free(op);
 	}
 }
Index: stable/11/usr.sbin/config/configvers.h
===================================================================
--- stable/11/usr.sbin/config/configvers.h	(revision 337332)
+++ stable/11/usr.sbin/config/configvers.h	(revision 337333)
@@ -1,53 +1,56 @@
 /*-
  * This file is in the public domain
  *
  * $FreeBSD$
  */
 
 /*
  * 6 digits of version.  The most significant are branch indicators at the
  * time when the last incompatible change was made (which is why it is
  * presently 6 on 7-current).  The least significant digits are incremented
  * as described below.  The format is similar to the __FreeBSD_version, but
  * not tied to it.
  *
  * DO NOT CASUALLY BUMP THIS NUMBER!  The rules are not the same as shared
  * libs or param.h/osreldate.
  *
  * It is the version number of the protocol between config(8) and the
  * sys/conf/ Makefiles (the kernel build system).
  *
  * It is now also used to trap certain problems that the syntax parser cannot
  * detect.
  *
  * Unfortunately, there is no version number for user supplied config files.
  *
  * Once, config(8) used to silently report errors and continue anyway.  This
  * was a huge problem for 'make buildkernel' which was run with the installed
  * /usr/sbin/config, not a cross built one.  We started bumping the version
  * number as a way to trap cases where the previous installworld was not
  * compatible with the new buildkernel.  The buildtools phase and much more
  * comprehensive error code returns solved this original problem.
  *
  * Most end-users will use buildkernel and the build tools from buildworld.
  * The people that are inconvenienced by gratuitous bumps are developers
  * who run config by hand.  However, developers shouldn't gratuitously be
  * inconvenienced.
  *
  * One should bump the CONFIGVERS in the following ways:
  *
  * (1) If you change config such that it won't read old config files,
  *     then bump the major number.  You shouldn't be doing this unless
  *     you are overhauling config.  Do not casually bump this number
  *     and by implication do not make changes that would force a bump
  *     of this number casually.  You should limit major bumps to once
  *     per branch.
  * (2) For each new feature added, bump the minor version of this file.
  *     When a new feature is actually used by the build system, update the
  *     %VERSREQ field in the Makefile.$ARCH of all the affected makefiles
  *     (typically all of them).
  *
  * $FreeBSD$
  */
-#define	CONFIGVERS	600015
+#define	CONFIGVERS	600016
 #define	MAJOR_VERS(x)	((x) / 100000)
+
+/* Last config(8) version to require envmode/hintmode */
+#define	CONFIGVERS_ENVMODE_REQ	600015
Index: stable/11/usr.sbin/config/main.c
===================================================================
--- stable/11/usr.sbin/config/main.c	(revision 337332)
+++ stable/11/usr.sbin/config/main.c	(revision 337333)
@@ -1,779 +1,780 @@
 /*
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #ifndef lint
 static const char copyright[] =
 "@(#) Copyright (c) 1980, 1993\n\
 	The Regents of the University of California.  All rights reserved.\n";
 #endif /* not lint */
 
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)main.c	8.1 (Berkeley) 6/6/93";
 #endif
 static const char rcsid[] =
   "$FreeBSD$";
 #endif /* not lint */
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/sbuf.h>
 #include <sys/file.h>
 #include <sys/mman.h>
 #include <sys/param.h>
 
 #include <assert.h>
 #include <ctype.h>
 #include <err.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <dirent.h>
 #include "y.tab.h"
 #include "config.h"
 #include "configvers.h"
 
 #ifndef TRUE
 #define TRUE	(1)
 #endif
 
 #ifndef FALSE
 #define FALSE	(0)
 #endif
 
 #define	CDIR	"../compile/"
 
 char *	PREFIX;
 char 	destdir[MAXPATHLEN];
 char 	srcdir[MAXPATHLEN];
 
 int	debugging;
 int	profiling;
 int	found_defaults;
 int	incignore;
 
 /*
  * Preserve old behaviour in INCLUDE_CONFIG_FILE handling (files are included
  * literally).
  */
 int	filebased = 0;
+int	versreq;
 
 static void configfile(void);
 static void get_srcdir(void);
 static void usage(void);
 static void cleanheaders(char *);
 static void kernconfdump(const char *);
+static void badversion(void);
 static void checkversion(void);
 extern int yyparse(void);
 
 struct hdr_list {
 	char *h_name;
 	struct hdr_list *h_next;
 } *htab;
 
 /*
  * Config builds a set of files for building a UNIX
  * system given a description of the desired system.
  */
 int
 main(int argc, char **argv)
 {
 
 	struct stat buf;
 	int ch, len;
 	char *p;
 	char *kernfile;
 	struct includepath* ipath;
 	int printmachine;
 
 	printmachine = 0;
 	kernfile = NULL;
 	SLIST_INIT(&includepath);
 	while ((ch = getopt(argc, argv, "CI:d:gmps:Vx:")) != -1)
 		switch (ch) {
 		case 'C':
 			filebased = 1;
 			break;
 		case 'I':
 			ipath = (struct includepath *) \
 			    	calloc(1, sizeof (struct includepath));
 			if (ipath == NULL)
 				err(EXIT_FAILURE, "calloc");
 			ipath->path = optarg;
 			SLIST_INSERT_HEAD(&includepath, ipath, path_next);
 			break;
 		case 'm':
 			printmachine = 1;
 			break;
 		case 'd':
 			if (*destdir == '\0')
 				strlcpy(destdir, optarg, sizeof(destdir));
 			else
 				errx(EXIT_FAILURE, "directory already set");
 			break;
 		case 'g':
 			debugging++;
 			break;
 		case 'p':
 			profiling++;
 			break;
 		case 's':
 			if (*srcdir == '\0')
 				strlcpy(srcdir, optarg, sizeof(srcdir));
 			else
 				errx(EXIT_FAILURE, "src directory already set");
 			break;
 		case 'V':
 			printf("%d\n", CONFIGVERS);
 			exit(0);
 		case 'x':
 			kernfile = optarg;
 			break;
 		case '?':
 		default:
 			usage();
 		}
 	argc -= optind;
 	argv += optind;
 
 	if (kernfile != NULL) {
 		kernconfdump(kernfile);
 		exit(EXIT_SUCCESS);
 	}
 
 	if (argc != 1)
 		usage();
 
 	PREFIX = *argv;
 	if (stat(PREFIX, &buf) != 0 || !S_ISREG(buf.st_mode))
 		err(2, "%s", PREFIX);
 	if (freopen("DEFAULTS", "r", stdin) != NULL) {
 		found_defaults = 1;
 		yyfile = "DEFAULTS";
 	} else {
 		if (freopen(PREFIX, "r", stdin) == NULL)
 			err(2, "%s", PREFIX);
 		yyfile = PREFIX;
 	}
 	if (*destdir != '\0') {
 		len = strlen(destdir);
 		while (len > 1 && destdir[len - 1] == '/')
 			destdir[--len] = '\0';
 		if (*srcdir == '\0')
 			get_srcdir();
 	} else {
 		strlcpy(destdir, CDIR, sizeof(destdir));
 		strlcat(destdir, PREFIX, sizeof(destdir));
 	}
 
 	SLIST_INIT(&cputype);
 	SLIST_INIT(&mkopt);
 	SLIST_INIT(&opt);
 	SLIST_INIT(&rmopts);
 	STAILQ_INIT(&cfgfiles);
 	STAILQ_INIT(&dtab);
 	STAILQ_INIT(&fntab);
 	STAILQ_INIT(&ftab);
 	STAILQ_INIT(&hints);
 	STAILQ_INIT(&envvars);
 	if (yyparse())
 		exit(3);
 
 	/*
 	 * Ensure that required elements (machine, cpu, ident) are present.
 	 */
 	if (machinename == NULL) {
 		printf("Specify machine type, e.g. ``machine i386''\n");
 		exit(1);
 	}
 	if (ident == NULL) {
 		printf("no ident line specified\n");
 		exit(1);
 	}
 	if (SLIST_EMPTY(&cputype)) {
 		printf("cpu type must be specified\n");
 		exit(1);
 	}
 	checkversion();
 
 	if (printmachine) {
 		printf("%s\t%s\n",machinename,machinearch);
 		exit(0);
 	}
 
 	/* Make compile directory */
 	p = path((char *)NULL);
 	if (stat(p, &buf)) {
 		if (mkdir(p, 0777))
 			err(2, "%s", p);
 	} else if (!S_ISDIR(buf.st_mode))
 		errx(EXIT_FAILURE, "%s isn't a directory", p);
 
 	configfile();			/* put config file into kernel*/
 	options();			/* make options .h files */
 	makefile();			/* build Makefile */
 	makeenv();			/* build env.c */
 	makehints();			/* build hints.c */
 	headers();			/* make a lot of .h files */
 	cleanheaders(p);
 	printf("Kernel build directory is %s\n", p);
 	printf("Don't forget to do ``make cleandepend && make depend''\n");
 	exit(0);
 }
 
 /*
  * get_srcdir
  *	determine the root of the kernel source tree
  *	and save that in srcdir.
  */
 static void
 get_srcdir(void)
 {
 	struct stat lg, phy;
 	char *p, *pwd;
 	int i;
 
 	if (realpath("../..", srcdir) == NULL)
 		err(EXIT_FAILURE, "Unable to find root of source tree");
 	if ((pwd = getenv("PWD")) != NULL && *pwd == '/' &&
 	    (pwd = strdup(pwd)) != NULL) {
 		/* Remove the last two path components. */
 		for (i = 0; i < 2; i++) {
 			if ((p = strrchr(pwd, '/')) == NULL) {
 				free(pwd);
 				return;
 			}
 			*p = '\0';
 		}
 		if (stat(pwd, &lg) != -1 && stat(srcdir, &phy) != -1 &&
 		    lg.st_dev == phy.st_dev && lg.st_ino == phy.st_ino)
 			strlcpy(srcdir, pwd, MAXPATHLEN);
 		free(pwd);
 	}
 }
 
 static void
 usage(void)
 {
 
 	fprintf(stderr,
 	    "usage: config [-CgmpV] [-d destdir] [-s srcdir] sysname\n");
 	fprintf(stderr, "       config -x kernel\n");
 	exit(EX_USAGE);
 }
 
 /*
  * get_word
  *	returns EOF on end of file
  *	NULL on end of line
  *	pointer to the word otherwise
  */
 char *
 get_word(FILE *fp)
 {
 	static char line[80];
 	int ch;
 	char *cp;
 	int escaped_nl = 0;
 
 begin:
 	while ((ch = getc(fp)) != EOF)
 		if (ch != ' ' && ch != '\t')
 			break;
 	if (ch == EOF)
 		return ((char *)EOF);
 	if (ch == '\\'){
 		escaped_nl = 1;
 		goto begin;
 	}
 	if (ch == '\n') {
 		if (escaped_nl){
 			escaped_nl = 0;
 			goto begin;
 		}
 		else
 			return (NULL);
 	}
 	cp = line;
 	*cp++ = ch;
 	/* Negation operator is a word by itself. */
 	if (ch == '!') {
 		*cp = 0;
 		return (line);
 	}
 	while ((ch = getc(fp)) != EOF) {
 		if (isspace(ch))
 			break;
 		*cp++ = ch;
 	}
 	*cp = 0;
 	if (ch == EOF)
 		return ((char *)EOF);
 	(void) ungetc(ch, fp);
 	return (line);
 }
 
 /*
  * get_quoted_word
  *	like get_word but will accept something in double or single quotes
  *	(to allow embedded spaces).
  */
 char *
 get_quoted_word(FILE *fp)
 {
 	static char line[256];
 	int ch;
 	char *cp;
 	int escaped_nl = 0;
 
 begin:
 	while ((ch = getc(fp)) != EOF)
 		if (ch != ' ' && ch != '\t')
 			break;
 	if (ch == EOF)
 		return ((char *)EOF);
 	if (ch == '\\'){
 		escaped_nl = 1;
 		goto begin;
 	}
 	if (ch == '\n') {
 		if (escaped_nl){
 			escaped_nl = 0;
 			goto begin;
 		}
 		else
 			return (NULL);
 	}
 	cp = line;
 	if (ch == '"' || ch == '\'') {
 		int quote = ch;
 
 		escaped_nl = 0;
 		while ((ch = getc(fp)) != EOF) {
 			if (ch == quote && !escaped_nl)
 				break;
 			if (ch == '\n' && !escaped_nl) {
 				*cp = 0;
 				printf("config: missing quote reading `%s'\n",
 					line);
 				exit(2);
 			}
 			if (ch == '\\' && !escaped_nl) {
 				escaped_nl = 1;
 				continue;
 			}
 			if (ch != quote && escaped_nl)
 				*cp++ = '\\';
 			*cp++ = ch;
 			escaped_nl = 0;
 		}
 	} else {
 		*cp++ = ch;
 		while ((ch = getc(fp)) != EOF) {
 			if (isspace(ch))
 				break;
 			*cp++ = ch;
 		}
 		if (ch != EOF)
 			(void) ungetc(ch, fp);
 	}
 	*cp = 0;
 	if (ch == EOF)
 		return ((char *)EOF);
 	return (line);
 }
 
 /*
  * prepend the path to a filename
  */
 char *
 path(const char *file)
 {
 	char *cp = NULL;
 
 	if (file)
 		asprintf(&cp, "%s/%s", destdir, file);
 	else
 		cp = strdup(destdir);
 	return (cp);
 }
 
 /*
  * Generate configuration file based on actual settings. With this mode, user
  * will be able to obtain and build conifguration file with one command.
  */
 static void
 configfile_dynamic(struct sbuf *sb)
 {
 	struct cputype *cput;
 	struct device *d;
 	struct opt *ol;
 	char *lend;
 	unsigned int i;
 
 	asprintf(&lend, "\\n\\\n");
 	assert(lend != NULL);
 	sbuf_printf(sb, "options\t%s%s", OPT_AUTOGEN, lend);
 	sbuf_printf(sb, "ident\t%s%s", ident, lend);
 	sbuf_printf(sb, "machine\t%s%s", machinename, lend);
 	SLIST_FOREACH(cput, &cputype, cpu_next)
 		sbuf_printf(sb, "cpu\t%s%s", cput->cpu_name, lend);
 	SLIST_FOREACH(ol, &mkopt, op_next)
 		sbuf_printf(sb, "makeoptions\t%s=%s%s", ol->op_name,
 		    ol->op_value, lend);
 	SLIST_FOREACH(ol, &opt, op_next) {
 		if (strncmp(ol->op_name, "DEV_", 4) == 0)
 			continue;
 		sbuf_printf(sb, "options\t%s", ol->op_name);
 		if (ol->op_value != NULL) {
 			sbuf_putc(sb, '=');
 			for (i = 0; i < strlen(ol->op_value); i++) {
 				if (ol->op_value[i] == '"')
 					sbuf_printf(sb, "\\%c",
 					    ol->op_value[i]);
 				else
 					sbuf_printf(sb, "%c",
 					    ol->op_value[i]);
 			}
 			sbuf_printf(sb, "%s", lend);
 		} else {
 			sbuf_printf(sb, "%s", lend);
 		}
 	}
 	/*
 	 * Mark this file as containing everything we need.
 	 */
 	STAILQ_FOREACH(d, &dtab, d_next)
 		sbuf_printf(sb, "device\t%s%s", d->d_name, lend);
 	free(lend);
 }
 
 /*
  * Generate file from the configuration files.
  */
 static void
 configfile_filebased(struct sbuf *sb)
 {
 	FILE *cff;
 	struct cfgfile *cf;
 	int i;
 
 	/*
 	 * Try to read all configuration files. Since those will be present as
 	 * C string in the macro, we have to slash their ends then the line
 	 * wraps.
 	 */
 	STAILQ_FOREACH(cf, &cfgfiles, cfg_next) {
 		cff = fopen(cf->cfg_path, "r");
 		if (cff == NULL) {
 			warn("Couldn't open file %s", cf->cfg_path);
 			continue;
 		}
 		while ((i = getc(cff)) != EOF) {
 			if (i == '\n')
 				sbuf_printf(sb, "\\n\\\n");
 			else if (i == '"' || i == '\'')
 				sbuf_printf(sb, "\\%c", i);
 			else
 				sbuf_putc(sb, i);
 		}
 		fclose(cff);
 	}
 }
 
 static void
 configfile(void)
 {
 	FILE *fo;
 	struct sbuf *sb;
 	char *p;
 
 	/* Add main configuration file to the list of files to be included */
 	cfgfile_add(PREFIX);
 	p = path("config.c.new");
 	fo = fopen(p, "w");
 	if (!fo)
 		err(2, "%s", p);
 	sb = sbuf_new(NULL, NULL, 2048, SBUF_AUTOEXTEND);
 	assert(sb != NULL);
 	sbuf_clear(sb);
 	if (filebased) {
 		/* Is needed, can be used for backward compatibility. */
 		configfile_filebased(sb);
 	} else {
 		configfile_dynamic(sb);
 	}
 	sbuf_finish(sb);
 	/* 
 	 * We print first part of the template, replace our tag with
 	 * configuration files content and later continue writing our
 	 * template.
 	 */
 	p = strstr(kernconfstr, KERNCONFTAG);
 	if (p == NULL)
 		errx(EXIT_FAILURE, "Something went terribly wrong!");
 	*p = '\0';
 	fprintf(fo, "%s", kernconfstr);
 	fprintf(fo, "%s", sbuf_data(sb));
 	p += strlen(KERNCONFTAG);
 	fprintf(fo, "%s", p);
 	sbuf_delete(sb);
 	fclose(fo);
 	moveifchanged(path("config.c.new"), path("config.c"));
 	cfgfile_removeall();
 }
 
 /*
  * moveifchanged --
  *	compare two files; rename if changed.
  */
 void
 moveifchanged(const char *from_name, const char *to_name)
 {
 	char *p, *q;
 	int changed;
 	size_t tsize;
 	struct stat from_sb, to_sb;
 	int from_fd, to_fd;
 
 	changed = 0;
 
 	if ((from_fd = open(from_name, O_RDONLY)) < 0)
 		err(EX_OSERR, "moveifchanged open(%s)", from_name);
 
 	if ((to_fd = open(to_name, O_RDONLY)) < 0)
 		changed++;
 
 	if (!changed && fstat(from_fd, &from_sb) < 0)
 		err(EX_OSERR, "moveifchanged fstat(%s)", from_name);
 
 	if (!changed && fstat(to_fd, &to_sb) < 0)
 		err(EX_OSERR, "moveifchanged fstat(%s)", to_name);
 
 	if (!changed && from_sb.st_size != to_sb.st_size)
 		changed++;
 
 	tsize = (size_t)from_sb.st_size;
 
 	if (!changed) {
 		p = mmap(NULL, tsize, PROT_READ, MAP_SHARED, from_fd, (off_t)0);
 		if (p == MAP_FAILED)
 			err(EX_OSERR, "mmap %s", from_name);
 		q = mmap(NULL, tsize, PROT_READ, MAP_SHARED, to_fd, (off_t)0);
 		if (q == MAP_FAILED)
 			err(EX_OSERR, "mmap %s", to_name);
 
 		changed = memcmp(p, q, tsize);
 		munmap(p, tsize);
 		munmap(q, tsize);
 	}
 	if (changed) {
 		if (rename(from_name, to_name) < 0)
 			err(EX_OSERR, "rename(%s, %s)", from_name, to_name);
 	} else {
 		if (unlink(from_name) < 0)
 			err(EX_OSERR, "unlink(%s)", from_name);
 	}
 }
 
 static void
 cleanheaders(char *p)
 {
 	DIR *dirp;
 	struct dirent *dp;
 	struct file_list *fl;
 	struct hdr_list *hl;
 	size_t len;
 
 	remember("y.tab.h");
 	remember("setdefs.h");
 	STAILQ_FOREACH(fl, &ftab, f_next)
 		remember(fl->f_fn);
 
 	/*
 	 * Scan the build directory and clean out stuff that looks like
 	 * it might have been a leftover NFOO header, etc.
 	 */
 	if ((dirp = opendir(p)) == NULL)
 		err(EX_OSERR, "opendir %s", p);
 	while ((dp = readdir(dirp)) != NULL) {
 		len = strlen(dp->d_name);
 		/* Skip non-headers */
 		if (len < 2 || dp->d_name[len - 2] != '.' ||
 		    dp->d_name[len - 1] != 'h')
 			continue;
 		/* Skip special stuff, eg: bus_if.h, but check opt_*.h */
 		if (strchr(dp->d_name, '_') &&
 		    strncmp(dp->d_name, "opt_", 4) != 0)
 			continue;
 		/* Check if it is a target file */
 		for (hl = htab; hl != NULL; hl = hl->h_next) {
 			if (eq(dp->d_name, hl->h_name)) {
 				break;
 			}
 		}
 		if (hl)
 			continue;
 		printf("Removing stale header: %s\n", dp->d_name);
 		if (unlink(path(dp->d_name)) == -1)
 			warn("unlink %s", dp->d_name);
 	}
 	(void)closedir(dirp);
 }
 
 void
 remember(const char *file)
 {
 	char *s;
 	struct hdr_list *hl;
 
 	if ((s = strrchr(file, '/')) != NULL)
 		s = ns(s + 1);
 	else
 		s = ns(file);
 
 	if (strchr(s, '_') && strncmp(s, "opt_", 4) != 0) {
 		free(s);
 		return;
 	}
 	for (hl = htab; hl != NULL; hl = hl->h_next) {
 		if (eq(s, hl->h_name)) {
 			free(s);
 			return;
 		}
 	}
 	hl = calloc(1, sizeof(*hl));
 	if (hl == NULL)
 		err(EXIT_FAILURE, "calloc");
 	hl->h_name = s;
 	hl->h_next = htab;
 	htab = hl;
 }
 
 /*
  * This one is quick hack. Will be probably moved to elf(3) interface.
  * It takes kernel configuration file name, passes it as an argument to
  * elfdump -a, which output is parsed by some UNIX tools...
  */
 static void
 kernconfdump(const char *file)
 {
 	struct stat st;
 	FILE *fp, *pp;
 	int error, osz, r;
 	unsigned int i, off, size, t1, t2, align;
 	char *cmd, *o;
 
 	r = open(file, O_RDONLY);
 	if (r == -1)
 		err(EXIT_FAILURE, "Couldn't open file '%s'", file);
 	error = fstat(r, &st);
 	if (error == -1)
 		err(EXIT_FAILURE, "fstat() failed");
 	if (S_ISDIR(st.st_mode))
 		errx(EXIT_FAILURE, "'%s' is a directory", file);
 	fp = fdopen(r, "r");
 	if (fp == NULL)
 		err(EXIT_FAILURE, "fdopen() failed");
 	osz = 1024;
 	o = calloc(1, osz);
 	if (o == NULL)
 		err(EXIT_FAILURE, "Couldn't allocate memory");
 	/* ELF note section header. */
 	asprintf(&cmd, "/usr/bin/elfdump -c %s | grep -A 8 kern_conf"
 	    "| tail -5 | cut -d ' ' -f 2 | paste - - - - -", file);
 	if (cmd == NULL)
 		errx(EXIT_FAILURE, "asprintf() failed");
 	pp = popen(cmd, "r");
 	if (pp == NULL)
 		errx(EXIT_FAILURE, "popen() failed");
 	free(cmd);
 	(void)fread(o, osz, 1, pp);
 	pclose(pp);
 	r = sscanf(o, "%d%d%d%d%d", &off, &size, &t1, &t2, &align);
 	free(o);
 	if (r != 5)
 		errx(EXIT_FAILURE, "File %s doesn't contain configuration "
 		    "file. Either unsupported, or not compiled with "
 		    "INCLUDE_CONFIG_FILE", file);
 	r = fseek(fp, off, SEEK_CUR);
 	if (r != 0)
 		err(EXIT_FAILURE, "fseek() failed");
 	for (i = 0; i < size; i++) {
 		r = fgetc(fp);
 		if (r == EOF)
 			break;
 		if (r == '\0') {
 			assert(i == size - 1 &&
 			    ("\\0 found in the middle of a file"));
 			break;
 		}
 		fputc(r, stdout);
 	}
 	fclose(fp);
 }
 
-static void 
-badversion(int versreq)
+static void
+badversion(void)
 {
 	fprintf(stderr, "ERROR: version of config(8) does not match kernel!\n");
 	fprintf(stderr, "config version = %d, ", CONFIGVERS);
 	fprintf(stderr, "version required = %d\n\n", versreq);
 	fprintf(stderr, "Make sure that /usr/src/usr.sbin/config is in sync\n");
 	fprintf(stderr, "with your /usr/src/sys and install a new config binary\n");
 	fprintf(stderr, "before trying this again.\n\n");
 	fprintf(stderr, "If running the new config fails check your config\n");
 	fprintf(stderr, "file against the GENERIC or LINT config files for\n");
 	fprintf(stderr, "changes in config syntax, or option/device naming\n");
 	fprintf(stderr, "conventions\n\n");
 	exit(1);
 }
 
 static void
 checkversion(void)
 {
 	FILE *ifp;
 	char line[BUFSIZ];
-	int versreq;
 
 	ifp = open_makefile_template();
 	while (fgets(line, BUFSIZ, ifp) != 0) {
 		if (*line != '%')
 			continue;
 		if (strncmp(line, "%VERSREQ=", 9) != 0)
 			continue;
 		versreq = atoi(line + 9);
 		if (MAJOR_VERS(versreq) == MAJOR_VERS(CONFIGVERS) &&
 		    versreq <= CONFIGVERS)
 			continue;
-		badversion(versreq);
+		badversion();
 	}
 	fclose(ifp);
 }
Index: stable/11/usr.sbin/config/mkmakefile.c
===================================================================
--- stable/11/usr.sbin/config/mkmakefile.c	(revision 337332)
+++ stable/11/usr.sbin/config/mkmakefile.c	(revision 337333)
@@ -1,826 +1,861 @@
 /*
  * Copyright (c) 1980, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)mkmakefile.c	8.1 (Berkeley) 6/6/93";
 #endif
 static const char rcsid[] =
   "$FreeBSD$";
 #endif /* not lint */
 
 /*
  * Build the makefile for the system, from
  * the information in the files files and the
  * additional files for the machine being compiled to.
  */
 
 #include <ctype.h>
 #include <err.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
+#include <sys/cnv.h>
+#include <sys/nv.h>
 #include <sys/param.h>
 #include "y.tab.h"
 #include "config.h"
 #include "configvers.h"
 
 static char *tail(char *);
 static void do_clean(FILE *);
 static void do_rules(FILE *);
 static void do_xxfiles(char *, FILE *);
 static void do_objs(FILE *);
 static void do_before_depend(FILE *);
 static int opteq(const char *, const char *);
 static void read_files(void);
+static void sanitize_envline(char *result, const char *src);
+static void process_into_file(char *line, FILE *ofp);
+static void process_into_nvlist(char *line, nvlist_t *nvl);
+static void dump_nvlist(nvlist_t *nvl, FILE *ofp);
 
 static void errout(const char *fmt, ...)
 {
 	va_list ap;
 
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
 	exit(1);
 }
 
 /*
  * Lookup a file, by name.
  */
 static struct file_list *
 fl_lookup(char *file)
 {
 	struct file_list *fp;
 
 	STAILQ_FOREACH(fp, &ftab, f_next) {
 		if (eq(fp->f_fn, file))
 			return (fp);
 	}
 	return (0);
 }
 
 /*
  * Make a new file list entry
  */
 static struct file_list *
 new_fent(void)
 {
 	struct file_list *fp;
 
 	fp = (struct file_list *) calloc(1, sizeof *fp);
 	if (fp == NULL)
 		err(EXIT_FAILURE, "calloc");
 	STAILQ_INSERT_TAIL(&ftab, fp, f_next);
 	return (fp);
 }
 
 /*
  * Open the correct Makefile and return it, or error out.
  */
 FILE *
 open_makefile_template(void)
 {
 	FILE *ifp;
 	char line[BUFSIZ];
 
 	snprintf(line, sizeof(line), "../../conf/Makefile.%s", machinename);
 	ifp = fopen(line, "r");
 	if (ifp == NULL) {
 		snprintf(line, sizeof(line), "Makefile.%s", machinename);
 		ifp = fopen(line, "r");
 	}
 	if (ifp == NULL)
 		err(1, "%s", line);
 	return (ifp);
 }
 
 /*
  * Build the makefile from the skeleton
  */
 void
 makefile(void)
 {
 	FILE *ifp, *ofp;
 	char line[BUFSIZ];
 	struct opt *op, *t;
 
 	read_files();
 	ifp = open_makefile_template();
 	ofp = fopen(path("Makefile.new"), "w");
 	if (ofp == NULL)
 		err(1, "%s", path("Makefile.new"));
 	fprintf(ofp, "KERN_IDENT=%s\n", ident);
 	fprintf(ofp, "MACHINE=%s\n", machinename);
 	fprintf(ofp, "MACHINE_ARCH=%s\n", machinearch);
 	SLIST_FOREACH_SAFE(op, &mkopt, op_next, t) {
 		fprintf(ofp, "%s=%s", op->op_name, op->op_value);
 		while ((op = SLIST_NEXT(op, op_append)) != NULL)
 			fprintf(ofp, " %s", op->op_value);
 		fprintf(ofp, "\n");
 	}
 	if (debugging)
 		fprintf(ofp, "DEBUG=-g\n");
 	if (profiling)
 		fprintf(ofp, "PROFLEVEL=%d\n", profiling);
 	if (*srcdir != '\0')
 		fprintf(ofp,"S=%s\n", srcdir);
 	while (fgets(line, BUFSIZ, ifp) != NULL) {
 		if (*line != '%') {
 			fprintf(ofp, "%s", line);
 			continue;
 		}
 		if (eq(line, "%BEFORE_DEPEND\n"))
 			do_before_depend(ofp);
 		else if (eq(line, "%OBJS\n"))
 			do_objs(ofp);
 		else if (strncmp(line, "%FILES.", 7) == 0)
 			do_xxfiles(line, ofp);
 		else if (eq(line, "%RULES\n"))
 			do_rules(ofp);
 		else if (eq(line, "%CLEAN\n"))
 			do_clean(ofp);
 		else if (strncmp(line, "%VERSREQ=", 9) == 0)
 			line[0] = '\0'; /* handled elsewhere */
 		else
 			fprintf(stderr,
 			    "Unknown %% construct in generic makefile: %s",
 			    line);
 	}
 	(void) fclose(ifp);
 	(void) fclose(ofp);
 	moveifchanged(path("Makefile.new"), path("Makefile"));
 }
 
-/*
- * Build hints.c from the skeleton
- */
-void
-makehints(void)
-{
-	FILE *ifp, *ofp;
-	char line[BUFSIZ];
-	char *s;
-	struct hint *hint;
-
-	ofp = fopen(path("hints.c.new"), "w");
-	if (ofp == NULL)
-		err(1, "%s", path("hints.c.new"));
-	fprintf(ofp, "#include <sys/types.h>\n");
-	fprintf(ofp, "#include <sys/systm.h>\n");
-	fprintf(ofp, "\n");
-	fprintf(ofp, "int hintmode = %d;\n", hintmode);
-	fprintf(ofp, "char static_hints[] = {\n");
-	STAILQ_FOREACH(hint, &hints, hint_next) {
-		ifp = fopen(hint->hint_name, "r");
-		if (ifp == NULL)
-			err(1, "%s", hint->hint_name);
-		while (fgets(line, BUFSIZ, ifp) != NULL) {
-			/* zap trailing CR and/or LF */
-			while ((s = strrchr(line, '\n')) != NULL)
-				*s = '\0';
-			while ((s = strrchr(line, '\r')) != NULL)
-				*s = '\0';
-			/* remove # comments */
-			s = strchr(line, '#');
-			if (s)
-				*s = '\0';
-			/* remove any whitespace and " characters */
-			s = line;
-			while (*s) {
-				if (*s == ' ' || *s == '\t' || *s == '"') {
-					while (*s) {
-						s[0] = s[1];
-						s++;
-					}
-					/* start over */
-					s = line;
-					continue;
-				}
-				s++;
-			}
-			/* anything left? */
-			if (*line == '\0')
-				continue;
-			fprintf(ofp, "\"%s\\0\"\n", line);
-		}
-		fclose(ifp);
-	}
-	fprintf(ofp, "\"\\0\"\n};\n");
-	fclose(ofp);
-	moveifchanged(path("hints.c.new"), path("hints.c"));
-}
-
 static void
 sanitize_envline(char *result, const char *src)
 {
 	const char *eq;
 	char c, *dst;
 	bool leading;
 
 	/* If there is no '=' it's not a well-formed name=value line. */
 	if ((eq = strchr(src, '=')) == NULL) {
 		*result = 0;
 		return;
 	}
 	dst = result;
 
 	/* Copy chars before the '=', skipping any leading spaces/quotes. */
 	leading = true;
 	while (src < eq) {
 		c = *src++;
 		if (leading && (isspace(c) || c == '"'))
 			continue;
 		*dst++ = c;
 		leading = false;
 	}
 
 	/* If it was all leading space, we don't have a well-formed line. */
 	if (leading) {
 		*result = 0;
 		return;
 	}
 
 	/* Trim spaces/quotes immediately before the '=', then copy the '='. */
 	while (isspace(dst[-1]) || dst[-1] == '"')
 		--dst;
 	*dst++ = *src++;
 
 	/* Copy chars after the '=', skipping any leading whitespace. */
 	leading = true;
 	while ((c = *src++) != 0) {
 		if (leading && (isspace(c) || c == '"'))
 			continue;
 		*dst++ = c;
 		leading = false;
 	}
 
 	/* If it was all leading space, it's a valid 'var=' (nil value). */
 	if (leading) {
 		*dst = 0;
 		return;
 	}
 
 	/* Trim trailing whitespace and quotes. */
 	while (isspace(dst[-1]) || dst[-1] == '"')
 		--dst;
 
 	*dst = 0;
 }
 
+static void
+process_into_file(char *line, FILE *ofp)
+{
+	char result[BUFSIZ];
+
+	sanitize_envline(result, line);
+	/* anything left? */
+	if (*result == '\0')
+		return;
+	fprintf(ofp, "\"%s\\0\"\n", result);
+}
+
+static void
+process_into_nvlist(char *line, nvlist_t *nvl)
+{
+	char result[BUFSIZ], *s;
+
+	sanitize_envline(result, line);
+	/* anything left? */
+	if (*result == '\0')
+		return;
+	s = strchr(result, '=');
+	*s = 0;
+	if (nvlist_exists(nvl, result))
+		nvlist_free(nvl, result);
+	nvlist_add_string(nvl, result, s + 1);
+}
+
+static void
+dump_nvlist(nvlist_t *nvl, FILE *ofp)
+{
+	const char *name;
+	void *cookie;
+
+	if (nvl == NULL)
+		return;
+
+	while (!nvlist_empty(nvl)) {
+		cookie = NULL;
+		name = nvlist_next(nvl, NULL, &cookie);
+		fprintf(ofp, "\"%s=%s\\0\"\n", name,
+		     cnvlist_get_string(cookie));
+
+		cnvlist_free_string(cookie);
+	}
+}
+
 /*
+ * Build hints.c from the skeleton
+ */
+void
+makehints(void)
+{
+	FILE *ifp, *ofp;
+	nvlist_t *nvl;
+	char line[BUFSIZ];
+	struct hint *hint;
+
+	ofp = fopen(path("hints.c.new"), "w");
+	if (ofp == NULL)
+		err(1, "%s", path("hints.c.new"));
+	fprintf(ofp, "#include <sys/types.h>\n");
+	fprintf(ofp, "#include <sys/systm.h>\n");
+	fprintf(ofp, "\n");
+	/*
+	 * Write out hintmode for older kernels. Remove when config(8) major
+	 * version rolls over.
+	 */
+	if (versreq <= CONFIGVERS_ENVMODE_REQ)
+		fprintf(ofp, "int hintmode = %d;\n",
+			!STAILQ_EMPTY(&hints) ? 1 : 0);
+	fprintf(ofp, "char static_hints[] = {\n");
+	nvl = nvlist_create(0);
+	STAILQ_FOREACH(hint, &hints, hint_next) {
+		ifp = fopen(hint->hint_name, "r");
+		if (ifp == NULL)
+			err(1, "%s", hint->hint_name);
+		while (fgets(line, BUFSIZ, ifp) != NULL)
+			process_into_nvlist(line, nvl);
+		dump_nvlist(nvl, ofp);
+		fclose(ifp);
+	}
+	nvlist_destroy(nvl);
+	fprintf(ofp, "\"\\0\"\n};\n");
+	fclose(ofp);
+	moveifchanged(path("hints.c.new"), path("hints.c"));
+}
+
+/*
  * Build env.c from the skeleton
  */
 void
 makeenv(void)
 {
 	FILE *ifp, *ofp;
-	char line[BUFSIZ], result[BUFSIZ], *linep;
+	nvlist_t *nvl;
+	char line[BUFSIZ];
 	struct envvar *envvar;
 
 	ofp = fopen(path("env.c.new"), "w");
 	if (ofp == NULL)
 		err(1, "%s", path("env.c.new"));
 	fprintf(ofp, "#include <sys/types.h>\n");
 	fprintf(ofp, "#include <sys/systm.h>\n");
 	fprintf(ofp, "\n");
-	fprintf(ofp, "int envmode = %d;\n", envmode);
+	/*
+	 * Write out envmode for older kernels. Remove when config(8) major
+	 * version rolls over.
+	 */
+	if (versreq <= CONFIGVERS_ENVMODE_REQ)
+		fprintf(ofp, "int envmode = %d;\n",
+			!STAILQ_EMPTY(&envvars) ? 1 : 0);
 	fprintf(ofp, "char static_env[] = {\n");
+	nvl = nvlist_create(0);
 	STAILQ_FOREACH(envvar, &envvars, envvar_next) {
 		if (envvar->env_is_file) {
 			ifp = fopen(envvar->env_str, "r");
 			if (ifp == NULL)
 				err(1, "%s", envvar->env_str);
-			while (fgets(line, BUFSIZ, ifp) != NULL) {
-				sanitize_envline(result, line);
-				/* anything left? */
-				if (*result == '\0')
-					continue;
-				fprintf(ofp, "\"%s\\0\"\n", result);
-			}
+			while (fgets(line, BUFSIZ, ifp) != NULL)
+				process_into_nvlist(line, nvl);
+			dump_nvlist(nvl, ofp);
 			fclose(ifp);
-		} else {
-			linep = envvar->env_str;
-			sanitize_envline(result, linep);
-			if (*result == '\0')
-				continue;
-			fprintf(ofp, "\"%s\\0\"\n", result);
-		}
+		} else
+			process_into_file(envvar->env_str, ofp);
 	}
+	nvlist_destroy(nvl);
 	fprintf(ofp, "\"\\0\"\n};\n");
 	fclose(ofp);
 	moveifchanged(path("env.c.new"), path("env.c"));
 }
 
 static void
 read_file(char *fname)
 {
 	char ifname[MAXPATHLEN];
 	FILE *fp;
 	struct file_list *tp;
 	struct device *dp;
 	struct opt *op;
 	char *wd, *this, *compilewith, *depends, *clean, *warning;
 	const char *objprefix;
 	int compile, match, nreqs, std, filetype, not,
 	    imp_rule, no_obj, before_depend, nowerror;
 
 	fp = fopen(fname, "r");
 	if (fp == NULL)
 		err(1, "%s", fname);
 next:
 	/*
 	 * include "filename"
 	 * filename    [ standard | optional ]
 	 *	[ dev* [ | dev* ... ] | profiling-routine ] [ no-obj ]
 	 *	[ compile-with "compile rule" [no-implicit-rule] ]
 	 *      [ dependency "dependency-list"] [ before-depend ]
 	 *	[ clean "file-list"] [ warning "text warning" ]
 	 *	[ obj-prefix "file prefix"]
 	 */
 	wd = get_word(fp);
 	if (wd == (char *)EOF) {
 		(void) fclose(fp);
 		return;
 	} 
 	if (wd == NULL)
 		goto next;
 	if (wd[0] == '#')
 	{
 		while (((wd = get_word(fp)) != (char *)EOF) && wd)
 			;
 		goto next;
 	}
 	if (eq(wd, "include")) {
 		wd = get_quoted_word(fp);
 		if (wd == (char *)EOF || wd == NULL)
 			errout("%s: missing include filename.\n", fname);
 		(void) snprintf(ifname, sizeof(ifname), "../../%s", wd);
 		read_file(ifname);
 		while (((wd = get_word(fp)) != (char *)EOF) && wd)
 			;
 		goto next;
 	}
 	this = ns(wd);
 	wd = get_word(fp);
 	if (wd == (char *)EOF)
 		return;
 	if (wd == NULL)
 		errout("%s: No type for %s.\n", fname, this);
 	tp = fl_lookup(this);
 	compile = 0;
 	match = 1;
 	nreqs = 0;
 	compilewith = 0;
 	depends = 0;
 	clean = 0;
 	warning = 0;
 	std = 0;
 	imp_rule = 0;
 	no_obj = 0;
 	before_depend = 0;
 	nowerror = 0;
 	not = 0;
 	filetype = NORMAL;
 	objprefix = "";
 	if (eq(wd, "standard"))
 		std = 1;
 	else if (!eq(wd, "optional"))
 		errout("%s: \"%s\" %s must be optional or standard\n",
 		    fname, wd, this);
 	for (wd = get_word(fp); wd; wd = get_word(fp)) {
 		if (wd == (char *)EOF)
 			return;
 		if (eq(wd, "!")) {
 			not = 1;
 			continue;
 		}
 		if (eq(wd, "|")) {
 			if (nreqs == 0)
 				errout("%s: syntax error describing %s\n",
 				       fname, this);
 			compile += match;
 			match = 1;
 			nreqs = 0;
 			continue;
 		}
 		if (eq(wd, "no-obj")) {
 			no_obj++;
 			continue;
 		}
 		if (eq(wd, "no-implicit-rule")) {
 			if (compilewith == NULL)
 				errout("%s: alternate rule required when "
 				       "\"no-implicit-rule\" is specified for"
 				       " %s.\n",
 				       fname, this);
 			imp_rule++;
 			continue;
 		}
 		if (eq(wd, "before-depend")) {
 			before_depend++;
 			continue;
 		}
 		if (eq(wd, "dependency")) {
 			wd = get_quoted_word(fp);
 			if (wd == (char *)EOF || wd == NULL)
 				errout("%s: %s missing dependency string.\n",
 				       fname, this);
 			depends = ns(wd);
 			continue;
 		}
 		if (eq(wd, "clean")) {
 			wd = get_quoted_word(fp);
 			if (wd == (char *)EOF || wd == NULL)
 				errout("%s: %s missing clean file list.\n",
 				       fname, this);
 			clean = ns(wd);
 			continue;
 		}
 		if (eq(wd, "compile-with")) {
 			wd = get_quoted_word(fp);
 			if (wd == (char *)EOF || wd == NULL)
 				errout("%s: %s missing compile command string.\n",
 				       fname, this);
 			compilewith = ns(wd);
 			continue;
 		}
 		if (eq(wd, "warning")) {
 			wd = get_quoted_word(fp);
 			if (wd == (char *)EOF || wd == NULL)
 				errout("%s: %s missing warning text string.\n",
 				       fname, this);
 			warning = ns(wd);
 			continue;
 		}
 		if (eq(wd, "obj-prefix")) {
 			wd = get_quoted_word(fp);
 			if (wd == (char *)EOF || wd == NULL)
 				errout("%s: %s missing object prefix string.\n",
 				       fname, this);
 			objprefix = ns(wd);
 			continue;
 		}
 		if (eq(wd, "nowerror")) {
 			nowerror = 1;
 			continue;
 		}
 		if (eq(wd, "local")) {
 			filetype = LOCAL;
 			continue;
 		}
 		if (eq(wd, "no-depend")) {
 			filetype = NODEPEND;
 			continue;
 		}
 		nreqs++;
 		if (eq(wd, "profiling-routine")) {
 			filetype = PROFILING;
 			continue;
 		}
 		if (std)
 			errout("standard entry %s has optional inclusion specifier %s!\n",
 			       this, wd);
 		STAILQ_FOREACH(dp, &dtab, d_next)
 			if (eq(dp->d_name, wd)) {
 				if (not)
 					match = 0;
 				else
 					dp->d_done |= DEVDONE;
 				goto nextparam;
 			}
 		SLIST_FOREACH(op, &opt, op_next)
 			if (op->op_value == 0 && opteq(op->op_name, wd)) {
 				if (not)
 					match = 0;
 				goto nextparam;
 			}
 		match &= not;
 nextparam:;
 		not = 0;
 	}
 	compile += match;
 	if (compile && tp == NULL) {
 		if (std == 0 && nreqs == 0)
 			errout("%s: what is %s optional on?\n",
 			       fname, this);
 		if (filetype == PROFILING && profiling == 0)
 			goto next;
 		tp = new_fent();
 		tp->f_fn = this;
 		tp->f_type = filetype;
 		if (filetype == LOCAL)
 			tp->f_srcprefix = "";
 		else
 			tp->f_srcprefix = "$S/";
 		if (imp_rule)
 			tp->f_flags |= NO_IMPLCT_RULE;
 		if (no_obj)
 			tp->f_flags |= NO_OBJ;
 		if (before_depend)
 			tp->f_flags |= BEFORE_DEPEND;
 		if (nowerror)
 			tp->f_flags |= NOWERROR;
 		tp->f_compilewith = compilewith;
 		tp->f_depends = depends;
 		tp->f_clean = clean;
 		tp->f_warn = warning;
 		tp->f_objprefix = objprefix;
 	}
 	goto next;
 }
 
 /*
  * Read in the information about files used in making the system.
  * Store it in the ftab linked list.
  */
 static void
 read_files(void)
 {
 	char fname[MAXPATHLEN];
 	struct files_name *nl, *tnl;
 	
 	(void) snprintf(fname, sizeof(fname), "../../conf/files");
 	read_file(fname);
 	(void) snprintf(fname, sizeof(fname),
 		       	"../../conf/files.%s", machinename);
 	read_file(fname);
 	for (nl = STAILQ_FIRST(&fntab); nl != NULL; nl = tnl) {
 		read_file(nl->f_name);
 		tnl = STAILQ_NEXT(nl, f_next);
 		free(nl->f_name);
 		free(nl);
 	}
 }
 
 static int
 opteq(const char *cp, const char *dp)
 {
 	char c, d;
 
 	for (; ; cp++, dp++) {
 		if (*cp != *dp) {
 			c = isupper(*cp) ? tolower(*cp) : *cp;
 			d = isupper(*dp) ? tolower(*dp) : *dp;
 			if (c != d)
 				return (0);
 		}
 		if (*cp == 0)
 			return (1);
 	}
 }
 
 static void
 do_before_depend(FILE *fp)
 {
 	struct file_list *tp;
 	int lpos, len;
 
 	fputs("BEFORE_DEPEND=", fp);
 	lpos = 15;
 	STAILQ_FOREACH(tp, &ftab, f_next)
 		if (tp->f_flags & BEFORE_DEPEND) {
 			len = strlen(tp->f_fn);
 			if ((len = 3 + len) + lpos > 72) {
 				lpos = 8;
 				fputs("\\\n\t", fp);
 			}
 			if (tp->f_flags & NO_IMPLCT_RULE)
 				fprintf(fp, "%s ", tp->f_fn);
 			else
 				fprintf(fp, "%s%s ", tp->f_srcprefix,
 				    tp->f_fn);
 			lpos += len + 1;
 		}
 	if (lpos != 8)
 		putc('\n', fp);
 }
 
 static void
 do_objs(FILE *fp)
 {
 	struct file_list *tp;
 	int lpos, len;
 	char *cp, och, *sp;
 
 	fprintf(fp, "OBJS=");
 	lpos = 6;
 	STAILQ_FOREACH(tp, &ftab, f_next) {
 		if (tp->f_flags & NO_OBJ)
 			continue;
 		sp = tail(tp->f_fn);
 		cp = sp + (len = strlen(sp)) - 1;
 		och = *cp;
 		*cp = 'o';
 		len += strlen(tp->f_objprefix);
 		if (len + lpos > 72) {
 			lpos = 8;
 			fprintf(fp, "\\\n\t");
 		}
 		fprintf(fp, "%s%s ", tp->f_objprefix, sp);
 		lpos += len + 1;
 		*cp = och;
 	}
 	if (lpos != 8)
 		putc('\n', fp);
 }
 
 static void
 do_xxfiles(char *tag, FILE *fp)
 {
 	struct file_list *tp;
 	int lpos, len, slen;
 	char *suff, *SUFF;
 
 	if (tag[strlen(tag) - 1] == '\n')
 		tag[strlen(tag) - 1] = '\0';
 
 	suff = ns(tag + 7);
 	SUFF = ns(suff);
 	raisestr(SUFF);
 	slen = strlen(suff);
 
 	fprintf(fp, "%sFILES=", SUFF);
 	free(SUFF);
 	lpos = 8;
 	STAILQ_FOREACH(tp, &ftab, f_next)
 		if (tp->f_type != NODEPEND) {
 			len = strlen(tp->f_fn);
 			if (tp->f_fn[len - slen - 1] != '.')
 				continue;
 			if (strcasecmp(&tp->f_fn[len - slen], suff) != 0)
 				continue;
 			if ((len = 3 + len) + lpos > 72) {
 				lpos = 8;
 				fputs("\\\n\t", fp);
 			}
 			fprintf(fp, "%s%s ", tp->f_srcprefix, tp->f_fn);
 			lpos += len + 1;
 		}
 	free(suff);
 	if (lpos != 8)
 		putc('\n', fp);
 }
 
 static char *
 tail(char *fn)
 {
 	char *cp;
 
 	cp = strrchr(fn, '/');
 	if (cp == NULL)
 		return (fn);
 	return (cp+1);
 }
 
 /*
  * Create the makerules for each file
  * which is part of the system.
  */
 static void
 do_rules(FILE *f)
 {
 	char *cp, *np, och;
 	struct file_list *ftp;
 	char *compilewith;
 	char cmd[128];
 
 	STAILQ_FOREACH(ftp, &ftab, f_next) {
 		if (ftp->f_warn)
 			fprintf(stderr, "WARNING: %s\n", ftp->f_warn);
 		cp = (np = ftp->f_fn) + strlen(ftp->f_fn) - 1;
 		och = *cp;
 		if (ftp->f_flags & NO_IMPLCT_RULE) {
 			if (ftp->f_depends)
 				fprintf(f, "%s%s: %s\n",
 					ftp->f_objprefix, np, ftp->f_depends);
 			else
 				fprintf(f, "%s%s: \n", ftp->f_objprefix, np);
 		}
 		else {
 			*cp = '\0';
 			if (och == 'o') {
 				fprintf(f, "%s%so:\n\t-cp %s%so .\n\n",
 					ftp->f_objprefix, tail(np),
 					ftp->f_srcprefix, np);
 				continue;
 			}
 			if (ftp->f_depends) {
 				fprintf(f, "%s%sln: %s%s%c %s\n",
 					ftp->f_objprefix, tail(np),
 					ftp->f_srcprefix, np, och,
 					ftp->f_depends);
 				fprintf(f, "\t${NORMAL_LINT}\n\n");
 				fprintf(f, "%s%so: %s%s%c %s\n",
 					ftp->f_objprefix, tail(np),
 					ftp->f_srcprefix, np, och,
 					ftp->f_depends);
 			}
 			else {
 				fprintf(f, "%s%sln: %s%s%c\n",
 					ftp->f_objprefix, tail(np),
 					ftp->f_srcprefix, np, och);
 				fprintf(f, "\t${NORMAL_LINT}\n\n");
 				fprintf(f, "%s%so: %s%s%c\n",
 					ftp->f_objprefix, tail(np),
 					ftp->f_srcprefix, np, och);
 			}
 		}
 		compilewith = ftp->f_compilewith;
 		if (compilewith == NULL) {
 			const char *ftype = NULL;
 
 			switch (ftp->f_type) {
 			case NORMAL:
 				ftype = "NORMAL";
 				break;
 			case PROFILING:
 				if (!profiling)
 					continue;
 				ftype = "PROFILE";
 				break;
 			default:
 				fprintf(stderr,
 				    "config: don't know rules for %s\n", np);
 				break;
 			}
 			snprintf(cmd, sizeof(cmd),
 			    "${%s_%c%s}", ftype,
 			    toupper(och),
 			    ftp->f_flags & NOWERROR ? "_NOWERROR" : "");
 			compilewith = cmd;
 		}
 		*cp = och;
 		if (strlen(ftp->f_objprefix))
 			fprintf(f, "\t%s %s%s\n", compilewith,
 			    ftp->f_srcprefix, np);
 		else
 			fprintf(f, "\t%s\n", compilewith);
 
 		if (!(ftp->f_flags & NO_OBJ))
 			fprintf(f, "\t${NORMAL_CTFCONVERT}\n\n");
 		else
 			fprintf(f, "\n");
 	}
 }
 
 static void
 do_clean(FILE *fp)
 {
 	struct file_list *tp;
 	int lpos, len;
 
 	fputs("CLEAN=", fp);
 	lpos = 7;
 	STAILQ_FOREACH(tp, &ftab, f_next)
 		if (tp->f_clean) {
 			len = strlen(tp->f_clean);
 			if (len + lpos > 72) {
 				lpos = 8;
 				fputs("\\\n\t", fp);
 			}
 			fprintf(fp, "%s ", tp->f_clean);
 			lpos += len + 1;
 		}
 	if (lpos != 8)
 		putc('\n', fp);
 }
 
 char *
 raisestr(char *str)
 {
 	char *cp = str;
 
 	while (*str) {
 		if (islower(*str))
 			*str = toupper(*str);
 		str++;
 	}
 	return (cp);
 }
Index: stable/11
===================================================================
--- stable/11	(revision 337332)
+++ stable/11	(revision 337333)

Property changes on: stable/11
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head:r335998,336019,336026,336036,336217,336335,336337,336415-336416,336419