UI, Workflows & Features

------------------------

Performance, Internal Implementation, Development Support etc.

--------------------------------------------------------------

allocation function given to it may fail to allocate and to deal

with such an error.

Fixes since v2.47

-----------------

had been identified and fixed.

(merge fc5589d6c1 ds/line-log-asan-fix later to maint).

* Other code cleanup, docfix, build fix, etc.

(merge 66893a14d0 ps/leakfixes-part-8 later to maint).

(merge 1164e270b5 jk/output-prefix-cleanup later to maint).

Changing or clearing this value will only affect fetches for new commits.

To fetch associated objects for commits already present in the local object

database, use the `--refetch` option of linkgit:git-fetch[1].

unknown ones, is server-specific.

When multiple `--server-option=<option>` are given, they are all

sent to the other side in the order listed on the command line.

--show-forced-updates::

By default, git checks if a branch is force-updated during

`--overlay`), and currently doesn't support overlay mode.

--ignore-other-worktrees::

--overwrite-ignore::

--no-overwrite-ignore::

unknown ones, is server-specific.

When multiple `--server-option=<option>` are given, they are all

sent to the other side in the order listed on the command line.

`-n`::

`--no-checkout`::

'git config list' [<file-option>] [<display-option>] [--includes]

'git config get' [<file-option>] [<display-option>] [--includes] [--all] [--regexp] [--value=<value>] [--fixed-value] [--default=<default>] <name>

'git config set' [<file-option>] [--type=<type>] [--all] [--value=<value>] [--fixed-value] <name> <value>

'git config rename-section' [<file-option>] <old-name> <new-name>

'git config remove-section' [<file-option>] <name>

'git config edit' [<file-option>]

character.

When multiple `--server-option=<option>` are given, they are all

sent to the other side in the order listed on the command line.

<repository>::

The "remote" repository to query. This parameter can be

linkgit:git-update-ref[1], and linkgit:git-mktag[1]. Thus, it can be

used as a part of a series of steps such as:

git update-ref $BRANCH1 $NEWCOMMIT

Note that when the exit status is non-zero, `NEWTREE` in this sequence

running `repair` from any worktree with each tree's new `<path>` as an

argument, will reestablish the connection to all the specified paths.

+

then running `repair` in the main worktree and specifying the new `<path>`

of each linked worktree will reestablish all connections in both

directions.

The provided options must not contain a NUL or LF character.

The server can advertise the `object-format` capability with a value `X` (in the

form `object-format=X`) to notify the client that the server is able to deal

+

The format of a <refspec> parameter is an optional plus

`+`, followed by the source <src>, followed

The colon can be omitted when <dst> is empty. <src> is

name.

+

A <refspec> may contain a `*` in its <src> to indicate a simple pattern

match. Such a refspec functions like a glob that matches any ref with the

<dst>. It will map refs to the destination by replacing the `*` with the

contents matched from the source.

+

notice problems before they are considered "done with review"; whereas

watching `master` means the stable branch could break for your platform, but

you have a decent chance of avoiding a tagged release breaking you. See "The

overview of which branches are used in the Git project, and how.

* The bug report should include information about what platform you are using.

To avoid reactive debugging and fixing when changes hit a release or stable, you

can aim to ensure `next` always works for your platform. (See "The Policy" in

`next` is used in the Git project.) To do that:

* You should add a runner for your platform to the GitHub Actions or GitLab CI

N_("update ignored files (default)"),

PARSE_OPT_NOCOMPLETE),

OPT_BOOL(0, "ignore-other-worktrees", &opts->ignore_other_worktrees,

OPT_END()

};

struct option *newopts = parse_options_concat(prevopts, options);

N_("git config list [<file-option>] [<display-option>] [--includes]"),

N_("git config get [<file-option>] [<display-option>] [--includes] [--all] [--regexp] [--value=<value>] [--fixed-value] [--default=<default>] <name>"),

N_("git config set [<file-option>] [--type=<type>] [--all] [--value=<value>] [--fixed-value] <name> <value>"),

N_("git config rename-section [<file-option>] <old-name> <new-name>"),

N_("git config remove-section [<file-option>] <name>"),

N_("git config edit [<file-option>]"),

};

static const char *const builtin_config_unset_usage[] = {

NULL

};

