quiz-lib

#!/usr/bin/env bash
# SPDX-License-Identifier: MPL-2.0
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# Copyright (c) 2023-2025, Rob Norris <robn@despairlabs.com>

#
# Linux source version numbers (the tarball version) don't always match their
# installed version number (module dir version, uname -a output), eg:
#
#   source    installed
#   6.9-rc1   6.9.0-rc1
#   6.9       6.9.0
#   6.9.1     6.9.1
#
# we allow any form. internally, we'll set up variables for the "version"
# (installed) and "source version" (source), and also vars for all the pieces
#

# separate function for the pre-cooked parse; used by quiz-kernel
# to request "latest in series"
function _quiz_kernel_vars () {
  local kver=$1

  _quiz_kver=""
  _quiz_ksrcver=""
  _quiz_kmajor=""
  _quiz_kminor=""
  _quiz_kpatch=""
  _quiz_ktype=""
  _quiz_ktype_patch=""

  if [[ ${kver%%-*} = "next" ]] ; then
    _quiz_kmajor=0
    _quiz_kminor=0
    _quiz_kpatch=0
    _quiz_ktype=next
    _quiz_ktype_patch=${kver##next-}
  elif [[ $kver = "master" ]] ; then
    _quiz_kmajor=0
    _quiz_kminor=0
    _quiz_kpatch=0
    _quiz_ktype=master
    _quiz_ktype_patch=
  else
    shopt -s lastpipe
    eval $(echo $kver | perl -nE '
      ($maj, $min, $pat, $ty, $typat) = m/
        ^
          ([1-9][0-9]*)                   # major
          \.                              # dot sep
          (0|[1-9][0-9]*)                 # minor
          (?:\.(0|[1-9][0-9]*))?          # patch 1+, optional
          (?:
            -(rc|next|master)             # type
            (?:-?(
              (?:[0-9a-f]+\+)             # typpatch: git ref
            |
              (?:[1-9][0-9]*)             # typpatch: number
            )?)
          )?
        $
      /gx;
      print <<~EOF;
        _quiz_kmajor=$maj
        _quiz_kminor=$min
        _quiz_kpatch=$pat
        _quiz_ktype=$ty
        _quiz_ktype_patch=$typat
      EOF
    ')
  fi

  if [[ -n "${QUIZ_DEBUG_VARS_PARSE:-}" ]] ; then
    cat 2>&1 <<EOF
DEBUG: exploded kernel version (parse): $kver
       _quiz_kmajor:      $_quiz_kmajor
       _quiz_kminor:      $_quiz_kminor
       _quiz_kpatch:      $_quiz_kpatch
       _quiz_ktype:       $_quiz_ktype
       _quiz_ktype_patch: $_quiz_ktype_patch
EOF
  fi

  return 0
}

function quiz_kernel_vars () {
  local kver="${1:-}"
  if [[ -z $kver ]] ; then
    fail "no kernel version set. use -k or set QUIZ_KERNEL_VERSION"
  fi

  _quiz_kernel_vars $kver

  if [[ -z $_quiz_kmajor || -z $_quiz_kminor ]] ; then
    fail "'$kver' is not a valid kernel version"
  fi
  if [[ -z $_quiz_kpatch ]] ; then
    _quiz_kpatch="0"
  fi
  if [[ -z $_quiz_ktype ]] ; then
    _quiz_ktype='release'
    _quiz_ksrcver=$_quiz_kmajor.$_quiz_kminor
    _quiz_kver=$_quiz_ksrcver
    if [[ "$_quiz_kpatch" = "0" ]] ; then
      _quiz_kver="$_quiz_kver.0"
    else
      _quiz_kver="$_quiz_kver.$_quiz_kpatch"
      _quiz_ksrcver="$_quiz_ksrcver.$_quiz_kpatch"
    fi
  elif [[ $_quiz_ktype == "rc" ]] ; then
    _quiz_kver=$_quiz_kmajor.$_quiz_kminor.0-$_quiz_ktype$_quiz_ktype_patch
    _quiz_ksrcver=$_quiz_kmajor.$_quiz_kminor-$_quiz_ktype$_quiz_ktype_patch
  elif [[ $_quiz_ktype == "next" ]] ; then
    _quiz_kver=$_quiz_kmajor.$_quiz_kminor.0-$_quiz_ktype-$_quiz_ktype_patch
    _quiz_ksrcver=$_quiz_kmajor.$_quiz_kminor-$_quiz_ktype-$_quiz_ktype_patch
  elif [[ $_quiz_ktype == "master" ]] ; then
    if [[ -n $_quiz_ktype_patch ]] ; then
      _quiz_kver=$_quiz_kmajor.$_quiz_kminor.0-$_quiz_ktype-$_quiz_ktype_patch
      _quiz_ksrcver=$_quiz_kmajor.$_quiz_kminor-$_quiz_ktype-$_quiz_ktype_patch
    else
      _quiz_kver=$_quiz_kmajor.$_quiz_kminor.0-$_quiz_ktype
      _quiz_ksrcver=$_quiz_kmajor.$_quiz_kminor-$_quiz_ktype
    fi
  fi

  if [[ -n "${QUIZ_DEBUG_VARS:-}" ]] ; then
    cat 2>&1 <<EOF
DEBUG: exploded kernel version: $kver
       _quiz_kmajor:      $_quiz_kmajor
       _quiz_kminor:      $_quiz_kminor
       _quiz_kpatch:      $_quiz_kpatch
       _quiz_ktype:       $_quiz_ktype
       _quiz_ktype_patch: $_quiz_ktype_patch
       _quiz_kver:        $_quiz_kver
       _quiz_ksrcver:     $_quiz_ksrcver
EOF
  fi
}

function quiz_kernel_best_available () {
  local kver="${1:-}"
  if [[ -z $kver ]] ; then
    fail "no kernel version set. use -k or set QUIZ_KERNEL_VERSION"
  fi

  local kernel_dir=$RUNDIR/system/kernel
  local kernel_slug=quiz-kernel-$_quiz_arch_kernel

  _quiz_kernel_dir=""
  _quiz_kernel_image=""

  quiz_kernel_vars $kver

  if [[ $kver = $_quiz_kver ]] ; then
    # canonical kernel version specified, must use only that version
    local dir=$kernel_dir/$kernel_slug-$_quiz_kver
    local image=$dir/kernel-$_quiz_kver
    if [[ ! -e $image ]] ; then
      fail "kernel image not found: $_quiz_kver"
    fi
    _quiz_kernel_dir=$dir
    _quiz_kernel_image=$image
  else
    # partial version specified, choose from best available
    local matchtype=$_quiz_ktype
    local searchpat
    if [[ $_quiz_ktype = "next" ]] ; then
      searchpat="$kernel_slug-*-$_quiz_ktype-$_quiz_ktype_patch"
    else
      searchpat="$kernel_slug-$_quiz_ksrcver.*"
    fi
    local candidates="$(find $kernel_dir -maxdepth 1 -name $searchpat | cut -f4- -d- | sort -V)"
    local best=""
    for candidate in $candidates ; do
      quiz_kernel_vars $candidate
      if [[ $_quiz_ktype != $matchtype ]] ; then
        trace "skipped non-release kernel image: $_quiz_kver"
      else
        best="$_quiz_kver"
        trace "matched kernel image: $_quiz_kver"
      fi
    done
    if [[ -z $best ]] ; then
      fail "matching kernel image not found: $kver"
    fi
    quiz_kernel_vars $best
    _quiz_kernel_dir=$kernel_dir/$kernel_slug-$_quiz_kver
    _quiz_kernel_image=$_quiz_kernel_dir/kernel-$_quiz_kver
  fi

  trace "using kernel: $_quiz_kver"
}

function quiz_arch_vars () {
  local arch="${1:-}"
  if [[ -z $arch ]] ; then
    fail "no architecture set. use -a or set QUIZ_ARCH"
  fi

  # defaults
  _quiz_arch=$arch
  _quiz_arch_kernel=""
  _quiz_arch_qemu=$arch
  _quiz_arch_prefix=$arch-linux-gnu
  _quiz_arch_native=""

  case "$arch" in
    x86_64)
      _quiz_arch_kernel=x86
      ;;
    aarch64)
      _quiz_arch_kernel=arm64
      ;;
    ppc64)
      _quiz_arch_kernel=powerpc
      ;;
    riscv64)
      _quiz_arch_kernel=riscv
      ;;
    loongarch64)
      _quiz_arch_kernel=loongarch
      ;;
    *)
      fail "no support for architecture: $arch"
      ;;
  esac

  if [[ $(uname -m) == $_quiz_arch ]] ; then
    _quiz_arch_native=1
  fi

  if [[ -n "${QUIZ_DEBUG_VARS:-}" ]] ; then
    cat 2>&1 <<EOF
