[lldb/Plugins] Update ScriptedProcess Process Plugin

[mib]

Summary

This patch is an update of D95713 since the commit have been reverted.

It fixes the hangs, crashes and other asynchronous issues when using Scripted Processes.

rdar://65508855

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Dead-code removal

[JDevlieghere]

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

94

You can move this into the if on line 98, or even just inline it.

101–104

139

I see this newline between log and LLDB_LOGF across this patch and while I don't mind (it's consistent) I'm curious why it's here. The next line is immediately using log and it other places in this patch where a variable is used directly after there is (usually) no newline.

206

Do we need this loop at all? It looks like nothing is ever setting is_running to true, so effectively this runs just the once? The two nested loops make it pretty hard to follow what the control flow is here.

237

317–346

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

129

Can we add a Doxygen comment (group) that explains what these things are and what they're used for?

[mib]

Address @JDevlieghere feedbacks

[JDevlieghere]

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

129–134

The trailing comments are a real pain with the 80 col limit and we're actively moving away from them. Please use /// above the line instead or consider documenting the whole thing with a comment group.

[mib]

Use Doxygen group comment for ScriptedProcess members.

[JDevlieghere]

LGTM

[jingham]

A bunch of little comments. I was also curious why you directly set the running private state, but use the async thread to generate the stopped events?

lldb/source/Plugins/Process/CMakeLists.txt

15

Why is this necessary? The code in Plugins/Process/scripted should work for any script interpreter (and should handle the case when there isn't one.)

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

79

If making the scripted process fails because there's no script interpreter, it would be good to get that fact out to the user. Maybe the ScriptedProcess constructor should take a Status object that it's caller can somehow bubble up?

86

If these two conditions aren't true, do you actually want to continue? Seems like you should error out here as well.

171

Does it do any good to broadcast the ShouldExit bit if the Async thread isn't running? If you're following the llvm style, you would do:

if (!m_async_thread.IsJoinable()) {

// Do your logging
return;

}

First, and then all the actual work of the function outside an if. That would the odd look of sending an event that you know is going to a particular thread when the thread isn't running?

262

I don't know if you actually need this, but it seems weird to be setting the PID in WillLaunch. I don't think there's any real process plugin that would know the PID of the launched process in WillLaunch. Maybe it just looks odd, but still is seems worthwhile to follow the behavior of "real" process plugins wherever you can.

301

Maybe these should be asserts. It really shouldn't be possible to get to DoResume for a ScriptedProcess with no interpreter and no script object. Also messages in the generic ScriptProcess code shouldn't refer to Python directly. You don't know that that's the script interpreter language being used here.

316

We call Status objects "error" pretty much everywhere. If we end up changing to use "status" then we should do that wholesale.

323

This seems asymmetric, why do you use the async thread to generate the stopped event, but not the running event?

328

Presumably the Interface knew why Resume failed if it did. Don't erase that information in the error you return here.

337

You checked both m_interpreter & m_script_object_sp above when checking for validity. Do you need to check both here as well.

343

The comment above Process::ReadMemory says processes plugins should not override the method. Why do you need to do this here? If there is a reason, it should be explained.

389

You are inconsistent about what you check for "We didn't manage to make the scripted process at all". Sometimes you just check for the interpreter and sometimes you check that and the m_script_object_sp...

Maybe you should put those checks into a ScriptedProcess method so you do it the same way everywhere.

411

Presumably this is just unimplemented? This is supposed to get the current set of threads, if any of them are in old_thread_list then they get copied to new_thread_list, and then any actually new threads will get added to new_thread_list.

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

24

I'm not sure LaunchInfo is the right name for this class. While it does get constructed by grabbing a couple of fields out of the ProcessLaunchInfo, it's actually used just to construct the ScriptedProcess so it isn't directly about launching the scripted process. Since you do a separate Launch operation, and you pass that a different entity also called LaunchInfo, I think this name is confusing.

119

The name of this bit is odd. It instructs the Async Thread to switch the private process state to eStateStopped. So AsyncContinue is a confusing name.

[mib]

Address @jingham feedbacks:

• Make ScriptedProcess plugin language agnostic
• Simplify execution control by removing Listener-Broadcaster model
• Solve non-deterministic hangs following D105698
• Fix memory read bug.

[mib]

Fix ScriptedProcess::IsAlive crash during process destruction

lldb/include/lldb/Interpreter/ScriptInterpreter.h

 //===-- ScriptInterpreter.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_INTERPRETER_SCRIPTINTERPRETER_H
 #define LLDB_INTERPRETER_SCRIPTINTERPRETER_H
 
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBError.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Interpreter/ScriptedProcessInterface.h"
enum ScriptReturnType {
     eScriptReturnTypeDouble,
     eScriptReturnTypeChar,
     eScriptReturnTypeCharStrOrNone,
     eScriptReturnTypeOpaqueObject
   };
 
   ScriptInterpreter(
       Debugger &debugger, lldb::ScriptLanguage script_lang,
-      lldb::ScriptedProcessInterfaceUP scripted_process_interface_up = {});
+      lldb::ScriptedProcessInterfaceUP scripted_process_interface_up =
+          std::make_unique<ScriptedProcessInterface>());
 
   ~ScriptInterpreter() override = default;
 
   struct ExecuteScriptOptions {
   public:
     ExecuteScriptOptions()
         : m_enable_io(true), m_set_lldb_globals(true), m_maskout_errors(true) {}
 

lldb/include/lldb/Target/Process.h

protected:
   ///     will be returned.
   ///
   /// \return
   ///     The number of bytes that were actually read into \a buf.
   ///     Zero is returned in the case of an error.
   virtual size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
                               Status &error) = 0;
 
