worktree.c

   1 #define USE_THE_REPOSITORY_VARIABLE
   2 #define DISABLE_SIGN_COMPARE_WARNINGS
   3
   4 #include "git-compat-util.h"
   5 #include "abspath.h"
   6 #include "environment.h"
   7 #include "gettext.h"
   8 #include "path.h"
   9 #include "repository.h"
  10 #include "refs.h"
  11 #include "setup.h"
  12 #include "strbuf.h"
  13 #include "worktree.h"
  14 #include "dir.h"
  15 #include "wt-status.h"
  16 #include "config.h"
  17
  18 void free_worktree(struct worktree *worktree)
  19 {
  20         if (!worktree)
  21                 return;
  22         free(worktree->path);
  23         free(worktree->id);
  24         free(worktree->head_ref);
  25         free(worktree->lock_reason);
  26         free(worktree->prune_reason);
  27         free(worktree);
  28 }
  29
  30 void free_worktrees(struct worktree **worktrees)
  31 {
  32         int i = 0;
  33         for (i = 0; worktrees[i]; i++)
  34                 free_worktree(worktrees[i]);
  35         free (worktrees);
  36 }
  37
  38 /**
  39  * Update head_oid, head_ref and is_detached of the given worktree
  40  */
  41 static void add_head_info(struct worktree *wt)
  42 {
  43         int flags;
  44         const char *target;
  45
  46         target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt),
  47                                          "HEAD",
  48                                          0,
  49                                          &wt->head_oid, &flags);
  50         if (!target)
  51                 return;
  52
  53         if (flags & REF_ISSYMREF)
  54                 wt->head_ref = xstrdup(target);
  55         else
  56                 wt->is_detached = 1;
  57 }
  58
  59 static int is_current_worktree(struct worktree *wt)
  60 {
  61         char *git_dir = absolute_pathdup(repo_get_git_dir(the_repository));
  62         char *wt_git_dir = get_worktree_git_dir(wt);
  63         int is_current = !fspathcmp(git_dir, absolute_path(wt_git_dir));
  64         free(wt_git_dir);
  65         free(git_dir);
  66         return is_current;
  67 }
  68
  69 /*
  70 * When in a secondary worktree, and when extensions.worktreeConfig
  71 * is true, only $commondir/config and $commondir/worktrees/<id>/
  72 * config.worktree are consulted, hence any core.bare=true setting in
  73 * $commondir/config.worktree gets overlooked. Thus, check it manually
  74 * to determine if the repository is bare.
  75 */
  76 static int is_main_worktree_bare(struct repository *repo)
  77 {
  78         int bare = 0;
  79         struct config_set cs = {0};
  80         char *worktree_config = xstrfmt("%s/config.worktree", repo_get_common_dir(repo));
  81
  82         git_configset_init(&cs);
  83         git_configset_add_file(&cs, worktree_config);
  84         git_configset_get_bool(&cs, "core.bare", &bare);
  85
  86         git_configset_clear(&cs);
  87         free(worktree_config);
  88         return bare;
  89 }
  90
  91 /**
  92  * get the main worktree
  93  */
  94 static struct worktree *get_main_worktree(int skip_reading_head)
  95 {
  96         struct worktree *worktree = NULL;
  97         struct strbuf worktree_path = STRBUF_INIT;
  98
  99         strbuf_add_real_path(&worktree_path, repo_get_common_dir(the_repository));
 100         strbuf_strip_suffix(&worktree_path, "/.git");
 101
 102         CALLOC_ARRAY(worktree, 1);
 103         worktree->repo = the_repository;
 104         worktree->path = strbuf_detach(&worktree_path, NULL);
 105         worktree->is_current = is_current_worktree(worktree);
 106         worktree->is_bare = (is_bare_repository_cfg == 1) ||
 107                 is_bare_repository() ||
 108                 /*
 109                  * When in a secondary worktree we have to also verify if the main
 110                  * worktree is bare in $commondir/config.worktree.
 111                  * This check is unnecessary if we're currently in the main worktree,
 112                  * as prior checks already consulted all configs of the current worktree.
 113                  */
 114                 (!worktree->is_current && is_main_worktree_bare(the_repository));
 115
 116         if (!skip_reading_head)
 117                 add_head_info(worktree);
 118         return worktree;
 119 }
 120
 121 struct worktree *get_linked_worktree(const char *id,
 122                                      int skip_reading_head)
 123 {
 124         struct worktree *worktree = NULL;
 125         struct strbuf path = STRBUF_INIT;
 126         struct strbuf worktree_path = STRBUF_INIT;
 127
 128         if (!id)
 129                 die("Missing linked worktree name");
 130
 131         repo_common_path_append(the_repository, &path, "worktrees/%s/gitdir", id);
 132         if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0)
 133                 /* invalid gitdir file */
 134                 goto done;
 135         strbuf_rtrim(&worktree_path);
 136         strbuf_strip_suffix(&worktree_path, "/.git");
 137
 138         if (!is_absolute_path(worktree_path.buf)) {
 139                 strbuf_strip_suffix(&path, "gitdir");
 140                 strbuf_addbuf(&path, &worktree_path);
 141                 strbuf_realpath_forgiving(&worktree_path, path.buf, 0);
 142         }
 143
 144         CALLOC_ARRAY(worktree, 1);
 145         worktree->repo = the_repository;
 146         worktree->path = strbuf_detach(&worktree_path, NULL);
 147         worktree->id = xstrdup(id);
 148         worktree->is_current = is_current_worktree(worktree);
 149         if (!skip_reading_head)
 150                 add_head_info(worktree);
 151
 152 done:
 153         strbuf_release(&path);
 154         strbuf_release(&worktree_path);
 155         return worktree;
 156 }
 157
 158 /*
 159  * NEEDSWORK: This function exists so that we can look up metadata of a
 160  * worktree without trying to access any of its internals like the refdb. It
 161  * would be preferable to instead have a corruption-tolerant function for
 162  * retrieving worktree metadata that could be used when the worktree is known
 163  * to not be in a healthy state, e.g. when creating or repairing it.
 164  */
 165 static struct worktree **get_worktrees_internal(int skip_reading_head)
 166 {
 167         struct worktree **list = NULL;
 168         struct strbuf path = STRBUF_INIT;
 169         DIR *dir;
 170         struct dirent *d;
 171         int counter = 0, alloc = 2;
 172
 173         ALLOC_ARRAY(list, alloc);
 174
 175         list[counter++] = get_main_worktree(skip_reading_head);
 176
 177         strbuf_addf(&path, "%s/worktrees", repo_get_common_dir(the_repository));
 178         dir = opendir(path.buf);
 179         strbuf_release(&path);
 180         if (dir) {
 181                 while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) {
 182                         struct worktree *linked = NULL;
 183
 184                         if ((linked = get_linked_worktree(d->d_name, skip_reading_head))) {
 185                                 ALLOC_GROW(list, counter + 1, alloc);
 186                                 list[counter++] = linked;
 187                         }
 188                 }
 189                 closedir(dir);
 190         }
 191         ALLOC_GROW(list, counter + 1, alloc);
 192         list[counter] = NULL;
 193
 194         return list;
 195 }
 196
 197 struct worktree **get_worktrees(void)
 198 {
 199         return get_worktrees_internal(0);
 200 }
 201
 202 struct worktree **get_worktrees_without_reading_head(void)
 203 {
 204         return get_worktrees_internal(1);
 205 }
 206
 207 char *get_worktree_git_dir(const struct worktree *wt)
 208 {
 209         if (!wt)
 210                 return xstrdup(repo_get_git_dir(the_repository));
 211         else if (!wt->id)
 212                 return xstrdup(repo_get_common_dir(the_repository));
 213         else
 214                 return repo_common_path(the_repository, "worktrees/%s", wt->id);
 215 }
 216
 217 static struct worktree *find_worktree_by_suffix(struct worktree **list,
 218                                                 const char *suffix)
 219 {
 220         struct worktree *found = NULL;
 221         int nr_found = 0, suffixlen;
 222
 223         suffixlen = strlen(suffix);
 224         if (!suffixlen)
 225                 return NULL;
 226
 227         for (; *list && nr_found < 2; list++) {
 228                 const char      *path    = (*list)->path;
 229                 int              pathlen = strlen(path);
 230                 int              start   = pathlen - suffixlen;
 231
 232                 /* suffix must start at directory boundary */
 233                 if ((!start || (start > 0 && is_dir_sep(path[start - 1]))) &&
 234                     !fspathcmp(suffix, path + start)) {
 235                         found = *list;
 236                         nr_found++;
 237                 }
 238         }
 239         return nr_found == 1 ? found : NULL;
 240 }
 241
 242 struct worktree *find_worktree(struct worktree **list,
 243                                const char *prefix,
 244                                const char *arg)
 245 {
 246         struct worktree *wt;
 247         char *to_free = NULL;
 248
 249         if ((wt = find_worktree_by_suffix(list, arg)))
 250                 return wt;
 251
 252         if (prefix)
 253                 arg = to_free = prefix_filename(prefix, arg);
 254         wt = find_worktree_by_path(list, arg);
 255         free(to_free);
 256         return wt;
 257 }
 258
 259 struct worktree *find_worktree_by_path(struct worktree **list, const char *p)
 260 {
 261         struct strbuf wt_path = STRBUF_INIT;
 262         char *path = real_pathdup(p, 0);
 263
 264         if (!path)
 265                 return NULL;
 266         for (; *list; list++) {
 267                 if (!strbuf_realpath(&wt_path, (*list)->path, 0))
 268                         continue;
 269
 270                 if (!fspathcmp(path, wt_path.buf))
 271                         break;
 272         }
 273         free(path);
 274         strbuf_release(&wt_path);
 275         return *list;
 276 }
 277
 278 int is_main_worktree(const struct worktree *wt)
 279 {
 280         return !wt->id;
 281 }
 282
 283 const char *worktree_lock_reason(struct worktree *wt)
 284 {
 285         if (is_main_worktree(wt))
 286                 return NULL;
 287
 288         if (!wt->lock_reason_valid) {
 289                 struct strbuf path = STRBUF_INIT;
 290
 291                 strbuf_addstr(&path, worktree_git_path(the_repository, wt, "locked"));
 292                 if (file_exists(path.buf)) {
 293                         struct strbuf lock_reason = STRBUF_INIT;
 294                         if (strbuf_read_file(&lock_reason, path.buf, 0) < 0)
 295                                 die_errno(_("failed to read '%s'"), path.buf);
 296                         strbuf_trim(&lock_reason);
 297                         wt->lock_reason = strbuf_detach(&lock_reason, NULL);
 298                 } else
 299                         wt->lock_reason = NULL;
 300                 wt->lock_reason_valid = 1;
 301                 strbuf_release(&path);
 302         }
 303
 304         return wt->lock_reason;
 305 }
 306
 307 const char *worktree_prune_reason(struct worktree *wt, timestamp_t expire)
 308 {
 309         struct strbuf reason = STRBUF_INIT;
 310         char *path = NULL;
 311
 312         if (is_main_worktree(wt))
 313                 return NULL;
 314         if (wt->prune_reason_valid)
 315                 return wt->prune_reason;
 316
 317         if (should_prune_worktree(wt->id, &reason, &path, expire))
 318                 wt->prune_reason = strbuf_detach(&reason, NULL);
 319         wt->prune_reason_valid = 1;
 320
 321         strbuf_release(&reason);
 322         free(path);
 323         return wt->prune_reason;
 324 }
 325
 326 /* convenient wrapper to deal with NULL strbuf */
 327 __attribute__((format (printf, 2, 3)))
 328 static void strbuf_addf_gently(struct strbuf *buf, const char *fmt, ...)
 329 {
 330         va_list params;
 331
 332         if (!buf)
 333                 return;
 334
 335         va_start(params, fmt);
 336         strbuf_vaddf(buf, fmt, params);
 337         va_end(params);
 338 }
 339
 340 int validate_worktree(const struct worktree *wt, struct strbuf *errmsg,
 341                       unsigned flags)
 342 {
 343         struct strbuf wt_path = STRBUF_INIT;
 344         struct strbuf realpath = STRBUF_INIT;
 345         struct strbuf buf = STRBUF_INIT;
 346         char *path = NULL;
 347         int err, ret = -1;
 348
 349         strbuf_addf(&wt_path, "%s/.git", wt->path);
 350
 351         if (is_main_worktree(wt)) {
 352                 if (is_directory(wt_path.buf)) {
 353                         ret = 0;
 354                         goto done;
 355                 }
 356                 /*
 357                  * Main worktree using .git file to point to the
 358                  * repository would make it impossible to know where
 359                  * the actual worktree is if this function is executed
 360                  * from another worktree. No .git file support for now.
 361                  */
 362                 strbuf_addf_gently(errmsg,
 363                                    _("'%s' at main working tree is not the repository directory"),
 364                                    wt_path.buf);
 365                 goto done;
 366         }
 367
 368         /*
 369          * Make sure "gitdir" file points to a real .git file and that
 370          * file points back here.
 371          */
 372         if (!is_absolute_path(wt->path)) {
 373                 strbuf_addf_gently(errmsg,
 374                                    _("'%s' file does not contain absolute path to the working tree location"),
 375                                    repo_common_path_replace(the_repository, &buf, "worktrees/%s/gitdir", wt->id));
 376                 goto done;
 377         }
 378
 379         if (flags & WT_VALIDATE_WORKTREE_MISSING_OK &&
 380             !file_exists(wt->path)) {
 381                 ret = 0;
 382                 goto done;
 383         }
 384
 385         if (!file_exists(wt_path.buf)) {
 386                 strbuf_addf_gently(errmsg, _("'%s' does not exist"), wt_path.buf);
 387                 goto done;
 388         }
 389
 390         path = xstrdup_or_null(read_gitfile_gently(wt_path.buf, &err));
 391         if (!path) {
 392                 strbuf_addf_gently(errmsg, _("'%s' is not a .git file, error code %d"),
 393                                    wt_path.buf, err);
 394                 goto done;
 395         }
 396
 397         strbuf_realpath(&realpath, repo_common_path_replace(the_repository, &buf, "worktrees/%s", wt->id), 1);
 398         ret = fspathcmp(path, realpath.buf);
 399
 400         if (ret)
 401                 strbuf_addf_gently(errmsg, _("'%s' does not point back to '%s'"),
 402                                    wt->path, repo_common_path_replace(the_repository, &buf,
 403                                                                       "worktrees/%s", wt->id));
 404 done:
 405         free(path);
 406         strbuf_release(&buf);
 407         strbuf_release(&wt_path);
 408         strbuf_release(&realpath);
 409         return ret;
 410 }
 411
 412 void update_worktree_location(struct worktree *wt, const char *path_,
 413                               int use_relative_paths)
 414 {
 415         struct strbuf path = STRBUF_INIT;
 416         struct strbuf dotgit = STRBUF_INIT;
 417         struct strbuf gitdir = STRBUF_INIT;
 418         char *wt_gitdir;
 419
 420         if (is_main_worktree(wt))
 421                 BUG("can't relocate main worktree");
 422
 423         wt_gitdir = repo_common_path(the_repository, "worktrees/%s/gitdir", wt->id);
 424         strbuf_realpath(&gitdir, wt_gitdir, 1);
 425         strbuf_realpath(&path, path_, 1);
 426         strbuf_addf(&dotgit, "%s/.git", path.buf);
 427         if (fspathcmp(wt->path, path.buf)) {
 428                 write_worktree_linking_files(dotgit, gitdir, use_relative_paths);
 429
 430                 free(wt->path);
 431                 wt->path = strbuf_detach(&path, NULL);
 432         }
 433         strbuf_release(&path);
 434         strbuf_release(&dotgit);
 435         strbuf_release(&gitdir);
 436         free(wt_gitdir);
 437 }
 438
 439 int is_worktree_being_rebased(const struct worktree *wt,
 440                               const char *target)
 441 {
 442         struct wt_status_state state;
 443         int found_rebase;
 444
 445         memset(&state, 0, sizeof(state));
 446         found_rebase = wt_status_check_rebase(wt, &state) &&
 447                        (state.rebase_in_progress ||
 448                         state.rebase_interactive_in_progress) &&
 449                        state.branch &&
 450                        skip_prefix(target, "refs/heads/", &target) &&
 451                        !strcmp(state.branch, target);
 452         wt_status_state_free_buffers(&state);
 453         return found_rebase;
 454 }
 455
 456 int is_worktree_being_bisected(const struct worktree *wt,
 457                                const char *target)
 458 {
 459         struct wt_status_state state;
 460         int found_bisect;
 461
 462         memset(&state, 0, sizeof(state));
 463         found_bisect = wt_status_check_bisect(wt, &state) &&
 464                        state.bisecting_from &&
 465                        skip_prefix(target, "refs/heads/", &target) &&
 466                        !strcmp(state.bisecting_from, target);
 467         wt_status_state_free_buffers(&state);
 468         return found_bisect;
 469 }
 470
 471 /*
 472  * note: this function should be able to detect shared symref even if
 473  * HEAD is temporarily detached (e.g. in the middle of rebase or
 474  * bisect). New commands that do similar things should update this
 475  * function as well.
 476  */
 477 int is_shared_symref(const struct worktree *wt, const char *symref,
 478                      const char *target)
 479 {
 480         const char *symref_target;
 481         struct ref_store *refs;
 482         int flags;
 483
 484         if (wt->is_bare)
 485                 return 0;
 486
 487         if (wt->is_detached && !strcmp(symref, "HEAD")) {
 488                 if (is_worktree_being_rebased(wt, target))
 489                         return 1;
 490                 if (is_worktree_being_bisected(wt, target))
 491                         return 1;
 492         }
 493
 494         refs = get_worktree_ref_store(wt);
 495         symref_target = refs_resolve_ref_unsafe(refs, symref, 0,
 496                                                 NULL, &flags);
 497         if ((flags & REF_ISSYMREF) &&
 498             symref_target && !strcmp(symref_target, target))
 499                 return 1;
 500
 501         return 0;
 502 }
 503
 504 const struct worktree *find_shared_symref(struct worktree **worktrees,
 505                                           const char *symref,
 506                                           const char *target)
 507 {
 508
 509         for (int i = 0; worktrees[i]; i++)
 510                 if (is_shared_symref(worktrees[i], symref, target))
 511                         return worktrees[i];
 512
 513         return NULL;
 514 }
 515
 516 int submodule_uses_worktrees(const char *path)
 517 {
 518         char *submodule_gitdir;
 519         struct strbuf sb = STRBUF_INIT, err = STRBUF_INIT;
 520         DIR *dir;
 521         struct dirent *d;
 522         int ret = 0;
 523         struct repository_format format = REPOSITORY_FORMAT_INIT;
 524
 525         submodule_gitdir = repo_submodule_path(the_repository,
 526                                                path, "%s", "");
 527         if (!submodule_gitdir)
 528                 return 0;
 529
 530         /* The env would be set for the superproject. */
 531         get_common_dir_noenv(&sb, submodule_gitdir);
 532         free(submodule_gitdir);
 533
 534         strbuf_addstr(&sb, "/config");
 535         read_repository_format(&format, sb.buf);
 536         if (verify_repository_format(&format, &err)) {
 537                 strbuf_release(&err);
 538                 strbuf_release(&sb);
 539                 clear_repository_format(&format);
 540                 return 1;
 541         }
 542         clear_repository_format(&format);
 543         strbuf_release(&err);
 544
 545         /* Replace config by worktrees. */
 546         strbuf_setlen(&sb, sb.len - strlen("config"));
 547         strbuf_addstr(&sb, "worktrees");
 548
 549         /* See if there is any file inside the worktrees directory. */
 550         dir = opendir(sb.buf);
 551         strbuf_release(&sb);
 552
 553         if (!dir)
 554                 return 0;
 555
 556         d = readdir_skip_dot_and_dotdot(dir);
 557         if (d)
 558                 ret = 1;
 559         closedir(dir);
 560         return ret;
 561 }
 562
 563 void strbuf_worktree_ref(const struct worktree *wt,
 564                          struct strbuf *sb,
 565                          const char *refname)
 566 {
 567         if (parse_worktree_ref(refname, NULL, NULL, NULL) ==
 568                     REF_WORKTREE_CURRENT &&
 569             wt && !wt->is_current) {
 570                 if (is_main_worktree(wt))
 571                         strbuf_addstr(sb, "main-worktree/");
 572                 else
 573                         strbuf_addf(sb, "worktrees/%s/", wt->id);
 574         }
 575         strbuf_addstr(sb, refname);
 576 }
 577
 578 int other_head_refs(each_ref_fn fn, void *cb_data)
 579 {
 580         struct worktree **worktrees, **p;
 581         struct strbuf refname = STRBUF_INIT;
 582         int ret = 0;
 583
 584         worktrees = get_worktrees();
 585         for (p = worktrees; *p; p++) {
 586                 struct worktree *wt = *p;
 587                 struct object_id oid;
 588                 int flag;
 589
 590                 if (wt->is_current)
 591                         continue;
 592
 593                 strbuf_reset(&refname);
 594                 strbuf_worktree_ref(wt, &refname, "HEAD");
 595                 if (refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
 596                                             refname.buf,
 597                                             RESOLVE_REF_READING,
 598                                             &oid, &flag))
 599                         ret = fn(refname.buf, NULL, &oid, flag, cb_data);
 600                 if (ret)
 601                         break;
 602         }
 603         free_worktrees(worktrees);
 604         strbuf_release(&refname);
 605         return ret;
 606 }
 607
 608 /*
 609  * Repair worktree's /path/to/worktree/.git file if missing, corrupt, or not
 610  * pointing at <repo>/worktrees/<id>.
 611  */
 612 static void repair_gitfile(struct worktree *wt,
 613                            worktree_repair_fn fn, void *cb_data,
 614                            int use_relative_paths)
 615 {
 616         struct strbuf dotgit = STRBUF_INIT;
 617         struct strbuf gitdir = STRBUF_INIT;
 618         struct strbuf repo = STRBUF_INIT;
 619         struct strbuf backlink = STRBUF_INIT;
 620         char *dotgit_contents = NULL;
 621         const char *repair = NULL;
 622         char *path = NULL;
 623         int err;
 624
 625         /* missing worktree can't be repaired */
 626         if (!file_exists(wt->path))
 627                 goto done;
 628
 629         if (!is_directory(wt->path)) {
 630                 fn(1, wt->path, _("not a directory"), cb_data);
 631                 goto done;
 632         }
 633
 634         path = repo_common_path(the_repository, "worktrees/%s", wt->id);
 635         strbuf_realpath(&repo, path, 1);
 636         strbuf_addf(&dotgit, "%s/.git", wt->path);
 637         strbuf_addf(&gitdir, "%s/gitdir", repo.buf);
 638         dotgit_contents = xstrdup_or_null(read_gitfile_gently(dotgit.buf, &err));
 639
 640         if (dotgit_contents) {
 641                 if (is_absolute_path(dotgit_contents)) {
 642                         strbuf_addstr(&backlink, dotgit_contents);
 643                 } else {
 644                         strbuf_addf(&backlink, "%s/%s", wt->path, dotgit_contents);
 645                         strbuf_realpath_forgiving(&backlink, backlink.buf, 0);
 646                 }
 647         }
 648
 649         if (err == READ_GITFILE_ERR_NOT_A_FILE)
 650                 fn(1, wt->path, _(".git is not a file"), cb_data);
 651         else if (err)
 652                 repair = _(".git file broken");
 653         else if (fspathcmp(backlink.buf, repo.buf))
 654                 repair = _(".git file incorrect");
 655         else if (use_relative_paths == is_absolute_path(dotgit_contents))
 656                 repair = _(".git file absolute/relative path mismatch");
 657
 658         if (repair) {
 659                 fn(0, wt->path, repair, cb_data);
 660                 write_worktree_linking_files(dotgit, gitdir, use_relative_paths);
 661         }
 662
 663 done:
 664         free(dotgit_contents);
 665         free(path);
 666         strbuf_release(&repo);
 667         strbuf_release(&dotgit);
 668         strbuf_release(&gitdir);
 669         strbuf_release(&backlink);
 670 }
 671
 672 static void repair_noop(int iserr UNUSED,
 673                         const char *path UNUSED,
 674                         const char *msg UNUSED,
 675                         void *cb_data UNUSED)
 676 {
 677         /* nothing */
 678 }
 679
 680 void repair_worktrees(worktree_repair_fn fn, void *cb_data, int use_relative_paths)
 681 {
 682         struct worktree **worktrees = get_worktrees_internal(1);
 683         struct worktree **wt = worktrees + 1; /* +1 skips main worktree */
 684
 685         if (!fn)
 686                 fn = repair_noop;
 687         for (; *wt; wt++)
 688                 repair_gitfile(*wt, fn, cb_data, use_relative_paths);
 689         free_worktrees(worktrees);
 690 }
 691
 692 void repair_worktree_after_gitdir_move(struct worktree *wt, const char *old_path)
 693 {
 694         struct strbuf gitdir = STRBUF_INIT;
 695         struct strbuf dotgit = STRBUF_INIT;
 696         int is_relative_path;
 697         char *path = NULL;
 698
 699         if (is_main_worktree(wt))
 700                 goto done;
 701
 702         path = repo_common_path(the_repository, "worktrees/%s/gitdir", wt->id);
 703         strbuf_realpath(&gitdir, path, 1);
 704
 705         if (strbuf_read_file(&dotgit, gitdir.buf, 0) < 0)
 706                 goto done;
 707
 708         strbuf_rtrim(&dotgit);
 709         is_relative_path = ! is_absolute_path(dotgit.buf);
 710         if (is_relative_path) {
 711                 strbuf_insertf(&dotgit, 0, "%s/worktrees/%s/", old_path, wt->id);
 712                 strbuf_realpath_forgiving(&dotgit, dotgit.buf, 0);
 713         }
 714
 715         if (!file_exists(dotgit.buf))
 716                 goto done;
 717
 718         write_worktree_linking_files(dotgit, gitdir, is_relative_path);
 719 done:
 720         strbuf_release(&gitdir);
 721         strbuf_release(&dotgit);
 722         free(path);
 723 }
 724
 725 void repair_worktrees_after_gitdir_move(const char *old_path)
 726 {
 727         struct worktree **worktrees = get_worktrees_internal(1);
 728         struct worktree **wt = worktrees + 1; /* +1 skips main worktree */
 729
 730         for (; *wt; wt++)
 731                 repair_worktree_after_gitdir_move(*wt, old_path);
 732         free_worktrees(worktrees);
 733 }
 734
 735 static int is_main_worktree_path(const char *path)
 736 {
 737         struct strbuf target = STRBUF_INIT;
 738         struct strbuf maindir = STRBUF_INIT;
 739         int cmp;
 740
 741         strbuf_add_real_path(&target, path);
 742         strbuf_strip_suffix(&target, "/.git");
 743         strbuf_add_real_path(&maindir, repo_get_common_dir(the_repository));
 744         strbuf_strip_suffix(&maindir, "/.git");
 745         cmp = fspathcmp(maindir.buf, target.buf);
 746
 747         strbuf_release(&maindir);
 748         strbuf_release(&target);
 749         return !cmp;
 750 }
 751
 752 /*
 753  * If both the main worktree and linked worktree have been moved, then the
 754  * gitfile /path/to/worktree/.git won't point into the repository, thus we
 755  * won't know which <repo>/worktrees/<id>/gitdir to repair. However, we may
 756  * be able to infer the gitdir by manually reading /path/to/worktree/.git,
 757  * extracting the <id>, and checking if <repo>/worktrees/<id> exists.
 758  *
 759  * Returns -1 on failure and strbuf.len on success.
 760  */
 761 static ssize_t infer_backlink(const char *gitfile, struct strbuf *inferred)
 762 {
 763         struct strbuf actual = STRBUF_INIT;
 764         const char *id;
 765
 766         if (strbuf_read_file(&actual, gitfile, 0) < 0)
 767                 goto error;
 768         if (!starts_with(actual.buf, "gitdir:"))
 769                 goto error;
 770         if (!(id = find_last_dir_sep(actual.buf)))
 771                 goto error;
 772         strbuf_trim(&actual);
 773         id++; /* advance past '/' to point at <id> */
 774         if (!*id)
 775                 goto error;
 776         repo_common_path_replace(the_repository, inferred, "worktrees/%s", id);
 777         if (!is_directory(inferred->buf))
 778                 goto error;
 779
 780         strbuf_release(&actual);
 781         return inferred->len;
 782 error:
 783         strbuf_release(&actual);
 784         strbuf_reset(inferred); /* clear invalid path */
 785         return -1;
 786 }
 787
 788 /*
 789  * Repair <repo>/worktrees/<id>/gitdir if missing, corrupt, or not pointing at
 790  * the worktree's path.
 791  */
 792 void repair_worktree_at_path(const char *path,
 793                              worktree_repair_fn fn, void *cb_data,
 794                              int use_relative_paths)
 795 {
 796         struct strbuf dotgit = STRBUF_INIT;
 797         struct strbuf backlink = STRBUF_INIT;
 798         struct strbuf inferred_backlink = STRBUF_INIT;
 799         struct strbuf gitdir = STRBUF_INIT;
 800         struct strbuf olddotgit = STRBUF_INIT;
 801         char *dotgit_contents = NULL;
 802         const char *repair = NULL;
 803         int err;
 804
 805         if (!fn)
 806                 fn = repair_noop;
 807
 808         if (is_main_worktree_path(path))
 809                 goto done;
 810
 811         strbuf_addf(&dotgit, "%s/.git", path);
 812         if (!strbuf_realpath(&dotgit, dotgit.buf, 0)) {
 813                 fn(1, path, _("not a valid path"), cb_data);
 814                 goto done;
 815         }
 816
 817         infer_backlink(dotgit.buf, &inferred_backlink);
 818         strbuf_realpath_forgiving(&inferred_backlink, inferred_backlink.buf, 0);
 819         dotgit_contents = xstrdup_or_null(read_gitfile_gently(dotgit.buf, &err));
 820         if (dotgit_contents) {
 821                 if (is_absolute_path(dotgit_contents)) {
 822                         strbuf_addstr(&backlink, dotgit_contents);
 823                 } else {
 824                         strbuf_addbuf(&backlink, &dotgit);
 825                         strbuf_strip_suffix(&backlink, ".git");
 826                         strbuf_addstr(&backlink, dotgit_contents);
 827                         strbuf_realpath_forgiving(&backlink, backlink.buf, 0);
 828                 }
 829         } else if (err == READ_GITFILE_ERR_NOT_A_FILE) {
 830                 fn(1, dotgit.buf, _("unable to locate repository; .git is not a file"), cb_data);
 831                 goto done;
 832         } else if (err == READ_GITFILE_ERR_NOT_A_REPO) {
 833                 if (inferred_backlink.len) {
 834                         /*
 835                          * Worktree's .git file does not point at a repository
 836                          * but we found a .git/worktrees/<id> in this
 837                          * repository with the same <id> as recorded in the
 838                          * worktree's .git file so make the worktree point at
 839                          * the discovered .git/worktrees/<id>.
 840                          */
 841                         strbuf_swap(&backlink, &inferred_backlink);
 842                 } else {
 843                         fn(1, dotgit.buf, _("unable to locate repository; .git file does not reference a repository"), cb_data);
 844                         goto done;
 845                 }
 846         } else {
 847                 fn(1, dotgit.buf, _("unable to locate repository; .git file broken"), cb_data);
 848                 goto done;
 849         }
 850
 851         /*
 852          * If we got this far, either the worktree's .git file pointed at a
 853          * valid repository (i.e. read_gitfile_gently() returned success) or
 854          * the .git file did not point at a repository but we were able to
 855          * infer a suitable new value for the .git file by locating a
 856          * .git/worktrees/<id> in *this* repository corresponding to the <id>
 857          * recorded in the worktree's .git file.
 858          *
 859          * However, if, at this point, inferred_backlink is non-NULL (i.e. we
 860          * found a suitable .git/worktrees/<id> in *this* repository) *and* the
 861          * worktree's .git file points at a valid repository *and* those two
 862          * paths differ, then that indicates that the user probably *copied*
 863          * the main and linked worktrees to a new location as a unit rather
 864          * than *moving* them. Thus, the copied worktree's .git file actually
 865          * points at the .git/worktrees/<id> in the *original* repository, not
 866          * in the "copy" repository. In this case, point the "copy" worktree's
 867          * .git file at the "copy" repository.
 868          */
 869         if (inferred_backlink.len && fspathcmp(backlink.buf, inferred_backlink.buf))
 870                 strbuf_swap(&backlink, &inferred_backlink);
 871
 872         strbuf_addf(&gitdir, "%s/gitdir", backlink.buf);
 873         if (strbuf_read_file(&olddotgit, gitdir.buf, 0) < 0)
 874                 repair = _("gitdir unreadable");
 875         else if (use_relative_paths == is_absolute_path(olddotgit.buf))
 876                 repair = _("gitdir absolute/relative path mismatch");
 877         else {
 878                 strbuf_rtrim(&olddotgit);
 879                 if (!is_absolute_path(olddotgit.buf)) {
 880                         strbuf_insertf(&olddotgit, 0, "%s/", backlink.buf);
 881                         strbuf_realpath_forgiving(&olddotgit, olddotgit.buf, 0);
 882                 }
 883                 if (fspathcmp(olddotgit.buf, dotgit.buf))
 884                         repair = _("gitdir incorrect");
 885         }
 886
 887         if (repair) {
 888                 fn(0, gitdir.buf, repair, cb_data);
 889                 write_worktree_linking_files(dotgit, gitdir, use_relative_paths);
 890         }
 891 done:
 892         free(dotgit_contents);
 893         strbuf_release(&olddotgit);
 894         strbuf_release(&backlink);
 895         strbuf_release(&inferred_backlink);
 896         strbuf_release(&gitdir);
 897         strbuf_release(&dotgit);
 898 }
 899
 900 int should_prune_worktree(const char *id, struct strbuf *reason, char **wtpath, timestamp_t expire)
 901 {
 902         struct stat st;
 903         struct strbuf dotgit = STRBUF_INIT;
 904         struct strbuf gitdir = STRBUF_INIT;
 905         struct strbuf repo = STRBUF_INIT;
 906         struct strbuf file = STRBUF_INIT;
 907         char *path = NULL;
 908         int rc = 0;
 909         int fd;
 910         size_t len;
 911         ssize_t read_result;
 912
 913         *wtpath = NULL;
 914
 915         path = repo_common_path(the_repository, "worktrees/%s", id);
 916         strbuf_realpath(&repo, path, 1);
 917         FREE_AND_NULL(path);
 918
 919         strbuf_addf(&gitdir, "%s/gitdir", repo.buf);
 920         if (!is_directory(repo.buf)) {
 921                 strbuf_addstr(reason, _("not a valid directory"));
 922                 rc = 1;
 923                 goto done;
 924         }
 925         strbuf_addf(&file, "%s/locked", repo.buf);
 926         if (file_exists(file.buf)) {
 927                 goto done;
 928         }
 929         if (stat(gitdir.buf, &st)) {
 930                 strbuf_addstr(reason, _("gitdir file does not exist"));
 931                 rc = 1;
 932                 goto done;
 933         }
 934         fd = open(gitdir.buf, O_RDONLY);
 935         if (fd < 0) {
 936                 strbuf_addf(reason, _("unable to read gitdir file (%s)"),
 937                             strerror(errno));
 938                 rc = 1;
 939                 goto done;
 940         }
 941         len = xsize_t(st.st_size);
 942         path = xmallocz(len);
 943
 944         read_result = read_in_full(fd, path, len);
 945         close(fd);
 946         if (read_result < 0) {
 947                 strbuf_addf(reason, _("unable to read gitdir file (%s)"),
 948                             strerror(errno));
 949                 rc = 1;
 950                 goto done;
 951         } else if (read_result != len) {
 952                 strbuf_addf(reason,
 953                             _("short read (expected %"PRIuMAX" bytes, read %"PRIuMAX")"),
 954                             (uintmax_t)len, (uintmax_t)read_result);
 955                 rc = 1;
 956                 goto done;
 957         }
 958         while (len && (path[len - 1] == '\n' || path[len - 1] == '\r'))
 959                 len--;
 960         if (!len) {
 961                 strbuf_addstr(reason, _("invalid gitdir file"));
 962                 rc = 1;
 963                 goto done;
 964         }
 965         path[len] = '\0';
 966         if (is_absolute_path(path)) {
 967                 strbuf_addstr(&dotgit, path);
 968         } else {
 969                 strbuf_addf(&dotgit, "%s/%s", repo.buf, path);
 970                 strbuf_realpath_forgiving(&dotgit, dotgit.buf, 0);
 971         }
 972         if (!file_exists(dotgit.buf)) {
 973                 strbuf_reset(&file);
 974                 strbuf_addf(&file, "%s/index", repo.buf);
 975                 if (stat(file.buf, &st) || st.st_mtime <= expire) {
 976                         strbuf_addstr(reason, _("gitdir file points to non-existent location"));
 977                         rc = 1;
 978                         goto done;
 979                 }
 980         }
 981         *wtpath = strbuf_detach(&dotgit, NULL);
 982 done:
 983         free(path);
 984         strbuf_release(&dotgit);
 985         strbuf_release(&gitdir);
 986         strbuf_release(&repo);
 987         strbuf_release(&file);
 988         return rc;
 989 }
 990
 991 static int move_config_setting(const char *key, const char *value,
 992                                const char *from_file, const char *to_file)
 993 {
 994         if (git_config_set_in_file_gently(to_file, key, NULL, value))
 995                 return error(_("unable to set %s in '%s'"), key, to_file);
 996         if (git_config_set_in_file_gently(from_file, key, NULL, NULL))
 997                 return error(_("unable to unset %s in '%s'"), key, from_file);
 998         return 0;
 999 }
