read-cache: new API write_locked_index instead of write_index/write_cache

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/add.c b/builtin/add.c
index 459208a326cd4cebfa813168d81a06c27fc54fc5..4baf3a563510b10e592ff06ae62df2f405413f6c 100644 (file)
--- a/builtin/add.c
+++ b/builtin/add.c
@@ -299,7 +299,6 @@ static int add_files(struct dir_struct *dir, int flags)
 int cmd_add(int argc, const char **argv, const char *prefix)
 {
        int exit_status = 0;
 int cmd_add(int argc, const char **argv, const char *prefix)
 {
        int exit_status = 0;

-       int newfd;

        struct pathspec pathspec;
        struct dir_struct dir;
        int flags;
        struct pathspec pathspec;
        struct dir_struct dir;
        int flags;


@@ -345,7 +344,7 @@ int cmd_add(int argc, const char **argv, const char *prefix)
        add_new_files = !take_worktree_changes && !refresh_only;
        require_pathspec = !take_worktree_changes;
 
        add_new_files = !take_worktree_changes && !refresh_only;
        require_pathspec = !take_worktree_changes;
 

-       newfd = hold_locked_index(&lock_file, 1);
+       hold_locked_index(&lock_file, 1);

 
        flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
                 (show_only ? ADD_CACHE_PRETEND : 0) |
 
        flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
                 (show_only ? ADD_CACHE_PRETEND : 0) |


@@ -443,8 +442,7 @@ int cmd_add(int argc, const char **argv, const char *prefix)
 
 finish:
        if (active_cache_changed) {
 
 finish:
        if (active_cache_changed) {

-               if (write_cache(newfd, active_cache, active_nr) ||
-                   commit_locked_index(&lock_file))
+               if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))

                        die(_("Unable to write new index file"));
        }
 
                        die(_("Unable to write new index file"));
        }
 