-  void SetState(lldb::EventSP &event_sp);
-
   lldb::StateType GetPrivateState();
 
   /// The "private" side of resuming a process.  This doesn't alter the state
   /// of m_run_lock, but just causes the process to resume.
   ///
   /// \return
   ///     An Status object describing the success or failure of the resume.
   Status PrivateResume();

lldb/source/Plugins/Process/CMakeLists.txt

 if (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   add_subdirectory(Linux)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   add_subdirectory(FreeBSD)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
   add_subdirectory(NetBSD)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
   add_subdirectory(Windows/Common)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(MacOSX-Kernel)
 endif()
+if (LLDB_ENABLE_PYTHON)
+  add_subdirectory(scripted)
+endif()
 add_subdirectory(gdb-remote)
 add_subdirectory(Utility)
 add_subdirectory(elf-core)
 add_subdirectory(mach-core)
 add_subdirectory(minidump)

lldb/source/Plugins/Process/scripted/CMakeLists.txt

+add_lldb_library(lldbPluginScriptedProcess PLUGIN
+  ScriptedProcess.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbTarget
+    lldbUtility
+    lldbPluginProcessUtility
+  LINK_COMPONENTS
+    BinaryFormat
+    Object
+    Support
+  )

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

+//===-- ScriptedProcess.h ------------------------------------- -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H
+#define LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H
+
+#include "lldb/Target/Process.h"
+#include "lldb/Utility/Broadcaster.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Status.h"
+
+#include <mutex>
+
+namespace lldb_private {
+
+class ScriptedProcess : public Process {
+protected:
+  class LaunchInfo {
+  public:
+    LaunchInfo(const ProcessLaunchInfo &launch_info) {
+      m_class_name = launch_info.GetScriptedProcessClassName();
+      m_dictionary_sp = launch_info.GetScriptedProcessDictionarySP();
+    }
+
+    std::string GetClassName() const { return m_class_name; }
+    StructuredData::DictionarySP GetDictionarySP() const {
+      return m_dictionary_sp;
+    }
+
+  private:
+    std::string m_class_name;
+    StructuredData::DictionarySP m_dictionary_sp;
+  };
+
+public:
+  static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
+                                        lldb::ListenerSP listener_sp,
+                                        const FileSpec *crash_file_path,
+                                        bool can_connect);
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static ConstString GetPluginNameStatic();
+
+  static const char *GetPluginDescriptionStatic();
+
+  ScriptedProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
+                  const ScriptedProcess::LaunchInfo &launch_info);
+
+  ~ScriptedProcess() override;
+
+  bool CanDebug(lldb::TargetSP target_sp,
+                bool plugin_specified_by_name) override;
+
+  DynamicLoader *GetDynamicLoader() override { return nullptr; }
+
+  ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+
+  SystemRuntime *GetSystemRuntime() override { return nullptr; }
+
+  bool StartAsyncThread();
+
+  void StopAsyncThread();
+
+  static lldb::thread_result_t AsyncThread(void *arg);
+
+  Status DoLoadCore() override;
+
+  Status WillLaunch(Module *module) override;
+
+  Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
+
+  void DidLaunch() override;
+
+  Status DoResume() override;
+
+  Status DoDestroy() override;
+
+  void RefreshStateAfterStop() override{};
+
+  bool IsAlive() override;
+
+  size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                    Status &error) override;
+
+  size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                      Status &error) override;
+
+  ArchSpec GetArchitecture();
+
+  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
+                             MemoryRegionInfo &range_info) override;
+
+  Status
+  GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) override;
+
+  bool GetProcessInfo(ProcessInstanceInfo &info) override;
+
+protected:
+  void Clear();
+
+  bool DoUpdateThreadList(ThreadList &old_thread_list,
+                          ThreadList &new_thread_list) override;
+
+  lldb::StateType SendContinuePacketAndWaitForResponse();
+
+  /// Broadcaster event bits definitions.
+  enum {
+    eBroadcastBitAsyncContinue = (1 << 0),
+    eBroadcastBitAsyncThreadShouldExit = (1 << 1),
+  };
+
+private:
+  ScriptedProcessInterface &GetInterface() const;
+
+  // Member variables.
+  const LaunchInfo m_launch_info;
+  lldb_private::ScriptInterpreter *m_interpreter = nullptr;
+  lldb_private::StructuredData::ObjectSP m_script_object_sp = nullptr;
+  Broadcaster m_async_broadcaster; ///< The broadcaster emitting process/thread
+                                   /// state change events.
+  lldb::ListenerSP m_async_listener_sp; ///< The listener waiting for
+                                        /// process/thread state change events.
+  HostThread m_async_thread; ///< The separate lldb thread that monitors events.
+  std::recursive_mutex m_async_thread_state_mutex;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

