bake

#!/bin/bash
set -euo pipefail
IFS=$'\n\t'

ROOT_DIR="$(dirname $(readlink -f "${BASH_SOURCE[0]}"))"

STATUS=$ROOT_DIR/.status
RPIBAKE=rpibake
PI_UID=1000 # The user id of the regular Raspberry Pi user, pi.

source $ROOT_DIR/vars

Q_IMG_BASENAME=$(basename -- ${Q_IMG_URL})
Q_IMG_EXTENSION="${Q_IMG_BASENAME#*.}"
Q_IMG_BASE=$(basename -- ${Q_IMG_URL} .${Q_IMG_EXTENSION})
Q_IMG=${ROOT_DIR}/binaries/${Q_IMG_BASE}.img

CLIENT_HOSTNAME=localhost

function debug() {
    echo $@ 1>&2
}

function help() {
    debug "bake"
    debug "  prerequisites          Install host system prerequisites to run QEMU."
    debug "  image"
    debug "    reset                Download the image specified in the configuration and reset local changes."
    debug "    expand BYTES         Expand the image to a given size in bytes."
    debug "    mount                Mount the image."
    debug "    init                 Store the SSH installer into image."
    debug "    umount               Unmount the image."
    debug "    userpass USER PASS   Configure autoconfiguration to create user with password."
    debug "  qemu                   Run Raspberry Pi OS in QEMU."
    debug "    versatile            Run with a more generic arm1176 configuration."
    debug "    raspi3b              Run QEMU with a Raspberru Pi 3 Model B native emulation configuration."
    debug "  wait                   Wait until SSH succeeds."
    debug "  ssh                    SSH into the guest system."
    debug "  rsync"
    debug "    ssh                  Invoke rsync over SSH."
    debug "  halt                   SSH into the guest system and turn it off."
    debug "  get"
    debug "    user                 Get the client user name."
    debug "    ssh"
    debug "      origin             Get the SSH destination user@hostname."
    debug "      port               Get the SSH port."
    debug "      public             Get the location of the public key used for SSH."
    debug "      private            Get the location of the private key used for SSH."
    debug "    mount"
    debug "      loop               Get the loop device path if it exist."
    debug "      boot               Get the mount location of the boot partition."
    debug "      user               Get the mount location of the user partition."
    debug "    native"
    debug "      kernel             Get the kernel file to use with native emulation."
    debug "      dtb                Get the device tree binary file to use with native emulation."
    debug "  set"
    debug "    user                 Set the client user name."
    debug "    ssh"
    debug "      public FILE        Set the location of the public key used for SSH."
    debug "      private FILE       Set the location of the private key used for SSH."
    debug "    native"
    debug "      kernel FILE        Set the kernel file to use with native emulation."
    debug "      dtb FILE           Set the device tree binary file to use with native emulation."
    exit -1
}

function pipe_ssh() {
    variable_get_ssh_private
    variable_get_client_user

    set +e
    ssh \
        ${CLIENT_USER}@${CLIENT_HOSTNAME} \
        -p ${Q_HOST_SSH_PORT} \
        -i ${SSH_PRIVATE} \
        -o StrictHostKeyChecking=no \
        -o 'ConnectionAttempts 1000' \
        $@ \
    ;
    RETCODE=$?
    set -e
    return $RETCODE
}

function pipe_ssh_exit() {
    pipe_ssh -T <<EOF
exit
EOF
}

function pipe_wait() {
    until pipe_ssh_exit
    do
        sleep 1
    done
}

function pipe_rsync_ssh() {
    variable_get_ssh_private
    rsync -e "ssh -p ${Q_HOST_SSH_PORT} -i ${SSH_PRIVATE}" $@
}

function trim() {
    echo "$1" | sed -re 's/^[\t\r\n ]*//' | sed -re 's/[\t\r\n ]*$//'
}

function partition_count() {
    IMG=$1
    partx $IMG -g | wc -l
}

function partition_query() {
    IMG=$1
    PARTITION=$2
    FIELD=$3
    trim "$(partx $IMG --bytes -g -n $PARTITION -o $FIELD)"
}

function variable_set_ssh_public() {
    crudini --set $STATUS $RPIBAKE SSH_PUBLIC $1
}

function variable_set_ssh_private() {
    crudini --set $STATUS $RPIBAKE SSH_PRIVATE $1
}

function variable_set_user() {
    crudini --set $STATUS $RPIBAKE CLIENT_USER $1
}

function variable_set_native_kernel() {
    crudini --set $STATUS $RPIBAKE NATIVE_KERNEL $1
}

