Enhance hold_lock_file_for_{update,append}() API

This changes the "die_on_error" boolean parameter to a mere "flags", and
changes the existing callers of hold_lock_file_for_update/append()
functions to pass LOCK_DIE_ON_ERROR.

Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin-commit.c b/builtin-commit.c
index e2a7e48b1ce97a74ef73a1feb53a9b9248cf8668..b563a0d67cedc66825692863d9e57001fba35348 100644 (file)
--- a/builtin-commit.c
+++ b/builtin-commit.c
@@ -320,7 +320,8 @@ static char *prepare_index(int argc, const char **argv, const char *prefix)
                die("unable to write new_index file");
 
        fd = hold_lock_file_for_update(&false_lock,
                die("unable to write new_index file");
 
        fd = hold_lock_file_for_update(&false_lock,

-                                      git_path("next-index-%d", getpid()), 1);
+                                      git_path("next-index-%d", getpid()),
+                                      LOCK_DIE_ON_ERROR);

 
        create_base_index();
        add_remove_files(&partial);
 
        create_base_index();
        add_remove_files(&partial);

diff --git a/builtin-fetch-pack.c b/builtin-fetch-pack.c
index 85509f5ee5884589980c9a1c5f96b66a3d49d5dd..21ce3e016314e0c8500c9010b2ff214b1e05e022 100644 (file)
--- a/builtin-fetch-pack.c
+++ b/builtin-fetch-pack.c
@@ -813,7 +813,8 @@ struct ref *fetch_pack(struct fetch_pack_args *my_args,
                          )
                        die("shallow file was changed during fetch");
 
                          )
                        die("shallow file was changed during fetch");
 

-               fd = hold_lock_file_for_update(&lock, shallow, 1);
+               fd = hold_lock_file_for_update(&lock, shallow,
+                                              LOCK_DIE_ON_ERROR);

                if (!write_shallow_commits(fd, 0)) {
                        unlink(shallow);
                        rollback_lock_file(&lock);
                if (!write_shallow_commits(fd, 0)) {
                        unlink(shallow);
                        rollback_lock_file(&lock);

diff --git a/builtin-revert.c b/builtin-revert.c
index 27881e94937dd79b9a0524eb2d9770427ec4f4fb..e839387629461be24c0bf1dacaa3cdb48cb2a5f4 100644 (file)
--- a/builtin-revert.c
+++ b/builtin-revert.c
@@ -338,7 +338,8 @@ static int revert_or_cherry_pick(int argc, const char **argv)
         * reverse of it if we are revert.
         */
 
         * reverse of it if we are revert.
         */
 

-       msg_fd = hold_lock_file_for_update(&msg_file, defmsg, 1);
+       msg_fd = hold_lock_file_for_update(&msg_file, defmsg,
+                                          LOCK_DIE_ON_ERROR);

 
        encoding = get_encoding(message);
        if (!encoding)
 
        encoding = get_encoding(message);
        if (!encoding)

diff --git a/bundle.c b/bundle.c
index 00b2aabefca49b634f49143523ee31556baa7777..7d17a1fde16204859849aaf28945739aaa685f91 100644 (file)
--- a/bundle.c
+++ b/bundle.c
@@ -186,7 +186,8 @@ int create_bundle(struct bundle_header *header, const char *path,
        if (bundle_to_stdout)
                bundle_fd = 1;
        else
        if (bundle_to_stdout)
                bundle_fd = 1;
        else

-               bundle_fd = hold_lock_file_for_update(&lock, path, 1);
+               bundle_fd = hold_lock_file_for_update(&lock, path,
+                                                     LOCK_DIE_ON_ERROR);

 
        /* write signature */
        write_or_die(bundle_fd, bundle_signature, strlen(bundle_signature));
 
        /* write signature */
        write_or_die(bundle_fd, bundle_signature, strlen(bundle_signature));

diff --git a/cache.h b/cache.h
index 884fae826cb8c296520aecbc8c23d9848dacb606..8ab2fd8fd082bc0c263fc055cab8e248b56985e0 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -411,6 +411,8 @@ struct lock_file {
        char on_list;
        char filename[PATH_MAX];
 };
        char on_list;
        char filename[PATH_MAX];
 };

+#define LOCK_DIE_ON_ERROR 1
+#define LOCK_NODEREF 2

 extern int hold_lock_file_for_update(struct lock_file *, const char *path, int);
 extern int hold_lock_file_for_append(struct lock_file *, const char *path, int);
 extern int commit_lock_file(struct lock_file *);
 extern int hold_lock_file_for_update(struct lock_file *, const char *path, int);
 extern int hold_lock_file_for_append(struct lock_file *, const char *path, int);
 extern int commit_lock_file(struct lock_file *);

diff --git a/lockfile.c b/lockfile.c
index 4023797b00fe21ecbabe3407ef8a12fca0690607..6d756086939b631ab13bf4fcdb8deed2787eed6b 100644 (file)
--- a/lockfile.c
+++ b/lockfile.c
@@ -121,15 +121,17 @@ static char *resolve_symlink(char *p, size_t s)
 }
 
 
 }
 
 

