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/Debugger.h" 18 #include "lldb/Core/Log.h" 19 #include "lldb/Core/PluginManager.h" 20 #include "lldb/Core/State.h" 21 #include "lldb/Interpreter/CommandInterpreter.h" 22 #include "lldb/Host/Host.h" 23 #include "lldb/Target/ABI.h" 24 #include "lldb/Target/LanguageRuntime.h" 25 #include "lldb/Target/CPPLanguageRuntime.h" 26 #include "lldb/Target/ObjCLanguageRuntime.h" 27 #include "lldb/Target/RegisterContext.h" 28 #include "lldb/Target/StopInfo.h" 29 #include "lldb/Target/Target.h" 30 #include "lldb/Target/TargetList.h" 31 #include "lldb/Target/Thread.h" 32 #include "lldb/Target/ThreadPlan.h" 33 34 using namespace lldb; 35 using namespace lldb_private; 36 37 Process* 38 Process::FindPlugin (Target &target, const char *plugin_name, Listener &listener) 39 { 40 ProcessCreateInstance create_callback = NULL; 41 if (plugin_name) 42 { 43 create_callback = PluginManager::GetProcessCreateCallbackForPluginName (plugin_name); 44 if (create_callback) 45 { 46 std::auto_ptr<Process> debugger_ap(create_callback(target, listener)); 47 if (debugger_ap->CanDebug(target)) 48 return debugger_ap.release(); 49 } 50 } 51 else 52 { 53 for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx) 54 { 55 std::auto_ptr<Process> debugger_ap(create_callback(target, listener)); 56 if (debugger_ap->CanDebug(target)) 57 return debugger_ap.release(); 58 } 59 } 60 return NULL; 61 } 62 63 64 //---------------------------------------------------------------------- 65 // Process constructor 66 //---------------------------------------------------------------------- 67 Process::Process(Target &target, Listener &listener) : 68 UserID (LLDB_INVALID_PROCESS_ID), 69 Broadcaster ("Process"), 70 ProcessInstanceSettings (*(Process::GetSettingsController().get())), 71 m_target (target), 72 m_public_state (eStateUnloaded), 73 m_private_state (eStateUnloaded), 74 m_private_state_broadcaster ("lldb.process.internal_state_broadcaster"), 75 m_private_state_control_broadcaster ("lldb.process.internal_state_control_broadcaster"), 76 m_private_state_listener ("lldb.process.internal_state_listener"), 77 m_private_state_control_wait(), 78 m_private_state_thread (LLDB_INVALID_HOST_THREAD), 79 m_stop_id (0), 80 m_thread_index_id (0), 81 m_exit_status (-1), 82 m_exit_string (), 83 m_thread_list (this), 84 m_notifications (), 85 m_persistent_vars(), 86 m_listener(listener), 87 m_unix_signals () 88 { 89 UpdateInstanceName(); 90 91 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT); 92 if (log) 93 log->Printf ("%p Process::Process()", this); 94 95 listener.StartListeningForEvents (this, 96 eBroadcastBitStateChanged | 97 eBroadcastBitInterrupt | 98 eBroadcastBitSTDOUT | 99 eBroadcastBitSTDERR); 100 101 m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster, 102 eBroadcastBitStateChanged); 103 104 m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster, 105 eBroadcastInternalStateControlStop | 106 eBroadcastInternalStateControlPause | 107 eBroadcastInternalStateControlResume); 108 } 109 110 //---------------------------------------------------------------------- 111 // Destructor 112 //---------------------------------------------------------------------- 113 Process::~Process() 114 { 115 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT); 116 if (log) 117 log->Printf ("%p Process::~Process()", this); 118 StopPrivateStateThread(); 119 } 120 121 void 122 Process::Finalize() 123 { 124 // Do any cleanup needed prior to being destructed... Subclasses 125 // that override this method should call this superclass method as well. 126 } 127 128 void 129 Process::RegisterNotificationCallbacks (const Notifications& callbacks) 130 { 131 m_notifications.push_back(callbacks); 132 if (callbacks.initialize != NULL) 133 callbacks.initialize (callbacks.baton, this); 134 } 135 136 bool 137 Process::UnregisterNotificationCallbacks(const Notifications& callbacks) 138 { 139 std::vector<Notifications>::iterator pos, end = m_notifications.end(); 140 for (pos = m_notifications.begin(); pos != end; ++pos) 141 { 142 if (pos->baton == callbacks.baton && 143 pos->initialize == callbacks.initialize && 144 pos->process_state_changed == callbacks.process_state_changed) 145 { 146 m_notifications.erase(pos); 147 return true; 148 } 149 } 150 return false; 151 } 152 153 void 154 Process::SynchronouslyNotifyStateChanged (StateType state) 155 { 156 std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end(); 157 for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos) 158 { 159 if (notification_pos->process_state_changed) 160 notification_pos->process_state_changed (notification_pos->baton, this, state); 161 } 162 } 163 164 // FIXME: We need to do some work on events before the general Listener sees them. 165 // For instance if we are continuing from a breakpoint, we need to ensure that we do 166 // the little "insert real insn, step & stop" trick. But we can't do that when the 167 // event is delivered by the broadcaster - since that is done on the thread that is 168 // waiting for new events, so if we needed more than one event for our handling, we would 169 // stall. So instead we do it when we fetch the event off of the queue. 170 // 171 172 StateType 173 Process::GetNextEvent (EventSP &event_sp) 174 { 175 StateType state = eStateInvalid; 176 177 if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp) 178 state = Process::ProcessEventData::GetStateFromEvent (event_sp.get()); 179 180 return state; 181 } 182 183 184 StateType 185 Process::WaitForProcessToStop (const TimeValue *timeout) 186 { 187 StateType match_states[] = { eStateStopped, eStateCrashed, eStateDetached, eStateExited, eStateUnloaded }; 188 return WaitForState (timeout, match_states, sizeof(match_states) / sizeof(StateType)); 189 } 190 191 192 StateType 193 Process::WaitForState 194 ( 195 const TimeValue *timeout, 196 const StateType *match_states, const uint32_t num_match_states 197 ) 198 { 199 EventSP event_sp; 200 uint32_t i; 201 StateType state = GetState(); 202 while (state != eStateInvalid) 203 { 204 // If we are exited or detached, we won't ever get back to any 205 // other valid state... 206 if (state == eStateDetached || state == eStateExited) 207 return state; 208 209 state = WaitForStateChangedEvents (timeout, event_sp); 210 211 for (i=0; i<num_match_states; ++i) 212 { 213 if (match_states[i] == state) 214 return state; 215 } 216 } 217 return state; 218 } 219 220 bool 221 Process::HijackProcessEvents (Listener *listener) 222 { 223 if (listener != NULL) 224 { 225 return HijackBroadcaster(listener, eBroadcastBitStateChanged); 226 } 227 else 228 return false; 229 } 230 231 void 232 Process::RestoreProcessEvents () 233 { 234 RestoreBroadcaster(); 235 } 236 237 StateType 238 Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp) 239 { 240 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 241 242 if (log) 243 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout); 244 245 StateType state = eStateInvalid; 246 if (m_listener.WaitForEventForBroadcasterWithType (timeout, 247 this, 248 eBroadcastBitStateChanged, 249 event_sp)) 250 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 251 252 if (log) 253 log->Printf ("Process::%s (timeout = %p, event_sp) => %s", 254 __FUNCTION__, 255 timeout, 256 StateAsCString(state)); 257 return state; 258 } 259 260 Event * 261 Process::PeekAtStateChangedEvents () 262 { 263 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 264 265 if (log) 266 log->Printf ("Process::%s...", __FUNCTION__); 267 268 Event *event_ptr; 269 event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this, 270 eBroadcastBitStateChanged); 271 if (log) 272 { 273 if (event_ptr) 274 { 275 log->Printf ("Process::%s (event_ptr) => %s", 276 __FUNCTION__, 277 StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr))); 278 } 279 else 280 { 281 log->Printf ("Process::%s no events found", 282 __FUNCTION__); 283 } 284 } 285 return event_ptr; 286 } 287 288 StateType 289 Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp) 290 { 291 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 292 293 if (log) 294 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout); 295 296 StateType state = eStateInvalid; 297 if (m_private_state_listener.WaitForEventForBroadcasterWithType(timeout, 298 &m_private_state_broadcaster, 299 eBroadcastBitStateChanged, 300 event_sp)) 301 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 302 303 // This is a bit of a hack, but when we wait here we could very well return 304 // to the command-line, and that could disable the log, which would render the 305 // log we got above invalid. 306 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 307 if (log) 308 log->Printf ("Process::%s (timeout = %p, event_sp) => %s", __FUNCTION__, timeout, StateAsCString(state)); 309 return state; 310 } 311 312 bool 313 Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only) 314 { 315 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 316 317 if (log) 318 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, timeout); 319 320 if (control_only) 321 return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp); 322 else 323 return m_private_state_listener.WaitForEvent(timeout, event_sp); 324 } 325 326 bool 327 Process::IsRunning () const 328 { 329 return StateIsRunningState (m_public_state.GetValue()); 330 } 331 332 int 333 Process::GetExitStatus () 334 { 335 if (m_public_state.GetValue() == eStateExited) 336 return m_exit_status; 337 return -1; 338 } 339 340 const char * 341 Process::GetExitDescription () 342 { 343 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty()) 344 return m_exit_string.c_str(); 345 return NULL; 346 } 347 348 void 349 Process::SetExitStatus (int status, const char *cstr) 350 { 351 m_exit_status = status; 352 if (cstr) 353 m_exit_string = cstr; 354 else 355 m_exit_string.clear(); 356 357 SetPrivateState (eStateExited); 358 } 359 360 // This static callback can be used to watch for local child processes on 361 // the current host. The the child process exits, the process will be 362 // found in the global target list (we want to be completely sure that the 363 // lldb_private::Process doesn't go away before we can deliver the signal. 364 bool 365 Process::SetProcessExitStatus 366 ( 367 void *callback_baton, 368 lldb::pid_t pid, 369 int signo, // Zero for no signal 370 int exit_status // Exit value of process if signal is zero 371 ) 372 { 373 if (signo == 0 || exit_status) 374 { 375 TargetSP target_sp(Debugger::FindTargetWithProcessID (pid)); 376 if (target_sp) 377 { 378 ProcessSP process_sp (target_sp->GetProcessSP()); 379 if (process_sp) 380 { 381 const char *signal_cstr = NULL; 382 if (signo) 383 signal_cstr = process_sp->GetUnixSignals().GetSignalAsCString (signo); 384 385 process_sp->SetExitStatus (exit_status, signal_cstr); 386 } 387 } 388 return true; 389 } 390 return false; 391 } 392 393 394 uint32_t 395 Process::GetNextThreadIndexID () 396 { 397 return ++m_thread_index_id; 398 } 399 400 StateType 401 Process::GetState() 402 { 403 // If any other threads access this we will need a mutex for it 404 return m_public_state.GetValue (); 405 } 406 407 void 408 Process::SetPublicState (StateType new_state) 409 { 410 Log *log = lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE); 411 if (log) 412 log->Printf("Process::SetPublicState (%s)", StateAsCString(new_state)); 413 m_public_state.SetValue (new_state); 414 } 415 416 StateType 417 Process::GetPrivateState () 418 { 419 return m_private_state.GetValue(); 420 } 421 422 void 423 Process::SetPrivateState (StateType new_state) 424 { 425 Log *log = lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE); 426 bool state_changed = false; 427 428 if (log) 429 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state)); 430 431 Mutex::Locker locker(m_private_state.GetMutex()); 432 433 const StateType old_state = m_private_state.GetValueNoLock (); 434 state_changed = old_state != new_state; 435 if (state_changed) 436 { 437 m_private_state.SetValueNoLock (new_state); 438 if (StateIsStoppedState(new_state)) 439 { 440 m_stop_id++; 441 if (log) 442 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_stop_id); 443 } 444 // Use our target to get a shared pointer to ourselves... 445 m_private_state_broadcaster.BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (GetTarget().GetProcessSP(), new_state)); 446 } 447 else 448 { 449 if (log) 450 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state), StateAsCString(old_state)); 451 } 452 } 453 454 455 uint32_t 456 Process::GetStopID() const 457 { 458 return m_stop_id; 459 } 460 461 addr_t 462 Process::GetImageInfoAddress() 463 { 464 return LLDB_INVALID_ADDRESS; 465 } 466 467 DynamicLoader * 468 Process::GetDynamicLoader() 469 { 470 return NULL; 471 } 472 473 const ABI * 474 Process::GetABI() 475 { 476 ConstString& triple = m_target_triple; 477 478 if (triple.IsEmpty()) 479 return NULL; 480 481 if (m_abi_sp.get() == NULL) 482 { 483 m_abi_sp.reset(ABI::FindPlugin(triple)); 484 } 485 486 return m_abi_sp.get(); 487 } 488 489 LanguageRuntime * 490 Process::GetLanguageRuntime(lldb::LanguageType language) 491 { 492 LanguageRuntimeCollection::iterator pos; 493 pos = m_language_runtimes.find (language); 494 if (pos == m_language_runtimes.end()) 495 { 496 lldb::LanguageRuntimeSP runtime(LanguageRuntime::FindPlugin(this, language)); 497 498 m_language_runtimes[language] 499 = runtime; 500 return runtime.get(); 501 } 502 else 503 return (*pos).second.get(); 504 } 505 506 CPPLanguageRuntime * 507 Process::GetCPPLanguageRuntime () 508 { 509 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus); 510 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus) 511 return static_cast<CPPLanguageRuntime *> (runtime); 512 return NULL; 513 } 514 515 ObjCLanguageRuntime * 516 Process::GetObjCLanguageRuntime () 517 { 518 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC); 519 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC) 520 return static_cast<ObjCLanguageRuntime *> (runtime); 521 return NULL; 522 } 523 524 BreakpointSiteList & 525 Process::GetBreakpointSiteList() 526 { 527 return m_breakpoint_site_list; 528 } 529 530 const BreakpointSiteList & 531 Process::GetBreakpointSiteList() const 532 { 533 return m_breakpoint_site_list; 534 } 535 536 537 void 538 Process::DisableAllBreakpointSites () 539 { 540 m_breakpoint_site_list.SetEnabledForAll (false); 541 } 542 543 Error 544 Process::ClearBreakpointSiteByID (lldb::user_id_t break_id) 545 { 546 Error error (DisableBreakpointSiteByID (break_id)); 547 548 if (error.Success()) 549 m_breakpoint_site_list.Remove(break_id); 550 551 return error; 552 } 553 554 Error 555 Process::DisableBreakpointSiteByID (lldb::user_id_t break_id) 556 { 557 Error error; 558 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id); 559 if (bp_site_sp) 560 { 561 if (bp_site_sp->IsEnabled()) 562 error = DisableBreakpoint (bp_site_sp.get()); 563 } 564 else 565 { 566 error.SetErrorStringWithFormat("invalid breakpoint site ID: %i", break_id); 567 } 568 569 return error; 570 } 571 572 Error 573 Process::EnableBreakpointSiteByID (lldb::user_id_t break_id) 574 { 575 Error error; 576 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id); 577 if (bp_site_sp) 578 { 579 if (!bp_site_sp->IsEnabled()) 580 error = EnableBreakpoint (bp_site_sp.get()); 581 } 582 else 583 { 584 error.SetErrorStringWithFormat("invalid breakpoint site ID: %i", break_id); 585 } 586 return error; 587 } 588 589 lldb::break_id_t 590 Process::CreateBreakpointSite (BreakpointLocationSP &owner, bool use_hardware) 591 { 592 const addr_t load_addr = owner->GetAddress().GetLoadAddress (&m_target); 593 if (load_addr != LLDB_INVALID_ADDRESS) 594 { 595 BreakpointSiteSP bp_site_sp; 596 597 // Look up this breakpoint site. If it exists, then add this new owner, otherwise 598 // create a new breakpoint site and add it. 599 600 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr); 601 602 if (bp_site_sp) 603 { 604 bp_site_sp->AddOwner (owner); 605 owner->SetBreakpointSite (bp_site_sp); 606 return bp_site_sp->GetID(); 607 } 608 else 609 { 610 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, LLDB_INVALID_THREAD_ID, use_hardware)); 611 if (bp_site_sp) 612 { 613 if (EnableBreakpoint (bp_site_sp.get()).Success()) 614 { 615 owner->SetBreakpointSite (bp_site_sp); 616 return m_breakpoint_site_list.Add (bp_site_sp); 617 } 618 } 619 } 620 } 621 // We failed to enable the breakpoint 622 return LLDB_INVALID_BREAK_ID; 623 624 } 625 626 void 627 Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp) 628 { 629 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id); 630 if (num_owners == 0) 631 { 632 DisableBreakpoint(bp_site_sp.get()); 633 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress()); 634 } 635 } 636 637 638 size_t 639 Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const 640 { 641 size_t bytes_removed = 0; 642 addr_t intersect_addr; 643 size_t intersect_size; 644 size_t opcode_offset; 645 size_t idx; 646 BreakpointSiteSP bp; 647 648 for (idx = 0; (bp = m_breakpoint_site_list.GetByIndex(idx)) != NULL; ++idx) 649 { 650 if (bp->GetType() == BreakpointSite::eSoftware) 651 { 652 if (bp->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset)) 653 { 654 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size); 655 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size); 656 assert(opcode_offset + intersect_size <= bp->GetByteSize()); 657 size_t buf_offset = intersect_addr - bp_addr; 658 ::memcpy(buf + buf_offset, bp->GetSavedOpcodeBytes() + opcode_offset, intersect_size); 659 } 660 } 661 } 662 return bytes_removed; 663 } 664 665 666 Error 667 Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site) 668 { 669 Error error; 670 assert (bp_site != NULL); 671 Log *log = lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS); 672 const addr_t bp_addr = bp_site->GetLoadAddress(); 673 if (log) 674 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx", bp_site->GetID(), (uint64_t)bp_addr); 675 if (bp_site->IsEnabled()) 676 { 677 if (log) 678 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already enabled", bp_site->GetID(), (uint64_t)bp_addr); 679 return error; 680 } 681 682 if (bp_addr == LLDB_INVALID_ADDRESS) 683 { 684 error.SetErrorString("BreakpointSite contains an invalid load address."); 685 return error; 686 } 687 // Ask the lldb::Process subclass to fill in the correct software breakpoint 688 // trap for the breakpoint site 689 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site); 690 691 if (bp_opcode_size == 0) 692 { 693 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%llx.\n", bp_addr); 694 } 695 else 696 { 697 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes(); 698 699 if (bp_opcode_bytes == NULL) 700 { 701 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode."); 702 return error; 703 } 704 705 // Save the original opcode by reading it 706 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size) 707 { 708 // Write a software breakpoint in place of the original opcode 709 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size) 710 { 711 uint8_t verify_bp_opcode_bytes[64]; 712 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size) 713 { 714 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0) 715 { 716 bp_site->SetEnabled(true); 717 bp_site->SetType (BreakpointSite::eSoftware); 718 if (log) 719 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS", 720 bp_site->GetID(), 721 (uint64_t)bp_addr); 722 } 723 else 724 error.SetErrorString("Failed to verify the breakpoint trap in memory."); 725 } 726 else 727 error.SetErrorString("Unable to read memory to verify breakpoint trap."); 728 } 729 else 730 error.SetErrorString("Unable to write breakpoint trap to memory."); 731 } 732 else 733 error.SetErrorString("Unable to read memory at breakpoint address."); 734 } 735 if (log) 736 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s", 737 bp_site->GetID(), 738 (uint64_t)bp_addr, 739 error.AsCString()); 740 return error; 741 } 742 743 Error 744 Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site) 745 { 746 Error error; 747 assert (bp_site != NULL); 748 Log *log = lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS); 749 addr_t bp_addr = bp_site->GetLoadAddress(); 750 lldb::user_id_t breakID = bp_site->GetID(); 751 if (log) 752 log->Printf ("ProcessMacOSX::DisableBreakpoint (breakID = %d) addr = 0x%llx", breakID, (uint64_t)bp_addr); 753 754 if (bp_site->IsHardware()) 755 { 756 error.SetErrorString("Breakpoint site is a hardware breakpoint."); 757 } 758 else if (bp_site->IsEnabled()) 759 { 760 const size_t break_op_size = bp_site->GetByteSize(); 761 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes(); 762 if (break_op_size > 0) 763 { 764 // Clear a software breakoint instruction 765 uint8_t curr_break_op[8]; 766 assert (break_op_size <= sizeof(curr_break_op)); 767 bool break_op_found = false; 768 769 // Read the breakpoint opcode 770 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size) 771 { 772 bool verify = false; 773 // Make sure we have the a breakpoint opcode exists at this address 774 if (::memcmp (curr_break_op, break_op, break_op_size) == 0) 775 { 776 break_op_found = true; 777 // We found a valid breakpoint opcode at this address, now restore 778 // the saved opcode. 779 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size) 780 { 781 verify = true; 782 } 783 else 784 error.SetErrorString("Memory write failed when restoring original opcode."); 785 } 786 else 787 { 788 error.SetErrorString("Original breakpoint trap is no longer in memory."); 789 // Set verify to true and so we can check if the original opcode has already been restored 790 verify = true; 791 } 792 793 if (verify) 794 { 795 uint8_t verify_opcode[8]; 796 assert (break_op_size < sizeof(verify_opcode)); 797 // Verify that our original opcode made it back to the inferior 798 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size) 799 { 800 // compare the memory we just read with the original opcode 801 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0) 802 { 803 // SUCCESS 804 bp_site->SetEnabled(false); 805 if (log) 806 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- SUCCESS", bp_site->GetID(), (uint64_t)bp_addr); 807 return error; 808 } 809 else 810 { 811 if (break_op_found) 812 error.SetErrorString("Failed to restore original opcode."); 813 } 814 } 815 else 816 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored."); 817 } 818 } 819 else 820 error.SetErrorString("Unable to read memory that should contain the breakpoint trap."); 821 } 822 } 823 else 824 { 825 if (log) 826 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- already disabled", bp_site->GetID(), (uint64_t)bp_addr); 827 return error; 828 } 829 830 if (log) 831 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%llx -- FAILED: %s", 832 bp_site->GetID(), 833 (uint64_t)bp_addr, 834 error.AsCString()); 835 return error; 836 837 } 838 839 840 size_t 841 Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error) 842 { 843 if (buf == NULL || size == 0) 844 return 0; 845 846 size_t bytes_read = 0; 847 uint8_t *bytes = (uint8_t *)buf; 848 849 while (bytes_read < size) 850 { 851 const size_t curr_size = size - bytes_read; 852 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read, 853 bytes + bytes_read, 854 curr_size, 855 error); 856 bytes_read += curr_bytes_read; 857 if (curr_bytes_read == curr_size || curr_bytes_read == 0) 858 break; 859 } 860 861 // Replace any software breakpoint opcodes that fall into this range back 862 // into "buf" before we return 863 if (bytes_read > 0) 864 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf); 865 return bytes_read; 866 } 867 868 size_t 869 Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error) 870 { 871 size_t bytes_written = 0; 872 const uint8_t *bytes = (const uint8_t *)buf; 873 874 while (bytes_written < size) 875 { 876 const size_t curr_size = size - bytes_written; 877 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written, 878 bytes + bytes_written, 879 curr_size, 880 error); 881 bytes_written += curr_bytes_written; 882 if (curr_bytes_written == curr_size || curr_bytes_written == 0) 883 break; 884 } 885 return bytes_written; 886 } 887 888 size_t 889 Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error) 890 { 891 if (buf == NULL || size == 0) 892 return 0; 893 // We need to write any data that would go where any current software traps 894 // (enabled software breakpoints) any software traps (breakpoints) that we 895 // may have placed in our tasks memory. 896 897 BreakpointSiteList::collection::const_iterator iter = m_breakpoint_site_list.GetMap()->lower_bound (addr); 898 BreakpointSiteList::collection::const_iterator end = m_breakpoint_site_list.GetMap()->end(); 899 900 if (iter == end || iter->second->GetLoadAddress() > addr + size) 901 return DoWriteMemory(addr, buf, size, error); 902 903 BreakpointSiteList::collection::const_iterator pos; 904 size_t bytes_written = 0; 905 addr_t intersect_addr = 0; 906 size_t intersect_size = 0; 907 size_t opcode_offset = 0; 908 const uint8_t *ubuf = (const uint8_t *)buf; 909 910 for (pos = iter; pos != end; ++pos) 911 { 912 BreakpointSiteSP bp; 913 bp = pos->second; 914 915 assert(bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset)); 916 assert(addr <= intersect_addr && intersect_addr < addr + size); 917 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size); 918 assert(opcode_offset + intersect_size <= bp->GetByteSize()); 919 920 // Check for bytes before this breakpoint 921 const addr_t curr_addr = addr + bytes_written; 922 if (intersect_addr > curr_addr) 923 { 924 // There are some bytes before this breakpoint that we need to 925 // just write to memory 926 size_t curr_size = intersect_addr - curr_addr; 927 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr, 928 ubuf + bytes_written, 929 curr_size, 930 error); 931 bytes_written += curr_bytes_written; 932 if (curr_bytes_written != curr_size) 933 { 934 // We weren't able to write all of the requested bytes, we 935 // are done looping and will return the number of bytes that 936 // we have written so far. 937 break; 938 } 939 } 940 941 // Now write any bytes that would cover up any software breakpoints 942 // directly into the breakpoint opcode buffer 943 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size); 944 bytes_written += intersect_size; 945 } 946 947 // Write any remaining bytes after the last breakpoint if we have any left 948 if (bytes_written < size) 949 bytes_written += WriteMemoryPrivate (addr + bytes_written, 950 ubuf + bytes_written, 951 size - bytes_written, 952 error); 953 954 return bytes_written; 955 } 956 957 addr_t 958 Process::AllocateMemory(size_t size, uint32_t permissions, Error &error) 959 { 960 // Fixme: we should track the blocks we've allocated, and clean them up... 961 // We could even do our own allocator here if that ends up being more efficient. 962 return DoAllocateMemory (size, permissions, error); 963 } 964 965 Error 966 Process::DeallocateMemory (addr_t ptr) 967 { 968 return DoDeallocateMemory (ptr); 969 } 970 971 972 Error 973 Process::EnableWatchpoint (WatchpointLocation *watchpoint) 974 { 975 Error error; 976 error.SetErrorString("watchpoints are not supported"); 977 return error; 978 } 979 980 Error 981 Process::DisableWatchpoint (WatchpointLocation *watchpoint) 982 { 983 Error error; 984 error.SetErrorString("watchpoints are not supported"); 985 return error; 986 } 987 988 StateType 989 Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp) 990 { 991 StateType state; 992 // Now wait for the process to launch and return control to us, and then 993 // call DidLaunch: 994 while (1) 995 { 996 // FIXME: Might want to put a timeout in here: 997 state = WaitForStateChangedEventsPrivate (NULL, event_sp); 998 if (state == eStateStopped || state == eStateCrashed || state == eStateExited) 999 break; 1000 else 1001 HandlePrivateEvent (event_sp); 1002 } 1003 return state; 1004 } 1005 1006 Error 1007 Process::Launch 1008 ( 1009 char const *argv[], 1010 char const *envp[], 1011 uint32_t launch_flags, 1012 const char *stdin_path, 1013 const char *stdout_path, 1014 const char *stderr_path 1015 ) 1016 { 1017 Error error; 1018 m_target_triple.Clear(); 1019 m_abi_sp.reset(); 1020 1021 Module *exe_module = m_target.GetExecutableModule().get(); 1022 if (exe_module) 1023 { 1024 char exec_file_path[PATH_MAX]; 1025 exe_module->GetFileSpec().GetPath(exec_file_path, sizeof(exec_file_path)); 1026 if (exe_module->GetFileSpec().Exists()) 1027 { 1028 error = WillLaunch (exe_module); 1029 if (error.Success()) 1030 { 1031 SetPublicState (eStateLaunching); 1032 // The args coming in should not contain the application name, the 1033 // lldb_private::Process class will add this in case the executable 1034 // gets resolved to a different file than was given on the command 1035 // line (like when an applicaiton bundle is specified and will 1036 // resolve to the contained exectuable file, or the file given was 1037 // a symlink or other file system link that resolves to a different 1038 // file). 1039 1040 // Get the resolved exectuable path 1041 1042 // Make a new argument vector 1043 std::vector<const char *> exec_path_plus_argv; 1044 // Append the resolved executable path 1045 exec_path_plus_argv.push_back (exec_file_path); 1046 1047 // Push all args if there are any 1048 if (argv) 1049 { 1050 for (int i = 0; argv[i]; ++i) 1051 exec_path_plus_argv.push_back(argv[i]); 1052 } 1053 1054 // Push a NULL to terminate the args. 1055 exec_path_plus_argv.push_back(NULL); 1056 1057 // Now launch using these arguments. 1058 error = DoLaunch (exe_module, 1059 exec_path_plus_argv.empty() ? NULL : &exec_path_plus_argv.front(), 1060 envp, 1061 launch_flags, 1062 stdin_path, 1063 stdout_path, 1064 stderr_path); 1065 1066 if (error.Fail()) 1067 { 1068 if (GetID() != LLDB_INVALID_PROCESS_ID) 1069 { 1070 SetID (LLDB_INVALID_PROCESS_ID); 1071 const char *error_string = error.AsCString(); 1072 if (error_string == NULL) 1073 error_string = "launch failed"; 1074 SetExitStatus (-1, error_string); 1075 } 1076 } 1077 else 1078 { 1079 EventSP event_sp; 1080 StateType state = WaitForProcessStopPrivate(NULL, event_sp); 1081 1082 if (state == eStateStopped || state == eStateCrashed) 1083 { 1084 DidLaunch (); 1085 1086 // This delays passing the stopped event to listeners till DidLaunch gets 1087 // a chance to complete... 1088 HandlePrivateEvent (event_sp); 1089 StartPrivateStateThread (); 1090 } 1091 else if (state == eStateExited) 1092 { 1093 // We exited while trying to launch somehow. Don't call DidLaunch as that's 1094 // not likely to work, and return an invalid pid. 1095 HandlePrivateEvent (event_sp); 1096 } 1097 } 1098 } 1099 } 1100 else 1101 { 1102 error.SetErrorStringWithFormat("File doesn't exist: '%s'.\n", exec_file_path); 1103 } 1104 } 1105 return error; 1106 } 1107 1108 Error 1109 Process::CompleteAttach () 1110 { 1111 Error error; 1112 1113 if (GetID() == LLDB_INVALID_PROCESS_ID) 1114 { 1115 error.SetErrorString("no process"); 1116 } 1117 1118 EventSP event_sp; 1119 StateType state = WaitForProcessStopPrivate(NULL, event_sp); 1120 if (state == eStateStopped || state == eStateCrashed) 1121 { 1122 DidAttach (); 1123 // Figure out which one is the executable, and set that in our target: 1124 ModuleList &modules = GetTarget().GetImages(); 1125 1126 size_t num_modules = modules.GetSize(); 1127 for (int i = 0; i < num_modules; i++) 1128 { 1129 ModuleSP module_sp = modules.GetModuleAtIndex(i); 1130 if (module_sp->IsExecutable()) 1131 { 1132 ModuleSP exec_module = GetTarget().GetExecutableModule(); 1133 if (!exec_module || exec_module != module_sp) 1134 { 1135 1136 GetTarget().SetExecutableModule (module_sp, false); 1137 } 1138 break; 1139 } 1140 } 1141 1142 // This delays passing the stopped event to listeners till DidLaunch gets 1143 // a chance to complete... 1144 HandlePrivateEvent(event_sp); 1145 StartPrivateStateThread(); 1146 } 1147 else 1148 { 1149 // We exited while trying to launch somehow. Don't call DidLaunch as that's 1150 // not likely to work, and return an invalid pid. 1151 if (state == eStateExited) 1152 HandlePrivateEvent (event_sp); 1153 error.SetErrorStringWithFormat("invalid state after attach: %s", 1154 lldb_private::StateAsCString(state)); 1155 } 1156 return error; 1157 } 1158 1159 Error 1160 Process::Attach (lldb::pid_t attach_pid) 1161 { 1162 1163 m_target_triple.Clear(); 1164 m_abi_sp.reset(); 1165 1166 // Find the process and its architecture. Make sure it matches the architecture 1167 // of the current Target, and if not adjust it. 1168 1169 ArchSpec attach_spec = GetArchSpecForExistingProcess (attach_pid); 1170 if (attach_spec != GetTarget().GetArchitecture()) 1171 { 1172 // Set the architecture on the target. 1173 GetTarget().SetArchitecture(attach_spec); 1174 } 1175 1176 Error error (WillAttachToProcessWithID(attach_pid)); 1177 if (error.Success()) 1178 { 1179 SetPublicState (eStateAttaching); 1180 1181 error = DoAttachToProcessWithID (attach_pid); 1182 if (error.Success()) 1183 { 1184 error = CompleteAttach(); 1185 } 1186 else 1187 { 1188 if (GetID() != LLDB_INVALID_PROCESS_ID) 1189 { 1190 SetID (LLDB_INVALID_PROCESS_ID); 1191 const char *error_string = error.AsCString(); 1192 if (error_string == NULL) 1193 error_string = "attach failed"; 1194 1195 SetExitStatus(-1, error_string); 1196 } 1197 } 1198 } 1199 return error; 1200 } 1201 1202 Error 1203 Process::Attach (const char *process_name, bool wait_for_launch) 1204 { 1205 m_target_triple.Clear(); 1206 m_abi_sp.reset(); 1207 1208 // Find the process and its architecture. Make sure it matches the architecture 1209 // of the current Target, and if not adjust it. 1210 1211 if (!wait_for_launch) 1212 { 1213 ArchSpec attach_spec = GetArchSpecForExistingProcess (process_name); 1214 if (attach_spec.IsValid() && attach_spec != GetTarget().GetArchitecture()) 1215 { 1216 // Set the architecture on the target. 1217 GetTarget().SetArchitecture(attach_spec); 1218 } 1219 } 1220 1221 Error error (WillAttachToProcessWithName(process_name, wait_for_launch)); 1222 if (error.Success()) 1223 { 1224 SetPublicState (eStateAttaching); 1225 error = DoAttachToProcessWithName (process_name, wait_for_launch); 1226 if (error.Fail()) 1227 { 1228 if (GetID() != LLDB_INVALID_PROCESS_ID) 1229 { 1230 SetID (LLDB_INVALID_PROCESS_ID); 1231 const char *error_string = error.AsCString(); 1232 if (error_string == NULL) 1233 error_string = "attach failed"; 1234 1235 SetExitStatus(-1, error_string); 1236 } 1237 } 1238 else 1239 { 1240 error = CompleteAttach(); 1241 } 1242 } 1243 return error; 1244 } 1245 1246 Error 1247 Process::Resume () 1248 { 1249 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 1250 if (log) 1251 log->Printf("Process::Resume() m_stop_id = %u", m_stop_id); 1252 1253 Error error (WillResume()); 1254 // Tell the process it is about to resume before the thread list 1255 if (error.Success()) 1256 { 1257 // Now let the thread list know we are about to resume to it 1258 // can let all of our threads know that they are about to be 1259 // resumed. Threads will each be called with 1260 // Thread::WillResume(StateType) where StateType contains the state 1261 // that they are supposed to have when the process is resumed 1262 // (suspended/running/stepping). Threads should also check 1263 // their resume signal in lldb::Thread::GetResumeSignal() 1264 // to see if they are suppoed to start back up with a signal. 1265 if (m_thread_list.WillResume()) 1266 { 1267 error = DoResume(); 1268 if (error.Success()) 1269 { 1270 DidResume(); 1271 m_thread_list.DidResume(); 1272 } 1273 } 1274 else 1275 { 1276 error.SetErrorStringWithFormat("thread list returned flase after WillResume"); 1277 } 1278 } 1279 return error; 1280 } 1281 1282 Error 1283 Process::Halt () 1284 { 1285 Error error (WillHalt()); 1286 1287 if (error.Success()) 1288 { 1289 error = DoHalt(); 1290 if (error.Success()) 1291 DidHalt(); 1292 } 1293 return error; 1294 } 1295 1296 Error 1297 Process::Detach () 1298 { 1299 Error error (WillDetach()); 1300 1301 if (error.Success()) 1302 { 1303 DisableAllBreakpointSites(); 1304 error = DoDetach(); 1305 if (error.Success()) 1306 { 1307 DidDetach(); 1308 StopPrivateStateThread(); 1309 } 1310 } 1311 return error; 1312 } 1313 1314 Error 1315 Process::Destroy () 1316 { 1317 Error error (WillDestroy()); 1318 if (error.Success()) 1319 { 1320 DisableAllBreakpointSites(); 1321 error = DoDestroy(); 1322 if (error.Success()) 1323 { 1324 DidDestroy(); 1325 StopPrivateStateThread(); 1326 } 1327 } 1328 return error; 1329 } 1330 1331 Error 1332 Process::Signal (int signal) 1333 { 1334 Error error (WillSignal()); 1335 if (error.Success()) 1336 { 1337 error = DoSignal(signal); 1338 if (error.Success()) 1339 DidSignal(); 1340 } 1341 return error; 1342 } 1343 1344 UnixSignals & 1345 Process::GetUnixSignals () 1346 { 1347 return m_unix_signals; 1348 } 1349 1350 Target & 1351 Process::GetTarget () 1352 { 1353 return m_target; 1354 } 1355 1356 const Target & 1357 Process::GetTarget () const 1358 { 1359 return m_target; 1360 } 1361 1362 uint32_t 1363 Process::GetAddressByteSize() 1364 { 1365 return m_target.GetArchitecture().GetAddressByteSize(); 1366 } 1367 1368 bool 1369 Process::ShouldBroadcastEvent (Event *event_ptr) 1370 { 1371 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr); 1372 bool return_value = true; 1373 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS); 1374 1375 switch (state) 1376 { 1377 case eStateAttaching: 1378 case eStateLaunching: 1379 case eStateDetached: 1380 case eStateExited: 1381 case eStateUnloaded: 1382 // These events indicate changes in the state of the debugging session, always report them. 1383 return_value = true; 1384 break; 1385 case eStateInvalid: 1386 // We stopped for no apparent reason, don't report it. 1387 return_value = false; 1388 break; 1389 case eStateRunning: 1390 case eStateStepping: 1391 // If we've started the target running, we handle the cases where we 1392 // are already running and where there is a transition from stopped to 1393 // running differently. 1394 // running -> running: Automatically suppress extra running events 1395 // stopped -> running: Report except when there is one or more no votes 1396 // and no yes votes. 1397 SynchronouslyNotifyStateChanged (state); 1398 switch (m_public_state.GetValue()) 1399 { 1400 case eStateRunning: 1401 case eStateStepping: 1402 // We always suppress multiple runnings with no PUBLIC stop in between. 1403 return_value = false; 1404 break; 1405 default: 1406 // TODO: make this work correctly. For now always report 1407 // run if we aren't running so we don't miss any runnning 1408 // events. If I run the lldb/test/thread/a.out file and 1409 // break at main.cpp:58, run and hit the breakpoints on 1410 // multiple threads, then somehow during the stepping over 1411 // of all breakpoints no run gets reported. 1412 return_value = true; 1413 1414 // This is a transition from stop to run. 1415 switch (m_thread_list.ShouldReportRun (event_ptr)) 1416 { 1417 case eVoteYes: 1418 case eVoteNoOpinion: 1419 return_value = true; 1420 break; 1421 case eVoteNo: 1422 return_value = false; 1423 break; 1424 } 1425 break; 1426 } 1427 break; 1428 case eStateStopped: 1429 case eStateCrashed: 1430 case eStateSuspended: 1431 { 1432 // We've stopped. First see if we're going to restart the target. 1433 // If we are going to stop, then we always broadcast the event. 1434 // If we aren't going to stop, let the thread plans decide if we're going to report this event. 1435 // If no thread has an opinion, we don't report it. 1436 if (state != eStateInvalid) 1437 { 1438 1439 RefreshStateAfterStop (); 1440 1441 if (m_thread_list.ShouldStop (event_ptr) == false) 1442 { 1443 switch (m_thread_list.ShouldReportStop (event_ptr)) 1444 { 1445 case eVoteYes: 1446 Process::ProcessEventData::SetRestartedInEvent (event_ptr, true); 1447 // Intentional fall-through here. 1448 case eVoteNoOpinion: 1449 case eVoteNo: 1450 return_value = false; 1451 break; 1452 } 1453 1454 if (log) 1455 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process", event_ptr, StateAsCString(state)); 1456 Resume (); 1457 } 1458 else 1459 { 1460 return_value = true; 1461 SynchronouslyNotifyStateChanged (state); 1462 } 1463 } 1464 } 1465 } 1466 1467 if (log) 1468 log->Printf ("Process::ShouldBroadcastEvent (%p) => %s", event_ptr, StateAsCString(state), return_value ? "YES" : "NO"); 1469 return return_value; 1470 } 1471 1472 //------------------------------------------------------------------ 1473 // Thread Queries 1474 //------------------------------------------------------------------ 1475 1476 ThreadList & 1477 Process::GetThreadList () 1478 { 1479 return m_thread_list; 1480 } 1481 1482 const ThreadList & 1483 Process::GetThreadList () const 1484 { 1485 return m_thread_list; 1486 } 1487 1488 1489 bool 1490 Process::StartPrivateStateThread () 1491 { 1492 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS); 1493 1494 if (log) 1495 log->Printf ("Process::%s ( )", __FUNCTION__); 1496 1497 // Create a thread that watches our internal state and controls which 1498 // events make it to clients (into the DCProcess event queue). 1499 m_private_state_thread = Host::ThreadCreate ("<lldb.process.internal-state>", Process::PrivateStateThread, this, NULL); 1500 return m_private_state_thread != LLDB_INVALID_HOST_THREAD; 1501 } 1502 1503 void 1504 Process::PausePrivateStateThread () 1505 { 1506 ControlPrivateStateThread (eBroadcastInternalStateControlPause); 1507 } 1508 1509 void 1510 Process::ResumePrivateStateThread () 1511 { 1512 ControlPrivateStateThread (eBroadcastInternalStateControlResume); 1513 } 1514 1515 void 1516 Process::StopPrivateStateThread () 1517 { 1518 ControlPrivateStateThread (eBroadcastInternalStateControlStop); 1519 } 1520 1521 void 1522 Process::ControlPrivateStateThread (uint32_t signal) 1523 { 1524 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS); 1525 1526 assert (signal == eBroadcastInternalStateControlStop || 1527 signal == eBroadcastInternalStateControlPause || 1528 signal == eBroadcastInternalStateControlResume); 1529 1530 if (log) 1531 log->Printf ("Process::%s ( ) - signal: %d", __FUNCTION__, signal); 1532 1533 // Signal the private state thread 1534 if (m_private_state_thread != LLDB_INVALID_HOST_THREAD) 1535 { 1536 TimeValue timeout_time; 1537 bool timed_out; 1538 1539 m_private_state_control_broadcaster.BroadcastEvent (signal, NULL); 1540 1541 timeout_time = TimeValue::Now(); 1542 timeout_time.OffsetWithSeconds(2); 1543 m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out); 1544 m_private_state_control_wait.SetValue (false, eBroadcastNever); 1545 1546 if (signal == eBroadcastInternalStateControlStop) 1547 { 1548 if (timed_out) 1549 Host::ThreadCancel (m_private_state_thread, NULL); 1550 1551 thread_result_t result = NULL; 1552 Host::ThreadJoin (m_private_state_thread, &result, NULL); 1553 m_private_state_thread = LLDB_INVALID_HOST_THREAD; 1554 } 1555 } 1556 } 1557 1558 void 1559 Process::HandlePrivateEvent (EventSP &event_sp) 1560 { 1561 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 1562 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 1563 // See if we should broadcast this state to external clients? 1564 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get()); 1565 if (log) 1566 log->Printf ("Process::%s (arg = %p, pid = %i) got event '%s' broadcast = %s", __FUNCTION__, this, GetID(), StateAsCString(internal_state), should_broadcast ? "yes" : "no"); 1567 1568 if (should_broadcast) 1569 { 1570 if (log) 1571 { 1572 log->Printf ("\tChanging public state from: %s to %s", StateAsCString(GetState ()), StateAsCString (internal_state)); 1573 } 1574 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get()); 1575 BroadcastEvent (event_sp); 1576 } 1577 else 1578 { 1579 if (log) 1580 { 1581 log->Printf ("\tNot changing public state with event: %s", StateAsCString (internal_state)); 1582 } 1583 } 1584 } 1585 1586 void * 1587 Process::PrivateStateThread (void *arg) 1588 { 1589 Process *proc = static_cast<Process*> (arg); 1590 void *result = proc->RunPrivateStateThread (); 1591 return result; 1592 } 1593 1594 void * 1595 Process::RunPrivateStateThread () 1596 { 1597 bool control_only = false; 1598 m_private_state_control_wait.SetValue (false, eBroadcastNever); 1599 1600 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 1601 if (log) 1602 log->Printf ("Process::%s (arg = %p, pid = %i) thread starting...", __FUNCTION__, this, GetID()); 1603 1604 bool exit_now = false; 1605 while (!exit_now) 1606 { 1607 EventSP event_sp; 1608 WaitForEventsPrivate (NULL, event_sp, control_only); 1609 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) 1610 { 1611 switch (event_sp->GetType()) 1612 { 1613 case eBroadcastInternalStateControlStop: 1614 exit_now = true; 1615 continue; // Go to next loop iteration so we exit without 1616 break; // doing any internal state managment below 1617 1618 case eBroadcastInternalStateControlPause: 1619 control_only = true; 1620 break; 1621 1622 case eBroadcastInternalStateControlResume: 1623 control_only = false; 1624 break; 1625 } 1626 m_private_state_control_wait.SetValue (true, eBroadcastAlways); 1627 } 1628 1629 1630 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); 1631 1632 if (internal_state != eStateInvalid) 1633 { 1634 HandlePrivateEvent (event_sp); 1635 } 1636 1637 if (internal_state == eStateInvalid || 1638 internal_state == eStateExited || 1639 internal_state == eStateDetached ) 1640 break; 1641 } 1642 1643 if (log) 1644 log->Printf ("Process::%s (arg = %p, pid = %i) thread exiting...", __FUNCTION__, this, GetID()); 1645 1646 m_private_state_thread = LLDB_INVALID_HOST_THREAD; 1647 return NULL; 1648 } 1649 1650 //------------------------------------------------------------------ 1651 // Process Event Data 1652 //------------------------------------------------------------------ 1653 1654 Process::ProcessEventData::ProcessEventData () : 1655 EventData (), 1656 m_process_sp (), 1657 m_state (eStateInvalid), 1658 m_restarted (false), 1659 m_update_state (false) 1660 { 1661 } 1662 1663 Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) : 1664 EventData (), 1665 m_process_sp (process_sp), 1666 m_state (state), 1667 m_restarted (false), 1668 m_update_state (false) 1669 { 1670 } 1671 1672 Process::ProcessEventData::~ProcessEventData() 1673 { 1674 } 1675 1676 const ConstString & 1677 Process::ProcessEventData::GetFlavorString () 1678 { 1679 static ConstString g_flavor ("Process::ProcessEventData"); 1680 return g_flavor; 1681 } 1682 1683 const ConstString & 1684 Process::ProcessEventData::GetFlavor () const 1685 { 1686 return ProcessEventData::GetFlavorString (); 1687 } 1688 1689 const ProcessSP & 1690 Process::ProcessEventData::GetProcessSP () const 1691 { 1692 return m_process_sp; 1693 } 1694 1695 StateType 1696 Process::ProcessEventData::GetState () const 1697 { 1698 return m_state; 1699 } 1700 1701 bool 1702 Process::ProcessEventData::GetRestarted () const 1703 { 1704 return m_restarted; 1705 } 1706 1707 void 1708 Process::ProcessEventData::SetRestarted (bool new_value) 1709 { 1710 m_restarted = new_value; 1711 } 1712 1713 void 1714 Process::ProcessEventData::DoOnRemoval (Event *event_ptr) 1715 { 1716 // This function gets called twice for each event, once when the event gets pulled 1717 // off of the private process event queue, and once when it gets pulled off of 1718 // the public event queue. m_update_state is used to distinguish these 1719 // two cases; it is false when we're just pulling it off for private handling, 1720 // and we don't want to do the breakpoint command handling then. 1721 1722 if (!m_update_state) 1723 return; 1724 1725 m_process_sp->SetPublicState (m_state); 1726 1727 // If we're stopped and haven't restarted, then do the breakpoint commands here: 1728 if (m_state == eStateStopped && ! m_restarted) 1729 { 1730 int num_threads = m_process_sp->GetThreadList().GetSize(); 1731 int idx; 1732 1733 for (idx = 0; idx < num_threads; ++idx) 1734 { 1735 lldb::ThreadSP thread_sp = m_process_sp->GetThreadList().GetThreadAtIndex(idx); 1736 1737 StopInfoSP stop_info_sp = thread_sp->GetStopInfo (); 1738 if (stop_info_sp) 1739 { 1740 stop_info_sp->PerformAction(event_ptr); 1741 } 1742 } 1743 1744 // The stop action might restart the target. If it does, then we want to mark that in the 1745 // event so that whoever is receiving it will know to wait for the running event and reflect 1746 // that state appropriately. 1747 1748 if (m_process_sp->GetPrivateState() == eStateRunning) 1749 SetRestarted(true); 1750 } 1751 } 1752 1753 void 1754 Process::ProcessEventData::Dump (Stream *s) const 1755 { 1756 if (m_process_sp) 1757 s->Printf(" process = %p (pid = %u), ", m_process_sp.get(), m_process_sp->GetID()); 1758 1759 s->Printf("state = %s", StateAsCString(GetState()));; 1760 } 1761 1762 const Process::ProcessEventData * 1763 Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr) 1764 { 1765 if (event_ptr) 1766 { 1767 const EventData *event_data = event_ptr->GetData(); 1768 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString()) 1769 return static_cast <const ProcessEventData *> (event_ptr->GetData()); 1770 } 1771 return NULL; 1772 } 1773 1774 ProcessSP 1775 Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr) 1776 { 1777 ProcessSP process_sp; 1778 const ProcessEventData *data = GetEventDataFromEvent (event_ptr); 1779 if (data) 1780 process_sp = data->GetProcessSP(); 1781 return process_sp; 1782 } 1783 1784 StateType 1785 Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr) 1786 { 1787 const ProcessEventData *data = GetEventDataFromEvent (event_ptr); 1788 if (data == NULL) 1789 return eStateInvalid; 1790 else 1791 return data->GetState(); 1792 } 1793 1794 bool 1795 Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr) 1796 { 1797 const ProcessEventData *data = GetEventDataFromEvent (event_ptr); 1798 if (data == NULL) 1799 return false; 1800 else 1801 return data->GetRestarted(); 1802 } 1803 1804 void 1805 Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value) 1806 { 1807 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); 1808 if (data != NULL) 1809 data->SetRestarted(new_value); 1810 } 1811 1812 bool 1813 Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr) 1814 { 1815 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); 1816 if (data) 1817 { 1818 data->SetUpdateStateOnRemoval(); 1819 return true; 1820 } 1821 return false; 1822 } 1823 1824 void 1825 Process::ProcessEventData::SetUpdateStateOnRemoval() 1826 { 1827 m_update_state = true; 1828 } 1829 1830 Target * 1831 Process::CalculateTarget () 1832 { 1833 return &m_target; 1834 } 1835 1836 Process * 1837 Process::CalculateProcess () 1838 { 1839 return this; 1840 } 1841 1842 Thread * 1843 Process::CalculateThread () 1844 { 1845 return NULL; 1846 } 1847 1848 StackFrame * 1849 Process::CalculateStackFrame () 1850 { 1851 return NULL; 1852 } 1853 1854 void 1855 Process::CalculateExecutionContext (ExecutionContext &exe_ctx) 1856 { 1857 exe_ctx.target = &m_target; 1858 exe_ctx.process = this; 1859 exe_ctx.thread = NULL; 1860 exe_ctx.frame = NULL; 1861 } 1862 1863 lldb::ProcessSP 1864 Process::GetSP () 1865 { 1866 return GetTarget().GetProcessSP(); 1867 } 1868 1869 ClangPersistentVariables & 1870 Process::GetPersistentVariables() 1871 { 1872 return m_persistent_vars; 1873 } 1874 1875 uint32_t 1876 Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids) 1877 { 1878 return 0; 1879 } 1880 1881 ArchSpec 1882 Process::GetArchSpecForExistingProcess (lldb::pid_t pid) 1883 { 1884 return Host::GetArchSpecForExistingProcess (pid); 1885 } 1886 1887 ArchSpec 1888 Process::GetArchSpecForExistingProcess (const char *process_name) 1889 { 1890 return Host::GetArchSpecForExistingProcess (process_name); 1891 } 1892 1893 lldb::UserSettingsControllerSP 1894 Process::GetSettingsController (bool finish) 1895 { 1896 static UserSettingsControllerSP g_settings_controller (new SettingsController); 1897 static bool initialized = false; 1898 1899 if (!initialized) 1900 { 1901 initialized = UserSettingsController::InitializeSettingsController (g_settings_controller, 1902 Process::SettingsController::global_settings_table, 1903 Process::SettingsController::instance_settings_table); 1904 } 1905 1906 if (finish) 1907 { 1908 UserSettingsController::FinalizeSettingsController (g_settings_controller); 1909 g_settings_controller.reset(); 1910 initialized = false; 1911 } 1912 1913 return g_settings_controller; 1914 } 1915 1916 void 1917 Process::UpdateInstanceName () 1918 { 1919 ModuleSP module_sp = GetTarget().GetExecutableModule(); 1920 if (module_sp) 1921 { 1922 StreamString sstr; 1923 sstr.Printf ("%s", module_sp->GetFileSpec().GetFilename().AsCString()); 1924 1925 Process::GetSettingsController()->RenameInstanceSettings (GetInstanceName().AsCString(), 1926 sstr.GetData()); 1927 } 1928 } 1929 1930 //-------------------------------------------------------------- 1931 // class Process::SettingsController 1932 //-------------------------------------------------------------- 1933 1934 Process::SettingsController::SettingsController () : 1935 UserSettingsController ("process", Target::GetSettingsController()) 1936 { 1937 m_default_settings.reset (new ProcessInstanceSettings (*this, false, 1938 InstanceSettings::GetDefaultName().AsCString())); 1939 } 1940 1941 Process::SettingsController::~SettingsController () 1942 { 1943 } 1944 1945 lldb::InstanceSettingsSP 1946 Process::SettingsController::CreateInstanceSettings (const char *instance_name) 1947 { 1948 ProcessInstanceSettings *new_settings = new ProcessInstanceSettings (*(Process::GetSettingsController().get()), 1949 false, instance_name); 1950 lldb::InstanceSettingsSP new_settings_sp (new_settings); 1951 return new_settings_sp; 1952 } 1953 1954 //-------------------------------------------------------------- 1955 // class ProcessInstanceSettings 1956 //-------------------------------------------------------------- 1957 1958 ProcessInstanceSettings::ProcessInstanceSettings (UserSettingsController &owner, bool live_instance, 1959 const char *name) : 1960 InstanceSettings (owner, (name == NULL ? InstanceSettings::InvalidName().AsCString() : name), live_instance), 1961 m_run_args (), 1962 m_env_vars (), 1963 m_input_path (), 1964 m_output_path (), 1965 m_error_path (), 1966 m_plugin (), 1967 m_disable_aslr (true) 1968 { 1969 // CopyInstanceSettings is a pure virtual function in InstanceSettings; it therefore cannot be called 1970 // until the vtables for ProcessInstanceSettings are properly set up, i.e. AFTER all the initializers. 1971 // For this reason it has to be called here, rather than in the initializer or in the parent constructor. 1972 // This is true for CreateInstanceName() too. 1973 1974 if (GetInstanceName () == InstanceSettings::InvalidName()) 1975 { 1976 ChangeInstanceName (std::string (CreateInstanceName().AsCString())); 1977 m_owner.RegisterInstanceSettings (this); 1978 } 1979 1980 if (live_instance) 1981 { 1982 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); 1983 CopyInstanceSettings (pending_settings,false); 1984 //m_owner.RemovePendingSettings (m_instance_name); 1985 } 1986 } 1987 1988 ProcessInstanceSettings::ProcessInstanceSettings (const ProcessInstanceSettings &rhs) : 1989 InstanceSettings (*(Process::GetSettingsController().get()), CreateInstanceName().AsCString()), 1990 m_run_args (rhs.m_run_args), 1991 m_env_vars (rhs.m_env_vars), 1992 m_input_path (rhs.m_input_path), 1993 m_output_path (rhs.m_output_path), 1994 m_error_path (rhs.m_error_path), 1995 m_plugin (rhs.m_plugin), 1996 m_disable_aslr (rhs.m_disable_aslr) 1997 { 1998 if (m_instance_name != InstanceSettings::GetDefaultName()) 1999 { 2000 const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); 2001 CopyInstanceSettings (pending_settings,false); 2002 m_owner.RemovePendingSettings (m_instance_name); 2003 } 2004 } 2005 2006 ProcessInstanceSettings::~ProcessInstanceSettings () 2007 { 2008 } 2009 2010 ProcessInstanceSettings& 2011 ProcessInstanceSettings::operator= (const ProcessInstanceSettings &rhs) 2012 { 2013 if (this != &rhs) 2014 { 2015 m_run_args = rhs.m_run_args; 2016 m_env_vars = rhs.m_env_vars; 2017 m_input_path = rhs.m_input_path; 2018 m_output_path = rhs.m_output_path; 2019 m_error_path = rhs.m_error_path; 2020 m_plugin = rhs.m_plugin; 2021 m_disable_aslr = rhs.m_disable_aslr; 2022 } 2023 2024 return *this; 2025 } 2026 2027 2028 void 2029 ProcessInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var_name, 2030 const char *index_value, 2031 const char *value, 2032 const ConstString &instance_name, 2033 const SettingEntry &entry, 2034 lldb::VarSetOperationType op, 2035 Error &err, 2036 bool pending) 2037 { 2038 if (var_name == RunArgsVarName()) 2039 UserSettingsController::UpdateStringArrayVariable (op, index_value, m_run_args, value, err); 2040 else if (var_name == EnvVarsVarName()) 2041 UserSettingsController::UpdateDictionaryVariable (op, index_value, m_env_vars, value, err); 2042 else if (var_name == InputPathVarName()) 2043 UserSettingsController::UpdateStringVariable (op, m_input_path, value, err); 2044 else if (var_name == OutputPathVarName()) 2045 UserSettingsController::UpdateStringVariable (op, m_output_path, value, err); 2046 else if (var_name == ErrorPathVarName()) 2047 UserSettingsController::UpdateStringVariable (op, m_error_path, value, err); 2048 else if (var_name == PluginVarName()) 2049 UserSettingsController::UpdateEnumVariable (entry.enum_values, (int *) &m_plugin, value, err); 2050 else if (var_name == DisableASLRVarName()) 2051 UserSettingsController::UpdateBooleanVariable (op, m_disable_aslr, value, err); 2052 } 2053 2054 void 2055 ProcessInstanceSettings::CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings, 2056 bool pending) 2057 { 2058 if (new_settings.get() == NULL) 2059 return; 2060 2061 ProcessInstanceSettings *new_process_settings = (ProcessInstanceSettings *) new_settings.get(); 2062 2063 m_run_args = new_process_settings->m_run_args; 2064 m_env_vars = new_process_settings->m_env_vars; 2065 m_input_path = new_process_settings->m_input_path; 2066 m_output_path = new_process_settings->m_output_path; 2067 m_error_path = new_process_settings->m_error_path; 2068 m_plugin = new_process_settings->m_plugin; 2069 m_disable_aslr = new_process_settings->m_disable_aslr; 2070 } 2071 2072 bool 2073 ProcessInstanceSettings::GetInstanceSettingsValue (const SettingEntry &entry, 2074 const ConstString &var_name, 2075 StringList &value, 2076 Error *err) 2077 { 2078 if (var_name == RunArgsVarName()) 2079 { 2080 if (m_run_args.GetArgumentCount() > 0) 2081 { 2082 for (int i = 0; i < m_run_args.GetArgumentCount(); ++i) 2083 value.AppendString (m_run_args.GetArgumentAtIndex (i)); 2084 } 2085 } 2086 else if (var_name == EnvVarsVarName()) 2087 { 2088 if (m_env_vars.size() > 0) 2089 { 2090 std::map<std::string, std::string>::iterator pos; 2091 for (pos = m_env_vars.begin(); pos != m_env_vars.end(); ++pos) 2092 { 2093 StreamString value_str; 2094 value_str.Printf ("%s=%s", pos->first.c_str(), pos->second.c_str()); 2095 value.AppendString (value_str.GetData()); 2096 } 2097 } 2098 } 2099 else if (var_name == InputPathVarName()) 2100 { 2101 value.AppendString (m_input_path.c_str()); 2102 } 2103 else if (var_name == OutputPathVarName()) 2104 { 2105 value.AppendString (m_output_path.c_str()); 2106 } 2107 else if (var_name == ErrorPathVarName()) 2108 { 2109 value.AppendString (m_error_path.c_str()); 2110 } 2111 else if (var_name == PluginVarName()) 2112 { 2113 value.AppendString (UserSettingsController::EnumToString (entry.enum_values, (int) m_plugin)); 2114 } 2115 else if (var_name == DisableASLRVarName()) 2116 { 2117 if (m_disable_aslr) 2118 value.AppendString ("true"); 2119 else 2120 value.AppendString ("false"); 2121 } 2122 else 2123 { 2124 if (err) 2125 err->SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString()); 2126 return false; 2127 } 2128 return true; 2129 } 2130 2131 const ConstString 2132 ProcessInstanceSettings::CreateInstanceName () 2133 { 2134 static int instance_count = 1; 2135 StreamString sstr; 2136 2137 sstr.Printf ("process_%d", instance_count); 2138 ++instance_count; 2139 2140 const ConstString ret_val (sstr.GetData()); 2141 return ret_val; 2142 } 2143 2144 const ConstString & 2145 ProcessInstanceSettings::RunArgsVarName () 2146 { 2147 static ConstString run_args_var_name ("run-args"); 2148 2149 return run_args_var_name; 2150 } 2151 2152 const ConstString & 2153 ProcessInstanceSettings::EnvVarsVarName () 2154 { 2155 static ConstString env_vars_var_name ("env-vars"); 2156 2157 return env_vars_var_name; 2158 } 2159 2160 const ConstString & 2161 ProcessInstanceSettings::InputPathVarName () 2162 { 2163 static ConstString input_path_var_name ("input-path"); 2164 2165 return input_path_var_name; 2166 } 2167 2168 const ConstString & 2169 ProcessInstanceSettings::OutputPathVarName () 2170 { 2171 static ConstString output_path_var_name ("output-path"); 2172 2173 return output_path_var_name; 2174 } 2175 2176 const ConstString & 2177 ProcessInstanceSettings::ErrorPathVarName () 2178 { 2179 static ConstString error_path_var_name ("error-path"); 2180 2181 return error_path_var_name; 2182 } 2183 2184 const ConstString & 2185 ProcessInstanceSettings::PluginVarName () 2186 { 2187 static ConstString plugin_var_name ("plugin"); 2188 2189 return plugin_var_name; 2190 } 2191 2192 2193 const ConstString & 2194 ProcessInstanceSettings::DisableASLRVarName () 2195 { 2196 static ConstString disable_aslr_var_name ("disable-aslr"); 2197 2198 return disable_aslr_var_name; 2199 } 2200 2201 2202 //-------------------------------------------------- 2203 // SettingsController Variable Tables 2204 //-------------------------------------------------- 2205 2206 SettingEntry 2207 Process::SettingsController::global_settings_table[] = 2208 { 2209 //{ "var-name", var-type , "default", enum-table, init'd, hidden, "help-text"}, 2210 { NULL, eSetVarTypeNone, NULL, NULL, 0, 0, NULL } 2211 }; 2212 2213 2214 lldb::OptionEnumValueElement 2215 Process::SettingsController::g_plugins[] = 2216 { 2217 { eMacosx, "process.macosx", "Use the native MacOSX debugger plugin" }, 2218 { eRemoteDebugger, "process.gdb-remote" , "Use the GDB Remote protocol based debugger plugin" }, 2219 { 0, NULL, NULL } 2220 }; 2221 2222 SettingEntry 2223 Process::SettingsController::instance_settings_table[] = 2224 { 2225 //{ "var-name", var-type, "default", enum-table, init'd, hidden, "help-text"}, 2226 { "run-args", eSetVarTypeArray, NULL, NULL, false, false, "A list containing all the arguments to be passed to the executable when it is run." }, 2227 { "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." }, 2228 { "input-path", eSetVarTypeString, "/dev/stdin", NULL, false, false, "The file/path to be used by the executable program for reading its input." }, 2229 { "output-path", eSetVarTypeString, "/dev/stdout", NULL, false, false, "The file/path to be used by the executable program for writing its output." }, 2230 { "error-path", eSetVarTypeString, "/dev/stderr", NULL, false, false, "The file/path to be used by the executable program for writings its error messages." }, 2231 { "plugin", eSetVarTypeEnum, NULL , g_plugins, false, false, "The plugin to be used to run the process." }, 2232 { "disable-aslr", eSetVarTypeBool, "true", NULL, false, false, "Disable Address Space Layout Randomization (ASLR)" }, 2233 { NULL, eSetVarTypeNone, NULL, NULL, 0, 0, NULL } 2234 }; 2235 2236 2237 2238