https://github.com/Kitware/CMake
Tip revision: fab7fe7ef5a5462952297611c1dd668a603e3a36 authored by Brad King on 17 March 2021, 14:16:33 UTC
CMake 3.20.0-rc5
CMake 3.20.0-rc5
Tip revision: fab7fe7
cmProcess.cxx
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmProcess.h"
#include <csignal>
#include <iostream>
#include <string>
#include <utility>
#include <cmext/algorithm>
#include "cmsys/Process.h"
#include "cmCTest.h"
#include "cmCTestRunTest.h"
#include "cmCTestTestHandler.h"
#include "cmGetPipes.h"
#include "cmStringAlgorithms.h"
#if defined(_WIN32)
# include <cm3p/kwiml/int.h>
#endif
#define CM_PROCESS_BUF_SIZE 65536
cmProcess::cmProcess(std::unique_ptr<cmCTestRunTest> runner)
: Runner(std::move(runner))
, Conv(cmProcessOutput::UTF8, CM_PROCESS_BUF_SIZE)
{
this->Timeout = cmDuration::zero();
this->TotalTime = cmDuration::zero();
this->ExitValue = 0;
this->Id = 0;
this->StartTime = std::chrono::steady_clock::time_point();
}
cmProcess::~cmProcess() = default;
void cmProcess::SetCommand(std::string const& command)
{
this->Command = command;
}
void cmProcess::SetCommandArguments(std::vector<std::string> const& args)
{
this->Arguments = args;
}
void cmProcess::SetWorkingDirectory(std::string const& dir)
{
this->WorkingDirectory = dir;
}
bool cmProcess::StartProcess(uv_loop_t& loop, std::vector<size_t>* affinity)
{
this->ProcessState = cmProcess::State::Error;
if (this->Command.empty()) {
return false;
}
this->StartTime = std::chrono::steady_clock::now();
this->ProcessArgs.clear();
// put the command as arg0
this->ProcessArgs.push_back(this->Command.c_str());
// now put the command arguments in
for (std::string const& arg : this->Arguments) {
this->ProcessArgs.push_back(arg.c_str());
}
this->ProcessArgs.push_back(nullptr); // null terminate the list
cm::uv_timer_ptr timer;
int status = timer.init(loop, this);
if (status != 0) {
cmCTestLog(this->Runner->GetCTest(), ERROR_MESSAGE,
"Error initializing timer: " << uv_strerror(status)
<< std::endl);
return false;
}
cm::uv_pipe_ptr pipe_writer;
cm::uv_pipe_ptr pipe_reader;
pipe_writer.init(loop, 0);
pipe_reader.init(loop, 0, this);
int fds[2] = { -1, -1 };
status = cmGetPipes(fds);
if (status != 0) {
cmCTestLog(this->Runner->GetCTest(), ERROR_MESSAGE,
"Error initializing pipe: " << uv_strerror(status)
<< std::endl);
return false;
}
uv_pipe_open(pipe_reader, fds[0]);
uv_pipe_open(pipe_writer, fds[1]);
uv_stdio_container_t stdio[3];
stdio[0].flags = UV_INHERIT_FD;
stdio[0].data.fd = 0;
stdio[1].flags = UV_INHERIT_STREAM;
stdio[1].data.stream = pipe_writer;
stdio[2] = stdio[1];
uv_process_options_t options = uv_process_options_t();
options.file = this->Command.data();
options.args = const_cast<char**>(this->ProcessArgs.data());
options.stdio_count = 3; // in, out and err
options.exit_cb = &cmProcess::OnExitCB;
options.stdio = stdio;
#if !defined(CMAKE_USE_SYSTEM_LIBUV)
std::vector<char> cpumask;
if (affinity && !affinity->empty()) {
cpumask.resize(static_cast<size_t>(uv_cpumask_size()), 0);
for (auto p : *affinity) {
cpumask[p] = 1;
}
options.cpumask = cpumask.data();
options.cpumask_size = cpumask.size();
} else {
options.cpumask = nullptr;
options.cpumask_size = 0;
}
#else
static_cast<void>(affinity);
#endif
status =
uv_read_start(pipe_reader, &cmProcess::OnAllocateCB, &cmProcess::OnReadCB);
if (status != 0) {
cmCTestLog(this->Runner->GetCTest(), ERROR_MESSAGE,
"Error starting read events: " << uv_strerror(status)
<< std::endl);
return false;
}
status = this->Process.spawn(loop, options, this);
if (status != 0) {
cmCTestLog(this->Runner->GetCTest(), ERROR_MESSAGE,
"Process not started\n " << this->Command << "\n["
<< uv_strerror(status) << "]\n");
return false;
}
this->PipeReader = std::move(pipe_reader);
this->Timer = std::move(timer);
this->StartTimer();
this->ProcessState = cmProcess::State::Executing;
return true;
}
void cmProcess::StartTimer()
{
auto* properties = this->Runner->GetTestProperties();
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(this->Timeout);
if (msec != std::chrono::milliseconds(0) || !properties->ExplicitTimeout) {
this->Timer.start(&cmProcess::OnTimeoutCB,
static_cast<uint64_t>(msec.count()), 0);
}
}
bool cmProcess::Buffer::GetLine(std::string& line)
{
// Scan for the next newline.
for (size_type sz = this->size(); this->Last != sz; ++this->Last) {
if ((*this)[this->Last] == '\n' || (*this)[this->Last] == '\0') {
// Extract the range first..last as a line.
const char* text = this->data() + this->First;
size_type length = this->Last - this->First;
while (length && text[length - 1] == '\r') {
length--;
}
line.assign(text, length);
// Start a new range for the next line.
++this->Last;
this->First = this->Last;
// Return the line extracted.
return true;
}
}
// Available data have been exhausted without a newline.
if (this->First != 0) {
// Move the partial line to the beginning of the buffer.
this->erase(this->begin(), this->begin() + this->First);
this->First = 0;
this->Last = this->size();
}
return false;
}
bool cmProcess::Buffer::GetLast(std::string& line)
{
// Return the partial last line, if any.
if (!this->empty()) {
line.assign(this->data(), this->size());
this->First = this->Last = 0;
this->clear();
return true;
}
return false;
}
void cmProcess::OnReadCB(uv_stream_t* stream, ssize_t nread,
const uv_buf_t* buf)
{
auto* self = static_cast<cmProcess*>(stream->data);
self->OnRead(nread, buf);
}
void cmProcess::OnRead(ssize_t nread, const uv_buf_t* buf)
{
std::string line;
if (nread > 0) {
std::string strdata;
this->Conv.DecodeText(buf->base, static_cast<size_t>(nread), strdata);
cm::append(this->Output, strdata);
while (this->Output.GetLine(line)) {
this->Runner->CheckOutput(line);
line.clear();
}
return;
}
if (nread == 0) {
return;
}
// The process will provide no more data.
if (nread != UV_EOF) {
auto error = static_cast<int>(nread);
cmCTestLog(this->Runner->GetCTest(), ERROR_MESSAGE,
"Error reading stream: " << uv_strerror(error) << std::endl);
}
// Look for partial last lines.
if (this->Output.GetLast(line)) {
this->Runner->CheckOutput(line);
}
this->ReadHandleClosed = true;
this->PipeReader.reset();
if (this->ProcessHandleClosed) {
uv_timer_stop(this->Timer);
this->Finish();
}
}
void cmProcess::OnAllocateCB(uv_handle_t* handle, size_t suggested_size,
uv_buf_t* buf)
{
auto* self = static_cast<cmProcess*>(handle->data);
self->OnAllocate(suggested_size, buf);
}
void cmProcess::OnAllocate(size_t /*suggested_size*/, uv_buf_t* buf)
{
if (this->Buf.size() != CM_PROCESS_BUF_SIZE) {
this->Buf.resize(CM_PROCESS_BUF_SIZE);
}
*buf =
uv_buf_init(this->Buf.data(), static_cast<unsigned int>(this->Buf.size()));
}
void cmProcess::OnTimeoutCB(uv_timer_t* timer)
{
auto* self = static_cast<cmProcess*>(timer->data);
self->OnTimeout();
}
void cmProcess::OnTimeout()
{
this->ProcessState = cmProcess::State::Expired;
bool const was_still_reading = !this->ReadHandleClosed;
if (!this->ReadHandleClosed) {
this->ReadHandleClosed = true;
this->PipeReader.reset();
}
if (!this->ProcessHandleClosed) {
// Kill the child and let our on-exit handler finish the test.
cmsysProcess_KillPID(static_cast<unsigned long>(this->Process->pid));
} else if (was_still_reading) {
// Our on-exit handler already ran but did not finish the test
// because we were still reading output. We've just dropped
// our read handler, so we need to finish the test now.
this->Finish();
}
}
void cmProcess::OnExitCB(uv_process_t* process, int64_t exit_status,
int term_signal)
{
auto* self = static_cast<cmProcess*>(process->data);
self->OnExit(exit_status, term_signal);
}
void cmProcess::OnExit(int64_t exit_status, int term_signal)
{
if (this->ProcessState != cmProcess::State::Expired) {
if (
#if defined(_WIN32)
((DWORD)exit_status & 0xF0000000) == 0xC0000000
#else
term_signal != 0
#endif
) {
this->ProcessState = cmProcess::State::Exception;
} else {
this->ProcessState = cmProcess::State::Exited;
}
}
// Record exit information.
this->ExitValue = exit_status;
this->Signal = term_signal;
this->ProcessHandleClosed = true;
if (this->ReadHandleClosed) {
uv_timer_stop(this->Timer);
this->Finish();
}
}
void cmProcess::Finish()
{
this->TotalTime = std::chrono::steady_clock::now() - this->StartTime;
// Because of a processor clock scew the runtime may become slightly
// negative. If someone changed the system clock while the process was
// running this may be even more. Make sure not to report a negative
// duration here.
if (this->TotalTime <= cmDuration::zero()) {
this->TotalTime = cmDuration::zero();
}
this->Runner->FinalizeTest();
}
cmProcess::State cmProcess::GetProcessStatus()
{
return this->ProcessState;
}
void cmProcess::ChangeTimeout(cmDuration t)
{
this->Timeout = t;
this->StartTimer();
}
void cmProcess::ResetStartTime()
{
this->StartTime = std::chrono::steady_clock::now();
}
cmProcess::Exception cmProcess::GetExitException() const
{
auto exception = Exception::None;
#if defined(_WIN32) && !defined(__CYGWIN__)
auto exit_code = (DWORD)this->ExitValue;
if ((exit_code & 0xF0000000) != 0xC0000000) {
return exception;
}
if (exit_code) {
switch (exit_code) {
case STATUS_DATATYPE_MISALIGNMENT:
case STATUS_ACCESS_VIOLATION:
case STATUS_IN_PAGE_ERROR:
case STATUS_INVALID_HANDLE:
case STATUS_NONCONTINUABLE_EXCEPTION:
case STATUS_INVALID_DISPOSITION:
case STATUS_ARRAY_BOUNDS_EXCEEDED:
case STATUS_STACK_OVERFLOW:
exception = Exception::Fault;
break;
case STATUS_FLOAT_DENORMAL_OPERAND:
case STATUS_FLOAT_DIVIDE_BY_ZERO:
case STATUS_FLOAT_INEXACT_RESULT:
case STATUS_FLOAT_INVALID_OPERATION:
case STATUS_FLOAT_OVERFLOW:
case STATUS_FLOAT_STACK_CHECK:
case STATUS_FLOAT_UNDERFLOW:
# ifdef STATUS_FLOAT_MULTIPLE_FAULTS
case STATUS_FLOAT_MULTIPLE_FAULTS:
# endif
# ifdef STATUS_FLOAT_MULTIPLE_TRAPS
case STATUS_FLOAT_MULTIPLE_TRAPS:
# endif
case STATUS_INTEGER_DIVIDE_BY_ZERO:
case STATUS_INTEGER_OVERFLOW:
exception = Exception::Numerical;
break;
case STATUS_CONTROL_C_EXIT:
exception = Exception::Interrupt;
break;
case STATUS_ILLEGAL_INSTRUCTION:
case STATUS_PRIVILEGED_INSTRUCTION:
exception = Exception::Illegal;
break;
default:
exception = Exception::Other;
}
}
#else
if (this->Signal) {
switch (this->Signal) {
case SIGSEGV:
exception = Exception::Fault;
break;
case SIGFPE:
exception = Exception::Numerical;
break;
case SIGINT:
exception = Exception::Interrupt;
break;
case SIGILL:
exception = Exception::Illegal;
break;
default:
exception = Exception::Other;
}
}
#endif
return exception;
}
std::string cmProcess::GetExitExceptionString() const
{
std::string exception_str;
#if defined(_WIN32)
switch (this->ExitValue) {
case STATUS_CONTROL_C_EXIT:
exception_str = "User interrupt";
break;
case STATUS_FLOAT_DENORMAL_OPERAND:
exception_str = "Floating-point exception (denormal operand)";
break;
case STATUS_FLOAT_DIVIDE_BY_ZERO:
exception_str = "Divide-by-zero";
break;
case STATUS_FLOAT_INEXACT_RESULT:
exception_str = "Floating-point exception (inexact result)";
break;
case STATUS_FLOAT_INVALID_OPERATION:
exception_str = "Invalid floating-point operation";
break;
case STATUS_FLOAT_OVERFLOW:
exception_str = "Floating-point overflow";
break;
case STATUS_FLOAT_STACK_CHECK:
exception_str = "Floating-point stack check failed";
break;
case STATUS_FLOAT_UNDERFLOW:
exception_str = "Floating-point underflow";
break;
# ifdef STATUS_FLOAT_MULTIPLE_FAULTS
case STATUS_FLOAT_MULTIPLE_FAULTS:
exception_str = "Floating-point exception (multiple faults)";
break;
# endif
# ifdef STATUS_FLOAT_MULTIPLE_TRAPS
case STATUS_FLOAT_MULTIPLE_TRAPS:
exception_str = "Floating-point exception (multiple traps)";
break;
# endif
case STATUS_INTEGER_DIVIDE_BY_ZERO:
exception_str = "Integer divide-by-zero";
break;
case STATUS_INTEGER_OVERFLOW:
exception_str = "Integer overflow";
break;
case STATUS_DATATYPE_MISALIGNMENT:
exception_str = "Datatype misalignment";
break;
case STATUS_ACCESS_VIOLATION:
exception_str = "Access violation";
break;
case STATUS_IN_PAGE_ERROR:
exception_str = "In-page error";
break;
case STATUS_INVALID_HANDLE:
exception_str = "Invalid handle";
break;
case STATUS_NONCONTINUABLE_EXCEPTION:
exception_str = "Noncontinuable exception";
break;
case STATUS_INVALID_DISPOSITION:
exception_str = "Invalid disposition";
break;
case STATUS_ARRAY_BOUNDS_EXCEEDED:
exception_str = "Array bounds exceeded";
break;
case STATUS_STACK_OVERFLOW:
exception_str = "Stack overflow";
break;
case STATUS_ILLEGAL_INSTRUCTION:
exception_str = "Illegal instruction";
break;
case STATUS_PRIVILEGED_INSTRUCTION:
exception_str = "Privileged instruction";
break;
case STATUS_NO_MEMORY:
default:
char buf[1024];
const char* fmt = "Exit code 0x%" KWIML_INT_PRIx64 "\n";
_snprintf(buf, 1024, fmt, this->ExitValue);
exception_str.assign(buf);
}
#else
switch (this->Signal) {
# ifdef SIGSEGV
case SIGSEGV:
exception_str = "Segmentation fault";
break;
# endif
# ifdef SIGBUS
# if !defined(SIGSEGV) || SIGBUS != SIGSEGV
case SIGBUS:
exception_str = "Bus error";
break;
# endif
# endif
# ifdef SIGFPE
case SIGFPE:
exception_str = "Floating-point exception";
break;
# endif
# ifdef SIGILL
case SIGILL:
exception_str = "Illegal instruction";
break;
# endif
# ifdef SIGINT
case SIGINT:
exception_str = "User interrupt";
break;
# endif
# ifdef SIGABRT
case SIGABRT:
exception_str = "Subprocess aborted";
break;
# endif
# ifdef SIGKILL
case SIGKILL:
exception_str = "Subprocess killed";
break;
# endif
# ifdef SIGTERM
case SIGTERM:
exception_str = "Subprocess terminated";
break;
# endif
# ifdef SIGHUP
case SIGHUP:
exception_str = "SIGHUP";
break;
# endif
# ifdef SIGQUIT
case SIGQUIT:
exception_str = "SIGQUIT";
break;
# endif
# ifdef SIGTRAP
case SIGTRAP:
exception_str = "SIGTRAP";
break;
# endif
# ifdef SIGIOT
# if !defined(SIGABRT) || SIGIOT != SIGABRT
case SIGIOT:
exception_str = "SIGIOT";
break;
# endif
# endif
# ifdef SIGUSR1
case SIGUSR1:
exception_str = "SIGUSR1";
break;
# endif
# ifdef SIGUSR2
case SIGUSR2:
exception_str = "SIGUSR2";
break;
# endif
# ifdef SIGPIPE
case SIGPIPE:
exception_str = "SIGPIPE";
break;
# endif
# ifdef SIGALRM
case SIGALRM:
exception_str = "SIGALRM";
break;
# endif
# ifdef SIGSTKFLT
case SIGSTKFLT:
exception_str = "SIGSTKFLT";
break;
# endif
# ifdef SIGCHLD
case SIGCHLD:
exception_str = "SIGCHLD";
break;
# elif defined(SIGCLD)
case SIGCLD:
exception_str = "SIGCLD";
break;
# endif
# ifdef SIGCONT
case SIGCONT:
exception_str = "SIGCONT";
break;
# endif
# ifdef SIGSTOP
case SIGSTOP:
exception_str = "SIGSTOP";
break;
# endif
# ifdef SIGTSTP
case SIGTSTP:
exception_str = "SIGTSTP";
break;
# endif
# ifdef SIGTTIN
case SIGTTIN:
exception_str = "SIGTTIN";
break;
# endif
# ifdef SIGTTOU
case SIGTTOU:
exception_str = "SIGTTOU";
break;
# endif
# ifdef SIGURG
case SIGURG:
exception_str = "SIGURG";
break;
# endif
# ifdef SIGXCPU
case SIGXCPU:
exception_str = "SIGXCPU";
break;
# endif
# ifdef SIGXFSZ
case SIGXFSZ:
exception_str = "SIGXFSZ";
break;
# endif
# ifdef SIGVTALRM
case SIGVTALRM:
exception_str = "SIGVTALRM";
break;
# endif
# ifdef SIGPROF
case SIGPROF:
exception_str = "SIGPROF";
break;
# endif
# ifdef SIGWINCH
case SIGWINCH:
exception_str = "SIGWINCH";
break;
# endif
# ifdef SIGPOLL
case SIGPOLL:
exception_str = "SIGPOLL";
break;
# endif
# ifdef SIGIO
# if !defined(SIGPOLL) || SIGIO != SIGPOLL
case SIGIO:
exception_str = "SIGIO";
break;
# endif
# endif
# ifdef SIGPWR
case SIGPWR:
exception_str = "SIGPWR";
break;
# endif
# ifdef SIGSYS
case SIGSYS:
exception_str = "SIGSYS";
break;
# endif
# ifdef SIGUNUSED
# if !defined(SIGSYS) || SIGUNUSED != SIGSYS
case SIGUNUSED:
exception_str = "SIGUNUSED";
break;
# endif
# endif
default:
exception_str = cmStrCat("Signal ", this->Signal);
}
#endif
return exception_str;
}