libreboot
/
lbmk
1
0
Fork 0
Code Packages Projects Releases Activity
lbmk/script/update/release

232 lines
6.6 KiB
Plaintext
Raw Normal View History

update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
#!/usr/bin/env sh
# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2020-2023 Leah Rowe <leah@libreboot.org>
set -u -e
. "include/err.sh"
update/release: fix missing variable definition i forgot to include option.sh in this script, during previous re-factoring. the cbfstoos variable is now defined exclusively in option.sh, but other scripts can set it to something else. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-15 22:33:29 +00:00
. "include/option.sh"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
don't delete microcode updates in rom images at present, lbmk can remove microcode updates on images for a given target, if the target specifies microcode_required="n" in target.cfg lbmk then provides images with microcode, and images without, in a given release. although the user can also remove them manually, this just makes it a bit more convenient, for those users who do wish to run without the updates. this functionality is provided only on those platforms where no-microcode is tested. well, this behaviour implements a compromise on libreboot policy, which is to always include microcode updates by default. see: Binary Blob Reduction Policy the *canoeboot* project now exists, developed in parallel with libreboot, and it ships without microcode updates, on the same targets where lbmk also handled this. running without microcode updates is foolish, and should not be encouraged. clean up lbmk by not providing this kludge. the libreboot documentation will be updated, telling such users to try canoeboot instead, or to remove the update from a given libreboot rom - this is still possible, and mitigations such as PECI disablement on GM45 are still in place (and will be kept), so that this continues to work well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-23 06:54:56 +00:00
eval "$(setvars "" vdir relname src_dirname srcdir _xm target romdir mode)"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
main()
{
vdir="release"
update/release: use getops OPTARG correctly Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-13 23:35:02 +00:00
while getopts d:m: option; do
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
[ -z "${OPTARG}" ] && $err "Empty argument not allowed"
update/release: use getops OPTARG correctly Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-13 23:35:02 +00:00
case "${option}" in
d) vdir="${OPTARG}" ;;
m) mode="${OPTARG}" ;;
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
*) $err "Invalid option" ;;
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
esac
done
set version/projectname properly lbmk used to set version/versiondate directly in err.sh, but now it's handled there by a function, which is called by the main script. script/update/release hadn't yet been adapted. the only change necessary is to call check_project() script/update/trees also makes use of it script/build/roms is using "projectname" Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-23 08:43:42 +00:00
check_project
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
vdir="${vdir}/${version}"
update/release: remove unused variables Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 04:30:54 +00:00
relname="${projectname}-${version}"
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
[ "${mode}" = "u-boot" ] && relname="u-boot-for-${relname}"
update/release: remove unused variables Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 04:30:54 +00:00
src_dirname="${relname}_src"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
srcdir="${vdir}/${src_dirname}"
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
[ -e "${vdir}" ] && $err "already exists: \"${vdir}\""
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
mkvdir
build_release
update/release: confirm vdir path on exit Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 11:09:31 +00:00
printf "DONE! Check release files under %s\n" "${vdir}"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
mkvdir()
{
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
mkdir -p "${vdir}" || $err "mkvdir: !mkdir -p \"${vdir}\""
git clone . "${srcdir}" || $err "mkdir: !gitclone \"${srcdir}\""
insert_version_files "$srcdir" || $err "mkvdir $srcdir: versionfile"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
build_release()
{
_xm="build_release ${vdir}"
(
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
cd "${srcdir}" || $err "${_xm}: !cd \"${srcdir}\""
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
fetch_trees
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
[ "${mode}" = "u-boot" ] || x_ mv src/docs docs
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
) || $err "can't create release files"
update/release: generate changelogs use the git log, as follows: git log --graph --pretty=format:'%Cred%h%Creset %s %Creset' --abbrev-commit this creates a nice, uniform list of changes. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-01-21 22:05:41 +00:00
git log --graph --pretty=format:'%Cred%h%Creset %s %Creset' \
--abbrev-commit > "${srcdir}/CHANGELOG" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "build_release $srcdir: couldn't generate changelog"
update/release: generate changelogs use the git log, as follows: git log --graph --pretty=format:'%Cred%h%Creset %s %Creset' --abbrev-commit this creates a nice, uniform list of changes. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-01-21 22:05:41 +00:00
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
(
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
if [ "${mode}" = "u-boot" ]; then
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
cd "${srcdir}/src/" || $err "${_xm}: mktarball \"${srcdir}\""
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
mktarball u-boot "../../${srcdir##*/}.tar.xz" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "$_xm: mksrc"
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
# make a src archive containing only u-boot
else
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
cd "${srcdir%/*}" || $err "${_xm}: mktarball \"${srcdir}\""
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
mktarball "${srcdir##*/}" "${srcdir##*/}.tar.xz" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "$_xm: mksrc"
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
fi
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
) || $err "can't create src tarball"
update/release: don't insert crossgcc tarballs why are we distributing gcc at all? the coreboot build system downloads it at build time, and the GNU rsync mirrors aren't going anywhere. simplify script/update/release by not handling gcc. this means: release archives will no longer contain gcc. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-23 04:29:50 +00:00
[ "${mode}" = "src" ] && return 0
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
[ "${mode}" = "u-boot" ] && return 0
update/release: copy crossgcc to archive everything downloaded, then tarballed, then built, now crossgcc is downloaded by coreboot. now extract, copy crossgcc tarballs, re-compress. TODO: simply add files to the archive, without re- compressing the whole thing. this is still more efficient than the old way: build everything, then clean and compress, making another build test on the release archive necessary; with this, there is still only one build test per release. with this, and the previous revisions dealing with submodules, the source archives should now be complete. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 10:51:38 +00:00
(
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
cd "${srcdir}" || $err "${_xm}: 2 !cd \"${srcdir}\""
update/release: copy crossgcc to archive everything downloaded, then tarballed, then built, now crossgcc is downloaded by coreboot. now extract, copy crossgcc tarballs, re-compress. TODO: simply add files to the archive, without re- compressing the whole thing. this is still more efficient than the old way: build everything, then clean and compress, making another build test on the release archive necessary; with this, there is still only one build test per release. with this, and the previous revisions dealing with submodules, the source archives should now be complete. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 10:51:38 +00:00
mkrom_images
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
) || $err "can't build rom images"
update/release: copy crossgcc to archive everything downloaded, then tarballed, then built, now crossgcc is downloaded by coreboot. now extract, copy crossgcc tarballs, re-compress. TODO: simply add files to the archive, without re- compressing the whole thing. this is still more efficient than the old way: build everything, then clean and compress, making another build test on the release archive necessary; with this, there is still only one build test per release. with this, and the previous revisions dealing with submodules, the source archives should now be complete. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 10:51:38 +00:00
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
rm -Rf "${srcdir}" || $err "!rm -Rf ${srcdir}"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
fetch_trees()
{
update/release: don't hardcode project names config/git has been re-arranged in a prior revision, ensuring that each file only refers to a main source tree defined within those files. the erstwhile "./build clean all" functionality is now once again possible in lbmk Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 05:53:25 +00:00
for x in config/git/*; do
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
[ "${mode}" = "u-boot" ] && break
update/release: don't hardcode project names config/git has been re-arranged in a prior revision, ensuring that each file only refers to a main source tree defined within those files. the erstwhile "./build clean all" functionality is now once again possible in lbmk Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 05:53:25 +00:00
[ ! -f "${x}" ] || ./update trees -f "${x#config/git/}" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "${_xm}: fetch ${x#config/git/}"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
done
support making u-boot-only tarballs in releases ./update release -m u-boot if someone just wants to make u-boot, they can use this and it tars up all the trees. Signed-off-by: Leah Rowe <info@minifree.org>
2024-02-07 00:16:18 +00:00
[ "${mode}" = "u-boot" ] && x_ ./update trees -f u-boot
update/release: delete multi-tree upstream repos e.g. src/coreboot/coreboot must not appear in a release, because we instead have directories like src/coreboot/default or src/coreboot/cros lbmk resets src/coreboot/coreboot to HEAD, but then resets revisions properly in copies of it therefore, for reproducibility, we must not include src/coreboot/coreboot, src/u-boot/u-boot or src/seabios/seabios into libreboot releases Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-13 22:53:24 +00:00
for x in config/*/build.list; do
[ -f "${x}" ] || continue
xp="${x#*/}"; xp="${xp%/*}"
20231021hotfix: replace x_ with err in some places keymaps weren't being set in keymay.cfg of cbfs, due to use of x_ in the rom script, and x_ doesn't handle quotes or spaces in arguments well. i'm going to remove use of x_ and xx_ (it's in my todo), for next release. for now, hot patch the release. i've gone through and replaced use of x_ with || err, in some places. not just the keymap.cfg command, but others too. in case there are more issues we missed. this commit is being tagged "20231021fix" and i'm using this tag to re-build the 20231021 release. i'll just replace the tarballs in rsync and add errata to the news page announcing the release. all i did was break peoples umlauts, i didn't brick their machines fortunately! very minor bug. anyway, x_/xx_ is a great idea, but sh isn't really designed for that style of programming. i'll go back to using just || err in the next release. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-22 11:31:55 +00:00
[ -L "${xp}" ] || rm -Rf "src/${xp}/${xp}" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "!rm -Rf \"src/${xp}/${xp}\""
update/release: delete multi-tree upstream repos e.g. src/coreboot/coreboot must not appear in a release, because we instead have directories like src/coreboot/default or src/coreboot/cros lbmk resets src/coreboot/coreboot to HEAD, but then resets revisions properly in copies of it therefore, for reproducibility, we must not include src/coreboot/coreboot, src/u-boot/u-boot or src/seabios/seabios into libreboot releases Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-13 22:53:24 +00:00
done
update/release: delete *all* .git and .gitmodules do it using find -exec this is more robust, and it will never need to be maintained over time (famous last words). this is done because now we download submodules for all git projects, so it's hard to predict. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 08:25:52 +00:00
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
find . -name ".git" -exec rm -Rf {} + || $err "$_xm: rm .git"
find . -name ".gitmodules" -exec rm -Rf {} + || $err "$_xm: rm .gitmod"
always re-generate .git in lbmk in release archives, .git is excluded but the version and versiondate files are included. from these, the git history is re-created with the exact date (but not taking into account timezone, at present). in this way, lbmk will have git history in a release archive. some build systems, like coreboot, prefer that there be git history available, so this is a nice workaround on those build systems. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-20 10:16:25 +00:00
x_ rm -Rf tmp .git
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
mkrom_images()
{
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
./build roms all || $err "${_xm}: roms-all"
./build serprog rp2040 || $err "${_xm}: rp2040"
./build serprog stm32 || $err "${_xm}: stm32"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
for rombuild in bin/*; do
[ -d "${rombuild}" ] || continue
handle_rom_archive "${rombuild}"
done
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
mv "release/${version}/roms/" ../roms || $err "${_xm}: copy roms/"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
handle_rom_archive()
{
builddir="${1}"
romdir="tmp/romdir"
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
rm -Rf "${romdir}" || $err "!rm romdir, handle_rom_archive"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
target="${builddir##*/}"
if [ ! -f "config/coreboot/${target}/target.cfg" ]; then
# No config, just make a tarball
update/release: remove unused variables Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 04:30:54 +00:00
tarball="release/${version}/roms/${relname}_${target}.tar.xz"
20231021hotfix: replace x_ with err in some places keymaps weren't being set in keymay.cfg of cbfs, due to use of x_ in the rom script, and x_ doesn't handle quotes or spaces in arguments well. i'm going to remove use of x_ and xx_ (it's in my todo), for next release. for now, hot patch the release. i've gone through and replaced use of x_ with || err, in some places. not just the keymap.cfg command, but others too. in case there are more issues we missed. this commit is being tagged "20231021fix" and i'm using this tag to re-build the 20231021 release. i'll just replace the tarballs in rsync and add errata to the news page announcing the release. all i did was break peoples umlauts, i didn't brick their machines fortunately! very minor bug. anyway, x_/xx_ is a great idea, but sh isn't really designed for that style of programming. i'll go back to using just || err in the next release. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-22 11:31:55 +00:00
insert_copying_files "${builddir}" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "!insert copy, handle, ${builddir}"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
mktarball "${builddir}" "${tarball}"
return 0
fi
romdir="${romdir}/bin/${target}"
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
mkdir -p "${romdir}" || $err "!mkdir -p romdir, handle_rom_archive"
cp "$builddir/"* "$romdir" || $err "!cp romdir, handle_rom_archive"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
update/release: nuke roms using the inject script This way, the handling of configs is unified into one script, which reduces the possibility of bugs later, and it reduces the repetition of code. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 02:30:52 +00:00
nukerom
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
printf "Generating release/%s/roms/%s-%s_%s.tar.xz\n" \
"${version}" "${projectname}" "${version}" "${target##*/}"
insert_version_files "${romdir}" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "mkrom_tarball ${romdir}: versionfile"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
insert_copying_files "$romdir" || $err "!insert copy, handle 2, $romdir"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
mkrom_tarball
}
update/release: nuke roms using the inject script This way, the handling of configs is unified into one script, which reduces the possibility of bugs later, and it reduces the repetition of code. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 02:30:52 +00:00
nukerom()
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
{
. "config/coreboot/${target}/target.cfg"
update/release: nuke roms using the inject script This way, the handling of configs is unified into one script, which reduces the possibility of bugs later, and it reduces the repetition of code. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 02:30:52 +00:00
# Hash the images before removing vendor files
lbmk: use 2-level directory structure in script/ as opposed to the current 3-level structure. recent build system simplifications have enabled this change, thus: ./build fw coreboot -> ./build roms ./build fw grub -> ./build grub ./build fw serprog -> ./build serprog ./update project release -> ./update release ./update project trees -> ./update trees ./update vendor download -> ./vendor download ./update vendor inject -> ./vendor inject alper criticised that the commands were too long, so i made them shorter! Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-19 23:17:30 +00:00
# which "./vendor inject" uses for verification
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
rm -f "${romdir}/vendorhashes" || $err "!rm ${romdir}/vendorhashes"
touch "${romdir}/vendorhashes" || $err "!touch ${romdir}/vendorhashes"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
(
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
cd "${romdir}" || $err "!cd romdir ${romdir}, nukerom"
lbmk scripts: general code cleanup Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-24 06:32:19 +00:00
sha512sum ./*.rom >> vendorhashes || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "!create vendorhashes, nukerom"
) || $err "can't create vendor hashes"
update/release: nuke roms using the inject script This way, the handling of configs is unified into one script, which reduces the possibility of bugs later, and it reduces the repetition of code. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 02:30:52 +00:00
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
for romfile in "${romdir}"/*.rom; do
[ -f "${romfile}" ] || continue
lbmk scripts: shorter code lines while seemingly pedantic, this does actually make code easier to read. mostly just switching to shorthand for variable names, where no expansions or patterns are used Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-24 09:04:36 +00:00
./vendor inject -r "$romfile" -b "$target" -n nuke || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "!vendor inject (nuke) ${romfile}, nukerom"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
done
}
insert_copying_files()
{
general code cleanup Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-22 09:46:43 +00:00
remkdir "${1}/licenses"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
l="${1}/licenses"
# copy licenses to rom image archive, for completion
20231021hotfix: replace x_ with err in some places keymaps weren't being set in keymay.cfg of cbfs, due to use of x_ in the rom script, and x_ doesn't handle quotes or spaces in arguments well. i'm going to remove use of x_ and xx_ (it's in my todo), for next release. for now, hot patch the release. i've gone through and replaced use of x_ with || err, in some places. not just the keymap.cfg command, but others too. in case there are more issues we missed. this commit is being tagged "20231021fix" and i'm using this tag to re-build the 20231021 release. i'll just replace the tarballs in rsync and add errata to the news page announcing the release. all i did was break peoples umlauts, i didn't brick their machines fortunately! very minor bug. anyway, x_/xx_ is a great idea, but sh isn't really designed for that style of programming. i'll go back to using just || err in the next release. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-22 11:31:55 +00:00
cp "src/grub/COPYING" "${l}/COPYING.grub" || return 1
cp "src/coreboot/default/COPYING" "${l}/COPYING.coreboot" || return 1
lbmk scripts: general code cleanup Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-24 06:32:19 +00:00
cp -R "src/coreboot/default/LICENSES" "${l}/LICENSES.coreboot" || \
return 1
20231021hotfix: replace x_ with err in some places keymaps weren't being set in keymay.cfg of cbfs, due to use of x_ in the rom script, and x_ doesn't handle quotes or spaces in arguments well. i'm going to remove use of x_ and xx_ (it's in my todo), for next release. for now, hot patch the release. i've gone through and replaced use of x_ with || err, in some places. not just the keymap.cfg command, but others too. in case there are more issues we missed. this commit is being tagged "20231021fix" and i'm using this tag to re-build the 20231021 release. i'll just replace the tarballs in rsync and add errata to the news page announcing the release. all i did was break peoples umlauts, i didn't brick their machines fortunately! very minor bug. anyway, x_/xx_ is a great idea, but sh isn't really designed for that style of programming. i'll go back to using just || err in the next release. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-22 11:31:55 +00:00
cp "src/seabios/default/COPYING" "${l}/COPYING.coreboot" || return 1
lbmk scripts: general code cleanup Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-24 06:32:19 +00:00
cp "src/seabios/default/COPYING.LESSER" "$l/COPYING.LESSER.seabios" \
|| return 1
20231021hotfix: replace x_ with err in some places keymaps weren't being set in keymay.cfg of cbfs, due to use of x_ in the rom script, and x_ doesn't handle quotes or spaces in arguments well. i'm going to remove use of x_ and xx_ (it's in my todo), for next release. for now, hot patch the release. i've gone through and replaced use of x_ with || err, in some places. not just the keymap.cfg command, but others too. in case there are more issues we missed. this commit is being tagged "20231021fix" and i'm using this tag to re-build the 20231021 release. i'll just replace the tarballs in rsync and add errata to the news page announcing the release. all i did was break peoples umlauts, i didn't brick their machines fortunately! very minor bug. anyway, x_/xx_ is a great idea, but sh isn't really designed for that style of programming. i'll go back to using just || err in the next release. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-22 11:31:55 +00:00
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
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
mkrom_tarball()
{
update/release: remove unused variables Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 04:30:54 +00:00
archivename="${relname}_${target##*/}"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
f="release/${version}/roms/${archivename}"
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
mkdir -p "${f%/*}" || $err "mkrom_tarball: !mkdir -p ${f%/*}"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
(
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
cd "${romdir%"/bin/$target"}" || $err "!cd ${romdir%"/bin/$target"}"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
mktarball "bin/${target}" "${archivename}.tar.xz"
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
) || $err "can't create rom tarball"
fix several shellcheck warnings lbmk didn't quote certain arguments in commands, or used ! -z instead of -n, things like that. simple fixes. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-16 07:56:26 +00:00
mv "${romdir%"/bin/${target}"}/${archivename}.tar.xz"* "${f%/*}" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "mktar ${f%/*}/${romdir%"/bin/$target"}/$archivename.tar.xz"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
fix several shellcheck warnings lbmk didn't quote certain arguments in commands, or used ! -z instead of -n, things like that. simple fixes. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-16 07:56:26 +00:00
printf "Created ROM archive: %s" "${f%/*}/${archivename}.tar.xz"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
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()
{
update/release: if *GNU* tar, use --mtime with --mtime, files added to the archive can be set to a static date (in this case, the unix epoch) the one used here is derived from git commit dates, and it is static; if not being handled in lbmk.git, the versiondate file never changes this is the first patch in a series of patches designed to bring about reproducible builds in libreboot a solution will need to be found, for non-GNU tar implementations, because they did not have an equivalent option according to their manpages. for example, BSD tar implementations. perhaps i could systematically go around changing file dates, on each file, as a fallback behaviour? Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-13 22:28:11 +00:00
# preserve timestamps for reproducible tarballs
update/release: fix/simplify mtime handling i wasn't getting the very first line of tar --version, so it wasn't doing the check properly. further sort the files by name within the tar archive. for reliability, don't bother using versiondate anymore: set a *fixed* date, and fixed timezone, to ensure that it works reliably for reproducible tarball creation. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 03:37:14 +00:00
tar_implementation=$(tar --version | head -n1) || :
update/release: if *GNU* tar, use --mtime with --mtime, files added to the archive can be set to a static date (in this case, the unix epoch) the one used here is derived from git commit dates, and it is static; if not being handled in lbmk.git, the versiondate file never changes this is the first patch in a series of patches designed to bring about reproducible builds in libreboot a solution will need to be found, for non-GNU tar implementations, because they did not have an equivalent option according to their manpages. for example, BSD tar implementations. perhaps i could systematically go around changing file dates, on each file, as a fallback behaviour? Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-13 22:28:11 +00:00
lbmk scripts: general code cleanup Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-24 06:32:19 +00:00
[ "${2%/*}" = "${2}" ] || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
mkdir -p "${2%/*}" || $err "mk, !mkdir -p \"${2%/*}\""
update/release: fix/simplify mtime handling i wasn't getting the very first line of tar --version, so it wasn't doing the check properly. further sort the files by name within the tar archive. for reliability, don't bother using versiondate anymore: set a *fixed* date, and fixed timezone, to ensure that it works reliably for reproducible tarball creation. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 03:37:14 +00:00
if [ "${tar_implementation% *}" = "tar (GNU tar)" ]; then
tar --sort=name --owner=root:0 --group=root:0 \
Libreboot 20240225 Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-02-25 12:53:16 +00:00
--mtime="UTC 2024-02-25" -c "$1" | xz -T0 -9e > "$2" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "mktarball 1, ${1}"
update/release: fix/simplify mtime handling i wasn't getting the very first line of tar --version, so it wasn't doing the check properly. further sort the files by name within the tar archive. for reliability, don't bother using versiondate anymore: set a *fixed* date, and fixed timezone, to ensure that it works reliably for reproducible tarball creation. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 03:37:14 +00:00
else
# TODO: reproducible tarballs on non-GNU systems
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
tar -c "$1" | xz -T0 -9e > "$2" || $err "mktarball 2, $1"
update/release: fix/simplify mtime handling i wasn't getting the very first line of tar --version, so it wasn't doing the check properly. further sort the files by name within the tar archive. for reliability, don't bother using versiondate anymore: set a *fixed* date, and fixed timezone, to ensure that it works reliably for reproducible tarball creation. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-14 03:37:14 +00:00
fi
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
(
[ "${2%/*}" != "${2}" ] && x_ cd "${2%/*}"
20231021hotfix: replace x_ with err in some places keymaps weren't being set in keymay.cfg of cbfs, due to use of x_ in the rom script, and x_ doesn't handle quotes or spaces in arguments well. i'm going to remove use of x_ and xx_ (it's in my todo), for next release. for now, hot patch the release. i've gone through and replaced use of x_ with || err, in some places. not just the keymap.cfg command, but others too. in case there are more issues we missed. this commit is being tagged "20231021fix" and i'm using this tag to re-build the 20231021 release. i'll just replace the tarballs in rsync and add errata to the news page announcing the release. all i did was break peoples umlauts, i didn't brick their machines fortunately! very minor bug. anyway, x_/xx_ is a great idea, but sh isn't really designed for that style of programming. i'll go back to using just || err in the next release. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-22 11:31:55 +00:00
sha512sum "${2##*/}" > "${2##*/}.sha512" || \
safer, simpler error handling in lbmk in shell scripts, a function named the same as a program included in the $PATH will override that program. for example, you could make a function called ls() and this would override the standand "ls". in lbmk, a part of it was first trying to run the "fail" command, deferring to "err", because some scripts call fail() which does some minor cleanup before calling err. in most cases, fail() is not defined, and it's possible that the user could have a program called "fail" in their $PATH, the behaviour of which we could not determine, and it could have disastrous effects. lbmk error handling has been re-engineered in such a way that the err function is defined in a variable, which defaults to err_ which calls err_, so defined under include/err.sh. in functions that require cleanup prior to error handling, a fail() function is still defined, and err is overridden, thus: err="fail" this change has made xx_() obsolete, so now only x_ is used. the x_ function is a wrapper that can be used to run a command and exit with non-zero status (from lbmk) if the command fails. the xx_ command did the same thing, but called fail() which would have called err(); now everything is $err example: rm -f "$filename" || err "could not delete file" this would now be: rm -f "$filename" || $err "could not delete file" overriding of err= must be done *after* including err.sh. for example: err="fail" . "include/err.sh" ^ this is wrong. instead, one must do: . "include/err.sh" err="fail" this is because err is set as a global variable under err.sh the new error handling is much cleaner, and safer. it also reduces the chance of mistakes such as: calling err when you meant to call fail. this is because the standard way is now to call $err, so you set err="fail" at the top of the script and all is well. Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
$err "!sha512sum \"${2##*/}\" > \"${2##*/}.sha512\""
) || $err "failed to create tarball checksum"
update/release/*: merge to update/project/release The logic has been re-written, where source archives are concerned. This clones the current repository, and starts a new build from scratch. A custom release directory is possible, by passing -d This eliminates a step during build-testing, saving hours of time, because it builds the release archive *inside* the release archive, with git files removed, thus replicating the same setup that the user would have. This also makes everything a bit more consistent, because it's guaranteed that a release archive will always have the same files; previously, the release build script would only copy what was already built, without building anything. Now, this script builds everything itself. The script also builds serprog images, not just coreboot. Usage: ./update project release If -d is not passed, release/ is used inside lbmk. Otherwise, you could do: ./update project release -d /path/to/directory If the directory exists, this script will exit (error). Other minor fixes: build/fw/coreboot: make version in coreboot-version (file) not contain hyphens, to work around a quirk in coreboot's build system when not building on regular libreboot releases. this quirk only appears when lbmk is not being compiled under git. The other main benefit of this change is that the new script will probably require a lot less maintenance. Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-08 01:34:50 +00:00
}
main $@