4 #include "environment.h"
6 #include "parse-options.h"
7 #include "fsmonitor-ll.h"
8 #include "fsmonitor-ipc.h"
9 #include "fsmonitor-path-utils.h"
10 #include "fsmonitor-settings.h"
11 #include "compat/fsmonitor/fsm-health.h"
12 #include "compat/fsmonitor/fsm-listen.h"
13 #include "fsmonitor--daemon.h"
14 #include "simple-ipc.h"
20 static const char * const builtin_fsmonitor__daemon_usage
[] = {
21 N_("git fsmonitor--daemon start [<options>]"),
22 N_("git fsmonitor--daemon run [<options>]"),
23 "git fsmonitor--daemon stop",
24 "git fsmonitor--daemon status",
28 #ifdef HAVE_FSMONITOR_DAEMON_BACKEND
30 * Global state loaded from config.
32 #define FSMONITOR__IPC_THREADS "fsmonitor.ipcthreads"
33 static int fsmonitor__ipc_threads
= 8;
35 #define FSMONITOR__START_TIMEOUT "fsmonitor.starttimeout"
36 static int fsmonitor__start_timeout_sec
= 60;
38 #define FSMONITOR__ANNOUNCE_STARTUP "fsmonitor.announcestartup"
39 static int fsmonitor__announce_startup
= 0;
41 static int fsmonitor_config(const char *var
, const char *value
,
42 const struct config_context
*ctx
, void *cb
)
44 if (!strcmp(var
, FSMONITOR__IPC_THREADS
)) {
45 int i
= git_config_int(var
, value
, ctx
->kvi
);
47 return error(_("value of '%s' out of range: %d"),
48 FSMONITOR__IPC_THREADS
, i
);
49 fsmonitor__ipc_threads
= i
;
53 if (!strcmp(var
, FSMONITOR__START_TIMEOUT
)) {
54 int i
= git_config_int(var
, value
, ctx
->kvi
);
56 return error(_("value of '%s' out of range: %d"),
57 FSMONITOR__START_TIMEOUT
, i
);
58 fsmonitor__start_timeout_sec
= i
;
62 if (!strcmp(var
, FSMONITOR__ANNOUNCE_STARTUP
)) {
64 int i
= git_config_bool_or_int(var
, value
, ctx
->kvi
, &is_bool
);
66 return error(_("value of '%s' not bool or int: %d"),
68 fsmonitor__announce_startup
= i
;
72 return git_default_config(var
, value
, ctx
, cb
);
78 * Send a "quit" command to the `git-fsmonitor--daemon` (if running)
79 * and wait for it to shutdown.
81 static int do_as_client__send_stop(void)
83 struct strbuf answer
= STRBUF_INIT
;
86 ret
= fsmonitor_ipc__send_command("quit", &answer
);
88 /* The quit command does not return any response data. */
89 strbuf_release(&answer
);
94 trace2_region_enter("fsm_client", "polling-for-daemon-exit", NULL
);
95 while (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING
)
97 trace2_region_leave("fsm_client", "polling-for-daemon-exit", NULL
);
102 static int do_as_client__status(void)
104 enum ipc_active_state state
= fsmonitor_ipc__get_state();
107 case IPC_STATE__LISTENING
:
108 printf(_("fsmonitor-daemon is watching '%s'\n"),
109 the_repository
->worktree
);
113 printf(_("fsmonitor-daemon is not watching '%s'\n"),
114 the_repository
->worktree
);
119 enum fsmonitor_cookie_item_result
{
120 FCIR_ERROR
= -1, /* could not create cookie file ? */
126 struct fsmonitor_cookie_item
{
127 struct hashmap_entry entry
;
129 enum fsmonitor_cookie_item_result result
;
132 static int cookies_cmp(const void *data UNUSED
,
133 const struct hashmap_entry
*he1
,
134 const struct hashmap_entry
*he2
, const void *keydata
)
136 const struct fsmonitor_cookie_item
*a
=
137 container_of(he1
, const struct fsmonitor_cookie_item
, entry
);
138 const struct fsmonitor_cookie_item
*b
=
139 container_of(he2
, const struct fsmonitor_cookie_item
, entry
);
141 return strcmp(a
->name
, keydata
? keydata
: b
->name
);
144 static enum fsmonitor_cookie_item_result
with_lock__wait_for_cookie(
145 struct fsmonitor_daemon_state
*state
)
147 /* assert current thread holding state->main_lock */
150 struct fsmonitor_cookie_item
*cookie
;
151 struct strbuf cookie_pathname
= STRBUF_INIT
;
152 struct strbuf cookie_filename
= STRBUF_INIT
;
153 enum fsmonitor_cookie_item_result result
;
156 CALLOC_ARRAY(cookie
, 1);
158 my_cookie_seq
= state
->cookie_seq
++;
160 strbuf_addf(&cookie_filename
, "%i-%i", getpid(), my_cookie_seq
);
162 strbuf_addbuf(&cookie_pathname
, &state
->path_cookie_prefix
);
163 strbuf_addbuf(&cookie_pathname
, &cookie_filename
);
165 cookie
->name
= strbuf_detach(&cookie_filename
, NULL
);
166 cookie
->result
= FCIR_INIT
;
167 hashmap_entry_init(&cookie
->entry
, strhash(cookie
->name
));
169 hashmap_add(&state
->cookies
, &cookie
->entry
);
171 trace_printf_key(&trace_fsmonitor
, "cookie-wait: '%s' '%s'",
172 cookie
->name
, cookie_pathname
.buf
);
175 * Create the cookie file on disk and then wait for a notification
176 * that the listener thread has seen it.
178 fd
= open(cookie_pathname
.buf
, O_WRONLY
| O_CREAT
| O_EXCL
, 0600);
180 error_errno(_("could not create fsmonitor cookie '%s'"),
183 cookie
->result
= FCIR_ERROR
;
188 * Technically, close() and unlink() can fail, but we don't
189 * care here. We only created the file to trigger a watch
190 * event from the FS to know that when we're up to date.
193 unlink(cookie_pathname
.buf
);
196 * Technically, this is an infinite wait (well, unless another
197 * thread sends us an abort). I'd like to change this to
198 * use `pthread_cond_timedwait()` and return an error/timeout
199 * and let the caller do the trivial response thing, but we
200 * don't have that routine in our thread-utils.
202 * After extensive beta testing I'm not really worried about
203 * this. Also note that the above open() and unlink() calls
204 * will cause at least two FS events on that path, so the odds
205 * of getting stuck are pretty slim.
207 while (cookie
->result
== FCIR_INIT
)
208 pthread_cond_wait(&state
->cookies_cond
,
212 hashmap_remove(&state
->cookies
, &cookie
->entry
, NULL
);
214 result
= cookie
->result
;
218 strbuf_release(&cookie_pathname
);
224 * Mark these cookies as _SEEN and wake up the corresponding client threads.
226 static void with_lock__mark_cookies_seen(struct fsmonitor_daemon_state
*state
,
227 const struct string_list
*cookie_names
)
229 /* assert current thread holding state->main_lock */
234 for (k
= 0; k
< cookie_names
->nr
; k
++) {
235 struct fsmonitor_cookie_item key
;
236 struct fsmonitor_cookie_item
*cookie
;
238 key
.name
= cookie_names
->items
[k
].string
;
239 hashmap_entry_init(&key
.entry
, strhash(key
.name
));
241 cookie
= hashmap_get_entry(&state
->cookies
, &key
, entry
, NULL
);
243 trace_printf_key(&trace_fsmonitor
, "cookie-seen: '%s'",
245 cookie
->result
= FCIR_SEEN
;
251 pthread_cond_broadcast(&state
->cookies_cond
);
255 * Set _ABORT on all pending cookies and wake up all client threads.
257 static void with_lock__abort_all_cookies(struct fsmonitor_daemon_state
*state
)
259 /* assert current thread holding state->main_lock */
261 struct hashmap_iter iter
;
262 struct fsmonitor_cookie_item
*cookie
;
265 hashmap_for_each_entry(&state
->cookies
, &iter
, cookie
, entry
) {
266 trace_printf_key(&trace_fsmonitor
, "cookie-abort: '%s'",
268 cookie
->result
= FCIR_ABORT
;
273 pthread_cond_broadcast(&state
->cookies_cond
);
277 * Requests to and from a FSMonitor Protocol V2 provider use an opaque
278 * "token" as a virtual timestamp. Clients can request a summary of all
279 * created/deleted/modified files relative to a token. In the response,
280 * clients receive a new token for the next (relative) request.
286 * The contents of the token are private and provider-specific.
288 * For the built-in fsmonitor--daemon, we define a token as follows:
290 * "builtin" ":" <token_id> ":" <sequence_nr>
292 * The "builtin" prefix is used as a namespace to avoid conflicts
293 * with other providers (such as Watchman).
295 * The <token_id> is an arbitrary OPAQUE string, such as a GUID,
296 * UUID, or {timestamp,pid}. It is used to group all filesystem
297 * events that happened while the daemon was monitoring (and in-sync
298 * with the filesystem).
300 * Unlike FSMonitor Protocol V1, it is not defined as a timestamp
301 * and does not define less-than/greater-than relationships.
302 * (There are too many race conditions to rely on file system
305 * The <sequence_nr> is a simple integer incremented whenever the
306 * daemon needs to make its state public. For example, if 1000 file
307 * system events come in, but no clients have requested the data,
308 * the daemon can continue to accumulate file changes in the same
309 * bin and does not need to advance the sequence number. However,
310 * as soon as a client does arrive, the daemon needs to start a new
311 * bin and increment the sequence number.
313 * The sequence number serves as the boundary between 2 sets
314 * of bins -- the older ones that the client has already seen
315 * and the newer ones that it hasn't.
317 * When a new <token_id> is created, the <sequence_nr> is reset to
324 * A new token_id is created:
326 * [1] each time the daemon is started.
328 * [2] any time that the daemon must re-sync with the filesystem
329 * (such as when the kernel drops or we miss events on a very
332 * [3] in response to a client "flush" command (for dropped event
335 * When a new token_id is created, the daemon is free to discard all
336 * cached filesystem events associated with any previous token_ids.
337 * Events associated with a non-current token_id will never be sent
338 * to a client. A token_id change implicitly means that the daemon
339 * has gap in its event history.
341 * Therefore, clients that present a token with a stale (non-current)
342 * token_id will always be given a trivial response.
344 struct fsmonitor_token_data
{
345 struct strbuf token_id
;
346 struct fsmonitor_batch
*batch_head
;
347 struct fsmonitor_batch
*batch_tail
;
348 uint64_t client_ref_count
;
351 struct fsmonitor_batch
{
352 struct fsmonitor_batch
*next
;
353 uint64_t batch_seq_nr
;
354 const char **interned_paths
;
359 static struct fsmonitor_token_data
*fsmonitor_new_token_data(void)
361 static int test_env_value
= -1;
362 static uint64_t flush_count
= 0;
363 struct fsmonitor_token_data
*token
;
364 struct fsmonitor_batch
*batch
;
366 CALLOC_ARRAY(token
, 1);
367 batch
= fsmonitor_batch__new();
369 strbuf_init(&token
->token_id
, 0);
370 token
->batch_head
= batch
;
371 token
->batch_tail
= batch
;
372 token
->client_ref_count
= 0;
374 if (test_env_value
< 0)
375 test_env_value
= git_env_bool("GIT_TEST_FSMONITOR_TOKEN", 0);
377 if (!test_env_value
) {
382 gettimeofday(&tv
, NULL
);
384 gmtime_r(&secs
, &tm
);
386 strbuf_addf(&token
->token_id
,
387 "%"PRIu64
".%d.%4d%02d%02dT%02d%02d%02d.%06ldZ",
390 tm
.tm_year
+ 1900, tm
.tm_mon
+ 1, tm
.tm_mday
,
391 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
,
394 strbuf_addf(&token
->token_id
, "test_%08x", test_env_value
++);
398 * We created a new <token_id> and are starting a new series
399 * of tokens with a zero <seq_nr>.
401 * Since clients cannot guess our new (non test) <token_id>
402 * they will always receive a trivial response (because of the
403 * mismatch on the <token_id>). The trivial response will
404 * tell them our new <token_id> so that subsequent requests
405 * will be relative to our new series. (And when sending that
406 * response, we pin the current head of the batch list.)
408 * Even if the client correctly guesses the <token_id>, their
409 * request of "builtin:<token_id>:0" asks for all changes MORE
410 * RECENT than batch/bin 0.
412 * This implies that it is a waste to accumulate paths in the
413 * initial batch/bin (because they will never be transmitted).
415 * So the daemon could be running for days and watching the
416 * file system, but doesn't need to actually accumulate any
417 * paths UNTIL we need to set a reference point for a later
420 * However, it is very useful for testing to always have a
421 * reference point set. Pin batch 0 to force early file system
422 * events to accumulate.
425 batch
->pinned_time
= time(NULL
);
430 struct fsmonitor_batch
*fsmonitor_batch__new(void)
432 struct fsmonitor_batch
*batch
;
434 CALLOC_ARRAY(batch
, 1);
439 void fsmonitor_batch__free_list(struct fsmonitor_batch
*batch
)
442 struct fsmonitor_batch
*next
= batch
->next
;
445 * The actual strings within the array of this batch
446 * are interned, so we don't own them. We only own
449 free(batch
->interned_paths
);
456 void fsmonitor_batch__add_path(struct fsmonitor_batch
*batch
,
459 const char *interned_path
= strintern(path
);
461 trace_printf_key(&trace_fsmonitor
, "event: %s", interned_path
);
463 ALLOC_GROW(batch
->interned_paths
, batch
->nr
+ 1, batch
->alloc
);
464 batch
->interned_paths
[batch
->nr
++] = interned_path
;
467 static void fsmonitor_batch__combine(struct fsmonitor_batch
*batch_dest
,
468 const struct fsmonitor_batch
*batch_src
)
472 ALLOC_GROW(batch_dest
->interned_paths
,
473 batch_dest
->nr
+ batch_src
->nr
+ 1,
476 for (k
= 0; k
< batch_src
->nr
; k
++)
477 batch_dest
->interned_paths
[batch_dest
->nr
++] =
478 batch_src
->interned_paths
[k
];
482 * To keep the batch list from growing unbounded in response to filesystem
483 * activity, we try to truncate old batches from the end of the list as
484 * they become irrelevant.
486 * We assume that the .git/index will be updated with the most recent token
487 * any time the index is updated. And future commands will only ask for
488 * recent changes *since* that new token. So as tokens advance into the
489 * future, older batch items will never be requested/needed. So we can
490 * truncate them without loss of functionality.
492 * However, multiple commands may be talking to the daemon concurrently
493 * or perform a slow command, so a little "token skew" is possible.
494 * Therefore, we want this to be a little bit lazy and have a generous
497 * The current reader thread walked backwards in time from `token->batch_head`
498 * back to `batch_marker` somewhere in the middle of the batch list.
500 * Let's walk backwards in time from that marker an arbitrary delay
501 * and truncate the list there. Note that these timestamps are completely
502 * artificial (based on when we pinned the batch item) and not on any
503 * filesystem activity.
505 * Return the obsolete portion of the list after we have removed it from
506 * the official list so that the caller can free it after leaving the lock.
508 #define MY_TIME_DELAY_SECONDS (5 * 60) /* seconds */
510 static struct fsmonitor_batch
*with_lock__truncate_old_batches(
511 struct fsmonitor_daemon_state
*state
,
512 const struct fsmonitor_batch
*batch_marker
)
514 /* assert current thread holding state->main_lock */
516 const struct fsmonitor_batch
*batch
;
517 struct fsmonitor_batch
*remainder
;
522 trace_printf_key(&trace_fsmonitor
, "Truncate: mark (%"PRIu64
",%"PRIu64
")",
523 batch_marker
->batch_seq_nr
,
524 (uint64_t)batch_marker
->pinned_time
);
526 for (batch
= batch_marker
; batch
; batch
= batch
->next
) {
529 if (!batch
->pinned_time
) /* an overflow batch */
532 t
= batch
->pinned_time
+ MY_TIME_DELAY_SECONDS
;
533 if (t
> batch_marker
->pinned_time
) /* too close to marker */
536 goto truncate_past_here
;
542 state
->current_token_data
->batch_tail
= (struct fsmonitor_batch
*)batch
;
544 remainder
= ((struct fsmonitor_batch
*)batch
)->next
;
545 ((struct fsmonitor_batch
*)batch
)->next
= NULL
;
550 static void fsmonitor_free_token_data(struct fsmonitor_token_data
*token
)
555 assert(token
->client_ref_count
== 0);
557 strbuf_release(&token
->token_id
);
559 fsmonitor_batch__free_list(token
->batch_head
);
565 * Flush all of our cached data about the filesystem. Call this if we
566 * lose sync with the filesystem and miss some notification events.
568 * [1] If we are missing events, then we no longer have a complete
569 * history of the directory (relative to our current start token).
570 * We should create a new token and start fresh (as if we just
573 * [2] Some of those lost events may have been for cookie files. We
574 * should assume the worst and abort them rather letting them starve.
576 * If there are no concurrent threads reading the current token data
577 * series, we can free it now. Otherwise, let the last reader free
580 * Either way, the old token data series is no longer associated with
583 static void with_lock__do_force_resync(struct fsmonitor_daemon_state
*state
)
585 /* assert current thread holding state->main_lock */
587 struct fsmonitor_token_data
*free_me
= NULL
;
588 struct fsmonitor_token_data
*new_one
= NULL
;
590 new_one
= fsmonitor_new_token_data();
592 if (state
->current_token_data
->client_ref_count
== 0)
593 free_me
= state
->current_token_data
;
594 state
->current_token_data
= new_one
;
596 fsmonitor_free_token_data(free_me
);
598 with_lock__abort_all_cookies(state
);
601 void fsmonitor_force_resync(struct fsmonitor_daemon_state
*state
)
603 pthread_mutex_lock(&state
->main_lock
);
604 with_lock__do_force_resync(state
);
605 pthread_mutex_unlock(&state
->main_lock
);
609 * Format an opaque token string to send to the client.
611 static void with_lock__format_response_token(
612 struct strbuf
*response_token
,
613 const struct strbuf
*response_token_id
,
614 const struct fsmonitor_batch
*batch
)
616 /* assert current thread holding state->main_lock */
618 strbuf_reset(response_token
);
619 strbuf_addf(response_token
, "builtin:%s:%"PRIu64
,
620 response_token_id
->buf
, batch
->batch_seq_nr
);
624 * Parse an opaque token from the client.
625 * Returns -1 on error.
627 static int fsmonitor_parse_client_token(const char *buf_token
,
628 struct strbuf
*requested_token_id
,
634 strbuf_reset(requested_token_id
);
637 if (!skip_prefix(buf_token
, "builtin:", &p
))
640 while (*p
&& *p
!= ':')
641 strbuf_addch(requested_token_id
, *p
++);
645 *seq_nr
= (uint64_t)strtoumax(p
, &p_end
, 10);
652 KHASH_INIT(str
, const char *, int, 0, kh_str_hash_func
, kh_str_hash_equal
)
654 static int do_handle_client(struct fsmonitor_daemon_state
*state
,
656 ipc_server_reply_cb
*reply
,
657 struct ipc_server_reply_data
*reply_data
)
659 struct fsmonitor_token_data
*token_data
= NULL
;
660 struct strbuf response_token
= STRBUF_INIT
;
661 struct strbuf requested_token_id
= STRBUF_INIT
;
662 struct strbuf payload
= STRBUF_INIT
;
663 uint64_t requested_oldest_seq_nr
= 0;
664 uint64_t total_response_len
= 0;
666 const struct fsmonitor_batch
*batch_head
;
667 const struct fsmonitor_batch
*batch
;
668 struct fsmonitor_batch
*remainder
= NULL
;
669 intmax_t count
= 0, duplicates
= 0;
675 enum fsmonitor_cookie_item_result cookie_result
;
678 * We expect `command` to be of the form:
680 * <command> := quit NUL
682 * | <V1-time-since-epoch-ns> NUL
683 * | <V2-opaque-fsmonitor-token> NUL
686 if (!strcmp(command
, "quit")) {
688 * A client has requested over the socket/pipe that the
691 * Tell the IPC thread pool to shutdown (which completes
692 * the await in the main thread (which can stop the
693 * fsmonitor listener thread)).
695 * There is no reply to the client.
697 return SIMPLE_IPC_QUIT
;
699 } else if (!strcmp(command
, "flush")) {
701 * Flush all of our cached data and generate a new token
702 * just like if we lost sync with the filesystem.
704 * Then send a trivial response using the new token.
709 } else if (!skip_prefix(command
, "builtin:", &p
)) {
710 /* assume V1 timestamp or garbage */
714 strtoumax(command
, &p_end
, 10);
715 trace_printf_key(&trace_fsmonitor
,
717 "fsmonitor: invalid command line '%s'" :
718 "fsmonitor: unsupported V1 protocol '%s'"),
724 /* We have "builtin:*" */
725 if (fsmonitor_parse_client_token(command
, &requested_token_id
,
726 &requested_oldest_seq_nr
)) {
727 trace_printf_key(&trace_fsmonitor
,
728 "fsmonitor: invalid V2 protocol token '%s'",
735 * We have a V2 valid token:
736 * "builtin:<token_id>:<seq_nr>"
742 pthread_mutex_lock(&state
->main_lock
);
744 if (!state
->current_token_data
)
745 BUG("fsmonitor state does not have a current token");
748 * Write a cookie file inside the directory being watched in
749 * an effort to flush out existing filesystem events that we
750 * actually care about. Suspend this client thread until we
751 * see the filesystem events for this cookie file.
753 * Creating the cookie lets us guarantee that our FS listener
754 * thread has drained the kernel queue and we are caught up
757 * If we cannot create the cookie (or otherwise guarantee that
758 * we are caught up), we send a trivial response. We have to
759 * assume that there might be some very, very recent activity
760 * on the FS still in flight.
763 cookie_result
= with_lock__wait_for_cookie(state
);
764 if (cookie_result
!= FCIR_SEEN
) {
765 error(_("fsmonitor: cookie_result '%d' != SEEN"),
772 with_lock__do_force_resync(state
);
775 * We mark the current head of the batch list as "pinned" so
776 * that the listener thread will treat this item as read-only
777 * (and prevent any more paths from being added to it) from
780 token_data
= state
->current_token_data
;
781 batch_head
= token_data
->batch_head
;
782 ((struct fsmonitor_batch
*)batch_head
)->pinned_time
= time(NULL
);
785 * FSMonitor Protocol V2 requires that we send a response header
786 * with a "new current token" and then all of the paths that changed
787 * since the "requested token". We send the seq_nr of the just-pinned
788 * head batch so that future requests from a client will be relative
791 with_lock__format_response_token(&response_token
,
792 &token_data
->token_id
, batch_head
);
794 reply(reply_data
, response_token
.buf
, response_token
.len
+ 1);
795 total_response_len
+= response_token
.len
+ 1;
797 trace2_data_string("fsmonitor", the_repository
, "response/token",
799 trace_printf_key(&trace_fsmonitor
, "response token: %s",
803 if (strcmp(requested_token_id
.buf
, token_data
->token_id
.buf
)) {
805 * The client last spoke to a different daemon
806 * instance -OR- the daemon had to resync with
807 * the filesystem (and lost events), so reject.
809 trace2_data_string("fsmonitor", the_repository
,
810 "response/token", "different");
813 } else if (requested_oldest_seq_nr
<
814 token_data
->batch_tail
->batch_seq_nr
) {
816 * The client wants older events than we have for
817 * this token_id. This means that the end of our
818 * batch list was truncated and we cannot give the
819 * client a complete snapshot relative to their
822 trace_printf_key(&trace_fsmonitor
,
823 "client requested truncated data");
829 pthread_mutex_unlock(&state
->main_lock
);
831 reply(reply_data
, "/", 2);
833 trace2_data_intmax("fsmonitor", the_repository
,
834 "response/trivial", 1);
840 * We're going to hold onto a pointer to the current
841 * token-data while we walk the list of batches of files.
842 * During this time, we will NOT be under the lock.
843 * So we ref-count it.
845 * This allows the listener thread to continue prepending
846 * new batches of items to the token-data (which we'll ignore).
848 * AND it allows the listener thread to do a token-reset
849 * (and install a new `current_token_data`).
851 token_data
->client_ref_count
++;
853 pthread_mutex_unlock(&state
->main_lock
);
856 * The client request is relative to the token that they sent,
857 * so walk the batch list backwards from the current head back
858 * to the batch (sequence number) they named.
860 * We use khash to de-dup the list of pathnames.
862 * NEEDSWORK: each batch contains a list of interned strings,
863 * so we only need to do pointer comparisons here to build the
864 * hash table. Currently, we're still comparing the string
867 shown
= kh_init_str();
868 for (batch
= batch_head
;
869 batch
&& batch
->batch_seq_nr
> requested_oldest_seq_nr
;
870 batch
= batch
->next
) {
873 for (k
= 0; k
< batch
->nr
; k
++) {
874 const char *s
= batch
->interned_paths
[k
];
877 if (kh_get_str(shown
, s
) != kh_end(shown
))
880 kh_put_str(shown
, s
, &hash_ret
);
882 trace_printf_key(&trace_fsmonitor
,
883 "send[%"PRIuMAX
"]: %s",
886 /* Each path gets written with a trailing NUL */
887 s_len
= strlen(s
) + 1;
889 if (payload
.len
+ s_len
>=
890 LARGE_PACKET_DATA_MAX
) {
891 reply(reply_data
, payload
.buf
,
893 total_response_len
+= payload
.len
;
894 strbuf_reset(&payload
);
897 strbuf_add(&payload
, s
, s_len
);
904 reply(reply_data
, payload
.buf
, payload
.len
);
905 total_response_len
+= payload
.len
;
908 kh_release_str(shown
);
910 pthread_mutex_lock(&state
->main_lock
);
912 if (token_data
->client_ref_count
> 0)
913 token_data
->client_ref_count
--;
915 if (token_data
->client_ref_count
== 0) {
916 if (token_data
!= state
->current_token_data
) {
918 * The listener thread did a token-reset while we were
919 * walking the batch list. Therefore, this token is
920 * stale and can be discarded completely. If we are
921 * the last reader thread using this token, we own
924 fsmonitor_free_token_data(token_data
);
927 * We are holding the lock and are the only
928 * reader of the ref-counted portion of the
929 * list, so we get the honor of seeing if the
930 * list can be truncated to save memory.
932 * The main loop did not walk to the end of the
933 * list, so this batch is the first item in the
934 * batch-list that is older than the requested
935 * end-point sequence number. See if the tail
936 * end of the list is obsolete.
938 remainder
= with_lock__truncate_old_batches(state
,
943 pthread_mutex_unlock(&state
->main_lock
);
946 fsmonitor_batch__free_list(remainder
);
948 trace2_data_intmax("fsmonitor", the_repository
, "response/length", total_response_len
);
949 trace2_data_intmax("fsmonitor", the_repository
, "response/count/files", count
);
950 trace2_data_intmax("fsmonitor", the_repository
, "response/count/duplicates", duplicates
);
953 strbuf_release(&response_token
);
954 strbuf_release(&requested_token_id
);
955 strbuf_release(&payload
);
960 static ipc_server_application_cb handle_client
;
962 static int handle_client(void *data
,
963 const char *command
, size_t command_len
,
964 ipc_server_reply_cb
*reply
,
965 struct ipc_server_reply_data
*reply_data
)
967 struct fsmonitor_daemon_state
*state
= data
;
971 * The Simple IPC API now supports {char*, len} arguments, but
972 * FSMonitor always uses proper null-terminated strings, so
973 * we can ignore the command_len argument. (Trust, but verify.)
975 if (command_len
!= strlen(command
))
976 BUG("FSMonitor assumes text messages");
978 trace_printf_key(&trace_fsmonitor
, "requested token: %s", command
);
980 trace2_region_enter("fsmonitor", "handle_client", the_repository
);
981 trace2_data_string("fsmonitor", the_repository
, "request", command
);
983 result
= do_handle_client(state
, command
, reply
, reply_data
);
985 trace2_region_leave("fsmonitor", "handle_client", the_repository
);
990 #define FSMONITOR_DIR "fsmonitor--daemon"
991 #define FSMONITOR_COOKIE_DIR "cookies"
992 #define FSMONITOR_COOKIE_PREFIX (FSMONITOR_DIR "/" FSMONITOR_COOKIE_DIR "/")
994 enum fsmonitor_path_type
fsmonitor_classify_path_workdir_relative(
997 if (fspathncmp(rel
, ".git", 4))
998 return IS_WORKDIR_PATH
;
1004 return IS_WORKDIR_PATH
; /* e.g. .gitignore */
1007 if (!fspathncmp(rel
, FSMONITOR_COOKIE_PREFIX
,
1008 strlen(FSMONITOR_COOKIE_PREFIX
)))
1009 return IS_INSIDE_DOT_GIT_WITH_COOKIE_PREFIX
;
1011 return IS_INSIDE_DOT_GIT
;
1014 enum fsmonitor_path_type
fsmonitor_classify_path_gitdir_relative(
1017 if (!fspathncmp(rel
, FSMONITOR_COOKIE_PREFIX
,
1018 strlen(FSMONITOR_COOKIE_PREFIX
)))
1019 return IS_INSIDE_GITDIR_WITH_COOKIE_PREFIX
;
1021 return IS_INSIDE_GITDIR
;
1024 static enum fsmonitor_path_type
try_classify_workdir_abs_path(
1025 struct fsmonitor_daemon_state
*state
,
1030 if (fspathncmp(path
, state
->path_worktree_watch
.buf
,
1031 state
->path_worktree_watch
.len
))
1032 return IS_OUTSIDE_CONE
;
1034 rel
= path
+ state
->path_worktree_watch
.len
;
1037 return IS_WORKDIR_PATH
; /* it is the root dir exactly */
1039 return IS_OUTSIDE_CONE
;
1042 return fsmonitor_classify_path_workdir_relative(rel
);
1045 enum fsmonitor_path_type
fsmonitor_classify_path_absolute(
1046 struct fsmonitor_daemon_state
*state
,
1050 enum fsmonitor_path_type t
;
1052 t
= try_classify_workdir_abs_path(state
, path
);
1053 if (state
->nr_paths_watching
== 1)
1055 if (t
!= IS_OUTSIDE_CONE
)
1058 if (fspathncmp(path
, state
->path_gitdir_watch
.buf
,
1059 state
->path_gitdir_watch
.len
))
1060 return IS_OUTSIDE_CONE
;
1062 rel
= path
+ state
->path_gitdir_watch
.len
;
1065 return IS_GITDIR
; /* it is the <gitdir> exactly */
1067 return IS_OUTSIDE_CONE
;
1070 return fsmonitor_classify_path_gitdir_relative(rel
);
1074 * We try to combine small batches at the front of the batch-list to avoid
1075 * having a long list. This hopefully makes it a little easier when we want
1076 * to truncate and maintain the list. However, we don't want the paths array
1077 * to just keep growing and growing with realloc, so we insert an arbitrary
1080 #define MY_COMBINE_LIMIT (1024)
1082 void fsmonitor_publish(struct fsmonitor_daemon_state
*state
,
1083 struct fsmonitor_batch
*batch
,
1084 const struct string_list
*cookie_names
)
1086 if (!batch
&& !cookie_names
->nr
)
1089 pthread_mutex_lock(&state
->main_lock
);
1092 struct fsmonitor_batch
*head
;
1094 head
= state
->current_token_data
->batch_head
;
1096 BUG("token does not have batch");
1097 } else if (head
->pinned_time
) {
1099 * We cannot alter the current batch list
1102 * [a] it is being transmitted to at least one
1103 * client and the handle_client() thread has a
1104 * ref-count, but not a lock on the batch list
1105 * starting with this item.
1107 * [b] it has been transmitted in the past to
1108 * at least one client such that future
1109 * requests are relative to this head batch.
1111 * So, we can only prepend a new batch onto
1112 * the front of the list.
1114 batch
->batch_seq_nr
= head
->batch_seq_nr
+ 1;
1116 state
->current_token_data
->batch_head
= batch
;
1117 } else if (!head
->batch_seq_nr
) {
1119 * Batch 0 is unpinned. See the note in
1120 * `fsmonitor_new_token_data()` about why we
1121 * don't need to accumulate these paths.
1123 fsmonitor_batch__free_list(batch
);
1124 } else if (head
->nr
+ batch
->nr
> MY_COMBINE_LIMIT
) {
1126 * The head batch in the list has never been
1127 * transmitted to a client, but folding the
1128 * contents of the new batch onto it would
1129 * exceed our arbitrary limit, so just prepend
1130 * the new batch onto the list.
1132 batch
->batch_seq_nr
= head
->batch_seq_nr
+ 1;
1134 state
->current_token_data
->batch_head
= batch
;
1137 * We are free to add the paths in the given
1138 * batch onto the end of the current head batch.
1140 fsmonitor_batch__combine(head
, batch
);
1141 fsmonitor_batch__free_list(batch
);
1145 if (cookie_names
->nr
)
1146 with_lock__mark_cookies_seen(state
, cookie_names
);
1148 pthread_mutex_unlock(&state
->main_lock
);
1151 static void *fsm_health__thread_proc(void *_state
)
1153 struct fsmonitor_daemon_state
*state
= _state
;
1155 trace2_thread_start("fsm-health");
1157 fsm_health__loop(state
);
1159 trace2_thread_exit();
1163 static void *fsm_listen__thread_proc(void *_state
)
1165 struct fsmonitor_daemon_state
*state
= _state
;
1167 trace2_thread_start("fsm-listen");
1169 trace_printf_key(&trace_fsmonitor
, "Watching: worktree '%s'",
1170 state
->path_worktree_watch
.buf
);
1171 if (state
->nr_paths_watching
> 1)
1172 trace_printf_key(&trace_fsmonitor
, "Watching: gitdir '%s'",
1173 state
->path_gitdir_watch
.buf
);
1175 fsm_listen__loop(state
);
1177 pthread_mutex_lock(&state
->main_lock
);
1178 if (state
->current_token_data
&&
1179 state
->current_token_data
->client_ref_count
== 0)
1180 fsmonitor_free_token_data(state
->current_token_data
);
1181 state
->current_token_data
= NULL
;
1182 pthread_mutex_unlock(&state
->main_lock
);
1184 trace2_thread_exit();
1188 static int fsmonitor_run_daemon_1(struct fsmonitor_daemon_state
*state
)
1190 struct ipc_server_opts ipc_opts
= {
1191 .nr_threads
= fsmonitor__ipc_threads
,
1194 * We know that there are no other active threads yet,
1195 * so we can let the IPC layer temporarily chdir() if
1196 * it needs to when creating the server side of the
1197 * Unix domain socket.
1199 .uds_disallow_chdir
= 0
1201 int health_started
= 0;
1202 int listener_started
= 0;
1206 * Start the IPC thread pool before the we've started the file
1207 * system event listener thread so that we have the IPC handle
1208 * before we need it.
1210 if (ipc_server_run_async(&state
->ipc_server_data
,
1211 state
->path_ipc
.buf
, &ipc_opts
,
1212 handle_client
, state
))
1214 _("could not start IPC thread pool on '%s'"),
1215 state
->path_ipc
.buf
);
1218 * Start the fsmonitor listener thread to collect filesystem
1221 if (pthread_create(&state
->listener_thread
, NULL
,
1222 fsm_listen__thread_proc
, state
)) {
1223 ipc_server_stop_async(state
->ipc_server_data
);
1224 err
= error(_("could not start fsmonitor listener thread"));
1227 listener_started
= 1;
1230 * Start the health thread to watch over our process.
1232 if (pthread_create(&state
->health_thread
, NULL
,
1233 fsm_health__thread_proc
, state
)) {
1234 ipc_server_stop_async(state
->ipc_server_data
);
1235 err
= error(_("could not start fsmonitor health thread"));
1241 * The daemon is now fully functional in background threads.
1242 * Our primary thread should now just wait while the threads
1247 * Wait for the IPC thread pool to shutdown (whether by client
1248 * request, from filesystem activity, or an error).
1250 ipc_server_await(state
->ipc_server_data
);
1253 * The fsmonitor listener thread may have received a shutdown
1254 * event from the IPC thread pool, but it doesn't hurt to tell
1255 * it again. And wait for it to shutdown.
1257 if (listener_started
) {
1258 fsm_listen__stop_async(state
);
1259 pthread_join(state
->listener_thread
, NULL
);
1262 if (health_started
) {
1263 fsm_health__stop_async(state
);
1264 pthread_join(state
->health_thread
, NULL
);
1269 if (state
->listen_error_code
)
1270 return state
->listen_error_code
;
1271 if (state
->health_error_code
)
1272 return state
->health_error_code
;
1276 static int fsmonitor_run_daemon(void)
1278 struct fsmonitor_daemon_state state
;
1282 memset(&state
, 0, sizeof(state
));
1284 hashmap_init(&state
.cookies
, cookies_cmp
, NULL
, 0);
1285 pthread_mutex_init(&state
.main_lock
, NULL
);
1286 pthread_cond_init(&state
.cookies_cond
, NULL
);
1287 state
.listen_error_code
= 0;
1288 state
.health_error_code
= 0;
1289 state
.current_token_data
= fsmonitor_new_token_data();
1291 /* Prepare to (recursively) watch the <worktree-root> directory. */
1292 strbuf_init(&state
.path_worktree_watch
, 0);
1293 strbuf_addstr(&state
.path_worktree_watch
, absolute_path(get_git_work_tree()));
1294 state
.nr_paths_watching
= 1;
1296 strbuf_init(&state
.alias
.alias
, 0);
1297 strbuf_init(&state
.alias
.points_to
, 0);
1298 if ((err
= fsmonitor__get_alias(state
.path_worktree_watch
.buf
, &state
.alias
)))
1302 * We create and delete cookie files somewhere inside the .git
1303 * directory to help us keep sync with the file system. If
1304 * ".git" is not a directory, then <gitdir> is not inside the
1305 * cone of <worktree-root>, so set up a second watch to watch
1306 * the <gitdir> so that we get events for the cookie files.
1308 strbuf_init(&state
.path_gitdir_watch
, 0);
1309 strbuf_addbuf(&state
.path_gitdir_watch
, &state
.path_worktree_watch
);
1310 strbuf_addstr(&state
.path_gitdir_watch
, "/.git");
1311 if (!is_directory(state
.path_gitdir_watch
.buf
)) {
1312 strbuf_reset(&state
.path_gitdir_watch
);
1313 strbuf_addstr(&state
.path_gitdir_watch
, absolute_path(get_git_dir()));
1314 state
.nr_paths_watching
= 2;
1318 * We will write filesystem syncing cookie files into
1319 * <gitdir>/<fsmonitor-dir>/<cookie-dir>/<pid>-<seq>.
1321 * The extra layers of subdirectories here keep us from
1322 * changing the mtime on ".git/" or ".git/foo/" when we create
1323 * or delete cookie files.
1325 * There have been problems with some IDEs that do a
1326 * non-recursive watch of the ".git/" directory and run a
1327 * series of commands any time something happens.
1329 * For example, if we place our cookie files directly in
1330 * ".git/" or ".git/foo/" then a `git status` (or similar
1331 * command) from the IDE will cause a cookie file to be
1332 * created in one of those dirs. This causes the mtime of
1333 * those dirs to change. This triggers the IDE's watch
1334 * notification. This triggers the IDE to run those commands
1335 * again. And the process repeats and the machine never goes
1338 * Adding the extra layers of subdirectories prevents the
1339 * mtime of ".git/" and ".git/foo" from changing when a
1340 * cookie file is created.
1342 strbuf_init(&state
.path_cookie_prefix
, 0);
1343 strbuf_addbuf(&state
.path_cookie_prefix
, &state
.path_gitdir_watch
);
1345 strbuf_addch(&state
.path_cookie_prefix
, '/');
1346 strbuf_addstr(&state
.path_cookie_prefix
, FSMONITOR_DIR
);
1347 mkdir(state
.path_cookie_prefix
.buf
, 0777);
1349 strbuf_addch(&state
.path_cookie_prefix
, '/');
1350 strbuf_addstr(&state
.path_cookie_prefix
, FSMONITOR_COOKIE_DIR
);
1351 mkdir(state
.path_cookie_prefix
.buf
, 0777);
1353 strbuf_addch(&state
.path_cookie_prefix
, '/');
1356 * We create a named-pipe or unix domain socket inside of the
1357 * ".git" directory. (Well, on Windows, we base our named
1358 * pipe in the NPFS on the absolute path of the git
1361 strbuf_init(&state
.path_ipc
, 0);
1362 strbuf_addstr(&state
.path_ipc
,
1363 absolute_path(fsmonitor_ipc__get_path(the_repository
)));
1366 * Confirm that we can create platform-specific resources for the
1367 * filesystem listener before we bother starting all the threads.
1369 if (fsm_listen__ctor(&state
)) {
1370 err
= error(_("could not initialize listener thread"));
1374 if (fsm_health__ctor(&state
)) {
1375 err
= error(_("could not initialize health thread"));
1380 * CD out of the worktree root directory.
1382 * The common Git startup mechanism causes our CWD to be the
1383 * root of the worktree. On Windows, this causes our process
1384 * to hold a locked handle on the CWD. This prevents the
1385 * worktree from being moved or deleted while the daemon is
1388 * We assume that our FS and IPC listener threads have either
1389 * opened all of the handles that they need or will do
1390 * everything using absolute paths.
1392 home
= getenv("HOME");
1393 if (home
&& *home
&& chdir(home
))
1394 die_errno(_("could not cd home '%s'"), home
);
1396 err
= fsmonitor_run_daemon_1(&state
);
1399 pthread_cond_destroy(&state
.cookies_cond
);
1400 pthread_mutex_destroy(&state
.main_lock
);
1401 fsm_listen__dtor(&state
);
1402 fsm_health__dtor(&state
);
1404 ipc_server_free(state
.ipc_server_data
);
1406 strbuf_release(&state
.path_worktree_watch
);
1407 strbuf_release(&state
.path_gitdir_watch
);
1408 strbuf_release(&state
.path_cookie_prefix
);
1409 strbuf_release(&state
.path_ipc
);
1410 strbuf_release(&state
.alias
.alias
);
1411 strbuf_release(&state
.alias
.points_to
);
1416 static int try_to_run_foreground_daemon(int detach_console MAYBE_UNUSED
)
1419 * Technically, we don't need to probe for an existing daemon
1420 * process, since we could just call `fsmonitor_run_daemon()`
1421 * and let it fail if the pipe/socket is busy.
1423 * However, this method gives us a nicer error message for a
1424 * common error case.
1426 if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING
)
1427 die(_("fsmonitor--daemon is already running '%s'"),
1428 the_repository
->worktree
);
1430 if (fsmonitor__announce_startup
) {
1431 fprintf(stderr
, _("running fsmonitor-daemon in '%s'\n"),
1432 the_repository
->worktree
);
1436 #ifdef GIT_WINDOWS_NATIVE
1441 return !!fsmonitor_run_daemon();
1444 static start_bg_wait_cb bg_wait_cb
;
1446 static int bg_wait_cb(const struct child_process
*cp UNUSED
,
1447 void *cb_data UNUSED
)
1449 enum ipc_active_state s
= fsmonitor_ipc__get_state();
1452 case IPC_STATE__LISTENING
:
1453 /* child is "ready" */
1456 case IPC_STATE__NOT_LISTENING
:
1457 case IPC_STATE__PATH_NOT_FOUND
:
1458 /* give child more time */
1462 case IPC_STATE__INVALID_PATH
:
1463 case IPC_STATE__OTHER_ERROR
:
1464 /* all the time in world won't help */
1469 static int try_to_start_background_daemon(void)
1471 struct child_process cp
= CHILD_PROCESS_INIT
;
1472 enum start_bg_result sbgr
;
1475 * Before we try to create a background daemon process, see
1476 * if a daemon process is already listening. This makes it
1477 * easier for us to report an already-listening error to the
1478 * console, since our spawn/daemon can only report the success
1479 * of creating the background process (and not whether it
1480 * immediately exited).
1482 if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING
)
1483 die(_("fsmonitor--daemon is already running '%s'"),
1484 the_repository
->worktree
);
1486 if (fsmonitor__announce_startup
) {
1487 fprintf(stderr
, _("starting fsmonitor-daemon in '%s'\n"),
1488 the_repository
->worktree
);
1494 strvec_push(&cp
.args
, "fsmonitor--daemon");
1495 strvec_push(&cp
.args
, "run");
1496 strvec_push(&cp
.args
, "--detach");
1497 strvec_pushf(&cp
.args
, "--ipc-threads=%d", fsmonitor__ipc_threads
);
1503 sbgr
= start_bg_command(&cp
, bg_wait_cb
, NULL
,
1504 fsmonitor__start_timeout_sec
);
1513 return error(_("daemon failed to start"));
1516 return error(_("daemon not online yet"));
1519 return error(_("daemon terminated"));
1523 int cmd_fsmonitor__daemon(int argc
, const char **argv
, const char *prefix
)
1526 enum fsmonitor_reason reason
;
1527 int detach_console
= 0;
1529 struct option options
[] = {
1530 OPT_BOOL(0, "detach", &detach_console
, N_("detach from console")),
1531 OPT_INTEGER(0, "ipc-threads",
1532 &fsmonitor__ipc_threads
,
1533 N_("use <n> ipc worker threads")),
1534 OPT_INTEGER(0, "start-timeout",
1535 &fsmonitor__start_timeout_sec
,
1536 N_("max seconds to wait for background daemon startup")),
1541 git_config(fsmonitor_config
, NULL
);
1543 argc
= parse_options(argc
, argv
, prefix
, options
,
1544 builtin_fsmonitor__daemon_usage
, 0);
1546 usage_with_options(builtin_fsmonitor__daemon_usage
, options
);
1549 if (fsmonitor__ipc_threads
< 1)
1550 die(_("invalid 'ipc-threads' value (%d)"),
1551 fsmonitor__ipc_threads
);
1553 prepare_repo_settings(the_repository
);
1555 * If the repo is fsmonitor-compatible, explicitly set IPC-mode
1556 * (without bothering to load the `core.fsmonitor` config settings).
1558 * If the repo is not compatible, the repo-settings will be set to
1559 * incompatible rather than IPC, so we can use one of the __get
1560 * routines to detect the discrepancy.
1562 fsm_settings__set_ipc(the_repository
);
1564 reason
= fsm_settings__get_reason(the_repository
);
1565 if (reason
> FSMONITOR_REASON_OK
)
1567 fsm_settings__get_incompatible_msg(the_repository
,
1570 if (!strcmp(subcmd
, "start"))
1571 return !!try_to_start_background_daemon();
1573 if (!strcmp(subcmd
, "run"))
1574 return !!try_to_run_foreground_daemon(detach_console
);
1576 if (!strcmp(subcmd
, "stop"))
1577 return !!do_as_client__send_stop();
1579 if (!strcmp(subcmd
, "status"))
1580 return !!do_as_client__status();
1582 die(_("Unhandled subcommand '%s'"), subcmd
);
1586 int cmd_fsmonitor__daemon(int argc
, const char **argv
, const char *prefix UNUSED
)
1588 struct option options
[] = {
1592 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1593 usage_with_options(builtin_fsmonitor__daemon_usage
, options
);
1595 die(_("fsmonitor--daemon not supported on this platform"));