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 |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [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 | |
Gilad Arnold | 8f861c0 | 2013-01-09 09:19:51 -0800 | [diff] [blame] | 17 | # Returns the pv command if it's available, otherwise plain-old cat. Note that |
| 18 | # this function echoes the command, rather than running it, so it can be used |
| 19 | # as an argument to other commands (like sudo). |
| 20 | pv_cat_cmd() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 21 | if type -P pv >&/dev/null; then |
Gilad Arnold | 8f861c0 | 2013-01-09 09:19:51 -0800 | [diff] [blame] | 22 | # Limit pv's output to 80 columns, for readability. |
| 23 | local term_cols=$(stty size 2>/dev/null | cut -d' ' -f2) |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 24 | if [[ ${term_cols:-0} -gt 80 ]]; then |
Gilad Arnold | 8f861c0 | 2013-01-09 09:19:51 -0800 | [diff] [blame] | 25 | echo pv -w 80 |
| 26 | else |
| 27 | echo pv |
| 28 | fi |
| 29 | else |
| 30 | echo cat |
| 31 | fi |
| 32 | } |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 33 | |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 34 | # Make sure we have the location and name of the calling script, using |
| 35 | # the current value if it is already set. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 36 | : ${SCRIPT_LOCATION:=$(dirname "$(readlink -f "$0")")} |
| 37 | : ${SCRIPT_NAME:=$(basename "$0")} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 38 | |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 39 | # Detect whether we're inside a chroot or not |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 40 | if [[ -e /etc/debian_chroot ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 41 | INSIDE_CHROOT=1 |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 42 | else |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 43 | INSIDE_CHROOT=0 |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 44 | fi |
| 45 | |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 46 | # Determine and set up variables needed for fancy color output (if supported). |
| 47 | V_BOLD_RED= |
| 48 | V_BOLD_GREEN= |
| 49 | V_BOLD_YELLOW= |
| 50 | V_REVERSE= |
| 51 | V_VIDOFF= |
| 52 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 53 | if tput colors >&/dev/null; then |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 54 | # order matters: we want VIDOFF last so that when we trace with `set -x`, |
| 55 | # our terminal doesn't bleed colors as bash dumps the values of vars. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 56 | V_BOLD_RED=$(tput bold; tput setaf 1) |
| 57 | V_BOLD_GREEN=$(tput bold; tput setaf 2) |
| 58 | V_BOLD_YELLOW=$(tput bold; tput setaf 3) |
| 59 | V_REVERSE=$(tput rev) |
| 60 | V_VIDOFF=$(tput sgr0) |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 61 | fi |
| 62 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 63 | # Turn on bash debug support if available for backtraces. |
| 64 | shopt -s extdebug 2>/dev/null |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 65 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 66 | # Output a backtrace all the way back to the raw invocation, suppressing |
| 67 | # only the _dump_trace frame itself. |
| 68 | _dump_trace() { |
| 69 | local j n p func src line args |
| 70 | p=${#BASH_ARGV[@]} |
| 71 | for (( n = ${#FUNCNAME[@]}; n > 1; --n )); do |
| 72 | func=${FUNCNAME[${n} - 1]} |
| 73 | src=${BASH_SOURCE[${n}]##*/} |
| 74 | line=${BASH_LINENO[${n} - 1]} |
| 75 | args= |
| 76 | if [[ -z ${BASH_ARGC[${n} -1]} ]]; then |
| 77 | args='(args unknown, no debug available)' |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 78 | else |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 79 | for (( j = 0; j < ${BASH_ARGC[${n} -1]}; ++j )); do |
| 80 | args="${args:+${args} }'${BASH_ARGV[$(( p - j - 1 ))]}'" |
| 81 | done |
| 82 | ! (( p -= ${BASH_ARGC[${n} - 1]} )) |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 83 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 84 | if [[ ${n} == ${#FUNCNAME[@]} ]]; then |
| 85 | error "script called: ${0##/*} ${args}" |
| 86 | error "Backtrace: (most recent call is last)" |
| 87 | else |
| 88 | error "$(printf ' file %s, line %s, called: %s %s' \ |
| 89 | "${src}" "${line}" "${func}" "${args}")" |
| 90 | fi |
| 91 | done |
| 92 | } |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 93 | |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 94 | # Declare these asap so that code below can safely assume they exist. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 95 | _message() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 96 | local prefix=$1 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 97 | shift |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 98 | if [[ $# -eq 0 ]]; then |
| 99 | echo -e "${prefix}${CROS_LOG_PREFIX:-""}:${V_VIDOFF}" >&2 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 100 | return |
| 101 | fi |
| 102 | ( |
| 103 | # Handle newlines in the message, prefixing each chunk correctly. |
| 104 | # Do this in a subshell to avoid having to track IFS/set -f state. |
| 105 | IFS=" |
| 106 | " |
| 107 | set +f |
| 108 | set -- $* |
| 109 | IFS=' ' |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 110 | if [[ $# -eq 0 ]]; then |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 111 | # Empty line was requested. |
| 112 | set -- '' |
| 113 | fi |
| 114 | for line in "$@"; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 115 | echo -e "${prefix}${CROS_LOG_PREFIX:-}: ${line}${V_VIDOFF}" >&2 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 116 | done |
| 117 | ) |
| 118 | } |
| 119 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 120 | info() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 121 | _message "${V_BOLD_GREEN}INFO " "$*" |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 122 | } |
| 123 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 124 | warn() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 125 | _message "${V_BOLD_YELLOW}WARNING " "$*" |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 126 | } |
| 127 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 128 | error() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 129 | _message "${V_BOLD_RED}ERROR " "$*" |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 130 | } |
| 131 | |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 132 | |
| 133 | # For all die functions, they must explicitly force set +eu; |
| 134 | # no reason to have them cause their own crash if we're inthe middle |
| 135 | # of reporting an error condition then exiting. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 136 | die_err_trap() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 137 | local command=$1 result=$2 |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 138 | set +e +u |
| 139 | |
| 140 | # Per the message, bash misreports 127 as 1 during err trap sometimes. |
| 141 | # Note this fact to ensure users don't place too much faith in the |
| 142 | # exit code in that case. |
| 143 | set -- "Command '${command}' exited with nonzero code: ${result}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 144 | if [[ ${result} -eq 1 ]] && [[ -z $(type -t ${command}) ]]; then |
| 145 | set -- "$@" \ |
| 146 | '(Note bash sometimes misreports "command not found" as exit code 1 '\ |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 147 | 'instead of 127)' |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 148 | fi |
| 149 | _dump_trace |
| 150 | error |
| 151 | error "Command failed:" |
| 152 | DIE_PREFIX=' ' |
| 153 | die_notrace "$@" |
| 154 | } |
| 155 | |
| 156 | # 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] | 157 | die() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 158 | set +e +u |
| 159 | _dump_trace |
| 160 | error |
| 161 | error "Error was:" |
| 162 | DIE_PREFIX=' ' |
| 163 | die_notrace "$@" |
| 164 | } |
| 165 | |
| 166 | # Exit this script w/out a backtrace. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 167 | die_notrace() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 168 | set +e +u |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 169 | if [[ $# -eq 0 ]]; then |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 170 | set -- '(no error message given)' |
| 171 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 172 | local line |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 173 | for line in "$@"; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 174 | error "${DIE_PREFIX}${line}" |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 175 | done |
Mike Frysinger | 669b28b | 2012-02-07 18:01:00 -0500 | [diff] [blame] | 176 | exit 1 |
| 177 | } |
| 178 | |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 179 | # Directory locations inside the dev chroot; try the new default, |
| 180 | # falling back to user specific paths if the upgrade has yet to |
| 181 | # happen. |
| 182 | _user="${USER}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 183 | [[ ${USER} == "root" ]] && _user="${SUDO_USER}" |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 184 | _CHROOT_TRUNK_DIRS=( "/home/${_user}/trunk" /mnt/host/source ) |
| 185 | _DEPOT_TOOLS_DIRS=( "/home/${_user}/depot_tools" /mnt/host/depot_tools ) |
| 186 | unset _user |
| 187 | |
| 188 | _process_mount_pt() { |
| 189 | # Given 4 arguments; the root path, the variable to set, |
| 190 | # the old location, and the new; finally, forcing the upgrade is doable |
| 191 | # via if a 5th arg is provided. |
| 192 | # This will then try to migrate the old to new if we can do so right now |
| 193 | # (else leaving symlinks in place w/in the new), and will set $1 to the |
| 194 | # new location. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 195 | local base=${1:-/} var=$2 old=$3 new=$4 force=${5:-false} |
| 196 | local _sudo=$([[ ${USER} != "root" ]] && echo sudo) |
| 197 | local val=${new} |
| 198 | if [[ -L ${base}/${new} ]] || [[ ! -e ${base}/${new} ]]; then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 199 | # Ok, it's either a symlink or this is the first run. Upgrade if we can- |
| 200 | # specifically, if we're outside the chroot and we can rmdir the old. |
| 201 | # If we cannot rmdir the old, that's due to a mount being bound to that |
| 202 | # point (even if we can't see it, it's there)- thus fallback to adding |
| 203 | # compat links. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 204 | if ${force} || ( [[ ${INSIDE_CHROOT} -eq 0 ]] && \ |
| 205 | ${_sudo} rmdir "${base}/${old}" 2>/dev/null ); then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 206 | ${_sudo} rm -f "${base}/${new}" || : |
| 207 | ${_sudo} mkdir -p "${base}/${new}" "$(dirname "${base}/${old}" )" |
| 208 | ${_sudo} ln -s "${new}" "${base}/${old}" |
| 209 | else |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 210 | if [[ ! -L ${base}/${new} ]]; then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 211 | # We can't do the upgrade right now; install compatibility links. |
| 212 | ${_sudo} mkdir -p "$(dirname "${base}/${new}")" "${base}/${old}" |
| 213 | ${_sudo} ln -s "${old}" "${base}/${new}" |
| 214 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 215 | val=${old} |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 216 | fi |
| 217 | fi |
| 218 | eval "${var}=\"${val}\"" |
| 219 | } |
| 220 | |
| 221 | set_chroot_trunk_dir() { |
| 222 | # This takes two optional arguments; the first being the path to the chroot |
| 223 | # base; this is only used by enter_chroot. The second argument is whether |
| 224 | # or not to force the new pathways; this is only used by make_chroot. Passing |
| 225 | # a non-null value for $2 forces the new paths. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 226 | if [[ ${INSIDE_CHROOT} -eq 0 ]] && [[ -z ${1-} ]]; then |
Brian Harring | 9086a3f | 2013-01-14 01:43:16 -0800 | [diff] [blame] | 227 | # Can't do the upgrade, thus skip trying to do so. |
| 228 | CHROOT_TRUNK_DIR="${_CHROOT_TRUNK_DIRS[1]}" |
| 229 | DEPOT_TOOLS_DIR="${_DEPOT_TOOLS_DIRS[1]}" |
| 230 | return |
| 231 | fi |
| 232 | _process_mount_pt "$1" CHROOT_TRUNK_DIR "${_CHROOT_TRUNK_DIRS[@]}" ${2:+true} |
| 233 | _process_mount_pt "$1" DEPOT_TOOLS_DIR "${_DEPOT_TOOLS_DIRS[@]}" ${2:+true} |
| 234 | } |
| 235 | |
| 236 | set_chroot_trunk_dir |
| 237 | |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 238 | # Construct a list of possible locations for the source tree. This list is |
| 239 | # based on various environment variables and globals that may have been set |
| 240 | # by the calling script. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 241 | get_gclient_root_list() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 242 | if [[ ${INSIDE_CHROOT} -eq 1 ]]; then |
Brian Harring | 2499bfb | 2012-12-18 16:23:31 -0800 | [diff] [blame] | 243 | echo "${CHROOT_TRUNK_DIR}" |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 244 | fi |
| 245 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 246 | if [[ -n ${COMMON_SH} ]]; then echo "$(dirname "${COMMON_SH}")/../.."; fi |
| 247 | if [[ -n ${BASH_SOURCE} ]]; then echo "$(dirname "${BASH_SOURCE}")/../.."; fi |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | # Based on the list of possible source locations we set GCLIENT_ROOT if it is |
| 251 | # not already defined by looking for a src directory in each seach path |
| 252 | # 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] | 253 | get_gclient_root() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 254 | if [[ -n ${GCLIENT_ROOT} ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 255 | return |
| 256 | fi |
| 257 | |
| 258 | for path in $(get_gclient_root_list); do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 259 | if [[ -d ${path}/src ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 260 | GCLIENT_ROOT=${path} |
| 261 | break |
| 262 | fi |
| 263 | done |
| 264 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 265 | if [[ -z ${GCLIENT_ROOT} ]]; then |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 266 | # Using dash or sh, we don't know where we are. $0 refers to the calling |
| 267 | # script, not ourselves, so that doesn't help us. |
| 268 | echo "Unable to determine location for common.sh. If you are sourcing" |
| 269 | echo "common.sh from a script run via dash or sh, you must do it in the" |
| 270 | echo "following way:" |
| 271 | echo ' COMMON_SH="$(dirname "$0")/../../scripts/common.sh"' |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 272 | echo ' . "${COMMON_SH}"' |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 273 | echo "where the first line is the relative path from your script to" |
| 274 | echo "common.sh." |
| 275 | exit 1 |
| 276 | fi |
| 277 | } |
| 278 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 279 | # Populate the ENVIRONMENT_WHITELIST array. |
| 280 | load_environment_whitelist() { |
| 281 | set -f |
| 282 | ENVIRONMENT_WHITELIST=( |
| 283 | $("${GCLIENT_ROOT}/chromite/scripts/cros_env_whitelist") |
| 284 | ) |
| 285 | set +f |
| 286 | } |
| 287 | |
Anton Staaf | 30acb0b | 2011-01-26 16:00:20 -0800 | [diff] [blame] | 288 | # Find root of source tree |
| 289 | get_gclient_root |
| 290 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 291 | # Canonicalize the directories for the root dir and the calling script. |
| 292 | # 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] | 293 | # This is better than just using |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 294 | # FOO="$(cd ${FOO} ; pwd)" |
tedbo | 4f44d9e | 2010-01-08 17:26:11 -0800 | [diff] [blame] | 295 | # since that leaves symbolic links intact. |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 296 | # Note that 'realpath' is equivalent to 'readlink -f'. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 297 | SCRIPT_LOCATION=$(readlink -f "${SCRIPT_LOCATION}") |
| 298 | GCLIENT_ROOT=$(readlink -f "${GCLIENT_ROOT}") |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 299 | |
| 300 | # Other directories should always be pathed down from GCLIENT_ROOT. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 301 | SRC_ROOT="${GCLIENT_ROOT}/src" |
| 302 | SRC_INTERNAL="${GCLIENT_ROOT}/src-internal" |
| 303 | SCRIPTS_DIR="${SRC_ROOT}/scripts" |
| 304 | BUILD_LIBRARY_DIR="${SCRIPTS_DIR}/build_library" |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 305 | |
| 306 | # Load developer's custom settings. Default location is in scripts dir, |
| 307 | # since that's available both inside and outside the chroot. By convention, |
| 308 | # settings from this file are variables starting with 'CHROMEOS_' |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 309 | : ${CHROMEOS_DEV_SETTINGS:=${SCRIPTS_DIR}/.chromeos_dev} |
| 310 | if [[ -f ${CHROMEOS_DEV_SETTINGS} ]]; then |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 311 | # Turn on exit-on-error during custom settings processing |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 312 | SAVE_OPTS=$(set +o) |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 313 | switch_to_strict_mode |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 314 | |
| 315 | # Read settings |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 316 | . "${CHROMEOS_DEV_SETTINGS}" |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 317 | |
| 318 | # Restore previous state of exit-on-error |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 319 | eval "${SAVE_OPTS}" |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 320 | fi |
| 321 | |
| 322 | # Load shflags |
Zdenek Behan | 07d2422 | 2011-11-02 00:46:25 +0000 | [diff] [blame] | 323 | # NOTE: This code snippet is in particular used by the au-generator (which |
| 324 | # stores shflags in ./lib/shflags/) and should not be touched. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 325 | if [[ -f ${SCRIPTS_DIR}/lib/shflags/shflags ]]; then |
Mike Frysinger | 77c674b | 2012-02-07 18:05:07 -0500 | [diff] [blame] | 326 | . "${SCRIPTS_DIR}/lib/shflags/shflags" || die "Couldn't find shflags" |
Zdenek Behan | 07d2422 | 2011-11-02 00:46:25 +0000 | [diff] [blame] | 327 | else |
| 328 | . ./lib/shflags/shflags || die "Couldn't find shflags" |
| 329 | fi |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 330 | |
Bill Richardson | 10d27c2 | 2010-01-20 13:38:50 -0800 | [diff] [blame] | 331 | # Our local mirror |
| 332 | DEFAULT_CHROMEOS_SERVER=${CHROMEOS_SERVER:-"http://build.chromium.org/mirror"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 333 | |
Bill Richardson | 10d27c2 | 2010-01-20 13:38:50 -0800 | [diff] [blame] | 334 | # Upstream mirrors and build suites come in 2 flavors |
| 335 | # DEV - development chroot, used to build the chromeos image |
| 336 | # IMG - bootable image, to run on actual hardware |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 337 | |
Bill Richardson | 10d27c2 | 2010-01-20 13:38:50 -0800 | [diff] [blame] | 338 | DEFAULT_DEV_MIRROR=${CHROMEOS_DEV_MIRROR:-"${DEFAULT_CHROMEOS_SERVER}/ubuntu"} |
| 339 | DEFAULT_DEV_SUITE=${CHROMEOS_DEV_SUITE:-"karmic"} |
| 340 | |
| 341 | DEFAULT_IMG_MIRROR=${CHROMEOS_IMG_MIRROR:-"${DEFAULT_CHROMEOS_SERVER}/ubuntu"} |
| 342 | DEFAULT_IMG_SUITE=${CHROMEOS_IMG_SUITE:-"karmic"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 343 | |
| 344 | # Default location for chroot |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 345 | DEFAULT_CHROOT_DIR=${CHROMEOS_CHROOT_DIR:-"${GCLIENT_ROOT}/chroot"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 346 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 347 | # 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] | 348 | # they don't pollute the source directory. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 349 | DEFAULT_BUILD_ROOT=${CHROMEOS_BUILD_ROOT:-"${SRC_ROOT}/build"} |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 350 | |
David McMahon | 4930294 | 2010-02-18 16:55:35 -0800 | [diff] [blame] | 351 | # Set up a global ALL_BOARDS value |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 352 | if [[ -d ${SRC_ROOT}/overlays ]]; then |
| 353 | ALL_BOARDS=$(cd "${SRC_ROOT}/overlays"; \ |
Mike Frysinger | a1a06ab | 2011-08-10 11:40:30 -0400 | [diff] [blame] | 354 | ls -1d overlay-* 2>&- | sed 's,overlay-,,g') |
David Rochberg | 3b91070 | 2010-12-02 10:45:21 -0500 | [diff] [blame] | 355 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 356 | # Normalize whitespace. |
| 357 | ALL_BOARDS=$(echo ${ALL_BOARDS}) |
Mike Frysinger | c17a493 | 2012-03-12 17:07:40 -0400 | [diff] [blame] | 358 | |
| 359 | # Sets the default board variable for calling script. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 360 | if [[ -f ${GCLIENT_ROOT}/src/scripts/.default_board ]]; then |
| 361 | DEFAULT_BOARD=$(<"${GCLIENT_ROOT}/src/scripts/.default_board") |
Mike Frysinger | c17a493 | 2012-03-12 17:07:40 -0400 | [diff] [blame] | 362 | # Check for user typos like whitespace. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 363 | if [[ -n ${DEFAULT_BOARD//[a-zA-Z0-9-_]} ]]; then |
Mike Frysinger | c17a493 | 2012-03-12 17:07:40 -0400 | [diff] [blame] | 364 | die ".default_board: invalid name detected; please fix:" \ |
| 365 | "'${DEFAULT_BOARD}'" |
| 366 | fi |
| 367 | fi |
| 368 | # Stub to get people to upgrade. |
| 369 | get_default_board() { |
| 370 | warn "please upgrade your script, and make sure to run build_packages" |
| 371 | } |
David McMahon | 4930294 | 2010-02-18 16:55:35 -0800 | [diff] [blame] | 372 | |
David James | ff07201 | 2010-11-30 13:22:05 -0800 | [diff] [blame] | 373 | # Enable --fast by default. |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 374 | DEFAULT_FAST=${FLAGS_TRUE} |
David James | 0366864 | 2010-07-28 17:08:29 -0700 | [diff] [blame] | 375 | |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 376 | # Directory to store built images. Should be set by sourcing script when used. |
| 377 | BUILD_DIR= |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 378 | |
| 379 | # Standard filenames |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 380 | CHROMEOS_BASE_IMAGE_NAME="chromiumos_base_image.bin" |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 381 | CHROMEOS_IMAGE_NAME="chromiumos_image.bin" |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 382 | CHROMEOS_DEVELOPER_IMAGE_NAME="chromiumos_image.bin" |
Gilad Arnold | 0836627 | 2012-02-08 10:46:26 -0800 | [diff] [blame] | 383 | CHROMEOS_RECOVERY_IMAGE_NAME="recovery_image.bin" |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 384 | CHROMEOS_TEST_IMAGE_NAME="chromiumos_test_image.bin" |
Chris Sosa | b885b80 | 2011-02-16 15:33:11 -0800 | [diff] [blame] | 385 | CHROMEOS_FACTORY_TEST_IMAGE_NAME="chromiumos_factory_image.bin" |
Chris Sosa | b0f5732 | 2011-10-25 03:07:23 +0000 | [diff] [blame] | 386 | CHROMEOS_FACTORY_INSTALL_SHIM_NAME="factory_install_shim.bin" |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 387 | |
Chris Sosa | aa1a7fd | 2010-04-02 14:06:29 -0700 | [diff] [blame] | 388 | # Install make for portage ebuilds. Used by build_image and gmergefs. |
Chris Masone | d11ce17 | 2010-11-09 14:22:08 -0800 | [diff] [blame] | 389 | # TODO: Is /usr/local/autotest-chrome still used by anyone? |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 390 | COMMON_INSTALL_MASK=" |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 391 | *.a |
| 392 | *.la |
Rene Bolldorf | 3222822 | 2012-07-21 14:18:22 -0400 | [diff] [blame] | 393 | *.h |
| 394 | *.hpp |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 395 | /etc/init.d |
| 396 | /etc/runlevels |
Hung-Te Lin | 76272be | 2012-08-07 19:10:09 +0800 | [diff] [blame] | 397 | /firmware |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 398 | /lib/rc |
| 399 | /usr/bin/Xnest |
| 400 | /usr/bin/Xvfb |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 401 | /usr/lib/debug |
| 402 | /usr/lib/gcc |
Mike Frysinger | 27b5edb | 2012-08-08 18:52:06 -0400 | [diff] [blame] | 403 | /usr/lib*/pkgconfig |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 404 | /usr/local/autotest-chrome |
| 405 | /usr/man |
| 406 | /usr/share/aclocal |
| 407 | /usr/share/doc |
| 408 | /usr/share/gettext |
| 409 | /usr/share/gtk-2.0 |
| 410 | /usr/share/gtk-doc |
| 411 | /usr/share/info |
| 412 | /usr/share/man |
| 413 | /usr/share/openrc |
| 414 | /usr/share/pkgconfig |
Ryan Harrison | b8bd594 | 2013-02-02 13:39:43 -0500 | [diff] [blame^] | 415 | /usr/share/profiling |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 416 | /usr/share/readline |
Chris Wolfe | d13775f | 2011-07-26 16:34:38 -0400 | [diff] [blame] | 417 | /usr/src |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 418 | " |
Chris Sosa | aa1a7fd | 2010-04-02 14:06:29 -0700 | [diff] [blame] | 419 | |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 420 | # Mask for base, dev, and test images (build_image, build_image --test) |
| 421 | DEFAULT_INSTALL_MASK=" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 422 | ${COMMON_INSTALL_MASK} |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 423 | /usr/local/autotest |
Joseph Hwang | ca63e04 | 2012-03-24 20:38:21 +0800 | [diff] [blame] | 424 | /lib/modules/*/kernel/drivers/input/misc/uinput.ko |
Olof Johansson | 1222b2e | 2012-08-08 15:27:35 -0700 | [diff] [blame] | 425 | /lib/modules/*/build |
| 426 | /lib/modules/*/source |
Kees Cook | 74f163b | 2012-12-18 15:46:51 -0800 | [diff] [blame] | 427 | test_*.ko |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 428 | " |
| 429 | |
| 430 | # Mask for factory test image (build_image --factory) |
| 431 | FACTORY_TEST_INSTALL_MASK=" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 432 | ${COMMON_INSTALL_MASK} |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 433 | */.svn |
| 434 | */CVS |
| 435 | /usr/local/autotest/[^c]* |
| 436 | /usr/local/autotest/conmux |
| 437 | /usr/local/autotest/client/deps/chrome_test |
| 438 | /usr/local/autotest/client/deps/piglit |
| 439 | /usr/local/autotest/client/deps/pyauto_dep |
| 440 | /usr/local/autotest/client/deps/realtimecomm_* |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 441 | /usr/local/autotest/client/site_tests/graphics_WebGLConformance |
| 442 | /usr/local/autotest/client/site_tests/platform_ToolchainOptions |
| 443 | /usr/local/autotest/client/site_tests/realtimecomm_GTalk* |
Jon Salz | d712ae9 | 2012-07-11 14:12:16 +0800 | [diff] [blame] | 444 | /usr/local/autotest/client/tests |
Jon Salz | 8c8186c | 2012-08-29 05:40:51 +0800 | [diff] [blame] | 445 | /usr/local/factory/bundle |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 446 | " |
| 447 | |
Chris Sosa | c9422fa | 2012-03-05 15:58:07 -0800 | [diff] [blame] | 448 | # Mask for factory install shim (build_image factory_install) |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 449 | FACTORY_SHIM_INSTALL_MASK=" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 450 | ${DEFAULT_INSTALL_MASK} |
Hung-Te Lin | d32c59f | 2012-01-19 19:54:01 +0800 | [diff] [blame] | 451 | /opt/[^g]* |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 452 | /opt/google/chrome |
| 453 | /opt/google/o3d |
| 454 | /opt/google/talkplugin |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 455 | /usr/lib/dri |
| 456 | /usr/lib/python2.6/test |
Vic Yang | 982556a | 2012-12-11 11:41:54 +0800 | [diff] [blame] | 457 | /usr/lib64/dri |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 458 | /usr/local/autotest-pkgs |
| 459 | /usr/share/X11 |
| 460 | /usr/share/chewing |
Vic Yang | 982556a | 2012-12-11 11:41:54 +0800 | [diff] [blame] | 461 | /usr/share/chromeos-assets |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 462 | /usr/share/fonts |
| 463 | /usr/share/ibus-pinyin |
| 464 | /usr/share/libhangul |
| 465 | /usr/share/locale |
| 466 | /usr/share/m17n |
| 467 | /usr/share/mime |
Vic Yang | 982556a | 2012-12-11 11:41:54 +0800 | [diff] [blame] | 468 | /usr/share/oem |
| 469 | /usr/share/pyzy |
Daniel Erat | e82f07c | 2010-12-21 13:39:22 -0800 | [diff] [blame] | 470 | /usr/share/sounds |
| 471 | /usr/share/tts |
| 472 | /usr/share/zoneinfo |
| 473 | " |
Tom Wai-Hong Tam | f87a367 | 2010-05-17 16:06:33 +0800 | [diff] [blame] | 474 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 475 | # ----------------------------------------------------------------------------- |
| 476 | # Functions |
| 477 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 478 | setup_board_warning() { |
tedbo | 373c390 | 2010-04-12 10:52:40 -0700 | [diff] [blame] | 479 | echo |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 480 | echo "${V_REVERSE}================ WARNING =====================${V_VIDOFF}" |
Chris Sosa | acada73 | 2010-02-23 15:20:03 -0800 | [diff] [blame] | 481 | echo |
| 482 | echo "*** No default board detected in " \ |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 483 | "${GCLIENT_ROOT}/src/scripts/.default_board" |
Chris Sosa | acada73 | 2010-02-23 15:20:03 -0800 | [diff] [blame] | 484 | echo "*** Either run setup_board with default flag set" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 485 | echo "*** or echo |board_name| > ${GCLIENT_ROOT}/src/scripts/.default_board" |
Chris Sosa | acada73 | 2010-02-23 15:20:03 -0800 | [diff] [blame] | 486 | echo |
| 487 | } |
| 488 | |
David James | 22dc2ba | 2012-11-29 15:46:58 -0800 | [diff] [blame] | 489 | is_nfs() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 490 | [[ $(stat -f -L -c %T "$1") == "nfs" ]] |
David James | 22dc2ba | 2012-11-29 15:46:58 -0800 | [diff] [blame] | 491 | } |
| 492 | |
| 493 | warn_if_nfs() { |
| 494 | if is_nfs "$1"; then |
| 495 | warn "$1 is on NFS. This is unsupported." |
| 496 | fi |
| 497 | } |
| 498 | |
Don Garrett | 640a058 | 2010-05-04 16:54:28 -0700 | [diff] [blame] | 499 | # Enter a chroot and restart the current script if needed |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 500 | restart_in_chroot_if_needed() { |
David Rochberg | 3b91070 | 2010-12-02 10:45:21 -0500 | [diff] [blame] | 501 | # NB: Pass in ARGV: restart_in_chroot_if_needed "$@" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 502 | if [[ ${INSIDE_CHROOT} -ne 1 ]]; then |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 503 | # Get inside_chroot path for script. |
| 504 | local chroot_path="$(reinterpret_path_for_chroot "$0")" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 505 | exec ${GCLIENT_ROOT}/chromite/bin/cros_sdk -- "${chroot_path}" "$@" |
Don Garrett | 640a058 | 2010-05-04 16:54:28 -0700 | [diff] [blame] | 506 | fi |
| 507 | } |
| 508 | |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 509 | # Fail unless we're inside the chroot. This guards against messing up your |
| 510 | # workstation. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 511 | assert_inside_chroot() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 512 | if [[ ${INSIDE_CHROOT} -ne 1 ]]; then |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 513 | echo "This script must be run inside the chroot. Run this first:" |
Zdenek Behan | 2811c16 | 2011-08-13 00:47:38 +0200 | [diff] [blame] | 514 | echo " cros_sdk" |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 515 | exit 1 |
| 516 | fi |
| 517 | } |
| 518 | |
| 519 | # Fail if we're inside the chroot. This guards against creating or entering |
| 520 | # nested chroots, among other potential problems. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 521 | assert_outside_chroot() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 522 | if [[ ${INSIDE_CHROOT} -ne 0 ]]; then |
rspangler@google.com | d74220d | 2009-10-09 20:56:14 +0000 | [diff] [blame] | 523 | echo "This script must be run outside the chroot." |
| 524 | exit 1 |
| 525 | fi |
| 526 | } |
| 527 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 528 | assert_not_root_user() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 529 | if [[ ${UID:-$(id -u)} == 0 ]]; then |
derat@google.com | 86dcc8e | 2009-11-21 19:49:49 +0000 | [diff] [blame] | 530 | echo "This script must be run as a non-root user." |
| 531 | exit 1 |
| 532 | fi |
| 533 | } |
| 534 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 535 | assert_root_user() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 536 | if [[ ${UID:-$(id -u)} != 0 ]] || [[ ${SUDO_USER:-root} == "root" ]]; then |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 537 | die_notrace "This script must be run using sudo from a non-root user." |
| 538 | fi |
| 539 | } |
| 540 | |
Luigi Semenzato | 1f82e12 | 2010-03-23 12:43:08 -0700 | [diff] [blame] | 541 | # Check that all arguments are flags; that is, there are no remaining arguments |
| 542 | # after parsing from shflags. Allow (with a warning) a single empty-string |
| 543 | # argument. |
| 544 | # |
| 545 | # TODO: fix buildbot so that it doesn't pass the empty-string parameter, |
| 546 | # then change this function. |
| 547 | # |
| 548 | # Usage: check_flags_only_and_allow_null_arg "$@" && set -- |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 549 | check_flags_only_and_allow_null_arg() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 550 | local do_shift=1 |
| 551 | if [[ $# -eq 1 ]] && [[ -z $1 ]]; then |
Luigi Semenzato | 1f82e12 | 2010-03-23 12:43:08 -0700 | [diff] [blame] | 552 | echo "$0: warning: ignoring null argument" >&2 |
| 553 | shift |
| 554 | do_shift=0 |
| 555 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 556 | if [[ $# -gt 0 ]]; then |
| 557 | echo "error: invalid arguments: \"$*\"" >&2 |
Luigi Semenzato | 1f82e12 | 2010-03-23 12:43:08 -0700 | [diff] [blame] | 558 | flags_help |
| 559 | exit 1 |
| 560 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 561 | return ${do_shift} |
Luigi Semenzato | 1f82e12 | 2010-03-23 12:43:08 -0700 | [diff] [blame] | 562 | } |
| 563 | |
Chris Sosa | aa1a7fd | 2010-04-02 14:06:29 -0700 | [diff] [blame] | 564 | # Removes single quotes around parameter |
| 565 | # Arguments: |
| 566 | # $1 - string which optionally has surrounding quotes |
| 567 | # Returns: |
| 568 | # None, but prints the string without quotes. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 569 | remove_quotes() { |
Chris Sosa | aa1a7fd | 2010-04-02 14:06:29 -0700 | [diff] [blame] | 570 | echo "$1" | sed -e "s/^'//; s/'$//" |
| 571 | } |
tedbo | 373c390 | 2010-04-12 10:52:40 -0700 | [diff] [blame] | 572 | |
| 573 | # Writes stdin to the given file name as root using sudo in overwrite mode. |
| 574 | # |
| 575 | # $1 - The output file name. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 576 | sudo_clobber() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 577 | sudo tee "$1" >/dev/null |
tedbo | 373c390 | 2010-04-12 10:52:40 -0700 | [diff] [blame] | 578 | } |
| 579 | |
| 580 | # Writes stdin to the given file name as root using sudo in append mode. |
| 581 | # |
| 582 | # $1 - The output file name. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 583 | sudo_append() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 584 | sudo tee -a "$1" >/dev/null |
tedbo | 373c390 | 2010-04-12 10:52:40 -0700 | [diff] [blame] | 585 | } |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 586 | |
Mike Frysinger | 286b592 | 2011-09-28 11:59:53 -0400 | [diff] [blame] | 587 | # Execute multiple commands in a single sudo. Generally will speed things |
| 588 | # up by avoiding multiple calls to `sudo`. If any commands fail, we will |
| 589 | # call die with the failing command. We can handle a max of ~100 commands, |
| 590 | # but hopefully no one will ever try that many at once. |
| 591 | # |
| 592 | # $@ - The commands to execute, one per arg. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 593 | sudo_multi() { |
Mike Frysinger | 286b592 | 2011-09-28 11:59:53 -0400 | [diff] [blame] | 594 | local i cmds |
| 595 | |
| 596 | # Construct the shell code to execute. It'll be of the form: |
| 597 | # ... && ( ( command ) || exit <command index> ) && ... |
| 598 | # This way we know which command exited. The exit status of |
| 599 | # the underlying command is lost, but we never cared about it |
| 600 | # in the first place (other than it is non zero), so oh well. |
| 601 | for (( i = 1; i <= $#; ++i )); do |
| 602 | cmds+=" && ( ( ${!i} ) || exit $(( i + 10 )) )" |
| 603 | done |
| 604 | |
| 605 | # Execute our constructed shell code. |
| 606 | sudo -- sh -c ":${cmds[*]}" && i=0 || i=$? |
| 607 | |
| 608 | # See if this failed, and if so, print out the failing command. |
| 609 | if [[ $i -gt 10 ]]; then |
| 610 | : $(( i -= 10 )) |
| 611 | die "sudo_multi failed: ${!i}" |
| 612 | elif [[ $i -ne 0 ]]; then |
| 613 | die "sudo_multi failed for unknown reason $i" |
| 614 | fi |
| 615 | } |
| 616 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 617 | # Writes stdin to the given file name as the sudo user in overwrite mode. |
| 618 | # |
| 619 | # $@ - The output file names. |
| 620 | user_clobber() { |
| 621 | install -m644 -o ${SUDO_UID} -g ${SUDO_GID} /dev/stdin "$@" |
| 622 | } |
| 623 | |
David James | 22dc2ba | 2012-11-29 15:46:58 -0800 | [diff] [blame] | 624 | # Copies the specified file owned by the user to the specified location. |
| 625 | # If the copy fails as root (e.g. due to root_squash and NFS), retry the copy |
| 626 | # with the user's account before failing. |
| 627 | user_cp() { |
| 628 | cp -p "$@" 2>/dev/null || sudo -u ${SUDO_USER} -- cp -p "$@" |
| 629 | } |
| 630 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 631 | # Appends stdin to the given file name as the sudo user. |
| 632 | # |
| 633 | # $1 - The output file name. |
| 634 | user_append() { |
| 635 | cat >> "$1" |
| 636 | chown ${SUDO_UID}:${SUDO_GID} "$1" |
| 637 | } |
| 638 | |
| 639 | # Create the specified directory, along with parents, as the sudo user. |
| 640 | # |
| 641 | # $@ - The directories to create. |
| 642 | user_mkdir() { |
| 643 | install -o ${SUDO_UID} -g ${SUDO_GID} -d "$@" |
| 644 | } |
| 645 | |
| 646 | # Create the specified symlink as the sudo user. |
| 647 | # |
| 648 | # $1 - Link target |
| 649 | # $2 - Link name |
| 650 | user_symlink() { |
| 651 | ln -sfT "$1" "$2" |
| 652 | chown -h ${SUDO_UID}:${SUDO_GID} "$2" |
| 653 | } |
| 654 | |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 655 | # Locate all mounts below a specified directory. |
| 656 | # |
| 657 | # $1 - The root tree. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 658 | sub_mounts() { |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 659 | # Assume that `mount` outputs a list of mount points in the order |
| 660 | # that things were mounted (since it always has and hopefully always |
| 661 | # will). As such, we have to unmount in reverse order to cleanly |
| 662 | # unmount submounts (think /dev/pts and /dev). |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 663 | awk -v path=$1 -v len="${#1}" \ |
Zdenek Behan | 1d5d3b5 | 2012-05-01 01:58:48 +0200 | [diff] [blame] | 664 | '(substr($2, 1, len) == path) { print $2 }' /proc/mounts | \ |
Zdenek Behan | 52970f4 | 2012-08-30 22:36:40 +0200 | [diff] [blame] | 665 | tac | \ |
| 666 | sed -e 's/\\040(deleted)$//' |
| 667 | # Hack(zbehan): If a bind mount's source is mysteriously removed, |
| 668 | # we'd end up with an orphaned mount with the above string in its name. |
| 669 | # It can only be seen through /proc/mounts and will stick around even |
| 670 | # when it should be gone already. crosbug.com/31250 |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 671 | } |
| 672 | |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 673 | # Unmounts a directory, if the unmount fails, warn, and then lazily unmount. |
| 674 | # |
| 675 | # $1 - The path to unmount. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 676 | safe_umount_tree() { |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 677 | local mounts=$(sub_mounts "$1") |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 678 | |
Mike Frysinger | e8aec37 | 2011-09-21 00:03:22 -0400 | [diff] [blame] | 679 | # Hmm, this shouldn't normally happen, but anything is possible. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 680 | if [[ -z ${mounts} ]]; then |
Mike Frysinger | e8aec37 | 2011-09-21 00:03:22 -0400 | [diff] [blame] | 681 | return 0 |
| 682 | fi |
| 683 | |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 684 | # First try to unmount in one shot to speed things up. |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 685 | if safe_umount -d ${mounts}; then |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 686 | return 0 |
| 687 | fi |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 688 | |
David James | d9b6798 | 2012-10-26 09:46:50 -0700 | [diff] [blame] | 689 | # Check whether our mounts were successfully unmounted. |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 690 | mounts=$(sub_mounts "$1") |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 691 | if [[ -z ${mounts} ]]; then |
David James | d9b6798 | 2012-10-26 09:46:50 -0700 | [diff] [blame] | 692 | warn "umount failed, but devices were unmounted anyway" |
| 693 | return 0 |
| 694 | fi |
| 695 | |
| 696 | # Well that didn't work, so lazy unmount remaining ones. |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 697 | warn "Failed to unmount ${mounts}" |
| 698 | warn "Doing a lazy unmount" |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 699 | if ! safe_umount -d -l ${mounts}; then |
Mike Frysinger | 1aa6124 | 2011-09-15 17:46:44 -0400 | [diff] [blame] | 700 | mounts=$(sub_mounts "$1") |
| 701 | die "Failed to lazily unmount ${mounts}" |
robotboy | 9891221 | 2010-04-12 14:08:14 -0700 | [diff] [blame] | 702 | fi |
| 703 | } |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 704 | |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 705 | |
David James | 7676488 | 2012-10-24 19:46:29 -0700 | [diff] [blame] | 706 | # Run umount as root. |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 707 | safe_umount() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 708 | $([[ ${UID:-$(id -u)} != 0 ]] && echo sudo) umount "$@" |
Brian Harring | ece65e0 | 2012-08-30 13:42:21 -0700 | [diff] [blame] | 709 | } |
| 710 | |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 711 | get_git_id() { |
| 712 | git var GIT_COMMITTER_IDENT | sed -e 's/^.*<\(\S\+\)>.*$/\1/' |
| 713 | } |
| 714 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 715 | # Fixes symlinks that are incorrectly prefixed with the build root $1 |
Chris Sosa | d445502 | 2010-05-20 10:14:06 -0700 | [diff] [blame] | 716 | # rather than the real running root '/'. |
| 717 | # TODO(sosa) - Merge setup - cleanup below with this method. |
| 718 | fix_broken_symlinks() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 719 | local build_root=$1 |
Chris Sosa | d445502 | 2010-05-20 10:14:06 -0700 | [diff] [blame] | 720 | local symlinks=$(find "${build_root}/usr/local" -lname "${build_root}/*") |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 721 | local symlink |
Chris Sosa | d445502 | 2010-05-20 10:14:06 -0700 | [diff] [blame] | 722 | for symlink in ${symlinks}; do |
| 723 | echo "Fixing ${symlink}" |
| 724 | local target=$(ls -l "${symlink}" | cut -f 2 -d '>') |
| 725 | # Trim spaces from target (bashism). |
| 726 | target=${target/ /} |
| 727 | # Make new target (removes rootfs prefix). |
| 728 | new_target=$(echo ${target} | sed "s#${build_root}##") |
| 729 | |
| 730 | echo "Fixing symlink ${symlink}" |
| 731 | sudo unlink "${symlink}" |
| 732 | sudo ln -sf "${new_target}" "${symlink}" |
| 733 | done |
| 734 | } |
| 735 | |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 736 | # Sets up symlinks for the developer root. It is necessary to symlink |
| 737 | # usr and local since the developer root is mounted at /usr/local and |
| 738 | # applications expect to be installed under /usr/local/bin, etc. |
| 739 | # This avoids packages installing into /usr/local/usr/local/bin. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 740 | # $1 specifies the symlink target for the developer root. |
| 741 | # $2 specifies the symlink target for the var directory. |
| 742 | # $3 specifies the location of the stateful partition. |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 743 | setup_symlinks_on_root() { |
| 744 | # Give args better names. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 745 | local dev_image_target=$1 |
| 746 | local var_target=$2 |
| 747 | local dev_image_root="$3/dev_image" |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 748 | |
| 749 | # If our var target is actually the standard var, we are cleaning up the |
| 750 | # symlinks (could also check for /usr/local for the dev_image_target). |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 751 | if [[ ${var_target} == "/var" ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 752 | echo "Cleaning up /usr/local symlinks for ${dev_image_root}" |
| 753 | else |
| 754 | echo "Setting up symlinks for /usr/local for ${dev_image_root}" |
| 755 | fi |
| 756 | |
| 757 | # Set up symlinks that should point to ${dev_image_target}. |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 758 | local path |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 759 | for path in usr local; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 760 | if [[ -h ${dev_image_root}/${path} ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 761 | sudo unlink "${dev_image_root}/${path}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 762 | elif [[ -e ${dev_image_root}/${path} ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 763 | die "${dev_image_root}/${path} should be a symlink if exists" |
| 764 | fi |
Mike Frysinger | a1a06ab | 2011-08-10 11:40:30 -0400 | [diff] [blame] | 765 | sudo ln -s "${dev_image_target}" "${dev_image_root}/${path}" |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 766 | done |
| 767 | |
| 768 | # Setup var symlink. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 769 | if [[ -h ${dev_image_root}/var ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 770 | sudo unlink "${dev_image_root}/var" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 771 | elif [[ -e ${dev_image_root}/var ]]; then |
Chris Sosa | 702618f | 2010-05-14 12:52:32 -0700 | [diff] [blame] | 772 | die "${dev_image_root}/var should be a symlink if it exists" |
| 773 | fi |
| 774 | |
| 775 | sudo ln -s "${var_target}" "${dev_image_root}/var" |
| 776 | } |
Nick Sanders | d250927 | 2010-06-16 03:50:04 -0700 | [diff] [blame] | 777 | |
Will Drewry | 55b42c9 | 2010-10-20 15:44:11 -0500 | [diff] [blame] | 778 | # These two helpers clobber the ro compat value in our root filesystem. |
| 779 | # |
| 780 | # When the system is built with --enable_rootfs_verification, bit-precise |
| 781 | # integrity checking is performed. That precision poses a usability issue on |
| 782 | # systems that automount partitions with recognizable filesystems, such as |
| 783 | # ext2/3/4. When the filesystem is mounted 'rw', ext2 metadata will be |
| 784 | # automatically updated even if no other writes are performed to the |
| 785 | # filesystem. In addition, ext2+ does not support a "read-only" flag for a |
| 786 | # given filesystem. That said, forward and backward compatibility of |
| 787 | # filesystem features are supported by tracking if a new feature breaks r/w or |
| 788 | # just write compatibility. We abuse the read-only compatibility flag[1] in |
| 789 | # the filesystem header by setting the high order byte (le) to FF. This tells |
| 790 | # the kernel that features R24-R31 are all enabled. Since those features are |
| 791 | # undefined on all ext-based filesystem, all standard kernels will refuse to |
| 792 | # mount the filesystem as read-write -- only read-only[2]. |
| 793 | # |
| 794 | # [1] 32-bit flag we are modifying: |
| 795 | # http://git.chromium.org/cgi-bin/gitweb.cgi?p=kernel.git;a=blob;f=include/linux/ext2_fs.h#l417 |
| 796 | # [2] Mount behavior is enforced here: |
| 797 | # http://git.chromium.org/cgi-bin/gitweb.cgi?p=kernel.git;a=blob;f=fs/ext2/super.c#l857 |
| 798 | # |
| 799 | # N.B., if the high order feature bits are used in the future, we will need to |
| 800 | # revisit this technique. |
| 801 | disable_rw_mount() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 802 | local rootfs=$1 |
Will Drewry | 55b42c9 | 2010-10-20 15:44:11 -0500 | [diff] [blame] | 803 | local offset="${2-0}" # in bytes |
Will Drewry | 9b7cb51 | 2010-10-20 18:11:24 -0500 | [diff] [blame] | 804 | local ro_compat_offset=$((0x464 + 3)) # Set 'highest' byte |
| 805 | printf '\377' | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 806 | sudo dd of="${rootfs}" seek=$((offset + ro_compat_offset)) \ |
Will Drewry | 55b42c9 | 2010-10-20 15:44:11 -0500 | [diff] [blame] | 807 | conv=notrunc count=1 bs=1 |
| 808 | } |
| 809 | |
| 810 | enable_rw_mount() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 811 | local rootfs=$1 |
Will Drewry | 55b42c9 | 2010-10-20 15:44:11 -0500 | [diff] [blame] | 812 | local offset="${2-0}" |
Will Drewry | 9b7cb51 | 2010-10-20 18:11:24 -0500 | [diff] [blame] | 813 | local ro_compat_offset=$((0x464 + 3)) # Set 'highest' byte |
| 814 | printf '\000' | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 815 | sudo dd of="${rootfs}" seek=$((offset + ro_compat_offset)) \ |
Will Drewry | 55b42c9 | 2010-10-20 15:44:11 -0500 | [diff] [blame] | 816 | conv=notrunc count=1 bs=1 |
| 817 | } |
| 818 | |
Nick Sanders | d250927 | 2010-06-16 03:50:04 -0700 | [diff] [blame] | 819 | # Get current timestamp. Assumes common.sh runs at startup. |
| 820 | start_time=$(date +%s) |
| 821 | |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 822 | # Get time elapsed since start_time in seconds. |
| 823 | get_elapsed_seconds() { |
Greg Spencer | 798d75f | 2011-02-01 22:04:49 -0800 | [diff] [blame] | 824 | local end_time=$(date +%s) |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 825 | local elapsed_seconds=$(( end_time - start_time )) |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 826 | echo ${elapsed_seconds} |
| 827 | } |
| 828 | |
| 829 | # Print time elapsed since start_time. |
| 830 | print_time_elapsed() { |
| 831 | # Optional first arg to specify elapsed_seconds. If not given, will |
| 832 | # recalculate elapsed time to now. Optional second arg to specify |
| 833 | # command name associated with elapsed time. |
| 834 | local elapsed_seconds=${1:-$(get_elapsed_seconds)} |
| 835 | local cmd_base=${2:-} |
| 836 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 837 | local minutes=$(( elapsed_seconds / 60 )) |
| 838 | local seconds=$(( elapsed_seconds % 60 )) |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 839 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 840 | if [[ -n ${cmd_base} ]]; then |
Matt Tennant | 298f61a | 2012-06-25 21:54:33 -0700 | [diff] [blame] | 841 | info "Elapsed time (${cmd_base}): ${minutes}m${seconds}s" |
| 842 | else |
| 843 | info "Elapsed time: ${minutes}m${seconds}s" |
| 844 | fi |
| 845 | } |
| 846 | |
| 847 | # Associative array for filling in extra command-specific stats before |
| 848 | # calling command_completed. |
| 849 | declare -A EXTRA_COMMAND_STATS |
| 850 | |
| 851 | # Save original command line. |
| 852 | command_line_arr=( "$0" "$@" ) |
| 853 | |
| 854 | command_completed() { |
| 855 | # Call print_elapsed_time regardless. |
| 856 | local run_time=$(get_elapsed_seconds) |
| 857 | local cmd_base=$(basename "${command_line_arr[0]}") |
| 858 | print_time_elapsed ${run_time} ${cmd_base} |
| 859 | |
| 860 | # Prepare command stats in an associative array. Additonal command-specific |
| 861 | # stats can be added through EXTRA_COMMAND_STATS associative array. |
| 862 | declare -A stats |
| 863 | stats=( |
| 864 | [cmd_line]=${command_line_arr[*]} |
| 865 | [cmd_base]=${cmd_base} |
| 866 | [cmd_args]=${command_line_arr[*]:1} |
| 867 | [run_time]=${run_time} |
| 868 | [username]=$(get_git_id) |
| 869 | [board]=${FLAGS_board} |
| 870 | [host]=$(hostname -f) |
| 871 | [cpu_count]=$(grep -c processor /proc/cpuinfo) |
| 872 | [cpu_type]=$(uname -p) |
| 873 | ) |
| 874 | |
| 875 | local attr |
| 876 | for attr in "${!EXTRA_COMMAND_STATS[@]}"; do |
| 877 | stats[${attr}]=${EXTRA_COMMAND_STATS[${attr}]} |
| 878 | done |
| 879 | |
| 880 | # Prepare temporary file for stats. |
| 881 | local tmpfile=$(mktemp -t tmp.stats.XXXXXX) |
| 882 | trap "rm -f '${tmpfile}'" EXIT |
| 883 | |
| 884 | # Write stats out to temporary file. |
| 885 | echo "Chromium OS Build Command Stats - Version 1" > "${tmpfile}" |
| 886 | for attr in "${!stats[@]}"; do |
| 887 | echo "${attr} ${stats[${attr}]}" |
| 888 | done >> "${tmpfile}" |
| 889 | |
| 890 | # Call upload_command_stats on the stats file. If it fails do not stop. |
| 891 | "${GCLIENT_ROOT}"/chromite/bin/upload_command_stats "${tmpfile}" || true |
| 892 | |
| 893 | rm "${tmpfile}" |
| 894 | trap - EXIT |
Nick Sanders | d250927 | 2010-06-16 03:50:04 -0700 | [diff] [blame] | 895 | } |
Doug Anderson | 0c9e88d | 2010-10-19 14:49:39 -0700 | [diff] [blame] | 896 | |
Anton Staaf | 9bcd841 | 2011-01-24 15:27:14 -0800 | [diff] [blame] | 897 | # The board and variant command line options can be used in a number of ways |
| 898 | # to specify the board and variant. The board can encode both pieces of |
| 899 | # information separated by underscores. Or the variant can be passed using |
| 900 | # the separate variant option. This function extracts the canonical board and |
| 901 | # variant information and provides it in the BOARD, VARIANT and BOARD_VARIANT |
| 902 | # variables. |
| 903 | get_board_and_variant() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 904 | local flags_board=$1 |
| 905 | local flags_variant=$2 |
Anton Staaf | 9bcd841 | 2011-01-24 15:27:14 -0800 | [diff] [blame] | 906 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 907 | BOARD=$(echo "${flags_board}" | cut -d '_' -f 1) |
| 908 | VARIANT=${flags_variant:-$(echo "${flags_board}" | cut -s -d '_' -f 2)} |
Anton Staaf | 9bcd841 | 2011-01-24 15:27:14 -0800 | [diff] [blame] | 909 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 910 | BOARD_VARIANT=${BOARD} |
| 911 | if [[ -n ${VARIANT} ]]; then |
| 912 | BOARD_VARIANT+="_${VARIANT}" |
Anton Staaf | 9bcd841 | 2011-01-24 15:27:14 -0800 | [diff] [blame] | 913 | fi |
| 914 | } |
Simon Glass | 142ca06 | 2011-02-09 13:39:43 -0800 | [diff] [blame] | 915 | |
Anton Staaf | 6f5262d | 2011-03-02 09:35:54 -0800 | [diff] [blame] | 916 | # Check that the specified file exists. If the file path is empty or the file |
| 917 | # doesn't exist on the filesystem generate useful error messages. Otherwise |
| 918 | # show the user the name and path of the file that will be used. The padding |
| 919 | # parameter can be used to tabulate multiple name:path pairs. For example: |
| 920 | # |
| 921 | # check_for_file "really long name" "...:" "file.foo" |
| 922 | # check_for_file "short name" ".........:" "another.bar" |
| 923 | # |
| 924 | # Results in the following output: |
| 925 | # |
| 926 | # Using really long name...: file.foo |
| 927 | # Using short name.........: another.bar |
| 928 | # |
| 929 | # If tabulation is not required then passing "" for padding generates the |
| 930 | # output "Using <name> <path>" |
| 931 | check_for_file() { |
| 932 | local name=$1 |
| 933 | local padding=$2 |
| 934 | local path=$3 |
| 935 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 936 | if [[ -z ${path} ]]; then |
Anton Staaf | 6f5262d | 2011-03-02 09:35:54 -0800 | [diff] [blame] | 937 | die "No ${name} file specified." |
| 938 | fi |
| 939 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 940 | if [[ ! -e ${path} ]]; then |
Anton Staaf | 6f5262d | 2011-03-02 09:35:54 -0800 | [diff] [blame] | 941 | die "No ${name} file found at: ${path}" |
| 942 | else |
| 943 | info "Using ${name}${padding} ${path}" |
| 944 | fi |
| 945 | } |
| 946 | |
| 947 | # Check that the specified tool exists. If it does not exist in the PATH |
| 948 | # generate a useful error message indicating how to install the ebuild |
| 949 | # that contains the required tool. |
| 950 | check_for_tool() { |
| 951 | local tool=$1 |
| 952 | local ebuild=$2 |
| 953 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 954 | if ! which "${tool}" >/dev/null; then |
Anton Staaf | 6f5262d | 2011-03-02 09:35:54 -0800 | [diff] [blame] | 955 | error "The ${tool} utility was not found in your path. Run the following" |
| 956 | error "command in your chroot to install it: sudo -E emerge ${ebuild}" |
| 957 | exit 1 |
| 958 | fi |
| 959 | } |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 960 | |
| 961 | # Reinterprets path from outside the chroot for use inside. |
| 962 | # Returns "" if "" given. |
| 963 | # $1 - The path to reinterpret. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 964 | reinterpret_path_for_chroot() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 965 | if [[ ${INSIDE_CHROOT} -ne 1 ]]; then |
| 966 | if [[ -z $1 ]]; then |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 967 | echo "" |
| 968 | else |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 969 | local path_abs_path=$(readlink -f "$1") |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 970 | local gclient_root_abs_path=$(readlink -f "${GCLIENT_ROOT}") |
| 971 | |
| 972 | # Strip the repository root from the path. |
| 973 | local relative_path=$(echo ${path_abs_path} \ |
Mike Frysinger | a1a06ab | 2011-08-10 11:40:30 -0400 | [diff] [blame] | 974 | | sed "s:${gclient_root_abs_path}/::") |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 975 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 976 | if [[ ${relative_path} == "${path_abs_path}" ]]; then |
| 977 | die "Error reinterpreting path. Path $1 is not within source tree." |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 978 | fi |
| 979 | |
| 980 | # Prepend the chroot repository path. |
| 981 | echo "/home/${USER}/trunk/${relative_path}" |
| 982 | fi |
| 983 | else |
| 984 | # Path is already inside the chroot :). |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 985 | echo "$1" |
Chris Sosa | fd2cdec | 2011-03-24 16:06:59 -0700 | [diff] [blame] | 986 | fi |
| 987 | } |
Gabe Black | 83d8b82 | 2011-08-01 17:50:09 -0700 | [diff] [blame] | 988 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 989 | emerge_custom_kernel() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 990 | local install_root=$1 |
David James | dee866c | 2012-03-15 14:53:19 -0700 | [diff] [blame] | 991 | local root=/build/${FLAGS_board} |
David James | 0ea96e4 | 2011-08-03 11:53:50 -0700 | [diff] [blame] | 992 | local tmp_pkgdir=${root}/custom-packages |
| 993 | |
| 994 | # Clean up any leftover state in custom directories. |
Mike Frysinger | a1a06ab | 2011-08-10 11:40:30 -0400 | [diff] [blame] | 995 | sudo rm -rf "${tmp_pkgdir}" |
David James | 0ea96e4 | 2011-08-03 11:53:50 -0700 | [diff] [blame] | 996 | |
| 997 | # Update chromeos-initramfs to contain the latest binaries from the build |
| 998 | # tree. This is basically just packaging up already-built binaries from |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 999 | # ${root}. We are careful not to muck with the existing prebuilts so that |
David James | 0ea96e4 | 2011-08-03 11:53:50 -0700 | [diff] [blame] | 1000 | # prebuilts can be uploaded in parallel. |
| 1001 | # TODO(davidjames): Implement ABI deps so that chromeos-initramfs will be |
| 1002 | # rebuilt automatically when its dependencies change. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1003 | sudo -E PKGDIR="${tmp_pkgdir}" ${EMERGE_BOARD_CMD} -1 \ |
David James | 0ea96e4 | 2011-08-03 11:53:50 -0700 | [diff] [blame] | 1004 | chromeos-base/chromeos-initramfs || die "Cannot emerge chromeos-initramfs" |
| 1005 | |
| 1006 | # Verify all dependencies of the kernel are installed. This should be a |
| 1007 | # no-op, but it's good to check in case a developer didn't run |
Mike Frysinger | 0957a18 | 2012-03-21 23:17:14 -0400 | [diff] [blame] | 1008 | # build_packages. We need the expand_virtual call to workaround a bug |
| 1009 | # in portage where it only installs the virtual pkg. |
| 1010 | local kernel=$(portageq-${FLAGS_board} expand_virtual ${root} \ |
| 1011 | virtual/linux-sources) |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1012 | sudo -E PKGDIR="${tmp_pkgdir}" ${EMERGE_BOARD_CMD} --onlydeps \ |
David James | 0ea96e4 | 2011-08-03 11:53:50 -0700 | [diff] [blame] | 1013 | ${kernel} || die "Cannot emerge kernel dependencies" |
| 1014 | |
| 1015 | # Build the kernel. This uses the standard root so that we can pick up the |
| 1016 | # initramfs from there. But we don't actually install the kernel to the |
| 1017 | # standard root, because that'll muck up the kernel debug symbols there, |
| 1018 | # which we want to upload in parallel. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1019 | sudo -E PKGDIR="${tmp_pkgdir}" ${EMERGE_BOARD_CMD} --buildpkgonly \ |
David James | 0ea96e4 | 2011-08-03 11:53:50 -0700 | [diff] [blame] | 1020 | ${kernel} || die "Cannot emerge kernel" |
| 1021 | |
| 1022 | # Install the custom kernel to the provided install root. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1023 | sudo -E PKGDIR="${tmp_pkgdir}" ${EMERGE_BOARD_CMD} --usepkgonly \ |
David James | 0ea96e4 | 2011-08-03 11:53:50 -0700 | [diff] [blame] | 1024 | --root=${install_root} ${kernel} || die "Cannot emerge kernel to root" |
| 1025 | } |
Brian Harring | feb04f7 | 2012-02-03 21:22:50 -0800 | [diff] [blame] | 1026 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 1027 | enable_strict_sudo() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1028 | if [[ -z ${CROS_SUDO_KEEP_ALIVE} ]]; then |
Brian Harring | feb04f7 | 2012-02-03 21:22:50 -0800 | [diff] [blame] | 1029 | echo "$0 was somehow invoked in a way that the sudo keep alive could" |
| 1030 | echo "not be found. Failing due to this. See crosbug.com/18393." |
| 1031 | exit 126 |
| 1032 | fi |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1033 | sudo() { |
| 1034 | $(type -P sudo) -n "$@" |
Brian Harring | feb04f7 | 2012-02-03 21:22:50 -0800 | [diff] [blame] | 1035 | } |
| 1036 | } |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1037 | |
Chris Wolfe | 21a27b7 | 2012-02-27 13:00:51 -0500 | [diff] [blame] | 1038 | # Checks that stdin and stderr are both terminals. |
| 1039 | # If so, we assume that there is a live user we can interact with. |
| 1040 | # This check can be overridden by setting the CROS_NO_PROMPT environment |
| 1041 | # variable to a non-empty value. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 1042 | is_interactive() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1043 | [[ -z ${CROS_NO_PROMPT} && -t 0 && -t 2 ]] |
Chris Wolfe | 21a27b7 | 2012-02-27 13:00:51 -0500 | [diff] [blame] | 1044 | } |
| 1045 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 1046 | assert_interactive() { |
Chris Wolfe | 21a27b7 | 2012-02-27 13:00:51 -0500 | [diff] [blame] | 1047 | if ! is_interactive; then |
| 1048 | die "Script ${0##*/} tried to get user input on a non-interactive terminal." |
| 1049 | fi |
| 1050 | } |
| 1051 | |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1052 | # Selection menu with a default option: this is similar to bash's select |
| 1053 | # built-in, only that in case of an empty selection it'll return the default |
| 1054 | # choice. Like select, it uses PS3 as the prompt. |
| 1055 | # |
| 1056 | # $1: name of variable to be assigned the selected value; it better not be of |
| 1057 | # the form choose_foo to avoid conflict with local variables. |
| 1058 | # $2: default value to return in case of an empty user entry. |
| 1059 | # $3: value to return in case of an invalid choice. |
| 1060 | # $...: options for selection. |
| 1061 | # |
| 1062 | # Usage example: |
| 1063 | # |
| 1064 | # PS3="Select one [1]: " |
| 1065 | # choose reply "foo" "ERROR" "foo" "bar" "foobar" |
| 1066 | # |
| 1067 | # This will present the following menu and prompt: |
| 1068 | # |
| 1069 | # 1) foo |
| 1070 | # 2) bar |
| 1071 | # 3) foobar |
| 1072 | # Select one [1]: |
| 1073 | # |
| 1074 | # The return value will be stored in a variable named 'reply'. If the input is |
| 1075 | # 1, 2 or 3, the return value will be "foo", "bar" or "foobar", respectively. |
| 1076 | # If it is empty (i.e. the user clicked Enter) it will be "foo". Anything else |
| 1077 | # will return "ERROR". |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 1078 | choose() { |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1079 | typeset -i choose_i=1 |
| 1080 | |
| 1081 | # Retrieve output variable name and default return value. |
| 1082 | local choose_reply=$1 |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1083 | local choose_default=$2 |
| 1084 | local choose_invalid=$3 |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1085 | shift 3 |
| 1086 | |
| 1087 | # Select a return value |
| 1088 | unset REPLY |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1089 | if [[ $# -gt 0 ]]; then |
Chris Wolfe | 21a27b7 | 2012-02-27 13:00:51 -0500 | [diff] [blame] | 1090 | assert_interactive |
| 1091 | |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1092 | # Actual options provided, present a menu and prompt for a choice. |
| 1093 | local choose_opt |
| 1094 | for choose_opt in "$@"; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1095 | echo "${choose_i}) ${choose_opt}" >&2 |
| 1096 | : $(( ++choose_i )) |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1097 | done |
| 1098 | read -p "$PS3" |
| 1099 | fi |
| 1100 | # Filter out strings containing non-digits. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1101 | if [[ ${REPLY} != "${REPLY%%[!0-9]*}" ]]; then |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1102 | REPLY=0 |
| 1103 | fi |
| 1104 | choose_i="${REPLY}" |
| 1105 | |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1106 | if [[ ${choose_i} -ge 1 && ${choose_i} -le $# ]]; then |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1107 | # Valid choice, return the corresponding value. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1108 | eval ${choose_reply}=\""${!choose_i}"\" |
| 1109 | elif [[ -z ${REPLY} ]]; then |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1110 | # Empty choice, return default value. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1111 | eval ${choose_reply}=\""${choose_default}"\" |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1112 | else |
| 1113 | # Invalid choice, return corresponding value. |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1114 | eval ${choose_reply}=\""${choose_invalid}\"" |
Gilad Arnold | 207a7c7 | 2012-02-09 10:19:16 -0800 | [diff] [blame] | 1115 | fi |
| 1116 | } |
David James | 855afb7 | 2012-03-14 20:04:59 -0700 | [diff] [blame] | 1117 | |
| 1118 | # Display --help if requested. This is used to hide options from help |
| 1119 | # that are not intended for developer use. |
| 1120 | # |
| 1121 | # How to use: |
| 1122 | # 1) Declare the options that you want to appear in help. |
| 1123 | # 2) Call this function. |
| 1124 | # 3) Declare the options that you don't want to appear in help. |
| 1125 | # |
| 1126 | # See build_packages for example usage. |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 1127 | show_help_if_requested() { |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1128 | local opt |
David James | 855afb7 | 2012-03-14 20:04:59 -0700 | [diff] [blame] | 1129 | for opt in "$@"; do |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1130 | if [[ ${opt} == "-h" || ${opt} == "--help" ]]; then |
David James | 855afb7 | 2012-03-14 20:04:59 -0700 | [diff] [blame] | 1131 | flags_help |
| 1132 | exit 0 |
| 1133 | fi |
| 1134 | done |
| 1135 | } |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 1136 | |
Mike Frysinger | 6b1abb2 | 2012-05-11 13:44:06 -0400 | [diff] [blame] | 1137 | switch_to_strict_mode() { |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 1138 | # Set up strict execution mode; note that the trap |
| 1139 | # must follow switch_to_strict_mode, else it will have no effect. |
| 1140 | set -e |
| 1141 | trap 'die_err_trap "${BASH_COMMAND:-command unknown}" "$?"' ERR |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1142 | if [[ $# -ne 0 ]]; then |
Brian Harring | 7f175a5 | 2012-03-02 05:37:00 -0800 | [diff] [blame] | 1143 | set "$@" |
| 1144 | fi |
| 1145 | } |
| 1146 | |
| 1147 | # TODO: Re-enable this once shflags is set -e safe. |
| 1148 | #switch_to_strict_mode |
Brian Harring | f264b82 | 2012-09-01 01:39:03 -0700 | [diff] [blame] | 1149 | |
Kris Rambish | 4404791 | 2012-09-14 16:56:11 -0700 | [diff] [blame] | 1150 | okboat() { |
| 1151 | # http://www.chris.com/ascii/index.php?art=transportation/nautical |
| 1152 | echo -e "${V_BOLD_GREEN}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1153 | cat <<BOAT |
Kris Rambish | 4404791 | 2012-09-14 16:56:11 -0700 | [diff] [blame] | 1154 | . o .. |
| 1155 | o . o o.o |
| 1156 | ...oo_ |
| 1157 | _[__\___ |
| 1158 | __|_o_o_o_o\__ |
| 1159 | OK \' ' ' ' ' ' / |
| 1160 | ^^^^^^^^^^^^^^^^^^^^ |
| 1161 | BOAT |
| 1162 | echo -e "${V_VIDOFF}" |
| 1163 | } |
| 1164 | |
| 1165 | failboat() { |
| 1166 | echo -e "${V_BOLD_RED}" |
Mike Frysinger | baae8eb | 2013-01-15 01:34:26 -0500 | [diff] [blame] | 1167 | cat <<BOAT |
Kris Rambish | 4404791 | 2012-09-14 16:56:11 -0700 | [diff] [blame] | 1168 | ' |
| 1169 | ' ) |
| 1170 | ) ( |
| 1171 | ( .') __/\ |
| 1172 | (. /o/` \ |
| 1173 | __/o/` \ |
| 1174 | FAIL / /o/` / |
| 1175 | ^^^^^^^^^^^^^^^^^^^^ |
| 1176 | BOAT |
| 1177 | echo -e "${V_VIDOFF}" |
| 1178 | die "$* failed" |
| 1179 | } |