strvec_pushl(&argv, "-c", "fetch.bundleURI=",

"fetch", "--append", "--no-auto-gc",

"--no-write-commit-graph", NULL);

add_options_to_argv(&argv, config);

if (max_children != 1 && list->nr != 1) {

* system event listener thread so that we have the IPC handle

* before we need it.

*/

return error_errno(

_("could not start IPC thread pool on '%s'"),

state->path_ipc.buf);

* | Input | Output |

* | *cmd | return code | *out | *is_available |

* +-------+-------------+-------------------+---------------+

* +-------+-------------+-------------------+---------------+

*

* GIT_TEST_MAINT_SCHEDULER set to “foo:./mock_foo.sh,bar:./mock_bar.sh”

struct string_list_item *item;

struct string_list list = STRING_LIST_INIT_NODUP;

return 0;

if (is_available)

*is_available = 0;

transport_ls_refs_options_release(&transport_options);

strvec_clear(&pattern);

return status;

}

RECURSE_SUBMODULES_ON_DEMAND : RECURSE_SUBMODULES_OFF;

recurse_submodules = val;

} else if (!strcmp(k, "push.pushoption")) {

} else if (!strcmp(k, "color.push")) {

push_use_color = git_config_colorbool(k, v);

return 0;

const struct add_opts *opts)

{

struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;

const char *name;

struct strvec child_env = STRVEC_INIT;

unsigned int counter = 0;

strbuf_reset(&sb);

strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);

strbuf_reset(&sb);

strbuf_addf(&sb, "%s/commondir", sb_repo.buf);

write_file(sb.buf, "../..");

strvec_clear(&child_env);

strbuf_release(&sb);

strbuf_release(&symref);

strbuf_release(&sb_repo);

strbuf_release(&sb_git);

strbuf_release(&sb_name);

free_worktree(wt);

return ret;

}

struct strbuf bundle_ref = STRBUF_INIT;

size_t bundle_prefix_len;

/*

* Skip the reachability walk here, since we will be adding

* a reachable ref pointing to the new tips, which will reach

* the prerequisite commits.

*/

/*

* Convert all refs/heads/ from the bundle into refs/bundles/

0, UPDATE_REFS_MSG_ON_ERR);

}

bundle_header_release(&header);

return result;

}

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "hex.h"

#include "lockfile.h"

#include "tree.h"

return 0;

}

{

struct cache_entry *ce = istate->cache[pos];

if (!S_ISSPARSEDIR(ce->ce_mode))

}

/*

* 1 - Restart verification - a call to ensure_full_index() freed the cache

* tree that is being verified and verification needs to be restarted from

* the new toplevel cache tree.

*/

static int verify_one(struct repository *r,

struct index_state *istate,

int i, pos, len = path->len;

struct strbuf tree_buf = STRBUF_INIT;

struct object_id new_oid;

for (i = 0; i < it->subtree_nr; i++) {

strbuf_addf(path, "%s/", it->down[i]->name);

strbuf_setlen(path, len);

}

if (it->entry_count < 0 ||

/* no verification on tests (t7003) that replace trees */

if (path->len) {

/*

*/

int is_sparse = istate->sparse_index;

pos = index_name_pos(istate, path->buf, path->len);

if (pos >= 0) {

}

pos = -pos - 1;

pos = 0;

}

i = 0;

while (i < it->entry_count) {

struct cache_entry *ce = istate->cache[pos + i];

unsigned mode;

int entlen;

name = ce->name + path->len;

slash = strchr(name, '/');

if (slash) {

entlen = slash - name;

sub = find_subtree(it, ce->name + path->len, entlen, 0);

oid = &sub->cache_tree->oid;

mode = S_IFDIR;

i += sub->cache_tree->entry_count;

strbuf_addf(&tree_buf, "%o %.*s%c", mode, entlen, name, '\0');

strbuf_add(&tree_buf, oid->hash, r->hash_algo->rawsz);

}

hash_object_file(r->hash_algo, tree_buf.buf, tree_buf.len, OBJ_TREE,

&new_oid);

strbuf_setlen(path, len);

strbuf_release(&tree_buf);

}

{

struct strbuf path = STRBUF_INIT;

strbuf_reset(&path);

BUG("ensure_full_index() called twice while verifying cache tree");

}

strbuf_release(&path);

}

int cache_tree_fully_valid(struct cache_tree *);

int cache_tree_update(struct index_state *, int);

/* bitmasks to write_index_as_tree flags */

#define WRITE_TREE_MISSING_OK 1

}