function variable_set_native_dtb() {
    crudini --set $STATUS $RPIBAKE NATIVE_DTB $1
}

function variable_get_ssh_public() {
    (crudini --get --existing $STATUS $RPIBAKE SSH_PUBLIC > /dev/null) || (debug "Did you forget to set the ssh public key 'set ssh public'?"; exit 1)
    export SSH_PUBLIC=$(crudini --get --existing $STATUS $RPIBAKE SSH_PUBLIC)
}

function variable_get_ssh_private() {
    (crudini --get --existing $STATUS $RPIBAKE SSH_PRIVATE > /dev/null) || (debug "Did you forget to set the ssh private key 'set ssh private'?"; exit 1)
    export SSH_PRIVATE=$(crudini --get --existing $STATUS $RPIBAKE SSH_PRIVATE)
}

function variable_get_client_user() {
    if crudini --get --existing $STATUS $RPIBAKE CLIENT_USER >& /dev/null
    then
        export CLIENT_USER=$(crudini --get --existing $STATUS $RPIBAKE CLIENT_USER)
    else
        export CLIENT_USER=pi
    fi
}

function variable_get_native_kernel() {
    (crudini --get --existing $STATUS $RPIBAKE NATIVE_KERNEL > /dev/null) || (debug "Did you forget to set the native kernel 'set native kernel'?"; exit 1)
    export NATIVE_KERNEL=$(crudini --get --existing $STATUS $RPIBAKE NATIVE_KERNEL)
}

function variable_get_native_dtb() {
    (crudini --get --existing $STATUS $RPIBAKE NATIVE_DTB > /dev/null) || (debug "Did you forget to set the native dtb 'set native dtb'?"; exit 1)
    export NATIVE_DTB=$(crudini --get --existing $STATUS $RPIBAKE NATIVE_DTB)
}

function image_variable_set() {
    crudini --set $STATUS $RPIBAKE LOOPBACK $LOOPBACK
    crudini --set $STATUS $RPIBAKE PART_BOOT $PART_BOOT
    crudini --set $STATUS $RPIBAKE PART_USER $PART_USER
}

function image_variable_del() {
    crudini --del $STATUS $RPIBAKE LOOPBACK
    crudini --del $STATUS $RPIBAKE PART_BOOT
    crudini --del $STATUS $RPIBAKE PART_USER
}

function image_variable_get() {
    export LOOPBACK=$(crudini --get $STATUS $RPIBAKE LOOPBACK)
    export PART_BOOT=$(crudini --get $STATUS $RPIBAKE PART_BOOT)
    export PART_USER=$(crudini --get $STATUS $RPIBAKE PART_USER)
}

function stage_prerequisites() {
    sudo apt-get -y install \
        crudini \
        xz-utils \
    ;
    case $(lsb_release --short --id) in
    "Ubuntu")
        local release=$(lsb_release --short --release)
        local major=$(echo $release | cut -f 1 -d '.')
        local minor=$(echo $release | cut -f 2 -d '.')
        if [[ ( "$major" -ge "22" && "$minor" -ge "4" ) || "$major" -gt "22" ]]
        then
            sudo apt-get -y install \
                qemu-utils \
                qemu-system-arm \
                qemu-system-aarch64 \
            ;
        else
            debug "This version of Ubuntu may not have QEMU 6.2.0 or later available via a repository."
            debug "QEMU will not be installed automatically."
        fi
        ;;
    esac
}

function stage_image() {
    if [ "$#" -lt 1 ]; then
        debug "Missing image argument."
        help
    fi
    COMMAND=$1
    shift
    case ${COMMAND} in
        reset)
            stage_image_reset $@
            ;;
        expand)
            stage_image_expand $@
            ;;
        mount)
            stage_image_mount $@
            ;;
        init)
            stage_image_init $@
            ;;
        umount)
            stage_image_umount $@
            ;;
        userpass)
            stage_image_userpass $@
            ;;
        *)
            debug "Unknown image command \"${COMMAND}\"."
            help
            ;;
    esac
}

