diff --git a/release/Makefile b/release/Makefile
index 77df7762e412..fee5f9acf59b 100644
--- a/release/Makefile
+++ b/release/Makefile
@@ -1,332 +1,291 @@
 # $FreeBSD$
 #
 # Makefile for building releases and release media.
 #
 # User-driven targets:
 #  cdrom: Builds release CD-ROM media (disc1.iso)
 #  dvdrom: Builds release DVD-ROM media (dvd1.iso)
 #  memstick: Builds memory stick image (memstick.img)
 #  mini-memstick: Builds minimal memory stick image (mini-memstick.img)
 #  ftp: Sets up FTP distribution area (ftp)
 #  release: Invokes real-release, vm-release, and cloudware-release targets
 #  real-release: Build all media and FTP distribution area
 #  vm-release: Build all virtual machine image targets
 #  cloudware-release: Build all cloud hosting provider targets
 #  install: Invokes the release-install and vm-install targets
 #  release-install: Copies all release installation media into ${DESTDIR}
 #  vm-install: Copies all virtual machine images into ${DESTDIR}
 #
 # Variables affecting the build process:
 #  WORLDDIR: location of src tree -- must have built world and default kernel
 #            (by default, the directory above this one)
 #  PORTSDIR: location of ports tree to distribute (default: /usr/ports)
-#  DOCDIR:   location of doc tree (default: /usr/doc)
 #  XTRADIR:  xtra-bits-dir argument for <arch>/mkisoimages.sh
 #  NOPKG:    if set, do not distribute third-party packages
 #  NOPORTS:  if set, do not distribute ports tree
 #  NOSRC:    if set, do not distribute source tree
-#  NODOC:    if set, do not generate release documentation
 #  WITH_DVD: if set, generate dvd1.iso
 #  WITH_COMPRESSED_IMAGES: if set, compress installation images with xz(1)
 #		(uncompressed images are not removed)
 #  WITH_VMIMAGES: if set, build virtual machine images with the release
 #  WITH_COMPRESSED_VMIMAGES: if set, compress virtual machine disk images
 #  		with xz(1) (extremely time consuming)
 #  WITH_CLOUDWARE: if set, build cloud hosting disk images with the release
 #  TARGET/TARGET_ARCH: architecture of built release
 #
 
 WORLDDIR?=	${.CURDIR}/..
 PORTSDIR?=	/usr/ports
-DOCDIR?=	/usr/doc
 RELNOTES_LANG?= en_US.ISO8859-1
 
 .if !defined(TARGET) || empty(TARGET)
 TARGET=		${MACHINE}
 .endif
 .if !defined(TARGET_ARCH) || empty(TARGET_ARCH)
 .if ${TARGET} == ${MACHINE}
 TARGET_ARCH=	${MACHINE_ARCH}
 .else
 TARGET_ARCH=	${TARGET}
 .endif
 .endif
 IMAKE=		${MAKE} TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET}
 DISTDIR=	dist
 
 # Define OSRELEASE by using newvers.sh
 .if !defined(OSRELEASE) || empty(OSRELEASE)
 .for _V in TYPE BRANCH REVISION
 ${_V}!=	eval $$(awk '/^${_V}=/{print}' ${.CURDIR}/../sys/conf/newvers.sh); echo $$${_V}
 .endfor
 .for _V in ${TARGET_ARCH}
 .if !empty(TARGET:M${_V})
 OSRELEASE=	${TYPE}-${REVISION}-${BRANCH}-${TARGET}
 VOLUME_LABEL=	${REVISION:C/[.-]/_/g}_${BRANCH:C/[.-]/_/g}_${TARGET}
 .else
 OSRELEASE=	${TYPE}-${REVISION}-${BRANCH}-${TARGET}-${TARGET_ARCH}
 VOLUME_LABEL=	${REVISION:C/[.-]/_/g}_${BRANCH:C/[.-]/_/g}_${TARGET_ARCH}
 .endif
 .endfor
 .endif
 
 .if !defined(VOLUME_LABEL) || empty(VOLUME_LABEL)
 VOLUME_LABEL=	FreeBSD_Install
 .endif
 
-.if !exists(${DOCDIR})
-NODOC= true
-.endif
 .if !exists(${PORTSDIR})
 NOPORTS= true
 .endif
 
 EXTRA_PACKAGES=
 .if !defined(NOPORTS)
 EXTRA_PACKAGES+= ports.txz
 .endif
 .if !defined(NOSRC)
 EXTRA_PACKAGES+= src.txz
 .endif
-#.if !defined(NODOC)
-#EXTRA_PACKAGES+= reldoc
-#.endif
 
 RELEASE_TARGETS= ftp
 IMAGES=
 .if exists(${.CURDIR}/${TARGET}/mkisoimages.sh)
 RELEASE_TARGETS+= cdrom
 IMAGES+=	disc1.iso bootonly.iso
 . if defined(WITH_DVD) && !empty(WITH_DVD)
 RELEASE_TARGETS+= dvdrom
 IMAGES+=	dvd1.iso
 . endif
 .endif
 .if exists(${.CURDIR}/${TARGET}/make-memstick.sh)
 RELEASE_TARGETS+= memstick.img
 RELEASE_TARGETS+= mini-memstick.img
 IMAGES+=	memstick.img
 IMAGES+=	mini-memstick.img
 .endif
 
 CLEANFILES=	packagesystem *.txz MANIFEST release ${IMAGES}
 .if defined(WITH_COMPRESSED_IMAGES) && !empty(WITH_COMPRESSED_IMAGES)
 . for I in ${IMAGES}
 CLEANFILES+=	${I}.xz
 . endfor
 .endif
 .if defined(WITH_DVD) && !empty(WITH_DVD)
 CLEANFILES+=	pkg-stage
 .endif
 CLEANDIRS=	dist ftp disc1 bootonly dvd
