diff --git a/release/Makefile.azure b/release/Makefile.azure
index a8f59282a09c..36f3f8715de1 100644
--- a/release/Makefile.azure
+++ b/release/Makefile.azure
@@ -1,75 +1,77 @@
 #
 #
 #
 # Makefile for uploading Microsoft Azure disk images.
 #
 
 AZURE_UPLOAD_TGTS=	azure-check-depends \
 			azure-do-upload
 CLEANFILES+=		${AZURE_UPLOAD_TGTS}
 
 .if defined(AZURE_UPLOAD_CONF) && !empty(AZURE_UPLOAD_CONF)
 . for VAR in _STORAGE _ACCOUNT _KEY
 AZURE${VAR}!=	grep -E '^AZURE${VAR}' ${AZURE_UPLOAD_CONF} | awk -F '	' '{print $$2}'
 . endfor
 .endif
 
 .if ${BRANCH} == "STABLE" || ${BRANCH} == "CURRENT" || ${BRANCH} == "PRERELEASE"
 SNAPSHOT_DATE!=		date +-${BUILDDATE}
 .endif
 
 START_DATE!=	date -v-1d -I -u
 EXPIRY_DATE!=	date -v+1m -I -u
 
 azure-upload:		${AZURE_UPLOAD_TGTS}
 
 azure-check-depends:
 .for VAR in _STORAGE _ACCOUNT _KEY
 . if !defined(AZURE${VAR}) || empty(AZURE${VAR})
 	@echo "Variable AZURE${VAR} cannot be empty."
 	@false
 . endif
 .endfor
 .if !exists(/usr/local/bin/az)
 . if !exists(${PORTSDIR}/sysutils/py-azure-cli/Makefile)
 .  if !exists(/usr/local/sbin/pkg-static)
 	env ASSUME_ALWAYS_YES=yes pkg bootstrap -yf
 .  endif
 	env ASSUME_ALWAYS_YES=yes pkg install -y sysutils/py-azure-cli
 . else
-	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/sysutils/py-azure-cli BATCH=1 all install clean
+	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/sysutils/py-azure-cli \
+	    BATCH=1 WRKDIRPREFIX=/tmp/ports DISTDIR=/tmp/distfiles \
+	    all install clean
 . endif
 .endif
 
 .for _FS in ${AZURE_FSLIST}
 AZURE_IMG_${_FS}=	${.OBJDIR}/azure.${_FS}.vhdf
 AZURE_TARGET_${_FS}=	${OSRELEASE}-${_FS}${SNAPSHOT_DATE}
 
 azure-do-upload-${_FS}:
 	/usr/local/bin/az storage blob upload \
 		--account-name ${AZURE_ACCOUNT} --account-key ${AZURE_KEY} \
 		--container-name ${AZURE_STORAGE} --type page \
 		--file ${AZURE_IMG_${_FS}} --name ${AZURE_TARGET_${_FS}}.vhd
 	@echo "The disk access URL with shared access signature is:"
 	@echo
 	@echo -n https://${AZURE_ACCOUNT}.blob.core.windows.net/${AZURE_STORAGE}/${AZURE_TARGET_${_FS}}.vhd?
 	@/usr/local/bin/az storage container generate-sas \
 		--account-name ${AZURE_ACCOUNT} --account-key ${AZURE_KEY} \
 		--name ${AZURE_STORAGE} \
 		--permissions lr \
 		--start ${START_DATE} \
 		--expiry ${EXPIRY_DATE} | cut -d '"' -f 2
 	@echo
 	@echo "Please go to Microsoft Partner Center to create a new offer and publish it:"
 	@echo
 	@echo "https://partner.microsoft.com/dashboard/commercial-marketplace/overview"
 	@echo
 	@echo "After the new offer status is live, you can delete the disk file with:"
 	@echo
 	@echo /usr/local/bin/az storage blob delete \
 		--account-name ${AZURE_ACCOUNT} --account-key ${AZURE_KEY} \
 		--container-name ${AZURE_STORAGE} --name ${AZURE_TARGET_${_FS}}.vhd
 	@echo
 .endfor
 
 azure-do-upload: azure-do-upload-${VMFS}