diff --git a/builtin/apply.c b/builtin/apply.c
index 87439fad118a2671989120dd5993a17b4541e2db..5e13444f9df7079fc01bc903aa1b40f00a3e5b94 100644 (file)
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -3644,7 +3644,7 @@ static void build_fake_ancestor(struct patch *list, const char *filename)
 {
        struct patch *patch;
        struct index_state result = { NULL };
 {
        struct patch *patch;
        struct index_state result = { NULL };

-       int fd;
+       static struct lock_file lock;

 
        /* Once we start supporting the reverse patch, it may be
         * worth showing the new sha1 prefix, but until then...
 
        /* Once we start supporting the reverse patch, it may be
         * worth showing the new sha1 prefix, but until then...


@@ -3682,8 +3682,8 @@ static void build_fake_ancestor(struct patch *list, const char *filename)
                        die ("Could not add %s to temporary index", name);
        }
 
                        die ("Could not add %s to temporary index", name);
        }
 

-       fd = open(filename, O_WRONLY | O_CREAT, 0666);
-       if (fd < 0 || write_index(&result, fd) || close(fd))
+       hold_lock_file_for_update(&lock, filename, LOCK_DIE_ON_ERROR);
+       if (write_locked_index(&result, &lock, COMMIT_LOCK))

                die ("Could not write temporary index to %s", filename);
 
        discard_index(&result);
                die ("Could not write temporary index to %s", filename);
 
        discard_index(&result);


@@ -4501,8 +4501,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
        }
 
        if (update_index) {
        }
 
        if (update_index) {

-               if (write_cache(newfd, active_cache, active_nr) ||
-                   commit_locked_index(&lock_file))
+               if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))

                        die(_("Unable to write new index file"));
        }
 
                        die(_("Unable to write new index file"));
        }
 

diff --git a/builtin/checkout-index.c b/builtin/checkout-index.c
index 61e75eb60c992e38ddf195abad564a76cbf934cb..9e49bf2f5695f0deaf7184ca7e9ef38059e3d680 100644 (file)
--- a/builtin/checkout-index.c
+++ b/builtin/checkout-index.c
@@ -279,8 +279,7 @@ int cmd_checkout_index(int argc, const char **argv, const char *prefix)
                checkout_all(prefix, prefix_length);
 
        if (0 <= newfd &&
                checkout_all(prefix, prefix_length);
 
        if (0 <= newfd &&

-           (write_cache(newfd, active_cache, active_nr) ||
-            commit_locked_index(&lock_file)))
+           write_locked_index(&the_index, &lock_file, COMMIT_LOCK))

                die("Unable to write new index file");
        return 0;
 }
                die("Unable to write new index file");
        return 0;
 }

diff --git a/builtin/checkout.c b/builtin/checkout.c
index 07cf55530918e8de6ae45e1c9b7e16707c32f844..944a634bc038fb17439f70d75ec78f035fb6db6f 100644 (file)
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -225,7 +225,6 @@ static int checkout_paths(const struct checkout_opts *opts,
        int flag;
        struct commit *head;
        int errs = 0;
        int flag;
        struct commit *head;
        int errs = 0;

-       int newfd;

        struct lock_file *lock_file;
 
        if (opts->track != BRANCH_TRACK_UNSPECIFIED)
        struct lock_file *lock_file;
 
        if (opts->track != BRANCH_TRACK_UNSPECIFIED)


@@ -256,7 +255,7 @@ static int checkout_paths(const struct checkout_opts *opts,
 
        lock_file = xcalloc(1, sizeof(struct lock_file));
 
 
        lock_file = xcalloc(1, sizeof(struct lock_file));
 

-       newfd = hold_locked_index(lock_file, 1);
+       hold_locked_index(lock_file, 1);

        if (read_cache_preload(&opts->pathspec) < 0)
                return error(_("corrupt index file"));
 
        if (read_cache_preload(&opts->pathspec) < 0)
                return error(_("corrupt index file"));
 


@@ -352,8 +351,7 @@ static int checkout_paths(const struct checkout_opts *opts,
                }
        }
 
                }
        }
 

-       if (write_cache(newfd, active_cache, active_nr) ||
-           commit_locked_index(lock_file))
+       if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))

                die(_("unable to write new index file"));
 
        read_ref_full("HEAD", rev, 0, &flag);
                die(_("unable to write new index file"));
 
        read_ref_full("HEAD", rev, 0, &flag);


@@ -444,8 +442,8 @@ static int merge_working_tree(const struct checkout_opts *opts,
 {
        int ret;
        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 {
        int ret;
        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));

-       int newfd = hold_locked_index(lock_file, 1);

 
 

+       hold_locked_index(lock_file, 1);

        if (read_cache_preload(NULL) < 0)
                return error(_("corrupt index file"));
 
        if (read_cache_preload(NULL) < 0)
                return error(_("corrupt index file"));
 


@@ -553,8 +551,7 @@ static int merge_working_tree(const struct checkout_opts *opts,
                }
        }
 
                }
        }
 

-       if (write_cache(newfd, active_cache, active_nr) ||
-           commit_locked_index(lock_file))
+       if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))

                die(_("unable to write new index file"));
 
        if (!opts->force && !opts->quiet)
                die(_("unable to write new index file"));
 
        if (!opts->force && !opts->quiet)

diff --git a/builtin/clone.c b/builtin/clone.c
index 9b3c04d914b3d318f723c2d3ded403fca9503c07..48f91f5be1035539920871372d5f9330cc8e6489 100644 (file)
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -616,7 +616,7 @@ static int checkout(void)
        struct unpack_trees_options opts;
        struct tree *tree;
        struct tree_desc t;
        struct unpack_trees_options opts;
        struct tree *tree;
        struct tree_desc t;

-       int err = 0, fd;
+       int err = 0;

 
        if (option_no_checkout)
                return 0;
 
        if (option_no_checkout)
                return 0;


@@ -640,7 +640,7 @@ static int checkout(void)
        setup_work_tree();
 
        lock_file = xcalloc(1, sizeof(struct lock_file));
        setup_work_tree();
 
        lock_file = xcalloc(1, sizeof(struct lock_file));

-       fd = hold_locked_index(lock_file, 1);
+       hold_locked_index(lock_file, 1);

 
        memset(&opts, 0, sizeof opts);
        opts.update = 1;
 
        memset(&opts, 0, sizeof opts);
        opts.update = 1;


@@ -656,8 +656,7 @@ static int checkout(void)
        if (unpack_trees(1, &t, &opts) < 0)
                die(_("unable to checkout working tree"));
 
        if (unpack_trees(1, &t, &opts) < 0)
                die(_("unable to checkout working tree"));
 

-       if (write_cache(fd, active_cache, active_nr) ||
-           commit_locked_index(lock_file))
+       if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))

                die(_("unable to write new index file"));
 
        err |= run_hook_le(NULL, "post-checkout", sha1_to_hex(null_sha1),
                die(_("unable to write new index file"));
 
        err |= run_hook_le(NULL, "post-checkout", sha1_to_hex(null_sha1),

diff --git a/builtin/commit.c b/builtin/commit.c
index 9cfef6c6cca61973a4982763e4b834bf1b45cb75..243b0c3300a2370795c53a9c37d27f7c380c0926 100644 (file)
--- a/builtin/commit.c
+++ b/builtin/commit.c
@@ -305,7 +305,6 @@ static void refresh_cache_or_die(int refresh_flags)
 static char *prepare_index(int argc, const char **argv, const char *prefix,
                           const struct commit *current_head, int is_status)
 {
 static char *prepare_index(int argc, const char **argv, const char *prefix,
                           const struct commit *current_head, int is_status)
 {

-       int fd;

        struct string_list partial;
        struct pathspec pathspec;
        int refresh_flags = REFRESH_QUIET;
        struct string_list partial;
        struct pathspec pathspec;
        int refresh_flags = REFRESH_QUIET;


@@ -321,12 +320,11 @@ static char *prepare_index(int argc, const char **argv, const char *prefix,
 
        if (interactive) {
                char *old_index_env = NULL;
 
        if (interactive) {
                char *old_index_env = NULL;

-               fd = hold_locked_index(&index_lock, 1);
+               hold_locked_index(&index_lock, 1);

 
                refresh_cache_or_die(refresh_flags);
 
 
                refresh_cache_or_die(refresh_flags);
 

-               if (write_cache(fd, active_cache, active_nr) ||
-                   close_lock_file(&index_lock))
+               if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))

                        die(_("unable to create temporary index"));
 
                old_index_env = getenv(INDEX_ENVIRONMENT);
                        die(_("unable to create temporary index"));
 
                old_index_env = getenv(INDEX_ENVIRONMENT);


@@ -360,12 +358,11 @@ static char *prepare_index(int argc, const char **argv, const char *prefix,
         * (B) on failure, rollback the real index.
         */
        if (all || (also && pathspec.nr)) {
         * (B) on failure, rollback the real index.
         */
        if (all || (also && pathspec.nr)) {

-               fd = hold_locked_index(&index_lock, 1);
+               hold_locked_index(&index_lock, 1);

                add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
                refresh_cache_or_die(refresh_flags);
                update_main_cache_tree(WRITE_TREE_SILENT);
                add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
                refresh_cache_or_die(refresh_flags);
                update_main_cache_tree(WRITE_TREE_SILENT);

-               if (write_cache(fd, active_cache, active_nr) ||
-                   close_lock_file(&index_lock))
+               if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))

                        die(_("unable to write new_index file"));
                commit_style = COMMIT_NORMAL;
                return index_lock.filename;
                        die(_("unable to write new_index file"));
                commit_style = COMMIT_NORMAL;
                return index_lock.filename;


@@ -381,12 +378,12 @@ static char *prepare_index(int argc, const char **argv, const char *prefix,
         * We still need to refresh the index here.
         */
        if (!only && !pathspec.nr) {
         * We still need to refresh the index here.
         */
        if (!only && !pathspec.nr) {

-               fd = hold_locked_index(&index_lock, 1);
+               hold_locked_index(&index_lock, 1);

                refresh_cache_or_die(refresh_flags);
                if (active_cache_changed) {
                        update_main_cache_tree(WRITE_TREE_SILENT);
                refresh_cache_or_die(refresh_flags);
                if (active_cache_changed) {
                        update_main_cache_tree(WRITE_TREE_SILENT);

-                       if (write_cache(fd, active_cache, active_nr) ||
-                           commit_locked_index(&index_lock))
+                       if (write_locked_index(&the_index, &index_lock,
+                                              COMMIT_LOCK))

                                die(_("unable to write new_index file"));
                } else {
                        rollback_lock_file(&index_lock);
                                die(_("unable to write new_index file"));
                } else {
                        rollback_lock_file(&index_lock);


@@ -432,24 +429,22 @@ static char *prepare_index(int argc, const char **argv, const char *prefix,
        if (read_cache() < 0)
                die(_("cannot read the index"));
 
        if (read_cache() < 0)
                die(_("cannot read the index"));
 

-       fd = hold_locked_index(&index_lock, 1);
+       hold_locked_index(&index_lock, 1);

        add_remove_files(&partial);
        refresh_cache(REFRESH_QUIET);
        add_remove_files(&partial);
        refresh_cache(REFRESH_QUIET);

-       if (write_cache(fd, active_cache, active_nr) ||
-           close_lock_file(&index_lock))
+       if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))

                die(_("unable to write new_index file"));
 
                die(_("unable to write new_index file"));
 

-       fd = hold_lock_file_for_update(&false_lock,
-                                      git_path("next-index-%"PRIuMAX,
-                                               (uintmax_t) getpid()),
-                                      LOCK_DIE_ON_ERROR);
+       hold_lock_file_for_update(&false_lock,
+                                 git_path("next-index-%"PRIuMAX,
+                                          (uintmax_t) getpid()),
+                                 LOCK_DIE_ON_ERROR);

 
        create_base_index(current_head);
        add_remove_files(&partial);
        refresh_cache(REFRESH_QUIET);
 
 
        create_base_index(current_head);
        add_remove_files(&partial);
        refresh_cache(REFRESH_QUIET);
 

-       if (write_cache(fd, active_cache, active_nr) ||
-           close_lock_file(&false_lock))
+       if (write_locked_index(&the_index, &false_lock, CLOSE_LOCK))

                die(_("unable to write temporary index file"));
 
        discard_cache();
                die(_("unable to write temporary index file"));
 
        discard_cache();

diff --git a/builtin/merge.c b/builtin/merge.c
index 66d8843301b22a6a89d9d765e9d3020942e6f672..bf770b6e936d0f0ada5ed423eb127182bf328001 100644 (file)
--- a/builtin/merge.c
+++ b/builtin/merge.c
@@ -657,14 +657,12 @@ static int try_merge_strategy(const char *strategy, struct commit_list *common,
                              struct commit_list *remoteheads,
                              struct commit *head, const char *head_arg)
 {
                              struct commit_list *remoteheads,
                              struct commit *head, const char *head_arg)
 {

-       int index_fd;

        struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
 
        struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
 

-       index_fd = hold_locked_index(lock, 1);
+       hold_locked_index(lock, 1);

        refresh_cache(REFRESH_QUIET);
        if (active_cache_changed &&
        refresh_cache(REFRESH_QUIET);
        if (active_cache_changed &&

-                       (write_cache(index_fd, active_cache, active_nr) ||
-                        commit_locked_index(lock)))
+           write_locked_index(&the_index, lock, COMMIT_LOCK))

                return error(_("Unable to write index."));
        rollback_lock_file(lock);
 
                return error(_("Unable to write index."));
        rollback_lock_file(lock);
 


@@ -672,7 +670,6 @@ static int try_merge_strategy(const char *strategy, struct commit_list *common,
                int clean, x;
                struct commit *result;
                struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
                int clean, x;
                struct commit *result;
                struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));

-               int index_fd;

                struct commit_list *reversed = NULL;
                struct merge_options o;
                struct commit_list *j;
                struct commit_list *reversed = NULL;
                struct merge_options o;
                struct commit_list *j;


@@ -700,12 +697,11 @@ static int try_merge_strategy(const char *strategy, struct commit_list *common,
                for (j = common; j; j = j->next)
                        commit_list_insert(j->item, &reversed);
 
                for (j = common; j; j = j->next)
                        commit_list_insert(j->item, &reversed);
 

-               index_fd = hold_locked_index(lock, 1);
+               hold_locked_index(lock, 1);

                clean = merge_recursive(&o, head,
                                remoteheads->item, reversed, &result);
                if (active_cache_changed &&
                clean = merge_recursive(&o, head,
                                remoteheads->item, reversed, &result);
                if (active_cache_changed &&

-                               (write_cache(index_fd, active_cache, active_nr) ||
-                                commit_locked_index(lock)))
+                   write_locked_index(&the_index, lock, COMMIT_LOCK))

                        die (_("unable to write %s"), get_index_file());
                rollback_lock_file(lock);
                return clean ? 0 : 1;
                        die (_("unable to write %s"), get_index_file());
                rollback_lock_file(lock);
                return clean ? 0 : 1;

diff --git a/builtin/mv.c b/builtin/mv.c
index 2a7243f52e413c821f9f75969edcc0a9822c8e21..db40777396c4ee06a292089451ae7db261c3c3c5 100644 (file)
--- a/builtin/mv.c
+++ b/builtin/mv.c
@@ -63,7 +63,7 @@ static struct lock_file lock_file;
 
 int cmd_mv(int argc, const char **argv, const char *prefix)
 {
 
 int cmd_mv(int argc, const char **argv, const char *prefix)
 {

-       int i, newfd, gitmodules_modified = 0;
+       int i, gitmodules_modified = 0;

        int verbose = 0, show_only = 0, force = 0, ignore_errors = 0;
        struct option builtin_mv_options[] = {
                OPT__VERBOSE(&verbose, N_("be verbose")),
        int verbose = 0, show_only = 0, force = 0, ignore_errors = 0;
        struct option builtin_mv_options[] = {
                OPT__VERBOSE(&verbose, N_("be verbose")),


@@ -85,7 +85,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
        if (--argc < 1)
                usage_with_options(builtin_mv_usage, builtin_mv_options);
 
        if (--argc < 1)
                usage_with_options(builtin_mv_usage, builtin_mv_options);
 

-       newfd = hold_locked_index(&lock_file, 1);
+       hold_locked_index(&lock_file, 1);

        if (read_cache() < 0)
                die(_("index file corrupt"));
 
        if (read_cache() < 0)
                die(_("index file corrupt"));
 


@@ -275,8 +275,7 @@ int cmd_mv(int argc, const char **argv, const char *prefix)
                stage_updated_gitmodules();
 
        if (active_cache_changed) {
                stage_updated_gitmodules();
 
        if (active_cache_changed) {

-               if (write_cache(newfd, active_cache, active_nr) ||
-                   commit_locked_index(&lock_file))
+               if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))

                        die(_("Unable to write new index file"));
        }
 
                        die(_("Unable to write new index file"));
        }
 

diff --git a/builtin/read-tree.c b/builtin/read-tree.c
index 0d7ef847a70581214fb88c3a981581670f7decbe..f26d90f5429e46af074a5cab2fc76e932fdde790 100644 (file)
--- a/builtin/read-tree.c
+++ b/builtin/read-tree.c
@@ -99,7 +99,7 @@ static struct lock_file lock_file;
 
 int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
 {
 
 int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
 {

-       int i, newfd, stage = 0;
+       int i, stage = 0;

        unsigned char sha1[20];
        struct tree_desc t[MAX_UNPACK_TREES];
        struct unpack_trees_options opts;
        unsigned char sha1[20];
        struct tree_desc t[MAX_UNPACK_TREES];
        struct unpack_trees_options opts;


@@ -149,7 +149,7 @@ int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
        argc = parse_options(argc, argv, unused_prefix, read_tree_options,
                             read_tree_usage, 0);
 
        argc = parse_options(argc, argv, unused_prefix, read_tree_options,
                             read_tree_usage, 0);
 

-       newfd = hold_locked_index(&lock_file, 1);
+       hold_locked_index(&lock_file, 1);

 
        prefix_set = opts.prefix ? 1 : 0;
        if (1 < opts.merge + opts.reset + prefix_set)
 
        prefix_set = opts.prefix ? 1 : 0;
        if (1 < opts.merge + opts.reset + prefix_set)


@@ -233,8 +233,7 @@ int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
        if (nr_trees == 1 && !opts.prefix)
                prime_cache_tree(&active_cache_tree, trees[0]);
 
        if (nr_trees == 1 && !opts.prefix)
                prime_cache_tree(&active_cache_tree, trees[0]);
 

-       if (write_cache(newfd, active_cache, active_nr) ||
-           commit_locked_index(&lock_file))
+       if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))

                die("unable to write new index file");
        return 0;
 }
                die("unable to write new index file");
        return 0;
 }

diff --git a/builtin/reset.c b/builtin/reset.c
index f4e087596b6337d2306af4cf45119752b4a049ea..0c56d28e168c24cc1444add7c7ca46bef7d61858 100644 (file)
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -351,7 +351,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
 
        if (reset_type != SOFT) {
                struct lock_file *lock = xcalloc(1, sizeof(*lock));
 
        if (reset_type != SOFT) {
                struct lock_file *lock = xcalloc(1, sizeof(*lock));

-               int newfd = hold_locked_index(lock, 1);
+               hold_locked_index(lock, 1);

                if (reset_type == MIXED) {
                        int flags = quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN;
                        if (read_from_tree(&pathspec, sha1, intent_to_add))
                if (reset_type == MIXED) {
                        int flags = quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN;
                        if (read_from_tree(&pathspec, sha1, intent_to_add))


@@ -367,8 +367,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
                                die(_("Could not reset index file to revision '%s'."), rev);
                }
 
                                die(_("Could not reset index file to revision '%s'."), rev);
                }
 

-               if (write_cache(newfd, active_cache, active_nr) ||
-                   commit_locked_index(lock))
+               if (write_locked_index(&the_index, lock, COMMIT_LOCK))

                        die(_("Could not write new index file."));
        }
 
                        die(_("Could not write new index file."));
        }
 

diff --git a/builtin/rm.c b/builtin/rm.c
index 960634dd0c52f1da689e8a54980e5e81cf2d2f36..bc6490b8bca554c568973997568543e206ffdb3e 100644 (file)
--- a/builtin/rm.c
+++ b/builtin/rm.c
@@ -278,7 +278,7 @@ static struct option builtin_rm_options[] = {
 
 int cmd_rm(int argc, const char **argv, const char *prefix)
 {
 
 int cmd_rm(int argc, const char **argv, const char *prefix)
 {

-       int i, newfd;
+       int i;

        struct pathspec pathspec;
        char *seen;
 
        struct pathspec pathspec;
        char *seen;
 


@@ -293,7 +293,7 @@ int cmd_rm(int argc, const char **argv, const char *prefix)
        if (!index_only)
                setup_work_tree();
 
        if (!index_only)
                setup_work_tree();
 

-       newfd = hold_locked_index(&lock_file, 1);
+       hold_locked_index(&lock_file, 1);

 
        if (read_cache() < 0)
                die(_("index file corrupt"));
 
        if (read_cache() < 0)
                die(_("index file corrupt"));


@@ -427,8 +427,7 @@ int cmd_rm(int argc, const char **argv, const char *prefix)
        }
 
        if (active_cache_changed) {
        }
 
        if (active_cache_changed) {

-               if (write_cache(newfd, active_cache, active_nr) ||
-                   commit_locked_index(&lock_file))
+               if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))

                        die(_("Unable to write new index file"));
        }
 
                        die(_("Unable to write new index file"));
        }
 

diff --git a/builtin/update-index.c b/builtin/update-index.c
index ba54e19cd559018fcca52b5251bffa78165e16a3..42cbe4ba1e4d1553934f13a06bf76156c078c6f0 100644 (file)
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -921,8 +921,7 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
                                exit(128);
                        unable_to_lock_index_die(get_index_file(), lock_error);
                }
                                exit(128);
                        unable_to_lock_index_die(get_index_file(), lock_error);
                }

-               if (write_cache(newfd, active_cache, active_nr) ||
-                   commit_locked_index(lock_file))
+               if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))

                        die("Unable to write new index file");
        }
 
                        die("Unable to write new index file");
        }
 

