* [PATCH 01/18] setup: replace use of `the_repository` in static functions
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 02/18] setup: stop using `the_repository` in `is_inside_worktree()` Patrick Steinhardt
` (17 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Replace the use of `the_repository` in "setup.c" for all static
functions. For now, we simply add `the_repository` to invocations of
these functions. This will be addressed in subsequent commits, where
we'll move up `the_repository` one more layer to callers of "setup.c".
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
setup.c | 188 ++++++++++++++++++++++++++++++++++------------------------------
1 file changed, 100 insertions(+), 88 deletions(-)
diff --git a/setup.c b/setup.c
index 7ec4427368..ba2898473a 100644
--- a/setup.c
+++ b/setup.c
@@ -50,13 +50,13 @@ const char *tmp_original_cwd;
* /dir/repolink/file (repolink points to /dir/repo) -> file
* /dir/repo (exactly equal to work tree) -> (empty string)
*/
-static int abspath_part_inside_repo(char *path)
+static int abspath_part_inside_repo(struct repository *repo, char *path)
{
size_t len;
size_t wtlen;
char *path0;
int off;
- const char *work_tree = precompose_string_if_needed(repo_get_work_tree(the_repository));
+ const char *work_tree = precompose_string_if_needed(repo_get_work_tree(repo));
struct strbuf realpath = STRBUF_INIT;
if (!work_tree)
@@ -132,7 +132,7 @@ char *prefix_path_gently(const char *prefix, int len,
free(sanitized);
return NULL;
}
- if (abspath_part_inside_repo(sanitized)) {
+ if (abspath_part_inside_repo(the_repository, sanitized)) {
free(sanitized);
return NULL;
}
@@ -509,7 +509,7 @@ void setup_work_tree(void)
initialized = 1;
}
-static void setup_original_cwd(void)
+static void setup_original_cwd(struct repository *repo)
{
struct strbuf tmp = STRBUF_INIT;
const char *worktree = NULL;
@@ -535,9 +535,9 @@ static void setup_original_cwd(void)
/* Normalize the directory */
if (!strbuf_realpath(&tmp, tmp_original_cwd, 0)) {
- trace2_data_string("setup", the_repository,
+ trace2_data_string("setup", repo,
"realpath-path", tmp_original_cwd);
- trace2_data_string("setup", the_repository,
+ trace2_data_string("setup", repo,
"realpath-failure", strerror(errno));
free((char*)tmp_original_cwd);
tmp_original_cwd = NULL;
@@ -552,7 +552,7 @@ static void setup_original_cwd(void)
* Get our worktree; we only protect the current working directory
* if it's in the worktree.
*/
- worktree = repo_get_work_tree(the_repository);
+ worktree = repo_get_work_tree(repo);
if (!worktree)
goto no_prevention_needed;
@@ -747,7 +747,10 @@ static int check_repo_format(const char *var, const char *value,
return read_worktree_config(var, value, ctx, vdata);
}
-static int check_repository_format_gently(const char *gitdir, struct repository_format *candidate, int *nongit_ok)
+static int check_repository_format_gently(struct repository *repo,
+ const char *gitdir,
+ struct repository_format *candidate,
+ int *nongit_ok)
{
struct strbuf sb = STRBUF_INIT;
struct strbuf err = STRBUF_INIT;
@@ -776,7 +779,7 @@ static int check_repository_format_gently(const char *gitdir, struct repository_
die("%s", err.buf);
}
- the_repository->repository_format_precious_objects = candidate->precious_objects;
+ repo->repository_format_precious_objects = candidate->precious_objects;
string_list_clear(&candidate->unknown_extensions, 0);
string_list_clear(&candidate->v1_only_extensions, 0);
@@ -1034,7 +1037,8 @@ const char *read_gitfile_gently(const char *path, int *return_error_code)
return error_code ? NULL : path;
}
-static void setup_git_env_internal(const char *git_dir,
+static void setup_git_env_internal(struct repository *repo,
+ const char *git_dir,
bool skip_initializing_odb)
{
char *git_replace_ref_base;
@@ -1052,7 +1056,7 @@ static void setup_git_env_internal(const char *git_dir,
args.disable_ref_updates = true;
args.skip_initializing_odb = skip_initializing_odb;
- repo_set_gitdir(the_repository, git_dir, &args);
+ repo_set_gitdir(repo, git_dir, &args);
strvec_clear(&to_free);
if (getenv(NO_REPLACE_OBJECTS_ENVIRONMENT))
@@ -1064,7 +1068,7 @@ static void setup_git_env_internal(const char *git_dir,
shallow_file = getenv(GIT_SHALLOW_FILE_ENVIRONMENT);
if (shallow_file)
- set_alternate_shallow_file(the_repository, shallow_file, 0);
+ set_alternate_shallow_file(repo, shallow_file, 0);
if (git_env_bool(NO_LAZY_FETCH_ENVIRONMENT, 0))
fetch_if_missing = 0;
@@ -1072,30 +1076,31 @@ static void setup_git_env_internal(const char *git_dir,
void setup_git_env(const char *git_dir)
{
- setup_git_env_internal(git_dir, false);
+ setup_git_env_internal(the_repository, git_dir, false);
}
-static void set_git_dir_1(const char *path, bool skip_initializing_odb)
+static void set_git_dir_1(struct repository *repo, const char *path, bool skip_initializing_odb)
{
xsetenv(GIT_DIR_ENVIRONMENT, path, 1);
- setup_git_env_internal(path, skip_initializing_odb);
+ setup_git_env_internal(repo, path, skip_initializing_odb);
}
static void update_relative_gitdir(const char *name UNUSED,
const char *old_cwd,
const char *new_cwd,
- void *data UNUSED)
+ void *data)
{
+ struct repository *repo = data;
char *path = reparent_relative_path(old_cwd, new_cwd,
- repo_get_git_dir(the_repository));
+ repo_get_git_dir(repo));
trace_printf_key(&trace_setup_key,
"setup: move $GIT_DIR to '%s'",
path);
- set_git_dir_1(path, true);
+ set_git_dir_1(repo, path, true);
free(path);
}
-static void set_git_dir(const char *path, int make_realpath)
+static void set_git_dir(struct repository *repo, const char *path, int make_realpath)
{
struct strbuf realpath = STRBUF_INIT;
@@ -1104,14 +1109,15 @@ static void set_git_dir(const char *path, int make_realpath)
path = realpath.buf;
}
- set_git_dir_1(path, false);
+ set_git_dir_1(repo, path, false);
if (!is_absolute_path(path))
- chdir_notify_register(NULL, update_relative_gitdir, NULL);
+ chdir_notify_register(NULL, update_relative_gitdir, repo);
strbuf_release(&realpath);
}
-static const char *setup_explicit_git_dir(const char *gitdirenv,
+static const char *setup_explicit_git_dir(struct repository *repo,
+ const char *gitdirenv,
struct strbuf *cwd,
struct repository_format *repo_fmt,
int *nongit_ok)
@@ -1139,7 +1145,7 @@ static const char *setup_explicit_git_dir(const char *gitdirenv,
die(_("not a git repository: '%s'"), gitdirenv);
}
- if (check_repository_format_gently(gitdirenv, repo_fmt, nongit_ok)) {
+ if (check_repository_format_gently(repo, gitdirenv, repo_fmt, nongit_ok)) {
free(gitfile);
return NULL;
}
@@ -1155,7 +1161,7 @@ static const char *setup_explicit_git_dir(const char *gitdirenv,
}
/* #18, #26 */
- set_git_dir(gitdirenv, 0);
+ set_git_dir(repo, gitdirenv, 0);
free(gitfile);
return NULL;
}
@@ -1177,7 +1183,7 @@ static const char *setup_explicit_git_dir(const char *gitdirenv,
}
else if (!git_env_bool(GIT_IMPLICIT_WORK_TREE_ENVIRONMENT, 1)) {
/* #16d */
- set_git_dir(gitdirenv, 0);
+ set_git_dir(repo, gitdirenv, 0);
free(gitfile);
return NULL;
}
@@ -1185,18 +1191,18 @@ static const char *setup_explicit_git_dir(const char *gitdirenv,
set_git_work_tree(".");
/* set_git_work_tree() must have been called by now */
- worktree = repo_get_work_tree(the_repository);
+ worktree = repo_get_work_tree(repo);
/* both repo_get_work_tree() and cwd are already normalized */
if (!strcmp(cwd->buf, worktree)) { /* cwd == worktree */
- set_git_dir(gitdirenv, 0);
+ set_git_dir(repo, gitdirenv, 0);
free(gitfile);
return NULL;
}
offset = dir_inside_of(cwd->buf, worktree);
if (offset >= 0) { /* cwd inside worktree? */
- set_git_dir(gitdirenv, 1);
+ set_git_dir(repo, gitdirenv, 1);
if (chdir(worktree))
die_errno(_("cannot chdir to '%s'"), worktree);
strbuf_addch(cwd, '/');
@@ -1205,17 +1211,18 @@ static const char *setup_explicit_git_dir(const char *gitdirenv,
}
/* cwd outside worktree */
- set_git_dir(gitdirenv, 0);
+ set_git_dir(repo, gitdirenv, 0);
free(gitfile);
return NULL;
}
-static const char *setup_discovered_git_dir(const char *gitdir,
+static const char *setup_discovered_git_dir(struct repository *repo,
+ const char *gitdir,
struct strbuf *cwd, int offset,
struct repository_format *repo_fmt,
int *nongit_ok)
{
- if (check_repository_format_gently(gitdir, repo_fmt, nongit_ok))
+ if (check_repository_format_gently(repo, gitdir, repo_fmt, nongit_ok))
return NULL;
/* --work-tree is set without --git-dir; use discovered one */
@@ -1227,14 +1234,14 @@ static const char *setup_discovered_git_dir(const char *gitdir,
gitdir = to_free = real_pathdup(gitdir, 1);
if (chdir(cwd->buf))
die_errno(_("cannot come back to cwd"));
- ret = setup_explicit_git_dir(gitdir, cwd, repo_fmt, nongit_ok);
+ ret = setup_explicit_git_dir(repo, gitdir, cwd, repo_fmt, nongit_ok);
free(to_free);
return ret;
}
/* #16.2, #17.2, #20.2, #21.2, #24, #25, #28, #29 (see t1510) */
if (is_bare_repository_cfg > 0) {
- set_git_dir(gitdir, (offset != cwd->len));
+ set_git_dir(repo, gitdir, (offset != cwd->len));
if (chdir(cwd->buf))
die_errno(_("cannot come back to cwd"));
return NULL;
@@ -1243,7 +1250,7 @@ static const char *setup_discovered_git_dir(const char *gitdir,
/* #0, #1, #5, #8, #9, #12, #13 */
set_git_work_tree(".");
if (strcmp(gitdir, DEFAULT_GIT_DIR_ENVIRONMENT))
- set_git_dir(gitdir, 0);
+ set_git_dir(repo, gitdir, 0);
inside_git_dir = 0;
inside_work_tree = 1;
if (offset >= cwd->len)
@@ -1258,13 +1265,14 @@ static const char *setup_discovered_git_dir(const char *gitdir,
}
/* #16.1, #17.1, #20.1, #21.1, #22.1 (see t1510) */
-static const char *setup_bare_git_dir(struct strbuf *cwd, int offset,
+static const char *setup_bare_git_dir(struct repository *repo,
+ struct strbuf *cwd, int offset,
struct repository_format *repo_fmt,
int *nongit_ok)
{
int root_len;
- if (check_repository_format_gently(".", repo_fmt, nongit_ok))
+ if (check_repository_format_gently(repo, ".", repo_fmt, nongit_ok))
return NULL;
setenv(GIT_IMPLICIT_WORK_TREE_ENVIRONMENT, "0", 1);
@@ -1276,7 +1284,7 @@ static const char *setup_bare_git_dir(struct strbuf *cwd, int offset,
gitdir = offset == cwd->len ? "." : xmemdupz(cwd->buf, offset);
if (chdir(cwd->buf))
die_errno(_("cannot come back to cwd"));
- return setup_explicit_git_dir(gitdir, cwd, repo_fmt, nongit_ok);
+ return setup_explicit_git_dir(repo, gitdir, cwd, repo_fmt, nongit_ok);
}
inside_git_dir = 1;
@@ -1286,10 +1294,10 @@ static const char *setup_bare_git_dir(struct strbuf *cwd, int offset,
die_errno(_("cannot come back to cwd"));
root_len = offset_1st_component(cwd->buf);
strbuf_setlen(cwd, offset > root_len ? offset : root_len);
- set_git_dir(cwd->buf, 0);
+ set_git_dir(repo, cwd->buf, 0);
}
else
- set_git_dir(".", 0);
+ set_git_dir(repo, ".", 0);
return NULL;
}
@@ -1827,7 +1835,7 @@ const char *enter_repo(const char *path, unsigned flags)
}
if (is_git_directory(".")) {
- set_git_dir(".", 0);
+ set_git_dir(the_repository, ".", 0);
check_repository_format(NULL);
return path;
}
@@ -1891,18 +1899,18 @@ const char *setup_git_directory_gently(int *nongit_ok)
switch (setup_git_directory_gently_1(&dir, &gitdir, &report, 1)) {
case GIT_DIR_EXPLICIT:
- prefix = setup_explicit_git_dir(gitdir.buf, &cwd, &repo_fmt, nongit_ok);
+ prefix = setup_explicit_git_dir(the_repository, gitdir.buf, &cwd, &repo_fmt, nongit_ok);
break;
case GIT_DIR_DISCOVERED:
if (dir.len < cwd.len && chdir(dir.buf))
die(_("cannot change to '%s'"), dir.buf);
- prefix = setup_discovered_git_dir(gitdir.buf, &cwd, dir.len,
+ prefix = setup_discovered_git_dir(the_repository, gitdir.buf, &cwd, dir.len,
&repo_fmt, nongit_ok);
break;
case GIT_DIR_BARE:
if (dir.len < cwd.len && chdir(dir.buf))
die(_("cannot change to '%s'"), dir.buf);
- prefix = setup_bare_git_dir(&cwd, dir.len, &repo_fmt, nongit_ok);
+ prefix = setup_bare_git_dir(the_repository, &cwd, dir.len, &repo_fmt, nongit_ok);
break;
case GIT_DIR_HIT_CEILING:
if (!nongit_ok)
@@ -2044,7 +2052,7 @@ const char *setup_git_directory_gently(int *nongit_ok)
free(payload);
}
- setup_original_cwd();
+ setup_original_cwd(the_repository);
strbuf_release(&dir);
strbuf_release(&gitdir);
@@ -2110,7 +2118,7 @@ void check_repository_format(struct repository_format *fmt)
struct repository_format repo_fmt = REPOSITORY_FORMAT_INIT;
if (!fmt)
fmt = &repo_fmt;
- check_repository_format_gently(repo_get_git_dir(the_repository), fmt, NULL);
+ check_repository_format_gently(the_repository, repo_get_git_dir(the_repository), fmt, NULL);
startup_info->have_repository = 1;
repo_set_hash_algo(the_repository, fmt->hash_algo);
repo_set_compat_hash_algo(the_repository, fmt->compat_hash_algo);
@@ -2239,7 +2247,9 @@ const char *get_template_dir(const char *option_template)
#define GIT_DEFAULT_HASH_ENVIRONMENT "GIT_DEFAULT_HASH"
-static void copy_templates_1(struct strbuf *path, struct strbuf *template_path,
+static void copy_templates_1(struct repository *repo,
+ struct strbuf *path,
+ struct strbuf *template_path,
DIR *dir)
{
size_t path_baselen = path->len;
@@ -2253,7 +2263,7 @@ static void copy_templates_1(struct strbuf *path, struct strbuf *template_path,
* with the way the namespace under .git/ is organized, should
* be really carefully chosen.
*/
- safe_create_dir(the_repository, path->buf, 1);
+ safe_create_dir(repo, path->buf, 1);
while ((de = readdir(dir)) != NULL) {
struct stat st_git, st_template;
int exists = 0;
@@ -2281,7 +2291,7 @@ static void copy_templates_1(struct strbuf *path, struct strbuf *template_path,
die_errno(_("cannot opendir '%s'"), template_path->buf);
strbuf_addch(path, '/');
strbuf_addch(template_path, '/');
- copy_templates_1(path, template_path, subdir);
+ copy_templates_1(repo, path, template_path, subdir);
closedir(subdir);
}
else if (exists)
@@ -2306,7 +2316,7 @@ static void copy_templates_1(struct strbuf *path, struct strbuf *template_path,
}
}
-static void copy_templates(const char *option_template)
+static void copy_templates(struct repository *repo, const char *option_template)
{
const char *template_dir = get_template_dir(option_template);
struct strbuf path = STRBUF_INIT;
@@ -2347,9 +2357,9 @@ static void copy_templates(const char *option_template)
goto close_free_return;
}
- strbuf_addstr(&path, repo_get_common_dir(the_repository));
+ strbuf_addstr(&path, repo_get_common_dir(repo));
strbuf_complete(&path, '/');
- copy_templates_1(&path, &template_path, dir);
+ copy_templates_1(repo, &path, &template_path, dir);
close_free_return:
closedir(dir);
free_return:
@@ -2443,13 +2453,13 @@ void initialize_repository_version(int hash_algo,
strbuf_release(&repo_version);
}
-static int is_reinit(void)
+static int is_reinit(struct repository *repo)
{
struct strbuf buf = STRBUF_INIT;
char junk[2];
int ret;
- repo_git_path_replace(the_repository, &buf, "HEAD");
+ repo_git_path_replace(repo, &buf, "HEAD");
ret = !access(buf.buf, R_OK) || readlink(buf.buf, junk, sizeof(junk) - 1) != -1;
strbuf_release(&buf);
return ret;
@@ -2459,7 +2469,7 @@ void create_reference_database(const char *initial_branch, int quiet)
{
struct strbuf err = STRBUF_INIT;
char *to_free = NULL;
- int reinit = is_reinit();
+ int reinit = is_reinit(the_repository);
if (ref_store_create_on_disk(get_main_ref_store(the_repository), 0, &err))
die("failed to set up refs db: %s", err.buf);
@@ -2493,7 +2503,8 @@ void create_reference_database(const char *initial_branch, int quiet)
free(to_free);
}
-static int create_default_files(const char *template_path,
+static int create_default_files(struct repository *repo,
+ const char *template_path,
const char *original_git_dir,
const struct repository_format *fmt,
int init_shared_repository)
@@ -2502,7 +2513,7 @@ static int create_default_files(const char *template_path,
struct strbuf path = STRBUF_INIT;
int reinit;
int filemode;
- const char *work_tree = repo_get_work_tree(the_repository);
+ const char *work_tree = repo_get_work_tree(repo);
/*
* First copy the templates -- we might have the default
@@ -2513,19 +2524,19 @@ static int create_default_files(const char *template_path,
* values (since we've just potentially changed what's available on
* disk).
*/
- copy_templates(template_path);
- repo_config_clear(the_repository);
- repo_settings_reset_shared_repository(the_repository);
- repo_config(the_repository, git_default_config, NULL);
+ copy_templates(repo, template_path);
+ repo_config_clear(repo);
+ repo_settings_reset_shared_repository(repo);
+ repo_config(repo, git_default_config, NULL);
- reinit = is_reinit();
+ reinit = is_reinit(repo);
/*
* We must make sure command-line options continue to override any
* values we might have just re-read from the config.
*/
if (init_shared_repository != -1)
- repo_settings_set_shared_repository(the_repository,
+ repo_settings_set_shared_repository(repo,
init_shared_repository);
is_bare_repository_cfg = !work_tree;
@@ -2534,14 +2545,14 @@ static int create_default_files(const char *template_path,
* We would have created the above under user's umask -- under
* shared-repository settings, we would need to fix them up.
*/
- if (repo_settings_get_shared_repository(the_repository)) {
- adjust_shared_perm(the_repository, repo_get_git_dir(the_repository));
+ if (repo_settings_get_shared_repository(repo)) {
+ adjust_shared_perm(repo, repo_get_git_dir(repo));
}
initialize_repository_version(fmt->hash_algo, fmt->ref_storage_format, reinit);
/* Check filemode trustability */
- repo_git_path_replace(the_repository, &path, "config");
+ repo_git_path_replace(repo, &path, "config");
filemode = TEST_FILEMODE;
if (TEST_FILEMODE && !lstat(path.buf, &st1)) {
struct stat st2;
@@ -2552,22 +2563,22 @@ static int create_default_files(const char *template_path,
if (filemode && !reinit && (st1.st_mode & S_IXUSR))
filemode = 0;
}
- repo_config_set(the_repository, "core.filemode", filemode ? "true" : "false");
+ repo_config_set(repo, "core.filemode", filemode ? "true" : "false");
if (is_bare_repository())
- repo_config_set(the_repository, "core.bare", "true");
+ repo_config_set(repo, "core.bare", "true");
else {
- repo_config_set(the_repository, "core.bare", "false");
+ repo_config_set(repo, "core.bare", "false");
/* allow template config file to override the default */
- if (repo_settings_get_log_all_ref_updates(the_repository) == LOG_REFS_UNSET)
- repo_config_set(the_repository, "core.logallrefupdates", "true");
+ if (repo_settings_get_log_all_ref_updates(repo) == LOG_REFS_UNSET)
+ repo_config_set(repo, "core.logallrefupdates", "true");
if (needs_work_tree_config(original_git_dir, work_tree))
- repo_config_set(the_repository, "core.worktree", work_tree);
+ repo_config_set(repo, "core.worktree", work_tree);
}
if (!reinit) {
/* Check if symlink is supported in the work tree */
- repo_git_path_replace(the_repository, &path, "tXXXXXX");
+ repo_git_path_replace(repo, &path, "tXXXXXX");
if (!close(xmkstemp(path.buf)) &&
!unlink(path.buf) &&
!symlink("testing", path.buf) &&
@@ -2575,12 +2586,12 @@ static int create_default_files(const char *template_path,
S_ISLNK(st1.st_mode))
unlink(path.buf); /* good */
else
- repo_config_set(the_repository, "core.symlinks", "false");
+ repo_config_set(repo, "core.symlinks", "false");
/* Check if the filesystem is case-insensitive */
- repo_git_path_replace(the_repository, &path, "CoNfIg");
+ repo_git_path_replace(repo, &path, "CoNfIg");
if (!access(path.buf, F_OK))
- repo_config_set(the_repository, "core.ignorecase", "true");
+ repo_config_set(repo, "core.ignorecase", "true");
probe_utf8_pathname_composition();
}
@@ -2588,23 +2599,23 @@ static int create_default_files(const char *template_path,
return reinit;
}
-static void create_object_directory(void)
+static void create_object_directory(struct repository *repo)
{
struct strbuf path = STRBUF_INIT;
size_t baselen;
- strbuf_addstr(&path, repo_get_object_directory(the_repository));
+ strbuf_addstr(&path, repo_get_object_directory(repo));
baselen = path.len;
- safe_create_dir(the_repository, path.buf, 1);
+ safe_create_dir(repo, path.buf, 1);
strbuf_setlen(&path, baselen);
strbuf_addstr(&path, "/pack");
- safe_create_dir(the_repository, path.buf, 1);
+ safe_create_dir(repo, path.buf, 1);
strbuf_setlen(&path, baselen);
strbuf_addstr(&path, "/info");
- safe_create_dir(the_repository, path.buf, 1);
+ safe_create_dir(repo, path.buf, 1);
strbuf_release(&path);
}
@@ -2682,7 +2693,8 @@ static int read_default_format_config(const char *key, const char *value,
return ret;
}
-static void repository_format_configure(struct repository_format *repo_fmt,
+static void repository_format_configure(struct repository *repo,
+ struct repository_format *repo_fmt,
int hash, enum ref_storage_format ref_format)
{
struct default_format_config cfg = {
@@ -2719,7 +2731,7 @@ static void repository_format_configure(struct repository_format *repo_fmt,
} else if (cfg.hash != GIT_HASH_UNKNOWN) {
repo_fmt->hash_algo = cfg.hash;
}
- repo_set_hash_algo(the_repository, repo_fmt->hash_algo);
+ repo_set_hash_algo(repo, repo_fmt->hash_algo);
env = getenv("GIT_DEFAULT_REF_FORMAT");
if (repo_fmt->version >= 0 &&
@@ -2758,7 +2770,7 @@ static void repository_format_configure(struct repository_format *repo_fmt,
free(backend);
}
- repo_set_ref_storage_format(the_repository, repo_fmt->ref_storage_format,
+ repo_set_ref_storage_format(repo, repo_fmt->ref_storage_format,
repo_fmt->ref_storage_payload);
}
@@ -2782,12 +2794,12 @@ int init_db(const char *git_dir, const char *real_git_dir,
if (!exist_ok && !stat(real_git_dir, &st))
die(_("%s already exists"), real_git_dir);
- set_git_dir(real_git_dir, 1);
+ set_git_dir(the_repository, real_git_dir, 1);
git_dir = repo_get_git_dir(the_repository);
separate_git_dir(git_dir, original_git_dir);
}
else {
- set_git_dir(git_dir, 1);
+ set_git_dir(the_repository, git_dir, 1);
git_dir = repo_get_git_dir(the_repository);
}
startup_info->have_repository = 1;
@@ -2800,7 +2812,7 @@ int init_db(const char *git_dir, const char *real_git_dir,
*/
check_repository_format(&repo_fmt);
- repository_format_configure(&repo_fmt, hash, ref_storage_format);
+ repository_format_configure(the_repository, &repo_fmt, hash, ref_storage_format);
/*
* Ensure `core.hidedotfiles` is processed. This must happen after we
@@ -2811,12 +2823,12 @@ int init_db(const char *git_dir, const char *real_git_dir,
safe_create_dir(the_repository, git_dir, 0);
- reinit = create_default_files(template_dir, original_git_dir,
+ reinit = create_default_files(the_repository, template_dir, original_git_dir,
&repo_fmt, init_shared_repository);
if (!(flags & INIT_DB_SKIP_REFDB))
create_reference_database(initial_branch, flags & INIT_DB_QUIET);
- create_object_directory();
+ create_object_directory(the_repository);
if (repo_settings_get_shared_repository(the_repository)) {
char buf[10];
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 02/18] setup: stop using `the_repository` in `is_inside_worktree()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 01/18] setup: replace use of `the_repository` in static functions Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-04-09 11:55 ` Karthik Nayak
2026-03-30 13:17 ` [PATCH 03/18] setup: stop using `the_repository` in `is_inside_git_dir()` Patrick Steinhardt
` (16 subsequent siblings)
18 siblings, 1 reply; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
The function `is_inside_worktree()` verifies whether or not the current
working directory is located inside the worktree of `the_repository`.
This is done by taking the worktree path and verifying that it's a
prefix of the current working directory.
This information is cached so that we don't have to re-do this change
multiple times. Furthermore, we proactively set the value in multiple
locations so that we don't even have to perform the check when we have
discovered the repository.
While we could simply move the caching variable into the repository, the
current layout doesn't really feel sensible in the first place:
- It can easily lead to false positives or negatives if at any point
in time we may switch the current working directory.
- We don't call the function in a hot loop, and neither is it overly
expensive to compute.
Drop the caching infrastructure and instead compute the property ad-hoc
via an injected repository.
Note that there is one small gotcha: we sometimes may end up with
relative directory paths, and if so `is_inside_dir()` might fail. This
wasn't an issue before because of how we proactively set the cached
value during repository discovery. Now that we stop doing that it
becomes a problem though, but it is worked around by resolving the
repository directory via `realpath()`.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/ls-files.c | 2 +-
builtin/rev-parse.c | 4 ++--
object-name.c | 2 +-
setup.c | 18 +++++++-----------
setup.h | 2 +-
submodule.c | 2 +-
6 files changed, 13 insertions(+), 17 deletions(-)
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index b148607f7a..09d95111b3 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -703,7 +703,7 @@ int cmd_ls_files(int argc,
if (dir.exclude_per_dir)
exc_given = 1;
- if (require_work_tree && !is_inside_work_tree())
+ if (require_work_tree && !is_inside_work_tree(repo))
setup_work_tree();
if (recurse_submodules &&
diff --git a/builtin/rev-parse.c b/builtin/rev-parse.c
index 01a62800e8..9629e1ccf7 100644
--- a/builtin/rev-parse.c
+++ b/builtin/rev-parse.c
@@ -1006,7 +1006,7 @@ int cmd_rev_parse(int argc,
}
if (!strcmp(arg, "--show-cdup")) {
const char *pfx = prefix;
- if (!is_inside_work_tree()) {
+ if (!is_inside_work_tree(the_repository)) {
const char *work_tree =
repo_get_work_tree(the_repository);
if (work_tree)
@@ -1068,7 +1068,7 @@ int cmd_rev_parse(int argc,
continue;
}
if (!strcmp(arg, "--is-inside-work-tree")) {
- printf("%s\n", is_inside_work_tree() ? "true"
+ printf("%s\n", is_inside_work_tree(the_repository) ? "true"
: "false");
continue;
}
diff --git a/object-name.c b/object-name.c
index e5adec4c9d..7b7e546b1f 100644
--- a/object-name.c
+++ b/object-name.c
@@ -1990,7 +1990,7 @@ static char *resolve_relative_path(struct repository *r, const char *rel)
if (!starts_with(rel, "./") && !starts_with(rel, "../"))
return NULL;
- if (r != the_repository || !is_inside_work_tree())
+ if (r != the_repository || !is_inside_work_tree(the_repository))
die(_("relative path syntax can't be used outside working tree"));
/* die() inside prefix_path() if resolved path is outside worktree */
diff --git a/setup.c b/setup.c
index ba2898473a..4df65ba2e8 100644
--- a/setup.c
+++ b/setup.c
@@ -27,7 +27,6 @@
#include "worktree.h"
static int inside_git_dir = -1;
-static int inside_work_tree = -1;
static int work_tree_config_is_bogus;
enum allowed_bare_repo {
ALLOWED_BARE_REPO_EXPLICIT = 0,
@@ -299,7 +298,7 @@ void verify_filename(const char *prefix,
*/
void verify_non_filename(const char *prefix, const char *arg)
{
- if (!is_inside_work_tree() || is_inside_git_dir())
+ if (!is_inside_work_tree(the_repository) || is_inside_git_dir())
return;
if (*arg == '-')
return; /* flag */
@@ -477,11 +476,13 @@ int is_inside_git_dir(void)
return inside_git_dir;
}
-int is_inside_work_tree(void)
+int is_inside_work_tree(struct repository *repo)
{
- if (inside_work_tree < 0)
- inside_work_tree = is_inside_dir(repo_get_work_tree(the_repository));
- return inside_work_tree;
+ static struct strbuf buf = STRBUF_INIT;
+ const char *worktree = repo_get_work_tree(repo);
+ if (!worktree)
+ return 0;
+ return is_inside_dir(strbuf_realpath(&buf, worktree, 1));
}
void setup_work_tree(void)
@@ -798,13 +799,10 @@ static int check_repository_format_gently(struct repository *repo,
if (!has_common) {
if (candidate->is_bare != -1) {
is_bare_repository_cfg = candidate->is_bare;
- if (is_bare_repository_cfg == 1)
- inside_work_tree = -1;
}
if (candidate->work_tree) {
free(git_work_tree_cfg);
git_work_tree_cfg = xstrdup(candidate->work_tree);
- inside_work_tree = -1;
}
}
@@ -1252,7 +1250,6 @@ static const char *setup_discovered_git_dir(struct repository *repo,
if (strcmp(gitdir, DEFAULT_GIT_DIR_ENVIRONMENT))
set_git_dir(repo, gitdir, 0);
inside_git_dir = 0;
- inside_work_tree = 1;
if (offset >= cwd->len)
return NULL;
@@ -1288,7 +1285,6 @@ static const char *setup_bare_git_dir(struct repository *repo,
}
inside_git_dir = 1;
- inside_work_tree = 0;
if (offset != cwd->len) {
if (chdir(cwd->buf))
die_errno(_("cannot come back to cwd"));
diff --git a/setup.h b/setup.h
index 80bc6e5f07..7c0aa75319 100644
--- a/setup.h
+++ b/setup.h
@@ -5,7 +5,7 @@
#include "string-list.h"
int is_inside_git_dir(void);
-int is_inside_work_tree(void);
+int is_inside_work_tree(struct repository *repo);
int get_common_dir_noenv(struct strbuf *sb, const char *gitdir);
int get_common_dir(struct strbuf *sb, const char *gitdir);
diff --git a/submodule.c b/submodule.c
index e20537ba8d..46116cee88 100644
--- a/submodule.c
+++ b/submodule.c
@@ -2622,7 +2622,7 @@ int get_superproject_working_tree(struct strbuf *buf)
int code;
ssize_t len;
- if (!is_inside_work_tree())
+ if (!is_inside_work_tree(the_repository))
/*
* FIXME:
* We might have a superproject, but it is harder
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH 02/18] setup: stop using `the_repository` in `is_inside_worktree()`
2026-03-30 13:17 ` [PATCH 02/18] setup: stop using `the_repository` in `is_inside_worktree()` Patrick Steinhardt
@ 2026-04-09 11:55 ` Karthik Nayak
0 siblings, 0 replies; 32+ messages in thread
From: Karthik Nayak @ 2026-04-09 11:55 UTC (permalink / raw)
To: Patrick Steinhardt, git
[-- Attachment #1: Type: text/plain, Size: 2102 bytes --]
Patrick Steinhardt <ps@pks.im> writes:
> The function `is_inside_worktree()` verifies whether or not the current
> working directory is located inside the worktree of `the_repository`.
> This is done by taking the worktree path and verifying that it's a
> prefix of the current working directory.
>
> This information is cached so that we don't have to re-do this change
> multiple times. Furthermore, we proactively set the value in multiple
> locations so that we don't even have to perform the check when we have
> discovered the repository.
>
> While we could simply move the caching variable into the repository, the
> current layout doesn't really feel sensible in the first place:
>
> - It can easily lead to false positives or negatives if at any point
> in time we may switch the current working directory.
>
> - We don't call the function in a hot loop, and neither is it overly
> expensive to compute.
>
> Drop the caching infrastructure and instead compute the property ad-hoc
> via an injected repository.
>
I was thinking we could cache the variable as 'static' within the
function, but that too would have the staleness issue and require
invalidation. So this looks sensible.
> Note that there is one small gotcha: we sometimes may end up with
> relative directory paths, and if so `is_inside_dir()` might fail. This
> wasn't an issue before because of how we proactively set the cached
> value during repository discovery. Now that we stop doing that it
> becomes a problem though, but it is worked around by resolving the
> repository directory via `realpath()`.
>
Ah!
[snip]
> -int is_inside_work_tree(void)
> +int is_inside_work_tree(struct repository *repo)
> {
> - if (inside_work_tree < 0)
> - inside_work_tree = is_inside_dir(repo_get_work_tree(the_repository));
> - return inside_work_tree;
> + static struct strbuf buf = STRBUF_INIT;
> + const char *worktree = repo_get_work_tree(repo);
> + if (!worktree)
> + return 0;
> + return is_inside_dir(strbuf_realpath(&buf, worktree, 1));
> }
We statically allocate the buf to avoid reallocation. Okay.
[snip]
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 690 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH 03/18] setup: stop using `the_repository` in `is_inside_git_dir()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 01/18] setup: replace use of `the_repository` in static functions Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 02/18] setup: stop using `the_repository` in `is_inside_worktree()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-04-09 12:58 ` Karthik Nayak
2026-03-30 13:17 ` [PATCH 04/18] setup: stop using `the_repository` in `prefix_path()` Patrick Steinhardt
` (15 subsequent siblings)
18 siblings, 1 reply; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Similar as with the preceding commit, `is_inside_git_dir()` determines
whether the current working directory is located inside the gitdir of
`the_repository`. Perform the same refactoring by dropping the caching
mechanism and injecting the repository that shall be checked.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/rev-parse.c | 2 +-
setup.c | 12 ++++--------
setup.h | 2 +-
3 files changed, 6 insertions(+), 10 deletions(-)
diff --git a/builtin/rev-parse.c b/builtin/rev-parse.c
index 9629e1ccf7..6dd49ae3f4 100644
--- a/builtin/rev-parse.c
+++ b/builtin/rev-parse.c
@@ -1063,7 +1063,7 @@ int cmd_rev_parse(int argc,
continue;
}
if (!strcmp(arg, "--is-inside-git-dir")) {
- printf("%s\n", is_inside_git_dir() ? "true"
+ printf("%s\n", is_inside_git_dir(the_repository) ? "true"
: "false");
continue;
}
diff --git a/setup.c b/setup.c
index 4df65ba2e8..864ce41116 100644
--- a/setup.c
+++ b/setup.c
@@ -26,7 +26,6 @@
#include "trace2.h"
#include "worktree.h"
-static int inside_git_dir = -1;
static int work_tree_config_is_bogus;
enum allowed_bare_repo {
ALLOWED_BARE_REPO_EXPLICIT = 0,
@@ -298,7 +297,7 @@ void verify_filename(const char *prefix,
*/
void verify_non_filename(const char *prefix, const char *arg)
{
- if (!is_inside_work_tree(the_repository) || is_inside_git_dir())
+ if (!is_inside_work_tree(the_repository) || is_inside_git_dir(the_repository))
return;
if (*arg == '-')
return; /* flag */
@@ -469,11 +468,10 @@ int is_nonbare_repository_dir(struct strbuf *path)
return ret;
}
-int is_inside_git_dir(void)
+int is_inside_git_dir(struct repository *repo)
{
- if (inside_git_dir < 0)
- inside_git_dir = is_inside_dir(repo_get_git_dir(the_repository));
- return inside_git_dir;
+ static struct strbuf buf = STRBUF_INIT;
+ return is_inside_dir(strbuf_realpath(&buf, repo_get_git_dir(repo), 1));
}
int is_inside_work_tree(struct repository *repo)
@@ -1249,7 +1247,6 @@ static const char *setup_discovered_git_dir(struct repository *repo,
set_git_work_tree(".");
if (strcmp(gitdir, DEFAULT_GIT_DIR_ENVIRONMENT))
set_git_dir(repo, gitdir, 0);
- inside_git_dir = 0;
if (offset >= cwd->len)
return NULL;
@@ -1284,7 +1281,6 @@ static const char *setup_bare_git_dir(struct repository *repo,
return setup_explicit_git_dir(repo, gitdir, cwd, repo_fmt, nongit_ok);
}
- inside_git_dir = 1;
if (offset != cwd->len) {
if (chdir(cwd->buf))
die_errno(_("cannot come back to cwd"));
diff --git a/setup.h b/setup.h
index 7c0aa75319..71d3f91883 100644
--- a/setup.h
+++ b/setup.h
@@ -4,7 +4,7 @@
#include "refs.h"
#include "string-list.h"
-int is_inside_git_dir(void);
+int is_inside_git_dir(struct repository *repo);
int is_inside_work_tree(struct repository *repo);
int get_common_dir_noenv(struct strbuf *sb, const char *gitdir);
int get_common_dir(struct strbuf *sb, const char *gitdir);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH 03/18] setup: stop using `the_repository` in `is_inside_git_dir()`
2026-03-30 13:17 ` [PATCH 03/18] setup: stop using `the_repository` in `is_inside_git_dir()` Patrick Steinhardt
@ 2026-04-09 12:58 ` Karthik Nayak
2026-04-13 5:47 ` Patrick Steinhardt
0 siblings, 1 reply; 32+ messages in thread
From: Karthik Nayak @ 2026-04-09 12:58 UTC (permalink / raw)
To: Patrick Steinhardt, git
[-- Attachment #1: Type: text/plain, Size: 438 bytes --]
Patrick Steinhardt <ps@pks.im> writes:
> Similar as with the preceding commit, `is_inside_git_dir()` determines
> whether the current working directory is located inside the gitdir of
> `the_repository`. Perform the same refactoring by dropping the caching
> mechanism and injecting the repository that shall be checked.
>
The patch looks good. I do wonder if these functions need a new home,
'setup.c' is fine, but it is also bloated.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 690 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH 03/18] setup: stop using `the_repository` in `is_inside_git_dir()`
2026-04-09 12:58 ` Karthik Nayak
@ 2026-04-13 5:47 ` Patrick Steinhardt
2026-04-13 15:36 ` Junio C Hamano
0 siblings, 1 reply; 32+ messages in thread
From: Patrick Steinhardt @ 2026-04-13 5:47 UTC (permalink / raw)
To: Karthik Nayak; +Cc: git
On Thu, Apr 09, 2026 at 08:58:03AM -0400, Karthik Nayak wrote:
> Patrick Steinhardt <ps@pks.im> writes:
>
> > Similar as with the preceding commit, `is_inside_git_dir()` determines
> > whether the current working directory is located inside the gitdir of
> > `the_repository`. Perform the same refactoring by dropping the caching
> > mechanism and injecting the repository that shall be checked.
> >
>
> The patch looks good. I do wonder if these functions need a new home,
> 'setup.c' is fine, but it is also bloated.
I agree that they don't really make a ton of sense in "setup.c". In
general, I would love to split up that file into two pieces:
- The pieces required to detect a repository and discover its exact
configuration. So scanning the current working directory and its
parent directories, paying attention to environment variables, and
detecting the repository format.
- The pieces required to configure the repository based on the
findings.
I would really like to completely detangle these two things from one
another so that the detection logic will basically just give us a
structure that contains all relevant information. And that info can then
be passed into "repository.c" to create a new repository for us based on
the info.
This would unlock a couple of benefits:
- Creating a repository will become "pure", as we only depend on
passed-in info and not on the environment anymore.
- We can unify the creation of a repository into, instead of having
roughly the same logic in both "setup.c" and "repository.c".
- We can remove some logic that essentially re-configures a repo
multiple times as we currently do in "setup.c", which should lead to
a much cleaner design.
This is already thinking ahead quite a bit though. The next step would
be to de-globalize some other functionality in "setup.c" first in the
next patch series. But afterwards I'd indeed like to tackle this problem
in the subsequent step.
Thanks!
Patrick
^ permalink raw reply [flat|nested] 32+ messages in thread* Re: [PATCH 03/18] setup: stop using `the_repository` in `is_inside_git_dir()`
2026-04-13 5:47 ` Patrick Steinhardt
@ 2026-04-13 15:36 ` Junio C Hamano
0 siblings, 0 replies; 32+ messages in thread
From: Junio C Hamano @ 2026-04-13 15:36 UTC (permalink / raw)
To: Patrick Steinhardt; +Cc: Karthik Nayak, git
Patrick Steinhardt <ps@pks.im> writes:
> I agree that they don't really make a ton of sense in "setup.c". In
> general, I would love to split up that file into two pieces:
>
> - The pieces required to detect a repository and discover its exact
> configuration. So scanning the current working directory and its
> parent directories, paying attention to environment variables, and
> detecting the repository format.
>
> - The pieces required to configure the repository based on the
> findings.
This sounds like a good direction to go. We the current structure,
if you are handed two local directories and told that they are
subdirectories of two repositories, it is hard to do the necessary
two discoveries independently.
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH 04/18] setup: stop using `the_repository` in `prefix_path()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (2 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 03/18] setup: stop using `the_repository` in `is_inside_git_dir()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 05/18] setup: stop using `the_repository` in `path_inside_repo()` Patrick Steinhardt
` (14 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `prefix_path()` and instead accept the
repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/blame.c | 2 +-
builtin/check-attr.c | 2 +-
builtin/checkout-index.c | 4 ++--
builtin/mv.c | 5 +++--
builtin/sparse-checkout.c | 3 ++-
builtin/update-index.c | 6 +++---
line-log.c | 2 +-
object-name.c | 2 +-
pathspec.c | 2 +-
setup.c | 15 ++++++++-------
setup.h | 4 ++--
t/helper/test-path-utils.c | 2 +-
12 files changed, 26 insertions(+), 23 deletions(-)
diff --git a/builtin/blame.c b/builtin/blame.c
index f3a11eff44..ffbd3ce5c5 100644
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -708,7 +708,7 @@ static unsigned parse_score(const char *arg)
static char *add_prefix(const char *prefix, const char *path)
{
- return prefix_path(prefix, prefix ? strlen(prefix) : 0, path);
+ return prefix_path(the_repository, prefix, prefix ? strlen(prefix) : 0, path);
}
static int git_blame_config(const char *var, const char *value,
diff --git a/builtin/check-attr.c b/builtin/check-attr.c
index 51ed48ce43..04b86e42ae 100644
--- a/builtin/check-attr.c
+++ b/builtin/check-attr.c
@@ -67,7 +67,7 @@ static void check_attr(const char *prefix, struct attr_check *check,
{
char *full_path =
- prefix_path(prefix, prefix ? strlen(prefix) : 0, file);
+ prefix_path(the_repository, prefix, prefix ? strlen(prefix) : 0, file);
if (collect_all) {
git_all_attrs(the_repository->index, full_path, check);
diff --git a/builtin/checkout-index.c b/builtin/checkout-index.c
index 188128aebd..311b94ff31 100644
--- a/builtin/checkout-index.c
+++ b/builtin/checkout-index.c
@@ -303,7 +303,7 @@ int cmd_checkout_index(int argc,
die("git checkout-index: don't mix '--all' and explicit filenames");
if (read_from_stdin)
die("git checkout-index: don't mix '--stdin' and explicit filenames");
- p = prefix_path(prefix, prefix_length, arg);
+ p = prefix_path(repo, prefix, prefix_length, arg);
err |= checkout_file(repo->index, p, prefix);
free(p);
}
@@ -325,7 +325,7 @@ int cmd_checkout_index(int argc,
die("line is badly quoted");
strbuf_swap(&buf, &unquoted);
}
- p = prefix_path(prefix, prefix_length, buf.buf);
+ p = prefix_path(repo, prefix, prefix_length, buf.buf);
err |= checkout_file(repo->index, p, prefix);
free(p);
}
diff --git a/builtin/mv.c b/builtin/mv.c
index 2215d34e31..948b330639 100644
--- a/builtin/mv.c
+++ b/builtin/mv.c
@@ -71,7 +71,7 @@ static void internal_prefix_pathspec(struct strvec *out,
trimmed = xmemdupz(pathspec[i], to_copy);
maybe_basename = (flags & DUP_BASENAME) ? basename(trimmed) : trimmed;
- prefixed_path = prefix_path(prefix, prefixlen, maybe_basename);
+ prefixed_path = prefix_path(the_repository, prefix, prefixlen, maybe_basename);
strvec_push(out, prefixed_path);
free(prefixed_path);
@@ -394,7 +394,8 @@ int cmd_mv(int argc,
for (j = 0; j < last - first; j++) {
const struct cache_entry *ce = the_repository->index->cache[first + j];
const char *path = ce->name;
- char *prefixed_path = prefix_path(dst_with_slash, dst_with_slash_len, path + length + 1);
+ char *prefixed_path = prefix_path(the_repository, dst_with_slash,
+ dst_with_slash_len, path + length + 1);
strvec_push(&sources, path);
strvec_push(&destinations, prefixed_path);
diff --git a/builtin/sparse-checkout.c b/builtin/sparse-checkout.c
index f4aa405da9..2af50fb2f9 100644
--- a/builtin/sparse-checkout.c
+++ b/builtin/sparse-checkout.c
@@ -735,7 +735,8 @@ static void sanitize_paths(struct repository *repo,
int prefix_len = strlen(prefix);
for (i = 0; i < args->nr; i++) {
- char *prefixed_path = prefix_path(prefix, prefix_len, args->v[i]);
+ char *prefixed_path = prefix_path(the_repository, prefix,
+ prefix_len, args->v[i]);
strvec_replace(args, i, prefixed_path);
free(prefixed_path);
}
diff --git a/builtin/update-index.c b/builtin/update-index.c
index 8a5907767b..7434112b8e 100644
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -655,7 +655,7 @@ static int do_unresolve(int ac, const char **av,
for (i = 1; i < ac; i++) {
const char *arg = av[i];
- char *p = prefix_path(prefix, prefix_length, arg);
+ char *p = prefix_path(the_repository, prefix, prefix_length, arg);
err |= unresolve_one(p);
free(p);
}
@@ -1158,7 +1158,7 @@ int cmd_update_index(int argc,
}
setup_work_tree();
- p = prefix_path(prefix, prefix_length, path);
+ p = prefix_path(the_repository, prefix, prefix_length, path);
update_one(p);
if (set_executable_bit)
chmod_path(set_executable_bit, p);
@@ -1208,7 +1208,7 @@ int cmd_update_index(int argc,
die("line is badly quoted");
strbuf_swap(&buf, &unquoted);
}
- p = prefix_path(prefix, prefix_length, buf.buf);
+ p = prefix_path(the_repository, prefix, prefix_length, buf.buf);
update_one(p);
if (set_executable_bit)
chmod_path(set_executable_bit, p);
diff --git a/line-log.c b/line-log.c
index eeaf68454e..a6fc46d331 100644
--- a/line-log.c
+++ b/line-log.c
@@ -589,7 +589,7 @@ parse_lines(struct repository *r, struct commit *commit,
range_part = xstrndup(item->string, name_part - item->string);
name_part++;
- full_name = prefix_path(prefix, prefix ? strlen(prefix) : 0,
+ full_name = prefix_path(r, prefix, prefix ? strlen(prefix) : 0,
name_part);
spec = alloc_filespec(full_name);
diff --git a/object-name.c b/object-name.c
index 7b7e546b1f..ca5f060a4e 100644
--- a/object-name.c
+++ b/object-name.c
@@ -1994,7 +1994,7 @@ static char *resolve_relative_path(struct repository *r, const char *rel)
die(_("relative path syntax can't be used outside working tree"));
/* die() inside prefix_path() if resolved path is outside worktree */
- return prefix_path(startup_info->prefix,
+ return prefix_path(the_repository, startup_info->prefix,
startup_info->prefix ? strlen(startup_info->prefix) : 0,
rel);
}
diff --git a/pathspec.c b/pathspec.c
index 5993c4afa0..f78b22709c 100644
--- a/pathspec.c
+++ b/pathspec.c
@@ -486,7 +486,7 @@ static void init_pathspec_item(struct pathspec_item *item, unsigned flags,
match = xstrdup(copyfrom);
prefixlen = 0;
} else {
- match = prefix_path_gently(prefix, prefixlen,
+ match = prefix_path_gently(the_repository, prefix, prefixlen,
&prefixlen, copyfrom);
if (!match) {
const char *hint_path;
diff --git a/setup.c b/setup.c
index 864ce41116..331ea86a40 100644
--- a/setup.c
+++ b/setup.c
@@ -117,7 +117,8 @@ static int abspath_part_inside_repo(struct repository *repo, char *path)
* ../../sub1/sub2/foo -> sub1/sub2/foo (but no remaining prefix)
* `pwd`/../bar -> sub1/bar (no remaining prefix)
*/
-char *prefix_path_gently(const char *prefix, int len,
+char *prefix_path_gently(struct repository *repo,
+ const char *prefix, int len,
int *remaining_prefix, const char *path)
{
const char *orig = path;
@@ -130,7 +131,7 @@ char *prefix_path_gently(const char *prefix, int len,
free(sanitized);
return NULL;
}
- if (abspath_part_inside_repo(the_repository, sanitized)) {
+ if (abspath_part_inside_repo(repo, sanitized)) {
free(sanitized);
return NULL;
}
@@ -146,13 +147,13 @@ char *prefix_path_gently(const char *prefix, int len,
return sanitized;
}
-char *prefix_path(const char *prefix, int len, const char *path)
+char *prefix_path(struct repository *repo, const char *prefix, int len, const char *path)
{
- char *r = prefix_path_gently(prefix, len, NULL, path);
+ char *r = prefix_path_gently(repo, prefix, len, NULL, path);
if (!r) {
- const char *hint_path = repo_get_work_tree(the_repository);
+ const char *hint_path = repo_get_work_tree(repo);
if (!hint_path)
- hint_path = repo_get_git_dir(the_repository);
+ hint_path = repo_get_git_dir(repo);
die(_("'%s' is outside repository at '%s'"), path,
absolute_path(hint_path));
}
@@ -162,7 +163,7 @@ char *prefix_path(const char *prefix, int len, const char *path)
int path_inside_repo(const char *prefix, const char *path)
{
int len = prefix ? strlen(prefix) : 0;
- char *r = prefix_path_gently(prefix, len, NULL, path);
+ char *r = prefix_path_gently(the_repository, prefix, len, NULL, path);
if (r) {
free(r);
return 1;
diff --git a/setup.h b/setup.h
index 71d3f91883..24034572b1 100644
--- a/setup.h
+++ b/setup.h
@@ -138,8 +138,8 @@ const char *enter_repo(const char *path, unsigned flags);
const char *setup_git_directory_gently(int *);
const char *setup_git_directory(void);
-char *prefix_path(const char *prefix, int len, const char *path);
-char *prefix_path_gently(const char *prefix, int len, int *remaining, const char *path);
+char *prefix_path(struct repository *repo, const char *prefix, int len, const char *path);
+char *prefix_path_gently(struct repository *repo, const char *prefix, int len, int *remaining, const char *path);
int check_filename(const char *prefix, const char *name);
void verify_filename(const char *prefix,
diff --git a/t/helper/test-path-utils.c b/t/helper/test-path-utils.c
index 874542ec34..163fdeefb0 100644
--- a/t/helper/test-path-utils.c
+++ b/t/helper/test-path-utils.c
@@ -379,7 +379,7 @@ int cmd__path_utils(int argc, const char **argv)
int nongit_ok;
setup_git_directory_gently(&nongit_ok);
while (argc > 3) {
- char *pfx = prefix_path(prefix, prefix_len, argv[3]);
+ char *pfx = prefix_path(the_repository, prefix, prefix_len, argv[3]);
puts(pfx);
free(pfx);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 05/18] setup: stop using `the_repository` in `path_inside_repo()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (3 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 04/18] setup: stop using `the_repository` in `prefix_path()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 06/18] setup: stop using `the_repository` in `verify_filename()` Patrick Steinhardt
` (13 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `path_inside_repo()` and instead accept
the repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/diff.c | 4 ++--
setup.c | 4 ++--
setup.h | 2 +-
3 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/builtin/diff.c b/builtin/diff.c
index 0b23c41456..7ddebce2ac 100644
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -471,8 +471,8 @@ int cmd_diff(int argc,
* as a colourful "diff" replacement.
*/
if (nongit || ((argc == i + 2) &&
- (!path_inside_repo(prefix, argv[i]) ||
- !path_inside_repo(prefix, argv[i + 1]))))
+ (!path_inside_repo(the_repository, prefix, argv[i]) ||
+ !path_inside_repo(the_repository, prefix, argv[i + 1]))))
no_index = DIFF_NO_INDEX_IMPLICIT;
}
diff --git a/setup.c b/setup.c
index 331ea86a40..6cfb05c527 100644
--- a/setup.c
+++ b/setup.c
@@ -160,10 +160,10 @@ char *prefix_path(struct repository *repo, const char *prefix, int len, const ch
return r;
}
-int path_inside_repo(const char *prefix, const char *path)
+int path_inside_repo(struct repository *repo, const char *prefix, const char *path)
{
int len = prefix ? strlen(prefix) : 0;
- char *r = prefix_path_gently(the_repository, prefix, len, NULL, path);
+ char *r = prefix_path_gently(repo, prefix, len, NULL, path);
if (r) {
free(r);
return 1;
diff --git a/setup.h b/setup.h
index 24034572b1..c3247d7fc8 100644
--- a/setup.h
+++ b/setup.h
@@ -146,7 +146,7 @@ void verify_filename(const char *prefix,
const char *name,
int diagnose_misspelt_rev);
void verify_non_filename(const char *prefix, const char *name);
-int path_inside_repo(const char *prefix, const char *path);
+int path_inside_repo(struct repository *repo, const char *prefix, const char *path);
void sanitize_stdfds(void);
int daemonize(void);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 06/18] setup: stop using `the_repository` in `verify_filename()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (4 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 05/18] setup: stop using `the_repository` in `path_inside_repo()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 07/18] setup: stop using `the_repository` in `verify_non_filename()` Patrick Steinhardt
` (12 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `verify_filename()` and instead accept
the repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/grep.c | 2 +-
builtin/reset.c | 2 +-
builtin/rev-parse.c | 4 ++--
revision.c | 2 +-
setup.c | 5 +++--
setup.h | 3 ++-
6 files changed, 10 insertions(+), 8 deletions(-)
diff --git a/builtin/grep.c b/builtin/grep.c
index e33285e5e6..b0e350cf89 100644
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -1163,7 +1163,7 @@ int cmd_grep(int argc,
if (!seen_dashdash) {
int j;
for (j = i; j < argc; j++)
- verify_filename(prefix, argv[j], j == i && allow_revs);
+ verify_filename(the_repository, prefix, argv[j], j == i && allow_revs);
}
parse_pathspec(&pathspec, 0,
diff --git a/builtin/reset.c b/builtin/reset.c
index 3590be57a5..1ac374d31b 100644
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -285,7 +285,7 @@ static void parse_args(struct pathspec *pathspec,
rev = *argv++;
} else {
/* Otherwise we treat this as a filename */
- verify_filename(prefix, argv[0], 1);
+ verify_filename(the_repository, prefix, argv[0], 1);
}
}
diff --git a/builtin/rev-parse.c b/builtin/rev-parse.c
index 6dd49ae3f4..d7c6400ddc 100644
--- a/builtin/rev-parse.c
+++ b/builtin/rev-parse.c
@@ -749,7 +749,7 @@ int cmd_rev_parse(int argc,
if (as_is) {
if (show_file(arg, output_prefix) && as_is < 2)
- verify_filename(prefix, arg, 0);
+ verify_filename(the_repository, prefix, arg, 0);
continue;
}
@@ -1173,7 +1173,7 @@ int cmd_rev_parse(int argc,
as_is = 1;
if (!show_file(arg, output_prefix))
continue;
- verify_filename(prefix, arg, 1);
+ verify_filename(the_repository, prefix, arg, 1);
}
strbuf_release(&buf);
if (verify) {
diff --git a/revision.c b/revision.c
index 31808e3df0..57cf00ae6b 100644
--- a/revision.c
+++ b/revision.c
@@ -3066,7 +3066,7 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct s
* but the latter we have checked in the main loop.
*/
for (j = i; j < argc; j++)
- verify_filename(revs->prefix, argv[j], j == i);
+ verify_filename(the_repository, revs->prefix, argv[j], j == i);
strvec_pushv(&prune_data, argv + i);
break;
diff --git a/setup.c b/setup.c
index 6cfb05c527..736f950bd0 100644
--- a/setup.c
+++ b/setup.c
@@ -280,7 +280,8 @@ static int looks_like_pathspec(const char *arg)
* diagnose_misspelt_rev == 0 for the next ones (because we already
* saw a filename, there's not ambiguity anymore).
*/
-void verify_filename(const char *prefix,
+void verify_filename(struct repository *repo,
+ const char *prefix,
const char *arg,
int diagnose_misspelt_rev)
{
@@ -288,7 +289,7 @@ void verify_filename(const char *prefix,
die(_("option '%s' must come before non-option arguments"), arg);
if (looks_like_pathspec(arg) || check_filename(prefix, arg))
return;
- die_verify_filename(the_repository, prefix, arg, diagnose_misspelt_rev);
+ die_verify_filename(repo, prefix, arg, diagnose_misspelt_rev);
}
/*
diff --git a/setup.h b/setup.h
index c3247d7fc8..24a6f66629 100644
--- a/setup.h
+++ b/setup.h
@@ -142,7 +142,8 @@ char *prefix_path(struct repository *repo, const char *prefix, int len, const ch
char *prefix_path_gently(struct repository *repo, const char *prefix, int len, int *remaining, const char *path);
int check_filename(const char *prefix, const char *name);
-void verify_filename(const char *prefix,
+void verify_filename(struct repository *repo,
+ const char *prefix,
const char *name,
int diagnose_misspelt_rev);
void verify_non_filename(const char *prefix, const char *name);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 07/18] setup: stop using `the_repository` in `verify_non_filename()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (5 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 06/18] setup: stop using `the_repository` in `verify_filename()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 08/18] setup: stop using `the_repository` in `enter_repo()` Patrick Steinhardt
` (11 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `verify_non_filename()` and instead
accept the repository as a parameter. The injection of `the_repository`
is thus bumped one level higher, where callers now pass it in
explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/checkout.c | 2 +-
builtin/grep.c | 2 +-
builtin/reset.c | 2 +-
revision.c | 4 ++--
setup.c | 4 ++--
setup.h | 2 +-
6 files changed, 8 insertions(+), 8 deletions(-)
diff --git a/builtin/checkout.c b/builtin/checkout.c
index e031e61886..d7069765e7 100644
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -1485,7 +1485,7 @@ static int parse_branchname_arg(int argc, const char **argv,
* it would be extremely annoying.
*/
if (argc)
- verify_non_filename(opts->prefix, arg);
+ verify_non_filename(the_repository, opts->prefix, arg);
} else if (opts->accept_pathspec) {
argcount++;
argv++;
diff --git a/builtin/grep.c b/builtin/grep.c
index b0e350cf89..4ec0c016b1 100644
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -1151,7 +1151,7 @@ int cmd_grep(int argc,
object = parse_object_or_die(the_repository, &oid, arg);
if (!seen_dashdash)
- verify_non_filename(prefix, arg);
+ verify_non_filename(the_repository, prefix, arg);
add_object_array_with_path(object, arg, &list, oc.mode, oc.path);
object_context_release(&oc);
}
diff --git a/builtin/reset.c b/builtin/reset.c
index 1ac374d31b..11f57605b5 100644
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -281,7 +281,7 @@ static void parse_args(struct pathspec *pathspec,
* Ok, argv[0] looks like a commit/tree; it should not
* be a filename.
*/
- verify_non_filename(prefix, argv[0]);
+ verify_non_filename(the_repository, prefix, argv[0]);
rev = *argv++;
} else {
/* Otherwise we treat this as a filename */
diff --git a/revision.c b/revision.c
index 57cf00ae6b..9071a38b85 100644
--- a/revision.c
+++ b/revision.c
@@ -2082,7 +2082,7 @@ static int handle_dotdot_1(const char *arg, char *dotdot,
if (!cant_be_filename) {
*dotdot = '.';
- verify_non_filename(revs->prefix, arg);
+ verify_non_filename(the_repository, revs->prefix, arg);
*dotdot = '\0';
}
@@ -2227,7 +2227,7 @@ static int handle_revision_arg_1(const char *arg_, struct rev_info *revs, int fl
goto out;
}
if (!cant_be_filename)
- verify_non_filename(revs->prefix, arg);
+ verify_non_filename(the_repository, revs->prefix, arg);
object = get_reference(revs, arg, &oid, flags ^ local_flags);
if (!object) {
ret = (revs->ignore_missing || revs->do_not_die_on_missing_objects) ? 0 : -1;
diff --git a/setup.c b/setup.c
index 736f950bd0..c6b5b85f3a 100644
--- a/setup.c
+++ b/setup.c
@@ -297,9 +297,9 @@ void verify_filename(struct repository *repo,
* and we parsed the arg as a refname. It should not be interpretable
* as a filename.
*/
-void verify_non_filename(const char *prefix, const char *arg)
+void verify_non_filename(struct repository *repo, const char *prefix, const char *arg)
{
- if (!is_inside_work_tree(the_repository) || is_inside_git_dir(the_repository))
+ if (!is_inside_work_tree(repo) || is_inside_git_dir(repo))
return;
if (*arg == '-')
return; /* flag */
diff --git a/setup.h b/setup.h
index 24a6f66629..364c2c728a 100644
--- a/setup.h
+++ b/setup.h
@@ -146,7 +146,7 @@ void verify_filename(struct repository *repo,
const char *prefix,
const char *name,
int diagnose_misspelt_rev);
-void verify_non_filename(const char *prefix, const char *name);
+void verify_non_filename(struct repository *repo, const char *prefix, const char *name);
int path_inside_repo(struct repository *repo, const char *prefix, const char *path);
void sanitize_stdfds(void);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 08/18] setup: stop using `the_repository` in `enter_repo()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (6 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 07/18] setup: stop using `the_repository` in `verify_non_filename()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 09/18] setup: stop using `the_repository` in `setup_work_tree()` Patrick Steinhardt
` (10 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `enter_repo()` and instead accept the
repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/receive-pack.c | 2 +-
builtin/upload-archive.c | 2 +-
builtin/upload-pack.c | 2 +-
daemon.c | 4 ++--
http-backend.c | 2 +-
setup.c | 4 ++--
setup.h | 2 +-
7 files changed, 9 insertions(+), 9 deletions(-)
diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index e34edff406..c5f73fff35 100644
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -2646,7 +2646,7 @@ int cmd_receive_pack(int argc,
setup_path();
- if (!enter_repo(service_dir, 0))
+ if (!enter_repo(the_repository, service_dir, 0))
die("'%s' does not appear to be a git repository", service_dir);
repo_config(the_repository, receive_pack_config, NULL);
diff --git a/builtin/upload-archive.c b/builtin/upload-archive.c
index 25312bb2a5..718e74b3ac 100644
--- a/builtin/upload-archive.c
+++ b/builtin/upload-archive.c
@@ -31,7 +31,7 @@ int cmd_upload_archive_writer(int argc,
if (argc != 2)
usage(upload_archive_usage);
- if (!enter_repo(argv[1], 0))
+ if (!enter_repo(the_repository, argv[1], 0))
die("'%s' does not appear to be a git repository", argv[1]);
init_archivers();
diff --git a/builtin/upload-pack.c b/builtin/upload-pack.c
index 30498fafea..32831fb879 100644
--- a/builtin/upload-pack.c
+++ b/builtin/upload-pack.c
@@ -59,7 +59,7 @@ int cmd_upload_pack(int argc,
if (strict)
enter_repo_flags |= ENTER_REPO_STRICT;
- if (!enter_repo(dir, enter_repo_flags))
+ if (!enter_repo(the_repository, dir, enter_repo_flags))
die("'%s' does not appear to be a git repository", dir);
switch (determine_protocol_version_server()) {
diff --git a/daemon.c b/daemon.c
index 0a7b1aae44..947dd90655 100644
--- a/daemon.c
+++ b/daemon.c
@@ -244,14 +244,14 @@ static const char *path_ok(const char *directory, struct hostinfo *hi)
}
enter_repo_flags = strict_paths ? ENTER_REPO_STRICT : 0;
- path = enter_repo(dir, enter_repo_flags);
+ path = enter_repo(the_repository, dir, enter_repo_flags);
if (!path && base_path && base_path_relaxed) {
/*
* if we fail and base_path_relaxed is enabled, try without
* prefixing the base path
*/
dir = directory;
- path = enter_repo(dir, enter_repo_flags);
+ path = enter_repo(the_repository, dir, enter_repo_flags);
}
if (!path) {
diff --git a/http-backend.c b/http-backend.c
index 1a171c5c5a..c7566b1d12 100644
--- a/http-backend.c
+++ b/http-backend.c
@@ -809,7 +809,7 @@ int cmd_main(int argc UNUSED, const char **argv UNUSED)
not_found(&hdr, "Request not supported: '%s'", dir);
setup_path();
- if (!enter_repo(dir, 0))
+ if (!enter_repo(the_repository, dir, 0))
not_found(&hdr, "Not a git repository: '%s'", dir);
if (!getenv("GIT_HTTP_EXPORT_ALL") &&
access("git-daemon-export-ok", F_OK) )
diff --git a/setup.c b/setup.c
index c6b5b85f3a..dca32addae 100644
--- a/setup.c
+++ b/setup.c
@@ -1756,7 +1756,7 @@ enum discovery_result discover_git_directory_reason(struct strbuf *commondir,
return result;
}
-const char *enter_repo(const char *path, unsigned flags)
+const char *enter_repo(struct repository *repo, const char *path, unsigned flags)
{
static struct strbuf validated_path = STRBUF_INIT;
static struct strbuf used_path = STRBUF_INIT;
@@ -1829,7 +1829,7 @@ const char *enter_repo(const char *path, unsigned flags)
}
if (is_git_directory(".")) {
- set_git_dir(the_repository, ".", 0);
+ set_git_dir(repo, ".", 0);
check_repository_format(NULL);
return path;
}
diff --git a/setup.h b/setup.h
index 364c2c728a..d0cfdfd44a 100644
--- a/setup.h
+++ b/setup.h
@@ -134,7 +134,7 @@ enum {
* links. User relative paths are also returned as they are given,
* except DWIM suffixing.
*/
-const char *enter_repo(const char *path, unsigned flags);
+const char *enter_repo(struct repository *repo, const char *path, unsigned flags);
const char *setup_git_directory_gently(int *);
const char *setup_git_directory(void);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 09/18] setup: stop using `the_repository` in `setup_work_tree()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (7 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 08/18] setup: stop using `the_repository` in `enter_repo()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-04-18 1:11 ` Elijah Newren
2026-03-30 13:17 ` [PATCH 10/18] setup: stop using `the_repository` in `set_git_work_tree()` Patrick Steinhardt
` (9 subsequent siblings)
18 siblings, 1 reply; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `setup_work_tree()` and instead accept
the repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Note that the function tracks bogus worktree configuration via a global
variable. If we have bogus configuration, and if later on some caller
tries to setup a worktree, then we'll die instead.
Of course, tracking this as a global variable doesn't make sense anymore
now that we can set up worktrees for arbitrary repositories. Move the
variable into `struct repository` instead.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
blame.c | 2 +-
builtin/check-attr.c | 2 +-
builtin/clone.c | 2 +-
builtin/describe.c | 2 +-
builtin/diff-index.c | 2 +-
builtin/diff.c | 4 ++--
builtin/difftool.c | 2 +-
builtin/grep.c | 2 +-
builtin/ls-files.c | 2 +-
builtin/read-tree.c | 2 +-
builtin/reset.c | 2 +-
builtin/rm.c | 2 +-
builtin/sparse-checkout.c | 16 ++++++++--------
builtin/submodule--helper.c | 2 +-
builtin/update-index.c | 10 +++++-----
git.c | 2 +-
repository.h | 1 +
setup.c | 9 ++++-----
setup.h | 2 +-
t/helper/test-subprocess.c | 4 +++-
wt-status.c | 2 +-
21 files changed, 38 insertions(+), 36 deletions(-)
diff --git a/blame.c b/blame.c
index a3c49d132e..977cbb7097 100644
--- a/blame.c
+++ b/blame.c
@@ -2813,7 +2813,7 @@ void setup_scoreboard(struct blame_scoreboard *sb,
}
if (!sb->contents_from)
- setup_work_tree();
+ setup_work_tree(the_repository);
sb->final = fake_working_tree_commit(sb->repo,
&sb->revs->diffopt,
diff --git a/builtin/check-attr.c b/builtin/check-attr.c
index 04b86e42ae..98f64d5b92 100644
--- a/builtin/check-attr.c
+++ b/builtin/check-attr.c
@@ -117,7 +117,7 @@ int cmd_check_attr(int argc,
int cnt, i, doubledash, filei;
if (!is_bare_repository())
- setup_work_tree();
+ setup_work_tree(the_repository);
repo_config(the_repository, git_default_config, NULL);
diff --git a/builtin/clone.c b/builtin/clone.c
index fba3c9c508..91b9a105a4 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -668,7 +668,7 @@ static int checkout(int submodule_progress,
}
/* We need to be in the new work tree for the checkout */
- setup_work_tree();
+ setup_work_tree(the_repository);
repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
diff --git a/builtin/describe.c b/builtin/describe.c
index bffeed13a3..1c47d7c0b7 100644
--- a/builtin/describe.c
+++ b/builtin/describe.c
@@ -781,7 +781,7 @@ int cmd_describe(int argc,
struct rev_info revs;
int fd;
- setup_work_tree();
+ setup_work_tree(the_repository);
prepare_repo_settings(the_repository);
the_repository->settings.command_requires_full_index = 0;
repo_read_index(the_repository);
diff --git a/builtin/diff-index.c b/builtin/diff-index.c
index 522dacfc4c..3db7cffede 100644
--- a/builtin/diff-index.c
+++ b/builtin/diff-index.c
@@ -69,7 +69,7 @@ int cmd_diff_index(int argc,
rev.max_count != -1 || rev.min_age != -1 || rev.max_age != -1)
usage(diff_cache_usage);
if (!(option & DIFF_INDEX_CACHED)) {
- setup_work_tree();
+ setup_work_tree(the_repository);
if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0) {
perror("repo_read_index_preload");
return -1;
diff --git a/builtin/diff.c b/builtin/diff.c
index 7ddebce2ac..1ede873ac1 100644
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -159,7 +159,7 @@ static void builtin_diff_index(struct rev_info *revs,
revs->max_age != -1)
usage(builtin_diff_usage);
if (!(option & DIFF_INDEX_CACHED)) {
- setup_work_tree();
+ setup_work_tree(the_repository);
if (repo_read_index_preload(the_repository,
&revs->diffopt.pathspec, 0) < 0) {
die_errno("repo_read_index_preload");
@@ -281,7 +281,7 @@ static void builtin_diff_files(struct rev_info *revs, int argc, const char **arg
(revs->diffopt.output_format & DIFF_FORMAT_PATCH))
diff_merges_set_dense_combined_if_unset(revs);
- setup_work_tree();
+ setup_work_tree(the_repository);
if (repo_read_index_preload(the_repository, &revs->diffopt.pathspec,
0) < 0) {
die_errno("repo_read_index_preload");
diff --git a/builtin/difftool.c b/builtin/difftool.c
index e4bc1f8316..2a21005f2e 100644
--- a/builtin/difftool.c
+++ b/builtin/difftool.c
@@ -767,7 +767,7 @@ int cmd_difftool(int argc,
die(_("difftool requires worktree or --no-index"));
if (!no_index){
- setup_work_tree();
+ setup_work_tree(repo);
setenv(GIT_DIR_ENVIRONMENT, absolute_path(repo_get_git_dir(repo)), 1);
setenv(GIT_WORK_TREE_ENVIRONMENT, absolute_path(repo_get_work_tree(repo)), 1);
} else if (dir_diff)
diff --git a/builtin/grep.c b/builtin/grep.c
index 4ec0c016b1..679f8b567a 100644
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -1272,7 +1272,7 @@ int cmd_grep(int argc,
die(_("--[no-]exclude-standard cannot be used for tracked contents"));
} else if (!list.nr) {
if (!cached)
- setup_work_tree();
+ setup_work_tree(the_repository);
hit = grep_cache(&opt, &pathspec, cached);
} else {
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 09d95111b3..e1a22b41b9 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -704,7 +704,7 @@ int cmd_ls_files(int argc,
exc_given = 1;
if (require_work_tree && !is_inside_work_tree(repo))
- setup_work_tree();
+ setup_work_tree(repo);
if (recurse_submodules &&
(show_deleted || show_others || show_unmerged ||
diff --git a/builtin/read-tree.c b/builtin/read-tree.c
index 460b21e40a..999a82ecdf 100644
--- a/builtin/read-tree.c
+++ b/builtin/read-tree.c
@@ -229,7 +229,7 @@ int cmd_read_tree(int argc,
opts.preserve_ignored = 0;
/* otherwise, opts.preserve_ignored is irrelevant */
if (opts.merge && !opts.index_only)
- setup_work_tree();
+ setup_work_tree(the_repository);
if (opts.skip_sparse_checkout)
ensure_full_index(the_repository->index);
diff --git a/builtin/reset.c b/builtin/reset.c
index 11f57605b5..3be6bd0121 100644
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -468,7 +468,7 @@ int cmd_reset(int argc,
trace2_cmd_mode(reset_type_names[reset_type]);
if (reset_type != SOFT && (reset_type != MIXED || repo_get_work_tree(the_repository)))
- setup_work_tree();
+ setup_work_tree(the_repository);
if (reset_type == MIXED && is_bare_repository())
die(_("%s reset is not allowed in a bare repository"),
diff --git a/builtin/rm.c b/builtin/rm.c
index 05d89e98c3..081d0bc375 100644
--- a/builtin/rm.c
+++ b/builtin/rm.c
@@ -296,7 +296,7 @@ int cmd_rm(int argc,
die(_("No pathspec was given. Which files should I remove?"));
if (!index_only)
- setup_work_tree();
+ setup_work_tree(the_repository);
prepare_repo_settings(the_repository);
the_repository->settings.command_requires_full_index = 0;
diff --git a/builtin/sparse-checkout.c b/builtin/sparse-checkout.c
index 2af50fb2f9..d89acbeb53 100644
--- a/builtin/sparse-checkout.c
+++ b/builtin/sparse-checkout.c
@@ -63,7 +63,7 @@ static int sparse_checkout_list(int argc, const char **argv, const char *prefix,
int res;
struct repo_config_values *cfg = repo_config_values(the_repository);
- setup_work_tree();
+ setup_work_tree(the_repository);
if (!cfg->apply_sparse_checkout)
die(_("this worktree is not sparse"));
@@ -229,7 +229,7 @@ static int update_working_directory(struct repository *r,
o.dst_index = r->index;
o.skip_sparse_checkout = 0;
- setup_work_tree();
+ setup_work_tree(the_repository);
repo_hold_locked_index(r, &lock_file, LOCK_DIE_ON_ERROR);
@@ -468,7 +468,7 @@ static int sparse_checkout_init(int argc, const char **argv, const char *prefix,
OPT_END(),
};
- setup_work_tree();
+ setup_work_tree(the_repository);
repo_read_index(repo);
init_opts.cone_mode = -1;
@@ -802,7 +802,7 @@ static int sparse_checkout_add(int argc, const char **argv, const char *prefix,
int ret;
struct repo_config_values *cfg = repo_config_values(the_repository);
- setup_work_tree();
+ setup_work_tree(the_repository);
if (!cfg->apply_sparse_checkout)
die(_("no sparse-checkout to add to"));
@@ -856,7 +856,7 @@ static int sparse_checkout_set(int argc, const char **argv, const char *prefix,
struct strvec patterns = STRVEC_INIT;
int ret;
- setup_work_tree();
+ setup_work_tree(the_repository);
repo_read_index(repo);
set_opts.cone_mode = -1;
@@ -912,7 +912,7 @@ static int sparse_checkout_reapply(int argc, const char **argv,
};
struct repo_config_values *cfg = repo_config_values(the_repository);
- setup_work_tree();
+ setup_work_tree(the_repository);
if (!cfg->apply_sparse_checkout)
die(_("must be in a sparse-checkout to reapply sparsity patterns"));
@@ -975,7 +975,7 @@ static int sparse_checkout_clean(int argc, const char **argv,
OPT_END(),
};
- setup_work_tree();
+ setup_work_tree(the_repository);
if (!cfg->apply_sparse_checkout)
die(_("must be in a sparse-checkout to clean directories"));
if (!core_sparse_checkout_cone)
@@ -1053,7 +1053,7 @@ static int sparse_checkout_disable(int argc, const char **argv,
* forcibly return to a dense checkout regardless of initial state.
*/
- setup_work_tree();
+ setup_work_tree(the_repository);
argc = parse_options(argc, argv, prefix,
builtin_sparse_checkout_disable_options,
builtin_sparse_checkout_disable_usage, 0);
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index 2f589e3b37..1cc82a134d 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -1250,7 +1250,7 @@ static int compute_summary_module_list(struct object_id *head_oid,
if (!info->cached) {
if (diff_cmd == DIFF_INDEX)
- setup_work_tree();
+ setup_work_tree(the_repository);
if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0) {
perror("repo_read_index_preload");
ret = -1;
diff --git a/builtin/update-index.c b/builtin/update-index.c
index 7434112b8e..d6dabacfd1 100644
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -732,7 +732,7 @@ struct refresh_params {
static int refresh(struct refresh_params *o, unsigned int flag)
{
- setup_work_tree();
+ setup_work_tree(the_repository);
repo_read_index(the_repository);
*o->has_errors |= refresh_index(the_repository->index, o->flags | flag, NULL,
NULL, NULL);
@@ -901,7 +901,7 @@ static enum parse_opt_result reupdate_callback(
BUG_ON_OPT_ARG(arg);
/* consume remaining arguments. */
- setup_work_tree();
+ setup_work_tree(the_repository);
*has_errors = do_reupdate(ctx->argv + 1, prefix);
if (*has_errors)
the_repository->index->cache_changed = 0;
@@ -1157,7 +1157,7 @@ int cmd_update_index(int argc,
transaction = NULL;
}
- setup_work_tree();
+ setup_work_tree(the_repository);
p = prefix_path(the_repository, prefix, prefix_length, path);
update_one(p);
if (set_executable_bit)
@@ -1199,7 +1199,7 @@ int cmd_update_index(int argc,
struct strbuf buf = STRBUF_INIT;
struct strbuf unquoted = STRBUF_INIT;
- setup_work_tree();
+ setup_work_tree(the_repository);
while (getline_fn(&buf, stdin) != EOF) {
char *p;
if (!nul_term_line && buf.buf[0] == '"') {
@@ -1253,7 +1253,7 @@ int cmd_update_index(int argc,
report(_("Untracked cache disabled"));
break;
case UC_TEST:
- setup_work_tree();
+ setup_work_tree(the_repository);
return !test_if_untracked_cache_is_supported();
case UC_ENABLE:
case UC_FORCE:
diff --git a/git.c b/git.c
index 2b212e6675..c146eaa20b 100644
--- a/git.c
+++ b/git.c
@@ -497,7 +497,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv, struct
commit_pager_choice();
if (!help && p->option & NEED_WORK_TREE)
- setup_work_tree();
+ setup_work_tree(the_repository);
trace_argv_printf(argv, "trace: built-in: git");
trace2_cmd_name(p->cmd);
diff --git a/repository.h b/repository.h
index 078059a6e0..abeef3129e 100644
--- a/repository.h
+++ b/repository.h
@@ -113,6 +113,7 @@ struct repository {
* A NULL value indicates that there is no working directory.
*/
char *worktree;
+ bool worktree_config_is_bogus;
/*
* Path from the root of the top-level superproject down to this
diff --git a/setup.c b/setup.c
index dca32addae..64a030c6cd 100644
--- a/setup.c
+++ b/setup.c
@@ -26,7 +26,6 @@
#include "trace2.h"
#include "worktree.h"
-static int work_tree_config_is_bogus;
enum allowed_bare_repo {
ALLOWED_BARE_REPO_EXPLICIT = 0,
ALLOWED_BARE_REPO_ALL,
@@ -485,7 +484,7 @@ int is_inside_work_tree(struct repository *repo)
return is_inside_dir(strbuf_realpath(&buf, worktree, 1));
}
-void setup_work_tree(void)
+void setup_work_tree(struct repository *repo)
{
const char *work_tree;
static int initialized = 0;
@@ -493,10 +492,10 @@ void setup_work_tree(void)
if (initialized)
return;
- if (work_tree_config_is_bogus)
+ if (repo->worktree_config_is_bogus)
die(_("unable to set up work tree using invalid config"));
- work_tree = repo_get_work_tree(the_repository);
+ work_tree = repo_get_work_tree(repo);
if (!work_tree || chdir_notify(work_tree))
die(_("this operation must be run in a work tree"));
@@ -1155,7 +1154,7 @@ static const char *setup_explicit_git_dir(struct repository *repo,
if (git_work_tree_cfg) {
/* #22.2, #30 */
warning("core.bare and core.worktree do not make sense");
- work_tree_config_is_bogus = 1;
+ repo->worktree_config_is_bogus = true;
}
/* #18, #26 */
diff --git a/setup.h b/setup.h
index d0cfdfd44a..8fed365637 100644
--- a/setup.h
+++ b/setup.h
@@ -56,7 +56,7 @@ const char *resolve_gitdir_gently(const char *suspect, int *return_error_code);
void die_upon_dubious_ownership(const char *gitfile, const char *worktree,
const char *gitdir);
-void setup_work_tree(void);
+void setup_work_tree(struct repository *repo);
/*
* discover_git_directory_reason() is similar to discover_git_directory(),
diff --git a/t/helper/test-subprocess.c b/t/helper/test-subprocess.c
index c344f1694d..8a070e47cd 100644
--- a/t/helper/test-subprocess.c
+++ b/t/helper/test-subprocess.c
@@ -1,3 +1,5 @@
+#define USE_THE_REPOSITORY_VARIABLE
+
#include "test-tool.h"
#include "run-command.h"
#include "setup.h"
@@ -11,7 +13,7 @@ int cmd__subprocess(int argc, const char **argv)
if (nogit)
die("No git repo found");
if (argc > 1 && !strcmp(argv[1], "--setup-work-tree")) {
- setup_work_tree();
+ setup_work_tree(the_repository);
argv++;
}
cp.git_cmd = 1;
diff --git a/wt-status.c b/wt-status.c
index 479ccc3304..6cc77ba68c 100644
--- a/wt-status.c
+++ b/wt-status.c
@@ -1206,7 +1206,7 @@ static void wt_longstatus_print_verbose(struct wt_status *s)
status_printf_ln(s, c,
"--------------------------------------------------");
status_printf_ln(s, c, _("Changes not staged for commit:"));
- setup_work_tree();
+ setup_work_tree(the_repository);
rev.diffopt.a_prefix = "i/";
rev.diffopt.b_prefix = "w/";
run_diff_files(&rev, 0);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH 09/18] setup: stop using `the_repository` in `setup_work_tree()`
2026-03-30 13:17 ` [PATCH 09/18] setup: stop using `the_repository` in `setup_work_tree()` Patrick Steinhardt
@ 2026-04-18 1:11 ` Elijah Newren
2026-04-20 7:06 ` Patrick Steinhardt
0 siblings, 1 reply; 32+ messages in thread
From: Elijah Newren @ 2026-04-18 1:11 UTC (permalink / raw)
To: Patrick Steinhardt; +Cc: git
On Mon, Mar 30, 2026 at 6:30 AM Patrick Steinhardt <ps@pks.im> wrote:
>
> Stop using `the_repository` in `setup_work_tree()` and instead accept
> the repository as a parameter. The injection of `the_repository` is thus
> bumped one level higher, where callers now pass it in explicitly.
>
> Note that the function tracks bogus worktree configuration via a global
> variable. If we have bogus configuration, and if later on some caller
> tries to setup a worktree, then we'll die instead.
>
> Of course, tracking this as a global variable doesn't make sense anymore
> now that we can set up worktrees for arbitrary repositories. Move the
> variable into `struct repository` instead.
Okay, we don't want a global, makes sense.
> Signed-off-by: Patrick Steinhardt <ps@pks.im>
> diff --git a/setup.c b/setup.c
> index dca32addae..64a030c6cd 100644
> --- a/setup.c
> +++ b/setup.c
> @@ -26,7 +26,6 @@
> #include "trace2.h"
> #include "worktree.h"
>
> -static int work_tree_config_is_bogus;
So, we removed this global....
> enum allowed_bare_repo {
> ALLOWED_BARE_REPO_EXPLICIT = 0,
> ALLOWED_BARE_REPO_ALL,
> @@ -485,7 +484,7 @@ int is_inside_work_tree(struct repository *repo)
> return is_inside_dir(strbuf_realpath(&buf, worktree, 1));
> }
>
> -void setup_work_tree(void)
> +void setup_work_tree(struct repository *repo)
> {
> const char *work_tree;
> static int initialized = 0;
...but we left this one...
> @@ -493,10 +492,10 @@ void setup_work_tree(void)
> if (initialized)
> return;
...and because of this other global, we still can only set up one work
tree in the process anyway. Should 'initialized' also be moved to a
field within repo?
^ permalink raw reply [flat|nested] 32+ messages in thread* Re: [PATCH 09/18] setup: stop using `the_repository` in `setup_work_tree()`
2026-04-18 1:11 ` Elijah Newren
@ 2026-04-20 7:06 ` Patrick Steinhardt
0 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-04-20 7:06 UTC (permalink / raw)
To: Elijah Newren; +Cc: git
On Fri, Apr 17, 2026 at 06:11:48PM -0700, Elijah Newren wrote:
> On Mon, Mar 30, 2026 at 6:30 AM Patrick Steinhardt <ps@pks.im> wrote:
> >
> > Stop using `the_repository` in `setup_work_tree()` and instead accept
> > the repository as a parameter. The injection of `the_repository` is thus
> > bumped one level higher, where callers now pass it in explicitly.
> >
> > Note that the function tracks bogus worktree configuration via a global
> > variable. If we have bogus configuration, and if later on some caller
> > tries to setup a worktree, then we'll die instead.
> >
> > Of course, tracking this as a global variable doesn't make sense anymore
> > now that we can set up worktrees for arbitrary repositories. Move the
> > variable into `struct repository` instead.
>
> Okay, we don't want a global, makes sense.
>
> > Signed-off-by: Patrick Steinhardt <ps@pks.im>
>
> > diff --git a/setup.c b/setup.c
> > index dca32addae..64a030c6cd 100644
> > --- a/setup.c
> > +++ b/setup.c
> > @@ -26,7 +26,6 @@
> > #include "trace2.h"
> > #include "worktree.h"
> >
> > -static int work_tree_config_is_bogus;
>
> So, we removed this global....
>
> > enum allowed_bare_repo {
> > ALLOWED_BARE_REPO_EXPLICIT = 0,
> > ALLOWED_BARE_REPO_ALL,
> > @@ -485,7 +484,7 @@ int is_inside_work_tree(struct repository *repo)
> > return is_inside_dir(strbuf_realpath(&buf, worktree, 1));
> > }
> >
> > -void setup_work_tree(void)
> > +void setup_work_tree(struct repository *repo)
> > {
> > const char *work_tree;
> > static int initialized = 0;
>
> ...but we left this one...
>
> > @@ -493,10 +492,10 @@ void setup_work_tree(void)
> > if (initialized)
> > return;
>
> ...and because of this other global, we still can only set up one work
> tree in the process anyway. Should 'initialized' also be moved to a
> field within repo?
Good catch. I thought I fixed this instance in a later commit or in the
next patch series, but I seemingly don't. Will adapt, thanks!
Patrick
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH 10/18] setup: stop using `the_repository` in `set_git_work_tree()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (8 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 09/18] setup: stop using `the_repository` in `setup_work_tree()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-04-18 1:16 ` Elijah Newren
2026-03-30 13:17 ` [PATCH 11/18] setup: stop using `the_repository` in `setup_git_env()` Patrick Steinhardt
` (8 subsequent siblings)
18 siblings, 1 reply; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `set_git_work_tree()` and instead accept
the repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Similar as with the preceding commit, we track whether the worktree has
been initialized already via a global variable so that we can die in
case the repository is re-initialized with a different worktree path.
Store this info in the `struct repository` instead so that we correctly
handle this per repository.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/clone.c | 2 +-
builtin/init-db.c | 6 +++---
repository.h | 1 +
setup.c | 24 +++++++++++-------------
setup.h | 2 +-
5 files changed, 17 insertions(+), 18 deletions(-)
diff --git a/builtin/clone.c b/builtin/clone.c
index 91b9a105a4..16cd7b029b 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -1114,7 +1114,7 @@ int cmd_clone(int argc,
die_errno(_("could not create work tree dir '%s'"),
work_tree);
junk_work_tree = work_tree;
- set_git_work_tree(work_tree);
+ set_git_work_tree(the_repository, work_tree);
}
if (real_git_dir) {
diff --git a/builtin/init-db.c b/builtin/init-db.c
index bb853e69f5..e626b0d8b7 100644
--- a/builtin/init-db.c
+++ b/builtin/init-db.c
@@ -237,9 +237,9 @@ int cmd_init_db(int argc,
if (!git_work_tree_cfg)
git_work_tree_cfg = xgetcwd();
if (work_tree)
- set_git_work_tree(work_tree);
+ set_git_work_tree(the_repository, work_tree);
else
- set_git_work_tree(git_work_tree_cfg);
+ set_git_work_tree(the_repository, git_work_tree_cfg);
if (access(repo_get_work_tree(the_repository), X_OK))
die_errno (_("Cannot access work tree '%s'"),
repo_get_work_tree(the_repository));
@@ -248,7 +248,7 @@ int cmd_init_db(int argc,
if (real_git_dir)
die(_("--separate-git-dir incompatible with bare repository"));
if (work_tree)
- set_git_work_tree(work_tree);
+ set_git_work_tree(the_repository, work_tree);
}
flags |= INIT_DB_EXIST_OK;
diff --git a/repository.h b/repository.h
index abeef3129e..7ae3d34484 100644
--- a/repository.h
+++ b/repository.h
@@ -113,6 +113,7 @@ struct repository {
* A NULL value indicates that there is no working directory.
*/
char *worktree;
+ bool worktree_initialized;
bool worktree_config_is_bogus;
/*
diff --git a/setup.c b/setup.c
index 64a030c6cd..2a917e3a5b 100644
--- a/setup.c
+++ b/setup.c
@@ -1149,7 +1149,7 @@ static const char *setup_explicit_git_dir(struct repository *repo,
/* #3, #7, #11, #15, #19, #23, #27, #31 (see t1510) */
if (work_tree_env)
- set_git_work_tree(work_tree_env);
+ set_git_work_tree(repo, work_tree_env);
else if (is_bare_repository_cfg > 0) {
if (git_work_tree_cfg) {
/* #22.2, #30 */
@@ -1164,7 +1164,7 @@ static const char *setup_explicit_git_dir(struct repository *repo,
}
else if (git_work_tree_cfg) { /* #6, #14 */
if (is_absolute_path(git_work_tree_cfg))
- set_git_work_tree(git_work_tree_cfg);
+ set_git_work_tree(repo, git_work_tree_cfg);
else {
char *core_worktree;
if (chdir(gitdirenv))
@@ -1174,7 +1174,7 @@ static const char *setup_explicit_git_dir(struct repository *repo,
core_worktree = xgetcwd();
if (chdir(cwd->buf))
die_errno(_("cannot come back to cwd"));
- set_git_work_tree(core_worktree);
+ set_git_work_tree(repo, core_worktree);
free(core_worktree);
}
}
@@ -1185,7 +1185,7 @@ static const char *setup_explicit_git_dir(struct repository *repo,
return NULL;
}
else /* #2, #10 */
- set_git_work_tree(".");
+ set_git_work_tree(repo, ".");
/* set_git_work_tree() must have been called by now */
worktree = repo_get_work_tree(repo);
@@ -1245,7 +1245,7 @@ static const char *setup_discovered_git_dir(struct repository *repo,
}
/* #0, #1, #5, #8, #9, #12, #13 */
- set_git_work_tree(".");
+ set_git_work_tree(repo, ".");
if (strcmp(gitdir, DEFAULT_GIT_DIR_ENVIRONMENT))
set_git_dir(repo, gitdir, 0);
if (offset >= cwd->len)
@@ -1836,29 +1836,27 @@ const char *enter_repo(struct repository *repo, const char *path, unsigned flags
return NULL;
}
-static int git_work_tree_initialized;
-
/*
* Note. This works only before you used a work tree. This was added
* primarily to support git-clone to work in a new repository it just
* created, and is not meant to flip between different work trees.
*/
-void set_git_work_tree(const char *new_work_tree)
+void set_git_work_tree(struct repository *repo, const char *new_work_tree)
{
- if (git_work_tree_initialized) {
+ if (repo->worktree_initialized) {
struct strbuf realpath = STRBUF_INIT;
strbuf_realpath(&realpath, new_work_tree, 1);
new_work_tree = realpath.buf;
- if (strcmp(new_work_tree, the_repository->worktree))
+ if (strcmp(new_work_tree, repo->worktree))
die("internal error: work tree has already been set\n"
"Current worktree: %s\nNew worktree: %s",
- the_repository->worktree, new_work_tree);
+ repo->worktree, new_work_tree);
strbuf_release(&realpath);
return;
}
- git_work_tree_initialized = 1;
- repo_set_worktree(the_repository, new_work_tree);
+ repo->worktree_initialized = 1;
+ repo_set_worktree(repo, new_work_tree);
}
const char *setup_git_directory_gently(int *nongit_ok)
diff --git a/setup.h b/setup.h
index 8fed365637..1a37089fa0 100644
--- a/setup.h
+++ b/setup.h
@@ -96,7 +96,7 @@ static inline int discover_git_directory(struct strbuf *commondir,
return 0;
}
-void set_git_work_tree(const char *tree);
+void set_git_work_tree(struct repository *repo, const char *tree);
/* Flags that can be passed to `enter_repo()`. */
enum {
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH 10/18] setup: stop using `the_repository` in `set_git_work_tree()`
2026-03-30 13:17 ` [PATCH 10/18] setup: stop using `the_repository` in `set_git_work_tree()` Patrick Steinhardt
@ 2026-04-18 1:16 ` Elijah Newren
2026-04-20 7:06 ` Patrick Steinhardt
0 siblings, 1 reply; 32+ messages in thread
From: Elijah Newren @ 2026-04-18 1:16 UTC (permalink / raw)
To: Patrick Steinhardt; +Cc: git
On Mon, Mar 30, 2026 at 6:19 AM Patrick Steinhardt <ps@pks.im> wrote:
>
> Stop using `the_repository` in `set_git_work_tree()` and instead accept
> the repository as a parameter. The injection of `the_repository` is thus
> bumped one level higher, where callers now pass it in explicitly.
>
> Similar as with the preceding commit, we track whether the worktree has
> been initialized already via a global variable so that we can die in
> case the repository is re-initialized with a different worktree path.
> Store this info in the `struct repository` instead so that we correctly
> handle this per repository.
>
> Signed-off-by: Patrick Steinhardt <ps@pks.im>
> ---
> builtin/clone.c | 2 +-
> builtin/init-db.c | 6 +++---
> repository.h | 1 +
> setup.c | 24 +++++++++++-------------
> setup.h | 2 +-
> 5 files changed, 17 insertions(+), 18 deletions(-)
>
> diff --git a/repository.h b/repository.h
> index abeef3129e..7ae3d34484 100644
> --- a/repository.h
> +++ b/repository.h
[...]
> + bool worktree_initialized;
> diff --git a/setup.c b/setup.c
[...]
>
> -static int git_work_tree_initialized;
Okay, so we replaced the global git_work_tree_intialized with a
repository field named worktree_initialized, _and_ changed its type
from int to bool...
> - git_work_tree_initialized = 1;
> - repo_set_worktree(the_repository, new_work_tree);
> + repo->worktree_initialized = 1;
> + repo_set_worktree(repo, new_work_tree);
...yet we still set it to "1". Shouldn't we initialize it to "true"
given the typechange?
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH 10/18] setup: stop using `the_repository` in `set_git_work_tree()`
2026-04-18 1:16 ` Elijah Newren
@ 2026-04-20 7:06 ` Patrick Steinhardt
0 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-04-20 7:06 UTC (permalink / raw)
To: Elijah Newren; +Cc: git
On Fri, Apr 17, 2026 at 06:16:30PM -0700, Elijah Newren wrote:
> On Mon, Mar 30, 2026 at 6:19 AM Patrick Steinhardt <ps@pks.im> wrote:
> > diff --git a/repository.h b/repository.h
> > index abeef3129e..7ae3d34484 100644
> > --- a/repository.h
> > +++ b/repository.h
> [...]
> > + bool worktree_initialized;
> > diff --git a/setup.c b/setup.c
> [...]
> >
> > -static int git_work_tree_initialized;
>
> Okay, so we replaced the global git_work_tree_intialized with a
> repository field named worktree_initialized, _and_ changed its type
> from int to bool...
>
> > - git_work_tree_initialized = 1;
> > - repo_set_worktree(the_repository, new_work_tree);
> > + repo->worktree_initialized = 1;
> > + repo_set_worktree(repo, new_work_tree);
>
> ...yet we still set it to "1". Shouldn't we initialize it to "true"
> given the typechange?
Good point, will fix.
Patrick
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH 11/18] setup: stop using `the_repository` in `setup_git_env()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (9 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 10/18] setup: stop using `the_repository` in `set_git_work_tree()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 12/18] setup: stop using `the_repository` in `setup_git_directory_gently()` Patrick Steinhardt
` (7 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `setup_git_env()` and instead accept the
repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Furthermore, the function is never used outside of "setup.c". Drop the
declaration in "environment.h" and make it static.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
environment.h | 2 --
setup.c | 6 +++---
2 files changed, 3 insertions(+), 5 deletions(-)
diff --git a/environment.h b/environment.h
index 123a71cdc8..9eb97b3869 100644
--- a/environment.h
+++ b/environment.h
@@ -147,8 +147,6 @@ void repo_config_values_init(struct repo_config_values *cfg);
* Please do not add new global config variables here.
*/
# ifdef USE_THE_REPOSITORY_VARIABLE
-void setup_git_env(const char *git_dir);
-
/*
* Returns true iff we have a configured git repository (either via
* setup_git_directory, or in the environment via $GIT_DIR).
diff --git a/setup.c b/setup.c
index 2a917e3a5b..e1814fb8e6 100644
--- a/setup.c
+++ b/setup.c
@@ -1071,9 +1071,9 @@ static void setup_git_env_internal(struct repository *repo,
fetch_if_missing = 0;
}
-void setup_git_env(const char *git_dir)
+static void setup_git_env(struct repository *repo, const char *git_dir)
{
- setup_git_env_internal(the_repository, git_dir, false);
+ setup_git_env_internal(repo, git_dir, false);
}
static void set_git_dir_1(struct repository *repo, const char *path, bool skip_initializing_odb)
@@ -1985,7 +1985,7 @@ const char *setup_git_directory_gently(int *nongit_ok)
const char *gitdir = getenv(GIT_DIR_ENVIRONMENT);
if (!gitdir)
gitdir = DEFAULT_GIT_DIR_ENVIRONMENT;
- setup_git_env(gitdir);
+ setup_git_env(the_repository, gitdir);
}
if (startup_info->have_repository) {
repo_set_hash_algo(the_repository, repo_fmt.hash_algo);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 12/18] setup: stop using `the_repository` in `setup_git_directory_gently()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (10 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 11/18] setup: stop using `the_repository` in `setup_git_env()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 13/18] setup: stop using `the_repository` in `setup_git_directory()` Patrick Steinhardt
` (6 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `setup_git_directory_gently()` and
instead accept the repository as a parameter. The injection of
`the_repository` is thus bumped one level higher, where callers now pass
it in explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/check-ref-format.c | 5 ++++-
builtin/diff.c | 2 +-
builtin/hash-object.c | 2 +-
builtin/help.c | 2 +-
builtin/stripspace.c | 2 +-
git.c | 6 +++---
http-fetch.c | 2 +-
imap-send.c | 2 +-
remote-curl.c | 4 ++--
setup.c | 36 ++++++++++++++++++------------------
setup.h | 2 +-
t/helper/test-path-utils.c | 2 +-
t/helper/test-subprocess.c | 2 +-
13 files changed, 36 insertions(+), 33 deletions(-)
diff --git a/builtin/check-ref-format.c b/builtin/check-ref-format.c
index 5d80afeec0..e42b0444ea 100644
--- a/builtin/check-ref-format.c
+++ b/builtin/check-ref-format.c
@@ -1,6 +1,9 @@
/*
* GIT - The information manager from hell
*/
+
+#define USE_THE_REPOSITORY_VARIABLE
+
#include "builtin.h"
#include "refs.h"
#include "setup.h"
@@ -41,7 +44,7 @@ static int check_ref_format_branch(const char *arg)
const char *name;
int nongit;
- setup_git_directory_gently(&nongit);
+ setup_git_directory_gently(the_repository, &nongit);
if (check_branch_ref(&sb, arg) ||
!skip_prefix(sb.buf, "refs/heads/", &name))
die("'%s' is not a valid branch name", arg);
diff --git a/builtin/diff.c b/builtin/diff.c
index 1ede873ac1..4b46e394ce 100644
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -455,7 +455,7 @@ int cmd_diff(int argc,
break;
}
- prefix = setup_git_directory_gently(&nongit);
+ prefix = setup_git_directory_gently(the_repository, &nongit);
if (!nongit) {
prepare_repo_settings(the_repository);
diff --git a/builtin/hash-object.c b/builtin/hash-object.c
index 5d900a6b8c..d7905bedc2 100644
--- a/builtin/hash-object.c
+++ b/builtin/hash-object.c
@@ -102,7 +102,7 @@ int cmd_hash_object(int argc,
if (flags & INDEX_WRITE_OBJECT)
prefix = setup_git_directory();
else
- prefix = setup_git_directory_gently(&nongit);
+ prefix = setup_git_directory_gently(the_repository, &nongit);
if (nongit && !the_hash_algo)
repo_set_hash_algo(the_repository, GIT_HASH_DEFAULT);
diff --git a/builtin/help.c b/builtin/help.c
index c0aece4da3..a140339999 100644
--- a/builtin/help.c
+++ b/builtin/help.c
@@ -740,7 +740,7 @@ int cmd_help(int argc,
return 0;
}
- setup_git_directory_gently(&nongit);
+ setup_git_directory_gently(the_repository, &nongit);
repo_config(the_repository, git_help_config, NULL);
if (parsed_help_format != HELP_FORMAT_NONE)
diff --git a/builtin/stripspace.c b/builtin/stripspace.c
index 4a566cbc5d..18705f1a5b 100644
--- a/builtin/stripspace.c
+++ b/builtin/stripspace.c
@@ -54,7 +54,7 @@ int cmd_stripspace(int argc,
usage_with_options(stripspace_usage, options);
if (mode == STRIP_COMMENTS || mode == COMMENT_LINES) {
- setup_git_directory_gently(&nongit);
+ setup_git_directory_gently(the_repository, &nongit);
repo_config(the_repository, git_default_config, NULL);
}
diff --git a/git.c b/git.c
index c146eaa20b..0df36c9b9d 100644
--- a/git.c
+++ b/git.c
@@ -84,7 +84,7 @@ static int list_cmds(const char *spec)
* Set up the repository so we can pick up any repo-level config (like
* completion.commands).
*/
- setup_git_directory_gently(&nongit);
+ setup_git_directory_gently(the_repository, &nongit);
while (*spec) {
const char *sep = strchrnul(spec, ',');
@@ -386,7 +386,7 @@ static int handle_alias(struct strvec *args, struct string_list *expanded_aliase
int nongit_ok;
/* Aliases expect GIT_PREFIX, GIT_DIR etc to be set */
- setup_git_directory_gently(&nongit_ok);
+ setup_git_directory_gently(the_repository, &nongit_ok);
commit_pager_choice();
@@ -480,7 +480,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv, struct
prefix = setup_git_directory();
no_repo = 0;
} else if (run_setup & RUN_SETUP_GENTLY) {
- prefix = setup_git_directory_gently(&no_repo);
+ prefix = setup_git_directory_gently(the_repository, &no_repo);
} else {
prefix = NULL;
}
diff --git a/http-fetch.c b/http-fetch.c
index 1922e23fcd..f9b6ecb061 100644
--- a/http-fetch.c
+++ b/http-fetch.c
@@ -109,7 +109,7 @@ int cmd_main(int argc, const char **argv)
struct strvec index_pack_args = STRVEC_INIT;
int ret;
- setup_git_directory_gently(&nongit);
+ setup_git_directory_gently(the_repository, &nongit);
while (arg < argc && argv[arg][0] == '-') {
const char *p;
diff --git a/imap-send.c b/imap-send.c
index af02c6a689..cfd6a5120c 100644
--- a/imap-send.c
+++ b/imap-send.c
@@ -1799,7 +1799,7 @@ int cmd_main(int argc, const char **argv)
int nongit_ok;
int ret;
- setup_git_directory_gently(&nongit_ok);
+ setup_git_directory_gently(the_repository, &nongit_ok);
repo_config(the_repository, git_imap_config, &server);
argc = parse_options(argc, (const char **)argv, "", imap_send_options, imap_send_usage, 0);
diff --git a/remote-curl.c b/remote-curl.c
index 92e40bb682..454283c43f 100644
--- a/remote-curl.c
+++ b/remote-curl.c
@@ -1546,7 +1546,7 @@ int cmd_main(int argc, const char **argv)
int nongit;
int ret = 1;
- setup_git_directory_gently(&nongit);
+ setup_git_directory_gently(the_repository, &nongit);
if (argc < 2) {
error(_("remote-curl: usage: git remote-curl <remote> [<url>]"));
goto cleanup;
@@ -1587,7 +1587,7 @@ int cmd_main(int argc, const char **argv)
break;
if (starts_with(buf.buf, "fetch ")) {
if (nongit) {
- setup_git_directory_gently(&nongit);
+ setup_git_directory_gently(the_repository, &nongit);
if (nongit)
die(_("remote-curl: fetch attempted without a local repo"));
}
diff --git a/setup.c b/setup.c
index e1814fb8e6..99c0d1640e 100644
--- a/setup.c
+++ b/setup.c
@@ -1859,7 +1859,7 @@ void set_git_work_tree(struct repository *repo, const char *new_work_tree)
repo_set_worktree(repo, new_work_tree);
}
-const char *setup_git_directory_gently(int *nongit_ok)
+const char *setup_git_directory_gently(struct repository *repo, int *nongit_ok)
{
static struct strbuf cwd = STRBUF_INIT;
struct strbuf dir = STRBUF_INIT, gitdir = STRBUF_INIT, report = STRBUF_INIT;
@@ -1874,7 +1874,7 @@ const char *setup_git_directory_gently(int *nongit_ok)
* configuration (including the per-repo config file that we
* ignored previously).
*/
- repo_config_clear(the_repository);
+ repo_config_clear(repo);
/*
* Let's assume that we are in a git repository.
@@ -1890,18 +1890,18 @@ const char *setup_git_directory_gently(int *nongit_ok)
switch (setup_git_directory_gently_1(&dir, &gitdir, &report, 1)) {
case GIT_DIR_EXPLICIT:
- prefix = setup_explicit_git_dir(the_repository, gitdir.buf, &cwd, &repo_fmt, nongit_ok);
+ prefix = setup_explicit_git_dir(repo, gitdir.buf, &cwd, &repo_fmt, nongit_ok);
break;
case GIT_DIR_DISCOVERED:
if (dir.len < cwd.len && chdir(dir.buf))
die(_("cannot change to '%s'"), dir.buf);
- prefix = setup_discovered_git_dir(the_repository, gitdir.buf, &cwd, dir.len,
+ prefix = setup_discovered_git_dir(repo, gitdir.buf, &cwd, dir.len,
&repo_fmt, nongit_ok);
break;
case GIT_DIR_BARE:
if (dir.len < cwd.len && chdir(dir.buf))
die(_("cannot change to '%s'"), dir.buf);
- prefix = setup_bare_git_dir(the_repository, &cwd, dir.len, &repo_fmt, nongit_ok);
+ prefix = setup_bare_git_dir(repo, &cwd, dir.len, &repo_fmt, nongit_ok);
break;
case GIT_DIR_HIT_CEILING:
if (!nongit_ok)
@@ -1981,30 +1981,30 @@ const char *setup_git_directory_gently(int *nongit_ok)
startup_info->have_repository ||
/* GIT_DIR_EXPLICIT */
getenv(GIT_DIR_ENVIRONMENT)) {
- if (!the_repository->gitdir) {
+ if (!repo->gitdir) {
const char *gitdir = getenv(GIT_DIR_ENVIRONMENT);
if (!gitdir)
gitdir = DEFAULT_GIT_DIR_ENVIRONMENT;
- setup_git_env(the_repository, gitdir);
+ setup_git_env(repo, gitdir);
}
if (startup_info->have_repository) {
- repo_set_hash_algo(the_repository, repo_fmt.hash_algo);
- repo_set_compat_hash_algo(the_repository,
+ repo_set_hash_algo(repo, repo_fmt.hash_algo);
+ repo_set_compat_hash_algo(repo,
repo_fmt.compat_hash_algo);
- repo_set_ref_storage_format(the_repository,
+ repo_set_ref_storage_format(repo,
repo_fmt.ref_storage_format,
repo_fmt.ref_storage_payload);
- the_repository->repository_format_worktree_config =
+ repo->repository_format_worktree_config =
repo_fmt.worktree_config;
- the_repository->repository_format_relative_worktrees =
+ repo->repository_format_relative_worktrees =
repo_fmt.relative_worktrees;
- the_repository->repository_format_submodule_path_cfg =
+ repo->repository_format_submodule_path_cfg =
repo_fmt.submodule_path_cfg;
/* take ownership of repo_fmt.partial_clone */
- the_repository->repository_format_partial_clone =
+ repo->repository_format_partial_clone =
repo_fmt.partial_clone;
repo_fmt.partial_clone = NULL;
- the_repository->repository_format_precious_objects =
+ repo->repository_format_precious_objects =
repo_fmt.precious_objects;
}
}
@@ -2037,13 +2037,13 @@ const char *setup_git_directory_gently(int *nongit_ok)
format = ref_storage_format_by_name(backend);
if (format == REF_STORAGE_FORMAT_UNKNOWN)
die(_("unknown ref storage format: '%s'"), backend);
- repo_set_ref_storage_format(the_repository, format, payload);
+ repo_set_ref_storage_format(repo, format, payload);
free(backend);
free(payload);
}
- setup_original_cwd(the_repository);
+ setup_original_cwd(repo);
strbuf_release(&dir);
strbuf_release(&gitdir);
@@ -2135,7 +2135,7 @@ void check_repository_format(struct repository_format *fmt)
*/
const char *setup_git_directory(void)
{
- return setup_git_directory_gently(NULL);
+ return setup_git_directory_gently(the_repository, NULL);
}
const char *resolve_gitdir_gently(const char *suspect, int *return_error_code)
diff --git a/setup.h b/setup.h
index 1a37089fa0..18092fbf16 100644
--- a/setup.h
+++ b/setup.h
@@ -136,7 +136,7 @@ enum {
*/
const char *enter_repo(struct repository *repo, const char *path, unsigned flags);
-const char *setup_git_directory_gently(int *);
+const char *setup_git_directory_gently(struct repository *repo, int *);
const char *setup_git_directory(void);
char *prefix_path(struct repository *repo, const char *prefix, int len, const char *path);
char *prefix_path_gently(struct repository *repo, const char *prefix, int len, int *remaining, const char *path);
diff --git a/t/helper/test-path-utils.c b/t/helper/test-path-utils.c
index 163fdeefb0..15eb44485c 100644
--- a/t/helper/test-path-utils.c
+++ b/t/helper/test-path-utils.c
@@ -377,7 +377,7 @@ int cmd__path_utils(int argc, const char **argv)
const char *prefix = argv[2];
int prefix_len = strlen(prefix);
int nongit_ok;
- setup_git_directory_gently(&nongit_ok);
+ setup_git_directory_gently(the_repository, &nongit_ok);
while (argc > 3) {
char *pfx = prefix_path(the_repository, prefix, prefix_len, argv[3]);
diff --git a/t/helper/test-subprocess.c b/t/helper/test-subprocess.c
index 8a070e47cd..a8194d24b3 100644
--- a/t/helper/test-subprocess.c
+++ b/t/helper/test-subprocess.c
@@ -9,7 +9,7 @@ int cmd__subprocess(int argc, const char **argv)
struct child_process cp = CHILD_PROCESS_INIT;
int nogit = 0;
- setup_git_directory_gently(&nogit);
+ setup_git_directory_gently(the_repository, &nogit);
if (nogit)
die("No git repo found");
if (argc > 1 && !strcmp(argv[1], "--setup-work-tree")) {
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 13/18] setup: stop using `the_repository` in `setup_git_directory()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (11 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 12/18] setup: stop using `the_repository` in `setup_git_directory_gently()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 14/18] setup: stop using `the_repository` in `upgrade_repository_format()` Patrick Steinhardt
` (5 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `setup_git_directory()` and instead
accept the repository as a parameter. The injection of `the_repository`
is thus bumped one level higher, where callers now pass it in
explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
archive.c | 2 +-
builtin/grep.c | 2 +-
builtin/hash-object.c | 2 +-
builtin/merge-file.c | 2 +-
builtin/rev-parse.c | 4 ++--
git.c | 2 +-
http-push.c | 2 +-
scalar.c | 4 ++--
setup.c | 4 ++--
setup.h | 2 +-
t/helper/test-advise.c | 2 +-
t/helper/test-bitmap.c | 2 +-
t/helper/test-bloom.c | 2 +-
t/helper/test-cache-tree.c | 2 +-
t/helper/test-config.c | 2 +-
t/helper/test-dump-cache-tree.c | 2 +-
t/helper/test-dump-fsmonitor.c | 2 +-
t/helper/test-dump-split-index.c | 2 +-
t/helper/test-dump-untracked-cache.c | 2 +-
t/helper/test-find-pack.c | 2 +-
t/helper/test-fsmonitor-client.c | 2 +-
t/helper/test-lazy-init-name-hash.c | 2 +-
t/helper/test-match-trees.c | 2 +-
t/helper/test-pack-deltas.c | 2 +-
t/helper/test-pack-mtimes.c | 2 +-
t/helper/test-partial-clone.c | 4 +++-
t/helper/test-path-walk.c | 2 +-
t/helper/test-reach.c | 2 +-
t/helper/test-read-cache.c | 2 +-
t/helper/test-read-graph.c | 2 +-
t/helper/test-read-midx.c | 2 +-
t/helper/test-ref-store.c | 2 +-
t/helper/test-revision-walking.c | 2 +-
t/helper/test-scrap-cache-tree.c | 2 +-
t/helper/test-serve-v2.c | 2 +-
t/helper/test-submodule-config.c | 2 +-
t/helper/test-submodule-nested-repo-config.c | 2 +-
t/helper/test-submodule.c | 10 +++++-----
t/helper/test-userdiff.c | 2 +-
t/helper/test-write-cache.c | 2 +-
40 files changed, 49 insertions(+), 47 deletions(-)
diff --git a/archive.c b/archive.c
index fcd474c682..51229107a5 100644
--- a/archive.c
+++ b/archive.c
@@ -786,7 +786,7 @@ int write_archive(int argc, const char **argv, const char *prefix,
* die ourselves; but its error message will be more specific
* than what we could write here.
*/
- setup_git_directory();
+ setup_git_directory(the_repository);
}
parse_treeish_arg(argv, &args, remote);
diff --git a/builtin/grep.c b/builtin/grep.c
index 679f8b567a..560133feb8 100644
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -1064,7 +1064,7 @@ int cmd_grep(int argc,
use_index = 0;
else
/* die the same way as if we did it at the beginning */
- setup_git_directory();
+ setup_git_directory(the_repository);
}
/* Ignore --recurse-submodules if --no-index is given or implied */
if (!use_index)
diff --git a/builtin/hash-object.c b/builtin/hash-object.c
index d7905bedc2..f306b0643f 100644
--- a/builtin/hash-object.c
+++ b/builtin/hash-object.c
@@ -100,7 +100,7 @@ int cmd_hash_object(int argc,
hash_object_usage, 0);
if (flags & INDEX_WRITE_OBJECT)
- prefix = setup_git_directory();
+ prefix = setup_git_directory(the_repository);
else
prefix = setup_git_directory_gently(the_repository, &nongit);
diff --git a/builtin/merge-file.c b/builtin/merge-file.c
index 59a9792208..8fa5765239 100644
--- a/builtin/merge-file.c
+++ b/builtin/merge-file.c
@@ -110,7 +110,7 @@ int cmd_merge_file(int argc,
if (!repo && object_id)
/* emit the correct "not a git repo" error in this case */
- setup_git_directory();
+ setup_git_directory(the_repository);
for (i = 0; i < 3; i++) {
char *fname;
diff --git a/builtin/rev-parse.c b/builtin/rev-parse.c
index d7c6400ddc..426a3c5676 100644
--- a/builtin/rev-parse.c
+++ b/builtin/rev-parse.c
@@ -739,7 +739,7 @@ int cmd_rev_parse(int argc,
/* No options; just report on whether we're in a git repo or not. */
if (argc == 1) {
- setup_git_directory();
+ setup_git_directory(the_repository);
repo_config(the_repository, git_default_config, NULL);
return 0;
}
@@ -774,7 +774,7 @@ int cmd_rev_parse(int argc,
/* The rest of the options require a git repository. */
if (!did_repo_setup) {
- prefix = setup_git_directory();
+ prefix = setup_git_directory(the_repository);
repo_config(the_repository, git_default_config, NULL);
did_repo_setup = 1;
diff --git a/git.c b/git.c
index 0df36c9b9d..78bd607e2f 100644
--- a/git.c
+++ b/git.c
@@ -477,7 +477,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv, struct
run_setup = RUN_SETUP_GENTLY;
if (run_setup & RUN_SETUP) {
- prefix = setup_git_directory();
+ prefix = setup_git_directory(the_repository);
no_repo = 0;
} else if (run_setup & RUN_SETUP_GENTLY) {
prefix = setup_git_directory_gently(the_repository, &no_repo);
diff --git a/http-push.c b/http-push.c
index 9ae6062198..ee66813012 100644
--- a/http-push.c
+++ b/http-push.c
@@ -1788,7 +1788,7 @@ int cmd_main(int argc, const char **argv)
if (delete_branch && rs.nr != 1)
die("You must specify only one branch name when deleting a remote branch");
- gitdir = setup_git_directory();
+ gitdir = setup_git_directory(the_repository);
memset(remote_dir_exists, -1, 256);
diff --git a/scalar.c b/scalar.c
index 4efb6ac36d..a80d8ee3ff 100644
--- a/scalar.c
+++ b/scalar.c
@@ -58,7 +58,7 @@ static void setup_enlistment_directory(int argc, const char **argv,
}
strbuf_setlen(&path, len);
- setup_git_directory();
+ setup_git_directory(the_repository);
if (!the_repository->worktree)
die(_("Scalar enlistments require a worktree"));
@@ -514,7 +514,7 @@ static int cmd_clone(int argc, const char **argv)
goto cleanup;
}
- setup_git_directory();
+ setup_git_directory(the_repository);
/* common-main already logs `argv` */
trace2_def_repo(the_repository);
diff --git a/setup.c b/setup.c
index 99c0d1640e..da0576d28a 100644
--- a/setup.c
+++ b/setup.c
@@ -2133,9 +2133,9 @@ void check_repository_format(struct repository_format *fmt)
* directory is not a strict subdirectory of the work tree root. The
* prefix always ends with a '/' character.
*/
-const char *setup_git_directory(void)
+const char *setup_git_directory(struct repository *repo)
{
- return setup_git_directory_gently(the_repository, NULL);
+ return setup_git_directory_gently(repo, NULL);
}
const char *resolve_gitdir_gently(const char *suspect, int *return_error_code)
diff --git a/setup.h b/setup.h
index 18092fbf16..b779661ce7 100644
--- a/setup.h
+++ b/setup.h
@@ -137,7 +137,7 @@ enum {
const char *enter_repo(struct repository *repo, const char *path, unsigned flags);
const char *setup_git_directory_gently(struct repository *repo, int *);
-const char *setup_git_directory(void);
+const char *setup_git_directory(struct repository *repo);
char *prefix_path(struct repository *repo, const char *prefix, int len, const char *path);
char *prefix_path_gently(struct repository *repo, const char *prefix, int len, int *remaining, const char *path);
diff --git a/t/helper/test-advise.c b/t/helper/test-advise.c
index 81ed93a05c..8f9db2693e 100644
--- a/t/helper/test-advise.c
+++ b/t/helper/test-advise.c
@@ -11,7 +11,7 @@ int cmd__advise_if_enabled(int argc, const char **argv)
if (argc != 2)
die("usage: %s <advice>", argv[0]);
- setup_git_directory();
+ setup_git_directory(the_repository);
repo_config(the_repository, git_default_config, NULL);
/*
diff --git a/t/helper/test-bitmap.c b/t/helper/test-bitmap.c
index 16a01669e4..d9b9a83b8f 100644
--- a/t/helper/test-bitmap.c
+++ b/t/helper/test-bitmap.c
@@ -37,7 +37,7 @@ static int bitmap_dump_pseudo_merge_objects(uint32_t n)
int cmd__bitmap(int argc, const char **argv)
{
- setup_git_directory();
+ setup_git_directory(the_repository);
if (argc == 2 && !strcmp(argv[1], "list-commits"))
return bitmap_list_commits();
diff --git a/t/helper/test-bloom.c b/t/helper/test-bloom.c
index 3283544bd3..0c65befbf0 100644
--- a/t/helper/test-bloom.c
+++ b/t/helper/test-bloom.c
@@ -52,7 +52,7 @@ static const char *const bloom_usage = "\n"
int cmd__bloom(int argc, const char **argv)
{
- setup_git_directory();
+ setup_git_directory(the_repository);
if (argc < 2)
usage(bloom_usage);
diff --git a/t/helper/test-cache-tree.c b/t/helper/test-cache-tree.c
index ff61d0ca7e..d42e260092 100644
--- a/t/helper/test-cache-tree.c
+++ b/t/helper/test-cache-tree.c
@@ -33,7 +33,7 @@ int cmd__cache_tree(int argc, const char **argv)
OPT_END()
};
- setup_git_directory();
+ setup_git_directory(the_repository);
argc = parse_options(argc, argv, NULL, options, test_cache_tree_usage, 0);
diff --git a/t/helper/test-config.c b/t/helper/test-config.c
index 9f8cca7c48..cfb3f4b111 100644
--- a/t/helper/test-config.c
+++ b/t/helper/test-config.c
@@ -102,7 +102,7 @@ int cmd__config(int argc, const char **argv)
return 0;
}
- setup_git_directory();
+ setup_git_directory(the_repository);
git_configset_init(&cs);
diff --git a/t/helper/test-dump-cache-tree.c b/t/helper/test-dump-cache-tree.c
index 3f0c7d0ed0..ccb41a4239 100644
--- a/t/helper/test-dump-cache-tree.c
+++ b/t/helper/test-dump-cache-tree.c
@@ -66,7 +66,7 @@ int cmd__dump_cache_tree(int ac UNUSED, const char **av UNUSED)
struct cache_tree *another = cache_tree();
int ret;
- setup_git_directory();
+ setup_git_directory(the_repository);
if (repo_read_index(the_repository) < 0)
die("unable to read index file");
istate = *the_repository->index;
diff --git a/t/helper/test-dump-fsmonitor.c b/t/helper/test-dump-fsmonitor.c
index efd017ca35..c991cbbb8a 100644
--- a/t/helper/test-dump-fsmonitor.c
+++ b/t/helper/test-dump-fsmonitor.c
@@ -9,7 +9,7 @@ int cmd__dump_fsmonitor(int ac UNUSED, const char **av UNUSED)
{
struct index_state *istate = the_repository->index;
- setup_git_directory();
+ setup_git_directory(the_repository);
if (do_read_index(istate, the_repository->index_file, 0) < 0)
die("unable to read index file");
if (!istate->fsmonitor_last_update) {
diff --git a/t/helper/test-dump-split-index.c b/t/helper/test-dump-split-index.c
index f855a3862c..aae0a40a74 100644
--- a/t/helper/test-dump-split-index.c
+++ b/t/helper/test-dump-split-index.c
@@ -17,7 +17,7 @@ int cmd__dump_split_index(int ac UNUSED, const char **av)
{
struct split_index *si;
- setup_git_directory();
+ setup_git_directory(the_repository);
do_read_index(the_repository->index, av[1], 1);
printf("own %s\n", oid_to_hex(&the_repository->index->oid));
diff --git a/t/helper/test-dump-untracked-cache.c b/t/helper/test-dump-untracked-cache.c
index 01a109496b..24308bd371 100644
--- a/t/helper/test-dump-untracked-cache.c
+++ b/t/helper/test-dump-untracked-cache.c
@@ -54,7 +54,7 @@ int cmd__dump_untracked_cache(int ac UNUSED, const char **av UNUSED)
xsetenv("GIT_CONFIG_KEY_0", "core.untrackedCache", 1);
xsetenv("GIT_CONFIG_VALUE_0", "keep", 1);
- setup_git_directory();
+ setup_git_directory(the_repository);
if (repo_read_index(the_repository) < 0)
die("unable to read index file");
uc = the_repository->index->untracked;
diff --git a/t/helper/test-find-pack.c b/t/helper/test-find-pack.c
index fc4b8a77b3..28d5b1fe09 100644
--- a/t/helper/test-find-pack.c
+++ b/t/helper/test-find-pack.c
@@ -25,7 +25,7 @@ int cmd__find_pack(int argc, const char **argv)
struct object_id oid;
struct packed_git *p;
int count = -1, actual_count = 0;
- const char *prefix = setup_git_directory();
+ const char *prefix = setup_git_directory(the_repository);
struct option options[] = {
OPT_INTEGER('c', "check-count", &count, "expected number of packs"),
diff --git a/t/helper/test-fsmonitor-client.c b/t/helper/test-fsmonitor-client.c
index 02bfe92e8d..dc1dff23fb 100644
--- a/t/helper/test-fsmonitor-client.c
+++ b/t/helper/test-fsmonitor-client.c
@@ -210,7 +210,7 @@ int cmd__fsmonitor_client(int argc, const char **argv)
subcmd = argv[0];
- setup_git_directory();
+ setup_git_directory(the_repository);
if (!strcmp(subcmd, "query"))
return !!do_send_query(token);
diff --git a/t/helper/test-lazy-init-name-hash.c b/t/helper/test-lazy-init-name-hash.c
index 40f5df4412..e542985c94 100644
--- a/t/helper/test-lazy-init-name-hash.c
+++ b/t/helper/test-lazy-init-name-hash.c
@@ -211,7 +211,7 @@ int cmd__lazy_init_name_hash(int argc, const char **argv)
const char *prefix;
uint64_t avg_single, avg_multi;
- prefix = setup_git_directory();
+ prefix = setup_git_directory(the_repository);
argc = parse_options(argc, argv, prefix, options, usage, 0);
diff --git a/t/helper/test-match-trees.c b/t/helper/test-match-trees.c
index 2ed064b971..006ce5278e 100644
--- a/t/helper/test-match-trees.c
+++ b/t/helper/test-match-trees.c
@@ -13,7 +13,7 @@ int cmd__match_trees(int ac UNUSED, const char **av)
struct object_id hash1, hash2, shifted;
struct tree *one, *two;
- setup_git_directory();
+ setup_git_directory(the_repository);
if (repo_get_oid(the_repository, av[1], &hash1))
die("cannot parse %s as an object name", av[1]);
diff --git a/t/helper/test-pack-deltas.c b/t/helper/test-pack-deltas.c
index 4981401eaa..c493b75e02 100644
--- a/t/helper/test-pack-deltas.c
+++ b/t/helper/test-pack-deltas.c
@@ -95,7 +95,7 @@ int cmd__pack_deltas(int argc, const char **argv)
if (argc || num_objects < 0)
usage_with_options(usage_str, options);
- setup_git_directory();
+ setup_git_directory(the_repository);
f = hashfd(the_repository->hash_algo, 1, "<stdout>");
write_pack_header(f, num_objects);
diff --git a/t/helper/test-pack-mtimes.c b/t/helper/test-pack-mtimes.c
index 7a8ee1de24..b774056799 100644
--- a/t/helper/test-pack-mtimes.c
+++ b/t/helper/test-pack-mtimes.c
@@ -32,7 +32,7 @@ int cmd__pack_mtimes(int argc, const char **argv)
struct strbuf buf = STRBUF_INIT;
struct packed_git *p;
- setup_git_directory();
+ setup_git_directory(the_repository);
if (argc != 2)
usage(pack_mtimes_usage);
diff --git a/t/helper/test-partial-clone.c b/t/helper/test-partial-clone.c
index d848800749..a7aab426d0 100644
--- a/t/helper/test-partial-clone.c
+++ b/t/helper/test-partial-clone.c
@@ -1,3 +1,5 @@
+#define USE_THE_REPOSITORY_VARIABLE
+
#include "test-tool.h"
#include "hex.h"
#include "repository.h"
@@ -32,7 +34,7 @@ static void object_info(const char *gitdir, const char *oid_hex)
int cmd__partial_clone(int argc, const char **argv)
{
- setup_git_directory();
+ setup_git_directory(the_repository);
if (argc < 4)
die("too few arguments");
diff --git a/t/helper/test-path-walk.c b/t/helper/test-path-walk.c
index fe63002c2b..69676b15a5 100644
--- a/t/helper/test-path-walk.c
+++ b/t/helper/test-path-walk.c
@@ -89,7 +89,7 @@ int cmd__path_walk(int argc, const char **argv)
OPT_END(),
};
- setup_git_directory();
+ setup_git_directory(the_repository);
revs.repo = the_repository;
argc = parse_options(argc, argv, NULL,
diff --git a/t/helper/test-reach.c b/t/helper/test-reach.c
index 3131b54a87..5d86a96c17 100644
--- a/t/helper/test-reach.c
+++ b/t/helper/test-reach.c
@@ -39,7 +39,7 @@ int cmd__reach(int ac, const char **av)
struct strbuf buf = STRBUF_INIT;
struct repository *r = the_repository;
- setup_git_directory();
+ setup_git_directory(the_repository);
if (ac < 2)
exit(1);
diff --git a/t/helper/test-read-cache.c b/t/helper/test-read-cache.c
index 9ae71cefb3..6b08ba8f07 100644
--- a/t/helper/test-read-cache.c
+++ b/t/helper/test-read-cache.c
@@ -19,7 +19,7 @@ int cmd__read_cache(int argc, const char **argv)
if (argc == 2)
cnt = strtol(argv[1], NULL, 0);
- setup_git_directory();
+ setup_git_directory(the_repository);
repo_config(the_repository, git_default_config, NULL);
for (i = 0; i < cnt; i++) {
diff --git a/t/helper/test-read-graph.c b/t/helper/test-read-graph.c
index 6a5f64e473..9f07b9c25a 100644
--- a/t/helper/test-read-graph.c
+++ b/t/helper/test-read-graph.c
@@ -76,7 +76,7 @@ int cmd__read_graph(int argc, const char **argv)
struct odb_source *source;
int ret = 0;
- setup_git_directory();
+ setup_git_directory(the_repository);
source = the_repository->objects->sources;
prepare_repo_settings(the_repository);
diff --git a/t/helper/test-read-midx.c b/t/helper/test-read-midx.c
index 388d29e2b5..790000fb26 100644
--- a/t/helper/test-read-midx.c
+++ b/t/helper/test-read-midx.c
@@ -14,7 +14,7 @@
static struct multi_pack_index *setup_midx(const char *object_dir)
{
struct odb_source *source;
- setup_git_directory();
+ setup_git_directory(the_repository);
source = odb_find_source(the_repository->objects, object_dir);
if (!source)
source = odb_add_to_alternates_memory(the_repository->objects,
diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c
index 74edf2029a..3866d0aca4 100644
--- a/t/helper/test-ref-store.c
+++ b/t/helper/test-ref-store.c
@@ -340,7 +340,7 @@ int cmd__ref_store(int argc UNUSED, const char **argv)
const char *func;
struct command *cmd;
- setup_git_directory();
+ setup_git_directory(the_repository);
argv = get_store(argv + 1, &refs);
diff --git a/t/helper/test-revision-walking.c b/t/helper/test-revision-walking.c
index 071f5bd1e2..70051eeaf8 100644
--- a/t/helper/test-revision-walking.c
+++ b/t/helper/test-revision-walking.c
@@ -56,7 +56,7 @@ int cmd__revision_walking(int argc, const char **argv)
if (argc < 2)
return 1;
- setup_git_directory();
+ setup_git_directory(the_repository);
if (!strcmp(argv[1], "run-twice")) {
printf("1st\n");
diff --git a/t/helper/test-scrap-cache-tree.c b/t/helper/test-scrap-cache-tree.c
index 64fff6e9e3..7b5ce501d9 100644
--- a/t/helper/test-scrap-cache-tree.c
+++ b/t/helper/test-scrap-cache-tree.c
@@ -12,7 +12,7 @@ int cmd__scrap_cache_tree(int ac UNUSED, const char **av UNUSED)
{
struct lock_file index_lock = LOCK_INIT;
- setup_git_directory();
+ setup_git_directory(the_repository);
repo_hold_locked_index(the_repository, &index_lock, LOCK_DIE_ON_ERROR);
if (repo_read_index(the_repository) < 0)
die("unable to read index file");
diff --git a/t/helper/test-serve-v2.c b/t/helper/test-serve-v2.c
index 63a200b8d4..27f3ed8947 100644
--- a/t/helper/test-serve-v2.c
+++ b/t/helper/test-serve-v2.c
@@ -23,7 +23,7 @@ int cmd__serve_v2(int argc, const char **argv)
N_("exit immediately after advertising capabilities")),
OPT_END()
};
- const char *prefix = setup_git_directory();
+ const char *prefix = setup_git_directory(the_repository);
/* ignore all unknown cmdline switches for now */
argc = parse_options(argc, argv, prefix, options, serve_usage,
diff --git a/t/helper/test-submodule-config.c b/t/helper/test-submodule-config.c
index cbe93f2f9e..3f30292179 100644
--- a/t/helper/test-submodule-config.c
+++ b/t/helper/test-submodule-config.c
@@ -34,7 +34,7 @@ int cmd__submodule_config(int argc, const char **argv)
if (my_argc % 2 != 0)
die_usage(argc, argv, "Wrong number of arguments.");
- setup_git_directory();
+ setup_git_directory(the_repository);
while (*arg) {
struct object_id commit_oid;
diff --git a/t/helper/test-submodule-nested-repo-config.c b/t/helper/test-submodule-nested-repo-config.c
index 2710341cd5..7e31d3fe47 100644
--- a/t/helper/test-submodule-nested-repo-config.c
+++ b/t/helper/test-submodule-nested-repo-config.c
@@ -19,7 +19,7 @@ int cmd__submodule_nested_repo_config(int argc, const char **argv)
if (argc < 3)
die_usage(argv, "Wrong number of arguments.");
- setup_git_directory();
+ setup_git_directory(the_repository);
if (repo_submodule_init(&subrepo, the_repository, argv[1], null_oid(the_hash_algo))) {
die_usage(argv, "Submodule not found.");
diff --git a/t/helper/test-submodule.c b/t/helper/test-submodule.c
index 0133852e1e..3c5c4c4a09 100644
--- a/t/helper/test-submodule.c
+++ b/t/helper/test-submodule.c
@@ -99,7 +99,7 @@ static int cmd__submodule_is_active(int argc, const char **argv)
if (argc != 1)
usage_with_options(submodule_is_active_usage, options);
- setup_git_directory();
+ setup_git_directory(the_repository);
return !is_submodule_active(the_repository, argv[0]);
}
@@ -142,7 +142,7 @@ static int cmd__submodule_config_list(int argc, const char **argv)
argc = parse_options(argc, argv, "test-tools", options, usage,
PARSE_OPT_KEEP_ARGV0);
- setup_git_directory();
+ setup_git_directory(the_repository);
if (argc == 2)
return print_config_from_gitmodules(the_repository, argv[1]);
@@ -161,7 +161,7 @@ static int cmd__submodule_config_set(int argc, const char **argv)
argc = parse_options(argc, argv, "test-tools", options, usage,
PARSE_OPT_KEEP_ARGV0);
- setup_git_directory();
+ setup_git_directory(the_repository);
/* Equivalent to ACTION_SET in builtin/config.c */
if (argc == 3) {
@@ -183,7 +183,7 @@ static int cmd__submodule_config_unset(int argc, const char **argv)
NULL
};
- setup_git_directory();
+ setup_git_directory(the_repository);
if (argc == 2) {
if (!is_writing_gitmodules_ok())
@@ -202,7 +202,7 @@ static int cmd__submodule_config_writeable(int argc, const char **argv UNUSED)
"test-tool submodule config-writeable",
NULL
};
- setup_git_directory();
+ setup_git_directory(the_repository);
if (argc == 1)
return is_writing_gitmodules_ok() ? 0 : -1;
diff --git a/t/helper/test-userdiff.c b/t/helper/test-userdiff.c
index aa3a9894d2..fc34c589b3 100644
--- a/t/helper/test-userdiff.c
+++ b/t/helper/test-userdiff.c
@@ -40,7 +40,7 @@ int cmd__userdiff(int argc, const char **argv)
return error("unknown argument %s", argv[1]);
if (want & USERDIFF_DRIVER_TYPE_CUSTOM) {
- setup_git_directory();
+ setup_git_directory(the_repository);
repo_config(the_repository, cmd__userdiff_config, NULL);
}
diff --git a/t/helper/test-write-cache.c b/t/helper/test-write-cache.c
index b37dd2c5d6..98e1477c98 100644
--- a/t/helper/test-write-cache.c
+++ b/t/helper/test-write-cache.c
@@ -12,7 +12,7 @@ int cmd__write_cache(int argc, const char **argv)
int i, cnt = 1;
if (argc == 2)
cnt = strtol(argv[1], NULL, 0);
- setup_git_directory();
+ setup_git_directory(the_repository);
repo_read_index(the_repository);
for (i = 0; i < cnt; i++) {
repo_hold_locked_index(the_repository, &index_lock,
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 14/18] setup: stop using `the_repository` in `upgrade_repository_format()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (12 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 13/18] setup: stop using `the_repository` in `setup_git_directory()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 15/18] setup: stop using `the_repository` in `check_repository_format()` Patrick Steinhardt
` (4 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `upgrade_repository_format()` and instead
accept the repository as a parameter. The injection of `the_repository`
is thus bumped one level higher, where callers now pass it in
explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
list-objects-filter-options.c | 2 +-
repository.h | 2 +-
setup.c | 6 +++---
worktree.c | 2 +-
4 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/list-objects-filter-options.c b/list-objects-filter-options.c
index cef67e5919..bc5d98f9e6 100644
--- a/list-objects-filter-options.c
+++ b/list-objects-filter-options.c
@@ -378,7 +378,7 @@ void partial_clone_register(
*/
return;
} else {
- if (upgrade_repository_format(1) < 0)
+ if (upgrade_repository_format(the_repository, 1) < 0)
die(_("unable to upgrade repository format to support partial clone"));
/* Add promisor config for the remote */
diff --git a/repository.h b/repository.h
index 7ae3d34484..bb83d03bbf 100644
--- a/repository.h
+++ b/repository.h
@@ -271,6 +271,6 @@ void repo_update_index_if_able(struct repository *, struct lock_file *);
* Return 1 if upgrade repository format to target_version succeeded,
* 0 if no upgrade is necessary, and -1 when upgrade is not possible.
*/
-int upgrade_repository_format(int target_version);
+int upgrade_repository_format(struct repository *repo, int target_version);
#endif /* REPOSITORY_H */
diff --git a/setup.c b/setup.c
index da0576d28a..6dbd096f20 100644
--- a/setup.c
+++ b/setup.c
@@ -808,7 +808,7 @@ static int check_repository_format_gently(struct repository *repo,
return 0;
}
-int upgrade_repository_format(int target_version)
+int upgrade_repository_format(struct repository *repo, int target_version)
{
struct strbuf sb = STRBUF_INIT;
struct strbuf err = STRBUF_INIT;
@@ -816,7 +816,7 @@ int upgrade_repository_format(int target_version)
struct repository_format repo_fmt = REPOSITORY_FORMAT_INIT;
int ret;
- repo_common_path_append(the_repository, &sb, "config");
+ repo_common_path_append(repo, &sb, "config");
read_repository_format(&repo_fmt, sb.buf);
strbuf_release(&sb);
@@ -838,7 +838,7 @@ int upgrade_repository_format(int target_version)
}
strbuf_addf(&repo_version, "%d", target_version);
- repo_config_set(the_repository, "core.repositoryformatversion", repo_version.buf);
+ repo_config_set(repo, "core.repositoryformatversion", repo_version.buf);
ret = 1;
diff --git a/worktree.c b/worktree.c
index 56732f8f33..8ca0a172c6 100644
--- a/worktree.c
+++ b/worktree.c
@@ -1104,7 +1104,7 @@ void write_worktree_linking_files(const char *dotgit, const char *gitdir,
strbuf_realpath(&repo, repo.buf, 1);
if (use_relative_paths && !the_repository->repository_format_relative_worktrees) {
- if (upgrade_repository_format(1) < 0)
+ if (upgrade_repository_format(the_repository, 1) < 0)
die(_("unable to upgrade repository format to support relative worktrees"));
if (repo_config_set_gently(the_repository, "extensions.relativeWorktrees", "true"))
die(_("unable to set extensions.relativeWorktrees setting"));
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 15/18] setup: stop using `the_repository` in `check_repository_format()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (13 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 14/18] setup: stop using `the_repository` in `upgrade_repository_format()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-04-18 1:23 ` Elijah Newren
2026-03-30 13:17 ` [PATCH 16/18] setup: stop using `the_repository` in `initialize_repository_version()` Patrick Steinhardt
` (3 subsequent siblings)
18 siblings, 1 reply; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `check_repository_format()` and instead
accept the repository as a parameter. The injection of `the_repository`
is thus bumped one level higher, where callers now pass it in
explicitly.
Furthermore, the function is never used outside "setup.c". Drop its
declaration in "setup.h" and make it static. Note that this requires us
to reorder the function.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
setup.c | 58 +++++++++++++++++++++++++++++++++-------------------------
setup.h | 10 ----------
2 files changed, 33 insertions(+), 35 deletions(-)
diff --git a/setup.c b/setup.c
index 6dbd096f20..c32d6e96bb 100644
--- a/setup.c
+++ b/setup.c
@@ -1755,6 +1755,37 @@ enum discovery_result discover_git_directory_reason(struct strbuf *commondir,
return result;
}
+/*
+ * Check the repository format version in the path found in repo_get_git_dir(the_repository),
+ * and die if it is a version we don't understand. Generally one would
+ * set_git_dir() before calling this, and use it only for "are we in a valid
+ * repo?".
+ *
+ * If successful and fmt is not NULL, fill fmt with data.
+ */
+static void check_repository_format(struct repository *repo, struct repository_format *fmt)
+{
+ struct repository_format repo_fmt = REPOSITORY_FORMAT_INIT;
+ if (!fmt)
+ fmt = &repo_fmt;
+ check_repository_format_gently(repo, repo_get_git_dir(repo), fmt, NULL);
+ startup_info->have_repository = 1;
+ repo_set_hash_algo(repo, fmt->hash_algo);
+ repo_set_compat_hash_algo(repo, fmt->compat_hash_algo);
+ repo_set_ref_storage_format(repo,
+ fmt->ref_storage_format,
+ fmt->ref_storage_payload);
+ repo->repository_format_worktree_config =
+ fmt->worktree_config;
+ repo->repository_format_submodule_path_cfg =
+ fmt->submodule_path_cfg;
+ repo->repository_format_relative_worktrees =
+ fmt->relative_worktrees;
+ repo->repository_format_partial_clone =
+ xstrdup_or_null(fmt->partial_clone);
+ clear_repository_format(&repo_fmt);
+}
+
const char *enter_repo(struct repository *repo, const char *path, unsigned flags)
{
static struct strbuf validated_path = STRBUF_INIT;
@@ -1829,7 +1860,7 @@ const char *enter_repo(struct repository *repo, const char *path, unsigned flags
if (is_git_directory(".")) {
set_git_dir(repo, ".", 0);
- check_repository_format(NULL);
+ check_repository_format(repo, NULL);
return path;
}
@@ -2104,29 +2135,6 @@ int git_config_perm(const char *var, const char *value)
return -(i & 0666);
}
-void check_repository_format(struct repository_format *fmt)
-{
- struct repository_format repo_fmt = REPOSITORY_FORMAT_INIT;
- if (!fmt)
- fmt = &repo_fmt;
- check_repository_format_gently(the_repository, repo_get_git_dir(the_repository), fmt, NULL);
- startup_info->have_repository = 1;
- repo_set_hash_algo(the_repository, fmt->hash_algo);
- repo_set_compat_hash_algo(the_repository, fmt->compat_hash_algo);
- repo_set_ref_storage_format(the_repository,
- fmt->ref_storage_format,
- fmt->ref_storage_payload);
- the_repository->repository_format_worktree_config =
- fmt->worktree_config;
- the_repository->repository_format_submodule_path_cfg =
- fmt->submodule_path_cfg;
- the_repository->repository_format_relative_worktrees =
- fmt->relative_worktrees;
- the_repository->repository_format_partial_clone =
- xstrdup_or_null(fmt->partial_clone);
- clear_repository_format(&repo_fmt);
-}
-
/*
* Returns the "prefix", a path to the current working directory
* relative to the work tree root, or NULL, if the current working
@@ -2801,7 +2809,7 @@ int init_db(const char *git_dir, const char *real_git_dir,
* config file, so this will not fail. What we are catching
* is an attempt to reinitialize new repository with an old tool.
*/
- check_repository_format(&repo_fmt);
+ check_repository_format(the_repository, &repo_fmt);
repository_format_configure(the_repository, &repo_fmt, hash, ref_storage_format);
diff --git a/setup.h b/setup.h
index b779661ce7..a820041af0 100644
--- a/setup.h
+++ b/setup.h
@@ -221,16 +221,6 @@ void clear_repository_format(struct repository_format *format);
int verify_repository_format(const struct repository_format *format,
struct strbuf *err);
-/*
- * Check the repository format version in the path found in repo_get_git_dir(the_repository),
- * and die if it is a version we don't understand. Generally one would
- * set_git_dir() before calling this, and use it only for "are we in a valid
- * repo?".
- *
- * If successful and fmt is not NULL, fill fmt with data.
- */
-void check_repository_format(struct repository_format *fmt);
-
const char *get_template_dir(const char *option_template);
#define INIT_DB_QUIET (1 << 0)
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH 15/18] setup: stop using `the_repository` in `check_repository_format()`
2026-03-30 13:17 ` [PATCH 15/18] setup: stop using `the_repository` in `check_repository_format()` Patrick Steinhardt
@ 2026-04-18 1:23 ` Elijah Newren
2026-04-20 7:06 ` Patrick Steinhardt
0 siblings, 1 reply; 32+ messages in thread
From: Elijah Newren @ 2026-04-18 1:23 UTC (permalink / raw)
To: Patrick Steinhardt; +Cc: git
On Mon, Mar 30, 2026 at 6:19 AM Patrick Steinhardt <ps@pks.im> wrote:
>
> Stop using `the_repository` in `check_repository_format()` and instead
> accept the repository as a parameter. The injection of `the_repository`
> is thus bumped one level higher, where callers now pass it in
> explicitly.
>
> Furthermore, the function is never used outside "setup.c". Drop its
> declaration in "setup.h" and make it static. Note that this requires us
> to reorder the function.
>
> Signed-off-by: Patrick Steinhardt <ps@pks.im>
> ---
> setup.c | 58 +++++++++++++++++++++++++++++++++-------------------------
> setup.h | 10 ----------
> 2 files changed, 33 insertions(+), 35 deletions(-)
>
> diff --git a/setup.c b/setup.c
> index 6dbd096f20..c32d6e96bb 100644
> --- a/setup.c
> +++ b/setup.c
> @@ -1755,6 +1755,37 @@ enum discovery_result discover_git_directory_reason(struct strbuf *commondir,
> return result;
> }
>
> +/*
> + * Check the repository format version in the path found in repo_get_git_dir(the_repository),
Can we make the code comment match the code below, i.e.
the_repository -> repo
?
> + * and die if it is a version we don't understand. Generally one would
> + * set_git_dir() before calling this, and use it only for "are we in a valid
> + * repo?".
> + *
> + * If successful and fmt is not NULL, fill fmt with data.
> + */
> +static void check_repository_format(struct repository *repo, struct repository_format *fmt)
> +{
> + struct repository_format repo_fmt = REPOSITORY_FORMAT_INIT;
> + if (!fmt)
> + fmt = &repo_fmt;
> + check_repository_format_gently(repo, repo_get_git_dir(repo), fmt, NULL);
^ permalink raw reply [flat|nested] 32+ messages in thread* Re: [PATCH 15/18] setup: stop using `the_repository` in `check_repository_format()`
2026-04-18 1:23 ` Elijah Newren
@ 2026-04-20 7:06 ` Patrick Steinhardt
0 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-04-20 7:06 UTC (permalink / raw)
To: Elijah Newren; +Cc: git
On Fri, Apr 17, 2026 at 06:23:13PM -0700, Elijah Newren wrote:
> On Mon, Mar 30, 2026 at 6:19 AM Patrick Steinhardt <ps@pks.im> wrote:
> > diff --git a/setup.c b/setup.c
> > index 6dbd096f20..c32d6e96bb 100644
> > --- a/setup.c
> > +++ b/setup.c
> > @@ -1755,6 +1755,37 @@ enum discovery_result discover_git_directory_reason(struct strbuf *commondir,
> > return result;
> > }
> >
> > +/*
> > + * Check the repository format version in the path found in repo_get_git_dir(the_repository),
>
> Can we make the code comment match the code below, i.e.
> the_repository -> repo
> ?
Good eyes, will adapt.
Patrick
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH 16/18] setup: stop using `the_repository` in `initialize_repository_version()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (14 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 15/18] setup: stop using `the_repository` in `check_repository_format()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 17/18] setup: stop using `the_repository` in `create_reference_database()` Patrick Steinhardt
` (2 subsequent siblings)
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `initialize_repository_version()` and
instead accept the repository as a parameter. The injection of
`the_repository` is thus bumped one level higher, where callers now pass
it in explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/clone.c | 4 ++--
refs.c | 2 +-
setup.c | 29 +++++++++++++++--------------
setup.h | 3 ++-
4 files changed, 20 insertions(+), 18 deletions(-)
diff --git a/builtin/clone.c b/builtin/clone.c
index 16cd7b029b..663ef0b524 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -1227,7 +1227,7 @@ int cmd_clone(int argc,
*
* This is sufficient for Git commands to discover the Git directory.
*/
- initialize_repository_version(GIT_HASH_UNKNOWN,
+ initialize_repository_version(the_repository, GIT_HASH_UNKNOWN,
the_repository->ref_storage_format, 1);
refs_create_refdir_stubs(the_repository, git_dir, NULL);
@@ -1440,7 +1440,7 @@ int cmd_clone(int argc,
* ours to the same thing.
*/
hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport));
- initialize_repository_version(hash_algo, the_repository->ref_storage_format, 1);
+ initialize_repository_version(the_repository, hash_algo, the_repository->ref_storage_format, 1);
repo_set_hash_algo(the_repository, hash_algo);
create_reference_database(NULL, 1);
diff --git a/refs.c b/refs.c
index e66cf4861d..6a49ef8a1c 100644
--- a/refs.c
+++ b/refs.c
@@ -3450,7 +3450,7 @@ int repo_migrate_ref_storage_format(struct repository *repo,
* repository format so that clients will use the new ref store.
* We also need to swap out the repository's main ref store.
*/
- initialize_repository_version(hash_algo_by_ptr(repo->hash_algo), format, 1);
+ initialize_repository_version(the_repository, hash_algo_by_ptr(repo->hash_algo), format, 1);
/*
* Unset the old ref store and release it. `get_main_ref_store()` will
diff --git a/setup.c b/setup.c
index c32d6e96bb..1570749b4a 100644
--- a/setup.c
+++ b/setup.c
@@ -2382,7 +2382,8 @@ static int needs_work_tree_config(const char *git_dir, const char *work_tree)
return 1;
}
-void initialize_repository_version(int hash_algo,
+void initialize_repository_version(struct repository *repo,
+ int hash_algo,
enum ref_storage_format ref_storage_format,
int reinit)
{
@@ -2399,35 +2400,35 @@ void initialize_repository_version(int hash_algo,
*/
if (hash_algo != GIT_HASH_SHA1_LEGACY ||
ref_storage_format != REF_STORAGE_FORMAT_FILES ||
- the_repository->ref_storage_payload)
+ repo->ref_storage_payload)
target_version = GIT_REPO_VERSION_READ;
if (hash_algo != GIT_HASH_SHA1_LEGACY && hash_algo != GIT_HASH_UNKNOWN)
- repo_config_set(the_repository, "extensions.objectformat",
+ repo_config_set(repo, "extensions.objectformat",
hash_algos[hash_algo].name);
else if (reinit)
- repo_config_set_gently(the_repository, "extensions.objectformat", NULL);
+ repo_config_set_gently(repo, "extensions.objectformat", NULL);
- if (the_repository->ref_storage_payload) {
+ if (repo->ref_storage_payload) {
struct strbuf ref_uri = STRBUF_INIT;
strbuf_addf(&ref_uri, "%s://%s",
ref_storage_format_to_name(ref_storage_format),
- the_repository->ref_storage_payload);
- repo_config_set(the_repository, "extensions.refstorage", ref_uri.buf);
+ repo->ref_storage_payload);
+ repo_config_set(repo, "extensions.refstorage", ref_uri.buf);
strbuf_release(&ref_uri);
} else if (ref_storage_format != REF_STORAGE_FORMAT_FILES) {
- repo_config_set(the_repository, "extensions.refstorage",
+ repo_config_set(repo, "extensions.refstorage",
ref_storage_format_to_name(ref_storage_format));
} else if (reinit) {
- repo_config_set_gently(the_repository, "extensions.refstorage", NULL);
+ repo_config_set_gently(repo, "extensions.refstorage", NULL);
}
if (reinit) {
struct strbuf config = STRBUF_INIT;
struct repository_format repo_fmt = REPOSITORY_FORMAT_INIT;
- repo_common_path_append(the_repository, &config, "config");
+ repo_common_path_append(repo, &config, "config");
read_repository_format(&repo_fmt, config.buf);
if (repo_fmt.v1_only_extensions.nr)
@@ -2437,17 +2438,17 @@ void initialize_repository_version(int hash_algo,
clear_repository_format(&repo_fmt);
}
- repo_config_get_bool(the_repository, "init.defaultSubmodulePathConfig",
+ repo_config_get_bool(repo, "init.defaultSubmodulePathConfig",
&default_submodule_path_config);
if (default_submodule_path_config) {
/* extensions.submodulepathconfig requires at least version 1 */
if (target_version == 0)
target_version = 1;
- repo_config_set(the_repository, "extensions.submodulepathconfig", "true");
+ repo_config_set(repo, "extensions.submodulepathconfig", "true");
}
strbuf_addf(&repo_version, "%d", target_version);
- repo_config_set(the_repository, "core.repositoryformatversion", repo_version.buf);
+ repo_config_set(repo, "core.repositoryformatversion", repo_version.buf);
strbuf_release(&repo_version);
}
@@ -2548,7 +2549,7 @@ static int create_default_files(struct repository *repo,
adjust_shared_perm(repo, repo_get_git_dir(repo));
}
- initialize_repository_version(fmt->hash_algo, fmt->ref_storage_format, reinit);
+ initialize_repository_version(repo, fmt->hash_algo, fmt->ref_storage_format, reinit);
/* Check filemode trustability */
repo_git_path_replace(repo, &path, "config");
diff --git a/setup.h b/setup.h
index a820041af0..c33b675ccf 100644
--- a/setup.h
+++ b/setup.h
@@ -232,7 +232,8 @@ int init_db(const char *git_dir, const char *real_git_dir,
enum ref_storage_format ref_storage_format,
const char *initial_branch, int init_shared_repository,
unsigned int flags);
-void initialize_repository_version(int hash_algo,
+void initialize_repository_version(struct repository *repo,
+ int hash_algo,
enum ref_storage_format ref_storage_format,
int reinit);
void create_reference_database(const char *initial_branch, int quiet);
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 17/18] setup: stop using `the_repository` in `create_reference_database()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (15 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 16/18] setup: stop using `the_repository` in `initialize_repository_version()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-03-30 13:17 ` [PATCH 18/18] setup: stop using `the_repository` in `init_db()` Patrick Steinhardt
2026-04-09 13:05 ` [PATCH 00/18] setup: drop uses of `the_repository` Karthik Nayak
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `create_reference_database()` and instead
accept the repository as a parameter. The injection of `the_repository`
is thus bumped one level higher, where callers now pass it in
explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/clone.c | 2 +-
setup.c | 13 +++++++------
setup.h | 2 +-
3 files changed, 9 insertions(+), 8 deletions(-)
diff --git a/builtin/clone.c b/builtin/clone.c
index 663ef0b524..d864022214 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -1442,7 +1442,7 @@ int cmd_clone(int argc,
hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport));
initialize_repository_version(the_repository, hash_algo, the_repository->ref_storage_format, 1);
repo_set_hash_algo(the_repository, hash_algo);
- create_reference_database(NULL, 1);
+ create_reference_database(the_repository, NULL, 1);
/*
* Before fetching from the remote, download and install bundle
diff --git a/setup.c b/setup.c
index 1570749b4a..efac2dd7b5 100644
--- a/setup.c
+++ b/setup.c
@@ -2465,13 +2465,14 @@ static int is_reinit(struct repository *repo)
return ret;
}
-void create_reference_database(const char *initial_branch, int quiet)
+void create_reference_database(struct repository *repo,
+ const char *initial_branch, int quiet)
{
struct strbuf err = STRBUF_INIT;
char *to_free = NULL;
- int reinit = is_reinit(the_repository);
+ int reinit = is_reinit(repo);
- if (ref_store_create_on_disk(get_main_ref_store(the_repository), 0, &err))
+ if (ref_store_create_on_disk(get_main_ref_store(repo), 0, &err))
die("failed to set up refs db: %s", err.buf);
/*
@@ -2483,14 +2484,14 @@ void create_reference_database(const char *initial_branch, int quiet)
if (!initial_branch)
initial_branch = to_free =
- repo_default_branch_name(the_repository, quiet);
+ repo_default_branch_name(repo, quiet);
ref = xstrfmt("refs/heads/%s", initial_branch);
if (check_refname_format(ref, 0) < 0)
die(_("invalid initial branch name: '%s'"),
initial_branch);
- if (refs_update_symref(get_main_ref_store(the_repository), "HEAD", ref, NULL) < 0)
+ if (refs_update_symref(get_main_ref_store(repo), "HEAD", ref, NULL) < 0)
exit(1);
free(ref);
}
@@ -2827,7 +2828,7 @@ int init_db(const char *git_dir, const char *real_git_dir,
&repo_fmt, init_shared_repository);
if (!(flags & INIT_DB_SKIP_REFDB))
- create_reference_database(initial_branch, flags & INIT_DB_QUIET);
+ create_reference_database(the_repository, initial_branch, flags & INIT_DB_QUIET);
create_object_directory(the_repository);
if (repo_settings_get_shared_repository(the_repository)) {
diff --git a/setup.h b/setup.h
index c33b675ccf..21737e9bd6 100644
--- a/setup.h
+++ b/setup.h
@@ -236,7 +236,7 @@ void initialize_repository_version(struct repository *repo,
int hash_algo,
enum ref_storage_format ref_storage_format,
int reinit);
-void create_reference_database(const char *initial_branch, int quiet);
+void create_reference_database(struct repository *repo, const char *initial_branch, int quiet);
/*
* NOTE NOTE NOTE!!
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH 18/18] setup: stop using `the_repository` in `init_db()`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (16 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 17/18] setup: stop using `the_repository` in `create_reference_database()` Patrick Steinhardt
@ 2026-03-30 13:17 ` Patrick Steinhardt
2026-04-09 13:05 ` [PATCH 00/18] setup: drop uses of `the_repository` Karthik Nayak
18 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-03-30 13:17 UTC (permalink / raw)
To: git
Stop using `the_repository` in `init_db()` and instead accept
the repository as a parameter. The injection of `the_repository` is thus
bumped one level higher, where callers now pass it in explicitly.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
---
builtin/clone.c | 2 +-
builtin/init-db.c | 2 +-
setup.c | 43 ++++++++++++++++++++++---------------------
setup.h | 3 ++-
4 files changed, 26 insertions(+), 24 deletions(-)
diff --git a/builtin/clone.c b/builtin/clone.c
index d864022214..bc35a3c0b1 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -1184,7 +1184,7 @@ int cmd_clone(int argc,
* repository, and reference backends may persist that information into
* their on-disk data structures.
*/
- init_db(git_dir, real_git_dir, option_template, GIT_HASH_UNKNOWN,
+ init_db(the_repository, git_dir, real_git_dir, option_template, GIT_HASH_UNKNOWN,
ref_storage_format, NULL,
do_not_override_repo_unix_permissions, INIT_DB_QUIET | INIT_DB_SKIP_REFDB);
diff --git a/builtin/init-db.c b/builtin/init-db.c
index e626b0d8b7..c55517ad94 100644
--- a/builtin/init-db.c
+++ b/builtin/init-db.c
@@ -252,7 +252,7 @@ int cmd_init_db(int argc,
}
flags |= INIT_DB_EXIST_OK;
- ret = init_db(git_dir, real_git_dir, template_dir, hash_algo,
+ ret = init_db(the_repository, git_dir, real_git_dir, template_dir, hash_algo,
ref_storage_format, initial_branch,
init_shared_repository, flags);
diff --git a/setup.c b/setup.c
index efac2dd7b5..67bede8b9d 100644
--- a/setup.c
+++ b/setup.c
@@ -2775,7 +2775,8 @@ static void repository_format_configure(struct repository *repo,
repo_fmt->ref_storage_payload);
}
-int init_db(const char *git_dir, const char *real_git_dir,
+int init_db(struct repository *repo,
+ const char *git_dir, const char *real_git_dir,
const char *template_dir, int hash,
enum ref_storage_format ref_storage_format,
const char *initial_branch,
@@ -2795,13 +2796,13 @@ int init_db(const char *git_dir, const char *real_git_dir,
if (!exist_ok && !stat(real_git_dir, &st))
die(_("%s already exists"), real_git_dir);
- set_git_dir(the_repository, real_git_dir, 1);
- git_dir = repo_get_git_dir(the_repository);
+ set_git_dir(repo, real_git_dir, 1);
+ git_dir = repo_get_git_dir(repo);
separate_git_dir(git_dir, original_git_dir);
}
else {
- set_git_dir(the_repository, git_dir, 1);
- git_dir = repo_get_git_dir(the_repository);
+ set_git_dir(repo, git_dir, 1);
+ git_dir = repo_get_git_dir(repo);
}
startup_info->have_repository = 1;
@@ -2811,27 +2812,27 @@ int init_db(const char *git_dir, const char *real_git_dir,
* config file, so this will not fail. What we are catching
* is an attempt to reinitialize new repository with an old tool.
*/
- check_repository_format(the_repository, &repo_fmt);
+ check_repository_format(repo, &repo_fmt);
- repository_format_configure(the_repository, &repo_fmt, hash, ref_storage_format);
+ repository_format_configure(repo, &repo_fmt, hash, ref_storage_format);
/*
* Ensure `core.hidedotfiles` is processed. This must happen after we
* have set up the repository format such that we can evaluate
* includeIf conditions correctly in the case of re-initialization.
*/
- repo_config(the_repository, git_default_core_config, NULL);
+ repo_config(repo, git_default_core_config, NULL);
- safe_create_dir(the_repository, git_dir, 0);
+ safe_create_dir(repo, git_dir, 0);
- reinit = create_default_files(the_repository, template_dir, original_git_dir,
+ reinit = create_default_files(repo, template_dir, original_git_dir,
&repo_fmt, init_shared_repository);
if (!(flags & INIT_DB_SKIP_REFDB))
- create_reference_database(the_repository, initial_branch, flags & INIT_DB_QUIET);
- create_object_directory(the_repository);
+ create_reference_database(repo, initial_branch, flags & INIT_DB_QUIET);
+ create_object_directory(repo);
- if (repo_settings_get_shared_repository(the_repository)) {
+ if (repo_settings_get_shared_repository(repo)) {
char buf[10];
/* We do not spell "group" and such, so that
* the configuration can be read by older version
@@ -2839,29 +2840,29 @@ int init_db(const char *git_dir, const char *real_git_dir,
* and compatibility values for PERM_GROUP and
* PERM_EVERYBODY.
*/
- if (repo_settings_get_shared_repository(the_repository) < 0)
+ if (repo_settings_get_shared_repository(repo) < 0)
/* force to the mode value */
- xsnprintf(buf, sizeof(buf), "0%o", -repo_settings_get_shared_repository(the_repository));
- else if (repo_settings_get_shared_repository(the_repository) == PERM_GROUP)
+ xsnprintf(buf, sizeof(buf), "0%o", -repo_settings_get_shared_repository(repo));
+ else if (repo_settings_get_shared_repository(repo) == PERM_GROUP)
xsnprintf(buf, sizeof(buf), "%d", OLD_PERM_GROUP);
- else if (repo_settings_get_shared_repository(the_repository) == PERM_EVERYBODY)
+ else if (repo_settings_get_shared_repository(repo) == PERM_EVERYBODY)
xsnprintf(buf, sizeof(buf), "%d", OLD_PERM_EVERYBODY);
else
BUG("invalid value for shared_repository");
- repo_config_set(the_repository, "core.sharedrepository", buf);
- repo_config_set(the_repository, "receive.denyNonFastforwards", "true");
+ repo_config_set(repo, "core.sharedrepository", buf);
+ repo_config_set(repo, "receive.denyNonFastforwards", "true");
}
if (!(flags & INIT_DB_QUIET)) {
int len = strlen(git_dir);
if (reinit)
- printf(repo_settings_get_shared_repository(the_repository)
+ printf(repo_settings_get_shared_repository(repo)
? _("Reinitialized existing shared Git repository in %s%s\n")
: _("Reinitialized existing Git repository in %s%s\n"),
git_dir, len && git_dir[len-1] != '/' ? "/" : "");
else
- printf(repo_settings_get_shared_repository(the_repository)
+ printf(repo_settings_get_shared_repository(repo)
? _("Initialized empty shared Git repository in %s%s\n")
: _("Initialized empty Git repository in %s%s\n"),
git_dir, len && git_dir[len-1] != '/' ? "/" : "");
diff --git a/setup.h b/setup.h
index 21737e9bd6..9409326fe4 100644
--- a/setup.h
+++ b/setup.h
@@ -227,7 +227,8 @@ const char *get_template_dir(const char *option_template);
#define INIT_DB_EXIST_OK (1 << 1)
#define INIT_DB_SKIP_REFDB (1 << 2)
-int init_db(const char *git_dir, const char *real_git_dir,
+int init_db(struct repository *repo,
+ const char *git_dir, const char *real_git_dir,
const char *template_dir, int hash_algo,
enum ref_storage_format ref_storage_format,
const char *initial_branch, int init_shared_repository,
--
2.53.0.1185.g05d4b7b318.dirty
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH 00/18] setup: drop uses of `the_repository`
2026-03-30 13:17 [PATCH 00/18] setup: drop uses of `the_repository` Patrick Steinhardt
` (17 preceding siblings ...)
2026-03-30 13:17 ` [PATCH 18/18] setup: stop using `the_repository` in `init_db()` Patrick Steinhardt
@ 2026-04-09 13:05 ` Karthik Nayak
2026-04-13 5:48 ` Patrick Steinhardt
18 siblings, 1 reply; 32+ messages in thread
From: Karthik Nayak @ 2026-04-09 13:05 UTC (permalink / raw)
To: Patrick Steinhardt, git
[-- Attachment #1: Type: text/plain, Size: 1683 bytes --]
Patrick Steinhardt <ps@pks.im> writes:
> Hi,
>
> I've had enough of "setup.c" and its complexities, so I finally decided
> to take the bullet and start refactoring this subsystem. This here is
> the first out of the following three steps:
>
> 1. Drop all uses of `the_repository`. This doesn't yet allow us to get
> rid of `USE_THE_REPOSITORY_VARIABLE`.
>
> 2. Convert a couple of global variables and drop
> `is_bare_repository_cfg`, which then allows us to drop
> `USE_THE_REPOSITORY_VARIABLE`.
>
> 3. Refactor the subsystem a bit so that we stop intermixing repository
> discovery and repository initialization. This is my original
> motivation as I want to get rid of `odb_prepare_alternates()`, but
> due to the way we initialize the repository it has proven to be
> extremely tedious.
>
> Most of the patches in this series here are rather mechanical. There's
> only a handful of patches that warrant more attention:
>
> - 2/18: setup: stop using `the_repository` in `is_inside_worktree()`
> - 3/18: setup: stop using `the_repository` in `is_inside_git_dir()`
> - 9/18: setup: stop using `the_repository` in `setup_work_tree()`
> - 10/18: setup: stop using `the_repository` in `set_git_work_tree()`
>
> Those patches don't only mechanical move stuff around, but also change
> some logic to make it work.
>
> The series is based on 5361983c07 (The 22nd batch, 2026-03-27). There is
> a single merge commit with "seen", but it's trivial to resolve.
>
The series looks good to me as is, like mentioned most of the patches
were fairly straight forward where we simply inject the repo variable
into the function. Thanks
[snip]
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 690 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread* Re: [PATCH 00/18] setup: drop uses of `the_repository`
2026-04-09 13:05 ` [PATCH 00/18] setup: drop uses of `the_repository` Karthik Nayak
@ 2026-04-13 5:48 ` Patrick Steinhardt
0 siblings, 0 replies; 32+ messages in thread
From: Patrick Steinhardt @ 2026-04-13 5:48 UTC (permalink / raw)
To: Karthik Nayak; +Cc: git
On Thu, Apr 09, 2026 at 09:05:21AM -0400, Karthik Nayak wrote:
> Patrick Steinhardt <ps@pks.im> writes:
>
> > Hi,
> >
> > I've had enough of "setup.c" and its complexities, so I finally decided
> > to take the bullet and start refactoring this subsystem. This here is
> > the first out of the following three steps:
> >
> > 1. Drop all uses of `the_repository`. This doesn't yet allow us to get
> > rid of `USE_THE_REPOSITORY_VARIABLE`.
> >
> > 2. Convert a couple of global variables and drop
> > `is_bare_repository_cfg`, which then allows us to drop
> > `USE_THE_REPOSITORY_VARIABLE`.
> >
> > 3. Refactor the subsystem a bit so that we stop intermixing repository
> > discovery and repository initialization. This is my original
> > motivation as I want to get rid of `odb_prepare_alternates()`, but
> > due to the way we initialize the repository it has proven to be
> > extremely tedious.
> >
> > Most of the patches in this series here are rather mechanical. There's
> > only a handful of patches that warrant more attention:
> >
> > - 2/18: setup: stop using `the_repository` in `is_inside_worktree()`
> > - 3/18: setup: stop using `the_repository` in `is_inside_git_dir()`
> > - 9/18: setup: stop using `the_repository` in `setup_work_tree()`
> > - 10/18: setup: stop using `the_repository` in `set_git_work_tree()`
> >
> > Those patches don't only mechanical move stuff around, but also change
> > some logic to make it work.
> >
> > The series is based on 5361983c07 (The 22nd batch, 2026-03-27). There is
> > a single merge commit with "seen", but it's trivial to resolve.
> >
>
> The series looks good to me as is, like mentioned most of the patches
> were fairly straight forward where we simply inject the repo variable
> into the function. Thanks
Thanks!
Patrick
^ permalink raw reply [flat|nested] 32+ messages in thread