[lldb] Prevent 'process connect' from using local-only plugins

[mgorny]

Summary

Add a 'can_connect' parameter to Process plugin initialization, and use
it to filter plugins to these capable of remote connections. This is
used to prevent 'process connect' from picking up a plugin that can only
be used locally, e.g. the legacy FreeBSD plugin.

[emaste]

Looks ok to me

[labath]

This is all weird (not in a "your fault" way). ProcessFreeBSD is decidedly a local-only plugin. It could never successfully complete the "process connect" command, regardless of whether we have some other remote plugin or not.

I think that the real fix here would be to change the plugin selection logic (Target::CreateProcess) to convey the fact that we're looking for a connectable plugin. The method already contains a FileSpec *core_file argument, which I guess is needed to select the proper core file subclass, so adding a can_connect argument would not be unreasonable (though not exactly pretty either).

Though, for the purposes of this test, just adding a "--plugin gdb-remote" argument to the "process connect" command should be sufficient as well.

[mgorny]

In D91810#2407461, @labath wrote:

I think that the real fix here would be to change the plugin selection logic (Target::CreateProcess) to convey the fact that we're looking for a connectable plugin. The method already contains a FileSpec *core_file argument, which I guess is needed to select the proper core file subclass, so adding a can_connect argument would not be unreasonable (though not exactly pretty either).

Would maybe a static class variable ('property'?) be cleaner?

[labath]

In D91810#2407483, @mgorny wrote:

In D91810#2407461, @labath wrote:

I think that the real fix here would be to change the plugin selection logic (Target::CreateProcess) to convey the fact that we're looking for a connectable plugin. The method already contains a FileSpec *core_file argument, which I guess is needed to select the proper core file subclass, so adding a can_connect argument would not be unreasonable (though not exactly pretty either).

Would maybe a static class variable ('property'?) be cleaner?

It might, though I am not sure how would you make that interact with the current selection logic. And I think you'll still need to pass a flag all the way to Process::FindPlugin, as that's the thing which iterates over registered classes.

[mgorny]

Updated to pass can_debug parameter, as suggested by @labath.

[labath]

Seems ok. The code could really use a refactor though...

lldb/test/Shell/Commands/command-process-connect.test

0–1

I'm pretty sure windows suffered from the same problem.

[mgorny]

lldb/test/Shell/Commands/command-process-connect.test

0–1

Ok, I will remove this and see what buildbots say.

lldb/include/lldb/Target/Process.h

/// UnregisterNotificationCallbacks (const Notifications&)
   /// Scans all loaded plug-in interfaces that implement versions of the
   /// Process plug-in interface and returns the first instance that can debug
   /// the file.
   ///
   /// \see Process::CanDebug ()
   static lldb::ProcessSP FindPlugin(lldb::TargetSP target_sp,
                                     llvm::StringRef plugin_name,
                                     lldb::ListenerSP listener_sp,
-                                    const FileSpec *crash_file_path);
+                                    const FileSpec *crash_file_path,
+                                    bool can_connect);
 
   /// Static function that can be used with the \b host function
   /// Host::StartMonitoringChildProcess ().
   ///
   /// This function can be used by lldb_private::Process subclasses when they
   /// want to watch for a local process and have its exit status automatically
   /// set when the host child process exits. Subclasses should call
   /// Host::StartMonitoringChildProcess () with:

lldb/include/lldb/Target/ProcessTrace.h

protected:
   void Clear();
 
   bool UpdateThreadList(ThreadList &old_thread_list,
                         ThreadList &new_thread_list) override;
 
 private:
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
-                                        const FileSpec *crash_file_path);
+                                        const FileSpec *crash_file_path,
+                                        bool can_connect);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_PROCESSTRACE_H

lldb/include/lldb/Target/Target.h

