2023-06-13 11:09:01 +00:00
|
|
|
#!/usr/bin/env sh
|
2023-09-25 01:19:30 +00:00
|
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
2024-01-01 17:57:35 +00:00
|
|
|
# SPDX-FileCopyrightText: 2014-2016,2020,2021,2023,2024 Leah Rowe <leah@libreboot.org>
|
2023-10-05 02:23:07 +00:00
|
|
|
# SPDX-FileCopyrightText: 2021,2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
|
2023-09-25 01:19:30 +00:00
|
|
|
# SPDX-FileCopyrightText: 2022 Caleb La Grange <thonkpeasant@protonmail.com>
|
2023-10-13 19:41:15 +00:00
|
|
|
# SPDX-FileCopyrightText: 2022-2023 Alper Nebi Yasak <alpernebiyasak@gmail.com>
|
2023-10-05 02:23:07 +00:00
|
|
|
# SPDX-FileCopyrightText: 2023 Riku Viitanen <riku.viitanen@protonmail.com>
|
2021-05-18 12:56:12 +00:00
|
|
|
|
|
|
|
|
set -u -e
|
|
|
|
|
|
2023-08-23 17:56:31 +00:00
|
|
|
. "include/err.sh"
|
2023-09-27 20:46:20 +00:00
|
|
|
. "include/option.sh"
|
2023-08-23 17:56:31 +00:00
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
seavgabiosrom="elf/seabios/default/libgfxinit/vgabios.bin"
|
|
|
|
|
grub_background="background1280x800.png"
|
|
|
|
|
grubelf="elf/grub/grub.elf"
|
|
|
|
|
cfgsdir="config/coreboot"
|
2023-09-30 12:05:57 +00:00
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
# Disable all payloads by default.
|
|
|
|
|
# target.cfg files have to specifically enable [a] payload(s)
|
2023-12-22 13:05:32 +00:00
|
|
|
pv="payload_grub payload_grub_withseabios payload_seabios payload_memtest t"
|
2023-11-01 09:12:56 +00:00
|
|
|
pv="${pv} payload_seabios_withgrub payload_seabios_grubonly payload_uboot memtest_bin"
|
2023-12-27 15:18:21 +00:00
|
|
|
v="romdir cbrom initmode displaymode cbcfg targetdir tree keymaps"
|
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
|
|
|
v="${v} grub_timeout ubdir board grub_scan_disk uboot_config"
|
2023-10-05 02:23:07 +00:00
|
|
|
eval "$(setvars "n" ${pv})"
|
2023-10-19 22:36:56 +00:00
|
|
|
eval "$(setvars "" ${v} boards _displaymode _payload _keyboard all targets)"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
main()
|
2023-09-30 12:21:15 +00:00
|
|
|
{
|
2023-12-23 08:43:42 +00:00
|
|
|
check_project
|
|
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
while [ $# -gt 0 ]; do
|
|
|
|
|
case ${1} in
|
2023-11-08 06:31:04 +00:00
|
|
|
help)
|
|
|
|
|
usage
|
|
|
|
|
exit 0 ;;
|
|
|
|
|
list)
|
|
|
|
|
items config/coreboot || :
|
|
|
|
|
exit 0 ;;
|
2023-10-05 02:23:07 +00:00
|
|
|
-d) _displaymode="${2}" ;;
|
|
|
|
|
-p) _payload="${2}" ;;
|
|
|
|
|
-k) _keyboard="${2}" ;;
|
|
|
|
|
*)
|
2023-10-06 01:53:37 +00:00
|
|
|
[ "${1}" = "all" ] && all="y"
|
2023-10-05 02:23:07 +00:00
|
|
|
boards="${1} ${boards}"
|
|
|
|
|
shift && continue ;;
|
|
|
|
|
esac
|
|
|
|
|
shift 2
|
|
|
|
|
done
|
|
|
|
|
|
2023-10-19 22:36:56 +00:00
|
|
|
[ "${all}" != "y" ] || boards=$(items config/coreboot) || \
|
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 "Cannot generate list of boards for building"
|
2023-10-06 01:53:37 +00:00
|
|
|
|
2023-09-30 14:03:24 +00:00
|
|
|
for x in ${boards}; do
|
2023-12-23 16:16:26 +00:00
|
|
|
eval "$(setvars "n" ${pv}) $(setvars "" ${v})"
|
2023-10-07 20:04:45 +00:00
|
|
|
grub_background="background1280x800.png"
|
2023-10-05 02:23:07 +00:00
|
|
|
board="${x}"
|
2023-12-24 06:02:12 +00:00
|
|
|
configure_target
|
2024-01-01 17:57:35 +00:00
|
|
|
build_payloads
|
2024-01-01 18:00:53 +00:00
|
|
|
build_target_mainboard
|
2023-10-07 01:55:17 +00:00
|
|
|
[ -d "bin/${board}" ] || continue
|
2023-10-07 02:06:20 +00:00
|
|
|
targets="* bin/${board}\n${targets}"
|
2023-09-30 12:21:15 +00:00
|
|
|
done
|
2023-10-06 02:03:31 +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
|
|
|
[ -z "${targets}" ] && $err "No ROM images were compiled"
|
2023-10-07 02:06:20 +00:00
|
|
|
printf "\nROM images available in these directories:\n"
|
2023-12-23 16:16:26 +00:00
|
|
|
eval "printf \"${targets}\""
|
|
|
|
|
printf "^^ ROM images available in these directories.\n\n"
|
2023-10-10 05:04:47 +00:00
|
|
|
|
2023-12-24 09:04:36 +00:00
|
|
|
printf "DO NOT flash images from elf/ - please use bin/ instead.\n"
|
2023-09-30 12:21:15 +00:00
|
|
|
}
|
|
|
|
|
|
2023-12-24 06:02:12 +00:00
|
|
|
configure_target()
|
2023-10-05 02:23:07 +00:00
|
|
|
{
|
|
|
|
|
targetdir="${cfgsdir}/${board}"
|
|
|
|
|
[ -f "${targetdir}/target.cfg" ] || \
|
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 "Missing target.cfg for target: ${board}"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
# Override the above defaults using target.cfg
|
|
|
|
|
. "${targetdir}/target.cfg"
|
|
|
|
|
|
2023-12-22 13:05:32 +00:00
|
|
|
[ -z "${grub_scan_disk}" ] && grub_scan_disk="both"
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$grub_scan_disk" != "both" ] && [ "$grub_scan_disk" != "ata" ] \
|
2023-10-05 21:16:07 +00:00
|
|
|
&& [ "${grub_scan_disk}" != "ahci" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
grub_scan_disk="both"
|
|
|
|
|
|
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 "$tree" ] && $err "$board: tree not defined"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-12-22 13:05:32 +00:00
|
|
|
[ "${payload_memtest}" != "y" ] && payload_memtest="n"
|
|
|
|
|
[ "${payload_grub_withseabios}" = "y" ] && payload_grub="y"
|
2023-10-05 21:16:07 +00:00
|
|
|
[ "${payload_grub_withseabios}" = "y" ] && \
|
|
|
|
|
eval "$(setvars "y" payload_seabios payload_seabios_withgrub)"
|
2023-12-22 13:05:32 +00:00
|
|
|
[ "$payload_seabios_withgrub" = "y" ] && payload_seabios="y"
|
|
|
|
|
[ "$payload_seabios_grubonly" = "y" ] && payload_seabios="y"
|
|
|
|
|
[ "$payload_seabios_grubonly" = "y" ] && payload_seabios_withgrub="y"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
# The reverse logic must not be applied. If SeaBIOS-with-GRUB works,
|
|
|
|
|
# that doesn't mean GRUB-withSeaBIOS will. For example, the board
|
|
|
|
|
# might have a graphics card whose vga rom coreboot doesn't execute
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_grub" != "y" ] && [ "$payload_seabios" != "y" ] && \
|
2023-10-05 21:16:07 +00:00
|
|
|
[ "${payload_uboot}" != "y" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
for configfile in "${targetdir}/config/"*; do
|
|
|
|
|
[ -e "${configfile}" ] || continue
|
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 "target '${board}' defines no payload"
|
2023-10-05 02:23:07 +00:00
|
|
|
done
|
|
|
|
|
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_uboot" != "n" ] && [ "$payload_uboot" != "y" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
payload_uboot="n"
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_uboot" = "y" ] && [ -z "$uboot_config" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
uboot_config="default"
|
|
|
|
|
|
|
|
|
|
# Override all payload directives with cmdline args
|
2023-10-07 04:36:52 +00:00
|
|
|
[ -z "${_payload}" ] && return 0
|
2023-10-05 02:23:07 +00:00
|
|
|
printf "setting payload to: %s\n" "${_payload}"
|
|
|
|
|
eval "$(setvars "n" payload_grub payload_memtest payload_seabios \
|
2023-11-01 09:12:56 +00:00
|
|
|
payload_seabios_withgrub payload_uboot payload_grub_withseabios \
|
|
|
|
|
payload_seabios_grubonly)"
|
2023-10-05 02:23:07 +00:00
|
|
|
eval "payload_${_payload}=y"
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-01 17:57:35 +00:00
|
|
|
build_payloads()
|
2023-09-30 13:13:11 +00:00
|
|
|
{
|
2023-10-05 02:23:07 +00:00
|
|
|
romdir="bin/${board}"
|
2023-10-06 21:59:36 +00:00
|
|
|
cbdir="src/coreboot/${board}"
|
|
|
|
|
[ "${board}" = "${tree}" ] || cbdir="src/coreboot/${tree}"
|
2023-10-05 02:23:07 +00:00
|
|
|
cbfstool="cbutils/${tree}/cbfstool"
|
|
|
|
|
cbrom="${cbdir}/build/coreboot.rom"
|
2023-10-02 02:54:39 +00:00
|
|
|
|
2023-12-24 09:04:36 +00:00
|
|
|
[ -f "$cbfstool" ] || x_ ./update trees -b coreboot utils $tree
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-10-09 05:06:20 +00:00
|
|
|
memtest_bin="memtest86plus/build64/memtest.bin"
|
2023-10-06 21:59:36 +00:00
|
|
|
[ "${payload_memtest}" != "y" ] || [ -f "src/${memtest_bin}" ] || \
|
2023-10-19 23:17:30 +00:00
|
|
|
x_ ./update trees -b memtest86plus
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2024-01-01 17:52:23 +00:00
|
|
|
[ "$payload_seabios" = "y" ] && x_ ./update trees -b seabios
|
2024-01-01 22:11:29 +00:00
|
|
|
if [ "$payload_grub" = "y" ] || [ "$payload_seabios_withgrub" = "y" ] \
|
|
|
|
|
|| [ "$payload_seabios_grubonly" = "y" ]; then build_grub_payload
|
|
|
|
|
fi
|
|
|
|
|
[ "${payload_uboot}" = "y" ] && build_uboot_payload; return 0
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-01 17:47:43 +00:00
|
|
|
build_grub_payload()
|
2023-10-05 02:23:07 +00:00
|
|
|
{
|
2024-01-01 19:09:45 +00:00
|
|
|
x_ mkdir -p elf/grub
|
|
|
|
|
|
2024-01-01 22:04:58 +00:00
|
|
|
for keymapfile in config/grub/keymap/*.gkb; do
|
2023-10-05 02:23:07 +00:00
|
|
|
[ -f "${keymapfile}" ] || continue
|
|
|
|
|
|
2023-12-23 16:16:26 +00:00
|
|
|
keymaps="${keymaps} ${keymapfile}"
|
2023-09-30 13:13:11 +00:00
|
|
|
done
|
GRUB: insert only 1 keymap per board, in cbfs
There is no need to add multiple keymap files, because
GRUB can load keymaps from CBFS. The current build logic
is designed to avoid building multiple GRUB binaries,
which are expensive computationally because each one
would then have to be compressed for each board.
This patch provides the best of both worlds: less space
used in flash like in the old lbmk design (1 keymap per
board), but retaining the current build speeds and therefore
not re-introducing the slowness of lbmk's previous GRUB
build logic.
The grub.cfg file has been modified, accordingly. It now
only loads a keymap.gkb file from CBFS, by default. It does
this, only if that file exists; if not, GRUB already defaults
to US Qwerty layout anyway.
ALSO: compress all keymap gkb files with xz -6
GRUB automatically decompresses files when accessed.
This results in about 2KB of flash space saved in CBFS.
Here is real-world data, showing the increased flash space:
< fallback/payload 0x3eb80 simple elf 548821 none
< keymap.cfg 0xc4bc0 raw 16 none
< (empty) 0xc4c00 null 11633316 none
---
> fallback/payload 0x3eb80 simple elf 546787 none
> keymap.gkb 0xc43c0 raw 344 none
> (empty) 0xc4540 null 11635044 none
This was taken by diffing the cbfstool "print" output,
both before and after. The *after* result is with this change.
11633316. In this example, 1728 bytes have been saved. Therefore,
with compression taken into account, this patch saves about 1.7KB
of space in CBFS.
This change means that lbmk can now scale to support hundreds
of keymaps, without increasing the amount of flash space used,
in each given image. Since the keymap files are compressed in
lbmk.git, in advance, we spend no additional time on compression
at build time. The resulting change in build speed in negligible.
Adding your own keymap.gkb file was already possible, for changing
the keymap in libreboot images, if you didn't want to change the
memdisk (and thus re-compile grub.elf). Now, this is the default
behaviour, and the only way to do it. It's much more efficient.
The original keymap files can be restored, by running unxz.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-01-17 23:54:53 +00:00
|
|
|
[ -z "$_keyboard" ] || [ -f "$grubcfgsdir/keymap/$_keyboard.gkb" ] || \
|
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_grub_payload: $_keyboard layout not defined"
|
2024-01-17 19:32:54 +00:00
|
|
|
[ -n "$_keyboard" ] && keymaps="${grubcfgsdir}/keymap/${_keyboard}.gkb"
|
2024-01-01 21:57:27 +00:00
|
|
|
[ -f "$grubelf" ] && return 0
|
2024-01-01 17:47:43 +00:00
|
|
|
[ -f "src/grub/grub-mkstandalone" ] || x_ ./update trees -b grub
|
2023-12-30 13:08:29 +00:00
|
|
|
|
|
|
|
|
./src/grub/grub-mkstandalone \
|
|
|
|
|
--grub-mkimage="src/grub/grub-mkimage" \
|
|
|
|
|
-O i386-coreboot \
|
|
|
|
|
-o "elf/grub/grub.elf" \
|
|
|
|
|
-d "src/grub/grub-core/" \
|
|
|
|
|
--fonts= --themes= --locales= \
|
|
|
|
|
--modules="${grub_modules}" \
|
|
|
|
|
--install-modules="${grub_install_modules}" \
|
|
|
|
|
"/boot/grub/grub.cfg=${grubcfgsdir}/config/grub_memdisk.cfg" \
|
|
|
|
|
"/boot/grub/grub_default.cfg=${grubcfgsdir}/config/grub.cfg" || \
|
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 "could not generate grub.elf"
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-01 17:57:35 +00:00
|
|
|
build_uboot_payload()
|
2023-10-05 02:23:07 +00:00
|
|
|
{
|
2023-10-19 23:17:30 +00:00
|
|
|
x_ ./update trees -b u-boot ${board}
|
2023-10-05 02:23:07 +00:00
|
|
|
ubdir="elf/u-boot/${board}/${uboot_config}"
|
|
|
|
|
ubootelf="${ubdir}/u-boot.elf"
|
2023-10-13 19:41:15 +00:00
|
|
|
[ ! -f "${ubootelf}" ] && [ -f "${ubdir}/u-boot" ] && \
|
|
|
|
|
ubootelf="${ubdir}/u-boot"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ -f "${ubootelf}" ] && return 0
|
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 find u-boot build for board, $board";
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-01 18:00:53 +00:00
|
|
|
build_target_mainboard()
|
2023-10-05 02:23:07 +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 -f "${romdir}/"* || $err "!prepare, rm files, ${romdir}"
|
2023-12-23 16:16:26 +00:00
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
for x in "normal" "vgarom" "libgfxinit"; do
|
|
|
|
|
initmode="${x}"
|
|
|
|
|
hmode="vesafb"
|
|
|
|
|
[ "${initmode}" = "vgarom" ] || hmode="corebootfb"
|
|
|
|
|
modes="${hmode} txtmode"
|
2023-10-07 04:36:52 +00:00
|
|
|
[ -z "${_displaymode}" ] || modes="${_displaymode}"
|
2023-10-05 02:23:07 +00:00
|
|
|
for y in ${modes}; do
|
|
|
|
|
displaymode="${y}"
|
|
|
|
|
[ "${initmode}" = "normal" ] && \
|
|
|
|
|
[ "$displaymode" != "txtmode" ] && continue
|
|
|
|
|
cbcfg="${targetdir}/config/${initmode}_${displaymode}"
|
|
|
|
|
[ "${initmode}" = "normal" ] && cbcfg="${cbcfg%_*}"
|
|
|
|
|
build_roms "${cbcfg}"
|
|
|
|
|
done
|
|
|
|
|
done
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# Main ROM building function. This calls all other functions below
|
|
|
|
|
build_roms()
|
|
|
|
|
{
|
|
|
|
|
cbcfg="${1}"
|
2023-11-08 06:31:04 +00:00
|
|
|
if [ ! -f "${cbcfg}" ]; then
|
2023-10-05 02:23:07 +00:00
|
|
|
printf "'%s' does not exist. Skipping build for %s %s %s\n" \
|
2023-12-22 13:05:32 +00:00
|
|
|
"$cbcfg" "$board" "$displaymode" "$initmode" 1>&2
|
2023-11-08 06:31:04 +00:00
|
|
|
return 0
|
|
|
|
|
fi
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-10-19 23:17:30 +00:00
|
|
|
x_ ./update trees -b coreboot ${board}
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-12-22 13:05:32 +00:00
|
|
|
_cbrom="elf/coreboot_nopayload_DO_NOT_FLASH"
|
|
|
|
|
_cbrom="${_cbrom}/${board}/${initmode}_${displaymode}"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ "${initmode}" = "normal" ] && \
|
2023-12-16 07:56:26 +00:00
|
|
|
_cbrom="${_cbrom%"_${displaymode}"}"
|
2023-10-05 02:23:07 +00:00
|
|
|
_cbrom="${_cbrom}/coreboot.rom"
|
|
|
|
|
cbrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)"
|
|
|
|
|
x_ cp "${_cbrom}" "${cbrom}"
|
|
|
|
|
|
|
|
|
|
[ "${payload_memtest}" != "y" ] || \
|
|
|
|
|
x_ "${cbfstool}" "${cbrom}" add-payload \
|
2023-10-06 21:59:36 +00:00
|
|
|
-f "src/${memtest_bin}" -n img/memtest -c lzma
|
2023-12-23 16:16:26 +00:00
|
|
|
[ "${payload_seabios}" = "y" ] && build_seabios_roms
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_grub" != "y" ] || x_ build_grub_roms "$cbrom" "grub"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ "${payload_uboot}" = "y" ] || return 0
|
2023-10-23 23:14:01 +00:00
|
|
|
x_ cp "${_cbrom}" "${cbrom}"
|
2023-10-05 02:23:07 +00:00
|
|
|
build_uboot_roms
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
build_seabios_roms()
|
|
|
|
|
{
|
|
|
|
|
if [ "${payload_seabios_withgrub}" = "y" ]; then
|
2023-12-22 13:05:32 +00:00
|
|
|
t=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
|
x_ cp "${cbrom}" "${t}"
|
|
|
|
|
x_ build_grub_roms "${t}" "seabios_withgrub"
|
2023-10-05 02:23:07 +00:00
|
|
|
else
|
|
|
|
|
t=$(mkSeabiosRom "${cbrom}" "fallback/payload") || \
|
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_seabios_roms: cannot build tmprom"
|
2023-10-05 02:23:07 +00:00
|
|
|
newrom="${romdir}/seabios_${board}_${initmode}_${displaymode}"
|
|
|
|
|
[ "${initmode}" = "normal" ] && newrom="${romdir}/seabios" \
|
|
|
|
|
&& newrom="${newrom}_${board}_${initmode}"
|
|
|
|
|
x_ moverom "${t}" "${newrom}.rom"
|
|
|
|
|
fi
|
2023-12-22 13:05:32 +00:00
|
|
|
x_ rm -f "${t}"
|
2023-09-30 13:13:11 +00:00
|
|
|
}
|
|
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
# Make separate ROM images with GRUB payload, for each supported keymap
|
|
|
|
|
build_grub_roms()
|
2023-09-30 12:05:57 +00:00
|
|
|
{
|
2023-10-05 02:23:07 +00:00
|
|
|
tmprom="${1}"
|
|
|
|
|
payload1="${2}" # allow values: grub, seabios, seabios_withgrub
|
|
|
|
|
|
2023-10-05 21:16:07 +00:00
|
|
|
grub_cbfs="fallback/payload"
|
2023-12-23 12:16:14 +00:00
|
|
|
if [ "$payload1" = "grub" ] && [ "$payload_grub_withseabios" = "y" ]
|
|
|
|
|
then
|
|
|
|
|
_tmpmvrom=$(mkSeabiosRom "$tmprom" "seabios.elf") || \
|
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_grub_roms 1 $board: can't build tmprom"
|
2023-12-23 12:16:14 +00:00
|
|
|
x_ mv "$_tmpmvrom" "$tmprom"
|
|
|
|
|
elif [ "$payload1" != "grub" ] && [ "$payload_seabios_withgrub" = "y" ]
|
|
|
|
|
then
|
|
|
|
|
grub_cbfs="img/grub2"
|
|
|
|
|
_tmpmvrom=$(mkSeabiosRom "$tmprom" fallback/payload) || \
|
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_grub_roms 2 $board: can't build tmprom"
|
2023-12-23 12:16:14 +00:00
|
|
|
x_ mv "$_tmpmvrom" "$tmprom"
|
|
|
|
|
fi
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
# we only need insert grub.elf once, for each coreboot config:
|
|
|
|
|
x_ "${cbfstool}" "${tmprom}" add-payload -f "${grubelf}" \
|
|
|
|
|
-n ${grub_cbfs} -c lzma
|
|
|
|
|
|
|
|
|
|
# we only need insert background.png once, for each coreboot config:
|
|
|
|
|
if [ "${displaymode}" = "vesafb" ] || \
|
|
|
|
|
[ "${displaymode}" = "corebootfb" ]; then
|
|
|
|
|
backgroundfile="config/grub/background/${grub_background}"
|
2023-10-22 11:31:55 +00:00
|
|
|
"${cbfstool}" "${tmprom}" add -f ${backgroundfile} \
|
2023-12-22 13:05:32 +00:00
|
|
|
-n background.png -t raw || \
|
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 background, ${backgroundfile}"
|
2023-10-05 02:23:07 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
tmpcfg=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
2023-12-22 13:05:32 +00:00
|
|
|
printf "set grub_scan_disk=\"%s\"\n" "$grub_scan_disk" >"$tmpcfg" \
|
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 "set grub_scandisk, $grub_scan_disk, $tmpcfg"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ "${grub_scan_disk}" = "both" ] || \
|
2023-12-22 13:05:32 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add -f "$tmpcfg" -n scan.cfg -t raw
|
2023-10-22 11:31:55 +00:00
|
|
|
printf "set timeout=%s\n" "${grub_timeout}" > "${tmpcfg}" || \
|
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 "set timeout, ${grub_timeout}, ${tmpcfg}"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ -z "${grub_timeout}" ] || x_ "${cbfstool}" "${tmprom}" add \
|
|
|
|
|
-f "${tmpcfg}" -n timeout.cfg -t raw
|
|
|
|
|
x_ rm -f "${tmpcfg}"
|
|
|
|
|
|
|
|
|
|
for keymapfile in ${keymaps}; do
|
|
|
|
|
[ -f "${keymapfile}" ] || continue
|
|
|
|
|
keymap="${keymapfile##*/}"
|
|
|
|
|
keymap="${keymap%.gkb}"
|
GRUB: insert only 1 keymap per board, in cbfs
There is no need to add multiple keymap files, because
GRUB can load keymaps from CBFS. The current build logic
is designed to avoid building multiple GRUB binaries,
which are expensive computationally because each one
would then have to be compressed for each board.
This patch provides the best of both worlds: less space
used in flash like in the old lbmk design (1 keymap per
board), but retaining the current build speeds and therefore
not re-introducing the slowness of lbmk's previous GRUB
build logic.
The grub.cfg file has been modified, accordingly. It now
only loads a keymap.gkb file from CBFS, by default. It does
this, only if that file exists; if not, GRUB already defaults
to US Qwerty layout anyway.
ALSO: compress all keymap gkb files with xz -6
GRUB automatically decompresses files when accessed.
This results in about 2KB of flash space saved in CBFS.
Here is real-world data, showing the increased flash space:
< fallback/payload 0x3eb80 simple elf 548821 none
< keymap.cfg 0xc4bc0 raw 16 none
< (empty) 0xc4c00 null 11633316 none
---
> fallback/payload 0x3eb80 simple elf 546787 none
> keymap.gkb 0xc43c0 raw 344 none
> (empty) 0xc4540 null 11635044 none
This was taken by diffing the cbfstool "print" output,
both before and after. The *after* result is with this change.
11633316. In this example, 1728 bytes have been saved. Therefore,
with compression taken into account, this patch saves about 1.7KB
of space in CBFS.
This change means that lbmk can now scale to support hundreds
of keymaps, without increasing the amount of flash space used,
in each given image. Since the keymap files are compressed in
lbmk.git, in advance, we spend no additional time on compression
at build time. The resulting change in build speed in negligible.
Adding your own keymap.gkb file was already possible, for changing
the keymap in libreboot images, if you didn't want to change the
memdisk (and thus re-compile grub.elf). Now, this is the default
behaviour, and the only way to do it. It's much more efficient.
The original keymap files can be restored, by running unxz.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-01-17 23:54:53 +00:00
|
|
|
|
|
|
|
|
tmpgrubrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)"
|
|
|
|
|
x_ cp "${tmprom}" "${tmpgrubrom}"
|
|
|
|
|
x_ "$cbfstool" "$tmpgrubrom" add -f "$keymapfile" \
|
|
|
|
|
-n keymap.gkb -t raw
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
newrom="${romdir}/${payload1}_${board}_${initmode}_"
|
|
|
|
|
newrom="${newrom}${displaymode}_${keymap}.rom"
|
|
|
|
|
[ "${initmode}" = "normal" ] && \
|
|
|
|
|
newrom="${romdir}/${payload1}_${board}_" && \
|
|
|
|
|
newrom="${newrom}${initmode}_${keymap}.rom"
|
|
|
|
|
x_ moverom "${tmpgrubrom}" "${newrom}"
|
2023-11-01 09:12:56 +00:00
|
|
|
[ "${payload_seabios_grubonly}" = "y" ] && \
|
|
|
|
|
mkSeabiosGrubonlyRom "${tmpgrubrom}" "${newrom}"
|
2023-10-05 02:23:07 +00:00
|
|
|
x_ rm -f "${tmpgrubrom}"
|
|
|
|
|
done
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# make a rom in /tmp/ and then print the path of that ROM
|
|
|
|
|
mkSeabiosRom() {
|
|
|
|
|
_cbrom="${1}" # rom to insert seabios in. will not be touched
|
|
|
|
|
# (a tmpfile will be made instead)
|
|
|
|
|
_seabios_cbfs_path="${2}" # e.g. fallback/payload
|
|
|
|
|
_seabioself="elf/seabios/default/${initmode}/bios.bin.elf"
|
|
|
|
|
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
|
|
|
|
|
|
x_ cp "${_cbrom}" "${tmprom}"
|
2023-12-24 09:04:36 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add-payload -f "$_seabioself" \
|
2023-12-16 07:56:26 +00:00
|
|
|
-n "${_seabios_cbfs_path}" -c lzma
|
2023-12-22 13:05:32 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add-int -i 3000 -n etc/ps2-keyboard-spinup
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-12-24 09:04:36 +00:00
|
|
|
z="2"; [ "$initmode" = "vgarom" ] && z="0"
|
|
|
|
|
x_ "$cbfstool" "$tmprom" add-int -i $z -n etc/pci-optionrom-exec
|
|
|
|
|
x_ "$cbfstool" "$tmprom" add-int -i 0 -n etc/optionroms-checksum
|
|
|
|
|
[ "$initmode" != "libgfxinit" ] || \
|
|
|
|
|
x_ "$cbfstool" "$tmprom" add -f "$seavgabiosrom" \
|
2023-10-05 02:23:07 +00:00
|
|
|
-n vgaroms/seavgabios.bin -t raw
|
|
|
|
|
|
|
|
|
|
printf "%s\n" "${tmprom}"
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-01 09:12:56 +00:00
|
|
|
# SeaGRUB configuration
|
|
|
|
|
mkSeabiosGrubonlyRom()
|
|
|
|
|
{
|
|
|
|
|
_grubrom="${1}"
|
|
|
|
|
_newrom="${2}"
|
|
|
|
|
|
|
|
|
|
tmpbootorder=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
|
|
|
|
|
|
# only load grub, by inserting a custom bootorder file
|
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
|
|
|
printf "/rom@img/grub2\n" > "$tmpbootorder" || $err "printf bootorder"
|
2023-11-01 09:12:56 +00:00
|
|
|
x_ "${cbfstool}" "${_grubrom}" \
|
|
|
|
|
add -f "${tmpbootorder}" -n bootorder -t raw
|
|
|
|
|
x_ rm -f "${tmpbootorder}"
|
|
|
|
|
|
|
|
|
|
x_ "${cbfstool}" "${_grubrom}" add-int -i 0 -n etc/show-boot-menu
|
|
|
|
|
x_ moverom "${_grubrom}" "${_newrom%.rom}_grubonly.rom"
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
build_uboot_roms()
|
|
|
|
|
{
|
2023-12-23 12:16:14 +00:00
|
|
|
tmprom=$(mkUbootRom "${cbrom}" "fallback/payload") || \
|
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_uboot_roms $board: could not create tmprom"
|
2023-10-05 02:23:07 +00:00
|
|
|
newrom="${romdir}/uboot_payload_${board}_${initmode}_${displaymode}.rom"
|
|
|
|
|
x_ moverom "${tmprom}" "${newrom}"
|
|
|
|
|
x_ rm -f "${tmprom}"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# make a rom in /tmp/ and then print the path of that ROM
|
|
|
|
|
mkUbootRom() {
|
2023-10-05 21:16:07 +00:00
|
|
|
_cbrom="${1}"
|
|
|
|
|
_uboot_cbfs_path="${2}"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
_ubdir="elf/u-boot/${board}/${uboot_config}"
|
|
|
|
|
_ubootelf="${_ubdir}/u-boot.elf"
|
2023-10-13 19:41:15 +00:00
|
|
|
[ -f "${_ubootelf}" ] || _ubootelf="${_ubdir}/u-boot"
|
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
|
|
|
[ -f "$_ubootelf" ] || $err "mkUbootRom: $board: cant find u-boot"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
|
|
|
|
|
|
x_ cp "${_cbrom}" "${tmprom}"
|
2023-12-24 09:04:36 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add-payload -f "$_ubootelf" \
|
2023-12-16 07:56:26 +00:00
|
|
|
-n "${_uboot_cbfs_path}" -c lzma
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
printf "%s\n" "${tmprom}"
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
moverom()
|
|
|
|
|
{
|
|
|
|
|
printf "Creating target image: %s\n" "$2"
|
2023-10-05 02:23:07 +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
|
|
|
x_ mkdir -p "${2%/*}"
|
|
|
|
|
x_ cp "$1" "$2"
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
usage()
|
|
|
|
|
{
|
|
|
|
|
cat <<- EOF
|
2023-10-19 23:17:30 +00:00
|
|
|
USAGE: ./build roms targetname
|
|
|
|
|
To build *all* boards, do this: ./build roms all
|
|
|
|
|
To list *all* boards, do this: ./build roms list
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
Optional Flags:
|
|
|
|
|
-d: displaymode
|
|
|
|
|
-p: payload
|
|
|
|
|
-k: keyboard layout
|
|
|
|
|
|
|
|
|
|
Example commands:
|
2023-10-10 22:48:03 +00:00
|
|
|
|
2023-10-19 23:17:30 +00:00
|
|
|
./build roms x60
|
|
|
|
|
./build roms x200_8mb x60
|
|
|
|
|
./build roms x60 -p grub -d corebootfb -k usqwerty
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
possible values for 'target':
|
2023-10-19 22:36:56 +00:00
|
|
|
$(items "config/coreboot")
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
Refer to the ${projectname} documentation for more information.
|
|
|
|
|
EOF
|
2023-09-30 12:05:57 +00:00
|
|
|
}
|
|
|
|
|
|
2023-05-10 04:39:11 +00:00
|
|
|
main $@
|