3 #include "environment.h"
6 #include "object-name.h"
7 #include "parse-options.h"
12 #include "run-command.h"
13 #include "oid-array.h"
19 static GIT_PATH_FUNC(git_path_bisect_terms
, "BISECT_TERMS")
20 static GIT_PATH_FUNC(git_path_bisect_expected_rev
, "BISECT_EXPECTED_REV")
21 static GIT_PATH_FUNC(git_path_bisect_ancestors_ok
, "BISECT_ANCESTORS_OK")
22 static GIT_PATH_FUNC(git_path_bisect_start
, "BISECT_START")
23 static GIT_PATH_FUNC(git_path_bisect_log
, "BISECT_LOG")
24 static GIT_PATH_FUNC(git_path_bisect_names
, "BISECT_NAMES")
25 static GIT_PATH_FUNC(git_path_bisect_first_parent
, "BISECT_FIRST_PARENT")
26 static GIT_PATH_FUNC(git_path_bisect_run
, "BISECT_RUN")
28 #define BUILTIN_GIT_BISECT_START_USAGE \
29 N_("git bisect start [--term-(new|bad)=<term> --term-(old|good)=<term>]" \
30 " [--no-checkout] [--first-parent] [<bad> [<good>...]] [--]" \
32 #define BUILTIN_GIT_BISECT_STATE_USAGE \
33 N_("git bisect (good|bad) [<rev>...]")
34 #define BUILTIN_GIT_BISECT_TERMS_USAGE \
35 "git bisect terms [--term-good | --term-bad]"
36 #define BUILTIN_GIT_BISECT_SKIP_USAGE \
37 N_("git bisect skip [(<rev>|<range>)...]")
38 #define BUILTIN_GIT_BISECT_NEXT_USAGE \
40 #define BUILTIN_GIT_BISECT_RESET_USAGE \
41 N_("git bisect reset [<commit>]")
42 #define BUILTIN_GIT_BISECT_VISUALIZE_USAGE \
43 "git bisect visualize"
44 #define BUILTIN_GIT_BISECT_REPLAY_USAGE \
45 N_("git bisect replay <logfile>")
46 #define BUILTIN_GIT_BISECT_LOG_USAGE \
48 #define BUILTIN_GIT_BISECT_RUN_USAGE \
49 N_("git bisect run <cmd> [<arg>...]")
51 static const char * const git_bisect_usage
[] = {
52 BUILTIN_GIT_BISECT_START_USAGE
,
53 BUILTIN_GIT_BISECT_STATE_USAGE
,
54 BUILTIN_GIT_BISECT_TERMS_USAGE
,
55 BUILTIN_GIT_BISECT_SKIP_USAGE
,
56 BUILTIN_GIT_BISECT_NEXT_USAGE
,
57 BUILTIN_GIT_BISECT_RESET_USAGE
,
58 BUILTIN_GIT_BISECT_VISUALIZE_USAGE
,
59 BUILTIN_GIT_BISECT_REPLAY_USAGE
,
60 BUILTIN_GIT_BISECT_LOG_USAGE
,
61 BUILTIN_GIT_BISECT_RUN_USAGE
,
65 struct add_bisect_ref_data
{
66 struct rev_info
*revs
;
67 unsigned int object_flags
;
75 static void free_terms(struct bisect_terms
*terms
)
77 FREE_AND_NULL(terms
->term_good
);
78 FREE_AND_NULL(terms
->term_bad
);
81 static void set_terms(struct bisect_terms
*terms
, const char *bad
,
84 free((void *)terms
->term_good
);
85 terms
->term_good
= xstrdup(good
);
86 free((void *)terms
->term_bad
);
87 terms
->term_bad
= xstrdup(bad
);
90 static const char vocab_bad
[] = "bad|new";
91 static const char vocab_good
[] = "good|old";
93 static int bisect_autostart(struct bisect_terms
*terms
);
96 * Check whether the string `term` belongs to the set of strings
97 * included in the variable arguments.
100 static int one_of(const char *term
, ...)
106 va_start(matches
, term
);
107 while (!res
&& (match
= va_arg(matches
, const char *)))
108 res
= !strcmp(term
, match
);
115 * return code BISECT_INTERNAL_SUCCESS_MERGE_BASE
116 * and BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND are codes
117 * that indicate special success.
120 static int is_bisect_success(enum bisect_error res
)
123 res
== BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
||
124 res
== BISECT_INTERNAL_SUCCESS_MERGE_BASE
;
127 static int write_in_file(const char *path
, const char *mode
, const char *format
, va_list args
)
132 if (strcmp(mode
, "w") && strcmp(mode
, "a"))
133 BUG("write-in-file does not support '%s' mode", mode
);
134 fp
= fopen(path
, mode
);
136 return error_errno(_("cannot open file '%s' in mode '%s'"), path
, mode
);
137 res
= vfprintf(fp
, format
, args
);
140 int saved_errno
= errno
;
143 return error_errno(_("could not write to file '%s'"), path
);
149 __attribute__((format (printf
, 2, 3)))
150 static int write_to_file(const char *path
, const char *format
, ...)
155 va_start(args
, format
);
156 res
= write_in_file(path
, "w", format
, args
);
162 __attribute__((format (printf
, 2, 3)))
163 static int append_to_file(const char *path
, const char *format
, ...)
168 va_start(args
, format
);
169 res
= write_in_file(path
, "a", format
, args
);
175 static int print_file_to_stdout(const char *path
)
177 int fd
= open(path
, O_RDONLY
);
181 return error_errno(_("cannot open file '%s' for reading"), path
);
182 if (copy_fd(fd
, 1) < 0)
183 ret
= error_errno(_("failed to read '%s'"), path
);
188 static int check_term_format(const char *term
, const char *orig_term
)
191 char *new_term
= xstrfmt("refs/bisect/%s", term
);
193 res
= check_refname_format(new_term
, 0);
197 return error(_("'%s' is not a valid term"), term
);
199 if (one_of(term
, "help", "start", "skip", "next", "reset",
200 "visualize", "view", "replay", "log", "run", "terms", NULL
))
201 return error(_("can't use the builtin command '%s' as a term"), term
);
204 * In theory, nothing prevents swapping completely good and bad,
205 * but this situation could be confusing and hasn't been tested
206 * enough. Forbid it for now.
209 if ((strcmp(orig_term
, "bad") && one_of(term
, "bad", "new", NULL
)) ||
210 (strcmp(orig_term
, "good") && one_of(term
, "good", "old", NULL
)))
211 return error(_("can't change the meaning of the term '%s'"), term
);
216 static int write_terms(const char *bad
, const char *good
)
220 if (!strcmp(bad
, good
))
221 return error(_("please use two different terms"));
223 if (check_term_format(bad
, "bad") || check_term_format(good
, "good"))
226 res
= write_to_file(git_path_bisect_terms(), "%s\n%s\n", bad
, good
);
231 static int bisect_reset(const char *commit
)
233 struct strbuf branch
= STRBUF_INIT
;
236 if (!strbuf_read_file(&branch
, git_path_bisect_start(), 0))
237 printf(_("We are not bisecting.\n"));
239 strbuf_rtrim(&branch
);
241 struct object_id oid
;
243 if (repo_get_oid_commit(the_repository
, commit
, &oid
))
244 return error(_("'%s' is not a valid commit"), commit
);
245 strbuf_addstr(&branch
, commit
);
248 if (branch
.len
&& !ref_exists("BISECT_HEAD")) {
249 struct child_process cmd
= CHILD_PROCESS_INIT
;
252 strvec_pushl(&cmd
.args
, "checkout", "--ignore-other-worktrees",
253 branch
.buf
, "--", NULL
);
254 if (run_command(&cmd
)) {
255 error(_("could not check out original"
256 " HEAD '%s'. Try 'git bisect"
257 " reset <commit>'."), branch
.buf
);
258 strbuf_release(&branch
);
263 strbuf_release(&branch
);
264 return bisect_clean_state();
267 static void log_commit(FILE *fp
, char *fmt
, const char *state
,
268 struct commit
*commit
)
270 struct pretty_print_context pp
= {0};
271 struct strbuf commit_msg
= STRBUF_INIT
;
272 char *label
= xstrfmt(fmt
, state
);
274 repo_format_commit_message(the_repository
, commit
, "%s", &commit_msg
,
277 fprintf(fp
, "# %s: [%s] %s\n", label
, oid_to_hex(&commit
->object
.oid
),
280 strbuf_release(&commit_msg
);
284 static int bisect_write(const char *state
, const char *rev
,
285 const struct bisect_terms
*terms
, int nolog
)
287 struct strbuf tag
= STRBUF_INIT
;
288 struct object_id oid
;
289 struct commit
*commit
;
293 if (!strcmp(state
, terms
->term_bad
)) {
294 strbuf_addf(&tag
, "refs/bisect/%s", state
);
295 } else if (one_of(state
, terms
->term_good
, "skip", NULL
)) {
296 strbuf_addf(&tag
, "refs/bisect/%s-%s", state
, rev
);
298 res
= error(_("Bad bisect_write argument: %s"), state
);
302 if (repo_get_oid(the_repository
, rev
, &oid
)) {
303 res
= error(_("couldn't get the oid of the rev '%s'"), rev
);
307 if (update_ref(NULL
, tag
.buf
, &oid
, NULL
, 0,
308 UPDATE_REFS_MSG_ON_ERR
)) {
313 fp
= fopen(git_path_bisect_log(), "a");
315 res
= error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
319 commit
= lookup_commit_reference(the_repository
, &oid
);
320 log_commit(fp
, "%s", state
, commit
);
323 fprintf(fp
, "git bisect %s %s\n", state
, rev
);
328 strbuf_release(&tag
);
332 static int check_and_set_terms(struct bisect_terms
*terms
, const char *cmd
)
334 int has_term_file
= !is_empty_or_missing_file(git_path_bisect_terms());
336 if (one_of(cmd
, "skip", "start", "terms", NULL
))
339 if (has_term_file
&& strcmp(cmd
, terms
->term_bad
) &&
340 strcmp(cmd
, terms
->term_good
))
341 return error(_("Invalid command: you're currently in a "
342 "%s/%s bisect"), terms
->term_bad
,
345 if (!has_term_file
) {
346 if (one_of(cmd
, "bad", "good", NULL
)) {
347 set_terms(terms
, "bad", "good");
348 return write_terms(terms
->term_bad
, terms
->term_good
);
350 if (one_of(cmd
, "new", "old", NULL
)) {
351 set_terms(terms
, "new", "old");
352 return write_terms(terms
->term_bad
, terms
->term_good
);
359 static int inc_nr(const char *refname UNUSED
,
360 const struct object_id
*oid UNUSED
,
361 int flag UNUSED
, void *cb_data
)
363 unsigned int *nr
= (unsigned int *)cb_data
;
368 static const char need_bad_and_good_revision_warning
[] =
369 N_("You need to give me at least one %s and %s revision.\n"
370 "You can use \"git bisect %s\" and \"git bisect %s\" for that.");
372 static const char need_bisect_start_warning
[] =
373 N_("You need to start by \"git bisect start\".\n"
374 "You then need to give me at least one %s and %s revision.\n"
375 "You can use \"git bisect %s\" and \"git bisect %s\" for that.");
377 static int decide_next(const struct bisect_terms
*terms
,
378 const char *current_term
, int missing_good
,
381 if (!missing_good
&& !missing_bad
)
386 if (missing_good
&& !missing_bad
&&
387 !strcmp(current_term
, terms
->term_good
)) {
390 * have bad (or new) but not good (or old). We could bisect
391 * although this is less optimum.
393 warning(_("bisecting only with a %s commit"), terms
->term_bad
);
397 * TRANSLATORS: Make sure to include [Y] and [n] in your
398 * translation. The program will only accept English input
401 yesno
= git_prompt(_("Are you sure [Y/n]? "), PROMPT_ECHO
);
402 if (starts_with(yesno
, "N") || starts_with(yesno
, "n"))
407 if (!is_empty_or_missing_file(git_path_bisect_start()))
408 return error(_(need_bad_and_good_revision_warning
),
409 vocab_bad
, vocab_good
, vocab_bad
, vocab_good
);
411 return error(_(need_bisect_start_warning
),
412 vocab_good
, vocab_bad
, vocab_good
, vocab_bad
);
415 static void bisect_status(struct bisect_state
*state
,
416 const struct bisect_terms
*terms
)
418 char *bad_ref
= xstrfmt("refs/bisect/%s", terms
->term_bad
);
419 char *good_glob
= xstrfmt("%s-*", terms
->term_good
);
421 if (ref_exists(bad_ref
))
424 for_each_glob_ref_in(inc_nr
, good_glob
, "refs/bisect/",
425 (void *) &state
->nr_good
);
431 __attribute__((format (printf
, 1, 2)))
432 static void bisect_log_printf(const char *fmt
, ...)
434 struct strbuf buf
= STRBUF_INIT
;
438 strbuf_vaddf(&buf
, fmt
, ap
);
441 printf("%s", buf
.buf
);
442 append_to_file(git_path_bisect_log(), "# %s", buf
.buf
);
444 strbuf_release(&buf
);
447 static void bisect_print_status(const struct bisect_terms
*terms
)
449 struct bisect_state state
= { 0 };
451 bisect_status(&state
, terms
);
453 /* If we had both, we'd already be started, and shouldn't get here. */
454 if (state
.nr_good
&& state
.nr_bad
)
457 if (!state
.nr_good
&& !state
.nr_bad
)
458 bisect_log_printf(_("status: waiting for both good and bad commits\n"));
459 else if (state
.nr_good
)
460 bisect_log_printf(Q_("status: waiting for bad commit, %d good commit known\n",
461 "status: waiting for bad commit, %d good commits known\n",
462 state
.nr_good
), state
.nr_good
);
464 bisect_log_printf(_("status: waiting for good commit(s), bad commit known\n"));
467 static int bisect_next_check(const struct bisect_terms
*terms
,
468 const char *current_term
)
470 struct bisect_state state
= { 0 };
471 bisect_status(&state
, terms
);
472 return decide_next(terms
, current_term
, !state
.nr_good
, !state
.nr_bad
);
475 static int get_terms(struct bisect_terms
*terms
)
477 struct strbuf str
= STRBUF_INIT
;
481 fp
= fopen(git_path_bisect_terms(), "r");
488 strbuf_getline_lf(&str
, fp
);
489 terms
->term_bad
= strbuf_detach(&str
, NULL
);
490 strbuf_getline_lf(&str
, fp
);
491 terms
->term_good
= strbuf_detach(&str
, NULL
);
496 strbuf_release(&str
);
500 static int bisect_terms(struct bisect_terms
*terms
, const char *option
)
502 if (get_terms(terms
))
503 return error(_("no terms defined"));
506 printf(_("Your current terms are %s for the old state\n"
507 "and %s for the new state.\n"),
508 terms
->term_good
, terms
->term_bad
);
511 if (one_of(option
, "--term-good", "--term-old", NULL
))
512 printf("%s\n", terms
->term_good
);
513 else if (one_of(option
, "--term-bad", "--term-new", NULL
))
514 printf("%s\n", terms
->term_bad
);
516 return error(_("invalid argument %s for 'git bisect terms'.\n"
517 "Supported options are: "
518 "--term-good|--term-old and "
519 "--term-bad|--term-new."), option
);
524 static int bisect_append_log_quoted(const char **argv
)
527 FILE *fp
= fopen(git_path_bisect_log(), "a");
528 struct strbuf orig_args
= STRBUF_INIT
;
533 if (fprintf(fp
, "git bisect start") < 1) {
538 sq_quote_argv(&orig_args
, argv
);
539 if (fprintf(fp
, "%s\n", orig_args
.buf
) < 1)
544 strbuf_release(&orig_args
);
548 static int add_bisect_ref(const char *refname
, const struct object_id
*oid
,
549 int flags UNUSED
, void *cb
)
551 struct add_bisect_ref_data
*data
= cb
;
553 add_pending_oid(data
->revs
, refname
, oid
, data
->object_flags
);
558 static int prepare_revs(struct bisect_terms
*terms
, struct rev_info
*revs
)
561 struct add_bisect_ref_data cb
= { revs
};
562 char *good
= xstrfmt("%s-*", terms
->term_good
);
565 * We cannot use terms->term_bad directly in
566 * for_each_glob_ref_in() and we have to append a '*' to it,
567 * otherwise for_each_glob_ref_in() will append '/' and '*'.
569 char *bad
= xstrfmt("%s*", terms
->term_bad
);
572 * It is important to reset the flags used by revision walks
573 * as the previous call to bisect_next_all() in turn
574 * sets up a revision walk.
576 reset_revision_walk();
577 repo_init_revisions(the_repository
, revs
, NULL
);
578 setup_revisions(0, NULL
, revs
, NULL
);
579 for_each_glob_ref_in(add_bisect_ref
, bad
, "refs/bisect/", &cb
);
580 cb
.object_flags
= UNINTERESTING
;
581 for_each_glob_ref_in(add_bisect_ref
, good
, "refs/bisect/", &cb
);
582 if (prepare_revision_walk(revs
))
583 res
= error(_("revision walk setup failed\n"));
590 static int bisect_skipped_commits(struct bisect_terms
*terms
)
594 struct rev_info revs
;
595 struct commit
*commit
;
596 struct pretty_print_context pp
= {0};
597 struct strbuf commit_name
= STRBUF_INIT
;
599 res
= prepare_revs(terms
, &revs
);
603 fp
= fopen(git_path_bisect_log(), "a");
605 return error_errno(_("could not open '%s' for appending"),
606 git_path_bisect_log());
608 if (fprintf(fp
, "# only skipped commits left to test\n") < 0)
609 return error_errno(_("failed to write to '%s'"), git_path_bisect_log());
611 while ((commit
= get_revision(&revs
)) != NULL
) {
612 strbuf_reset(&commit_name
);
613 repo_format_commit_message(the_repository
, commit
, "%s",
615 fprintf(fp
, "# possible first %s commit: [%s] %s\n",
616 terms
->term_bad
, oid_to_hex(&commit
->object
.oid
),
621 * Reset the flags used by revision walks in case
622 * there is another revision walk after this one.
624 reset_revision_walk();
626 strbuf_release(&commit_name
);
627 release_revisions(&revs
);
632 static int bisect_successful(struct bisect_terms
*terms
)
634 struct object_id oid
;
635 struct commit
*commit
;
636 struct pretty_print_context pp
= {0};
637 struct strbuf commit_name
= STRBUF_INIT
;
638 char *bad_ref
= xstrfmt("refs/bisect/%s",terms
->term_bad
);
641 read_ref(bad_ref
, &oid
);
642 commit
= lookup_commit_reference_by_name(bad_ref
);
643 repo_format_commit_message(the_repository
, commit
, "%s", &commit_name
,
646 res
= append_to_file(git_path_bisect_log(), "# first %s commit: [%s] %s\n",
647 terms
->term_bad
, oid_to_hex(&commit
->object
.oid
),
650 strbuf_release(&commit_name
);
655 static enum bisect_error
bisect_next(struct bisect_terms
*terms
, const char *prefix
)
657 enum bisect_error res
;
659 if (bisect_autostart(terms
))
660 return BISECT_FAILED
;
662 if (bisect_next_check(terms
, terms
->term_good
))
663 return BISECT_FAILED
;
665 /* Perform all bisection computation */
666 res
= bisect_next_all(the_repository
, prefix
);
668 if (res
== BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
) {
669 res
= bisect_successful(terms
);
670 return res
? res
: BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
;
671 } else if (res
== BISECT_ONLY_SKIPPED_LEFT
) {
672 res
= bisect_skipped_commits(terms
);
673 return res
? res
: BISECT_ONLY_SKIPPED_LEFT
;
678 static enum bisect_error
bisect_auto_next(struct bisect_terms
*terms
, const char *prefix
)
680 if (bisect_next_check(terms
, NULL
)) {
681 bisect_print_status(terms
);
685 return bisect_next(terms
, prefix
);
688 static enum bisect_error
bisect_start(struct bisect_terms
*terms
, int argc
,
692 int first_parent_only
= 0;
693 int i
, has_double_dash
= 0, must_write_terms
= 0, bad_seen
= 0;
694 int flags
, pathspec_pos
;
695 enum bisect_error res
= BISECT_OK
;
696 struct string_list revs
= STRING_LIST_INIT_DUP
;
697 struct string_list states
= STRING_LIST_INIT_DUP
;
698 struct strbuf start_head
= STRBUF_INIT
;
699 struct strbuf bisect_names
= STRBUF_INIT
;
700 struct object_id head_oid
;
701 struct object_id oid
;
704 if (is_bare_repository())
708 * Check for one bad and then some good revisions
710 for (i
= 0; i
< argc
; i
++) {
711 if (!strcmp(argv
[i
], "--")) {
717 for (i
= 0; i
< argc
; i
++) {
718 const char *arg
= argv
[i
];
719 if (!strcmp(argv
[i
], "--")) {
721 } else if (!strcmp(arg
, "--no-checkout")) {
723 } else if (!strcmp(arg
, "--first-parent")) {
724 first_parent_only
= 1;
725 } else if (!strcmp(arg
, "--term-good") ||
726 !strcmp(arg
, "--term-old")) {
729 return error(_("'' is not a valid term"));
730 must_write_terms
= 1;
731 free((void *) terms
->term_good
);
732 terms
->term_good
= xstrdup(argv
[i
]);
733 } else if (skip_prefix(arg
, "--term-good=", &arg
) ||
734 skip_prefix(arg
, "--term-old=", &arg
)) {
735 must_write_terms
= 1;
736 free((void *) terms
->term_good
);
737 terms
->term_good
= xstrdup(arg
);
738 } else if (!strcmp(arg
, "--term-bad") ||
739 !strcmp(arg
, "--term-new")) {
742 return error(_("'' is not a valid term"));
743 must_write_terms
= 1;
744 free((void *) terms
->term_bad
);
745 terms
->term_bad
= xstrdup(argv
[i
]);
746 } else if (skip_prefix(arg
, "--term-bad=", &arg
) ||
747 skip_prefix(arg
, "--term-new=", &arg
)) {
748 must_write_terms
= 1;
749 free((void *) terms
->term_bad
);
750 terms
->term_bad
= xstrdup(arg
);
751 } else if (starts_with(arg
, "--")) {
752 return error(_("unrecognized option: '%s'"), arg
);
753 } else if (!get_oidf(&oid
, "%s^{commit}", arg
)) {
754 string_list_append(&revs
, oid_to_hex(&oid
));
755 } else if (has_double_dash
) {
756 die(_("'%s' does not appear to be a valid "
765 * The user ran "git bisect start <sha1> <sha1>", hence did not
766 * explicitly specify the terms, but we are already starting to
767 * set references named with the default terms, and won't be able
768 * to change afterwards.
771 must_write_terms
= 1;
772 for (i
= 0; i
< revs
.nr
; i
++) {
774 string_list_append(&states
, terms
->term_good
);
777 string_list_append(&states
, terms
->term_bad
);
784 head
= resolve_ref_unsafe("HEAD", 0, &head_oid
, &flags
);
786 if (repo_get_oid(the_repository
, "HEAD", &head_oid
))
787 return error(_("bad HEAD - I need a HEAD"));
790 * Check if we are bisecting
792 if (!is_empty_or_missing_file(git_path_bisect_start())) {
793 /* Reset to the rev from where we started */
794 strbuf_read_file(&start_head
, git_path_bisect_start(), 0);
795 strbuf_trim(&start_head
);
797 struct child_process cmd
= CHILD_PROCESS_INIT
;
800 strvec_pushl(&cmd
.args
, "checkout", start_head
.buf
,
802 if (run_command(&cmd
)) {
803 res
= error(_("checking out '%s' failed."
804 " Try 'git bisect start "
811 /* Get the rev from where we start. */
812 if (!repo_get_oid(the_repository
, head
, &head_oid
) &&
813 !starts_with(head
, "refs/heads/")) {
814 strbuf_reset(&start_head
);
815 strbuf_addstr(&start_head
, oid_to_hex(&head_oid
));
816 } else if (!repo_get_oid(the_repository
, head
, &head_oid
) &&
817 skip_prefix(head
, "refs/heads/", &head
)) {
818 strbuf_addstr(&start_head
, head
);
820 return error(_("bad HEAD - strange symbolic ref"));
825 * Get rid of any old bisect state.
827 if (bisect_clean_state())
828 return BISECT_FAILED
;
831 * Write new start state
833 write_file(git_path_bisect_start(), "%s\n", start_head
.buf
);
835 if (first_parent_only
)
836 write_file(git_path_bisect_first_parent(), "\n");
839 if (repo_get_oid(the_repository
, start_head
.buf
, &oid
) < 0) {
840 res
= error(_("invalid ref: '%s'"), start_head
.buf
);
843 if (update_ref(NULL
, "BISECT_HEAD", &oid
, NULL
, 0,
844 UPDATE_REFS_MSG_ON_ERR
)) {
850 if (pathspec_pos
< argc
- 1)
851 sq_quote_argv(&bisect_names
, argv
+ pathspec_pos
);
852 write_file(git_path_bisect_names(), "%s\n", bisect_names
.buf
);
854 for (i
= 0; i
< states
.nr
; i
++)
855 if (bisect_write(states
.items
[i
].string
,
856 revs
.items
[i
].string
, terms
, 1)) {
861 if (must_write_terms
&& write_terms(terms
->term_bad
,
867 res
= bisect_append_log_quoted(argv
);
872 string_list_clear(&revs
, 0);
873 string_list_clear(&states
, 0);
874 strbuf_release(&start_head
);
875 strbuf_release(&bisect_names
);
879 res
= bisect_auto_next(terms
, NULL
);
880 if (!is_bisect_success(res
))
881 bisect_clean_state();
885 static inline int file_is_not_empty(const char *path
)
887 return !is_empty_or_missing_file(path
);
890 static int bisect_autostart(struct bisect_terms
*terms
)
895 if (file_is_not_empty(git_path_bisect_start()))
898 fprintf_ln(stderr
, _("You need to start by \"git bisect "
901 if (!isatty(STDIN_FILENO
))
905 * TRANSLATORS: Make sure to include [Y] and [n] in your
906 * translation. The program will only accept English input
909 yesno
= git_prompt(_("Do you want me to do it for you "
910 "[Y/n]? "), PROMPT_ECHO
);
911 res
= tolower(*yesno
) == 'n' ?
912 -1 : bisect_start(terms
, 0, empty_strvec
);
917 static enum bisect_error
bisect_state(struct bisect_terms
*terms
, int argc
,
921 int i
, verify_expected
= 1;
922 struct object_id oid
, expected
;
923 struct strbuf buf
= STRBUF_INIT
;
924 struct oid_array revs
= OID_ARRAY_INIT
;
927 return error(_("Please call `--bisect-state` with at least one argument"));
929 if (bisect_autostart(terms
))
930 return BISECT_FAILED
;
933 if (check_and_set_terms(terms
, state
) ||
934 !one_of(state
, terms
->term_good
, terms
->term_bad
, "skip", NULL
))
935 return BISECT_FAILED
;
939 if (argc
> 1 && !strcmp(state
, terms
->term_bad
))
940 return error(_("'git bisect %s' can take only one argument."), terms
->term_bad
);
943 const char *head
= "BISECT_HEAD";
944 enum get_oid_result res_head
= repo_get_oid(the_repository
,
947 if (res_head
== MISSING_OBJECT
) {
949 res_head
= repo_get_oid(the_repository
, head
, &oid
);
953 error(_("Bad rev input: %s"), head
);
954 oid_array_append(&revs
, &oid
);
958 * All input revs must be checked before executing bisect_write()
959 * to discard junk revs.
962 for (; argc
; argc
--, argv
++) {
963 struct commit
*commit
;
965 if (repo_get_oid(the_repository
, *argv
, &oid
)){
966 error(_("Bad rev input: %s"), *argv
);
967 oid_array_clear(&revs
);
968 return BISECT_FAILED
;
971 commit
= lookup_commit_reference(the_repository
, &oid
);
973 die(_("Bad rev input (not a commit): %s"), *argv
);
975 oid_array_append(&revs
, &commit
->object
.oid
);
978 if (strbuf_read_file(&buf
, git_path_bisect_expected_rev(), 0) < the_hash_algo
->hexsz
||
979 get_oid_hex(buf
.buf
, &expected
) < 0)
980 verify_expected
= 0; /* Ignore invalid file contents */
981 strbuf_release(&buf
);
983 for (i
= 0; i
< revs
.nr
; i
++) {
984 if (bisect_write(state
, oid_to_hex(&revs
.oid
[i
]), terms
, 0)) {
985 oid_array_clear(&revs
);
986 return BISECT_FAILED
;
988 if (verify_expected
&& !oideq(&revs
.oid
[i
], &expected
)) {
989 unlink_or_warn(git_path_bisect_ancestors_ok());
990 unlink_or_warn(git_path_bisect_expected_rev());
995 oid_array_clear(&revs
);
996 return bisect_auto_next(terms
, NULL
);
999 static enum bisect_error
bisect_log(void)
1002 const char* filename
= git_path_bisect_log();
1004 if (is_empty_or_missing_file(filename
))
1005 return error(_("We are not bisecting."));
1007 fd
= open(filename
, O_RDONLY
);
1009 return BISECT_FAILED
;
1011 status
= copy_fd(fd
, STDOUT_FILENO
);
1013 return status
? BISECT_FAILED
: BISECT_OK
;
1016 static int process_replay_line(struct bisect_terms
*terms
, struct strbuf
*line
)
1018 const char *p
= line
->buf
+ strspn(line
->buf
, " \t");
1019 char *word_end
, *rev
;
1021 if ((!skip_prefix(p
, "git bisect", &p
) &&
1022 !skip_prefix(p
, "git-bisect", &p
)) || !isspace(*p
))
1024 p
+= strspn(p
, " \t");
1026 word_end
= (char *)p
+ strcspn(p
, " \t");
1027 rev
= word_end
+ strspn(word_end
, " \t");
1028 *word_end
= '\0'; /* NUL-terminate the word */
1031 if (check_and_set_terms(terms
, p
))
1034 if (!strcmp(p
, "start")) {
1035 struct strvec argv
= STRVEC_INIT
;
1037 sq_dequote_to_strvec(rev
, &argv
);
1038 res
= bisect_start(terms
, argv
.nr
, argv
.v
);
1039 strvec_clear(&argv
);
1043 if (one_of(p
, terms
->term_good
,
1044 terms
->term_bad
, "skip", NULL
))
1045 return bisect_write(p
, rev
, terms
, 0);
1047 if (!strcmp(p
, "terms")) {
1048 struct strvec argv
= STRVEC_INIT
;
1050 sq_dequote_to_strvec(rev
, &argv
);
1051 res
= bisect_terms(terms
, argv
.nr
== 1 ? argv
.v
[0] : NULL
);
1052 strvec_clear(&argv
);
1055 error(_("'%s'?? what are you talking about?"), p
);
1060 static enum bisect_error
bisect_replay(struct bisect_terms
*terms
, const char *filename
)
1063 enum bisect_error res
= BISECT_OK
;
1064 struct strbuf line
= STRBUF_INIT
;
1066 if (is_empty_or_missing_file(filename
))
1067 return error(_("cannot read file '%s' for replaying"), filename
);
1069 if (bisect_reset(NULL
))
1070 return BISECT_FAILED
;
1072 fp
= fopen(filename
, "r");
1074 return BISECT_FAILED
;
1076 while ((strbuf_getline(&line
, fp
) != EOF
) && !res
)
1077 res
= process_replay_line(terms
, &line
);
1079 strbuf_release(&line
);
1083 return BISECT_FAILED
;
1085 return bisect_auto_next(terms
, NULL
);
1088 static enum bisect_error
bisect_skip(struct bisect_terms
*terms
, int argc
,
1092 enum bisect_error res
;
1093 struct strvec argv_state
= STRVEC_INIT
;
1095 strvec_push(&argv_state
, "skip");
1097 for (i
= 0; i
< argc
; i
++) {
1098 const char *dotdot
= strstr(argv
[i
], "..");
1101 struct rev_info revs
;
1102 struct commit
*commit
;
1104 repo_init_revisions(the_repository
, &revs
, NULL
);
1105 setup_revisions(2, argv
+ i
- 1, &revs
, NULL
);
1107 if (prepare_revision_walk(&revs
))
1108 die(_("revision walk setup failed\n"));
1109 while ((commit
= get_revision(&revs
)) != NULL
)
1110 strvec_push(&argv_state
,
1111 oid_to_hex(&commit
->object
.oid
));
1113 reset_revision_walk();
1114 release_revisions(&revs
);
1116 strvec_push(&argv_state
, argv
[i
]);
1119 res
= bisect_state(terms
, argv_state
.nr
, argv_state
.v
);
1121 strvec_clear(&argv_state
);
1125 static int bisect_visualize(struct bisect_terms
*terms
, int argc
,
1128 struct child_process cmd
= CHILD_PROCESS_INIT
;
1129 struct strbuf sb
= STRBUF_INIT
;
1131 if (bisect_next_check(terms
, NULL
) != 0)
1132 return BISECT_FAILED
;
1136 if ((getenv("DISPLAY") || getenv("SESSIONNAME") || getenv("MSYSTEM") ||
1137 getenv("SECURITYSESSIONID")) && exists_in_PATH("gitk")) {
1138 strvec_push(&cmd
.args
, "gitk");
1140 strvec_push(&cmd
.args
, "log");
1144 if (argv
[0][0] == '-') {
1145 strvec_push(&cmd
.args
, "log");
1147 } else if (strcmp(argv
[0], "tig") && !starts_with(argv
[0], "git"))
1150 strvec_pushv(&cmd
.args
, argv
);
1153 strvec_pushl(&cmd
.args
, "--bisect", "--", NULL
);
1155 strbuf_read_file(&sb
, git_path_bisect_names(), 0);
1156 sq_dequote_to_strvec(sb
.buf
, &cmd
.args
);
1157 strbuf_release(&sb
);
1159 return run_command(&cmd
);
1162 static int get_first_good(const char *refname UNUSED
,
1163 const struct object_id
*oid
,
1164 int flag UNUSED
, void *cb_data
)
1166 oidcpy(cb_data
, oid
);
1170 static int do_bisect_run(const char *command
)
1172 struct child_process cmd
= CHILD_PROCESS_INIT
;
1174 printf(_("running %s\n"), command
);
1176 strvec_push(&cmd
.args
, command
);
1177 return run_command(&cmd
);
1180 static int verify_good(const struct bisect_terms
*terms
, const char *command
)
1183 enum bisect_error res
;
1184 struct object_id good_rev
;
1185 struct object_id current_rev
;
1186 char *good_glob
= xstrfmt("%s-*", terms
->term_good
);
1187 int no_checkout
= ref_exists("BISECT_HEAD");
1189 for_each_glob_ref_in(get_first_good
, good_glob
, "refs/bisect/",
1193 if (read_ref(no_checkout
? "BISECT_HEAD" : "HEAD", ¤t_rev
))
1196 res
= bisect_checkout(&good_rev
, no_checkout
);
1197 if (res
!= BISECT_OK
)
1200 rc
= do_bisect_run(command
);
1202 res
= bisect_checkout(¤t_rev
, no_checkout
);
1203 if (res
!= BISECT_OK
)
1209 static int bisect_run(struct bisect_terms
*terms
, int argc
, const char **argv
)
1211 int res
= BISECT_OK
;
1212 struct strbuf command
= STRBUF_INIT
;
1213 const char *new_state
;
1214 int temporary_stdout_fd
, saved_stdout
;
1215 int is_first_run
= 1;
1217 if (bisect_next_check(terms
, NULL
))
1218 return BISECT_FAILED
;
1221 error(_("bisect run failed: no command provided."));
1222 return BISECT_FAILED
;
1225 sq_quote_argv(&command
, argv
);
1226 strbuf_ltrim(&command
);
1228 res
= do_bisect_run(command
.buf
);
1231 * Exit code 126 and 127 can either come from the shell
1232 * if it was unable to execute or even find the script,
1233 * or from the script itself. Check with a known-good
1234 * revision to avoid trashing the bisect run due to a
1235 * missing or non-executable script.
1237 if (is_first_run
&& (res
== 126 || res
== 127)) {
1238 int rc
= verify_good(terms
, command
.buf
);
1240 if (rc
< 0 || 128 <= rc
) {
1241 error(_("unable to verify %s on good"
1242 " revision"), command
.buf
);
1243 res
= BISECT_FAILED
;
1247 error(_("bogus exit code %d for good revision"),
1249 res
= BISECT_FAILED
;
1254 if (res
< 0 || 128 <= res
) {
1255 error(_("bisect run failed: exit code %d from"
1256 " %s is < 0 or >= 128"), res
, command
.buf
);
1263 new_state
= terms
->term_good
;
1265 new_state
= terms
->term_bad
;
1267 temporary_stdout_fd
= open(git_path_bisect_run(), O_CREAT
| O_WRONLY
| O_TRUNC
, 0666);
1269 if (temporary_stdout_fd
< 0) {
1270 res
= error_errno(_("cannot open file '%s' for writing"), git_path_bisect_run());
1275 saved_stdout
= dup(1);
1276 dup2(temporary_stdout_fd
, 1);
1278 res
= bisect_state(terms
, 1, &new_state
);
1281 dup2(saved_stdout
, 1);
1282 close(saved_stdout
);
1283 close(temporary_stdout_fd
);
1285 print_file_to_stdout(git_path_bisect_run());
1287 if (res
== BISECT_ONLY_SKIPPED_LEFT
)
1288 error(_("bisect run cannot continue any more"));
1289 else if (res
== BISECT_INTERNAL_SUCCESS_MERGE_BASE
) {
1290 puts(_("bisect run success"));
1292 } else if (res
== BISECT_INTERNAL_SUCCESS_1ST_BAD_FOUND
) {
1293 puts(_("bisect found first bad commit"));
1296 error(_("bisect run failed: 'git bisect %s'"
1297 " exited with error code %d"), new_state
, res
);
1304 strbuf_release(&command
);
1308 static int cmd_bisect__reset(int argc
, const char **argv
, const char *prefix UNUSED
)
1311 return error(_("'%s' requires either no argument or a commit"),
1312 "git bisect reset");
1313 return bisect_reset(argc
? argv
[0] : NULL
);
1316 static int cmd_bisect__terms(int argc
, const char **argv
, const char *prefix UNUSED
)
1319 struct bisect_terms terms
= { 0 };
1322 return error(_("'%s' requires 0 or 1 argument"),
1323 "git bisect terms");
1324 res
= bisect_terms(&terms
, argc
== 1 ? argv
[0] : NULL
);
1329 static int cmd_bisect__start(int argc
, const char **argv
, const char *prefix UNUSED
)
1332 struct bisect_terms terms
= { 0 };
1334 set_terms(&terms
, "bad", "good");
1335 res
= bisect_start(&terms
, argc
, argv
);
1340 static int cmd_bisect__next(int argc
, const char **argv UNUSED
, const char *prefix
)
1343 struct bisect_terms terms
= { 0 };
1346 return error(_("'%s' requires 0 arguments"),
1349 res
= bisect_next(&terms
, prefix
);
1354 static int cmd_bisect__log(int argc UNUSED
, const char **argv UNUSED
, const char *prefix UNUSED
)
1356 return bisect_log();
1359 static int cmd_bisect__replay(int argc
, const char **argv
, const char *prefix UNUSED
)
1362 struct bisect_terms terms
= { 0 };
1365 return error(_("no logfile given"));
1366 set_terms(&terms
, "bad", "good");
1367 res
= bisect_replay(&terms
, argv
[0]);
1372 static int cmd_bisect__skip(int argc
, const char **argv
, const char *prefix UNUSED
)
1375 struct bisect_terms terms
= { 0 };
1377 set_terms(&terms
, "bad", "good");
1379 res
= bisect_skip(&terms
, argc
, argv
);
1384 static int cmd_bisect__visualize(int argc
, const char **argv
, const char *prefix UNUSED
)
1387 struct bisect_terms terms
= { 0 };
1390 res
= bisect_visualize(&terms
, argc
, argv
);
1395 static int cmd_bisect__run(int argc
, const char **argv
, const char *prefix UNUSED
)
1398 struct bisect_terms terms
= { 0 };
1401 return error(_("'%s' failed: no command provided."), "git bisect run");
1403 res
= bisect_run(&terms
, argc
, argv
);
1408 int cmd_bisect(int argc
, const char **argv
, const char *prefix
)
1411 parse_opt_subcommand_fn
*fn
= NULL
;
1412 struct option options
[] = {
1413 OPT_SUBCOMMAND("reset", &fn
, cmd_bisect__reset
),
1414 OPT_SUBCOMMAND("terms", &fn
, cmd_bisect__terms
),
1415 OPT_SUBCOMMAND("start", &fn
, cmd_bisect__start
),
1416 OPT_SUBCOMMAND("next", &fn
, cmd_bisect__next
),
1417 OPT_SUBCOMMAND("log", &fn
, cmd_bisect__log
),
1418 OPT_SUBCOMMAND("replay", &fn
, cmd_bisect__replay
),
1419 OPT_SUBCOMMAND("skip", &fn
, cmd_bisect__skip
),
1420 OPT_SUBCOMMAND("visualize", &fn
, cmd_bisect__visualize
),
1421 OPT_SUBCOMMAND("view", &fn
, cmd_bisect__visualize
),
1422 OPT_SUBCOMMAND("run", &fn
, cmd_bisect__run
),
1425 argc
= parse_options(argc
, argv
, prefix
, options
, git_bisect_usage
,
1426 PARSE_OPT_SUBCOMMAND_OPTIONAL
);
1429 struct bisect_terms terms
= { 0 };
1432 usage_msg_opt(_("need a command"), git_bisect_usage
, options
);
1434 set_terms(&terms
, "bad", "good");
1436 if (check_and_set_terms(&terms
, argv
[0]))
1437 usage_msg_optf(_("unknown command: '%s'"), git_bisect_usage
,
1439 res
= bisect_state(&terms
, argc
, argv
);
1444 res
= fn(argc
, argv
, prefix
);
1447 return is_bisect_success(res
) ? 0 : -res
;