diff --git a/release/Makefile.ec2 b/release/Makefile.ec2
index c674c967ff57..8f5f6f205779 100644
--- a/release/Makefile.ec2
+++ b/release/Makefile.ec2
@@ -1,90 +1,94 @@
 #
 #
 #
 # Makefile for creating an EC2 AMI from a disk image.
 #
 
 .if ${BRANCH} == "CURRENT" || ${BRANCH} == "STABLE" || ${BRANCH} == "PRERELEASE"
 AMINAMESUFFIX!=	date +-${BUILDDATE}
 .endif
 .if defined(EC2PUBLIC) && !empty(EC2PUBLIC)
 PUBLISH=	--public
 .endif
 .if defined(EC2PUBLICSNAP) && !empty(EC2PUBLICSNAP)
 PUBLICSNAP=	--publicsnap
 .endif
 .if defined(EC2SNSTOPIC) && !empty(EC2SNSTOPIC)
 EC2SNSREL=	${REVISION}-${BRANCH}
 EC2SNSVERS=	${GITBRANCH}@${GITREV}
 .endif
 .if ${TARGET_ARCH} != "amd64"
 EC2ARCH=	--${TARGET_ARCH:S/aarch64/arm64/}
 .endif
 .if !defined(AMIBOOTMETHOD)
 AMIBOOTMETHOD=	UEFI-PREFERRED
 .endif
 .if ${AMIBOOTMETHOD} == "UEFI" && ${TARGET_ARCH} == "amd64"
 BOOTMODEOPT=	--uefi
 .endif
 .if ${AMIBOOTMETHOD} == "UEFI-PREFERRED" && ${TARGET_ARCH} == "amd64"
 BOOTMODEOPT=	--uefi-preferred
 .endif
 
 CLEANFILES+=		ec2ami
 
 .if !exists(/usr/local/bin/bsdec2-image-upload)
 CW_EC2_PORTINSTALL=	cw-ec2-portinstall
 CLEANFILES+=		${CW_EC2_PORTINSTALL}
 .else
 CW_EC2_PORTINSTALL=
 .endif
 
 cw-ec2-portinstall:
-.if exists(${PORTSDIR}/net/bsdec2-image-upload/Makefile)
-	env - UNAME_r=${UNAME_r} PATH=$$PATH make -C ${PORTSDIR}/net/bsdec2-image-upload BATCH=1 all install clean
-.else
-. if !exists(/usr/local/sbin/pkg-static)
-	env ASSUME_ALWAYS_YES=yes pkg bootstrap -y
-. endif
+.if !exists(/usr/local/bin/bsdec2-image-upload)
+. if !exists(${PORTSDIR}/net/bsdec2-image-upload/Makefile)
+.  if !exists(/usr/local/sbin/pkg-static)
+	env ASSUME_ALWAYS_YES=yes pkg bootstrap -yf
+.  endif
 	env ASSUME_ALWAYS_YES=yes pkg install -y net/bsdec2-image-upload
+. else
+	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/net/bsdec2-image-upload \
+	    BATCH=1 WRKDIRPREFIX=/tmp/ports DISTDIR=/tmp/distfiles \
+	    all install clean
+. endif
 .endif
 	@touch ${.TARGET}
 
 .for _FS in ${EC2_FSLIST}
 .for _FL in ${EC2_FLAVOURS:tl}
 .if defined(SSMPREFIX) && !empty(SSMPREFIX)
 SSMOPTS_${_FL}_${_FS}=	--ssm-name ${SSMPREFIX}/${TARGET_ARCH:S/aarch64/arm64/}/${_FL}/${_FS}/${REVISION}/${BRANCH}
 .endif
 EC2AMILIST+=	ec2ami-${_FL}-${_FS}
 ec2ami-${_FL}-${_FS}: cw-ec2-${_FL}-${_FS} ${CW_EC2_PORTINSTALL}
 .if !defined(AWSKEYFILE) || !exists(${AWSKEYFILE})
 	@echo "--------------------------------------------------------------"
 	@echo ">>> AWSKEYFILE must point at AWS keys for EC2 AMI creation"
 	@echo "--------------------------------------------------------------"
 	@false
 .endif
 .if !defined(AWSREGION)
 	@echo "--------------------------------------------------------------"
 	@echo ">>> AWSREGION must be specified EC2 AMI creation"
 	@echo "--------------------------------------------------------------"
 	@false
 .endif
 .if !defined(AWSBUCKET)
 	@echo "--------------------------------------------------------------"
 	@echo ">>> AWSBUCKET must be specified for EC2 AMI creation"
 	@echo "--------------------------------------------------------------"
 	@false
 .endif
 	/usr/local/bin/bsdec2-image-upload ${PUBLISH} ${PUBLICSNAP} \
 	    ${EC2ARCH} ${SSMOPTS_${_FL}_${_FS}} ${BOOTMODEOPT} --sriov --ena \
 	    ${.OBJDIR}/${EC2-${_FL:tu}${_FS:tu}IMAGE} \
 	    "${TYPE} ${REVISION}-${BRANCH}-${TARGET}${AMINAMESUFFIX} ${AMIBOOTMETHOD} ${_FL} ${_FS:tu}" \
 	    "${TYPE}/${TARGET} ${GITBRANCH}@${GITREV}" \
 	    ${AWSREGION} ${AWSBUCKET} ${AWSKEYFILE} \
 	    ${EC2SNSTOPIC} ${EC2SNSREL} ${EC2SNSVERS}
 	@touch ${.TARGET}
 .endfor
 .endfor
 
 ec2ami: ec2ami-base-${VMFS}
 ec2amis: ${EC2AMILIST}
