branch.c

   1 #include "git-compat-util.h"
   2 #include "cache.h"
   3 #include "advice.h"
   4 #include "config.h"
   5 #include "branch.h"
   6 #include "environment.h"
   7 #include "gettext.h"
   8 #include "hex.h"
   9 #include "object-name.h"
  10 #include "refs.h"
  11 #include "refspec.h"
  12 #include "remote.h"
  13 #include "sequencer.h"
  14 #include "commit.h"
  15 #include "worktree.h"
  16 #include "submodule-config.h"
  17 #include "run-command.h"
  18 #include "strmap.h"
  19
  20 struct tracking {
  21         struct refspec_item spec;
  22         struct string_list *srcs;
  23         const char *remote;
  24         int matches;
  25 };
  26
  27 struct find_tracked_branch_cb {
  28         struct tracking *tracking;
  29         struct string_list ambiguous_remotes;
  30 };
  31
  32 static int find_tracked_branch(struct remote *remote, void *priv)
  33 {
  34         struct find_tracked_branch_cb *ftb = priv;
  35         struct tracking *tracking = ftb->tracking;
  36
  37         if (!remote_find_tracking(remote, &tracking->spec)) {
  38                 switch (++tracking->matches) {
  39                 case 1:
  40                         string_list_append(tracking->srcs, tracking->spec.src);
  41                         tracking->remote = remote->name;
  42                         break;
  43                 case 2:
  44                         /* there are at least two remotes; backfill the first one */
  45                         string_list_append(&ftb->ambiguous_remotes, tracking->remote);
  46                         /* fall through */
  47                 default:
  48                         string_list_append(&ftb->ambiguous_remotes, remote->name);
  49                         free(tracking->spec.src);
  50                         string_list_clear(tracking->srcs, 0);
  51                 break;
  52                 }
  53                 /* remote_find_tracking() searches by src if present */
  54                 tracking->spec.src = NULL;
  55         }
  56         return 0;
  57 }
  58
  59 static int should_setup_rebase(const char *origin)
  60 {
  61         switch (autorebase) {
  62         case AUTOREBASE_NEVER:
  63                 return 0;
  64         case AUTOREBASE_LOCAL:
  65                 return origin == NULL;
  66         case AUTOREBASE_REMOTE:
  67                 return origin != NULL;
  68         case AUTOREBASE_ALWAYS:
  69                 return 1;
  70         }
  71         return 0;
  72 }
  73
  74 /**
  75  * Install upstream tracking configuration for a branch; specifically, add
  76  * `branch.<name>.remote` and `branch.<name>.merge` entries.
  77  *
  78  * `flag` contains integer flags for options; currently only
  79  * BRANCH_CONFIG_VERBOSE is checked.
  80  *
  81  * `local` is the name of the branch whose configuration we're installing.
  82  *
  83  * `origin` is the name of the remote owning the upstream branches. NULL means
  84  * the upstream branches are local to this repo.
  85  *
  86  * `remotes` is a list of refs that are upstream of local
  87  */
  88 static int install_branch_config_multiple_remotes(int flag, const char *local,
  89                 const char *origin, struct string_list *remotes)
  90 {
  91         const char *shortname = NULL;
  92         struct strbuf key = STRBUF_INIT;
  93         struct string_list_item *item;
  94         int rebasing = should_setup_rebase(origin);
  95
  96         if (!remotes->nr)
  97                 BUG("must provide at least one remote for branch config");
  98         if (rebasing && remotes->nr > 1)
  99                 die(_("cannot inherit upstream tracking configuration of "
 100                       "multiple refs when rebasing is requested"));
 101
 102         /*
 103          * If the new branch is trying to track itself, something has gone
 104          * wrong. Warn the user and don't proceed any further.
 105          */
 106         if (!origin)
 107                 for_each_string_list_item(item, remotes)
 108                         if (skip_prefix(item->string, "refs/heads/", &shortname)
 109                             && !strcmp(local, shortname)) {
 110                                 warning(_("not setting branch '%s' as its own upstream"),
 111                                         local);
 112                                 return 0;
 113                         }
 114
 115         strbuf_addf(&key, "branch.%s.remote", local);
 116         if (git_config_set_gently(key.buf, origin ? origin : ".") < 0)
 117                 goto out_err;
 118
 119         strbuf_reset(&key);
 120         strbuf_addf(&key, "branch.%s.merge", local);
 121         /*
 122          * We want to overwrite any existing config with all the branches in
 123          * "remotes". Override any existing config, then write our branches. If
 124          * more than one is provided, use CONFIG_REGEX_NONE to preserve what
 125          * we've written so far.
 126          */
 127         if (git_config_set_gently(key.buf, NULL) < 0)
 128                 goto out_err;
 129         for_each_string_list_item(item, remotes)
 130                 if (git_config_set_multivar_gently(key.buf, item->string, CONFIG_REGEX_NONE, 0) < 0)
 131                         goto out_err;
 132
 133         if (rebasing) {
 134                 strbuf_reset(&key);
 135                 strbuf_addf(&key, "branch.%s.rebase", local);
 136                 if (git_config_set_gently(key.buf, "true") < 0)
 137                         goto out_err;
 138         }
 139         strbuf_release(&key);
 140
 141         if (flag & BRANCH_CONFIG_VERBOSE) {
 142                 struct strbuf tmp_ref_name = STRBUF_INIT;
 143                 struct string_list friendly_ref_names = STRING_LIST_INIT_DUP;
 144
 145                 for_each_string_list_item(item, remotes) {
 146                         shortname = item->string;
 147                         skip_prefix(shortname, "refs/heads/", &shortname);
 148                         if (origin) {
 149                                 strbuf_addf(&tmp_ref_name, "%s/%s",
 150                                             origin, shortname);
 151                                 string_list_append_nodup(
 152                                         &friendly_ref_names,
 153                                         strbuf_detach(&tmp_ref_name, NULL));
 154                         } else {
 155                                 string_list_append(
 156                                         &friendly_ref_names, shortname);
 157                         }
 158                 }
 159
 160                 if (remotes->nr == 1) {
 161                         /*
 162                          * Rebasing is only allowed in the case of a single
 163                          * upstream branch.
 164                          */
 165                         printf_ln(rebasing ?
 166                                 _("branch '%s' set up to track '%s' by rebasing.") :
 167                                 _("branch '%s' set up to track '%s'."),
 168                                 local, friendly_ref_names.items[0].string);
 169                 } else {
 170                         printf_ln(_("branch '%s' set up to track:"), local);
 171                         for_each_string_list_item(item, &friendly_ref_names)
 172                                 printf_ln("  %s", item->string);
 173                 }
 174
 175                 string_list_clear(&friendly_ref_names, 0);
 176         }
 177
 178         return 0;
 179
 180 out_err:
 181         strbuf_release(&key);
 182         error(_("unable to write upstream branch configuration"));
 183
 184         advise(_("\nAfter fixing the error cause you may try to fix up\n"
 185                 "the remote tracking information by invoking:"));
 186         if (remotes->nr == 1)
 187                 advise("  git branch --set-upstream-to=%s%s%s",
 188                         origin ? origin : "",
 189                         origin ? "/" : "",
 190                         remotes->items[0].string);
 191         else {
 192                 advise("  git config --add branch.\"%s\".remote %s",
 193                         local, origin ? origin : ".");
 194                 for_each_string_list_item(item, remotes)
 195                         advise("  git config --add branch.\"%s\".merge %s",
 196                                 local, item->string);
 197         }
 198
 199         return -1;
 200 }
 201
 202 int install_branch_config(int flag, const char *local, const char *origin,
 203                 const char *remote)
 204 {
 205         int ret;
 206         struct string_list remotes = STRING_LIST_INIT_DUP;
 207
 208         string_list_append(&remotes, remote);
 209         ret = install_branch_config_multiple_remotes(flag, local, origin, &remotes);
 210         string_list_clear(&remotes, 0);
 211         return ret;
 212 }
 213
 214 static int inherit_tracking(struct tracking *tracking, const char *orig_ref)
 215 {
 216         const char *bare_ref;
 217         struct branch *branch;
 218         int i;
 219
 220         bare_ref = orig_ref;
 221         skip_prefix(orig_ref, "refs/heads/", &bare_ref);
 222
 223         branch = branch_get(bare_ref);
 224         if (!branch->remote_name) {
 225                 warning(_("asked to inherit tracking from '%s', but no remote is set"),
 226                         bare_ref);
 227                 return -1;
 228         }
 229
 230         if (branch->merge_nr < 1 || !branch->merge_name || !branch->merge_name[0]) {
 231                 warning(_("asked to inherit tracking from '%s', but no merge configuration is set"),
 232                         bare_ref);
 233                 return -1;
 234         }
 235
 236         tracking->remote = xstrdup(branch->remote_name);
 237         for (i = 0; i < branch->merge_nr; i++)
 238                 string_list_append(tracking->srcs, branch->merge_name[i]);
 239         return 0;
 240 }
 241
 242 /*
 243  * Used internally to set the branch.<new_ref>.{remote,merge} config
 244  * settings so that branch 'new_ref' tracks 'orig_ref'. Unlike
 245  * dwim_and_setup_tracking(), this does not do DWIM, i.e. "origin/main"
 246  * will not be expanded to "refs/remotes/origin/main", so it is not safe
 247  * for 'orig_ref' to be raw user input.
 248  */
 249 static void setup_tracking(const char *new_ref, const char *orig_ref,
 250                            enum branch_track track, int quiet)
 251 {
 252         struct tracking tracking;
 253         struct string_list tracking_srcs = STRING_LIST_INIT_DUP;
 254         int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
 255         struct find_tracked_branch_cb ftb_cb = {
 256                 .tracking = &tracking,
 257                 .ambiguous_remotes = STRING_LIST_INIT_DUP,
 258         };
 259
 260         if (!track)
 261                 BUG("asked to set up tracking, but tracking is disallowed");
 262
 263         memset(&tracking, 0, sizeof(tracking));
 264         tracking.spec.dst = (char *)orig_ref;
 265         tracking.srcs = &tracking_srcs;
 266         if (track != BRANCH_TRACK_INHERIT)
 267                 for_each_remote(find_tracked_branch, &ftb_cb);
 268         else if (inherit_tracking(&tracking, orig_ref))
 269                 goto cleanup;
 270
 271         if (!tracking.matches)
 272                 switch (track) {
 273                 /* If ref is not remote, still use local */
 274                 case BRANCH_TRACK_ALWAYS:
 275                 case BRANCH_TRACK_EXPLICIT:
 276                 case BRANCH_TRACK_OVERRIDE:
 277                 /* Remote matches not evaluated */
 278                 case BRANCH_TRACK_INHERIT:
 279                         break;
 280                 /* Otherwise, if no remote don't track */
 281                 default:
 282                         goto cleanup;
 283                 }
 284
 285         /*
 286          * This check does not apply to BRANCH_TRACK_INHERIT;
 287          * that supports multiple entries in tracking_srcs but
 288          * leaves tracking.matches at 0.
 289          */
 290         if (tracking.matches > 1) {
 291                 int status = die_message(_("not tracking: ambiguous information for ref '%s'"),
 292                                             orig_ref);
 293                 if (advice_enabled(ADVICE_AMBIGUOUS_FETCH_REFSPEC)) {
 294                         struct strbuf remotes_advice = STRBUF_INIT;
 295                         struct string_list_item *item;
 296
 297                         for_each_string_list_item(item, &ftb_cb.ambiguous_remotes)
 298                                 /*
 299                                  * TRANSLATORS: This is a line listing a remote with duplicate
 300                                  * refspecs in the advice message below. For RTL languages you'll
 301                                  * probably want to swap the "%s" and leading "  " space around.
 302                                  */
 303                                 strbuf_addf(&remotes_advice, _("  %s\n"), item->string);
 304
 305                         /*
 306                          * TRANSLATORS: The second argument is a \n-delimited list of
 307                          * duplicate refspecs, composed above.
 308                          */
 309                         advise(_("There are multiple remotes whose fetch refspecs map to the remote\n"
 310                                  "tracking ref '%s':\n"
 311                                  "%s"
 312                                  "\n"
 313                                  "This is typically a configuration error.\n"
 314                                  "\n"
 315                                  "To support setting up tracking branches, ensure that\n"
 316                                  "different remotes' fetch refspecs map into different\n"
 317                                  "tracking namespaces."), orig_ref,
 318                                remotes_advice.buf);
 319                         strbuf_release(&remotes_advice);
 320                 }
 321                 exit(status);
 322         }
 323
 324         if (track == BRANCH_TRACK_SIMPLE) {
 325                 /*
 326                  * Only track if remote branch name matches.
 327                  * Reaching into items[0].string is safe because
 328                  * we know there is at least one and not more than
 329                  * one entry (because only BRANCH_TRACK_INHERIT can
 330                  * produce more than one entry).
 331                  */
 332                 const char *tracked_branch;
 333                 if (!skip_prefix(tracking.srcs->items[0].string,
 334                                  "refs/heads/", &tracked_branch) ||
 335                     strcmp(tracked_branch, new_ref))
 336                         return;
 337         }
 338
 339         if (tracking.srcs->nr < 1)
 340                 string_list_append(tracking.srcs, orig_ref);
 341         if (install_branch_config_multiple_remotes(config_flags, new_ref,
 342                                 tracking.remote, tracking.srcs) < 0)
 343                 exit(1);
 344
 345 cleanup:
 346         string_list_clear(&tracking_srcs, 0);
 347         string_list_clear(&ftb_cb.ambiguous_remotes, 0);
 348 }
 349
 350 int read_branch_desc(struct strbuf *buf, const char *branch_name)
 351 {
 352         char *v = NULL;
 353         struct strbuf name = STRBUF_INIT;
 354         strbuf_addf(&name, "branch.%s.description", branch_name);
 355         if (git_config_get_string(name.buf, &v)) {
 356                 strbuf_release(&name);
 357                 return -1;
 358         }
 359         strbuf_addstr(buf, v);
 360         free(v);
 361         strbuf_release(&name);
 362         return 0;
 363 }
 364
 365 /*
 366  * Check if 'name' can be a valid name for a branch; die otherwise.
 367  * Return 1 if the named branch already exists; return 0 otherwise.
 368  * Fill ref with the full refname for the branch.
 369  */
 370 int validate_branchname(const char *name, struct strbuf *ref)
 371 {
 372         if (strbuf_check_branch_ref(ref, name))
 373                 die(_("'%s' is not a valid branch name"), name);
 374
 375         return ref_exists(ref->buf);
 376 }
 377
 378 static int initialized_checked_out_branches;
 379 static struct strmap current_checked_out_branches = STRMAP_INIT;
 380
 381 static void prepare_checked_out_branches(void)
 382 {
 383         int i = 0;
 384         struct worktree **worktrees;
 385
 386         if (initialized_checked_out_branches)
 387                 return;
 388         initialized_checked_out_branches = 1;
 389
 390         worktrees = get_worktrees();
 391
 392         while (worktrees[i]) {
 393                 char *old;
 394                 struct wt_status_state state = { 0 };
 395                 struct worktree *wt = worktrees[i++];
 396                 struct string_list update_refs = STRING_LIST_INIT_DUP;
 397
 398                 if (wt->is_bare)
 399                         continue;
 400
 401                 if (wt->head_ref) {
 402                         old = strmap_put(&current_checked_out_branches,
 403                                          wt->head_ref,
 404                                          xstrdup(wt->path));
 405                         free(old);
 406                 }
 407
 408                 if (wt_status_check_rebase(wt, &state) &&
 409                     (state.rebase_in_progress || state.rebase_interactive_in_progress) &&
 410                     state.branch) {
 411                         struct strbuf ref = STRBUF_INIT;
 412                         strbuf_addf(&ref, "refs/heads/%s", state.branch);
 413                         old = strmap_put(&current_checked_out_branches,
 414                                          ref.buf,
 415                                          xstrdup(wt->path));
 416                         free(old);
 417                         strbuf_release(&ref);
 418                 }
 419                 wt_status_state_free_buffers(&state);
 420
 421                 if (wt_status_check_bisect(wt, &state) &&
 422                     state.branch) {
 423                         struct strbuf ref = STRBUF_INIT;
 424                         strbuf_addf(&ref, "refs/heads/%s", state.branch);
 425                         old = strmap_put(&current_checked_out_branches,
 426                                          ref.buf,
 427                                          xstrdup(wt->path));
 428                         free(old);
 429                         strbuf_release(&ref);
 430                 }
 431                 wt_status_state_free_buffers(&state);
 432
 433                 if (!sequencer_get_update_refs_state(get_worktree_git_dir(wt),
 434                                                      &update_refs)) {
 435                         struct string_list_item *item;
 436                         for_each_string_list_item(item, &update_refs) {
 437                                 old = strmap_put(&current_checked_out_branches,
 438                                                  item->string,
 439                                                  xstrdup(wt->path));
 440                                 free(old);
 441                         }
 442                         string_list_clear(&update_refs, 1);
 443                 }
 444         }
 445
 446         free_worktrees(worktrees);
 447 }
 448
 449 const char *branch_checked_out(const char *refname)
 450 {
 451         prepare_checked_out_branches();
 452         return strmap_get(&current_checked_out_branches, refname);
 453 }
 454
 455 /*
 456  * Check if a branch 'name' can be created as a new branch; die otherwise.
 457  * 'force' can be used when it is OK for the named branch already exists.
 458  * Return 1 if the named branch already exists; return 0 otherwise.
 459  * Fill ref with the full refname for the branch.
 460  */
 461 int validate_new_branchname(const char *name, struct strbuf *ref, int force)
 462 {
 463         const char *path;
 464         if (!validate_branchname(name, ref))
 465                 return 0;
 466
 467         if (!force)
 468                 die(_("a branch named '%s' already exists"),
 469                     ref->buf + strlen("refs/heads/"));
 470
 471         if ((path = branch_checked_out(ref->buf)))
 472                 die(_("cannot force update the branch '%s' "
 473                       "checked out at '%s'"),
 474                     ref->buf + strlen("refs/heads/"), path);
 475
 476         return 1;
 477 }
 478
 479 static int check_tracking_branch(struct remote *remote, void *cb_data)
 480 {
 481         char *tracking_branch = cb_data;
 482         struct refspec_item query;
 483         memset(&query, 0, sizeof(struct refspec_item));
 484         query.dst = tracking_branch;
 485         return !remote_find_tracking(remote, &query);
 486 }
 487
 488 static int validate_remote_tracking_branch(char *ref)
 489 {
 490         return !for_each_remote(check_tracking_branch, ref);
 491 }
 492
 493 static const char upstream_not_branch[] =
 494 N_("cannot set up tracking information; starting point '%s' is not a branch");
 495 static const char upstream_missing[] =
 496 N_("the requested upstream branch '%s' does not exist");
 497 static const char upstream_advice[] =
 498 N_("\n"
 499 "If you are planning on basing your work on an upstream\n"
 500 "branch that already exists at the remote, you may need to\n"
 501 "run \"git fetch\" to retrieve it.\n"
 502 "\n"
 503 "If you are planning to push out a new local branch that\n"
 504 "will track its remote counterpart, you may want to use\n"
 505 "\"git push -u\" to set the upstream config as you push.");
 506
 507 /**
 508  * DWIMs a user-provided ref to determine the starting point for a
 509  * branch and validates it, where:
 510  *
 511  *   - r is the repository to validate the branch for
 512  *
 513  *   - start_name is the ref that we would like to test. This is
 514  *     expanded with DWIM and assigned to out_real_ref.
 515  *
 516  *   - track is the tracking mode of the new branch. If tracking is
 517  *     explicitly requested, start_name must be a branch (because
 518  *     otherwise start_name cannot be tracked)
 519  *
 520  *   - out_oid is an out parameter containing the object_id of start_name
 521  *
 522  *   - out_real_ref is an out parameter containing the full, 'real' form
 523  *     of start_name e.g. refs/heads/main instead of main
 524  *
 525  */
 526 static void dwim_branch_start(struct repository *r, const char *start_name,
 527                            enum branch_track track, char **out_real_ref,
 528                            struct object_id *out_oid)
 529 {
 530         struct commit *commit;
 531         struct object_id oid;
 532         char *real_ref;
 533         int explicit_tracking = 0;
 534
 535         if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
 536                 explicit_tracking = 1;
 537
 538         real_ref = NULL;
 539         if (repo_get_oid_mb(r, start_name, &oid)) {
 540                 if (explicit_tracking) {
 541                         int code = die_message(_(upstream_missing), start_name);
 542                         advise_if_enabled(ADVICE_SET_UPSTREAM_FAILURE,
 543                                           _(upstream_advice));
 544                         exit(code);
 545                 }
 546                 die(_("not a valid object name: '%s'"), start_name);
 547         }
 548
 549         switch (repo_dwim_ref(r, start_name, strlen(start_name), &oid,
 550                               &real_ref, 0)) {
 551         case 0:
 552                 /* Not branching from any existing branch */
 553                 if (explicit_tracking)
 554                         die(_(upstream_not_branch), start_name);
 555                 break;
 556         case 1:
 557                 /* Unique completion -- good, only if it is a real branch */
 558                 if (!starts_with(real_ref, "refs/heads/") &&
 559                     validate_remote_tracking_branch(real_ref)) {
 560                         if (explicit_tracking)
 561                                 die(_(upstream_not_branch), start_name);
 562                         else
 563                                 FREE_AND_NULL(real_ref);
 564                 }
 565                 break;
 566         default:
 567                 die(_("ambiguous object name: '%s'"), start_name);
 568                 break;
 569         }
 570
 571         if (!(commit = lookup_commit_reference(r, &oid)))
 572                 die(_("not a valid branch point: '%s'"), start_name);
 573         if (out_real_ref) {
 574                 *out_real_ref = real_ref;
 575                 real_ref = NULL;
 576         }
 577         if (out_oid)
 578                 oidcpy(out_oid, &commit->object.oid);
 579
 580         FREE_AND_NULL(real_ref);
 581 }
 582
 583 void create_branch(struct repository *r,
 584                    const char *name, const char *start_name,
 585                    int force, int clobber_head_ok, int reflog,
 586                    int quiet, enum branch_track track, int dry_run)
 587 {
 588         struct object_id oid;
 589         char *real_ref;
 590         struct strbuf ref = STRBUF_INIT;
 591         int forcing = 0;
 592         struct ref_transaction *transaction;
 593         struct strbuf err = STRBUF_INIT;
 594         char *msg;
 595
 596         if (track == BRANCH_TRACK_OVERRIDE)
 597                 BUG("'track' cannot be BRANCH_TRACK_OVERRIDE. Did you mean to call dwim_and_setup_tracking()?");
 598         if (clobber_head_ok && !force)
 599                 BUG("'clobber_head_ok' can only be used with 'force'");
 600
 601         if (clobber_head_ok ?
 602                           validate_branchname(name, &ref) :
 603                           validate_new_branchname(name, &ref, force)) {
 604                 forcing = 1;
 605         }
 606
 607         dwim_branch_start(r, start_name, track, &real_ref, &oid);
 608         if (dry_run)
 609                 goto cleanup;
 610
 611         if (reflog)
 612                 log_all_ref_updates = LOG_REFS_NORMAL;
 613
 614         if (forcing)
 615                 msg = xstrfmt("branch: Reset to %s", start_name);
 616         else
 617                 msg = xstrfmt("branch: Created from %s", start_name);
 618         transaction = ref_transaction_begin(&err);
 619         if (!transaction ||
 620                 ref_transaction_update(transaction, ref.buf,
 621                                         &oid, forcing ? NULL : null_oid(),
 622                                         0, msg, &err) ||
 623                 ref_transaction_commit(transaction, &err))
 624                 die("%s", err.buf);
 625         ref_transaction_free(transaction);
 626         strbuf_release(&err);
 627         free(msg);
 628
 629         if (real_ref && track)
 630                 setup_tracking(ref.buf + 11, real_ref, track, quiet);
 631
 632 cleanup:
 633         strbuf_release(&ref);
 634         free(real_ref);
 635 }
 636
 637 void dwim_and_setup_tracking(struct repository *r, const char *new_ref,
 638                              const char *orig_ref, enum branch_track track,
 639                              int quiet)
 640 {
 641         char *real_orig_ref;
 642         dwim_branch_start(r, orig_ref, track, &real_orig_ref, NULL);
 643         setup_tracking(new_ref, real_orig_ref, track, quiet);
 644 }
 645
 646 /**
 647  * Creates a branch in a submodule by calling
 648  * create_branches_recursively() in a child process. The child process
 649  * is necessary because install_branch_config_multiple_remotes() (which
 650  * is called by setup_tracking()) does not support writing configs to
 651  * submodules.
 652  */
 653 static int submodule_create_branch(struct repository *r,
 654                                    const struct submodule *submodule,
 655                                    const char *name, const char *start_oid,
 656                                    const char *tracking_name, int force,
 657                                    int reflog, int quiet,
 658                                    enum branch_track track, int dry_run)
 659 {
 660         int ret = 0;
 661         struct child_process child = CHILD_PROCESS_INIT;
 662         struct strbuf child_err = STRBUF_INIT;
 663         struct strbuf out_buf = STRBUF_INIT;
 664         char *out_prefix = xstrfmt("submodule '%s': ", submodule->name);
 665         child.git_cmd = 1;
 666         child.err = -1;
 667         child.stdout_to_stderr = 1;
 668
 669         prepare_other_repo_env(&child.env, r->gitdir);
 670         /*
 671          * submodule_create_branch() is indirectly invoked by "git
 672          * branch", but we cannot invoke "git branch" in the child
 673          * process. "git branch" accepts a branch name and start point,
 674          * where the start point is assumed to provide both the OID
 675          * (start_oid) and the branch to use for tracking
 676          * (tracking_name). But when recursing through submodules,
 677          * start_oid and tracking name need to be specified separately
 678          * (see create_branches_recursively()).
 679          */
 680         strvec_pushl(&child.args, "submodule--helper", "create-branch", NULL);
 681         if (dry_run)
 682                 strvec_push(&child.args, "--dry-run");
 683         if (force)
 684                 strvec_push(&child.args, "--force");
 685         if (quiet)
 686                 strvec_push(&child.args, "--quiet");
 687         if (reflog)
 688                 strvec_push(&child.args, "--create-reflog");
 689
 690         switch (track) {
 691         case BRANCH_TRACK_NEVER:
 692                 strvec_push(&child.args, "--no-track");
 693                 break;
 694         case BRANCH_TRACK_ALWAYS:
 695         case BRANCH_TRACK_EXPLICIT:
 696                 strvec_push(&child.args, "--track=direct");
 697                 break;
 698         case BRANCH_TRACK_OVERRIDE:
 699                 BUG("BRANCH_TRACK_OVERRIDE cannot be used when creating a branch.");
 700                 break;
 701         case BRANCH_TRACK_INHERIT:
 702                 strvec_push(&child.args, "--track=inherit");
 703                 break;
 704         case BRANCH_TRACK_UNSPECIFIED:
 705                 /* Default for "git checkout". Do not pass --track. */
 706         case BRANCH_TRACK_REMOTE:
 707                 /* Default for "git branch". Do not pass --track. */
 708         case BRANCH_TRACK_SIMPLE:
 709                 /* Config-driven only. Do not pass --track. */
 710                 break;
 711         }
 712
 713         strvec_pushl(&child.args, name, start_oid, tracking_name, NULL);
 714
 715         if ((ret = start_command(&child)))
 716                 return ret;
 717         ret = finish_command(&child);
 718         strbuf_read(&child_err, child.err, 0);
 719         strbuf_add_lines(&out_buf, out_prefix, child_err.buf, child_err.len);
 720
 721         if (ret)
 722                 fprintf(stderr, "%s", out_buf.buf);
 723         else
 724                 printf("%s", out_buf.buf);
 725
 726         strbuf_release(&child_err);
 727         strbuf_release(&out_buf);
 728         return ret;
 729 }
 730
 731 void create_branches_recursively(struct repository *r, const char *name,
 732                                  const char *start_commitish,
 733                                  const char *tracking_name, int force,
 734                                  int reflog, int quiet, enum branch_track track,
 735                                  int dry_run)
 736 {
 737         int i = 0;
 738         char *branch_point = NULL;
 739         struct object_id super_oid;
 740         struct submodule_entry_list submodule_entry_list;
 741
 742         /* Perform dwim on start_commitish to get super_oid and branch_point. */
 743         dwim_branch_start(r, start_commitish, BRANCH_TRACK_NEVER,
 744                           &branch_point, &super_oid);
 745
 746         /*
 747          * If we were not given an explicit name to track, then assume we are at
 748          * the top level and, just like the non-recursive case, the tracking
 749          * name is the branch point.
 750          */
 751         if (!tracking_name)
 752                 tracking_name = branch_point;
 753
 754         submodules_of_tree(r, &super_oid, &submodule_entry_list);
 755         /*
 756          * Before creating any branches, first check that the branch can
 757          * be created in every submodule.
 758          */
 759         for (i = 0; i < submodule_entry_list.entry_nr; i++) {
 760                 if (!submodule_entry_list.entries[i].repo) {
 761                         int code = die_message(
 762                                 _("submodule '%s': unable to find submodule"),
 763                                 submodule_entry_list.entries[i].submodule->name);
 764                         if (advice_enabled(ADVICE_SUBMODULES_NOT_UPDATED))
 765                                 advise(_("You may try updating the submodules using 'git checkout --no-recurse-submodules %s && git submodule update --init'"),
 766                                        start_commitish);
 767                         exit(code);
 768                 }
 769
 770                 if (submodule_create_branch(
 771                             submodule_entry_list.entries[i].repo,
 772                             submodule_entry_list.entries[i].submodule, name,
 773                             oid_to_hex(&submodule_entry_list.entries[i]
 774                                                 .name_entry->oid),
 775                             tracking_name, force, reflog, quiet, track, 1))
 776                         die(_("submodule '%s': cannot create branch '%s'"),
 777                             submodule_entry_list.entries[i].submodule->name,
 778                             name);
 779         }
 780
 781         create_branch(r, name, start_commitish, force, 0, reflog, quiet,
 782                       BRANCH_TRACK_NEVER, dry_run);
 783         if (dry_run)
 784                 return;
 785         /*
 786          * NEEDSWORK If tracking was set up in the superproject but not the
 787          * submodule, users might expect "git branch --recurse-submodules" to
 788          * fail or give a warning, but this is not yet implemented because it is
 789          * tedious to determine whether or not tracking was set up in the
 790          * superproject.
 791          */
 792         if (track)
 793                 setup_tracking(name, tracking_name, track, quiet);
 794
 795         for (i = 0; i < submodule_entry_list.entry_nr; i++) {
 796                 if (submodule_create_branch(
 797                             submodule_entry_list.entries[i].repo,
 798                             submodule_entry_list.entries[i].submodule, name,
 799                             oid_to_hex(&submodule_entry_list.entries[i]
 800                                                 .name_entry->oid),
 801                             tracking_name, force, reflog, quiet, track, 0))
 802                         die(_("submodule '%s': cannot create branch '%s'"),
 803                             submodule_entry_list.entries[i].submodule->name,
 804                             name);
 805                 repo_clear(submodule_entry_list.entries[i].repo);
 806         }
 807 }
 808
 809 void remove_merge_branch_state(struct repository *r)
 810 {
 811         unlink(git_path_merge_head(r));
 812         unlink(git_path_merge_rr(r));
 813         unlink(git_path_merge_msg(r));
 814         unlink(git_path_merge_mode(r));
 815         unlink(git_path_auto_merge(r));
 816         save_autostash(git_path_merge_autostash(r));
 817 }
 818
 819 void remove_branch_state(struct repository *r, int verbose)
 820 {
 821         sequencer_post_commit_cleanup(r, verbose);
 822         unlink(git_path_squash_msg(r));
 823         remove_merge_branch_state(r);
 824 }
 825
 826 void die_if_checked_out(const char *branch, int ignore_current_worktree)
 827 {
 828         struct worktree **worktrees = get_worktrees();
 829
 830         for (int i = 0; worktrees[i]; i++) {
 831                 if (worktrees[i]->is_current && ignore_current_worktree)
 832                         continue;
 833
 834                 if (is_shared_symref(worktrees[i], "HEAD", branch)) {
 835                         skip_prefix(branch, "refs/heads/", &branch);
 836                         die(_("'%s' is already checked out at '%s'"),
 837                                 branch, worktrees[i]->path);
 838                 }
 839         }
 840
 841         free_worktrees(worktrees);
 842 }
 843
 844 int replace_each_worktree_head_symref(const char *oldref, const char *newref,
 845                                       const char *logmsg)
 846 {
 847         int ret = 0;
 848         struct worktree **worktrees = get_worktrees();
 849         int i;
 850
 851         for (i = 0; worktrees[i]; i++) {
 852                 struct ref_store *refs;
 853
 854                 if (worktrees[i]->is_detached)
 855                         continue;
 856                 if (!worktrees[i]->head_ref)
 857                         continue;
 858                 if (strcmp(oldref, worktrees[i]->head_ref))
 859                         continue;
 860
 861                 refs = get_worktree_ref_store(worktrees[i]);
 862                 if (refs_create_symref(refs, "HEAD", newref, logmsg))
 863                         ret = error(_("HEAD of working tree %s is not updated"),
 864                                     worktrees[i]->path);
 865         }
 866
 867         free_worktrees(worktrees);
 868         return ret;
 869 }