| #!/bin/bash |
| # |
| # Copyright 2020 Google LLC |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| PLATFORM=${PLATFORM:-shodan} |
| |
| ## Shamelessly borrowed from android's envsetup.sh. |
| function getrootdir |
| { |
| local TOPFILE="build/Makefile" |
| # if env variable `SHODAN_ROOTDIR` is set, the setting is sticky. |
| if [[ -n "$SHODAN_ROOTDIR" && -f "$SHODAN_ROOTDIR/$TOPFILE" ]]; then |
| # The following circumlocution ensures we remove symlinks |
| # from SHODAN_ROOTDIR. |
| (cd "${SHODAN_ROOTDIR}"; PWD= /bin/pwd) |
| else |
| if [[ -f "${TOPFILE}" ]]; then |
| # The following circumlocution (repeated below as well) ensures |
| # that we record the true directory name and not one that is |
| # faked up with symlink names. |
| PWD= /bin/pwd |
| else |
| local HERE="${PWD}" |
| local R= |
| while [ \( ! \( -f "${TOPFILE}" \) \) -a \( "${PWD}" != "/" \) ]; do |
| \cd .. |
| R=`PWD= /bin/pwd -P` |
| done |
| \cd "${HERE}" |
| if [ -f "${R}/${TOPFILE}" ]; then |
| echo "${R}" |
| fi |
| fi |
| fi |
| } |
| |
| export ROOTDIR="$(getrootdir)" |
| export OUT="${ROOTDIR}/out" |
| export CACHE="${ROOTDIR}/cache" |
| |
| # NB: platform setup.sh (included below) sets up the rust toolchain |
| export PATH="${HOME}/.local/bin:${PATH}" |
| export PATH="${CACHE}/toolchain/bin:${PATH}" |
| export PATH="${ROOTDIR}/scripts:${PATH}" |
| export PATH="${CACHE}/renode:${PATH}" |
| export PATH="${OUT}/host/qemu/riscv32-softmmu:${PATH}" |
| export PATH="${OUT}/host/flatbuffers/bin:${PATH}" |
| export PATH="${OUT}/host/verilator/bin:${PATH}" |
| export PATH="${OUT}/host/verible/bin:${PATH}" |
| |
| export CANTRIP_RUST_VERSION=${CANTRIP_RUST_VERSION:-"nightly-2023-04-20"} |
| export RENODE_PORT=1234 |
| |
| export PYTHONPATH="${PYTHONPATH}:${ROOTDIR}/cicd/" |
| export PYTHON_SHODAN_ENV="${CACHE}/python-venv" |
| |
| function renode |
| { |
| "${CACHE}/renode/renode" "$@" |
| } |
| |
| function iss |
| { |
| (cd "${ROOTDIR}" && python3 "${ROOTDIR}/scripts/quick_sim.py" "$@") |
| } |
| |
| function get-groups |
| { |
| git --git-dir="${ROOTDIR}/.repo/manifests.git" config \ |
| --get manifest.groups |
| } |
| |
| function m |
| { |
| (cd "${ROOTDIR}" && make -f "${ROOTDIR}/build/Makefile" "$@") |
| return $? |
| } |
| |
| function _hmm |
| { |
| local targetname="$1"; shift |
| targetname="${targetname}" gawk -f "${ROOTDIR}/build/helpmemake.awk" \ |
| "${ROOTDIR}/build/Makefile" \ |
| "${ROOTDIR}/build/platforms/${PLATFORM}"/*.mk \ |
| "${ROOTDIR}"/build/*.mk |
| } |
| |
| function hmm |
| { |
| local usage="Usage: hmm [-h] [-l] <targetname>" |
| local long="" |
| local args=$(getopt hl $*) |
| set -- $args |
| |
| for i; do |
| case "$1" in |
| -l) |
| long=1 |
| shift 1 |
| ;; |
| |
| --) |
| shift |
| break |
| ;; |
| |
| -h|*) |
| echo $usage >/dev/stderr |
| return 1 |
| ;; |
| esac |
| done |
| |
| local targetname="${1}"; shift |
| |
| if [[ -n "${targetname}" ]]; then |
| _hmm "${targetname}" |
| return 0 |
| fi |
| |
| if [[ -z "${long}" ]]; then |
| _hmm | fmt --width=80 |
| else |
| _hmm |
| fi |
| } |
| |
| function safe-abandon |
| { |
| local branch="${1}"; shift |
| |
| if [[ -z "${branch}" ]]; then |
| echo "Usage: safe-abandon <branchname>" |
| echo |
| echo "Abandons a repo branch in the current project only." |
| echo "This is much safer than using the actual 'repo abandon'" |
| echo "command, since it won't globally revert branches across" |
| echo "the entire project space." |
| echo |
| return 1 |
| fi |
| |
| repo abandon "${branch}" . |
| } |
| |
| function list-platforms |
| { |
| for i in $(echo "${ROOTDIR}/build/platforms"/*); do |
| basename $i |sed 's/\.sh$//' |
| done |
| } |
| |
| function set-platform |
| { |
| local platform="${1}"; shift |
| |
| if [[ -z "${platform}" ]]; then |
| ( |
| echo "Usage: set-platform <platform>" |
| echo |
| echo "Sets the target platform for the build. Platforms available are:" |
| echo |
| list-platforms |
| echo |
| ) | fmt |
| return 1 |
| fi |
| |
| export PLATFORM="${platform}" |
| export CANTRIP_OUT_DIR="${OUT}/cantrip/${PLATFORM}" |
| export CHERIOT_OUT_DIR="${OUT}/cheriot/${PLATFORM}" |
| source "${ROOTDIR}/build/platforms/${platform}/setup.sh" |
| } |
| |
| function kcargo |
| { |
| # NB: sel4-config needs a path to the kernel build which could be |
| # in debug or release (for our needs either works) |
| local SEL4_OUT_DIR="${CANTRIP_OUT_DIR}/debug/kernel/" |
| if [[ ! -d "${SEL4_OUT_DIR}/gen_config" ]]; then |
| SEL4_OUT_DIR="${CANTRIP_OUT_DIR}/release/kernel/" |
| if [[ ! -d "${SEL4_OUT_DIR}/gen_config" ]]; then |
| echo "No kernel build found at ${SEL4_OUT_DIR}; build a kernel first" |
| set +x |
| return 1 |
| fi |
| fi |
| |
| local SEL4_PLATFORM=$(awk '$1 == "CONFIG_PLATFORM" {print $3}' "$ROOTDIR/build/platforms/$PLATFORM/cantrip.mk") |
| local RUST_TARGET=$(awk '/RUST_TARGET/{print $3}' "$ROOTDIR/build/platforms/$PLATFORM/cantrip_apps.mk") |
| |
| local CARGO_CMD="cargo +${CANTRIP_RUST_VERSION}" |
| local CARGO_TARGET="--target ${RUST_TARGET} --features ${SEL4_PLATFORM}" |
| local CARGO_OPTS='-Z unstable-options -Z avoid-dev-deps' |
| # TODO(sleffler): maybe set --target-dir to avoid polluting the src tree |
| |
| # NB: we don't want to export anything to the user's shell (in particular |
| # RUSTFLAGS), hence the subshell parenthesis. |
| ( |
| export RUSTFLAGS='-Z tls-model=local-exec' |
| export SEL4_OUT_DIR="$SEL4_OUT_DIR" |
| |
| cmd=${1:-build} |
| case "$1" in |
| fmt) |
| ${CARGO_CMD} $*;; |
| ""|-*) |
| ${CARGO_CMD} build ${CARGO_OPTS} ${CARGO_TARGET};; |
| clippy) |
| # NB: track preupload-clippy.sh |
| ${CARGO_CMD} clippy ${CARGO_OPTS} ${CARGO_TARGET} \ |
| --target-dir ${CANTRIP_OUT_DIR}/clippy -- \ |
| -D warnings \ |
| -A clippy::uninlined_format_args |
| ;; |
| *) |
| ${CARGO_CMD} $* ${CARGO_OPTS} ${CARGO_TARGET};; |
| esac |
| ) |
| } |
| |
| set-platform ${PLATFORM} |
| |
| if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then |
| unset JUMP_TARGETS |
| declare -Ax JUMP_TARGETS |
| JUMP_TARGETS[.]="." |
| JUMP_TARGETS[top]="${ROOTDIR}" |
| JUMP_TARGETS[rootdir]="${ROOTDIR}" |
| JUMP_TARGETS[out]="${OUT}" |
| JUMP_TARGETS[build]="${ROOTDIR}/build" |
| JUMP_TARGETS[doc]="${ROOTDIR}/doc" |
| |
| JUMP_TARGETS[sel4]="${ROOTDIR}/cantrip/kernel" |
| JUMP_TARGETS[kernel]="${ROOTDIR}/cantrip/kernel" |
| JUMP_TARGETS[cantrip]="${ROOTDIR}/cantrip/projects/cantrip" |
| JUMP_TARGETS[system]="${ROOTDIR}/cantrip/projects/cantrip/apps/system" |
| JUMP_TARGETS[c-apps]="${ROOTDIR}/cantrip/projects/cantrip/apps/c" |
| JUMP_TARGETS[rust-apps]="${ROOTDIR}/cantrip/projects/cantrip/apps/rust" |
| |
| JUMP_TARGETS[debug]="${CANTRIP_OUT_DIR}/debug" |
| JUMP_TARGETS[release]="${CANTRIP_OUT_DIR}/release" |
| |
| JUMP_TARGETS[tock]="${ROOTDIR}/sw/tock" |
| JUMP_TARGETS[sim]="${ROOTDIR}/sim" |
| |
| function j |
| { |
| local target="$1"; shift |
| local splitpath=(${target//\// }) |
| local subpath="" |
| |
| if [[ -z "${target}" ]]; then |
| cd "${ROOTDIR}" |
| return 0 |
| fi |
| |
| if [[ -z "${JUMP_TARGETS[$target]}" ]]; then |
| target="${splitpath[0]}" |
| subpath="${splitpath[@]:1}" |
| fi |
| |
| if [[ -z "${JUMP_TARGETS[$target]}" ]]; then |
| echo "Jump targets are:" |
| echo "${!JUMP_TARGETS[@]}" |
| return 1 |
| fi |
| |
| cd "${JUMP_TARGETS[$target]}" |
| |
| if [[ ! -z "${subpath}" ]]; then |
| cd "${subpath}" |
| fi |
| } |
| |
| if builtin complete >/dev/null 2>/dev/null; then |
| function _j_targets |
| { |
| echo "${!JUMP_TARGETS[@]}" |
| } |
| |
| function _j |
| { |
| local cur="${COMP_WORDS[COMP_CWORD]}" |
| COMPREPLY=() |
| if [[ "${COMP_CWORD}" -eq 1 ]]; then |
| COMPREPLY=( $(compgen -W "$(_j_targets)" $cur) ) |
| fi |
| } |
| |
| complete -F _j j |
| |
| function _complete_build_targets |
| { |
| local cur="${COMP_WORDS[COMP_CWORD]}" |
| COMPREPLY=() |
| if [[ "${COMP_CWORD}" -eq 1 ]]; then |
| COMPREPLY=( $(compgen -W "$(hmm -l)" $cur) ) |
| fi |
| } |
| |
| complete -F _complete_build_targets m |
| complete -F _complete_build_targets hmm |
| |
| function _complete_platform_targets |
| { |
| local cur="${COMP_WORDS[COMP_CWORD]}" |
| COMPREPLY=() |
| if [[ "${COMP_CWORD}" -eq 1 ]]; then |
| COMPREPLY=( $(compgen -W "$(list-platforms)" $cur) ) |
| fi |
| } |
| |
| complete -F _complete_platform_targets set-platform |
| fi |
| fi |
| |
| ## Watch a file for a pattern and exit when matched or timed out |
| function expect_match |
| { |
| local match_string="$1" |
| local log_path="$2" |
| local timeout="$3" |
| |
| if [[ -z "${match_string}" ]] || [[ -z "${log_path}" ]]; then |
| echo "Usage: expect_match <pattern> <file path> [timeout]" |
| echo " pattern: grep regexp pattern" |
| echo " file path: Path to file to search" |
| echo " timeout: optional timeout, defaults to 30s" |
| return 1 |
| fi |
| |
| log_path="$(realpath ${log_path})" |
| |
| if [[ -z "${timeout}" ]]; then |
| timeout="30s" |
| fi |
| |
| echo "Watching for ${match_string} in ${log_path}" |
| timeout "${timeout}" bash -c "until grep -q -e \"${match_string}\" \"${log_path}\"; do sleep 1; done" |
| } |
| |
| |
| # Explicitly set the variables to run the venv python interpreter. |
| export PATH="${PYTHON_SHODAN_ENV}/bin:${PATH}" |
| export VIRTUAL_ENV="${PYTHON_SHODAN_ENV}" |
| |
| echo "========================================" |
| echo ROOTDIR="${ROOTDIR}" |
| echo OUT="${OUT}" |
| echo PLATFORM="${PLATFORM}" |
| echo PYTHON_SHODAN_ENV="${PYTHON_SHODAN_ENV}" |
| echo "========================================" |
| echo |
| echo Type \'m \[target\]\' to build. |
| echo |
| echo "Targets available are:" |
| echo |
| hmm |
| echo |
| echo "To get more information on a target, use 'hmm [target]'" |
| echo |
| |
| declare -F parting_messages >/dev/null && parting_messages |
