libreboot
/
lbmk
1
0
Fork 0
Code Packages Projects Releases Activity

Greatly simplify error handling in shell scripts 

Instead of having detailed error messages, run most
commands through a function that calls err() under
fault conditions.

Where detail is still required, err() is still called
manually. Where it isn't, the error message is simply
whatever command was executed to cause the error.

This results in a massive sloccount reduction for lbmk;
specifically, 178 sloc reduction, or a 8.1% reduction.
The total sloccount is now 2022, for shell scripts.

Signed-off-by: Leah Rowe <leah@libreboot.org>
btrfsvols
Leah Rowe 2023-10-01 06:33:43 +01:00
parent 5f914a4d00
commit 8c03b886c4
19 changed files with 278 additions and 461 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/blobutil.sh
View File

@ -52,14 +52,14 @@ fetch()
_dest="${5##*../}"
_dl="${blobdir}/cache/${dlsum}"
mkdir -p "${_dl%/*}" || err "fetch: !mkdir ${_dl%/*}"
x_ mkdir -p "${_dl%/*}"
dl_fail="y"
vendor_checksum "${dlsum}" "${_dl}" && dl_fail="n"
for url in "${dl}" "${dl_bkup}"; do
[ "${dl_fail}" = "n" ] && break
[ -z "${url}" ] && continue
rm -f "${_dl}" || err "fetch: !rm -f ${_dl}"
x_ rm -f "${_dl}"
curl --location --retry 3 -A "${_ua}" "${url}" -o "${_dl}" || \
wget --tries 3 -U "${_ua}" "${url}" -O "${_dl}" || \
continue
@ -68,7 +68,7 @@ fetch()
[ "${dl_fail}" = "y" ] && \
err "fetch ${dlsum}: matched file unavailable"
rm -Rf "${_dl}_extracted" || err "!rm ${_dl}_extracted"
x_ rm -Rf "${_dl}_extracted"
mkdirs "${_dest}" "extract_${dl_type}" || return 0
eval "extract_${dl_type}"
@ -89,9 +89,9 @@ mkdirs()
{
[ -f "${1}" ] && \
printf "mkdirs ${1} ${2}: already downloaded\n" 1>&2 && return 1
mkdir -p "${1%/*}" || err "mkdirs ${1} ${2}: !mkdir ${1%/*}"
rm -Rf "${appdir}" || err "mkdirs ${1} ${2}: can't remove ${appdir}"
mkdir -p "${appdir}/" || err "mkdirs ${1} ${2}: !mkdir ${appdir}"
x_ mkdir -p "${1%/*}"
x_ rm -Rf "${appdir}"
x_ mkdir -p "${appdir}/"
extract_archive "${_dl}" "${appdir}" || \
[ "${2}" = "extract_e6400vga" ] || err "mkdirs ${1} ${2}: !extract"
}

9
include/err.sh
View File

@ -1,6 +1,15 @@
# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2022, 2023 Leah Rowe <leah@libreboot.org>
xfail=""
x_() {
[ $# -lt 1 ] || ${@} || err "${@}"
}
xx_() {
[ $# -lt 1 ] || ${@} || fail "${@}"
}
setvars()
{
_setvars=""

18
include/mrc.sh
View File

@ -14,15 +14,14 @@ extract_mrc()
_file="${_file%.zip}"
(
cd "${appdir}" || err "extract_mrc: !cd ${appdir}"
x_ cd "${appdir}"
extract_partition ROOT-A "${_file}" root-a.ext2
extract_shellball root-a.ext2 chromeos-firmwareupdate-${MRC_board}
extract_coreboot chromeos-firmwareupdate-${MRC_board}
)
"${cbfstool}" "${appdir}/"coreboot-*.bin extract -n mrc.bin \
-f "${_dest}" -r RO_SECTION || \
err "extract_mrc: could not fetch mrc.bin"
x_ "${cbfstool}" "${appdir}/"coreboot-*.bin extract -n mrc.bin \
-f "${_dest}" -r RO_SECTION
}
extract_partition()
@ -39,9 +38,8 @@ extract_partition()
START=$(( $( echo ${ROOTP} | cut -f2 -d\ | tr -d "B" ) ))
SIZE=$(( $( echo ${ROOTP} | cut -f4 -d\ | tr -d "B" ) ))
dd if="${FILE}" of="${ROOTFS}" bs=${_bs} skip=$(( ${START} / ${_bs} )) \
count=$(( ${SIZE} / ${_bs} )) || \
err "extract_partition: can't extract root file system"
x_ dd if="${FILE}" of="${ROOTFS}" bs=${_bs} \
skip=$(( ${START} / ${_bs} )) count=$(( ${SIZE} / ${_bs} ))
}
extract_shellball()
@ -62,8 +60,7 @@ extract_coreboot()
printf "Extracting coreboot image\n"
[ -f "${_shellball}" ] || \
err "extract_coreboot: shellball missing in google cros image"
sh "${_shellball}" --unpack "${_unpacked}" || \
err "extract_coreboot: shellball exits with non-zero status"
x_ sh "${_shellball}" --unpack "${_unpacked}"
# TODO: audit the f* out of that shellball, for each mrc version.
# it has to be updated for each mrc update. we should ideally
@ -75,6 +72,5 @@ extract_coreboot()
_version=$( cat "${_unpacked}/VERSION" | grep BIOS\ version: | \
cut -f2 -d: | tr -d \ )
cp "${_unpacked}/bios.bin" "coreboot-${_version}.bin" || \
err "extract_coreboot: cannot copy google cros rom"
x_ cp "${_unpacked}/bios.bin" "coreboot-${_version}.bin"
}

3
include/option.sh
View File

@ -38,6 +38,5 @@ scan_config()
done << EOF
$(eval "awk '${awkstr}' \"${revfile}\"")
EOF
rm -f "${revfile}" || \
"${_fail}" "scan_config: Cannot remove tmpfile"
rm -f "${revfile}" || "${_fail}" "scan_config: Cannot remove tmpfile"
}

13
lbmk
View File

