static bool dir_generator(
w_query *query,
w_root_t *root,
struct w_query_ctx *ctx,
struct watchman_dir *dir,
uint32_t depth)
{
w_ht_iter_t i;
if (w_ht_first(dir->files, &i)) do {
struct watchman_file *file = w_ht_val_ptr(i.value);
if (!w_query_process_file(query, ctx, file)) {
return false;
}
} while (w_ht_next(dir->files, &i));
if (depth > 0 && w_ht_first(dir->dirs, &i)) do {
struct watchman_dir *child = w_ht_val_ptr(i.value);
if (!dir_generator(query, root, ctx, child, depth - 1)) {
return false;
}
} while (w_ht_next(dir->dirs, &i));
return true;
}
// The ignore logic is to stop recursion of grandchildren or later
// generations than an ignored dir. We allow the direct children
// of an ignored dir, but no further down.
bool w_is_ignored(w_root_t *root, const char *path, uint32_t pathlen)
{
w_ht_iter_t i;
if (w_ht_first(root->ignore_dirs, &i)) do {
w_string_t *ign = w_ht_val_ptr(i.value);
if (pathlen < ign->len) {
continue;
}
if (memcmp(ign->buf, path, ign->len) == 0) {
if (ign->len == pathlen) {
// Exact match
return true;
}
if (path[ign->len] == WATCHMAN_DIR_SEP) {
// prefix match
return true;
}
}
} while (w_ht_next(root->ignore_dirs, &i));
if (w_ht_first(root->ignore_vcs, &i)) do {
w_string_t *ign = w_ht_val_ptr(i.value);
if (pathlen <= ign->len) {
continue;
}
if (memcmp(ign->buf, path, ign->len) == 0) {
// prefix matches, but it isn't a parent
if (path[ign->len] != WATCHMAN_DIR_SEP) {
continue;
}
// If we find any '/' in the remainder of the path, then we should
// ignore it. Otherwise we allow it.
path += ign->len + 1;
pathlen -= ign->len + 1;
if (memchr(path, WATCHMAN_DIR_SEP, pathlen)) {
return true;
}
}
} while (w_ht_next(root->ignore_vcs, &i));
return false;
}
/* parse an expression term. It can be one of:
* "term"
* ["term" <parameters>]
*/
w_query_expr *w_query_expr_parse(w_query *query, json_t *exp)
{
w_string_t *name;
w_query_expr_parser parser;
if (json_is_string(exp)) {
name = w_string_new(json_string_value(exp));
} else if (json_is_array(exp) && json_array_size(exp) > 0) {
json_t *first = json_array_get(exp, 0);
if (!json_is_string(first)) {
query->errmsg = strdup(
"first element of an expression must be a string");
return NULL;
}
name = w_string_new(json_string_value(first));
} else {
query->errmsg = strdup("expected array or string for an expression");
return NULL;
}
parser = w_ht_val_ptr(w_ht_get(term_hash, w_ht_ptr_val(name)));
if (!parser) {
ignore_result(asprintf(&query->errmsg,
"unknown expression term '%s'",
name->buf));
w_string_delref(name);
return NULL;
}
w_string_delref(name);
return parser(query, exp);
}
void w_log_to_clients(int level, const char *buf)
{
json_t *json = NULL;
w_ht_iter_t iter;
if (!clients) {
return;
}
pthread_mutex_lock(&w_client_lock);
if (w_ht_first(clients, &iter)) do {
struct watchman_client *client = w_ht_val_ptr(iter.value);
if (client->log_level != W_LOG_OFF && client->log_level >= level) {
json = make_response();
if (json) {
set_prop(json, "log", json_string_nocheck(buf));
if (!enqueue_response(client, json, true)) {
json_decref(json);
}
}
}
} while (w_ht_next(clients, &iter));
pthread_mutex_unlock(&w_client_lock);
}
bool w_should_log_to_clients(int level)
{
w_ht_iter_t iter;
bool result = false;
pthread_mutex_lock(&w_client_lock);
if (!clients) {
pthread_mutex_unlock(&w_client_lock);
return false;
}
if (w_ht_first(clients, &iter)) do {
struct watchman_client *client = w_ht_val_ptr(iter.value);
if (client->log_level != W_LOG_OFF && client->log_level >= level) {
result = true;
break;
}
} while (w_ht_next(clients, &iter));
pthread_mutex_unlock(&w_client_lock);
return result;
}
static void cmd_debug_show_cursors(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp, *cursors;
w_ht_iter_t i;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client,
"wrong number of arguments for 'debug-show-cursors'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
resp = make_response();
w_root_lock(root);
cursors = json_object_of_size(w_ht_size(root->cursors));
if (w_ht_first(root->cursors, &i)) do {
w_string_t *name = w_ht_val_ptr(i.key);
set_prop(cursors, name->buf, json_integer(i.value));
} while (w_ht_next(root->cursors, &i));
w_root_unlock(root);
set_prop(resp, "cursors", cursors);
send_and_dispose_response(client, resp);
w_root_delref(root);
}
static bool suffix_generator(
w_query *query,
w_root_t *root,
struct w_query_ctx *ctx,
int64_t *num_walked)
{
uint32_t i;
struct watchman_file *f;
int64_t n = 0;
bool result = true;
for (i = 0; i < query->nsuffixes; i++) {
// Head of suffix index for this suffix
f = w_ht_val_ptr(w_ht_get(root->suffixes,
w_ht_ptr_val(query->suffixes[i])));
// Walk and process
for (; f; f = f->suffix_next) {
++n;
if (!w_query_file_matches_relative_root(ctx, f)) {
continue;
}
if (!w_query_process_file(query, ctx, f)) {
result = false;
goto done;
}
}
}
done:
*num_walked = n;
return result;
}
// Caller must hold spawn_lock
static w_root_t *lookup_running_pid(pid_t pid)
{
if (!running_kids) {
return NULL;
}
return w_ht_val_ptr(w_ht_get(running_kids, pid));
}
static w_ht_val_t copy_pending(w_ht_val_t key) {
struct pending_move *src = w_ht_val_ptr(key);
struct pending_move *dest = malloc(sizeof(*dest));
dest->created = src->created;
dest->name = src->name;
w_string_addref(src->name);
return w_ht_ptr_val(dest);
}
static void delete_subscription(w_ht_val_t val)
{
struct watchman_client_subscription *sub = w_ht_val_ptr(val);
w_string_delref(sub->name);
w_query_delref(sub->query);
free(sub);
}
static bool inot_root_consume_notify(watchman_global_watcher_t watcher,
w_root_t *root, struct watchman_pending_collection *coll)
{
struct inot_root_state *state = root->watch;
struct inotify_event *ine;
char *iptr;
int n;
struct timeval now;
unused_parameter(watcher);
n = read(state->infd, &state->ibuf, sizeof(state->ibuf));
if (n == -1) {
if (errno == EINTR) {
return false;
}
w_log(W_LOG_FATAL, "read(%d, %zu): error %s\n",
state->infd, sizeof(state->ibuf), strerror(errno));
}
w_log(W_LOG_DBG, "inotify read: returned %d.\n", n);
gettimeofday(&now, NULL);
for (iptr = state->ibuf; iptr < state->ibuf + n;
iptr = iptr + sizeof(*ine) + ine->len) {
ine = (struct inotify_event*)iptr;
process_inotify_event(root, coll, ine, now);
if (root->cancelled) {
return false;
}
}
// It is possible that we can accumulate a set of pending_move
// structs in move_map. This happens when a directory is moved
// outside of the watched tree; we get the MOVE_FROM but never
// get the MOVE_TO with the same cookie. To avoid leaking these,
// we'll age out the move_map after processing a full set of
// inotify events. We age out rather than delete all because
// the MOVE_TO may yet be waiting to read in another go around.
// We allow a somewhat arbitrary but practical grace period to
// observe the corresponding MOVE_TO.
if (w_ht_size(state->move_map) > 0) {
w_ht_iter_t iter;
if (w_ht_first(state->move_map, &iter)) do {
struct pending_move *pending = w_ht_val_ptr(iter.value);
if (now.tv_sec - pending->created > 5 /* seconds */) {
w_log(W_LOG_DBG,
"deleting pending move %s (moved outside of watch?)\n",
pending->name->buf);
w_ht_iter_del(state->move_map, &iter);
}
} while (w_ht_next(state->move_map, &iter));
}
return true;
}
json_t *w_capability_get_list(void) {
json_t *arr = json_array_of_size(w_ht_size(capabilities));
w_ht_iter_t iter;
w_ht_first(capabilities, &iter);
do {
w_string_t *name = w_ht_val_ptr(iter.key);
json_array_append(arr, w_string_to_json(name));
} while (w_ht_next(capabilities, &iter));
return arr;
}
void w_cancel_subscriptions_for_root(w_root_t *root) {
w_ht_iter_t iter;
pthread_mutex_lock(&w_client_lock);
if (w_ht_first(clients, &iter)) {
do {
struct watchman_user_client *client = w_ht_val_ptr(iter.value);
w_ht_iter_t citer;
if (w_ht_first(client->subscriptions, &citer)) {
do {
struct watchman_client_subscription *sub = w_ht_val_ptr(citer.value);
if (sub->root == root) {
json_t *response = make_response();
w_log(W_LOG_ERR,
"Cancel subscription %.*s for client:stm=%p due to "
"root cancellation\n",
sub->name->len, sub->name->buf, client->client.stm);
set_prop(response, "root", w_string_to_json(root->root_path));
set_prop(response, "subscription", w_string_to_json(sub->name));
set_prop(response, "unilateral", json_true());
set_prop(response, "canceled", json_true());
if (!enqueue_response(&client->client, response, true)) {
w_log(W_LOG_DBG, "failed to queue sub cancellation\n");
json_decref(response);
}
w_ht_iter_del(client->subscriptions, &citer);
}
} while (w_ht_next(client->subscriptions, &citer));
}
} while (w_ht_next(clients, &iter));
}
pthread_mutex_unlock(&w_client_lock);
}
static bool dir_generator(
w_query *query,
w_root_t *root,
struct w_query_ctx *ctx,
struct watchman_dir *dir,
uint32_t depth,
int64_t *num_walked)
{
w_ht_iter_t i;
int64_t n = 0;
bool result = true;
if (w_ht_first(dir->files, &i)) do {
struct watchman_file *file = w_ht_val_ptr(i.value);
++n;
if (!w_query_process_file(query, ctx, file)) {
result = false;
goto done;
}
} while (w_ht_next(dir->files, &i));
if (depth > 0 && w_ht_first(dir->dirs, &i)) do {
struct watchman_dir *child = w_ht_val_ptr(i.value);
int64_t child_walked = 0;
result = dir_generator(query, root, ctx, child, depth - 1, &child_walked);
n += child_walked;
if (!result) {
goto done;
}
} while (w_ht_next(dir->dirs, &i));
done:
*num_walked = n;
return result;
}
void w_mark_dead(pid_t pid)
{
w_root_t *root = NULL;
w_ht_iter_t iter;
pthread_mutex_lock(&spawn_lock);
root = lookup_running_pid(pid);
if (!root) {
pthread_mutex_unlock(&spawn_lock);
return;
}
delete_running_pid(pid);
pthread_mutex_unlock(&spawn_lock);
w_log(W_LOG_DBG, "mark_dead: %.*s child pid %d\n",
root->root_path->len, root->root_path->buf, (int)pid);
/* now walk the cmds and try to find our match */
w_root_lock(root);
/* walk the list of triggers, and run their rules */
if (w_ht_first(root->commands, &iter)) do {
struct watchman_trigger_command *cmd;
cmd = w_ht_val_ptr(iter.value);
if (cmd->current_proc != pid) {
w_log(W_LOG_DBG, "mark_dead: is [%.*s] %d == %d\n",
cmd->triggername->len, cmd->triggername->buf,
(int)cmd->current_proc, (int)pid);
continue;
}
/* first mark the process as dead */
cmd->current_proc = 0;
if (root->cancelled) {
w_log(W_LOG_DBG, "mark_dead: root was cancelled\n");
break;
}
w_assess_trigger(root, cmd);
break;
} while (w_ht_next(root->commands, &iter));
w_root_unlock(root);
w_root_delref(root);
}
void print_command_list_for_help(FILE *where)
{
uint32_t i = 0, n = w_ht_size(command_funcs);
struct watchman_command_handler_def **defs;
w_ht_iter_t iter;
defs = calloc(n, sizeof(*defs));
if (w_ht_first(command_funcs, &iter)) do {
defs[i++] = w_ht_val_ptr(iter.value);
} while (w_ht_next(command_funcs, &iter));
qsort(defs, n, sizeof(*defs), compare_def);
fprintf(where, "\n\nAvailable commands:\n\n");
for (i = 0; i < n; i++) {
fprintf(where, " %s\n", defs[i]->name);
}
}
BOOL w_wait_for_any_child(DWORD timeoutms, DWORD *pid) {
HANDLE handles[MAXIMUM_WAIT_OBJECTS];
DWORD pids[MAXIMUM_WAIT_OBJECTS];
int i = 0;
w_ht_iter_t iter;
DWORD res;
*pid = 0;
pthread_mutex_lock(&child_proc_lock);
if (child_procs && w_ht_first(child_procs, &iter)) do {
HANDLE proc = w_ht_val_ptr(iter.value);
pids[i] = (DWORD)iter.key;
handles[i++] = proc;
} while (w_ht_next(child_procs, &iter));
pthread_mutex_unlock(&child_proc_lock);
if (i == 0) {
return false;
}
w_log(W_LOG_DBG, "w_wait_for_any_child: waiting for %d handles\n", i);
res = WaitForMultipleObjectsEx(i, handles, false, timeoutms, true);
if (res == WAIT_FAILED) {
errno = map_win32_err(GetLastError());
return false;
}
if (res < WAIT_OBJECT_0 + i) {
i = res - WAIT_OBJECT_0;
} else if (res >= WAIT_ABANDONED_0 && res < WAIT_ABANDONED_0 + i) {
i = res - WAIT_ABANDONED_0;
} else {
return false;
}
pthread_mutex_lock(&child_proc_lock);
w_ht_del(child_procs, pids[i]);
pthread_mutex_unlock(&child_proc_lock);
CloseHandle(handles[i]);
*pid = pids[i];
return true;
}
static void client_delete(w_ht_val_t val)
{
struct watchman_client *client = w_ht_val_ptr(val);
struct watchman_client_response *resp;
/* cancel subscriptions */
w_ht_free(client->subscriptions);
while (client->head) {
resp = client->head;
client->head = resp->next;
json_decref(resp->json);
free(resp);
}
w_json_buffer_free(&client->reader);
w_json_buffer_free(&client->writer);
close(client->ping[0]);
close(client->ping[1]);
close(client->fd);
free(client);
}
static struct watchman_command_handler_def *lookup(
json_t *args, char **errmsg, int mode)
{
struct watchman_command_handler_def *def;
const char *cmd_name;
w_string_t *cmd;
if (!json_array_size(args)) {
ignore_result(asprintf(errmsg,
"invalid command (expected an array with some elements!)"));
return false;
}
cmd_name = json_string_value(json_array_get(args, 0));
if (!cmd_name) {
ignore_result(asprintf(errmsg,
"invalid command: expected element 0 to be the command name"));
return false;
}
cmd = w_string_new(cmd_name);
def = w_ht_val_ptr(w_ht_get(command_funcs, w_ht_ptr_val(cmd)));
w_string_delref(cmd);
if (def) {
if (mode && ((def->flags & mode) == 0)) {
ignore_result(asprintf(errmsg,
"command %s not available in this mode", cmd_name));
return NULL;
}
return def;
}
if (mode) {
ignore_result(asprintf(errmsg, "unknown command %s", cmd_name));
}
return NULL;
}
static void client_delete(w_ht_val_t val)
{
struct watchman_client *client = w_ht_val_ptr(val);
struct watchman_client_response *resp;
w_log(W_LOG_DBG, "client_delete %p\n", client);
/* cancel subscriptions */
w_ht_free(client->subscriptions);
while (client->head) {
resp = client->head;
client->head = resp->next;
json_decref(resp->json);
free(resp);
}
w_json_buffer_free(&client->reader);
w_json_buffer_free(&client->writer);
w_event_destroy(client->ping);
w_stm_close(client->stm);
free(client);
}
static bool suffix_generator(
w_query *query,
w_root_t *root,
struct w_query_ctx *ctx)
{
uint32_t i;
struct watchman_file *f;
for (i = 0; i < query->nsuffixes; i++) {
// Head of suffix index for this suffix
f = w_ht_val_ptr(w_ht_get(root->suffixes,
w_ht_ptr_val(query->suffixes[i])));
// Walk and process
while (f) {
if (!w_query_process_file(query, ctx, f)) {
return false;
}
f = f->suffix_next;
}
}
return true;
}
static bool kqueue_root_consume_notify(watchman_global_watcher_t watcher,
w_root_t *root, struct watchman_pending_collection *coll)
{
struct kqueue_root_state *state = root->watch;
int n;
int i;
struct timespec ts = { 0, 0 };
struct timeval now;
unused_parameter(watcher);
errno = 0;
n = kevent(state->kq_fd, NULL, 0,
state->keventbuf, sizeof(state->keventbuf) / sizeof(state->keventbuf[0]),
&ts);
w_log(W_LOG_DBG, "consume_kqueue: %s n=%d err=%s\n",
root->root_path->buf, n, strerror(errno));
if (root->cancelled) {
return 0;
}
gettimeofday(&now, NULL);
for (i = 0; n > 0 && i < n; i++) {
uint32_t fflags = state->keventbuf[i].fflags;
bool is_dir = IS_DIR_BIT_SET(state->keventbuf[i].udata);
w_string_t *path;
char flags_label[128];
int fd = state->keventbuf[i].ident;
w_expand_flags(kflags, fflags, flags_label, sizeof(flags_label));
pthread_mutex_lock(&state->lock);
path = w_ht_val_ptr(w_ht_get(state->fd_to_name, fd));
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);
pthread_mutex_unlock(&state->lock);
continue;
}
w_string_addref(path);
w_log(W_LOG_DBG, " KQ fd=%d path %s [0x%x %s]\n",
fd, path->buf, 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->buf, fflags);
w_root_cancel(root);
pthread_mutex_unlock(&state->lock);
return 0;
}
// Remove our watch bits
memset(&k, 0, sizeof(k));
EV_SET(&k, fd, EVFILT_VNODE, EV_DELETE, 0, 0, NULL);
kevent(state->kq_fd, &k, 1, NULL, 0, 0);
w_ht_del(state->name_to_fd, w_ht_ptr_val(path));
w_ht_del(state->fd_to_name, fd);
}
pthread_mutex_unlock(&state->lock);
w_pending_coll_add(coll, path, !is_dir, now, !is_dir);
w_string_delref(path);
}
return n > 0;
}
bool w_start_listener(const char *path)
{
#ifndef _WIN32
struct sigaction sa;
sigset_t sigset;
#endif
void *ignored;
listener_thread = pthread_self();
#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);
listener_fd = get_listener_socket(path);
if (listener_fd == -1) {
return false;
}
w_set_cloexec(listener_fd);
#endif
if (!clients) {
clients = w_ht_new(2, NULL);
}
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
} else {
w_setup_signal_handlers();
}
#else
w_setup_signal_handlers();
#endif
w_set_nonblock(listener_fd);
// Now run the dispatch
#ifndef _WIN32
accept_loop();
#else
named_pipe_accept_loop(path);
#endif
#ifndef _WIN32
/* close out some resources to persuade valgrind to run clean */
close(listener_fd);
listener_fd = -1;
#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 {
w_ht_iter_t iter;
pthread_mutex_lock(&w_client_lock);
n_clients = w_ht_size(clients);
if (w_ht_first(clients, &iter)) do {
struct watchman_client *client = w_ht_val_ptr(iter.value);
w_event_set(client->ping);
#ifndef _WIN32
// If we've been waiting around for a while, interrupt
// the client thread; it may be blocked on a write
if (interval >= max_interval) {
pthread_kill(client->thread_handle, SIGUSR1);
}
#endif
} while (w_ht_next(clients, &iter));
pthread_mutex_unlock(&w_client_lock);
if (n_clients != last_count) {
w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients);
}
usleep(interval);
interval = MIN(interval * 2, max_interval);
} while (n_clients > 0);
}
pthread_join(reaper_thread, &ignored);
cfg_shutdown();
return true;
}
static void process_inotify_event(
w_root_t *root,
struct watchman_pending_collection *coll,
struct inotify_event *ine,
struct timeval now)
{
struct inot_root_state *state = root->watch;
char flags_label[128];
w_expand_flags(inflags, ine->mask, flags_label, sizeof(flags_label));
w_log(W_LOG_DBG, "notify: wd=%d mask=0x%x %s %s\n", ine->wd, ine->mask,
flags_label, ine->len > 0 ? ine->name : "");
if (ine->wd == -1 && (ine->mask & IN_Q_OVERFLOW)) {
/* we missed something, will need to re-crawl */
w_root_schedule_recrawl(root, "IN_Q_OVERFLOW");
} else if (ine->wd != -1) {
w_string_t *dir_name = NULL;
w_string_t *name = NULL;
char buf[WATCHMAN_NAME_MAX];
int pending_flags = W_PENDING_VIA_NOTIFY;
pthread_mutex_lock(&state->lock);
dir_name = w_ht_val_ptr(w_ht_get(state->wd_to_name, ine->wd));
if (dir_name) {
w_string_addref(dir_name);
}
pthread_mutex_unlock(&state->lock);
if (dir_name) {
if (ine->len > 0) {
snprintf(buf, sizeof(buf), "%.*s/%s",
dir_name->len, dir_name->buf,
ine->name);
name = w_string_new(buf);
} else {
name = dir_name;
w_string_addref(name);
}
}
if (ine->len > 0 && (ine->mask & (IN_MOVED_FROM|IN_ISDIR))
== (IN_MOVED_FROM|IN_ISDIR)) {
struct pending_move mv;
// record this as a pending move, so that we can automatically
// watch the target when we get the other side of it.
mv.created = now.tv_sec;
mv.name = name;
pthread_mutex_lock(&state->lock);
if (!w_ht_replace(state->move_map, ine->cookie, w_ht_ptr_val(&mv))) {
w_log(W_LOG_FATAL,
"failed to store %" PRIx32 " -> %s in move map\n",
ine->cookie, name->buf);
}
pthread_mutex_unlock(&state->lock);
w_log(W_LOG_DBG,
"recording move_from %" PRIx32 " %s\n", ine->cookie,
name->buf);
}
if (ine->len > 0 && (ine->mask & (IN_MOVED_TO|IN_ISDIR))
== (IN_MOVED_FROM|IN_ISDIR)) {
struct pending_move *old;
pthread_mutex_lock(&state->lock);
old = w_ht_val_ptr(w_ht_get(state->move_map, ine->cookie));
if (old) {
int wd = inotify_add_watch(state->infd, name->buf,
WATCHMAN_INOTIFY_MASK);
if (wd == -1) {
if (errno == ENOSPC || errno == ENOMEM) {
// Limits exceeded, no recovery from our perspective
set_poison_state(root, name, now, "inotify-add-watch", errno,
inot_strerror(errno));
} else {
w_log(W_LOG_DBG, "add_watch: %s %s\n",
name->buf, inot_strerror(errno));
}
} else {
w_log(W_LOG_DBG, "moved %s -> %s\n", old->name->buf, name->buf);
w_ht_replace(state->wd_to_name, wd, w_ht_ptr_val(name));
}
} else {
w_log(W_LOG_DBG, "move: cookie=%" PRIx32 " not found in move map %s\n",
ine->cookie, name->buf);
}
pthread_mutex_unlock(&state->lock);
}
if (dir_name) {
if ((ine->mask & (IN_UNMOUNT|IN_IGNORED|IN_DELETE_SELF|IN_MOVE_SELF))) {
w_string_t *pname;
if (w_string_equal(root->root_path, name)) {
w_log(W_LOG_ERR,
"root dir %s has been (re)moved, canceling watch\n",
root->root_path->buf);
w_string_delref(name);
w_string_delref(dir_name);
w_root_cancel(root);
return;
}
// We need to examine the parent and crawl down
pname = w_string_dirname(name);
w_log(W_LOG_DBG, "mask=%x, focus on parent: %.*s\n",
ine->mask, pname->len, pname->buf);
w_string_delref(name);
name = pname;
pending_flags |= W_PENDING_RECURSIVE;
}
if (ine->mask & (IN_CREATE|IN_DELETE)) {
pending_flags |= W_PENDING_RECURSIVE;
}
w_log(W_LOG_DBG, "add_pending for inotify mask=%x %.*s\n",
ine->mask, name->len, name->buf);
w_pending_coll_add(coll, name, now, pending_flags);
w_string_delref(name);
// The kernel removed the wd -> name mapping, so let's update
// our state here also
if ((ine->mask & IN_IGNORED) != 0) {
w_log(W_LOG_DBG, "mask=%x: remove watch %d %.*s\n", ine->mask,
ine->wd, dir_name->len, dir_name->buf);
pthread_mutex_lock(&state->lock);
w_ht_del(state->wd_to_name, ine->wd);
pthread_mutex_unlock(&state->lock);
}
w_string_delref(dir_name);
} else if ((ine->mask & (IN_MOVE_SELF|IN_IGNORED)) == 0) {
// If we can't resolve the dir, and this isn't notification
// that it has gone away, then we want to recrawl to fix
// up our state.
w_log(W_LOG_ERR, "wanted dir %d for mask %x but not found %.*s\n",
ine->wd, ine->mask, ine->len, ine->name);
w_root_schedule_recrawl(root, "dir missing from internal state");
}
}
}
static void del_pending(w_ht_val_t key) {
struct pending_move *p = w_ht_val_ptr(key);
w_string_delref(p->name);
free(p);
}
/* trigger /root triggername [watch patterns] -- cmd to run
* Sets up a trigger so that we can execute a command when a change
* is detected */
static void cmd_trigger(struct watchman_client *client, json_t *args)
{
w_root_t *root;
struct watchman_trigger_command *cmd, *old;
json_t *resp;
json_t *trig;
char *errmsg = NULL;
bool need_save = true;
root = resolve_root_or_err(client, args, 1, true);
if (!root) {
return;
}
if (json_array_size(args) < 3) {
send_error_response(client, "not enough arguments");
goto done;
}
trig = json_array_get(args, 2);
if (json_is_string(trig)) {
trig = build_legacy_trigger(root, client, args);
if (!trig) {
goto done;
}
} else {
// Add a ref so that we don't need to conditionally decref later
// for the legacy case later
json_incref(trig);
}
cmd = w_build_trigger_from_def(root, trig, &errmsg);
json_decref(trig);
if (!cmd) {
send_error_response(client, "%s", errmsg);
goto done;
}
resp = make_response();
set_prop(resp, "triggerid", json_string_nocheck(cmd->triggername->buf));
w_root_lock(root);
old = w_ht_val_ptr(w_ht_get(root->commands,
w_ht_ptr_val(cmd->triggername)));
if (old && json_equal(cmd->definition, old->definition)) {
// Same definition: we don't and shouldn't touch things, so that we
// preserve the associated trigger clock and don't cause the trigger
// to re-run immediately
set_prop(resp, "disposition", json_string_nocheck("already_defined"));
w_trigger_command_free(cmd);
cmd = NULL;
need_save = false;
} else {
set_prop(resp, "disposition", json_string_nocheck(
old ? "replaced" : "created"));
w_ht_replace(root->commands, w_ht_ptr_val(cmd->triggername),
w_ht_ptr_val(cmd));
// Force the trigger to be eligible to run now
root->ticks++;
root->pending_trigger_tick = root->ticks;
}
w_root_unlock(root);
if (need_save) {
w_state_save();
}
send_and_dispose_response(client, resp);
done:
if (errmsg) {
free(errmsg);
}
w_root_delref(root);
}
static bool path_generator(
w_query *query,
w_root_t *root,
struct w_query_ctx *ctx)
{
struct watchman_file *f;
uint32_t i;
for (i = 0; i < query->npaths; i++) {
struct watchman_dir *dir;
w_string_t *dir_name, *file_name, *full_name;
// Compose path with root
full_name = w_string_path_cat(root->root_path, query->paths[i].name);
// special case of root dir itself
if (w_string_equal(root->root_path, full_name)) {
// dirname on the root is outside the root, which is useless
dir = w_root_resolve_dir(root, full_name, false);
goto is_dir;
}
// Ideally, we'd just resolve it directly as a dir and be done.
// It's not quite so simple though, because we may resolve a dir
// that had been deleted and replaced by a file.
// We prefer to resolve the parent and walk down.
dir_name = w_string_dirname(full_name);
if (!dir_name) {
w_string_delref(full_name);
continue;
}
dir = w_root_resolve_dir(root, dir_name, false);
w_string_delref(dir_name);
if (!dir) {
// Doesn't exist, and never has
w_string_delref(full_name);
continue;
}
if (dir->files) {
file_name = w_string_basename(query->paths[i].name);
f = w_ht_val_ptr(w_ht_get(dir->files, w_ht_ptr_val(file_name)));
w_string_delref(file_name);
// If it's a file (but not an existent dir)
if (f && (!f->exists || !S_ISDIR(f->st.st_mode))) {
w_string_delref(full_name);
if (!w_query_process_file(query, ctx, f)) {
return false;
}
continue;
}
}
// Is it a dir?
dir = w_ht_val_ptr(w_ht_get(dir->dirs, w_ht_ptr_val(full_name)));
w_string_delref(full_name);
is_dir:
// We got a dir; process recursively to specified depth
if (dir && !dir_generator(query, root, ctx, dir,
query->paths[i].depth)) {
return false;
}
}
return true;
}
bool w_start_listener(const char *path)
{
struct sockaddr_un un;
pthread_t thr;
pthread_attr_t attr;
pthread_mutexattr_t mattr;
struct sigaction sa;
sigset_t sigset;
#ifdef HAVE_LIBGIMLI_H
volatile struct gimli_heartbeat *hb = NULL;
#endif
struct timeval tv;
void *ignored;
int n_clients = 0;
listener_thread = pthread_self();
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&w_client_lock, &mattr);
pthread_mutexattr_destroy(&mattr);
#ifdef HAVE_LIBGIMLI_H
hb = gimli_heartbeat_attach();
#endif
#if defined(HAVE_KQUEUE) || defined(HAVE_FSEVENTS)
{
struct rlimit limit;
int mib[2] = { CTL_KERN,
#ifdef KERN_MAXFILESPERPROC
KERN_MAXFILESPERPROC
#else
KERN_MAXFILES
#endif
};
int maxperproc;
size_t len;
len = sizeof(maxperproc);
sysctl(mib, 2, &maxperproc, &len, NULL, 0);
getrlimit(RLIMIT_NOFILE, &limit);
w_log(W_LOG_ERR, "file limit is %" PRIu64
" kern.maxfilesperproc=%i\n",
limit.rlim_cur, maxperproc);
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
proc_pid = (int)getpid();
if (gettimeofday(&tv, NULL) == -1) {
w_log(W_LOG_ERR, "gettimeofday failed: %s\n", strerror(errno));
return false;
}
proc_start_time = (uint64_t)tv.tv_sec;
if (strlen(path) >= sizeof(un.sun_path) - 1) {
w_log(W_LOG_ERR, "%s: path is too long\n",
path);
return false;
}
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);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
listener_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (listener_fd == -1) {
w_log(W_LOG_ERR, "socket: %s\n",
strerror(errno));
return false;
}
un.sun_family = PF_LOCAL;
strcpy(un.sun_path, path);
unlink(path);
if (bind(listener_fd, (struct sockaddr*)&un, sizeof(un)) != 0) {
w_log(W_LOG_ERR, "bind(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
if (listen(listener_fd, 200) != 0) {
w_log(W_LOG_ERR, "listen(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
w_set_cloexec(listener_fd);
if (pthread_create(&reaper_thread, NULL, child_reaper, NULL)) {
w_log(W_LOG_FATAL, "pthread_create(reaper): %s\n",
strerror(errno));
return false;
}
if (!clients) {
clients = w_ht_new(2, &client_hash_funcs);
}
w_state_load();
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
#endif
w_set_nonblock(listener_fd);
// Now run the dispatch
while (!stopping) {
int client_fd;
struct watchman_client *client;
struct pollfd pfd;
int bufsize;
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
#endif
pfd.events = POLLIN;
pfd.fd = listener_fd;
if (poll(&pfd, 1, 10000) < 1 || (pfd.revents & POLLIN) == 0) {
continue;
}
#ifdef HAVE_ACCEPT4
client_fd = accept4(listener_fd, NULL, 0, SOCK_CLOEXEC);
#else
client_fd = accept(listener_fd, NULL, 0);
#endif
if (client_fd == -1) {
continue;
}
w_set_cloexec(client_fd);
bufsize = WATCHMAN_IO_BUF_SIZE;
setsockopt(client_fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
client = calloc(1, sizeof(*client));
client->fd = client_fd;
w_log(W_LOG_DBG, "accepted client %p fd=%d\n", client, client_fd);
if (!w_json_buffer_init(&client->reader)) {
// FIXME: error handling
}
if (!w_json_buffer_init(&client->writer)) {
// FIXME: error handling
}
if (pipe(client->ping)) {
// FIXME: error handling
}
client->subscriptions = w_ht_new(2, &subscription_hash_funcs);
w_set_cloexec(client->ping[0]);
w_set_nonblock(client->ping[0]);
w_set_cloexec(client->ping[1]);
w_set_nonblock(client->ping[1]);
pthread_mutex_lock(&w_client_lock);
w_ht_set(clients, client->fd, w_ht_ptr_val(client));
pthread_mutex_unlock(&w_client_lock);
// 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.
if (pthread_create(&thr, &attr, client_thread, client)) {
// It didn't work out, sorry!
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, client->fd);
pthread_mutex_unlock(&w_client_lock);
}
}
pthread_attr_destroy(&attr);
/* close out some resources to persuade valgrind to run clean */
close(listener_fd);
listener_fd = -1;
// Wait for clients, waking any sleeping clients up in the process
do {
w_ht_iter_t iter;
pthread_mutex_lock(&w_client_lock);
n_clients = w_ht_size(clients);
if (w_ht_first(clients, &iter)) do {
struct watchman_client *client = w_ht_val_ptr(iter.value);
ignore_result(write(client->ping[1], "a", 1));
} while (w_ht_next(clients, &iter));
pthread_mutex_unlock(&w_client_lock);
w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients);
usleep(2000);
} while (n_clients > 0);
w_root_free_watched_roots();
pthread_join(reaper_thread, &ignored);
cfg_shutdown();
return true;
}
bool w_start_listener(const char *path)
{
pthread_mutexattr_t mattr;
#ifndef _WIN32
struct sigaction sa;
sigset_t sigset;
#endif
void *ignored;
#ifdef HAVE_LIBGIMLI_H
volatile struct gimli_heartbeat *hb = NULL;
#endif
struct timeval tv;
int n_clients = 0;
listener_thread = pthread_self();
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&w_client_lock, &mattr);
pthread_mutexattr_destroy(&mattr);
#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
proc_pid = (int)getpid();
if (gettimeofday(&tv, NULL) == -1) {
w_log(W_LOG_ERR, "gettimeofday failed: %s\n", strerror(errno));
return false;
}
proc_start_time = (uint64_t)tv.tv_sec;
#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);
listener_fd = get_listener_socket(path);
if (listener_fd == -1) {
return false;
}
w_set_cloexec(listener_fd);
#endif
if (pthread_create(&reaper_thread, NULL, child_reaper, NULL)) {
w_log(W_LOG_FATAL, "pthread_create(reaper): %s\n",
strerror(errno));
return false;
}
if (!clients) {
clients = w_ht_new(2, &client_hash_funcs);
}
w_state_load();
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
} else {
w_setup_signal_handlers();
}
#else
w_setup_signal_handlers();
#endif
w_set_nonblock(listener_fd);
// Now run the dispatch
#ifndef _WIN32
accept_loop();
#else
named_pipe_accept_loop(path);
#endif
#ifndef _WIN32
/* close out some resources to persuade valgrind to run clean */
close(listener_fd);
listener_fd = -1;
#endif
// Wait for clients, waking any sleeping clients up in the process
do {
w_ht_iter_t iter;
pthread_mutex_lock(&w_client_lock);
n_clients = w_ht_size(clients);
if (w_ht_first(clients, &iter)) do {
struct watchman_client *client = w_ht_val_ptr(iter.value);
w_event_set(client->ping);
} while (w_ht_next(clients, &iter));
pthread_mutex_unlock(&w_client_lock);
w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients);
usleep(2000);
} while (n_clients > 0);
w_root_free_watched_roots();
pthread_join(reaper_thread, &ignored);
cfg_shutdown();
return true;
}