-static int lock_file(struct lock_file *lk, const char *path)
+static int lock_file(struct lock_file *lk, const char *path, int flags)

 {
 {

-       if (strlen(path) >= sizeof(lk->filename)) return -1;
+       if (strlen(path) >= sizeof(lk->filename))
+               return -1;

        strcpy(lk->filename, path);
        /*
         * subtract 5 from size to make sure there's room for adding
         * ".lock" for the lock file name
         */
        strcpy(lk->filename, path);
        /*
         * subtract 5 from size to make sure there's room for adding
         * ".lock" for the lock file name
         */

-       resolve_symlink(lk->filename, sizeof(lk->filename)-5);
+       if (!(flags & LOCK_NODEREF))
+               resolve_symlink(lk->filename, sizeof(lk->filename)-5);

        strcat(lk->filename, ".lock");
        lk->fd = open(lk->filename, O_RDWR | O_CREAT | O_EXCL, 0666);
        if (0 <= lk->fd) {
        strcat(lk->filename, ".lock");
        lk->fd = open(lk->filename, O_RDWR | O_CREAT | O_EXCL, 0666);
        if (0 <= lk->fd) {


@@ -155,21 +157,21 @@ static int lock_file(struct lock_file *lk, const char *path)
        return lk->fd;
 }
 
        return lk->fd;
 }
 

-int hold_lock_file_for_update(struct lock_file *lk, const char *path, int die_on_error)
+int hold_lock_file_for_update(struct lock_file *lk, const char *path, int flags)

 {
 {

-       int fd = lock_file(lk, path);
-       if (fd < 0 && die_on_error)
+       int fd = lock_file(lk, path, flags);
+       if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))

                die("unable to create '%s.lock': %s", path, strerror(errno));
        return fd;
 }
 
                die("unable to create '%s.lock': %s", path, strerror(errno));
        return fd;
 }
 