diff --git a/cache-tree.c b/cache-tree.c
index 7fa524a11323621d24c352b0a1108ae953a60cf5..52f8692efa2367c369d48ae1b61516be26981813 100644 (file)
--- a/cache-tree.c
+++ b/cache-tree.c
@@ -595,8 +595,7 @@ int write_cache_as_tree(unsigned char *sha1, int flags, const char *prefix)
                                      active_nr, flags) < 0)
                        return WRITE_TREE_UNMERGED_INDEX;
                if (0 <= newfd) {
                                      active_nr, flags) < 0)
                        return WRITE_TREE_UNMERGED_INDEX;
                if (0 <= newfd) {

-                       if (!write_cache(newfd, active_cache, active_nr) &&
-                           !commit_lock_file(lock_file))
+                       if (!write_locked_index(&the_index, lock_file, COMMIT_LOCK))

                                newfd = -1;
                }
                /* Not being able to write is fine -- we are only interested
                                newfd = -1;
                }
                /* Not being able to write is fine -- we are only interested

diff --git a/cache.h b/cache.h
index 107ac61b68f15b1e15532c09fda9e9799f830e44..9cc2b97fc308e24f8acae15de182e709cab78f4e 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -301,7 +301,6 @@ extern void free_name_hash(struct index_state *istate);
 #define read_cache_preload(pathspec) read_index_preload(&the_index, (pathspec))
 #define is_cache_unborn() is_index_unborn(&the_index)
 #define read_cache_unmerged() read_index_unmerged(&the_index)
 #define read_cache_preload(pathspec) read_index_preload(&the_index, (pathspec))
 #define is_cache_unborn() is_index_unborn(&the_index)
 #define read_cache_unmerged() read_index_unmerged(&the_index)

-#define write_cache(newfd, cache, entries) write_index(&the_index, (newfd))

 #define discard_cache() discard_index(&the_index)
 #define unmerged_cache() unmerged_index(&the_index)
 #define cache_name_pos(name, namelen) index_name_pos(&the_index,(name),(namelen))
 #define discard_cache() discard_index(&the_index)
 #define unmerged_cache() unmerged_index(&the_index)
 #define cache_name_pos(name, namelen) index_name_pos(&the_index,(name),(namelen))


@@ -456,12 +455,15 @@ extern int daemonize(void);
        } while (0)
 
 /* Initialize and use the cache information */
        } while (0)
 
 /* Initialize and use the cache information */

