1 //===-- Platform.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/Platform.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "lldb/Breakpoint/BreakpointIDList.h" 17 #include "lldb/Core/Error.h" 18 #include "lldb/Core/Log.h" 19 #include "lldb/Core/ModuleSpec.h" 20 #include "lldb/Core/PluginManager.h" 21 #include "lldb/Host/FileSpec.h" 22 #include "lldb/Host/Host.h" 23 #include "lldb/Target/Process.h" 24 #include "lldb/Target/Target.h" 25 26 using namespace lldb; 27 using namespace lldb_private; 28 29 // Use a singleton function for g_local_platform_sp to avoid init 30 // constructors since LLDB is often part of a shared library 31 static PlatformSP& 32 GetDefaultPlatformSP () 33 { 34 static PlatformSP g_default_platform_sp; 35 return g_default_platform_sp; 36 } 37 38 static Mutex & 39 GetConnectedPlatformListMutex () 40 { 41 static Mutex g_remote_connected_platforms_mutex (Mutex::eMutexTypeRecursive); 42 return g_remote_connected_platforms_mutex; 43 } 44 static std::vector<PlatformSP> & 45 GetConnectedPlatformList () 46 { 47 static std::vector<PlatformSP> g_remote_connected_platforms; 48 return g_remote_connected_platforms; 49 } 50 51 52 const char * 53 Platform::GetHostPlatformName () 54 { 55 return "host"; 56 } 57 58 //------------------------------------------------------------------ 59 /// Get the native host platform plug-in. 60 /// 61 /// There should only be one of these for each host that LLDB runs 62 /// upon that should be statically compiled in and registered using 63 /// preprocessor macros or other similar build mechanisms. 64 /// 65 /// This platform will be used as the default platform when launching 66 /// or attaching to processes unless another platform is specified. 67 //------------------------------------------------------------------ 68 PlatformSP 69 Platform::GetDefaultPlatform () 70 { 71 return GetDefaultPlatformSP (); 72 } 73 74 void 75 Platform::SetDefaultPlatform (const lldb::PlatformSP &platform_sp) 76 { 77 // The native platform should use its static void Platform::Initialize() 78 // function to register itself as the native platform. 79 GetDefaultPlatformSP () = platform_sp; 80 } 81 82 Error 83 Platform::GetFile (const FileSpec &platform_file, 84 const UUID *uuid_ptr, 85 FileSpec &local_file) 86 { 87 // Default to the local case 88 local_file = platform_file; 89 return Error(); 90 } 91 92 FileSpecList 93 Platform::LocateExecutableScriptingResources (Target *target, Module &module) 94 { 95 return FileSpecList(); 96 } 97 98 Platform* 99 Platform::FindPlugin (Process *process, const ConstString &plugin_name) 100 { 101 PlatformCreateInstance create_callback = NULL; 102 if (plugin_name) 103 { 104 create_callback = PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name); 105 if (create_callback) 106 { 107 ArchSpec arch; 108 if (process) 109 { 110 arch = process->GetTarget().GetArchitecture(); 111 } 112 std::unique_ptr<Platform> instance_ap(create_callback(process, &arch)); 113 if (instance_ap.get()) 114 return instance_ap.release(); 115 } 116 } 117 else 118 { 119 for (uint32_t idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != NULL; ++idx) 120 { 121 std::unique_ptr<Platform> instance_ap(create_callback(process, nullptr)); 122 if (instance_ap.get()) 123 return instance_ap.release(); 124 } 125 } 126 return NULL; 127 } 128 129 Error 130 Platform::GetSharedModule (const ModuleSpec &module_spec, 131 ModuleSP &module_sp, 132 const FileSpecList *module_search_paths_ptr, 133 ModuleSP *old_module_sp_ptr, 134 bool *did_create_ptr) 135 { 136 // Don't do any path remapping for the default implementation 137 // of the platform GetSharedModule function, just call through 138 // to our static ModuleList function. Platform subclasses that 139 // implement remote debugging, might have a developer kits 140 // installed that have cached versions of the files for the 141 // remote target, or might implement a download and cache 142 // locally implementation. 143 const bool always_create = false; 144 return ModuleList::GetSharedModule (module_spec, 145 module_sp, 146 module_search_paths_ptr, 147 old_module_sp_ptr, 148 did_create_ptr, 149 always_create); 150 } 151 152 PlatformSP 153 Platform::Create (const char *platform_name, Error &error) 154 { 155 PlatformCreateInstance create_callback = NULL; 156 lldb::PlatformSP platform_sp; 157 if (platform_name && platform_name[0]) 158 { 159 ConstString const_platform_name (platform_name); 160 create_callback = PluginManager::GetPlatformCreateCallbackForPluginName (const_platform_name); 161 if (create_callback) 162 platform_sp.reset(create_callback(true, NULL)); 163 else 164 error.SetErrorStringWithFormat ("unable to find a plug-in for the platform named \"%s\"", platform_name); 165 } 166 else 167 error.SetErrorString ("invalid platform name"); 168 return platform_sp; 169 } 170 171 172 PlatformSP 173 Platform::Create (const ArchSpec &arch, ArchSpec *platform_arch_ptr, Error &error) 174 { 175 lldb::PlatformSP platform_sp; 176 if (arch.IsValid()) 177 { 178 uint32_t idx; 179 PlatformCreateInstance create_callback; 180 // First try exact arch matches across all platform plug-ins 181 bool exact = true; 182 for (idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex (idx)); ++idx) 183 { 184 if (create_callback) 185 { 186 platform_sp.reset(create_callback(false, &arch)); 187 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, exact, platform_arch_ptr)) 188 return platform_sp; 189 } 190 } 191 // Next try compatible arch matches across all platform plug-ins 192 exact = false; 193 for (idx = 0; (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex (idx)); ++idx) 194 { 195 if (create_callback) 196 { 197 platform_sp.reset(create_callback(false, &arch)); 198 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, exact, platform_arch_ptr)) 199 return platform_sp; 200 } 201 } 202 } 203 else 204 error.SetErrorString ("invalid platform name"); 205 if (platform_arch_ptr) 206 platform_arch_ptr->Clear(); 207 platform_sp.reset(); 208 return platform_sp; 209 } 210 211 uint32_t 212 Platform::GetNumConnectedRemotePlatforms () 213 { 214 Mutex::Locker locker (GetConnectedPlatformListMutex ()); 215 return GetConnectedPlatformList().size(); 216 } 217 218 PlatformSP 219 Platform::GetConnectedRemotePlatformAtIndex (uint32_t idx) 220 { 221 PlatformSP platform_sp; 222 { 223 Mutex::Locker locker (GetConnectedPlatformListMutex ()); 224 if (idx < GetConnectedPlatformList().size()) 225 platform_sp = GetConnectedPlatformList ()[idx]; 226 } 227 return platform_sp; 228 } 229 230 //------------------------------------------------------------------ 231 /// Default Constructor 232 //------------------------------------------------------------------ 233 Platform::Platform (bool is_host) : 234 m_is_host (is_host), 235 m_os_version_set_while_connected (false), 236 m_system_arch_set_while_connected (false), 237 m_sdk_sysroot (), 238 m_sdk_build (), 239 m_remote_url (), 240 m_name (), 241 m_major_os_version (UINT32_MAX), 242 m_minor_os_version (UINT32_MAX), 243 m_update_os_version (UINT32_MAX), 244 m_system_arch(), 245 m_uid_map_mutex (Mutex::eMutexTypeNormal), 246 m_gid_map_mutex (Mutex::eMutexTypeNormal), 247 m_uid_map(), 248 m_gid_map(), 249 m_max_uid_name_len (0), 250 m_max_gid_name_len (0) 251 { 252 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 253 if (log) 254 log->Printf ("%p Platform::Platform()", this); 255 } 256 257 //------------------------------------------------------------------ 258 /// Destructor. 259 /// 260 /// The destructor is virtual since this class is designed to be 261 /// inherited from by the plug-in instance. 262 //------------------------------------------------------------------ 263 Platform::~Platform() 264 { 265 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 266 if (log) 267 log->Printf ("%p Platform::~Platform()", this); 268 } 269 270 void 271 Platform::GetStatus (Stream &strm) 272 { 273 uint32_t major = UINT32_MAX; 274 uint32_t minor = UINT32_MAX; 275 uint32_t update = UINT32_MAX; 276 std::string s; 277 strm.Printf (" Platform: %s\n", GetPluginName().GetCString()); 278 279 ArchSpec arch (GetSystemArchitecture()); 280 if (arch.IsValid()) 281 { 282 if (!arch.GetTriple().str().empty()) 283 strm.Printf(" Triple: %s\n", arch.GetTriple().str().c_str()); 284 } 285 286 if (GetOSVersion(major, minor, update)) 287 { 288 strm.Printf("OS Version: %u", major); 289 if (minor != UINT32_MAX) 290 strm.Printf(".%u", minor); 291 if (update != UINT32_MAX) 292 strm.Printf(".%u", update); 293 294 if (GetOSBuildString (s)) 295 strm.Printf(" (%s)", s.c_str()); 296 297 strm.EOL(); 298 } 299 300 if (GetOSKernelDescription (s)) 301 strm.Printf(" Kernel: %s\n", s.c_str()); 302 303 if (IsHost()) 304 { 305 strm.Printf(" Hostname: %s\n", GetHostname()); 306 } 307 else 308 { 309 const bool is_connected = IsConnected(); 310 if (is_connected) 311 strm.Printf(" Hostname: %s\n", GetHostname()); 312 strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no"); 313 } 314 } 315 316 317 bool 318 Platform::GetOSVersion (uint32_t &major, 319 uint32_t &minor, 320 uint32_t &update) 321 { 322 bool success = m_major_os_version != UINT32_MAX; 323 if (IsHost()) 324 { 325 if (!success) 326 { 327 // We have a local host platform 328 success = Host::GetOSVersion (m_major_os_version, 329 m_minor_os_version, 330 m_update_os_version); 331 m_os_version_set_while_connected = success; 332 } 333 } 334 else 335 { 336 // We have a remote platform. We can only fetch the remote 337 // OS version if we are connected, and we don't want to do it 338 // more than once. 339 340 const bool is_connected = IsConnected(); 341 342 bool fetch = false; 343 if (success) 344 { 345 // We have valid OS version info, check to make sure it wasn't 346 // manually set prior to connecting. If it was manually set prior 347 // to connecting, then lets fetch the actual OS version info 348 // if we are now connected. 349 if (is_connected && !m_os_version_set_while_connected) 350 fetch = true; 351 } 352 else 353 { 354 // We don't have valid OS version info, fetch it if we are connected 355 fetch = is_connected; 356 } 357 358 if (fetch) 359 { 360 success = GetRemoteOSVersion (); 361 m_os_version_set_while_connected = success; 362 } 363 } 364 365 if (success) 366 { 367 major = m_major_os_version; 368 minor = m_minor_os_version; 369 update = m_update_os_version; 370 } 371 return success; 372 } 373 374 bool 375 Platform::GetOSBuildString (std::string &s) 376 { 377 if (IsHost()) 378 return Host::GetOSBuildString (s); 379 else 380 return GetRemoteOSBuildString (s); 381 } 382 383 bool 384 Platform::GetOSKernelDescription (std::string &s) 385 { 386 if (IsHost()) 387 return Host::GetOSKernelDescription (s); 388 else 389 return GetRemoteOSKernelDescription (s); 390 } 391 392 ConstString 393 Platform::GetName () 394 { 395 const char *name = GetHostname(); 396 if (name == NULL || name[0] == '\0') 397 return GetPluginName(); 398 return ConstString (name); 399 } 400 401 const char * 402 Platform::GetHostname () 403 { 404 if (IsHost()) 405 return "localhost"; 406 407 if (m_name.empty()) 408 return NULL; 409 return m_name.c_str(); 410 } 411 412 const char * 413 Platform::GetUserName (uint32_t uid) 414 { 415 const char *user_name = GetCachedUserName(uid); 416 if (user_name) 417 return user_name; 418 if (IsHost()) 419 { 420 std::string name; 421 if (Host::GetUserName(uid, name)) 422 return SetCachedUserName (uid, name.c_str(), name.size()); 423 } 424 return NULL; 425 } 426 427 const char * 428 Platform::GetGroupName (uint32_t gid) 429 { 430 const char *group_name = GetCachedGroupName(gid); 431 if (group_name) 432 return group_name; 433 if (IsHost()) 434 { 435 std::string name; 436 if (Host::GetGroupName(gid, name)) 437 return SetCachedGroupName (gid, name.c_str(), name.size()); 438 } 439 return NULL; 440 } 441 442 bool 443 Platform::SetOSVersion (uint32_t major, 444 uint32_t minor, 445 uint32_t update) 446 { 447 if (IsHost()) 448 { 449 // We don't need anyone setting the OS version for the host platform, 450 // we should be able to figure it out by calling Host::GetOSVersion(...). 451 return false; 452 } 453 else 454 { 455 // We have a remote platform, allow setting the target OS version if 456 // we aren't connected, since if we are connected, we should be able to 457 // request the remote OS version from the connected platform. 458 if (IsConnected()) 459 return false; 460 else 461 { 462 // We aren't connected and we might want to set the OS version 463 // ahead of time before we connect so we can peruse files and 464 // use a local SDK or PDK cache of support files to disassemble 465 // or do other things. 466 m_major_os_version = major; 467 m_minor_os_version = minor; 468 m_update_os_version = update; 469 return true; 470 } 471 } 472 return false; 473 } 474 475 476 Error 477 Platform::ResolveExecutable (const FileSpec &exe_file, 478 const ArchSpec &exe_arch, 479 lldb::ModuleSP &exe_module_sp, 480 const FileSpecList *module_search_paths_ptr) 481 { 482 Error error; 483 if (exe_file.Exists()) 484 { 485 ModuleSpec module_spec (exe_file, exe_arch); 486 if (module_spec.GetArchitecture().IsValid()) 487 { 488 error = ModuleList::GetSharedModule (module_spec, 489 exe_module_sp, 490 module_search_paths_ptr, 491 NULL, 492 NULL); 493 } 494 else 495 { 496 // No valid architecture was specified, ask the platform for 497 // the architectures that we should be using (in the correct order) 498 // and see if we can find a match that way 499 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, module_spec.GetArchitecture()); ++idx) 500 { 501 error = ModuleList::GetSharedModule (module_spec, 502 exe_module_sp, 503 module_search_paths_ptr, 504 NULL, 505 NULL); 506 // Did we find an executable using one of the 507 if (error.Success() && exe_module_sp) 508 break; 509 } 510 } 511 } 512 else 513 { 514 error.SetErrorStringWithFormat ("'%s' does not exist", 515 exe_file.GetPath().c_str()); 516 } 517 return error; 518 } 519 520 Error 521 Platform::ResolveSymbolFile (Target &target, 522 const ModuleSpec &sym_spec, 523 FileSpec &sym_file) 524 { 525 Error error; 526 if (sym_spec.GetSymbolFileSpec().Exists()) 527 sym_file = sym_spec.GetSymbolFileSpec(); 528 else 529 error.SetErrorString("unable to resolve symbol file"); 530 return error; 531 532 } 533 534 535 536 bool 537 Platform::ResolveRemotePath (const FileSpec &platform_path, 538 FileSpec &resolved_platform_path) 539 { 540 resolved_platform_path = platform_path; 541 return resolved_platform_path.ResolvePath(); 542 } 543 544 545 const ArchSpec & 546 Platform::GetSystemArchitecture() 547 { 548 if (IsHost()) 549 { 550 if (!m_system_arch.IsValid()) 551 { 552 // We have a local host platform 553 m_system_arch = Host::GetArchitecture(); 554 m_system_arch_set_while_connected = m_system_arch.IsValid(); 555 } 556 } 557 else 558 { 559 // We have a remote platform. We can only fetch the remote 560 // system architecture if we are connected, and we don't want to do it 561 // more than once. 562 563 const bool is_connected = IsConnected(); 564 565 bool fetch = false; 566 if (m_system_arch.IsValid()) 567 { 568 // We have valid OS version info, check to make sure it wasn't 569 // manually set prior to connecting. If it was manually set prior 570 // to connecting, then lets fetch the actual OS version info 571 // if we are now connected. 572 if (is_connected && !m_system_arch_set_while_connected) 573 fetch = true; 574 } 575 else 576 { 577 // We don't have valid OS version info, fetch it if we are connected 578 fetch = is_connected; 579 } 580 581 if (fetch) 582 { 583 m_system_arch = GetRemoteSystemArchitecture (); 584 m_system_arch_set_while_connected = m_system_arch.IsValid(); 585 } 586 } 587 return m_system_arch; 588 } 589 590 591 Error 592 Platform::ConnectRemote (Args& args) 593 { 594 Error error; 595 if (IsHost()) 596 error.SetErrorStringWithFormat ("The currently selected platform (%s) is the host platform and is always connected.", GetPluginName().GetCString()); 597 else 598 error.SetErrorStringWithFormat ("Platform::ConnectRemote() is not supported by %s", GetPluginName().GetCString()); 599 return error; 600 } 601 602 Error 603 Platform::DisconnectRemote () 604 { 605 Error error; 606 if (IsHost()) 607 error.SetErrorStringWithFormat ("The currently selected platform (%s) is the host platform and is always connected.", GetPluginName().GetCString()); 608 else 609 error.SetErrorStringWithFormat ("Platform::DisconnectRemote() is not supported by %s", GetPluginName().GetCString()); 610 return error; 611 } 612 613 bool 614 Platform::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info) 615 { 616 // Take care of the host case so that each subclass can just 617 // call this function to get the host functionality. 618 if (IsHost()) 619 return Host::GetProcessInfo (pid, process_info); 620 return false; 621 } 622 623 uint32_t 624 Platform::FindProcesses (const ProcessInstanceInfoMatch &match_info, 625 ProcessInstanceInfoList &process_infos) 626 { 627 // Take care of the host case so that each subclass can just 628 // call this function to get the host functionality. 629 uint32_t match_count = 0; 630 if (IsHost()) 631 match_count = Host::FindProcesses (match_info, process_infos); 632 return match_count; 633 } 634 635 636 Error 637 Platform::LaunchProcess (ProcessLaunchInfo &launch_info) 638 { 639 Error error; 640 // Take care of the host case so that each subclass can just 641 // call this function to get the host functionality. 642 if (IsHost()) 643 { 644 if (::getenv ("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY")) 645 launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY); 646 647 if (launch_info.GetFlags().Test (eLaunchFlagLaunchInShell)) 648 { 649 const bool is_localhost = true; 650 const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug); 651 const bool first_arg_is_full_shell_command = false; 652 if (!launch_info.ConvertArgumentsForLaunchingInShell (error, 653 is_localhost, 654 will_debug, 655 first_arg_is_full_shell_command)) 656 return error; 657 } 658 659 error = Host::LaunchProcess (launch_info); 660 } 661 else 662 error.SetErrorString ("base lldb_private::Platform class can't launch remote processes"); 663 return error; 664 } 665 666 lldb::ProcessSP 667 Platform::DebugProcess (ProcessLaunchInfo &launch_info, 668 Debugger &debugger, 669 Target *target, // Can be NULL, if NULL create a new target, else use existing one 670 Listener &listener, 671 Error &error) 672 { 673 ProcessSP process_sp; 674 // Make sure we stop at the entry point 675 launch_info.GetFlags ().Set (eLaunchFlagDebug); 676 // We always launch the process we are going to debug in a separate process 677 // group, since then we can handle ^C interrupts ourselves w/o having to worry 678 // about the target getting them as well. 679 launch_info.SetLaunchInSeparateProcessGroup(true); 680 681 error = LaunchProcess (launch_info); 682 if (error.Success()) 683 { 684 if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) 685 { 686 ProcessAttachInfo attach_info (launch_info); 687 process_sp = Attach (attach_info, debugger, target, listener, error); 688 if (process_sp) 689 { 690 // Since we attached to the process, it will think it needs to detach 691 // if the process object just goes away without an explicit call to 692 // Process::Kill() or Process::Detach(), so let it know to kill the 693 // process if this happens. 694 process_sp->SetShouldDetach (false); 695 696 // If we didn't have any file actions, the pseudo terminal might 697 // have been used where the slave side was given as the file to 698 // open for stdin/out/err after we have already opened the master 699 // so we can read/write stdin/out/err. 700 int pty_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor(); 701 if (pty_fd != lldb_utility::PseudoTerminal::invalid_fd) 702 { 703 process_sp->SetSTDIOFileDescriptor(pty_fd); 704 } 705 } 706 } 707 } 708 return process_sp; 709 } 710 711 712 lldb::PlatformSP 713 Platform::GetPlatformForArchitecture (const ArchSpec &arch, ArchSpec *platform_arch_ptr) 714 { 715 lldb::PlatformSP platform_sp; 716 Error error; 717 if (arch.IsValid()) 718 platform_sp = Platform::Create (arch, platform_arch_ptr, error); 719 return platform_sp; 720 } 721 722 723 //------------------------------------------------------------------ 724 /// Lets a platform answer if it is compatible with a given 725 /// architecture and the target triple contained within. 726 //------------------------------------------------------------------ 727 bool 728 Platform::IsCompatibleArchitecture (const ArchSpec &arch, bool exact_arch_match, ArchSpec *compatible_arch_ptr) 729 { 730 // If the architecture is invalid, we must answer true... 731 if (arch.IsValid()) 732 { 733 ArchSpec platform_arch; 734 // Try for an exact architecture match first. 735 if (exact_arch_match) 736 { 737 for (uint32_t arch_idx=0; GetSupportedArchitectureAtIndex (arch_idx, platform_arch); ++arch_idx) 738 { 739 if (arch.IsExactMatch(platform_arch)) 740 { 741 if (compatible_arch_ptr) 742 *compatible_arch_ptr = platform_arch; 743 return true; 744 } 745 } 746 } 747 else 748 { 749 for (uint32_t arch_idx=0; GetSupportedArchitectureAtIndex (arch_idx, platform_arch); ++arch_idx) 750 { 751 if (arch.IsCompatibleMatch(platform_arch)) 752 { 753 if (compatible_arch_ptr) 754 *compatible_arch_ptr = platform_arch; 755 return true; 756 } 757 } 758 } 759 } 760 if (compatible_arch_ptr) 761 compatible_arch_ptr->Clear(); 762 return false; 763 764 } 765 766 767 lldb::BreakpointSP 768 Platform::SetThreadCreationBreakpoint (lldb_private::Target &target) 769 { 770 return lldb::BreakpointSP(); 771 } 772 773 size_t 774 Platform::GetEnvironment (StringList &environment) 775 { 776 environment.Clear(); 777 return false; 778 } 779 780
