日々の反省1

環境：

• Windows
• cygwin 1.7.8
• Android SDK r10
• Android NDK r5b

 
前提：

• 環境変数NDK_ROOTを設定済であること。
• Android SDKにパスを通してあること。
• ndk-buildでビルド済でプロジェクトフォルダのlibsにgdbserverがあること。
  できれば-gでビルド済であること。
• apkがdebuggableであること。
• 端末/エミュレータが起動済であること。
• apkが端末/エミュレータにインストール済で、プロセスが起動済であること。
• 端末/エミュレータのシェルにrootで入れること。(Android 2.1以前の場合)

 
A. Android 2.2 以上の場合

• cygwinのシェルでプロジェクトのルートフォルダ上で$NDK_ROOT/ndk-gdbを実行。
• gdbが起動するのであとは煮るなり焼くなり。

 
B. Android 2.1 以前の場合

• 以下のスクリプトをプロジェクトのルートフォルダにmy-ndk-gdbの名前で保存。

  #!/bin/sh
  
  ANDROID_NDK_ROOT=$NDK_ROOT
  . $NDK_ROOT/build/core/ndk-common.sh
  
  force_32bit_binaries
  find_program ADB_CMD adb
  ADB_FLAGS=
  AWK_CMD=awk
  DEBUG_PORT=5039
  
  # 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=
  
  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  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
  }
  
  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
  }
  
  # 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
  
  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 $2"
              shift
              ;;
          -s*)
              check_adb_flags
              optarg=`expr -- "$opt" : '-s\(.*\)'`
              ADB_FLAGS=" -s $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"
              ;;
          -*) # 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 [ "$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 "    --start           Launch application instead of attaching to existing one"
      echo "    --launch=   Same as --start, but specify activity name (see below)"
      echo "    --launch-list     List all launchable activity names from manifest"
      echo "    --delay=    Delay in seconds between activity start and gdbserver attach."
      echo "    --project=  Specify application project path"
      echo "    -p          Same as --project="
      echo "    --port=     Use tcp:localhost: to communicate with gdbserver [$DEBUG_PORT]"
      echo "    --exec=     Execute gdb initialization commands in  after connection"
      echo "    -x          Same as --exec="
      echo "    --adb=      Use specific adb command [$ADB_CMD]"
      echo "    --awk=      Use specific awk command [$AWK_CMD]"
      echo "    -e                Connect to single emulator instance"
      echo "    -d                Connect to single target device"
      echo "    -s        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= to point to a valid one."
          exit 1
      fi
      log "Using default adb command: $ADB_CMD"
  fi
  
  ADB_VERSION=`$ADB_CMD version`
  if [ $? != 0 ] ; then
      echo "ERROR: Could not run ADB with: $ADB_CMD"
      exit 1
  fi
  log "ADB version found: $ADB_VERSION"
  
  ADB_CMD="${ADB_CMD}${ADB_FLAGS}"
  log "Using final ADB command: '$ADB_CMD'"
  
  adb_shell ()
  {
      # Run an adb shell command and return its output.
      #
      # We need to filter weird control characters like \r that are
      # included in the output.
      #
      $ADB_CMD shell $@ | sed -e 's![[:cntrl:]]!!g'
  }
  
  # 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= 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=."
              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" = "" ] ; 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`
  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 "
      echo "       in case of multiple ones."
      exit 1
  fi
  
  # Get the target device's supported ABI(s)
  # And check that they are supported by the application
  #
  COMPAT_ABI=none
  CPU_ABI=`adb_shell getprop ro.product.cpu.abi`
  for ABI in $APP_ABIS; do
      if [ "$ABI" = "$CPU_ABI" ] ; then
          COMPAT_ABI=$CPU_ABI
          break
      fi
  done
  
  CPU_ABI2=`adb_shell getprop ro.product.cpu.abi2`
  if [ -z "$CPU_ABI2" ] ; then
      log "Device CPU ABI: $CPU_ABI"
  else
      log "Device CPU ABIs: $CPU_ABI $CPU_ABI2"
      if [ "$COMPAT_ABI" = "none" ] ; then
          for ABI in $APP_ABIS; do
              if [ "$ABI" = "$CPU_ABI2" ] ; then
                  COMPAT_ABI=$CPU_ABI2
                  break
              fi
          done
      fi
  fi
  if [ "$COMPAT_ABI" = none ] ; then
      echo "ERROR: The device does not support the application's targetted CPU ABIs!"
      if [ "$CPU_ABI2" = "$CPU_ABI" ] ; then
          CPU_ABI2=
      fi
      echo "       Device supports:  $CPU_ABI $CPU_ABI2"
      echo "       Package supports: $APP_ABIS"
      exit 1
  fi
  log "Compatible device ABI: $COMPAT_ABI"
  
  # 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 gdbserver 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/gdbserver ] ; then
          log "Found gdbserver 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/gdbserver ] ; then
          echo "ERROR: Could not find gdbserver binary 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
  
  # push the gdbserver to  of the package on the device
  APP_DST=`get_build_var NDK_APP_DST_DIR`
  log "Using app dst directory: $APP_DST"
  run $ADB_CMD push `native_path $APP_DST/gdbserver` /data/data/$PACKAGE_NAME/lib/gdbserver
  run $ADB_CMD shell chmod 777 /data/data/$PACKAGE_NAME/lib/gdbserver
  
  # Let's check that 'gdbserver' is properly installed on the device too. If this
  # is not the case, the user didn't install the proper package after rebuilding.
  #
  DEVICE_GDBSERVER=`adb_shell ls /data/data/$PACKAGE_NAME/lib/gdbserver`
  log "Found device gdbserver: $DEVICE_GDBSERVER"
  if pattern_match "No such file or directory" "$DEVICE_GDBSERVER" ] ; then
      echo "ERROR: Non-debuggable application installed on the target device."
      echo "       Please re-install the debuggable version!"
      exit 1
  fi
  
  # 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"
  
  TOOLCHAIN_PREFIX=`get_build_var_for_abi TOOLCHAIN_PREFIX $COMPAT_ABI`
  log "Using toolchain prefix: $TOOLCHAIN_PREFIX"
  
  APP_OUT=`get_build_var_for_abi TARGET_OUT $COMPAT_ABI`
  log "Using app out directory: $APP_OUT"
  
  # Find the  of the package on the device
  DATA_DIR=`adb_shell /system/bin/sh -c "cd /data/data/$PACKAGE_NAME/lib && pwd"`
  log "Found data directory: '$DATA_DIR'"
  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
  
  # 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=
      # 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= 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 -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=`$ADB_CMD shell ps | $AWK_CMD -f $AWK_SCRIPTS/extract-pid.awk -v PACKAGE=$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= if not."
      fi
      exit 1
  fi
  
  # Check that there is no other instance of gdbserver running
  GDBSERVER_PS=`$ADB_CMD shell ps | grep lib/gdbserver`
  if [ -n "$GDBSERVER_PS" ] ; 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"
      GDBSERVER_PID=`echo $GDBSERVER_PS | $AWK_CMD -f $AWK_SCRIPTS/extract-pid.awk -v PACKAGE=lib/gdbserver`
      if [ $GDBSERVER_PID != 0 ] ; then
          run $ADB_CMD shell kill -9 $GDBSERVER_PID
      fi
  fi
  
  # Launch gdbserver now
  DEBUG_SOCKET=debug-socket
  run $ADB_CMD shell /data/data/$PACKAGE_NAME/lib/gdbserver 0:$DEBUG_PORT --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 tcp:$DEBUG_PORT
  if [ $? != 0 ] ; then
      echo "ERROR: Could not setup network redirection to gdbserver?"
      echo "       Maybe using --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/lib/libc.so `native_path $APP_OUT/libc.so`
  log "Pulled libc.so from device/emulator."
  
  # 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`

  上記はndk-gdbを編集したもの。オリジナルのファイルには以下のライセンス表
  記が入っています。(っていう書き方でライセンス条件満たしているのでしたっ
  けか。)

  #
  # 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.
  #

• cygwinのシェルでプロジェクトのルートフォルダ上で./my-ndk-gdb を実行。
• gdbが起動するのであとは煮るなり焼くなり。

 
Android 2.1以前の場合のは、巷の情報をもとにndk-gdbを編集したもの。
ndk-gdbがもとになっているので上記以外の方法でもできるはず。

——–
2011/03/18 00:06 (JST): 「nkd」とかいてたところがあったので「ndk」に修正。