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