public:
   /// \param[in] s
   ///     The stream to which to dump the object description.
   void Dump(Stream *s, lldb::DescriptionLevel description_level);
 
   // If listener_sp is null, the listener of the owning Debugger object will be
   // used.
   const lldb::ProcessSP &CreateProcess(lldb::ListenerSP listener_sp,
                                        llvm::StringRef plugin_name,
-                                       const FileSpec *crash_file);
+                                       const FileSpec *crash_file,
+                                       bool can_connect);
 
   const lldb::ProcessSP &GetProcessSP() const;
 
   bool IsValid() { return m_valid; }
 
   void Destroy();
 
   Status Launch(ProcessLaunchInfo &launch_info,

lldb/include/lldb/lldb-private-interfaces.h

typedef lldb::StructuredDataPluginSP (*StructuredDataPluginCreateInstance)(
     Process &process);
 typedef Status (*StructuredDataFilterLaunchInfo)(ProcessLaunchInfo &launch_info,
                                                  Target *target);
 typedef SystemRuntime *(*SystemRuntimeCreateInstance)(Process *process);
 typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
                                                    const ArchSpec *arch);
 typedef lldb::ProcessSP (*ProcessCreateInstance)(
     lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-    const FileSpec *crash_file_path);
+    const FileSpec *crash_file_path, bool can_connect);
 typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(
     Debugger &debugger);
 typedef SymbolFile *(*SymbolFileCreateInstance)(lldb::ObjectFileSP objfile_sp);
 typedef SymbolVendor *(*SymbolVendorCreateInstance)(
     const lldb::ModuleSP &module_sp,
     lldb_private::Stream
         *feedback_strm); // Module can be NULL for default system symbol vendor
 typedef bool (*BreakpointHitCallback)(void *baton,

lldb/source/API/SBTarget.cpp

LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore,
                      (const char *, lldb::SBError &), core_file, error);
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     FileSpec filespec(core_file);
     FileSystem::Instance().Resolve(filespec);
     ProcessSP process_sp(target_sp->CreateProcess(
-        target_sp->GetDebugger().GetListener(), "", &filespec));
+        target_sp->GetDebugger().GetListener(), "", &filespec, false));
     if (process_sp) {
       error.SetError(process_sp->LoadCore());
       if (error.Success())
         sb_process.SetSP(process_sp);
     } else {
       error.SetErrorString("Failed to create the process");
     }
   } else {
lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
   SBProcess sb_process;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());
 
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (listener.IsValid())
       process_sp =
-          target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, nullptr);
+          target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, nullptr,
+                                   true);
     else
       process_sp = target_sp->CreateProcess(
-          target_sp->GetDebugger().GetListener(), plugin_name, nullptr);
+          target_sp->GetDebugger().GetListener(), plugin_name, nullptr, true);
 
     if (process_sp) {
       sb_process.SetSP(process_sp);
       error.SetError(process_sp->ConnectRemote(url));
     } else {
       error.SetErrorString("unable to create lldb_private::Process");
     }
   } else {

lldb/source/Commands/CommandObjectTarget.cpp

if (argc == 1 || core_file || remote_file) {
         }
 
         if (core_file) {
           FileSpec core_file_dir;
           core_file_dir.GetDirectory() = core_file.GetDirectory();
           target_sp->AppendExecutableSearchPaths(core_file_dir);
 
           ProcessSP process_sp(target_sp->CreateProcess(
-              GetDebugger().GetListener(), llvm::StringRef(), &core_file));
+              GetDebugger().GetListener(), llvm::StringRef(), &core_file,
+              false));
 
           if (process_sp) {
             // Seems weird that we Launch a core file, but that is what we
             // do!
             error = process_sp->LoadCore();
 
             if (error.Fail()) {
               result.AppendError(

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

if (target && error.Success()) {
         LLDB_LOGF(log, "PlatformPOSIX::%s set selected target to %p %s",
                   __FUNCTION__, (void *)target,
                   exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
                                 : "<null>");
       }
 
       process_sp =
           target->CreateProcess(attach_info.GetListenerForProcess(debugger),
-                                attach_info.GetProcessPluginName(), nullptr);
+                                attach_info.GetProcessPluginName(), nullptr,
+                                false);
 
       if (process_sp) {
         ListenerSP listener_sp = attach_info.GetHijackListener();
         if (listener_sp == nullptr) {
           listener_sp =
               Listener::MakeListener("lldb.PlatformPOSIX.attach.hijack");
           attach_info.SetHijackListener(listener_sp);
         }
PlatformPOSIX::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
   }
 
   // Mark target as currently selected target.
   debugger.GetTargetList().SetSelectedTarget(target);
 
   // Now create the gdb-remote process.
   LLDB_LOG(log, "having target create process with gdb-remote plugin");
   process_sp =
-      target->CreateProcess(launch_info.GetListener(), "gdb-remote", nullptr);
+      target->CreateProcess(launch_info.GetListener(), "gdb-remote", nullptr,
+                            true);
 
   if (!process_sp) {
     error.SetErrorString("CreateProcess() failed for gdb-remote process");
     LLDB_LOG(log, "error: {0}", error);
     return process_sp;
   }
 
   LLDB_LOG(log, "successfully created process");

lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp

ProcessSP PlatformWindows::DebugProcess(ProcessLaunchInfo &launch_info,
   }
 
   if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
     // This is a process attach.  Don't need to launch anything.
     ProcessAttachInfo attach_info(launch_info);
     return Attach(attach_info, debugger, target, error);
   } else {
     ProcessSP process_sp = target->CreateProcess(
-        launch_info.GetListener(), launch_info.GetProcessPluginName(), nullptr);
+        launch_info.GetListener(), launch_info.GetProcessPluginName(), nullptr,
+        false);
 
     // We need to launch and attach to the process.
     launch_info.GetFlags().Set(eLaunchFlagDebug);
     if (process_sp)
       error = process_sp->Launch(launch_info);
 
     return process_sp;
   }