DEBUG: exploded arch vars: $arch
       _quiz_arch:        $_quiz_arch
       _quiz_arch_kernel: $_quiz_arch_kernel
       _quiz_arch_qemu:   $_quiz_arch_qemu
       _quiz_arch_prefix: $_quiz_arch_prefix
       _quiz_arch_native: $_quiz_arch_native
EOF
  fi

  trace "using arch: $_quiz_arch"
}

#
# XXX this are actually more like arch vars, but I'm still not sure where
#     debian sits in the whole structure, so for now I'm just keeping it
#     contained -- robn, 2025-01-10
#
function quiz_debian_vars () {
  if [[ -z "${_quiz_arch:-}" ]] ; then
    fail "internal error: call quiz_arch_vars() first"
  fi

  # defaults for supported architectures
  _quiz_debian_arch=""
  _quiz_debian_release=trixie
  _quiz_debian_mirror="https://deb.debian.org/debian"

  case "$_quiz_arch" in
    x86_64)
      _quiz_debian_arch=amd64
      ;;
    aarch64)
      _quiz_debian_arch=arm64
      ;;
    riscv64)
      _quiz_debian_arch=riscv64
      ;;
    ppc64)
      _quiz_debian_arch=ppc64
      _quiz_debian_release=unstable
      _quiz_debian_mirror="[trusted=yes] https://deb.debian.org/debian-ports"
      ;;
    loongarch64)
      _quiz_debian_arch=loong64
      _quiz_debian_release=unstable
      _quiz_debian_mirror="[trusted=yes] https://deb.debian.org/debian-ports"
      ;;
    *)
      fail "internal error: debian vars for arch $_quiz_arch not defined"
      ;;
  esac

  if [[ -n "${QUIZ_DEBUG_VARS:-}" ]] ; then
    cat 2>&1 <<EOF
DEBUG: exploded debian vars for arch: $_quiz_arch
       _quiz_debian_arch:    $_quiz_debian_arch
       _quiz_debian_release: $_quiz_debian_release
       _quiz_debian_mirror:  $_quiz_debian_mirror
EOF
  fi
}

# vim: ft=bash