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 // C includes 11 #include <errno.h> 12 #include <limits.h> 13 #include <stdlib.h> 14 #include <sys/types.h> 15 #ifndef _WIN32 16 #include <unistd.h> 17 #include <dlfcn.h> 18 #include <grp.h> 19 #include <netdb.h> 20 #include <pwd.h> 21 #include <sys/stat.h> 22 #endif 23 24 #if defined (__APPLE__) 25 #include <mach/mach_port.h> 26 #include <mach/mach_init.h> 27 #include <mach-o/dyld.h> 28 #endif 29 30 #if defined (__linux__) || defined (__FreeBSD__) || defined (__FreeBSD_kernel__) || defined (__APPLE__) || defined(__NetBSD__) 31 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 32 #include <spawn.h> 33 #endif 34 #include <sys/wait.h> 35 #include <sys/syscall.h> 36 #endif 37 38 #if defined (__FreeBSD__) 39 #include <pthread_np.h> 40 #endif 41 42 // C++ includes 43 #include <limits> 44 45 #include "lldb/Host/FileSystem.h" 46 #include "lldb/Host/Host.h" 47 #include "lldb/Host/HostInfo.h" 48 #include "lldb/Core/ArchSpec.h" 49 #include "lldb/Core/Error.h" 50 #include "lldb/Core/Log.h" 51 #include "lldb/Host/FileSpec.h" 52 #include "lldb/Host/HostProcess.h" 53 #include "lldb/Host/MonitoringProcessLauncher.h" 54 #include "lldb/Host/Predicate.h" 55 #include "lldb/Host/ProcessLauncher.h" 56 #include "lldb/Host/ThreadLauncher.h" 57 #include "lldb/lldb-private-forward.h" 58 #include "llvm/Support/FileSystem.h" 59 #include "lldb/Target/FileAction.h" 60 #include "lldb/Target/ProcessLaunchInfo.h" 61 #include "lldb/Target/UnixSignals.h" 62 #include "lldb/Utility/CleanUp.h" 63 #include "llvm/ADT/SmallString.h" 64 65 #if defined(_WIN32) 66 #include "lldb/Host/windows/ProcessLauncherWindows.h" 67 #elif defined(__ANDROID__) || defined(__ANDROID_NDK__) 68 #include "lldb/Host/android/ProcessLauncherAndroid.h" 69 #else 70 #include "lldb/Host/posix/ProcessLauncherPosix.h" 71 #endif 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 #if !defined (__APPLE__) && !defined (_WIN32) 90 struct MonitorInfo 91 { 92 lldb::pid_t pid; // The process ID to monitor 93 Host::MonitorChildProcessCallback callback; // The callback function to call when "pid" exits or signals 94 void *callback_baton; // The callback baton for the callback function 95 bool monitor_signals; // If true, call the callback when "pid" gets signaled. 96 }; 97 98 static thread_result_t 99 MonitorChildProcessThreadFunction (void *arg); 100 101 HostThread 102 Host::StartMonitoringChildProcess(Host::MonitorChildProcessCallback callback, void *callback_baton, lldb::pid_t pid, bool monitor_signals) 103 { 104 MonitorInfo * info_ptr = new MonitorInfo(); 105 106 info_ptr->pid = pid; 107 info_ptr->callback = callback; 108 info_ptr->callback_baton = callback_baton; 109 info_ptr->monitor_signals = monitor_signals; 110 111 char thread_name[256]; 112 ::snprintf(thread_name, sizeof(thread_name), "<lldb.host.wait4(pid=%" PRIu64 ")>", pid); 113 return ThreadLauncher::LaunchThread(thread_name, MonitorChildProcessThreadFunction, info_ptr, NULL); 114 } 115 116 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 117 //------------------------------------------------------------------ 118 // Scoped class that will disable thread canceling when it is 119 // constructed, and exception safely restore the previous value it 120 // when it goes out of scope. 121 //------------------------------------------------------------------ 122 class ScopedPThreadCancelDisabler 123 { 124 public: 125 ScopedPThreadCancelDisabler() 126 { 127 // Disable the ability for this thread to be cancelled 128 int err = ::pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &m_old_state); 129 if (err != 0) 130 m_old_state = -1; 131 } 132 133 ~ScopedPThreadCancelDisabler() 134 { 135 // Restore the ability for this thread to be cancelled to what it 136 // previously was. 137 if (m_old_state != -1) 138 ::pthread_setcancelstate (m_old_state, 0); 139 } 140 private: 141 int m_old_state; // Save the old cancelability state. 142 }; 143 #endif // __ANDROID_NDK__ 144 145 static thread_result_t 146 MonitorChildProcessThreadFunction (void *arg) 147 { 148 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); 149 const char *function = __FUNCTION__; 150 if (log) 151 log->Printf ("%s (arg = %p) thread starting...", function, arg); 152 153 MonitorInfo *info = (MonitorInfo *)arg; 154 155 const Host::MonitorChildProcessCallback callback = info->callback; 156 void * const callback_baton = info->callback_baton; 157 const bool monitor_signals = info->monitor_signals; 158 159 assert (info->pid <= UINT32_MAX); 160 const ::pid_t pid = monitor_signals ? -1 * getpgid(info->pid) : info->pid; 161 162 delete info; 163 164 int status = -1; 165 #if defined (__FreeBSD__) || defined (__FreeBSD_kernel__) 166 #define __WALL 0 167 #endif 168 const int options = __WALL; 169 170 while (1) 171 { 172 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 173 if (log) 174 log->Printf("%s ::waitpid (pid = %" PRIi32 ", &status, options = %i)...", function, pid, options); 175 176 // Wait for all child processes 177 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 178 ::pthread_testcancel (); 179 #endif 180 // Get signals from all children with same process group of pid 181 const ::pid_t wait_pid = ::waitpid (pid, &status, options); 182 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 183 ::pthread_testcancel (); 184 #endif 185 if (wait_pid == -1) 186 { 187 if (errno == EINTR) 188 continue; 189 else 190 { 191 if (log) 192 log->Printf ("%s (arg = %p) thread exiting because waitpid failed (%s)...", __FUNCTION__, arg, strerror(errno)); 193 break; 194 } 195 } 196 else if (wait_pid > 0) 197 { 198 bool exited = false; 199 int signal = 0; 200 int exit_status = 0; 201 const char *status_cstr = NULL; 202 if (WIFSTOPPED(status)) 203 { 204 signal = WSTOPSIG(status); 205 status_cstr = "STOPPED"; 206 } 207 else if (WIFEXITED(status)) 208 { 209 exit_status = WEXITSTATUS(status); 210 status_cstr = "EXITED"; 211 exited = true; 212 } 213 else if (WIFSIGNALED(status)) 214 { 215 signal = WTERMSIG(status); 216 status_cstr = "SIGNALED"; 217 if (wait_pid == abs(pid)) { 218 exited = true; 219 exit_status = -1; 220 } 221 } 222 else 223 { 224 status_cstr = "(\?\?\?)"; 225 } 226 227 // Scope for pthread_cancel_disabler 228 { 229 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 230 ScopedPThreadCancelDisabler pthread_cancel_disabler; 231 #endif 232 233 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 234 if (log) 235 log->Printf ("%s ::waitpid (pid = %" PRIi32 ", &status, options = %i) => pid = %" PRIi32 ", status = 0x%8.8x (%s), signal = %i, exit_state = %i", 236 function, 237 pid, 238 options, 239 wait_pid, 240 status, 241 status_cstr, 242 signal, 243 exit_status); 244 245 if (exited || (signal != 0 && monitor_signals)) 246 { 247 bool callback_return = false; 248 if (callback) 249 callback_return = callback (callback_baton, wait_pid, exited, signal, exit_status); 250 251 // If our process exited, then this thread should exit 252 if (exited && wait_pid == abs(pid)) 253 { 254 if (log) 255 log->Printf ("%s (arg = %p) thread exiting because pid received exit signal...", __FUNCTION__, arg); 256 break; 257 } 258 // If the callback returns true, it means this process should 259 // exit 260 if (callback_return) 261 { 262 if (log) 263 log->Printf ("%s (arg = %p) thread exiting because callback returned true...", __FUNCTION__, arg); 264 break; 265 } 266 } 267 } 268 } 269 } 270 271 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS); 272 if (log) 273 log->Printf ("%s (arg = %p) thread exiting...", __FUNCTION__, arg); 274 275 return NULL; 276 } 277 278 #endif // #if !defined (__APPLE__) && !defined (_WIN32) 279 280 #if !defined (__APPLE__) 281 282 void 283 Host::SystemLog (SystemLogType type, const char *format, va_list args) 284 { 285 vfprintf (stderr, format, args); 286 } 287 288 #endif 289 290 void 291 Host::SystemLog (SystemLogType type, const char *format, ...) 292 { 293 va_list args; 294 va_start (args, format); 295 SystemLog (type, format, args); 296 va_end (args); 297 } 298 299 lldb::pid_t 300 Host::GetCurrentProcessID() 301 { 302 return ::getpid(); 303 } 304 305 #ifndef _WIN32 306 307 lldb::tid_t 308 Host::GetCurrentThreadID() 309 { 310 #if defined (__APPLE__) 311 // Calling "mach_thread_self()" bumps the reference count on the thread 312 // port, so we need to deallocate it. mach_task_self() doesn't bump the ref 313 // count. 314 thread_port_t thread_self = mach_thread_self(); 315 mach_port_deallocate(mach_task_self(), thread_self); 316 return thread_self; 317 #elif defined(__FreeBSD__) 318 return lldb::tid_t(pthread_getthreadid_np()); 319 #elif defined(__ANDROID_NDK__) 320 return lldb::tid_t(gettid()); 321 #elif defined(__linux__) 322 return lldb::tid_t(syscall(SYS_gettid)); 323 #else 324 return lldb::tid_t(pthread_self()); 325 #endif 326 } 327 328 lldb::thread_t 329 Host::GetCurrentThread () 330 { 331 return lldb::thread_t(pthread_self()); 332 } 333 334 const char * 335 Host::GetSignalAsCString (int signo) 336 { 337 switch (signo) 338 { 339 case SIGHUP: return "SIGHUP"; // 1 hangup 340 case SIGINT: return "SIGINT"; // 2 interrupt 341 case SIGQUIT: return "SIGQUIT"; // 3 quit 342 case SIGILL: return "SIGILL"; // 4 illegal instruction (not reset when caught) 343 case SIGTRAP: return "SIGTRAP"; // 5 trace trap (not reset when caught) 344 case SIGABRT: return "SIGABRT"; // 6 abort() 345 #if defined(SIGPOLL) 346 #if !defined(SIGIO) || (SIGPOLL != SIGIO) 347 // Under some GNU/Linux, SIGPOLL and SIGIO are the same. Causing the build to 348 // fail with 'multiple define cases with same value' 349 case SIGPOLL: return "SIGPOLL"; // 7 pollable event ([XSR] generated, not supported) 350 #endif 351 #endif 352 #if defined(SIGEMT) 353 case SIGEMT: return "SIGEMT"; // 7 EMT instruction 354 #endif 355 case SIGFPE: return "SIGFPE"; // 8 floating point exception 356 case SIGKILL: return "SIGKILL"; // 9 kill (cannot be caught or ignored) 357 case SIGBUS: return "SIGBUS"; // 10 bus error 358 case SIGSEGV: return "SIGSEGV"; // 11 segmentation violation 359 case SIGSYS: return "SIGSYS"; // 12 bad argument to system call 360 case SIGPIPE: return "SIGPIPE"; // 13 write on a pipe with no one to read it 361 case SIGALRM: return "SIGALRM"; // 14 alarm clock 362 case SIGTERM: return "SIGTERM"; // 15 software termination signal from kill 363 case SIGURG: return "SIGURG"; // 16 urgent condition on IO channel 364 case SIGSTOP: return "SIGSTOP"; // 17 sendable stop signal not from tty 365 case SIGTSTP: return "SIGTSTP"; // 18 stop signal from tty 366 case SIGCONT: return "SIGCONT"; // 19 continue a stopped process 367 case SIGCHLD: return "SIGCHLD"; // 20 to parent on child stop or exit 368 case SIGTTIN: return "SIGTTIN"; // 21 to readers pgrp upon background tty read 369 case SIGTTOU: return "SIGTTOU"; // 22 like TTIN for output if (tp->t_local<OSTOP) 370 #if defined(SIGIO) 371 case SIGIO: return "SIGIO"; // 23 input/output possible signal 372 #endif 373 case SIGXCPU: return "SIGXCPU"; // 24 exceeded CPU time limit 374 case SIGXFSZ: return "SIGXFSZ"; // 25 exceeded file size limit 375 case SIGVTALRM: return "SIGVTALRM"; // 26 virtual time alarm 376 case SIGPROF: return "SIGPROF"; // 27 profiling time alarm 377 #if defined(SIGWINCH) 378 case SIGWINCH: return "SIGWINCH"; // 28 window size changes 379 #endif 380 #if defined(SIGINFO) 381 case SIGINFO: return "SIGINFO"; // 29 information request 382 #endif 383 case SIGUSR1: return "SIGUSR1"; // 30 user defined signal 1 384 case SIGUSR2: return "SIGUSR2"; // 31 user defined signal 2 385 default: 386 break; 387 } 388 return NULL; 389 } 390 391 #endif 392 393 void 394 Host::WillTerminate () 395 { 396 } 397 398 #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined (__linux__) // see macosx/Host.mm 399 400 void 401 Host::Backtrace (Stream &strm, uint32_t max_frames) 402 { 403 // TODO: Is there a way to backtrace the current process on other systems? 404 } 405 406 size_t 407 Host::GetEnvironment (StringList &env) 408 { 409 // TODO: Is there a way to the host environment for this process on other systems? 410 return 0; 411 } 412 413 #endif // #if !defined (__APPLE__) && !defined (__FreeBSD__) && !defined (__FreeBSD_kernel__) && !defined (__linux__) 414 415 #ifndef _WIN32 416 417 lldb::thread_key_t 418 Host::ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback) 419 { 420 pthread_key_t key; 421 ::pthread_key_create (&key, callback); 422 return key; 423 } 424 425 void* 426 Host::ThreadLocalStorageGet(lldb::thread_key_t key) 427 { 428 return ::pthread_getspecific (key); 429 } 430 431 void 432 Host::ThreadLocalStorageSet(lldb::thread_key_t key, void *value) 433 { 434 ::pthread_setspecific (key, value); 435 } 436 437 #endif 438 439 #if !defined (__APPLE__) // see Host.mm 440 441 bool 442 Host::GetBundleDirectory (const FileSpec &file, FileSpec &bundle) 443 { 444 bundle.Clear(); 445 return false; 446 } 447 448 bool 449 Host::ResolveExecutableInBundle (FileSpec &file) 450 { 451 return false; 452 } 453 #endif 454 455 #ifndef _WIN32 456 457 FileSpec 458 Host::GetModuleFileSpecForHostAddress (const void *host_addr) 459 { 460 FileSpec module_filespec; 461 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 462 Dl_info info; 463 if (::dladdr (host_addr, &info)) 464 { 465 if (info.dli_fname) 466 module_filespec.SetFile(info.dli_fname, true); 467 } 468 #else 469 assert(false && "dladdr() not supported on Android"); 470 #endif 471 return module_filespec; 472 } 473 474 #endif 475 476 #if !defined(__linux__) 477 bool 478 Host::FindProcessThreads (const lldb::pid_t pid, TidMap &tids_to_attach) 479 { 480 return false; 481 } 482 #endif 483 484 struct ShellInfo 485 { 486 ShellInfo () : 487 process_reaped (false), 488 can_delete (false), 489 pid (LLDB_INVALID_PROCESS_ID), 490 signo(-1), 491 status(-1) 492 { 493 } 494 495 lldb_private::Predicate<bool> process_reaped; 496 lldb_private::Predicate<bool> can_delete; 497 lldb::pid_t pid; 498 int signo; 499 int status; 500 }; 501 502 static bool 503 MonitorShellCommand (void *callback_baton, 504 lldb::pid_t pid, 505 bool exited, // True if the process did exit 506 int signo, // Zero for no signal 507 int status) // Exit value of process if signal is zero 508 { 509 ShellInfo *shell_info = (ShellInfo *)callback_baton; 510 shell_info->pid = pid; 511 shell_info->signo = signo; 512 shell_info->status = status; 513 // Let the thread running Host::RunShellCommand() know that the process 514 // exited and that ShellInfo has been filled in by broadcasting to it 515 shell_info->process_reaped.SetValue(1, eBroadcastAlways); 516 // Now wait for a handshake back from that thread running Host::RunShellCommand 517 // so we know that we can delete shell_info_ptr 518 shell_info->can_delete.WaitForValueEqualTo(true); 519 // Sleep a bit to allow the shell_info->can_delete.SetValue() to complete... 520 usleep(1000); 521 // Now delete the shell info that was passed into this function 522 delete shell_info; 523 return true; 524 } 525 526 Error 527 Host::RunShellCommand (const char *command, 528 const char *working_dir, 529 int *status_ptr, 530 int *signo_ptr, 531 std::string *command_output_ptr, 532 uint32_t timeout_sec, 533 bool run_in_default_shell) 534 { 535 Error error; 536 ProcessLaunchInfo launch_info; 537 launch_info.SetArchitecture(HostInfo::GetArchitecture()); 538 if (run_in_default_shell) 539 { 540 // Run the command in a shell 541 launch_info.SetShell(HostInfo::GetDefaultShell()); 542 launch_info.GetArguments().AppendArgument(command); 543 const bool localhost = true; 544 const bool will_debug = false; 545 const bool first_arg_is_full_shell_command = true; 546 launch_info.ConvertArgumentsForLaunchingInShell (error, 547 localhost, 548 will_debug, 549 first_arg_is_full_shell_command, 550 0); 551 } 552 else 553 { 554 // No shell, just run it 555 Args args (command); 556 const bool first_arg_is_executable = true; 557 launch_info.SetArguments(args, first_arg_is_executable); 558 } 559 560 if (working_dir) 561 launch_info.SetWorkingDirectory(working_dir); 562 llvm::SmallString<PATH_MAX> output_file_path; 563 564 if (command_output_ptr) 565 { 566 // Create a temporary file to get the stdout/stderr and redirect the 567 // output of the command into this file. We will later read this file 568 // if all goes well and fill the data into "command_output_ptr" 569 FileSpec tmpdir_file_spec; 570 if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) 571 { 572 tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%"); 573 llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath().c_str(), output_file_path); 574 } 575 else 576 { 577 llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "", output_file_path); 578 } 579 } 580 581 launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false); 582 if (!output_file_path.empty()) 583 { 584 launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_path.c_str(), false, true); 585 launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO); 586 } 587 else 588 { 589 launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true); 590 launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true); 591 } 592 593 // The process monitor callback will delete the 'shell_info_ptr' below... 594 std::unique_ptr<ShellInfo> shell_info_ap (new ShellInfo()); 595 596 const bool monitor_signals = false; 597 launch_info.SetMonitorProcessCallback(MonitorShellCommand, shell_info_ap.get(), monitor_signals); 598 599 error = LaunchProcess (launch_info); 600 const lldb::pid_t pid = launch_info.GetProcessID(); 601 602 if (error.Success() && pid == LLDB_INVALID_PROCESS_ID) 603 error.SetErrorString("failed to get process ID"); 604 605 if (error.Success()) 606 { 607 // The process successfully launched, so we can defer ownership of 608 // "shell_info" to the MonitorShellCommand callback function that will 609 // get called when the process dies. We release the unique pointer as it 610 // doesn't need to delete the ShellInfo anymore. 611 ShellInfo *shell_info = shell_info_ap.release(); 612 TimeValue *timeout_ptr = nullptr; 613 TimeValue timeout_time(TimeValue::Now()); 614 if (timeout_sec > 0) { 615 timeout_time.OffsetWithSeconds(timeout_sec); 616 timeout_ptr = &timeout_time; 617 } 618 bool timed_out = false; 619 shell_info->process_reaped.WaitForValueEqualTo(true, timeout_ptr, &timed_out); 620 if (timed_out) 621 { 622 error.SetErrorString("timed out waiting for shell command to complete"); 623 624 // Kill the process since it didn't complete within the timeout specified 625 Kill (pid, SIGKILL); 626 // Wait for the monitor callback to get the message 627 timeout_time = TimeValue::Now(); 628 timeout_time.OffsetWithSeconds(1); 629 timed_out = false; 630 shell_info->process_reaped.WaitForValueEqualTo(true, &timeout_time, &timed_out); 631 } 632 else 633 { 634 if (status_ptr) 635 *status_ptr = shell_info->status; 636 637 if (signo_ptr) 638 *signo_ptr = shell_info->signo; 639 640 if (command_output_ptr) 641 { 642 command_output_ptr->clear(); 643 FileSpec file_spec(output_file_path.c_str(), File::eOpenOptionRead); 644 uint64_t file_size = file_spec.GetByteSize(); 645 if (file_size > 0) 646 { 647 if (file_size > command_output_ptr->max_size()) 648 { 649 error.SetErrorStringWithFormat("shell command output is too large to fit into a std::string"); 650 } 651 else 652 { 653 command_output_ptr->resize(file_size); 654 file_spec.ReadFileContents(0, &((*command_output_ptr)[0]), command_output_ptr->size(), &error); 655 } 656 } 657 } 658 } 659 shell_info->can_delete.SetValue(true, eBroadcastAlways); 660 } 661 662 FileSpec output_file_spec(output_file_path.c_str(), false); 663 if (FileSystem::GetFileExists(output_file_spec)) 664 FileSystem::Unlink(output_file_path.c_str()); 665 // Handshake with the monitor thread, or just let it know in advance that 666 // it can delete "shell_info" in case we timed out and were not able to kill 667 // the process... 668 return error; 669 } 670 671 672 // LaunchProcessPosixSpawn for Apple, Linux, FreeBSD and other GLIBC 673 // systems 674 675 #if defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) || defined (__GLIBC__) || defined(__NetBSD__) 676 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 677 // this method needs to be visible to macosx/Host.cpp and 678 // common/Host.cpp. 679 680 short 681 Host::GetPosixspawnFlags(const ProcessLaunchInfo &launch_info) 682 { 683 short flags = POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK; 684 685 #if defined (__APPLE__) 686 if (launch_info.GetFlags().Test (eLaunchFlagExec)) 687 flags |= POSIX_SPAWN_SETEXEC; // Darwin specific posix_spawn flag 688 689 if (launch_info.GetFlags().Test (eLaunchFlagDebug)) 690 flags |= POSIX_SPAWN_START_SUSPENDED; // Darwin specific posix_spawn flag 691 692 if (launch_info.GetFlags().Test (eLaunchFlagDisableASLR)) 693 flags |= _POSIX_SPAWN_DISABLE_ASLR; // Darwin specific posix_spawn flag 694 695 if (launch_info.GetLaunchInSeparateProcessGroup()) 696 flags |= POSIX_SPAWN_SETPGROUP; 697 698 #ifdef POSIX_SPAWN_CLOEXEC_DEFAULT 699 #if defined (__APPLE__) && (defined (__x86_64__) || defined (__i386__)) 700 static LazyBool g_use_close_on_exec_flag = eLazyBoolCalculate; 701 if (g_use_close_on_exec_flag == eLazyBoolCalculate) 702 { 703 g_use_close_on_exec_flag = eLazyBoolNo; 704 705 uint32_t major, minor, update; 706 if (HostInfo::GetOSVersion(major, minor, update)) 707 { 708 // Kernel panic if we use the POSIX_SPAWN_CLOEXEC_DEFAULT on 10.7 or earlier 709 if (major > 10 || (major == 10 && minor > 7)) 710 { 711 // Only enable for 10.8 and later OS versions 712 g_use_close_on_exec_flag = eLazyBoolYes; 713 } 714 } 715 } 716 #else 717 static LazyBool g_use_close_on_exec_flag = eLazyBoolYes; 718 #endif 719 // Close all files exception those with file actions if this is supported. 720 if (g_use_close_on_exec_flag == eLazyBoolYes) 721 flags |= POSIX_SPAWN_CLOEXEC_DEFAULT; 722 #endif 723 #endif // #if defined (__APPLE__) 724 return flags; 725 } 726 727 Error 728 Host::LaunchProcessPosixSpawn(const char *exe_path, const ProcessLaunchInfo &launch_info, lldb::pid_t &pid) 729 { 730 Error error; 731 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_PROCESS)); 732 733 posix_spawnattr_t attr; 734 error.SetError( ::posix_spawnattr_init (&attr), eErrorTypePOSIX); 735 736 if (error.Fail() || log) 737 error.PutToLog(log, "::posix_spawnattr_init ( &attr )"); 738 if (error.Fail()) 739 return error; 740 741 // Make a quick class that will cleanup the posix spawn attributes in case 742 // we return in the middle of this function. 743 lldb_utility::CleanUp <posix_spawnattr_t *, int> posix_spawnattr_cleanup(&attr, posix_spawnattr_destroy); 744 745 sigset_t no_signals; 746 sigset_t all_signals; 747 sigemptyset (&no_signals); 748 sigfillset (&all_signals); 749 ::posix_spawnattr_setsigmask(&attr, &no_signals); 750 #if defined (__linux__) || defined (__FreeBSD__) 751 ::posix_spawnattr_setsigdefault(&attr, &no_signals); 752 #else 753 ::posix_spawnattr_setsigdefault(&attr, &all_signals); 754 #endif 755 756 short flags = GetPosixspawnFlags(launch_info); 757 758 error.SetError( ::posix_spawnattr_setflags (&attr, flags), eErrorTypePOSIX); 759 if (error.Fail() || log) 760 error.PutToLog(log, "::posix_spawnattr_setflags ( &attr, flags=0x%8.8x )", flags); 761 if (error.Fail()) 762 return error; 763 764 // posix_spawnattr_setbinpref_np appears to be an Apple extension per: 765 // http://www.unix.com/man-page/OSX/3/posix_spawnattr_setbinpref_np/ 766 #if defined (__APPLE__) && !defined (__arm__) 767 768 // Don't set the binpref if a shell was provided. After all, that's only going to affect what version of the shell 769 // is launched, not what fork of the binary is launched. We insert "arch --arch <ARCH> as part of the shell invocation 770 // to do that job on OSX. 771 772 if (launch_info.GetShell() == nullptr) 773 { 774 // We don't need to do this for ARM, and we really shouldn't now that we 775 // have multiple CPU subtypes and no posix_spawnattr call that allows us 776 // to set which CPU subtype to launch... 777 const ArchSpec &arch_spec = launch_info.GetArchitecture(); 778 cpu_type_t cpu = arch_spec.GetMachOCPUType(); 779 cpu_type_t sub = arch_spec.GetMachOCPUSubType(); 780 if (cpu != 0 && 781 cpu != static_cast<cpu_type_t>(UINT32_MAX) && 782 cpu != static_cast<cpu_type_t>(LLDB_INVALID_CPUTYPE) && 783 !(cpu == 0x01000007 && sub == 8)) // If haswell is specified, don't try to set the CPU type or we will fail 784 { 785 size_t ocount = 0; 786 error.SetError( ::posix_spawnattr_setbinpref_np (&attr, 1, &cpu, &ocount), eErrorTypePOSIX); 787 if (error.Fail() || log) 788 error.PutToLog(log, "::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = 0x%8.8x, count => %llu )", cpu, (uint64_t)ocount); 789 790 if (error.Fail() || ocount != 1) 791 return error; 792 } 793 } 794 795 #endif 796 797 const char *tmp_argv[2]; 798 char * const *argv = (char * const*)launch_info.GetArguments().GetConstArgumentVector(); 799 char * const *envp = (char * const*)launch_info.GetEnvironmentEntries().GetConstArgumentVector(); 800 if (argv == NULL) 801 { 802 // posix_spawn gets very unhappy if it doesn't have at least the program 803 // name in argv[0]. One of the side affects I have noticed is the environment 804 // variables don't make it into the child process if "argv == NULL"!!! 805 tmp_argv[0] = exe_path; 806 tmp_argv[1] = NULL; 807 argv = (char * const*)tmp_argv; 808 } 809 810 #if !defined (__APPLE__) 811 // manage the working directory 812 char current_dir[PATH_MAX]; 813 current_dir[0] = '\0'; 814 #endif 815 816 const char *working_dir = launch_info.GetWorkingDirectory(); 817 if (working_dir) 818 { 819 #if defined (__APPLE__) 820 // Set the working directory on this thread only 821 if (__pthread_chdir (working_dir) < 0) { 822 if (errno == ENOENT) { 823 error.SetErrorStringWithFormat("No such file or directory: %s", working_dir); 824 } else if (errno == ENOTDIR) { 825 error.SetErrorStringWithFormat("Path doesn't name a directory: %s", working_dir); 826 } else { 827 error.SetErrorStringWithFormat("An unknown error occurred when changing directory for process execution."); 828 } 829 return error; 830 } 831 #else 832 if (::getcwd(current_dir, sizeof(current_dir)) == NULL) 833 { 834 error.SetError(errno, eErrorTypePOSIX); 835 error.LogIfError(log, "unable to save the current directory"); 836 return error; 837 } 838 839 if (::chdir(working_dir) == -1) 840 { 841 error.SetError(errno, eErrorTypePOSIX); 842 error.LogIfError(log, "unable to change working directory to %s", working_dir); 843 return error; 844 } 845 #endif 846 } 847 848 ::pid_t result_pid = LLDB_INVALID_PROCESS_ID; 849 const size_t num_file_actions = launch_info.GetNumFileActions (); 850 if (num_file_actions > 0) 851 { 852 posix_spawn_file_actions_t file_actions; 853 error.SetError( ::posix_spawn_file_actions_init (&file_actions), eErrorTypePOSIX); 854 if (error.Fail() || log) 855 error.PutToLog(log, "::posix_spawn_file_actions_init ( &file_actions )"); 856 if (error.Fail()) 857 return error; 858 859 // Make a quick class that will cleanup the posix spawn attributes in case 860 // we return in the middle of this function. 861 lldb_utility::CleanUp <posix_spawn_file_actions_t *, int> posix_spawn_file_actions_cleanup (&file_actions, posix_spawn_file_actions_destroy); 862 863 for (size_t i=0; i<num_file_actions; ++i) 864 { 865 const FileAction *launch_file_action = launch_info.GetFileActionAtIndex(i); 866 if (launch_file_action) 867 { 868 if (!AddPosixSpawnFileAction(&file_actions, launch_file_action, log, error)) 869 return error; 870 } 871 } 872 873 error.SetError(::posix_spawnp(&result_pid, exe_path, &file_actions, &attr, argv, envp), eErrorTypePOSIX); 874 875 if (error.Fail() || log) 876 { 877 error.PutToLog(log, "::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", result_pid, 878 exe_path, static_cast<void *>(&file_actions), static_cast<void *>(&attr), reinterpret_cast<const void *>(argv), 879 reinterpret_cast<const void *>(envp)); 880 if (log) 881 { 882 for (int ii=0; argv[ii]; ++ii) 883 log->Printf("argv[%i] = '%s'", ii, argv[ii]); 884 } 885 } 886 887 } 888 else 889 { 890 error.SetError(::posix_spawnp(&result_pid, exe_path, NULL, &attr, argv, envp), eErrorTypePOSIX); 891 892 if (error.Fail() || log) 893 { 894 error.PutToLog(log, "::posix_spawnp ( pid => %i, path = '%s', file_actions = NULL, attr = %p, argv = %p, envp = %p )", 895 result_pid, exe_path, static_cast<void *>(&attr), reinterpret_cast<const void *>(argv), 896 reinterpret_cast<const void *>(envp)); 897 if (log) 898 { 899 for (int ii=0; argv[ii]; ++ii) 900 log->Printf("argv[%i] = '%s'", ii, argv[ii]); 901 } 902 } 903 } 904 pid = result_pid; 905 906 if (working_dir) 907 { 908 #if defined (__APPLE__) 909 // No more thread specific current working directory 910 __pthread_fchdir (-1); 911 #else 912 if (::chdir(current_dir) == -1 && error.Success()) 913 { 914 error.SetError(errno, eErrorTypePOSIX); 915 error.LogIfError(log, "unable to change current directory back to %s", 916 current_dir); 917 } 918 #endif 919 } 920 921 return error; 922 } 923 924 bool 925 Host::AddPosixSpawnFileAction(void *_file_actions, const FileAction *info, Log *log, Error &error) 926 { 927 if (info == NULL) 928 return false; 929 930 posix_spawn_file_actions_t *file_actions = reinterpret_cast<posix_spawn_file_actions_t *>(_file_actions); 931 932 switch (info->GetAction()) 933 { 934 case FileAction::eFileActionNone: 935 error.Clear(); 936 break; 937 938 case FileAction::eFileActionClose: 939 if (info->GetFD() == -1) 940 error.SetErrorString("invalid fd for posix_spawn_file_actions_addclose(...)"); 941 else 942 { 943 error.SetError(::posix_spawn_file_actions_addclose(file_actions, info->GetFD()), eErrorTypePOSIX); 944 if (log && (error.Fail() || log)) 945 error.PutToLog(log, "posix_spawn_file_actions_addclose (action=%p, fd=%i)", 946 static_cast<void *>(file_actions), info->GetFD()); 947 } 948 break; 949 950 case FileAction::eFileActionDuplicate: 951 if (info->GetFD() == -1) 952 error.SetErrorString("invalid fd for posix_spawn_file_actions_adddup2(...)"); 953 else if (info->GetActionArgument() == -1) 954 error.SetErrorString("invalid duplicate fd for posix_spawn_file_actions_adddup2(...)"); 955 else 956 { 957 error.SetError( 958 ::posix_spawn_file_actions_adddup2(file_actions, info->GetFD(), info->GetActionArgument()), 959 eErrorTypePOSIX); 960 if (log && (error.Fail() || log)) 961 error.PutToLog(log, "posix_spawn_file_actions_adddup2 (action=%p, fd=%i, dup_fd=%i)", 962 static_cast<void *>(file_actions), info->GetFD(), info->GetActionArgument()); 963 } 964 break; 965 966 case FileAction::eFileActionOpen: 967 if (info->GetFD() == -1) 968 error.SetErrorString("invalid fd in posix_spawn_file_actions_addopen(...)"); 969 else 970 { 971 int oflag = info->GetActionArgument(); 972 973 mode_t mode = 0; 974 975 if (oflag & O_CREAT) 976 mode = 0640; 977 978 error.SetError( 979 ::posix_spawn_file_actions_addopen(file_actions, info->GetFD(), info->GetPath(), oflag, mode), 980 eErrorTypePOSIX); 981 if (error.Fail() || log) 982 error.PutToLog(log, 983 "posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)", 984 static_cast<void *>(file_actions), info->GetFD(), info->GetPath(), oflag, mode); 985 } 986 break; 987 } 988 return error.Success(); 989 } 990 #endif // !defined(__ANDROID__) && !defined(__ANDROID_NDK__) 991 #endif // defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) || defined (__GLIBC__) || defined(__NetBSD__) 992 993 #if defined(__linux__) || defined(__FreeBSD__) || defined(__GLIBC__) || defined(__NetBSD__) || defined(_WIN32) 994 // The functions below implement process launching via posix_spawn() for Linux, 995 // FreeBSD and NetBSD. 996 997 Error 998 Host::LaunchProcess (ProcessLaunchInfo &launch_info) 999 { 1000 std::unique_ptr<ProcessLauncher> delegate_launcher; 1001 #if defined(_WIN32) 1002 delegate_launcher.reset(new ProcessLauncherWindows()); 1003 #elif defined(__ANDROID__) || defined(__ANDROID_NDK__) 1004 delegate_launcher.reset(new ProcessLauncherAndroid()); 1005 #else 1006 delegate_launcher.reset(new ProcessLauncherPosix()); 1007 #endif 1008 MonitoringProcessLauncher launcher(std::move(delegate_launcher)); 1009 1010 Error error; 1011 HostProcess process = launcher.LaunchProcess(launch_info, error); 1012 1013 // TODO(zturner): It would be better if the entire HostProcess were returned instead of writing 1014 // it into this structure. 1015 launch_info.SetProcessID(process.GetProcessId()); 1016 1017 return error; 1018 } 1019 #endif // defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) 1020 1021 #ifndef _WIN32 1022 void 1023 Host::Kill(lldb::pid_t pid, int signo) 1024 { 1025 ::kill(pid, signo); 1026 } 1027 1028 #endif 1029 1030 #if !defined (__APPLE__) 1031 bool 1032 Host::OpenFileInExternalEditor (const FileSpec &file_spec, uint32_t line_no) 1033 { 1034 return false; 1035 } 1036 1037 void 1038 Host::SetCrashDescriptionWithFormat (const char *format, ...) 1039 { 1040 } 1041 1042 void 1043 Host::SetCrashDescription (const char *description) 1044 { 1045 } 1046 1047 #endif 1048 1049 #if !defined (__linux__) && !defined (__FreeBSD__) && !defined(__FreeBSD_kernel__) && !defined (__NetBSD__) 1050 1051 const lldb_private::UnixSignalsSP& 1052 Host::GetUnixSignals () 1053 { 1054 static UnixSignalsSP s_unix_signals_sp (new UnixSignals ()); 1055 return s_unix_signals_sp; 1056 } 1057 1058 #endif 1059