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/Log.h"
71 #include "lldb/Utility/State.h"
72 #include "lldb/Utility/Timer.h"
73 
74 using namespace lldb;
75 using namespace lldb_private;
76 using namespace std::chrono;
77 
78 // Comment out line below to disable memory caching, overriding the process
79 // setting target.process.disable-memory-cache
80 #define ENABLE_MEMORY_CACHING
81 
82 #ifdef ENABLE_MEMORY_CACHING
83 #define DISABLE_MEM_CACHE_DEFAULT false
84 #else
85 #define DISABLE_MEM_CACHE_DEFAULT true
86 #endif
87 
89  : public Cloneable<ProcessOptionValueProperties, OptionValueProperties> {
90 public:
92 
94  bool will_modify,
95  uint32_t idx) const override {
96  // When getting the value for a key from the process options, we will
97  // always try and grab the setting from the current process if there is
98  // one. Else we just use the one from this instance.
99  if (exe_ctx) {
100  Process *process = exe_ctx->GetProcessPtr();
101  if (process) {
102  ProcessOptionValueProperties *instance_properties =
103  static_cast<ProcessOptionValueProperties *>(
104  process->GetValueProperties().get());
105  if (this != instance_properties)
106  return instance_properties->ProtectedGetPropertyAtIndex(idx);
107  }
108  }
109  return ProtectedGetPropertyAtIndex(idx);
110  }
111 };
112 
113 static constexpr OptionEnumValueElement g_follow_fork_mode_values[] = {
114  {
116  "parent",
117  "Continue tracing the parent process and detach the child.",
118  },
119  {
120  eFollowChild,
121  "child",
122  "Trace the child process and detach the parent.",
123  },
124 };
125 
126 #define LLDB_PROPERTIES_process
127 #include "TargetProperties.inc"
128 
129 enum {
130 #define LLDB_PROPERTIES_process
131 #include "TargetPropertiesEnum.inc"
133 };
134 
135 #define LLDB_PROPERTIES_process_experimental
136 #include "TargetProperties.inc"
137 
138 enum {
139 #define LLDB_PROPERTIES_process_experimental
140 #include "TargetPropertiesEnum.inc"
141 };
142 
144  : public Cloneable<ProcessExperimentalOptionValueProperties,
145  OptionValueProperties> {
146 public:
148  : Cloneable(
149  ConstString(Properties::GetExperimentalSettingsName())) {}
150 };
151 
152 ProcessExperimentalProperties::ProcessExperimentalProperties()
153  : Properties(OptionValuePropertiesSP(
155  m_collection_sp->Initialize(g_process_experimental_properties);
156 }
157 
159  : Properties(),
160  m_process(process) // Can be nullptr for global ProcessProperties
161 {
162  if (process == nullptr) {
163  // Global process properties, set them up one time
165  std::make_shared<ProcessOptionValueProperties>(ConstString("process"));
166  m_collection_sp->Initialize(g_process_properties);
167  m_collection_sp->AppendProperty(
168  ConstString("thread"), ConstString("Settings specific to threads."),
170  } else {
173  m_collection_sp->SetValueChangedCallback(
174  ePropertyPythonOSPluginPath,
175  [this] { m_process->LoadOperatingSystemPlugin(true); });
176  }
177 
179  std::make_unique<ProcessExperimentalProperties>();
180  m_collection_sp->AppendProperty(
182  ConstString("Experimental settings - setting these won't produce "
183  "errors if the setting is not present."),
184  true, m_experimental_properties_up->GetValueProperties());
185 }
186 
188 
190  const uint32_t idx = ePropertyDisableMemCache;
191  return m_collection_sp->GetPropertyAtIndexAsBoolean(
192  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
193 }
194 
196  const uint32_t idx = ePropertyMemCacheLineSize;
197  return m_collection_sp->GetPropertyAtIndexAsUInt64(
198  nullptr, idx, g_process_properties[idx].default_uint_value);
199 }
200 
202  Args args;
203  const uint32_t idx = ePropertyExtraStartCommand;
204  m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
205  return args;
206 }
207 
209  const uint32_t idx = ePropertyExtraStartCommand;
210  m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
211 }
212 
214  const uint32_t idx = ePropertyPythonOSPluginPath;
215  return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
216 }
217 
219  const uint32_t idx = ePropertyVirtualAddressableBits;
220  return m_collection_sp->GetPropertyAtIndexAsUInt64(
221  nullptr, idx, g_process_properties[idx].default_uint_value);
222 }
223 
225  const uint32_t idx = ePropertyVirtualAddressableBits;
226  m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, bits);
227 }
229  const uint32_t idx = ePropertyPythonOSPluginPath;
230  m_collection_sp->SetPropertyAtIndexAsFileSpec(nullptr, idx, file);
231 }
232 
234  const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
235  return m_collection_sp->GetPropertyAtIndexAsBoolean(
236  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
237 }
238 
240  const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
241  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
242 }
243 
245  const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
246  return m_collection_sp->GetPropertyAtIndexAsBoolean(
247  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
248 }
249 
251  const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
252  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
253 }
254 
256  const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
257  return m_collection_sp->GetPropertyAtIndexAsBoolean(
258  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
259 }
260 
262  const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
263  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
264 }
265 
267  const uint32_t idx = ePropertyDisableLangRuntimeUnwindPlans;
268  return m_collection_sp->GetPropertyAtIndexAsBoolean(
269  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
270 }
271 
273  const uint32_t idx = ePropertyDisableLangRuntimeUnwindPlans;
274  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, disable);
275  m_process->Flush();
276 }
277 
279  const uint32_t idx = ePropertyDetachKeepsStopped;
280  return m_collection_sp->GetPropertyAtIndexAsBoolean(
281  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
282 }
283 
285  const uint32_t idx = ePropertyDetachKeepsStopped;
286  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
287 }
288 
290  const uint32_t idx = ePropertyWarningOptimization;
291  return m_collection_sp->GetPropertyAtIndexAsBoolean(
292  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
293 }
294 
296  const uint32_t idx = ePropertyWarningUnsupportedLanguage;
297  return m_collection_sp->GetPropertyAtIndexAsBoolean(
298  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
299 }
300 
302  const uint32_t idx = ePropertyStopOnExec;
303  return m_collection_sp->GetPropertyAtIndexAsBoolean(
304  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
305 }
306 
308  const uint32_t idx = ePropertyUtilityExpressionTimeout;
309  uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
310  nullptr, idx, g_process_properties[idx].default_uint_value);
311  return std::chrono::seconds(value);
312 }
313 
314 std::chrono::seconds ProcessProperties::GetInterruptTimeout() const {
315  const uint32_t idx = ePropertyInterruptTimeout;
316  uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
317  nullptr, idx, g_process_properties[idx].default_uint_value);
318  return std::chrono::seconds(value);
319 }
320 
322  const uint32_t idx = ePropertySteppingRunsAllThreads;
323  return m_collection_sp->GetPropertyAtIndexAsBoolean(
324  nullptr, idx, g_process_properties[idx].default_uint_value != 0);
325 }
326 
328  const bool fail_value = true;
329  const Property *exp_property =
330  m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyExperimental);
331  OptionValueProperties *exp_values =
332  exp_property->GetValue()->GetAsProperties();
333  if (!exp_values)
334  return fail_value;
335 
336  return exp_values->GetPropertyAtIndexAsBoolean(
337  nullptr, ePropertyOSPluginReportsAllThreads, fail_value);
338 }
339 
341  const Property *exp_property =
342  m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyExperimental);
343  OptionValueProperties *exp_values =
344  exp_property->GetValue()->GetAsProperties();
345  if (exp_values)
346  exp_values->SetPropertyAtIndexAsBoolean(
347  nullptr, ePropertyOSPluginReportsAllThreads, does_report);
348 }
349 
351  const uint32_t idx = ePropertyFollowForkMode;
352  return (FollowForkMode)m_collection_sp->GetPropertyAtIndexAsEnumeration(
353  nullptr, idx, g_process_properties[idx].default_uint_value);
354 }
355 
356 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp,
357  llvm::StringRef plugin_name,
358  ListenerSP listener_sp,
359  const FileSpec *crash_file_path,
360  bool can_connect) {
361  static uint32_t g_process_unique_id = 0;
362 
363  ProcessSP process_sp;
364  ProcessCreateInstance create_callback = nullptr;
365  if (!plugin_name.empty()) {
366  ConstString const_plugin_name(plugin_name);
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_warnings_issued(),
440  m_run_thread_plan_lock(), m_can_jit(eCanJITDontKnow) {
442 
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 
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 
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 
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) {
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 
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) {
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) {
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 
1056  LLDB_LOGF(
1057  log, "Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1058  status, status, cstr ? "\"" : "", cstr ? cstr : "NULL", cstr ? "\"" : "");
1059 
1060  // We were already in the exited state
1062  LLDB_LOGF(log, "Process::SetExitStatus () ignoring exit status because "
1063  "state was already set to eStateExited");
1064  return false;
1065  }
1066 
1067  m_exit_status = status;
1068  if (cstr)
1069  m_exit_string = cstr;
1070  else
1071  m_exit_string.clear();
1072 
1073  // Clear the last natural stop ID since it has a strong reference to this
1074  // process
1076 
1078 
1079  // Allow subclasses to do some cleanup
1080  DidExit();
1081 
1082  return true;
1083 }
1084 
1086  switch (m_private_state.GetValue()) {
1087  case eStateConnected:
1088  case eStateAttaching:
1089  case eStateLaunching:
1090  case eStateStopped:
1091  case eStateRunning:
1092  case eStateStepping:
1093  case eStateCrashed:
1094  case eStateSuspended:
1095  return true;
1096  default:
1097  return false;
1098  }
1099 }
1100 
1101 // This static callback can be used to watch for local child processes on the
1102 // current host. The child process exits, the process will be found in the
1103 // global target list (we want to be completely sure that the
1104 // lldb_private::Process doesn't go away before we can deliver the signal.
1106  lldb::pid_t pid, bool exited,
1107  int signo, // Zero for no signal
1108  int exit_status // Exit value of process if signal is zero
1109  ) {
1111  LLDB_LOGF(log,
1112  "Process::SetProcessExitStatus (pid=%" PRIu64
1113  ", exited=%i, signal=%i, exit_status=%i)\n",
1114  pid, exited, signo, exit_status);
1115 
1116  if (exited) {
1117  TargetSP target_sp(Debugger::FindTargetWithProcessID(pid));
1118  if (target_sp) {
1119  ProcessSP process_sp(target_sp->GetProcessSP());
1120  if (process_sp) {
1121  const char *signal_cstr = nullptr;
1122  if (signo)
1123  signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
1124 
1125  process_sp->SetExitStatus(exit_status, signal_cstr);
1126  }
1127  }
1128  return true;
1129  }
1130  return false;
1131 }
1132 
1134  ThreadList &new_thread_list) {
1136  return DoUpdateThreadList(old_thread_list, new_thread_list);
1137 }
1138 
1140  const uint32_t stop_id = GetStopID();
1141  if (m_thread_list.GetSize(false) == 0 ||
1142  stop_id != m_thread_list.GetStopID()) {
1143  bool clear_unused_threads = true;
1144  const StateType state = GetPrivateState();
1145  if (StateIsStoppedState(state, true)) {
1146  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
1147  m_thread_list.SetStopID(stop_id);
1148 
1149  // m_thread_list does have its own mutex, but we need to hold onto the
1150  // mutex between the call to UpdateThreadList(...) and the
1151  // os->UpdateThreadList(...) so it doesn't change on us
1152  ThreadList &old_thread_list = m_thread_list;
1153  ThreadList real_thread_list(this);
1154  ThreadList new_thread_list(this);
1155  // Always update the thread list with the protocol specific thread list,
1156  // but only update if "true" is returned
1157  if (UpdateThreadList(m_thread_list_real, real_thread_list)) {
1158  // Don't call into the OperatingSystem to update the thread list if we
1159  // are shutting down, since that may call back into the SBAPI's,
1160  // requiring the API lock which is already held by whoever is shutting
1161  // us down, causing a deadlock.
1163  if (os && !m_destroy_in_process) {
1164  // Clear any old backing threads where memory threads might have been
1165  // backed by actual threads from the lldb_private::Process subclass
1166  size_t num_old_threads = old_thread_list.GetSize(false);
1167  for (size_t i = 0; i < num_old_threads; ++i)
1168  old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
1169  // See if the OS plugin reports all threads. If it does, then
1170  // it is safe to clear unseen thread's plans here. Otherwise we
1171  // should preserve them in case they show up again:
1172  clear_unused_threads = GetOSPluginReportsAllThreads();
1173 
1174  // Turn off dynamic types to ensure we don't run any expressions.
1175  // Objective-C can run an expression to determine if a SBValue is a
1176  // dynamic type or not and we need to avoid this. OperatingSystem
1177  // plug-ins can't run expressions that require running code...
1178 
1179  Target &target = GetTarget();
1180  const lldb::DynamicValueType saved_prefer_dynamic =
1181  target.GetPreferDynamicValue();
1182  if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1184 
1185  // Now let the OperatingSystem plug-in update the thread list
1186 
1187  os->UpdateThreadList(
1188  old_thread_list, // Old list full of threads created by OS plug-in
1189  real_thread_list, // The actual thread list full of threads
1190  // created by each lldb_private::Process
1191  // subclass
1192  new_thread_list); // The new thread list that we will show to the
1193  // user that gets filled in
1194 
1195  if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1196  target.SetPreferDynamicValue(saved_prefer_dynamic);
1197  } else {
1198  // No OS plug-in, the new thread list is the same as the real thread
1199  // list.
1200  new_thread_list = real_thread_list;
1201  }
1202 
1203  m_thread_list_real.Update(real_thread_list);
1204  m_thread_list.Update(new_thread_list);
1205  m_thread_list.SetStopID(stop_id);
1206 
1208  // Clear any extended threads that we may have accumulated previously
1211 
1212  m_queue_list.Clear();
1214  }
1215  }
1216  // Now update the plan stack map.
1217  // If we do have an OS plugin, any absent real threads in the
1218  // m_thread_list have already been removed from the ThreadPlanStackMap.
1219  // So any remaining threads are OS Plugin threads, and those we want to
1220  // preserve in case they show up again.
1221  m_thread_plans.Update(m_thread_list, clear_unused_threads);
1222  }
1223  }
1224 }
1225 
1227  return m_thread_plans.Find(tid);
1228 }
1229 
1231  return m_thread_plans.PrunePlansForTID(tid);
1232 }
1233 
1235  m_thread_plans.Update(GetThreadList(), true, false);
1236 }
1237 
1239  lldb::DescriptionLevel desc_level,
1240  bool internal, bool condense_trivial,
1241  bool skip_unreported_plans) {
1243  strm, tid, desc_level, internal, condense_trivial, skip_unreported_plans);
1244 }
1246  bool internal, bool condense_trivial,
1247  bool skip_unreported_plans) {
1248  m_thread_plans.DumpPlans(strm, desc_level, internal, condense_trivial,
1249  skip_unreported_plans);
1250 }
1251 
1253  if (m_system_runtime_up) {
1254  if (m_queue_list.GetSize() == 0 ||
1256  const StateType state = GetPrivateState();
1257  if (StateIsStoppedState(state, true)) {
1258  m_system_runtime_up->PopulateQueueList(m_queue_list);
1260  }
1261  }
1262  }
1263 }
1264 
1267  if (os)
1268  return os->CreateThread(tid, context);
1269  return ThreadSP();
1270 }
1271 
1273  return AssignIndexIDToThread(thread_id);
1274 }
1275 
1276 bool Process::HasAssignedIndexIDToThread(uint64_t thread_id) {
1277  return (m_thread_id_to_index_id_map.find(thread_id) !=
1279 }
1280 
1282  uint32_t result = 0;
1283  std::map<uint64_t, uint32_t>::iterator iterator =
1284  m_thread_id_to_index_id_map.find(thread_id);
1285  if (iterator == m_thread_id_to_index_id_map.end()) {
1286  result = ++m_thread_index_id;
1287  m_thread_id_to_index_id_map[thread_id] = result;
1288  } else {
1289  result = iterator->second;
1290  }
1291 
1292  return result;
1293 }
1294 
1296  return m_public_state.GetValue();
1297 }
1298 
1299 void Process::SetPublicState(StateType new_state, bool restarted) {
1302  LLDB_LOGF(log, "Process::SetPublicState (state = %s, restarted = %i)",
1303  StateAsCString(new_state), restarted);
1304  const StateType old_state = m_public_state.GetValue();
1305  m_public_state.SetValue(new_state);
1306 
1307  // On the transition from Run to Stopped, we unlock the writer end of the run
1308  // lock. The lock gets locked in Resume, which is the public API to tell the
1309  // program to run.
1311  if (new_state == eStateDetached) {
1312  LLDB_LOGF(log,
1313  "Process::SetPublicState (%s) -- unlocking run lock for detach",
1314  StateAsCString(new_state));
1316  } else {
1317  const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1318  const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1319  if ((old_state_is_stopped != new_state_is_stopped)) {
1320  if (new_state_is_stopped && !restarted) {
1321  LLDB_LOGF(log, "Process::SetPublicState (%s) -- unlocking run lock",
1322  StateAsCString(new_state));
1324  }
1325  }
1326  }
1327  }
1328 }
1329 
1333  LLDB_LOGF(log, "Process::Resume -- locking run lock");
1335  Status error("Resume request failed - process still running.");
1336  LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1337  return error;
1338  }
1340  if (!error.Success()) {
1341  // Undo running state change
1343  }
1344  return error;
1345 }
1346 
1347 static const char *g_resume_sync_name = "lldb.Process.ResumeSynchronous.hijack";
1348 
1352  LLDB_LOGF(log, "Process::ResumeSynchronous -- locking run lock");
1354  Status error("Resume request failed - process still running.");
1355  LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1356  return error;
1357  }
1358 
1359  ListenerSP listener_sp(
1361  HijackProcessEvents(listener_sp);
1362 
1364  if (error.Success()) {
1365  StateType state = WaitForProcessToStop(llvm::None, nullptr, true,
1366  listener_sp, stream);
1367  const bool must_be_alive =
1368  false; // eStateExited is ok, so this must be false
1369  if (!StateIsStoppedState(state, must_be_alive))
1370  error.SetErrorStringWithFormat(
1371  "process not in stopped state after synchronous resume: %s",
1372  StateAsCString(state));
1373  } else {
1374  // Undo running state change
1376  }
1377 
1378  // Undo the hijacking of process events...
1380 
1381  return error;
1382 }
1383 
1386  const char *hijacking_name = GetHijackingListenerName();
1387  if (hijacking_name &&
1388  strcmp(hijacking_name, g_resume_sync_name))
1389  return true;
1390  }
1391  return false;
1392 }
1393 
1396  const char *hijacking_name = GetHijackingListenerName();
1397  if (hijacking_name &&
1398  strcmp(hijacking_name, g_resume_sync_name) == 0)
1399  return true;
1400  }
1401  return false;
1402 }
1403 
1405 
1407  if (m_finalizing)
1408  return;
1409 
1412  bool state_changed = false;
1413 
1414  LLDB_LOGF(log, "Process::SetPrivateState (%s)", StateAsCString(new_state));
1415 
1416  std::lock_guard<std::recursive_mutex> thread_guard(m_thread_list.GetMutex());
1417  std::lock_guard<std::recursive_mutex> guard(m_private_state.GetMutex());
1418 
1419  const StateType old_state = m_private_state.GetValueNoLock();
1420  state_changed = old_state != new_state;
1421 
1422  const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1423  const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1424  if (old_state_is_stopped != new_state_is_stopped) {
1425  if (new_state_is_stopped)
1427  else
1429  }
1430 
1431  if (state_changed) {
1432  m_private_state.SetValueNoLock(new_state);
1433  EventSP event_sp(
1435  new ProcessEventData(shared_from_this(), new_state)));
1436  if (StateIsStoppedState(new_state, false)) {
1437  // Note, this currently assumes that all threads in the list stop when
1438  // the process stops. In the future we will want to support a debugging
1439  // model where some threads continue to run while others are stopped.
1440  // When that happens we will either need a way for the thread list to
1441  // identify which threads are stopping or create a special thread list
1442  // containing only threads which actually stopped.
1443  //
1444  // The process plugin is responsible for managing the actual behavior of
1445  // the threads and should have stopped any threads that are going to stop
1446  // before we get here.
1448 
1449  m_mod_id.BumpStopID();
1453  LLDB_LOGF(log, "Process::SetPrivateState (%s) stop_id = %u",
1454  StateAsCString(new_state), m_mod_id.GetStopID());
1455  }
1456 
1458  } else {
1459  LLDB_LOGF(log,
1460  "Process::SetPrivateState (%s) state didn't change. Ignoring...",
1461  StateAsCString(new_state));
1462  }
1463 }
1464 
1467 }
1468 
1471 }
1472 
1474 
1475 const lldb::ABISP &Process::GetABI() {
1476  if (!m_abi_sp)
1477  m_abi_sp = ABI::FindPlugin(shared_from_this(), GetTarget().GetArchitecture());
1478  return m_abi_sp;
1479 }
1480 
1481 std::vector<LanguageRuntime *> Process::GetLanguageRuntimes() {
1482  std::vector<LanguageRuntime *> language_runtimes;
1483 
1484  if (m_finalizing)
1485  return language_runtimes;
1486 
1487  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
1488  // Before we pass off a copy of the language runtimes, we must make sure that
1489  // our collection is properly populated. It's possible that some of the
1490  // language runtimes were not loaded yet, either because nobody requested it
1491  // yet or the proper condition for loading wasn't yet met (e.g. libc++.so
1492  // hadn't been loaded).
1493  for (const lldb::LanguageType lang_type : Language::GetSupportedLanguages()) {
1494  if (LanguageRuntime *runtime = GetLanguageRuntime(lang_type))
1495  language_runtimes.emplace_back(runtime);
1496  }
1497 
1498  return language_runtimes;
1499 }
1500 
1502  if (m_finalizing)
1503  return nullptr;
1504 
1505  LanguageRuntime *runtime = nullptr;
1506 
1507  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
1508  LanguageRuntimeCollection::iterator pos;
1509  pos = m_language_runtimes.find(language);
1510  if (pos == m_language_runtimes.end() || !pos->second) {
1511  lldb::LanguageRuntimeSP runtime_sp(
1512  LanguageRuntime::FindPlugin(this, language));
1513 
1514  m_language_runtimes[language] = runtime_sp;
1515  runtime = runtime_sp.get();
1516  } else
1517  runtime = pos->second.get();
1518 
1519  if (runtime)
1520  // It's possible that a language runtime can support multiple LanguageTypes,
1521  // for example, CPPLanguageRuntime will support eLanguageTypeC_plus_plus,
1522  // eLanguageTypeC_plus_plus_03, etc. Because of this, we should get the
1523  // primary language type and make sure that our runtime supports it.
1524  assert(runtime->GetLanguageType() == Language::GetPrimaryLanguage(language));
1525 
1526  return runtime;
1527 }
1528 
1530  if (m_finalizing)
1531  return false;
1532 
1533  if (in_value.IsDynamic())
1534  return false;
1535  LanguageType known_type = in_value.GetObjectRuntimeLanguage();
1536 
1537  if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC) {
1538  LanguageRuntime *runtime = GetLanguageRuntime(known_type);
1539  return runtime ? runtime->CouldHaveDynamicValue(in_value) : false;
1540  }
1541 
1542  for (LanguageRuntime *runtime : GetLanguageRuntimes()) {
1543  if (runtime->CouldHaveDynamicValue(in_value))
1544  return true;
1545  }
1546 
1547  return false;
1548 }
1549 
1551  m_dynamic_checkers_up.reset(dynamic_checkers);
1552 }
1553 
1555  return m_breakpoint_site_list;
1556 }
1557 
1559  return m_breakpoint_site_list;
1560 }
1561 
1563  m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void {
1564  // bp_site->SetEnabled(true);
1565  DisableBreakpointSite(bp_site);
1566  });
1567 }
1568 
1571 
1572  if (error.Success())
1573  m_breakpoint_site_list.Remove(break_id);
1574 
1575  return error;
1576 }
1577 
1579  Status error;
1580  BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID(break_id);
1581  if (bp_site_sp) {
1582  if (bp_site_sp->IsEnabled())
1583  error = DisableBreakpointSite(bp_site_sp.get());
1584  } else {
1585  error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64,
1586  break_id);
1587  }
1588 
1589  return error;
1590 }
1591 
1593  Status error;
1594  BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID(break_id);
1595  if (bp_site_sp) {
1596  if (!bp_site_sp->IsEnabled())
1597  error = EnableBreakpointSite(bp_site_sp.get());
1598  } else {
1599  error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64,
1600  break_id);
1601  }
1602  return error;
1603 }
1604 
1606 Process::CreateBreakpointSite(const BreakpointLocationSP &owner,
1607  bool use_hardware) {
1608  addr_t load_addr = LLDB_INVALID_ADDRESS;
1609 
1610  bool show_error = true;
1611  switch (GetState()) {
1612  case eStateInvalid:
1613  case eStateUnloaded:
1614  case eStateConnected:
1615  case eStateAttaching:
1616  case eStateLaunching:
1617  case eStateDetached:
1618  case eStateExited:
1619  show_error = false;
1620  break;
1621 
1622  case eStateStopped:
1623  case eStateRunning:
1624  case eStateStepping:
1625  case eStateCrashed:
1626  case eStateSuspended:
1627  show_error = IsAlive();
1628  break;
1629  }
1630 
1631  // Reset the IsIndirect flag here, in case the location changes from pointing
1632  // to a indirect symbol to a regular symbol.
1633  owner->SetIsIndirect(false);
1634 
1635  if (owner->ShouldResolveIndirectFunctions()) {
1636  Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
1637  if (symbol && symbol->IsIndirect()) {
1638  Status error;
1639  Address symbol_address = symbol->GetAddress();
1640  load_addr = ResolveIndirectFunction(&symbol_address, error);
1641  if (!error.Success() && show_error) {
1643  "warning: failed to resolve indirect function at 0x%" PRIx64
1644  " for breakpoint %i.%i: %s\n",
1645  symbol->GetLoadAddress(&GetTarget()),
1646  owner->GetBreakpoint().GetID(), owner->GetID(),
1647  error.AsCString() ? error.AsCString() : "unknown error");
1648  return LLDB_INVALID_BREAK_ID;
1649  }
1650  Address resolved_address(load_addr);
1651  load_addr = resolved_address.GetOpcodeLoadAddress(&GetTarget());
1652  owner->SetIsIndirect(true);
1653  } else
1654  load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget());
1655  } else
1656  load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget());
1657 
1658  if (load_addr != LLDB_INVALID_ADDRESS) {
1659  BreakpointSiteSP bp_site_sp;
1660 
1661  // Look up this breakpoint site. If it exists, then add this new owner,
1662  // otherwise create a new breakpoint site and add it.
1663 
1664  bp_site_sp = m_breakpoint_site_list.FindByAddress(load_addr);
1665 
1666  if (bp_site_sp) {
1667  bp_site_sp->AddOwner(owner);
1668  owner->SetBreakpointSite(bp_site_sp);
1669  return bp_site_sp->GetID();
1670  } else {
1671  bp_site_sp.reset(new BreakpointSite(&m_breakpoint_site_list, owner,
1672  load_addr, use_hardware));
1673  if (bp_site_sp) {
1674  Status error = EnableBreakpointSite(bp_site_sp.get());
1675  if (error.Success()) {
1676  owner->SetBreakpointSite(bp_site_sp);
1677  return m_breakpoint_site_list.Add(bp_site_sp);
1678  } else {
1679  if (show_error || use_hardware) {
1680  // Report error for setting breakpoint...
1682  "warning: failed to set breakpoint site at 0x%" PRIx64
1683  " for breakpoint %i.%i: %s\n",
1684  load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
1685  error.AsCString() ? error.AsCString() : "unknown error");
1686  }
1687  }
1688  }
1689  }
1690  }
1691  // We failed to enable the breakpoint
1692  return LLDB_INVALID_BREAK_ID;
1693 }
1694 
1696  lldb::user_id_t owner_loc_id,
1697  BreakpointSiteSP &bp_site_sp) {
1698  uint32_t num_owners = bp_site_sp->RemoveOwner(owner_id, owner_loc_id);
1699  if (num_owners == 0) {
1700  // Don't try to disable the site if we don't have a live process anymore.
1701  if (IsAlive())
1702  DisableBreakpointSite(bp_site_sp.get());
1703  m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
1704  }
1705 }
1706 
1708  uint8_t *buf) const {
1709  size_t bytes_removed = 0;
1710  BreakpointSiteList bp_sites_in_range;
1711 
1712  if (m_breakpoint_site_list.FindInRange(bp_addr, bp_addr + size,
1713  bp_sites_in_range)) {
1714  bp_sites_in_range.ForEach([bp_addr, size,
1715  buf](BreakpointSite *bp_site) -> void {
1716  if (bp_site->GetType() == BreakpointSite::eSoftware) {
1717  addr_t intersect_addr;
1718  size_t intersect_size;
1719  size_t opcode_offset;
1720  if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr,
1721  &intersect_size, &opcode_offset)) {
1722  assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
1723  assert(bp_addr < intersect_addr + intersect_size &&
1724  intersect_addr + intersect_size <= bp_addr + size);
1725  assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
1726  size_t buf_offset = intersect_addr - bp_addr;
1727  ::memcpy(buf + buf_offset,
1728  bp_site->GetSavedOpcodeBytes() + opcode_offset,
1729  intersect_size);
1730  }
1731  }
1732  });
1733  }
1734  return bytes_removed;
1735 }
1736 
1737 size_t Process::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
1738  PlatformSP platform_sp(GetTarget().GetPlatform());
1739  if (platform_sp)
1740  return platform_sp->GetSoftwareBreakpointTrapOpcode(GetTarget(), bp_site);
1741  return 0;
1742 }
1743 
1745  Status error;
1746  assert(bp_site != nullptr);
1748  const addr_t bp_addr = bp_site->GetLoadAddress();
1749  LLDB_LOGF(
1750  log, "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64,
1751  bp_site->GetID(), (uint64_t)bp_addr);
1752  if (bp_site->IsEnabled()) {
1753  LLDB_LOGF(
1754  log,
1755  "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1756  " -- already enabled",
1757  bp_site->GetID(), (uint64_t)bp_addr);
1758  return error;
1759  }
1760 
1761  if (bp_addr == LLDB_INVALID_ADDRESS) {
1762  error.SetErrorString("BreakpointSite contains an invalid load address.");
1763  return error;
1764  }
1765  // Ask the lldb::Process subclass to fill in the correct software breakpoint
1766  // trap for the breakpoint site
1767  const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
1768 
1769  if (bp_opcode_size == 0) {
1770  error.SetErrorStringWithFormat("Process::GetSoftwareBreakpointTrapOpcode() "
1771  "returned zero, unable to get breakpoint "
1772  "trap for address 0x%" PRIx64,
1773  bp_addr);
1774  } else {
1775  const uint8_t *const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
1776 
1777  if (bp_opcode_bytes == nullptr) {
1778  error.SetErrorString(
1779  "BreakpointSite doesn't contain a valid breakpoint trap opcode.");
1780  return error;
1781  }
1782 
1783  // Save the original opcode by reading it
1784  if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size,
1785  error) == bp_opcode_size) {
1786  // Write a software breakpoint in place of the original opcode
1787  if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) ==
1788  bp_opcode_size) {
1789  uint8_t verify_bp_opcode_bytes[64];
1790  if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size,
1791  error) == bp_opcode_size) {
1792  if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes,
1793  bp_opcode_size) == 0) {
1794  bp_site->SetEnabled(true);
1796  LLDB_LOGF(log,
1797  "Process::EnableSoftwareBreakpoint (site_id = %d) "
1798  "addr = 0x%" PRIx64 " -- SUCCESS",
1799  bp_site->GetID(), (uint64_t)bp_addr);
1800  } else
1801  error.SetErrorString(
1802  "failed to verify the breakpoint trap in memory.");
1803  } else
1804  error.SetErrorString(
1805  "Unable to read memory to verify breakpoint trap.");
1806  } else
1807  error.SetErrorString("Unable to write breakpoint trap to memory.");
1808  } else
1809  error.SetErrorString("Unable to read memory at breakpoint address.");
1810  }
1811  if (log && error.Fail())
1812  LLDB_LOGF(
1813  log,
1814  "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1815  " -- FAILED: %s",
1816  bp_site->GetID(), (uint64_t)bp_addr, error.AsCString());
1817  return error;
1818 }
1819 
1821  Status error;
1822  assert(bp_site != nullptr);
1824  addr_t bp_addr = bp_site->GetLoadAddress();
1825  lldb::user_id_t breakID = bp_site->GetID();
1826  LLDB_LOGF(log,
1827  "Process::DisableSoftwareBreakpoint (breakID = %" PRIu64
1828  ") addr = 0x%" PRIx64,
1829  breakID, (uint64_t)bp_addr);
1830 
1831  if (bp_site->IsHardware()) {
1832  error.SetErrorString("Breakpoint site is a hardware breakpoint.");
1833  } else if (bp_site->IsEnabled()) {
1834  const size_t break_op_size = bp_site->GetByteSize();
1835  const uint8_t *const break_op = bp_site->GetTrapOpcodeBytes();
1836  if (break_op_size > 0) {
1837  // Clear a software breakpoint instruction
1838  uint8_t curr_break_op[8];
1839  assert(break_op_size <= sizeof(curr_break_op));
1840  bool break_op_found = false;
1841 
1842  // Read the breakpoint opcode
1843  if (DoReadMemory(bp_addr, curr_break_op, break_op_size, error) ==
1844  break_op_size) {
1845  bool verify = false;
1846  // Make sure the breakpoint opcode exists at this address
1847  if (::memcmp(curr_break_op, break_op, break_op_size) == 0) {
1848  break_op_found = true;
1849  // We found a valid breakpoint opcode at this address, now restore
1850  // the saved opcode.
1851  if (DoWriteMemory(bp_addr, bp_site->GetSavedOpcodeBytes(),
1852  break_op_size, error) == break_op_size) {
1853  verify = true;
1854  } else
1855  error.SetErrorString(
1856  "Memory write failed when restoring original opcode.");
1857  } else {
1858  error.SetErrorString(
1859  "Original breakpoint trap is no longer in memory.");
1860  // Set verify to true and so we can check if the original opcode has
1861  // already been restored
1862  verify = true;
1863  }
1864 
1865  if (verify) {
1866  uint8_t verify_opcode[8];
1867  assert(break_op_size < sizeof(verify_opcode));
1868  // Verify that our original opcode made it back to the inferior
1869  if (DoReadMemory(bp_addr, verify_opcode, break_op_size, error) ==
1870  break_op_size) {
1871  // compare the memory we just read with the original opcode
1872  if (::memcmp(bp_site->GetSavedOpcodeBytes(), verify_opcode,
1873  break_op_size) == 0) {
1874  // SUCCESS
1875  bp_site->SetEnabled(false);
1876  LLDB_LOGF(log,
1877  "Process::DisableSoftwareBreakpoint (site_id = %d) "
1878  "addr = 0x%" PRIx64 " -- SUCCESS",
1879  bp_site->GetID(), (uint64_t)bp_addr);
1880  return error;
1881  } else {
1882  if (break_op_found)
1883  error.SetErrorString("Failed to restore original opcode.");
1884  }
1885  } else
1886  error.SetErrorString("Failed to read memory to verify that "
1887  "breakpoint trap was restored.");
1888  }
1889  } else
1890  error.SetErrorString(
1891  "Unable to read memory that should contain the breakpoint trap.");
1892  }
1893  } else {
1894  LLDB_LOGF(
1895  log,
1896  "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1897  " -- already disabled",
1898  bp_site->GetID(), (uint64_t)bp_addr);
1899  return error;
1900  }
1901 
1902  LLDB_LOGF(
1903  log,
1904  "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1905  " -- FAILED: %s",
1906  bp_site->GetID(), (uint64_t)bp_addr, error.AsCString());
1907  return error;
1908 }
1909 
1910 // Uncomment to verify memory caching works after making changes to caching
1911 // code
1912 //#define VERIFY_MEMORY_READS
1913 
1914 size_t Process::ReadMemory(addr_t addr, void *buf, size_t size, Status &error) {
1915  error.Clear();
1916  if (!GetDisableMemoryCache()) {
1917 #if defined(VERIFY_MEMORY_READS)
1918  // Memory caching is enabled, with debug verification
1919 
1920  if (buf && size) {
1921  // Uncomment the line below to make sure memory caching is working.
1922  // I ran this through the test suite and got no assertions, so I am
1923  // pretty confident this is working well. If any changes are made to
1924  // memory caching, uncomment the line below and test your changes!
1925 
1926  // Verify all memory reads by using the cache first, then redundantly
1927  // reading the same memory from the inferior and comparing to make sure
1928  // everything is exactly the same.
1929  std::string verify_buf(size, '\0');
1930  assert(verify_buf.size() == size);
1931  const size_t cache_bytes_read =
1932  m_memory_cache.Read(this, addr, buf, size, error);
1933  Status verify_error;
1934  const size_t verify_bytes_read =
1935  ReadMemoryFromInferior(addr, const_cast<char *>(verify_buf.data()),
1936  verify_buf.size(), verify_error);
1937  assert(cache_bytes_read == verify_bytes_read);
1938  assert(memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
1939  assert(verify_error.Success() == error.Success());
1940  return cache_bytes_read;
1941  }
1942  return 0;
1943 #else // !defined(VERIFY_MEMORY_READS)
1944  // Memory caching is enabled, without debug verification
1945 
1946  return m_memory_cache.Read(addr, buf, size, error);
1947 #endif // defined (VERIFY_MEMORY_READS)
1948  } else {
1949  // Memory caching is disabled
1950 
1951  return ReadMemoryFromInferior(addr, buf, size, error);
1952  }
1953 }
1954 
1956  Status &error) {
1957  char buf[256];
1958  out_str.clear();
1959  addr_t curr_addr = addr;
1960  while (true) {
1961  size_t length = ReadCStringFromMemory(curr_addr, buf, sizeof(buf), error);
1962  if (length == 0)
1963  break;
1964  out_str.append(buf, length);
1965  // If we got "length - 1" bytes, we didn't get the whole C string, we need
1966  // to read some more characters
1967  if (length == sizeof(buf) - 1)
1968  curr_addr += length;
1969  else
1970  break;
1971  }
1972  return out_str.size();
1973 }
1974 
1975 size_t Process::ReadStringFromMemory(addr_t addr, char *dst, size_t max_bytes,
1976  Status &error, size_t type_width) {
1977  size_t total_bytes_read = 0;
1978  if (dst && max_bytes && type_width && max_bytes >= type_width) {
1979  // Ensure a null terminator independent of the number of bytes that is
1980  // read.
1981  memset(dst, 0, max_bytes);
1982  size_t bytes_left = max_bytes - type_width;
1983 
1984  const char terminator[4] = {'\0', '\0', '\0', '\0'};
1985  assert(sizeof(terminator) >= type_width && "Attempting to validate a "
1986  "string with more than 4 bytes "
1987  "per character!");
1988 
1989  addr_t curr_addr = addr;
1990  const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
1991  char *curr_dst = dst;
1992 
1993  error.Clear();
1994  while (bytes_left > 0 && error.Success()) {
1995  addr_t cache_line_bytes_left =
1996  cache_line_size - (curr_addr % cache_line_size);
1997  addr_t bytes_to_read =
1998  std::min<addr_t>(bytes_left, cache_line_bytes_left);
1999  size_t bytes_read = ReadMemory(curr_addr, curr_dst, bytes_to_read, error);
2000 
2001  if (bytes_read == 0)
2002  break;
2003 
2004  // Search for a null terminator of correct size and alignment in
2005  // bytes_read
2006  size_t aligned_start = total_bytes_read - total_bytes_read % type_width;
2007  for (size_t i = aligned_start;
2008  i + type_width <= total_bytes_read + bytes_read; i += type_width)
2009  if (::memcmp(&dst[i], terminator, type_width) == 0) {
2010  error.Clear();
2011  return i;
2012  }
2013 
2014  total_bytes_read += bytes_read;
2015  curr_dst += bytes_read;
2016  curr_addr += bytes_read;
2017  bytes_left -= bytes_read;
2018  }
2019  } else {
2020  if (max_bytes)
2021  error.SetErrorString("invalid arguments");
2022  }
2023  return total_bytes_read;
2024 }
2025 
2026 // Deprecated in favor of ReadStringFromMemory which has wchar support and
2027 // correct code to find null terminators.
2029  size_t dst_max_len,
2030  Status &result_error) {
2031  size_t total_cstr_len = 0;
2032  if (dst && dst_max_len) {
2033  result_error.Clear();
2034  // NULL out everything just to be safe
2035  memset(dst, 0, dst_max_len);
2036  Status error;
2037  addr_t curr_addr = addr;
2038  const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2039  size_t bytes_left = dst_max_len - 1;
2040  char *curr_dst = dst;
2041 
2042  while (bytes_left > 0) {
2043  addr_t cache_line_bytes_left =
2044  cache_line_size - (curr_addr % cache_line_size);
2045  addr_t bytes_to_read =
2046  std::min<addr_t>(bytes_left, cache_line_bytes_left);
2047  size_t bytes_read = ReadMemory(curr_addr, curr_dst, bytes_to_read, error);
2048 
2049  if (bytes_read == 0) {
2050  result_error = error;
2051  dst[total_cstr_len] = '\0';
2052  break;
2053  }
2054  const size_t len = strlen(curr_dst);
2055 
2056  total_cstr_len += len;
2057 
2058  if (len < bytes_to_read)
2059  break;
2060 
2061  curr_dst += bytes_read;
2062  curr_addr += bytes_read;
2063  bytes_left -= bytes_read;
2064  }
2065  } else {
2066  if (dst == nullptr)
2067  result_error.SetErrorString("invalid arguments");
2068  else
2069  result_error.Clear();
2070  }
2071  return total_cstr_len;
2072 }
2073 
2074 size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size,
2075  Status &error) {
2077 
2078  if (buf == nullptr || size == 0)
2079  return 0;
2080 
2081  size_t bytes_read = 0;
2082  uint8_t *bytes = (uint8_t *)buf;
2083 
2084  while (bytes_read < size) {
2085  const size_t curr_size = size - bytes_read;
2086  const size_t curr_bytes_read =
2087  DoReadMemory(addr + bytes_read, bytes + bytes_read, curr_size, error);
2088  bytes_read += curr_bytes_read;
2089  if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2090  break;
2091  }
2092 
2093  // Replace any software breakpoint opcodes that fall into this range back
2094  // into "buf" before we return
2095  if (bytes_read > 0)
2096  RemoveBreakpointOpcodesFromBuffer(addr, bytes_read, (uint8_t *)buf);
2097  return bytes_read;
2098 }
2099 
2101  size_t integer_byte_size,
2102  uint64_t fail_value,
2103  Status &error) {
2104  Scalar scalar;
2105  if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar,
2106  error))
2107  return scalar.ULongLong(fail_value);
2108  return fail_value;
2109 }
2110 
2112  size_t integer_byte_size,
2113  int64_t fail_value,
2114  Status &error) {
2115  Scalar scalar;
2116  if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, true, scalar,
2117  error))
2118  return scalar.SLongLong(fail_value);
2119  return fail_value;
2120 }
2121 
2123  Scalar scalar;
2124  if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar,
2125  error))
2126  return scalar.ULongLong(LLDB_INVALID_ADDRESS);
2127  return LLDB_INVALID_ADDRESS;
2128 }
2129 
2131  Status &error) {
2132  Scalar scalar;
2133  const uint32_t addr_byte_size = GetAddressByteSize();
2134  if (addr_byte_size <= 4)
2135  scalar = (uint32_t)ptr_value;
2136  else
2137  scalar = ptr_value;
2138  return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) ==
2139  addr_byte_size;
2140 }
2141 
2142 size_t Process::WriteMemoryPrivate(addr_t addr, const void *buf, size_t size,
2143  Status &error) {
2144  size_t bytes_written = 0;
2145  const uint8_t *bytes = (const uint8_t *)buf;
2146 
2147  while (bytes_written < size) {
2148  const size_t curr_size = size - bytes_written;
2149  const size_t curr_bytes_written = DoWriteMemory(
2150  addr + bytes_written, bytes + bytes_written, curr_size, error);
2151  bytes_written += curr_bytes_written;
2152  if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2153  break;
2154  }
2155  return bytes_written;
2156 }
2157 
2158 size_t Process::WriteMemory(addr_t addr, const void *buf, size_t size,
2159  Status &error) {
2160 #if defined(ENABLE_MEMORY_CACHING)
2161  m_memory_cache.Flush(addr, size);
2162 #endif
2163 
2164  if (buf == nullptr || size == 0)
2165  return 0;
2166 
2168 
2169  // We need to write any data that would go where any current software traps
2170  // (enabled software breakpoints) any software traps (breakpoints) that we
2171  // may have placed in our tasks memory.
2172 
2173  BreakpointSiteList bp_sites_in_range;
2174  if (!m_breakpoint_site_list.FindInRange(addr, addr + size, bp_sites_in_range))
2175  return WriteMemoryPrivate(addr, buf, size, error);
2176 
2177  // No breakpoint sites overlap
2178  if (bp_sites_in_range.IsEmpty())
2179  return WriteMemoryPrivate(addr, buf, size, error);
2180 
2181  const uint8_t *ubuf = (const uint8_t *)buf;
2182  uint64_t bytes_written = 0;
2183 
2184  bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf,
2185  &error](BreakpointSite *bp) -> void {
2186  if (error.Fail())
2187  return;
2188 
2189  if (bp->GetType() != BreakpointSite::eSoftware)
2190  return;
2191 
2192  addr_t intersect_addr;
2193  size_t intersect_size;
2194  size_t opcode_offset;
2195  const bool intersects = bp->IntersectsRange(
2196  addr, size, &intersect_addr, &intersect_size, &opcode_offset);
2197  UNUSED_IF_ASSERT_DISABLED(intersects);
2198  assert(intersects);
2199  assert(addr <= intersect_addr && intersect_addr < addr + size);
2200  assert(addr < intersect_addr + intersect_size &&
2201  intersect_addr + intersect_size <= addr + size);
2202  assert(opcode_offset + intersect_size <= bp->GetByteSize());
2203 
2204  // Check for bytes before this breakpoint
2205  const addr_t curr_addr = addr + bytes_written;
2206  if (intersect_addr > curr_addr) {
2207  // There are some bytes before this breakpoint that we need to just
2208  // write to memory
2209  size_t curr_size = intersect_addr - curr_addr;
2210  size_t curr_bytes_written =
2211  WriteMemoryPrivate(curr_addr, ubuf + bytes_written, curr_size, error);
2212  bytes_written += curr_bytes_written;
2213  if (curr_bytes_written != curr_size) {
2214  // We weren't able to write all of the requested bytes, we are
2215  // done looping and will return the number of bytes that we have
2216  // written so far.
2217  if (error.Success())
2218  error.SetErrorToGenericError();
2219  }
2220  }
2221  // Now write any bytes that would cover up any software breakpoints
2222  // directly into the breakpoint opcode buffer
2223  ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written,
2224  intersect_size);
2225  bytes_written += intersect_size;
2226  });
2227 
2228  // Write any remaining bytes after the last breakpoint if we have any left
2229  if (bytes_written < size)
2230  bytes_written +=
2231  WriteMemoryPrivate(addr + bytes_written, ubuf + bytes_written,
2232  size - bytes_written, error);
2233 
2234  return bytes_written;
2235 }
2236 
2237 size_t Process::WriteScalarToMemory(addr_t addr, const Scalar &scalar,
2238  size_t byte_size, Status &error) {
2239  if (byte_size == UINT32_MAX)
2240  byte_size = scalar.GetByteSize();
2241  if (byte_size > 0) {
2242  uint8_t buf[32];
2243  const size_t mem_size =
2244  scalar.GetAsMemoryData(buf, byte_size, GetByteOrder(), error);
2245  if (mem_size > 0)
2246  return WriteMemory(addr, buf, mem_size, error);
2247  else
2248  error.SetErrorString("failed to get scalar as memory data");
2249  } else {
2250  error.SetErrorString("invalid scalar value");
2251  }
2252  return 0;
2253 }
2254 
2256  bool is_signed, Scalar &scalar,
2257  Status &error) {
2258  uint64_t uval = 0;
2259  if (byte_size == 0) {
2260  error.SetErrorString("byte size is zero");
2261  } else if (byte_size & (byte_size - 1)) {
2262  error.SetErrorStringWithFormat("byte size %u is not a power of 2",
2263  byte_size);
2264  } else if (byte_size <= sizeof(uval)) {
2265  const size_t bytes_read = ReadMemory(addr, &uval, byte_size, error);
2266  if (bytes_read == byte_size) {
2267  DataExtractor data(&uval, sizeof(uval), GetByteOrder(),
2268  GetAddressByteSize());
2269  lldb::offset_t offset = 0;
2270  if (byte_size <= 4)
2271  scalar = data.GetMaxU32(&offset, byte_size);
2272  else
2273  scalar = data.GetMaxU64(&offset, byte_size);
2274  if (is_signed)
2275  scalar.SignExtend(byte_size * 8);
2276  return bytes_read;
2277  }
2278  } else {
2279  error.SetErrorStringWithFormat(
2280  "byte size of %u is too large for integer scalar type", byte_size);
2281  }
2282  return 0;
2283 }
2284 
2285 Status Process::WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) {
2286  Status error;
2287  for (const auto &Entry : entries) {
2288  WriteMemory(Entry.Dest, Entry.Contents.data(), Entry.Contents.size(),
2289  error);
2290  if (!error.Success())
2291  break;
2292  }
2293  return error;
2294 }
2295 
2296 #define USE_ALLOCATE_MEMORY_CACHE 1
2297 addr_t Process::AllocateMemory(size_t size, uint32_t permissions,
2298  Status &error) {
2299  if (GetPrivateState() != eStateStopped) {
2300  error.SetErrorToGenericError();
2301  return LLDB_INVALID_ADDRESS;
2302  }
2303 
2304 #if defined(USE_ALLOCATE_MEMORY_CACHE)
2305  return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2306 #else
2307  addr_t allocated_addr = DoAllocateMemory(size, permissions, error);
2309  LLDB_LOGF(log,
2310  "Process::AllocateMemory(size=%" PRIu64
2311  ", permissions=%s) => 0x%16.16" PRIx64
2312  " (m_stop_id = %u m_memory_id = %u)",
2313  (uint64_t)size, GetPermissionsAsCString(permissions),
2314  (uint64_t)allocated_addr, m_mod_id.GetStopID(),
2315  m_mod_id.GetMemoryID());
2316  return allocated_addr;
2317 #endif
2318 }
2319 
2320 addr_t Process::CallocateMemory(size_t size, uint32_t permissions,
2321  Status &error) {
2322  addr_t return_addr = AllocateMemory(size, permissions, error);
2323  if (error.Success()) {
2324  std::string buffer(size, 0);
2325  WriteMemory(return_addr, buffer.c_str(), size, error);
2326  }
2327  return return_addr;
2328 }
2329 
2331  if (m_can_jit == eCanJITDontKnow) {
2333  Status err;
2334 
2335  uint64_t allocated_memory = AllocateMemory(
2336  8, ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
2337  err);
2338 
2339  if (err.Success()) {
2341  LLDB_LOGF(log,
2342  "Process::%s pid %" PRIu64
2343  " allocation test passed, CanJIT () is true",
2344  __FUNCTION__, GetID());
2345  } else {
2346  m_can_jit = eCanJITNo;
2347  LLDB_LOGF(log,
2348  "Process::%s pid %" PRIu64
2349  " allocation test failed, CanJIT () is false: %s",
2350  __FUNCTION__, GetID(), err.AsCString());
2351  }
2352 
2353  DeallocateMemory(allocated_memory);
2354  }
2355 
2356  return m_can_jit == eCanJITYes;
2357 }
2358 
2359 void Process::SetCanJIT(bool can_jit) {
2360  m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
2361 }
2362 
2363 void Process::SetCanRunCode(bool can_run_code) {
2364  SetCanJIT(can_run_code);
2365  m_can_interpret_function_calls = can_run_code;
2366 }
2367 
2369  Status error;
2370 #if defined(USE_ALLOCATE_MEMORY_CACHE)
2372  error.SetErrorStringWithFormat(
2373  "deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);
2374  }
2375 #else
2376  error = DoDeallocateMemory(ptr);
2377 
2379  LLDB_LOGF(log,
2380  "Process::DeallocateMemory(addr=0x%16.16" PRIx64
2381  ") => err = %s (m_stop_id = %u, m_memory_id = %u)",
2382  ptr, error.AsCString("SUCCESS"), m_mod_id.GetStopID(),
2383  m_mod_id.GetMemoryID());
2384 #endif
2385  return error;
2386 }
2387 
2388 ModuleSP Process::ReadModuleFromMemory(const FileSpec &file_spec,
2389  lldb::addr_t header_addr,
2390  size_t size_to_read) {
2392  if (log) {
2393  LLDB_LOGF(log,
2394  "Process::ReadModuleFromMemory reading %s binary from memory",
2395  file_spec.GetPath().c_str());
2396  }
2397  ModuleSP module_sp(new Module(file_spec, ArchSpec()));
2398  if (module_sp) {
2399  Status error;
2400  ObjectFile *objfile = module_sp->GetMemoryObjectFile(
2401  shared_from_this(), header_addr, error, size_to_read);
2402  if (objfile)
2403  return module_sp;
2404  }
2405  return ModuleSP();
2406 }
2407 
2409  uint32_t &permissions) {
2410  MemoryRegionInfo range_info;
2411  permissions = 0;
2412  Status error(GetMemoryRegionInfo(load_addr, range_info));
2413  if (!error.Success())
2414  return false;
2415  if (range_info.GetReadable() == MemoryRegionInfo::eDontKnow ||
2416  range_info.GetWritable() == MemoryRegionInfo::eDontKnow ||
2417  range_info.GetExecutable() == MemoryRegionInfo::eDontKnow) {
2418  return false;
2419  }
2420 
2421  if (range_info.GetReadable() == MemoryRegionInfo::eYes)
2422  permissions |= lldb::ePermissionsReadable;
2423 
2424  if (range_info.GetWritable() == MemoryRegionInfo::eYes)
2425  permissions |= lldb::ePermissionsWritable;
2426 
2427  if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
2428  permissions |= lldb::ePermissionsExecutable;
2429 
2430  return true;
2431 }
2432 
2433 Status Process::EnableWatchpoint(Watchpoint *watchpoint, bool notify) {
2434  Status error;
2435  error.SetErrorString("watchpoints are not supported");
2436  return error;
2437 }
2438 
2439 Status Process::DisableWatchpoint(Watchpoint *watchpoint, bool notify) {
2440  Status error;
2441  error.SetErrorString("watchpoints are not supported");
2442  return error;
2443 }
2444 
2445 StateType
2447  const Timeout<std::micro> &timeout) {
2448  StateType state;
2449 
2450  while (true) {
2451  event_sp.reset();
2452  state = GetStateChangedEventsPrivate(event_sp, timeout);
2453 
2454  if (StateIsStoppedState(state, false))
2455  break;
2456 
2457  // If state is invalid, then we timed out
2458  if (state == eStateInvalid)
2459  break;
2460 
2461  if (event_sp)
2462  HandlePrivateEvent(event_sp);
2463  }
2464  return state;
2465 }
2466 
2468  if (flush)
2469  m_thread_list.Clear();
2470  m_os_up.reset(OperatingSystem::FindPlugin(this, nullptr));
2471  if (flush)
2472  Flush();
2473 }
2474 
2476  Status error;
2477  m_abi_sp.reset();
2478  m_dyld_up.reset();
2479  m_jit_loaders_up.reset();
2480  m_system_runtime_up.reset();
2481  m_os_up.reset();
2482  m_process_input_reader.reset();
2483 
2484  Module *exe_module = GetTarget().GetExecutableModulePointer();
2485  if (!exe_module) {
2486  error.SetErrorString("executable module does not exist");
2487  return error;
2488  }
2489 
2490  char local_exec_file_path[PATH_MAX];
2491  char platform_exec_file_path[PATH_MAX];
2492  exe_module->GetFileSpec().GetPath(local_exec_file_path,
2493  sizeof(local_exec_file_path));
2494  exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path,
2495  sizeof(platform_exec_file_path));
2496  if (FileSystem::Instance().Exists(exe_module->GetFileSpec())) {
2497  // Install anything that might need to be installed prior to launching.
2498  // For host systems, this will do nothing, but if we are connected to a
2499  // remote platform it will install any needed binaries
2500  error = GetTarget().Install(&launch_info);
2501  if (error.Fail())
2502  return error;
2503 
2504  // Listen and queue events that are broadcasted during the process launch.
2505  ListenerSP listener_sp(Listener::MakeListener("LaunchEventHijack"));
2506  HijackProcessEvents(listener_sp);
2507  auto on_exit = llvm::make_scope_exit([this]() { RestoreProcessEvents(); });
2508 
2511 
2512  error = WillLaunch(exe_module);
2513  if (error.Success()) {
2514  const bool restarted = false;
2515  SetPublicState(eStateLaunching, restarted);
2516  m_should_detach = false;
2517 
2519  // Now launch using these arguments.
2520  error = DoLaunch(exe_module, launch_info);
2521  } else {
2522  // This shouldn't happen
2523  error.SetErrorString("failed to acquire process run lock");
2524  }
2525 
2526  if (error.Fail()) {
2527  if (GetID() != LLDB_INVALID_PROCESS_ID) {
2529  const char *error_string = error.AsCString();
2530  if (error_string == nullptr)
2531  error_string = "launch failed";
2532  SetExitStatus(-1, error_string);
2533  }
2534  } else {
2535  EventSP event_sp;
2536 
2537  // Now wait for the process to launch and return control to us, and then
2538  // call DidLaunch:
2539  StateType state = WaitForProcessStopPrivate(event_sp, seconds(10));
2540 
2541  if (state == eStateInvalid || !event_sp) {
2542  // We were able to launch the process, but we failed to catch the
2543  // initial stop.
2544  error.SetErrorString("failed to catch stop after launch");
2545  SetExitStatus(0, "failed to catch stop after launch");
2546  Destroy(false);
2547  } else if (state == eStateStopped || state == eStateCrashed) {
2548  DidLaunch();
2549 
2550  DynamicLoader *dyld = GetDynamicLoader();
2551  if (dyld)
2552  dyld->DidLaunch();
2553 
2555 
2556  SystemRuntime *system_runtime = GetSystemRuntime();
2557  if (system_runtime)
2558  system_runtime->DidLaunch();
2559 
2560  if (!m_os_up)
2562 
2563  // We successfully launched the process and stopped, now it the
2564  // right time to set up signal filters before resuming.
2566 
2567  // Note, the stop event was consumed above, but not handled. This
2568  // was done to give DidLaunch a chance to run. The target is either
2569  // stopped or crashed. Directly set the state. This is done to
2570  // prevent a stop message with a bunch of spurious output on thread
2571  // status, as well as not pop a ProcessIOHandler.
2572  SetPublicState(state, false);
2573 
2576  else
2578 
2579  // Target was stopped at entry as was intended. Need to notify the
2580  // listeners about it.
2581  if (state == eStateStopped &&
2582  launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
2583  HandlePrivateEvent(event_sp);
2584  } else if (state == eStateExited) {
2585  // We exited while trying to launch somehow. Don't call DidLaunch
2586  // as that's not likely to work, and return an invalid pid.
2587  HandlePrivateEvent(event_sp);
2588  }
2589  }
2590  }
2591  } else {
2592  error.SetErrorStringWithFormat("file doesn't exist: '%s'",
2593  local_exec_file_path);
2594  }
2595 
2596  return error;
2597 }
2598 
2600  Status error = DoLoadCore();
2601  if (error.Success()) {
2602  ListenerSP listener_sp(
2603  Listener::MakeListener("lldb.process.load_core_listener"));
2604  HijackProcessEvents(listener_sp);
2605 
2608  else
2610 
2611  DynamicLoader *dyld = GetDynamicLoader();
2612  if (dyld)
2613  dyld->DidAttach();
2614 
2616 
2617  SystemRuntime *system_runtime = GetSystemRuntime();
2618  if (system_runtime)
2619  system_runtime->DidAttach();
2620 
2621  if (!m_os_up)
2623 
2624  // We successfully loaded a core file, now pretend we stopped so we can
2625  // show all of the threads in the core file and explore the crashed state.
2627 
2628  // Wait for a stopped event since we just posted one above...
2629  lldb::EventSP event_sp;
2630  StateType state =
2631  WaitForProcessToStop(llvm::None, &event_sp, true, listener_sp);
2632 
2633  if (!StateIsStoppedState(state, false)) {
2635  LLDB_LOGF(log, "Process::Halt() failed to stop, state is: %s",
2636  StateAsCString(state));
2637  error.SetErrorString(
2638  "Did not get stopped event after loading the core file.");
2639  }
2641  }
2642  return error;
2643 }
2644 
2646  if (!m_dyld_up)
2647  m_dyld_up.reset(DynamicLoader::FindPlugin(this, nullptr));
2648  return m_dyld_up.get();
2649 }
2650 
2652 
2653 llvm::Expected<bool> Process::SaveCore(llvm::StringRef outfile) {
2654  return false;
2655 }
2656 
2658  if (!m_jit_loaders_up) {
2659  m_jit_loaders_up = std::make_unique<JITLoaderList>();
2661  }
2662  return *m_jit_loaders_up;
2663 }
2664 
2666  if (!m_system_runtime_up)
2668  return m_system_runtime_up.get();
2669 }
2670 
2672  uint32_t exec_count)
2673  : NextEventAction(process), m_exec_count(exec_count) {
2675  LLDB_LOGF(
2676  log,
2677  "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32,
2678  __FUNCTION__, static_cast<void *>(process), exec_count);
2679 }
2680 
2684 
2685  StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
2686  LLDB_LOGF(log,
2687  "Process::AttachCompletionHandler::%s called with state %s (%d)",
2688  __FUNCTION__, StateAsCString(state), static_cast<int>(state));
2689 
2690  switch (state) {
2691  case eStateAttaching:
2692  return eEventActionSuccess;
2693 
2694  case eStateRunning:
2695  case eStateConnected:
2696  return eEventActionRetry;
2697 
2698  case eStateStopped:
2699  case eStateCrashed:
2700  // During attach, prior to sending the eStateStopped event,
2701  // lldb_private::Process subclasses must set the new process ID.
2702  assert(m_process->GetID() != LLDB_INVALID_PROCESS_ID);
2703  // We don't want these events to be reported, so go set the
2704  // ShouldReportStop here:
2706 
2707  if (m_exec_count > 0) {
2708  --m_exec_count;
2709 
2710  LLDB_LOGF(log,
2711  "Process::AttachCompletionHandler::%s state %s: reduced "
2712  "remaining exec count to %" PRIu32 ", requesting resume",
2713  __FUNCTION__, StateAsCString(state), m_exec_count);
2714 
2715  RequestResume();
2716  return eEventActionRetry;
2717  } else {
2718  LLDB_LOGF(log,
2719  "Process::AttachCompletionHandler::%s state %s: no more "
2720  "execs expected to start, continuing with attach",
2721  __FUNCTION__, StateAsCString(state));
2722 
2724  return eEventActionSuccess;
2725  }
2726  break;
2727 
2728  default:
2729  case eStateExited:
2730  case eStateInvalid:
2731  break;
2732  }
2733 
2734  m_exit_string.assign("No valid Process");
2735  return eEventActionExit;
2736 }
2737 
2740  return eEventActionSuccess;
2741 }
2742 
2744  return m_exit_string.c_str();
2745 }
2746 
2748  if (m_listener_sp)
2749  return m_listener_sp;
2750  else
2751  return debugger.GetListener();
2752 }
2753 
2755  m_abi_sp.reset();
2756  m_process_input_reader.reset();
2757  m_dyld_up.reset();
2758  m_jit_loaders_up.reset();
2759  m_system_runtime_up.reset();
2760  m_os_up.reset();
2761 
2762  lldb::pid_t attach_pid = attach_info.GetProcessID();
2763  Status error;
2764  if (attach_pid == LLDB_INVALID_PROCESS_ID) {
2765  char process_name[PATH_MAX];
2766 
2767  if (attach_info.GetExecutableFile().GetPath(process_name,
2768  sizeof(process_name))) {
2769  const bool wait_for_launch = attach_info.GetWaitForLaunch();
2770 
2771  if (wait_for_launch) {
2772  error = WillAttachToProcessWithName(process_name, wait_for_launch);
2773  if (error.Success()) {
2775  m_should_detach = true;
2776  const bool restarted = false;
2777  SetPublicState(eStateAttaching, restarted);
2778  // Now attach using these arguments.
2779  error = DoAttachToProcessWithName(process_name, attach_info);
2780  } else {
2781  // This shouldn't happen
2782  error.SetErrorString("failed to acquire process run lock");
2783  }
2784 
2785  if (error.Fail()) {
2786  if (GetID() != LLDB_INVALID_PROCESS_ID) {
2788  if (error.AsCString() == nullptr)
2789  error.SetErrorString("attach failed");
2790 
2791  SetExitStatus(-1, error.AsCString());
2792  }
2793  } else {
2795  this, attach_info.GetResumeCount()));
2797  }
2798  return error;
2799  }
2800  } else {
2801  ProcessInstanceInfoList process_infos;
2802  PlatformSP platform_sp(GetTarget().GetPlatform());
2803 
2804  if (platform_sp) {
2805  ProcessInstanceInfoMatch match_info;
2806  match_info.GetProcessInfo() = attach_info;
2807  match_info.SetNameMatchType(NameMatch::Equals);
2808  platform_sp->FindProcesses(match_info, process_infos);
2809  const uint32_t num_matches = process_infos.size();
2810  if (num_matches == 1) {
2811  attach_pid = process_infos[0].GetProcessID();
2812  // Fall through and attach using the above process ID
2813  } else {
2814  match_info.GetProcessInfo().GetExecutableFile().GetPath(
2815  process_name, sizeof(process_name));
2816  if (num_matches > 1) {
2817  StreamString s;
2818  ProcessInstanceInfo::DumpTableHeader(s, true, false);
2819  for (size_t i = 0; i < num_matches; i++) {
2820  process_infos[i].DumpAsTableRow(
2821  s, platform_sp->GetUserIDResolver(), true, false);
2822  }
2823  error.SetErrorStringWithFormat(
2824  "more than one process named %s:\n%s", process_name,
2825  s.GetData());
2826  } else
2827  error.SetErrorStringWithFormat(
2828  "could not find a process named %s", process_name);
2829  }
2830  } else {
2831  error.SetErrorString(
2832  "invalid platform, can't find processes by name");
2833  return error;
2834  }
2835  }
2836  } else {
2837  error.SetErrorString("invalid process name");
2838  }
2839  }
2840 
2841  if (attach_pid != LLDB_INVALID_PROCESS_ID) {
2842  error = WillAttachToProcessWithID(attach_pid);
2843  if (error.Success()) {
2844 
2846  // Now attach using these arguments.
2847  m_should_detach = true;
2848  const bool restarted = false;
2849  SetPublicState(eStateAttaching, restarted);
2850  error = DoAttachToProcessWithID(attach_pid, attach_info);
2851  } else {
2852  // This shouldn't happen
2853  error.SetErrorString("failed to acquire process run lock");
2854  }
2855 
2856  if (error.Success()) {
2858  this, attach_info.GetResumeCount()));
2860  } else {
2861  if (GetID() != LLDB_INVALID_PROCESS_ID)
2863 
2864  const char *error_string = error.AsCString();
2865  if (error_string == nullptr)
2866  error_string = "attach failed";
2867 
2868  SetExitStatus(-1, error_string);
2869  }
2870  }
2871  }
2872  return error;
2873 }
2874 
2878  LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
2879 
2880  // Let the process subclass figure out at much as it can about the process
2881  // before we go looking for a dynamic loader plug-in.
2882  ArchSpec process_arch;
2883  DidAttach(process_arch);
2884 
2885  if (process_arch.IsValid()) {
2886  GetTarget().SetArchitecture(process_arch);
2887  if (log) {
2888  const char *triple_str = process_arch.GetTriple().getTriple().c_str();
2889  LLDB_LOGF(log,
2890  "Process::%s replacing process architecture with DidAttach() "
2891  "architecture: %s",
2892  __FUNCTION__, triple_str ? triple_str : "<null>");
2893  }
2894  }
2895 
2896  // We just attached. If we have a platform, ask it for the process
2897  // architecture, and if it isn't the same as the one we've already set,
2898  // switch architectures.
2899  PlatformSP platform_sp(GetTarget().GetPlatform());
2900  assert(platform_sp);
2901  if (platform_sp) {
2902  const ArchSpec &target_arch = GetTarget().GetArchitecture();
2903  if (target_arch.IsValid() &&
2904  !platform_sp->IsCompatibleArchitecture(target_arch, false, nullptr)) {
2905  ArchSpec platform_arch;
2906  platform_sp =
2907  platform_sp->GetPlatformForArchitecture(target_arch, &platform_arch);
2908  if (platform_sp) {
2909  GetTarget().SetPlatform(platform_sp);
2910  GetTarget().SetArchitecture(platform_arch);
2911  LLDB_LOGF(log,
2912  "Process::%s switching platform to %s and architecture "
2913  "to %s based on info from attach",
2914  __FUNCTION__, platform_sp->GetName().AsCString(""),
2915  platform_arch.GetTriple().getTriple().c_str());
2916  }
2917  } else if (!process_arch.IsValid()) {
2918  ProcessInstanceInfo process_info;
2919  GetProcessInfo(process_info);
2920  const ArchSpec &process_arch = process_info.GetArchitecture();
2921  const ArchSpec &target_arch = GetTarget().GetArchitecture();
2922  if (process_arch.IsValid() &&
2923  target_arch.IsCompatibleMatch(process_arch) &&
2924  !target_arch.IsExactMatch(process_arch)) {
2925  GetTarget().SetArchitecture(process_arch);
2926  LLDB_LOGF(log,
2927  "Process::%s switching architecture to %s based on info "
2928  "the platform retrieved for pid %" PRIu64,
2929  __FUNCTION__, process_arch.GetTriple().getTriple().c_str(),
2930  GetID());
2931  }
2932  }
2933  }
2934 
2935  // We have completed the attach, now it is time to find the dynamic loader
2936  // plug-in
2937  DynamicLoader *dyld = GetDynamicLoader();
2938  if (dyld) {
2939  dyld->DidAttach();
2940  if (log) {
2941  ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
2942  LLDB_LOGF(log,
2943  "Process::%s after DynamicLoader::DidAttach(), target "
2944  "executable is %s (using %s plugin)",
2945  __FUNCTION__,
2946  exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
2947  : "<none>",
2948  dyld->GetPluginName().AsCString("<unnamed>"));
2949  }
2950  }
2951 
2953 
2954  SystemRuntime *system_runtime = GetSystemRuntime();
2955  if (system_runtime) {
2956  system_runtime->DidAttach();
2957  if (log) {
2958  ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
2959  LLDB_LOGF(log,
2960  "Process::%s after SystemRuntime::DidAttach(), target "
2961  "executable is %s (using %s plugin)",
2962  __FUNCTION__,
2963  exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
2964  : "<none>",
2965  system_runtime->GetPluginName().AsCString("<unnamed>"));
2966  }
2967  }
2968 
2969  if (!m_os_up) {
2971  if (m_os_up) {
2972  // Somebody might have gotten threads before now, but we need to force the
2973  // update after we've loaded the OperatingSystem plugin or it won't get a
2974  // chance to process the threads.
2975  m_thread_list.Clear();
2977  }
2978  }
2979  // Figure out which one is the executable, and set that in our target:
2980  ModuleSP new_executable_module_sp;
2981  for (ModuleSP module_sp : GetTarget().GetImages().Modules()) {
2982  if (module_sp && module_sp->IsExecutable()) {
2983  if (GetTarget().GetExecutableModulePointer() != module_sp.get())
2984  new_executable_module_sp = module_sp;
2985  break;
2986  }
2987  }
2988  if (new_executable_module_sp) {
2989  GetTarget().SetExecutableModule(new_executable_module_sp,
2991  if (log) {
2992  ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
2993  LLDB_LOGF(
2994  log,
2995  "Process::%s after looping through modules, target executable is %s",
2996  __FUNCTION__,
2997  exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
2998  : "<none>");
2999  }
3000  }
3001 }
3002 
3003 Status Process::ConnectRemote(llvm::StringRef remote_url) {
3004  m_abi_sp.reset();
3005  m_process_input_reader.reset();
3006 
3007  // Find the process and its architecture. Make sure it matches the
3008  // architecture of the current Target, and if not adjust it.
3009 
3010  Status error(DoConnectRemote(remote_url));
3011  if (error.Success()) {
3012  if (GetID() != LLDB_INVALID_PROCESS_ID) {
3013  EventSP event_sp;
3014  StateType state = WaitForProcessStopPrivate(event_sp, llvm::None);
3015 
3016  if (state == eStateStopped || state == eStateCrashed) {
3017  // If we attached and actually have a process on the other end, then
3018  // this ended up being the equivalent of an attach.
3019  CompleteAttach();
3020 
3021  // This delays passing the stopped event to listeners till
3022  // CompleteAttach gets a chance to complete...
3023  HandlePrivateEvent(event_sp);
3024  }
3025  }
3026 
3029  else
3031  }
3032  return error;
3033 }
3034 
3037  LIBLLDB_LOG_STEP));
3038  LLDB_LOGF(log,
3039  "Process::PrivateResume() m_stop_id = %u, public state: %s "
3040  "private state: %s",
3043 
3044  // If signals handing status changed we might want to update our signal
3045  // filters before resuming.
3047 
3048  Status error(WillResume());
3049  // Tell the process it is about to resume before the thread list
3050  if (error.Success()) {
3051  // Now let the thread list know we are about to resume so it can let all of
3052  // our threads know that they are about to be resumed. Threads will each be
3053  // called with Thread::WillResume(StateType) where StateType contains the
3054  // state that they are supposed to have when the process is resumed
3055  // (suspended/running/stepping). Threads should also check their resume
3056  // signal in lldb::Thread::GetResumeSignal() to see if they are supposed to
3057  // start back up with a signal.
3058  if (m_thread_list.WillResume()) {
3059  // Last thing, do the PreResumeActions.
3060  if (!RunPreResumeActions()) {
3061  error.SetErrorString(
3062  "Process::PrivateResume PreResumeActions failed, not resuming.");
3063  } else {
3065  error = DoResume();
3066  if (error.Success()) {
3067  DidResume();
3069  LLDB_LOGF(log, "Process thinks the process has resumed.");
3070  } else {
3071  LLDB_LOGF(log, "Process::PrivateResume() DoResume failed.");
3072  return error;
3073  }
3074  }
3075  } else {
3076  // Somebody wanted to run without running (e.g. we were faking a step
3077  // from one frame of a set of inlined frames that share the same PC to
3078  // another.) So generate a continue & a stopped event, and let the world
3079  // handle them.
3080  LLDB_LOGF(log,
3081  "Process::PrivateResume() asked to simulate a start & stop.");
3082 
3085  }
3086  } else
3087  LLDB_LOGF(log, "Process::PrivateResume() got an error \"%s\".",
3088  error.AsCString("<unknown error>"));
3089  return error;
3090 }
3091 
3092 Status Process::Halt(bool clear_thread_plans, bool use_run_lock) {
3094  return Status("Process is not running.");
3095 
3096  // Don't clear the m_clear_thread_plans_on_stop, only set it to true if in
3097  // case it was already set and some thread plan logic calls halt on its own.
3098  m_clear_thread_plans_on_stop |= clear_thread_plans;
3099 
3100  ListenerSP halt_listener_sp(
3101  Listener::MakeListener("lldb.process.halt_listener"));
3102  HijackProcessEvents(halt_listener_sp);
3103 
3104  EventSP event_sp;
3105 
3107 
3109  // Don't hijack and eat the eStateExited as the code that was doing the
3110  // attach will be waiting for this event...
3112  SetExitStatus(SIGKILL, "Cancelled async attach.");
3113  Destroy(false);
3114  return Status();
3115  }
3116 
3117  // Wait for the process halt timeout seconds for the process to stop.
3118  StateType state =
3119  WaitForProcessToStop(GetInterruptTimeout(), &event_sp, true,
3120  halt_listener_sp, nullptr, use_run_lock);
3122 
3123  if (state == eStateInvalid || !event_sp) {
3124  // We timed out and didn't get a stop event...
3125  return Status("Halt timed out. State = %s", StateAsCString(GetState()));
3126  }
3127 
3128  BroadcastEvent(event_sp);
3129 
3130  return Status();
3131 }
3132 
3133 Status Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
3134  Status error;
3135 
3136  // Check both the public & private states here. If we're hung evaluating an
3137  // expression, for instance, then the public state will be stopped, but we
3138  // still need to interrupt.
3142  LLDB_LOGF(log, "Process::%s() About to stop.", __FUNCTION__);
3143 
3144  ListenerSP listener_sp(
3145  Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack"));
3146  HijackProcessEvents(listener_sp);
3147 
3149 
3150  // Consume the interrupt event.
3152  &exit_event_sp, true, listener_sp);
3153 
3155 
3156  // If the process exited while we were waiting for it to stop, put the
3157  // exited event into the shared pointer passed in and return. Our caller
3158  // doesn't need to do anything else, since they don't have a process
3159  // anymore...
3160 
3161  if (state == eStateExited || m_private_state.GetValue() == eStateExited) {
3162  LLDB_LOGF(log, "Process::%s() Process exited while waiting to stop.",
3163  __FUNCTION__);
3164  return error;
3165  } else
3166  exit_event_sp.reset(); // It is ok to consume any non-exit stop events
3167 
3168  if (state != eStateStopped) {
3169  LLDB_LOGF(log, "Process::%s() failed to stop, state is: %s", __FUNCTION__,
3170  StateAsCString(state));
3171  // If we really couldn't stop the process then we should just error out
3172  // here, but if the lower levels just bobbled sending the event and we
3173  // really are stopped, then continue on.
3174  StateType private_state = m_private_state.GetValue();
3175  if (private_state != eStateStopped) {
3176  return Status(
3177  "Attempt to stop the target in order to detach timed out. "
3178  "State = %s",
3180  }
3181  }
3182  }
3183  return error;
3184 }
3185 
3186 Status Process::Detach(bool keep_stopped) {
3187  EventSP exit_event_sp;
3188  Status error;
3189  m_destroy_in_process = true;
3190 
3191  error = WillDetach();
3192 
3193  if (error.Success()) {
3194  if (DetachRequiresHalt()) {
3195  error = StopForDestroyOrDetach(exit_event_sp);
3196  if (!error.Success()) {
3197  m_destroy_in_process = false;
3198  return error;
3199  } else if (exit_event_sp) {
3200  // We shouldn't need to do anything else here. There's no process left
3201  // to detach from...
3203  m_destroy_in_process = false;
3204  return error;
3205  }
3206  }
3207 
3210 
3211  error = DoDetach(keep_stopped);
3212  if (error.Success()) {
3213  DidDetach();
3215  } else {
3216  return error;
3217  }
3218  }
3219  m_destroy_in_process = false;
3220 
3221  // If we exited when we were waiting for a process to stop, then forward the
3222  // event here so we don't lose the event
3223  if (exit_event_sp) {
3224  // Directly broadcast our exited event because we shut down our private
3225  // state thread above
3226  BroadcastEvent(exit_event_sp);
3227  }
3228 
3229  // If we have been interrupted (to kill us) in the middle of running, we may
3230  // not end up propagating the last events through the event system, in which
3231  // case we might strand the write lock. Unlock it here so when we do to tear
3232  // down the process we don't get an error destroying the lock.
3233 
3235  return error;
3236 }
3237 
3238 Status Process::Destroy(bool force_kill) {
3239  // If we've already called Process::Finalize then there's nothing useful to
3240  // be done here. Finalize has actually called Destroy already.
3241  if (m_finalizing)
3242  return {};
3243  return DestroyImpl(force_kill);
3244 }
3245 
3246 Status Process::DestroyImpl(bool force_kill) {
3247  // Tell ourselves we are in the process of destroying the process, so that we
3248  // don't do any unnecessary work that might hinder the destruction. Remember
3249  // to set this back to false when we are done. That way if the attempt
3250  // failed and the process stays around for some reason it won't be in a
3251  // confused state.
3252 
3253  if (force_kill)
3254  m_should_detach = false;
3255 
3256  if (GetShouldDetach()) {
3257  // FIXME: This will have to be a process setting:
3258  bool keep_stopped = false;
3259  Detach(keep_stopped);
3260  }
3261 
3262  m_destroy_in_process = true;
3263 
3265  if (error.Success()) {
3266  EventSP exit_event_sp;
3267  if (DestroyRequiresHalt()) {
3268  error = StopForDestroyOrDetach(exit_event_sp);
3269  }
3270 
3272  // Ditch all thread plans, and remove all our breakpoints: in case we
3273  // have to restart the target to kill it, we don't want it hitting a
3274  // breakpoint... Only do this if we've stopped, however, since if we
3275  // didn't manage to halt it above, then we're not going to have much luck
3276  // doing this now.
3279  }
3280 
3281  error = DoDestroy();
3282  if (error.Success()) {
3283  DidDestroy();
3285  }
3288  m_stdin_forward = false;
3289 
3290  if (m_process_input_reader) {
3291  m_process_input_reader->SetIsDone(true);
3292  m_process_input_reader->Cancel();
3293  m_process_input_reader.reset();
3294  }
3295 
3296  // If we exited when we were waiting for a process to stop, then forward
3297  // the event here so we don't lose the event
3298  if (exit_event_sp) {
3299  // Directly broadcast our exited event because we shut down our private
3300  // state thread above
3301  BroadcastEvent(exit_event_sp);
3302  }
3303 
3304  // If we have been interrupted (to kill us) in the middle of running, we
3305  // may not end up propagating the last events through the event system, in
3306  // which case we might strand the write lock. Unlock it here so when we do
3307  // to tear down the process we don't get an error destroying the lock.
3309  }
3310 
3311  m_destroy_in_process = false;
3312 
3313  return error;
3314 }
3315 
3317  Status error(WillSignal());
3318  if (error.Success()) {
3319  error = DoSignal(signal);
3320  if (error.Success())
3321  DidSignal();
3322  }
3323  return error;
3324 }
3325 
3326 void Process::SetUnixSignals(UnixSignalsSP &&signals_sp) {
3327  assert(signals_sp && "null signals_sp");
3328  m_unix_signals_sp = signals_sp;
3329 }
3330 
3331 const lldb::UnixSignalsSP &Process::GetUnixSignals() {
3332  assert(m_unix_signals_sp && "null m_unix_signals_sp");
3333  return m_unix_signals_sp;
3334 }
3335 
3337  return GetTarget().GetArchitecture().GetByteOrder();
3338 }
3339 
3342 }
3343 
3345  const StateType state =
3347  bool return_value = true;
3350 
3351  switch (state) {
3352  case eStateDetached:
3353  case eStateExited:
3354  case eStateUnloaded:
3358  m_stdin_forward = false;
3359 
3360  LLVM_FALLTHROUGH;
3361  case eStateConnected:
3362  case eStateAttaching:
3363  case eStateLaunching:
3364  // These events indicate changes in the state of the debugging session,
3365  // always report them.
3366  return_value = true;
3367  break;
3368  case eStateInvalid:
3369  // We stopped for no apparent reason, don't report it.
3370  return_value = false;
3371  break;
3372  case eStateRunning:
3373  case eStateStepping:
3374  // If we've started the target running, we handle the cases where we are
3375  // already running and where there is a transition from stopped to running
3376  // differently. running -> running: Automatically suppress extra running
3377  // events stopped -> running: Report except when there is one or more no
3378  // votes
3379  // and no yes votes.
3382  return_value = true;
3383  else {
3384  switch (m_last_broadcast_state) {
3385  case eStateRunning:
3386  case eStateStepping:
3387  // We always suppress multiple runnings with no PUBLIC stop in between.
3388  return_value = false;
3389  break;
3390  default:
3391  // TODO: make this work correctly. For now always report
3392  // run if we aren't running so we don't miss any running events. If I
3393  // run the lldb/test/thread/a.out file and break at main.cpp:58, run
3394  // and hit the breakpoints on multiple threads, then somehow during the
3395  // stepping over of all breakpoints no run gets reported.
3396 
3397  // This is a transition from stop to run.
3398  switch (m_thread_list.ShouldReportRun(event_ptr)) {
3399  case eVoteYes:
3400  case eVoteNoOpinion:
3401  return_value = true;
3402  break;
3403  case eVoteNo:
3404  return_value = false;
3405  break;
3406  }
3407  break;
3408  }
3409  }
3410  break;
3411  case eStateStopped:
3412  case eStateCrashed:
3413  case eStateSuspended:
3414  // We've stopped. First see if we're going to restart the target. If we
3415  // are going to stop, then we always broadcast the event. If we aren't
3416  // going to stop, let the thread plans decide if we're going to report this
3417  // event. If no thread has an opinion, we don't report it.
3418 
3422  LLDB_LOGF(log,
3423  "Process::ShouldBroadcastEvent (%p) stopped due to an "
3424  "interrupt, state: %s",
3425  static_cast<void *>(event_ptr), StateAsCString(state));
3426  // Even though we know we are going to stop, we should let the threads
3427  // have a look at the stop, so they can properly set their state.
3428  m_thread_list.ShouldStop(event_ptr);
3429  return_value = true;
3430  } else {
3431  bool was_restarted = ProcessEventData::GetRestartedFromEvent(event_ptr);
3432  bool should_resume = false;
3433 
3434  // It makes no sense to ask "ShouldStop" if we've already been
3435  // restarted... Asking the thread list is also not likely to go well,
3436  // since we are running again. So in that case just report the event.
3437 
3438  if (!was_restarted)
3439  should_resume = !m_thread_list.ShouldStop(event_ptr);
3440 
3441  if (was_restarted || should_resume || m_resume_requested) {
3442  Vote report_stop_vote = m_thread_list.ShouldReportStop(event_ptr);
3443  LLDB_LOGF(log,
3444  "Process::ShouldBroadcastEvent: should_resume: %i state: "
3445  "%s was_restarted: %i report_stop_vote: %d.",
3446  should_resume, StateAsCString(state), was_restarted,
3447  report_stop_vote);
3448 
3449  switch (report_stop_vote) {
3450  case eVoteYes:
3451  return_value = true;
3452  break;
3453  case eVoteNoOpinion:
3454  case eVoteNo:
3455  return_value = false;
3456  break;
3457  }
3458 
3459  if (!was_restarted) {
3460  LLDB_LOGF(log,
3461  "Process::ShouldBroadcastEvent (%p) Restarting process "
3462  "from state: %s",
3463  static_cast<void *>(event_ptr), StateAsCString(state));
3464  ProcessEventData::SetRestartedInEvent(event_ptr, true);
3465  PrivateResume();
3466  }
3467  } else {
3468  return_value = true;
3470  }
3471  }
3472  break;
3473  }
3474 
3475  // Forcing the next event delivery is a one shot deal. So reset it here.
3477 
3478  // We do some coalescing of events (for instance two consecutive running
3479  // events get coalesced.) But we only coalesce against events we actually
3480  // broadcast. So we use m_last_broadcast_state to track that. NB - you
3481  // can't use "m_public_state.GetValue()" for that purpose, as was originally
3482  // done, because the PublicState reflects the last event pulled off the
3483  // queue, and there may be several events stacked up on the queue unserviced.
3484  // So the PublicState may not reflect the last broadcasted event yet.
3485  // m_last_broadcast_state gets updated here.
3486 
3487  if (return_value)
3488  m_last_broadcast_state = state;
3489 
3490  LLDB_LOGF(log,
3491  "Process::ShouldBroadcastEvent (%p) => new state: %s, last "
3492  "broadcast state: %s - %s",
3493  static_cast<void *>(event_ptr), StateAsCString(state),
3495  return_value ? "YES" : "NO");
3496  return return_value;
3497 }
3498 
3499 bool Process::StartPrivateStateThread(bool is_secondary_thread) {
3501 
3502  bool already_running = PrivateStateThreadIsValid();
3503  LLDB_LOGF(log, "Process::%s()%s ", __FUNCTION__,
3504  already_running ? " already running"
3505  : " starting private state thread");
3506 
3507  if (!is_secondary_thread && already_running)
3508  return true;
3509 
3510  // Create a thread that watches our internal state and controls which events
3511  // make it to clients (into the DCProcess event queue).
3512  char thread_name[1024];
3513  uint32_t max_len = llvm::get_max_thread_name_length();
3514  if (max_len > 0 && max_len <= 30) {
3515  // On platforms with abbreviated thread name lengths, choose thread names
3516  // that fit within the limit.
3517  if (already_running)
3518  snprintf(thread_name, sizeof(thread_name), "intern-state-OV");
3519  else
3520  snprintf(thread_name, sizeof(thread_name), "intern-state");
3521  } else {
3522  if (already_running)
3523  snprintf(thread_name, sizeof(thread_name),
3524  "<lldb.process.internal-state-override(pid=%" PRIu64 ")>",
3525  GetID());
3526  else
3527  snprintf(thread_name, sizeof(thread_name),
3528  "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
3529  }
3530 
3531  // Create the private state thread, and start it running.
3532  PrivateStateThreadArgs *args_ptr =
3533  new PrivateStateThreadArgs(this, is_secondary_thread);
3534  llvm::Expected<HostThread> private_state_thread =
3536  (void *)args_ptr, 8 * 1024 * 1024);
3537  if (!private_state_thread) {
3539  "failed to launch host thread: {}",
3540  llvm::toString(private_state_thread.takeError()));
3541  return false;
3542  }
3543 
3544  assert(private_state_thread->IsJoinable());
3545  m_private_state_thread = *private_state_thread;
3547  return true;
3548 }
3549 
3552 }
3553 
3556 }
3557 
3561  else {
3563  LLDB_LOGF(
3564  log,
3565  "Went to stop the private state thread, but it was already invalid.");
3566  }
3567 }
3568 
3571 
3572  assert(signal == eBroadcastInternalStateControlStop ||
3575 
3576  LLDB_LOGF(log, "Process::%s (signal = %d)", __FUNCTION__, signal);
3577 
3578  // Signal the private state thread
3580  // Broadcast the event.
3581  // It is important to do this outside of the if below, because it's
3582  // possible that the thread state is invalid but that the thread is waiting
3583  // on a control event instead of simply being on its way out (this should
3584  // not happen, but it apparently can).
3585  LLDB_LOGF(log, "Sending control event of type: %d.", signal);
3586  std::shared_ptr<EventDataReceipt> event_receipt_sp(new EventDataReceipt());
3588  event_receipt_sp);
3589 
3590  // Wait for the event receipt or for the private state thread to exit
3591  bool receipt_received = false;
3592  if (PrivateStateThreadIsValid()) {
3593  while (!receipt_received) {
3594  // Check for a receipt for n seconds and then check if the private
3595  // state thread is still around.
3596  receipt_received =
3597  event_receipt_sp->WaitForEventReceived(GetUtilityExpressionTimeout());
3598  if (!receipt_received) {
3599  // Check if the private state thread is still around. If it isn't
3600  // then we are done waiting
3602  break; // Private state thread exited or is exiting, we are done
3603  }
3604  }
3605  }
3606 
3607  if (signal == eBroadcastInternalStateControlStop) {
3608  thread_result_t result = {};
3609  m_private_state_thread.Join(&result);
3611  }
3612  } else {
3613  LLDB_LOGF(
3614  log,
3615  "Private state thread already dead, no need to signal it to stop.");
3616  }
3617 }
3618 
3622  nullptr);
3623  else
3625 }
3626 
3627 void Process::HandlePrivateEvent(EventSP &event_sp) {
3629  m_resume_requested = false;
3630 
3631  const StateType new_state =
3633 
3634  // First check to see if anybody wants a shot at this event:
3635  if (m_next_event_action_up) {
3636  NextEventAction::EventActionResult action_result =
3637  m_next_event_action_up->PerformAction(event_sp);
3638  LLDB_LOGF(log, "Ran next event action, result was %d.", action_result);
3639 
3640  switch (action_result) {
3642  SetNextEventAction(nullptr);
3643  break;
3644 
3646  break;
3647 
3649  // Handle Exiting Here. If we already got an exited event, we should
3650  // just propagate it. Otherwise, swallow this event, and set our state
3651  // to exit so the next event will kill us.
3652  if (new_state != eStateExited) {
3653  // FIXME: should cons up an exited event, and discard this one.
3654  SetExitStatus(0, m_next_event_action_up->GetExitString());
3655  SetNextEventAction(nullptr);
3656  return;
3657  }
3658  SetNextEventAction(nullptr);
3659  break;
3660  }
3661  }
3662 
3663  // See if we should broadcast this state to external clients?
3664  const bool should_broadcast = ShouldBroadcastEvent(event_sp.get());
3665 
3666  if (should_broadcast) {
3667  const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged);
3668  if (log) {
3669  LLDB_LOGF(log,
3670  "Process::%s (pid = %" PRIu64
3671  ") broadcasting new state %s (old state %s) to %s",
3672  __FUNCTION__, GetID(), StateAsCString(new_state),
3674  is_hijacked ? "hijacked" : "public");
3675  }
3677  if (StateIsRunningState(new_state)) {
3678  // Only push the input handler if we aren't fowarding events, as this
3679  // means the curses GUI is in use... Or don't push it if we are launching
3680  // since it will come up stopped.
3681  if (!GetTarget().GetDebugger().IsForwardingEvents() &&
3682  new_state != eStateLaunching && new_state != eStateAttaching) {
3686  LLDB_LOGF(log, "Process::%s updated m_iohandler_sync to %d",
3687  __FUNCTION__, m_iohandler_sync.GetValue());
3688  }
3689  } else if (StateIsStoppedState(new_state, false)) {
3690  if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
3691  // If the lldb_private::Debugger is handling the events, we don't want
3692  // to pop the process IOHandler here, we want to do it when we receive
3693  // the stopped event so we can carefully control when the process
3694  // IOHandler is popped because when we stop we want to display some
3695  // text stating how and why we stopped, then maybe some
3696  // process/thread/frame info, and then we want the "(lldb) " prompt to
3697  // show up. If we pop the process IOHandler here, then we will cause
3698  // the command interpreter to become the top IOHandler after the
3699  // process pops off and it will update its prompt right away... See the
3700  // Debugger.cpp file where it calls the function as
3701  // "process_sp->PopProcessIOHandler()" to see where I am talking about.
3702  // Otherwise we end up getting overlapping "(lldb) " prompts and
3703  // garbled output.
3704  //
3705  // If we aren't handling the events in the debugger (which is indicated
3706  // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or
3707  // we are hijacked, then we always pop the process IO handler manually.
3708  // Hijacking happens when the internal process state thread is running
3709  // thread plans, or when commands want to run in synchronous mode and
3710  // they call "process->WaitForProcessToStop()". An example of something
3711  // that will hijack the events is a simple expression:
3712  //
3713  // (lldb) expr (int)puts("hello")
3714  //
3715  // This will cause the internal process state thread to resume and halt
3716  // the process (and _it_ will hijack the eBroadcastBitStateChanged
3717  // events) and we do need the IO handler to be pushed and popped
3718  // correctly.
3719 
3720  if (is_hijacked || !GetTarget().GetDebugger().IsHandlingEvents())
3722  }
3723  }
3724 
3725  BroadcastEvent(event_sp);
3726  } else {
3727  if (log) {
3728  LLDB_LOGF(
3729  log,
3730  "Process::%s (pid = %" PRIu64
3731  ") suppressing state %s (old state %s): should_broadcast == false",
3732  __FUNCTION__, GetID(), StateAsCString(new_state),
3734  }
3735  }
3736 }
3737 
3739  EventSP event_sp;
3740  Status error(WillHalt());
3741  if (error.Fail())
3742  return error;
3743 
3744  // Ask the process subclass to actually halt our process
3745  bool caused_stop;
3746  error = DoHalt(caused_stop);
3747 
3748  DidHalt();
3749  return error;
3750 }
3751 
3753  std::unique_ptr<PrivateStateThreadArgs> args_up(
3754  static_cast<PrivateStateThreadArgs *>(arg));
3755  thread_result_t result =
3756  args_up->process->RunPrivateStateThread(args_up->is_secondary_thread);
3757  return result;
3758 }
3759 
3761  bool control_only = true;
3762 
3764  LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
3765  __FUNCTION__, static_cast<void *>(this), GetID());
3766 
3767  bool exit_now = false;
3768  bool interrupt_requested = false;
3769  while (!exit_now) {
3770  EventSP event_sp;
3771  GetEventsPrivate(event_sp, llvm::None, control_only);
3772  if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) {
3773  LLDB_LOGF(log,
3774  "Process::%s (arg = %p, pid = %" PRIu64
3775  ") got a control event: %d",
3776  __FUNCTION__, static_cast<void *>(this), GetID(),
3777  event_sp->GetType());
3778 
3779  switch (event_sp->GetType()) {
3781  exit_now = true;
3782  break; // doing any internal state management below
3783 
3785  control_only = true;
3786  break;
3787 
3789  control_only = false;
3790  break;
3791  }
3792 
3793  continue;
3794  } else if (event_sp->GetType() == eBroadcastBitInterrupt) {
3796  LLDB_LOGF(log,
3797  "Process::%s (arg = %p, pid = %" PRIu64
3798  ") woke up with an interrupt while attaching - "
3799  "forwarding interrupt.",
3800  __FUNCTION__, static_cast<void *>(this), GetID());
3803  LLDB_LOGF(log,
3804  "Process::%s (arg = %p, pid = %" PRIu64
3805  ") woke up with an interrupt - Halting.",
3806  __FUNCTION__, static_cast<void *>(this), GetID());
3807  Status error = HaltPrivate();
3808  if (error.Fail() && log)
3809  LLDB_LOGF(log,
3810  "Process::%s (arg = %p, pid = %" PRIu64
3811  ") failed to halt the process: %s",
3812  __FUNCTION__, static_cast<void *>(this), GetID(),
3813  error.AsCString());
3814  // Halt should generate a stopped event. Make a note of the fact that
3815  // we were doing the interrupt, so we can set the interrupted flag
3816  // after we receive the event. We deliberately set this to true even if
3817  // HaltPrivate failed, so that we can interrupt on the next natural
3818  // stop.
3819  interrupt_requested = true;
3820  } else {
3821  // This can happen when someone (e.g. Process::Halt) sees that we are
3822  // running and sends an interrupt request, but the process actually
3823  // stops before we receive it. In that case, we can just ignore the
3824  // request. We use m_last_broadcast_state, because the Stopped event
3825  // may not have been popped of the event queue yet, which is when the
3826  // public state gets updated.
3827  LLDB_LOGF(log,
3828  "Process::%s ignoring interrupt as we have already stopped.",
3829  __FUNCTION__);
3830  }
3831  continue;
3832  }
3833 
3834  const StateType internal_state =
3836 
3837  if (internal_state != eStateInvalid) {
3839  StateIsStoppedState(internal_state, true)) {
3842  }
3843 
3844  if (interrupt_requested) {
3845  if (StateIsStoppedState(internal_state, true)) {
3846  // We requested the interrupt, so mark this as such in the stop event
3847  // so clients can tell an interrupted process from a natural stop
3848  ProcessEventData::SetInterruptedInEvent(event_sp.get(), true);
3849  interrupt_requested = false;
3850  } else if (log) {
3851  LLDB_LOGF(log,
3852  "Process::%s interrupt_requested, but a non-stopped "
3853  "state '%s' received.",
3854  __FUNCTION__, StateAsCString(internal_state));
3855  }
3856  }
3857 
3858  HandlePrivateEvent(event_sp);
3859  }
3860 
3861  if (internal_state == eStateInvalid || internal_state == eStateExited ||
3862  internal_state == eStateDetached) {
3863  LLDB_LOGF(log,
3864  "Process::%s (arg = %p, pid = %" PRIu64
3865  ") about to exit with internal state %s...",
3866  __FUNCTION__, static_cast<void *>(this), GetID(),
3867  StateAsCString(internal_state));
3868 
3869  break;
3870  }
3871  }
3872 
3873  // Verify log is still enabled before attempting to write to it...
3874  LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
3875  __FUNCTION__, static_cast<void *>(this), GetID());
3876 
3877  // If we are a secondary thread, then the primary thread we are working for
3878  // will have already acquired the public_run_lock, and isn't done with what
3879  // it was doing yet, so don't try to change it on the way out.
3880  if (!is_secondary_thread)
3882  return {};
3883 }
3884 
3885 // Process Event Data
3886 
3888 
3889 Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
3890  StateType state)
3891  : EventData(), m_process_wp(), m_state(state), m_restarted(false),
3892  m_update_state(0), m_interrupted(false) {
3893  if (process_sp)
3894  m_process_wp = process_sp;
3895 }
3896 
3898 
3900  static ConstString g_flavor("Process::ProcessEventData");
3901  return g_flavor;
3902 }
3903 
3906 }
3907 
3909  bool &found_valid_stopinfo) {
3910  found_valid_stopinfo = false;
3911 
3912  ProcessSP process_sp(m_process_wp.lock());
3913  if (!process_sp)
3914  return false;
3915 
3916  ThreadList &curr_thread_list = process_sp->GetThreadList();
3917  uint32_t num_threads = curr_thread_list.GetSize();
3918  uint32_t idx;
3919 
3920  // The actions might change one of the thread's stop_info's opinions about
3921  // whether we should stop the process, so we need to query that as we go.
3922 
3923  // One other complication here, is that we try to catch any case where the
3924  // target has run (except for expressions) and immediately exit, but if we
3925  // get that wrong (which is possible) then the thread list might have
3926  // changed, and that would cause our iteration here to crash. We could
3927  // make a copy of the thread list, but we'd really like to also know if it
3928  // has changed at all, so we make up a vector of the thread ID's and check
3929  // what we get back against this list & bag out if anything differs.
3930  ThreadList not_suspended_thread_list(process_sp.get());
3931  std::vector<uint32_t> thread_index_array(num_threads);
3932  uint32_t not_suspended_idx = 0;
3933  for (idx = 0; idx < num_threads; ++idx) {
3934  lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
3935 
3936  /*
3937  Filter out all suspended threads, they could not be the reason
3938  of stop and no need to perform any actions on them.
3939  */
3940  if (thread_sp->GetResumeState() != eStateSuspended) {
3941  not_suspended_thread_list.AddThread(thread_sp);
3942  thread_index_array[not_suspended_idx] = thread_sp->GetIndexID();
3943  not_suspended_idx++;
3944  }
3945  }
3946 
3947  // Use this to track whether we should continue from here. We will only
3948  // continue the target running if no thread says we should stop. Of course
3949  // if some thread's PerformAction actually sets the target running, then it
3950  // doesn't matter what the other threads say...
3951 
3952  bool still_should_stop = false;
3953 
3954  // Sometimes - for instance if we have a bug in the stub we are talking to,
3955  // we stop but no thread has a valid stop reason. In that case we should
3956  // just stop, because we have no way of telling what the right thing to do
3957  // is, and it's better to let the user decide than continue behind their
3958  // backs.
3959 
3960  for (idx = 0; idx < not_suspended_thread_list.GetSize(); ++idx) {
3961  curr_thread_list = process_sp->GetThreadList();
3962  if (curr_thread_list.GetSize() != num_threads) {
3965  LLDB_LOGF(
3966  log,
3967  "Number of threads changed from %u to %u while processing event.",
3968  num_threads, curr_thread_list.GetSize());
3969  break;
3970  }
3971 
3972  lldb::ThreadSP thread_sp = not_suspended_thread_list.GetThreadAtIndex(idx);
3973 
3974  if (thread_sp->GetIndexID() != thread_index_array[idx]) {
3977  LLDB_LOGF(log,
3978  "The thread at position %u changed from %u to %u while "
3979  "processing event.",
3980  idx, thread_index_array[idx], thread_sp->GetIndexID());
3981  break;
3982  }
3983 
3984  StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
3985  if (stop_info_sp && stop_info_sp->IsValid()) {
3986  found_valid_stopinfo = true;
3987  bool this_thread_wants_to_stop;
3988  if (stop_info_sp->GetOverrideShouldStop()) {
3989  this_thread_wants_to_stop =
3990  stop_info_sp->GetOverriddenShouldStopValue();
3991  } else {
3992  stop_info_sp->PerformAction(event_ptr);
3993  // The stop action might restart the target. If it does, then we
3994  // want to mark that in the event so that whoever is receiving it
3995  // will know to wait for the running event and reflect that state
3996  // appropriately. We also need to stop processing actions, since they
3997  // aren't expecting the target to be running.
3998 
3999  // FIXME: we might have run.
4000  if (stop_info_sp->HasTargetRunSinceMe()) {
4001  SetRestarted(true);
4002  break;
4003  }
4004 
4005  this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
4006  }
4007 
4008  if (!still_should_stop)
4009  still_should_stop = this_thread_wants_to_stop;
4010  }
4011  }
4012 
4013  return still_should_stop;
4014 }
4015 
4017  ProcessSP process_sp(m_process_wp.lock());
4018 
4019  if (!process_sp)
4020  return;
4021 
4022  // This function gets called twice for each event, once when the event gets
4023  // pulled off of the private process event queue, and then any number of
4024  // times, first when it gets pulled off of the public event queue, then other
4025  // times when we're pretending that this is where we stopped at the end of
4026  // expression evaluation. m_update_state is used to distinguish these three
4027  // cases; it is 0 when we're just pulling it off for private handling, and >
4028  // 1 for expression evaluation, and we don't want to do the breakpoint
4029  // command handling then.
4030  if (m_update_state != 1)
4031  return;
4032 
4033  process_sp->SetPublicState(
4035 
4036  if (m_state == eStateStopped && !m_restarted) {
4037  // Let process subclasses know we are about to do a public stop and do
4038  // anything they might need to in order to speed up register and memory
4039  // accesses.
4040  process_sp->WillPublicStop();
4041  }
4042 
4043  // If this is a halt event, even if the halt stopped with some reason other
4044  // than a plain interrupt (e.g. we had already stopped for a breakpoint when
4045  // the halt request came through) don't do the StopInfo actions, as they may
4046  // end up restarting the process.
4047  if (m_interrupted)
4048  return;
4049 
4050  // If we're not stopped or have restarted, then skip the StopInfo actions:
4051  if (m_state != eStateStopped || m_restarted) {
4052  return;
4053  }
4054 
4055  bool does_anybody_have_an_opinion = false;
4056  bool still_should_stop = ShouldStop(event_ptr, does_anybody_have_an_opinion);
4057 
4058  if (GetRestarted()) {
4059  return;
4060  }
4061 
4062  if (!still_should_stop && does_anybody_have_an_opinion) {
4063  // We've been asked to continue, so do that here.
4064  SetRestarted(true);
4065  // Use the public resume method here, since this is just extending a
4066  // public resume.
4067  process_sp->PrivateResume();
4068  } else {
4069  bool hijacked = process_sp->IsHijackedForEvent(eBroadcastBitStateChanged) &&
4070  !process_sp->StateChangedIsHijackedForSynchronousResume();
4071 
4072  if (!hijacked) {
4073  // If we didn't restart, run the Stop Hooks here.
4074  // Don't do that if state changed events aren't hooked up to the
4075  // public (or SyncResume) broadcasters. StopHooks are just for
4076  // real public stops. They might also restart the target,
4077  // so watch for that.
4078  if (process_sp->GetTarget().RunStopHooks())
4079  SetRestarted(true);
4080  }
4081  }
4082 }
4083 
4085  ProcessSP process_sp(m_process_wp.lock());
4086 
4087  if (process_sp)
4088  s->Printf(" process = %p (pid = %" PRIu64 "), ",
4089  static_cast<void *>(process_sp.get()), process_sp->GetID());
4090  else
4091  s->PutCString(" process = NULL, ");
4092 
4093  s->Printf("state = %s", StateAsCString(GetState()));
4094 }
4095 
4098  if (event_ptr) {
4099  const EventData *event_data = event_ptr->GetData();
4100  if (event_data &&
4101  event_data->GetFlavor() == ProcessEventData::GetFlavorString())
4102  return static_cast<const ProcessEventData *>(event_ptr->GetData());
4103  }
4104  return nullptr;
4105 }
4106 
4107 ProcessSP
4109  ProcessSP process_sp;
4110  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4111  if (data)
4112  process_sp = data->GetProcessSP();
4113  return process_sp;
4114 }
4115 
4117  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4118  if (data == nullptr)
4119  return eStateInvalid;
4120  else
4121  return data->GetState();
4122 }
4123 
4125  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4126  if (data == nullptr)
4127  return false;
4128  else
4129  return data->GetRestarted();
4130 }
4131 
4133  bool new_value) {
4134  ProcessEventData *data =
4135  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4136  if (data != nullptr)
4137  data->SetRestarted(new_value);
4138 }
4139 
4140 size_t
4142  ProcessEventData *data =
4143  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4144  if (data != nullptr)
4145  return data->GetNumRestartedReasons();
4146  else
4147  return 0;
4148 }
4149 
4150 const char *
4152  size_t idx) {
4153  ProcessEventData *data =
4154  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4155  if (data != nullptr)
4156  return data->GetRestartedReasonAtIndex(idx);
4157  else
4158  return nullptr;
4159 }
4160 
4162  const char *reason) {
4163  ProcessEventData *data =
4164  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4165  if (data != nullptr)
4166  data->AddRestartedReason(reason);
4167 }
4168 
4170  const Event *event_ptr) {
4171  const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
4172  if (data == nullptr)
4173  return false;
4174  else
4175  return data->GetInterrupted();
4176 }
4177 
4179  bool new_value) {
4180  ProcessEventData *data =
4181  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4182  if (data != nullptr)
4183  data->SetInterrupted(new_value);
4184 }
4185 
4187  ProcessEventData *data =
4188  const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
4189  if (data) {
4190  data->SetUpdateStateOnRemoval();
4191  return true;
4192  }
4193  return false;
4194 }
4195 
4196 lldb::TargetSP Process::CalculateTarget() { return m_target_wp.lock(); }
4197 
4199  exe_ctx.SetTargetPtr(&GetTarget());
4200  exe_ctx.SetProcessPtr(this);
4201  exe_ctx.SetThreadPtr(nullptr);
4202  exe_ctx.SetFramePtr(nullptr);
4203 }
4204 
4205 // uint32_t
4206 // Process::ListProcessesMatchingName (const char *name, StringList &matches,
4207 // std::vector<lldb::pid_t> &pids)
4208 //{
4209 // return 0;
4210 //}
4211 //
4212 // ArchSpec
4213 // Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4214 //{
4215 // return Host::GetArchSpecForExistingProcess (pid);
4216 //}
4217 //
4218 // ArchSpec
4219 // Process::GetArchSpecForExistingProcess (const char *process_name)
4220 //{
4221 // return Host::GetArchSpecForExistingProcess (process_name);
4222 //}
4223 
4224 void Process::AppendSTDOUT(const char *s, size_t len) {
4225  std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
4226  m_stdout_data.append(s, len);
4228  new ProcessEventData(shared_from_this(), GetState()));
4229 }
4230 
4231 void Process::AppendSTDERR(const char *s, size_t len) {
4232  std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
4233  m_stderr_data.append(s, len);
4235  new ProcessEventData(shared_from_this(), GetState()));
4236 }
4237 
4238 void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) {
4239  std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
4240  m_profile_data.push_back(one_profile_data);
4242  new ProcessEventData(shared_from_this(), GetState()));
4243 }
4244 
4246  const StructuredDataPluginSP &plugin_sp) {
4249  new EventDataStructuredData(shared_from_this(), object_sp, plugin_sp));
4250 }
4251 
4252 StructuredDataPluginSP
4254  auto find_it = m_structured_data_plugin_map.find(type_name);
4255  if (find_it != m_structured_data_plugin_map.end())
4256  return find_it->second;
4257  else
4258  return StructuredDataPluginSP();
4259 }
4260 
4261 size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) {
4262  std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
4263  if (m_profile_data.empty())
4264  return 0;
4265 
4266  std::string &one_profile_data = m_profile_data.front();
4267  size_t bytes_available = one_profile_data.size();
4268  if (bytes_available > 0) {
4270  LLDB_LOGF(log, "Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4271  static_cast<void *>(buf), static_cast<uint64_t>(buf_size));
4272  if (bytes_available > buf_size) {
4273  memcpy(buf, one_profile_data.c_str(), buf_size);
4274  one_profile_data.erase(0, buf_size);
4275  bytes_available = buf_size;
4276  } else {
4277  memcpy(buf, one_profile_data.c_str(), bytes_available);
4278  m_profile_data.erase(m_profile_data.begin());
4279  }
4280  }
4281  return bytes_available;
4282 }
4283 
4284 // Process STDIO
4285 
4286 size_t Process::GetSTDOUT(char *buf, size_t buf_size, Status &error) {
4287  std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
4288  size_t bytes_available = m_stdout_data.size();
4289  if (bytes_available > 0) {
4291  LLDB_LOGF(log, "Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4292  static_cast<void *>(buf), static_cast<uint64_t>(buf_size));
4293  if (bytes_available > buf_size) {
4294  memcpy(buf, m_stdout_data.c_str(), buf_size);
4295  m_stdout_data.erase(0, buf_size);
4296  bytes_available = buf_size;
4297  } else {
4298  memcpy(buf, m_stdout_data.c_str(), bytes_available);
4299  m_stdout_data.clear();
4300  }
4301  }
4302  return bytes_available;
4303 }
4304 
4305 size_t Process::GetSTDERR(char *buf, size_t buf_size, Status &error) {
4306  std::lock_guard<std::recursive_mutex> gaurd(m_stdio_communication_mutex);
4307  size_t bytes_available = m_stderr_data.size();
4308  if (bytes_available > 0) {
4310  LLDB_LOGF(log, "Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4311  static_cast<void *>(buf), static_cast<uint64_t>(buf_size));
4312  if (bytes_available > buf_size) {
4313  memcpy(buf, m_stderr_data.c_str(), buf_size);
4314  m_stderr_data.erase(0, buf_size);
4315  bytes_available = buf_size;
4316  } else {
4317  memcpy(buf, m_stderr_data.c_str(), bytes_available);
4318  m_stderr_data.clear();
4319  }
4320  }
4321  return bytes_available;
4322 }
4323 
4324 void Process::STDIOReadThreadBytesReceived(void *baton, const void *src,
4325  size_t src_len) {
4326  Process *process = (Process *)baton;
4327  process->AppendSTDOUT(static_cast<const char *>(src), src_len);
4328 }
4329 
4331 public:
4332  IOHandlerProcessSTDIO(Process *process, int write_fd)
4333  : IOHandler(process->GetTarget().GetDebugger(),
4334  IOHandler::Type::ProcessIO),
4335  m_process(process),
4336  m_read_file(GetInputFD(), File::eOpenOptionReadOnly, false),
4337  m_write_file(write_fd, File::eOpenOptionWriteOnly, false) {
4338  m_pipe.CreateNew(false);
4339  }
4340 
4341  ~IOHandlerProcessSTDIO() override = default;
4342 
4343  // Each IOHandler gets to run until it is done. It should read data from the
4344  // "in" and place output into "out" and "err and return when done.
4345  void Run() override {
4346  if (!m_read_file.IsValid() || !m_write_file.IsValid() ||
4347  !m_pipe.CanRead() || !m_pipe.CanWrite()) {
4348  SetIsDone(true);
4349  return;
4350  }
4351 
4352  SetIsDone(false);
4353  const int read_fd = m_read_file.GetDescriptor();
4354  Terminal terminal(read_fd);
4355  TerminalState terminal_state(terminal, false);
4356  terminal.SetCanonical(false);
4357  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  m_is_running = true;
4362  while (!GetIsDone()) {
4363  SelectHelper select_helper;
4364  select_helper.FDSetRead(read_fd);
4365  select_helper.FDSetRead(pipe_read_fd);
4366  Status error = select_helper.Select();
4367 
4368  if (error.Fail()) {
4369  SetIsDone(true);
4370  } else {
4371  char ch = 0;
4372  size_t n;
4373  if (select_helper.FDIsSetRead(read_fd)) {
4374  n = 1;
4375  if (m_read_file.Read(&ch, n).Success() && n == 1) {
4376  if (m_write_file.Write(&ch, n).Fail() || n != 1)
4377  SetIsDone(true);
4378  } else
4379  SetIsDone(true);
4380  }
4381  if (select_helper.FDIsSetRead(pipe_read_fd)) {
4382  size_t bytes_read;
4383  // Consume the interrupt byte
4384  Status error = m_pipe.Read(&ch, 1, bytes_read);
4385  if (error.Success()) {
4386  switch (ch) {
4387  case 'q':
4388  SetIsDone(true);
4389  break;
4390  case 'i':
4393  break;
4394  }
4395  }
4396  }
4397  }
4398  }
4399  m_is_running = false;
4400 #endif
4401  }
4402 
4403  void Cancel() override {
4404  SetIsDone(true);
4405  // Only write to our pipe to cancel if we are in
4406  // IOHandlerProcessSTDIO::Run(). We can end up with a python command that
4407  // is being run from the command interpreter:
4408  //
4409  // (lldb) step_process_thousands_of_times
4410  //
4411  // In this case the command interpreter will be in the middle of handling
4412  // the command and if the process pushes and pops the IOHandler thousands
4413  // of times, we can end up writing to m_pipe without ever consuming the
4414  // bytes from the pipe in IOHandlerProcessSTDIO::Run() and end up
4415  // deadlocking when the pipe gets fed up and blocks until data is consumed.
4416  if (m_is_running) {
4417  char ch = 'q'; // Send 'q' for quit
4418  size_t bytes_written = 0;
4419  m_pipe.Write(&ch, 1, bytes_written);
4420  }
4421  }
4422 
4423  bool Interrupt() override {
4424  // Do only things that are safe to do in an interrupt context (like in a
4425  // SIGINT handler), like write 1 byte to a file descriptor. This will
4426  // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
4427  // that was written to the pipe and then call
4428  // m_process->SendAsyncInterrupt() from a much safer location in code.
4429  if (m_active) {
4430  char ch = 'i'; // Send 'i' for interrupt
4431  size_t bytes_written = 0;
4432  Status result = m_pipe.Write(&ch, 1, bytes_written);
4433  return result.Success();
4434  } else {
4435  // This IOHandler might be pushed on the stack, but not being run
4436  // currently so do the right thing if we aren't actively watching for
4437  // STDIN by sending the interrupt to the process. Otherwise the write to
4438  // the pipe above would do nothing. This can happen when the command
4439  // interpreter is running and gets a "expression ...". It will be on the
4440  // IOHandler thread and sending the input is complete to the delegate
4441  // which will cause the expression to run, which will push the process IO
4442  // handler, but not run it.
4443 
4446  return true;
4447  }
4448  }
4449  return false;
4450  }
4451 
4452  void GotEOF() override {}
4453 
4454 protected:
4456  NativeFile m_read_file; // Read from this file (usually actual STDIN for LLDB
4457  NativeFile m_write_file; // Write to this file (usually the master pty for
4458  // getting io to debuggee)
4460  std::atomic<bool> m_is_running{false};
4461 };
4462 
4464  // First set up the Read Thread for reading/handling process I/O
4466  std::make_unique<ConnectionFileDescriptor>(fd, true));
4471 
4472  // Now read thread is set up, set up input reader.
4473 
4476  std::make_shared<IOHandlerProcessSTDIO>(this, fd);
4477  }
4478 }
4479 
4481  IOHandlerSP io_handler_sp(m_process_input_reader);
4482  if (io_handler_sp)
4483  return GetTarget().GetDebugger().IsTopIOHandler(io_handler_sp);
4484  return false;
4485 }
4487  IOHandlerSP io_handler_sp(m_process_input_reader);
4488  if (io_handler_sp) {
4490  LLDB_LOGF(log, "Process::%s pushing IO handler", __FUNCTION__);
4491 
4492  io_handler_sp->SetIsDone(false);
4493  // If we evaluate an utility function, then we don't cancel the current
4494  // IOHandler. Our IOHandler is non-interactive and shouldn't disturb the
4495  // existing IOHandler that potentially provides the user interface (e.g.
4496  // the IOHandler for Editline).
4497  bool cancel_top_handler = !m_mod_id.IsRunningUtilityFunction();
4498  GetTarget().GetDebugger().RunIOHandlerAsync(io_handler_sp,
4499  cancel_top_handler);
4500  return true;
4501  }
4502  return false;
4503 }
4504 
4506  IOHandlerSP io_handler_sp(m_process_input_reader);
4507  if (io_handler_sp)
4508  return GetTarget().GetDebugger().RemoveIOHandler(io_handler_sp);
4509  return false;
4510 }
4511 
4512 // The process needs to know about installed plug-ins
4514 
4516 
4517 namespace {
4518 // RestorePlanState is used to record the "is private", "is master" and "okay
4519 // to discard" fields of the plan we are running, and reset it on Clean or on
4520 // destruction. It will only reset the state once, so you can call Clean and
4521 // then monkey with the state and it won't get reset on you again.
4522 
4523 class RestorePlanState {
4524 public:
4525  RestorePlanState(lldb::ThreadPlanSP thread_plan_sp)
4526  : m_thread_plan_sp(thread_plan_sp), m_already_reset(false) {
4527  if (m_thread_plan_sp) {
4528  m_private = m_thread_plan_sp->GetPrivate();
4529  m_is_master = m_thread_plan_sp->IsMasterPlan();
4530  m_okay_to_discard = m_thread_plan_sp->OkayToDiscard();
4531  }
4532  }
4533 
4534  ~RestorePlanState() { Clean(); }
4535 
4536  void Clean() {
4537  if (!m_already_reset && m_thread_plan_sp) {
4538  m_already_reset = true;
4539  m_thread_plan_sp->SetPrivate(m_private);
4540  m_thread_plan_sp->SetIsMasterPlan(m_is_master);
4541  m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);
4542  }
4543  }
4544 
4545 private:
4546  lldb::ThreadPlanSP m_thread_plan_sp;
4547  bool m_already_reset;
4548  bool m_private;
4549  bool m_is_master;
4550  bool m_okay_to_discard;
4551 };
4552 } // anonymous namespace
4553 
4554 static microseconds
4556  const milliseconds default_one_thread_timeout(250);
4557 
4558  // If the overall wait is forever, then we don't need to worry about it.
4559  if (!options.GetTimeout()) {
4560  return options.GetOneThreadTimeout() ? *options.GetOneThreadTimeout()
4561  : default_one_thread_timeout;
4562  }
4563 
4564  // If the one thread timeout is set, use it.
4565  if (options.GetOneThreadTimeout())
4566  return *options.GetOneThreadTimeout();
4567 
4568  // Otherwise use half the total timeout, bounded by the
4569  // default_one_thread_timeout.
4570  return std::min<microseconds>(default_one_thread_timeout,
4571  *options.GetTimeout() / 2);
4572 }
4573 
4574 static Timeout<std::micro>
4576  bool before_first_timeout) {
4577  // If we are going to run all threads the whole time, or if we are only going
4578  // to run one thread, we can just return the overall timeout.
4579  if (!options.GetStopOthers() || !options.GetTryAllThreads())
4580  return options.GetTimeout();
4581 
4582  if (before_first_timeout)
4583  return GetOneThreadExpressionTimeout(options);
4584 
4585  if (!options.GetTimeout())
4586  return llvm::None;
4587  else
4588  return *options.GetTimeout() - GetOneThreadExpressionTimeout(options);
4589 }
4590 
4591 static llvm::Optional<ExpressionResults>
4592 HandleStoppedEvent(lldb::tid_t thread_id, const ThreadPlanSP &thread_plan_sp,
4593  RestorePlanState &restorer, const EventSP &event_sp,
4594  EventSP &event_to_broadcast_sp,
4595  const EvaluateExpressionOptions &options,
4596  bool handle_interrupts) {
4598 
4599  ThreadSP thread_sp = thread_plan_sp->GetTarget()
4600  .GetProcessSP()
4601  ->GetThreadList()
4602  .FindThreadByID(thread_id);
4603  if (!thread_sp) {
4604  LLDB_LOG(log,
4605  "The thread on which we were running the "
4606  "expression: tid = {0}, exited while "
4607  "the expression was running.",
4608  thread_id);
4610  }
4611 
4612  ThreadPlanSP plan = thread_sp->GetCompletedPlan();
4613  if (plan == thread_plan_sp && plan->PlanSucceeded()) {
4614  LLDB_LOG(log, "execution completed successfully");
4615 
4616  // Restore the plan state so it will get reported as intended when we are
4617  // done.
4618  restorer.Clean();
4619  return eExpressionCompleted;
4620  }
4621 
4622  StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
4623  if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint &&
4624  stop_info_sp->ShouldNotify(event_sp.get())) {
4625  LLDB_LOG(log, "stopped for breakpoint: {0}.", stop_info_sp->GetDescription());
4626  if (!options.DoesIgnoreBreakpoints()) {
4627  // Restore the plan state and then force Private to false. We are going
4628  // to stop because of this plan so we need it to become a public plan or
4629  // it won't report correctly when we continue to its termination later
4630  // on.
4631  restorer.Clean();
4632  thread_plan_sp->SetPrivate(false);
4633  event_to_broadcast_sp = event_sp;
4634  }
4635  return eExpressionHitBreakpoint;
4636  }
4637 
4638  if (!handle_interrupts &&
4640  return llvm::None;
4641 
4642  LLDB_LOG(log, "thread plan did not successfully complete");
4643  if (!options.DoesUnwindOnError())
4644  event_to_broadcast_sp = event_sp;
4645  return eExpressionInterrupted;
4646 }
4647 
4650  lldb::ThreadPlanSP &thread_plan_sp,
4651  const EvaluateExpressionOptions &options,
4652  DiagnosticManager &diagnostic_manager) {
4654 
4655  std::lock_guard<std::mutex> run_thread_plan_locker(m_run_thread_plan_lock);
4656 
4657  if (!thread_plan_sp) {
4658  diagnostic_manager.PutString(
4660  "RunThreadPlan called with empty thread plan.");
4661  return eExpressionSetupError;
4662  }
4663 
4664  if (!thread_plan_sp->ValidatePlan(nullptr)) {
4665  diagnostic_manager.PutString(
4667  "RunThreadPlan called with an invalid thread plan.");
4668  return eExpressionSetupError;
4669  }
4670 
4671  if (exe_ctx.GetProcessPtr() != this) {
4672  diagnostic_manager.PutString(eDiagnosticSeverityError,
4673  "RunThreadPlan called on wrong process.");
4674  return eExpressionSetupError;
4675  }
4676 
4677  Thread *thread = exe_ctx.GetThreadPtr();
4678  if (thread == nullptr) {
4679  diagnostic_manager.PutString(eDiagnosticSeverityError,
4680  "RunThreadPlan called with invalid thread.");
4681  return eExpressionSetupError;
4682  }
4683 
4684  // Record the thread's id so we can tell when a thread we were using
4685  // to run the expression exits during the expression evaluation.
4686  lldb::tid_t expr_thread_id = thread->GetID();
4687 
4688  // We need to change some of the thread plan attributes for the thread plan
4689  // runner. This will restore them when we are done:
4690 
4691  RestorePlanState thread_plan_restorer(thread_plan_sp);
4692 
4693  // We rely on the thread plan we are running returning "PlanCompleted" if
4694  // when it successfully completes. For that to be true the plan can't be
4695  // private - since private plans suppress themselves in the GetCompletedPlan
4696  // call.
4697 
4698  thread_plan_sp->SetPrivate(false);
4699 
4700  // The plans run with RunThreadPlan also need to be terminal master plans or
4701  // when they are done we will end up asking the plan above us whether we
4702  // should stop, which may give the wrong answer.
4703 
4704  thread_plan_sp->SetIsMasterPlan(true);
4705  thread_plan_sp->SetOkayToDiscard(false);
4706 
4707  // If we are running some utility expression for LLDB, we now have to mark
4708  // this in the ProcesModID of this process. This RAII takes care of marking
4709  // and reverting the mark it once we are done running the expression.
4710  UtilityFunctionScope util_scope(options.IsForUtilityExpr() ? this : nullptr);
4711 
4713  diagnostic_manager.PutString(
4715  "RunThreadPlan called while the private state was not stopped.");
4716  return eExpressionSetupError;
4717  }
4718 
4719  // Save the thread & frame from the exe_ctx for restoration after we run
4720  const uint32_t thread_idx_id = thread->GetIndexID();
4721  StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
4722  if (!selected_frame_sp) {
4723  thread->SetSelectedFrame(nullptr);
4724  selected_frame_sp = thread->GetSelectedFrame();
4725  if (!selected_frame_sp) {
4726  diagnostic_manager.Printf(
4728  "RunThreadPlan called without a selected frame on thread %d",
4729  thread_idx_id);
4730  return eExpressionSetupError;
4731  }
4732  }
4733 
4734  // Make sure the timeout values make sense. The one thread timeout needs to
4735  // be smaller than the overall timeout.
4736  if (options.GetOneThreadTimeout() && options.GetTimeout() &&
4737  *options.GetTimeout() < *options.GetOneThreadTimeout()) {
4738  diagnostic_manager.PutString(eDiagnosticSeverityError,
4739  "RunThreadPlan called with one thread "
4740  "timeout greater than total timeout");
4741  return eExpressionSetupError;
4742  }
4743 
4744  StackID ctx_frame_id = selected_frame_sp->GetStackID();
4745 
4746  // N.B. Running the target may unset the currently selected thread and frame.
4747  // We don't want to do that either, so we should arrange to reset them as
4748  // well.
4749 
4750  lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
4751 
4752  uint32_t selected_tid;
4753  StackID selected_stack_id;
4754  if (selected_thread_sp) {
4755  selected_tid = selected_thread_sp->GetIndexID();
4756  selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
4757  } else {
4758  selected_tid = LLDB_INVALID_THREAD_ID;
4759  }
4760 
4761  HostThread backup_private_state_thread;
4762  lldb::StateType old_state = eStateInvalid;
4763  lldb::ThreadPlanSP stopper_base_plan_sp;
4764 
4768  // Yikes, we are running on the private state thread! So we can't wait for
4769  // public events on this thread, since we are the thread that is generating
4770  // public events. The simplest thing to do is to spin up a temporary thread
4771  // to handle private state thread events while we are fielding public
4772  // events here.
4773  LLDB_LOGF(log, "Running thread plan on private state thread, spinning up "
4774  "another state thread to handle the events.");
4775 
4776  backup_private_state_thread = m_private_state_thread;
4777 
4778  // One other bit of business: we want to run just this thread plan and
4779  // anything it pushes, and then stop, returning control here. But in the
4780  // normal course of things, the plan above us on the stack would be given a
4781  // shot at the stop event before deciding to stop, and we don't want that.
4782  // So we insert a "stopper" base plan on the stack before the plan we want
4783  // to run. Since base plans always stop and return control to the user,
4784  // that will do just what we want.
4785  stopper_base_plan_sp.reset(new ThreadPlanBase(*thread));
4786  thread->QueueThreadPlan(stopper_base_plan_sp, false);
4787  // Have to make sure our public state is stopped, since otherwise the
4788  // reporting logic below doesn't work correctly.
4789  old_state = m_public_state.GetValue();
4791 
4792  // Now spin up the private state thread:
4794  }
4795 
4796  thread->QueueThreadPlan(
4797  thread_plan_sp, false); // This used to pass "true" does that make sense?
4798 
4799  if (options.GetDebug()) {
4800  // In this case, we aren't actually going to run, we just want to stop
4801  // right away. Flush this thread so we will refetch the stacks and show the
4802  // correct backtrace.
4803  // FIXME: To make this prettier we should invent some stop reason for this,
4804  // but that
4805  // is only cosmetic, and this functionality is only of use to lldb
4806  // developers who can live with not pretty...
4807  thread->Flush();
4809  }
4810 
4811  ListenerSP listener_sp(
4812  Listener::MakeListener("lldb.process.listener.run-thread-plan"));
4813 
4814  lldb::EventSP event_to_broadcast_sp;
4815 
4816  {
4817  // This process event hijacker Hijacks the Public events and its destructor
4818  // makes sure that the process events get restored on exit to the function.
4819  //
4820  // If the event needs to propagate beyond the hijacker (e.g., the process
4821  // exits during execution), then the event is put into
4822  // event_to_broadcast_sp for rebroadcasting.
4823 
4824  ProcessEventHijacker run_thread_plan_hijacker(*this, listener_sp);
4825 
4826  if (log) {
4827  StreamString s;
4828  thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
4829  LLDB_LOGF(log,
4830  "Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64
4831  " to run thread plan \"%s\".",
4832  thread_idx_id, expr_thread_id, s.GetData());
4833  }
4834 
4835  bool got_event;
4836  lldb::EventSP event_sp;
4837  lldb::StateType stop_state = lldb::eStateInvalid;
4838 
4839  bool before_first_timeout = true; // This is set to false the first time
4840  // that we have to halt the target.
4841  bool do_resume = true;
4842  bool handle_running_event = true;
4843 
4844  // This is just for accounting:
4845  uint32_t num_resumes = 0;
4846 
4847  // If we are going to run all threads the whole time, or if we are only
4848  // going to run one thread, then we don't need the first timeout. So we
4849  // pretend we are after the first timeout already.
4850  if (!options.GetStopOthers() || !options.GetTryAllThreads())
4851  before_first_timeout = false;
4852 
4853  LLDB_LOGF(log, "Stop others: %u, try all: %u, before_first: %u.\n",
4854  options.GetStopOthers(), options.GetTryAllThreads(),
4855  before_first_timeout);
4856 
4857  // This isn't going to work if there are unfetched events on the queue. Are
4858  // there cases where we might want to run the remaining events here, and
4859  // then try to call the function? That's probably being too tricky for our
4860  // own good.
4861 
4862  Event *other_events = listener_sp->PeekAtNextEvent();
4863  if (other_events != nullptr) {
4864  diagnostic_manager.PutString(
4866  "RunThreadPlan called with pending events on the queue.");
4867  return eExpressionSetupError;
4868  }
4869 
4870  // We also need to make sure that the next event is delivered. We might be
4871  // calling a function as part of a thread plan, in which case the last
4872  // delivered event could be the running event, and we don't want event
4873  // coalescing to cause us to lose OUR running event...
4875 
4876 // This while loop must exit out the bottom, there's cleanup that we need to do
4877 // when we are done. So don't call return anywhere within it.
4878 
4879 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
4880  // It's pretty much impossible to write test cases for things like: One
4881  // thread timeout expires, I go to halt, but the process already stopped on
4882  // the function call stop breakpoint. Turning on this define will make us
4883  // not fetch the first event till after the halt. So if you run a quick
4884  // function, it will have completed, and the completion event will be
4885  // waiting, when you interrupt for halt. The expression evaluation should
4886  // still succeed.
4887  bool miss_first_event = true;
4888 #endif
4889  while (true) {
4890  // We usually want to resume the process if we get to the top of the
4891  // loop. The only exception is if we get two running events with no
4892  // intervening stop, which can happen, we will just wait for then next
4893  // stop event.
4894  LLDB_LOGF(log,
4895  "Top of while loop: do_resume: %i handle_running_event: %i "
4896  "before_first_timeout: %i.",
4897  do_resume, handle_running_event, before_first_timeout);
4898 
4899  if (do_resume || handle_running_event) {
4900  // Do the initial resume and wait for the running event before going
4901  // further.
4902 
4903  if (do_resume) {
4904  num_resumes++;
4905  Status resume_error = PrivateResume();
4906  if (!resume_error.Success()) {
4907  diagnostic_manager.Printf(
4909  "couldn't resume inferior the %d time: \"%s\".", num_resumes,
4910  resume_error.AsCString());
4911  return_value = eExpressionSetupError;
4912  break;
4913  }
4914  }
4915 
4916  got_event =
4917  listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
4918  if (!got_event) {
4919  LLDB_LOGF(log,
4920  "Process::RunThreadPlan(): didn't get any event after "
4921  "resume %" PRIu32 ", exiting.",
4922  num_resumes);
4923 
4924  diagnostic_manager.Printf(eDiagnosticSeverityError,
4925  "didn't get any event after resume %" PRIu32
4926  ", exiting.",
4927  num_resumes);
4928  return_value = eExpressionSetupError;
4929  break;
4930  }
4931 
4932  stop_state =
4934 
4935  if (stop_state != eStateRunning) {
4936  bool restarted = false;
4937 
4938  if (stop_state == eStateStopped) {
4940  event_sp.get());
4941  LLDB_LOGF(
4942  log,
4943  "Process::RunThreadPlan(): didn't get running event after "
4944  "resume %d, got %s instead (restarted: %i, do_resume: %i, "
4945  "handle_running_event: %i).",
4946  num_resumes, StateAsCString(stop_state), restarted, do_resume,
4947  handle_running_event);
4948  }
4949 
4950  if (restarted) {
4951  // This is probably an overabundance of caution, I don't think I
4952  // should ever get a stopped & restarted event here. But if I do,
4953  // the best thing is to Halt and then get out of here.
4954  const bool clear_thread_plans = false;
4955  const bool use_run_lock = false;
4956  Halt(clear_thread_plans, use_run_lock);
4957  }
4958 
4959  diagnostic_manager.Printf(
4961  "didn't get running event after initial resume, got %s instead.",
4962  StateAsCString(stop_state));
4963  return_value = eExpressionSetupError;
4964  break;
4965  }
4966 
4967  if (log)
4968  log->PutCString("Process::RunThreadPlan(): resuming succeeded.");
4969  // We need to call the function synchronously, so spin waiting for it
4970  // to return. If we get interrupted while executing, we're going to
4971  // lose our context, and won't be able to gather the result at this
4972  // point. We set the timeout AFTER the resume, since the resume takes
4973  // some time and we don't want to charge that to the timeout.
4974  } else {
4975  if (log)
4976  log->PutCString("Process::RunThreadPlan(): waiting for next event.");
4977  }
4978 
4979  do_resume = true;
4980  handle_running_event = true;
4981 
4982  // Now wait for the process to stop again:
4983  event_sp.reset();
4984 
4985  Timeout<std::micro> timeout =
4986  GetExpressionTimeout(options, before_first_timeout);
4987  if (log) {
4988  if (timeout) {
4989  auto now = system_clock::now();
4990  LLDB_LOGF(log,
4991  "Process::RunThreadPlan(): about to wait - now is %s - "
4992  "endpoint is %s",
4993  llvm::to_string(now).c_str(),
4994  llvm::to_string(now + *timeout).c_str());
4995  } else {
4996  LLDB_LOGF(log, "Process::RunThreadPlan(): about to wait forever.");
4997  }
4998  }
4999 
5000 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5001  // See comment above...
5002  if (miss_first_event) {
5003  std::this_thread::sleep_for(std::chrono::milliseconds(1));
5004  miss_first_event = false;
5005  got_event = false;
5006  } else
5007 #endif
5008  got_event = listener_sp->GetEvent(event_sp, timeout);
5009 
5010  if (got_event) {
5011  if (event_sp) {
5012  bool keep_going = false;
5013  if (event_sp->GetType() == eBroadcastBitInterrupt) {
5014  const bool clear_thread_plans = false;
5015  const bool use_run_lock = false;
5016  Halt(clear_thread_plans, use_run_lock);
5017  return_value = eExpressionInterrupted;
5018  diagnostic_manager.PutString(eDiagnosticSeverityRemark,
5019  "execution halted by user interrupt.");
5020  LLDB_LOGF(log, "Process::RunThreadPlan(): Got interrupted by "
5021  "eBroadcastBitInterrupted, exiting.");
5022  break;
5023  } else {
5024  stop_state =
5026  LLDB_LOGF(log,
5027  "Process::RunThreadPlan(): in while loop, got event: %s.",
5028  StateAsCString(stop_state));
5029 
5030  switch (stop_state) {
5031  case lldb::eStateStopped: {
5033  event_sp.get())) {
5034  // If we were restarted, we just need to go back up to fetch
5035  // another event.
5036  LLDB_LOGF(log, "Process::RunThreadPlan(): Got a stop and "
5037  "restart, so we'll continue waiting.");
5038  keep_going = true;
5039  do_resume = false;
5040  handle_running_event = true;
5041  } else {
5042  const bool handle_interrupts = true;
5043  return_value = *HandleStoppedEvent(
5044  expr_thread_id, thread_plan_sp, thread_plan_restorer,
5045  event_sp, event_to_broadcast_sp, options,
5046  handle_interrupts);
5047  if (return_value == eExpressionThreadVanished)
5048  keep_going = false;
5049  }
5050  } break;
5051 
5052  case lldb::eStateRunning:
5053  // This shouldn't really happen, but sometimes we do get two
5054  // running events without an intervening stop, and in that case
5055  // we should just go back to waiting for the stop.
5056  do_resume = false;
5057  keep_going = true;
5058  handle_running_event = false;
5059  break;
5060 
5061  default:
5062  LLDB_LOGF(log,
5063  "Process::RunThreadPlan(): execution stopped with "
5064  "unexpected state: %s.",
5065  StateAsCString(stop_state));
5066 
5067  if (stop_state == eStateExited)
5068  event_to_broadcast_sp = event_sp;
5069 
5070  diagnostic_manager.PutString(
5072  "execution stopped with unexpected state.");
5073  return_value = eExpressionInterrupted;
5074  break;
5075  }
5076  }
5077 
5078  if (keep_going)
5079  continue;
5080  else
5081  break;
5082  } else {
5083  if (log)
5084  log->PutCString("Process::RunThreadPlan(): got_event was true, but "
5085  "the event pointer was null. How odd...");
5086  return_value = eExpressionInterrupted;
5087  break;
5088  }
5089  } else {
5090  // If we didn't get an event that means we've timed out... We will
5091  // interrupt the process here. Depending on what we were asked to do
5092  // we will either exit, or try with all threads running for the same
5093  // timeout.
5094 
5095  if (log) {
5096  if (options.GetTryAllThreads()) {
5097  if (before_first_timeout) {
5098  LLDB_LOG(log,
5099  "Running function with one thread timeout timed out.");
5100  } else
5101  LLDB_LOG(log, "Restarting function with all threads enabled and "
5102  "timeout: {0} timed out, abandoning execution.",
5103  timeout);
5104  } else
5105  LLDB_LOG(log, "Running function with timeout: {0} timed out, "
5106  "abandoning execution.",
5107  timeout);
5108  }
5109 
5110  // It is possible that between the time we issued the Halt, and we get
5111  // around to calling Halt the target could have stopped. That's fine,
5112  // Halt will figure that out and send the appropriate Stopped event.
5113  // BUT it is also possible that we stopped & restarted (e.g. hit a
5114  // signal with "stop" set to false.) In
5115  // that case, we'll get the stopped & restarted event, and we should go
5116  // back to waiting for the Halt's stopped event. That's what this
5117  // while loop does.
5118 
5119  bool back_to_top = true;
5120  uint32_t try_halt_again = 0;
5121  bool do_halt = true;
5122  const uint32_t num_retries = 5;
5123  while (try_halt_again < num_retries) {
5124  Status halt_error;
5125  if (do_halt) {
5126  LLDB_LOGF(log, "Process::RunThreadPlan(): Running Halt.");
5127  const bool clear_thread_plans = false;
5128  const bool use_run_lock = false;
5129  Halt(clear_thread_plans, use_run_lock);
5130  }
5131  if (halt_error.Success()) {
5132  if (log)
5133  log->PutCString("Process::RunThreadPlan(): Halt succeeded.");
5134 
5135  got_event =
5136  listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
5137 
5138  if (got_event) {
5139  stop_state =
5141  if (log) {
5142  LLDB_LOGF(log,
5143  "Process::RunThreadPlan(): Stopped with event: %s",
5144  StateAsCString(stop_state));
5145  if (stop_state == lldb::eStateStopped &&
5147  event_sp.get()))
5148  log->PutCString(" Event was the Halt interruption event.");
5149  }
5150 
5151  if (stop_state == lldb::eStateStopped) {
5153  event_sp.get())) {
5154  if (log)
5155  log->PutCString("Process::RunThreadPlan(): Went to halt "
5156  "but got a restarted event, there must be "
5157  "an un-restarted stopped event so try "
5158  "again... "
5159  "Exiting wait loop.");
5160  try_halt_again++;
5161  do_halt = false;
5162  continue;
5163  }
5164 
5165  // Between the time we initiated the Halt and the time we
5166  // delivered it, the process could have already finished its
5167  // job. Check that here:
5168  const bool handle_interrupts = false;
5169  if (auto result = HandleStoppedEvent(
5170  expr_thread_id, thread_plan_sp, thread_plan_restorer,
5171  event_sp, event_to_broadcast_sp, options,
5172  handle_interrupts)) {
5173  return_value = *result;
5174  back_to_top = false;
5175  break;
5176  }
5177 
5178  if (!options.GetTryAllThreads()) {
5179  if (log)
5180  log->PutCString("Process::RunThreadPlan(): try_all_threads "
5181  "was false, we stopped so now we're "
5182  "quitting.");
5183  return_value = eExpressionInterrupted;
5184  back_to_top = false;
5185  break;
5186  }
5187 
5188  if (before_first_timeout) {
5189  // Set all the other threads to run, and return to the top of
5190  // the loop, which will continue;
5191  before_first_timeout = false;
5192  thread_plan_sp->SetStopOthers(false);
5193  if (log)
5194  log->PutCString(
5195  "Process::RunThreadPlan(): about to resume.");
5196 
5197  back_to_top = true;
5198  break;
5199  } else {
5200  // Running all threads failed, so return Interrupted.
5201  if (log)
5202  log->PutCString("Process::RunThreadPlan(): running all "
5203  "threads timed out.");
5204  return_value = eExpressionInterrupted;
5205  back_to_top = false;
5206  break;
5207  }
5208  }
5209  } else {
5210  if (log)
5211  log->PutCString("Process::RunThreadPlan(): halt said it "
5212  "succeeded, but I got no event. "
5213  "I'm getting out of here passing Interrupted.");
5214  return_value = eExpressionInterrupted;
5215  back_to_top = false;
5216  break;
5217  }
5218  } else {
5219  try_halt_again++;
5220  continue;
5221  }
5222  }
5223 
5224  if (!back_to_top || try_halt_again > num_retries)
5225  break;
5226  else
5227  continue;
5228  }
5229  } // END WAIT LOOP
5230 
5231  // If we had to start up a temporary private state thread to run this
5232  // thread plan, shut it down now.
5233  if (backup_private_state_thread.IsJoinable()) {
5235  Status error;
5236  m_private_state_thread = backup_private_state_thread;
5237  if (stopper_base_plan_sp) {
5238  thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
5239  }
5240  if (old_state != eStateInvalid)
5241  m_public_state.SetValueNoLock(old_state);
5242  }
5243 
5244  // If our thread went away on us, we need to get out of here without
5245  // doing any more work. We don't have to clean up the thread plan, that
5246  // will have happened when the Thread was destroyed.
5247  if (return_value == eExpressionThreadVanished) {
5248  return return_value;
5249  }
5250 
5251  if (return_value != eExpressionCompleted && log) {
5252  // Print a backtrace into the log so we can figure out where we are:
5253  StreamString s;
5254  s.PutCString("Thread state after unsuccessful completion: \n");
5255  thread->GetStackFrameStatus(s, 0, UINT32_MAX, true, UINT32_MAX);
5256  log->PutString(s.GetString());
5257  }
5258  // Restore the thread state if we are going to discard the plan execution.
5259  // There are three cases where this could happen: 1) The execution
5260  // successfully completed 2) We hit a breakpoint, and ignore_breakpoints
5261  // was true 3) We got some other error, and discard_on_error was true
5262  bool should_unwind = (return_value == eExpressionInterrupted &&
5263  options.DoesUnwindOnError()) ||
5264  (return_value == eExpressionHitBreakpoint &&
5265  options.DoesIgnoreBreakpoints());
5266 
5267  if (return_value == eExpressionCompleted || should_unwind) {
5268  thread_plan_sp->RestoreThreadState();
5269  }
5270 
5271  // Now do some processing on the results of the run:
5272  if (return_value == eExpressionInterrupted ||
5273  return_value == eExpressionHitBreakpoint) {
5274  if (log) {
5275  StreamString s;
5276  if (event_sp)
5277  event_sp->Dump(&s);
5278  else {
5279  log->PutCString("Process::RunThreadPlan(): Stop event that "
5280  "interrupted us is NULL.");
5281  }
5282 
5283  StreamString ts;
5284 
5285  const char *event_explanation = nullptr;
5286 
5287  do {
5288  if (!event_sp) {
5289  event_explanation = "<no event>";
5290  break;
5291  } else if (event_sp->GetType() == eBroadcastBitInterrupt) {
5292  event_explanation = "<user interrupt>";
5293  break;
5294  } else {
5295  const Process::ProcessEventData *event_data =
5297  event_sp.get());
5298 
5299  if (!event_data) {
5300  event_explanation = "<no event data>";
5301  break;
5302  }
5303 
5304  Process *process = event_data->GetProcessSP().get();
5305 
5306  if (!process) {
5307  event_explanation = "<no process>";
5308  break;
5309  }
5310 
5311  ThreadList &thread_list = process->GetThreadList();
5312 
5313  uint32_t num_threads = thread_list.GetSize();
5314  uint32_t thread_index;
5315 
5316  ts.Printf("<%u threads> ", num_threads);
5317 
5318  for (thread_index = 0; thread_index < num_threads; ++thread_index) {
5319  Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
5320 
5321  if (!thread) {
5322  ts.Printf("<?> ");
5323  continue;
5324  }
5325 
5326  ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
5327  RegisterContext *register_context =
5328  thread->GetRegisterContext().get();
5329 
5330  if (register_context)
5331  ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
5332  else
5333  ts.Printf("[ip unknown] ");
5334 
5335  // Show the private stop info here, the public stop info will be
5336  // from the last natural stop.
5337  lldb::StopInfoSP stop_info_sp = thread->GetPrivateStopInfo();
5338  if (stop_info_sp) {
5339  const char *stop_desc = stop_info_sp->GetDescription();
5340  if (stop_desc)
5341  ts.PutCString(stop_desc);
5342  }
5343  ts.Printf(">");
5344  }
5345 
5346  event_explanation = ts.GetData();
5347  }
5348  } while (false);
5349 
5350  if (event_explanation)
5351  LLDB_LOGF(log,
5352  "Process::RunThreadPlan(): execution interrupted: %s %s",
5353  s.GetData(), event_explanation);
5354  else
5355  LLDB_LOGF(log, "Process::RunThreadPlan(): execution interrupted: %s",
5356  s.GetData());
5357  }
5358 
5359  if (should_unwind) {
5360  LLDB_LOGF(log,
5361  "Process::RunThreadPlan: ExecutionInterrupted - "
5362  "discarding thread plans up to %p.",
5363  static_cast<void *>(thread_plan_sp.get()));
5364  thread->DiscardThreadPlansUpToPlan(thread_plan_sp);
5365  } else {
5366  LLDB_LOGF(log,
5367  "Process::RunThreadPlan: ExecutionInterrupted - for "
5368  "plan: %p not discarding.",
5369  static_cast<void *>(thread_plan_sp.get()));
5370  }
5371  } else if (return_value == eExpressionSetupError) {
5372  if (log)
5373  log->PutCString("Process::RunThreadPlan(): execution set up error.");
5374 
5375  if (options.DoesUnwindOnError()) {
5376  thread->DiscardThreadPlansUpToPlan(thread_plan_sp);
5377  }
5378  } else {
5379  if (thread->IsThreadPlanDone(thread_plan_sp.get())) {
5380  if (log)
5381  log->PutCString("Process::RunThreadPlan(): thread plan is done");
5382  return_value = eExpressionCompleted;
5383  } else if (thread->WasThreadPlanDiscarded(thread_plan_sp.get())) {
5384  if (log)