1000
1001 int init_worktree_config(struct repository *r)
1002 {
1003         int res = 0;
1004         int bare = 0;
1005         struct config_set cs = { { 0 } };
1006         const char *core_worktree;
1007         char *common_config_file;
1008         char *main_worktree_file;
1009
1010         /*
1011          * If the extension is already enabled, then we can skip the
1012          * upgrade process.
1013          */
1014         if (r->repository_format_worktree_config)
1015                 return 0;
1016         if ((res = git_config_set_gently("extensions.worktreeConfig", "true")))
1017                 return error(_("failed to set extensions.worktreeConfig setting"));
1018
1019         common_config_file = xstrfmt("%s/config", r->commondir);
1020         main_worktree_file = xstrfmt("%s/config.worktree", r->commondir);
1021
1022         git_configset_init(&cs);
1023         git_configset_add_file(&cs, common_config_file);
1024
1025         /*
1026          * If core.bare is true in the common config file, then we need to
1027          * move it to the main worktree's config file or it will break all
1028          * worktrees. If it is false, then leave it in place because it
1029          * _could_ be negating a global core.bare=true.
1030          */
1031         if (!git_configset_get_bool(&cs, "core.bare", &bare) && bare) {
1032                 if ((res = move_config_setting("core.bare", "true",
1033                                                common_config_file,
1034                                                main_worktree_file)))
1035                         goto cleanup;
1036         }
1037         /*
1038          * If core.worktree is set, then the main worktree is located
1039          * somewhere different than the parent of the common Git dir.
1040          * Relocate that value to avoid breaking all worktrees with this
1041          * upgrade to worktree config.
1042          */
1043         if (!git_configset_get_value(&cs, "core.worktree", &core_worktree, NULL)) {
1044                 if ((res = move_config_setting("core.worktree", core_worktree,
1045                                                common_config_file,
1046                                                main_worktree_file)))
1047                         goto cleanup;
1048         }
1049
1050         /*
1051          * Ensure that we use worktree config for the remaining lifetime
1052          * of the current process.
1053          */
1054         r->repository_format_worktree_config = 1;
1055
1056 cleanup:
1057         git_configset_clear(&cs);
1058         free(common_config_file);
1059         free(main_worktree_file);
1060         return res;
1061 }
1062
1063 void write_worktree_linking_files(struct strbuf dotgit, struct strbuf gitdir,
1064                                   int use_relative_paths)
1065 {
1066         struct strbuf path = STRBUF_INIT;
1067         struct strbuf repo = STRBUF_INIT;
1068         struct strbuf tmp = STRBUF_INIT;
1069
1070         strbuf_addbuf(&path, &dotgit);
1071         strbuf_strip_suffix(&path, "/.git");
1072         strbuf_realpath(&path, path.buf, 1);
1073         strbuf_addbuf(&repo, &gitdir);
1074         strbuf_strip_suffix(&repo, "/gitdir");
1075         strbuf_realpath(&repo, repo.buf, 1);
1076
1077         if (use_relative_paths && !the_repository->repository_format_relative_worktrees) {
1078                 if (upgrade_repository_format(1) < 0)
1079                         die(_("unable to upgrade repository format to support relative worktrees"));
1080                 if (git_config_set_gently("extensions.relativeWorktrees", "true"))
1081                         die(_("unable to set extensions.relativeWorktrees setting"));
1082                 the_repository->repository_format_relative_worktrees = 1;
1083         }
1084
1085         if (use_relative_paths) {
1086                 write_file(gitdir.buf, "%s/.git", relative_path(path.buf, repo.buf, &tmp));
1087                 write_file(dotgit.buf, "gitdir: %s", relative_path(repo.buf, path.buf, &tmp));
1088         } else {
1089                 write_file(gitdir.buf, "%s/.git", path.buf);
1090                 write_file(dotgit.buf, "gitdir: %s", repo.buf);
1091         }
1092
1093         strbuf_release(&path);
1094         strbuf_release(&repo);
1095         strbuf_release(&tmp);
1096 }