data->stream_started = 1;

pthread_mutex_lock(&data->dq_lock);

pthread_cond_wait(&data->dq_finished, &data->dq_lock);

pthread_mutex_unlock(&data->dq_lock);

start_rdcw_watch(data->watch_gitdir) == -1)

goto force_error_stop;

for (;;) {

dwWait = WaitForMultipleObjects(data->nr_listener_handles,

data->hListener,

struct ipc_server_data *server_data = NULL;

int ret;

if (ret)

return ret;

ret = ipc_server_await(server_data);

ipc_server_free(server_data);

int back_pos;

int front_pos;

int shutdown_requested;

int is_stopped;

};

/*

* Start IPC server in a pool of background threads.

*/

{

struct unix_ss_socket *server_socket = NULL;

struct ipc_server_data *server_data;

server_data->accept_thread->fd_send_shutdown = sv[0];

server_data->accept_thread->fd_wait_shutdown = sv[1];

if (pthread_create(&server_data->accept_thread->pthread_id, NULL,

accept_thread_proc, server_data->accept_thread))

die_errno(_("could not start accept_thread '%s'"), path);

return 0;

}

/*

* Gently tell the IPC server treads to shutdown.

* Can be run on any thread.

trace2_region_enter("ipc-server", "server-stop-async", NULL);

server_data->shutdown_requested = 1;

HANDLE hEventStopRequested;

struct ipc_server_thread_data *thread_list;

int is_stopped;

};

enum connect_result {

return ret;

}

/*

* Thread proc for an IPC server worker thread. It handles a series of

* connections from clients. It cleans and reuses the hPipe between each

memset(&oConnect, 0, sizeof(oConnect));

oConnect.hEvent = hEventConnected;

for (;;) {

cr = wait_for_connection(server_thread_data, &oConnect);

return hPipe;

}

{

struct ipc_server_data *server_data;

wchar_t wpath[MAX_PATH];

strbuf_addstr(&server_data->buf_path, path);

wcscpy(server_data->wpath, wpath);

if (nr_threads < 1)

nr_threads = 1;

return 0;

}

int ipc_server_stop_async(struct ipc_server_data *server_data)

{

if (!server_data)

* We DO NOT attempt to force them to drop an active connection.

*/

SetEvent(server_data->hEventStopRequested);

return 0;

}

free(std);

}

free(server_data);

}

for_each_string_list_item(item, filter->exclude_ref_config_pattern) {

normalize_glob_ref(item, NULL, item->string);

}

}

decoration_loaded = 1;

decoration_flags = flags;

}

}

static void show_parents(struct commit *commit, int abbrev, FILE *file)

{

struct commit_list *p;

int *need_8bit_cte_p,

int maybe_multipart);

void load_ref_decorations(struct decoration_filter *filter, int flags);

void fmt_output_commit(struct strbuf *, struct commit *, struct rev_info *);

void fmt_output_subject(struct strbuf *, const char *subject, struct rev_info *);

#include "git-compat-util.h"

#include "hash.h"

#include "path.h"

#include "object-store.h"

#include "hex.h"

#include "wrapper.h"

#include "gettext.h"

#include "loose.h"

for (; iter != kh_end(map); iter++) {

if (kh_exist(map, iter)) {

continue;

strbuf_addf(&buf, "%s %s\n", oid_to_hex(&kh_key(map, iter)), oid_to_hex(kh_value(map, iter)));

if (write_in_full(fd, buf.buf, buf.len) < 0)

int new_shared_index, ret, test_split_index_env;

struct split_index *si = istate->split_index;

if ((flags & SKIP_IF_UNCHANGED) && !istate->cache_changed) {

if (flags & COMMIT_LOCK)

#include "advice.h"

#include "connect.h"

#include "parse-options.h"

enum map_direction { FROM_SRC, FROM_DST };

ret->name = xstrndup(name, len);

refspec_init(&ret->push, REFSPEC_PUSH);

refspec_init(&ret->fetch, REFSPEC_FETCH);

ALLOC_GROW(remote_state->remotes, remote_state->remotes_nr + 1,

remote_state->remotes_alloc);

free((char *)remote->uploadpack);

FREE_AND_NULL(remote->http_proxy);

FREE_AND_NULL(remote->http_proxy_authmethod);

}

static void add_merge(struct branch *branch, const char *name)

} else if (!strcmp(subkey, "vcs")) {

FREE_AND_NULL(remote->foreign_vcs);

return git_config_string(&remote->foreign_vcs, key, value);

}

return 0;

}

