minix/external/bsd/kyua-testers/dist/stacktrace_test.c

// Copyright 2012 Google Inc.
// 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 "stacktrace.h"

#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/wait.h>

#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <atf-c.h>

#include "env.h"
#include "error.h"
#include "fs.h"
#include "run.h"
#include "text.h"


/// Ensures that the given expression does not return a kyua_error_t.
///
/// \param expr Expression to evaluate.
#define RE(expr) ATF_REQUIRE(!kyua_error_is_set(expr))


/// Ensures that the given expression does not return a kyua_error_t.
///
/// \param expr Expression to evaluate.
/// \param msg Failure message.
#define RE_MSG(expr, msg) ATF_REQUIRE_MSG(!kyua_error_is_set(expr), msg)


/// Generates a core dump.
///
/// Due to the complexity of this interface, you should probably use
/// generate_core() instead.
///
/// \post If this fails to generate a core file, the test case is marked as
/// skipped.  The caller therefore can rely that a core dump has been created on
/// return.
///
/// \param tc Pointer to the caller test case.
/// \param run_params Parameters for the execution of the helper.
/// \param helper_path Path to the created helper.
/// \param exec_path Name of the helper, prefixed with ./ so that it can be
///     executed from within the work directory.
/// \param helper_name Basename of the helper.
///
/// \return The PID of the crashed binary.
static pid_t
generate_core_aux(const atf_tc_t* tc, const kyua_run_params_t* run_params,
                  const char* helper_path, const char* exec_path,
                  const char* helper_name)
{
    const char* srcdir = atf_tc_get_config_var(tc, "srcdir");

    char* src_helper;
    RE(kyua_fs_concat(&src_helper, srcdir, "stacktrace_helper", NULL));
    atf_utils_copy_file(src_helper, helper_path);
    free(src_helper);

    // We use kyua_run_fork for this to better simulate the final use case of
    // the stacktrace gathering, as test programs are run through these
    // functions.  Also, kyua_run_fork provides us with automatic unlimiting of
    // resources so that core files can be generated.

    pid_t pid;
    const kyua_error_t error = kyua_run_fork(run_params, &pid);
    if (!kyua_error_is_set(error) && pid == 0) {
        const char* const args[] = { helper_name, NULL };
        kyua_run_exec(exec_path, args);
    }
    RE(error);

    int status; bool timed_out;
    RE_MSG(kyua_run_wait(pid, &status, &timed_out),
           "wait failed; unexpected problem during exec?");

    ATF_REQUIRE(WIFSIGNALED(status));
    if (!WCOREDUMP(status))
        atf_tc_skip("Test failed to generate core dump");
    return pid;
}


/// Creates a script.
///
/// \param script Path to the script to create.
/// \param contents Contents of the script.
static void
create_script(const char* script, const char* contents)
{
    atf_utils_create_file(script, "#! /bin/sh\n\n%s\n", contents);
    ATF_REQUIRE(chmod(script, 0755) != -1);
}


/// Generates a core file.
///
/// \param tc Pointer to the calling test case.
/// \param work_directory Name of the directory in which to place the binary
///     that will generate the stacktrace.
/// \param program_name Basename of the binary that will crash.
///
/// \return PID of the process that generated the core file.
static pid_t
generate_core(const atf_tc_t* tc, const char* work_directory,
              const char* program_name)
{
    kyua_run_params_t run_params;
    kyua_run_params_init(&run_params);
    if (strcmp(work_directory, ".") != 0) {
        ATF_REQUIRE(mkdir(work_directory, 0755) != -1);
        run_params.work_directory = work_directory;
    }

    char* copy_to; char* exec_path;
    RE(kyua_text_printf(&copy_to, "%s/%s", work_directory, program_name));
    RE(kyua_text_printf(&exec_path, "./%s", program_name));
    const pid_t pid = generate_core_aux(tc, &run_params, copy_to, exec_path,
                                        program_name);
    free(exec_path);
    free(copy_to);
    return pid;
}


/// Prepares and runs kyua_stacktrace_dump().
///
/// \param tc Pointer to the calling test case.
/// \param work_directory Name of the directory in which to place the binary
///     that will generate the stacktrace.
/// \param program_name Basename of the binary that will crash.
/// \param output_name Name of the file to which to write the stacktrace.
/// \param timeout_seconds Time to give GDB to complete.
static void
do_dump(const atf_tc_t* tc, const char* work_directory,
        const char* program_name, const char* output_name,
        const int timeout_seconds)
{
    const pid_t pid = generate_core(tc, work_directory, program_name);

    kyua_run_params_t run_params;
    kyua_run_params_init(&run_params);
    run_params.timeout_seconds = timeout_seconds + 100;  // Some large value.
    run_params.work_directory = work_directory;  // Created by generate_core.

    kyua_stacktrace_gdb_timeout = timeout_seconds;

    FILE* output = fopen(output_name, "w");
    ATF_REQUIRE(output != NULL);
    kyua_stacktrace_dump(program_name, pid, &run_params, output);
    fclose(output);
    atf_utils_cat_file(output_name, "dump output: ");
}


ATF_TC_WITHOUT_HEAD(find_core__found__short);
ATF_TC_BODY(find_core__found__short, tc)
{
    const pid_t pid = generate_core(tc, "dir", "short");
    const char* core_name = kyua_stacktrace_find_core("short", "dir", pid);
    if (core_name == NULL)
        atf_tc_fail("Core dumped, but no candidates found");
    ATF_REQUIRE(strstr(core_name, "core") != NULL);
    ATF_REQUIRE(access(core_name, F_OK) != -1);
}


