exception_integration_test.cpp

Go to the documentation of this file.

// Integration tests for cctlib's exception + signal / non-local-return
// handling. Each victim exercises a specific pattern (throw/catch, deep
// unwind, rethrow, catch-all, destructor cleanup during unwind, high-
// frequency loop, polymorphic catch, setjmp/longjmp, sigsegv-recovery).
// For every (client tool, victim) combination we assert:
//   * pin exits with code 0 (no SIGSEGV in the tool),
//   * a report file with the expected prefix is produced.
//
// This suite exists specifically to guard against regressions of the
// cctlib exception-unwind bug where a direct call to _Unwind_GetIP
// resolved to Pin's private libunwind and corrupted context reads.
// See RememberUnwindGetIPFromImage() in src/cctlib.cpp.
 
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
#include <fstream>
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include <vector>
 
#include <gtest/gtest.h>
 
namespace {
 
std::string env(const char* n) { const char* v = getenv(n); return v ? v : ""; }
std::string cctlib_root() {
    std::string r = env("CCTLIB_ROOT");
    return r.empty() ? "../.." : r;
}
std::string pin_root() { return env("PIN_ROOT"); }
 
// Run pin with the given tool against the victim; return pin's exit code.
int run_pin(const std::string& tool, const std::string& victim,
            const std::vector<std::string>& extra_args = {}) {
    std::string pin = pin_root() + "/pin";
    std::vector<char*> argv;
    argv.push_back(const_cast<char*>(pin.c_str()));
    argv.push_back(const_cast<char*>("-t"));
    argv.push_back(const_cast<char*>(tool.c_str()));
    argv.push_back(const_cast<char*>("--"));
    argv.push_back(const_cast<char*>(victim.c_str()));
    for (auto& a : extra_args) argv.push_back(const_cast<char*>(a.c_str()));
    argv.push_back(nullptr);
 
    pid_t pid = fork();
    if (pid < 0) return -1;
    if (pid == 0) {
        if (env("CCTLIB_TEST_VERBOSE").empty()) {
            int devnull = open("/dev/null", O_WRONLY);
            if (devnull >= 0) { dup2(devnull, 1); dup2(devnull, 2); close(devnull); }
        }
        execv(pin.c_str(), argv.data());
        _exit(127);
    }
    int status = 0;
    if (waitpid(pid, &status, 0) < 0) return -1;
    if (WIFEXITED(status)) return WEXITSTATUS(status);
    return -128 - WTERMSIG(status);
}
 
// True if any file matching dir/prefix* exists.
bool has_output_file(const std::string& dir, const std::string& prefix) {
    std::string cmd = "ls " + dir + "/" + prefix + "* >/dev/null 2>&1";
    return system(cmd.c_str()) == 0;
}
 
// Remove stale output files that would otherwise trip the presence check.
void cleanup(const std::string& dir, const std::string& prefix) {
    std::string cmd = "rm -f " + dir + "/" + prefix + "*";
    (void)system(cmd.c_str());
}
 
// One row in the (tool, output-prefix) product.
struct ToolSpec {
    const char* name;         // gtest label
    const char* soPath;       // relative to clients/obj-intel64/
    const char* outPrefix;    // report file prefix in CWD
};
 
const ToolSpec kTools[] = {
    { "deadspy", "deadspy_client.so", "deadspy.out." },
    { "redspy",  "redspy_client.so",  "redspy.out."  },
    { "loadspy", "loadspy_client.so", "redLoad.out." },
};
 
// Victim programs under tests/gtest/obj/apps/exceptions.
struct VictimSpec {
    const char* name;   // gtest label + binary basename
};
 
const VictimSpec kVictims[] = {
    { "exc_simple_throw"     },
    { "exc_deep_unwind"      },
    { "exc_rethrow"          },
    { "exc_catchall"         },
    { "exc_dtor_cleanup"     },
    { "exc_stress_loop"      },
    { "exc_polymorphic"      },
    { "exc_none_tn"          },
    { "exc_uncaught_tn"      },
    { "exc_ctor_throw"       },
    { "exc_catch_and_resume" },
    { "sig_longjmp"          },
    { "sig_sigsegv_recover"  },
};
 
class ExceptionRun
    : public ::testing::TestWithParam<std::tuple<ToolSpec, VictimSpec>> {
  protected:
    std::string root_;
    void SetUp() override {
        root_ = cctlib_root();
        ASSERT_FALSE(pin_root().empty()) << "PIN_ROOT required";
        // Report files land in CWD; keep them next to the repo so parallel
        // gtest invocations don't stomp on each other.
        ASSERT_EQ(0, chdir(root_.c_str())) << "chdir(" << root_ << ") failed";
    }
};
 
TEST_P(ExceptionRun, PinExitsCleanlyAndReportIsProduced) {
    auto [tool, victim] = GetParam();
 
    // TODO(loadspy-fault-safe): loadspy's analysis routine dereferences
    // the load address to capture "value at read" (see
    // RedSpyAnalysis::CheckNByteValueAfterRead in loadspy_client.cpp).
    // For the sig_sigsegv_recover victim, the app deliberately reads
    // from 0x1 to trigger SIGSEGV; loadspy's callback runs first and
    // faults on the same address. Fix by routing the load through
    // PIN_SafeCopy. Deadspy (shadow-only) and redspy (read-only address
    // never written to) don't hit this. Tracked separately.
    if (std::string(tool.name) == "loadspy" &&
        std::string(victim.name) == "sig_sigsegv_recover") {
        GTEST_SKIP() << "known loadspy fault-safety bug; independent of the"
                        " cctlib exception fix under test";
    }
 
    std::string toolPath = root_ + "/clients/obj-intel64/" + tool.soPath;
    std::string victimPath = root_ + "/tests/gtest/obj/apps/exceptions/" + victim.name;
    ASSERT_EQ(0, access(toolPath.c_str(), F_OK)) << toolPath << " missing";
    ASSERT_EQ(0, access(victimPath.c_str(), F_OK)) << victimPath << " missing";
 
    cleanup(root_, tool.outPrefix);
    int rc = run_pin(toolPath, victimPath);
    // Non-zero == SIGSEGV in the tool (rc < -128 encodes the terminating
    // signal), a fatal PIN_ExitProcess(-1) from the cctlib unwind
    // resolver, or the victim itself failing.
    EXPECT_EQ(0, rc)
        << "tool=" << tool.name << " victim=" << victim.name << " rc=" << rc
        << " -- see repo root for output artifacts";
    EXPECT_TRUE(has_output_file(root_, tool.outPrefix))
        << "no " << tool.outPrefix << "* file produced by " << tool.name
        << " for " << victim.name;
}
 
INSTANTIATE_TEST_SUITE_P(
    ToolAndVictim, ExceptionRun,
    ::testing::Combine(::testing::ValuesIn(kTools),
                       ::testing::ValuesIn(kVictims)),
    [](const testing::TestParamInfo<ExceptionRun::ParamType>& info) {
        std::string s;
        s += std::get<0>(info.param).name;
        s += "__";
        s += std::get<1>(info.param).name;
        return s;
    });
 
}  // namespace