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 <dlfcn.h> 14 #include <errno.h> 15 #include <grp.h> 16 #include <limits.h> 17 #include <netdb.h> 18 #include <pwd.h> 19 #include <sys/types.h> 20 #include <sys/sysctl.h> 21 #include <unistd.h> 22 23 #if defined (__APPLE__) 24 25 #include <dispatch/dispatch.h> 26 #include <libproc.h> 27 #include <mach-o/dyld.h> 28 #include <mach/mach_port.h> 29 30 #endif 31 32 #if defined (__linux__) || defined (__FreeBSD__) || defined (__FreeBSD_kernel__) 33 #include <sys/wait.h> 34 #include <sys/syscall.h> 35 #endif 36 37 #if defined (__FreeBSD__) 38 #include <pthread_np.h> 39 #endif 40 41 #include "lldb/Host/Host.h" 42 #include "lldb/Core/ArchSpec.h" 43 #include "lldb/Core/ConstString.h" 44 #include "lldb/Core/Debugger.h" 45 #include "lldb/Core/Error.h" 46 #include "lldb/Core/Log.h" 47 #include "lldb/Core/StreamString.h" 48 #include "lldb/Core/ThreadSafeSTLMap.h" 49 #include "lldb/Host/Config.h" 50 #include "lldb/Host/Endian.h" 51 #include "lldb/Host/FileSpec.h" 52 #include "lldb/Host/Mutex.h" 53 #include "lldb/Target/Process.h" 54 #include "lldb/Target/TargetList.h" 55 56 #include "llvm/ADT/SmallString.h" 57 #include "llvm/Support/Host.h" 58 #include "llvm/Support/MachO.h" 59 #include "llvm/Support/raw_ostream.h" 60 61 62 63 64 65 using namespace lldb; 66 using namespace lldb_private; 67 68 69 #if !defined (__APPLE__) 70 struct MonitorInfo 71 { 72 lldb::pid_t pid; // The process ID to monitor 73 Host::MonitorChildProcessCallback callback; // The callback function to call when "pid" exits or signals 74 void *callback_baton; // The callback baton for the callback function 75 bool monitor_signals; // If true, call the callback when "pid" gets signaled. 76 }; 77 78 static void * 79 MonitorChildProcessThreadFunction (void *arg); 80 81 lldb::thread_t 82 Host::StartMonitoringChildProcess 83 ( 84 Host::MonitorChildProcessCallback callback, 85 void *callback_baton, 86 lldb::pid_t pid, 87 bool monitor_signals 88 ) 89 { 90 lldb::thread_t thread = LLDB_INVALID_HOST_THREAD; 91 MonitorInfo * info_ptr = new MonitorInfo(); 92 93 info_ptr->pid = pid; 94 info_ptr->callback = callback; 95 info_ptr->callback_baton = callback_baton; 96 info_ptr->monitor_signals = monitor_signals; 97 98 char thread_name[256]; 99 ::snprintf (thread_name, sizeof(thread_name), "<lldb.host.wait4(pid=%" PRIu64 ")>", pid); 100 thread = ThreadCreate (thread_name, 101 MonitorChildProcessThreadFunction, 102 info_ptr, 103 NULL); 104 105 return thread; 106 } 107 108 //------------------------------------------------------------------ 109 // Scoped class that will disable thread canceling when it is 110 // constructed, and exception safely restore the previous value it 111 // when it goes out of scope. 112 //------------------------------------------------------------------ 113 class ScopedPThreadCancelDisabler 114 { 115 public: 116 ScopedPThreadCancelDisabler() 117 { 118 // Disable the ability for this thread to be cancelled 119 int err = ::pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &m_old_state); 120 if (err != 0) 121 m_old_state = -1; 122 123 } 124 125 ~ScopedPThreadCancelDisabler() 126 { 127 // Restore the ability for this thread to be cancelled to what it 128 // previously was. 129 if (m_old_state != -1) 130 ::pthread_setcancelstate (m_old_state, 0); 131 } 132 private: 133 int m_old_state; // Save the old cancelability state. 134 }; 135 136 static void * 137 MonitorChildProcessThreadFunction (void *arg) 138 { 139 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 140 const char *function = __FUNCTION__; 141 if (log) 142 log->Printf ("%s (arg = %p) thread starting...", function, arg); 143 144 MonitorInfo *info = (MonitorInfo *)arg; 145 146 const Host::MonitorChildProcessCallback callback = info->callback; 147 void * const callback_baton = info->callback_baton; 148 const lldb::pid_t pid = info->pid; 149 const bool monitor_signals = info->monitor_signals; 150 151 delete info; 152 153 int status = -1; 154 #if defined (__FreeBSD__) || defined (__FreeBSD_kernel__) 155 #define __WALL 0 156 #endif 157 const int options = __WALL; 158 159 while (1) 160 { 161 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 162 if (log) 163 log->Printf("%s ::wait_pid (pid = %" PRIu64 ", &status, options = %i)...", function, pid, options); 164 165 // Wait for all child processes 166 ::pthread_testcancel (); 167 // Get signals from all children with same process group of pid 168 const lldb::pid_t wait_pid = ::waitpid (-1*pid, &status, options); 169 ::pthread_testcancel (); 170 171 if (wait_pid == -1) 172 { 173 if (errno == EINTR) 174 continue; 175 else 176 { 177 if (log) 178 log->Printf ("%s (arg = %p) thread exiting because waitpid failed (%s)...", __FUNCTION__, arg, strerror(errno)); 179 break; 180 } 181 } 182 else if (wait_pid > 0) 183 { 184 bool exited = false; 185 int signal = 0; 186 int exit_status = 0; 187 const char *status_cstr = NULL; 188 if (WIFSTOPPED(status)) 189 { 190 signal = WSTOPSIG(status); 191 status_cstr = "STOPPED"; 192 } 193 else if (WIFEXITED(status)) 194 { 195 exit_status = WEXITSTATUS(status); 196 status_cstr = "EXITED"; 197 exited = true; 198 } 199 else if (WIFSIGNALED(status)) 200 { 201 signal = WTERMSIG(status); 202 status_cstr = "SIGNALED"; 203 if (wait_pid == pid) { 204 exited = true; 205 exit_status = -1; 206 } 207 } 208 else 209 { 210 status_cstr = "(\?\?\?)"; 211 } 212 213 // Scope for pthread_cancel_disabler 214 { 215 ScopedPThreadCancelDisabler pthread_cancel_disabler; 216 217 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 218 if (log) 219 log->Printf ("%s ::waitpid (pid = %" PRIu64 ", &status, options = %i) => pid = %" PRIu64 ", status = 0x%8.8x (%s), signal = %i, exit_state = %i", 220 function, 221 wait_pid, 222 options, 223 pid, 224 status, 225 status_cstr, 226 signal, 227 exit_status); 228 229 if (exited || (signal != 0 && monitor_signals)) 230 { 231 bool callback_return = false; 232 if (callback) 233 callback_return = callback (callback_baton, wait_pid, exited, signal, exit_status); 234 235 // If our process exited, then this thread should exit 236 if (exited && wait_pid == pid) 237 { 238 if (log) 239 log->Printf ("%s (arg = %p) thread exiting because pid received exit signal...", __FUNCTION__, arg); 240 break; 241 } 242 // If the callback returns true, it means this process should 243 // exit 244 if (callback_return) 245 { 246 if (log) 247 log->Printf ("%s (arg = %p) thread exiting because callback returned true...", __FUNCTION__, arg); 248 break; 249 } 250 } 251 } 252 } 253 } 254 255 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 256 if (log) 257 log->Printf ("%s (arg = %p) thread exiting...", __FUNCTION__, arg); 258 259 return NULL; 260 } 261 262 263 void 264 Host::SystemLog (SystemLogType type, const char *format, va_list args) 265 { 266 vfprintf (stderr, format, args); 267 } 268 269 #endif // #if !defined (__APPLE__) 270 271 void 272 Host::SystemLog (SystemLogType type, const char *format, ...) 273 { 274 va_list args; 275 va_start (args, format); 276 SystemLog (type, format, args); 277 va_end (args); 278 } 279 280 size_t 281 Host::GetPageSize() 282 { 283 return ::getpagesize(); 284 } 285 286 const ArchSpec & 287 Host::GetArchitecture (SystemDefaultArchitecture arch_kind) 288 { 289 static bool g_supports_32 = false; 290 static bool g_supports_64 = false; 291 static ArchSpec g_host_arch_32; 292 static ArchSpec g_host_arch_64; 293 294 #if defined (__APPLE__) 295 296 // Apple is different in that it can support both 32 and 64 bit executables 297 // in the same operating system running concurrently. Here we detect the 298 // correct host architectures for both 32 and 64 bit including if 64 bit 299 // executables are supported on the system. 300 301 if (g_supports_32 == false && g_supports_64 == false) 302 { 303 // All apple systems support 32 bit execution. 304 g_supports_32 = true; 305 uint32_t cputype, cpusubtype; 306 uint32_t is_64_bit_capable = false; 307 size_t len = sizeof(cputype); 308 ArchSpec host_arch; 309 // These will tell us about the kernel architecture, which even on a 64 310 // bit machine can be 32 bit... 311 if (::sysctlbyname("hw.cputype", &cputype, &len, NULL, 0) == 0) 312 { 313 len = sizeof (cpusubtype); 314 if (::sysctlbyname("hw.cpusubtype", &cpusubtype, &len, NULL, 0) != 0) 315 cpusubtype = CPU_TYPE_ANY; 316 317 len = sizeof (is_64_bit_capable); 318 if (::sysctlbyname("hw.cpu64bit_capable", &is_64_bit_capable, &len, NULL, 0) == 0) 319 { 320 if (is_64_bit_capable) 321 g_supports_64 = true; 322 } 323 324 if (is_64_bit_capable) 325 { 326 #if defined (__i386__) || defined (__x86_64__) 327 if (cpusubtype == CPU_SUBTYPE_486) 328 cpusubtype = CPU_SUBTYPE_I386_ALL; 329 #endif 330 if (cputype & CPU_ARCH_ABI64) 331 { 332 // We have a 64 bit kernel on a 64 bit system 333 g_host_arch_32.SetArchitecture (eArchTypeMachO, ~(CPU_ARCH_MASK) & cputype, cpusubtype); 334 g_host_arch_64.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 335 } 336 else 337 { 338 // We have a 32 bit kernel on a 64 bit system 339 g_host_arch_32.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 340 cputype |= CPU_ARCH_ABI64; 341 g_host_arch_64.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 342 } 343 } 344 else 345 { 346 g_host_arch_32.SetArchitecture (eArchTypeMachO, cputype, cpusubtype); 347 g_host_arch_64.Clear(); 348 } 349 } 350 } 351 352 #else // #if defined (__APPLE__) 353 354 if (g_supports_32 == false && g_supports_64 == false) 355 { 356 llvm::Triple triple(llvm::sys::getDefaultTargetTriple()); 357 358 g_host_arch_32.Clear(); 359 g_host_arch_64.Clear(); 360 361 // If the OS is Linux, "unknown" in the vendor slot isn't what we want 362 // for the default triple. It's probably an artifact of config.guess. 363 if (triple.getOS() == llvm::Triple::Linux && triple.getVendor() == llvm::Triple::UnknownVendor) 364 triple.setVendorName(""); 365 366 switch (triple.getArch()) 367 { 368 default: 369 g_host_arch_32.SetTriple(triple); 370 g_supports_32 = true; 371 break; 372 373 case llvm::Triple::x86_64: 374 g_host_arch_64.SetTriple(triple); 375 g_supports_64 = true; 376 g_host_arch_32.SetTriple(triple.get32BitArchVariant()); 377 g_supports_32 = true; 378 break; 379 380 case llvm::Triple::sparcv9: 381 case llvm::Triple::ppc64: 382 g_host_arch_64.SetTriple(triple); 383 g_supports_64 = true; 384 break; 385 } 386 387 g_supports_32 = g_host_arch_32.IsValid(); 388 g_supports_64 = g_host_arch_64.IsValid(); 389 } 390 391 #endif // #else for #if defined (__APPLE__) 392 393 if (arch_kind == eSystemDefaultArchitecture32) 394 return g_host_arch_32; 395 else if (arch_kind == eSystemDefaultArchitecture64) 396 return g_host_arch_64; 397 398 if (g_supports_64) 399 return g_host_arch_64; 400 401 return g_host_arch_32; 402 } 403 404 const ConstString & 405 Host::GetVendorString() 406 { 407 static ConstString g_vendor; 408 if (!g_vendor) 409 { 410 const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture); 411 const llvm::StringRef &str_ref = host_arch.GetTriple().getVendorName(); 412 g_vendor.SetCStringWithLength(str_ref.data(), str_ref.size()); 413 } 414 return g_vendor; 415 } 416 417 const ConstString & 418 Host::GetOSString() 419 { 420 static ConstString g_os_string; 421 if (!g_os_string) 422 { 423 const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture); 424 const llvm::StringRef &str_ref = host_arch.GetTriple().getOSName(); 425 g_os_string.SetCStringWithLength(str_ref.data(), str_ref.size()); 426 } 427 return g_os_string; 428 } 429 430 const ConstString & 431 Host::GetTargetTriple() 432 { 433 static ConstString g_host_triple; 434 if (!(g_host_triple)) 435 { 436 const ArchSpec &host_arch = GetArchitecture (eSystemDefaultArchitecture); 437 g_host_triple.SetCString(host_arch.GetTriple().getTriple().c_str()); 438 } 439 return g_host_triple; 440 } 441 442 lldb::pid_t 443 Host::GetCurrentProcessID() 444 { 445 return ::getpid(); 446 } 447 448 lldb::tid_t 449 Host::GetCurrentThreadID() 450 { 451 #if defined (__APPLE__) 452 // Calling "mach_port_deallocate()" bumps the reference count on the thread 453 // port, so we need to deallocate it. mach_task_self() doesn't bump the ref 454 // count. 455 thread_port_t thread_self = mach_thread_self(); 456 mach_port_deallocate(mach_task_self(), thread_self); 457 return thread_self; 458 #elif defined(__FreeBSD__) 459 return lldb::tid_t(pthread_getthreadid_np()); 460 #elif defined(__linux__) 461 return lldb::tid_t(syscall(SYS_gettid)); 462 #else 463 return lldb::tid_t(pthread_self()); 464 #endif 465 } 466 467 lldb::thread_t 468 Host::GetCurrentThread () 469 { 470 return lldb::thread_t(pthread_self()); 471 } 472 473 const char * 474 Host::GetSignalAsCString (int signo) 475 { 476 switch (signo) 477 { 478 case SIGHUP: return "SIGHUP"; // 1 hangup 479 case SIGINT: return "SIGINT"; // 2 interrupt 480 case SIGQUIT: return "SIGQUIT"; // 3 quit 481 case SIGILL: return "SIGILL"; // 4 illegal instruction (not reset when caught) 482 case SIGTRAP: return "SIGTRAP"; // 5 trace trap (not reset when caught) 483 case SIGABRT: return "SIGABRT"; // 6 abort() 484 #if (defined(_POSIX_C_SOURCE) && !defined(_DARWIN_C_SOURCE)) 485 case SIGPOLL: return "SIGPOLL"; // 7 pollable event ([XSR] generated, not supported) 486 #endif 487 #if !defined(_POSIX_C_SOURCE) 488 case SIGEMT: return "SIGEMT"; // 7 EMT instruction 489 #endif 490 case SIGFPE: return "SIGFPE"; // 8 floating point exception 491 case SIGKILL: return "SIGKILL"; // 9 kill (cannot be caught or ignored) 492 case SIGBUS: return "SIGBUS"; // 10 bus error 493 case SIGSEGV: return "SIGSEGV"; // 11 segmentation violation 494 case SIGSYS: return "SIGSYS"; // 12 bad argument to system call 495 case SIGPIPE: return "SIGPIPE"; // 13 write on a pipe with no one to read it 496 case SIGALRM: return "SIGALRM"; // 14 alarm clock 497 case SIGTERM: return "SIGTERM"; // 15 software termination signal from kill 498 case SIGURG: return "SIGURG"; // 16 urgent condition on IO channel 499 case SIGSTOP: return "SIGSTOP"; // 17 sendable stop signal not from tty 500 case SIGTSTP: return "SIGTSTP"; // 18 stop signal from tty 501 case SIGCONT: return "SIGCONT"; // 19 continue a stopped process 502 case SIGCHLD: return "SIGCHLD"; // 20 to parent on child stop or exit 503 case SIGTTIN: return "SIGTTIN"; // 21 to readers pgrp upon background tty read 504 case SIGTTOU: return "SIGTTOU"; // 22 like TTIN for output if (tp->t_local<OSTOP) 505 #if !defined(_POSIX_C_SOURCE) 506 case SIGIO: return "SIGIO"; // 23 input/output possible signal 507 #endif 508 case SIGXCPU: return "SIGXCPU"; // 24 exceeded CPU time limit 509 case SIGXFSZ: return "SIGXFSZ"; // 25 exceeded file size limit 510 case SIGVTALRM: return "SIGVTALRM"; // 26 virtual time alarm 511 case SIGPROF: return "SIGPROF"; // 27 profiling time alarm 512 #if !defined(_POSIX_C_SOURCE) 513 case SIGWINCH: return "SIGWINCH"; // 28 window size changes 514 case SIGINFO: return "SIGINFO"; // 29 information request 515 #endif 516 case SIGUSR1: return "SIGUSR1"; // 30 user defined signal 1 517 case SIGUSR2: return "SIGUSR2"; // 31 user defined signal 2 518 default: 519 break; 520 } 521 return NULL; 522 } 523 524 void 525 Host::WillTerminate () 526 { 527 } 528 529 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined (__linux__) // see macosx/Host.mm 530 531 void 532 Host::ThreadCreated (const char *thread_name) 533 { 534 } 535 536 void 537 Host::Backtrace (Stream &strm, uint32_t max_frames) 538 { 539 // TODO: Is there a way to backtrace the current process on other systems? 540 } 541 542 size_t 543 Host::GetEnvironment (StringList &env) 544 { 545 // TODO: Is there a way to the host environment for this process on other systems? 546 return 0; 547 } 548 549 #endif // #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined (__linux__) 550 551 struct HostThreadCreateInfo 552 { 553 std::string thread_name; 554 thread_func_t thread_fptr; 555 thread_arg_t thread_arg; 556 557 HostThreadCreateInfo (const char *name, thread_func_t fptr, thread_arg_t arg) : 558 thread_name (name ? name : ""), 559 thread_fptr (fptr), 560 thread_arg (arg) 561 { 562 } 563 }; 564 565 static thread_result_t 566 ThreadCreateTrampoline (thread_arg_t arg) 567 { 568 HostThreadCreateInfo *info = (HostThreadCreateInfo *)arg; 569 Host::ThreadCreated (info->thread_name.c_str()); 570 thread_func_t thread_fptr = info->thread_fptr; 571 thread_arg_t thread_arg = info->thread_arg; 572 573 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); 574 if (log) 575 log->Printf("thread created"); 576 577 delete info; 578 return thread_fptr (thread_arg); 579 } 580 581 lldb::thread_t 582 Host::ThreadCreate 583 ( 584 const char *thread_name, 585 thread_func_t thread_fptr, 586 thread_arg_t thread_arg, 587 Error *error 588 ) 589 { 590 lldb::thread_t thread = LLDB_INVALID_HOST_THREAD; 591 592 // Host::ThreadCreateTrampoline will delete this pointer for us. 593 HostThreadCreateInfo *info_ptr = new HostThreadCreateInfo (thread_name, thread_fptr, thread_arg); 594 595 int err = ::pthread_create (&thread, NULL, ThreadCreateTrampoline, info_ptr); 596 if (err == 0) 597 { 598 if (error) 599 error->Clear(); 600 return thread; 601 } 602 603 if (error) 604 error->SetError (err, eErrorTypePOSIX); 605 606 return LLDB_INVALID_HOST_THREAD; 607 } 608 609 bool 610 Host::ThreadCancel (lldb::thread_t thread, Error *error) 611 { 612 int err = ::pthread_cancel (thread); 613 if (error) 614 error->SetError(err, eErrorTypePOSIX); 615 return err == 0; 616 } 617 618 bool 619 Host::ThreadDetach (lldb::thread_t thread, Error *error) 620 { 621 int err = ::pthread_detach (thread); 622 if (error) 623 error->SetError(err, eErrorTypePOSIX); 624 return err == 0; 625 } 626 627 bool 628 Host::ThreadJoin (lldb::thread_t thread, thread_result_t *thread_result_ptr, Error *error) 629 { 630 int err = ::pthread_join (thread, thread_result_ptr); 631 if (error) 632 error->SetError(err, eErrorTypePOSIX); 633 return err == 0; 634 } 635 636 bool 637 Host::SetThreadName (lldb::pid_t pid, lldb::tid_t tid, const char *name) 638 { 639 #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5 640 lldb::pid_t curr_pid = Host::GetCurrentProcessID(); 641 lldb::tid_t curr_tid = Host::GetCurrentThreadID(); 642 if (pid == LLDB_INVALID_PROCESS_ID) 643 pid = curr_pid; 644 645 if (tid == LLDB_INVALID_THREAD_ID) 646 tid = curr_tid; 647 648 // Set the pthread name if possible 649 if (pid == curr_pid && tid == curr_tid) 650 { 651 if (::pthread_setname_np (name) == 0) 652 return true; 653 } 654 return false; 655 #elif defined (__FreeBSD__) 656 lldb::pid_t curr_pid = Host::GetCurrentProcessID(); 657 lldb::tid_t curr_tid = Host::GetCurrentThreadID(); 658 if (pid == LLDB_INVALID_PROCESS_ID) 659 pid = curr_pid; 660 661 if (tid == LLDB_INVALID_THREAD_ID) 662 tid = curr_tid; 663 664 // Set the pthread name if possible 665 if (pid == curr_pid && tid == curr_tid) 666 { 667 ::pthread_set_name_np (::pthread_self(), name); 668 return true; 669 } 670 return false; 671 #elif defined (__linux__) || defined (__GLIBC__) 672 void *fn = dlsym (RTLD_DEFAULT, "pthread_setname_np"); 673 if (fn) 674 { 675 lldb::pid_t curr_pid = Host::GetCurrentProcessID(); 676 lldb::tid_t curr_tid = Host::GetCurrentThreadID(); 677 if (pid == LLDB_INVALID_PROCESS_ID) 678 pid = curr_pid; 679 680 if (tid == LLDB_INVALID_THREAD_ID) 681 tid = curr_tid; 682 683 if (pid == curr_pid && tid == curr_tid) 684 { 685 int (*pthread_setname_np_func)(pthread_t thread, const char *name); 686 *reinterpret_cast<void **> (&pthread_setname_np_func) = fn; 687 688 if (pthread_setname_np_func (::pthread_self(), name) == 0) 689 return true; 690 } 691 } 692 return false; 693 #else 694 return false; 695 #endif 696 } 697 698 bool 699 Host::SetShortThreadName (lldb::pid_t pid, lldb::tid_t tid, 700 const char *thread_name, size_t len) 701 { 702 char *namebuf = (char *)::malloc (len + 1); 703 704 // Thread names are coming in like '<lldb.comm.debugger.edit>' and 705 // '<lldb.comm.debugger.editline>'. So just chopping the end of the string 706 // off leads to a lot of similar named threads. Go through the thread name 707 // and search for the last dot and use that. 708 const char *lastdot = ::strrchr (thread_name, '.'); 709 710 if (lastdot && lastdot != thread_name) 711 thread_name = lastdot + 1; 712 ::strncpy (namebuf, thread_name, len); 713 namebuf[len] = 0; 714 715 int namebuflen = strlen(namebuf); 716 if (namebuflen > 0) 717 { 718 if (namebuf[namebuflen - 1] == '(' || namebuf[namebuflen - 1] == '>') 719 { 720 // Trim off trailing '(' and '>' characters for a bit more cleanup. 721 namebuflen--; 722 namebuf[namebuflen] = 0; 723 } 724 return Host::SetThreadName (pid, tid, namebuf); 725 } 726 return false; 727 } 728 729 FileSpec 730 Host::GetProgramFileSpec () 731 { 732 static FileSpec g_program_filespec; 733 if (!g_program_filespec) 734 { 735 #if defined (__APPLE__) 736 char program_fullpath[PATH_MAX]; 737 // If DST is NULL, then return the number of bytes needed. 738 uint32_t len = sizeof(program_fullpath); 739 int err = _NSGetExecutablePath (program_fullpath, &len); 740 if (err == 0) 741 g_program_filespec.SetFile (program_fullpath, false); 742 else if (err == -1) 743 { 744 char *large_program_fullpath = (char *)::malloc (len + 1); 745 746 err = _NSGetExecutablePath (large_program_fullpath, &len); 747 if (err == 0) 748 g_program_filespec.SetFile (large_program_fullpath, false); 749 750 ::free (large_program_fullpath); 751 } 752 #elif defined (__linux__) 753 char exe_path[PATH_MAX]; 754 ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path) - 1); 755 if (len > 0) { 756 exe_path[len] = 0; 757 g_program_filespec.SetFile(exe_path, false); 758 } 759 #elif defined (__FreeBSD__) || defined (__FreeBSD_kernel__) 760 int exe_path_mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, getpid() }; 761 size_t exe_path_size; 762 if (sysctl(exe_path_mib, 4, NULL, &exe_path_size, NULL, 0) == 0) 763 { 764 char *exe_path = new char[exe_path_size]; 765 if (sysctl(exe_path_mib, 4, exe_path, &exe_path_size, NULL, 0) == 0) 766 g_program_filespec.SetFile(exe_path, false); 767 delete[] exe_path; 768 } 769 #endif 770 } 771 return g_program_filespec; 772 } 773 774 FileSpec 775 Host::GetModuleFileSpecForHostAddress (const void *host_addr) 776 { 777 FileSpec module_filespec; 778 Dl_info info; 779 if (::dladdr (host_addr, &info)) 780 { 781 if (info.dli_fname) 782 module_filespec.SetFile(info.dli_fname, true); 783 } 784 return module_filespec; 785 } 786 787 #if !defined (__APPLE__) // see Host.mm 788 789 bool 790 Host::GetBundleDirectory (const FileSpec &file, FileSpec &bundle) 791 { 792 bundle.Clear(); 793 return false; 794 } 795 796 bool 797 Host::ResolveExecutableInBundle (FileSpec &file) 798 { 799 return false; 800 } 801 #endif 802 803 // Opaque info that tracks a dynamic library that was loaded 804 struct DynamicLibraryInfo 805 { 806 DynamicLibraryInfo (const FileSpec &fs, int o, void *h) : 807 file_spec (fs), 808 open_options (o), 809 handle (h) 810 { 811 } 812 813 const FileSpec file_spec; 814 uint32_t open_options; 815 void * handle; 816 }; 817 818 void * 819 Host::DynamicLibraryOpen (const FileSpec &file_spec, uint32_t options, Error &error) 820 { 821 char path[PATH_MAX]; 822 if (file_spec.GetPath(path, sizeof(path))) 823 { 824 int mode = 0; 825 826 if (options & eDynamicLibraryOpenOptionLazy) 827 mode |= RTLD_LAZY; 828 else 829 mode |= RTLD_NOW; 830 831 832 if (options & eDynamicLibraryOpenOptionLocal) 833 mode |= RTLD_LOCAL; 834 else 835 mode |= RTLD_GLOBAL; 836 837 #ifdef LLDB_CONFIG_DLOPEN_RTLD_FIRST_SUPPORTED 838 if (options & eDynamicLibraryOpenOptionLimitGetSymbol) 839 mode |= RTLD_FIRST; 840 #endif 841 842 void * opaque = ::dlopen (path, mode); 843 844 if (opaque) 845 { 846 error.Clear(); 847 return new DynamicLibraryInfo (file_spec, options, opaque); 848 } 849 else 850 { 851 error.SetErrorString(::dlerror()); 852 } 853 } 854 else 855 { 856 error.SetErrorString("failed to extract path"); 857 } 858 return NULL; 859 } 860 861 Error 862 Host::DynamicLibraryClose (void *opaque) 863 { 864 Error error; 865 if (opaque == NULL) 866 { 867 error.SetErrorString ("invalid dynamic library handle"); 868 } 869 else 870 { 871 DynamicLibraryInfo *dylib_info = (DynamicLibraryInfo *) opaque; 872 if (::dlclose (dylib_info->handle) != 0) 873 { 874 error.SetErrorString(::dlerror()); 875 } 876 877 dylib_info->open_options = 0; 878 dylib_info->handle = 0; 879 delete dylib_info; 880 } 881 return error; 882 } 883 884 void * 885 Host::DynamicLibraryGetSymbol (void *opaque, const char *symbol_name, Error &error) 886 { 887 if (opaque == NULL) 888 { 889 error.SetErrorString ("invalid dynamic library handle"); 890 } 891 else 892 { 893 DynamicLibraryInfo *dylib_info = (DynamicLibraryInfo *) opaque; 894 895 void *symbol_addr = ::dlsym (dylib_info->handle, symbol_name); 896 if (symbol_addr) 897 { 898 #ifndef LLDB_CONFIG_DLOPEN_RTLD_FIRST_SUPPORTED 899 // This host doesn't support limiting searches to this shared library 900 // so we need to verify that the match came from this shared library 901 // if it was requested in the Host::DynamicLibraryOpen() function. 902 if (dylib_info->open_options & eDynamicLibraryOpenOptionLimitGetSymbol) 903 { 904 FileSpec match_dylib_spec (Host::GetModuleFileSpecForHostAddress (symbol_addr)); 905 if (match_dylib_spec != dylib_info->file_spec) 906 { 907 char dylib_path[PATH_MAX]; 908 if (dylib_info->file_spec.GetPath (dylib_path, sizeof(dylib_path))) 909 error.SetErrorStringWithFormat ("symbol not found in \"%s\"", dylib_path); 910 else 911 error.SetErrorString ("symbol not found"); 912 return NULL; 913 } 914 } 915 #endif 916 error.Clear(); 917 return symbol_addr; 918 } 919 else 920 { 921 error.SetErrorString(::dlerror()); 922 } 923 } 924 return NULL; 925 } 926 927 bool 928 Host::GetLLDBPath (PathType path_type, FileSpec &file_spec) 929 { 930 // To get paths related to LLDB we get the path to the executable that 931 // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB", 932 // on linux this is assumed to be the "lldb" main executable. If LLDB on 933 // linux is actually in a shared library (liblldb.so) then this function will 934 // need to be modified to "do the right thing". 935 936 switch (path_type) 937 { 938 case ePathTypeLLDBShlibDir: 939 { 940 static ConstString g_lldb_so_dir; 941 if (!g_lldb_so_dir) 942 { 943 FileSpec lldb_file_spec (Host::GetModuleFileSpecForHostAddress ((void *)Host::GetLLDBPath)); 944 g_lldb_so_dir = lldb_file_spec.GetDirectory(); 945 } 946 file_spec.GetDirectory() = g_lldb_so_dir; 947 return file_spec.GetDirectory(); 948 } 949 break; 950 951 case ePathTypeSupportExecutableDir: 952 { 953 static ConstString g_lldb_support_exe_dir; 954 if (!g_lldb_support_exe_dir) 955 { 956 FileSpec lldb_file_spec; 957 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 958 { 959 char raw_path[PATH_MAX]; 960 char resolved_path[PATH_MAX]; 961 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 962 963 #if defined (__APPLE__) 964 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 965 if (framework_pos) 966 { 967 framework_pos += strlen("LLDB.framework"); 968 #if !defined (__arm__) 969 ::strncpy (framework_pos, "/Resources", PATH_MAX - (framework_pos - raw_path)); 970 #endif 971 } 972 #endif 973 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 974 g_lldb_support_exe_dir.SetCString(resolved_path); 975 } 976 } 977 file_spec.GetDirectory() = g_lldb_support_exe_dir; 978 return file_spec.GetDirectory(); 979 } 980 break; 981 982 case ePathTypeHeaderDir: 983 { 984 static ConstString g_lldb_headers_dir; 985 if (!g_lldb_headers_dir) 986 { 987 #if defined (__APPLE__) 988 FileSpec lldb_file_spec; 989 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 990 { 991 char raw_path[PATH_MAX]; 992 char resolved_path[PATH_MAX]; 993 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 994 995 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 996 if (framework_pos) 997 { 998 framework_pos += strlen("LLDB.framework"); 999 ::strncpy (framework_pos, "/Headers", PATH_MAX - (framework_pos - raw_path)); 1000 } 1001 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 1002 g_lldb_headers_dir.SetCString(resolved_path); 1003 } 1004 #else 1005 // TODO: Anyone know how we can determine this for linux? Other systems?? 1006 g_lldb_headers_dir.SetCString ("/opt/local/include/lldb"); 1007 #endif 1008 } 1009 file_spec.GetDirectory() = g_lldb_headers_dir; 1010 return file_spec.GetDirectory(); 1011 } 1012 break; 1013 1014 #ifndef LLDB_DISABLE_PYTHON 1015 case ePathTypePythonDir: 1016 { 1017 static ConstString g_lldb_python_dir; 1018 if (!g_lldb_python_dir) 1019 { 1020 FileSpec lldb_file_spec; 1021 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 1022 { 1023 char raw_path[PATH_MAX]; 1024 char resolved_path[PATH_MAX]; 1025 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 1026 1027 #if defined (__APPLE__) 1028 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 1029 if (framework_pos) 1030 { 1031 framework_pos += strlen("LLDB.framework"); 1032 ::strncpy (framework_pos, "/Resources/Python", PATH_MAX - (framework_pos - raw_path)); 1033 } 1034 #else 1035 llvm::SmallString<256> python_version_dir; 1036 llvm::raw_svector_ostream os(python_version_dir); 1037 os << "/python" << PY_MAJOR_VERSION << '.' << PY_MINOR_VERSION << "/site-packages"; 1038 os.flush(); 1039 1040 // We may get our string truncated. Should we protect 1041 // this with an assert? 1042 1043 ::strncat(raw_path, python_version_dir.c_str(), 1044 sizeof(raw_path) - strlen(raw_path) - 1); 1045 1046 #endif 1047 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 1048 g_lldb_python_dir.SetCString(resolved_path); 1049 } 1050 } 1051 file_spec.GetDirectory() = g_lldb_python_dir; 1052 return file_spec.GetDirectory(); 1053 } 1054 break; 1055 #endif 1056 1057 case ePathTypeLLDBSystemPlugins: // System plug-ins directory 1058 { 1059 #if defined (__APPLE__) || defined(__linux__) 1060 static ConstString g_lldb_system_plugin_dir; 1061 static bool g_lldb_system_plugin_dir_located = false; 1062 if (!g_lldb_system_plugin_dir_located) 1063 { 1064 g_lldb_system_plugin_dir_located = true; 1065 #if defined (__APPLE__) 1066 FileSpec lldb_file_spec; 1067 if (GetLLDBPath (ePathTypeLLDBShlibDir, lldb_file_spec)) 1068 { 1069 char raw_path[PATH_MAX]; 1070 char resolved_path[PATH_MAX]; 1071 lldb_file_spec.GetPath(raw_path, sizeof(raw_path)); 1072 1073 char *framework_pos = ::strstr (raw_path, "LLDB.framework"); 1074 if (framework_pos) 1075 { 1076 framework_pos += strlen("LLDB.framework"); 1077 ::strncpy (framework_pos, "/Resources/PlugIns", PATH_MAX - (framework_pos - raw_path)); 1078 FileSpec::Resolve (raw_path, resolved_path, sizeof(resolved_path)); 1079 g_lldb_system_plugin_dir.SetCString(resolved_path); 1080 } 1081 return false; 1082 } 1083 #elif defined (__linux__) 1084 FileSpec lldb_file_spec("/usr/lib/lldb", true); 1085 if (lldb_file_spec.Exists()) 1086 { 1087 g_lldb_system_plugin_dir.SetCString(lldb_file_spec.GetPath().c_str()); 1088 } 1089 #endif // __APPLE__ || __linux__ 1090 } 1091 1092 if (g_lldb_system_plugin_dir) 1093 { 1094 file_spec.GetDirectory() = g_lldb_system_plugin_dir; 1095 return true; 1096 } 1097 #else 1098 // TODO: where would system LLDB plug-ins be located on other systems? 1099 return false; 1100 #endif 1101 } 1102 break; 1103 1104 case ePathTypeLLDBUserPlugins: // User plug-ins directory 1105 { 1106 #if defined (__APPLE__) 1107 static ConstString g_lldb_user_plugin_dir; 1108 if (!g_lldb_user_plugin_dir) 1109 { 1110 char user_plugin_path[PATH_MAX]; 1111 if (FileSpec::Resolve ("~/Library/Application Support/LLDB/PlugIns", 1112 user_plugin_path, 1113 sizeof(user_plugin_path))) 1114 { 1115 g_lldb_user_plugin_dir.SetCString(user_plugin_path); 1116 } 1117 } 1118 file_spec.GetDirectory() = g_lldb_user_plugin_dir; 1119 return file_spec.GetDirectory(); 1120 #elif defined (__linux__) 1121 static ConstString g_lldb_user_plugin_dir; 1122 if (!g_lldb_user_plugin_dir) 1123 { 1124 // XDG Base Directory Specification 1125 // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html 1126 // If XDG_DATA_HOME exists, use that, otherwise use ~/.local/share/lldb. 1127 FileSpec lldb_file_spec; 1128 const char *xdg_data_home = getenv("XDG_DATA_HOME"); 1129 if (xdg_data_home && xdg_data_home[0]) 1130 { 1131 std::string user_plugin_dir (xdg_data_home); 1132 user_plugin_dir += "/lldb"; 1133 lldb_file_spec.SetFile (user_plugin_dir.c_str(), true); 1134 } 1135 else 1136 { 1137 const char *home_dir = getenv("HOME"); 1138 if (home_dir && home_dir[0]) 1139 { 1140 std::string user_plugin_dir (home_dir); 1141 user_plugin_dir += "/.local/share/lldb"; 1142 lldb_file_spec.SetFile (user_plugin_dir.c_str(), true); 1143 } 1144 } 1145 1146 if (lldb_file_spec.Exists()) 1147 g_lldb_user_plugin_dir.SetCString(lldb_file_spec.GetPath().c_str()); 1148 } 1149 file_spec.GetDirectory() = g_lldb_user_plugin_dir; 1150 return file_spec.GetDirectory(); 1151 #endif 1152 // TODO: where would user LLDB plug-ins be located on other systems? 1153 return false; 1154 } 1155 } 1156 1157 return false; 1158 } 1159 1160 1161 bool 1162 Host::GetHostname (std::string &s) 1163 { 1164 char hostname[PATH_MAX]; 1165 hostname[sizeof(hostname) - 1] = '\0'; 1166 if (::gethostname (hostname, sizeof(hostname) - 1) == 0) 1167 { 1168 struct hostent* h = ::gethostbyname (hostname); 1169 if (h) 1170 s.assign (h->h_name); 1171 else 1172 s.assign (hostname); 1173 return true; 1174 } 1175 return false; 1176 } 1177 1178 const char * 1179 Host::GetUserName (uint32_t uid, std::string &user_name) 1180 { 1181 struct passwd user_info; 1182 struct passwd *user_info_ptr = &user_info; 1183 char user_buffer[PATH_MAX]; 1184 size_t user_buffer_size = sizeof(user_buffer); 1185 if (::getpwuid_r (uid, 1186 &user_info, 1187 user_buffer, 1188 user_buffer_size, 1189 &user_info_ptr) == 0) 1190 { 1191 if (user_info_ptr) 1192 { 1193 user_name.assign (user_info_ptr->pw_name); 1194 return user_name.c_str(); 1195 } 1196 } 1197 user_name.clear(); 1198 return NULL; 1199 } 1200 1201 const char * 1202 Host::GetGroupName (uint32_t gid, std::string &group_name) 1203 { 1204 char group_buffer[PATH_MAX]; 1205 size_t group_buffer_size = sizeof(group_buffer); 1206 struct group group_info; 1207 struct group *group_info_ptr = &group_info; 1208 // Try the threadsafe version first 1209 if (::getgrgid_r (gid, 1210 &group_info, 1211 group_buffer, 1212 group_buffer_size, 1213 &group_info_ptr) == 0) 1214 { 1215 if (group_info_ptr) 1216 { 1217 group_name.assign (group_info_ptr->gr_name); 1218 return group_name.c_str(); 1219 } 1220 } 1221 else 1222 { 1223 // The threadsafe version isn't currently working 1224 // for me on darwin, but the non-threadsafe version 1225 // is, so I am calling it below. 1226 group_info_ptr = ::getgrgid (gid); 1227 if (group_info_ptr) 1228 { 1229 group_name.assign (group_info_ptr->gr_name); 1230 return group_name.c_str(); 1231 } 1232 } 1233 group_name.clear(); 1234 return NULL; 1235 } 1236 1237 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) // see macosx/Host.mm 1238 bool 1239 Host::GetOSBuildString (std::string &s) 1240 { 1241 s.clear(); 1242 return false; 1243 } 1244 1245 bool 1246 Host::GetOSKernelDescription (std::string &s) 1247 { 1248 s.clear(); 1249 return false; 1250 } 1251 #endif 1252 1253 uint32_t 1254 Host::GetUserID () 1255 { 1256 return getuid(); 1257 } 1258 1259 uint32_t 1260 Host::GetGroupID () 1261 { 1262 return getgid(); 1263 } 1264 1265 uint32_t 1266 Host::GetEffectiveUserID () 1267 { 1268 return geteuid(); 1269 } 1270 1271 uint32_t 1272 Host::GetEffectiveGroupID () 1273 { 1274 return getegid(); 1275 } 1276 1277 #if !defined (__APPLE__) && !defined(__linux__) 1278 uint32_t 1279 Host::FindProcesses (const ProcessInstanceInfoMatch &match_info, ProcessInstanceInfoList &process_infos) 1280 { 1281 process_infos.Clear(); 1282 return process_infos.GetSize(); 1283 } 1284 #endif // #if !defined (__APPLE__) && !defined(__linux__) 1285 1286 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined(__linux__) 1287 bool 1288 Host::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info) 1289 { 1290 process_info.Clear(); 1291 return false; 1292 } 1293 #endif 1294 1295 #if !defined(__linux__) 1296 bool 1297 Host::FindProcessThreads (const lldb::pid_t pid, TidMap &tids_to_attach) 1298 { 1299 return false; 1300 } 1301 #endif 1302 1303 lldb::TargetSP 1304 Host::GetDummyTarget (lldb_private::Debugger &debugger) 1305 { 1306 static TargetSP g_dummy_target_sp; 1307 1308 // FIXME: Maybe the dummy target should be per-Debugger 1309 if (!g_dummy_target_sp || !g_dummy_target_sp->IsValid()) 1310 { 1311 ArchSpec arch(Target::GetDefaultArchitecture()); 1312 if (!arch.IsValid()) 1313 arch = Host::GetArchitecture (); 1314 Error err = debugger.GetTargetList().CreateTarget(debugger, 1315 NULL, 1316 arch.GetTriple().getTriple().c_str(), 1317 false, 1318 NULL, 1319 g_dummy_target_sp); 1320 } 1321 1322 return g_dummy_target_sp; 1323 } 1324 1325 struct ShellInfo 1326 { 1327 ShellInfo () : 1328 process_reaped (false), 1329 can_delete (false), 1330 pid (LLDB_INVALID_PROCESS_ID), 1331 signo(-1), 1332 status(-1) 1333 { 1334 } 1335 1336 lldb_private::Predicate<bool> process_reaped; 1337 lldb_private::Predicate<bool> can_delete; 1338 lldb::pid_t pid; 1339 int signo; 1340 int status; 1341 }; 1342 1343 static bool 1344 MonitorShellCommand (void *callback_baton, 1345 lldb::pid_t pid, 1346 bool exited, // True if the process did exit 1347 int signo, // Zero for no signal 1348 int status) // Exit value of process if signal is zero 1349 { 1350 ShellInfo *shell_info = (ShellInfo *)callback_baton; 1351 shell_info->pid = pid; 1352 shell_info->signo = signo; 1353 shell_info->status = status; 1354 // Let the thread running Host::RunShellCommand() know that the process 1355 // exited and that ShellInfo has been filled in by broadcasting to it 1356 shell_info->process_reaped.SetValue(1, eBroadcastAlways); 1357 // Now wait for a handshake back from that thread running Host::RunShellCommand 1358 // so we know that we can delete shell_info_ptr 1359 shell_info->can_delete.WaitForValueEqualTo(true); 1360 // Sleep a bit to allow the shell_info->can_delete.SetValue() to complete... 1361 usleep(1000); 1362 // Now delete the shell info that was passed into this function 1363 delete shell_info; 1364 return true; 1365 } 1366 1367 Error 1368 Host::RunShellCommand (const char *command, 1369 const char *working_dir, 1370 int *status_ptr, 1371 int *signo_ptr, 1372 std::string *command_output_ptr, 1373 uint32_t timeout_sec, 1374 const char *shell) 1375 { 1376 Error error; 1377 ProcessLaunchInfo launch_info; 1378 if (shell && shell[0]) 1379 { 1380 // Run the command in a shell 1381 launch_info.SetShell(shell); 1382 launch_info.GetArguments().AppendArgument(command); 1383 const bool localhost = true; 1384 const bool will_debug = false; 1385 const bool first_arg_is_full_shell_command = true; 1386 launch_info.ConvertArgumentsForLaunchingInShell (error, 1387 localhost, 1388 will_debug, 1389 first_arg_is_full_shell_command); 1390 } 1391 else 1392 { 1393 // No shell, just run it 1394 Args args (command); 1395 const bool first_arg_is_executable = true; 1396 launch_info.SetArguments(args, first_arg_is_executable); 1397 } 1398 1399 if (working_dir) 1400 launch_info.SetWorkingDirectory(working_dir); 1401 char output_file_path_buffer[L_tmpnam]; 1402 const char *output_file_path = NULL; 1403 if (command_output_ptr) 1404 { 1405 // Create a temporary file to get the stdout/stderr and redirect the 1406 // output of the command into this file. We will later read this file 1407 // if all goes well and fill the data into "command_output_ptr" 1408 output_file_path = ::tmpnam(output_file_path_buffer); 1409 launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false); 1410 launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_path, false, true); 1411 launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO); 1412 } 1413 else 1414 { 1415 launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false); 1416 launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true); 1417 launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true); 1418 } 1419 1420 // The process monitor callback will delete the 'shell_info_ptr' below... 1421 std::unique_ptr<ShellInfo> shell_info_ap (new ShellInfo()); 1422 1423 const bool monitor_signals = false; 1424 launch_info.SetMonitorProcessCallback(MonitorShellCommand, shell_info_ap.get(), monitor_signals); 1425 1426 error = LaunchProcess (launch_info); 1427 const lldb::pid_t pid = launch_info.GetProcessID(); 1428 if (pid != LLDB_INVALID_PROCESS_ID) 1429 { 1430 // The process successfully launched, so we can defer ownership of 1431 // "shell_info" to the MonitorShellCommand callback function that will 1432 // get called when the process dies. We release the unique pointer as it 1433 // doesn't need to delete the ShellInfo anymore. 1434 ShellInfo *shell_info = shell_info_ap.release(); 1435 TimeValue timeout_time(TimeValue::Now()); 1436 timeout_time.OffsetWithSeconds(timeout_sec); 1437 bool timed_out = false; 1438 shell_info->process_reaped.WaitForValueEqualTo(true, &timeout_time, &timed_out); 1439 if (timed_out) 1440 { 1441 error.SetErrorString("timed out waiting for shell command to complete"); 1442 1443 // Kill the process since it didn't complete withint the timeout specified 1444 ::kill (pid, SIGKILL); 1445 // Wait for the monitor callback to get the message 1446 timeout_time = TimeValue::Now(); 1447 timeout_time.OffsetWithSeconds(1); 1448 timed_out = false; 1449 shell_info->process_reaped.WaitForValueEqualTo(true, &timeout_time, &timed_out); 1450 } 1451 else 1452 { 1453 if (status_ptr) 1454 *status_ptr = shell_info->status; 1455 1456 if (signo_ptr) 1457 *signo_ptr = shell_info->signo; 1458 1459 if (command_output_ptr) 1460 { 1461 command_output_ptr->clear(); 1462 FileSpec file_spec(output_file_path, File::eOpenOptionRead); 1463 uint64_t file_size = file_spec.GetByteSize(); 1464 if (file_size > 0) 1465 { 1466 if (file_size > command_output_ptr->max_size()) 1467 { 1468 error.SetErrorStringWithFormat("shell command output is too large to fit into a std::string"); 1469 } 1470 else 1471 { 1472 command_output_ptr->resize(file_size); 1473 file_spec.ReadFileContents(0, &((*command_output_ptr)[0]), command_output_ptr->size(), &error); 1474 } 1475 } 1476 } 1477 } 1478 shell_info->can_delete.SetValue(true, eBroadcastAlways); 1479 } 1480 else 1481 { 1482 error.SetErrorString("failed to get process ID"); 1483 } 1484 1485 if (output_file_path) 1486 ::unlink (output_file_path); 1487 // Handshake with the monitor thread, or just let it know in advance that 1488 // it can delete "shell_info" in case we timed out and were not able to kill 1489 // the process... 1490 return error; 1491 } 1492 1493 1494 uint32_t 1495 Host::GetNumberCPUS () 1496 { 1497 static uint32_t g_num_cores = UINT32_MAX; 1498 if (g_num_cores == UINT32_MAX) 1499 { 1500 #if defined(__APPLE__) or defined (__linux__) or defined (__FreeBSD__) or defined (__FreeBSD_kernel__) 1501 1502 g_num_cores = ::sysconf(_SC_NPROCESSORS_ONLN); 1503 1504 #elif defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 1505 1506 // Header file for this might need to be included at the top of this file 1507 SYSTEM_INFO system_info; 1508 ::GetSystemInfo (&system_info); 1509 g_num_cores = system_info.dwNumberOfProcessors; 1510 1511 #else 1512 1513 // Assume POSIX support if a host specific case has not been supplied above 1514 g_num_cores = 0; 1515 int num_cores = 0; 1516 size_t num_cores_len = sizeof(num_cores); 1517 #ifdef HW_AVAILCPU 1518 int mib[] = { CTL_HW, HW_AVAILCPU }; 1519 #else 1520 int mib[] = { CTL_HW, HW_NCPU }; 1521 #endif 1522 1523 /* get the number of CPUs from the system */ 1524 if (sysctl(mib, sizeof(mib)/sizeof(int), &num_cores, &num_cores_len, NULL, 0) == 0 && (num_cores > 0)) 1525 { 1526 g_num_cores = num_cores; 1527 } 1528 else 1529 { 1530 mib[1] = HW_NCPU; 1531 num_cores_len = sizeof(num_cores); 1532 if (sysctl(mib, sizeof(mib)/sizeof(int), &num_cores, &num_cores_len, NULL, 0) == 0 && (num_cores > 0)) 1533 { 1534 if (num_cores > 0) 1535 g_num_cores = num_cores; 1536 } 1537 } 1538 #endif 1539 } 1540 return g_num_cores; 1541 } 1542 1543 1544 1545 #if !defined (__APPLE__) 1546 bool 1547 Host::OpenFileInExternalEditor (const FileSpec &file_spec, uint32_t line_no) 1548 { 1549 return false; 1550 } 1551 1552 void 1553 Host::SetCrashDescriptionWithFormat (const char *format, ...) 1554 { 1555 } 1556 1557 void 1558 Host::SetCrashDescription (const char *description) 1559 { 1560 } 1561 1562 lldb::pid_t 1563 LaunchApplication (const FileSpec &app_file_spec) 1564 { 1565 return LLDB_INVALID_PROCESS_ID; 1566 } 1567 1568 #endif 1569
