Merge pull request 'fix smbios_product_name for t1700 mt and sff' (#452 ) from Ronanand0/lbmk:fix-smbios-prod-name-for-t1700 into master

Reviewed-on: https://codeberg.org/libreboot/lbmk/pulls/452
Update config/coreboot/t1700sff_bmrc_12mb/config/libgfxinit_txtmode
2026-09-20 05:30:25 +02:00 · 2026-09-18 12:23:58 +02:00 · 2026-09-18 11:14:03 +02:00 · 2026-09-18 11:13:11 +02:00 · 2026-09-18 11:12:28 +02:00 · 2026-09-18 11:10:47 +02:00
53 changed files with 1096 additions and 8412 deletions
@@ -21,6 +21,7 @@ CONFIG_OPTION_BACKEND_NONE=y
 # CONFIG_USE_CBFS_FILE_OPTION_BACKEND is not set
 CONFIG_COMPRESS_RAMSTAGE_LZMA=y
 # CONFIG_COMPRESS_RAMSTAGE_LZ4 is not set
+# CONFIG_COMPRESS_RAMSTAGE_ZSTD is not set
 CONFIG_SEPARATE_ROMSTAGE=y
 CONFIG_INCLUDE_CONFIG_FILE=y
 CONFIG_COLLECT_TIMESTAMPS=y
@@ -99,6 +100,7 @@ CONFIG_VENDOR_DELL=y
 # CONFIG_VENDOR_PRODRIVE is not set
 # CONFIG_VENDOR_PROTECTLI is not set
 # CONFIG_VENDOR_PURISM is not set
+# CONFIG_VENDOR_QOTOM is not set
 # CONFIG_VENDOR_RAPTOR_CS is not set
 # CONFIG_VENDOR_RAZER is not set
 # CONFIG_VENDOR_RODA is not set
@@ -127,7 +129,7 @@ CONFIG_CBFS_SIZE=0xEEE000
 CONFIG_CONSOLE_SERIAL=y
 CONFIG_LINEAR_FRAMEBUFFER_MAX_HEIGHT=2160
 CONFIG_LINEAR_FRAMEBUFFER_MAX_WIDTH=3840
-CONFIG_MAX_CPUS=16
+CONFIG_MAX_CPUS=8
 # CONFIG_ONBOARD_VGA_IS_PRIMARY is not set
 CONFIG_POST_DEVICE=y
 CONFIG_POST_IO=y
@@ -149,19 +151,21 @@ CONFIG_INTEL_GMA_VBT_FILE="src/mainboard/$(MAINBOARDDIR)/data.vbt"
 CONFIG_PRERAM_CBMEM_CONSOLE_SIZE=0xc00
 CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="OptiPlex 3040 Micro"
 # CONFIG_CONSOLE_POST is not set
+CONFIG_FSP_FD_PATH="3rdparty/fsp/KabylakeFspBinPkg/Fsp.fd"
+CONFIG_MAX_SOCKET=1
 CONFIG_CMOS_DEFAULT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.default"
 CONFIG_CMOS_LAYOUT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.layout"
-CONFIG_MAX_SOCKET=1
-CONFIG_BOOT_DEVICE_SPI_FLASH_BUS=0
 CONFIG_USE_PM_ACPI_TIMER=y
-# CONFIG_BOARD_DELL_LATITUDE_E7240 is not set
+CONFIG_BOOT_DEVICE_SPI_FLASH_BUS=0
 # CONFIG_BOARD_DELL_E4300 is not set
 # CONFIG_BOARD_DELL_E6400 is not set
+# CONFIG_BOARD_DELL_LATITUDE_E7240 is not set
 CONFIG_BOARD_DELL_OPTIPLEX_3040=y
 # CONFIG_BOARD_DELL_OPTIPLEX_780_MT is not set
 # CONFIG_BOARD_DELL_OPTIPLEX_780_USFF is not set
 # CONFIG_BOARD_DELL_OPTIPLEX_9020_SFF is not set
 # CONFIG_BOARD_DELL_OPTIPLEX_9020_MT is not set
+# CONFIG_BOARD_DELL_OPTIPLEX_3050 is not set
 # CONFIG_BOARD_DELL_LATITUDE_E5420 is not set
 # CONFIG_BOARD_DELL_LATITUDE_E5520 is not set
 # CONFIG_BOARD_DELL_LATITUDE_E6220 is not set
@@ -205,7 +209,8 @@ CONFIG_GFX_GMA_PANEL_1_ON_EDP=y
 CONFIG_DRIVERS_UART_8250IO=y
 CONFIG_PC_CMOS_BASE_PORT_BANK1=0x72
 CONFIG_HEAP_SIZE=0x100000
-CONFIG_EC_GPE_SCI=0x50
+# CONFIG_BOOTMEDIA_SMM_BWP is not set
+# CONFIG_DRIVERS_EFI_FW_INFO is not set
 CONFIG_BOARD_ROMSIZE_KB_16384=y
 # CONFIG_COREBOOT_ROMSIZE_KB_256 is not set
 # CONFIG_COREBOOT_ROMSIZE_KB_512 is not set
@@ -249,6 +254,7 @@ CONFIG_SMM_RESERVED_SIZE=0x200000
 CONFIG_SMM_MODULE_STACK_SIZE=0x800
 CONFIG_ACPI_BERT_SIZE=0x0
 CONFIG_DRIVERS_I2C_DESIGNWARE_CLOCK_MHZ=120
+CONFIG_CPU_PT_ROM_MAP_GB=512
 CONFIG_PRERAM_CBFS_CACHE_SIZE=0x4000
 CONFIG_DOMAIN_RESOURCE_32BIT_LIMIT=0xe0000000
 CONFIG_ACPI_CPU_STRING="CP%02X"
@@ -266,7 +272,6 @@ CONFIG_SOC_INTEL_I2C_DEV_MAX=6
 CONFIG_SOC_INTEL_COMMON_LPSS_UART_CLK_M_VAL=0x30
 CONFIG_SOC_INTEL_COMMON_LPSS_UART_CLK_N_VAL=0xc35
 CONFIG_FSP_HEADER_PATH="3rdparty/fsp/KabylakeFspBinPkg/Include/"
-CONFIG_FSP_FD_PATH="3rdparty/fsp/KabylakeFspBinPkg/Fsp.fd"
 CONFIG_SOC_INTEL_COMMON_DEBUG_CONSENT=0
 CONFIG_INTEL_GMA_BCLV_OFFSET=0xc8254
 CONFIG_INTEL_GMA_BCLV_WIDTH=16
@@ -284,6 +289,8 @@ CONFIG_SOC_INTEL_GFX_FRAMEBUFFER_OFFSET=0x0
 CONFIG_PCIE_LTR_MAX_SNOOP_LATENCY=0x1003
 CONFIG_PCIE_LTR_MAX_NO_SNOOP_LATENCY=0x1003
 CONFIG_SOC_PHYSICAL_ADDRESS_WIDTH=0
+CONFIG_RAMSTAGE_CBFS_CACHE_SIZE=0x4000
+CONFIG_CBFS_CACHE_ALIGN=8
 CONFIG_SOC_INTEL_COMMON_SKYLAKE_BASE=y
 CONFIG_SOC_INTEL_KABYLAKE=y
 CONFIG_SKYLAKE_SOC_PCH_H=y
@@ -293,7 +300,7 @@ CONFIG_SKYLAKE_SOC_PCH_H=y
 CONFIG_FSP_T_LOCATION=0xfffe0000
 CONFIG_SOC_INTEL_COMMON_BLOCK_P2SB=y
 CONFIG_FIXED_SMBUS_IO_BASE=0xefa0
-CONFIG_CBFS_CACHE_ALIGN=8
+CONFIG_UART_BITBANG_TX_DELAY_MS=5
 CONFIG_SOC_INTEL_COMMON=y

 #
@@ -431,7 +438,6 @@ CONFIG_UDELAY_TSC=y
 CONFIG_TSC_MONOTONIC_TIMER=y
 CONFIG_TSC_SYNC_MFENCE=y
 CONFIG_HAVE_SMI_HANDLER=y
-CONFIG_CPU_PT_ROM_MAP_GB=512
 CONFIG_SMM_TSEG=y
 CONFIG_SMM_PCI_RESOURCE_STORE_NUM_SLOTS=8
 CONFIG_AP_STACK_SIZE=0x800
@@ -500,7 +506,6 @@ CONFIG_ARCH_ALL_STAGES_X86_32=y
 CONFIG_RESERVED_PHYSICAL_ADDRESS_BITS_SUPPORT=y
 CONFIG_X86_TOP4G_BOOTMEDIA_MAP=y
 CONFIG_POSTRAM_CBFS_CACHE_IN_BSS=y
-CONFIG_RAMSTAGE_CBFS_CACHE_SIZE=0x4000
 CONFIG_PC80_SYSTEM=y
 CONFIG_HAVE_CMOS_DEFAULT=y
 CONFIG_POSTCAR_STAGE=y
@@ -564,6 +569,8 @@ CONFIG_INTEL_GMA_ADD_VBT=y
 # CONFIG_SOFTWARE_I2C is not set
 CONFIG_I2C_TRANSFER_TIMEOUT_US=500000
 CONFIG_RESOURCE_ALLOCATION_TOP_DOWN=y
+CONFIG_DRAM_SUPPORT_DDR4=y
+CONFIG_DRAM_SUPPORT_DDR3=y
 # end of Devices

 #
@@ -571,8 +578,8 @@ CONFIG_RESOURCE_ALLOCATION_TOP_DOWN=y
 #
 CONFIG_CRB_TPM_BASE_ADDRESS=0xfed40000
 # CONFIG_DRIVERS_EFI_VARIABLE_STORE is not set
-# CONFIG_DRIVERS_EFI_FW_INFO is not set
 # CONFIG_ELOG is not set
+# CONFIG_DRIVERS_HWID_DMI is not set
 CONFIG_CACHE_MRC_SETTINGS=y
 CONFIG_MRC_SETTINGS_PROTECT=y
 # CONFIG_DRIVERS_OPTION_CFR is not set
@@ -610,6 +617,7 @@ CONFIG_USE_FSP_NOTIFY_PHASE_READY_TO_BOOT=y
 CONFIG_USE_FSP_NOTIFY_PHASE_END_OF_FIRMWARE=y
 # CONFIG_DISPLAY_FSP_TIMESTAMPS is not set
 # CONFIG_BUILDING_WITH_DEBUG_FSP is not set
+CONFIG_FSP_VGA_MODE12_BPP=0x0
 CONFIG_INTEL_GMA_ACPI=y
 CONFIG_VBT_CBFS_COMPRESSION_LZMA=y
 # CONFIG_VBT_CBFS_COMPRESSION_LZ4 is not set
@@ -670,7 +678,6 @@ CONFIG_PLATFORM_HAS_DRAM_CLEAR=y
 CONFIG_BOOTMEDIA_LOCK_NONE=y
 # CONFIG_BOOTMEDIA_LOCK_CONTROLLER is not set
 # CONFIG_BOOTMEDIA_LOCK_CHIP is not set
-# CONFIG_BOOTMEDIA_SMM_BWP is not set
 # end of Security

 CONFIG_ACPI_HAVE_PCAT_8259=y
@@ -811,6 +818,9 @@ CONFIG_DECOMPRESS_OFAST=y
 # Boot Logo Configuration
 #
 # CONFIG_BMP_LOGO is not set
+CONFIG_PLATFORM_POST_RENDER_DELAY_SEC=5
+CONFIG_PLATFORM_OFF_MODE_CHARGING_INDICATOR_LOGO_PATH="3rdparty/blobs/mainboard/$(MAINBOARDDIR)/off_mode_charging.bmp"
+# CONFIG_FRAMEBUFFER_SPLASH_TEXT is not set
 # end of Boot Logo Configuration

 CONFIG_WARNINGS_ARE_ERRORS=y
@@ -21,6 +21,7 @@ CONFIG_OPTION_BACKEND_NONE=y
 # CONFIG_USE_CBFS_FILE_OPTION_BACKEND is not set
 CONFIG_COMPRESS_RAMSTAGE_LZMA=y
 # CONFIG_COMPRESS_RAMSTAGE_LZ4 is not set
+# CONFIG_COMPRESS_RAMSTAGE_ZSTD is not set
 CONFIG_SEPARATE_ROMSTAGE=y
 CONFIG_INCLUDE_CONFIG_FILE=y
 CONFIG_COLLECT_TIMESTAMPS=y
@@ -99,6 +100,7 @@ CONFIG_VENDOR_DELL=y
 # CONFIG_VENDOR_PRODRIVE is not set
 # CONFIG_VENDOR_PROTECTLI is not set
 # CONFIG_VENDOR_PURISM is not set
+# CONFIG_VENDOR_QOTOM is not set
 # CONFIG_VENDOR_RAPTOR_CS is not set
 # CONFIG_VENDOR_RAZER is not set
 # CONFIG_VENDOR_RODA is not set
@@ -125,7 +127,7 @@ CONFIG_FMDFILE=""
 CONFIG_MAINBOARD_VENDOR="Dell Inc."
 CONFIG_CBFS_SIZE=0xEEE000
 CONFIG_CONSOLE_SERIAL=y
-CONFIG_MAX_CPUS=16
+CONFIG_MAX_CPUS=8
 # CONFIG_ONBOARD_VGA_IS_PRIMARY is not set
 CONFIG_POST_DEVICE=y
 CONFIG_POST_IO=y
@@ -147,19 +149,21 @@ CONFIG_INTEL_GMA_VBT_FILE="src/mainboard/$(MAINBOARDDIR)/data.vbt"
 CONFIG_PRERAM_CBMEM_CONSOLE_SIZE=0xc00
 CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="OptiPlex 3040 Micro"
 # CONFIG_CONSOLE_POST is not set
+CONFIG_FSP_FD_PATH="3rdparty/fsp/KabylakeFspBinPkg/Fsp.fd"
+CONFIG_MAX_SOCKET=1
 CONFIG_CMOS_DEFAULT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.default"
 CONFIG_CMOS_LAYOUT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.layout"
-CONFIG_MAX_SOCKET=1
-CONFIG_BOOT_DEVICE_SPI_FLASH_BUS=0
 CONFIG_USE_PM_ACPI_TIMER=y
-# CONFIG_BOARD_DELL_LATITUDE_E7240 is not set
+CONFIG_BOOT_DEVICE_SPI_FLASH_BUS=0
 # CONFIG_BOARD_DELL_E4300 is not set
 # CONFIG_BOARD_DELL_E6400 is not set
+# CONFIG_BOARD_DELL_LATITUDE_E7240 is not set
 CONFIG_BOARD_DELL_OPTIPLEX_3040=y
 # CONFIG_BOARD_DELL_OPTIPLEX_780_MT is not set
 # CONFIG_BOARD_DELL_OPTIPLEX_780_USFF is not set
 # CONFIG_BOARD_DELL_OPTIPLEX_9020_SFF is not set
 # CONFIG_BOARD_DELL_OPTIPLEX_9020_MT is not set
+# CONFIG_BOARD_DELL_OPTIPLEX_3050 is not set
 # CONFIG_BOARD_DELL_LATITUDE_E5420 is not set
 # CONFIG_BOARD_DELL_LATITUDE_E5520 is not set
 # CONFIG_BOARD_DELL_LATITUDE_E6220 is not set
@@ -203,7 +207,8 @@ CONFIG_GFX_GMA_PANEL_1_ON_EDP=y
 CONFIG_DRIVERS_UART_8250IO=y
 CONFIG_PC_CMOS_BASE_PORT_BANK1=0x72
 CONFIG_HEAP_SIZE=0x100000
-CONFIG_EC_GPE_SCI=0x50
+# CONFIG_BOOTMEDIA_SMM_BWP is not set
+# CONFIG_DRIVERS_EFI_FW_INFO is not set
 CONFIG_BOARD_ROMSIZE_KB_16384=y
 # CONFIG_COREBOOT_ROMSIZE_KB_256 is not set
 # CONFIG_COREBOOT_ROMSIZE_KB_512 is not set
@@ -247,6 +252,7 @@ CONFIG_SMM_RESERVED_SIZE=0x200000
 CONFIG_SMM_MODULE_STACK_SIZE=0x800
 CONFIG_ACPI_BERT_SIZE=0x0
 CONFIG_DRIVERS_I2C_DESIGNWARE_CLOCK_MHZ=120
+CONFIG_CPU_PT_ROM_MAP_GB=512
 CONFIG_PRERAM_CBFS_CACHE_SIZE=0x4000
 CONFIG_DOMAIN_RESOURCE_32BIT_LIMIT=0xe0000000
 CONFIG_ACPI_CPU_STRING="CP%02X"
@@ -264,7 +270,6 @@ CONFIG_SOC_INTEL_I2C_DEV_MAX=6
 CONFIG_SOC_INTEL_COMMON_LPSS_UART_CLK_M_VAL=0x30
 CONFIG_SOC_INTEL_COMMON_LPSS_UART_CLK_N_VAL=0xc35
 CONFIG_FSP_HEADER_PATH="3rdparty/fsp/KabylakeFspBinPkg/Include/"
-CONFIG_FSP_FD_PATH="3rdparty/fsp/KabylakeFspBinPkg/Fsp.fd"
 CONFIG_SOC_INTEL_COMMON_DEBUG_CONSENT=0
 CONFIG_INTEL_GMA_BCLV_OFFSET=0xc8254
 CONFIG_INTEL_GMA_BCLV_WIDTH=16
@@ -282,6 +287,8 @@ CONFIG_SOC_INTEL_GFX_FRAMEBUFFER_OFFSET=0x0
 CONFIG_PCIE_LTR_MAX_SNOOP_LATENCY=0x1003
 CONFIG_PCIE_LTR_MAX_NO_SNOOP_LATENCY=0x1003
 CONFIG_SOC_PHYSICAL_ADDRESS_WIDTH=0
+CONFIG_RAMSTAGE_CBFS_CACHE_SIZE=0x4000
+CONFIG_CBFS_CACHE_ALIGN=8
 CONFIG_SOC_INTEL_COMMON_SKYLAKE_BASE=y
 CONFIG_SOC_INTEL_KABYLAKE=y
 CONFIG_SKYLAKE_SOC_PCH_H=y
@@ -291,7 +298,7 @@ CONFIG_SKYLAKE_SOC_PCH_H=y
 CONFIG_FSP_T_LOCATION=0xfffe0000
 CONFIG_SOC_INTEL_COMMON_BLOCK_P2SB=y
 CONFIG_FIXED_SMBUS_IO_BASE=0xefa0
-CONFIG_CBFS_CACHE_ALIGN=8
+CONFIG_UART_BITBANG_TX_DELAY_MS=5
 CONFIG_SOC_INTEL_COMMON=y

 #
@@ -429,7 +436,6 @@ CONFIG_UDELAY_TSC=y
 CONFIG_TSC_MONOTONIC_TIMER=y
 CONFIG_TSC_SYNC_MFENCE=y
 CONFIG_HAVE_SMI_HANDLER=y
-CONFIG_CPU_PT_ROM_MAP_GB=512
 CONFIG_SMM_TSEG=y
 CONFIG_SMM_PCI_RESOURCE_STORE_NUM_SLOTS=8
 CONFIG_AP_STACK_SIZE=0x800
@@ -498,7 +504,6 @@ CONFIG_ARCH_ALL_STAGES_X86_32=y
 CONFIG_RESERVED_PHYSICAL_ADDRESS_BITS_SUPPORT=y
 CONFIG_X86_TOP4G_BOOTMEDIA_MAP=y
 CONFIG_POSTRAM_CBFS_CACHE_IN_BSS=y
-CONFIG_RAMSTAGE_CBFS_CACHE_SIZE=0x4000
 CONFIG_PC80_SYSTEM=y
 CONFIG_HAVE_CMOS_DEFAULT=y
 CONFIG_POSTCAR_STAGE=y
@@ -556,6 +561,8 @@ CONFIG_INTEL_GMA_ADD_VBT=y
 # CONFIG_SOFTWARE_I2C is not set
 CONFIG_I2C_TRANSFER_TIMEOUT_US=500000
 CONFIG_RESOURCE_ALLOCATION_TOP_DOWN=y
+CONFIG_DRAM_SUPPORT_DDR4=y
+CONFIG_DRAM_SUPPORT_DDR3=y
 # end of Devices

 #
@@ -563,8 +570,8 @@ CONFIG_RESOURCE_ALLOCATION_TOP_DOWN=y
 #
 CONFIG_CRB_TPM_BASE_ADDRESS=0xfed40000
 # CONFIG_DRIVERS_EFI_VARIABLE_STORE is not set
-# CONFIG_DRIVERS_EFI_FW_INFO is not set
 # CONFIG_ELOG is not set
+# CONFIG_DRIVERS_HWID_DMI is not set
 CONFIG_CACHE_MRC_SETTINGS=y
 CONFIG_MRC_SETTINGS_PROTECT=y
 # CONFIG_DRIVERS_OPTION_CFR is not set
@@ -602,6 +609,7 @@ CONFIG_USE_FSP_NOTIFY_PHASE_READY_TO_BOOT=y
 CONFIG_USE_FSP_NOTIFY_PHASE_END_OF_FIRMWARE=y
 # CONFIG_DISPLAY_FSP_TIMESTAMPS is not set
 # CONFIG_BUILDING_WITH_DEBUG_FSP is not set
+CONFIG_FSP_VGA_MODE12_BPP=0x0
 CONFIG_INTEL_GMA_ACPI=y
 CONFIG_VBT_CBFS_COMPRESSION_LZMA=y
 # CONFIG_VBT_CBFS_COMPRESSION_LZ4 is not set
@@ -663,7 +671,6 @@ CONFIG_PLATFORM_HAS_DRAM_CLEAR=y
 CONFIG_BOOTMEDIA_LOCK_NONE=y
 # CONFIG_BOOTMEDIA_LOCK_CONTROLLER is not set
 # CONFIG_BOOTMEDIA_LOCK_CHIP is not set
-# CONFIG_BOOTMEDIA_SMM_BWP is not set
 # end of Security

 CONFIG_ACPI_HAVE_PCAT_8259=y
@@ -804,6 +811,9 @@ CONFIG_DECOMPRESS_OFAST=y
 # Boot Logo Configuration
 #
 # CONFIG_BMP_LOGO is not set
+CONFIG_PLATFORM_POST_RENDER_DELAY_SEC=5
+CONFIG_PLATFORM_OFF_MODE_CHARGING_INDICATOR_LOGO_PATH="3rdparty/blobs/mainboard/$(MAINBOARDDIR)/off_mode_charging.bmp"
+# CONFIG_FRAMEBUFFER_SPLASH_TEXT is not set
 # end of Boot Logo Configuration

 CONFIG_WARNINGS_ARE_ERRORS=y
@@ -0,0 +1,52 @@
+From 330177da40df12813d6e45c9cdb6285dcbff8b59 Mon Sep 17 00:00:00 2001
+From: Leah Rowe <leah@libreboot.org>
+Date: Mon, 3 Aug 2026 22:22:39 +0100
+Subject: [PATCH 1/1] fix gcc error with __unused
+
+just discard it explicitly.
+
+really now, this is better. it's what i do.
+
+(void)foo;
+
+then gcc won't blow up. fixes building on my debian machine.
+
+Signed-off-by: Leah Rowe <leah@libreboot.org>
+---
+ src/commonlib/region.c | 11 ++++++++---
+ 1 file changed, 8 insertions(+), 3 deletions(-)
+
+diff --git a/src/commonlib/region.c b/src/commonlib/region.c
+index 4a7e285747..b016600da9 100644
+--- a/src/commonlib/region.c
+++ b/src/commonlib/region.c
+@@ -229,18 +229,23 @@ void xlate_region_device_rw_init(struct xlate_region_device *xdev,
+ }
+ 
+ static void *mdev_mmap(const struct region_device *rd, size_t offset,
+-			size_t size __unused)
+			size_t size)
+ {
+ 	const struct mem_region_device *mdev;
+ 
+	(void)size;
+
+ 	mdev = container_of(rd, __typeof__(*mdev), rdev);
+ 
+ 	return &mdev->base[offset];
+ }
+ 
+-static int mdev_munmap(const struct region_device *rd __unused,
+-			void *mapping __unused)
+static int mdev_munmap(const struct region_device *rd,
+			void *mapping)
+ {
+	(void)mapping;
+	(void)rd;
+
+ 	return 0;
+ }
+ 
+-- 
+2.47.3
+
@@ -8,5 +8,4 @@ payload_memtest="y"
 grub_scan_disk="nvme ahci"
 grubtree="xhci_nvme"
 vcfg="hp820g2"
-build_depend="seabios/default grub/xhci_nvme memtest86plus u-boot/amd64coreboot"
-payload_uboot="amd64"
+build_depend="seabios/default grub/xhci_nvme memtest86plus"
@@ -150,7 +150,7 @@ CONFIG_MEMLAYOUT_LD_FILE="src/arch/x86/memlayout.ld"
 # CONFIG_FATAL_ASSERTS is not set
 CONFIG_INTEL_GMA_VBT_FILE="src/mainboard/$(MAINBOARDDIR)/data.vbt"
 CONFIG_PRERAM_CBMEM_CONSOLE_SIZE=0xc00
-CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="OptiPlex 7020/9020 SFF"
+CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="Precision T1700 MT"
 # CONFIG_CONSOLE_POST is not set
 CONFIG_MAX_SOCKET=1
 CONFIG_CMOS_DEFAULT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.default"
@@ -148,7 +148,7 @@ CONFIG_MEMLAYOUT_LD_FILE="src/arch/x86/memlayout.ld"
 # CONFIG_FATAL_ASSERTS is not set
 CONFIG_INTEL_GMA_VBT_FILE="src/mainboard/$(MAINBOARDDIR)/data.vbt"
 CONFIG_PRERAM_CBMEM_CONSOLE_SIZE=0xc00
-CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="OptiPlex 7020/9020 SFF"
+CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="Precision T1700 MT"
 # CONFIG_CONSOLE_POST is not set
 CONFIG_MAX_SOCKET=1
 CONFIG_CMOS_DEFAULT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.default"
@@ -150,7 +150,7 @@ CONFIG_MEMLAYOUT_LD_FILE="src/arch/x86/memlayout.ld"
 # CONFIG_FATAL_ASSERTS is not set
 CONFIG_INTEL_GMA_VBT_FILE="src/mainboard/$(MAINBOARDDIR)/data.vbt"
 CONFIG_PRERAM_CBMEM_CONSOLE_SIZE=0xc00
-CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="OptiPlex 7020/9020 SFF"
+CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="Precision T1700 SFF"
 # CONFIG_CONSOLE_POST is not set
 CONFIG_MAX_SOCKET=1
 CONFIG_CMOS_DEFAULT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.default"
@@ -148,7 +148,7 @@ CONFIG_MEMLAYOUT_LD_FILE="src/arch/x86/memlayout.ld"
 # CONFIG_FATAL_ASSERTS is not set
 CONFIG_INTEL_GMA_VBT_FILE="src/mainboard/$(MAINBOARDDIR)/data.vbt"
 CONFIG_PRERAM_CBMEM_CONSOLE_SIZE=0xc00
-CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="OptiPlex 7020/9020 SFF"
+CONFIG_MAINBOARD_SMBIOS_PRODUCT_NAME="Precision T1700 SFF"
 # CONFIG_CONSOLE_POST is not set
 CONFIG_MAX_SOCKET=1
 CONFIG_CMOS_DEFAULT_FILE="src/mainboard/$(MAINBOARDDIR)/cmos.default"
@@ -24,5 +24,5 @@ payload_uboot=""
 cbfscfg=""

 premake="corebootpremake"
-mkhelper="coreboot_pad_one_byte"
-postmake="mkcorebootbin"
+mkhelper="$if_not_dry_build coreboot_pad_one_byte"
+postmake="$if_not_dry_build mkcorebootbin"
@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 bootstrapargs="--gnulib-srcdir=gnulib/ --no-git"
-autoconfargs="--with-platform=coreboot --disable-werror"
+configureargs="--with-platform=coreboot --disable-werror"
 makeargs="FS_PAYLOAD_MODULES=\"\""
 buildtype="autohell"
-mkhelper="mkpayload_grub"
+mkhelper="$if_not_dry_build mkpayload_grub"
@@ -1,3 +1,4 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

-postmake="copyps1bios"
+mkhelper="$if_not_dry_build copyps1bios"
+postmake="$if_not_dry_build copyps1bios"
@@ -6,7 +6,7 @@ acpica arm-none-eabi-binutils arm-none-eabi-gcc arm-none-eabi-newlib \
 autogen base-devel bison cdrtools cmake curl device-mapper doxygen \
 dtc e2fsprogs flex freetype2 fuse2 gawk gcc-ada gdb gettext git \
 help2man innoextract libftdi libgpiod libjaylink libpciaccess libusb nasm \
-ncurses openssl 7zip ccache less libx86 \
+ncurses openssl 7zip less libx86 \
 pandoc parted pciutils perl perl-libwww python python-setuptools rsync \
 sharutils subversion swig texinfo ttf-dejavu unarchiver unzip wget xz zlib mtools \
 "
@@ -13,6 +13,6 @@ libsdl2-dev libselinux1-dev libssl-dev libtool libusb-1.0-0 libusb-1.0-0-dev \
 libusb-dev lz4 lzma lzma-alone m4 nasm openssl 7zip parted pciutils \
 perl pkg-config python3 python3-distutils-extra python3-pkg-resources python3-pycryptodome \
 python3-pyelftools python3-setuptools python-is-python3 sharutils swig unar \
-unifont unifont-bin unzip uuid-dev wget xfonts-unifont zlib1g-dev ccache \
+unifont unifont-bin unzip uuid-dev wget xfonts-unifont zlib1g-dev \
 g++-mipsel-linux-gnu make genisoimage mtools libx86-1 libx86-dev libstdc++-arm-none-eabi-newlib autoconf-archive \
 "
@@ -10,5 +10,5 @@ innoextract intltool libftdi-devel libselinux-devel libusb1 libusb1-devel \
 nasm ncurses-devel openssl-devel p7zip p7zip-plugins pandoc parted \
 pciutils-devel perl perl-libwww-perl python-unversioned-command python3 \
 python3-setuptools rsync sharutils subversion texinfo unar unifont \
-unifont-fonts unifont-ttf-fonts unzip wget xz zlib-devel ccache swig \
+unifont-fonts unifont-ttf-fonts unzip wget xz zlib-devel swig \
 "
@@ -11,5 +11,5 @@ libselinux-devel libusb1 libusb1-devel nasm ncurses-devel openssl-devel \
 p7zip p7zip-plugins pandoc parted pciutils-devel perl perl-libwww-perl \
 python-unversioned-command python3 python3-setuptools rsync sharutils \
 subversion systemd-devel texinfo unar unifont unifont-fonts \
-unifont-ttf-fonts unzip wget xz zlib-devel ccache swig python3-devel \
+unifont-ttf-fonts unzip wget xz zlib-devel swig python3-devel \
 "
@@ -11,6 +11,6 @@ libselinux-devel libusb1 libusb1-devel nasm ncurses-devel openssl-devel openssl-
 p7zip p7zip-plugins pandoc parted pciutils-devel perl perl-libwww-perl \
 python-unversioned-command python3 python3-setuptools rsync sharutils \
 subversion systemd-devel texinfo unar unifont unifont-fonts uuid-devel \
-unifont-ttf-fonts unzip wget xz zlib-devel ccache swig python3-devel \
+unifont-ttf-fonts unzip wget xz zlib-devel swig python3-devel \
 libuuid-devel gnutls-devel \
 "
@@ -11,6 +11,6 @@ libselinux-devel libusb1 libusb1-devel nasm ncurses-devel openssl-devel openssl-
 p7zip p7zip-plugins pandoc parted pciutils-devel perl perl-libwww-perl \
 python-unversioned-command python3 python3-setuptools rsync sharutils \
 subversion systemd-devel texinfo unifont unifont-fonts uuid-devel \
-unifont-ttf-fonts unzip wget xz zlib-devel ccache swig python3-devel \
+unifont-ttf-fonts unzip wget xz zlib-devel swig python3-devel \
 libuuid-devel gnutls-devel tar unar libtool \
 "
@@ -11,6 +11,6 @@ libselinux-devel libusb1 libusb1-devel nasm ncurses-devel openssl-devel openssl-
 p7zip p7zip-plugins pandoc parted pciutils-devel perl perl-libwww-perl \
 python-unversioned-command python3 python3-setuptools rsync sharutils \
 subversion systemd-devel texinfo unifont unifont-fonts uuid-devel \
-unifont-ttf-fonts unzip wget xz zlib-devel ccache swig python3-devel \
+unifont-ttf-fonts unzip wget xz zlib-devel swig python3-devel \
 libuuid-devel gnutls-devel tar unar libtool \
 "
@@ -11,7 +11,7 @@ dev-libs/libgpiod app-arch/sharutils dev-libs/libtomcrypt sys-devel/autogen \
 media-libs/freetype sys-fs/e2fsprogs sys-fs/lvm2 dev-libs/libusb \
 sys-block/parted sys-fs/mtools app-arch/lz4 dev-libs/leancrypto sys-fs/fuse \
 sys-apps/dtc net-libs/gnutls net-misc/curl dev-build/cmake dev-vcs/git \
-dev-util/ccache dev-embedded/libftdi app-arch/innoextract sys-devel/gcc \
+dev-embedded/libftdi app-arch/innoextract sys-devel/gcc \
 sys-apps/pciutils app-crypt/efitools gnustep-base/gnustep-make gnustep-base/gnustep-base \
 app-arch/unar app-arch/7zip dev-lang/python dev-python/setuptools dev-python/ply \
 sys-libs/libselinux dev-python/pyelftools dev-python/pycparser dev-python/cffi \
@@ -12,6 +12,6 @@ libpython3-dev libsdl2-dev libselinux1-dev libssl-dev libtool libusb-1.0-0 \
 libusb-1.0-0-dev lz4 lzma lzma-alone m4 nasm openssl p7zip p7zip-full parted \
 pciutils perl pkg-config python3 python3-pkg-resources python3-pycryptodome \
 python3-pyelftools python3-setuptools python-is-python3 sharutils swig \
-fonts-unifont unar unifont unzip uuid-dev wget zlib1g-dev ccache \
+fonts-unifont unar unifont unzip uuid-dev wget zlib1g-dev \
 g++-mipsel-linux-gnu make genisoimage mtools \
 "
@@ -8,5 +8,5 @@ freetype freetype-devel fuse gawk gcc-ada gdb gettext gettext-devel git \
 gnutls-devel help2man innoextract libftdi1 libpciaccess libusb libuuid-devel \
 nasm ncurses ncurses-devel openssl openssl-devel 7zip parted pciutils perl \
 perl-LWP python python3 python3-devel python3-setuptools rsync sharutils \
-subversion swig texinfo unar unzip wget xz zlib ccache \
+subversion swig texinfo unar unzip wget xz zlib \
 "
@@ -2,4 +2,3 @@

 makeargs="-f lbmkbofhmakefile"
 cleanargs="-f lbmkbofhmakefile"
-mkhelper="copyps1bios"
@@ -1,138 +0,0 @@
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-# Copyright (c) 2025 Leah Rowe <leah@libreboot.org>
-
-# Import MrChromebox project into xbmk
-
-# NOTE: variable naming scheme:
-#  mr_ for variables/functions dealing with MrChromebox
-#  mx_ for variables/functions pertaining to Libreboot setup
-#	because i am a non-binary blob
-
-spdx="# SPDX-License-Identifier: GPL-3.0-or-later"
-
-# temporary work variables
-mr_tmpdir="" # dir to clone tmp repos in
-
-# NOTE: upstream for our purposes: https://review.coreboot.org/coreboot
-mr_cbrepo="https://github.com/mrchromebox/coreboot"
-mr_cbbranch="MrChromebox-2503" # branch in mrchromebox
-mr_cbrev="ecd9fa6a177e00132ec214252a2b9cebbb01e25f" # relative to base
-mr_cbrevbase="38f5f7c48024d9fca4b6bbd88914423c34da709c" # 25.03 upstream base
-mr_cbtree="chromebook" # tree name in xbmk
-
-# NOTE: upstream for our purposes: https://github.com/tianocore/edk2.git
-mr_edk2repo="https://github.com/mrchromebox/edk2"
-mr_edk2branch="uefipayload_2502" # branch in mrchromebox
-mr_edk2rev="feaf6b976b7cc72a18ed364f273751c943a9e7d0" # relative to base
-mr_edk2revbase="fbe0805b2091393406952e84724188f8c1941837" # 2025.02 upstream
-mr_edk2tree="chromebook" # tree name in xbmk
-
-# mxlibreboot was here
-prep_mr_import()
-{
-	if [ -f "$xbmkpwd/CHANGELOG" ]; then
-
-		err "Project import disabled on releases" "prep_mr_import" "$@"
-	fi
-
-	mr_tmpdir="`mktemp -d || err "can't make mrtmpdir"`" || \
-	    err "can't make mrtmpdir" "prep_mr_coreboot" "$@"
-
-	x_ remkdir "$mr_tmpdir"
-
-	x_ prep_mx_edk2conf
-
-	x_ prep_mr_projects
-
-	x_ rm -Rf "$mr_tmpdir"
-}
-
-# create config/git/edk2/pkg.cfg
-prep_mx_edk2conf()
-{
-	x_ remkdir "config/git/edk2"
-
-	x_ prep_mr_file "config/git/edk2/pkg.cfg" \
-	    "$spdx" \
-	    "" \
-	    "rev=\"HEAD\"" \
-	    "url=\"https://codeberg.org/libreboot/edk2\"" \
-	    "bkup_url=\"https://git.disroot.org/libreboot/edk2\""
-}
-
-# prep config/PROJECT/TREE/ for various projects
-prep_mr_projects()
-{
-	x_ prep_mr "coreboot" "$mr_cbrepo" "$mr_cbbranch" "$mr_cbrev" \
-	    "$mr_cbrevbase" "$mr_cbtree"
-
-	x_ prep_mr "edk2" "$mr_edk2repo" "$mr_edk2branch" "$mr_edk2rev" \
-	    "$mr_edk2revbase" "$mr_edk2tree"
-}
-
-# create config/PROJECT/TREE/target.cfg
-# and config/PROJECT/TREE/patches/
-prep_mr()
-{
-	mr_projectname="$1"
-	mr_repo="$2"
-	mr_branch="$3"
-	mr_rev="$4"
-	mr_revbase="$5"
-	mr_tree="$6"
-
-	x_ prep_mr_clone "$@"
-	x_ prep_mr_patch "$@"
-
-	x_ prep_mr_file "config/$1/$6/target.cfg" \
-	    "$spdx" \
-	    "" \
-	    "tree=\"$6\"" \
-	    "rev=\"$5\""
-}
-
-prep_mr_clone()
-{
-	mr_tmpclone="$mr_tmpdir/$1"
-
-	x_ git clone "$2" "$mr_tmpclone"
-
-	x_ git -C "$mr_tmpclone" checkout "$3"
-	# we don't reset, because we format-patch between revbase..rev
-}
-
-prep_mr_patch()
-{
-	mr_tmpclone="$mr_tmpdir/$1"
-	mx_patchdir="config/$1/$6/patches"
-
-	x_ remkdir "$mx_patchdir"
-
-	if [ "$4" != "$5" ]; then
-
-		x_ git -C "$mr_tmpclone" format-patch $5..$4
-		x_ mv "$mr_tmpclone"/*.patch "$mx_patchdir"
-	fi
-
-	# if no patches were created, rmdir will succeed
-	rmdir "$mx_patchdir" 1>/dev/null 2>/dev/null || :
-}
-
-prep_mr_file()
-{
-	mr_filename="$1"
-	shift 1
-
-	x_ rm -f "$mr_filename"
-
-	while [ $# -gt 0 ]; do
-
-		printf "%s\n" "$1" >> "$mr_filename" || \
-		    err "Can't write '$1' to '$mr_filename'" prep_mr_file "$@"
-
-		shift 1
-	done
-
-	printf "Created '%s'\n" "$mr_filename"
-}
@@ -1,77 +1,51 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

-# Copyright (c) 2020-2021,2023-2025 Leah Rowe <leah@libreboot.org>
+# Copyright (c) 2020-2021,2023-2026 Leah Rowe <leah@libreboot.org>
 # Copyright (c) 2022 Caleb La Grange <thonkpeasant@protonmail.com>

-url=""
-bkup_url=""
-
-depend=""
-loc=""
-subcurl=""
-subcurl_bkup=""
-subgit=""
-subgit_bkup=""
-subhash=""
+eval "`newvar url bkup_url depend loc subcurl subcurl_bkup subgit subgit_bkup \
+    subhash`"

 tmpgit="$xbtmp/gitclone"
 tmpgitcache="$xbtmp/tmpgit"

-fetch_targets()
+multi_tree_fetch()
 {
-	if [ -d "src/$project/$tree" ]; then
-
-		return 0
-	fi
+	[ -d "src/$project/$tree" ] && return 0

 	git_prep "$url" "$bkup_url" "$xbmkpwd/$configdir/$tree/patches" \
 	    "src/$project/$tree" "submod"
 }

-fetch_project()
+single_tree_fetch()
 {
 	xgcctree=""

 	. "config/git/$project/pkg.cfg" || \
 	    err "Can't read config 'config/git/$project/pkg.cfg'" \
-	    "fetch_project" "@"
-
-	if [ -z "$url" ] || \
-	    [ -z "$bkup_url" ]; then
+	    "single_tree_fetch" "@"

+	if [ -z "$url" ] || [ -z "$bkup_url" ]; then
 		err "url/bkup_url not both set 'config/git/$project/pkg.cfg'" \
-		    "fetch_project" "$@"
+		    "single_tree_fetch" "$@"
 	fi

-	if [ -n "$xgcctree" ]; then
-
-		x_ ./mk -f coreboot "$xgcctree"
-	fi
-
-	if [ -n "$depend" ]; then
+	[ -n "$xgcctree" ] && \
+		x_ "$mk" -f coreboot "$xgcctree"

+	[ -n "$depend" ] && \
 		for d in $depend ; do
-
-			x_ ./mk -f $d
+			x_ "$mk" -f $d
 		done
-	fi

-	clone_project
+	$if_single_tree \
+		clone_project; :
 }

 clone_project()
 {
-	if ! singletree "$project"; then
-
-		return 0
-	fi
-
 	loc="src/$project"
-
-	if [ -d "$loc" ]; then
-
-		return 0
-	fi
+	[ -d "$loc" ] && return 0

 	remkdir "${tmpgit%/*}"
 	git_prep "$url" "$bkup_url" "$xbmkpwd/config/$project/patches" "$loc"
@@ -84,23 +58,16 @@ git_prep()
 	_patchdir="$3"
 	_loc="$4" # $1 and $2 are gitrepo and gitrepo_backup

-	if [ -z "$rev" ]; then
-
+	[ -z "$rev" ] && \
 		err "$project/$tree: rev not set" "git_prep" "$@"
-	fi

 	xbget git "$1" "$2" "$tmpgit" "$rev" "$_patchdir"
-
-	if singletree "$project" || \
-	    [ $# -gt 4 ]; then
-
+	if singletree "$project" || [ $# -gt 4 ]; then
 		dx_ fetch_submodule "$mdir/module.list"
 	fi

-	if [ "$_loc" != "${_loc%/*}" ]; then
-
-		x_ xbmkdir "${_loc%/*}"
-	fi
+	[ "$_loc" != "${_loc%/*}" ] && \
+		x_ mkdir -p "${_loc%/*}"

 	x_ mv "$tmpgit" "$_loc"
 }
@@ -108,73 +75,28 @@ git_prep()
 fetch_submodule()
 {
 	mcfgdir="$mdir/${1##*/}"
+	eval "`newvar st subcurl subcurl_bkup subgit subgit_bkup subhash`"

-	st=""
-	subcurl=""
-	subcurl_bkup=""
-	subgit=""
-	subgit_bkup=""
-	subhash=""
-
-	if e "$mcfgdir/module.cfg" f missing; then
-		return 0
-	fi
-
+	e "$mcfgdir/module.cfg" f missing && return 0
 	. "$mcfgdir/module.cfg" || \
 	    err "Can't read '$mcfgdir/module.cfg'" "fetch_submodules" "$@"

-	if [ -n "$subgit" ] || \
-	    [ -n "$subgit_bkup" ]; then
-
-		st="$st git"
-	fi
-
-	if [ -n "$subcurl" ] || \
-	    [ -n "$subcurl_bkup" ]; then
-
-		st="$st curl"
-	fi
-
-	st="${st# }"
-
-	if [ "$st" = "git curl" ]; then
-
+	[ -n "$subgit" ] && [ -n "$subgit_bkup" ] && \
+		st="git"
+	[ -n "$subcurl" ] && [ -n "$subcurl_bkup" ] && \
+		st="curl$st"
+	[ "$st" = "curlgit" ] && \
 		err "$mdir: git+curl defined" "fetch_submodule" "$@"
-	fi
-
-	if [ -z "$st" ]; then
-
+	[ -z "$st" ] && \
 		return 0
-	fi
-
-	if [ "$st" = "curl" ]; then
-
-		if [ -z "$subcurl" ] || [ -z "$subcurl_bkup" ]; then
-			err "subcurl/subcurl_bkup not both set" \
-			    "fetch_submodule" "$@"
-		fi
-
-	elif [ -z "$subgit" ] || \
-	    [ -z "$subgit_bkup" ]; then
-
-		err "subgit/subgit_bkup not both set" "fetch_submodule" "$@"
-
-	elif [ -z "$subhash" ]; then
-
+	[ -z "$subhash" ] && \
 		err "subhash not set" "fetch_submodule" "$@"
-	fi
-
-	if [ "$st" = "git" ]; then

+	[ "$st" = "git" ] && \
 		x_ rm -Rf "$tmpgit/$1"

-		xbget "$st" "$subgit" "$subgit_bkup" "$tmpgit/$1" \
-		    "$subhash" "$mdir/${1##*/}/patches"
-	else
-
-		xbget "$st" "$subcurl" "$subcurl_bkup" "$tmpgit/$1" \
-		    "$subhash" "$mdir/${1##*/}/patches"
-	fi
+	eval "xbget \"\$st\" \"\$sub$st\" \"\$sub${st}_bkup\" \"\$tmpgit/\$1\" \
+	    \"\$subhash\" \"\$mdir/\${1##*/}/patches\""
 }

 # TODO: in the following functions, argument numbers are used
@@ -183,151 +105,85 @@ fetch_submodule()

 xbget()
 {
-	if [ "$1" != "curl" ] && \
-	    [ "$1" != "copy" ] && \
-	    [ "$1" != "git" ]; then
-
+	[ "$1" != "curl" ] && [ "$1" != "copy" ] && [ "$1" != "git" ] && \
 		err "Bad dlop (arg 1)" "xbget" "$@"
-	fi

 	for url in "$2" "$3"; do
-
-		if [ -z "$url" ]; then
-
+		[ -z "$url" ] && \
 			err "empty URL given in" "xbget" "$@"
-
-		elif ! try_fetch "$url" "$@"; then
-
+		try_fetch_$1 "$url" "$@" || \
 			continue
-		fi
-
-		case "$1" in
-
-		git)
-
-			if [ ! -d "$4" ]; then
-				continue
-			fi
-			;;
-
-		*)
-
-			if [ ! -f "$4" ]; then
-				continue
-			fi
-			;;
-		esac
-
-		return 0 # successful download/copy
+		[ -e "$4" ] && return 0; : # successful download/copy
 	done

 	err "failed to download file/repository" "xbget" "$@"; :
 }

-try_fetch()
-{
-	if [ "$2" = "git" ]; then
-
-		if ! try_fetch_git "$@"; then
-
-			return 1
-		fi
-	else
-
-		if ! try_fetch_file "$@"; then
-
-			return 1
-		fi
-	fi
-}
-
 try_fetch_git()
 {
 	# 1st argument $1 is the current git remote being tried,
 	# let's say it was https://foo.example.com/repo, then cached
 	# directories becomes cache/mirror/foo.example.com/repo

-	if [ "$XBMK_CACHE_MIRROR" = "y" ]; then
-
+	cached="clone"
+	[ "$XBMK_CACHE_MIRROR" = "y" ] && \
 		cached="mirror"
-	else
-
-		cached="clone"
-	fi
-
 	cached="$cached/${1#*://}"
 	cached="$XBMK_CACHE/$cached"

-	x_ xbmkdir "${5%/*}" "${cached%/*}"
-
-	if ! try_$2 "$cached" "$@"; then
+	x_ mkdir -p "${5%/*}" "${cached%/*}"

+	try_$2 "$cached" "$@" || \
 		return 1
-	elif [ ! -d "$cached" ]; then
-
+	[ ! -d "$cached" ] && \
 		return 1
-	fi

 	if [ ! -d "$5" ]; then
-
 		tmpclone "$cached" "$5" "$6" "$7" || \
 		    err "Can't clone final repo" "try_fetch" "$@"; :
 	fi

-	if [ ! -d "$5" ]; then
-
-		return 1
-	fi
+	[ ! -d "$5" ] && \
+		return 1; :
 }

-try_fetch_file()
+try_fetch_copy()
+{
+	try_fetch_curl "$@" || return 1; :
+}
+
+try_fetch_curl()
 {
 	cached="file/$6"
 	cached="$XBMK_CACHE/$cached"

-	x_ xbmkdir "${5%/*}" "${cached%/*}"
+	x_ mkdir -p "${5%/*}" "${cached%/*}"

 	if bad_checksum "$6" "$cached" 2>/dev/null; then
-
 		x_ rm -f "$cached"
 	fi

-	if [ ! -f "$cached" ]; then
-
-		if ! try_$2 "$cached" "$@"; then
-
+	[ -f "$cached" ] || \
+		try_$2 "$cached" "$@" || \
 			return 1
-		fi
-	fi

-	if [ -f "$5" ]; then
-		if bad_checksum "$6" "$5" 2>/dev/null; then
-			x_ cp "$cached" "$5"
-		fi
-	fi
+	[ -f "$5" ] && bad_checksum "$6" "$5" 2>/dev/null && \
+		x_ cp "$cached" "$5"

 	if [ ! -f "$cached" ]; then
-
 		return 1
-
 	elif bad_checksum "$6" "$cached"; then
-
 		x_ rm -f "$cached"
 		return 1
 	fi

-	if [ "$cached" != "$5" ]; then
-
+	[ "$cached" != "$5" ] && \
 		x_ cp "$cached" "$5"
-	fi

 	if bad_checksum "$6" "$5"; then
-
 		x_ rm -f "$5"
 		return 1
-
 	elif [ ! -f "$5" ]; then
-
 		return 1
 	fi
 }
@@ -336,22 +192,8 @@ try_curl()
 {
 	ua="Mozilla/5.0 (Windows NT 10.0; rv:91.0) Gecko/20100101 Firefox/91.0"

-	case "$2" in
-
-	https://www.supermicro.com/*)
-
-		ua="curl/8.6.0"
-		;;
-
-	*)
-		:
-		;;
-
-	esac
-
 	( x_ curl --location --retry 3 -A "$ua" "$2" -o "$1" ) \
-	    || ( x_ wget --tries 3 -U "$ua" "$2" -O "$1" ) \
-	    || return 1; :
+	    || ( x_ wget --tries 3 -U "$ua" "$2" -O "$1" ) || return 1; :
 }

 try_copy()
@@ -367,62 +209,43 @@ try_git()
 	x_ rm -Rf "$tmpgitcache"

 	if [ ! -d "$gitdest" ]; then
-
 		if [ "$XBMK_CACHE_MIRROR" = "y" ]; then
-
 			( x_ git clone --mirror "$2" "$tmpgitcache" ) || \
 			    return 1
 		else
-
 			( x_ git clone "$2" "$tmpgitcache" ) || return 1
 		fi

-		x_ xbmkdir "${gitdest%/*}"
+		x_ mkdir -p "${gitdest%/*}"
 		x_ mv "$tmpgitcache" "$gitdest"
 	fi

-	if git -C "$gitdest" show "$7" 1>/dev/null 2>/dev/null && \
-	    [ "$forcepull" != "y" ]; then
-
-		# don't try to pull the latest changes if the given target
-		# revision already exists locally. this saves a lot of time
-		# during release builds, and reduces the chance that we will
-		# interact with grub.git or gnulib.git overall during runtime
-
-		return 0
-	fi
+	git -C "$gitdest" show "$7" 1>/dev/null 2>/dev/null && \
+	    [ "$forcepull" != "y" ] && \
+		return 0 # don't pull changes if target rev exists locally

 	if [ "$XBMK_CACHE_MIRROR" = "y" ]; then
-
 		( x_ git -C "$gitdest" fetch ) || :; :
 		( x_ git -C "$gitdest" update-server-info ) || :; :
 	else
-
 		( x_ git -C "$gitdest" pull --all ) || :; :
 	fi
 }

 bad_checksum()
 {
-	if e "$2" f missing; then
-
+	e "$2" f missing && \
 		return 0
-	fi
-
-	build_sbase

+	eval "$build_sbase"
 	csum="$(x_ "$sha512sum" "$2" | awk '{print $1}')" || \
 	    err "!sha512 '$2' $1" bad_checksum "$@"

-	if [ "$csum" = "$1" ]; then
-
+	[ "$csum" = "$1" ] && \
 		return 1
-	else

-		x_ rm -f "$2"
-
-		printf "BAD SHA512 %s, '%s'; need %s\n" "$csum" "$2" "$1" 1>&2
-	fi
+	x_ rm -f "$2"
+	printf "BAD SHA512 %s, '%s'; need %s\n" "$csum" "$2" "$1" 1>&2
 }

 tmpclone()
@@ -430,9 +253,8 @@ tmpclone()
 	( x_ git clone "$1" "$2" ) || return 1
 	( x_ git -C "$2" reset --hard "$3" ) || return 1

-	if [ ! -d "$4" ]; then
+	[ ! -d "$4" ] && \
 		return 0
-	fi

 	tmpclone_patchlist="`mktemp || err "Can't create tmp patch list"`" || \
 	    err "Can't create tmp patch list" "tmpclone" "$@"
@@ -443,7 +265,7 @@ tmpclone()

 	while read -r tmpclone_patch; do

-		( x_ git -C "$2" am --keep-cr "$tmpclone_patch" ) || \
+		( x_ git -C "$2" am -3 --keep-cr "$tmpclone_patch" ) || \
 		    err "Can't apply '$tmpclone_patch'" "tmpclone" "$@"; :

 	done < "$tmpclone_patchlist" || \
@@ -2,52 +2,23 @@

 # Copyright (c) 2022 Caleb La Grange <thonkpeasant@protonmail.com>
 # Copyright (c) 2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
-# Copyright (c) 2020-2025 Leah Rowe <leah@libreboot.org>
+# Copyright (c) 2020-2026 Leah Rowe <leah@libreboot.org>
 # Copyright (c) 2025 Alper Nebi Yasak <alpernebiyasak@gmail.com>

-export LANG=C.UTF-8
-export LC_COLLATE=C.UTF-8
-export LC_ALL=C.UTF-8
-
 projectname="libreboot"
 projectsite="https://libreboot.org/"

-# TODO: consider just erroring here instead of hardcoding a default
-if [ -z "${PATH+x}" ]; then
-	export PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
-fi
-
-sha512sum="util/sbase/sha512sum"
-
-aur_notice=""
-basetmp=""
-board=""
-checkvarschk=""
-checkvarsxbmk=""
-configdir=""
-datadir=""
-is_child=""
-python=""
-pyver=""
-reinstall=""
-relname=""
-version=""
-versiondate=""
-xbmklock=""
-xbmkpath=""
-xbmkpwd=""
-xbmkpwd=""
-xbtmp=""
+eval "`newvar aur_notice basetmp board checkvarschk checkvarsxbmk configdir \
+    datadir is_child python pyver reinstall relname version versiondate \
+    xbmklock xbmkpath xbtmp sha512sum`"

 xbmk_init()
 {
-	xbmkpwd="`pwd || err "Cannot generate PWD"`" || err "!" xbmk_init "$@"
 	xbmklock="$xbmkpwd/lock"
 	basetmp="$xbmkpwd/xbmkwd"
 	sha512sum="$xbmkpwd/util/sbase/sha512sum"

 	if [ $# -gt 0 ] && [ "$1" = "dependencies" ]; then
-
 		x_ xbmkpkg "$@"
 		exit 0
 	fi
@@ -55,193 +26,115 @@ xbmk_init()
 	id -u 1>/dev/null 2>/dev/null || \
 	    err "suid check failed" "xbmk_init" "$@"

-	if [ "$(id -u)" = "0" ]; then
-
+	[ "$(id -u)" = "0" ] && \
 		err "this command as root is not permitted" "xbmk_init" "$@"
-	fi

 	export PWD="$xbmkpwd"
-	x_ xbmkdir "$basetmp"
+	x_ mkdir -p "$basetmp" "cache"

-	if [ ! -e "cache" ]; then
-
-		x_ xbmkdir "cache"
-	fi
-
-	for init_cmd in get_version set_env set_threads git_init child_exec; do
-
-		if ! xbmk_$init_cmd "$@"; then
-
-			break
-		fi
-	done
+	eval "$(printf "get_ver set_env set_threads git_init xchild\n" | awk \
+	    '{ for (i=1; i<=NF; i++) $i = $i " \"$@\" || return 0;"; print }')"
 }

 xbmkpkg()
 {
 	xchk xbmkpkg "$@"

-	if [ $# -gt 2 ]; then
-
+	[ $# -gt 2 ] && \
 		reinstall="$3"
-	fi

 	. "config/dependencies/$2" || \
 	    err "Can't read 'config/dependencies/$2'" "xbmkpkg" "$@"

-	if [ -z "$pkg_add" ] || \
-	    [ -z "$pkglist" ]; then
-
+	if [ -z "$pkg_add" ] || [ -z "$pkglist" ]; then
 		err "pkg_add/pkglist not both set" "xbmkpkg" "$@"
 	fi

 	if [ "$2" == "gentoo" ]; then

-		if [ -z "$pkg_use" ] || \
-		    [ -z "$pkg_use_file" ]; then
-
+		if [ -z "$pkg_use" ] || [ -z "$pkg_use_file" ]; then
 			err "pkg_use/pkg_use_file not both set" "xbmkpkg" "$@"
 		fi

 		printf "Updating package use...\n"
 		printf "Writing into %s" "$pkg_use_file..."

-		if [ ! -d "`dirname $pkg_use_file`" ]; then
-
-			x_ mkdir -p "`dirname $pkg_use_file`"
-		fi
+		x_ mkdir -p "`dirname $pkg_use_file`"

 		printf "%s\n" "$pkg_use" >> "$pkg_use_file"
 	fi

 	x_ $pkg_add $pkglist

-	if [ -n "$aur_notice" ]; then
-
-		printf "You need AUR packages: %s\n" "$aur_notice" 1>&2
-	fi
+	[ -n "$aur_notice" ] && \
+		printf "You need AUR packages: %s\n" "$aur_notice" 1>&2; :
 }

-xbmk_get_version()
+get_ver()
 {
-	if [ -f ".version" ]; then
-
+	[ ! -f ".version" ] || \
 		read -r version < ".version" || \
-		    err "can't read version file" "xbmk_get_version" "$@"
-	fi
-
-	if [ -f ".versiondate" ]; then
-
+		    err "can't read version file" "get_ver" "$@"
+	[ ! -f ".versiondate" ] || \
 		read -r versiondate < ".versiondate" || \
-		    err "can't read versiondate" xbmk_get_version "$@"
-	fi
+		    err "can't read versiondate" get_ver "$@"

-	if [ -f ".version" ] && \
-	    [ -z "$version" ]; then
-
-		err "version not set" "xbmk_get_version" "$@"
-	fi
-
-	if [ -f ".versiondate" ] && \
-	    [ -z "$versiondate" ]; then
-
-		err "versiondate not set" "xbmk_get_version" "$@"
-	fi
-
-	if [ ! -e ".git" ] && \
-	    [ ! -f ".version" ]; then
+	[ -f ".version" ] && [ -z "$version" ] && \
+		err "version not set" "get_ver" "$@"
+	[ -f ".versiondate" ] && [ -z "$versiondate" ] && \
+		err "versiondate not set" "get_ver" "$@"

+	[ ! -e ".git" ] && [ ! -f ".version" ] && \
 		version="unknown"
-	fi
-
-	if [ ! -e ".git" ] && \
-	    [ ! -f ".versiondate" ]; then
-
+	[ ! -e ".git" ] && [ ! -f ".versiondate" ] && \
 		versiondate="1716415872"
-	fi

 	xbmk_sanitize_version

-	if [ -n "$version" ]; then
-
-		relname="$projectname-$version"
-	fi
+	[ -n "$version" ] && \
+		relname="$projectname-$version"; :
 }

 # a parent instance will cause this function to return 0.
 # a child instance will return 1, skipping further initialisation
 # after this function is called.
-xbmk_set_env()
+set_env()
 {
 	is_child="n"
-
 	xbmkpath="$PATH"

 	# unify all temporary files/directories in a single TMPDIR
-
-	if [ -n "${TMPDIR+x}" ] && \
-	    [ "${TMPDIR%_*}" != "$basetmp/xbmk" ]; then
-
+	[ -n "${TMPDIR+x}" ] && [ "${TMPDIR%_*}" != "$basetmp/xbmk" ] && \
 		unset TMPDIR
-	fi
-
 	if [ -n "${TMPDIR+x}" ]; then
-
 		export TMPDIR="$TMPDIR"
 		xbtmp="$TMPDIR"
 	fi
-
-	if [ -n "${TMPDIR+x}" ]; then
-
+	[ -n "${TMPDIR+x}" ] && \
 		is_child="y"
-	fi

 	if [ "$is_child" = "y" ]; then
-
-		# child instance of xbmk, so we stop init after this point
-		# and execute the given user command upon return:
-
 		xbmk_child_set_env
-
-		return 1
-	else
-
-		# parent instance of xbmk, so we continue initialising.
-		# a parent instance of xbmk never processes its own
-		# command directly; instead, it calls a child instance
-		# of xbmk, and exits with the corresponding return status.
-
-		xbmk_parent_set_env
-
-		return 0
+		return 1 # child instance. discontinue initialisation.
 	fi
+	xbmk_parent_set_env
 }

 xbmk_child_set_env()
 {
 	xbmk_child_set_tmp

-	if [ -z "${XBMK_CACHE+x}" ]; then
-
-		err "XBMK_CACHE unset on child" "xbmk_set_env" "$@"
-	fi
-
-	if [ -z "${XBMK_THREADS+x}" ]; then
-
-		xbmk_set_threads; :
-	fi
-
-	if [ -z "${XBMK_CACHE_MIRROR+x}" ]; then
-
-		xbmk_set_mirror
-	fi
+	[ -z "${XBMK_CACHE+x}" ] && \
+		err "XBMK_CACHE unset on child" "set_env" "$@"
+	[ -z "${XBMK_THREADS+x}" ] && \
+		set_threads
+	[ -z "${XBMK_CACHE_MIRROR+x}" ] && \
+		xbmk_set_mirror; :
 }

 xbmk_child_set_tmp()
 {
-	badtmp=""
-	locktmp=""
-	xbtmpchk=""
+	eval "`newvar badtmp locktmp xbtmpchk`"

 	xbtmpchk="`findpath "$TMPDIR" || err "!findpath $TMPDIR"`" || \
 	    err "!findpath '$TMPDIR'" "xbmk_child_set_tmp" "$@"
@@ -250,15 +143,12 @@ xbmk_child_set_tmp()
 	    err "can't read '$xbmklock'" "xbmk_child_set_tmp" "$@"

 	if [ "$locktmp" != "$xbtmpchk" ]; then
-
 		badtmp="TMPDIR '$xbtmpchk' changed; was '$locktmp'"
-
 		printf "bad TMPDIR init, '%s': %s\n" "$TMPDIR" "$badtmp" 1>&2
 		err "'$xbmklock' present with bad tmpdir. is a build running?"
 	fi

 	xbtmp="$xbtmpchk"
-
 	export TMPDIR="$xbtmpchk"
 }

@@ -267,7 +157,7 @@ xbmk_parent_set_env()
 	xbmk_parent_check_tmp

 	printf "%s\n" "$xbtmp" > "$xbmklock" || \
-	    err "cannot create '$xbmklock'" xbmk_set_env "$@"; :
+	    err "cannot create '$xbmklock'" set_env "$@"; :

 	# not really critical for security, but it's a barrier
 	# against the user to make them think twice before deleting it
@@ -275,15 +165,11 @@ xbmk_parent_set_env()

 	x_ chmod -w "$xbmklock"

-	xbmk_parent_set_export
+	forx 'xbmk_%s' parent_set_export set_version

-	xbmk_set_version
+	remkdir "$xbtmp" "$xbtmp/xbmkpath"

-	remkdir "$xbtmp" "$xbtmp/gnupath" "$xbtmp/xbmkpath"
-
-	xbmk_set_pyver
-
-	xbmk_set_mirror
+	forx 'xbmk_set_%s' pyver mirror
 }

 xbmk_parent_check_tmp()
@@ -297,29 +183,20 @@ xbmk_parent_check_tmp()
 	x_ touch "$xbmklist"

 	for xtmpdir in "$basetmp"/xbmk_*; do
-
-		if [ -e "$xtmpdir" ]; then
-
+		[ ! -e "$xtmpdir" ] || \
 			printf "%s\n" "$xtmpdir" >> "$xbmklist" || \
 			    err "can't write '$xtmpdir' to '$xbmklist'" \
 			    "xbmk_parent_check_tmp" "$@"; :
-		fi
 	done

 	# set up a unified temporary directory, for common deletion later:
-
 	export TMPDIR="`x_ mktemp -d -t xbmk_XXXXXXXX`" || \
 	    err "can't export TMPDIR" "xbmk_parent_check_tmp" "$@"
-
 	xbtmp="$TMPDIR"

 	while read -r xtmpdir; do
-
-		if [ "$xtmpdir" = "$xbtmp" ]; then
-
-			err "pre-existing '$xbtmp'" "xbmk_parent_check_tmp" "$@"
-		fi
-
+		[ "$xtmpdir" = "$xbtmp" ] && \
+			err "pre-existing $xbtmp" xbmk_parent_check_tmp "$@"; :
 	done < "$xbmklist" || \
 	    err "Can't read xbmklist: '$xbmklist'" "xbmk_parent_check_tmp" "$@"

@@ -330,133 +207,84 @@ xbmk_parent_set_export()
 {
 	export XBMK_CACHE="$xbmkpwd/cache"

-	if [ -e "$XBMK_CACHE" ] && \
-	    [ ! -d "$XBMK_CACHE" ]; then
-
+	[ -e "$XBMK_CACHE" ] && [ ! -d "$XBMK_CACHE" ] && \
 		err "cachedir '$XBMK_CACHE' is a file" \
 		    "xbmk_parent_set_export" "$@"
-	fi

-	export PATH="$xbtmp/xbmkpath:$xbtmp/gnupath:$PATH"
+	export PATH="$xbtmp/xbmkpath:$PATH"
 	xbmkpath="$PATH"

 	# if "y": a coreboot target won't be built if target.cfg says release=n
 	# (this is used to exclude certain build targets from releases)

-	if [ -z "${XBMK_RELEASE+x}" ]; then
-
+	[ -z "${XBMK_RELEASE+x}" ] && \
 		export XBMK_RELEASE="n"
-	fi
-
-	if [ "$XBMK_RELEASE" = "Y" ]; then
-
+	[ "$XBMK_RELEASE" = "Y" ] && \
 		export XBMK_RELEASE="y"
-	fi
-
-	if [ "$XBMK_RELEASE" != "y" ]; then
-
-		export XBMK_RELEASE="n"
-	fi
+	[ "$XBMK_RELEASE" != "y" ] && \
+		export XBMK_RELEASE="n"; :
 }

-xbmk_set_threads()
+set_threads()
 {
-	if [ -z "${XBMK_THREADS+x}" ]; then
-
+	[ -z "${XBMK_THREADS+x}" ] && \
 		export XBMK_THREADS=1
-	fi
-
-	if ! expr "X$XBMK_THREADS" : "X-\{0,1\}[0123456789][0123456789]*$" \
-	    1>/dev/null 2>/dev/null; then
-
-		export XBMK_THREADS=1
-	fi
+	expr "X$XBMK_THREADS" : "X-\{0,1\}[0123456789][0123456789]*$" \
+	    1>/dev/null 2>/dev/null || \
+		export XBMK_THREADS=1; :
 }

 xbmk_set_version()
 {
 	version_="$version"
-
-	if [ -e ".git" ]; then
-
+	[ ! -e ".git" ] || \
 		version="$(git describe --tags HEAD 2>&1)" || \
 		    version="git-$(git rev-parse HEAD 2>&1)" || \
 		    version="$version_"
-	fi

 	versiondate_="$versiondate"
-
-	if [ -e ".git" ]; then
-
+	[ ! -e ".git" ] || \
 		versiondate="$(git show --no-patch --no-notes \
 		    --pretty='%ct' HEAD)" || versiondate="$versiondate_"
-	fi
-
-	if [ -z "$version" ] || \
-	    [ -z "$versiondate" ]; then
-
-		err "version and/or versiondate unset" "xbmk_set_version" "$@"
-	fi

 	update_xbmkver "."

 	relname="$projectname-$version"
-
 	export LOCALVERSION="-$projectname-${version%%-*}"
 }

 xbmk_set_pyver()
 {
-	pyver="2"
 	python="python3"
+	pyver="2"
 	pyv="import sys; print(sys.version_info[:])"

-	if ! pybin python3 1>/dev/null; then
-
+	pybin python3 1>/dev/null || \
 		python="python"
-	fi
-
-	if [ "$python" = "python3" ]; then
-
+	[ "$python" = "python3" ] && \
 		pyver="3"
-	fi
-
-	if ! pybin "$python" 1>/dev/null; then
-
+	pybin "$python" 1>/dev/null || \
 		pyver=""
-	fi
-
-	if [ -n "$pyver" ]; then

+	[ -z "$pyver" ] || \
 		"`x_ pybin "$python"`" -c "$pyv" 1>/dev/null \
 		    2>/dev/null || \
 		    err "Can't detect Python version." "xbmk_set_pyver" "$@"
-	fi
-
 	if [ -n "$pyver" ]; then
-
 		pyver="$("$(pybin "$python")" -c "$pyv" | awk '{print $1}')"
-
 		pyver="${pyver#(}"
-
 		pyver="${pyver%,}"
 	fi
-
-	if [ "${pyver%%.*}" != "3" ]; then
-
+	[ "${pyver%%.*}" != "3" ] && \
 		err "Bad python version (must by 3.x)" "xbmk_set_pyver" "$@"
-	fi

 	# set up python in PATH (environmental variable):
-
 	(
 		x_ cd "$xbtmp/xbmkpath"
-
 		x_ ln -s "`x_ pybin "$python"`" python || \
 		    err "can't make symlink" "xbmk_set_pyver" "$@"

-	) || \
-	    err "Can't link Python in $xbtmp/xbmkpath" "xbmk_set_pyver" "$@"; :
+	) || err "Can't link Python in $xbtmp/xbmkpath" xbmk_set_pyver "$@"; :
 }

 # Use direct path, to prevent a hang if Python is using a virtual environment,
@@ -467,60 +295,37 @@ pybin()
 	py="import sys; quit(1) if sys.prefix == sys.base_prefix else quit(0)"

 	venv=1
-
-	if ! command -v "$1" 1>/dev/null 2>/dev/null; then
-
+	command -v "$1" 1>/dev/null 2>/dev/null || \
 		venv=0
-	fi
-
-	if [ $venv -gt 0 ]; then
-
-		if ! "$1" -c "$py" 1>/dev/null 2>/dev/null; then

+	[ $venv -lt 1 ] || \
+		"$1" -c "$py" 1>/dev/null 2>/dev/null || \
 			venv=0
-		fi
-	fi
-
-	# ideally, don't rely on PATH or hardcoded paths if python venv.
-	# use the *real*, direct executable linked to by the venv symlink:
-
-	if [ $venv -gt 0 ] && \
-	    [ -L "`command -v "$1" 2>/dev/null`" ]; then

+	# try the direct path from PATH first. the binary specified by venv
+	# can be called directly, which then removes use of the venv
+	if [ $venv -gt 0 ] && [ -L "`command -v "$1" 2>/dev/null`" ]; then
 		pypath="$(findpath \
 		    "$(command -v "$1" 2>/dev/null)" 2>/dev/null || :)"
-
-		if [ -e "$pypath" ] && \
-		    [ ! -d "$pypath" ] && \
+		if [ -e "$pypath" ] && [ ! -d "$pypath" ] && \
 		    [ -x "$pypath" ]; then
-
 			printf "%s\n" "$pypath"
-
 			return 0
 		fi
 	fi

 	# if python venv: fall back to common PATH directories for checking:
-
 	[ $venv -gt 0 ] && for pypath in "/usr/local/bin" "/usr/bin"; do
-
-		if [ -e "$pypath/$1" ] && \
-		     ! -d "$pypath/$1" ] && \
+		if [ -e "$pypath/$1" ] && [ ! -d "$pypath/$1" ] && \
 		    [ -x "$pypath/$1" ]; then
-
 			printf "%s/%s\n" "$pypath" "$1"
-
 			return 0
 		fi
-
 	done && return 1

-	# Defer to normal command -v if not a venv:
-
-	if ! command -v "$1" 2>/dev/null; then
-
-		return 1
-	fi
+	# Defer to normal command -v if not a venv
+	command -v "$1" 2>/dev/null || \
+		return 1; :
 }

 xbmk_set_mirror()
@@ -533,79 +338,51 @@ xbmk_set_mirror()
 	# it's slower, and uses more disk space, and some upstreams might not
 	# appreciate it, so it should only be used for development or archival

-	if [ -z "${XBMK_CACHE_MIRROR+x}" ]; then
-
+	[ -z "${XBMK_CACHE_MIRROR+x}" ] && \
 		export XBMK_CACHE_MIRROR="n"
-	fi
-
-	if [ "$XBMK_CACHE_MIRROR" != "y" ]; then
-
-		export XBMK_CACHE_MIRROR="n"
-	fi
+	[ "$XBMK_CACHE_MIRROR" != "y" ] && \
+		export XBMK_CACHE_MIRROR="n"; :
 }

-xbmk_git_init()
+git_init()
 {
-	# the git identity check is only needed for: ./mk -b coreboot [args]
-
+	# the git identity check is only needed for: "$mk" -b coreboot [args]
 	[ "${2-}" = "-b" ] && [ "${3-}" = "coreboot" ] && \
 	    for gitarg in "user.name" "user.email"; do
-
-		gitcmd="git config --includes $gitarg"
-
-		if ! $gitcmd 1>/dev/null 2>/dev/null; then
-
+		git config --includes $gitarg 1>/dev/null 2>/dev/null || \
 			err "Run this first: $gitcmd \"your ${gitcmd##*.}\"" \
-			    "xbmk_git_init" "$@"
-		fi
+			    "git_init" "$@"; :
 	done

-	if [ -L ".git" ]; then
-
-		err "'$xbmkpwd/.git' is a symlink" "xbmk_git_init" "$@"
-	fi
-
-	if [ -e ".git" ]; then
-
+	[ -L ".git" ] && \
+		err "'$xbmkpwd/.git' is a symlink" "git_init" "$@"
+	[ -e ".git" ] && \
 		return 0
-	fi

-	# GNU-specific extensions of date are used.
-	# TODO: that is a bug. fix it!
-
-	x_ date --version | grep "GNU coreutils" 1>/dev/null 2>/dev/null || \
-	    err "Non-GNU date implementation" "xbmk_git_init" "$@"
-
-	cdate="`x_ date -Rud @$versiondate || err "can't get date"`" || \
-	    err "can't get date" "xbmk_git_init" "$@"
+	(
+	export GIT_COMMITTER_DATE="@$versiondate +0000"
+	export GIT_AUTHOR_DATE="@$versiondate +0000"

 	x_ git init 1>/dev/null 2>/dev/null
-
 	x_ git add -A . 1>/dev/null 2>/dev/null
-
 	x_ git -c user.name="xbmk" -c user.email="xbmk@example.com" \
-	    commit -m "$projectname $version" --date "$cdate" \
+	    commit -m "$projectname $version" \
 	    --author="xbmk <xbmk@example.com>" 1>/dev/null 2>/dev/null
-
 	x_ git -c user.name="xbmk" -c user.email="xbmk@example.com" \
 	    tag -a "$version" -m "$projectname $version" \
 	    1>/dev/null 2>/dev/null; :
+
+	) || err "Can't initialise workdir" git_init "$@"; :
 }

-xbmk_child_exec()
+xchild()
 {
 	xbmk_rval=0

-	( x_ ./mk "$@" ) \
-	    || xbmk_rval=1
+	( x_ "$mk" "$@" ) || xbmk_rval=1

-	( x_ rm -Rf "$xbtmp" ) \
-	    || xbmk_rval=1
-
-	( x_ rm -f "$xbmklock" ) \
-	    || xbmk_rval=1
+	( x_ rm -Rf "$xbtmp" ) || xbmk_rval=1
+	( x_ rm -f "$xbmklock" ) || xbmk_rval=1

 	exit $xbmk_rval
 }
-
-xbmk_init "$@"
@@ -2,200 +2,117 @@

 # Copyright (c) 2022 Caleb La Grange <thonkpeasant@protonmail.com>
 # Copyright (c) 2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
-# Copyright (c) 2023-2025 Leah Rowe <leah@libreboot.org>
+# Copyright (c) 2023-2026 Leah Rowe <leah@libreboot.org>

 cbcfgsdir="config/coreboot"
 tmpromdel="$XBMK_CACHE/DO_NOT_FLASH"
 nvmutil="util/nvmutil/nvmutil"
 ifdtool="elf/coreboot/default/ifdtool"

-checkvars="CONFIG_GBE_BIN_PATH"
+checkvars="CONFIG_GBE_BIN_PATH ${checkvarsxbmk-} ${checkvarschk-}"

-if [ -n "$checkvarsxbmk" ]; then
-
-	checkvars="$checkvars $checkvarsxbmk"
-fi
-
-if [ -n "$checkvarschk" ]; then
-
-	checkvars="$checkvars $checkvarschk"
-fi
-
-archive=""
-board=""
-boarddir=""
-IFD_platform=""
-ifdprefix=""
-new_mac=""
-tmpromdir=""
-tree=""
-xchanged=""
-
-eval "`setvars "" $checkvars`"
+eval "`newvar archive board boarddir IFD_platform ifdprefix \
+    new_mac nuke tmpromdir tree xchanged $checkvars`"

 inject()
 {
 	remkdir "$tmpromdel"

-	if [ $# -lt 1 ]; then
-
-		err "No options specified" "inject" "$@"
-	fi
+	[ $# -lt 1 ] && err "No options specified" "inject" "$@"

 	archive="$1";
 	new_mac="xx:xx:xx:xx:xx:xx"

-	nuke=""
-	xchanged=""
-
 	[ $# -gt 1 ] && case "$2" in
-
 	nuke)
-
 		new_mac=""
 		nuke="nuke"
 		;;
-
 	setmac)
-
 		if [ $# -gt 2 ]; then
-
 			new_mac="$3" && \
-
-			if [ -z "$new_mac" ]; then
-
-				err "Empty MAC address specified" "inject" "$@"
-			fi
+			[ -z "$new_mac" ] && \
+				err "Empty MAC address" "inject" "$@"; :
 		fi
 		;;
-
 	*)
-
 		err "Unrecognised inject mode: '$2'" "inject" "$@" ;;
 	esac

-	if [ "$new_mac" = "keep" ]; then
-
+	[ "$new_mac" = "keep" ] && \
 		new_mac=""
-	fi

 	check_release
-
 	if check_target; then
-
-		if ! patch_release; then
-
-			return 0
-		fi
+		patch_release || return 0
 	fi
-
-	if [ "$xchanged" = "y" ]; then
-
+	[ "$xchanged" = "y" ] && \
 		remktar
-	fi
-
-	if [ "$xchanged" = "y" ]; then
-
-		printf "\n'%s' was modified\n" "$archive" 1>&2
-
-	else
-
-		printf "\n'%s' was NOT modified\n" "$archive" 1>&2
-	fi

 	x_ rm -Rf "$tmpromdel"
 }

 check_release()
 {
-	if [ -L "$archive" ]; then
-
+	[ -L "$archive" ] && \
 		err "'$archive' is a symlink" "check_release" "$@"
-	fi
-
-	if e "$archive" f missing; then
-
+	e "$archive" f missing && \
 		err "'$archive' missing" "check_release" "$@"
-	fi

 	archivename="`basename "$archive" || err "Can't get '$archive' name"`" \
 	    || err "can't get '$archive' name" "check_release" "$@"

-	if [ -z "$archivename" ]; then
-
+	[ -z "$archivename" ] && \
 		err "Can't determine archive name" "check_release" "$@"
-	fi

 	case "$archivename" in
-
 	*_src.tar.xz)
-
 		err "'$archive' is a src archive!" "check_release" "$@"
 		;;
-
 	grub_*|seagrub_*|custom_*|seauboot_*|seabios_withgrub_*)
-
 		err "'$archive' is a ROM image" "check_release" "$@"
 		;;
-
 	*.tar.xz) _stripped_prefix="${archivename#*_}"
-
 		board="${_stripped_prefix%.tar.xz}"
 		;;
-
 	*)
-
 		err "'$archive': cannot detect board" "check_release" "$@"
 		;;
-
 	esac; :
 }

 check_target()
 {
-	if [ "$board" != "${board#serprog_}" ]; then
-
-		return 1
-	fi
+	[ "$board" = "${board#serprog_}" ] || return 1

 	boarddir="$cbcfgsdir/$board"

 	. "$boarddir/target.cfg" || \
 	    err "Can't read '$boarddir/target.cfg'" "check_target" "$@"

-	if [ -z "$tree" ]; then
-
+	[ -z "$tree" ] && \
 		err "tree unset in '$boarddir/target.cfg'" "check_target" "$@"
-	fi

-	x_ ./mk -d coreboot "$tree"
+	x_ "$mk" -d coreboot "$tree"

 	ifdtool="elf/coreboot/$tree/ifdtool"
-
-	if [ -n "$IFD_platform" ]; then
-
-		ifdprefix="-p $IFD_platform"
-	fi
+	[ -n "$IFD_platform" ] && \
+		ifdprefix="-p $IFD_platform"; :
 }

 patch_release()
 {
-	if [ "$nuke" != "nuke" ]; then
-
-		x_ ./mk download "$board"
-	fi
+	[ "$nuke" != "nuke" ] && \
+		x_ "$mk" download "$board"

 	has_hashes="n"
 	tmpromdir="$tmpromdel/bin/$board"

 	remkdir "${tmpromdir%"/bin/$board"}"
-
 	x_ tar -xf "$archive" -C "${tmpromdir%"/bin/$board"}"

 	for _hashes in "vendorhashes" "blobhashes"; do
-
 		if e "$tmpromdir/$_hashes" f; then
-
 			has_hashes="y"
 			hashfile="$_hashes"

@@ -203,41 +120,29 @@ patch_release()
 		fi
 	done

-	if ! readkconfig; then
+	readkconfig || return 1

-		return 1
-
-	elif [ -n "$new_mac" ] && \
-	    [ -n "$CONFIG_GBE_BIN_PATH" ]; then
-
-		modify_mac
-	fi
+	[ -n "$new_mac" ] && [ -n "$CONFIG_GBE_BIN_PATH" ] && \
+		modify_mac; :
 }

 readkconfig()
 {
 	x_ rm -f "$xbtmp/cbcfg"
-
 	fx_ scankconfig x_ find "$boarddir/config" -type f

-	if e "$xbtmp/cbcfg" f missing; then
-
+	e "$xbtmp/cbcfg" f missing && \
 		return 1
-	fi

 	. "$xbtmp/cbcfg" || \
 	    err "Can't read '$xbtmp/cbcfg'" "readkconfig" "$@"

-	if ! setvfile "$@"; then
-
-		return 1
-	fi
+	setvfile "$@" || return 1; :
 }

 scankconfig()
 {
 	for cbc in $checkvars; do
-
 		grep "$cbc" "$1" 2>/dev/null 1>>"$xbtmp/cbcfg" || :
 	done
 }
@@ -246,45 +151,35 @@ modify_mac()
 {
 	x_ cp "${CONFIG_GBE_BIN_PATH##*../}" "$xbtmp/gbe"

-	if [ -n "$new_mac" ] && \
-	    [ "$new_mac" != "restore" ]; then
-
-		x_ make -C util/nvmutil clean
-
-		x_ make -C util/nvmutil
-
+	if [ -n "$new_mac" ] && [ "$new_mac" != "restore" ]; then
+		forx 'x_ make -C util/nvmutil %s' clean nvmutil
 		x_ "$nvmutil" "$xbtmp/gbe" setmac "$new_mac"
 	fi

-	fx_ newmac x_ find "$tmpromdir" -maxdepth 1 -type f -name "*.rom"
+	fx_ newmac x_ find "$tmpromdir" -mindepth 1 -maxdepth 1 \
+	    -type f -name "*.rom"

 	printf "\nThe following GbE NVM data will be written:\n"
-
 	x_ "$nvmutil" "$xbtmp/gbe" dump | grep -v "bytes read from file" || :
 }

 newmac()
 {
-	if e "$1" f; then
-
-		xchanged="y"
-
-		x_ "$ifdtool" $ifdprefix -i GbE:"$xbtmp/gbe" "$1" -O "$1"
-	fi
+	e "$1" f || return 0
+	xchanged="y"
+	x_ "$ifdtool" $ifdprefix -i GbE:"$xbtmp/gbe" "$1" -O "$1"
 }

 remktar()
 {
 	(
-		x_ cd "${tmpromdir%"/bin/$board"}"
+	x_ cd "${tmpromdir%"/bin/$board"}"

-		printf "Re-building tar archive (please wait)\n"
-
-		mkrom_tarball "bin/$board" 1>/dev/null
+	printf "Re-building tar archive (please wait)\n"
+	mkrom_tarball "bin/$board" 1>/dev/null

 	) || err "Cannot re-generate '$archive'" "remktar" "$@"

 	mv "${tmpromdir%"/bin/$board"}/bin/${relname}_${board}.tar.xz" \
-	    "$archive" || \
-	    err "'$archive' -> Can't overwrite" "remktar" "$@"; :
+	    "$archive" || err "'$archive' -> Can't overwrite" "remktar" "$@"; :
 }
@@ -4,11 +4,7 @@
 # Modifications in this version are Copyright 2021,2023-2025 Leah Rowe.
 # Original copyright detailed in repo: https://review.coreboot.org/coreboot/

-MRC_board=""
-MRC_hash=""
-MRC_url=""
-MRC_url_bkup=""
-SHELLBALL=""
+eval "`newvar MRC_board MRC_hash MRC_url MRC_url_bkup SHELLBALL`"

 extract_refcode()
 {
@@ -18,43 +14,33 @@ extract_refcode()
 	# and refcode is extracted from an image using the old scheme. we use
 	# cbfstool from coreboot 4.11_branch, the tree used by ASUS KGPE-D16:

-	if [ -z "$cbfstoolref" ]; then
-
+	[ -z "$cbfstoolref" ] && \
 		err "cbfstoolref not set" "extract_refcode" "$@"
-	fi

-	x_ xbmkdir "${_pre_dest%/*}"
+	x_ mkdir -p "${_pre_dest%/*}"

 	x_ "$cbfstoolref" "$appdir/bios.bin" extract \
 	    -m x86 -n fallback/refcode -f "$appdir/ref" -r RO_SECTION

-	# enable the Intel GbE device, if told by offset MRC_refcode_gbe:
-
-	if [ -n "$MRC_refcode_gbe" ]; then
-
+	# enable the Intel GbE device, if told by offset MRC_refcode_gbe
+	[ -n "$MRC_refcode_gbe" ] && \
 		x_ dd if="config/ifd/hp820g2/1.bin" of="$appdir/ref" bs=1 \
 		    seek=$MRC_refcode_gbe count=1 conv=notrunc; :
-	fi

 	x_ mv "$appdir/ref" "$_pre_dest"
 }

 extract_mrc()
 {
-	if [ -z "$MRC_board" ]; then
-
+	[ -z "$MRC_board" ] && \
 		err "MRC_board unset" "extract_mrc" "$@"
-
-	elif [ -z "$CONFIG_MRC_FILE" ]; then
-
+	[ -z "$CONFIG_MRC_FILE" ] && \
 		err "CONFIG_MRC_FILE unset" "extract_mrc" "$@"
-	fi

 	SHELLBALL="chromeos-firmwareupdate-$MRC_board"

 	(
 		x_ cd "$appdir"
-
 		extract_partition "${MRC_url##*/}"
 		extract_archive "$SHELLBALL" .

@@ -72,7 +58,6 @@ extract_partition()
 	    parted "${1%.zip}" 2>/dev/null | grep "ROOT-A" )

 	START=$(( $( echo $ROOTP | cut -f2 -d\ | tr -d "B" ) ))
-
 	SIZE=$(( $( echo $ROOTP | cut -f4 -d\ | tr -d "B" ) ))

 	x_ dd if="${1%.zip}" of="root-a.ext2" bs=1024 \
@@ -11,29 +11,20 @@ grubdata="config/data/grub"
 buildser()
 {
 	if [ "$1" = "pico" ]; then
-
 		x_ cmake -DPICO_BOARD="$2" \
 		    -DPICO_SDK_PATH="$picosdk" -B "$sersrc/build" "$sersrc"
-
 		x_ cmake --build "$sersrc/build"
-
 	elif [ "$1" = "stm32" ]; then
-
 		x_ make -C "$sersrc" libopencm3-just-make BOARD=$2
-
 		x_ make -C "$sersrc" BOARD=$2
 	fi

-	x_ xbmkdir "bin/serprog_$1"
-
+	x_ mkdir -p "bin/serprog_$1"
 	x_ mv "$serx" "bin/serprog_$1/serprog_$2.${serx##*.}"
 }

 copyps1bios()
 {
-	$if_dry_build \
-		return 0
-
 	remkdir "bin/playstation"
 	x_ cp src/pcsx-redux/src/mips/openbios/openbios.bin bin/playstation

@@ -47,11 +38,7 @@ copyps1bios()

 mkpayload_grub()
 {
-	grub_modules=""
-	grub_install_modules=""
-
-	$if_dry_build \
-		return 0
+	eval "`newvar grub_modules grub_install_modules`"

 	. "$grubdata/module/$tree" || \
 	    err "Can't read '$grubdata/module/$tree'" "mkpayload_grub" "$@"
@@ -69,112 +56,65 @@ mkpayload_grub()

 corebootpremake()
 {
-	if [ "$XBMK_RELEASE" = "y" ] && \
-	    [ "$release" = "n" ]; then
-
+	[ "$XBMK_RELEASE" = "y" ] && [ "$release" = "n" ] && \
 		return 0
-	fi
-
-	$if_not_dry_build \
-		cook_coreboot_config

 	fx_ check_coreboot_util printf "cbfstool\nifdtool\n"

 	printf "%s\n" "${version%%-*}" > "$srcdir/.coreboot-version" || \
 	    err "!mk $srcdir .coreboot-version" "corebootpremake" "$@"

-	if [ -z "$mode" ] && \
-	    [ "$target" != "$tree" ]; then
-
-		x_ ./mk download "$target"
-	fi
-}
-
-cook_coreboot_config()
-{
-	if [ -z "$mode" ] && \
-	    [ -f "$srcdir/.config" ]; then
-
-		printf "CONFIG_CCACHE=y\n" >> "$srcdir/.config" || \
-		    err "can't cook '$srcdir'" "cook_coreboot_config" "$@"
-	fi
+	[ "$target" != "$tree" ] && \
+		x_ "$mk" download "$target"; :
 }

 check_coreboot_util()
 {
-	if [ "$badhash" = "y" ]; then
-
+	[ "$badhash" = "y" ] && \
 		x_ rm -f "elf/coreboot/$tree/$1"
-	fi
-
-	if e "elf/coreboot/$tree/$1" f; then
-
+	e "elf/coreboot/$tree/$1" f && \
 		return 0
-	fi

 	utilelfdir="elf/coreboot/$tree"
 	utilsrcdir="src/coreboot/$tree/util/$1"

 	utilmode=""
-
-	if [ -n "$mode" ]; then
-
+	[ -n "$mode" ] && \
 		utilmode="clean"
-	fi

 	x_ make -C "$utilsrcdir" $utilmode -j$XBMK_THREADS $makeargs

 	if [ -n "$mode" ]; then
-
-		# TODO: is this rm command needed?
 		x_ rm -Rf "$utilelfdir"
-
 		return 0
-
-	elif [ -n "$mode" ] || \
-	    [ -f "$utilelfdir/$1" ]; then
-
+	elif [ -n "$mode" ] || [ -f "$utilelfdir/$1" ]; then
 		return 0
 	fi

-	x_ xbmkdir "$utilelfdir"
-
+	x_ mkdir -p "$utilelfdir"
 	x_ cp "$utilsrcdir/$1" "$utilelfdir"

-	if [ "$1" = "cbfstool" ]; then
-
-		x_ cp "$utilsrcdir/rmodtool" "$utilelfdir"
-	fi
+	[ "$1" = "cbfstool" ] && \
+		x_ cp "$utilsrcdir/rmodtool" "$utilelfdir"; :
 }

 coreboot_pad_one_byte()
 {
-	if [ "$XBMK_RELEASE" = "y" ] && [ "$release" = "n" ]; then
+	[ "$XBMK_RELEASE" = "y" ] && [ "$release" = "n" ] && \
 		return 0
-	fi

-	$if_not_dry_build \
-		pad_one_byte "$srcdir/build/coreboot.rom"
+	pad_one_byte "$srcdir/build/coreboot.rom"
 }

 mkcorebootbin()
 {
-	if [ "$XBMK_RELEASE" = "y" ] && \
-	    [ "$release" = "n" ]; then
-
+	[ "$XBMK_RELEASE" = "y" ] && [ "$release" = "n" ] && \
 		return 0
-	fi

-	$if_not_dry_build \
-		check_coreboot_util cbfstool
-
-	$if_not_dry_build \
-		check_coreboot_util ifdtool
+	forx 'check_coreboot_util %s' cbfstool ifdtool

 	for y in "$target_dir/config"/*; do
-
 		defconfig="$y"
-
 		mkcorebootbin_real
 	done

@@ -183,138 +123,78 @@ mkcorebootbin()

 mkcorebootbin_real()
 {
-	if [ "$target" = "$tree" ]; then
-
-		return 0
-	fi
+	[ "$target" = "$tree" ] && return 0

 	tmprom="$xbtmp/coreboot.rom"

 	initmode="${defconfig##*/}"
 	displaymode="${initmode##*_}"
-
 	if [ "$displaymode" = "$initmode" ]; then
-
 		# blank it for "normal" or "fspgop" configs:

 		displaymode=""
 	fi
-
 	initmode="${initmode%%_*}"
-
 	cbfstool="elf/coreboot/$tree/cbfstool"

 	# cbfstool option backends, if they exist
 	cbfscfg="config/coreboot/$target/cbfs.cfg"

 	elfrom="elf/coreboot/$tree/$target/$initmode"
-
-	if [ -n "$displaymode" ]; then
-
+	[ -n "$displaymode" ] && \
 		elfrom="${elfrom}_$displaymode"
-	fi
-
 	elfrom="$elfrom/coreboot.rom"

-	$if_not_dry_build \
-		x_ cp "$elfrom" "$tmprom"
+	x_ cp "$elfrom" "$tmprom"
+	unpad_one_byte "$tmprom"

-	$if_not_dry_build \
-		unpad_one_byte "$tmprom"
-
-	if [ -n "$payload_uboot" ] && \
-	    [ "$payload_uboot" != "amd64" ] && \
-	    [ "$payload_uboot" != "i386" ] && \
-	    [ "$payload_uboot" != "arm64" ]; then
-
-		err "'$target' defines bad u-boot type '$payload_uboot'" \
+	[ -n "$payload_uboot" ] && [ "$payload_uboot" != "amd64" ] && \
+	    [ "$payload_uboot" != "i386" ] && [ "$payload_uboot" != "arm64" ] \
+		&& err "'$target' defines bad u-boot type '$payload_uboot'" \
 		    "mkcorebootbin_real" "$@"
-	fi
-
-	if [ -n "$payload_uboot" ] && \
-	    [ "$payload_uboot" != "arm64" ]; then

+	[ -n "$payload_uboot" ] && [ "$payload_uboot" != "arm64" ] && \
 		payload_seabios="y"
-	fi
-
-	if [ -z "$uboot_config" ]; then

+	[ -z "$uboot_config" ] && \
 		uboot_config="default"
-	fi
-
-	if [ "$payload_grub" = "y" ]; then
-
+	[ "$payload_grub" = "y" ] && \
 		payload_seabios="y"
-	fi
-
-	if [ "$payload_seabios" = "y" ] && \
-	    [ "$payload_uboot" = "arm64" ]; then
-
-		$if_not_dry_build \
-			err "$target: U-Boot arm / SeaBIOS/GRUB both enabled" \
-			    "mkcorebootbin_real" "$@"
-	fi
-
-	if [ -z "$grub_scan_disk" ]; then
+	[ "$payload_seabios" = "y" ] && [ "$payload_uboot" = "arm64" ] && \
+		err "$target: U-Boot arm / SeaBIOS/GRUB both enabled" \
+		    "mkcorebootbin_real" "$@"

+	[ -z "$grub_scan_disk" ] && \
 		grub_scan_disk="nvme ahci ata"
-	fi
-
-	if [ -z "$grubtree" ]; then
-
+	[ -z "$grubtree" ] && \
 		grubtree="default"
-	fi
-
 	grubelf="elf/grub/$grubtree/$grubtree/payload/grub.elf"

-	if [ "$payload_memtest" != "y" ]; then
-
+	[ "$payload_memtest" != "y" ] && \
 		payload_memtest="n"
-	fi
-
-	if [ "$(uname -m)" != "x86_64" ]; then
-
+	[ "$(uname -m)" != "x86_64" ] && \
 		payload_memtest="n"
-	fi
-
-	if [ "$payload_grubsea" = "y" ] && \
-	    [ "$initmode" = "normal" ]; then

+	[ "$payload_grubsea" = "y" ] && [ "$initmode" = "normal" ] && \
 		payload_grubsea="n"
-	fi
-
-	if [ "$payload_grub" != "y" ]; then
-
+	[ "$payload_grub" != "y" ] && \
 		payload_grubsea="n"
-	fi
-
-	$if_dry_build \
-		return 0
-
-	if [ -f "$cbfscfg" ]; then

+	[ -f "$cbfscfg" ] && \
 		dx_ add_cbfs_option "$cbfscfg"
-	fi

 	if grep "CONFIG_PAYLOAD_NONE=y" "$defconfig"; then
-
 		if [ "$payload_seabios" = "y" ]; then
-
 			pname="seabios"
-
 			add_seabios
 		fi
-
 		if [ "$payload_uboot" = "arm64" ]; then
-
 			pname="uboot"
-
-			add_uboot
+			add_uboot "" fallback/payload default \
+			    "$target" u-boot.elf
 		fi
 	else
-
 		pname="custom"
-
 		cprom
 	fi; :
 }
@@ -323,15 +203,10 @@ mkcorebootbin_real()

 add_cbfs_option()
 {
-	# TODO: input sanitization (currently mitigated by careful config)
-
 	op_name="`printf "%s\n" "$1" | awk '{print $1}'`"
-
 	op_arg="`printf "%s\n" "$1" | awk '{print $2}'`"

-	if [ -z "$op_name" ] || \
-	    [ -z "$op_arg" ]; then
-
+	if [ -z "$op_name" ] || [ -z "$op_arg" ]; then
 		return 0
 	fi

@@ -350,92 +225,53 @@ add_cbfs_option()

 add_seabios()
 {
-	if [ -n "$payload_uboot" ] && \
-	    [ "$payload_uboot" != "arm64" ]; then
-
-		# we must add u-boot first, because it's added as a flat
-		# binary at a specific offset for secondary program loader
-
-		$if_not_dry_build \
-			add_uboot
-	fi
+	[ -n "$payload_uboot" ] && [ "$payload_uboot" != "arm64" ] && \
+	    [ "$displaymode" != "txtmode" ] && [ "$initmode" != "normal" ] && \
+		add_uboot_x86 # u-boot first, due to fixed cbfs offset

 	_seabioself="elf/seabios/default/default/$initmode/bios.bin.elf"
-
-	if [ "$initmode" = "fspgop" ]; then
-
+	[ "$initmode" = "fspgop" ] && \
 	    _seabioself="elf/seabios/default/default/libgfxinit/bios.bin.elf"
-	fi

 	_seaname="fallback/payload"
-
-	if [ "$payload_grubsea" = "y" ]; then
-
+	[ "$payload_grubsea" = "y" ] && \
 		 _seaname="seabios.elf"
-	fi

 	cbfs "$tmprom" "$_seabioself" "$_seaname"

 	x_ "$cbfstool" "$tmprom" add-int -i 3000 -n etc/ps2-keyboard-spinup

 	opexec="2"
-
-	if [ "$initmode" = "vgarom" ]; then
-
+	[ "$initmode" = "vgarom" ] && \
 		opexec="0"
-	fi
-
 	x_ "$cbfstool" "$tmprom" add-int -i $opexec -n etc/pci-optionrom-exec

 	x_ "$cbfstool" "$tmprom" add-int -i 0 -n etc/optionroms-checksum
-
-	if [ "$initmode" = "libgfxinit" ] || \
-	    [ "$initmode" = "fspgop" ]; then
-
+	if [ "$initmode" = "libgfxinit" ] || [ "$initmode" = "fspgop" ]; then
 		cbfs "$tmprom" "$seavgabiosrom" vgaroms/seavgabios.bin raw
 	fi

-	if [ "$payload_memtest" = "y" ]; then
-
-		# because why not have memtest?
-		# we can have it. we are entitled to it.
-		# so we shall have it, yes. having memtest86+
-		# in your boot flash makes you a better person.
-
+	[ "$payload_memtest" = "y" ] && \
 		cbfs "$tmprom" "elf/memtest86plus/memtest.bin" img/memtest
-	fi
-
-	if [ "$payload_grub" = "y" ]; then

+	[ "$payload_grub" = "y" ] && \
 		add_grub
-	fi

-	if [ "$payload_grubsea" != "y" ]; then
+	[ "$payload_grubsea" != "y" ] && \
+		cprom # seabios, but don't load grub/u-boot first

-		# ROM image where SeaBIOS doesn't load grub/u-boot first.
-		# U-Boot/GRUB available in ESC menu if enabled for the board
-
-		cprom
-	fi
-
-	# now make "SeaUBoot" and "SeaGRUB" images, where SeaBIOS auto-loads
-	# SeaBIOS or U-Boot first; users can bypass this by pressing ESC
-	# in the SeaBIOS menu, to boot devices using SeaBIOS itself instead
+	# now make seauboot(u-boot loaded by seabios) and SeaGRUB (GRUB loaded
+	# by SeaBIOS) images; users can bypass via ESC to boot from SeaBIOS

 	if [ "$payload_uboot" = "amd64" ] && \
 	    [ "$displaymode" != "txtmode" ] && \
-	    [ "$initmode" != "normal" ] && \
-	    [ "$payload_grubsea" != "y" ]; then
-
+	    [ "$initmode" != "normal" ] && [ "$payload_grubsea" != "y" ]; then
 		pname="seauboot"
-
 		cprom "seauboot"
 	fi

 	if [ "$payload_grub" = "y" ]; then
-
 		pname="seagrub"
-
 		mkseagrub
 	fi
 }
@@ -444,11 +280,8 @@ add_grub()
 {
 	# path in CBFS for the GRUB payload
 	_grubname="img/grub2"
-
-	if [ "$payload_grubsea" = "y" ]; then
-
+	[ "$payload_grubsea" = "y" ] && \
 		_grubname="fallback/payload"
-	fi

 	cbfs "$tmprom" "$grubelf" "$_grubname"

@@ -458,107 +291,44 @@ add_grub()

 	cbfs "$tmprom" "$xbtmp/tmpcfg" scan.cfg raw

-	if [ "$initmode" != "normal" ] && \
-	    [ "$displaymode" != "txtmode" ]; then
-
+	[ "$initmode" != "normal" ] && [ "$displaymode" != "txtmode" ] && \
 		cbfs "$tmprom" "$grubdata/background/background1280x800.png" \
-		    "background.png" raw
-	fi
+		    "background.png" raw; :
 }

 mkseagrub()
 {
 	if [ "$payload_grubsea" = "y" ]; then
-
 		pname="grub"
 	else
-
 		cbfs "$tmprom" "$grubdata/bootorder" bootorder raw
 	fi

 	fx_ cprom x_ find "$grubdata/keymap" -type f -name "*.gkb"
 }

+add_uboot_x86()
+{
+	[ "$payload_uboot" = "amd64" ] && \
+		add_uboot "-l 0x1110000 -e 0x1110000" "img/u-boot" \
+		    "x86_64" "amd64coreboot" "u-boot-x86-with-spl.bin"
+	[ "$payload_uboot" = "i386" ] && \
+		add_uboot "-l 0x1110000 -e 0x1110000" "u-boot" "x86" \
+		    "i386coreboot" "u-boot-dtb.bin"; :
+}
+
 add_uboot()
 {
-	if [ "$displaymode" = "txtmode" ]; then
+	ubootelf="elf/u-boot/$3/$4/$uboot_config/$5"
+	[ ! -f "$ubootelf" ] && \
+		ubootelf="${ubootelf%.elf}" # hack (fix arm64 build)

-		printf "cb/%s: Can't use U-Boot in text mode\n" "$target" 1>&2
-
-		return 0
-
-	elif [ "$initmode" = "normal" ]; then
-
-		printf "cb/%s: Can't use U-Boot in normal initmode\n" \
-		    "$target" 1>&2
-
-		return 0
-	fi
-
-	# TODO: re-work to allow each coreboot target to say which ub tree
-	# instead of hardcoding as in the current logic below:
-
-	# aarch64 targets:
-	ubcbfsargs=""
-	ubpath="fallback/payload"
-	ubtree="default"
-	ubtarget="$target"
-
-	# override for x86/x86_64 targets:
-	if [ -n "$payload_uboot" ] && [ "$payload_uboot" != "arm64" ]; then
-
-		ubcbfsargs="-l 0x1110000 -e 0x1110000" # 64-bit and 32-bit
-			# on 64-bit, 0x1120000 is the SPL, with a stub that
-			# loads it, located at 0x1110000
-
-		ubpath="img/u-boot" # 64-bit
-
-		ubtree="x86_64"
-		ubtarget="amd64coreboot"
-
-		if [ "$payload_uboot" = "i386" ]; then
-
-			# override for 32-bit
-
-			ubpath="u-boot"
-
-			ubtree="x86"
-			ubtarget="i386coreboot"; :
-		fi
-	fi
-
-	ubdir="elf/u-boot/$ubtree/$ubtarget/$uboot_config"
-
-	# aarch64 targets:
-
-	ubootelf="$ubdir/u-boot.elf"
-
-	if [ ! -f "$ubootelf" ]; then
-
-		ubootelf="$ubdir/u-boot"
-	fi
-
-	# override for x86/x86_64 targets:
-
-	if [ "$payload_uboot" = "i386" ]; then
-
-		ubootelf="$ubdir/u-boot-dtb.bin"
-
-	elif [ "$payload_uboot" = "amd64" ]; then
-
-		ubootelf="$ubdir/u-boot-x86-with-spl.bin" # EFI-compatible
-	fi
-
-	cbfs "$tmprom" "$ubootelf" "$ubpath" $ubcbfsargs
-
-	if [ "$payload_seabios" != "y" ]; then
-
-		cprom
-	fi
+	cbfs "$tmprom" "$ubootelf" "$2" $1
+	[ "$payload_seabios" != "y" ] && \
+		cprom; :
 }

 # prepare the final image in bin/ for user installation:
-
 cprom()
 {
 	cpcmd="cp"
@@ -566,14 +336,9 @@ cprom()
 	tmpnew=""
 	newrom="bin/$target/${pname}_${target}_$initmode.rom"

-	if [ -n "$displaymode" ]; then
-
+	[ -n "$displaymode" ] && \
 		newrom="${newrom%.rom}_$displaymode.rom"
-	fi
-
-	if [ $# -gt 0 ] && \
-	    [ "${1%.gkb}" != "$1" ]; then
-
+	if [ $# -gt 0 ] && [ "${1%.gkb}" != "$1" ]; then
 		tmpnew="${1##*/}"
 		newrom="${newrom%.rom}_${tmpnew%.gkb}.rom"
 	fi
@@ -581,26 +346,21 @@ cprom()
 	irom="$tmprom"

 	if [ $# -gt 0 ]; then
-
 		irom="$(mktemp || err "!mk irom, $(echo "$@")")" || \
 		    err "can't copy rom" "cprom" "$@"

 		x_ cp "$tmprom" "$irom" && cpcmd="mv"

 		if [ "${1%.gkb}" != "$1" ]; then
-
 			cbfs "$irom" "$grubdata/keymap/$tmpnew" keymap.gkb raw
-
 		elif [ "$1" = "seauboot" ]; then
-
 			cbfs "$irom" "$grubdata/bootorder_uboot" bootorder raw
 		fi
 	fi

 	printf "Creating new %s image: '%s'\n" "$projectname" "$newrom"

-	x_ xbmkdir "bin/$target"
-
+	x_ mkdir -p "bin/$target"
 	x_ $cpcmd "$irom" "$newrom"
 }

@@ -609,15 +369,10 @@ cbfs()
 	ccmd="add-payload"
 	lzma="-c lzma"

-	if [ $# -gt 3 ] && \
-	    [ $# -lt 5 ]; then
-
+	if [ $# -gt 3 ] && [ $# -lt 5 ]; then
 		ccmd="add"
 		lzma="-t $4"
-
-	elif [ $# -gt 4 ] && \
-	    [ "$5" = "0x1110000" ]; then
-
+	elif [ $# -gt 4 ] && [ "$5" = "0x1110000" ]; then
 		ccmd="add-flat-binary" && \
 		lzma="-c lzma -l 0x1110000 -e 0x1110000"
 	fi
@@ -629,17 +384,11 @@ cbfs()

 mkcoreboottar()
 {
-	$if_dry_build \
-		return 0
-
-	if [ "$target" = "$tree" ] || \
-	    [ "$XBMK_RELEASE" != "y" ] || \
+	if [ "$target" = "$tree" ] || [ "$XBMK_RELEASE" != "y" ] || \
 	    [ "$release" = "n" ]; then
-
 		return 0
 	fi

 	mkrom_tarball "bin/$target"
-
-	x_ ./mk inject "bin/${relname}_${target}.tar.xz" nuke
+	x_ "$mk" inject "bin/${relname}_${target}.tar.xz" nuke
 }
@@ -2,7 +2,7 @@

 # Copyright (c) 2022 Caleb La Grange <thonkpeasant@protonmail.com>
 # Copyright (c) 2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
-# Copyright (c) 2023-2025 Leah Rowe <leah@libreboot.org>
+# Copyright (c) 2023-2026 Leah Rowe <leah@libreboot.org>

 # These are variables and functions, extending the functionality of
 # inject.sh, to be used with lbmk; they are kept separate here, so that
@@ -36,147 +36,63 @@ checkvarsxbmk="CONFIG_ME_BIN_PATH CONFIG_SMSC_SCH5545_EC_FW_FILE \
    CONFIG_FSP_FD_PATH CONFIG_IFD_BIN_PATH CONFIG_MRC_FILE CONFIG_FSP_M_CBFS"

 # lbmk-specific extensions; general variables
-cbdir=""
-cbfstoolref=""
-has_hashes=""
-hashfile=""
-kbc1126_ec_dump=""
-mecleaner=""
-mfs=""
-nuke=""
-rom=""
-vcfg=""
-xromsize=""
+eval "`newvar cbdir cbfstoolref has_hashes hashfile kbc1126_ec_dump mecleaner \
+    mfs nuke rom vcfg xromsize _7ztest _dest _dl _dl_bin _me _metmp _pre_dest`"

-_7ztest=""
-_dest=""
-_dl=""
-_dl_bin=""
-_me=""
-_metmp=""
-_pre_dest=""
-
-# lbmk-specific extensions; declared in pkg.cfg files in config/vendor/
-DL_hash=""
-DL_url=""
-DL_url_bkup=""
-E6400_VGA_bin_hash=""
-E6400_VGA_DL_hash=""
-E6400_VGA_DL_url=""
-E6400_VGA_DL_url_bkup=""
-E6400_VGA_offset=""
-E6400_VGA_romname=""
-EC_FW1_hash=""
-EC_FW2_hash=""
-EC_hash=""
-EC_url=""
-EC_url_bkup=""
-FSPFD_hash=""
-FSPM_bin_hash=""
-FSPS_bin_hash=""
-ME11bootguard=""
-ME11delta=""
-ME11pch=""
-ME11sku=""
-ME11version=""
-ME_bin_hash=""
-MEcheck=""
-MEclean=""
-MEshrink=""
-MRC_bin_hash=""
-MRC_refcode_cbtree=""
-MRC_refcode_gbe=""
-REF_bin_hash=""
-SCH5545EC_bin_hash=""
-SCH5545EC_DL_hash=""
-SCH5545EC_DL_url=""
-SCH5545EC_DL_url_bkup=""
-TBFW_bin_hash=""
-TBFW_hash=""
-TBFW_size=""
-TBFW_url=""
-TBFW_url_bkup=""
-XBMKmecleaner=""
+# lbmk-specific extensions; declared by pkg.cfg files in config/vendor/
+eval "`newvar DL_hash DL_url DL_url_bkup E6400_VGA_bin_hash E6400_VGA_DL_hash \
+    E6400_VGA_DL_url E6400_VGA_DL_url_bkup E6400_VGA_offset E6400_VGA_romname \
+    EC_FW1_hash EC_FW2_hash EC_hash EC_url EC_url_bkup FSPFD_hash \
+    FSPM_bin_hash FSPS_bin_hash ME11bootguard ME11delta ME11pch ME11sku \
+    ME11version ME_bin_hash MEcheck MEclean MEshrink MRC_bin_hash \
+    MRC_refcode_cbtree MRC_refcode_gbe REF_bin_hash SCH5545EC_bin_hash \
+    SCH5545EC_DL_hash SCH5545EC_DL_url SCH5545EC_DL_url_bkup TBFW_bin_hash \
+    TBFW_hash TBFW_size TBFW_url TBFW_url_bkup XBMKmecleaner`"

 download()
 {
-	if [ $# -lt 1 ]; then
-
-		err "No argument given" "download" "$@"
-	fi
+	[ $# -lt 1 ] && err "No argument given" "download" "$@"

 	export PATH="$PATH:/sbin"
 	board="$1"

-	if check_target; then
-
-		readkconfig download
-	fi
+	check_target && readkconfig download; :
 }

 getfiles()
 {
-	if [ -n "$CONFIG_HAVE_ME_BIN" ];then
-
+	[ -n "$CONFIG_HAVE_ME_BIN" ] && \
 		fetch intel_me "$DL_url" "$DL_url_bkup" "$DL_hash" \
 		    "$CONFIG_ME_BIN_PATH" curl "$ME_bin_hash"
-	fi
-
-	if [ -n "$CONFIG_INCLUDE_SMSC_SCH5545_EC_FW" ]; then
-
+	[ -n "$CONFIG_INCLUDE_SMSC_SCH5545_EC_FW" ] && \
 		fetch sch5545ec "$SCH5545EC_DL_url" "$SCH5545EC_DL_url_bkup" \
 		    "$SCH5545EC_DL_hash" "$CONFIG_SMSC_SCH5545_EC_FW_FILE" \
 		    "curl" "$SCH5545EC_bin_hash"
-	fi
-
-	if [ -n "$CONFIG_KBC1126_FW1" ]; then
-
+	[ -n "$CONFIG_KBC1126_FW1" ] && \
 		fetch kbc1126ec "$EC_url" "$EC_url_bkup" "$EC_hash" \
 		    "$CONFIG_KBC1126_FW1" curl "$EC_FW1_hash"
-	fi
-
-	if [ -n "$CONFIG_KBC1126_FW2" ]; then
-
+	[ -n "$CONFIG_KBC1126_FW2" ] && \
 		fetch kbc1126ec "$EC_url" "$EC_url_bkup" "$EC_hash" \
 		    "$CONFIG_KBC1126_FW2" curl "$EC_FW2_hash"
-	fi
-
-	if [ -n "$CONFIG_VGA_BIOS_FILE" ]; then
-
+	[ -n "$CONFIG_VGA_BIOS_FILE" ] && \
 		fetch e6400vga "$E6400_VGA_DL_url" "$E6400_VGA_DL_url_bkup" \
 		    "$E6400_VGA_DL_hash" "$CONFIG_VGA_BIOS_FILE" "curl" \
 		    "$E6400_VGA_bin_hash"
-	fi
-
-	if [ -n "$CONFIG_HAVE_MRC" ]; then
-
+	[ -n "$CONFIG_HAVE_MRC" ] && \
 		fetch "mrc" "$MRC_url" "$MRC_url_bkup" "$MRC_hash" \
 		    "$CONFIG_MRC_FILE" "curl" "$MRC_bin_hash"
-	fi
-
-	if [ -n "$CONFIG_REFCODE_BLOB_FILE" ]; then
-
+	[ -n "$CONFIG_REFCODE_BLOB_FILE" ] && \
 		fetch "refcode" "$MRC_url" "$MRC_url_bkup" "$MRC_hash" \
 		    "$CONFIG_REFCODE_BLOB_FILE" "curl" "$REF_bin_hash"
-	fi
-
-	if [ -n "$CONFIG_LENOVO_TBFW_BIN" ]; then
-
+	[ -n "$CONFIG_LENOVO_TBFW_BIN" ] && \
 		fetch "tbfw" "$TBFW_url" "$TBFW_url_bkup" "$TBFW_hash" \
 		    "$CONFIG_LENOVO_TBFW_BIN" "curl" "$TBFW_bin_hash"
-	fi
-
-	if [ -n "$CONFIG_FSP_M_FILE" ]; then
-
+	[ -n "$CONFIG_FSP_M_FILE" ] && \
 		fetch "fsp" "$CONFIG_FSP_FD_PATH" "$CONFIG_FSP_FD_PATH" \
 		    "$FSPFD_hash" "$CONFIG_FSP_M_FILE" "copy" "$FSPM_bin_hash"
-	fi
-
-	if [ -n "$CONFIG_FSP_S_FILE" ]; then
-
+	[ -n "$CONFIG_FSP_S_FILE" ] && \
 		fetch "fsp" "$CONFIG_FSP_FD_PATH" "$CONFIG_FSP_FD_PATH" \
-		    "$FSPFD_hash" "$CONFIG_FSP_S_FILE" "copy" "$FSPS_bin_hash"
-	fi
+		    "$FSPFD_hash" "$CONFIG_FSP_S_FILE" copy "$FSPS_bin_hash"; :
 }

 fetch()
@@ -190,137 +106,74 @@ fetch()
 	dlop="$6"
 	binsum="$7"

-	if [ -z "$binsum" ]; then
-
-		err "binsum is empty (no checksum)" "fetch" "$@"
-	fi
+	[ -z "$binsum" ] && err "binsum is empty (no checksum)" "fetch" "$@"

 	_dl="$XBMK_CACHE/file/$dlsum" # internet file to extract from e.g. .exe
 	_dl_bin="$XBMK_CACHE/file/$binsum" # extracted file e.g. me.bin

-	if [ "$5" = "/dev/null" ]; then
-
-		return 0
-	fi
+	[ "$5" = "/dev/null" ] && return 0 # fetch/extract disabled

 	# an extracted vendor file will be placed in pre_dest first, for
-	# verifying its checksum. if it matches, it is later moved to _dest:
-
+	# verifying its checksum. if it matches, it is later moved to _dest
 	remkdir "${_pre_dest%/*}" "$appdir"

-	# HACK: if grabbing fsp from coreboot, fix the path for lbmk:
-
-	if [ "$dl_type" = "fsp" ]; then
-
-		dl="${dl##*../}"
-		_cdp="$dl"
-
-		if [ ! -f "$_cdp" ]; then
+	# HACK: if grabbing fsp from coreboot, fix the path for lbmk
+	[ "$dl_type" = "fsp" ] && for bkup in "" "_bkup"; do
+		eval "dl$bkup=\"\${dl$bkup##*../}\""
+		eval "_cdp=\"\$dl$bkup\""

+		[ ! -f "$_cdp" ] && \
 			_cdp="$cbdir/$_cdp"
-		fi
-
-		if [ -f "$_cdp" ]; then
-
-			dl="$_cdp"
-		fi
-
-		dl_bkup="${dl_bkup##*../}"
-		_cdp="$dl_bkup"
-
-		if [ ! -f "$_cdp" ]; then
-
-			_cdp="$cbdir/$_cdp"
-		fi
-
-		if [ -f "$_cdp" ]; then
-
-			dl_bkup="$_cdp"; :
-		fi
-	fi
+		[ -f "$_cdp" ] && \
+			eval "dl$bkup=\"\$_cdp\""; :
+	done; :

 	# download the file (from the internet) to extract from:
-
 	xbget "$dlop" "$dl" "$dl_bkup" "$_dl" "$dlsum"
 	x_ rm -Rf "${_dl}_extracted"

 	# skip extraction if a cached extracted file exists:
-
 	( xbget copy "$_dl_bin" "$_dl_bin" "$_dest" "$binsum" 2>/dev/null ) || :
-
-	if [ -f "$_dest" ]; then
-
+	[ -f "$_dest" ] && \
 		return 0
-	fi

-	x_ xbmkdir "${_dest%/*}"
-
-	if [ "$dl_type" != "fsp" ]; then
+	x_ mkdir -p "${_dest%/*}"

+	[ "$dl_type" = "fsp" ] || \
 		extract_archive "$_dl" "$appdir" || \
 		    [ "$dl_type" = "e6400vga" ] || \
 		    err "$_dest $dl_type: !extract" "fetch" "$@"
-	fi

 	x_ extract_$dl_type "$_dl" "$appdir"
-
 	set -u -e

 	# some functions don't output directly to the given file, _pre_dest.
 	# instead, they put multiple files there, but we need the one matching
 	# the given hashsum. So, search for a matching file via bruteforce:
-
 	( fx_ "mkdst $binsum" x_ find "${_pre_dest%/*}" -type f ) || :

-	if ! bad_checksum "$binsum" "$_dest"; then
+	bad_checksum "$binsum" "$_dest" || \
+		[ ! -f "$_dest" ] || return 0; :

-		if [ -f "$_dest" ]; then
-
-			return 0
-		fi
-	fi
-
-	if [ -z "$binsum" ]; then
-
-		printf "'%s': checksum undefined\n" "$_dest" 1>&2
-	fi
-
-	if [ -L "$_dest" ]; then
-
-		printf "WARNING: '%s' is a link!\n" "$_dest" 1>&2
-
-	else
-
-		x_ rm -f "$_dest"
-	fi
+	x_ rm -f "$_dest"

+	[ -z "$binsum" ] && printf "WARNING: %s: no checksum\n" "$_dest" 1>&2
 	err "Can't safely extract '$_dest', for board '$board'" "fetch" "$@"
 }

 mkdst()
 {
-	if bad_checksum "$1" "$2" 2>/dev/null; then
-
-		x_ rm -f "$2"
-
-	else
-
+	if ! bad_checksum "$1" "$2" 2>/dev/null; then
 		x_ mv "$2" "$_dl_bin"
 		x_ cp "$_dl_bin" "$_dest"
-
 		exit 1
 	fi
+	x_ rm -f "$2"
 }

 extract_intel_me()
 {
-	if e "$mecleaner" f missing; then
-
-		err "$cbdir: me_cleaner missing" "extract_intel_me" "$@"
-	fi
-
 	mfs=""
-
 	_7ztest="$xbtmp/metmp/a"
 	_metmp="$xbtmp/me.bin"

@@ -328,31 +181,20 @@ extract_intel_me()
 	x_ rm -Rf "$_7ztest"

 	# maintain compatibility with older configs
-	# because in the past, shrink was assumed:
-
-	if [ -z "$MEshrink" ]; then
-
+	# because in the past, shrink was assumed
+	[ -z "$MEshrink" ] && \
 		MEshrink="y"
-	fi
-
-	if [ "$MEshrink" != "y" ] && \
-	    [ "$MEshrink" != "n" ]; then
-
+	[ "$MEshrink" != "y" ] && [ "$MEshrink" != "n" ] && \
 		err "MEshrink set badly on '$board' vendor config"
-	fi

 	if [ "$ME11bootguard" = "y" ]; then
-
-		if [ -z "$ME11delta" ] || \
-		    [ -z "$ME11version" ] || \
-		    [ -z "$ME11sku" ] || \
-		    [ -z "$ME11pch" ]; then
-
+		if [ -z "$ME11delta" ] || [ -z "$ME11version" ] || \
+		    [ -z "$ME11sku" ] || [ -z "$ME11pch" ]; then
 			err "$board: ME11delta/ME11version/ME11sku/ME11pch" \
 			    "extract_intel_me" "$@"
 		fi

-		x_ ./mk -f deguard
+		x_ "$mk" -f deguard
 	fi

 	set +u +e
@@ -362,11 +204,8 @@ extract_intel_me()
 	set -u -e

 	if [ "$ME11bootguard" != "y" ]; then
-
 		x_ mv "$_metmp" "$_pre_dest"
-
 	else
-
 		( apply_deguard_hack ) || \
 		    err "deguard error on '$_dest'" "extract_intel_me" "$@"; :
 	fi
@@ -376,101 +215,47 @@ extract_intel_me()
 # must be called inside a subshell.
 find_me()
 {
-	if [ -f "$_metmp" ]; then
-
-		# we found me.bin, so we stop searching
-
-		exit 1
-
-	elif [ -L "$1" ]; then
-
-		return 0
-	fi
+	[ -f "$_metmp" ] && exit 1 # me.bin found
+	[ -L "$1" ] && return 0 # symlinks disabled for security reasons

 	_7ztest="${_7ztest}a"

-	_keep="" # -k: keep fptr modules even if they can be removed
-	_pass="" # -p: skip fptr check
 	_r="-r" # re-locate modules
 	_trunc="-t" # -t: truncate the ME size
+	eval "`newvar _keep _pass`" # -k (keep fptr modules), -p (skip checks)

-	if [ "$ME11bootguard" = "y" ]; then
-
+	[ "$ME11bootguard" = "y" ] && \
 		mfs="--whitelist MFS"
-	fi
-
 	if [ "$MEclean" = "n" ]; then
-
 		MEshrink="n"
-
 		_keep="-k" # keep ME modules, don't delete anything
 		mfs="" # no MFS whitelist needed, due to -r:
 	fi
-
-	if [ "$MEclean" = "n" ] || \
-	    [ "$MEshrink" != "y" ]; then
-
-		# MEclean can still be y, this just means don't shrink,
-		# so deleted modules would become padded space. this
-		# could also be used alongside --whitelist, if
-		# MEclean is otherwise enabled.
-
-		_r="" # don't re-locate ME modules
-		_trunc="" # don't shrink the me.bin file size
+	if [ "$MEclean" = "n" ] || [ "$MEshrink" != "y" ]; then
+		eval "`newvar _r _trunc`"
 	fi
-
-	if [ "$MEcheck" = "n" ]; then
-
+	[ "$MEcheck" = "n" ] && \
 		_pass="-p" # skip fptr check
-	fi
-
-	if [ -n "$mfs" ]; then
-
+	[ -n "$mfs" ] && \
 		_r="" # cannot re-locate modules if using --whitelist MFS
-	fi

 	if "$mecleaner" $mfs $_r $_keep $_pass $_trunc -O "$xbtmp/a" \
-	    -M "$_metmp" "$1" \
-	    || \
+	    -M "$_metmp" "$1" || [ -f "$_metmp" ]; then
+		: # me.bin extracted from a full image with ifd, then shrunk
+	elif "$mecleaner" $mfs $_r $_pass $_keep $_trunc -O "$_metmp" "$1" || \
 	    [ -f "$_metmp" ]; then
-
-		# me.bin extracted from a full image with ifd, then shrunk
-		:
-
-	elif "$mecleaner" $mfs $_r $_pass $_keep $_trunc -O "$_metmp" "$1" \
-	    || \
-	    [ -f "$_metmp" ]; then
-
-		# me.bin image already present, and we shrunk it
-		:
-
+		: # me.bin image already present, and we shrunk it
 	elif "$me7updateparser" $_keep -O "$_metmp" "$1"; then
-
-		# thinkpad sandybridge me.bin image e.g. x220/t420
-		:
-
+		: # thinkpad sandybridge me.bin image e.g. x220/t420
 	elif extract_archive "$1" "$_7ztest"; then
-
-		# scan newly extracted archive within extracted archive
-		:
-
+		: # scan newly extracted archive within extracted archive
 	else
-
-		# could not extract anything, so we'll try the next file
-		return 0
+		return 0 # can't extract, so try the next file
 	fi

-	if [ -f "$_metmp" ]; then
+	[ -f "$_metmp" ] && exit 1 # me.bin found

-		# we found me.bin, so we stop searching
-
-		exit 1
-	else
-
-		# if the subshell does exit 1, we found me.bin, so exit 1
-
-		( fx_ find_me x_ find "$_7ztest" -type f ) || exit 1; :
-	fi
+	( fx_ find_me x_ find "$_7ztest" -type f ) || exit 1; : # 1==me found
 }

 apply_deguard_hack()
@@ -484,35 +269,15 @@ apply_deguard_hack()

 extract_archive()
 {
-	if innoextract "$1" -d "$2"; then
-
-		:
-
-	elif python "$pfs_extract" "$1" -e; then
-
-		:
-
-	elif 7z x "$1" -o"$2"; then
-
-		:
-
-	elif "$bsdtar" -C "$2" -xf "$1"; then
-
-		:
-
-	elif "$bsdunzip" "$1" -d "$2"; then
-
-		:
-
-	else
-
+	innoextract "$1" -d "$2" || \
+	    python "$pfs_extract" "$1" -e || \
+	    7z x "$1" -o"$2" || \
+	    "$bsdtar" -C "$2" -xf "$1" || \
+	    "$bsdunzip" "$1" -d "$2" || \
 		return 1
-	fi

-	if [ -d "${_dl}_extracted" ]; then
-
-		x_ cp -R "${_dl}_extracted" "$2"
-	fi
+	[ -d "${_dl}_extracted" ] && \
+		x_ cp -R "${_dl}_extracted" "$2"; :
 }

 extract_kbc1126ec()
@@ -531,45 +296,23 @@ extract_kbc1126ec_dump()
 {
 	x_ cd "$appdir/"

-	if mv Rompaq/68*.BIN ec.bin; then
-
-		:
-
-	elif unar -D ROM.CAB Rom.bin; then
-
-		:
-
-	elif unar -D Rom.CAB Rom.bin; then
-
-		:
-
-	elif unar -D 68*.CAB Rom.bin; then
-
-		:
-
-	else
-
+	mv Rompaq/68*.BIN ec.bin || \
+	    unar -D ROM.CAB Rom.bin || \
+	    unar -D Rom.CAB Rom.bin || \
+	    unar -D 68*.CAB Rom.bin || \
 		err "!kbc1126 unar" "extract_kbc1126ec" "$@"
-	fi

-	if [ ! -f "ec.bin" ]; then
+	[ -f "ec.bin" ] || x_ mv Rom.bin ec.bin

-		x_ mv Rom.bin ec.bin
-	fi
-
-	if x_ e ec.bin f; then
-
-		x_ "$kbc1126_ec_dump" ec.bin
-	fi
+	x_ e ec.bin f
+	x_ "$kbc1126_ec_dump" ec.bin
 }

 extract_e6400vga()
 {
 	set +u +e

-	if [ -z "$E6400_VGA_offset" ] || \
-	    [ -z "$E6400_VGA_romname" ]; then
-
+	if [ -z "$E6400_VGA_offset" ] || [ -z "$E6400_VGA_romname" ]; then
 		err "$board: E6400_VGA_romname/E6400_VGA_offset unset" \
 		    "extract_e6400vga" "$@"
 	fi
@@ -577,15 +320,14 @@ extract_e6400vga()
 	tail -c +$E6400_VGA_offset "$_dl" | gunzip > "$appdir/bios.bin" || :

 	(
-
 	x_ cd "$appdir"
 	x_ e "bios.bin" f
-
 	"$e6400_unpack" bios.bin || printf "TODO: fix dell extract util\n"
-
 	) || err "can't extract e6400 vga rom" "extract_e6400vga" "$@"

 	x_ cp "$appdir/$E6400_VGA_romname" "$_pre_dest"
+
+	set -u -e
 }

 extract_sch5545ec()
@@ -599,7 +341,6 @@ extract_sch5545ec()
 	_sch5545ec_fw="$_sch5545ec_fw/0 Raw section/body.bin" # <-- this!

 	x_ "$uefiextract" "$_bios"
-
 	x_ cp "$_sch5545ec_fw" "$_pre_dest"
 }

@@ -607,19 +348,14 @@ extract_sch5545ec()
 # https://pcsupport.lenovo.com/us/en/products/laptops-and-netbooks/thinkpad-t-series-laptops/thinkpad-t480-type-20l5-20l6/20l5/solutions/ht508988
 extract_tbfw()
 {
-	if [ -z "$TBFW_size" ]; then
-
-		err "$board: TBFW_size unset" "extract_tbfw" "$@"
-	fi
+	[ -z "$TBFW_size" ] && err "$board: TBFW_size unset" extract_tbfw "$@"

 	fx_ copytb x_ find "$appdir" -type f -name "TBT.bin"
 }

 copytb()
 {
-	if [ -f "$1" ] && \
-	    [ ! -L "$1" ]; then
-
+	if [ -f "$1" ] && [ ! -L "$1" ]; then
 		x_ dd if=/dev/null of="$1" bs=1 seek=$TBFW_size
 		x_ mv "$1" "$_pre_dest"

@@ -635,31 +371,23 @@ extract_fsp()

 setvfile()
 {
-	[ -n "$vcfg" ] && for c in $checkvarschk; do
-
+	[ -n "$vcfg" ] && for c in $checkvarschk
+	do
 		do_getvfile="n"
-
 		vcmd="[ \"\${$c}\" != \"/dev/null\" ] && [ -n \"\${$c}\" ]"

 		eval "$vcmd && do_getvfile=\"y\""

-		if [ "$do_getvfile" = "y" ]; then
-
-			if getvfile "$@"; then
-
-				return 0
-			fi
-		fi
-
+		[ "$do_getvfile" = "y" ] && \
+			getvfile "$@" && \
+				return 0; :
 	done && return 1; :
 }

 getvfile()
 {
-	if e "config/vendor/$vcfg/pkg.cfg" f missing; then
-
+	e "config/vendor/$vcfg/pkg.cfg" f missing && \
 		return 1
-	fi

 	. "config/vendor/$vcfg/pkg.cfg" || \
 	    err "Can't read 'config/vendor/$vcfg/pkg.cfg'" "getvfile" "$@"
@@ -667,16 +395,10 @@ getvfile()
 	bootstrap

 	if [ $# -gt 0 ]; then
-
-		# download vendor files
-
-		getfiles
-	else
-
-		# inject vendor files
-
-		fx_ prep x_ find "$tmpromdir" -maxdepth 1 -type f -name "*.rom"
-
+		getfiles # ./mk download
+	else # ./mk inject
+		fx_ prep x_ find "$tmpromdir" -mindepth 1 -maxdepth 1 \
+		    -type f -name "*.rom"
 		( check_vendor_hashes ) || \
 		    err "$archive: Can't verify hashes" "getvfile" "$@"; :
 	fi
@@ -691,29 +413,20 @@ bootstrap()
 	rmodtool="elf/coreboot/$tree/rmodtool"

 	mecleaner="$xbmkpwd/$cbdir/util/me_cleaner/me_cleaner.py"
-
-	if [ "$XBMKmecleaner" = "y" ]; then
-
+	[ "$XBMKmecleaner" = "y" ] && \
 		mecleaner="$xbmkpwd/src/me_cleaner/me_cleaner.py"
-	fi

-	x_ ./mk -f coreboot "${cbdir##*/}"
-	x_ ./mk -f me_cleaner
+	x_ "$mk" -f coreboot "${cbdir##*/}"
+	x_ "$mk" -f me_cleaner

-	x_ ./mk -b bios_extract
-	x_ ./mk -b biosutilities
-	x_ ./mk -b uefitool
-	x_ ./mk -b libarchive # for bsdtar and bsdunzip
-
-	if [ -d "${kbc1126_ec_dump%/*}" ]; then
+	forx 'x_ \"$mk\" -b %s' bios_extract biosutilities uefitool libarchive

+	[ -d "${kbc1126_ec_dump%/*}" ] && \
 		x_ make -C "$cbdir/util/kbc1126"
-	fi

 	if [ -n "$MRC_refcode_cbtree" ]; then
-
 		cbfstoolref="elf/coreboot/$MRC_refcode_cbtree/cbfstool"
-		x_ ./mk -d coreboot "$MRC_refcode_cbtree"; :
+		x_ "$mk" -d coreboot "$MRC_refcode_cbtree"; :
 	fi
 }

@@ -723,24 +436,18 @@ prep()
 	_xromname="${1##*/}"
 	_xromnew="${_xrom%/*}/${_xromname#"$vfix"}"

-	if [ "$nuke" = "nuke" ]; then
-
+	[ "$nuke" = "nuke" ] && \
 		_xromnew="${_xrom%/*}/$vfix${_xrom##*/}"
-	fi
-
-	if e "$_xrom" f missing; then

+	e "$_xrom" f missing && \
 		return 0
-	fi
-
-	if [ -z "${_xromname#"$vfix"}" ]; then

+	[ -z "${_xromname#"$vfix"}" ] && \
 		err "$_xromname / $vfix: name match" "prep" "$@"
-	fi

 	# Remove the prefix and 1-byte pad
-	if [ "${_xromname#"$vfix"}" != "$_xromname" ] && \
-	    [ "$nuke" != "nuke" ]; then
+	if [ "${_xromname#"$vfix"}" != "$_xromname" ] \
+	    && [ "$nuke" != "nuke" ]; then

 		unpad_one_byte "$_xrom"
 		x_ mv "$_xrom" "$_xromnew"
@@ -749,34 +456,23 @@ prep()
 	fi

 	if [ "$nuke" = "nuke" ]; then
-
 		( mksha512 "$_xrom" "vendorhashes" ) || err; :
 	fi

-	if ! add_vfiles "$_xrom"; then
-
-		# no need to insert files. we will later
-		# still process MAC addresses as required
-
-		return 1
-	fi
+	add_vfiles "$_xrom" || return 1 # no need to insert files

 	if [ "$nuke" = "nuke" ]; then
-
 		pad_one_byte "$_xrom"
-
 		x_ mv "$_xrom" "$_xromnew"
 	fi
 }

 mksha512()
 {
-	build_sbase
-
-	if [ "${1%/*}" != "$1" ]; then
+	eval "$build_sbase"

+	[ "${1%/*}" != "$1" ] && \
 		x_ cd "${1%/*}"
-	fi

 	x_ "$sha512sum" ./"${1##*/}" >> "$2" || \
 	    err "!sha512sum \"$1\" > \"$2\"" "mksha512" "$@"
@@ -787,70 +483,37 @@ add_vfiles()
 	rom="$1"

 	if [ "$has_hashes" != "y" ] && [ "$nuke" != "nuke" ]; then
-
 		printf "'%s' has no hash file. Skipping.\n" "$archive" 1>&2
-
 		return 1
-
 	elif [ "$has_hashes" = "y" ] && [ "$nuke" = "nuke" ]; then
-
 		printf "'%s' has a hash file. Skipping nuke.\n" "$archive" 1>&2
-
 		return 1
 	fi

-	if [ -n "$CONFIG_HAVE_REFCODE_BLOB" ]; then
-
+	[ -n "$CONFIG_HAVE_REFCODE_BLOB" ] && \
 		vfile "fallback/refcode" "$CONFIG_REFCODE_BLOB_FILE" "stage"
-	fi
-
-	if [ "$CONFIG_HAVE_MRC" = "y" ]; then
-
+	[ "$CONFIG_HAVE_MRC" = "y" ] && \
 		vfile "mrc.bin" "$CONFIG_MRC_FILE" "mrc" "0xfffa0000"
-	fi
-
-	if [ "$CONFIG_HAVE_ME_BIN" = "y" ]; then
-
+	[ "$CONFIG_HAVE_ME_BIN" = "y" ] && \
 		vfile IFD "$CONFIG_ME_BIN_PATH" me
-	fi
-
-	if [ -n "$CONFIG_KBC1126_FW1" ]; then
-
+	[ -n "$CONFIG_KBC1126_FW1" ] && \
 		vfile ecfw1.bin "$CONFIG_KBC1126_FW1" raw \
 		    "$CONFIG_KBC1126_FW1_OFFSET"
-	fi
-
-	if [ -n "$CONFIG_KBC1126_FW2" ]; then
-
+	[ -n "$CONFIG_KBC1126_FW2" ] && \
 		vfile ecfw2.bin "$CONFIG_KBC1126_FW2" raw \
 		    "$CONFIG_KBC1126_FW2_OFFSET"
-	fi
-
-	if [ -n "$CONFIG_VGA_BIOS_FILE" ] && [ -n "$CONFIG_VGA_BIOS_ID" ]; then
-
+	[ -n "$CONFIG_VGA_BIOS_FILE" ] && [ -n "$CONFIG_VGA_BIOS_ID" ] && \
 		vfile "pci$CONFIG_VGA_BIOS_ID.rom" "$CONFIG_VGA_BIOS_FILE" \
 		    optionrom
-	fi
-
-	if [ "$CONFIG_INCLUDE_SMSC_SCH5545_EC_FW" = "y" ] && \
-	    [ -n "$CONFIG_SMSC_SCH5545_EC_FW_FILE" ]; then
-
+	[ "$CONFIG_INCLUDE_SMSC_SCH5545_EC_FW" = "y" ] && \
+	    [ -n "$CONFIG_SMSC_SCH5545_EC_FW_FILE" ] && \
 		vfile sch5545_ecfw.bin "$CONFIG_SMSC_SCH5545_EC_FW_FILE" raw
-	fi
-
-	if [ -z "$CONFIG_FSP_USE_REPO" ] && \
-	    [ -z "$CONFIG_FSP_FULL_FD" ] && \
-	    [ -n "$CONFIG_FSP_M_FILE" ]; then
-
+	[ -z "$CONFIG_FSP_USE_REPO" ] && [ -z "$CONFIG_FSP_FULL_FD" ] && \
+	    [ -n "$CONFIG_FSP_M_FILE" ] && \
 		vfile "$CONFIG_FSP_M_CBFS" "$CONFIG_FSP_M_FILE" fsp --xip
-	fi
-
-	if [ -z "$CONFIG_FSP_USE_REPO" ] && \
-	    [ -z "$CONFIG_FSP_FULL_FD" ] && \
-	   [ -n "$CONFIG_FSP_S_FILE" ]; then
-
+	[ -z "$CONFIG_FSP_USE_REPO" ] && [ -z "$CONFIG_FSP_FULL_FD" ] && \
+	   [ -n "$CONFIG_FSP_S_FILE" ] && \
 		vfile "$CONFIG_FSP_S_CBFS" "$CONFIG_FSP_S_FILE" fsp
-	fi

 	xchanged="y"

@@ -859,10 +522,7 @@ add_vfiles()

 vfile()
 {
-	if [ "$2" = "/dev/null" ]; then
-
-		return 0
-	fi
+	[ "$2" = "/dev/null" ] && return 0

 	cbfsname="$1"
 	_dest="${2##*../}"
@@ -870,50 +530,33 @@ vfile()

 	_offset=""

-	if [ "$blobtype" = "fsp" ] && \
-	    [ $# -gt 3 ]; then
-
+	if [ "$blobtype" = "fsp" ] && [ $# -gt 3 ]; then
 		_offset="$4"
-
-	elif [ $# -gt 3 ] && \
-	    _offset="-b $4" && [ -z "$4" ]; then
-
+	elif [ $# -gt 3 ] && _offset="-b $4" && [ -z "$4" ]; then
 		err "$rom: offset given but empty (undefined)" "vfile" "$@"
 	fi

-	if [ "$nuke" != "nuke" ]; then
-
+	[ "$nuke" != "nuke" ] && \
 		x_ e "$_dest" f
-	fi

 	if [ "$cbfsname" = "IFD" ]; then
-
 		if [ "$nuke" = "nuke" ]; then
-
 			x_ "$ifdtool" $ifdprefix --nuke $blobtype "$rom" \
 			    -O "$rom"
 		else
-
 			x_ "$ifdtool" $ifdprefix -i $blobtype:$_dest "$rom" \
 			    -O "$rom"
 		fi
-
 	elif [ "$nuke" = "nuke" ]; then
-
 		x_ "$cbfstool" "$rom" remove -n "$cbfsname"
-
 	elif [ "$blobtype" = "stage" ]; then
-
 		# the only stage we handle is refcode

 		x_ rm -f "$xbtmp/refcode"
-
 		x_ "$rmodtool" -i "$_dest" -o "$xbtmp/refcode"
 		x_ "$cbfstool" "$rom" add-stage -f "$xbtmp/refcode" \
 		    -n "$cbfsname" -t stage
-
 	else
-
 		x_ "$cbfstool" "$rom" add -f "$_dest" -n "$cbfsname" \
 		    -t $blobtype $_offset
 	fi
@@ -924,13 +567,11 @@ vfile()
 # must be called from a subshell
 check_vendor_hashes()
 {
-	build_sbase
+	eval "$build_sbase"

 	x_ cd "$tmpromdir"

-	if [ "$has_hashes" != "n" ] && \
-	    [ "$nuke" != "nuke" ]; then
-
+	if [ "$has_hashes" != "n" ] && [ "$nuke" != "nuke" ]; then
 		( x_ "$sha512sum" -c "$hashfile" ) || \
 		    x_ sha1sum -c "$hashfile"
 	fi
@@ -2,16 +2,23 @@

 # Copyright (c) 2022 Caleb La Grange <thonkpeasant@protonmail.com>
 # Copyright (c) 2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
-# Copyright (c) 2020-2025 Leah Rowe <leah@libreboot.org>
+# Copyright (c) 2020-2026 Leah Rowe <leah@libreboot.org>
 # Copyright (c) 2025 Alper Nebi Yasak <alpernebiyasak@gmail.com>

 cbfstool="elf/coreboot/default/cbfstool"
 rmodtool="elf/coreboot/default/rmodtool"

+build_sbase="[ ! -f \"\$sha512sum\" ] && x_ make -C util/sbase"
+
+newvar()
+{
+	printf "%s\n" "$*" | \
+	    awk '{ for (i=1; i<=NF; i++) $i = $i "=;"; print }'; :
+}
+
 mkrom_tarball()
 {
 	update_xbmkver "$1"
-
 	mktarball "$1" "${1%/*}/${relname}_${1##*/}.tar.xz"

 	x_ rm -Rf "$1"
@@ -21,6 +28,10 @@ update_xbmkver()
 {
 	xbmk_sanitize_version

+	if [ -z "${version-}" ] || [ -z "${versiondate-}" ]; then
+		err "version and/or versiondate unset" "update_xbmkver" "$@"
+	fi
+
 	printf "%s\n" "$version" > "$1/.version" || \
 	    err "can't write '$1'" "update_xbmkver" "$@"; :

@@ -28,36 +39,26 @@ update_xbmkver()
 	    err "can't write '$versiondate'" "update_xbmkver" "$@"; :
 }

+version()
+{
+	printf "%s\nWebsite: %s\n" "$relname" "$projectsite"
+}
+
 xbmk_sanitize_version()
 {
-	if [ -z "$version" ]; then
-
-		return 0
-	fi
-
-	version="`printf "%s\n" "$version" | sed -e 's/\t//g'`"
-	version="`printf "%s\n" "$version" | sed -e 's/\ //g'`"
-	version="`printf "%s\n" "$version" | sed -e 's/\.\.//g'`"
-	version="`printf "%s\n" "$version" | sed -e 's/\.\///g'`"
-	version="`printf "%s\n" "$version" | sed -e 's/\//-/g'`"
-
-	version="${version#-}"
-
-	if [ -z "$version" ]; then
-
+	[ -n "$version" ] && version="`printf '%s\n' "$version" | sed \
+		's/[[:space:]]//g; s/\.\.//g; s/\.\///g; s/\//-/g; s/^-//'`" \
+	&& [ -z "$version" ] && \
 		err "'version' empty after sanitization" \
-		    "xbmk_sanitize_version" "$@"
-	fi
+		    "xbmk_sanitize_version" "$@"; :
 }

 mktarball()
 {
 	printf "Creating tar archive '%s' from directory '%s'\n" "$2" "$1"

-	if [ "${2%/*}" != "$2" ]; then
-
-		x_ xbmkdir "${2%/*}"
-	fi
+	[ "${2%/*}" != "$2" ] && \
+		x_ mkdir -p "${2%/*}"

 	x_ tar -c "$1" | xz -T$XBMK_THREADS -9e > "$2" || \
 	    err "can't make tarball '$1'" "mktarball" "$@"
@@ -66,78 +67,27 @@ mktarball()
 e()
 {
 	es_t="e"
-
-	if [ $# -gt 1 ]; then
-
+	[ $# -gt 1 ] && \
 		es_t="$2"
-	fi

 	es2="already exists"
 	estr="[ -$es_t \"\$1\" ] || return 1"

 	if [ $# -gt 2 ]; then
-
 		estr="[ -$es_t \"\$1\" ] && return 1"
 		es2="missing"
 	fi

 	eval "$estr"
-
 	printf "%s %s\n" "$1" "$es2" 1>&2
 }

-setvars()
-{
-	_setvars=""
-
-	if [ $# -lt 2 ]; then
-
-		return 0
-	fi
-
-	val="$1"
-
-	shift 1
-
-	while [ $# -gt 0 ]; do
-
-		printf "%s=\"%s\"\n" "$1" "$val"
-
-		shift 1
-	done
-}
-
-# return 0 if project is single-tree, otherwise 1
-# e.g. coreboot is multi-tree, so 1
 singletree()
 {
 	( fx_ "eval exit 1 && err" find "config/$1/"*/ -type f \
 	    -name "target.cfg" ) || return 1; :
 }

-findpath()
-{
-	if [ $# -lt 1 ]; then
-
-		err "findpath: No arguments provided" "findpath" "$@"
-	fi
-
-	while [ $# -gt 0 ]; do
-
-		found="`readlink -f "$1" 2>/dev/null`" || return 1; :
-
-		if [ -z "$found" ]; then
-
-			found="`realpath "$1" 2>/dev/null`" || \
-			    return 1
-		fi
-
-		printf "%s\n" "$found"
-
-		shift 1
-	done
-}
-
 pad_one_byte()
 {
 	paddedfile="`mktemp || err "mktemp pad_one_byte"`" || \
@@ -154,58 +104,31 @@ unpad_one_byte()
 	xromsize="$(expr $(stat -c '%s' "$1") - 1)" || \
 	    err "can't increment file size" "unpad_one_byte" "$@"

-	if [ $xromsize -lt 524288 ]; then
-
+	[ $xromsize -lt 524288 ] && \
 		err "too small, $xromsize: $1" "unpad_one_byte" "$@"
-	fi

 	unpaddedfile="`mktemp || err "mktemp unpad_one_byte"`" || \
 	    err "can't make tmp file" "unpad_one_byte" "$@"

 	x_ dd if="$1" of="$unpaddedfile" bs=$xromsize count=1
-
 	x_ mv "$unpaddedfile" "$1"
 }

-build_sbase()
-{
-	if [ ! -f "$sha512sum" ]; then
-
-		x_ make -C "$xbmkpwd/util/sbase"
-	fi
-}
-
 remkdir()
 {
 	x_ rm -Rf "$@"
-
-	x_ xbmkdir "$@"
-}
-
-xbmkdir()
-{
-	while [ $# -gt 0 ]; do
-
-		if [ ! -d "$1" ]; then
-
-			x_ mkdir -p "$1"
-		fi
-
-		shift 1
-	done
+	x_ mkdir -p "$@"
 }

 fx_()
 {
 	xchk fx_ "$@"
-
 	xcmd="$1"

 	xfile="`mktemp || err "can't create tmpfile"`" || \
 	    err "can't make tmpfile" "fx_" "$@"

 	x_ rm -f "$xfile"
-
 	x_ touch "$xfile"

 	shift 1
@@ -214,7 +137,6 @@ fx_()
 	    err "can't sort to '$xfile'" "fx_" "$xcmd" "$@"

 	dx_ "$xcmd" "$xfile" || :
-
 	x_ rm -f "$xfile"
 }

@@ -222,90 +144,18 @@ dx_()
 {
 	xchk dx_ "$@"

-	if [ ! -f "$2" ]; then
-
-		return 0
-	fi
+	[ ! -f "$2" ] && return 0

 	while read -r fx; do
-
 		$1 "$fx" || return 1; :
-
-	done < "$2" \
-	    || err "cannot read '$2'" "dx_" "$@"; :
-}
-
-x_()
-{
-	if [ $# -lt 1 ]; then
-
-		return 0
-
-	elif [ -z "$1" ]; then
-
-		err "Empty first arg" "x_" "$@"
-
-	else
-
-		"$@" || err "Unhandled error" "x_" "$@"
-	fi
+	done < "$2" || err "cannot read '$2'" "dx_" "$@"; :
 }

 xchk()
 {
 	if [ $# -lt 3 ]; then
-
 		err "$1 needs at least two arguments" "xchk" "$@"
-
-	elif [ -z "$2" ] || \
-	    [ -z "$3" ]; then
-
+	elif [ -z "$2" ] || [ -z "$3" ]; then
 		err "arguments must not be empty" "xchk" "$@"
 	fi
 }
-
-err()
-{
-	if [ $# -eq 1 ]; then
-
-		printf "ERROR %s: %s\n" "$0" "$1" 1>&2 || :
-
-	elif [ $# -gt 1 ]; then
-
-		printf "ERROR %s: %s: in command with args: " "$0" "$1" 1>&2
-
-		shift 1
-
-		xprintf "$@" 1>&2
-
-	else
-
-		printf "ERROR, but no arguments provided to err\n" 1>&2
-	fi
-
-	exit 1
-}
-
-xprintf()
-{
-	xprintfargs=0
-
-	while [ $# -gt 0 ]; do
-
-		printf "\"%s\"" "$1"
-
-		if [ $# -gt 1 ]; then
-
-			printf " "
-		fi
-
-		xprintfargs=1
-
-		shift 1
-	done
-
-	if [ $xprintfargs -gt 0 ]; then
-
-		printf "\n"
-	fi
-}
@@ -1,71 +1,32 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

-# Copyright (c) 2023-2025 Leah Rowe <leah@libreboot.org>
+# Copyright (c) 2023-2026 Leah Rowe <leah@libreboot.org>

-reldest=""
-reldir=""
-relmode=""
-rsrc=""
-vdir=""
+eval "`newvar reldest reldir rsrc vdir`"

 release()
 {
 	export XBMK_RELEASE="y"
-
 	reldir="release"

-	while getopts m: option; do
-
-		if [ -z "$OPTARG" ]; then
-
-			err "empty argument not allowed" "release" "$@"
-		fi
-
-		case "$option" in
-
-		m)
-			relmode="$OPTARG"
-			;;
-
-		*)
-			err "invalid option '-$option'" "release" "$@"
-			;;
-
-		esac
-	done
-
 	reldest="$reldir/$version"
-
-	if [ -e "$reldest" ]; then
-
+	[ -e "$reldest" ] && \
 		err "already exists: \"$reldest\"" "release" "$@"
-	fi

 	vdir="`mktemp -d || err "can't make vdir"`" || \
 	    err "can't make tmp vdir" "release" "$@"
-
 	vdir="$vdir/$version"
-
 	rsrc="$vdir/${relname}_src"

 	remkdir "$vdir"
-
 	x_ git clone . "$rsrc"
-
 	update_xbmkver "$rsrc"

-	prep_release src
-	prep_release tarball
-
-	if [ "$relmode" != "src" ]; then
-
-		prep_release bin
-	fi
+	forx 'prep_release %s' src tarball bin

 	x_ rm -Rf "$rsrc"

-	x_ xbmkdir "$reldir"
-
+	x_ mkdir -p "$reldir"
 	x_ mv "$vdir" "$reldir"
 	x_ rm -Rf "${vdir%"/$version"}"

@@ -75,17 +36,13 @@ release()
 prep_release()
 {
 	(
-		if [ "$1" != "tarball" ]; then
+	if [ "$1" != "tarball" ]; then
+		x_ cd "$rsrc"
+		[ ! -e "cache" ] && \
+			x_ ln -s "$XBMK_CACHE" "cache"; :
+	fi

-			x_ cd "$rsrc"
-
-			if [ ! -e "cache" ]; then
-
-				x_ ln -s "$XBMK_CACHE" "cache"
-			fi
-		fi
-
-		prep_release_$1
+	prep_release_$1

 	) || err "can't prep release $1" "prep_release" "$@"
 }
@@ -96,23 +53,18 @@ prep_release_src()

 	x_ ./mk -f

-	fx_ "x_ rm -Rf" x_ find . -name ".git"
-	fx_ "x_ rm -Rf" x_ find . -name ".gitmodules"
+	forx 'fx_ \"x_ rm -Rf\" x_ find . -name \".%s\"' git gitmodules

-	# delete unwanted files from the release
 	( fx_ nuke x_ find config -type f -name "nuke.list" ) || \
 	    err "can't prune project files" "prep_release_src" "$@"; :
 }

-# delete unwanted files from the release
 nuke()
 {
 	r="$rsrc/src/${1#config/}"

 	if [ -d "${r%/*}" ]; then
-
 		x_ cd "${r%/*}"
-
 		dx_ "x_ rm -Rf" "$rsrc/$1"
 	fi
 }
@@ -124,14 +76,12 @@ prep_release_tarball()
 	    err "can't create '$rsrc/CHANGELOG'" "prep_release_tarball" "$@" 

 	x_ rm -f "$rsrc/lock" "$rsrc/cache"
-
 	x_ rm -Rf "$rsrc/xbmkwd" "$rsrc/util/sbase"
-
 	x_ mv "$rsrc/util/sbase2" "$rsrc/util/sbase"

 	(
-		x_ cd "${rsrc%/*}"
-		x_ mktarball "${rsrc##*/}" "${rsrc##*/}.tar.xz"
+	x_ cd "${rsrc%/*}"
+	x_ mktarball "${rsrc##*/}" "${rsrc##*/}.tar.xz"

 	) || err "can't create src tarball" "prep_release_tarball" "$@"; :
 }
@@ -139,15 +89,11 @@ prep_release_tarball()
 prep_release_bin()
 {
 	x_ ./mk -d coreboot
-	x_ ./mk -b coreboot

-	x_ ./mk -b pico-serprog
+	forx 'x_ ./mk -b' coreboot pico-serprog stm32-vserprog pcsx-redux

-	x_ ./mk -b stm32-vserprog
-
-	x_ ./mk -b pcsx-redux
-
-	fx_ mkrom_tarball x_ find bin -maxdepth 1 -type d -name "serprog_*"
+	fx_ mkrom_tarball x_ find bin -mindepth 1 -maxdepth 1 \
+	    -type d -name "serprog_*"

 	x_ mv bin ../roms
 }
@@ -1,927 +0,0 @@
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-# Copyright (c) 2022-2023 Alper Nebi Yasak <alpernebiyasak@gmail.com>
-# Copyright (c) 2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
-# Copyright (c) 2023-2025 Leah Rowe <leah@libreboot.org>
-
-# flag e.g. ./mk -b <-- mkflag would be "b"
-flag=""
-
-# macros, overridden depending on the flag
-if_do_make=""
-if_dry_build=":"
-if_not_do_make=":"
-if_not_dry_build=""
-
-autoconfargs=""
-autogenargs=""
-badhash=""
-badtghash=""
-bootstrapargs=""
-build_depend=""
-buildtype=""
-cleanargs=""
-cmakedir=""
-cmd=""
-defconfig=""
-dest_dir=""
-elfdir=""
-forcepull=""
-gccdir=""
-gccfull=""
-gccver=""
-gnatdir=""
-gnatfull=""
-gnatver=""
-listfile=""
-makeargs=""
-mdir=""
-mkhelper=""
-mkhelpercfg=""
-mode=""
-postmake=""
-premake=""
-project=""
-release=""
-rev=""
-srcdir=""
-target=""
-target_dir=""
-targets=""
-tree=""
-xarch=""
-xgcctree=""
-xlang=""
-
-trees()
-{
-	flags="f:F:b:m:u:c:x:s:l:n:d:"
-
-	while getopts $flags option; do
-
-		if [ -n "$flag" ]; then
-
-			err "only one flag is permitted" "trees" "$@"
-		fi
-
-		flag="$1"
-
-		# the "mode" variable is affixed to a make command, example:
-		# ./mk -m coreboot does: make menuconfig -C src/coreboot/tree
-
-		case "$flag" in
-
-		-d)
-			# -d is similar to -b, except that
-			# a large number of operations will be
-			# skipped. these are "if_not_dry_build build" scenarios
-			# where only a subset of build tasks are done,
-			# and $if_not_dry_build is prefixed to skipped commands
-
-			if_dry_build=""
-			if_not_dry_build=":"
-			;;
-
-		-b) : ;;
-
-		-u) mode="oldconfig" ;;
-
-		-m) mode="menuconfig" ;;
-
-		-c) mode="distclean" ;;
-
-		-x) mode="crossgcc-clean" ;;
-
-		-f|-F) # download source code for a project
-			# macros. colon means false.
-
-			if_do_make=":"
-			if_dry_build=""
-			if_not_do_make=""
-			if_not_dry_build=":"
-			if [ "$flag" = "-F" ]; then
-				# don't skip git fetch/pull on cached src
-
-				forcepull="y"
-			fi
-			;;
-
-		-s) mode="savedefconfig" ;;
-
-		-l) mode="olddefconfig" ;;
-
-		-n) mode="nconfig" ;;
-
-		*) err "invalid option '-$option'" "trees" "$@" ;;
-
-		esac
-
-		if [ -z "${OPTARG+x}" ]; then
-
-			shift 1
-
-			break
-		fi
-
-		project="${OPTARG#src/}"
-		project="${project#config/git/}"
-
-		shift 2
-	done
-
-	if [ -z "$flag" ]; then
-
-		err "missing flag ($flags)" "trees" "$@"
-
-	elif [ -z "$project" ]; then
-
-		fx_ "x_ ./mk $flag" x_ ls -1 config/git
-
-		return 1
-
-	elif [ ! -f "config/git/$project/pkg.cfg" ]; then
-
-		err "config/git/$project/pkg.cfg missing" "trees" "$@"
-	fi
-
-	elfdir="elf/$project"
-	datadir="config/data/$project"
-	configdir="config/$project"
-	srcdir="src/$project"
-	dest_dir="$elfdir"
-
-	listfile="$datadir/build.list"
-
-	if [ ! -f "$listfile" ]; then
-
-		listfile="" # build.list is optional on all projects
-	fi
-
-	mkhelpercfg="$datadir/mkhelper.cfg"
-
-	if e "$mkhelpercfg" f missing; then
-
-		mkhelpercfg="$xbtmp/mkhelper.cfg"
-
-		x_ touch "$mkhelpercfg"
-	fi
-
-	targets="$*"
-	cmd="build_targets $targets"
-
-	if singletree "$project"; then
-
-		cmd="build_project"
-	fi
-
-	remkdir "${tmpgit%/*}"
-}
-
-build_project()
-{
-	if ! configure_project "$configdir"; then
-
-		return 0
-
-	elif [ -f "$listfile" ]; then
-
-		if ! $if_not_dry_build elfcheck; then
-
-			return 0
-		fi
-	fi
-
-	if [ "$mode" = "distclean" ]; then
-
-		mode="clean"
-	fi
-
-	if ! run_make_command; then
-
-		return 0
-	fi
-
-	if [ -z "$mode" ]; then
-
-		$if_not_dry_build \
-			copy_elf; :
-	fi
-}
-
-build_targets()
-{
-	if [ ! -d "$configdir" ]; then
-
-		err "directory '$configdir' doesn't exist" "build_targets" "$@"
-
-	elif [ $# -lt 1 ]; then
-
-		targets="$(ls -1 "$configdir")" || \
-		    err "'$configdir': can't list targets" "build_targets" "$@"
-	fi
-
-	for x in $targets; do
-
-		unset CROSS_COMPILE
-		export PATH="$xbmkpath"
-
-		if [ "$x" = "list" ]; then
-
-			x_ ls -1 "config/$project"
-
-			listfile=""
-
-			break
-		fi
-
-		printf "'make %s', '%s', '%s'\n" "$mode" "$project" "$x"
-
-		target="$x"
-
-		x_ handle_defconfig
-
-		if [ -z "$mode" ]; then
-
-			x_ $postmake
-		fi
-	done; :
-}
-
-handle_defconfig()
-{
-	target_dir="$configdir/$target"
-
-	if [ ! -f "CHANGELOG" ]; then
-
-		fetch_project "$project"
-	fi
-
-	if ! configure_project "$target_dir"; then
-
-		return 0
-	fi
-
-	if [ -z "$tree" ]; then
-
-		err "$configdir: 'tree' not set" "handle_defconfig" "$@"
-	fi
-
-	srcdir="src/$project/$tree"
-
-	if [ "$mode" = "${mode%clean}" ] && \
-	    [ ! -d "$srcdir" ]; then
-
-		return 0
-	fi
-
-	for y in "$target_dir/config"/*; do
-
-		if [ "$flag" != "-d" ] && \
-		    [ ! -f "$y" ]; then
-
-			continue
-
-		elif [ "$flag" != "-d" ]; then
-
-			defconfig="$y"
-		fi
-
-		if [ -z "$mode" ]; then
-
-			check_defconfig || continue; :
-		fi
-
-		if [ -z "$mode" ]; then
-
-			for _xarch in $xarch; do
-
-				$if_dry_build \
-					break
-
-				if [ -n "$_xarch" ]; then
-
-					check_cross_compiler "$_xarch"
-				fi
-			done; :
-		fi
-
-		handle_makefile
-
-		if [ -z "$mode" ]; then
-
-			$if_not_dry_build \
-				copy_elf
-		fi
-	done; :
-}
-
-configure_project()
-{
-	tcfg="$1/target.cfg"
-
-	autoconfargs=""
-	badhash=""
-	badtghash=""
-	bootstrapargs=""
-	build_depend=""
-	buildtype=""
-	cleanargs=""
-	makeargs=""
-	mkhelper=""
-	postmake=""
-	premake=""
-	release=""
-	xarch=""
-	xgcctree=""
-	xlang=""
-
-	if [ ! -f "$tcfg" ]; then
-
-		buildtype="auto"
-	fi
-
-	# globally initialise all variables for a source tree / target:
-
-	if e "$datadir/mkhelper.cfg" f; then
-
-		. "$datadir/mkhelper.cfg" || \
-		    err "Can't read '$datadir/mkhelper.cfg'" \
-		    "configure_project" "$@"
-	fi
-
-	# override target/tree specific variables from per-target config:
-
-	while e "$tcfg" f || \
-	    [ "$cmd" != "build_project" ]; do
-
-		# TODO: implement infinite loop detection here, caused
-		#       by project targets pointing to other targets/trees
-		#       when then ultimate point back repeatedly; this is
-		#       currently avoided simply by careful configuration.
-		#       temporary files per tree/target name could be created
-		#	per iteration, and then checked the next time
-
-		printf "Loading %s config: %s\n" "$project" "$tcfg"
-
-		rev=""
-		tree=""
-
-		. "$tcfg" || \
-		    err "Can't read '$tcfg'" "configure_project" "$@"
-
-		if [ "$flag" = "-d" ]; then
-
-			build_depend="" # dry run
-		fi
-
-		if [ "$cmd" = "build_project" ]; then
-
-			# single-tree, so it can't be a target pointing
-			# to a main source tree
-
-			break
-		fi
-
-		$if_do_make \
-			break
-
-		if [ "${tcfg%/*/target.cfg}" = "${tcfg%"/$tree/target.cfg"}" ]
-		then
-
-			# we have found the main source tree that
-			# a given target uses; no need to continue
-
-			break
-
-		else
-
-			tcfg="${tcfg%/*/target.cfg}/$tree/target.cfg"
-		fi
-
-	done
-
-	if [ "$XBMK_RELEASE" = "y" ] && \
-	    [ "$release" = "n" ]; then
-
-		return 1
-	fi
-
-	if [ -n "$buildtype" ] && \
-	    [ "${mode%config}" != "$mode" ]; then
-
-		return 1
-	fi
-
-	if [ -z "$mode" ]; then
-
-		$if_not_dry_build \
-			build_dependencies
-	fi
-
-	mdir="$xbmkpwd/config/submodule/$project"
-
-	if [ -n "$tree" ]; then
-
-		mdir="$mdir/$tree"
-	fi
-
-	if [ ! -f "CHANGELOG" ]; then
-
-		delete_old_project_files
-
-		$if_not_do_make \
-			fetch_${cmd#build_}
-	fi
-
-	$if_not_do_make \
-		return 1
-
-	x_ ./mk -f "$project" "$target"
-}
-
-# projects can specify which other projects
-# to build first, as declared dependencies:
-
-build_dependencies()
-{
-	for bd in $build_depend; do
-
-		bd_project="${bd%%/*}"
-		bd_tree="${bd##*/}"
-
-		if [ -z "$bd_project" ]; then
-
-			$if_not_dry_build \
-				err "$project/$tree: !bd '$bd'" \
-				    "build_dependencies" "$@"
-		fi
-
-		if [ "${bd##*/}" = "$bd" ]; then
-
-			bd_tree=""
-		fi
-
-		if [ -n "$bd_project" ]; then
-
-			$if_not_dry_build \
-				x_ ./mk -b $bd_project $bd_tree; :
-		fi
-	done; :
-}
-
-# delete_old_project_files along with project_up_to_date,
-# concatenates the sha512sum hashes of all files related to
-# a project, tree or target, then gets the sha512sum of that
-# concatenation. this is checked against any existing
-# calculation previously cached; if the result differs, or
-# nothing was previously stored, we know to delete resources
-# such as builds, project sources and so on, for auto-rebuild:
-
-delete_old_project_files()
-{
-	# delete an entire source tree along with its builds:
-	if ! project_up_to_date hash "$tree" badhash "$datadir" \
-	    "$configdir/$tree" "$mdir"; then
-
-		x_ rm -Rf "src/$project/$tree" "elf/$project/$tree"
-	fi
-
-	x_ cp "$xbtmp/new.hash" "$XBMK_CACHE/hash/$project$tree"
-
-	if singletree "$project" || \
-	    [ -z "$target" ] || \
-	    [ "$target" = "$tree" ]; then
-
-		return 0
-	fi
-
-	# delete only the builds of a given target, but not src.
-	# this is useful when only the target config changes, for
-	# example x200_8mb coreboot configs change, but not coreboot:
-
-	if ! project_up_to_date tghash "$target" badtghash "$configdir/$target"
-	then
-
-		x_ rm -Rf "elf/$project/$tree/$target"
-	fi
-
-	x_ cp "$xbtmp/new.hash" "$XBMK_CACHE/tghash/$project$target"
-}
-
-project_up_to_date()
-{
-	old_hash=""
-	hash=""
-
-	hashdir="$1"
-	hashname="$2"
-	badhashvar="$3"
-
-	shift 3
-
-	x_ xbmkdir "$XBMK_CACHE/$hashdir"
-
-	if [ -f "$XBMK_CACHE/$hashdir/$project$hashname" ]; then
-
-		read -r old_hash < "$XBMK_CACHE/$hashdir/$project$hashname" \
-		    || err \
-		    "$hashdir: err '$XBMK_CACHE/$hashdir/$project$hashname'" \
-		    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" \
-		    "$@"
-	fi
-
-	build_sbase
-
-	fx_ "x_ util/sbase/sha512sum" find "$@" -type f -not -path \
-	    "*/.git*/*" | awk '{print $1}' > "$xbtmp/tmp.hash" || \
-	    err "!h $project $hashdir" \
-	    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@"
-
-	hash="$(x_ "$sha512sum" "$xbtmp/tmp.hash" | awk '{print $1}' || \
-	    err)" || err "$hashname: Can't read sha512 of '$xbtmp/tmp.hash'" \
-	    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@"
-
-	if [ "$hash" != "$old_hash" ] || \
-	    [ ! -f "$XBMK_CACHE/$hashdir/$project$hashname" ]; then
-
-		eval "$badhashvar=\"y\""
-	fi
-
-	printf "%s\n" "$hash" > "$xbtmp/new.hash" || \
-	    err "!mkhash $xbtmp/new.hash ($hashdir $hashname $badhashvar)" \
-	    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@"
-
-	eval "[ \"\$$badhashvar\" = \"y\" ] && return 1"; :
-}
-
-check_cross_compiler()
-{
-	cbdir="src/coreboot/$tree"
-
-	if [ "$project" != "coreboot" ]; then
-
-		cbdir="src/coreboot/default"
-	fi
-
-	if [ -n "$xgcctree" ]; then
-
-		cbdir="src/coreboot/$xgcctree"
-	fi
-
-	xfix="${1%-*}"
-
-	if [ "$xfix" = "x86_64" ]; then
-
-		xfix="x64"
-	fi
-
-	xgccfile="elf/coreboot/$tree/xgcc_${xfix}_was_compiled"
-	xgccargs="crossgcc-$xfix UPDATED_SUBMODULES=1 CPUS=$XBMK_THREADS"
-
-	x_ ./mk -f coreboot "${cbdir#src/coreboot/}"
-
-	x_ xbmkdir "elf/coreboot/$tree" # TODO: is this needed?
-
-	export PATH="$xbmkpwd/$cbdir/util/crossgcc/xgcc/bin:$PATH"
-
-	export CROSS_COMPILE="${xarch% *}-"
-
-	if [ -n "$xlang" ]; then
-
-		export BUILD_LANGUAGES="$xlang"
-	fi
-
-	if [ -f "$xgccfile" ]; then
-
-		# skip the build, because a build already exists:
-
-		return 0
-	fi
-
-	check_gnu_path gcc gnat || x_ check_gnu_path gnat gcc
-
-	# try twice because xgcc sometimes fails for, like, no reason
-	#
-	make -C "$cbdir" $xgccargs || x_ make -C "$cbdir" $xgccargs
-
-	# this tells subsequent runs that the build was already done:
-	#
-	x_ touch "$xgccfile"
-
-	# reset hostcc in PATH:
-	#
-	remkdir "$xbtmp/gnupath"
-}
-
-# host toolchain version correction:
-
-# fix mismatching gcc/gnat versions on debian trixie/sid. as of december 2024,
-# trixie/sid had gnat-13 as gnat and gcc-14 as gcc, but has gnat-14 in apt. in
-# some cases, gcc 13+14 and gnat-13 are present; or gnat-14 and gcc-14, but
-# gnat in PATH never resolves to gnat-14, because gnat-14 was "experimental"
-
-# note that this was implemented for debian trixie-testing, but this same
-# issue will likely occur in future distros, including newer debian testing
-# releases. this just matches up the versions of each toolchain component.
-
-check_gnu_path()
-{
-	if ! command -v "$1" 1>/dev/null; then
-
-		err "Host '$1' unavailable" "check_gnu_path" "$@"
-	fi
-
-	gccdir=""
-	gccfull=""
-	gccver=""
-	gnatdir=""
-	gnatfull=""
-	gnatver=""
-
-	if host_gcc_gnat_match "$@"; then
-
-		return 0
-
-	elif ! match_gcc_gnat_versions "$@"; then
-
-		return 1
-	fi
-}
-
-# check if gcc/gnat versions already match:
-
-host_gcc_gnat_match()
-{
-	if ! gnu_setver "$1" "$1"; then
-
-		err "Command '$1' unavailable." "check_gnu_path" "$@"
-	fi
-
-	gnu_setver "$2" "$2" || :
-
-	eval "[ -z \"\$$1ver\" ] && err \"Cannot detect host '$1' version\""
-
-	if [ "$gnatfull" != "$gccfull" ]; then
-
-		# non-matching host gcc/gnat versions
-
-		return 1
-	fi
-}
-
-# find all host gcc/gnat versions, matching them up in PATH:
-
-match_gcc_gnat_versions()
-{
-	eval "$1dir=\"$(dirname "$(command -v "$1")")\""
-
-	eval "_gnudir=\"\$$1dir\""
-	eval "_gnuver=\"\$$1ver\""
-
-	for _bin in "$_gnudir/$2-"*; do
-
-		if [ "${_bin#"$_gnudir/$2-"}" = "$_gnuver" ] && [ -x "$_bin" ]
-		then
-
-			_gnuver="${_bin#"$_gnudir/$2-"}"
-			break
-		fi
-	done
-
-	if ! gnu_setver "$2" "$_gnudir/$2-$_gnuver"; then
-
-		return 1
-
-	elif [ "$gnatfull" != "$gccfull" ]; then
-
-		return 1
-	fi
-
-	( link_gcc_gnat_versions "$@" "$_gnudir" "$_gnuver" ) || \
-	    err "Can't link '$2-$_gnuver' '$_gnudir'" "check_gnu_path" "$@"; :
-}
-
-# create symlinks in PATH, so that the GCC/GNAT versions match:
-
-link_gcc_gnat_versions()
-{
-	_gnudir="$3"
-	_gnuver="$4"
-
-	remkdir "$xbtmp/gnupath"
-
-	x_ cd "$xbtmp/gnupath"
-
-	for _gnubin in "$_gnudir/$2"*"-$_gnuver"; do
-
-		_gnuutil="${_gnubin##*/}"
-
-		if [ -e "$_gnubin" ]; then
-
-			x_ ln -s "$_gnubin" "${_gnuutil%"-$_gnuver"}"
-		fi
-	done
-}
-
-# get the gcc/gnat version
-# fail: return 1 if util not found
-gnu_setver()
-{
-	eval "$2 --version 1>/dev/null 2>/dev/null || return 1"
-
-	eval "$1ver=\"`"$2" --version 2>/dev/null | head -n1`\""
-	eval "$1ver=\"\${$1ver##* }\""
-	eval "$1full=\"\$$1ver\""
-	eval "$1ver=\"\${$1ver%%.*}\""; :
-}
-
-check_defconfig()
-{
-	if [ ! -f "$defconfig" ]; then
-
-		$if_not_dry_build \
-			err "$project/$target: no config" "check_defconfig" "$@"
-	fi
-
-	dest_dir="$elfdir/$tree/$target/${defconfig#"$target_dir/config/"}"
-
-	# skip build if a previous one exists:
-
-	$if_dry_build \
-		return 0
-
-	if ! elfcheck; then
-
-		return 1
-	fi
-}
-
-elfcheck()
-{
-	# TODO: *STILL* very hacky check. do it properly (based on build.list)
-
-	# extremely hacky check that glues the entire universe together
-
-	# beware demons
-
-	( fx_ "eval exit 1 && err" find "$dest_dir" -type f ) || return 1; :
-}
-
-handle_makefile()
-{
-	if $if_not_dry_build check_makefile "$srcdir"; then
-
-		$if_not_dry_build \
-			x_ make -C "$srcdir" $cleanargs clean
-	fi
-
-	if [ -f "$defconfig" ]; then
-
-		x_ cp "$defconfig" "$srcdir/.config"
-	fi
-
-	run_make_command || \
-	    err "no makefile!" "handle_makefile" "$@"
-
-	_copy=".config"
-
-	if [ "$mode" = "savedefconfig" ]; then
-
-		_copy="defconfig"
-	fi
-
-	if [ "${mode%config}" != "$mode" ]; then
-
-		$if_not_dry_build \
-			x_ cp "$srcdir/$_copy" "$defconfig"; :
-	fi
-
-	if [ -e "$srcdir/.git" ] && \
-	   [ "$project" = "u-boot" ] && \
-	    [ "$mode" = "distclean" ]; then
-
-		$if_not_dry_build \
-			x_ git -C "$srcdir" $cleanargs clean -fdx; :
-	fi
-}
-
-run_make_command()
-{
-	if [ -z "$mode" ]; then
-		x_ $premake
-	fi
-
-	if $if_not_dry_build check_cmake "$srcdir"; then
-
-		if [ -z "$mode" ]; then
-
-			$if_not_dry_build \
-				check_autoconf "$srcdir"
-		fi
-	fi
-
-	if ! $if_not_dry_build check_makefile "$srcdir"; then
-
-		return 1
-	fi
-
-	$if_not_dry_build \
-		x_ make -C "$srcdir" $mode -j$XBMK_THREADS $makeargs
-
-	if [ -z "$mode" ]; then
-
-		x_ $mkhelper
-	fi
-
-	if ! check_makefile "$srcdir"; then
-
-		return 0
-	fi
-
-	if [ "$mode" = "clean" ]; then
-
-		$if_dry_build \
-			return 0
-
-		if ! make -C "$srcdir" $cleanargs distclean; then
-
-			x_ make -C "$srcdir" $cleanargs clean
-		fi
-	fi
-}
-
-check_cmake()
-{
-	$if_dry_build \
-		return 0
-
-	if [ ! -n "$cmakedir" ]; then
-		return 0
-
-	elif ! check_makefile "$1"; then
-
-		if ! cmake -B "$1" "$1/$cmakedir"; then
-
-			x_ check_makefile "$1"
-		fi
-	fi
-
-	x_ check_makefile "$1"; :
-}
-
-check_autoconf()
-{
-	(
-		x_ cd "$1"
-
-		if [ -f "bootstrap" ]; then
-
-			x_ ./bootstrap $bootstrapargs
-		fi
-
-		if [ -f "autogen.sh" ]; then
-
-			x_ ./autogen.sh $autogenargs
-		fi
-
-		if [ -f "configure" ]; then
-
-			x_ ./configure $autoconfargs; :
-		fi
-
-	) || err "can't bootstrap project: $1" "check_autoconf" "$@"; :
-}
-
-check_makefile()
-{
-	if [ ! -f "$1/Makefile" ] && \
-	    [ ! -f "$1/makefile" ] && \
-	    [ ! -f "$1/GNUmakefile" ]; then
-
-		return 1
-	fi
-}
-
-copy_elf()
-{
-	if [ -f "$listfile" ]; then
-
-		x_ xbmkdir "$dest_dir"
-	fi
-
-	if [ -f "$listfile" ]; then
-
-		while read -r f; do
-
-			if [ -f "$srcdir/$f" ]; then
-
-				x_ cp "$srcdir/$f" "$dest_dir"
-			fi
-
-		done < "$listfile" || err \
-		    "cannot read '$listfile'" "copy_elf" "$@"; :
-	fi
-
-	( x_ make clean -C "$srcdir" $cleanargs ) || \
-	    err "can't make-clean '$srcdir'" "copy_elf" "$@"; :
-}
@@ -1,82 +1,550 @@
-#!/usr/bin/env sh
+#!/bin/sh

 # SPDX-License-Identifier: GPL-3.0-or-later

-# Copyright (c) 2020-2025 Leah Rowe <leah@libreboot.org>
+# Copyright (c) 2020-2026 Leah Rowe <leah@libreboot.org>
 # Copyright (c) 2022 Caleb La Grange <thonkpeasant@protonmail.com>
+# Copyright (c) 2022-2023 Alper Nebi Yasak <alpernebiyasak@gmail.com>
+# Copyright (c) 2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>

 set -u -e

-ispwd="true"
+findpath()
+{
+	forx 'readlink -f \"%s\" 2>/dev/null || \
+	    x_ realpath \"%s\" 2>/dev/null' "$@"
+}

-if [ "$0" != "./mk" ]; then
+printf "%s\n" "%s" | grep -o "%s" 1>/dev/null || exit 1 # safety (-o check)
+forx()
+{
+	awkarg="{printf \"${1-};\""
+	shift 1 2>/dev/null || :

-	ispwd="false"
-fi
-if [ "$ispwd" = "true" ] && [ -L "mk" ]; then
+	scount="$(printf "%s\n" "$awkarg" | grep -o "%s" | wc -l)"
+	while [ $scount -gt 0 ]; do
+		awkarg="$awkarg,\$0"
+		scount="$(expr $scount - 1 || :)"
+	done

-	ispwd="false"
-fi
-if [ "$ispwd" = "false" ]; then
+	while [ $# -gt 0 ]; do
+		eval "$(printf '%s\n' "$1" | awk "$awkarg}")"
+		shift 1
+	done
+}
+
+x_()
+{
+	[ $# -lt 1 ] || "$@" || err "UNHANDLED ERROR" "x_" "$@"; :
+}
+
+err()
+{
+	printf '%s\n' "$@" | awk '{printf "\"%s\" ", $0}'
+	printf "ERROR!\n"

-	printf "You must run this in the proper work directory.\n" 1>&2
 	exit 1
-fi
+}
+
+forx 'export %s=\"C.UTF-8\"' LANG LANGUAGE LC_CTYPE LC_NUMERIC LC_TIME \
+    LC_COLLATE LC_MONETARY LC_MESSAGES LC_PAPER LC_NAME LC_ADDRESS \
+    LC_TELEPHONE LC_MEASUREMENT LC_IDENTIFICATION LC_ALL
+
+(
+mk="$0"
+[ "${mk##*/}" != "$mk" ] || \
+    mk="$(x_ command -v "$mk")" || exit 1
+
+mk="$(x_ findpath "$mk")" || exit 1
+xbmkpwd="$(x_ dirname "$mk")" || exit 1
+
+x_ cd "$xbmkpwd"

 . "include/lib.sh"
-. "include/init.sh"
-. "include/vendor.sh"
-. "include/mrc.sh"
-. "include/inject.sh"
-. "include/rom.sh"
-. "include/release.sh"
-. "include/get.sh"
-. "include/chromebook.sh"
+. "include/env/init.sh"
+x_ xbmk_init "$@"
+
+. "include/env/get.sh"
+
+. "include/fw/vendor.sh"
+. "include/fw/mrc.sh"
+. "include/fw/inject.sh"
+. "include/fw/rom.sh"
+
+. "include/mk/release.sh"
+
+_f="${1-}"
+shift 1 2>/dev/null || :
+
+eval "$(printf "version release download inject\n" | awk '{ for (i=1; i<=NF; \
+    i++) $i = "[ \""$i"\" = \"$_f\" ] && x_ "$i" \"$@\" && exit 0;"; print }')"
+
+# macros, overridden depending on the flag
+if_not_do_make=":" # : means false
+if_make_config=":"
+if_build=":" # can be false even if make is true
+if_dry_build=":"
+if_single_tree=":"
+eval "`newvar if_do_make if_not_make_config if_not_build if_not_dry_build`"
+
+eval "`newvar configureargs autogenargs badhash badtghash bootstrapargs \
+    build_depend buildtype cleanargs cmakedir cmd defconfig dest_dir elfdir \
+    flag forcepull listfile makeargs mdir mkhelper mkhelpercfg mode postmake \
+    premake project release rev srcdir target target_dir tree xarch xgcctree \
+    xlang`"

 main()
 {
-	cmd=""
-	if [ $# -gt 0 ]; then
+	flags="f:F:b:m:u:s:l:n:d:"

-		cmd="$1"
-		shift 1
+	while getopts $flags option
+	do
+		[ -n "$flag" ] && \
+			err "only one flag is permitted" "trees" "$@"
+
+		flag="$1"
+
+		# the "mode" variable is affixed to a make command, example:
+		# "$mk" -m coreboot does: make menuconfig -C src/coreboot/tree
+
+		case "$flag" in
+		-b) : ;; # build a source tree
+		-d) # dry builds. -d is like -b but skips many build steps
+			if_dry_build=""
+			if_not_dry_build=":"
+			;;
+		-f|-F) # download source code for a project
+			eval "`newvar if_not_do_make if_dry_build`"
+			if_do_make=":"
+			if_not_dry_build=":"
+			[ "$flag" = "-F" ] && \
+				forcepull="y"; : # never skip git fetch/pull
+			;;
+		-u) mode="oldconfig" ;;
+		-m) mode="menuconfig" ;;
+		-s) mode="savedefconfig" ;;
+		-l) mode="olddefconfig" ;;
+		-n) mode="nconfig" ;;
+		*) err "invalid option '-$option'" "trees" "$@" ;;
+		esac
+
+		if [ -z "$mode" ]; then
+			if_build=""
+			if_not_build=":"
+		fi
+		if [ "${mode%config}" != "$mode" ]; then
+			if_make_config=""
+			if_not_make_config=":"
+		fi
+
+		if [ -z "${OPTARG+x}" ]; then
+			shift 1
+			break
+		fi
+
+		project="${OPTARG#src/}"
+		project="${project#config/git/}"
+
+		shift 2
+	done
+
+	if [ -z "$flag" ]; then
+		err "missing flag ($flags)" "trees" "$@"
+	elif [ -z "$project" ]; then
+		fx_ "x_ "$mk" $flag" x_ ls -1 config/git
+		return 0
+	elif [ ! -f "config/git/$project/pkg.cfg" ]; then
+		err "config/git/$project/pkg.cfg missing" "trees" "$@"
 	fi

-	case "$cmd" in
+	elfdir="elf/$project"
+	datadir="config/data/$project"
+	configdir="config/$project"
+	srcdir="src/$project"
+	dest_dir="$elfdir"

-	version)
+	listfile="$datadir/build.list"
+	[ ! -f "$listfile" ] && \
+		listfile="" # build.list is optional on all projects

-		printf "%s\nWebsite: %s\n" "$relname" "$projectsite"
-		;;
+	mkhelpercfg="$datadir/mkhelper.cfg"
+	if e "$mkhelpercfg" f missing; then
+		mkhelpercfg="$xbtmp/mkhelper.cfg"
+		x_ touch "$mkhelpercfg"
+	fi

-	release|download|inject|prep_mr_import)
+	if singletree "$project"; then
+		cmd="mk_single_tree"
+		if_single_tree=""
+	else
+		cmd="mk_multi_tree"
+	fi

-		$cmd "$@"
-		;;
+	remkdir "${tmpgit%/*}"
+	x_ touch "$mkhelpercfg"

-	-*)
-
-		return 0
-		;;
-	*)
-
-		err "bad command" main "$@"
-		;;
-	esac
-
-	# some commands disable them. turn them back on!
-	set -u -e
-
-	return 1
+	. "$mkhelpercfg"
+	$cmd "$@"
 }

-main "$@" || exit 0
+mk_single_tree()
+{
+	configure_project "$configdir" || \
+		return 0

-. "include/tree.sh"
+	[ ! -f "$listfile" ] || $if_not_dry_build \
+		elfcheck || return 0

-trees "$@" || exit 0
+	run_make_command && $if_build $if_not_dry_build \
+		copy_elf; :
+}

-x_ touch "$mkhelpercfg"
+mk_multi_tree()
+{
+	[ ! -d "$configdir" ] && err "missing '$configdir'" mk_multi_tree "$@"
+	[ $# -lt 1 ] && fx_ mk_multi_tree find "$configdir" \
+		    -mindepth 1 -maxdepth 1 -type d

-. "$mkhelpercfg"
-$cmd
+	[ $# -gt 0 ] && for x in "$@"
+	do
+		unset CROSS_COMPILE
+		export PATH="$xbmkpath"
+
+		if [ "$x" = "list" ]; then
+			x_ ls -1 "config/$project"
+			listfile=""
+			break
+		fi
+
+		printf "'make %s', '%s', '%s'\n" "$mode" "$project" "$x"
+
+		target="${x##*/}"
+
+		x_ handle_defconfig
+		$if_build \
+			x_ $postmake; :
+	done; :
+}
+
+handle_defconfig()
+{
+	target_dir="$configdir/$target"
+
+	[ ! -f "CHANGELOG" ] && \
+		single_tree_fetch "$project"
+
+	configure_project "$target_dir" || \
+		return 0
+
+	[ -z "$tree" ] && err "$configdir: 'tree' unset" handle_defconfig "$@"
+
+	srcdir="src/$project/$tree"
+
+	[ -d "$srcdir" ] && for y in "$target_dir/config"/*
+	do
+		[ ! -f "$y" ] && \
+			$if_not_dry_build \
+				continue
+
+		$if_not_dry_build eval \
+			defconfig="$y"
+
+		$if_build \
+			prep_mk_multi_tree || continue
+
+		handle_makefile
+
+		$if_build $if_not_dry_build \
+			copy_elf; :
+	done; :
+}
+
+configure_project()
+{
+	_tcfg="$1/target.cfg"
+
+	eval "`newvar configureargs badhash badtghash bootstrapargs \
+	    build_depend buildtype cleanargs makeargs mkhelper postmake \
+	    premake release xarch xgcctree xlang`"
+
+	[ ! -f "$_tcfg" ] && buildtype="auto"
+
+	# globally initialise all variables for a source tree / target:
+	if e "$datadir/mkhelper.cfg" f; then
+		. "$datadir/mkhelper.cfg" || \
+		    err "Can't read '$datadir/mkhelper.cfg'" \
+		    "configure_project" "$@"
+	fi
+
+	# override target/tree specific variables from per-target config:
+	while e "$_tcfg" f || [ "$cmd" != "mk_single_tree" ]
+	do
+		printf "Loading %s config: %s\n" "$project" "$_tcfg"
+		eval "`newvar rev tree`"
+
+		. "$_tcfg" || err "Can't read '$_tcfg'" configure_project "$@"
+
+		$if_dry_build eval \
+			build_depend=""
+
+		$if_single_tree \
+			break
+		$if_do_make \
+			break
+		[ "${_tcfg%/*/target.cfg}" = "${_tcfg%"/$tree/target.cfg"}" ] \
+			&& break # target and tree matching was successful
+
+		_tcfg="${_tcfg%/*/target.cfg}/$tree/target.cfg" # try next
+	done
+
+	[ "$XBMK_RELEASE" = "y" ] && [ "$release" = "n" ] && \
+		return 1
+	[ -n "$buildtype" ] && $if_make_config \
+		return 1
+
+	$if_build $if_not_dry_build \
+		build_dependencies
+
+	mdir="$xbmkpwd/config/submodule/$project"
+	[ -n "$tree" ] && mdir="$mdir/$tree"
+
+	if [ ! -f "CHANGELOG" ]; then
+		delete_old_project_files
+		$if_not_do_make \
+			${cmd#mk_}_fetch
+	fi
+	$if_not_do_make \
+		return 1
+
+	x_ "$mk" -f "$project" "$target"
+}
+
+# projects can specify which other projects
+# to build first, as declared dependencies:
+
+build_dependencies()
+{
+	for bd in $build_depend
+	do
+		bd_project="${bd%%/*}"
+		bd_tree="${bd##*/}"
+
+		[ -z "$bd_project" ] && \
+			$if_not_dry_build \
+				err "$project/$tree: !bd '$bd'" \
+				    "build_dependencies" "$@"
+
+		[ "${bd##*/}" = "$bd" ] && \
+			bd_tree=""
+
+		[ -n "$bd_project" ] && \
+			$if_not_dry_build \
+				x_ "$mk" -b $bd_project $bd_tree; :
+	done; :
+}
+
+# delete_old_project_files along with project_up_to_date,
+# concatenates the sha512sum hashes of all files related to
+# a project, tree or target, then gets the sha512sum of that
+# concatenation. this is checked against any existing
+# calculation previously cached; if the result differs, or
+# nothing was previously stored, we know to delete resources
+# such as builds, project sources and so on, for auto-rebuild:
+
+delete_old_project_files()
+{
+	# delete an entire source tree along with its builds:
+	project_up_to_date hash "$tree" badhash "$datadir" \
+	    "$configdir/$tree" "$mdir" || \
+		x_ rm -Rf "src/$project/$tree" "elf/$project/$tree"
+
+	x_ cp "$xbtmp/new.hash" "$XBMK_CACHE/hash/$project$tree"
+
+	if singletree "$project" || [ -z "$target" ] || [ "$target" = "$tree" ]
+	then
+		return 0
+	fi
+
+	# delete only the builds of a given target, but not src.
+	# this is useful when only the target config changes, for
+	# example x200_8mb coreboot configs change, but not coreboot:
+
+	project_up_to_date tghash "$target" badtghash "$configdir/$target" || \
+		x_ rm -Rf "elf/$project/$tree/$target"
+
+	x_ cp "$xbtmp/new.hash" "$XBMK_CACHE/tghash/$project$target"
+}
+
+project_up_to_date()
+{
+	eval "`newvar hash old_hash`"
+
+	hashdir="$1"
+	hashname="$2"
+	badhashvar="$3"
+
+	shift 3
+
+	x_ mkdir -p "$XBMK_CACHE/$hashdir"
+
+	if [ -f "$XBMK_CACHE/$hashdir/$project$hashname" ]; then
+		read -r old_hash < "$XBMK_CACHE/$hashdir/$project$hashname" \
+		    || err \
+		    "$hashdir: err '$XBMK_CACHE/$hashdir/$project$hashname'" \
+		    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" \
+		    "$@"
+	fi
+
+	eval "$build_sbase"
+	fx_ "x_ util/sbase/sha512sum" find "$@" -type f -not -path \
+	    "*/.git*/*" | awk '{print $1}' > "$xbtmp/tmp.hash" || \
+	    err "!h $project $hashdir" \
+	    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@"
+
+	hash="$(x_ "$sha512sum" "$xbtmp/tmp.hash" | awk '{print $1}' || \
+	    err)" || err "$hashname: Can't read sha512 of '$xbtmp/tmp.hash'" \
+	    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@"
+
+	if [ "$hash" != "$old_hash" ] || \
+	    [ ! -f "$XBMK_CACHE/$hashdir/$project$hashname" ]; then
+		eval "$badhashvar=\"y\""
+	fi
+
+	printf "%s\n" "$hash" > "$xbtmp/new.hash" || \
+	    err "!mkhash $xbtmp/new.hash ($hashdir $hashname $badhashvar)" \
+	    "project_up_to_date" "$hashdir" "$hashname" "$badhashvar" "$@"
+
+	eval "[ \"\$$badhashvar\" = \"y\" ] && return 1"; :
+}
+
+prep_mk_multi_tree()
+{
+	dest_dir="$elfdir/$tree/$target/${defconfig#"$target_dir/config/"}"
+
+	$if_not_dry_build elfcheck || return 1 # skip if a build exists
+	$if_not_dry_build eval "$(printf '%s\n' "$xarch" | awk \
+	    '{ for (i=1; i<=NF; i++) $i = "check_xgcc \""$i"\";"; print }')"
+}
+
+check_xgcc()
+{
+	cbdir="src/coreboot/$tree"
+
+	[ "$project" != "coreboot" ] && \
+		cbdir="src/coreboot/default"
+	[ -n "$xgcctree" ] && \
+		cbdir="src/coreboot/$xgcctree"
+
+	cbelfdir="elf${cbdir#src}"
+
+	xfix="${1%-*}"
+	[ "$xfix" = "x86_64" ] && xfix="x64"
+
+	xgccfile="$cbelfdir/xgcc_${xfix}_was_compiled"
+	xgccargs="crossgcc-$xfix UPDATED_SUBMODULES=1 CPUS=$XBMK_THREADS"
+
+	x_ "$mk" -f coreboot "${cbdir#src/coreboot/}"
+	x_ mkdir -p "$cbelfdir"
+
+	# tell build systems what cross-compiler to use
+	export PATH="$xbmkpwd/$cbdir/util/crossgcc/xgcc/bin:$PATH"
+	export CROSS_COMPILE="${xarch% *}-" # used by e.g. u-boot
+
+	# coreboot-specific (we disable gnat on some trees)
+	[ -n "$xlang" ] && \
+		export BUILD_LANGUAGES="$xlang"
+
+	[ -f "$xgccfile" ] && return 0 # skip (build already exists)
+
+	make -C "$cbdir" $xgccargs || x_ make -C "$cbdir" $xgccargs
+
+	x_ touch "$xgccfile" # prevent unnecessary re-build operations
+}
+
+elfcheck()
+{
+	# TODO: *STILL* very hacky check. do it properly (based on build.list)
+	( fx_ "eval exit 1 && err" find "$dest_dir" -type f ) || return 1; :
+}
+
+handle_makefile()
+{
+	check_makefile "$srcdir" && $if_not_dry_build \
+		x_ make -C "$srcdir" clean $cleanargs
+
+	[ -f "$defconfig" ] && \
+		x_ cp "$defconfig" "$srcdir/.config"
+
+	run_make_command || err "no makefile!" "handle_makefile" "$@"
+
+	_copy=".config"
+	[ "$mode" = "savedefconfig" ] && \
+		_copy="defconfig"
+
+	$if_make_config \
+		x_ cp "$srcdir/$_copy" "$defconfig"; :
+}
+
+run_make_command()
+{
+	$if_build \
+		x_ $premake
+	$if_not_dry_build \
+		run_make_command_real || return 1
+	$if_build \
+		x_ $mkhelper; :
+}
+
+run_make_command_real()
+{
+	[ -z "$cmakedir" ] || \
+		x_ cmake -B "$srcdir" "$srcdir/$cmakedir"
+	$if_build \
+		check_autoconf "$srcdir"
+
+	check_makefile "$srcdir" || return 1
+	x_ make -C "$srcdir" $mode -j$XBMK_THREADS $makeargs
+}
+
+check_autoconf()
+{
+	(
+	x_ cd "$1"
+
+	[ -f "bootstrap" ] && \
+		x_ ./bootstrap $bootstrapargs
+	[ -f "autogen.sh" ] && \
+		x_ ./autogen.sh $autogenargs
+	[ -f "configure" ] && \
+		x_ ./configure $configureargs; :
+
+	) || err "can't bootstrap project: $1" check_autoconf "$@"; :
+}
+
+check_makefile()
+{
+	[ ! -f "$1/Makefile" ] && [ ! -f "$1/makefile" ] && \
+	    [ ! -f "$1/GNUmakefile" ] && return 1; :
+}
+
+copy_elf()
+{
+	[ -f "$listfile" ] && \
+		x_ mkdir -p "$dest_dir"
+
+	if [ -f "$listfile" ]; then
+		while read -r f; do
+			[ -f "$srcdir/$f" ] && \
+				x_ cp "$srcdir/$f" "$dest_dir"; :
+
+		done < "$listfile" || err \
+		    "cannot read '$listfile'" "copy_elf" "$@"; :
+	fi
+
+	( x_ make -C "$srcdir" clean $cleanargs ) || \
+	    err "can't make-clean '$srcdir'" "copy_elf" "$@"; :
+}
+
+x_ main "$_f" "$@"
+
+) || exit 1; :
@@ -1,7 +0,0 @@
-/nvm
-/nvmutil
-/mkhtemp
-/lottery
-*.bin
-*.o
-*.d
@@ -1,2 +0,0 @@
-Leah Rowe
-Riku Viitanen
@@ -1,21 +0,0 @@
-Copyright (C) 2022-2026 Leah Rowe <leah@libreboot.org>
-Copyright (c) 2023 Riku Viitanen <riku.viitanen@protonmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -1,60 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2022,2026 Leah Rowe <leah@libreboot.org>
-# Copyright (c) 2023 Riku Viitanen <riku.viitanen@protonmail.com>
-
-CC = cc
-CFLAGS = -Os -Wall -Wextra -std=c99 -pedantic
-LDFLAGS =
-PREFIX = /usr/local
-DESTDIR =
-INSTALL = install
-
-PROGS = nvmutil mkhtemp lottery
-
-LIB_OBJS = \
-	lib/state.o \
-	lib/file.o \
-	lib/string.o \
-	lib/usage.o \
-	lib/command.o \
-	lib/num.o \
-	lib/io.o \
-	lib/checksum.o \
-	lib/word.o \
-	lib/mkhtemp.o \
-	lib/rand.o
-
-OBJS_NVMUTIL = nvmutil.o $(LIB_OBJS)
-OBJS_MKHTEMP = mkhtemp.o lib/file.o lib/string.o lib/num.o lib/mkhtemp.o lib/rand.o
-OBJS_LOTTERY = lottery.o lib/file.o lib/string.o lib/num.o lib/mkhtemp.o lib/rand.o
-
-all: $(PROGS)
-
-nvmutil: $(OBJS_NVMUTIL)
-	$(CC) $(CFLAGS) $(OBJS_NVMUTIL) -o $@ $(LDFLAGS)
-
-mkhtemp: $(OBJS_MKHTEMP)
-	$(CC) $(CFLAGS) $(OBJS_MKHTEMP) -o $@ $(LDFLAGS)
-
-lottery: $(OBJS_LOTTERY)
-	$(CC) $(CFLAGS) $(OBJS_LOTTERY) -o $@ $(LDFLAGS)
-
-.c.o:
-	$(CC) $(CFLAGS) -c $< -o $@
-
-install: $(PROGS)
-	mkdir -p $(DESTDIR)$(PREFIX)/bin
-	for p in $(PROGS); do \
-		$(INSTALL) $$p $(DESTDIR)$(PREFIX)/bin/$$p; \
-		chmod 755 $(DESTDIR)$(PREFIX)/bin/$$p; \
-	done
-
-uninstall:
-	for p in $(PROGS); do \
-		rm -f $(DESTDIR)$(PREFIX)/bin/$$p; \
-	done
-
-clean:
-	rm -f $(PROGS) *.o lib/*.o
-
-distclean: clean
@@ -1,254 +0,0 @@
-Mkhtemp - Hardened mktemp
-------------------------
-
-Just like normal mktemp, but hardened.
-
-Create new files and directories randomly as determined by
-the user's TMPDIR, or fallback. These temporary files and
-directories can be generated from e.g. shell scripts, running
-mkhtemp. There is also a library that you could use in your
-program. Portable to Linux and BSD. **WORK IN PROGRESS.
-This is a very new project. Expect bugs - a stable release
-will be announced, when the code has matured.**
-
-A brief summary of *why* mkhtemp is more secure (more
-details provided later in this readme - please also
-read the source code):
-
-Detect and mitigate symlink attacks, directory access
-race conditions, unsecure TMPDIR (e.g. bad enforce sticky
-bit policy on world writeable dirs), implement in user
-space a virtual sandbox (block directory escape and resolve
-paths by walking from `/` manually instead of relying on
-the kernel/system), voluntarily error out (halt all
-operation) if accessing files you don't own - that's why
-sticky bits are checked for example, even when you're root.
-
-It... blocks symlinks, relative paths, attempts to prevent
-directory escape (outside of the directory that the file
-you're creating is in), basically implementing an analog
-of something like e.g. unveil, but in userspace!
-
-Mkhtemp is designed to be the most secure implementation
-possible, of mktemp, offering a heavy amount of hardening
-over traditional mktemp. Written in C99, and the plan is
-very much to keep this code portable over time - patches
-very much welcome.
-
-i.e. please read the source code
-
-```
-/*
- * WARNING: WORK IN PROGRESS.
- * Do not use this software in
- * your distro yet. It's ready
- * when it's ready. Read the src.
- *
- * What you see is an early beta.
- *
- * Please do not merge this in
- * your Linux distro package repo
- * yet (unless maybe you're AUR).
- */
-```
-
-Supported mktemp flags:
-
-```
-mkhtemp: usage: mkhtemp [-d] [-p dir] [template]
-
- -p DIR       <-- set directory, overriding TMPDIR
- -d           <-- make a directory instead of a file
- -q           <-- silence errors (exit status unchanged)
-```
-
-The rest of them will be added later (the same ones
-that GNU and BSD mktemp implement). With these options,
-you can generate files/directories already.
-
-You can also write a template at the end. e.g.
-
-```
-mkhtemp -d -p path/to/directory vickysomething_XXXXXXXXXXX
-```
-
-On most sane/normal setups, the program should already
-actually work, but please know that it's very different
-internally than every other mktemp implementation.
-
-Read the source code if you're interested. As of this
-time of writing, mkhtemp is very new, and under
-development. A stable release will be announced when ready.
-
-### What does mkhtemp do differently?
-
-This software attempts to provide mitigation against
-several TOCTOU-based
-attacks e.g. directory rename / symlink / re-mount, and
-generally provides much higher strictness than previous
-implementations such as mktemp, mkstemp or even mkdtemp.
-It uses several modern features by default, e.g. openat2
-and `O_TMPFILE` (plus `O_EXCL`) on Linux, with additional
-hardening; BSD projects only have openat so the code uses
-that there, but some (not all) of the kinds of checks
-Openat2 enforces are done manually (in userspace).
-
-File system sandboxing in userspace (pathless discovery,
-and operations are done only with FDs). At startup, the
-root directory is opened, and then everything is relative
-to that.
-
-Many programs rely on mktemp, and they use TMPDIR in a way
-that is quite insecure. Mkhtemp intends to change that,
-quite dramatically, with: userspace sandbox (and use OS
-level options e.g. OBSD pledge where available), constant
-identity/ownership checks on files, MUCH stricter ownership
-restrictions (e.g. enforce sticky bit policy on world-
-writeable tmpdirs), preventing operation on other people's
-files (only your own files) - even root is restricted,
-depending on how the code is compiled. Please read the code.
-
-Basically, the gist of it is that normal mktemp *trusts*
-your system is set up properly. It will just run however
-you tell it to, on whatever directory you tell it to, and
-if you're able to write to it, it will write to it.
-Some implementations (e.g. OpenBSD one) do some checks,
-but not all of them do *all* checks. The purpose of
-mkhtemp is to be as strict as possible, while still being
-reliable enough that people can use it. Instead of catering
-to legacy requirements, mkhtemp says that systems should
-be secure. So if you're running in an insecure environment,
-the goal of mkhtemp is to *exit* when you run it; better
-this than files being corrupted.
-
-Security and reliability are the same thing. They both
-mean that your computer is behaving as it should, in a
-manner that you can predict.
-
-It doesn't matter how many containers you have, or how
-memory-safe your programming language is, the same has
-been true forever: code equals bugs, and code usually
-has the same percentage of bugs, so more code equals
-more bugs. Therefore, highly secure systems (such as
-OpenBSD) typically try to keep their code as small and
-clean as possible, so that they can audit it. Mkhtemp
-assumes that your system is hostile, and is designed
-accordingly.
-
-What?
-----
-
-This is the utility version, which makes use of the also-
-included library. No docs yet - source code are the docs,
-and the (ever evolving, and hardening) specification.
-
-This was written from scratch, for use in nvmutil, and
-it is designed to be portable (BSD, Linux). Patches
-very much welcome.
-
-Caution
-------
-
-This is a new utility. Expect bugs.
-
-```
-WARNING: This is MUCH stricter than every other mktemp
-         implementation, even more so than mkdtemp or
-         the OpenBSD version of mkstemp. It *will* break,
-         or more specifically, reveal the flaws in, almost
-         every major critical infrastructure, because most
-         people already use mktemp extremely insecurely.
-```
-
-This tool is written by me, for me, and also Libreboot, but
-it will be summitted for review to various Linux distros
-and BSD projects once it has reached maturity.
-
-### Why was this written?
-
-Atomic writes were implemented in nvmutil (Libreboot's
-Intel GbE NVM editor), but one element remained: the
-program mktemp, itself, which has virtually no securitty
-checks whatsoever. GNU and BSD implementations use
-mkstemp now, which is a bit more secure, and they offer
-additional hardening, but I wanted to be reasonably
-assured that my GbE files were not being corrupted in
-any way, and that naturally led to writing a hardened
-tool. It was originally just going to be for nvmutil,
-but then it became its own standard utility.
-
-Existing implementations of mktemp just simply do not
-have sufficient checks in place to prevent misuse. This
-tool, mkhtemp, intentionally focuses on being secure
-instead of easy. For individuals just running Linux on
-their personal machine, it might not make much difference,
-but corporations and projects running computers for lots
-of big infrastructure need something reliable, since
-mktemp is just one of those things everyone uses.
-Every big program needs to make temporary files.
-
-But the real reason I wrote this tool is because, it's
-fun, and because I wanted to challenge myself.
-
-Roadmap
-------
-
-Some things that are in the near future for mkhtemp
-development:
-
-Thoroughly document every known case of CVEs in the wild,
-and major attacks against individuals/projects/corporations
-that were made possible by mktemp - that mkhtemp might
-have prevented. There are several.
-
-More hardening; still a lot more that can be done, depending
-on OS. E.g. integrate FreeBSD capsicum.
-
-Another example: although usually reliable, comparing the
-inode and device of a file/directory isn't by itself sufficient.
-There are other checks that mkhtemp does; for example I could
-implement it so that directories are more aggressively re-
-opened by mkhtemp itself, mid-operation. This re-opening
-would be quite expensive computationally, but it would then
-allow us to re-check everything, since we store state from
-when the program starts.
-
-Tidy up the code: the current code was thrown together in
-a week, and needs tidying. A proper specification should be
-written, to define how it works, and then the code should
-be auditted for compliance. A lot of the functions are
-also quite complex and do a lot; they could be split up.
-
-Right now, mkhtemp mainly returns a file descriptor and
-a path, after operation, ironic given the methods it uses
-while opening your file/dir. After it's done, you then have
-to handle everything again. Mkhtemp could keep everything
-open instead, and continue to provide verification; in
-other words, it could provide a completely unified way for
-Linux/BSD programs to open files, write to them atomically,
-and close. Programs like Vim will do this for example, or
-other text editors, but every program has its own way. So
-what mkhtemp could do is provide a well-defined API alongside
-its mktemp hardening. Efforts would be made to avoid
-feature creep, and ensure that the code remains small and
-nimble.
-
-Compatibility mode: another thing is that mkhtemp is a bit
-too strict for some users, so it may break some setups. What
-it could do is provide a compatibility mode, and in this
-mode, behave like regular mktemp. That way, it could become
-a drop-in replacement on Linux distros (and BSDs if they
-want it), while providing a more hardened version and
-recommending that where possible.
-
-~~Rewrite it in rust~~ (nothing against it though, I just like C99 for some reason)
-
-Also, generally document the history of mktemp, and how
-mkhtemp works in comparison.
-
-Also a manpage.
-
-Once all this is done, and the project is fully polished,
-then it will be ready for your Linux distro. For now, I
-just use it in nvmutil (and I also use it on my personal
-computer).
@@ -1,607 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2022-2026 Leah Rowe <leah@libreboot.org>
-
- TODO: this file should be split, into headers for each
-       C source file specifically. it was originally just
-       for nvmutil, until i added mkhtemp to the mix
- */
-
-
-#ifndef COMMON_H
-#define COMMON_H
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <limits.h>
-
-/* dangerously cool macros:
- */
-
-#define SUCCESS(x) ((x) >= 0)
-
-/* syscalls can set errno even on success; this
- * is rare, but permitted. in various functions, we
- * reset errno on success, to what the caller had,
- * but we must still honour what was returned.
- *
- * lib/file.c is littered with examples
- */
-#define reset_caller_errno(return_value) \
-	do { \
-		if (SUCCESS(return_value) && (!errno)) \
-			errno = saved_errno; \
-	} while (0)
-
-#define items(x) (sizeof((x)) / sizeof((x)[0]))
-
-#define MKHTEMP_RETRY_MAX 512
-#define MKHTEMP_SPIN_THRESHOLD 32
-
-#define MKHTEMP_FILE 0
-#define MKHTEMP_DIR  1
-
-
-/* if 1: on operations that
- * check ownership, always
- * permit root to access even
- * if not the file/dir owner
- */
-#ifndef ALLOW_ROOT_OVERRIDE
-#define ALLOW_ROOT_OVERRIDE 0
-#endif
-
-/*
- */
-
-#ifndef SSIZE_MAX
-#define SSIZE_MAX ((ssize_t)(~((ssize_t)1 << (sizeof(ssize_t)*CHAR_BIT-1))))
-#endif
-
-
-/* build config
- */
-
-#ifndef NVMUTIL_H
-#define NVMUTIL_H
-
-#define MAX_CMD_LEN 50
-
-#ifndef PATH_MAX
-#define PATH_MAX 4096
-#endif
-#ifndef PATH_MAX
-#error PATH_MAX_undefined
-#elif ((PATH_MAX) < 1024)
-#error PATH_MAX_too_low
-#endif
-
-#ifndef S_ISVTX
-#define S_ISVTX 01000
-#endif
-
-#if defined(S_IFMT) && ((S_ISVTX & S_IFMT) != 0)
-#error "Unexpected bit layout"
-#endif
-
-#ifndef _FILE_OFFSET_BITS
-#define _FILE_OFFSET_BITS 64
-#endif
-
-#ifndef EXIT_FAILURE
-#define EXIT_FAILURE 1
-#endif
-
-#ifndef EXIT_SUCCESS
-#define EXIT_SUCCESS 0
-#endif
-
-#ifndef O_NOCTTY
-#define O_NOCTTY 0
-#endif
-
-#ifndef O_ACCMODE
-#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
-#endif
-
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
-#ifndef O_EXCL
-#define O_EXCL 0
-#endif
-
-#ifndef O_CREAT
-#define O_CREAT 0
-#endif
-
-#ifndef O_NONBLOCK
-#define O_NONBLOCK 0
-#endif
-
-#ifndef O_CLOEXEC
-#define O_CLOEXEC 0
-#endif
-
-#ifndef O_NOFOLLOW
-#define O_NOFOLLOW 0
-#endif
-
-#ifndef FD_CLOEXEC
-#define FD_CLOEXEC 0
-#endif
-
-/* Sizes in bytes:
- */
-
-#define SIZE_1KB 1024
-#define SIZE_4KB (4 * SIZE_1KB)
-#define SIZE_8KB (8 * SIZE_1KB)
-#define SIZE_16KB (16 * SIZE_1KB)
-#define SIZE_128KB (128 * SIZE_1KB)
-
-#define GBE_BUF_SIZE (SIZE_128KB)
-
-/* First 128 bytes of gbe.bin is NVM.
- * Then extended area. All of NVM must
- * add up to BABA, truncated (LE)
- *
- * First 4KB of each half of the file
- * contains NVM+extended.
- */
-
-#define GBE_WORK_SIZE (SIZE_8KB)
-#define GBE_PART_SIZE (GBE_WORK_SIZE >> 1)
-#define NVM_CHECKSUM 0xBABA
-#define NVM_SIZE 128
-#define NVM_WORDS (NVM_SIZE >> 1)
-#define NVM_CHECKSUM_WORD (NVM_WORDS - 1)
-
-/* argc minimum (dispatch)
- */
-
-#define ARGC_3 3
-#define ARGC_4 4
-
-/* For checking if an fd is a normal file.
- * Portable for old Unix e.g. v7 (S_IFREG),
- * 4.2BSD (S_IFMT), POSIX (S_ISREG).
- *
- * IFREG: assumed 0100000 (classic bitmask)
- */
-
-#ifndef S_ISREG
-#if defined(S_IFMT) && defined(S_IFREG)
-#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
-#elif defined(S_IFREG)
-#define S_ISREG(m) (((m) & S_IFREG) != 0)
-#else
-#error "can't determine types with stat()"
-#endif
-#endif
-
-#define IO_READ 0
-#define IO_WRITE 1
-#define IO_PREAD 2
-#define IO_PWRITE 3
-
-/* for nvmutil commands
- */
-
-#define CMD_DUMP 0
-#define CMD_SETMAC 1
-#define CMD_SWAP 2
-#define CMD_COPY 3
-#define CMD_CAT 4
-#define CMD_CAT16 5
-#define CMD_CAT128 6
-
-#define ARG_NOPART 0
-#define ARG_PART 1
-
-#define SKIP_CHECKSUM_READ 0
-#define CHECKSUM_READ 1
-
-#define SKIP_CHECKSUM_WRITE 0
-#define CHECKSUM_WRITE 1
-
-/* command table
- */
-
-typedef void (*func_t)(void);
-
-struct commands {
-	size_t chk;
-	char *str;
-	func_t run;
-	int argc;
-	unsigned char arg_part;
-	unsigned char chksum_read;
-	unsigned char chksum_write;
-	size_t rw_size; /* within the 4KB GbE part */
-	int flags; /* e.g. O_RDWR or O_RDONLY */
-};
-
-/* mac address
- */
-
-struct macaddr {
-	char *str; /* set to rmac, or argv string */
-	char rmac[18]; /* xx:xx:xx:xx:xx:xx */
-	unsigned short mac_buf[3];
-};
-
-/* gbe.bin and tmpfile
- */
-
-struct xfile {
-	int gbe_fd;
-	struct stat gbe_st;
-
-	int tmp_fd;
-	struct stat tmp_st;
-
-	char *tname; /* path of tmp file */
-	char *fname; /* path of gbe file */
-
-	unsigned char *buf; /* work memory for files */
-
-	int io_err_gbe; /* intermediary write (verification) */
-	int io_err_gbe_bin; /* final write (real file) */
-	int rw_check_err_read[2];
-	int rw_check_partial_read[2];
-	int rw_check_bad_part[2];
-
-	int post_rw_checksum[2];
-
-	off_t gbe_file_size;
-	off_t gbe_tmp_size;
-
-	size_t part;
-	unsigned char part_modified[2];
-	unsigned char part_valid[2];
-
-	unsigned char real_buf[GBE_BUF_SIZE];
-	unsigned char bufcmp[GBE_BUF_SIZE]; /* compare gbe/tmp/reads */
-
-	unsigned char pad[GBE_WORK_SIZE]; /* the file that wouldn't die */
-
-	/* we later rename in-place, using old fd. renameat() */
-	int dirfd;
-	char *base;
-	char *tmpbase;
-};
-
-/* Command table, MAC address, files
- *
- * BE CAREFUL when editing this
- * to ensure that you also update
- * the tables in xstatus()
- */
-
-struct xstate {
-	struct commands cmd[7];
-	struct macaddr mac;
-	struct xfile f;
-
-	size_t i; /* index to cmd[] for current command */
-	int no_cmd;
-
-	/* Cat commands set this.
-	   the cat cmd helpers check it */
-	int cat;
-};
-
-struct filesystem {
-	int rootfd;
-};
-
-struct xstate *xstart(int argc, char *argv[]);
-struct xstate *xstatus(void);
-
-/* Sanitize command tables.
- */
-
-void sanitize_command_list(void);
-void sanitize_command_index(size_t c);
-
-/* Argument handling (user input)
- */
-
-void set_cmd(int argc, char *argv[]);
-void set_cmd_args(int argc, char *argv[]);
-size_t conv_argv_part_num(const char *part_str);
-
-/* Prep files for reading
- */
-
-void open_gbe_file(void);
-int fd_verify_regular(int fd,
-    const struct stat *expected,
-    struct stat *out);
-int fd_verify_identity(int fd,
-    const struct stat *expected,
-    struct stat *out);
-int fd_verify_dir_identity(int fd,
-    const struct stat *expected);
-int is_owner(struct stat *st);
-int lock_file(int fd, int flags);
-int same_file(int fd, struct stat *st_old, int check_size);
-
-/* Read GbE file and verify checksums
- */
-
-void copy_gbe(void);
-void read_file(void);
-void read_checksums(void);
-int good_checksum(size_t partnum);
-
-/* validate commands
- */
-
-void check_command_num(size_t c);
-unsigned char valid_command(size_t c);
-
-/* Helper functions for command: setmac
- */
-
-void cmd_helper_setmac(void);
-void parse_mac_string(void);
-void set_mac_byte(size_t mac_byte_pos);
-void set_mac_nib(size_t mac_str_pos,
-    size_t mac_byte_pos, size_t mac_nib_pos);
-void write_mac_part(size_t partnum);
-
-/* string functions
- */
-
-size_t page_remain(const void *p);
-long pagesize(void);
-char *smalloc(char **buf, size_t size);
-void *vmalloc(void **buf, size_t size);
-size_t slen(const char *scmp, size_t maxlen,
-    size_t *rval);
-int vcmp(const void *s1, const void *s2, size_t n);
-int scmp(const char *a, const char *b,
-    size_t maxlen, int *rval);
-int ccmp(const char *a, const char *b, size_t i,
-    int *rval);
-int dup_pair(char **dir, const char *d,
-    char **base, const char *b);
-char *sdup(const char *s,
-    size_t n, char **dest);
-char *scatn(ssize_t sc, const char **sv,
-    size_t max, char **rval);
-char *scat(const char *s1, const char *s2,
-    size_t n, char **dest);
-void dcat(const char *s, size_t n,
-    size_t off, char **dest1,
-    char **dest2);
-/* numerical functions
- */
-
-unsigned short hextonum(char ch_s);
-void spew_hex(const void *data, size_t len);
-void *rmalloc(size_t n);
-void rset(void *buf, size_t n);
-void *rmalloc(size_t n);
-char *rchars(size_t n);
-size_t rsize(size_t n);
-
-/* Helper functions for command: dump
- */
-
-void cmd_helper_dump(void);
-void print_mac_from_nvm(size_t partnum);
-
-/* Helper functions for command: swap
- */
-
-void cmd_helper_swap(void);
-
-/* Helper functions for command: copy
- */
-
-void cmd_helper_copy(void);
-
-/* Helper functions for commands:
- * cat, cat16 and cat128
- */
-
-void cmd_helper_cat(void);
-void cmd_helper_cat16(void);
-void cmd_helper_cat128(void);
-void cat(size_t nff);
-void cat_buf(unsigned char *b);
-
-/* Command verification/control
- */
-
-void check_cmd(void (*fn)(void), const char *name);
-void cmd_helper_err(void);
-
-/* Write GbE files to disk
- */
-
-void write_gbe_file(void);
-void set_checksum(size_t part);
-unsigned short calculated_checksum(size_t p);
-
-/* NVM read/write
- */
-
-unsigned short nvm_word(size_t pos16, size_t part);
-void set_nvm_word(size_t pos16,
-    size_t part, unsigned short val16);
-void set_part_modified(size_t p);
-void check_nvm_bound(size_t pos16, size_t part);
-void check_bin(size_t a, const char *a_name);
-
-/* GbE file read/write
- */
-
-void rw_gbe_file_part(size_t p, int rw_type,
-    const char *rw_type_str);
-void write_to_gbe_bin(void);
-int gbe_mv(void);
-void check_written_part(size_t p);
-void report_io_err_rw(void);
-unsigned char *gbe_mem_offset(size_t part, const char *f_op);
-off_t gbe_file_offset(size_t part, const char *f_op);
-off_t gbe_x_offset(size_t part, const char *f_op,
-    const char *d_type, off_t nsize, off_t ncmp);
-ssize_t rw_gbe_file_exact(int fd, unsigned char *mem, size_t nrw,
-    off_t off, int rw_type);
-
-/* Generic read/write
- */
-
-int fsync_dir(const char *path);
-ssize_t rw_exact(int fd, unsigned char *mem, size_t len,
-    off_t off, int rw_type);
-ssize_t rw(int fd, void *mem, size_t nrw,
-    off_t off, int rw_type);
-int io_args(int fd, void *mem, size_t nrw,
-    off_t off, int rw_type);
-int check_file(int fd, struct stat *st);
-ssize_t rw_over_nrw(ssize_t r, size_t nrw);
-int sys_retry(int saved_errno, long rval);
-int fs_retry(int saved_errno, int rval);
-int rw_retry(int saved_errno, ssize_t rval);
-
-/* Error handling and cleanup
- */
-
-void usage(void);
-int with_fallback_errno(int fallback);
-void exitf(const char *msg, ...);
-func_t errhook(func_t ptr); /* hook function for cleanup on err */
-const char *lbgetprogname(void);
-void no_op(void);
-void err_mkhtemp(int errval, const char *msg, ...);
-
-/* libc hardening
- */
-
-int new_tmpfile(int *fd, char **path, char *tmpdir,
-    const char *template);
-int new_tmpdir(int *fd, char **path, char *tmpdir,
-    const char *template);
-int new_tmp_common(int *fd, char **path, int type,
-    char *tmpdir, const char *template);
-int mkhtemp_try_create(int dirfd,
-    struct stat *st_dir_first,
-    char *fname_copy,
-    char *p,
-    size_t xc,
-    int *fd,
-    struct stat *st,
-    int type);
-int
-mkhtemp_tmpfile_linux(int dirfd,
-    struct stat *st_dir_first,
-    char *fname_copy,
-    char *p,
-    size_t xc,
-    int *fd,
-    struct stat *st);
-int mkhtemp(int *fd, struct stat *st,
-    char *template, int dirfd, const char *fname,
-    struct stat *st_dir_first, int type);
-int world_writeable_and_sticky(const char *s,
-    int sticky_allowed, int always_sticky);
-int same_dir(const char *a, const char *b);
-int tmpdir_policy(const char *path,
-    int *allow_noworld_unsticky);
-char *env_tmpdir(int always_sticky, char **tmpdir,
-    char *override_tmpdir);
-int secure_file(int *fd,
-    struct stat *st,
-    struct stat *expected,
-    int bad_flags,
-    int check_seek,
-    int do_lock,
-    mode_t mode);
-void xclose(int *fd);
-int fsync_on_eintr(int fd);
-int fs_rename_at(int olddirfd, const char *old,
-             int newdirfd, const char *new);
-int fs_open(const char *path, int flags);
-void free_and_set_null(char **buf);
-void open_file_on_eintr(const char *path, int *fd, int flags, mode_t mode,
-    struct stat *st);
-struct filesystem *rootfs(void);
-int fs_resolve_at(int dirfd, const char *path, int flags);
-int fs_next_component(const char **p,
-    char *name, size_t namesz);
-int fs_open_component(int dirfd, const char *name,
-    int flags, int is_last);
-int fs_dirname_basename(const char *path,
-    char **dir, char **base, int allow_relative);
-int openat_on_eintr(int dirfd, const char *path,
-    int flags, mode_t mode);
-int mkdirat_on_eintr(int dirfd, 
-    const char *pathname, mode_t mode);
-int if_err(int condition, int errval);
-int if_err_sys(int condition);
-char *lbsetprogname(char *argv0);
-
-/* asserts */
-
-/* type asserts */
-typedef char static_assert_char_is_8_bits[(CHAR_BIT == 8) ? 1 : -1];
-typedef char static_assert_char_is_1[(sizeof(char) == 1) ? 1 : -1];
-typedef char static_assert_unsigned_char_is_1[
-    (sizeof(unsigned char) == 1) ? 1 : -1];
-typedef char static_assert_unsigned_short_is_2[
-    (sizeof(unsigned short) >= 2) ? 1 : -1];
-typedef char static_assert_short_is_2[(sizeof(short) >= 2) ? 1 : -1];
-typedef char static_assert_unsigned_int_is_4[
-    (sizeof(unsigned int) >= 4) ? 1 : -1];
-typedef char static_assert_unsigned_ssize_t_is_4[
-    (sizeof(size_t) >= 4) ? 1 : -1];
-typedef char static_assert_ssize_t_ussize_t[
-    (sizeof(size_t) == sizeof(ssize_t)) ? 1 : -1];
-typedef char static_assert_int_ge_32[(sizeof(int) >= 4) ? 1 : -1];
-typedef char static_assert_twos_complement[
-    ((-1 & 3) == 3) ? 1 : -1
-];
-typedef char assert_unsigned_ssize_t_ptr[
-    (sizeof(size_t) >= sizeof(void *)) ? 1 : -1
-];
-
-/*
- * We set _FILE_OFFSET_BITS 64, but we only handle
- * but we only need smaller files, so require 4-bytes.
- * Some operating systems ignore the define, hence assert:
- */
-typedef char static_assert_off_t_is_32[(sizeof(off_t) >= 4) ? 1 : -1];
-
-/*
- * asserts (variables/defines sanity check)
- */
-typedef char assert_argc3[(ARGC_3==3)?1:-1];
-typedef char assert_argc4[(ARGC_4==4)?1:-1];
-typedef char assert_read[(IO_READ==0)?1:-1];
-typedef char assert_write[(IO_WRITE==1)?1:-1];
-typedef char assert_pread[(IO_PREAD==2)?1:-1];
-typedef char assert_pwrite[(IO_PWRITE==3)?1:-1];
-typedef char assert_pathlen[(PATH_MAX>=1024)?1:-1];
-/* commands */
-typedef char assert_cmd_dump[(CMD_DUMP==0)?1:-1];
-typedef char assert_cmd_setmac[(CMD_SETMAC==1)?1:-1];
-typedef char assert_cmd_swap[(CMD_SWAP==2)?1:-1];
-typedef char assert_cmd_copy[(CMD_COPY==3)?1:-1];
-typedef char assert_cmd_cat[(CMD_CAT==4)?1:-1];
-typedef char assert_cmd_cat16[(CMD_CAT16==5)?1:-1];
-typedef char assert_cmd_cat128[(CMD_CAT128==6)?1:-1];
-/* bool */
-typedef char bool_arg_nopart[(ARG_NOPART==0)?1:-1];
-typedef char bool_arg_part[(ARG_PART==1)?1:-1];
-typedef char bool_skip_checksum_read[(SKIP_CHECKSUM_READ==0)?1:-1];
-typedef char bool_checksum_read[(CHECKSUM_READ==1)?1:-1];
-typedef char bool_skip_checksum_write[(SKIP_CHECKSUM_WRITE==0)?1:-1];
-typedef char bool_checksum_write[(CHECKSUM_WRITE==1)?1:-1];
-
-#endif
-#endif
@@ -1,108 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2022-2026 Leah Rowe <leah@libreboot.org>
- *
- * Functions related to GbE NVM checksums.
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "../include/common.h"
-
-void
-read_checksums(void)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd = &x->cmd[x->i];
-	struct xfile *f = &x->f;
-
-	size_t _p;
-	size_t _skip_part;
-
-	unsigned char _num_invalid;
-	unsigned char _max_invalid;
-
-	f->part_valid[0] = 0;
-	f->part_valid[1] = 0;
-
-	if (!cmd->chksum_read)
-		return;
-
-	_num_invalid = 0;
-	_max_invalid = 2;
-
-	if (cmd->arg_part)
-		_max_invalid = 1;
-
-	/* Skip verification on this part,
-	 * but only when arg_part is set.
-	 */
-	_skip_part = f->part ^ 1;
-
-	for (_p = 0; _p < 2; _p++) {
-
-		/* Only verify a part if it was *read*
-		 */
-		if (cmd->arg_part && (_p == _skip_part))
-			continue;
-
-		f->part_valid[_p] = good_checksum(_p);
-		if (!f->part_valid[_p])
-			++_num_invalid;
-	}
-
-	if (_num_invalid >= _max_invalid) {
-
-		if (_max_invalid == 1)
-			exitf("%s: part %lu has a bad checksum",
-			    f->fname, (size_t)f->part);
-
-		exitf("%s: No valid checksum found in file",
-		    f->fname);
-	}
-}
-
-int
-good_checksum(size_t partnum)
-{
-	unsigned short expected_checksum;
-	unsigned short actual_checksum;
-
-	expected_checksum =
-	    calculated_checksum(partnum);
-
-	actual_checksum =
-	    nvm_word(NVM_CHECKSUM_WORD, partnum);
-
-	if (expected_checksum == actual_checksum) {
-		return 1;
-	} else {
-		return 0;
-	}
-}
-
-void
-set_checksum(size_t p)
-{
-	check_bin(p, "part number");
-	set_nvm_word(NVM_CHECKSUM_WORD, p, calculated_checksum(p));
-}
-
-unsigned short
-calculated_checksum(size_t p)
-{
-	size_t c;
-	unsigned int val16;
-
-	val16 = 0;
-
-	for (c = 0; c < NVM_CHECKSUM_WORD; c++)
-		val16 += (unsigned int)nvm_word(c, p);
-
-	return (unsigned short)((NVM_CHECKSUM - val16) & 0xffff);
-}
@@ -1,521 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2022-2026 Leah Rowe <leah@libreboot.org>
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stddef.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "../include/common.h"
-
-void
-sanitize_command_list(void)
-{
-	struct xstate *x = xstatus();
-
-	size_t c;
-	size_t num_commands;
-
-	num_commands = items(x->cmd);
-
-	for (c = 0; c < num_commands; c++)
-		sanitize_command_index(c);
-}
-
-void
-sanitize_command_index(size_t c)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd = &x->cmd[c];
-
-	int _flag;
-	size_t gbe_rw_size;
-
-	size_t rval;
-
-	check_command_num(c);
-
-	if (cmd->argc < 3)
-		exitf("cmd index %lu: argc below 3, %d",
-		    (size_t)c, cmd->argc);
-
-	if (cmd->str == NULL)
-		exitf("cmd index %lu: NULL str",
-		    (size_t)c);
-
-	if (*cmd->str == '\0')
-		exitf("cmd index %lu: empty str",
-		    (size_t)c);
-
-	if (slen(cmd->str, MAX_CMD_LEN +1, &rval) > MAX_CMD_LEN) {
-		exitf("cmd index %lu: str too long: %s",
-		    (size_t)c, cmd->str);
-	}
-
-	if (cmd->run == NULL)
-		exitf("cmd index %lu: cmd ptr null",
-		    (size_t)c);
-
-	check_bin(cmd->arg_part, "cmd.arg_part");
-	check_bin(cmd->chksum_read, "cmd.chksum_read");
-	check_bin(cmd->chksum_write, "cmd.chksum_write");
-
-	gbe_rw_size = cmd->rw_size;
-
-	switch (gbe_rw_size) {
-	case GBE_PART_SIZE:
-	case NVM_SIZE:
-		break;
-	default:
-		exitf("Unsupported rw_size: %lu",
-		    (size_t)gbe_rw_size);
-	}
-
-	if (gbe_rw_size > GBE_PART_SIZE)
-		exitf("rw_size larger than GbE part: %lu",
-		    (size_t)gbe_rw_size);
-
-	_flag = (cmd->flags & O_ACCMODE);
-
-	if (_flag != O_RDONLY &&
-	    _flag != O_RDWR)
-		exitf("invalid cmd.flags setting");
-}
-
-void
-set_cmd(int argc, char *argv[])
-{
-	struct xstate *x = xstatus();
-	const char *cmd;
-
-	int rval;
-
-	size_t c;
-
-	for (c = 0; c < items(x->cmd); c++) {
-
-		cmd = x->cmd[c].str;
-
-		if (scmp(argv[2], cmd, MAX_CMD_LEN, &rval))
-			continue; /* not the right command */
-
-		/* valid command found */
-		if (argc >= x->cmd[c].argc) {
-			x->no_cmd = 0;
-			x->i = c; /* set command */
-
-			return;
-		}
-
-		exitf(
-		    "Too few args on command '%s'", cmd);
-	}
-
-
-	x->no_cmd = 1;
-}
-
-void
-set_cmd_args(int argc, char *argv[])
-{
-	struct xstate *x = xstatus();
-	size_t i = x->i;
-	struct commands *cmd = &x->cmd[i];
-	struct xfile *f = &x->f;
-
-	if (!valid_command(i) || argc < 3)
-		usage();
-
-	if (x->no_cmd)
-		usage();
-
-	/* Maintainer bug
-	 */
-	if (cmd->arg_part && argc < 4)
-		exitf(
-		    "arg_part set for command that needs argc4");
-
-	if (cmd->arg_part && i == CMD_SETMAC)
-		exitf(
-		    "arg_part set on CMD_SETMAC");
-
-	if (i == CMD_SETMAC) {
-
-		if (argc >= 4)
-			x->mac.str = argv[3];
-		else
-			x->mac.str = x->mac.rmac;
-
-	} else if (cmd->arg_part) {
-
-		f->part = conv_argv_part_num(argv[3]);
-	}
-}
-
-size_t
-conv_argv_part_num(const char *part_str)
-{
-	unsigned char ch;
-
-	if (part_str[0] == '\0' || part_str[1] != '\0')
-		exitf("Partnum string '%s' wrong length", part_str);
-
-	/* char signedness is implementation-defined
-	 */
-	ch = (unsigned char)part_str[0];
-	if (ch < '0' || ch > '1')
-		exitf("Bad part number (%c)", ch);
-
-	return (size_t)(ch - '0');
-}
-
-void
-check_command_num(size_t c)
-{
-	if (!valid_command(c))
-		exitf("Invalid run_cmd arg: %lu",
-		    (size_t)c);
-}
-
-unsigned char
-valid_command(size_t c)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd;
-
-	if (c >= items(x->cmd))
-		return 0;
-
-	cmd = &x->cmd[c];
-
-	if (c != cmd->chk)
-		exitf(
-		    "Invalid cmd chk value (%lu) vs arg: %lu",
-		    cmd->chk, c);
-
-	return 1;
-}
-
-void
-cmd_helper_setmac(void)
-{
-	struct xstate *x = xstatus();
-	struct macaddr *mac = &x->mac;
-
-	size_t partnum;
-
-	check_cmd(cmd_helper_setmac, "setmac");
-
-	printf("MAC address to be written: %s\n", mac->str);
-	parse_mac_string();
-
-	for (partnum = 0; partnum < 2; partnum++)
-		write_mac_part(partnum);
-}
-
-void
-parse_mac_string(void)
-{
-	struct xstate *x = xstatus();
-	struct macaddr *mac = &x->mac;
-
-	size_t mac_byte;
-
-	size_t rval;
-
-	if (slen(x->mac.str, 18, &rval) != 17)
-		exitf("MAC address is the wrong length");
-
-	memset(mac->mac_buf, 0, sizeof(mac->mac_buf));
-
-	for (mac_byte = 0; mac_byte < 6; mac_byte++)
-		set_mac_byte(mac_byte);
-
-	if ((mac->mac_buf[0] | mac->mac_buf[1] | mac->mac_buf[2]) == 0)
-		exitf("Must not specify all-zeroes MAC address");
-
-	if (mac->mac_buf[0] & 1)
-		exitf("Must not specify multicast MAC address");
-}
-
-void
-set_mac_byte(size_t mac_byte_pos)
-{
-	struct xstate *x = xstatus();
-	struct macaddr *mac = &x->mac;
-
-	char separator;
-
-	size_t mac_str_pos;
-	size_t mac_nib_pos;
-
-	mac_str_pos = mac_byte_pos * 3;
-
-	if (mac_str_pos < 15) {
-		if ((separator = mac->str[mac_str_pos + 2]) != ':')
-			exitf("Invalid MAC address separator '%c'",
-			    separator);
-	}
-
-	for (mac_nib_pos = 0; mac_nib_pos < 2; mac_nib_pos++)
-		set_mac_nib(mac_str_pos, mac_byte_pos, mac_nib_pos);
-}
-
-void
-set_mac_nib(size_t mac_str_pos,
-    size_t mac_byte_pos, size_t mac_nib_pos)
-{
-	struct xstate *x = xstatus();
-	struct macaddr *mac = &x->mac;
-
-	char mac_ch;
-	unsigned short hex_num;
-
-	mac_ch = mac->str[mac_str_pos + mac_nib_pos];
-
-	if ((hex_num = hextonum(mac_ch)) > 15) {
-		if (hex_num >= 17)
-			exitf("Randomisation failure");
-		else
-			exitf("Invalid character '%c'",
-			    mac->str[mac_str_pos + mac_nib_pos]);
-	}
-
-	/* If random, ensure that local/unicast bits are set.
-	 */
-	if ((mac_byte_pos == 0) && (mac_nib_pos == 1) &&
-	    ((mac_ch | 0x20) == 'x' ||
-	    (mac_ch == '?')))
-		hex_num = (hex_num & 0xE) | 2; /* local, unicast */
-
-	/* MAC words stored big endian in-file, little-endian
-	 * logically, so we reverse the order.
-	 */
-	mac->mac_buf[mac_byte_pos >> 1] |= hex_num <<
-	    (((mac_byte_pos & 1) << 3) /* left or right byte? */
-	    | ((mac_nib_pos ^ 1) << 2)); /* left or right nib? */
-}
-
-void
-write_mac_part(size_t partnum)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-	struct macaddr *mac = &x->mac;
-
-	size_t w;
-
-	check_bin(partnum, "part number");
-	if (!f->part_valid[partnum])
-		return;
-
-	for (w = 0; w < 3; w++)
-		set_nvm_word(w, partnum, mac->mac_buf[w]);
-
-	printf("Wrote MAC address to part %lu: ",
-	    (size_t)partnum);
-	print_mac_from_nvm(partnum);
-}
-
-void
-cmd_helper_dump(void)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	size_t p;
-
-	check_cmd(cmd_helper_dump, "dump");
-
-	f->part_valid[0] = good_checksum(0);
-	f->part_valid[1] = good_checksum(1);
-
-	for (p = 0; p < 2; p++) {
-
-		if (!f->part_valid[p]) {
-
-			fprintf(stderr,
-			    "BAD checksum %04x in part %lu (expected %04x)\n",
-			    nvm_word(NVM_CHECKSUM_WORD, p),
-			    (size_t)p,
-			    calculated_checksum(p));
-		}
-
-		printf("MAC (part %lu): ",
-		    (size_t)p);
-
-		print_mac_from_nvm(p);
-		spew_hex(f->buf + (p * GBE_PART_SIZE), NVM_SIZE);
-	}
-}
-
-void
-print_mac_from_nvm(size_t partnum)
-{
-	size_t c;
-	unsigned short val16;
-
-	for (c = 0; c < 3; c++) {
-
-		val16 = nvm_word(c, partnum);
-
-		printf("%02x:%02x",
-		    (unsigned int)(val16 & 0xff),
-		    (unsigned int)(val16 >> 8));
-
-		if (c == 2)
-			printf("\n");
-		else
-			printf(":");
-	}
-}
-
-void
-cmd_helper_swap(void)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	check_cmd(cmd_helper_swap, "swap");
-
-	memcpy(
-	    f->buf + (size_t)GBE_WORK_SIZE,
-	    f->buf,
-	    GBE_PART_SIZE);
-
-	memcpy(
-	    f->buf,
-	    f->buf + (size_t)GBE_PART_SIZE,
-	    GBE_PART_SIZE);
-
-	memcpy(
-	    f->buf + (size_t)GBE_PART_SIZE,
-	    f->buf + (size_t)GBE_WORK_SIZE,
-	    GBE_PART_SIZE);
-
-	set_part_modified(0);
-	set_part_modified(1);
-}
-
-void
-cmd_helper_copy(void)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	check_cmd(cmd_helper_copy, "copy");
-
-	memcpy(
-	    f->buf + (size_t)((f->part ^ 1) * GBE_PART_SIZE),
-	    f->buf + (size_t)(f->part * GBE_PART_SIZE),
-	    GBE_PART_SIZE);
-
-	set_part_modified(f->part ^ 1);
-}
-
-void
-cmd_helper_cat(void)
-{
-	struct xstate *x = xstatus();
-
-	check_cmd(cmd_helper_cat, "cat");
-
-	x->cat = 0;
-	cat(0);
-}
-
-void
-cmd_helper_cat16(void)
-{
-	struct xstate *x = xstatus();
-
-	check_cmd(cmd_helper_cat16, "cat16");
-
-	x->cat = 1;
-	cat(1);
-}
-
-void
-cmd_helper_cat128(void)
-{
-	struct xstate *x = xstatus();
-
-	check_cmd(cmd_helper_cat128, "cat128");
-
-	x->cat = 15;
-	cat(15);
-}
-
-void
-cat(size_t nff)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	size_t p;
-	size_t ff;
-
-	p = 0;
-	ff = 0;
-
-	if ((size_t)x->cat != nff) {
-
-		exitf("erroneous call to cat");
-	}
-
-	fflush(NULL);
-
-	memset(f->pad, 0xff, GBE_PART_SIZE);
-
-	for (p = 0; p < 2; p++) {
-
-		cat_buf(f->bufcmp +
-		    (size_t)(p * (f->gbe_file_size >> 1)));
-
-		for (ff = 0; ff < nff; ff++) {
-
-			cat_buf(f->pad);
-		}
-	}
-}
-
-void
-cat_buf(unsigned char *b)
-{
-	if (b == NULL)
-		exitf("null pointer in cat command");
-
-	if (rw_exact(STDOUT_FILENO, b,
-	    GBE_PART_SIZE, 0, IO_WRITE) < 0)
-		exitf("stdout: cat");
-}
-void
-check_cmd(void (*fn)(void),
-    const char *name)
-{
-	struct xstate *x = xstatus();
-	size_t i = x->i;
-
-	if (x->cmd[i].run != fn)
-		exitf("Running %s, but cmd %s is set",
-		    name, x->cmd[i].str);
-
-	/* prevent second command
-	 */
-	for (i = 0; i < items(x->cmd); i++)
-		x->cmd[i].run = cmd_helper_err;
-}
-
-void
-cmd_helper_err(void)
-{
-	exitf(
-	    "Erroneously running command twice");
-}
@@ -1,817 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>
- *
- * Pathless i/o, and some stuff you
- * probably never saw in userspace.
- *
- * Be nice to the demon.
- */
-
-/*
-TODO: putting it here just so it's somewhere:
-PATH_MAX is not reliable as a limit for paths,
-because the real length depends on mount point,
-and specific file systems.
-more correct usage example:
-long max = pathconf("/", _PC_PATH_MAX);
- */
-
-/* for openat2: */
-#ifdef __linux__
-#if !defined(USE_OPENAT) || \
-    ((USE_OPENAT) < 1) /* if 1: use openat, not openat2 */
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE 1
-#endif
-#include <linux/openat2.h>
-#include <sys/syscall.h>
-#endif
-#endif
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "../include/common.h"
-
-/* check that a file changed
- */
-
-int
-same_file(int fd, struct stat *st_old,
-    int check_size)
-{
-	struct stat st;
-	int saved_errno = errno;
-	int rval = 0;
-	errno = 0;
-
-	if (if_err(st_old == NULL, EFAULT) ||
-	    if_err(fd < 0, EBADF) ||
-	    (rval = fstat(fd, &st)) < 0 ||
-	    (rval = fd_verify_regular(fd, st_old, &st)) < 0 ||
-	    if_err(check_size && st.st_size != st_old->st_size, ESTALE))
-		return with_fallback_errno(ESTALE);
-
-	reset_caller_errno(rval);
-	return 0;
-}
-
-int
-fsync_dir(const char *path)
-{
-	int saved_errno = errno;
-	size_t pathlen = 0;
-	char *dirbuf = NULL;
-	int dirfd = -1;
-	char *slash = NULL;
-	struct stat st = {0};
-	int rval = 0;
-	errno = 0;
-
-	if (if_err(slen(path, PATH_MAX, &pathlen) == 0, EINVAL))
-		goto err_fsync_dir;
-
-	memcpy(smalloc(&dirbuf, pathlen + 1),
-	    path, pathlen + 1);
-	slash = strrchr(dirbuf, '/');
-
-	if (slash != NULL) {
-		*slash = '\0';
-		if (*dirbuf == '\0') {
-			dirbuf[0] = '/';
-			dirbuf[1] = '\0';
-		}
-	} else {
-		dirbuf[0] = '.';
-		dirbuf[1] = '\0';
-	}
-
-	dirfd = fs_open(dirbuf,
-	    O_RDONLY | O_CLOEXEC | O_NOCTTY
-#ifdef O_DIRECTORY
-	    | O_DIRECTORY
-#endif
-#ifdef O_NOFOLLOW
-	    | O_NOFOLLOW
-#endif
-);
-
-	if (if_err_sys(dirfd < 0) ||
-	    if_err_sys((rval = fstat(dirfd, &st)) < 0) ||
-	    if_err(!S_ISDIR(st.st_mode), ENOTDIR)
-	    ||
-	    if_err_sys((rval = fsync_on_eintr(dirfd)) == -1))
-		goto err_fsync_dir;
-
-	xclose(&dirfd);
-	free_and_set_null(&dirbuf);
-
-	reset_caller_errno(rval);
-	return 0;
-
-err_fsync_dir:
-	free_and_set_null(&dirbuf);
-	xclose(&dirfd);
-
-	return with_fallback_errno(EIO);
-}
-
-/* rw_exact() - Read perfectly or die
- *
- * Read/write, and absolutely insist on an
- * absolute read; e.g. if 100 bytes are
- * requested, this MUST return 100.
- *
- * This function will never return zero.
- * It will only return below (error),
- * or above (success). On error, -1 is
- * returned and errno is set accordingly.
- *
- * Zero-byte returns are not allowed.
- * It will re-spin a finite number of
- * times upon zero-return, to recover,
- * otherwise it will return an error.
- */
-
-ssize_t
-rw_exact(int fd, unsigned char *mem, size_t nrw,
-    off_t off, int rw_type)
-{
-	int saved_errno = errno;
-	ssize_t rval = 0;
-	ssize_t rc = 0;
-	size_t nrw_cur;
-	off_t off_cur;
-	void *mem_cur;
-	errno = 0;
-
-	if (io_args(fd, mem, nrw, off, rw_type) == -1)
-		goto err_rw_exact;
-
-	while (1) {
-	
-		/* Prevent theoretical overflow */
-		if (if_err(rval >= 0 && (size_t)rval > (nrw - (size_t)rc),
-		    EOVERFLOW))
-			goto err_rw_exact;
-
-		rc += rval;
-		if ((size_t)rc >= nrw)
-			break;
-
-		mem_cur = (void *)(mem + (size_t)rc);
-		nrw_cur = (size_t)(nrw - (size_t)rc);
-
-		if (if_err(off < 0, EOVERFLOW))
-			goto err_rw_exact;
-
-		off_cur = off + (off_t)rc;
-
-		if ((rval = rw(fd, mem_cur, nrw_cur, off_cur, rw_type)) <= 0)
-			goto err_rw_exact;
-	}
-
-	if (if_err((size_t)rc != nrw, EIO) ||
-	    (rval = rw_over_nrw(rc, nrw)) < 0)
-		goto err_rw_exact;
-
-	reset_caller_errno(rval);
-	return rval;
-
-err_rw_exact:
-	return with_fallback_errno(EIO);
-}
-
-/**
- * rw() - read-write but with more
- * safety checks than barebones libc
- *
- * A fallback is provided for regular read/write.
- * rw_type can be IO_READ (read), IO_WRITE (write),
- * IO_PREAD (pread) or IO_PWRITE
- *
- * WARNING: this function allows zero-byte returns.
- * this is intentional, to mimic libc behaviour.
- * use rw_exact if you need to avoid this.
- * (ditto partial writes/reads)
- *
- */
-ssize_t
-rw(int fd, void *mem, size_t nrw,
-    off_t off, int rw_type)
-{
-	ssize_t rval = 0;
-	ssize_t r = -1;
-	int saved_errno = errno;
-	errno = 0;
-
-	if (io_args(fd, mem, nrw, off, rw_type) == -1 ||
-	    if_err(mem == NULL, EFAULT) ||
-	    if_err(fd < 0, EBADF) ||
-	    if_err(off < 0, EFAULT) ||
-	    if_err(nrw == 0, EINVAL))
-		return with_fallback_errno(EIO);
-
-	do {
-		switch (rw_type) {
-		case IO_READ:
-			r = read(fd, mem, nrw);
-			break;
-		case IO_WRITE:
-			r = write(fd, mem, nrw);
-			break;
-		case IO_PREAD:
-			r = pread(fd, mem, nrw, off);
-			break;
-		case IO_PWRITE:
-			r = pwrite(fd, mem, nrw, off);
-			break;
-		default:
-			errno = EINVAL;
-			break;
-		}
-
-	} while (rw_retry(saved_errno, r));
-	
-	if ((rval = rw_over_nrw(r, nrw)) < 0)
-		return with_fallback_errno(EIO);
-
-	reset_caller_errno(rval);
-	return rval;
-}
-
-int
-io_args(int fd, void *mem, size_t nrw,
-    off_t off, int rw_type)
-{
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(mem == NULL, EFAULT) ||
-	    if_err(fd < 0, EBADF) ||
-	    if_err(off < 0, ERANGE) ||
-	    if_err(!nrw, EPERM) || /* TODO: toggle zero-byte check */
-	    if_err(nrw > (size_t)SSIZE_MAX, ERANGE) ||
-	    if_err(((size_t)off + nrw) < (size_t)off, ERANGE) ||
-	    if_err(rw_type > IO_PWRITE, EINVAL))
-		goto err_io_args;
-
-	reset_caller_errno(0);
-	return 0;
-
-err_io_args:
-	return with_fallback_errno(EINVAL);
-}
-
-int
-check_file(int fd, struct stat *st)
-{
-	int saved_errno = errno;
-	int rval = 0;
-	errno = 0;
-
-	if (if_err(fd < 0, EBADF) ||
-	    if_err(st == NULL, EFAULT) ||
-	    ((rval = fstat(fd, st)) == -1) ||
-	    if_err(!S_ISREG(st->st_mode), EBADF))
-		goto err_is_file;
-
-	reset_caller_errno(rval);
-	return 0;
-
-err_is_file:
-	return with_fallback_errno(EINVAL);
-}
-
-/* POSIX can say whatever it wants.
- * specification != implementation
- */
-ssize_t
-rw_over_nrw(ssize_t r, size_t nrw)
-{
-	if (if_err(!nrw, EIO) ||
-	    (r == -1) ||
-	    if_err((size_t)r > SSIZE_MAX, ERANGE) ||
-	    if_err((size_t)r > nrw, ERANGE))
-		return with_fallback_errno(EIO);
-
-	return r;
-}
-
-/* two functions that reduce sloccount by
- * two hundred lines */
-int
-if_err(int condition, int errval)
-{
-	if (!condition)
-		return 0;
-	if (errval)
-		errno = errval;
-	return 1;
-}
-int
-if_err_sys(int condition)
-{
-	if (!condition)
-		return 0;
-	return 1;
-}
-
-int
-fs_rename_at(int olddirfd, const char *old,
-    int newdirfd, const char *new)
-{
-	if (if_err(new == NULL || old == NULL, EFAULT) ||
-	    if_err(olddirfd < 0 || newdirfd < 0, EBADF))
-		return -1;
-
-	return renameat(olddirfd, old, newdirfd, new);
-}
-
-/* secure open, based on relative path to root
- *
- * always a fixed fd for / see: rootfs()
- * and fs_resolve_at()
- */
-int
-fs_open(const char *path, int flags)
-{
-	struct filesystem *fs;
-
-	if (if_err(path == NULL, EFAULT) ||
-	    if_err(path[0] != '/', EINVAL) ||
-	    if_err_sys((fs = rootfs()) == NULL))
-		return -1;
-
-	return fs_resolve_at(fs->rootfd, path + 1, flags);
-}
-
-/* singleton function that returns a fixed descriptor of /
- * used throughout, for repeated integrity checks
- */
-struct filesystem *
-rootfs(void)
-{
-	static struct filesystem global_fs;
-	static int fs_initialised = 0;
-
-	if (!fs_initialised) {
-
-		global_fs.rootfd = -1;
-
-		open_file_on_eintr("/", &global_fs.rootfd,
-		    O_RDONLY | O_DIRECTORY | O_CLOEXEC, 0400, NULL);
-
-		if (global_fs.rootfd < 0)
-			return NULL;
-
-		fs_initialised = 1;
-	}
-
-	return &global_fs;
-}
-
-/* filesystem sandboxing in userspace
- * TODO:
-	missing length bound check.
-	potential CPU DoS on very long paths, spammed repeatedly.
-	perhaps cap at MAX_PATH?
- */
-int
-fs_resolve_at(int dirfd, const char *path, int flags)
-{
-	int nextfd = -1;
-	int curfd;
-	const char *p;
-	char name[PATH_MAX];
-	int saved_errno = errno;
-	int r;
-	int is_last;
-	errno = 0;
-
-	if (dirfd < 0 || path == NULL || *path == '\0') {
-		errno = EINVAL;
-		return -1;
-	}
-
-	p = path;
-	curfd = dirfd; /* start here */
-
-	for (;;) {
-		r = fs_next_component(&p, name, sizeof(name));
-		if (r < 0)
-			goto err;
-		if (r == 0)
-			break;
-
-		is_last = (*p == '\0');
-
-		nextfd = fs_open_component(curfd, name, flags, is_last);
-		if (nextfd < 0)
-			goto err;
-
-		/* close previous fd if not the original input */
-		if (curfd != dirfd)
-			xclose(&curfd);
-
-		curfd = nextfd;
-		nextfd = -1;
-	}
-
-	reset_caller_errno(0);
-	return curfd;
-
-err:
-	saved_errno = errno;
-
-	if (nextfd >= 0)
-		xclose(&nextfd);
-
-	/* close curfd only if it's not the original */
-	if (curfd != dirfd && curfd >= 0)
-		xclose(&curfd);
-
-	errno = saved_errno;
-	return with_fallback_errno(EIO);
-}
-
-/* NOTE:
-	rejects . and .. but not empty strings
-	after normalisation. edge case:
-	//////
-
-	normalised implicitly, but might be good
-	to add a defensive check regardless. code
-	probably not exploitable in current state.
- */
-int
-fs_next_component(const char **p,
-    char *name, size_t namesz)
-{
-	const char *s = *p;
-	size_t len = 0;
-
-	while (*s == '/')
-		s++;
-
-	if (*s == '\0') {
-		*p = s;
-		return 0;
-	}
-
-	while (s[len] != '/' && s[len] != '\0')
-		len++;
-
-	if (len == 0 || len >= namesz ||
-	    len >= PATH_MAX) {
-		errno = ENAMETOOLONG;
-		return -1;
-	}
-
-	memcpy(name, s, len);
-	name[len] = '\0';
-
-	/* reject . and .. */
-	if (if_err((name[0] == '.' && name[1] == '\0') ||
-	    (name[0] == '.' && name[1] == '.' && name[2] == '\0'), EPERM))
-		goto err;
-
-	*p = s + len;
-	return 1;
-err:
-	return with_fallback_errno(EPERM);
-}
-
-int
-fs_open_component(int dirfd, const char *name,
-    int flags, int is_last)
-{
-	int saved_errno = errno;
-	int fd;
-	struct stat st;
-	errno = 0;
-
-	fd = openat_on_eintr(dirfd, name,
-	    (is_last ? flags : (O_RDONLY | O_DIRECTORY)) |
-	    O_NOFOLLOW | O_CLOEXEC, (flags & O_CREAT) ? 0600 : 0);
-
-	if (!is_last &&
-	    (if_err(fd < 0, EBADF) ||
-	     if_err_sys(fstat(fd, &st) < 0) ||
-	     if_err(!S_ISDIR(st.st_mode), ENOTDIR)))
-		return with_fallback_errno(EIO);
-
-	reset_caller_errno(fd);
-	return fd;
-}
-
-int
-fs_dirname_basename(const char *path,
-    char **dir, char **base,
-    int allow_relative)
-{
-	int saved_errno = errno;
-	char *buf = NULL;
-	char *slash;
-	size_t len;
-	const char *d = NULL;
-	const char *b = NULL;
-	errno = 0;
-
-	if (if_err(path == NULL || dir == NULL || base == NULL, EFAULT))
-		goto err;
-
-	slen(path, PATH_MAX, &len);
-	memcpy(smalloc(&buf, len + 1),
-	    path, len + 1);
-
-	/* strip trailing slashes */
-	while (len > 1 && buf[len - 1] == '/')
-		buf[--len] = '\0';
-
-	slash = strrchr(buf, '/');
-
-	if (slash) {
-
-		*slash = '\0';
-		d = buf;
-		b = slash + 1;
-
-		if (*d == '\0')
-			d = "/";
-	} else if (allow_relative) {
-
-		d = ".";
-		b = buf;
-	} else {
-		free_and_set_null(&buf);
-		goto err;
-	}
-
-	if (dup_pair(dir, d, base, b) < 0) {
-		free_and_set_null(&buf);
-		goto err;
-	}
-
-	free_and_set_null(&buf);
-
-	reset_caller_errno(0);
-	return 0;
-err:
-	return with_fallback_errno(EINVAL);
-}
-
-/* TODO: why does this abort, but others
-   e.g. open_file_on_eintr, don't???
- */
-void
-open_file_on_eintr(const char *path,
-    int *fd, int flags, mode_t mode,
-    struct stat *st)
-{
-	int saved_errno = errno;
-	int rval = 0;
-	errno = 0;
-
-	if (path == NULL)
-		exitf("open_file_on_eintr: null path");
-	if (fd == NULL)
-		exitf("%s: open_file_on_eintr: null fd ptr", path);
-	if (*fd >= 0)
-		exitf(
-		    "%s: open_file_on_eintr: file already open", path);
-
-	errno = 0;
-	while (fs_retry(saved_errno,
-	    rval = open(path, flags, mode)));
-
-	if (rval < 0)
-		exitf(
-		    "%s: open_file_on_eintr: could not close", path);
-
-	reset_caller_errno(rval);
-	*fd = rval;
-
-	/* we don't care about edge case behaviour here,
-	   even if the next operation sets errno on success,
-	   because the open() call is our main concern.
-	   however, we also must preserve the new errno,
-	   assuming it changed above under the same edge case */
-
-	saved_errno = errno;
-
-	if (st != NULL) {
-		if (fstat(*fd, st) < 0)
-			exitf("%s: stat", path);
-
-		if (!S_ISREG(st->st_mode))
-			exitf("%s: not a regular file", path);
-	}
-
-	if (lseek(*fd, 0, SEEK_CUR) == (off_t)-1)
-		exitf("%s: file not seekable", path);
-
-	errno = saved_errno; /* see previous comment */
-}
-
-
-#if defined(__linux__) && \
-    (!defined(USE_OPENAT) || ((USE_OPENAT) < 1)) /* we use openat2 on linux */
-int
-openat_on_eintr(int dirfd, const char *path,
-    int flags, mode_t mode)
-{
-	struct open_how how = {
-		.flags = (unsigned long long)flags,
-		.mode = mode,
-		.resolve =
-		    RESOLVE_BENEATH |
-		    RESOLVE_NO_SYMLINKS |
-		    RESOLVE_NO_MAGICLINKS
-	};
-	int saved_errno = errno;
-	long rval = 0;
-	errno = 0;
-
-	if (if_err(dirfd < 0, EBADF) ||
-	    if_err(path == NULL, EFAULT))
-		goto err;
-
-	errno = 0;
-	while (sys_retry(saved_errno,
-	    rval = syscall(SYS_openat2, dirfd, path, &how, sizeof(how))));
-
-	if (rval == -1) /* avoid long->int UB for -1 */
-		goto err;
-
-	reset_caller_errno(rval);
-	return (int)rval;
-err:
-	return with_fallback_errno(EIO); /* -1 */
-}
-#else /* regular openat on non-linux e.g. openbsd */
-int
-openat_on_eintr(int dirfd, const char *path,
-    int flags, mode_t mode)
-{
-	int saved_errno = errno;
-	int rval = 0;
-	errno = 0;
-
-	if (if_err(dirfd < 0, EBADF) ||
-	    if_err(path == NULL, EFAULT))
-		return with_fallback_errno(EIO);
-
-	while (fs_retry(saved_errno,
-	    rval = openat(dirfd, path, flags, mode)));
-
-	reset_caller_errno(rval);
-	return rval;
-}
-#endif
-
-int
-mkdirat_on_eintr(int dirfd, 
-    const char *path, mode_t mode)
-{
-	int saved_errno = errno;
-	int rval = 0;
-	errno = 0;
-
-	if (if_err(dirfd < 0, EBADF) ||
-	    if_err(path == NULL, EFAULT))
-		return with_fallback_errno(EIO);
-
-	while (fs_retry(saved_errno,
-	    rval = mkdirat(dirfd, path, mode)));
-
-	reset_caller_errno(rval);
-	return rval;
-}
-
-int
-fsync_on_eintr(int fd)
-{
-	int saved_errno = errno;
-	int rval = 0;
-	errno = 0;
-
-	if (if_err(fd < 0, EBADF))
-		return with_fallback_errno(EIO);
-
-	while (fs_retry(saved_errno,
-	    rval = fsync(fd)));
-
-	reset_caller_errno(rval);
-	return rval;
-}
-
-void
-xclose(int *fd)
-{
-	int saved_errno = errno;
-	int rval = 0;
-
-	if (fd == NULL)
-		exitf("xclose: null pointer");
-	if (*fd < 0)
-		return;
-
-	/* nuance regarding EINTR on close():
-	 * EINTR can be set on error, but there's
-	 * no guarantee whether the fd is then still
-	 * open or closed. on some other commands, we
-	 * loop EINTR, but for close, we instead skip
-	 * aborting *if the errno is EINTR* - so don't
-	 * loop it, but do regard EINTR with rval -1
-	 * as essenitally a successful close()
-	 */
-
-	/* because we don't want to mess with someone
-	 * elses file if that fd is then reassigned.
-	 * if the operation truly did fail, we ignore
-	 * it. just leave it flying in the wind */
-
-	errno = 0;
-	if ((rval = close(*fd)) < 0) {
-		if (errno != EINTR)
-			exitf("xclose: could not close");
-
-		/* regard EINTR as a successful close */
-		rval = 0;
-	}
-
-	*fd = -1;
-
-	reset_caller_errno(rval);
-}
-
-/* unified eintr looping.
- * differently typed functions
- * to avoid potential UB
- *
- * ONE MACRO TO RULE THEM ALL:
- */
-#define fs_err_retry() \
-	do { \
-		if ((rval == -1) && \
-		    (errno == EINTR)) \
-			return 1; \
-		if (rval >= 0 && !errno) \
-			errno = saved_errno; \
-		return 0; \
-	} while(0)
-/*
- * Regarding the errno logic above:
- * on success, it is permitted that
- * a syscall could still set errno.
- * We reset errno after storingit
- * for later preservation, in functions
- * that call *_retry() functions.
- *
- * They rely ultimately on this
- * macro for errno restoration. We
- * assume therefore that errno was
- * reset to zero before the retry
- * loop. If errno is then *set* on
- * success, we leave it alone. Otherwise,
- * we restore the caller's saved errno.
- *
- * This offers some consistency, while
- * complying with POSIX specification.
- */
-
-
-/* retry switch for functions that
-   return long status e.g. linux syscall
- */
-int
-sys_retry(int saved_errno, long rval)
-{
-	fs_err_retry();
-}
-
-/* retry switch for functions that
-   return int status e.g. mkdirat
- */
-int
-fs_retry(int saved_errno, int rval)
-{
-	fs_err_retry();
-}
-
-/* retry switch for functions that
-   return rw count in ssize_t e.g. read()
- */
-int
-rw_retry(int saved_errno, ssize_t rval)
-{
-	fs_err_retry();
-}
@@ -1,563 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>
- *
- * I/O functions specific to nvmutil.
- */
-
-/* TODO: local tmpfiles not being deleted
-	when flags==O_RDONLY e.g. dump command
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "../include/common.h"
-
-void
-open_gbe_file(void)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd = &x->cmd[x->i];
-	struct xfile *f = &x->f;
-	int saved_errno = errno;
-	errno = 0;
-
-	int _flags;
-
-	f->gbe_fd = -1;
-
-	open_file_on_eintr(f->fname, &f->gbe_fd,
-	    O_NOFOLLOW | O_CLOEXEC | O_NOCTTY,
-	    ((cmd->flags & O_ACCMODE) == O_RDONLY) ? 0400 : 0600,
-	    &f->gbe_st);
-
-	if (f->gbe_st.st_nlink > 1)
-		exitf(
-		    "%s: warning: file has multiple (%lu) hard links\n",
-		    f->fname, (size_t)f->gbe_st.st_nlink);
-
-	if (f->gbe_st.st_nlink == 0)
-		exitf("%s: file unlinked while open", f->fname);
-
-	if ((_flags = fcntl(f->gbe_fd, F_GETFL)) == -1)
-		exitf("%s: fcntl(F_GETFL)", f->fname);
-
-	/* O_APPEND allows POSIX write() to ignore
-	 * the current write offset and write at EOF,
-	 * which would break positional read/write
-	 */
-
-	if (_flags & O_APPEND)
-		exitf("%s: O_APPEND flag", f->fname);
-
-	f->gbe_file_size = f->gbe_st.st_size;
-
-	switch (f->gbe_file_size) {
-	case SIZE_8KB:
-	case SIZE_16KB:
-	case SIZE_128KB:
-		break;
-	default:
-		exitf("File size must be 8KB, 16KB or 128KB");
-	}
-
-/* currently fails (EBADF), locks are advisory anyway: */
-/*
-	if (lock_file(f->gbe_fd, cmd->flags) == -1)
-		exitf("%s: can't lock", f->fname);
-*/
-
-	reset_caller_errno(0);
-}
-
-void
-copy_gbe(void)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	read_file();
-
-	if (f->gbe_file_size == SIZE_8KB)
-		return;
-
-	memcpy(f->buf + (size_t)GBE_PART_SIZE,
-	    f->buf + (size_t)(f->gbe_file_size >> 1),
-	    (size_t)GBE_PART_SIZE);
-}
-
-void
-read_file(void)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	struct stat _st;
-	ssize_t _r;
-
-	/* read main file
-	 */
-	_r = rw_exact(f->gbe_fd, f->buf, f->gbe_file_size,
-	    0, IO_PREAD);
-
-	if (_r < 0)
-		exitf("%s: read failed", f->fname);
-
-	/* copy to tmpfile
-	 */
-	_r = rw_exact(f->tmp_fd, f->buf, f->gbe_file_size,
-	    0, IO_PWRITE);
-
-	if (_r < 0)
-		exitf("%s: %s: copy failed",
-		    f->fname, f->tname);
-
-	/* file size comparison
-	 */
-	if (fstat(f->tmp_fd, &_st) == -1)
-		exitf("%s: stat", f->tname);
-
-	f->gbe_tmp_size = _st.st_size;
-
-	if (f->gbe_tmp_size != f->gbe_file_size)
-		exitf("%s: %s: not the same size",
-		    f->fname, f->tname);
-
-	/* needs sync, for verification
-	 */
-	if (fsync_on_eintr(f->tmp_fd) == -1)
-		exitf("%s: fsync (tmpfile copy)", f->tname);
-
-	_r = rw_exact(f->tmp_fd, f->bufcmp, f->gbe_file_size,
-	    0, IO_PREAD);
-
-	if (_r < 0)
-		exitf("%s: read failed (cmp)", f->tname);
-
-	if (vcmp(f->buf, f->bufcmp, f->gbe_file_size) != 0)
-		exitf("%s: %s: read contents differ (pre-test)",
-		    f->fname, f->tname);
-}
-
-void
-write_gbe_file(void)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd = &x->cmd[x->i];
-	struct xfile *f = &x->f;
-
-	size_t p;
-	unsigned char update_checksum;
-
-	if ((cmd->flags & O_ACCMODE) == O_RDONLY)
-		return;
-
-	if (same_file(f->tmp_fd, &f->tmp_st, 0) < 0)
-		exitf("%s: file inode/device changed", f->tname);
-
-	if (same_file(f->gbe_fd, &f->gbe_st, 1) < 0)
-		exitf("%s: file has changed", f->fname);
-
-	update_checksum = cmd->chksum_write;
-
-	for (p = 0; p < 2; p++) {
-		if (!f->part_modified[p])
-			continue;
-
-		if (update_checksum)
-			set_checksum(p);
-
-		rw_gbe_file_part(p, IO_PWRITE, "pwrite");
-	}
-}
-
-void
-rw_gbe_file_part(size_t p, int rw_type,
-    const char *rw_type_str)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd = &x->cmd[x->i];
-	struct xfile *f = &x->f;
-
-	ssize_t rval;
-
-	off_t file_offset;
-
-	size_t gbe_rw_size;
-	unsigned char *mem_offset;
-
-	gbe_rw_size = cmd->rw_size;
-
-	if (rw_type < IO_PREAD || rw_type > IO_PWRITE)
-		exitf("%s: %s: part %lu: invalid rw_type, %d",
-		    f->fname, rw_type_str, (size_t)p, rw_type);
-
-	mem_offset = gbe_mem_offset(p, rw_type_str);
-	file_offset = (off_t)gbe_file_offset(p, rw_type_str);
-
-	rval = rw_gbe_file_exact(f->tmp_fd, mem_offset,
-	    gbe_rw_size, file_offset, rw_type);
-
-	if (rval == -1)
-		exitf("%s: %s: part %lu",
-		    f->fname, rw_type_str, (size_t)p);
-
-	if ((size_t)rval != gbe_rw_size)
-		exitf("%s: partial %s: part %lu",
-		    f->fname, rw_type_str, (size_t)p);
-}
-
-void
-write_to_gbe_bin(void)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd = &x->cmd[x->i];
-	struct xfile *f = &x->f;
-
-	int saved_errno;
-	int mv;
-
-	if ((cmd->flags & O_ACCMODE) != O_RDWR)
-		return;
-
-	write_gbe_file();
-
-	/* We may otherwise read from
-	 * cache, so we must sync.
-	 */
-
-	if (fsync_on_eintr(f->tmp_fd) == -1)
-		exitf("%s: fsync (pre-verification)",
-		    f->tname);
-
-	check_written_part(0);
-	check_written_part(1);
-
-	report_io_err_rw();
-
-	if (f->io_err_gbe)
-		exitf("%s: bad write", f->fname);
-
-	saved_errno = errno;
-
-	xclose(&f->tmp_fd);
-	xclose(&f->gbe_fd);
-
-	errno = saved_errno;
-
-	/* tmpfile written, now we
-	 * rename it back to the main file
-	 * (we do atomic writes)
-	 */
-
-	f->tmp_fd = -1;
-	f->gbe_fd = -1;
-
-	if (!f->io_err_gbe_bin) {
-
-		mv = gbe_mv();
-
-		if (mv < 0) {
-
-			f->io_err_gbe_bin = 1;
-
-			fprintf(stderr, "%s: %s\n",
-			    f->fname, strerror(errno));
-		} else {
-
-			/* removed by rename
-			 */
-			free_and_set_null(&f->tname);
-		}
-	}
-
-	if (!f->io_err_gbe_bin)
-		return;
-
-	fprintf(stderr, "FAIL (rename): %s: skipping fsync\n",
-	    f->fname);
-	if (errno)
-		fprintf(stderr,
-		    "errno %d: %s\n", errno, strerror(errno));
-}
-
-void
-check_written_part(size_t p)
-{
-	struct xstate *x = xstatus();
-	struct commands *cmd = &x->cmd[x->i];
-	struct xfile *f = &x->f;
-
-	ssize_t rval;
-
-	size_t gbe_rw_size;
-
-	off_t file_offset;
-	unsigned char *mem_offset;
-
-	unsigned char *buf_restore;
-
-	if (!f->part_modified[p])
-		return;
-
-	gbe_rw_size = cmd->rw_size;
-
-	mem_offset = gbe_mem_offset(p, "pwrite");
-	file_offset = (off_t)gbe_file_offset(p, "pwrite");
-
-	memset(f->pad, 0xff, sizeof(f->pad));
-
-	if (same_file(f->tmp_fd, &f->tmp_st, 0) < 0)
-		exitf("%s: file inode/device changed", f->tname);
-
-	if (same_file(f->gbe_fd, &f->gbe_st, 1) < 0)
-		exitf("%s: file changed during write", f->fname);
-
-	rval = rw_gbe_file_exact(f->tmp_fd, f->pad,
-	    gbe_rw_size, file_offset, IO_PREAD);
-
-	if (rval == -1)
-		f->rw_check_err_read[p] = f->io_err_gbe = 1;
-	else if ((size_t)rval != gbe_rw_size)
-		f->rw_check_partial_read[p] = f->io_err_gbe = 1;
-	else if (vcmp(mem_offset, f->pad, gbe_rw_size) != 0)
-		f->rw_check_bad_part[p] = f->io_err_gbe = 1;
-
-	if (f->rw_check_err_read[p] ||
-	    f->rw_check_partial_read[p])
-		return;
-
-	/* We only load one part on-file, into memory but
-	 * always at offset zero, for post-write checks.
-	 * That's why we hardcode good_checksum(0)
-	 */
-
-	buf_restore = f->buf;
-
-	/* good_checksum works on f->buf
-	 * so let's change f->buf for now
-	 */
-
-	f->buf = f->pad;
-
-	if (good_checksum(0))
-		f->post_rw_checksum[p] = 1;
-
-	f->buf = buf_restore;
-}
-
-void
-report_io_err_rw(void)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	size_t p;
-
-	if (!f->io_err_gbe)
-		return;
-
-	for (p = 0; p < 2; p++) {
-		if (!f->part_modified[p])
-			continue;
-
-		if (f->rw_check_err_read[p])
-			fprintf(stderr,
-			    "%s: pread: p%lu (post-verification)\n",
-			    f->fname, (size_t)p);
-		if (f->rw_check_partial_read[p])
-			fprintf(stderr,
-			    "%s: partial pread: p%lu (post-verification)\n",
-			    f->fname, (size_t)p);
-		if (f->rw_check_bad_part[p])
-			fprintf(stderr,
-			    "%s: pwrite: corrupt write on p%lu\n",
-			    f->fname, (size_t)p);
-
-		if (f->rw_check_err_read[p] ||
-		    f->rw_check_partial_read[p]) {
-			fprintf(stderr,
-			    "%s: p%lu: skipped checksum verification "
-			    "(because read failed)\n",
-			    f->fname, (size_t)p);
-
-			continue;
-		}
-
-		fprintf(stderr, "%s: ", f->fname);
-
-		if (f->post_rw_checksum[p])
-			fprintf(stderr, "GOOD");
-		else
-			fprintf(stderr, "BAD");
-
-		fprintf(stderr, " checksum in p%lu on-disk.\n",
-		    (size_t)p);
-
-		if (f->post_rw_checksum[p]) {
-			fprintf(stderr,
-			    "    This does NOT mean it's safe. it may be\n"
-			    "    salvageable if you use the cat feature.\n");
-		}
-	}
-}
-
-int
-gbe_mv(void)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	int rval;
-
-	int saved_errno;
-	int tmp_gbe_bin_exists;
-
-	/* will be set 0 if it doesn't
-	 */
-	tmp_gbe_bin_exists = 1;
-
-	saved_errno = errno;
-
-	rval = fs_rename_at(f->dirfd, f->tmpbase,
-	    f->dirfd, f->base);
-
-	if (rval > -1)
-		tmp_gbe_bin_exists = 0;
-
-	if (f->gbe_fd > -1) {
-		xclose(&f->gbe_fd);
-
-		if (fsync_dir(f->fname) < 0) {
-			f->io_err_gbe_bin = 1;
-			rval = -1;
-		}
-	}
-
-	xclose(&f->tmp_fd);
-
-	/* before this function is called,
-	 * tmp_fd may have been moved
-	 */
-	if (tmp_gbe_bin_exists) {
-		if (unlink(f->tname) < 0)
-			rval = -1;
-		else
-			tmp_gbe_bin_exists = 0;
-	}
-
-	if (rval >= 0) 
-		goto out;
-
-	return with_fallback_errno(EIO);
-out:
-	reset_caller_errno(rval);
-	return rval;
-}
-
-/* This one is similar to gbe_file_offset,
- * but used to check Gbe bounds in memory,
- * and it is *also* used during file I/O.
- */
-unsigned char *
-gbe_mem_offset(size_t p, const char *f_op)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	off_t gbe_off;
-
-	gbe_off = gbe_x_offset(p, f_op, "mem",
-	    GBE_PART_SIZE, GBE_WORK_SIZE);
-
-	return (unsigned char *)
-	    (f->buf + (size_t)gbe_off);
-}
-
-/* I/O operations filtered here. These operations must
- * only write from the 0th position or the half position
- * within the GbE file, and write 4KB of data.
- */
-off_t
-gbe_file_offset(size_t p, const char *f_op)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	off_t gbe_file_half_size;
-
-	gbe_file_half_size = f->gbe_file_size >> 1;
-
-	return gbe_x_offset(p, f_op, "file",
-	    gbe_file_half_size, f->gbe_file_size);
-}
-
-off_t
-gbe_x_offset(size_t p, const char *f_op, const char *d_type,
-    off_t nsize, off_t ncmp)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	off_t off;
-
-	check_bin(p, "part number");
-
-	off = ((off_t)p) * (off_t)nsize;
-
-	if (off > ncmp - GBE_PART_SIZE)
-		exitf("%s: GbE %s %s out of bounds",
-		    f->fname, d_type, f_op);
-
-	if (off != 0 && off != ncmp >> 1)
-		exitf("%s: GbE %s %s at bad offset",
-		    f->fname, d_type, f_op);
-
-	return off;
-}
-
-ssize_t
-rw_gbe_file_exact(int fd, unsigned char *mem, size_t nrw,
-    off_t off, int rw_type)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	ssize_t r;
-
-	if (io_args(fd, mem, nrw, off, rw_type) == -1)
-		return -1;
-
-	if (mem != (void *)f->pad) {
-		if (mem < f->buf)
-			goto err_rw_gbe_file_exact;
-
-		if ((size_t)(mem - f->buf) >= GBE_WORK_SIZE)
-			goto err_rw_gbe_file_exact;
-	}
-
-	if (off < 0 || off >= f->gbe_file_size)
-		goto err_rw_gbe_file_exact;
-
-	if (nrw > (size_t)(f->gbe_file_size - off))
-		goto err_rw_gbe_file_exact;
-
-	if (nrw > (size_t)GBE_PART_SIZE)
-		goto err_rw_gbe_file_exact;
-
-	r = rw_exact(fd, mem, nrw, off, rw_type);
-
-	return rw_over_nrw(r, nrw);
-
-err_rw_gbe_file_exact:
-	return with_fallback_errno(EIO);
-}
@@ -1,914 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>
- *
- * Hardened mktemp (be nice to the demon).
- */
-
-/* for openat2 / fast path: */
-#ifdef __linux__
-#if !defined(USE_OPENAT) || \
-    ((USE_OPENAT) < 1) /* if 1: use openat, not openat2 */
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE 1
-#endif
-#include <sys/syscall.h>
-#include <linux/openat2.h>
-#ifndef O_TMPFILE
-#define O_TMPFILE 020000000
-#endif
-#ifndef AT_EMPTY_PATH
-#define AT_EMPTY_PATH 0x1000
-#endif
-#endif
-#endif
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "../include/common.h"
-
-/* note: tmpdir is an override of TMPDIR or /tmp or /var/tmp */
-int
-new_tmpfile(int *fd, char **path, char *tmpdir,
-    const char *template)
-{
-	return new_tmp_common(fd, path, MKHTEMP_FILE,
-	    tmpdir, template);
-}
-
-/* note: tmpdir is an override of TMPDIR or /tmp or /var/tmp */
-int
-new_tmpdir(int *fd, char **path, char *tmpdir,
-    const char *template)
-{
-	return new_tmp_common(fd, path, MKHTEMP_DIR,
-	    tmpdir, template);
-}
-
-int
-new_tmp_common(int *fd, char **path, int type,
-    char *tmpdir, const char *template)
-{
-	struct stat st;
-
-	const char *templatestr;
-
-	size_t dirlen;
-	char *dest = NULL; /* final path (will be written into "path") */
-	int saved_errno = errno;
-	int dirfd = -1;
-	const char *fname = NULL;
-
-	struct stat st_dir_first;
-
-	char *fail_dir = NULL;
-
-	errno = 0;
-
-	if (if_err(path == NULL || fd == NULL, EFAULT) ||
-	    if_err(*fd >= 0, EEXIST)) /* don't touch someone else's file */
-		goto err;
-
-	/* regarding **path:
-	* the pointer (to the pointer)
-	* must nott be null, but we don't
-	* care about the pointer it points
-	* to. you should expect it to be
-	* replaced upon successful return
-	*
-	* (on error, it will not be touched)
-	*/
-
-	*fd = -1;
-
-	if (tmpdir == NULL) { /* no user override */
-#if defined(PERMIT_NON_STICKY_ALWAYS) && \
-    ((PERMIT_NON_STICKY_ALWAYS) > 0)
-		tmpdir = env_tmpdir(PERMIT_NON_STICKY_ALWAYS, &fail_dir, NULL);
-#else
-		tmpdir = env_tmpdir(0, &fail_dir, NULL);
-#endif
-	} else {
-
-#if defined(PERMIT_NON_STICKY_ALWAYS) && \
-    ((PERMIT_NON_STICKY_ALWAYS) > 0)
-		tmpdir = env_tmpdir(PERMIT_NON_STICKY_ALWAYS, &fail_dir,
-		    tmpdir);
-#else
-		tmpdir = env_tmpdir(0, &fail_dir, tmpdir);
-#endif
-	}
-	if (if_err(tmpdir ==NULL || *tmpdir == '\0' || *tmpdir != '/', EINVAL))
-		goto err;
-
-	if (template != NULL)
-		templatestr = template;
-	else
-		templatestr = "tmp.XXXXXXXXXX";
-
-       /* may as well calculate in advance */
-	dirlen = slen(tmpdir, PATH_MAX, &dirlen);
-	/* full path: */
-	dest = scatn(3, (const char *[]) { tmpdir, "/", templatestr },
-	    PATH_MAX, &dest);
-
-	fname = dest + dirlen + 1;
-
-	dirfd = fs_open(tmpdir,
-	    O_RDONLY | O_DIRECTORY);
-	if (dirfd < 0)
-		goto err;
-
-	if (fstat(dirfd, &st_dir_first) < 0)
-		goto err;
-
-	*fd = mkhtemp(fd, &st, dest, dirfd,
-	    fname, &st_dir_first, type);
-	if (*fd < 0)
-		goto err;
-
-	xclose(&dirfd);
-
-	errno = saved_errno;
-	*path = dest;
-
-	reset_caller_errno(0);
-	return 0;
-
-err:
-	free_and_set_null(&dest);
-
-	xclose(&dirfd);
-	xclose(fd);
-
-	/* where a TMPDIR isn't found, and we err,
-	 * we pass this back through for the
-	 * error message
-	 */
-	if (fail_dir != NULL)
-		*path = fail_dir;
-
-	errno = saved_errno;
-	return with_fallback_errno(EIO);
-}
-
-
-/* hardened TMPDIR parsing
- */
-
-char *
-env_tmpdir(int bypass_all_sticky_checks, char **tmpdir,
-    char *override_tmpdir)
-{
-	char *t = NULL;
-	int allow_noworld_unsticky;
-	int saved_errno = errno;
-
-	static const char tmp[] = "/tmp";
-	static const char vartmp[] = "/var/tmp";
-
-	char *rval = NULL;
-
-	errno = 0;
-
-	/* tmpdir is a user override, if set */
-	if (override_tmpdir == NULL)
-		t = getenv("TMPDIR");
-	else
-		t = override_tmpdir;
-
-	if (t != NULL && *t != '\0') {
-
-		if (tmpdir_policy(t,
-		    &allow_noworld_unsticky) < 0)
-			goto err;
-
-		if (!world_writeable_and_sticky(t,
-		    allow_noworld_unsticky,
-		    bypass_all_sticky_checks))
-			goto err;
-
-		rval = NULL;
-		if (t != NULL) {
-			if (sdup(t, PATH_MAX, &rval) == NULL)
-				goto err;
-		}
-		goto out;
-	}
-
-	allow_noworld_unsticky = 0;
-
-	if (world_writeable_and_sticky(tmp, allow_noworld_unsticky,
-	    bypass_all_sticky_checks))
-		rval = (char *)tmp;
-	else if (world_writeable_and_sticky(vartmp,
-	    allow_noworld_unsticky, bypass_all_sticky_checks))
-		rval = (char *)vartmp;
-	else
-		goto err;
-
-out:
-	reset_caller_errno(0);
-	if (tmpdir != NULL)
-		*tmpdir = rval;
-	return rval;
-err:
-	if (tmpdir != NULL && t != NULL)
-		*tmpdir = t;
-	(void) with_fallback_errno(EPERM);
-	return NULL;
-}
-
-int
-tmpdir_policy(const char *path,
-    int *allow_noworld_unsticky)
-{
-	int saved_errno = errno;
-	int r;
-	errno = 0;
-
-	if (if_err(path == NULL ||
-	    allow_noworld_unsticky == NULL, EFAULT))
-		goto err_tmpdir_policy;
-
-	*allow_noworld_unsticky = 1;
-
-	r = same_dir(path, "/tmp");
-	if (r < 0)
-		goto err_tmpdir_policy;
-	if (r > 0)
-		*allow_noworld_unsticky = 0;
-
-	r = same_dir(path, "/var/tmp");
-	if (r < 0)
-		goto err_tmpdir_policy;
-	if (r > 0)
-		*allow_noworld_unsticky = 0;
-
-	reset_caller_errno(0);
-	return 0;
-
-err_tmpdir_policy:
-	return with_fallback_errno(EPERM);
-}
-
-int
-same_dir(const char *a, const char *b)
-{
-	int fd_a = -1;
-	int fd_b = -1;
-
-	struct stat st_a;
-	struct stat st_b;
-
-	int saved_errno = errno;
-	int rval = 0; /* LOGICAL error, 0, if 0 is returned */
-	errno = 0;
-
-	/* optimisation: if both dirs
-	   are the same, we don't need
-	   to check anything. sehr schnell!
-	 */
-	/* bonus: scmp checks null for us */
-	if (!scmp(a, b, PATH_MAX, &rval))
-		goto success_same_dir;
-	else
-		rval = 0; /* reset */
-
-	if ((fd_a = fs_open(a, O_RDONLY | O_DIRECTORY | O_NOFOLLOW)) < 0 ||
-	    (fd_b = fs_open(b, O_RDONLY | O_DIRECTORY | O_NOFOLLOW)) < 0 ||
-	    fstat(fd_a, &st_a) < 0 ||
-	    fstat(fd_b, &st_b) < 0)
-		goto err_same_dir;
-
-	if (st_a.st_dev == st_b.st_dev &&
-	    st_a.st_ino == st_b.st_ino) {
-success_same_dir:
-		rval = 1; /* SUCCESS */
-	}
-
-	xclose(&fd_a);
-	xclose(&fd_b);
-
-	/* we reset caller errno regardless
-	 * of success, so long as it's not
-	 * a syscall error
-	 */
-	reset_caller_errno(0);
-	return rval;
-
-err_same_dir:
-	/* FAILURE (probably syscall) - returns -1
-	 */
-	xclose(&fd_a);
-	xclose(&fd_b);
-
-	return with_fallback_errno(EIO); /* -1 */
-}
-
-/* bypass_all_sticky_checks: if set,
-       disable stickiness checks (libc behaviour)
-       (if not set: leah behaviour)
-
-   allow_noworld_unsticky:
-       allow non-sticky files if not world-writeable
-       (still block non-sticky in standard TMPDIR)
-*/
-int
-world_writeable_and_sticky(
-    const char *s,
-    int allow_noworld_unsticky,
-    int bypass_all_sticky_checks)
-{
-	struct stat st;
-	int dirfd = -1;
-
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(s == NULL || *s == '\0', EINVAL) ||
-	    (dirfd = fs_open(s, O_RDONLY | O_DIRECTORY)) < 0 ||
-	    fstat(dirfd, &st) < 0 ||
-	    if_err(!S_ISDIR(st.st_mode), ENOTDIR))
-		goto sticky_hell;
-
-	/* *normal-**ish mode (libc):
-	 */
-	if (bypass_all_sticky_checks)
-		goto sticky_heaven; /* normal == no security */
-
-	/* extremely not-libc mode:
-	 * only require stickiness on world-writeable dirs:
-	 */
-	if (st.st_mode & S_IWOTH) { /* world writeable */
-
-		if (if_err(!(st.st_mode & S_ISVTX), EPERM))
-			goto sticky_hell; /* not sticky */
-
-		goto sticky_heaven; /* sticky! */
-	} else if (allow_noworld_unsticky) {
-		goto sticky_heaven; /* sticky visa */
-	} else {
-		goto sticky_hell; /* visa denied */
-	}
-
-sticky_heaven:
-	if (faccessat(dirfd, 	".", X_OK, AT_EACCESS) < 0)
-		goto sticky_hell; /* down you go! */
-
-	xclose(&dirfd);
-	reset_caller_errno(0);
-	return 1;
-
-sticky_hell:
-	xclose(&dirfd);
-	(void) with_fallback_errno(EPERM);
-	return 0;
-}
-
-/* mk(h)temp - hardened mktemp.
- * like mkstemp, but (MUCH) harder.
- *
- * designed to resist TOCTOU attacks
- * e.g. directory race / symlink attack
- * 
- * extremely strict and even implements
- * some limited userspace-level sandboxing,
- * similar in spirit to openbsd unveil,
- * though unveil is from kernel space.
- *
- * supports both files and directories.
- * file: type = MKHTEMP_FILE (0)
- * dir: type = MKHTEMP_DIR (1)
- *
- * DESIGN NOTES:
- *
- * caller is expected to handle
- * cleanup e.g. free(), on *st,
- * *template, *fname (all of the
- * pointers). ditto fd cleanup.
- *
- * some limited cleanup is
- * performed here, e.g. directory/file
- * cleanup on error in mkhtemp_try_create
- *
- * we only check if these are not NULL,
- * and the caller is expected to take
- * care; without too many conditions,
- * these functions are more flexible,
- * but some precauttions are taken:
- *
- * when used via the function new_tmpfile
- * or new_tmpdir, thtis is extremely strict,
- * much stricter than previous mktemp
- * variants. for example, it is much
- * stricter about stickiness on world
- * writeable directories, and it enforces
- * file ownership under hardened mode
- * (only lets you touch your own files/dirs)
- */
-/*
- TODO:
-	some variables e.g. template vs suffix,
-	assumes they match.
-	we should test this explicitly,
-	but the way this is called is
-	currently safe - this would however
-	be nice for future library use
-	by outside projects.
-	this whole code needs to be reorganised
-*/
-int
-mkhtemp(int *fd,
-    struct stat *st,
-    char *template,
-    int dirfd,
-    const char *fname,
-    struct stat *st_dir_first,
-    int type)
-{
-	size_t template_len = 0;
-	size_t xc = 0;
-	size_t fname_len = 0;
-
-	char *fname_copy = NULL;
-	char *p;
-
-	size_t retries;
-
-	int saved_errno = errno;
-
-	int r;
-	char *end;
-
-	errno = 0;
-
-	if (if_err(fd == NULL || template == NULL || fname == NULL ||
-	          st_dir_first == NULL, EFAULT) ||
-	    if_err(*fd >= 0, EEXIST) ||
-	    if_err(dirfd < 0, EBADF))
-		goto err;
-
-	/* count X */
-	for (end = template + slen(template, PATH_MAX, &template_len);
-	    end > template && *--end == 'X'; xc++);
-
-	fname_len = slen(fname, PATH_MAX, &fname_len);
-	if (if_err(strrchr(fname, '/') != NULL, EINVAL))
-		goto err;
-
-	if (if_err(xc < 3 || xc > template_len, EINVAL) ||
-	    if_err(fname_len > template_len, EOVERFLOW))
-		goto err;
-
-	if (if_err(vcmp(fname, template + template_len - fname_len,
-	      fname_len) != 0, EINVAL))
-		goto err;
-
-	/* fname_copy = templatestr region only; p points to trailing XXXXXX */
-	memcpy(smalloc(&fname_copy, fname_len + 1),
-	    template + template_len - fname_len,
-	    fname_len + 1);
-	p = fname_copy + fname_len - xc;
-
-	for (retries = 0; retries < MKHTEMP_RETRY_MAX; retries++) {
-
-		r = mkhtemp_try_create(dirfd,
-		    st_dir_first, fname_copy,
-		    p, xc, fd, st, type);
-
-		if (r == 0)
-			continue;
-		if (r < 0)
-			goto err;
-
-		/* success: copy final name back */
-		memcpy(template + template_len - fname_len,
-		    fname_copy, fname_len);
-
-		errno = saved_errno;
-		goto success;
-	}
-
-	errno = EEXIST;
-err:
-	xclose(fd);
-	free_and_set_null(&fname_copy);
-
-	return with_fallback_errno(EIO);
-
-success:
-	free_and_set_null(&fname_copy);
-
-	reset_caller_errno(0);
-	return *fd;
-}
-
-int
-mkhtemp_try_create(int dirfd,
-    struct stat *st_dir_first,
-    char *fname_copy,
-    char *p,
-    size_t xc,
-    int *fd,
-    struct stat *st,
-    int type)
-{
-	struct stat st_open;
-	int saved_errno = errno;
-	int rval = -1;
-	char *rstr = NULL;
-
-	int file_created = 0;
-	int dir_created = 0;
-
-	errno = 0;
-
-	if (if_err(fd == NULL || st == NULL || p ==NULL || fname_copy ==NULL ||
-	      st_dir_first == NULL, EFAULT) ||
-	    if_err(*fd >= 0, EEXIST))
-		goto err;
-
-	/* TODO: potential infinite loop under entropy failure.
-	 * if attacker has control of rand - TODO: maybe add timeout
-	 */
-	memcpy(p, rstr = rchars(xc), xc);
-	free_and_set_null(&rstr);
-
-	if (if_err_sys(fd_verify_dir_identity(dirfd, st_dir_first) < 0))
-		goto err;
-
-	if (type == MKHTEMP_FILE) {
-#if defined(__linux__) && \
-    (!defined(USE_OPENAT) || ((USE_OPENAT) < 1))
-		/* try O_TMPFILE fast path */
-		if (mkhtemp_tmpfile_linux(dirfd,
-		    st_dir_first, fname_copy,
-		    p, xc, fd, st) >= 0) {
-
-			errno = saved_errno;
-			rval = 1;
-			goto out;
-		}
-#endif
-
-		*fd = openat_on_eintr(dirfd, fname_copy,
-		    O_RDWR | O_CREAT | O_EXCL |
-		    O_NOFOLLOW | O_CLOEXEC | O_NOCTTY, 0600);
-
-		/* O_CREAT and O_EXCL guarantees creation upon success
-		 */
-		if (*fd >= 0)
-			file_created = 1;
-
-	} else { /* dir: MKHTEMP_DIR */
-
-		if (mkdirat_on_eintr(dirfd, fname_copy, 0700) < 0)
-			goto err;
-
-		/* ^ NOTE: opening the directory here
-			will never set errno=EEXIST,
-			since we're not creating it */
-
-		dir_created = 1;
-
-		/* do it again (mitigate directory race) */
-		if (fd_verify_dir_identity(dirfd, st_dir_first) < 0)
-			goto err;
-
-		if ((*fd = openat_on_eintr(dirfd, fname_copy,
-		    O_RDONLY | O_DIRECTORY | O_CLOEXEC, 0)) < 0)
-			goto err;
-
-		if (if_err_sys(fstat(*fd, &st_open) < 0) ||
-		    if_err(!S_ISDIR(st_open.st_mode), ENOTDIR))
-			goto err;
-
-		/* NOTE: pointless to check nlink here (only just opened) */
-		if (fd_verify_dir_identity(dirfd, st_dir_first) < 0)
-			goto err;
-
-	}
-
-	/* NOTE: openat_on_eintr and mkdirat_on_eintr
-	 * already handled EINTR/EAGAIN looping
-	 */
-
-	if (*fd < 0) {
-		if (errno == EEXIST) {
-
-			rval = 0;
-			goto out;
-		}
-		goto err;
-	}
-
-	if (fstat(*fd, &st_open) < 0)
-		goto err;
-
-	if (type == MKHTEMP_FILE) {
-
-		if (fd_verify_dir_identity(dirfd, st_dir_first) < 0)
-			goto err;
-
-		if (secure_file(fd, st, &st_open,
-		    O_APPEND, 1, 1, 0600) < 0) /* WARNING: only once */
-			goto err;
-
-	} else { /* dir: MKHTEMP_DIR */
-
-		if (fd_verify_identity(*fd, &st_open, st_dir_first) < 0)
-			goto err;
-
-		if (if_err(!S_ISDIR(st_open.st_mode), ENOTDIR) ||
-		    if_err_sys(is_owner(&st_open) < 0) ||
-		    if_err(st_open.st_mode & (S_IWGRP | S_IWOTH), EPERM))
-			goto err;
-	}
-
-	rval = 1;
-
-out:
-	reset_caller_errno(0);
-	return rval;
-err:
-	xclose(fd);
-
-	if (file_created)
-		(void) unlinkat(dirfd, fname_copy, 0);
-	if (dir_created)
-		(void) unlinkat(dirfd, fname_copy, AT_REMOVEDIR);
-
-	return with_fallback_errno(EPERM);
-}
-
-/* linux has its own special hardening
-   available specifically for tmpfiles,
-   which eliminates many race conditions.
-
-   we still use openat() on bsd, which is
-   still ok with our other mitigations
- */
-#if defined(__linux__) && \
-    (!defined(USE_OPENAT) || ((USE_OPENAT) < 1))
-int
-mkhtemp_tmpfile_linux(int dirfd,
-    struct stat *st_dir_first,
-    char *fname_copy,
-    char *p,
-    size_t xc,
-    int *fd,
-    struct stat *st)
-{
-	int saved_errno = errno;
-	int tmpfd = -1;
-	size_t retries;
-	int linked = 0;
-	char *rstr = NULL;
-	errno = 0;
-
-	if (if_err(fd == NULL || st == NULL ||
-	    fname_copy == NULL || p == NULL ||
-	    st_dir_first == NULL, EFAULT))
-		goto err;
-
-	/* create unnamed tmpfile */
-	tmpfd = openat_on_eintr(dirfd, ".",
-	    O_TMPFILE | O_RDWR | O_CLOEXEC, 0600);
-
-	if (tmpfd < 0)
-		goto err;
-
-	if (fd_verify_dir_identity(dirfd, st_dir_first) < 0)
-		goto err;
-
-	for (retries = 0; retries < MKHTEMP_RETRY_MAX; retries++) {
-
-		memcpy(p, rstr = rchars(xc), xc);
-		free_and_set_null(&rstr);
-
-		if (fd_verify_dir_identity(dirfd,
-		    st_dir_first) < 0)
-			goto err;
-
-		if (linkat(tmpfd, "", dirfd,
-		    fname_copy, AT_EMPTY_PATH) == -1) {
-
-			if (errno == EEXIST)
-				continue; /* retry on collision */
-			else
-				goto err;
-		}
-
-		linked = 1; /* file created */
-
-		/* TODO: potential fd leak here.
-		 * probably should only set *fd on successful
-		 * return from this function (see below)
-		 */
-		if (fd_verify_dir_identity(dirfd, st_dir_first) < 0 ||
-		    fstat(*fd = tmpfd, st) < 0 ||
-		    secure_file(fd, st, st, O_APPEND, 1, 1, 0600) < 0)
-			goto err;
-
-		goto out;
-	}
-
-	if (!errno)
-		errno = EEXIST;
-err:
-	if (linked)
-		(void) unlinkat(dirfd, fname_copy, 0);
-
-	xclose(&tmpfd);
-	return with_fallback_errno(EIO);
-out:
-	reset_caller_errno(0);
-	return 0;
-}
-#endif
-
-/* WARNING: **ONCE** per file.
- *
- * some of these checks will trip up
- * if you do them twice; all of them
- * only need to be done once anyway.
- */
-int secure_file(int *fd,
-    struct stat *st,
-    struct stat *expected,
-    int bad_flags,
-    int check_seek,
-    int do_lock,
-    mode_t mode)
-{
-	int flags = -1;
-	struct stat st_now;
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(fd == NULL || st == NULL, EFAULT) ||
-	    if_err(*fd < 0, EBADF))
-		goto err_demons;
-
-	if ((flags = fcntl(*fd, F_GETFL)) == -1)
-		goto err_demons;
-
-	if (if_err(bad_flags > 0 && (flags & bad_flags), EPERM))
-		goto err_demons;
-
-	if (expected != NULL) {
-		if (fd_verify_regular(*fd, expected, st) < 0)
-			goto err_demons;
-	} else if (if_err_sys(fstat(*fd, &st_now) == -1) ||
-	    if_err(!S_ISREG(st_now.st_mode), EBADF)) {
-		goto err_demons; /***********/
-	} else                   /* ( >:3 ) */
-		*st = st_now;    /*  /| |\  */  /* don't let him out */
-				 /*   / \   */
-	if (check_seek) {        /***********/
-		if (lseek(*fd, 0, SEEK_CUR) == (off_t)-1)
-			goto err_demons;
-	} /* don't release the demon! */
-
-	if (if_err(st->st_nlink != 1, ELOOP) ||
-	    if_err(st->st_uid != geteuid() && geteuid() != 0, EPERM) ||
-	    if_err_sys(is_owner(st) < 0) ||
-	    if_err(st->st_mode & (S_IWGRP | S_IWOTH), EPERM))
-		goto err_demons;
-
-	if (do_lock) {
-		if (lock_file(*fd, flags) == -1)
-			goto err_demons;
-
-		/* TODO: why would this be NULL? audit
-		 * to find out. we should always verify! */
-		if (expected != NULL)
-			if (fd_verify_identity(*fd, expected, &st_now) < 0)
-				goto err_demons;
-	}
-
-	if (fchmod(*fd, mode) == -1)
-		goto err_demons;
-
-	reset_caller_errno(0);
-	return 0;
-
-err_demons:
-	return with_fallback_errno(EIO);
-}
-
-int
-fd_verify_regular(int fd,
-    const struct stat *expected,
-    struct stat *out)
-{
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err_sys(fd_verify_identity(fd, expected, out) < 0) ||
-	    if_err(!S_ISREG(out->st_mode), EBADF)) {
-		return with_fallback_errno(EIO);
-	} else {
-		reset_caller_errno(0);
-		return 0; /* regular file */
-	}
-}
-
-int
-fd_verify_identity(int fd,
-    const struct stat *expected,
-    struct stat *out)
-{
-	struct stat st_now;
-	int saved_errno = errno;
-	errno = 0;
-
-if(	if_err(fd < 0 || expected == NULL, EFAULT) ||
-	  if_err_sys(fstat(fd, &st_now)) ||
-	    if_err(st_now.st_dev != expected->st_dev ||
-	      st_now.st_ino != expected->st_ino, ESTALE))
-		return with_fallback_errno(EIO);
-
-	if (out != NULL)
-		*out = st_now;
-
-	reset_caller_errno(0);
-	return 0;
-}
-
-int
-fd_verify_dir_identity(int fd,
-    const struct stat *expected)
-{
-	struct stat st_now;
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(fd < 0 || expected == NULL, EFAULT) ||
-	    if_err_sys(fstat(fd, &st_now) < 0) ||
-	    if_err(st_now.st_dev != expected->st_dev, ESTALE) ||
-	    if_err(st_now.st_ino != expected->st_ino, ESTALE) ||
-	    if_err(!S_ISDIR(st_now.st_mode), ENOTDIR))
-		goto err;
-
-	reset_caller_errno(0);
-	return 0;
-err:
-	return with_fallback_errno(EIO);
-}
-
-int
-is_owner(struct stat *st)
-{
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(st == NULL, EFAULT) ||
-	    if_err(st->st_uid != geteuid() /* someone else's file */
-#if defined(ALLOW_ROOT_OVERRIDE) && ((ALLOW_ROOT_OVERRIDE) > 0)
-	      && geteuid() != 0 /* override for root */
-#endif
-	    , EPERM)) return with_fallback_errno(EIO);
-
-	reset_caller_errno(0);
-	return 0;
-}
-
-int
-lock_file(int fd, int flags)
-{
-	struct flock fl;
-	int saved_errno = errno;
-	int fcntl_rval = -1;
-	errno = 0;
-
-	if (if_err(fd < 0, EBADF) ||
-	    if_err(flags < 0, EINVAL))
-		goto err_lock_file;
-
-	memset(&fl, 0, sizeof(fl));
-
-	if ((flags & O_ACCMODE) == O_RDONLY)
-		fl.l_type = F_RDLCK;
-	else
-		fl.l_type = F_WRLCK;
-
-	fl.l_whence = SEEK_SET;
-
-	if ((fcntl_rval = fcntl(fd, F_SETLK, &fl)) == -1)
-		goto err_lock_file;
-
-	reset_caller_errno(0);
-	return 0;
-
-err_lock_file:
-	return with_fallback_errno(EIO);
-}
@@ -1,116 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>
- *
- * Non-randomisation-related numerical functions.
- * For rand functions, see: rand.c
- */
-
-#ifdef __OpenBSD__
-#include <sys/param.h>
-#endif
-#include <sys/types.h>
-
-#include <errno.h>
-#if !((defined(__OpenBSD__) && (OpenBSD) >= 201) || \
-    defined(__FreeBSD__) || \
-    defined(__NetBSD__) || defined(__APPLE__))
-#include <fcntl.h> /* if not arc4random: /dev/urandom */
-#endif
-#include <ctype.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "../include/common.h"
-
-unsigned short
-hextonum(char ch_s)
-{
-	unsigned char ch;
-
-	ch = (unsigned char)ch_s;
-
-	if ((unsigned int)(ch - '0') <= 9)
-		return ch - '0';
-
-	ch |= 0x20;
-
-	if ((unsigned int)(ch - 'a') <= 5)
-		return ch - 'a' + 10;
-
-	if (ch == '?' || ch == 'x') /* random */
-		return (short)rsize(16); /* <-- with rejection sampling! */
-
-	return 16;
-}
-
-/* basically hexdump -C */
-/*
-	TODO: optimise this
-	write a full util for hexdump
-	how to optimise:
-	don't call print tens of thousands of times!
-	convert the numbers manually, and cache everything
-	in a BUFSIZ sized buffer, with everything properly
-	aligned. i worked out that i could fit 79 rows
-	in a 8KB buffer (1264 bytes of numbers represented
-	as strings in hex)
-	this depends on the OS, and would be calculated at
-	runtime.
-	then:
-	don't use printf. just write it to stdout (basically
-	a simple cat implementation)
-*/
-void
-spew_hex(const void *data, size_t len)
-{
-	const unsigned char *buf = (const unsigned char *)data;
-	unsigned char c;
-	size_t i;
-	size_t j;
-
-	if (buf == NULL ||
-	    len == 0)
-		return;
-
-	for (i = 0; i < len; i += 16) {
-
-		if (len <= 4294967296) /* below 4GB */
-			printf("%08zx  ", i);
-		else
-			printf("%16zu  ", i);
-
-		for (j = 0; j < 16; j++) {
-
-			if (i + j < len)
-				printf("%02x ", buf[i + j]);
-			else
-				printf("   ");
-
-			if (j == 7)
-				printf(" ");
-		}
-
-		printf(" |");
-
-		for (j = 0; j < 16 && i + j < len; j++) {
-
-			c = buf[i + j];
-			printf("%c", isprint(c) ? c : '.');
-		}
-
-		printf("|\n");
-	}
-
-	printf("%08zx\n", len);
-}
-
-void
-check_bin(size_t a, const char *a_name)
-{
-	if (a > 1)
-		exitf("%s must be 0 or 1, but is %lu",
-		    a_name, (size_t)a);
-}
@@ -1,200 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>
- *
- * Random number generation
- */
-
-#if defined(USE_ARC4) && \
-    ((USE_ARC4) > 0)
-#define _DEFAULT_SOURCE 1 /* for arc4random on *linux* */
-			/* (not needed on bsd - on bsd,
-			   it is used automatically unless
-			   overridden with USE_URANDOM */
-#elif defined(USE_URANDOM) && \
-    ((USE_URANDOM) > 0)
-#include <fcntl.h> /* if not arc4random: /dev/urandom */
-#elif defined(__linux__) && \
-    !(defined(USE_ARC4) && ((USE_ARC4) > 0))
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE 1
-#endif
-#include <sys/syscall.h>
-#include <sys/random.h>
-#endif
-
-#ifdef __OpenBSD__
-#include <sys/param.h>
-#endif
-#include <sys/types.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stddef.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "../include/common.h"
-
-/* Regarding Linux getrandom/urandom:
- *
- * For maximum security guarantee, we *only*
- * use getrandom via syscall, or /dev/urandom;
- * use of urandom is ill advised. This is why
- * we use the syscall, in case the libc version
- * of getrandom() might defer to /dev/urandom
- *
- * We *abort* on error, for both /dev/urandom
- * and getrandom(), because the BSD arc4random
- * never returns with error; therefore, for the
- * most parity in terms of behaviour, we abort,
- * because otherwise the function would have two
- * return modes: always successful (BSD), or only
- * sometimes (Linux). The BSD arc4random could
- * theoretically abort; it is extremely unlikely
- * there, and just so on Linux, hence this design.
- *
- * This is important, because cryptographic code
- * for example must not rely on weak randomness.
- * We must therefore treat broken randomness as
- * though the world is broken, and burn accordingly.
- *
- * Similarly, any invalid input (NULL, zero bytes
- * requested) are treated as fatal errors; again,
- * cryptographic code must be reliable. If your
- * code erroneously requested zero bytes, you might
- * then end up with a non-randomised buffer, where
- * you likely intended otherwise.
- *
- * In other words: call rset() correctly, or your
- * program dies, and rset will behave correctly,
- * or your program dies.
- */
-
-/* random string generator, with
- * rejection sampling. NOTE: only
- * uses ASCII-safe characters, for
- * printing on a unix terminal
- *
- * you still shouldn't use this for
- * password generation; open diceware
- * passphrases are better for that
- *
- * NOTE: the generated strings must
- * ALSO be safe for file/directory names
- * on unix-like os e.g. linux/bsd
- */
-char *
-rchars(size_t n) /* emulates spkmodem-decode */
-{
-	static char ch[] =
-	    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-
-	char *s = NULL;
-	size_t i;
-
-	smalloc(&s, n + 1);
-	for (i = 0; i < n; i++)
-		s[i] = ch[rsize(sizeof(ch) - 1)];
-
-	*(s + n) = '\0';
-	return s;
-}
-
-size_t
-rsize(size_t n)
-{
-	size_t rval = SIZE_MAX;
-	if (!n)
-		exitf("rsize: division by zero");
-
-	/* rejection sampling (clamp rand to eliminate modulo bias) */
-	for (; rval >= SIZE_MAX - (SIZE_MAX % n); rset(&rval, sizeof(rval)));
-
-	return rval % n;
-}
-
-void *
-rmalloc(size_t n)
-{
-	void *buf = NULL;
-	rset(vmalloc(&buf, n), n);
-	return buf; /* basically malloc() but with rand */
-}
-
-void
-rset(void *buf, size_t n)
-{
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(buf == NULL, EFAULT))
-		goto err;
-
-	if (n == 0)
-		exitf("rset: zero-byte request");
-
-/* on linux, getrandom is recommended,
-   but you can pass -DUSE_ARC4=1 to use arc4random.
-   useful for portability testing from linux.
- */
-#if (defined(USE_ARC4) && ((USE_ARC4) > 0)) || \
-    ((defined(__OpenBSD__) || defined(__FreeBSD__) || \
-    defined(__NetBSD__) || defined(__APPLE__) || \
-    defined(__DragonFly__)) && !(defined(USE_URANDOM) && \
-    ((USE_URANDOM) > 0)))
-
-	arc4random_buf(buf, n);
-#else
-	size_t off = 0;
-
-retry_rand: {
-
-#if defined(USE_URANDOM) && \
-    ((USE_URANDOM) > 0)
-	ssize_t rval;
-	int fd = -1;
-
-	open_file_on_eintr("/dev/urandom", &fd, O_RDONLY, 0400, NULL);
-
-	while (rw_retry(saved_errno,
-	    rval = rw(fd, (unsigned char *)buf + off, n - off, 0, IO_READ)));
-#elif defined(__linux__)
-	long rval;
-	while (sys_retry(saved_errno,
-		rval = syscall(SYS_getrandom,
-		    (unsigned char *)buf + off, n - off, 0)));
-#else
-#error Unsupported operating system (possibly unsecure randomisation)
-#endif
-
-	if (rval < 0 || /* syscall fehler */
-	    rval == 0) { /* prevent infinite loop on fatal err */
-#if defined(USE_URANDOM) && \
-    ((USE_URANDOM) > 0)
-		xclose(&fd);
-#endif
-		goto err;
-	}
-
-	if ((off += (size_t)rval) < n)
-		goto retry_rand;
-
-#if defined(USE_URANDOM) && \
-    ((USE_URANDOM) > 0)
-	xclose(&fd);
-#endif
-}
-
-#endif
-	reset_caller_errno(0);
-	return;
-err:
-	(void) with_fallback_errno(ECANCELED);
-	exitf("Randomisierungsfehler");
-	exit(EXIT_FAILURE);
-}
@@ -1,164 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2022-2026 Leah Rowe <leah@libreboot.org>
- *
- * State machine (singleton) for nvmutil data.
- */
-
-#ifndef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 700
-#endif
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "../include/common.h"
-
-struct xstate *
-xstart(int argc, char *argv[])
-{
-	static int first_run = 1;
-	static char *dir = NULL;
-	static char *base = NULL;
-	char *realdir = NULL;
-	char *tmpdir = NULL;
-	char *tmpbase_local = NULL;
-
-	static struct xstate us = {
-	{
-		/* be careful when modifying xstate. you
-		 * must set everything precisely */
-	{
-		CMD_DUMP, "dump", cmd_helper_dump, ARGC_3,
-		ARG_NOPART,
-		SKIP_CHECKSUM_READ, SKIP_CHECKSUM_WRITE,
-		NVM_SIZE, O_RDONLY
-	}, {
-		CMD_SETMAC, "setmac", cmd_helper_setmac, ARGC_3,
-		ARG_NOPART,
-		CHECKSUM_READ, CHECKSUM_WRITE,
-		NVM_SIZE, O_RDWR
-	}, {
-		CMD_SWAP, "swap", cmd_helper_swap, ARGC_3,
-		ARG_NOPART,
-		CHECKSUM_READ, SKIP_CHECKSUM_WRITE,
-		GBE_PART_SIZE, O_RDWR
-	}, {
-		CMD_COPY, "copy", cmd_helper_copy, ARGC_4,
-		ARG_PART,
-		CHECKSUM_READ, SKIP_CHECKSUM_WRITE,
-		GBE_PART_SIZE, O_RDWR
-	}, {
-		CMD_CAT, "cat", cmd_helper_cat, ARGC_3,
-		ARG_NOPART,
-		CHECKSUM_READ, SKIP_CHECKSUM_WRITE,
-		GBE_PART_SIZE, O_RDONLY
-	}, {
-		CMD_CAT16, "cat16", cmd_helper_cat16, ARGC_3,
-		ARG_NOPART,
-		CHECKSUM_READ, SKIP_CHECKSUM_WRITE,
-		GBE_PART_SIZE, O_RDONLY
-	}, {
-		CMD_CAT128, "cat128", cmd_helper_cat128, ARGC_3,
-		ARG_NOPART,
-		CHECKSUM_READ, SKIP_CHECKSUM_WRITE,
-		GBE_PART_SIZE, O_RDONLY
-	}
-	},
-
-	/* ->mac */
-	{NULL, "xx:xx:xx:xx:xx:xx", {0, 0, 0}}, /* .str, .rmac, .mac_buf */
-
-	/* .f */
-	{0},
-
-	/* ->i   (index to cmd[]) */
-	0,
-
-	/* .no_cmd (set 0 when a command is found) */
-	1,
-
-	/* .cat (cat helpers set this) */
-	-1
-
-	};
-
-	if (!first_run)
-		return &us;
-
-	if (argc < 3)
-		exitf("xstart: Too few arguments");
-	if (argv == NULL)
-		exitf("xstart: NULL argv");
-	
-	first_run = 0;
-
-	us.f.buf = us.f.real_buf;
-
-	us.f.fname = argv[1];
-
-	us.f.tmp_fd = -1;
-	us.f.tname = NULL;
-
-	if ((realdir = realpath(us.f.fname, NULL)) == NULL)
-		exitf("xstart: can't get realpath of %s",
-		    us.f.fname);
-
-	if (fs_dirname_basename(realdir, &dir, &base, 0) < 0)
-		exitf("xstart: don't know CWD of %s",
-		    us.f.fname);
-
-	sdup(base, PATH_MAX, &us.f.base);
-
-	us.f.dirfd = fs_open(dir,
-	    O_RDONLY | O_DIRECTORY);
-	if (us.f.dirfd < 0)
-		exitf("%s: open dir", dir);
-
-	if (new_tmpfile(&us.f.tmp_fd, &us.f.tname, dir, ".gbe.XXXXXXXXXX") < 0)
-		exitf("%s", us.f.tname);
-
-	if (fs_dirname_basename(us.f.tname,
-	    &tmpdir, &tmpbase_local, 0) < 0)
-		exitf("tmp basename");
-
-	sdup(tmpbase_local, PATH_MAX, &us.f.tmpbase);
-
-	free_and_set_null(&tmpdir);
-
-	if (us.f.tname == NULL)
-		exitf("x->f.tname null");
-	if (*us.f.tname == '\0')
-		exitf("x->f.tname empty");
-
-	if (fstat(us.f.tmp_fd, &us.f.tmp_st) < 0)
-		exitf("%s: stat", us.f.tname);
-
-	memset(us.f.real_buf, 0, sizeof(us.f.real_buf));
-	memset(us.f.bufcmp, 0, sizeof(us.f.bufcmp));
-
-	/* for good measure */
-	memset(us.f.pad, 0, sizeof(us.f.pad));
-
-	return &us;
-}
-
-struct xstate *
-xstatus(void)
-{
-	struct xstate *x = xstart(0, NULL);
-
-	if (x == NULL)
-		exitf("NULL pointer to xstate");
-
-	return x;
-}
@@ -1,643 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>
- *
- * String functions
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <limits.h>
-#include <stdint.h>
-
-#include "../include/common.h"
-
-/* for null detection inside
- * word-optimised string functions
- */
-#define ff ((size_t)-1 / 0xFF)
-#define high ((ff) * 0x80)
-/* NOTE:
- * do not assume that a match means
- * both words have null at the same
- * location. see how this is handled
- * e.g. in scmp.
- */
-#define zeroes(x) (((x) - (ff)) & ~(x) & (high))
-
-size_t
-page_remain(const void *p)
-{
-	/* calling sysconf repeatedly
-	 * is folly. cache it (static)
-	 */
-	static size_t pagesz = 0;
-	if (!pagesz)
-		pagesz = (size_t)pagesize();
-
-	return pagesz - ((uintptr_t)p & (pagesz - 1));
-}
-
-long
-pagesize(void)
-{
-	static long rval = 0;
-	static int set = 0;
-	int saved_errno = 0;
-
-	if (!set) {
-		if ((rval = sysconf(_SC_PAGESIZE)) < 0)
-			exitf("could not determine page size");
-		set = 1;
-	}
-
-	reset_caller_errno(0);
-	return rval;
-}
-
-void
-free_and_set_null(char **buf)
-{
-	if (buf == NULL)
-		exitf(
-		    "null ptr (to ptr for freeing) in free_and_set_null");
-
-	if (*buf == NULL)
-		return;
-
-	free(*buf);
-	*buf = NULL;
-}
-
-/* safe(ish) malloc.
-
-   use this and free_and_set_null()
-   in your program, to reduce the
-   chance of use after frees!
-
-   if you use these functions in the
-   intended way, you will greatly reduce
-   the number of bugs in your code
- */
-char *
-smalloc(char **buf, size_t size)
-{
-	return (char *)vmalloc((void **)buf, size);
-}
-void *
-vmalloc(void **buf, size_t size)
-{
-	int saved_errno = errno;
-	void *rval = NULL;
-	errno = 0;
-
-	if (size >= SIZE_MAX - 1)
-		exitf("integer overflow in vmalloc");
-	if (buf == NULL)
-		exitf("Bad pointer passed to vmalloc");
-
-	/* lots of programs will
-	 * re-initialise a buffer
-	 * that was allocated, without
-	 * freeing or NULLing it. this
-	 * is here intentionally, to
-	 * force the programmer to behave
-	 */
-	if (*buf != NULL)
-		exitf("Non-null pointer given to vmalloc");
-
-	if (!size)
-		exitf(
-		   "Tried to vmalloc(0) and that is very bad. Fix it now");
-
-	if ((rval = malloc(size)) == NULL)
-		exitf("malloc fail in vmalloc");
-
-	reset_caller_errno(0);
-	return *buf = rval;
-}
-
-/* strict word-based strcmp */
-int
-scmp(const char *a,
-    const char *b,
-    size_t maxlen,
-    int *rval)
-{
-	size_t i = 0;
-	size_t j;
-	size_t wa;
-	size_t wb;
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(a == NULL || b == NULL || rval == NULL, EFAULT))
-		goto err;
-
-	for ( ; ((uintptr_t)(a + i) % sizeof(size_t)) != 0; i++) {
-
-		if (if_err(i >= maxlen, EOVERFLOW))
-			goto err;
-		else if (!ccmp(a, b, i, rval))
-			goto out;
-	}
-
-	for ( ; i + sizeof(size_t) <= maxlen;
-	    i += sizeof(size_t)) {
-
-		/* prevent crossing page boundary on word check */
-		if (page_remain(a + i) < sizeof(size_t) ||
-		    page_remain(b + i) < sizeof(size_t))
-			break;
-
-		memcpy(&wa, a + i, sizeof(size_t));
-		memcpy(&wb, b + i, sizeof(size_t));
-
-		if (wa != wb)
-			for (j = 0; j < sizeof(size_t); j++)
-				if (!ccmp(a, b, i + j, rval))
-					goto out;
-
-		if (!zeroes(wa))
-			continue;
-
-		*rval = 0;
-		goto out;
-	}
-
-	for ( ; i < maxlen; i++)
-		if (!ccmp(a, b, i, rval))
-			goto out;
-
-err:
-	(void) with_fallback_errno(EFAULT);
-	if (rval != NULL)
-		*rval = -1;
-
-	exitf("scmp");
-	return -1;
-out:
-	reset_caller_errno(0);
-	return *rval;
-}
-
-int ccmp(const char *a, const char *b,
-    size_t i, int *rval)
-{
-	unsigned char ac;
-	unsigned char bc;
-
-	if (if_err(a == NULL || b == NULL || rval == NULL, EFAULT))
-		exitf("ccmp");
-
-	ac = (unsigned char)a[i];
-	bc = (unsigned char)b[i];
-
-	if (ac != bc) {
-		*rval = ac - bc;
-		return 0;
-	} else if (ac == '\0') {
-		*rval = 0;
-		return 0;
-	}
-
-	return 1;
-}
-
-/* strict word-based strlen */
-size_t
-slen(const char *s,
-    size_t maxlen,
-    size_t *rval)
-{
-	int saved_errno = errno;
-	size_t i = 0;
-	size_t w;
-	size_t j;
-	errno = 0;
-
-	if (if_err(s == NULL || rval == NULL, EFAULT))
-		goto err;
-
-	for ( ; ((uintptr_t)(s + i) % sizeof(size_t)) != 0; i++) {
-
-		if (if_err(i >= maxlen, EOVERFLOW))
-			goto err;
-		if (s[i] == '\0') {
-			*rval = i;
-			goto out;
-		}
-	}
-
-	for ( ; i + sizeof(size_t) <= maxlen;
-	    i += sizeof(size_t)) {
-
-		memcpy(&w, s + i, sizeof(size_t));
-		if (!zeroes(w))
-			continue;
-
-		for (j = 0; j < sizeof(size_t); j++) {
-			if (s[i + j] == '\0') {
-				*rval = i + j;
-				goto out;
-			}
-		}
-	}
-
-	for ( ; i < maxlen; i++) {
-		if (s[i] == '\0') {
-			*rval = i;
-			goto out;
-		}
-	}
-
-err:
-	(void) with_fallback_errno(EFAULT);
-	if (rval != NULL)
-		*rval = 0;
-
-	exitf("slen"); /* abort */
-	return 0; /* gcc15 is happy */
-out:
-	reset_caller_errno(0);
-	return *rval;
-}
-
-int
-dup_pair(char **dir, const char *d,
-    char **base, const char *b)
-{
-	char *dtmp = NULL;
-	char *btmp = NULL;
-
-	if (d && sdup(d, PATH_MAX, &dtmp) == NULL)
-		return -1;
-
-	if (b && sdup(b, PATH_MAX, &btmp) == NULL) {
-		free(dtmp);
-		return -1;
-	}
-
-	*dir = dtmp;
-	*base = btmp;
-
-	return 0;
-}
-
-/* strict word-based strdup */
-char *
-sdup(const char *s,
-    size_t max, char **dest)
-{
-	size_t j;
-	size_t w;
-	size_t i = 0;
-	char *out = NULL;
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(dest == NULL || *dest != NULL || s == NULL, EFAULT))
-		goto err;
-
-	out = smalloc(dest, max);
-
-	for ( ; ((uintptr_t)(s + i) % sizeof(size_t)) != 0; i++) {
-
-		if (if_err(i >= max, EOVERFLOW))
-			goto err;
-
-		out[i] = s[i];
-		if (s[i] == '\0') {
-			*dest = out;
-			goto out;
-		}
-	}
-
-	for ( ; i + sizeof(size_t) <= max; i += sizeof(size_t)) {
-
-		if (page_remain(s + i) < sizeof(size_t))
-			break;
-
-		memcpy(&w, s + i, sizeof(size_t));
-		if (!zeroes(w)) {
-			memcpy(out + i, &w, sizeof(size_t));
-			continue;
-		}
-
-		for (j = 0; j < sizeof(size_t); j++) {
-
-			out[i + j] = s[i + j];
-			if (s[i + j] == '\0') {
-				*dest = out;
-				goto out;
-			}
-		}
-	}
-
-	for ( ; i < max; i++) {
-
-		out[i] = s[i];
-		if (s[i] == '\0') {
-			*dest = out;
-			goto out;
-		}
-	}
-
-err:
-	free_and_set_null(&out);
-	if (dest != NULL)
-		*dest = NULL;
-
-	(void) with_fallback_errno(EFAULT);
-	exitf("sdup");
-
-	return NULL;
-out:
-	reset_caller_errno(0);
-	return *dest;
-}
-
-/* concatenate N number of strings */
-char *
-scatn(ssize_t sc, const char **sv,
-    size_t max, char **rval)
-{
-	int saved_errno = errno;
-	char *final = NULL;
-	char *rcur = NULL;
-	char *rtmp = NULL;
-	ssize_t i;
-	errno = 0;
-
-	if (if_err(sc < 2, EINVAL) ||
-	    if_err(sv == NULL, EFAULT) ||
-	    if_err(rval == NULL || *rval != NULL, EFAULT))
-		goto err;
-
-	for (i = 0; i < sc; i++) {
-
-		if (if_err(sv[i] == NULL, EFAULT))
-			goto err;
-		else if (i == 0) {
-			(void) sdup(sv[0], max, &final);
-			continue;
-		}
-
-		rtmp = NULL;
-		scat(final, sv[i], max, &rtmp);
-
-		free_and_set_null(&final);
-		final = rtmp;
-		rtmp = NULL;
-	}
-
-	reset_caller_errno(0);
-	*rval = final;
-	return *rval;
-err:
-	free_and_set_null(&rcur);
-	free_and_set_null(&rtmp);
-	free_and_set_null(&final);
-
-	(void) with_fallback_errno(EFAULT);
-
-	exitf("scatn");
-	return NULL;
-}
-
-/* strict strcat */
-char *
-scat(const char *s1, const char *s2,
-    size_t n, char **dest)
-{
-	size_t size1;
-	size_t size2;
-	char *rval = NULL;
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(dest == NULL || *dest != NULL, EFAULT))
-		goto err;
-
-	slen(s1, n, &size1);
-	slen(s2, n, &size2);
-
-	if (if_err(size1
-	    > SIZE_MAX - size2 - 1, EOVERFLOW))
-		goto err;
-
-	smalloc(&rval, size1 + size2 + 1);
-
-	memcpy(rval, s1, size1);
-	memcpy(rval + size1, s2, size2);
-	*(rval + size1 + size2) = '\0';
-
-	reset_caller_errno(0);
-	*dest = rval;
-	return *dest;
-err:
-	(void) with_fallback_errno(EINVAL);
-	if (dest != NULL)
-		*dest = NULL;
-	exitf("scat");
-
-	return NULL;
-}
-
-/* strict split/de-cat - off is where
-   2nd buffer will start from */
-void
-dcat(const char *s, size_t n,
-    size_t off, char **dest1,
-    char **dest2)
-{
-	size_t size;
-	char *rval1 = NULL;
-	char *rval2 = NULL;
-	int saved_errno = errno;
-	errno = 0;
-
-	if (if_err(dest1 == NULL || dest2 == NULL, EFAULT))
-		goto err;
-
-	if (if_err(slen(s, n, &size) >= SIZE_MAX - 1, EOVERFLOW) ||
-	    if_err(off >= size, EOVERFLOW))
-		goto err;
-
-	memcpy(smalloc(&rval1, off + 1),
-	    s, off);
-	*(rval1 + off) = '\0';
-
-	memcpy(smalloc(&rval2, size - off +1),
-	    s + off, size - off);
-	*(rval2 + size - off) = '\0';
-
-	*dest1 = rval1;
-	*dest2 = rval2;
-
-	reset_caller_errno(0);
-	return;
-
-err:
-	*dest1 = *dest2 = NULL;
-
-	free_and_set_null(&rval1);
-	free_and_set_null(&rval2);
-
-	(void) with_fallback_errno(EINVAL);
-	exitf("dcat");
-}
-
-/* because no libc reimagination is complete
- * without a reimplementation of memcmp. and
- * no safe one is complete without null checks.
- */
-int
-vcmp(const void *s1, const void *s2, size_t n)
-{
-	int saved_errno = errno;
-	size_t i = 0;
-	size_t a;
-	size_t b;
-
-	const unsigned char *x;
-	const unsigned char *y;
-	errno = 0;
-
-	if (if_err(s1 == NULL || s2 == NULL, EFAULT))
-		exitf("vcmp: null input");
-
-	x = s1;
-	y = s2;
-
-	for ( ; i + sizeof(size_t) <= n; i += sizeof(size_t)) {
-
-		memcpy(&a, x + i, sizeof(size_t));
-		memcpy(&b, y + i, sizeof(size_t));
-
-		if (a != b)
-			break;
-	}
-
-	for ( ; i < n; i++)
-		if (x[i] != y[i])
-			return (int)x[i] - (int)y[i];
-
-	reset_caller_errno(0);
-	return 0;
-}
-
-/* on functions that return with errno,
- * i sometimes have a default fallback,
- * which is set if errno wasn't changed,
- * under error condition.
- */
-int
-with_fallback_errno(int fallback)
-{
-	if (!errno)
-		errno = fallback;
-	return -1;
-}
-
-/* the one for nvmutil state is in state.c */
-/* this one just exits */
-void
-exitf(const char *msg, ...)
-{
-	va_list args;
-	int saved_errno = errno;
-
-	func_t err_cleanup = errhook(NULL);
-	err_cleanup();
-	reset_caller_errno(0);
-	saved_errno = errno;
-
-	if (!errno)
-		saved_errno = errno = ECANCELED;
-
-	fprintf(stderr, "%s: ", lbgetprogname());
-
-	va_start(args, msg);
-	vfprintf(stderr, msg, args);
-	va_end(args);
-
-	errno = saved_errno;
-	fprintf(stderr, ": %s\n", strerror(errno));
-
-	exit(EXIT_FAILURE);
-}
-
-/* the err function will
- * call this upon exit, and
- * cleanup will be performed
- * e.g. you might want to
- * close some files, depending
- * on your program.
- * see: exitf()
- */
-func_t errhook(func_t ptr)
-{
-	static int set = 0;
-	static func_t hook = NULL;
-
-	if (!set) {
-		set = 1;
-
-		if (ptr == NULL)
-			hook = no_op;
-		else
-			hook = ptr;
-	}
-
-	return hook;
-}
-
-void
-no_op(void)
-{
-	return;
-}
-
-const char *
-lbgetprogname(void)
-{
-	char *name = lbsetprogname(NULL);
-	char *p = NULL;
-	if (name)
-		p = strrchr(name, '/');
-	if (p)
-		return p + 1;
-	else if (name)
-		return name;
-	else
-		return "libreboot-utils";
-}
-
-/* singleton. if string not null,
-   sets the string. after set,
-   will not set anymore. either
-   way, returns the string
- */
-char *
-lbsetprogname(char *argv0)
-{
-	static char *progname = NULL;
-	static int set = 0;
-
-	if (!set) {
-		if (argv0 == NULL)
-			return "libreboot-utils";
-		(void) sdup(argv0, PATH_MAX, &progname);
-		set = 1;
-	}
-
-	return progname;
-}
@@ -1,30 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2023 Riku Viitanen <riku.viitanen@protonmail.com>
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>
- */
-
-#include <errno.h>
-#include <stdio.h>
-
-#include "../include/common.h"
-
-void
-usage(void)
-{
-	const char *util = lbgetprogname();
-
-	fprintf(stderr,
-	    "Modify Intel GbE NVM images e.g. set MAC\n"
-	    "USAGE:\n"
-	    "\t%s FILE dump\n"
-	    "\t%s FILE setmac [MAC]\n"
-	    "\t%s FILE swap\n"
-	    "\t%s FILE copy 0|1\n"
-	    "\t%s FILE cat\n"
-	    "\t%s FILE cat16\n"
-	    "\t%s FILE cat128\n",
-	    util, util, util, util,
-	    util, util, util);
-
-	exitf("Too few arguments");
-}
@@ -1,68 +0,0 @@
-/* SPDX-License-Identifier: MIT
- * Copyright (c) 2022-2026 Leah Rowe <leah@libreboot.org>
- *
- * Manipulate Intel GbE NVM words, which are 16-bit little
- * endian in the files (MAC address words are big endian).
- */
-
-#include <sys/types.h>
-
-#include <errno.h>
-#include <stddef.h>
-
-#include "../include/common.h"
-
-unsigned short
-nvm_word(size_t pos16, size_t p)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	size_t pos;
-
-	check_nvm_bound(pos16, p);
-	pos = (pos16 << 1) + (p * GBE_PART_SIZE);
-
-	return (unsigned short)f->buf[pos] |
-	    ((unsigned short)f->buf[pos + 1] << 8);
-}
-
-void
-set_nvm_word(size_t pos16, size_t p, unsigned short val16)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	size_t pos;
-
-	check_nvm_bound(pos16, p);
-	pos = (pos16 << 1) + (p * GBE_PART_SIZE);
-
-	f->buf[pos] = (unsigned char)(val16 & 0xff);
-	f->buf[pos + 1] = (unsigned char)(val16 >> 8);
-
-	set_part_modified(p);
-}
-
-void
-set_part_modified(size_t p)
-{
-	struct xstate *x = xstatus();
-	struct xfile *f = &x->f;
-
-	check_bin(p, "part number");
-	f->part_modified[p] = 1;
-}
-
-void
-check_nvm_bound(size_t c, size_t p)
-{
-	/* Block out of bound NVM access
-	 */
-
-	check_bin(p, "part number");
-
-	if (c >= NVM_WORDS)
-		exitf("check_nvm_bound: out of bounds %lu",
-		    (size_t)c);
-}
@@ -1,74 +0,0 @@
-/* SPDX-License-Identifier: MIT                                        ( >:3 )
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>                    /| |\
-   Something something non-determinism                                   / \ */
-
-#include <ctype.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <stdlib.h>
-#include "include/common.h"
-
-static void
-exit_cleanup(void);
-
-int
-main(int argc, char **argv)
-{
-#ifndef __linux__
-#error This code is currently buggy on BSD systems. Only use on Linux.
-#endif
-	int same = 0;
-	char *buf;
-	size_t size = BUFSIZ;
-	(void) argc, (void) argv;
-
-	(void) errhook(exit_cleanup);
-	(void) lbsetprogname(argv[0]);
-
-#ifdef __OpenBSD__
-	/* https://man.openbsd.org/pledge.2 */
-	if (pledge("stdio", NULL) == -1)
-		exitf("pledge");
-#endif
-
-	buf = rmalloc(size);
-	if (!vcmp(buf, buf + (size >> 1), size >> 1))
-		same = 1;
-
-	if (argc < 2) /* no spew */
-		spew_hex(buf, size);
-	free_and_set_null(&buf);
-
-	fprintf(stderr, "\n%s\n", same ? "You win!" : "You lose!");
-
-	return same ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
-static void
-exit_cleanup(void)
-{
-#if defined(__OpenBSD__)
-	fprintf(stderr, "OpenBSD wins\n");
-#elif defined(__FreeBSD__)
-	fprintf(stderr, "FreeBSD wins\n");
-#elif defined(__NetBSD__)
-	fprintf(stderr, "NetBSD wins\n");
-#elif defined(__APPLE__)
-	fprintf(stderr, "MacOS wins\n");
-#elif defined(__DragonFly__)
-	fprintf(stderr, "DragonFly BSD wins\n");
-#elif defined(__linux__)
-#if defined(__GLIBC__)
-	fprintf(stderr, "GNU/Linux wins\n");
-#elif defined(__MUSL__)
-	fprintf(stderr, "Rich Felker wins\n");
-#else
-	fprintf(stderr, "Linux wins\n");
-#endif
-#else
-	fprintf(stderr, "Your operating system wins\n");
-#endif
-	return;
-}
@@ -1,152 +0,0 @@
-/* SPDX-License-Identifier: MIT                                        ( >:3 )
- * Copyright (c) 2026 Leah Rowe <leah@libreboot.org>                    /| |\
- *                                                                       / \
- * Hardened mktemp (mkhtemp!)
- *
- * WORK IN PROGRESS (proof of concept), or, v0.0000001
- * DO NOT PUT THIS IN YOUR LINUX DISTRO YET.
- *
- * In other words: for reference only -- PATCHES WELCOME!
- *
- * I will remove this notice when the code is mature, and
- * probably contact several of your projects myself.
- *
- * See README. This is an ongoing project; no proper docs
- * yet, and no manpage (yet!) - the code is documentation,
- * while the specification that it implements evolves.
- */
-
-#ifndef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 700
-#endif
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "include/common.h"
-
-static void
-exit_cleanup(void);
-
-int
-main(int argc, char *argv[])
-{
-#ifndef __linux__
-#error This code is currently buggy on BSD systems. Only use on Linux.
-#endif
-	size_t len;
-	size_t tlen;
-	size_t xc = 0;
-
-	char *tmpdir = NULL;
-	char *template = NULL;
-	char *p;
-	char *s = NULL;
-	char *rp;
-	char resolved[PATH_MAX];
-	char c;
-
-	int fd = -1;
-	int type = MKHTEMP_FILE;
-
-	(void) errhook(exit_cleanup);
-	(void) lbsetprogname(argv[0]);
-
-#ifdef __OpenBSD__
-	/* https://man.openbsd.org/pledge.2 */
-	if (pledge("stdio flock rpath wpath cpath fattr", NULL) == -1)
-		exitf("pledge");
-#endif
-
-	while ((c =
-	    getopt(argc, argv, "qdp:")) != -1) {
-
-		switch (c) {
-		case 'd':
-			type = MKHTEMP_DIR;
-			break;
-
-		case 'p':
-			tmpdir = optarg;
-			break;
-
-		case 'q': /* don't print errors */
-			  /* (exit status unchanged) */
-			break;
-
-		default:
-			goto err_usage;
-		}
-	}
-
-	if (optind < argc)
-		template = argv[optind];
-	if (optind + 1 < argc)
-		goto err_usage;
-
-	/* custom template e.g. foo.XXXXXXXXXXXXXXXXXXXXX */
-	if (template != NULL) {	
-		for (p = template + slen(template, PATH_MAX, &tlen);
-		    p > template && *--p == 'X'; xc++);
-
-		if (xc < 3) /* the gnu mktemp errs on less than 3 */
-			exitf(
-			"template must have 3 X or more on end (12+ advised");
-	}
-
-	/* user supplied -p PATH - WARNING:
-	 * this permits symlinks, but only here,
-	 * not in the library, so they are resolved
-	 * here first, and *only here*. the mkhtemp
-	 * library blocks them. be careful
-	 * when using -p
-	 */
-	if (tmpdir != NULL) {
-		rp = realpath(tmpdir, resolved);
-		if (rp == NULL)
-			exitf("%s", tmpdir);
-
-		tmpdir = resolved;
-	}
-
-	if (new_tmp_common(&fd, &s, type,
-	    tmpdir, template) < 0)
-		exitf("%s", s);
-
-#ifdef __OpenBSD__
-	if (pledge("stdio", NULL) == -1)
-		exitf("pledge");
-#endif
-
-	if (s == NULL)
-		exitf("bad string initialisation");
-	if (*s == '\0')
-		exitf("empty string initialisation");
-
-	slen(s, PATH_MAX, &len); /* Nullterminierung prüfen */
-	/* for good measure. (bonus: also re-checks length overflow) */
-
-	printf("%s\n", s);
-
-	return EXIT_SUCCESS;
-
-err_usage:
-	exitf(
-	    "usage: %s [-d] [-p dir] [template]\n", lbgetprogname());
-}
-
-static void
-exit_cleanup(void)
-{
-	return;
-}
@@ -1,134 +0,0 @@
-/* SPDX-License-Identifier: MIT                                        ( >:3 )
- * Copyright (c) 2022-2026 Leah Rowe <leah@libreboot.org>               /| |\
- *                                                                       / \
- * This tool lets you modify Intel GbE NVM (Gigabit Ethernet
- * Non-Volatile Memory) images, e.g. change the MAC address.
- * These images configure your Intel Gigabit Ethernet adapter.
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "include/common.h"
-
-static void
-exit_cleanup(void);
-
-int
-main(int argc, char *argv[])
-{
-#ifndef __linux__
-#error This code is currently buggy on BSD systems. Only use on Linux.
-#endif
-	struct xstate *x;
-	struct commands *cmd;
-	struct xfile *f;
-	size_t c;
-
-	(void) lbsetprogname(argv[0]);
-	if (argc < 3)
-		usage();
-
-	(void) errhook(exit_cleanup);
-
-#ifdef __OpenBSD
-	/* https://man.openbsd.org/pledge.2 */
-	/* https://man.openbsd.org/unveil.2 */
-	if (pledge("stdio flock rpath wpath cpath unveil", NULL) == -1)
-		exitf("pledge");
-	if (unveil("/dev/urandom", "r") == -1)
-		exitf("unveil");
-#endif	
-
-#ifndef S_ISREG
-	exitf(
-	    "Can't determine file types (S_ISREG undefined)");
-#endif
-#if ((CHAR_BIT) != 8)
-	exitf("Unsupported char size");
-#endif
-
-	if ((x = xstart(argc, argv)) == NULL)
-		exitf("NULL state on init");
-
-	/* parse user command */
-/* TODO: CHECK ACCESSES VIA xstatus() */
-	set_cmd(argc, argv);
-	set_cmd_args(argc, argv);
-
-	cmd = &x->cmd[x->i];
-	f = &x->f;
-
-#ifdef __OpenBSD__
-	if ((cmd->flags & O_ACCMODE) == O_RDONLY) {
-		if (unveil(f->fname, "r") == -1)
-			exitf("unveil");
-	} else {
-		if (unveil(f->fname, "rwc") == -1)
-			exitf("unveil");
-	}
-
-	if (unveil(f->tname, "rwc") == -1)
-		exitf("unveil");
-	if (unveil(NULL, NULL) == -1)
-		exitf("unveil");
-	if (pledge("stdio flock rpath wpath cpath", NULL) == -1)
-		exitf("pledge");
-#endif
-
-	if (cmd->run == NULL)
-		exitf("Command not set");
-
-	sanitize_command_list();
-	open_gbe_file();
-	copy_gbe();
-	read_checksums();
-	cmd->run();
-
-	for (c = 0; c < items(x->cmd); c++)
-		x->cmd[c].run = cmd_helper_err;
-
-	if ((cmd->flags & O_ACCMODE) == O_RDWR)
-		write_to_gbe_bin();
-
-	exit_cleanup();
-	if (f->io_err_gbe_bin)
-		exitf("%s: error writing final file");
-
-	free_and_set_null(&f->tname);
-
-	return EXIT_SUCCESS;
-}
-
-static void
-exit_cleanup(void)
-{
-	struct xstate *x;
-	struct xfile *f;
-
-	x = xstatus();
-	if (x == NULL)
-		return;
-
-	f = &x->f;
-
-	/* close fds if still open */
-	xclose(&f->tmp_fd);
-	xclose(&f->gbe_fd);
-
-	/* unlink tmpfile if it exists */
-	if (f->tname != NULL) {
-		(void) unlink(f->tname);
-		free_and_set_null(&f->tname);
-	}
-}