@ -21,9 +21,7 @@ option=""
main()
{
id -u 1>/dev/null 2>/dev/null || \
fail "cannot ascertain user id"
xx_ id -u 1>/dev/null 2>/dev/null
initialise_command $@
shift 2
@ -40,8 +38,7 @@ initialise_command()
[ $# -lt 1 ] && fail "Too few arguments. Try: ${0} help"
mode="${1}"
[ "${mode}" != "dependencies" ] || \
install_packages $@ || fail "Can't install dependencies"
[ "${mode}" != "dependencies" ] || xx_ install_packages $@
[ "$(id -u)" != "0" ] || \
fail "running this command as root is not permitted"
@ -68,8 +65,7 @@ install_packages()
aur_notice=""
. "config/dependencies/${2}"
${pkg_add} ${pkglist} || \
fail "install_packages: Error installing dependencies"
xx_ ${pkg_add} ${pkglist}
[ "${aur_notice}" = "" ] || \
printf "You must install AUR packages: %s\n" "${aur_notice}" 1>&2
@ -79,8 +75,7 @@ install_packages()
execute_command()
{
if [ "${option}" = "list" ]; then
listitems "${buildpath}/${mode}" || \
fail "execute_command: cannot list command options"
xx_ listitems "${buildpath}/${mode}"
lbmk_exit 0
fi
[ -f "${buildpath}/${mode}/${option}" ] || \

3
script/build/boot/roms
View File

@ -41,8 +41,7 @@ build_bootroms()
{
opts="${_displaymode} ${_payload} ${_keyboard}"
for x in ${boards}; do
./build boot roms_helper ${opts} ${x} || \
err "handle_targets ${opts} ${x}: build error"
x_ ./build boot roms_helper ${opts} ${x}
[ -d "bin/${x}" ] && targets="${x} ${targets}"
done
}

129
script/build/boot/roms_helper
View File

@ -110,16 +110,15 @@ build_dependencies()
cbfstool="cbutils/${tree}/cbfstool"
cbrom="${cbdir}/build/coreboot.rom"
./build coreboot utils ${tree} || err "cannot build cbutils/${tree}"
x_ ./build coreboot utils ${tree}
build_dependency_seabios
memtest_bin="memtest86plus/build${arch#*_}/memtest.bin"
[ "${payload_memtest}" != "y" ] || [ -f "${memtest_bin}" ] || \
./handle make file -b ${memtest_bin%/*} || \
err "cannot build memtest86+"
x_ ./handle make file -b ${memtest_bin%/*}
rm -f "${romdir}"/* || err "cannot: rm -f \"${romdir}\"/*"
x_ rm -f "${romdir}/"*
build_dependency_grub
build_dependency_uboot
@ -133,8 +132,7 @@ build_dependency_seabios()
|| [ ! -f elf/seabios/default/libgfxinit/bios.bin.elf ] \
|| [ ! -f elf/seabios/default/vgarom/bios.bin.elf ] \
|| [ ! -f elf/seabios/default/normal/bios.bin.elf ]; then
./handle make config -b seabios || \
err "cannot build seabios"
x_ ./handle make config -b seabios
fi
}
@ -155,16 +153,14 @@ build_dependency_grub()
rebuild_grub="y" && break
done
[ "${rebuild_grub}" = "y" ] || return 0
./build grub payload || \
err "build_dependency_grub: cannot build grub payload"
x_ ./build grub payload
}
build_dependency_uboot()
{
[ "${payload_uboot}" = "y" ] || return 0
./handle make config -b u-boot ${board} || \
err "cannot build u-boot target: ${board}"
x_ ./handle make config -b u-boot ${board}
ubdir="elf/u-boot/${board}/${uboot_config}"
ubootelf="${ubdir}/u-boot.elf"
[ ! -f "${ubootelf}" ] && [ -f "${ubdir}/u-boot.bin" ] && \
@ -201,26 +197,22 @@ build_roms()
"${cbcfg}" "${board}" "${displaymode}" "${initmode}" \
1>&2 && return 0
./handle make config -b coreboot ${board} || \
err "build_roms: cannot build coreboot for target: ${board}"
x_ ./handle make config -b coreboot ${board}
_cbrom="elf/coreboot/${board}/${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && \
_cbrom="${_cbrom%_${displaymode}}"
_cbrom="${_cbrom}/coreboot.rom"
cbrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)"
cp "${_cbrom}" "${cbrom}" || \
err "build_roms: cannot copy rom"
x_ cp "${_cbrom}" "${cbrom}"
[ "${payload_memtest}" != "y" ] || \
"${cbfstool}" "${cbrom}" add-payload \
-f "${memtest_bin}" -n img/memtest -c lzma || \
err "build_roms: cannot add img/memtest to coreboot rom"
x_ "${cbfstool}" "${cbrom}" add-payload \
-f "${memtest_bin}" -n img/memtest -c lzma
[ "${payload_seabios}" = "y" ] && \
build_seabios_roms
[ "${payload_grub}" != "y" ] || \
build_grub_roms "${cbrom}" "grub" || \
err "build_roms: build_grub_roms failed"
x_ build_grub_roms "${cbrom}" "grub"
[ "${payload_uboot}" = "y" ] || return 0
build_uboot_roms
}
@ -229,68 +221,57 @@ build_seabios_roms()
{
if [ "${payload_seabios_withgrub}" = "y" ]; then
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${cbrom}" "${tmprom}" || \
err "build_seabios_roms: cannot copy to tmprom"
build_grub_roms "${tmprom}" "seabios_withgrub" || \
err "build_roms: cannot build grub roms, seabios w/grub"
rm -f "${tmprom}" || err "build_roms: can't remove tmprom"
x_ cp "${cbrom}" "${tmprom}"
x_ build_grub_roms "${tmprom}" "seabios_withgrub"
x_ rm -f "${tmprom}"
else
t=$(mkSeabiosRom "${cbrom}" "fallback/payload") || \
err "build_seabios_roms: cannot build tmprom"
newrom="${romdir}/seabios_${board}_${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && newrom="${romdir}/seabios" \
&& newrom="${newrom}_${board}_${initmode}"
moverom "${t}" "${newrom}.rom" || \
err "build_roms: cannot copy rom"
rm -f "${t}" || err "cannot rm ${t}"
x_ moverom "${t}" "${newrom}.rom"
x_ rm -f "${t}"
fi
}
# Make separate ROM images with GRUB payload, for each supported keymap
build_grub_roms() {
build_grub_roms()
{
tmprom="${1}"
payload1="${2}" # allow values: grub, seabios, seabios_withgrub
grub_cbfs="fallback/payload"
if [ "${payload_grub_withseabios}" = "y" ] && \
[ "${payload1}" = "grub" ]; then
mv "$(mkSeabiosRom "${tmprom}" "seabios.elf")" "${tmprom}" || \
err "build_grub_roms: cannot move tmp rom (seabios.elf)"
x_ mv "$(mkSeabiosRom "${tmprom}" "seabios.elf")" "${tmprom}"
elif [ "${payload_seabios_withgrub}" = "y" ] && \
[ "${payload1}" != "grub" ]; then
mv "$(mkSeabiosRom "${tmprom}" fallback/payload)" "${tmprom}" \
|| err "build_grub_roms: cannot move SeaBIOS ROM to tmprom"
x_ mv "$(mkSeabiosRom "${tmprom}" fallback/payload)" "${tmprom}"
grub_cbfs="img/grub2"
fi
# we only need insert grub.elf once, for each coreboot config:
"${cbfstool}" "${tmprom}" add-payload -f "${grubelf}" -n ${grub_cbfs} \
-c lzma || err "build_grub_roms: cannot add grub payload to tmprom"
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}"
"${cbfstool}" "${tmprom}" add -f ${backgroundfile} \
-n background.png -t raw || \
err "build_grub_roms: cannot add background.png to tmprom"
x_ "${cbfstool}" "${tmprom}" add -f ${backgroundfile} \
-n background.png -t raw
fi
tmpcfg=$(mktemp -t coreboot_rom.XXXXXXXXXX) ||
err "build_grub_roms: cannot create temporary scan.cfg"
printf "set grub_scan_disk=\"%s\"\n" "${grub_scan_disk}" > \
"${tmpcfg}" || err "build_grub_roms: cannot create scan.cfg"
x_ printf "set grub_scan_disk=\"%s\"\n" "${grub_scan_disk}" >"${tmpcfg}"
[ "${grub_scan_disk}" = "both" ] || \
"${cbfstool}" "${tmprom}" add -f "${tmpcfg}" -n scan.cfg -t \
raw || err "build_grub_roms: can't insert scan.cfg"
printf "set timeout=%s\n" "${grub_timeout}" > "${tmpcfg}" || \
err "build_grub_roms: can't create timeout.cfg"
[ -z "${grub_timeout}" ] || \
"${cbfstool}" "${tmprom}" add -f "${tmpcfg}" -n timeout.cfg \
-t raw || err "build_grub_roms: can't insert timeout.cfg"
rm -f "${tmpcfg}" || err "build_grub_roms: can't delete tmpcfg"
x_ "${cbfstool}" "${tmprom}" add -f "${tmpcfg}" -n scan.cfg -t raw
x_ printf "set timeout=%s\n" "${grub_timeout}" > "${tmpcfg}"
[ -z "${grub_timeout}" ] || x_ "${cbfstool}" "${tmprom}" add \
-f "${tmpcfg}" -n timeout.cfg -t raw
x_ rm -f "${tmpcfg}"
keymaps=""
for kmapfile in "${kmapdir}"/*; do
@ -309,9 +290,8 @@ build_grub_roms() {
[ "${initmode}" = "normal" ] && \
newrom="${romdir}/${payload1}_${board}_" && \
newrom="${newrom}${initmode}_${keymap}.rom"
moverom "${tmpgrubrom}" "${newrom}" || \
err "build_grub_roms, moverom"
rm -f "${tmpgrubrom}" || err "rm tmpgrubrom, build_grub_roms"
x_ moverom "${tmpgrubrom}" "${newrom}"
x_ rm -f "${tmpgrubrom}"
done
}
@ -324,9 +304,8 @@ mkGrubRom() {
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX) || \
err "mkGrubRom: cannot create tmprom"
cp "${_cbrom}" "${tmprom}" || err "mkGrubRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add -f "${keymapcfg}" -n keymap.cfg -t raw \
|| err "mkGrubRom: cannot add keymap.cfg to tmprom"
x_ cp "${_cbrom}" "${tmprom}"
x_ "${cbfstool}" "${tmprom}" add -f "${keymapcfg}" -n keymap.cfg -t raw
printf "%s\n" "${tmprom}"
}
@ -339,23 +318,17 @@ mkSeabiosRom() {
_seabioself="elf/seabios/default/${initmode}/bios.bin.elf"
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${_cbrom}" "${tmprom}" || \
err "mkSeabiosRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add-payload -f "${_seabioself}" \
-n ${_seabios_cbfs_path} -c lzma || \
err "mkSeabiosRom: can't add payload, ${_seabioself}, to rom"
"${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup \
|| err "mkSeabiosRom: cbfs add-int etc/ps2-keyboard-spinup 3000"
x_ cp "${_cbrom}" "${tmprom}"
x_ "${cbfstool}" "${tmprom}" add-payload -f "${_seabioself}" \
-n ${_seabios_cbfs_path} -c lzma
x_ "${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup
z="2"; [ "${initmode}" = "vgarom" ] && z="0"
"${cbfstool}" "${tmprom}" add-int -i $z -n etc/pci-optionrom-exec || \
err "mkSeabiosRom: cbfs add-int etc/pci-optionrom-exec 0"
"${cbfstool}" "${tmprom}" add-int -i 0 -n etc/optionroms-checksum || \
err "mkSeabiosRom: cbfs add-int etc/optionroms-checksum 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" ] || \
"${cbfstool}" "${tmprom}" add -f "${seavgabiosrom}" \
-n vgaroms/seavgabios.bin -t raw || \
err "mkSeabiosRom: cbfs add-raw vgaroms/seavgabios.bin"
x_ "${cbfstool}" "${tmprom}" add -f "${seavgabiosrom}" \
-n vgaroms/seavgabios.bin -t raw
printf "%s\n" "${tmprom}"
}
@ -366,9 +339,8 @@ build_uboot_roms()
newrom="${romdir}/uboot_payload_${board}_${initmode}_${displaymode}.rom"
[ "${initmode}" = "normal" ] && \
newrom="${romdir}/uboot_payload_${board}_${initmode}.rom"
moverom "${tmprom}" "${newrom}" || \
err "build_roms: moverom fail (u-boot)"
rm -f "${tmprom}" || err "build_roms: cannot rm u-boot rom"
x_ moverom "${tmprom}" "${newrom}"
x_ rm -f "${tmprom}"
}
# make a rom in /tmp/ and then print the path of that ROM
@ -384,11 +356,9 @@ mkUbootRom() {
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${_cbrom}" "${tmprom}" || \
err "mkUbootRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add-payload -f "${_ubootelf}" \
-n ${_uboot_cbfs_path} -c lzma || \
err "mkUbootRom: cannot add u-boot to tmprom"
x_ cp "${_cbrom}" "${tmprom}"
x_ "${cbfstool}" "${tmprom}" add-payload -f "${_ubootelf}" \
-n ${_uboot_cbfs_path} -c lzma
printf "%s\n" "${tmprom}"
}
@ -401,10 +371,9 @@ moverom() {
printf "Creating target image: %s\n" "${newrom}"
[ -d "${newrom%/*}" ] || mkdir -p "${newrom%/*}/" || \
err "moverom: cannot create rom directory: \"${newrom%/*}\""
[ -d "${newrom%/*}" ] || x_ mkdir -p "${newrom%/*}/"
[ "${blobs_required}" = "n" ] && newrom="${newrom%.rom}_noblobs.rom"
cp "${rompath}" "${newrom}" || err "moverom: can't copy rom"
x_ cp "${rompath}" "${newrom}"
}
main $@

31
script/build/coreboot/utils
View File

@ -13,14 +13,12 @@ main()
if [ $# -gt 0 ]; then
for board in "${@}"; do
build_for_mainboard ${board} || \
err "cannot build cbutils for target, ${board}"
x_ build_for_mainboard ${board}
done
else
for boarddir in config/coreboot/*; do
[ ! -d "${boarddir}" ] && continue
build_for_mainboard ${boarddir##*/} || \
err "cannot build cbutils for target, ${board}"
x_ build_for_mainboard ${boarddir##*/}
done
fi
}
@ -28,36 +26,29 @@ main()
build_for_mainboard() {
board="${1}"
[ -d "config/coreboot/${board}" ] || \
err "build_for_mainboard ${board}: boarddir does not exist"
err "build_for_mainboard ${board}: boarddir does not exist"
[ -f "config/coreboot/${board}/target.cfg" ] || \
err "build_for_mainboard ${board}: target.cfg does not exist"
err "build_for_mainboard ${board}: target.cfg does not exist"
tree="undefined"
. "config/coreboot/${board}/target.cfg" # source
[ "${tree}" = "undefined" ] && \
err "build_for_mainboard: improper tree definition for '${board}'"
err "build_for_mainboard ${board}: improper tree definition"
buildutils "${tree}"
}
buildutils() {
tree="${1}"
[ -d "coreboot/${tree}/" ] || \
./update project trees coreboot $tree || \
err "buildutils: cannot fetch ${tree}"
x_ ./update project trees coreboot ${tree}
for util in cbfstool ifdtool; do
[ -f "cbutils/${tree}/${util}" ] && continue
[ -d "cbutils/${tree}" ] || \
mkdir -p "cbutils/${tree}" || \
err "buildutils: can't mkdir cbutils/${tree}"
[ -d "cbutils/${tree}" ] || x_ mkdir -p "cbutils/${tree}"
utildir="coreboot/${tree}/util/${util}"
make distclean -C "${utildir}" || \
err "buildutils: cannot clean ${utildir}"
make -j$(nproc) -C "${utildir}" || \
err "buildutils: cannot build ${utildir}"
cp "${utildir}/${util}" "cbutils/${tree}" || \
err "buildutils: can't cp ${util} cbutils/${tree}/"
make distclean -C "${utildir}" || \
err "buildutils: can't clean ${utildir}"
x_ make distclean -C "${utildir}"
x_ make -j$(nproc) -C "${utildir}"
x_ cp "${utildir}/${util}" "cbutils/${tree}"
x_ make distclean -C "${utildir}"
done
}

26
script/build/fw/serprog
View File

@ -28,8 +28,7 @@ main()
else
err "${usage}"
fi
mkdir -p "bin/serprog_${platform}" || \
err "can't create dir: bin/serprog_${platform}"
x_ mkdir -p "bin/serprog_${platform}"
if [ $# -gt 1 ] ; then
if [ "${2}" = "list" ] ; then
@ -47,20 +46,18 @@ main()
fetch_repo()
{
./update project repo "${1}" || err "fetch ${1} failed!\n"
x_ ./update project repo "${1}"
}
build_rp2040_rom()
{
board=${1}
printf "Building pico-serprog for ${board}\n"
cmake -DPICO_BOARD="${board}" -DPICO_SDK_PATH="${pico_sdk_dir}" \
-B "${pico_src_dir}/build" "${pico_src_dir}" \
|| err "can't cmake ${pico_src_dir}"
cmake --build "${pico_src_dir}/build"
mv ${pico_src_dir}/build/pico_serprog.uf2 \
bin/serprog_rp2040/serprog_${board}.uf2 \
|| err "${board} serprog build failed!"
x_ cmake -DPICO_BOARD="${board}" -DPICO_SDK_PATH="${pico_sdk_dir}" \
-B "${pico_src_dir}/build" "${pico_src_dir}"
x_ cmake --build "${pico_src_dir}/build"
x_ mv ${pico_src_dir}/build/pico_serprog.uf2 \
bin/serprog_rp2040/serprog_${board}.uf2
printf "output to bin/serprog_rp2040/serprog_${board}.uf2\n"
}
@ -68,11 +65,10 @@ build_stm32_rom()
{
board=${1}
printf "Building stm32-vserprog for ${board}\n"
make -C ${stm32_src_dir} libopencm3-just-make BOARD=${board}
make -C ${stm32_src_dir} BOARD=${board}
mv ${stm32_src_dir}/stm32-vserprog.hex \
bin/serprog_stm32/serprog_${board}.hex \
|| err "${board} serprog build failed!"
x_ make -C ${stm32_src_dir} libopencm3-just-make BOARD=${board}
x_ make -C ${stm32_src_dir} BOARD=${board}
x_ mv ${stm32_src_dir}/stm32-vserprog.hex \
bin/serprog_stm32/serprog_${board}.hex
printf "output to bin/serprog_stm32/serprog_${board}.hex\n"
}

17
script/build/grub/payload
View File

@ -22,16 +22,12 @@ main()
handle_dependencies()
{
[ -d "grub/" ] || \
./update project repo grub || \
err "handle_dependencies: cannot fetch grub"
x_ ./update project repo grub
[ -f "grub/grub-mkstandalone" ] || \
./build grub utils || \
err "handle_dependencies: cannot build grub utils"
x_ ./build grub utils
[ -d "${elfdir}" ] || \
mkdir -p "${elfdir}" || \
err "handle_dependencies: cannot mkdir ${elfdir}"
rm -f "${elfdir}/"* || \
err "handle_dependencies: cannot rm inside: ${elfdir}/"
x_ mkdir -p "${elfdir}"
x_ rm -f "${elfdir}/"*
}
build_keymap_configs()
@ -40,9 +36,8 @@ build_keymap_configs()
[ -f "${keylayoutfile}" ] || continue
keymap="${keylayoutfile##${grubcfgsdir}/keymap/}"
keymap="${keymap%.gkb}"
printf "keymap %s\n" "${keymap}" > \
"${elfdir}/keymap_${keymap}.cfg" || \
err "mk_keymap: can't make ${elfdir}/keymap_${keymap}.cfg"
x_ printf "keymap %s\n" "${keymap}" > \
"${elfdir}/keymap_${keymap}.cfg"
done
}

20
script/build/grub/utils
View File

@ -10,25 +10,19 @@ set -u -e
main()
{
[ -d "grub/" ] || ./update project repo grub || err "cannot fetch grub"
[ -d "grub/" ] || x_ ./update project repo grub
build_grub
}
build_grub()
{
(
cd grub/ || \
err "build_grub: cd"
[ ! -d Makefile ] || make distclean || \
err "build_grub: make-distclean"
./bootstrap --gnulib-srcdir=gnulib/ --no-git || \
err "build_grub: gnulib bootstrap"
./autogen.sh || \
err "build_grub: autogen.sh"
./configure --with-platform=coreboot || \
err "build_grub: autoconf"
make -j$(nproc) FS_PAYLOAD_MODULES="" || \
err "build_grub: make"
x_ cd grub/
[ ! -d Makefile ] || x_ make distclean
x_ ./bootstrap --gnulib-srcdir=gnulib/ --no-git
x_ ./autogen.sh
x_ ./configure --with-platform=coreboot
x_ make -j$(nproc) FS_PAYLOAD_MODULES=""
)
}

92
script/build/release/roms
View File

@ -38,41 +38,33 @@ init_check()
[ ! -d "bin/" ] && \
err "init_check: no ROMs built yet (error)"
[ -d "release/" ] || \
mkdir -p release/ || \
err "init_check: !mkdir -p release/"
x_ mkdir -p release/
[ -d "release/${version}/" ] || \
mkdir -p "release/${version}/" || \
err "init_check: !mkdir -p release/${version}/"
x_ mkdir -p "release/${version}/"
[ ! -d "release/${version}/roms/" ] || \
rm -Rf "release/${version}/roms/" || \
err "init_check: !rm -Rf release/${version}/roms/"
x_ rm -Rf "release/${version}/roms/"
[ -d "release/${version}/roms/" ] && return 0
mkdir -p "release/${version}/roms/" || \
err "init_check: !mkdir -p release/${version}/roms/"
x_ mkdir -p "release/${version}/roms/"
}
make_archive()
{
builddir="${1}"
romdir="tmp/romdir" || \
err "make_archive: cannot create tmpdir"
rm -Rf "${romdir}" || err "make_archive: can't remove tmpdir"
romdir="tmp/romdir"
x_ rm -Rf "${romdir}"
target="${builddir##*/}"
if [ ! -f "config/coreboot/${target}/target.cfg" ]; then
# No config, just make a tarball
tarball=release/${version}/roms/${target}_${version}.tar.xz
tar -c "${builddir}" | xz -T0 -6 > ${tarball} || \
(rm ${tarball}
err "make_archive: cannot make \"${tarball}\"")
x_ tar -c "${builddir}" | xz -T0 -6 > ${tarball} || \
x_ rm -f ${tarball}
return 0
fi
romdir="${romdir}/bin/${target}"
mkdir -p "${romdir}" || \
err "make_archive: can't mkdir tmpdir"
cp "${builddir}"/* "${romdir}" || \
err "make_archive: cannot copy ROM images directory -> ${romdir}"
x_ mkdir -p "${romdir}"
x_ cp "${builddir}"/* "${romdir}"
printf "%s\n" "${target}"
@ -97,24 +89,18 @@ make_archive()
printf "Generating release/%s/roms/%s-%s_%s.tar.xz\n" \
"${version}" "${projectname}" "${version}" "${target##*/}"
printf "%s\n" "${version}" > "${romdir}/version" || \
err "make_archive: can't create ${romdir}/version"
printf "%s\n" "${versiondate}" > "${romdir}/versiondate" || \
err "make_archive: can't create ${romdir}/versiondate"
printf "%s\n" "${projectname}" > "${romdir}/projectname" || \
err "make_archive: can't create ${romdir}/projectname"
x_ printf "%s\n" "${version}" > "${romdir}/version"
x_ printf "%s\n" "${versiondate}" > "${romdir}/versiondate"
x_ printf "%s\n" "${projectname}" > "${romdir}/projectname"
archivename="${projectname}-${version}_${target##*/}"
f="release/${version}/roms/${archivename}"
(
cd "${romdir%/bin/${target}}" || err "make_archive: can't cd to tmpdir"
tar -c "bin/${target}/" | xz -T0 -9e > "${archivename}.tar.xz" || \
err "make_archive:cant make ${projectname}-${version}_${target##*/}"
x_ cd "${romdir%/bin/${target}}"
x_ tar -c "bin/${target}/" | xz -T0 -9e > "${archivename}.tar.xz"
)
mv "${romdir%/bin/${target}}/${archivename}.tar.xz" "${f}.tar.xz" || \
err "make_archive: can't copy tarball"
rm -Rf "${romdir%/bin/${target}}" || \
err "make_archive: can't delete tmpdir"
x_ mv "${romdir%/bin/${target}}/${archivename}.tar.xz" "${f}.tar.xz"
x_ rm -Rf "${romdir%/bin/${target}}"
}
strip_archive()
@ -122,10 +108,8 @@ strip_archive()
romdir=${1}
[ -d "coreboot/${tree}" ] || \
./update project trees coreboot ${tree} || \
err "strip_archive: coreboot/${tree}: can't fetch source"
./build coreboot utils ${tree} || \
err "strip_archive: coreboot/${tree}: can't build utils"
x_ ./update project trees coreboot ${tree}
x_ ./build coreboot utils ${tree}
if [ "${microcode_required}" = "n" ]; then
for romfile in "${romdir}"/*.rom; do
@ -134,21 +118,17 @@ strip_archive()
done
for romfile in "${romdir}"/*.tmprom; do
[ -f "${romfile}" ] || continue
mv "${romfile}" "${romfile%.tmprom}.rom" || \
err "can't make no-u rom: ${romfile%.tmprom}.rom"
x_ mv "${romfile}" "${romfile%.tmprom}.rom"
done
fi
# Hash the rom before removing blobs
rm -f "${romdir}/blobhashes" || \
err "strip_archive: !rm -f ${blobdir}/blobhashes"
touch "${romdir}/blobhashes" || \
err "strip_archive: !touch ${blobdir}/blobhashes"
x_ rm -f "${romdir}/blobhashes"
x_ touch "${romdir}/blobhashes"
(
cd "${romdir}" || err "strip_archive: !cd ${romdir}"
sha512sum *.rom >> blobhashes || \
err "strip_archive: ${romdir}: !sha512sum *.rom >> blobhashes"
x_ cd "${romdir}"
x_ sha512sum *.rom >> blobhashes
)
for romfile in "${romdir}"/*.rom; do
@ -161,40 +141,32 @@ strip_ucode()
{
romfile=${1}
_newrom_b="${romfile%.rom}_nomicrocode.tmprom"
cp "${romfile}" "${_newrom_b}" || \
err "strip_rom_image: cp \"${romfile}\" \"${_newrom_b}\""
x_ cp "${romfile}" "${_newrom_b}"
microcode_present="y"
"${cbfstool}" "${_newrom_b}" remove -n \
cpu_microcode_blob.bin 2>/dev/null || microcode_present="n"
[ "${microcode_present}" = "n" ] || return 0
printf "REMARK: '%s' already lacks microcode\n" "${romfile}" 1>&2
printf "Renaming default ROM file instead.\n" 1>&2
mv "${romfile}" "${_newrom_b}" || \
err "strip_rom_image: can't rename no-u ${romfile}"
x_ mv "${romfile}" "${_newrom_b}"
}
strip_rom_image()
{
[ -f "${1}" ] || return 0
[ "${CONFIG_HAVE_ME_BIN}" != "y" ] || \
"${ifdtool}" --nuke me "${1}" -O "${1}" || \
err "strip_rom_images: ${1}: cannot nuke Intel ME"
x_ "${ifdtool}" --nuke me "${1}" -O "${1}"
[ "${CONFIG_HAVE_MRC}" != "y" ] || \
"${cbfstool}" "${1}" remove -n mrc.bin || \
err "strip_rom_images: ${1}: cannot nuke mrc.bin"
x_ "${cbfstool}" "${1}" remove -n mrc.bin
[ "${CONFIG_INCLUDE_SMSC_SCH5545_EC_FW}" != "y" ] || \
"${cbfstool}" "${1}" remove -n sch5545_ecfw.bin || \
err "strip_rom_images: ${1}: can't nuke sch5545ec fw"
x_ "${cbfstool}" "${1}" remove -n sch5545_ecfw.bin
if [ "${CONFIG_KBC1126_FIRMWARE}" = "y" ]; then
"${cbfstool}" "${1}" remove -n ecfw1.bin || \
err "strip_rom_images: ${1}: can't nuke ecfw1.bin"
"${cbfstool}" "${1}" remove -n ecfw2.bin || \
err "strip_rom_images: ${1}: can't nuke ecfw2.bin"
x_ "${cbfstool}" "${1}" remove -n ecfw1.bin
x_ "${cbfstool}" "${1}" remove -n ecfw2.bin
fi
# TODO: replace this board-specific hack
[ "${target}" = "e6400_4mb" ] || return 0
"${cbfstool}" "${1}" remove -n "pci10de,06eb.rom" || \
err "strip_rom_images: ${1}: can't nuke e6400 vga rom"
x_ "${cbfstool}" "${1}" remove -n "pci10de,06eb.rom"
}
main $@

92
script/build/release/src
View File

@ -45,31 +45,23 @@ create_release_directory()
dirname="${projectname}-${version}_src"
srcdir="${reldir}/${dirname}"
[ -d "release/" ] || mkdir -p release/ || \
err "create_release_directory: !mkdir -p release/"
[ -d "${reldir}/" ] || mkdir -p "${reldir}/" || \
err "create_release_directory: !mkdir -p ${reldir}/"
[ ! -d "${srcdir}/" ] || rm -Rf "${srcdir}/" || \
err "create_release_directory: !rm -Rf ${srcdir}/"
[ -d "release/" ] || x_ mkdir -p release/
[ -d "${reldir}/" ] || x_ mkdir -p "${reldir}/"
[ ! -d "${srcdir}/" ] || x_ rm -Rf "${srcdir}/"
[ ! -f "${srcdir}.tar.xz" ] || \
rm -f "${srcdir}.tar.xz/" || \
err "create_release_directory: !rm -f ${srcdir}.tar.xz/"
x_ rm -f "${srcdir}.tar.xz/"
mkdir -p "${srcdir}/" || \
err "create_release_directory: !mkdir -p ${srcdir}/"
printf "%s" "${version}" > "${srcdir}"/version || \
err "create_release_directory: ${srcdir}/version: can't create file"
x_ mkdir -p "${srcdir}/"
x_ printf "%s" "${version}" > "${srcdir}"/version
}
download_modules()
{
for modname in ${trees_fetch_list}; do
[ -d "${modname}" ] || ./update project trees ${modname} || \
err "download_modules: couldn't download ${modname} trees"
[ -d "${modname}" ] || x_ ./update project trees ${modname}
done
for modname in ${simple_fetch_list} ${download_only_list}; do
[ -d "${modname}/" ] || ./update project repo ${modname} || \
err "download_modules: couldn't download ${modname} repo"
[ -d "${modname}/" ] || x_ ./update project repo ${modname}
done
}
@ -80,34 +72,27 @@ copy_files()
for subdir in "${dir}"/*; do
[ -d "${subdir}" ] || continue
[ "${subdir##*/}" = "${dir}" ] && continue
mkdir -p "${srcdir}/${dir}" || \
err "copy_files: !mkdir -p ${srcdir}/${dir}"
x_ mkdir -p "${srcdir}/${dir}"
[ ! -d "${srcdir}/${dir}/${subdir##*/}" ] || \
rm -Rf "${srcdir}/${dir}/${subdir##*/}" || \
err "copy_f:can't rm ${srcdir}/${dir}/${subdir##*/}"
cp -R "${subdir}" "${srcdir}/${dir}/${subdir##*/}" || \
err "copy_f:can't cp ${srcdir}/${dir}/${subdir##*/}"
x_ rm -Rf "${srcdir}/${dir}/${subdir##*/}"
x_ cp -R "${subdir}" "${srcdir}/${dir}/${subdir##*/}"
done
done
for dir in ${simple_fetch_list} ${dirlist}; do
cp -R "${dir}/" "${srcdir}/" || \
err "copy_files: !cp -R ${dir}/ ${srcdir}/"
x_ cp -R "${dir}/" "${srcdir}/"
done
for i in ${filelist}; do
if [ ! -f "${i}" ]; then
rm -Rf "${srcdir}" || \
err "copy_files: !rm -Rf ${srcdir}"
x_ rm -Rf "${srcdir}"
err "copy_files: file '${i}' does not exist"
fi
cp "${i}" "${srcdir}/" || \
err "copy_files: !cp ${i} ${srcdir}/"
x_ cp "${i}" "${srcdir}/"
done
(
cd "${srcdir}/" || err "copy_files: can't enter dir: ${srcdir}/"
x_ cd "${srcdir}/"
for i in ${linklist}; do
ln -s lbmk "${i}" || \
err "copy_files: cannot create symlink: ${i} -> lbmk"
x_ ln -s lbmk "${i}"
done
)
}
@ -115,55 +100,40 @@ copy_files()
purge_files()
{
(
cd "${srcdir}/" || err "purge_files 3: !cd ${srcdir}/"
x_ cd "${srcdir}/"
[ ! -d "coreboot/default/util/kbc1126" ] || \
./handle make file -c "coreboot/default/util/kbc1126" || \
err "purge_files 1: default/util/kbc1126: ! make clean"
./handle make config -x coreboot || \
err "purge_files: coreboot: cannot clean crossgcc files"
x_ ./handle make file -c "coreboot/default/util/kbc1126"
x_ ./handle make config -x coreboot
for p in u-boot seabios coreboot; do
./handle make config -c "${p}" || \
err "purge_files: ${p}: cannot clean the source trees"
x_ ./handle make config -c "${p}"
done
for p in bios_extract flashrom grub uefitool; do
./handle make file -c "${p}" || \
err "purge_files: !./handle make file -c ${p}"
x_ ./handle make file -c "${p}"
done
for p in "stm32-vserprog" "stm32-vserprog/libopencm3"; do
./handle make file -c "util-fw/${p}" || \
err "purge_files !./handle make file util-fw/${p}"
x_ ./handle make file -c "util-fw/${p}"
done
for p in 32 64; do
./handle make file -c "memtest86plus/build${p}" || \
err "purge_files: cannot clean memtest86+ build${p}"
x_ ./handle make file -c "memtest86plus/build${p}"
done
for p in "nvmutil" "spkmodem_recv" "e6400-flash-unlock"; do
make clean -C "util/${p}" || \
err "purge_files 2: !make clean -C ${util}/p"
x_ make clean -C "util/${p}"
done
for p in ${trees_fetch_list}; do
rm -Rf "${p}/${p}" "${p}"/*/.git* || \
err "purge_files 1: cannot clean ${p} project files"
x_ rm -Rf "${p}/${p}" "${p}"/*/.git*
done
rm -Rf .git* */.git* */*/.git* */*/*/.git* */*/*/*/.git* \
*/*/*/*/*/.git* */*/*/*/*/*/.git* */*/*/*/*/*/*/.git* || \
err "purge_files rm-rf2: can't purge .git files/directories"
rm -Rf cbutils || err "purge_files: can't remove ${srcdir}/cbutils/"
rm -Rf elf || err "purge_files: can't remove ${srcdir}/elf/"
rm -Rf util-fw/rp2040/pico-serprog/build || \
err "purge_files: can't remove pico-serprog/build"
x_ rm -Rf .git* */.git* */*/.git* */*/*/.git* */*/*/*/.git* \
*/*/*/*/*/.git* */*/*/*/*/*/.git* */*/*/*/*/*/*/.git*
x_ rm -Rf cbutils elf util-fw/rp2040/pico-serprog/build
)
}
create_release_archive()
{
(
cd "${reldir}/" || \
err "create_release_archive 4: !cd ${reldir}/"
tar -c "${dirname}/" | xz -T0 -9e >"${dirname}.tar.xz" || \
err "create_release_archive: can't create ${dirname}.tar.xz"
rm -Rf "${dirname}/" || \
err "create_release_archive 5: !rm -Rf ${dirname}/"
x_ cd "${reldir}/"
x_ tar -c "${dirname}/" | xz -T0 -9e >"${dirname}.tar.xz"
x_ rm -Rf "${dirname}/"
)
}