function stage_image_reset() {
    if [ ! -f "${HOME}/RaspberryPiOS/${Q_IMG_BASE}.img" ]
    then
        mkdir -p "${HOME}/RaspberryPiOS"
        pushd "${HOME}/RaspberryPiOS" >& /dev/null
            debug "Download ${Q_IMG_URL}"
            wget --continue "${Q_IMG_URL}"

            case "${Q_IMG_EXTENSION}" in
                zip)
                    debug "Unzip ${Q_IMG_BASE}.img"
                    time unzip "${Q_IMG_BASE}.zip"
                    ;;
                img.xz)
                    debug "Decompress ${Q_IMG_BASE}.img"
                    time unxz -k "${Q_IMG_BASE}.img.xz"
                    ;;
                *)
                    debug "Unandled image file extension ${Q_IMG_EXTENSION}"
                    exit -1
            esac
        popd >& /dev/null
    fi

    debug "Copy ${Q_IMG_BASE}.img"
    mkdir -p "${ROOT_DIR}/binaries"
    pushd "${ROOT_DIR}/binaries" >& /dev/null
        rm -f "${Q_IMG_BASE}.img"
        time cp "${HOME}/RaspberryPiOS/${Q_IMG_BASE}.img" .
    popd >& /dev/null
}

function stage_image_expand() {
    DISK_SIZE=$1
    shift

    SECTOR_SIZE=512

    # Verify that the new disk size is in a multiple of the sector size.
    if [ "0" -ne $(( ${DISK_SIZE} % ${SECTOR_SIZE})) ]
    then
        debug "The specified disk size ${DISK_SIZE} is not divisible by the sector size ${SECTOR_SIZE}."
        exit -1
    fi

    # Verify that the image contains exactly partitions 1 and 2.
    COUNT_PARTITION=$(partition_count ${Q_IMG})
    if [ 2 -ne $COUNT_PARTITION ]
    then
        debug "Expected to find 2 partitions."
        exit -1
    fi
    for i in $(seq $COUNT_PARTITION)
    do
        case "$i" in
        1) # This should map to the boot partition.
            ;&
        2) # This should map to the main partition.
            debug "Partition $i"
            debug "start    $(partition_query ${Q_IMG} $i START)s"
            debug "end      $(partition_query ${Q_IMG} $i END)s"
            debug "sectors  $(partition_query ${Q_IMG} $i SECTORS)s"
            debug "size     $(partition_query ${Q_IMG} $i SIZE)"
            debug "name     $(partition_query ${Q_IMG} $i NAME)"
            debug "uuid     $(partition_query ${Q_IMG} $i UUID)"
            debug
            ;;
        *)
            debug "Unexpected partition number $i."
            exit -1
            ;;
        esac
    done

    # Verify that the partition is actually being expanded and not shrunk.
    DISK_SIZE_CURRENT=$(stat -c "%s" ${Q_IMG})
    if [ ${DISK_SIZE} -lt ${DISK_SIZE_CURRENT} ]
    then
        debug "The requested disk size ${DISK_SIZE} is less than the current disk size ${DISK_SIZE_CURRENT}."
        help
    fi

    # Expand disk image file.
    qemu-img resize -f raw ${Q_IMG} ${DISK_SIZE} 1>&2

    # Expand partition.
    DISK_SIZE_SECTORS=$(( ${DISK_SIZE} / ${SECTOR_SIZE} ))
    DISK_END_SECTORS=$(( ${DISK_SIZE_SECTORS} - 1 )) # The minus 1 is because this is the last actual sector's number.
    parted ${Q_IMG} resizepart 2 ${DISK_END_SECTORS}s

    debug "Loop back image."
    LOOPBACK=$(sudo losetup -f)
    sudo losetup -P $LOOPBACK $Q_IMG
    PART_BOOT=$(mktemp -d)
    PART_USER=$(mktemp -d)

    function unloop_disks() {
        debug "Unloop image."
        sudo losetup -d $LOOPBACK
    }
    trap unloop_disks EXIT

    # Filesystem check before.
    sudo e2fsck -f ${LOOPBACK}p2

    # Expand filesystem.
    sudo resize2fs ${LOOPBACK}p2

    # Filesystem check and after.
    sudo e2fsck -f ${LOOPBACK}p2

    trap - EXIT
    unloop_disks
}

function stage_image_mount() {
    debug "Loop back image."
    LOOPBACK=$(sudo losetup -f)
    sudo losetup -P $LOOPBACK $Q_IMG
    PART_BOOT=$(mktemp -d)
    PART_USER=$(mktemp -d)

    function unloop_image() {
        debug "Unloop image."
        sudo losetup -d $LOOPBACK
    }
    trap unloop_image EXIT

    debug "Set mount information."
    image_variable_set

    debug "Mount image."
    sudo mount ${LOOPBACK}p1 $PART_BOOT
    sudo mount ${LOOPBACK}p2 $PART_USER

    trap - EXIT
    # Don't run unloop_image.
}

