builtin/add.c

   1 /*
   2  * "git add" builtin command
   3  *
   4  * Copyright (C) 2006 Linus Torvalds
   5  */
   6 #define USE_THE_INDEX_COMPATIBILITY_MACROS
   7 #include "cache.h"
   8 #include "config.h"
   9 #include "builtin.h"
  10 #include "lockfile.h"
  11 #include "dir.h"
  12 #include "pathspec.h"
  13 #include "exec-cmd.h"
  14 #include "cache-tree.h"
  15 #include "run-command.h"
  16 #include "parse-options.h"
  17 #include "diff.h"
  18 #include "diffcore.h"
  19 #include "revision.h"
  20 #include "bulk-checkin.h"
  21 #include "argv-array.h"
  22 #include "submodule.h"
  23 #include "add-interactive.h"
  24
  25 static const char * const builtin_add_usage[] = {
  26         N_("git add [<options>] [--] <pathspec>..."),
  27         NULL
  28 };
  29 static int patch_interactive, add_interactive, edit_interactive;
  30 static int take_worktree_changes;
  31 static int add_renormalize;
  32 static int pathspec_file_nul;
  33 static const char *pathspec_from_file;
  34 static int legacy_stash_p; /* support for the scripted `git stash` */
  35
  36 struct update_callback_data {
  37         int flags;
  38         int add_errors;
  39 };
  40
  41 static void chmod_pathspec(struct pathspec *pathspec, char flip)
  42 {
  43         int i;
  44
  45         for (i = 0; i < active_nr; i++) {
  46                 struct cache_entry *ce = active_cache[i];
  47
  48                 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
  49                         continue;
  50
  51                 if (chmod_cache_entry(ce, flip) < 0)
  52                         fprintf(stderr, "cannot chmod %cx '%s'\n", flip, ce->name);
  53         }
  54 }
  55
  56 static int fix_unmerged_status(struct diff_filepair *p,
  57                                struct update_callback_data *data)
  58 {
  59         if (p->status != DIFF_STATUS_UNMERGED)
  60                 return p->status;
  61         if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
  62                 /*
  63                  * This is not an explicit add request, and the
  64                  * path is missing from the working tree (deleted)
  65                  */
  66                 return DIFF_STATUS_DELETED;
  67         else
  68                 /*
  69                  * Either an explicit add request, or path exists
  70                  * in the working tree.  An attempt to explicitly
  71                  * add a path that does not exist in the working tree
  72                  * will be caught as an error by the caller immediately.
  73                  */
  74                 return DIFF_STATUS_MODIFIED;
  75 }
  76
  77 static void update_callback(struct diff_queue_struct *q,
  78                             struct diff_options *opt, void *cbdata)
  79 {
  80         int i;
  81         struct update_callback_data *data = cbdata;
  82
  83         for (i = 0; i < q->nr; i++) {
  84                 struct diff_filepair *p = q->queue[i];
  85                 const char *path = p->one->path;
  86                 switch (fix_unmerged_status(p, data)) {
  87                 default:
  88                         die(_("unexpected diff status %c"), p->status);
  89                 case DIFF_STATUS_MODIFIED:
  90                 case DIFF_STATUS_TYPE_CHANGED:
  91                         if (add_file_to_index(&the_index, path, data->flags)) {
  92                                 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
  93                                         die(_("updating files failed"));
  94                                 data->add_errors++;
  95                         }
  96                         break;
  97                 case DIFF_STATUS_DELETED:
  98                         if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
  99                                 break;
 100                         if (!(data->flags & ADD_CACHE_PRETEND))
 101                                 remove_file_from_index(&the_index, path);
 102                         if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
 103                                 printf(_("remove '%s'\n"), path);
 104                         break;
 105                 }
 106         }
 107 }
 108
 109 int add_files_to_cache(const char *prefix,
 110                        const struct pathspec *pathspec, int flags)
 111 {
 112         struct update_callback_data data;
 113         struct rev_info rev;
 114
 115         memset(&data, 0, sizeof(data));
 116         data.flags = flags;
 117
 118         repo_init_revisions(the_repository, &rev, prefix);
 119         setup_revisions(0, NULL, &rev, NULL);
 120         if (pathspec)
 121                 copy_pathspec(&rev.prune_data, pathspec);
 122         rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
 123         rev.diffopt.format_callback = update_callback;
 124         rev.diffopt.format_callback_data = &data;
 125         rev.diffopt.flags.override_submodule_config = 1;
 126         rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
 127         run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
 128         clear_pathspec(&rev.prune_data);
 129         return !!data.add_errors;
 130 }
 131
 132 static int renormalize_tracked_files(const struct pathspec *pathspec, int flags)
 133 {
 134         int i, retval = 0;
 135
 136         for (i = 0; i < active_nr; i++) {
 137                 struct cache_entry *ce = active_cache[i];
 138
 139                 if (ce_stage(ce))
 140                         continue; /* do not touch unmerged paths */
 141                 if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))
 142                         continue; /* do not touch non blobs */
 143                 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
 144                         continue;
 145                 retval |= add_file_to_cache(ce->name, flags | ADD_CACHE_RENORMALIZE);
 146         }
 147
 148         return retval;
 149 }
 150
 151 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
 152 {
 153         char *seen;
 154         int i;
 155         struct dir_entry **src, **dst;
 156
 157         seen = xcalloc(pathspec->nr, 1);
 158
 159         src = dst = dir->entries;
 160         i = dir->nr;
 161         while (--i >= 0) {
 162                 struct dir_entry *entry = *src++;
 163                 if (dir_path_match(&the_index, entry, pathspec, prefix, seen))
 164                         *dst++ = entry;
 165         }
 166         dir->nr = dst - dir->entries;
 167         add_pathspec_matches_against_index(pathspec, &the_index, seen);
 168         return seen;
 169 }
 170
 171 static void refresh(int verbose, const struct pathspec *pathspec)
 172 {
 173         char *seen;
 174         int i;
 175
 176         seen = xcalloc(pathspec->nr, 1);
 177         refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
 178                       pathspec, seen, _("Unstaged changes after refreshing the index:"));
 179         for (i = 0; i < pathspec->nr; i++) {
 180                 if (!seen[i])
 181                         die(_("pathspec '%s' did not match any files"),
 182                             pathspec->items[i].match);
 183         }
 184         free(seen);
 185 }
 186
 187 int run_add_interactive(const char *revision, const char *patch_mode,
 188                         const struct pathspec *pathspec)
 189 {
 190         int status, i;
 191         struct argv_array argv = ARGV_ARRAY_INIT;
 192         int use_builtin_add_i =
 193                 git_env_bool("GIT_TEST_ADD_I_USE_BUILTIN", -1);
 194
 195         if (use_builtin_add_i < 0)
 196                 git_config_get_bool("add.interactive.usebuiltin",
 197                                     &use_builtin_add_i);
 198
 199         if (use_builtin_add_i == 1) {
 200                 enum add_p_mode mode;
 201
 202                 if (!patch_mode)
 203                         return !!run_add_i(the_repository, pathspec);
 204
 205                 if (!strcmp(patch_mode, "--patch"))
 206                         mode = ADD_P_ADD;
 207                 else if (!strcmp(patch_mode, "--patch=stash"))
 208                         mode = ADD_P_STASH;
 209                 else if (!strcmp(patch_mode, "--patch=reset"))
 210                         mode = ADD_P_RESET;
 211                 else if (!strcmp(patch_mode, "--patch=checkout"))
 212                         mode = ADD_P_CHECKOUT;
 213                 else if (!strcmp(patch_mode, "--patch=worktree"))
 214                         mode = ADD_P_WORKTREE;
 215                 else
 216                         die("'%s' not supported", patch_mode);
 217
 218                 return !!run_add_p(the_repository, mode, revision, pathspec);
 219         }
 220
 221         argv_array_push(&argv, "add--interactive");
 222         if (patch_mode)
 223                 argv_array_push(&argv, patch_mode);
 224         if (revision)
 225                 argv_array_push(&argv, revision);
 226         argv_array_push(&argv, "--");
 227         for (i = 0; i < pathspec->nr; i++)
 228                 /* pass original pathspec, to be re-parsed */
 229                 argv_array_push(&argv, pathspec->items[i].original);
 230
 231         status = run_command_v_opt(argv.argv, RUN_GIT_CMD);
 232         argv_array_clear(&argv);
 233         return status;
 234 }
 235
 236 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
 237 {
 238         struct pathspec pathspec;
 239
 240         parse_pathspec(&pathspec, 0,
 241                        PATHSPEC_PREFER_FULL |
 242                        PATHSPEC_SYMLINK_LEADING_PATH |
 243                        PATHSPEC_PREFIX_ORIGIN,
 244                        prefix, argv);
 245
 246         return run_add_interactive(NULL,
 247                                    patch ? "--patch" : NULL,
 248                                    &pathspec);
 249 }
 250
 251 static int edit_patch(int argc, const char **argv, const char *prefix)
 252 {
 253         char *file = git_pathdup("ADD_EDIT.patch");
 254         const char *apply_argv[] = { "apply", "--recount", "--cached",
 255                 NULL, NULL };
 256         struct child_process child = CHILD_PROCESS_INIT;
 257         struct rev_info rev;
 258         int out;
 259         struct stat st;
 260
 261         apply_argv[3] = file;
 262
 263         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 264
 265         if (read_cache() < 0)
 266                 die(_("Could not read the index"));
 267
 268         repo_init_revisions(the_repository, &rev, prefix);
 269         rev.diffopt.context = 7;
 270
 271         argc = setup_revisions(argc, argv, &rev, NULL);
 272         rev.diffopt.output_format = DIFF_FORMAT_PATCH;
 273         rev.diffopt.use_color = 0;
 274         rev.diffopt.flags.ignore_dirty_submodules = 1;
 275         out = open(file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
 276         if (out < 0)
 277                 die(_("Could not open '%s' for writing."), file);
 278         rev.diffopt.file = xfdopen(out, "w");
 279         rev.diffopt.close_file = 1;
 280         if (run_diff_files(&rev, 0))
 281                 die(_("Could not write patch"));
 282
 283         if (launch_editor(file, NULL, NULL))
 284                 die(_("editing patch failed"));
 285
 286         if (stat(file, &st))
 287                 die_errno(_("Could not stat '%s'"), file);
 288         if (!st.st_size)
 289                 die(_("Empty patch. Aborted."));
 290
 291         child.git_cmd = 1;
 292         child.argv = apply_argv;
 293         if (run_command(&child))
 294                 die(_("Could not apply '%s'"), file);
 295
 296         unlink(file);
 297         free(file);
 298         return 0;
 299 }
 300
 301 static const char ignore_error[] =
 302 N_("The following paths are ignored by one of your .gitignore files:\n");
 303
 304 static int verbose, show_only, ignored_too, refresh_only;
 305 static int ignore_add_errors, intent_to_add, ignore_missing;
 306 static int warn_on_embedded_repo = 1;
 307
 308 #define ADDREMOVE_DEFAULT 1
 309 static int addremove = ADDREMOVE_DEFAULT;
 310 static int addremove_explicit = -1; /* unspecified */
 311
 312 static char *chmod_arg;
 313
 314 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
 315 {
 316         /* if we are told to ignore, we are not adding removals */
 317         *(int *)opt->value = !unset ? 0 : 1;
 318         return 0;
 319 }
 320
 321 static struct option builtin_add_options[] = {
 322         OPT__DRY_RUN(&show_only, N_("dry run")),
 323         OPT__VERBOSE(&verbose, N_("be verbose")),
 324         OPT_GROUP(""),
 325         OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
 326         OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
 327         OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
 328         OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files"), 0),
 329         OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 330         OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")),
 331         OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 332         OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 333         { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
 334           NULL /* takes no arguments */,
 335           N_("ignore paths removed in the working tree (same as --no-all)"),
 336           PARSE_OPT_NOARG, ignore_removal_cb },
 337         OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 338         OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 339         OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 340         OPT_STRING(0, "chmod", &chmod_arg, "(+|-)x",
 341                    N_("override the executable bit of the listed files")),
 342         OPT_HIDDEN_BOOL(0, "warn-embedded-repo", &warn_on_embedded_repo,
 343                         N_("warn when adding an embedded repository")),
 344         OPT_HIDDEN_BOOL(0, "legacy-stash-p", &legacy_stash_p,
 345                         N_("backend for `git stash -p`")),
 346         OPT_PATHSPEC_FROM_FILE(&pathspec_from_file),
 347         OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul),
 348         OPT_END(),
 349 };
 350
 351 static int add_config(const char *var, const char *value, void *cb)
 352 {
 353         if (!strcmp(var, "add.ignoreerrors") ||
 354             !strcmp(var, "add.ignore-errors")) {
 355                 ignore_add_errors = git_config_bool(var, value);
 356                 return 0;
 357         }
 358
 359         return git_default_config(var, value, cb);
 360 }
 361
 362 static const char embedded_advice[] = N_(
 363 "You've added another git repository inside your current repository.\n"
 364 "Clones of the outer repository will not contain the contents of\n"
 365 "the embedded repository and will not know how to obtain it.\n"
 366 "If you meant to add a submodule, use:\n"
 367 "\n"
 368 "       git submodule add <url> %s\n"
 369 "\n"
 370 "If you added this path by mistake, you can remove it from the\n"
 371 "index with:\n"
 372 "\n"
 373 "       git rm --cached %s\n"
 374 "\n"
 375 "See \"git help submodule\" for more information."
 376 );
 377
 378 static void check_embedded_repo(const char *path)
 379 {
 380         struct strbuf name = STRBUF_INIT;
 381
 382         if (!warn_on_embedded_repo)
 383                 return;
 384         if (!ends_with(path, "/"))
 385                 return;
 386
 387         /* Drop trailing slash for aesthetics */
 388         strbuf_addstr(&name, path);
 389         strbuf_strip_suffix(&name, "/");
 390
 391         warning(_("adding embedded git repository: %s"), name.buf);
 392         if (advice_add_embedded_repo) {
 393                 advise(embedded_advice, name.buf, name.buf);
 394                 /* there may be multiple entries; advise only once */
 395                 advice_add_embedded_repo = 0;
 396         }
 397
 398         strbuf_release(&name);
 399 }
 400
 401 static int add_files(struct dir_struct *dir, int flags)
 402 {
 403         int i, exit_status = 0;
 404
 405         if (dir->ignored_nr) {
 406                 fprintf(stderr, _(ignore_error));
 407                 for (i = 0; i < dir->ignored_nr; i++)
 408                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 409                 if (advice_add_ignored_file)
 410                         advise(_("Use -f if you really want to add them.\n"
 411                                 "Turn this message off by running\n"
 412                                 "\"git config advice.addIgnoredFile false\""));
 413                 exit_status = 1;
 414         }
 415
 416         for (i = 0; i < dir->nr; i++) {
 417                 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
 418                         if (!ignore_add_errors)
 419                                 die(_("adding files failed"));
 420                         exit_status = 1;
 421                 } else {
 422                         check_embedded_repo(dir->entries[i]->name);
 423                 }
 424         }
 425         return exit_status;
 426 }
 427
 428 int cmd_add(int argc, const char **argv, const char *prefix)
 429 {
 430         int exit_status = 0;
 431         struct pathspec pathspec;
 432         struct dir_struct dir;
 433         int flags;
 434         int add_new_files;
 435         int require_pathspec;
 436         char *seen = NULL;
 437         struct lock_file lock_file = LOCK_INIT;
 438
 439         git_config(add_config, NULL);
 440
 441         argc = parse_options(argc, argv, prefix, builtin_add_options,
 442                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 443         if (patch_interactive)
 444                 add_interactive = 1;
 445         if (add_interactive) {
 446                 if (pathspec_from_file)
 447                         die(_("--pathspec-from-file is incompatible with --interactive/--patch"));
 448                 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
 449         }
 450         if (legacy_stash_p) {
 451                 struct pathspec pathspec;
 452
 453                 parse_pathspec(&pathspec, 0,
 454                         PATHSPEC_PREFER_FULL |
 455                         PATHSPEC_SYMLINK_LEADING_PATH |
 456                         PATHSPEC_PREFIX_ORIGIN,
 457                         prefix, argv);
 458
 459                 return run_add_interactive(NULL, "--patch=stash", &pathspec);
 460         }
 461
 462         if (edit_interactive) {
 463                 if (pathspec_from_file)
 464                         die(_("--pathspec-from-file is incompatible with --edit"));
 465                 return(edit_patch(argc, argv, prefix));
 466         }
 467         argc--;
 468         argv++;
 469
 470         if (0 <= addremove_explicit)
 471                 addremove = addremove_explicit;
 472         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 473                 addremove = 0; /* "-u" was given but not "-A" */
 474
 475         if (addremove && take_worktree_changes)
 476                 die(_("-A and -u are mutually incompatible"));
 477
 478         if (!show_only && ignore_missing)
 479                 die(_("Option --ignore-missing can only be used together with --dry-run"));
 480
 481         if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
 482                           chmod_arg[1] != 'x' || chmod_arg[2]))
 483                 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
 484
 485         add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
 486         require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
 487
 488         hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
 489
 490         /*
 491          * Check the "pathspec '%s' did not match any files" block
 492          * below before enabling new magic.
 493          */
 494         parse_pathspec(&pathspec, PATHSPEC_ATTR,
 495                        PATHSPEC_PREFER_FULL |
 496                        PATHSPEC_SYMLINK_LEADING_PATH,
 497                        prefix, argv);
 498
 499         if (pathspec_from_file) {
 500                 if (pathspec.nr)
 501                         die(_("--pathspec-from-file is incompatible with pathspec arguments"));
 502
 503                 parse_pathspec_file(&pathspec, PATHSPEC_ATTR,
 504                                     PATHSPEC_PREFER_FULL |
 505                                     PATHSPEC_SYMLINK_LEADING_PATH,
 506                                     prefix, pathspec_from_file, pathspec_file_nul);
 507         } else if (pathspec_file_nul) {
 508                 die(_("--pathspec-file-nul requires --pathspec-from-file"));
 509         }
 510
 511         if (require_pathspec && pathspec.nr == 0) {
 512                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 513                 if (advice_add_empty_pathspec)
 514                         advise( _("Maybe you wanted to say 'git add .'?\n"
 515                                 "Turn this message off by running\n"
 516                                 "\"git config advice.addEmptyPathspec false\""));
 517                 return 0;
 518         }
 519
 520         if (!take_worktree_changes && addremove_explicit < 0 && pathspec.nr)
 521                 /* Turn "git add pathspec..." to "git add -A pathspec..." */
 522                 addremove = 1;
 523
 524         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 525                  (show_only ? ADD_CACHE_PRETEND : 0) |
 526                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 527                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 528                  (!(addremove || take_worktree_changes)
 529                   ? ADD_CACHE_IGNORE_REMOVAL : 0));
 530
 531         if (read_cache_preload(&pathspec) < 0)
 532                 die(_("index file corrupt"));
 533
 534         die_in_unpopulated_submodule(&the_index, prefix);
 535         die_path_inside_submodule(&the_index, &pathspec);
 536
 537         if (add_new_files) {
 538                 int baselen;
 539
 540                 /* Set up the default git porcelain excludes */
 541                 memset(&dir, 0, sizeof(dir));
 542                 if (!ignored_too) {
 543                         dir.flags |= DIR_COLLECT_IGNORED;
 544                         setup_standard_excludes(&dir);
 545                 }
 546
 547                 /* This picks up the paths that are not tracked */
 548                 baselen = fill_directory(&dir, &the_index, &pathspec);
 549                 if (pathspec.nr)
 550                         seen = prune_directory(&dir, &pathspec, baselen);
 551         }
 552
 553         if (refresh_only) {
 554                 refresh(verbose, &pathspec);
 555                 goto finish;
 556         }
 557
 558         if (pathspec.nr) {
 559                 int i;
 560
 561                 if (!seen)
 562                         seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
 563
 564                 /*
 565                  * file_exists() assumes exact match
 566                  */
 567                 GUARD_PATHSPEC(&pathspec,
 568                                PATHSPEC_FROMTOP |
 569                                PATHSPEC_LITERAL |
 570                                PATHSPEC_GLOB |
 571                                PATHSPEC_ICASE |
 572                                PATHSPEC_EXCLUDE);
 573
 574                 for (i = 0; i < pathspec.nr; i++) {
 575                         const char *path = pathspec.items[i].match;
 576                         if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
 577                                 continue;
 578                         if (!seen[i] && path[0] &&
 579                             ((pathspec.items[i].magic &
 580                               (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 581                              !file_exists(path))) {
 582                                 if (ignore_missing) {
 583                                         int dtype = DT_UNKNOWN;
 584                                         if (is_excluded(&dir, &the_index, path, &dtype))
 585                                                 dir_add_ignored(&dir, &the_index,
 586                                                                 path, pathspec.items[i].len);
 587                                 } else
 588                                         die(_("pathspec '%s' did not match any files"),
 589                                             pathspec.items[i].original);
 590                         }
 591                 }
 592                 free(seen);
 593         }
 594
 595         plug_bulk_checkin();
 596
 597         if (add_renormalize)
 598                 exit_status |= renormalize_tracked_files(&pathspec, flags);
 599         else
 600                 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
 601
 602         if (add_new_files)
 603                 exit_status |= add_files(&dir, flags);
 604
 605         if (chmod_arg && pathspec.nr)
 606                 chmod_pathspec(&pathspec, chmod_arg[0]);
 607         unplug_bulk_checkin();
 608
 609 finish:
 610         if (write_locked_index(&the_index, &lock_file,
 611                                COMMIT_LOCK | SKIP_IF_UNCHANGED))
 612                 die(_("Unable to write new index file"));
 613
 614         UNLEAK(pathspec);
 615         UNLEAK(dir);
 616         return exit_status;
 617 }