768 lines
23 KiB
Bash
Executable File
768 lines
23 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Copyright (C) 2018 Luke Shumaker
|
|
# Copyright (C) 2023-2024 Umorpha Systems
|
|
# SPDX-License-Identifier: AGPL-3.0-or-later
|
|
declare -r NAME=osi-mk
|
|
declare -r VERSION=20231023
|
|
|
|
# Why is this different than mkosi[1]?
|
|
#
|
|
# - mkosi claims to be "legacy-free"--but they call everything that's
|
|
# not systemd "legacy"; that clearly won't do for creating OpenRC
|
|
# images.
|
|
#
|
|
# - mkosi claims to be "legacy-free", only supporting GPT
|
|
# disk-labels--but btrfs can be booted directly, without a separate
|
|
# disk-label, or a separate ESP partition. To a btrfs disk, GPT/ESP
|
|
# is legacy.
|
|
#
|
|
# - Using a raw btrfs disk means that it can easily be mounted without
|
|
# first dissecting the disk-label.
|
|
#
|
|
# [1]: https://github.com/systemd/mkosi
|
|
|
|
set -euE -o pipefail
|
|
shopt -s expand_aliases
|
|
|
|
install_prefix="$(realpath --logical --canonicalize-missing -- "${BASH_SOURCE[0]}/../..")"
|
|
readonly install_prefix
|
|
|
|
source "${install_prefix}/lib/osi.sh"
|
|
source "${install_prefix}/lib/argparse.sh"
|
|
|
|
loaded_modules=()
|
|
load_module() {
|
|
local module
|
|
if ! [[ -f $1 ]]; then
|
|
argparse:error 'Module does not exist: %s' "$1"
|
|
return
|
|
fi
|
|
module="$(realpath -- "$1")"
|
|
if osi.sh:in_array "$module" "${loaded_modules[@]}"; then
|
|
return 0
|
|
fi
|
|
loaded_modules+=("$module")
|
|
# shellcheck source=/dev/null
|
|
source "$1"
|
|
}
|
|
|
|
beg_indent() {
|
|
exec 8> >(
|
|
osi.sh:printf -v prefix -- "$@"
|
|
# shellcheck disable=SC2154 # false-positive, doesn't understand `osi.sh:printf -v`
|
|
"${install_prefix}/lib/indent" "$NAME [$prefix] "
|
|
)
|
|
_indent_pid=$!
|
|
}
|
|
|
|
alias end_indent=' <&- >&8; exec 8<&-; wait $_indent_pid'
|
|
|
|
osi-mk:genfstab() {
|
|
local arg_mountpoint=$1
|
|
{
|
|
# This header mimics the stock fstat from 'filesystem'.
|
|
echo '# Static information about the filesystems.'
|
|
echo '# See fstab(5) for details.'
|
|
echo
|
|
{
|
|
# This doesn't quite mimic the header from 'filesystem'
|
|
#
|
|
# - I swapped "file system" for "device", for clarity,
|
|
# and so that it's one word for `column -t`.
|
|
# - I swapped "pass" for "fsck", for clarity.
|
|
# - I removed the space after the "#", so it works with
|
|
# `column -t`.
|
|
echo '#<device> <mountpoint> <type> <options> <dump> <fsck>'
|
|
case "${arg_conf[format]}" in
|
|
erofs)
|
|
echo "UUID=${arg_conf[fsuuid]}" / erofs defaults 0 1
|
|
;;
|
|
*)
|
|
genfstab -t uuid "$arg_mountpoint" | grep '^[#]' | awk '$3 != "swap"'
|
|
;;
|
|
esac
|
|
} | column -t
|
|
} >"${arg_mountpoint}/etc/fstab"
|
|
}
|
|
|
|
osi-mk:directories() {
|
|
local arg_mountpoint=$1
|
|
local spec outside inside
|
|
for spec in "${arg_directories[@]}"; do
|
|
outside="${spec%:*}"
|
|
inside="${spec#"${outside}:"}"
|
|
# TODO: maybe rsync would be better?
|
|
mkdir -p -- "$(dirname -- "${arg_mountpoint}/${inside}")"
|
|
osi.sh:print 'Copying %q to %q:%q' "$outside" "$arg_file" "$inside"
|
|
cp -aT --no-preserve=ownership -- "$outside" "${arg_mountpoint}/${inside}"
|
|
done
|
|
}
|
|
|
|
osi-mk:hostname() {
|
|
local arg_mountpoint=$1
|
|
|
|
echo "${arg_conf[hostname]}" >"$arg_mountpoint/etc/hostname"
|
|
}
|
|
|
|
osi-mk:machine-id() {
|
|
local arg_mountpoint=$1
|
|
|
|
case "${arg_conf[machine-id]}" in
|
|
auto) :;; # leave it alone
|
|
none) rm -f -- "$arg_mountpoint/etc/machine-id";;
|
|
*) echo "${arg_conf[machine-id]}" >"$arg_mountpoint/etc/machine-id";;
|
|
esac
|
|
}
|
|
|
|
osi-mk:mkinitcpio() {
|
|
local arg_mountpoint=$1
|
|
osi.sh:print 'Configuring mkinitcpio to include all drivers'
|
|
mkdir -p -- "$arg_mountpoint/etc/mkinitcpio.conf.d"
|
|
cat >"$arg_mountpoint/etc/mkinitcpio.conf.d/osi-mk.conf" <<'EOF'
|
|
#!/hint/bash
|
|
# Copyright (C) 2023 Umorpha Systems
|
|
# SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
# Remove 'autodetect' from HOOKS; include all drivers.
|
|
for ((i=0; i<${#HOOKS[@]}; i++)); do
|
|
if [[ ${HOOKS[i]} == autodetect ]]; then
|
|
HOOKS=("${HOOKS[@]:0:i}" "${HOOKS[@]:i+1}")
|
|
fi
|
|
done
|
|
EOF
|
|
}
|
|
|
|
osi-mk:grub-install() {
|
|
local arg_mountpoint=$1
|
|
|
|
local target=${arg_conf[bootloader]#grub-}
|
|
if [[ $target == arm-uboot-* ]]; then
|
|
target=arm-uboot
|
|
fi
|
|
|
|
# shellcheck disable=SC2016
|
|
arch-chroot -- "$arg_mountpoint" sh -c \
|
|
"grub-install --target=${target} "'"$(awk '\''$2 == "/" { print $1 }'\'' </proc/mounts)"'
|
|
}
|
|
|
|
osi-mk:grub-mkconfig() {
|
|
local arg_mountpoint=$1
|
|
arch-chroot -- "$arg_mountpoint" grub-mkconfig -o /boot/grub/grub.cfg
|
|
}
|
|
|
|
osi-mk:source-date-epoch() {
|
|
local arg_mountpoint=$1
|
|
|
|
# Backdate package install dates to 1 second before SOURCE_DATE_EPOCH.
|
|
local file
|
|
for file in "$arg_mountpoint"/var/lib/pacman/local/*/desc; do
|
|
awk -v maxdate="$((SOURCE_DATE_EPOCH-1))" '
|
|
BEGIN{
|
|
x=0
|
|
}
|
|
$0 == "%INSTALLDATE%" {
|
|
x=2
|
|
}
|
|
{
|
|
if (x == 1 && $0 > maxdate) {
|
|
print maxdate
|
|
} else {
|
|
print
|
|
}
|
|
x--
|
|
}
|
|
' <"$file" >"$file.tmp"
|
|
mv -T -- "$file.tmp" "$file"
|
|
touch --date="@$((SOURCE_DATE_EPOCH-1))" -- "$file"
|
|
done
|
|
|
|
# Backdate pacman.log to 1 second before SOURCE_DATE_EPOCH.
|
|
if [[ -f "$arg_mountpoint/var/log/pacman.log" ]]; then
|
|
local old new
|
|
old='^\[....-..-..T..:..:..[-+]....]'
|
|
new="[$(TZ=UTC date --date="@$((SOURCE_DATE_EPOCH-1))" --iso-8601=seconds | sed 's/:00$/00/')]"
|
|
sed -i "s/$old/$new/" -- "$arg_mountpoint/var/log/pacman.log"
|
|
touch --date="@$((SOURCE_DATE_EPOCH-1))" -- "$arg_mountpoint/var/log/pacman.log"
|
|
fi
|
|
|
|
# Backdate file timestamps to SOURCE_DATE_EPOCH.
|
|
case "${arg_conf[format]}" in
|
|
raw_btrfs)
|
|
# Ugg, it's lame that `find` can't find files newer than a
|
|
# timestamp without using a temporary file.
|
|
touch --date="@$SOURCE_DATE_EPOCH" -- "$arg_mountpoint/.source_date_epoch"
|
|
find "$arg_mountpoint" -xdev -depth \
|
|
-newer "$arg_mountpoint/.source_date_epoch" \
|
|
-exec touch --no-dereference --date="@$SOURCE_DATE_EPOCH" -- {} +
|
|
rm -f -- "$arg_mountpoint/.source_date_epoch"
|
|
touch --date="@$SOURCE_DATE_EPOCH" -- "$arg_mountpoint/"
|
|
;;
|
|
erofs)
|
|
# Nothing to do; mkfs.erofs supports SOURCE_DATE_EPOCH.
|
|
:
|
|
;;
|
|
esac
|
|
}
|
|
|
|
main() {
|
|
# argparse specifications ##############################################
|
|
#
|
|
# There got to be enough args with enough validation logic
|
|
# that the declare/parse/set/validate locations were all far
|
|
# enough apart that it was hard to maintain.
|
|
#
|
|
# So I factored out an argparse.sh library, so that I could
|
|
# keep the logic for a given argument close to itself.
|
|
#
|
|
# Please don't hate me for failing to KISS or remember that
|
|
# YAGNI; please trust that I did actually "NI".
|
|
|
|
opt_specs+=(': --inside : MOUNTPOINT : internal-use only')
|
|
local arg_mountpoint=
|
|
opt_visit:inside() { argparse:setmode inside; arg_mountpoint=$1; }
|
|
opt_final:inside() { :; }
|
|
|
|
opt_specs+=('-e : --edit : [BASE.img] : edit an existing image')
|
|
local arg_edit=false
|
|
local arg_edit_base=''
|
|
opt_visit:edit() { arg_edit=true; arg_edit_base=$1; }
|
|
opt_final:edit() {
|
|
if $arg_edit; then
|
|
# We set arg_file below in opt_positional().
|
|
if ! [[ -f ${arg_edit_base:-$arg_file} ]]; then
|
|
argparse:error 'Image must already exist to --edit: %s' "${arg_edit_base:-$arg_file}"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
opt_specs+=(': --disorderfs : : use disorderfs')
|
|
local arg_disorderfs=false
|
|
opt_visit:disorderfs() { arg_disorderfs=true; }
|
|
opt_final:disorderfs() { :; }
|
|
|
|
opt_specs+=('')
|
|
|
|
opt_specs+=('-d : --directory : OUTSIDE\:INSIDE : include the given directory')
|
|
local arg_directories=()
|
|
opt_visit:directory() {
|
|
if ! [[ -d "${1%:*}" ]]; then
|
|
argparse:error 'Directory does not exist: %s' "${1%:*}"
|
|
return
|
|
fi
|
|
arg_directories+=("$1")
|
|
}
|
|
opt_final:directory() { :; }
|
|
|
|
opt_specs+=('-m : --module : MOD.sh : include the given module')
|
|
local arg_modules=()
|
|
opt_visit:module() {
|
|
if ! [[ -f $1 ]]; then
|
|
argparse:error 'Module does not exist: %s' "$1"
|
|
return
|
|
fi
|
|
arg_modules+=("$1")
|
|
}
|
|
opt_final:module() { :; }
|
|
|
|
opt_specs+=('-p : --package : PKGNAME : include the given package (or group)')
|
|
local arg_packages=()
|
|
opt_visit:package() { arg_packages+=("$1"); }
|
|
opt_final:package() { :; }
|
|
|
|
opt_specs+=('-P : --package-file : PKG.pkg.tar.xz : include the given package file')
|
|
local arg_package_files=()
|
|
opt_visit:package-file() {
|
|
if ! [[ -f "$1" ]]; then
|
|
argparse:error 'Package file does not exist: %s' "$1"
|
|
return
|
|
fi
|
|
arg_package_files+=("$1")
|
|
}
|
|
opt_final:package-file() { :; }
|
|
|
|
opt_specs+=('-C : --conf : KEY=VAL : set set a config option')
|
|
declare -A arg_conf=(
|
|
# not package names
|
|
[arch]="$(uname -m)"
|
|
[format]=raw_btrfs
|
|
[genfstab]=true
|
|
[machine-id]=auto
|
|
|
|
# package names
|
|
[initramfs]=mkinitcpio
|
|
[dbus-units]=dbus-broker-units
|
|
)
|
|
if [[ "${SOURCE_DATE_EPOCH:-}" =~ ^([0-9]+|auto)$ ]]; then
|
|
arg_conf[SOURCE_DATE_EPOCH]="$SOURCE_DATE_EPOCH"
|
|
arg_orig=(--conf=SOURCE_DATE_EPOCH="${arg_conf[SOURCE_DATE_EPOCH]}" "${arg_orig[@]}")
|
|
fi
|
|
opt_visit:conf() {
|
|
local key val
|
|
key="${1%%=*}"
|
|
val="${1#*=}"
|
|
case "$key" in
|
|
arch)
|
|
if ! [[ -f "/usr/share/pacman/defaults/pacman.conf.$val" ]]; then
|
|
argparse:error 'Invalid --conf=arch= value: %q' "$val"
|
|
return
|
|
fi
|
|
;;
|
|
format)
|
|
case "$val" in
|
|
raw_btrfs) :;;
|
|
erofs) :;;
|
|
*) argparse:error 'Unrecognized --conf=format= value: %q' "$val"; return;;
|
|
esac
|
|
;;
|
|
bootloader)
|
|
case "$val" in
|
|
# This is the list as of GRUB 2.12-1.parabola1
|
|
grub-i386-pc) :;;
|
|
grub-i386-efi) :;;
|
|
grub-i386-emu) :;;
|
|
grub-i386-xen) :;;
|
|
grub-i386-qemu) :;;
|
|
grub-i386-ieee1275) :;;
|
|
grub-i386-coreboot) :;;
|
|
grub-i386-multiboot) :;;
|
|
|
|
grub-x86_64-efi) :;;
|
|
grub-x86_64-emu) :;;
|
|
grub-x86_64-xen) :;;
|
|
|
|
grub-arm-emu) :;;
|
|
grub-arm-uboot) :;;
|
|
grub-arm-uboot-am335x_bone) :;;
|
|
grub-arm-uboot-omap3_beagle) :;;
|
|
grub-arm-uboot-omap3_beagle_xm) :;;
|
|
grub-arm-uboot-omap3_beagle_xm_ab) :;;
|
|
grub-arm-uboot-udoo) :;;
|
|
|
|
none) :;;
|
|
*) argparse:error 'Unrecognized --conf=bootloader= value: %q' "$val"; return;;
|
|
esac
|
|
;;
|
|
genfstab)
|
|
case "${val,,}" in
|
|
1|t|true|y|yes) val=true;;
|
|
0|f|false|n|no) val=false;;
|
|
*) argparse:error 'Unrecognized --conf=genfstab= value: %q' "$val"; return;;
|
|
esac
|
|
;;
|
|
machine-id)
|
|
if ! [[ "$val" =~ ^(auto|none|[0-9a-f]{32})$ ]]; then
|
|
argparse:error 'Invalid --conf=machine-id= value: %q' "$val"
|
|
return
|
|
fi
|
|
;;
|
|
SOURCE_DATE_EPOCH)
|
|
if ! [[ "$val" =~ ^([0-9]+|auto|)$ ]]; then
|
|
argparse:error 'Invalid --conf=SOURCE_DATE_EPOCH= value: %q' "$val"
|
|
return
|
|
fi
|
|
;;
|
|
esac
|
|
arg_conf["$key"]="$val";
|
|
}
|
|
opt_final:conf() {
|
|
if [[ -z "${arg_conf[bootloader]:-}" ]]; then
|
|
case "${arg_conf[arch]}" in
|
|
x86_64|i686) arg_conf[bootloader]=grub-i386-pc;;
|
|
armv7h) arg_conf[bootloader]=grub-arm-uboot;;
|
|
esac
|
|
fi
|
|
case "${arg_conf[arch]}" in
|
|
i686)
|
|
case "${arg_conf[bootloader]}" in
|
|
grub-i386-*) :;;
|
|
grub-*) argparse:error 'Invalid GRUB platform for CPU architecture: %q %q' "${arg_conf[arch]}" "${arg_conf[bootloader]}";;
|
|
esac
|
|
;;
|
|
x86_64)
|
|
case "${arg_conf[bootloader]}" in
|
|
grub-i386-*) :;;
|
|
grub-x86_64-*) :;;
|
|
grub-*) argparse:error 'Invalid GRUB platform for CPU architecture: %q %q' "${arg_conf[arch]}" "${arg_conf[bootloader]}";;
|
|
esac
|
|
;;
|
|
armv7h)
|
|
case "${arg_conf[bootloader]}" in
|
|
grub-arm-*) :;;
|
|
grub-*) argparse:error 'Invalid GRUB platform for CPU architecture: %q %q' "${arg_conf[arch]}" "${arg_conf[bootloader]}";;
|
|
esac
|
|
;;
|
|
esac
|
|
case "${arg_conf[format]}" in
|
|
raw_btrfs)
|
|
if [[ -z ${arg_conf[size]:-} ]]; then
|
|
argparse:error 'Must specify --conf=size= when creating a new image'
|
|
fi
|
|
;;
|
|
erofs)
|
|
if $arg_edit; then
|
|
argparse:error '--conf=format=erofs does not support --edit'
|
|
fi
|
|
if [[ ${arg_conf[bootloader]} != none ]]; then
|
|
argparse:error '--conf=format=erofs requires --conf=bootloader=none'
|
|
fi
|
|
;;
|
|
esac
|
|
}
|
|
|
|
local arg_file
|
|
opt_positional() {
|
|
if (( $# != 1 )); then
|
|
argparse:error "Expected 1 positional argument, got %d: %s" "$#" "${*@Q}"
|
|
return
|
|
fi
|
|
arg_file=$1
|
|
if [[ "$opt_mode" != inside ]]; then
|
|
if [[ ( $arg_edit = false || -n $arg_edit_base ) && -e $arg_file ]]; then
|
|
argparse:error 'Image file already exists, refusing to overwrite: %s' "$arg_file"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# actually parse the args ##############################################
|
|
|
|
local arg_orig=("$@")
|
|
argparse outside "$@"
|
|
|
|
# main ################################################################
|
|
|
|
case "$opt_mode" in
|
|
error)
|
|
osi.sh:print "Try '%q --help' for more information" "${0##*/}" >&2
|
|
return $EXIT_INVALIDARGUMENT
|
|
;;
|
|
version)
|
|
osi.sh:print "%s (osi-tools) %s" "$NAME" "$VERSION"
|
|
return $EXIT_SUCCESS
|
|
;;
|
|
help)
|
|
osi.sh:print 'Usage: %s [OPTIONS] FILENAME.img' "${0##*/}"
|
|
osi.sh:print 'Operating System Image: Make'
|
|
echo
|
|
osi.sh:print 'Create a mountable, bootable OS image.'
|
|
echo
|
|
osi.sh:print 'OPTIONS:'
|
|
echo "${opt_flaghelp}" | grep -v -e --inside
|
|
return $EXIT_SUCCESS
|
|
;;
|
|
|
|
# main code starts here
|
|
outside) # the part that runs as a normal user without the image mounted
|
|
mount_dev="$arg_file"
|
|
mount_opt=''
|
|
|
|
beg_indent 'format:before'
|
|
{
|
|
case "${arg_conf[format]}" in
|
|
raw_btrfs)
|
|
if $arg_edit; then
|
|
if [[ -n $arg_edit_base ]]; then
|
|
cp -T --reflink -- "$arg_edit_base" "$arg_file"
|
|
fi
|
|
if [[ -n ${arg_conf[fsuuid]:-} ]]; then
|
|
# Explicit new FSUUID.
|
|
btrfstune -f -U "${arg_conf[fsuuid]:-}" "$arg_file"
|
|
elif [[ -n $arg_edit_base ]]; then
|
|
# Random new FSUUID.
|
|
btrfstune -fu "$arg_file"
|
|
fi
|
|
if [[ -n ${arg_conf[size]:-} ]]; then
|
|
# Calculate sizes in exact bytes now, to avoid any discrepancies
|
|
# between truncate(1) and btrfs-filesystem(8).
|
|
# Use truncate(1) to do this. It's a little gross,
|
|
# but because TMPDIR is likely on tmpfs, it's time-cheap,
|
|
# and because of sparse files, it's space-cheap.
|
|
tmpfile=$(mktemp -t -- "${0##*/}.XXXXXXXXXX")
|
|
trap "rm -- ${tmpfile@Q}" EXIT
|
|
case "${arg_conf[size]}" in
|
|
'+'*|'-'*|'<'*|'>'*|'/'*|'%'*)
|
|
truncate --reference="$arg_file" --size="${arg_conf[size]}" -- "$tmpfile";;
|
|
*)
|
|
truncate --size="${arg_conf[size]}" -- "$tmpfile";;
|
|
esac
|
|
old_size=$(stat --format='%s' -- "$arg_file")
|
|
new_size=$(stat --format='%s' -- "$tmpfile")
|
|
rm -- "$tmpfile"
|
|
trap - EXIT
|
|
|
|
# Do the resize
|
|
arg_mountpoint=$(mktemp -dt -- "${0##*/}.XXXXXXXXXX")
|
|
trap "rmdir -- ${arg_mountpoint@Q}" EXIT
|
|
if (( new_size > old_size )); then
|
|
truncate --size="$new_size" -- "$arg_file"
|
|
osi.sh:sudo -- "${install_prefix}/bin/osi-mount" --root -- "$arg_file" "$arg_mountpoint" btrfs filesystem resize max "$arg_mountpoint"
|
|
elif (( new_size < old_size )); then
|
|
osi.sh:sudo -- "${install_prefix}/bin/osi-mount" --root -- "$arg_file" "$arg_mountpoint" btrfs filesystem resize "$new_size" "$arg_mountpoint"
|
|
truncate --size="$new_size" -- "$arg_file"
|
|
fi
|
|
rmdir -- "$arg_mountpoint"
|
|
trap - EXIT
|
|
fi
|
|
else
|
|
truncate --size="${arg_conf[size]}" -- "$arg_file"
|
|
mkfs.btrfs ${arg_conf[fsuuid]:+"--uuid=${arg_conf[fsuuid]}"} -- "$arg_file"
|
|
fi
|
|
;;
|
|
erofs)
|
|
if [[ -z "${arg_conf[fsuuid]:-}" ]]; then
|
|
arg_conf[fsuuid]=$(uuidgen)
|
|
arg_orig=(--conf=fsuuid="${arg_conf[fsuuid]}" "${arg_orig[@]}")
|
|
fi
|
|
|
|
mount_dev=$(mktemp -dt -- "${0##*/}.XXXXXXXXXX")
|
|
# Make our own tmpfs because $TMPDIR might be mounted
|
|
# with 'noexec' or something. Also, so we can clean it
|
|
# up without a `sudo rm -rf`.
|
|
osi.sh:sudo mount -t tmpfs tmpfs:osi-mk "$mount_dev"
|
|
trap "osi.sh:sudo umount ${mount_dev@Q}; rmdir -- ${mount_dev@Q}" EXIT
|
|
mount_opt=bind
|
|
;;
|
|
esac
|
|
} end_indent
|
|
|
|
arg_mountpoint=$(mktemp -dt -- "${0##*/}.XXXXXXXXXX")
|
|
r=0
|
|
osi.sh:sudo -- "${install_prefix}/bin/osi-mount" --root \
|
|
--rwdir="${TMPDIR:-/tmp}" \
|
|
--rwdir=/var/cache/pacman/pkg \
|
|
--rwdir=/etc/pacman.d/gnupg \
|
|
--options="$mount_opt" \
|
|
-- \
|
|
"$mount_dev" "$arg_mountpoint" \
|
|
"${BASH_SOURCE[0]}" --inside="$arg_mountpoint" \
|
|
"${arg_orig[@]}" || r=$?
|
|
rmdir -- "$arg_mountpoint"
|
|
if (( r != 0 )); then
|
|
return $r
|
|
fi
|
|
|
|
beg_indent 'format:after'
|
|
{
|
|
case "${arg_conf[format]}" in
|
|
erofs)
|
|
if [[ "${arg_conf[SOURCE_DATE_EPOCH]:-}" == auto ]]; then
|
|
local file
|
|
for file in "$mount_dev"/var/lib/pacman/local/*/desc; do
|
|
arg_conf[SOURCE_DATE_EPOCH]="$(sed -n '/^%INSTALLDATE%$/{n;p;}' -- "$file")"
|
|
break
|
|
done
|
|
fi
|
|
if [[ -n "${arg_conf[SOURCE_DATE_EPOCH]:-}" ]]; then
|
|
export SOURCE_DATE_EPOCH="${arg_conf[SOURCE_DATE_EPOCH]}"
|
|
fi
|
|
tmpdir=$(mktemp -dt -- "${0##*/}.XXXXXXXXXX")
|
|
trap "sudo umount ${mount_dev@Q}; rmdir -- ${mount_dev@Q}; rm -f -- ${tmpdir@Q}/erofs.img; rmdir -- ${tmpdir@Q}" EXIT
|
|
osi.sh:sudo mkfs.erofs \
|
|
-U"${arg_conf[fsuuid]}" \
|
|
${arg_conf[erofs_compression]:+"-z${arg_conf[erofs_compression]}"} \
|
|
"$tmpdir/erofs.img" "$mount_dev"
|
|
cp -T "$tmpdir/erofs.img" "$arg_file"
|
|
;;
|
|
esac
|
|
} end_indent
|
|
|
|
osi.sh:print '%s Done' "$NAME"
|
|
;;
|
|
inside) # the part that runs as root with the image mounted
|
|
osi.sh:needs_sudo
|
|
|
|
### Load modules ###
|
|
packages=("${arg_packages[@]}")
|
|
pre_install=()
|
|
post_install=(
|
|
10:osi-mk:machine-id
|
|
50:osi-mk:directories
|
|
)
|
|
|
|
if "${arg_conf[genfstab]}"; then
|
|
if ! $arg_edit || [[ -n $arg_edit_base ]] || [[ -n "${arg_conf[fsuuid]:-}" ]]; then
|
|
post_install+=(10:osi-mk:genfstab)
|
|
fi
|
|
fi
|
|
case "${arg_conf[format]}" in
|
|
raw_btrfs)
|
|
packages+=(btrfs-progs)
|
|
;;
|
|
erofs)
|
|
packages+=(erofs-utils)
|
|
;;
|
|
esac
|
|
case "${arg_conf[bootloader]}" in
|
|
grub-*)
|
|
if [[ "${arg_conf[bootloader]}" == grub-arm-uboot-* ]]; then
|
|
packages+=("grub-${arg_conf[bootloader]#grub-arm-uboot-}")
|
|
else
|
|
packages+=(grub)
|
|
fi
|
|
post_install+=(88:osi-mk:grub-mkconfig) # before 89:osi-mk:source-date-epoch
|
|
if ! $arg_edit; then
|
|
post_install+=(87:osi-mk:grub-install) # before '88:osi-mk:grub-mkconfig'
|
|
fi
|
|
;;
|
|
esac
|
|
case "${arg_conf[initramfs]:-}" in
|
|
mkinitcpio)
|
|
pre_install+=(10:osi-mk:mkinitcpio)
|
|
;;
|
|
esac
|
|
if [[ -n "${arg_conf[hostname]:-}" ]]; then
|
|
post_install+=(10:osi-mk:hostname)
|
|
fi
|
|
if [[ -n "${arg_conf[SOURCE_DATE_EPOCH]:-}" ]]; then
|
|
post_install+=(89:osi-mk:source-date-epoch)
|
|
fi
|
|
|
|
local pkgfile pkgdeps
|
|
for pkgfile in "${arg_package_files[@]}"; do
|
|
mapfile -t pkgdeps < <(bsdtar xfO "$pkgfile" .PKGINFO | sed -n 's/^depend = //p')
|
|
cache_packages+=("${pkgdeps[@]}")
|
|
done
|
|
|
|
for module in "${arg_modules[@]}"; do
|
|
load_module "$module"
|
|
done
|
|
cache_packages+=("${packages[@]}")
|
|
|
|
### Disorderfs ###
|
|
if $arg_disorderfs; then
|
|
orig_arg_mountpoint=$arg_mountpoint
|
|
arg_mountpoint=$(mktemp -dt -- "${0##*/}.XXXXXXXXXX")
|
|
disorderfs --multi-user=yes --shuffle-dirents=yes "$orig_arg_mountpoint" "$arg_mountpoint"
|
|
trap "fusermount -u ${arg_mountpoint@Q}; rmdir ${arg_mountpoint@Q}" EXIT
|
|
fi
|
|
|
|
pacman_conf="/usr/share/pacman/defaults/pacman.conf.${arg_conf[arch]}"
|
|
|
|
### Download ###
|
|
beg_indent 'download:repos'
|
|
{
|
|
# Download syncdbs to the image
|
|
mkdir -p -- "$arg_mountpoint"/var/{lib/pacman,log}
|
|
pacman -r "$arg_mountpoint" --config="$pacman_conf" \
|
|
-Sy --noconfirm
|
|
} end_indent
|
|
beg_indent 'download:check-config'
|
|
{
|
|
# Validate that the user specified an answer to
|
|
# every question that pacman asks.
|
|
opt_fail=false
|
|
while read -r -a options; do
|
|
name="${options[0]%:}"
|
|
options=("${options[@]:1}")
|
|
|
|
base=${name%%[<>=]*}
|
|
if osi.sh:in_array "${arg_conf["$base"]:-}" "${options[@]}" "${options[@]#*/}"; then
|
|
osi.sh:print 'inserting package %s=%s' "$name" "${arg_conf["$base"]}"
|
|
packages+=("${arg_conf["$base"]}")
|
|
cache_packages+=("${arg_conf["$base"]}")
|
|
else
|
|
osi.sh:error 0 "must set option '%q' to one of [%s]" "$base" "${options[*]}"
|
|
opt_fail=true
|
|
fi
|
|
done < <("${install_prefix}/lib/pacman-choices" \
|
|
-r "$arg_mountpoint" --config="$pacman_conf" \
|
|
--oneline -- "${cache_packages[@]}")
|
|
if [[ $opt_fail == true ]]; then
|
|
exit $EXIT_NOTCONFIGURED
|
|
fi
|
|
} end_indent
|
|
beg_indent 'download:packages'
|
|
{
|
|
if (( ${#cache_packages[@]} > 0 )); then # this check is important for --edit
|
|
# Download needed packages to the host cache
|
|
pacman -r "$arg_mountpoint" --config="$pacman_conf" \
|
|
-Syw --noconfirm -- "${cache_packages[@]}"
|
|
|
|
# Copy needed packages from host cache to image cache
|
|
mkdir -p -- "$arg_mountpoint"/var/cache/pacman/pkg
|
|
pacman -r "$arg_mountpoint" --config="$pacman_conf" \
|
|
-Sp --print-format='%l' -- "${cache_packages[@]}" \
|
|
| sed -En 's,^file://(.*),\1\n\1.sig,p' \
|
|
| xargs -d $'\n' -r cp -t "$arg_mountpoint/var/cache/pacman/pkg" --
|
|
fi
|
|
} end_indent
|
|
|
|
if [[ "${arg_conf[SOURCE_DATE_EPOCH]:-}" =~ ^[0-9]+$ ]]; then
|
|
osi.sh:print '%s SOURCE_DATE_EPOCH=%s' "$NAME" "${arg_conf[SOURCE_DATE_EPOCH]}"
|
|
export SOURCE_DATE_EPOCH="${arg_conf[SOURCE_DATE_EPOCH]}"
|
|
fi
|
|
|
|
### pre_install ###
|
|
while IFS=: read -r n fn; do
|
|
beg_indent 'pre_install:%s:%s' "$n" "$fn"
|
|
(
|
|
osi.sh:print Begin
|
|
"$fn" "$arg_mountpoint"
|
|
osi.sh:print End
|
|
) end_indent
|
|
done < <([[ "${#pre_install[@]}" == 0 ]] || printf '%s\n' "${pre_install[@]}" | sort)
|
|
rm -f -- "$arg_mountpoint"/var/log/pacman.log
|
|
|
|
### Install ###
|
|
beg_indent 'install'
|
|
{
|
|
if (( ${#packages[@]} > 0 )); then # this check is important for --edit
|
|
local pacstrap_args=(
|
|
-G # don't copy the host's pacman keyring
|
|
-M # don't copy the host's mirrorlist
|
|
-C "$pacman_conf"
|
|
--
|
|
"$arg_mountpoint"
|
|
--hookdir="$arg_mountpoint/etc/pacman.d/hooks" # hack around https://bugs.archlinux.org/task/49347
|
|
--needed # for --edit
|
|
"${packages[@]}"
|
|
)
|
|
TMPDIR='' pacstrap "${pacstrap_args[@]}"
|
|
fi
|
|
if [[ -f "$arg_mountpoint/var/log/pacman.log" ]]; then
|
|
sed -i "s:${arg_mountpoint}:/mnt:g" -- "$arg_mountpoint/var/log/pacman.log"
|
|
fi
|
|
if (( ${#arg_package_files[@]} > 0 )); then
|
|
dir="$(mktemp -d -- "$arg_mountpoint/var/tmp/package-files.XXXXXXXXXX")"
|
|
trap "rm -rf -- ${dir@Q}" EXIT
|
|
cp -t "$dir" -- "${arg_package_files[@]}"
|
|
local arg filelist=()
|
|
for arg in "${arg_package_files[@]}"; do
|
|
filelist+=("/var/tmp/${dir##*/var/tmp/}/${arg##*/}")
|
|
done
|
|
arch-chroot -- "$arg_mountpoint" pacman -U --noconfirm -- "${filelist[@]}"
|
|
rm -rf -- "$dir"
|
|
trap - EXIT
|
|
fi
|
|
} end_indent
|
|
|
|
if [[ "${arg_conf[SOURCE_DATE_EPOCH]:-}" == auto ]]; then
|
|
# set it to 1 second after the last timestamp from any
|
|
# package (that extra second is so that post-install
|
|
# things can be timestamped after the package files).
|
|
arg_conf[SOURCE_DATE_EPOCH]=$(($({
|
|
zcat "$arg_mountpoint"/var/lib/pacman/local/*/mtree | grep -o 'time=[0-9]*' | cut -d= -f2
|
|
cat /var/lib/pacman/local/*/desc | sed -n '/^%BUILDDATE%$/{n;p;}'
|
|
} | sort -n | tail -n1) + 1))
|
|
fi
|
|
if [[ -n "${arg_conf[SOURCE_DATE_EPOCH]:-}" ]]; then
|
|
osi.sh:print '%s SOURCE_DATE_EPOCH=%s' "$NAME" "${arg_conf[SOURCE_DATE_EPOCH]}"
|
|
export SOURCE_DATE_EPOCH="${arg_conf[SOURCE_DATE_EPOCH]}"
|
|
fi
|
|
|
|
### post_install ###
|
|
while IFS=: read -r n fn; do
|
|
beg_indent 'post_install:%s:%s' "$n" "$fn"
|
|
(
|
|
osi.sh:print Begin
|
|
"$fn" "$arg_mountpoint"
|
|
osi.sh:print End
|
|
) end_indent
|
|
done < <([[ "${#post_install[@]}" == 0 ]] || printf '%s\n' "${post_install[@]}" | sort)
|
|
;;
|
|
|
|
*) osi.sh:bug 'unknown opt_mode: %s' "$opt_mode";;
|
|
esac
|
|
}
|
|
|
|
main "$@"
|