branch.c

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