#!/usr/bin/env python # # Copyright (C) 2015 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. # import adb import argparse import logging import os import subprocess import sys # Shared functions across gdbclient.py and ndk-gdb.py. import gdbrunner def get_gdbserver_path(root, arch): path = "{}/prebuilts/misc/android-{}/gdbserver{}/gdbserver{}" if arch.endswith("64"): return path.format(root, arch, "64", "64") else: return path.format(root, arch, "", "") def parse_args(): parser = gdbrunner.ArgumentParser() group = parser.add_argument_group(title="attach target") group = group.add_mutually_exclusive_group(required=True) group.add_argument( "-p", dest="target_pid", metavar="PID", type=int, help="attach to a process with specified PID") group.add_argument( "-n", dest="target_name", metavar="NAME", help="attach to a process with specified name") group.add_argument( "-r", dest="run_cmd", metavar="CMD", nargs=argparse.REMAINDER, help="run a binary on the device, with args") parser.add_argument( "--port", nargs="?", default="5039", help="override the port used on the host") parser.add_argument( "--user", nargs="?", default="root", help="user to run commands as on the device [default: root]") return parser.parse_args() def dump_var(root, variable): make_args = ["make", "CALLED_FROM_SETUP=true", "BUILD_SYSTEM={}/build/core".format(root), "--no-print-directory", "-f", "{}/build/core/config.mk".format(root), "dumpvar-{}".format(variable)] # subprocess cwd argument does not change the PWD shell variable, but # dumpvar.mk uses PWD to create an absolute path, so we need to set it. saved_pwd = os.environ['PWD'] os.environ['PWD'] = root make_output = subprocess.check_output(make_args, cwd=root) os.environ['PWD'] = saved_pwd return make_output.splitlines()[0] def verify_device(root, props): names = set([props["ro.build.product"], props["ro.product.device"]]) target_device = dump_var(root, "TARGET_DEVICE") if target_device not in names: msg = "TARGET_DEVICE ({}) does not match attached device ({})" sys.exit(msg.format(target_device, ", ".join(names))) def get_remote_pid(device, process_name): processes = gdbrunner.get_processes(device) if process_name not in processes: msg = "failed to find running process {}".format(process_name) sys.exit(msg) pids = processes[process_name] if len(pids) > 1: msg = "multiple processes match '{}': {}".format(process_name, pids) sys.exit(msg) # Fetch the binary using the PID later. return pids[0] def ensure_linker(device, sysroot, is64bit): local_path = os.path.join(sysroot, "system", "bin", "linker") remote_path = "/system/bin/linker" if is64bit: local_path += "64" remote_path += "64" if not os.path.exists(local_path): device.pull(remote_path, local_path) def handle_switches(args, sysroot): """Fetch the targeted binary and determine how to attach gdb. Args: args: Parsed arguments. sysroot: Local sysroot path. Returns: (binary_file, attach_pid, run_cmd). Precisely one of attach_pid or run_cmd will be None. """ device = args.device binary_file = None pid = None run_cmd = None if args.target_pid: # Fetch the binary using the PID later. pid = args.target_pid elif args.target_name: # Fetch the binary using the PID later. pid = get_remote_pid(device, args.target_name) elif args.run_cmd: if not args.run_cmd[0]: sys.exit("empty command passed to -r") if not args.run_cmd[0].startswith("/"): sys.exit("commands passed to -r must use absolute paths") run_cmd = args.run_cmd binary_file, local = gdbrunner.find_file(device, run_cmd[0], sysroot, user=args.user) if binary_file is None: assert pid is not None try: binary_file, local = gdbrunner.find_binary(device, pid, sysroot, user=args.user) except adb.ShellError: sys.exit("failed to pull binary for PID {}".format(pid)) if not local: logging.warning("Couldn't find local unstripped executable in {}," " symbols may not be available.".format(sysroot)) return (binary_file, pid, run_cmd) def generate_gdb_script(sysroot, binary_file, is64bit, port, connect_timeout=5): # Generate a gdb script. # TODO: Detect the zygote and run 'art-on' automatically. root = os.environ["ANDROID_BUILD_TOP"] symbols_dir = os.path.join(sysroot, "system", "lib64" if is64bit else "lib") vendor_dir = os.path.join(sysroot, "vendor", "lib64" if is64bit else "lib") solib_search_path = [] symbols_paths = ["", "hw", "ssl/engines", "drm", "egl", "soundfx"] vendor_paths = ["", "hw", "egl"] solib_search_path += [os.path.join(symbols_dir, x) for x in symbols_paths] solib_search_path += [os.path.join(vendor_dir, x) for x in vendor_paths] solib_search_path = ":".join(solib_search_path) gdb_commands = "" gdb_commands += "file '{}'\n".format(binary_file.name) gdb_commands += "directory '{}'\n".format(root) gdb_commands += "set solib-absolute-prefix {}\n".format(sysroot) gdb_commands += "set solib-search-path {}\n".format(solib_search_path) dalvik_gdb_script = os.path.join(root, "development", "scripts", "gdb", "dalvik.gdb") if not os.path.exists(dalvik_gdb_script): logging.warning(("couldn't find {} - ART debugging options will not " + "be available").format(dalvik_gdb_script)) else: gdb_commands += "source {}\n".format(dalvik_gdb_script) # Try to connect for a few seconds, sometimes the device gdbserver takes # a little bit to come up, especially on emulators. gdb_commands += """ python def target_remote_with_retry(target, timeout_seconds): import time end_time = time.time() + timeout_seconds while True: try: gdb.execute("target remote " + target) return True except gdb.error as e: time_left = end_time - time.time() if time_left < 0 or time_left > timeout_seconds: print("Error: unable to connect to device.") print(e) return False time.sleep(min(0.25, time_left)) target_remote_with_retry(':{}', {}) end """.format(port, connect_timeout) return gdb_commands def main(): args = parse_args() device = args.device if device is None: sys.exit("ERROR: Failed to find device.") props = device.get_props() root = os.environ["ANDROID_BUILD_TOP"] sysroot = dump_var(root, "abs-TARGET_OUT_UNSTRIPPED") # Make sure the environment matches the attached device. verify_device(root, props) debug_socket = "/data/local/tmp/debug_socket" pid = None run_cmd = None # Fetch binary for -p, -n. binary_file, pid, run_cmd = handle_switches(args, sysroot) with binary_file: arch = gdbrunner.get_binary_arch(binary_file) is64bit = arch.endswith("64") # Make sure we have the linker ensure_linker(device, sysroot, is64bit) # Start gdbserver. gdbserver_local_path = get_gdbserver_path(root, arch) gdbserver_remote_path = "/data/local/tmp/{}-gdbserver".format(arch) gdbrunner.start_gdbserver( device, gdbserver_local_path, gdbserver_remote_path, target_pid=pid, run_cmd=run_cmd, debug_socket=debug_socket, port=args.port, user=args.user) # Generate a gdb script. gdb_commands = generate_gdb_script(sysroot=sysroot, binary_file=binary_file, is64bit=is64bit, port=args.port) # Find where gdb is if sys.platform.startswith("linux"): platform_name = "linux-x86" elif sys.platform.startswith("darwin"): platform_name = "darwin-x86" else: sys.exit("Unknown platform: {}".format(sys.platform)) gdb_path = os.path.join(root, "prebuilts", "gdb", platform_name, "bin", "gdb") # Print a newline to separate our messages from the GDB session. print("") # Start gdb. gdbrunner.start_gdb(gdb_path, gdb_commands) if __name__ == "__main__": main()