+struct lock_file;

 extern int read_index(struct index_state *);
 extern int read_index_preload(struct index_state *, const struct pathspec *pathspec);
 extern int read_index_from(struct index_state *, const char *path);
 extern int is_index_unborn(struct index_state *);
 extern int read_index_unmerged(struct index_state *);
 extern int read_index(struct index_state *);
 extern int read_index_preload(struct index_state *, const struct pathspec *pathspec);
 extern int read_index_from(struct index_state *, const char *path);
 extern int is_index_unborn(struct index_state *);
 extern int read_index_unmerged(struct index_state *);

-extern int write_index(struct index_state *, int newfd);
+#define COMMIT_LOCK            (1 << 0)
+#define CLOSE_LOCK             (1 << 1)
+extern int write_locked_index(struct index_state *, struct lock_file *lock, unsigned flags);

 extern int discard_index(struct index_state *);
 extern int unmerged_index(const struct index_state *);
 extern int verify_path(const char *path);
 extern int discard_index(struct index_state *);
 extern int unmerged_index(const struct index_state *);
 extern int verify_path(const char *path);

diff --git a/merge-recursive.c b/merge-recursive.c
index 41770929420da4cba934b0b86b9cd2f55f9cab31..442c1ec0f492a5a0bede39687b97021978a5550a 100644 (file)
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -1986,7 +1986,7 @@ int merge_recursive_generic(struct merge_options *o,
                            const unsigned char **base_list,
                            struct commit **result)
 {
                            const unsigned char **base_list,
                            struct commit **result)
 {

-       int clean, index_fd;
+       int clean;

        struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
        struct commit *head_commit = get_ref(head, o->branch1);
        struct commit *next_commit = get_ref(merge, o->branch2);
        struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
        struct commit *head_commit = get_ref(head, o->branch1);
        struct commit *next_commit = get_ref(merge, o->branch2);


@@ -2003,12 +2003,11 @@ int merge_recursive_generic(struct merge_options *o,
                }
        }
 
                }
        }
 

