| # Copyright 2015 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """cros debug: Debug the applications on the target device.""" |
| |
| from __future__ import print_function |
| |
| import os |
| import logging |
| import urlparse |
| |
| from chromite import cros |
| from chromite.lib import cros_build_lib |
| from chromite.lib import remote_access |
| |
| |
| @cros.CommandDecorator('debug') |
| class DebugCommand(cros.CrosCommand): |
| """Use GDB to debug a process running on the target device. |
| |
| This command starts a GDB session to debug a remote process running on the |
| target device. The remote process can either be an existing process or newly |
| started by calling this command. |
| |
| This command can also be used to find out information about all running |
| processes of an executable on the target device. |
| """ |
| |
| # Override base class property to enable stats upload. |
| upload_stats = True |
| |
| def __init__(self, options): |
| """Initialize DebugCommand.""" |
| cros.CrosCommand.__init__(self, options) |
| # SSH connection settings. |
| self.ssh_hostname = None |
| self.ssh_port = None |
| self.ssh_username = None |
| self.ssh_private_key = None |
| # The board name of the target device. |
| self.board = None |
| # Settings of the process to debug. |
| self.attach = False |
| self.list = False |
| self.exe = None |
| self.pid = None |
| |
| @classmethod |
| def AddParser(cls, parser): |
| """Add parser arguments.""" |
| super(cls, DebugCommand).AddParser(parser) |
| parser.add_argument( |
| 'device', help='IP[:port] address of the target device.') |
| parser.add_argument( |
| '--board', default=None, help='The board to use. By default it is ' |
| 'automatically detected. You can override the detected board with ' |
| 'this option.') |
| parser.add_argument( |
| '--private-key', type='path', default=None, |
| help='SSH identity file (private key).') |
| parser.add_argument( |
| '--attach', action='store_true', default=False, |
| help='Attach GDB to an already running process on the target device.') |
| parser.add_argument( |
| '-l', '--list', action='store_true', default=False, |
| help='List running processes of the executable on the target device.') |
| parser.add_argument( |
| '--exe', help='Full path of the executable on the target device.') |
| parser.add_argument( |
| '-p', '--pid', type=int, |
| help='The pid of the process on the target device.') |
| |
| def _GetRunningPids(self, device): |
| """Get all the running pids on the device with the executable path.""" |
| try: |
| result = device.BaseRunCommand(['pgrep', '-fx', self.exe]) |
| try: |
| return [int(pid) for pid in result.output.splitlines()] |
| except ValueError: |
| cros_build_lib.Die('Parsing output failed:\n%s', result.output) |
| except cros_build_lib.RunCommandError: |
| cros_build_lib.Die( |
| 'Failed to find any running process of %s on device %s', self.exe, |
| self.ssh_hostname) |
| |
| def _ListProcesses(self, device, pids): |
| """Provided with a list of pids, print out information of the processes.""" |
| try: |
| result = device.BaseRunCommand(['ps', 'aux']) |
| lines = result.output.splitlines() |
| try: |
| header, procs = lines[0], lines[1:] |
| info = os.linesep.join([p for p in procs if int(p.split()[1]) in pids]) |
| except ValueError: |
| cros_build_lib.Die('Parsing output failed:\n%s', result.output) |
| |
| print('\nList running processes of %s on device %s:\n%s\n%s' % |
| (self.exe, self.ssh_hostname, header, info)) |
| except cros_build_lib.RunCommandError: |
| cros_build_lib.Die( |
| 'Failed to find any running process on device %s', self.ssh_hostname) |
| |
| def _DebugNewProcess(self): |
| """Start a new process on the target device and attach gdb to it.""" |
| logging.info( |
| 'Ready to start and debug %s on device %s', self.exe, self.ssh_hostname) |
| cmd = [ |
| 'gdb_remote', '--ssh', |
| '--board', self.board, |
| '--remote', self.ssh_hostname, |
| '--remote_file', self.exe, |
| ] |
| cros_build_lib.RunCommand(cmd) |
| |
| def _DebugRunningProcess(self, pid): |
| """Start gdb and attach it to the remote running process with |pid|.""" |
| logging.info( |
| 'Ready to debug process %d on device %s', pid, self.ssh_hostname) |
| cmd = [ |
| 'gdb_remote', '--ssh', |
| '--board', self.board, |
| '--remote', self.ssh_hostname, |
| '--remote_pid', str(pid), |
| ] |
| cros_build_lib.RunCommand(cmd) |
| |
| def _ReadOptions(self): |
| """Process options and set variables.""" |
| device = self.options.device |
| if urlparse.urlparse(device).scheme == '': |
| # For backward compatibility, prepend ssh:// ourselves. |
| device = 'ssh://%s' % device |
| |
| parsed = urlparse.urlparse(device) |
| if parsed.scheme == 'ssh': |
| self.ssh_hostname = parsed.hostname |
| self.ssh_username = parsed.username |
| self.ssh_port = parsed.port |
| self.ssh_private_key = self.options.private_key |
| self.attach = self.options.attach |
| self.list = self.options.list |
| self.exe = self.options.exe |
| self.pid = self.options.pid |
| else: |
| cros_build_lib.Die('Does not support device %s', self.options.device) |
| |
| def Run(self): |
| """Run cros debug.""" |
| self.options.Freeze() |
| self._ReadOptions() |
| self.RunInsideChroot(auto_detect_project=True) |
| try: |
| with remote_access.ChromiumOSDeviceHandler( |
| self.ssh_hostname, port=self.ssh_port, username=self.ssh_username, |
| private_key=self.ssh_private_key) as device: |
| self.board = cros_build_lib.GetBoard(device_board=device.board, |
| override_board=self.options.board) |
| logging.info('Board is %s', self.board) |
| |
| if self.pid: |
| # Ignore other flags and start GDB on the pid if it is provided. |
| self._DebugRunningProcess(self.pid) |
| return |
| |
| if not (self.exe and self.exe.startswith('/')): |
| cros_build_lib.Die('--exe is required and must be a full pathname.') |
| logging.info('Executable path is %s', self.exe) |
| if not device.IsFileExecutable(self.exe): |
| cros_build_lib.Die( |
| 'File path "%s" does not exist or is not executable on device %s', |
| self.exe, self.ssh_hostname) |
| |
| if self.list: |
| # If '--list' flag is on, list the processes without launching GDB. |
| pids = self._GetRunningPids(device) |
| self._ListProcesses(device, pids) |
| return |
| |
| if self.attach: |
| pids = self._GetRunningPids(device) |
| if not pids: |
| cros_build_lib.Die('No running process of %s is found on device %s', |
| self.exe, self.ssh_hostname) |
| elif len(pids) == 1: |
| idx = 0 |
| else: |
| self._ListProcesses(device, pids) |
| idx = cros_build_lib.GetChoice( |
| 'Please select the process pid to debug:', pids) |
| self._DebugRunningProcess(pids[idx]) |
| return |
| |
| self._DebugNewProcess() |
| |
| except (Exception, KeyboardInterrupt) as e: |
| logging.error(e) |
| if self.options.debug: |
| raise |
