lbmk/script/update/release

295 lines
9.0 KiB
Bash
Executable File

#!/usr/bin/env sh
# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2020-2023 Leah Rowe <leah@libreboot.org>
set -u -e
. "include/err.sh"
. "include/option.sh"
eval "$(setvars "" vdir relname src_dirname srcdir _xm target romdir \
microcode_required mode)"
main()
{
vdir="release"
while getopts d:m: option; do
[ -z "${OPTARG}" ] && err "Empty argument not allowed"
case "${option}" in
d) vdir="${OPTARG}" ;;
m) mode="${OPTARG}" ;;
*) err "Invalid option" ;;
esac
done
vdir="${vdir}/${version}"
relname="${projectname}-${version}"
src_dirname="${relname}_src"
srcdir="${vdir}/${src_dirname}"
[ -e "${vdir}" ] && err "already exists: \"${vdir}\""
mkvdir
build_release
printf "DONE! Check release files under %s\n" "${vdir}"
}
mkvdir()
{
mkdir -p "${vdir}" || err "mkvdir: !mkdir -p \"${vdir}\""
git clone . "${srcdir}" || err "mkdir: !gitclone \"${srcdir}\""
insert_version_files "${srcdir}" || err "mkvdir ${srcdir}: versionfile"
}
build_release()
{
_xm="build_release ${vdir}"
(
cd "${srcdir}" || err "${_xm}: !cd \"${srcdir}\""
fetch_trees
x_ mv src/docs docs
) || err "can't copy docs"
(
cd "${srcdir%/*}" || err "${_xm}: mktarball \"${srcdir}\""
mktarball "${srcdir##*/}" "${srcdir##*/}.tar.xz" || err "${_xm}: mksrc"
) || err "can't create pre-crossgcc src tarball"
[ "${mode}" = "src" ] && return 0 # for src mode, xgcc tarballs are
# not included in the src archive
# now build roms, then copy crossgcc to src and re-compress
# while compressing rom images too.
(
cd "${srcdir}" || err "${_xm}: 2 !cd \"${srcdir}\""
mkrom_images
) || err "can't build rom images"
for _cbd in "${srcdir}/src/coreboot/"*; do
[ -d "${_cbd}/util/crossgcc/tarballs" ] || continue
_xgccdir="${vdir}/crossgcc/${_cbd##*/}"
mkdir -p "${_xgccdir}" || \
err "build_release: !mkdir -p ${_xgccdir}"
cp -R "${_cbd}/util/crossgcc/tarballs/"* "${_xgccdir}" || \
err "build_gcc: !copy xgcc ${_cbd}"
done
rm -Rf "${srcdir}" || err "build_release: !rm -Rf ${srcdir}"
(
cd "${srcdir%/*}" || err "${_xm} 2: mktarball \"${srcdir}\""
tar -xf "${srcdir##*/}.tar.xz" || err "!extract ${srcdir##*/}.tar.xz"
rm -f "${srcdir##*/}.tar.xz" || err "!rm -f ${srcdir##*/}.tar.xz"
) || err "can't extract pre-crossgcc src tarball"
for _xgcc in "${vdir}/crossgcc/"*; do
[ -d "${_xgcc}" ] || continue
mkdir -p "${srcdir}/src/coreboot/${_xgcc##*/}/util/crossgcc/tarballs" || \
err "!mkdir src/coreboot/${_xgcc##*/}/util/crossgcc/tarballs"
mv "${_xgcc}/"* \
"${srcdir}/src/coreboot/${_xgcc##*/}/util/crossgcc/tarballs/" \
|| err "!move xgcc tarballs to ${srcdir}/xgcc/${_xgcc##*/}"
done
rm -Rf "${vdir}/crossgcc" || err "!rm -Rf \"${vdir}/crossgcc\""
(
cd "${srcdir%/*}" || err "${_xm}: mktarball \"${srcdir}\""
mktarball "${srcdir##*/}" "${srcdir##*/}.tar.xz" || err "${_xm}: mksrc"
) || err "can't create src tarball with crossgcc"
# now test the vendor insert script, using the release archive:
(
cd "${srcdir}" || err "!cd ${srcdir}"
mkfakeroms
for vrom in ../roms/*.tar.xz; do
[ -f "${vrom}" ] || continue
case "${vrom}" in
*serprog*) continue ;;
esac
./vendor inject "${vrom}" || \
err "TESTFAIL: inject: ${vrom##*/}"
continue
done
) || err "vendorfile inject test failure"
rm -Rf "${srcdir}" || err "!rm -Rf ${srcdir}"
}
fetch_trees()
{
for x in config/git/*; do
[ ! -f "${x}" ] || ./update trees -f "${x#config/git/}" || \
err "${_xm}: fetch ${x#config/git/}"
done
for x in config/*/build.list; do
[ -f "${x}" ] || continue
xp="${x#*/}"; xp="${xp%/*}"
[ -L "${xp}" ] || rm -Rf "src/${xp}/${xp}" || \
err "!rm -Rf \"src/${xp}/${xp}\""
done
find . -name ".git" -exec rm -Rf {} + || err "${_xm}: rm .git"
find . -name ".gitmodules" -exec rm -Rf {} + || err "${_xm}: rm .gitmod"
x_ rm -Rf tmp .git
}
mkrom_images()
{
mkfakeroms
./build roms all || err "${_xm}: roms-all"
./build serprog rp2040 || err "${_xm}: rp2040"
./build serprog stm32 || err "${_xm}: stm32"
for rombuild in bin/*; do
[ -d "${rombuild}" ] || continue
handle_rom_archive "${rombuild}"
done
mv "release/${version}/roms/" ../roms || err "${_xm}: copy roms/"
}
mkfakeroms()
{
# fake me.bin to make x201 roms build
mkdir -p "vendorfiles/x201/" || \
err "mkvdir: !mkdir -p \"vendorfiles/x201/\""
dd if=/dev/zero of="vendorfiles/x201/me.bin" \
bs=68k count=1 || err "mkvdir: can't make fake x201 me.bin"
}
handle_rom_archive()
{
builddir="${1}"
romdir="tmp/romdir"
rm -Rf "${romdir}" || err "!rm romdir, handle_rom_archive"
target="${builddir##*/}"
if [ ! -f "config/coreboot/${target}/target.cfg" ]; then
# No config, just make a tarball
tarball="release/${version}/roms/${relname}_${target}.tar.xz"
insert_copying_files "${builddir}" || \
err "!insert copy, handle, ${builddir}"
mktarball "${builddir}" "${tarball}"
return 0
fi
romdir="${romdir}/bin/${target}"
mkdir -p "${romdir}" || err "!mkdir -p romdir, handle_rom_archive"
cp "${builddir}/"* "${romdir}" || err "!cp romdir, handle_rom_archive"
nukerom
printf "Generating release/%s/roms/%s-%s_%s.tar.xz\n" \
"${version}" "${projectname}" "${version}" "${target##*/}"
insert_version_files "${romdir}" || \
err "mkrom_tarball ${romdir}: versionfile"
insert_copying_files "${romdir}" || err "!insert copy, handle 2, ${romdir}"
mkrom_tarball
}
nukerom()
{
microcode_required="y"
. "config/coreboot/${target}/target.cfg"
if [ "${microcode_required}" != "y" ] && \
[ "${microcode_required}" != "n" ]; then microcode_required="y"; fi
if [ "${microcode_required}" = "n" ]; then
for romfile in "${romdir}"/*.rom; do
[ -f "${romfile}" ] || continue
strip_ucode "${romfile}"
done
for romfile in "${romdir}"/*.tmprom; do
[ -f "${romfile}" ] || continue
mv "${romfile}" "${romfile%.tmprom}.rom" || \
err "!mv romfile, nukerom"
done
fi
# Hash the images before removing vendor files
# which "./vendor inject" uses for verification
rm -f "${romdir}/vendorhashes" || err "!rm ${romdir}/vendorhashes"
touch "${romdir}/vendorhashes" || err "!touch ${romdir}/vendorhashes"
(
cd "${romdir}" || err "!cd romdir ${romdir}, nukerom"
sha512sum ./*.rom >> vendorhashes || err "!create vendorhashes, nukerom"
) || err "can't create vendor hashes"
for romfile in "${romdir}"/*.rom; do
[ -f "${romfile}" ] || continue
./vendor inject -r "${romfile}" -b "${target}" -n nuke || \
err "!vendor inject (nuke) ${romfile}, nukerom"
done
}
strip_ucode()
{
romfile=${1}
_newrom_b="${romfile%.rom}_nomicrocode.tmprom"
cp "${romfile}" "${_newrom_b}" || err "!cp romfile ${romfile}, strip_u"
microcode_present="y"
"${cbfstool}" "${_newrom_b}" remove -n \
cpu_microcode_blob.bin 2>/dev/null || microcode_present="n"
[ "${microcode_present}" = "n" ] || return 0
printf "REMARK: '%s' already lacks microcode\n" "${romfile}" 1>&2
printf "Renaming default ROM file instead.\n" 1>&2
mv "${romfile}" "${_newrom_b}" || err "!mv romfile ${romfile}, strip_u"
}
insert_copying_files()
{
rm -Rf "${1}/licenses" || return 1
mkdir -p "${1}/licenses" || return 1
l="${1}/licenses"
# copy licenses to rom image archive, for completion
cp "src/grub/COPYING" "${l}/COPYING.grub" || return 1
cp "src/coreboot/default/COPYING" "${l}/COPYING.coreboot" || return 1
cp -R "src/coreboot/default/LICENSES" "${l}/LICENSES.coreboot" || return 1
cp "src/seabios/default/COPYING" "${l}/COPYING.coreboot" || return 1
cp "src/seabios/default/COPYING.LESSER" "${l}/COPYING.LESSER.seabios" || return 1
cp -R "src/u-boot/default/Licenses" "${l}/COPYING.u-boot" || return 1
printf "Multiple licenses. Check corresponding %s source archive\n" \
"${projectname}" > "${1}/COPYING" || return 1
}
mkrom_tarball()
{
archivename="${relname}_${target##*/}"
f="release/${version}/roms/${archivename}"
mkdir -p "${f%/*}" || err "mkrom_tarball: !mkdir -p ${f%/*}"
(
cd "${romdir%"/bin/${target}"}" || err "!cd ${romdir%"/bin/${target}"}"
mktarball "bin/${target}" "${archivename}.tar.xz"
) || err "can't create rom tarball"
mv "${romdir%"/bin/${target}"}/${archivename}.tar.xz"* "${f%/*}" || \
err "!mktarball, rom, ${f%/*}/${romdir%"/bin/${target}"}/${archivename}.tar.xz"
printf "Created ROM archive: %s" "${f%/*}/${archivename}.tar.xz"
}
insert_version_files()
{
printf "%s\n" "${version}" > "${1}/version" || return 1
printf "%s\n" "${versiondate}" > "${1}/versiondate" || return 1
printf "%s\n" "${projectname}" > "${1}/projectname" || return 1
}
mktarball()
{
# preserve timestamps for reproducible tarballs
tar_implementation=$(tar --version | head -n1) || :
[ "${2%/*}" = "${2}" ] || mkdir -p "${2%/*}" || err "mk, !mkdir -p \"${2%/*}\""
if [ "${tar_implementation% *}" = "tar (GNU tar)" ]; then
tar --sort=name --owner=root:0 --group=root:0 \
--mtime="UTC 2023-11-06" -c "${1}" | xz -T0 -9e > "${2}" || \
err "mktarball 1, ${1}"
else
# TODO: reproducible tarballs on non-GNU systems
tar -c "${1}" | xz -T0 -9e > "${2}" || err "mktarball 2, ${1}"
fi
(
[ "${2%/*}" != "${2}" ] && x_ cd "${2%/*}"
sha512sum "${2##*/}" > "${2##*/}.sha512" || \
err "!sha512sum \"${2##*/}\" > \"${2##*/}.sha512\""
) || err "failed to create tarball checksum"
}
main $@