vendor/kyua/0.13-a685f91vendor/kyua

1 files changed, 370 insertions, 0 deletions

diff --git a/utils/stacktrace.cpp b/utils/stacktrace.cpp
new file mode 100644
index 000000000000..11636b31959f
--- /dev/null
+++ b/utils/stacktrace.cpp
@@ -0,0 +1,370 @@
+// Copyright 2012 The Kyua Authors.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+//   notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+//   notice, this list of conditions and the following disclaimer in the
+//   documentation and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors
+//   may be used to endorse or promote products derived from this software
+//   without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "utils/stacktrace.hpp"
+
+extern "C" {
+#include <sys/param.h>
+#include <sys/resource.h>
+
+#include <unistd.h>
+}
+
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "utils/datetime.hpp"
+#include "utils/env.hpp"
+#include "utils/format/macros.hpp"
+#include "utils/fs/operations.hpp"
+#include "utils/fs/path.hpp"
+#include "utils/logging/macros.hpp"
+#include "utils/optional.ipp"
+#include "utils/process/executor.ipp"
+#include "utils/process/operations.hpp"
+#include "utils/process/status.hpp"
+#include "utils/sanity.hpp"
+
+namespace datetime = utils::datetime;
+namespace executor = utils::process::executor;
+namespace fs = utils::fs;
+namespace process = utils::process;
+
+using utils::none;
+using utils::optional;
+
+
+/// Built-in path to GDB.
+///
+/// This is the value that should be passed to the find_gdb() function.  If this
+/// is an absolute path, then we use the binary specified by the variable; if it
+/// is a relative path, we look for the binary in the path.
+///
+/// Test cases can override the value of this built-in constant to unit-test the
+/// behavior of the functions below.
+const char* utils::builtin_gdb = GDB;
+
+
+/// Maximum time the external GDB process is allowed to run for.
+datetime::delta utils::gdb_timeout(60, 0);
+
+
+namespace {
+
+
+/// Maximum length of the core file name, if known.
+///
+/// Some operating systems impose a maximum length on the basename of the core
+/// file.  If MAXCOMLEN is defined, then we need to truncate the program name to
+/// this length before searching for the core file.  If no such limit is known,
+/// this is infinite.
+static const std::string::size_type max_core_name_length =
+#if defined(MAXCOMLEN)
+    MAXCOMLEN
+#else
+    std::string::npos
+#endif
+    ;
+
+
+/// Functor to execute GDB in a subprocess.
+class run_gdb {
+    /// Path to the GDB binary to use.
+    const fs::path& _gdb;
+
+    /// Path to the program being debugged.
+    const fs::path& _program;
+
+    /// Path to the dumped core.
+    const fs::path& _core_name;
+
+public:
+    /// Constructs the functor.
+    ///
+    /// \param gdb_ Path to the GDB binary to use.
+    /// \param program_ Path to the program being debugged.  Can be relative to
+    ///     the given work directory.
+    /// \param core_name_ Path to the dumped core.  Use find_core() to deduce
+    ///     a valid candidate.  Can be relative to the given work directory.
+    run_gdb(const fs::path& gdb_, const fs::path& program_,
+            const fs::path& core_name_) :
+        _gdb(gdb_), _program(program_), _core_name(core_name_)
+    {
+    }
+
+    /// Executes GDB.
+    ///
+    /// \param control_directory Directory where we can store control files to
+    ///     not clobber any files created by the program being debugged.
+    void
+    operator()(const fs::path& control_directory)
+    {
+        const fs::path gdb_script_path = control_directory / "gdb.script";
+
+        // Old versions of GDB, such as the one shipped by FreeBSD as of
+        // 11.0-CURRENT on 2014-11-26, do not support scripts on the command
+        // line via the '-ex' flag.  Instead, we have to create a script file
+        // and use that instead.
+        std::ofstream gdb_script(gdb_script_path.c_str());
+        if (!gdb_script) {
+            std::cerr << "Cannot create GDB script\n";
+            ::_exit(EXIT_FAILURE);
+        }
+        gdb_script << "backtrace\n";
+        gdb_script.close();
+
+        utils::unsetenv("TERM");
+
+        std::vector< std::string > args;
+        args.push_back("-batch");
+        args.push_back("-q");
+        args.push_back("-x");
+        args.push_back(gdb_script_path.str());
+        args.push_back(_program.str());
+        args.push_back(_core_name.str());
+
+        // Force all GDB output to go to stderr.  We print messages to stderr
+        // when grabbing the stacktrace and we do not want GDB's output to end
+        // up split in two different files.
+        if (::dup2(STDERR_FILENO, STDOUT_FILENO) == -1) {
+            std::cerr << "Cannot redirect stdout to stderr\n";
+            ::_exit(EXIT_FAILURE);
+        }
+
+        process::exec(_gdb, args);
+    }
+};
+
+
+}  // anonymous namespace
+
+
+/// Looks for the path to the GDB binary.
+///
+/// \return The absolute path to the GDB binary if any, otherwise none.  Note
+/// that the returned path may or may not be valid: there is no guarantee that
+/// the path exists and is executable.
+optional< fs::path >
+utils::find_gdb(void)
+{
+    if (std::strlen(builtin_gdb) == 0) {
+        LW("The builtin path to GDB is bogus, which probably indicates a bug "
+           "in the build system; cannot gather stack traces");
+        return none;
+    }
+
+    const fs::path gdb(builtin_gdb);
+    if (gdb.is_absolute())
+        return utils::make_optional(gdb);
+    else
+        return fs::find_in_path(gdb.c_str());
+}
+
+
+/// Looks for a core file for the given program.
+///
+/// \param program The name of the binary that generated the core file.  Can be
+///     either absolute or relative.
+/// \param status The exit status of the program.  This is necessary to gather
+///     the PID.
+/// \param work_directory The directory from which the program was run.
+///
+/// \return The path to the core file, if found; otherwise none.
+optional< fs::path >
+utils::find_core(const fs::path& program, const process::status& status,
+                 const fs::path& work_directory)
+{
+    std::vector< fs::path > candidates;
+
+    candidates.push_back(work_directory /
+        (program.leaf_name().substr(0, max_core_name_length) + ".core"));
+    if (program.is_absolute()) {
+        candidates.push_back(program.branch_path() /
+            (program.leaf_name().substr(0, max_core_name_length) + ".core"));
+    }
+    candidates.push_back(work_directory / (F("core.%s") % status.dead_pid()));
+    candidates.push_back(fs::path("/cores") /
+                         (F("core.%s") % status.dead_pid()));
+
+    for (std::vector< fs::path >::const_iterator iter = candidates.begin();
+         iter != candidates.end(); ++iter) {
+        if (fs::exists(*iter)) {
+            LD(F("Attempting core file candidate %s: found") % *iter);
+            return utils::make_optional(*iter);
+        } else {
+            LD(F("Attempting core file candidate %s: not found") % *iter);
+        }
+    }
+    return none;
+}
+
+
+/// Raises core size limit to its possible maximum.
+///
+/// This is a best-effort operation.  There is no guarantee that the operation
+/// will yield a large-enough limit to generate any possible core file.
+///
+/// \return True if the core size could be unlimited; false otherwise.
+bool
+utils::unlimit_core_size(void)
+{
+    bool ok;
+
+    struct ::rlimit rl;
+    if (::getrlimit(RLIMIT_CORE, &rl) == -1) {
+        const int original_errno = errno;
+        LW(F("getrlimit should not have failed but got: %s") %
+           std::strerror(original_errno));
+        ok = false;
+    } else {
+        if (rl.rlim_max == 0) {
+            LW("getrlimit returned 0 for RLIMIT_CORE rlim_max; cannot raise "
+               "soft core limit");
+            ok = false;
+        } else {
+            rl.rlim_cur = rl.rlim_max;
+            LD(F("Raising soft core size limit to %s (hard value)") %
+               rl.rlim_cur);
+            if (::setrlimit(RLIMIT_CORE, &rl) == -1) {
+                const int original_errno = errno;
+                LW(F("setrlimit should not have failed but got: %s") %
+                   std::strerror(original_errno));
+                ok = false;
+            } else {
+                ok = true;
+            }
+        }
+    }
+
+    return ok;
+}
+
+
+/// Gathers a stacktrace of a crashed program.
+///
+/// \param program The name of the binary that crashed and dumped a core file.
+///     Can be either absolute or relative.
+/// \param executor_handle The executor handler to get the status from and
+///     gdb handler from.
+/// \param exit_handle The exit handler to stream additional diagnostic
+///     information from (stderr) and for redirecting to additional
+///     information to gdb from.
+///
+/// \post If anything goes wrong, the diagnostic messages are written to the
+/// output.  This function should not throw.
+void
+utils::dump_stacktrace(const fs::path& program,
+                       executor::executor_handle& executor_handle,
+                       const executor::exit_handle& exit_handle)
+{
+    PRE(exit_handle.status());
+    const process::status& status = exit_handle.status().get();
+    PRE(status.signaled() && status.coredump());
+
+    std::ofstream gdb_err(exit_handle.stderr_file().c_str(), std::ios::app);
+    if (!gdb_err) {
+        LW(F("Failed to open %s to append GDB's output") %
+           exit_handle.stderr_file());
+        return;
+    }
+
+    gdb_err << F("Process with PID %s exited with signal %s and dumped core; "
+                 "attempting to gather stack trace\n") %
+        status.dead_pid() % status.termsig();
+
+    const optional< fs::path > gdb = utils::find_gdb();
+    if (!gdb) {
+        gdb_err << F("Cannot find GDB binary; builtin was '%s'\n") %
+            builtin_gdb;
+        return;
+    }
+
+    const optional< fs::path > core_file = find_core(
+        program, status, exit_handle.work_directory());
+    if (!core_file) {
+        gdb_err << F("Cannot find any core file\n");
+        return;
+    }
+
+    gdb_err.flush();
+    const executor::exec_handle exec_handle =
+        executor_handle.spawn_followup(
+            run_gdb(gdb.get(), program, core_file.get()),
+            exit_handle, gdb_timeout);
+    const executor::exit_handle gdb_exit_handle =
+        executor_handle.wait(exec_handle);
+
+    const optional< process::status >& gdb_status = gdb_exit_handle.status();
+    if (!gdb_status) {
+        gdb_err << "GDB timed out\n";
+    } else {
+        if (gdb_status.get().exited() &&
+            gdb_status.get().exitstatus() == EXIT_SUCCESS) {
+            gdb_err << "GDB exited successfully\n";
+        } else {
+            gdb_err << "GDB failed; see output above for details\n";
+        }
+    }
+}
+
+
+/// Gathers a stacktrace of a program if it crashed.
+///
+/// This is just a convenience function to allow appending the stacktrace to an
+/// existing file and to permit reusing the status as returned by auxiliary
+/// process-spawning functions.
+///
+/// \param program The name of the binary that crashed and dumped a core file.
+///     Can be either absolute or relative.
+/// \param executor_handle The executor handler to get the status from and
+///     gdb handler from.
+/// \param exit_handle The exit handler to stream additional diagnostic
+///     information from (stderr) and for redirecting to additional
+///     information to gdb from.
+///
+/// \throw std::runtime_error If the output file cannot be opened.
+///
+/// \post If anything goes wrong with the stack gatheringq, the diagnostic
+/// messages are written to the output.
+void
+utils::dump_stacktrace_if_available(const fs::path& program,
+                                    executor::executor_handle& executor_handle,
+                                    const executor::exit_handle& exit_handle)
+{
+    const optional< process::status >& status = exit_handle.status();
+    if (!status || !status.get().signaled() || !status.get().coredump())
+        return;
+
+    dump_stacktrace(program, executor_handle, exit_handle);
+}