Make --gdb work again by using gdbserver

sky/tools/skydb

 #!/usr/bin/env python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import skypy.paths
 from skypy.skyserver import SkyServer
 import argparse
 import json
 import logging
@@ skipping 13 matching lines @@
 from pylib import forwarder
 
 
 SUPPORTED_MIME_TYPES = [
     'text/html',
     'text/sky',
     'text/plain',
 ]
 
 DEFAULT_SKY_COMMAND_PORT = 7777
+GDB_PORT = 8888
 SKY_SERVER_PORT = 9999
 PID_FILE_PATH = "/tmp/skydb.pids"
 DEFAULT_URL = "https://raw.githubusercontent.com/domokit/mojo/master/sky/examples/home.sky"
 
 
 # FIXME: Move this into mopy.config
 def gn_args_from_build_dir(build_dir):
     gn_cmd = [
         'gn', 'args',
         build_dir,
@@ skipping 81 matching lines @@
 
     def sky_server_for_args(self, args):
         # FIXME: This is a hack.  sky_server should just take a build_dir
         # not a magical "configuration" name.
         configuration = os.path.basename(os.path.normpath(args.build_dir))
         server_root = self._server_root_for_url(args.url_or_path)
         sky_server = SkyServer(self.paths, SKY_SERVER_PORT,
             configuration, server_root)
         return sky_server
 
+    def _create_paths_for_build_dir(self, build_dir):
+        # skypy.paths.Paths takes a root-relative build_dir argument. :(
+        abs_build_dir = os.path.abspath(build_dir)
+        root_relative_build_dir = os.path.relpath(abs_build_dir, SRC_ROOT)
+        return skypy.paths.Paths(root_relative_build_dir)
+
     def start_command(self, args):
-        # skypy.paths.Paths takes a root-relative build_dir argument. :(
-        build_dir = os.path.abspath(args.build_dir)
-        root_relative_build_dir = os.path.relpath(build_dir, SRC_ROOT)
         # FIXME: Lame that we use self for a command-specific variable.
-        self.paths = skypy.paths.Paths(root_relative_build_dir)
+        self.paths = self._create_paths_for_build_dir(args.build_dir)
 
         self.stop_command(None) # Quit any existing process.
         self.pids = {} # Clear out our pid file.
 
         # FIXME: This is probably not the right way to compute is_android
         # from the build directory?
         gn_args = gn_args_from_build_dir(args.build_dir)
         is_android = 'android_sdk_version' in gn_args
 
         sky_server = self.sky_server_for_args(args)
@@ skipping 16 matching lines @@
                 sky_server.port)
             self.pids['remote_sky_server_port'] = device_http_port
 
             port_string = 'tcp:%s' % args.command_port
             subprocess.check_call([
                 'adb', 'forward', port_string, port_string
             ])
             self.pids['remote_sky_command_port'] = args.command_port
 
         shell_command = self._build_mojo_shell_command(args)
+
+        # On android we can't launch inside gdb, but rather have to attach.
+        if args.gdb and not is_android:
+            shell_command = ['gdbserver', ':%s' % GDB_PORT] + shell_command
+
         print ' '.join(map(pipes.quote, shell_command))
         self.pids['mojo_shell_pid'] = subprocess.Popen(shell_command).pid
 
-        if args.gdb:
-            print "Sorry, I'm not sure how best to wire up --gdb to work"
-            print "with mojo_shell as a background process.  For now use:"
-            print "gdb --pid %s" % self.pids['mojo_shell_pid']
-            shell_command = ['gdb'] + shell_command
+        if args.gdb and is_android:
+            gdbserver_cmd = ['gdbserver', '--attach', ':%s' % GDB_PORT]
+            self.pids['remote_gdbserver_pid'] = subprocess.Popen(shell_command).pid
 
-        if not self._wait_for_sky_command_port():
-            logging.error('Failed to start sky')
-            self.stop_command(None)
+            port_string = 'tcp:%s' % GDB_PORT
+            subprocess.check_call([
+                'adb', 'forward', port_string, port_string
+            ])
+            self.pids['remote_gdbserver_port'] = GDB_PORT
+
+        if not args.gdb:
+            if not self._wait_for_sky_command_port():
+                logging.error('Failed to start sky')
+                self.stop_command(None)
+            else:
+                self.load_command(args)
         else:
-            self.load_command(args)
+            print 'No load issued, connect with gdb first and then run load.'
 
     def _kill_if_exists(self, key, name):
         pid = self.pids.pop(key, None)
         if not pid:
             logging.info('No pid for %s, nothing to do.' % name)
             return
         logging.info('Killing %s (%s).' % (name, pid))
         try:
             os.kill(pid, signal.SIGTERM)
         except OSError:
             logging.info('%s (%s) already gone.' % (name, pid))
 
     def stop_command(self, args):
         # TODO(eseidel): mojo_shell crashes when attempting graceful shutdown.
         # self._send_command_to_sky('/quit')
         self._kill_if_exists('mojo_shell_pid', 'mojo_shell')
 
         self._kill_if_exists('sky_server_pid', 'sky_server')
         # We could be much more surgical here:
-        if 'remote_sky_command_port' in self.pids:
+        if 'remote_sky_server_port' in self.pids:

[eseidel, 2015/01/13 20:11:32]

This was just checking for the wrong key.  They both occur in the same
conditions, but this is more correct.

             device = android_commands.AndroidCommands(
                 self.pids['device_serial'])
             forwarder.Forwarder.UnmapAllDevicePorts(device)
 
         if 'remote_sky_command_port' in self.pids:
             # adb forward --remove takes the *host* port, not the remote port.
             port_string = 'tcp:%s' % self.pids['sky_command_port']
             subprocess.call(['adb', 'forward', '--remove', port_string])
 
+        if 'remote_gdbserver_port' in self.pids:
+            port_string = 'tcp:%s' % self.pids['remote_gdbserver_port']
+            subprocess.call(['adb', 'forward', '--remove', port_string])
+
     def load_command(self, args):
         if not urlparse.urlparse(args.url_or_path).scheme:
             # The load happens on the remote device, use the remote port.
             remote_sky_server_port = self.pids.get('remote_sky_server_port',
                 self.pids['sky_server_port'])
             url = SkyServer.url_for_path(remote_sky_server_port,
                     self.pids['sky_server_root'], args.url_or_path)
         else:
             url = args.url_or_path
         self._send_command_to_sky('/load', url)
@@ skipping 50 matching lines @@
     def logcat_command(self, args):
         TAGS = [
             'AndroidHandler',
             'MojoMain',
             'MojoShellActivity',
             'MojoShellApplication',
             'chromium',
         ]
         subprocess.call(['adb', 'logcat', '-s'] + TAGS)
 
+    def gdb_attach_command(self, args):
+        self.paths = self._create_paths_for_build_dir(self.pids['build_dir'])
+        gdb_command = [
+            '/usr/bin/gdb', self.paths.mojo_shell_path,
+            '--eval-command', 'target remote localhost:%s' % GDB_PORT
+        ]
+        print " ".join(gdb_command)
+        # We don't want python listenting for signals or anything, so exec
+        # gdb and let it take the entire process.
+        os.execv(gdb_command[0], gdb_command)
+
     def main(self):
         logging.basicConfig(level=logging.INFO)
         logging.getLogger("requests").setLevel(logging.WARNING)
 
         self.pids = self._load_pid_file(PID_FILE_PATH)
 
         parser = argparse.ArgumentParser(description='Sky launcher/debugger')
         subparsers = parser.add_subparsers(help='sub-command help')
 
         start_parser = subparsers.add_parser('start',
@@ skipping 11 matching lines @@
         start_parser.set_defaults(func=self.start_command)
 
         stop_parser = subparsers.add_parser('stop',
             help=('stop sky (as listed in %s)' % PID_FILE_PATH))
         stop_parser.set_defaults(func=self.stop_command)
 
         logcat_parser = subparsers.add_parser('logcat',
             help=('dump sky-related logs from device'))
         logcat_parser.set_defaults(func=self.logcat_command)
 
+        gdb_attach_parser = subparsers.add_parser('gdb_attach',
+            help='launch gdb and attach to gdbserver launched from start --gdb')
+        gdb_attach_parser.set_defaults(func=self.gdb_attach_command)
+
         self._add_basic_command(subparsers, 'trace', '/trace',
             'toggle tracing')
         self._add_basic_command(subparsers, 'reload', '/reload',
             'reload the current page')
         self._add_basic_command(subparsers, 'inspect', '/inspect',
             'stop the running sky instance')
 
         load_parser = subparsers.add_parser('load',
             help='load a new page in the currently running sky')
         load_parser.add_argument('url_or_path', type=str)
         load_parser.set_defaults(func=self.load_command)
 
         args = parser.parse_args()
         args.func(args)
 
         self._write_pid_file(PID_FILE_PATH, self.pids)
 
 
 if __name__ == '__main__':
     SkyDebugger().main()