refs/debug.c

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