Merge branch 'ma/lockfile-cleanup'

Code clean-up to adjust to a more recent lockfile API convention that
allows lockfile instances kept on the stack.

* ma/lockfile-cleanup:
lock_file: move static locks into functions
lock_file: make function-local locks non-static
refs.c: do not die if locking fails in `delete_pseudoref()`
refs.c: do not die if locking fails in `write_pseudoref()`
t/helper/test-write-cache: clean up lock-handling

diff --git a/apply.c b/apply.c
index d80b26bc336a51f3cd356c029ef6dd51bee11af5..40b3fae4f648e988b044f6d5c736b87932cad804 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -4058,7 +4058,7 @@ static int build_fake_ancestor(struct apply_state *state, struct patch *list)
 {
        struct patch *patch;
        struct index_state result = { NULL };
-       static struct lock_file lock;
+       struct lock_file lock = LOCK_INIT;
        int res;
 
        /* Once we start supporting the reverse patch, it may be

diff --git a/builtin/add.c b/builtin/add.c
index c9e2619a9ad8febc10e4132c88e7a74c6c9bbeaf..8a155dd41eccd8004a55b1302111293ae59ea542 100644 (file)
--- a/builtin/add.c
+++ b/builtin/add.c
@@ -265,8 +265,6 @@ static int edit_patch(int argc, const char **argv, const char *prefix)
        return 0;
 }
 
-static struct lock_file lock_file;
-
 static const char ignore_error[] =
 N_("The following paths are ignored by one of your .gitignore files:\n");
 
@@ -393,6 +391,7 @@ int cmd_add(int argc, const char **argv, const char *prefix)
        int add_new_files;
        int require_pathspec;
        char *seen = NULL;
+       struct lock_file lock_file = LOCK_INIT;
 
        git_config(add_config, NULL);
 

diff --git a/builtin/describe.c b/builtin/describe.c
index a4160e7f5d1321e08be78f86d63b780a1711616f..cf1ae77d7c705cdfb34bdb5403bad8db4148eccf 100644 (file)
--- a/builtin/describe.c
+++ b/builtin/describe.c
@@ -612,7 +612,7 @@ int cmd_describe(int argc, const char **argv, const char *prefix)
                                suffix = broken;
                        }
                } else if (dirty) {
-                       static struct lock_file index_lock;
+                       struct lock_file index_lock = LOCK_INIT;
                        struct rev_info revs;
                        struct argv_array args = ARGV_ARRAY_INIT;
                        int fd, result;

diff --git a/builtin/difftool.c b/builtin/difftool.c
index aad0e073ee61648a73843ceddffbab6047c9721b..162806f2385c944a3708dd31f38a5d1e2010aa5a 100644 (file)
--- a/builtin/difftool.c
+++ b/builtin/difftool.c
@@ -610,7 +610,7 @@ static int run_dir_diff(const char *extcmd, int symlinks, const char *prefix,
                        continue;
 
                if (!indices_loaded) {
-                       static struct lock_file lock;
+                       struct lock_file lock = LOCK_INIT;
                        strbuf_reset(&buf);
                        strbuf_addf(&buf, "%s/wtindex", tmpdir);
                        if (hold_lock_file_for_update(&lock, buf.buf, 0) < 0 ||

diff --git a/builtin/gc.c b/builtin/gc.c
index c4777b2449e331336bac0baea317adb7c387eefb..ccfb1ceaeb3eb9c6a8cbe9297bceac94fa54bcac 100644 (file)
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@ -373,7 +373,7 @@ static int need_to_gc(void)
 /* return NULL on success, else hostname running the gc */
 static const char *lock_repo_for_gc(int force, pid_t* ret_pid)
 {
-       static struct lock_file lock;
+       struct lock_file lock = LOCK_INIT;
        char my_host[HOST_NAME_MAX + 1];
        struct strbuf sb = STRBUF_INIT;
        struct stat st;

diff --git a/builtin/merge.c b/builtin/merge.c
index 9db5a2cf16e189bb3bd0ceec7d34c6651d630225..de62b2c5c6e61f55eedb9f1dc1b80898bec5e46a 100644 (file)
--- a/builtin/merge.c
+++ b/builtin/merge.c
@@ -647,7 +647,7 @@ static int try_merge_strategy(const char *strategy, struct commit_list *common,
                              struct commit_list *remoteheads,
                              struct commit *head)
 {
-       static struct lock_file lock;
+       struct lock_file lock = LOCK_INIT;
        const char *head_arg = "HEAD";
 
        hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
@@ -805,7 +805,7 @@ static int merge_trivial(struct commit *head, struct commit_list *remoteheads)
 {
        struct object_id result_tree, result_commit;
        struct commit_list *parents, **pptr = &parents;
-       static struct lock_file lock;
+       struct lock_file lock = LOCK_INIT;
 
        hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
        refresh_cache(REFRESH_QUIET);

diff --git a/builtin/mv.c b/builtin/mv.c
index 7a63667d64810c1164cf3acad3cfcc6cedf4010d..80bb967a63f154eb44ebc1a6dd7f833d01dce83e 100644 (file)
--- a/builtin/mv.c
+++ b/builtin/mv.c
@@ -72,7 +72,6 @@ static const char *add_slash(const char *path)
        return path;
 }
 
-static struct lock_file lock_file;
 #define SUBMODULE_WITH_GITDIR ((const char *)1)
 
 static void prepare_move_submodule(const char *src, int first,
@@ -131,6 +130,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
        enum update_mode { BOTH = 0, WORKING_DIRECTORY, INDEX } *modes;
        struct stat st;
        struct string_list src_for_dst = STRING_LIST_INIT_NODUP;
+       struct lock_file lock_file = LOCK_INIT;
 
        git_config(git_default_config, NULL);
 

diff --git a/builtin/read-tree.c b/builtin/read-tree.c
index bf87a2710b31fa49b1802ed297c8ae52eede6354..ebc43eb8057dc9c85aad4c608250ed9a6c4d6cd1 100644 (file)
--- a/builtin/read-tree.c
+++ b/builtin/read-tree.c
@@ -107,8 +107,6 @@ static int git_read_tree_config(const char *var, const char *value, void *cb)
        return git_default_config(var, value, cb);
 }
 
-static struct lock_file lock_file;
-
 int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
 {
        int i, stage = 0;
@@ -116,6 +114,7 @@ int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
        struct tree_desc t[MAX_UNPACK_TREES];
        struct unpack_trees_options opts;
        int prefix_set = 0;
+       struct lock_file lock_file = LOCK_INIT;
        const struct option read_tree_options[] = {
                { OPTION_CALLBACK, 0, "index-output", NULL, N_("file"),
                  N_("write resulting index to <file>"),

diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index 0dd163280d43c9d23e87fecc049ed03332aada0b..132a5339a3eb9d36c0b78cd69d6e492c5b78d545 100644 (file)
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -876,7 +876,7 @@ static void refuse_unconfigured_deny_delete_current(void)
 static int command_singleton_iterator(void *cb_data, struct object_id *oid);
 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 {
-       static struct lock_file shallow_lock;
+       struct lock_file shallow_lock = LOCK_INIT;
        struct oid_array extra = OID_ARRAY_INIT;
        struct check_connected_options opt = CHECK_CONNECTED_INIT;
        uint32_t mask = 1 << (cmd->index % 32);

diff --git a/builtin/rm.c b/builtin/rm.c
index 5b6fc7ee818be4a4f060dc06f12fb45a25a2ea9b..65b448ef8ee91079194841762d4b7a2193eec9a9 100644 (file)
--- a/builtin/rm.c
+++ b/builtin/rm.c
@@ -233,8 +233,6 @@ static int check_local_mod(struct object_id *head, int index_only)
        return errs;
 }
 
-static struct lock_file lock_file;
-
 static int show_only = 0, force = 0, index_only = 0, recursive = 0, quiet = 0;
 static int ignore_unmatch = 0;
 
@@ -251,6 +249,7 @@ static struct option builtin_rm_options[] = {
 
 int cmd_rm(int argc, const char **argv, const char *prefix)
 {
+       struct lock_file lock_file = LOCK_INIT;
        int i;
        struct pathspec pathspec;
        char *seen;

diff --git a/bundle.c b/bundle.c
index 902c9b54485be2000696a697472fa10d97b36153..160bbfdc64ec2876bdc685d253bf537d1c739c1f 100644 (file)
--- a/bundle.c
+++ b/bundle.c
@@ -409,7 +409,7 @@ static int write_bundle_refs(int bundle_fd, struct rev_info *revs)
 int create_bundle(struct bundle_header *header, const char *path,
                  int argc, const char **argv)
 {
-       static struct lock_file lock;
+       struct lock_file lock = LOCK_INIT;
        int bundle_fd = -1;
        int bundle_to_stdout;
        int ref_count = 0;

diff --git a/fast-import.c b/fast-import.c
index b2338fa8eb20d5c52d2bf03d73dca050721c292c..4d55910ab9a0634a553c01643035ef9afe6034c7 100644 (file)
--- a/fast-import.c
+++ b/fast-import.c
@@ -1817,7 +1817,7 @@ static void dump_marks_helper(FILE *f,
 
 static void dump_marks(void)
 {
-       static struct lock_file mark_lock;
+       struct lock_file mark_lock = LOCK_INIT;
        FILE *f;
 
        if (!export_marks_file || (import_marks_file && !import_marks_file_done))

diff --git a/refs.c b/refs.c
index 1f31e6cf00dcb17c1fdf24a98e9575dbd1ba62fc..7013363a902a4e4aebf6a4cbb2cd4e565230eb93 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -660,7 +660,7 @@ static int write_pseudoref(const char *pseudoref, const struct object_id *oid,
 {
        const char *filename;
        int fd;
-       static struct lock_file lock;
+       struct lock_file lock = LOCK_INIT;
        struct strbuf buf = STRBUF_INIT;
        int ret = -1;
 
@@ -670,8 +670,7 @@ static int write_pseudoref(const char *pseudoref, const struct object_id *oid,
        strbuf_addf(&buf, "%s\n", oid_to_hex(oid));
 
        filename = git_path("%s", pseudoref);
-       fd = hold_lock_file_for_update_timeout(&lock, filename,
-                                              LOCK_DIE_ON_ERROR,
+       fd = hold_lock_file_for_update_timeout(&lock, filename, 0,
                                               get_files_ref_lock_timeout_ms());
        if (fd < 0) {
                strbuf_addf(err, "could not open '%s' for writing: %s",
@@ -706,20 +705,23 @@ static int write_pseudoref(const char *pseudoref, const struct object_id *oid,
 
 static int delete_pseudoref(const char *pseudoref, const struct object_id *old_oid)
 {
-       static struct lock_file lock;
        const char *filename;
 
        filename = git_path("%s", pseudoref);
 
        if (old_oid && !is_null_oid(old_oid)) {
+               struct lock_file lock = LOCK_INIT;
                int fd;
                struct object_id actual_old_oid;
 
                fd = hold_lock_file_for_update_timeout(
-                               &lock, filename, LOCK_DIE_ON_ERROR,
+                               &lock, filename, 0,
                                get_files_ref_lock_timeout_ms());
-               if (fd < 0)
-                       die_errno(_("Could not open '%s' for writing"), filename);
+               if (fd < 0) {
+                       error_errno(_("could not open '%s' for writing"),
+                                   filename);
+                       return -1;
+               }
                if (read_ref(pseudoref, &actual_old_oid))
                        die("could not read ref '%s'", pseudoref);
                if (oidcmp(&actual_old_oid, old_oid)) {

diff --git a/refs/files-backend.c b/refs/files-backend.c
index 49d8f67bf132c2357fddcca4b449e28a54ce8f7c..03fb8649c792b9eb1c1a03a405225feee29a9040 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -2991,7 +2991,7 @@ static int files_reflog_expire(struct ref_store *ref_store,
 {
        struct files_ref_store *refs =
                files_downcast(ref_store, REF_STORE_WRITE, "reflog_expire");
-       static struct lock_file reflog_lock;
+       struct lock_file reflog_lock = LOCK_INIT;
        struct expire_reflog_cb cb;
        struct ref_lock *lock;
        struct strbuf log_file_sb = STRBUF_INIT;

diff --git a/rerere.c b/rerere.c
index 18cae2d11c9a86aae0ed352a8f7606b142c5c183..e0862e27786244b1a98723d09475223cc001dd62 100644 (file)
--- a/rerere.c
+++ b/rerere.c
@@ -703,10 +703,9 @@ static int merge(const struct rerere_id *id, const char *path)
        return ret;
 }
 
-static struct lock_file index_lock;
-
 static void update_paths(struct string_list *update)
 {
+       struct lock_file index_lock = LOCK_INIT;
        int i;
 
        hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);

diff --git a/shallow.c b/shallow.c
index df4d44ea7a34a6d6bef119d1494f1c055614cbb1..85313619eac17843513156c911d6b4207e1457fe 100644 (file)
--- a/shallow.c
+++ b/shallow.c
@@ -353,7 +353,7 @@ void advertise_shallow_grafts(int fd)
  */
 void prune_shallow(int show_only)
 {
-       static struct lock_file shallow_lock;
+       struct lock_file shallow_lock = LOCK_INIT;
        struct strbuf sb = STRBUF_INIT;
        int fd;
 

diff --git a/t/helper/test-scrap-cache-tree.c b/t/helper/test-scrap-cache-tree.c
index d26d3e7c8b1a407e2cf40ce20750495f500d5170..393f1604ff954703a2a5e075fbda1e14d0827dc0 100644 (file)
--- a/t/helper/test-scrap-cache-tree.c
+++ b/t/helper/test-scrap-cache-tree.c
@@ -4,10 +4,10 @@
 #include "tree.h"
 #include "cache-tree.h"
 
-static struct lock_file index_lock;
-
 int cmd__scrap_cache_tree(int ac, const char **av)
 {
+       struct lock_file index_lock = LOCK_INIT;
+
        setup_git_directory();
        hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
        if (read_cache() < 0)

diff --git a/t/helper/test-write-cache.c b/t/helper/test-write-cache.c
index 017dc303800d9ba385a9836d85f81445c6b7e8b7..8837717d36a77c04346279b570e1a0a4506fe838 100644 (file)
--- a/t/helper/test-write-cache.c
+++ b/t/helper/test-write-cache.c
@@ -2,22 +2,18 @@
 #include "cache.h"
 #include "lockfile.h"
 
-static struct lock_file index_lock;
-
 int cmd__write_cache(int argc, const char **argv)
 {
-       int i, cnt = 1, lockfd;
+       struct lock_file index_lock = LOCK_INIT;
+       int i, cnt = 1;
        if (argc == 2)
                cnt = strtol(argv[1], NULL, 0);
        setup_git_directory();
        read_cache();
        for (i = 0; i < cnt; i++) {
-               lockfd = hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
-               if (0 <= lockfd) {
-                       write_locked_index(&the_index, &index_lock, COMMIT_LOCK);
-               } else {
-                       rollback_lock_file(&index_lock);
-               }
+               hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
+               if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
+                       die("unable to write index file");
        }
 
        return 0;