| 1 | #define USE_THE_REPOSITORY_VARIABLE |
| 2 | #define DISABLE_SIGN_COMPARE_WARNINGS |
| 3 | |
| 4 | #include "git-compat-util.h" |
| 5 | #include "config.h" |
| 6 | #include "dir.h" |
| 7 | #include "environment.h" |
| 8 | #include "ewah/ewok.h" |
| 9 | #include "fsmonitor.h" |
| 10 | #include "fsmonitor-ipc.h" |
| 11 | #include "name-hash.h" |
| 12 | #include "repository.h" |
| 13 | #include "run-command.h" |
| 14 | #include "strbuf.h" |
| 15 | #include "trace2.h" |
| 16 | |
| 17 | #define INDEX_EXTENSION_VERSION1 (1) |
| 18 | #define INDEX_EXTENSION_VERSION2 (2) |
| 19 | #define HOOK_INTERFACE_VERSION1 (1) |
| 20 | #define HOOK_INTERFACE_VERSION2 (2) |
| 21 | |
| 22 | struct trace_key trace_fsmonitor = TRACE_KEY_INIT(FSMONITOR); |
| 23 | |
| 24 | static void assert_index_minimum(struct index_state *istate, size_t pos) |
| 25 | { |
| 26 | if (pos > istate->cache_nr) |
| 27 | BUG("fsmonitor_dirty has more entries than the index (%"PRIuMAX" > %u)", |
| 28 | (uintmax_t)pos, istate->cache_nr); |
| 29 | } |
| 30 | |
| 31 | static void fsmonitor_ewah_callback(size_t pos, void *is) |
| 32 | { |
| 33 | struct index_state *istate = (struct index_state *)is; |
| 34 | struct cache_entry *ce; |
| 35 | |
| 36 | assert_index_minimum(istate, pos + 1); |
| 37 | |
| 38 | ce = istate->cache[pos]; |
| 39 | ce->ce_flags &= ~CE_FSMONITOR_VALID; |
| 40 | } |
| 41 | |
| 42 | static int fsmonitor_hook_version(void) |
| 43 | { |
| 44 | int hook_version; |
| 45 | |
| 46 | if (repo_config_get_int(the_repository, "core.fsmonitorhookversion", &hook_version)) |
| 47 | return -1; |
| 48 | |
| 49 | if (hook_version == HOOK_INTERFACE_VERSION1 || |
| 50 | hook_version == HOOK_INTERFACE_VERSION2) |
| 51 | return hook_version; |
| 52 | |
| 53 | warning("Invalid hook version '%i' in core.fsmonitorhookversion. " |
| 54 | "Must be 1 or 2.", hook_version); |
| 55 | return -1; |
| 56 | } |
| 57 | |
| 58 | int read_fsmonitor_extension(struct index_state *istate, const void *data, |
| 59 | unsigned long sz) |
| 60 | { |
| 61 | const char *index = data; |
| 62 | uint32_t hdr_version; |
| 63 | uint32_t ewah_size; |
| 64 | struct ewah_bitmap *fsmonitor_dirty; |
| 65 | int ret; |
| 66 | uint64_t timestamp; |
| 67 | struct strbuf last_update = STRBUF_INIT; |
| 68 | |
| 69 | if (sz < sizeof(uint32_t) + 1 + sizeof(uint32_t)) |
| 70 | return error("corrupt fsmonitor extension (too short)"); |
| 71 | |
| 72 | hdr_version = get_be32(index); |
| 73 | index += sizeof(uint32_t); |
| 74 | if (hdr_version == INDEX_EXTENSION_VERSION1) { |
| 75 | timestamp = get_be64(index); |
| 76 | strbuf_addf(&last_update, "%"PRIu64"", timestamp); |
| 77 | index += sizeof(uint64_t); |
| 78 | } else if (hdr_version == INDEX_EXTENSION_VERSION2) { |
| 79 | strbuf_addstr(&last_update, index); |
| 80 | index += last_update.len + 1; |
| 81 | } else { |
| 82 | return error("bad fsmonitor version %d", hdr_version); |
| 83 | } |
| 84 | |
| 85 | istate->fsmonitor_last_update = strbuf_detach(&last_update, NULL); |
| 86 | |
| 87 | ewah_size = get_be32(index); |
| 88 | index += sizeof(uint32_t); |
| 89 | |
| 90 | fsmonitor_dirty = ewah_new(); |
| 91 | ret = ewah_read_mmap(fsmonitor_dirty, index, ewah_size); |
| 92 | if (ret != ewah_size) { |
| 93 | ewah_free(fsmonitor_dirty); |
| 94 | return error("failed to parse ewah bitmap reading fsmonitor index extension"); |
| 95 | } |
| 96 | istate->fsmonitor_dirty = fsmonitor_dirty; |
| 97 | |
| 98 | if (!istate->split_index) |
| 99 | assert_index_minimum(istate, istate->fsmonitor_dirty->bit_size); |
| 100 | |
| 101 | trace2_data_string("index", NULL, "extension/fsmn/read/token", |
| 102 | istate->fsmonitor_last_update); |
| 103 | trace_printf_key(&trace_fsmonitor, |
| 104 | "read fsmonitor extension successful '%s'", |
| 105 | istate->fsmonitor_last_update); |
| 106 | return 0; |
| 107 | } |
| 108 | |
| 109 | void fill_fsmonitor_bitmap(struct index_state *istate) |
| 110 | { |
| 111 | unsigned int i, skipped = 0; |
| 112 | istate->fsmonitor_dirty = ewah_new(); |
| 113 | for (i = 0; i < istate->cache_nr; i++) { |
| 114 | if (istate->cache[i]->ce_flags & CE_REMOVE) |
| 115 | skipped++; |
| 116 | else if (!(istate->cache[i]->ce_flags & CE_FSMONITOR_VALID)) |
| 117 | ewah_set(istate->fsmonitor_dirty, i - skipped); |
| 118 | } |
| 119 | } |
| 120 | |
| 121 | void write_fsmonitor_extension(struct strbuf *sb, struct index_state *istate) |
| 122 | { |
| 123 | uint32_t hdr_version; |
| 124 | uint32_t ewah_start; |
| 125 | uint32_t ewah_size = 0; |
| 126 | int fixup = 0; |
| 127 | |
| 128 | if (!istate->split_index) |
| 129 | assert_index_minimum(istate, istate->fsmonitor_dirty->bit_size); |
| 130 | |
| 131 | put_be32(&hdr_version, INDEX_EXTENSION_VERSION2); |
| 132 | strbuf_add(sb, &hdr_version, sizeof(uint32_t)); |
| 133 | |
| 134 | strbuf_addstr(sb, istate->fsmonitor_last_update); |
| 135 | strbuf_addch(sb, 0); /* Want to keep a NUL */ |
| 136 | |
| 137 | fixup = sb->len; |
| 138 | strbuf_add(sb, &ewah_size, sizeof(uint32_t)); /* we'll fix this up later */ |
| 139 | |
| 140 | ewah_start = sb->len; |
| 141 | ewah_serialize_strbuf(istate->fsmonitor_dirty, sb); |
| 142 | ewah_free(istate->fsmonitor_dirty); |
| 143 | istate->fsmonitor_dirty = NULL; |
| 144 | |
| 145 | /* fix up size field */ |
| 146 | put_be32(&ewah_size, sb->len - ewah_start); |
| 147 | memcpy(sb->buf + fixup, &ewah_size, sizeof(uint32_t)); |
| 148 | |
| 149 | trace2_data_string("index", NULL, "extension/fsmn/write/token", |
| 150 | istate->fsmonitor_last_update); |
| 151 | trace_printf_key(&trace_fsmonitor, |
| 152 | "write fsmonitor extension successful '%s'", |
| 153 | istate->fsmonitor_last_update); |
| 154 | } |
| 155 | |
| 156 | /* |
| 157 | * Call the query-fsmonitor hook passing the last update token of the saved results. |
| 158 | */ |
| 159 | static int query_fsmonitor_hook(struct repository *r, |
| 160 | int version, |
| 161 | const char *last_update, |
| 162 | struct strbuf *query_result) |
| 163 | { |
| 164 | struct child_process cp = CHILD_PROCESS_INIT; |
| 165 | int result; |
| 166 | |
| 167 | if (fsm_settings__get_mode(r) != FSMONITOR_MODE_HOOK) |
| 168 | return -1; |
| 169 | |
| 170 | strvec_push(&cp.args, fsm_settings__get_hook_path(r)); |
| 171 | strvec_pushf(&cp.args, "%d", version); |
| 172 | strvec_pushf(&cp.args, "%s", last_update); |
| 173 | cp.use_shell = 1; |
| 174 | cp.dir = repo_get_work_tree(the_repository); |
| 175 | |
| 176 | trace2_region_enter("fsm_hook", "query", NULL); |
| 177 | |
| 178 | result = capture_command(&cp, query_result, 1024); |
| 179 | |
| 180 | if (result) |
| 181 | trace2_data_intmax("fsm_hook", NULL, "query/failed", result); |
| 182 | else |
| 183 | trace2_data_intmax("fsm_hook", NULL, "query/response-length", |
| 184 | query_result->len); |
| 185 | |
| 186 | trace2_region_leave("fsm_hook", "query", NULL); |
| 187 | |
| 188 | return result; |
| 189 | } |
| 190 | |
| 191 | /* |
| 192 | * Invalidate the FSM bit on this CE. This is like mark_fsmonitor_invalid() |
| 193 | * but we've already handled the untracked-cache, so let's not repeat that |
| 194 | * work. This also lets us have a different trace message so that we can |
| 195 | * see everything that was done as part of the refresh-callback. |
| 196 | */ |
| 197 | static void invalidate_ce_fsm(struct cache_entry *ce) |
| 198 | { |
| 199 | if (ce->ce_flags & CE_FSMONITOR_VALID) { |
| 200 | trace_printf_key(&trace_fsmonitor, |
| 201 | "fsmonitor_refresh_callback INV: '%s'", |
| 202 | ce->name); |
| 203 | ce->ce_flags &= ~CE_FSMONITOR_VALID; |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | static size_t handle_path_with_trailing_slash( |
| 208 | struct index_state *istate, const char *name, int pos); |
| 209 | |
| 210 | /* |
| 211 | * Use the name-hash to do a case-insensitive cache-entry lookup with |
| 212 | * the pathname and invalidate the cache-entry. |
| 213 | * |
| 214 | * Returns the number of cache-entries that we invalidated. |
| 215 | */ |
| 216 | static size_t handle_using_name_hash_icase( |
| 217 | struct index_state *istate, const char *name) |
| 218 | { |
| 219 | struct cache_entry *ce = NULL; |
| 220 | |
| 221 | ce = index_file_exists(istate, name, strlen(name), 1); |
| 222 | if (!ce) |
| 223 | return 0; |
| 224 | |
| 225 | /* |
| 226 | * A case-insensitive search in the name-hash using the |
| 227 | * observed pathname found a cache-entry, so the observed path |
| 228 | * is case-incorrect. Invalidate the cache-entry and use the |
| 229 | * correct spelling from the cache-entry to invalidate the |
| 230 | * untracked-cache. Since we now have sparse-directories in |
| 231 | * the index, the observed pathname may represent a regular |
| 232 | * file or a sparse-index directory. |
| 233 | * |
| 234 | * Note that we should not have seen FSEvents for a |
| 235 | * sparse-index directory, but we handle it just in case. |
| 236 | * |
| 237 | * Either way, we know that there are not any cache-entries for |
| 238 | * children inside the cone of the directory, so we don't need to |
| 239 | * do the usual scan. |
| 240 | */ |
| 241 | trace_printf_key(&trace_fsmonitor, |
| 242 | "fsmonitor_refresh_callback MAP: '%s' '%s'", |
| 243 | name, ce->name); |
| 244 | |
| 245 | /* |
| 246 | * NEEDSWORK: We used the name-hash to find the correct |
| 247 | * case-spelling of the pathname in the cache-entry[], so |
| 248 | * technically this is a tracked file or a sparse-directory. |
| 249 | * It should not have any entries in the untracked-cache, so |
| 250 | * we should not need to use the case-corrected spelling to |
| 251 | * invalidate the untracked-cache. So we may not need to |
| 252 | * do this. For now, I'm going to be conservative and always |
| 253 | * do it; we can revisit this later. |
| 254 | */ |
| 255 | untracked_cache_invalidate_trimmed_path(istate, ce->name, 0); |
| 256 | |
| 257 | invalidate_ce_fsm(ce); |
| 258 | return 1; |
| 259 | } |
| 260 | |
| 261 | /* |
| 262 | * Use the dir-name-hash to find the correct-case spelling of the |
| 263 | * directory. Use the canonical spelling to invalidate all of the |
| 264 | * cache-entries within the matching cone. |
| 265 | * |
| 266 | * Returns the number of cache-entries that we invalidated. |
| 267 | */ |
| 268 | static size_t handle_using_dir_name_hash_icase( |
| 269 | struct index_state *istate, const char *name) |
| 270 | { |
| 271 | struct strbuf canonical_path = STRBUF_INIT; |
| 272 | int pos; |
| 273 | size_t len = strlen(name); |
| 274 | size_t nr_in_cone; |
| 275 | |
| 276 | if (name[len - 1] == '/') |
| 277 | len--; |
| 278 | |
| 279 | if (!index_dir_find(istate, name, len, &canonical_path)) |
| 280 | return 0; /* name is untracked */ |
| 281 | |
| 282 | if (!memcmp(name, canonical_path.buf, canonical_path.len)) { |
| 283 | strbuf_release(&canonical_path); |
| 284 | /* |
| 285 | * NEEDSWORK: Our caller already tried an exact match |
| 286 | * and failed to find one. They called us to do an |
| 287 | * ICASE match, so we should never get an exact match, |
| 288 | * so we could promote this to a BUG() here if we |
| 289 | * wanted to. It doesn't hurt anything to just return |
| 290 | * 0 and go on because we should never get here. Or we |
| 291 | * could just get rid of the memcmp() and this "if" |
| 292 | * clause completely. |
| 293 | */ |
| 294 | BUG("handle_using_dir_name_hash_icase(%s) did not exact match", |
| 295 | name); |
| 296 | } |
| 297 | |
| 298 | trace_printf_key(&trace_fsmonitor, |
| 299 | "fsmonitor_refresh_callback MAP: '%s' '%s'", |
| 300 | name, canonical_path.buf); |
| 301 | |
| 302 | /* |
| 303 | * The dir-name-hash only tells us the corrected spelling of |
| 304 | * the prefix. We have to use this canonical path to do a |
| 305 | * lookup in the cache-entry array so that we repeat the |
| 306 | * original search using the case-corrected spelling. |
| 307 | */ |
| 308 | strbuf_addch(&canonical_path, '/'); |
| 309 | pos = index_name_pos(istate, canonical_path.buf, |
| 310 | canonical_path.len); |
| 311 | nr_in_cone = handle_path_with_trailing_slash( |
| 312 | istate, canonical_path.buf, pos); |
| 313 | strbuf_release(&canonical_path); |
| 314 | return nr_in_cone; |
| 315 | } |
| 316 | |
| 317 | /* |
| 318 | * The daemon sent an observed pathname without a trailing slash. |
| 319 | * (This is the normal case.) We do not know if it is a tracked or |
| 320 | * untracked file, a sparse-directory, or a populated directory (on a |
| 321 | * platform such as Windows where FSEvents are not qualified). |
| 322 | * |
| 323 | * The pathname contains the observed case reported by the FS. We |
| 324 | * do not know it is case-correct or -incorrect. |
| 325 | * |
| 326 | * Assume it is case-correct and try an exact match. |
| 327 | * |
| 328 | * Return the number of cache-entries that we invalidated. |
| 329 | */ |
| 330 | static size_t handle_path_without_trailing_slash( |
| 331 | struct index_state *istate, const char *name, int pos) |
| 332 | { |
| 333 | /* |
| 334 | * Mark the untracked cache dirty for this path (regardless of |
| 335 | * whether or not we find an exact match for it in the index). |
| 336 | * Since the path is unqualified (no trailing slash hint in the |
| 337 | * FSEvent), it may refer to a file or directory. So we should |
| 338 | * not assume one or the other and should always let the untracked |
| 339 | * cache decide what needs to invalidated. |
| 340 | */ |
| 341 | untracked_cache_invalidate_trimmed_path(istate, name, 0); |
| 342 | |
| 343 | if (pos >= 0) { |
| 344 | /* |
| 345 | * An exact match on a tracked file. We assume that we |
| 346 | * do not need to scan forward for a sparse-directory |
| 347 | * cache-entry with the same pathname, nor for a cone |
| 348 | * at that directory. (That is, assume no D/F conflicts.) |
| 349 | */ |
| 350 | invalidate_ce_fsm(istate->cache[pos]); |
| 351 | return 1; |
| 352 | } else { |
| 353 | size_t nr_in_cone; |
| 354 | struct strbuf work_path = STRBUF_INIT; |
| 355 | |
| 356 | /* |
| 357 | * The negative "pos" gives us the suggested insertion |
| 358 | * point for the pathname (without the trailing slash). |
| 359 | * We need to see if there is a directory with that |
| 360 | * prefix, but there can be lots of pathnames between |
| 361 | * "foo" and "foo/" like "foo-" or "foo-bar", so we |
| 362 | * don't want to do our own scan. |
| 363 | */ |
| 364 | strbuf_add(&work_path, name, strlen(name)); |
| 365 | strbuf_addch(&work_path, '/'); |
| 366 | pos = index_name_pos(istate, work_path.buf, work_path.len); |
| 367 | nr_in_cone = handle_path_with_trailing_slash( |
| 368 | istate, work_path.buf, pos); |
| 369 | strbuf_release(&work_path); |
| 370 | return nr_in_cone; |
| 371 | } |
| 372 | } |
| 373 | |
| 374 | /* |
| 375 | * The daemon can decorate directory events, such as a move or rename, |
| 376 | * by adding a trailing slash to the observed name. Use this to |
| 377 | * explicitly invalidate the entire cone under that directory. |
| 378 | * |
| 379 | * The daemon can only reliably do that if the OS FSEvent contains |
| 380 | * sufficient information in the event. |
| 381 | * |
| 382 | * macOS FSEvents have enough information. |
| 383 | * |
| 384 | * Other platforms may or may not be able to do it (and it might |
| 385 | * depend on the type of event (for example, a daemon could lstat() an |
| 386 | * observed pathname after a rename, but not after a delete)). |
| 387 | * |
| 388 | * If we find an exact match in the index for a path with a trailing |
| 389 | * slash, it means that we matched a sparse-index directory in a |
| 390 | * cone-mode sparse-checkout (since that's the only time we have |
| 391 | * directories in the index). We should never see this in practice |
| 392 | * (because sparse directories should not be present and therefore |
| 393 | * not generating FS events). Either way, we can treat them in the |
| 394 | * same way and just invalidate the cache-entry and the untracked |
| 395 | * cache (and in this case, the forward cache-entry scan won't find |
| 396 | * anything and it doesn't hurt to let it run). |
| 397 | * |
| 398 | * Return the number of cache-entries that we invalidated. We will |
| 399 | * use this later to determine if we need to attempt a second |
| 400 | * case-insensitive search on case-insensitive file systems. That is, |
| 401 | * if the search using the observed-case in the FSEvent yields any |
| 402 | * results, we assume the prefix is case-correct. If there are no |
| 403 | * matches, we still don't know if the observed path is simply |
| 404 | * untracked or case-incorrect. |
| 405 | */ |
| 406 | static size_t handle_path_with_trailing_slash( |
| 407 | struct index_state *istate, const char *name, int pos) |
| 408 | { |
| 409 | int i; |
| 410 | size_t nr_in_cone = 0; |
| 411 | |
| 412 | /* |
| 413 | * Mark the untracked cache dirty for this directory path |
| 414 | * (regardless of whether or not we find an exact match for it |
| 415 | * in the index or find it to be proper prefix of one or more |
| 416 | * files in the index), since the FSEvent is hinting that |
| 417 | * there may be changes on or within the directory. |
| 418 | */ |
| 419 | untracked_cache_invalidate_trimmed_path(istate, name, 0); |
| 420 | |
| 421 | if (pos < 0) |
| 422 | pos = -pos - 1; |
| 423 | |
| 424 | /* Mark all entries for the folder invalid */ |
| 425 | for (i = pos; i < istate->cache_nr; i++) { |
| 426 | if (!starts_with(istate->cache[i]->name, name)) |
| 427 | break; |
| 428 | invalidate_ce_fsm(istate->cache[i]); |
| 429 | nr_in_cone++; |
| 430 | } |
| 431 | |
| 432 | return nr_in_cone; |
| 433 | } |
| 434 | |
| 435 | static void fsmonitor_refresh_callback(struct index_state *istate, char *name) |
| 436 | { |
| 437 | int len = strlen(name); |
| 438 | int pos = index_name_pos(istate, name, len); |
| 439 | size_t nr_in_cone; |
| 440 | |
| 441 | trace_printf_key(&trace_fsmonitor, |
| 442 | "fsmonitor_refresh_callback '%s' (pos %d)", |
| 443 | name, pos); |
| 444 | |
| 445 | if (name[len - 1] == '/') |
| 446 | nr_in_cone = handle_path_with_trailing_slash(istate, name, pos); |
| 447 | else |
| 448 | nr_in_cone = handle_path_without_trailing_slash(istate, name, pos); |
| 449 | |
| 450 | /* |
| 451 | * If we did not find an exact match for this pathname or any |
| 452 | * cache-entries with this directory prefix and we're on a |
| 453 | * case-insensitive file system, try again using the name-hash |
| 454 | * and dir-name-hash. |
| 455 | */ |
| 456 | if (!nr_in_cone && repo_ignore_case(the_repository)) { |
| 457 | nr_in_cone = handle_using_name_hash_icase(istate, name); |
| 458 | if (!nr_in_cone) |
| 459 | nr_in_cone = handle_using_dir_name_hash_icase( |
| 460 | istate, name); |
| 461 | } |
| 462 | |
| 463 | if (nr_in_cone) |
| 464 | trace_printf_key(&trace_fsmonitor, |
| 465 | "fsmonitor_refresh_callback CNT: %d", |
| 466 | (int)nr_in_cone); |
| 467 | } |
| 468 | |
| 469 | /* |
| 470 | * The number of pathnames that we need to receive from FSMonitor |
| 471 | * before we force the index to be updated. |
| 472 | * |
| 473 | * Note that any pathname within the set of received paths MAY cause |
| 474 | * cache-entry or istate flag bits to be updated and thus cause the |
| 475 | * index to be updated on disk. |
| 476 | * |
| 477 | * However, the response may contain many paths (such as ignored |
| 478 | * paths) that will not update any flag bits. And thus not force the |
| 479 | * index to be updated. (This is fine and normal.) It also means |
| 480 | * that the token will not be updated in the FSMonitor index |
| 481 | * extension. So the next Git command will find the same token in the |
| 482 | * index, make the same token-relative request, and receive the same |
| 483 | * response (plus any newly changed paths). If this response is large |
| 484 | * (and continues to grow), performance could be impacted. |
| 485 | * |
| 486 | * For example, if the user runs a build and it writes 100K object |
| 487 | * files but doesn't modify any source files, the index would not need |
| 488 | * to be updated. The FSMonitor response (after the build and |
| 489 | * relative to a pre-build token) might be 5MB. Each subsequent Git |
| 490 | * command will receive that same 100K/5MB response until something |
| 491 | * causes the index to be updated. And `refresh_fsmonitor()` will |
| 492 | * have to iterate over those 100K paths each time. |
| 493 | * |
| 494 | * Performance could be improved if we optionally force update the |
| 495 | * index after a very large response and get an updated token into |
| 496 | * the FSMonitor index extension. This should allow subsequent |
| 497 | * commands to get smaller and more current responses. |
| 498 | * |
| 499 | * The value chosen here does not need to be precise. The index |
| 500 | * will be updated automatically the first time the user touches |
| 501 | * a tracked file and causes a command like `git status` to |
| 502 | * update an mtime to be updated and/or set a flag bit. |
| 503 | */ |
| 504 | static int fsmonitor_force_update_threshold = 100; |
| 505 | |
| 506 | void refresh_fsmonitor(struct index_state *istate) |
| 507 | { |
| 508 | static int warn_once = 0; |
| 509 | struct strbuf query_result = STRBUF_INIT; |
| 510 | int query_success = 0, hook_version = -1; |
| 511 | size_t bol = 0; /* beginning of line */ |
| 512 | uint64_t last_update; |
| 513 | struct strbuf last_update_token = STRBUF_INIT; |
| 514 | char *buf; |
| 515 | unsigned int i; |
| 516 | int is_trivial = 0; |
| 517 | struct repository *r = istate->repo; |
| 518 | enum fsmonitor_mode fsm_mode = fsm_settings__get_mode(r); |
| 519 | enum fsmonitor_reason reason = fsm_settings__get_reason(r); |
| 520 | |
| 521 | if (!warn_once && reason > FSMONITOR_REASON_OK) { |
| 522 | char *msg = fsm_settings__get_incompatible_msg(r, reason); |
| 523 | warn_once = 1; |
| 524 | warning("%s", msg); |
| 525 | free(msg); |
| 526 | } |
| 527 | |
| 528 | if (fsm_mode <= FSMONITOR_MODE_DISABLED || |
| 529 | istate->fsmonitor_has_run_once) |
| 530 | return; |
| 531 | |
| 532 | istate->fsmonitor_has_run_once = 1; |
| 533 | |
| 534 | trace_printf_key(&trace_fsmonitor, "refresh fsmonitor"); |
| 535 | |
| 536 | if (fsm_mode == FSMONITOR_MODE_IPC) { |
| 537 | query_success = !fsmonitor_ipc__send_query( |
| 538 | istate->fsmonitor_last_update ? |
| 539 | istate->fsmonitor_last_update : "builtin:fake", |
| 540 | &query_result); |
| 541 | if (query_success) { |
| 542 | /* |
| 543 | * The response contains a series of nul terminated |
| 544 | * strings. The first is the new token. |
| 545 | * |
| 546 | * Use `char *buf` as an interlude to trick the CI |
| 547 | * static analysis to let us use `strbuf_addstr()` |
| 548 | * here (and only copy the token) rather than |
| 549 | * `strbuf_addbuf()`. |
| 550 | */ |
| 551 | buf = query_result.buf; |
| 552 | strbuf_addstr(&last_update_token, buf); |
| 553 | bol = last_update_token.len + 1; |
| 554 | is_trivial = query_result.buf[bol] == '/'; |
| 555 | if (is_trivial) |
| 556 | trace2_data_intmax("fsm_client", NULL, |
| 557 | "query/trivial-response", 1); |
| 558 | } else { |
| 559 | /* |
| 560 | * The builtin daemon is not available on this |
| 561 | * platform -OR- we failed to get a response. |
| 562 | * |
| 563 | * Generate a fake token (rather than a V1 |
| 564 | * timestamp) for the index extension. (If |
| 565 | * they switch back to the hook API, we don't |
| 566 | * want ambiguous state.) |
| 567 | */ |
| 568 | strbuf_addstr(&last_update_token, "builtin:fake"); |
| 569 | } |
| 570 | |
| 571 | goto apply_results; |
| 572 | } |
| 573 | |
| 574 | assert(fsm_mode == FSMONITOR_MODE_HOOK); |
| 575 | |
| 576 | hook_version = fsmonitor_hook_version(); |
| 577 | |
| 578 | /* |
| 579 | * This could be racy so save the date/time now and query_fsmonitor_hook |
| 580 | * should be inclusive to ensure we don't miss potential changes. |
| 581 | */ |
| 582 | last_update = getnanotime(); |
| 583 | if (hook_version == HOOK_INTERFACE_VERSION1) |
| 584 | strbuf_addf(&last_update_token, "%"PRIu64"", last_update); |
| 585 | |
| 586 | /* |
| 587 | * If we have a last update token, call query_fsmonitor_hook for the set of |
| 588 | * changes since that token, else assume everything is possibly dirty |
| 589 | * and check it all. |
| 590 | */ |
| 591 | if (istate->fsmonitor_last_update) { |
| 592 | if (hook_version == -1 || hook_version == HOOK_INTERFACE_VERSION2) { |
| 593 | query_success = !query_fsmonitor_hook( |
| 594 | r, HOOK_INTERFACE_VERSION2, |
| 595 | istate->fsmonitor_last_update, &query_result); |
| 596 | |
| 597 | if (query_success) { |
| 598 | if (hook_version < 0) |
| 599 | hook_version = HOOK_INTERFACE_VERSION2; |
| 600 | |
| 601 | /* |
| 602 | * First entry will be the last update token |
| 603 | * Need to use a char * variable because static |
| 604 | * analysis was suggesting to use strbuf_addbuf |
| 605 | * but we don't want to copy the entire strbuf |
| 606 | * only the chars up to the first NUL |
| 607 | */ |
| 608 | buf = query_result.buf; |
| 609 | strbuf_addstr(&last_update_token, buf); |
| 610 | if (!last_update_token.len) { |
| 611 | warning("Empty last update token."); |
| 612 | query_success = 0; |
| 613 | } else { |
| 614 | bol = last_update_token.len + 1; |
| 615 | is_trivial = query_result.buf[bol] == '/'; |
| 616 | } |
| 617 | } else if (hook_version < 0) { |
| 618 | hook_version = HOOK_INTERFACE_VERSION1; |
| 619 | if (!last_update_token.len) |
| 620 | strbuf_addf(&last_update_token, "%"PRIu64"", last_update); |
| 621 | } |
| 622 | } |
| 623 | |
| 624 | if (hook_version == HOOK_INTERFACE_VERSION1) { |
| 625 | query_success = !query_fsmonitor_hook( |
| 626 | r, HOOK_INTERFACE_VERSION1, |
| 627 | istate->fsmonitor_last_update, &query_result); |
| 628 | if (query_success) |
| 629 | is_trivial = query_result.buf[0] == '/'; |
| 630 | } |
| 631 | |
| 632 | if (is_trivial) |
| 633 | trace2_data_intmax("fsm_hook", NULL, |
| 634 | "query/trivial-response", 1); |
| 635 | |
| 636 | trace_performance_since(last_update, "fsmonitor process '%s'", |
| 637 | fsm_settings__get_hook_path(r)); |
| 638 | trace_printf_key(&trace_fsmonitor, |
| 639 | "fsmonitor process '%s' returned %s", |
| 640 | fsm_settings__get_hook_path(r), |
| 641 | query_success ? "success" : "failure"); |
| 642 | } |
| 643 | |
| 644 | apply_results: |
| 645 | /* |
| 646 | * The response from FSMonitor (excluding the header token) is |
| 647 | * either: |
| 648 | * |
| 649 | * [a] a (possibly empty) list of NUL delimited relative |
| 650 | * pathnames of changed paths. This list can contain |
| 651 | * files and directories. Directories have a trailing |
| 652 | * slash. |
| 653 | * |
| 654 | * [b] a single '/' to indicate the provider had no |
| 655 | * information and that we should consider everything |
| 656 | * invalid. We call this a trivial response. |
| 657 | */ |
| 658 | trace2_region_enter("fsmonitor", "apply_results", istate->repo); |
| 659 | |
| 660 | if (query_success && !is_trivial) { |
| 661 | /* |
| 662 | * Mark all pathnames returned by the monitor as dirty. |
| 663 | * |
| 664 | * This updates both the cache-entries and the untracked-cache. |
| 665 | */ |
| 666 | int count = 0; |
| 667 | |
| 668 | buf = query_result.buf; |
| 669 | for (i = bol; i < query_result.len; i++) { |
| 670 | if (buf[i] != '\0') |
| 671 | continue; |
| 672 | fsmonitor_refresh_callback(istate, buf + bol); |
| 673 | bol = i + 1; |
| 674 | count++; |
| 675 | } |
| 676 | if (bol < query_result.len) { |
| 677 | fsmonitor_refresh_callback(istate, buf + bol); |
| 678 | count++; |
| 679 | } |
| 680 | |
| 681 | /* Now mark the untracked cache for fsmonitor usage */ |
| 682 | if (istate->untracked) |
| 683 | istate->untracked->use_fsmonitor = 1; |
| 684 | |
| 685 | if (count > fsmonitor_force_update_threshold) |
| 686 | istate->cache_changed |= FSMONITOR_CHANGED; |
| 687 | |
| 688 | trace2_data_intmax("fsmonitor", istate->repo, "apply_count", |
| 689 | count); |
| 690 | |
| 691 | } else { |
| 692 | /* |
| 693 | * We failed to get a response or received a trivial response, |
| 694 | * so invalidate everything. |
| 695 | * |
| 696 | * We only want to run the post index changed hook if |
| 697 | * we've actually changed entries, so keep track if we |
| 698 | * actually changed entries or not. |
| 699 | */ |
| 700 | int is_cache_changed = 0; |
| 701 | |
| 702 | for (i = 0; i < istate->cache_nr; i++) { |
| 703 | if (istate->cache[i]->ce_flags & CE_FSMONITOR_VALID) { |
| 704 | is_cache_changed = 1; |
| 705 | istate->cache[i]->ce_flags &= ~CE_FSMONITOR_VALID; |
| 706 | } |
| 707 | } |
| 708 | |
| 709 | /* |
| 710 | * If we're going to check every file, ensure we save |
| 711 | * the results. |
| 712 | */ |
| 713 | if (is_cache_changed) |
| 714 | istate->cache_changed |= FSMONITOR_CHANGED; |
| 715 | |
| 716 | if (istate->untracked) |
| 717 | istate->untracked->use_fsmonitor = 0; |
| 718 | } |
| 719 | trace2_region_leave("fsmonitor", "apply_results", istate->repo); |
| 720 | |
| 721 | strbuf_release(&query_result); |
| 722 | |
| 723 | /* Now that we've updated istate, save the last_update_token */ |
| 724 | FREE_AND_NULL(istate->fsmonitor_last_update); |
| 725 | istate->fsmonitor_last_update = strbuf_detach(&last_update_token, NULL); |
| 726 | } |
| 727 | |
| 728 | /* |
| 729 | * The caller wants to turn on FSMonitor. And when the caller writes |
| 730 | * the index to disk, a FSMonitor extension should be included. This |
| 731 | * requires that `istate->fsmonitor_last_update` not be NULL. But we |
| 732 | * have not actually talked to a FSMonitor process yet, so we don't |
| 733 | * have an initial value for this field. |
| 734 | * |
| 735 | * For a protocol V1 FSMonitor process, this field is a formatted |
| 736 | * "nanoseconds since epoch" field. However, for a protocol V2 |
| 737 | * FSMonitor process, this field is an opaque token. |
| 738 | * |
| 739 | * Historically, `add_fsmonitor()` has initialized this field to the |
| 740 | * current time for protocol V1 processes. There are lots of race |
| 741 | * conditions here, but that code has shipped... |
| 742 | * |
| 743 | * The only true solution is to use a V2 FSMonitor and get a current |
| 744 | * or default token value (that it understands), but we cannot do that |
| 745 | * until we have actually talked to an instance of the FSMonitor process |
| 746 | * (but the protocol requires that we send a token first...). |
| 747 | * |
| 748 | * For simplicity, just initialize like we have a V1 process and require |
| 749 | * that V2 processes adapt. |
| 750 | */ |
| 751 | static void initialize_fsmonitor_last_update(struct index_state *istate) |
| 752 | { |
| 753 | struct strbuf last_update = STRBUF_INIT; |
| 754 | |
| 755 | strbuf_addf(&last_update, "%"PRIu64"", getnanotime()); |
| 756 | istate->fsmonitor_last_update = strbuf_detach(&last_update, NULL); |
| 757 | } |
| 758 | |
| 759 | void add_fsmonitor(struct index_state *istate) |
| 760 | { |
| 761 | unsigned int i; |
| 762 | |
| 763 | if (!istate->fsmonitor_last_update) { |
| 764 | trace_printf_key(&trace_fsmonitor, "add fsmonitor"); |
| 765 | istate->cache_changed |= FSMONITOR_CHANGED; |
| 766 | initialize_fsmonitor_last_update(istate); |
| 767 | |
| 768 | /* reset the fsmonitor state */ |
| 769 | for (i = 0; i < istate->cache_nr; i++) |
| 770 | istate->cache[i]->ce_flags &= ~CE_FSMONITOR_VALID; |
| 771 | |
| 772 | /* reset the untracked cache */ |
| 773 | if (istate->untracked) { |
| 774 | add_untracked_cache(istate); |
| 775 | istate->untracked->use_fsmonitor = 1; |
| 776 | } |
| 777 | |
| 778 | /* Update the fsmonitor state */ |
| 779 | refresh_fsmonitor(istate); |
| 780 | } |
| 781 | } |
| 782 | |
| 783 | void remove_fsmonitor(struct index_state *istate) |
| 784 | { |
| 785 | if (istate->fsmonitor_last_update) { |
| 786 | trace_printf_key(&trace_fsmonitor, "remove fsmonitor"); |
| 787 | istate->cache_changed |= FSMONITOR_CHANGED; |
| 788 | FREE_AND_NULL(istate->fsmonitor_last_update); |
| 789 | } |
| 790 | } |
| 791 | |
| 792 | void tweak_fsmonitor(struct index_state *istate) |
| 793 | { |
| 794 | unsigned int i; |
| 795 | int fsmonitor_enabled = (fsm_settings__get_mode(istate->repo) |
| 796 | > FSMONITOR_MODE_DISABLED); |
| 797 | |
| 798 | if (istate->fsmonitor_dirty) { |
| 799 | if (fsmonitor_enabled) { |
| 800 | /* Mark all entries valid */ |
| 801 | for (i = 0; i < istate->cache_nr; i++) { |
| 802 | if (S_ISGITLINK(istate->cache[i]->ce_mode)) |
| 803 | continue; |
| 804 | istate->cache[i]->ce_flags |= CE_FSMONITOR_VALID; |
| 805 | } |
| 806 | |
| 807 | /* Mark all previously saved entries as dirty */ |
| 808 | assert_index_minimum(istate, istate->fsmonitor_dirty->bit_size); |
| 809 | ewah_each_bit(istate->fsmonitor_dirty, fsmonitor_ewah_callback, istate); |
| 810 | |
| 811 | refresh_fsmonitor(istate); |
| 812 | } |
| 813 | |
| 814 | ewah_free(istate->fsmonitor_dirty); |
| 815 | istate->fsmonitor_dirty = NULL; |
| 816 | } |
| 817 | |
| 818 | if (fsmonitor_enabled) |
| 819 | add_fsmonitor(istate); |
| 820 | else |
| 821 | remove_fsmonitor(istate); |
| 822 | } |