+//===-- ScriptedProcess.cpp -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ScriptedProcess.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+
+#include "lldb/Host/OptionParser.h"
+#include "lldb/Host/ThreadLauncher.h"
+#include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Interpreter/OptionGroupBoolean.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/RegisterContext.h"
+
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/State.h"
+
+#include <mutex>
+
+LLDB_PLUGIN_DEFINE(ScriptedProcess)
+
+using namespace lldb;
+using namespace lldb_private;
+
+ConstString ScriptedProcess::GetPluginNameStatic() {
+  static ConstString g_name("ScriptedProcess");
+  return g_name;
+}
+
+const char *ScriptedProcess::GetPluginDescriptionStatic() {
+  return "Scripted Process plug-in.";
+}
+
+lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
+                                                lldb::ListenerSP listener_sp,
+                                                const FileSpec *file,
+                                                bool can_connect) {
+  ScriptedProcess::LaunchInfo launch_info(target_sp->GetProcessLaunchInfo());
+
+  auto process_sp =
+      std::make_shared<ScriptedProcess>(target_sp, listener_sp, launch_info);
+
+  if (!process_sp || !process_sp->m_script_object_sp ||
+      !process_sp->m_script_object_sp->IsValid())
+    return nullptr;
+
+  return process_sp;
+}
+
+bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
+                               bool plugin_specified_by_name) {
+  return true;
+}
+
+ScriptedProcess::ScriptedProcess(lldb::TargetSP target_sp,
+                                 lldb::ListenerSP listener_sp,
+                                 const ScriptedProcess::LaunchInfo &launch_info)
+    : Process(target_sp, listener_sp), m_launch_info(launch_info),
+      m_async_broadcaster(nullptr,
+                          "lldb.process.scripted-process.async-broadcaster"),
+      m_async_listener_sp(Listener::MakeListener(
+          "lldb.process.scripted-process.async-listener")),
+      m_async_thread_state_mutex() {
+  if (!target_sp)
+    return;
+
+  m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
+
+  if (!m_interpreter)
+    return;
+
+  StructuredData::ObjectSP object_sp = GetInterface().CreatePluginObject(
+      m_launch_info.GetClassName().c_str(), target_sp,
+      m_launch_info.GetDictionarySP());
+
+  if (object_sp && object_sp->IsValid())
+    m_script_object_sp = object_sp;
+
+  m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit,
+                                   "async thread should exit");
+  m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue,
+                                   "async thread continue");
+
+  const uint32_t async_event_mask =
+      eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
+
+  if (m_async_listener_sp->StartListeningForEvents(
+          &m_async_broadcaster, async_event_mask) != async_event_mask) {
+    LLDB_LOGF(
+        GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS),
+        "ScriptedProcess::%s failed to listen for m_async_broadcaster events",
+        __FUNCTION__);
+
+    m_script_object_sp = nullptr;
+  }
+}
+
+ScriptedProcess::~ScriptedProcess() {
+  StopAsyncThread();
+  Clear();
+  // We need to call finalize on the process before destroying ourselves to
+  // make sure all of the broadcaster cleanup goes as planned. If we destruct
+  // this class, then Process::~Process() might have problems trying to fully
+  // destroy the broadcaster.
+  Finalize();
+}
+
+void ScriptedProcess::Initialize() {
+  static llvm::once_flag g_once_flag;
+
+  llvm::call_once(g_once_flag, []() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(), CreateInstance);
+  });
+}
+
+void ScriptedProcess::Terminate() {
+  PluginManager::UnregisterPlugin(ScriptedProcess::CreateInstance);
+}
+
+ConstString ScriptedProcess::GetPluginName() { return GetPluginNameStatic(); }
+
+uint32_t ScriptedProcess::GetPluginVersion() { return 1; }
+
+bool ScriptedProcess::StartAsyncThread() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+  LLDB_LOGF(log, "ScriptedProcess::%s ()", __FUNCTION__);
+
+  std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
+  if (m_async_thread.IsJoinable()) {
+    LLDB_LOGF(log,
+              "ScriptedProcess::%s () - Called when Async thread was "
+              "already running.",
+              __FUNCTION__);
+    return true;
+  }
+
+  llvm::Expected<HostThread> async_thread =
+      ThreadLauncher::LaunchThread("<lldb.process.scripted-process.async>",
+                                   ScriptedProcess::AsyncThread, this);
+
+  if (!async_thread) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+                   async_thread.takeError(),
+                   "failed to launch host thread: {}");
+    return false;
+  }
+
+  m_async_thread = *async_thread;
+  return m_async_thread.IsJoinable();
+}
+
+void ScriptedProcess::StopAsyncThread() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+  LLDB_LOGF(log, "ScriptedProcess::%s ()", __FUNCTION__);
+
+  std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
+
+  m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncThreadShouldExit);
+
+  if (m_async_thread.IsJoinable()) {
+    m_async_thread.Join(nullptr);
+    m_async_thread.Reset();
+  } else
+    LLDB_LOGF(
+        log,
+        "ScriptedProcess::%s () - Called when Async thread was not running.",
+        __FUNCTION__);
+}
+
+thread_result_t ScriptedProcess::AsyncThread(void *arg) {
+  ScriptedProcess *process = static_cast<ScriptedProcess *>(arg);
+
+  const lldb::pid_t pid = process->GetID();
+
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+  LLDB_LOGF(log,
+            "ScriptedProcess::%s (arg = %p, pid = %" PRIu64
+            ") thread starting...",
+            __FUNCTION__, arg, pid);
+
+  EventSP event_sp;
+  bool done = false;
+  while (!done) {
+    LLDB_LOGF(log,
+              "ScriptedProcess::%s (arg = %p, pid = %" PRIu64
+              ") listener.WaitForEvent (NULL, event_sp)...",
+              __FUNCTION__, arg, pid);
+    if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
+      const uint32_t event_type = event_sp->GetType();
+
+      switch (event_type) {
+      case eBroadcastBitAsyncContinue: {
+        LLDB_LOGF(log,
+                  "ScriptedProcess::%s (arg = %p, pid = %" PRIu64
+                  ") got eBroadcastBitAsyncContinue",
+                  __FUNCTION__, arg, pid);
+
+        process->SetPrivateState(eStateStopped);
+
+      } break;
+
+      case eBroadcastBitAsyncThreadShouldExit: {
+        LLDB_LOGF(log,
+                  "ScriptedProcess::%s (arg = %p, pid = %" PRIu64
+                  ") got eBroadcastBitAsyncThreadShouldExit...",
+                  __FUNCTION__, arg, pid);
+        done = true;
+      } break;
+
+      default: {
+        LLDB_LOGF(log,
+                  "ScriptedProcess::%s (arg = %p, pid = %" PRIu64
+                  ") got unknown event 0x%8.8x",
+                  __FUNCTION__, arg, pid, event_type);
+        done = true;
+      } break;
+      }
+    } else {
+      LLDB_LOGF(log,
+                "ScriptedProcess::AsyncThread (pid = %" PRIu64
+                ") listener.WaitForEvent (NULL, event_sp) => false",
+                pid);
+      done = true;
+    }
+  }
+
+  LLDB_LOGF(log,
+            "ScriptedProcess::%s (arg = %p, pid = %" PRIu64
+            ") thread exiting...",
+            __FUNCTION__, arg, pid);
+
+  return {};
+}
+
+StateType ScriptedProcess::SendContinuePacketAndWaitForResponse() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+  LLDB_LOGF(log, "ScriptedProcess::%s ()", __FUNCTION__);
+
+  m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncThreadShouldExit);
+
+  return eStateStopped;
+}
+
+Status ScriptedProcess::DoLoadCore() {
+  ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo();
+
+  return DoLaunch(nullptr, launch_info);
+}
+
+Status ScriptedProcess::WillLaunch(Module *module) {
+  if (m_interpreter)
+    m_pid = GetInterface().GetProcessID();
+  return Status();
+}
+
+Status ScriptedProcess::DoLaunch(Module *exe_module,
+                                 ProcessLaunchInfo &launch_info) {
+  if (!m_interpreter)
+    return Status("No interpreter.");
+
+  if (!m_script_object_sp)
+    return Status("No python object.");
+
+  if (!m_async_thread.IsJoinable())
+    StartAsyncThread();
+
+  SetPrivateState(eStateLaunching);
+
+  Status status = GetInterface().Launch();
+
+  if (status.Fail())
+    return status;
+
+  m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncContinue);
+
+  UpdateThreadListIfNeeded();
+  GetThreadList();
+
+  return {};
+}
+
+void ScriptedProcess::DidLaunch() {
+  if (m_interpreter)
+    m_pid = GetInterface().GetProcessID();
+}
+
+Status ScriptedProcess::DoResume() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  if (!m_interpreter)
+    return Status("No interpreter.");
+
+  if (!m_script_object_sp)
+    return Status("No python object.");
+
+  // FIXME: Fetch data from thread.
+  const StateType thread_resume_state = eStateRunning;
+
+  LLDB_LOGF(log, "ScriptedProcess::%s thread_resume_state = %s", __FUNCTION__,
+            StateAsCString(thread_resume_state));
+
+  bool resume = (thread_resume_state == eStateRunning);
+  assert(thread_resume_state == eStateRunning && "invalid thread resume state");
+
+  Status status;
+  if (resume) {
+    LLDB_LOGF(log, "ScriptedProcess::%s sending resume", __FUNCTION__);
+
+    status = GetInterface().Resume();
+
+    if (status.Success()) {
+      SetPrivateState(eStateRunning);
+      m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncContinue);
+    } else
+      status.SetErrorString("ScriptedProcess resume failed");
+  } else {
+    status.SetErrorString("thread is suspended");
+  }
+
+  return status;
+}
+
+Status ScriptedProcess::DoDestroy() { return Status(); }
+
+bool ScriptedProcess::IsAlive() {
+  if (!m_interpreter)
+    return false;
+
+  return GetInterface().IsAlive();
+}
+
+size_t ScriptedProcess::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                   Status &error) {
+  return DoReadMemory(addr, buf, size, error);
+}
+


