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 
82 extern "C" {
83 int __pthread_chdir(const char *path);
84 int __pthread_fchdir(int fildes);
85 }
86 
87 #endif
88 
89 using namespace lldb;
90 using namespace lldb_private;
91 
92 #if !defined(__APPLE__) && !defined(_WIN32)
93 struct 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 
100 static thread_result_t MonitorChildProcessThreadFunction(void *arg);
101 
102 llvm::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.
121 class ScopedPThreadCancelDisabler {
122 public:
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 
137 private:
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))
144 static __thread volatile sig_atomic_t g_usr1_called;
145 #else
146 static thread_local volatile sig_atomic_t g_usr1_called;
147 #endif
148 
149 static void SigUsr1Handler(int) { g_usr1_called = 1; }
150 #endif // __linux__
151 
152 static 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 
164 static 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 
289 void Host::SystemLog(SystemLogType type, const char *format, va_list args) {
290   vfprintf(stderr, format, args);
291 }
292 
293 #endif
294 
295 void 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 
313 lldb::pid_t Host::GetCurrentProcessID() { return ::getpid(); }
314 
315 #ifndef _WIN32
316 
317 lldb::thread_t Host::GetCurrentThread() {
318   return lldb::thread_t(pthread_self());
319 }
320 
321 const 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 
411 bool Host::GetBundleDirectory(const FileSpec &file, FileSpec &bundle) {
412   bundle.Clear();
413   return false;
414 }
415 
416 bool Host::ResolveExecutableInBundle(FileSpec &file) { return false; }
417 #endif
418 
419 #ifndef _WIN32
420 
421 FileSpec 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__)
438 bool Host::FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach) {
439   return false;
440 }
441 #endif
442 
443 struct 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 
454 static bool
455 MonitorShellCommand(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 
469 Status 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 
480 Status 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__)
593 Status 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
614 void Host::Kill(lldb::pid_t pid, int signo) { ::kill(pid, signo); }
615 
616 #endif
617 
618 #if !defined(__APPLE__)
619 bool Host::OpenFileInExternalEditor(const FileSpec &file_spec,
620                                     uint32_t line_no) {
621   return false;
622 }
623 
624 #endif
625 
626 std::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)
635 WaitStatus 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 
646 void 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