-       index_fd = hold_locked_index(lock, 1);
+       hold_locked_index(lock, 1);

        clean = merge_recursive(o, head_commit, next_commit, ca,
                        result);
        if (active_cache_changed &&
        clean = merge_recursive(o, head_commit, next_commit, ca,
                        result);
        if (active_cache_changed &&

-                       (write_cache(index_fd, active_cache, active_nr) ||
-                        commit_locked_index(lock)))
+           write_locked_index(&the_index, lock, COMMIT_LOCK))

                return error(_("Unable to write index."));
 
        return clean ? 0 : 1;
                return error(_("Unable to write index."));
 
        return clean ? 0 : 1;

diff --git a/merge.c b/merge.c
index 70f1000fcbef5cb04e5b25791b482b5f40fab204..610725c1044776373cd87e9b7d92903b4bfddc39 100644 (file)
--- a/merge.c
+++ b/merge.c
@@ -66,13 +66,13 @@ int checkout_fast_forward(const unsigned char *head,
        struct tree *trees[MAX_UNPACK_TREES];
        struct unpack_trees_options opts;
        struct tree_desc t[MAX_UNPACK_TREES];
        struct tree *trees[MAX_UNPACK_TREES];
        struct unpack_trees_options opts;
        struct tree_desc t[MAX_UNPACK_TREES];

-       int i, fd, nr_trees = 0;
+       int i, nr_trees = 0;

        struct dir_struct dir;
        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 
        refresh_cache(REFRESH_QUIET);
 
        struct dir_struct dir;
        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 
        refresh_cache(REFRESH_QUIET);
 

-       fd = hold_locked_index(lock_file, 1);
+       hold_locked_index(lock_file, 1);

 
        memset(&trees, 0, sizeof(trees));
        memset(&opts, 0, sizeof(opts));
 
        memset(&trees, 0, sizeof(trees));
        memset(&opts, 0, sizeof(opts));


@@ -105,8 +105,7 @@ int checkout_fast_forward(const unsigned char *head,
        }
        if (unpack_trees(nr_trees, t, &opts))
                return -1;
        }
        if (unpack_trees(nr_trees, t, &opts))
                return -1;

