Report more precise error message when attach fails

[labath]

Summary

If the remote stub sends a specific error message instead of just a E??
code, we can use this to display a more informative error message
instead of just the generic "unable to attach" message.

I write a test for this using the SB API.
On the console this will show up like:
(lldb) process attach ...
error: attach failed: <STUB-MESSAGE>

if the stub supports error messages, or:
error: attach failed: "Error ??"

if it doesn't.

[JDevlieghere]

LGTM module comment

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

3809 ↗

(On Diff #142194)

Outdated comment

[davide]

lgtm

[jingham]

That looks fine.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/gdb_remote_client/TestGDBRemoteClient.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestGDBRemoteClient(GDBRemoteTestBase):
 
     def test_connect(self):
         """Test connecting to a remote gdb server"""
         target = self.createTarget("a.yaml")
         process = self.connect(target)
         self.assertPacketLogContains(["qProcessInfo", "qfThreadInfo"])
+
+    def test_attach_fail(self):
+        error_msg = "mock-error-msg"
+
+        class MyResponder(MockGDBServerResponder):
+            # Pretend we don't have any process during the initial queries.
+            def qC(self):
+                return "E42"
+
+            def qfThreadInfo(self):
+                return "OK" # No threads.
+
+            # Then, when we are asked to attach, error out.
+            def vAttach(self, pid):
+                return "E42;" + error_msg.encode("hex")
+
+        self.server.responder = MyResponder()
+
+        target = self.dbg.CreateTarget("")
+        process = self.connect(target)
+        lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
+
+        error = lldb.SBError()
+        target.AttachToProcessWithID(lldb.SBListener(), 47, error)
+        self.assertEquals(error_msg, error.GetCString())

lldb/trunk/packages/Python/lldbsuite/test/functionalities/gdb_remote_client/gdbclientutils.py

def respond(self, packet):
         if packet[0:7] == "qSymbol":
             return self.qSymbol(packet[8:])
         if packet[0:10] == "qSupported":
             return self.qSupported(packet[11:].split(";"))
         if packet == "qfThreadInfo":
             return self.qfThreadInfo()
         if packet == "qC":
             return self.qC()
+        if packet == "QEnableErrorStrings":
+            return self.QEnableErrorStrings()
         if packet == "?":
             return self.haltReason()
         if packet[0] == "H":
             return self.selectThread(packet[1], int(packet[2:], 16))
         if packet[0:6] == "qXfer:":
             obj, read, annex, location = packet[6:].split(":")
             offset, length = [int(x, 16) for x in location.split(',')]
             data, has_more = self.qXferRead(obj, annex, offset, length)
             if data is not None:
                 return self._qXferResponse(data, has_more)
             return ""
+        if packet.startswith("vAttach;"):
+            pid = packet.partition(';')[2]
+            return self.vAttach(int(pid, 16))
         if packet[0] == "Z":
             return self.setBreakpoint(packet)
         return self.other(packet)
 
     def interrupt(self):
         raise self.UnexpectedPacketException()
 
     def cont(self):
def qSupported(self, client_supported):
         return "qXfer:features:read+;PacketSize=3fff;QStartNoAckMode+"
 
     def qfThreadInfo(self):
         return "l"
 
     def qC(self):
         return "QC0"
 
+    def QEnableErrorStrings(self):
+        return "OK"
+
     def haltReason(self):
         # SIGINT is 2, return type is 2 digit hex string
         return "S02"
 
     def qXferRead(self, obj, annex, offset, length):
         return None, False
 
     def _qXferResponse(self, data, has_more):
         return "%s%s" % ("m" if has_more else "l", escape_binary(data))
 
+    def vAttach(self, pid):
+        raise self.UnexpectedPacketException()
+
     def selectThread(self, op, thread_id):
         return "OK"
 
     def setBreakpoint(self, packet):
         raise self.UnexpectedPacketException()
 
     def other(self, packet):
         # empty string means unsupported

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
                 // the "E87" error code from debugserver -- this indicates that
                 // the process is not debuggable.  Return a slightly more
                 // helpful
                 // error message about why the attach failed.
                 if (::strstr(continue_cstr, "vAttach") != NULL &&
                     response.GetError() == 0x87) {
                   process->SetExitStatus(-1, "cannot attach to process due to "
                                              "System Integrity Protection");
-                }
-                // E01 code from vAttach means that the attach failed
-                if (::strstr(continue_cstr, "vAttach") != NULL &&
-                    response.GetError() == 0x1) {
-                  process->SetExitStatus(-1, "unable to attach");
+                } else if (::strstr(continue_cstr, "vAttach") != NULL &&
+                           response.GetStatus().Fail()) {
+                  process->SetExitStatus(-1, response.GetStatus().AsCString());
                 } else {
                   process->SetExitStatus(-1, "lost connection");
                 }
                 break;
               }
 
               default:
                 process->SetPrivateState(stop_state);