+size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                     Status &error) {
+
+  auto error_with_message = [&error](llvm::StringRef message) {
+    error.SetErrorString(message);
+    return LLDB_INVALID_ADDRESS;
+  };
+
+  if (!m_interpreter)
+    return error_with_message("No interpreter.");
+
+  lldb::DataExtractorSP data_extractor_sp =
+      GetInterface().ReadMemoryAtAddress(addr, size, error);
+
+  if (!data_extractor_sp || error.Fail())
+    return LLDB_INVALID_ADDRESS;
+
+  if (data_extractor_sp->GetByteSize() != size)
+    return error_with_message("Failed to read requested memory size.");
+
+  offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
+      0, size, buf, size, GetByteOrder());
+
+  if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
+    return error_with_message("Failed to copy read memory to buffer.");
+
+  return size;
+}
+
+ArchSpec ScriptedProcess::GetArchitecture() {
+  return GetTarget().GetArchitecture();
+}
+
+Status ScriptedProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
+                                            MemoryRegionInfo &region) {
+  return Status();
+}
+
+Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos &region_list) {
+  Status error;
+
+  if (!m_interpreter) {
+    error.SetErrorString("No interpreter.");
+    return error;
+  }
+
+  lldb::addr_t address = 0;
+  lldb::MemoryRegionInfoSP mem_region_sp = nullptr;
+
+  while ((mem_region_sp =
+              GetInterface().GetMemoryRegionContainingAddress(address))) {
+    auto range = mem_region_sp->GetRange();
+    address += range.GetRangeBase() + range.GetByteSize();
+    region_list.push_back(*mem_region_sp.get());
+  }
+
+  return error;
+}
+
+void ScriptedProcess::Clear() { Process::m_thread_list.Clear(); }
+
+bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
+                                         ThreadList &new_thread_list) {
+  return new_thread_list.GetSize(false) > 0;
+}
+
+bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) {
+  info.Clear();
+  info.SetProcessID(GetID());
+  info.SetArchitecture(GetArchitecture());
+  lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
+  if (module_sp) {
+    const bool add_exe_file_as_first_arg = false;
+    info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
+                           add_exe_file_as_first_arg);
+  }
+  return true;
+}
+
+ScriptedProcessInterface &ScriptedProcess::GetInterface() const {
+  return m_interpreter->GetScriptedProcessInterface();
+}

