Allow to make multiple reflog updates to the same ref during a transaction.
This means we only need to lock the reflog once, during the first update
that touches the reflog, and that all further updates can just write the
reflog entry since the reflog is already locked.

This allows us to write code such as:

t = transaction_begin()
transaction_reflog_update(t, "foo", REFLOG_TRUNCATE, NULL);
loop-over-somehting...
   transaction_reflog_update(t, "foo", 0, <message>);
transaction_commit(t)

where we first truncate the reflog and then build the new content one line at a
time.

Signed-off-by: Ronnie Sahlberg <sahlb...@google.com>
---
 refs.c | 45 ++++++++++++++++++++++++++++++++++++---------
 1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/refs.c b/refs.c
index 2163c90..3b90457 100644
--- a/refs.c
+++ b/refs.c
@@ -2407,6 +2407,11 @@ static void try_remove_empty_parents(char *name)
  * pruned.
  */
 #define REF_ISPRUNING  0x0100
+/*
+ * Only the first reflog update needs to lock the reflog file. Further updates
+ * just use the lock taken by the first update.
+ */
+#define UPDATE_REFLOG_NOLOCK 0x0200
 
 /* make sure nobody touched the ref, and unlink */
 static void prune_ref(struct ref_to_prune *r)
@@ -3413,7 +3418,7 @@ enum transaction_update_type {
        UPDATE_LOG = 1,
 };
 
-/**
+/*
  * Information needed for a single ref update.  Set new_sha1 to the
  * new value or to zero to delete the ref.  To check the old value
  * while locking the ref, set have_old to 1 and set old_sha1 to the
@@ -3423,7 +3428,7 @@ struct ref_update {
        enum transaction_update_type update_type;
        unsigned char new_sha1[20];
        unsigned char old_sha1[20];
-       int flags; /* REF_NODEREF? */
+       int flags; /* REF_NODEREF? or private flags */
        int have_old; /* 1 if old_sha1 is valid, 0 otherwise */
        struct ref_lock *lock;
        int type;
@@ -3431,8 +3436,9 @@ struct ref_update {
 
        /* used by reflog updates */
        int reflog_fd;
-       struct lock_file reflog_lock;
+       struct lock_file *reflog_lock;
        char *committer;
+       struct ref_update *orig_update; /* For UPDATE_REFLOG_NOLOCK */
 
        const char refname[FLEX_ARRAY];
 };
@@ -3514,12 +3520,27 @@ int transaction_update_reflog(struct ref_transaction 
*transaction,
                              struct strbuf *err)
 {
        struct ref_update *update;
+       int i;
 
        if (transaction->state != REF_TRANSACTION_OPEN)
                die("BUG: update_reflog called for transaction that is not "
                    "open");
 
        update = add_update(transaction, refname, UPDATE_LOG);
+       update->flags = flags;
+       for (i = 0; i < transaction->nr - 1; i++) {
+               if (transaction->updates[i]->update_type != UPDATE_LOG)
+                       continue;
+               if (!strcmp(transaction->updates[i]->refname,
+                           update->refname)) {
+                       update->flags |= UPDATE_REFLOG_NOLOCK;
+                       update->orig_update = transaction->updates[i];
+                       break;
+               }
+       }
+       if (!(update->flags & UPDATE_REFLOG_NOLOCK))
+               update->reflog_lock = xcalloc(1, sizeof(struct lock_file));
+
        hashcpy(update->new_sha1, new_sha1);
        hashcpy(update->old_sha1, old_sha1);
        update->reflog_fd = -1;
@@ -3535,7 +3556,6 @@ int transaction_update_reflog(struct ref_transaction 
*transaction,
        }
        if (msg)
                update->msg = xstrdup(msg);
-       update->flags = flags;
 
        return 0;
 }
@@ -3712,10 +3732,15 @@ int transaction_commit(struct ref_transaction 
*transaction,
 
                if (update->update_type != UPDATE_LOG)
                        continue;
+               if (update->flags & UPDATE_REFLOG_NOLOCK) {
+                       update->reflog_fd = update->orig_update->reflog_fd;
+                       update->reflog_lock = update->orig_update->reflog_lock;
+                       continue;
+               }
                update->reflog_fd = hold_lock_file_for_append(
-                                       &update->reflog_lock,
+                                       update->reflog_lock,
                                        git_path("logs/%s", update->refname),
-                                       0);
+                                       LOCK_NODEREF);
                if (update->reflog_fd < 0) {
                        const char *str = "Cannot lock reflog for '%s'. %s";
 
@@ -3781,7 +3806,7 @@ int transaction_commit(struct ref_transaction 
*transaction,
                                ftruncate(update->reflog_fd, 0)) {
                                error("Could not truncate reflog: %s. %s",
                                      update->refname, strerror(errno));
-                               rollback_lock_file(&update->reflog_lock);
+                               rollback_lock_file(update->reflog_lock);
                                update->reflog_fd = -1;
                                continue;
                        }
@@ -3791,7 +3816,7 @@ int transaction_commit(struct ref_transaction 
*transaction,
                                     update->committer, update->msg)) {
                        error("Could write to reflog: %s. %s",
                              update->refname, strerror(errno));
-                       rollback_lock_file(&update->reflog_lock);
+                       rollback_lock_file(update->reflog_lock);
                        update->reflog_fd = -1;
                }
        }
@@ -3802,9 +3827,11 @@ int transaction_commit(struct ref_transaction 
*transaction,
 
                if (update->update_type != UPDATE_LOG)
                        continue;
+               if (update->flags & UPDATE_REFLOG_NOLOCK)
+                       continue;
                if (update->reflog_fd == -1)
                        continue;
-               if (commit_lock_file(&update->reflog_lock)) {
+               if (commit_lock_file(update->reflog_lock)) {
                        error("Could not commit reflog: %s. %s",
                              update->refname, strerror(errno));
                        update->reflog_fd = -1;
-- 
2.0.0.770.gd892650.dirty

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to