-int hold_lock_file_for_append(struct lock_file *lk, const char *path, int die_on_error)
+int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)

 {
        int fd, orig_fd;
 
 {
        int fd, orig_fd;
 

-       fd = lock_file(lk, path);
+       fd = lock_file(lk, path, flags);

        if (fd < 0) {
        if (fd < 0) {

-               if (die_on_error)
+               if (flags & LOCK_DIE_ON_ERROR)

                        die("unable to create '%s.lock': %s", path, strerror(errno));
                return fd;
        }
                        die("unable to create '%s.lock': %s", path, strerror(errno));
                return fd;
        }


@@ -177,13 +179,13 @@ int hold_lock_file_for_append(struct lock_file *lk, const char *path, int die_on
        orig_fd = open(path, O_RDONLY);
        if (orig_fd < 0) {
                if (errno != ENOENT) {
        orig_fd = open(path, O_RDONLY);
        if (orig_fd < 0) {
                if (errno != ENOENT) {

-                       if (die_on_error)
+                       if (flags & LOCK_DIE_ON_ERROR)

                                die("cannot open '%s' for copying", path);
                        close(fd);
                        return error("cannot open '%s' for copying", path);
                }
        } else if (copy_fd(orig_fd, fd)) {
                                die("cannot open '%s' for copying", path);
                        close(fd);
                        return error("cannot open '%s' for copying", path);
                }
        } else if (copy_fd(orig_fd, fd)) {

-               if (die_on_error)
+               if (flags & LOCK_DIE_ON_ERROR)

                        exit(128);
                close(fd);
                return -1;
                        exit(128);
                close(fd);
                return -1;


@@ -215,7 +217,10 @@ int commit_lock_file(struct lock_file *lk)
 
 int hold_locked_index(struct lock_file *lk, int die_on_error)
 {
 
 int hold_locked_index(struct lock_file *lk, int die_on_error)
 {

-       return hold_lock_file_for_update(lk, get_index_file(), die_on_error);
+       return hold_lock_file_for_update(lk, get_index_file(),
+                                        die_on_error
+                                        ? LOCK_DIE_ON_ERROR
+                                        : 0);

 }
 
 void set_alternate_index_output(const char *name)
 }
 
 void set_alternate_index_output(const char *name)

diff --git a/pack-refs.c b/pack-refs.c
index 848d311c2b2c651dbb14893c260584f00c639357..2c76fb181f64e10c65517224b0c09cb648db81ac 100644 (file)
--- a/pack-refs.c
+++ b/pack-refs.c
@@ -89,7 +89,8 @@ int pack_refs(unsigned int flags)
        memset(&cbdata, 0, sizeof(cbdata));
        cbdata.flags = flags;
 
        memset(&cbdata, 0, sizeof(cbdata));
        cbdata.flags = flags;
 

-       fd = hold_lock_file_for_update(&packed, git_path("packed-refs"), 1);
+       fd = hold_lock_file_for_update(&packed, git_path("packed-refs"),
+                                      LOCK_DIE_ON_ERROR);

        cbdata.refs_file = fdopen(fd, "w");
        if (!cbdata.refs_file)
                die("unable to create ref-pack file structure (%s)",
        cbdata.refs_file = fdopen(fd, "w");
        if (!cbdata.refs_file)
                die("unable to create ref-pack file structure (%s)",

diff --git a/refs.c b/refs.c
index 39a3b23804d2da715c564459bf320be23d41c1bf..9e422dcccbb3d499b55df5f39612b12c3c3f52e0 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -790,7 +790,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char
        struct ref_lock *lock;
        struct stat st;
        int last_errno = 0;
        struct ref_lock *lock;
        struct stat st;
        int last_errno = 0;

-       int type;
+       int type, lflags;

        int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
 
        lock = xcalloc(1, sizeof(struct ref_lock));
        int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
 
        lock = xcalloc(1, sizeof(struct ref_lock));


@@ -830,8 +830,11 @@ static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char
 
        lock->lk = xcalloc(1, sizeof(struct lock_file));
 
 
        lock->lk = xcalloc(1, sizeof(struct lock_file));
 

-       if (flags & REF_NODEREF)
+       lflags = LOCK_DIE_ON_ERROR;
+       if (flags & REF_NODEREF) {

                ref = orig_ref;
                ref = orig_ref;

+               lflags |= LOCK_NODEREF;
+       }

        lock->ref_name = xstrdup(ref);
        lock->orig_ref_name = xstrdup(orig_ref);
        ref_file = git_path("%s", ref);
        lock->ref_name = xstrdup(ref);
        lock->orig_ref_name = xstrdup(orig_ref);
        ref_file = git_path("%s", ref);


@@ -845,8 +848,8 @@ static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char
                error("unable to create directory for %s", ref_file);
                goto error_return;
        }
                error("unable to create directory for %s", ref_file);
                goto error_return;
        }

-       lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, 1);

 
 

+       lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);

        return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
 
  error_return:
        return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
 
  error_return:

diff --git a/rerere.c b/rerere.c
index 323e493dafee46c0d3f95e3c4cd9c4c9b463bbef..2b7a99d729e13b09239f1d9175d3d6c0048821b0 100644 (file)
--- a/rerere.c
+++ b/rerere.c
@@ -346,7 +346,8 @@ int setup_rerere(struct string_list *merge_rr)
                return -1;
 
        merge_rr_path = xstrdup(git_path("MERGE_RR"));
                return -1;
 
        merge_rr_path = xstrdup(git_path("MERGE_RR"));

-       fd = hold_lock_file_for_update(&write_lock, merge_rr_path, 1);
+       fd = hold_lock_file_for_update(&write_lock, merge_rr_path,
+                                      LOCK_DIE_ON_ERROR);

        read_rr(merge_rr);
        return fd;
 }
        read_rr(merge_rr);
        return fd;
 }

diff --git a/sha1_file.c b/sha1_file.c
index e2cb342a32f31be2b9ffc1867fbfd671fe63cef1..5cfae5d1adb8c386d4e38c1960f60fb3357c17b3 100644 (file)
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -385,7 +385,7 @@ static void read_info_alternates(const char * relative_base, int depth)
 void add_to_alternates_file(const char *reference)
 {
        struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
 void add_to_alternates_file(const char *reference)
 {
        struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));

-       int fd = hold_lock_file_for_append(lock, git_path("objects/info/alternates"), 1);
+       int fd = hold_lock_file_for_append(lock, git_path("objects/info/alternates"), LOCK_DIE_ON_ERROR);

        char *alt = mkpath("%s/objects\n", reference);
        write_or_die(fd, alt, strlen(alt));
        if (commit_lock_file(lock))
        char *alt = mkpath("%s/objects\n", reference);
        write_or_die(fd, alt, strlen(alt));
        if (commit_lock_file(lock))

diff --git a/t/t7201-co.sh b/t/t7201-co.sh
index 3f70adaf5a1449f09ca062e45915783d6b6cbf4b..f93478f97ff8d139d4c67690e1c85f098ca90a10 100755 (executable)
--- a/t/t7201-co.sh
+++ b/t/t7201-co.sh
@@ -339,7 +339,7 @@ test_expect_success 'checkout w/--track from non-branch HEAD fails' '
     test "z$(git rev-parse master^0)" = "z$(git rev-parse HEAD)"
 '
 
     test "z$(git rev-parse master^0)" = "z$(git rev-parse HEAD)"
 '
 

-test_expect_failure 'detach a symbolic link HEAD' '
+test_expect_success 'detach a symbolic link HEAD' '

     git checkout master &&
     git config --bool core.prefersymlinkrefs yes &&
     git checkout side &&
     git checkout master &&
     git config --bool core.prefersymlinkrefs yes &&
     git checkout side &&