lldb/source/Target/Target.cpp

 //===-- Target.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Target.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
 #include "lldb/Breakpoint/BreakpointResolverName.h"
Status Target::Launch(ProcessLaunchInfo &launch_info, Stream *stream) {
   }
 
   if (!launch_info.GetArchitecture().IsValid())
     launch_info.GetArchitecture() = GetArchitecture();
 
   // If we're not already connected to the process, and if we have a platform
   // that can launch a process for debugging, go ahead and do that here.
   if (state != eStateConnected && platform_sp &&
-      platform_sp->CanDebugProcess()) {
+      platform_sp->CanDebugProcess() && !launch_info.IsScriptedProcess()) {
     LLDB_LOGF(log, "Target::%s asking the platform to debug the process",
               __FUNCTION__);
 
     // If there was a previous process, delete it before we make the new one.
     // One subtle point, we delete the process before we release the reference
     // to m_process_sp.  That way even if we are the last owner, the process
     // will get Finalized before it gets destroyed.
     DeleteCurrentProcess();

lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py

 """
 Test python scripted process in lldb
 """
 
 import os
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test import lldbtest
 
 
-class PlatformProcessCrashInfoTestCase(TestBase):
+class ScriptedProcesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
         self.source = "main.c"
 
     def tearDown(self):
def test_python_plugin_package(self):
                     substrs=["ScriptedProcess"])
 
         self.expect('script from lldb.plugins.scripted_process import ScriptedProcess',
                     substrs=["ImportError"], matching=False)
 
         self.expect('script dir(ScriptedProcess)',
                     substrs=["launch"])
 
