Host.cpp revision 360784 
1//===-- Host.cpp ------------------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// C includes
10#include <errno.h>
11#include <limits.h>
12#include <stdlib.h>
13#include <sys/types.h>
14#ifndef _WIN32
15#include <dlfcn.h>
16#include <grp.h>
17#include <netdb.h>
18#include <pwd.h>
19#include <sys/stat.h>
20#include <unistd.h>
21#endif
22
23#if defined(__APPLE__)
24#include <mach-o/dyld.h>
25#include <mach/mach_init.h>
26#include <mach/mach_port.h>
27#endif
28
29#if defined(__linux__) || defined(__FreeBSD__) ||                              \
30    defined(__FreeBSD_kernel__) || defined(__APPLE__) ||                       \
31    defined(__NetBSD__) || defined(__OpenBSD__)
32#if !defined(__ANDROID__)
33#include <spawn.h>
34#endif
35#include <sys/syscall.h>
36#include <sys/wait.h>
37#endif
38
39#if defined(__FreeBSD__)
40#include <pthread_np.h>
41#endif
42
43#if defined(__NetBSD__)
44#include <lwp.h>
45#endif
46
47#include <csignal>
48
49#include "lldb/Host/FileAction.h"
50#include "lldb/Host/FileSystem.h"
51#include "lldb/Host/Host.h"
52#include "lldb/Host/HostInfo.h"
53#include "lldb/Host/HostProcess.h"
54#include "lldb/Host/MonitoringProcessLauncher.h"
55#include "lldb/Host/ProcessLaunchInfo.h"
56#include "lldb/Host/ProcessLauncher.h"
57#include "lldb/Host/ThreadLauncher.h"
58#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
59#include "lldb/Utility/DataBufferLLVM.h"
60#include "lldb/Utility/FileSpec.h"
61#include "lldb/Utility/Log.h"
62#include "lldb/Utility/Predicate.h"
63#include "lldb/Utility/Status.h"
64#include "lldb/lldb-private-forward.h"
65#include "llvm/ADT/SmallString.h"
66#include "llvm/ADT/StringSwitch.h"
67#include "llvm/Support/Errno.h"
68#include "llvm/Support/FileSystem.h"
69
70#if defined(_WIN32)
71#include "lldb/Host/windows/ConnectionGenericFileWindows.h"
72#include "lldb/Host/windows/ProcessLauncherWindows.h"
73#else
74#include "lldb/Host/posix/ProcessLauncherPosixFork.h"
75#endif
76
77#if defined(__APPLE__)
78#ifndef _POSIX_SPAWN_DISABLE_ASLR
79#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
80#endif
81
82extern "C" {
83int __pthread_chdir(const char *path);
84int __pthread_fchdir(int fildes);
85}
86
87#endif
88
89using namespace lldb;
90using namespace lldb_private;
91
92#if !defined(__APPLE__) && !defined(_WIN32)
93struct MonitorInfo {
94  lldb::pid_t pid; // The process ID to monitor
95  Host::MonitorChildProcessCallback
96      callback; // The callback function to call when "pid" exits or signals
97  bool monitor_signals; // If true, call the callback when "pid" gets signaled.
98};
99
100static thread_result_t MonitorChildProcessThreadFunction(void *arg);
101
102llvm::Expected<HostThread> Host::StartMonitoringChildProcess(
103    const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
104    bool monitor_signals) {
105  MonitorInfo *info_ptr = new MonitorInfo();
106
107  info_ptr->pid = pid;
108  info_ptr->callback = callback;
109  info_ptr->monitor_signals = monitor_signals;
110
111  char thread_name[256];
112  ::snprintf(thread_name, sizeof(thread_name),
113             "<lldb.host.wait4(pid=%" PRIu64 ")>", pid);
114  return ThreadLauncher::LaunchThread(
115      thread_name, MonitorChildProcessThreadFunction, info_ptr, 0);
116}
117
118#ifndef __linux__
119// Scoped class that will disable thread canceling when it is constructed, and
120// exception safely restore the previous value it when it goes out of scope.
121class ScopedPThreadCancelDisabler {
122public:
123  ScopedPThreadCancelDisabler() {
124    // Disable the ability for this thread to be cancelled
125    int err = ::pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &m_old_state);
126    if (err != 0)
127      m_old_state = -1;
128  }
129
130  ~ScopedPThreadCancelDisabler() {
131    // Restore the ability for this thread to be cancelled to what it
132    // previously was.
133    if (m_old_state != -1)
134      ::pthread_setcancelstate(m_old_state, 0);
135  }
136
137private:
138  int m_old_state; // Save the old cancelability state.
139};
140#endif // __linux__
141
142#ifdef __linux__
143#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
144static __thread volatile sig_atomic_t g_usr1_called;
145#else
146static thread_local volatile sig_atomic_t g_usr1_called;
147#endif
148
149static void SigUsr1Handler(int) { g_usr1_called = 1; }
150#endif // __linux__
151
152static bool CheckForMonitorCancellation() {
153#ifdef __linux__
154  if (g_usr1_called) {
155    g_usr1_called = 0;
156    return true;
157  }
158#else
159  ::pthread_testcancel();
160#endif
161  return false;
162}
163
164static thread_result_t MonitorChildProcessThreadFunction(void *arg) {
165  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
166  const char *function = __FUNCTION__;
167  LLDB_LOGF(log, "%s (arg = %p) thread starting...", function, arg);
168
169  MonitorInfo *info = (MonitorInfo *)arg;
170
171  const Host::MonitorChildProcessCallback callback = info->callback;
172  const bool monitor_signals = info->monitor_signals;
173
174  assert(info->pid <= UINT32_MAX);
175  const ::pid_t pid = monitor_signals ? -1 * getpgid(info->pid) : info->pid;
176
177  delete info;
178
179  int status = -1;
180#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
181#define __WALL 0
182#endif
183  const int options = __WALL;
184
185#ifdef __linux__
186  // This signal is only used to interrupt the thread from waitpid
187  struct sigaction sigUsr1Action;
188  memset(&sigUsr1Action, 0, sizeof(sigUsr1Action));
189  sigUsr1Action.sa_handler = SigUsr1Handler;
190  ::sigaction(SIGUSR1, &sigUsr1Action, nullptr);
191#endif // __linux__
192
193  while (1) {
194    log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
195    LLDB_LOGF(log, "%s ::waitpid (pid = %" PRIi32 ", &status, options = %i)...",
196              function, pid, options);
197
198    if (CheckForMonitorCancellation())
199      break;
200
201    // Get signals from all children with same process group of pid
202    const ::pid_t wait_pid = ::waitpid(pid, &status, options);
203
204    if (CheckForMonitorCancellation())
205      break;
206
207    if (wait_pid == -1) {
208      if (errno == EINTR)
209        continue;
210      else {
211        LLDB_LOG(log,
212                 "arg = {0}, thread exiting because waitpid failed ({1})...",
213                 arg, llvm::sys::StrError());
214        break;
215      }
216    } else if (wait_pid > 0) {
217      bool exited = false;
218      int signal = 0;
219      int exit_status = 0;
220      const char *status_cstr = nullptr;
221      if (WIFSTOPPED(status)) {
222        signal = WSTOPSIG(status);
223        status_cstr = "STOPPED";
224      } else if (WIFEXITED(status)) {
225        exit_status = WEXITSTATUS(status);
226        status_cstr = "EXITED";
227        exited = true;
228      } else if (WIFSIGNALED(status)) {
229        signal = WTERMSIG(status);
230        status_cstr = "SIGNALED";
231        if (wait_pid == abs(pid)) {
232          exited = true;
233          exit_status = -1;
234        }
235      } else {
236        status_cstr = "(\?\?\?)";
237      }
238
239      // Scope for pthread_cancel_disabler
240      {
241#ifndef __linux__
242        ScopedPThreadCancelDisabler pthread_cancel_disabler;
243#endif
244
245        log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
246        LLDB_LOGF(log,
247                  "%s ::waitpid (pid = %" PRIi32
248                  ", &status, options = %i) => pid = %" PRIi32
249                  ", status = 0x%8.8x (%s), signal = %i, exit_state = %i",
250                  function, pid, options, wait_pid, status, status_cstr, signal,
251                  exit_status);
252
253        if (exited || (signal != 0 && monitor_signals)) {
254          bool callback_return = false;
255          if (callback)
256            callback_return = callback(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            LLDB_LOGF(log,
261                      "%s (arg = %p) thread exiting because pid received "
262                      "exit signal...",
263                      __FUNCTION__, arg);
264            break;
265          }
266          // If the callback returns true, it means this process should exit
267          if (callback_return) {
268            LLDB_LOGF(log,
269                      "%s (arg = %p) thread exiting because callback "
270                      "returned true...",
271                      __FUNCTION__, arg);
272            break;
273          }
274        }
275      }
276    }
277  }
278
279  log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
280  LLDB_LOGF(log, "%s (arg = %p) thread exiting...", __FUNCTION__, arg);
281
282  return nullptr;
283}
284
285#endif // #if !defined (__APPLE__) && !defined (_WIN32)
286
287#if !defined(__APPLE__)
288
289void Host::SystemLog(SystemLogType type, const char *format, va_list args) {
290  vfprintf(stderr, format, args);
291}
292
293#endif
294
295void Host::SystemLog(SystemLogType type, const char *format, ...) {
296  {
297    va_list args;
298    va_start(args, format);
299    SystemLog(type, format, args);
300    va_end(args);
301  }
302
303  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST));
304  if (log && log->GetVerbose()) {
305    // Log to log channel. This allows testcases to grep for log output.
306    va_list args;
307    va_start(args, format);
308    log->VAPrintf(format, args);
309    va_end(args);
310  }
311}
312
313lldb::pid_t Host::GetCurrentProcessID() { return ::getpid(); }
314
315#ifndef _WIN32
316
317lldb::thread_t Host::GetCurrentThread() {
318  return lldb::thread_t(pthread_self());
319}
320
321const char *Host::GetSignalAsCString(int signo) {
322  switch (signo) {
323  case SIGHUP:
324    return "SIGHUP"; // 1    hangup
325  case SIGINT:
326    return "SIGINT"; // 2    interrupt
327  case SIGQUIT:
328    return "SIGQUIT"; // 3    quit
329  case SIGILL:
330    return "SIGILL"; // 4    illegal instruction (not reset when caught)
331  case SIGTRAP:
332    return "SIGTRAP"; // 5    trace trap (not reset when caught)
333  case SIGABRT:
334    return "SIGABRT"; // 6    abort()
335#if defined(SIGPOLL)
336#if !defined(SIGIO) || (SIGPOLL != SIGIO)
337  // Under some GNU/Linux, SIGPOLL and SIGIO are the same. Causing the build to
338  // fail with 'multiple define cases with same value'
339  case SIGPOLL:
340    return "SIGPOLL"; // 7    pollable event ([XSR] generated, not supported)
341#endif
342#endif
343#if defined(SIGEMT)
344  case SIGEMT:
345    return "SIGEMT"; // 7    EMT instruction
346#endif
347  case SIGFPE:
348    return "SIGFPE"; // 8    floating point exception
349  case SIGKILL:
350    return "SIGKILL"; // 9    kill (cannot be caught or ignored)
351  case SIGBUS:
352    return "SIGBUS"; // 10    bus error
353  case SIGSEGV:
354    return "SIGSEGV"; // 11    segmentation violation
355  case SIGSYS:
356    return "SIGSYS"; // 12    bad argument to system call
357  case SIGPIPE:
358    return "SIGPIPE"; // 13    write on a pipe with no one to read it
359  case SIGALRM:
360    return "SIGALRM"; // 14    alarm clock
361  case SIGTERM:
362    return "SIGTERM"; // 15    software termination signal from kill
363  case SIGURG:
364    return "SIGURG"; // 16    urgent condition on IO channel
365  case SIGSTOP:
366    return "SIGSTOP"; // 17    sendable stop signal not from tty
367  case SIGTSTP:
368    return "SIGTSTP"; // 18    stop signal from tty
369  case SIGCONT:
370    return "SIGCONT"; // 19    continue a stopped process
371  case SIGCHLD:
372    return "SIGCHLD"; // 20    to parent on child stop or exit
373  case SIGTTIN:
374    return "SIGTTIN"; // 21    to readers pgrp upon background tty read
375  case SIGTTOU:
376    return "SIGTTOU"; // 22    like TTIN for output if (tp->t_local&LTOSTOP)
377#if defined(SIGIO)
378  case SIGIO:
379    return "SIGIO"; // 23    input/output possible signal
380#endif
381  case SIGXCPU:
382    return "SIGXCPU"; // 24    exceeded CPU time limit
383  case SIGXFSZ:
384    return "SIGXFSZ"; // 25    exceeded file size limit
385  case SIGVTALRM:
386    return "SIGVTALRM"; // 26    virtual time alarm
387  case SIGPROF:
388    return "SIGPROF"; // 27    profiling time alarm
389#if defined(SIGWINCH)
390  case SIGWINCH:
391    return "SIGWINCH"; // 28    window size changes
392#endif
393#if defined(SIGINFO)
394  case SIGINFO:
395    return "SIGINFO"; // 29    information request
396#endif
397  case SIGUSR1:
398    return "SIGUSR1"; // 30    user defined signal 1
399  case SIGUSR2:
400    return "SIGUSR2"; // 31    user defined signal 2
401  default:
402    break;
403  }
404  return nullptr;
405}
406
407#endif
408
409#if !defined(__APPLE__) // see Host.mm
410
411bool Host::GetBundleDirectory(const FileSpec &file, FileSpec &bundle) {
412  bundle.Clear();
413  return false;
414}
415
416bool Host::ResolveExecutableInBundle(FileSpec &file) { return false; }
417#endif
418
419#ifndef _WIN32
420
421FileSpec Host::GetModuleFileSpecForHostAddress(const void *host_addr) {
422  FileSpec module_filespec;
423#if !defined(__ANDROID__)
424  Dl_info info;
425  if (::dladdr(host_addr, &info)) {
426    if (info.dli_fname) {
427      module_filespec.SetFile(info.dli_fname, FileSpec::Style::native);
428      FileSystem::Instance().Resolve(module_filespec);
429    }
430  }
431#endif
432  return module_filespec;
433}
434
435#endif
436
437#if !defined(__linux__)
438bool Host::FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach) {
439  return false;
440}
441#endif
442
443struct ShellInfo {
444  ShellInfo()
445      : process_reaped(false), pid(LLDB_INVALID_PROCESS_ID), signo(-1),
446        status(-1) {}
447
448  lldb_private::Predicate<bool> process_reaped;
449  lldb::pid_t pid;
450  int signo;
451  int status;
452};
453
454static bool
455MonitorShellCommand(std::shared_ptr<ShellInfo> shell_info, lldb::pid_t pid,
456                    bool exited, // True if the process did exit
457                    int signo,   // Zero for no signal
458                    int status)  // Exit value of process if signal is zero
459{
460  shell_info->pid = pid;
461  shell_info->signo = signo;
462  shell_info->status = status;
463  // Let the thread running Host::RunShellCommand() know that the process
464  // exited and that ShellInfo has been filled in by broadcasting to it
465  shell_info->process_reaped.SetValue(true, eBroadcastAlways);
466  return true;
467}
468
469Status Host::RunShellCommand(const char *command, const FileSpec &working_dir,
470                             int *status_ptr, int *signo_ptr,
471                             std::string *command_output_ptr,
472                             const Timeout<std::micro> &timeout,
473                             bool run_in_default_shell,
474                             bool hide_stderr) {
475  return RunShellCommand(Args(command), working_dir, status_ptr, signo_ptr,
476                         command_output_ptr, timeout, run_in_default_shell,
477                         hide_stderr);
478}
479
480Status Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
481                             int *status_ptr, int *signo_ptr,
482                             std::string *command_output_ptr,
483                             const Timeout<std::micro> &timeout,
484                             bool run_in_default_shell,
485                             bool hide_stderr) {
486  Status error;
487  ProcessLaunchInfo launch_info;
488  launch_info.SetArchitecture(HostInfo::GetArchitecture());
489  if (run_in_default_shell) {
490    // Run the command in a shell
491    launch_info.SetShell(HostInfo::GetDefaultShell());
492    launch_info.GetArguments().AppendArguments(args);
493    const bool localhost = true;
494    const bool will_debug = false;
495    const bool first_arg_is_full_shell_command = false;
496    launch_info.ConvertArgumentsForLaunchingInShell(
497        error, localhost, will_debug, first_arg_is_full_shell_command, 0);
498  } else {
499    // No shell, just run it
500    const bool first_arg_is_executable = true;
501    launch_info.SetArguments(args, first_arg_is_executable);
502  }
503
504  if (working_dir)
505    launch_info.SetWorkingDirectory(working_dir);
506  llvm::SmallString<64> output_file_path;
507
508  if (command_output_ptr) {
509    // Create a temporary file to get the stdout/stderr and redirect the output
510    // of the command into this file. We will later read this file if all goes
511    // well and fill the data into "command_output_ptr"
512    if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
513      tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%");
514      llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
515                                      output_file_path);
516    } else {
517      llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "",
518                                         output_file_path);
519    }
520  }
521
522  FileSpec output_file_spec(output_file_path.c_str());
523  // Set up file descriptors.
524  launch_info.AppendSuppressFileAction(STDIN_FILENO, true, false);
525  if (output_file_spec)
526    launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_spec, false,
527                                     true);
528  else
529    launch_info.AppendSuppressFileAction(STDOUT_FILENO, false, true);
530
531  if (output_file_spec && !hide_stderr)
532    launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO);
533  else
534    launch_info.AppendSuppressFileAction(STDERR_FILENO, false, true);
535
536  std::shared_ptr<ShellInfo> shell_info_sp(new ShellInfo());
537  const bool monitor_signals = false;
538  launch_info.SetMonitorProcessCallback(
539      std::bind(MonitorShellCommand, shell_info_sp, std::placeholders::_1,
540                std::placeholders::_2, std::placeholders::_3,
541                std::placeholders::_4),
542      monitor_signals);
543
544  error = LaunchProcess(launch_info);
545  const lldb::pid_t pid = launch_info.GetProcessID();
546
547  if (error.Success() && pid == LLDB_INVALID_PROCESS_ID)
548    error.SetErrorString("failed to get process ID");
549
550  if (error.Success()) {
551    if (!shell_info_sp->process_reaped.WaitForValueEqualTo(true, timeout)) {
552      error.SetErrorString("timed out waiting for shell command to complete");
553
554      // Kill the process since it didn't complete within the timeout specified
555      Kill(pid, SIGKILL);
556      // Wait for the monitor callback to get the message
557      shell_info_sp->process_reaped.WaitForValueEqualTo(
558          true, std::chrono::seconds(1));
559    } else {
560      if (status_ptr)
561        *status_ptr = shell_info_sp->status;
562
563      if (signo_ptr)
564        *signo_ptr = shell_info_sp->signo;
565
566      if (command_output_ptr) {
567        command_output_ptr->clear();
568        uint64_t file_size =
569            FileSystem::Instance().GetByteSize(output_file_spec);
570        if (file_size > 0) {
571          if (file_size > command_output_ptr->max_size()) {
572            error.SetErrorStringWithFormat(
573                "shell command output is too large to fit into a std::string");
574          } else {
575            auto Buffer =
576                FileSystem::Instance().CreateDataBuffer(output_file_spec);
577            if (error.Success())
578              command_output_ptr->assign(Buffer->GetChars(),
579                                         Buffer->GetByteSize());
580          }
581        }
582      }
583    }
584  }
585
586  llvm::sys::fs::remove(output_file_spec.GetPath());
587  return error;
588}
589
590// The functions below implement process launching for non-Apple-based
591// platforms
592#if !defined(__APPLE__)
593Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
594  std::unique_ptr<ProcessLauncher> delegate_launcher;
595#if defined(_WIN32)
596  delegate_launcher.reset(new ProcessLauncherWindows());
597#else
598  delegate_launcher.reset(new ProcessLauncherPosixFork());
599#endif
600  MonitoringProcessLauncher launcher(std::move(delegate_launcher));
601
602  Status error;
603  HostProcess process = launcher.LaunchProcess(launch_info, error);
604
605  // TODO(zturner): It would be better if the entire HostProcess were returned
606  // instead of writing it into this structure.
607  launch_info.SetProcessID(process.GetProcessId());
608
609  return error;
610}
611#endif // !defined(__APPLE__)
612
613#ifndef _WIN32
614void Host::Kill(lldb::pid_t pid, int signo) { ::kill(pid, signo); }
615
616#endif
617
618#if !defined(__APPLE__)
619bool Host::OpenFileInExternalEditor(const FileSpec &file_spec,
620                                    uint32_t line_no) {
621  return false;
622}
623
624#endif
625
626std::unique_ptr<Connection> Host::CreateDefaultConnection(llvm::StringRef url) {
627#if defined(_WIN32)
628  if (url.startswith("file://"))
629    return std::unique_ptr<Connection>(new ConnectionGenericFile());
630#endif
631  return std::unique_ptr<Connection>(new ConnectionFileDescriptor());
632}
633
634#if defined(LLVM_ON_UNIX)
635WaitStatus WaitStatus::Decode(int wstatus) {
636  if (WIFEXITED(wstatus))
637    return {Exit, uint8_t(WEXITSTATUS(wstatus))};
638  else if (WIFSIGNALED(wstatus))
639    return {Signal, uint8_t(WTERMSIG(wstatus))};
640  else if (WIFSTOPPED(wstatus))
641    return {Stop, uint8_t(WSTOPSIG(wstatus))};
642  llvm_unreachable("Unknown wait status");
643}
644#endif
645
646void llvm::format_provider<WaitStatus>::format(const WaitStatus &WS,
647                                               raw_ostream &OS,
648                                               StringRef Options) {
649  if (Options == "g") {
650    char type;
651    switch (WS.type) {
652    case WaitStatus::Exit:
653      type = 'W';
654      break;
655    case WaitStatus::Signal:
656      type = 'X';
657      break;
658    case WaitStatus::Stop:
659      type = 'S';
660      break;
661    }
662    OS << formatv("{0}{1:x-2}", type, WS.status);
663    return;
664  }
665
666  assert(Options.empty());
667  const char *desc;
668  switch(WS.type) {
669  case WaitStatus::Exit:
670    desc = "Exited with status";
671    break;
672  case WaitStatus::Signal:
673    desc = "Killed by signal";
674    break;
675  case WaitStatus::Stop:
676    desc = "Stopped by signal";
677    break;
678  }
679  OS << desc << " " << int(WS.status);
680}
681