lldb::ProcessSP PlatformWindows::Attach(ProcessAttachInfo &attach_info,
 
   if (!target || error.Fail())
     return process_sp;
 
   debugger.GetTargetList().SetSelectedTarget(target);
 
   const char *plugin_name = attach_info.GetProcessPluginName();
   process_sp = target->CreateProcess(
-      attach_info.GetListenerForProcess(debugger), plugin_name, nullptr);
+      attach_info.GetListenerForProcess(debugger), plugin_name, nullptr, false);
 
   process_sp->HijackProcessEvents(attach_info.GetHijackListener());
   if (process_sp)
     error = process_sp->Attach(attach_info);
 
   return process_sp;
 }
 

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

if (IsConnected()) {
           error.Clear();
 
         if (target && error.Success()) {
           debugger.GetTargetList().SetSelectedTarget(target);
 
           // The darwin always currently uses the GDB remote debugger plug-in
           // so even when debugging locally we are debugging remotely!
           process_sp = target->CreateProcess(launch_info.GetListener(),
-                                             "gdb-remote", nullptr);
+                                             "gdb-remote", nullptr, true);
 
           if (process_sp) {
             error = process_sp->ConnectRemote(connect_url.c_str());
             // Retry the connect remote one time...
             if (error.Fail())
               error = process_sp->ConnectRemote(connect_url.c_str());
             if (error.Success())
               error = process_sp->Launch(launch_info);
if (IsConnected()) {
 
         if (target && error.Success()) {
           debugger.GetTargetList().SetSelectedTarget(target);
 
           // The darwin always currently uses the GDB remote debugger plug-in
           // so even when debugging locally we are debugging remotely!
           process_sp =
               target->CreateProcess(attach_info.GetListenerForProcess(debugger),
-                                    "gdb-remote", nullptr);
+                                    "gdb-remote", nullptr, true);
           if (process_sp) {
             error = process_sp->ConnectRemote(connect_url.c_str());
             if (error.Success()) {
               ListenerSP listener_sp = attach_info.GetHijackListener();
               if (listener_sp)
                 process_sp->HijackProcessEvents(listener_sp);
               error = process_sp->Attach(attach_info);
             }

lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h

 class FreeBSDThread;
 
 class ProcessFreeBSD : public lldb_private::Process {
 
 public:
   // Static functions.
   static lldb::ProcessSP
   CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-                 const lldb_private::FileSpec *crash_file_path);
+                 const lldb_private::FileSpec *crash_file_path,
+                 bool can_connect);
 
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();

lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 }
 }
 
 // Static functions.
 
 lldb::ProcessSP
 ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp,
                                lldb::ListenerSP listener_sp,
-                               const FileSpec *crash_file_path) {
+                               const FileSpec *crash_file_path,
+                               bool can_connect) {
   lldb::ProcessSP process_sp;
-  if (crash_file_path == NULL)
+  if (crash_file_path == NULL && !can_connect)
     process_sp.reset(
         new ProcessFreeBSD(target_sp, listener_sp, GetFreeBSDSignals()));
   return process_sp;
 }
 
 void ProcessFreeBSD::Initialize() {
   static llvm::once_flag g_once_flag;
 

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h

 
 class ThreadKDP;
 
 class ProcessKDP : public lldb_private::Process {
 public:
   // Constructors and Destructors
   static lldb::ProcessSP
   CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-                 const lldb_private::FileSpec *crash_file_path);
+                 const lldb_private::FileSpec *crash_file_path,
+                 bool can_connect);
 
   static void Initialize();
 
   static void DebuggerInitialize(lldb_private::Debugger &debugger);
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 }
 
 void ProcessKDP::Terminate() {
   PluginManager::UnregisterPlugin(ProcessKDP::CreateInstance);
 }
 
 lldb::ProcessSP ProcessKDP::CreateInstance(TargetSP target_sp,
                                            ListenerSP listener_sp,
-                                           const FileSpec *crash_file_path) {
+                                           const FileSpec *crash_file_path,
+                                           bool can_connect) {
   lldb::ProcessSP process_sp;
   if (crash_file_path == NULL)
     process_sp = std::make_shared<ProcessKDP>(target_sp, listener_sp);
   return process_sp;
 }
 
 bool ProcessKDP::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) {
   if (plugin_specified_by_name)

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h

 
 class HostProcess;
 
 class ProcessWindows : public Process, public ProcessDebugger {
 public:
   // Static functions.
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
-                                        const FileSpec *);
+                                        const FileSpec *,
+                                        bool can_connect);
 
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

