LLDB  mainline
Process.cpp
Go to the documentation of this file.
1 //===-- Process.cpp -------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include <atomic>
10 #include <memory>
11 #include <mutex>
12 
13 #include "llvm/ADT/ScopeExit.h"
14 #include "llvm/Support/ScopedPrinter.h"
15 #include "llvm/Support/Threading.h"
16 
19 #include "lldb/Core/Debugger.h"
20 #include "lldb/Core/Module.h"
21 #include "lldb/Core/ModuleSpec.h"
23 #include "lldb/Core/StreamFile.h"
29 #include "lldb/Host/FileSystem.h"
30 #include "lldb/Host/Host.h"
31 #include "lldb/Host/HostInfo.h"
32 #include "lldb/Host/OptionParser.h"
33 #include "lldb/Host/Pipe.h"
34 #include "lldb/Host/Terminal.h"
39 #include "lldb/Symbol/Function.h"
40 #include "lldb/Symbol/Symbol.h"
41 #include "lldb/Target/ABI.h"
45 #include "lldb/Target/JITLoader.h"
47 #include "lldb/Target/Language.h"
52 #include "lldb/Target/Platform.h"
53 #include "lldb/Target/Process.h"
55 #include "lldb/Target/StopInfo.h"
58 #include "lldb/Target/Target.h"
59 #include "lldb/Target/TargetList.h"
60 #include "lldb/Target/Thread.h"
61 #include "lldb/Target/ThreadPlan.h"
66 #include "lldb/Utility/Event.h"
67 #include "lldb/Utility/LLDBLog.h"
68 #include "lldb/Utility/Log.h"
72 #include "lldb/Utility/State.h"
73 #include "lldb/Utility/Timer.h"
74 
75 using namespace lldb;
76 using namespace lldb_private;
77 using namespace std::chrono;
78 
79 // Comment out line below to disable memory caching, overriding the process
80 // setting target.process.disable-memory-cache
81 #define ENABLE_MEMORY_CACHING
82 
83 #ifdef ENABLE_MEMORY_CACHING
84 #define DISABLE_MEM_CACHE_DEFAULT false
85 #else
86 #define DISABLE_MEM_CACHE_DEFAULT true
87 #endif
88 
90  : public Cloneable<ProcessOptionValueProperties, OptionValueProperties> {
91 public:
93 
95  bool will_modify,
96  uint32_t idx) const override {
97  // When getting the value for a key from the process options, we will
98  // always try and grab the setting from the current process if there is
99  // one. Else we just use the one from this instance.
100  if (exe_ctx) {
101  Process *process = exe_ctx->GetProcessPtr();
102  if (process) {
103  ProcessOptionValueProperties *instance_properties =
104  static_cast<ProcessOptionValueProperties *>(
105  process->GetValueProperties().get());
106  if (this != instance_properties)
107  return instance_properties->ProtectedGetPropertyAtIndex(idx);
108  }
109  }
110  return ProtectedGetPropertyAtIndex(idx);
111  }
112 };
113 
114 static constexpr OptionEnumValueElement g_follow_fork_mode_values[] = {
115  {
117  "parent",
118  "Continue tracing the parent process and detach the child.",
119  },
120  {
121  eFollowChild,
122  "child",
123  "Trace the child process and detach the parent.",
124  },
125 };
126 
127 #define LLDB_PROPERTIES_process
128 #include "TargetProperties.inc"
129 
130 enum {
131 #define LLDB_PROPERTIES_process
132 #include "TargetPropertiesEnum.inc"
134 };
135 
136 #define LLDB_PROPERTIES_process_experimental
137 #include "TargetProperties.inc"
138 
139 enum {
140 #define LLDB_PROPERTIES_process_experimental
141 #include "TargetPropertiesEnum.inc"
142 };
143 
145  : public Cloneable<ProcessExperimentalOptionValueProperties,
146  OptionValueProperties> {
147 public:
149  : Cloneable(
150  ConstString(Properties::GetExperimentalSettingsName())) {}
151 };
152 
153 ProcessExperimentalProperties::ProcessExperimentalProperties()
154  : Properties(OptionValuePropertiesSP(
156  m_collection_sp->Initialize(g_process_experimental_properties);
157 }
158 
160  : Properties(),
161  m_process(process) // Can be nullptr for global ProcessProperties
162 {
163  if (process == nullptr) {
164  // Global process properties, set them up one time
166  std::make_shared<ProcessOptionValueProperties>(ConstString("process"));
167  m_collection_sp->Initialize(g_process_properties);
168  m_collection_sp->AppendProperty(
169  ConstString("thread"), ConstString("Settings specific to threads."),
171  } else {
174  m_collection_sp->SetValueChangedCallback(
175  ePropertyPythonOSPluginPath,
176  [this] { m_process->LoadOperatingSystemPlugin(true); });
177  }
178 
180  std::make_unique<ProcessExperimentalProperties>();
181  m_collection_sp->AppendProperty(
183  ConstString("Experimental settings - setting these won't produce "
184  "errors if the setting is not present."),
185  true, m_experimental_properties_up->GetValueProperties());
186 }
187 
189 
191  const uint32_t idx = ePropertyDisableMemCache;
192  return m_collection_sp->GetPropertyAtIndexAsBoolean(
193  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
194 }
195 
197  const uint32_t idx = ePropertyMemCacheLineSize;
198  return m_collection_sp->GetPropertyAtIndexAsUInt64(
199  nullptr, idx, g_process_properties[idx].default_uint_value);
200 }
201 
203  Args args;
204  const uint32_t idx = ePropertyExtraStartCommand;
205  m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
206  return args;
207 }
208 
210  const uint32_t idx = ePropertyExtraStartCommand;
211  m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
212 }
213 
215  const uint32_t idx = ePropertyPythonOSPluginPath;
216  return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
217 }
218 
220  const uint32_t idx = ePropertyVirtualAddressableBits;
221  return m_collection_sp->GetPropertyAtIndexAsUInt64(
222  nullptr, idx, g_process_properties[idx].default_uint_value);
223 }
224 
226  const uint32_t idx = ePropertyVirtualAddressableBits;
227  m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, bits);
228 }
230  const uint32_t idx = ePropertyPythonOSPluginPath;
231  m_collection_sp->SetPropertyAtIndexAsFileSpec(nullptr, idx, file);
232 }
233 
235  const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
236  return m_collection_sp->GetPropertyAtIndexAsBoolean(
237  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
238 }
239 
241  const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
242  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
243 }
244 
246  const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
247  return m_collection_sp->GetPropertyAtIndexAsBoolean(
248  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
249 }
250 
252  const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
253  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
254 }
255 
257  const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
258  return m_collection_sp->GetPropertyAtIndexAsBoolean(
259  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
260 }
261 
263  const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
264  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
265 }
266 
268  const uint32_t idx = ePropertyDisableLangRuntimeUnwindPlans;
269  return m_collection_sp->GetPropertyAtIndexAsBoolean(
270  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
271 }
272 
274  const uint32_t idx = ePropertyDisableLangRuntimeUnwindPlans;
275  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, disable);
276  m_process->Flush();
277 }
278 
280  const uint32_t idx = ePropertyDetachKeepsStopped;
281  return m_collection_sp->GetPropertyAtIndexAsBoolean(
282  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
283 }
284 
286  const uint32_t idx = ePropertyDetachKeepsStopped;
287  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
288 }
289 
291  const uint32_t idx = ePropertyWarningOptimization;
292  return m_collection_sp->GetPropertyAtIndexAsBoolean(
293  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
294 }
295 
297  const uint32_t idx = ePropertyWarningUnsupportedLanguage;
298  return m_collection_sp->GetPropertyAtIndexAsBoolean(
299  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
300 }
301 
303  const uint32_t idx = ePropertyStopOnExec;
304  return m_collection_sp->GetPropertyAtIndexAsBoolean(
305  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
306 }
307 
309  const uint32_t idx = ePropertyUtilityExpressionTimeout;
310  uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
311  nullptr, idx, g_process_properties[idx].default_uint_value);
312  return std::chrono::seconds(value);
313 }
314 
315 std::chrono::seconds ProcessProperties::GetInterruptTimeout() const {
316  const uint32_t idx = ePropertyInterruptTimeout;
317  uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
318  nullptr, idx, g_process_properties[idx].default_uint_value);
319  return std::chrono::seconds(value);
320 }
321 
323  const uint32_t idx = ePropertySteppingRunsAllThreads;
324  return m_collection_sp->GetPropertyAtIndexAsBoolean(
325  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
326 }
327 
329  const bool fail_value = true;
330  const Property *exp_property =
331  m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyExperimental);
332  OptionValueProperties *exp_values =
333  exp_property->GetValue()->GetAsProperties();
334  if (!exp_values)
335  return fail_value;
336 
337  return exp_values->GetPropertyAtIndexAsBoolean(
338  nullptr, ePropertyOSPluginReportsAllThreads, fail_value);
339 }
340 
342  const Property *exp_property =
343  m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyExperimental);
344  OptionValueProperties *exp_values =
345  exp_property->GetValue()->GetAsProperties();
346  if (exp_values)
347  exp_values->SetPropertyAtIndexAsBoolean(
348  nullptr, ePropertyOSPluginReportsAllThreads, does_report);
349 }
350 
352  const uint32_t idx = ePropertyFollowForkMode;
353  return (FollowForkMode)m_collection_sp->GetPropertyAtIndexAsEnumeration(
354  nullptr, idx, g_process_properties[idx].default_uint_value);
355 }
356 
357 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp,
358  llvm::StringRef plugin_name,
359  ListenerSP listener_sp,
360  const FileSpec *crash_file_path,
361  bool can_connect) {
362  static uint32_t g_process_unique_id = 0;
363 
364  ProcessSP process_sp;
365  ProcessCreateInstance create_callback = nullptr;
366  if (!plugin_name.empty()) {
367  create_callback =
369  if (create_callback) {
370  process_sp = create_callback(target_sp, listener_sp, crash_file_path,
371  can_connect);
372  if (process_sp) {
373  if (process_sp->CanDebug(target_sp, true)) {
374  process_sp->m_process_unique_id = ++g_process_unique_id;
375  } else
376  process_sp.reset();
377  }
378  }
379  } else {
380  for (uint32_t idx = 0;
381  (create_callback =
383  ++idx) {
384  process_sp = create_callback(target_sp, listener_sp, crash_file_path,
385  can_connect);
386  if (process_sp) {
387  if (process_sp->CanDebug(target_sp, false)) {
388  process_sp->m_process_unique_id = ++g_process_unique_id;
389  break;
390  } else
391  process_sp.reset();
392  }
393  }
394  }
395  return process_sp;
396 }
397 
399  static ConstString class_name("lldb.process");
400  return class_name;
401 }
402 
403 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp)
404  : Process(target_sp, listener_sp,
405  UnixSignals::Create(HostInfo::GetArchitecture())) {
406  // This constructor just delegates to the full Process constructor,
407  // defaulting to using the Host's UnixSignals.
408 }
409 
410 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp,
411  const UnixSignalsSP &unix_signals_sp)
412  : ProcessProperties(this),
413  Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()),
414  Process::GetStaticBroadcasterClass().AsCString()),
415  m_target_wp(target_sp), m_public_state(eStateUnloaded),
416  m_private_state(eStateUnloaded),
417  m_private_state_broadcaster(nullptr,
418  "lldb.process.internal_state_broadcaster"),
419  m_private_state_control_broadcaster(
420  nullptr, "lldb.process.internal_state_control_broadcaster"),
421  m_private_state_listener_sp(
422  Listener::MakeListener("lldb.process.internal_state_listener")),
423  m_mod_id(), m_process_unique_id(0), m_thread_index_id(0),
424  m_thread_id_to_index_id_map(), m_exit_status(-1), m_exit_string(),
425  m_exit_status_mutex(), m_thread_mutex(), m_thread_list_real(this),
426  m_thread_list(this), m_thread_plans(*this), m_extended_thread_list(this),
427  m_extended_thread_stop_id(0), m_queue_list(this), m_queue_list_stop_id(0),
428  m_notifications(), m_image_tokens(), m_listener_sp(listener_sp),
429  m_breakpoint_site_list(), m_dynamic_checkers_up(),
430  m_unix_signals_sp(unix_signals_sp), m_abi_sp(), m_process_input_reader(),
431  m_stdio_communication("process.stdio"), m_stdio_communication_mutex(),
432  m_stdin_forward(false), m_stdout_data(), m_stderr_data(),
433  m_profile_data_comm_mutex(), m_profile_data(), m_iohandler_sync(0),
434  m_memory_cache(*this), m_allocated_memory_cache(*this),
435  m_should_detach(false), m_next_event_action_up(), m_public_run_lock(),
436  m_private_run_lock(), m_finalizing(false),
437  m_clear_thread_plans_on_stop(false), m_force_next_event_delivery(false),
438  m_last_broadcast_state(eStateInvalid), m_destroy_in_process(false),
439  m_can_interpret_function_calls(false), m_run_thread_plan_lock(),
440  m_can_jit(eCanJITDontKnow) {
442 
443  Log *log = GetLog(LLDBLog::Object);
444  LLDB_LOGF(log, "%p Process::Process()", static_cast<void *>(this));
445 
446  if (!m_unix_signals_sp)
447  m_unix_signals_sp = std::make_shared<UnixSignals>();
448 
449  SetEventName(eBroadcastBitStateChanged, "state-changed");
450  SetEventName(eBroadcastBitInterrupt, "interrupt");
451  SetEventName(eBroadcastBitSTDOUT, "stdout-available");
452  SetEventName(eBroadcastBitSTDERR, "stderr-available");
453  SetEventName(eBroadcastBitProfileData, "profile-data-available");
454  SetEventName(eBroadcastBitStructuredData, "structured-data-available");
455 
457  eBroadcastInternalStateControlStop, "control-stop");
459  eBroadcastInternalStateControlPause, "control-pause");
461  eBroadcastInternalStateControlResume, "control-resume");
462 
463  m_listener_sp->StartListeningForEvents(
467 
468  m_private_state_listener_sp->StartListeningForEvents(
471 
472  m_private_state_listener_sp->StartListeningForEvents(
476  // We need something valid here, even if just the default UnixSignalsSP.
477  assert(m_unix_signals_sp && "null m_unix_signals_sp after initialization");
478 
479  // Allow the platform to override the default cache line size
480  OptionValueSP value_sp =
482  ->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)
483  ->GetValue();
484  uint32_t platform_cache_line_size =
485  target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
486  if (!value_sp->OptionWasSet() && platform_cache_line_size != 0)
487  value_sp->SetUInt64Value(platform_cache_line_size);
488 
490 }
491 
493  Log *log = GetLog(LLDBLog::Object);
494  LLDB_LOGF(log, "%p Process::~Process()", static_cast<void *>(this));
496 
497  // ThreadList::Clear() will try to acquire this process's mutex, so
498  // explicitly clear the thread list here to ensure that the mutex is not
499  // destroyed before the thread list.
501 }
502 
504  // NOTE: intentional leak so we don't crash if global destructor chain gets
505  // called as other threads still use the result of this function
506  static ProcessProperties *g_settings_ptr =
507  new ProcessProperties(nullptr);
508  return *g_settings_ptr;
509 }
510 
512  if (m_finalizing.exchange(true))
513  return;
514 
515  // Destroy the process. This will call the virtual function DoDestroy under
516  // the hood, giving our derived class a chance to do the ncessary tear down.
517  DestroyImpl(false);
518 
519  // Clear our broadcaster before we proceed with destroying
521 
522  // Do any cleanup needed prior to being destructed... Subclasses that
523  // override this method should call this superclass method as well.
524 
525  // We need to destroy the loader before the derived Process class gets
526  // destroyed since it is very likely that undoing the loader will require
527  // access to the real process.
528  m_dynamic_checkers_up.reset();
529  m_abi_sp.reset();
530  m_os_up.reset();
531  m_system_runtime_up.reset();
532  m_dyld_up.reset();
533  m_jit_loaders_up.reset();
540  std::vector<Notifications> empty_notifications;
541  m_notifications.swap(empty_notifications);
542  m_image_tokens.clear();
545  {
546  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
547  m_language_runtimes.clear();
548  }
550  m_next_event_action_up.reset();
551  // Clear the last natural stop ID since it has a strong reference to this
552  // process
554  //#ifdef LLDB_CONFIGURATION_DEBUG
555  // StreamFile s(stdout, false);
556  // EventSP event_sp;
557  // while (m_private_state_listener_sp->GetNextEvent(event_sp))
558  // {
559  // event_sp->Dump (&s);
560  // s.EOL();
561  // }
562  //#endif
563  // We have to be very careful here as the m_private_state_listener might
564  // contain events that have ProcessSP values in them which can keep this
565  // process around forever. These events need to be cleared out.
567  m_public_run_lock.TrySetRunning(); // This will do nothing if already locked
569  m_private_run_lock.TrySetRunning(); // This will do nothing if already locked
572 }
573 
575  m_notifications.push_back(callbacks);
576  if (callbacks.initialize != nullptr)
577  callbacks.initialize(callbacks.baton, this);
578 }
579 
581  std::vector<Notifications>::iterator pos, end = m_notifications.end();
582  for (pos = m_notifications.begin(); pos != end; ++pos) {
583  if (pos->baton == callbacks.baton &&
584  pos->initialize == callbacks.initialize &&
585  pos->process_state_changed == callbacks.process_state_changed) {
586  m_notifications.erase(pos);
587  return true;
588  }
589  }
590  return false;
591 }
592 
594  std::vector<Notifications>::iterator notification_pos,
595  notification_end = m_notifications.end();
596  for (notification_pos = m_notifications.begin();
597  notification_pos != notification_end; ++notification_pos) {
598  if (notification_pos->process_state_changed)
599  notification_pos->process_state_changed(notification_pos->baton, this,
600  state);
601  }
602 }
603 
604 // FIXME: We need to do some work on events before the general Listener sees
605 // them.
606 // For instance if we are continuing from a breakpoint, we need to ensure that
607 // we do the little "insert real insn, step & stop" trick. But we can't do
608 // that when the event is delivered by the broadcaster - since that is done on
609 // the thread that is waiting for new events, so if we needed more than one
610 // event for our handling, we would stall. So instead we do it when we fetch
611 // the event off of the queue.
612 //
613 
614 StateType Process::GetNextEvent(EventSP &event_sp) {
615  StateType state = eStateInvalid;
616 
617  if (m_listener_sp->GetEventForBroadcaster(this, event_sp,
618  std::chrono::seconds(0)) &&
619  event_sp)
620  state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
621 
622  return state;
623 }
624 
626  const Timeout<std::micro> &timeout) {
627  // don't sync (potentially context switch) in case where there is no process
628  // IO
630  return;
631 
632  auto Result = m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id, timeout);
633 
634  Log *log = GetLog(LLDBLog::Process);
635  if (Result) {
636  LLDB_LOG(
637  log,
638  "waited from m_iohandler_sync to change from {0}. New value is {1}.",
639  iohandler_id, *Result);
640  } else {
641  LLDB_LOG(log, "timed out waiting for m_iohandler_sync to change from {0}.",
642  iohandler_id);
643  }
644 }
645 
647  EventSP *event_sp_ptr, bool wait_always,
648  ListenerSP hijack_listener_sp,
649  Stream *stream, bool use_run_lock) {
650  // We can't just wait for a "stopped" event, because the stopped event may
651  // have restarted the target. We have to actually check each event, and in
652  // the case of a stopped event check the restarted flag on the event.
653  if (event_sp_ptr)
654  event_sp_ptr->reset();
655  StateType state = GetState();
656  // If we are exited or detached, we won't ever get back to any other valid
657  // state...
658  if (state == eStateDetached || state == eStateExited)
659  return state;
660 
661  Log *log = GetLog(LLDBLog::Process);
662  LLDB_LOG(log, "timeout = {0}", timeout);
663 
664  if (!wait_always && StateIsStoppedState(state, true) &&
666  LLDB_LOGF(log,
667  "Process::%s returning without waiting for events; process "
668  "private and public states are already 'stopped'.",
669  __FUNCTION__);
670  // We need to toggle the run lock as this won't get done in
671  // SetPublicState() if the process is hijacked.
672  if (hijack_listener_sp && use_run_lock)
674  return state;
675  }
676 
677  while (state != eStateInvalid) {
678  EventSP event_sp;
679  state = GetStateChangedEvents(event_sp, timeout, hijack_listener_sp);
680  if (event_sp_ptr && event_sp)
681  *event_sp_ptr = event_sp;
682 
683  bool pop_process_io_handler = (hijack_listener_sp.get() != nullptr);
685  pop_process_io_handler);
686 
687  switch (state) {
688  case eStateCrashed:
689  case eStateDetached:
690  case eStateExited:
691  case eStateUnloaded:
692  // We need to toggle the run lock as this won't get done in
693  // SetPublicState() if the process is hijacked.
694  if (hijack_listener_sp && use_run_lock)
696  return state;
697  case eStateStopped:
699  continue;
700  else {
701  // We need to toggle the run lock as this won't get done in
702  // SetPublicState() if the process is hijacked.
703  if (hijack_listener_sp && use_run_lock)
705  return state;
706  }
707  default:
708  continue;
709  }
710  }
711  return state;
712 }
713 
714 bool Process::HandleProcessStateChangedEvent(const EventSP &event_sp,
715  Stream *stream,
716  bool &pop_process_io_handler) {
717  const bool handle_pop = pop_process_io_handler;
718 
719  pop_process_io_handler = false;
720  ProcessSP process_sp =
722 
723  if (!process_sp)
724  return false;
725 
726  StateType event_state =
728  if (event_state == eStateInvalid)
729  return false;
730 
731  switch (event_state) {
732  case eStateInvalid:
733  case eStateUnloaded:
734  case eStateAttaching:
735  case eStateLaunching:
736  case eStateStepping:
737  case eStateDetached:
738  if (stream)
739  stream->Printf("Process %" PRIu64 " %s\n", process_sp->GetID(),
740  StateAsCString(event_state));
741  if (event_state == eStateDetached)
742  pop_process_io_handler = true;
743  break;
744 
745  case eStateConnected:
746  case eStateRunning:
747  // Don't be chatty when we run...
748  break;
749 
750  case eStateExited:
751  if (stream)
752  process_sp->GetStatus(*stream);
753  pop_process_io_handler = true;
754  break;
755 
756  case eStateStopped:
757  case eStateCrashed:
758  case eStateSuspended:
759  // Make sure the program hasn't been auto-restarted:
761  if (stream) {
762  size_t num_reasons =
764  if (num_reasons > 0) {
765  // FIXME: Do we want to report this, or would that just be annoyingly
766  // chatty?
767  if (num_reasons == 1) {
768  const char *reason =
770  event_sp.get(), 0);
771  stream->Printf("Process %" PRIu64 " stopped and restarted: %s\n",
772  process_sp->GetID(),
773  reason ? reason : "<UNKNOWN REASON>");
774  } else {
775  stream->Printf("Process %" PRIu64
776  " stopped and restarted, reasons:\n",
777  process_sp->GetID());
778 
779  for (size_t i = 0; i < num_reasons; i++) {
780  const char *reason =
782  event_sp.get(), i);
783  stream->Printf("\t%s\n", reason ? reason : "<UNKNOWN REASON>");
784  }
785  }
786  }
787  }
788  } else {
789  StopInfoSP curr_thread_stop_info_sp;
790  // Lock the thread list so it doesn't change on us, this is the scope for
791  // the locker:
792  {
793  ThreadList &thread_list = process_sp->GetThreadList();
794  std::lock_guard<std::recursive_mutex> guard(thread_list.GetMutex());
795 
796  ThreadSP curr_thread(thread_list.GetSelectedThread());
797  ThreadSP thread;
798  StopReason curr_thread_stop_reason = eStopReasonInvalid;
799  bool prefer_curr_thread = false;
800  if (curr_thread && curr_thread->IsValid()) {
801  curr_thread_stop_reason = curr_thread->GetStopReason();
802  switch (curr_thread_stop_reason) {
803  case eStopReasonNone:
804  case eStopReasonInvalid:
805  // Don't prefer the current thread if it didn't stop for a reason.
806  break;
807  case eStopReasonSignal: {
808  // We need to do the same computation we do for other threads
809  // below in case the current thread happens to be the one that
810  // stopped for the no-stop signal.
811  uint64_t signo = curr_thread->GetStopInfo()->GetValue();
812  if (process_sp->GetUnixSignals()->GetShouldStop(signo))
813  prefer_curr_thread = true;
814  } break;
815  default:
816  prefer_curr_thread = true;
817  break;
818  }
819  curr_thread_stop_info_sp = curr_thread->GetStopInfo();
820  }
821 
822  if (!prefer_curr_thread) {
823  // Prefer a thread that has just completed its plan over another
824  // thread as current thread.
825  ThreadSP plan_thread;
826  ThreadSP other_thread;
827 
828  const size_t num_threads = thread_list.GetSize();
829  size_t i;
830  for (i = 0; i < num_threads; ++i) {
831  thread = thread_list.GetThreadAtIndex(i);
832  StopReason thread_stop_reason = thread->GetStopReason();
833  switch (thread_stop_reason) {
834  case eStopReasonInvalid:
835  case eStopReasonNone:
836  break;
837 
838  case eStopReasonSignal: {
839  // Don't select a signal thread if we weren't going to stop at
840  // that signal. We have to have had another reason for stopping
841  // here, and the user doesn't want to see this thread.
842  uint64_t signo = thread->GetStopInfo()->GetValue();
843  if (process_sp->GetUnixSignals()->GetShouldStop(signo)) {
844  if (!other_thread)
845  other_thread = thread;
846  }
847  break;
848  }
849  case eStopReasonTrace:
853  case eStopReasonExec:
854  case eStopReasonFork:
855  case eStopReasonVFork:
860  if (!other_thread)
861  other_thread = thread;
862  break;
864  if (!plan_thread)
865  plan_thread = thread;
866  break;
867  }
868  }
869  if (plan_thread)
870  thread_list.SetSelectedThreadByID(plan_thread->GetID());
871  else if (other_thread)
872  thread_list.SetSelectedThreadByID(other_thread->GetID());
873  else {
874  if (curr_thread && curr_thread->IsValid())
875  thread = curr_thread;
876  else
877  thread = thread_list.GetThreadAtIndex(0);
878 
879  if (thread)
880  thread_list.SetSelectedThreadByID(thread->GetID());
881  }
882  }
883  }
884  // Drop the ThreadList mutex by here, since GetThreadStatus below might
885  // have to run code, e.g. for Data formatters, and if we hold the
886  // ThreadList mutex, then the process is going to have a hard time
887  // restarting the process.
888  if (stream) {
889  Debugger &debugger = process_sp->GetTarget().GetDebugger();
890  if (debugger.GetTargetList().GetSelectedTarget().get() ==
891  &process_sp->GetTarget()) {
892  ThreadSP thread_sp = process_sp->GetThreadList().GetSelectedThread();
893 
894  if (!thread_sp || !thread_sp->IsValid())
895  return false;
896 
897  const bool only_threads_with_stop_reason = true;
898  const uint32_t start_frame = thread_sp->GetSelectedFrameIndex();
899  const uint32_t num_frames = 1;
900  const uint32_t num_frames_with_source = 1;
901  const bool stop_format = true;
902 
903  process_sp->GetStatus(*stream);
904  process_sp->GetThreadStatus(*stream, only_threads_with_stop_reason,
905  start_frame, num_frames,
906  num_frames_with_source,
907  stop_format);
908  if (curr_thread_stop_info_sp) {
909  lldb::addr_t crashing_address;
910  ValueObjectSP valobj_sp = StopInfo::GetCrashingDereference(
911  curr_thread_stop_info_sp, &crashing_address);
912  if (valobj_sp) {
914  ValueObject::GetExpressionPathFormat::
915  eGetExpressionPathFormatHonorPointers;
916  stream->PutCString("Likely cause: ");
917  valobj_sp->GetExpressionPath(*stream, format);
918  stream->Printf(" accessed 0x%" PRIx64 "\n", crashing_address);
919  }
920  }
921  } else {
922  uint32_t target_idx = debugger.GetTargetList().GetIndexOfTarget(
923  process_sp->GetTarget().shared_from_this());
924  if (target_idx != UINT32_MAX)
925  stream->Printf("Target %d: (", target_idx);
926  else
927  stream->Printf("Target <unknown index>: (");
928  process_sp->GetTarget().Dump(stream, eDescriptionLevelBrief);
929  stream->Printf(") stopped.\n");
930  }
931  }
932 
933  // Pop the process IO handler
934  pop_process_io_handler = true;
935  }
936  break;
937  }
938 
939  if (handle_pop && pop_process_io_handler)
940  process_sp->PopProcessIOHandler();
941 
942  return true;
943 }
944 
945 bool Process::HijackProcessEvents(ListenerSP listener_sp) {
946  if (listener_sp) {
947  return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged |
949  } else
950  return false;
951 }
952 
954 
956  const Timeout<std::micro> &timeout,
957  ListenerSP hijack_listener_sp) {
958  Log *log = GetLog(LLDBLog::Process);
959  LLDB_LOG(log, "timeout = {0}, event_sp)...", timeout);
960 
961  ListenerSP listener_sp = hijack_listener_sp;
962  if (!listener_sp)
963  listener_sp = m_listener_sp;
964 
965  StateType state = eStateInvalid;
966  if (listener_sp->GetEventForBroadcasterWithType(
968  timeout)) {
969  if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
970  state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
971  else
972  LLDB_LOG(log, "got no event or was interrupted.");
973  }
974 
975  LLDB_LOG(log, "timeout = {0}, event_sp) => {1}", timeout, state);
976  return state;
977 }
978 
980  Log *log = GetLog(LLDBLog::Process);
981 
982  LLDB_LOGF(log, "Process::%s...", __FUNCTION__);
983 
984  Event *event_ptr;
985  event_ptr = m_listener_sp->PeekAtNextEventForBroadcasterWithType(
987  if (log) {
988  if (event_ptr) {
989  LLDB_LOGF(log, "Process::%s (event_ptr) => %s", __FUNCTION__,
991  } else {
992  LLDB_LOGF(log, "Process::%s no events found", __FUNCTION__);
993  }
994  }
995  return event_ptr;
996 }
997 
998 StateType
1000  const Timeout<std::micro> &timeout) {
1001  Log *log = GetLog(LLDBLog::Process);
1002  LLDB_LOG(log, "timeout = {0}, event_sp)...", timeout);
1003 
1004  StateType state = eStateInvalid;
1005  if (m_private_state_listener_sp->GetEventForBroadcasterWithType(
1008  timeout))
1009  if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1010  state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1011 
1012  LLDB_LOG(log, "timeout = {0}, event_sp) => {1}", timeout,
1013  state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
1014  return state;
1015 }
1016 
1017 bool Process::GetEventsPrivate(EventSP &event_sp,
1018  const Timeout<std::micro> &timeout,
1019  bool control_only) {
1020  Log *log = GetLog(LLDBLog::Process);
1021  LLDB_LOG(log, "timeout = {0}, event_sp)...", timeout);
1022 
1023  if (control_only)
1024  return m_private_state_listener_sp->GetEventForBroadcaster(
1025  &m_private_state_control_broadcaster, event_sp, timeout);
1026  else
1027  return m_private_state_listener_sp->GetEvent(event_sp, timeout);
1028 }
1029 
1030 bool Process::IsRunning() const {
1032 }
1033 
1035  std::lock_guard<std::mutex> guard(m_exit_status_mutex);
1036 
1038  return m_exit_status;
1039  return -1;
1040 }
1041 
1043  std::lock_guard<std::mutex> guard(m_exit_status_mutex);
1044 
1045  if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
1046  return m_exit_string.c_str();
1047  return nullptr;
1048 }
1049 
1050 bool Process::SetExitStatus(int status, const char *cstr) {
1051  // Use a mutex to protect setting the exit status.
1052  std::lock_guard<std::mutex> guard(m_exit_status_mutex);
1053 
1055  LLDB_LOGF(
1056  log, "Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1057  status, status, cstr ? "\"" : "", cstr ? cstr : "NULL", cstr ? "\"" : "");
1058 
1059  // We were already in the exited state
1061  LLDB_LOGF(log, "Process::SetExitStatus () ignoring exit status because "
1062  "state was already set to eStateExited");
1063  return false;
1064  }
1065 
1066  m_exit_status = status;
1067  if (cstr)
1068  m_exit_string = cstr;
1069  else
1070  m_exit_string.clear();
1071 
1072  // Clear the last natural stop ID since it has a strong reference to this
1073  // process
1075 
1077 
1078  // Allow subclasses to do some cleanup
1079  DidExit();
1080 
1081  return true;
1082 }
1083 
1085  switch (m_private_state.GetValue()) {
1086  case eStateConnected:
1087  case eStateAttaching:
1088  case eStateLaunching:
1089  case eStateStopped:
1090  case eStateRunning:
1091  case eStateStepping:
1092  case eStateCrashed:
1093  case eStateSuspended:
1094  return true;
1095  default:
1096  return false;
1097  }
1098 }
1099 
1100 // This static callback can be used to watch for local child processes on the
1101 // current host. The child process exits, the process will be found in the
1102 // global target list (we want to be completely sure that the
1103 // lldb_private::Process doesn't go away before we can deliver the signal.
1105  lldb::pid_t pid, bool exited,
1106  int signo, // Zero for no signal
1107  int exit_status // Exit value of process if signal is zero
1108  ) {
1109  Log *log = GetLog(LLDBLog::Process);
1110  LLDB_LOGF(log,
1111  "Process::SetProcessExitStatus (pid=%" PRIu64
1112  ", exited=%i, signal=%i, exit_status=%i)\n",
1113  pid, exited, signo, exit_status);
1114 
1115  if (exited) {
1116  TargetSP target_sp(Debugger::FindTargetWithProcessID(pid));
1117  if (target_sp) {
1118  ProcessSP process_sp(target_sp->GetProcessSP());
1119  if (process_sp) {
1120  const char *signal_cstr = nullptr;
1121  if (signo)
1122  signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
1123 
1124  process_sp->SetExitStatus(exit_status, signal_cstr);
1125  }
1126  }
1127  return true;
1128  }
1129  return false;
1130 }
1131 
1133  ThreadList &new_thread_list) {
1135  return DoUpdateThreadList(old_thread_list, new_thread_list);
1136 }
1137 
1139  const uint32_t stop_id = GetStopID();
1140  if (m_thread_list.GetSize(false) == 0 ||
1141  stop_id != m_thread_list.GetStopID()) {
1142  bool clear_unused_threads = true;
1143  const StateType state = GetPrivateState();
1144  if (StateIsStoppedState(state, true)) {
1145  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
1146  m_thread_list.SetStopID(stop_id);
1147 
1148  // m_thread_list does have its own mutex, but we need to hold onto the
1149  // mutex between the call to UpdateThreadList(...) and the
1150  // os->UpdateThreadList(...) so it doesn't change on us
1151  ThreadList &old_thread_list = m_thread_list;
1152  ThreadList real_thread_list(this);
1153  ThreadList new_thread_list(this);
1154  // Always update the thread list with the protocol specific thread list,
1155  // but only update if "true" is returned
1156  if (UpdateThreadList(m_thread_list_real, real_thread_list)) {
1157  // Don't call into the OperatingSystem to update the thread list if we
1158  // are shutting down, since that may call back into the SBAPI's,
1159  // requiring the API lock which is already held by whoever is shutting
1160  // us down, causing a deadlock.
1162  if (os && !m_destroy_in_process) {
1163  // Clear any old backing threads where memory threads might have been
1164  // backed by actual threads from the lldb_private::Process subclass
1165  size_t num_old_threads = old_thread_list.GetSize(false);
1166  for (size_t i = 0; i < num_old_threads; ++i)
1167  old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
1168  // See if the OS plugin reports all threads. If it does, then
1169  // it is safe to clear unseen thread's plans here. Otherwise we
1170  // should preserve them in case they show up again:
1171  clear_unused_threads = GetOSPluginReportsAllThreads();
1172 
1173  // Turn off dynamic types to ensure we don't run any expressions.
1174  // Objective-C can run an expression to determine if a SBValue is a
1175  // dynamic type or not and we need to avoid this. OperatingSystem
1176  // plug-ins can't run expressions that require running code...
1177 
1178  Target &target = GetTarget();
1179  const lldb::DynamicValueType saved_prefer_dynamic =
1180  target.GetPreferDynamicValue();
1181  if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1183 
1184  // Now let the OperatingSystem plug-in update the thread list
1185 
1186  os->UpdateThreadList(
1187  old_thread_list, // Old list full of threads created by OS plug-in
1188  real_thread_list, // The actual thread list full of threads
1189  // created by each lldb_private::Process
1190  // subclass
1191  new_thread_list); // The new thread list that we will show to the
1192  // user that gets filled in
1193 
1194  if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1195  target.SetPreferDynamicValue(saved_prefer_dynamic);
1196  } else {
1197  // No OS plug-in, the new thread list is the same as the real thread
1198  // list.
1199  new_thread_list = real_thread_list;
1200  }
1201 
1202  m_thread_list_real.Update(real_thread_list);
1203  m_thread_list.Update(new_thread_list);
1204  m_thread_list.SetStopID(stop_id);
1205 
1207  // Clear any extended threads that we may have accumulated previously
1210 
1211  m_queue_list.Clear();
1213  }
1214  }
1215  // Now update the plan stack map.
1216  // If we do have an OS plugin, any absent real threads in the
1217  // m_thread_list have already been removed from the ThreadPlanStackMap.
1218  // So any remaining threads are OS Plugin threads, and those we want to
1219  // preserve in case they show up again.
1220  m_thread_plans.Update(m_thread_list, clear_unused_threads);
1221  }
1222  }
1223 }
1224 
1226  return m_thread_plans.Find(tid);
1227 }
1228 
1230  return m_thread_plans.PrunePlansForTID(tid);
1231 }
1232 
1234  m_thread_plans.Update(GetThreadList(), true, false);
1235 }
1236 
1238  lldb::DescriptionLevel desc_level,
1239  bool internal, bool condense_trivial,
1240  bool skip_unreported_plans) {
1242  strm, tid, desc_level, internal, condense_trivial, skip_unreported_plans);
1243 }
1245  bool internal, bool condense_trivial,
1246  bool skip_unreported_plans) {
1247  m_thread_plans.DumpPlans(strm, desc_level, internal, condense_trivial,
1248  skip_unreported_plans);
1249 }
1250 
1252  if (m_system_runtime_up) {
1253  if (m_queue_list.GetSize() == 0 ||
1255  const StateType state = GetPrivateState();
1256  if (StateIsStoppedState(state, true)) {
1257  m_system_runtime_up->PopulateQueueList(m_queue_list);
1259  }
1260  }
1261  }
1262 }
1263 
1266  if (os)
1267  return os->CreateThread(tid, context);
1268  return ThreadSP();
1269 }
1270 
1272  return AssignIndexIDToThread(thread_id);
1273 }
1274 
1275 bool Process::HasAssignedIndexIDToThread(uint64_t thread_id) {
1276  return (m_thread_id_to_index_id_map.find(thread_id) !=
1278 }
1279 
1281  uint32_t result = 0;
1282  std::map<uint64_t, uint32_t>::iterator iterator =
1283  m_thread_id_to_index_id_map.find(thread_id);
1284  if (iterator == m_thread_id_to_index_id_map.end()) {
1285  result = ++m_thread_index_id;
1286  m_thread_id_to_index_id_map[thread_id] = result;
1287  } else {
1288  result = iterator->second;
1289  }
1290 
1291  return result;
1292 }
1293 
1295  return m_public_state.GetValue();
1296 }
1297 
1298 void Process::SetPublicState(StateType new_state, bool restarted) {
1299  const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1300  if (new_state_is_stopped) {
1301  // This will only set the time if the public stop time has no value, so
1302  // it is ok to call this multiple times. With a public stop we can't look
1303  // at the stop ID because many private stops might have happened, so we
1304  // can't check for a stop ID of zero. This allows the "statistics" command
1305  // to dump the time it takes to reach somewhere in your code, like a
1306  // breakpoint you set.
1308  }
1309 
1311  LLDB_LOGF(log, "Process::SetPublicState (state = %s, restarted = %i)",
1312  StateAsCString(new_state), restarted);
1313  const StateType old_state = m_public_state.GetValue();
1314  m_public_state.SetValue(new_state);
1315 
1316  // On the transition from Run to Stopped, we unlock the writer end of the run
1317  // lock. The lock gets locked in Resume, which is the public API to tell the
1318  // program to run.
1320  if (new_state == eStateDetached) {
1321  LLDB_LOGF(log,
1322  "Process::SetPublicState (%s) -- unlocking run lock for detach",
1323  StateAsCString(new_state));
1325  } else {
1326  const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1327  if ((old_state_is_stopped != new_state_is_stopped)) {
1328  if (new_state_is_stopped && !restarted) {
1329  LLDB_LOGF(log, "Process::SetPublicState (%s) -- unlocking run lock",
1330  StateAsCString(new_state));
1332  }
1333  }
1334  }
1335  }
1336 }
1337 
1340  LLDB_LOGF(log, "Process::Resume -- locking run lock");
1342  Status error("Resume request failed - process still running.");
1343  LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1344  return error;
1345  }
1347  if (!error.Success()) {
1348  // Undo running state change
1350  }
1351  return error;
1352 }
1353 
1354 static const char *g_resume_sync_name = "lldb.Process.ResumeSynchronous.hijack";
1355 
1358  LLDB_LOGF(log, "Process::ResumeSynchronous -- locking run lock");
1360  Status error("Resume request failed - process still running.");
1361  LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1362  return error;
1363  }
1364 
1365  ListenerSP listener_sp(
1367  HijackProcessEvents(listener_sp);
1368 
1370  if (error.Success()) {
1371  StateType state = WaitForProcessToStop(llvm::None, nullptr, true,
1372  listener_sp, stream);
1373  const bool must_be_alive =
1374  false; // eStateExited is ok, so this must be false
1375  if (!StateIsStoppedState(state, must_be_alive))
1376  error.SetErrorStringWithFormat(
1377  "process not in stopped state after synchronous resume: %s",
1378  StateAsCString(state));
1379  } else {
1380  // Undo running state change
1382  }
1383 
1384  // Undo the hijacking of process events...
1386 
1387  return error;
1388 }
1389 
1392  const char *hijacking_name = GetHijackingListenerName();
1393  if (hijacking_name &&
1394  strcmp(hijacking_name, g_resume_sync_name))
1395  return true;
1396  }
1397  return false;
1398 }
1399 
1402  const char *hijacking_name = GetHijackingListenerName();
1403  if (hijacking_name &&
1404  strcmp(hijacking_name, g_resume_sync_name) == 0)
1405  return true;
1406  }
1407  return false;
1408 }
1409 
1411 
1413  if (m_finalizing)
1414  return;
1415 
1417  bool state_changed = false;
1418 
1419  LLDB_LOGF(log, "Process::SetPrivateState (%s)", StateAsCString(new_state));
1420 
1421  std::lock_guard<std::recursive_mutex> thread_guard(m_thread_list.GetMutex());
1422  std::lock_guard<std::recursive_mutex> guard(m_private_state.GetMutex());
1423 
1424  const StateType old_state = m_private_state.GetValueNoLock();
1425  state_changed = old_state != new_state;
1426 
1427  const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1428  const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1429  if (old_state_is_stopped != new_state_is_stopped) {
1430  if (new_state_is_stopped)
1432  else
1434  }
1435 
1436  if (state_changed) {
1437  m_private_state.SetValueNoLock(new_state);
1438  EventSP event_sp(
1440  new ProcessEventData(shared_from_this(), new_state)));
1441  if (StateIsStoppedState(new_state, false)) {
1442  // Note, this currently assumes that all threads in the list stop when
1443  // the process stops. In the future we will want to support a debugging
1444  // model where some threads continue to run while others are stopped.
1445  // When that happens we will either need a way for the thread list to
1446  // identify which threads are stopping or create a special thread list
1447  // containing only threads which actually stopped.
1448  //
1449  // The process plugin is responsible for managing the actual behavior of
1450  // the threads and should have stopped any threads that are going to stop
1451  // before we get here.
1453 
1454  if (m_mod_id.BumpStopID() == 0)
1456 
1460  LLDB_LOGF(log, "Process::SetPrivateState (%s) stop_id = %u",
1461  StateAsCString(new_state), m_mod_id.GetStopID());
1462  }
1463 
1465  } else {
1466  LLDB_LOGF(log,
1467  "Process::SetPrivateState (%s) state didn't change. Ignoring...",
1468  StateAsCString(new_state));
1469  }
1470 }
1471 
1474 }
1475 
1478 }
1479 
1481 
1482 const lldb::ABISP &Process::GetABI() {
1483  if (!m_abi_sp)
1484  m_abi_sp = ABI::FindPlugin(shared_from_this(), GetTarget().GetArchitecture());
1485  return m_abi_sp;
1486 }
1487 
1488 std::vector<LanguageRuntime *> Process::GetLanguageRuntimes() {
1489  std::vector<LanguageRuntime *> language_runtimes;
1490 
1491  if (m_finalizing)
1492  return language_runtimes;
1493 
1494  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
1495  // Before we pass off a copy of the language runtimes, we must make sure that
1496  // our collection is properly populated. It's possible that some of the
1497  // language runtimes were not loaded yet, either because nobody requested it
1498  // yet or the proper condition for loading wasn't yet met (e.g. libc++.so
1499  // hadn't been loaded).
1500  for (const lldb::LanguageType lang_type : Language::GetSupportedLanguages()) {
1501  if (LanguageRuntime *runtime = GetLanguageRuntime(lang_type))
1502  language_runtimes.emplace_back(runtime);
1503  }
1504 
1505  return language_runtimes;
1506 }
1507 
1509  if (m_finalizing)
1510  return nullptr;
1511 
1512  LanguageRuntime *runtime = nullptr;
1513 
1514  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
1515  LanguageRuntimeCollection::iterator pos;
1516  pos = m_language_runtimes.find(language);
1517  if (pos == m_language_runtimes.end() || !pos->second) {
1518  lldb::LanguageRuntimeSP runtime_sp(
1519  LanguageRuntime::FindPlugin(this, language));
1520 
1521  m_language_runtimes[language] = runtime_sp;
1522  runtime = runtime_sp.get();
1523  } else
1524  runtime = pos->second.get();
1525 
1526  if (runtime)
1527  // It's possible that a language runtime can support multiple LanguageTypes,
1528  // for example, CPPLanguageRuntime will support eLanguageTypeC_plus_plus,
1529  // eLanguageTypeC_plus_plus_03, etc. Because of this, we should get the
1530  // primary language type and make sure that our runtime supports it.
1531  assert(runtime->GetLanguageType() == Language::GetPrimaryLanguage(language));
1532 
1533  return runtime;
1534 }
1535 
1537  if (m_finalizing)
1538  return false;
1539 
1540  if (in_value.IsDynamic())
1541  return false;
1542  LanguageType known_type = in_value.GetObjectRuntimeLanguage();
1543 
1544  if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC) {
1545  LanguageRuntime *runtime = GetLanguageRuntime(known_type);
1546  return runtime ? runtime->CouldHaveDynamicValue(in_value) : false;
1547  }
1548 
1549  for (LanguageRuntime *runtime : GetLanguageRuntimes()) {
1550  if (runtime->CouldHaveDynamicValue(in_value))
1551  return true;
1552  }
1553 
1554  return false;
1555 }
1556 
1558  m_dynamic_checkers_up.reset(dynamic_checkers);
1559 }
1560 
1562  return m_breakpoint_site_list;
1563 }
1564 
1566  return m_breakpoint_site_list;
1567 }
1568 
1570  m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void {
1571  // bp_site->SetEnabled(true);
1572  DisableBreakpointSite(bp_site);
1573  });
1574 }
1575 
1578 
1579  if (error.Success())
1580  m_breakpoint_site_list.Remove(break_id);
1581 
1582  return error;
1583 }
1584 
1586  Status error;
1587  BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID(break_id);
1588  if (bp_site_sp) {
1589  if (bp_site_sp->IsEnabled())
1590  error = DisableBreakpointSite(bp_site_sp.get());
1591  } else {
1592  error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64,
1593  break_id);
1594  }
1595 
1596  return error;
1597 }
1598 
1600  Status error;
1601  BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID(break_id);
1602  if (bp_site_sp) {
1603  if (!bp_site_sp->IsEnabled())
1604  error = EnableBreakpointSite(bp_site_sp.get());
1605  } else {
1606  error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64,
1607  break_id);
1608  }
1609  return error;
1610 }
1611 
1613 Process::CreateBreakpointSite(const BreakpointLocationSP &owner,
1614  bool use_hardware) {
1615  addr_t load_addr = LLDB_INVALID_ADDRESS;
1616 
1617  bool show_error = true;
1618  switch (GetState()) {
1619  case eStateInvalid:
1620  case eStateUnloaded:
1621  case eStateConnected:
1622  case eStateAttaching:
1623  case eStateLaunching:
1624  case eStateDetached:
1625  case eStateExited:
1626  show_error = false;
1627  break;
1628 
1629  case eStateStopped:
1630  case eStateRunning:
1631  case eStateStepping:
1632  case eStateCrashed:
1633  case eStateSuspended:
1634  show_error = IsAlive();
1635  break;
1636  }
1637 
1638  // Reset the IsIndirect flag here, in case the location changes from pointing
1639  // to a indirect symbol to a regular symbol.
1640  owner->SetIsIndirect(false);
1641 
1642  if (owner->ShouldResolveIndirectFunctions()) {
1643  Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
1644  if (symbol && symbol->IsIndirect()) {
1645  Status error;
1646  Address symbol_address = symbol->GetAddress();
1647  load_addr = ResolveIndirectFunction(&symbol_address, error);
1648  if (!error.Success() && show_error) {
1650  "warning: failed to resolve indirect function at 0x%" PRIx64
1651  " for breakpoint %i.%i: %s\n",
1652  symbol->GetLoadAddress(&GetTarget()),
1653  owner->GetBreakpoint().GetID(), owner->GetID(),
1654  error.AsCString() ? error.AsCString() : "unknown error");
1655  return LLDB_INVALID_BREAK_ID;
1656  }
1657  Address resolved_address(load_addr);
1658  load_addr = resolved_address.GetOpcodeLoadAddress(&GetTarget());
1659  owner->SetIsIndirect(true);
1660  } else
1661  load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget());
1662  } else
1663  load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget());
1664 
1665  if (load_addr != LLDB_INVALID_ADDRESS) {
1666  BreakpointSiteSP bp_site_sp;
1667 
1668  // Look up this breakpoint site. If it exists, then add this new owner,
1669  // otherwise create a new breakpoint site and add it.
1670 
1671  bp_site_sp = m_breakpoint_site_list.FindByAddress(load_addr);
1672 
1673  if (bp_site_sp) {
1674  bp_site_sp->AddOwner(owner);
1675  owner->SetBreakpointSite(bp_site_sp);
1676  return bp_site_sp->GetID();
1677  } else {
1678  bp_site_sp.reset(new BreakpointSite(&m_breakpoint_site_list, owner,
1679  load_addr, use_hardware));
1680  if (bp_site_sp) {
1681  Status error = EnableBreakpointSite(bp_site_sp.get());
1682  if (error.Success()) {
1683  owner->SetBreakpointSite(bp_site_sp);
1684  return m_breakpoint_site_list.Add(bp_site_sp);
1685  } else {
1686  if (show_error || use_hardware) {
1687  // Report error for setting breakpoint...
1689  "warning: failed to set breakpoint site at 0x%" PRIx64
1690  " for breakpoint %i.%i: %s\n",
1691  load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
1692  error.AsCString() ? error.AsCString() : "unknown error");
1693  }
1694  }
1695  }
1696  }
1697  }
1698  // We failed to enable the breakpoint
1699  return LLDB_INVALID_BREAK_ID;
1700 }
1701 
1703  lldb::user_id_t owner_loc_id,
1704  BreakpointSiteSP &bp_site_sp) {
1705  uint32_t num_owners = bp_site_sp->RemoveOwner(owner_id, owner_loc_id);
1706  if (num_owners == 0) {
1707  // Don't try to disable the site if we don't have a live process anymore.
1708  if (IsAlive())
1709  DisableBreakpointSite(bp_site_sp.get());
1710  m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
1711  }
1712 }
1713 
1715  uint8_t *buf) const {
1716  size_t bytes_removed = 0;
1717  BreakpointSiteList bp_sites_in_range;
1718 
1719  if (m_breakpoint_site_list.FindInRange(bp_addr, bp_addr + size,
1720  bp_sites_in_range)) {
1721  bp_sites_in_range.ForEach([bp_addr, size,
1722  buf](BreakpointSite *bp_site) -> void {
1723  if (bp_site->GetType() == BreakpointSite::eSoftware) {
1724  addr_t intersect_addr;
1725  size_t intersect_size;
1726  size_t opcode_offset;
1727  if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr,
1728  &intersect_size, &opcode_offset)) {
1729  assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
1730  assert(bp_addr < intersect_addr + intersect_size &&
1731  intersect_addr + intersect_size <= bp_addr + size);
1732  assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
1733  size_t buf_offset = intersect_addr - bp_addr;
1734  ::memcpy(buf + buf_offset,
1735  bp_site->GetSavedOpcodeBytes() + opcode_offset,
1736  intersect_size);
1737  }
1738  }
1739  });
1740  }
1741  return bytes_removed;
1742 }
1743 
1744 size_t Process::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
1745  PlatformSP platform_sp(GetTarget().GetPlatform());
1746  if (platform_sp)
1747  return platform_sp->GetSoftwareBreakpointTrapOpcode(GetTarget(), bp_site);
1748  return 0;
1749 }
1750 
1752  Status error;
1753  assert(bp_site != nullptr);
1755  const addr_t bp_addr = bp_site->GetLoadAddress();
1756  LLDB_LOGF(
1757  log, "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64,
1758  bp_site->GetID(), (uint64_t)bp_addr);
1759  if (bp_site->IsEnabled()) {
1760  LLDB_LOGF(
1761  log,
1762  "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1763  " -- already enabled",
1764  bp_site->GetID(), (uint64_t)bp_addr);
1765  return error;
1766  }
1767 
1768  if (bp_addr == LLDB_INVALID_ADDRESS) {
1769  error.SetErrorString("BreakpointSite contains an invalid load address.");
1770  return error;
1771  }
1772  // Ask the lldb::Process subclass to fill in the correct software breakpoint
1773  // trap for the breakpoint site
1774  const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
1775 
1776  if (bp_opcode_size == 0) {
1777  error.SetErrorStringWithFormat("Process::GetSoftwareBreakpointTrapOpcode() "
1778  "returned zero, unable to get breakpoint "
1779  "trap for address 0x%" PRIx64,
1780  bp_addr);
1781  } else {
1782  const uint8_t *const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
1783 
1784  if (bp_opcode_bytes == nullptr) {
1785  error.SetErrorString(
1786  "BreakpointSite doesn't contain a valid breakpoint trap opcode.");
1787  return error;
1788  }
1789 
1790  // Save the original opcode by reading it
1791  if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size,
1792  error) == bp_opcode_size) {
1793  // Write a software breakpoint in place of the original opcode
1794  if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) ==
1795  bp_opcode_size) {
1796  uint8_t verify_bp_opcode_bytes[64];
1797  if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size,
1798  error) == bp_opcode_size) {
1799  if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes,
1800  bp_opcode_size) == 0) {
1801  bp_site->SetEnabled(true);
1803  LLDB_LOGF(log,
1804  "Process::EnableSoftwareBreakpoint (site_id = %d) "
1805  "addr = 0x%" PRIx64 " -- SUCCESS",
1806  bp_site->GetID(), (uint64_t)bp_addr);
1807  } else
1808  error.SetErrorString(
1809  "failed to verify the breakpoint trap in memory.");
1810  } else
1811  error.SetErrorString(
1812  "Unable to read memory to verify breakpoint trap.");
1813  } else
1814  error.SetErrorString("Unable to write breakpoint trap to memory.");
1815  } else
1816  error.SetErrorString("Unable to read memory at breakpoint address.");
1817  }
1818  if (log && error.Fail())
1819  LLDB_LOGF(
1820  log,
1821  "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1822  " -- FAILED: %s",
1823  bp_site->GetID(), (uint64_t)bp_addr, error.AsCString());
1824  return error;
1825 }
1826 
1828  Status error;
1829  assert(bp_site != nullptr);
1831  addr_t bp_addr = bp_site->GetLoadAddress();
1832  lldb::user_id_t breakID = bp_site->GetID();
1833  LLDB_LOGF(log,
1834  "Process::DisableSoftwareBreakpoint (breakID = %" PRIu64
1835  ") addr = 0x%" PRIx64,
1836  breakID, (uint64_t)bp_addr);
1837 
1838  if (bp_site->IsHardware()) {
1839  error.SetErrorString("Breakpoint site is a hardware breakpoint.");
1840  } else if (bp_site->IsEnabled()) {
1841  const size_t break_op_size = bp_site->GetByteSize();
1842  const uint8_t *const break_op = bp_site->GetTrapOpcodeBytes();
1843  if (break_op_size > 0) {
1844  // Clear a software breakpoint instruction
1845  uint8_t curr_break_op[8];
1846  assert(break_op_size <= sizeof(curr_break_op));
1847  bool break_op_found = false;
1848 
1849  // Read the breakpoint opcode
1850  if (DoReadMemory(bp_addr, curr_break_op, break_op_size, error) ==
1851  break_op_size) {
1852  bool verify = false;
1853  // Make sure the breakpoint opcode exists at this address
1854  if (::memcmp(curr_break_op, break_op, break_op_size) == 0) {
1855  break_op_found = true;
1856  // We found a valid breakpoint opcode at this address, now restore
1857  // the saved opcode.
1858  if (DoWriteMemory(bp_addr, bp_site->GetSavedOpcodeBytes(),
1859  break_op_size, error) == break_op_size) {
1860  verify = true;
1861  } else
1862  error.SetErrorString(
1863  "Memory write failed when restoring original opcode.");
1864  } else {
1865  error.SetErrorString(
1866  "Original breakpoint trap is no longer in memory.");
1867  // Set verify to true and so we can check if the original opcode has
1868  // already been restored
1869  verify = true;
1870  }
1871 
1872  if (verify) {
1873  uint8_t verify_opcode[8];
1874  assert(break_op_size < sizeof(verify_opcode));
1875  // Verify that our original opcode made it back to the inferior
1876  if (DoReadMemory(bp_addr, verify_opcode, break_op_size, error) ==
1877  break_op_size) {
1878  // compare the memory we just read with the original opcode
1879  if (::memcmp(bp_site->GetSavedOpcodeBytes(), verify_opcode,
1880  break_op_size) == 0) {
1881  // SUCCESS
1882  bp_site->SetEnabled(false);
1883  LLDB_LOGF(log,
1884  "Process::DisableSoftwareBreakpoint (site_id = %d) "
1885  "addr = 0x%" PRIx64 " -- SUCCESS",
1886  bp_site->GetID(), (uint64_t)bp_addr);
1887  return error;
1888  } else {
1889  if (break_op_found)
1890  error.SetErrorString("Failed to restore original opcode.");
1891  }
1892  } else
1893  error.SetErrorString("Failed to read memory to verify that "
1894  "breakpoint trap was restored.");
1895  }
1896  } else
1897  error.SetErrorString(
1898  "Unable to read memory that should contain the breakpoint trap.");
1899  }
1900  } else {
1901  LLDB_LOGF(
1902  log,
1903  "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1904  " -- already disabled",
1905  bp_site->GetID(), (uint64_t)bp_addr);
1906  return error;
1907  }
1908 
1909  LLDB_LOGF(
1910  log,
1911  "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1912  " -- FAILED: %s",
1913  bp_site->GetID(), (uint64_t)bp_addr, error.AsCString());
1914  return error;
1915 }
1916 
1917 // Uncomment to verify memory caching works after making changes to caching
1918 // code
1919 //#define VERIFY_MEMORY_READS
1920 
1921 size_t Process::ReadMemory(addr_t addr, void *buf, size_t size, Status &error) {
1922  if (ABISP abi_sp = GetABI())
1923  addr = abi_sp->FixAnyAddress(addr);
1924 
1925  error.Clear();
1926  if (!GetDisableMemoryCache()) {
1927 #if defined(VERIFY_MEMORY_READS)
1928  // Memory caching is enabled, with debug verification
1929 
1930  if (buf && size) {
1931  // Uncomment the line below to make sure memory caching is working.
1932  // I ran this through the test suite and got no assertions, so I am
1933  // pretty confident this is working well. If any changes are made to
1934  // memory caching, uncomment the line below and test your changes!
1935 
1936  // Verify all memory reads by using the cache first, then redundantly
1937  // reading the same memory from the inferior and comparing to make sure
1938  // everything is exactly the same.
1939  std::string verify_buf(size, '\0');
1940  assert(verify_buf.size() == size);
1941  const size_t cache_bytes_read =
1942  m_memory_cache.Read(this, addr, buf, size, error);
1943  Status verify_error;
1944  const size_t verify_bytes_read =
1945  ReadMemoryFromInferior(addr, const_cast<char *>(verify_buf.data()),
1946  verify_buf.size(), verify_error);
1947  assert(cache_bytes_read == verify_bytes_read);
1948  assert(memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
1949  assert(verify_error.Success() == error.Success());
1950  return cache_bytes_read;
1951  }
1952  return 0;
1953 #else // !defined(VERIFY_MEMORY_READS)
1954  // Memory caching is enabled, without debug verification
1955 
1956  return m_memory_cache.Read(addr, buf, size, error);
1957 #endif // defined (VERIFY_MEMORY_READS)
1958  } else {
1959  // Memory caching is disabled
1960 
1961  return ReadMemoryFromInferior(addr, buf, size, error);
1962  }
1963 }
1964 
1966  Status &error) {
1967  char buf[256];
1968  out_str.clear();
1969  addr_t curr_addr = addr;
1970  while (true) {
1971  size_t length = ReadCStringFromMemory(curr_addr, buf, sizeof(buf), error);
1972  if (length == 0)
1973  break;
1974  out_str.append(buf, length);
1975  // If we got "length - 1" bytes, we didn't get the whole C string, we need
1976  // to read some more characters
1977  if (length == sizeof(buf) - 1)
1978  curr_addr += length;
1979  else
1980  break;
1981  }
1982  return out_str.size();
1983 }
1984 
1985 // Deprecated in favor of ReadStringFromMemory which has wchar support and
1986 // correct code to find null terminators.
1988  size_t dst_max_len,
1989  Status &result_error) {
1990  size_t total_cstr_len = 0;
1991  if (dst && dst_max_len) {
1992  result_error.Clear();
1993  // NULL out everything just to be safe
1994  memset(dst, 0, dst_max_len);
1995  Status error;
1996  addr_t curr_addr = addr;
1997  const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
1998  size_t bytes_left = dst_max_len - 1;
1999  char *curr_dst = dst;
2000 
2001  while (bytes_left > 0) {
2002  addr_t cache_line_bytes_left =
2003  cache_line_size - (curr_addr % cache_line_size);
2004  addr_t bytes_to_read =
2005  std::min<addr_t>(bytes_left, cache_line_bytes_left);
2006  size_t bytes_read = ReadMemory(curr_addr, curr_dst, bytes_to_read, error);
2007 
2008  if (bytes_read == 0) {
2009  result_error = error;
2010  dst[total_cstr_len] = '\0';
2011  break;
2012  }
2013  const size_t len = strlen(curr_dst);
2014 
2015  total_cstr_len += len;
2016 
2017  if (len < bytes_to_read)
2018  break;
2019 
2020  curr_dst += bytes_read;
2021  curr_addr += bytes_read;
2022  bytes_left -= bytes_read;
2023  }
2024  } else {
2025  if (dst == nullptr)
2026  result_error.SetErrorString("invalid arguments");
2027  else
2028  result_error.Clear();
2029  }
2030  return total_cstr_len;
2031 }
2032 
2033 size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size,
2034  Status &error) {
2036 
2037  if (ABISP abi_sp = GetABI())
2038  addr = abi_sp->FixAnyAddress(addr);
2039 
2040  if (buf == nullptr || size == 0)
2041  return 0;
2042 
2043  size_t bytes_read = 0;
2044  uint8_t *bytes = (uint8_t *)buf;
2045 
2046  while (bytes_read < size) {
2047  const size_t curr_size = size - bytes_read;
2048  const size_t curr_bytes_read =
2049  DoReadMemory(addr + bytes_read, bytes + bytes_read, curr_size, error);
2050  bytes_read += curr_bytes_read;
2051  if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2052  break;
2053  }
2054 
2055  // Replace any software breakpoint opcodes that fall into this range back
2056  // into "buf" before we return
2057  if (bytes_read > 0)
2058  RemoveBreakpointOpcodesFromBuffer(addr, bytes_read, (uint8_t *)buf);
2059  return bytes_read;
2060 }
2061 
2063  size_t integer_byte_size,
2064  uint64_t fail_value,
2065  Status &error) {
2066  Scalar scalar;
2067  if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar,
2068  error))
2069  return scalar.ULongLong(fail_value);
2070  return fail_value;
2071 }
2072 
2074  size_t integer_byte_size,
2075  int64_t fail_value,
2076  Status &error) {
2077  Scalar scalar;
2078  if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, true, scalar,
2079  error))
2080  return scalar.SLongLong(fail_value);
2081  return fail_value;
2082 }
2083 
2085  Scalar scalar;
2086  if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar,
2087  error))
2088  return scalar.ULongLong(LLDB_INVALID_ADDRESS);
2089  return LLDB_INVALID_ADDRESS;
2090 }
2091 
2093  Status &error) {
2094  Scalar scalar;
2095  const uint32_t addr_byte_size = GetAddressByteSize();
2096  if (addr_byte_size <= 4)
2097  scalar = (uint32_t)ptr_value;
2098  else
2099  scalar = ptr_value;
2100  return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) ==
2101  addr_byte_size;
2102 }
2103 
2104 size_t Process::WriteMemoryPrivate(addr_t addr, const void *buf, size_t size,
2105  Status &error) {
2106  size_t bytes_written = 0;
2107  const uint8_t *bytes = (const uint8_t *)buf;
2108 
2109  while (bytes_written < size) {
2110  const size_t curr_size = size - bytes_written;
2111  const size_t curr_bytes_written = DoWriteMemory(
2112  addr + bytes_written, bytes + bytes_written, curr_size, error);
2113  bytes_written += curr_bytes_written;
2114  if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2115  break;
2116  }
2117  return bytes_written;
2118 }
2119 
2120 size_t Process::WriteMemory(addr_t addr, const void *buf, size_t size,
2121  Status &error) {
2122  if (ABISP abi_sp = GetABI())
2123  addr = abi_sp->FixAnyAddress(addr);
2124 
2125 #if defined(ENABLE_MEMORY_CACHING)
2126  m_memory_cache.Flush(addr, size);
2127 #endif
2128 
2129  if (buf == nullptr || size == 0)
2130  return 0;
2131 
2133 
2134  // We need to write any data that would go where any current software traps
2135  // (enabled software breakpoints) any software traps (breakpoints) that we
2136  // may have placed in our tasks memory.
2137 
2138  BreakpointSiteList bp_sites_in_range;
2139  if (!m_breakpoint_site_list.FindInRange(addr, addr + size, bp_sites_in_range))
2140  return WriteMemoryPrivate(addr, buf, size, error);
2141 
2142  // No breakpoint sites overlap
2143  if (bp_sites_in_range.IsEmpty())
2144  return WriteMemoryPrivate(addr, buf, size, error);
2145 
2146  const uint8_t *ubuf = (const uint8_t *)buf;
2147  uint64_t bytes_written = 0;
2148 
2149  bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf,
2150  &error](BreakpointSite *bp) -> void {
2151  if (error.Fail())
2152  return;
2153 
2154  if (bp->GetType() != BreakpointSite::eSoftware)
2155  return;
2156 
2157  addr_t intersect_addr;
2158  size_t intersect_size;
2159  size_t opcode_offset;
2160  const bool intersects = bp->IntersectsRange(
2161  addr, size, &intersect_addr, &intersect_size, &opcode_offset);
2162  UNUSED_IF_ASSERT_DISABLED(intersects);
2163  assert(intersects);
2164  assert(addr <= intersect_addr && intersect_addr < addr + size);
2165  assert(addr < intersect_addr + intersect_size &&
2166  intersect_addr + intersect_size <= addr + size);
2167  assert(opcode_offset + intersect_size <= bp->GetByteSize());
2168 
2169  // Check for bytes before this breakpoint
2170  const addr_t curr_addr = addr + bytes_written;
2171  if (intersect_addr > curr_addr) {
2172  // There are some bytes before this breakpoint that we need to just
2173  // write to memory
2174  size_t curr_size = intersect_addr - curr_addr;
2175  size_t curr_bytes_written =
2176  WriteMemoryPrivate(curr_addr, ubuf + bytes_written, curr_size, error);
2177  bytes_written += curr_bytes_written;
2178  if (curr_bytes_written != curr_size) {
2179  // We weren't able to write all of the requested bytes, we are
2180  // done looping and will return the number of bytes that we have
2181  // written so far.
2182  if (error.Success())
2183  error.SetErrorToGenericError();
2184  }
2185  }
2186  // Now write any bytes that would cover up any software breakpoints
2187  // directly into the breakpoint opcode buffer
2188  ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written,
2189  intersect_size);
2190  bytes_written += intersect_size;
2191  });
2192 
2193  // Write any remaining bytes after the last breakpoint if we have any left
2194  if (bytes_written < size)
2195  bytes_written +=
2196  WriteMemoryPrivate(addr + bytes_written, ubuf + bytes_written,
2197  size - bytes_written, error);
2198 
2199  return bytes_written;
2200 }
2201 
2202 size_t Process::WriteScalarToMemory(addr_t addr, const Scalar &scalar,
2203  size_t byte_size, Status &error) {
2204  if (byte_size == UINT32_MAX)
2205  byte_size = scalar.GetByteSize();
2206  if (byte_size > 0) {
2207  uint8_t buf[32];
2208  const size_t mem_size =
2209  scalar.GetAsMemoryData(buf, byte_size, GetByteOrder(), error);
2210  if (mem_size > 0)
2211  return WriteMemory(addr, buf, mem_size, error);
2212  else
2213  error.SetErrorString("failed to get scalar as memory data");
2214  } else {
2215  error.SetErrorString("invalid scalar value");
2216  }
2217  return 0;
2218 }
2219 
2221  bool is_signed, Scalar &scalar,
2222  Status &error) {
2223  uint64_t uval = 0;
2224  if (byte_size == 0) {
2225  error.SetErrorString("byte size is zero");
2226  } else if (byte_size & (byte_size - 1)) {
2227  error.SetErrorStringWithFormat("byte size %u is not a power of 2",
2228  byte_size);
2229  } else if (byte_size <= sizeof(uval)) {
2230  const size_t bytes_read = ReadMemory(addr, &uval, byte_size, error);
2231  if (bytes_read == byte_size) {
2232  DataExtractor data(&uval, sizeof(uval), GetByteOrder(),
2233  GetAddressByteSize());
2234  lldb::offset_t offset = 0;
2235  if (byte_size <= 4)
2236  scalar = data.GetMaxU32(&offset, byte_size);
2237  else
2238  scalar = data.GetMaxU64(&offset, byte_size);
2239  if (is_signed)
2240  scalar.SignExtend(byte_size * 8);
2241  return bytes_read;
2242  }
2243  } else {
2244  error.SetErrorStringWithFormat(
2245  "byte size of %u is too large for integer scalar type", byte_size);
2246  }
2247  return 0;
2248 }
2249 
2250 Status Process::WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) {
2251  Status error;
2252  for (const auto &Entry : entries) {
2253  WriteMemory(Entry.Dest, Entry.Contents.data(), Entry.Contents.size(),
2254  error);
2255  if (!error.Success())
2256  break;
2257  }
2258  return error;
2259 }
2260 
2261 #define USE_ALLOCATE_MEMORY_CACHE 1
2262 addr_t Process::AllocateMemory(size_t size, uint32_t permissions,
2263  Status &error) {
2264  if (GetPrivateState() != eStateStopped) {
2265  error.SetErrorToGenericError();
2266  return LLDB_INVALID_ADDRESS;
2267  }
2268 
2269 #if defined(USE_ALLOCATE_MEMORY_CACHE)
2270  return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2271 #else
2272  addr_t allocated_addr = DoAllocateMemory(size, permissions, error);
2273  Log *log = GetLog(LLDBLog::Process);
2274  LLDB_LOGF(log,
2275  "Process::AllocateMemory(size=%" PRIu64
2276  ", permissions=%s) => 0x%16.16" PRIx64
2277  " (m_stop_id = %u m_memory_id = %u)",
2278  (uint64_t)size, GetPermissionsAsCString(permissions),
2279  (uint64_t)allocated_addr, m_mod_id.GetStopID(),
2280  m_mod_id.GetMemoryID());
2281  return allocated_addr;
2282 #endif
2283 }
2284 
2285 addr_t Process::CallocateMemory(size_t size, uint32_t permissions,
2286  Status &error) {
2287  addr_t return_addr = AllocateMemory(size, permissions, error);
2288  if (error.Success()) {
2289  std::string buffer(size, 0);
2290  WriteMemory(return_addr, buffer.c_str(), size, error);
2291  }
2292  return return_addr;
2293 }
2294 
2296  if (m_can_jit == eCanJITDontKnow) {
2297  Log *log = GetLog(LLDBLog::Process);
2298  Status err;
2299 
2300  uint64_t allocated_memory = AllocateMemory(
2301  8, ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
2302  err);
2303 
2304  if (err.Success()) {
2306  LLDB_LOGF(log,
2307  "Process::%s pid %" PRIu64
2308  " allocation test passed, CanJIT () is true",
2309  __FUNCTION__, GetID());
2310  } else {
2311  m_can_jit = eCanJITNo;
2312  LLDB_LOGF(log,
2313  "Process::%s pid %" PRIu64
2314  " allocation test failed, CanJIT () is false: %s",
2315  __FUNCTION__, GetID(), err.AsCString());
2316  }
2317 
2318  DeallocateMemory(allocated_memory);
2319  }
2320 
2321  return m_can_jit == eCanJITYes;
2322 }
2323 
2324 void Process::SetCanJIT(bool can_jit) {
2325  m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
2326 }
2327 
2328 void Process::SetCanRunCode(bool can_run_code) {
2329  SetCanJIT(can_run_code);
2330  m_can_interpret_function_calls = can_run_code;
2331 }
2332 
2334  Status error;
2335 #if defined(USE_ALLOCATE_MEMORY_CACHE)
2337  error.SetErrorStringWithFormat(
2338  "deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);
2339  }
2340 #else
2341  error = DoDeallocateMemory(ptr);
2342 
2343  Log *log = GetLog(LLDBLog::Process);
2344  LLDB_LOGF(log,
2345  "Process::DeallocateMemory(addr=0x%16.16" PRIx64
2346  ") => err = %s (m_stop_id = %u, m_memory_id = %u)",
2347  ptr, error.AsCString("SUCCESS"), m_mod_id.GetStopID(),
2348  m_mod_id.GetMemoryID());
2349 #endif
2350  return error;
2351 }
2352 
2353 ModuleSP Process::ReadModuleFromMemory(const FileSpec &file_spec,
2354  lldb::addr_t header_addr,
2355  size_t size_to_read) {
2356  Log *log = GetLog(LLDBLog::Host);
2357  if (log) {
2358  LLDB_LOGF(log,
2359  "Process::ReadModuleFromMemory reading %s binary from memory",
2360  file_spec.GetPath().c_str());
2361  }
2362  ModuleSP module_sp(new Module(file_spec, ArchSpec()));
2363  if (module_sp) {
2364  Status error;
2365  ObjectFile *objfile = module_sp->GetMemoryObjectFile(
2366  shared_from_this(), header_addr, error, size_to_read);
2367  if (objfile)
2368  return module_sp;
2369  }
2370  return ModuleSP();
2371 }
2372 
2374  uint32_t &permissions) {
2375  MemoryRegionInfo range_info;
2376  permissions = 0;
2377  Status error(GetMemoryRegionInfo(load_addr, range_info));
2378  if (!error.Success())
2379  return false;
2380  if (range_info.GetReadable() == MemoryRegionInfo::eDontKnow ||
2381  range_info.GetWritable() == MemoryRegionInfo::eDontKnow ||
2382  range_info.GetExecutable() == MemoryRegionInfo::eDontKnow) {
2383  return false;
2384  }
2385 
2386  if (range_info.GetReadable() == MemoryRegionInfo::eYes)
2387  permissions |= lldb::ePermissionsReadable;
2388 
2389  if (range_info.GetWritable() == MemoryRegionInfo::eYes)
2390  permissions |= lldb::ePermissionsWritable;
2391 
2392  if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
2393  permissions |= lldb::ePermissionsExecutable;
2394 
2395  return true;
2396 }
2397 
2398 Status Process::EnableWatchpoint(Watchpoint *watchpoint, bool notify) {
2399  Status error;
2400  error.SetErrorString("watchpoints are not supported");
2401  return error;
2402 }
2403 
2404 Status Process::DisableWatchpoint(Watchpoint *watchpoint, bool notify) {
2405  Status error;
2406  error.SetErrorString("watchpoints are not supported");
2407  return error;
2408 }
2409 
2410 StateType
2412  const Timeout<std::micro> &timeout) {
2413  StateType state;
2414 
2415  while (true) {
2416  event_sp.reset();
2417  state = GetStateChangedEventsPrivate(event_sp, timeout);
2418 
2419  if (StateIsStoppedState(state, false))
2420  break;
2421 
2422  // If state is invalid, then we timed out
2423  if (state == eStateInvalid)
2424  break;
2425 
2426  if (event_sp)
2427  HandlePrivateEvent(event_sp);
2428  }
2429  return state;
2430 }
2431 
2433  if (flush)
2434  m_thread_list.Clear();
2435  m_os_up.reset(OperatingSystem::FindPlugin(this, nullptr));
2436  if (flush)
2437  Flush();
2438 }
2439 
2441  StateType state_after_launch = eStateInvalid;
2442  EventSP first_stop_event_sp;
2443  Status status =
2444  LaunchPrivate(launch_info, state_after_launch, first_stop_event_sp);
2445  if (status.Fail())
2446  return status;
2447 
2448  if (state_after_launch != eStateStopped &&
2449  state_after_launch != eStateCrashed)
2450  return Status();
2451 
2452  // Note, the stop event was consumed above, but not handled. This
2453  // was done to give DidLaunch a chance to run. The target is either
2454  // stopped or crashed. Directly set the state. This is done to
2455  // prevent a stop message with a bunch of spurious output on thread
2456  // status, as well as not pop a ProcessIOHandler.
2457  SetPublicState(state_after_launch, false);
2458 
2461  else
2463 
2464  // Target was stopped at entry as was intended. Need to notify the
2465  // listeners about it.
2466  if (launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
2467  HandlePrivateEvent(first_stop_event_sp);
2468 
2469  return Status();
2470 }
2471 
2473  EventSP &event_sp) {
2474  Status error;
2475  m_abi_sp.reset();
2476  m_dyld_up.reset();
2477  m_jit_loaders_up.reset();
2478  m_system_runtime_up.reset();
2479  m_os_up.reset();
2480  m_process_input_reader.reset();
2481 
2482  Module *exe_module = GetTarget().GetExecutableModulePointer();
2483 
2484  // The "remote executable path" is hooked up to the local Executable
2485  // module. But we should be able to debug a remote process even if the
2486  // executable module only exists on the remote. However, there needs to
2487  // be a way to express this path, without actually having a module.
2488  // The way to do that is to set the ExecutableFile in the LaunchInfo.
2489  // Figure that out here:
2490 
2491  FileSpec exe_spec_to_use;
2492  if (!exe_module) {
2493  if (!launch_info.GetExecutableFile()) {
2494  error.SetErrorString("executable module does not exist");
2495  return error;
2496  }
2497  exe_spec_to_use = launch_info.GetExecutableFile();
2498  } else
2499  exe_spec_to_use = exe_module->GetFileSpec();
2500 
2501  if (exe_module && FileSystem::Instance().Exists(exe_module->GetFileSpec())) {
2502  // Install anything that might need to be installed prior to launching.
2503  // For host systems, this will do nothing, but if we are connected to a
2504  // remote platform it will install any needed binaries
2505  error = GetTarget().Install(&launch_info);
2506  if (error.Fail())
2507  return error;
2508  }
2509 
2510  // Listen and queue events that are broadcasted during the process launch.
2511  ListenerSP listener_sp(Listener::MakeListener("LaunchEventHijack"));
2512  HijackProcessEvents(listener_sp);
2513  auto on_exit = llvm::make_scope_exit([this]() { RestoreProcessEvents(); });
2514 
2517 
2518  error = WillLaunch(exe_module);
2519  if (error.Fail()) {
2520  std::string local_exec_file_path = exe_spec_to_use.GetPath();
2521  return Status("file doesn't exist: '%s'", local_exec_file_path.c_str());
2522  }
2523 
2524  const bool restarted = false;
2525  SetPublicState(eStateLaunching, restarted);
2526  m_should_detach = false;
2527 
2529  // Now launch using these arguments.
2530  error = DoLaunch(exe_module, launch_info);
2531  } else {
2532  // This shouldn't happen
2533  error.SetErrorString("failed to acquire process run lock");
2534  }
2535 
2536  if (error.Fail()) {
2537  if (GetID() != LLDB_INVALID_PROCESS_ID) {
2539  const char *error_string = error.AsCString();
2540  if (error_string == nullptr)
2541  error_string = "launch failed";
2542  SetExitStatus(-1, error_string);
2543  }
2544  return error;
2545  }
2546 
2547  // Now wait for the process to launch and return control to us, and then
2548  // call DidLaunch:
2549  state = WaitForProcessStopPrivate(event_sp, seconds(10));
2550 
2551  if (state == eStateInvalid || !event_sp) {
2552  // We were able to launch the process, but we failed to catch the
2553  // initial stop.
2554  error.SetErrorString("failed to catch stop after launch");
2555  SetExitStatus(0, error.AsCString());
2556  Destroy(false);
2557  return error;
2558  }
2559 
2560  if (state == eStateExited) {
2561  // We exited while trying to launch somehow. Don't call DidLaunch
2562  // as that's not likely to work, and return an invalid pid.
2563  HandlePrivateEvent(event_sp);
2564  return Status();
2565  }
2566 
2567  if (state == eStateStopped || state == eStateCrashed) {
2568  DidLaunch();
2569 
2570  // Now that we know the process type, update its signal responses from the
2571  // ones stored in the Target:
2572  if (m_unix_signals_sp) {
2573  StreamSP warning_strm = GetTarget().GetDebugger().GetAsyncErrorStream();
2575  }
2576 
2577  DynamicLoader *dyld = GetDynamicLoader();
2578  if (dyld)
2579  dyld->DidLaunch();
2580 
2582 
2583  SystemRuntime *system_runtime = GetSystemRuntime();
2584  if (system_runtime)
2585  system_runtime->DidLaunch();
2586 
2587  if (!m_os_up)
2589 
2590  // We successfully launched the process and stopped, now it the
2591  // right time to set up signal filters before resuming.
2593  return Status();
2594  }
2595 
2596  return Status("Unexpected process state after the launch: %s, expected %s, "
2597  "%s, %s or %s",
2601 }
2602 
2604  Status error = DoLoadCore();
2605  if (error.Success()) {
2606  ListenerSP listener_sp(
2607  Listener::MakeListener("lldb.process.load_core_listener"));
2608  HijackProcessEvents(listener_sp);
2609 
2612  else
2614 
2615  DynamicLoader *dyld = GetDynamicLoader();
2616  if (dyld)
2617  dyld->DidAttach();
2618 
2620 
2621  SystemRuntime *system_runtime = GetSystemRuntime();
2622  if (system_runtime)
2623  system_runtime->DidAttach();
2624 
2625  if (!m_os_up)
2627 
2628  // We successfully loaded a core file, now pretend we stopped so we can
2629  // show all of the threads in the core file and explore the crashed state.
2631 
2632  // Wait for a stopped event since we just posted one above...
2633  lldb::EventSP event_sp;
2634  StateType state =
2635  WaitForProcessToStop(llvm::None, &event_sp, true, listener_sp);
2636 
2637  if (!StateIsStoppedState(state, false)) {
2638  Log *log = GetLog(LLDBLog::Process);
2639  LLDB_LOGF(log, "Process::Halt() failed to stop, state is: %s",
2640  StateAsCString(state));
2641  error.SetErrorString(
2642  "Did not get stopped event after loading the core file.");
2643  }
2645  }
2646  return error;
2647 }
2648 
2650  if (!m_dyld_up)
2651  m_dyld_up.reset(DynamicLoader::FindPlugin(this, ""));
2652  return m_dyld_up.get();
2653 }
2654 
2656 
2657 llvm::Expected<bool> Process::SaveCore(llvm::StringRef outfile) {
2658  return false;
2659 }
2660 
2662  if (!m_jit_loaders_up) {
2663  m_jit_loaders_up = std::make_unique<JITLoaderList>();
2665  }
2666  return *m_jit_loaders_up;
2667 }
2668 
2670  if (!m_system_runtime_up)
2672  return m_system_runtime_up.get();
2673 }
2674 
2676  uint32_t exec_count)
2677  : NextEventAction(process), m_exec_count(exec_count) {
2678  Log *log = GetLog(LLDBLog::Process);
2679  LLDB_LOGF(
2680  log,
2681  "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32,
2682  __FUNCTION__, static_cast<void *>(process), exec_count);
2683 }
2684 
2687  Log *log = GetLog(LLDBLog::Process);
2688 
2689  StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
2690  LLDB_LOGF(log,
2691  "Process::AttachCompletionHandler::%s called with state %s (%d)",
2692  __FUNCTION__, StateAsCString(state), static_cast<int>(state));
2693 
2694  switch (state) {
2695  case eStateAttaching:
2696  return eEventActionSuccess;
2697 
2698  case eStateRunning:
2699  case eStateConnected:
2700  return eEventActionRetry;
2701 
2702  case eStateStopped:
2703  case eStateCrashed:
2704  // During attach, prior to sending the eStateStopped event,
2705  // lldb_private::Process subclasses must set the new process ID.
2706  assert(m_process->GetID() != LLDB_INVALID_PROCESS_ID);
2707  // We don't want these events to be reported, so go set the
2708  // ShouldReportStop here:
2710 
2711  if (m_exec_count > 0) {
2712  --m_exec_count;
2713 
2714  LLDB_LOGF(log,
2715  "Process::AttachCompletionHandler::%s state %s: reduced "
2716  "remaining exec count to %" PRIu32 ", requesting resume",
2717  __FUNCTION__, StateAsCString(state), m_exec_count);
2718 
2719  RequestResume();
2720  return eEventActionRetry;
2721  } else {
2722  LLDB_LOGF(log,
2723  "Process::AttachCompletionHandler::%s state %s: no more "
2724  "execs expected to start, continuing with attach",
2725  __FUNCTION__, StateAsCString(state));
2726 
2728  return eEventActionSuccess;
2729  }
2730  break;
2731 
2732  default:
2733  case eStateExited:
2734  case eStateInvalid:
2735  break;
2736  }
2737 
2738  m_exit_string.assign("No valid Process");
2739  return eEventActionExit;
2740 }
2741 
2744  return eEventActionSuccess;
2745 }
2746 
2748  return m_exit_string.c_str();
2749 }
2750 
2752  if (m_listener_sp)
2753  return m_listener_sp;
2754  else
2755  return debugger.GetListener();
2756 }
2757 
2759  m_abi_sp.reset();
2760  m_process_input_reader.reset();
2761  m_dyld_up.reset();
2762  m_jit_loaders_up.reset();
2763  m_system_runtime_up.reset();
2764  m_os_up.reset();
2765 
2766  lldb::pid_t attach_pid = attach_info.GetProcessID();
2767  Status error;
2768  if (attach_pid == LLDB_INVALID_PROCESS_ID) {
2769  char process_name[PATH_MAX];
2770 
2771  if (attach_info.GetExecutableFile().GetPath(process_name,
2772  sizeof(process_name))) {
2773  const bool wait_for_launch = attach_info.GetWaitForLaunch();
2774 
2775  if (wait_for_launch) {
2776  error = WillAttachToProcessWithName(process_name, wait_for_launch);
2777  if (error.Success()) {
2779  m_should_detach = true;
2780  const bool restarted = false;
2781  SetPublicState(eStateAttaching, restarted);
2782  // Now attach using these arguments.
2783  error = DoAttachToProcessWithName(process_name, attach_info);
2784  } else {
2785  // This shouldn't happen
2786  error.SetErrorString("failed to acquire process run lock");
2787  }
2788 
2789  if (error.Fail()) {
2790  if (GetID() != LLDB_INVALID_PROCESS_ID) {
2792  if (error.AsCString() == nullptr)
2793  error.SetErrorString("attach failed");
2794 
2795  SetExitStatus(-1, error.AsCString());
2796  }
2797  } else {
2799  this, attach_info.GetResumeCount()));
2801  }
2802  return error;
2803  }
2804  } else {
2805  ProcessInstanceInfoList process_infos;
2806  PlatformSP platform_sp(GetTarget().GetPlatform());
2807 
2808  if (platform_sp) {
2809  ProcessInstanceInfoMatch match_info;
2810  match_info.GetProcessInfo() = attach_info;
2811  match_info.SetNameMatchType(NameMatch::Equals);
2812  platform_sp->FindProcesses(match_info, process_infos);
2813  const uint32_t num_matches = process_infos.size();
2814  if (num_matches == 1) {
2815  attach_pid = process_infos[0].GetProcessID();
2816  // Fall through and attach using the above process ID
2817  } else {
2818  match_info.GetProcessInfo().GetExecutableFile().GetPath(
2819  process_name, sizeof(process_name));
2820  if (num_matches > 1) {
2821  StreamString s;
2822  ProcessInstanceInfo::DumpTableHeader(s, true, false);
2823  for (size_t i = 0; i < num_matches; i++) {
2824  process_infos[i].DumpAsTableRow(
2825  s, platform_sp->GetUserIDResolver(), true, false);
2826  }
2827  error.SetErrorStringWithFormat(
2828  "more than one process named %s:\n%s", process_name,
2829  s.GetData());
2830  } else
2831  error.SetErrorStringWithFormat(
2832  "could not find a process named %s", process_name);
2833  }
2834  } else {
2835  error.SetErrorString(
2836  "invalid platform, can't find processes by name");
2837  return error;
2838  }
2839  }
2840  } else {
2841  error.SetErrorString("invalid process name");
2842  }
2843  }
2844 
2845  if (attach_pid != LLDB_INVALID_PROCESS_ID) {
2846  error = WillAttachToProcessWithID(attach_pid);
2847  if (error.Success()) {
2848 
2850  // Now attach using these arguments.
2851  m_should_detach = true;
2852  const bool restarted = false;
2853  SetPublicState(eStateAttaching, restarted);
2854  error = DoAttachToProcessWithID(attach_pid, attach_info);
2855  } else {
2856  // This shouldn't happen
2857  error.SetErrorString("failed to acquire process run lock");
2858  }
2859 
2860  if (error.Success()) {
2862  this, attach_info.GetResumeCount()));
2864  } else {
2865  if (GetID() != LLDB_INVALID_PROCESS_ID)
2867 
2868  const char *error_string = error.AsCString();
2869  if (error_string == nullptr)
2870  error_string = "attach failed";
2871 
2872  SetExitStatus(-1, error_string);
2873  }
2874  }
2875  }
2876  return error;
2877 }
2878 
2881  LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
2882 
2883  // Let the process subclass figure out at much as it can about the process
2884  // before we go looking for a dynamic loader plug-in.
2885  ArchSpec process_arch;
2886  DidAttach(process_arch);
2887 
2888  if (process_arch.IsValid()) {
2889  GetTarget().SetArchitecture(process_arch);
2890  if (log) {
2891  const char *triple_str = process_arch.GetTriple().getTriple().c_str();
2892  LLDB_LOGF(log,
2893  "Process::%s replacing process architecture with DidAttach() "
2894  "architecture: %s",
2895  __FUNCTION__, triple_str ? triple_str : "<null>");
2896  }
2897  }
2898 
2899  // We just attached. If we have a platform, ask it for the process
2900  // architecture, and if it isn't the same as the one we've already set,
2901  // switch architectures.
2902  PlatformSP platform_sp(GetTarget().GetPlatform());
2903  assert(platform_sp);
2904  ArchSpec process_host_arch = GetSystemArchitecture();
2905  if (platform_sp) {
2906  const ArchSpec &target_arch = GetTarget().GetArchitecture();
2907  if (target_arch.IsValid() &&
2908  !platform_sp->IsCompatibleArchitecture(target_arch, process_host_arch,
2909  false, nullptr)) {
2910  ArchSpec platform_arch;
2911  platform_sp = GetTarget().GetDebugger().GetPlatformList().GetOrCreate(
2912  target_arch, process_host_arch, &platform_arch);
2913  if (platform_sp) {
2914  GetTarget().SetPlatform(platform_sp);
2915  GetTarget().SetArchitecture(platform_arch);
2916  LLDB_LOG(log,
2917  "switching platform to {0} and architecture to {1} based on "
2918  "info from attach",
2919  platform_sp->GetName(), platform_arch.GetTriple().getTriple());
2920  }
2921  } else if (!process_arch.IsValid()) {
2922  ProcessInstanceInfo process_info;
2923  GetProcessInfo(process_info);
2924  const ArchSpec &process_arch = process_info.GetArchitecture();
2925  const ArchSpec &target_arch = GetTarget().GetArchitecture();
2926  if (process_arch.IsValid() &&
2927  target_arch.IsCompatibleMatch(process_arch) &&
2928  !target_arch.IsExactMatch(process_arch)) {
2929  GetTarget().SetArchitecture(process_arch);
2930  LLDB_LOGF(log,
2931  "Process::%s switching architecture to %s based on info "
2932  "the platform retrieved for pid %" PRIu64,
2933  __FUNCTION__, process_arch.GetTriple().getTriple().c_str(),
2934  GetID());
2935  }
2936  }
2937  }
2938  // Now that we know the process type, update its signal responses from the
2939  // ones stored in the Target:
2940  if (m_unix_signals_sp) {
2941  StreamSP warning_strm = GetTarget().GetDebugger().GetAsyncErrorStream();
2943  }
2944 
2945  // We have completed the attach, now it is time to find the dynamic loader
2946  // plug-in
2947  DynamicLoader *dyld = GetDynamicLoader();
2948  if (dyld) {
2949  dyld->DidAttach();
2950  if (log) {
2951  ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
2952  LLDB_LOG(log,
2953  "after DynamicLoader::DidAttach(), target "
2954  "executable is {0} (using {1} plugin)",
2955  exe_module_sp ? exe_module_sp->GetFileSpec() : FileSpec(),
2956  dyld->GetPluginName());
2957  }
2958  }
2959 
2961 
2962  SystemRuntime *system_runtime = GetSystemRuntime();
2963  if (system_runtime) {
2964  system_runtime->DidAttach();
2965  if (log) {
2966  ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
2967  LLDB_LOG(log,
2968  "after SystemRuntime::DidAttach(), target "
2969  "executable is {0} (using {1} plugin)",
2970  exe_module_sp ? exe_module_sp->GetFileSpec() : FileSpec(),
2971  system_runtime->GetPluginName());
2972  }
2973  }
2974 
2975  if (!m_os_up) {
2977  if (m_os_up) {
2978  // Somebody might have gotten threads before now, but we need to force the
2979  // update after we've loaded the OperatingSystem plugin or it won't get a
2980  // chance to process the threads.
2981  m_thread_list.Clear();
2983  }
2984  }
2985  // Figure out which one is the executable, and set that in our target:
2986  ModuleSP new_executable_module_sp;
2987  for (ModuleSP module_sp : GetTarget().GetImages().Modules()) {
2988  if (module_sp && module_sp->IsExecutable()) {
2989  if (GetTarget().GetExecutableModulePointer() != module_sp.get())
2990  new_executable_module_sp = module_sp;
2991  break;
2992  }
2993  }
2994  if (new_executable_module_sp) {
2995  GetTarget().SetExecutableModule(new_executable_module_sp,
2997  if (log) {
2998  ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
2999  LLDB_LOGF(
3000  log,
3001  "Process::%s after looping through modules, target executable is %s",
3002  __FUNCTION__,
3003  exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
3004  : "<none>");
3005  }
3006  }
3007 }
3008 
3009 Status Process::ConnectRemote(llvm::StringRef remote_url) {
3010  m_abi_sp.reset();
3011  m_process_input_reader.reset();
3012 
3013  // Find the process and its architecture. Make sure it matches the
3014  // architecture of the current Target, and if not adjust it.
3015 
3016  Status error(DoConnectRemote(remote_url));
3017  if (error.Success()) {
3018  if (GetID() != LLDB_INVALID_PROCESS_ID) {
3019  EventSP event_sp;
3020  StateType state = WaitForProcessStopPrivate(event_sp, llvm::None);
3021 
3022  if (state == eStateStopped || state == eStateCrashed) {
3023  // If we attached and actually have a process on the other end, then
3024  // this ended up being the equivalent of an attach.
3025  CompleteAttach();
3026 
3027  // This delays passing the stopped event to listeners till
3028  // CompleteAttach gets a chance to complete...
3029  HandlePrivateEvent(event_sp);
3030  }
3031  }
3032 
3035  else
3037  }
3038  return error;
3039 }
3040 
3043  LLDB_LOGF(log,
3044  "Process::PrivateResume() m_stop_id = %u, public state: %s "
3045  "private state: %s",
3048 
3049  // If signals handing status changed we might want to update our signal
3050  // filters before resuming.
3052 
3053  Status error(WillResume());
3054  // Tell the process it is about to resume before the thread list
3055  if (error.Success()) {
3056  // Now let the thread list know we are about to resume so it can let all of
3057  // our threads know that they are about to be resumed. Threads will each be
3058  // called with Thread::WillResume(StateType) where StateType contains the
3059  // state that they are supposed to have when the process is resumed
3060  // (suspended/running/stepping). Threads should also check their resume
3061  // signal in lldb::Thread::GetResumeSignal() to see if they are supposed to
3062  // start back up with a signal.
3063  if (m_thread_list.WillResume()) {
3064  // Last thing, do the PreResumeActions.
3065  if (!RunPreResumeActions()) {
3066  error.SetErrorString(
3067  "Process::PrivateResume PreResumeActions failed, not resuming.");
3068  } else {
3070  error = DoResume();
3071  if (error.Success()) {
3072  DidResume();
3074  LLDB_LOGF(log, "Process thinks the process has resumed.");
3075  } else {
3076  LLDB_LOGF(log, "Process::PrivateResume() DoResume failed.");
3077  return error;
3078  }
3079  }
3080  } else {
3081  // Somebody wanted to run without running (e.g. we were faking a step
3082  // from one frame of a set of inlined frames that share the same PC to
3083  // another.) So generate a continue & a stopped event, and let the world
3084  // handle them.
3085  LLDB_LOGF(log,
3086  "Process::PrivateResume() asked to simulate a start & stop.");
3087 
3090  }
3091  } else
3092  LLDB_LOGF(log, "Process::PrivateResume() got an error \"%s\".",
3093  error.AsCString("<unknown error>"));
3094  return error;
3095 }
3096 
3097 Status Process::Halt(bool clear_thread_plans, bool use_run_lock) {
3099  return Status("Process is not running.");
3100 
3101  // Don't clear the m_clear_thread_plans_on_stop, only set it to true if in
3102  // case it was already set and some thread plan logic calls halt on its own.
3103  m_clear_thread_plans_on_stop |= clear_thread_plans;
3104 
3105  ListenerSP halt_listener_sp(
3106  Listener::MakeListener("lldb.process.halt_listener"));
3107  HijackProcessEvents(halt_listener_sp);
3108 
3109  EventSP event_sp;
3110 
3112 
3114  // Don't hijack and eat the eStateExited as the code that was doing the
3115  // attach will be waiting for this event...
3117  SetExitStatus(SIGKILL, "Cancelled async attach.");
3118  Destroy(false);
3119  return Status();
3120  }
3121 
3122  // Wait for the process halt timeout seconds for the process to stop.
3123  StateType state =
3124  WaitForProcessToStop(GetInterruptTimeout(), &event_sp, true,
3125  halt_listener_sp, nullptr, use_run_lock);
3127 
3128  if (state == eStateInvalid || !event_sp) {
3129  // We timed out and didn't get a stop event...
3130  return Status("Halt timed out. State = %s", StateAsCString(GetState()));
3131  }
3132 
3133  BroadcastEvent(event_sp);
3134 
3135  return Status();
3136 }
3137 
3138 Status Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
3139  Status error;
3140 
3141  // Check both the public & private states here. If we're hung evaluating an
3142  // expression, for instance, then the public state will be stopped, but we
3143  // still need to interrupt.
3146  Log *log = GetLog(LLDBLog::Process);
3147  LLDB_LOGF(log, "Process::%s() About to stop.", __FUNCTION__);
3148 
3149  ListenerSP listener_sp(
3150  Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack"));
3151  HijackProcessEvents(listener_sp);
3152 
3154 
3155  // Consume the interrupt event.
3157  &exit_event_sp, true, listener_sp);
3158 
3160 
3161  // If the process exited while we were waiting for it to stop, put the
3162  // exited event into the shared pointer passed in and return. Our caller
3163  // doesn't need to do anything else, since they don't have a process
3164  // anymore...
3165 
3166  if (state == eStateExited || m_private_state.GetValue() == eStateExited) {
3167  LLDB_LOGF(log, "Process::%s() Process exited while waiting to stop.",
3168  __FUNCTION__);
3169  return error;
3170  } else
3171  exit_event_sp.reset(); // It is ok to consume any non-exit stop events
3172 
3173  if (state != eStateStopped) {
3174  LLDB_LOGF(log, "Process::%s() failed to stop, state is: %s", __FUNCTION__,
3175  StateAsCString(state));
3176  // If we really couldn't stop the process then we should just error out
3177  // here, but if the lower levels just bobbled sending the event and we
3178  // really are stopped, then continue on.
3179  StateType private_state = m_private_state.GetValue();
3180  if (private_state != eStateStopped) {
3181  return Status(
3182  "Attempt to stop the target in order to detach timed out. "
3183  "State = %s",
3185  }
3186  }
3187  }
3188  return error;
3189 }
3190 
3191 Status Process::Detach(bool keep_stopped) {
3192  EventSP exit_event_sp;
3193  Status error;
3194  m_destroy_in_process = true;
3195 
3196  error = WillDetach();
3197 
3198  if (error.Success()) {
3199  if (DetachRequiresHalt()) {
3200  error = StopForDestroyOrDetach(exit_event_sp);
3201  if (!error.Success()) {
3202  m_destroy_in_process = false;
3203  return error;
3204  } else if (exit_event_sp) {
3205  // We shouldn't need to do anything else here. There's no process left
3206  // to detach from...
3208  m_destroy_in_process = false;
3209  return error;
3210  }
3211  }
3212 
3215 
3216  error = DoDetach(keep_stopped);
3217  if (error.Success()) {
3218  DidDetach();
3220  } else {
3221  return error;
3222  }
3223  }
3224  m_destroy_in_process = false;
3225 
3226  // If we exited when we were waiting for a process to stop, then forward the
3227  // event here so we don't lose the event
3228  if (exit_event_sp) {
3229  // Directly broadcast our exited event because we shut down our private
3230  // state thread above
3231  BroadcastEvent(exit_event_sp);
3232  }
3233 
3234  // If we have been interrupted (to kill us) in the middle of running, we may
3235  // not end up propagating the last events through the event system, in which
3236  // case we might strand the write lock. Unlock it here so when we do to tear
3237  // down the process we don't get an error destroying the lock.
3238 
3240  return error;
3241 }
3242 
3243 Status Process::Destroy(bool force_kill) {
3244  // If we've already called Process::Finalize then there's nothing useful to
3245  // be done here. Finalize has actually called Destroy already.
3246  if (m_finalizing)
3247  return {};
3248  return DestroyImpl(force_kill);
3249 }
3250 
3251 Status Process::DestroyImpl(bool force_kill) {
3252  // Tell ourselves we are in the process of destroying the process, so that we
3253  // don't do any unnecessary work that might hinder the destruction. Remember
3254  // to set this back to false when we are done. That way if the attempt
3255  // failed and the process stays around for some reason it won't be in a
3256  // confused state.
3257 
3258  if (force_kill)
3259  m_should_detach = false;
3260 
3261  if (GetShouldDetach()) {
3262  // FIXME: This will have to be a process setting:
3263  bool keep_stopped = false;
3264  Detach(keep_stopped);
3265  }
3266 
3267  m_destroy_in_process = true;
3268 
3270  if (error.Success()) {
3271  EventSP exit_event_sp;
3272  if (DestroyRequiresHalt()) {
3273  error = StopForDestroyOrDetach(exit_event_sp);
3274  }
3275 
3277  // Ditch all thread plans, and remove all our breakpoints: in case we
3278  // have to restart the target to kill it, we don't want it hitting a
3279  // breakpoint... Only do this if we've stopped, however, since if we
3280  // didn't manage to halt it above, then we're not going to have much luck
3281  // doing this now.
3284  }
3285 
3286  error = DoDestroy();
3287  if (error.Success()) {
3288  DidDestroy();
3290  }
3293  m_stdin_forward = false;
3294 
3295  if (m_process_input_reader) {
3296  m_process_input_reader->SetIsDone(true);
3297  m_process_input_reader->Cancel();
3298  m_process_input_reader.reset();
3299  }
3300 
3301  // If we exited when we were waiting for a process to stop, then forward
3302  // the event here so we don't lose the event
3303  if (exit_event_sp) {
3304  // Directly broadcast our exited event because we shut down our private
3305  // state thread above
3306  BroadcastEvent(exit_event_sp);
3307  }
3308 
3309  // If we have been interrupted (to kill us) in the middle of running, we
3310  // may not end up propagating the last events through the event system, in
3311  // which case we might strand the write lock. Unlock it here so when we do
3312  // to tear down the process we don't get an error destroying the lock.
3314  }
3315 
3316  m_destroy_in_process = false;
3317 
3318  return error;
3319 }
3320 
3322  Status error(WillSignal());
3323  if (error.Success()) {
3324  error = DoSignal(signal);
3325  if (error.Success())
3326  DidSignal();
3327  }
3328  return error;
3329 }
3330 
3331 void Process::SetUnixSignals(UnixSignalsSP &&signals_sp) {
3332  assert(signals_sp && "null signals_sp");
3333  m_unix_signals_sp = signals_sp;
3334 }
3335 
3336 const lldb::UnixSignalsSP &Process::GetUnixSignals() {
3337  assert(m_unix_signals_sp && "null m_unix_signals_sp");
3338  return m_unix_signals_sp;
3339 }
3340 
3342  return GetTarget().GetArchitecture().GetByteOrder();
3343 }
3344 
3347 }
3348 
3350  const StateType state =
3352  bool return_value = true;
3354 
3355  switch (state) {
3356  case eStateDetached:
3357  case eStateExited:
3358  case eStateUnloaded:
3362  m_stdin_forward = false;
3363 
3364  LLVM_FALLTHROUGH;
3365  case eStateConnected:
3366  case eStateAttaching:
3367  case eStateLaunching:
3368  // These events indicate changes in the state of the debugging session,
3369  // always report them.
3370  return_value = true;
3371  break;
3372  case eStateInvalid:
3373  // We stopped for no apparent reason, don't report it.
3374  return_value = false;
3375  break;
3376  case eStateRunning:
3377  case eStateStepping:
3378  // If we've started the target running, we handle the cases where we are
3379  // already running and where there is a transition from stopped to running
3380  // differently. running -> running: Automatically suppress extra running
3381  // events stopped -> running: Report except when there is one or more no
3382  // votes
3383  // and no yes votes.
3386  return_value = true;
3387  else {
3388  switch (m_last_broadcast_state) {
3389  case eStateRunning:
3390  case eStateStepping:
3391  // We always suppress multiple runnings with no PUBLIC stop in between.
3392  return_value = false;
3393  break;
3394  default:
3395  // TODO: make this work correctly. For now always report
3396  // run if we aren't running so we don't miss any running events. If I
3397  // run the lldb/test/thread/a.out file and break at main.cpp:58, run
3398  // and hit the breakpoints on multiple threads, then somehow during the
3399  // stepping over of all breakpoints no run gets reported.
3400 
3401  // This is a transition from stop to run.
3402  switch (m_thread_list.ShouldReportRun(event_ptr)) {
3403  case eVoteYes:
3404  case eVoteNoOpinion:
3405  return_value = true;
3406  break;
3407  case eVoteNo:
3408  return_value = false;
3409  break;
3410  }
3411  break;
3412  }
3413  }
3414  break;
3415  case eStateStopped:
3416  case eStateCrashed:
3417  case eStateSuspended:
3418  // We've stopped. First see if we're going to restart the target. If we
3419  // are going to stop, then we always broadcast the event. If we aren't
3420  // going to stop, let the thread plans decide if we're going to report this
3421  // event. If no thread has an opinion, we don't report it.
3422 
3426  LLDB_LOGF(log,
3427  "Process::ShouldBroadcastEvent (%p) stopped due to an "
3428  "interrupt, state: %s",
3429  static_cast<void *>(event_ptr), StateAsCString(state));
3430  // Even though we know we are going to stop, we should let the threads
3431  // have a look at the stop, so they can properly set their state.
3432  m_thread_list.ShouldStop(event_ptr);
3433  return_value = true;
3434  } else {
3435  bool was_restarted = ProcessEventData::GetRestartedFromEvent(event_ptr);
3436  bool should_resume = false;
3437 
3438  // It makes no sense to ask "ShouldStop" if we've already been
3439  // restarted... Asking the thread list is also not likely to go well,
3440  // since we are running again. So in that case just report the event.
3441 
3442  if (!was_restarted)
3443  should_resume = !m_thread_list.ShouldStop(event_ptr);
3444 
3445  if (was_restarted || should_resume || m_resume_requested) {
3446  Vote report_stop_vote = m_thread_list.ShouldReportStop(event_ptr);
3447  LLDB_LOGF(log,
3448  "Process::ShouldBroadcastEvent: should_resume: %i state: "
3449  "%s was_restarted: %i report_stop_vote: %d.",
3450  should_resume, StateAsCString(state), was_restarted,
3451  report_stop_vote);
3452 
3453  switch (report_stop_vote) {
3454  case eVoteYes:
3455  return_value = true;
3456  break;
3457  case eVoteNoOpinion:
3458  case eVoteNo:
3459  return_value = false;
3460  break;
3461  }
3462 
3463  if (!was_restarted) {
3464  LLDB_LOGF(log,
3465  "Process::ShouldBroadcastEvent (%p) Restarting process "
3466  "from state: %s",
3467  static_cast<void *>(event_ptr), StateAsCString(state));
3468  ProcessEventData::SetRestartedInEvent(event_ptr, true);
3469  PrivateResume();
3470  }
3471  } else {
3472  return_value = true;
3474  }
3475  }
3476  break;
3477  }
3478 
3479  // Forcing the next event delivery is a one shot deal. So reset it here.
3481 
3482  // We do some coalescing of events (for instance two consecutive running
3483  // events get coalesced.) But we only coalesce against events we actually
3484  // broadcast. So we use m_last_broadcast_state to track that. NB - you
3485  // can't use "m_public_state.GetValue()" for that purpose, as was originally
3486  // done, because the PublicState reflects the last event pulled off the
3487  // queue, and there may be several events stacked up on the queue unserviced.
3488  // So the PublicState may not reflect the last broadcasted event yet.
3489  // m_last_broadcast_state gets updated here.
3490 
3491  if (return_value)
3492  m_last_broadcast_state = state;
3493 
3494  LLDB_LOGF(log,
3495  "Process::ShouldBroadcastEvent (%p) => new state: %s, last "
3496  "broadcast state: %s - %s",
3497  static_cast<void *>(event_ptr), StateAsCString(state),
3499  return_value ? "YES" : "NO");
3500  return return_value;
3501 }
3502 
3503 bool Process::StartPrivateStateThread(bool is_secondary_thread) {
3504  Log *log = GetLog(LLDBLog::Events);
3505 
3506  bool already_running = PrivateStateThreadIsValid();
3507  LLDB_LOGF(log, "Process::%s()%s ", __FUNCTION__,
3508  already_running ? " already running"
3509  : " starting private state thread");
3510 
3511  if (!is_secondary_thread && already_running)
3512  return true;
3513 
3514  // Create a thread that watches our internal state and controls which events
3515  // make it to clients (into the DCProcess event queue).
3516  char thread_name[1024];
3517  uint32_t max_len = llvm::get_max_thread_name_length();
3518  if (max_len > 0 && max_len <= 30) {
3519  // On platforms with abbreviated thread name lengths, choose thread names
3520  // that fit within the limit.
3521  if (already_running)
3522  snprintf(thread_name, sizeof(thread_name), "intern-state-OV");
3523  else
3524  snprintf(thread_name, sizeof(thread_name), "intern-state");
3525  } else {
3526  if (already_running)
3527  snprintf(thread_name, sizeof(thread_name),
3528  "<lldb.process.internal-state-override(pid=%" PRIu64 ")>",
3529  GetID());
3530  else
3531  snprintf(thread_name, sizeof(thread_name),
3532  "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
3533  }
3534 
3535  llvm::Expected<HostThread> private_state_thread =
3537  thread_name,
3538  [this, is_secondary_thread] {
3539  return RunPrivateStateThread(is_secondary_thread);
3540  },
3541  8 * 1024 * 1024);
3542  if (!private_state_thread) {
3543  LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",
3544  llvm::toString(private_state_thread.takeError()));
3545  return false;
3546  }
3547 
3548  assert(private_state_thread->IsJoinable());
3549  m_private_state_thread = *private_state_thread;
3551  return true;
3552 }
3553 
3556 }
3557 
3560 }
3561 
3565  else {
3566  Log *log = GetLog(LLDBLog::Process);
3567  LLDB_LOGF(
3568  log,
3569  "Went to stop the private state thread, but it was already invalid.");
3570  }
3571 }
3572 
3574  Log *log = GetLog(LLDBLog::Process);
3575 
3576  assert(signal == eBroadcastInternalStateControlStop ||
3579 
3580  LLDB_LOGF(log, "Process::%s (signal = %d)", __FUNCTION__, signal);
3581 
3582  // Signal the private state thread
3584  // Broadcast the event.
3585  // It is important to do this outside of the if below, because it's
3586  // possible that the thread state is invalid but that the thread is waiting
3587  // on a control event instead of simply being on its way out (this should
3588  // not happen, but it apparently can).
3589  LLDB_LOGF(log, "Sending control event of type: %d.", signal);
3590  std::shared_ptr<EventDataReceipt> event_receipt_sp(new EventDataReceipt());
3592  event_receipt_sp);
3593 
3594  // Wait for the event receipt or for the private state thread to exit
3595  bool receipt_received = false;
3596  if (PrivateStateThreadIsValid()) {
3597  while (!receipt_received) {
3598  // Check for a receipt for n seconds and then check if the private
3599  // state thread is still around.
3600  receipt_received =
3601  event_receipt_sp->WaitForEventReceived(GetUtilityExpressionTimeout());
3602  if (!receipt_received) {
3603  // Check if the private state thread is still around. If it isn't
3604  // then we are done waiting
3606  break; // Private state thread exited or is exiting, we are done
3607  }
3608  }
3609  }
3610 
3611  if (signal == eBroadcastInternalStateControlStop) {
3612  thread_result_t result = {};
3613  m_private_state_thread.Join(&result);
3615  }
3616  } else {
3617  LLDB_LOGF(
3618  log,
3619  "Private state thread already dead, no need to signal it to stop.");
3620  }
3621 }
3622 
3626  nullptr);
3627  else
3629 }
3630 
3631 void Process::HandlePrivateEvent(EventSP &event_sp) {
3632  Log *log = GetLog(LLDBLog::Process);
3633  m_resume_requested = false;
3634 
3635  const StateType new_state =
3637 
3638  // First check to see if anybody wants a shot at this event:
3639  if (m_next_event_action_up) {
3640  NextEventAction::EventActionResult action_result =
3641  m_next_event_action_up->PerformAction(event_sp);
3642  LLDB_LOGF(log, "Ran next event action, result was %d.", action_result);
3643 
3644  switch (action_result) {
3646  SetNextEventAction(nullptr);
3647  break;
3648 
3650  break;
3651 
3653  // Handle Exiting Here. If we already got an exited event, we should
3654  // just propagate it. Otherwise, swallow this event, and set our state
3655  // to exit so the next event will kill us.
3656  if (new_state != eStateExited) {
3657  // FIXME: should cons up an exited event, and discard this one.
3658  SetExitStatus(0, m_next_event_action_up->GetExitString());
3659  SetNextEventAction(nullptr);
3660  return;
3661  }
3662  SetNextEventAction(nullptr);
3663  break;
3664  }
3665  }
3666 
3667  // See if we should broadcast this state to external clients?
3668  const bool should_broadcast = ShouldBroadcastEvent(event_sp.get());
3669 
3670  if (should_broadcast) {
3671  const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged);
3672  if (log) {
3673  LLDB_LOGF(log,
3674  "Process::%s (pid = %" PRIu64
3675  ") broadcasting new state %s (old state %s) to %s",
3676  __FUNCTION__, GetID(), StateAsCString(new_state),
3678  is_hijacked ? "hijacked" : "public");
3679  }
3681  if (StateIsRunningState(new_state)) {
3682  // Only push the input handler if we aren't fowarding events, as this
3683  // means the curses GUI is in use... Or don't push it if we are launching
3684  // since it will come up stopped.
3685  if (!GetTarget().GetDebugger().IsForwardingEvents() &&
3686  new_state != eStateLaunching && new_state != eStateAttaching) {
3690  LLDB_LOGF(log, "Process::%s updated m_iohandler_sync to %d",
3691  __FUNCTION__, m_iohandler_sync.GetValue());
3692  }
3693  } else if (StateIsStoppedState(new_state, false)) {
3694  if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
3695  // If the lldb_private::Debugger is handling the events, we don't want
3696  // to pop the process IOHandler here, we want to do it when we receive
3697  // the stopped event so we can carefully control when the process
3698  // IOHandler is popped because when we stop we want to display some
3699  // text stating how and why we stopped, then maybe some
3700  // process/thread/frame info, and then we want the "(lldb) " prompt to
3701  // show up. If we pop the process IOHandler here, then we will cause
3702  // the command interpreter to become the top IOHandler after the
3703  // process pops off and it will update its prompt right away... See the
3704  // Debugger.cpp file where it calls the function as
3705  // "process_sp->PopProcessIOHandler()" to see where I am talking about.
3706  // Otherwise we end up getting overlapping "(lldb) " prompts and
3707  // garbled output.
3708  //
3709  // If we aren't handling the events in the debugger (which is indicated
3710  // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or
3711  // we are hijacked, then we always pop the process IO handler manually.
3712  // Hijacking happens when the internal process state thread is running
3713  // thread plans, or when commands want to run in synchronous mode and
3714  // they call "process->WaitForProcessToStop()". An example of something
3715  // that will hijack the events is a simple expression:
3716  //
3717  // (lldb) expr (int)puts("hello")
3718  //
3719  // This will cause the internal process state thread to resume and halt
3720  // the process (and _it_ will hijack the eBroadcastBitStateChanged
3721  // events) and we do need the IO handler to be pushed and popped
3722  // correctly.
3723 
3724  if (is_hijacked || !GetTarget().GetDebugger().IsHandlingEvents())
3726  }
3727  }
3728 
3729  BroadcastEvent(event_sp);
3730  } else {
3731  if (log) {
3732  LLDB_LOGF(
3733  log,
3734  "Process::%s (pid = %" PRIu64
3735  ") suppressing state %s (old state %s): should_broadcast == false",
3736  __FUNCTION__, GetID(), StateAsCString(new_state),
3738  }
3739  }
3740 }
3741 
3743  EventSP event_sp;
3744  Status error(WillHalt());
3745  if (error.Fail())
3746  return error;
3747 
3748  // Ask the process subclass to actually halt our process
3749  bool caused_stop;
3750  error = DoHalt(caused_stop);
3751 
3752  DidHalt();
3753  return error;
3754 }
3755 
3757  bool control_only = true;
3758 
3759  Log *log = GetLog(LLDBLog::Process);
3760  LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
3761  __FUNCTION__, static_cast<void *>(this), GetID());
3762 
3763  bool exit_now = false;
3764  bool interrupt_requested = false;
3765  while (!exit_now) {
3766  EventSP event_sp;
3767  GetEventsPrivate(event_sp, llvm::None, control_only);
3768  if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) {
3769  LLDB_LOGF(log,
3770  "Process::%s (arg = %p, pid = %" PRIu64
3771  ") got a control event: %d",
3772  __FUNCTION__, static_cast<void *>(this), GetID(),
3773  event_sp->GetType());
3774 
3775  switch (event_sp->GetType()) {
3777  exit_now = true;
3778  break; // doing any internal state management below
3779 
3781  control_only = true;
3782  break;
3783 
3785  control_only = false;
3786  break;
3787  }
3788 
3789  continue;
3790  } else if (event_sp->GetType() == eBroadcastBitInterrupt) {
3792  LLDB_LOGF(log,
3793  "Process::%s (arg = %p, pid = %" PRIu64
3794  ") woke up with an interrupt while attaching - "
3795  "forwarding interrupt.",
3796  __FUNCTION__, static_cast<void *>(this), GetID());
3799  LLDB_LOGF(log,
3800  "Process::%s (arg = %p, pid = %" PRIu64
3801  ") woke up with an interrupt - Halting.",
3802  __FUNCTION__, static_cast<void *>(this), GetID());
3803  Status error = HaltPrivate();
3804  if (error.Fail() && log)
3805  LLDB_LOGF(log,
3806  "Process::%s (arg = %p, pid = %" PRIu64
3807  ") failed to halt the process: %s",
3808  __FUNCTION__, static_cast<void *>(this), GetID(),
3809  error.AsCString());
3810  // Halt should generate a stopped event. Make a note of the fact that
3811  // we were doing the interrupt, so we can set the interrupted flag
3812  // after we receive the event. We deliberately set this to true even if
3813  // HaltPrivate failed, so that we can interrupt on the next natural
3814  // stop.
3815  interrupt_requested = true;
3816  } else {
3817  // This can happen when someone (e.g. Process::Halt) sees that we are
3818  // running and sends an interrupt request, but the process actually
3819  // stops before we receive it. In that case, we can just ignore the
3820  // request. We use m_last_broadcast_state, because the Stopped event
3821  // may not have been popped of the event queue yet, which is when the
3822  // public state gets updated.
3823  LLDB_LOGF(log,
3824  "Process::%s ignoring interrupt as we have already stopped.",
3825  __FUNCTION__);
3826  }
3827  continue;
3828  }
3829 
3830  const StateType internal_state =
3832 
3833  if (internal_state != eStateInvalid) {
3835  StateIsStoppedState(internal_state, true)) {
3838  }
3839 
3840  if (interrupt_requested) {
3841  if (StateIsStoppedState(internal_state, true)) {
3842  // We requested the interrupt, so mark this as such in the stop event
3843  // so clients can tell an interrupted process from a natural stop
3844  ProcessEventData::SetInterruptedInEvent(event_sp.get(), true);
3845  interrupt_requested = false;
3846  } else if (log) {
3847  LLDB_LOGF(log,
3848  "Process::%s interrupt_requested, but a non-stopped "
3849  "state '%s' received.",
3850  __FUNCTION__, StateAsCString(internal_state));
3851  }
3852  }
3853 
3854  HandlePrivateEvent(event_sp);
3855  }
3856 
3857  if (internal_state == eStateInvalid || internal_state == eStateExited ||
3858  internal_state == eStateDetached) {
3859  LLDB_LOGF(log,
3860  "Process::%s (arg = %p, pid = %" PRIu64
3861  ") about to exit with internal state %s...",
3862  __FUNCTION__, static_cast<void *>(this), GetID(),
3863  StateAsCString(internal_state));
3864 
3865  break;
3866  }
3867  }
3868 
3869  // Verify log is still enabled before attempting to write to it...
3870  LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
3871  __FUNCTION__, static_cast<void *>(this), GetID());
3872 
3873  // If we are a secondary thread, then the primary thread we are working for
3874  // will have already acquired the public_run_lock, and isn't done with what
3875  // it was doing yet, so don't try to change it on the way out.
3876  if (!is_secondary_thread)
3878  return {};
3879 }
3880 
3881 // Process Event Data
3882 
3884 
3885 Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
3886  StateType state)
3887  : EventData(), m_process_wp(), m_state(state) {
3888  if (process_sp)
3889  m_process_wp = process_sp;
3890 }
3891 
3893 
3895  static ConstString g_flavor("Process::ProcessEventData");
3896  return g_flavor;
3897 }
3898 
3901 }
3902 
3904  bool &found_valid_stopinfo) {
3905  found_valid_stopinfo = false;
3906 
3907  ProcessSP process_sp(m_process_wp.lock());
3908  if (!process_sp)
3909  return false;
3910 
3911  ThreadList &curr_thread_list = process_sp->GetThreadList();
3912  uint32_t num_threads = curr_thread_list.GetSize();
3913  uint32_t idx;
3914 
3915  // The actions might change one of the thread's stop_info's opinions about
3916  // whether we should stop the process, so we need to query that as we go.
3917 
3918  // One other complication here, is that we try to catch any case where the
3919  // target has run (except for expressions) and immediately exit, but if we
3920  // get that wrong (which is possible) then the thread list might have
3921  // changed, and that would cause our iteration here to crash. We could
3922  // make a copy of the thread list, but we'd really like to also know if it
3923  // has changed at all, so we make up a vector of the thread ID's and check
3924  // what we get back against this list & bag out if anything differs.
3925  ThreadList not_suspended_thread_list(process_sp.get());
3926  std::vector<uint32_t> thread_index_array(num_threads);
3927  uint32_t not_suspended_idx = 0;
3928  for (idx = 0; idx < num_threads; ++idx) {
3929  lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
3930 
3931  /*
3932  Filter out all suspended threads, they could not be the reason
3933  of stop and no need to perform any actions on them.
3934  */
3935  if (thread_sp->GetResumeState() != eStateSuspended) {
3936  not_suspended_thread_list.AddThread(thread_sp);
3937  thread_index_array[not_suspended_idx] = thread_sp->GetIndexID();
3938  not_suspended_idx++;
3939  }
3940  }
3941 
3942  // Use this to track whether we should continue from here. We will only
3943  // continue the target running if no thread says we should stop. Of course
3944  // if some thread's PerformAction actually sets the target running, then it
3945  // doesn't matter what the other threads say...
3946 
3947  bool still_should_stop = false;
3948 
3949  // Sometimes - for instance if we have a bug in the stub we are talking to,
3950  // we stop but no thread has a valid stop reason. In that case we should
3951  // just stop, because we have no way of telling what the right thing to do
3952  // is, and it's better to let the user decide than continue behind their
3953  // backs.
3954 
3955  for (idx = 0; idx < not_suspended_thread_list.GetSize(); ++idx) {
3956  curr_thread_list = process_sp->GetThreadList();
3957  if (curr_thread_list.GetSize() != num_threads) {
3959  LLDB_LOGF(
3960  log,
3961  "Number of threads changed from %u to %u while processing event.",
3962  num_threads, curr_thread_list.GetSize());
3963  break;
3964  }
3965 
3966  lldb::ThreadSP thread_sp = not_suspended_thread_list.GetThreadAtIndex(idx);
3967 
3968  if (thread_sp->GetIndexID() != thread_index_array[idx]) {
3970  LLDB_LOGF(log,
3971  "The thread at position %u changed from %u to %u while "
3972  "processing event.",
3973  idx, thread_index_array[idx], thread_sp->GetIndexID());
3974  break;
3975  }
3976 
3977  StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
3978  if (stop_info_sp && stop_info_sp->IsValid()) {
3979  found_valid_stopinfo = true;
3980  bool this_thread_wants_to_stop;
3981  if (stop_info_sp->GetOverrideShouldStop()) {
3982  this_thread_wants_to_stop =
3983  stop_info_sp->GetOverriddenShouldStopValue();
3984  } else {
3985  stop_info_sp->PerformAction(event_ptr);
3986  // The stop action might restart the target. If it does, then we
3987  // want to mark that in the event so that whoever is receiving it
3988  // will know to wait for the running event and reflect that state
3989  // appropriately. We also need to stop processing actions, since they
3990  // aren't expecting the target to be running.
3991 
3992  // FIXME: we might have run.
3993  if (stop_info_sp->HasTargetRunSinceMe()) {
3994  SetRestarted(true);
3995  break;
3996  }
3997 
3998  this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
3999  }
4000 
4001  if (!still_should_stop)
4002  still_should_stop = this_thread_wants_to_stop;
4003  }
4004  }
4005 
4006  return still_should_stop;
4007 }
4008 
4010  ProcessSP process_sp(m_process_wp.lock());
4011 
4012  if (!process_sp)
4013  return;
4014 
4015  // This function gets called twice for each event, once when the event gets
4016  // pulled off of the private process event queue, and then any number of
4017  // times, first when it gets pulled off of the public event queue, then other
4018  // times when we're pretending that this is where we stopped at the end of
4019  // expression evaluation. m_update_state is used to distinguish these three
4020  // cases; it is 0 when we're just pulling it off for private handling, and >
4021  // 1 for expression evaluation, and we don't want to do the breakpoint
4022  // command handling then.
4023  if (m_update_state != 1)
4024  return;
4025 
4026  process_sp->SetPublicState(
4028 
4029  if (m_state == eStateStopped && !m_restarted) {
4030  // Let process subclasses know we are about to do a public stop and do
4031  // anything they might need to in order to speed up register and memory
4032  // accesses.
4033  process_sp->WillPublicStop();
4034  }
4035 
4036  // If this is a halt event, even if the halt stopped with some reason other
4037  // than a plain interrupt (e.g. we had already stopped for a breakpoint when
4038  // the halt request came through) don't do the StopInfo actions, as they may
4039  // end up restarting the process.
4040  if (m_interrupted)
4041  return;
4042 
4043  // If we're not stopped or have restarted, then skip the StopInfo actions:
4044  if (m_state != eStateStopped || m_restarted) {
4045  return;
4046  }
4047 
4048  bool does_anybody_have_an_opinion = false;
4049  bool still_should_stop = ShouldStop(event_ptr, does_anybody_have_an_opinion);
4050 
4051  if (GetRestarted()) {
4052  return;
4053  }
4054 
4055  if (!still_should_stop && does_anybody_have_an_opinion) {
4056  // We've been asked to continue, so do that here.
4057  SetRestarted(true);
4058  // Use the public resume method here, since this is just extending a
4059  // public resume.
4060  process_sp->PrivateResume();
4061  } else {
4062  bool hijacked = process_sp->IsHijackedForEvent(eBroadcastBitStateChanged) &&
4063  !process_sp->StateChangedIsHijackedForSynchronousResume();
4064 
4065  if (!hijacked) {
4066  // If we didn't restart, run the Stop Hooks here.
4067  // Don't do that if state changed events aren't hooked up to the
4068  // public (or SyncResume) broadcasters. StopHooks are just for
4069  // real public stops. They might also restart the target,
4070  // so watch for that.
4071  if (process_sp->GetTarget().RunStopHooks())
4072  SetRestarted(true);
4073  }
4074  }
4075 }
4076 
4078  ProcessSP process_sp(m_process_wp.lock());
4079 
4080  if (process_sp)
4081  s->Printf(" process = %p (pid = %" PRIu64 "), ",
4082  static_cast<void *>(process_sp.get()), process_sp->GetID());
4083  else
4084  s->PutCString(" process = NULL, ");
4085 
4086  s->Printf("state = %s", StateAsCString(GetState()));
4087 }
4088 
4091  if (event_ptr) {
4092  const EventData *event_data = event_ptr->GetData();
4093  if (event_data &&
4094  event_data->GetFlavor() == ProcessEventData::GetFlavorString())
4095  return static_cast<const ProcessEventData *>(event_ptr->GetData());
4096  }
4097  return nullptr;
4098 }
4099 
4100 ProcessSP
4102  ProcessSP process_sp;
4103  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4104  if (data)
4105  process_sp = data->GetProcessSP();
4106  return process_sp;
4107 }
4108 
4110  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4111  if (data == nullptr)
4112  return eStateInvalid;
4113  else
4114  return data->GetState();
4115 }
4116 
4118  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4119  if (data == nullptr)
4120  return false;
4121  else
4122  return data->GetRestarted();
4123 }
4124 
4126  bool new_value) {
4127  ProcessEventData *data =
4128  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4129  if (data != nullptr)
4130  data->SetRestarted(new_value);
4131 }
4132 
4133 size_t
4135  ProcessEventData *data =
4136  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4137  if (data != nullptr)
4138  return data->GetNumRestartedReasons();
4139  else
4140  return 0;
4141 }
4142 
4143 const char *
4145  size_t idx) {
4146  ProcessEventData *data =
4147  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4148  if (data != nullptr)
4149  return data->GetRestartedReasonAtIndex(idx);
4150  else
4151  return nullptr;
4152 }
4153 
4155  const char *reason) {
4156  ProcessEventData *data =
4157  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4158  if (data != nullptr)
4159  data->AddRestartedReason(reason);
4160 }
4161 
4163  const Event *event_ptr) {
4164  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4165  if (data == nullptr)
4166  return false;
4167  else
4168  return data->GetInterrupted();
4169 }
4170 
4172  bool new_value) {
4173  ProcessEventData *data =
4174  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4175  if (data != nullptr)
4176  data->SetInterrupted(new_value);
4177 }
4178 
4180  ProcessEventData *data =
4181  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4182  if (data) {
4183  data->SetUpdateStateOnRemoval();
4184  return true;
4185  }
4186  return false;
4187 }
4188 
4189 lldb::TargetSP Process::CalculateTarget() { return m_target_wp.lock(); }
4190 
4192  exe_ctx.SetTargetPtr(&GetTarget());
4193  exe_ctx.SetProcessPtr(this);
4194  exe_ctx.SetThreadPtr(nullptr);
4195  exe_ctx.SetFramePtr(nullptr);
4196 }
4197 
4198 // uint32_t
4199 // Process::ListProcessesMatchingName (const char *name, StringList &matches,
4200 // std::vector<lldb::pid_t> &pids)
4201 //{
4202 // return 0;
4203 //}
4204 //
4205 // ArchSpec
4206 // Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4207 //{
4208 // return Host::GetArchSpecForExistingProcess (pid);
4209 //}
4210 //
4211 // ArchSpec
4212 // Process::GetArchSpecForExistingProcess (const char *process_name)
4213 //{
4214 // return Host::GetArchSpecForExistingProcess (process_name);
4215 //}
4216 
4217 void Process::AppendSTDOUT(const char *s, size_t len) {
4218  std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
4219  m_stdout_data.append(s, len);
4221  new ProcessEventData(shared_from_this(), GetState()));
4222 }
4223 
4224 void Process::AppendSTDERR(const char *s, size_t len) {
4225  std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
4226  m_stderr_data.append(s, len);
4228  new ProcessEventData(shared_from_this(), GetState()));
4229 }
4230 
4231 void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) {
4232  std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
4233  m_profile_data.push_back(one_profile_data);
4235  new ProcessEventData(shared_from_this(), GetState()));
4236 }
4237 
4239  const StructuredDataPluginSP &plugin_sp) {
4242  new EventDataStructuredData(shared_from_this(), object_sp, plugin_sp));
4243 }
4244 
4245 StructuredDataPluginSP
4247  auto find_it = m_structured_data_plugin_map.find(type_name);
4248  if (find_it != m_structured_data_plugin_map.end())
4249  return find_it->second;
4250  else
4251  return StructuredDataPluginSP();
4252 }
4253 
4254 size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) {
4255  std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
4256  if (m_profile_data.empty())
4257  return 0;
4258 
4259  std::string &one_profile_data = m_profile_data.front();
4260  size_t bytes_available = one_profile_data.size();
4261  if (bytes_available > 0) {
4262  Log *log = GetLog(LLDBLog::Process);
4263  LLDB_LOGF(log, "Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4264  static_cast<void *>(buf), static_cast<uint64_t>(buf_size));
4265  if (bytes_available > buf_size) {
4266  memcpy(buf, one_profile_data.c_str(), buf_size);
4267  one_profile_data.erase(0, buf_size);
4268  bytes_available = buf_size;
4269  } else {
4270  memcpy(buf, one_profile_data.c_str(), bytes_available);
4271  m_profile_data.erase(m_profile_data.begin());
4272  }
4273  }
4274  return bytes_available;
4275 }
4276 
4277 // Process STDIO
4278 
4279 size_t Process::GetSTDOUT(char *buf, size_t buf_size, Status &error) {
4280  std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
4281  size_t bytes_available = m_stdout_data.size();
4282  if (bytes_available > 0) {
4283  Log *log = GetLog(LLDBLog::Process);
4284  LLDB_LOGF(log, "Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4285  static_cast<void *>(buf), static_cast<uint64_t>(buf_size));
4286  if (bytes_available > buf_size) {
4287  memcpy(buf, m_stdout_data.c_str(), buf_size);
4288  m_stdout_data.erase(0, buf_size);
4289  bytes_available = buf_size;
4290  } else {
4291  memcpy(buf, m_stdout_data.c_str(), bytes_available);
4292  m_stdout_data.clear();
4293  }
4294  }
4295  return bytes_available;
4296 }
4297 
4298 size_t Process::GetSTDERR(char *buf, size_t buf_size, Status &error) {
4299  std::lock_guard<std::recursive_mutex> gaurd(m_stdio_communication_mutex);
4300  size_t bytes_available = m_stderr_data.size();
4301  if (bytes_available > 0) {
4302  Log *log = GetLog(LLDBLog::Process);
4303  LLDB_LOGF(log, "Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4304  static_cast<void *>(buf), static_cast<uint64_t>(buf_size));
4305  if (bytes_available > buf_size) {
4306  memcpy(buf, m_stderr_data.c_str(), buf_size);
4307  m_stderr_data.erase(0, buf_size);
4308  bytes_available = buf_size;
4309  } else {
4310  memcpy(buf, m_stderr_data.c_str(), bytes_available);
4311  m_stderr_data.clear();
4312  }
4313  }
4314  return bytes_available;
4315 }
4316 
4317 void Process::STDIOReadThreadBytesReceived(void *baton, const void *src,
4318  size_t src_len) {
4319  Process *process = (Process *)baton;
4320  process->AppendSTDOUT(static_cast<const char *>(src), src_len);
4321 }
4322 
4324 public:
4325  IOHandlerProcessSTDIO(Process *process, int write_fd)
4326  : IOHandler(process->GetTarget().GetDebugger(),
4327  IOHandler::Type::ProcessIO),
4328  m_process(process),
4329  m_read_file(GetInputFD(), File::eOpenOptionReadOnly, false),
4330  m_write_file(write_fd, File::eOpenOptionWriteOnly, false) {
4331  m_pipe.CreateNew(false);
4332  }
4333 
4334  ~IOHandlerProcessSTDIO() override = default;
4335 
4336  void SetIsRunning(bool running) {
4337  std::lock_guard<std::mutex> guard(m_mutex);
4338  SetIsDone(!running);
4339  m_is_running = running;
4340  }
4341 
4342  // Each IOHandler gets to run until it is done. It should read data from the
4343  // "in" and place output into "out" and "err and return when done.
4344  void Run() override {
4345  if (!m_read_file.IsValid() || !m_write_file.IsValid() ||
4346  !m_pipe.CanRead() || !m_pipe.CanWrite()) {
4347  SetIsDone(true);
4348  return;
4349  }
4350 
4351  SetIsDone(false);
4352  const int read_fd = m_read_file.GetDescriptor();
4353  Terminal terminal(read_fd);
4354  TerminalState terminal_state(terminal, false);
4355  // FIXME: error handling?
4356  llvm::consumeError(terminal.SetCanonical(false));
4357  llvm::consumeError(terminal.SetEcho(false));
4358 // FD_ZERO, FD_SET are not supported on windows
4359 #ifndef _WIN32
4360  const int pipe_read_fd = m_pipe.GetReadFileDescriptor();
4361  SetIsRunning(true);
4362  while (true) {
4363  {
4364  std::lock_guard<std::mutex> guard(m_mutex);
4365  if (GetIsDone())
4366  break;
4367  }
4368 
4369  SelectHelper select_helper;
4370  select_helper.FDSetRead(read_fd);
4371  select_helper.FDSetRead(pipe_read_fd);
4372  Status error = select_helper.Select();
4373 
4374  if (error.Fail())
4375  break;
4376 
4377  char ch = 0;
4378  size_t n;
4379  if (select_helper.FDIsSetRead(read_fd)) {
4380  n = 1;
4381  if (m_read_file.Read(&ch, n).Success() && n == 1) {
4382  if (m_write_file.Write(&ch, n).Fail() || n != 1)
4383  break;
4384  } else
4385  break;
4386  }
4387 
4388  if (select_helper.FDIsSetRead(pipe_read_fd)) {
4389  size_t bytes_read;
4390  // Consume the interrupt byte
4391  Status error = m_pipe.Read(&ch, 1, bytes_read);
4392  if (error.Success()) {
4393  if (ch == 'q')
4394  break;
4395  if (ch == 'i')
4398  }
4399  }
4400  }
4401  SetIsRunning(false);
4402 #endif
4403  }
4404 
4405  void Cancel() override {
4406  std::lock_guard<std::mutex> guard(m_mutex);
4407  SetIsDone(true);
4408  // Only write to our pipe to cancel if we are in
4409  // IOHandlerProcessSTDIO::Run(). We can end up with a python command that
4410  // is being run from the command interpreter:
4411  //
4412  // (lldb) step_process_thousands_of_times
4413  //
4414  // In this case the command interpreter will be in the middle of handling
4415  // the command and if the process pushes and pops the IOHandler thousands
4416  // of times, we can end up writing to m_pipe without ever consuming the
4417  // bytes from the pipe in IOHandlerProcessSTDIO::Run() and end up
4418  // deadlocking when the pipe gets fed up and blocks until data is consumed.
4419  if (m_is_running) {
4420  char ch = 'q'; // Send 'q' for quit
4421  size_t bytes_written = 0;
4422  m_pipe.Write(&ch, 1, bytes_written);
4423  }
4424  }
4425 
4426  bool Interrupt() override {
4427  // Do only things that are safe to do in an interrupt context (like in a
4428  // SIGINT handler), like write 1 byte to a file descriptor. This will
4429  // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
4430  // that was written to the pipe and then call
4431  // m_process->SendAsyncInterrupt() from a much safer location in code.
4432  if (m_active) {
4433  char ch = 'i'; // Send 'i' for interrupt
4434  size_t bytes_written = 0;
4435  Status result = m_pipe.Write(&ch, 1, bytes_written);
4436  return result.Success();
4437  } else {
4438  // This IOHandler might be pushed on the stack, but not being run
4439  // currently so do the right thing if we aren't actively watching for
4440  // STDIN by sending the interrupt to the process. Otherwise the write to
4441  // the pipe above would do nothing. This can happen when the command
4442  // interpreter is running and gets a "expression ...". It will be on the
4443  // IOHandler thread and sending the input is complete to the delegate
4444  // which will cause the expression to run, which will push the process IO
4445  // handler, but not run it.
4446 
4449  return true;
4450  }
4451  }
4452  return false;
4453  }
4454 
4455  void GotEOF() override {}
4456 
4457 protected:
4459  NativeFile m_read_file; // Read from this file (usually actual STDIN for LLDB
4460  NativeFile m_write_file; // Write to this file (usually the primary pty for
4461  // getting io to debuggee)
4463  std::mutex m_mutex;
4464  bool m_is_running = false;
4465 };
4466 
4468  // First set up the Read Thread for reading/handling process I/O
4470  std::make_unique<ConnectionFileDescriptor>(fd, true));
4475 
4476  // Now read thread is set up, set up input reader.
4477 
4480  std::make_shared<IOHandlerProcessSTDIO>(this, fd);
4481  }
4482 }
4483 
4485  IOHandlerSP io_handler_sp(m_process_input_reader);
4486  if (io_handler_sp)
4487  return GetTarget().GetDebugger().IsTopIOHandler(io_handler_sp);
4488  return false;
4489 }
4491  IOHandlerSP io_handler_sp(m_process_input_reader);
4492  if (io_handler_sp) {
4493  Log *log = GetLog(LLDBLog::Process);
4494  LLDB_LOGF(log, "Process::%s pushing IO handler", __FUNCTION__);
4495 
4496  io_handler_sp->SetIsDone(false);
4497  // If we evaluate an utility function, then we don't cancel the current
4498  // IOHandler. Our IOHandler is non-interactive and shouldn't disturb the
4499  // existing IOHandler that potentially provides the user interface (e.g.
4500  // the IOHandler for Editline).
4501  bool cancel_top_handler = !m_mod_id.IsRunningUtilityFunction();
4502  GetTarget().GetDebugger().RunIOHandlerAsync(io_handler_sp,
4503  cancel_top_handler);
4504  return true;
4505  }
4506  return false;
4507 }
4508 
4510  IOHandlerSP io_handler_sp(m_process_input_reader);
4511  if (io_handler_sp)
4512  return GetTarget().GetDebugger().RemoveIOHandler(io_handler_sp);
4513  return false;
4514 }
4515 
4516 // The process needs to know about installed plug-ins
4518 
4520 
4521 namespace {
4522 // RestorePlanState is used to record the "is private", "is controlling" and
4523 // "okay
4524 // to discard" fields of the plan we are running, and reset it on Clean or on
4525 // destruction. It will only reset the state once, so you can call Clean and
4526 // then monkey with the state and it won't get reset on you again.
4527 
4528 class RestorePlanState {
4529 public:
4530  RestorePlanState(lldb::ThreadPlanSP thread_plan_sp)
4531  : m_thread_plan_sp(thread_plan_sp) {
4532  if (m_thread_plan_sp) {
4533  m_private = m_thread_plan_sp->GetPrivate();
4534  m_is_controlling = m_thread_plan_sp->IsControllingPlan();
4535  m_okay_to_discard = m_thread_plan_sp->OkayToDiscard();
4536  }
4537  }
4538 
4539  ~RestorePlanState() { Clean(); }
4540 
4541  void Clean() {
4542  if (!m_already_reset && m_thread_plan_sp) {
4543  m_already_reset = true;
4544  m_thread_plan_sp->SetPrivate(m_private);
4545  m_thread_plan_sp->SetIsControllingPlan(m_is_controlling);
4546  m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);
4547  }
4548  }
4549 
4550 private:
4551  lldb::ThreadPlanSP m_thread_plan_sp;
4552  bool m_already_reset = false;
4553  bool m_private;
4554  bool m_is_controlling;
4555  bool m_okay_to_discard;
4556 };
4557 } // anonymous namespace
4558 
4559 static microseconds
4561  const milliseconds default_one_thread_timeout(250);
4562 
4563  // If the overall wait is forever, then we don't need to worry about it.
4564  if (!options.GetTimeout()) {
4565  return options.GetOneThreadTimeout() ? *options.GetOneThreadTimeout()
4566  : default_one_thread_timeout;
4567  }
4568 
4569  // If the one thread timeout is set, use it.
4570  if (options.GetOneThreadTimeout())
4571  return *options.GetOneThreadTimeout();
4572 
4573  // Otherwise use half the total timeout, bounded by the
4574  // default_one_thread_timeout.
4575  return std::min<microseconds>(default_one_thread_timeout,
4576  *options.GetTimeout() / 2);
4577 }
4578 
4579 static Timeout<std::micro>
4581  bool before_first_timeout) {
4582  // If we are going to run all threads the whole time, or if we are only going
4583  // to run one thread, we can just return the overall timeout.
4584  if (!options.GetStopOthers() || !options.GetTryAllThreads())
4585  return options.GetTimeout();
4586 
4587  if (before_first_timeout)
4588  return GetOneThreadExpressionTimeout(options);
4589 
4590  if (!options.GetTimeout())
4591  return llvm::None;
4592  else
4593  return *options.GetTimeout() - GetOneThreadExpressionTimeout(options);
4594 }
4595 
4596 static llvm::Optional<ExpressionResults>
4597 HandleStoppedEvent(lldb::tid_t thread_id, const ThreadPlanSP &thread_plan_sp,
4598  RestorePlanState &restorer, const EventSP &event_sp,
4599  EventSP &event_to_broadcast_sp,
4600  const EvaluateExpressionOptions &options,
4601  bool handle_interrupts) {
4603 
4604  ThreadSP thread_sp = thread_plan_sp->GetTarget()
4605  .GetProcessSP()
4606  ->GetThreadList()
4607  .FindThreadByID(thread_id);
4608  if (!thread_sp) {
4609  LLDB_LOG(log,
4610  "The thread on which we were running the "
4611  "expression: tid = {0}, exited while "
4612  "the expression was running.",
4613  thread_id);
4615  }
4616 
4617  ThreadPlanSP plan = thread_sp->GetCompletedPlan();
4618  if (plan == thread_plan_sp && plan->PlanSucceeded()) {
4619  LLDB_LOG(log, "execution completed successfully");
4620 
4621  // Restore the plan state so it will get reported as intended when we are
4622  // done.
4623  restorer.Clean();
4624  return eExpressionCompleted;
4625  }
4626 
4627  StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
4628  if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint &&
4629  stop_info_sp->ShouldNotify(event_sp.get())) {
4630  LLDB_LOG(log, "stopped for breakpoint: {0}.", stop_info_sp->GetDescription());
4631  if (!options.DoesIgnoreBreakpoints()) {
4632  // Restore the plan state and then force Private to false. We are going
4633  // to stop because of this plan so we need it to become a public plan or
4634  // it won't report correctly when we continue to its termination later
4635  // on.
4636  restorer.Clean();
4637  thread_plan_sp->SetPrivate(false);
4638  event_to_broadcast_sp = event_sp;
4639  }
4640  return eExpressionHitBreakpoint;
4641  }
4642 
4643  if (!handle_interrupts &&
4645  return llvm::None;
4646 
4647  LLDB_LOG(log, "thread plan did not successfully complete");
4648  if (!options.DoesUnwindOnError())
4649  event_to_broadcast_sp = event_sp;
4650  return eExpressionInterrupted;
4651 }
4652 
4655  lldb::ThreadPlanSP &thread_plan_sp,
4656  const EvaluateExpressionOptions &options,
4657  DiagnosticManager &diagnostic_manager) {
4659 
4660  std::lock_guard<std::mutex> run_thread_plan_locker(m_run_thread_plan_lock);
4661 
4662  if (!thread_plan_sp) {
4663  diagnostic_manager.PutString(
4665  "RunThreadPlan called with empty thread plan.");
4666  return eExpressionSetupError;
4667  }
4668 
4669  if (!thread_plan_sp->ValidatePlan(nullptr)) {
4670  diagnostic_manager.PutString(
4672  "RunThreadPlan called with an invalid thread plan.");
4673  return eExpressionSetupError;
4674  }
4675 
4676  if (exe_ctx.GetProcessPtr() != this) {
4677  diagnostic_manager.PutString(eDiagnosticSeverityError,
4678  "RunThreadPlan called on wrong process.");
4679  return eExpressionSetupError;
4680  }
4681 
4682  Thread *thread = exe_ctx.GetThreadPtr();
4683  if (thread == nullptr) {
4684  diagnostic_manager.PutString(eDiagnosticSeverityError,
4685  "RunThreadPlan called with invalid thread.");
4686  return eExpressionSetupError;
4687  }
4688 
4689  // Record the thread's id so we can tell when a thread we were using
4690  // to run the expression exits during the expression evaluation.
4691  lldb::tid_t expr_thread_id = thread->GetID();
4692 
4693  // We need to change some of the thread plan attributes for the thread plan
4694  // runner. This will restore them when we are done:
4695 
4696  RestorePlanState thread_plan_restorer(thread_plan_sp);
4697 
4698  // We rely on the thread plan we are running returning "PlanCompleted" if
4699  // when it successfully completes. For that to be true the plan can't be
4700  // private - since private plans suppress themselves in the GetCompletedPlan
4701  // call.
4702 
4703  thread_plan_sp->SetPrivate(false);
4704 
4705  // The plans run with RunThreadPlan also need to be terminal controlling plans
4706  // or when they are done we will end up asking the plan above us whether we
4707  // should stop, which may give the wrong answer.
4708 
4709  thread_plan_sp->SetIsControllingPlan(true);
4710  thread_plan_sp->SetOkayToDiscard(false);
4711 
4712  // If we are running some utility expression for LLDB, we now have to mark
4713  // this in the ProcesModID of this process. This RAII takes care of marking
4714  // and reverting the mark it once we are done running the expression.
4715  UtilityFunctionScope util_scope(options.IsForUtilityExpr() ? this : nullptr);
4716 
4718  diagnostic_manager.PutString(
4720  "RunThreadPlan called while the private state was not stopped.");
4721  return eExpressionSetupError;
4722  }
4723 
4724  // Save the thread & frame from the exe_ctx for restoration after we run
4725  const uint32_t thread_idx_id = thread->GetIndexID();
4726  StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
4727  if (!selected_frame_sp) {
4728  thread->SetSelectedFrame(nullptr);
4729  selected_frame_sp = thread->GetSelectedFrame();
4730  if (!selected_frame_sp) {
4731  diagnostic_manager.Printf(
4733  "RunThreadPlan called without a selected frame on thread %d",
4734  thread_idx_id);
4735  return eExpressionSetupError;
4736  }
4737  }
4738 
4739  // Make sure the timeout values make sense. The one thread timeout needs to
4740  // be smaller than the overall timeout.
4741  if (options.GetOneThreadTimeout() && options.GetTimeout() &&
4742  *options.GetTimeout() < *options.GetOneThreadTimeout()) {
4743  diagnostic_manager.PutString(eDiagnosticSeverityError,
4744  "RunThreadPlan called with one thread "
4745  "timeout greater than total timeout");
4746  return eExpressionSetupError;
4747  }
4748 
4749  StackID ctx_frame_id = selected_frame_sp->GetStackID();
4750 
4751  // N.B. Running the target may unset the currently selected thread and frame.
4752  // We don't want to do that either, so we should arrange to reset them as
4753  // well.
4754 
4755  lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
4756 
4757  uint32_t selected_tid;
4758  StackID selected_stack_id;
4759  if (selected_thread_sp) {
4760  selected_tid = selected_thread_sp->GetIndexID();
4761  selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
4762  } else {
4763  selected_tid = LLDB_INVALID_THREAD_ID;
4764  }
4765 
4766  HostThread backup_private_state_thread;
4767  lldb::StateType old_state = eStateInvalid;
4768  lldb::ThreadPlanSP stopper_base_plan_sp;
4769 
4772  // Yikes, we are running on the private state thread! So we can't wait for
4773  // public events on this thread, since we are the thread that is generating
4774  // public events. The simplest thing to do is to spin up a temporary thread
4775  // to handle private state thread events while we are fielding public
4776  // events here.
4777  LLDB_LOGF(log, "Running thread plan on private state thread, spinning up "
4778  "another state thread to handle the events.");
4779 
4780  backup_private_state_thread = m_private_state_thread;
4781 
4782  // One other bit of business: we want to run just this thread plan and
4783  // anything it pushes, and then stop, returning control here. But in the
4784  // normal course of things, the plan above us on the stack would be given a
4785  // shot at the stop event before deciding to stop, and we don't want that.
4786  // So we insert a "stopper" base plan on the stack before the plan we want
4787  // to run. Since base plans always stop and return control to the user,
4788  // that will do just what we want.
4789  stopper_base_plan_sp.reset(new ThreadPlanBase(*thread));
4790  thread->QueueThreadPlan(stopper_base_plan_sp, false);
4791  // Have to make sure our public state is stopped, since otherwise the
4792  // reporting logic below doesn't work correctly.
4793  old_state = m_public_state.GetValue();
4795 
4796  // Now spin up the private state thread:
4798  }
4799 
4800  thread->QueueThreadPlan(
4801  thread_plan_sp, false); // This used to pass "true" does that make sense?
4802 
4803  if (options.GetDebug()) {
4804  // In this case, we aren't actually going to run, we just want to stop
4805  // right away. Flush this thread so we will refetch the stacks and show the
4806  // correct backtrace.
4807  // FIXME: To make this prettier we should invent some stop reason for this,
4808  // but that
4809  // is only cosmetic, and this functionality is only of use to lldb
4810  // developers who can live with not pretty...
4811  thread->Flush();
4813  }
4814 
4815  ListenerSP listener_sp(
4816  Listener::MakeListener("lldb.process.listener.run-thread-plan"));
4817 
4818  lldb::EventSP event_to_broadcast_sp;
4819 
4820  {
4821  // This process event hijacker Hijacks the Public events and its destructor
4822  // makes sure that the process events get restored on exit to the function.
4823  //
4824  // If the event needs to propagate beyond the hijacker (e.g., the process
4825  // exits during execution), then the event is put into
4826  // event_to_broadcast_sp for rebroadcasting.
4827 
4828  ProcessEventHijacker run_thread_plan_hijacker(*this, listener_sp);
4829 
4830  if (log) {
4831  StreamString s;
4832  thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
4833  LLDB_LOGF(log,
4834  "Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64
4835  " to run thread plan \"%s\".",
4836  thread_idx_id, expr_thread_id, s.GetData());
4837  }
4838 
4839  bool got_event;
4840  lldb::EventSP event_sp;
4841  lldb::StateType stop_state = lldb::eStateInvalid;
4842 
4843  bool before_first_timeout = true; // This is set to false the first time
4844  // that we have to halt the target.
4845  bool do_resume = true;
4846  bool handle_running_event = true;
4847 
4848  // This is just for accounting:
4849  uint32_t num_resumes = 0;
4850 
4851  // If we are going to run all threads the whole time, or if we are only
4852  // going to run one thread, then we don't need the first timeout. So we
4853  // pretend we are after the first timeout already.
4854  if (!options.GetStopOthers() || !options.GetTryAllThreads())
4855  before_first_timeout = false;
4856 
4857  LLDB_LOGF(log, "Stop others: %u, try all: %u, before_first: %u.\n",
4858  options.GetStopOthers(), options.GetTryAllThreads(),
4859  before_first_timeout);
4860 
4861  // This isn't going to work if there are unfetched events on the queue. Are
4862  // there cases where we might want to run the remaining events here, and
4863  // then try to call the function? That's probably being too tricky for our
4864  // own good.
4865 
4866  Event *other_events = listener_sp->PeekAtNextEvent();
4867  if (other_events != nullptr) {
4868  diagnostic_manager.PutString(
4870  "RunThreadPlan called with pending events on the queue.");
4871  return eExpressionSetupError;
4872  }
4873 
4874  // We also need to make sure that the next event is delivered. We might be
4875  // calling a function as part of a thread plan, in which case the last
4876  // delivered event could be the running event, and we don't want event
4877  // coalescing to cause us to lose OUR running event...
4879 
4880 // This while loop must exit out the bottom, there's cleanup that we need to do
4881 // when we are done. So don't call return anywhere within it.
4882 
4883 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
4884  // It's pretty much impossible to write test cases for things like: One
4885  // thread timeout expires, I go to halt, but the process already stopped on
4886  // the function call stop breakpoint. Turning on this define will make us
4887  // not fetch the first event till after the halt. So if you run a quick
4888  // function, it will have completed, and the completion event will be
4889  // waiting, when you interrupt for halt. The expression evaluation should
4890  // still succeed.
4891  bool miss_first_event = true;
4892 #endif
4893  while (true) {
4894  // We usually want to resume the process if we get to the top of the
4895  // loop. The only exception is if we get two running events with no
4896  // intervening stop, which can happen, we will just wait for then next
4897  // stop event.
4898  LLDB_LOGF(log,
4899  "Top of while loop: do_resume: %i handle_running_event: %i "
4900  "before_first_timeout: %i.",
4901  do_resume, handle_running_event, before_first_timeout);
4902 
4903  if (do_resume || handle_running_event) {
4904  // Do the initial resume and wait for the running event before going
4905  // further.
4906 
4907  if (do_resume) {
4908  num_resumes++;
4909  Status resume_error = PrivateResume();
4910  if (!resume_error.Success()) {
4911  diagnostic_manager.Printf(
4913  "couldn't resume inferior the %d time: \"%s\".", num_resumes,
4914  resume_error.AsCString());
4915  return_value = eExpressionSetupError;
4916  break;
4917  }
4918  }
4919 
4920  got_event =
4921  listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
4922  if (!got_event) {
4923  LLDB_LOGF(log,
4924  "Process::RunThreadPlan(): didn't get any event after "
4925  "resume %" PRIu32 ", exiting.",
4926  num_resumes);
4927 
4928  diagnostic_manager.Printf(eDiagnosticSeverityError,
4929  "didn't get any event after resume %" PRIu32
4930  ", exiting.",
4931  num_resumes);
4932  return_value = eExpressionSetupError;
4933  break;
4934  }
4935 
4936  stop_state =
4938 
4939  if (stop_state != eStateRunning) {
4940  bool restarted = false;
4941 
4942  if (stop_state == eStateStopped) {
4944  event_sp.get());
4945  LLDB_LOGF(
4946  log,
4947  "Process::RunThreadPlan(): didn't get running event after "
4948  "resume %d, got %s instead (restarted: %i, do_resume: %i, "
4949  "handle_running_event: %i).",
4950  num_resumes, StateAsCString(stop_state), restarted, do_resume,
4951  handle_running_event);
4952  }
4953 
4954  if (restarted) {
4955  // This is probably an overabundance of caution, I don't think I
4956  // should ever get a stopped & restarted event here. But if I do,
4957  // the best thing is to Halt and then get out of here.
4958  const bool clear_thread_plans = false;
4959  const bool use_run_lock = false;
4960  Halt(clear_thread_plans, use_run_lock);
4961  }
4962 
4963  diagnostic_manager.Printf(
4965  "didn't get running event after initial resume, got %s instead.",
4966  StateAsCString(stop_state));
4967  return_value = eExpressionSetupError;
4968  break;
4969  }
4970 
4971  if (log)
4972  log->PutCString("Process::RunThreadPlan(): resuming succeeded.");
4973  // We need to call the function synchronously, so spin waiting for it
4974  // to return. If we get interrupted while executing, we're going to
4975  // lose our context, and won't be able to gather the result at this
4976  // point. We set the timeout AFTER the resume, since the resume takes
4977  // some time and we don't want to charge that to the timeout.
4978  } else {
4979  if (log)
4980  log->PutCString("Process::RunThreadPlan(): waiting for next event.");
4981  }
4982 
4983  do_resume = true;
4984  handle_running_event = true;
4985 
4986  // Now wait for the process to stop again:
4987  event_sp.reset();
4988 
4989  Timeout<std::micro> timeout =
4990  GetExpressionTimeout(options, before_first_timeout);
4991  if (log) {
4992  if (timeout) {
4993  auto now = system_clock::now();
4994  LLDB_LOGF(log,
4995  "Process::RunThreadPlan(): about to wait - now is %s - "
4996  "endpoint is %s",
4997  llvm::to_string(now).c_str(),
4998  llvm::to_string(now + *timeout).c_str());
4999  } else {
5000  LLDB_LOGF(log, "Process::RunThreadPlan(): about to wait forever.");
5001  }
5002  }
5003 
5004 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5005  // See comment above...
5006  if (miss_first_event) {
5007  std::this_thread::sleep_for(std::chrono::milliseconds(1));
5008  miss_first_event = false;
5009  got_event = false;
5010  } else
5011 #endif
5012  got_event = listener_sp->GetEvent(event_sp, timeout);
5013 
5014  if (got_event) {
5015  if (event_sp) {
5016  bool keep_going = false;
5017  if (event_sp->GetType() == eBroadcastBitInterrupt) {
5018  const bool clear_thread_plans = false;
5019  const bool use_run_lock = false;
5020  Halt(clear_thread_plans, use_run_lock);
5021  return_value = eExpressionInterrupted;
5022  diagnostic_manager.PutString(eDiagnosticSeverityRemark,
5023  "execution halted by user interrupt.");
5024  LLDB_LOGF(log, "Process::RunThreadPlan(): Got interrupted by "
5025  "eBroadcastBitInterrupted, exiting.");
5026  break;
5027  } else {
5028  stop_state =
5030  LLDB_LOGF(log,
5031  "Process::RunThreadPlan(): in while loop, got event: %s.",
5032  StateAsCString(stop_state));
5033 
5034  switch (stop_state) {
5035  case lldb::eStateStopped: {
5037  event_sp.get())) {
5038  // If we were restarted, we just need to go back up to fetch
5039  // another event.
5040  LLDB_LOGF(log, "Process::RunThreadPlan(): Got a stop and "
5041  "restart, so we'll continue waiting.");
5042  keep_going = true;
5043  do_resume = false;
5044  handle_running_event = true;
5045  } else {
5046  const bool handle_interrupts = true;
5047  return_value = *HandleStoppedEvent(
5048  expr_thread_id, thread_plan_sp, thread_plan_restorer,
5049  event_sp, event_to_broadcast_sp, options,
5050  handle_interrupts);
5051  if (return_value == eExpressionThreadVanished)
5052  keep_going = false;
5053  }
5054  } break;
5055 
5056  case lldb::eStateRunning:
5057  // This shouldn't really happen, but sometimes we do get two
5058  // running events without an intervening stop, and in that case
5059  // we should just go back to waiting for the stop.
5060  do_resume = false;
5061  keep_going = true;
5062  handle_running_event = false;
5063  break;
5064 
5065  default:
5066  LLDB_LOGF(log,
5067  "Process::RunThreadPlan(): execution stopped with "
5068  "unexpected state: %s.",
5069  StateAsCString(stop_state));
5070 
5071  if (stop_state == eStateExited)
5072  event_to_broadcast_sp = event_sp;
5073 
5074  diagnostic_manager.PutString(
5076  "execution stopped with unexpected state.");
5077  return_value = eExpressionInterrupted;
5078  break;
5079  }
5080  }
5081 
5082  if (keep_going)
5083  continue;
5084  else
5085  break;
5086  } else {
5087  if (log)
5088  log->PutCString("Process::RunThreadPlan(): got_event was true, but "
5089  "the event pointer was null. How odd...");
5090  return_value = eExpressionInterrupted;
5091  break;
5092  }
5093  } else {
5094  // If we didn't get an event that means we've timed out... We will
5095  // interrupt the process here. Depending on what we were asked to do
5096  // we will either exit, or try with all threads running for the same
5097  // timeout.
5098 
5099  if (log) {
5100  if (options.GetTryAllThreads()) {
5101  if (before_first_timeout) {
5102  LLDB_LOG(log,
5103  "Running function with one thread timeout timed out.");
5104  } else
5105  LLDB_LOG(log, "Restarting function with all threads enabled and "
5106  "timeout: {0} timed out, abandoning execution.",
5107  timeout);
5108  } else
5109  LLDB_LOG(log, "Running function with timeout: {0} timed out, "
5110  "abandoning execution.",
5111  timeout);
5112  }
5113 
5114  // It is possible that between the time we issued the Halt, and we get
5115  // around to calling Halt the target could have stopped. That's fine,
5116  // Halt will figure that out and send the appropriate Stopped event.
5117  // BUT it is also possible that we stopped & restarted (e.g. hit a
5118  // signal with "stop" set to false.) In
5119  // that case, we'll get the stopped & restarted event, and we should go
5120  // back to waiting for the Halt's stopped event. That's what this
5121  // while loop does.
5122 
5123  bool back_to_top = true;
5124  uint32_t try_halt_again = 0;
5125  bool do_halt = true;
5126  const uint32_t num_retries = 5;
5127  while (try_halt_again < num_retries) {
5128  Status halt_error;
5129  if (do_halt) {
5130  LLDB_LOGF(log, "Process::RunThreadPlan(): Running Halt.");
5131  const bool clear_thread_plans = false;
5132  const bool use_run_lock = false;
5133  Halt(clear_thread_plans, use_run_lock);
5134  }
5135  if (halt_error.Success()) {
5136  if (log)
5137  log->PutCString("Process::RunThreadPlan(): Halt succeeded.");
5138 
5139  got_event =
5140  listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
5141 
5142  if (got_event) {
5143  stop_state =
5145  if (log) {
5146  LLDB_LOGF(log,
5147  "Process::RunThreadPlan(): Stopped with event: %s",
5148  StateAsCString(stop_state));
5149  if (stop_state == lldb::eStateStopped &&
5151  event_sp.get()))
5152  log->PutCString(" Event was the Halt interruption event.");
5153  }
5154 
5155  if (stop_state == lldb::eStateStopped) {
5157  event_sp.get())) {
5158  if (log)
5159  log->PutCString("Process::RunThreadPlan(): Went to halt "
5160  "but got a restarted event, there must be "
5161  "an un-restarted stopped event so try "
5162  "again... "
5163  "Exiting wait loop.");
5164  try_halt_again++;
5165  do_halt = false;
5166  continue;
5167  }
5168 
5169  // Between the time we initiated the Halt and the time we
5170  // delivered it, the process could have already finished its
5171  // job. Check that here:
5172  const bool handle_interrupts = false;
5173  if (auto result = HandleStoppedEvent(
5174  expr_thread_id, thread_plan_sp, thread_plan_restorer,
5175  event_sp, event_to_broadcast_sp, options,
5176  handle_interrupts)) {
5177  return_value = *result;
5178  back_to_top = false;
5179  break;
5180  }
5181 
5182  if (!options.GetTryAllThreads()) {
5183  if (log)
5184  log->PutCString("Process::RunThreadPlan(): try_all_threads "
5185  "was false, we stopped so now we're "
5186  "quitting.");
5187  return_value = eExpressionInterrupted;
5188  back_to_top = false;
5189  break;
5190  }
5191 
5192  if (before_first_timeout) {
5193  // Set all the other threads to run, and return to the top of
5194  // the loop, which will continue;
5195  before_first_timeout = false;
5196  thread_plan_sp->SetStopOthers(false);
5197  if (log)
5198  log->PutCString(
5199  "Process::RunThreadPlan(): about to resume.");
5200 
5201  back_to_top = true;
5202  break;
5203  } else {
5204  // Running all threads failed, so return Interrupted.
5205  if (log)
5206  log->PutCString("Process::RunThreadPlan(): running all "
5207  "threads timed out.");
5208  return_value = eExpressionInterrupted;
5209  back_to_top = false;
5210  break;
5211  }
5212  }
5213  } else {
5214  if (log)
5215  log->PutCString("Process::RunThreadPlan(): halt said it "
5216  "succeeded, but I got no event. "
5217  "I'm getting out of here passing Interrupted.");
5218  return_value = eExpressionInterrupted;
5219  back_to_top = false;
5220  break;
5221  }
5222  } else {
5223  try_halt_again++;
5224  continue;
5225  }
5226  }
5227 
5228  if (!back_to_top || try_halt_again > num_retries)
5229  break;
5230  else
5231  continue;
5232  }
5233  } // END WAIT LOOP
5234 
5235  // If we had to start up a temporary private state thread to run this
5236  // thread plan, shut it down now.
5237  if (backup_private_state_thread.IsJoinable()) {
5239  Status error;
5240  m_private_state_thread = backup_private_state_thread;
5241  if (stopper_base_plan_sp) {
5242  thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
5243  }
5244  if (old_state != eStateInvalid)
5245  m_public_state.SetValueNoLock(old_state);
5246  }
5247 
5248  // If our thread went away on us, we need to get out of here without
5249  // doing any more work. We don't have to clean up the thread plan, that
5250  // will have happened when the Thread was destroyed.
5251  if (return_value == eExpressionThreadVanished) {
5252  return return_value;
5253  }
5254 
5255  if (return_value != eExpressionCompleted && log) {
5256  // Print a backtrace into the log so we can figure out where we are:
5257  StreamString s;
5258  s.PutCString("Thread state after unsuccessful completion: \n");
5259  thread->GetStackFrameStatus(s, 0, UINT32_MAX, true, UINT32_MAX);
5260  log->PutString(s.GetString());
5261  }
5262  // Restore the thread state if we are going to discard the plan execution.
5263  // There are three cases where this could happen: 1) The execution
5264  // successfully completed 2) We hit a breakpoint, and ignore_breakpoints
5265  // was true 3) We got some other error, and discard_on_error was true
5266  bool should_unwind = (return_value == eExpressionInterrupted &&
5267  options.DoesUnwindOnError()) ||
5268  (return_value == eExpressionHitBreakpoint &&
5269  options.DoesIgnoreBreakpoints());
5270 
5271  if (return_value == eExpressionCompleted || should_unwind) {
5272  thread_plan_sp->RestoreThreadState();
5273  }
5274 
5275  // Now do some processing on the results of the run:
5276  if (return_value == eExpressionInterrupted ||
5277  return_value == eExpressionHitBreakpoint) {
5278  if (log) {
5279  StreamString s;
5280  if (event_sp)
5281  event_sp->Dump(&s);
5282  else {
5283  log->PutCString("Process::RunThreadPlan(): Stop event that "
5284  "interrupted us is NULL.");
5285  }
5286 
5287  StreamString ts;
5288 
5289  const char *event_explanation = nullptr;
5290 
5291  do {
5292  if (!event_sp) {
5293  event_explanation = "<no event>";
5294  break;
5295  } else if (event_sp->GetType() == eBroadcastBitInterrupt) {
5296  event_explanation = "<user interrupt>";
5297  break;
5298  } else {
5299  const Process::ProcessEventData *event_data =
5301  event_sp.get());
5302 
5303  if (!event_data) {
5304  event_explanation = "<no event data>";
5305  break;
5306  }
5307 
5308  Process *process = event_data->GetProcessSP().get();
5309 
5310  if (!process) {
5311  event_explanation = "<no process>";
5312  break;
5313  }
5314 
5315  ThreadList &thread_list = process->GetThreadList();
5316 
5317  uint32_t num_threads = thread_list.GetSize();
5318  uint32_t thread_index;
5319 
5320  ts.Printf("<%u threads> ", num_threads);
5321 
5322  for (thread_index = 0; thread_index < num_threads; ++thread_index) {
5323  Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
5324 
5325  if (!thread) {
5326  ts.Printf("<?> ");
5327  continue;
5328  }
5329 
5330  ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
5331  RegisterContext *register_context =
5332  thread->GetRegisterContext().get();
5333 
5334  if (register_context)
5335  ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
5336  else
5337  ts.Printf("[ip unknown] ");
5338 
5339  // Show the private stop info here, the public stop info will be
5340  // from the last natural stop.
5341  lldb::StopInfoSP stop_info_sp = thread->GetPrivateStopInfo();
5342  if (stop_info_sp) {
5343  const char *stop_desc = stop_info_sp->GetDescription();
5344  if (stop_desc)
5345  ts.PutCString(stop_desc);
5346  }
5347  ts.Printf(">");
5348  }
5349 
5350  event_explanation = ts.GetData();
5351  }
5352  } while (false);
5353 
5354  if (event_explanation)
5355  LLDB_LOGF(log,
5356  "Process::RunThreadPlan(): execution interrupted: %s %s",
5357  s.GetData(), event_explanation);
5358  else
5359  LLDB_LOGF(log, "Process::RunThreadPlan(): execution interrupted: %s",
5360  s.GetData());
5361  }
5362 
5363  if (should_unwind) {
5364  LLDB_LOGF(log,
5365  "Process::RunThreadPlan: ExecutionInterrupted - "
5366  "discarding thread plans up to %p.",
5367  static_cast<void *>(thread_plan_sp.get()));
5368  thread->DiscardThreadPlansUpToPlan(thread_plan_sp);
5369  } else {
5370  LLDB_LOGF(log,
5371  "Process::RunThreadPlan: ExecutionInterrupted - for "
5372  "plan: %p not discarding.",