ATF_TC_WITHOUT_HEAD(find_core__found__long);
ATF_TC_BODY(find_core__found__long, tc)
{
    const pid_t pid = generate_core(
        tc, "dir", "long-name-that-may-be-truncated-in-some-systems");
    const char* core_name = kyua_stacktrace_find_core(
        "long-name-that-may-be-truncated-in-some-systems", "dir", pid);
    if (core_name == NULL)
        atf_tc_fail("Core dumped, but no candidates found");
    ATF_REQUIRE(strstr(core_name, "core") != NULL);
    ATF_REQUIRE(access(core_name, F_OK) != -1);
}


ATF_TC_WITHOUT_HEAD(find_core__not_found);
ATF_TC_BODY(find_core__not_found, tc)
{
    const char* core_name = kyua_stacktrace_find_core("missing", ".", 1);
    if (core_name != NULL)
        atf_tc_fail("Core not dumped, but candidate found: %s", core_name);
}


ATF_TC_WITHOUT_HEAD(dump__integration);
ATF_TC_BODY(dump__integration, tc)
{
    do_dump(tc, "dir", "short", "stacktrace", 10);

    // It is hard to validate the execution of an arbitrary GDB of which we know
    // nothing anything.  Just assume that the backtrace, at the very least,
    // prints a frame identifier.
    ATF_REQUIRE(atf_utils_grep_file("#0", "stacktrace"));
}


ATF_TC_WITHOUT_HEAD(dump__ok);
ATF_TC_BODY(dump__ok, tc)
{
    RE(kyua_env_set("PATH", "."));
    create_script("fake-gdb", "echo 'frame 1'; echo 'frame 2'; "
                  "echo 'some warning' 1>&2; exit 0");
    kyua_stacktrace_gdb = "fake-gdb";

    do_dump(tc, ".", "short", "stacktrace", 10);

    ATF_REQUIRE(atf_utils_grep_file("dumped core; attempting to gather",
                                    "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("frame 1", "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("frame 2", "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("some warning", "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("GDB exited successfully", "stacktrace"));
}


ATF_TC_WITHOUT_HEAD(dump__cannot_find_core);
ATF_TC_BODY(dump__cannot_find_core, tc)
{
    kyua_run_params_t run_params;
    kyua_run_params_init(&run_params);

    FILE* output = fopen("stacktrace", "w");
    ATF_REQUIRE(output != NULL);
    // This assumes that init(8) has never core dumped.
    kyua_stacktrace_dump("missing", 1, &run_params, output);
    fclose(output);
    atf_utils_cat_file("stacktrace", "dump output: ");

    ATF_REQUIRE(atf_utils_grep_file("Cannot find any core file", "stacktrace"));
}


ATF_TC_WITHOUT_HEAD(dump__cannot_find_gdb);
ATF_TC_BODY(dump__cannot_find_gdb, tc)
{
    RE(kyua_env_set("PATH", "."));
    kyua_stacktrace_gdb = "missing-gdb";

    do_dump(tc, ".", "dont-care", "stacktrace", 10);

    ATF_REQUIRE(atf_utils_grep_file("execvp failed", "stacktrace"));
}


ATF_TC_WITHOUT_HEAD(dump__gdb_fail);
ATF_TC_BODY(dump__gdb_fail, tc)
{
    RE(kyua_env_set("PATH", "."));
    create_script("fake-gdb", "echo 'foo'; echo 'bar' 1>&2; exit 56");
    kyua_stacktrace_gdb = "fake-gdb";

    do_dump(tc, ".", "short", "stacktrace", 10);

    ATF_REQUIRE(atf_utils_grep_file("foo", "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("bar", "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("GDB failed with code 56; see output above "
                                    "for details", "stacktrace"));
}


ATF_TC_WITHOUT_HEAD(dump__gdb_times_out);
ATF_TC_BODY(dump__gdb_times_out, tc)
{
    RE(kyua_env_set("PATH", "."));
    create_script("fake-gdb", "echo 'foo'; echo 'bar' 1>&2; "
                  "/bin/sleep 10; /usr/bin/sleep 10; exit 0");
    kyua_stacktrace_gdb = "fake-gdb";

    do_dump(tc, ".", "short", "stacktrace", 1);

    ATF_REQUIRE(atf_utils_grep_file("foo", "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("bar", "stacktrace"));
    ATF_REQUIRE(atf_utils_grep_file("GDB failed; timed out", "stacktrace"));
}


ATF_TP_ADD_TCS(tp)
{
    ATF_TP_ADD_TC(tp, find_core__found__short);
    ATF_TP_ADD_TC(tp, find_core__found__long);
    ATF_TP_ADD_TC(tp, find_core__not_found);

    ATF_TP_ADD_TC(tp, dump__integration);
    ATF_TP_ADD_TC(tp, dump__ok);
    ATF_TP_ADD_TC(tp, dump__cannot_find_core);
    ATF_TP_ADD_TC(tp, dump__cannot_find_gdb);
    ATF_TP_ADD_TC(tp, dump__gdb_fail);
    ATF_TP_ADD_TC(tp, dump__gdb_times_out);

    return atf_no_error();
}