diff --git a/release/Makefile.gce b/release/Makefile.gce
index 2bfdf4edc246..51dc5e3436e2 100644
--- a/release/Makefile.gce
+++ b/release/Makefile.gce
@@ -1,82 +1,86 @@
 #
 #
 #
 # Makefile for uploading Google Compute Engine disk images.
 #
 
 GCE_UPLOAD_TGTS=	gce-check-depends \
 			gce-do-package \
 			gce-do-upload
 # I do not yet have a better way to deal with the "must be run interactively"
 # thing, so this is a fail-safe "do not do anything."
 .if !defined(GCE_LOGIN_SKIP) || empty(GCE_LOGIN_SKIP)
 GCE_UPLOAD_TGTS=	gce-do-login
 .endif
 CLEANFILES+=		${GCE_UPLOAD_TGTS}
 
 GCE_BUCKET?=
 GCE_LICENSE?=
 
 .if !defined(GCE_FAMILY) || empty(GCE_FAMILY)
 GCE_FAMILY=		${TYPE:tl}-${REVISION:S,.,-,}
 .endif
 
 .if ${BRANCH} == "STABLE" || ${BRANCH} == "CURRENT" || ${BRANCH} == "PRERELEASE"
 SNAPSHOT_DATE=		-v${BUILDDATE}
 GCE_FAMILY_SUFX=	-snap
 .endif
 
 gce-upload:		${GCE_UPLOAD_TGTS}
 
 gce-check-depends:
 .for VAR in _BUCKET
 . if !defined(GCE${VAR}) || empty(GCE${VAR})
 	@echo "Variable GCE${VAR} cannot be empty."
 	@false
 . endif
 .endfor
 .if !exists(/usr/local/bin/gcloud)
 . if !exists(${PORTSDIR}/net/google-cloud-sdk/Makefile)
 .  if !exists(/usr/local/sbin/pkg-static)
 	env ASSUME_ALWAYS_YES=yes pkg bootstrap -yf
 .  endif
 	env ASSUME_ALWAYS_YES=yes pkg install -y net/google-cloud-sdk \
 		lang/python
 . else
