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