[lldb/Plugins] Add ScriptedProcess Process Plugin

[mib]

Summary

This patch introduces Scripted Processes to lldb.

The goal, here, is to be able to attach in the debugger to fake processes
that are backed by script files (in Python, Lua, Swift, etc ...) and
inspect them statically.

Scripted Processes can be used in cooperative multithreading environments
like the XNU Kernel or other real-time operating systems, but it can
also help us improve the debugger testing infrastructure by writting
synthetic tests that simulates hard-to-reproduce process/thread states.

Although ScriptedProcess is not feature-complete at the moment, it has
basic execution capabilities and will improve in the following patches.

rdar://65508855

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

[mib]

Remove dead code.

[mib]

Fix typo in copyright header.

[mib]

• Set Process PID in ScriptedProcess::DidLaunch
• Updated ScriptedProcess::DoReadMemory implementation.
• Fix typos.

[JDevlieghere]

lldb/source/Plugins/Process/CMakeLists.txt

15

nit: I'd make this lowercase for consistency with the other plugins (and keep Utility the exception as it's not a plugin).

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

1 ↗

(On Diff #320287)

This is shorter than the closing ASCII art. Missing -s?

41 ↗

(On Diff #320287)

Maybe qualify this as ScriptedProcess::LaunchInfo to make it clear you're not just making a copy but actually converting it.

This also answers my earlier question about who holds onto the LaunchInfo: nobody once this function returns. I would pass he process launch info to the ScriptedProcess and have the constructor instantiate the ScriptedProcess::LaunchInfo as its ivar.

43 ↗

(On Diff #320287)

This will always return a valid ScriptedProcess which (IIRC) is the mechanism used by the plugin framework to communicate that the current plugin is the right one and able to handle the process. Shouldn't it only return a ScriptedProcess when the user has requested one? Does this work when you launch without -S?

159 ↗

(On Diff #320287)

size_t

167 ↗

(On Diff #320287)

size_t

174 ↗

(On Diff #320287)

Seems like this is still outstanding ;-)

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

1 ↗

(On Diff #320287)

Header needs the C++ thingy

33 ↗

(On Diff #320287)

I think someone else already pointed that out elsewhere but this should probably be a std::string.

102 ↗

(On Diff #320287)

This seems suspicious. Who manages the lifetime of the launch info and how do we guarantee it matches the lifetime of the process?

[mib]

• Address @JDevlieghere comments:
• Add test

[mib]

Update ScriptedProcess::GetMemoryRegions to load regions lazily.

[JDevlieghere]

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

118

m_interpreter->GetScriptedProcessInterface() seems to repeated a lot. Maybe it's worth having a private helper method that wraps it?

ScriptedProcess::GetInferface() { 
  return m_interpreter->GetScriptedProcessInterface();
}

154

Remembering to set the size seems error prone. I would use a ScopeExit (and clear it at the end on success).

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

46

I think this should work on all platforms?

53

can you make this more portable with os.path.join or os.dirname?

54

Why is this needed?

[mib]

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

54

I use this to load the script without running the process launch -C .... command.

You can see the rest of the logic in D95712, in the MyScriptedProcess example.

[mib]

Address @JDevlieghere feedbacks:

• Make test more portable
• Add helper function to get the ScriptedProcessInterface

[mib]

Fix test typo.

[JDevlieghere]

This LGTM

[mib]

Test ScriptedProcess::ReadMemory
Test launching the scripted process from both the command line and from the SBAPI.

[mib]

Add support for loading a corefile.
Fix incomplete scripted process instantiation.

[davezarzycki]

An auto-bisecting cron job has identified this change as a regression on Fedora 33 (x86-64). Can we get a quick fix or revert this? Here is the build output:

https://znu.io/dd391e1ef762d79f86112dc2480a89c9be066ce1-bisect.txt

[davezarzycki]

I've reverted this. If you need help debugging this, please let me know. Also, as a reminder, please see the attached build log from earlier in the conversation. Thanks!

[mib]

In D95713#2647241, @davezarzycki wrote:

I've reverted this. If you need help debugging this, please let me know. Also, as a reminder, please see the attached build log from earlier in the conversation. Thanks!

@davezarzycki Sorry for the inconvenience, I made sure it passed on the macOS and Debian bot (http://lab.llvm.org:8011/#/builders/68/builds/9225) before signing off but it seems that the patch caused some issues on other platforms.

Thanks for letting me know about that, I'll take a look at the build log and try to reproduce the issue.

[teemperor]

The tests are failing because Dave's bot is running without enabled Python. The same is true for the Windows bot. Putting the plugin behind #ifdef LLDB_ENABLE_PYTHON should fix this.

FWIW, even with enabled Python this seems to have some minor problems with command parsing:

FAIL: test_double_type_dwo (TestDoubleTypes.DoubleTypesTestCase)
   Test that double-type variables are displayed correctly.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 1846, in test_method
    return attrvalue(self)
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/types/TestDoubleTypes.py", line 21, in test_double_type
    self.build_and_run('double.cpp', set(['double']))
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/types/AbstractBase.py", line 67, in build_and_run
    self.build_and_run_with_source_atoms_expr(
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/types/AbstractBase.py", line 88, in build_and_run_with_source_atoms_expr
    self.generic_type_tester(
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/types/AbstractBase.py", line 145, in generic_type_tester
    self.process_launch_o()
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/types/AbstractBase.py", line 111, in process_launch_o
    self.runCmd(
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 2176, in runCmd
    self.assertTrue(self.res.Succeeded(),
AssertionError: False is not True : Command 'process launch -o "/home/teemperor/work/ci/build/lldb-test-build.noindex/types/TestDoubleTypes.test_double_type_dwo/test_double_type_dwo-golden-output.txt"
Error output:
error: invalid combination of options for the given command
' did not return successfully

(This is with enabled Python)

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

62

You probably want to use default initializers in the header for this stuff.

[davezarzycki]

In D95713#2647548, @teemperor wrote:

The tests are failing because Dave's bot is running without enabled Python. The same is true for the Windows bot. Putting the plugin behind #ifdef LLDB_ENABLE_PYTHON should fix this.

My cron job is not intentionally disabling python support. That just happened to be the fallout from the normal feature detection dance before the build starts:

• Could NOT find SWIG (missing: SWIG_EXECUTABLE SWIG_DIR) (Required is at least version "3.0")
• SWIG 3 or later is required for Python support in LLDB but could not be found
• Could NOT find PythonAndSwig (missing: Python3_LIBRARIES Python3_INCLUDE_DIRS SWIG_EXECUTABLE)
• Enable Python scripting support in LLDB: FALSE

[teemperor]

In D95713#2647722, @davezarzycki wrote:

In D95713#2647548, @teemperor wrote:

The tests are failing because Dave's bot is running without enabled Python. The same is true for the Windows bot. Putting the plugin behind #ifdef LLDB_ENABLE_PYTHON should fix this.

My cron job is not intentionally disabling python support. That just happened to be the fallout from the normal feature detection dance before the build starts:

• Could NOT find SWIG (missing: SWIG_EXECUTABLE SWIG_DIR) (Required is at least version "3.0")
• SWIG 3 or later is required for Python support in LLDB but could not be found
• Could NOT find PythonAndSwig (missing: Python3_LIBRARIES Python3_INCLUDE_DIRS SWIG_EXECUTABLE)
• Enable Python scripting support in LLDB: FALSE

To clarify what I meant: The patch is wrong and the tests should not fail when SWIG>3 can't be found (which disables Python support). I was just pointing out what's the bug here. That your setup doesn't have SWIG>3 is perfectly fine (I'm in fact setting up another bot that is disabling SWIG/Python right now because this doesn't seem really covered beside the Windows bot and your bisect one)

[mib]

Enable ScriptedProcess process plugin only when LLDB_ENABLE_PYTHON is true.

This should fix the test failures that happen when python support is disabled.

[mib]

With the help of @teemperor, I was able to test that my latest changes work on Linux with and without enabling python for lldb. I'll re-land the patch and monitor the bots to make sure there is no other issues.

[stella.stamenova]

lldb/bindings/python/CMakeLists.txt

114

How is this different than the package on line 107?

[stella.stamenova]

In D95713#2647548, @teemperor wrote:

The tests are failing because Dave's bot is running without enabled Python. The same is true for the Windows bot. Putting the plugin behind #ifdef LLDB_ENABLE_PYTHON should fix this.

The windows bot actually has LLDB_ENABLE_PYTHON set to true, so the failure has a different root cause. The error it is reporting is access violation. I'll get @mib some logs to investigate when I get a chance.

[mib]

lldb/bindings/python/CMakeLists.txt

114

This might have been copied twice ... getting rid of it.

[mib]

Addressing @stella.stamenova feedback.

[stella.stamenova]

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

70

This is where the AV happens on Windows. It looks like GetInterface returns null

[mib]

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

70

Thanks @stella.stamenova for taking a closer look at this. I don't know why would the test call this code and crash, but I'll continue investigating it.

[davezarzycki]

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

70

I've seen this crash on Fedora (x86-64) too so I don't think it's Windows specific.

lldb/bindings/python/CMakeLists.txt

function(finish_swig_python swig_target lldb_python_bindings_dir lldb_python_target_dir)
 
   create_python_package(
     ${swig_target}
     ${lldb_python_target_dir}
     "plugins"
     FILES
     "${LLDB_SOURCE_DIR}/examples/python/scripted_process/scripted_process.py")
 
+  create_python_package(
+    ${swig_target}
+    ${lldb_python_target_dir}
+    "plugins"
+    FILES
+    "${LLDB_SOURCE_DIR}/examples/python/scripted_process/scripted_process.py")
+
   if(APPLE)
     create_python_package(
       ${swig_target}
       ${lldb_python_target_dir} "macosx"
       FILES "${LLDB_SOURCE_DIR}/examples/python/crashlog.py"
             "${LLDB_SOURCE_DIR}/examples/darwin/heap_find/heap.py")
 
     create_python_package(

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/ConstString.h"
+#include "lldb/Utility/Status.h"
+
+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; }
+
+  Status DoLoadCore() 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;
+
+private:
+  ScriptedProcessInterface &GetInterface() const;
+
+  const LaunchInfo m_launch_info;
+  lldb_private::ScriptInterpreter *m_interpreter = nullptr;
+  lldb_private::StructuredData::ObjectSP m_script_object_sp = nullptr;
+};
+
+} // 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/Interpreter/OptionArgParser.h"
+#include "lldb/Interpreter/OptionGroupBoolean.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+
+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) {
+  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;
+}
+
+ScriptedProcess::~ScriptedProcess() {
+  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; }
+
+Status ScriptedProcess::DoLoadCore() {
+  ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo();
+
+  return DoLaunch(nullptr, launch_info);
+}
+
+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.");
+
+  Status status = GetInterface().Launch();
+
+  if (status.Success()) {
+    SetPrivateState(eStateRunning);
+    SetPrivateState(eStateStopped);
+  }
+
+  return status;
+};
+
+void ScriptedProcess::DidLaunch() {
+  if (m_interpreter)
+    m_pid = GetInterface().GetProcessID();
+}
+
+Status ScriptedProcess::DoResume() {
+  if (!m_interpreter)
+    return Status("No interpreter.");
+
+  if (!m_script_object_sp)
+    return Status("No python object.");
+
+  Status status = GetInterface().Resume();
+
+  if (status.Success()) {
+    SetPrivateState(eStateRunning);
+    SetPrivateState(eStateStopped);
+  }
+
+  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

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)