[lldb/platform-gdb] Clear cached protocol state upon disconnection

[labath]

Summary

Previously we would persist the flags indicating whether the remote side
supports a particular feature across reconnects, which is obviously not
a good idea.

I implement the clearing by nuking (its the only way to be sure :) the
entire GDBRemoteCommunication object in the disconnect operation and
creating a new one upon connection. This allows us to maintain a nice
invariant that the GDBRemoteCommunication object (which is now a
pointer) exists only if it is connected. The downside to that is that a
lot of functions now needs to check the validity of the pointer instead
of blindly accessing the object.

The process communication does not suffer from the same issue because we
always destroy the entire Process object for a relaunch.

[JDevlieghere]

LGTM

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

84–85

Should this have assert(IsConnected()); like PlatformRemoteGDBServer::LaunchGDBServer does?

104

Same here.

[labath]

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

84–85

Yeah, I guess it should.

lldb/packages/Python/lldbsuite/test/lldbgdbclient.py

def connect(self, target):
         listener = self.dbg.GetListener()
         error = lldb.SBError()
         process = target.ConnectRemote(listener,
                 self.server.get_connect_url(), "gdb-remote", error)
         self.assertTrue(error.Success(), error.description)
         self.assertTrue(process, PROCESS_IS_VALID)
         return process
 
-    def assertPacketLogContains(self, packets):
+    def assertPacketLogContains(self, packets, log=None):
         """
         Assert that the mock server's packet log contains the given packets.
 
         The packet log includes all packets sent by the client and received
         by the server.  This fuction makes it easy to verify that the client
         sent the expected packets to the server.
 
         The check does not require that the packets be consecutive, but does
         require that they are ordered in the log as they ordered in the arg.
         """
+        if log is None:
+            log = self.server.responder.packetLog
         i = 0
         j = 0
-        log = self.server.responder.packetLog
 
         while i < len(packets) and j < len(log):
             if log[j] == packets[i]:
                 i += 1
             j += 1
         if i < len(packets):
             self.fail(u"Did not receive: %s\nLast 10 packets:\n\t%s" %
                     (packets[i], u'\n\t'.join(log)))

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 PlatformAndroidRemoteGDBServer::PlatformAndroidRemoteGDBServer() = default;
 
 PlatformAndroidRemoteGDBServer::~PlatformAndroidRemoteGDBServer() {
   for (const auto &it : m_port_forwards)
     DeleteForwardPortWithAdb(it.second, m_device_id);
 }
 
 bool PlatformAndroidRemoteGDBServer::LaunchGDBServer(lldb::pid_t &pid,
                                                      std::string &connect_url) {
+  assert(IsConnected());
   uint16_t remote_port = 0;
   std::string socket_name;
-  if (!m_gdb_client.LaunchGDBServer("127.0.0.1", pid, remote_port, socket_name))
+  if (!m_gdb_client_up->LaunchGDBServer("127.0.0.1", pid, remote_port,
+                                        socket_name))
     return false;
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
   auto error =
       MakeConnectURL(pid, remote_port, socket_name.c_str(), connect_url);
   if (error.Success() && log)
     LLDB_LOGF(log, "gdbserver connect URL: %s", connect_url.c_str());
 
   return error.Success();
 }
 
 bool PlatformAndroidRemoteGDBServer::KillSpawnedProcess(lldb::pid_t pid) {
+  assert(IsConnected());
   DeleteForwardPort(pid);
-  return m_gdb_client.KillSpawnedProcess(pid);
+  return m_gdb_client_up->KillSpawnedProcess(pid);
 }
 
 Status PlatformAndroidRemoteGDBServer::ConnectRemote(Args &args) {
   m_device_id.clear();
 
   if (args.GetArgumentCount() != 1)
     return Status(
         "\"platform connect\" takes a single argument: <connect-url>");

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

public:
 
   size_t ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
                                    lldb_private::Status &error) override;
 
   virtual size_t
   GetPendingGdbServerList(std::vector<std::string> &connection_urls);
 
 protected:
-  process_gdb_remote::GDBRemoteCommunicationClient m_gdb_client;
+  std::unique_ptr<process_gdb_remote::GDBRemoteCommunicationClient>
+      m_gdb_client_up;
   std::string m_platform_description; // After we connect we can get a more
                                       // complete description of what we are
                                       // connected to
   std::string m_platform_scheme;
   std::string m_platform_hostname;
 
   lldb::UnixSignalsSP m_remote_signals_sp;
 

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 
 bool PlatformRemoteGDBServer::GetModuleSpec(const FileSpec &module_file_spec,
                                             const ArchSpec &arch,
                                             ModuleSpec &module_spec) {
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
 
   const auto module_path = module_file_spec.GetPath(false);
 
-  if (!m_gdb_client.GetModuleInfo(module_file_spec, arch, module_spec)) {
+  if (!m_gdb_client_up ||
+      !m_gdb_client_up->GetModuleInfo(module_file_spec, arch, module_spec)) {
     LLDB_LOGF(
         log,
         "PlatformRemoteGDBServer::%s - failed to get module info for %s:%s",
         __FUNCTION__, module_path.c_str(),
         arch.GetTriple().getTriple().c_str());
     return false;
   }
 
Status PlatformRemoteGDBServer::GetFileWithUUID(const FileSpec &platform_file,
                                                 FileSpec &local_file) {
   // Default to the local case
   local_file = platform_file;
   return Status();
 }
 
 /// Default Constructor
 PlatformRemoteGDBServer::PlatformRemoteGDBServer()
-    : Platform(false), // This is a remote platform
-      m_gdb_client() {
-  m_gdb_client.SetPacketTimeout(
-      process_gdb_remote::ProcessGDBRemote::GetPacketTimeout());
-}
+    : Platform(/*is_host=*/false) {}
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
 PlatformRemoteGDBServer::~PlatformRemoteGDBServer() = default;
 
 size_t PlatformRemoteGDBServer::GetSoftwareBreakpointTrapOpcode(
     Target &target, BreakpointSite *bp_site) {
   // This isn't needed if the z/Z packets are supported in the GDB remote
   // server. But we might need a packet to detect this.
   return 0;
 }
 
 bool PlatformRemoteGDBServer::GetRemoteOSVersion() {
-  m_os_version = m_gdb_client.GetOSVersion();
+  if (m_gdb_client_up)
+    m_os_version = m_gdb_client_up->GetOSVersion();
   return !m_os_version.empty();
 }
 
 llvm::Optional<std::string> PlatformRemoteGDBServer::GetRemoteOSBuildString() {
-  return m_gdb_client.GetOSBuildString();
+  if (!m_gdb_client_up)
+    return llvm::None;
+  return m_gdb_client_up->GetOSBuildString();
 }
 
 llvm::Optional<std::string>
 PlatformRemoteGDBServer::GetRemoteOSKernelDescription() {
-  return m_gdb_client.GetOSKernelDescription();
+  if (!m_gdb_client_up)
+    return llvm::None;
+  return m_gdb_client_up->GetOSKernelDescription();
 }
 
 // Remote Platform subclasses need to override this function
 ArchSpec PlatformRemoteGDBServer::GetRemoteSystemArchitecture() {
-  return m_gdb_client.GetSystemArchitecture();
+  if (!m_gdb_client_up)
+    return ArchSpec();
+  return m_gdb_client_up->GetSystemArchitecture();
 }
 
 FileSpec PlatformRemoteGDBServer::GetRemoteWorkingDirectory() {
   if (IsConnected()) {
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     FileSpec working_dir;
-    if (m_gdb_client.GetWorkingDir(working_dir) && log)
+    if (m_gdb_client_up->GetWorkingDir(working_dir) && log)
       LLDB_LOGF(log,
                 "PlatformRemoteGDBServer::GetRemoteWorkingDirectory() -> '%s'",
                 working_dir.GetCString());
     return working_dir;
   } else {
     return Platform::GetRemoteWorkingDirectory();
   }
 }
 
 bool PlatformRemoteGDBServer::SetRemoteWorkingDirectory(
     const FileSpec &working_dir) {
   if (IsConnected()) {
     // Clear the working directory it case it doesn't get set correctly. This
     // will for use to re-read it
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     LLDB_LOGF(log, "PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')",
               working_dir.GetCString());
-    return m_gdb_client.SetWorkingDir(working_dir) == 0;
+    return m_gdb_client_up->SetWorkingDir(working_dir) == 0;
   } else
     return Platform::SetRemoteWorkingDirectory(working_dir);
 }
 
 bool PlatformRemoteGDBServer::IsConnected() const {
-  return m_gdb_client.IsConnected();
+  if (m_gdb_client_up) {
+    assert(m_gdb_client_up->IsConnected());
+    return true;
+  }
+  return false;
 }
 
 Status PlatformRemoteGDBServer::ConnectRemote(Args &args) {
   Status error;
   if (IsConnected()) {
     error.SetErrorStringWithFormat("the platform is already connected to '%s', "
                                    "execute 'platform disconnect' to close the "
                                    "current connection",
Status PlatformRemoteGDBServer::ConnectRemote(Args &args) {
   llvm::Optional<URI> parsed_url = URI::Parse(url);
   if (!parsed_url)
     return Status("Invalid URL: %s", url);
 
   // We're going to reuse the hostname when we connect to the debugserver.
   m_platform_scheme = parsed_url->scheme.str();
   m_platform_hostname = parsed_url->hostname.str();
 
-  m_gdb_client.SetConnection(std::make_unique<ConnectionFileDescriptor>());
+  auto client_up =
+      std::make_unique<process_gdb_remote::GDBRemoteCommunicationClient>();
+  client_up->SetPacketTimeout(
+      process_gdb_remote::ProcessGDBRemote::GetPacketTimeout());
+  client_up->SetConnection(std::make_unique<ConnectionFileDescriptor>());
   if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
     repro::GDBRemoteProvider &provider =
         g->GetOrCreate<repro::GDBRemoteProvider>();
-    m_gdb_client.SetPacketRecorder(provider.GetNewPacketRecorder());
+    client_up->SetPacketRecorder(provider.GetNewPacketRecorder());
   }
-  m_gdb_client.Connect(url, &error);
+  client_up->Connect(url, &error);
 
   if (error.Fail())
     return error;
 
-  if (m_gdb_client.HandshakeWithServer(&error)) {
-    m_gdb_client.GetHostInfo();
+  if (client_up->HandshakeWithServer(&error)) {
+    m_gdb_client_up = std::move(client_up);
+    m_gdb_client_up->GetHostInfo();
     // If a working directory was set prior to connecting, send it down
     // now.
     if (m_working_dir)
-      m_gdb_client.SetWorkingDir(m_working_dir);
+      m_gdb_client_up->SetWorkingDir(m_working_dir);
 
     m_supported_architectures.clear();
-    ArchSpec remote_arch = m_gdb_client.GetSystemArchitecture();
+    ArchSpec remote_arch = m_gdb_client_up->GetSystemArchitecture();
     if (remote_arch) {
       m_supported_architectures.push_back(remote_arch);
       if (remote_arch.GetTriple().isArch64Bit())
         m_supported_architectures.push_back(
             ArchSpec(remote_arch.GetTriple().get32BitArchVariant()));
     }
   } else {
-    m_gdb_client.Disconnect();
+    client_up->Disconnect();
     if (error.Success())
       error.SetErrorString("handshake failed");
   }
   return error;
 }
 
 Status PlatformRemoteGDBServer::DisconnectRemote() {
   Status error;
-  m_gdb_client.Disconnect(&error);
+  m_gdb_client_up.reset();
   m_remote_signals_sp.reset();
   return error;
 }
 
 const char *PlatformRemoteGDBServer::GetHostname() {
-  m_gdb_client.GetHostname(m_name);
+  if (m_gdb_client_up)
+    m_gdb_client_up->GetHostname(m_name);
   if (m_name.empty())
     return nullptr;
   return m_name.c_str();
 }
 
 llvm::Optional<std::string>
 PlatformRemoteGDBServer::DoGetUserName(UserIDResolver::id_t uid) {
   std::string name;
-  if (m_gdb_client.GetUserName(uid, name))
+  if (m_gdb_client_up && m_gdb_client_up->GetUserName(uid, name))
     return std::move(name);
   return llvm::None;
 }
 
 llvm::Optional<std::string>
 PlatformRemoteGDBServer::DoGetGroupName(UserIDResolver::id_t gid) {
   std::string name;
-  if (m_gdb_client.GetGroupName(gid, name))
+  if (m_gdb_client_up && m_gdb_client_up->GetGroupName(gid, name))
     return std::move(name);
   return llvm::None;
 }
 
 uint32_t PlatformRemoteGDBServer::FindProcesses(
     const ProcessInstanceInfoMatch &match_info,
     ProcessInstanceInfoList &process_infos) {
-  return m_gdb_client.FindProcesses(match_info, process_infos);
+  if (m_gdb_client_up)
+    return m_gdb_client_up->FindProcesses(match_info, process_infos);
+  return 0;
 }
 
 bool PlatformRemoteGDBServer::GetProcessInfo(
     lldb::pid_t pid, ProcessInstanceInfo &process_info) {
-  return m_gdb_client.GetProcessInfo(pid, process_info);
+  if (m_gdb_client_up)
+    return m_gdb_client_up->GetProcessInfo(pid, process_info);
+  return false;
 }
 
 Status PlatformRemoteGDBServer::LaunchProcess(ProcessLaunchInfo &launch_info) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   Status error;
 
   LLDB_LOGF(log, "PlatformRemoteGDBServer::%s() called", __FUNCTION__);
 
+  if (!IsConnected())
+    return Status("Not connected.");
   auto num_file_actions = launch_info.GetNumFileActions();
   for (decltype(num_file_actions) i = 0; i < num_file_actions; ++i) {
     const auto file_action = launch_info.GetFileActionAtIndex(i);
     if (file_action->GetAction() != FileAction::eFileActionOpen)
       continue;
     switch (file_action->GetFD()) {
     case STDIN_FILENO:
-      m_gdb_client.SetSTDIN(file_action->GetFileSpec());
+      m_gdb_client_up->SetSTDIN(file_action->GetFileSpec());
       break;
     case STDOUT_FILENO:
-      m_gdb_client.SetSTDOUT(file_action->GetFileSpec());
+      m_gdb_client_up->SetSTDOUT(file_action->GetFileSpec());
       break;
     case STDERR_FILENO:
-      m_gdb_client.SetSTDERR(file_action->GetFileSpec());
+      m_gdb_client_up->SetSTDERR(file_action->GetFileSpec());
       break;
     }
   }
 
-  m_gdb_client.SetDisableASLR(
+  m_gdb_client_up->SetDisableASLR(
       launch_info.GetFlags().Test(eLaunchFlagDisableASLR));
-  m_gdb_client.SetDetachOnError(
+  m_gdb_client_up->SetDetachOnError(
       launch_info.GetFlags().Test(eLaunchFlagDetachOnError));
 
   FileSpec working_dir = launch_info.GetWorkingDirectory();
   if (working_dir) {
-    m_gdb_client.SetWorkingDir(working_dir);
+    m_gdb_client_up->SetWorkingDir(working_dir);
   }
 
   // Send the environment and the program + arguments after we connect
-  m_gdb_client.SendEnvironment(launch_info.GetEnvironment());
+  m_gdb_client_up->SendEnvironment(launch_info.GetEnvironment());
 
   ArchSpec arch_spec = launch_info.GetArchitecture();
   const char *arch_triple = arch_spec.GetTriple().str().c_str();
 
-  m_gdb_client.SendLaunchArchPacket(arch_triple);
+  m_gdb_client_up->SendLaunchArchPacket(arch_triple);
   LLDB_LOGF(
       log,
       "PlatformRemoteGDBServer::%s() set launch architecture triple to '%s'",
       __FUNCTION__, arch_triple ? arch_triple : "<NULL>");
 
   int arg_packet_err;
   {
     // Scope for the scoped timeout object
     process_gdb_remote::GDBRemoteCommunication::ScopedTimeout timeout(
-        m_gdb_client, std::chrono::seconds(5));
-    arg_packet_err = m_gdb_client.SendArgumentsPacket(launch_info);
+        *m_gdb_client_up, std::chrono::seconds(5));
+    arg_packet_err = m_gdb_client_up->SendArgumentsPacket(launch_info);
   }
 
   if (arg_packet_err == 0) {
     std::string error_str;
-    if (m_gdb_client.GetLaunchSuccess(error_str)) {
-      const auto pid = m_gdb_client.GetCurrentProcessID(false);
+    if (m_gdb_client_up->GetLaunchSuccess(error_str)) {
+      const auto pid = m_gdb_client_up->GetCurrentProcessID(false);
       if (pid != LLDB_INVALID_PROCESS_ID) {
         launch_info.SetProcessID(pid);
         LLDB_LOGF(log,
                   "PlatformRemoteGDBServer::%s() pid %" PRIu64
                   " launched successfully",
                   __FUNCTION__, pid);
       } else {
         LLDB_LOGF(log,
if (IsConnected()) {
       error.SetErrorString("not connected to remote gdb server");
     }
   }
   return process_sp;
 }
 
 bool PlatformRemoteGDBServer::LaunchGDBServer(lldb::pid_t &pid,
                                               std::string &connect_url) {
+  assert(IsConnected());
+
   ArchSpec remote_arch = GetRemoteSystemArchitecture();
   llvm::Triple &remote_triple = remote_arch.GetTriple();
 
   uint16_t port = 0;
   std::string socket_name;
   bool launch_result = false;
   if (remote_triple.getVendor() == llvm::Triple::Apple &&
       remote_triple.getOS() == llvm::Triple::IOS) {
     // When remote debugging to iOS, we use a USB mux that always talks to
     // localhost, so we will need the remote debugserver to accept connections
     // only from localhost, no matter what our current hostname is
     launch_result =
-        m_gdb_client.LaunchGDBServer("127.0.0.1", pid, port, socket_name);
+        m_gdb_client_up->LaunchGDBServer("127.0.0.1", pid, port, socket_name);
   } else {
     // All other hosts should use their actual hostname
     launch_result =
-        m_gdb_client.LaunchGDBServer(nullptr, pid, port, socket_name);
+        m_gdb_client_up->LaunchGDBServer(nullptr, pid, port, socket_name);
   }
 
   if (!launch_result)
     return false;
 
   connect_url =
       MakeGdbServerUrl(m_platform_scheme, m_platform_hostname, port,
                        (socket_name.empty()) ? nullptr : socket_name.c_str());
   return true;
 }
 
 bool PlatformRemoteGDBServer::KillSpawnedProcess(lldb::pid_t pid) {
-  return m_gdb_client.KillSpawnedProcess(pid);
+  assert(IsConnected());
+  return m_gdb_client_up->KillSpawnedProcess(pid);
 }
 
 lldb::ProcessSP PlatformRemoteGDBServer::Attach(
     ProcessAttachInfo &attach_info, Debugger &debugger,
     Target *target, // Can be NULL, if NULL create a new target, else use
                     // existing one
     Status &error) {
   lldb::ProcessSP process_sp;
if (IsConnected()) {
       error.SetErrorString("not connected to remote gdb server");
     }
   }
   return process_sp;
 }
 
 Status PlatformRemoteGDBServer::MakeDirectory(const FileSpec &file_spec,
                                               uint32_t mode) {
-  Status error = m_gdb_client.MakeDirectory(file_spec, mode);
+  if (!IsConnected())
+    return Status("Not connected.");
+  Status error = m_gdb_client_up->MakeDirectory(file_spec, mode);
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::MakeDirectory(path='%s', mode=%o) "
             "error = %u (%s)",
             file_spec.GetCString(), mode, error.GetError(), error.AsCString());
   return error;
 }
 
 Status PlatformRemoteGDBServer::GetFilePermissions(const FileSpec &file_spec,
                                                    uint32_t &file_permissions) {
-  Status error = m_gdb_client.GetFilePermissions(file_spec, file_permissions);
+  if (!IsConnected())
+    return Status("Not connected.");
+  Status error =
+      m_gdb_client_up->GetFilePermissions(file_spec, file_permissions);
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::GetFilePermissions(path='%s', "
             "file_permissions=%o) error = %u (%s)",
             file_spec.GetCString(), file_permissions, error.GetError(),
             error.AsCString());
   return error;
 }
 
 Status PlatformRemoteGDBServer::SetFilePermissions(const FileSpec &file_spec,
                                                    uint32_t file_permissions) {
-  Status error = m_gdb_client.SetFilePermissions(file_spec, file_permissions);
+  if (!IsConnected())
+    return Status("Not connected.");
+  Status error =
+      m_gdb_client_up->SetFilePermissions(file_spec, file_permissions);
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::SetFilePermissions(path='%s', "
             "file_permissions=%o) error = %u (%s)",
             file_spec.GetCString(), file_permissions, error.GetError(),
             error.AsCString());
   return error;
 }
 
 lldb::user_id_t PlatformRemoteGDBServer::OpenFile(const FileSpec &file_spec,
                                                   File::OpenOptions flags,
                                                   uint32_t mode,
                                                   Status &error) {
-  return m_gdb_client.OpenFile(file_spec, flags, mode, error);
+  if (IsConnected())
+    return m_gdb_client_up->OpenFile(file_spec, flags, mode, error);
+  return LLDB_INVALID_UID;
 }
 
 bool PlatformRemoteGDBServer::CloseFile(lldb::user_id_t fd, Status &error) {
-  return m_gdb_client.CloseFile(fd, error);
+  if (IsConnected())
+    return m_gdb_client_up->CloseFile(fd, error);
+  error = Status("Not connected.");
+  return false;
 }
 
 lldb::user_id_t
 PlatformRemoteGDBServer::GetFileSize(const FileSpec &file_spec) {
-  return m_gdb_client.GetFileSize(file_spec);
+  if (IsConnected())
+    return m_gdb_client_up->GetFileSize(file_spec);
+  return LLDB_INVALID_UID;
 }
 
 void PlatformRemoteGDBServer::AutoCompleteDiskFileOrDirectory(
     CompletionRequest &request, bool only_dir) {
-  m_gdb_client.AutoCompleteDiskFileOrDirectory(request, only_dir);
+  if (IsConnected())
+    m_gdb_client_up->AutoCompleteDiskFileOrDirectory(request, only_dir);
 }
 
 uint64_t PlatformRemoteGDBServer::ReadFile(lldb::user_id_t fd, uint64_t offset,
                                            void *dst, uint64_t dst_len,
                                            Status &error) {
-  return m_gdb_client.ReadFile(fd, offset, dst, dst_len, error);
+  if (IsConnected())
+    return m_gdb_client_up->ReadFile(fd, offset, dst, dst_len, error);
+  error = Status("Not connected.");
+  return 0;
 }
 
 uint64_t PlatformRemoteGDBServer::WriteFile(lldb::user_id_t fd, uint64_t offset,
                                             const void *src, uint64_t src_len,
                                             Status &error) {
-  return m_gdb_client.WriteFile(fd, offset, src, src_len, error);
+  if (IsConnected())
+    return m_gdb_client_up->WriteFile(fd, offset, src, src_len, error);
+  error = Status("Not connected.");
+  return 0;
 }
 
 Status PlatformRemoteGDBServer::PutFile(const FileSpec &source,
                                         const FileSpec &destination,
                                         uint32_t uid, uint32_t gid) {
   return Platform::PutFile(source, destination, uid, gid);
 }
 
 Status PlatformRemoteGDBServer::CreateSymlink(
     const FileSpec &src, // The name of the link is in src
     const FileSpec &dst) // The symlink points to dst
 {
-  Status error = m_gdb_client.CreateSymlink(src, dst);
+  if (!IsConnected())
+    return Status("Not connected.");
+  Status error = m_gdb_client_up->CreateSymlink(src, dst);
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::CreateSymlink(src='%s', dst='%s') "
             "error = %u (%s)",
             src.GetCString(), dst.GetCString(), error.GetError(),
             error.AsCString());
   return error;
 }
 
 Status PlatformRemoteGDBServer::Unlink(const FileSpec &file_spec) {
-  Status error = m_gdb_client.Unlink(file_spec);
+  if (!IsConnected())
+    return Status("Not connected.");
+  Status error = m_gdb_client_up->Unlink(file_spec);
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
   LLDB_LOGF(log, "PlatformRemoteGDBServer::Unlink(path='%s') error = %u (%s)",
             file_spec.GetCString(), error.GetError(), error.AsCString());
   return error;
 }
 
 bool PlatformRemoteGDBServer::GetFileExists(const FileSpec &file_spec) {
-  return m_gdb_client.GetFileExists(file_spec);
+  if (IsConnected())
+    return m_gdb_client_up->GetFileExists(file_spec);
+  return false;
 }
 
 Status PlatformRemoteGDBServer::RunShellCommand(
     llvm::StringRef shell, llvm::StringRef command,
     const FileSpec &
         working_dir, // Pass empty FileSpec to use the current working directory
     int *status_ptr, // Pass NULL if you don't want the process exit status
     int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                      // process to exit
     std::string
         *command_output, // Pass NULL if you don't want the command output
     const Timeout<std::micro> &timeout) {
-  return m_gdb_client.RunShellCommand(command, working_dir, status_ptr,
+  if (!IsConnected())
+    return Status("Not connected.");
+  return m_gdb_client_up->RunShellCommand(command, working_dir, status_ptr,
                                           signo_ptr, command_output, timeout);
 }
 
 void PlatformRemoteGDBServer::CalculateTrapHandlerSymbolNames() {
   m_trap_handlers.push_back(ConstString("_sigtramp"));
 }
 
 const UnixSignalsSP &PlatformRemoteGDBServer::GetRemoteUnixSignals() {
   if (!IsConnected())
     return Platform::GetRemoteUnixSignals();
 
   if (m_remote_signals_sp)
     return m_remote_signals_sp;
 
   // If packet not implemented or JSON failed to parse, we'll guess the signal
   // set based on the remote architecture.
   m_remote_signals_sp = UnixSignals::Create(GetRemoteSystemArchitecture());
 
   StringExtractorGDBRemote response;
   auto result =
-      m_gdb_client.SendPacketAndWaitForResponse("jSignalsInfo", response);
+      m_gdb_client_up->SendPacketAndWaitForResponse("jSignalsInfo", response);
 
   if (result != decltype(result)::Success ||
       response.GetResponseType() != response.eResponse)
     return m_remote_signals_sp;
 
   auto object_sp =
       StructuredData::ParseJSON(std::string(response.GetStringRef()));
   if (!object_sp || !object_sp->IsValid())
if (error.Fail())
       return i; // We already connected to i process succsessfully
   }
   return connection_urls.size();
 }
 
 size_t PlatformRemoteGDBServer::GetPendingGdbServerList(
     std::vector<std::string> &connection_urls) {
   std::vector<std::pair<uint16_t, std::string>> remote_servers;
-  m_gdb_client.QueryGDBServer(remote_servers);
+  if (!IsConnected())
+    return 0;
+  m_gdb_client_up->QueryGDBServer(remote_servers);
   for (const auto &gdbserver : remote_servers) {
     const char *socket_name_cstr =
         gdbserver.second.empty() ? nullptr : gdbserver.second.c_str();
     connection_urls.emplace_back(
         MakeGdbServerUrl(m_platform_scheme, m_platform_hostname,
                          gdbserver.first, socket_name_cstr));
   }
   return connection_urls.size();
 }

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemotePlatformFile.py

def test_file_size_fallback(self):
                    [r"File size of /some/file\.txt \(remote\): 66051"])
         self.assertPacketLogContains([
             "vFile:size:2f736f6d652f66696c652e747874",
             "vFile:open:2f736f6d652f66696c652e747874,00000000,00000000",
             "vFile:fstat:5",
             "vFile:close:5",
             ])
 
+        self.runCmd("platform disconnect")
+
+        # For a new onnection, we should attempt vFile:size once again.
+        server2 = MockGDBServer(self.server_socket_class())
+        server2.responder = Responder()
+        server2.start()
+        self.addTearDownHook(lambda:server2.stop())
+        self.runCmd("platform connect " + server2.get_connect_url())
+        self.match("platform get-size /other/file.txt",
+                   [r"File size of /other/file\.txt \(remote\): 66051"])
+
+        self.assertPacketLogContains([
+            "vFile:size:2f6f746865722f66696c652e747874",
+            "vFile:open:2f6f746865722f66696c652e747874,00000000,00000000",
+            "vFile:fstat:5",
+            "vFile:close:5",
+            ],
+            log=server2.responder.packetLog)
+
     @skipIfWindows
     def test_file_permissions(self):
         """Test 'platform get-permissions'"""
 
         class Responder(MockGDBServerResponder):
             def vFile(self, packet):
                 return "F1a4"