Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/lib/Basics/process-utils.cpp

1305 lines
37 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Esteban Lombeyda
////////////////////////////////////////////////////////////////////////////////
#include "process-utils.h"
#if defined(TRI_HAVE_MACOS_MEM_STATS)
#include <sys/types.h>
#include <sys/sysctl.h>
#endif
#ifdef TRI_HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#endif
#ifdef TRI_HAVE_MACH
#include <mach/mach_host.h>
#include <mach/mach_port.h>
#include <mach/mach_traps.h>
#include <mach/task.h>
#include <mach/thread_act.h>
#include <mach/vm_map.h>
#endif
#ifdef _WIN32
#include <Psapi.h>
#include <TlHelp32.h>
#endif
#include "Logger/Logger.h"
#include "Basics/MutexLocker.h"
#include "Basics/StringBuffer.h"
#include "Basics/StringUtils.h"
#include "Basics/Thread.h"
#include "Basics/tri-strings.h"
using namespace arangodb;
////////////////////////////////////////////////////////////////////////////////
/// @brief physical memory
////////////////////////////////////////////////////////////////////////////////
uint64_t TRI_PhysicalMemory;
////////////////////////////////////////////////////////////////////////////////
/// @brief contains all data documented by "proc"
///
/// @see man 5 proc for the state of a process
////////////////////////////////////////////////////////////////////////////////
#ifdef TRI_HAVE_LINUX_PROC
typedef struct process_state_s {
pid_t pid;
/* size was choosen arbitrary */
char comm[128];
char state;
int ppid;
int pgrp;
int session;
int tty_nr;
int tpgid;
unsigned flags;
/* lu */
unsigned long minflt;
unsigned long cminflt;
unsigned long majflt;
unsigned long cmajflt;
unsigned long utime;
unsigned long stime;
/* ld */
long cutime;
long cstime;
long priority;
long nice;
long num_threads;
long itrealvalue;
/* llu */
long long unsigned int starttime;
/* lu */
unsigned long vsize;
/* ld */
long rss;
/* lu */
// cppcheck-suppress *
unsigned long rsslim;
// cppcheck-suppress *
unsigned long startcode;
// cppcheck-suppress *
unsigned long endcode;
// cppcheck-suppress *
unsigned long startstack;
// cppcheck-suppress *
unsigned long kstkesp;
// cppcheck-suppress *
unsigned long signal;
/* obsolete lu*/
// cppcheck-suppress *
unsigned long blocked;
// cppcheck-suppress *
unsigned long sigignore;
// cppcheck-suppress *
unsigned int sigcatch;
// cppcheck-suppress *
unsigned long wchan;
/* no maintained lu */
// cppcheck-suppress *
unsigned long nswap;
// cppcheck-suppress *
unsigned long cnswap;
/* d */
// cppcheck-suppress *
int exit_signal;
// cppcheck-suppress *
int processor;
/* u */
// cppcheck-suppress *
unsigned rt_priority;
// cppcheck-suppress *
unsigned policy;
/* llu */
// cppcheck-suppress *
long long unsigned int delayacct_blkio_ticks;
/* lu */
// cppcheck-suppress *
unsigned long guest_time;
/* ld */
// cppcheck-suppress *
long cguest_time;
} process_state_t;
#endif
////////////////////////////////////////////////////////////////////////////////
/// @brief all external processes
////////////////////////////////////////////////////////////////////////////////
static std::vector<TRI_external_t*> ExternalProcesses;
////////////////////////////////////////////////////////////////////////////////
/// @brief lock for protected access to vector ExternalProcesses
////////////////////////////////////////////////////////////////////////////////
static arangodb::Mutex ExternalProcessesLock;
////////////////////////////////////////////////////////////////////////////////
/// @brief creates pipe pair
////////////////////////////////////////////////////////////////////////////////
#ifndef _WIN32
static bool CreatePipes(int* pipe_server_to_child, int* pipe_child_to_server) {
if (pipe(pipe_server_to_child) == -1) {
LOG(ERR) << "cannot create pipe";
return false;
}
if (pipe(pipe_child_to_server) == -1) {
LOG(ERR) << "cannot create pipe";
close(pipe_server_to_child[0]);
close(pipe_server_to_child[1]);
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief starts external process
////////////////////////////////////////////////////////////////////////////////
static void StartExternalProcess(TRI_external_t* external, bool usePipes) {
int pipe_server_to_child[2];
int pipe_child_to_server[2];
if (usePipes) {
bool ok = CreatePipes(pipe_server_to_child, pipe_child_to_server);
if (!ok) {
external->_status = TRI_EXT_PIPE_FAILED;
return;
}
}
int processPid = fork();
// child process
if (processPid == 0) {
// set stdin and stdout of child process
if (usePipes) {
dup2(pipe_server_to_child[0], 0);
dup2(pipe_child_to_server[1], 1);
fcntl(0, F_SETFD, 0);
fcntl(1, F_SETFD, 0);
fcntl(2, F_SETFD, 0);
// close pipes
close(pipe_server_to_child[0]);
close(pipe_server_to_child[1]);
close(pipe_child_to_server[0]);
close(pipe_child_to_server[1]);
} else {
close(0);
fcntl(1, F_SETFD, 0);
fcntl(2, F_SETFD, 0);
}
// ignore signals in worker process
signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
// execute worker
execvp(external->_executable, external->_arguments);
_exit(1);
}
// parent
if (processPid == -1) {
LOG(ERR) << "fork failed";
if (usePipes) {
close(pipe_server_to_child[0]);
close(pipe_server_to_child[1]);
close(pipe_child_to_server[0]);
close(pipe_child_to_server[1]);
}
external->_status = TRI_EXT_FORK_FAILED;
return;
}
LOG(DEBUG) << "fork succeeded, child pid: " << processPid;
if (usePipes) {
close(pipe_server_to_child[0]);
close(pipe_child_to_server[1]);
external->_writePipe = pipe_server_to_child[1];
external->_readPipe = pipe_child_to_server[0];
} else {
external->_writePipe = -1;
external->_readPipe = -1;
}
external->_pid = processPid;
external->_status = TRI_EXT_RUNNING;
}
#else
static bool createPipes(HANDLE* hChildStdinRd, HANDLE* hChildStdinWr,
HANDLE* hChildStdoutRd, HANDLE* hChildStdoutWr) {
// set the bInheritHandle flag so pipe handles are inherited
SECURITY_ATTRIBUTES saAttr;
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
// create a pipe for the child process's STDOUT
if (!CreatePipe(hChildStdoutRd, hChildStdoutWr, &saAttr, 0)) {
LOG(ERR) << ""
<< "stdout pipe creation failed";
return false;
}
// create a pipe for the child process's STDIN
if (!CreatePipe(hChildStdinRd, hChildStdinWr, &saAttr, 0)) {
CloseHandle(hChildStdoutRd);
CloseHandle(hChildStdoutWr);
LOG(ERR) << "stdin pipe creation failed";
return false;
}
return true;
}
#define appendChar(buf, x) \
do { \
err = TRI_AppendCharStringBuffer((buf), (x)); \
if (err != TRI_ERROR_NO_ERROR) { \
return err; \
} \
} while (false);
static int appendQuotedArg(TRI_string_buffer_t* buf, char const* p) {
int err;
appendChar(buf, '"');
while (*p != 0) {
unsigned int i;
unsigned int NumberBackslashes = 0;
char const* q = p;
while (*q == '\\') {
++q;
++NumberBackslashes;
}
if (*q == 0) {
// Escape all backslashes, but let the terminating
// double quotation mark we add below be interpreted
// as a metacharacter.
for (i = 0; i < NumberBackslashes; i++) {
appendChar(buf, '\\');
appendChar(buf, '\\');
}
break;
} else if (*q == '"') {
// Escape all backslashes and the following
// double quotation mark.
for (i = 0; i < NumberBackslashes; i++) {
appendChar(buf, '\\');
appendChar(buf, '\\');
}
appendChar(buf, '\\');
appendChar(buf, *q);
} else {
// Backslashes aren't special here.
for (i = 0; i < NumberBackslashes; i++) {
appendChar(buf, '\\');
}
appendChar(buf, *q);
}
p = ++q;
}
appendChar(buf, '"');
return TRI_ERROR_NO_ERROR;
}
static char* makeWindowsArgs(TRI_external_t* external) {
TRI_string_buffer_t* buf;
size_t i;
int err = TRI_ERROR_NO_ERROR;
char* res;
buf = TRI_CreateStringBuffer(TRI_UNKNOWN_MEM_ZONE);
if (buf == NULL) {
return NULL;
}
TRI_ReserveStringBuffer(buf, 1024);
err = appendQuotedArg(buf, external->_executable);
if (err != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buf);
return NULL;
}
for (i = 1; i < external->_numberArguments; i++) {
err = TRI_AppendCharStringBuffer(buf, ' ');
if (err != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buf);
return NULL;
}
err = appendQuotedArg(buf, external->_arguments[i]);
}
res = TRI_StealStringBuffer(buf);
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buf);
return res;
}
static bool startProcess(TRI_external_t* external, HANDLE rd, HANDLE wr) {
char* args;
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
BOOL bFuncRetn = FALSE;
args = makeWindowsArgs(external);
if (args == NULL) {
LOG(ERR) << "execute of '" << external->_executable
<< "' failed making args";
return false;
}
// set up members of the PROCESS_INFORMATION structure
ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
// set up members of the STARTUPINFO structure
ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
siStartInfo.cb = sizeof(STARTUPINFO);
siStartInfo.dwFlags = STARTF_USESTDHANDLES;
siStartInfo.hStdInput = rd ? rd : GetStdHandle(STD_INPUT_HANDLE);
siStartInfo.hStdOutput = wr ? wr : GetStdHandle(STD_OUTPUT_HANDLE);
siStartInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
// create the child process
bFuncRetn = CreateProcess(NULL,
args, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
CREATE_NEW_PROCESS_GROUP, // creation flags
NULL, // use parent's environment
NULL, // use parent's current directory
&siStartInfo, // STARTUPINFO pointer
&piProcInfo); // receives PROCESS_INFORMATION
TRI_Free(TRI_UNKNOWN_MEM_ZONE, args);
if (bFuncRetn == FALSE) {
LOG(ERR) << "execute of '" << external->_executable
<< "' failed, error: " << GetLastError();
return false;
} else {
external->_pid = piProcInfo.dwProcessId;
external->_process = piProcInfo.hProcess;
CloseHandle(piProcInfo.hThread);
return true;
}
}
static void StartExternalProcess(TRI_external_t* external, bool usePipes) {
HANDLE hChildStdinRd = NULL, hChildStdinWr = NULL;
HANDLE hChildStdoutRd = NULL, hChildStdoutWr = NULL;
bool fSuccess;
if (usePipes) {
fSuccess = createPipes(&hChildStdinRd, &hChildStdinWr, &hChildStdoutRd,
&hChildStdoutWr);
if (!fSuccess) {
external->_status = TRI_EXT_PIPE_FAILED;
return;
}
}
// now create the child process.
fSuccess = startProcess(external, hChildStdinRd, hChildStdoutWr);
if (!fSuccess) {
external->_status = TRI_EXT_FORK_FAILED;
if (hChildStdoutRd != NULL) {
CloseHandle(hChildStdoutRd);
}
if (hChildStdoutWr != NULL) {
CloseHandle(hChildStdoutWr);
}
if (hChildStdinRd != NULL) {
CloseHandle(hChildStdinRd);
}
if (hChildStdinWr != NULL) {
CloseHandle(hChildStdinWr);
}
return;
}
CloseHandle(hChildStdinRd);
CloseHandle(hChildStdoutWr);
external->_readPipe = hChildStdoutRd;
external->_writePipe = hChildStdinWr;
external->_status = TRI_EXT_RUNNING;
}
#endif
////////////////////////////////////////////////////////////////////////////////
/// @brief converts usec and sec into seconds
////////////////////////////////////////////////////////////////////////////////
#ifdef ARANGODB_HAVE_GETRUSAGE
uint64_t TRI_MicrosecondsTv(struct timeval* tv) {
time_t sec = tv->tv_sec;
suseconds_t usec = tv->tv_usec;
while (usec < 0) {
usec += 1000000;
sec -= 1;
}
return (sec * 1000000LL) + usec;
}
#endif
////////////////////////////////////////////////////////////////////////////////
/// @brief returns information about the current process
////////////////////////////////////////////////////////////////////////////////
#ifdef TRI_HAVE_LINUX_PROC
TRI_process_info_t TRI_ProcessInfoSelf() {
return TRI_ProcessInfo(Thread::currentProcessId());
}
#elif ARANGODB_HAVE_GETRUSAGE
TRI_process_info_t TRI_ProcessInfoSelf() {
TRI_process_info_t result;
memset(&result, 0, sizeof(result));
result._scClkTck = 1000000;
struct rusage used;
int res = getrusage(RUSAGE_SELF, &used);
if (res == 0) {
result._minorPageFaults = used.ru_minflt;
result._majorPageFaults = used.ru_majflt;
result._systemTime = TRI_MicrosecondsTv(&used.ru_stime);
result._userTime = TRI_MicrosecondsTv(&used.ru_utime);
// ru_maxrss is the resident set size in kilobytes. need to multiply with
// 1024 to get the number of bytes
result._residentSize = used.ru_maxrss * ARANGODB_GETRUSAGE_MAXRSS_UNIT;
}
#ifdef TRI_HAVE_MACH
{
kern_return_t rc;
thread_array_t array;
mach_msg_type_number_t count;
rc = task_threads(mach_task_self(), &array, &count);
if (rc == KERN_SUCCESS) {
unsigned int i;
result._numberThreads = count;
for (i = 0; i < count; ++i) {
mach_port_deallocate(mach_task_self(), array[i]);
}
vm_deallocate(mach_task_self(), (vm_address_t)array,
sizeof(thread_t) * count);
}
}
{
kern_return_t rc;
struct task_basic_info t_info;
mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
rc = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&t_info,
&t_info_count);
if (rc == KERN_SUCCESS) {
result._virtualSize = t_info.virtual_size;
result._residentSize = t_info.resident_size;
} else {
result._virtualSize = 0;
result._residentSize = 0;
}
}
#endif
return result;
}
#else
/// --------------------------------------------
/// transform a file time to timestamp
/// Particularities:
/// 1. FileTime can save a date at Jan, 1 1601
/// timestamp saves dates at 1970
/// --------------------------------------------
static uint64_t _TimeAmount(FILETIME* ft) {
uint64_t ts, help;
ts = ft->dwLowDateTime;
help = ft->dwHighDateTime;
help = help << 32;
ts |= help;
/// at moment without transformation
return ts;
}
static time_t _FileTime_to_POSIX(FILETIME* ft) {
LONGLONG ts, help;
ts = ft->dwLowDateTime;
help = ft->dwHighDateTime;
help = help << 32;
ts |= help;
return (ts - 116444736000000000) / 10000000;
}
TRI_process_info_t TRI_ProcessInfoSelf() {
TRI_process_info_t result;
PROCESS_MEMORY_COUNTERS_EX pmc;
memset(&result, 0, sizeof(result));
pmc.cb = sizeof(PROCESS_MEMORY_COUNTERS_EX);
// compiler warning wird in kauf genommen!c
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms684874(v=vs.85).aspx
if (GetProcessMemoryInfo(GetCurrentProcess(), (PPROCESS_MEMORY_COUNTERS)&pmc,
pmc.cb)) {
result._majorPageFaults = pmc.PageFaultCount;
// there is not any corresponce to minflt in linux
result._minorPageFaults = 0;
// from MSDN:
// "The working set is the amount of memory physically mapped to the process
// context at a given time.
// Memory in the paged pool is system memory that can be transferred to the
// paging file on disk(paged) when
// it is not being used. Memory in the nonpaged pool is system memory that
// cannot be paged to disk as long as
// the corresponding objects are allocated. The pagefile usage represents
// how much memory is set aside for the
// process in the system paging file. When memory usage is too high, the
// virtual memory manager pages selected
// memory to disk. When a thread needs a page that is not in memory, the
// memory manager reloads it from the
// paging file."
result._residentSize = pmc.WorkingSetSize;
result._virtualSize = pmc.PrivateUsage;
}
/// computing times
FILETIME creationTime, exitTime, kernelTime, userTime;
if (GetProcessTimes(GetCurrentProcess(), &creationTime, &exitTime,
&kernelTime, &userTime)) {
// see remarks in
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms683223(v=vs.85).aspx
// value in seconds
result._scClkTck = 10000000; // 1e7
result._systemTime = _TimeAmount(&kernelTime);
result._userTime = _TimeAmount(&userTime);
// for computing the timestamps of creation and exit time
// the function '_FileTime_to_POSIX' should be called
}
/// computing number of threads
DWORD myPID = GetCurrentProcessId();
HANDLE snapShot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, myPID);
if (snapShot != INVALID_HANDLE_VALUE) {
THREADENTRY32 te32;
te32.dwSize = sizeof(THREADENTRY32);
if (Thread32First(snapShot, &te32)) {
result._numberThreads++;
while (Thread32Next(snapShot, &te32)) {
if (te32.th32OwnerProcessID == myPID) {
result._numberThreads++;
}
}
}
CloseHandle(snapShot);
}
return result;
}
#endif
////////////////////////////////////////////////////////////////////////////////
/// @brief returns information about the process
////////////////////////////////////////////////////////////////////////////////
#ifdef TRI_HAVE_LINUX_PROC
TRI_process_info_t TRI_ProcessInfo(TRI_pid_t pid) {
TRI_process_info_t result;
memset(&result, 0, sizeof(result));
char fn[1024];
snprintf(fn, sizeof(fn), "/proc/%d/stat", pid);
int fd = open(fn, O_RDONLY);
if (fd >= 0) {
char str[1024];
process_state_t st;
size_t n;
memset(&str, 0, sizeof(str));
n = read(fd, str, sizeof(str));
close(fd);
if (n == 0) {
return result;
}
// fix process name in buffer. sadly, the process name might contain
// whitespace
// and the sscanf format '%s' will not honor that
char* p = &str[0];
char* e = p + n;
// first skip over the process id at the start of the string
while (*p != '\0' && p < e && *p != ' ') {
++p;
}
// skip space
if (p < e && *p == ' ') {
++p;
}
// check if filename is contained in parentheses
if (p < e && *p == '(') {
// yes
++p;
// now replace all whitespace within the process name with underscores
// otherwise the sscanf below will happily parse the string incorrectly
while (p < e && *p != '0' && *p != ')') {
if (*p == ' ') {
*p = '_';
}
++p;
}
}
// cppcheck-suppress *
sscanf(str,
"%d %s %c %d %d %d %d %d %u %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld "
"%ld %ld %llu %lu %ld",
&st.pid, (char*)&st.comm, &st.state, &st.ppid, &st.pgrp, &st.session,
&st.tty_nr, &st.tpgid, &st.flags, &st.minflt, &st.cminflt,
&st.majflt, &st.cmajflt, &st.utime, &st.stime, &st.cutime,
&st.cstime, &st.priority, &st.nice, &st.num_threads, &st.itrealvalue,
&st.starttime, &st.vsize, &st.rss);
result._minorPageFaults = st.minflt;
result._majorPageFaults = st.majflt;
result._userTime = st.utime;
result._systemTime = st.stime;
result._numberThreads = st.num_threads;
// st.rss is measured in number of pages, we need to multiply by page size
// to get the actual amount
result._residentSize = st.rss * getpagesize();
result._virtualSize = st.vsize;
result._scClkTck = sysconf(_SC_CLK_TCK);
}
return result;
}
#else
TRI_process_info_t TRI_ProcessInfo(TRI_pid_t pid) {
TRI_process_info_t result;
memset(&result, 0, sizeof(result));
result._scClkTck = 1;
return result;
}
#endif
////////////////////////////////////////////////////////////////////////////////
/// @brief sets the process name
////////////////////////////////////////////////////////////////////////////////
void TRI_SetProcessTitle(char const* title) {
#ifdef TRI_HAVE_SYS_PRCTL_H
prctl(PR_SET_NAME, title, 0, 0, 0);
#endif
}
////////////////////////////////////////////////////////////////////////////////
/// @brief frees an external process structure
////////////////////////////////////////////////////////////////////////////////
static void FreeExternal(TRI_external_t* ext) {
TRI_Free(TRI_CORE_MEM_ZONE, ext->_executable);
for (size_t i = 0; i < ext->_numberArguments; i++) {
TRI_Free(TRI_CORE_MEM_ZONE, ext->_arguments[i]);
}
TRI_Free(TRI_CORE_MEM_ZONE, ext->_arguments);
#ifndef _WIN32
if (ext->_readPipe != -1) {
close(ext->_readPipe);
}
if (ext->_writePipe != -1) {
close(ext->_writePipe);
}
#else
CloseHandle(ext->_process);
if (ext->_readPipe != NULL) {
CloseHandle(ext->_readPipe);
}
if (ext->_writePipe != NULL) {
CloseHandle(ext->_writePipe);
}
#endif
TRI_Free(TRI_CORE_MEM_ZONE, ext);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief starts an external process
////////////////////////////////////////////////////////////////////////////////
void TRI_CreateExternalProcess(char const* executable, char const** arguments,
size_t n, bool usePipes,
TRI_external_id_t* pid) {
// create the external structure
TRI_external_t* external = static_cast<TRI_external_t*>(
TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_external_t), true));
if (external == nullptr) {
// gracefully handle out of memory
pid->_pid = TRI_INVALID_PROCESS_ID;
return;
}
external->_executable = TRI_DuplicateString(executable);
external->_numberArguments = n + 1;
external->_arguments = static_cast<char**>(
TRI_Allocate(TRI_CORE_MEM_ZONE, (n + 2) * sizeof(char*), true));
if (external->_arguments == nullptr) {
// gracefully handle out of memory
pid->_pid = TRI_INVALID_PROCESS_ID;
FreeExternal(external);
return;
}
external->_arguments[0] = TRI_DuplicateString(executable);
for (size_t i = 0; i < n; ++i) {
external->_arguments[i + 1] = TRI_DuplicateString(arguments[i]);
}
external->_arguments[n + 1] = nullptr;
external->_status = TRI_EXT_NOT_STARTED;
StartExternalProcess(external, usePipes);
if (external->_status != TRI_EXT_RUNNING) {
pid->_pid = TRI_INVALID_PROCESS_ID;
FreeExternal(external);
return;
}
LOG(DEBUG) << "adding process " << external->_pid << " to list";
// Note that the following deals with different types under windows,
// however, this code here can be written in a platform-independent
// way:
pid->_pid = external->_pid;
pid->_readPipe = external->_readPipe;
pid->_writePipe = external->_writePipe;
MUTEX_LOCKER(mutexLocker, ExternalProcessesLock);
try {
ExternalProcesses.push_back(external);
} catch (...) {
pid->_pid = TRI_INVALID_PROCESS_ID;
FreeExternal(external);
return;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the status of an external process
////////////////////////////////////////////////////////////////////////////////
TRI_external_status_t TRI_CheckExternalProcess(TRI_external_id_t pid,
bool wait) {
TRI_external_status_t status;
status._status = TRI_EXT_NOT_FOUND;
status._exitStatus = 0;
TRI_external_t* external = nullptr;
{
MUTEX_LOCKER(mutexLocker, ExternalProcessesLock);
for (auto& it : ExternalProcesses) {
if (it->_pid == pid._pid) {
external = it;
break;
}
}
}
if (external == nullptr) {
status._errorMessage =
std::string("the pid you're looking for is not in our list: ") +
arangodb::basics::StringUtils::itoa(static_cast<int64_t>(pid._pid));
status._status = TRI_EXT_NOT_FOUND;
LOG(WARN) << "checkExternal: pid not found: " << pid._pid;
return status;
}
if (external->_status == TRI_EXT_RUNNING ||
external->_status == TRI_EXT_STOPPED) {
#ifndef _WIN32
int opts;
int loc = 0;
if (wait) {
opts = WUNTRACED;
} else {
opts = WNOHANG | WUNTRACED;
}
TRI_pid_t res = waitpid(external->_pid, &loc, opts);
if (res == 0) {
if (wait) {
status._errorMessage =
std::string("waitpid returned 0 for pid while it shouldn't ") +
arangodb::basics::StringUtils::itoa(external->_pid);
if (WIFEXITED(loc)) {
external->_status = TRI_EXT_TERMINATED;
external->_exitStatus = WEXITSTATUS(loc);
} else if (WIFSIGNALED(loc)) {
external->_status = TRI_EXT_ABORTED;
external->_exitStatus = WTERMSIG(loc);
} else if (WIFSTOPPED(loc)) {
external->_status = TRI_EXT_STOPPED;
external->_exitStatus = 0;
} else {
external->_status = TRI_EXT_ABORTED;
external->_exitStatus = 0;
}
} else {
external->_exitStatus = 0;
}
} else if (res == -1) {
TRI_set_errno(TRI_ERROR_SYS_ERROR);
LOG(WARN) << "waitpid returned error for pid " << external->_pid << " ("
<< wait << "): " << TRI_last_error();
status._errorMessage =
std::string("waitpid returned error for pid ") +
arangodb::basics::StringUtils::itoa(external->_pid) +
std::string(": ") + std::string(TRI_last_error());
} else if (static_cast<TRI_pid_t>(external->_pid) ==
static_cast<TRI_pid_t>(res)) {
if (WIFEXITED(loc)) {
external->_status = TRI_EXT_TERMINATED;
external->_exitStatus = WEXITSTATUS(loc);
} else if (WIFSIGNALED(loc)) {
external->_status = TRI_EXT_ABORTED;
external->_exitStatus = WTERMSIG(loc);
} else if (WIFSTOPPED(loc)) {
external->_status = TRI_EXT_STOPPED;
external->_exitStatus = 0;
} else {
external->_status = TRI_EXT_ABORTED;
external->_exitStatus = 0;
}
} else {
LOG(WARN) << "unexpected waitpid result for pid " << external->_pid
<< ": " << res;
status._errorMessage =
std::string("unexpected waitpid result for pid ") +
arangodb::basics::StringUtils::itoa(external->_pid) +
std::string(": ") + arangodb::basics::StringUtils::itoa(res);
}
#else
{
char windowsErrorBuf[256];
bool wantGetExitCode = wait;
if (wait) {
DWORD result;
result = WaitForSingleObject(external->_process, INFINITE);
if (result == WAIT_FAILED) {
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
windowsErrorBuf, sizeof(windowsErrorBuf), NULL);
LOG(WARN) << "could not wait for subprocess with pid "
<< external->_pid << ": " << windowsErrorBuf;
status._errorMessage =
std::string("could not wait for subprocess with pid ") +
arangodb::basics::StringUtils::itoa(
static_cast<int64_t>(external->_pid)) +
windowsErrorBuf;
status._exitStatus = GetLastError();
}
} else {
DWORD result;
result = WaitForSingleObject(external->_process, 0);
switch (result) {
case WAIT_ABANDONED:
wantGetExitCode = true;
LOG(WARN) << "WAIT_ABANDONED while waiting for subprocess with pid "
<< external->_pid;
break;
case WAIT_OBJECT_0:
/// this seems to be the exit case - want getExitCodeProcess here.
wantGetExitCode = true;
break;
case WAIT_TIMEOUT:
// success - everything went well.
external->_exitStatus = 0;
break;
case WAIT_FAILED:
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
windowsErrorBuf, sizeof(windowsErrorBuf), NULL);
LOG(WARN) << "could not wait for subprocess with pid "
<< external->_pid << ": " << windowsErrorBuf;
status._errorMessage =
std::string("could not wait for subprocess with PID '") +
arangodb::basics::StringUtils::itoa(
static_cast<int64_t>(external->_pid)) +
std::string("'") + windowsErrorBuf;
status._exitStatus = GetLastError();
default:
wantGetExitCode = true;
LOG(WARN)
<< "unexpected status while waiting for subprocess with pid "
<< external->_pid;
}
}
if (wantGetExitCode) {
DWORD exitCode = STILL_ACTIVE;
if (!GetExitCodeProcess(external->_process, &exitCode)) {
LOG(WARN) << "exit status could not be determined for pid "
<< external->_pid;
status._errorMessage =
std::string("exit status could not be determined for pid ") +
arangodb::basics::StringUtils::itoa(
static_cast<int64_t>(external->_pid));
} else {
if (exitCode == STILL_ACTIVE) {
external->_exitStatus = 0;
} else if (exitCode > 255) {
// this should be one of our signals which we mapped...
external->_status = TRI_EXT_ABORTED;
external->_exitStatus = exitCode - 255;
} else {
external->_status = TRI_EXT_TERMINATED;
external->_exitStatus = exitCode;
}
}
} else {
external->_status = TRI_EXT_RUNNING;
}
}
#endif
} else {
LOG(WARN) << "unexpected process status " << external->_status << ": "
<< external->_exitStatus;
status._errorMessage =
std::string("unexpected process status ") +
arangodb::basics::StringUtils::itoa(external->_status) +
std::string(": ") +
arangodb::basics::StringUtils::itoa(external->_exitStatus);
}
status._status = external->_status;
status._exitStatus = external->_exitStatus;
// Do we have to free our data?
if (external->_status != TRI_EXT_RUNNING &&
external->_status != TRI_EXT_STOPPED) {
MUTEX_LOCKER(mutexLocker, ExternalProcessesLock);
for (auto it = ExternalProcesses.begin(); it != ExternalProcesses.end();
++it) {
if ((*it)->_pid == pid._pid) {
ExternalProcesses.erase(it);
break;
}
}
FreeExternal(external);
}
return status;
}
#ifndef _WIN32
static bool OurKillProcess(TRI_external_t* pid) {
if (0 == kill(pid->_pid, SIGTERM)) {
int count;
// Otherwise we just let it be.
for (count = 0; count < 10; count++) {
pid_t p;
int loc;
// And wait for it to avoid a zombie:
sleep(1);
p = waitpid(pid->_pid, &loc, WUNTRACED | WNOHANG);
if (p == pid->_pid) {
return true;
}
if (count == 8) {
kill(pid->_pid, SIGKILL);
}
}
}
return false;
}
#else
static bool OurKillProcess(TRI_external_t* pid) {
bool ok = true;
UINT uExitCode = 0;
DWORD exitCode;
// kill worker process
if (0 != TerminateProcess(pid->_process, uExitCode)) {
LOG(TRACE) << "kill of worker process succeeded";
} else {
DWORD e1 = GetLastError();
BOOL ok = GetExitCodeProcess(pid->_process, &exitCode);
if (ok) {
LOG(DEBUG) << "worker process already dead: " << exitCode;
} else {
LOG(WARN) << "kill of worker process failed: " << exitCode;
ok = false;
}
}
return ok;
}
static bool OurKillProcessPID(DWORD pid) {
HANDLE hProcess;
UINT uExitCode = 0;
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
if (hProcess != nullptr) {
TerminateProcess(hProcess, uExitCode);
CloseHandle(hProcess);
return true;
}
return false;
}
#endif
////////////////////////////////////////////////////////////////////////////////
/// @brief kills an external process
////////////////////////////////////////////////////////////////////////////////
bool TRI_KillExternalProcess(TRI_external_id_t pid) {
LOG(DEBUG) << "killing process: " << pid._pid;
TRI_external_t* external = nullptr; // just to please the compiler
{
MUTEX_LOCKER(mutexLocker, ExternalProcessesLock);
for (auto it = ExternalProcesses.begin(); it != ExternalProcesses.end();
++it) {
if ((*it)->_pid == pid._pid) {
external = (*it);
ExternalProcesses.erase(it);
break;
}
}
}
if (external == nullptr) {
LOG(DEBUG) << "kill: process not found: " << pid._pid;
#ifndef _WIN32
// Kill just in case:
if (0 == kill(pid._pid, SIGTERM)) {
// Otherwise we just let it be.
for (int count = 0; count < 10; count++) {
int loc;
pid_t p;
// And wait for it to avoid a zombie:
sleep(1);
p = waitpid(pid._pid, &loc, WUNTRACED | WNOHANG);
if (p == pid._pid) {
return true;
}
if (count == 8) {
kill(pid._pid, SIGKILL);
}
}
}
return false;
#else
return OurKillProcessPID(pid._pid);
#endif
}
bool ok = true;
if (external->_status == TRI_EXT_RUNNING ||
external->_status == TRI_EXT_STOPPED) {
ok = OurKillProcess(external);
}
FreeExternal(external);
return ok;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief stops an external process, only on Unix
////////////////////////////////////////////////////////////////////////////////
bool TRI_SuspendExternalProcess(TRI_external_id_t pid) {
LOG(DEBUG) << "suspending process: " << pid._pid;
#ifndef _WIN32
return 0 == kill(pid._pid, SIGSTOP);
#else
return true;
#endif
}
////////////////////////////////////////////////////////////////////////////////
/// @brief continues an external process, only on Unix
////////////////////////////////////////////////////////////////////////////////
bool TRI_ContinueExternalProcess(TRI_external_id_t pid) {
LOG(DEBUG) << "continueing process: " << pid._pid;
#ifndef _WIN32
return 0 == kill(pid._pid, SIGCONT);
#else
return true;
#endif
}
////////////////////////////////////////////////////////////////////////////////
/// @brief gets the physical memory
////////////////////////////////////////////////////////////////////////////////
#if defined(TRI_HAVE_MACOS_MEM_STATS)
static uint64_t GetPhysicalMemory() {
int mib[2];
int64_t physicalMemory;
size_t length;
// Get the Physical memory size
mib[0] = CTL_HW;
#ifdef TRI_HAVE_MACOS_MEM_STATS
mib[1] = HW_MEMSIZE;
#else
mib[1] = HW_PHYSMEM; // The bytes of physical memory. (kenel + user space)
#endif
length = sizeof(int64_t);
sysctl(mib, 2, &physicalMemory, &length, nullptr, 0);
return (uint64_t)physicalMemory;
}
#else
#ifdef TRI_HAVE_SC_PHYS_PAGES
static uint64_t GetPhysicalMemory() {
long pages = sysconf(_SC_PHYS_PAGES);
long page_size = sysconf(_SC_PAGE_SIZE);
return (uint64_t)(pages * page_size);
}
#else
#ifdef TRI_HAVE_WIN32_GLOBAL_MEMORY_STATUS
static uint64_t GetPhysicalMemory() {
MEMORYSTATUSEX status;
status.dwLength = sizeof(status);
GlobalMemoryStatusEx(&status);
return (uint64_t)status.ullTotalPhys;
}
#else
static uint64_t GetPhysicalMemory() {
PROCESS_MEMORY_COUNTERS pmc;
memset(&result, 0, sizeof(result));
pmc.cb = sizeof(PROCESS_MEMORY_COUNTERS);
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms684874(v=vs.85).aspx
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, pmc.cb)) {
return pmc.PeakWorkingSetSize;
}
return 0;
}
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////
/// @brief initializes the process components
////////////////////////////////////////////////////////////////////////////////
void TRI_InitializeProcess() {
TRI_PhysicalMemory = GetPhysicalMemory();
}
////////////////////////////////////////////////////////////////////////////////
/// @brief shuts down the process components
////////////////////////////////////////////////////////////////////////////////
void TRI_ShutdownProcess() {
MUTEX_LOCKER(mutexLocker, ExternalProcessesLock);
for (auto* e : ExternalProcesses) {
FreeExternal(e);
}
ExternalProcesses.clear();
}
Reference in New Issue View Git Blame Copy Permalink