kyua-0.13/utils/stacktrace.cpp

// 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 status The exit status of the program.
/// \param work_directory The directory from which the program was run.
/// \param output Stream into which to dump the stack trace and any additional
///     information.
///
/// \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 status The exit status of the program if available; may be none when
///     the program timed out.
/// \param work_directory The directory from which the program was run.
/// \param output_file File into which to dump the stack trace and any
///     additional information.
///
/// \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);
}