Linux - debugging of local processes via lldb-gdbserver

[vharron]

Summary

Instead of lldb calling the ptrace APIs directly, it launches an llgs
instance and communicates with it via the remote debug protocol.

This has two advantages.

1. There is more code shared between the remote debugging code path

and the local debugging code path. If a feature works in remote, it
probably works locally and vice-versa.

2. It makes us more architecturally similar to OSX (which also does

local debugging via a connection to debugserver).

This path is called LLGS local. We think that this configuration is
now at parity with (or better than) local linux debugging.

It is currently invoked if you have an environment variable defined
"PLATFORM_LINUX_FORCE_LLGS_LOCAL"

We would like to switch to LLGS local as the default path and only
use the non-LLGS path if someone has an environment variable defined
"PLATFORM_LINUX_DISABLE_LLGS_LOCAL"

Later, if all goes well, we would like to remove non-LLGS local
debugging support to simplify the codebase and avoid confusion.

[clayborg]

Looks good. I believe doing remote debugging all of the time is the best way to go and what we should encourage people to use it.

We might also, in a separate patch, ask the platform for the GDB remote binary. The default implementation would return "lldb-gdbserver":

virtual Error
Platform::GetGDBServer(FileSpec &f)
{

// Calculate the default path to llgs

}

Then we would override this on PlatformDarwin to return the path to debugserver. This way the GDB remote binary path isn't hard coded at compile time. And other platforms that use the GDB remote protocol can specify their own binaries that might get distributed with the built LLDB.

[ovyalov]

lgtm

[vharron]

Changed from reading env variable to reading setting

[vharron]

Removed unchanged file

[clayborg]

Looks good.

[vharron]

Committed: r230919

source/Plugins/Platform/Linux/PlatformLinux.cpp

namespace
     };
 
     const PropertyDefinition*
     GetStaticPropertyDefinitions ()
     {
         static PropertyDefinition
         g_properties[] =
         {
-            { "use-llgs-for-local" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "Control whether the platform uses llgs for local debug sessions." },
+            { "use-llgs-for-local" , OptionValue::eTypeBoolean, true, true, NULL, NULL, "Control whether the platform uses llgs for local debug sessions." },
             {  NULL        , OptionValue::eTypeInvalid, false, 0  , NULL, NULL, NULL  }
         };
 
-        // Allow environment variable to force using llgs-local.
-        if (getenv("PLATFORM_LINUX_FORCE_LLGS_LOCAL"))
-            g_properties[ePropertyUseLlgsForLocal].default_uint_value = true;
+        // Allow environment variable to disable llgs-local.
+        if (getenv("PLATFORM_LINUX_DISABLE_LLGS_LOCAL"))
+            g_properties[ePropertyUseLlgsForLocal].default_uint_value = false;
 
         return g_properties;
     }
 }
 
 class PlatformLinuxProperties : public Properties
 {
 public:

test/lldbtest.py

 def expectedFailureLinux(bugnumber=None, compilers=None):
     if bugnumber: return expectedFailureOS('linux', bugnumber, compilers)
 
 def expectedFailureWindows(bugnumber=None, compilers=None):
     if bugnumber: return expectedFailureOS('win32', bugnumber, compilers)
 
 def expectedFailureLLGS(bugnumber=None, compilers=None):
     def fn(self):
-        return 'PLATFORM_LINUX_FORCE_LLGS_LOCAL' in os.environ and self.expectedCompiler(compilers)
+        # llgs local is only an option on Linux systems
+        if 'linux' not in sys.platform:
+            return False
+        self.runCmd('settings show platform.plugin.linux.use-llgs-for-local')
+        return 'true' in self.res.GetOutput() and self.expectedCompiler(compilers)
     if bugnumber: return expectedFailure(fn, bugnumber)
 
 def skipIfRemote(func):
     """Decorate the item to skip tests if testing remotely."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@skipIfRemote can only be used to decorate a test method")
     @wraps(func)
     def wrapper(*args, **kwargs):