73
script/handle/make/config
View File

@ -56,8 +56,7 @@ handle_dependencies()
fail "Cannot get options for ${cfgsdir}"
[ $# -gt 0 ] && targets=$@
[ -d "${elfdir}" ] || [ "${mode}" != "all" ] || \
mkdir -p "${elfdir}/" || fail "can't create directory ${elfdir}"
[ "${mode}" = "all" ] && xx_ mkdir -p "${elfdir}/"
}
handle_targets()
@ -67,8 +66,8 @@ handle_targets()
printf "Running 'make %s' for project '%s, target '%s''\n" \
"${mode}" "${project}" "${target}"
[ "${project}" != "coreboot" ] || [ "${mode}" != "all" ] || \
./update blobs download ${target} || fail "blobutil"
handle_defconfig || fail "error handling config file"
xx_ ./update blobs download ${target}
xx_ handle_defconfig
done
[ "${mode}" = "all" ] || return 0
@ -96,8 +95,7 @@ handle_defconfig()
handle_src_tree()
{
target_dir="${cfgsdir}/${target}"
mkdir -p "${elfdir}/${target}" || \
fail "handle_src_tree: !mkdir -p ${elfdir}/${target}"
xx_ mkdir -p "${elfdir}/${target}"
eval "$(setvars "undefined" arch tree)"
romtype="normal"
@ -121,8 +119,7 @@ handle_src_tree()
"${codedir}" 1>&2
return 1
fi
./update project trees "${project}" "${target}" || \
fail "handle_src_tree: can't fetch ${project}/${target}"
xx_ ./update project trees "${project}" "${target}"
elif [ "${mode}" = "distclean" ] || \
[ "${mode}" = "crossgcc-clean" ]; then
[ -f "${tmpclean}/${tree}" ] && return 1
@ -134,8 +131,7 @@ handle_src_tree()
[ "${mode}" != "all" ] || check_cross_compiler || \
fail "handle_src_tree ${project}/${target}: crossgcc"
cbfstool="cbutils/${tree}/cbfstool"
[ -f "${cbfstool}" ] || ./build coreboot utils "${tree}" || \
fail "handle_src_tree: cannot build cbfstool"
[ -f "${cbfstool}" ] || xx_ ./build coreboot utils "${tree}"
fi
}
@ -156,8 +152,7 @@ check_cross_compiler()
# only true if not building coreboot:
ctarget="${cbdir#coreboot/}"
[ -d "${cbdir}" ] || \
./update project trees coreboot ${ctarget} || \
fail "check_cross_compiler: can't fetch coreboot/${ctarget}"
xx_ ./update project trees coreboot ${ctarget}
if [ "${arch}" = "x86_32" ] || [ "${arch}" = "x86_64" ]; then
[ -d "${cbdir}/util/crossgcc/xgcc/i386-elf/" ] || \
@ -205,17 +200,13 @@ check_config()
printf "Build already exists, so skipping build\n" 1>&2
return 1
done
mkdir -p "${dest_dir}" || \
fail "check_config: cannot mkdir: ${dest_dir}"
xx_ mkdir -p "${dest_dir}"
}
run_make_command()
{
./handle make file -c "${codedir}" || \
fail "run_make_command: make distclean/clean failed"
cp "${config}" "${codedir}/.config" || \
fail "run_make_command: can't copy config for: ${project}/${target}"
xx_ ./handle make file -c "${codedir}"
xx_ cp "${config}" "${codedir}/.config"
[ "${mode}" != "all" ] || make -C "${codedir}" silentoldconfig || \
make -C "${codedir}" oldconfig || : # don't error on oldconfig
@ -223,30 +214,26 @@ run_make_command()
printf "%s\n" "${our_version}" >"${codedir}/.coreboot-version" \
|| fail "run_make_command: ${codedir}: can't set version"
fi
make -C "${codedir}" -j$(nproc) ${mode} || \
fail "run_make: !make-${mode}: ${codedir} (${project}/${target})"
xx_ make -C "${codedir}" -j$(nproc) ${mode}
if [ -e "${codedir}/.git" ] && [ "${project}" = "u-boot" ] && \
[ "${mode}" = "distclean" ]; then
git -C "${codedir}" clean -fdx || \
fail "run_make_command: ${codedir}: cannot clean u-boot git"
xx_ git -C "${codedir}" clean -fdx
elif [ "${mode}" = "oldconfig" ] || [ "${mode}" = "menuconfig" ]; then
cp "${codedir}/.config" "${config}" || \
fail "run_make: can't edit config: ${project}/${target}"
xx_ cp "${codedir}/.config" "${config}"
fi
}
copy_elf()
{
[ "${project}" != "coreboot" ] || modify_coreboot_rom || \
fail "copy_elf: cannot prepare coreboot image"
[ "${project}" != "coreboot" ] || xx_ modify_coreboot_rom
while read f; do
[ ! -f "${codedir}/$f" ] || cp "${codedir}/${f}" \
"${dest_dir}/" || fail "copy_elf: cannot copy elf file"
[ ! -f "${codedir}/$f" ] || \
xx_ cp "${codedir}/${f}" "${dest_dir}/"
done < ${listfile}
./handle make file -c "${codedir}" || \
fail "copy_elf: clean: ${codedir} (${project}/${target})"
xx_ ./handle make file -c "${codedir}"
}
modify_coreboot_rom()
@ -255,32 +242,26 @@ modify_coreboot_rom()
[ -f "${rompath}" ] || \
fail "modify_coreboot_rom: does not exist: ${rompath}"
tmprom="$(mktemp -t rom.XXXXXXXXXX)"
rm -f "${tmprom}" || \
fail "modify_coreboot_rom prep: cannot remove tmprom"
xx_ rm -f "${tmprom}"
if [ "${romtype}" = "d8d16sas" ]; then
# pike2008 roms hang seabios. an empty rom will override
# the built-in one, thus disabling all execution of it
touch "${tmprom}" || \
fail "modify_coreboot_rom: cannot create fake oprom"
xx_ touch "${tmprom}"
for deviceID in "0072" "3050"; do
"${cbfstool}" "${rompath}" add -f "${tmprom}" \
-n "pci1000,${deviceID}.rom" -t raw || \
fail "modify_coreboot_rom: can't insert fake rom"
xx_ "${cbfstool}" "${rompath}" add -f "${tmprom}" \
-n "pci1000,${deviceID}.rom" -t raw
done
elif [ "${romtype}" = "i945 laptop" ]; then
# for bucts-based installation method from factory bios
dd if="${rompath}" of="${tmprom}" bs=1 \
xx_ dd if="${rompath}" of="${tmprom}" bs=1 \
skip=$(($(stat -c %s "${rompath}") - 0x10000)) \
count=64k || \
fail "modify_coreboot_rom: can't read i945 bootblock"
dd if="${tmprom}" of="${rompath}" bs=1 \
count=64k
xx_ dd if="${tmprom}" of="${rompath}" bs=1 \
seek=$(($(stat -c %s "${rompath}") - 0x20000)) \
count=64k conv=notrunc || \
fail "modify_coreboot_rom: can't write i945 bootblock"
count=64k conv=notrunc
fi
rm -f "${tmprom}" || \
fail "modify_coreboot_rom: cannot remove tmprom"
xx_ rm -f "${tmprom}"
}
fail()