-#.if !defined(NODOC)
-#CLEANDIRS+=    reldoc rdoc
-#.endif
 beforeclean:
 	chflags -R noschg .
 .include <bsd.obj.mk>
 clean: beforeclean
 
 base.txz:
 	mkdir -p ${DISTDIR}
 	cd ${WORLDDIR} && ${IMAKE} distributeworld DISTDIR=${.OBJDIR}/${DISTDIR}
 # Set up mergemaster root database
 	sh ${.CURDIR}/scripts/mm-mtree.sh -m ${WORLDDIR} -F \
 	    "TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET} ${.MAKE.JOBS:D-j${.MAKE.JOBS}}" \
 	    -D "${.OBJDIR}/${DISTDIR}/base"
 	etcupdate extract -B -M "TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET}" \
 	    -s ${WORLDDIR} -d "${.OBJDIR}/${DISTDIR}/base/var/db/etcupdate"
 # Package all components
 	cd ${WORLDDIR} && ${IMAKE} packageworld DISTDIR=${.OBJDIR}/${DISTDIR}
 	mv ${DISTDIR}/*.txz .
 
 kernel.txz:
 	mkdir -p ${DISTDIR}
 	cd ${WORLDDIR} && ${IMAKE} distributekernel packagekernel DISTDIR=${.OBJDIR}/${DISTDIR}
 	mv ${DISTDIR}/kernel*.txz .
 
 src.txz:
 	mkdir -p ${DISTDIR}/usr
 	ln -fs ${WORLDDIR} ${DISTDIR}/usr/src
 	cd ${DISTDIR} && tar cLvf - --exclude .svn --exclude .zfs \
 	    --exclude .git --exclude @ --exclude usr/src/release/dist usr/src | \
 	    ${XZ_CMD} > ${.OBJDIR}/src.txz
 
 ports.txz:
 	mkdir -p ${DISTDIR}/usr
 	ln -fs ${PORTSDIR} ${DISTDIR}/usr/ports
 	cd ${DISTDIR} && tar cLvf - \
 	    --exclude .git --exclude .svn \
 	    --exclude usr/ports/distfiles --exclude usr/ports/packages \
 	    --exclude 'usr/ports/INDEX*' --exclude work usr/ports | \
 	    ${XZ_CMD} > ${.OBJDIR}/ports.txz
 
-#reldoc:
-#	cd ${DOCDIR}/en_US.ISO8859-1/htdocs/releases/${REVISION}R && \
-#	    env MAN4DIR=${WORLDDIR}/share/man/man4 \
-#	    _BRANCH=${BRANCH} \
-#	    ${MAKE} all install clean "FORMATS=html txt" \
-#	    INSTALL_COMPRESSED='' URLS_ABSOLUTE=YES DOCDIR=${.OBJDIR}/rdoc \
-#	    WEBDIR=${DOCDIR} DESTDIR=${.OBJDIR}/rdoc
-#	mkdir -p reldoc
-#.for i in hardware readme relnotes errata
-#	ln -f ${.OBJDIR}/rdoc/${i:tl}.txt \
-#		reldoc/${i:tu}.TXT
-#	ln -f ${.OBJDIR}/rdoc/${i:tl}.html \
-#		reldoc/${i:tu}.HTML
-#.endfor
-#	cp ${.OBJDIR}/rdoc/docbook.css \
-#		reldoc/
-
 disc1: packagesystem
 # Install system
 	mkdir -p ${.TARGET}
 	cd ${WORLDDIR} && ${IMAKE} installkernel installworld distribution \
 	    DESTDIR=${.OBJDIR}/${.TARGET} MK_AT=no \
 	    MK_INSTALLLIB=no MK_LIB32=no MK_MAIL=no \
 	    MK_TOOLCHAIN=no MK_PROFILE=no \
 	    MK_RESCUE=no MK_DICT=no \
 	    MK_KERNEL_SYMBOLS=no MK_TESTS=no MK_DEBUG_FILES=no \
 	    -DDB_FROM_SRC
 # Copy distfiles
 	mkdir -p ${.TARGET}/usr/freebsd-dist
 	for dist in MANIFEST $$(ls *.txz | grep -vE -- '(base|lib32)-dbg'); \
 	    do cp $${dist} ${.TARGET}/usr/freebsd-dist; \
 	done
-# Copy documentation, if generated
-#.if !defined(NODOC)
-#	cp reldoc/* ${.TARGET}
-#.endif
 # Set up installation environment
 	ln -fs /tmp/bsdinstall_etc/resolv.conf ${.TARGET}/etc/resolv.conf
 	echo sendmail_enable=\"NONE\" > ${.TARGET}/etc/rc.conf
 	echo hostid_enable=\"NO\" >> ${.TARGET}/etc/rc.conf
 	echo debug.witness.trace=0 >> ${.TARGET}/etc/sysctl.conf
 	echo vfs.mountroot.timeout=\"10\" >> ${.TARGET}/boot/loader.conf
 	echo kernels_autodetect=\"NO\" >> ${.TARGET}/boot/loader.conf
 	cp ${.CURDIR}/rc.local ${.TARGET}/etc
 	touch ${.TARGET}
 
 bootonly: packagesystem
 # Install system
 	mkdir -p ${.TARGET}
 	cd ${WORLDDIR} && ${IMAKE} installkernel installworld distribution \
 	    DESTDIR=${.OBJDIR}/${.TARGET} MK_AT=no \
 	    MK_GAMES=no \
 	    MK_INSTALLLIB=no MK_LIB32=no MK_MAIL=no \
 	    MK_TOOLCHAIN=no MK_PROFILE=no \
 	    MK_RESCUE=no MK_DICT=no \
 	    MK_KERNEL_SYMBOLS=no MK_TESTS=no MK_DEBUG_FILES=no \
 	    -DDB_FROM_SRC
 # Copy manifest only (no distfiles) to get checksums
 	mkdir -p ${.TARGET}/usr/freebsd-dist
 	cp MANIFEST ${.TARGET}/usr/freebsd-dist
-# Copy documentation, if generated
-#.if !defined(NODOC)
-#	cp reldoc/* ${.TARGET}
-#.endif
 # Set up installation environment
 	ln -fs /tmp/bsdinstall_etc/resolv.conf ${.TARGET}/etc/resolv.conf
 	echo sendmail_enable=\"NONE\" > ${.TARGET}/etc/rc.conf
 	echo hostid_enable=\"NO\" >> ${.TARGET}/etc/rc.conf
 	echo debug.witness.trace=0 >> ${.TARGET}/etc/sysctl.conf
 	echo vfs.mountroot.timeout=\"10\" >> ${.TARGET}/boot/loader.conf
 	echo kernels_autodetect=\"NO\" >> ${.TARGET}/boot/loader.conf
 	cp ${.CURDIR}/rc.local ${.TARGET}/etc
 
 dvd: packagesystem
 # Install system
 	mkdir -p ${.TARGET}
 	cd ${WORLDDIR} && ${IMAKE} installkernel installworld distribution \
 		DESTDIR=${.OBJDIR}/${.TARGET} MK_RESCUE=no MK_KERNEL_SYMBOLS=no \
 		MK_TESTS=no MK_DEBUG_FILES=no \
 		-DDB_FROM_SRC
 # Copy distfiles
 	mkdir -p ${.TARGET}/usr/freebsd-dist
 	for dist in MANIFEST $$(ls *.txz | grep -v -- '(base|lib32)-dbg'); \
 	    do cp $${dist} ${.TARGET}/usr/freebsd-dist; \
 	done
-# Copy documentation, if generated
-#.if !defined(NODOC)
-#	cp reldoc/* ${.TARGET}
-#.endif
 # Set up installation environment
 	ln -fs /tmp/bsdinstall_etc/resolv.conf ${.TARGET}/etc/resolv.conf
 	echo sendmail_enable=\"NONE\" > ${.TARGET}/etc/rc.conf
 	echo hostid_enable=\"NO\" >> ${.TARGET}/etc/rc.conf
 	echo debug.witness.trace=0 >> ${.TARGET}/etc/sysctl.conf
 	echo vfs.mountroot.timeout=\"10\" >> ${.TARGET}/boot/loader.conf
 	echo kernels_autodetect=\"NO\" >> ${.TARGET}/boot/loader.conf
 	cp ${.CURDIR}/rc.local ${.TARGET}/etc
 	touch ${.TARGET}
 
 release.iso: disc1.iso
 disc1.iso: disc1
 	sh ${.CURDIR}/${TARGET}/mkisoimages.sh -b ${VOLUME_LABEL}_CD ${.TARGET} disc1 ${XTRADIR}
 
 dvd1.iso: dvd pkg-stage
 	sh ${.CURDIR}/${TARGET}/mkisoimages.sh -b ${VOLUME_LABEL}_DVD ${.TARGET} dvd ${XTRADIR}
 
 bootonly.iso: bootonly
 	sh ${.CURDIR}/${TARGET}/mkisoimages.sh -b ${VOLUME_LABEL}_BO ${.TARGET} bootonly ${XTRADIR}
 
 memstick: memstick.img
 memstick.img: disc1
 	sh ${.CURDIR}/${TARGET}/make-memstick.sh disc1 ${.TARGET}
 
 mini-memstick: mini-memstick.img
 mini-memstick.img: bootonly
 	sh ${.CURDIR}/${TARGET}/make-memstick.sh bootonly ${.TARGET}
 
 packagesystem: base.txz kernel.txz ${EXTRA_PACKAGES}
 	sh ${.CURDIR}/scripts/make-manifest.sh *.txz > MANIFEST
 	touch ${.TARGET}
 
 pkg-stage:
 .if !defined(NOPKG) || empty(NOPKG)
 	env PORTSDIR=${PORTSDIR} REPOS_DIR=${.CURDIR}/pkg_repos/ \
 		sh ${.CURDIR}/scripts/pkg-stage.sh
 	mkdir -p ${.OBJDIR}/dvd/packages/repos/
 	cp ${.CURDIR}/scripts/FreeBSD_install_cdrom.conf \
 		${.OBJDIR}/dvd/packages/repos/
 .endif
 	touch ${.TARGET}
 
 cdrom: disc1.iso bootonly.iso
 dvdrom: dvd1.iso
 ftp: packagesystem
 	rm -rf ftp
 	mkdir -p ftp
 	cp *.txz MANIFEST ftp
 
 release:	real-release vm-release cloudware-release
 	${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} release-done
 	true
 
 release-done:
 	touch release
 
 real-release:
 	${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} obj
 	${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} ${RELEASE_TARGETS}
 
 install:	release-install vm-install
 
 release-install:
 .if defined(DESTDIR) && !empty(DESTDIR)
 	mkdir -p ${DESTDIR}
 .endif
 	cp -a ftp ${DESTDIR}/
 .if !empty(IMAGES)
 .for I in ${IMAGES}
 	cp -p ${I} ${DESTDIR}/${OSRELEASE}-${I}
 . if defined(WITH_COMPRESSED_IMAGES) && !empty(WITH_COMPRESSED_IMAGES)
 	${XZ_CMD} -k ${DESTDIR}/${OSRELEASE}-${I}
 . endif
 .endfor
 	cd ${DESTDIR} && sha512 ${OSRELEASE}* > ${DESTDIR}/CHECKSUM.SHA512
 	cd ${DESTDIR} && sha256 ${OSRELEASE}* > ${DESTDIR}/CHECKSUM.SHA256
 .endif
 
 .include "${.CURDIR}/Makefile.inc1"
 .include "${.CURDIR}/Makefile.vm"
diff --git a/release/arm/GENERICSD.conf b/release/arm/GENERICSD.conf
index 8749f5fd95cf..c76829b22b04 100644
--- a/release/arm/GENERICSD.conf
+++ b/release/arm/GENERICSD.conf
@@ -1,69 +1,68 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="armv7"
 EMBEDDED_TARGET="arm"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-beaglebone sysutils/u-boot-rpi2 sysutils/rpi-firmware"
 FAT_SIZE="50m -b 1m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 BBB_UBOOT_DIR="/usr/local/share/u-boot/u-boot-beaglebone"
 RPI_UBOOT_DIR="/usr/local/share/u-boot/u-boot-rpi2"
 RPI_FIRMWARE_DIR="/usr/local/share/rpi-firmware"
 RPI_OL_DIR="${RPI_FIRMWARE_DIR}/overlays"
 OVERLAYS="mmc.dtbo"
 PART_SCHEME="MBR"
 export BOARDNAME="GENERICSD"
 
 arm_install_uboot_rpi2() {
 	UBOOT_FILES="u-boot.bin"
 	RPI_FIRMWARE_FILES="bootcode.bin config.txt \
 		fixup.dat fixup_cd.dat fixup_db.dat fixup_x.dat \
 		start.elf start_cd.elf start_db.elf start_x.elf \
 		bcm2709-rpi-2-b.dtb"
 	FATMOUNT="${DESTDIR%${KERNEL}}/fat"
 	chroot ${CHROOTDIR} mkdir -p "${FATMOUNT}"
 	chroot ${CHROOTDIR} mount_msdosfs /dev/${mddev}s1 ${FATMOUNT}
 	for _UF in ${UBOOT_FILES}; do
 		chroot ${CHROOTDIR} cp -p ${RPI_UBOOT_DIR}/${_UF} \
 			${FATMOUNT}/${_UF}
 	done
 	for _UF in ${RPI_FIRMWARE_FILES}; do
 		chroot ${CHROOTDIR} cp -p ${RPI_FIRMWARE_DIR}/${_UF} \
 			${FATMOUNT}/${_UF}
 	done
 	chroot ${CHROOTDIR} mkdir -p ${FATMOUNT}/overlays
 	for _OL in ${OVERLAYS}; do
 		chroot ${CHROOTDIR} cp -p ${RPI_OL_DIR}/${_OL} \
 			${FATMOUNT}/overlays/${_OL}
 	done
 	sync
 	umount_loop ${CHROOTDIR}/${FATMOUNT}
 	chroot ${CHROOTDIR} rmdir ${FATMOUNT}
 	
 	return 0
 }
 
 arm_install_uboot_bbb() {
 	FATMOUNT="${DESTDIR%${KERNEL}}/fat"
 	chroot ${CHROOTDIR} mkdir -p "${FATMOUNT}"
 	chroot ${CHROOTDIR} mount_msdosfs /dev/${mddev}s1 ${FATMOUNT}
 	chroot ${CHROOTDIR} cp -p ${BBB_UBOOT_DIR}/MLO ${FATMOUNT}/MLO
 	chroot ${CHROOTDIR} cp -p ${BBB_UBOOT_DIR}/u-boot.img ${FATMOUNT}/u-boot.img
 	sync
 	umount_loop ${CHROOTDIR}/${FATMOUNT}
 	chroot ${CHROOTDIR} rmdir ${FATMOUNT}
 
 	return 0
 }
 
 arm_install_uboot() {
 	arm_install_uboot_bbb
 	arm_install_uboot_rpi2
 }
diff --git a/release/arm/RPI-B.conf b/release/arm/RPI-B.conf
index 27fa6aac2644..f164edd25b90 100644
--- a/release/arm/RPI-B.conf
+++ b/release/arm/RPI-B.conf
@@ -1,51 +1,50 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="armv6"
 EMBEDDED_TARGET="arm"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-rpi sysutils/rpi-firmware"
 FAT_SIZE="50m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="RPI-B"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 UBOOT_DIR="/usr/local/share/u-boot/u-boot-rpi"
 RPI_FIRMWARE_DIR="/usr/local/share/rpi-firmware"
 OL_DIR="${RPI_FIRMWARE_DIR}/overlays"
 OVERLAYS="mmc.dtbo disable-bt.dtbo"
 PART_SCHEME="MBR"
 export BOARDNAME="RPI-B"
 
 arm_install_uboot() {
 	UBOOT_FILES="u-boot.bin"
 	RPI_FIRMWARE_FILES="bootcode.bin config.txt \
 		fixup.dat fixup_cd.dat fixup_db.dat fixup_x.dat \
 		start.elf start_cd.elf start_db.elf start_x.elf \
 		bcm2708-rpi-zero-w.dtb bcm2708-rpi-b-plus.dtb \
 		bcm2708-rpi-b.dtb bcm2708-rpi-cm.dtb"
 	FATMOUNT="${DESTDIR%${KERNEL}}/fat"
 	chroot ${CHROOTDIR} mkdir -p "${FATMOUNT}"
 	chroot ${CHROOTDIR} mount_msdosfs /dev/${mddev}s1 ${FATMOUNT}
 	for _UF in ${UBOOT_FILES}; do
 		chroot ${CHROOTDIR} cp -p ${UBOOT_DIR}/${_UF} \
 			${FATMOUNT}/${_UF}
 	done
 	for _UF in ${RPI_FIRMWARE_FILES}; do
 		chroot ${CHROOTDIR} cp -p ${RPI_FIRMWARE_DIR}/${_UF} \
 			${FATMOUNT}/${_UF}
 	done
 	chroot ${CHROOTDIR} mkdir -p ${FATMOUNT}/overlays
 	for _OL in ${OVERLAYS}; do
 		chroot ${CHROOTDIR} cp -p ${OL_DIR}/${_OL} \
 			${FATMOUNT}/overlays/${_OL}
 	done
 	sync
 	umount_loop ${CHROOTDIR}/${FATMOUNT}
 	chroot ${CHROOTDIR} rmdir ${FATMOUNT}
 	
 	return 0
 }
diff --git a/release/arm64/PINE64-LTS.conf b/release/arm64/PINE64-LTS.conf
index 60de485703c8..4006f6273307 100644
--- a/release/arm64/PINE64-LTS.conf
+++ b/release/arm64/PINE64-LTS.conf
@@ -1,27 +1,26 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="aarch64"
 EMBEDDED_TARGET="arm64"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-pine64-lts"
 FAT_SIZE="54m -b 1m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 PART_SCHEME="GPT"
 FDT_OVERLAYS="sun50i-a64-timer,sun50i-a64-opp"
 export BOARDNAME="PINE64-LTS"
 
 arm_install_uboot() {
 	UBOOT_DIR="/usr/local/share/u-boot/u-boot-pine64-lts"
 	UBOOT_FILES="u-boot-sunxi-with-spl.bin"
 	chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILES} \
 		of=/dev/${mddev} bs=128k seek=1 conv=sync
 	
 	return 0
 }
diff --git a/release/arm64/PINE64.conf b/release/arm64/PINE64.conf
index 12435e38730d..87cb9c584c54 100644
--- a/release/arm64/PINE64.conf
+++ b/release/arm64/PINE64.conf
@@ -1,27 +1,26 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="aarch64"
 EMBEDDED_TARGET="arm64"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-pine64"
 FAT_SIZE="54m -b 1m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 PART_SCHEME="GPT"
 FDT_OVERLAYS="sun50i-a64-timer,sun50i-a64-opp"
 export BOARDNAME="PINE64"
 
 arm_install_uboot() {
 	UBOOT_DIR="/usr/local/share/u-boot/u-boot-pine64"
 	UBOOT_FILES="u-boot-sunxi-with-spl.bin"
 	chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILES} \
 		of=/dev/${mddev} bs=128k seek=1 conv=sync
 	
 	return 0
 }
diff --git a/release/arm64/PINEBOOK.conf b/release/arm64/PINEBOOK.conf
index 20e5b7713161..da5d31149c04 100644
--- a/release/arm64/PINEBOOK.conf
+++ b/release/arm64/PINEBOOK.conf
@@ -1,42 +1,41 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="aarch64"
 EMBEDDED_TARGET="arm64"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-pinebook"
 FAT_SIZE="54m -b 1m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 PART_SCHEME="GPT"
 FDT_OVERLAYS="sun50i-a64-timer,sun50i-a64-opp"
 export BOARDNAME="PINEBOOK"
 
 arm_install_uboot() {
 	UBOOT_DIR="/usr/local/share/u-boot/u-boot-pinebook"
 	UBOOT_FILES="u-boot-sunxi-with-spl.bin"
 	chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILES} \
 		of=/dev/${mddev} bs=128k seek=1 conv=sync
 
 	return 0
 }
 
 arm_do_quirk() {
 	echo '# Enable quirk for trackpad' \
 	     >> ${CHROOTDIR}/${DESTDIR}/boot/loader.conf
 	echo 'usb_quirk_load=YES' \
 	     >> ${CHROOTDIR}/${DESTDIR}/boot/loader.conf
 	echo 'ums_load=YES' \
 	     >> ${CHROOTDIR}/${DESTDIR}/boot/loader.conf
 	echo 'hw.usb.quirk="0x258a 0x000c 0x0000 0xffff UQ_CFG_INDEX=1"' \
 	     >> ${CHROOTDIR}/${DESTDIR}/boot/loader.conf
 	# We want EFIFB but there is no node and so we cannot know
 	# which regulator is used for powering lcd/hdmi
 	echo 'hw.regulator.disable_unused=0' \
 	     >> ${CHROOTDIR}/${DESTDIR}/boot/loader.conf
 }
diff --git a/release/arm64/ROCK64.conf b/release/arm64/ROCK64.conf
index 02041dd789d7..e77930b73661 100644
--- a/release/arm64/ROCK64.conf
+++ b/release/arm64/ROCK64.conf
@@ -1,28 +1,27 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="aarch64"
 EMBEDDED_TARGET="arm64"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-rock64"
 FAT_SIZE="50m -b 16m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 PART_SCHEME="GPT"
 export BOARDNAME="ROCK64"
 
 arm_install_uboot() {
 	UBOOT_DIR="/usr/local/share/u-boot/u-boot-rock64"
 	UBOOT_FILE_1="idbloader.img"
 	UBOOT_FILE_2="u-boot.itb"
 	chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILE_1} \
 		of=/dev/${mddev} bs=512 seek=64 conv=sync
 	chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILE_2} \
 		of=/dev/${mddev} bs=512 seek=16384 conv=sync
 	return 0
 }
diff --git a/release/arm64/ROCKPRO64.conf b/release/arm64/ROCKPRO64.conf
index fc454e30ec72..e09c3a8b491f 100644
--- a/release/arm64/ROCKPRO64.conf
+++ b/release/arm64/ROCKPRO64.conf
@@ -1,28 +1,27 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="aarch64"
 EMBEDDED_TARGET="arm64"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-rockpro64"
 FAT_SIZE="50m -b 16m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 PART_SCHEME="GPT"
 export BOARDNAME="ROCKPRO64"
 
 arm_install_uboot() {
 	UBOOT_DIR="/usr/local/share/u-boot/u-boot-rockpro64"
 	UBOOT_FILE_1="idbloader.img"
 	UBOOT_FILE_2="u-boot.itb"
 	chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILE_1} \
 		of=/dev/${mddev} bs=512 seek=64 conv=sync
 	chroot ${CHROOTDIR} dd if=${UBOOT_DIR}/${UBOOT_FILE_2} \
 		of=/dev/${mddev} bs=512 seek=16384 conv=sync
 	return 0
 }
diff --git a/release/arm64/RPI.conf b/release/arm64/RPI.conf
index 2dfe23547ae9..e7fd12f95090 100644
--- a/release/arm64/RPI.conf
+++ b/release/arm64/RPI.conf
@@ -1,55 +1,54 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 DTB_DIR="/usr/local/share/rpi-firmware"
 DTB="bcm2710-rpi-2-b.dtb bcm2710-rpi-3-b.dtb bcm2710-rpi-3-b-plus.dtb bcm2711-rpi-4-b.dtb"
 EMBEDDED_TARGET_ARCH="aarch64"
 EMBEDDED_TARGET="arm64"
 EMBEDDEDBUILD=1
 EMBEDDEDPORTS="sysutils/u-boot-rpi-arm64 sysutils/rpi-firmware"
 FAT_SIZE="50m -b 1m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 OL_DIR="${DTB_DIR}/overlays"
 OVERLAYS="mmc.dtbo pwm.dtbo disable-bt.dtbo"
 PART_SCHEME="MBR"
 export BOARDNAME="RPI"
 
 arm_install_uboot() {
 	UBOOT_DIR="/usr/local/share/u-boot/u-boot-rpi-arm64"
 	UBOOT_FILES="README u-boot.bin"
 	DTB_FILES="armstub8.bin armstub8-gic.bin bootcode.bin fixup_cd.dat \
 		fixup_db.dat fixup_x.dat fixup.dat LICENCE.broadcom \
 		start_cd.elf start_db.elf start_x.elf start.elf \
 		fixup4.dat fixup4cd.dat fixup4db.dat fixup4x.dat start4.elf \
 		start4cd.elf start4db.elf start4x.elf ${DTB}"
 	FATMOUNT="${DESTDIR%${KERNEL}}fat"
 	chroot ${CHROOTDIR} mkdir -p "${FATMOUNT}"
 	chroot ${CHROOTDIR} mount_msdosfs /dev/${mddev}s1 ${FATMOUNT}
 	for _UF in ${UBOOT_FILES}; do
 		chroot ${CHROOTDIR} cp -p ${UBOOT_DIR}/${_UF} \
 			${FATMOUNT}/${_UF}
 	done
 	for _DF in ${DTB_FILES}; do
 		chroot ${CHROOTDIR} cp -p ${DTB_DIR}/${_DF} \
 			${FATMOUNT}/${_DF}
 	done
 	chroot ${CHROOTDIR} cp -p ${DTB_DIR}/config_arm64.txt \
 			${FATMOUNT}/config.txt
 	chroot ${CHROOTDIR} mkdir -p ${FATMOUNT}/overlays
 	for _OL in ${OVERLAYS}; do
 		chroot ${CHROOTDIR} cp -p ${OL_DIR}/${_OL} \
 			${FATMOUNT}/overlays/${_OL}
 	done
 
 	sync
 	umount_loop ${CHROOTDIR}/${FATMOUNT}
 	chroot ${CHROOTDIR} rmdir ${FATMOUNT}
 	
 	return 0
 }
diff --git a/release/release.conf.sample b/release/release.conf.sample
index bb9c8acb1b87..4de068750228 100644
--- a/release/release.conf.sample
+++ b/release/release.conf.sample
@@ -1,123 +1,116 @@
 #!/bin/sh
 #
 
 ## Redefine environment variables here to override prototypes
 ## defined in release.sh.
 #load_chroot_env() { }
 #load_target_env() { }
 #buildenv_setup() { }
 
 ## Set the directory within which the release will be built.
 CHROOTDIR="/scratch"
 
 ## Do not explicitly require the devel/git port to be installed.
 #NOGIT=1
 ## Set the version control system host.
 GITROOT="https://git.freebsd.org/"
 GITSRC="src.git"
 GITPORTS="ports.git"
-GITDOC="doc.git"
 
 ## Set the src/, ports/, and doc/ branches or tags.
 SRCBRANCH="main"
-DOCBRANCH="main"
 PORTBRANCH="main"
 
 ## Sample configuration for using git from ports.
 #GITCMD="/usr/local/bin/git clone -q --branch main"
 
 ## Set to override the default target architecture.
 #TARGET="amd64"
 #TARGET_ARCH="amd64"
 #KERNEL="GENERIC"
 ## Multiple kernels may be set.
 #KERNEL="GENERIC XENHVM"
 
 ## Set to specify a custom make.conf and/or src.conf
 #MAKE_CONF="/etc/local/make.conf"
 #SRC_CONF="/etc/local/src.conf"
 
 ## Set to use make(1) flags.
 #MAKE_FLAGS="-s"
 
 ## Set to use world- and kernel-specific make(1) flags.
 #WORLD_FLAGS="-j $(sysctl -n hw.ncpu)"
 #KERNEL_FLAGS="-j $(( $(( $(sysctl -n hw.ncpu) + 1 )) / 2 ))"
 
 ## Set miscellaneous 'make release' settings.
-#NODOC=
 #NOPORTS=
 #NOSRC=
 #WITH_DVD=
 #WITH_COMPRESSED_IMAGES=
 
 ## Set to '1' to disable multi-threaded xz(1) compression.
 #XZ_THREADS=0
 
 ## Set when building embedded images.
 #EMBEDDEDBUILD=
 
 ## Set to a list of ports required to build embedded system-on-chip
 ## images, such as sysutils/u-boot-rpi.
 #EMBEDDEDPORTS=
 
 ## Set to the hardware platform of the target userland.  This value
 ## is passed to make(1) to set the TARGET (value of uname -m) to cross
 ## build.
 #EMBEDDED_TARGET=
 
 ## Set to the machine processor architecture of the target userland.
 ## This value is passed to make(1) to set the TARGET_ARCH (value of uname -p)
 ## to cross build.
 #EMBEDDED_TARGET_ARCH=
 
 ## Set to skip the chroot environment buildworld/installworld/distribution
 ## step if it is expected the build environment will exist via alternate
 ## means.
 #CHROOTBUILD_SKIP=
 
 ## Set to a non-empty value skip checkout or update of /usr/src in
 ## the chroot.  This is intended for use when /usr/src already exists.
 #SRC_UPDATE_SKIP=
 
-## Set to a non-empty value skip checkout or update of /usr/doc in
-## the chroot.  This is intended for use when /usr/doc already exists.
-#DOC_UPDATE_SKIP=
-
 ## Set to a non-empty value skip checkout or update of /usr/ports in
 ## the chroot.  This is intended for use when /usr/ports already exists.
 #PORTS_UPDATE_SKIP=
 
 ## Set to pass additional flags to make(1) for the build chroot setup, such
 ## as TARGET/TARGET_ARCH.
 #CHROOT_MAKEENV=
 
 ## Set to a non-empty value to build virtual machine images as part of the
 ## release build.
 #WITH_VMIMAGES=
 
 ## Set to a non-empty value to compress virtual machine images with xz(1)
 ## as part of the release build.
 #WITH_COMPRESSED_VMIMAGES=
 
 ## If WITH_VMIMAGES is set to a non-empty value, this is the name of the
 ## file to use for the installed userland/kernel.
 #VMBASE="vm"
 
 ## If WITH_VMIMAGES is set to a non-empty value, this is the size of the
 ## virtual machine disk filesystem.  Valid size values are described in
 ## the truncate(1) manual page.
 #VMSIZE="20G"
 
 ## If WITH_VMIMAGES is set to a non-empty value, this is a list of disk
 ## image formats to create.  Valid values are listed in the mkimg(1)
 ## manual page, as well as 'mkimg --formats' output.
 #VMFORMATS="vhdf vmdk qcow2 raw"
 
 ## Set to a non-empty value to build virtual machine images for various
 ## cloud providers as part of the release build.
 #WITH_CLOUDWARE=
 
 ## If WITH_CLOUDWARE is set to a non-empty value, this is a list of providers
 ## to create disk images.
 #CLOUDWARE="EC2 GCE VAGRANT-VIRTUALBOX VAGRANT-VMWARE"
diff --git a/release/release.sh b/release/release.sh
index 58f946b9bba1..3d7612ef6b80 100755
--- a/release/release.sh
+++ b/release/release.sh
@@ -1,512 +1,468 @@
 #!/bin/sh
 #-
 # Copyright (c) 2020-2021 Rubicon Communications, LLC (netgate.com)
 # Copyright (c) 2013-2019 The FreeBSD Foundation
 # Copyright (c) 2013 Glen Barber
 # Copyright (c) 2011 Nathan Whitehorn
 # All rights reserved.
 #
 # Portions of this software were developed by Glen Barber
 # under sponsorship from the FreeBSD Foundation.
 #
 # 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.
 #
 # release.sh: check out source trees, and build release components with
 #  totally clean, fresh trees.
 # Based on release/generate-release.sh written by Nathan Whitehorn
 #
 
 export PATH="/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin"
 
 VERSION=3
 
 # Prototypes that can be redefined per-chroot or per-target.
 load_chroot_env() { }
 load_target_env() { }
 buildenv_setup() { }
 
 usage() {
 	echo "Usage: $0 [-c release.conf]"
 	exit 1
 }
 
 # env_setup(): Set up the default build environment variables, such as the
 # CHROOTDIR, VCSCMD, GITROOT, etc.  This is called before the release.conf
 # file is sourced, if '-c <release.conf>' is specified.
 env_setup() {
 	# The directory within which the release will be built.
 	CHROOTDIR="/scratch"
 	if [ -z "${RELENGDIR}" ]; then
 		export RELENGDIR="$(dirname $(realpath ${0}))"
 	fi
 
 	# The default version control system command to obtain the sources.
 	for _dir in /usr/bin /usr/local/bin; do
 		[ -x "${_dir}/git" ] && VCSCMD="/${_dir}/git"
 		[ ! -z "${VCSCMD}" ] && break 2
 	done
 
 	# Find the Subversion binary to use.  This is a workaround to use
 	# the source of truth for the ports tree, as the conversion to Git
 	# is targeted to occur slightly after the currently-scheduled 13.0
 	# release.
 	for _dir in /usr/bin /usr/local/bin; do
 		for _svn in svn svnlite; do
 			[ -x "${_dir}/${_svn}" ] && SVNCMD="${_dir}/${_svn}"
 			[ ! -z "${SVNCMD}" ] && break 2
 		done
 	done
 
 	if [ -z "${VCSCMD}" -a -z "${NOGIT}" ]; then
 		echo "*** The devel/git port/package is required."
 		exit 1
 	fi
 	VCSCMD="/usr/local/bin/git clone -q"
 
 	# The default git checkout server, and branches for src/, doc/,
 	# and ports/.
 	GITROOT="https://git.FreeBSD.org/"
 	SRCBRANCH="main"
-	DOCBRANCH="main"
 	PORTBRANCH="head"
 	GITSRC="src.git"
 	GITPORTS="ports.git"
-	GITDOC="doc.git"
 
 	# Set for embedded device builds.
 	EMBEDDEDBUILD=
 
 	# The default make.conf and src.conf to use.  Set to /dev/null
 	# by default to avoid polluting the chroot(8) environment with
 	# non-default settings.
 	MAKE_CONF="/dev/null"
 	SRC_CONF="/dev/null"
 
 	# The number of make(1) jobs, defaults to the number of CPUs available
 	# for buildworld, and half of number of CPUs available for buildkernel.
 	WORLD_FLAGS="-j$(sysctl -n hw.ncpu)"
 	KERNEL_FLAGS="-j$(( $(( $(sysctl -n hw.ncpu) + 1 )) / 2))"
 
 	MAKE_FLAGS="-s"
 
 	# The name of the kernel to build, defaults to GENERIC.
 	KERNEL="GENERIC"
 
 	# Set to non-empty value to disable checkout of doc/ and/or ports/.
-	# Disabling ports/ checkout also forces NODOC to be set.
-	NODOC=
 	NOPORTS=
 
 	# Set to non-empty value to disable distributing source tree.
 	NOSRC=
 
 	# Set to non-empty value to build dvd1.iso as part of the release.
 	WITH_DVD=
 	WITH_COMPRESSED_IMAGES=
 
 	# Set to non-empty value to build virtual machine images as part of
 	# the release.
 	WITH_VMIMAGES=
 	WITH_COMPRESSED_VMIMAGES=
 	XZ_THREADS=0
 
 	# Set to non-empty value to build virtual machine images for various
 	# cloud providers as part of the release.
 	WITH_CLOUDWARE=
 
 	return 0
 } # env_setup()
 
 # env_check(): Perform sanity tests on the build environment, such as ensuring
 # files/directories exist, as well as adding backwards-compatibility hacks if
 # necessary.  This is called unconditionally, and overrides the defaults set
 # in env_setup() if '-c <release.conf>' is specified.
 env_check() {
 	chroot_build_release_cmd="chroot_build_release"
 
 	# Prefix the branches with the GITROOT for the full checkout URL.
 	SRC="${GITROOT}${GITSRC}"
-	DOC="${GITROOT}${GITDOC}"
 	#PORT="${GITROOT}${GITPORTS}"
 	PORT="svn://svn.freebsd.org/ports/"
 
 	if [ -n "${EMBEDDEDBUILD}" ]; then
 		WITH_DVD=
 		WITH_COMPRESSED_IMAGES=
-		NODOC=yes
 		case ${EMBEDDED_TARGET}:${EMBEDDED_TARGET_ARCH} in
 			arm:arm*|arm64:aarch64|riscv:riscv64*)
 				chroot_build_release_cmd="chroot_arm_build_release"
 				;;
 			*)
 				;;
 		esac
 	fi
 
-	# If PORTS is set and NODOC is unset, force NODOC=yes because the ports
-	# tree is required to build the documentation set.
-	if [ -n "${NOPORTS}" ] && [ -z "${NODOC}" ]; then
-		echo "*** NOTICE: Setting NODOC=1 since ports tree is required"
-		echo "            and NOPORTS is set."
-		NODOC=yes
-	fi
-
-	# If NOSRC, NOPORTS and/or NODOC are unset, they must not pass to make
+	# If NOSRC and/or NOPORTS are unset, they must not pass to make
 	# as variables.  The release makefile verifies definedness of the
-	# NOPORTS/NODOC variables instead of their values.
-	SRCDOCPORTS=
+	# NOPORTS variable instead of its value.
+	SRCPORTS=
 	if [ -n "${NOPORTS}" ]; then
-		SRCDOCPORTS="NOPORTS=yes"
-	fi
-	if [ -n "${NODOC}" ]; then
-		SRCDOCPORTS="${SRCDOCPORTS}${SRCDOCPORTS:+ }NODOC=yes"
+		SRCPORTS="NOPORTS=yes"
 	fi
 	if [ -n "${NOSRC}" ]; then
-		SRCDOCPORTS="${SRCDOCPORTS}${SRCDOCPORTS:+ }NOSRC=yes"
+		SRCPORTS="${SRCPORTS}${SRCPORTS:+ }NOSRC=yes"
 	fi
 
 	# The aggregated build-time flags based upon variables defined within
 	# this file, unless overridden by release.conf.  In most cases, these
 	# will not need to be changed.
 	CONF_FILES="__MAKE_CONF=${MAKE_CONF} SRCCONF=${SRC_CONF}"
 	if [ -n "${TARGET}" ] && [ -n "${TARGET_ARCH}" ]; then
 		ARCH_FLAGS="TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH}"
 	else
 		ARCH_FLAGS=
 	fi
 
 	if [ -z "${CHROOTDIR}" ]; then
 		echo "Please set CHROOTDIR."
 		exit 1
 	fi
 
 	if [ $(id -u) -ne 0 ]; then
 		echo "Needs to be run as root."
 		exit 1
 	fi
 
 	# Unset CHROOTBUILD_SKIP if the chroot(8) does not appear to exist.
 	if [ ! -z "${CHROOTBUILD_SKIP}" -a ! -e ${CHROOTDIR}/bin/sh ]; then
 		CHROOTBUILD_SKIP=
 	fi
 
 	CHROOT_MAKEENV="${CHROOT_MAKEENV} \
 		MAKEOBJDIRPREFIX=${CHROOTDIR}/tmp/obj"
 	CHROOT_WMAKEFLAGS="${MAKE_FLAGS} ${WORLD_FLAGS} ${CONF_FILES}"
 	CHROOT_IMAKEFLAGS="${WORLD_FLAGS} ${CONF_FILES}"
 	CHROOT_DMAKEFLAGS="${WORLD_FLAGS} ${CONF_FILES}"
 	RELEASE_WMAKEFLAGS="${MAKE_FLAGS} ${WORLD_FLAGS} ${ARCH_FLAGS} \
 		${CONF_FILES}"
 	RELEASE_KMAKEFLAGS="${MAKE_FLAGS} ${KERNEL_FLAGS} \
 		KERNCONF=\"${KERNEL}\" ${ARCH_FLAGS} ${CONF_FILES}"
 	RELEASE_RMAKEFLAGS="${ARCH_FLAGS} \
-		KERNCONF=\"${KERNEL}\" ${CONF_FILES} ${SRCDOCPORTS} \
+		KERNCONF=\"${KERNEL}\" ${CONF_FILES} ${SRCPORTS} \
 		WITH_DVD=${WITH_DVD} WITH_VMIMAGES=${WITH_VMIMAGES} \
 		WITH_CLOUDWARE=${WITH_CLOUDWARE} XZ_THREADS=${XZ_THREADS}"
 
 	return 0
 } # env_check()
 
 # chroot_setup(): Prepare the build chroot environment for the release build.
 chroot_setup() {
 	load_chroot_env
 	mkdir -p ${CHROOTDIR}/usr
 
 	if [ -z "${SRC_UPDATE_SKIP}" ]; then
 		if [ -d "${CHROOTDIR}/usr/src/.git" ]; then
 			git -C ${CHROOTDIR}/usr/src pull -q
 		else
 			${VCSCMD} ${SRC} -b ${SRCBRANCH} ${CHROOTDIR}/usr/src
 		fi
 	fi
-	if [ -z "${NODOC}" ] && [ -z "${DOC_UPDATE_SKIP}" ]; then
-		if [ -d "${CHROOTDIR}/usr/doc/.git" ]; then
-			git -C ${CHROOTDIR}/usr/doc pull -q
-		else
-			${VCSCMD} ${DOC} -b ${DOCBRANCH} ${CHROOTDIR}/usr/doc
-		fi
-	fi
 	if [ -z "${NOPORTS}" ] && [ -z "${PORTS_UPDATE_SKIP}" ]; then
 		# if [ -d "${CHROOTDIR}/usr/ports/.git" ]; then
 			# git -C ${CHROOTDIR}/usr/ports pull -q
 		# XXX: Workaround for the overlap in the Git conversion timeframe.
 		if [ -d "${CHROOTDIR}/usr/ports/.svn" ]; then
 			${SVNCMD} update ${CHROOTDIR}/usr/ports
 		else
 			#${VCSCMD} ${PORT} -b ${PORTBRANCH} ${CHROOTDIR}/usr/ports
 			# XXX: Workaround for the overlap in the Git
 			# conversion timeframe.
 			${SVNCMD} co ${PORT}/${PORTBRANCH} ${CHROOTDIR}/usr/ports
 		fi
 	fi
 
 	if [ -z "${CHROOTBUILD_SKIP}" ]; then
 		cd ${CHROOTDIR}/usr/src
 		env ${CHROOT_MAKEENV} make ${CHROOT_WMAKEFLAGS} buildworld
 		env ${CHROOT_MAKEENV} make ${CHROOT_IMAKEFLAGS} installworld \
 			DESTDIR=${CHROOTDIR}
 		env ${CHROOT_MAKEENV} make ${CHROOT_DMAKEFLAGS} distribution \
 			DESTDIR=${CHROOTDIR}
 	fi
 
 	return 0
 } # chroot_setup()
 
 # extra_chroot_setup(): Prepare anything additional within the build
 # necessary for the release build.
 extra_chroot_setup() {
 	mkdir -p ${CHROOTDIR}/dev
 	mount -t devfs devfs ${CHROOTDIR}/dev
 	[ -e /etc/resolv.conf -a ! -e ${CHROOTDIR}/etc/resolv.conf ] && \
 		cp /etc/resolv.conf ${CHROOTDIR}/etc/resolv.conf
 	# Run ldconfig(8) in the chroot directory so /var/run/ld-elf*.so.hints
 	# is created.  This is needed by ports-mgmt/pkg.
 	eval chroot ${CHROOTDIR} /etc/rc.d/ldconfig forcerestart
 
 	# If MAKE_CONF and/or SRC_CONF are set and not character devices
 	# (/dev/null), copy them to the chroot.
 	if [ -e ${MAKE_CONF} ] && [ ! -c ${MAKE_CONF} ]; then
 		mkdir -p ${CHROOTDIR}/$(dirname ${MAKE_CONF})
 		cp ${MAKE_CONF} ${CHROOTDIR}/${MAKE_CONF}
 	fi
 	if [ -e ${SRC_CONF} ] && [ ! -c ${SRC_CONF} ]; then
 		mkdir -p ${CHROOTDIR}/$(dirname ${SRC_CONF})
 		cp ${SRC_CONF} ${CHROOTDIR}/${SRC_CONF}
 	fi
 
 	if [ -z "${NOGIT}" ]; then
 		# Install git from ports or packages if the ports tree is
 		# available and VCSCMD is unset.
 		_gitcmd="$(which git)"
 		if [ -d ${CHROOTDIR}/usr/ports -a -z "${_gitcmd}" ]; then
 			# Trick the ports 'run-autotools-fixup' target to do the right
 			# thing.
 			_OSVERSION=$(chroot ${CHROOTDIR} /usr/bin/uname -U)
 			REVISION=$(chroot ${CHROOTDIR} make -C /usr/src/release -V REVISION)
 			BRANCH=$(chroot ${CHROOTDIR} make -C /usr/src/release -V BRANCH)
 			UNAME_r=${REVISION}-${BRANCH}
 			GITUNSETOPTS="CONTRIB CURL CVS GITWEB GUI HTMLDOCS"
 			GITUNSETOPTS="${GITUNSETOPTS} ICONV NLS P4 PERL"
 			GITUNSETOPTS="${GITUNSETOPTS} SEND_EMAIL SUBTREE SVN"
 			GITUNSETOPTS="${GITUNSETOPTS} PCRE PCRE2"
 			PBUILD_FLAGS="OSVERSION=${_OSVERSION} BATCH=yes"
 			PBUILD_FLAGS="${PBUILD_FLAGS} UNAME_r=${UNAME_r}"
 			PBUILD_FLAGS="${PBUILD_FLAGS} OSREL=${REVISION}"
 			PBUILD_FLAGS="${PBUILD_FLAGS} WRKDIRPREFIX=/tmp/ports"
 			PBUILD_FLAGS="${PBUILD_FLAGS} DISTDIR=/tmp/distfiles"
 			eval chroot ${CHROOTDIR} env OPTIONS_UNSET=\"${GITUNSETOPTS}\" \
 				${PBUILD_FLAGS} \
 				make -C /usr/ports/devel/git FORCE_PKG_REGISTER=1 \
 				WRKDIRPREFIX=/tmp/ports \
 				DISTDIR=/tmp/distfiles \
 				install clean distclean
 		else
 			eval chroot ${CHROOTDIR} env ASSUME_ALWAYS_YES=yes \
 				pkg install -y devel/git
 			eval chroot ${CHROOTDIR} env ASSUME_ALWAYS_YES=yes \
 				pkg clean -y
 		fi
 	fi
-	if [ -z "${NODOC}" ] && [ -d ${CHROOTDIR}/usr/ports ]; then
-		# Trick the ports 'run-autotools-fixup' target to do the right
-		# thing.
-		_OSVERSION=$(chroot ${CHROOTDIR} /usr/bin/uname -U)
-		REVISION=$(chroot ${CHROOTDIR} make -C /usr/src/release -V REVISION)
-		BRANCH=$(chroot ${CHROOTDIR} make -C /usr/src/release -V BRANCH)
-		UNAME_r=${REVISION}-${BRANCH}
-		if [ -d ${CHROOTDIR}/usr/doc ] && [ -z "${NODOC}" ]; then
-			PBUILD_FLAGS="OSVERSION=${_OSVERSION} BATCH=yes"
-			PBUILD_FLAGS="${PBUILD_FLAGS} UNAME_r=${UNAME_r}"
-			PBUILD_FLAGS="${PBUILD_FLAGS} OSREL=${REVISION}"
-			PBUILD_FLAGS="${PBUILD_FLAGS} WRKDIRPREFIX=/tmp/ports"
-			PBUILD_FLAGS="${PBUILD_FLAGS} DISTDIR=/tmp/distfiles"
-			chroot ${CHROOTDIR} env ${PBUILD_FLAGS} \
-				OPTIONS_UNSET="AVAHI FOP IGOR" make -C \
-				/usr/ports/textproc/docproj \
-				FORCE_PKG_REGISTER=1 \
-				install clean distclean
-		fi
-	fi
 
 	if [ ! -z "${EMBEDDEDPORTS}" ]; then
 		_OSVERSION=$(chroot ${CHROOTDIR} /usr/bin/uname -U)
 		REVISION=$(chroot ${CHROOTDIR} make -C /usr/src/release -V REVISION)
 		BRANCH=$(chroot ${CHROOTDIR} make -C /usr/src/release -V BRANCH)
 		UNAME_r=${REVISION}-${BRANCH}
 		PBUILD_FLAGS="OSVERSION=${_OSVERSION} BATCH=yes"
 		PBUILD_FLAGS="${PBUILD_FLAGS} UNAME_r=${UNAME_r}"
 		PBUILD_FLAGS="${PBUILD_FLAGS} OSREL=${REVISION}"
 		PBUILD_FLAGS="${PBUILD_FLAGS} WRKDIRPREFIX=/tmp/ports"
 		PBUILD_FLAGS="${PBUILD_FLAGS} DISTDIR=/tmp/distfiles"
 		for _PORT in ${EMBEDDEDPORTS}; do
 			eval chroot ${CHROOTDIR} env ${PBUILD_FLAGS} make -C \
 				/usr/ports/${_PORT} \
 				FORCE_PKG_REGISTER=1 deinstall install clean distclean
 		done
 	fi
 
 	buildenv_setup
 
 	return 0
 } # extra_chroot_setup()
 
 # chroot_build_target(): Build the userland and kernel for the build target.
 chroot_build_target() {
 	load_target_env
 	if [ ! -z "${EMBEDDEDBUILD}" ]; then
 		RELEASE_WMAKEFLAGS="${RELEASE_WMAKEFLAGS} \
 			TARGET=${EMBEDDED_TARGET} \
 			TARGET_ARCH=${EMBEDDED_TARGET_ARCH}"
 		RELEASE_KMAKEFLAGS="${RELEASE_KMAKEFLAGS} \
 			TARGET=${EMBEDDED_TARGET} \
 			TARGET_ARCH=${EMBEDDED_TARGET_ARCH}"
 	fi
 	eval chroot ${CHROOTDIR} make -C /usr/src ${RELEASE_WMAKEFLAGS} buildworld
 	eval chroot ${CHROOTDIR} make -C /usr/src ${RELEASE_KMAKEFLAGS} buildkernel
 
 	return 0
 } # chroot_build_target
 
 # chroot_build_release(): Invoke the 'make release' target.
 chroot_build_release() {
 	load_target_env
 	if [ ! -z "${WITH_VMIMAGES}" ]; then
 		if [ -z "${VMFORMATS}" ]; then
 			VMFORMATS="$(eval chroot ${CHROOTDIR} \
 				make -C /usr/src/release -V VMFORMATS)"
 		fi
 		if [ -z "${VMSIZE}" ]; then
 			VMSIZE="$(eval chroot ${CHROOTDIR} \
 				make -C /usr/src/release -V VMSIZE)"
 		fi
 		RELEASE_RMAKEFLAGS="${RELEASE_RMAKEFLAGS} \
 			VMFORMATS=\"${VMFORMATS}\" VMSIZE=${VMSIZE}"
 	fi
 	eval chroot ${CHROOTDIR} make -C /usr/src/release \
 		${RELEASE_RMAKEFLAGS} release
 	eval chroot ${CHROOTDIR} make -C /usr/src/release \
 		${RELEASE_RMAKEFLAGS} install DESTDIR=/R \
 		WITH_COMPRESSED_IMAGES=${WITH_COMPRESSED_IMAGES} \
 		WITH_COMPRESSED_VMIMAGES=${WITH_COMPRESSED_VMIMAGES}
 
 	return 0
 } # chroot_build_release()
 
 efi_boot_name()
 {
 	case $1 in
 		arm)
 			echo "bootarm.efi"
 			;;
 		arm64)
 			echo "bootaa64.efi"
 			;;
 		amd64)
 			echo "bootx64.efi"
 			;;
 		riscv)
 			echo "bootriscv64.efi"
 			;;
 	esac
 }
 
 # chroot_arm_build_release(): Create arm SD card image.
 chroot_arm_build_release() {
 	load_target_env
 	case ${EMBEDDED_TARGET} in
 		arm|arm64|riscv)
 			if [ -e "${RELENGDIR}/tools/arm.subr" ]; then
 				. "${RELENGDIR}/tools/arm.subr"
 			fi
 			;;
 		*)
 			;;
 	esac
 	[ ! -z "${RELEASECONF}" ] && . "${RELEASECONF}"
 	export MAKE_FLAGS="${MAKE_FLAGS} TARGET=${EMBEDDED_TARGET}"
 	export MAKE_FLAGS="${MAKE_FLAGS} TARGET_ARCH=${EMBEDDED_TARGET_ARCH}"
 	export MAKE_FLAGS="${MAKE_FLAGS} ${CONF_FILES}"
 	eval chroot ${CHROOTDIR} env WITH_UNIFIED_OBJDIR=1 make ${MAKE_FLAGS} -C /usr/src/release obj
 	export WORLDDIR="$(eval chroot ${CHROOTDIR} make ${MAKE_FLAGS} -C /usr/src/release -V WORLDDIR)"
 	export OBJDIR="$(eval chroot ${CHROOTDIR} env WITH_UNIFIED_OBJDIR=1 make ${MAKE_FLAGS} -C /usr/src/release -V .OBJDIR)"
 	export DESTDIR="${OBJDIR}/${KERNEL}"
 	export IMGBASE="${CHROOTDIR}/${OBJDIR}/${BOARDNAME}.img"
 	export OSRELEASE="$(eval chroot ${CHROOTDIR} make ${MAKE_FLAGS} -C /usr/src/release \
 		TARGET=${EMBEDDED_TARGET} TARGET_ARCH=${EMBEDDED_TARGET_ARCH} \
 		-V OSRELEASE)"
 	chroot ${CHROOTDIR} mkdir -p ${DESTDIR}
 	chroot ${CHROOTDIR} truncate -s ${IMAGE_SIZE} ${IMGBASE##${CHROOTDIR}}
 	export mddev=$(chroot ${CHROOTDIR} \
 		mdconfig -f ${IMGBASE##${CHROOTDIR}} ${MD_ARGS})
 	arm_create_disk
 	arm_install_base
 	arm_install_boot
 	arm_install_uboot
 	mdconfig -d -u ${mddev}
 	chroot ${CHROOTDIR} rmdir ${DESTDIR}
 	mv ${IMGBASE} ${CHROOTDIR}/${OBJDIR}/${OSRELEASE}-${BOARDNAME}.img
 	chroot ${CHROOTDIR} mkdir -p /R
 	chroot ${CHROOTDIR} cp -p ${OBJDIR}/${OSRELEASE}-${BOARDNAME}.img \
 		/R/${OSRELEASE}-${BOARDNAME}.img
 	chroot ${CHROOTDIR} xz -T ${XZ_THREADS} /R/${OSRELEASE}-${BOARDNAME}.img
 	cd ${CHROOTDIR}/R && sha512 ${OSRELEASE}* \
 		> CHECKSUM.SHA512
 	cd ${CHROOTDIR}/R && sha256 ${OSRELEASE}* \
 		> CHECKSUM.SHA256
 
 	return 0
 } # chroot_arm_build_release()
 
 # main(): Start here.
 main() {
 	set -e # Everything must succeed
 	env_setup
 	while getopts c: opt; do
 		case ${opt} in
 			c)
 				RELEASECONF="$(realpath ${OPTARG})"
 				;;
 			\?)
 				usage
 				;;
 		esac
 	done
 	shift $(($OPTIND - 1))
 	if [ ! -z "${RELEASECONF}" ]; then
 		if [ -e "${RELEASECONF}" ]; then
 			. ${RELEASECONF}
 		else
 			echo "Nonexistent configuration file: ${RELEASECONF}"
 			echo "Using default build environment."
 		fi
 	fi
 	env_check
 	trap "umount ${CHROOTDIR}/dev" EXIT # Clean up devfs mount on exit
 	chroot_setup
 	extra_chroot_setup
 	chroot_build_target
 	${chroot_build_release_cmd}
 
 	return 0
 } # main()
 
 main "${@}"
diff --git a/release/riscv/GENERICSD.conf b/release/riscv/GENERICSD.conf
index 52734b1dd8e8..d85a8ff7cd93 100644
--- a/release/riscv/GENERICSD.conf
+++ b/release/riscv/GENERICSD.conf
@@ -1,16 +1,15 @@
 #!/bin/sh
 #
 # $FreeBSD$
 #
 
 EMBEDDED_TARGET_ARCH="riscv64"
 EMBEDDED_TARGET="riscv"
 EMBEDDEDBUILD=1
 FAT_SIZE="54m -b 8m"
 FAT_TYPE="16"
 IMAGE_SIZE="3072M"
 KERNEL="GENERIC"
 MD_ARGS="-x 63 -y 255"
-NODOC=1
 PART_SCHEME="GPT"
 export BOARDNAME="GENERICSD"