build/android/adb_gdb

   1 #!/bin/bash
   2 #
   3 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   4 # Use of this source code is governed by a BSD-style license that can be
   5 # found in the LICENSE file.
   6 #
   7
   8 # A generic script used to attach to a running Chromium process and
   9 # debug it. Most users should not use this directly, but one of the
  10 # wrapper scripts like adb_gdb_content_shell
  11 #
  12 # Use --help to print full usage instructions.
  13 #
  14
  15 PROGNAME=$(basename "$0")
  16 PROGDIR=$(dirname "$0")
  17
  18 # Location of Chromium-top-level sources.
  19 CHROMIUM_SRC=$(cd "$PROGDIR"/../.. >/dev/null && pwd 2>/dev/null)
  20
  21 # Location of Chromium out/ directory.
  22 if [ -z "$CHROMIUM_OUT_DIR" ]; then
  23   CHROMIUM_OUT_DIR=out
  24 fi
  25
  26 TMPDIR=
  27 GDBSERVER_PIDFILE=
  28 TARGET_GDBSERVER=
  29
  30 clean_exit () {
  31   if [ "$TMPDIR" ]; then
  32     GDBSERVER_PID=$(cat $GDBSERVER_PIDFILE 2>/dev/null)
  33     if [ "$GDBSERVER_PID" ]; then
  34       log "Killing background gdbserver process: $GDBSERVER_PID"
  35       kill -9 $GDBSERVER_PID >/dev/null 2>&1
  36     fi
  37     if [ "$TARGET_GDBSERVER" ]; then
  38       log "Removing target gdbserver binary: $TARGET_GDBSERVER."
  39       "$ADB" shell run-as "$PACKAGE_NAME" rm "$TARGET_GDBSERVER" >/dev/null 2>&1
  40     fi
  41     log "Cleaning up: $TMPDIR"
  42     rm -rf "$TMPDIR"
  43   fi
  44   trap "" EXIT
  45   exit $1
  46 }
  47
  48 # Ensure clean exit on Ctrl-C or normal exit.
  49 trap "clean_exit 1" INT HUP QUIT TERM
  50 trap "clean_exit \$?" EXIT
  51
  52 panic () {
  53   echo "ERROR: $@" >&2
  54   exit 1
  55 }
  56
  57 fail_panic () {
  58   if [ $? != 0 ]; then panic "$@"; fi
  59 }
  60
  61 log () {
  62   if [ "$VERBOSE" -gt 0 ]; then
  63     echo "$@"
  64   fi
  65 }
  66
  67 DEFAULT_PULL_LIBS_DIR=/tmp/$USER-adb-gdb-libs
  68
  69 # NOTE: Allow wrapper scripts to set various default through ADB_GDB_XXX
  70 # environment variables. This is only for cosmetic reasons, i.e. to
  71 # display proper
  72
  73 # Allow wrapper scripts to set the default activity through
  74 # the ADB_GDB_ACTIVITY variable. Users are still able to change the
  75 # final activity name through --activity=<name> option.
  76 #
  77 # This is only for cosmetic reasons, i.e. to display the proper default
  78 # in the --help output.
  79 #
  80 DEFAULT_ACTIVITY=${ADB_GDB_ACTIVITY:-".Main"}
  81
  82 # Allow wrapper scripts to set the program name through ADB_GDB_PROGNAME
  83 PROGNAME=${ADB_GDB_PROGNAME:-$(basename "$0")}
  84
  85 ACTIVITY=$DEFAULT_ACTIVITY
  86 ADB=
  87 ANNOTATE=
  88 # Note: Ignore BUILDTYPE variable, because the Ninja build doesn't use it.
  89 BUILDTYPE=
  90 FORCE=
  91 GDBEXEPOSTFIX=gdb
  92 GDBINIT=
  93 GDBSERVER=
  94 HELP=
  95 NDK_DIR=
  96 NO_PULL_LIBS=
  97 PACKAGE_NAME=
  98 PID=
  99 PROGRAM_NAME="activity"
 100 PULL_LIBS=
 101 PULL_LIBS_DIR=
 102 SANDBOXED=
 103 SANDBOXED_INDEX=
 104 START=
 105 SU_PREFIX=
 106 SYMBOL_DIR=
 107 TARGET_ARCH=
 108 TOOLCHAIN=
 109 VERBOSE=0
 110
 111 for opt; do
 112   optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
 113   case $opt in
 114     --adb=*)
 115       ADB=$optarg
 116       ;;
 117     --activity=*)
 118       ACTIVITY=$optarg
 119       ;;
 120     --annotate=3)
 121       ANNOTATE=$optarg
 122       ;;
 123     --force)
 124       FORCE=true
 125       ;;
 126     --gdbserver=*)
 127       GDBSERVER=$optarg
 128       ;;
 129     --gdb=*)
 130       GDB=$optarg
 131       ;;
 132     --help|-h|-?)
 133       HELP=true
 134       ;;
 135     --ndk-dir=*)
 136       NDK_DIR=$optarg
 137       ;;
 138     --no-pull-libs)
 139       NO_PULL_LIBS=true
 140       ;;
 141     --package-name=*)
 142       PACKAGE_NAME=$optarg
 143       ;;
 144     --pid=*)
 145       PID=$optarg
 146       ;;
 147     --program-name=*)
 148       PROGRAM_NAME=$optarg
 149       ;;
 150     --pull-libs)
 151       PULL_LIBS=true
 152       ;;
 153     --pull-libs-dir=*)
 154       PULL_LIBS_DIR=$optarg
 155       ;;
 156     --sandboxed)
 157       SANDBOXED=true
 158       ;;
 159     --sandboxed=*)
 160       SANDBOXED=true
 161       SANDBOXED_INDEX=$optarg
 162       ;;
 163     --script=*)
 164       GDBINIT=$optarg
 165       ;;
 166     --start)
 167       START=true
 168       ;;
 169     --su-prefix=*)
 170       SU_PREFIX=$optarg
 171       ;;
 172     --symbol-dir=*)
 173       SYMBOL_DIR=$optarg
 174       ;;
 175     --out-dir=*)
 176       CHROMIUM_OUT_DIR=$optarg
 177       ;;
 178     --target-arch=*)
 179       TARGET_ARCH=$optarg
 180       ;;
 181     --toolchain=*)
 182       TOOLCHAIN=$optarg
 183       ;;
 184     --ui)
 185       GDBEXEPOSTFIX=gdbtui
 186       ;;
 187     --verbose)
 188       VERBOSE=$(( $VERBOSE + 1 ))
 189       ;;
 190     --debug)
 191       BUILDTYPE=Debug
 192       ;;
 193     --release)
 194       BUILDTYPE=Release
 195       ;;
 196     -*)
 197       panic "Unknown option $OPT, see --help." >&2
 198       ;;
 199     *)
 200       if [ "$PACKAGE_NAME" ]; then
 201         panic "You can only provide a single package name as argument!\
 202  See --help."
 203       fi
 204       PACKAGE_NAME=$opt
 205       ;;
 206   esac
 207 done
 208
 209 print_help_options () {
 210   cat <<EOF
 211 EOF
 212 }
 213
 214 if [ "$HELP" ]; then
 215   if [ "$ADB_GDB_PROGNAME" ]; then
 216     # Assume wrapper scripts all provide a default package name.
 217     cat <<EOF
 218 Usage: $PROGNAME [options]
 219
 220 Attach gdb to a running Android $PROGRAM_NAME process.
 221 EOF
 222   else
 223     # Assume this is a direct call to adb_gdb
 224   cat <<EOF
 225 Usage: $PROGNAME [options] [<package-name>]
 226
 227 Attach gdb to a running Android $PROGRAM_NAME process.
 228
 229 If provided, <package-name> must be the name of the Android application's
 230 package name to be debugged. You can also use --package-name=<name> to
 231 specify it.
 232 EOF
 233   fi
 234
 235   cat <<EOF
 236
 237 This script is used to debug a running $PROGRAM_NAME process.
 238 This can be a regular Android application process, or a sandboxed
 239 service, if you use the --sandboxed or --sandboxed=<num> option.
 240
 241 This script needs several things to work properly. It will try to pick
 242 them up automatically for you though:
 243
 244    - target gdbserver binary
 245    - host gdb client (e.g. arm-linux-androideabi-gdb)
 246    - directory with symbolic version of $PROGRAM_NAME's shared libraries.
 247
 248 You can also use --ndk-dir=<path> to specify an alternative NDK installation
 249 directory.
 250
 251 The script tries to find the most recent version of the debug version of
 252 shared libraries under one of the following directories:
 253
 254   \$CHROMIUM_SRC/<out>/Release/lib/           (used by Ninja builds)
 255   \$CHROMIUM_SRC/<out>/Debug/lib/             (used by Ninja builds)
 256   \$CHROMIUM_SRC/<out>/Release/lib.target/    (used by Make builds)
 257   \$CHROMIUM_SRC/<out>/Debug/lib.target/      (used by Make builds)
 258
 259 Where <out> is 'out' by default, unless the --out=<name> option is used or
 260 the CHROMIUM_OUT_DIR environment variable is defined.
 261
 262 You can restrict this search by using --release or --debug to specify the
 263 build type, or simply use --symbol-dir=<path> to specify the file manually.
 264
 265 The script tries to extract the target architecture from your target device,
 266 but if this fails, will default to 'arm'. Use --target-arch=<name> to force
 267 its value.
 268
 269 Otherwise, the script will complain, but you can use the --gdbserver,
 270 --gdb and --symbol-lib options to specify everything manually.
 271
 272 An alternative to --gdb=<file> is to use --toollchain=<path> to specify
 273 the path to the host target-specific cross-toolchain.
 274
 275 You will also need the 'adb' tool in your path. Otherwise, use the --adb
 276 option. The script will complain if there is more than one device connected
 277 and ANDROID_SERIAL is not defined.
 278
 279 The first time you use it on a device, the script will pull many system
 280 libraries required by the process into a temporary directory. This
 281 is done to strongly improve the debugging experience, like allowing
 282 readable thread stacks and more. The libraries are copied to the following
 283 directory by default:
 284
 285   $DEFAULT_PULL_LIBS_DIR/
 286
 287 But you can use the --pull-libs-dir=<path> option to specify an
 288 alternative. The script can detect when you change the connected device,
 289 and will re-pull the libraries only in this case. You can however force it
 290 with the --pull-libs option.
 291
 292 Any local .gdbinit script will be ignored, but it is possible to pass a
 293 gdb command script with the --script=<file> option. Note that its commands
 294 will be passed to gdb after the remote connection and library symbol
 295 loading have completed.
 296
 297 Valid options:
 298   --help|-h|-?          Print this message.
 299   --verbose             Increase verbosity.
 300
 301   --sandboxed           Debug first sandboxed process we find.
 302   --sandboxed=<num>     Debug specific sandboxed process.
 303   --symbol-dir=<path>   Specify directory with symbol shared libraries.
 304   --out-dir=<path>      Specify the out directory.
 305   --package-name=<name> Specify package name (alternative to 1st argument).
 306   --program-name=<name> Specify program name (cosmetic only).
 307   --pid=<pid>           Specify application process pid.
 308   --force               Kill any previous debugging session, if any.
 309   --start               Start package's activity on device.
 310   --ui                  Use gdbtui instead of gdb
 311   --activity=<name>     Activity name for --start [$DEFAULT_ACTIVITY].
 312   --annotate=<num>      Enable gdb annotation.
 313   --script=<file>       Specify extra GDB init script.
 314
 315   --gdbserver=<file>    Specify target gdbserver binary.
 316   --gdb=<file>          Specify host gdb client binary.
 317   --target-arch=<name>  Specify NDK target arch.
 318   --adb=<file>          Specify host ADB binary.
 319
 320   --su-prefix=<prefix>  Prepend <prefix> to 'adb shell' commands that are
 321                         run by this script. This can be useful to use
 322                         the 'su' program on rooted production devices.
 323                         e.g. --su-prefix="su -c"
 324
 325   --pull-libs           Force system libraries extraction.
 326   --no-pull-libs        Do not extract any system library.
 327   --libs-dir=<path>     Specify system libraries extraction directory.
 328
 329   --debug               Use libraries under out/Debug.
 330   --release             Use libraries under out/Release.
 331
 332 EOF
 333   exit 0
 334 fi
 335
 336 if [ -z "$PACKAGE_NAME" ]; then
 337   panic "Please specify a package name on the command line. See --help."
 338 fi
 339
 340 if [ -z "$NDK_DIR" ]; then
 341   ANDROID_NDK_ROOT=$(PYTHONPATH=$CHROMIUM_SRC/build/android python -c \
 342 'from pylib.constants import ANDROID_NDK_ROOT; print ANDROID_NDK_ROOT,')
 343 else
 344   if [ ! -d "$NDK_DIR" ]; then
 345     panic "Invalid directory: $NDK_DIR"
 346   fi
 347   if [ ! -f "$NDK_DIR/ndk-build" ]; then
 348     panic "Not a valid NDK directory: $NDK_DIR"
 349   fi
 350   ANDROID_NDK_ROOT=$NDK_DIR
 351 fi
 352
 353 if [ "$GDBINIT" -a ! -f "$GDBINIT" ]; then
 354   panic "Unknown --script file: $GDBINIT"
 355 fi
 356
 357 # Check that ADB is in our path
 358 if [ -z "$ADB" ]; then
 359   ADB=$(which adb 2>/dev/null)
 360   if [ -z "$ADB" ]; then
 361     panic "Can't find 'adb' tool in your path. Install it or use \
 362 --adb=<file>"
 363   fi
 364   log "Auto-config: --adb=$ADB"
 365 fi
 366
 367 # Check that it works minimally
 368 ADB_VERSION=$($ADB version 2>/dev/null)
 369 echo "$ADB_VERSION" | fgrep -q -e "Android Debug Bridge"
 370 if [ $? != 0 ]; then
 371   panic "Your 'adb' tool seems invalid, use --adb=<file> to specify a \
 372 different one: $ADB"
 373 fi
 374
 375 # If there are more than one device connected, and ANDROID_SERIAL is not
 376 # defined, print an error message.
 377 NUM_DEVICES_PLUS2=$($ADB devices 2>/dev/null | wc -l)
 378 if [ "$NUM_DEVICES_PLUS2" -lt 3 -a -z "$ANDROID_SERIAL" ]; then
 379   echo "ERROR: There is more than one Android device connected to ADB."
 380   echo "Please define ANDROID_SERIAL to specify which one to use."
 381   exit 1
 382 fi
 383
 384 # Run a command through adb shell, strip the extra \r from the output
 385 # and return the correct status code to detect failures. This assumes
 386 # that the adb shell command prints a final \n to stdout.
 387 # $1+: command to run
 388 # Out: command's stdout
 389 # Return: command's status
 390 # Note: the command's stderr is lost
 391 adb_shell () {
 392   local TMPOUT="$(mktemp)"
 393   local LASTLINE RET
 394   local ADB=${ADB:-adb}
 395
 396   # The weird sed rule is to strip the final \r on each output line
 397   # Since 'adb shell' never returns the command's proper exit/status code,
 398   # we force it to print it as '%%<status>' in the temporary output file,
 399   # which we will later strip from it.
 400   $ADB shell $@ ";" echo "%%\$?" 2>/dev/null | \
 401       sed -e 's![[:cntrl:]]!!g' > $TMPOUT
 402   # Get last line in log, which contains the exit code from the command
 403   LASTLINE=$(sed -e '$!d' $TMPOUT)
 404   # Extract the status code from the end of the line, which must
 405   # be '%%<code>'.
 406   RET=$(echo "$LASTLINE" | \
 407     awk '{ if (match($0, "%%[0-9]+$")) { print substr($0,RSTART+2); } }')
 408   # Remove the status code from the last line. Note that this may result
 409   # in an empty line.
 410   LASTLINE=$(echo "$LASTLINE" | \
 411     awk '{ if (match($0, "%%[0-9]+$")) { print substr($0,1,RSTART-1); } }')
 412   # The output itself: all lines except the status code.
 413   sed -e '$d' $TMPOUT && printf "%s" "$LASTLINE"
 414   # Remove temp file.
 415   rm -f $TMPOUT
 416   # Exit with the appropriate status.
 417   return $RET
 418 }
 419
 420 # Find the target architecture from the target device.
 421 # This returns an NDK-compatible architecture name.
 422 # out: NDK Architecture name, or empty string.
 423 get_gyp_target_arch () {
 424   local ARCH=$(adb_shell getprop ro.product.cpu.abi)
 425   case $ARCH in
 426     mips|x86|x86_64) echo "$ARCH";;
 427     arm64*) echo "arm64";;
 428     arm*) echo "arm";;
 429     *) echo "";
 430   esac
 431 }
 432
 433 if [ -z "$TARGET_ARCH" ]; then
 434   TARGET_ARCH=$(get_gyp_target_arch)
 435   if [ -z "$TARGET_ARCH" ]; then
 436     TARGET_ARCH=arm
 437   fi
 438 else
 439   # Nit: accept Chromium's 'ia32' as a valid target architecture. This
 440   # script prefers the NDK 'x86' name instead because it uses it to find
 441   # NDK-specific files (host gdb) with it.
 442   if [ "$TARGET_ARCH" = "ia32" ]; then
 443     TARGET_ARCH=x86
 444     log "Auto-config: --arch=$TARGET_ARCH  (equivalent to ia32)"
 445   fi
 446 fi
 447
 448 # Detect the NDK system name, i.e. the name used to identify the host.
 449 # out: NDK system name (e.g. 'linux' or 'darwin')
 450 get_ndk_host_system () {
 451   local HOST_OS
 452   if [ -z "$NDK_HOST_SYSTEM" ]; then
 453     HOST_OS=$(uname -s)
 454     case $HOST_OS in
 455       Linux) NDK_HOST_SYSTEM=linux;;
 456       Darwin) NDK_HOST_SYSTEM=darwin;;
 457       *) panic "You can't run this script on this system: $HOST_OS";;
 458     esac
 459   fi
 460   echo "$NDK_HOST_SYSTEM"
 461 }
 462
 463 # Detect the NDK host architecture name.
 464 # out: NDK arch name (e.g. 'x86' or 'x86_64')
 465 get_ndk_host_arch () {
 466   local HOST_ARCH HOST_OS
 467   if [ -z "$NDK_HOST_ARCH" ]; then
 468     HOST_OS=$(get_ndk_host_system)
 469     HOST_ARCH=$(uname -p)
 470     case $HOST_ARCH in
 471       i?86) NDK_HOST_ARCH=x86;;
 472       x86_64|amd64) NDK_HOST_ARCH=x86_64;;
 473       *) panic "You can't run this script on this host architecture: $HOST_ARCH";;
 474     esac
 475     # Darwin trick: "uname -p" always returns i386 on 64-bit installations.
 476     if [ "$HOST_OS" = darwin -a "$NDK_HOST_ARCH" = "x86" ]; then
 477       # Use '/usr/bin/file', not just 'file' to avoid buggy MacPorts
 478       # implementations of the tool. See http://b.android.com/53769
 479       HOST_64BITS=$(/usr/bin/file -L "$SHELL" | grep -e "x86[_-]64")
 480       if [ "$HOST_64BITS" ]; then
 481         NDK_HOST_ARCH=x86_64
 482       fi
 483     fi
 484   fi
 485   echo "$NDK_HOST_ARCH"
 486 }
 487
 488 # Convert an NDK architecture name into a GNU configure triplet.
 489 # $1: NDK architecture name (e.g. 'arm')
 490 # Out: Android GNU configure triplet (e.g. 'arm-linux-androideabi')
 491 get_arch_gnu_config () {
 492   case $1 in
 493     arm)
 494       echo "arm-linux-androideabi"
 495       ;;
 496     arm64)
 497       echo "aarch64-linux-android"
 498       ;;
 499     x86)
 500       echo "i686-linux-android"
 501       ;;
 502     x86_64)
 503       echo "x86_64-linux-android"
 504       ;;
 505     mips)
 506       echo "mipsel-linux-android"
 507       ;;
 508     *)
 509       echo "$ARCH-linux-android"
 510       ;;
 511   esac
 512 }
 513
 514 # Convert an NDK architecture name into a toolchain name prefix
 515 # $1: NDK architecture name (e.g. 'arm')
 516 # Out: NDK toolchain name prefix (e.g. 'arm-linux-androideabi')
 517 get_arch_toolchain_prefix () {
 518   # Return the configure triplet, except for x86!
 519   if [ "$1" = "x86" ]; then
 520     echo "$1"
 521   else
 522     get_arch_gnu_config $1
 523   fi
 524 }
 525
 526 # Find a NDK toolchain prebuilt file or sub-directory.
 527 # This will probe the various arch-specific toolchain directories
 528 # in the NDK for the needed file.
 529 # $1: NDK install path
 530 # $2: NDK architecture name
 531 # $3: prebuilt sub-path to look for.
 532 # Out: file path, or empty if none is found.
 533 get_ndk_toolchain_prebuilt () {
 534   local NDK_DIR="${1%/}"
 535   local ARCH="$2"
 536   local SUBPATH="$3"
 537   local NAME="$(get_arch_toolchain_prefix $ARCH)"
 538   local FILE TARGET
 539   FILE=$NDK_DIR/toolchains/$NAME-4.9/prebuilt/$SUBPATH
 540   if [ ! -f "$FILE" ]; then
 541     FILE=$NDK_DIR/toolchains/$NAME-4.8/prebuilt/$SUBPATH
 542     if [ ! -f "$FILE" ]; then
 543       FILE=
 544     fi
 545   fi
 546   echo "$FILE"
 547 }
 548
 549 # Find the path to an NDK's toolchain full prefix for a given architecture
 550 # $1: NDK install path
 551 # $2: NDK target architecture name
 552 # Out: install path + binary prefix (e.g.
 553 #      ".../path/to/bin/arm-linux-androideabi-")
 554 get_ndk_toolchain_fullprefix () {
 555   local NDK_DIR="$1"
 556   local ARCH="$2"
 557   local TARGET NAME HOST_OS HOST_ARCH GCC CONFIG
 558
 559   # NOTE: This will need to be updated if the NDK changes the names or moves
 560   #        the location of its prebuilt toolchains.
 561   #
 562   GCC=
 563   HOST_OS=$(get_ndk_host_system)
 564   HOST_ARCH=$(get_ndk_host_arch)
 565   CONFIG=$(get_arch_gnu_config $ARCH)
 566   GCC=$(get_ndk_toolchain_prebuilt \
 567         "$NDK_DIR" "$ARCH" "$HOST_OS-$HOST_ARCH/bin/$CONFIG-gcc")
 568   if [ -z "$GCC" -a "$HOST_ARCH" = "x86_64" ]; then
 569     GCC=$(get_ndk_toolchain_prebuilt \
 570           "$NDK_DIR" "$ARCH" "$HOST_OS-x86/bin/$CONFIG-gcc")
 571   fi
 572   if [ ! -f "$GCC" -a "$ARCH" = "x86" ]; then
 573     # Special case, the x86 toolchain used to be incorrectly
 574     # named i686-android-linux-gcc!
 575     GCC=$(get_ndk_toolchain_prebuilt \
 576           "$NDK_DIR" "$ARCH" "$HOST_OS-x86/bin/i686-android-linux-gcc")
 577   fi
 578   if [ -z "$GCC" ]; then
 579     panic "Cannot find Android NDK toolchain for '$ARCH' architecture. \
 580 Please verify your NDK installation!"
 581   fi
 582   echo "${GCC%%gcc}"
 583 }
 584
 585 # $1: NDK install path
 586 # $2: target architecture.
 587 get_ndk_gdbserver () {
 588   local NDK_DIR="$1"
 589   local ARCH=$2
 590   local BINARY
 591
 592   # The location has moved after NDK r8
 593   BINARY=$NDK_DIR/prebuilt/android-$ARCH/gdbserver/gdbserver
 594   if [ ! -f "$BINARY" ]; then
 595     BINARY=$(get_ndk_toolchain_prebuilt "$NDK_DIR" "$ARCH" gdbserver)
 596   fi
 597   echo "$BINARY"
 598 }
 599
 600 # Check/probe the path to the Android toolchain installation. Always
 601 # use the NDK versions of gdb and gdbserver. They must match to avoid
 602 # issues when both binaries do not speak the same wire protocol.
 603 #
 604 if [ -z "$TOOLCHAIN" ]; then
 605   ANDROID_TOOLCHAIN=$(get_ndk_toolchain_fullprefix \
 606                       "$ANDROID_NDK_ROOT" "$TARGET_ARCH")
 607   ANDROID_TOOLCHAIN=$(dirname "$ANDROID_TOOLCHAIN")
 608   log "Auto-config: --toolchain=$ANDROID_TOOLCHAIN"
 609 else
 610   # Be flexible, allow one to specify either the install path or the bin
 611   # sub-directory in --toolchain:
 612   #
 613   if [ -d "$TOOLCHAIN/bin" ]; then
 614     TOOLCHAIN=$TOOLCHAIN/bin
 615   fi
 616   ANDROID_TOOLCHAIN=$TOOLCHAIN
 617 fi
 618
 619 # Cosmetic: Remove trailing directory separator.
 620 ANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN%/}
 621
 622 # Find host GDB client binary
 623 if [ -z "$GDB" ]; then
 624   GDB=$(which $ANDROID_TOOLCHAIN/*-$GDBEXEPOSTFIX 2>/dev/null | head -1)
 625   if [ -z "$GDB" ]; then
 626     panic "Can't find Android gdb client in your path, check your \
 627 --toolchain or --gdb path."
 628   fi
 629   log "Host gdb client: $GDB"
 630 fi
 631
 632 # Find gdbserver binary, we will later push it to /data/local/tmp
 633 # This ensures that both gdbserver and $GDB talk the same binary protocol,
 634 # otherwise weird problems will appear.
 635 #
 636 if [ -z "$GDBSERVER" ]; then
 637   GDBSERVER=$(get_ndk_gdbserver "$ANDROID_NDK_ROOT" "$TARGET_ARCH")
 638   if [ -z "$GDBSERVER" ]; then
 639     panic "Can't find NDK gdbserver binary. use --gdbserver to specify \
 640 valid one!"
 641   fi
 642   log "Auto-config: --gdbserver=$GDBSERVER"
 643 fi
 644
 645 # A unique ID for this script's session. This needs to be the same in all
 646 # sub-shell commands we're going to launch, so take the PID of the launcher
 647 # process.
 648 TMP_ID=$$
 649
 650 # Temporary directory, will get cleaned up on exit.
 651 TMPDIR=/tmp/$USER-adb-gdb-tmp-$TMP_ID
 652 mkdir -p "$TMPDIR" && rm -rf "$TMPDIR"/*
 653
 654 GDBSERVER_PIDFILE="$TMPDIR"/gdbserver-$TMP_ID.pid
 655
 656 # If --force is specified, try to kill any gdbserver process started by the
 657 # same user on the device. Normally, these are killed automatically by the
 658 # script on exit, but there are a few corner cases where this would still
 659 # be needed.
 660 if [ "$FORCE" ]; then
 661   GDBSERVER_PIDS=$(adb_shell ps | awk '$9 ~ /gdbserver/ { print $2; }')
 662   for GDB_PID in $GDBSERVER_PIDS; do
 663     log "Killing previous gdbserver (PID=$GDB_PID)"
 664     adb_shell kill -9 $GDB_PID
 665   done
 666 fi
 667
 668 if [ "$START" ]; then
 669   log "Starting $PROGRAM_NAME on device."
 670   adb_shell am start -n $PACKAGE_NAME/$ACTIVITY 2>/dev/null
 671   adb_shell ps | grep -q $PACKAGE_NAME
 672   fail_panic "Could not start $PROGRAM_NAME on device. Are you sure the \
 673 package is installed?"
 674 fi
 675
 676 # Return the timestamp of a given time, as number of seconds since epoch.
 677 # $1: file path
 678 # Out: file timestamp
 679 get_file_timestamp () {
 680   stat -c %Y "$1" 2>/dev/null
 681 }
 682
 683 # Detect the build type and symbol directory. This is done by finding
 684 # the most recent sub-directory containing debug shared libraries under
 685 # $CHROMIUM_SRC/$CHROMIUM_OUT_DIR/
 686 #
 687 # $1: $BUILDTYPE value, can be empty
 688 # Out: nothing, but this sets SYMBOL_DIR
 689 #
 690 detect_symbol_dir () {
 691   local SUBDIRS SUBDIR LIST DIR DIR_LIBS TSTAMP
 692   # Note: Ninja places debug libraries under out/$BUILDTYPE/lib/, while
 693   # Make places then under out/$BUILDTYPE/lib.target.
 694   if [ "$1" ]; then
 695     SUBDIRS="$1/lib $1/lib.target"
 696   else
 697     SUBDIRS="Release/lib Debug/lib Release/lib.target Debug/lib.target"
 698   fi
 699   LIST=$TMPDIR/scan-subdirs-$$.txt
 700   printf "" > "$LIST"
 701   for SUBDIR in $SUBDIRS; do
 702     DIR=$CHROMIUM_SRC/$CHROMIUM_OUT_DIR/$SUBDIR
 703     if [ -d "$DIR" ]; then
 704       # Ignore build directories that don't contain symbol versions
 705       # of the shared libraries.
 706       DIR_LIBS=$(ls "$DIR"/lib*.so 2>/dev/null)
 707       if [ -z "$DIR_LIBS" ]; then
 708         echo "No shared libs: $DIR"
 709         continue
 710       fi
 711       TSTAMP=$(get_file_timestamp "$DIR")
 712       printf "%s %s\n" "$TSTAMP" "$SUBDIR" >> "$LIST"
 713     fi
 714   done
 715   SUBDIR=$(cat $LIST | sort -r | head -1 | cut -d" " -f2)
 716   rm -f "$LIST"
 717
 718   if [ -z "$SUBDIR" ]; then
 719     if [ -z "$1" ]; then
 720       panic "Could not find any build directory under \
 721 $CHROMIUM_SRC/$CHROMIUM_OUT_DIR. Please build the program first!"
 722     else
 723       panic "Could not find any $1 directory under \
 724 $CHROMIUM_SRC/$CHROMIUM_OUT_DIR. Check your build type!"
 725     fi
 726   fi
 727
 728   SYMBOL_DIR=$CHROMIUM_SRC/$CHROMIUM_OUT_DIR/$SUBDIR
 729   log "Auto-config: --symbol-dir=$SYMBOL_DIR"
 730 }
 731
 732 if [ -z "$SYMBOL_DIR" ]; then
 733   detect_symbol_dir "$BUILDTYPE"
 734 fi
 735
 736 # Allow several concurrent debugging sessions
 737 TARGET_GDBSERVER=/data/data/$PACKAGE_NAME/gdbserver-adb-gdb-$TMP_ID
 738 TMP_TARGET_GDBSERVER=/data/local/tmp/gdbserver-adb-gdb-$TMP_ID
 739
 740 # Return the build fingerprint contained in a build.prop file.
 741 # $1: path to build.prop file
 742 get_build_fingerprint_from () {
 743   cat "$1" | grep -e '^ro.build.fingerprint=' | cut -d= -f2
 744 }
 745
 746
 747 ORG_PULL_LIBS_DIR=$PULL_LIBS_DIR
 748 PULL_LIBS_DIR=${PULL_LIBS_DIR:-$DEFAULT_PULL_LIBS_DIR}
 749
 750 HOST_FINGERPRINT=
 751 DEVICE_FINGERPRINT=$(adb_shell getprop ro.build.fingerprint)
 752 log "Device build fingerprint: $DEVICE_FINGERPRINT"
 753
 754 # If --pull-libs-dir is not specified, and this is a platform build, look
 755 # if we can use the symbolic libraries under $ANDROID_PRODUCT_OUT/symbols/
 756 # directly, if the build fingerprint matches the device.
 757 if [ -z "$ORG_PULL_LIBS_DIR" -a \
 758      "$ANDROID_PRODUCT_OUT" -a \
 759      -f "$ANDROID_PRODUCT_OUT/system/build.prop" ]; then
 760   ANDROID_FINGERPRINT=$(get_build_fingerprint_from \
 761                         "$ANDROID_PRODUCT_OUT"/system/build.prop)
 762   log "Android build fingerprint:  $ANDROID_FINGERPRINT"
 763   if [ "$ANDROID_FINGERPRINT" = "$DEVICE_FINGERPRINT" ]; then
 764     log "Perfect match!"
 765     PULL_LIBS_DIR=$ANDROID_PRODUCT_OUT/symbols
 766     HOST_FINGERPRINT=$ANDROID_FINGERPRINT
 767     if [ "$PULL_LIBS" ]; then
 768       log "Ignoring --pull-libs since the device and platform build \
 769 fingerprints match."
 770       NO_PULL_LIBS=true
 771     fi
 772   fi
 773 fi
 774
 775 # If neither --pull-libs an --no-pull-libs were specified, check the build
 776 # fingerprints of the device, and the cached system libraries on the host.
 777 #
 778 if [ -z "$NO_PULL_LIBS" -a -z "$PULL_LIBS" ]; then
 779   if [ ! -f "$PULL_LIBS_DIR/build.prop" ]; then
 780     log "Auto-config: --pull-libs  (no cached libraries)"
 781     PULL_LIBS=true
 782   else
 783     HOST_FINGERPRINT=$(get_build_fingerprint_from "$PULL_LIBS_DIR/build.prop")
 784     log "Host build fingerprint:   $HOST_FINGERPRINT"
 785     if [ "$HOST_FINGERPRINT" == "$DEVICE_FINGERPRINT" ]; then
 786       log "Auto-config: --no-pull-libs (fingerprint match)"
 787       NO_PULL_LIBS=true
 788     else
 789       log "Auto-config: --pull-libs  (fingerprint mismatch)"
 790       PULL_LIBS=true
 791     fi
 792   fi
 793 fi
 794
 795 # Extract the system libraries from the device if necessary.
 796 if [ "$PULL_LIBS" -a -z "$NO_PULL_LIBS" ]; then
 797   echo "Extracting system libraries into: $PULL_LIBS_DIR"
 798 fi
 799
 800 mkdir -p "$PULL_LIBS_DIR"
 801 fail_panic "Can't create --libs-dir directory: $PULL_LIBS_DIR"
 802
 803 # If requested, work for M-x gdb.  The gdb indirections make it
 804 # difficult to pass --annotate=3 to the gdb binary itself.
 805 GDB_ARGS=
 806 if [ "$ANNOTATE" ]; then
 807   GDB_ARGS=$GDB_ARGS" --annotate=$ANNOTATE"
 808 fi
 809
 810 # Get the PID from the first argument or else find the PID of the
 811 # browser process.
 812 if [ -z "$PID" ]; then
 813   PROCESSNAME=$PACKAGE_NAME
 814   if [ "$SANDBOXED_INDEX" ]; then
 815     PROCESSNAME=$PROCESSNAME:sandboxed_process$SANDBOXED_INDEX
 816   elif [ "$SANDBOXED" ]; then
 817     PROCESSNAME=$PROCESSNAME:sandboxed_process
 818     PID=$(adb_shell ps | \
 819           awk '$9 ~ /^'$PROCESSNAME'/ { print $2; }' | head -1)
 820   fi
 821   if [ -z "$PID" ]; then
 822     PID=$(adb_shell ps | \
 823           awk '$9 == "'$PROCESSNAME'" { print $2; }' | head -1)
 824   fi
 825   if [ -z "$PID" ]; then
 826     if [ "$START" ]; then
 827       panic "Can't find application process PID, did it crash?"
 828     else
 829       panic "Can't find application process PID, are you sure it is \
 830 running? Try using --start."
 831     fi
 832   fi
 833   log "Found process PID: $PID"
 834 elif [ "$SANDBOXED" ]; then
 835   echo "WARNING: --sandboxed option ignored due to use of --pid."
 836 fi
 837
 838 # Determine if 'adb shell' runs as root or not.
 839 # If so, we can launch gdbserver directly, otherwise, we have to
 840 # use run-as $PACKAGE_NAME ..., which requires the package to be debuggable.
 841 #
 842 if [ "$SU_PREFIX" ]; then
 843   # Need to check that this works properly.
 844   SU_PREFIX_TEST_LOG=$TMPDIR/su-prefix.log
 845   adb_shell $SU_PREFIX \"echo "foo"\" > $SU_PREFIX_TEST_LOG 2>&1
 846   if [ $? != 0 -o "$(cat $SU_PREFIX_TEST_LOG)" != "foo" ]; then
 847     echo "ERROR: Cannot use '$SU_PREFIX' as a valid su prefix:"
 848     echo "$ adb shell $SU_PREFIX \"echo foo\""
 849     cat $SU_PREFIX_TEST_LOG
 850     exit 1
 851   fi
 852   COMMAND_PREFIX="$SU_PREFIX \""
 853   COMMAND_SUFFIX="\""
 854 else
 855   SHELL_UID=$(adb shell cat /proc/self/status | \
 856               awk '$1 == "Uid:" { print $2; }')
 857   log "Shell UID: $SHELL_UID"
 858   if [ "$SHELL_UID" != 0 -o -n "$NO_ROOT" ]; then
 859     COMMAND_PREFIX="run-as $PACKAGE_NAME"
 860     COMMAND_SUFFIX=
 861   else
 862     COMMAND_PREFIX=
 863     COMMAND_SUFFIX=
 864   fi
 865 fi
 866 log "Command prefix: '$COMMAND_PREFIX'"
 867 log "Command suffix: '$COMMAND_SUFFIX'"
 868
 869 # Pull device's system libraries that are mapped by our process.
 870 # Pulling all system libraries is too long, so determine which ones
 871 # we need by looking at /proc/$PID/maps instead
 872 if [ "$PULL_LIBS" -a -z "$NO_PULL_LIBS" ]; then
 873   echo "Extracting system libraries into: $PULL_LIBS_DIR"
 874   rm -f $PULL_LIBS_DIR/build.prop
 875   MAPPINGS=$(adb_shell $COMMAND_PREFIX cat /proc/$PID/maps $COMMAND_SUFFIX)
 876   if [ $? != 0 ]; then
 877     echo "ERROR: Could not list process's memory mappings."
 878     if [ "$SU_PREFIX" ]; then
 879       panic "Are you sure your --su-prefix is correct?"
 880     else
 881       panic "Use --su-prefix if the application is not debuggable."
 882     fi
 883   fi
 884   SYSTEM_LIBS=$(echo "$MAPPINGS" | \
 885       awk '$6 ~ /\/system\/.*\.so$/ { print $6; }' | sort -u)
 886   for SYSLIB in /system/bin/linker $SYSTEM_LIBS; do
 887     echo "Pulling from device: $SYSLIB"
 888     DST_FILE=$PULL_LIBS_DIR$SYSLIB
 889     DST_DIR=$(dirname "$DST_FILE")
 890     mkdir -p "$DST_DIR" && adb pull $SYSLIB "$DST_FILE" 2>/dev/null
 891     fail_panic "Could not pull $SYSLIB from device !?"
 892   done
 893   echo "Pulling device build.prop"
 894   adb pull /system/build.prop $PULL_LIBS_DIR/build.prop
 895   fail_panic "Could not pull device build.prop !?"
 896 fi
 897
 898 # Find all the sub-directories of $PULL_LIBS_DIR, up to depth 4
 899 # so we can add them to solib-search-path later.
 900 SOLIB_DIRS=$(find $PULL_LIBS_DIR -mindepth 1 -maxdepth 4 -type d | \
 901              grep -v "^$" | tr '\n' ':')
 902
 903 # This is a re-implementation of gdbclient, where we use compatible
 904 # versions of gdbserver and $GDBNAME to ensure that everything works
 905 # properly.
 906 #
 907
 908 # Push gdbserver to the device
 909 log "Pushing gdbserver $GDBSERVER to $TARGET_GDBSERVER"
 910 adb push $GDBSERVER $TMP_TARGET_GDBSERVER &>/dev/null
 911 adb shell run-as $PACKAGE_NAME cp $TMP_TARGET_GDBSERVER .
 912 adb shell rm $TMP_TARGET_GDBSERVER
 913 fail_panic "Could not copy gdbserver to the device!"
 914
 915 PORT=5039
 916 HOST_PORT=$PORT
 917 TARGET_PORT=$PORT
 918
 919 # Select correct app_process for architecture.
 920 case $TARGET_ARCH in
 921       arm|x86|mips) GDBEXEC=app_process;;
 922       arm64|x86_64) GDBEXEC=app_process64;;
 923       *) fail_panic "Unknown app_process for architecture!";;
 924 esac
 925
 926 # Detect AddressSanitizer setup on the device. In that case app_process is a
 927 # script, and the real executable is app_process.real.
 928 GDBEXEC_ASAN=app_process.real
 929 adb_shell ls /system/bin/$GDBEXEC_ASAN
 930 if [ $? == 0 ]; then
 931     GDBEXEC=$GDBEXEC_ASAN
 932 fi
 933
 934 # Pull the app_process binary from the device.
 935 log "Pulling $GDBEXEC from device"
 936 adb pull /system/bin/$GDBEXEC "$TMPDIR"/$GDBEXEC &>/dev/null
 937 fail_panic "Could not retrieve $GDBEXEC from the device!"
 938
 939 # Setup network redirection
 940 log "Setting network redirection (host:$HOST_PORT -> device:$TARGET_PORT)"
 941 adb forward tcp:$HOST_PORT tcp:$TARGET_PORT
 942 fail_panic "Could not setup network redirection from \
 943 host:localhost:$HOST_PORT to device:localhost:$TARGET_PORT!"
 944
 945 # Start gdbserver in the background
 946 # Note that using run-as requires the package to be debuggable.
 947 #
 948 # If not, this will fail horribly. The alternative is to run the
 949 # program as root, which requires of course root privileges.
 950 # Maybe we should add a --root option to enable this?
 951 #
 952 log "Starting gdbserver in the background:"
 953 GDBSERVER_LOG=$TMPDIR/gdbserver-$TMP_ID.log
 954 log "adb shell $COMMAND_PREFIX $TARGET_GDBSERVER :$TARGET_PORT \
 955 --attach $PID $COMMAND_SUFFIX"
 956 ("$ADB" shell $COMMAND_PREFIX $TARGET_GDBSERVER :$TARGET_PORT \
 957  --attach $PID $COMMAND_SUFFIX > $GDBSERVER_LOG 2>&1) &
 958 GDBSERVER_PID=$!
 959 echo "$GDBSERVER_PID" > $GDBSERVER_PIDFILE
 960 log "background job pid: $GDBSERVER_PID"
 961
 962 # Check that it is still running after a few seconds. If not, this means we
 963 # could not properly attach to it
 964 sleep 2
 965 log "Job control: $(jobs -l)"
 966 STATE=$(jobs -l | awk '$2 == "'$GDBSERVER_PID'" { print $3; }')
 967 if [ "$STATE" != "Running" ]; then
 968   echo "ERROR: GDBServer could not attach to PID $PID!"
 969   if [ $(adb_shell su -c getenforce) != "Permissive" ];  then
 970     echo "Device mode is Enforcing. Changing Device mode to Permissive "
 971     $(adb_shell su -c setenforce 0)
 972     if [ $(adb_shell su -c getenforce) != "Permissive" ]; then
 973       echo "ERROR: Failed to Change Device mode to Permissive"
 974       echo "Failure log (use --verbose for more information):"
 975       cat $GDBSERVER_LOG
 976       exit 1
 977     fi
 978   else
 979     echo "Failure log (use --verbose for more information):"
 980     cat $GDBSERVER_LOG
 981     exit 1
 982   fi
 983 fi
 984
 985 # Generate a file containing useful GDB initialization commands
 986 readonly COMMANDS=$TMPDIR/gdb.init
 987 log "Generating GDB initialization commands file: $COMMANDS"
 988 echo -n "" > $COMMANDS
 989 echo "set print pretty 1" >> $COMMANDS
 990 echo "python" >> $COMMANDS
 991 echo "import sys" >> $COMMANDS
 992 echo "sys.path.insert(0, '$CHROMIUM_SRC/tools/gdb/')" >> $COMMANDS
 993 echo "try:" >> $COMMANDS
 994 echo "  import gdb_chrome" >> $COMMANDS
 995 echo "finally:" >> $COMMANDS
 996 echo "  sys.path.pop(0)" >> $COMMANDS
 997 echo "end" >> $COMMANDS
 998 echo "file $TMPDIR/$GDBEXEC" >> $COMMANDS
 999 echo "directory $CHROMIUM_SRC" >> $COMMANDS
1000 echo "set solib-absolute-prefix $PULL_LIBS_DIR" >> $COMMANDS
1001 echo "set solib-search-path $SOLIB_DIRS:$PULL_LIBS_DIR:$SYMBOL_DIR" \
1002     >> $COMMANDS
1003 echo "echo Attaching and reading symbols, this may take a while.." \
1004     >> $COMMANDS
1005 echo "target remote :$HOST_PORT" >> $COMMANDS
1006
1007 if [ "$GDBINIT" ]; then
1008   cat "$GDBINIT" >> $COMMANDS
1009 fi
1010
1011 if [ "$VERBOSE" -gt 0 ]; then
1012   echo "### START $COMMANDS"
1013   cat $COMMANDS
1014   echo "### END $COMMANDS"
1015 fi
1016
1017 log "Launching gdb client: $GDB $GDB_ARGS -x $COMMANDS"
1018 $GDB $GDB_ARGS -x $COMMANDS &&
1019 rm -f "$GDBSERVER_PIDFILE"