git/list[1] front-page[2] threads[3] people[4] search[5] about
 

[PATCH v11 0/5] fetch: avoid fetching every branch of a new remote in a shallow repo

From
Harald Nordgren via GitGitGadget <gitgitgadget@gmail.com>
Date
Oct 25, 2026, 20:25 UTC
Message-ID
<pull.2412.v11.git.git.1792959921.gitgitgadget@gmail.com>
In-Reply-To
<pull.2412.git.git.1789829246437.gitgitgadget@gmail.com>
Avoid fetching every branch of a new remote in a shallow repo.
Changes in v11:
 * remote_find_tracking() now falls back to remote.<name>.refmap when
   remote.<name>.fetch doesn't match. Negative refspecs in fetch still
   exclude refs, and both cases have tests
 * The helpers write straight into a strvec, take the output parameter last
   and the remote as const
 * The followRemoteHEAD lookup is done once, not duplicated in two branches
 * Clearer commit messages and docs: a working example plus a reference to
   49ca2fba39, the goal stated first, an incorrect "used to die" claim
   dropped, and an explanation of why a refmap turns on the inference
 * use_limited_fetch is a bool
Changes in v10:
 * Resolve merge conflict after master integrated
   ch/fetch-followremotehead-lazy-validation.
Changes in v9:
 * Moved the do_fetch() if/else-if/else split out of the preliminary
   helper-extraction commit and into the refmap-inference commit that needs
   it. Preliminary commit is now a simpler refactor.
Changes in v8:
 * Split into a preliminary collect_upstream_from_remote() helper commit
   plus a simplified refmap-inference commit.
 * Fixed a regression that could drop the current branch's @{upstream} when
   remote.<name>.fetch was narrowed.
 * Threaded struct repository * through instead of hardcoding
   the_repository.
 * Minor naming and comment cleanups.
Changes in v7:
 * Fixed fatal: --refmap option is only meaningful with command-line
   refspec(s) firing just from configuring remote.<name>.refmap alone, with
   nothing else to fetch.
 * When both remote.<name>.fetch and remote.<name>.refmap are configured, a
   refspec-less fetch follows .fetch as usual, .refmap only remaps something
   already being fetched by name. Added tests.
Changes in v6:
 * Remove leftover reference to deleted default-branch logic in commit
   message.
Changes in v5:
 * Renumber test file from t5585 to t5586.
Changes in v4:
 * Removed the automatic default-branch fetch. A fresh remote fetches
   nothing until you track a branch explicitly.
 * Fixed fetch report showing "new ref HEAD" instead of "new branch "
 * Reworded remote..refmap docs and commit message.
Changes in v3:
 * Replace the special ":"/"+:" fetch refspec with remote.<name>.refmap,
   reusing git's existing --refmap mechanism instead of inventing new
   refspec syntax.
 * Split the change into 4 commits.
Changes in v2:
 * Replaced the opt-in fetch.shallow config entirely with a new special
   fetch refspec (+:) that git remote add now defaults new remotes to in a
   shallow repository. The new refspec fetches whichever branches any local
   branch tracks at that remote, plus the remote's default branch.
Harald Nordgren (5):
  fetch: add remote.<name>.refmap
  fetch: extract collect_upstream_from_remote() helper
  fetch: infer branches to fetch from a refmap-only remote
  remote: add "git remote add --limited-fetch"
  remote: default to --limited-fetch in a shallow repository
 Documentation/config/remote.adoc |   8 +++
 Documentation/fetch-options.adoc |  10 +++
 Documentation/git-remote.adoc    |  14 +++-
 builtin/fetch.c                  |  94 +++++++++++++++++-------
 builtin/remote.c                 |  31 ++++++--
 remote.c                         |  60 +++++++++++++++-
 remote.h                         |  20 ++++++
 t/meson.build                    |   1 +
 t/t5505-remote.sh                |  76 ++++++++++++++++++++
 t/t5510-fetch.sh                 | 101 ++++++++++++++++++++++++++
 t/t5586-fetch-refmap.sh          | 119 +++++++++++++++++++++++++++++++
 11 files changed, 501 insertions(+), 33 deletions(-)
 create mode 100755 t/t5586-fetch-refmap.sh
