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