Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1 | #!/bin/bash |
Chris Sosa | 2b73600 | 2012-02-12 16:16:08 -0800 | [diff] [blame] | 2 | # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 3 | # Use of this source code is governed by a BSD-style license that can be |
| 4 | # found in the LICENSE file. |
| 5 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 6 | # All scripts should die on error unless commands are specifically excepted |
| 7 | # by prefixing with '!' or surrounded by 'set +e' / 'set -e'. |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 8 | |
| 9 | # The number of jobs to pass to tools that can run in parallel (such as make |
| 10 | # and dpkg-buildpackage |
Alex Deymo | 135faa1 | 2015-01-21 11:20:13 -0800 | [diff] [blame] | 11 | if [[ -z ${NUM_JOBS:-} ]]; then |
Brian Harring | 28bb01f | 2012-05-09 15:26:09 -0700 | [diff] [blame] | 12 | NUM_JOBS=$(grep -c "^processor" /proc/cpuinfo) |
| 13 | fi |
| 14 | # Ensure that any sub scripts we invoke get the max proc count. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 15 | export NUM_JOBS |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 16 | |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 17 | # Make sure we have the location and name of the calling script, using |
| 18 | # the current value if it is already set. |
Alex Deymo | 7ba56be | 2015-02-12 14:28:06 -0800 | [diff] [blame] | 19 | : ${SCRIPT_LOCATION:=$(dirname "$(readlink -f -- "$0")")} |
| 20 | : ${SCRIPT_NAME:=$(basename -- "$0")} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 21 | |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 22 | # Detect whether we're inside a chroot or not |
David James | 47e0e8a | 2015-03-11 15:24:10 -0700 | [diff] [blame] | 23 | CHROOT_VERSION_FILE=/etc/cros_chroot_version |
| 24 | if [[ -e ${CHROOT_VERSION_FILE} ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 25 | INSIDE_CHROOT=1 |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 26 | else |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 27 | INSIDE_CHROOT=0 |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 28 | fi |
| 29 | |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 30 | # Determine and set up variables needed for fancy color output (if supported). |
| 31 | V_BOLD_RED= |
| 32 | V_BOLD_GREEN= |
| 33 | V_BOLD_YELLOW= |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 34 | V_VIDOFF= |
| 35 | |
Mike Frysinger | 8e477cd | 2019-08-21 23:59:12 -0400 | [diff] [blame] | 36 | if [[ -t 1 ]]; then |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 37 | # order matters: we want VIDOFF last so that when we trace with `set -x`, |
| 38 | # our terminal doesn't bleed colors as bash dumps the values of vars. |
Mike Frysinger | 8e477cd | 2019-08-21 23:59:12 -0400 | [diff] [blame] | 39 | V_BOLD_RED=$'\e[1;31m' |
| 40 | V_BOLD_GREEN=$'\e[1;32m' |
| 41 | V_BOLD_YELLOW=$'\e[1;33m' |
| 42 | V_VIDOFF=$'\e[m' |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 43 | fi |
| 44 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 45 | # Turn on bash debug support if available for backtraces. |
| 46 | shopt -s extdebug 2>/dev/null |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 47 | |
Marc Herbert | ff9fa31 | 2015-01-16 17:18:53 -0800 | [diff] [blame] | 48 | # Output a backtrace. Optional parameter allows hiding the last |
| 49 | # frame(s) so functions like "die()" can hide their additional |
| 50 | # frame(s) if they wish. |
Mike Frysinger | bbec711 | 2019-08-22 00:44:29 -0400 | [diff] [blame] | 51 | _dump_trace() { |
Marc Herbert | ff9fa31 | 2015-01-16 17:18:53 -0800 | [diff] [blame] | 52 | # Default = 0 hidden frames: show everything except dump_trace |
| 53 | # frame itself. |
| 54 | local hidden_frames=${1:-0} |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 55 | local j n p func src line args |
| 56 | p=${#BASH_ARGV[@]} |
Marc Herbert | ff9fa31 | 2015-01-16 17:18:53 -0800 | [diff] [blame] | 57 | |
Marc Herbert | f51cf8f | 2015-01-20 13:56:00 -0800 | [diff] [blame] | 58 | error "$(date)" |
Marc Herbert | ee1fcbb | 2015-05-28 10:37:46 -0700 | [diff] [blame] | 59 | error "$(ps f -o pgid,ppid,pid,etime,cputime,%cpu,command)" |
Marc Herbert | f51cf8f | 2015-01-20 13:56:00 -0800 | [diff] [blame] | 60 | |
Marc Herbert | ff9fa31 | 2015-01-16 17:18:53 -0800 | [diff] [blame] | 61 | # Frame 0 is ourselves so it's always suppressed / does not count. |
| 62 | for (( n = ${#FUNCNAME[@]}; n > hidden_frames; --n )); do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 63 | func=${FUNCNAME[${n} - 1]} |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 64 | line=${BASH_LINENO[${n} - 1]} |
| 65 | args= |
| 66 | if [[ -z ${BASH_ARGC[${n} -1]} ]]; then |
| 67 | args='(args unknown, no debug available)' |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 68 | else |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 69 | for (( j = 0; j < ${BASH_ARGC[${n} -1]}; ++j )); do |
| 70 | args="${args:+${args} }'${BASH_ARGV[$(( p - j - 1 ))]}'" |
| 71 | done |
| 72 | ! (( p -= ${BASH_ARGC[${n} - 1]} )) |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 73 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 74 | if [[ ${n} == ${#FUNCNAME[@]} ]]; then |
Marc Herbert | ee1fcbb | 2015-05-28 10:37:46 -0700 | [diff] [blame] | 75 | error "Arguments of $$: ${0##/*} ${args}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 76 | error "Backtrace: (most recent call is last)" |
| 77 | else |
Marc Herbert | 2e8c590 | 2015-01-15 20:17:31 -0800 | [diff] [blame] | 78 | src=${BASH_SOURCE[${n}]##*/} |
Marc Herbert | fa6cbe7 | 2015-01-20 14:09:09 -0800 | [diff] [blame] | 79 | curr_func=${FUNCNAME[${n}]} |
| 80 | error "$(printf ' %s:%s:%s(), called: %s %s ' \ |
| 81 | "${src}" "${line}" "${curr_func}" "${func}" "${args}")" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 82 | fi |
| 83 | done |
| 84 | } |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 85 | |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 86 | # Declare these asap so that code below can safely assume they exist. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 87 | _message() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 88 | local prefix=$1 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 89 | shift |
Mike Frysinger | ca7cd94 | 2019-09-08 04:40:45 -0400 | [diff] [blame] | 90 | printf '%s: ' "$(date +%H:%M:%S)" >&2 |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 91 | if [[ $# -eq 0 ]]; then |
| 92 | echo -e "${prefix}${CROS_LOG_PREFIX:-""}:${V_VIDOFF}" >&2 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 93 | return |
| 94 | fi |
| 95 | ( |
| 96 | # Handle newlines in the message, prefixing each chunk correctly. |
| 97 | # Do this in a subshell to avoid having to track IFS/set -f state. |
| 98 | IFS=" |
| 99 | " |
| 100 | set +f |
| 101 | set -- $* |
| 102 | IFS=' ' |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 103 | if [[ $# -eq 0 ]]; then |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 104 | # Empty line was requested. |
| 105 | set -- '' |
| 106 | fi |
| 107 | for line in "$@"; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 108 | echo -e "${prefix}${CROS_LOG_PREFIX:-}: ${line}${V_VIDOFF}" >&2 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 109 | done |
| 110 | ) |
| 111 | } |
| 112 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 113 | info() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 114 | _message "${V_BOLD_GREEN}INFO " "$*" |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 115 | } |
| 116 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 117 | warn() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 118 | _message "${V_BOLD_YELLOW}WARNING " "$*" |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 119 | } |
| 120 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 121 | error() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 122 | _message "${V_BOLD_RED}ERROR " "$*" |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 123 | } |
| 124 | |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 125 | |
| 126 | # For all die functions, they must explicitly force set +eu; |
Alex Deymo | f923595 | 2015-01-15 11:15:09 -0800 | [diff] [blame] | 127 | # no reason to have them cause their own crash if we're in the middle |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 128 | # of reporting an error condition then exiting. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 129 | die_err_trap() { |
Mike Frysinger | 9ebc8ce | 2015-04-06 13:15:01 -0400 | [diff] [blame] | 130 | local result=${1:-$?} |
| 131 | local command=${2:-${BASH_COMMAND:-command unknown}} |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 132 | set +e +u |
| 133 | |
Mike Frysinger | 9ebc8ce | 2015-04-06 13:15:01 -0400 | [diff] [blame] | 134 | if [[ ${result} == "0" ]]; then |
| 135 | # Let callers simplify by setting us as an EXIT trap handler. |
| 136 | return 0 |
| 137 | fi |
| 138 | |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 139 | # Per the message, bash misreports 127 as 1 during err trap sometimes. |
| 140 | # Note this fact to ensure users don't place too much faith in the |
| 141 | # exit code in that case. |
| 142 | set -- "Command '${command}' exited with nonzero code: ${result}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 143 | if [[ ${result} -eq 1 ]] && [[ -z $(type -t ${command}) ]]; then |
| 144 | set -- "$@" \ |
| 145 | '(Note bash sometimes misreports "command not found" as exit code 1 '\ |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 146 | 'instead of 127)' |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 147 | fi |
Mike Frysinger | bbec711 | 2019-08-22 00:44:29 -0400 | [diff] [blame] | 148 | _dump_trace 1 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 149 | error |
| 150 | error "Command failed:" |
| 151 | DIE_PREFIX=' ' |
| 152 | die_notrace "$@" |
| 153 | } |
| 154 | |
| 155 | # Exit this script due to a failure, outputting a backtrace in the process. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 156 | die() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 157 | set +e +u |
Mike Frysinger | bbec711 | 2019-08-22 00:44:29 -0400 | [diff] [blame] | 158 | _dump_trace 1 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 159 | error |
| 160 | error "Error was:" |
| 161 | DIE_PREFIX=' ' |
| 162 | die_notrace "$@" |
| 163 | } |
| 164 | |
| 165 | # Exit this script w/out a backtrace. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 166 | die_notrace() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 167 | set +e +u |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 168 | if [[ $# -eq 0 ]]; then |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 169 | set -- '(no error message given)' |
| 170 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 171 | local line |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 172 | for line in "$@"; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 173 | error "${DIE_PREFIX}${line}" |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 174 | done |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 175 | exit 1 |
| 176 | } |
| 177 | |
David James | bf13ea8 | 2013-05-08 14:17:25 -0700 | [diff] [blame] | 178 | # Check for a single string in a list of space-separated strings. |
| 179 | # e.g. has "foo" "foo bar baz" is true, but has "f" "foo bar baz" is not. |
| 180 | has() { [[ " ${*:2} " == *" $1 "* ]]; } |
| 181 | |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 182 | # Directory locations inside the dev chroot; try the new default, |
| 183 | # falling back to user specific paths if the upgrade has yet to |
| 184 | # happen. |
| 185 | _user="${USER}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 186 | [[ ${USER} == "root" ]] && _user="${SUDO_USER}" |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 187 | _CHROOT_TRUNK_DIRS=( "/home/${_user}/trunk" /mnt/host/source ) |
| 188 | _DEPOT_TOOLS_DIRS=( "/home/${_user}/depot_tools" /mnt/host/depot_tools ) |
| 189 | unset _user |
| 190 | |
| 191 | _process_mount_pt() { |
| 192 | # Given 4 arguments; the root path, the variable to set, |
| 193 | # the old location, and the new; finally, forcing the upgrade is doable |
| 194 | # via if a 5th arg is provided. |
| 195 | # This will then try to migrate the old to new if we can do so right now |
| 196 | # (else leaving symlinks in place w/in the new), and will set $1 to the |
| 197 | # new location. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 198 | local base=${1:-/} var=$2 old=$3 new=$4 force=${5:-false} |
| 199 | local _sudo=$([[ ${USER} != "root" ]] && echo sudo) |
| 200 | local val=${new} |
Mike Frysinger | 2d9a97d | 2015-02-25 01:38:56 -0500 | [diff] [blame] | 201 | if ${force} || [[ -L ${base}/${new} ]] || [[ ! -e ${base}/${new} ]]; then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 202 | # Ok, it's either a symlink or this is the first run. Upgrade if we can- |
| 203 | # specifically, if we're outside the chroot and we can rmdir the old. |
| 204 | # If we cannot rmdir the old, that's due to a mount being bound to that |
| 205 | # point (even if we can't see it, it's there)- thus fallback to adding |
| 206 | # compat links. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 207 | if ${force} || ( [[ ${INSIDE_CHROOT} -eq 0 ]] && \ |
| 208 | ${_sudo} rmdir "${base}/${old}" 2>/dev/null ); then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 209 | ${_sudo} rm -f "${base}/${new}" || : |
| 210 | ${_sudo} mkdir -p "${base}/${new}" "$(dirname "${base}/${old}" )" |
| 211 | ${_sudo} ln -s "${new}" "${base}/${old}" |
| 212 | else |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 213 | if [[ ! -L ${base}/${new} ]]; then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 214 | # We can't do the upgrade right now; install compatibility links. |
| 215 | ${_sudo} mkdir -p "$(dirname "${base}/${new}")" "${base}/${old}" |
| 216 | ${_sudo} ln -s "${old}" "${base}/${new}" |
| 217 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 218 | val=${old} |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 219 | fi |
| 220 | fi |
| 221 | eval "${var}=\"${val}\"" |
| 222 | } |
| 223 | |
| 224 | set_chroot_trunk_dir() { |
| 225 | # This takes two optional arguments; the first being the path to the chroot |
| 226 | # base; this is only used by enter_chroot. The second argument is whether |
| 227 | # or not to force the new pathways; this is only used by make_chroot. Passing |
| 228 | # a non-null value for $2 forces the new paths. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 229 | if [[ ${INSIDE_CHROOT} -eq 0 ]] && [[ -z ${1-} ]]; then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 230 | # Can't do the upgrade, thus skip trying to do so. |
| 231 | CHROOT_TRUNK_DIR="${_CHROOT_TRUNK_DIRS[1]}" |
| 232 | DEPOT_TOOLS_DIR="${_DEPOT_TOOLS_DIRS[1]}" |
| 233 | return |
| 234 | fi |
Alex Deymo | 76277de | 2015-01-22 11:02:13 -0800 | [diff] [blame] | 235 | _process_mount_pt "${1:-}" CHROOT_TRUNK_DIR "${_CHROOT_TRUNK_DIRS[@]}" \ |
| 236 | ${2:+true} |
| 237 | _process_mount_pt "${1:-}" DEPOT_TOOLS_DIR "${_DEPOT_TOOLS_DIRS[@]}" \ |
| 238 | ${2:+true} |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 239 | } |
| 240 | |
| 241 | set_chroot_trunk_dir |
| 242 | |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 243 | # Construct a list of possible locations for the source tree. This list is |
| 244 | # based on various environment variables and globals that may have been set |
| 245 | # by the calling script. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 246 | get_gclient_root_list() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 247 | if [[ ${INSIDE_CHROOT} -eq 1 ]]; then |
Brian Harring | 2499bfb | 2012-12-18 16:23:31 -0800 | [diff] [blame] | 248 | echo "${CHROOT_TRUNK_DIR}" |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 249 | fi |
| 250 | |
Alex Deymo | 135faa1 | 2015-01-21 11:20:13 -0800 | [diff] [blame] | 251 | if [[ -n ${COMMON_SH:-} ]]; then echo "$(dirname "${COMMON_SH}")/../.."; fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 252 | if [[ -n ${BASH_SOURCE} ]]; then echo "$(dirname "${BASH_SOURCE}")/../.."; fi |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | # Based on the list of possible source locations we set GCLIENT_ROOT if it is |
| 256 | # not already defined by looking for a src directory in each seach path |
| 257 | # location. If we do not find a valid looking root we error out. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 258 | get_gclient_root() { |
Alex Deymo | 135faa1 | 2015-01-21 11:20:13 -0800 | [diff] [blame] | 259 | if [[ -n ${GCLIENT_ROOT:-} ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 260 | return |
| 261 | fi |
| 262 | |
| 263 | for path in $(get_gclient_root_list); do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 264 | if [[ -d ${path}/src ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 265 | GCLIENT_ROOT=${path} |
| 266 | break |
| 267 | fi |
| 268 | done |
| 269 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 270 | if [[ -z ${GCLIENT_ROOT} ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 271 | # Using dash or sh, we don't know where we are. $0 refers to the calling |
| 272 | # script, not ourselves, so that doesn't help us. |
| 273 | echo "Unable to determine location for common.sh. If you are sourcing" |
| 274 | echo "common.sh from a script run via dash or sh, you must do it in the" |
| 275 | echo "following way:" |
| 276 | echo ' COMMON_SH="$(dirname "$0")/../../scripts/common.sh"' |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 277 | echo ' . "${COMMON_SH}"' |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 278 | echo "where the first line is the relative path from your script to" |
| 279 | echo "common.sh." |
| 280 | exit 1 |
| 281 | fi |
| 282 | } |
| 283 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 284 | # Populate the ENVIRONMENT_WHITELIST array. |
| 285 | load_environment_whitelist() { |
| 286 | set -f |
| 287 | ENVIRONMENT_WHITELIST=( |
| 288 | $("${GCLIENT_ROOT}/chromite/scripts/cros_env_whitelist") |
| 289 | ) |
| 290 | set +f |
| 291 | } |
| 292 | |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 293 | # Find root of source tree |
| 294 | get_gclient_root |
| 295 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 296 | # Canonicalize the directories for the root dir and the calling script. |
| 297 | # readlink is part of coreutils and should be present even in a bare chroot. |
tedbo | 4f44d9e | 2010-01-08 17:26:11 -0800 | [diff] [blame] | 298 | # This is better than just using |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 299 | # FOO="$(cd ${FOO} ; pwd)" |
tedbo | 4f44d9e | 2010-01-08 17:26:11 -0800 | [diff] [blame] | 300 | # since that leaves symbolic links intact. |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 301 | # Note that 'realpath' is equivalent to 'readlink -f'. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 302 | SCRIPT_LOCATION=$(readlink -f "${SCRIPT_LOCATION}") |
| 303 | GCLIENT_ROOT=$(readlink -f "${GCLIENT_ROOT}") |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 304 | |
| 305 | # Other directories should always be pathed down from GCLIENT_ROOT. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 306 | SRC_ROOT="${GCLIENT_ROOT}/src" |
| 307 | SRC_INTERNAL="${GCLIENT_ROOT}/src-internal" |
| 308 | SCRIPTS_DIR="${SRC_ROOT}/scripts" |
| 309 | BUILD_LIBRARY_DIR="${SCRIPTS_DIR}/build_library" |
Mike Frysinger | 66accd2 | 2017-09-13 03:50:30 -0400 | [diff] [blame] | 310 | CHROMITE_BIN="${GCLIENT_ROOT}/chromite/bin" |
Alex Klein | 999443c | 2018-10-17 12:02:05 -0600 | [diff] [blame] | 311 | IMAGES_DIR="${GCLIENT_ROOT}/src/build/images" |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 312 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 313 | # Load shflags |
Zdenek Behan | 07d2422 | 2011-11-02 00:46:25 +0000 | [diff] [blame] | 314 | # NOTE: This code snippet is in particular used by the au-generator (which |
| 315 | # stores shflags in ./lib/shflags/) and should not be touched. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 316 | if [[ -f ${SCRIPTS_DIR}/lib/shflags/shflags ]]; then |
Mike Frysinger | 77c674b | 2012-02-07 18:05:07 -0500 | [diff] [blame] | 317 | . "${SCRIPTS_DIR}/lib/shflags/shflags" || die "Couldn't find shflags" |
Zdenek Behan | 07d2422 | 2011-11-02 00:46:25 +0000 | [diff] [blame] | 318 | else |
| 319 | . ./lib/shflags/shflags || die "Couldn't find shflags" |
| 320 | fi |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 321 | |
Bill Richardson | 10d27c2 | 2010-01-20 13:38:50 -0800 | [diff] [blame] | 322 | # Our local mirror |
| 323 | DEFAULT_CHROMEOS_SERVER=${CHROMEOS_SERVER:-"http://build.chromium.org/mirror"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 324 | |
Bill Richardson | 10d27c2 | 2010-01-20 13:38:50 -0800 | [diff] [blame] | 325 | # Upstream mirrors and build suites come in 2 flavors |
| 326 | # DEV - development chroot, used to build the chromeos image |
| 327 | # IMG - bootable image, to run on actual hardware |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 328 | |
Bill Richardson | 10d27c2 | 2010-01-20 13:38:50 -0800 | [diff] [blame] | 329 | DEFAULT_DEV_MIRROR=${CHROMEOS_DEV_MIRROR:-"${DEFAULT_CHROMEOS_SERVER}/ubuntu"} |
| 330 | DEFAULT_DEV_SUITE=${CHROMEOS_DEV_SUITE:-"karmic"} |
| 331 | |
| 332 | DEFAULT_IMG_MIRROR=${CHROMEOS_IMG_MIRROR:-"${DEFAULT_CHROMEOS_SERVER}/ubuntu"} |
| 333 | DEFAULT_IMG_SUITE=${CHROMEOS_IMG_SUITE:-"karmic"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 334 | |
| 335 | # Default location for chroot |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 336 | DEFAULT_CHROOT_DIR=${CHROMEOS_CHROOT_DIR:-"${GCLIENT_ROOT}/chroot"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 337 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 338 | # All output files from build should go under ${DEFAULT_BUILD_ROOT}, so that |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 339 | # they don't pollute the source directory. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 340 | DEFAULT_BUILD_ROOT=${CHROMEOS_BUILD_ROOT:-"${SRC_ROOT}/build"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 341 | |
Chris Ching | 4bc95a1 | 2016-11-22 13:44:13 -0700 | [diff] [blame] | 342 | # Default location for event files |
| 343 | DEFAULT_EVENT_DIR=${DEFAULT_EVENT_DIR:-"${DEFAULT_BUILD_ROOT}/events"} |
| 344 | |
| 345 | # Default event file. Format is YYYYDD.HHMM.json |
| 346 | DEFAULT_EVENT_FILE=${DEFAULT_EVENT_FILE:-"${DEFAULT_EVENT_DIR}/$(date +%Y%m%d.%H%M.).json"} |
| 347 | |
Mike Frysinger | c17a493 | 2012-03-12 17:07:40 -0400 | [diff] [blame] | 348 | # Sets the default board variable for calling script. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 349 | if [[ -f ${GCLIENT_ROOT}/src/scripts/.default_board ]]; then |
| 350 | DEFAULT_BOARD=$(<"${GCLIENT_ROOT}/src/scripts/.default_board") |
Mike Frysinger | c17a493 | 2012-03-12 17:07:40 -0400 | [diff] [blame] | 351 | # Check for user typos like whitespace. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 352 | if [[ -n ${DEFAULT_BOARD//[a-zA-Z0-9-_]} ]]; then |
Mike Frysinger | c17a493 | 2012-03-12 17:07:40 -0400 | [diff] [blame] | 353 | die ".default_board: invalid name detected; please fix:" \ |
| 354 | "'${DEFAULT_BOARD}'" |
| 355 | fi |
| 356 | fi |
David McMahon | 4930294 | 2010-02-18 16:55:35 -0800 | [diff] [blame] | 357 | |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 358 | # Directory to store built images. Should be set by sourcing script when used. |
| 359 | BUILD_DIR= |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 360 | |
Mike Frysinger | 34808e5 | 2017-01-11 21:14:08 -0500 | [diff] [blame] | 361 | # Path to the verified boot directory where we get signing related keys/scripts. |
| 362 | VBOOT_DIR="${CHROOT_TRUNK_DIR}/src/platform/vboot_reference" |
| 363 | VBOOT_TESTKEYS_DIR="${VBOOT_DIR}/tests/testkeys" |
Mike Frysinger | 40cea03 | 2017-03-12 19:48:20 -0400 | [diff] [blame] | 364 | # We load these from the chroot rather than directly from the vboot source repo |
| 365 | # so we work correctly even in a minilayout. |
| 366 | VBOOT_DEVKEYS_DIR="/usr/share/vboot/devkeys" |
| 367 | VBOOT_SIGNING_DIR="/usr/share/vboot/bin" |
Mike Frysinger | 34808e5 | 2017-01-11 21:14:08 -0500 | [diff] [blame] | 368 | |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 369 | # Standard filenames |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 370 | CHROMEOS_BASE_IMAGE_NAME="chromiumos_base_image.bin" |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 371 | CHROMEOS_IMAGE_NAME="chromiumos_image.bin" |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 372 | CHROMEOS_DEVELOPER_IMAGE_NAME="chromiumos_image.bin" |
Gilad Arnold | 0836627 | 2012-02-08 10:46:26 -0800 | [diff] [blame] | 373 | CHROMEOS_RECOVERY_IMAGE_NAME="recovery_image.bin" |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 374 | CHROMEOS_TEST_IMAGE_NAME="chromiumos_test_image.bin" |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 375 | CHROMEOS_FACTORY_INSTALL_SHIM_NAME="factory_install_shim.bin" |
Bertrand SIMONNET | b17cd57 | 2015-04-01 10:27:37 -0700 | [diff] [blame] | 376 | SYSROOT_SETTINGS_FILE="/var/cache/edb/chromeos" |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 377 | |
Rahul Chaudhry | 306f688 | 2015-05-13 15:14:13 -0700 | [diff] [blame] | 378 | # Install mask for portage ebuilds. Used by build_image and gmergefs. |
Chris Masone | d11ce17 | 2010-11-09 14:22:08 -0800 | [diff] [blame] | 379 | # TODO: Is /usr/local/autotest-chrome still used by anyone? |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 380 | COMMON_INSTALL_MASK=" |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 381 | *.a |
Alex Deymo | 1856c4f | 2014-09-24 08:15:34 -0700 | [diff] [blame] | 382 | *.c |
| 383 | *.cc |
Rahul Chaudhry | 306f688 | 2015-05-13 15:14:13 -0700 | [diff] [blame] | 384 | *.go |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 385 | *.la |
Rene Bolldorf | 3222822 | 2012-07-21 14:18:22 -0400 | [diff] [blame] | 386 | *.h |
Brian Norris | ef0880d | 2016-05-19 12:39:56 -0700 | [diff] [blame] | 387 | *.hh |
Rene Bolldorf | 3222822 | 2012-07-21 14:18:22 -0400 | [diff] [blame] | 388 | *.hpp |
Kevin Cernekee | 6ab57a9 | 2015-06-25 15:43:06 -0700 | [diff] [blame] | 389 | *.h++ |
Nam T. Nguyen | aa15f14 | 2015-05-15 14:27:50 -0700 | [diff] [blame] | 390 | *.hxx |
Ryo Hashimoto | 44e6a25 | 2019-10-10 16:12:02 +0900 | [diff] [blame] | 391 | *.proto |
Mike Frysinger | 97c6ac9 | 2014-06-16 00:06:37 -0400 | [diff] [blame] | 392 | */.keep* |
Shuhei Takahashi | c62d307 | 2019-01-29 18:04:35 +0900 | [diff] [blame] | 393 | /build/libexec/tast |
Andrew | 7e8ecf7 | 2020-02-07 12:54:25 -0800 | [diff] [blame] | 394 | /build/rootfs/dlc |
Matt Delco | 80f3d78 | 2019-11-15 14:04:31 -0800 | [diff] [blame] | 395 | /build/share |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 396 | /etc/init.d |
| 397 | /etc/runlevels |
Qijiang Fan | 6834cba | 2018-04-04 16:41:56 +0900 | [diff] [blame] | 398 | /etc/selinux/intermediates |
Hung-Te Lin | 76272be | 2012-08-07 19:10:09 +0800 | [diff] [blame] | 399 | /firmware |
Mike Frysinger | 785f09d | 2013-09-25 22:11:21 -0400 | [diff] [blame] | 400 | /lib/modules/*/vdso |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 401 | /lib/rc |
Tomasz Figa | 435f0e5 | 2017-01-06 14:28:06 +0900 | [diff] [blame] | 402 | /opt/google/containers/android/vendor/lib*/pkgconfig |
Benjamin Gordon | ffcb2b1 | 2017-10-24 13:02:46 -0600 | [diff] [blame] | 403 | /opt/google/containers/android/build |
Nam T. Nguyen | f1de1a7 | 2015-05-27 08:37:46 -0700 | [diff] [blame] | 404 | /usr/bin/*-config |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 405 | /usr/bin/Xnest |
| 406 | /usr/bin/Xvfb |
Sergei Datsenko | 29869d9 | 2019-11-12 14:26:27 +1100 | [diff] [blame] | 407 | /usr/include |
Stephen Barber | 717c583 | 2020-01-17 16:14:41 -0800 | [diff] [blame] | 408 | /usr/lib/cros_rust_registry |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 409 | /usr/lib/debug |
Rahul Chaudhry | 306f688 | 2015-05-13 15:14:13 -0700 | [diff] [blame] | 410 | /usr/lib/gopath |
Mike Frysinger | 27b5edb | 2012-08-08 18:52:06 -0400 | [diff] [blame] | 411 | /usr/lib*/pkgconfig |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 412 | /usr/local/autotest-chrome |
| 413 | /usr/man |
| 414 | /usr/share/aclocal |
Brian Norris | 0f3c4e2 | 2016-06-21 12:23:18 -0700 | [diff] [blame] | 415 | /usr/share/cups/drv |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 416 | /usr/share/doc |
| 417 | /usr/share/gettext |
| 418 | /usr/share/gtk-2.0 |
| 419 | /usr/share/gtk-doc |
| 420 | /usr/share/info |
| 421 | /usr/share/man |
Brian Norris | 0f3c4e2 | 2016-06-21 12:23:18 -0700 | [diff] [blame] | 422 | /usr/share/ppd |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 423 | /usr/share/openrc |
| 424 | /usr/share/pkgconfig |
Ryan Harrison | b8bd594 | 2013-02-02 13:39:43 -0500 | [diff] [blame] | 425 | /usr/share/profiling |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 426 | /usr/share/readline |
Chris Wolfe | d13775f | 2011-07-26 16:34:38 -0400 | [diff] [blame] | 427 | /usr/src |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 428 | " |
Chris Sosa | aa1a7fd | 2010-04-02 14:06:29 -0700 | [diff] [blame] | 429 | |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 430 | # Mask for base, dev, and test images (build_image, build_image --test) |
| 431 | DEFAULT_INSTALL_MASK=" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 432 | ${COMMON_INSTALL_MASK} |
Don Garrett | ac1cd0d | 2013-07-18 18:04:06 -0700 | [diff] [blame] | 433 | /boot/config-* |
| 434 | /boot/System.map-* |
Aviv Keshet | a1838ba | 2013-07-23 10:58:23 -0700 | [diff] [blame] | 435 | /usr/local/build/autotest |
Olof Johansson | 1222b2e | 2012-08-08 15:27:35 -0700 | [diff] [blame] | 436 | /lib/modules/*/build |
| 437 | /lib/modules/*/source |
Kees Cook | 74f163b | 2012-12-18 15:46:51 -0800 | [diff] [blame] | 438 | test_*.ko |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 439 | " |
| 440 | |
Chris Sosa | c9422fa | 2012-03-05 15:58:07 -0800 | [diff] [blame] | 441 | # Mask for factory install shim (build_image factory_install) |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 442 | FACTORY_SHIM_INSTALL_MASK=" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 443 | ${DEFAULT_INSTALL_MASK} |
Cheng-Han Yang | c924c2c | 2018-11-02 17:02:29 +0800 | [diff] [blame] | 444 | /opt/google/chrome |
| 445 | /opt/google/containers |
Vic Yang | 982556a | 2012-12-11 11:41:54 +0800 | [diff] [blame] | 446 | /usr/lib64/dri |
Hung-Te Lin | 7f721ec | 2017-07-18 15:14:48 +0800 | [diff] [blame] | 447 | /usr/lib/dri |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 448 | /usr/share/X11 |
Hung-Te Lin | 7f721ec | 2017-07-18 15:14:48 +0800 | [diff] [blame] | 449 | /usr/share/chromeos-assets/[^i]* |
| 450 | /usr/share/chromeos-assets/i[^m]* |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 451 | /usr/share/fonts |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 452 | /usr/share/locale |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 453 | /usr/share/mime |
Vic Yang | 982556a | 2012-12-11 11:41:54 +0800 | [diff] [blame] | 454 | /usr/share/oem |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 455 | /usr/share/sounds |
| 456 | /usr/share/tts |
| 457 | /usr/share/zoneinfo |
| 458 | " |
Tom Wai-Hong Tam | f87a367 | 2010-05-17 16:06:33 +0800 | [diff] [blame] | 459 | |
Sabin Floares | e790ea7 | 2016-11-21 14:56:41 +0200 | [diff] [blame] | 460 | # Mask for images without systemd. |
| 461 | SYSTEMD_INSTALL_MASK=" |
Chris Morin | 83226ab | 2018-12-07 19:53:48 -0800 | [diff] [blame] | 462 | /lib/systemd/network |
| 463 | /usr/lib/systemd/system |
Sabin Floares | e790ea7 | 2016-11-21 14:56:41 +0200 | [diff] [blame] | 464 | " |
| 465 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 466 | # ----------------------------------------------------------------------------- |
| 467 | # Functions |
| 468 | |
Don Garrett | 640a058 | 2010-05-04 16:54:28 -0700 | [diff] [blame] | 469 | # Enter a chroot and restart the current script if needed |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 470 | restart_in_chroot_if_needed() { |
David Rochberg | 3b91070 | 2010-12-02 10:45:21 -0500 | [diff] [blame] | 471 | # NB: Pass in ARGV: restart_in_chroot_if_needed "$@" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 472 | if [[ ${INSIDE_CHROOT} -ne 1 ]]; then |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 473 | # Get inside_chroot path for script. |
| 474 | local chroot_path="$(reinterpret_path_for_chroot "$0")" |
Mike Frysinger | 66accd2 | 2017-09-13 03:50:30 -0400 | [diff] [blame] | 475 | exec "${CHROMITE_BIN}/cros_sdk" -- "${chroot_path}" "$@" |
Don Garrett | 640a058 | 2010-05-04 16:54:28 -0700 | [diff] [blame] | 476 | fi |
| 477 | } |
| 478 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 479 | # Fail unless we're inside the chroot. This guards against messing up your |
| 480 | # workstation. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 481 | assert_inside_chroot() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 482 | if [[ ${INSIDE_CHROOT} -ne 1 ]]; then |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 483 | echo "This script must be run inside the chroot. Run this first:" |
Zdenek Behan | 2811c16 | 2011-08-13 00:47:38 +0200 | [diff] [blame] | 484 | echo " cros_sdk" |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 485 | exit 1 |
| 486 | fi |
| 487 | } |
| 488 | |
| 489 | # Fail if we're inside the chroot. This guards against creating or entering |
| 490 | # nested chroots, among other potential problems. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 491 | assert_outside_chroot() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 492 | if [[ ${INSIDE_CHROOT} -ne 0 ]]; then |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 493 | echo "This script must be run outside the chroot." |
| 494 | exit 1 |
| 495 | fi |
| 496 | } |
| 497 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 498 | assert_not_root_user() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 499 | if [[ ${UID:-$(id -u)} == 0 ]]; then |
derat@google.com | 86dcc8e | 2009-11-21 19:49:49 +0000 | [diff] [blame] | 500 | echo "This script must be run as a non-root user." |
| 501 | exit 1 |
| 502 | fi |
| 503 | } |
| 504 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 505 | assert_root_user() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 506 | if [[ ${UID:-$(id -u)} != 0 ]] || [[ ${SUDO_USER:-root} == "root" ]]; then |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 507 | die_notrace "This script must be run using sudo from a non-root user." |
| 508 | fi |
| 509 | } |
| 510 | |
tedbo | 373c390 | 2010-04-12 10:52:40 -0700 | [diff] [blame] | 511 | # Writes stdin to the given file name as root using sudo in overwrite mode. |
| 512 | # |
| 513 | # $1 - The output file name. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 514 | sudo_clobber() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 515 | sudo tee "$1" >/dev/null |
tedbo | 373c390 | 2010-04-12 10:52:40 -0700 | [diff] [blame] | 516 | } |
| 517 | |
Mike Frysinger | 286b592 | 2011-09-28 11:59:53 -0400 | [diff] [blame] | 518 | # Execute multiple commands in a single sudo. Generally will speed things |
| 519 | # up by avoiding multiple calls to `sudo`. If any commands fail, we will |
| 520 | # call die with the failing command. We can handle a max of ~100 commands, |
| 521 | # but hopefully no one will ever try that many at once. |
| 522 | # |
| 523 | # $@ - The commands to execute, one per arg. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 524 | sudo_multi() { |
Mike Frysinger | 286b592 | 2011-09-28 11:59:53 -0400 | [diff] [blame] | 525 | local i cmds |
| 526 | |
| 527 | # Construct the shell code to execute. It'll be of the form: |
| 528 | # ... && ( ( command ) || exit <command index> ) && ... |
| 529 | # This way we know which command exited. The exit status of |
| 530 | # the underlying command is lost, but we never cared about it |
| 531 | # in the first place (other than it is non zero), so oh well. |
| 532 | for (( i = 1; i <= $#; ++i )); do |
| 533 | cmds+=" && ( ( ${!i} ) || exit $(( i + 10 )) )" |
| 534 | done |
| 535 | |
| 536 | # Execute our constructed shell code. |
| 537 | sudo -- sh -c ":${cmds[*]}" && i=0 || i=$? |
| 538 | |
| 539 | # See if this failed, and if so, print out the failing command. |
| 540 | if [[ $i -gt 10 ]]; then |
| 541 | : $(( i -= 10 )) |
| 542 | die "sudo_multi failed: ${!i}" |
| 543 | elif [[ $i -ne 0 ]]; then |
| 544 | die "sudo_multi failed for unknown reason $i" |
| 545 | fi |
| 546 | } |
| 547 | |
Chris Masone | bbccc24 | 2014-02-08 16:23:53 -0800 | [diff] [blame] | 548 | # Clears out stale shadow-utils locks in the given target root. |
| 549 | sudo_clear_shadow_locks() { |
| 550 | info "Clearing shadow utils lockfiles under $1" |
| 551 | sudo rm -f "$1/etc/"{passwd,group,shadow,gshadow}.lock* |
| 552 | } |
| 553 | |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 554 | # Locate all mounts below a specified directory. |
| 555 | # |
| 556 | # $1 - The root tree. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 557 | sub_mounts() { |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 558 | # Assume that `mount` outputs a list of mount points in the order |
| 559 | # that things were mounted (since it always has and hopefully always |
| 560 | # will). As such, we have to unmount in reverse order to cleanly |
| 561 | # unmount submounts (think /dev/pts and /dev). |
Alex Deymo | 7ba56be | 2015-02-12 14:28:06 -0800 | [diff] [blame] | 562 | awk -v path="$1" -v len="${#1}" \ |
Benjamin Gordon | 1d5afed | 2017-06-14 16:35:32 -0600 | [diff] [blame] | 563 | '(substr($2, 1, len+1) == path || |
| 564 | substr($2, 1, len+1) == (path "/")) { print $2 }' /proc/mounts | \ |
Zdenek Behan | 52970f4 | 2012-08-30 22:36:40 +0200 | [diff] [blame] | 565 | tac | \ |
| 566 | sed -e 's/\\040(deleted)$//' |
| 567 | # Hack(zbehan): If a bind mount's source is mysteriously removed, |
| 568 | # we'd end up with an orphaned mount with the above string in its name. |
| 569 | # It can only be seen through /proc/mounts and will stick around even |
| 570 | # when it should be gone already. crosbug.com/31250 |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 571 | } |
| 572 | |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 573 | # Unmounts a directory, if the unmount fails, warn, and then lazily unmount. |
| 574 | # |
| 575 | # $1 - The path to unmount. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 576 | safe_umount_tree() { |
Alex Deymo | 7ba56be | 2015-02-12 14:28:06 -0800 | [diff] [blame] | 577 | local mount_point="$1" |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 578 | |
Alex Deymo | 7ba56be | 2015-02-12 14:28:06 -0800 | [diff] [blame] | 579 | local mounts=( $(sub_mounts "${mount_point}") ) |
| 580 | |
| 581 | # Silently return if the mount_point was already unmounted. |
| 582 | if [[ ${#mounts[@]} -eq 0 ]]; then |
Mike Frysinger | e8aec37 | 2011-09-21 00:03:22 -0400 | [diff] [blame] | 583 | return 0 |
| 584 | fi |
| 585 | |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 586 | # First try to unmount in one shot to speed things up. |
Chirantan Ekbote | 30823e9 | 2016-06-29 11:39:03 -0700 | [diff] [blame] | 587 | if LC_ALL=C safe_umount -d "${mounts[@]}"; then |
| 588 | return 0 |
David James | d9b6798 | 2012-10-26 09:46:50 -0700 | [diff] [blame] | 589 | fi |
| 590 | |
| 591 | # Well that didn't work, so lazy unmount remaining ones. |
Alex Deymo | 7ba56be | 2015-02-12 14:28:06 -0800 | [diff] [blame] | 592 | warn "Failed to unmount ${mounts[@]}, these are the processes using the" \ |
| 593 | "mount points." |
| 594 | sudo fuser -vm "${mount_point}" || true |
| 595 | |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 596 | warn "Doing a lazy unmount" |
Alex Deymo | 7ba56be | 2015-02-12 14:28:06 -0800 | [diff] [blame] | 597 | if ! safe_umount -d -l "${mounts[@]}"; then |
| 598 | mounts=( $(sub_mounts "${mount_point}") ) |
| 599 | die "Failed to lazily unmount ${mounts[@]}" |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 600 | fi |
| 601 | } |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 602 | |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 603 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 604 | # Run umount as root. |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 605 | safe_umount() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 606 | $([[ ${UID:-$(id -u)} != 0 ]] && echo sudo) umount "$@" |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 607 | } |
| 608 | |
Gabe Black | fbdb1d5 | 2014-09-22 23:43:35 -0700 | [diff] [blame] | 609 | # Setup a loopback device for a file and scan for partitions, with retries. |
| 610 | # |
| 611 | # $1 - The file to back the new loopback device. |
| 612 | # $2-$N - Additional arguments to pass to losetup. |
| 613 | loopback_partscan() { |
| 614 | local lb_dev image="$1" |
| 615 | shift |
LaMont Jones | 005f77b | 2019-10-11 14:04:55 -0600 | [diff] [blame] | 616 | |
George Engelbrecht | fcd236f | 2019-10-28 18:12:56 -0600 | [diff] [blame] | 617 | # We set up a binary backoff for adding the partitions. We give 10 attempts |
| 618 | # each time nth time we fail, backing off by 1<<n. The maximum time then |
| 619 | # spent sleeping will be sum(2^n) from [0...10] which is 1023 seconds, |
| 620 | # or ~37 minutes. |
| 621 | local i partx_out partx_d_out sleep_seconds=1 |
| 622 | for (( i = 0; i <= 10; i++ )); do |
| 623 | # Flush any dirty pages in the image before we do partx commands. |
| 624 | info "Running sync -f ${image}" |
| 625 | sync -f "${image}" |
LaMont Jones | 005f77b | 2019-10-11 14:04:55 -0600 | [diff] [blame] | 626 | |
George Engelbrecht | fcd236f | 2019-10-28 18:12:56 -0600 | [diff] [blame] | 627 | # This (perhaps) mounts the partitions as well. |
| 628 | lb_dev=$(sudo losetup --show -f "$@" "${image}") |
Mike Frysinger | c97934e | 2019-09-02 02:48:28 -0400 | [diff] [blame] | 629 | |
George Engelbrecht | fcd236f | 2019-10-28 18:12:56 -0600 | [diff] [blame] | 630 | # Try to clean the slate by removing any existing parts (best effort). |
| 631 | partx_d_out=$(sudo partx -v -d "${lb_dev}") || true |
Mike Frysinger | c97934e | 2019-09-02 02:48:28 -0400 | [diff] [blame] | 632 | |
George Engelbrecht | fcd236f | 2019-10-28 18:12:56 -0600 | [diff] [blame] | 633 | # Try to add the partitions back. |
| 634 | if ! partx_out=$(sudo partx -v -a "${lb_dev}"); then |
| 635 | local proc_parts |
| 636 | warn "Adding partitions with 'partx -v -a ${lb_dev}' failed." |
| 637 | warn "partx -d output:\n${partx_d_out}" |
| 638 | warn "partx -a output:\n${partx_out}" |
| 639 | proc_parts=$(cat /proc/partitions) |
| 640 | warn "/proc/partitions before detaching loopback:\n ${proc_parts}" |
| 641 | # Detach the image. |
| 642 | sudo losetup -d "${lb_dev}" || true |
| 643 | proc_parts=$(cat /proc/partitions) |
| 644 | warn "/proc/partitions after detaching loopback:\n ${proc_parts}" |
| 645 | warn "Sleeping ${sleep_seconds} before trying again." |
| 646 | sleep "${sleep_seconds}" |
| 647 | : $(( sleep_seconds <<= 1 )) |
| 648 | else |
| 649 | break |
| 650 | fi |
| 651 | done |
Gabe Black | fbdb1d5 | 2014-09-22 23:43:35 -0700 | [diff] [blame] | 652 | |
Gabe Black | 7bb6c5a | 2015-03-16 20:23:06 -0700 | [diff] [blame] | 653 | echo "${lb_dev}" |
Gabe Black | fbdb1d5 | 2014-09-22 23:43:35 -0700 | [diff] [blame] | 654 | } |
| 655 | |
| 656 | # Detach a loopback device set up earlier. |
| 657 | # |
Gabe Black | 01ba4de | 2015-03-11 16:34:56 -0700 | [diff] [blame] | 658 | # $1 - The loop device to detach. |
| 659 | # $2-$N - Additional arguments to pass to losetup. |
Gabe Black | fbdb1d5 | 2014-09-22 23:43:35 -0700 | [diff] [blame] | 660 | loopback_detach() { |
Mike Frysinger | af64ed5 | 2015-04-06 13:20:39 -0400 | [diff] [blame] | 661 | # Retry the deletes before we detach. crbug.com/469259 |
| 662 | local i |
| 663 | for (( i = 0; i < 10; i++ )); do |
Mike Frysinger | ad3b200 | 2019-08-21 23:35:59 -0400 | [diff] [blame] | 664 | if sudo partx -d "$1"; then |
Mike Frysinger | af64ed5 | 2015-04-06 13:20:39 -0400 | [diff] [blame] | 665 | break |
| 666 | fi |
| 667 | warn "Sleeping & retrying ..." |
| 668 | sync |
| 669 | sleep 1 |
| 670 | done |
Mike Frysinger | ad3b200 | 2019-08-21 23:35:59 -0400 | [diff] [blame] | 671 | sudo losetup --detach "$@" |
Gabe Black | fbdb1d5 | 2014-09-22 23:43:35 -0700 | [diff] [blame] | 672 | } |
| 673 | |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 674 | # Sets up symlinks for the developer root. It is necessary to symlink |
| 675 | # usr and local since the developer root is mounted at /usr/local and |
| 676 | # applications expect to be installed under /usr/local/bin, etc. |
| 677 | # This avoids packages installing into /usr/local/usr/local/bin. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 678 | # $1 specifies the symlink target for the developer root. |
| 679 | # $2 specifies the symlink target for the var directory. |
| 680 | # $3 specifies the location of the stateful partition. |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 681 | setup_symlinks_on_root() { |
| 682 | # Give args better names. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 683 | local dev_image_target=$1 |
| 684 | local var_target=$2 |
| 685 | local dev_image_root="$3/dev_image" |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 686 | |
Mike Frysinger | 9e15538 | 2019-07-12 21:11:00 -0400 | [diff] [blame] | 687 | # Make sure the dev_image dir itself exists. |
| 688 | if [[ ! -d "${dev_image_root}" ]]; then |
| 689 | sudo mkdir "${dev_image_root}" |
| 690 | fi |
| 691 | |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 692 | # If our var target is actually the standard var, we are cleaning up the |
| 693 | # symlinks (could also check for /usr/local for the dev_image_target). |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 694 | if [[ ${var_target} == "/var" ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 695 | echo "Cleaning up /usr/local symlinks for ${dev_image_root}" |
| 696 | else |
| 697 | echo "Setting up symlinks for /usr/local for ${dev_image_root}" |
| 698 | fi |
| 699 | |
| 700 | # Set up symlinks that should point to ${dev_image_target}. |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 701 | local path |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 702 | for path in usr local; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 703 | if [[ -h ${dev_image_root}/${path} ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 704 | sudo unlink "${dev_image_root}/${path}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 705 | elif [[ -e ${dev_image_root}/${path} ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 706 | die "${dev_image_root}/${path} should be a symlink if exists" |
| 707 | fi |
Mike Frysinger | a1a06ab | 2011-08-10 11:40:30 -0400 | [diff] [blame] | 708 | sudo ln -s "${dev_image_target}" "${dev_image_root}/${path}" |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 709 | done |
| 710 | |
| 711 | # Setup var symlink. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 712 | if [[ -h ${dev_image_root}/var ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 713 | sudo unlink "${dev_image_root}/var" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 714 | elif [[ -e ${dev_image_root}/var ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 715 | die "${dev_image_root}/var should be a symlink if it exists" |
| 716 | fi |
| 717 | |
| 718 | sudo ln -s "${var_target}" "${dev_image_root}/var" |
| 719 | } |
Nick Sanders | d250927 | 2010-06-16 03:50:04 -0700 | [diff] [blame] | 720 | |
| 721 | # Get current timestamp. Assumes common.sh runs at startup. |
| 722 | start_time=$(date +%s) |
| 723 | |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 724 | # Get time elapsed since start_time in seconds. |
Mike Frysinger | bbec711 | 2019-08-22 00:44:29 -0400 | [diff] [blame] | 725 | _get_elapsed_seconds() { |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 726 | local end_time=$(date +%s) |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 727 | local elapsed_seconds=$(( end_time - start_time )) |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 728 | echo ${elapsed_seconds} |
| 729 | } |
| 730 | |
| 731 | # Print time elapsed since start_time. |
| 732 | print_time_elapsed() { |
| 733 | # Optional first arg to specify elapsed_seconds. If not given, will |
| 734 | # recalculate elapsed time to now. Optional second arg to specify |
| 735 | # command name associated with elapsed time. |
Mike Frysinger | bbec711 | 2019-08-22 00:44:29 -0400 | [diff] [blame] | 736 | local elapsed_seconds=${1:-$(_get_elapsed_seconds)} |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 737 | local cmd_base=${2:-} |
| 738 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 739 | local minutes=$(( elapsed_seconds / 60 )) |
| 740 | local seconds=$(( elapsed_seconds % 60 )) |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 741 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 742 | if [[ -n ${cmd_base} ]]; then |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 743 | info "Elapsed time (${cmd_base}): ${minutes}m${seconds}s" |
| 744 | else |
| 745 | info "Elapsed time: ${minutes}m${seconds}s" |
| 746 | fi |
| 747 | } |
| 748 | |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 749 | command_completed() { |
| 750 | # Call print_elapsed_time regardless. |
Mike Frysinger | bbec711 | 2019-08-22 00:44:29 -0400 | [diff] [blame] | 751 | local run_time=$(_get_elapsed_seconds) |
Mike Frysinger | 3131d41 | 2019-03-02 14:09:37 -0500 | [diff] [blame] | 752 | local cmd_base=$(basename "$0") |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 753 | print_time_elapsed ${run_time} ${cmd_base} |
Nick Sanders | d250927 | 2010-06-16 03:50:04 -0700 | [diff] [blame] | 754 | } |
Doug Anderson | 0c9e88d | 2010-10-19 14:49:39 -0700 | [diff] [blame] | 755 | |
Albert Chaulk | 5d190f7 | 2013-07-12 11:42:18 -0700 | [diff] [blame] | 756 | # Load configuration files that allow board-specific overrides of default |
| 757 | # functionality to be specified in overlays. |
Steve Fung | d3b1f5f | 2015-03-29 21:47:24 -0700 | [diff] [blame] | 758 | # $1 - File to load. |
Albert Chaulk | 5d190f7 | 2013-07-12 11:42:18 -0700 | [diff] [blame] | 759 | load_board_specific_script() { |
Steve Fung | 88897cc | 2015-03-25 13:38:38 -0700 | [diff] [blame] | 760 | local file=$1 overlay |
| 761 | [[ $# -ne 1 ]] && die "load_board_specific_script requires exactly 1 param" |
| 762 | for overlay in ${BOARD_OVERLAY}; do |
Albert Chaulk | 5d190f7 | 2013-07-12 11:42:18 -0700 | [diff] [blame] | 763 | local setup_sh="${overlay}/scripts/${file}" |
| 764 | if [[ -e ${setup_sh} ]]; then |
| 765 | source "${setup_sh}" |
| 766 | fi |
| 767 | done |
| 768 | } |
| 769 | |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 770 | # Reinterprets path from outside the chroot for use inside. |
| 771 | # Returns "" if "" given. |
| 772 | # $1 - The path to reinterpret. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 773 | reinterpret_path_for_chroot() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 774 | if [[ ${INSIDE_CHROOT} -ne 1 ]]; then |
| 775 | if [[ -z $1 ]]; then |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 776 | echo "" |
| 777 | else |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 778 | local path_abs_path=$(readlink -f "$1") |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 779 | local gclient_root_abs_path=$(readlink -f "${GCLIENT_ROOT}") |
| 780 | |
| 781 | # Strip the repository root from the path. |
| 782 | local relative_path=$(echo ${path_abs_path} \ |
Mike Frysinger | a1a06ab | 2011-08-10 11:40:30 -0400 | [diff] [blame] | 783 | | sed "s:${gclient_root_abs_path}/::") |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 784 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 785 | if [[ ${relative_path} == "${path_abs_path}" ]]; then |
| 786 | die "Error reinterpreting path. Path $1 is not within source tree." |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 787 | fi |
| 788 | |
| 789 | # Prepend the chroot repository path. |
Chris Sosa | ed2ff4b | 2013-08-30 12:58:41 -0700 | [diff] [blame] | 790 | echo "/mnt/host/source/${relative_path}" |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 791 | fi |
| 792 | else |
| 793 | # Path is already inside the chroot :). |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 794 | echo "$1" |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 795 | fi |
| 796 | } |
Gabe Black | 83d8b82 | 2011-08-01 17:50:09 -0700 | [diff] [blame] | 797 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 798 | switch_to_strict_mode() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 799 | # Set up strict execution mode; note that the trap |
| 800 | # must follow switch_to_strict_mode, else it will have no effect. |
| 801 | set -e |
Mike Frysinger | 9ebc8ce | 2015-04-06 13:15:01 -0400 | [diff] [blame] | 802 | trap 'die_err_trap' ERR |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 803 | if [[ $# -ne 0 ]]; then |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 804 | set "$@" |
| 805 | fi |
| 806 | } |
| 807 | |
| 808 | # TODO: Re-enable this once shflags is set -e safe. |
| 809 | #switch_to_strict_mode |