#include "hash.h"

#include "hashmap.h"

#include "refspec.h"

#include "strvec.h"

struct option;

/* The method used for authenticating against `http_proxy`. */

char *http_proxy_authmethod;

};

/**

int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;

int skipped_commit = 0;

struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;

struct commit_list *commits = NULL, **tail = &commits, *iter;

struct commit_list *tips = NULL, **tips_tail = &tips;

struct commit *commit;

oidmap_init(&state.commit2label, 0);

hashmap_init(&state.labels, labels_cmp, NULL, 0);

strbuf_init(&state.buf, 32);

if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {

struct labels_entry *onto_label_entry;

continue;

}

if (skip_prefix(oneline.buf, "Merge ", &p1) &&

(p1 = strchr(p1, '\'')) &&

(p2 = strchr(++p1, '\'')))

else if (skip_prefix(oneline.buf, "Merge pull request ",

&p1) &&

(p1 = strstr(p1, " from ")))

else

strbuf_reset(&buf);

strbuf_addf(&buf, "%s -C %s",

/* label the tips of merged branches */

for (; to_merge; to_merge = to_merge->next) {

oid = &to_merge->item->object.oid;

strbuf_addch(&buf, ' ');

tips_tail = &commit_list_insert(to_merge->item,

tips_tail)->next;

}

strbuf_addf(&buf, " # %s", oneline.buf);

free_commit_list(commits);

free_commit_list(tips);

strbuf_release(&oneline);

strbuf_release(&buf);

static int todo_list_add_update_ref_commands(struct todo_list *todo_list)

