Change LaunchThread interface to return an expected.

[JDevlieghere]

Summary

Change the interface to return an expected, instead of taking a Status pointer.

[jingham]

lldb/source/API/SBHostOS.cpp

110–117 ↗

(On Diff #207899)

If somebody passed you an error_ptr here, you have to fill it in correctly. The way you've written this, error_ptr won't say Failure() in the case where making the thread fails.

114 ↗

(On Diff #207899)

Does this really end up returning LLDB_INVALID_HOST_THREAD?

[JDevlieghere]

Address Jim's feedback.

[labath]

Looks fine to me.

Instead of just throwing the error away when the thread creation fails (and there's no way to pass it up the stack), I'd consider logging the error instead.

lldb/source/Target/Process.cpp

3601 ↗

(On Diff #207929)

I would assume this should always be true for a successfully created thread. Delete the check or change to an assert maybe?

[mgorny]

This seems to have broken the build for us:
http://lab.llvm.org:8011/builders/netbsd-amd64/builds/20658

FAILED: tools/lldb/source/Host/CMakeFiles/lldbHost.dir/common/Host.cpp.o 
/usr/bin/g++  -DGTEST_HAS_RTTI=0 -DHAVE_ROUND -DLIBXML2_DEFINED -DLLDB_CONFIGURATION_RELEASE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/lldb/source/Host -I/home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/Host -Itools/lldb/include -I/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include -Iinclude -I/home/motus/netbsd8/netbsd8/llvm/include -I/usr/pkg/include/python2.7 -I/home/motus/netbsd8/netbsd8/llvm/tools/clang/include -Itools/lldb/../clang/include -I/usr/pkg/include/libxml2 -I/home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/. -fPIC -fvisibility-inlines-hidden -Werror=date-time -std=c++11 -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -O3 -DNDEBUG    -fno-exceptions -fno-rtti -MD -MT tools/lldb/source/Host/CMakeFiles/lldbHost.dir/common/Host.cpp.o -MF tools/lldb/source/Host/CMakeFiles/lldbHost.dir/common/Host.cpp.o.d -o tools/lldb/source/Host/CMakeFiles/lldbHost.dir/common/Host.cpp.o -c /home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/Host/common/Host.cpp
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/Host/common/Host.cpp: In static member function 'static lldb_private::HostThread lldb_private::Host::StartMonitoringChildProcess(const MonitorChildProcessCallback&, lldb::__pid_t, bool)':
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/Host/common/Host.cpp:115:72: error: no matching function for call to 'lldb_private::ThreadLauncher::LaunchThread(char [256], void* (&)(void*), MonitorInfo*&, std::nullptr_t)'
       thread_name, MonitorChildProcessThreadFunction, info_ptr, nullptr);
                                                                        ^
In file included from /home/motus/netbsd8/netbsd8/llvm/tools/lldb/source/Host/common/Host.cpp:57:0:
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include/lldb/Host/ThreadLauncher.h:23:3: note: candidate: static llvm::Expected<lldb_private::HostThread> lldb_private::ThreadLauncher::LaunchThread(llvm::StringRef, lldb::thread_func_t, lldb::thread_arg_t, size_t)
   LaunchThread(llvm::StringRef name, lldb::thread_func_t thread_function,
   ^
/home/motus/netbsd8/netbsd8/llvm/tools/lldb/include/lldb/Host/ThreadLauncher.h:23:3: note:   no known conversion for argument 4 from 'std::nullptr_t' to 'size_t {aka long unsigned int}'
At global scope:
cc1plus: warning: unrecognized command line option '-Wno-vla-extension'
cc1plus: warning: unrecognized command line option '-Wno-deprecated-register'

[labath]

lldb/trunk/source/Core/Debugger.cpp

1652

I'm sorry to be such a nag, but this is incorrect for two reasons:

• this won't clear the error object if logging is disabled. There's an LLDB_LOG_ERROR macro to handle that correctly.
• llvm::formatv does not accept {} as a format argument. You need to use {0} instead.

lldb/trunk/include/lldb/Host/ThreadLauncher.h

-//===-- ThreadLauncher.h -----------------------------------------*- C++
-//-*-===//
+//===-- ThreadLauncher.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_Host_ThreadLauncher_h_
 #define lldb_Host_ThreadLauncher_h_
 
 #include "lldb/Host/HostThread.h"
-#include "lldb/Utility/Status.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
 
 namespace lldb_private {
 
 class ThreadLauncher {
 public:
-  static HostThread
+  static llvm::Expected<HostThread>
   LaunchThread(llvm::StringRef name, lldb::thread_func_t thread_function,
-               lldb::thread_arg_t thread_arg, Status *error_ptr,
+               lldb::thread_arg_t thread_arg,
                size_t min_stack_byte_size = 0); // Minimum stack size in bytes,
                                                 // set stack size to zero for
                                                 // default platform thread stack
                                                 // size
 
   struct HostThreadCreateInfo {
     std::string thread_name;
     lldb::thread_func_t thread_fptr;

lldb/trunk/source/API/SBHostOS.cpp

 }
 
 lldb::thread_t SBHostOS::ThreadCreate(const char *name,
                                       lldb::thread_func_t thread_function,
                                       void *thread_arg, SBError *error_ptr) {
   LLDB_RECORD_DUMMY(lldb::thread_t, SBHostOS, ThreadCreate,
                     (lldb::thread_func_t, void *, SBError *), name,
                     thread_function, thread_arg, error_ptr);
-  HostThread thread(
-      ThreadLauncher::LaunchThread(name, thread_function, thread_arg,
-                                   error_ptr ? error_ptr->get() : nullptr));
-  return thread.Release();
+  llvm::Expected<HostThread> thread =
+      ThreadLauncher::LaunchThread(name, thread_function, thread_arg);
+  if (!thread) {
+    if (error_ptr)
+      error_ptr->SetError(Status(thread.takeError()));
+    else
+      llvm::consumeError(thread.takeError());
+    return LLDB_INVALID_HOST_THREAD;
+  }
+
+  return thread->Release();
 }
 
 void SBHostOS::ThreadCreated(const char *name) {
   LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
                             name);
 }
 
 bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {

lldb/trunk/source/Core/Communication.cpp

lldb_private::LogIfAnyCategoriesSet(
       LIBLLDB_LOG_COMMUNICATION, "%p Communication::StartReadThread ()", this);
 
   char thread_name[1024];
   snprintf(thread_name, sizeof(thread_name), "<lldb.comm.%s>",
            GetBroadcasterName().AsCString());
 
   m_read_thread_enabled = true;
   m_read_thread_did_exit = false;
-  m_read_thread = ThreadLauncher::LaunchThread(
-      thread_name, Communication::ReadThread, this, error_ptr);
+  auto maybe_thread = ThreadLauncher::LaunchThread(
+      thread_name, Communication::ReadThread, this);
+  if (maybe_thread) {
+    m_read_thread = *maybe_thread;
+  } else {
+    if (error_ptr)
+      *error_ptr = Status(maybe_thread.takeError());
+    else {
+      LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+               "failed to launch host thread: {}",
+               llvm::toString(maybe_thread.takeError()));
+    }
+  }
+
   if (!m_read_thread.IsJoinable())
     m_read_thread_enabled = false;
+
   return m_read_thread_enabled;
 }
 
 bool Communication::StopReadThread(Status *error_ptr) {
   if (!m_read_thread.IsJoinable())
     return true;
 
   lldb_private::LogIfAnyCategoriesSet(

lldb/trunk/source/Core/Debugger.cpp

if (!m_event_handler_thread.IsJoinable()) {
     listener_sp->StartListeningForEvents(&m_sync_broadcaster,
                                          eBroadcastBitEventThreadIsListening);
 
     auto thread_name =
         full_name.GetLength() < llvm::get_max_thread_name_length() ?
         full_name.AsCString() : "dbg.evt-handler";
 
     // Use larger 8MB stack for this thread
-    m_event_handler_thread = ThreadLauncher::LaunchThread(thread_name,
-        EventHandlerThread, this, nullptr, g_debugger_event_thread_stack_bytes);
+    llvm::Expected<HostThread> event_handler_thread =
+        ThreadLauncher::LaunchThread(thread_name, EventHandlerThread, this,
+                                     g_debugger_event_thread_stack_bytes);
+
+    if (event_handler_thread) {
+      m_event_handler_thread = *event_handler_thread;
+    } else {
+      LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+               "failed to launch host thread: {}",
+               llvm::toString(event_handler_thread.takeError()));
+    }
 
     // Make sure DefaultEventHandler() is running and listening to events
     // before we return from this function. We are only listening for events of
     // type eBroadcastBitEventThreadIsListening so we don't need to check the
     // event, we just need to wait an infinite amount of time for it (nullptr
     // timeout as the first parameter)
     lldb::EventSP event_sp;
     listener_sp->GetEvent(event_sp, llvm::None);
lldb::thread_result_t Debugger::IOHandlerThread(lldb::thread_arg_t arg) {
   debugger->ExecuteIOHandlers();
   debugger->StopEventHandlerThread();
   return {};
 }
 
 bool Debugger::HasIOHandlerThread() { return m_io_handler_thread.IsJoinable(); }
 
 bool Debugger::StartIOHandlerThread() {
-  if (!m_io_handler_thread.IsJoinable())
-    m_io_handler_thread = ThreadLauncher::LaunchThread(
-        "lldb.debugger.io-handler", IOHandlerThread, this, nullptr,
+  if (!m_io_handler_thread.IsJoinable()) {
+    llvm::Expected<HostThread> io_handler_thread = ThreadLauncher::LaunchThread(
+        "lldb.debugger.io-handler", IOHandlerThread, this,
         8 * 1024 * 1024); // Use larger 8MB stack for this thread
+    if (io_handler_thread) {
+      m_io_handler_thread = *io_handler_thread;
+    } else {
+      LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+               "failed to launch host thread: {}",
+               llvm::toString(io_handler_thread.takeError()));
+    }
+  }
   return m_io_handler_thread.IsJoinable();
 }
 
 void Debugger::StopIOHandlerThread() {
   if (m_io_handler_thread.IsJoinable()) {
     if (m_input_file_sp)
       m_input_file_sp->GetFile().Close();
     m_io_handler_thread.Join(nullptr);

lldb/trunk/source/Host/common/TaskPool.cpp

 //===--------------------- TaskPool.cpp -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/TaskPool.h"
 #include "lldb/Host/ThreadLauncher.h"
+#include "lldb/Utility/Log.h"
 
 #include <cstdint>
 #include <queue>
 #include <thread>
 
 namespace lldb_private {
 
 namespace {
void TaskPoolImpl::AddTask(std::function<void()> &&task_fn) {
 
   std::unique_lock<std::mutex> lock(m_tasks_mutex);
   m_tasks.emplace(std::move(task_fn));
   if (m_thread_count < GetHardwareConcurrencyHint()) {
     m_thread_count++;
     // Note that this detach call needs to happen with the m_tasks_mutex held.
     // This prevents the thread from exiting prematurely and triggering a linux
     // libc bug (https://sourceware.org/bugzilla/show_bug.cgi?id=19951).
-    lldb_private::ThreadLauncher::LaunchThread("task-pool.worker", WorkerPtr,
-                                               this, nullptr, min_stack_size)
-        .Release();
+    llvm::Expected<HostThread> host_thread =
+        lldb_private::ThreadLauncher::LaunchThread(
+            "task-pool.worker", WorkerPtr, this, min_stack_size);
+    if (host_thread) {
+      host_thread->Release();
+    } else {
+      LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+               "failed to launch host thread: {}",
+               llvm::toString(host_thread.takeError()));
+    }
   }
 }
 
 lldb::thread_result_t TaskPoolImpl::WorkerPtr(void *pool) {
   Worker((TaskPoolImpl *)pool);
   return {};
 }
 

lldb/trunk/source/Host/common/ThreadLauncher.cpp

 
 #if defined(_WIN32)
 #include "lldb/Host/windows/windows.h"
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
-HostThread ThreadLauncher::LaunchThread(llvm::StringRef name,
-                                        lldb::thread_func_t thread_function,
-                                        lldb::thread_arg_t thread_arg,
-                                        Status *error_ptr,
-                                        size_t min_stack_byte_size) {
-  Status error;
-  if (error_ptr)
-    error_ptr->Clear();
-
+llvm::Expected<HostThread> ThreadLauncher::LaunchThread(
+    llvm::StringRef name, lldb::thread_func_t thread_function,
+    lldb::thread_arg_t thread_arg, size_t min_stack_byte_size) {
   // Host::ThreadCreateTrampoline will delete this pointer for us.
   HostThreadCreateInfo *info_ptr =
       new HostThreadCreateInfo(name.data(), thread_function, thread_arg);
   lldb::thread_t thread;
 #ifdef _WIN32
   thread = (lldb::thread_t)::_beginthreadex(
       0, (unsigned)min_stack_byte_size,
       HostNativeThread::ThreadCreateTrampoline, info_ptr, 0, NULL);
   if (thread == (lldb::thread_t)(-1L))
-    error.SetError(::GetLastError(), eErrorTypeWin32);
+    return llvm::errorCodeToError(::GetLastError());
 #else
 
 // ASAN instrumentation adds a lot of bookkeeping overhead on stack frames.
 #if __has_feature(address_sanitizer)
   const size_t eight_megabytes = 8 * 1024 * 1024;
   if (min_stack_byte_size < eight_megabytes) {
     min_stack_byte_size += eight_megabytes;
   }
#endif
   }
   int err =
       ::pthread_create(&thread, thread_attr_ptr,
                        HostNativeThread::ThreadCreateTrampoline, info_ptr);
 
   if (destroy_attr)
     ::pthread_attr_destroy(&thread_attr);
 
-  error.SetError(err, eErrorTypePOSIX);
+  if (err)
+    return llvm::errorCodeToError(
+        std::error_code(err, std::generic_category()));
 #endif
-  if (error_ptr)
-    *error_ptr = error;
-  if (!error.Success())
-    thread = LLDB_INVALID_HOST_THREAD;
 
   return HostThread(thread);
 }

lldb/trunk/source/Host/macosx/objcxx/Host.mm

::snprintf(connect_url, sizeof(connect_url), "unix-accept://%s",
              unix_socket_name);
 
   // Spawn a new thread to accept incoming connection on the connect_url
   // so we can grab the pid from the inferior. We have to do this because we
   // are sending an AppleScript that will launch a process in Terminal.app,
   // in a shell and the shell will fork/exec a couple of times before we get
   // to the process that we wanted to launch. So when our process actually
   // gets launched, we will handshake with it and get the process ID for it.
-  HostThread accept_thread = ThreadLauncher::LaunchThread(
-      unix_socket_name, AcceptPIDFromInferior, connect_url, &lldb_error);
+  llvm::Expected<HostThread> accept_thread = ThreadLauncher::LaunchThread(
+      unix_socket_name, AcceptPIDFromInferior, connect_url);
+
+  if (!accept_thread)
+    return Status(accept_thread.takeError());
 
   [applescript executeAndReturnError:nil];
 
   thread_result_t accept_thread_result = NULL;
-  lldb_error = accept_thread.Join(&accept_thread_result);
+  lldb_error = accept_thread->Join(&accept_thread_result);
   if (lldb_error.Success() && accept_thread_result) {
     pid = (intptr_t)accept_thread_result;
 
     // Wait for process to be stopped at the entry point by watching
     // for the process status to be set to SSTOP which indicates it it
     // SIGSTOP'ed at the entry point
     WaitForProcessToSIGSTOP(pid, 5);
   }

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

 #include "lldb/Interpreter/OptionGroupString.h"
 #include "lldb/Interpreter/OptionGroupUInt64.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Utility/UUID.h"
 
 #include "llvm/Support/Threading.h"
 
 #define USEC_PER_SEC 1000000
 
bool ProcessKDP::StartAsyncThread() {
   Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
 
   if (log)
     log->Printf("ProcessKDP::StartAsyncThread ()");
 
   if (m_async_thread.IsJoinable())
     return true;
 
-  m_async_thread = ThreadLauncher::LaunchThread(
-      "<lldb.process.kdp-remote.async>", ProcessKDP::AsyncThread, this, NULL);
+  llvm::Expected<HostThread> async_thread = ThreadLauncher::LaunchThread(
+      "<lldb.process.kdp-remote.async>", ProcessKDP::AsyncThread, this);
+  if (!async_thread) {
+    LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+             "failed to launch host thread: {}",
+             llvm::toString(async_thread.takeError()));
+    return false;
+  }
+  m_async_thread = *async_thread;
   return m_async_thread.IsJoinable();
 }
 
 void ProcessKDP::StopAsyncThread() {
   Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
 
   if (log)
     log->Printf("ProcessKDP::StopAsyncThread ()");

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

if (!m_bytes.empty()) {
     }
   }
   packet.Clear();
   return GDBRemoteCommunication::PacketType::Invalid;
 }
 
 Status GDBRemoteCommunication::StartListenThread(const char *hostname,
                                                  uint16_t port) {
-  Status error;
-  if (m_listen_thread.IsJoinable()) {
-    error.SetErrorString("listen thread already running");
-  } else {
-    char listen_url[512];
-    if (hostname && hostname[0])
-      snprintf(listen_url, sizeof(listen_url), "listen://%s:%i", hostname,
-               port);
-    else
-      snprintf(listen_url, sizeof(listen_url), "listen://%i", port);
-    m_listen_url = listen_url;
-    SetConnection(new ConnectionFileDescriptor());
-    m_listen_thread = ThreadLauncher::LaunchThread(
-        listen_url, GDBRemoteCommunication::ListenThread, this, &error);
-  }
-  return error;
+  if (m_listen_thread.IsJoinable())
+    return Status("listen thread already running");
+
+    snprintf(listen_url, sizeof(listen_url), "listen://%s:%i", hostname, port);
+  llvm::Expected<HostThread> listen_thread = ThreadLauncher::LaunchThread(
+      listen_url, GDBRemoteCommunication::ListenThread, this);
+  if (!listen_thread)
+    return Status(listen_thread.takeError());
+  m_listen_thread = *listen_thread;
+
+  return Status();
 }
 
 bool GDBRemoteCommunication::JoinListenThread() {
   if (m_listen_thread.IsJoinable())
     m_listen_thread.Join(nullptr);
   return true;
 }
 

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

GDBRemoteCommunicationReplayServer::LoadReplayHistory(const FileSpec &path) {
   return Error::success();
 }
 
 bool GDBRemoteCommunicationReplayServer::StartAsyncThread() {
   std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
   if (!m_async_thread.IsJoinable()) {
     // Create a thread that watches our internal state and controls which
     // events make it to clients (into the DCProcess event queue).
-    m_async_thread = ThreadLauncher::LaunchThread(
+    llvm::Expected<HostThread> async_thread = ThreadLauncher::LaunchThread(
         "<lldb.gdb-replay.async>",
-        GDBRemoteCommunicationReplayServer::AsyncThread, this, nullptr);
+        GDBRemoteCommunicationReplayServer::AsyncThread, this);
+    if (!async_thread) {
+      LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+               "failed to launch host thread: {}",
+               llvm::toString(async_thread.takeError()));
+      return false;
+    }
+    m_async_thread = *async_thread;
   }
 
   // Wait for handshake.
   m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncContinue);
 
   return m_async_thread.IsJoinable();
 }
 

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

bool ProcessGDBRemote::StartAsyncThread() {
   if (log)
     log->Printf("ProcessGDBRemote::%s ()", __FUNCTION__);
 
   std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
   if (!m_async_thread.IsJoinable()) {
     // Create a thread that watches our internal state and controls which
     // events make it to clients (into the DCProcess event queue).
 
-    m_async_thread = ThreadLauncher::LaunchThread(
-        "<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this,
-        nullptr);
+    llvm::Expected<HostThread> async_thread = ThreadLauncher::LaunchThread(
+        "<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this);
+    if (!async_thread) {
+      LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+               "failed to launch host thread: {}",
+               llvm::toString(async_thread.takeError()));
+      return false;
+    }
+    m_async_thread = *async_thread;
   } else if (log)
     log->Printf("ProcessGDBRemote::%s () - Called when Async thread was "
                 "already running.",
                 __FUNCTION__);
 
   return m_async_thread.IsJoinable();
 }
 

lldb/trunk/source/Target/Process.cpp

if (max_len > 0 && max_len <= 30) {
     else
       snprintf(thread_name, sizeof(thread_name),
                "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
   }
 
   // Create the private state thread, and start it running.
   PrivateStateThreadArgs *args_ptr =
       new PrivateStateThreadArgs(this, is_secondary_thread);
-  m_private_state_thread =
+  llvm::Expected<HostThread> private_state_thread =
       ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread,
-                                   (void *)args_ptr, nullptr, 8 * 1024 * 1024);
-  if (m_private_state_thread.IsJoinable()) {
-    ResumePrivateStateThread();
-    return true;
-  } else
-    return false;
+                                   (void *)args_ptr, 8 * 1024 * 1024);
+  if (!private_state_thread) {
+    LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
+             "failed to launch host thread: {}",
+             llvm::toString(private_state_thread.takeError()));
+    return false;
+  }
+
+  assert(private_state_thread->IsJoinable());
+  m_private_state_thread = *private_state_thread;
 }
 
 void Process::PausePrivateStateThread() {
   ControlPrivateStateThread(eBroadcastInternalStateControlPause);
 }
 
 void Process::ResumePrivateStateThread() {
   ControlPrivateStateThread(eBroadcastInternalStateControlResume);