static std::shared_ptr<watchman_client> make_new_client(
std::unique_ptr<watchman_stream>&& stm) {
auto client = std::make_shared<watchman_user_client>(std::move(stm));
clients.wlock()->insert(client);
// Start a thread for the client.
// We used to use libevent for this, but we have
// a low volume of concurrent clients and the json
// parse/encode APIs are not easily used in a non-blocking
// server architecture.
try {
std::thread thr([client]() { client_thread(client); });
thr.detach();
} catch (const std::exception& e) {
clients.wlock()->erase(client);
throw;
}
return client;
}
bool FSEventsWatcher::start(const std::shared_ptr<w_root_t>& root) {
// Spin up the fsevents processing thread; it owns a ref on the root
auto self = std::dynamic_pointer_cast<FSEventsWatcher>(shared_from_this());
try {
// Acquire the mutex so thread initialization waits until we release it
auto wlock = items_.wlock();
std::thread thread([self, root]() {
try {
self->FSEventsThread(root);
} catch (const std::exception& e) {
watchman::log(watchman::ERR, "uncaught exception: ", e.what());
root->cancel();
}
// Ensure that we signal the condition variable before we
// finish this thread. That ensures that don't get stuck
// waiting in FSEventsWatcher::start if something unexpected happens.
self->fse_cond.notify_one();
});
// We have to detach because the readChangesThread may wind up
// being the last thread to reference the watcher state and
// cannot join itself.
thread.detach();
// Allow thread init to proceed; wait for its signal
fse_cond.wait(wlock.getUniqueLock());
if (root->failure_reason) {
w_log(
W_LOG_ERR,
"failed to start fsevents thread: %s\n",
root->failure_reason.c_str());
return false;
}
return true;
} catch (const std::exception& e) {
watchman::log(
watchman::ERR, "failed to start fsevents thread: ", e.what(), "\n");
return false;
}
}
bool FSEventsWatcher::waitNotify(int timeoutms) {
auto wlock = items_.wlock();
fse_cond.wait_for(
wlock.getUniqueLock(), std::chrono::milliseconds(timeoutms));
return !wlock->empty();
}
bool FSEventsWatcher::consumeNotify(
const std::shared_ptr<w_root_t>& root,
PendingCollection::LockedPtr& coll) {
struct timeval now;
bool recurse;
char flags_label[128];
std::deque<watchman_fsevent> items;
{
auto wlock = items_.wlock();
std::swap(items, *wlock);
}
gettimeofday(&now, nullptr);
for (auto& item : items) {
w_expand_flags(kflags, item.flags, flags_label, sizeof(flags_label));
w_log(
W_LOG_DBG,
"fsevents: got %s 0x%" PRIx32 " %s\n",
item.path.c_str(),
item.flags,
flags_label);
if (item.flags & kFSEventStreamEventFlagUserDropped) {
root->scheduleRecrawl("kFSEventStreamEventFlagUserDropped");
break;
}
if (item.flags & kFSEventStreamEventFlagKernelDropped) {
root->scheduleRecrawl("kFSEventStreamEventFlagKernelDropped");
break;
}
if (item.flags & kFSEventStreamEventFlagUnmount) {
w_log(
W_LOG_ERR,
"kFSEventStreamEventFlagUnmount %s, cancel watch\n",
item.path.c_str());
root->cancel();
break;
}
if (item.flags & kFSEventStreamEventFlagRootChanged) {
w_log(
W_LOG_ERR,
"kFSEventStreamEventFlagRootChanged %s, cancel watch\n",
item.path.c_str());
root->cancel();
break;
}
recurse = (item.flags & (kFSEventStreamEventFlagMustScanSubDirs |
kFSEventStreamEventFlagItemRenamed))
? true
: false;
coll->add(
item.path,
now,
W_PENDING_VIA_NOTIFY | (recurse ? W_PENDING_RECURSIVE : 0));
}
return !items.empty();
}
void FSEventsWatcher::FSEventsThread(const std::shared_ptr<w_root_t>& root) {
CFFileDescriptorRef fdref;
CFFileDescriptorContext fdctx;
w_set_thread_name("fsevents %s", root->root_path.c_str());
{
// Block until fsevents_root_start is waiting for our initialization
auto wlock = items_.wlock();
attempt_resync_on_drop = root->config.getBool("fsevents_try_resync", true);
memset(&fdctx, 0, sizeof(fdctx));
fdctx.info = root.get();
fdref = CFFileDescriptorCreate(
nullptr, fse_pipe.read.fd(), true, fse_pipe_callback, &fdctx);
CFFileDescriptorEnableCallBacks(fdref, kCFFileDescriptorReadCallBack);
{
CFRunLoopSourceRef fdsrc;
fdsrc = CFFileDescriptorCreateRunLoopSource(nullptr, fdref, 0);
if (!fdsrc) {
root->failure_reason = w_string_new_typed(
"CFFileDescriptorCreateRunLoopSource failed", W_STRING_UNICODE);
goto done;
}
CFRunLoopAddSource(CFRunLoopGetCurrent(), fdsrc, kCFRunLoopDefaultMode);
CFRelease(fdsrc);
}
stream = fse_stream_make(
root, kFSEventStreamEventIdSinceNow, root->failure_reason);
if (!stream) {
goto done;
}
if (!FSEventStreamStart(stream->stream)) {
root->failure_reason = w_string::printf(
"FSEventStreamStart failed, look at your log file %s for "
"lines mentioning FSEvents and see %s#fsevents for more information\n",
log_name,
cfg_get_trouble_url());
goto done;
}
// Signal to fsevents_root_start that we're done initializing
fse_cond.notify_one();
}
// Process the events stream until we get signalled to quit
CFRunLoopRun();
done:
if (stream) {
delete stream;
}
if (fdref) {
CFRelease(fdref);
}
w_log(W_LOG_DBG, "fse_thread done\n");
}
bool w_start_listener(const char *path)
{
#ifndef _WIN32
struct sigaction sa;
sigset_t sigset;
#endif
#ifdef HAVE_LIBGIMLI_H
hb = gimli_heartbeat_attach();
#endif
#if defined(HAVE_KQUEUE) || defined(HAVE_FSEVENTS)
{
struct rlimit limit;
# ifndef __OpenBSD__
int mib[2] = { CTL_KERN,
# ifdef KERN_MAXFILESPERPROC
KERN_MAXFILESPERPROC
# else
KERN_MAXFILES
# endif
};
# endif
int maxperproc;
getrlimit(RLIMIT_NOFILE, &limit);
# ifndef __OpenBSD__
{
size_t len;
len = sizeof(maxperproc);
sysctl(mib, 2, &maxperproc, &len, NULL, 0);
w_log(W_LOG_ERR, "file limit is %" PRIu64
" kern.maxfilesperproc=%i\n",
limit.rlim_cur, maxperproc);
}
# else
maxperproc = limit.rlim_max;
w_log(W_LOG_ERR, "openfiles-cur is %" PRIu64
" openfiles-max=%i\n",
limit.rlim_cur, maxperproc);
# endif
if (limit.rlim_cur != RLIM_INFINITY &&
maxperproc > 0 &&
limit.rlim_cur < (rlim_t)maxperproc) {
limit.rlim_cur = maxperproc;
if (setrlimit(RLIMIT_NOFILE, &limit)) {
w_log(W_LOG_ERR,
"failed to raise limit to %" PRIu64 " (%s).\n",
limit.rlim_cur,
strerror(errno));
} else {
w_log(W_LOG_ERR,
"raised file limit to %" PRIu64 "\n",
limit.rlim_cur);
}
}
getrlimit(RLIMIT_NOFILE, &limit);
#ifndef HAVE_FSEVENTS
if (limit.rlim_cur < 10240) {
w_log(W_LOG_ERR,
"Your file descriptor limit is very low (%" PRIu64 "), "
"please consult the watchman docs on raising the limits\n",
limit.rlim_cur);
}
#endif
}
#endif
#ifndef _WIN32
signal(SIGPIPE, SIG_IGN);
/* allow SIGUSR1 and SIGCHLD to wake up a blocked thread, without restarting
* syscalls */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = wakeme;
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, NULL);
sigaction(SIGCHLD, &sa, NULL);
// Block SIGCHLD everywhere
sigemptyset(&sigset);
sigaddset(&sigset, SIGCHLD);
sigprocmask(SIG_BLOCK, &sigset, NULL);
if (listener_fd) {
// Assume that it was prepped by w_listener_prep_inetd()
w_log(W_LOG_ERR, "Using socket from inetd as listening socket\n");
} else {
listener_fd = get_listener_socket(path);
if (!listener_fd) {
return false;
}
}
listener_fd.setCloExec();
#endif
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
} else {
w_setup_signal_handlers();
}
#else
w_setup_signal_handlers();
#endif
listener_fd.setNonBlock();
startSanityCheckThread();
// Now run the dispatch
#ifndef _WIN32
listener_thread_event = w_event_make();
accept_loop(std::move(listener_fd));
#else
named_pipe_accept_loop(path);
#endif
// Wait for clients, waking any sleeping clients up in the process
{
int interval = 2000;
int last_count = 0, n_clients = 0;
const int max_interval = 1000000; // 1 second
do {
{
auto clientsLock = clients.rlock();
n_clients = clientsLock->size();
for (auto client : *clientsLock) {
client->ping->notify();
}
}
if (n_clients != last_count) {
w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients);
}
usleep(interval);
interval = std::min(interval * 2, max_interval);
} while (n_clients > 0);
}
w_state_shutdown();
return true;
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void client_thread(std::shared_ptr<watchman_client> client) noexcept {
struct watchman_event_poll pfd[2];
json_error_t jerr;
bool client_alive = true;
// Keep a persistent vector around so that we can avoid allocating
// and releasing heap memory when we collect items from the publisher
std::vector<std::shared_ptr<const watchman::Publisher::Item>> pending;
client->stm->setNonBlock(true);
w_set_thread_name(
"client=%p:stm=%p:pid=%d",
client.get(),
client->stm.get(),
client->stm->getPeerProcessID());
client->client_is_owner = client->stm->peerIsOwner();
pfd[0].evt = client->stm->getEvents();
pfd[1].evt = client->ping.get();
while (!stopping && client_alive) {
// Wait for input from either the client socket or
// via the ping pipe, which signals that some other
// thread wants to unilaterally send data to the client
ignore_result(w_poll_events(pfd, 2, 2000));
if (stopping) {
break;
}
if (pfd[0].ready) {
auto request = client->reader.decodeNext(client->stm.get(), &jerr);
if (!request && errno == EAGAIN) {
// That's fine
} else if (!request) {
// Not so cool
if (client->reader.wpos == client->reader.rpos) {
// If they disconnected in between PDUs, no need to log
// any error
goto disconnected;
}
send_error_response(
client.get(),
"invalid json at position %d: %s",
jerr.position,
jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconnected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
client->capabilities = client->reader.capabilities;
dispatch_command(client.get(), request, CMD_DAEMON);
}
}
if (pfd[1].ready) {
while (client->ping->testAndClear()) {
// Enqueue refs to pending log payloads
pending.clear();
getPending(pending, client->debugSub, client->errorSub);
for (auto& item : pending) {
client->enqueueResponse(json_ref(item->payload), false);
}
// Maybe we have subscriptions to dispatch?
auto userClient =
std::dynamic_pointer_cast<watchman_user_client>(client);
if (userClient) {
std::vector<w_string> subsToDelete;
for (auto& subiter : userClient->unilateralSub) {
auto sub = subiter.first;
auto subStream = subiter.second;
watchman::log(
watchman::DBG, "consider fan out sub ", sub->name, "\n");
pending.clear();
subStream->getPending(pending);
bool seenSettle = false;
for (auto& item : pending) {
auto dumped = json_dumps(item->payload, 0);
watchman::log(
watchman::DBG,
"Unilateral payload for sub ",
sub->name,
" ",
dumped ? dumped : "<<MISSING!!>>",
"\n");
free(dumped);
if (item->payload.get_default("canceled")) {
auto resp = make_response();
watchman::log(
watchman::ERR,
"Cancel subscription ",
sub->name,
" due to root cancellation\n");
resp.set({{"root", item->payload.get_default("root")},
{"unilateral", json_true()},
{"canceled", json_true()},
{"subscription", w_string_to_json(sub->name)}});
client->enqueueResponse(std::move(resp), false);
// Remember to cancel this subscription.
// We can't do it in this loop because that would
// invalidate the iterators and cause a headache.
subsToDelete.push_back(sub->name);
continue;
}
if (item->payload.get_default("state-enter") ||
item->payload.get_default("state-leave")) {
auto resp = make_response();
json_object_update(item->payload, resp);
// We have the opportunity to populate additional response
// fields here (since we don't want to block the command).
// We don't populate the fat clock for SCM aware queries
// because determination of mergeBase could add latency.
resp.set({{"unilateral", json_true()},
{"subscription", w_string_to_json(sub->name)}});
client->enqueueResponse(std::move(resp), false);
watchman::log(
watchman::DBG,
"Fan out subscription state change for ",
sub->name,
"\n");
continue;
}
if (!sub->debug_paused && item->payload.get_default("settled")) {
seenSettle = true;
continue;
}
}
if (seenSettle) {
sub->processSubscription();
}
}
for (auto& name : subsToDelete) {
userClient->unsubByName(name);
}
}
}
}
/* now send our response(s) */
while (!client->responses.empty() && client_alive) {
auto& response_to_send = client->responses.front();
client->stm->setNonBlock(false);
/* Return the data in the same format that was used to ask for it.
* Update client liveness based on send success.
*/
client_alive = client->writer.pduEncodeToStream(
client->pdu_type,
client->capabilities,
response_to_send,
client->stm.get());
client->stm->setNonBlock(true);
client->responses.pop_front();
}
}
disconnected:
w_set_thread_name(
"NOT_CONN:client=%p:stm=%p:pid=%d",
client.get(),
client->stm.get(),
client->stm->getPeerProcessID());
// Remove the client from the map before we tear it down, as this makes
// it easier to flush out pending writes on windows without worrying
// about w_log_to_clients contending for the write buffers
clients.wlock()->erase(client);
}
bool KQueueWatcher::startWatchFile(struct watchman_file* file) {
struct kevent k;
auto full_name = w_dir_path_cat_str(file->parent, file->getName());
{
auto rlock = maps_.rlock();
if (rlock->name_to_fd.find(full_name) != rlock->name_to_fd.end()) {
// Already watching it
return true;
}
}
w_log(W_LOG_DBG, "watch_file(%s)\n", full_name.c_str());
FileDescriptor fdHolder(open(full_name.c_str(), O_EVTONLY | O_CLOEXEC));
auto rawFd = fdHolder.fd();
if (rawFd == -1) {
watchman::log(
watchman::ERR,
"failed to open ",
full_name,
", O_EVTONLY: ",
strerror(errno),
"\n");
return false;
}
memset(&k, 0, sizeof(k));
EV_SET(
&k,
rawFd,
EVFILT_VNODE,
EV_ADD | EV_CLEAR,
NOTE_WRITE | NOTE_DELETE | NOTE_EXTEND | NOTE_RENAME | NOTE_ATTRIB,
0,
(w_string_t*)full_name);
{
auto wlock = maps_.wlock();
wlock->name_to_fd[full_name] = std::move(fdHolder);
wlock->fd_to_name[rawFd] = full_name;
}
if (kevent(kq_fd.fd(), &k, 1, nullptr, 0, 0)) {
watchman::log(
watchman::DBG,
"kevent EV_ADD file ",
full_name,
" failed: ",
full_name.c_str(),
strerror(errno),
"\n");
auto wlock = maps_.wlock();
wlock->name_to_fd.erase(full_name);
wlock->fd_to_name.erase(rawFd);
} else {
watchman::log(
watchman::DBG, "kevent file ", full_name, " -> ", rawFd, "\n");
}
return true;
}
bool KQueueWatcher::consumeNotify(
const std::shared_ptr<w_root_t>& root,
PendingCollection::LockedPtr& coll) {
int n;
int i;
struct timespec ts = { 0, 0 };
struct timeval now;
errno = 0;
n = kevent(
kq_fd.fd(),
nullptr,
0,
keventbuf,
sizeof(keventbuf) / sizeof(keventbuf[0]),
&ts);
w_log(
W_LOG_DBG,
"consume_kqueue: %s n=%d err=%s\n",
root->root_path.c_str(),
n,
strerror(errno));
if (root->inner.cancelled) {
return 0;
}
gettimeofday(&now, nullptr);
for (i = 0; n > 0 && i < n; i++) {
uint32_t fflags = keventbuf[i].fflags;
bool is_dir = IS_DIR_BIT_SET(keventbuf[i].udata);
char flags_label[128];
int fd = keventbuf[i].ident;
w_expand_flags(kflags, fflags, flags_label, sizeof(flags_label));
auto wlock = maps_.wlock();
auto it = wlock->fd_to_name.find(fd);
w_string path = it == wlock->fd_to_name.end() ? nullptr : it->second;
if (!path) {
// Was likely a buffered notification for something that we decided
// to stop watching
w_log(W_LOG_DBG,
" KQ notif for fd=%d; flags=0x%x %s no ref for it in fd_to_name\n",
fd, fflags, flags_label);
continue;
}
w_log(
W_LOG_DBG,
" KQ fd=%d path %s [0x%x %s]\n",
fd,
path.data(),
fflags,
flags_label);
if ((fflags & (NOTE_DELETE|NOTE_RENAME|NOTE_REVOKE))) {
struct kevent k;
if (w_string_equal(path, root->root_path)) {
w_log(
W_LOG_ERR,
"root dir %s has been (re)moved [code 0x%x], canceling watch\n",
root->root_path.c_str(),
fflags);
root->cancel();
return 0;
}
// Remove our watch bits
memset(&k, 0, sizeof(k));
EV_SET(&k, fd, EVFILT_VNODE, EV_DELETE, 0, 0, nullptr);
kevent(kq_fd.fd(), &k, 1, nullptr, 0, 0);
wlock->name_to_fd.erase(path);
wlock->fd_to_name.erase(fd);
}
coll->add(
path, now, is_dir ? 0 : (W_PENDING_RECURSIVE | W_PENDING_VIA_NOTIFY));
}
return n > 0;
}
std::unique_ptr<watchman_dir_handle> KQueueWatcher::startWatchDir(
const std::shared_ptr<w_root_t>& root,
struct watchman_dir* dir,
struct timeval,
const char* path) {
struct stat st, osdirst;
struct kevent k;
auto osdir = w_dir_open(path);
FileDescriptor fdHolder(open(path, O_NOFOLLOW | O_EVTONLY | O_CLOEXEC));
auto rawFd = fdHolder.fd();
if (rawFd == -1) {
// directory got deleted between opendir and open
throw std::system_error(
errno, std::generic_category(), std::string("open O_EVTONLY: ") + path);
}
if (fstat(rawFd, &st) == -1 || fstat(osdir->getFd(), &osdirst) == -1) {
// whaaa?
root->scheduleRecrawl("fstat failed");
throw std::system_error(
errno,
std::generic_category(),
std::string("fstat failed for dir ") + path);
}
if (st.st_dev != osdirst.st_dev || st.st_ino != osdirst.st_ino) {
// directory got replaced between opendir and open -- at this point its
// parent's being watched, so we let filesystem events take care of it
throw std::system_error(
ENOTDIR,
std::generic_category(),
std::string("directory replaced between opendir and open: ") + path);
}
memset(&k, 0, sizeof(k));
auto dir_name = dir->getFullPath();
EV_SET(
&k,
rawFd,
EVFILT_VNODE,
EV_ADD | EV_CLEAR,
NOTE_WRITE | NOTE_DELETE | NOTE_EXTEND | NOTE_RENAME,
0,
SET_DIR_BIT((w_string_t*)dir_name));
// Our mapping needs to be visible before we add it to the queue,
// otherwise we can get a wakeup and not know what it is
{
auto wlock = maps_.wlock();
wlock->name_to_fd[dir_name] = std::move(fdHolder);
wlock->fd_to_name[rawFd] = dir_name;
}
if (kevent(kq_fd.fd(), &k, 1, nullptr, 0, 0)) {
w_log(W_LOG_DBG, "kevent EV_ADD dir %s failed: %s",
path, strerror(errno));
auto wlock = maps_.wlock();
wlock->name_to_fd.erase(dir_name);
wlock->fd_to_name.erase(rawFd);
} else {
watchman::log(watchman::DBG, "kevent dir ", dir_name, " -> ", rawFd, "\n");
}
return osdir;
}