-	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/net/google-cloud-sdk BATCH=1 all install clean
-	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/lang/python BATCH=1 all install clean
+	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/net/google-cloud-sdk \
+	    BATCH=1 WRKDIRPREFIX=/tmp/ports DISTDIR=/tmp/distfiles \
+	    all install clean
+	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/lang/python \
+	    BATCH=1 WRKDIRPREFIX=/tmp/ports DISTDIR=/tmp/distfiles \
+	    all install clean
 . endif
 .endif
 
 gce-do-login:
 	@echo "This requires human interaction, which is not yet supported."
 	@true
 
 .for _FS in ${GCE_FSLIST}
 GCE_IMG_${_FS}=		${.OBJDIR}/gce.${_FS}.raw
 # Really?  Uppercase characters are not allowed?  Sigh...
 # And don't even get me started on the '.'.
 GCE_TARGET_${_FS}=	${OSRELEASE:S,.raw,,:tl:S,.,-,g}-${_FS}${SNAPSHOT_DATE}
 
 gce-do-package-${_FS}:
 	@# Yes, really...  Sigh.
 	cd ${.OBJDIR} && mv ${GCE_IMG_${_FS}} disk.raw
 	cd ${.OBJDIR} && tar --format=gnutar -zcf \
 		${GCE_TARGET_${_FS}:S,${.OBJDIR}/,,}.tar.gz disk.raw
 	cd ${.OBJDIR} && mv disk.raw ${GCE_IMG_${_FS}}
 	touch ${.OBJDIR}/${.TARGET}
 
 gce-do-upload-${_FS}:
 	@# Fallthrough in case the bucket already exists.
 	/usr/local/bin/gsutil mb gs://${GCE_BUCKET} || true
 	/usr/local/bin/gsutil cp ${.OBJDIR}/${GCE_TARGET_${_FS}}.tar.gz \
 		gs://${GCE_BUCKET}/
 	/usr/local/bin/gcloud compute images create ${GCE_TARGET_${_FS}} \
 		--family=${GCE_FAMILY}${GCE_FAMILY_SUFX} ${GCE_LICENSE} \
 		--guest-os-features=GVNIC,UEFI_COMPATIBLE \
 		--source-uri gs://${GCE_BUCKET}/${GCE_TARGET_${_FS}}.tar.gz
 	touch ${.OBJDIR}/${.TARGET}
 .endfor
 
 gce-do-package: gce-do-package-${VMFS}
 gce-do-upload: gce-do-upload-${VMFS}
