refs/debug.c

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