freshlybakedca.ke
Git fork
1#include "git-compat-util.h"
2#include "hex.h"
3#include "refs-internal.h"
4#include "trace.h"
5
6static struct trace_key trace_refs = TRACE_KEY_INIT(REFS);
7
8struct debug_ref_store {
9 struct ref_store base;
10 struct ref_store *refs;
11};
12
13extern struct ref_storage_be refs_be_debug;
14
15struct ref_store *maybe_debug_wrap_ref_store(const char *gitdir, struct ref_store *store)
16{
17 struct debug_ref_store *res;
18 struct ref_storage_be *be_copy;
19
20 if (!trace_want(&trace_refs)) {
21 return store;
22 }
23 res = xmalloc(sizeof(struct debug_ref_store));
24 be_copy = xmalloc(sizeof(*be_copy));
25 *be_copy = refs_be_debug;
26 /* we never deallocate backends, so safe to copy the pointer. */
27 be_copy->name = store->be->name;
28 trace_printf_key(&trace_refs, "ref_store for %s\n", gitdir);
29 res->refs = store;
30 base_ref_store_init((struct ref_store *)res, store->repo, gitdir,
31 be_copy);
32 return (struct ref_store *)res;
33}
34
35static void debug_release(struct ref_store *refs)
36{
37 struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
38 drefs->refs->be->release(drefs->refs);
39 trace_printf_key(&trace_refs, "release\n");
40}
41
42static int debug_create_on_disk(struct ref_store *refs, int flags, struct strbuf *err)
43{
44 struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
45 int res = drefs->refs->be->create_on_disk(drefs->refs, flags, err);
46 trace_printf_key(&trace_refs, "create_on_disk: %d\n", res);
47 return res;
48}
49
50static int debug_transaction_prepare(struct ref_store *refs,
51 struct ref_transaction *transaction,
52 struct strbuf *err)
53{
54 struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
55 int res;
56 transaction->ref_store = drefs->refs;
57 res = drefs->refs->be->transaction_prepare(drefs->refs, transaction,
58 err);
59 trace_printf_key(&trace_refs, "transaction_prepare: %d \"%s\"\n", res,
60 err->buf);
61 return res;
62}
63
64static void print_update(int i, const char *refname,
65 const struct object_id *old_oid,
66 const struct object_id *new_oid, unsigned int flags,
67 unsigned int type, const char *msg)
68{
69 char o[GIT_MAX_HEXSZ + 1] = "null";
70 char n[GIT_MAX_HEXSZ + 1] = "null";
71 if (old_oid)
72 oid_to_hex_r(o, old_oid);
73 if (new_oid)
74 oid_to_hex_r(n, new_oid);
75
76 type &= 0xf; /* see refs.h REF_* */
77 flags &= REF_HAVE_NEW | REF_HAVE_OLD | REF_NO_DEREF |
78 REF_FORCE_CREATE_REFLOG;
79 trace_printf_key(&trace_refs, "%d: %s %s -> %s (F=0x%x, T=0x%x) \"%s\"\n", i, refname,
80 o, n, flags, type, msg);
81}
82
83static void print_transaction(struct ref_transaction *transaction)
84{
85 trace_printf_key(&trace_refs, "transaction {\n");
86 for (size_t i = 0; i < transaction->nr; i++) {
87 struct ref_update *u = transaction->updates[i];
88 print_update(i, u->refname, &u->old_oid, &u->new_oid, u->flags,
89 u->type, u->msg);
90 }
91 trace_printf_key(&trace_refs, "}\n");
92}
93
94static int debug_transaction_finish(struct ref_store *refs,
95 struct ref_transaction *transaction,
96 struct strbuf *err)
97{
98 struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
99 int res;
100 transaction->ref_store = drefs->refs;
101 res = drefs->refs->be->transaction_finish(drefs->refs, transaction,
102 err);
103 print_transaction(transaction);
104 trace_printf_key(&trace_refs, "finish: %d\n", res);
105 return res;
106}
107
108static int debug_transaction_abort(struct ref_store *refs,
109 struct ref_transaction *transaction,
110 struct strbuf *err)
111{
112 struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
113 int res;
114 transaction->ref_store = drefs->refs;
115 res = drefs->refs->be->transaction_abort(drefs->refs, transaction, err);
116 return res;
117}
118
119static int debug_pack_refs(struct ref_store *ref_store, struct pack_refs_opts *opts)
120{
121 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
122 int res = drefs->refs->be->pack_refs(drefs->refs, opts);
123 trace_printf_key(&trace_refs, "pack_refs: %d\n", res);
124 return res;
125}
126
127static int debug_rename_ref(struct ref_store *ref_store, const char *oldref,
128 const char *newref, const char *logmsg)
129{
130 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
131 int res = drefs->refs->be->rename_ref(drefs->refs, oldref, newref,
132 logmsg);
133 trace_printf_key(&trace_refs, "rename_ref: %s -> %s \"%s\": %d\n", oldref, newref,
134 logmsg, res);
135 return res;
136}
137
138static int debug_copy_ref(struct ref_store *ref_store, const char *oldref,
139 const char *newref, const char *logmsg)
140{
141 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
142 int res =
143 drefs->refs->be->copy_ref(drefs->refs, oldref, newref, logmsg);
144 trace_printf_key(&trace_refs, "copy_ref: %s -> %s \"%s\": %d\n", oldref, newref,
145 logmsg, res);
146 return res;
147}
148
149struct debug_ref_iterator {
150 struct ref_iterator base;
151 struct ref_iterator *iter;
152};
153
154static int debug_ref_iterator_advance(struct ref_iterator *ref_iterator)
155{
156 struct debug_ref_iterator *diter =
157 (struct debug_ref_iterator *)ref_iterator;
158 int res = diter->iter->vtable->advance(diter->iter);
159 if (res)
160 trace_printf_key(&trace_refs, "iterator_advance: (%d)\n", res);
161 else
162 trace_printf_key(&trace_refs, "iterator_advance: %s (0)\n",
163 diter->iter->refname);
164
165 diter->base.refname = diter->iter->refname;
166 diter->base.oid = diter->iter->oid;
167 diter->base.flags = diter->iter->flags;
168 return res;
169}
170
171static int debug_ref_iterator_seek(struct ref_iterator *ref_iterator,
172 const char *refname, unsigned int flags)
173{
174 struct debug_ref_iterator *diter =
175 (struct debug_ref_iterator *)ref_iterator;
176 int res = diter->iter->vtable->seek(diter->iter, refname, flags);
177 trace_printf_key(&trace_refs, "iterator_seek: %s flags: %d: %d\n",
178 refname ? refname : "", flags, res);
179 return res;
180}
181
182static int debug_ref_iterator_peel(struct ref_iterator *ref_iterator,
183 struct object_id *peeled)
184{
185 struct debug_ref_iterator *diter =
186 (struct debug_ref_iterator *)ref_iterator;
187 int res = diter->iter->vtable->peel(diter->iter, peeled);
188 trace_printf_key(&trace_refs, "iterator_peel: %s: %d\n", diter->iter->refname, res);
189 return res;
190}
191
192static void debug_ref_iterator_release(struct ref_iterator *ref_iterator)
193{
194 struct debug_ref_iterator *diter =
195 (struct debug_ref_iterator *)ref_iterator;
196 diter->iter->vtable->release(diter->iter);
197 trace_printf_key(&trace_refs, "iterator_abort\n");
198}
199
200static struct ref_iterator_vtable debug_ref_iterator_vtable = {
201 .advance = debug_ref_iterator_advance,
202 .seek = debug_ref_iterator_seek,
203 .peel = debug_ref_iterator_peel,
204 .release = debug_ref_iterator_release,
205};
206
207static struct ref_iterator *
208debug_ref_iterator_begin(struct ref_store *ref_store, const char *prefix,
209 const char **exclude_patterns, unsigned int flags)
210{
211 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
212 struct ref_iterator *res =
213 drefs->refs->be->iterator_begin(drefs->refs, prefix,
214 exclude_patterns, flags);
215 struct debug_ref_iterator *diter = xcalloc(1, sizeof(*diter));
216 base_ref_iterator_init(&diter->base, &debug_ref_iterator_vtable);
217 diter->iter = res;
218 trace_printf_key(&trace_refs, "ref_iterator_begin: \"%s\" (0x%x)\n",
219 prefix, flags);
220 return &diter->base;
221}
222
223static int debug_read_raw_ref(struct ref_store *ref_store, const char *refname,
224 struct object_id *oid, struct strbuf *referent,
225 unsigned int *type, int *failure_errno)
226{
227 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
228 int res = 0;
229
230 oidcpy(oid, null_oid(ref_store->repo->hash_algo));
231 res = drefs->refs->be->read_raw_ref(drefs->refs, refname, oid, referent,
232 type, failure_errno);
233
234 if (res == 0) {
235 trace_printf_key(&trace_refs, "read_raw_ref: %s: %s (=> %s) type %x: %d\n",
236 refname, oid_to_hex(oid), referent->buf, *type, res);
237 } else {
238 trace_printf_key(&trace_refs,
239 "read_raw_ref: %s: %d (errno %d)\n", refname,
240 res, *failure_errno);
241 }
242 return res;
243}
244
245static int debug_read_symbolic_ref(struct ref_store *ref_store, const char *refname,
246 struct strbuf *referent)
247{
248 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
249 struct ref_store *refs = drefs->refs;
250 int res;
251
252 res = refs->be->read_symbolic_ref(refs, refname, referent);
253 if (!res)
254 trace_printf_key(&trace_refs, "read_symbolic_ref: %s: (%s)\n",
255 refname, referent->buf);
256 else
257 trace_printf_key(&trace_refs,
258 "read_symbolic_ref: %s: %d\n", refname, res);
259 return res;
260
261}
262
263static struct ref_iterator *
264debug_reflog_iterator_begin(struct ref_store *ref_store)
265{
266 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
267 struct ref_iterator *res =
268 drefs->refs->be->reflog_iterator_begin(drefs->refs);
269 trace_printf_key(&trace_refs, "for_each_reflog_iterator_begin\n");
270 return res;
271}
272
273struct debug_reflog {
274 const char *refname;
275 each_reflog_ent_fn *fn;
276 void *cb_data;
277};
278
279static int debug_print_reflog_ent(const char *refname,
280 struct object_id *old_oid,
281 struct object_id *new_oid,
282 const char *committer, timestamp_t timestamp,
283 int tz, const char *msg, void *cb_data)
284{
285 struct debug_reflog *dbg = (struct debug_reflog *)cb_data;
286 int ret;
287 char o[GIT_MAX_HEXSZ + 1] = "null";
288 char n[GIT_MAX_HEXSZ + 1] = "null";
289 char *msgend = strchrnul(msg, '\n');
290 if (old_oid)
291 oid_to_hex_r(o, old_oid);
292 if (new_oid)
293 oid_to_hex_r(n, new_oid);
294
295 ret = dbg->fn(refname, old_oid, new_oid, committer, timestamp, tz, msg,
296 dbg->cb_data);
297 trace_printf_key(&trace_refs,
298 "reflog_ent %s (ret %d): %s -> %s, %s %ld \"%.*s\"\n",
299 dbg->refname, ret, o, n, committer,
300 (long int)timestamp, (int)(msgend - msg), msg);
301 return ret;
302}
303
304static int debug_for_each_reflog_ent(struct ref_store *ref_store,
305 const char *refname, each_reflog_ent_fn fn,
306 void *cb_data)
307{
308 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
309 struct debug_reflog dbg = {
310 .refname = refname,
311 .fn = fn,
312 .cb_data = cb_data,
313 };
314
315 int res = drefs->refs->be->for_each_reflog_ent(
316 drefs->refs, refname, &debug_print_reflog_ent, &dbg);
317 trace_printf_key(&trace_refs, "for_each_reflog: %s: %d\n", refname, res);
318 return res;
319}
320
321static int debug_for_each_reflog_ent_reverse(struct ref_store *ref_store,
322 const char *refname,
323 each_reflog_ent_fn fn,
324 void *cb_data)
325{
326 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
327 struct debug_reflog dbg = {
328 .refname = refname,
329 .fn = fn,
330 .cb_data = cb_data,
331 };
332 int res = drefs->refs->be->for_each_reflog_ent_reverse(
333 drefs->refs, refname, &debug_print_reflog_ent, &dbg);
334 trace_printf_key(&trace_refs, "for_each_reflog_reverse: %s: %d\n", refname, res);
335 return res;
336}
337
338static int debug_reflog_exists(struct ref_store *ref_store, const char *refname)
339{
340 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
341 int res = drefs->refs->be->reflog_exists(drefs->refs, refname);
342 trace_printf_key(&trace_refs, "reflog_exists: %s: %d\n", refname, res);
343 return res;
344}
345
346static int debug_create_reflog(struct ref_store *ref_store, const char *refname,
347 struct strbuf *err)
348{
349 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
350 int res = drefs->refs->be->create_reflog(drefs->refs, refname, err);
351 trace_printf_key(&trace_refs, "create_reflog: %s: %d\n", refname, res);
352 return res;
353}
354
355static int debug_delete_reflog(struct ref_store *ref_store, const char *refname)
356{
357 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
358 int res = drefs->refs->be->delete_reflog(drefs->refs, refname);
359 trace_printf_key(&trace_refs, "delete_reflog: %s: %d\n", refname, res);
360 return res;
361}
362
363struct debug_reflog_expiry_should_prune {
364 reflog_expiry_prepare_fn *prepare;
365 reflog_expiry_should_prune_fn *should_prune;
366 reflog_expiry_cleanup_fn *cleanup;
367 void *cb_data;
368};
369
370static void debug_reflog_expiry_prepare(const char *refname,
371 const struct object_id *oid,
372 void *cb_data)
373{
374 struct debug_reflog_expiry_should_prune *prune = cb_data;
375 trace_printf_key(&trace_refs, "reflog_expire_prepare: %s\n", refname);
376 prune->prepare(refname, oid, prune->cb_data);
377}
378
379static int debug_reflog_expiry_should_prune_fn(struct object_id *ooid,
380 struct object_id *noid,
381 const char *email,
382 timestamp_t timestamp, int tz,
383 const char *message, void *cb_data) {
384 struct debug_reflog_expiry_should_prune *prune = cb_data;
385
386 int result = prune->should_prune(ooid, noid, email, timestamp, tz, message, prune->cb_data);
387 trace_printf_key(&trace_refs, "reflog_expire_should_prune: %s %ld: %d\n", message, (long int) timestamp, result);
388 return result;
389}
390
391static void debug_reflog_expiry_cleanup(void *cb_data)
392{
393 struct debug_reflog_expiry_should_prune *prune = cb_data;
394 prune->cleanup(prune->cb_data);
395}
396
397static int debug_reflog_expire(struct ref_store *ref_store, const char *refname,
398 unsigned int flags,
399 reflog_expiry_prepare_fn prepare_fn,
400 reflog_expiry_should_prune_fn should_prune_fn,
401 reflog_expiry_cleanup_fn cleanup_fn,
402 void *policy_cb_data)
403{
404 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
405 struct debug_reflog_expiry_should_prune prune = {
406 .prepare = prepare_fn,
407 .cleanup = cleanup_fn,
408 .should_prune = should_prune_fn,
409 .cb_data = policy_cb_data,
410 };
411 int res = drefs->refs->be->reflog_expire(drefs->refs, refname,
412 flags, &debug_reflog_expiry_prepare,
413 &debug_reflog_expiry_should_prune_fn,
414 &debug_reflog_expiry_cleanup,
415 &prune);
416 trace_printf_key(&trace_refs, "reflog_expire: %s: %d\n", refname, res);
417 return res;
418}
419
420static int debug_fsck(struct ref_store *ref_store,
421 struct fsck_options *o,
422 struct worktree *wt)
423{
424 struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
425 int res = drefs->refs->be->fsck(drefs->refs, o, wt);
426 trace_printf_key(&trace_refs, "fsck: %d\n", res);
427 return res;
428}
429
430struct ref_storage_be refs_be_debug = {
431 .name = "debug",
432 .init = NULL,
433 .release = debug_release,
434 .create_on_disk = debug_create_on_disk,
435
436 /*
437 * None of these should be NULL. If the "files" backend (in
438 * "struct ref_storage_be refs_be_files" in files-backend.c)
439 * has a function we should also have a wrapper for it here.
440 * Test the output with "GIT_TRACE_REFS=1".
441 */
442 .transaction_prepare = debug_transaction_prepare,
443 .transaction_finish = debug_transaction_finish,
444 .transaction_abort = debug_transaction_abort,
445
446 .pack_refs = debug_pack_refs,
447 .rename_ref = debug_rename_ref,
448 .copy_ref = debug_copy_ref,
449
450 .iterator_begin = debug_ref_iterator_begin,
451 .read_raw_ref = debug_read_raw_ref,
452 .read_symbolic_ref = debug_read_symbolic_ref,
453
454 .reflog_iterator_begin = debug_reflog_iterator_begin,
455 .for_each_reflog_ent = debug_for_each_reflog_ent,
456 .for_each_reflog_ent_reverse = debug_for_each_reflog_ent_reverse,
457 .reflog_exists = debug_reflog_exists,
458 .create_reflog = debug_create_reflog,
459 .delete_reflog = debug_delete_reflog,
460 .reflog_expire = debug_reflog_expire,
461
462 .fsck = debug_fsck,
463};