diff --git a/release/Makefile.vagrant b/release/Makefile.vagrant
index bcfbf9a5a6f7..d8f3c14e9498 100644
--- a/release/Makefile.vagrant
+++ b/release/Makefile.vagrant
@@ -1,106 +1,108 @@
 #
 #
 # Makefile for producing and uploading Vagrant boxes to Hashicorp Atlas
 #
 # Usage Example:
 #   Create a Vagrant image for VirtualBox:
 #     make vagrant-box WITH_VMIMAGES=y WITH_CLOUDWARE=y \
 #       CLOUDWARE=vagrant-virtualbox VMFORMATS=vmdk
 #
 #   To create a Vagrant image for VMWare and Upload it to Atlas:
 #     VAGRANT_KEY is your Atlas API Token
 #     VAGRANT_USERNAME is your Atlas Username
 #     env VAGRANT_KEY=foo VAGRANT_USERNAME=bar make vagrant-upload \
 #       WITH_VMIMAGES=y WITH_CLOUDWARE=y CLOUDWARE=vagrant-vmware \
 #       VMFORMATS=vmdk
 #     For more info: https://www.vagrantup.com/docs/other/atlas.html
 #
 
 VAGRANT_IMG?=		${.OBJDIR}/vagrant.vmdk
 VAGRANT_UPLOAD_TGTS=	vagrant-check-depends
 CLEANFILES+=		${VAGRANT_UPLOAD_TGTS}
 
 .if defined(VAGRANT_UPLOAD_CONF) && !empty(VAGRANT_UPLOAD_CONF)
 . for VAR in _KEY _USERNAME
 VAGRANT${VAR}!=		grep -E ^VAGRANT${VAR} ${VAGRANT_UPLOAD_CONF} | awk -F'	' '{print $$2}'
 ATLAS${VAR}:=		${VAGRANT${VAR}}
 . endfor
 .endif
 
 .if ${BRANCH} == "STABLE" || ${BRANCH} == "CURRENT" || ${BRANCH} == "PRERELEASE"
 SNAPSHOT_DATE!=		date +-${BUILDDATE}
 .endif
 
 VAGRANT_VERSION!=	date +%Y.%m.%d
 VAGRANT_TARGET:=	${OSRELEASE}${SNAPSHOT_DATE}
 .if !empty(CLOUDWARE)
 . for _PROVIDER in ${CLOUDWARE}
 .  if ${_PROVIDER:tu:MVAGRANT*}
 VAGRANT_PROVIDERS+=	${_PROVIDER:tu:S/VAGRANT-//:tl}
 .  endif
 . endfor
 .endif
 VAGRANT_PROVIDERS?=	vmware virtualbox
 
 
 vagrant-check-depends:
 .for VAR in _KEY _USERNAME _VERSION
 . if !defined(VAGRANT${VAR}) || empty(VAGRANT${VAR})
 	@echo "Variable VAGRANT${VAR} cannot be empty."
 	@false
 . endif
 .endfor
 .if !exists(/usr/local/bin/curl)
 . if !exists(${PORTSDIR}/ftp/curl/Makefile)
 .  if !exists(/usr/local/sbin/pkg-static)
 	env ASSUME_ALWAYS_YES=yes pkg bootstrap -yf
 .  endif
 	env ASSUME_ALWAYS_YES=yes pkg install -y curl
 . else
-	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/ftp/curl BATCH=1 all install clean
+	env UNAME_r=${UNAME_r} make -C ${PORTSDIR}/ftp/curl \
+	    BATCH=1 WRKDIRPREFIX=/tmp/ports DISTDIR=/tmp/distfiles \
+	    all install clean
 . endif
 .endif
 
 .for PROVIDER in ${VAGRANT_PROVIDERS}
 CLEANFILES+=	vagrant-do-package-${PROVIDER} ${VAGRANT_TARGET}.${PROVIDER}.box
 CLEANDIRS+=	${PROVIDER}
 VAGRANT_UPLOAD_TGTS+=	vagrant-do-upload-${PROVIDER}
 
 ${PROVIDER}:
 	@mkdir -p ${PROVIDER}
 
 ${VAGRANT_TARGET}.${PROVIDER}.box: ${PROVIDER} cw-vagrant-${PROVIDER} vagrant-create-${PROVIDER}-metadata
 	@echo "==> PACKAGING: ${VAGRANT_TARGET}.${PROVIDER}.box in `pwd`"
 	@cp vagrant-${PROVIDER}.vmdk ${PROVIDER}/vagrant.vmdk
 . if ${PROVIDER} == "virtualbox"
 	@(cd ${.OBJDIR}/${PROVIDER} && echo '{"provider":"${PROVIDER}"}' > metadata.json)
 	@(cd ${.OBJDIR}/${PROVIDER} && tar -czf ../${VAGRANT_TARGET}.${PROVIDER}.box metadata.json box.ovf vagrant.vmdk)
 . elif ${PROVIDER} == "vmware"
 	@(cd ${.OBJDIR}/${PROVIDER} && echo '{"provider":"${PROVIDER}_desktop"}' > metadata.json)
 	@(cd ${.OBJDIR}/${PROVIDER} && tar -czf ../${VAGRANT_TARGET}.${PROVIDER}.box metadata.json vagrant.vmx vagrant.vmdk)
 . endif
 
 CLEANFILES+=	vagrant-do-upload-${PROVIDER}
 vagrant-do-upload-${PROVIDER}: vagrant-box
 . if ${PROVIDER} == "virtualbox"
 	${.CURDIR}/scripts/atlas-upload.sh -b ${TYPE}-${REVISION}-${BRANCH} -f ${VAGRANT_TARGET}.${PROVIDER}.box -p ${PROVIDER} -k ${VAGRANT_KEY} -u ${VAGRANT_USERNAME} -v ${VAGRANT_VERSION}
 . elif ${PROVIDER} == "vmware"
 	${.CURDIR}/scripts/atlas-upload.sh -b ${TYPE}-${REVISION}-${BRANCH} -f ${VAGRANT_TARGET}.${PROVIDER}.box -p ${PROVIDER}_desktop -k ${VAGRANT_KEY} -u ${VAGRANT_USERNAME} -v ${VAGRANT_VERSION}
 . endif
 	touch ${.OBJDIR}/${.TARGET}
 
 vagrant-box: ${VAGRANT_TARGET}.${PROVIDER}.box
 
 .endfor
 
 vagrant-upload:	${VAGRANT_UPLOAD_TGTS}
 
 vagrant-create-virtualbox-metadata: virtualbox/box.ovf
 
 virtualbox/box.ovf: ${.CURDIR}/scripts/box.ovf
 	cp ${.ALLSRC} virtualbox/
 
 vmware/vagrant.vmx: ${.CURDIR}/scripts/vagrant.vmx
 	cp ${.ALLSRC} vmware/
 
 vagrant-create-vmware-metadata: vmware/vagrant.vmx