function stage_image_init() {
    variable_get_ssh_public
    image_variable_get

    debug "Install SSH keys."
    sudo -u \#$PI_UID mkdir -p $PART_USER/home/pi/.ssh
    sudo -u \#$PI_UID cp ${SSH_PUBLIC} $PART_USER/home/pi/.ssh/authorized_keys

    debug "Install SSH server installer."
    sudo mv $PART_USER/etc/rc.local $PART_USER/etc/rc.local.original
    sudo cp $ROOT_DIR/mount/rc.local $PART_USER/etc/
}

function stage_image_umount() {
    debug "Get mount information."
    image_variable_get
 
    debug "Unmount image."
    sudo umount $PART_BOOT
    sudo umount $PART_USER

    debug "Unloop image."
    sudo losetup -d $LOOPBACK

    debug "Delete mount information."
    image_variable_del
}

function stage_image_userpass() {
    if [ "$#" -lt 2 ]; then
        debug "Missing user or password arguments."
        help
    fi

    local NEW_USER=$1
    local NEW_PASSWD=$2
    shift 2

    debug "Configuring new user."
    image_variable_get
    echo | sudo tee -a $PART_BOOT/userconf <<EOF
$NEW_USER:$NEW_PASSWD
EOF
}

function stage_qemu_versatile() {
    # The maximum number of CPUs is 1.
    # The maximum amount of memory is 256MB.
    # iperf reports a network throughput of ~25 Mbits/sec.
    sudo qemu-system-arm \
        -M versatilepb \
        -cpu arm1176 \
        -m 256 \
        -append "root=/dev/sda2 rootfstype=ext4 rw" \
        -net nic \
        -net user,hostfwd=tcp::$Q_HOST_SSH_PORT-:22 \
        -net tap,ifname=vnet0,script=no,downscript=no \
        -drive file=$Q_IMG,format=raw \
        -dtb ${ROOT_DIR}/qemu-rpi-kernel/${Q_DTB}.dtb \
        -kernel ${ROOT_DIR}/qemu-rpi-kernel/${Q_KERNEL} \
        -no-reboot \
        $@ \
    ;
}

function stage_qemu_raspi3b() {
    variable_get_native_kernel
    variable_get_native_dtb

    # iperf reports a network throughput of ~600-850 Kbits/sec.
    sudo qemu-system-aarch64 \
        -M raspi3b \
        -append "rw earlyprintk loglevel=8 console=ttyAMA0,115200 dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootdelay=1" \
        -kernel "${NATIVE_KERNEL}" \
        -dtb "${NATIVE_DTB}" \
        -sd "${Q_IMG}" \
        -m 1G \
        -smp 4 \
        -serial stdio \
        -usb \
        -device usb-mouse \
        -device usb-kbd \
        -device usb-net,netdev=net0 \
        -device usb-net,netdev=net1 \
        -netdev user,id=net0,hostfwd=tcp::$Q_HOST_SSH_PORT-:22 \
        -netdev tap,id=net1,script=no,downscript=no \
        -no-reboot \
        $@ \
    ;
}

function stage_qemu() {
    if [ "$#" -lt 1 ]; then
        debug "Missing qemu argument."
        help
    fi
    COMMAND=$1
    shift
    case ${COMMAND} in
        versatile)
            stage_qemu_versatile $@
            ;;
        raspi3b)
            stage_qemu_raspi3b $@
            ;;
        *)
            debug "Unknown qemu command \"${COMMAND}\"."
            help
            ;;
    esac
}

function stage_wait() {
    pipe_wait $@
}

function stage_ssh() {
    pipe_ssh $@
}

function stage_rsync() {
    if [ "$#" -lt 1 ]; then
        debug "Missing rsync argument."
        help
    fi
    COMMAND=$1
    shift
    case ${COMMAND} in
        ssh)
            stage_rsync_ssh $@
            ;;
        *)
            debug "Unknown rsync command \"${COMMAND}\"."
            help
            ;;
    esac
}

function stage_rsync_ssh() {
    pipe_rsync_ssh $@
}

function stage_halt() {
    stage_ssh $@ <<EOF
sudo reboot
EOF
}