-       if (write_cache(fd, active_cache, active_nr) ||
-               commit_locked_index(lock_file))
+       if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))

                die(_("unable to write new index file"));
        return 0;
 }
                die(_("unable to write new index file"));
        return 0;
 }

diff --git a/read-cache.c b/read-cache.c
index ba13353b377d4f27b9ff6cf1b85811fcca61e224..44d4732b650890255af90b836f48f4bd4bfd451b 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -1779,13 +1779,11 @@ static int has_racy_timestamp(struct index_state *istate)
 void update_index_if_able(struct index_state *istate, struct lock_file *lockfile)
 {
        if ((istate->cache_changed || has_racy_timestamp(istate)) &&
 void update_index_if_able(struct index_state *istate, struct lock_file *lockfile)
 {
        if ((istate->cache_changed || has_racy_timestamp(istate)) &&

-           !write_index(istate, lockfile->fd))
-               commit_locked_index(lockfile);
-       else
+           write_locked_index(istate, lockfile, COMMIT_LOCK))

                rollback_lock_file(lockfile);
 }
 
                rollback_lock_file(lockfile);
 }
 

-int write_index(struct index_state *istate, int newfd)
+static int do_write_index(struct index_state *istate, int newfd)

 {
        git_SHA_CTX c;
        struct cache_header hdr;
 {
        git_SHA_CTX c;
        struct cache_header hdr;


@@ -1877,6 +1875,28 @@ int write_index(struct index_state *istate, int newfd)
        return 0;
 }
 
        return 0;
 }
 

