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/Target/Process.h" 11 12 #include "lldb/lldb-private-log.h" 13 14 #include "lldb/Breakpoint/StoppointCallbackContext.h" 15 #include "lldb/Breakpoint/BreakpointLocation.h" 16 #include "lldb/Core/Event.h" 17 #include "lldb/Core/ConnectionFileDescriptor.h" 18 #include "lldb/Core/Debugger.h" 19 #include "lldb/Core/InputReader.h" 20 #include "lldb/Core/Log.h" 21 #include "lldb/Core/PluginManager.h" 22 #include "lldb/Core/State.h" 23 #include "lldb/Expression/ClangUserExpression.h" 24 #include "lldb/Interpreter/CommandInterpreter.h" 25 #include "lldb/Host/Host.h" 26 #include "lldb/Target/ABI.h" 27 #include "lldb/Target/DynamicLoader.h" 28 #include "lldb/Target/OperatingSystem.h" 29 #include "lldb/Target/LanguageRuntime.h" 30 #include "lldb/Target/CPPLanguageRuntime.h" 31 #include "lldb/Target/ObjCLanguageRuntime.h" 32 #include "lldb/Target/Platform.h" 33 #include "lldb/Target/RegisterContext.h" 34 #include "lldb/Target/StopInfo.h" 35 #include "lldb/Target/Target.h" 36 #include "lldb/Target/TargetList.h" 37 #include "lldb/Target/Thread.h" 38 #include "lldb/Target/ThreadPlan.h" 39 40 using namespace lldb; 41 using namespace lldb_private; 42 43 void 44 ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const 45 { 46 const char *cstr; 47 if (m_pid != LLDB_INVALID_PROCESS_ID) 48 s.Printf (" pid = %i\n", m_pid); 49 50 if (m_parent_pid != LLDB_INVALID_PROCESS_ID) 51 s.Printf (" parent = %i\n", m_parent_pid); 52 53 if (m_executable) 54 { 55 s.Printf (" name = %s\n", m_executable.GetFilename().GetCString()); 56 s.PutCString (" file = "); 57 m_executable.Dump(&s); 58 s.EOL(); 59 } 60 const uint32_t argc = m_arguments.GetArgumentCount(); 61 if (argc > 0) 62 { 63 for (uint32_t i=0; i<argc; i++) 64 { 65 const char *arg = m_arguments.GetArgumentAtIndex(i); 66 if (i < 10) 67 s.Printf (" arg[%u] = %s\n", i, arg); 68 else 69 s.Printf ("arg[%u] = %s\n", i, arg); 70 } 71 } 72 73 const uint32_t envc = m_environment.GetArgumentCount(); 74 if (envc > 0) 75 { 76 for (uint32_t i=0; i<envc; i++) 77 { 78 const char *env = m_environment.GetArgumentAtIndex(i); 79 if (i < 10) 80 s.Printf (" env[%u] = %s\n", i, env); 81 else 82 s.Printf ("env[%u] = %s\n", i, env); 83 } 84 } 85 86 if (m_arch.IsValid()) 87 s.Printf (" arch = %s\n", m_arch.GetTriple().str().c_str()); 88 89 if (m_uid != UINT32_MAX) 90 { 91 cstr = platform->GetUserName (m_uid); 92 s.Printf (" uid = %-5u (%s)\n", m_uid, cstr ? cstr : ""); 93 } 94 if (m_gid != UINT32_MAX) 95 { 96 cstr = platform->GetGroupName (m_gid); 97 s.Printf (" gid = %-5u (%s)\n", m_gid, cstr ? cstr : ""); 98 } 99 if (m_euid != UINT32_MAX) 100 { 101 cstr = platform->GetUserName (m_euid); 102 s.Printf (" euid = %-5u (%s)\n", m_euid, cstr ? cstr : ""); 103 } 104 if (m_egid != UINT32_MAX) 105 { 106 cstr = platform->GetGroupName (m_egid); 107 s.Printf (" egid = %-5u (%s)\n", m_egid, cstr ? cstr : ""); 108 } 109 } 110 111 void 112 ProcessInstanceInfo::DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose) 113 { 114 const char *label; 115 if (show_args || verbose) 116 label = "ARGUMENTS"; 117 else 118 label = "NAME"; 119 120 if (verbose) 121 { 122 s.Printf ("PID PARENT USER GROUP EFF USER EFF GROUP TRIPLE %s\n", label); 123 s.PutCString ("====== ====== ========== ========== ========== ========== ======================== ============================\n"); 124 } 125 else 126 { 127 s.Printf ("PID PARENT USER ARCH %s\n", label); 128 s.PutCString ("====== ====== ========== ======= ============================\n"); 129 } 130 } 131 132 void 133 ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const 134 { 135 if (m_pid != LLDB_INVALID_PROCESS_ID) 136 { 137 const char *cstr; 138 s.Printf ("%-6u %-6u ", m_pid, m_parent_pid); 139 140 141 if (verbose) 142 { 143 cstr = platform->GetUserName (m_uid); 144 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed 145 s.Printf ("%-10s ", cstr); 146 else 147 s.Printf ("%-10u ", m_uid); 148 149 cstr = platform->GetGroupName (m_gid); 150 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed 151 s.Printf ("%-10s ", cstr); 152 else 153 s.Printf ("%-10u ", m_gid); 154 155 cstr = platform->GetUserName (m_euid); 156 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed 157 s.Printf ("%-10s ", cstr); 158 else 159 s.Printf ("%-10u ", m_euid); 160 161 cstr = platform->GetGroupName (m_egid); 162 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed 163 s.Printf ("%-10s ", cstr); 164 else 165 s.Printf ("%-10u ", m_egid); 166 s.Printf ("%-24s ", m_arch.IsValid() ? m_arch.GetTriple().str().c_str() : ""); 167 } 168 else 169 { 170 s.Printf ("%-10s %.*-7s ", 171 platform->GetUserName (m_euid), 172 (int)m_arch.GetTriple().getArchName().size(), 173 m_arch.GetTriple().getArchName().data()); 174 } 175 176 if (verbose || show_args) 177 { 178 const uint32_t argc = m_arguments.GetArgumentCount(); 179 if (argc > 0) 180 { 181 for (uint32_t i=0; i<argc; i++) 182 { 183 if (i > 0) 184 s.PutChar (' '); 185 s.PutCString (m_arguments.GetArgumentAtIndex(i)); 186 } 187 } 188 } 189 else 190 { 191 s.PutCString (GetName()); 192 } 193 194 s.EOL(); 195 } 196 } 197 198 199 void 200 ProcessInfo::SetArgumentsFromArgs (const Args& args, 201 bool first_arg_is_executable, 202 bool first_arg_is_executable_and_argument) 203 { 204 // Copy all arguments 205 m_arguments = args; 206 207 // Is the first argument the executable? 208 if (first_arg_is_executable) 209 { 210 const char *first_arg = args.GetArgumentAtIndex (0); 211 if (first_arg) 212 { 213 // Yes the first argument is an executable, set it as the executable 214 // in the launch options. Don't resolve the file path as the path 215 // could be a remote platform path 216 const bool resolve = false; 217 m_executable.SetFile(first_arg, resolve); 218 219 // If argument zero is an executable and shouldn't be included 220 // in the arguments, remove it from the front of the arguments 221 if (first_arg_is_executable_and_argument == false) 222 m_arguments.DeleteArgumentAtIndex (0); 223 } 224 } 225 } 226 227 bool 228 ProcessLaunchInfo::FileAction::Open (int fd, const char *path, bool read, bool write) 229 { 230 if ((read || write) && fd >= 0 && path && path[0]) 231 { 232 m_action = eFileActionOpen; 233 m_fd = fd; 234 if (read && write) 235 m_arg = O_RDWR; 236 else if (read) 237 m_arg = O_RDONLY; 238 else 239 m_arg = O_WRONLY; 240 m_path.assign (path); 241 return true; 242 } 243 else 244 { 245 Clear(); 246 } 247 return false; 248 } 249 250 bool 251 ProcessLaunchInfo::FileAction::Close (int fd) 252 { 253 Clear(); 254 if (fd >= 0) 255 { 256 m_action = eFileActionClose; 257 m_fd = fd; 258 } 259 return m_fd >= 0; 260 } 261 262 263 bool 264 ProcessLaunchInfo::FileAction::Duplicate (int fd, int dup_fd) 265 { 266 Clear(); 267 if (fd >= 0 && dup_fd >= 0) 268 { 269 m_action = eFileActionDuplicate; 270 m_fd = fd; 271 m_arg = dup_fd; 272 } 273 return m_fd >= 0; 274 } 275 276 277 278 bool 279 ProcessLaunchInfo::FileAction::AddPosixSpawnFileAction (posix_spawn_file_actions_t *file_actions, 280 const FileAction *info, 281 Log *log, 282 Error& error) 283 { 284 if (info == NULL) 285 return false; 286 287 switch (info->m_action) 288 { 289 case eFileActionNone: 290 error.Clear(); 291 break; 292 293 case eFileActionClose: 294 if (info->m_fd == -1) 295 error.SetErrorString ("invalid fd for posix_spawn_file_actions_addclose(...)"); 296 else 297 { 298 error.SetError (::posix_spawn_file_actions_addclose (file_actions, info->m_fd), 299 eErrorTypePOSIX); 300 if (log && (error.Fail() || log)) 301 error.PutToLog(log, "posix_spawn_file_actions_addclose (action=%p, fd=%i)", 302 file_actions, info->m_fd); 303 } 304 break; 305 306 case eFileActionDuplicate: 307 if (info->m_fd == -1) 308 error.SetErrorString ("invalid fd for posix_spawn_file_actions_adddup2(...)"); 309 else if (info->m_arg == -1) 310 error.SetErrorString ("invalid duplicate fd for posix_spawn_file_actions_adddup2(...)"); 311 else 312 { 313 error.SetError (::posix_spawn_file_actions_adddup2 (file_actions, info->m_fd, info->m_arg), 314 eErrorTypePOSIX); 315 if (log && (error.Fail() || log)) 316 error.PutToLog(log, "posix_spawn_file_actions_adddup2 (action=%p, fd=%i, dup_fd=%i)", 317 file_actions, info->m_fd, info->m_arg); 318 } 319 break; 320 321 case eFileActionOpen: 322 if (info->m_fd == -1) 323 error.SetErrorString ("invalid fd in posix_spawn_file_actions_addopen(...)"); 324 else 325 { 326 int oflag = info->m_arg; 327 mode_t mode = 0; 328 329 error.SetError (::posix_spawn_file_actions_addopen (file_actions, 330 info->m_fd, 331 info->m_path.c_str(), 332 oflag, 333 mode), 334 eErrorTypePOSIX); 335 if (error.Fail() || log) 336 error.PutToLog(log, 337 "posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)", 338 file_actions, info->m_fd, info->m_path.c_str(), oflag, mode); 339 } 340 break; 341 342 default: 343 error.SetErrorStringWithFormat ("invalid file action: %i", info->m_action); 344 break; 345 } 346 return error.Success(); 347 } 348 349 Error 350 ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg) 351 { 352 Error error; 353 char short_option = (char) m_getopt_table[option_idx].val; 354 355 switch (short_option) 356 { 357 case 's': // Stop at program entry point 358 launch_info.GetFlags().Set (eLaunchFlagStopAtEntry); 359 break; 360 361 case 'e': // STDERR for read + write 362 { 363 ProcessLaunchInfo::FileAction action; 364 if (action.Open(STDERR_FILENO, option_arg, true, true)) 365 launch_info.AppendFileAction (action); 366 } 367 break; 368 369 case 'i': // STDIN for read only 370 { 371 ProcessLaunchInfo::FileAction action; 372 if (action.Open(STDIN_FILENO, option_arg, true, false)) 373 launch_info.AppendFileAction (action); 374 } 375 break; 376 377 case 'o': // Open STDOUT for write only 378 { 379 ProcessLaunchInfo::FileAction action; 380 if (action.Open(STDOUT_FILENO, option_arg, false, true)) 381 launch_info.AppendFileAction (action); 382 } 383 break; 384 385 case 'p': // Process plug-in name 386 launch_info.SetProcessPluginName (option_arg); 387 break; 388 389 case 'n': // Disable STDIO 390 { 391 ProcessLaunchInfo::FileAction action; 392 if (action.Open(STDERR_FILENO, "/dev/null", true, true)) 393 launch_info.AppendFileAction (action); 394 if (action.Open(STDOUT_FILENO, "/dev/null", false, true)) 395 launch_info.AppendFileAction (action); 396 if (action.Open(STDIN_FILENO, "/dev/null", true, false)) 397 launch_info.AppendFileAction (action); 398 } 399 break; 400 401 case 'w': 402 launch_info.SetWorkingDirectory (option_arg); 403 break; 404 405 case 't': // Open process in new terminal window 406 launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY); 407 break; 408 409 case 'a': 410 launch_info.GetArchitecture().SetTriple (option_arg, 411 m_interpreter.GetPlatform(true).get()); 412 break; 413 414 case 'A': 415 launch_info.GetFlags().Set (eLaunchFlagDisableASLR); 416 break; 417 418 case 'v': 419 launch_info.GetEnvironmentEntries().AppendArgument(option_arg); 420 break; 421 422 default: 423 error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option); 424 break; 425 426 } 427 return error; 428 } 429 430 OptionDefinition 431 ProcessLaunchCommandOptions::g_option_table[] = 432 { 433 { 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."}, 434 { LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', no_argument, NULL, 0, eArgTypeNone, "Disable address space layout randomization when launching a process."}, 435 { LLDB_OPT_SET_ALL, false, "plugin", 'p', required_argument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."}, 436 { LLDB_OPT_SET_ALL, false, "working-dir", 'w', required_argument, NULL, 0, eArgTypePath, "Set the current working directory to <path> when running the inferior."}, 437 { LLDB_OPT_SET_ALL, false, "arch", 'a', required_argument, NULL, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous."}, 438 { 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."}, 439 440 { LLDB_OPT_SET_1 , false, "stdin", 'i', required_argument, NULL, 0, eArgTypePath, "Redirect stdin for the process to <path>."}, 441 { LLDB_OPT_SET_1 , false, "stdout", 'o', required_argument, NULL, 0, eArgTypePath, "Redirect stdout for the process to <path>."}, 442 { LLDB_OPT_SET_1 , false, "stderr", 'e', required_argument, NULL, 0, eArgTypePath, "Redirect stderr for the process to <path>."}, 443 444 { LLDB_OPT_SET_2 , false, "tty", 't', no_argument, NULL, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)."}, 445 446 { 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."}, 447 448 { 0 , false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 449 }; 450 451 452 453 bool 454 ProcessInstanceInfoMatch::NameMatches (const char *process_name) const 455 { 456 if (m_name_match_type == eNameMatchIgnore || process_name == NULL) 457 return true; 458 const char *match_name = m_match_info.GetName(); 459 if (!match_name) 460 return true; 461 462 return lldb_private::NameMatches (process_name, m_name_match_type, match_name); 463 } 464 465 bool 466 ProcessInstanceInfoMatch::Matches (const ProcessInstanceInfo &proc_info) const 467 { 468 if (!NameMatches (proc_info.GetName())) 469 return false; 470 471 if (m_match_info.ProcessIDIsValid() && 472 m_match_info.GetProcessID() != proc_info.GetProcessID()) 473 return false; 474 475 if (m_match_info.ParentProcessIDIsValid() && 476 m_match_info.GetParentProcessID() != proc_info.GetParentProcessID()) 477 return false; 478 479 if (m_match_info.UserIDIsValid () && 480 m_match_info.GetUserID() != proc_info.GetUserID()) 481 return false; 482 483 if (m_match_info.GroupIDIsValid () && 484 m_match_info.GetGroupID() != proc_info.GetGroupID()) 485 return false; 486 487 if (m_match_info.EffectiveUserIDIsValid () && 488 m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID()) 489 return false; 490 491 if (m_match_info.EffectiveGroupIDIsValid () && 492 m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID()) 493 return false; 494 495 if (m_match_info.GetArchitecture().IsValid() && 496 m_match_info.GetArchitecture() != proc_info.GetArchitecture()) 497 return false; 498 return true; 499 } 500 501 bool 502 ProcessInstanceInfoMatch::MatchAllProcesses () const 503 { 504 if (m_name_match_type != eNameMatchIgnore) 505 return false; 506 507 if (m_match_info.ProcessIDIsValid()) 508 return false; 509 510 if (m_match_info.ParentProcessIDIsValid()) 511 return false; 512 513 if (m_match_info.UserIDIsValid ()) 514 return false; 515 516 if (m_match_info.GroupIDIsValid ()) 517 return false; 518 519 if (m_match_info.EffectiveUserIDIsValid ()) 520 return false; 521 522 if (m_match_info.EffectiveGroupIDIsValid ()) 523 return false; 524 525 if (m_match_info.GetArchitecture().IsValid()) 526 return false; 527 528 if (m_match_all_users) 529 return false; 530 531 return true; 532 533 } 534 535 void 536 ProcessInstanceInfoMatch::Clear() 537 { 538 m_match_info.Clear(); 539 m_name_match_type = eNameMatchIgnore; 540 m_match_all_users = false; 541 } 542 543 Process* 544 Process::FindPlugin (Target &target, const char *plugin_name, Listener &listener) 545 { 546 ProcessCreateInstance create_callback = NULL; 547 if (plugin_name) 548 { 549 create_callback = PluginManager::GetProcessCreateCallbackForPluginName (plugin_name); 550 if (create_callback) 551 { 552 std::auto_ptr<Process> debugger_ap(create_callback(target, listener)); 553 if (debugger_ap->CanDebug(target, true)) 554 return debugger_ap.release(); 555 } 556 } 557 else 558 { 559 for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx) 560 { 561 std::auto_ptr<Process> debugger_ap(create_callback(target, listener)); 562 if (debugger_ap->CanDebug(target, false)) 563 return debugger_ap.release(); 564 } 565 } 566 return NULL; 567 } 568 569 570 //---------------------------------------------------------------------- 571 // Process constructor 572 //---------------------------------------------------------------------- 573 Process::Process(Target &target, Listener &listener) : 574 UserID (LLDB_INVALID_PROCESS_ID), 575 Broadcaster ("lldb.process"), 576 ProcessInstanceSettings (*GetSettingsController()), 577 m_target (target), 578 m_public_state (eStateUnloaded), 579 m_private_state (eStateUnloaded), 580 m_private_state_broadcaster ("lldb.process.internal_state_broadcaster"), 581 m_private_state_control_broadcaster ("lldb.process.internal_state_control_broadcaster"), 582 m_private_state_listener ("lldb.process.internal_state_listener"), 583 m_private_state_control_wait(), 584 m_private_state_thread (LLDB_INVALID_HOST_THREAD), 585 m_mod_id (), 586 m_thread_index_id (0), 587 m_exit_status (-1), 588 m_exit_string (), 589 m_thread_list (this), 590 m_notifications (), 591 m_image_tokens (), 592 m_listener (listener), 593 m_breakpoint_site_list (), 594 m_dynamic_checkers_ap (), 595 m_unix_signals (), 596 m_abi_sp (), 597 m_process_input_reader (), 598 m_stdio_communication ("process.stdio"), 599 m_stdio_communication_mutex (Mutex::eMutexTypeRecursive), 600 m_stdout_data (), 601 m_memory_cache (*this), 602 m_allocated_memory_cache (*this), 603 m_next_event_action_ap() 604 { 605 UpdateInstanceName(); 606 607 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 608 if (log) 609 log->Printf ("%p Process::Process()", this); 610 611 SetEventName (eBroadcastBitStateChanged, "state-changed"); 612 SetEventName (eBroadcastBitInterrupt, "interrupt"); 613 SetEventName (eBroadcastBitSTDOUT, "stdout-available"); 614 SetEventName (eBroadcastBitSTDERR, "stderr-available"); 615 616 listener.StartListeningForEvents (this, 617 eBroadcastBitStateChanged | 618 eBroadcastBitInterrupt | 619 eBroadcastBitSTDOUT | 620 eBroadcastBitSTDERR); 621 622 m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster, 623 eBroadcastBitStateChanged); 624 625 m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster, 626 eBroadcastInternalStateControlStop | 627 eBroadcastInternalStateControlPause | 628 eBroadcastInternalStateControlResume); 629 } 630 631 //---------------------------------------------------------------------- 632 // Destructor 633 //---------------------------------------------------------------------- 634 Process::~Process() 635 { 636 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 637 if (log) 638 log->Printf ("%p Process::~Process()", this); 639 StopPrivateStateThread(); 640 } 641 642 void 643 Process::Finalize() 644 { 645 // Do any cleanup needed prior to being destructed... Subclasses 646 // that override this method should call this superclass method as well. 647 648 // We need to destroy the loader before the derived Process class gets destroyed 649 // since it is very likely that undoing the loader will require access to the real process. 650 m_dyld_ap.reset(); 651 m_os_ap.reset(); 652 } 653 654 void 655 Process::RegisterNotificationCallbacks (const Notifications& callbacks) 656 { 657 m_notifications.push_back(callbacks); 658 if (callbacks.initialize != NULL) 659 callbacks.initialize (callbacks.baton, this); 660 } 661 662 bool 663 Process::UnregisterNotificationCallbacks(const Notifications& callbacks) 664 { 665 std::vector<Notifications>::iterator pos, end = m_notifications.end(); 666 for (pos = m_notifications.begin(); pos != end; ++pos) 667 { 668 if (pos->baton == callbacks.baton && 669 pos->initialize == callbacks.initialize && 670 pos->process_state_changed == callbacks.process_state_changed) 671 { 672 m_notifications.erase(pos); 673 return true; 674 } 675 } 676 return false; 677 } 678 679 void 680 Process::SynchronouslyNotifyStateChanged (StateType state) 681 { 682 std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end(); 683 for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos) 684 { 685 if (notification_pos->process_state_changed) 686 notification_pos->process_state_changed (notification_pos->baton, this, state); 687 } 688 } 689 690 // FIXME: We need to do some work on events before the general Listener sees them. 691 // For instance if we are continuing from a breakpoint, we need to ensure that we do 692 // the little "insert real insn, step & stop" trick. But we can't do that when the 693 // event is delivered by the broadcaster - since that is done on the thread that is 694 // waiting for new events, so if we needed more than one event for our handling, we would 695 // stall. So instead we do it when we fetch the event off of the queue. 696 // 697 698 StateType 699 Process::GetNextEvent (EventSP &event_sp) 700 { 701 StateType state = eStateInvalid; 702 703 if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp) 704 state = Process::ProcessEventData::GetStateFromEvent (event_sp.get()); 705 706 return state; 707 } 708 709 710 StateType 711 Process::WaitForProcessToStop (const TimeValue *timeout) 712 { 713 // We can't just wait for a "stopped" event, because the stopped event may have restarted the target. 714 // We have to actually check each event, and in the case of a stopped event check the restarted flag 715 // on the event. 716 EventSP event_sp; 717 StateType state = GetState(); 718 // If we are exited or detached, we won't ever get back to any 719 // other valid state... 720 if (state == eStateDetached || state == eStateExited) 721 return state; 722 723 while (state != eStateInvalid) 724 { 725 state = WaitForStateChangedEvents (timeout, event_sp); 726 switch (state) 727 { 728 case eStateCrashed: 729 case eStateDetached: 730 case eStateExited: 731 case eStateUnloaded: 732 return state; 733 case eStateStopped: 734 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) 735 continue; 736 else 737 return state; 738 default: 739 continue; 740 } 741 } 742 return state; 743 } 744 745 746 StateType 747 Process::WaitForState 748 ( 749 const TimeValue *timeout, 750 const StateType *match_states, const uint32_t num_match_states 751 ) 752 { 753 EventSP event_sp; 754 uint32_t i; 755 StateType state = GetState(); 756 while (state != eStateInvalid) 757 { 758 // If we are exited or detached, we won't ever get back to any 759 // other valid state... 760 if (state == eStateDetached || state == eStateExited) 761 return state; 762 763 state = WaitForStateChangedEvents (timeout, event_sp); 764 765 for (i=0; i<num_match_states; ++i) 766 { 767 if (match_states[i] == state) 768 return state; 769 } 770 } 771 return state; 772 } 773 774 bool 775 Process::HijackProcessEvents (Listener *listener) 776 { 777 if (listener != NULL) 778 { 779 return HijackBroadcaster(listener, eBroadcastBitStateChanged); 780 } 781 else 782 return false; 783 } 784 785 void 786 Process::RestoreProcessEvents () 787 { 788 RestoreBroadcaster(); 789 } 790 791 bool 792 Process::HijackPrivateProcessEvents (Listener *listener) 793 { 794 if (listener != NULL) 795 { 796 return m_private_state_broadcaster.HijackBroadcaster(listener, eBroadcastBitStateChanged); 797 } 798 else 799 return false; 800 } 801 802 void 803 Process::RestorePrivateProcessEvents () 804 { 805 m_private_state_broadcaster.RestoreBroadcaster(); 806 } 807 808 StateType 809 Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp) 810 { 811 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 812 813 if (log) 814 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout); 815 816 StateType state = eStateInvalid; 817 if (m_listener.WaitForEventForBroadcasterWithType (timeout, 818 this, 819 eBroadcastBitStateChanged, 820 event_sp)) 821 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 822 823 if (log) 824 log->Printf ("Process::%s (timeout = %p, event_sp) => %s", 825 __FUNCTION__, 826 timeout, 827 StateAsCString(state)); 828 return state; 829 } 830 831 Event * 832 Process::PeekAtStateChangedEvents () 833 { 834 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 835 836 if (log) 837 log->Printf ("Process::%s...", __FUNCTION__); 838 839 Event *event_ptr; 840 event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this, 841 eBroadcastBitStateChanged); 842 if (log) 843 { 844 if (event_ptr) 845 { 846 log->Printf ("Process::%s (event_ptr) => %s", 847 __FUNCTION__, 848 StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr))); 849 } 850 else 851 { 852 log->Printf ("Process::%s no events found", 853 __FUNCTION__); 854 } 855 } 856 return event_ptr; 857 } 858 859 StateType 860 Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp) 861 { 862 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 863 864 if (log) 865 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout); 866 867 StateType state = eStateInvalid; 868 if (m_private_state_listener.WaitForEventForBroadcasterWithType (timeout, 869 &m_private_state_broadcaster, 870 eBroadcastBitStateChanged, 871 event_sp)) 872 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 873 874 // This is a bit of a hack, but when we wait here we could very well return 875 // to the command-line, and that could disable the log, which would render the 876 // log we got above invalid. 877 if (log) 878 { 879 if (state == eStateInvalid) 880 log->Printf ("Process::%s (timeout = %p, event_sp) => TIMEOUT", __FUNCTION__, timeout); 881 else 882 log->Printf ("Process::%s (timeout = %p, event_sp) => %s", __FUNCTION__, timeout, StateAsCString(state)); 883 } 884 return state; 885 } 886 887 bool 888 Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only) 889 { 890 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 891 892 if (log) 893 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout); 894 895 if (control_only) 896 return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp); 897 else 898 return m_private_state_listener.WaitForEvent(timeout, event_sp); 899 } 900 901 bool 902 Process::IsRunning () const 903 { 904 return StateIsRunningState (m_public_state.GetValue()); 905 } 906 907 int 908 Process::GetExitStatus () 909 { 910 if (m_public_state.GetValue() == eStateExited) 911 return m_exit_status; 912 return -1; 913 } 914 915 916 void 917 Process::ProcessInstanceSettings::GetHostEnvironmentIfNeeded () 918 { 919 if (m_inherit_host_env && !m_got_host_env) 920 { 921 m_got_host_env = true; 922 StringList host_env; 923 const size_t host_env_count = Host::GetEnvironment (host_env); 924 for (size_t idx=0; idx<host_env_count; idx++) 925 { 926 const char *env_entry = host_env.GetStringAtIndex (idx); 927 if (env_entry) 928 { 929 const char *equal_pos = ::strchr(env_entry, '='); 930 if (equal_pos) 931 { 932 std::string key (env_entry, equal_pos - env_entry); 933 std::string value (equal_pos + 1); 934 if (m_env_vars.find (key) == m_env_vars.end()) 935 m_env_vars[key] = value; 936 } 937 } 938 } 939 } 940 } 941 942 943 size_t 944 Process::ProcessInstanceSettings::GetEnvironmentAsArgs (Args &env) 945 { 946 GetHostEnvironmentIfNeeded (); 947 948 dictionary::const_iterator pos, end = m_env_vars.end(); 949 for (pos = m_env_vars.begin(); pos != end; ++pos) 950 { 951 std::string env_var_equal_value (pos->first); 952 env_var_equal_value.append(1, '='); 953 env_var_equal_value.append (pos->second); 954 env.AppendArgument (env_var_equal_value.c_str()); 955 } 956 return env.GetArgumentCount(); 957 } 958 959 960 const char * 961 Process::GetExitDescription () 962 { 963 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty()) 964 return m_exit_string.c_str(); 965 return NULL; 966 } 967 968 bool 969 Process::SetExitStatus (int status, const char *cstr) 970 { 971 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS)); 972 if (log) 973 log->Printf("Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)", 974 status, status, 975 cstr ? "\"" : "", 976 cstr ? cstr : "NULL", 977 cstr ? "\"" : ""); 978 979 // We were already in the exited state 980 if (m_private_state.GetValue() == eStateExited) 981 { 982 if (log) 983 log->Printf("Process::SetExitStatus () ignoring exit status because state was already set to eStateExited"); 984 return false; 985 } 986 987 m_exit_status = status; 988 if (cstr) 989 m_exit_string = cstr; 990 else 991 m_exit_string.clear(); 992 993 DidExit (); 994 995 SetPrivateState (eStateExited); 996 return true; 997 } 998 999 // This static callback can be used to watch for local child processes on 1000 // the current host. The the child process exits, the process will be 1001 // found in the global target list (we want to be completely sure that the 1002 // lldb_private::Process doesn't go away before we can deliver the signal. 1003 bool 1004 Process::SetProcessExitStatus 1005 ( 1006 void *callback_baton, 1007 lldb::pid_t pid, 1008 int signo, // Zero for no signal 1009 int exit_status // Exit value of process if signal is zero 1010 ) 1011 { 1012 if (signo == 0 || exit_status) 1013 { 1014 TargetSP target_sp(Debugger::FindTargetWithProcessID (pid)); 1015 if (target_sp) 1016 { 1017 ProcessSP process_sp (target_sp->GetProcessSP()); 1018 if (process_sp) 1019 { 1020 const char *signal_cstr = NULL; 1021 if (signo) 1022 signal_cstr = process_sp->GetUnixSignals().GetSignalAsCString (signo); 1023 1024 process_sp->SetExitStatus (exit_status, signal_cstr); 1025 } 1026 } 1027 return true; 1028 } 1029 return false; 1030 } 1031 1032 1033 void 1034 Process::UpdateThreadListIfNeeded () 1035 { 1036 const uint32_t stop_id = GetStopID(); 1037 if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID()) 1038 { 1039 Mutex::Locker locker (m_thread_list.GetMutex ()); 1040 ThreadList new_thread_list(this); 1041 // Always update the thread list with the protocol specific 1042 // thread list 1043 UpdateThreadList (m_thread_list, new_thread_list); 1044 OperatingSystem *os = GetOperatingSystem (); 1045 if (os) 1046 os->UpdateThreadList (m_thread_list, new_thread_list); 1047 m_thread_list.Update (new_thread_list); 1048 m_thread_list.SetStopID (stop_id); 1049 } 1050 } 1051 1052 uint32_t 1053 Process::GetNextThreadIndexID () 1054 { 1055 return ++m_thread_index_id; 1056 } 1057 1058 StateType 1059 Process::GetState() 1060 { 1061 // If any other threads access this we will need a mutex for it 1062 return m_public_state.GetValue (); 1063 } 1064 1065 void 1066 Process::SetPublicState (StateType new_state) 1067 { 1068 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS)); 1069 if (log) 1070 log->Printf("Process::SetPublicState (%s)", StateAsCString(new_state)); 1071 m_public_state.SetValue (new_state); 1072 } 1073 1074 StateType 1075 Process::GetPrivateState () 1076 { 1077 return m_private_state.GetValue(); 1078 } 1079 1080 void 1081 Process::SetPrivateState (StateType new_state) 1082 { 1083 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS)); 1084 bool state_changed = false; 1085 1086 if (log) 1087 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state)); 1088 1089 Mutex::Locker locker(m_private_state.GetMutex()); 1090 1091 const StateType old_state = m_private_state.GetValueNoLock (); 1092 state_changed = old_state != new_state; 1093 if (state_changed) 1094 { 1095 m_private_state.SetValueNoLock (new_state); 1096 if (StateIsStoppedState(new_state)) 1097 { 1098 m_mod_id.BumpStopID(); 1099 m_memory_cache.Clear(); 1100 if (log) 1101 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_mod_id.GetStopID()); 1102 } 1103 // Use our target to get a shared pointer to ourselves... 1104 m_private_state_broadcaster.BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (GetTarget().GetProcessSP(), new_state)); 1105 } 1106 else 1107 { 1108 if (log) 1109 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state), StateAsCString(old_state)); 1110 } 1111 } 1112 1113 addr_t 1114 Process::GetImageInfoAddress() 1115 { 1116 return LLDB_INVALID_ADDRESS; 1117 } 1118 1119 //---------------------------------------------------------------------- 1120 // LoadImage 1121 // 1122 // This function provides a default implementation that works for most 1123 // unix variants. Any Process subclasses that need to do shared library 1124 // loading differently should override LoadImage and UnloadImage and 1125 // do what is needed. 1126 //---------------------------------------------------------------------- 1127 uint32_t 1128 Process::LoadImage (const FileSpec &image_spec, Error &error) 1129 { 1130 DynamicLoader *loader = GetDynamicLoader(); 1131 if (loader) 1132 { 1133 error = loader->CanLoadImage(); 1134 if (error.Fail()) 1135 return LLDB_INVALID_IMAGE_TOKEN; 1136 } 1137 1138 if (error.Success()) 1139 { 1140 ThreadSP thread_sp(GetThreadList ().GetSelectedThread()); 1141 1142 if (thread_sp) 1143 { 1144 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0)); 1145 1146 if (frame_sp) 1147 { 1148 ExecutionContext exe_ctx; 1149 frame_sp->CalculateExecutionContext (exe_ctx); 1150 bool unwind_on_error = true; 1151 StreamString expr; 1152 char path[PATH_MAX]; 1153 image_spec.GetPath(path, sizeof(path)); 1154 expr.Printf("dlopen (\"%s\", 2)", path); 1155 const char *prefix = "extern \"C\" void* dlopen (const char *path, int mode);\n"; 1156 lldb::ValueObjectSP result_valobj_sp; 1157 ClangUserExpression::Evaluate (exe_ctx, eExecutionPolicyAlways, unwind_on_error, expr.GetData(), prefix, result_valobj_sp); 1158 error = result_valobj_sp->GetError(); 1159 if (error.Success()) 1160 { 1161 Scalar scalar; 1162 if (result_valobj_sp->ResolveValue (scalar)) 1163 { 1164 addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS); 1165 if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS) 1166 { 1167 uint32_t image_token = m_image_tokens.size(); 1168 m_image_tokens.push_back (image_ptr); 1169 return image_token; 1170 } 1171 } 1172 } 1173 } 1174 } 1175 } 1176 return LLDB_INVALID_IMAGE_TOKEN; 1177 } 1178 1179 //---------------------------------------------------------------------- 1180 // UnloadImage 1181 // 1182 // This function provides a default implementation that works for most 1183 // unix variants. Any Process subclasses that need to do shared library 1184 // loading differently should override LoadImage and UnloadImage and 1185 // do what is needed. 1186 //---------------------------------------------------------------------- 1187 Error 1188 Process::UnloadImage (uint32_t image_token) 1189 { 1190 Error error; 1191 if (image_token < m_image_tokens.size()) 1192 { 1193 const addr_t image_addr = m_image_tokens[image_token]; 1194 if (image_addr == LLDB_INVALID_ADDRESS) 1195 { 1196 error.SetErrorString("image already unloaded"); 1197 } 1198 else 1199 { 1200 DynamicLoader *loader = GetDynamicLoader(); 1201 if (loader) 1202 error = loader->CanLoadImage(); 1203 1204 if (error.Success()) 1205 { 1206 ThreadSP thread_sp(GetThreadList ().GetSelectedThread()); 1207 1208 if (thread_sp) 1209 { 1210 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0)); 1211 1212 if (frame_sp) 1213 { 1214 ExecutionContext exe_ctx; 1215 frame_sp->CalculateExecutionContext (exe_ctx); 1216 bool unwind_on_error = true; 1217 StreamString expr; 1218 expr.Printf("dlclose ((void *)0x%llx)", image_addr); 1219 const char *prefix = "extern \"C\" int dlclose(void* handle);\n"; 1220 lldb::ValueObjectSP result_valobj_sp; 1221 ClangUserExpression::Evaluate (exe_ctx, eExecutionPolicyAlways, unwind_on_error, expr.GetData(), prefix, result_valobj_sp); 1222 if (result_valobj_sp->GetError().Success()) 1223 { 1224 Scalar scalar; 1225 if (result_valobj_sp->ResolveValue (scalar)) 1226 { 1227 if (scalar.UInt(1)) 1228 { 1229 error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData()); 1230 } 1231 else 1232 { 1233 m_image_tokens[image_token] = LLDB_INVALID_ADDRESS; 1234 } 1235 } 1236 } 1237 else 1238 { 1239 error = result_valobj_sp->GetError(); 1240 } 1241 } 1242 } 1243 } 1244 } 1245 } 1246 else 1247 { 1248 error.SetErrorString("invalid image token"); 1249 } 1250 return error; 1251 } 1252 1253 const lldb::ABISP & 1254 Process::GetABI() 1255 { 1256 if (!m_abi_sp) 1257 m_abi_sp = ABI::FindPlugin(m_target.GetArchitecture()); 1258 return m_abi_sp; 1259 } 1260 1261 LanguageRuntime * 1262 Process::GetLanguageRuntime(lldb::LanguageType language) 1263 { 1264 LanguageRuntimeCollection::iterator pos; 1265 pos = m_language_runtimes.find (language); 1266 if (pos == m_language_runtimes.end()) 1267 { 1268 lldb::LanguageRuntimeSP runtime(LanguageRuntime::FindPlugin(this, language)); 1269 1270 m_language_runtimes[language] 1271 = runtime; 1272 return runtime.get(); 1273 } 1274 else 1275 return (*pos).second.get(); 1276 } 1277 1278 CPPLanguageRuntime * 1279 Process::GetCPPLanguageRuntime () 1280 { 1281 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus); 1282 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus) 1283 return static_cast<CPPLanguageRuntime *> (runtime); 1284 return NULL; 1285 } 1286 1287 ObjCLanguageRuntime * 1288 Process::GetObjCLanguageRuntime () 1289 { 1290 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC); 1291 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC) 1292 return static_cast<ObjCLanguageRuntime *> (runtime); 1293 return NULL; 1294 } 1295 1296 BreakpointSiteList & 1297 Process::GetBreakpointSiteList() 1298 { 1299 return m_breakpoint_site_list; 1300 } 1301 1302 const BreakpointSiteList & 1303 Process::GetBreakpointSiteList() const 1304 { 1305 return m_breakpoint_site_list; 1306 } 1307 1308 1309 void 1310 Process::DisableAllBreakpointSites () 1311 { 1312 m_breakpoint_site_list.SetEnabledForAll (false); 1313 } 1314 1315 Error 1316 Process::ClearBreakpointSiteByID (lldb::user_id_t break_id) 1317 { 1318 Error error (DisableBreakpointSiteByID (break_id)); 1319 1320 if (error.Success()) 1321 m_breakpoint_site_list.Remove(break_id); 1322 1323 return error; 1324 } 1325 1326 Error 1327 Process::DisableBreakpointSiteByID (lldb::user_id_t break_id) 1328 { 1329 Error error; 1330 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id); 1331 if (bp_site_sp) 1332 { 1333 if (bp_site_sp->IsEnabled()) 1334 error = DisableBreakpoint (bp_site_sp.get()); 1335 } 1336 else 1337 { 1338 error.SetErrorStringWithFormat("invalid breakpoint site ID: %i", break_id); 1339 } 1340 1341 return error; 1342 } 1343 1344 Error 1345 Process::EnableBreakpointSiteByID (lldb::user_id_t break_id) 1346 { 1347 Error error; 1348 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id); 1349 if (bp_site_sp) 1350 { 1351 if (!bp_site_sp->IsEnabled()) 1352 error = EnableBreakpoint (bp_site_sp.get()); 1353 } 1354 else 1355 { 1356 error.SetErrorStringWithFormat("invalid breakpoint site ID: %i", break_id); 1357 } 1358 return error; 1359 } 1360 1361 lldb::break_id_t 1362 Process::CreateBreakpointSite (BreakpointLocationSP &owner, bool use_hardware) 1363 { 1364 const addr_t load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target); 1365 if (load_addr != LLDB_INVALID_ADDRESS) 1366 { 1367 BreakpointSiteSP bp_site_sp; 1368 1369 // Look up this breakpoint site. If it exists, then add this new owner, otherwise 1370 // create a new breakpoint site and add it. 1371 1372 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr); 1373 1374 if (bp_site_sp) 1375 { 1376 bp_site_sp->AddOwner (owner); 1377 owner->SetBreakpointSite (bp_site_sp); 1378 return bp_site_sp->GetID(); 1379 } 1380 else 1381 { 1382 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, LLDB_INVALID_THREAD_ID, use_hardware)); 1383 if (bp_site_sp) 1384 { 1385 if (EnableBreakpoint (bp_site_sp.get()).Success()) 1386 { 1387 owner->SetBreakpointSite (bp_site_sp); 1388 return m_breakpoint_site_list.Add (bp_site_sp); 1389 } 1390 } 1391 } 1392 } 1393 // We failed to enable the breakpoint 1394 return LLDB_INVALID_BREAK_ID; 1395 1396 } 1397 1398 void 1399 Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp) 1400 { 1401 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id); 1402 if (num_owners == 0) 1403 { 1404 DisableBreakpoint(bp_site_sp.get()); 1405 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress()); 1406 } 1407 } 1408 1409 1410 size_t 1411 Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const 1412 { 1413 size_t bytes_removed = 0; 1414 addr_t intersect_addr; 1415 size_t intersect_size; 1416 size_t opcode_offset; 1417 size_t idx; 1418 BreakpointSiteSP bp; 1419 BreakpointSiteList bp_sites_in_range; 1420 1421 if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range)) 1422 { 1423 for (idx = 0; (bp = bp_sites_in_range.GetByIndex(idx)) != NULL; ++idx) 1424 { 1425 if (bp->GetType() == BreakpointSite::eSoftware) 1426 { 1427 if (bp->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset)) 1428 { 1429 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size); 1430 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size); 1431 assert(opcode_offset + intersect_size <= bp->GetByteSize()); 1432 size_t buf_offset = intersect_addr - bp_addr; 1433 ::memcpy(buf + buf_offset, bp->GetSavedOpcodeBytes() + opcode_offset, intersect_size); 1434 } 1435 } 1436 } 1437 } 1438 return bytes_removed; 1439 } 1440 1441 1442 1443 size_t 1444 Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site) 1445 { 1446 PlatformSP platform_sp (m_target.GetPlatform()); 1447 if (platform_sp) 1448 return platform_sp->GetSoftwareBreakpointTrapOpcode (m_target, bp_site); 1449 return 0; 1450 } 1451 1452 Error 1453 Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site) 1454 { 1455 Error error; 1456 assert (bp_site != NULL); 1457 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 1458 const addr_t bp_addr = bp_site->GetLoadAddress(); 1459 if (log) 1460 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx", bp_site->GetID(), (uint64_t)bp_addr); 1461 if (bp_site->IsEnabled()) 1462 { 1463 if (log) 1464 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already enabled", bp_site->GetID(), (uint64_t)bp_addr); 1465 return error; 1466 } 1467 1468 if (bp_addr == LLDB_INVALID_ADDRESS) 1469 { 1470 error.SetErrorString("BreakpointSite contains an invalid load address."); 1471 return error; 1472 } 1473 // Ask the lldb::Process subclass to fill in the correct software breakpoint 1474 // trap for the breakpoint site 1475 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site); 1476 1477 if (bp_opcode_size == 0) 1478 { 1479 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%llx.\n", bp_addr); 1480 } 1481 else 1482 { 1483 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes(); 1484 1485 if (bp_opcode_bytes == NULL) 1486 { 1487 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode."); 1488 return error; 1489 } 1490 1491 // Save the original opcode by reading it 1492 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size) 1493 { 1494 // Write a software breakpoint in place of the original opcode 1495 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size) 1496 { 1497 uint8_t verify_bp_opcode_bytes[64]; 1498 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size) 1499 { 1500 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0) 1501 { 1502 bp_site->SetEnabled(true); 1503 bp_site->SetType (BreakpointSite::eSoftware); 1504 if (log) 1505 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS", 1506 bp_site->GetID(), 1507 (uint64_t)bp_addr); 1508 } 1509 else 1510 error.SetErrorString("Failed to verify the breakpoint trap in memory."); 1511 } 1512 else 1513 error.SetErrorString("Unable to read memory to verify breakpoint trap."); 1514 } 1515 else 1516 error.SetErrorString("Unable to write breakpoint trap to memory."); 1517 } 1518 else 1519 error.SetErrorString("Unable to read memory at breakpoint address."); 1520 } 1521 if (log && error.Fail()) 1522 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s", 1523 bp_site->GetID(), 1524 (uint64_t)bp_addr, 1525 error.AsCString()); 1526 return error; 1527 } 1528 1529 Error 1530 Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site) 1531 { 1532 Error error; 1533 assert (bp_site != NULL); 1534 LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); 1535 addr_t bp_addr = bp_site->GetLoadAddress(); 1536 lldb::user_id_t breakID = bp_site->GetID(); 1537 if (log) 1538 log->Printf ("Process::DisableBreakpoint (breakID = %d) addr = 0x%llx", breakID, (uint64_t)bp_addr); 1539 1540 if (bp_site->IsHardware()) 1541 { 1542 error.SetErrorString("Breakpoint site is a hardware breakpoint."); 1543 } 1544 else if (bp_site->IsEnabled()) 1545 { 1546 const size_t break_op_size = bp_site->GetByteSize(); 1547 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes(); 1548 if (break_op_size > 0) 1549 { 1550 // Clear a software breakoint instruction 1551 uint8_t curr_break_op[8]; 1552 assert (break_op_size <= sizeof(curr_break_op)); 1553 bool break_op_found = false; 1554 1555 // Read the breakpoint opcode 1556 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size) 1557 { 1558 bool verify = false; 1559 // Make sure we have the a breakpoint opcode exists at this address 1560 if (::memcmp (curr_break_op, break_op, break_op_size) == 0) 1561 { 1562 break_op_found = true; 1563 // We found a valid breakpoint opcode at this address, now restore 1564 // the saved opcode. 1565 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size) 1566 { 1567 verify = true; 1568 } 1569 else 1570 error.SetErrorString("Memory write failed when restoring original opcode."); 1571 } 1572 else 1573 { 1574 error.SetErrorString("Original breakpoint trap is no longer in memory."); 1575 // Set verify to true and so we can check if the original opcode has already been restored 1576 verify = true; 1577 } 1578 1579 if (verify) 1580 { 1581 uint8_t verify_opcode[8]; 1582 assert (break_op_size < sizeof(verify_opcode)); 1583 // Verify that our original opcode made it back to the inferior 1584 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size) 1585 { 1586 // compare the memory we just read with the original opcode 1587 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0) 1588 { 1589 // SUCCESS 1590 bp_site->SetEnabled(false); 1591 if (log) 1592 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS", bp_site->GetID(), (uint64_t)bp_addr); 1593 return error; 1594 } 1595 else 1596 { 1597 if (break_op_found) 1598 error.SetErrorString("Failed to restore original opcode."); 1599 } 1600 } 1601 else 1602 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored."); 1603 } 1604 } 1605 else 1606 error.SetErrorString("Unable to read memory that should contain the breakpoint trap."); 1607 } 1608 } 1609 else 1610 { 1611 if (log) 1612 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already disabled", bp_site->GetID(), (uint64_t)bp_addr); 1613 return error; 1614 } 1615 1616 if (log) 1617 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s", 1618 bp_site->GetID(), 1619 (uint64_t)bp_addr, 1620 error.AsCString()); 1621 return error; 1622 1623 } 1624 1625 // Comment out line below to disable memory caching 1626 #define ENABLE_MEMORY_CACHING 1627 // Uncomment to verify memory caching works after making changes to caching code 1628 //#define VERIFY_MEMORY_READS 1629 1630 #if defined (ENABLE_MEMORY_CACHING) 1631 1632 #if defined (VERIFY_MEMORY_READS) 1633 1634 size_t 1635 Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error) 1636 { 1637 // Memory caching is enabled, with debug verification 1638 if (buf && size) 1639 { 1640 // Uncomment the line below to make sure memory caching is working. 1641 // I ran this through the test suite and got no assertions, so I am 1642 // pretty confident this is working well. If any changes are made to 1643 // memory caching, uncomment the line below and test your changes! 1644 1645 // Verify all memory reads by using the cache first, then redundantly 1646 // reading the same memory from the inferior and comparing to make sure 1647 // everything is exactly the same. 1648 std::string verify_buf (size, '\0'); 1649 assert (verify_buf.size() == size); 1650 const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error); 1651 Error verify_error; 1652 const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error); 1653 assert (cache_bytes_read == verify_bytes_read); 1654 assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0); 1655 assert (verify_error.Success() == error.Success()); 1656 return cache_bytes_read; 1657 } 1658 return 0; 1659 } 1660 1661 #else // #if defined (VERIFY_MEMORY_READS) 1662 1663 size_t 1664 Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error) 1665 { 1666 // Memory caching enabled, no verification 1667 return m_memory_cache.Read (addr, buf, size, error); 1668 } 1669 1670 #endif // #else for #if defined (VERIFY_MEMORY_READS) 1671 1672 #else // #if defined (ENABLE_MEMORY_CACHING) 1673 1674 size_t 1675 Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error) 1676 { 1677 // Memory caching is disabled 1678 return ReadMemoryFromInferior (addr, buf, size, error); 1679 } 1680 1681 #endif // #else for #if defined (ENABLE_MEMORY_CACHING) 1682 1683 1684 size_t 1685 Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len) 1686 { 1687 size_t total_cstr_len = 0; 1688 if (dst && dst_max_len) 1689 { 1690 // NULL out everything just to be safe 1691 memset (dst, 0, dst_max_len); 1692 Error error; 1693 addr_t curr_addr = addr; 1694 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize(); 1695 size_t bytes_left = dst_max_len - 1; 1696 char *curr_dst = dst; 1697 1698 while (bytes_left > 0) 1699 { 1700 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size); 1701 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left); 1702 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error); 1703 1704 if (bytes_read == 0) 1705 { 1706 dst[total_cstr_len] = '\0'; 1707 break; 1708 } 1709 const size_t len = strlen(curr_dst); 1710 1711 total_cstr_len += len; 1712 1713 if (len < bytes_to_read) 1714 break; 1715 1716 curr_dst += bytes_read; 1717 curr_addr += bytes_read; 1718 bytes_left -= bytes_read; 1719 } 1720 } 1721 return total_cstr_len; 1722 } 1723 1724 size_t 1725 Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error) 1726 { 1727 if (buf == NULL || size == 0) 1728 return 0; 1729 1730 size_t bytes_read = 0; 1731 uint8_t *bytes = (uint8_t *)buf; 1732 1733 while (bytes_read < size) 1734 { 1735 const size_t curr_size = size - bytes_read; 1736 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read, 1737 bytes + bytes_read, 1738 curr_size, 1739 error); 1740 bytes_read += curr_bytes_read; 1741 if (curr_bytes_read == curr_size || curr_bytes_read == 0) 1742 break; 1743 } 1744 1745 // Replace any software breakpoint opcodes that fall into this range back 1746 // into "buf" before we return 1747 if (bytes_read > 0) 1748 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf); 1749 return bytes_read; 1750 } 1751 1752 uint64_t 1753 Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error) 1754 { 1755 Scalar scalar; 1756 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error)) 1757 return scalar.ULongLong(fail_value); 1758 return fail_value; 1759 } 1760 1761 addr_t 1762 Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error) 1763 { 1764 Scalar scalar; 1765 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error)) 1766 return scalar.ULongLong(LLDB_INVALID_ADDRESS); 1767 return LLDB_INVALID_ADDRESS; 1768 } 1769 1770 1771 bool 1772 Process::WritePointerToMemory (lldb::addr_t vm_addr, 1773 lldb::addr_t ptr_value, 1774 Error &error) 1775 { 1776 Scalar scalar; 1777 const uint32_t addr_byte_size = GetAddressByteSize(); 1778 if (addr_byte_size <= 4) 1779 scalar = (uint32_t)ptr_value; 1780 else 1781 scalar = ptr_value; 1782 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size; 1783 } 1784 1785 size_t 1786 Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error) 1787 { 1788 size_t bytes_written = 0; 1789 const uint8_t *bytes = (const uint8_t *)buf; 1790 1791 while (bytes_written < size) 1792 { 1793 const size_t curr_size = size - bytes_written; 1794 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written, 1795 bytes + bytes_written, 1796 curr_size, 1797 error); 1798 bytes_written += curr_bytes_written; 1799 if (curr_bytes_written == curr_size || curr_bytes_written == 0) 1800 break; 1801 } 1802 return bytes_written; 1803 } 1804 1805 size_t 1806 Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error) 1807 { 1808 #if defined (ENABLE_MEMORY_CACHING) 1809 m_memory_cache.Flush (addr, size); 1810 #endif 1811 1812 if (buf == NULL || size == 0) 1813 return 0; 1814 1815 m_mod_id.BumpMemoryID(); 1816 1817 // We need to write any data that would go where any current software traps 1818 // (enabled software breakpoints) any software traps (breakpoints) that we 1819 // may have placed in our tasks memory. 1820 1821 BreakpointSiteList::collection::const_iterator iter = m_breakpoint_site_list.GetMap()->lower_bound (addr); 1822 BreakpointSiteList::collection::const_iterator end = m_breakpoint_site_list.GetMap()->end(); 1823 1824 if (iter == end || iter->second->GetLoadAddress() > addr + size) 1825 return WriteMemoryPrivate (addr, buf, size, error); 1826 1827 BreakpointSiteList::collection::const_iterator pos; 1828 size_t bytes_written = 0; 1829 addr_t intersect_addr = 0; 1830 size_t intersect_size = 0; 1831 size_t opcode_offset = 0; 1832 const uint8_t *ubuf = (const uint8_t *)buf; 1833 1834 for (pos = iter; pos != end; ++pos) 1835 { 1836 BreakpointSiteSP bp; 1837 bp = pos->second; 1838 1839 assert(bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset)); 1840 assert(addr <= intersect_addr && intersect_addr < addr + size); 1841 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size); 1842 assert(opcode_offset + intersect_size <= bp->GetByteSize()); 1843 1844 // Check for bytes before this breakpoint 1845 const addr_t curr_addr = addr + bytes_written; 1846 if (intersect_addr > curr_addr) 1847 { 1848 // There are some bytes before this breakpoint that we need to 1849 // just write to memory 1850 size_t curr_size = intersect_addr - curr_addr; 1851 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr, 1852 ubuf + bytes_written, 1853 curr_size, 1854 error); 1855 bytes_written += curr_bytes_written; 1856 if (curr_bytes_written != curr_size) 1857 { 1858 // We weren't able to write all of the requested bytes, we 1859 // are done looping and will return the number of bytes that 1860 // we have written so far. 1861 break; 1862 } 1863 } 1864 1865 // Now write any bytes that would cover up any software breakpoints 1866 // directly into the breakpoint opcode buffer 1867 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size); 1868 bytes_written += intersect_size; 1869 } 1870 1871 // Write any remaining bytes after the last breakpoint if we have any left 1872 if (bytes_written < size) 1873 bytes_written += WriteMemoryPrivate (addr + bytes_written, 1874 ubuf + bytes_written, 1875 size - bytes_written, 1876 error); 1877 1878 return bytes_written; 1879 } 1880 1881 size_t 1882 Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, uint32_t byte_size, Error &error) 1883 { 1884 if (byte_size == UINT32_MAX) 1885 byte_size = scalar.GetByteSize(); 1886 if (byte_size > 0) 1887 { 1888 uint8_t buf[32]; 1889 const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error); 1890 if (mem_size > 0) 1891 return WriteMemory(addr, buf, mem_size, error); 1892 else 1893 error.SetErrorString ("failed to get scalar as memory data"); 1894 } 1895 else 1896 { 1897 error.SetErrorString ("invalid scalar value"); 1898 } 1899 return 0; 1900 } 1901 1902 size_t 1903 Process::ReadScalarIntegerFromMemory (addr_t addr, 1904 uint32_t byte_size, 1905 bool is_signed, 1906 Scalar &scalar, 1907 Error &error) 1908 { 1909 uint64_t uval; 1910 1911 if (byte_size <= sizeof(uval)) 1912 { 1913 size_t bytes_read = ReadMemory (addr, &uval, byte_size, error); 1914 if (bytes_read == byte_size) 1915 { 1916 DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize()); 1917 uint32_t offset = 0; 1918 if (byte_size <= 4) 1919 scalar = data.GetMaxU32 (&offset, byte_size); 1920 else 1921 scalar = data.GetMaxU64 (&offset, byte_size); 1922 1923 if (is_signed) 1924 scalar.SignExtend(byte_size * 8); 1925 return bytes_read; 1926 } 1927 } 1928 else 1929 { 1930 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size); 1931 } 1932 return 0; 1933 } 1934 1935 #define USE_ALLOCATE_MEMORY_CACHE 1 1936 addr_t 1937 Process::AllocateMemory(size_t size, uint32_t permissions, Error &error) 1938 { 1939 if (GetPrivateState() != eStateStopped) 1940 return LLDB_INVALID_ADDRESS; 1941 1942 #if defined (USE_ALLOCATE_MEMORY_CACHE) 1943 return m_allocated_memory_cache.AllocateMemory(size, permissions, error); 1944 #else 1945 addr_t allocated_addr = DoAllocateMemory (size, permissions, error); 1946 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1947 if (log) 1948 log->Printf("Process::AllocateMemory(size=%4zu, permissions=%s) => 0x%16.16llx (m_stop_id = %u m_memory_id = %u)", 1949 size, 1950 GetPermissionsAsCString (permissions), 1951 (uint64_t)allocated_addr, 1952 m_mod_id.GetStopID(), 1953 m_mod_id.GetMemoryID()); 1954 return allocated_addr; 1955 #endif 1956 } 1957 1958 Error 1959 Process::DeallocateMemory (addr_t ptr) 1960 { 1961 Error error; 1962 #if defined (USE_ALLOCATE_MEMORY_CACHE) 1963 if (!m_allocated_memory_cache.DeallocateMemory(ptr)) 1964 { 1965 error.SetErrorStringWithFormat ("deallocation of memory at 0x%llx failed.", (uint64_t)ptr); 1966 } 1967 #else 1968 error = DoDeallocateMemory (ptr); 1969 1970 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 1971 if (log) 1972 log->Printf("Process::DeallocateMemory(addr=0x%16.16llx) => err = %s (m_stop_id = %u, m_memory_id = %u)", 1973 ptr, 1974 error.AsCString("SUCCESS"), 1975 m_mod_id.GetStopID(), 1976 m_mod_id.GetMemoryID()); 1977 #endif 1978 return error; 1979 } 1980 1981 1982 Error 1983 Process::EnableWatchpoint (WatchpointLocation *watchpoint) 1984 { 1985 Error error; 1986 error.SetErrorString("watchpoints are not supported"); 1987 return error; 1988 } 1989 1990 Error 1991 Process::DisableWatchpoint (WatchpointLocation *watchpoint) 1992 { 1993 Error error; 1994 error.SetErrorString("watchpoints are not supported"); 1995 return error; 1996 } 1997 1998 StateType 1999 Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp) 2000 { 2001 StateType state; 2002 // Now wait for the process to launch and return control to us, and then 2003 // call DidLaunch: 2004 while (1) 2005 { 2006 event_sp.reset(); 2007 state = WaitForStateChangedEventsPrivate (timeout, event_sp); 2008 2009 if (StateIsStoppedState(state)) 2010 break; 2011 2012 // If state is invalid, then we timed out 2013 if (state == eStateInvalid) 2014 break; 2015 2016 if (event_sp) 2017 HandlePrivateEvent (event_sp); 2018 } 2019 return state; 2020 } 2021 2022 Error 2023 Process::Launch 2024 ( 2025 char const *argv[], 2026 char const *envp[], 2027 uint32_t launch_flags, 2028 const char *stdin_path, 2029 const char *stdout_path, 2030 const char *stderr_path, 2031 const char *working_directory 2032 ) 2033 { 2034 Error error; 2035 m_abi_sp.reset(); 2036 m_dyld_ap.reset(); 2037 m_os_ap.reset(); 2038 m_process_input_reader.reset(); 2039 2040 Module *exe_module = m_target.GetExecutableModulePointer(); 2041 if (exe_module) 2042 { 2043 char local_exec_file_path[PATH_MAX]; 2044 char platform_exec_file_path[PATH_MAX]; 2045 exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path)); 2046 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path)); 2047 if (exe_module->GetFileSpec().Exists()) 2048 { 2049 if (PrivateStateThreadIsValid ()) 2050 PausePrivateStateThread (); 2051 2052 error = WillLaunch (exe_module); 2053 if (error.Success()) 2054 { 2055 SetPublicState (eStateLaunching); 2056 // The args coming in should not contain the application name, the 2057 // lldb_private::Process class will add this in case the executable 2058 // gets resolved to a different file than was given on the command 2059 // line (like when an applicaiton bundle is specified and will 2060 // resolve to the contained exectuable file, or the file given was 2061 // a symlink or other file system link that resolves to a different 2062 // file). 2063 2064 // Get the resolved exectuable path 2065 2066 // Make a new argument vector 2067 std::vector<const char *> exec_path_plus_argv; 2068 // Append the resolved executable path 2069 exec_path_plus_argv.push_back (platform_exec_file_path); 2070 2071 // Push all args if there are any 2072 if (argv) 2073 { 2074 for (int i = 0; argv[i]; ++i) 2075 exec_path_plus_argv.push_back(argv[i]); 2076 } 2077 2078 // Push a NULL to terminate the args. 2079 exec_path_plus_argv.push_back(NULL); 2080 2081 // Now launch using these arguments. 2082 error = DoLaunch (exe_module, 2083 exec_path_plus_argv.empty() ? NULL : &exec_path_plus_argv.front(), 2084 envp, 2085 launch_flags, 2086 stdin_path, 2087 stdout_path, 2088 stderr_path, 2089 working_directory); 2090 2091 if (error.Fail()) 2092 { 2093 if (GetID() != LLDB_INVALID_PROCESS_ID) 2094 { 2095 SetID (LLDB_INVALID_PROCESS_ID); 2096 const char *error_string = error.AsCString(); 2097 if (error_string == NULL) 2098 error_string = "launch failed"; 2099 SetExitStatus (-1, error_string); 2100 } 2101 } 2102 else 2103 { 2104 EventSP event_sp; 2105 TimeValue timeout_time; 2106 timeout_time = TimeValue::Now(); 2107 timeout_time.OffsetWithSeconds(10); 2108 StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp); 2109 2110 if (state == eStateInvalid || event_sp.get() == NULL) 2111 { 2112 // We were able to launch the process, but we failed to 2113 // catch the initial stop. 2114 SetExitStatus (0, "failed to catch stop after launch"); 2115 Destroy(); 2116 } 2117 else if (state == eStateStopped || state == eStateCrashed) 2118 { 2119 2120 DidLaunch (); 2121 2122 m_dyld_ap.reset (DynamicLoader::FindPlugin (this, NULL)); 2123 if (m_dyld_ap.get()) 2124 m_dyld_ap->DidLaunch(); 2125 2126 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL)); 2127 // This delays passing the stopped event to listeners till DidLaunch gets 2128 // a chance to complete... 2129 HandlePrivateEvent (event_sp); 2130 2131 if (PrivateStateThreadIsValid ()) 2132 ResumePrivateStateThread (); 2133 else 2134 StartPrivateStateThread (); 2135 } 2136 else if (state == eStateExited) 2137 { 2138 // We exited while trying to launch somehow. Don't call DidLaunch as that's 2139 // not likely to work, and return an invalid pid. 2140 HandlePrivateEvent (event_sp); 2141 } 2142 } 2143 } 2144 } 2145 else 2146 { 2147 error.SetErrorStringWithFormat("File doesn't exist: '%s'.\n", local_exec_file_path); 2148 } 2149 } 2150 return error; 2151 } 2152 2153 Process::NextEventAction::EventActionResult 2154 Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp) 2155 { 2156 StateType state = ProcessEventData::GetStateFromEvent (event_sp.get()); 2157 switch (state) 2158 { 2159 case eStateRunning: 2160 case eStateConnected: 2161 return eEventActionRetry; 2162 2163 case eStateStopped: 2164 case eStateCrashed: 2165 { 2166 // During attach, prior to sending the eStateStopped event, 2167 // lldb_private::Process subclasses must set the process must set 2168 // the new process ID. 2169 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID); 2170 m_process->CompleteAttach (); 2171 return eEventActionSuccess; 2172 } 2173 2174 2175 break; 2176 default: 2177 case eStateExited: 2178 case eStateInvalid: 2179 m_exit_string.assign ("No valid Process"); 2180 return eEventActionExit; 2181 break; 2182 } 2183 } 2184 2185 Process::NextEventAction::EventActionResult 2186 Process::AttachCompletionHandler::HandleBeingInterrupted() 2187 { 2188 return eEventActionSuccess; 2189 } 2190 2191 const char * 2192 Process::AttachCompletionHandler::GetExitString () 2193 { 2194 return m_exit_string.c_str(); 2195 } 2196 2197 Error 2198 Process::Attach (lldb::pid_t attach_pid) 2199 { 2200 2201 m_abi_sp.reset(); 2202 m_process_input_reader.reset(); 2203 2204 m_dyld_ap.reset(); 2205 m_os_ap.reset(); 2206 2207 Error error (WillAttachToProcessWithID(attach_pid)); 2208 if (error.Success()) 2209 { 2210 SetPublicState (eStateAttaching); 2211 2212 error = DoAttachToProcessWithID (attach_pid); 2213 if (error.Success()) 2214 { 2215 SetNextEventAction(new Process::AttachCompletionHandler(this)); 2216 StartPrivateStateThread(); 2217 } 2218 else 2219 { 2220 if (GetID() != LLDB_INVALID_PROCESS_ID) 2221 { 2222 SetID (LLDB_INVALID_PROCESS_ID); 2223 const char *error_string = error.AsCString(); 2224 if (error_string == NULL) 2225 error_string = "attach failed"; 2226 2227 SetExitStatus(-1, error_string); 2228 } 2229 } 2230 } 2231 return error; 2232 } 2233 2234 Error 2235 Process::Attach (const char *process_name, bool wait_for_launch) 2236 { 2237 m_abi_sp.reset(); 2238 m_process_input_reader.reset(); 2239 2240 // Find the process and its architecture. Make sure it matches the architecture 2241 // of the current Target, and if not adjust it. 2242 Error error; 2243 2244 if (!wait_for_launch) 2245 { 2246 ProcessInstanceInfoList process_infos; 2247 PlatformSP platform_sp (m_target.GetPlatform ()); 2248 assert (platform_sp.get()); 2249 2250 if (platform_sp) 2251 { 2252 ProcessInstanceInfoMatch match_info; 2253 match_info.GetProcessInfo().SetName(process_name); 2254 match_info.SetNameMatchType (eNameMatchEquals); 2255 platform_sp->FindProcesses (match_info, process_infos); 2256 if (process_infos.GetSize() > 1) 2257 { 2258 error.SetErrorStringWithFormat ("More than one process named %s\n", process_name); 2259 } 2260 else if (process_infos.GetSize() == 0) 2261 { 2262 error.SetErrorStringWithFormat ("Could not find a process named %s\n", process_name); 2263 } 2264 } 2265 else 2266 { 2267 error.SetErrorString ("Invalid platform"); 2268 } 2269 } 2270 2271 if (error.Success()) 2272 { 2273 m_dyld_ap.reset(); 2274 m_os_ap.reset(); 2275 2276 error = WillAttachToProcessWithName(process_name, wait_for_launch); 2277 if (error.Success()) 2278 { 2279 SetPublicState (eStateAttaching); 2280 error = DoAttachToProcessWithName (process_name, wait_for_launch); 2281 if (error.Fail()) 2282 { 2283 if (GetID() != LLDB_INVALID_PROCESS_ID) 2284 { 2285 SetID (LLDB_INVALID_PROCESS_ID); 2286 const char *error_string = error.AsCString(); 2287 if (error_string == NULL) 2288 error_string = "attach failed"; 2289 2290 SetExitStatus(-1, error_string); 2291 } 2292 } 2293 else 2294 { 2295 SetNextEventAction(new Process::AttachCompletionHandler(this)); 2296 StartPrivateStateThread(); 2297 } 2298 } 2299 } 2300 return error; 2301 } 2302 2303 void 2304 Process::CompleteAttach () 2305 { 2306 // Let the process subclass figure out at much as it can about the process 2307 // before we go looking for a dynamic loader plug-in. 2308 DidAttach(); 2309 2310 // We just attached. If we have a platform, ask it for the process architecture, and if it isn't 2311 // the same as the one we've already set, switch architectures. 2312 PlatformSP platform_sp (m_target.GetPlatform ()); 2313 assert (platform_sp.get()); 2314 if (platform_sp) 2315 { 2316 ProcessInstanceInfo process_info; 2317 platform_sp->GetProcessInfo (GetID(), process_info); 2318 const ArchSpec &process_arch = process_info.GetArchitecture(); 2319 if (process_arch.IsValid() && m_target.GetArchitecture() != process_arch) 2320 m_target.SetArchitecture (process_arch); 2321 } 2322 2323 // We have completed the attach, now it is time to find the dynamic loader 2324 // plug-in 2325 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL)); 2326 if (m_dyld_ap.get()) 2327 m_dyld_ap->DidAttach(); 2328 2329 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL)); 2330 // Figure out which one is the executable, and set that in our target: 2331 ModuleList &modules = m_target.GetImages(); 2332 2333 size_t num_modules = modules.GetSize(); 2334 for (int i = 0; i < num_modules; i++) 2335 { 2336 ModuleSP module_sp (modules.GetModuleAtIndex(i)); 2337 if (module_sp && module_sp->IsExecutable()) 2338 { 2339 if (m_target.GetExecutableModulePointer() != module_sp.get()) 2340 m_target.SetExecutableModule (module_sp, false); 2341 break; 2342 } 2343 } 2344 } 2345 2346 Error 2347 Process::ConnectRemote (const char *remote_url) 2348 { 2349 m_abi_sp.reset(); 2350 m_process_input_reader.reset(); 2351 2352 // Find the process and its architecture. Make sure it matches the architecture 2353 // of the current Target, and if not adjust it. 2354 2355 Error error (DoConnectRemote (remote_url)); 2356 if (error.Success()) 2357 { 2358 if (GetID() != LLDB_INVALID_PROCESS_ID) 2359 { 2360 EventSP event_sp; 2361 StateType state = WaitForProcessStopPrivate(NULL, event_sp); 2362 2363 if (state == eStateStopped || state == eStateCrashed) 2364 { 2365 // If we attached and actually have a process on the other end, then 2366 // this ended up being the equivalent of an attach. 2367 CompleteAttach (); 2368 2369 // This delays passing the stopped event to listeners till 2370 // CompleteAttach gets a chance to complete... 2371 HandlePrivateEvent (event_sp); 2372 2373 } 2374 } 2375 2376 if (PrivateStateThreadIsValid ()) 2377 ResumePrivateStateThread (); 2378 else 2379 StartPrivateStateThread (); 2380 } 2381 return error; 2382 } 2383 2384 2385 Error 2386 Process::Resume () 2387 { 2388 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2389 if (log) 2390 log->Printf("Process::Resume() m_stop_id = %u, public state: %s private state: %s", 2391 m_mod_id.GetStopID(), 2392 StateAsCString(m_public_state.GetValue()), 2393 StateAsCString(m_private_state.GetValue())); 2394 2395 Error error (WillResume()); 2396 // Tell the process it is about to resume before the thread list 2397 if (error.Success()) 2398 { 2399 // Now let the thread list know we are about to resume so it 2400 // can let all of our threads know that they are about to be 2401 // resumed. Threads will each be called with 2402 // Thread::WillResume(StateType) where StateType contains the state 2403 // that they are supposed to have when the process is resumed 2404 // (suspended/running/stepping). Threads should also check 2405 // their resume signal in lldb::Thread::GetResumeSignal() 2406 // to see if they are suppoed to start back up with a signal. 2407 if (m_thread_list.WillResume()) 2408 { 2409 error = DoResume(); 2410 if (error.Success()) 2411 { 2412 DidResume(); 2413 m_thread_list.DidResume(); 2414 if (log) 2415 log->Printf ("Process thinks the process has resumed."); 2416 } 2417 } 2418 else 2419 { 2420 error.SetErrorStringWithFormat("Process::WillResume() thread list returned false after WillResume"); 2421 } 2422 } 2423 else if (log) 2424 log->Printf ("Process::WillResume() got an error \"%s\".", error.AsCString("<unknown error>")); 2425 return error; 2426 } 2427 2428 Error 2429 Process::Halt () 2430 { 2431 // Pause our private state thread so we can ensure no one else eats 2432 // the stop event out from under us. 2433 Listener halt_listener ("lldb.process.halt_listener"); 2434 HijackPrivateProcessEvents(&halt_listener); 2435 2436 EventSP event_sp; 2437 Error error (WillHalt()); 2438 2439 if (error.Success()) 2440 { 2441 2442 bool caused_stop = false; 2443 2444 // Ask the process subclass to actually halt our process 2445 error = DoHalt(caused_stop); 2446 if (error.Success()) 2447 { 2448 if (m_public_state.GetValue() == eStateAttaching) 2449 { 2450 SetExitStatus(SIGKILL, "Cancelled async attach."); 2451 Destroy (); 2452 } 2453 else 2454 { 2455 // If "caused_stop" is true, then DoHalt stopped the process. If 2456 // "caused_stop" is false, the process was already stopped. 2457 // If the DoHalt caused the process to stop, then we want to catch 2458 // this event and set the interrupted bool to true before we pass 2459 // this along so clients know that the process was interrupted by 2460 // a halt command. 2461 if (caused_stop) 2462 { 2463 // Wait for 1 second for the process to stop. 2464 TimeValue timeout_time; 2465 timeout_time = TimeValue::Now(); 2466 timeout_time.OffsetWithSeconds(1); 2467 bool got_event = halt_listener.WaitForEvent (&timeout_time, event_sp); 2468 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get()); 2469 2470 if (!got_event || state == eStateInvalid) 2471 { 2472 // We timeout out and didn't get a stop event... 2473 error.SetErrorStringWithFormat ("Halt timed out. State = %s", StateAsCString(GetState())); 2474 } 2475 else 2476 { 2477 if (StateIsStoppedState (state)) 2478 { 2479 // We caused the process to interrupt itself, so mark this 2480 // as such in the stop event so clients can tell an interrupted 2481 // process from a natural stop 2482 ProcessEventData::SetInterruptedInEvent (event_sp.get(), true); 2483 } 2484 else 2485 { 2486 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2487 if (log) 2488 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state)); 2489 error.SetErrorString ("Did not get stopped event after halt."); 2490 } 2491 } 2492 } 2493 DidHalt(); 2494 } 2495 } 2496 } 2497 // Resume our private state thread before we post the event (if any) 2498 RestorePrivateProcessEvents(); 2499 2500 // Post any event we might have consumed. If all goes well, we will have 2501 // stopped the process, intercepted the event and set the interrupted 2502 // bool in the event. Post it to the private event queue and that will end up 2503 // correctly setting the state. 2504 if (event_sp) 2505 m_private_state_broadcaster.BroadcastEvent(event_sp); 2506 2507 return error; 2508 } 2509 2510 Error 2511 Process::Detach () 2512 { 2513 Error error (WillDetach()); 2514 2515 if (error.Success()) 2516 { 2517 DisableAllBreakpointSites(); 2518 error = DoDetach(); 2519 if (error.Success()) 2520 { 2521 DidDetach(); 2522 StopPrivateStateThread(); 2523 } 2524 } 2525 return error; 2526 } 2527 2528 Error 2529 Process::Destroy () 2530 { 2531 Error error (WillDestroy()); 2532 if (error.Success()) 2533 { 2534 DisableAllBreakpointSites(); 2535 error = DoDestroy(); 2536 if (error.Success()) 2537 { 2538 DidDestroy(); 2539 StopPrivateStateThread(); 2540 } 2541 m_stdio_communication.StopReadThread(); 2542 m_stdio_communication.Disconnect(); 2543 if (m_process_input_reader && m_process_input_reader->IsActive()) 2544 m_target.GetDebugger().PopInputReader (m_process_input_reader); 2545 if (m_process_input_reader) 2546 m_process_input_reader.reset(); 2547 } 2548 return error; 2549 } 2550 2551 Error 2552 Process::Signal (int signal) 2553 { 2554 Error error (WillSignal()); 2555 if (error.Success()) 2556 { 2557 error = DoSignal(signal); 2558 if (error.Success()) 2559 DidSignal(); 2560 } 2561 return error; 2562 } 2563 2564 lldb::ByteOrder 2565 Process::GetByteOrder () const 2566 { 2567 return m_target.GetArchitecture().GetByteOrder(); 2568 } 2569 2570 uint32_t 2571 Process::GetAddressByteSize () const 2572 { 2573 return m_target.GetArchitecture().GetAddressByteSize(); 2574 } 2575 2576 2577 bool 2578 Process::ShouldBroadcastEvent (Event *event_ptr) 2579 { 2580 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr); 2581 bool return_value = true; 2582 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS)); 2583 2584 switch (state) 2585 { 2586 case eStateConnected: 2587 case eStateAttaching: 2588 case eStateLaunching: 2589 case eStateDetached: 2590 case eStateExited: 2591 case eStateUnloaded: 2592 // These events indicate changes in the state of the debugging session, always report them. 2593 return_value = true; 2594 break; 2595 case eStateInvalid: 2596 // We stopped for no apparent reason, don't report it. 2597 return_value = false; 2598 break; 2599 case eStateRunning: 2600 case eStateStepping: 2601 // If we've started the target running, we handle the cases where we 2602 // are already running and where there is a transition from stopped to 2603 // running differently. 2604 // running -> running: Automatically suppress extra running events 2605 // stopped -> running: Report except when there is one or more no votes 2606 // and no yes votes. 2607 SynchronouslyNotifyStateChanged (state); 2608 switch (m_public_state.GetValue()) 2609 { 2610 case eStateRunning: 2611 case eStateStepping: 2612 // We always suppress multiple runnings with no PUBLIC stop in between. 2613 return_value = false; 2614 break; 2615 default: 2616 // TODO: make this work correctly. For now always report 2617 // run if we aren't running so we don't miss any runnning 2618 // events. If I run the lldb/test/thread/a.out file and 2619 // break at main.cpp:58, run and hit the breakpoints on 2620 // multiple threads, then somehow during the stepping over 2621 // of all breakpoints no run gets reported. 2622 return_value = true; 2623 2624 // This is a transition from stop to run. 2625 switch (m_thread_list.ShouldReportRun (event_ptr)) 2626 { 2627 case eVoteYes: 2628 case eVoteNoOpinion: 2629 return_value = true; 2630 break; 2631 case eVoteNo: 2632 return_value = false; 2633 break; 2634 } 2635 break; 2636 } 2637 break; 2638 case eStateStopped: 2639 case eStateCrashed: 2640 case eStateSuspended: 2641 { 2642 // We've stopped. First see if we're going to restart the target. 2643 // If we are going to stop, then we always broadcast the event. 2644 // If we aren't going to stop, let the thread plans decide if we're going to report this event. 2645 // If no thread has an opinion, we don't report it. 2646 if (ProcessEventData::GetInterruptedFromEvent (event_ptr)) 2647 { 2648 if (log) 2649 log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s", event_ptr, StateAsCString(state)); 2650 return true; 2651 } 2652 else 2653 { 2654 RefreshStateAfterStop (); 2655 2656 if (m_thread_list.ShouldStop (event_ptr) == false) 2657 { 2658 switch (m_thread_list.ShouldReportStop (event_ptr)) 2659 { 2660 case eVoteYes: 2661 Process::ProcessEventData::SetRestartedInEvent (event_ptr, true); 2662 // Intentional fall-through here. 2663 case eVoteNoOpinion: 2664 case eVoteNo: 2665 return_value = false; 2666 break; 2667 } 2668 2669 if (log) 2670 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s", event_ptr, StateAsCString(state)); 2671 Resume (); 2672 } 2673 else 2674 { 2675 return_value = true; 2676 SynchronouslyNotifyStateChanged (state); 2677 } 2678 } 2679 } 2680 } 2681 2682 if (log) 2683 log->Printf ("Process::ShouldBroadcastEvent (%p) => %s", event_ptr, StateAsCString(state), return_value ? "YES" : "NO"); 2684 return return_value; 2685 } 2686 2687 2688 bool 2689 Process::StartPrivateStateThread () 2690 { 2691 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS)); 2692 2693 bool already_running = PrivateStateThreadIsValid (); 2694 if (log) 2695 log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread"); 2696 2697 if (already_running) 2698 return true; 2699 2700 // Create a thread that watches our internal state and controls which 2701 // events make it to clients (into the DCProcess event queue). 2702 char thread_name[1024]; 2703 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%i)>", GetID()); 2704 m_private_state_thread = Host::ThreadCreate (thread_name, Process::PrivateStateThread, this, NULL); 2705 return IS_VALID_LLDB_HOST_THREAD(m_private_state_thread); 2706 } 2707 2708 void 2709 Process::PausePrivateStateThread () 2710 { 2711 ControlPrivateStateThread (eBroadcastInternalStateControlPause); 2712 } 2713 2714 void 2715 Process::ResumePrivateStateThread () 2716 { 2717 ControlPrivateStateThread (eBroadcastInternalStateControlResume); 2718 } 2719 2720 void 2721 Process::StopPrivateStateThread () 2722 { 2723 if (PrivateStateThreadIsValid ()) 2724 ControlPrivateStateThread (eBroadcastInternalStateControlStop); 2725 } 2726 2727 void 2728 Process::ControlPrivateStateThread (uint32_t signal) 2729 { 2730 LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS)); 2731 2732 assert (signal == eBroadcastInternalStateControlStop || 2733 signal == eBroadcastInternalStateControlPause || 2734 signal == eBroadcastInternalStateControlResume); 2735 2736 if (log) 2737 log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal); 2738 2739 // Signal the private state thread. First we should copy this is case the 2740 // thread starts exiting since the private state thread will NULL this out 2741 // when it exits 2742 const lldb::thread_t private_state_thread = m_private_state_thread; 2743 if (IS_VALID_LLDB_HOST_THREAD(private_state_thread)) 2744 { 2745 TimeValue timeout_time; 2746 bool timed_out; 2747 2748 m_private_state_control_broadcaster.BroadcastEvent (signal, NULL); 2749 2750 timeout_time = TimeValue::Now(); 2751 timeout_time.OffsetWithSeconds(2); 2752 m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out); 2753 m_private_state_control_wait.SetValue (false, eBroadcastNever); 2754 2755 if (signal == eBroadcastInternalStateControlStop) 2756 { 2757 if (timed_out) 2758 Host::ThreadCancel (private_state_thread, NULL); 2759 2760 thread_result_t result = NULL; 2761 Host::ThreadJoin (private_state_thread, &result, NULL); 2762 m_private_state_thread = LLDB_INVALID_HOST_THREAD; 2763 } 2764 } 2765 } 2766 2767 void 2768 Process::HandlePrivateEvent (EventSP &event_sp) 2769 { 2770 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2771 2772 const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 2773 2774 // First check to see if anybody wants a shot at this event: 2775 if (m_next_event_action_ap.get() != NULL) 2776 { 2777 NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp); 2778 switch (action_result) 2779 { 2780 case NextEventAction::eEventActionSuccess: 2781 SetNextEventAction(NULL); 2782 break; 2783 case NextEventAction::eEventActionRetry: 2784 break; 2785 case NextEventAction::eEventActionExit: 2786 // Handle Exiting Here. If we already got an exited event, 2787 // we should just propagate it. Otherwise, swallow this event, 2788 // and set our state to exit so the next event will kill us. 2789 if (new_state != eStateExited) 2790 { 2791 // FIXME: should cons up an exited event, and discard this one. 2792 SetExitStatus(0, m_next_event_action_ap->GetExitString()); 2793 SetNextEventAction(NULL); 2794 return; 2795 } 2796 SetNextEventAction(NULL); 2797 break; 2798 } 2799 } 2800 2801 // See if we should broadcast this state to external clients? 2802 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get()); 2803 2804 if (should_broadcast) 2805 { 2806 if (log) 2807 { 2808 log->Printf ("Process::%s (pid = %i) broadcasting new state %s (old state %s) to %s", 2809 __FUNCTION__, 2810 GetID(), 2811 StateAsCString(new_state), 2812 StateAsCString (GetState ()), 2813 IsHijackedForEvent(eBroadcastBitStateChanged) ? "hijacked" : "public"); 2814 } 2815 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get()); 2816 if (StateIsRunningState (new_state)) 2817 PushProcessInputReader (); 2818 else 2819 PopProcessInputReader (); 2820 2821 BroadcastEvent (event_sp); 2822 } 2823 else 2824 { 2825 if (log) 2826 { 2827 log->Printf ("Process::%s (pid = %i) suppressing state %s (old state %s): should_broadcast == false", 2828 __FUNCTION__, 2829 GetID(), 2830 StateAsCString(new_state), 2831 StateAsCString (GetState ()), 2832 IsHijackedForEvent(eBroadcastBitStateChanged) ? "hijacked" : "public"); 2833 } 2834 } 2835 } 2836 2837 void * 2838 Process::PrivateStateThread (void *arg) 2839 { 2840 Process *proc = static_cast<Process*> (arg); 2841 void *result = proc->RunPrivateStateThread (); 2842 return result; 2843 } 2844 2845 void * 2846 Process::RunPrivateStateThread () 2847 { 2848 bool control_only = false; 2849 m_private_state_control_wait.SetValue (false, eBroadcastNever); 2850 2851 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2852 if (log) 2853 log->Printf ("Process::%s (arg = %p, pid = %i) thread starting...", __FUNCTION__, this, GetID()); 2854 2855 bool exit_now = false; 2856 while (!exit_now) 2857 { 2858 EventSP event_sp; 2859 WaitForEventsPrivate (NULL, event_sp, control_only); 2860 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) 2861 { 2862 switch (event_sp->GetType()) 2863 { 2864 case eBroadcastInternalStateControlStop: 2865 exit_now = true; 2866 continue; // Go to next loop iteration so we exit without 2867 break; // doing any internal state managment below 2868 2869 case eBroadcastInternalStateControlPause: 2870 control_only = true; 2871 break; 2872 2873 case eBroadcastInternalStateControlResume: 2874 control_only = false; 2875 break; 2876 } 2877 2878 if (log) 2879 log->Printf ("Process::%s (arg = %p, pid = %i) got a control event: %d", __FUNCTION__, this, GetID(), event_sp->GetType()); 2880 2881 m_private_state_control_wait.SetValue (true, eBroadcastAlways); 2882 continue; 2883 } 2884 2885 2886 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 2887 2888 if (internal_state != eStateInvalid) 2889 { 2890 HandlePrivateEvent (event_sp); 2891 } 2892 2893 if (internal_state == eStateInvalid || 2894 internal_state == eStateExited || 2895 internal_state == eStateDetached ) 2896 { 2897 if (log) 2898 log->Printf ("Process::%s (arg = %p, pid = %i) about to exit with internal state %s...", __FUNCTION__, this, GetID(), StateAsCString(internal_state)); 2899 2900 break; 2901 } 2902 } 2903 2904 // Verify log is still enabled before attempting to write to it... 2905 if (log) 2906 log->Printf ("Process::%s (arg = %p, pid = %i) thread exiting...", __FUNCTION__, this, GetID()); 2907 2908 m_private_state_control_wait.SetValue (true, eBroadcastAlways); 2909 m_private_state_thread = LLDB_INVALID_HOST_THREAD; 2910 return NULL; 2911 } 2912 2913 //------------------------------------------------------------------ 2914 // Process Event Data 2915 //------------------------------------------------------------------ 2916 2917 Process::ProcessEventData::ProcessEventData () : 2918 EventData (), 2919 m_process_sp (), 2920 m_state (eStateInvalid), 2921 m_restarted (false), 2922 m_update_state (0), 2923 m_interrupted (false) 2924 { 2925 } 2926 2927 Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) : 2928 EventData (), 2929 m_process_sp (process_sp), 2930 m_state (state), 2931 m_restarted (false), 2932 m_update_state (0), 2933 m_interrupted (false) 2934 { 2935 } 2936 2937 Process::ProcessEventData::~ProcessEventData() 2938 { 2939 } 2940 2941 const ConstString & 2942 Process::ProcessEventData::GetFlavorString () 2943 { 2944 static ConstString g_flavor ("Process::ProcessEventData"); 2945 return g_flavor; 2946 } 2947 2948 const ConstString & 2949 Process::ProcessEventData::GetFlavor () const 2950 { 2951 return ProcessEventData::GetFlavorString (); 2952 } 2953 2954 void 2955 Process::ProcessEventData::DoOnRemoval (Event *event_ptr) 2956 { 2957 // This function gets called twice for each event, once when the event gets pulled 2958 // off of the private process event queue, and then any number of times, first when it gets pulled off of 2959 // the public event queue, then other times when we're pretending that this is where we stopped at the 2960 // end of expression evaluation. m_update_state is used to distinguish these 2961 // three cases; it is 0 when we're just pulling it off for private handling, 2962 // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then. 2963 2964 if (m_update_state != 1) 2965 return; 2966 2967 m_process_sp->SetPublicState (m_state); 2968 2969 // If we're stopped and haven't restarted, then do the breakpoint commands here: 2970 if (m_state == eStateStopped && ! m_restarted) 2971 { 2972 int num_threads = m_process_sp->GetThreadList().GetSize(); 2973 int idx; 2974 2975 // The actions might change one of the thread's stop_info's opinions about whether we should 2976 // stop the process, so we need to query that as we go. 2977 bool still_should_stop = true; 2978 2979 for (idx = 0; idx < num_threads; ++idx) 2980 { 2981 lldb::ThreadSP thread_sp = m_process_sp->GetThreadList().GetThreadAtIndex(idx); 2982 2983 StopInfoSP stop_info_sp = thread_sp->GetStopInfo (); 2984 if (stop_info_sp) 2985 { 2986 stop_info_sp->PerformAction(event_ptr); 2987 // The stop action might restart the target. If it does, then we want to mark that in the 2988 // event so that whoever is receiving it will know to wait for the running event and reflect 2989 // that state appropriately. 2990 // We also need to stop processing actions, since they aren't expecting the target to be running. 2991 if (m_process_sp->GetPrivateState() == eStateRunning) 2992 { 2993 SetRestarted (true); 2994 break; 2995 } 2996 else if (!stop_info_sp->ShouldStop(event_ptr)) 2997 { 2998 still_should_stop = false; 2999 } 3000 } 3001 } 3002 3003 3004 if (m_process_sp->GetPrivateState() != eStateRunning) 3005 { 3006 if (!still_should_stop) 3007 { 3008 // We've been asked to continue, so do that here. 3009 SetRestarted(true); 3010 m_process_sp->Resume(); 3011 } 3012 else 3013 { 3014 // If we didn't restart, run the Stop Hooks here: 3015 // They might also restart the target, so watch for that. 3016 m_process_sp->GetTarget().RunStopHooks(); 3017 if (m_process_sp->GetPrivateState() == eStateRunning) 3018 SetRestarted(true); 3019 } 3020 } 3021 3022 } 3023 } 3024 3025 void 3026 Process::ProcessEventData::Dump (Stream *s) const 3027 { 3028 if (m_process_sp) 3029 s->Printf(" process = %p (pid = %u), ", m_process_sp.get(), m_process_sp->GetID()); 3030 3031 s->Printf("state = %s", StateAsCString(GetState())); 3032 } 3033 3034 const Process::ProcessEventData * 3035 Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr) 3036 { 3037 if (event_ptr) 3038 { 3039 const EventData *event_data = event_ptr->GetData(); 3040 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString()) 3041 return static_cast <const ProcessEventData *> (event_ptr->GetData()); 3042 } 3043 return NULL; 3044 } 3045 3046 ProcessSP 3047 Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr) 3048 { 3049 ProcessSP process_sp; 3050 const ProcessEventData *data = GetEventDataFromEvent (event_ptr); 3051 if (data) 3052 process_sp = data->GetProcessSP(); 3053 return process_sp; 3054 } 3055 3056 StateType 3057 Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr) 3058 { 3059 const ProcessEventData *data = GetEventDataFromEvent (event_ptr); 3060 if (data == NULL) 3061 return eStateInvalid; 3062 else 3063 return data->GetState(); 3064 } 3065 3066 bool 3067 Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr) 3068 { 3069 const ProcessEventData *data = GetEventDataFromEvent (event_ptr); 3070 if (data == NULL) 3071 return false; 3072 else 3073 return data->GetRestarted(); 3074 } 3075 3076 void 3077 Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value) 3078 { 3079 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); 3080 if (data != NULL) 3081 data->SetRestarted(new_value); 3082 } 3083 3084 bool 3085 Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr) 3086 { 3087 const ProcessEventData *data = GetEventDataFromEvent (event_ptr); 3088 if (data == NULL) 3089 return false; 3090 else 3091 return data->GetInterrupted (); 3092 } 3093 3094 void 3095 Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value) 3096 { 3097 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); 3098 if (data != NULL) 3099 data->SetInterrupted(new_value); 3100 } 3101 3102 bool 3103 Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr) 3104 { 3105 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); 3106 if (data) 3107 { 3108 data->SetUpdateStateOnRemoval(); 3109 return true; 3110 } 3111 return false; 3112 } 3113 3114 void 3115 Process::CalculateExecutionContext (ExecutionContext &exe_ctx) 3116 { 3117 exe_ctx.target = &m_target; 3118 exe_ctx.process = this; 3119 exe_ctx.thread = NULL; 3120 exe_ctx.frame = NULL; 3121 } 3122 3123 lldb::ProcessSP 3124 Process::GetSP () 3125 { 3126 return GetTarget().GetProcessSP(); 3127 } 3128 3129 //uint32_t 3130 //Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids) 3131 //{ 3132 // return 0; 3133 //} 3134 // 3135 //ArchSpec 3136 //Process::GetArchSpecForExistingProcess (lldb::pid_t pid) 3137 //{ 3138 // return Host::GetArchSpecForExistingProcess (pid); 3139 //} 3140 // 3141 //ArchSpec 3142 //Process::GetArchSpecForExistingProcess (const char *process_name) 3143 //{ 3144 // return Host::GetArchSpecForExistingProcess (process_name); 3145 //} 3146 // 3147 void 3148 Process::AppendSTDOUT (const char * s, size_t len) 3149 { 3150 Mutex::Locker locker (m_stdio_communication_mutex); 3151 m_stdout_data.append (s, len); 3152 3153 BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (GetTarget().GetProcessSP(), GetState())); 3154 } 3155 3156 void 3157 Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len) 3158 { 3159 Process *process = (Process *) baton; 3160 process->AppendSTDOUT (static_cast<const char *>(src), src_len); 3161 } 3162 3163 size_t 3164 Process::ProcessInputReaderCallback (void *baton, 3165 InputReader &reader, 3166 lldb::InputReaderAction notification, 3167 const char *bytes, 3168 size_t bytes_len) 3169 { 3170 Process *process = (Process *) baton; 3171 3172 switch (notification) 3173 { 3174 case eInputReaderActivate: 3175 break; 3176 3177 case eInputReaderDeactivate: 3178 break; 3179 3180 case eInputReaderReactivate: 3181 break; 3182 3183 case eInputReaderAsynchronousOutputWritten: 3184 break; 3185 3186 case eInputReaderGotToken: 3187 { 3188 Error error; 3189 process->PutSTDIN (bytes, bytes_len, error); 3190 } 3191 break; 3192 3193 case eInputReaderInterrupt: 3194 process->Halt (); 3195 break; 3196 3197 case eInputReaderEndOfFile: 3198 process->AppendSTDOUT ("^D", 2); 3199 break; 3200 3201 case eInputReaderDone: 3202 break; 3203 3204 } 3205 3206 return bytes_len; 3207 } 3208 3209 void 3210 Process::ResetProcessInputReader () 3211 { 3212 m_process_input_reader.reset(); 3213 } 3214 3215 void 3216 Process::SetUpProcessInputReader (int file_descriptor) 3217 { 3218 // First set up the Read Thread for reading/handling process I/O 3219 3220 std::auto_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (file_descriptor, true)); 3221 3222 if (conn_ap.get()) 3223 { 3224 m_stdio_communication.SetConnection (conn_ap.release()); 3225 if (m_stdio_communication.IsConnected()) 3226 { 3227 m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this); 3228 m_stdio_communication.StartReadThread(); 3229 3230 // Now read thread is set up, set up input reader. 3231 3232 if (!m_process_input_reader.get()) 3233 { 3234 m_process_input_reader.reset (new InputReader(m_target.GetDebugger())); 3235 Error err (m_process_input_reader->Initialize (Process::ProcessInputReaderCallback, 3236 this, 3237 eInputReaderGranularityByte, 3238 NULL, 3239 NULL, 3240 false)); 3241 3242 if (err.Fail()) 3243 m_process_input_reader.reset(); 3244 } 3245 } 3246 } 3247 } 3248 3249 void 3250 Process::PushProcessInputReader () 3251 { 3252 if (m_process_input_reader && !m_process_input_reader->IsActive()) 3253 m_target.GetDebugger().PushInputReader (m_process_input_reader); 3254 } 3255 3256 void 3257 Process::PopProcessInputReader () 3258 { 3259 if (m_process_input_reader && m_process_input_reader->IsActive()) 3260 m_target.GetDebugger().PopInputReader (m_process_input_reader); 3261 } 3262 3263 // The process needs to know about installed plug-ins 3264 void 3265 Process::SettingsInitialize () 3266 { 3267 static std::vector<OptionEnumValueElement> g_plugins; 3268 3269 int i=0; 3270 const char *name; 3271 OptionEnumValueElement option_enum; 3272 while ((name = PluginManager::GetProcessPluginNameAtIndex (i)) != NULL) 3273 { 3274 if (name) 3275 { 3276 option_enum.value = i; 3277 option_enum.string_value = name; 3278 option_enum.usage = PluginManager::GetProcessPluginDescriptionAtIndex (i); 3279 g_plugins.push_back (option_enum); 3280 } 3281 ++i; 3282 } 3283 option_enum.value = 0; 3284 option_enum.string_value = NULL; 3285 option_enum.usage = NULL; 3286 g_plugins.push_back (option_enum); 3287 3288 for (i=0; (name = SettingsController::instance_settings_table[i].var_name); ++i) 3289 { 3290 if (::strcmp (name, "plugin") == 0) 3291 { 3292 SettingsController::instance_settings_table[i].enum_values = &g_plugins[0]; 3293 break; 3294 } 3295 } 3296 UserSettingsControllerSP &usc = GetSettingsController(); 3297 usc.reset (new SettingsController); 3298 UserSettingsController::InitializeSettingsController (usc, 3299 SettingsController::global_settings_table, 3300 SettingsController::instance_settings_table); 3301 3302 // Now call SettingsInitialize() for each 'child' of Process settings 3303 Thread::SettingsInitialize (); 3304 } 3305 3306 void 3307 Process::SettingsTerminate () 3308 { 3309 // Must call SettingsTerminate() on each 'child' of Process settings before terminating Process settings. 3310 3311 Thread::SettingsTerminate (); 3312 3313 // Now terminate Process Settings. 3314 3315 UserSettingsControllerSP &usc = GetSettingsController(); 3316 UserSettingsController::FinalizeSettingsController (usc); 3317 usc.reset(); 3318 } 3319 3320 UserSettingsControllerSP & 3321 Process::GetSettingsController () 3322 { 3323 static UserSettingsControllerSP g_settings_controller; 3324 return g_settings_controller; 3325 } 3326 3327 void 3328 Process::UpdateInstanceName () 3329 { 3330 Module *module = GetTarget().GetExecutableModulePointer(); 3331 if (module) 3332 { 3333 StreamString sstr; 3334 sstr.Printf ("%s", module->GetFileSpec().GetFilename().AsCString()); 3335 3336 GetSettingsController()->RenameInstanceSettings (GetInstanceName().AsCString(), 3337 sstr.GetData()); 3338 } 3339 } 3340 3341 ExecutionResults 3342 Process::RunThreadPlan (ExecutionContext &exe_ctx, 3343 lldb::ThreadPlanSP &thread_plan_sp, 3344 bool stop_others, 3345 bool try_all_threads, 3346 bool discard_on_error, 3347 uint32_t single_thread_timeout_usec, 3348 Stream &errors) 3349 { 3350 ExecutionResults return_value = eExecutionSetupError; 3351 3352 if (thread_plan_sp.get() == NULL) 3353 { 3354 errors.Printf("RunThreadPlan called with empty thread plan."); 3355 return eExecutionSetupError; 3356 } 3357 3358 // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes. 3359 // For that to be true the plan can't be private - since private plans suppress themselves in the 3360 // GetCompletedPlan call. 3361 3362 bool orig_plan_private = thread_plan_sp->GetPrivate(); 3363 thread_plan_sp->SetPrivate(false); 3364 3365 if (m_private_state.GetValue() != eStateStopped) 3366 { 3367 errors.Printf ("RunThreadPlan called while the private state was not stopped."); 3368 return eExecutionSetupError; 3369 } 3370 3371 // Save the thread & frame from the exe_ctx for restoration after we run 3372 const uint32_t thread_idx_id = exe_ctx.thread->GetIndexID(); 3373 StackID ctx_frame_id = exe_ctx.thread->GetSelectedFrame()->GetStackID(); 3374 3375 // N.B. Running the target may unset the currently selected thread and frame. We don't want to do that either, 3376 // so we should arrange to reset them as well. 3377 3378 lldb::ThreadSP selected_thread_sp = exe_ctx.process->GetThreadList().GetSelectedThread(); 3379 3380 uint32_t selected_tid; 3381 StackID selected_stack_id; 3382 if (selected_thread_sp != NULL) 3383 { 3384 selected_tid = selected_thread_sp->GetIndexID(); 3385 selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID(); 3386 } 3387 else 3388 { 3389 selected_tid = LLDB_INVALID_THREAD_ID; 3390 } 3391 3392 exe_ctx.thread->QueueThreadPlan(thread_plan_sp, true); 3393 3394 Listener listener("lldb.process.listener.run-thread-plan"); 3395 3396 // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get 3397 // restored on exit to the function. 3398 3399 ProcessEventHijacker run_thread_plan_hijacker (*this, &listener); 3400 3401 lldb::LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS)); 3402 if (log) 3403 { 3404 StreamString s; 3405 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 3406 log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4x to run thread plan \"%s\".", 3407 exe_ctx.thread->GetIndexID(), 3408 exe_ctx.thread->GetID(), 3409 s.GetData()); 3410 } 3411 3412 bool got_event; 3413 lldb::EventSP event_sp; 3414 lldb::StateType stop_state = lldb::eStateInvalid; 3415 3416 TimeValue* timeout_ptr = NULL; 3417 TimeValue real_timeout; 3418 3419 bool first_timeout = true; 3420 bool do_resume = true; 3421 3422 while (1) 3423 { 3424 // We usually want to resume the process if we get to the top of the loop. 3425 // The only exception is if we get two running events with no intervening 3426 // stop, which can happen, we will just wait for then next stop event. 3427 3428 if (do_resume) 3429 { 3430 // Do the initial resume and wait for the running event before going further. 3431 3432 Error resume_error = exe_ctx.process->Resume (); 3433 if (!resume_error.Success()) 3434 { 3435 errors.Printf("Error resuming inferior: \"%s\".\n", resume_error.AsCString()); 3436 return_value = eExecutionSetupError; 3437 break; 3438 } 3439 3440 real_timeout = TimeValue::Now(); 3441 real_timeout.OffsetWithMicroSeconds(500000); 3442 timeout_ptr = &real_timeout; 3443 3444 got_event = listener.WaitForEvent(NULL, event_sp); 3445 if (!got_event) 3446 { 3447 if (log) 3448 log->PutCString("Didn't get any event after initial resume, exiting."); 3449 3450 errors.Printf("Didn't get any event after initial resume, exiting."); 3451 return_value = eExecutionSetupError; 3452 break; 3453 } 3454 3455 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 3456 if (stop_state != eStateRunning) 3457 { 3458 if (log) 3459 log->Printf("Didn't get running event after initial resume, got %s instead.", StateAsCString(stop_state)); 3460 3461 errors.Printf("Didn't get running event after initial resume, got %s instead.", StateAsCString(stop_state)); 3462 return_value = eExecutionSetupError; 3463 break; 3464 } 3465 3466 if (log) 3467 log->PutCString ("Resuming succeeded."); 3468 // We need to call the function synchronously, so spin waiting for it to return. 3469 // If we get interrupted while executing, we're going to lose our context, and 3470 // won't be able to gather the result at this point. 3471 // We set the timeout AFTER the resume, since the resume takes some time and we 3472 // don't want to charge that to the timeout. 3473 3474 if (single_thread_timeout_usec != 0) 3475 { 3476 real_timeout = TimeValue::Now(); 3477 if (first_timeout) 3478 real_timeout.OffsetWithMicroSeconds(single_thread_timeout_usec); 3479 else 3480 real_timeout.OffsetWithSeconds(10); 3481 3482 timeout_ptr = &real_timeout; 3483 } 3484 } 3485 else 3486 { 3487 if (log) 3488 log->PutCString ("Handled an extra running event."); 3489 do_resume = true; 3490 } 3491 3492 // Now wait for the process to stop again: 3493 stop_state = lldb::eStateInvalid; 3494 event_sp.reset(); 3495 got_event = listener.WaitForEvent (timeout_ptr, event_sp); 3496 3497 if (got_event) 3498 { 3499 if (event_sp.get()) 3500 { 3501 bool keep_going = false; 3502 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 3503 if (log) 3504 log->Printf("In while loop, got event: %s.", StateAsCString(stop_state)); 3505 3506 switch (stop_state) 3507 { 3508 case lldb::eStateStopped: 3509 { 3510 // Yay, we're done. Now make sure that our thread plan actually completed. 3511 ThreadSP thread_sp = exe_ctx.process->GetThreadList().FindThreadByIndexID (thread_idx_id); 3512 if (!thread_sp) 3513 { 3514 // Ooh, our thread has vanished. Unlikely that this was successful execution... 3515 if (log) 3516 log->Printf ("Execution completed but our thread (index-id=%u) has vanished.", thread_idx_id); 3517 return_value = eExecutionInterrupted; 3518 } 3519 else 3520 { 3521 StopInfoSP stop_info_sp (thread_sp->GetStopInfo ()); 3522 StopReason stop_reason = eStopReasonInvalid; 3523 if (stop_info_sp) 3524 stop_reason = stop_info_sp->GetStopReason(); 3525 if (stop_reason == eStopReasonPlanComplete) 3526 { 3527 if (log) 3528 log->PutCString ("Execution completed successfully."); 3529 // Now mark this plan as private so it doesn't get reported as the stop reason 3530 // after this point. 3531 if (thread_plan_sp) 3532 thread_plan_sp->SetPrivate (orig_plan_private); 3533 return_value = eExecutionCompleted; 3534 } 3535 else 3536 { 3537 if (log) 3538 log->PutCString ("Thread plan didn't successfully complete."); 3539 3540 return_value = eExecutionInterrupted; 3541 } 3542 } 3543 } 3544 break; 3545 3546 case lldb::eStateCrashed: 3547 if (log) 3548 log->PutCString ("Execution crashed."); 3549 return_value = eExecutionInterrupted; 3550 break; 3551 3552 case lldb::eStateRunning: 3553 do_resume = false; 3554 keep_going = true; 3555 break; 3556 3557 default: 3558 if (log) 3559 log->Printf("Execution stopped with unexpected state: %s.", StateAsCString(stop_state)); 3560 3561 errors.Printf ("Execution stopped with unexpected state."); 3562 return_value = eExecutionInterrupted; 3563 break; 3564 } 3565 if (keep_going) 3566 continue; 3567 else 3568 break; 3569 } 3570 else 3571 { 3572 if (log) 3573 log->PutCString ("got_event was true, but the event pointer was null. How odd..."); 3574 return_value = eExecutionInterrupted; 3575 break; 3576 } 3577 } 3578 else 3579 { 3580 // If we didn't get an event that means we've timed out... 3581 // We will interrupt the process here. Depending on what we were asked to do we will 3582 // either exit, or try with all threads running for the same timeout. 3583 // Not really sure what to do if Halt fails here... 3584 3585 if (log) { 3586 if (try_all_threads) 3587 { 3588 if (first_timeout) 3589 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %d timed out, " 3590 "trying with all threads enabled.", 3591 single_thread_timeout_usec); 3592 else 3593 log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled " 3594 "and timeout: %d timed out.", 3595 single_thread_timeout_usec); 3596 } 3597 else 3598 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %d timed out, " 3599 "halt and abandoning execution.", 3600 single_thread_timeout_usec); 3601 } 3602 3603 Error halt_error = exe_ctx.process->Halt(); 3604 if (halt_error.Success()) 3605 { 3606 if (log) 3607 log->PutCString ("Process::RunThreadPlan(): Halt succeeded."); 3608 3609 // If halt succeeds, it always produces a stopped event. Wait for that: 3610 3611 real_timeout = TimeValue::Now(); 3612 real_timeout.OffsetWithMicroSeconds(500000); 3613 3614 got_event = listener.WaitForEvent(&real_timeout, event_sp); 3615 3616 if (got_event) 3617 { 3618 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 3619 if (log) 3620 { 3621 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state)); 3622 if (stop_state == lldb::eStateStopped 3623 && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get())) 3624 log->PutCString (" Event was the Halt interruption event."); 3625 } 3626 3627 if (stop_state == lldb::eStateStopped) 3628 { 3629 // Between the time we initiated the Halt and the time we delivered it, the process could have 3630 // already finished its job. Check that here: 3631 3632 if (exe_ctx.thread->IsThreadPlanDone (thread_plan_sp.get())) 3633 { 3634 if (log) 3635 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. " 3636 "Exiting wait loop."); 3637 return_value = eExecutionCompleted; 3638 break; 3639 } 3640 3641 if (!try_all_threads) 3642 { 3643 if (log) 3644 log->PutCString ("try_all_threads was false, we stopped so now we're quitting."); 3645 return_value = eExecutionInterrupted; 3646 break; 3647 } 3648 3649 if (first_timeout) 3650 { 3651 // Set all the other threads to run, and return to the top of the loop, which will continue; 3652 first_timeout = false; 3653 thread_plan_sp->SetStopOthers (false); 3654 if (log) 3655 log->PutCString ("Process::RunThreadPlan(): About to resume."); 3656 3657 continue; 3658 } 3659 else 3660 { 3661 // Running all threads failed, so return Interrupted. 3662 if (log) 3663 log->PutCString("Process::RunThreadPlan(): running all threads timed out."); 3664 return_value = eExecutionInterrupted; 3665 break; 3666 } 3667 } 3668 } 3669 else 3670 { if (log) 3671 log->PutCString("Process::RunThreadPlan(): halt said it succeeded, but I got no event. " 3672 "I'm getting out of here passing Interrupted."); 3673 return_value = eExecutionInterrupted; 3674 break; 3675 } 3676 } 3677 else 3678 { 3679 // This branch is to work around some problems with gdb-remote's Halt. It is a little racy, and can return 3680 // an error from halt, but if you wait a bit you'll get a stopped event anyway. 3681 if (log) 3682 log->Printf ("Process::RunThreadPlan(): halt failed: error = \"%s\", I'm just going to wait a little longer and see if I get a stopped event.", 3683 halt_error.AsCString()); 3684 real_timeout = TimeValue::Now(); 3685 real_timeout.OffsetWithMicroSeconds(500000); 3686 timeout_ptr = &real_timeout; 3687 got_event = listener.WaitForEvent(&real_timeout, event_sp); 3688 if (!got_event || event_sp.get() == NULL) 3689 { 3690 // This is not going anywhere, bag out. 3691 if (log) 3692 log->PutCString ("Process::RunThreadPlan(): halt failed: and waiting for the stopped event failed."); 3693 return_value = eExecutionInterrupted; 3694 break; 3695 } 3696 else 3697 { 3698 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 3699 if (log) 3700 log->PutCString ("Process::RunThreadPlan(): halt failed: but then I got a stopped event. Whatever..."); 3701 if (stop_state == lldb::eStateStopped) 3702 { 3703 // Between the time we initiated the Halt and the time we delivered it, the process could have 3704 // already finished its job. Check that here: 3705 3706 if (exe_ctx.thread->IsThreadPlanDone (thread_plan_sp.get())) 3707 { 3708 if (log) 3709 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. " 3710 "Exiting wait loop."); 3711 return_value = eExecutionCompleted; 3712 break; 3713 } 3714 3715 if (first_timeout) 3716 { 3717 // Set all the other threads to run, and return to the top of the loop, which will continue; 3718 first_timeout = false; 3719 thread_plan_sp->SetStopOthers (false); 3720 if (log) 3721 log->PutCString ("Process::RunThreadPlan(): About to resume."); 3722 3723 continue; 3724 } 3725 else 3726 { 3727 // Running all threads failed, so return Interrupted. 3728 if (log) 3729 log->PutCString ("Process::RunThreadPlan(): running all threads timed out."); 3730 return_value = eExecutionInterrupted; 3731 break; 3732 } 3733 } 3734 else 3735 { 3736 if (log) 3737 log->Printf ("Process::RunThreadPlan(): halt failed, I waited and didn't get" 3738 " a stopped event, instead got %s.", StateAsCString(stop_state)); 3739 return_value = eExecutionInterrupted; 3740 break; 3741 } 3742 } 3743 } 3744 3745 } 3746 3747 } // END WAIT LOOP 3748 3749 // Now do some processing on the results of the run: 3750 if (return_value == eExecutionInterrupted) 3751 { 3752 if (log) 3753 { 3754 StreamString s; 3755 if (event_sp) 3756 event_sp->Dump (&s); 3757 else 3758 { 3759 log->PutCString ("Process::RunThreadPlan(): Stop event that interrupted us is NULL."); 3760 } 3761 3762 StreamString ts; 3763 3764 const char *event_explanation = NULL; 3765 3766 do 3767 { 3768 const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get()); 3769 3770 if (!event_data) 3771 { 3772 event_explanation = "<no event data>"; 3773 break; 3774 } 3775 3776 Process *process = event_data->GetProcessSP().get(); 3777 3778 if (!process) 3779 { 3780 event_explanation = "<no process>"; 3781 break; 3782 } 3783 3784 ThreadList &thread_list = process->GetThreadList(); 3785 3786 uint32_t num_threads = thread_list.GetSize(); 3787 uint32_t thread_index; 3788 3789 ts.Printf("<%u threads> ", num_threads); 3790 3791 for (thread_index = 0; 3792 thread_index < num_threads; 3793 ++thread_index) 3794 { 3795 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get(); 3796 3797 if (!thread) 3798 { 3799 ts.Printf("<?> "); 3800 continue; 3801 } 3802 3803 ts.Printf("<0x%4.4x ", thread->GetID()); 3804 RegisterContext *register_context = thread->GetRegisterContext().get(); 3805 3806 if (register_context) 3807 ts.Printf("[ip 0x%llx] ", register_context->GetPC()); 3808 else 3809 ts.Printf("[ip unknown] "); 3810 3811 lldb::StopInfoSP stop_info_sp = thread->GetStopInfo(); 3812 if (stop_info_sp) 3813 { 3814 const char *stop_desc = stop_info_sp->GetDescription(); 3815 if (stop_desc) 3816 ts.PutCString (stop_desc); 3817 } 3818 ts.Printf(">"); 3819 } 3820 3821 event_explanation = ts.GetData(); 3822 } while (0); 3823 3824 if (log) 3825 { 3826 if (event_explanation) 3827 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation); 3828 else 3829 log->Printf("Process::RunThreadPlan(): execution interrupted: %s", s.GetData()); 3830 } 3831 3832 if (discard_on_error && thread_plan_sp) 3833 { 3834 exe_ctx.thread->DiscardThreadPlansUpToPlan (thread_plan_sp); 3835 thread_plan_sp->SetPrivate (orig_plan_private); 3836 } 3837 } 3838 } 3839 else if (return_value == eExecutionSetupError) 3840 { 3841 if (log) 3842 log->PutCString("Process::RunThreadPlan(): execution set up error."); 3843 3844 if (discard_on_error && thread_plan_sp) 3845 { 3846 exe_ctx.thread->DiscardThreadPlansUpToPlan (thread_plan_sp); 3847 thread_plan_sp->SetPrivate (orig_plan_private); 3848 } 3849 } 3850 else 3851 { 3852 if (exe_ctx.thread->IsThreadPlanDone (thread_plan_sp.get())) 3853 { 3854 if (log) 3855 log->PutCString("Process::RunThreadPlan(): thread plan is done"); 3856 return_value = eExecutionCompleted; 3857 } 3858 else if (exe_ctx.thread->WasThreadPlanDiscarded (thread_plan_sp.get())) 3859 { 3860 if (log) 3861 log->PutCString("Process::RunThreadPlan(): thread plan was discarded"); 3862 return_value = eExecutionDiscarded; 3863 } 3864 else 3865 { 3866 if (log) 3867 log->PutCString("Process::RunThreadPlan(): thread plan stopped in mid course"); 3868 if (discard_on_error && thread_plan_sp) 3869 { 3870 if (log) 3871 log->PutCString("Process::RunThreadPlan(): discarding thread plan 'cause discard_on_error is set."); 3872 exe_ctx.thread->DiscardThreadPlansUpToPlan (thread_plan_sp); 3873 thread_plan_sp->SetPrivate (orig_plan_private); 3874 } 3875 } 3876 } 3877 3878 // Thread we ran the function in may have gone away because we ran the target 3879 // Check that it's still there, and if it is put it back in the context. Also restore the 3880 // frame in the context if it is still present. 3881 exe_ctx.thread = exe_ctx.process->GetThreadList().FindThreadByIndexID(thread_idx_id, true).get(); 3882 if (exe_ctx.thread) 3883 { 3884 exe_ctx.frame = exe_ctx.thread->GetFrameWithStackID (ctx_frame_id).get(); 3885 } 3886 3887 // Also restore the current process'es selected frame & thread, since this function calling may 3888 // be done behind the user's back. 3889 3890 if (selected_tid != LLDB_INVALID_THREAD_ID) 3891 { 3892 if (exe_ctx.process->GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid()) 3893 { 3894 // We were able to restore the selected thread, now restore the frame: 3895 StackFrameSP old_frame_sp = exe_ctx.process->GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id); 3896 if (old_frame_sp) 3897 exe_ctx.process->GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get()); 3898 } 3899 } 3900 3901 return return_value; 3902 } 3903 3904 const char * 3905 Process::ExecutionResultAsCString (ExecutionResults result) 3906 { 3907 const char *result_name; 3908 3909 switch (result) 3910 { 3911 case eExecutionCompleted: 3912 result_name = "eExecutionCompleted"; 3913 break; 3914 case eExecutionDiscarded: 3915 result_name = "eExecutionDiscarded"; 3916 break; 3917 case eExecutionInterrupted: 3918 result_name = "eExecutionInterrupted"; 3919 break; 3920 case eExecutionSetupError: 3921 result_name = "eExecutionSetupError"; 3922 break; 3923 case eExecutionTimedOut: 3924 result_name = "eExecutionTimedOut"; 3925 break; 3926 } 3927 return result_name; 3928 } 3929 3930 void 3931 Process::GetStatus (Stream &strm) 3932 { 3933 const StateType state = GetState(); 3934 if (StateIsStoppedState(state)) 3935 { 3936 if (state == eStateExited) 3937 { 3938 int exit_status = GetExitStatus(); 3939 const char *exit_description = GetExitDescription(); 3940 strm.Printf ("Process %d exited with status = %i (0x%8.8x) %s\n", 3941 GetID(), 3942 exit_status, 3943 exit_status, 3944 exit_description ? exit_description : ""); 3945 } 3946 else 3947 { 3948 if (state == eStateConnected) 3949 strm.Printf ("Connected to remote target.\n"); 3950 else 3951 strm.Printf ("Process %d %s\n", GetID(), StateAsCString (state)); 3952 } 3953 } 3954 else 3955 { 3956 strm.Printf ("Process %d is running.\n", GetID()); 3957 } 3958 } 3959 3960 size_t 3961 Process::GetThreadStatus (Stream &strm, 3962 bool only_threads_with_stop_reason, 3963 uint32_t start_frame, 3964 uint32_t num_frames, 3965 uint32_t num_frames_with_source) 3966 { 3967 size_t num_thread_infos_dumped = 0; 3968 3969 const size_t num_threads = GetThreadList().GetSize(); 3970 for (uint32_t i = 0; i < num_threads; i++) 3971 { 3972 Thread *thread = GetThreadList().GetThreadAtIndex(i).get(); 3973 if (thread) 3974 { 3975 if (only_threads_with_stop_reason) 3976 { 3977 if (thread->GetStopInfo().get() == NULL) 3978 continue; 3979 } 3980 thread->GetStatus (strm, 3981 start_frame, 3982 num_frames, 3983 num_frames_with_source); 3984 ++num_thread_infos_dumped; 3985 } 3986 } 3987 return num_thread_infos_dumped; 3988 } 3989 3990 //-------------------------------------------------------------- 3991 // class Process::SettingsController 3992 //-------------------------------------------------------------- 3993 3994 Process::SettingsController::SettingsController () : 3995 UserSettingsController ("process", Target::GetSettingsController()) 3996 { 3997 m_default_settings.reset (new ProcessInstanceSettings (*this, 3998 false, 3999 InstanceSettings::GetDefaultName().AsCString())); 4000 } 4001 4002 Process::SettingsController::~SettingsController () 4003 { 4004 } 4005 4006 lldb::InstanceSettingsSP 4007 Process::SettingsController::CreateInstanceSettings (const char *instance_name) 4008 { 4009 ProcessInstanceSettings *new_settings = new ProcessInstanceSettings (*GetSettingsController(), 4010 false, 4011 instance_name); 4012 lldb::InstanceSettingsSP new_settings_sp (new_settings); 4013 return new_settings_sp; 4014 } 4015 4016 //-------------------------------------------------------------- 4017 // class ProcessInstanceSettings 4018 //-------------------------------------------------------------- 4019 4020 ProcessInstanceSettings::ProcessInstanceSettings 4021 ( 4022 UserSettingsController &owner, 4023 bool live_instance, 4024 const char *name 4025 ) : 4026 InstanceSettings (owner, name ? name : InstanceSettings::InvalidName().AsCString(), live_instance), 4027 m_run_args (), 4028 m_env_vars (), 4029 m_input_path (), 4030 m_output_path (), 4031 m_error_path (), 4032 m_disable_aslr (true), 4033 m_disable_stdio (false), 4034 m_inherit_host_env (true), 4035 m_got_host_env (false) 4036 { 4037 // CopyInstanceSettings is a pure virtual function in InstanceSettings; it therefore cannot be called 4038 // until the vtables for ProcessInstanceSettings are properly set up, i.e. AFTER all the initializers. 4039 // For this reason it has to be called here, rather than in the initializer or in the parent constructor. 4040 // This is true for CreateInstanceName() too. 4041 4042 if (GetInstanceName () == InstanceSettings::InvalidName()) 4043 { 4044 ChangeInstanceName (std::string (CreateInstanceName().AsCString())); 4045 m_owner.RegisterInstanceSettings (this); 4046 } 4047 4048 if (live_instance) 4049 { 4050 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); 4051 CopyInstanceSettings (pending_settings,false); 4052 //m_owner.RemovePendingSettings (m_instance_name); 4053 } 4054 } 4055 4056 ProcessInstanceSettings::ProcessInstanceSettings (const ProcessInstanceSettings &rhs) : 4057 InstanceSettings (*Process::GetSettingsController(), CreateInstanceName().AsCString()), 4058 m_run_args (rhs.m_run_args), 4059 m_env_vars (rhs.m_env_vars), 4060 m_input_path (rhs.m_input_path), 4061 m_output_path (rhs.m_output_path), 4062 m_error_path (rhs.m_error_path), 4063 m_disable_aslr (rhs.m_disable_aslr), 4064 m_disable_stdio (rhs.m_disable_stdio) 4065 { 4066 if (m_instance_name != InstanceSettings::GetDefaultName()) 4067 { 4068 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); 4069 CopyInstanceSettings (pending_settings,false); 4070 m_owner.RemovePendingSettings (m_instance_name); 4071 } 4072 } 4073 4074 ProcessInstanceSettings::~ProcessInstanceSettings () 4075 { 4076 } 4077 4078 ProcessInstanceSettings& 4079 ProcessInstanceSettings::operator= (const ProcessInstanceSettings &rhs) 4080 { 4081 if (this != &rhs) 4082 { 4083 m_run_args = rhs.m_run_args; 4084 m_env_vars = rhs.m_env_vars; 4085 m_input_path = rhs.m_input_path; 4086 m_output_path = rhs.m_output_path; 4087 m_error_path = rhs.m_error_path; 4088 m_disable_aslr = rhs.m_disable_aslr; 4089 m_disable_stdio = rhs.m_disable_stdio; 4090 m_inherit_host_env = rhs.m_inherit_host_env; 4091 } 4092 4093 return *this; 4094 } 4095 4096 4097 void 4098 ProcessInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var_name, 4099 const char *index_value, 4100 const char *value, 4101 const ConstString &instance_name, 4102 const SettingEntry &entry, 4103 VarSetOperationType op, 4104 Error &err, 4105 bool pending) 4106 { 4107 if (var_name == RunArgsVarName()) 4108 UserSettingsController::UpdateStringArrayVariable (op, index_value, m_run_args, value, err); 4109 else if (var_name == EnvVarsVarName()) 4110 { 4111 // This is nice for local debugging, but it is isn't correct for 4112 // remote debugging. We need to stop process.env-vars from being 4113 // populated with the host environment and add this as a launch option 4114 // and get the correct environment from the Target's platform. 4115 // GetHostEnvironmentIfNeeded (); 4116 UserSettingsController::UpdateDictionaryVariable (op, index_value, m_env_vars, value, err); 4117 } 4118 else if (var_name == InputPathVarName()) 4119 UserSettingsController::UpdateStringVariable (op, m_input_path, value, err); 4120 else if (var_name == OutputPathVarName()) 4121 UserSettingsController::UpdateStringVariable (op, m_output_path, value, err); 4122 else if (var_name == ErrorPathVarName()) 4123 UserSettingsController::UpdateStringVariable (op, m_error_path, value, err); 4124 else if (var_name == DisableASLRVarName()) 4125 UserSettingsController::UpdateBooleanVariable (op, m_disable_aslr, value, true, err); 4126 else if (var_name == DisableSTDIOVarName ()) 4127 UserSettingsController::UpdateBooleanVariable (op, m_disable_stdio, value, false, err); 4128 } 4129 4130 void 4131 ProcessInstanceSettings::CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings, 4132 bool pending) 4133 { 4134 if (new_settings.get() == NULL) 4135 return; 4136 4137 ProcessInstanceSettings *new_process_settings = (ProcessInstanceSettings *) new_settings.get(); 4138 4139 m_run_args = new_process_settings->m_run_args; 4140 m_env_vars = new_process_settings->m_env_vars; 4141 m_input_path = new_process_settings->m_input_path; 4142 m_output_path = new_process_settings->m_output_path; 4143 m_error_path = new_process_settings->m_error_path; 4144 m_disable_aslr = new_process_settings->m_disable_aslr; 4145 m_disable_stdio = new_process_settings->m_disable_stdio; 4146 } 4147 4148 bool 4149 ProcessInstanceSettings::GetInstanceSettingsValue (const SettingEntry &entry, 4150 const ConstString &var_name, 4151 StringList &value, 4152 Error *err) 4153 { 4154 if (var_name == RunArgsVarName()) 4155 { 4156 if (m_run_args.GetArgumentCount() > 0) 4157 { 4158 for (int i = 0; i < m_run_args.GetArgumentCount(); ++i) 4159 value.AppendString (m_run_args.GetArgumentAtIndex (i)); 4160 } 4161 } 4162 else if (var_name == EnvVarsVarName()) 4163 { 4164 GetHostEnvironmentIfNeeded (); 4165 4166 if (m_env_vars.size() > 0) 4167 { 4168 std::map<std::string, std::string>::iterator pos; 4169 for (pos = m_env_vars.begin(); pos != m_env_vars.end(); ++pos) 4170 { 4171 StreamString value_str; 4172 value_str.Printf ("%s=%s", pos->first.c_str(), pos->second.c_str()); 4173 value.AppendString (value_str.GetData()); 4174 } 4175 } 4176 } 4177 else if (var_name == InputPathVarName()) 4178 { 4179 value.AppendString (m_input_path.c_str()); 4180 } 4181 else if (var_name == OutputPathVarName()) 4182 { 4183 value.AppendString (m_output_path.c_str()); 4184 } 4185 else if (var_name == ErrorPathVarName()) 4186 { 4187 value.AppendString (m_error_path.c_str()); 4188 } 4189 else if (var_name == InheritHostEnvVarName()) 4190 { 4191 if (m_inherit_host_env) 4192 value.AppendString ("true"); 4193 else 4194 value.AppendString ("false"); 4195 } 4196 else if (var_name == DisableASLRVarName()) 4197 { 4198 if (m_disable_aslr) 4199 value.AppendString ("true"); 4200 else 4201 value.AppendString ("false"); 4202 } 4203 else if (var_name == DisableSTDIOVarName()) 4204 { 4205 if (m_disable_stdio) 4206 value.AppendString ("true"); 4207 else 4208 value.AppendString ("false"); 4209 } 4210 else 4211 { 4212 if (err) 4213 err->SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString()); 4214 return false; 4215 } 4216 return true; 4217 } 4218 4219 const ConstString 4220 ProcessInstanceSettings::CreateInstanceName () 4221 { 4222 static int instance_count = 1; 4223 StreamString sstr; 4224 4225 sstr.Printf ("process_%d", instance_count); 4226 ++instance_count; 4227 4228 const ConstString ret_val (sstr.GetData()); 4229 return ret_val; 4230 } 4231 4232 const ConstString & 4233 ProcessInstanceSettings::RunArgsVarName () 4234 { 4235 static ConstString run_args_var_name ("run-args"); 4236 4237 return run_args_var_name; 4238 } 4239 4240 const ConstString & 4241 ProcessInstanceSettings::EnvVarsVarName () 4242 { 4243 static ConstString env_vars_var_name ("env-vars"); 4244 4245 return env_vars_var_name; 4246 } 4247 4248 const ConstString & 4249 ProcessInstanceSettings::InheritHostEnvVarName () 4250 { 4251 static ConstString g_name ("inherit-env"); 4252 4253 return g_name; 4254 } 4255 4256 const ConstString & 4257 ProcessInstanceSettings::InputPathVarName () 4258 { 4259 static ConstString input_path_var_name ("input-path"); 4260 4261 return input_path_var_name; 4262 } 4263 4264 const ConstString & 4265 ProcessInstanceSettings::OutputPathVarName () 4266 { 4267 static ConstString output_path_var_name ("output-path"); 4268 4269 return output_path_var_name; 4270 } 4271 4272 const ConstString & 4273 ProcessInstanceSettings::ErrorPathVarName () 4274 { 4275 static ConstString error_path_var_name ("error-path"); 4276 4277 return error_path_var_name; 4278 } 4279 4280 const ConstString & 4281 ProcessInstanceSettings::DisableASLRVarName () 4282 { 4283 static ConstString disable_aslr_var_name ("disable-aslr"); 4284 4285 return disable_aslr_var_name; 4286 } 4287 4288 const ConstString & 4289 ProcessInstanceSettings::DisableSTDIOVarName () 4290 { 4291 static ConstString disable_stdio_var_name ("disable-stdio"); 4292 4293 return disable_stdio_var_name; 4294 } 4295 4296 //-------------------------------------------------- 4297 // SettingsController Variable Tables 4298 //-------------------------------------------------- 4299 4300 SettingEntry 4301 Process::SettingsController::global_settings_table[] = 4302 { 4303 //{ "var-name", var-type , "default", enum-table, init'd, hidden, "help-text"}, 4304 { NULL, eSetVarTypeNone, NULL, NULL, 0, 0, NULL } 4305 }; 4306 4307 4308 SettingEntry 4309 Process::SettingsController::instance_settings_table[] = 4310 { 4311 //{ "var-name", var-type, "default", enum-table, init'd, hidden, "help-text"}, 4312 { "run-args", eSetVarTypeArray, NULL, NULL, false, false, "A list containing all the arguments to be passed to the executable when it is run." }, 4313 { "env-vars", eSetVarTypeDictionary, NULL, NULL, false, false, "A list of all the environment variables to be passed to the executable's environment, and their values." }, 4314 { "inherit-env", eSetVarTypeBoolean, "true", NULL, false, false, "Inherit the environment from the process that is running LLDB." }, 4315 { "input-path", eSetVarTypeString, NULL, NULL, false, false, "The file/path to be used by the executable program for reading its input." }, 4316 { "output-path", eSetVarTypeString, NULL, NULL, false, false, "The file/path to be used by the executable program for writing its output." }, 4317 { "error-path", eSetVarTypeString, NULL, NULL, false, false, "The file/path to be used by the executable program for writings its error messages." }, 4318 { "plugin", eSetVarTypeEnum, NULL, NULL, false, false, "The plugin to be used to run the process." }, 4319 { "disable-aslr", eSetVarTypeBoolean, "true", NULL, false, false, "Disable Address Space Layout Randomization (ASLR)" }, 4320 { "disable-stdio", eSetVarTypeBoolean, "false", NULL, false, false, "Disable stdin/stdout for process (e.g. for a GUI application)" }, 4321 { NULL, eSetVarTypeNone, NULL, NULL, false, false, NULL } 4322 }; 4323 4324 4325 4326