function stage_get() {
    if [ "$#" -lt 1 ]; then
        debug "Missing get argument."
        help
    fi
    COMMAND=$1
    shift
    case ${COMMAND} in
        user)
            variable_get_client_user
            echo ${CLIENT_USER}
            ;;
        ssh)
            if [ "$#" -lt 1 ]; then
                debug "Missing get ssh argument."
                help
            fi
            COMMAND=$1
            shift
            case ${COMMAND} in
                origin)
                    variable_get_client_user
                    echo ${CLIENT_USER}@${CLIENT_HOSTNAME}
                    ;;
                port)
                    echo ${Q_HOST_SSH_PORT}
                    ;;
                public)
                    variable_get_ssh_public
                    echo ${SSH_PUBLIC}
                    ;;
                private)
                    variable_get_ssh_private
                    echo ${SSH_PRIVATE}
                    ;;
                *)
                    debug "Unknown get ssh command \"${COMMAND}\"."
                    help
                    ;;
            esac
            ;;
        mount)
            if [ "$#" -lt 1 ]; then
                debug "Missing get mount argument."
                help
            fi
            COMMAND=$1
            shift

            image_variable_get
            case ${COMMAND} in
                loop)
                    echo ${LOOPBACK}
                    ;;
                boot)
                    echo ${PART_BOOT}
                    ;;
                user)
                    echo ${PART_USER}
                    ;;
                *)
                    debug "Unknown get mount command \"${COMMAND}\"."
                    help
                    ;;
            esac
            ;;
        native)
            if [ "$#" -lt 1 ]; then
                debug "Missing get native argument."
                help
            fi
            COMMAND=$1
            shift

            case ${COMMAND} in
                kernel)
                    variable_get_native_kernel
                    echo ${NATIVE_KERNEL}
                    ;;
                dtb)
                    variable_get_native_dtb
                    echo ${NATIVE_DTB}
                    ;;
                *)
                    debug "Unknown get native command \"${COMMAND}\"."
                    help
                    ;;
            esac
            ;;
        *)
            debug "Unknown get command \"${COMMAND}\"."
            help
            ;;
    esac
}

function stage_set() {
    if [ "$#" -lt 1 ]; then
        debug "Missing set argument."
        help
    fi
    COMMAND=$1
    shift
    case ${COMMAND} in
        user)
            if [ "$#" -lt 1 ]; then
                debug "Missing set user argument."
                help
            fi
            ARG=$1
            shift
            variable_set_user $ARG
            ;;
        ssh)
            if [ "$#" -lt 1 ]; then
                debug "Missing set ssh argument."
                help
            fi
            COMMAND=$1
            shift
            case ${COMMAND} in
                public)
                    if [ "$#" -lt 1 ]; then
                        debug "Missing set ssh public argument."
                        help
                    fi
                    ARG=$1
                    shift
                    variable_set_ssh_public $ARG
                    ;;
                private)
                    if [ "$#" -lt 1 ]; then
                        debug "Missing set ssh private argument."
                        help
                    fi
                    ARG=$1
                    shift
                    variable_set_ssh_private $ARG
                    ;;
                *)
                    debug "Unknown set ssh command \"${COMMAND}\"."
                    help
                    ;;
            esac
            ;;
        native)
            if [ "$#" -lt 1 ]; then
                debug "Missing set native argument."
                help
            fi
            COMMAND=$1
            shift

            case ${COMMAND} in
                kernel)
                    if [ "$#" -lt 1 ]; then
                        debug "Missing set native kernel argument."
                        help
                    fi
                    COMMAND=$1
                    shift

                    variable_set_native_kernel $COMMAND
                    ;;
                dtb)
                    if [ "$#" -lt 1 ]; then
                        debug "Missing set native kernel dtb."
                        help
                    fi
                    COMMAND=$1
                    shift

                    variable_set_native_dtb $COMMAND
                    ;;
                *)
                    debug "Unknown get native command \"${COMMAND}\"."
                    help
                    ;;
            esac
            ;;
        *)
            debug "Unknown set command \"${COMMAND}\"."
            help
            ;;
    esac
}

function stage_main() {
    if [ "$#" -lt 1 ]; then
        debug "Missing argument."
        help
    fi
    COMMAND=$1
    shift
    case ${COMMAND} in
        prerequisites)
            stage_prerequisites $@
            ;;
        image)
            stage_image $@
            ;;
        qemu)
            stage_qemu $@
            ;;
        wait)
            stage_wait $@
            ;;
        ssh)
            stage_ssh $@
            ;;
        rsync)
            stage_rsync $@
            ;;
        halt)
            stage_halt $@
            ;;
        get)
            stage_get $@
            ;;
        set)
            stage_set $@
            ;;
        *)
            debug "Unknown command \"${COMMAND}\"."
            help
            ;;
    esac
}

stage_main $@