自学教程：C++ w_log函数代码示例

bool cfg_get_bool(w_root_t *root, const char *name, bool defval){  json_t *val = cfg_get_json(root, name);  if (val) {    if (!json_is_boolean(val)) {      w_log(W_LOG_FATAL, "Expected config value %s to be a boolean/n", name);    }    return json_is_true(val);  }  return defval;}

bool w_json_buffer_passthru(w_jbuffer_t *jr,    enum w_pdu_type output_pdu,    w_jbuffer_t *output_pdu_buf,    w_stm_t stm){  json_t *j;  json_error_t jerr;  bool res;  if (!read_and_detect_pdu(jr, stm, &jerr)) {    w_log(W_LOG_ERR, "failed to identify PDU: %s/n",        jerr.text);    return false;  }  if (jr->pdu_type == output_pdu) {    // We can stream it through    if (!stream_pdu(jr, stm, &jerr)) {      w_log(W_LOG_ERR, "stream_pdu: %s/n", jerr.text);      return false;    }    return true;  }  j = read_pdu_into_json(jr, stm, &jerr);  if (!j) {    w_log(W_LOG_ERR, "failed to parse response: %s/n",        jerr.text);    return false;  }  w_json_buffer_reset(output_pdu_buf);  res = w_ser_write_pdu(output_pdu, output_pdu_buf, w_stm_stdout(), j);  json_decref(j);  return res;}

void w_assess_trigger(w_root_t *root, struct watchman_trigger_command *cmd){  w_query_res res;  struct w_clockspec *since_spec = cmd->query->since_spec;  if (since_spec && since_spec->tag == w_cs_clock) {    w_log(W_LOG_DBG, "running trigger rules! since %" PRIu32 "/n",        since_spec->clock.ticks);  } else {    w_log(W_LOG_DBG, "running trigger rules!/n");  }  // Triggers never need to sync explicitly; we are only dispatched  // at settle points which are by definition sync'd to the present time  cmd->query->sync_timeout = 0;  if (!w_query_execute(cmd->query, root, &res, trigger_generator, cmd)) {    w_log(W_LOG_ERR, "error running trigger query: %s", res.errmsg);    w_query_result_free(&res);    return;  }  w_log(W_LOG_DBG, "trigger generated %" PRIu32 " results/n",      res.num_results);  // create a new spec that will be used the next time  cmd->query->since_spec = w_clockspec_new_clock(res.root_number, res.ticks);  if (res.num_results) {    spawn_command(root, cmd, &res, since_spec);  }  if (since_spec) {    w_clockspec_free(since_spec);    since_spec = NULL;  }  w_query_result_free(&res);}

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 DIR *portfs_root_start_watch_dir(watchman_global_watcher_t watcher,    w_root_t *root, struct watchman_dir *dir, struct timeval now,    const char *path) {  struct portfs_root_state *state = root->watch;  DIR *osdir;  struct stat st;  unused_parameter(watcher);  osdir = opendir_nofollow(path);  if (!osdir) {    handle_open_errno(root, dir, now, "opendir", errno, NULL);    return NULL;  }  if (fstat(dirfd(osdir), &st) == -1) {    // whaaa?    w_log(W_LOG_ERR, "fstat on opened dir %s failed: %s/n", path,        strerror(errno));    w_root_schedule_recrawl(root, "fstat failed");    closedir(osdir);    return NULL;  }  dir->port_file.fo_mtime = st.st_atim;  dir->port_file.fo_mtime = st.st_mtim;  dir->port_file.fo_ctime = st.st_ctim;  dir->port_file.fo_name = (char*)dir->path->buf;  errno = 0;  if (port_associate(state->port_fd, PORT_SOURCE_FILE,        (uintptr_t)&dir->port_file, WATCHMAN_PORT_EVENTS,        SET_DIR_BIT(dir))) {    w_log(W_LOG_ERR, "port_associate %s %s/n",        dir->port_file.fo_name, strerror(errno));  }  return osdir;}

static bool try_command(json_t *cmd, int timeout){  w_stm_t client = NULL;  w_jbuffer_t buffer;  w_jbuffer_t output_pdu_buffer;  int err;  client = w_stm_connect(sock_name, timeout * 1000);  if (client == NULL) {    return false;  }  if (!cmd) {    w_stm_close(client);    return true;  }  w_json_buffer_init(&buffer);  // Send command  if (!w_ser_write_pdu(server_pdu, &buffer, client, cmd)) {    err = errno;    w_log(W_LOG_ERR, "error sending PDU to server/n");    w_json_buffer_free(&buffer);    w_stm_close(client);    errno = err;    return false;  }  w_json_buffer_reset(&buffer);  w_json_buffer_init(&output_pdu_buffer);  do {    if (!w_json_buffer_passthru(          &buffer, output_pdu, &output_pdu_buffer, client)) {      err = errno;      w_json_buffer_free(&buffer);      w_json_buffer_free(&output_pdu_buffer);      w_stm_close(client);      errno = err;      return false;    }  } while (persistent);  w_json_buffer_free(&buffer);  w_json_buffer_free(&output_pdu_buffer);  w_stm_close(client);  return true;}

json_int_t cfg_get_int(w_root_t *root, const char *name,    json_int_t defval){  json_t *val = cfg_get_json(root, name);  if (val) {    if (!json_is_integer(val)) {      w_log(W_LOG_FATAL, "Expected config value %s to be an integer/n", name);    }    return json_integer_value(val);  }  return defval;}

const char *cfg_get_string(w_root_t *root, const char *name,    const char *defval){  json_t *val = cfg_get_json(root, name);  if (val) {    if (!json_is_string(val)) {      w_log(W_LOG_FATAL, "Expected config value %s to be a string/n", name);    }    return json_string_value(val);  }  return defval;}

static const char *compute_user_name(void) {  const char *user = get_env_with_fallback("USER", "LOGNAME", NULL);#ifdef _WIN32  static char user_buf[256];#endif  if (!user) {#ifdef _WIN32    DWORD size = sizeof(user_buf);    if (GetUserName(user_buf, &size)) {      user_buf[size] = 0;      user = user_buf;    } else {      w_log(W_LOG_FATAL, "GetUserName failed: %s. I don't know who you are/n",          win32_strerror(GetLastError()));    }#else    uid_t uid = getuid();    struct passwd *pw;    pw = getpwuid(uid);    if (!pw) {      w_log(W_LOG_FATAL, "getpwuid(%d) failed: %s. I don't know who you are/n",          uid, strerror(errno));    }    user = pw->pw_name;#endif    if (!user) {      w_log(W_LOG_ERR, "watchman requires that you set $USER in your env/n");      abort();    }  }  return user;}

static void crash_handler(int signo, siginfo_t *si, void *ucontext) {  const char *reason = "";  unused_parameter(ucontext);  if (si) {    switch (si->si_signo) {      case SIGILL:        switch (si->si_code) {          case ILL_ILLOPC: reason = "illegal opcode"; break;          case ILL_ILLOPN: reason = "illegal operand"; break;          case ILL_ILLADR: reason = "illegal addressing mode"; break;          case ILL_ILLTRP: reason = "illegal trap"; break;          case ILL_PRVOPC: reason = "privileged opcode"; break;          case ILL_PRVREG: reason = "privileged register"; break;          case ILL_COPROC: reason = "co-processor error"; break;          case ILL_BADSTK: reason = "internal stack error"; break;        }        break;      case SIGFPE:        switch (si->si_code) {          case FPE_INTDIV: reason = "integer divide by zero"; break;          case FPE_INTOVF: reason = "integer overflow"; break;          case FPE_FLTDIV: reason = "floating point divide by zero"; break;          case FPE_FLTOVF: reason = "floating point overflow"; break;          case FPE_FLTUND: reason = "floating point underflow"; break;          case FPE_FLTRES: reason = "floating point inexact result"; break;          case FPE_FLTINV: reason = "invalid floating point operation"; break;          case FPE_FLTSUB: reason = "subscript out of range"; break;        }        break;      case SIGSEGV:        switch (si->si_code) {          case SEGV_MAPERR: reason = "address not mapped to object"; break;          case SEGV_ACCERR: reason = "invalid permissions for mapped object";                            break;        }        break;#ifdef SIGBUS      case SIGBUS:        switch (si->si_code) {          case BUS_ADRALN: reason = "invalid address alignment"; break;          case BUS_ADRERR: reason = "non-existent physical address"; break;        }        break;#endif    }  }  w_log(W_LOG_FATAL, "Terminating due to signal %d %s. %s (%p)/n",      signo, strsignal(signo), reason, si ? si->si_value.sival_ptr : NULL);}

static struct watchman_client *make_new_client(w_stm_t stm) {  struct watchman_client *client;  pthread_attr_t attr;  pthread_attr_init(&attr);  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);  client = calloc(1, derived_client_size);  if (!client) {    pthread_attr_destroy(&attr);    return NULL;  }  client->stm = stm;  w_log(W_LOG_DBG, "accepted client:stm=%p/n", client->stm);  if (!w_json_buffer_init(&client->reader)) {    // FIXME: error handling  }  if (!w_json_buffer_init(&client->writer)) {    // FIXME: error handling  }  client->ping = w_event_make();  if (!client->ping) {    // FIXME: error handling  }  derived_client_ctor(client);  pthread_mutex_lock(&w_client_lock);  w_ht_set(clients, w_ht_ptr_val(client), 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(&client->thread_handle, &attr, client_thread, client)) {    // It didn't work out, sorry!    pthread_mutex_lock(&w_client_lock);    w_ht_del(clients, w_ht_ptr_val(client));    pthread_mutex_unlock(&w_client_lock);    client_delete(client);  }  pthread_attr_destroy(&attr);  return client;}

static void accept_loop() {  while (!stopping) {    int client_fd;    struct pollfd pfd;    int bufsize;    w_stm_t stm;#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, 60000) < 1 || (pfd.revents & POLLIN) == 0) {      if (stopping) {        break;      }      // Timed out, or error.      // Arrange to sanity check that we're working      w_check_my_sock();      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,        (void*)&bufsize, sizeof(bufsize));    stm = w_stm_fdopen(client_fd);    if (!stm) {      w_log(W_LOG_ERR, "Failed to allocate stm for fd: %s/n",          strerror(errno));      close(client_fd);      continue;    }    make_new_client(stm);  }}

w_stm_t w_stm_connect_unix(const char *path, int timeoutms) {  w_stm_t stm;  struct sockaddr_un un;  int max_attempts = timeoutms / 10;  int attempts = 0;  int bufsize = WATCHMAN_IO_BUF_SIZE;  int fd;  if (strlen(path) >= sizeof(un.sun_path) - 1) {    w_log(W_LOG_ERR, "w_stm_connect_unix(%s) path is too long/n", path);    errno = E2BIG;    return NULL;  }  fd = socket(PF_LOCAL, SOCK_STREAM, 0);  if (fd == -1) {    return NULL;  }  memset(&un, 0, sizeof(un));  un.sun_family = PF_LOCAL;  strcpy(un.sun_path, path);retry_connect:  if (connect(fd, (struct sockaddr*)&un, sizeof(un))) {    int err = errno;    if (err == ECONNREFUSED || err == ENOENT) {      if (attempts++ < max_attempts) {        usleep(10000);        goto retry_connect;      }    }    close(fd);    return NULL;  }  setsockopt(fd, SOL_SOCKET, SO_RCVBUF,      (void*)&bufsize, sizeof(bufsize));  stm = w_stm_fdopen(fd);  if (!stm) {    close(fd);  }  return stm;}

void send_error_response(struct watchman_client *client,    const char *fmt, ...){  char buf[WATCHMAN_NAME_MAX];  va_list ap;  json_t *resp = make_response();  va_start(ap, fmt);  vsnprintf(buf, sizeof(buf), fmt, ap);  va_end(ap);  w_log(W_LOG_DBG, "send_error_response: fd=%d %s/n", client->fd, buf);  set_prop(resp, "error", json_string_nocheck(buf));  send_and_dispose_response(client, resp);}

static void cmd_shutdown(    struct watchman_client *client,    json_t *args){  json_t *resp = make_response();  unused_parameter(args);  w_log(W_LOG_ERR, "shutdown-server was requested, exiting!/n");  stopping = true;  // Knock listener thread out of poll/accept  pthread_kill(listener_thread, SIGUSR1);  set_prop(resp, "shutdown-server", json_true());  send_and_dispose_response(client, resp);}

static void parse_encoding(const char *enc, enum w_pdu_type *pdu){  if (!enc) {    return;  }  if (!strcmp(enc, "json")) {    *pdu = is_json_compact;    return;  }  if (!strcmp(enc, "bser")) {    *pdu = is_bser;    return;  }  w_log(W_LOG_ERR, "Invalid encoding '%s', use one of json or bser/n", enc);  exit(EX_USAGE);}

/* must be called with root and client locked */void w_run_subscription_rules(    struct watchman_client *client,    struct watchman_client_subscription *sub,    w_root_t *root){  json_t *response = build_subscription_results(sub, root);  if (!response) {    return;  }  if (!enqueue_response(client, response, true)) {    w_log(W_LOG_DBG, "failed to queue sub response/n");    json_decref(response);  }}

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);}

/** * This function expects the config to be an object containing the keys 'group' * and 'others', each a bool. */mode_t cfg_get_perms(const char* name, bool write_bits, bool execute_bits) {  auto val = cfg_get_json(name);  mode_t ret = S_IRUSR | S_IWUSR;  if (execute_bits) {    ret |= S_IXUSR;  }  if (val) {    if (!val.isObject()) {      w_log(W_LOG_FATAL, "Expected config value %s to be an object/n", name);    }    ret |= get_group_perm(name, val, write_bits, execute_bits);    ret |= get_others_perm(name, val, write_bits, execute_bits);  }  return ret;}

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;  }}

int main(int argc, char **argv){  bool ran;  json_t *cmd;  parse_cmdline(&argc, &argv);  if (foreground) {    run_service();    return 0;  }  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 {#ifdef USE_GIMLI      spawn_via_gimli();#elif defined(__APPLE__)      spawn_via_launchd();#else      daemonize();#endif      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!/n");  }  return 1;}

static void CALLBACK write_completed(DWORD err, DWORD bytes,    LPOVERLAPPED olap) {  // Reverse engineer our handle from the olap pointer  struct overlapped_op *op = (void*)olap;  struct win_handle *h = op->h;  struct write_buf *wbuf = op->wbuf;  stream_debug("WriteFileEx: completion callback invoked: bytes=%d %s/n",      (int)bytes, win32_strerror(err));  EnterCriticalSection(&h->mtx);  if (h->write_pending == op) {    h->write_pending = NULL;  }  if (err == 0) {    wbuf->cursor += bytes;    wbuf->len -= bytes;    if (wbuf->len == 0) {      // Consumed this buffer      free(wbuf);    } else {      w_log(W_LOG_FATAL, "WriteFileEx: short write: %d written, %d remain/n",          bytes, wbuf->len);    }  } else {    stream_debug("WriteFilex: completion: failed: %s/n",        win32_strerror(err));    h->errcode = err;    h->error_pending = true;    SetEvent(h->waitable);  }  // Send whatever else we have waiting to go  initiate_write(h);  LeaveCriticalSection(&h->mtx);  // Free the prior struct after possibly initiating another write  // to minimize the change of the same address being reused and  // confusing the completion status  free(op);}

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 struct watchman_dir_handle *inot_root_start_watch_dir(    watchman_global_watcher_t watcher,    w_root_t *root, struct watchman_dir *dir, struct timeval now,    const char *path) {  struct inot_root_state *state = root->watch;  struct watchman_dir_handle *osdir = NULL;  int newwd, err;  unused_parameter(watcher);  // Carry out our very strict opendir first to ensure that we're not  // traversing symlinks in the context of this root  osdir = w_dir_open(path);  if (!osdir) {    handle_open_errno(root, dir, now, "opendir", errno, NULL);    return NULL;  }  // The directory might be different since the last time we looked at it, so  // call inotify_add_watch unconditionally.  newwd = inotify_add_watch(state->infd, path, WATCHMAN_INOTIFY_MASK);  if (newwd == -1) {    err = errno;    if (errno == ENOSPC || errno == ENOMEM) {      // Limits exceeded, no recovery from our perspective      set_poison_state(root, dir->path, now, "inotify-add-watch", errno,          inot_strerror(errno));    } else {      handle_open_errno(root, dir, now, "inotify_add_watch", errno,          inot_strerror(errno));    }    w_dir_close(osdir);    errno = err;    return NULL;  }  // record mapping  pthread_mutex_lock(&state->lock);  w_ht_replace(state->wd_to_name, newwd, w_ht_ptr_val(dir->path));  pthread_mutex_unlock(&state->lock);  w_log(W_LOG_DBG, "adding %d -> %s mapping/n", newwd, path);  return osdir;}

static bool stream_pdu(w_jbuffer_t *jr, w_stm_t stm, json_error_t *jerr){  switch (jr->pdu_type) {    case is_json_compact:    case is_json_pretty:      return stream_until_newline(jr, stm);    case is_bser:      {        json_int_t len;        jr->rpos += 2;        if (!w_bser_decode_pdu_len(jr, stm, &len, jerr)) {          return false;        }        return stream_n_bytes(jr, stm, len, jerr);      }    default:      w_log(W_LOG_FATAL, "not streaming for pdu type %d/n", jr->pdu_type);      return false;  }}

int main(int argc, char **argv){  bool ran;  json_t *cmd;  parse_cmdline(&argc, &argv);  if (foreground) {    unlink(sock_name);    run_service();    return 0;  }  cmd = build_command(argc, argv);  ran = try_command(cmd, 0);  if (!ran && should_start(errno)) {    if (no_spawn) {      ran = try_client_mode_command(cmd, !no_pretty);    } else {      unlink(sock_name);#ifdef USE_GIMLI      spawn_via_gimli();#else      daemonize();#endif      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!/n");  }  return 1;}

static void client_delete(struct watchman_client *client){  struct watchman_client_response *resp;  w_log(W_LOG_DBG, "client_delete %p/n", client);  derived_client_dtor(client);  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_shutdown(client->stm);  w_stm_close(client->stm);  free(client);}

static bool subscription_generator(    w_query *query,    w_root_t *root,    struct w_query_ctx *ctx,    void *gendata,    int64_t *num_walked){  struct watchman_file *f;  struct watchman_client_subscription *sub = gendata;  int64_t n = 0;  bool result = true;  w_log(W_LOG_DBG, "running subscription %s %p/n",      sub->name->buf, sub);  // Walk back in time until we hit the boundary  for (f = root->latest_file; f; f = f->next) {    ++n;    if (ctx->since.is_timestamp && f->otime.timestamp < ctx->since.timestamp) {      break;    }    if (!ctx->since.is_timestamp &&        f->otime.ticks <= ctx->since.clock.ticks) {      break;    }    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;}

// This is the iterator callback we use to prune out obsoleted leaves.// We need to compare the prefix to make sure that we don't delete// a sibling node by mistake (see commentary on the is_path_prefix// function for more on that).int PendingCollectionBase::iterContext::operator()(    const w_string& key,    std::shared_ptr<watchman_pending_fs>& p) {  if (!p) {    // It was removed; update the tree to reflect this    coll.tree_.erase(key);    // Stop iteration: we deleted something and invalidated the iterators.    return 1;  }  if ((p->flags & W_PENDING_CRAWL_ONLY) == 0 && key.size() > root.size() &&      is_path_prefix(          (const char*)key.data(), key.size(), root.data(), root.size()) &&      !watchman::CookieSync::isPossiblyACookie(p->path)) {    w_log(        W_LOG_DBG,        "delete_kids: removing (%d) %.*s from pending because it is "        "obsoleted by (%d) %.*s/n",        int(p->path.size()),        int(p->path.size()),        p->path.data(),        int(root.size()),        int(root.size()),        root.data());    // Unlink the child from the pending index.    coll.unlinkItem(p);    // Remove it from the art tree.    coll.tree_.erase(key);    // Stop iteration because we just invalidated the iterator state    // by modifying the tree mid-iteration.    return 1;  }  return 0;}