refs/debug.c

   1
   2 #include "refs-internal.h"
   3 #include "trace.h"
   4
   5 static struct trace_key trace_refs = TRACE_KEY_INIT(REFS);
   6
   7 struct debug_ref_store {
   8         struct ref_store base;
   9         struct ref_store *refs;
  10 };
  11
  12 extern struct ref_storage_be refs_be_debug;
  13
  14 struct ref_store *maybe_debug_wrap_ref_store(const char *gitdir, struct ref_store *store)
  15 {
  16         struct debug_ref_store *res;
  17         struct ref_storage_be *be_copy;
  18
  19         if (!trace_want(&trace_refs)) {
  20                 return store;
  21         }
  22         res = xmalloc(sizeof(struct debug_ref_store));
  23         be_copy = xmalloc(sizeof(*be_copy));
  24         *be_copy = refs_be_debug;
  25         /* we never deallocate backends, so safe to copy the pointer. */
  26         be_copy->name = store->be->name;
  27         trace_printf_key(&trace_refs, "ref_store for %s\n", gitdir);
  28         res->refs = store;
  29         base_ref_store_init((struct ref_store *)res, store->repo, gitdir,
  30                             be_copy);
  31         return (struct ref_store *)res;
  32 }
  33
  34 static int debug_init_db(struct ref_store *refs, struct strbuf *err)
  35 {
  36         struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
  37         int res = drefs->refs->be->init_db(drefs->refs, err);
  38         trace_printf_key(&trace_refs, "init_db: %d\n", res);
  39         return res;
  40 }
  41
  42 static int debug_transaction_prepare(struct ref_store *refs,
  43                                      struct ref_transaction *transaction,
  44                                      struct strbuf *err)
  45 {
  46         struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
  47         int res;
  48         transaction->ref_store = drefs->refs;
  49         res = drefs->refs->be->transaction_prepare(drefs->refs, transaction,
  50                                                    err);
  51         trace_printf_key(&trace_refs, "transaction_prepare: %d \"%s\"\n", res,
  52                          err->buf);
  53         return res;
  54 }
  55
  56 static void print_update(int i, const char *refname,
  57                          const struct object_id *old_oid,
  58                          const struct object_id *new_oid, unsigned int flags,
  59                          unsigned int type, const char *msg)
  60 {
  61         char o[GIT_MAX_HEXSZ + 1] = "null";
  62         char n[GIT_MAX_HEXSZ + 1] = "null";
  63         if (old_oid)
  64                 oid_to_hex_r(o, old_oid);
  65         if (new_oid)
  66                 oid_to_hex_r(n, new_oid);
  67
  68         type &= 0xf; /* see refs.h REF_* */
  69         flags &= REF_HAVE_NEW | REF_HAVE_OLD | REF_NO_DEREF |
  70                 REF_FORCE_CREATE_REFLOG;
  71         trace_printf_key(&trace_refs, "%d: %s %s -> %s (F=0x%x, T=0x%x) \"%s\"\n", i, refname,
  72                 o, n, flags, type, msg);
  73 }
  74
  75 static void print_transaction(struct ref_transaction *transaction)
  76 {
  77         int i;
  78         trace_printf_key(&trace_refs, "transaction {\n");
  79         for (i = 0; i < transaction->nr; i++) {
  80                 struct ref_update *u = transaction->updates[i];
  81                 print_update(i, u->refname, &u->old_oid, &u->new_oid, u->flags,
  82                              u->type, u->msg);
  83         }
  84         trace_printf_key(&trace_refs, "}\n");
  85 }
  86
  87 static int debug_transaction_finish(struct ref_store *refs,
  88                                     struct ref_transaction *transaction,
  89                                     struct strbuf *err)
  90 {
  91         struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
  92         int res;
  93         transaction->ref_store = drefs->refs;
  94         res = drefs->refs->be->transaction_finish(drefs->refs, transaction,
  95                                                   err);
  96         print_transaction(transaction);
  97         trace_printf_key(&trace_refs, "finish: %d\n", res);
  98         return res;
  99 }
 100
 101 static int debug_transaction_abort(struct ref_store *refs,
 102                                    struct ref_transaction *transaction,
 103                                    struct strbuf *err)
 104 {
 105         struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
 106         int res;
 107         transaction->ref_store = drefs->refs;
 108         res = drefs->refs->be->transaction_abort(drefs->refs, transaction, err);
 109         return res;
 110 }
 111
 112 static int debug_initial_transaction_commit(struct ref_store *refs,
 113                                             struct ref_transaction *transaction,
 114                                             struct strbuf *err)
 115 {
 116         struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
 117         int res;
 118         transaction->ref_store = drefs->refs;
 119         res = drefs->refs->be->initial_transaction_commit(drefs->refs,
 120                                                           transaction, err);
 121         return res;
 122 }
 123
 124 static int debug_pack_refs(struct ref_store *ref_store, unsigned int flags)
 125 {
 126         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 127         int res = drefs->refs->be->pack_refs(drefs->refs, flags);
 128         trace_printf_key(&trace_refs, "pack_refs: %d\n", res);
 129         return res;
 130 }
 131
 132 static int debug_create_symref(struct ref_store *ref_store,
 133                                const char *ref_name, const char *target,
 134                                const char *logmsg)
 135 {
 136         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 137         int res = drefs->refs->be->create_symref(drefs->refs, ref_name, target,
 138                                                  logmsg);
 139         trace_printf_key(&trace_refs, "create_symref: %s -> %s \"%s\": %d\n", ref_name,
 140                 target, logmsg, res);
 141         return res;
 142 }
 143
 144 static int debug_delete_refs(struct ref_store *ref_store, const char *msg,
 145                              struct string_list *refnames, unsigned int flags)
 146 {
 147         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 148         int res =
 149                 drefs->refs->be->delete_refs(drefs->refs, msg, refnames, flags);
 150         int i;
 151         trace_printf_key(&trace_refs, "delete_refs {\n");
 152         for (i = 0; i < refnames->nr; i++)
 153                 trace_printf_key(&trace_refs, "%s\n", refnames->items[i].string);
 154         trace_printf_key(&trace_refs, "}: %d\n", res);
 155         return res;
 156 }
 157
 158 static int debug_rename_ref(struct ref_store *ref_store, const char *oldref,
 159                             const char *newref, const char *logmsg)
 160 {
 161         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 162         int res = drefs->refs->be->rename_ref(drefs->refs, oldref, newref,
 163                                               logmsg);
 164         trace_printf_key(&trace_refs, "rename_ref: %s -> %s \"%s\": %d\n", oldref, newref,
 165                 logmsg, res);
 166         return res;
 167 }
 168
 169 static int debug_copy_ref(struct ref_store *ref_store, const char *oldref,
 170                           const char *newref, const char *logmsg)
 171 {
 172         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 173         int res =
 174                 drefs->refs->be->copy_ref(drefs->refs, oldref, newref, logmsg);
 175         trace_printf_key(&trace_refs, "copy_ref: %s -> %s \"%s\": %d\n", oldref, newref,
 176                 logmsg, res);
 177         return res;
 178 }
 179
 180 struct debug_ref_iterator {
 181         struct ref_iterator base;
 182         struct ref_iterator *iter;
 183 };
 184
 185 static int debug_ref_iterator_advance(struct ref_iterator *ref_iterator)
 186 {
 187         struct debug_ref_iterator *diter =
 188                 (struct debug_ref_iterator *)ref_iterator;
 189         int res = diter->iter->vtable->advance(diter->iter);
 190         if (res)
 191                 trace_printf_key(&trace_refs, "iterator_advance: (%d)\n", res);
 192         else
 193                 trace_printf_key(&trace_refs, "iterator_advance: %s (0)\n",
 194                         diter->iter->refname);
 195
 196         diter->base.ordered = diter->iter->ordered;
 197         diter->base.refname = diter->iter->refname;
 198         diter->base.oid = diter->iter->oid;
 199         diter->base.flags = diter->iter->flags;
 200         return res;
 201 }
 202
 203 static int debug_ref_iterator_peel(struct ref_iterator *ref_iterator,
 204                                    struct object_id *peeled)
 205 {
 206         struct debug_ref_iterator *diter =
 207                 (struct debug_ref_iterator *)ref_iterator;
 208         int res = diter->iter->vtable->peel(diter->iter, peeled);
 209         trace_printf_key(&trace_refs, "iterator_peel: %s: %d\n", diter->iter->refname, res);
 210         return res;
 211 }
 212
 213 static int debug_ref_iterator_abort(struct ref_iterator *ref_iterator)
 214 {
 215         struct debug_ref_iterator *diter =
 216                 (struct debug_ref_iterator *)ref_iterator;
 217         int res = diter->iter->vtable->abort(diter->iter);
 218         trace_printf_key(&trace_refs, "iterator_abort: %d\n", res);
 219         return res;
 220 }
 221
 222 static struct ref_iterator_vtable debug_ref_iterator_vtable = {
 223         debug_ref_iterator_advance, debug_ref_iterator_peel,
 224         debug_ref_iterator_abort
 225 };
 226
 227 static struct ref_iterator *
 228 debug_ref_iterator_begin(struct ref_store *ref_store, const char *prefix,
 229                          unsigned int flags)
 230 {
 231         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 232         struct ref_iterator *res =
 233                 drefs->refs->be->iterator_begin(drefs->refs, prefix, flags);
 234         struct debug_ref_iterator *diter = xcalloc(1, sizeof(*diter));
 235         base_ref_iterator_init(&diter->base, &debug_ref_iterator_vtable, 1);
 236         diter->iter = res;
 237         trace_printf_key(&trace_refs, "ref_iterator_begin: \"%s\" (0x%x)\n",
 238                          prefix, flags);
 239         return &diter->base;
 240 }
 241
 242 static int debug_read_raw_ref(struct ref_store *ref_store, const char *refname,
 243                               struct object_id *oid, struct strbuf *referent,
 244                               unsigned int *type, int *failure_errno)
 245 {
 246         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 247         int res = 0;
 248
 249         oidcpy(oid, null_oid());
 250         res = drefs->refs->be->read_raw_ref(drefs->refs, refname, oid, referent,
 251                                             type, failure_errno);
 252
 253         if (res == 0) {
 254                 trace_printf_key(&trace_refs, "read_raw_ref: %s: %s (=> %s) type %x: %d\n",
 255                         refname, oid_to_hex(oid), referent->buf, *type, res);
 256         } else {
 257                 trace_printf_key(&trace_refs,
 258                                  "read_raw_ref: %s: %d (errno %d)\n", refname,
 259                                  res, *failure_errno);
 260         }
 261         return res;
 262 }
 263
 264 static struct ref_iterator *
 265 debug_reflog_iterator_begin(struct ref_store *ref_store)
 266 {
 267         struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
 268         struct ref_iterator *res =
 269                 drefs->refs->be->reflog_iterator_begin(drefs->refs);
 270         trace_printf_key(&trace_refs, "for_each_reflog_iterator_begin\n");
 271         return res;
 272 }
 273
 274 struct debug_reflog {
 275         const char *refname;
 276         each_reflog_ent_fn *fn;
 277         void *cb_data;
 278 };
 279
 280 static int debug_print_reflog_ent(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(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
 304 static 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
 321 static 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
 338 static 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
 346 static 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
 355 static 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
 363 struct 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
 370 static 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
 379 static 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
 391 static 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
 397 static 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
 420 struct ref_storage_be refs_be_debug = {
 421         NULL,
 422         "debug",
 423         NULL,
 424         debug_init_db,
 425         debug_transaction_prepare,
 426         debug_transaction_finish,
 427         debug_transaction_abort,
 428         debug_initial_transaction_commit,
 429
 430         debug_pack_refs,
 431         debug_create_symref,
 432         debug_delete_refs,
 433         debug_rename_ref,
 434         debug_copy_ref,
 435
 436         debug_ref_iterator_begin,
 437         debug_read_raw_ref,
 438
 439         debug_reflog_iterator_begin,
 440         debug_for_each_reflog_ent,
 441         debug_for_each_reflog_ent_reverse,
 442         debug_reflog_exists,
 443         debug_create_reflog,
 444         debug_delete_reflog,
 445         debug_reflog_expire,
 446 };