+static int do_write_locked_index(struct index_state *istate, struct lock_file *lock,
+                                unsigned flags)
+{
+       int ret = do_write_index(istate, lock->fd);
+       if (ret)
+               return ret;
+       assert((flags & (COMMIT_LOCK | CLOSE_LOCK)) !=
+              (COMMIT_LOCK | CLOSE_LOCK));
+       if (flags & COMMIT_LOCK)
+               return commit_locked_index(lock);
+       else if (flags & CLOSE_LOCK)
+               return close_lock_file(lock);
+       else
+               return ret;
+}
+
+int write_locked_index(struct index_state *istate, struct lock_file *lock,
+                      unsigned flags)
+{
+       return do_write_locked_index(istate, lock, flags);
+}
+

 /*
  * Read the index file that is potentially unmerged into given
  * index_state, dropping any unmerged entries.  Returns true if
 /*
  * Read the index file that is potentially unmerged into given
  * index_state, dropping any unmerged entries.  Returns true if

diff --git a/rerere.c b/rerere.c
index d55aa8a01b4a4f200f24972795f2887644a06d43..ffc6a5b168304726b5fe326211f26dafa460c7fa 100644 (file)
--- a/rerere.c
+++ b/rerere.c
@@ -492,8 +492,7 @@ static int update_paths(struct string_list *update)
        }
 
        if (!status && active_cache_changed) {
        }
 
        if (!status && active_cache_changed) {

-               if (write_cache(fd, active_cache, active_nr) ||
-                   commit_locked_index(&index_lock))
+               if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK))

                        die("Unable to write new index file");
        } else if (fd >= 0)
                rollback_lock_file(&index_lock);
                        die("Unable to write new index file");
        } else if (fd >= 0)
                rollback_lock_file(&index_lock);

diff --git a/sequencer.c b/sequencer.c
index 7b886a67dd3eb3d45f10fd84306182f2ffbdf857..5ebc461a9b4f131001b186736d94cd52654ce5ce 100644 (file)
--- a/sequencer.c
+++ b/sequencer.c
@@ -294,11 +294,11 @@ static int do_recursive_merge(struct commit *base, struct commit *next,
 {
        struct merge_options o;
        struct tree *result, *next_tree, *base_tree, *head_tree;
 {
        struct merge_options o;
        struct tree *result, *next_tree, *base_tree, *head_tree;

-       int clean, index_fd;
+       int clean;

        const char **xopt;
        static struct lock_file index_lock;
 
        const char **xopt;
        static struct lock_file index_lock;
 

-       index_fd = hold_locked_index(&index_lock, 1);
+       hold_locked_index(&index_lock, 1);

 
        read_cache();
 
 
        read_cache();
 


@@ -319,8 +319,7 @@ static int do_recursive_merge(struct commit *base, struct commit *next,
                            next_tree, base_tree, &result);
 
        if (active_cache_changed &&
                            next_tree, base_tree, &result);
 
        if (active_cache_changed &&

-           (write_cache(index_fd, active_cache, active_nr) ||
-            commit_locked_index(&index_lock)))
+           write_locked_index(&the_index, &index_lock, COMMIT_LOCK))

                /* TRANSLATORS: %s will be "revert" or "cherry-pick" */
                die(_("%s: Unable to write new index file"), action_name(opts));
        rollback_lock_file(&index_lock);
                /* TRANSLATORS: %s will be "revert" or "cherry-pick" */
                die(_("%s: Unable to write new index file"), action_name(opts));
        rollback_lock_file(&index_lock);


