posix.cpp

Go to the documentation of this file.

#include <libgrading.h>

#include <cassert>
#include <functional>

#include <sys/mman.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>

using namespace grading;
using std::unique_ptr;


static std::string currentTestName;


CheckResult::~CheckResult()
{
    if (reportError_)
    {
        std::cerr << "Check failed";

        if (not currentTestName.empty())
            std::cerr << " in test '" << currentTestName << "'";

        std::cerr << "\n";

        if (expected_.empty())
            std::cerr << "  " << actual_ << "\n";

        else
            std::cerr
                << "  expected `" << expected_
                << "`, got `" << actual_ << "`\n"
                ;

        std::cerr
            << "  " << message_.str()
            << "\n\n"
            ;

        exit(static_cast<int>(TestResult::Fail));
    }
}


static TestResult ProcessChildStatus(int status)
{
    if (WIFEXITED(status))
        return static_cast<TestResult>(WEXITSTATUS(status));

    if (WIFSIGNALED(status))
    {
        if (WTERMSIG(status) == SIGSEGV)
            return TestResult::Segfault;

        else
            return TestResult::OtherError;
    }

    assert(false && "unhandled child exit mode");
}



class PosixSharedMemory : public SharedMemory
{
    public:
    PosixSharedMemory(int fd, size_t len, void *rawPtr)
        : shmfd(fd), length(len), ptr(rawPtr)
    {
    }

    ~PosixSharedMemory()
    {
        munmap(ptr, length);
        close(shmfd);
    }

    virtual void *rawPointer() const override { return ptr; }

    private:
    int shmfd;
    size_t length;
    void *ptr;
};


unique_ptr<SharedMemory> grading::MapSharedData(size_t len)
{
    int shmfd = shm_open("shm.tmp", O_RDWR);
    void *map = mmap(0, len, PROT_READ | PROT_WRITE,
                     MAP_ANON | MAP_SHARED, shmfd, 0);

    return unique_ptr<SharedMemory>(new PosixSharedMemory(shmfd, len, map));
}


TestResult grading::RunTest(std::function<TestResult ()> test, std::string name,
                            time_t timeout, std::ostream& errorStream)
{
    std::cout.flush();
    std::cerr.flush();
    std::clog.flush();

    pid_t child = fork();

    if (child == 0)
    {
        currentTestName = name;

        // Redirect cerr in the child process to the designated stream.
        std::cerr.rdbuf(errorStream.rdbuf());

        TestResult result = test();
        exit(static_cast<int>(result));
    }
    else
    {
        int status;
        int options = (timeout ? WNOHANG : 0);

        time_t start = time(nullptr);

        while (true)
        {
            pid_t result = waitpid(child, &status, options);

            // Success: the child process has returned.
            if (result == child)
                break;

            // Error in waitpid()?
            if (result < 0)
            {
                assert(errno == EINTR);
                continue;
            }

            // Child process isn't finished yet.
            const time_t now = time(nullptr);
            if ((now - start) > timeout)
            {
                kill(child, SIGKILL);
                waitpid(child, &status, 0);
                return TestResult::Timeout;
            }

            usleep(100);
        }

        return ProcessChildStatus(status);
    }
}