std::string GetProcessExecutableName(DWORD pid) {
   return file_name;
 }
 } // anonymous namespace
 
 namespace lldb_private {
 
 ProcessSP ProcessWindows::CreateInstance(lldb::TargetSP target_sp,
                                          lldb::ListenerSP listener_sp,
-                                         const FileSpec *) {
+                                         const FileSpec *,
+                                         bool can_connect) {
   return ProcessSP(new ProcessWindows(target_sp, listener_sp));
 }
 
 static bool ShouldUseLLDBServer() {
   llvm::StringRef use_lldb_server = ::getenv("LLDB_USE_LLDB_SERVER");
   return use_lldb_server.equals_lower("on") ||
          use_lldb_server.equals_lower("yes") ||
          use_lldb_server.equals_lower("1") ||

lldb/source/Plugins/Process/elf-core/ProcessElfCore.h

 
 struct ThreadData;
 
 class ProcessElfCore : public lldb_private::PostMortemProcess {
 public:
   // Constructors and Destructors
   static lldb::ProcessSP
   CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-                 const lldb_private::FileSpec *crash_file_path);
+                 const lldb_private::FileSpec *crash_file_path,
+                 bool can_connect);
 
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

 }
 
 void ProcessElfCore::Terminate() {
   PluginManager::UnregisterPlugin(ProcessElfCore::CreateInstance);
 }
 
 lldb::ProcessSP ProcessElfCore::CreateInstance(lldb::TargetSP target_sp,
                                                lldb::ListenerSP listener_sp,
-                                               const FileSpec *crash_file) {
+                                               const FileSpec *crash_file,
+                                               bool can_connect) {
   lldb::ProcessSP process_sp;
-  if (crash_file) {
+  if (crash_file && !can_connect) {
     // Read enough data for a ELF32 header or ELF64 header Note: Here we care
     // about e_type field only, so it is safe to ignore possible presence of
     // the header extension.
     const size_t header_size = sizeof(llvm::ELF::Elf64_Ehdr);
 
     auto data_sp = FileSystem::Instance().CreateDataBuffer(
         crash_file->GetPath(), header_size, 0);
     if (data_sp && data_sp->GetByteSize() == header_size &&

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

class ProcessGDBRemote : public Process,
                          private GDBRemoteClientBase::ContinueDelegate {
 public:
   ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
 
   ~ProcessGDBRemote() override;
 
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
-                                        const FileSpec *crash_file_path);
+                                        const FileSpec *crash_file_path,
+                                        bool can_connect);
 
   static void Initialize();
 
   static void DebuggerInitialize(Debugger &debugger);
 
   static void Terminate();
 
   static ConstString GetPluginNameStatic();

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

 
 void ProcessGDBRemote::Terminate() {
   PluginManager::UnregisterPlugin(ProcessGDBRemote::CreateInstance);
 }
 
 lldb::ProcessSP
 ProcessGDBRemote::CreateInstance(lldb::TargetSP target_sp,
                                  ListenerSP listener_sp,
-                                 const FileSpec *crash_file_path) {
+                                 const FileSpec *crash_file_path,
+                                 bool can_connect) {
   lldb::ProcessSP process_sp;
   if (crash_file_path == nullptr)
     process_sp = std::make_shared<ProcessGDBRemote>(target_sp, listener_sp);
   return process_sp;
 }
 
 bool ProcessGDBRemote::CanDebug(lldb::TargetSP target_sp,
                                 bool plugin_specified_by_name) {

lldb/source/Plugins/Process/mach-core/ProcessMachCore.h

public:
   // Constructors and Destructors
   ProcessMachCore(lldb::TargetSP target_sp, lldb::ListenerSP listener,
                   const lldb_private::FileSpec &core_file);
 
   ~ProcessMachCore() override;
 
   static lldb::ProcessSP
   CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener,
-                 const lldb_private::FileSpec *crash_file_path);
+                 const lldb_private::FileSpec *crash_file_path,
+                 bool can_connect);
 
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();

lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

 }
 
 void ProcessMachCore::Terminate() {
   PluginManager::UnregisterPlugin(ProcessMachCore::CreateInstance);
 }
 
 lldb::ProcessSP ProcessMachCore::CreateInstance(lldb::TargetSP target_sp,
                                                 ListenerSP listener_sp,
-                                                const FileSpec *crash_file) {
+                                                const FileSpec *crash_file,
+                                                bool can_connect) {
   lldb::ProcessSP process_sp;
-  if (crash_file) {
+  if (crash_file && !can_connect) {
     const size_t header_size = sizeof(llvm::MachO::mach_header);
     auto data_sp = FileSystem::Instance().CreateDataBuffer(
         crash_file->GetPath(), header_size, 0);
     if (data_sp && data_sp->GetByteSize() == header_size) {
       DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
 
       lldb::offset_t data_offset = 0;
       llvm::MachO::mach_header mach_header;

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

 namespace lldb_private {
 
 namespace minidump {
 
 class ProcessMinidump : public PostMortemProcess {
 public:
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
-                                        const FileSpec *crash_file_path);
+                                        const FileSpec *crash_file_path,
+                                        bool can_connect);
 
   static void Initialize();
 
   static void Terminate();
 
   static ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

 }
 
 const char *ProcessMinidump::GetPluginDescriptionStatic() {
   return "Minidump plug-in.";
 }
 
 lldb::ProcessSP ProcessMinidump::CreateInstance(lldb::TargetSP target_sp,
                                                 lldb::ListenerSP listener_sp,
-                                                const FileSpec *crash_file) {
-  if (!crash_file)
+                                                const FileSpec *crash_file,
+                                                bool can_connect) {
+  if (!crash_file || can_connect)
     return nullptr;
 
   lldb::ProcessSP process_sp;
   // Read enough data for the Minidump header
   constexpr size_t header_size = sizeof(Header);
   auto DataPtr = FileSystem::Instance().CreateDataBuffer(crash_file->GetPath(),
                                                          header_size, 0);
   if (!DataPtr)

lldb/source/Target/Platform.cpp

lldb::ProcessSP Platform::DoConnectProcess(llvm::StringRef connect_url,
   }
 
   if (!target || error.Fail())
     return nullptr;
 
   debugger.GetTargetList().SetSelectedTarget(target);
 
   lldb::ProcessSP process_sp =
-      target->CreateProcess(debugger.GetListener(), plugin_name, nullptr);
+      target->CreateProcess(debugger.GetListener(), plugin_name, nullptr, true);
 
   if (!process_sp)
     return nullptr;
 
   // If this private method is called with a stream we are synchronous.
   const bool synchronous = stream != nullptr;
 
   ListenerSP listener_sp(

lldb/source/Target/Process.cpp

 
 llvm::ArrayRef<OptionDefinition> ProcessLaunchCommandOptions::GetDefinitions() {
   return llvm::makeArrayRef(g_process_launch_options);
 }
 
 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp,
                               llvm::StringRef plugin_name,
                               ListenerSP listener_sp,
-                              const FileSpec *crash_file_path) {
+                              const FileSpec *crash_file_path,
+                              bool can_connect) {
   static uint32_t g_process_unique_id = 0;
 
   ProcessSP process_sp;
   ProcessCreateInstance create_callback = nullptr;
   if (!plugin_name.empty()) {
     ConstString const_plugin_name(plugin_name);
     create_callback =
         PluginManager::GetProcessCreateCallbackForPluginName(const_plugin_name);
     if (create_callback) {
-      process_sp = create_callback(target_sp, listener_sp, crash_file_path);
+      process_sp = create_callback(target_sp, listener_sp, crash_file_path,
+                                   can_connect);
       if (process_sp) {
         if (process_sp->CanDebug(target_sp, true)) {
           process_sp->m_process_unique_id = ++g_process_unique_id;
         } else
           process_sp.reset();
       }
     }
   } else {
     for (uint32_t idx = 0;
          (create_callback =
               PluginManager::GetProcessCreateCallbackAtIndex(idx)) != nullptr;
          ++idx) {
-      process_sp = create_callback(target_sp, listener_sp, crash_file_path);
+      process_sp = create_callback(target_sp, listener_sp, crash_file_path,
+                                   can_connect);
       if (process_sp) {
         if (process_sp->CanDebug(target_sp, false)) {
           process_sp->m_process_unique_id = ++g_process_unique_id;
           break;
         } else
           process_sp.reset();
       }
     }

lldb/source/Target/ProcessTrace.cpp

 }
 
 void ProcessTrace::Terminate() {
   PluginManager::UnregisterPlugin(ProcessTrace::CreateInstance);
 }
 
 ProcessSP ProcessTrace::CreateInstance(TargetSP target_sp,
                                        ListenerSP listener_sp,
-                                       const FileSpec *crash_file) {
+                                       const FileSpec *crash_file,
+                                       bool can_connect) {
+  if (can_connect)
+    return nullptr;
   return std::make_shared<ProcessTrace>(target_sp, listener_sp);
 }
 
 bool ProcessTrace::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) {
   return plugin_specified_by_name;
 }
 
 ProcessTrace::ProcessTrace(TargetSP target_sp, ListenerSP listener_sp)

lldb/source/Target/Target.cpp

if (m_process_sp) {
     CleanupProcess();
 
     m_process_sp.reset();
   }
 }
 
 const lldb::ProcessSP &Target::CreateProcess(ListenerSP listener_sp,
                                              llvm::StringRef plugin_name,
-                                             const FileSpec *crash_file) {
+                                             const FileSpec *crash_file,
+                                             bool can_connect) {
   if (!listener_sp)
     listener_sp = GetDebugger().GetListener();
   DeleteCurrentProcess();
   m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name,
-                                     listener_sp, crash_file);
+                                     listener_sp, crash_file, can_connect);
   return m_process_sp;
 }
 
 const lldb::ProcessSP &Target::GetProcessSP() const { return m_process_sp; }
 
 lldb::REPLSP Target::GetREPL(Status &err, lldb::LanguageType language,
                              const char *repl_options, bool can_create) {
   if (language == eLanguageTypeUnknown) {
LLDB_LOGF(log,
               "process, getting a process plugin to do this for us.",
               __FUNCTION__);
 
     if (state == eStateConnected) {
       assert(m_process_sp);
     } else {
       // Use a Process plugin to construct the process.
       const char *plugin_name = launch_info.GetProcessPluginName();
-      CreateProcess(launch_info.GetListener(), plugin_name, nullptr);
+      CreateProcess(launch_info.GetListener(), plugin_name, nullptr, false);
     }
 
     // Since we didn't have a platform launch the process, launch it here.
     if (m_process_sp)
       error = m_process_sp->Launch(launch_info);
   }
 
   if (!m_process_sp && error.Success())
if (state != eStateConnected && platform_sp != nullptr &&
       platform_sp->CanDebugProcess()) {
     SetPlatform(platform_sp);
     process_sp = platform_sp->Attach(attach_info, GetDebugger(), this, error);
   } else {
     if (state != eStateConnected) {
       const char *plugin_name = attach_info.GetProcessPluginName();
       process_sp =
           CreateProcess(attach_info.GetListenerForProcess(GetDebugger()),
-                        plugin_name, nullptr);
+                        plugin_name, nullptr, false);
       if (process_sp == nullptr) {
         error.SetErrorStringWithFormat(
             "failed to create process using plugin %s",
             (plugin_name) ? plugin_name : "null");
         return error;
       }
     }
     if (hijack_listener_sp)

lldb/source/Target/TraceSessionFileParser.cpp

TraceSessionFileParser::ParseProcess(const JSONProcess &process) {
 
   ParsedProcess parsed_process;
   parsed_process.target_sp = target_sp;
 
   m_debugger.GetTargetList().SetSelectedTarget(target_sp.get());
 
   ProcessSP process_sp = target_sp->CreateProcess(
       /*listener*/ nullptr, "trace",
-      /*crash_file*/ nullptr);
+      /*crash_file*/ nullptr,
+      /*can_connect*/ false);
 
   process_sp->SetID(static_cast<lldb::pid_t>(process.pid));
 
   for (const JSONThread &thread : process.threads)
     parsed_process.threads.push_back(ParseThread(process_sp, thread));
 
   for (const JSONModule &module : process.modules)
     if (Error err = ParseModule(target_sp, module))

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

 import lldb
 import binascii
 import os
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 @skipIfRemote
 class TestProcessConnect(GDBRemoteTestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
 
-    @skipIfWindows
     def test_gdb_remote_sync(self):
         """Test the gdb-remote command in synchronous mode"""
         try:
             self.dbg.SetAsync(False)
             self.expect("gdb-remote " + self.server.get_connect_address(),
                         substrs=['Process', 'stopped'])
         finally:
             self.dbg.GetSelectedPlatform().DisconnectRemote()
 
-    @skipIfWindows
     @skipIfReproducer # Reproducer don't support async.
     def test_gdb_remote_async(self):
         """Test the gdb-remote command in asynchronous mode"""
         try:
             self.dbg.SetAsync(True)
             self.expect("gdb-remote " + self.server.get_connect_address(),
                         matching=False,
                         substrs=['Process', 'stopped'])
             lldbutil.expect_state_changes(self, self.dbg.GetListener(),
                                           self.process(), [lldb.eStateStopped])
         finally:
             self.dbg.GetSelectedPlatform().DisconnectRemote()
 
-    @skipIfWindows
-    @expectedFailureAll(oslist=["freebsd"])
     def test_process_connect_sync(self):
         """Test the gdb-remote command in synchronous mode"""
         try:
             self.dbg.SetAsync(False)
             self.expect("process connect connect://" +
                         self.server.get_connect_address(),
                         substrs=['Process', 'stopped'])
         finally:
             self.dbg.GetSelectedPlatform().DisconnectRemote()
 
-    @skipIfWindows
-    @expectedFailureAll(oslist=["freebsd"])
     @skipIfReproducer # Reproducer don't support async.
     def test_process_connect_async(self):
         """Test the gdb-remote command in asynchronous mode"""
         try:
             self.dbg.SetAsync(True)
             self.expect("process connect connect://" +
                         self.server.get_connect_address(),
                         matching=False,
                         substrs=['Process', 'stopped'])
             lldbutil.expect_state_changes(self, self.dbg.GetListener(),
                                           self.process(), [lldb.eStateStopped])
         finally:
             self.dbg.GetSelectedPlatform().DisconnectRemote()

lldb/test/Shell/Commands/command-process-connect.test

-# UNSUPPORTED: system-windows
-# XFAIL: system-freebsd
-
 # Synchronous
 # RUN: %lldb -o 'platform select remote-gdb-server' -o 'process connect connect://localhost:4321' 2>&1 | FileCheck %s
 
 # Asynchronous
 # RUN: echo -e 'platform select remote-gdb-server\nprocess connect connect://localhost:4321' | %lldb 2>&1 | FileCheck %s
 
 # CHECK: Platform: remote-gdb-server
 # CHECK: Connected: no
 # CHECK: error: Failed to connect port