1 //===-- Process.cpp ---------------------------------------------*- C++ -*-===// 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/Support/ScopedPrinter.h" 14 #include "llvm/Support/Threading.h" 15 16 #include "Plugins/Process/Utility/InferiorCallPOSIX.h" 17 #include "lldb/Breakpoint/BreakpointLocation.h" 18 #include "lldb/Breakpoint/StoppointCallbackContext.h" 19 #include "lldb/Core/Debugger.h" 20 #include "lldb/Core/Module.h" 21 #include "lldb/Core/ModuleSpec.h" 22 #include "lldb/Core/PluginManager.h" 23 #include "lldb/Core/StreamFile.h" 24 #include "lldb/Expression/DiagnosticManager.h" 25 #include "lldb/Expression/DynamicCheckerFunctions.h" 26 #include "lldb/Expression/UserExpression.h" 27 #include "lldb/Expression/UtilityFunction.h" 28 #include "lldb/Host/ConnectionFileDescriptor.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" 35 #include "lldb/Host/ThreadLauncher.h" 36 #include "lldb/Interpreter/CommandInterpreter.h" 37 #include "lldb/Interpreter/OptionArgParser.h" 38 #include "lldb/Interpreter/OptionValueProperties.h" 39 #include "lldb/Symbol/Function.h" 40 #include "lldb/Symbol/Symbol.h" 41 #include "lldb/Target/ABI.h" 42 #include "lldb/Target/DynamicLoader.h" 43 #include "lldb/Target/InstrumentationRuntime.h" 44 #include "lldb/Target/JITLoader.h" 45 #include "lldb/Target/JITLoaderList.h" 46 #include "lldb/Target/Language.h" 47 #include "lldb/Target/LanguageRuntime.h" 48 #include "lldb/Target/MemoryHistory.h" 49 #include "lldb/Target/MemoryRegionInfo.h" 50 #include "lldb/Target/OperatingSystem.h" 51 #include "lldb/Target/Platform.h" 52 #include "lldb/Target/Process.h" 53 #include "lldb/Target/RegisterContext.h" 54 #include "lldb/Target/StopInfo.h" 55 #include "lldb/Target/StructuredDataPlugin.h" 56 #include "lldb/Target/SystemRuntime.h" 57 #include "lldb/Target/Target.h" 58 #include "lldb/Target/TargetList.h" 59 #include "lldb/Target/Thread.h" 60 #include "lldb/Target/ThreadPlan.h" 61 #include "lldb/Target/ThreadPlanBase.h" 62 #include "lldb/Target/UnixSignals.h" 63 #include "lldb/Utility/Event.h" 64 #include "lldb/Utility/Log.h" 65 #include "lldb/Utility/NameMatches.h" 66 #include "lldb/Utility/ProcessInfo.h" 67 #include "lldb/Utility/SelectHelper.h" 68 #include "lldb/Utility/State.h" 69 70 using namespace lldb; 71 using namespace lldb_private; 72 using namespace std::chrono; 73 74 // Comment out line below to disable memory caching, overriding the process 75 // setting target.process.disable-memory-cache 76 #define ENABLE_MEMORY_CACHING 77 78 #ifdef ENABLE_MEMORY_CACHING 79 #define DISABLE_MEM_CACHE_DEFAULT false 80 #else 81 #define DISABLE_MEM_CACHE_DEFAULT true 82 #endif 83 84 class ProcessOptionValueProperties : public OptionValueProperties { 85 public: 86 ProcessOptionValueProperties(ConstString name) 87 : OptionValueProperties(name) {} 88 89 // This constructor is used when creating ProcessOptionValueProperties when 90 // it is part of a new lldb_private::Process instance. It will copy all 91 // current global property values as needed 92 ProcessOptionValueProperties(ProcessProperties *global_properties) 93 : OptionValueProperties(*global_properties->GetValueProperties()) {} 94 95 const Property *GetPropertyAtIndex(const ExecutionContext *exe_ctx, 96 bool will_modify, 97 uint32_t idx) const override { 98 // When getting the value for a key from the process options, we will 99 // always try and grab the setting from the current process if there is 100 // one. Else we just use the one from this instance. 101 if (exe_ctx) { 102 Process *process = exe_ctx->GetProcessPtr(); 103 if (process) { 104 ProcessOptionValueProperties *instance_properties = 105 static_cast<ProcessOptionValueProperties *>( 106 process->GetValueProperties().get()); 107 if (this != instance_properties) 108 return instance_properties->ProtectedGetPropertyAtIndex(idx); 109 } 110 } 111 return ProtectedGetPropertyAtIndex(idx); 112 } 113 }; 114 115 static constexpr PropertyDefinition g_properties[] = { 116 {"disable-memory-cache", OptionValue::eTypeBoolean, false, 117 DISABLE_MEM_CACHE_DEFAULT, nullptr, {}, 118 "Disable reading and caching of memory in fixed-size units."}, 119 {"extra-startup-command", OptionValue::eTypeArray, false, 120 OptionValue::eTypeString, nullptr, {}, 121 "A list containing extra commands understood by the particular process " 122 "plugin used. " 123 "For instance, to turn on debugserver logging set this to " 124 "\"QSetLogging:bitmask=LOG_DEFAULT;\""}, 125 {"ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, true, 126 nullptr, {}, 127 "If true, breakpoints will be ignored during expression evaluation."}, 128 {"unwind-on-error-in-expressions", OptionValue::eTypeBoolean, true, true, 129 nullptr, {}, "If true, errors in expression evaluation will unwind " 130 "the stack back to the state before the call."}, 131 {"python-os-plugin-path", OptionValue::eTypeFileSpec, false, true, nullptr, 132 {}, "A path to a python OS plug-in module file that contains a " 133 "OperatingSystemPlugIn class."}, 134 {"stop-on-sharedlibrary-events", OptionValue::eTypeBoolean, true, false, 135 nullptr, {}, 136 "If true, stop when a shared library is loaded or unloaded."}, 137 {"detach-keeps-stopped", OptionValue::eTypeBoolean, true, false, nullptr, 138 {}, "If true, detach will attempt to keep the process stopped."}, 139 {"memory-cache-line-size", OptionValue::eTypeUInt64, false, 512, nullptr, 140 {}, "The memory cache line size"}, 141 {"optimization-warnings", OptionValue::eTypeBoolean, false, true, nullptr, 142 {}, "If true, warn when stopped in code that is optimized where " 143 "stepping and variable availability may not behave as expected."}, 144 {"stop-on-exec", OptionValue::eTypeBoolean, true, true, 145 nullptr, {}, 146 "If true, stop when a shared library is loaded or unloaded."}, 147 {"utility-expression-timeout", OptionValue::eTypeUInt64, false, 15, 148 nullptr, {}, 149 "The time in seconds to wait for LLDB-internal utility expressions."} 150 }; 151 152 enum { 153 ePropertyDisableMemCache, 154 ePropertyExtraStartCommand, 155 ePropertyIgnoreBreakpointsInExpressions, 156 ePropertyUnwindOnErrorInExpressions, 157 ePropertyPythonOSPluginPath, 158 ePropertyStopOnSharedLibraryEvents, 159 ePropertyDetachKeepsStopped, 160 ePropertyMemCacheLineSize, 161 ePropertyWarningOptimization, 162 ePropertyStopOnExec, 163 ePropertyUtilityExpressionTimeout, 164 }; 165 166 ProcessProperties::ProcessProperties(lldb_private::Process *process) 167 : Properties(), 168 m_process(process) // Can be nullptr for global ProcessProperties 169 { 170 if (process == nullptr) { 171 // Global process properties, set them up one time 172 m_collection_sp = 173 std::make_shared<ProcessOptionValueProperties>(ConstString("process")); 174 m_collection_sp->Initialize(g_properties); 175 m_collection_sp->AppendProperty( 176 ConstString("thread"), ConstString("Settings specific to threads."), 177 true, Thread::GetGlobalProperties()->GetValueProperties()); 178 } else { 179 m_collection_sp = std::make_shared<ProcessOptionValueProperties>( 180 Process::GetGlobalProperties().get()); 181 m_collection_sp->SetValueChangedCallback( 182 ePropertyPythonOSPluginPath, 183 ProcessProperties::OptionValueChangedCallback, this); 184 } 185 } 186 187 ProcessProperties::~ProcessProperties() = default; 188 189 void ProcessProperties::OptionValueChangedCallback(void *baton, 190 OptionValue *option_value) { 191 ProcessProperties *properties = (ProcessProperties *)baton; 192 if (properties->m_process) 193 properties->m_process->LoadOperatingSystemPlugin(true); 194 } 195 196 bool ProcessProperties::GetDisableMemoryCache() const { 197 const uint32_t idx = ePropertyDisableMemCache; 198 return m_collection_sp->GetPropertyAtIndexAsBoolean( 199 nullptr, idx, g_properties[idx].default_uint_value != 0); 200 } 201 202 uint64_t ProcessProperties::GetMemoryCacheLineSize() const { 203 const uint32_t idx = ePropertyMemCacheLineSize; 204 return m_collection_sp->GetPropertyAtIndexAsUInt64( 205 nullptr, idx, g_properties[idx].default_uint_value); 206 } 207 208 Args ProcessProperties::GetExtraStartupCommands() const { 209 Args args; 210 const uint32_t idx = ePropertyExtraStartCommand; 211 m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args); 212 return args; 213 } 214 215 void ProcessProperties::SetExtraStartupCommands(const Args &args) { 216 const uint32_t idx = ePropertyExtraStartCommand; 217 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args); 218 } 219 220 FileSpec ProcessProperties::GetPythonOSPluginPath() const { 221 const uint32_t idx = ePropertyPythonOSPluginPath; 222 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); 223 } 224 225 void ProcessProperties::SetPythonOSPluginPath(const FileSpec &file) { 226 const uint32_t idx = ePropertyPythonOSPluginPath; 227 m_collection_sp->SetPropertyAtIndexAsFileSpec(nullptr, idx, file); 228 } 229 230 bool ProcessProperties::GetIgnoreBreakpointsInExpressions() const { 231 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions; 232 return m_collection_sp->GetPropertyAtIndexAsBoolean( 233 nullptr, idx, g_properties[idx].default_uint_value != 0); 234 } 235 236 void ProcessProperties::SetIgnoreBreakpointsInExpressions(bool ignore) { 237 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions; 238 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore); 239 } 240 241 bool ProcessProperties::GetUnwindOnErrorInExpressions() const { 242 const uint32_t idx = ePropertyUnwindOnErrorInExpressions; 243 return m_collection_sp->GetPropertyAtIndexAsBoolean( 244 nullptr, idx, g_properties[idx].default_uint_value != 0); 245 } 246 247 void ProcessProperties::SetUnwindOnErrorInExpressions(bool ignore) { 248 const uint32_t idx = ePropertyUnwindOnErrorInExpressions; 249 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore); 250 } 251 252 bool ProcessProperties::GetStopOnSharedLibraryEvents() const { 253 const uint32_t idx = ePropertyStopOnSharedLibraryEvents; 254 return m_collection_sp->GetPropertyAtIndexAsBoolean( 255 nullptr, idx, g_properties[idx].default_uint_value != 0); 256 } 257 258 void ProcessProperties::SetStopOnSharedLibraryEvents(bool stop) { 259 const uint32_t idx = ePropertyStopOnSharedLibraryEvents; 260 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop); 261 } 262 263 bool ProcessProperties::GetDetachKeepsStopped() const { 264 const uint32_t idx = ePropertyDetachKeepsStopped; 265 return m_collection_sp->GetPropertyAtIndexAsBoolean( 266 nullptr, idx, g_properties[idx].default_uint_value != 0); 267 } 268 269 void ProcessProperties::SetDetachKeepsStopped(bool stop) { 270 const uint32_t idx = ePropertyDetachKeepsStopped; 271 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop); 272 } 273 274 bool ProcessProperties::GetWarningsOptimization() const { 275 const uint32_t idx = ePropertyWarningOptimization; 276 return m_collection_sp->GetPropertyAtIndexAsBoolean( 277 nullptr, idx, g_properties[idx].default_uint_value != 0); 278 } 279 280 bool ProcessProperties::GetStopOnExec() const { 281 const uint32_t idx = ePropertyStopOnExec; 282 return m_collection_sp->GetPropertyAtIndexAsBoolean( 283 nullptr, idx, g_properties[idx].default_uint_value != 0); 284 } 285 286 std::chrono::seconds ProcessProperties::GetUtilityExpressionTimeout() const { 287 const uint32_t idx = ePropertyUtilityExpressionTimeout; 288 uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64( 289 nullptr, idx, g_properties[idx].default_uint_value); 290 return std::chrono::seconds(value); 291 } 292 293 Status ProcessLaunchCommandOptions::SetOptionValue( 294 uint32_t option_idx, llvm::StringRef option_arg, 295 ExecutionContext *execution_context) { 296 Status error; 297 const int short_option = m_getopt_table[option_idx].val; 298 299 switch (short_option) { 300 case 's': // Stop at program entry point 301 launch_info.GetFlags().Set(eLaunchFlagStopAtEntry); 302 break; 303 304 case 'i': // STDIN for read only 305 { 306 FileAction action; 307 if (action.Open(STDIN_FILENO, FileSpec(option_arg), true, false)) 308 launch_info.AppendFileAction(action); 309 break; 310 } 311 312 case 'o': // Open STDOUT for write only 313 { 314 FileAction action; 315 if (action.Open(STDOUT_FILENO, FileSpec(option_arg), false, true)) 316 launch_info.AppendFileAction(action); 317 break; 318 } 319 320 case 'e': // STDERR for write only 321 { 322 FileAction action; 323 if (action.Open(STDERR_FILENO, FileSpec(option_arg), false, true)) 324 launch_info.AppendFileAction(action); 325 break; 326 } 327 328 case 'p': // Process plug-in name 329 launch_info.SetProcessPluginName(option_arg); 330 break; 331 332 case 'n': // Disable STDIO 333 { 334 FileAction action; 335 const FileSpec dev_null(FileSystem::DEV_NULL); 336 if (action.Open(STDIN_FILENO, dev_null, true, false)) 337 launch_info.AppendFileAction(action); 338 if (action.Open(STDOUT_FILENO, dev_null, false, true)) 339 launch_info.AppendFileAction(action); 340 if (action.Open(STDERR_FILENO, dev_null, false, true)) 341 launch_info.AppendFileAction(action); 342 break; 343 } 344 345 case 'w': 346 launch_info.SetWorkingDirectory(FileSpec(option_arg)); 347 break; 348 349 case 't': // Open process in new terminal window 350 launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY); 351 break; 352 353 case 'a': { 354 TargetSP target_sp = 355 execution_context ? execution_context->GetTargetSP() : TargetSP(); 356 PlatformSP platform_sp = 357 target_sp ? target_sp->GetPlatform() : PlatformSP(); 358 launch_info.GetArchitecture() = 359 Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg); 360 } break; 361 362 case 'A': // Disable ASLR. 363 { 364 bool success; 365 const bool disable_aslr_arg = 366 OptionArgParser::ToBoolean(option_arg, true, &success); 367 if (success) 368 disable_aslr = disable_aslr_arg ? eLazyBoolYes : eLazyBoolNo; 369 else 370 error.SetErrorStringWithFormat( 371 "Invalid boolean value for disable-aslr option: '%s'", 372 option_arg.empty() ? "<null>" : option_arg.str().c_str()); 373 break; 374 } 375 376 case 'X': // shell expand args. 377 { 378 bool success; 379 const bool expand_args = 380 OptionArgParser::ToBoolean(option_arg, true, &success); 381 if (success) 382 launch_info.SetShellExpandArguments(expand_args); 383 else 384 error.SetErrorStringWithFormat( 385 "Invalid boolean value for shell-expand-args option: '%s'", 386 option_arg.empty() ? "<null>" : option_arg.str().c_str()); 387 break; 388 } 389 390 case 'c': 391 if (!option_arg.empty()) 392 launch_info.SetShell(FileSpec(option_arg)); 393 else 394 launch_info.SetShell(HostInfo::GetDefaultShell()); 395 break; 396 397 case 'v': 398 launch_info.GetEnvironment().insert(option_arg); 399 break; 400 401 default: 402 error.SetErrorStringWithFormat("unrecognized short option character '%c'", 403 short_option); 404 break; 405 } 406 return error; 407 } 408 409 static constexpr OptionDefinition g_process_launch_options[] = { 410 {LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument, 411 nullptr, {}, 0, eArgTypeNone, 412 "Stop at the entry point of the program when launching a process."}, 413 {LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', 414 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, 415 "Set whether to disable address space layout randomization when launching " 416 "a process."}, 417 {LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, 418 nullptr, {}, 0, eArgTypePlugin, 419 "Name of the process plugin you want to use."}, 420 {LLDB_OPT_SET_ALL, false, "working-dir", 'w', 421 OptionParser::eRequiredArgument, nullptr, {}, 0, 422 eArgTypeDirectoryName, 423 "Set the current working directory to <path> when running the inferior."}, 424 {LLDB_OPT_SET_ALL, false, "arch", 'a', OptionParser::eRequiredArgument, 425 nullptr, {}, 0, eArgTypeArchitecture, 426 "Set the architecture for the process to launch when ambiguous."}, 427 {LLDB_OPT_SET_ALL, false, "environment", 'v', 428 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeNone, 429 "Specify an environment variable name/value string (--environment " 430 "NAME=VALUE). Can be specified multiple times for subsequent environment " 431 "entries."}, 432 {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "shell", 'c', 433 OptionParser::eOptionalArgument, nullptr, {}, 0, eArgTypeFilename, 434 "Run the process in a shell (not supported on all platforms)."}, 435 436 {LLDB_OPT_SET_1, false, "stdin", 'i', OptionParser::eRequiredArgument, 437 nullptr, {}, 0, eArgTypeFilename, 438 "Redirect stdin for the process to <filename>."}, 439 {LLDB_OPT_SET_1, false, "stdout", 'o', OptionParser::eRequiredArgument, 440 nullptr, {}, 0, eArgTypeFilename, 441 "Redirect stdout for the process to <filename>."}, 442 {LLDB_OPT_SET_1, false, "stderr", 'e', OptionParser::eRequiredArgument, 443 nullptr, {}, 0, eArgTypeFilename, 444 "Redirect stderr for the process to <filename>."}, 445 446 {LLDB_OPT_SET_2, false, "tty", 't', OptionParser::eNoArgument, nullptr, 447 {}, 0, eArgTypeNone, 448 "Start the process in a terminal (not supported on all platforms)."}, 449 450 {LLDB_OPT_SET_3, false, "no-stdio", 'n', OptionParser::eNoArgument, nullptr, 451 {}, 0, eArgTypeNone, 452 "Do not set up for terminal I/O to go to running process."}, 453 {LLDB_OPT_SET_4, false, "shell-expand-args", 'X', 454 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, 455 "Set whether to shell expand arguments to the process when launching."}, 456 }; 457 458 llvm::ArrayRef<OptionDefinition> ProcessLaunchCommandOptions::GetDefinitions() { 459 return llvm::makeArrayRef(g_process_launch_options); 460 } 461 462 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp, 463 llvm::StringRef plugin_name, 464 ListenerSP listener_sp, 465 const FileSpec *crash_file_path) { 466 static uint32_t g_process_unique_id = 0; 467 468 ProcessSP process_sp; 469 ProcessCreateInstance create_callback = nullptr; 470 if (!plugin_name.empty()) { 471 ConstString const_plugin_name(plugin_name); 472 create_callback = 473 PluginManager::GetProcessCreateCallbackForPluginName(const_plugin_name); 474 if (create_callback) { 475 process_sp = create_callback(target_sp, listener_sp, crash_file_path); 476 if (process_sp) { 477 if (process_sp->CanDebug(target_sp, true)) { 478 process_sp->m_process_unique_id = ++g_process_unique_id; 479 } else 480 process_sp.reset(); 481 } 482 } 483 } else { 484 for (uint32_t idx = 0; 485 (create_callback = 486 PluginManager::GetProcessCreateCallbackAtIndex(idx)) != nullptr; 487 ++idx) { 488 process_sp = create_callback(target_sp, listener_sp, crash_file_path); 489 if (process_sp) { 490 if (process_sp->CanDebug(target_sp, false)) { 491 process_sp->m_process_unique_id = ++g_process_unique_id; 492 break; 493 } else 494 process_sp.reset(); 495 } 496 } 497 } 498 return process_sp; 499 } 500 501 ConstString &Process::GetStaticBroadcasterClass() { 502 static ConstString class_name("lldb.process"); 503 return class_name; 504 } 505 506 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp) 507 : Process(target_sp, listener_sp, 508 UnixSignals::Create(HostInfo::GetArchitecture())) { 509 // This constructor just delegates to the full Process constructor, 510 // defaulting to using the Host's UnixSignals. 511 } 512 513 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp, 514 const UnixSignalsSP &unix_signals_sp) 515 : ProcessProperties(this), UserID(LLDB_INVALID_PROCESS_ID), 516 Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()), 517 Process::GetStaticBroadcasterClass().AsCString()), 518 m_target_wp(target_sp), m_public_state(eStateUnloaded), 519 m_private_state(eStateUnloaded), 520 m_private_state_broadcaster(nullptr, 521 "lldb.process.internal_state_broadcaster"), 522 m_private_state_control_broadcaster( 523 nullptr, "lldb.process.internal_state_control_broadcaster"), 524 m_private_state_listener_sp( 525 Listener::MakeListener("lldb.process.internal_state_listener")), 526 m_mod_id(), m_process_unique_id(0), m_thread_index_id(0), 527 m_thread_id_to_index_id_map(), m_exit_status(-1), m_exit_string(), 528 m_exit_status_mutex(), m_thread_mutex(), m_thread_list_real(this), 529 m_thread_list(this), m_extended_thread_list(this), 530 m_extended_thread_stop_id(0), m_queue_list(this), m_queue_list_stop_id(0), 531 m_notifications(), m_image_tokens(), m_listener_sp(listener_sp), 532 m_breakpoint_site_list(), m_dynamic_checkers_up(), 533 m_unix_signals_sp(unix_signals_sp), m_abi_sp(), m_process_input_reader(), 534 m_stdio_communication("process.stdio"), m_stdio_communication_mutex(), 535 m_stdin_forward(false), m_stdout_data(), m_stderr_data(), 536 m_profile_data_comm_mutex(), m_profile_data(), m_iohandler_sync(0), 537 m_memory_cache(*this), m_allocated_memory_cache(*this), 538 m_should_detach(false), m_next_event_action_up(), m_public_run_lock(), 539 m_private_run_lock(), m_finalizing(false), m_finalize_called(false), 540 m_clear_thread_plans_on_stop(false), m_force_next_event_delivery(false), 541 m_last_broadcast_state(eStateInvalid), m_destroy_in_process(false), 542 m_can_interpret_function_calls(false), m_warnings_issued(), 543 m_run_thread_plan_lock(), m_can_jit(eCanJITDontKnow) { 544 CheckInWithManager(); 545 546 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); 547 if (log) 548 log->Printf("%p Process::Process()", static_cast<void *>(this)); 549 550 if (!m_unix_signals_sp) 551 m_unix_signals_sp = std::make_shared<UnixSignals>(); 552 553 SetEventName(eBroadcastBitStateChanged, "state-changed"); 554 SetEventName(eBroadcastBitInterrupt, "interrupt"); 555 SetEventName(eBroadcastBitSTDOUT, "stdout-available"); 556 SetEventName(eBroadcastBitSTDERR, "stderr-available"); 557 SetEventName(eBroadcastBitProfileData, "profile-data-available"); 558 SetEventName(eBroadcastBitStructuredData, "structured-data-available"); 559 560 m_private_state_control_broadcaster.SetEventName( 561 eBroadcastInternalStateControlStop, "control-stop"); 562 m_private_state_control_broadcaster.SetEventName( 563 eBroadcastInternalStateControlPause, "control-pause"); 564 m_private_state_control_broadcaster.SetEventName( 565 eBroadcastInternalStateControlResume, "control-resume"); 566 567 m_listener_sp->StartListeningForEvents( 568 this, eBroadcastBitStateChanged | eBroadcastBitInterrupt | 569 eBroadcastBitSTDOUT | eBroadcastBitSTDERR | 570 eBroadcastBitProfileData | eBroadcastBitStructuredData); 571 572 m_private_state_listener_sp->StartListeningForEvents( 573 &m_private_state_broadcaster, 574 eBroadcastBitStateChanged | eBroadcastBitInterrupt); 575 576 m_private_state_listener_sp->StartListeningForEvents( 577 &m_private_state_control_broadcaster, 578 eBroadcastInternalStateControlStop | eBroadcastInternalStateControlPause | 579 eBroadcastInternalStateControlResume); 580 // We need something valid here, even if just the default UnixSignalsSP. 581 assert(m_unix_signals_sp && "null m_unix_signals_sp after initialization"); 582 583 // Allow the platform to override the default cache line size 584 OptionValueSP value_sp = 585 m_collection_sp 586 ->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize) 587 ->GetValue(); 588 uint32_t platform_cache_line_size = 589 target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize(); 590 if (!value_sp->OptionWasSet() && platform_cache_line_size != 0) 591 value_sp->SetUInt64Value(platform_cache_line_size); 592 } 593 594 Process::~Process() { 595 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); 596 if (log) 597 log->Printf("%p Process::~Process()", static_cast<void *>(this)); 598 StopPrivateStateThread(); 599 600 // ThreadList::Clear() will try to acquire this process's mutex, so 601 // explicitly clear the thread list here to ensure that the mutex is not 602 // destroyed before the thread list. 603 m_thread_list.Clear(); 604 } 605 606 const ProcessPropertiesSP &Process::GetGlobalProperties() { 607 // NOTE: intentional leak so we don't crash if global destructor chain gets 608 // called as other threads still use the result of this function 609 static ProcessPropertiesSP *g_settings_sp_ptr = 610 new ProcessPropertiesSP(new ProcessProperties(nullptr)); 611 return *g_settings_sp_ptr; 612 } 613 614 void Process::Finalize() { 615 m_finalizing = true; 616 617 // Destroy this process if needed 618 switch (GetPrivateState()) { 619 case eStateConnected: 620 case eStateAttaching: 621 case eStateLaunching: 622 case eStateStopped: 623 case eStateRunning: 624 case eStateStepping: 625 case eStateCrashed: 626 case eStateSuspended: 627 Destroy(false); 628 break; 629 630 case eStateInvalid: 631 case eStateUnloaded: 632 case eStateDetached: 633 case eStateExited: 634 break; 635 } 636 637 // Clear our broadcaster before we proceed with destroying 638 Broadcaster::Clear(); 639 640 // Do any cleanup needed prior to being destructed... Subclasses that 641 // override this method should call this superclass method as well. 642 643 // We need to destroy the loader before the derived Process class gets 644 // destroyed since it is very likely that undoing the loader will require 645 // access to the real process. 646 m_dynamic_checkers_up.reset(); 647 m_abi_sp.reset(); 648 m_os_up.reset(); 649 m_system_runtime_up.reset(); 650 m_dyld_up.reset(); 651 m_jit_loaders_up.reset(); 652 m_thread_list_real.Destroy(); 653 m_thread_list.Destroy(); 654 m_extended_thread_list.Destroy(); 655 m_queue_list.Clear(); 656 m_queue_list_stop_id = 0; 657 std::vector<Notifications> empty_notifications; 658 m_notifications.swap(empty_notifications); 659 m_image_tokens.clear(); 660 m_memory_cache.Clear(); 661 m_allocated_memory_cache.Clear(); 662 { 663 std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex); 664 m_language_runtimes.clear(); 665 } 666 m_instrumentation_runtimes.clear(); 667 m_next_event_action_up.reset(); 668 // Clear the last natural stop ID since it has a strong reference to this 669 // process 670 m_mod_id.SetStopEventForLastNaturalStopID(EventSP()); 671 //#ifdef LLDB_CONFIGURATION_DEBUG 672 // StreamFile s(stdout, false); 673 // EventSP event_sp; 674 // while (m_private_state_listener_sp->GetNextEvent(event_sp)) 675 // { 676 // event_sp->Dump (&s); 677 // s.EOL(); 678 // } 679 //#endif 680 // We have to be very careful here as the m_private_state_listener might 681 // contain events that have ProcessSP values in them which can keep this 682 // process around forever. These events need to be cleared out. 683 m_private_state_listener_sp->Clear(); 684 m_public_run_lock.TrySetRunning(); // This will do nothing if already locked 685 m_public_run_lock.SetStopped(); 686 m_private_run_lock.TrySetRunning(); // This will do nothing if already locked 687 m_private_run_lock.SetStopped(); 688 m_structured_data_plugin_map.clear(); 689 m_finalize_called = true; 690 } 691 692 void Process::RegisterNotificationCallbacks(const Notifications &callbacks) { 693 m_notifications.push_back(callbacks); 694 if (callbacks.initialize != nullptr) 695 callbacks.initialize(callbacks.baton, this); 696 } 697 698 bool Process::UnregisterNotificationCallbacks(const Notifications &callbacks) { 699 std::vector<Notifications>::iterator pos, end = m_notifications.end(); 700 for (pos = m_notifications.begin(); pos != end; ++pos) { 701 if (pos->baton == callbacks.baton && 702 pos->initialize == callbacks.initialize && 703 pos->process_state_changed == callbacks.process_state_changed) { 704 m_notifications.erase(pos); 705 return true; 706 } 707 } 708 return false; 709 } 710 711 void Process::SynchronouslyNotifyStateChanged(StateType state) { 712 std::vector<Notifications>::iterator notification_pos, 713 notification_end = m_notifications.end(); 714 for (notification_pos = m_notifications.begin(); 715 notification_pos != notification_end; ++notification_pos) { 716 if (notification_pos->process_state_changed) 717 notification_pos->process_state_changed(notification_pos->baton, this, 718 state); 719 } 720 } 721 722 // FIXME: We need to do some work on events before the general Listener sees 723 // them. 724 // For instance if we are continuing from a breakpoint, we need to ensure that 725 // we do the little "insert real insn, step & stop" trick. But we can't do 726 // that when the event is delivered by the broadcaster - since that is done on 727 // the thread that is waiting for new events, so if we needed more than one 728 // event for our handling, we would stall. So instead we do it when we fetch 729 // the event off of the queue. 730 // 731 732 StateType Process::GetNextEvent(EventSP &event_sp) { 733 StateType state = eStateInvalid; 734 735 if (m_listener_sp->GetEventForBroadcaster(this, event_sp, 736 std::chrono::seconds(0)) && 737 event_sp) 738 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 739 740 return state; 741 } 742 743 void Process::SyncIOHandler(uint32_t iohandler_id, 744 const Timeout<std::micro> &timeout) { 745 // don't sync (potentially context switch) in case where there is no process 746 // IO 747 if (!m_process_input_reader) 748 return; 749 750 auto Result = m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id, timeout); 751 752 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 753 if (Result) { 754 LLDB_LOG( 755 log, 756 "waited from m_iohandler_sync to change from {0}. New value is {1}.", 757 iohandler_id, *Result); 758 } else { 759 LLDB_LOG(log, "timed out waiting for m_iohandler_sync to change from {0}.", 760 iohandler_id); 761 } 762 } 763 764 StateType Process::WaitForProcessToStop(const Timeout<std::micro> &timeout, 765 EventSP *event_sp_ptr, bool wait_always, 766 ListenerSP hijack_listener_sp, 767 Stream *stream, bool use_run_lock) { 768 // We can't just wait for a "stopped" event, because the stopped event may 769 // have restarted the target. We have to actually check each event, and in 770 // the case of a stopped event check the restarted flag on the event. 771 if (event_sp_ptr) 772 event_sp_ptr->reset(); 773 StateType state = GetState(); 774 // If we are exited or detached, we won't ever get back to any other valid 775 // state... 776 if (state == eStateDetached || state == eStateExited) 777 return state; 778 779 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 780 LLDB_LOG(log, "timeout = {0}", timeout); 781 782 if (!wait_always && StateIsStoppedState(state, true) && 783 StateIsStoppedState(GetPrivateState(), true)) { 784 if (log) 785 log->Printf("Process::%s returning without waiting for events; process " 786 "private and public states are already 'stopped'.", 787 __FUNCTION__); 788 // We need to toggle the run lock as this won't get done in 789 // SetPublicState() if the process is hijacked. 790 if (hijack_listener_sp && use_run_lock) 791 m_public_run_lock.SetStopped(); 792 return state; 793 } 794 795 while (state != eStateInvalid) { 796 EventSP event_sp; 797 state = GetStateChangedEvents(event_sp, timeout, hijack_listener_sp); 798 if (event_sp_ptr && event_sp) 799 *event_sp_ptr = event_sp; 800 801 bool pop_process_io_handler = (hijack_listener_sp.get() != nullptr); 802 Process::HandleProcessStateChangedEvent(event_sp, stream, 803 pop_process_io_handler); 804 805 switch (state) { 806 case eStateCrashed: 807 case eStateDetached: 808 case eStateExited: 809 case eStateUnloaded: 810 // We need to toggle the run lock as this won't get done in 811 // SetPublicState() if the process is hijacked. 812 if (hijack_listener_sp && use_run_lock) 813 m_public_run_lock.SetStopped(); 814 return state; 815 case eStateStopped: 816 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) 817 continue; 818 else { 819 // We need to toggle the run lock as this won't get done in 820 // SetPublicState() if the process is hijacked. 821 if (hijack_listener_sp && use_run_lock) 822 m_public_run_lock.SetStopped(); 823 return state; 824 } 825 default: 826 continue; 827 } 828 } 829 return state; 830 } 831 832 bool Process::HandleProcessStateChangedEvent(const EventSP &event_sp, 833 Stream *stream, 834 bool &pop_process_io_handler) { 835 const bool handle_pop = pop_process_io_handler; 836 837 pop_process_io_handler = false; 838 ProcessSP process_sp = 839 Process::ProcessEventData::GetProcessFromEvent(event_sp.get()); 840 841 if (!process_sp) 842 return false; 843 844 StateType event_state = 845 Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 846 if (event_state == eStateInvalid) 847 return false; 848 849 switch (event_state) { 850 case eStateInvalid: 851 case eStateUnloaded: 852 case eStateAttaching: 853 case eStateLaunching: 854 case eStateStepping: 855 case eStateDetached: 856 if (stream) 857 stream->Printf("Process %" PRIu64 " %s\n", process_sp->GetID(), 858 StateAsCString(event_state)); 859 if (event_state == eStateDetached) 860 pop_process_io_handler = true; 861 break; 862 863 case eStateConnected: 864 case eStateRunning: 865 // Don't be chatty when we run... 866 break; 867 868 case eStateExited: 869 if (stream) 870 process_sp->GetStatus(*stream); 871 pop_process_io_handler = true; 872 break; 873 874 case eStateStopped: 875 case eStateCrashed: 876 case eStateSuspended: 877 // Make sure the program hasn't been auto-restarted: 878 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) { 879 if (stream) { 880 size_t num_reasons = 881 Process::ProcessEventData::GetNumRestartedReasons(event_sp.get()); 882 if (num_reasons > 0) { 883 // FIXME: Do we want to report this, or would that just be annoyingly 884 // chatty? 885 if (num_reasons == 1) { 886 const char *reason = 887 Process::ProcessEventData::GetRestartedReasonAtIndex( 888 event_sp.get(), 0); 889 stream->Printf("Process %" PRIu64 " stopped and restarted: %s\n", 890 process_sp->GetID(), 891 reason ? reason : "<UNKNOWN REASON>"); 892 } else { 893 stream->Printf("Process %" PRIu64 894 " stopped and restarted, reasons:\n", 895 process_sp->GetID()); 896 897 for (size_t i = 0; i < num_reasons; i++) { 898 const char *reason = 899 Process::ProcessEventData::GetRestartedReasonAtIndex( 900 event_sp.get(), i); 901 stream->Printf("\t%s\n", reason ? reason : "<UNKNOWN REASON>"); 902 } 903 } 904 } 905 } 906 } else { 907 StopInfoSP curr_thread_stop_info_sp; 908 // Lock the thread list so it doesn't change on us, this is the scope for 909 // the locker: 910 { 911 ThreadList &thread_list = process_sp->GetThreadList(); 912 std::lock_guard<std::recursive_mutex> guard(thread_list.GetMutex()); 913 914 ThreadSP curr_thread(thread_list.GetSelectedThread()); 915 ThreadSP thread; 916 StopReason curr_thread_stop_reason = eStopReasonInvalid; 917 if (curr_thread) { 918 curr_thread_stop_reason = curr_thread->GetStopReason(); 919 curr_thread_stop_info_sp = curr_thread->GetStopInfo(); 920 } 921 if (!curr_thread || !curr_thread->IsValid() || 922 curr_thread_stop_reason == eStopReasonInvalid || 923 curr_thread_stop_reason == eStopReasonNone) { 924 // Prefer a thread that has just completed its plan over another 925 // thread as current thread. 926 ThreadSP plan_thread; 927 ThreadSP other_thread; 928 929 const size_t num_threads = thread_list.GetSize(); 930 size_t i; 931 for (i = 0; i < num_threads; ++i) { 932 thread = thread_list.GetThreadAtIndex(i); 933 StopReason thread_stop_reason = thread->GetStopReason(); 934 switch (thread_stop_reason) { 935 case eStopReasonInvalid: 936 case eStopReasonNone: 937 break; 938 939 case eStopReasonSignal: { 940 // Don't select a signal thread if we weren't going to stop at 941 // that signal. We have to have had another reason for stopping 942 // here, and the user doesn't want to see this thread. 943 uint64_t signo = thread->GetStopInfo()->GetValue(); 944 if (process_sp->GetUnixSignals()->GetShouldStop(signo)) { 945 if (!other_thread) 946 other_thread = thread; 947 } 948 break; 949 } 950 case eStopReasonTrace: 951 case eStopReasonBreakpoint: 952 case eStopReasonWatchpoint: 953 case eStopReasonException: 954 case eStopReasonExec: 955 case eStopReasonThreadExiting: 956 case eStopReasonInstrumentation: 957 if (!other_thread) 958 other_thread = thread; 959 break; 960 case eStopReasonPlanComplete: 961 if (!plan_thread) 962 plan_thread = thread; 963 break; 964 } 965 } 966 if (plan_thread) 967 thread_list.SetSelectedThreadByID(plan_thread->GetID()); 968 else if (other_thread) 969 thread_list.SetSelectedThreadByID(other_thread->GetID()); 970 else { 971 if (curr_thread && curr_thread->IsValid()) 972 thread = curr_thread; 973 else 974 thread = thread_list.GetThreadAtIndex(0); 975 976 if (thread) 977 thread_list.SetSelectedThreadByID(thread->GetID()); 978 } 979 } 980 } 981 // Drop the ThreadList mutex by here, since GetThreadStatus below might 982 // have to run code, e.g. for Data formatters, and if we hold the 983 // ThreadList mutex, then the process is going to have a hard time 984 // restarting the process. 985 if (stream) { 986 Debugger &debugger = process_sp->GetTarget().GetDebugger(); 987 if (debugger.GetTargetList().GetSelectedTarget().get() == 988 &process_sp->GetTarget()) { 989 const bool only_threads_with_stop_reason = true; 990 const uint32_t start_frame = 0; 991 const uint32_t num_frames = 1; 992 const uint32_t num_frames_with_source = 1; 993 const bool stop_format = true; 994 process_sp->GetStatus(*stream); 995 process_sp->GetThreadStatus(*stream, only_threads_with_stop_reason, 996 start_frame, num_frames, 997 num_frames_with_source, 998 stop_format); 999 if (curr_thread_stop_info_sp) { 1000 lldb::addr_t crashing_address; 1001 ValueObjectSP valobj_sp = StopInfo::GetCrashingDereference( 1002 curr_thread_stop_info_sp, &crashing_address); 1003 if (valobj_sp) { 1004 const bool qualify_cxx_base_classes = false; 1005 1006 const ValueObject::GetExpressionPathFormat format = 1007 ValueObject::GetExpressionPathFormat:: 1008 eGetExpressionPathFormatHonorPointers; 1009 stream->PutCString("Likely cause: "); 1010 valobj_sp->GetExpressionPath(*stream, qualify_cxx_base_classes, 1011 format); 1012 stream->Printf(" accessed 0x%" PRIx64 "\n", crashing_address); 1013 } 1014 } 1015 } else { 1016 uint32_t target_idx = debugger.GetTargetList().GetIndexOfTarget( 1017 process_sp->GetTarget().shared_from_this()); 1018 if (target_idx != UINT32_MAX) 1019 stream->Printf("Target %d: (", target_idx); 1020 else 1021 stream->Printf("Target <unknown index>: ("); 1022 process_sp->GetTarget().Dump(stream, eDescriptionLevelBrief); 1023 stream->Printf(") stopped.\n"); 1024 } 1025 } 1026 1027 // Pop the process IO handler 1028 pop_process_io_handler = true; 1029 } 1030 break; 1031 } 1032 1033 if (handle_pop && pop_process_io_handler) 1034 process_sp->PopProcessIOHandler(); 1035 1036 return true; 1037 } 1038 1039 bool Process::HijackProcessEvents(ListenerSP listener_sp) { 1040 if (listener_sp) { 1041 return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged | 1042 eBroadcastBitInterrupt); 1043 } else 1044 return false; 1045 } 1046 1047 void Process::RestoreProcessEvents() { RestoreBroadcaster(); } 1048 1049 StateType Process::GetStateChangedEvents(EventSP &event_sp, 1050 const Timeout<std::micro> &timeout, 1051 ListenerSP hijack_listener_sp) { 1052 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1053 LLDB_LOG(log, "timeout = {0}, event_sp)...", timeout); 1054 1055 ListenerSP listener_sp = hijack_listener_sp; 1056 if (!listener_sp) 1057 listener_sp = m_listener_sp; 1058 1059 StateType state = eStateInvalid; 1060 if (listener_sp->GetEventForBroadcasterWithType( 1061 this, eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp, 1062 timeout)) { 1063 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged) 1064 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 1065 else 1066 LLDB_LOG(log, "got no event or was interrupted."); 1067 } 1068 1069 LLDB_LOG(log, "timeout = {0}, event_sp) => {1}", timeout, state); 1070 return state; 1071 } 1072 1073 Event *Process::PeekAtStateChangedEvents() { 1074 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1075 1076 if (log) 1077 log->Printf("Process::%s...", __FUNCTION__); 1078 1079 Event *event_ptr; 1080 event_ptr = m_listener_sp->PeekAtNextEventForBroadcasterWithType( 1081 this, eBroadcastBitStateChanged); 1082 if (log) { 1083 if (event_ptr) { 1084 log->Printf( 1085 "Process::%s (event_ptr) => %s", __FUNCTION__, 1086 StateAsCString(ProcessEventData::GetStateFromEvent(event_ptr))); 1087 } else { 1088 log->Printf("Process::%s no events found", __FUNCTION__); 1089 } 1090 } 1091 return event_ptr; 1092 } 1093 1094 StateType 1095 Process::GetStateChangedEventsPrivate(EventSP &event_sp, 1096 const Timeout<std::micro> &timeout) { 1097 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1098 LLDB_LOG(log, "timeout = {0}, event_sp)...", timeout); 1099 1100 StateType state = eStateInvalid; 1101 if (m_private_state_listener_sp->GetEventForBroadcasterWithType( 1102 &m_private_state_broadcaster, 1103 eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp, 1104 timeout)) 1105 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged) 1106 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 1107 1108 LLDB_LOG(log, "timeout = {0}, event_sp) => {1}", timeout, 1109 state == eStateInvalid ? "TIMEOUT" : StateAsCString(state)); 1110 return state; 1111 } 1112 1113 bool Process::GetEventsPrivate(EventSP &event_sp, 1114 const Timeout<std::micro> &timeout, 1115 bool control_only) { 1116 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1117 LLDB_LOG(log, "timeout = {0}, event_sp)...", timeout); 1118 1119 if (control_only) 1120 return m_private_state_listener_sp->GetEventForBroadcaster( 1121 &m_private_state_control_broadcaster, event_sp, timeout); 1122 else 1123 return m_private_state_listener_sp->GetEvent(event_sp, timeout); 1124 } 1125 1126 bool Process::IsRunning() const { 1127 return StateIsRunningState(m_public_state.GetValue()); 1128 } 1129 1130 int Process::GetExitStatus() { 1131 std::lock_guard<std::mutex> guard(m_exit_status_mutex); 1132 1133 if (m_public_state.GetValue() == eStateExited) 1134 return m_exit_status; 1135 return -1; 1136 } 1137 1138 const char *Process::GetExitDescription() { 1139 std::lock_guard<std::mutex> guard(m_exit_status_mutex); 1140 1141 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty()) 1142 return m_exit_string.c_str(); 1143 return nullptr; 1144 } 1145 1146 bool Process::SetExitStatus(int status, const char *cstr) { 1147 // Use a mutex to protect setting the exit status. 1148 std::lock_guard<std::mutex> guard(m_exit_status_mutex); 1149 1150 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE | 1151 LIBLLDB_LOG_PROCESS)); 1152 if (log) 1153 log->Printf( 1154 "Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)", 1155 status, status, cstr ? "\"" : "", cstr ? cstr : "NULL", 1156 cstr ? "\"" : ""); 1157 1158 // We were already in the exited state 1159 if (m_private_state.GetValue() == eStateExited) { 1160 if (log) 1161 log->Printf("Process::SetExitStatus () ignoring exit status because " 1162 "state was already set to eStateExited"); 1163 return false; 1164 } 1165 1166 m_exit_status = status; 1167 if (cstr) 1168 m_exit_string = cstr; 1169 else 1170 m_exit_string.clear(); 1171 1172 // Clear the last natural stop ID since it has a strong reference to this 1173 // process 1174 m_mod_id.SetStopEventForLastNaturalStopID(EventSP()); 1175 1176 SetPrivateState(eStateExited); 1177 1178 // Allow subclasses to do some cleanup 1179 DidExit(); 1180 1181 return true; 1182 } 1183 1184 bool Process::IsAlive() { 1185 switch (m_private_state.GetValue()) { 1186 case eStateConnected: 1187 case eStateAttaching: 1188 case eStateLaunching: 1189 case eStateStopped: 1190 case eStateRunning: 1191 case eStateStepping: 1192 case eStateCrashed: 1193 case eStateSuspended: 1194 return true; 1195 default: 1196 return false; 1197 } 1198 } 1199 1200 // This static callback can be used to watch for local child processes on the 1201 // current host. The child process exits, the process will be found in the 1202 // global target list (we want to be completely sure that the 1203 // lldb_private::Process doesn't go away before we can deliver the signal. 1204 bool Process::SetProcessExitStatus( 1205 lldb::pid_t pid, bool exited, 1206 int signo, // Zero for no signal 1207 int exit_status // Exit value of process if signal is zero 1208 ) { 1209 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1210 if (log) 1211 log->Printf("Process::SetProcessExitStatus (pid=%" PRIu64 1212 ", exited=%i, signal=%i, exit_status=%i)\n", 1213 pid, exited, signo, exit_status); 1214 1215 if (exited) { 1216 TargetSP target_sp(Debugger::FindTargetWithProcessID(pid)); 1217 if (target_sp) { 1218 ProcessSP process_sp(target_sp->GetProcessSP()); 1219 if (process_sp) { 1220 const char *signal_cstr = nullptr; 1221 if (signo) 1222 signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo); 1223 1224 process_sp->SetExitStatus(exit_status, signal_cstr); 1225 } 1226 } 1227 return true; 1228 } 1229 return false; 1230 } 1231 1232 void Process::UpdateThreadListIfNeeded() { 1233 const uint32_t stop_id = GetStopID(); 1234 if (m_thread_list.GetSize(false) == 0 || 1235 stop_id != m_thread_list.GetStopID()) { 1236 const StateType state = GetPrivateState(); 1237 if (StateIsStoppedState(state, true)) { 1238 std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex()); 1239 // m_thread_list does have its own mutex, but we need to hold onto the 1240 // mutex between the call to UpdateThreadList(...) and the 1241 // os->UpdateThreadList(...) so it doesn't change on us 1242 ThreadList &old_thread_list = m_thread_list; 1243 ThreadList real_thread_list(this); 1244 ThreadList new_thread_list(this); 1245 // Always update the thread list with the protocol specific thread list, 1246 // but only update if "true" is returned 1247 if (UpdateThreadList(m_thread_list_real, real_thread_list)) { 1248 // Don't call into the OperatingSystem to update the thread list if we 1249 // are shutting down, since that may call back into the SBAPI's, 1250 // requiring the API lock which is already held by whoever is shutting 1251 // us down, causing a deadlock. 1252 OperatingSystem *os = GetOperatingSystem(); 1253 if (os && !m_destroy_in_process) { 1254 // Clear any old backing threads where memory threads might have been 1255 // backed by actual threads from the lldb_private::Process subclass 1256 size_t num_old_threads = old_thread_list.GetSize(false); 1257 for (size_t i = 0; i < num_old_threads; ++i) 1258 old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread(); 1259 1260 // Turn off dynamic types to ensure we don't run any expressions. 1261 // Objective-C can run an expression to determine if a SBValue is a 1262 // dynamic type or not and we need to avoid this. OperatingSystem 1263 // plug-ins can't run expressions that require running code... 1264 1265 Target &target = GetTarget(); 1266 const lldb::DynamicValueType saved_prefer_dynamic = 1267 target.GetPreferDynamicValue(); 1268 if (saved_prefer_dynamic != lldb::eNoDynamicValues) 1269 target.SetPreferDynamicValue(lldb::eNoDynamicValues); 1270 1271 // Now let the OperatingSystem plug-in update the thread list 1272 1273 os->UpdateThreadList( 1274 old_thread_list, // Old list full of threads created by OS plug-in 1275 real_thread_list, // The actual thread list full of threads 1276 // created by each lldb_private::Process 1277 // subclass 1278 new_thread_list); // The new thread list that we will show to the 1279 // user that gets filled in 1280 1281 if (saved_prefer_dynamic != lldb::eNoDynamicValues) 1282 target.SetPreferDynamicValue(saved_prefer_dynamic); 1283 } else { 1284 // No OS plug-in, the new thread list is the same as the real thread 1285 // list 1286 new_thread_list = real_thread_list; 1287 } 1288 1289 m_thread_list_real.Update(real_thread_list); 1290 m_thread_list.Update(new_thread_list); 1291 m_thread_list.SetStopID(stop_id); 1292 1293 if (GetLastNaturalStopID() != m_extended_thread_stop_id) { 1294 // Clear any extended threads that we may have accumulated previously 1295 m_extended_thread_list.Clear(); 1296 m_extended_thread_stop_id = GetLastNaturalStopID(); 1297 1298 m_queue_list.Clear(); 1299 m_queue_list_stop_id = GetLastNaturalStopID(); 1300 } 1301 } 1302 } 1303 } 1304 } 1305 1306 void Process::UpdateQueueListIfNeeded() { 1307 if (m_system_runtime_up) { 1308 if (m_queue_list.GetSize() == 0 || 1309 m_queue_list_stop_id != GetLastNaturalStopID()) { 1310 const StateType state = GetPrivateState(); 1311 if (StateIsStoppedState(state, true)) { 1312 m_system_runtime_up->PopulateQueueList(m_queue_list); 1313 m_queue_list_stop_id = GetLastNaturalStopID(); 1314 } 1315 } 1316 } 1317 } 1318 1319 ThreadSP Process::CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context) { 1320 OperatingSystem *os = GetOperatingSystem(); 1321 if (os) 1322 return os->CreateThread(tid, context); 1323 return ThreadSP(); 1324 } 1325 1326 uint32_t Process::GetNextThreadIndexID(uint64_t thread_id) { 1327 return AssignIndexIDToThread(thread_id); 1328 } 1329 1330 bool Process::HasAssignedIndexIDToThread(uint64_t thread_id) { 1331 return (m_thread_id_to_index_id_map.find(thread_id) != 1332 m_thread_id_to_index_id_map.end()); 1333 } 1334 1335 uint32_t Process::AssignIndexIDToThread(uint64_t thread_id) { 1336 uint32_t result = 0; 1337 std::map<uint64_t, uint32_t>::iterator iterator = 1338 m_thread_id_to_index_id_map.find(thread_id); 1339 if (iterator == m_thread_id_to_index_id_map.end()) { 1340 result = ++m_thread_index_id; 1341 m_thread_id_to_index_id_map[thread_id] = result; 1342 } else { 1343 result = iterator->second; 1344 } 1345 1346 return result; 1347 } 1348 1349 StateType Process::GetState() { 1350 return m_public_state.GetValue(); 1351 } 1352 1353 void Process::SetPublicState(StateType new_state, bool restarted) { 1354 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE | 1355 LIBLLDB_LOG_PROCESS)); 1356 if (log) 1357 log->Printf("Process::SetPublicState (state = %s, restarted = %i)", 1358 StateAsCString(new_state), restarted); 1359 const StateType old_state = m_public_state.GetValue(); 1360 m_public_state.SetValue(new_state); 1361 1362 // On the transition from Run to Stopped, we unlock the writer end of the run 1363 // lock. The lock gets locked in Resume, which is the public API to tell the 1364 // program to run. 1365 if (!StateChangedIsExternallyHijacked()) { 1366 if (new_state == eStateDetached) { 1367 if (log) 1368 log->Printf( 1369 "Process::SetPublicState (%s) -- unlocking run lock for detach", 1370 StateAsCString(new_state)); 1371 m_public_run_lock.SetStopped(); 1372 } else { 1373 const bool old_state_is_stopped = StateIsStoppedState(old_state, false); 1374 const bool new_state_is_stopped = StateIsStoppedState(new_state, false); 1375 if ((old_state_is_stopped != new_state_is_stopped)) { 1376 if (new_state_is_stopped && !restarted) { 1377 if (log) 1378 log->Printf("Process::SetPublicState (%s) -- unlocking run lock", 1379 StateAsCString(new_state)); 1380 m_public_run_lock.SetStopped(); 1381 } 1382 } 1383 } 1384 } 1385 } 1386 1387 Status Process::Resume() { 1388 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE | 1389 LIBLLDB_LOG_PROCESS)); 1390 if (log) 1391 log->Printf("Process::Resume -- locking run lock"); 1392 if (!m_public_run_lock.TrySetRunning()) { 1393 Status error("Resume request failed - process still running."); 1394 if (log) 1395 log->Printf("Process::Resume: -- TrySetRunning failed, not resuming."); 1396 return error; 1397 } 1398 Status error = PrivateResume(); 1399 if (!error.Success()) { 1400 // Undo running state change 1401 m_public_run_lock.SetStopped(); 1402 } 1403 return error; 1404 } 1405 1406 static const char *g_resume_sync_name = "lldb.Process.ResumeSynchronous.hijack"; 1407 1408 Status Process::ResumeSynchronous(Stream *stream) { 1409 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE | 1410 LIBLLDB_LOG_PROCESS)); 1411 if (log) 1412 log->Printf("Process::ResumeSynchronous -- locking run lock"); 1413 if (!m_public_run_lock.TrySetRunning()) { 1414 Status error("Resume request failed - process still running."); 1415 if (log) 1416 log->Printf("Process::Resume: -- TrySetRunning failed, not resuming."); 1417 return error; 1418 } 1419 1420 ListenerSP listener_sp( 1421 Listener::MakeListener(g_resume_sync_name)); 1422 HijackProcessEvents(listener_sp); 1423 1424 Status error = PrivateResume(); 1425 if (error.Success()) { 1426 StateType state = 1427 WaitForProcessToStop(llvm::None, nullptr, true, listener_sp, stream); 1428 const bool must_be_alive = 1429 false; // eStateExited is ok, so this must be false 1430 if (!StateIsStoppedState(state, must_be_alive)) 1431 error.SetErrorStringWithFormat( 1432 "process not in stopped state after synchronous resume: %s", 1433 StateAsCString(state)); 1434 } else { 1435 // Undo running state change 1436 m_public_run_lock.SetStopped(); 1437 } 1438 1439 // Undo the hijacking of process events... 1440 RestoreProcessEvents(); 1441 1442 return error; 1443 } 1444 1445 bool Process::StateChangedIsExternallyHijacked() { 1446 if (IsHijackedForEvent(eBroadcastBitStateChanged)) { 1447 const char *hijacking_name = GetHijackingListenerName(); 1448 if (hijacking_name && 1449 strcmp(hijacking_name, g_resume_sync_name)) 1450 return true; 1451 } 1452 return false; 1453 } 1454 1455 bool Process::StateChangedIsHijackedForSynchronousResume() { 1456 if (IsHijackedForEvent(eBroadcastBitStateChanged)) { 1457 const char *hijacking_name = GetHijackingListenerName(); 1458 if (hijacking_name && 1459 strcmp(hijacking_name, g_resume_sync_name) == 0) 1460 return true; 1461 } 1462 return false; 1463 } 1464 1465 StateType Process::GetPrivateState() { return m_private_state.GetValue(); } 1466 1467 void Process::SetPrivateState(StateType new_state) { 1468 if (m_finalize_called) 1469 return; 1470 1471 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE | 1472 LIBLLDB_LOG_PROCESS)); 1473 bool state_changed = false; 1474 1475 if (log) 1476 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state)); 1477 1478 std::lock_guard<std::recursive_mutex> thread_guard(m_thread_list.GetMutex()); 1479 std::lock_guard<std::recursive_mutex> guard(m_private_state.GetMutex()); 1480 1481 const StateType old_state = m_private_state.GetValueNoLock(); 1482 state_changed = old_state != new_state; 1483 1484 const bool old_state_is_stopped = StateIsStoppedState(old_state, false); 1485 const bool new_state_is_stopped = StateIsStoppedState(new_state, false); 1486 if (old_state_is_stopped != new_state_is_stopped) { 1487 if (new_state_is_stopped) 1488 m_private_run_lock.SetStopped(); 1489 else 1490 m_private_run_lock.SetRunning(); 1491 } 1492 1493 if (state_changed) { 1494 m_private_state.SetValueNoLock(new_state); 1495 EventSP event_sp( 1496 new Event(eBroadcastBitStateChanged, 1497 new ProcessEventData(shared_from_this(), new_state))); 1498 if (StateIsStoppedState(new_state, false)) { 1499 // Note, this currently assumes that all threads in the list stop when 1500 // the process stops. In the future we will want to support a debugging 1501 // model where some threads continue to run while others are stopped. 1502 // When that happens we will either need a way for the thread list to 1503 // identify which threads are stopping or create a special thread list 1504 // containing only threads which actually stopped. 1505 // 1506 // The process plugin is responsible for managing the actual behavior of 1507 // the threads and should have stopped any threads that are going to stop 1508 // before we get here. 1509 m_thread_list.DidStop(); 1510 1511 m_mod_id.BumpStopID(); 1512 if (!m_mod_id.IsLastResumeForUserExpression()) 1513 m_mod_id.SetStopEventForLastNaturalStopID(event_sp); 1514 m_memory_cache.Clear(); 1515 if (log) 1516 log->Printf("Process::SetPrivateState (%s) stop_id = %u", 1517 StateAsCString(new_state), m_mod_id.GetStopID()); 1518 } 1519 1520 // Use our target to get a shared pointer to ourselves... 1521 if (m_finalize_called && !PrivateStateThreadIsValid()) 1522 BroadcastEvent(event_sp); 1523 else 1524 m_private_state_broadcaster.BroadcastEvent(event_sp); 1525 } else { 1526 if (log) 1527 log->Printf( 1528 "Process::SetPrivateState (%s) state didn't change. Ignoring...", 1529 StateAsCString(new_state)); 1530 } 1531 } 1532 1533 void Process::SetRunningUserExpression(bool on) { 1534 m_mod_id.SetRunningUserExpression(on); 1535 } 1536 1537 void Process::SetRunningUtilityFunction(bool on) { 1538 m_mod_id.SetRunningUtilityFunction(on); 1539 } 1540 1541 addr_t Process::GetImageInfoAddress() { return LLDB_INVALID_ADDRESS; } 1542 1543 const lldb::ABISP &Process::GetABI() { 1544 if (!m_abi_sp) 1545 m_abi_sp = ABI::FindPlugin(shared_from_this(), GetTarget().GetArchitecture()); 1546 return m_abi_sp; 1547 } 1548 1549 std::vector<LanguageRuntime *> 1550 Process::GetLanguageRuntimes(bool retry_if_null) { 1551 std::vector<LanguageRuntime *> language_runtimes; 1552 1553 if (m_finalizing) 1554 return language_runtimes; 1555 1556 std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex); 1557 // Before we pass off a copy of the language runtimes, we must make sure that 1558 // our collection is properly populated. It's possible that some of the 1559 // language runtimes were not loaded yet, either because nobody requested it 1560 // yet or the proper condition for loading wasn't yet met (e.g. libc++.so 1561 // hadn't been loaded). 1562 for (const lldb::LanguageType lang_type : Language::GetSupportedLanguages()) { 1563 if (LanguageRuntime *runtime = GetLanguageRuntime(lang_type, retry_if_null)) 1564 language_runtimes.emplace_back(runtime); 1565 } 1566 1567 return language_runtimes; 1568 } 1569 1570 LanguageRuntime *Process::GetLanguageRuntime(lldb::LanguageType language, 1571 bool retry_if_null) { 1572 if (m_finalizing) 1573 return nullptr; 1574 1575 LanguageRuntime *runtime = nullptr; 1576 1577 std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex); 1578 LanguageRuntimeCollection::iterator pos; 1579 pos = m_language_runtimes.find(language); 1580 if (pos == m_language_runtimes.end() || (retry_if_null && !pos->second)) { 1581 lldb::LanguageRuntimeSP runtime_sp( 1582 LanguageRuntime::FindPlugin(this, language)); 1583 1584 m_language_runtimes[language] = runtime_sp; 1585 runtime = runtime_sp.get(); 1586 } else 1587 runtime = pos->second.get(); 1588 1589 if (runtime) 1590 // It's possible that a language runtime can support multiple LanguageTypes, 1591 // for example, CPPLanguageRuntime will support eLanguageTypeC_plus_plus, 1592 // eLanguageTypeC_plus_plus_03, etc. Because of this, we should get the 1593 // primary language type and make sure that our runtime supports it. 1594 assert(runtime->GetLanguageType() == Language::GetPrimaryLanguage(language)); 1595 1596 return runtime; 1597 } 1598 1599 bool Process::IsPossibleDynamicValue(ValueObject &in_value) { 1600 if (m_finalizing) 1601 return false; 1602 1603 if (in_value.IsDynamic()) 1604 return false; 1605 LanguageType known_type = in_value.GetObjectRuntimeLanguage(); 1606 1607 if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC) { 1608 LanguageRuntime *runtime = GetLanguageRuntime(known_type); 1609 return runtime ? runtime->CouldHaveDynamicValue(in_value) : false; 1610 } 1611 1612 for (LanguageRuntime *runtime : GetLanguageRuntimes()) { 1613 if (runtime->CouldHaveDynamicValue(in_value)) 1614 return true; 1615 } 1616 1617 return false; 1618 } 1619 1620 void Process::SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers) { 1621 m_dynamic_checkers_up.reset(dynamic_checkers); 1622 } 1623 1624 BreakpointSiteList &Process::GetBreakpointSiteList() { 1625 return m_breakpoint_site_list; 1626 } 1627 1628 const BreakpointSiteList &Process::GetBreakpointSiteList() const { 1629 return m_breakpoint_site_list; 1630 } 1631 1632 void Process::DisableAllBreakpointSites() { 1633 m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void { 1634 // bp_site->SetEnabled(true); 1635 DisableBreakpointSite(bp_site); 1636 }); 1637 } 1638 1639 Status Process::ClearBreakpointSiteByID(lldb::user_id_t break_id) { 1640 Status error(DisableBreakpointSiteByID(break_id)); 1641 1642 if (error.Success()) 1643 m_breakpoint_site_list.Remove(break_id); 1644 1645 return error; 1646 } 1647 1648 Status Process::DisableBreakpointSiteByID(lldb::user_id_t break_id) { 1649 Status error; 1650 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID(break_id); 1651 if (bp_site_sp) { 1652 if (bp_site_sp->IsEnabled()) 1653 error = DisableBreakpointSite(bp_site_sp.get()); 1654 } else { 1655 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, 1656 break_id); 1657 } 1658 1659 return error; 1660 } 1661 1662 Status Process::EnableBreakpointSiteByID(lldb::user_id_t break_id) { 1663 Status error; 1664 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID(break_id); 1665 if (bp_site_sp) { 1666 if (!bp_site_sp->IsEnabled()) 1667 error = EnableBreakpointSite(bp_site_sp.get()); 1668 } else { 1669 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, 1670 break_id); 1671 } 1672 return error; 1673 } 1674 1675 lldb::break_id_t 1676 Process::CreateBreakpointSite(const BreakpointLocationSP &owner, 1677 bool use_hardware) { 1678 addr_t load_addr = LLDB_INVALID_ADDRESS; 1679 1680 bool show_error = true; 1681 switch (GetState()) { 1682 case eStateInvalid: 1683 case eStateUnloaded: 1684 case eStateConnected: 1685 case eStateAttaching: 1686 case eStateLaunching: 1687 case eStateDetached: 1688 case eStateExited: 1689 show_error = false; 1690 break; 1691 1692 case eStateStopped: 1693 case eStateRunning: 1694 case eStateStepping: 1695 case eStateCrashed: 1696 case eStateSuspended: 1697 show_error = IsAlive(); 1698 break; 1699 } 1700 1701 // Reset the IsIndirect flag here, in case the location changes from pointing 1702 // to a indirect symbol to a regular symbol. 1703 owner->SetIsIndirect(false); 1704 1705 if (owner->ShouldResolveIndirectFunctions()) { 1706 Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol(); 1707 if (symbol && symbol->IsIndirect()) { 1708 Status error; 1709 Address symbol_address = symbol->GetAddress(); 1710 load_addr = ResolveIndirectFunction(&symbol_address, error); 1711 if (!error.Success() && show_error) { 1712 GetTarget().GetDebugger().GetErrorFile()->Printf( 1713 "warning: failed to resolve indirect function at 0x%" PRIx64 1714 " for breakpoint %i.%i: %s\n", 1715 symbol->GetLoadAddress(&GetTarget()), 1716 owner->GetBreakpoint().GetID(), owner->GetID(), 1717 error.AsCString() ? error.AsCString() : "unknown error"); 1718 return LLDB_INVALID_BREAK_ID; 1719 } 1720 Address resolved_address(load_addr); 1721 load_addr = resolved_address.GetOpcodeLoadAddress(&GetTarget()); 1722 owner->SetIsIndirect(true); 1723 } else 1724 load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget()); 1725 } else 1726 load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget()); 1727 1728 if (load_addr != LLDB_INVALID_ADDRESS) { 1729 BreakpointSiteSP bp_site_sp; 1730 1731 // Look up this breakpoint site. If it exists, then add this new owner, 1732 // otherwise create a new breakpoint site and add it. 1733 1734 bp_site_sp = m_breakpoint_site_list.FindByAddress(load_addr); 1735 1736 if (bp_site_sp) { 1737 bp_site_sp->AddOwner(owner); 1738 owner->SetBreakpointSite(bp_site_sp); 1739 return bp_site_sp->GetID(); 1740 } else { 1741 bp_site_sp.reset(new BreakpointSite(&m_breakpoint_site_list, owner, 1742 load_addr, use_hardware)); 1743 if (bp_site_sp) { 1744 Status error = EnableBreakpointSite(bp_site_sp.get()); 1745 if (error.Success()) { 1746 owner->SetBreakpointSite(bp_site_sp); 1747 return m_breakpoint_site_list.Add(bp_site_sp); 1748 } else { 1749 if (show_error || use_hardware) { 1750 // Report error for setting breakpoint... 1751 GetTarget().GetDebugger().GetErrorFile()->Printf( 1752 "warning: failed to set breakpoint site at 0x%" PRIx64 1753 " for breakpoint %i.%i: %s\n", 1754 load_addr, owner->GetBreakpoint().GetID(), owner->GetID(), 1755 error.AsCString() ? error.AsCString() : "unknown error"); 1756 } 1757 } 1758 } 1759 } 1760 } 1761 // We failed to enable the breakpoint 1762 return LLDB_INVALID_BREAK_ID; 1763 } 1764 1765 void Process::RemoveOwnerFromBreakpointSite(lldb::user_id_t owner_id, 1766 lldb::user_id_t owner_loc_id, 1767 BreakpointSiteSP &bp_site_sp) { 1768 uint32_t num_owners = bp_site_sp->RemoveOwner(owner_id, owner_loc_id); 1769 if (num_owners == 0) { 1770 // Don't try to disable the site if we don't have a live process anymore. 1771 if (IsAlive()) 1772 DisableBreakpointSite(bp_site_sp.get()); 1773 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress()); 1774 } 1775 } 1776 1777 size_t Process::RemoveBreakpointOpcodesFromBuffer(addr_t bp_addr, size_t size, 1778 uint8_t *buf) const { 1779 size_t bytes_removed = 0; 1780 BreakpointSiteList bp_sites_in_range; 1781 1782 if (m_breakpoint_site_list.FindInRange(bp_addr, bp_addr + size, 1783 bp_sites_in_range)) { 1784 bp_sites_in_range.ForEach([bp_addr, size, 1785 buf](BreakpointSite *bp_site) -> void { 1786 if (bp_site->GetType() == BreakpointSite::eSoftware) { 1787 addr_t intersect_addr; 1788 size_t intersect_size; 1789 size_t opcode_offset; 1790 if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr, 1791 &intersect_size, &opcode_offset)) { 1792 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size); 1793 assert(bp_addr < intersect_addr + intersect_size && 1794 intersect_addr + intersect_size <= bp_addr + size); 1795 assert(opcode_offset + intersect_size <= bp_site->GetByteSize()); 1796 size_t buf_offset = intersect_addr - bp_addr; 1797 ::memcpy(buf + buf_offset, 1798 bp_site->GetSavedOpcodeBytes() + opcode_offset, 1799 intersect_size); 1800 } 1801 } 1802 }); 1803 } 1804 return bytes_removed; 1805 } 1806 1807 size_t Process::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) { 1808 PlatformSP platform_sp(GetTarget().GetPlatform()); 1809 if (platform_sp) 1810 return platform_sp->GetSoftwareBreakpointTrapOpcode(GetTarget(), bp_site); 1811 return 0; 1812 } 1813 1814 Status Process::EnableSoftwareBreakpoint(BreakpointSite *bp_site) { 1815 Status error; 1816 assert(bp_site != nullptr); 1817 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 1818 const addr_t bp_addr = bp_site->GetLoadAddress(); 1819 if (log) 1820 log->Printf( 1821 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64, 1822 bp_site->GetID(), (uint64_t)bp_addr); 1823 if (bp_site->IsEnabled()) { 1824 if (log) 1825 log->Printf( 1826 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 1827 " -- already enabled", 1828 bp_site->GetID(), (uint64_t)bp_addr); 1829 return error; 1830 } 1831 1832 if (bp_addr == LLDB_INVALID_ADDRESS) { 1833 error.SetErrorString("BreakpointSite contains an invalid load address."); 1834 return error; 1835 } 1836 // Ask the lldb::Process subclass to fill in the correct software breakpoint 1837 // trap for the breakpoint site 1838 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site); 1839 1840 if (bp_opcode_size == 0) { 1841 error.SetErrorStringWithFormat("Process::GetSoftwareBreakpointTrapOpcode() " 1842 "returned zero, unable to get breakpoint " 1843 "trap for address 0x%" PRIx64, 1844 bp_addr); 1845 } else { 1846 const uint8_t *const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes(); 1847 1848 if (bp_opcode_bytes == nullptr) { 1849 error.SetErrorString( 1850 "BreakpointSite doesn't contain a valid breakpoint trap opcode."); 1851 return error; 1852 } 1853 1854 // Save the original opcode by reading it 1855 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, 1856 error) == bp_opcode_size) { 1857 // Write a software breakpoint in place of the original opcode 1858 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == 1859 bp_opcode_size) { 1860 uint8_t verify_bp_opcode_bytes[64]; 1861 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, 1862 error) == bp_opcode_size) { 1863 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, 1864 bp_opcode_size) == 0) { 1865 bp_site->SetEnabled(true); 1866 bp_site->SetType(BreakpointSite::eSoftware); 1867 if (log) 1868 log->Printf("Process::EnableSoftwareBreakpoint (site_id = %d) " 1869 "addr = 0x%" PRIx64 " -- SUCCESS", 1870 bp_site->GetID(), (uint64_t)bp_addr); 1871 } else 1872 error.SetErrorString( 1873 "failed to verify the breakpoint trap in memory."); 1874 } else 1875 error.SetErrorString( 1876 "Unable to read memory to verify breakpoint trap."); 1877 } else 1878 error.SetErrorString("Unable to write breakpoint trap to memory."); 1879 } else 1880 error.SetErrorString("Unable to read memory at breakpoint address."); 1881 } 1882 if (log && error.Fail()) 1883 log->Printf( 1884 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 1885 " -- FAILED: %s", 1886 bp_site->GetID(), (uint64_t)bp_addr, error.AsCString()); 1887 return error; 1888 } 1889 1890 Status Process::DisableSoftwareBreakpoint(BreakpointSite *bp_site) { 1891 Status error; 1892 assert(bp_site != nullptr); 1893 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 1894 addr_t bp_addr = bp_site->GetLoadAddress(); 1895 lldb::user_id_t breakID = bp_site->GetID(); 1896 if (log) 1897 log->Printf("Process::DisableSoftwareBreakpoint (breakID = %" PRIu64 1898 ") addr = 0x%" PRIx64, 1899 breakID, (uint64_t)bp_addr); 1900 1901 if (bp_site->IsHardware()) { 1902 error.SetErrorString("Breakpoint site is a hardware breakpoint."); 1903 } else if (bp_site->IsEnabled()) { 1904 const size_t break_op_size = bp_site->GetByteSize(); 1905 const uint8_t *const break_op = bp_site->GetTrapOpcodeBytes(); 1906 if (break_op_size > 0) { 1907 // Clear a software breakpoint instruction 1908 uint8_t curr_break_op[8]; 1909 assert(break_op_size <= sizeof(curr_break_op)); 1910 bool break_op_found = false; 1911 1912 // Read the breakpoint opcode 1913 if (DoReadMemory(bp_addr, curr_break_op, break_op_size, error) == 1914 break_op_size) { 1915 bool verify = false; 1916 // Make sure the breakpoint opcode exists at this address 1917 if (::memcmp(curr_break_op, break_op, break_op_size) == 0) { 1918 break_op_found = true; 1919 // We found a valid breakpoint opcode at this address, now restore 1920 // the saved opcode. 1921 if (DoWriteMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), 1922 break_op_size, error) == break_op_size) { 1923 verify = true; 1924 } else 1925 error.SetErrorString( 1926 "Memory write failed when restoring original opcode."); 1927 } else { 1928 error.SetErrorString( 1929 "Original breakpoint trap is no longer in memory."); 1930 // Set verify to true and so we can check if the original opcode has 1931 // already been restored 1932 verify = true; 1933 } 1934 1935 if (verify) { 1936 uint8_t verify_opcode[8]; 1937 assert(break_op_size < sizeof(verify_opcode)); 1938 // Verify that our original opcode made it back to the inferior 1939 if (DoReadMemory(bp_addr, verify_opcode, break_op_size, error) == 1940 break_op_size) { 1941 // compare the memory we just read with the original opcode 1942 if (::memcmp(bp_site->GetSavedOpcodeBytes(), verify_opcode, 1943 break_op_size) == 0) { 1944 // SUCCESS 1945 bp_site->SetEnabled(false); 1946 if (log) 1947 log->Printf("Process::DisableSoftwareBreakpoint (site_id = %d) " 1948 "addr = 0x%" PRIx64 " -- SUCCESS", 1949 bp_site->GetID(), (uint64_t)bp_addr); 1950 return error; 1951 } else { 1952 if (break_op_found) 1953 error.SetErrorString("Failed to restore original opcode."); 1954 } 1955 } else 1956 error.SetErrorString("Failed to read memory to verify that " 1957 "breakpoint trap was restored."); 1958 } 1959 } else 1960 error.SetErrorString( 1961 "Unable to read memory that should contain the breakpoint trap."); 1962 } 1963 } else { 1964 if (log) 1965 log->Printf( 1966 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 1967 " -- already disabled", 1968 bp_site->GetID(), (uint64_t)bp_addr); 1969 return error; 1970 } 1971 1972 if (log) 1973 log->Printf( 1974 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 1975 " -- FAILED: %s", 1976 bp_site->GetID(), (uint64_t)bp_addr, error.AsCString()); 1977 return error; 1978 } 1979 1980 // Uncomment to verify memory caching works after making changes to caching 1981 // code 1982 //#define VERIFY_MEMORY_READS 1983 1984 size_t Process::ReadMemory(addr_t addr, void *buf, size_t size, Status &error) { 1985 error.Clear(); 1986 if (!GetDisableMemoryCache()) { 1987 #if defined(VERIFY_MEMORY_READS) 1988 // Memory caching is enabled, with debug verification 1989 1990 if (buf && size) { 1991 // Uncomment the line below to make sure memory caching is working. 1992 // I ran this through the test suite and got no assertions, so I am 1993 // pretty confident this is working well. If any changes are made to 1994 // memory caching, uncomment the line below and test your changes! 1995 1996 // Verify all memory reads by using the cache first, then redundantly 1997 // reading the same memory from the inferior and comparing to make sure 1998 // everything is exactly the same. 1999 std::string verify_buf(size, '\0'); 2000 assert(verify_buf.size() == size); 2001 const size_t cache_bytes_read = 2002 m_memory_cache.Read(this, addr, buf, size, error); 2003 Status verify_error; 2004 const size_t verify_bytes_read = 2005 ReadMemoryFromInferior(addr, const_cast<char *>(verify_buf.data()), 2006 verify_buf.size(), verify_error); 2007 assert(cache_bytes_read == verify_bytes_read); 2008 assert(memcmp(buf, verify_buf.data(), verify_buf.size()) == 0); 2009 assert(verify_error.Success() == error.Success()); 2010 return cache_bytes_read; 2011 } 2012 return 0; 2013 #else // !defined(VERIFY_MEMORY_READS) 2014 // Memory caching is enabled, without debug verification 2015 2016 return m_memory_cache.Read(addr, buf, size, error); 2017 #endif // defined (VERIFY_MEMORY_READS) 2018 } else { 2019 // Memory caching is disabled 2020 2021 return ReadMemoryFromInferior(addr, buf, size, error); 2022 } 2023 } 2024 2025 size_t Process::ReadCStringFromMemory(addr_t addr, std::string &out_str, 2026 Status &error) { 2027 char buf[256]; 2028 out_str.clear(); 2029 addr_t curr_addr = addr; 2030 while (true) { 2031 size_t length = ReadCStringFromMemory(curr_addr, buf, sizeof(buf), error); 2032 if (length == 0) 2033 break; 2034 out_str.append(buf, length); 2035 // If we got "length - 1" bytes, we didn't get the whole C string, we need 2036 // to read some more characters 2037 if (length == sizeof(buf) - 1) 2038 curr_addr += length; 2039 else 2040 break; 2041 } 2042 return out_str.size(); 2043 } 2044 2045 size_t Process::ReadStringFromMemory(addr_t addr, char *dst, size_t max_bytes, 2046 Status &error, size_t type_width) { 2047 size_t total_bytes_read = 0; 2048 if (dst && max_bytes && type_width && max_bytes >= type_width) { 2049 // Ensure a null terminator independent of the number of bytes that is 2050 // read. 2051 memset(dst, 0, max_bytes); 2052 size_t bytes_left = max_bytes - type_width; 2053 2054 const char terminator[4] = {'\0', '\0', '\0', '\0'}; 2055 assert(sizeof(terminator) >= type_width && "Attempting to validate a " 2056 "string with more than 4 bytes " 2057 "per character!"); 2058 2059 addr_t curr_addr = addr; 2060 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize(); 2061 char *curr_dst = dst; 2062 2063 error.Clear(); 2064 while (bytes_left > 0 && error.Success()) { 2065 addr_t cache_line_bytes_left = 2066 cache_line_size - (curr_addr % cache_line_size); 2067 addr_t bytes_to_read = 2068 std::min<addr_t>(bytes_left, cache_line_bytes_left); 2069 size_t bytes_read = ReadMemory(curr_addr, curr_dst, bytes_to_read, error); 2070 2071 if (bytes_read == 0) 2072 break; 2073 2074 // Search for a null terminator of correct size and alignment in 2075 // bytes_read 2076 size_t aligned_start = total_bytes_read - total_bytes_read % type_width; 2077 for (size_t i = aligned_start; 2078 i + type_width <= total_bytes_read + bytes_read; i += type_width) 2079 if (::memcmp(&dst[i], terminator, type_width) == 0) { 2080 error.Clear(); 2081 return i; 2082 } 2083 2084 total_bytes_read += bytes_read; 2085 curr_dst += bytes_read; 2086 curr_addr += bytes_read; 2087 bytes_left -= bytes_read; 2088 } 2089 } else { 2090 if (max_bytes) 2091 error.SetErrorString("invalid arguments"); 2092 } 2093 return total_bytes_read; 2094 } 2095 2096 // Deprecated in favor of ReadStringFromMemory which has wchar support and 2097 // correct code to find null terminators. 2098 size_t Process::ReadCStringFromMemory(addr_t addr, char *dst, 2099 size_t dst_max_len, 2100 Status &result_error) { 2101 size_t total_cstr_len = 0; 2102 if (dst && dst_max_len) { 2103 result_error.Clear(); 2104 // NULL out everything just to be safe 2105 memset(dst, 0, dst_max_len); 2106 Status error; 2107 addr_t curr_addr = addr; 2108 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize(); 2109 size_t bytes_left = dst_max_len - 1; 2110 char *curr_dst = dst; 2111 2112 while (bytes_left > 0) { 2113 addr_t cache_line_bytes_left = 2114 cache_line_size - (curr_addr % cache_line_size); 2115 addr_t bytes_to_read = 2116 std::min<addr_t>(bytes_left, cache_line_bytes_left); 2117 size_t bytes_read = ReadMemory(curr_addr, curr_dst, bytes_to_read, error); 2118 2119 if (bytes_read == 0) { 2120 result_error = error; 2121 dst[total_cstr_len] = '\0'; 2122 break; 2123 } 2124 const size_t len = strlen(curr_dst); 2125 2126 total_cstr_len += len; 2127 2128 if (len < bytes_to_read) 2129 break; 2130 2131 curr_dst += bytes_read; 2132 curr_addr += bytes_read; 2133 bytes_left -= bytes_read; 2134 } 2135 } else { 2136 if (dst == nullptr) 2137 result_error.SetErrorString("invalid arguments"); 2138 else 2139 result_error.Clear(); 2140 } 2141 return total_cstr_len; 2142 } 2143 2144 size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size, 2145 Status &error) { 2146 if (buf == nullptr || size == 0) 2147 return 0; 2148 2149 size_t bytes_read = 0; 2150 uint8_t *bytes = (uint8_t *)buf; 2151 2152 while (bytes_read < size) { 2153 const size_t curr_size = size - bytes_read; 2154 const size_t curr_bytes_read = 2155 DoReadMemory(addr + bytes_read, bytes + bytes_read, curr_size, error); 2156 bytes_read += curr_bytes_read; 2157 if (curr_bytes_read == curr_size || curr_bytes_read == 0) 2158 break; 2159 } 2160 2161 // Replace any software breakpoint opcodes that fall into this range back 2162 // into "buf" before we return 2163 if (bytes_read > 0) 2164 RemoveBreakpointOpcodesFromBuffer(addr, bytes_read, (uint8_t *)buf); 2165 return bytes_read; 2166 } 2167 2168 uint64_t Process::ReadUnsignedIntegerFromMemory(lldb::addr_t vm_addr, 2169 size_t integer_byte_size, 2170 uint64_t fail_value, 2171 Status &error) { 2172 Scalar scalar; 2173 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, 2174 error)) 2175 return scalar.ULongLong(fail_value); 2176 return fail_value; 2177 } 2178 2179 int64_t Process::ReadSignedIntegerFromMemory(lldb::addr_t vm_addr, 2180 size_t integer_byte_size, 2181 int64_t fail_value, 2182 Status &error) { 2183 Scalar scalar; 2184 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, true, scalar, 2185 error)) 2186 return scalar.SLongLong(fail_value); 2187 return fail_value; 2188 } 2189 2190 addr_t Process::ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error) { 2191 Scalar scalar; 2192 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, 2193 error)) 2194 return scalar.ULongLong(LLDB_INVALID_ADDRESS); 2195 return LLDB_INVALID_ADDRESS; 2196 } 2197 2198 bool Process::WritePointerToMemory(lldb::addr_t vm_addr, lldb::addr_t ptr_value, 2199 Status &error) { 2200 Scalar scalar; 2201 const uint32_t addr_byte_size = GetAddressByteSize(); 2202 if (addr_byte_size <= 4) 2203 scalar = (uint32_t)ptr_value; 2204 else 2205 scalar = ptr_value; 2206 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == 2207 addr_byte_size; 2208 } 2209 2210 size_t Process::WriteMemoryPrivate(addr_t addr, const void *buf, size_t size, 2211 Status &error) { 2212 size_t bytes_written = 0; 2213 const uint8_t *bytes = (const uint8_t *)buf; 2214 2215 while (bytes_written < size) { 2216 const size_t curr_size = size - bytes_written; 2217 const size_t curr_bytes_written = DoWriteMemory( 2218 addr + bytes_written, bytes + bytes_written, curr_size, error); 2219 bytes_written += curr_bytes_written; 2220 if (curr_bytes_written == curr_size || curr_bytes_written == 0) 2221 break; 2222 } 2223 return bytes_written; 2224 } 2225 2226 size_t Process::WriteMemory(addr_t addr, const void *buf, size_t size, 2227 Status &error) { 2228 #if defined(ENABLE_MEMORY_CACHING) 2229 m_memory_cache.Flush(addr, size); 2230 #endif 2231 2232 if (buf == nullptr || size == 0) 2233 return 0; 2234 2235 m_mod_id.BumpMemoryID(); 2236 2237 // We need to write any data that would go where any current software traps 2238 // (enabled software breakpoints) any software traps (breakpoints) that we 2239 // may have placed in our tasks memory. 2240 2241 BreakpointSiteList bp_sites_in_range; 2242 if (!m_breakpoint_site_list.FindInRange(addr, addr + size, bp_sites_in_range)) 2243 return WriteMemoryPrivate(addr, buf, size, error); 2244 2245 // No breakpoint sites overlap 2246 if (bp_sites_in_range.IsEmpty()) 2247 return WriteMemoryPrivate(addr, buf, size, error); 2248 2249 const uint8_t *ubuf = (const uint8_t *)buf; 2250 uint64_t bytes_written = 0; 2251 2252 bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, 2253 &error](BreakpointSite *bp) -> void { 2254 if (error.Fail()) 2255 return; 2256 2257 addr_t intersect_addr; 2258 size_t intersect_size; 2259 size_t opcode_offset; 2260 const bool intersects = bp->IntersectsRange( 2261 addr, size, &intersect_addr, &intersect_size, &opcode_offset); 2262 UNUSED_IF_ASSERT_DISABLED(intersects); 2263 assert(intersects); 2264 assert(addr <= intersect_addr && intersect_addr < addr + size); 2265 assert(addr < intersect_addr + intersect_size && 2266 intersect_addr + intersect_size <= addr + size); 2267 assert(opcode_offset + intersect_size <= bp->GetByteSize()); 2268 2269 // Check for bytes before this breakpoint 2270 const addr_t curr_addr = addr + bytes_written; 2271 if (intersect_addr > curr_addr) { 2272 // There are some bytes before this breakpoint that we need to just 2273 // write to memory 2274 size_t curr_size = intersect_addr - curr_addr; 2275 size_t curr_bytes_written = 2276 WriteMemoryPrivate(curr_addr, ubuf + bytes_written, curr_size, error); 2277 bytes_written += curr_bytes_written; 2278 if (curr_bytes_written != curr_size) { 2279 // We weren't able to write all of the requested bytes, we are 2280 // done looping and will return the number of bytes that we have 2281 // written so far. 2282 if (error.Success()) 2283 error.SetErrorToGenericError(); 2284 } 2285 } 2286 // Now write any bytes that would cover up any software breakpoints 2287 // directly into the breakpoint opcode buffer 2288 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, 2289 intersect_size); 2290 bytes_written += intersect_size; 2291 }); 2292 2293 // Write any remaining bytes after the last breakpoint if we have any left 2294 if (bytes_written < size) 2295 bytes_written += 2296 WriteMemoryPrivate(addr + bytes_written, ubuf + bytes_written, 2297 size - bytes_written, error); 2298 2299 return bytes_written; 2300 } 2301 2302 size_t Process::WriteScalarToMemory(addr_t addr, const Scalar &scalar, 2303 size_t byte_size, Status &error) { 2304 if (byte_size == UINT32_MAX) 2305 byte_size = scalar.GetByteSize(); 2306 if (byte_size > 0) { 2307 uint8_t buf[32]; 2308 const size_t mem_size = 2309 scalar.GetAsMemoryData(buf, byte_size, GetByteOrder(), error); 2310 if (mem_size > 0) 2311 return WriteMemory(addr, buf, mem_size, error); 2312 else 2313 error.SetErrorString("failed to get scalar as memory data"); 2314 } else { 2315 error.SetErrorString("invalid scalar value"); 2316 } 2317 return 0; 2318 } 2319 2320 size_t Process::ReadScalarIntegerFromMemory(addr_t addr, uint32_t byte_size, 2321 bool is_signed, Scalar &scalar, 2322 Status &error) { 2323 uint64_t uval = 0; 2324 if (byte_size == 0) { 2325 error.SetErrorString("byte size is zero"); 2326 } else if (byte_size & (byte_size - 1)) { 2327 error.SetErrorStringWithFormat("byte size %u is not a power of 2", 2328 byte_size); 2329 } else if (byte_size <= sizeof(uval)) { 2330 const size_t bytes_read = ReadMemory(addr, &uval, byte_size, error); 2331 if (bytes_read == byte_size) { 2332 DataExtractor data(&uval, sizeof(uval), GetByteOrder(), 2333 GetAddressByteSize()); 2334 lldb::offset_t offset = 0; 2335 if (byte_size <= 4) 2336 scalar = data.GetMaxU32(&offset, byte_size); 2337 else 2338 scalar = data.GetMaxU64(&offset, byte_size); 2339 if (is_signed) 2340 scalar.SignExtend(byte_size * 8); 2341 return bytes_read; 2342 } 2343 } else { 2344 error.SetErrorStringWithFormat( 2345 "byte size of %u is too large for integer scalar type", byte_size); 2346 } 2347 return 0; 2348 } 2349 2350 Status Process::WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) { 2351 Status error; 2352 for (const auto &Entry : entries) { 2353 WriteMemory(Entry.Dest, Entry.Contents.data(), Entry.Contents.size(), 2354 error); 2355 if (!error.Success()) 2356 break; 2357 } 2358 return error; 2359 } 2360 2361 #define USE_ALLOCATE_MEMORY_CACHE 1 2362 addr_t Process::AllocateMemory(size_t size, uint32_t permissions, 2363 Status &error) { 2364 if (GetPrivateState() != eStateStopped) { 2365 error.SetErrorToGenericError(); 2366 return LLDB_INVALID_ADDRESS; 2367 } 2368 2369 #if defined(USE_ALLOCATE_MEMORY_CACHE) 2370 return m_allocated_memory_cache.AllocateMemory(size, permissions, error); 2371 #else 2372 addr_t allocated_addr = DoAllocateMemory(size, permissions, error); 2373 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 2374 if (log) 2375 log->Printf("Process::AllocateMemory(size=%" PRIu64 2376 ", permissions=%s) => 0x%16.16" PRIx64 2377 " (m_stop_id = %u m_memory_id = %u)", 2378 (uint64_t)size, GetPermissionsAsCString(permissions), 2379 (uint64_t)allocated_addr, m_mod_id.GetStopID(), 2380 m_mod_id.GetMemoryID()); 2381 return allocated_addr; 2382 #endif 2383 } 2384 2385 addr_t Process::CallocateMemory(size_t size, uint32_t permissions, 2386 Status &error) { 2387 addr_t return_addr = AllocateMemory(size, permissions, error); 2388 if (error.Success()) { 2389 std::string buffer(size, 0); 2390 WriteMemory(return_addr, buffer.c_str(), size, error); 2391 } 2392 return return_addr; 2393 } 2394 2395 bool Process::CanJIT() { 2396 if (m_can_jit == eCanJITDontKnow) { 2397 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 2398 Status err; 2399 2400 uint64_t allocated_memory = AllocateMemory( 2401 8, ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable, 2402 err); 2403 2404 if (err.Success()) { 2405 m_can_jit = eCanJITYes; 2406 if (log) 2407 log->Printf("Process::%s pid %" PRIu64 2408 " allocation test passed, CanJIT () is true", 2409 __FUNCTION__, GetID()); 2410 } else { 2411 m_can_jit = eCanJITNo; 2412 if (log) 2413 log->Printf("Process::%s pid %" PRIu64 2414 " allocation test failed, CanJIT () is false: %s", 2415 __FUNCTION__, GetID(), err.AsCString()); 2416 } 2417 2418 DeallocateMemory(allocated_memory); 2419 } 2420 2421 return m_can_jit == eCanJITYes; 2422 } 2423 2424 void Process::SetCanJIT(bool can_jit) { 2425 m_can_jit = (can_jit ? eCanJITYes : eCanJITNo); 2426 } 2427 2428 void Process::SetCanRunCode(bool can_run_code) { 2429 SetCanJIT(can_run_code); 2430 m_can_interpret_function_calls = can_run_code; 2431 } 2432 2433 Status Process::DeallocateMemory(addr_t ptr) { 2434 Status error; 2435 #if defined(USE_ALLOCATE_MEMORY_CACHE) 2436 if (!m_allocated_memory_cache.DeallocateMemory(ptr)) { 2437 error.SetErrorStringWithFormat( 2438 "deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr); 2439 } 2440 #else 2441 error = DoDeallocateMemory(ptr); 2442 2443 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 2444 if (log) 2445 log->Printf("Process::DeallocateMemory(addr=0x%16.16" PRIx64 2446 ") => err = %s (m_stop_id = %u, m_memory_id = %u)", 2447 ptr, error.AsCString("SUCCESS"), m_mod_id.GetStopID(), 2448 m_mod_id.GetMemoryID()); 2449 #endif 2450 return error; 2451 } 2452 2453 ModuleSP Process::ReadModuleFromMemory(const FileSpec &file_spec, 2454 lldb::addr_t header_addr, 2455 size_t size_to_read) { 2456 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); 2457 if (log) { 2458 log->Printf("Process::ReadModuleFromMemory reading %s binary from memory", 2459 file_spec.GetPath().c_str()); 2460 } 2461 ModuleSP module_sp(new Module(file_spec, ArchSpec())); 2462 if (module_sp) { 2463 Status error; 2464 ObjectFile *objfile = module_sp->GetMemoryObjectFile( 2465 shared_from_this(), header_addr, error, size_to_read); 2466 if (objfile) 2467 return module_sp; 2468 } 2469 return ModuleSP(); 2470 } 2471 2472 bool Process::GetLoadAddressPermissions(lldb::addr_t load_addr, 2473 uint32_t &permissions) { 2474 MemoryRegionInfo range_info; 2475 permissions = 0; 2476 Status error(GetMemoryRegionInfo(load_addr, range_info)); 2477 if (!error.Success()) 2478 return false; 2479 if (range_info.GetReadable() == MemoryRegionInfo::eDontKnow || 2480 range_info.GetWritable() == MemoryRegionInfo::eDontKnow || 2481 range_info.GetExecutable() == MemoryRegionInfo::eDontKnow) { 2482 return false; 2483 } 2484 2485 if (range_info.GetReadable() == MemoryRegionInfo::eYes) 2486 permissions |= lldb::ePermissionsReadable; 2487 2488 if (range_info.GetWritable() == MemoryRegionInfo::eYes) 2489 permissions |= lldb::ePermissionsWritable; 2490 2491 if (range_info.GetExecutable() == MemoryRegionInfo::eYes) 2492 permissions |= lldb::ePermissionsExecutable; 2493 2494 return true; 2495 } 2496 2497 Status Process::EnableWatchpoint(Watchpoint *watchpoint, bool notify) { 2498 Status error; 2499 error.SetErrorString("watchpoints are not supported"); 2500 return error; 2501 } 2502 2503 Status Process::DisableWatchpoint(Watchpoint *watchpoint, bool notify) { 2504 Status error; 2505 error.SetErrorString("watchpoints are not supported"); 2506 return error; 2507 } 2508 2509 StateType 2510 Process::WaitForProcessStopPrivate(EventSP &event_sp, 2511 const Timeout<std::micro> &timeout) { 2512 StateType state; 2513 2514 while (true) { 2515 event_sp.reset(); 2516 state = GetStateChangedEventsPrivate(event_sp, timeout); 2517 2518 if (StateIsStoppedState(state, false)) 2519 break; 2520 2521 // If state is invalid, then we timed out 2522 if (state == eStateInvalid) 2523 break; 2524 2525 if (event_sp) 2526 HandlePrivateEvent(event_sp); 2527 } 2528 return state; 2529 } 2530 2531 void Process::LoadOperatingSystemPlugin(bool flush) { 2532 if (flush) 2533 m_thread_list.Clear(); 2534 m_os_up.reset(OperatingSystem::FindPlugin(this, nullptr)); 2535 if (flush) 2536 Flush(); 2537 } 2538 2539 Status Process::Launch(ProcessLaunchInfo &launch_info) { 2540 Status error; 2541 m_abi_sp.reset(); 2542 m_dyld_up.reset(); 2543 m_jit_loaders_up.reset(); 2544 m_system_runtime_up.reset(); 2545 m_os_up.reset(); 2546 m_process_input_reader.reset(); 2547 2548 Module *exe_module = GetTarget().GetExecutableModulePointer(); 2549 if (!exe_module) { 2550 error.SetErrorString("executable module does not exist"); 2551 return error; 2552 } 2553 2554 char local_exec_file_path[PATH_MAX]; 2555 char platform_exec_file_path[PATH_MAX]; 2556 exe_module->GetFileSpec().GetPath(local_exec_file_path, 2557 sizeof(local_exec_file_path)); 2558 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, 2559 sizeof(platform_exec_file_path)); 2560 if (FileSystem::Instance().Exists(exe_module->GetFileSpec())) { 2561 // Install anything that might need to be installed prior to launching. 2562 // For host systems, this will do nothing, but if we are connected to a 2563 // remote platform it will install any needed binaries 2564 error = GetTarget().Install(&launch_info); 2565 if (error.Fail()) 2566 return error; 2567 2568 if (PrivateStateThreadIsValid()) 2569 PausePrivateStateThread(); 2570 2571 error = WillLaunch(exe_module); 2572 if (error.Success()) { 2573 const bool restarted = false; 2574 SetPublicState(eStateLaunching, restarted); 2575 m_should_detach = false; 2576 2577 if (m_public_run_lock.TrySetRunning()) { 2578 // Now launch using these arguments. 2579 error = DoLaunch(exe_module, launch_info); 2580 } else { 2581 // This shouldn't happen 2582 error.SetErrorString("failed to acquire process run lock"); 2583 } 2584 2585 if (error.Fail()) { 2586 if (GetID() != LLDB_INVALID_PROCESS_ID) { 2587 SetID(LLDB_INVALID_PROCESS_ID); 2588 const char *error_string = error.AsCString(); 2589 if (error_string == nullptr) 2590 error_string = "launch failed"; 2591 SetExitStatus(-1, error_string); 2592 } 2593 } else { 2594 EventSP event_sp; 2595 2596 // Now wait for the process to launch and return control to us, and then 2597 // call DidLaunch: 2598 StateType state = WaitForProcessStopPrivate(event_sp, seconds(10)); 2599 2600 if (state == eStateInvalid || !event_sp) { 2601 // We were able to launch the process, but we failed to catch the 2602 // initial stop. 2603 error.SetErrorString("failed to catch stop after launch"); 2604 SetExitStatus(0, "failed to catch stop after launch"); 2605 Destroy(false); 2606 } else if (state == eStateStopped || state == eStateCrashed) { 2607 DidLaunch(); 2608 2609 DynamicLoader *dyld = GetDynamicLoader(); 2610 if (dyld) 2611 dyld->DidLaunch(); 2612 2613 GetJITLoaders().DidLaunch(); 2614 2615 SystemRuntime *system_runtime = GetSystemRuntime(); 2616 if (system_runtime) 2617 system_runtime->DidLaunch(); 2618 2619 if (!m_os_up) 2620 LoadOperatingSystemPlugin(false); 2621 2622 // We successfully launched the process and stopped, now it the 2623 // right time to set up signal filters before resuming. 2624 UpdateAutomaticSignalFiltering(); 2625 2626 // Note, the stop event was consumed above, but not handled. This 2627 // was done to give DidLaunch a chance to run. The target is either 2628 // stopped or crashed. Directly set the state. This is done to 2629 // prevent a stop message with a bunch of spurious output on thread 2630 // status, as well as not pop a ProcessIOHandler. 2631 SetPublicState(state, false); 2632 2633 if (PrivateStateThreadIsValid()) 2634 ResumePrivateStateThread(); 2635 else 2636 StartPrivateStateThread(); 2637 2638 // Target was stopped at entry as was intended. Need to notify the 2639 // listeners about it. 2640 if (state == eStateStopped && 2641 launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) 2642 HandlePrivateEvent(event_sp); 2643 } else if (state == eStateExited) { 2644 // We exited while trying to launch somehow. Don't call DidLaunch 2645 // as that's not likely to work, and return an invalid pid. 2646 HandlePrivateEvent(event_sp); 2647 } 2648 } 2649 } 2650 } else { 2651 error.SetErrorStringWithFormat("file doesn't exist: '%s'", 2652 local_exec_file_path); 2653 } 2654 2655 return error; 2656 } 2657 2658 Status Process::LoadCore() { 2659 Status error = DoLoadCore(); 2660 if (error.Success()) { 2661 ListenerSP listener_sp( 2662 Listener::MakeListener("lldb.process.load_core_listener")); 2663 HijackProcessEvents(listener_sp); 2664 2665 if (PrivateStateThreadIsValid()) 2666 ResumePrivateStateThread(); 2667 else 2668 StartPrivateStateThread(); 2669 2670 DynamicLoader *dyld = GetDynamicLoader(); 2671 if (dyld) 2672 dyld->DidAttach(); 2673 2674 GetJITLoaders().DidAttach(); 2675 2676 SystemRuntime *system_runtime = GetSystemRuntime(); 2677 if (system_runtime) 2678 system_runtime->DidAttach(); 2679 2680 if (!m_os_up) 2681 LoadOperatingSystemPlugin(false); 2682 2683 // We successfully loaded a core file, now pretend we stopped so we can 2684 // show all of the threads in the core file and explore the crashed state. 2685 SetPrivateState(eStateStopped); 2686 2687 // Wait for a stopped event since we just posted one above... 2688 lldb::EventSP event_sp; 2689 StateType state = 2690 WaitForProcessToStop(llvm::None, &event_sp, true, listener_sp); 2691 2692 if (!StateIsStoppedState(state, false)) { 2693 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 2694 if (log) 2695 log->Printf("Process::Halt() failed to stop, state is: %s", 2696 StateAsCString(state)); 2697 error.SetErrorString( 2698 "Did not get stopped event after loading the core file."); 2699 } 2700 RestoreProcessEvents(); 2701 } 2702 return error; 2703 } 2704 2705 DynamicLoader *Process::GetDynamicLoader() { 2706 if (!m_dyld_up) 2707 m_dyld_up.reset(DynamicLoader::FindPlugin(this, nullptr)); 2708 return m_dyld_up.get(); 2709 } 2710 2711 DataExtractor Process::GetAuxvData() { return DataExtractor(); } 2712 2713 JITLoaderList &Process::GetJITLoaders() { 2714 if (!m_jit_loaders_up) { 2715 m_jit_loaders_up.reset(new JITLoaderList()); 2716 JITLoader::LoadPlugins(this, *m_jit_loaders_up); 2717 } 2718 return *m_jit_loaders_up; 2719 } 2720 2721 SystemRuntime *Process::GetSystemRuntime() { 2722 if (!m_system_runtime_up) 2723 m_system_runtime_up.reset(SystemRuntime::FindPlugin(this)); 2724 return m_system_runtime_up.get(); 2725 } 2726 2727 Process::AttachCompletionHandler::AttachCompletionHandler(Process *process, 2728 uint32_t exec_count) 2729 : NextEventAction(process), m_exec_count(exec_count) { 2730 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 2731 if (log) 2732 log->Printf( 2733 "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32, 2734 __FUNCTION__, static_cast<void *>(process), exec_count); 2735 } 2736 2737 Process::NextEventAction::EventActionResult 2738 Process::AttachCompletionHandler::PerformAction(lldb::EventSP &event_sp) { 2739 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 2740 2741 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get()); 2742 if (log) 2743 log->Printf( 2744 "Process::AttachCompletionHandler::%s called with state %s (%d)", 2745 __FUNCTION__, StateAsCString(state), static_cast<int>(state)); 2746 2747 switch (state) { 2748 case eStateAttaching: 2749 return eEventActionSuccess; 2750 2751 case eStateRunning: 2752 case eStateConnected: 2753 return eEventActionRetry; 2754 2755 case eStateStopped: 2756 case eStateCrashed: 2757 // During attach, prior to sending the eStateStopped event, 2758 // lldb_private::Process subclasses must set the new process ID. 2759 assert(m_process->GetID() != LLDB_INVALID_PROCESS_ID); 2760 // We don't want these events to be reported, so go set the 2761 // ShouldReportStop here: 2762 m_process->GetThreadList().SetShouldReportStop(eVoteNo); 2763 2764 if (m_exec_count > 0) { 2765 --m_exec_count; 2766 2767 if (log) 2768 log->Printf("Process::AttachCompletionHandler::%s state %s: reduced " 2769 "remaining exec count to %" PRIu32 ", requesting resume", 2770 __FUNCTION__, StateAsCString(state), m_exec_count); 2771 2772 RequestResume(); 2773 return eEventActionRetry; 2774 } else { 2775 if (log) 2776 log->Printf("Process::AttachCompletionHandler::%s state %s: no more " 2777 "execs expected to start, continuing with attach", 2778 __FUNCTION__, StateAsCString(state)); 2779 2780 m_process->CompleteAttach(); 2781 return eEventActionSuccess; 2782 } 2783 break; 2784 2785 default: 2786 case eStateExited: 2787 case eStateInvalid: 2788 break; 2789 } 2790 2791 m_exit_string.assign("No valid Process"); 2792 return eEventActionExit; 2793 } 2794 2795 Process::NextEventAction::EventActionResult 2796 Process::AttachCompletionHandler::HandleBeingInterrupted() { 2797 return eEventActionSuccess; 2798 } 2799 2800 const char *Process::AttachCompletionHandler::GetExitString() { 2801 return m_exit_string.c_str(); 2802 } 2803 2804 ListenerSP ProcessAttachInfo::GetListenerForProcess(Debugger &debugger) { 2805 if (m_listener_sp) 2806 return m_listener_sp; 2807 else 2808 return debugger.GetListener(); 2809 } 2810 2811 Status Process::Attach(ProcessAttachInfo &attach_info) { 2812 m_abi_sp.reset(); 2813 m_process_input_reader.reset(); 2814 m_dyld_up.reset(); 2815 m_jit_loaders_up.reset(); 2816 m_system_runtime_up.reset(); 2817 m_os_up.reset(); 2818 2819 lldb::pid_t attach_pid = attach_info.GetProcessID(); 2820 Status error; 2821 if (attach_pid == LLDB_INVALID_PROCESS_ID) { 2822 char process_name[PATH_MAX]; 2823 2824 if (attach_info.GetExecutableFile().GetPath(process_name, 2825 sizeof(process_name))) { 2826 const bool wait_for_launch = attach_info.GetWaitForLaunch(); 2827 2828 if (wait_for_launch) { 2829 error = WillAttachToProcessWithName(process_name, wait_for_launch); 2830 if (error.Success()) { 2831 if (m_public_run_lock.TrySetRunning()) { 2832 m_should_detach = true; 2833 const bool restarted = false; 2834 SetPublicState(eStateAttaching, restarted); 2835 // Now attach using these arguments. 2836 error = DoAttachToProcessWithName(process_name, attach_info); 2837 } else { 2838 // This shouldn't happen 2839 error.SetErrorString("failed to acquire process run lock"); 2840 } 2841 2842 if (error.Fail()) { 2843 if (GetID() != LLDB_INVALID_PROCESS_ID) { 2844 SetID(LLDB_INVALID_PROCESS_ID); 2845 if (error.AsCString() == nullptr) 2846 error.SetErrorString("attach failed"); 2847 2848 SetExitStatus(-1, error.AsCString()); 2849 } 2850 } else { 2851 SetNextEventAction(new Process::AttachCompletionHandler( 2852 this, attach_info.GetResumeCount())); 2853 StartPrivateStateThread(); 2854 } 2855 return error; 2856 } 2857 } else { 2858 ProcessInstanceInfoList process_infos; 2859 PlatformSP platform_sp(GetTarget().GetPlatform()); 2860 2861 if (platform_sp) { 2862 ProcessInstanceInfoMatch match_info; 2863 match_info.GetProcessInfo() = attach_info; 2864 match_info.SetNameMatchType(NameMatch::Equals); 2865 platform_sp->FindProcesses(match_info, process_infos); 2866 const uint32_t num_matches = process_infos.GetSize(); 2867 if (num_matches == 1) { 2868 attach_pid = process_infos.GetProcessIDAtIndex(0); 2869 // Fall through and attach using the above process ID 2870 } else { 2871 match_info.GetProcessInfo().GetExecutableFile().GetPath( 2872 process_name, sizeof(process_name)); 2873 if (num_matches > 1) { 2874 StreamString s; 2875 ProcessInstanceInfo::DumpTableHeader(s, true, false); 2876 for (size_t i = 0; i < num_matches; i++) { 2877 process_infos.GetProcessInfoAtIndex(i).DumpAsTableRow( 2878 s, platform_sp->GetUserIDResolver(), true, false); 2879 } 2880 error.SetErrorStringWithFormat( 2881 "more than one process named %s:\n%s", process_name, 2882 s.GetData()); 2883 } else 2884 error.SetErrorStringWithFormat( 2885 "could not find a process named %s", process_name); 2886 } 2887 } else { 2888 error.SetErrorString( 2889 "invalid platform, can't find processes by name"); 2890 return error; 2891 } 2892 } 2893 } else { 2894 error.SetErrorString("invalid process name"); 2895 } 2896 } 2897 2898 if (attach_pid != LLDB_INVALID_PROCESS_ID) { 2899 error = WillAttachToProcessWithID(attach_pid); 2900 if (error.Success()) { 2901 2902 if (m_public_run_lock.TrySetRunning()) { 2903 // Now attach using these arguments. 2904 m_should_detach = true; 2905 const bool restarted = false; 2906 SetPublicState(eStateAttaching, restarted); 2907 error = DoAttachToProcessWithID(attach_pid, attach_info); 2908 } else { 2909 // This shouldn't happen 2910 error.SetErrorString("failed to acquire process run lock"); 2911 } 2912 2913 if (error.Success()) { 2914 SetNextEventAction(new Process::AttachCompletionHandler( 2915 this, attach_info.GetResumeCount())); 2916 StartPrivateStateThread(); 2917 } else { 2918 if (GetID() != LLDB_INVALID_PROCESS_ID) 2919 SetID(LLDB_INVALID_PROCESS_ID); 2920 2921 const char *error_string = error.AsCString(); 2922 if (error_string == nullptr) 2923 error_string = "attach failed"; 2924 2925 SetExitStatus(-1, error_string); 2926 } 2927 } 2928 } 2929 return error; 2930 } 2931 2932 void Process::CompleteAttach() { 2933 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | 2934 LIBLLDB_LOG_TARGET)); 2935 if (log) 2936 log->Printf("Process::%s()", __FUNCTION__); 2937 2938 // Let the process subclass figure out at much as it can about the process 2939 // before we go looking for a dynamic loader plug-in. 2940 ArchSpec process_arch; 2941 DidAttach(process_arch); 2942 2943 if (process_arch.IsValid()) { 2944 GetTarget().SetArchitecture(process_arch); 2945 if (log) { 2946 const char *triple_str = process_arch.GetTriple().getTriple().c_str(); 2947 log->Printf("Process::%s replacing process architecture with DidAttach() " 2948 "architecture: %s", 2949 __FUNCTION__, triple_str ? triple_str : "<null>"); 2950 } 2951 } 2952 2953 // We just attached. If we have a platform, ask it for the process 2954 // architecture, and if it isn't the same as the one we've already set, 2955 // switch architectures. 2956 PlatformSP platform_sp(GetTarget().GetPlatform()); 2957 assert(platform_sp); 2958 if (platform_sp) { 2959 const ArchSpec &target_arch = GetTarget().GetArchitecture(); 2960 if (target_arch.IsValid() && 2961 !platform_sp->IsCompatibleArchitecture(target_arch, false, nullptr)) { 2962 ArchSpec platform_arch; 2963 platform_sp = 2964 platform_sp->GetPlatformForArchitecture(target_arch, &platform_arch); 2965 if (platform_sp) { 2966 GetTarget().SetPlatform(platform_sp); 2967 GetTarget().SetArchitecture(platform_arch); 2968 if (log) 2969 log->Printf("Process::%s switching platform to %s and architecture " 2970 "to %s based on info from attach", 2971 __FUNCTION__, platform_sp->GetName().AsCString(""), 2972 platform_arch.GetTriple().getTriple().c_str()); 2973 } 2974 } else if (!process_arch.IsValid()) { 2975 ProcessInstanceInfo process_info; 2976 GetProcessInfo(process_info); 2977 const ArchSpec &process_arch = process_info.GetArchitecture(); 2978 if (process_arch.IsValid() && 2979 !GetTarget().GetArchitecture().IsExactMatch(process_arch)) { 2980 GetTarget().SetArchitecture(process_arch); 2981 if (log) 2982 log->Printf("Process::%s switching architecture to %s based on info " 2983 "the platform retrieved for pid %" PRIu64, 2984 __FUNCTION__, 2985 process_arch.GetTriple().getTriple().c_str(), GetID()); 2986 } 2987 } 2988 } 2989 2990 // We have completed the attach, now it is time to find the dynamic loader 2991 // plug-in 2992 DynamicLoader *dyld = GetDynamicLoader(); 2993 if (dyld) { 2994 dyld->DidAttach(); 2995 if (log) { 2996 ModuleSP exe_module_sp = GetTarget().GetExecutableModule(); 2997 log->Printf("Process::%s after DynamicLoader::DidAttach(), target " 2998 "executable is %s (using %s plugin)", 2999 __FUNCTION__, 3000 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str() 3001 : "<none>", 3002 dyld->GetPluginName().AsCString("<unnamed>")); 3003 } 3004 } 3005 3006 GetJITLoaders().DidAttach(); 3007 3008 SystemRuntime *system_runtime = GetSystemRuntime(); 3009 if (system_runtime) { 3010 system_runtime->DidAttach(); 3011 if (log) { 3012 ModuleSP exe_module_sp = GetTarget().GetExecutableModule(); 3013 log->Printf("Process::%s after SystemRuntime::DidAttach(), target " 3014 "executable is %s (using %s plugin)", 3015 __FUNCTION__, 3016 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str() 3017 : "<none>", 3018 system_runtime->GetPluginName().AsCString("<unnamed>")); 3019 } 3020 } 3021 3022 if (!m_os_up) { 3023 LoadOperatingSystemPlugin(false); 3024 if (m_os_up) { 3025 // Somebody might have gotten threads before now, but we need to force the 3026 // update after we've loaded the OperatingSystem plugin or it won't get a 3027 // chance to process the threads. 3028 m_thread_list.Clear(); 3029 UpdateThreadListIfNeeded(); 3030 } 3031 } 3032 // Figure out which one is the executable, and set that in our target: 3033 const ModuleList &target_modules = GetTarget().GetImages(); 3034 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); 3035 size_t num_modules = target_modules.GetSize(); 3036 ModuleSP new_executable_module_sp; 3037 3038 for (size_t i = 0; i < num_modules; i++) { 3039 ModuleSP module_sp(target_modules.GetModuleAtIndexUnlocked(i)); 3040 if (module_sp && module_sp->IsExecutable()) { 3041 if (GetTarget().GetExecutableModulePointer() != module_sp.get()) 3042 new_executable_module_sp = module_sp; 3043 break; 3044 } 3045 } 3046 if (new_executable_module_sp) { 3047 GetTarget().SetExecutableModule(new_executable_module_sp, 3048 eLoadDependentsNo); 3049 if (log) { 3050 ModuleSP exe_module_sp = GetTarget().GetExecutableModule(); 3051 log->Printf( 3052 "Process::%s after looping through modules, target executable is %s", 3053 __FUNCTION__, 3054 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str() 3055 : "<none>"); 3056 } 3057 } 3058 } 3059 3060 Status Process::ConnectRemote(Stream *strm, llvm::StringRef remote_url) { 3061 m_abi_sp.reset(); 3062 m_process_input_reader.reset(); 3063 3064 // Find the process and its architecture. Make sure it matches the 3065 // architecture of the current Target, and if not adjust it. 3066 3067 Status error(DoConnectRemote(strm, remote_url)); 3068 if (error.Success()) { 3069 if (GetID() != LLDB_INVALID_PROCESS_ID) { 3070 EventSP event_sp; 3071 StateType state = WaitForProcessStopPrivate(event_sp, llvm::None); 3072 3073 if (state == eStateStopped || state == eStateCrashed) { 3074 // If we attached and actually have a process on the other end, then 3075 // this ended up being the equivalent of an attach. 3076 CompleteAttach(); 3077 3078 // This delays passing the stopped event to listeners till 3079 // CompleteAttach gets a chance to complete... 3080 HandlePrivateEvent(event_sp); 3081 } 3082 } 3083 3084 if (PrivateStateThreadIsValid()) 3085 ResumePrivateStateThread(); 3086 else 3087 StartPrivateStateThread(); 3088 } 3089 return error; 3090 } 3091 3092 Status Process::PrivateResume() { 3093 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | 3094 LIBLLDB_LOG_STEP)); 3095 if (log) 3096 log->Printf("Process::PrivateResume() m_stop_id = %u, public state: %s " 3097 "private state: %s", 3098 m_mod_id.GetStopID(), StateAsCString(m_public_state.GetValue()), 3099 StateAsCString(m_private_state.GetValue())); 3100 3101 // If signals handing status changed we might want to update our signal 3102 // filters before resuming. 3103 UpdateAutomaticSignalFiltering(); 3104 3105 Status error(WillResume()); 3106 // Tell the process it is about to resume before the thread list 3107 if (error.Success()) { 3108 // Now let the thread list know we are about to resume so it can let all of 3109 // our threads know that they are about to be resumed. Threads will each be 3110 // called with Thread::WillResume(StateType) where StateType contains the 3111 // state that they are supposed to have when the process is resumed 3112 // (suspended/running/stepping). Threads should also check their resume 3113 // signal in lldb::Thread::GetResumeSignal() to see if they are supposed to 3114 // start back up with a signal. 3115 if (m_thread_list.WillResume()) { 3116 // Last thing, do the PreResumeActions. 3117 if (!RunPreResumeActions()) { 3118 error.SetErrorStringWithFormat( 3119 "Process::PrivateResume PreResumeActions failed, not resuming."); 3120 } else { 3121 m_mod_id.BumpResumeID(); 3122 error = DoResume(); 3123 if (error.Success()) { 3124 DidResume(); 3125 m_thread_list.DidResume(); 3126 if (log) 3127 log->Printf("Process thinks the process has resumed."); 3128 } else { 3129 if (log) 3130 log->Printf( 3131 "Process::PrivateResume() DoResume failed."); 3132 return error; 3133 } 3134 } 3135 } else { 3136 // Somebody wanted to run without running (e.g. we were faking a step 3137 // from one frame of a set of inlined frames that share the same PC to 3138 // another.) So generate a continue & a stopped event, and let the world 3139 // handle them. 3140 if (log) 3141 log->Printf( 3142 "Process::PrivateResume() asked to simulate a start & stop."); 3143 3144 SetPrivateState(eStateRunning); 3145 SetPrivateState(eStateStopped); 3146 } 3147 } else if (log) 3148 log->Printf("Process::PrivateResume() got an error \"%s\".", 3149 error.AsCString("<unknown error>")); 3150 return error; 3151 } 3152 3153 Status Process::Halt(bool clear_thread_plans, bool use_run_lock) { 3154 if (!StateIsRunningState(m_public_state.GetValue())) 3155 return Status("Process is not running."); 3156 3157 // Don't clear the m_clear_thread_plans_on_stop, only set it to true if in 3158 // case it was already set and some thread plan logic calls halt on its own. 3159 m_clear_thread_plans_on_stop |= clear_thread_plans; 3160 3161 ListenerSP halt_listener_sp( 3162 Listener::MakeListener("lldb.process.halt_listener")); 3163 HijackProcessEvents(halt_listener_sp); 3164 3165 EventSP event_sp; 3166 3167 SendAsyncInterrupt(); 3168 3169 if (m_public_state.GetValue() == eStateAttaching) { 3170 // Don't hijack and eat the eStateExited as the code that was doing the 3171 // attach will be waiting for this event... 3172 RestoreProcessEvents(); 3173 SetExitStatus(SIGKILL, "Cancelled async attach."); 3174 Destroy(false); 3175 return Status(); 3176 } 3177 3178 // Wait for 10 second for the process to stop. 3179 StateType state = WaitForProcessToStop( 3180 seconds(10), &event_sp, true, halt_listener_sp, nullptr, use_run_lock); 3181 RestoreProcessEvents(); 3182 3183 if (state == eStateInvalid || !event_sp) { 3184 // We timed out and didn't get a stop event... 3185 return Status("Halt timed out. State = %s", StateAsCString(GetState())); 3186 } 3187 3188 BroadcastEvent(event_sp); 3189 3190 return Status(); 3191 } 3192 3193 Status Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) { 3194 Status error; 3195 3196 // Check both the public & private states here. If we're hung evaluating an 3197 // expression, for instance, then the public state will be stopped, but we 3198 // still need to interrupt. 3199 if (m_public_state.GetValue() == eStateRunning || 3200 m_private_state.GetValue() == eStateRunning) { 3201 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 3202 if (log) 3203 log->Printf("Process::%s() About to stop.", __FUNCTION__); 3204 3205 ListenerSP listener_sp( 3206 Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack")); 3207 HijackProcessEvents(listener_sp); 3208 3209 SendAsyncInterrupt(); 3210 3211 // Consume the interrupt event. 3212 StateType state = 3213 WaitForProcessToStop(seconds(10), &exit_event_sp, true, listener_sp); 3214 3215 RestoreProcessEvents(); 3216 3217 // If the process exited while we were waiting for it to stop, put the 3218 // exited event into the shared pointer passed in and return. Our caller 3219 // doesn't need to do anything else, since they don't have a process 3220 // anymore... 3221 3222 if (state == eStateExited || m_private_state.GetValue() == eStateExited) { 3223 if (log) 3224 log->Printf("Process::%s() Process exited while waiting to stop.", 3225 __FUNCTION__); 3226 return error; 3227 } else 3228 exit_event_sp.reset(); // It is ok to consume any non-exit stop events 3229 3230 if (state != eStateStopped) { 3231 if (log) 3232 log->Printf("Process::%s() failed to stop, state is: %s", __FUNCTION__, 3233 StateAsCString(state)); 3234 // If we really couldn't stop the process then we should just error out 3235 // here, but if the lower levels just bobbled sending the event and we 3236 // really are stopped, then continue on. 3237 StateType private_state = m_private_state.GetValue(); 3238 if (private_state != eStateStopped) { 3239 return Status( 3240 "Attempt to stop the target in order to detach timed out. " 3241 "State = %s", 3242 StateAsCString(GetState())); 3243 } 3244 } 3245 } 3246 return error; 3247 } 3248 3249 Status Process::Detach(bool keep_stopped) { 3250 EventSP exit_event_sp; 3251 Status error; 3252 m_destroy_in_process = true; 3253 3254 error = WillDetach(); 3255 3256 if (error.Success()) { 3257 if (DetachRequiresHalt()) { 3258 error = StopForDestroyOrDetach(exit_event_sp); 3259 if (!error.Success()) { 3260 m_destroy_in_process = false; 3261 return error; 3262 } else if (exit_event_sp) { 3263 // We shouldn't need to do anything else here. There's no process left 3264 // to detach from... 3265 StopPrivateStateThread(); 3266 m_destroy_in_process = false; 3267 return error; 3268 } 3269 } 3270 3271 m_thread_list.DiscardThreadPlans(); 3272 DisableAllBreakpointSites(); 3273 3274 error = DoDetach(keep_stopped); 3275 if (error.Success()) { 3276 DidDetach(); 3277 StopPrivateStateThread(); 3278 } else { 3279 return error; 3280 } 3281 } 3282 m_destroy_in_process = false; 3283 3284 // If we exited when we were waiting for a process to stop, then forward the 3285 // event here so we don't lose the event 3286 if (exit_event_sp) { 3287 // Directly broadcast our exited event because we shut down our private 3288 // state thread above 3289 BroadcastEvent(exit_event_sp); 3290 } 3291 3292 // If we have been interrupted (to kill us) in the middle of running, we may 3293 // not end up propagating the last events through the event system, in which 3294 // case we might strand the write lock. Unlock it here so when we do to tear 3295 // down the process we don't get an error destroying the lock. 3296 3297 m_public_run_lock.SetStopped(); 3298 return error; 3299 } 3300 3301 Status Process::Destroy(bool force_kill) { 3302 3303 // Tell ourselves we are in the process of destroying the process, so that we 3304 // don't do any unnecessary work that might hinder the destruction. Remember 3305 // to set this back to false when we are done. That way if the attempt 3306 // failed and the process stays around for some reason it won't be in a 3307 // confused state. 3308 3309 if (force_kill) 3310 m_should_detach = false; 3311 3312 if (GetShouldDetach()) { 3313 // FIXME: This will have to be a process setting: 3314 bool keep_stopped = false; 3315 Detach(keep_stopped); 3316 } 3317 3318 m_destroy_in_process = true; 3319 3320 Status error(WillDestroy()); 3321 if (error.Success()) { 3322 EventSP exit_event_sp; 3323 if (DestroyRequiresHalt()) { 3324 error = StopForDestroyOrDetach(exit_event_sp); 3325 } 3326 3327 if (m_public_state.GetValue() != eStateRunning) { 3328 // Ditch all thread plans, and remove all our breakpoints: in case we 3329 // have to restart the target to kill it, we don't want it hitting a 3330 // breakpoint... Only do this if we've stopped, however, since if we 3331 // didn't manage to halt it above, then we're not going to have much luck 3332 // doing this now. 3333 m_thread_list.DiscardThreadPlans(); 3334 DisableAllBreakpointSites(); 3335 } 3336 3337 error = DoDestroy(); 3338 if (error.Success()) { 3339 DidDestroy(); 3340 StopPrivateStateThread(); 3341 } 3342 m_stdio_communication.Disconnect(); 3343 m_stdio_communication.StopReadThread(); 3344 m_stdin_forward = false; 3345 3346 if (m_process_input_reader) { 3347 m_process_input_reader->SetIsDone(true); 3348 m_process_input_reader->Cancel(); 3349 m_process_input_reader.reset(); 3350 } 3351 3352 // If we exited when we were waiting for a process to stop, then forward 3353 // the event here so we don't lose the event 3354 if (exit_event_sp) { 3355 // Directly broadcast our exited event because we shut down our private 3356 // state thread above 3357 BroadcastEvent(exit_event_sp); 3358 } 3359 3360 // If we have been interrupted (to kill us) in the middle of running, we 3361 // may not end up propagating the last events through the event system, in 3362 // which case we might strand the write lock. Unlock it here so when we do 3363 // to tear down the process we don't get an error destroying the lock. 3364 m_public_run_lock.SetStopped(); 3365 } 3366 3367 m_destroy_in_process = false; 3368 3369 return error; 3370 } 3371 3372 Status Process::Signal(int signal) { 3373 Status error(WillSignal()); 3374 if (error.Success()) { 3375 error = DoSignal(signal); 3376 if (error.Success()) 3377 DidSignal(); 3378 } 3379 return error; 3380 } 3381 3382 void Process::SetUnixSignals(UnixSignalsSP &&signals_sp) { 3383 assert(signals_sp && "null signals_sp"); 3384 m_unix_signals_sp = signals_sp; 3385 } 3386 3387 const lldb::UnixSignalsSP &Process::GetUnixSignals() { 3388 assert(m_unix_signals_sp && "null m_unix_signals_sp"); 3389 return m_unix_signals_sp; 3390 } 3391 3392 lldb::ByteOrder Process::GetByteOrder() const { 3393 return GetTarget().GetArchitecture().GetByteOrder(); 3394 } 3395 3396 uint32_t Process::GetAddressByteSize() const { 3397 return GetTarget().GetArchitecture().GetAddressByteSize(); 3398 } 3399 3400 bool Process::ShouldBroadcastEvent(Event *event_ptr) { 3401 const StateType state = 3402 Process::ProcessEventData::GetStateFromEvent(event_ptr); 3403 bool return_value = true; 3404 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS | 3405 LIBLLDB_LOG_PROCESS)); 3406 3407 switch (state) { 3408 case eStateDetached: 3409 case eStateExited: 3410 case eStateUnloaded: 3411 m_stdio_communication.SynchronizeWithReadThread(); 3412 m_stdio_communication.Disconnect(); 3413 m_stdio_communication.StopReadThread(); 3414 m_stdin_forward = false; 3415 3416 LLVM_FALLTHROUGH; 3417 case eStateConnected: 3418 case eStateAttaching: 3419 case eStateLaunching: 3420 // These events indicate changes in the state of the debugging session, 3421 // always report them. 3422 return_value = true; 3423 break; 3424 case eStateInvalid: 3425 // We stopped for no apparent reason, don't report it. 3426 return_value = false; 3427 break; 3428 case eStateRunning: 3429 case eStateStepping: 3430 // If we've started the target running, we handle the cases where we are 3431 // already running and where there is a transition from stopped to running 3432 // differently. running -> running: Automatically suppress extra running 3433 // events stopped -> running: Report except when there is one or more no 3434 // votes 3435 // and no yes votes. 3436 SynchronouslyNotifyStateChanged(state); 3437 if (m_force_next_event_delivery) 3438 return_value = true; 3439 else { 3440 switch (m_last_broadcast_state) { 3441 case eStateRunning: 3442 case eStateStepping: 3443 // We always suppress multiple runnings with no PUBLIC stop in between. 3444 return_value = false; 3445 break; 3446 default: 3447 // TODO: make this work correctly. For now always report 3448 // run if we aren't running so we don't miss any running events. If I 3449 // run the lldb/test/thread/a.out file and break at main.cpp:58, run 3450 // and hit the breakpoints on multiple threads, then somehow during the 3451 // stepping over of all breakpoints no run gets reported. 3452 3453 // This is a transition from stop to run. 3454 switch (m_thread_list.ShouldReportRun(event_ptr)) { 3455 case eVoteYes: 3456 case eVoteNoOpinion: 3457 return_value = true; 3458 break; 3459 case eVoteNo: 3460 return_value = false; 3461 break; 3462 } 3463 break; 3464 } 3465 } 3466 break; 3467 case eStateStopped: 3468 case eStateCrashed: 3469 case eStateSuspended: 3470 // We've stopped. First see if we're going to restart the target. If we 3471 // are going to stop, then we always broadcast the event. If we aren't 3472 // going to stop, let the thread plans decide if we're going to report this 3473 // event. If no thread has an opinion, we don't report it. 3474 3475 m_stdio_communication.SynchronizeWithReadThread(); 3476 RefreshStateAfterStop(); 3477 if (ProcessEventData::GetInterruptedFromEvent(event_ptr)) { 3478 if (log) 3479 log->Printf("Process::ShouldBroadcastEvent (%p) stopped due to an " 3480 "interrupt, state: %s", 3481 static_cast<void *>(event_ptr), StateAsCString(state)); 3482 // Even though we know we are going to stop, we should let the threads 3483 // have a look at the stop, so they can properly set their state. 3484 m_thread_list.ShouldStop(event_ptr); 3485 return_value = true; 3486 } else { 3487 bool was_restarted = ProcessEventData::GetRestartedFromEvent(event_ptr); 3488 bool should_resume = false; 3489 3490 // It makes no sense to ask "ShouldStop" if we've already been 3491 // restarted... Asking the thread list is also not likely to go well, 3492 // since we are running again. So in that case just report the event. 3493 3494 if (!was_restarted) 3495 should_resume = !m_thread_list.ShouldStop(event_ptr); 3496 3497 if (was_restarted || should_resume || m_resume_requested) { 3498 Vote stop_vote = m_thread_list.ShouldReportStop(event_ptr); 3499 if (log) 3500 log->Printf("Process::ShouldBroadcastEvent: should_resume: %i state: " 3501 "%s was_restarted: %i stop_vote: %d.", 3502 should_resume, StateAsCString(state), was_restarted, 3503 stop_vote); 3504 3505 switch (stop_vote) { 3506 case eVoteYes: 3507 return_value = true; 3508 break; 3509 case eVoteNoOpinion: 3510 case eVoteNo: 3511 return_value = false; 3512 break; 3513 } 3514 3515 if (!was_restarted) { 3516 if (log) 3517 log->Printf("Process::ShouldBroadcastEvent (%p) Restarting process " 3518 "from state: %s", 3519 static_cast<void *>(event_ptr), StateAsCString(state)); 3520 ProcessEventData::SetRestartedInEvent(event_ptr, true); 3521 PrivateResume(); 3522 } 3523 } else { 3524 return_value = true; 3525 SynchronouslyNotifyStateChanged(state); 3526 } 3527 } 3528 break; 3529 } 3530 3531 // Forcing the next event delivery is a one shot deal. So reset it here. 3532 m_force_next_event_delivery = false; 3533 3534 // We do some coalescing of events (for instance two consecutive running 3535 // events get coalesced.) But we only coalesce against events we actually 3536 // broadcast. So we use m_last_broadcast_state to track that. NB - you 3537 // can't use "m_public_state.GetValue()" for that purpose, as was originally 3538 // done, because the PublicState reflects the last event pulled off the 3539 // queue, and there may be several events stacked up on the queue unserviced. 3540 // So the PublicState may not reflect the last broadcasted event yet. 3541 // m_last_broadcast_state gets updated here. 3542 3543 if (return_value) 3544 m_last_broadcast_state = state; 3545 3546 if (log) 3547 log->Printf("Process::ShouldBroadcastEvent (%p) => new state: %s, last " 3548 "broadcast state: %s - %s", 3549 static_cast<void *>(event_ptr), StateAsCString(state), 3550 StateAsCString(m_last_broadcast_state), 3551 return_value ? "YES" : "NO"); 3552 return return_value; 3553 } 3554 3555 bool Process::StartPrivateStateThread(bool is_secondary_thread) { 3556 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS)); 3557 3558 bool already_running = PrivateStateThreadIsValid(); 3559 if (log) 3560 log->Printf("Process::%s()%s ", __FUNCTION__, 3561 already_running ? " already running" 3562 : " starting private state thread"); 3563 3564 if (!is_secondary_thread && already_running) 3565 return true; 3566 3567 // Create a thread that watches our internal state and controls which events 3568 // make it to clients (into the DCProcess event queue). 3569 char thread_name[1024]; 3570 uint32_t max_len = llvm::get_max_thread_name_length(); 3571 if (max_len > 0 && max_len <= 30) { 3572 // On platforms with abbreviated thread name lengths, choose thread names 3573 // that fit within the limit. 3574 if (already_running) 3575 snprintf(thread_name, sizeof(thread_name), "intern-state-OV"); 3576 else 3577 snprintf(thread_name, sizeof(thread_name), "intern-state"); 3578 } else { 3579 if (already_running) 3580 snprintf(thread_name, sizeof(thread_name), 3581 "<lldb.process.internal-state-override(pid=%" PRIu64 ")>", 3582 GetID()); 3583 else 3584 snprintf(thread_name, sizeof(thread_name), 3585 "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID()); 3586 } 3587 3588 // Create the private state thread, and start it running. 3589 PrivateStateThreadArgs *args_ptr = 3590 new PrivateStateThreadArgs(this, is_secondary_thread); 3591 llvm::Expected<HostThread> private_state_thread = 3592 ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread, 3593 (void *)args_ptr, 8 * 1024 * 1024); 3594 if (!private_state_thread) { 3595 LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST), 3596 "failed to launch host thread: {}", 3597 llvm::toString(private_state_thread.takeError())); 3598 return false; 3599 } 3600 3601 assert(private_state_thread->IsJoinable()); 3602 m_private_state_thread = *private_state_thread; 3603 ResumePrivateStateThread(); 3604 return true; 3605 } 3606 3607 void Process::PausePrivateStateThread() { 3608 ControlPrivateStateThread(eBroadcastInternalStateControlPause); 3609 } 3610 3611 void Process::ResumePrivateStateThread() { 3612 ControlPrivateStateThread(eBroadcastInternalStateControlResume); 3613 } 3614 3615 void Process::StopPrivateStateThread() { 3616 if (m_private_state_thread.IsJoinable()) 3617 ControlPrivateStateThread(eBroadcastInternalStateControlStop); 3618 else { 3619 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 3620 if (log) 3621 log->Printf( 3622 "Went to stop the private state thread, but it was already invalid."); 3623 } 3624 } 3625 3626 void Process::ControlPrivateStateThread(uint32_t signal) { 3627 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 3628 3629 assert(signal == eBroadcastInternalStateControlStop || 3630 signal == eBroadcastInternalStateControlPause || 3631 signal == eBroadcastInternalStateControlResume); 3632 3633 if (log) 3634 log->Printf("Process::%s (signal = %d)", __FUNCTION__, signal); 3635 3636 // Signal the private state thread 3637 if (m_private_state_thread.IsJoinable()) { 3638 // Broadcast the event. 3639 // It is important to do this outside of the if below, because it's 3640 // possible that the thread state is invalid but that the thread is waiting 3641 // on a control event instead of simply being on its way out (this should 3642 // not happen, but it apparently can). 3643 if (log) 3644 log->Printf("Sending control event of type: %d.", signal); 3645 std::shared_ptr<EventDataReceipt> event_receipt_sp(new EventDataReceipt()); 3646 m_private_state_control_broadcaster.BroadcastEvent(signal, 3647 event_receipt_sp); 3648 3649 // Wait for the event receipt or for the private state thread to exit 3650 bool receipt_received = false; 3651 if (PrivateStateThreadIsValid()) { 3652 while (!receipt_received) { 3653 // Check for a receipt for n seconds and then check if the private 3654 // state thread is still around. 3655 receipt_received = 3656 event_receipt_sp->WaitForEventReceived(GetUtilityExpressionTimeout()); 3657 if (!receipt_received) { 3658 // Check if the private state thread is still around. If it isn't 3659 // then we are done waiting 3660 if (!PrivateStateThreadIsValid()) 3661 break; // Private state thread exited or is exiting, we are done 3662 } 3663 } 3664 } 3665 3666 if (signal == eBroadcastInternalStateControlStop) { 3667 thread_result_t result = {}; 3668 m_private_state_thread.Join(&result); 3669 m_private_state_thread.Reset(); 3670 } 3671 } else { 3672 if (log) 3673 log->Printf( 3674 "Private state thread already dead, no need to signal it to stop."); 3675 } 3676 } 3677 3678 void Process::SendAsyncInterrupt() { 3679 if (PrivateStateThreadIsValid()) 3680 m_private_state_broadcaster.BroadcastEvent(Process::eBroadcastBitInterrupt, 3681 nullptr); 3682 else 3683 BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr); 3684 } 3685 3686 void Process::HandlePrivateEvent(EventSP &event_sp) { 3687 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 3688 m_resume_requested = false; 3689 3690 const StateType new_state = 3691 Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 3692 3693 // First check to see if anybody wants a shot at this event: 3694 if (m_next_event_action_up) { 3695 NextEventAction::EventActionResult action_result = 3696 m_next_event_action_up->PerformAction(event_sp); 3697 if (log) 3698 log->Printf("Ran next event action, result was %d.", action_result); 3699 3700 switch (action_result) { 3701 case NextEventAction::eEventActionSuccess: 3702 SetNextEventAction(nullptr); 3703 break; 3704 3705 case NextEventAction::eEventActionRetry: 3706 break; 3707 3708 case NextEventAction::eEventActionExit: 3709 // Handle Exiting Here. If we already got an exited event, we should 3710 // just propagate it. Otherwise, swallow this event, and set our state 3711 // to exit so the next event will kill us. 3712 if (new_state != eStateExited) { 3713 // FIXME: should cons up an exited event, and discard this one. 3714 SetExitStatus(0, m_next_event_action_up->GetExitString()); 3715 SetNextEventAction(nullptr); 3716 return; 3717 } 3718 SetNextEventAction(nullptr); 3719 break; 3720 } 3721 } 3722 3723 // See if we should broadcast this state to external clients? 3724 const bool should_broadcast = ShouldBroadcastEvent(event_sp.get()); 3725 3726 if (should_broadcast) { 3727 const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged); 3728 if (log) { 3729 log->Printf("Process::%s (pid = %" PRIu64 3730 ") broadcasting new state %s (old state %s) to %s", 3731 __FUNCTION__, GetID(), StateAsCString(new_state), 3732 StateAsCString(GetState()), 3733 is_hijacked ? "hijacked" : "public"); 3734 } 3735 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get()); 3736 if (StateIsRunningState(new_state)) { 3737 // Only push the input handler if we aren't fowarding events, as this 3738 // means the curses GUI is in use... Or don't push it if we are launching 3739 // since it will come up stopped. 3740 if (!GetTarget().GetDebugger().IsForwardingEvents() && 3741 new_state != eStateLaunching && new_state != eStateAttaching) { 3742 PushProcessIOHandler(); 3743 m_iohandler_sync.SetValue(m_iohandler_sync.GetValue() + 1, 3744 eBroadcastAlways); 3745 if (log) 3746 log->Printf("Process::%s updated m_iohandler_sync to %d", 3747 __FUNCTION__, m_iohandler_sync.GetValue()); 3748 } 3749 } else if (StateIsStoppedState(new_state, false)) { 3750 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) { 3751 // If the lldb_private::Debugger is handling the events, we don't want 3752 // to pop the process IOHandler here, we want to do it when we receive 3753 // the stopped event so we can carefully control when the process 3754 // IOHandler is popped because when we stop we want to display some 3755 // text stating how and why we stopped, then maybe some 3756 // process/thread/frame info, and then we want the "(lldb) " prompt to 3757 // show up. If we pop the process IOHandler here, then we will cause 3758 // the command interpreter to become the top IOHandler after the 3759 // process pops off and it will update its prompt right away... See the 3760 // Debugger.cpp file where it calls the function as 3761 // "process_sp->PopProcessIOHandler()" to see where I am talking about. 3762 // Otherwise we end up getting overlapping "(lldb) " prompts and 3763 // garbled output. 3764 // 3765 // If we aren't handling the events in the debugger (which is indicated 3766 // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or 3767 // we are hijacked, then we always pop the process IO handler manually. 3768 // Hijacking happens when the internal process state thread is running 3769 // thread plans, or when commands want to run in synchronous mode and 3770 // they call "process->WaitForProcessToStop()". An example of something 3771 // that will hijack the events is a simple expression: 3772 // 3773 // (lldb) expr (int)puts("hello") 3774 // 3775 // This will cause the internal process state thread to resume and halt 3776 // the process (and _it_ will hijack the eBroadcastBitStateChanged 3777 // events) and we do need the IO handler to be pushed and popped 3778 // correctly. 3779 3780 if (is_hijacked || !GetTarget().GetDebugger().IsHandlingEvents()) 3781 PopProcessIOHandler(); 3782 } 3783 } 3784 3785 BroadcastEvent(event_sp); 3786 } else { 3787 if (log) { 3788 log->Printf( 3789 "Process::%s (pid = %" PRIu64 3790 ") suppressing state %s (old state %s): should_broadcast == false", 3791 __FUNCTION__, GetID(), StateAsCString(new_state), 3792 StateAsCString(GetState())); 3793 } 3794 } 3795 } 3796 3797 Status Process::HaltPrivate() { 3798 EventSP event_sp; 3799 Status error(WillHalt()); 3800 if (error.Fail()) 3801 return error; 3802 3803 // Ask the process subclass to actually halt our process 3804 bool caused_stop; 3805 error = DoHalt(caused_stop); 3806 3807 DidHalt(); 3808 return error; 3809 } 3810 3811 thread_result_t Process::PrivateStateThread(void *arg) { 3812 std::unique_ptr<PrivateStateThreadArgs> args_up( 3813 static_cast<PrivateStateThreadArgs *>(arg)); 3814 thread_result_t result = 3815 args_up->process->RunPrivateStateThread(args_up->is_secondary_thread); 3816 return result; 3817 } 3818 3819 thread_result_t Process::RunPrivateStateThread(bool is_secondary_thread) { 3820 bool control_only = true; 3821 3822 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 3823 if (log) 3824 log->Printf("Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...", 3825 __FUNCTION__, static_cast<void *>(this), GetID()); 3826 3827 bool exit_now = false; 3828 bool interrupt_requested = false; 3829 while (!exit_now) { 3830 EventSP event_sp; 3831 GetEventsPrivate(event_sp, llvm::None, control_only); 3832 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) { 3833 if (log) 3834 log->Printf("Process::%s (arg = %p, pid = %" PRIu64 3835 ") got a control event: %d", 3836 __FUNCTION__, static_cast<void *>(this), GetID(), 3837 event_sp->GetType()); 3838 3839 switch (event_sp->GetType()) { 3840 case eBroadcastInternalStateControlStop: 3841 exit_now = true; 3842 break; // doing any internal state management below 3843 3844 case eBroadcastInternalStateControlPause: 3845 control_only = true; 3846 break; 3847 3848 case eBroadcastInternalStateControlResume: 3849 control_only = false; 3850 break; 3851 } 3852 3853 continue; 3854 } else if (event_sp->GetType() == eBroadcastBitInterrupt) { 3855 if (m_public_state.GetValue() == eStateAttaching) { 3856 if (log) 3857 log->Printf("Process::%s (arg = %p, pid = %" PRIu64 3858 ") woke up with an interrupt while attaching - " 3859 "forwarding interrupt.", 3860 __FUNCTION__, static_cast<void *>(this), GetID()); 3861 BroadcastEvent(eBroadcastBitInterrupt, nullptr); 3862 } else if (StateIsRunningState(m_last_broadcast_state)) { 3863 if (log) 3864 log->Printf("Process::%s (arg = %p, pid = %" PRIu64 3865 ") woke up with an interrupt - Halting.", 3866 __FUNCTION__, static_cast<void *>(this), GetID()); 3867 Status error = HaltPrivate(); 3868 if (error.Fail() && log) 3869 log->Printf("Process::%s (arg = %p, pid = %" PRIu64 3870 ") failed to halt the process: %s", 3871 __FUNCTION__, static_cast<void *>(this), GetID(), 3872 error.AsCString()); 3873 // Halt should generate a stopped event. Make a note of the fact that 3874 // we were doing the interrupt, so we can set the interrupted flag 3875 // after we receive the event. We deliberately set this to true even if 3876 // HaltPrivate failed, so that we can interrupt on the next natural 3877 // stop. 3878 interrupt_requested = true; 3879 } else { 3880 // This can happen when someone (e.g. Process::Halt) sees that we are 3881 // running and sends an interrupt request, but the process actually 3882 // stops before we receive it. In that case, we can just ignore the 3883 // request. We use m_last_broadcast_state, because the Stopped event 3884 // may not have been popped of the event queue yet, which is when the 3885 // public state gets updated. 3886 if (log) 3887 log->Printf( 3888 "Process::%s ignoring interrupt as we have already stopped.", 3889 __FUNCTION__); 3890 } 3891 continue; 3892 } 3893 3894 const StateType internal_state = 3895 Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 3896 3897 if (internal_state != eStateInvalid) { 3898 if (m_clear_thread_plans_on_stop && 3899 StateIsStoppedState(internal_state, true)) { 3900 m_clear_thread_plans_on_stop = false; 3901 m_thread_list.DiscardThreadPlans(); 3902 } 3903 3904 if (interrupt_requested) { 3905 if (StateIsStoppedState(internal_state, true)) { 3906 // We requested the interrupt, so mark this as such in the stop event 3907 // so clients can tell an interrupted process from a natural stop 3908 ProcessEventData::SetInterruptedInEvent(event_sp.get(), true); 3909 interrupt_requested = false; 3910 } else if (log) { 3911 log->Printf("Process::%s interrupt_requested, but a non-stopped " 3912 "state '%s' received.", 3913 __FUNCTION__, StateAsCString(internal_state)); 3914 } 3915 } 3916 3917 HandlePrivateEvent(event_sp); 3918 } 3919 3920 if (internal_state == eStateInvalid || internal_state == eStateExited || 3921 internal_state == eStateDetached) { 3922 if (log) 3923 log->Printf("Process::%s (arg = %p, pid = %" PRIu64 3924 ") about to exit with internal state %s...", 3925 __FUNCTION__, static_cast<void *>(this), GetID(), 3926 StateAsCString(internal_state)); 3927 3928 break; 3929 } 3930 } 3931 3932 // Verify log is still enabled before attempting to write to it... 3933 if (log) 3934 log->Printf("Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...", 3935 __FUNCTION__, static_cast<void *>(this), GetID()); 3936 3937 // If we are a secondary thread, then the primary thread we are working for 3938 // will have already acquired the public_run_lock, and isn't done with what 3939 // it was doing yet, so don't try to change it on the way out. 3940 if (!is_secondary_thread) 3941 m_public_run_lock.SetStopped(); 3942 return {}; 3943 } 3944 3945 // Process Event Data 3946 3947 Process::ProcessEventData::ProcessEventData() 3948 : EventData(), m_process_wp(), m_state(eStateInvalid), m_restarted(false), 3949 m_update_state(0), m_interrupted(false) {} 3950 3951 Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp, 3952 StateType state) 3953 : EventData(), m_process_wp(), m_state(state), m_restarted(false), 3954 m_update_state(0), m_interrupted(false) { 3955 if (process_sp) 3956 m_process_wp = process_sp; 3957 } 3958 3959 Process::ProcessEventData::~ProcessEventData() = default; 3960 3961 ConstString Process::ProcessEventData::GetFlavorString() { 3962 static ConstString g_flavor("Process::ProcessEventData"); 3963 return g_flavor; 3964 } 3965 3966 ConstString Process::ProcessEventData::GetFlavor() const { 3967 return ProcessEventData::GetFlavorString(); 3968 } 3969 3970 void Process::ProcessEventData::DoOnRemoval(Event *event_ptr) { 3971 ProcessSP process_sp(m_process_wp.lock()); 3972 3973 if (!process_sp) 3974 return; 3975 3976 // This function gets called twice for each event, once when the event gets 3977 // pulled off of the private process event queue, and then any number of 3978 // times, first when it gets pulled off of the public event queue, then other 3979 // times when we're pretending that this is where we stopped at the end of 3980 // expression evaluation. m_update_state is used to distinguish these three 3981 // cases; it is 0 when we're just pulling it off for private handling, and > 3982 // 1 for expression evaluation, and we don't want to do the breakpoint 3983 // command handling then. 3984 if (m_update_state != 1) 3985 return; 3986 3987 process_sp->SetPublicState( 3988 m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr)); 3989 3990 if (m_state == eStateStopped && !m_restarted) { 3991 // Let process subclasses know we are about to do a public stop and do 3992 // anything they might need to in order to speed up register and memory 3993 // accesses. 3994 process_sp->WillPublicStop(); 3995 } 3996 3997 // If this is a halt event, even if the halt stopped with some reason other 3998 // than a plain interrupt (e.g. we had already stopped for a breakpoint when 3999 // the halt request came through) don't do the StopInfo actions, as they may 4000 // end up restarting the process. 4001 if (m_interrupted) 4002 return; 4003 4004 // If we're stopped and haven't restarted, then do the StopInfo actions here: 4005 if (m_state == eStateStopped && !m_restarted) { 4006 ThreadList &curr_thread_list = process_sp->GetThreadList(); 4007 uint32_t num_threads = curr_thread_list.GetSize(); 4008 uint32_t idx; 4009 4010 // The actions might change one of the thread's stop_info's opinions about 4011 // whether we should stop the process, so we need to query that as we go. 4012 4013 // One other complication here, is that we try to catch any case where the 4014 // target has run (except for expressions) and immediately exit, but if we 4015 // get that wrong (which is possible) then the thread list might have 4016 // changed, and that would cause our iteration here to crash. We could 4017 // make a copy of the thread list, but we'd really like to also know if it 4018 // has changed at all, so we make up a vector of the thread ID's and check 4019 // what we get back against this list & bag out if anything differs. 4020 std::vector<uint32_t> thread_index_array(num_threads); 4021 for (idx = 0; idx < num_threads; ++idx) 4022 thread_index_array[idx] = 4023 curr_thread_list.GetThreadAtIndex(idx)->GetIndexID(); 4024 4025 // Use this to track whether we should continue from here. We will only 4026 // continue the target running if no thread says we should stop. Of course 4027 // if some thread's PerformAction actually sets the target running, then it 4028 // doesn't matter what the other threads say... 4029 4030 bool still_should_stop = false; 4031 4032 // Sometimes - for instance if we have a bug in the stub we are talking to, 4033 // we stop but no thread has a valid stop reason. In that case we should 4034 // just stop, because we have no way of telling what the right thing to do 4035 // is, and it's better to let the user decide than continue behind their 4036 // backs. 4037 4038 bool does_anybody_have_an_opinion = false; 4039 4040 for (idx = 0; idx < num_threads; ++idx) { 4041 curr_thread_list = process_sp->GetThreadList(); 4042 if (curr_thread_list.GetSize() != num_threads) { 4043 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP | 4044 LIBLLDB_LOG_PROCESS)); 4045 if (log) 4046 log->Printf( 4047 "Number of threads changed from %u to %u while processing event.", 4048 num_threads, curr_thread_list.GetSize()); 4049 break; 4050 } 4051 4052 lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx); 4053 4054 if (thread_sp->GetIndexID() != thread_index_array[idx]) { 4055 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP | 4056 LIBLLDB_LOG_PROCESS)); 4057 if (log) 4058 log->Printf("The thread at position %u changed from %u to %u while " 4059 "processing event.", 4060 idx, thread_index_array[idx], thread_sp->GetIndexID()); 4061 break; 4062 } 4063 4064 StopInfoSP stop_info_sp = thread_sp->GetStopInfo(); 4065 if (stop_info_sp && stop_info_sp->IsValid()) { 4066 does_anybody_have_an_opinion = true; 4067 bool this_thread_wants_to_stop; 4068 if (stop_info_sp->GetOverrideShouldStop()) { 4069 this_thread_wants_to_stop = 4070 stop_info_sp->GetOverriddenShouldStopValue(); 4071 } else { 4072 stop_info_sp->PerformAction(event_ptr); 4073 // The stop action might restart the target. If it does, then we 4074 // want to mark that in the event so that whoever is receiving it 4075 // will know to wait for the running event and reflect that state 4076 // appropriately. We also need to stop processing actions, since they 4077 // aren't expecting the target to be running. 4078 4079 // FIXME: we might have run. 4080 if (stop_info_sp->HasTargetRunSinceMe()) { 4081 SetRestarted(true); 4082 break; 4083 } 4084 4085 this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr); 4086 } 4087 4088 if (!still_should_stop) 4089 still_should_stop = this_thread_wants_to_stop; 4090 } 4091 } 4092 4093 if (!GetRestarted()) { 4094 if (!still_should_stop && does_anybody_have_an_opinion) { 4095 // We've been asked to continue, so do that here. 4096 SetRestarted(true); 4097 // Use the public resume method here, since this is just extending a 4098 // public resume. 4099 process_sp->PrivateResume(); 4100 } else { 4101 bool hijacked = 4102 process_sp->IsHijackedForEvent(eBroadcastBitStateChanged) && 4103 !process_sp->StateChangedIsHijackedForSynchronousResume(); 4104 4105 if (!hijacked) { 4106 // If we didn't restart, run the Stop Hooks here. 4107 // Don't do that if state changed events aren't hooked up to the 4108 // public (or SyncResume) broadcasters. StopHooks are just for 4109 // real public stops. They might also restart the target, 4110 // so watch for that. 4111 process_sp->GetTarget().RunStopHooks(); 4112 if (process_sp->GetPrivateState() == eStateRunning) 4113 SetRestarted(true); 4114 } 4115 } 4116 } 4117 } 4118 } 4119 4120 void Process::ProcessEventData::Dump(Stream *s) const { 4121 ProcessSP process_sp(m_process_wp.lock()); 4122 4123 if (process_sp) 4124 s->Printf(" process = %p (pid = %" PRIu64 "), ", 4125 static_cast<void *>(process_sp.get()), process_sp->GetID()); 4126 else 4127 s->PutCString(" process = NULL, "); 4128 4129 s->Printf("state = %s", StateAsCString(GetState())); 4130 } 4131 4132 const Process::ProcessEventData * 4133 Process::ProcessEventData::GetEventDataFromEvent(const Event *event_ptr) { 4134 if (event_ptr) { 4135 const EventData *event_data = event_ptr->GetData(); 4136 if (event_data && 4137 event_data->GetFlavor() == ProcessEventData::GetFlavorString()) 4138 return static_cast<const ProcessEventData *>(event_ptr->GetData()); 4139 } 4140 return nullptr; 4141 } 4142 4143 ProcessSP 4144 Process::ProcessEventData::GetProcessFromEvent(const Event *event_ptr) { 4145 ProcessSP process_sp; 4146 const ProcessEventData *data = GetEventDataFromEvent(event_ptr); 4147 if (data) 4148 process_sp = data->GetProcessSP(); 4149 return process_sp; 4150 } 4151 4152 StateType Process::ProcessEventData::GetStateFromEvent(const Event *event_ptr) { 4153 const ProcessEventData *data = GetEventDataFromEvent(event_ptr); 4154 if (data == nullptr) 4155 return eStateInvalid; 4156 else 4157 return data->GetState(); 4158 } 4159 4160 bool Process::ProcessEventData::GetRestartedFromEvent(const Event *event_ptr) { 4161 const ProcessEventData *data = GetEventDataFromEvent(event_ptr); 4162 if (data == nullptr) 4163 return false; 4164 else 4165 return data->GetRestarted(); 4166 } 4167 4168 void Process::ProcessEventData::SetRestartedInEvent(Event *event_ptr, 4169 bool new_value) { 4170 ProcessEventData *data = 4171 const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); 4172 if (data != nullptr) 4173 data->SetRestarted(new_value); 4174 } 4175 4176 size_t 4177 Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr) { 4178 ProcessEventData *data = 4179 const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); 4180 if (data != nullptr) 4181 return data->GetNumRestartedReasons(); 4182 else 4183 return 0; 4184 } 4185 4186 const char * 4187 Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr, 4188 size_t idx) { 4189 ProcessEventData *data = 4190 const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); 4191 if (data != nullptr) 4192 return data->GetRestartedReasonAtIndex(idx); 4193 else 4194 return nullptr; 4195 } 4196 4197 void Process::ProcessEventData::AddRestartedReason(Event *event_ptr, 4198 const char *reason) { 4199 ProcessEventData *data = 4200 const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); 4201 if (data != nullptr) 4202 data->AddRestartedReason(reason); 4203 } 4204 4205 bool Process::ProcessEventData::GetInterruptedFromEvent( 4206 const Event *event_ptr) { 4207 const ProcessEventData *data = GetEventDataFromEvent(event_ptr); 4208 if (data == nullptr) 4209 return false; 4210 else 4211 return data->GetInterrupted(); 4212 } 4213 4214 void Process::ProcessEventData::SetInterruptedInEvent(Event *event_ptr, 4215 bool new_value) { 4216 ProcessEventData *data = 4217 const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); 4218 if (data != nullptr) 4219 data->SetInterrupted(new_value); 4220 } 4221 4222 bool Process::ProcessEventData::SetUpdateStateOnRemoval(Event *event_ptr) { 4223 ProcessEventData *data = 4224 const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); 4225 if (data) { 4226 data->SetUpdateStateOnRemoval(); 4227 return true; 4228 } 4229 return false; 4230 } 4231 4232 lldb::TargetSP Process::CalculateTarget() { return m_target_wp.lock(); } 4233 4234 void Process::CalculateExecutionContext(ExecutionContext &exe_ctx) { 4235 exe_ctx.SetTargetPtr(&GetTarget()); 4236 exe_ctx.SetProcessPtr(this); 4237 exe_ctx.SetThreadPtr(nullptr); 4238 exe_ctx.SetFramePtr(nullptr); 4239 } 4240 4241 // uint32_t 4242 // Process::ListProcessesMatchingName (const char *name, StringList &matches, 4243 // std::vector<lldb::pid_t> &pids) 4244 //{ 4245 // return 0; 4246 //} 4247 // 4248 // ArchSpec 4249 // Process::GetArchSpecForExistingProcess (lldb::pid_t pid) 4250 //{ 4251 // return Host::GetArchSpecForExistingProcess (pid); 4252 //} 4253 // 4254 // ArchSpec 4255 // Process::GetArchSpecForExistingProcess (const char *process_name) 4256 //{ 4257 // return Host::GetArchSpecForExistingProcess (process_name); 4258 //} 4259 4260 void Process::AppendSTDOUT(const char *s, size_t len) { 4261 std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex); 4262 m_stdout_data.append(s, len); 4263 BroadcastEventIfUnique(eBroadcastBitSTDOUT, 4264 new ProcessEventData(shared_from_this(), GetState())); 4265 } 4266 4267 void Process::AppendSTDERR(const char *s, size_t len) { 4268 std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex); 4269 m_stderr_data.append(s, len); 4270 BroadcastEventIfUnique(eBroadcastBitSTDERR, 4271 new ProcessEventData(shared_from_this(), GetState())); 4272 } 4273 4274 void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) { 4275 std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex); 4276 m_profile_data.push_back(one_profile_data); 4277 BroadcastEventIfUnique(eBroadcastBitProfileData, 4278 new ProcessEventData(shared_from_this(), GetState())); 4279 } 4280 4281 void Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp, 4282 const StructuredDataPluginSP &plugin_sp) { 4283 BroadcastEvent( 4284 eBroadcastBitStructuredData, 4285 new EventDataStructuredData(shared_from_this(), object_sp, plugin_sp)); 4286 } 4287 4288 StructuredDataPluginSP 4289 Process::GetStructuredDataPlugin(ConstString type_name) const { 4290 auto find_it = m_structured_data_plugin_map.find(type_name); 4291 if (find_it != m_structured_data_plugin_map.end()) 4292 return find_it->second; 4293 else 4294 return StructuredDataPluginSP(); 4295 } 4296 4297 size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) { 4298 std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex); 4299 if (m_profile_data.empty()) 4300 return 0; 4301 4302 std::string &one_profile_data = m_profile_data.front(); 4303 size_t bytes_available = one_profile_data.size(); 4304 if (bytes_available > 0) { 4305 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 4306 if (log) 4307 log->Printf("Process::GetProfileData (buf = %p, size = %" PRIu64 ")", 4308 static_cast<void *>(buf), static_cast<uint64_t>(buf_size)); 4309 if (bytes_available > buf_size) { 4310 memcpy(buf, one_profile_data.c_str(), buf_size); 4311 one_profile_data.erase(0, buf_size); 4312 bytes_available = buf_size; 4313 } else { 4314 memcpy(buf, one_profile_data.c_str(), bytes_available); 4315 m_profile_data.erase(m_profile_data.begin()); 4316 } 4317 } 4318 return bytes_available; 4319 } 4320 4321 // Process STDIO 4322 4323 size_t Process::GetSTDOUT(char *buf, size_t buf_size, Status &error) { 4324 std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex); 4325 size_t bytes_available = m_stdout_data.size(); 4326 if (bytes_available > 0) { 4327 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 4328 if (log) 4329 log->Printf("Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")", 4330 static_cast<void *>(buf), static_cast<uint64_t>(buf_size)); 4331 if (bytes_available > buf_size) { 4332 memcpy(buf, m_stdout_data.c_str(), buf_size); 4333 m_stdout_data.erase(0, buf_size); 4334 bytes_available = buf_size; 4335 } else { 4336 memcpy(buf, m_stdout_data.c_str(), bytes_available); 4337 m_stdout_data.clear(); 4338 } 4339 } 4340 return bytes_available; 4341 } 4342 4343 size_t Process::GetSTDERR(char *buf, size_t buf_size, Status &error) { 4344 std::lock_guard<std::recursive_mutex> gaurd(m_stdio_communication_mutex); 4345 size_t bytes_available = m_stderr_data.size(); 4346 if (bytes_available > 0) { 4347 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 4348 if (log) 4349 log->Printf("Process::GetSTDERR (buf = %p, size = %" PRIu64 ")", 4350 static_cast<void *>(buf), static_cast<uint64_t>(buf_size)); 4351 if (bytes_available > buf_size) { 4352 memcpy(buf, m_stderr_data.c_str(), buf_size); 4353 m_stderr_data.erase(0, buf_size); 4354 bytes_available = buf_size; 4355 } else { 4356 memcpy(buf, m_stderr_data.c_str(), bytes_available); 4357 m_stderr_data.clear(); 4358 } 4359 } 4360 return bytes_available; 4361 } 4362 4363 void Process::STDIOReadThreadBytesReceived(void *baton, const void *src, 4364 size_t src_len) { 4365 Process *process = (Process *)baton; 4366 process->AppendSTDOUT(static_cast<const char *>(src), src_len); 4367 } 4368 4369 class IOHandlerProcessSTDIO : public IOHandler { 4370 public: 4371 IOHandlerProcessSTDIO(Process *process, int write_fd) 4372 : IOHandler(process->GetTarget().GetDebugger(), 4373 IOHandler::Type::ProcessIO), 4374 m_process(process), m_write_file(write_fd, false) { 4375 m_pipe.CreateNew(false); 4376 m_read_file.SetDescriptor(GetInputFD(), false); 4377 } 4378 4379 ~IOHandlerProcessSTDIO() override = default; 4380 4381 // Each IOHandler gets to run until it is done. It should read data from the 4382 // "in" and place output into "out" and "err and return when done. 4383 void Run() override { 4384 if (!m_read_file.IsValid() || !m_write_file.IsValid() || 4385 !m_pipe.CanRead() || !m_pipe.CanWrite()) { 4386 SetIsDone(true); 4387 return; 4388 } 4389 4390 SetIsDone(false); 4391 const int read_fd = m_read_file.GetDescriptor(); 4392 TerminalState terminal_state; 4393 terminal_state.Save(read_fd, false); 4394 Terminal terminal(read_fd); 4395 terminal.SetCanonical(false); 4396 terminal.SetEcho(false); 4397 // FD_ZERO, FD_SET are not supported on windows 4398 #ifndef _WIN32 4399 const int pipe_read_fd = m_pipe.GetReadFileDescriptor(); 4400 m_is_running = true; 4401 while (!GetIsDone()) { 4402 SelectHelper select_helper; 4403 select_helper.FDSetRead(read_fd); 4404 select_helper.FDSetRead(pipe_read_fd); 4405 Status error = select_helper.Select(); 4406 4407 if (error.Fail()) { 4408 SetIsDone(true); 4409 } else { 4410 char ch = 0; 4411 size_t n; 4412 if (select_helper.FDIsSetRead(read_fd)) { 4413 n = 1; 4414 if (m_read_file.Read(&ch, n).Success() && n == 1) { 4415 if (m_write_file.Write(&ch, n).Fail() || n != 1) 4416 SetIsDone(true); 4417 } else 4418 SetIsDone(true); 4419 } 4420 if (select_helper.FDIsSetRead(pipe_read_fd)) { 4421 size_t bytes_read; 4422 // Consume the interrupt byte 4423 Status error = m_pipe.Read(&ch, 1, bytes_read); 4424 if (error.Success()) { 4425 switch (ch) { 4426 case 'q': 4427 SetIsDone(true); 4428 break; 4429 case 'i': 4430 if (StateIsRunningState(m_process->GetState())) 4431 m_process->SendAsyncInterrupt(); 4432 break; 4433 } 4434 } 4435 } 4436 } 4437 } 4438 m_is_running = false; 4439 #endif 4440 terminal_state.Restore(); 4441 } 4442 4443 void Cancel() override { 4444 SetIsDone(true); 4445 // Only write to our pipe to cancel if we are in 4446 // IOHandlerProcessSTDIO::Run(). We can end up with a python command that 4447 // is being run from the command interpreter: 4448 // 4449 // (lldb) step_process_thousands_of_times 4450 // 4451 // In this case the command interpreter will be in the middle of handling 4452 // the command and if the process pushes and pops the IOHandler thousands 4453 // of times, we can end up writing to m_pipe without ever consuming the 4454 // bytes from the pipe in IOHandlerProcessSTDIO::Run() and end up 4455 // deadlocking when the pipe gets fed up and blocks until data is consumed. 4456 if (m_is_running) { 4457 char ch = 'q'; // Send 'q' for quit 4458 size_t bytes_written = 0; 4459 m_pipe.Write(&ch, 1, bytes_written); 4460 } 4461 } 4462 4463 bool Interrupt() override { 4464 // Do only things that are safe to do in an interrupt context (like in a 4465 // SIGINT handler), like write 1 byte to a file descriptor. This will 4466 // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte 4467 // that was written to the pipe and then call 4468 // m_process->SendAsyncInterrupt() from a much safer location in code. 4469 if (m_active) { 4470 char ch = 'i'; // Send 'i' for interrupt 4471 size_t bytes_written = 0; 4472 Status result = m_pipe.Write(&ch, 1, bytes_written); 4473 return result.Success(); 4474 } else { 4475 // This IOHandler might be pushed on the stack, but not being run 4476 // currently so do the right thing if we aren't actively watching for 4477 // STDIN by sending the interrupt to the process. Otherwise the write to 4478 // the pipe above would do nothing. This can happen when the command 4479 // interpreter is running and gets a "expression ...". It will be on the 4480 // IOHandler thread and sending the input is complete to the delegate 4481 // which will cause the expression to run, which will push the process IO 4482 // handler, but not run it. 4483 4484 if (StateIsRunningState(m_process->GetState())) { 4485 m_process->SendAsyncInterrupt(); 4486 return true; 4487 } 4488 } 4489 return false; 4490 } 4491 4492 void GotEOF() override {} 4493 4494 protected: 4495 Process *m_process; 4496 File m_read_file; // Read from this file (usually actual STDIN for LLDB 4497 File m_write_file; // Write to this file (usually the master pty for getting 4498 // io to debuggee) 4499 Pipe m_pipe; 4500 std::atomic<bool> m_is_running{false}; 4501 }; 4502 4503 void Process::SetSTDIOFileDescriptor(int fd) { 4504 // First set up the Read Thread for reading/handling process I/O 4505 4506 std::unique_ptr<ConnectionFileDescriptor> conn_up( 4507 new ConnectionFileDescriptor(fd, true)); 4508 4509 if (conn_up) { 4510 m_stdio_communication.SetConnection(conn_up.release()); 4511 if (m_stdio_communication.IsConnected()) { 4512 m_stdio_communication.SetReadThreadBytesReceivedCallback( 4513 STDIOReadThreadBytesReceived, this); 4514 m_stdio_communication.StartReadThread(); 4515 4516 // Now read thread is set up, set up input reader. 4517 4518 if (!m_process_input_reader) 4519 m_process_input_reader = 4520 std::make_shared<IOHandlerProcessSTDIO>(this, fd); 4521 } 4522 } 4523 } 4524 4525 bool Process::ProcessIOHandlerIsActive() { 4526 IOHandlerSP io_handler_sp(m_process_input_reader); 4527 if (io_handler_sp) 4528 return GetTarget().GetDebugger().IsTopIOHandler(io_handler_sp); 4529 return false; 4530 } 4531 bool Process::PushProcessIOHandler() { 4532 IOHandlerSP io_handler_sp(m_process_input_reader); 4533 if (io_handler_sp) { 4534 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 4535 if (log) 4536 log->Printf("Process::%s pushing IO handler", __FUNCTION__); 4537 4538 io_handler_sp->SetIsDone(false); 4539 // If we evaluate an utility function, then we don't cancel the current 4540 // IOHandler. Our IOHandler is non-interactive and shouldn't disturb the 4541 // existing IOHandler that potentially provides the user interface (e.g. 4542 // the IOHandler for Editline). 4543 bool cancel_top_handler = !m_mod_id.IsRunningUtilityFunction(); 4544 GetTarget().GetDebugger().PushIOHandler(io_handler_sp, cancel_top_handler); 4545 return true; 4546 } 4547 return false; 4548 } 4549 4550 bool Process::PopProcessIOHandler() { 4551 IOHandlerSP io_handler_sp(m_process_input_reader); 4552 if (io_handler_sp) 4553 return GetTarget().GetDebugger().PopIOHandler(io_handler_sp); 4554 return false; 4555 } 4556 4557 // The process needs to know about installed plug-ins 4558 void Process::SettingsInitialize() { Thread::SettingsInitialize(); } 4559 4560 void Process::SettingsTerminate() { Thread::SettingsTerminate(); } 4561 4562 namespace { 4563 // RestorePlanState is used to record the "is private", "is master" and "okay 4564 // to discard" fields of the plan we are running, and reset it on Clean or on 4565 // destruction. It will only reset the state once, so you can call Clean and 4566 // then monkey with the state and it won't get reset on you again. 4567 4568 class RestorePlanState { 4569 public: 4570 RestorePlanState(lldb::ThreadPlanSP thread_plan_sp) 4571 : m_thread_plan_sp(thread_plan_sp), m_already_reset(false) { 4572 if (m_thread_plan_sp) { 4573 m_private = m_thread_plan_sp->GetPrivate(); 4574 m_is_master = m_thread_plan_sp->IsMasterPlan(); 4575 m_okay_to_discard = m_thread_plan_sp->OkayToDiscard(); 4576 } 4577 } 4578 4579 ~RestorePlanState() { Clean(); } 4580 4581 void Clean() { 4582 if (!m_already_reset && m_thread_plan_sp) { 4583 m_already_reset = true; 4584 m_thread_plan_sp->SetPrivate(m_private); 4585 m_thread_plan_sp->SetIsMasterPlan(m_is_master); 4586 m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard); 4587 } 4588 } 4589 4590 private: 4591 lldb::ThreadPlanSP m_thread_plan_sp; 4592 bool m_already_reset; 4593 bool m_private; 4594 bool m_is_master; 4595 bool m_okay_to_discard; 4596 }; 4597 } // anonymous namespace 4598 4599 static microseconds 4600 GetOneThreadExpressionTimeout(const EvaluateExpressionOptions &options) { 4601 const milliseconds default_one_thread_timeout(250); 4602 4603 // If the overall wait is forever, then we don't need to worry about it. 4604 if (!options.GetTimeout()) { 4605 return options.GetOneThreadTimeout() ? *options.GetOneThreadTimeout() 4606 : default_one_thread_timeout; 4607 } 4608 4609 // If the one thread timeout is set, use it. 4610 if (options.GetOneThreadTimeout()) 4611 return *options.GetOneThreadTimeout(); 4612 4613 // Otherwise use half the total timeout, bounded by the 4614 // default_one_thread_timeout. 4615 return std::min<microseconds>(default_one_thread_timeout, 4616 *options.GetTimeout() / 2); 4617 } 4618 4619 static Timeout<std::micro> 4620 GetExpressionTimeout(const EvaluateExpressionOptions &options, 4621 bool before_first_timeout) { 4622 // If we are going to run all threads the whole time, or if we are only going 4623 // to run one thread, we can just return the overall timeout. 4624 if (!options.GetStopOthers() || !options.GetTryAllThreads()) 4625 return options.GetTimeout(); 4626 4627 if (before_first_timeout) 4628 return GetOneThreadExpressionTimeout(options); 4629 4630 if (!options.GetTimeout()) 4631 return llvm::None; 4632 else 4633 return *options.GetTimeout() - GetOneThreadExpressionTimeout(options); 4634 } 4635 4636 static llvm::Optional<ExpressionResults> 4637 HandleStoppedEvent(Thread &thread, const ThreadPlanSP &thread_plan_sp, 4638 RestorePlanState &restorer, const EventSP &event_sp, 4639 EventSP &event_to_broadcast_sp, 4640 const EvaluateExpressionOptions &options, bool handle_interrupts) { 4641 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS); 4642 4643 ThreadPlanSP plan = thread.GetCompletedPlan(); 4644 if (plan == thread_plan_sp && plan->PlanSucceeded()) { 4645 LLDB_LOG(log, "execution completed successfully"); 4646 4647 // Restore the plan state so it will get reported as intended when we are 4648 // done. 4649 restorer.Clean(); 4650 return eExpressionCompleted; 4651 } 4652 4653 StopInfoSP stop_info_sp = thread.GetStopInfo(); 4654 if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint && 4655 stop_info_sp->ShouldNotify(event_sp.get())) { 4656 LLDB_LOG(log, "stopped for breakpoint: {0}.", stop_info_sp->GetDescription()); 4657 if (!options.DoesIgnoreBreakpoints()) { 4658 // Restore the plan state and then force Private to false. We are going 4659 // to stop because of this plan so we need it to become a public plan or 4660 // it won't report correctly when we continue to its termination later 4661 // on. 4662 restorer.Clean(); 4663 thread_plan_sp->SetPrivate(false); 4664 event_to_broadcast_sp = event_sp; 4665 } 4666 return eExpressionHitBreakpoint; 4667 } 4668 4669 if (!handle_interrupts && 4670 Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get())) 4671 return llvm::None; 4672 4673 LLDB_LOG(log, "thread plan did not successfully complete"); 4674 if (!options.DoesUnwindOnError()) 4675 event_to_broadcast_sp = event_sp; 4676 return eExpressionInterrupted; 4677 } 4678 4679 ExpressionResults 4680 Process::RunThreadPlan(ExecutionContext &exe_ctx, 4681 lldb::ThreadPlanSP &thread_plan_sp, 4682 const EvaluateExpressionOptions &options, 4683 DiagnosticManager &diagnostic_manager) { 4684 ExpressionResults return_value = eExpressionSetupError; 4685 4686 std::lock_guard<std::mutex> run_thread_plan_locker(m_run_thread_plan_lock); 4687 4688 if (!thread_plan_sp) { 4689 diagnostic_manager.PutString( 4690 eDiagnosticSeverityError, 4691 "RunThreadPlan called with empty thread plan."); 4692 return eExpressionSetupError; 4693 } 4694 4695 if (!thread_plan_sp->ValidatePlan(nullptr)) { 4696 diagnostic_manager.PutString( 4697 eDiagnosticSeverityError, 4698 "RunThreadPlan called with an invalid thread plan."); 4699 return eExpressionSetupError; 4700 } 4701 4702 if (exe_ctx.GetProcessPtr() != this) { 4703 diagnostic_manager.PutString(eDiagnosticSeverityError, 4704 "RunThreadPlan called on wrong process."); 4705 return eExpressionSetupError; 4706 } 4707 4708 Thread *thread = exe_ctx.GetThreadPtr(); 4709 if (thread == nullptr) { 4710 diagnostic_manager.PutString(eDiagnosticSeverityError, 4711 "RunThreadPlan called with invalid thread."); 4712 return eExpressionSetupError; 4713 } 4714 4715 // We need to change some of the thread plan attributes for the thread plan 4716 // runner. This will restore them when we are done: 4717 4718 RestorePlanState thread_plan_restorer(thread_plan_sp); 4719 4720 // We rely on the thread plan we are running returning "PlanCompleted" if 4721 // when it successfully completes. For that to be true the plan can't be 4722 // private - since private plans suppress themselves in the GetCompletedPlan 4723 // call. 4724 4725 thread_plan_sp->SetPrivate(false); 4726 4727 // The plans run with RunThreadPlan also need to be terminal master plans or 4728 // when they are done we will end up asking the plan above us whether we 4729 // should stop, which may give the wrong answer. 4730 4731 thread_plan_sp->SetIsMasterPlan(true); 4732 thread_plan_sp->SetOkayToDiscard(false); 4733 4734 // If we are running some utility expression for LLDB, we now have to mark 4735 // this in the ProcesModID of this process. This RAII takes care of marking 4736 // and reverting the mark it once we are done running the expression. 4737 UtilityFunctionScope util_scope(options.IsForUtilityExpr() ? this : nullptr); 4738 4739 if (m_private_state.GetValue() != eStateStopped) { 4740 diagnostic_manager.PutString( 4741 eDiagnosticSeverityError, 4742 "RunThreadPlan called while the private state was not stopped."); 4743 return eExpressionSetupError; 4744 } 4745 4746 // Save the thread & frame from the exe_ctx for restoration after we run 4747 const uint32_t thread_idx_id = thread->GetIndexID(); 4748 StackFrameSP selected_frame_sp = thread->GetSelectedFrame(); 4749 if (!selected_frame_sp) { 4750 thread->SetSelectedFrame(nullptr); 4751 selected_frame_sp = thread->GetSelectedFrame(); 4752 if (!selected_frame_sp) { 4753 diagnostic_manager.Printf( 4754 eDiagnosticSeverityError, 4755 "RunThreadPlan called without a selected frame on thread %d", 4756 thread_idx_id); 4757 return eExpressionSetupError; 4758 } 4759 } 4760 4761 // Make sure the timeout values make sense. The one thread timeout needs to 4762 // be smaller than the overall timeout. 4763 if (options.GetOneThreadTimeout() && options.GetTimeout() && 4764 *options.GetTimeout() < *options.GetOneThreadTimeout()) { 4765 diagnostic_manager.PutString(eDiagnosticSeverityError, 4766 "RunThreadPlan called with one thread " 4767 "timeout greater than total timeout"); 4768 return eExpressionSetupError; 4769 } 4770 4771 StackID ctx_frame_id = selected_frame_sp->GetStackID(); 4772 4773 // N.B. Running the target may unset the currently selected thread and frame. 4774 // We don't want to do that either, so we should arrange to reset them as 4775 // well. 4776 4777 lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread(); 4778 4779 uint32_t selected_tid; 4780 StackID selected_stack_id; 4781 if (selected_thread_sp) { 4782 selected_tid = selected_thread_sp->GetIndexID(); 4783 selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID(); 4784 } else { 4785 selected_tid = LLDB_INVALID_THREAD_ID; 4786 } 4787 4788 HostThread backup_private_state_thread; 4789 lldb::StateType old_state = eStateInvalid; 4790 lldb::ThreadPlanSP stopper_base_plan_sp; 4791 4792 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP | 4793 LIBLLDB_LOG_PROCESS)); 4794 if (m_private_state_thread.EqualsThread(Host::GetCurrentThread())) { 4795 // Yikes, we are running on the private state thread! So we can't wait for 4796 // public events on this thread, since we are the thread that is generating 4797 // public events. The simplest thing to do is to spin up a temporary thread 4798 // to handle private state thread events while we are fielding public 4799 // events here. 4800 if (log) 4801 log->Printf("Running thread plan on private state thread, spinning up " 4802 "another state thread to handle the events."); 4803 4804 backup_private_state_thread = m_private_state_thread; 4805 4806 // One other bit of business: we want to run just this thread plan and 4807 // anything it pushes, and then stop, returning control here. But in the 4808 // normal course of things, the plan above us on the stack would be given a 4809 // shot at the stop event before deciding to stop, and we don't want that. 4810 // So we insert a "stopper" base plan on the stack before the plan we want 4811 // to run. Since base plans always stop and return control to the user, 4812 // that will do just what we want. 4813 stopper_base_plan_sp.reset(new ThreadPlanBase(*thread)); 4814 thread->QueueThreadPlan(stopper_base_plan_sp, false); 4815 // Have to make sure our public state is stopped, since otherwise the 4816 // reporting logic below doesn't work correctly. 4817 old_state = m_public_state.GetValue(); 4818 m_public_state.SetValueNoLock(eStateStopped); 4819 4820 // Now spin up the private state thread: 4821 StartPrivateStateThread(true); 4822 } 4823 4824 thread->QueueThreadPlan( 4825 thread_plan_sp, false); // This used to pass "true" does that make sense? 4826 4827 if (options.GetDebug()) { 4828 // In this case, we aren't actually going to run, we just want to stop 4829 // right away. Flush this thread so we will refetch the stacks and show the 4830 // correct backtrace. 4831 // FIXME: To make this prettier we should invent some stop reason for this, 4832 // but that 4833 // is only cosmetic, and this functionality is only of use to lldb 4834 // developers who can live with not pretty... 4835 thread->Flush(); 4836 return eExpressionStoppedForDebug; 4837 } 4838 4839 ListenerSP listener_sp( 4840 Listener::MakeListener("lldb.process.listener.run-thread-plan")); 4841 4842 lldb::EventSP event_to_broadcast_sp; 4843 4844 { 4845 // This process event hijacker Hijacks the Public events and its destructor 4846 // makes sure that the process events get restored on exit to the function. 4847 // 4848 // If the event needs to propagate beyond the hijacker (e.g., the process 4849 // exits during execution), then the event is put into 4850 // event_to_broadcast_sp for rebroadcasting. 4851 4852 ProcessEventHijacker run_thread_plan_hijacker(*this, listener_sp); 4853 4854 if (log) { 4855 StreamString s; 4856 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 4857 log->Printf("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64 4858 " to run thread plan \"%s\".", 4859 thread->GetIndexID(), thread->GetID(), s.GetData()); 4860 } 4861 4862 bool got_event; 4863 lldb::EventSP event_sp; 4864 lldb::StateType stop_state = lldb::eStateInvalid; 4865 4866 bool before_first_timeout = true; // This is set to false the first time 4867 // that we have to halt the target. 4868 bool do_resume = true; 4869 bool handle_running_event = true; 4870 4871 // This is just for accounting: 4872 uint32_t num_resumes = 0; 4873 4874 // If we are going to run all threads the whole time, or if we are only 4875 // going to run one thread, then we don't need the first timeout. So we 4876 // pretend we are after the first timeout already. 4877 if (!options.GetStopOthers() || !options.GetTryAllThreads()) 4878 before_first_timeout = false; 4879 4880 if (log) 4881 log->Printf("Stop others: %u, try all: %u, before_first: %u.\n", 4882 options.GetStopOthers(), options.GetTryAllThreads(), 4883 before_first_timeout); 4884 4885 // This isn't going to work if there are unfetched events on the queue. Are 4886 // there cases where we might want to run the remaining events here, and 4887 // then try to call the function? That's probably being too tricky for our 4888 // own good. 4889 4890 Event *other_events = listener_sp->PeekAtNextEvent(); 4891 if (other_events != nullptr) { 4892 diagnostic_manager.PutString( 4893 eDiagnosticSeverityError, 4894 "RunThreadPlan called with pending events on the queue."); 4895 return eExpressionSetupError; 4896 } 4897 4898 // We also need to make sure that the next event is delivered. We might be 4899 // calling a function as part of a thread plan, in which case the last 4900 // delivered event could be the running event, and we don't want event 4901 // coalescing to cause us to lose OUR running event... 4902 ForceNextEventDelivery(); 4903 4904 // This while loop must exit out the bottom, there's cleanup that we need to do 4905 // when we are done. So don't call return anywhere within it. 4906 4907 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT 4908 // It's pretty much impossible to write test cases for things like: One 4909 // thread timeout expires, I go to halt, but the process already stopped on 4910 // the function call stop breakpoint. Turning on this define will make us 4911 // not fetch the first event till after the halt. So if you run a quick 4912 // function, it will have completed, and the completion event will be 4913 // waiting, when you interrupt for halt. The expression evaluation should 4914 // still succeed. 4915 bool miss_first_event = true; 4916 #endif 4917 while (true) { 4918 // We usually want to resume the process if we get to the top of the 4919 // loop. The only exception is if we get two running events with no 4920 // intervening stop, which can happen, we will just wait for then next 4921 // stop event. 4922 if (log) 4923 log->Printf("Top of while loop: do_resume: %i handle_running_event: %i " 4924 "before_first_timeout: %i.", 4925 do_resume, handle_running_event, before_first_timeout); 4926 4927 if (do_resume || handle_running_event) { 4928 // Do the initial resume and wait for the running event before going 4929 // further. 4930 4931 if (do_resume) { 4932 num_resumes++; 4933 Status resume_error = PrivateResume(); 4934 if (!resume_error.Success()) { 4935 diagnostic_manager.Printf( 4936 eDiagnosticSeverityError, 4937 "couldn't resume inferior the %d time: \"%s\".", num_resumes, 4938 resume_error.AsCString()); 4939 return_value = eExpressionSetupError; 4940 break; 4941 } 4942 } 4943 4944 got_event = 4945 listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout()); 4946 if (!got_event) { 4947 if (log) 4948 log->Printf("Process::RunThreadPlan(): didn't get any event after " 4949 "resume %" PRIu32 ", exiting.", 4950 num_resumes); 4951 4952 diagnostic_manager.Printf(eDiagnosticSeverityError, 4953 "didn't get any event after resume %" PRIu32 4954 ", exiting.", 4955 num_resumes); 4956 return_value = eExpressionSetupError; 4957 break; 4958 } 4959 4960 stop_state = 4961 Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 4962 4963 if (stop_state != eStateRunning) { 4964 bool restarted = false; 4965 4966 if (stop_state == eStateStopped) { 4967 restarted = Process::ProcessEventData::GetRestartedFromEvent( 4968 event_sp.get()); 4969 if (log) 4970 log->Printf( 4971 "Process::RunThreadPlan(): didn't get running event after " 4972 "resume %d, got %s instead (restarted: %i, do_resume: %i, " 4973 "handle_running_event: %i).", 4974 num_resumes, StateAsCString(stop_state), restarted, do_resume, 4975 handle_running_event); 4976 } 4977 4978 if (restarted) { 4979 // This is probably an overabundance of caution, I don't think I 4980 // should ever get a stopped & restarted event here. But if I do, 4981 // the best thing is to Halt and then get out of here. 4982 const bool clear_thread_plans = false; 4983 const bool use_run_lock = false; 4984 Halt(clear_thread_plans, use_run_lock); 4985 } 4986 4987 diagnostic_manager.Printf( 4988 eDiagnosticSeverityError, 4989 "didn't get running event after initial resume, got %s instead.", 4990 StateAsCString(stop_state)); 4991 return_value = eExpressionSetupError; 4992 break; 4993 } 4994 4995 if (log) 4996 log->PutCString("Process::RunThreadPlan(): resuming succeeded."); 4997 // We need to call the function synchronously, so spin waiting for it 4998 // to return. If we get interrupted while executing, we're going to 4999 // lose our context, and won't be able to gather the result at this 5000 // point. We set the timeout AFTER the resume, since the resume takes 5001 // some time and we don't want to charge that to the timeout. 5002 } else { 5003 if (log) 5004 log->PutCString("Process::RunThreadPlan(): waiting for next event."); 5005 } 5006 5007 do_resume = true; 5008 handle_running_event = true; 5009 5010 // Now wait for the process to stop again: 5011 event_sp.reset(); 5012 5013 Timeout<std::micro> timeout = 5014 GetExpressionTimeout(options, before_first_timeout); 5015 if (log) { 5016 if (timeout) { 5017 auto now = system_clock::now(); 5018 log->Printf("Process::RunThreadPlan(): about to wait - now is %s - " 5019 "endpoint is %s", 5020 llvm::to_string(now).c_str(), 5021 llvm::to_string(now + *timeout).c_str()); 5022 } else { 5023 log->Printf("Process::RunThreadPlan(): about to wait forever."); 5024 } 5025 } 5026 5027 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT 5028 // See comment above... 5029 if (miss_first_event) { 5030 usleep(1000); 5031 miss_first_event = false; 5032 got_event = false; 5033 } else 5034 #endif 5035 got_event = listener_sp->GetEvent(event_sp, timeout); 5036 5037 if (got_event) { 5038 if (event_sp) { 5039 bool keep_going = false; 5040 if (event_sp->GetType() == eBroadcastBitInterrupt) { 5041 const bool clear_thread_plans = false; 5042 const bool use_run_lock = false; 5043 Halt(clear_thread_plans, use_run_lock); 5044 return_value = eExpressionInterrupted; 5045 diagnostic_manager.PutString(eDiagnosticSeverityRemark, 5046 "execution halted by user interrupt."); 5047 if (log) 5048 log->Printf("Process::RunThreadPlan(): Got interrupted by " 5049 "eBroadcastBitInterrupted, exiting."); 5050 break; 5051 } else { 5052 stop_state = 5053 Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 5054 if (log) 5055 log->Printf( 5056 "Process::RunThreadPlan(): in while loop, got event: %s.", 5057 StateAsCString(stop_state)); 5058 5059 switch (stop_state) { 5060 case lldb::eStateStopped: { 5061 // We stopped, figure out what we are going to do now. 5062 ThreadSP thread_sp = 5063 GetThreadList().FindThreadByIndexID(thread_idx_id); 5064 if (!thread_sp) { 5065 // Ooh, our thread has vanished. Unlikely that this was 5066 // successful execution... 5067 if (log) 5068 log->Printf("Process::RunThreadPlan(): execution completed " 5069 "but our thread (index-id=%u) has vanished.", 5070 thread_idx_id); 5071 return_value = eExpressionInterrupted; 5072 } else if (Process::ProcessEventData::GetRestartedFromEvent( 5073 event_sp.get())) { 5074 // If we were restarted, we just need to go back up to fetch 5075 // another event. 5076 if (log) { 5077 log->Printf("Process::RunThreadPlan(): Got a stop and " 5078 "restart, so we'll continue waiting."); 5079 } 5080 keep_going = true; 5081 do_resume = false; 5082 handle_running_event = true; 5083 } else { 5084 const bool handle_interrupts = true; 5085 return_value = *HandleStoppedEvent( 5086 *thread, thread_plan_sp, thread_plan_restorer, event_sp, 5087 event_to_broadcast_sp, options, handle_interrupts); 5088 } 5089 } break; 5090 5091 case lldb::eStateRunning: 5092 // This shouldn't really happen, but sometimes we do get two 5093 // running events without an intervening stop, and in that case 5094 // we should just go back to waiting for the stop. 5095 do_resume = false; 5096 keep_going = true; 5097 handle_running_event = false; 5098 break; 5099 5100 default: 5101 if (log) 5102 log->Printf("Process::RunThreadPlan(): execution stopped with " 5103 "unexpected state: %s.", 5104 StateAsCString(stop_state)); 5105 5106 if (stop_state == eStateExited) 5107 event_to_broadcast_sp = event_sp; 5108 5109 diagnostic_manager.PutString( 5110 eDiagnosticSeverityError, 5111 "execution stopped with unexpected state."); 5112 return_value = eExpressionInterrupted; 5113 break; 5114 } 5115 } 5116 5117 if (keep_going) 5118 continue; 5119 else 5120 break; 5121 } else { 5122 if (log) 5123 log->PutCString("Process::RunThreadPlan(): got_event was true, but " 5124 "the event pointer was null. How odd..."); 5125 return_value = eExpressionInterrupted; 5126 break; 5127 } 5128 } else { 5129 // If we didn't get an event that means we've timed out... We will 5130 // interrupt the process here. Depending on what we were asked to do 5131 // we will either exit, or try with all threads running for the same 5132 // timeout. 5133 5134 if (log) { 5135 if (options.GetTryAllThreads()) { 5136 if (before_first_timeout) { 5137 LLDB_LOG(log, 5138 "Running function with one thread timeout timed out."); 5139 } else 5140 LLDB_LOG(log, "Restarting function with all threads enabled and " 5141 "timeout: {0} timed out, abandoning execution.", 5142 timeout); 5143 } else 5144 LLDB_LOG(log, "Running function with timeout: {0} timed out, " 5145 "abandoning execution.", 5146 timeout); 5147 } 5148 5149 // It is possible that between the time we issued the Halt, and we get 5150 // around to calling Halt the target could have stopped. That's fine, 5151 // Halt will figure that out and send the appropriate Stopped event. 5152 // BUT it is also possible that we stopped & restarted (e.g. hit a 5153 // signal with "stop" set to false.) In 5154 // that case, we'll get the stopped & restarted event, and we should go 5155 // back to waiting for the Halt's stopped event. That's what this 5156 // while loop does. 5157 5158 bool back_to_top = true; 5159 uint32_t try_halt_again = 0; 5160 bool do_halt = true; 5161 const uint32_t num_retries = 5; 5162 while (try_halt_again < num_retries) { 5163 Status halt_error; 5164 if (do_halt) { 5165 if (log) 5166 log->Printf("Process::RunThreadPlan(): Running Halt."); 5167 const bool clear_thread_plans = false; 5168 const bool use_run_lock = false; 5169 Halt(clear_thread_plans, use_run_lock); 5170 } 5171 if (halt_error.Success()) { 5172 if (log) 5173 log->PutCString("Process::RunThreadPlan(): Halt succeeded."); 5174 5175 got_event = 5176 listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout()); 5177 5178 if (got_event) { 5179 stop_state = 5180 Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 5181 if (log) { 5182 log->Printf("Process::RunThreadPlan(): Stopped with event: %s", 5183 StateAsCString(stop_state)); 5184 if (stop_state == lldb::eStateStopped && 5185 Process::ProcessEventData::GetInterruptedFromEvent( 5186 event_sp.get())) 5187 log->PutCString(" Event was the Halt interruption event."); 5188 } 5189 5190 if (stop_state == lldb::eStateStopped) { 5191 if (Process::ProcessEventData::GetRestartedFromEvent( 5192 event_sp.get())) { 5193 if (log) 5194 log->PutCString("Process::RunThreadPlan(): Went to halt " 5195 "but got a restarted event, there must be " 5196 "an un-restarted stopped event so try " 5197 "again... " 5198 "Exiting wait loop."); 5199 try_halt_again++; 5200 do_halt = false; 5201 continue; 5202 } 5203 5204 // Between the time we initiated the Halt and the time we 5205 // delivered it, the process could have already finished its 5206 // job. Check that here: 5207 const bool handle_interrupts = false; 5208 if (auto result = HandleStoppedEvent( 5209 *thread, thread_plan_sp, thread_plan_restorer, event_sp, 5210 event_to_broadcast_sp, options, handle_interrupts)) { 5211 return_value = *result; 5212 back_to_top = false; 5213 break; 5214 } 5215 5216 if (!options.GetTryAllThreads()) { 5217 if (log) 5218 log->PutCString("Process::RunThreadPlan(): try_all_threads " 5219 "was false, we stopped so now we're " 5220 "quitting."); 5221 return_value = eExpressionInterrupted; 5222 back_to_top = false; 5223 break; 5224 } 5225 5226 if (before_first_timeout) { 5227 // Set all the other threads to run, and return to the top of 5228 // the loop, which will continue; 5229 before_first_timeout = false; 5230 thread_plan_sp->SetStopOthers(false); 5231 if (log) 5232 log->PutCString( 5233 "Process::RunThreadPlan(): about to resume."); 5234 5235 back_to_top = true; 5236 break; 5237 } else { 5238 // Running all threads failed, so return Interrupted. 5239 if (log) 5240 log->PutCString("Process::RunThreadPlan(): running all " 5241 "threads timed out."); 5242 return_value = eExpressionInterrupted; 5243 back_to_top = false; 5244 break; 5245 } 5246 } 5247 } else { 5248 if (log) 5249 log->PutCString("Process::RunThreadPlan(): halt said it " 5250 "succeeded, but I got no event. " 5251 "I'm getting out of here passing Interrupted."); 5252 return_value = eExpressionInterrupted; 5253 back_to_top = false; 5254 break; 5255 } 5256 } else { 5257 try_halt_again++; 5258 continue; 5259 } 5260 } 5261 5262 if (!back_to_top || try_halt_again > num_retries) 5263 break; 5264 else 5265 continue; 5266 } 5267 } // END WAIT LOOP 5268 5269 // If we had to start up a temporary private state thread to run this 5270 // thread plan, shut it down now. 5271 if (backup_private_state_thread.IsJoinable()) { 5272 StopPrivateStateThread(); 5273 Status error; 5274 m_private_state_thread = backup_private_state_thread; 5275 if (stopper_base_plan_sp) { 5276 thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp); 5277 } 5278 if (old_state != eStateInvalid) 5279 m_public_state.SetValueNoLock(old_state); 5280 } 5281 5282 if (return_value != eExpressionCompleted && log) { 5283 // Print a backtrace into the log so we can figure out where we are: 5284 StreamString s; 5285 s.PutCString("Thread state after unsuccessful completion: \n"); 5286 thread->GetStackFrameStatus(s, 0, UINT32_MAX, true, UINT32_MAX); 5287 log->PutString(s.GetString()); 5288 } 5289 // Restore the thread state if we are going to discard the plan execution. 5290 // There are three cases where this could happen: 1) The execution 5291 // successfully completed 2) We hit a breakpoint, and ignore_breakpoints 5292 // was true 3) We got some other error, and discard_on_error was true 5293 bool should_unwind = (return_value == eExpressionInterrupted && 5294 options.DoesUnwindOnError()) || 5295 (return_value == eExpressionHitBreakpoint && 5296 options.DoesIgnoreBreakpoints()); 5297 5298 if (return_value == eExpressionCompleted || should_unwind) { 5299 thread_plan_sp->RestoreThreadState(); 5300 } 5301 5302 // Now do some processing on the results of the run: 5303 if (return_value == eExpressionInterrupted || 5304 return_value == eExpressionHitBreakpoint) { 5305 if (log) { 5306 StreamString s; 5307 if (event_sp) 5308 event_sp->Dump(&s); 5309 else { 5310 log->PutCString("Process::RunThreadPlan(): Stop event that " 5311 "interrupted us is NULL."); 5312 } 5313 5314 StreamString ts; 5315 5316 const char *event_explanation = nullptr; 5317 5318 do { 5319 if (!event_sp) { 5320 event_explanation = "<no event>"; 5321 break; 5322 } else if (event_sp->GetType() == eBroadcastBitInterrupt) { 5323 event_explanation = "<user interrupt>"; 5324 break; 5325 } else { 5326 const Process::ProcessEventData *event_data = 5327 Process::ProcessEventData::GetEventDataFromEvent( 5328 event_sp.get()); 5329 5330 if (!event_data) { 5331 event_explanation = "<no event data>"; 5332 break; 5333 } 5334 5335 Process *process = event_data->GetProcessSP().get(); 5336 5337 if (!process) { 5338 event_explanation = "<no process>"; 5339 break; 5340 } 5341 5342 ThreadList &thread_list = process->GetThreadList(); 5343 5344 uint32_t num_threads = thread_list.GetSize(); 5345 uint32_t thread_index; 5346 5347 ts.Printf("<%u threads> ", num_threads); 5348 5349 for (thread_index = 0; thread_index < num_threads; ++thread_index) { 5350 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get(); 5351 5352 if (!thread) { 5353 ts.Printf("<?> "); 5354 continue; 5355 } 5356 5357 ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID()); 5358 RegisterContext *register_context = 5359 thread->GetRegisterContext().get(); 5360 5361 if (register_context) 5362 ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC()); 5363 else 5364 ts.Printf("[ip unknown] "); 5365 5366 // Show the private stop info here, the public stop info will be 5367 // from the last natural stop. 5368 lldb::StopInfoSP stop_info_sp = thread->GetPrivateStopInfo(); 5369 if (stop_info_sp) { 5370 const char *stop_desc = stop_info_sp->GetDescription(); 5371 if (stop_desc) 5372 ts.PutCString(stop_desc); 5373 } 5374 ts.Printf(">"); 5375 } 5376 5377 event_explanation = ts.GetData(); 5378 } 5379 } while (false); 5380 5381 if (event_explanation) 5382 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", 5383 s.GetData(), event_explanation); 5384 else 5385 log->Printf("Process::RunThreadPlan(): execution interrupted: %s", 5386 s.GetData()); 5387 } 5388 5389 if (should_unwind) { 5390 if (log) 5391 log->Printf("Process::RunThreadPlan: ExecutionInterrupted - " 5392 "discarding thread plans up to %p.", 5393 static_cast<void *>(thread_plan_sp.get())); 5394 thread->DiscardThreadPlansUpToPlan(thread_plan_sp); 5395 } else { 5396 if (log) 5397 log->Printf("Process::RunThreadPlan: ExecutionInterrupted - for " 5398 "plan: %p not discarding.", 5399 static_cast<void *>(thread_plan_sp.get())); 5400 } 5401 } else if (return_value == eExpressionSetupError) { 5402 if (log) 5403 log->PutCString("Process::RunThreadPlan(): execution set up error."); 5404 5405 if (options.DoesUnwindOnError()) { 5406 thread->DiscardThreadPlansUpToPlan(thread_plan_sp); 5407 } 5408 } else { 5409 if (thread->IsThreadPlanDone(thread_plan_sp.get())) { 5410 if (log) 5411 log->PutCString("Process::RunThreadPlan(): thread plan is done"); 5412 return_value = eExpressionCompleted; 5413 } else if (thread->WasThreadPlanDiscarded(thread_plan_sp.get())) { 5414 if (log) 5415 log->PutCString( 5416 "Process::RunThreadPlan(): thread plan was discarded"); 5417 return_value = eExpressionDiscarded; 5418 } else { 5419 if (log) 5420 log->PutCString( 5421 "Process::RunThreadPlan(): thread plan stopped in mid course"); 5422 if (options.DoesUnwindOnError() && thread_plan_sp) { 5423 if (log) 5424 log->PutCString("Process::RunThreadPlan(): discarding thread plan " 5425 "'cause unwind_on_error is set."); 5426 thread->DiscardThreadPlansUpToPlan(thread_plan_sp); 5427 } 5428 } 5429 } 5430 5431 // Thread we ran the function in may have gone away because we ran the 5432 // target Check that it's still there, and if it is put it back in the 5433 // context. Also restore the frame in the context if it is still present. 5434 thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get(); 5435 if (thread) { 5436 exe_ctx.SetFrameSP(thread->GetFrameWithStackID(ctx_frame_id)); 5437 } 5438 5439 // Also restore the current process'es selected frame & thread, since this 5440 // function calling may be done behind the user's back. 5441 5442 if (selected_tid != LLDB_INVALID_THREAD_ID) { 5443 if (GetThreadList().SetSelectedThreadByIndexID(selected_tid) && 5444 selected_stack_id.IsValid()) { 5445 // We were able to restore the selected thread, now restore the frame: 5446 std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex()); 5447 StackFrameSP old_frame_sp = 5448 GetThreadList().GetSelectedThread()->GetFrameWithStackID( 5449 selected_stack_id); 5450 if (old_frame_sp) 5451 GetThreadList().GetSelectedThread()->SetSelectedFrame( 5452 old_frame_sp.get()); 5453 } 5454 } 5455 } 5456 5457 // If the process exited during the run of the thread plan, notify everyone. 5458 5459 if (event_to_broadcast_sp) { 5460 if (log) 5461 log->PutCString("Process::RunThreadPlan(): rebroadcasting event."); 5462 BroadcastEvent(event_to_broadcast_sp); 5463 } 5464 5465 return return_value; 5466 } 5467 5468 const char *Process::ExecutionResultAsCString(ExpressionResults result) { 5469 const char *result_name; 5470 5471 switch (result) { 5472 case eExpressionCompleted: 5473 result_name = "eExpressionCompleted"; 5474 break; 5475 case eExpressionDiscarded: 5476 result_name = "eExpressionDiscarded"; 5477 break; 5478 case eExpressionInterrupted: 5479 result_name = "eExpressionInterrupted"; 5480 break; 5481 case eExpressionHitBreakpoint: 5482 result_name = "eExpressionHitBreakpoint"; 5483 break; 5484 case eExpressionSetupError: 5485 result_name = "eExpressionSetupError"; 5486 break; 5487 case eExpressionParseError: 5488 result_name = "eExpressionParseError"; 5489 break; 5490 case eExpressionResultUnavailable: 5491 result_name = "eExpressionResultUnavailable"; 5492 break; 5493 case eExpressionTimedOut: 5494 result_name = "eExpressionTimedOut"; 5495 break; 5496 case eExpressionStoppedForDebug: 5497 result_name = "eExpressionStoppedForDebug"; 5498 break; 5499 } 5500 return result_name; 5501 } 5502 5503 void Process::GetStatus(Stream &strm) { 5504 const StateType state = GetState(); 5505 if (StateIsStoppedState(state, false)) { 5506 if (state == eStateExited) { 5507 int exit_status = GetExitStatus(); 5508 const char *exit_description = GetExitDescription(); 5509 strm.Printf("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n", 5510 GetID(), exit_status, exit_status, 5511 exit_description ? exit_description : ""); 5512 } else { 5513 if (state == eStateConnected) 5514 strm.Printf("Connected to remote target.\n"); 5515 else 5516 strm.Printf("Process %" PRIu64 " %s\n", GetID(), StateAsCString(state)); 5517 } 5518 } else { 5519 strm.Printf("Process %" PRIu64 " is running.\n", GetID()); 5520 } 5521 } 5522 5523 size_t Process::GetThreadStatus(Stream &strm, 5524 bool only_threads_with_stop_reason, 5525 uint32_t start_frame, uint32_t num_frames, 5526 uint32_t num_frames_with_source, 5527 bool stop_format) { 5528 size_t num_thread_infos_dumped = 0; 5529 5530 // You can't hold the thread list lock while calling Thread::GetStatus. That 5531 // very well might run code (e.g. if we need it to get return values or 5532 // arguments.) For that to work the process has to be able to acquire it. 5533 // So instead copy the thread ID's, and look them up one by one: 5534 5535 uint32_t num_threads; 5536 std::vector<lldb::tid_t> thread_id_array; 5537 // Scope for thread list locker; 5538 { 5539 std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex()); 5540 ThreadList &curr_thread_list = GetThreadList(); 5541 num_threads = curr_thread_list.GetSize(); 5542 uint32_t idx; 5543 thread_id_array.resize(num_threads); 5544 for (idx = 0; idx < num_threads; ++idx) 5545 thread_id_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetID(); 5546 } 5547 5548 for (uint32_t i = 0; i < num_threads; i++) { 5549 ThreadSP thread_sp(GetThreadList().FindThreadByID(thread_id_array[i])); 5550 if (thread_sp) { 5551 if (only_threads_with_stop_reason) { 5552 StopInfoSP stop_info_sp = thread_sp->GetStopInfo(); 5553 if (!stop_info_sp || !stop_info_sp->IsValid()) 5554 continue; 5555 } 5556 thread_sp->GetStatus(strm, start_frame, num_frames, 5557 num_frames_with_source, 5558 stop_format); 5559 ++num_thread_infos_dumped; 5560 } else { 5561 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 5562 if (log) 5563 log->Printf("Process::GetThreadStatus - thread 0x" PRIu64 5564 " vanished while running Thread::GetStatus."); 5565 } 5566 } 5567 return num_thread_infos_dumped; 5568 } 5569 5570 void Process::AddInvalidMemoryRegion(const LoadRange ®ion) { 5571 m_memory_cache.AddInvalidRange(region.GetRangeBase(), region.GetByteSize()); 5572 } 5573 5574 bool Process::RemoveInvalidMemoryRange(const LoadRange ®ion) { 5575 return m_memory_cache.RemoveInvalidRange(region.GetRangeBase(), 5576 region.GetByteSize()); 5577 } 5578 5579 void Process::AddPreResumeAction(PreResumeActionCallback callback, 5580 void *baton) { 5581 m_pre_resume_actions.push_back(PreResumeCallbackAndBaton(callback, baton)); 5582 } 5583 5584 bool Process::RunPreResumeActions() { 5585 bool result = true; 5586 while (!m_pre_resume_actions.empty()) { 5587 struct PreResumeCallbackAndBaton action = m_pre_resume_actions.back(); 5588 m_pre_resume_actions.pop_back(); 5589 bool this_result = action.callback(action.baton); 5590 if (result) 5591 result = this_result; 5592 } 5593 return result; 5594 } 5595 5596 void Process::ClearPreResumeActions() { m_pre_resume_actions.clear(); } 5597 5598 void Process::ClearPreResumeAction(PreResumeActionCallback callback, void *baton) 5599 { 5600 PreResumeCallbackAndBaton element(callback, baton); 5601 auto found_iter = std::find(m_pre_resume_actions.begin(), m_pre_resume_actions.end(), element); 5602 if (found_iter != m_pre_resume_actions.end()) 5603 { 5604 m_pre_resume_actions.erase(found_iter); 5605 } 5606 } 5607 5608 ProcessRunLock &Process::GetRunLock() { 5609 if (m_private_state_thread.EqualsThread(Host::GetCurrentThread())) 5610 return m_private_run_lock; 5611 else 5612 return m_public_run_lock; 5613 } 5614 5615 void Process::Flush() { 5616 m_thread_list.Flush(); 5617 m_extended_thread_list.Flush(); 5618 m_extended_thread_stop_id = 0; 5619 m_queue_list.Clear(); 5620 m_queue_list_stop_id = 0; 5621 } 5622 5623 void Process::DidExec() { 5624 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 5625 if (log) 5626 log->Printf("Process::%s()", __FUNCTION__); 5627 5628 Target &target = GetTarget(); 5629 target.CleanupProcess(); 5630 target.ClearModules(false); 5631 m_dynamic_checkers_up.reset(); 5632 m_abi_sp.reset(); 5633 m_system_runtime_up.reset(); 5634 m_os_up.reset(); 5635 m_dyld_up.reset(); 5636 m_jit_loaders_up.reset(); 5637 m_image_tokens.clear(); 5638 m_allocated_memory_cache.Clear(); 5639 { 5640 std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex); 5641 m_language_runtimes.clear(); 5642 } 5643 m_instrumentation_runtimes.clear(); 5644 m_thread_list.DiscardThreadPlans(); 5645 m_memory_cache.Clear(true); 5646 DoDidExec(); 5647 CompleteAttach(); 5648 // Flush the process (threads and all stack frames) after running 5649 // CompleteAttach() in case the dynamic loader loaded things in new 5650 // locations. 5651 Flush(); 5652 5653 // After we figure out what was loaded/unloaded in CompleteAttach, we need to 5654 // let the target know so it can do any cleanup it needs to. 5655 target.DidExec(); 5656 } 5657 5658 addr_t Process::ResolveIndirectFunction(const Address *address, Status &error) { 5659 if (address == nullptr) { 5660 error.SetErrorString("Invalid address argument"); 5661 return LLDB_INVALID_ADDRESS; 5662 } 5663 5664 addr_t function_addr = LLDB_INVALID_ADDRESS; 5665 5666 addr_t addr = address->GetLoadAddress(&GetTarget()); 5667 std::map<addr_t, addr_t>::const_iterator iter = 5668 m_resolved_indirect_addresses.find(addr); 5669 if (iter != m_resolved_indirect_addresses.end()) { 5670 function_addr = (*iter).second; 5671 } else { 5672 if (!InferiorCall(this, address, function_addr)) { 5673 Symbol *symbol = address->CalculateSymbolContextSymbol(); 5674 error.SetErrorStringWithFormat( 5675 "Unable to call resolver for indirect function %s", 5676 symbol ? symbol->GetName().AsCString() : "<UNKNOWN>"); 5677 function_addr = LLDB_INVALID_ADDRESS; 5678 } else { 5679 m_resolved_indirect_addresses.insert( 5680 std::pair<addr_t, addr_t>(addr, function_addr)); 5681 } 5682 } 5683 return function_addr; 5684 } 5685 5686 void Process::ModulesDidLoad(ModuleList &module_list) { 5687 SystemRuntime *sys_runtime = GetSystemRuntime(); 5688 if (sys_runtime) { 5689 sys_runtime->ModulesDidLoad(module_list); 5690 } 5691 5692 GetJITLoaders().ModulesDidLoad(module_list); 5693 5694 // Give runtimes a chance to be created. 5695 InstrumentationRuntime::ModulesDidLoad(module_list, this, 5696 m_instrumentation_runtimes); 5697 5698 // Tell runtimes about new modules. 5699 for (auto pos = m_instrumentation_runtimes.begin(); 5700 pos != m_instrumentation_runtimes.end(); ++pos) { 5701 InstrumentationRuntimeSP runtime = pos->second; 5702 runtime->ModulesDidLoad(module_list); 5703 } 5704 5705 // Let any language runtimes we have already created know about the modules 5706 // that loaded. 5707 5708 // Iterate over a copy of this language runtime list in case the language 5709 // runtime ModulesDidLoad somehow causes the language runtime to be 5710 // unloaded. 5711 { 5712 std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex); 5713 LanguageRuntimeCollection language_runtimes(m_language_runtimes); 5714 for (const auto &pair : language_runtimes) { 5715 // We must check language_runtime_sp to make sure it is not nullptr as we 5716 // might cache the fact that we didn't have a language runtime for a 5717 // language. 5718 LanguageRuntimeSP language_runtime_sp = pair.second; 5719 if (language_runtime_sp) 5720 language_runtime_sp->ModulesDidLoad(module_list); 5721 } 5722 } 5723 5724 // If we don't have an operating system plug-in, try to load one since 5725 // loading shared libraries might cause a new one to try and load 5726 if (!m_os_up) 5727 LoadOperatingSystemPlugin(false); 5728 5729 // Give structured-data plugins a chance to see the modified modules. 5730 for (auto pair : m_structured_data_plugin_map) { 5731 if (pair.second) 5732 pair.second->ModulesDidLoad(*this, module_list); 5733 } 5734 } 5735 5736 void Process::PrintWarning(uint64_t warning_type, const void *repeat_key, 5737 const char *fmt, ...) { 5738 bool print_warning = true; 5739 5740 StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream(); 5741 if (!stream_sp) 5742 return; 5743 if (warning_type == eWarningsOptimization && !GetWarningsOptimization()) { 5744 return; 5745 } 5746 5747 if (repeat_key != nullptr) { 5748 WarningsCollection::iterator it = m_warnings_issued.find(warning_type); 5749 if (it == m_warnings_issued.end()) { 5750 m_warnings_issued[warning_type] = WarningsPointerSet(); 5751 m_warnings_issued[warning_type].insert(repeat_key); 5752 } else { 5753 if (it->second.find(repeat_key) != it->second.end()) { 5754 print_warning = false; 5755 } else { 5756 it->second.insert(repeat_key); 5757 } 5758 } 5759 } 5760 5761 if (print_warning) { 5762 va_list args; 5763 va_start(args, fmt); 5764 stream_sp->PrintfVarArg(fmt, args); 5765 va_end(args); 5766 } 5767 } 5768 5769 void Process::PrintWarningOptimization(const SymbolContext &sc) { 5770 if (GetWarningsOptimization() && sc.module_sp && 5771 !sc.module_sp->GetFileSpec().GetFilename().IsEmpty() && sc.function && 5772 sc.function->GetIsOptimized()) { 5773 PrintWarning(Process::Warnings::eWarningsOptimization, sc.module_sp.get(), 5774 "%s was compiled with optimization - stepping may behave " 5775 "oddly; variables may not be available.\n", 5776 sc.module_sp->GetFileSpec().GetFilename().GetCString()); 5777 } 5778 } 5779 5780 bool Process::GetProcessInfo(ProcessInstanceInfo &info) { 5781 info.Clear(); 5782 5783 PlatformSP platform_sp = GetTarget().GetPlatform(); 5784 if (!platform_sp) 5785 return false; 5786 5787 return platform_sp->GetProcessInfo(GetID(), info); 5788 } 5789 5790 ThreadCollectionSP Process::GetHistoryThreads(lldb::addr_t addr) { 5791 ThreadCollectionSP threads; 5792 5793 const MemoryHistorySP &memory_history = 5794 MemoryHistory::FindPlugin(shared_from_this()); 5795 5796 if (!memory_history) { 5797 return threads; 5798 } 5799 5800 threads = std::make_shared<ThreadCollection>( 5801 memory_history->GetHistoryThreads(addr)); 5802 5803 return threads; 5804 } 5805 5806 InstrumentationRuntimeSP 5807 Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type) { 5808 InstrumentationRuntimeCollection::iterator pos; 5809 pos = m_instrumentation_runtimes.find(type); 5810 if (pos == m_instrumentation_runtimes.end()) { 5811 return InstrumentationRuntimeSP(); 5812 } else 5813 return (*pos).second; 5814 } 5815 5816 bool Process::GetModuleSpec(const FileSpec &module_file_spec, 5817 const ArchSpec &arch, ModuleSpec &module_spec) { 5818 module_spec.Clear(); 5819 return false; 5820 } 5821 5822 size_t Process::AddImageToken(lldb::addr_t image_ptr) { 5823 m_image_tokens.push_back(image_ptr); 5824 return m_image_tokens.size() - 1; 5825 } 5826 5827 lldb::addr_t Process::GetImagePtrFromToken(size_t token) const { 5828 if (token < m_image_tokens.size()) 5829 return m_image_tokens[token]; 5830 return LLDB_INVALID_IMAGE_TOKEN; 5831 } 5832 5833 void Process::ResetImageToken(size_t token) { 5834 if (token < m_image_tokens.size()) 5835 m_image_tokens[token] = LLDB_INVALID_IMAGE_TOKEN; 5836 } 5837 5838 Address 5839 Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr, 5840 AddressRange range_bounds) { 5841 Target &target = GetTarget(); 5842 DisassemblerSP disassembler_sp; 5843 InstructionList *insn_list = nullptr; 5844 5845 Address retval = default_stop_addr; 5846 5847 if (!target.GetUseFastStepping()) 5848 return retval; 5849 if (!default_stop_addr.IsValid()) 5850 return retval; 5851 5852 ExecutionContext exe_ctx(this); 5853 const char *plugin_name = nullptr; 5854 const char *flavor = nullptr; 5855 const bool prefer_file_cache = true; 5856 disassembler_sp = Disassembler::DisassembleRange( 5857 target.GetArchitecture(), plugin_name, flavor, exe_ctx, range_bounds, 5858 prefer_file_cache); 5859 if (disassembler_sp) 5860 insn_list = &disassembler_sp->GetInstructionList(); 5861 5862 if (insn_list == nullptr) { 5863 return retval; 5864 } 5865 5866 size_t insn_offset = 5867 insn_list->GetIndexOfInstructionAtAddress(default_stop_addr); 5868 if (insn_offset == UINT32_MAX) { 5869 return retval; 5870 } 5871 5872 uint32_t branch_index = 5873 insn_list->GetIndexOfNextBranchInstruction(insn_offset, target, 5874 false /* ignore_calls*/); 5875 if (branch_index == UINT32_MAX) { 5876 return retval; 5877 } 5878 5879 if (branch_index > insn_offset) { 5880 Address next_branch_insn_address = 5881 insn_list->GetInstructionAtIndex(branch_index)->GetAddress(); 5882 if (next_branch_insn_address.IsValid() && 5883 range_bounds.ContainsFileAddress(next_branch_insn_address)) { 5884 retval = next_branch_insn_address; 5885 } 5886 } 5887 5888 return retval; 5889 } 5890 5891 Status 5892 Process::GetMemoryRegions(lldb_private::MemoryRegionInfos ®ion_list) { 5893 5894 Status error; 5895 5896 lldb::addr_t range_end = 0; 5897 5898 region_list.clear(); 5899 do { 5900 lldb_private::MemoryRegionInfo region_info; 5901 error = GetMemoryRegionInfo(range_end, region_info); 5902 // GetMemoryRegionInfo should only return an error if it is unimplemented. 5903 if (error.Fail()) { 5904 region_list.clear(); 5905 break; 5906 } 5907 5908 range_end = region_info.GetRange().GetRangeEnd(); 5909 if (region_info.GetMapped() == MemoryRegionInfo::eYes) { 5910 region_list.push_back(std::move(region_info)); 5911 } 5912 } while (range_end != LLDB_INVALID_ADDRESS); 5913 5914 return error; 5915 } 5916 5917 Status 5918 Process::ConfigureStructuredData(ConstString type_name, 5919 const StructuredData::ObjectSP &config_sp) { 5920 // If you get this, the Process-derived class needs to implement a method to 5921 // enable an already-reported asynchronous structured data feature. See 5922 // ProcessGDBRemote for an example implementation over gdb-remote. 5923 return Status("unimplemented"); 5924 } 5925 5926 void Process::MapSupportedStructuredDataPlugins( 5927 const StructuredData::Array &supported_type_names) { 5928 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 5929 5930 // Bail out early if there are no type names to map. 5931 if (supported_type_names.GetSize() == 0) { 5932 if (log) 5933 log->Printf("Process::%s(): no structured data types supported", 5934 __FUNCTION__); 5935 return; 5936 } 5937 5938 // Convert StructuredData type names to ConstString instances. 5939 std::set<ConstString> const_type_names; 5940 5941 if (log) 5942 log->Printf("Process::%s(): the process supports the following async " 5943 "structured data types:", 5944 __FUNCTION__); 5945 5946 supported_type_names.ForEach( 5947 [&const_type_names, &log](StructuredData::Object *object) { 5948 if (!object) { 5949 // Invalid - shouldn't be null objects in the array. 5950 return false; 5951 } 5952 5953 auto type_name = object->GetAsString(); 5954 if (!type_name) { 5955 // Invalid format - all type names should be strings. 5956 return false; 5957 } 5958 5959 const_type_names.insert(ConstString(type_name->GetValue())); 5960 LLDB_LOG(log, "- {0}", type_name->GetValue()); 5961 return true; 5962 }); 5963 5964 // For each StructuredDataPlugin, if the plugin handles any of the types in 5965 // the supported_type_names, map that type name to that plugin. Stop when 5966 // we've consumed all the type names. 5967 // FIXME: should we return an error if there are type names nobody 5968 // supports? 5969 for (uint32_t plugin_index = 0; !const_type_names.empty(); plugin_index++) { 5970 auto create_instance = 5971 PluginManager::GetStructuredDataPluginCreateCallbackAtIndex( 5972 plugin_index); 5973 if (!create_instance) 5974 break; 5975 5976 // Create the plugin. 5977 StructuredDataPluginSP plugin_sp = (*create_instance)(*this); 5978 if (!plugin_sp) { 5979 // This plugin doesn't think it can work with the process. Move on to the 5980 // next. 5981 continue; 5982 } 5983 5984 // For any of the remaining type names, map any that this plugin supports. 5985 std::vector<ConstString> names_to_remove; 5986 for (auto &type_name : const_type_names) { 5987 if (plugin_sp->SupportsStructuredDataType(type_name)) { 5988 m_structured_data_plugin_map.insert( 5989 std::make_pair(type_name, plugin_sp)); 5990 names_to_remove.push_back(type_name); 5991 if (log) 5992 log->Printf("Process::%s(): using plugin %s for type name " 5993 "%s", 5994 __FUNCTION__, plugin_sp->GetPluginName().GetCString(), 5995 type_name.GetCString()); 5996 } 5997 } 5998 5999 // Remove the type names that were consumed by this plugin. 6000 for (auto &type_name : names_to_remove) 6001 const_type_names.erase(type_name); 6002 } 6003 } 6004 6005 bool Process::RouteAsyncStructuredData( 6006 const StructuredData::ObjectSP object_sp) { 6007 // Nothing to do if there's no data. 6008 if (!object_sp) 6009 return false; 6010 6011 // The contract is this must be a dictionary, so we can look up the routing 6012 // key via the top-level 'type' string value within the dictionary. 6013 StructuredData::Dictionary *dictionary = object_sp->GetAsDictionary(); 6014 if (!dictionary) 6015 return false; 6016 6017 // Grab the async structured type name (i.e. the feature/plugin name). 6018 ConstString type_name; 6019 if (!dictionary->GetValueForKeyAsString("type", type_name)) 6020 return false; 6021 6022 // Check if there's a plugin registered for this type name. 6023 auto find_it = m_structured_data_plugin_map.find(type_name); 6024 if (find_it == m_structured_data_plugin_map.end()) { 6025 // We don't have a mapping for this structured data type. 6026 return false; 6027 } 6028 6029 // Route the structured data to the plugin. 6030 find_it->second->HandleArrivalOfStructuredData(*this, type_name, object_sp); 6031 return true; 6032 } 6033 6034 Status Process::UpdateAutomaticSignalFiltering() { 6035 // Default implementation does nothign. 6036 // No automatic signal filtering to speak of. 6037 return Status(); 6038 } 6039 6040 UtilityFunction *Process::GetLoadImageUtilityFunction( 6041 Platform *platform, 6042 llvm::function_ref<std::unique_ptr<UtilityFunction>()> factory) { 6043 if (platform != GetTarget().GetPlatform().get()) 6044 return nullptr; 6045 std::call_once(m_dlopen_utility_func_flag_once, 6046 [&] { m_dlopen_utility_func_up = factory(); }); 6047 return m_dlopen_utility_func_up.get(); 6048 } 6049