PendingCollection::LockedPtr PendingCollection::lockAndWait(
std::chrono::milliseconds timeoutms,
bool& pinged) {
auto lock = wlock();
if (lock->checkAndResetPinged()) {
pinged = true;
return lock;
}
if (timeoutms.count() == -1) {
cond_.wait(lock.getUniqueLock());
} else {
cond_.wait_for(lock.getUniqueLock(), timeoutms);
}
pinged = lock->checkAndResetPinged();
return lock;
}
void AsyncFileWriter::ioThread() {
folly::setThreadName("log_writer");
while (true) {
// With the lock held, grab a pointer to the current queue, then increment
// the ioThreadCounter index so that other threads will write into the
// other queue as we process this one.
std::vector<std::string>* ioQueue;
size_t numDiscarded;
bool stop;
{
auto data = data_.lock();
ioQueue = data->getCurrentQueue();
while (ioQueue->empty() && !data->stop) {
messageReady_.wait(data.getUniqueLock());
}
++data->ioThreadCounter;
numDiscarded = data->numDiscarded;
data->numDiscarded = 0;
data->currentBufferSize = 0;
stop = data->stop;
}
ioCV_.notify_all();
// Write the log messages now that we have released the lock
try {
performIO(ioQueue);
} catch (const std::exception& ex) {
onIoError(ex);
}
// clear() empties the vector, but the allocated capacity remains so we can
// just reuse it without having to re-allocate in most cases.
ioQueue->clear();
if (numDiscarded > 0) {
auto msg = getNumDiscardedMsg(numDiscarded);
if (!msg.empty()) {
auto ret = folly::writeFull(file_.fd(), msg.data(), msg.size());
// We currently ignore errors from writeFull() here.
// There's not much we can really do.
(void)ret;
}
}
if (stop) {
data_->ioThreadDone = true;
break;
}
}
}
void AsyncFileWriter::flush() {
auto data = data_.lock();
auto start = data->ioThreadCounter;
// Wait until ioThreadCounter increments by at least two.
// Waiting for a single increment is not sufficient, as this happens after
// the I/O thread has swapped the queues, which is before it has actually
// done the I/O.
while (data->ioThreadCounter < start + 2) {
if (data->ioThreadDone) {
return;
}
// Enqueue an empty string and wake the I/O thread.
// The empty string ensures that the I/O thread will break out of its wait
// loop and increment the ioThreadCounter, even if there is no other work
// to do.
data->getCurrentQueue()->emplace_back();
messageReady_.notify_one();
// Wait for notification from the I/O thread that it has done work.
ioCV_.wait(data.getUniqueLock());
}
}
void PerfLogThread::loop() {
json_ref samples;
char **envp;
json_ref perf_cmd;
int64_t sample_batch;
w_set_thread_name("perflog");
// Prep some things that we'll need each time we run a command
{
uint32_t env_size;
auto envpht = w_envp_make_ht();
char *statedir = dirname(strdup(watchman_state_file));
w_envp_set_cstring(envpht, "WATCHMAN_STATE_DIR", statedir);
w_envp_set_cstring(envpht, "WATCHMAN_SOCK", get_sock_name());
envp = w_envp_make_from_ht(envpht, &env_size);
}
perf_cmd = cfg_get_json("perf_logger_command");
if (json_is_string(perf_cmd)) {
perf_cmd = json_array({perf_cmd});
}
if (!json_is_array(perf_cmd)) {
w_log(
W_LOG_FATAL,
"perf_logger_command must be either a string or an array of strings\n");
}
sample_batch = cfg_get_int("perf_logger_command_max_samples_per_call", 4);
while (!w_is_stopping()) {
{
auto wlock = samples_.wlock();
if (!*wlock) {
cond_.wait(wlock.getUniqueLock());
}
samples = nullptr;
std::swap(samples, *wlock);
}
if (samples) {
while (json_array_size(samples) > 0) {
int i = 0;
auto cmd = json_array();
posix_spawnattr_t attr;
posix_spawn_file_actions_t actions;
pid_t pid;
char **argv = NULL;
json_array_extend(cmd, perf_cmd);
while (i < sample_batch && json_array_size(samples) > 0) {
char *stringy = json_dumps(json_array_get(samples, 0), 0);
if (stringy) {
json_array_append_new(
cmd, typed_string_to_json(stringy, W_STRING_MIXED));
free(stringy);
}
json_array_remove(samples, 0);
i++;
}
argv = w_argv_copy_from_json(cmd, 0);
if (!argv) {
char *dumped = json_dumps(cmd, 0);
w_log(W_LOG_FATAL, "error converting %s to an argv array\n", dumped);
}
posix_spawnattr_init(&attr);
#ifdef POSIX_SPAWN_CLOEXEC_DEFAULT
posix_spawnattr_setflags(&attr, POSIX_SPAWN_CLOEXEC_DEFAULT);
#endif
posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_addopen(&actions, STDIN_FILENO, "/dev/null",
O_RDONLY, 0666);
posix_spawn_file_actions_addopen(&actions, STDOUT_FILENO, "/dev/null",
O_WRONLY, 0666);
posix_spawn_file_actions_addopen(&actions, STDERR_FILENO, "/dev/null",
O_WRONLY, 0666);
if (posix_spawnp(&pid, argv[0], &actions, &attr, argv, envp) == 0) {
int status;
while (waitpid(pid, &status, 0) != pid) {
if (errno != EINTR) {
break;
}
}
} else {
int err = errno;
w_log(W_LOG_ERR, "failed to spawn %s: %s\n", argv[0],
strerror(err));
}
posix_spawnattr_destroy(&attr);
posix_spawn_file_actions_destroy(&actions);
free(argv);
}
}
}
}
bool FSEventsWatcher::waitNotify(int timeoutms) {
auto wlock = items_.wlock();
fse_cond.wait_for(
wlock.getUniqueLock(), std::chrono::milliseconds(timeoutms));
return !wlock->empty();
}
