1 //===-- PlatformFreeBSD.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/lldb-python.h" 11 12 #include "PlatformFreeBSD.h" 13 14 // C Includes 15 #include <stdio.h> 16 #include <sys/utsname.h> 17 18 // C++ Includes 19 // Other libraries and framework includes 20 // Project includes 21 #include "lldb/Core/Error.h" 22 #include "lldb/Core/Debugger.h" 23 #include "lldb/Core/Module.h" 24 #include "lldb/Core/ModuleSpec.h" 25 #include "lldb/Core/PluginManager.h" 26 #include "lldb/Host/Host.h" 27 28 using namespace lldb; 29 using namespace lldb_private; 30 31 Platform * 32 PlatformFreeBSD::CreateInstance (bool force, const lldb_private::ArchSpec *arch) 33 { 34 // The only time we create an instance is when we are creating a remote 35 // freebsd platform 36 const bool is_host = false; 37 38 bool create = force; 39 if (create == false && arch && arch->IsValid()) 40 { 41 const llvm::Triple &triple = arch->GetTriple(); 42 switch (triple.getVendor()) 43 { 44 case llvm::Triple::PC: 45 create = true; 46 break; 47 48 #if defined(__FreeBSD__) || defined(__OpenBSD__) 49 // Only accept "unknown" for the vendor if the host is BSD and 50 // it "unknown" wasn't specified (it was just returned becasue it 51 // was NOT specified) 52 case llvm::Triple::UnknownArch: 53 create = !arch->TripleVendorWasSpecified(); 54 break; 55 #endif 56 default: 57 break; 58 } 59 60 if (create) 61 { 62 switch (triple.getOS()) 63 { 64 case llvm::Triple::FreeBSD: 65 case llvm::Triple::KFreeBSD: 66 break; 67 68 #if defined(__FreeBSD__) || defined(__OpenBSD__) 69 // Only accept "unknown" for the OS if the host is BSD and 70 // it "unknown" wasn't specified (it was just returned becasue it 71 // was NOT specified) 72 case llvm::Triple::UnknownOS: 73 create = arch->TripleOSWasSpecified(); 74 break; 75 #endif 76 default: 77 create = false; 78 break; 79 } 80 } 81 } 82 if (create) 83 return new PlatformFreeBSD (is_host); 84 return NULL; 85 86 } 87 88 lldb_private::ConstString 89 PlatformFreeBSD::GetPluginNameStatic (bool is_host) 90 { 91 if (is_host) 92 { 93 static ConstString g_host_name(Platform::GetHostPlatformName ()); 94 return g_host_name; 95 } 96 else 97 { 98 static ConstString g_remote_name("remote-freebsd"); 99 return g_remote_name; 100 } 101 } 102 103 const char * 104 PlatformFreeBSD::GetDescriptionStatic (bool is_host) 105 { 106 if (is_host) 107 return "Local FreeBSD user platform plug-in."; 108 else 109 return "Remote FreeBSD user platform plug-in."; 110 } 111 112 static uint32_t g_initialize_count = 0; 113 114 void 115 PlatformFreeBSD::Initialize () 116 { 117 if (g_initialize_count++ == 0) 118 { 119 #if defined (__FreeBSD__) 120 // Force a host flag to true for the default platform object. 121 PlatformSP default_platform_sp (new PlatformFreeBSD(true)); 122 default_platform_sp->SetSystemArchitecture (Host::GetArchitecture()); 123 Platform::SetDefaultPlatform (default_platform_sp); 124 #endif 125 PluginManager::RegisterPlugin(PlatformFreeBSD::GetPluginNameStatic(false), 126 PlatformFreeBSD::GetDescriptionStatic(false), 127 PlatformFreeBSD::CreateInstance); 128 } 129 } 130 131 void 132 PlatformFreeBSD::Terminate () 133 { 134 if (g_initialize_count > 0 && --g_initialize_count == 0) 135 PluginManager::UnregisterPlugin (PlatformFreeBSD::CreateInstance); 136 } 137 138 //------------------------------------------------------------------ 139 /// Default Constructor 140 //------------------------------------------------------------------ 141 PlatformFreeBSD::PlatformFreeBSD (bool is_host) : 142 Platform(is_host) 143 { 144 } 145 146 //------------------------------------------------------------------ 147 /// Destructor. 148 /// 149 /// The destructor is virtual since this class is designed to be 150 /// inherited from by the plug-in instance. 151 //------------------------------------------------------------------ 152 PlatformFreeBSD::~PlatformFreeBSD() 153 { 154 } 155 156 157 Error 158 PlatformFreeBSD::ResolveExecutable (const FileSpec &exe_file, 159 const ArchSpec &exe_arch, 160 lldb::ModuleSP &exe_module_sp, 161 const FileSpecList *module_search_paths_ptr) 162 { 163 Error error; 164 // Nothing special to do here, just use the actual file and architecture 165 166 char exe_path[PATH_MAX]; 167 FileSpec resolved_exe_file (exe_file); 168 169 if (IsHost()) 170 { 171 // If we have "ls" as the exe_file, resolve the executable location based on 172 // the current path variables 173 if (!resolved_exe_file.Exists()) 174 { 175 exe_file.GetPath(exe_path, sizeof(exe_path)); 176 resolved_exe_file.SetFile(exe_path, true); 177 } 178 179 if (!resolved_exe_file.Exists()) 180 resolved_exe_file.ResolveExecutableLocation (); 181 182 if (resolved_exe_file.Exists()) 183 error.Clear(); 184 else 185 { 186 exe_file.GetPath(exe_path, sizeof(exe_path)); 187 error.SetErrorStringWithFormat("unable to find executable for '%s'", exe_path); 188 } 189 } 190 else 191 { 192 if (m_remote_platform_sp) 193 { 194 error = m_remote_platform_sp->ResolveExecutable (exe_file, 195 exe_arch, 196 exe_module_sp, 197 module_search_paths_ptr); 198 } 199 else 200 { 201 // We may connect to a process and use the provided executable (Don't use local $PATH). 202 203 // Resolve any executable within a bundle on MacOSX 204 Host::ResolveExecutableInBundle (resolved_exe_file); 205 206 if (resolved_exe_file.Exists()) { 207 error.Clear(); 208 } 209 else 210 { 211 exe_file.GetPath(exe_path, sizeof(exe_path)); 212 error.SetErrorStringWithFormat("the platform is not currently connected, and '%s' doesn't exist in the system root.", exe_path); 213 } 214 } 215 } 216 217 218 if (error.Success()) 219 { 220 ModuleSpec module_spec (resolved_exe_file, exe_arch); 221 if (module_spec.GetArchitecture().IsValid()) 222 { 223 error = ModuleList::GetSharedModule (module_spec, 224 exe_module_sp, 225 module_search_paths_ptr, 226 NULL, 227 NULL); 228 229 if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL) 230 { 231 exe_module_sp.reset(); 232 error.SetErrorStringWithFormat ("'%s' doesn't contain the architecture %s", 233 exe_file.GetPath().c_str(), 234 exe_arch.GetArchitectureName()); 235 } 236 } 237 else 238 { 239 // No valid architecture was specified, ask the platform for 240 // the architectures that we should be using (in the correct order) 241 // and see if we can find a match that way 242 StreamString arch_names; 243 ArchSpec platform_arch; 244 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, platform_arch); ++idx) 245 { 246 error = ModuleList::GetSharedModule (module_spec, 247 exe_module_sp, 248 module_search_paths_ptr, 249 NULL, 250 NULL); 251 // Did we find an executable using one of the 252 if (error.Success()) 253 { 254 if (exe_module_sp && exe_module_sp->GetObjectFile()) 255 break; 256 else 257 error.SetErrorToGenericError(); 258 } 259 260 if (idx > 0) 261 arch_names.PutCString (", "); 262 arch_names.PutCString (platform_arch.GetArchitectureName()); 263 } 264 265 if (error.Fail() || !exe_module_sp) 266 { 267 error.SetErrorStringWithFormat ("'%s' doesn't contain any '%s' platform architectures: %s", 268 exe_file.GetPath().c_str(), 269 GetPluginName().GetCString(), 270 arch_names.GetString().c_str()); 271 } 272 } 273 } 274 else 275 { 276 error.SetErrorStringWithFormat ("'%s' does not exist", 277 exe_file.GetPath().c_str()); 278 } 279 280 return error; 281 } 282 283 size_t 284 PlatformFreeBSD::GetSoftwareBreakpointTrapOpcode (Target &target, BreakpointSite *bp_site) 285 { 286 ArchSpec arch = target.GetArchitecture(); 287 const uint8_t *trap_opcode = NULL; 288 size_t trap_opcode_size = 0; 289 290 switch (arch.GetCore()) 291 { 292 default: 293 assert(false && "Unhandled architecture in PlatformFreeBSD::GetSoftwareBreakpointTrapOpcode()"); 294 break; 295 296 case ArchSpec::eCore_x86_32_i386: 297 case ArchSpec::eCore_x86_64_x86_64: 298 { 299 static const uint8_t g_i386_opcode[] = { 0xCC }; 300 trap_opcode = g_i386_opcode; 301 trap_opcode_size = sizeof(g_i386_opcode); 302 } 303 break; 304 } 305 306 if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size)) 307 return trap_opcode_size; 308 309 return 0; 310 } 311 312 bool 313 PlatformFreeBSD::GetRemoteOSVersion () 314 { 315 if (m_remote_platform_sp) 316 return m_remote_platform_sp->GetOSVersion (m_major_os_version, 317 m_minor_os_version, 318 m_update_os_version); 319 return false; 320 } 321 322 bool 323 PlatformFreeBSD::GetRemoteOSBuildString (std::string &s) 324 { 325 if (m_remote_platform_sp) 326 return m_remote_platform_sp->GetRemoteOSBuildString (s); 327 s.clear(); 328 return false; 329 } 330 331 bool 332 PlatformFreeBSD::GetRemoteOSKernelDescription (std::string &s) 333 { 334 if (m_remote_platform_sp) 335 return m_remote_platform_sp->GetRemoteOSKernelDescription (s); 336 s.clear(); 337 return false; 338 } 339 340 // Remote Platform subclasses need to override this function 341 ArchSpec 342 PlatformFreeBSD::GetRemoteSystemArchitecture () 343 { 344 if (m_remote_platform_sp) 345 return m_remote_platform_sp->GetRemoteSystemArchitecture (); 346 return ArchSpec(); 347 } 348 349 350 const char * 351 PlatformFreeBSD::GetHostname () 352 { 353 if (IsHost()) 354 return Platform::GetHostname(); 355 356 if (m_remote_platform_sp) 357 return m_remote_platform_sp->GetHostname (); 358 return NULL; 359 } 360 361 bool 362 PlatformFreeBSD::IsConnected () const 363 { 364 if (IsHost()) 365 return true; 366 else if (m_remote_platform_sp) 367 return m_remote_platform_sp->IsConnected(); 368 return false; 369 } 370 371 Error 372 PlatformFreeBSD::ConnectRemote (Args& args) 373 { 374 Error error; 375 if (IsHost()) 376 { 377 error.SetErrorStringWithFormat ("can't connect to the host platform '%s', always connected", GetPluginName().GetCString()); 378 } 379 else 380 { 381 if (!m_remote_platform_sp) 382 m_remote_platform_sp = Platform::Create ("remote-gdb-server", error); 383 384 if (m_remote_platform_sp) 385 { 386 if (error.Success()) 387 { 388 if (m_remote_platform_sp) 389 { 390 error = m_remote_platform_sp->ConnectRemote (args); 391 } 392 else 393 { 394 error.SetErrorString ("\"platform connect\" takes a single argument: <connect-url>"); 395 } 396 } 397 } 398 else 399 error.SetErrorString ("failed to create a 'remote-gdb-server' platform"); 400 401 if (error.Fail()) 402 m_remote_platform_sp.reset(); 403 } 404 405 return error; 406 } 407 408 Error 409 PlatformFreeBSD::DisconnectRemote () 410 { 411 Error error; 412 413 if (IsHost()) 414 { 415 error.SetErrorStringWithFormat ("can't disconnect from the host platform '%s', always connected", GetPluginName().GetCString()); 416 } 417 else 418 { 419 if (m_remote_platform_sp) 420 error = m_remote_platform_sp->DisconnectRemote (); 421 else 422 error.SetErrorString ("the platform is not currently connected"); 423 } 424 return error; 425 } 426 427 bool 428 PlatformFreeBSD::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info) 429 { 430 bool success = false; 431 if (IsHost()) 432 { 433 success = Platform::GetProcessInfo (pid, process_info); 434 } 435 else if (m_remote_platform_sp) 436 { 437 success = m_remote_platform_sp->GetProcessInfo (pid, process_info); 438 } 439 return success; 440 } 441 442 443 444 uint32_t 445 PlatformFreeBSD::FindProcesses (const ProcessInstanceInfoMatch &match_info, 446 ProcessInstanceInfoList &process_infos) 447 { 448 uint32_t match_count = 0; 449 if (IsHost()) 450 { 451 // Let the base class figure out the host details 452 match_count = Platform::FindProcesses (match_info, process_infos); 453 } 454 else 455 { 456 // If we are remote, we can only return results if we are connected 457 if (m_remote_platform_sp) 458 match_count = m_remote_platform_sp->FindProcesses (match_info, process_infos); 459 } 460 return match_count; 461 } 462 463 Error 464 PlatformFreeBSD::LaunchProcess (ProcessLaunchInfo &launch_info) 465 { 466 Error error; 467 if (IsHost()) 468 { 469 error = Platform::LaunchProcess (launch_info); 470 } 471 else 472 { 473 if (m_remote_platform_sp) 474 error = m_remote_platform_sp->LaunchProcess (launch_info); 475 else 476 error.SetErrorString ("the platform is not currently connected"); 477 } 478 return error; 479 } 480 481 lldb::ProcessSP 482 PlatformFreeBSD::Attach(ProcessAttachInfo &attach_info, 483 Debugger &debugger, 484 Target *target, 485 Listener &listener, 486 Error &error) 487 { 488 lldb::ProcessSP process_sp; 489 if (IsHost()) 490 { 491 if (target == NULL) 492 { 493 TargetSP new_target_sp; 494 ArchSpec emptyArchSpec; 495 496 error = debugger.GetTargetList().CreateTarget (debugger, 497 NULL, 498 emptyArchSpec, 499 false, 500 m_remote_platform_sp, 501 new_target_sp); 502 target = new_target_sp.get(); 503 } 504 else 505 error.Clear(); 506 507 if (target && error.Success()) 508 { 509 debugger.GetTargetList().SetSelectedTarget(target); 510 // The freebsd always currently uses the GDB remote debugger plug-in 511 // so even when debugging locally we are debugging remotely! 512 // Just like the darwin plugin. 513 process_sp = target->CreateProcess (listener, "gdb-remote", NULL); 514 515 if (process_sp) 516 error = process_sp->Attach (attach_info); 517 } 518 } 519 else 520 { 521 if (m_remote_platform_sp) 522 process_sp = m_remote_platform_sp->Attach (attach_info, debugger, target, listener, error); 523 else 524 error.SetErrorString ("the platform is not currently connected"); 525 } 526 return process_sp; 527 } 528 529 const char * 530 PlatformFreeBSD::GetUserName (uint32_t uid) 531 { 532 // Check the cache in Platform in case we have already looked this uid up 533 const char *user_name = Platform::GetUserName(uid); 534 if (user_name) 535 return user_name; 536 537 if (IsRemote() && m_remote_platform_sp) 538 return m_remote_platform_sp->GetUserName(uid); 539 return NULL; 540 } 541 542 const char * 543 PlatformFreeBSD::GetGroupName (uint32_t gid) 544 { 545 const char *group_name = Platform::GetGroupName(gid); 546 if (group_name) 547 return group_name; 548 549 if (IsRemote() && m_remote_platform_sp) 550 return m_remote_platform_sp->GetGroupName(gid); 551 return NULL; 552 } 553 554 555 // From PlatformMacOSX only 556 Error 557 PlatformFreeBSD::GetFile (const FileSpec &platform_file, 558 const UUID *uuid_ptr, 559 FileSpec &local_file) 560 { 561 if (IsRemote()) 562 { 563 if (m_remote_platform_sp) 564 return m_remote_platform_sp->GetFile (platform_file, uuid_ptr, local_file); 565 } 566 567 // Default to the local case 568 local_file = platform_file; 569 return Error(); 570 } 571 572 Error 573 PlatformFreeBSD::GetSharedModule (const ModuleSpec &module_spec, 574 ModuleSP &module_sp, 575 const FileSpecList *module_search_paths_ptr, 576 ModuleSP *old_module_sp_ptr, 577 bool *did_create_ptr) 578 { 579 Error error; 580 module_sp.reset(); 581 582 if (IsRemote()) 583 { 584 // If we have a remote platform always, let it try and locate 585 // the shared module first. 586 if (m_remote_platform_sp) 587 { 588 error = m_remote_platform_sp->GetSharedModule (module_spec, 589 module_sp, 590 module_search_paths_ptr, 591 old_module_sp_ptr, 592 did_create_ptr); 593 } 594 } 595 596 if (!module_sp) 597 { 598 // Fall back to the local platform and find the file locally 599 error = Platform::GetSharedModule (module_spec, 600 module_sp, 601 module_search_paths_ptr, 602 old_module_sp_ptr, 603 did_create_ptr); 604 } 605 if (module_sp) 606 module_sp->SetPlatformFileSpec(module_spec.GetFileSpec()); 607 return error; 608 } 609 610 611 bool 612 PlatformFreeBSD::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch) 613 { 614 // From macosx;s plugin code. For FreeBSD we may want to support more archs. 615 if (idx == 0) 616 { 617 arch = Host::GetArchitecture (Host::eSystemDefaultArchitecture); 618 return arch.IsValid(); 619 } 620 else if (idx == 1) 621 { 622 ArchSpec platform_arch (Host::GetArchitecture (Host::eSystemDefaultArchitecture)); 623 ArchSpec platform_arch64 (Host::GetArchitecture (Host::eSystemDefaultArchitecture64)); 624 if (platform_arch.IsExactMatch(platform_arch64)) 625 { 626 // This freebsd platform supports both 32 and 64 bit. Since we already 627 // returned the 64 bit arch for idx == 0, return the 32 bit arch 628 // for idx == 1 629 arch = Host::GetArchitecture (Host::eSystemDefaultArchitecture32); 630 return arch.IsValid(); 631 } 632 } 633 return false; 634 } 635 636 void 637 PlatformFreeBSD::GetStatus (Stream &strm) 638 { 639 struct utsname un; 640 641 if (uname(&un)) { 642 strm << "FreeBSD"; 643 return; 644 } 645 646 strm << "Host: " << un.sysname << ' ' << un.release << ' ' << un.version << '\n'; 647 Platform::GetStatus(strm); 648 } 649
