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