6 #include "run-command.h"
9 #define INDEX_EXTENSION_VERSION (1)
10 #define HOOK_INTERFACE_VERSION (1)
12 struct trace_key trace_fsmonitor
= TRACE_KEY_INIT(FSMONITOR
);
14 static void fsmonitor_ewah_callback(size_t pos
, void *is
)
16 struct index_state
*istate
= (struct index_state
*)is
;
17 struct cache_entry
*ce
= istate
->cache
[pos
];
19 ce
->ce_flags
&= ~CE_FSMONITOR_VALID
;
22 int read_fsmonitor_extension(struct index_state
*istate
, const void *data
,
25 const char *index
= data
;
28 struct ewah_bitmap
*fsmonitor_dirty
;
31 if (sz
< sizeof(uint32_t) + sizeof(uint64_t) + sizeof(uint32_t))
32 return error("corrupt fsmonitor extension (too short)");
34 hdr_version
= get_be32(index
);
35 index
+= sizeof(uint32_t);
36 if (hdr_version
!= INDEX_EXTENSION_VERSION
)
37 return error("bad fsmonitor version %d", hdr_version
);
39 istate
->fsmonitor_last_update
= get_be64(index
);
40 index
+= sizeof(uint64_t);
42 ewah_size
= get_be32(index
);
43 index
+= sizeof(uint32_t);
45 fsmonitor_dirty
= ewah_new();
46 ret
= ewah_read_mmap(fsmonitor_dirty
, index
, ewah_size
);
47 if (ret
!= ewah_size
) {
48 ewah_free(fsmonitor_dirty
);
49 return error("failed to parse ewah bitmap reading fsmonitor index extension");
51 istate
->fsmonitor_dirty
= fsmonitor_dirty
;
53 trace_printf_key(&trace_fsmonitor
, "read fsmonitor extension successful");
57 void write_fsmonitor_extension(struct strbuf
*sb
, struct index_state
*istate
)
61 struct ewah_bitmap
*bitmap
;
64 uint32_t ewah_size
= 0;
67 put_be32(&hdr_version
, INDEX_EXTENSION_VERSION
);
68 strbuf_add(sb
, &hdr_version
, sizeof(uint32_t));
70 put_be64(&tm
, istate
->fsmonitor_last_update
);
71 strbuf_add(sb
, &tm
, sizeof(uint64_t));
73 strbuf_add(sb
, &ewah_size
, sizeof(uint32_t)); /* we'll fix this up later */
77 for (i
= 0; i
< istate
->cache_nr
; i
++)
78 if (!(istate
->cache
[i
]->ce_flags
& CE_FSMONITOR_VALID
))
80 ewah_serialize_strbuf(bitmap
, sb
);
83 /* fix up size field */
84 put_be32(&ewah_size
, sb
->len
- ewah_start
);
85 memcpy(sb
->buf
+ fixup
, &ewah_size
, sizeof(uint32_t));
87 trace_printf_key(&trace_fsmonitor
, "write fsmonitor extension successful");
91 * Call the query-fsmonitor hook passing the time of the last saved results.
93 static int query_fsmonitor(int version
, uint64_t last_update
, struct strbuf
*query_result
)
95 struct child_process cp
= CHILD_PROCESS_INIT
;
100 if (!(argv
[0] = core_fsmonitor
))
103 snprintf(ver
, sizeof(version
), "%d", version
);
104 snprintf(date
, sizeof(date
), "%" PRIuMAX
, (uintmax_t)last_update
);
110 cp
.dir
= get_git_work_tree();
112 return capture_command(&cp
, query_result
, 1024);
115 static void fsmonitor_refresh_callback(struct index_state
*istate
, const char *name
)
117 int pos
= index_name_pos(istate
, name
, strlen(name
));
120 struct cache_entry
*ce
= istate
->cache
[pos
];
121 ce
->ce_flags
&= ~CE_FSMONITOR_VALID
;
125 * Mark the untracked cache dirty even if it wasn't found in the index
126 * as it could be a new untracked file.
128 trace_printf_key(&trace_fsmonitor
, "fsmonitor_refresh_callback '%s'", name
);
129 untracked_cache_invalidate_path(istate
, name
);
132 void refresh_fsmonitor(struct index_state
*istate
)
134 static int has_run_once
= 0;
135 struct strbuf query_result
= STRBUF_INIT
;
136 int query_success
= 0;
137 size_t bol
; /* beginning of line */
138 uint64_t last_update
;
142 if (!core_fsmonitor
|| has_run_once
)
146 trace_printf_key(&trace_fsmonitor
, "refresh fsmonitor");
148 * This could be racy so save the date/time now and query_fsmonitor
149 * should be inclusive to ensure we don't miss potential changes.
151 last_update
= getnanotime();
154 * If we have a last update time, call query_fsmonitor for the set of
155 * changes since that time, else assume everything is possibly dirty
158 if (istate
->fsmonitor_last_update
) {
159 query_success
= !query_fsmonitor(HOOK_INTERFACE_VERSION
,
160 istate
->fsmonitor_last_update
, &query_result
);
161 trace_performance_since(last_update
, "fsmonitor process '%s'", core_fsmonitor
);
162 trace_printf_key(&trace_fsmonitor
, "fsmonitor process '%s' returned %s",
163 core_fsmonitor
, query_success
? "success" : "failure");
166 /* a fsmonitor process can return '/' to indicate all entries are invalid */
167 if (query_success
&& query_result
.buf
[0] != '/') {
168 /* Mark all entries returned by the monitor as dirty */
169 buf
= query_result
.buf
;
171 for (i
= 0; i
< query_result
.len
; i
++) {
174 fsmonitor_refresh_callback(istate
, buf
+ bol
);
177 if (bol
< query_result
.len
)
178 fsmonitor_refresh_callback(istate
, buf
+ bol
);
180 /* Mark all entries invalid */
181 for (i
= 0; i
< istate
->cache_nr
; i
++)
182 istate
->cache
[i
]->ce_flags
&= ~CE_FSMONITOR_VALID
;
184 if (istate
->untracked
)
185 istate
->untracked
->use_fsmonitor
= 0;
187 strbuf_release(&query_result
);
189 /* Now that we've updated istate, save the last_update time */
190 istate
->fsmonitor_last_update
= last_update
;
193 void add_fsmonitor(struct index_state
*istate
)
197 if (!istate
->fsmonitor_last_update
) {
198 trace_printf_key(&trace_fsmonitor
, "add fsmonitor");
199 istate
->cache_changed
|= FSMONITOR_CHANGED
;
200 istate
->fsmonitor_last_update
= getnanotime();
202 /* reset the fsmonitor state */
203 for (i
= 0; i
< istate
->cache_nr
; i
++)
204 istate
->cache
[i
]->ce_flags
&= ~CE_FSMONITOR_VALID
;
206 /* reset the untracked cache */
207 if (istate
->untracked
) {
208 add_untracked_cache(istate
);
209 istate
->untracked
->use_fsmonitor
= 1;
212 /* Update the fsmonitor state */
213 refresh_fsmonitor(istate
);
217 void remove_fsmonitor(struct index_state
*istate
)
219 if (istate
->fsmonitor_last_update
) {
220 trace_printf_key(&trace_fsmonitor
, "remove fsmonitor");
221 istate
->cache_changed
|= FSMONITOR_CHANGED
;
222 istate
->fsmonitor_last_update
= 0;
226 void tweak_fsmonitor(struct index_state
*istate
)
229 int fsmonitor_enabled
= git_config_get_fsmonitor();
231 if (istate
->fsmonitor_dirty
) {
232 if (fsmonitor_enabled
) {
233 /* Mark all entries valid */
234 for (i
= 0; i
< istate
->cache_nr
; i
++) {
235 istate
->cache
[i
]->ce_flags
|= CE_FSMONITOR_VALID
;
238 /* Mark all previously saved entries as dirty */
239 ewah_each_bit(istate
->fsmonitor_dirty
, fsmonitor_ewah_callback
, istate
);
241 /* Now mark the untracked cache for fsmonitor usage */
242 if (istate
->untracked
)
243 istate
->untracked
->use_fsmonitor
= 1;
246 ewah_free(istate
->fsmonitor_dirty
);
247 istate
->fsmonitor_dirty
= NULL
;
250 switch (fsmonitor_enabled
) {
251 case -1: /* keep: do nothing */
254 remove_fsmonitor(istate
);
257 add_fsmonitor(istate
);
259 default: /* unknown value: do nothing */