1 //===-- Host.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 // C includes 13 #include <errno.h> 14 #include <limits.h> 15 #include <stdlib.h> 16 #include <sys/types.h> 17 #ifdef _WIN32 18 #include "lldb/Host/windows/windows.h" 19 #include <winsock2.h> 20 #include <ws2tcpip.h> 21 #else 22 #include <unistd.h> 23 #include <dlfcn.h> 24 #include <grp.h> 25 #include <netdb.h> 26 #include <pwd.h> 27 #include <sys/stat.h> 28 #endif 29 30 #if !defined (__GNU__) && !defined (_WIN32) 31 // Does not exist under GNU/HURD or Windows 32 #include <sys/sysctl.h> 33 #endif 34 35 #if defined (__APPLE__) 36 #include <mach/mach_port.h> 37 #include <mach/mach_init.h> 38 #include <mach-o/dyld.h> 39 #include <AvailabilityMacros.h> 40 #endif 41 42 #if defined (__linux__) || defined (__FreeBSD__) || defined (__FreeBSD_kernel__) || defined (__APPLE__) 43 #include <spawn.h> 44 #include <sys/wait.h> 45 #include <sys/syscall.h> 46 #endif 47 48 #if defined (__FreeBSD__) 49 #include <pthread_np.h> 50 #endif 51 52 #include "lldb/Host/Host.h" 53 #include "lldb/Core/ArchSpec.h" 54 #include "lldb/Core/ConstString.h" 55 #include "lldb/Core/Debugger.h" 56 #include "lldb/Core/Error.h" 57 #include "lldb/Core/Log.h" 58 #include "lldb/Core/Module.h" 59 #include "lldb/Core/StreamString.h" 60 #include "lldb/Core/ThreadSafeSTLMap.h" 61 #include "lldb/Host/Config.h" 62 #include "lldb/Host/Endian.h" 63 #include "lldb/Host/FileSpec.h" 64 #include "lldb/Host/Mutex.h" 65 #include "lldb/Target/Process.h" 66 #include "lldb/Target/TargetList.h" 67 #include "lldb/Utility/CleanUp.h" 68 69 #include "llvm/ADT/SmallString.h" 70 #include "llvm/Support/Host.h" 71 #include "llvm/Support/raw_ostream.h" 72 73 #if defined (__APPLE__) 74 #ifndef _POSIX_SPAWN_DISABLE_ASLR 75 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100 76 #endif 77 78 extern "C" 79 { 80 int __pthread_chdir(const char *path); 81 int __pthread_fchdir (int fildes); 82 } 83 84 #endif 85 86 using namespace lldb; 87 using namespace lldb_private; 88 89 90 #if !defined (__APPLE__) && !defined (_WIN32) 91 struct MonitorInfo 92 { 93 lldb::pid_t pid; // The process ID to monitor 94 Host::MonitorChildProcessCallback callback; // The callback function to call when "pid" exits or signals 95 void *callback_baton; // The callback baton for the callback function 96 bool monitor_signals; // If true, call the callback when "pid" gets signaled. 97 }; 98 99 static thread_result_t 100 MonitorChildProcessThreadFunction (void *arg); 101 102 lldb::thread_t 103 Host::StartMonitoringChildProcess 104 ( 105 Host::MonitorChildProcessCallback callback, 106 void *callback_baton, 107 lldb::pid_t pid, 108 bool monitor_signals 109 ) 110 { 111 lldb::thread_t thread = LLDB_INVALID_HOST_THREAD; 112 MonitorInfo * info_ptr = new MonitorInfo(); 113 114 info_ptr->pid = pid; 115 info_ptr->callback = callback; 116 info_ptr->callback_baton = callback_baton; 117 info_ptr->monitor_signals = monitor_signals; 118 119 char thread_name[256]; 120 ::snprintf (thread_name, sizeof(thread_name), "<lldb.host.wait4(pid=%" PRIu64 ")>", pid); 121 thread = ThreadCreate (thread_name, 122 MonitorChildProcessThreadFunction, 123 info_ptr, 124 NULL); 125 126 return thread; 127 } 128 129 //------------------------------------------------------------------ 130 // Scoped class that will disable thread canceling when it is 131 // constructed, and exception safely restore the previous value it 132 // when it goes out of scope. 133 //------------------------------------------------------------------ 134 class ScopedPThreadCancelDisabler 135 { 136 public: 137 ScopedPThreadCancelDisabler() 138 { 139 // Disable the ability for this thread to be cancelled 140 int err = ::pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &m_old_state); 141 if (err != 0) 142 m_old_state = -1; 143 144 } 145 146 ~ScopedPThreadCancelDisabler() 147 { 148 // Restore the ability for this thread to be cancelled to what it 149 // previously was. 150 if (m_old_state != -1) 151 ::pthread_setcancelstate (m_old_state, 0); 152 } 153 private: 154 int m_old_state; // Save the old cancelability state. 155 }; 156 157 static thread_result_t 158 MonitorChildProcessThreadFunction (void *arg) 159 { 160 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 161 const char *function = __FUNCTION__; 162 if (log) 163 log->Printf ("%s (arg = %p) thread starting...", function, arg); 164 165 MonitorInfo *info = (MonitorInfo *)arg; 166 167 const Host::MonitorChildProcessCallback callback = info->callback; 168 void * const callback_baton = info->callback_baton; 169 const bool monitor_signals = info->monitor_signals; 170 171 assert (info->pid <= UINT32_MAX); 172 const ::pid_t pid = monitor_signals ? -1 * getpgid(info->pid) : info->pid; 173 174 delete info; 175 176 int status = -1; 177 #if defined (__FreeBSD__) || defined (__FreeBSD_kernel__) 178 #define __WALL 0 179 #endif 180 const int options = __WALL; 181 182 while (1) 183 { 184 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 185 if (log) 186 log->Printf("%s ::wait_pid (pid = %" PRIi32 ", &status, options = %i)...", function, pid, options); 187 188 // Wait for all child processes 189 ::pthread_testcancel (); 190 // Get signals from all children with same process group of pid 191 const ::pid_t wait_pid = ::waitpid (pid, &status, options); 192 ::pthread_testcancel (); 193 194 if (wait_pid == -1) 195 { 196 if (errno == EINTR) 197 continue; 198 else 199 { 200 if (log) 201 log->Printf ("%s (arg = %p) thread exiting because waitpid failed (%s)...", __FUNCTION__, arg, strerror(errno)); 202 break; 203 } 204 } 205 else if (wait_pid > 0) 206 { 207 bool exited = false; 208 int signal = 0; 209 int exit_status = 0; 210 const char *status_cstr = NULL; 211 if (WIFSTOPPED(status)) 212 { 213 signal = WSTOPSIG(status); 214 status_cstr = "STOPPED"; 215 } 216 else if (WIFEXITED(status)) 217 { 218 exit_status = WEXITSTATUS(status); 219 status_cstr = "EXITED"; 220 exited = true; 221 } 222 else if (WIFSIGNALED(status)) 223 { 224 signal = WTERMSIG(status); 225 status_cstr = "SIGNALED"; 226 if (wait_pid == abs(pid)) { 227 exited = true; 228 exit_status = -1; 229 } 230 } 231 else 232 { 233 status_cstr = "(\?\?\?)"; 234 } 235 236 // Scope for pthread_cancel_disabler 237 { 238 ScopedPThreadCancelDisabler pthread_cancel_disabler; 239 240 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 241 if (log) 242 log->Printf ("%s ::waitpid (pid = %" PRIi32 ", &status, options = %i) => pid = %" PRIi32 ", status = 0x%8.8x (%s), signal = %i, exit_state = %i", 243 function, 244 wait_pid, 245 options, 246 pid, 247 status, 248 status_cstr, 249 signal, 250 exit_status); 251 252 if (exited || (signal != 0 && monitor_signals)) 253 { 254 bool callback_return = false; 255 if (callback) 256 callback_return = callback (callback_baton, wait_pid, exited, signal, exit_status); 257 258 // If our process exited, then this thread should exit 259 if (exited && wait_pid == abs(pid)) 260 { 261 if (log) 262 log->Printf ("%s (arg = %p) thread exiting because pid received exit signal...", __FUNCTION__, arg); 263 break; 264 } 265 // If the callback returns true, it means this process should 266 // exit 267 if (callback_return) 268 { 269 if (log) 270 log->Printf ("%s (arg = %p) thread exiting because callback returned true...", __FUNCTION__, arg); 271 break; 272 } 273 } 274 } 275 } 276 } 277 278 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 279 if (log) 280 log->Printf ("%s (arg = %p) thread exiting...", __FUNCTION__, arg); 281 282 return NULL; 283 } 284 285 #endif // #if !defined (__APPLE__) && !defined (_WIN32) 286 287 #if !defined (__APPLE__) 288 289 void 290 Host::SystemLog (SystemLogType type, const char *format, va_list args) 291 { 292 vfprintf (stderr, format, args); 293 } 294 295 #endif 296 297 void 298 Host::SystemLog (SystemLogType type, const char *format, ...) 299 { 300 va_list args; 301 va_start (args, format); 302 SystemLog (type, format, args); 303 va_end (args); 304 } 305 306 const ArchSpec & 307 Host::GetArchitecture (SystemDefaultArchitecture arch_kind) 308 { 309 static bool g_supports_32 = false; 310 static bool g_supports_64 = false; 311 static ArchSpec g_host_arch_32; 312 static ArchSpec g_host_arch_64; 313 314 #if defined (__APPLE__) 315 316 // Apple is different in that it can support both 32 and 64 bit executables 317 // in the same operating system running concurrently. Here we detect the 318 // correct host architectures for both 32 and 64 bit including if 64 bit 319 // executables are supported on the system. 320 321 if (g_supports_32 == false && g_supports_64 == false) 322 { 323 // All apple systems support 32 bit execution. 324 g_supports_32 = true; 325 uint32_t cputype, cpusubtype; 326 uint32_t is_64_bit_capable = false; 327 size_t len = sizeof(cputype); 328 ArchSpec host_arch; 329 // These will tell us about the kernel architecture, which even on a 64 330 // bit machine can be 32 bit... 331 if (::sysctlbyname("hw.cputype", &cputype, &len, NULL, 0) == 0) 332 { 333 len = sizeof (cpusubtype); 334 if (::sysctlbyname("hw.cpusubtype", &cpusubtype, &len, NULL, 0) != 0) 335 cpusubtype = CPU_TYPE_ANY; 336 337 len = sizeof (is_64_bit_capable); 338 if (::sysctlbyname("hw.cpu64bit_capable", &is_64_bit_capable, &len, NULL, 0) == 0) 339 { 340 if (is_64_bit_capable) 341 g_supports_64 = true; 342 } 343 344 if (is_64_bit_capable) 345 { 346 #if defined (__i386__) || defined (__x86_64__) 347 if (cpusubtype == CPU_SUBTYPE_486) 348 cpusubtype = CPU_SUBTYPE_I386_ALL; 349 #endif 350 if (cputype & CPU_ARCH_ABI64) 351 { 352 // We have a 64 bit kernel on a 64 bit system 353 g_host_arch_32.SetArchitecture (eArchTypeMachO, ~(CPU_ARCH_MASK) & cputype, cpusubtype); 354 g_host_arch_64.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 355 } 356 else 357 { 358 // We have a 32 bit kernel on a 64 bit system 359 g_host_arch_32.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 360 cputype |= CPU_ARCH_ABI64; 361 g_host_arch_64.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 362 } 363 } 364 else 365 { 366 g_host_arch_32.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 367 g_host_arch_64.Clear(); 368 } 369 } 370 } 371 372 #else // #if defined (__APPLE__) 373 374 if (g_supports_32 == false && g_supports_64 == false) 375 { 376 llvm::Triple triple(llvm::sys::getDefaultTargetTriple()); 377 378 g_host_arch_32.Clear(); 379 g_host_arch_64.Clear(); 380 381 // If the OS is Linux, "unknown" in the vendor slot isn't what we want 382 // for the default triple. It's probably an artifact of config.guess. 383 if (triple.getOS() == llvm::Triple::Linux && triple.getVendor() == llvm::Triple::UnknownVendor) 384 triple.setVendorName (""); 385 386 const char* distribution_id = GetDistributionId ().AsCString(); 387 388 switch (triple.getArch()) 389 { 390 default: 391 g_host_arch_32.SetTriple(triple); 392 g_host_arch_32.SetDistributionId (distribution_id); 393 g_supports_32 = true; 394 break; 395 396 case llvm::Triple::x86_64: 397 g_host_arch_64.SetTriple(triple); 398 g_host_arch_64.SetDistributionId (distribution_id); 399 g_supports_64 = true; 400 g_host_arch_32.SetTriple(triple.get32BitArchVariant()); 401 g_host_arch_32.SetDistributionId (distribution_id); 402 g_supports_32 = true; 403 break; 404 405 case llvm::Triple::mips64: 406 case llvm::Triple::sparcv9: 407 case llvm::Triple::ppc64: 408 g_host_arch_64.SetTriple(triple); 409 g_host_arch_64.SetDistributionId (distribution_id); 410 g_supports_64 = true; 411 break; 412 } 413 414 g_supports_32 = g_host_arch_32.IsValid(); 415 g_supports_64 = g_host_arch_64.IsValid(); 416 } 417 418 #endif // #else for #if defined (__APPLE__) 419 420 if (arch_kind == eSystemDefaultArchitecture32) 421 return g_host_arch_32; 422 else if (arch_kind == eSystemDefaultArchitecture64) 423 return g_host_arch_64; 424 425 if (g_supports_64) 426 return g_host_arch_64; 427 428 return g_host_arch_32; 429 } 430 431 const ConstString & 432 Host::GetVendorString() 433 { 434 static ConstString g_vendor; 435 if (!g_vendor) 436 { 437 const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture); 438 const llvm::StringRef &str_ref = host_arch.GetTriple().getVendorName(); 439 g_vendor.SetCStringWithLength(str_ref.data(), str_ref.size()); 440 } 441 return g_vendor; 442 } 443 444 const ConstString & 445 Host::GetOSString() 446 { 447 static ConstString g_os_string; 448 if (!g_os_string) 449 { 450 const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture); 451 const llvm::StringRef &str_ref = host_arch.GetTriple().getOSName(); 452 g_os_string.SetCStringWithLength(str_ref.data(), str_ref.size()); 453 } 454 return g_os_string; 455 } 456 457 const ConstString & 458 Host::GetTargetTriple() 459 { 460 static ConstString g_host_triple; 461 if (!(g_host_triple)) 462 { 463 const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture); 464 g_host_triple.SetCString(host_arch.GetTriple().getTriple().c_str()); 465 } 466 return g_host_triple; 467 } 468 469 // See linux/Host.cpp for Linux-based implementations of this. 470 // Add your platform-specific implementation to the appropriate host file. 471 #if !defined(__linux__) 472 473 const ConstString & 474 Host::GetDistributionId () 475 { 476 static ConstString s_distribution_id; 477 return s_distribution_id; 478 } 479 480 #endif // #if !defined(__linux__) 481 482 lldb::pid_t 483 Host::GetCurrentProcessID() 484 { 485 return ::getpid(); 486 } 487 488 #ifndef _WIN32 489 490 lldb::tid_t 491 Host::GetCurrentThreadID() 492 { 493 #if defined (__APPLE__) 494 // Calling "mach_thread_self()" bumps the reference count on the thread 495 // port, so we need to deallocate it. mach_task_self() doesn't bump the ref 496 // count. 497 thread_port_t thread_self = mach_thread_self(); 498 mach_port_deallocate(mach_task_self(), thread_self); 499 return thread_self; 500 #elif defined(__FreeBSD__) 501 return lldb::tid_t(pthread_getthreadid_np()); 502 #elif defined(__linux__) 503 return lldb::tid_t(syscall(SYS_gettid)); 504 #else 505 return lldb::tid_t(pthread_self()); 506 #endif 507 } 508 509 lldb::thread_t 510 Host::GetCurrentThread () 511 { 512 return lldb::thread_t(pthread_self()); 513 } 514 515 const char * 516 Host::GetSignalAsCString (int signo) 517 { 518 switch (signo) 519 { 520 case SIGHUP: return "SIGHUP"; // 1 hangup 521 case SIGINT: return "SIGINT"; // 2 interrupt 522 case SIGQUIT: return "SIGQUIT"; // 3 quit 523 case SIGILL: return "SIGILL"; // 4 illegal instruction (not reset when caught) 524 case SIGTRAP: return "SIGTRAP"; // 5 trace trap (not reset when caught) 525 case SIGABRT: return "SIGABRT"; // 6 abort() 526 #if defined(SIGPOLL) 527 #if !defined(SIGIO) || (SIGPOLL != SIGIO) 528 // Under some GNU/Linux, SIGPOLL and SIGIO are the same. Causing the build to 529 // fail with 'multiple define cases with same value' 530 case SIGPOLL: return "SIGPOLL"; // 7 pollable event ([XSR] generated, not supported) 531 #endif 532 #endif 533 #if defined(SIGEMT) 534 case SIGEMT: return "SIGEMT"; // 7 EMT instruction 535 #endif 536 case SIGFPE: return "SIGFPE"; // 8 floating point exception 537 case SIGKILL: return "SIGKILL"; // 9 kill (cannot be caught or ignored) 538 case SIGBUS: return "SIGBUS"; // 10 bus error 539 case SIGSEGV: return "SIGSEGV"; // 11 segmentation violation 540 case SIGSYS: return "SIGSYS"; // 12 bad argument to system call 541 case SIGPIPE: return "SIGPIPE"; // 13 write on a pipe with no one to read it 542 case SIGALRM: return "SIGALRM"; // 14 alarm clock 543 case SIGTERM: return "SIGTERM"; // 15 software termination signal from kill 544 case SIGURG: return "SIGURG"; // 16 urgent condition on IO channel 545 case SIGSTOP: return "SIGSTOP"; // 17 sendable stop signal not from tty 546 case SIGTSTP: return "SIGTSTP"; // 18 stop signal from tty 547 case SIGCONT: return "SIGCONT"; // 19 continue a stopped process 548 case SIGCHLD: return "SIGCHLD"; // 20 to parent on child stop or exit 549 case SIGTTIN: return "SIGTTIN"; // 21 to readers pgrp upon background tty read 550 case SIGTTOU: return "SIGTTOU"; // 22 like TTIN for output if (tp->t_local<OSTOP) 551 #if defined(SIGIO) 552 case SIGIO: return "SIGIO"; // 23 input/output possible signal 553 #endif 554 case SIGXCPU: return "SIGXCPU"; // 24 exceeded CPU time limit 555 case SIGXFSZ: return "SIGXFSZ"; // 25 exceeded file size limit 556 case SIGVTALRM: return "SIGVTALRM"; // 26 virtual time alarm 557 case SIGPROF: return "SIGPROF"; // 27 profiling time alarm 558 #if defined(SIGWINCH) 559 case SIGWINCH: return "SIGWINCH"; // 28 window size changes 560 #endif 561 #if defined(SIGINFO) 562 case SIGINFO: return "SIGINFO"; // 29 information request 563 #endif 564 case SIGUSR1: return "SIGUSR1"; // 30 user defined signal 1 565 case SIGUSR2: return "SIGUSR2"; // 31 user defined signal 2 566 default: 567 break; 568 } 569 return NULL; 570 } 571 572 #endif 573 574 void 575 Host::WillTerminate () 576 { 577 } 578 579 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined (__linux__) // see macosx/Host.mm 580 581 void 582 Host::ThreadCreated (const char *thread_name) 583 { 584 } 585 586 void 587 Host::Backtrace (Stream &strm, uint32_t max_frames) 588 { 589 // TODO: Is there a way to backtrace the current process on other systems? 590 } 591 592 size_t 593 Host::GetEnvironment (StringList &env) 594 { 595 // TODO: Is there a way to the host environment for this process on other systems? 596 return 0; 597 } 598 599 #endif // #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined (__linux__) 600 601 struct HostThreadCreateInfo 602 { 603 std::string thread_name; 604 thread_func_t thread_fptr; 605 thread_arg_t thread_arg; 606 607 HostThreadCreateInfo (const char *name, thread_func_t fptr, thread_arg_t arg) : 608 thread_name (name ? name : ""), 609 thread_fptr (fptr), 610 thread_arg (arg) 611 { 612 } 613 }; 614 615 static thread_result_t 616 #ifdef _WIN32 617 __stdcall 618 #endif 619 ThreadCreateTrampoline (thread_arg_t arg) 620 { 621 HostThreadCreateInfo *info = (HostThreadCreateInfo *)arg; 622 Host::ThreadCreated (info->thread_name.c_str()); 623 thread_func_t thread_fptr = info->thread_fptr; 624 thread_arg_t thread_arg = info->thread_arg; 625 626 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 627 if (log) 628 log->Printf("thread created"); 629 630 delete info; 631 return thread_fptr (thread_arg); 632 } 633 634 lldb::thread_t 635 Host::ThreadCreate 636 ( 637 const char *thread_name, 638 thread_func_t thread_fptr, 639 thread_arg_t thread_arg, 640 Error *error 641 ) 642 { 643 lldb::thread_t thread = LLDB_INVALID_HOST_THREAD; 644 645 // Host::ThreadCreateTrampoline will delete this pointer for us. 646 HostThreadCreateInfo *info_ptr = new HostThreadCreateInfo (thread_name, thread_fptr, thread_arg); 647 648 #ifdef _WIN32 649 thread = ::_beginthreadex(0, 0, ThreadCreateTrampoline, info_ptr, 0, NULL); 650 int err = thread <= 0 ? GetLastError() : 0; 651 #else 652 int err = ::pthread_create (&thread, NULL, ThreadCreateTrampoline, info_ptr); 653 #endif 654 if (err == 0) 655 { 656 if (error) 657 error->Clear(); 658 return thread; 659 } 660 661 if (error) 662 error->SetError (err, eErrorTypePOSIX); 663 664 return LLDB_INVALID_HOST_THREAD; 665 } 666 667 #ifndef _WIN32 668 669 bool 670 Host::ThreadCancel (lldb::thread_t thread, Error *error) 671 { 672 int err = ::pthread_cancel (thread); 673 if (error) 674 error->SetError(err, eErrorTypePOSIX); 675 return err == 0; 676 } 677 678 bool 679 Host::ThreadDetach (lldb::thread_t thread, Error *error) 680 { 681 int err = ::pthread_detach (thread); 682 if (error) 683 error->SetError(err, eErrorTypePOSIX); 684 return err == 0; 685 } 686 687 bool 688 Host::ThreadJoin (lldb::thread_t thread, thread_result_t *thread_result_ptr, Error *error) 689 { 690 int err = ::pthread_join (thread, thread_result_ptr); 691 if (error) 692 error->SetError(err, eErrorTypePOSIX); 693 return err == 0; 694 } 695 696 lldb::thread_key_t 697 Host::ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback) 698 { 699 pthread_key_t key; 700 ::pthread_key_create (&key, callback); 701 return key; 702 } 703 704 void* 705 Host::ThreadLocalStorageGet(lldb::thread_key_t key) 706 { 707 return ::pthread_getspecific (key); 708 } 709 710 void 711 Host::ThreadLocalStorageSet(lldb::thread_key_t key, void *value) 712 { 713 ::pthread_setspecific (key, value); 714 } 715 716 bool 717 Host::SetThreadName (lldb::pid_t pid, lldb::tid_t tid, const char *name) 718 { 719 #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5 720 lldb::pid_t curr_pid = Host::GetCurrentProcessID(); 721 lldb::tid_t curr_tid = Host::GetCurrentThreadID(); 722 if (pid == LLDB_INVALID_PROCESS_ID) 723 pid = curr_pid; 724 725 if (tid == LLDB_INVALID_THREAD_ID) 726 tid = curr_tid; 727 728 // Set the pthread name if possible 729 if (pid == curr_pid && tid == curr_tid) 730 { 731 if (::pthread_setname_np (name) == 0) 732 return true; 733 } 734 return false; 735 #elif defined (__FreeBSD__) 736 lldb::pid_t curr_pid = Host::GetCurrentProcessID(); 737 lldb::tid_t curr_tid = Host::GetCurrentThreadID(); 738 if (pid == LLDB_INVALID_PROCESS_ID) 739 pid = curr_pid; 740 741 if (tid == LLDB_INVALID_THREAD_ID) 742 tid = curr_tid; 743 744 // Set the pthread name if possible 745 if (pid == curr_pid && tid == curr_tid) 746 { 747 ::pthread_set_name_np (::pthread_self(), name); 748 return true; 749 } 750 return false; 751 #elif defined (__linux__) || defined (__GLIBC__) 752 void *fn = dlsym (RTLD_DEFAULT, "pthread_setname_np"); 753 if (fn) 754 { 755 lldb::pid_t curr_pid = Host::GetCurrentProcessID(); 756 lldb::tid_t curr_tid = Host::GetCurrentThreadID(); 757 if (pid == LLDB_INVALID_PROCESS_ID) 758 pid = curr_pid; 759 760 if (tid == LLDB_INVALID_THREAD_ID) 761 tid = curr_tid; 762 763 if (pid == curr_pid && tid == curr_tid) 764 { 765 int (*pthread_setname_np_func)(pthread_t thread, const char *name); 766 *reinterpret_cast<void **> (&pthread_setname_np_func) = fn; 767 768 if (pthread_setname_np_func (::pthread_self(), name) == 0) 769 return true; 770 } 771 } 772 return false; 773 #else 774 return false; 775 #endif 776 } 777 778 bool 779 Host::SetShortThreadName (lldb::pid_t pid, lldb::tid_t tid, 780 const char *thread_name, size_t len) 781 { 782 std::unique_ptr<char[]> namebuf(new char[len+1]); 783 784 // Thread names are coming in like '<lldb.comm.debugger.edit>' and 785 // '<lldb.comm.debugger.editline>'. So just chopping the end of the string 786 // off leads to a lot of similar named threads. Go through the thread name 787 // and search for the last dot and use that. 788 const char *lastdot = ::strrchr (thread_name, '.'); 789 790 if (lastdot && lastdot != thread_name) 791 thread_name = lastdot + 1; 792 ::strncpy (namebuf.get(), thread_name, len); 793 namebuf[len] = 0; 794 795 int namebuflen = strlen(namebuf.get()); 796 if (namebuflen > 0) 797 { 798 if (namebuf[namebuflen - 1] == '(' || namebuf[namebuflen - 1] == '>') 799 { 800 // Trim off trailing '(' and '>' characters for a bit more cleanup. 801 namebuflen--; 802 namebuf[namebuflen] = 0; 803 } 804 return Host::SetThreadName (pid, tid, namebuf.get()); 805 } 806 return false; 807 } 808 809 #endif 810 811 FileSpec 812 Host::GetProgramFileSpec () 813 { 814 static FileSpec g_program_filespec; 815 if (!g_program_filespec) 816 { 817 #if defined (__APPLE__) 818 char program_fullpath[PATH_MAX]; 819 // If DST is NULL, then return the number of bytes needed. 820 uint32_t len = sizeof(program_fullpath); 821 int err = _NSGetExecutablePath (program_fullpath, &len); 822 if (err == 0) 823 g_program_filespec.SetFile (program_fullpath, false); 824 else if (err == -1) 825 { 826 char *large_program_fullpath = (char *)::malloc (len + 1); 827 828 err = _NSGetExecutablePath (large_program_fullpath, &len); 829 if (err == 0) 830 g_program_filespec.SetFile (large_program_fullpath, false); 831 832 ::free (large_program_fullpath); 833 } 834 #elif defined (__linux__) 835 char exe_path[PATH_MAX]; 836 ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path) - 1); 837 if (len > 0) { 838 exe_path[len] = 0; 839 g_program_filespec.SetFile(exe_path, false); 840 } 841 #elif defined (__FreeBSD__) || defined (__FreeBSD_kernel__) 842 int exe_path_mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, getpid() }; 843 size_t exe_path_size; 844 if (sysctl(exe_path_mib, 4, NULL, &exe_path_size, NULL, 0) == 0) 845 { 846 char *exe_path = new char[exe_path_size]; 847 if (sysctl(exe_path_mib, 4, exe_path, &exe_path_size, NULL, 0) == 0) 848 g_program_filespec.SetFile(exe_path, false); 849 delete[] exe_path; 850 } 851 #endif 852 } 853 return g_program_filespec; 854 } 855 856 #if !defined (__APPLE__) // see Host.mm 857 858 bool 859 Host::GetBundleDirectory (const FileSpec &file, FileSpec &bundle) 860 { 861 bundle.Clear(); 862 return false; 863 } 864 865 bool 866 Host::ResolveExecutableInBundle (FileSpec &file) 867 { 868 return false; 869 } 870 #endif 871 872 #ifndef _WIN32 873 874 // Opaque info that tracks a dynamic library that was loaded 875 struct DynamicLibraryInfo 876 { 877 DynamicLibraryInfo (const FileSpec &fs, int o, void *h) : 878 file_spec (fs), 879 open_options (o), 880 handle (h) 881 { 882 } 883 884 const FileSpec file_spec; 885 uint32_t open_options; 886 void * handle; 887 }; 888 889 void * 890 Host::DynamicLibraryOpen (const FileSpec &file_spec, uint32_t options, Error &error) 891 { 892 char path[PATH_MAX]; 893 if (file_spec.GetPath(path, sizeof(path))) 894 { 895 int mode = 0; 896 897 if (options & eDynamicLibraryOpenOptionLazy) 898 mode |= RTLD_LAZY; 899 else 900 mode |= RTLD_NOW; 901 902 903 if (options & eDynamicLibraryOpenOptionLocal) 904 mode |= RTLD_LOCAL; 905 else 906 mode |= RTLD_GLOBAL; 907 908 #ifdef LLDB_CONFIG_DLOPEN_RTLD_FIRST_SUPPORTED 909 if (options & eDynamicLibraryOpenOptionLimitGetSymbol) 910 mode |= RTLD_FIRST; 911 #endif 912 913 void * opaque = ::dlopen (path, mode); 914 915 if (opaque) 916 { 917 error.Clear(); 918 return new DynamicLibraryInfo (file_spec, options, opaque); 919 } 920 else 921 { 922 error.SetErrorString(::dlerror()); 923 } 924 } 925 else 926 { 927 error.SetErrorString("failed to extract path"); 928 } 929 return NULL; 930 } 931 932 Error 933 Host::DynamicLibraryClose (void *opaque) 934 { 935 Error error; 936 if (opaque == NULL) 937 { 938 error.SetErrorString ("invalid dynamic library handle"); 939 } 940 else 941 { 942 DynamicLibraryInfo *dylib_info = (DynamicLibraryInfo *) opaque; 943 if (::dlclose (dylib_info->handle) != 0) 944 { 945 error.SetErrorString(::dlerror()); 946 } 947 948 dylib_info->open_options = 0; 949 dylib_info->handle = 0; 950 delete dylib_info; 951 } 952 return error; 953 } 954 955 void * 956 Host::DynamicLibraryGetSymbol (void *opaque, const char *symbol_name, Error &error) 957 { 958 if (opaque == NULL) 959 { 960 error.SetErrorString ("invalid dynamic library handle"); 961 } 962 else 963 { 964 DynamicLibraryInfo *dylib_info = (DynamicLibraryInfo *) opaque; 965 966 void *symbol_addr = ::dlsym (dylib_info->handle, symbol_name); 967 if (symbol_addr) 968 { 969 #ifndef LLDB_CONFIG_DLOPEN_RTLD_FIRST_SUPPORTED 970 // This host doesn't support limiting searches to this shared library 971 // so we need to verify that the match came from this shared library 972 // if it was requested in the Host::DynamicLibraryOpen() function. 973 if (dylib_info->open_options & eDynamicLibraryOpenOptionLimitGetSymbol) 974 { 975 FileSpec match_dylib_spec (Host::GetModuleFileSpecForHostAddress (symbol_addr)); 976 if (match_dylib_spec != dylib_info->file_spec) 977 { 978 char dylib_path[PATH_MAX]; 979 if (dylib_info->file_spec.GetPath (dylib_path, sizeof(dylib_path))) 980 error.SetErrorStringWithFormat ("symbol not found in \"%s\"", dylib_path); 981 else 982 error.SetErrorString ("symbol not found"); 983 return NULL; 984 } 985 } 986 #endif 987 error.Clear(); 988 return symbol_addr; 989 } 990 else 991 { 992 error.SetErrorString(::dlerror()); 993 } 994 } 995 return NULL; 996 } 997 998 FileSpec 999 Host::GetModuleFileSpecForHostAddress (const void *host_addr) 1000 { 1001 FileSpec module_filespec; 1002 Dl_info info; 1003 if (::dladdr (host_addr, &info)) 1004 { 1005 if (info.dli_fname) 1006 module_filespec.SetFile(info.dli_fname, true); 1007 } 1008 return module_filespec; 1009 } 1010 1011 #endif 1012 1013 1014 static void CleanupProcessSpecificLLDBTempDir () 1015 { 1016 // Get the process specific LLDB temporary directory and delete it. 1017 FileSpec tmpdir_file_spec; 1018 if (Host::GetLLDBPath (ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) 1019 { 1020 // Remove the LLDB temporary directory if we have one. Set "recurse" to 1021 // true to all files that were created for the LLDB process can be cleaned up. 1022 const bool recurse = true; 1023 Host::RemoveDirectory(tmpdir_file_spec.GetDirectory().GetCString(), recurse); 1024 } 1025 } 1026 1027 bool 1028 Host::GetLLDBPath (PathType path_type, FileSpec &file_spec) 1029 { 1030 // To get paths related to LLDB we get the path to the executable that 1031 // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB", 1032 // on linux this is assumed to be the "lldb" main executable. If LLDB on 1033 // linux is actually in a shared library (liblldb.so) then this function will 1034 // need to be modified to "do the right thing". 1035 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST); 1036 1037 switch (path_type) 1038 { 1039 case ePathTypeLLDBShlibDir: 1040 { 1041 static ConstString g_lldb_so_dir; 1042 if (!g_lldb_so_dir) 1043 { 1044 FileSpec lldb_file_spec (Host::GetModuleFileSpecForHostAddress ((void *)Host::GetLLDBPath)); 1045 g_lldb_so_dir = lldb_file_spec.GetDirectory(); 1046 if (log) 1047 log->Printf("Host::GetLLDBPath(ePathTypeLLDBShlibDir) => '%s'", g_lldb_so_dir.GetCString()); 1048 } 1049 file_spec.GetDirectory() = g_lldb_so_dir; 1050 return (bool)file_spec.GetDirectory(); 1051 } 1052 break; 1053 1054 case ePathTypeSupportExecutableDir: 1055 { 1056 static ConstString g_lldb_support_exe_dir; 1057 if (!g_lldb_support_exe_dir) 1058 { 1059 FileSpec lldb_file_spec; 1060 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 1061 { 1062 char raw_path[PATH_MAX]; 1063 char resolved_path[PATH_MAX]; 1064 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 1065 1066 #if defined (__APPLE__) 1067 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 1068 if (framework_pos) 1069 { 1070 framework_pos += strlen("LLDB.framework"); 1071 #if defined (__arm__) || defined (__arm64__) 1072 // Shallow bundle 1073 *framework_pos = '\0'; 1074 #else 1075 // Normal bundle 1076 ::strncpy (framework_pos, "/Resources", PATH_MAX - (framework_pos - raw_path)); 1077 #endif 1078 } 1079 #endif // #if defined (__APPLE__) 1080 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 1081 g_lldb_support_exe_dir.SetCString(resolved_path); 1082 } 1083 if (log) 1084 log->Printf("Host::GetLLDBPath(ePathTypeSupportExecutableDir) => '%s'", g_lldb_support_exe_dir.GetCString()); 1085 } 1086 file_spec.GetDirectory() = g_lldb_support_exe_dir; 1087 return (bool)file_spec.GetDirectory(); 1088 } 1089 break; 1090 1091 case ePathTypeHeaderDir: 1092 { 1093 static ConstString g_lldb_headers_dir; 1094 if (!g_lldb_headers_dir) 1095 { 1096 #if defined (__APPLE__) 1097 FileSpec lldb_file_spec; 1098 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 1099 { 1100 char raw_path[PATH_MAX]; 1101 char resolved_path[PATH_MAX]; 1102 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 1103 1104 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 1105 if (framework_pos) 1106 { 1107 framework_pos += strlen("LLDB.framework"); 1108 ::strncpy (framework_pos, "/Headers", PATH_MAX - (framework_pos - raw_path)); 1109 } 1110 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 1111 g_lldb_headers_dir.SetCString(resolved_path); 1112 } 1113 #else 1114 // TODO: Anyone know how we can determine this for linux? Other systems?? 1115 g_lldb_headers_dir.SetCString ("/opt/local/include/lldb"); 1116 #endif 1117 if (log) 1118 log->Printf("Host::GetLLDBPath(ePathTypeHeaderDir) => '%s'", g_lldb_headers_dir.GetCString()); 1119 } 1120 file_spec.GetDirectory() = g_lldb_headers_dir; 1121 return (bool)file_spec.GetDirectory(); 1122 } 1123 break; 1124 1125 #ifdef LLDB_DISABLE_PYTHON 1126 case ePathTypePythonDir: 1127 return false; 1128 #else 1129 case ePathTypePythonDir: 1130 { 1131 static ConstString g_lldb_python_dir; 1132 if (!g_lldb_python_dir) 1133 { 1134 FileSpec lldb_file_spec; 1135 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 1136 { 1137 char raw_path[PATH_MAX]; 1138 char resolved_path[PATH_MAX]; 1139 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 1140 1141 #if defined (__APPLE__) 1142 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 1143 if (framework_pos) 1144 { 1145 framework_pos += strlen("LLDB.framework"); 1146 ::strncpy (framework_pos, "/Resources/Python", PATH_MAX - (framework_pos - raw_path)); 1147 } 1148 else 1149 { 1150 #endif 1151 llvm::SmallString<256> python_version_dir; 1152 llvm::raw_svector_ostream os(python_version_dir); 1153 os << "/python" << PY_MAJOR_VERSION << '.' << PY_MINOR_VERSION << "/site-packages"; 1154 os.flush(); 1155 1156 // We may get our string truncated. Should we protect 1157 // this with an assert? 1158 1159 ::strncat(raw_path, python_version_dir.c_str(), 1160 sizeof(raw_path) - strlen(raw_path) - 1); 1161 1162 #if defined (__APPLE__) 1163 } 1164 #endif 1165 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 1166 g_lldb_python_dir.SetCString(resolved_path); 1167 } 1168 1169 if (log) 1170 log->Printf("Host::GetLLDBPath(ePathTypePythonDir) => '%s'", g_lldb_python_dir.GetCString()); 1171 1172 } 1173 file_spec.GetDirectory() = g_lldb_python_dir; 1174 return (bool)file_spec.GetDirectory(); 1175 } 1176 break; 1177 #endif 1178 1179 case ePathTypeLLDBSystemPlugins: // System plug-ins directory 1180 { 1181 #if defined (__APPLE__) || defined(__linux__) 1182 static ConstString g_lldb_system_plugin_dir; 1183 static bool g_lldb_system_plugin_dir_located = false; 1184 if (!g_lldb_system_plugin_dir_located) 1185 { 1186 g_lldb_system_plugin_dir_located = true; 1187 #if defined (__APPLE__) 1188 FileSpec lldb_file_spec; 1189 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 1190 { 1191 char raw_path[PATH_MAX]; 1192 char resolved_path[PATH_MAX]; 1193 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 1194 1195 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 1196 if (framework_pos) 1197 { 1198 framework_pos += strlen("LLDB.framework"); 1199 ::strncpy (framework_pos, "/Resources/PlugIns", PATH_MAX - (framework_pos - raw_path)); 1200 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 1201 g_lldb_system_plugin_dir.SetCString(resolved_path); 1202 } 1203 return false; 1204 } 1205 #elif defined (__linux__) 1206 FileSpec lldb_file_spec("/usr/lib/lldb", true); 1207 if (lldb_file_spec.Exists()) 1208 { 1209 g_lldb_system_plugin_dir.SetCString(lldb_file_spec.GetPath().c_str()); 1210 } 1211 #endif // __APPLE__ || __linux__ 1212 1213 if (log) 1214 log->Printf("Host::GetLLDBPath(ePathTypeLLDBSystemPlugins) => '%s'", g_lldb_system_plugin_dir.GetCString()); 1215 1216 } 1217 1218 if (g_lldb_system_plugin_dir) 1219 { 1220 file_spec.GetDirectory() = g_lldb_system_plugin_dir; 1221 return true; 1222 } 1223 #else 1224 // TODO: where would system LLDB plug-ins be located on other systems? 1225 return false; 1226 #endif 1227 } 1228 break; 1229 1230 case ePathTypeLLDBUserPlugins: // User plug-ins directory 1231 { 1232 #if defined (__APPLE__) 1233 static ConstString g_lldb_user_plugin_dir; 1234 if (!g_lldb_user_plugin_dir) 1235 { 1236 char user_plugin_path[PATH_MAX]; 1237 if (FileSpec::Resolve ("~/Library/Application Support/LLDB/PlugIns", 1238 user_plugin_path, 1239 sizeof(user_plugin_path))) 1240 { 1241 g_lldb_user_plugin_dir.SetCString(user_plugin_path); 1242 } 1243 } 1244 file_spec.GetDirectory() = g_lldb_user_plugin_dir; 1245 return (bool)file_spec.GetDirectory(); 1246 #elif defined (__linux__) 1247 static ConstString g_lldb_user_plugin_dir; 1248 if (!g_lldb_user_plugin_dir) 1249 { 1250 // XDG Base Directory Specification 1251 // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html 1252 // If XDG_DATA_HOME exists, use that, otherwise use ~/.local/share/lldb. 1253 FileSpec lldb_file_spec; 1254 const char *xdg_data_home = getenv("XDG_DATA_HOME"); 1255 if (xdg_data_home && xdg_data_home[0]) 1256 { 1257 std::string user_plugin_dir (xdg_data_home); 1258 user_plugin_dir += "/lldb"; 1259 lldb_file_spec.SetFile (user_plugin_dir.c_str(), true); 1260 } 1261 else 1262 { 1263 const char *home_dir = getenv("HOME"); 1264 if (home_dir && home_dir[0]) 1265 { 1266 std::string user_plugin_dir (home_dir); 1267 user_plugin_dir += "/.local/share/lldb"; 1268 lldb_file_spec.SetFile (user_plugin_dir.c_str(), true); 1269 } 1270 } 1271 1272 if (lldb_file_spec.Exists()) 1273 g_lldb_user_plugin_dir.SetCString(lldb_file_spec.GetPath().c_str()); 1274 if (log) 1275 log->Printf("Host::GetLLDBPath(ePathTypeLLDBUserPlugins) => '%s'", g_lldb_user_plugin_dir.GetCString()); 1276 } 1277 file_spec.GetDirectory() = g_lldb_user_plugin_dir; 1278 return (bool)file_spec.GetDirectory(); 1279 #endif 1280 // TODO: where would user LLDB plug-ins be located on other systems? 1281 return false; 1282 } 1283 1284 case ePathTypeLLDBTempSystemDir: 1285 { 1286 static ConstString g_lldb_tmp_dir; 1287 if (!g_lldb_tmp_dir) 1288 { 1289 const char *tmpdir_cstr = getenv("TMPDIR"); 1290 if (tmpdir_cstr == NULL) 1291 { 1292 tmpdir_cstr = getenv("TMP"); 1293 if (tmpdir_cstr == NULL) 1294 tmpdir_cstr = getenv("TEMP"); 1295 } 1296 if (tmpdir_cstr) 1297 { 1298 StreamString pid_tmpdir; 1299 pid_tmpdir.Printf("%s/lldb", tmpdir_cstr); 1300 if (Host::MakeDirectory(pid_tmpdir.GetString().c_str(), eFilePermissionsDirectoryDefault).Success()) 1301 { 1302 pid_tmpdir.Printf("/%" PRIu64, Host::GetCurrentProcessID()); 1303 if (Host::MakeDirectory(pid_tmpdir.GetString().c_str(), eFilePermissionsDirectoryDefault).Success()) 1304 { 1305 // Make an atexit handler to clean up the process specify LLDB temp dir 1306 // and all of its contents. 1307 ::atexit (CleanupProcessSpecificLLDBTempDir); 1308 g_lldb_tmp_dir.SetCString(pid_tmpdir.GetString().c_str()); 1309 if (log) 1310 log->Printf("Host::GetLLDBPath(ePathTypeLLDBTempSystemDir) => '%s'", g_lldb_tmp_dir.GetCString()); 1311 1312 } 1313 } 1314 } 1315 } 1316 file_spec.GetDirectory() = g_lldb_tmp_dir; 1317 return (bool)file_spec.GetDirectory(); 1318 } 1319 } 1320 1321 return false; 1322 } 1323 1324 1325 bool 1326 Host::GetHostname (std::string &s) 1327 { 1328 char hostname[PATH_MAX]; 1329 hostname[sizeof(hostname) - 1] = '\0'; 1330 if (::gethostname (hostname, sizeof(hostname) - 1) == 0) 1331 { 1332 struct hostent* h = ::gethostbyname (hostname); 1333 if (h) 1334 s.assign (h->h_name); 1335 else 1336 s.assign (hostname); 1337 return true; 1338 } 1339 return false; 1340 } 1341 1342 #ifndef _WIN32 1343 1344 const char * 1345 Host::GetUserName (uint32_t uid, std::string &user_name) 1346 { 1347 struct passwd user_info; 1348 struct passwd *user_info_ptr = &user_info; 1349 char user_buffer[PATH_MAX]; 1350 size_t user_buffer_size = sizeof(user_buffer); 1351 if (::getpwuid_r (uid, 1352 &user_info, 1353 user_buffer, 1354 user_buffer_size, 1355 &user_info_ptr) == 0) 1356 { 1357 if (user_info_ptr) 1358 { 1359 user_name.assign (user_info_ptr->pw_name); 1360 return user_name.c_str(); 1361 } 1362 } 1363 user_name.clear(); 1364 return NULL; 1365 } 1366 1367 const char * 1368 Host::GetGroupName (uint32_t gid, std::string &group_name) 1369 { 1370 char group_buffer[PATH_MAX]; 1371 size_t group_buffer_size = sizeof(group_buffer); 1372 struct group group_info; 1373 struct group *group_info_ptr = &group_info; 1374 // Try the threadsafe version first 1375 if (::getgrgid_r (gid, 1376 &group_info, 1377 group_buffer, 1378 group_buffer_size, 1379 &group_info_ptr) == 0) 1380 { 1381 if (group_info_ptr) 1382 { 1383 group_name.assign (group_info_ptr->gr_name); 1384 return group_name.c_str(); 1385 } 1386 } 1387 else 1388 { 1389 // The threadsafe version isn't currently working 1390 // for me on darwin, but the non-threadsafe version 1391 // is, so I am calling it below. 1392 group_info_ptr = ::getgrgid (gid); 1393 if (group_info_ptr) 1394 { 1395 group_name.assign (group_info_ptr->gr_name); 1396 return group_name.c_str(); 1397 } 1398 } 1399 group_name.clear(); 1400 return NULL; 1401 } 1402 1403 uint32_t 1404 Host::GetUserID () 1405 { 1406 return getuid(); 1407 } 1408 1409 uint32_t 1410 Host::GetGroupID () 1411 { 1412 return getgid(); 1413 } 1414 1415 uint32_t 1416 Host::GetEffectiveUserID () 1417 { 1418 return geteuid(); 1419 } 1420 1421 uint32_t 1422 Host::GetEffectiveGroupID () 1423 { 1424 return getegid(); 1425 } 1426 1427 #endif 1428 1429 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) // see macosx/Host.mm 1430 bool 1431 Host::GetOSBuildString (std::string &s) 1432 { 1433 s.clear(); 1434 return false; 1435 } 1436 1437 bool 1438 Host::GetOSKernelDescription (std::string &s) 1439 { 1440 s.clear(); 1441 return false; 1442 } 1443 #endif 1444 1445 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined(__linux__) 1446 uint32_t 1447 Host::FindProcesses (const ProcessInstanceInfoMatch &match_info, ProcessInstanceInfoList &process_infos) 1448 { 1449 process_infos.Clear(); 1450 return process_infos.GetSize(); 1451 } 1452 1453 bool 1454 Host::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info) 1455 { 1456 process_info.Clear(); 1457 return false; 1458 } 1459 #endif 1460 1461 #if !defined(__linux__) 1462 bool 1463 Host::FindProcessThreads (const lldb::pid_t pid, TidMap &tids_to_attach) 1464 { 1465 return false; 1466 } 1467 #endif 1468 1469 lldb::TargetSP 1470 Host::GetDummyTarget (lldb_private::Debugger &debugger) 1471 { 1472 static TargetSP g_dummy_target_sp; 1473 1474 // FIXME: Maybe the dummy target should be per-Debugger 1475 if (!g_dummy_target_sp || !g_dummy_target_sp->IsValid()) 1476 { 1477 ArchSpec arch(Target::GetDefaultArchitecture()); 1478 if (!arch.IsValid()) 1479 arch = Host::GetArchitecture (); 1480 Error err = debugger.GetTargetList().CreateTarget(debugger, 1481 NULL, 1482 arch.GetTriple().getTriple().c_str(), 1483 false, 1484 NULL, 1485 g_dummy_target_sp); 1486 } 1487 1488 return g_dummy_target_sp; 1489 } 1490 1491 struct ShellInfo 1492 { 1493 ShellInfo () : 1494 process_reaped (false), 1495 can_delete (false), 1496 pid (LLDB_INVALID_PROCESS_ID), 1497 signo(-1), 1498 status(-1) 1499 { 1500 } 1501 1502 lldb_private::Predicate<bool> process_reaped; 1503 lldb_private::Predicate<bool> can_delete; 1504 lldb::pid_t pid; 1505 int signo; 1506 int status; 1507 }; 1508 1509 static bool 1510 MonitorShellCommand (void *callback_baton, 1511 lldb::pid_t pid, 1512 bool exited, // True if the process did exit 1513 int signo, // Zero for no signal 1514 int status) // Exit value of process if signal is zero 1515 { 1516 ShellInfo *shell_info = (ShellInfo *)callback_baton; 1517 shell_info->pid = pid; 1518 shell_info->signo = signo; 1519 shell_info->status = status; 1520 // Let the thread running Host::RunShellCommand() know that the process 1521 // exited and that ShellInfo has been filled in by broadcasting to it 1522 shell_info->process_reaped.SetValue(1, eBroadcastAlways); 1523 // Now wait for a handshake back from that thread running Host::RunShellCommand 1524 // so we know that we can delete shell_info_ptr 1525 shell_info->can_delete.WaitForValueEqualTo(true); 1526 // Sleep a bit to allow the shell_info->can_delete.SetValue() to complete... 1527 usleep(1000); 1528 // Now delete the shell info that was passed into this function 1529 delete shell_info; 1530 return true; 1531 } 1532 1533 Error 1534 Host::RunShellCommand (const char *command, 1535 const char *working_dir, 1536 int *status_ptr, 1537 int *signo_ptr, 1538 std::string *command_output_ptr, 1539 uint32_t timeout_sec, 1540 const char *shell) 1541 { 1542 Error error; 1543 ProcessLaunchInfo launch_info; 1544 if (shell && shell[0]) 1545 { 1546 // Run the command in a shell 1547 launch_info.SetShell(shell); 1548 launch_info.GetArguments().AppendArgument(command); 1549 const bool localhost = true; 1550 const bool will_debug = false; 1551 const bool first_arg_is_full_shell_command = true; 1552 launch_info.ConvertArgumentsForLaunchingInShell (error, 1553 localhost, 1554 will_debug, 1555 first_arg_is_full_shell_command, 1556 0); 1557 } 1558 else 1559 { 1560 // No shell, just run it 1561 Args args (command); 1562 const bool first_arg_is_executable = true; 1563 launch_info.SetArguments(args, first_arg_is_executable); 1564 } 1565 1566 if (working_dir) 1567 launch_info.SetWorkingDirectory(working_dir); 1568 char output_file_path_buffer[PATH_MAX]; 1569 const char *output_file_path = NULL; 1570 1571 if (command_output_ptr) 1572 { 1573 // Create a temporary file to get the stdout/stderr and redirect the 1574 // output of the command into this file. We will later read this file 1575 // if all goes well and fill the data into "command_output_ptr" 1576 FileSpec tmpdir_file_spec; 1577 if (Host::GetLLDBPath (ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) 1578 { 1579 tmpdir_file_spec.GetFilename().SetCString("lldb-shell-output.XXXXXX"); 1580 strncpy(output_file_path_buffer, tmpdir_file_spec.GetPath().c_str(), sizeof(output_file_path_buffer)); 1581 } 1582 else 1583 { 1584 strncpy(output_file_path_buffer, "/tmp/lldb-shell-output.XXXXXX", sizeof(output_file_path_buffer)); 1585 } 1586 1587 output_file_path = ::mktemp(output_file_path_buffer); 1588 } 1589 1590 launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false); 1591 if (output_file_path) 1592 { 1593 launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_path, false, true); 1594 launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO); 1595 } 1596 else 1597 { 1598 launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true); 1599 launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true); 1600 } 1601 1602 // The process monitor callback will delete the 'shell_info_ptr' below... 1603 std::unique_ptr<ShellInfo> shell_info_ap (new ShellInfo()); 1604 1605 const bool monitor_signals = false; 1606 launch_info.SetMonitorProcessCallback(MonitorShellCommand, shell_info_ap.get(), monitor_signals); 1607 1608 error = LaunchProcess (launch_info); 1609 const lldb::pid_t pid = launch_info.GetProcessID(); 1610 1611 if (error.Success() && pid == LLDB_INVALID_PROCESS_ID) 1612 error.SetErrorString("failed to get process ID"); 1613 1614 if (error.Success()) 1615 { 1616 // The process successfully launched, so we can defer ownership of 1617 // "shell_info" to the MonitorShellCommand callback function that will 1618 // get called when the process dies. We release the unique pointer as it 1619 // doesn't need to delete the ShellInfo anymore. 1620 ShellInfo *shell_info = shell_info_ap.release(); 1621 TimeValue *timeout_ptr = nullptr; 1622 TimeValue timeout_time(TimeValue::Now()); 1623 if (timeout_sec > 0) { 1624 timeout_time.OffsetWithSeconds(timeout_sec); 1625 timeout_ptr = &timeout_time; 1626 } 1627 bool timed_out = false; 1628 shell_info->process_reaped.WaitForValueEqualTo(true, timeout_ptr, &timed_out); 1629 if (timed_out) 1630 { 1631 error.SetErrorString("timed out waiting for shell command to complete"); 1632 1633 // Kill the process since it didn't complete withint the timeout specified 1634 Kill (pid, SIGKILL); 1635 // Wait for the monitor callback to get the message 1636 timeout_time = TimeValue::Now(); 1637 timeout_time.OffsetWithSeconds(1); 1638 timed_out = false; 1639 shell_info->process_reaped.WaitForValueEqualTo(true, &timeout_time, &timed_out); 1640 } 1641 else 1642 { 1643 if (status_ptr) 1644 *status_ptr = shell_info->status; 1645 1646 if (signo_ptr) 1647 *signo_ptr = shell_info->signo; 1648 1649 if (command_output_ptr) 1650 { 1651 command_output_ptr->clear(); 1652 FileSpec file_spec(output_file_path, File::eOpenOptionRead); 1653 uint64_t file_size = file_spec.GetByteSize(); 1654 if (file_size > 0) 1655 { 1656 if (file_size > command_output_ptr->max_size()) 1657 { 1658 error.SetErrorStringWithFormat("shell command output is too large to fit into a std::string"); 1659 } 1660 else 1661 { 1662 command_output_ptr->resize(file_size); 1663 file_spec.ReadFileContents(0, &((*command_output_ptr)[0]), command_output_ptr->size(), &error); 1664 } 1665 } 1666 } 1667 } 1668 shell_info->can_delete.SetValue(true, eBroadcastAlways); 1669 } 1670 1671 if (output_file_path) 1672 ::unlink (output_file_path); 1673 // Handshake with the monitor thread, or just let it know in advance that 1674 // it can delete "shell_info" in case we timed out and were not able to kill 1675 // the process... 1676 return error; 1677 } 1678 1679 1680 // LaunchProcessPosixSpawn for Apple, Linux, FreeBSD and other GLIBC 1681 // systems 1682 1683 #if defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) || defined (__GLIBC__) 1684 1685 // this method needs to be visible to macosx/Host.cpp and 1686 // common/Host.cpp. 1687 1688 short 1689 Host::GetPosixspawnFlags (ProcessLaunchInfo &launch_info) 1690 { 1691 short flags = POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK; 1692 1693 #if defined (__APPLE__) 1694 if (launch_info.GetFlags().Test (eLaunchFlagExec)) 1695 flags |= POSIX_SPAWN_SETEXEC; // Darwin specific posix_spawn flag 1696 1697 if (launch_info.GetFlags().Test (eLaunchFlagDebug)) 1698 flags |= POSIX_SPAWN_START_SUSPENDED; // Darwin specific posix_spawn flag 1699 1700 if (launch_info.GetFlags().Test (eLaunchFlagDisableASLR)) 1701 flags |= _POSIX_SPAWN_DISABLE_ASLR; // Darwin specific posix_spawn flag 1702 1703 if (launch_info.GetLaunchInSeparateProcessGroup()) 1704 flags |= POSIX_SPAWN_SETPGROUP; 1705 1706 #ifdef POSIX_SPAWN_CLOEXEC_DEFAULT 1707 #if defined (__APPLE__) && (defined (__x86_64__) || defined (__i386__)) 1708 static LazyBool g_use_close_on_exec_flag = eLazyBoolCalculate; 1709 if (g_use_close_on_exec_flag == eLazyBoolCalculate) 1710 { 1711 g_use_close_on_exec_flag = eLazyBoolNo; 1712 1713 uint32_t major, minor, update; 1714 if (Host::GetOSVersion(major, minor, update)) 1715 { 1716 // Kernel panic if we use the POSIX_SPAWN_CLOEXEC_DEFAULT on 10.7 or earlier 1717 if (major > 10 || (major == 10 && minor > 7)) 1718 { 1719 // Only enable for 10.8 and later OS versions 1720 g_use_close_on_exec_flag = eLazyBoolYes; 1721 } 1722 } 1723 } 1724 #else 1725 static LazyBool g_use_close_on_exec_flag = eLazyBoolYes; 1726 #endif 1727 // Close all files exception those with file actions if this is supported. 1728 if (g_use_close_on_exec_flag == eLazyBoolYes) 1729 flags |= POSIX_SPAWN_CLOEXEC_DEFAULT; 1730 #endif 1731 #endif // #if defined (__APPLE__) 1732 return flags; 1733 } 1734 1735 Error 1736 Host::LaunchProcessPosixSpawn (const char *exe_path, ProcessLaunchInfo &launch_info, ::pid_t &pid) 1737 { 1738 Error error; 1739 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_PROCESS)); 1740 1741 posix_spawnattr_t attr; 1742 error.SetError( ::posix_spawnattr_init (&attr), eErrorTypePOSIX); 1743 1744 if (error.Fail() || log) 1745 error.PutToLog(log, "::posix_spawnattr_init ( &attr )"); 1746 if (error.Fail()) 1747 return error; 1748 1749 // Make a quick class that will cleanup the posix spawn attributes in case 1750 // we return in the middle of this function. 1751 lldb_utility::CleanUp <posix_spawnattr_t *, int> posix_spawnattr_cleanup(&attr, posix_spawnattr_destroy); 1752 1753 sigset_t no_signals; 1754 sigset_t all_signals; 1755 sigemptyset (&no_signals); 1756 sigfillset (&all_signals); 1757 ::posix_spawnattr_setsigmask(&attr, &no_signals); 1758 #if defined (__linux__) || defined (__FreeBSD__) 1759 ::posix_spawnattr_setsigdefault(&attr, &no_signals); 1760 #else 1761 ::posix_spawnattr_setsigdefault(&attr, &all_signals); 1762 #endif 1763 1764 short flags = GetPosixspawnFlags(launch_info); 1765 1766 error.SetError( ::posix_spawnattr_setflags (&attr, flags), eErrorTypePOSIX); 1767 if (error.Fail() || log) 1768 error.PutToLog(log, "::posix_spawnattr_setflags ( &attr, flags=0x%8.8x )", flags); 1769 if (error.Fail()) 1770 return error; 1771 1772 // posix_spawnattr_setbinpref_np appears to be an Apple extension per: 1773 // http://www.unix.com/man-page/OSX/3/posix_spawnattr_setbinpref_np/ 1774 #if defined (__APPLE__) && !defined (__arm__) 1775 1776 // Don't set the binpref if a shell was provided. After all, that's only going to affect what version of the shell 1777 // is launched, not what fork of the binary is launched. We insert "arch --arch <ARCH> as part of the shell invocation 1778 // to do that job on OSX. 1779 1780 if (launch_info.GetShell() == nullptr) 1781 { 1782 // We don't need to do this for ARM, and we really shouldn't now that we 1783 // have multiple CPU subtypes and no posix_spawnattr call that allows us 1784 // to set which CPU subtype to launch... 1785 const ArchSpec &arch_spec = launch_info.GetArchitecture(); 1786 cpu_type_t cpu = arch_spec.GetMachOCPUType(); 1787 cpu_type_t sub = arch_spec.GetMachOCPUSubType(); 1788 if (cpu != 0 && 1789 cpu != static_cast<cpu_type_t>(UINT32_MAX) && 1790 cpu != static_cast<cpu_type_t>(LLDB_INVALID_CPUTYPE) && 1791 !(cpu == 0x01000007 && sub == 8)) // If haswell is specified, don't try to set the CPU type or we will fail 1792 { 1793 size_t ocount = 0; 1794 error.SetError( ::posix_spawnattr_setbinpref_np (&attr, 1, &cpu, &ocount), eErrorTypePOSIX); 1795 if (error.Fail() || log) 1796 error.PutToLog(log, "::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = 0x%8.8x, count => %llu )", cpu, (uint64_t)ocount); 1797 1798 if (error.Fail() || ocount != 1) 1799 return error; 1800 } 1801 } 1802 1803 #endif 1804 1805 const char *tmp_argv[2]; 1806 char * const *argv = (char * const*)launch_info.GetArguments().GetConstArgumentVector(); 1807 char * const *envp = (char * const*)launch_info.GetEnvironmentEntries().GetConstArgumentVector(); 1808 if (argv == NULL) 1809 { 1810 // posix_spawn gets very unhappy if it doesn't have at least the program 1811 // name in argv[0]. One of the side affects I have noticed is the environment 1812 // variables don't make it into the child process if "argv == NULL"!!! 1813 tmp_argv[0] = exe_path; 1814 tmp_argv[1] = NULL; 1815 argv = (char * const*)tmp_argv; 1816 } 1817 1818 #if !defined (__APPLE__) 1819 // manage the working directory 1820 char current_dir[PATH_MAX]; 1821 current_dir[0] = '\0'; 1822 #endif 1823 1824 const char *working_dir = launch_info.GetWorkingDirectory(); 1825 if (working_dir) 1826 { 1827 #if defined (__APPLE__) 1828 // Set the working directory on this thread only 1829 if (__pthread_chdir (working_dir) < 0) { 1830 if (errno == ENOENT) { 1831 error.SetErrorStringWithFormat("No such file or directory: %s", working_dir); 1832 } else if (errno == ENOTDIR) { 1833 error.SetErrorStringWithFormat("Path doesn't name a directory: %s", working_dir); 1834 } else { 1835 error.SetErrorStringWithFormat("An unknown error occurred when changing directory for process execution."); 1836 } 1837 return error; 1838 } 1839 #else 1840 if (::getcwd(current_dir, sizeof(current_dir)) == NULL) 1841 { 1842 error.SetError(errno, eErrorTypePOSIX); 1843 error.LogIfError(log, "unable to save the current directory"); 1844 return error; 1845 } 1846 1847 if (::chdir(working_dir) == -1) 1848 { 1849 error.SetError(errno, eErrorTypePOSIX); 1850 error.LogIfError(log, "unable to change working directory to %s", working_dir); 1851 return error; 1852 } 1853 #endif 1854 } 1855 1856 const size_t num_file_actions = launch_info.GetNumFileActions (); 1857 if (num_file_actions > 0) 1858 { 1859 posix_spawn_file_actions_t file_actions; 1860 error.SetError( ::posix_spawn_file_actions_init (&file_actions), eErrorTypePOSIX); 1861 if (error.Fail() || log) 1862 error.PutToLog(log, "::posix_spawn_file_actions_init ( &file_actions )"); 1863 if (error.Fail()) 1864 return error; 1865 1866 // Make a quick class that will cleanup the posix spawn attributes in case 1867 // we return in the middle of this function. 1868 lldb_utility::CleanUp <posix_spawn_file_actions_t *, int> posix_spawn_file_actions_cleanup (&file_actions, posix_spawn_file_actions_destroy); 1869 1870 for (size_t i=0; i<num_file_actions; ++i) 1871 { 1872 const ProcessLaunchInfo::FileAction *launch_file_action = launch_info.GetFileActionAtIndex(i); 1873 if (launch_file_action) 1874 { 1875 if (!ProcessLaunchInfo::FileAction::AddPosixSpawnFileAction (&file_actions, 1876 launch_file_action, 1877 log, 1878 error)) 1879 return error; 1880 } 1881 } 1882 1883 error.SetError (::posix_spawnp (&pid, 1884 exe_path, 1885 &file_actions, 1886 &attr, 1887 argv, 1888 envp), 1889 eErrorTypePOSIX); 1890 1891 if (error.Fail() || log) 1892 { 1893 error.PutToLog(log, "::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", 1894 pid, exe_path, static_cast<void*>(&file_actions), 1895 static_cast<void*>(&attr), 1896 reinterpret_cast<const void*>(argv), 1897 reinterpret_cast<const void*>(envp)); 1898 if (log) 1899 { 1900 for (int ii=0; argv[ii]; ++ii) 1901 log->Printf("argv[%i] = '%s'", ii, argv[ii]); 1902 } 1903 } 1904 1905 } 1906 else 1907 { 1908 error.SetError (::posix_spawnp (&pid, 1909 exe_path, 1910 NULL, 1911 &attr, 1912 argv, 1913 envp), 1914 eErrorTypePOSIX); 1915 1916 if (error.Fail() || log) 1917 { 1918 error.PutToLog(log, "::posix_spawnp ( pid => %i, path = '%s', file_actions = NULL, attr = %p, argv = %p, envp = %p )", 1919 pid, exe_path, static_cast<void*>(&attr), 1920 reinterpret_cast<const void*>(argv), 1921 reinterpret_cast<const void*>(envp)); 1922 if (log) 1923 { 1924 for (int ii=0; argv[ii]; ++ii) 1925 log->Printf("argv[%i] = '%s'", ii, argv[ii]); 1926 } 1927 } 1928 } 1929 1930 if (working_dir) 1931 { 1932 #if defined (__APPLE__) 1933 // No more thread specific current working directory 1934 __pthread_fchdir (-1); 1935 #else 1936 if (::chdir(current_dir) == -1 && error.Success()) 1937 { 1938 error.SetError(errno, eErrorTypePOSIX); 1939 error.LogIfError(log, "unable to change current directory back to %s", 1940 current_dir); 1941 } 1942 #endif 1943 } 1944 1945 return error; 1946 } 1947 1948 #endif // LaunchProcedssPosixSpawn: Apple, Linux, FreeBSD and other GLIBC systems 1949 1950 1951 #if defined(__linux__) || defined(__FreeBSD__) || defined(__GLIBC__) 1952 // The functions below implement process launching via posix_spawn() for Linux 1953 // and FreeBSD. 1954 1955 Error 1956 Host::LaunchProcess (ProcessLaunchInfo &launch_info) 1957 { 1958 Error error; 1959 char exe_path[PATH_MAX]; 1960 1961 PlatformSP host_platform_sp (Platform::GetDefaultPlatform ()); 1962 1963 const ArchSpec &arch_spec = launch_info.GetArchitecture(); 1964 1965 FileSpec exe_spec(launch_info.GetExecutableFile()); 1966 1967 FileSpec::FileType file_type = exe_spec.GetFileType(); 1968 if (file_type != FileSpec::eFileTypeRegular) 1969 { 1970 lldb::ModuleSP exe_module_sp; 1971 error = host_platform_sp->ResolveExecutable (exe_spec, 1972 arch_spec, 1973 exe_module_sp, 1974 NULL); 1975 1976 if (error.Fail()) 1977 return error; 1978 1979 if (exe_module_sp) 1980 exe_spec = exe_module_sp->GetFileSpec(); 1981 } 1982 1983 if (exe_spec.Exists()) 1984 { 1985 exe_spec.GetPath (exe_path, sizeof(exe_path)); 1986 } 1987 else 1988 { 1989 launch_info.GetExecutableFile().GetPath (exe_path, sizeof(exe_path)); 1990 error.SetErrorStringWithFormat ("executable doesn't exist: '%s'", exe_path); 1991 return error; 1992 } 1993 1994 assert(!launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY)); 1995 1996 ::pid_t pid = LLDB_INVALID_PROCESS_ID; 1997 1998 error = LaunchProcessPosixSpawn(exe_path, launch_info, pid); 1999 2000 if (pid != LLDB_INVALID_PROCESS_ID) 2001 { 2002 // If all went well, then set the process ID into the launch info 2003 launch_info.SetProcessID(pid); 2004 2005 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 2006 2007 // Make sure we reap any processes we spawn or we will have zombies. 2008 if (!launch_info.MonitorProcess()) 2009 { 2010 const bool monitor_signals = false; 2011 StartMonitoringChildProcess (Process::SetProcessExitStatus, 2012 NULL, 2013 pid, 2014 monitor_signals); 2015 if (log) 2016 log->PutCString ("monitored child process with default Process::SetProcessExitStatus."); 2017 } 2018 else 2019 { 2020 if (log) 2021 log->PutCString ("monitored child process with user-specified process monitor."); 2022 } 2023 } 2024 else 2025 { 2026 // Invalid process ID, something didn't go well 2027 if (error.Success()) 2028 error.SetErrorString ("process launch failed for unknown reasons"); 2029 } 2030 return error; 2031 } 2032 2033 #endif // defined(__linux__) or defined(__FreeBSD__) 2034 2035 #ifndef _WIN32 2036 2037 size_t 2038 Host::GetPageSize() 2039 { 2040 return ::getpagesize(); 2041 } 2042 2043 uint32_t 2044 Host::GetNumberCPUS () 2045 { 2046 static uint32_t g_num_cores = UINT32_MAX; 2047 if (g_num_cores == UINT32_MAX) 2048 { 2049 #if defined(__APPLE__) or defined (__linux__) or defined (__FreeBSD__) or defined (__FreeBSD_kernel__) 2050 2051 g_num_cores = ::sysconf(_SC_NPROCESSORS_ONLN); 2052 2053 #else 2054 2055 // Assume POSIX support if a host specific case has not been supplied above 2056 g_num_cores = 0; 2057 int num_cores = 0; 2058 size_t num_cores_len = sizeof(num_cores); 2059 #ifdef HW_AVAILCPU 2060 int mib[] = { CTL_HW, HW_AVAILCPU }; 2061 #else 2062 int mib[] = { CTL_HW, HW_NCPU }; 2063 #endif 2064 2065 /* get the number of CPUs from the system */ 2066 if (sysctl(mib, sizeof(mib)/sizeof(int), &num_cores, &num_cores_len, NULL, 0) == 0 && (num_cores > 0)) 2067 { 2068 g_num_cores = num_cores; 2069 } 2070 else 2071 { 2072 mib[1] = HW_NCPU; 2073 num_cores_len = sizeof(num_cores); 2074 if (sysctl(mib, sizeof(mib)/sizeof(int), &num_cores, &num_cores_len, NULL, 0) == 0 && (num_cores > 0)) 2075 { 2076 if (num_cores > 0) 2077 g_num_cores = num_cores; 2078 } 2079 } 2080 #endif 2081 } 2082 return g_num_cores; 2083 } 2084 2085 void 2086 Host::Kill(lldb::pid_t pid, int signo) 2087 { 2088 ::kill(pid, signo); 2089 } 2090 2091 #endif 2092 2093 #if !defined (__APPLE__) 2094 bool 2095 Host::OpenFileInExternalEditor (const FileSpec &file_spec, uint32_t line_no) 2096 { 2097 return false; 2098 } 2099 2100 void 2101 Host::SetCrashDescriptionWithFormat (const char *format, ...) 2102 { 2103 } 2104 2105 void 2106 Host::SetCrashDescription (const char *description) 2107 { 2108 } 2109 2110 lldb::pid_t 2111 Host::LaunchApplication (const FileSpec &app_file_spec) 2112 { 2113 return LLDB_INVALID_PROCESS_ID; 2114 } 2115 2116 #endif 2117 2118 2119 #ifdef LLDB_DISABLE_POSIX 2120 2121 Error 2122 Host::MakeDirectory (const char* path, uint32_t mode) 2123 { 2124 Error error; 2125 error.SetErrorStringWithFormat("%s in not implemented on this host", __PRETTY_FUNCTION__); 2126 return error; 2127 } 2128 2129 Error 2130 Host::GetFilePermissions (const char* path, uint32_t &file_permissions) 2131 { 2132 Error error; 2133 error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__); 2134 return error; 2135 } 2136 2137 Error 2138 Host::SetFilePermissions (const char* path, uint32_t file_permissions) 2139 { 2140 Error error; 2141 error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__); 2142 return error; 2143 } 2144 2145 Error 2146 Host::Symlink (const char *src, const char *dst) 2147 { 2148 Error error; 2149 error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__); 2150 return error; 2151 } 2152 2153 Error 2154 Host::Readlink (const char *path, char *buf, size_t buf_len) 2155 { 2156 Error error; 2157 error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__); 2158 return error; 2159 } 2160 2161 Error 2162 Host::Unlink (const char *path) 2163 { 2164 Error error; 2165 error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__); 2166 return error; 2167 } 2168 2169 Error 2170 Host::RemoveDirectory (const char* path, bool recurse) 2171 { 2172 Error error; 2173 error.SetErrorStringWithFormat("%s is not supported on this host", __PRETTY_FUNCTION__); 2174 return error; 2175 } 2176 2177 #else 2178 2179 Error 2180 Host::MakeDirectory (const char* path, uint32_t file_permissions) 2181 { 2182 Error error; 2183 if (path && path[0]) 2184 { 2185 if (::mkdir(path, file_permissions) != 0) 2186 { 2187 error.SetErrorToErrno(); 2188 switch (error.GetError()) 2189 { 2190 case ENOENT: 2191 { 2192 // Parent directory doesn't exist, so lets make it if we can 2193 FileSpec spec(path, false); 2194 if (spec.GetDirectory() && spec.GetFilename()) 2195 { 2196 // Make the parent directory and try again 2197 Error error2 = Host::MakeDirectory(spec.GetDirectory().GetCString(), file_permissions); 2198 if (error2.Success()) 2199 { 2200 // Try and make the directory again now that the parent directory was made successfully 2201 if (::mkdir(path, file_permissions) == 0) 2202 error.Clear(); 2203 else 2204 error.SetErrorToErrno(); 2205 } 2206 } 2207 } 2208 break; 2209 case EEXIST: 2210 { 2211 FileSpec path_spec(path, false); 2212 if (path_spec.IsDirectory()) 2213 error.Clear(); // It is a directory and it already exists 2214 } 2215 break; 2216 } 2217 } 2218 } 2219 else 2220 { 2221 error.SetErrorString("empty path"); 2222 } 2223 return error; 2224 } 2225 2226 Error 2227 Host::RemoveDirectory (const char* path, bool recurse) 2228 { 2229 Error error; 2230 if (path && path[0]) 2231 { 2232 if (recurse) 2233 { 2234 StreamString command; 2235 command.Printf("rm -rf \"%s\"", path); 2236 int status = ::system(command.GetString().c_str()); 2237 if (status != 0) 2238 error.SetError(status, eErrorTypeGeneric); 2239 } 2240 else 2241 { 2242 if (::rmdir(path) != 0) 2243 error.SetErrorToErrno(); 2244 } 2245 } 2246 else 2247 { 2248 error.SetErrorString("empty path"); 2249 } 2250 return error; 2251 } 2252 2253 Error 2254 Host::GetFilePermissions (const char* path, uint32_t &file_permissions) 2255 { 2256 Error error; 2257 struct stat file_stats; 2258 if (::stat (path, &file_stats) == 0) 2259 { 2260 // The bits in "st_mode" currently match the definitions 2261 // for the file mode bits in unix. 2262 file_permissions = file_stats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); 2263 } 2264 else 2265 { 2266 error.SetErrorToErrno(); 2267 } 2268 return error; 2269 } 2270 2271 Error 2272 Host::SetFilePermissions (const char* path, uint32_t file_permissions) 2273 { 2274 Error error; 2275 if (::chmod(path, file_permissions) != 0) 2276 error.SetErrorToErrno(); 2277 return error; 2278 } 2279 2280 Error 2281 Host::Symlink (const char *src, const char *dst) 2282 { 2283 Error error; 2284 if (::symlink(dst, src) == -1) 2285 error.SetErrorToErrno(); 2286 return error; 2287 } 2288 2289 Error 2290 Host::Unlink (const char *path) 2291 { 2292 Error error; 2293 if (::unlink(path) == -1) 2294 error.SetErrorToErrno(); 2295 return error; 2296 } 2297 2298 Error 2299 Host::Readlink (const char *path, char *buf, size_t buf_len) 2300 { 2301 Error error; 2302 ssize_t count = ::readlink(path, buf, buf_len); 2303 if (count < 0) 2304 error.SetErrorToErrno(); 2305 else if (static_cast<size_t>(count) < (buf_len-1)) 2306 buf[count] = '\0'; // Success 2307 else 2308 error.SetErrorString("'buf' buffer is too small to contain link contents"); 2309 return error; 2310 } 2311 2312 2313 #endif 2314 2315 typedef std::map<lldb::user_id_t, lldb::FileSP> FDToFileMap; 2316 FDToFileMap& GetFDToFileMap() 2317 { 2318 static FDToFileMap g_fd2filemap; 2319 return g_fd2filemap; 2320 } 2321 2322 lldb::user_id_t 2323 Host::OpenFile (const FileSpec& file_spec, 2324 uint32_t flags, 2325 uint32_t mode, 2326 Error &error) 2327 { 2328 std::string path (file_spec.GetPath()); 2329 if (path.empty()) 2330 { 2331 error.SetErrorString("empty path"); 2332 return UINT64_MAX; 2333 } 2334 FileSP file_sp(new File()); 2335 error = file_sp->Open(path.c_str(),flags,mode); 2336 if (file_sp->IsValid() == false) 2337 return UINT64_MAX; 2338 lldb::user_id_t fd = file_sp->GetDescriptor(); 2339 GetFDToFileMap()[fd] = file_sp; 2340 return fd; 2341 } 2342 2343 bool 2344 Host::CloseFile (lldb::user_id_t fd, Error &error) 2345 { 2346 if (fd == UINT64_MAX) 2347 { 2348 error.SetErrorString ("invalid file descriptor"); 2349 return false; 2350 } 2351 FDToFileMap& file_map = GetFDToFileMap(); 2352 FDToFileMap::iterator pos = file_map.find(fd); 2353 if (pos == file_map.end()) 2354 { 2355 error.SetErrorStringWithFormat ("invalid host file descriptor %" PRIu64, fd); 2356 return false; 2357 } 2358 FileSP file_sp = pos->second; 2359 if (!file_sp) 2360 { 2361 error.SetErrorString ("invalid host backing file"); 2362 return false; 2363 } 2364 error = file_sp->Close(); 2365 file_map.erase(pos); 2366 return error.Success(); 2367 } 2368 2369 uint64_t 2370 Host::WriteFile (lldb::user_id_t fd, uint64_t offset, const void* src, uint64_t src_len, Error &error) 2371 { 2372 if (fd == UINT64_MAX) 2373 { 2374 error.SetErrorString ("invalid file descriptor"); 2375 return UINT64_MAX; 2376 } 2377 FDToFileMap& file_map = GetFDToFileMap(); 2378 FDToFileMap::iterator pos = file_map.find(fd); 2379 if (pos == file_map.end()) 2380 { 2381 error.SetErrorStringWithFormat("invalid host file descriptor %" PRIu64 , fd); 2382 return false; 2383 } 2384 FileSP file_sp = pos->second; 2385 if (!file_sp) 2386 { 2387 error.SetErrorString ("invalid host backing file"); 2388 return UINT64_MAX; 2389 } 2390 if (static_cast<uint64_t>(file_sp->SeekFromStart(offset, &error)) != offset || 2391 error.Fail()) 2392 return UINT64_MAX; 2393 size_t bytes_written = src_len; 2394 error = file_sp->Write(src, bytes_written); 2395 if (error.Fail()) 2396 return UINT64_MAX; 2397 return bytes_written; 2398 } 2399 2400 uint64_t 2401 Host::ReadFile (lldb::user_id_t fd, uint64_t offset, void* dst, uint64_t dst_len, Error &error) 2402 { 2403 if (fd == UINT64_MAX) 2404 { 2405 error.SetErrorString ("invalid file descriptor"); 2406 return UINT64_MAX; 2407 } 2408 FDToFileMap& file_map = GetFDToFileMap(); 2409 FDToFileMap::iterator pos = file_map.find(fd); 2410 if (pos == file_map.end()) 2411 { 2412 error.SetErrorStringWithFormat ("invalid host file descriptor %" PRIu64, fd); 2413 return false; 2414 } 2415 FileSP file_sp = pos->second; 2416 if (!file_sp) 2417 { 2418 error.SetErrorString ("invalid host backing file"); 2419 return UINT64_MAX; 2420 } 2421 if (static_cast<uint64_t>(file_sp->SeekFromStart(offset, &error)) != offset || 2422 error.Fail()) 2423 return UINT64_MAX; 2424 size_t bytes_read = dst_len; 2425 error = file_sp->Read(dst ,bytes_read); 2426 if (error.Fail()) 2427 return UINT64_MAX; 2428 return bytes_read; 2429 } 2430 2431 lldb::user_id_t 2432 Host::GetFileSize (const FileSpec& file_spec) 2433 { 2434 return file_spec.GetByteSize(); 2435 } 2436 2437 bool 2438 Host::GetFileExists (const FileSpec& file_spec) 2439 { 2440 return file_spec.Exists(); 2441 } 2442 2443 bool 2444 Host::CalculateMD5 (const FileSpec& file_spec, 2445 uint64_t &low, 2446 uint64_t &high) 2447 { 2448 #if defined (__APPLE__) 2449 StreamString md5_cmd_line; 2450 md5_cmd_line.Printf("md5 -q '%s'", file_spec.GetPath().c_str()); 2451 std::string hash_string; 2452 Error err = Host::RunShellCommand(md5_cmd_line.GetData(), NULL, NULL, NULL, &hash_string, 60); 2453 if (err.Fail()) 2454 return false; 2455 // a correctly formed MD5 is 16-bytes, that is 32 hex digits 2456 // if the output is any other length it is probably wrong 2457 if (hash_string.size() != 32) 2458 return false; 2459 std::string part1(hash_string,0,16); 2460 std::string part2(hash_string,16); 2461 const char* part1_cstr = part1.c_str(); 2462 const char* part2_cstr = part2.c_str(); 2463 high = ::strtoull(part1_cstr, NULL, 16); 2464 low = ::strtoull(part2_cstr, NULL, 16); 2465 return true; 2466 #else 2467 // your own MD5 implementation here 2468 return false; 2469 #endif 2470 } 2471