{

int i, res;

struct todo_add_branch_context ctx = {

.buf = &todo_list->buf,

.refs_to_oids = STRING_LIST_INIT_DUP,

ctx.items_alloc = 2 * todo_list->nr + 1;

ALLOC_ARRAY(ctx.items, ctx.items_alloc);

for (i = 0; i < todo_list->nr; ) {

struct todo_item *item = &todo_list->items[i];

if (rename(src, git_dir))

die_errno(_("unable to move %s to %s"), src, git_dir);

}

write_file(git_link, "gitdir: %s", git_dir);

* When a client IPC message is received, the `application_cb` will be

* called (possibly on a random thread) to handle the message and

* optionally compose a reply message.

*/

/*

* Gently signal the IPC server pool to shutdown. No new client

! test -d .git/worktrees/wt

'

test_done

test_cmp expect-gitfile sidemoved/.git

'

test_done

pick $(git log -1 --format=%h branch2~1) F

pick $(git log -1 --format=%h branch2) I

update-ref refs/heads/branch2

reset onto

pick $(git log -1 --format=%h refs/heads/second) J

update-ref refs/heads/second

update-ref refs/heads/third

pick $(git log -1 --format=%h HEAD~2) M

update-ref refs/heads/no-conflict-branch

update-ref refs/heads/merge-branch

EOF

reset onto

pick $b B

reset onto

pick $c C

label branch-point

pick $f F

pick $g G

reset branch-point # C

pick $d D

EOF

'

test_expect_success 'labels that are object IDs are rewritten' '

test_commit I &&

third=$(git rev-parse HEAD) &&

git checkout -b labels main &&

test_tick &&

git commit -m "Merge commit '\''$third'\'' into labels" &&

echo noop >script-from-scratch &&

# that the diff output isn't wildly unreasonable.

test_description='test tree diff when trees have duplicate entries'

. ./test-lib.sh

# make_tree_entry <mode> <mode> <sha1>

rm commit_id up final

'

'

git checkout base &&

'

git checkout base &&

GIT_TEST_CHECK_CACHE_TREE=false &&

git reset --hard &&

'

test_expect_failure 'can switch to another branch when status is empty' '

grep "server-option=world" log

'

test_expect_success 'warn if using server-option with ls-remote with legacy protocol' '

test_must_fail env GIT_TEST_PROTOCOL_VERSION=0 git -c protocol.version=0 \

ls-remote -o hello -o world "file://$(pwd)/file_parent" main 2>err &&

grep "server-option=world" log

'

test_expect_success 'warn if using server-option with fetch with legacy protocol' '

test_when_finished "rm -rf temp_child" &&

grep "server-option=world" log

'

test_expect_success 'warn if using server-option with clone with legacy protocol' '

test_when_finished "rm -rf myclone" &&

test_grep "server options require protocol version 2 or later" err

'

test_expect_success 'upload-pack respects config using protocol v2' '

git init server &&

write_script server/.git/hook <<-\EOF &&

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean &&

git update-index --no-skip-worktree .gitignore &&

git checkout .gitignore

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean src/ &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean src/ src/ &&

'

mkdir -p build docs src/test &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so src/test/1.c &&

(cd src/ && git clean) &&

'

mkdir -p build docs src/feature &&

touch a.out src/part3.c src/feature/file.c docs/manual.txt obj.o build/lib.so &&

(cd src/ && git clean -d feature/) &&

'

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

ln -s docs/manual.txt src/part4.c &&

git clean &&

'

touch a.clean b.clean other.c &&

git clean "*.clean" &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -n &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -d &&

'

mkdir -p build docs examples &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so examples/1.c &&

git clean -d src/ examples/ &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -x &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -d -x &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -d -x -e src &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -X &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -d -X &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -d -X -e src &&

'

mkdir -p build docs &&

touch a.out src/part3.c docs/manual.txt obj.o build/lib.so &&

git clean -n &&

'

test_expect_success 'clean.requireForce and -f' '

git clean -f &&

'

test_commit deeply.nested deeper.world

) &&

git clean -f -d &&

'

test_expect_success 'should clean things that almost look like git but are not' '

test_commit deeply.nested deeper.world

) &&

git clean -f -f -d &&

'

test_expect_success 'git clean -e' '

touch known 1 2 3 &&

git add known &&

git clean -f -e 1 -e 2 &&

)

'

mkdir foo &&

chmod a= foo &&

git clean -dfx foo &&

'

test_expect_success 'git clean -d respects pathspecs (dir is prefix of pathspec)' '

maintenance.repo "$(pwd)/$META"

'

test_expect_success 'start --scheduler=<scheduler>' '

test_expect_code 129 git maintenance start --scheduler=foo 2>err &&

test_grep "unrecognized --scheduler argument" err &&

data->version = discover_version(&reader);

switch (data->version) {

case protocol_v2:

if (server_feature_v2("session-id", &server_sid))

trace2_data_string("transfer", NULL, "server-sid", server_sid);

if (must_list_refs)

BUG("invalid protocol_allow_config type");

}

void transport_check_allowed(const char *type)

{

if (!is_transport_allowed(type, -1))

/* common method used by transport-helper.c and send-pack.c */

void reject_atomic_push(struct ref *refs, int mirror_mode);

#endif

if (!o->merge)

BUG("We need cache-tree to do this optimization");

/*

* Do what unpack_callback() and unpack_single_entry() normally

if (o->dst_index) {

move_index_extensions(&o->internal.result, o->src_index);

if (!ret) {

if (!o->skip_cache_tree_update &&

!cache_tree_fully_valid(o->internal.result.cache_tree))

cache_tree_update(&o->internal.result,

strbuf_rtrim(&worktree_path);

strbuf_strip_suffix(&worktree_path, "/.git");

CALLOC_ARRAY(worktree, 1);

worktree->repo = the_repository;

worktree->path = strbuf_detach(&worktree_path, NULL);

void update_worktree_location(struct worktree *wt, const char *path_)

{

struct strbuf path = STRBUF_INIT;

if (is_main_worktree(wt))

BUG("can't relocate main worktree");

strbuf_realpath(&path, path_, 1);

if (fspathcmp(wt->path, path.buf)) {

free(wt->path);

wt->path = strbuf_detach(&path, NULL);

}

strbuf_release(&path);

}

int is_worktree_being_rebased(const struct worktree *wt,

{

struct strbuf dotgit = STRBUF_INIT;

struct strbuf repo = STRBUF_INIT;

const char *repair = NULL;

int err;

/* missing worktree can't be repaired */

if (!file_exists(wt->path))

if (!is_directory(wt->path)) {

fn(1, wt->path, _("not a directory"), cb_data);

}

strbuf_realpath(&repo, git_common_path("worktrees/%s", wt->id), 1);

strbuf_addf(&dotgit, "%s/.git", wt->path);

if (err == READ_GITFILE_ERR_NOT_A_FILE)

fn(1, wt->path, _(".git is not a file"), cb_data);

else if (err)

repair = _(".git file broken");

repair = _(".git file incorrect");

if (repair) {

fn(0, wt->path, repair, cb_data);

}

strbuf_release(&repo);

strbuf_release(&dotgit);

}

static void repair_noop(int iserr UNUSED,

free_worktrees(worktrees);

}

static int is_main_worktree_path(const char *path)

{

struct strbuf target = STRBUF_INIT;

* be able to infer the gitdir by manually reading /path/to/worktree/.git,

* extracting the <id>, and checking if <repo>/worktrees/<id> exists.

*/

{

struct strbuf actual = STRBUF_INIT;

const char *id;

if (strbuf_read_file(&actual, gitfile, 0) < 0)

id++; /* advance past '/' to point at <id> */

if (!*id)

goto error;

goto error;

strbuf_release(&actual);

error:

strbuf_release(&actual);

}

/*

{

struct strbuf dotgit = STRBUF_INIT;

struct strbuf realdotgit = STRBUF_INIT;

struct strbuf gitdir = STRBUF_INIT;

struct strbuf olddotgit = STRBUF_INIT;

const char *repair = NULL;

int err;

goto done;

}

fn(1, realdotgit.buf, _("unable to locate repository; .git is not a file"), cb_data);

goto done;

} else if (err == READ_GITFILE_ERR_NOT_A_REPO) {

fn(1, realdotgit.buf, _("unable to locate repository; .git file does not reference a repository"), cb_data);

goto done;

}

fn(1, realdotgit.buf, _("unable to locate repository; .git file broken"), cb_data);

goto done;

}

if (strbuf_read_file(&olddotgit, gitdir.buf, 0) < 0)

repair = _("gitdir unreadable");

else {

strbuf_rtrim(&olddotgit);

repair = _("gitdir incorrect");

}

if (repair) {

fn(0, gitdir.buf, repair, cb_data);

}

done:

strbuf_release(&olddotgit);

strbuf_release(&gitdir);

strbuf_release(&realdotgit);

strbuf_release(&dotgit);

}

int should_prune_worktree(const char *id, struct strbuf *reason, char **wtpath, timestamp_t expire)

{

struct stat st;

int fd;

size_t len;

ssize_t read_result;

*wtpath = NULL;

strbuf_addstr(reason, _("not a valid directory"));

}

strbuf_addstr(reason, _("gitdir file does not exist"));

}

if (fd < 0) {

strbuf_addf(reason, _("unable to read gitdir file (%s)"),

strerror(errno));

}

len = xsize_t(st.st_size);

path = xmallocz(len);

read_result = read_in_full(fd, path, len);

if (read_result < 0) {

strbuf_addf(reason, _("unable to read gitdir file (%s)"),

strerror(errno));

strbuf_addf(reason,

_("short read (expected %"PRIuMAX" bytes, read %"PRIuMAX")"),

(uintmax_t)len, (uintmax_t)read_result);

}

while (len && (path[len - 1] == '\n' || path[len - 1] == '\r'))

len--;

if (!len) {

strbuf_addstr(reason, _("invalid gitdir file"));

}

path[len] = '\0';

strbuf_addstr(reason, _("gitdir file points to non-existent location"));

}

}

}

static int move_config_setting(const char *key, const char *value,

void repair_worktrees(worktree_repair_fn, void *cb_data);

/*

* Repair administrative files corresponding to the worktree at the given path.

* The worktree's .git file pointing at the repository must be intact for the

* repair to succeed. Useful for re-associating an orphaned worktree with the