const char *w_get_thread_name(void) {
const char *name = pthread_getspecific(thread_name_key);
if (name) {
return name;
}
return w_set_thread_name("%" PRIu32, (uint32_t)(uintptr_t)pthread_self());
}
static void run_service(void)
{
int fd;
bool res;
// redirect std{in,out,err}
fd = open("/dev/null", O_RDONLY);
if (fd != -1) {
ignore_result(dup2(fd, STDIN_FILENO));
close(fd);
}
fd = open(log_name, O_WRONLY|O_APPEND|O_CREAT, 0600);
if (fd != -1) {
ignore_result(dup2(fd, STDOUT_FILENO));
ignore_result(dup2(fd, STDERR_FILENO));
close(fd);
}
#ifndef _WIN32
/* we are the child, let's set things up */
ignore_result(chdir("/"));
#endif
w_set_thread_name("listener");
{
char hostname[256];
gethostname(hostname, sizeof(hostname));
hostname[sizeof(hostname) - 1] = '\0';
w_log(W_LOG_ERR, "Watchman %s %s starting up on %s\n",
PACKAGE_VERSION,
#ifdef WATCHMAN_BUILD_INFO
WATCHMAN_BUILD_INFO,
#else
"<no build info set>",
#endif
hostname);
}
watchman_watcher_init();
res = w_start_listener(sock_name);
watchman_watcher_dtor();
if (res) {
exit(0);
}
exit(1);
}
static void *child_reaper(void *arg)
{
sigset_t sigset;
unused_parameter(arg);
w_set_thread_name("child_reaper");
// Unblock SIGCHLD only in this thread
sigemptyset(&sigset);
sigaddset(&sigset, SIGCHLD);
pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);
while (!stopping) {
usleep(200000);
w_reap_children(true);
}
return 0;
}
static void *child_reaper(void *arg)
{
#ifndef _WIN32
sigset_t sigset;
// By default, keep both SIGCHLD and SIGUSR1 blocked
sigemptyset(&sigset);
sigaddset(&sigset, SIGUSR1);
sigaddset(&sigset, SIGCHLD);
pthread_sigmask(SIG_BLOCK, &sigset, NULL);
// SIGCHLD is ordinarily blocked, so we listen for it only in
// sigsuspend, when we're also listening for the SIGUSR1 that tells
// us to exit.
pthread_sigmask(SIG_BLOCK, NULL, &sigset);
sigdelset(&sigset, SIGCHLD);
sigdelset(&sigset, SIGUSR1);
#endif
unused_parameter(arg);
w_set_thread_name("child_reaper");
#ifdef _WIN32
while (!stopping) {
usleep(200000);
w_reap_children(true);
}
#else
while (!stopping) {
w_reap_children(false);
sigsuspend(&sigset);
}
#endif
return 0;
}
int main(int argc, char **argv)
{
bool ran;
json_t *cmd;
w_client_lock_init();
parse_cmdline(&argc, &argv);
if (foreground) {
run_service();
return 0;
}
w_set_thread_name("cli");
cmd = build_command(argc, argv);
preprocess_command(cmd, output_pdu);
ran = try_command(cmd, 0);
if (!ran && should_start(errno)) {
if (no_spawn) {
if (!no_local) {
ran = try_client_mode_command(cmd, !no_pretty);
}
} else {
spawn_watchman();
ran = try_command(cmd, 10);
}
}
json_decref(cmd);
if (ran) {
return 0;
}
if (!no_spawn) {
w_log(W_LOG_ERR, "unable to talk to your watchman on %s! (%s)\n",
sock_name, strerror(errno));
#ifdef __APPLE__
if (getenv("TMUX")) {
w_log(W_LOG_ERR, "\n"
"You may be hitting a tmux related session issue.\n"
"An immediate workaround is to run:\n"
"\n"
" watchman version\n"
"\n"
"just once, from *outside* your tmux session, to allow the launchd\n"
"registration to be setup. Once done, you can continue to access\n"
"watchman from inside your tmux sessions as usual.\n"
"\n"
"Longer term, you may wish to install this tool:\n"
"\n"
" https://github.com/ChrisJohnsen/tmux-MacOSX-pasteboard\n"
"\n"
"and configure tmux to use `reattach-to-user-namespace`\n"
"when it launches your shell.\n");
}
#endif
}
return 1;
}
static void run_service(void)
{
int fd;
bool res;
#ifndef _WIN32
// Before we redirect stdin/stdout to the log files, move any inetd-provided
// socket to a different descriptor number.
if (inetd_style) {
if (!w_listener_prep_inetd()) {
return;
}
}
#endif
// redirect std{in,out,err}
fd = open("/dev/null", O_RDONLY);
if (fd != -1) {
ignore_result(dup2(fd, STDIN_FILENO));
close(fd);
}
fd = open(log_name, O_WRONLY|O_APPEND|O_CREAT, 0600);
if (fd != -1) {
ignore_result(dup2(fd, STDOUT_FILENO));
ignore_result(dup2(fd, STDERR_FILENO));
close(fd);
}
if (!lock_pidfile()) {
return;
}
#ifndef _WIN32
/* we are the child, let's set things up */
ignore_result(chdir("/"));
#endif
w_set_thread_name("listener");
{
char hostname[256];
gethostname(hostname, sizeof(hostname));
hostname[sizeof(hostname) - 1] = '\0';
w_log(W_LOG_ERR, "Watchman %s %s starting up on %s\n",
PACKAGE_VERSION,
#ifdef WATCHMAN_BUILD_INFO
WATCHMAN_BUILD_INFO,
#else
"<no build info set>",
#endif
hostname);
}
#ifndef _WIN32
// Block SIGCHLD by default; we only want it to be delivered
// to the reaper thread and only when it is ready to reap.
// This MUST happen before we spawn any threads so that they
// can pick up our default blocked signal mask.
{
sigset_t sigset;
sigemptyset(&sigset);
sigaddset(&sigset, SIGCHLD);
sigprocmask(SIG_BLOCK, &sigset, NULL);
}
#endif
watchman_watcher_init();
w_clockspec_init();
// Start the reaper before we load any state; the state may
// have triggers associated with it which may spawn processes
w_start_reaper();
w_state_load();
res = w_start_listener(sock_name);
w_root_free_watched_roots();
if (res) {
exit(0);
}
exit(1);
}
static void *readchanges_thread(void *arg) {
w_root_t *root = arg;
struct winwatch_root_state *state = root->watch;
DWORD size = WATCHMAN_BATCH_LIMIT * (sizeof(FILE_NOTIFY_INFORMATION) + 512);
char *buf;
DWORD err, filter;
OVERLAPPED olap;
BOOL initiate_read = true;
HANDLE handles[2] = { state->olap, state->ping };
DWORD bytes;
w_set_thread_name("readchange %.*s",
root->root_path->len, root->root_path->buf);
// Block until winmatch_root_st is waiting for our initialization
pthread_mutex_lock(&state->mtx);
filter = FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_DIR_NAME|
FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_SIZE|
FILE_NOTIFY_CHANGE_LAST_WRITE;
memset(&olap, 0, sizeof(olap));
olap.hEvent = state->olap;
buf = malloc(size);
if (!buf) {
w_log(W_LOG_ERR, "failed to allocate %u bytes for dirchanges buf\n", size);
goto out;
}
if (!ReadDirectoryChangesW(state->dir_handle, buf, size,
TRUE, filter, NULL, &olap, NULL)) {
err = GetLastError();
w_log(W_LOG_ERR,
"ReadDirectoryChangesW: failed, cancel watch. %s\n",
win32_strerror(err));
w_root_lock(root);
w_root_cancel(root);
w_root_unlock(root);
goto out;
}
// Signal that we are done with init. We MUST do this AFTER our first
// successful ReadDirectoryChangesW, otherwise there is a race condition
// where we'll miss observing the cookie for a query that comes in
// after we've crawled but before the watch is established.
w_log(W_LOG_DBG, "ReadDirectoryChangesW signalling as init done");
pthread_cond_signal(&state->cond);
pthread_mutex_unlock(&state->mtx);
initiate_read = false;
// The state->mutex must not be held when we enter the loop
while (!root->cancelled) {
if (initiate_read) {
if (!ReadDirectoryChangesW(state->dir_handle,
buf, size, TRUE, filter, NULL, &olap, NULL)) {
err = GetLastError();
w_log(W_LOG_ERR,
"ReadDirectoryChangesW: failed, cancel watch. %s\n",
win32_strerror(err));
w_root_lock(root);
w_root_cancel(root);
w_root_unlock(root);
break;
} else {
initiate_read = false;
}
}
w_log(W_LOG_DBG, "waiting for change notifications");
DWORD status = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
if (status == WAIT_OBJECT_0) {
bytes = 0;
if (!GetOverlappedResult(state->dir_handle, &olap,
&bytes, FALSE)) {
err = GetLastError();
w_log(W_LOG_ERR, "overlapped ReadDirectoryChangesW(%s): 0x%x %s\n",
root->root_path->buf,
err, win32_strerror(err));
if (err == ERROR_INVALID_PARAMETER && size > NETWORK_BUF_SIZE) {
// May be a network buffer related size issue; the docs say that
// we can hit this when watching a UNC path. Let's downsize and
// retry the read just one time
w_log(W_LOG_ERR, "retrying watch for possible network location %s "
"with smaller buffer\n", root->root_path->buf);
size = NETWORK_BUF_SIZE;
initiate_read = true;
continue;
}
if (err == ERROR_NOTIFY_ENUM_DIR) {
w_root_schedule_recrawl(root, "ERROR_NOTIFY_ENUM_DIR");
} else {
w_log(W_LOG_ERR, "Cancelling watch for %s\n",
root->root_path->buf);
w_root_lock(root);
w_root_cancel(root);
w_root_unlock(root);
break;
}
} else {
PFILE_NOTIFY_INFORMATION not = (PFILE_NOTIFY_INFORMATION)buf;
struct winwatch_changed_item *head = NULL, *tail = NULL;
while (true) {
struct winwatch_changed_item *item;
DWORD n_chars;
w_string_t *name, *full;
// FileNameLength is in BYTES, but FileName is WCHAR
n_chars = not->FileNameLength / sizeof(not->FileName[0]);
name = w_string_new_wchar(not->FileName, n_chars);
full = w_string_path_cat(root->root_path, name);
w_string_delref(name);
if (w_is_ignored(root, full->buf, full->len)) {
w_string_delref(full);
} else {
item = calloc(1, sizeof(*item));
item->name = full;
if (tail) {
tail->next = item;
} else {
head = item;
}
tail = item;
}
// Advance to next item
if (not->NextEntryOffset == 0) {
break;
}
not = (PFILE_NOTIFY_INFORMATION)(not->NextEntryOffset + (char*)not);
}
if (tail) {
pthread_mutex_lock(&state->mtx);
if (state->tail) {
state->tail->next = head;
} else {
state->head = head;
}
state->tail = tail;
pthread_mutex_unlock(&state->mtx);
pthread_cond_signal(&state->cond);
}
ResetEvent(state->olap);
initiate_read = true;
}
} else if (status == WAIT_OBJECT_0 + 1) {
w_log(W_LOG_ERR, "signalled\n");
break;
} else {
w_log(W_LOG_ERR, "impossible wait status=%d\n",
status);
break;
}
}
pthread_mutex_lock(&state->mtx);
out:
// Signal to winwatch_root_start that we're done initializing in
// the failure path. We'll also do this after we've completed
// the run loop in the success path; it's a spurious wakeup but
// harmless and saves us from adding and setting a control flag
// in each of the failure `goto` statements. winwatch_root_dtor
// will `pthread_join` us before `state` is freed.
pthread_cond_signal(&state->cond);
pthread_mutex_unlock(&state->mtx);
if (buf) {
free(buf);
}
w_log(W_LOG_DBG, "done\n");
w_root_delref(root);
return NULL;
}
static void *perf_log_thread(void *unused) {
json_t *samples = NULL;
char **envp;
json_t *perf_cmd;
int64_t sample_batch;
unused_parameter(unused);
w_set_thread_name("perflog");
// Prep some things that we'll need each time we run a command
{
uint32_t env_size;
w_ht_t *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(NULL, "perf_logger_command");
if (json_is_string(perf_cmd)) {
perf_cmd = json_pack("[O]", 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(NULL, "perf_logger_command_max_samples_per_call", 4);
while (true) {
pthread_mutex_lock(&perf_log_lock);
if (!perf_log_samples) {
pthread_cond_wait(&perf_log_cond, &perf_log_lock);
}
samples = perf_log_samples;
perf_log_samples = NULL;
pthread_mutex_unlock(&perf_log_lock);
if (samples) {
while (json_array_size(samples) > 0) {
int i = 0;
json_t *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);
json_array_append(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) {
// There's no sense waiting here, because w_reap_children is called
// by the reaper thread.
} 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);
json_decref(cmd);
}
json_decref(samples);
}
}
return NULL;
}
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);
}
}
}
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void *client_thread(void *ptr)
{
struct watchman_client *client = ptr;
struct watchman_event_poll pfd[2];
json_t *request;
json_error_t jerr;
w_stm_set_nonblock(client->stm, true);
w_set_thread_name("client:stm=%p", client->stm);
w_stm_get_events(client->stm, &pfd[0].evt);
pfd[1].evt = client->ping;
while (!stopping) {
// 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) {
request = w_json_buffer_next(&client->reader, client->stm, &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 disconected;
}
send_error_response(client, "invalid json at position %d: %s",
jerr.position, jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
dispatch_command(client, request, CMD_DAEMON);
json_decref(request);
}
}
if (pfd[1].ready) {
w_event_test_and_clear(client->ping);
}
/* now send our response(s) */
while (client->head) {
struct watchman_client_response *resp;
/* de-queue the first response */
pthread_mutex_lock(&w_client_lock);
resp = client->head;
if (resp) {
client->head = resp->next;
if (client->tail == resp) {
client->tail = NULL;
}
}
pthread_mutex_unlock(&w_client_lock);
if (resp) {
bool ok;
w_stm_set_nonblock(client->stm, false);
/* Return the data in the same format that was used to ask for it */
ok = w_ser_write_pdu(client->pdu_type, &client->writer,
client->stm, resp->json);
json_decref(resp->json);
free(resp);
w_stm_set_nonblock(client->stm, true);
if (!ok) {
break;
}
}
}
}
disconected:
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
return NULL;
}
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");
}
static void run_service(void)
{
int fd;
bool res;
#ifndef _WIN32
// Before we redirect stdin/stdout to the log files, move any inetd-provided
// socket to a different descriptor number.
if (inetd_style) {
if (!w_listener_prep_inetd()) {
return;
}
}
#endif
// redirect std{in,out,err}
fd = open("/dev/null", O_RDONLY);
if (fd != -1) {
ignore_result(dup2(fd, STDIN_FILENO));
close(fd);
}
fd = open(log_name, O_WRONLY|O_APPEND|O_CREAT, 0600);
if (fd != -1) {
ignore_result(dup2(fd, STDOUT_FILENO));
ignore_result(dup2(fd, STDERR_FILENO));
close(fd);
}
if (!lock_pidfile()) {
return;
}
#ifndef _WIN32
/* we are the child, let's set things up */
ignore_result(chdir("/"));
#endif
w_set_thread_name("listener");
{
char hostname[256];
gethostname(hostname, sizeof(hostname));
hostname[sizeof(hostname) - 1] = '\0';
w_log(W_LOG_ERR, "Watchman %s %s starting up on %s\n",
PACKAGE_VERSION,
#ifdef WATCHMAN_BUILD_INFO
WATCHMAN_BUILD_INFO,
#else
"<no build info set>",
#endif
hostname);
}
watchman_watcher_init();
w_clockspec_init();
w_state_load();
w_start_reaper();
res = w_start_listener(sock_name);
w_root_free_watched_roots();
if (res) {
exit(0);
}
exit(1);
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void *client_thread(void *ptr)
{
struct watchman_client *client = ptr;
struct watchman_event_poll pfd[2];
struct watchman_client_response *queued_responses_to_send;
json_t *request;
json_error_t jerr;
bool send_ok = true;
w_stm_set_nonblock(client->stm, true);
w_set_thread_name("client=%p:stm=%p", client, client->stm);
client->client_is_owner = w_stm_peer_is_owner(client->stm);
w_stm_get_events(client->stm, &pfd[0].evt);
pfd[1].evt = client->ping;
while (!stopping) {
// 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) {
request = w_json_buffer_next(&client->reader, client->stm, &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 disconected;
}
send_error_response(client, "invalid json at position %d: %s",
jerr.position, jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
dispatch_command(client, request, CMD_DAEMON);
json_decref(request);
}
}
if (pfd[1].ready) {
w_event_test_and_clear(client->ping);
}
/* de-queue the pending responses under the lock */
pthread_mutex_lock(&w_client_lock);
queued_responses_to_send = client->head;
client->head = NULL;
client->tail = NULL;
pthread_mutex_unlock(&w_client_lock);
/* now send our response(s) */
while (queued_responses_to_send) {
struct watchman_client_response *response_to_send =
queued_responses_to_send;
if (send_ok) {
w_stm_set_nonblock(client->stm, false);
/* Return the data in the same format that was used to ask for it.
* Don't bother sending any more messages if the client disconnects,
* but still free their memory.
*/
send_ok = w_ser_write_pdu(client->pdu_type, &client->writer,
client->stm, response_to_send->json);
w_stm_set_nonblock(client->stm, true);
}
queued_responses_to_send = response_to_send->next;
json_decref(response_to_send->json);
free(response_to_send);
}
}
disconected:
w_set_thread_name("NOT_CONN:client=%p:stm=%p", client, client->stm);
// 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
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
client_delete(client);
return NULL;
}
static void *fsevents_thread(void *arg)
{
w_root_t *root = arg;
FSEventStreamContext ctx;
CFMutableArrayRef parray;
CFStringRef cpath;
FSEventStreamRef fs_stream = NULL;
CFFileDescriptorContext fdctx;
CFFileDescriptorRef fdref;
struct fsevents_root_state *state = root->watch;
double latency;
w_set_thread_name("fsevents %.*s", root->root_path->len,
root->root_path->buf);
// Block until fsevents_root_start is waiting for our initialization
pthread_mutex_lock(&state->fse_mtx);
memset(&ctx, 0, sizeof(ctx));
ctx.info = root;
memset(&fdctx, 0, sizeof(fdctx));
fdctx.info = root;
fdref = CFFileDescriptorCreate(NULL, state->fse_pipe[0], true,
fse_pipe_callback, &fdctx);
CFFileDescriptorEnableCallBacks(fdref, kCFFileDescriptorReadCallBack);
{
CFRunLoopSourceRef fdsrc;
fdsrc = CFFileDescriptorCreateRunLoopSource(NULL, fdref, 0);
if (!fdsrc) {
root->failure_reason = w_string_new(
"CFFileDescriptorCreateRunLoopSource failed");
goto done;
}
CFRunLoopAddSource(CFRunLoopGetCurrent(), fdsrc, kCFRunLoopDefaultMode);
CFRelease(fdsrc);
}
parray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
if (!parray) {
root->failure_reason = w_string_new("CFArrayCreateMutable failed");
goto done;
}
cpath = CFStringCreateWithBytes(NULL, (const UInt8*)root->root_path->buf,
root->root_path->len, kCFStringEncodingUTF8,
false);
if (!cpath) {
root->failure_reason = w_string_new("CFStringCreateWithBytes failed");
goto done;
}
CFArrayAppendValue(parray, cpath);
CFRelease(cpath);
latency = cfg_get_double(root, "fsevents_latency", 0.01),
w_log(W_LOG_DBG,
"FSEventStreamCreate for path %.*s with latency %f seconds\n",
root->root_path->len,
root->root_path->buf,
latency);
fs_stream = FSEventStreamCreate(NULL, fse_callback,
&ctx, parray, kFSEventStreamEventIdSinceNow,
latency,
kFSEventStreamCreateFlagNoDefer|
kFSEventStreamCreateFlagWatchRoot|
kFSEventStreamCreateFlagFileEvents);
if (!fs_stream) {
root->failure_reason = w_string_new("FSEventStreamCreate failed");
goto done;
}
FSEventStreamScheduleWithRunLoop(fs_stream,
CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
if (!FSEventStreamStart(fs_stream)) {
root->failure_reason = w_string_make_printf(
"FSEventStreamStart failed, look at your log file %s for "
"lines mentioning FSEvents and see "
"https://facebook.github.io/watchman/docs/troubleshooting.html#"
"fsevents for more information\n", log_name);
goto done;
}
// Signal to fsevents_root_start that we're done initializing
pthread_cond_signal(&state->fse_cond);
pthread_mutex_unlock(&state->fse_mtx);
// Process the events stream until we get signalled to quit
CFRunLoopRun();
// Since the goto's above hold fse_mtx, we should grab it here
pthread_mutex_lock(&state->fse_mtx);
done:
if (fs_stream) {
FSEventStreamStop(fs_stream);
FSEventStreamInvalidate(fs_stream);
FSEventStreamRelease(fs_stream);
}
if (fdref) {
CFRelease(fdref);
}
// Signal to fsevents_root_start that we're done initializing in
// the failure path. We'll also do this after we've completed
// the run loop in the success path; it's a spurious wakeup but
// harmless and saves us from adding and setting a control flag
// in each of the failure `goto` statements. fsevents_root_dtor
// will `pthread_join` us before `state` is freed.
pthread_cond_signal(&state->fse_cond);
pthread_mutex_unlock(&state->fse_mtx);
w_log(W_LOG_DBG, "fse_thread done\n");
w_root_delref(root);
return NULL;
}
// The client thread reads and decodes json packets,
// then dispatches the commands that it finds
static void *client_thread(void *ptr)
{
struct watchman_client *client = ptr;
struct pollfd pfd[2];
json_t *request;
json_error_t jerr;
char buf[16];
w_set_nonblock(client->fd);
w_set_thread_name("client:fd=%d", client->fd);
while (!stopping) {
// 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
pfd[0].fd = client->fd;
pfd[0].events = POLLIN|POLLHUP|POLLERR;
pfd[0].revents = 0;
pfd[1].fd = client->ping[0];
pfd[1].events = POLLIN|POLLHUP|POLLERR;
pfd[1].revents = 0;
ignore_result(poll(pfd, 2, 200));
if (stopping) {
break;
}
if (pfd[0].revents & (POLLHUP|POLLERR)) {
w_log(W_LOG_DBG, "got HUP|ERR on client %p fd=%d, disconnecting\n",
client, client->fd);
break;
}
if (pfd[0].revents) {
// Solaris: we may not detect POLLHUP until we try to read, so
// let's peek ahead and characterize it correctly. This is only
// needed if we have no data buffered
if (client->reader.wpos == client->reader.rpos) {
char peek;
if (recv(client->fd, &peek, sizeof(peek), MSG_PEEK) == 0) {
w_log(W_LOG_DBG, "got HUP|ERR on client fd=%d, disconnecting\n",
client->fd);
goto disconected;
}
}
request = w_json_buffer_next(&client->reader, client->fd, &jerr);
if (!request && errno == EAGAIN) {
// That's fine
} else if (!request) {
// Not so cool
send_error_response(client, "invalid json at position %d: %s",
jerr.position, jerr.text);
w_log(W_LOG_ERR, "invalid data from client: %s\n", jerr.text);
goto disconected;
} else if (request) {
client->pdu_type = client->reader.pdu_type;
dispatch_command(client, request, CMD_DAEMON);
json_decref(request);
}
}
if (pfd[1].revents) {
ignore_result(read(client->ping[0], buf, sizeof(buf)));
}
/* now send our response(s) */
while (client->head) {
struct watchman_client_response *resp;
/* de-queue the first response */
pthread_mutex_lock(&w_client_lock);
resp = client->head;
if (resp) {
client->head = resp->next;
if (client->tail == resp) {
client->tail = NULL;
}
}
pthread_mutex_unlock(&w_client_lock);
if (resp) {
w_clear_nonblock(client->fd);
/* Return the data in the same format that was used to ask for it */
w_ser_write_pdu(client->pdu_type, &client->writer,
client->fd, resp->json);
json_decref(resp->json);
free(resp);
w_set_nonblock(client->fd);
}
}
}
disconected:
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, client->fd);
pthread_mutex_unlock(&w_client_lock);
return NULL;
}