@@ -680,8 +679,7 @@ static void read_and_refresh_cache(struct replay_opts *opts)
                die(_("git %s: failed to read the index"), action_name(opts));
        refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
        if (the_index.cache_changed && index_fd >= 0) {
                die(_("git %s: failed to read the index"), action_name(opts));
        refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
        if (the_index.cache_changed && index_fd >= 0) {

-               if (write_index(&the_index, index_fd) ||
-                   commit_locked_index(&index_lock))
+               if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK))

                        die(_("git %s: failed to refresh the index"), action_name(opts));
        }
        rollback_lock_file(&index_lock);
                        die(_("git %s: failed to refresh the index"), action_name(opts));
        }
        rollback_lock_file(&index_lock);

diff --git a/test-scrap-cache-tree.c b/test-scrap-cache-tree.c
index 4728013910cf1a36dac6a594c403c29de60b1fe6..9ebcbca9d25150e9bfca77a73ca45d2a06423f49 100644 (file)
--- a/test-scrap-cache-tree.c
+++ b/test-scrap-cache-tree.c
@@ -6,12 +6,11 @@ static struct lock_file index_lock;
 
 int main(int ac, char **av)
 {
 
 int main(int ac, char **av)
 {

-       int fd = hold_locked_index(&index_lock, 1);
+       hold_locked_index(&index_lock, 1);

        if (read_cache() < 0)
                die("unable to read index file");
        active_cache_tree = NULL;
        if (read_cache() < 0)
                die("unable to read index file");
        active_cache_tree = NULL;

-       if (write_cache(fd, active_cache, active_nr)
-           || commit_lock_file(&index_lock))
+       if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK))

                die("unable to write index file");
        return 0;
 }
                die("unable to write index file");
        return 0;
 }