+    def test_launch_scripted_process_sbapi(self):
+        """Test that we can launch an lldb scripted process using the SBAPI,
+        check its process ID and read string from memory."""
+        self.build()
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+
+        scripted_process_example_relpath = ['..','..','..','..','examples','python','scripted_process','my_scripted_process.py']
+        os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
+        self.runCmd("command script import " + os.path.join(self.getSourceDir(),
+                                                            *scripted_process_example_relpath))
+
+        launch_info = lldb.SBLaunchInfo(None)
+        launch_info.SetProcessPluginName("ScriptedProcess")
+        launch_info.SetScriptedProcessClassName("my_scripted_process.MyScriptedProcess")
+
+        error = lldb.SBError()
+        process = target.Launch(launch_info, error)
+        self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
+        self.assertEqual(process.GetProcessID(), 42)
+
+        hello_world = "Hello, world!"
+        memory_read = process.ReadCStringFromMemory(0x50000000000,
+                                                    len(hello_world) + 1, # NULL byte
+                                                    error)
+
+        self.assertTrue(error.Success(), "Failed to read memory from scripted process.")
+        self.assertEqual(hello_world, memory_read)
+
+    def test_launch_scripted_process_cli(self):
+        """Test that we can launch an lldb scripted process from the command
+        line, check its process ID and read string from memory."""
+        self.build()
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+
+        scripted_process_example_relpath = ['..','..','..','..','examples','python','scripted_process','my_scripted_process.py']
+        self.runCmd("command script import " + os.path.join(self.getSourceDir(),
+                                                            *scripted_process_example_relpath))
+
+        process = target.GetProcess()
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetProcessID(), 42)
+
+        error = lldb.SBError()
+        hello_world = "Hello, world!"
+        memory_read = process.ReadCStringFromMemory(0x50000000000,
+                                                    len(hello_world) + 1, # NULL byte
+                                                    error)
+
+        self.assertTrue(error.Success(), "Failed to read memory from scripted process.")
+        self.assertEqual(hello_world, memory_read)