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