base-commit: 7e34d8174dcda3435d1404c9a30bef46afe6c13e
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2412%2FHaraldNordgren%2Ffetch-shallow-narrow-refspec-v11
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2412/HaraldNordgren/fetch-shallow-narrow-refspec-v11
Pull-Request: https://github.com/git/git/pull/2412
Range-diff vs v10:
 1:  ba7f1354cd ! 1:  d66b3c0bb1 fetch: add remote.<name>.refmap
     @@ remote.c: void ref_push_report_free(struct ref_push_report *report)
       int remote_find_tracking(struct remote *remote, struct refspec_item *refspec)
       {
      -	return refspec_find_match(&remote->fetch, refspec);
     -+	if (remote->fetch.nr)
     -+		return refspec_find_match(&remote->fetch, refspec);
     -+	return refspec_find_match(&remote->refmap, refspec);
     ++	char **result = refspec->src ? &refspec->dst : &refspec->src;
     ++
     ++	if (remote->fetch.nr && !refspec_find_match(&remote->fetch, refspec))
     ++		return 0;
     ++	if (refspec_find_match(&remote->refmap, refspec))
     ++		return -1;
     ++	if (refname_matches_negative_refspec_item(refspec->src, &remote->fetch)) {
     ++		FREE_AND_NULL(*result);
     ++		return -1;
     ++	}
     ++	return 0;
       }
       
       static struct ref *alloc_ref_with_prefix(const char *prefix, size_t prefixlen,
     @@ t/t5510-fetch.sh: test_expect_success 'explicit --refmap option overrides remote
      +		EOF
      +	)
      +'
     ++
     ++test_expect_success 'remote.<name>.refmap tracks a branch outside remote.<name>.fetch' '
     ++	test_when_finished "rm -fr fetch-refmap-upstream downstream" &&
     ++	git init -b main fetch-refmap-upstream &&
     ++	test_commit -C fetch-refmap-upstream base &&
     ++	git -C fetch-refmap-upstream branch other &&
     ++	git init downstream &&
     ++	(
     ++		cd downstream &&
     ++		git remote add -t main origin ../fetch-refmap-upstream &&
     ++		git config remote.origin.refmap "+refs/heads/*:refs/remotes/origin/*" &&
     ++		git fetch origin other &&
     ++		git branch --track topic origin/other &&
     ++		test_cmp_config origin branch.topic.remote &&
     ++		test_cmp_config refs/heads/other branch.topic.merge &&
     ++		echo refs/remotes/origin/other >expect &&
     ++		git rev-parse --symbolic-full-name topic@{upstream} >actual &&
     ++		test_cmp expect actual
     ++	)
     ++'
     ++
     ++test_expect_success 'remote.<name>.refmap does not track a branch excluded by remote.<name>.fetch' '
     ++	test_when_finished "rm -fr fetch-refmap-upstream downstream" &&
     ++	git init -b main fetch-refmap-upstream &&
     ++	test_commit -C fetch-refmap-upstream base &&
     ++	git -C fetch-refmap-upstream branch secret &&
     ++	git init downstream &&
     ++	(
     ++		cd downstream &&
     ++		git remote add origin ../fetch-refmap-upstream &&
     ++		git config --add remote.origin.fetch "^refs/heads/secret" &&
     ++		git config remote.origin.refmap "+refs/heads/*:refs/remotes/origin/*" &&
     ++		git fetch origin secret &&
     ++		git rev-parse --verify refs/remotes/origin/secret &&
     ++		test_must_fail git branch --track topic origin/secret 2>err &&
     ++		test_grep "not a branch" err
     ++	)
     ++'
      +
       test_expect_success 'explicitly empty --refmap option disables remote.*.fetch' '
       	git branch -f side &&
 2:  aa20604144 ! 2:  f685051033 fetch: extract collect_upstream_from_remote() helper
     @@ Metadata
       ## Commit message ##
          fetch: extract collect_upstream_from_remote() helper
      
     -    When a fetch has no refspec to work from, we fall back to guessing
     -    what to fetch: the remote's configured fetch refspec if there is one,
     -    and separately, whether the current branch's upstream lives on this
     -    remote. The latter is independent of the former on purpose: a narrow
     -    refspec (for example from "git remote add -t") can leave the current
     -    branch's own upstream uncovered, and we still need to be able to fetch
     -    it.
     +    When a fetch has no refspec to work from, we decide what to fetch from
     +    two sources: the remote's configured fetch refspec, and the current
     +    branch's upstream, if it lives on that remote. For example, after
     +
     +        git clone --single-branch <url>
     +        git switch -c work
     +        git push -u origin work
     +
     +    the remote's refspec only covers "main", but a refspec-less "git fetch
     +    origin" still fetches "work" into FETCH_HEAD, so that a plain "git
     +    pull" finds the branch to merge. See 49ca2fba39 (fetch: add
     +    branch.*.merge to default ref-prefix extension, 2022-09-08).
      
          That "does this branch build on this remote" check was inlined for
          just the current branch. Move it into its own function,
     @@ builtin/fetch.c: static int do_fetch(struct transport *transport,
       		refspec_ref_prefixes(rs, &transport_ls_refs_options.ref_prefixes);
       	} else {
      -		struct branch *branch = branch_get(NULL);
     -+		struct string_list tracked = STRING_LIST_INIT_DUP;
     -+		struct string_list_item *item;
     - 
     +-
       		if (transport->remote->fetch.nr) {
       			refspec_ref_prefixes(&transport->remote->fetch,
     + 					     &transport_ls_refs_options.ref_prefixes);
      @@ builtin/fetch.c: static int do_fetch(struct transport *transport,
       			else
       				follow_remote_head = BUILTIN_FOLLOW_REMOTE_HEAD_DFLT;
     @@ builtin/fetch.c: static int do_fetch(struct transport *transport,
      +		 * branch's upstream (e.g. a narrowed -t refspec), so
      +		 * make sure we can still fetch it regardless.
      +		 */
     -+		collect_upstream_from_remote(the_repository, &tracked,
     -+					      transport->remote, NULL);
     -+		for_each_string_list_item(item, &tracked)
     -+			strvec_push(&transport_ls_refs_options.ref_prefixes,
     -+				    item->string);
     -+		string_list_clear(&tracked, 0);
     ++		collect_upstream_from_remote(the_repository, transport->remote,
     ++					      NULL, &transport_ls_refs_options.ref_prefixes);
       
       		/*
       		 * If there are no refs specified to fetch, then we just
     @@ remote.c: int branch_merge_matches(struct branch *branch,
       }
       
      +void collect_upstream_from_remote(struct repository *repo,
     -+				   struct string_list *tracked,
     -+				   struct remote *remote,
     -+				   const char *refname)
     ++				   const struct remote *remote,
     ++				   const char *refname,
     ++				   struct strvec *tracked)
      +{
      +	struct branch *branch = repo_branch_get(repo, refname);
      +
     @@ remote.c: int branch_merge_matches(struct branch *branch,
      +		return;
      +
      +	for (int i = 0; i < branch->merge_nr; i++)
     -+		string_list_insert(tracked, branch->merge[i]->src);
     ++		strvec_push(tracked, branch->merge[i]->src);
      +}
      +
       __attribute__((format (printf,2,3)))
     @@ remote.h: int branch_has_merge_config(struct branch *branch);
      + * tracked. A NULL refname means the current branch.
      + */
      +void collect_upstream_from_remote(struct repository *repo,
     -+				   struct string_list *tracked,
     -+				   struct remote *remote,
     -+				   const char *refname);
     ++				   const struct remote *remote,
     ++				   const char *refname,
     ++				   struct strvec *tracked);
      +
       /* list of the remote in a group as configured */
       struct remote_group_data {
 3:  9fb7e77a86 ! 3:  5c76b3b88d fetch: infer branches to fetch from a refmap-only remote
     @@ Metadata
       ## Commit message ##
          fetch: infer branches to fetch from a refmap-only remote
      
     -    Configuring remote.<name>.refmap without remote.<name>.fetch used to
     -    make a refspec-less "git fetch <name>" fail with "--refmap option is
     -    only meaningful with command-line refspec(s)", since a refmap only
     -    says where to put fetched refs, not what to fetch.
     +    We want remote.<name>.refmap to work on its own, without also setting
     +    remote.<name>.fetch, so a remote can be limited to the branches
     +    already in use locally, without listing them by hand or touching the
     +    command line every time.
      
     -    Make that case infer what to fetch: the local branches whose
     -    @{upstream} is already on that remote. This lets a remote be
     -    configured to fetch only the branches actually in use, without
     -    listing them by hand in remote.<name>.fetch, and without needing to
     -    touch the command line every time.
     +    Infer what to fetch from the local branches whose @{upstream} is
     +    already on that remote. The refmap itself still only controls where
     +    those fetched refs land, not which branches are selected.
      
          Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
      
     @@ Documentation/config/remote.adoc: remote.<name>.fetch::
      -	store. See the `--refmap` entry in linkgit:git-fetch[1].
      +	store. If `remote.<name>.fetch` is not set either, a refspec-less
      +	fetch infers what to fetch from local branches built on this
     -+	remote, instead of fetching every branch it has. See the
     -+	`--refmap` entry in linkgit:git-fetch[1].
     ++	remote, instead of needing `remote.<name>.fetch` listed by hand.
     ++	See the `--refmap` entry in linkgit:git-fetch[1].
       
       remote.<name>.push::
       	The default set of "refspec" for linkgit:git-push[1]. See
     @@ Documentation/fetch-options.adoc: endif::git-pull[]
      -same way `remote.<name>.fetch` provides the default refspecs to fetch.
      +When a refmap is active (from `--refmap` or `remote.<name>.refmap`) but
      +nothing to fetch is specified on the command line, nor is there a
     -+`remote.<name>.fetch`, branches from the remote that are used as the
     -+`@{upstream}` of our local branches are fetched.
     ++`remote.<name>.fetch`, infer what to fetch from local branches built on
     ++this remote: remote-tracking branches from this remote that are also
     ++configured as the `@{upstream}` of a local branch are fetched. The
     ++refmap only decides where those fetched refs land, the same as it
     ++would for an explicit refspec, and does not narrow which branches are
     ++selected. It is what turns this on, since without it the fetched
     ++branches would have nowhere to land.
       
       `-t`::
       `--tags`::
     @@ builtin/fetch.c: static struct ref *get_ref_map(struct remote *remote,
       
      +	if (!rs->nr && remote && !remote->fetch.nr &&
      +	    effective_refmap && effective_refmap->nr) {
     -+		struct string_list tracked = STRING_LIST_INIT_DUP;
     -+		struct string_list_item *item;
     ++		struct strvec tracked = STRVEC_INIT;
      +
      +		branches_tracking_remote(the_repository, remote, &tracked);
     -+		for_each_string_list_item(item, &tracked)
     -+			refspec_append(&inferred_rs, item->string);
     -+		string_list_clear(&tracked, 0);
     ++		for (size_t i = 0; i < tracked.nr; i++)
     ++			refspec_append(&inferred_rs, tracked.v[i]);
     ++		strvec_clear(&tracked);
      +
      +		rs = &inferred_rs;
      +		infer_from_refmap = 1;
     @@ builtin/fetch.c: static struct ref *get_ref_map(struct remote *remote,
       	return ref_map;
       }
       
     +@@ builtin/fetch.c: static int do_fetch(struct transport *transport,
     + 	struct strmap rejected_refs = STRMAP_INIT;
     + 	int summary_width = 0;
     + 	int follow_remote_head = FOLLOW_REMOTE_NEVER;
     ++	bool apply_follow_remote_head_config = false;
     + 
     + 	if (tags == TAGS_DEFAULT) {
     + 		if (transport->remote->fetch_tags == 2)
      @@ builtin/fetch.c: static int do_fetch(struct transport *transport,
       
       	if (rs->nr) {
       		refspec_ref_prefixes(rs, &transport_ls_refs_options.ref_prefixes);
     +-	} else {
     +-		if (transport->remote->fetch.nr) {
     +-			refspec_ref_prefixes(&transport->remote->fetch,
     +-					     &transport_ls_refs_options.ref_prefixes);
     +-			/*
     +-			 * See remote.c's handling of remote.<name>.followRemoteHEAD
     +-			 * for the analogous, still-unresolved case.
     +-			 */
     +-			if (transport->remote->follow_remote_head)
     +-				follow_remote_head = transport->remote->follow_remote_head;
     +-			else if (config->follow_remote_head_seen)
     +-				follow_remote_head = get_follow_remote_head(config->follow_remote_head_raw);
     +-			else
     +-				follow_remote_head = BUILTIN_FOLLOW_REMOTE_HEAD_DFLT;
     +-		}
      +	} else if (transport->remote->fetch.nr) {
     -+		struct string_list tracked = STRING_LIST_INIT_DUP;
     -+		struct string_list_item *item;
     -+
      +		refspec_ref_prefixes(&transport->remote->fetch,
      +				     &transport_ls_refs_options.ref_prefixes);
     ++		apply_follow_remote_head_config = true;
     + 
     + 		/*
     + 		 * The configured refspec may not cover the current
     +@@ builtin/fetch.c: static int do_fetch(struct transport *transport,
     + 		 */
     + 		collect_upstream_from_remote(the_repository, transport->remote,
     + 					      NULL, &transport_ls_refs_options.ref_prefixes);
     ++	} else {
     ++		/*
     ++		 * The --refmap command line option, if given, takes
     ++		 * precedence over remote.<name>.refmap.
     ++		 */
     ++		struct refspec *effective_refmap = refmap.nr ? &refmap :
     ++			&transport->remote->refmap;
     ++
     ++		if (effective_refmap->nr) {
     ++			branches_tracking_remote(the_repository, transport->remote,
     ++						  &transport_ls_refs_options.ref_prefixes);
     ++			apply_follow_remote_head_config = true;
     ++		} else {
     ++			collect_upstream_from_remote(the_repository, transport->remote,
     ++						      NULL, &transport_ls_refs_options.ref_prefixes);
     ++		}
     + 
     + 		/*
     + 		 * If there are no refs specified to fetch, then we just
     +@@ builtin/fetch.c: static int do_fetch(struct transport *transport,
     + 				    "HEAD");
     + 	}
     + 
     ++	if (apply_follow_remote_head_config) {
      +		/*
      +		 * See remote.c's handling of remote.<name>.followRemoteHEAD
      +		 * for the analogous, still-unresolved case.
     @@ builtin/fetch.c: static int do_fetch(struct transport *transport,
      +			follow_remote_head = get_follow_remote_head(config->follow_remote_head_raw);
      +		else
      +			follow_remote_head = BUILTIN_FOLLOW_REMOTE_HEAD_DFLT;
     ++	}
      +
     -+		/*
     -+		 * The configured refspec may not cover the current
     -+		 * branch's upstream (e.g. a narrowed -t refspec), so
     -+		 * make sure we can still fetch it regardless.
     -+		 */
     -+		collect_upstream_from_remote(the_repository, &tracked,
     -+					      transport->remote, NULL);
     -+		for_each_string_list_item(item, &tracked)
     -+			strvec_push(&transport_ls_refs_options.ref_prefixes,
     -+				    item->string);
     -+		string_list_clear(&tracked, 0);
     - 	} else {
     -+		/*
     -+		 * The --refmap command line option, if given, takes
     -+		 * precedence over remote.<name>.refmap.
     -+		 */
     -+		struct refspec *effective_refmap = refmap.nr ? &refmap :
     -+			&transport->remote->refmap;
     - 		struct string_list tracked = STRING_LIST_INIT_DUP;
     - 		struct string_list_item *item;
     - 
     --		if (transport->remote->fetch.nr) {
     --			refspec_ref_prefixes(&transport->remote->fetch,
     --					     &transport_ls_refs_options.ref_prefixes);
     -+		if (effective_refmap->nr) {
     -+			branches_tracking_remote(the_repository,
     -+						  transport->remote, &tracked);
     - 			/*
     - 			 * See remote.c's handling of remote.<name>.followRemoteHEAD
     - 			 * for the analogous, still-unresolved case.
     -@@ builtin/fetch.c: static int do_fetch(struct transport *transport,
     - 				follow_remote_head = get_follow_remote_head(config->follow_remote_head_raw);
     - 			else
     - 				follow_remote_head = BUILTIN_FOLLOW_REMOTE_HEAD_DFLT;
     -+		} else {
     -+			collect_upstream_from_remote(the_repository, &tracked,
     -+						      transport->remote, NULL);
     - 		}
     --
     --		/*
     --		 * The configured refspec may not cover the current
     --		 * branch's upstream (e.g. a narrowed -t refspec), so
     --		 * make sure we can still fetch it regardless.
     --		 */
     --		collect_upstream_from_remote(the_repository, &tracked,
     --					      transport->remote, NULL);
     - 		for_each_string_list_item(item, &tracked)
     - 			strvec_push(&transport_ls_refs_options.ref_prefixes,
     - 				    item->string);
     + 	if (tags == TAGS_SET || tags == TAGS_DEFAULT)
     + 		strvec_push(&transport_ls_refs_options.ref_prefixes,
     + 			    "refs/tags/");
      
       ## remote.c ##
      @@ remote.c: void collect_upstream_from_remote(struct repository *repo,
     - 		string_list_insert(tracked, branch->merge[i]->src);
     + 		strvec_push(tracked, branch->merge[i]->src);
       }
       
      +struct branches_tracking_remote_cb_data {
      +	struct repository *repo;
     -+	struct remote *remote;
     -+	struct string_list *tracked;
     ++	const struct remote *remote;
     ++	struct strvec *tracked;
      +};
      +
      +static int add_if_tracking_remote(const struct reference *ref, void *cb_data)
      +{
      +	struct branches_tracking_remote_cb_data *data = cb_data;
      +
     -+	collect_upstream_from_remote(data->repo, data->tracked, data->remote,
     -+				      ref->name);
     ++	collect_upstream_from_remote(data->repo, data->remote, ref->name,
     ++				      data->tracked);
      +	return 0;
      +}
      +
     -+void branches_tracking_remote(struct repository *repo, struct remote *remote,
     -+			       struct string_list *tracked)
     ++void branches_tracking_remote(struct repository *repo,
     ++			       const struct remote *remote,
     ++			       struct strvec *tracked)
      +{
      +	struct branches_tracking_remote_cb_data data = { repo, remote, tracked };
      +
     @@ remote.c: void collect_upstream_from_remote(struct repository *repo,
      
       ## remote.h ##
      @@ remote.h: void collect_upstream_from_remote(struct repository *repo,
     - 				   struct remote *remote,
     - 				   const char *refname);
     + 				   const char *refname,
     + 				   struct strvec *tracked);
       
     -+/* fills tracked with the refname of every local branch's upstream on remote */
     -+void branches_tracking_remote(struct repository *repo, struct remote *remote,
     -+			       struct string_list *tracked);
     ++/* Same as collect_upstream_from_remote(), but checked for every local branch. */
     ++void branches_tracking_remote(struct repository *repo,
     ++			       const struct remote *remote,
     ++			       struct strvec *tracked);
      +
       /* list of the remote in a group as configured */
       struct remote_group_data {
 4:  80028d4f86 ! 4:  417f14d708 remote: add "git remote add --limited-fetch"
     @@ builtin/remote.c: static int add(int argc, const char **argv, const char *prefix
       	repo_config_set(the_repository, buf.buf, url);
       
       	if (!mirror || mirror & MIRROR_FETCH) {
     -+		int use_limited_fetch = mirror == MIRROR_NONE && track.nr == 0 &&
     ++		bool use_limited_fetch = mirror == MIRROR_NONE && track.nr == 0 &&
      +			limited_fetch == 1;
      +
       		strbuf_reset(&buf);
 5:  552bf08971 ! 5:  de0daa8623 remote: default to --limited-fetch in a shallow repository
     @@ Metadata
       ## Commit message ##
          remote: default to --limited-fetch in a shallow repository
      
     -    Adding a second remote to a shallow, single-branch clone used to
     -    still fetch every branch that remote has, since "git remote add"
     -    always set up a wildcard remote.<name>.fetch refspec regardless of
     -    how shallow the repository already was. That defeats the purpose of
     -    having cloned shallow and single-branch in the first place, and can
     -    make a plain "git fetch" on that remote hang or take a very long
     +    Adding a second remote to a shallow clone used to still fetch every
     +    branch that remote has, since "git remote add" always set up a
     +    wildcard remote.<name>.fetch refspec regardless of how shallow the
     +    repository already was. That defeats the purpose of having cloned
     +    shallow in the first place (for example with --single-branch), and
     +    can make a plain "git fetch" on that remote hang or take a very long
          time on a repository with many branches.
      
          Turn --limited-fetch on by default when the repository is already
     @@ builtin/remote.c
      @@ builtin/remote.c: static int add(int argc, const char **argv, const char *prefix,
       
       	if (!mirror || mirror & MIRROR_FETCH) {
     - 		int use_limited_fetch = mirror == MIRROR_NONE && track.nr == 0 &&
     + 		bool use_limited_fetch = mirror == MIRROR_NONE && track.nr == 0 &&
      -			limited_fetch == 1;
      +			(limited_fetch == 1 ||
      +			 (limited_fetch == -1 &&
-- 
gitgitgadget
Previous: Phillip WoodNext: Harald Nordgren via GitGitGadget
Message 113 of 154 in “fetch: add config to avoid fetching every branch in shallow repo”
  1. fetch: add config to avoid fetching every branch in shallow repoHarald Nordgren via GitGitGadget, Sep 19, 2026
  2. Phillip WoodSep 21, 2026
  3. Harald NordgrenSep 21, 2026
  4. Harald NordgrenSep 22, 2026
  5. Phillip WoodSep 22, 2026
  6. Harald NordgrenSep 22, 2026
  7. Phillip WoodSep 23, 2026
  8. Junio C HamanoSep 22, 2026
  9. Harald NordgrenSep 22, 2026
  10. Phillip WoodSep 23, 2026
  11. Junio C HamanoSep 23, 2026
  12. D. Ben KnobleSep 23, 2026
  13. Junio C HamanoSep 23, 2026
  14. D. Ben KnobleSep 24, 2026
  15. Junio C HamanoSep 24, 2026
  16. fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Sep 23, 2026
  17. Junio C HamanoSep 23, 2026
  18. 0/4 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Sep 25, 2026
  19. 1/4 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Sep 25, 2026
  20. Junio C HamanoSep 25, 2026
  21. 2/4 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Sep 25, 2026
  22. Junio C HamanoSep 25, 2026
  23. 3/4 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Sep 25, 2026
  24. 4/4 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Sep 25, 2026
  25. 0/4 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Sep 29, 2026
  26. 1/4 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Sep 29, 2026
  27. 2/4 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Sep 29, 2026
  28. Harald NordgrenSep 29, 2026
  29. Junio C HamanoSep 29, 2026
  30. 3/4 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Sep 29, 2026
  31. 4/4 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Sep 29, 2026
  32. Junio C HamanoSep 29, 2026
  33. 0/4 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 2, 2026
  34. 1/4 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Oct 2, 2026
  35. 2/4 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 2, 2026
  36. 3/4 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 2, 2026
  37. Junio C HamanoOct 2, 2026
  38. 4/4 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 2, 2026
  39. 0/4 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 4, 2026
  40. 1/4 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Oct 4, 2026
  41. 2/4 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 4, 2026
  42. 3/4 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 4, 2026
  43. 4/4 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 4, 2026
  44. Junio C HamanoOct 4, 2026
  45. Harald NordgrenOct 4, 2026
  46. Junio C HamanoOct 5, 2026
  47. Harald NordgrenOct 5, 2026
  48. 0/4 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 7, 2026
  49. 1/4 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Oct 7, 2026
  50. 2/4 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 7, 2026
  51. Junio C HamanoOct 8, 2026
  52. Harald NordgrenOct 9, 2026
  53. Harald NordgrenOct 9, 2026
  54. 3/4 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 7, 2026
  55. 4/4 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 7, 2026
  56. 0/5 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 10, 2026
  57. 1/5 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Oct 10, 2026
  58. 2/5 fetch: extract collect_upstream_from_remote() helperHarald Nordgren via GitGitGadget, Oct 10, 2026
  59. Junio C HamanoOct 10, 2026
  60. Harald NordgrenOct 10, 2026
  61. 3/5 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 10, 2026
  62. 4/5 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 10, 2026
  63. Junio C HamanoOct 10, 2026
  64. 5/5 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 10, 2026
  65. 0/5 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 14, 2026
  66. 1/5 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Oct 14, 2026
  67. 2/5 fetch: extract collect_upstream_from_remote() helperHarald Nordgren via GitGitGadget, Oct 14, 2026
  68. 3/5 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 14, 2026
  69. 4/5 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 14, 2026
  70. 5/5 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 14, 2026
  71. 0/5 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 20, 2026
  72. 1/5 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Oct 20, 2026
  73. D. Ben KnobleOct 24, 2026
  74. Harald NordgrenOct 24, 2026
  75. D. Ben KnobleOct 25, 2026
  76. Harald NordgrenOct 25, 2026
  77. Junio C HamanoOct 25, 2026
  78. Harald NordgrenOct 26, 2026
  79. Junio C HamanoOct 26, 2026
  80. Phillip WoodOct 27, 2026
  81. Junio C HamanoOct 27, 2026
  82. Phillip WoodOct 28, 2026
  83. Junio C HamanoOct 28, 2026
  84. Harald NordgrenOct 28, 2026
  85. Phillip WoodOct 29, 2026
  86. Junio C HamanoOct 29, 2026
  87. Phillip WoodOct 26, 2026
  88. Junio C HamanoOct 26, 2026
  89. Phillip WoodOct 26, 2026
  90. Ben KnobleOct 29, 2026
  91. Harald NordgrenOct 29, 2026
  92. Junio C HamanoOct 29, 2026
  93. Harald NordgrenOct 30, 2026
  94. Notes, refs, etc. (was: Re: [PATCH v10 1/5] fetch: add remote.<name>.refmap)D. Ben Knoble, Nov 7, 2026
  95. 2/5 fetch: extract collect_upstream_from_remote() helperHarald Nordgren via GitGitGadget, Oct 20, 2026
  96. D. Ben KnobleOct 24, 2026
  97. Harald NordgrenOct 25, 2026
  98. D. Ben KnobleOct 27, 2026
  99. 3/5 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 20, 2026
  100. D. Ben KnobleOct 24, 2026
  101. Harald NordgrenOct 25, 2026
  102. 4/5 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 20, 2026
  103. D. Ben KnobleOct 24, 2026
  104. 5/5 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 20, 2026
  105. D. Ben KnobleOct 24, 2026
  106. Harald NordgrenOct 25, 2026
  107. Junio C HamanoOct 23, 2026
  108. D. Ben KnobleOct 24, 2026
  109. Phillip WoodOct 26, 2026
  110. Junio C HamanoOct 26, 2026
  111. Harald NordgrenOct 27, 2026
  112. Phillip WoodOct 27, 2026
  113. 0/5 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 25, 2026
  114. 1/5 fetch: add remote.<name>.refmapHarald Nordgren via GitGitGadget, Oct 25, 2026
  115. 2/5 fetch: extract collect_upstream_from_remote() helperHarald Nordgren via GitGitGadget, Oct 25, 2026
  116. 3/5 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 25, 2026
  117. 4/5 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 25, 2026
  118. 5/5 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 25, 2026
  119. 0/5 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 27, 2026
  120. 1/5 fetch: add remote.<name>.fetchRefmapHarald Nordgren via GitGitGadget, Oct 27, 2026
  121. 2/5 fetch: extract collect_upstream_from_remote() helperHarald Nordgren via GitGitGadget, Oct 27, 2026
  122. 3/5 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 27, 2026
  123. 4/5 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 27, 2026
  124. 5/5 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 27, 2026
  125. 0/6 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Oct 30, 2026
  126. 1/6 fetch: add remote.<name>.fetchRefmapHarald Nordgren via GitGitGadget, Oct 30, 2026
  127. Phillip WoodNov 12, 2026
  128. Junio C HamanoNov 12, 2026
  129. Phillip WoodNov 13, 2026
  130. 2/6 fetch: extract collect_upstream_from_remote() helperHarald Nordgren via GitGitGadget, Oct 30, 2026
  131. 3/6 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Oct 30, 2026
  132. 4/6 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Oct 30, 2026
  133. 5/6 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Oct 30, 2026
  134. 6/6 remote: resolve @{push} through remote.<name>.fetchRefmapHarald Nordgren via GitGitGadget, Oct 30, 2026
  135. D. Ben KnobleNov 11, 2026
  136. Junio C HamanoNov 11, 2026
  137. Harald NordgrenNov 14, 2026
  138. Harald NordgrenNov 11, 2026
  139. Phillip WoodNov 11, 2026
  140. Junio C HamanoNov 11, 2026
  141. D. Ben KnobleNov 11, 2026
  142. Phillip WoodNov 12, 2026
  143. Matt HunterNov 12, 2026
  144. Phillip WoodNov 17, 2026
  145. 0/5 fetch: avoid fetching every branch of a new remote in a shallow repoHarald Nordgren via GitGitGadget, Nov 14, 2026
  146. 1/5 fetch: add remote.<name>.fetchRefmapHarald Nordgren via GitGitGadget, Nov 14, 2026
  147. Phillip WoodNov 17, 2026
  148. Junio C HamanoNov 17, 2026
  149. Phillip WoodNov 17, 2026
  150. Junio C HamanoNov 17, 2026
  151. 2/5 fetch: extract collect_upstream_from_remote() helperHarald Nordgren via GitGitGadget, Nov 14, 2026
  152. 3/5 fetch: infer branches to fetch from a refmap-only remoteHarald Nordgren via GitGitGadget, Nov 14, 2026
  153. 4/5 remote: add "git remote add --limited-fetch"Harald Nordgren via GitGitGadget, Nov 14, 2026
  154. 5/5 remote: default to --limited-fetch in a shallow repositoryHarald Nordgren via GitGitGadget, Nov 14, 2026

Read the whole thread, see it on lore, or plain text.

$ cat FOOTERMessages come from the public archive at lore.kernel.org/git, fetched every hour. The front page is chosen and written each morning by an AI editor and can be wrong; the threads themselves are the record. About and API. For agents: an MCP server at https://gitlist.dev/mcp, and any thread, story or person page as Markdown by adding .md to its URL (or sending Accept: text/markdown). Details in /llms.txt.