11
script/handle/make/file
View File

@ -29,14 +29,13 @@ main()
handle_dependencies()
{
[ -d "${project}" ] || ./update project repo "${project%/*}" || \
err "handle_dependencies: can't fetch ${project%/*}"
[ -d "${project}" ] || x_ ./update project repo "${project%/*}"
[ -d "${project}" ] || \
err "handle_dependencies: ${project%/*} not downloaded"
[ "${project}" = "uefitool" ] || return 0 # TODO: remove hardcoding
(
cd uefitool || err "handle_dependencies: !cd uefitool"
x_ cd uefitool
cmake UEFIExtract/ || [ -f Makefile ] || \
err "handle_dependencies: !cmake UEFIExtract/"
)
@ -45,11 +44,9 @@ handle_dependencies()
run_make_command()
{
if [ -z "${mode}" ]; then
make -C "${project}" -j$(nproc) || \
err "run_make_command: !make -C ${project}"
x_ make -C "${project}" -j$(nproc)
else
make -C "${project}" clean || \
err "run_make_command: ${project}: make-clean failed"
x_ make -C "${project}" clean
make -C "${project}" distclean || :
fi
}

30
script/update/blobs/download
View File

@ -41,21 +41,16 @@ detect_firmware()
build_dependencies()
{
[ -d ${cbdir} ] || \
./update project trees coreboot ${cbdir##*/} || \
err "build_dependencies: can't fetch ${cbdir}"
x_ ./update project trees coreboot ${cbdir##*/}
for d in uefitool biosutilities bios_extract me_cleaner; do
[ -d "${d}" ] && continue
./update project repo "${d}" || \
err "build_dependencies: can't fetch ${d}"
x_ ./update project repo "${d}"
done
[ -f uefitool/uefiextract ] || \
./handle make file -b uefitool || \
err "build_dependencies: can't build uefitool"
x_ ./handle make file -b uefitool
[ -f "${cbdir}/util/kbc1126/kbc1126_ec_dump" ] || \
make -C "${cbdir}/util/kbc1126" || \
err "build_dependencies: can't build kbc1126_ec_dump"
./build coreboot utils default || \
err "build_dependencies: cannot build utils in cbutils/default/"
x_ make -C "${cbdir}/util/kbc1126"
x_ ./build coreboot utils default
}
download_blobs()
@ -117,13 +112,12 @@ extract_intel_me()
extract_kbc1126ec()
{
(
cd "${appdir}/" || \
err "extract_kbc1126_ec: !cd \"${appdir}/\""
x_ cd "${appdir}/"
mv Rompaq/68*.BIN ec.bin || :
if [ ! -f ec.bin ]; then
unar -D ROM.CAB Rom.bin || unar -D Rom.CAB Rom.bin || \
unar -D 68*.CAB Rom.bin || err "extract_kbc1126_ec !extract"
mv Rom.bin ec.bin || err "extract_kbc1126_ec: *didn't* extract"
x_ unar -D 68*.CAB Rom.bin
x_ mv Rom.bin ec.bin
fi
[ -f ec.bin ] || err "extract_kbc1126_ec ${board}: can't extract"
"${kbc1126_ec_dump}" ec.bin || \
@ -135,8 +129,7 @@ extract_kbc1126ec()
done
[ "${ec_ex}" = "y" ] || \
err "extract_kbc1126_ec ${board}: didn't extract ecfw1/2.bin"
cp "${appdir}/"ec.bin.fw* "${_dest%/*}/" || \
err "extract_kbc1126_ec: cant mv ecfw1/2 ${_dest%/*}"
x_ cp "${appdir}/"ec.bin.fw* "${_dest%/*}/"
}
extract_e6400vga()
@ -148,14 +141,13 @@ extract_e6400vga()
tail -c +${E6400_VGA_offset} "${_dl}" | \
gunzip >"${appdir}/bios.bin" || :
(
cd "${appdir}" || err "extract_e6400vga: can't cd ${appdir}"
x_ cd "${appdir}"
[ -f "bios.bin" ] || err "extract_e6400vga: can't extract bios.bin"
"${e6400_unpack}" bios.bin || printf "TODO: fix dell extract util\n"
[ -f "${E6400_VGA_romname}" ] || \
err "extract_e6400vga: can't extract vga rom from bios.bin"
)
cp "${appdir}"/"${E6400_VGA_romname}" "${_dest}" || \
err "extract_e6400vga: can't copy vga rom to ${_dest}"
x_ cp "${appdir}"/"${E6400_VGA_romname}" "${_dest}"
}
# TODO: this code is cancer. hardcoded is bad, and stupid.

89
script/update/blobs/inject
View File

@ -82,18 +82,15 @@ detect_board()
err "detect_board: could not detect board type"
esac
[ -d "${boarddir}/" ] || \
err "detect_board: dir, ${boarddir}, doesn't exist"
err "detect_board: dir, ${boarddir}, doesn't exist"
printf "%s\n" "${board}"
}
build_dependencies()
{
[ -d "${cbdir}" ] || ./update project trees coreboot default || \
err "build_dependencies: could not download coreboot/default"
./build coreboot utils default || \
err "build_dependencies: could not build cbutils"
./update blobs download ${board} || \
err "build_dependencies: Could not download blobs for ${board}"
[ -d "${cbdir}" ] || x_ ./update project trees coreboot default
x_ ./build coreboot utils default
x_ ./update blobs download ${board}
}
inject_blobs()
@ -104,35 +101,31 @@ inject_blobs()
release_archive="y"
patch_release_roms
else
patch_rom "${rom}" || \
err "inject_blobs: could not patch ${x}"
x_ patch_rom "${rom}"
fi
}
patch_release_roms()
{
_tmpdir="tmp/romdir"
rm -Rf "${_tmpdir}" || err "patch_release_roms 1: can't prepare tmpdir"
mkdir -p "${_tmpdir}" || err "patch_release_roms: can't make tmpdir"
tar -xf "${releasearchive}" -C "${_tmpdir}" || \
err "patch_release_roms: could not extract release archive"
x_ rm -Rf "${_tmpdir}"
x_ mkdir -p "${_tmpdir}"
x_ tar -xf "${releasearchive}" -C "${_tmpdir}"
for x in "${_tmpdir}"/bin/*/*.rom ; do
printf "patching rom: %s\n" "$x"
patch_rom "${x}" || err "patch_release_roms: could not patch ${x}"
x_ patch_rom "${x}"
done
for x in "${_tmpdir}"/bin/*/*_nomicrocode.rom ; do
[ -f "${x}" ] || continue
[ -f "${x%_nomicrocode.rom}.rom" ] || continue
cp "${x%_nomicrocode.rom}.rom" "${x}" || \
err "patch_release_roms: ${x}: can't overwrite no-ucode rom"
"${cbfstool}" "${x}" remove -n cpu_microcode_blob.bin || \
err "patch_release_roms: ${x}: cannot remove u-code"
x_ cp "${x%_nomicrocode.rom}.rom" "${x}"
x_ "${cbfstool}" "${x}" remove -n cpu_microcode_blob.bin
done
(
cd "${_tmpdir}"/bin/*
x_ cd "${_tmpdir}/bin/"*
# NOTE: For compatibility with older rom releases, defer to sha1
sha512sum --status -c blobhashes || \
@ -146,14 +139,12 @@ patch_release_roms()
done
fi
[ -d bin/release ] || mkdir -p bin/release || \
err "patch_release_roms: !mkdir -p bin/release"
mv "${_tmpdir}"/bin/* bin/release/ || \
err "patch_release_roms: !mv ${_tmpdir}/bin/* bin/release/"
[ -d bin/release ] || x_ mkdir -p bin/release
x_ mv "${_tmpdir}"/bin/* bin/release/
printf "Success! Your ROMs are in bin/release\n"
rm -Rf "${_tmpdir}" || err "patch_release_roms: !rm -Rf ${_tmpdir}"
x_ rm -Rf "${_tmpdir}"
}
patch_rom()
@ -170,7 +161,7 @@ patch_rom()
[ -f "${rom%_nomicrocode.rom}.rom" ] && \
[ "${release_archive}" = "y" ] && return 0
check_defconfig "${boarddir}" || err "patch_rom ${rom}: no defconfig"
x_ check_defconfig "${boarddir}"
set -- "${boarddir}/config/"*
. "${1}" 2>/dev/null
@ -217,8 +208,8 @@ inject_blob_intel_mrc()
# source code, and it is *always* correct for haswell platform.
# TODO: this logic should be tweaked to handle more platforms
"${cbfstool}" "${rom}" add -f mrc/haswell/mrc.bin -n mrc.bin -t mrc \
-b 0xfffa0000 || err "inject_blob_intel_mrc: cannot insert mrc.bin"
x_ "${cbfstool}" "${rom}" add -f mrc/haswell/mrc.bin -n mrc.bin \
-t mrc -b 0xfffa0000
}
inject_blob_intel_me()
@ -233,8 +224,7 @@ inject_blob_intel_me()
[ ! -f "${_me_location}" ] && \
err "inject_blob_intel_me: per CONFIG_ME_BIN_PATH: file missing"
"${ifdtool}" -i me:"${_me_location}" "${rom}" -O "${rom}" || \
err "inject_blob_intel_me: cannot insert me.bin"
x_ "${ifdtool}" -i me:"${_me_location}" "${rom}" -O "${rom}"
}
inject_blob_hp_kbc1126_ec()
@ -258,12 +248,10 @@ inject_blob_hp_kbc1126_ec()
err "inject_blob_hp_kbc1126_ec: ${board}: ecfw not downloaded"
fi
"${cbfstool}" "${rom}" add -f "${_ec1_location}" -n ecfw1.bin \
-b ${_ec1_offset} -t raw || \
err "inject_blob_hp_kbc1126_ec: cannot insert ecfw1.bin"
"${cbfstool}" "${rom}" add -f "${_ec2_location}" -n ecfw2.bin \
-b ${_ec2_offset} -t raw || \
err "inject_blob_hp_kbc1126_ec: cannot insert ecfw2.bin"
x_ "${cbfstool}" "${rom}" add -f "${_ec1_location}" -n ecfw1.bin \
-b ${_ec1_offset} -t raw
x_ "${cbfstool}" "${rom}" add -f "${_ec2_location}" -n ecfw2.bin \
-b ${_ec2_offset} -t raw
}
inject_blob_dell_e6400_vgarom_nvidia()
@ -276,29 +264,24 @@ inject_blob_dell_e6400_vgarom_nvidia()
printf "adding pci option rom\n"
if [ "${_vga_dir}" != "${pciromsdir}" ]; then
[ "${_vga_dir}" = "${pciromsdir}" ] || \
err "inject_blob_dell_e6400vga: invalid pcirom dir: ${_vga_dir}"
fi
if [ ! -f "${_vga_location}" ]; then
[ -f "${_vga_location}" ] || \
err "inject_blob_dell_e6400vga: ${_vga_location} doesn't exist"
fi
"${cbfstool}" "${rom}" add -f "${_vga_location}" \
-n "pci${CONFIG_VGA_BIOS_ID}.rom" -t optionrom || \
err "inject_blob_dell_e6400vga: cannot insert vga oprom"
x_ "${cbfstool}" "${rom}" add -f "${_vga_location}" \
-n "pci${CONFIG_VGA_BIOS_ID}.rom" -t optionrom
}
inject_blob_smsc_sch5545_ec()
{
rom="${1}"
_sch5545ec_location="${CONFIG_SMSC_SCH5545_EC_FW_FILE#../../}"
[ -f "${_sch5545ec_location}" ] || \
err "inject_blob_smsc_sch5545_ec: SCH5545 fw missing"
"${cbfstool}" "${rom}" add -f "${_sch5545ec_location}" \
-n sch5545_ecfw.bin -t raw || \
err "inject_blob_smsc_sch5545_ec: can't insert sch5545_ecfw.bin"
x_ "${cbfstool}" "${rom}" add -f "${_sch5545ec_location}" \
-n sch5545_ecfw.bin -t raw
}
modify_gbe()
@ -309,21 +292,17 @@ modify_gbe()
rom="${1}"
_gbe_location=${CONFIG_GBE_BIN_PATH#../../}
[ -f "${_gbe_location}" ] || \
err "modify_gbe: CONFIG_GBE_BIN_PATH points to missing file"
[ -f "${nvmutil}" ] || \
make -C util/nvmutil || err "modify_gbe: couldn't build nvmutil"
x_ make -C util/nvmutil
_gbe_tmp=$(mktemp -t gbeXXXX.bin)
cp "${_gbe_location}" "${_gbe_tmp}"
"${nvmutil}" "${_gbe_tmp}" setmac "${new_mac}" || \
err "modify_gbe: ${board}: failed to modify mac address"
x_ cp "${_gbe_location}" "${_gbe_tmp}"
x_ "${nvmutil}" "${_gbe_tmp}" setmac "${new_mac}"
x_ "${ifdtool}" -i GbE:"${_gbe_tmp}" "${rom}" -O "${rom}"
"${ifdtool}" -i GbE:"${_gbe_tmp}" "${rom}" -O "${rom}" || \
err "modify_gbe: ${board}: cannot insert modified gbe.bin"
rm -f "${_gbe_tmp}" || err "modify_gbe: can't remove ${_gbe_tmp}"
x_ rm -f "${_gbe_tmp}"
}
usage()

19
script/update/project/repo
View File

@ -23,11 +23,9 @@ main()
clone_project
[ "${depend}" = "" ] || for d in ${depend} ; do
./update project repo ${d} || \
fail "Cannot fetch dependency, ${d}, for project, ${name}"
xx_ ./update project repo ${d}
done
rm -Rf "${tmp_dir}" || fail "cannot remove tmpdir, ${tmp_dir}"
xx_ rm -Rf "${tmp_dir}"
}
verify_config()
@ -39,8 +37,8 @@ verify_config()
clone_project()
{
rm -Rf "${tmp_dir}" || fail "clone_project: cannot remove old tmpdir"
mkdir -p "${tmp_dir%/*}" || fail "clone_project: can't mkdir"
xx_ rm -Rf "${tmp_dir}"
xx_ mkdir -p "${tmp_dir%/*}"
git clone ${url} "${tmp_dir}" || git clone ${bkup_url} "${tmp_dir}" || \
fail "clone_project: could not download ${name}"
@ -50,12 +48,9 @@ clone_project()
fail "clone_project ${loc}/: cannot apply patches"
[ ! -d "${loc}" ] || \
rm -Rf "${loc}" || \
fail "clone_project: Can't remove directory '${loc}'"
[ "${loc}" = "${loc%/*}" ] || mkdir -p ${loc%/*} || \
fail "clone_project: cannot make directory for ${name}"
mv "${tmp_dir}" "${loc}" || \
fail "clone_project: could not copy temp file to destination"
xx_ rm -Rf "${loc}"
[ "${loc}" = "${loc%/*}" ] || xx_ mkdir -p ${loc%/*}
xx_ mv "${tmp_dir}" "${loc}"
}
fail()

50
script/update/project/trees
View File

@ -15,7 +15,7 @@ eval "$(setvars "" _target tree rev project cfgsdir)"
main()
{
rm -f "${cfgsdir}"/*/seen || err_rm_seen "main 1"
x_ rm -f "${cfgsdir}"/*/seen
printf "Downloading %s and (if available) applying patches\n" \
${project}
@ -32,11 +32,10 @@ main()
err "No targets available for project: ${project}"
for x in ${targets}; do
rm -f "${cfgsdir}"/*/seen || err_rm_seen "main 2"
download_for_target "${x}" || \
err "${project}/${target}: cannot download source tree"
x_ rm -f "${cfgsdir}"/*/seen
x_ download_for_target "${x}"
done
rm -f "${cfgsdir}"/*/seen || err_rm_seen "main 3"
x_ rm -f "${cfgsdir}"/*/seen
}
download_for_target()
@ -45,10 +44,8 @@ download_for_target()
tree="undefined"
rev="undefined"
fetch_config "${_target}" || \
err "download_for_target: ${project}/${_target}: bad target.cfg"
rm -f "${cfgsdir}"/*/seen || err_rm_seen "download_for_target"
x_ fetch_config "${_target}"
x_ rm -f "${cfgsdir}"/*/seen
if [ -d "${project}/${tree}" ]; then
printf "REMARK: download/%s %s: exists. Skipping.\n" \
@ -60,8 +57,7 @@ download_for_target()
fetch_from_upstream || \
err "download_for_target: cannot fetch: ${project}"
prepare_new_tree "${_target}" "${tree}" "${rev}" || \
err "download_for_target: cannot create tree: ${project}/${tree}"
x_ prepare_new_tree "${_target}" "${tree}" "${rev}"
}
fetch_config()
@ -82,14 +78,16 @@ fetch_config()
_target="${tree}"
continue
elif [ "${tree}" = "undefined" ]; then
printf "ERROR (fetch_config): download/%s:" 1>&2
printf "ERROR (fetch_config): download/%s:" \
"${project}" 1>&2
printf " tree name undefined for '%s\n'" \
"${project}" "${_target}" 1>&2
"${_target}" 1>&2
return 1
elif [ "${rev}" = "undefined" ]; then
printf "ERROR (fetch_config): download/%s:" 1>&2
printf "ERROR (fetch_config): download/%s:" \
"${project}" 1>&2
printf " commit ID undefined for '%s'\n" \
"${project}" "${_target}" 1>&2
"${_target}" 1>&2
return 1
else
break
@ -114,8 +112,7 @@ check_config_for_target()
1>&2
return 1
fi
touch "${cfgsdir}/${_target}/seen" || \
err "${project}/${_target}: touch \"${cfgsdir}/${_target}/seen\""
x_ touch "${cfgsdir}/${_target}/seen"
}
fetch_from_upstream()
@ -137,26 +134,17 @@ prepare_new_tree()
[ "${tree}" != "${target}" ] && \
printf "(for target, %s)\n" "${target}"
cp -R "${project}/${project}" "${project}/${tree}" || \
err "${project}/${tree}: cannot copy source tree"
git_reset_rev "${project}/${tree}" "${rev}" "err" || \
err "prepare_new_trees ${project}/${tree}: cannot reset <- ${rev}"
x_ cp -R "${project}/${project}" "${project}/${tree}"
x_ git_reset_rev "${project}/${tree}" "${rev}" "err"
(
cd "${project}/${tree}" || \
err "prepare_new_tree: !cd \"${project}/${tree}\""
x_ cd "${project}/${tree}"
git submodule update --init --checkout || \
err "prepare_new_tree ${project}/${tree}: can't update git modules"
)
git_am_patches "${PWD}/${project}/${tree}" \
"${PWD}/${cfgsdir}/${tree}/patches" "err" || \
err "prepare_new_trees ${project}/${tree}: cannot apply patches"
}
err_rm_seen()
{
err "${1}: ${project}/${target}: cannot rm: \"${cfgsdir}/*/seen\""
x_ git_am_patches "${PWD}/${project}/${tree}" \
"${PWD}/${cfgsdir}/${tree}/patches" "err"
}
main $@