Last active
May 8, 2018 10:07
-
-
Save TomTasche/9690186 to your computer and use it in GitHub Desktop.
ndk-gdb of NDK r9d modified to *always* debug the ":remote"-process of your app
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#!/bin/sh | |
# | |
# Copyright (C) 2010 The Android Open Source Project | |
# | |
# Licensed under the Apache License, Version 2.0 (the "License"); | |
# you may not use this file except in compliance with the License. | |
# You may obtain a copy of the License at | |
# | |
# http://www.apache.org/licenses/LICENSE-2.0 | |
# | |
# Unless required by applicable law or agreed to in writing, software | |
# distributed under the License is distributed on an "AS IS" BASIS, | |
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
# See the License for the specific language governing permissions and | |
# limitations under the License. | |
# | |
# This wrapper script is used to launch a native debugging session | |
# on a given NDK application. The application must be debuggable, i.e. | |
# its android:debuggable attribute must be set to 'true' in the | |
# <application> element of its manifest. | |
# | |
# See docs/NDK-GDB.TXT for usage description. Essentially, you just | |
# need to launch ndk-gdb from your application project directory | |
# after doing ndk-build && ant install && <start-application-on-device> | |
# | |
PROGDIR=`dirname $0` | |
PROGDIR=`cd $PROGDIR && pwd -P` | |
# Check if absolute NDK path contain space | |
# | |
case $PROGDIR in | |
*\ *) echo "ERROR: NDK path cannot contain space" | |
exit 1 | |
;; | |
esac | |
NDK_BUILDTOOLS_PATH=$PROGDIR/build/tools | |
. $PROGDIR/build/tools/prebuilt-common.sh | |
. $PROGDIR/build/tools/ndk-common.sh | |
force_32bit_binaries | |
# Find if a given shell program is available. | |
# We need to take care of the fact that the 'which <foo>' command | |
# may return either an empty string (Linux) or something like | |
# "no <foo> in ..." (Darwin). Also, we need to redirect stderr | |
# to /dev/null for Cygwin | |
# | |
# $1: program name | |
# Out: program path, or empty string | |
# Return: 0 on success, != 0 on error | |
# | |
find_program () | |
{ | |
local PROG RET | |
PROG=$(which "$1" 2>/dev/null) | |
RET=$? | |
if [ $RET != 0 ]; then | |
PROG= | |
fi | |
echo "$PROG" | |
return $RET | |
} | |
quote_spaces () | |
{ | |
echo "$@" | sed -e 's! !\ !g' | |
} | |
# If ADB_CMD is not defined, try to find a program named 'adb' | |
# in our path. | |
ADB_CMD=${ADB_CMD:-$(find_program adb)} | |
ADB_FLAGS=${ADB_FLAGS:-} | |
DEVICE_SERIAL= | |
JDB_CMD=${JDB_CMD:-$(find_program jdb)} | |
AWK_CMD=${AWK_CMD:-$(find_program awk)} | |
DEBUG_PORT=5039 | |
JDB_PORT=65534 | |
UNKNOWN_ABI=$(find_ndk_unknown_archs) | |
# Delay in seconds between launching the activity and attaching gdbserver on it. | |
# This is needed because there is no way to know when the activity has really | |
# started, and sometimes this takes a few seconds. | |
DELAY=2 | |
PARAMETERS= | |
OPTION_HELP=no | |
OPTION_PROJECT= | |
OPTION_FORCE=no | |
OPTION_ADB= | |
OPTION_EXEC= | |
OPTION_START=no | |
OPTION_LAUNCH= | |
OPTION_LAUNCH_LIST=no | |
OPTION_DELAY= | |
OPTION_WAIT="-D" | |
check_parameter () | |
{ | |
if [ -z "$2" ]; then | |
echo "ERROR: Missing parameter after option '$1'" | |
exit 1 | |
fi | |
} | |
check_adb_flags () | |
{ | |
if [ -n "$ADB_FLAGS" ] ; then | |
echo "ERROR: Only one of -e, -d or -s <serial> can be used at the same time!" | |
exit 1 | |
fi | |
} | |
get_build_var () | |
{ | |
if [ -z "$GNUMAKE" ] ; then | |
GNUMAKE=make | |
fi | |
$GNUMAKE --no-print-dir -f $ANDROID_NDK_ROOT/build/core/build-local.mk -C $PROJECT DUMP_$1 | tail -1 | |
} | |
get_build_var_for_abi () | |
{ | |
if [ -z "$GNUMAKE" ] ; then | |
GNUMAKE=make | |
fi | |
$GNUMAKE --no-print-dir -f $ANDROID_NDK_ROOT/build/core/build-local.mk -C $PROJECT DUMP_$1 APP_ABI=$2 | tail -1 | |
} | |
# Used to run an awk script on the manifest | |
run_awk_manifest_script () | |
{ | |
$AWK_CMD -f $AWK_SCRIPTS/$1 $PROJECT/$MANIFEST | |
} | |
if [ "$HOST_OS" = "cygwin" ] ; then | |
# Return native path representation from cygwin one | |
# $1: a cygwin-compatible path (e.g. /cygdrive/c/some/thing) | |
# Return: path in host windows representation, e.g. C:/some/thing | |
# | |
# We use mixed mode (i.e. / as the directory separator) because | |
# all the tools we use recognize it properly, and it avoids lots | |
# of escaping nonsense associated with "\" | |
# | |
native_path () | |
{ | |
cygpath -m $1 | |
} | |
else # HOST_OS != windows | |
native_path () | |
{ | |
echo "$1" | |
} | |
fi # HOST_OS != windows | |
# We need to ensure the ANDROID_NDK_ROOT is absolute, otherwise calls | |
# to get_build_var, get_build_var_for_abi and run_awk_manifest_script | |
# might fail, e.g. when invoked with: | |
# | |
# cd $NDKROOT | |
# ./ndk-gdb --project=/path/to/project | |
# | |
path_is_absolute () | |
{ | |
local P P2 | |
P=$1 # copy path | |
P2=${P#/} # remove / prefix, if any | |
[ "$P" != "$P2" ] | |
} | |
if ! path_is_absolute "$ANDROID_NDK_ROOT"; then | |
ANDROID_NDK_ROOT=$(pwd)/$ANDROID_NDK_ROOT | |
fi | |
VERBOSE=no | |
while [ -n "$1" ]; do | |
opt="$1" | |
optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'` | |
case "$opt" in | |
--help|-h|-\?) | |
OPTION_HELP=yes | |
;; | |
--verbose) | |
VERBOSE=yes | |
;; | |
-s) | |
check_parameter $1 $2 | |
check_adb_flags | |
ADB_FLAGS=" -s" | |
DEVICE_SERIAL=$2 | |
shift | |
;; | |
-s*) | |
check_adb_flags | |
optarg=`expr -- "$opt" : '-s\(.*\)'` | |
ADB_FLAGS=" -s" | |
DEVICE_SERIAL=$optarg | |
;; | |
-p) | |
check_parameter $1 $2 | |
OPTION_PROJECT="$2" | |
shift | |
;; | |
-p*) | |
optarg=`expr -- "$opt" : '-p\(.*\)'` | |
OPTION_PROJECT="$optarg" | |
;; | |
--exec=*) | |
OPTION_EXEC="$optarg" | |
;; | |
-x) | |
check_parameter $1 $2 | |
OPTION_EXEC="$2" | |
shift | |
;; | |
-x*) | |
optarg=`expr -- "$opt" : '-x\(.*\)'` | |
OPTION_EXEC="$optarg" | |
;; | |
-e) | |
check_adb_flags | |
ADB_FLAGS=" -e" | |
;; | |
-d) | |
check_adb_flags | |
ADB_FLAGS=" -d" | |
;; | |
--adb=*) # specify ADB command | |
OPTION_ADB="$optarg" | |
;; | |
--awk=*) | |
AWK_CMD="$optarg" | |
;; | |
--project=*) | |
OPTION_PROJECT="$optarg" | |
;; | |
--port=*) | |
DEBUG_PORT="$optarg" | |
;; | |
--force) | |
OPTION_FORCE="yes" | |
;; | |
--launch-list) | |
OPTION_LAUNCH_LIST="yes" | |
;; | |
--launch=*) | |
OPTION_LAUNCH="$optarg" | |
;; | |
--start) | |
OPTION_START=yes | |
;; | |
--delay=*) | |
OPTION_DELAY="$optarg" | |
;; | |
--nowait) | |
JDB_PORT= | |
OPTION_WAIT= | |
;; | |
-*) # unknown options | |
echo "ERROR: Unknown option '$opt', use --help for list of valid ones." | |
exit 1 | |
;; | |
*) # Simply record parameter | |
if [ -z "$PARAMETERS" ] ; then | |
PARAMETERS="$opt" | |
else | |
PARAMETERS="$PARAMETERS $opt" | |
fi | |
;; | |
esac | |
shift | |
done | |
if [ -z "$JDB_CMD" ] && [ -n "$OPTION_WAIT" ]; then | |
echo "ERROR: 'jdb' not found; you must either install the JDK, or specify --nowait" | |
exit 1 | |
fi | |
if [ -n "$JDB_PORT" ] && [ "$JDB_PORT" = "$DEBUG_PORT" ]; then | |
echo "ERROR: --port specified cannot be $JDB_PORT without --nowait" | |
exit 1 | |
fi | |
if [ "$OPTION_HELP" = "yes" ] ; then | |
echo "Usage: $PROGNAME [options]" | |
echo "" | |
echo "Setup a gdb debugging session for your Android NDK application." | |
echo "Read $$NDK/docs/NDK-GDB.TXT for complete usage instructions." | |
echo "" | |
echo "Valid options:" | |
echo "" | |
echo " --help|-h|-? Print this help" | |
echo " --verbose Enable verbose mode" | |
echo " --force Kill existing debug session if it exists" | |
echo " --nowait Don't have application wait for debugger to attach" | |
echo " (This might cause you to miss some early JNI breakpoints)" | |
echo " --start Launch application instead of attaching to existing one" | |
echo " --launch=<name> Same as --start, but specify activity name (see below)" | |
echo " --launch-list List all launchable activity names from manifest" | |
echo " --delay=<secs> Delay in seconds between activity start and gdbserver attach." | |
echo " --project=<path> Specify application project path" | |
echo " -p <path> Same as --project=<path>" | |
echo " --port=<port> Use tcp:localhost:<port> to communicate with gdbserver [$DEBUG_PORT]" | |
echo " --exec=<file> Execute gdb initialization commands in <file> after connection" | |
echo " -x <file> Same as --exec=<file>" | |
echo " --adb=<file> Use specific adb command [$ADB_CMD]" | |
echo " --awk=<file> Use specific awk command [$AWK_CMD]" | |
echo " -e Connect to single emulator instance" | |
echo " -d Connect to single target device" | |
echo " -s <serial> Connect to specific emulator or device" | |
echo "" | |
exit 0 | |
fi | |
log "Android NDK installation path: $ANDROID_NDK_ROOT" | |
if [ -n "$OPTION_EXEC" ] ; then | |
if [ ! -f "$OPTION_EXEC" ]; then | |
echo "ERROR: Invalid initialization file: $OPTION_EXEC" | |
exit 1 | |
fi | |
fi | |
if [ -n "$OPTION_DELAY" ] ; then | |
DELAY="$OPTION_DELAY" | |
fi | |
# Check ADB tool version | |
if [ -n "$OPTION_ADB" ] ; then | |
ADB_CMD=$OPTION_ADB | |
log "Using specific adb command: $ADB_CMD" | |
else | |
if [ -z "$ADB_CMD" ] ; then | |
echo "ERROR: The 'adb' tool is not in your path." | |
echo " You can change your PATH variable, or use" | |
echo " --adb=<executable> to point to a valid one." | |
exit 1 | |
fi | |
log "Using default adb command: $ADB_CMD" | |
fi | |
ADB_CMD=$(quote_spaces $ADB_CMD) | |
ADB_VERSION=$("$ADB_CMD" version 2>/dev/null) | |
if [ $? != 0 ] ; then | |
echo "ERROR: Could not run ADB with: $ADB_CMD" | |
exit 1 | |
fi | |
log "ADB version found: $ADB_VERSION" | |
if [ "x$DEVICE_SERIAL" = "x" ]; then | |
log "Using ADB flags: $ADB_FLAGS" | |
else | |
log "Using ADB flags: $ADB_FLAGS" \"$DEVICE_SERIAL\" | |
fi | |
JDB_CMD=$(quote_spaces $JDB_CMD) | |
log "Using JDB command: $JDB_CMD" | |
# Run an ADB command with the right ADB flags | |
# $1+: adb command parameter | |
adb_cmd () | |
{ | |
if [ "x$DEVICE_SERIAL" = "x" ]; then | |
"$ADB_CMD" $ADB_FLAGS "$@" | |
else | |
# NOTE: We escape $ADB_CMD and $DEVICE_SERIAL in case they contains spaces. | |
"$ADB_CMD" $ADB_FLAGS "$DEVICE_SERIAL" "$@" | |
fi | |
} | |
# Used internally by adb_var_shell and adb_var_shell2. | |
# $1: 1 to redirect stderr to $1, 0 otherwise. | |
# $2: Variable name that will contain the result | |
# $3+: Command options | |
_adb_var_shell () | |
{ | |
# We need a temporary file to store the output of our command | |
local CMD_OUT RET OUTPUT VARNAME REDIRECT_STDERR | |
REDIRECT_STDERR=$1 | |
VARNAME=$2 | |
shift; shift; | |
CMD_OUT=`mktemp /tmp/ndk-gdb-cmdout-XXXXXX` | |
# Run the command, while storing the standard output to CMD_OUT | |
# and appending the exit code as the last line. | |
if [ "$REDIRECT_STDERR" != 0 ]; then | |
adb_cmd shell "$@" ";" echo \$? | sed -e 's![[:cntrl:]]!!g' > $CMD_OUT 2>&1 | |
else | |
adb_cmd shell "$@" ";" echo \$? | sed -e 's![[:cntrl:]]!!g' > $CMD_OUT | |
fi | |
# Get last line in log, which contains the exit code from the command | |
RET=`sed -e '$!d' $CMD_OUT` | |
# Get output, which corresponds to everything except the last line | |
OUT=`sed -e '$d' $CMD_OUT` | |
rm -f $CMD_OUT | |
eval $VARNAME=\"\$OUT\" | |
return $RET | |
} | |
# Run a command through 'adb shell' and captures its standard output | |
# into a variable. The function's exit code is the same than the command's. | |
# | |
# This is required because there is a bug where "adb shell" always returns | |
# 0 on the host, even if the command fails on the device. | |
# | |
# $1: Variable name (e.g. FOO) | |
# On exit, $FOO is set to the command's standard output | |
# | |
# The return status will be 0 (success) if the command succeeded | |
# or 1 (failure) otherwise. | |
adb_var_shell () | |
{ | |
_adb_var_shell 0 "$@" | |
} | |
# A variant of adb_var_shell that stores both stdout and stderr in the output | |
# $1: Variable name | |
adb_var_shell2 () | |
{ | |
_adb_var_shell 1 "$@" | |
} | |
# Return the PID of a given package or program, or 0 if it doesn't run | |
# $1: Package name ("com.example.hellojni") or program name ("/lib/gdbserver") | |
# Out: PID number, or 0 if not running | |
get_pid_of () | |
{ | |
adb_cmd shell ps | $AWK_CMD -f $AWK_SCRIPTS/extract-pid.awk -v PACKAGE="$1:remote" | |
} | |
# Check the awk tool | |
AWK_SCRIPTS=$ANDROID_NDK_ROOT/build/awk | |
AWK_TEST=`$AWK_CMD -f $AWK_SCRIPTS/check-awk.awk` | |
if [ $? != 0 ] ; then | |
echo "ERROR: Could not run '$AWK_CMD' command. Do you have it installed properly?" | |
exit 1 | |
fi | |
if [ "$AWK_TEST" != "Pass" ] ; then | |
echo "ERROR: Your version of 'awk' is obsolete. Please use --awk=<file> to point to Nawk or Gawk!" | |
exit 1 | |
fi | |
# Name of the manifest file | |
MANIFEST=AndroidManifest.xml | |
# Find the root of the application project. | |
if [ -n "$OPTION_PROJECT" ] ; then | |
PROJECT=$OPTION_PROJECT | |
log "Using specified project path: $PROJECT" | |
if [ ! -d "$PROJECT" ] ; then | |
echo "ERROR: Your --project option does not point to a directory!" | |
exit 1 | |
fi | |
if [ ! -f "$PROJECT/$MANIFEST" ] ; then | |
echo "ERROR: Your --project does not point to an Android project path!" | |
echo " It is missing a $MANIFEST file." | |
exit 1 | |
fi | |
else | |
# Assume we are in the project directory | |
if [ -f "$MANIFEST" ] ; then | |
PROJECT=. | |
else | |
PROJECT= | |
CURDIR=`pwd` | |
while [ "$CURDIR" != "/" ] ; do | |
if [ -f "$CURDIR/$MANIFEST" ] ; then | |
PROJECT="$CURDIR" | |
break | |
fi | |
CURDIR=`dirname $CURDIR` | |
done | |
if [ -z "$PROJECT" ] ; then | |
echo "ERROR: Launch this script from an application project directory, or use --project=<path>." | |
exit 1 | |
fi | |
fi | |
log "Using auto-detected project path: $PROJECT" | |
fi | |
# Extract the package name from the manifest | |
PACKAGE_NAME=`run_awk_manifest_script extract-package-name.awk` | |
log "Found package name: $PACKAGE_NAME" | |
if [ $? != 0 -o "$PACKAGE_NAME" = "<none>" ] ; then | |
echo "ERROR: Could not extract package name from $PROJECT/$MANIFEST." | |
echo " Please check that the file is well-formed!" | |
exit 1 | |
fi | |
# If --launch-list is used, list all launchable activities, and be done with it | |
if [ "$OPTION_LAUNCH_LIST" = "yes" ] ; then | |
log "Extracting list of launchable activities from manifest:" | |
run_awk_manifest_script extract-launchable.awk | |
exit 0 | |
fi | |
APP_ABIS=`get_build_var APP_ABI` | |
if [ "$APP_ABIS" != "${APP_ABIS%%all*}" ] ; then | |
# replace first "all" with all available ABIs | |
ALL_ABIS=`get_build_var NDK_ALL_ABIS` | |
APP_ABIS_FRONT="${APP_ABIS%%all*}" | |
APP_ABIS_BACK="${APP_ABIS#*all}" | |
APP_ABIS="${APP_ABIS_FRONT}${ALL_ABIS}${APP_ABIS_BACK}" | |
fi | |
# replace "armeabi-v7a-hard" with "armeabi-v7a" | |
APP_ABIS=`echo $APP_ABIS | sed -e 's/armeabi-v7a-hard/armeabi-v7a/g'` | |
log "ABIs targetted by application: $APP_ABIS" | |
# Check the ADB command, and that we can connect to the device/emulator | |
ADB_TEST=`adb_cmd shell ls` | |
if [ $? != 0 ] ; then | |
echo "ERROR: Could not connect to device or emulator!" | |
echo " Please check that an emulator is running or a device is connected" | |
echo " through USB to this machine. You can use -e, -d and -s <serial>" | |
echo " in case of multiple ones." | |
exit 1 | |
fi | |
# Check that the device is running Froyo (API Level 8) or higher | |
# | |
adb_var_shell API_LEVEL getprop ro.build.version.sdk | |
if [ $? != 0 -o -z "$API_LEVEL" ] ; then | |
echo "ERROR: Could not find target device's supported API level!" | |
echo "ndk-gdb will only work if your device is running Android 2.2 or higher." | |
exit 1 | |
fi | |
log "Device API Level: $API_LEVEL" | |
if [ "$API_LEVEL" -lt "8" ] ; then | |
echo "ERROR: ndk-gdb requires a target device running Android 2.2 (API level 8) or higher." | |
echo "The target device is running API level $API_LEVEL!" | |
exit 1 | |
fi | |
# Get the target device's supported ABI(s) | |
# And check that they are supported by the application | |
# | |
COMPAT_ABI=none | |
adb_var_shell CPU_ABI1 getprop ro.product.cpu.abi | |
adb_var_shell CPU_ABI2 getprop ro.product.cpu.abi2 | |
# Both CPU_ABI1 and CPU_ABI2 may contain multiple comma-delimited abis. | |
# Concatanate CPU_ABI1 and CPU_ABI2 and replace all ',' with space. | |
# Add trailing space to ease whole-word matching of APP_ABI. | |
CPU_ABIS="$CPU_ABI1,$CPU_ABI2" | |
CPU_ABIS=$(echo $CPU_ABIS | tr ',' ' ') | |
log "Device CPU ABIs: $CPU_ABIS" | |
APP_ABIS=$APP_ABIS" " | |
adb_var_shell BCFILES run-as $PACKAGE_NAME /system/bin/sh -c "ls lib/*.bc" | |
if [ $? == 0 ]; then | |
COMPAT_ABI="$UNKNOWN_ABI" | |
else | |
for CPU_ABI in $CPU_ABIS; do | |
if [ "$APP_ABIS" != "${APP_ABIS%$CPU_ABI *}" ] ; then | |
COMPAT_ABI=$CPU_ABI | |
break | |
fi | |
done | |
fi | |
if [ "$COMPAT_ABI" = none ] ; then | |
echo "ERROR: The device does not support the application's targetted CPU ABIs!" | |
echo " Device supports: $CPU_ABIS" | |
echo " Package supports: $APP_ABIS" | |
exit 1 | |
fi | |
log "Compatible device ABI: $COMPAT_ABI" | |
# Get information from the build system | |
GDBSETUP_INIT=`get_build_var_for_abi NDK_APP_GDBSETUP $COMPAT_ABI` | |
log "Using gdb setup init: $GDBSETUP_INIT" | |
# Find the prefix for gdb-client | |
if [ "$COMPAT_ABI" != "$UNKNOWN_ABI" ]; then | |
TOOLCHAIN_PREFIX=`get_build_var_for_abi TOOLCHAIN_PREFIX $COMPAT_ABI` | |
else | |
TOOLCHAIN_ABI=$(echo $CPU_ABIS | awk '{print $NF}') | |
TOOLCHAIN_PREFIX=`get_build_var_for_abi TOOLCHAIN_PREFIX $TOOLCHAIN_ABI` | |
fi | |
log "Using toolchain prefix: $TOOLCHAIN_PREFIX" | |
APP_OUT=`get_build_var_for_abi TARGET_OUT $COMPAT_ABI` | |
log "Using app out directory: $APP_OUT" | |
# Check that the application is debuggable, or nothing will work | |
DEBUGGABLE=`run_awk_manifest_script extract-debuggable.awk` | |
log "Found debuggable flag: $DEBUGGABLE" | |
if [ $? != 0 -o "$DEBUGGABLE" != "true" ] ; then | |
# If gdb.setup exists, then we built with 'ndk-build NDK_DEBUG=1' and it's | |
# ok to not have android:debuggable set to true in the original manifest. | |
# However, if this is not the case, then complain!! | |
if [ -f $PROJECT/libs/$COMPAT_ABI/gdb.setup ] ; then | |
log "Found gdb.setup under libs/$COMPAT_ABI, assuming app was built with NDK_DEBUG=1" | |
else | |
echo "ERROR: Package $PACKAGE_NAME is not debuggable ! You can fix that in two ways:" | |
echo "" | |
echo " - Rebuilt with the NDK_DEBUG=1 option when calling 'ndk-build'." | |
echo "" | |
echo " - Modify your manifest to set android:debuggable attribute to \"true\"," | |
echo " then rebuild normally." | |
echo "" | |
echo "After one of these, re-install to the device!" | |
exit 1 | |
fi | |
else | |
# DEBUGGABLE is true in the manifest. Let's check that the user didn't change the | |
# debuggable flag in the manifest without calling ndk-build afterwards. | |
if [ ! -f $PROJECT/libs/$COMPAT_ABI/gdb.setup ] ; then | |
echo "ERROR: Could not find gdb.setup under $PROJECT/libs/$COMPAT_ABI" | |
echo " This usually means you modified your AndroidManifest.xml to set" | |
echo " the android:debuggable flag to 'true' but did not rebuild the" | |
echo " native binaries. Please call 'ndk-build' to do so," | |
echo " *then* re-install to the device!" | |
exit 1 | |
fi | |
fi | |
# Find the <dataDir> of the package on the device | |
adb_var_shell2 DATA_DIR run-as $PACKAGE_NAME /system/bin/sh -c pwd | |
if [ $? != 0 -o -z "$DATA_DIR" ] ; then | |
echo "ERROR: Could not extract package's data directory. Are you sure that" | |
echo " your installed application is debuggable?" | |
exit 1 | |
fi | |
log "Found data directory: '$DATA_DIR'" | |
# Let's check that 'gdbserver' is properly installed on the device too. If 'gdbserver' | |
# is not there, push 'gdbserver' found in prebuilt. | |
# | |
DEVICE_GDBSERVER=$DATA_DIR/lib/gdbserver | |
adb_var_shell2 GDBSERVER_RESULT ls $DEVICE_GDBSERVER | |
if [ $? != 0 ]; then | |
# Figure out what's the target-arch and find gdbserver in prebuilt. | |
TARGET_ARCH=none | |
for ANDROID_ARCH in $ANDROID_NDK_ROOT/prebuilt/android-*; do | |
ANDROID_ARCH=${ANDROID_ARCH#*android-} | |
if [ x"$CPU_ABIS" != x"${CPU_ABIS#$ANDROID_ARCH*}" ]; then | |
TARGET_ARCH=$ANDROID_ARCH | |
break; | |
fi | |
done | |
if [ $TARGET_ARCH != "none" ]; then | |
DEVICE_GDBSERVER=/data/local/tmp/gdbserver | |
adb shell mkdir -p /data/local/tmp | |
adb push ${ANDROID_NDK_ROOT}/prebuilt/android-${TARGET_ARCH}/gdbserver/gdbserver \ | |
$DEVICE_GDBSERVER | |
log "Push gdbserver in device" | |
else | |
echo "ERROR: Non-debuggable application installed on the target device." | |
echo " Please re-install the debuggable version!" | |
exit 1 | |
fi | |
fi | |
log "Found device gdbserver: $DEVICE_GDBSERVER" | |
# Launch the activity if needed | |
if [ "$OPTION_START" = "yes" ] ; then | |
# If --launch is used, ignore --start, otherwise extract the first | |
# launchable activity name from the manifest and use it as if --launch=<name> | |
# was used instead. | |
# | |
if [ -z "$OPTION_LAUNCH" ] ; then | |
OPTION_LAUNCH=`run_awk_manifest_script extract-launchable.awk | sed 2q` | |
if [ $? != 0 ] ; then | |
echo "ERROR: Could not extract name of launchable activity from manifest!" | |
echo " Try to use --launch=<name> directly instead as a work-around." | |
exit 1 | |
fi | |
log "Found first launchable activity: $OPTION_LAUNCH" | |
if [ -z "$OPTION_LAUNCH" ] ; then | |
echo "ERROR: It seems that your Application does not have any launchable activity!" | |
echo " Please fix your manifest file and rebuild/re-install your application." | |
exit 1 | |
fi | |
fi | |
fi | |
if [ -n "$OPTION_LAUNCH" ] ; then | |
log "Launching activity: $PACKAGE_NAME/$OPTION_LAUNCH" | |
run adb_cmd shell am start $OPTION_WAIT -n $PACKAGE_NAME/$OPTION_LAUNCH | |
if [ $? != 0 ] ; then | |
echo "ERROR: Could not launch specified activity: $OPTION_LAUNCH" | |
echo " Use --launch-list to dump a list of valid values." | |
exit 1 | |
fi | |
# Sleep a bit, it sometimes take one second to start properly | |
# Note that we use the 'sleep' command on the device here. | |
run adb_cmd shell sleep $DELAY | |
fi | |
# Find the PID of the application being run | |
PID=$(get_pid_of "$PACKAGE_NAME") | |
log "Found running PID: $PID" | |
if [ $? != 0 -o "$PID" = "0" ] ; then | |
echo "ERROR: Could not extract PID of application on device/emulator." | |
if [ -n "$OPTION_LAUNCH" ] ; then | |
echo " Weird, this probably means one of these:" | |
echo "" | |
echo " - The installed package does not match your current manifest." | |
echo " - The application process was terminated." | |
echo "" | |
echo " Try using the --verbose option and look at its output for details." | |
else | |
echo " Are you sure the application is already started?" | |
echo " Consider using --start or --launch=<name> if not." | |
fi | |
exit 1 | |
fi | |
# Check that there is no other instance of gdbserver running | |
GDBSERVER_PID=$(get_pid_of lib/gdbserver) | |
if [ "$GDBSERVER_PID" != "0" ]; then | |
if [ "$OPTION_FORCE" = "no" ] ; then | |
echo "ERROR: Another debug session running, Use --force to kill it." | |
exit 1 | |
fi | |
log "Killing existing debugging session" | |
run adb_cmd shell kill -9 $GDBSERVER_PID | |
fi | |
# Launch gdbserver now | |
DEBUG_SOCKET=debug-socket | |
run adb_cmd shell run-as $PACKAGE_NAME $DEVICE_GDBSERVER +$DEBUG_SOCKET --attach $PID & | |
if [ $? != 0 ] ; then | |
echo "ERROR: Could not launch gdbserver on the device?" | |
exit 1 | |
fi | |
log "Launched gdbserver succesfully." | |
# Setup network redirection | |
log "Setup network redirection" | |
run adb_cmd forward tcp:$DEBUG_PORT localfilesystem:$DATA_DIR/$DEBUG_SOCKET | |
if [ $? != 0 ] ; then | |
echo "ERROR: Could not setup network redirection to gdbserver?" | |
echo " Maybe using --port=<port> to use a different TCP port might help?" | |
exit 1 | |
fi | |
# Get the app_server binary from the device | |
APP_PROCESS=$APP_OUT/app_process | |
run adb_cmd pull /system/bin/app_process `native_path $APP_PROCESS` | |
log "Pulled app_process from device/emulator." | |
run adb_cmd pull /system/bin/linker `native_path $APP_OUT/linker` | |
log "Pulled linker from device/emulator." | |
run adb_cmd pull /system/lib/libc.so `native_path $APP_OUT/libc.so` | |
log "Pulled libc.so from device/emulator." | |
# Setup JDB connection, for --start or --launch | |
if [ "$OPTION_START" = "yes" ] || [ -n "$OPTION_LAUNCH" ] ; then | |
if [ -n "$JDB_PORT" ]; then | |
log "Setup JDB connection" | |
run adb_cmd forward tcp:$JDB_PORT jdwp:$PID | |
sleep 1 | |
$JDB_CMD -connect com.sun.jdi.SocketAttach:hostname=localhost,port=$JDB_PORT & | |
sleep 1 | |
fi | |
fi | |
# If we are debugging UNKNOWN_ABI, download compiled *.so from device. | |
# | |
if [ "$COMPAT_ABI" == "$UNKNOWN_ABI" ]; then | |
for bc in $BCFILES; do | |
log "Pulled $(basename $bc .bc).so from device/emulator." | |
adb pull $DATA_DIR/lib/$(basename $bc .bc).so $PROJECT/obj/local/$UNKNOWN_ABI/ | |
done | |
fi | |
# Now launch the appropriate gdb client with the right init commands | |
# | |
GDBCLIENT=${TOOLCHAIN_PREFIX}gdb | |
GDBSETUP=$APP_OUT/gdb.setup | |
cp -f $GDBSETUP_INIT $GDBSETUP | |
#uncomment the following to debug the remote connection only | |
#echo "set debug remote 1" >> $GDBSETUP | |
echo "file `native_path $APP_PROCESS`" >> $GDBSETUP | |
echo "target remote :$DEBUG_PORT" >> $GDBSETUP | |
if [ -n "$OPTION_EXEC" ] ; then | |
cat $OPTION_EXEC >> $GDBSETUP | |
fi | |
$GDBCLIENT -x `native_path $GDBSETUP` |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment