* [PATCH v2 03/10] path-walk: support blobless filter
From: Derrick Stolee via GitGitGadget @ 2026-05-04 20:21 UTC (permalink / raw)
To: git
Cc: christian.couder, gitster, johannes.schindelin, johncai86,
karthik.188, kristofferhaugsbakk, me, newren, peff, ps,
Derrick Stolee, Derrick Stolee
In-Reply-To: <pull.2101.v2.git.1777926079.gitgitgadget@gmail.com>
From: Derrick Stolee <stolee@gmail.com>
The 'git pack-objects' command can opt-in to using the path-walk API for
scanning the objects. Currently, this option is dynamically disabled if
combined with '--filter=<X>', even when using a simple filter such as
'blob:none' to signal a blobless packfile. This is a common scenario for
repos at scale, so is worth integrating.
Also, users can opt-in to the '--path-walk' option by default through
the pack.usePathWalk=true config option. When using that in a blobless
partial clone, the following warning can appear even though the user did
not specify either option directly:
warning: cannot use --filter with --path-walk
Teach the path-walk API to handle the 'blob:none' object filter
natively. When revs->filter.choice is LOFC_BLOB_NONE, the path-walk
sets info->blobs to 0 (skipping all blob objects) and clears the
filter from revs so that prepare_revision_walk() does not reject the
configuration.
This check is implemented in the static prepare_filters() method, which
will simultaneously check if the input filters are compatible and will
make the appropriate mutations to the path_walk_info and filters if the
path_walk_info is non-NULL. This allows us to use this logic both in the
API method path_walk_filter_compatible() for use in
builtin/pack-objects.c and as a prep step in walk_objects_by_path().
Update the test helper (test-path-walk) to accept --filter=<spec>
as a test-tool option (before '--'), applying it to revs after
setup_revisions() to avoid the --objects requirement check.
Also switch test-path-walk from REV_INFO_INIT with manual repo
assignment to repo_init_revisions(), which properly initializes
the filter_spec strbuf needed for filter parsing.
Add tests for blob:none with --all and with a single branch.
The performance test p5315 shows the impact of this change when using
blobless filters:
Test HEAD~1 HEAD
---------------------------------------------------------------------
5315.6: repack (blob:none) 13.53 13.87 +2.5%
5315.7: repack size (blob:none) 137.7M 137.8M +0.1%
5315.8: repack (blob:none, --path-walk) 13.51 23.43 +73.4%
5315.9: repack size (blob:none, --path-walk) 137.7M 115.2M -16.3%
These performance tests were run on the Git repository. The --path-walk
feature shows meaningful space savings (16% smaller for blobless packs)
at the cost of increased computation time due to the two compression
passes. This data demonstrates that the feature is engaged and provides
real compression benefits when --no-reuse-delta forces fresh deltas.
Co-Authored-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Derrick Stolee <stolee@gmail.com>
---
Documentation/git-pack-objects.adoc | 6 +--
builtin/pack-objects.c | 2 +-
path-walk.c | 30 +++++++++++++++
path-walk.h | 7 ++++
t/helper/test-path-walk.c | 11 +++++-
t/t6601-path-walk.sh | 60 +++++++++++++++++++++++++++++
6 files changed, 111 insertions(+), 5 deletions(-)
diff --git a/Documentation/git-pack-objects.adoc b/Documentation/git-pack-objects.adoc
index b78175fbe1..917045d5c3 100644
--- a/Documentation/git-pack-objects.adoc
+++ b/Documentation/git-pack-objects.adoc
@@ -402,9 +402,9 @@ will be automatically changed to version `1`.
of filenames that cause collisions in Git's default name-hash
algorithm.
+
-Incompatible with `--delta-islands`, `--shallow`, or `--filter`. The
-`--use-bitmap-index` option will be ignored in the presence of
-`--path-walk.`
+Incompatible with `--delta-islands`. The `--use-bitmap-index` option is
+ignored in the presence of `--path-walk`. Whe `--path-walk` option
+supports the `--filter=<spec>` form `blob:none`.
DELTA ISLANDS
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 4338962904..bc9fb5b457 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -5177,7 +5177,7 @@ int cmd_pack_objects(int argc,
if (path_walk) {
const char *option = NULL;
- if (filter_options.choice)
+ if (!path_walk_filter_compatible(&filter_options))
option = "--filter";
else if (use_delta_islands)
option = "--delta-islands";
diff --git a/path-walk.c b/path-walk.c
index 6e426af433..a4dd197c37 100644
--- a/path-walk.c
+++ b/path-walk.c
@@ -9,6 +9,7 @@
#include "hashmap.h"
#include "hex.h"
#include "list-objects.h"
+#include "list-objects-filter-options.h"
#include "object.h"
#include "oid-array.h"
#include "path.h"
@@ -485,6 +486,32 @@ static int setup_pending_objects(struct path_walk_info *info,
return 0;
}
+static int prepare_filters(struct path_walk_info *info,
+ struct list_objects_filter_options *options)
+{
+ switch (options->choice) {
+ case LOFC_DISABLED:
+ return 1;
+
+ case LOFC_BLOB_NONE:
+ if (info) {
+ info->blobs = 0;
+ list_objects_filter_release(options);
+ }
+ return 1;
+
+ default:
+ error(_("object filter '%s' not supported by the path-walk API"),
+ list_objects_filter_spec(options));
+ return 0;
+ }
+}
+
+int path_walk_filter_compatible(struct list_objects_filter_options *options)
+{
+ return prepare_filters(NULL, options);
+}
+
/**
* Given the configuration of 'info', walk the commits based on 'info->revs' and
* call 'info->path_fn' on each discovered path.
@@ -512,6 +539,9 @@ int walk_objects_by_path(struct path_walk_info *info)
trace2_region_enter("path-walk", "commit-walk", info->revs->repo);
+ if (!prepare_filters(info, &info->revs->filter))
+ return -1;
+
CALLOC_ARRAY(commit_list, 1);
commit_list->type = OBJ_COMMIT;
diff --git a/path-walk.h b/path-walk.h
index 5ef5a8440e..be8d27b398 100644
--- a/path-walk.h
+++ b/path-walk.h
@@ -85,3 +85,10 @@ void path_walk_info_clear(struct path_walk_info *info);
* Returns nonzero on an error.
*/
int walk_objects_by_path(struct path_walk_info *info);
+
+struct list_objects_filter_options;
+/**
+ * Given a set of options for filtering objects, return 1 if the options
+ * are compatible with the path-walk API and 0 otherwise.
+ */
+int path_walk_filter_compatible(struct list_objects_filter_options *options);
diff --git a/t/helper/test-path-walk.c b/t/helper/test-path-walk.c
index fe63002c2b..88f86ae0dc 100644
--- a/t/helper/test-path-walk.c
+++ b/t/helper/test-path-walk.c
@@ -4,6 +4,7 @@
#include "dir.h"
#include "environment.h"
#include "hex.h"
+#include "list-objects-filter-options.h"
#include "object-name.h"
#include "object.h"
#include "pretty.h"
@@ -71,6 +72,8 @@ int cmd__path_walk(int argc, const char **argv)
struct rev_info revs = REV_INFO_INIT;
struct path_walk_info info = PATH_WALK_INFO_INIT;
struct path_walk_test_data data = { 0 };
+ struct list_objects_filter_options filter_options =
+ LIST_OBJECTS_FILTER_INIT;
struct option options[] = {
OPT_BOOL(0, "blobs", &info.blobs,
N_("toggle inclusion of blob objects")),
@@ -86,11 +89,12 @@ int cmd__path_walk(int argc, const char **argv)
N_("toggle aggressive edge walk")),
OPT_BOOL(0, "stdin-pl", &stdin_pl,
N_("read a pattern list over stdin")),
+ OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),
OPT_END(),
};
setup_git_directory();
- revs.repo = the_repository;
+ repo_init_revisions(the_repository, &revs, NULL);
argc = parse_options(argc, argv, NULL,
options, path_walk_usage,
@@ -101,6 +105,10 @@ int cmd__path_walk(int argc, const char **argv)
else
usage(path_walk_usage[0]);
+ /* Apply the filter after setup_revisions to avoid the --objects check. */
+ if (filter_options.choice)
+ list_objects_filter_copy(&revs.filter, &filter_options);
+
info.revs = &revs;
info.path_fn = emit_block;
info.path_fn_data = &data;
@@ -129,6 +137,7 @@ int cmd__path_walk(int argc, const char **argv)
free(info.pl);
}
+ list_objects_filter_release(&filter_options);
release_revisions(&revs);
return res;
}
diff --git a/t/t6601-path-walk.sh b/t/t6601-path-walk.sh
index 56bd1e3c5b..94df309987 100755
--- a/t/t6601-path-walk.sh
+++ b/t/t6601-path-walk.sh
@@ -415,4 +415,64 @@ test_expect_success 'trees are reported exactly once' '
test_line_count = 1 out-filtered
'
+test_expect_success 'all, blob:none filter' '
+ test-tool path-walk --filter=blob:none -- --all >out &&
+
+ cat >expect <<-EOF &&
+ 0:commit::$(git rev-parse topic)
+ 0:commit::$(git rev-parse base)
+ 0:commit::$(git rev-parse base~1)
+ 0:commit::$(git rev-parse base~2)
+ 1:tag:/tags:$(git rev-parse refs/tags/first)
+ 1:tag:/tags:$(git rev-parse refs/tags/second.1)
+ 1:tag:/tags:$(git rev-parse refs/tags/second.2)
+ 1:tag:/tags:$(git rev-parse refs/tags/third)
+ 1:tag:/tags:$(git rev-parse refs/tags/fourth)
+ 1:tag:/tags:$(git rev-parse refs/tags/tree-tag)
+ 1:tag:/tags:$(git rev-parse refs/tags/blob-tag)
+ 2:tree::$(git rev-parse topic^{tree})
+ 2:tree::$(git rev-parse base^{tree})
+ 2:tree::$(git rev-parse base~1^{tree})
+ 2:tree::$(git rev-parse base~2^{tree})
+ 2:tree::$(git rev-parse refs/tags/tree-tag^{})
+ 2:tree::$(git rev-parse refs/tags/tree-tag2^{})
+ 3:tree:a/:$(git rev-parse base:a)
+ 4:tree:child/:$(git rev-parse refs/tags/tree-tag:child)
+ 5:tree:left/:$(git rev-parse base:left)
+ 5:tree:left/:$(git rev-parse base~2:left)
+ 6:tree:right/:$(git rev-parse topic:right)
+ 6:tree:right/:$(git rev-parse base~1:right)
+ 6:tree:right/:$(git rev-parse base~2:right)
+ blobs:0
+ commits:4
+ tags:7
+ trees:13
+ EOF
+
+ test_cmp_sorted expect out
+'
+
+test_expect_success 'topic only, blob:none filter' '
+ test-tool path-walk --filter=blob:none -- topic >out &&
+
+ cat >expect <<-EOF &&
+ 0:commit::$(git rev-parse topic)
+ 0:commit::$(git rev-parse base~1)
+ 0:commit::$(git rev-parse base~2)
+ 1:tree::$(git rev-parse topic^{tree})
+ 1:tree::$(git rev-parse base~1^{tree})
+ 1:tree::$(git rev-parse base~2^{tree})
+ 2:tree:left/:$(git rev-parse base~2:left)
+ 3:tree:right/:$(git rev-parse topic:right)
+ 3:tree:right/:$(git rev-parse base~1:right)
+ 3:tree:right/:$(git rev-parse base~2:right)
+ blobs:0
+ commits:3
+ tags:0
+ trees:7
+ EOF
+
+ test_cmp_sorted expect out
+'
+
test_done
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 02/10] t/perf: add pack-objects filter and path-walk benchmark
From: Derrick Stolee via GitGitGadget @ 2026-05-04 20:21 UTC (permalink / raw)
To: git
Cc: christian.couder, gitster, johannes.schindelin, johncai86,
karthik.188, kristofferhaugsbakk, me, newren, peff, ps,
Derrick Stolee, Derrick Stolee
In-Reply-To: <pull.2101.v2.git.1777926079.gitgitgadget@gmail.com>
From: Derrick Stolee <stolee@gmail.com>
Add p5315-pack-objects-filter.sh to measure the performance of
'git pack-objects --revs --all' under different filter and traversal
combinations:
* no filter (baseline)
* --filter=blob:none (blobless)
* --filter=sparse:oid=<oid> (cone-mode sparse)
Each filter scenario is tested both with and without --path-walk,
producing paired measurements that show the impact of the path-walk
traversal for each filter type as we integrate the --path-walk feature
with different --filter options. It currently has no integration so
falls back to the standard revision walk. Thus, there are no significant
differences in the current results other than a full repack (and even
then, the --path-walk feature is not incredibly different for the
default Git repository):
Test HEAD
-----------------------------------------------------
5315.2: repack (no filter) 27.91
5315.3: repack size (no filter) 250.7M
5315.4: repack (no filter, --path-walk) 34.92
5315.5: repack size (no filter, --path-walk) 220.0M
5315.6: repack (blob:none) 13.63
5315.7: repack size (blob:none) 137.6M
5315.8: repack (blob:none, --path-walk) 13.48
5315.9: repack size (blob:none, --path-walk) 137.7M
5315.10: repack (sparse:oid) 72.67
5315.11: repack size (sparse:oid) 187.4M
5315.12: repack (sparse:oid, --path-walk) 72.47
5315.13: repack size (sparse:oid, --path-walk) 187.4M
The sparse filter definition is built automatically by sampling
depth-2 directories from the test repository, making the test work
on any repo passed via GIT_PERF_LARGE_REPO. For repos that lack
depth-2 directories, a single top-level directory is used; for flat
repos, the sparse tests are skipped via prerequisite.
Signed-off-by: Derrick Stolee <stolee@gmail.com>
---
t/perf/p5315-pack-objects-filter.sh | 129 ++++++++++++++++++++++++++++
1 file changed, 129 insertions(+)
create mode 100755 t/perf/p5315-pack-objects-filter.sh
diff --git a/t/perf/p5315-pack-objects-filter.sh b/t/perf/p5315-pack-objects-filter.sh
new file mode 100755
index 0000000000..b009039c89
--- /dev/null
+++ b/t/perf/p5315-pack-objects-filter.sh
@@ -0,0 +1,129 @@
+#!/bin/sh
+
+test_description='Tests pack-objects performance with filters and --path-walk'
+. ./perf-lib.sh
+
+test_perf_large_repo
+
+test_expect_success 'setup filter inputs' '
+ # Sample a few depth-2 directories from the test repo to build
+ # a cone-mode sparse-checkout definition. The sampling picks
+ # directories at evenly-spaced positions so the choice is stable
+ # and scales to repos of any shape.
+
+ git ls-tree -d --name-only HEAD >top-dirs &&
+ top_nr=$(wc -l <top-dirs) &&
+
+ >depth2-dirs &&
+ while read tdir
+ do
+ git ls-tree -d --name-only "HEAD:$tdir" 2>/dev/null |
+ sed "s|^|$tdir/|" >>depth2-dirs || return 1
+ done <top-dirs &&
+
+ d2_nr=$(wc -l <depth2-dirs) &&
+
+ if test "$d2_nr" -ge 2
+ then
+ # Pick two directories from evenly-spaced positions.
+ first=$(sed -n "1p" depth2-dirs) &&
+ mid=$(sed -n "$((d2_nr / 2 + 1))p" depth2-dirs) &&
+
+ p1=$(dirname "$first") &&
+ p2=$(dirname "$mid") &&
+
+ # Build cone-mode sparse-checkout patterns.
+ {
+ echo "/*" &&
+ echo "!/*/" &&
+ echo "/$p1/" &&
+ echo "!/$p1/*/" &&
+ if test "$p1" != "$p2"
+ then
+ echo "/$p2/" &&
+ echo "!/$p2/*/"
+ fi &&
+ echo "/$first/" &&
+ if test "$first" != "$mid"
+ then
+ echo "/$mid/"
+ fi
+ } >sparse-patterns &&
+
+ git hash-object -w sparse-patterns >sparse-oid &&
+ echo "Sparse cone: $first $mid" &&
+ cat sparse-patterns &&
+ test_set_prereq SPARSE_OID
+ elif test "$top_nr" -ge 1
+ then
+ # Fallback: use a single top-level directory.
+ first=$(sed -n "1p" top-dirs) &&
+ {
+ echo "/*" &&
+ echo "!/*/" &&
+ echo "/$first/"
+ } >sparse-patterns &&
+
+ git hash-object -w sparse-patterns >sparse-oid &&
+ echo "Sparse cone: $first" &&
+ cat sparse-patterns &&
+ test_set_prereq SPARSE_OID
+ fi
+'
+
+test_perf 'repack (no filter)' '
+ git pack-objects --stdout --no-reuse-delta --revs --all </dev/null >pk
+'
+
+test_size 'repack size (no filter)' '
+ test_file_size pk
+'
+
+test_perf 'repack (no filter, --path-walk)' '
+ git pack-objects --stdout --no-reuse-delta --revs --all --path-walk </dev/null >pk
+'
+
+test_size 'repack size (no filter, --path-walk)' '
+ test_file_size pk
+'
+
+test_perf 'repack (blob:none)' '
+ git pack-objects --stdout --no-reuse-delta --revs --all --filter=blob:none </dev/null >pk
+'
+
+test_size 'repack size (blob:none)' '
+ test_file_size pk
+'
+
+test_perf 'repack (blob:none, --path-walk)' '
+ git pack-objects --stdout --no-reuse-delta --revs --all --path-walk \
+ --filter=blob:none </dev/null >pk
+'
+
+test_size 'repack size (blob:none, --path-walk)' '
+ test_file_size pk
+'
+
+test_perf 'repack (sparse:oid)' \
+ --prereq SPARSE_OID '
+ git pack-objects --stdout --no-reuse-delta --revs --all \
+ --filter=sparse:oid=$(cat sparse-oid) </dev/null >pk
+'
+
+test_size 'repack size (sparse:oid)' \
+ --prereq SPARSE_OID '
+ test_file_size pk
+'
+
+test_perf 'repack (sparse:oid, --path-walk)' \
+ --prereq SPARSE_OID '
+ git pack-objects --stdout --no-reuse-delta --revs --all --path-walk \
+ --filter=sparse:oid=$(cat sparse-oid) </dev/null >pk
+'
+
+test_size 'repack size (sparse:oid, --path-walk)' \
+ --prereq SPARSE_OID '
+ test_file_size pk
+'
+
+test_done
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 01/10] pack-objects: pass --objects with --path-walk
From: Derrick Stolee via GitGitGadget @ 2026-05-04 20:21 UTC (permalink / raw)
To: git
Cc: christian.couder, gitster, johannes.schindelin, johncai86,
karthik.188, kristofferhaugsbakk, me, newren, peff, ps,
Derrick Stolee, Derrick Stolee
In-Reply-To: <pull.2101.v2.git.1777926079.gitgitgadget@gmail.com>
From: Derrick Stolee <stolee@gmail.com>
When 'git pack-objects' has the --path-walk option enabled, it uses a
different set of revision walk parameters than normal. For once,
--objects was previously assumed by the path-walk API and was not needed
to be added. We also needed --boundary to allow discovering
UNINTERESTING objects to use as delta bases.
We will be updating the path-walk API soon to work with some filter
options. However, the revision machinery will trigger a fatal error:
fatal: object filtering requires --objects
The fix is easy: add the --objects option as an argument. This has no
effect on the path-walk API but does simplify the revision option
parsing for the objects filter.
We can remove the comment about "removing" the options because they were
never removed and instead not added. We still need to disable using
bitmaps.
Signed-off-by: Derrick Stolee <stolee@gmail.com>
---
builtin/pack-objects.c | 5 +----
1 file changed, 1 insertion(+), 4 deletions(-)
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index dd2480a73d..4338962904 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -5190,10 +5190,7 @@ int cmd_pack_objects(int argc,
}
if (path_walk) {
strvec_push(&rp, "--boundary");
- /*
- * We must disable the bitmaps because we are removing
- * the --objects / --objects-edge[-aggressive] options.
- */
+ strvec_push(&rp, "--objects");
use_bitmap_index = 0;
} else if (thin) {
use_internal_rev_list = 1;
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 00/10] pack-objects: integrate --path-walk and some --filter options
From: Derrick Stolee via GitGitGadget @ 2026-05-04 20:21 UTC (permalink / raw)
To: git
Cc: christian.couder, gitster, johannes.schindelin, johncai86,
karthik.188, kristofferhaugsbakk, me, newren, peff, ps,
Derrick Stolee
In-Reply-To: <pull.2101.git.1777731354.gitgitgadget@gmail.com>
NOTE: This series is based on en/backfill-fixes-and-edges.
The 'git pack-objects' command has a '--path-walk' option that uses the
path-walk API instead of a typical revision walk to group objects into
chunks by path name instead of relying solely on name-hashes to group
similar files together. (It also does a second compression pass looking for
better deltas after the first pass that is focused within chunks per path.)
The '--path-walk' feature was not previously integrated with the '--filter'
feature, so a warning would appear and disable the path-walk API when a
filter is given. This patch series integrates these together in the
following ways:
* --filter=blob:none updates the path-walk API options to skip blobs.
* --filter=blob:limit=<size> adds a scan to a list of blob objects to
remove objects that are too large.
* --filter=sparse:<oid> adds a scan to the chunks to validate that the
paths match the sparse-checkout patterns.
In particular, this last check is significantly faster than the previous
algorithm because it can check all objects at a given path simultaneously
instead of checking all sparse-checkout patterns for each discovered blob
object.
A subtlety must be added here, in that we must change how we mark an object
as "seen" during the path-walk. We may need to add an object to multiple
paths and only mark it as "seen" if it indeed matched the sparse-checkout
patterns as the path is accepted for emitting to the callback. This adds a
new filter that the "seen" objects must also be removed from later chunks to
avoid sending the same object as grouped to multiple chunks.
There's also a subtle detail here in that the path-walk API also prunes tree
paths based on cone-mode sparse-checkouts, to enable 'git backfill --sparse'
operating quickly for small sparse-checkout scopes. But the
--filter=sparse:<oid> feature doesn't prune trees!
As a future step, I do plan to recommend that we add a treesparse:<oid>
setting that does allow us to trim the tree set by cone-mode sparse
patterns. At the time that partial clone filters were being created, cone
mode sparse-checkout didn't exist and neither did the sparse index. Those
features together make a smaller tree set possible, assuming the user never
needs to change their scope. This would be a significant change so it is not
implemented here, though the git pack-objects integration would be quick
after this series completes.
Neither the sparse:<oid> or hypothetical treesparse:<oid> options are or
should necessarily be supported by Git servers. It's too expensive to
compute dynamically and it doesn't work well with reachability bitmaps. What
becomes possible with this change is that it becomes reasonably fast to
construct bundles with these filters that can bootstrap a working
environment with the full history of all files within a given
sparse-checkout scope.
Performance Results
===================
Since the '--path-walk' option is ignored in today's Git version when a
'--filter' is added, the performance matches the behavior without
'--path-walk'. For the tables below, you can compare the rows against each
other (time and then packfile size) for the mode without and then with
'--path-walk' as a representation of "before" and "after". (These tables are
repeated in the commit messages as new implementations improve specific
rows.)
I chose a number of open source repositories of various sizes and shapes:
git/git
=======
Test HEAD
-------------------------------------------------------------------
5315.2: repack (no filter) 27.73
5315.3: repack size (no filter) 250.6M
5315.4: repack (no filter, --path-walk) 35.19
5315.5: repack size (no filter, --path-walk) 220.1M
5315.6: repack (blob:none) 13.42
5315.7: repack size (blob:none) 137.6M
5315.8: repack (blob:none, --path-walk) 20.98
5315.9: repack size (blob:none, --path-walk) 115.2M
5315.10: repack (sparse:oid) 72.53
5315.11: repack size (sparse:oid) 187.5M
5315.12: repack (sparse:oid, --path-walk) 29.00
5315.13: repack size (sparse:oid, --path-walk) 161.0M
nodejs/node
===========
Test HEAD
--------------------------------------------------------------------
5315.2: repack (no filter) 75.53
5315.3: repack size (no filter) 0.9G
5315.4: repack (no filter, --path-walk) 80.54
5315.5: repack size (no filter, --path-walk) 885.7M
5315.6: repack (blob:none) 12.65
5315.7: repack size (blob:none) 148.6M
5315.8: repack (blob:none, --path-walk) 17.60
5315.9: repack size (blob:none, --path-walk) 134.6M
5315.10: repack (sparse:oid) 518.84
5315.11: repack size (sparse:oid) 153.4M
5315.12: repack (sparse:oid, --path-walk) 27.99
5315.13: repack size (sparse:oid, --path-walk) 139.4M
microsoft/fluentui
==================
Test HEAD
--------------------------------------------------------------------
5315.2: repack (no filter) 146.77
5315.3: repack size (no filter) 562.1M
5315.4: repack (no filter, --path-walk) 72.82
5315.5: repack size (no filter, --path-walk) 172.6M
5315.6: repack (blob:none) 4.84
5315.7: repack size (blob:none) 62.7M
5315.8: repack (blob:none, --path-walk) 5.19
5315.9: repack size (blob:none, --path-walk) 59.9M
5315.10: repack (sparse:oid) 59.95
5315.11: repack size (sparse:oid) 85.6M
5315.12: repack (sparse:oid, --path-walk) 15.16
5315.13: repack size (sparse:oid, --path-walk) 72.5M
microsoftdocs/azure-devops-docs
===============================
Test HEAD
---------------------------------------------------------------------
5315.2: repack (no filter) 4.41
5315.3: repack size (no filter) 1.6G
5315.4: repack (no filter, --path-walk) 6.00
5315.5: repack size (no filter, --path-walk) 1.6G
5315.6: repack (blob:none) 1.35
5315.7: repack size (blob:none) 60.0M
5315.8: repack (blob:none, --path-walk) 1.23
5315.9: repack size (blob:none, --path-walk) 60.0M
5315.10: repack (sparse:oid) 138.24
5315.11: repack size (sparse:oid) 84.4M
5315.12: repack (sparse:oid, --path-walk) 1.86
5315.13: repack size (sparse:oid, --path-walk) 84.4M
Performance conclusions
=======================
As seen in earlier series around the '--path-walk' feature, the space
savings can be valuable but is not always guaranteed. When the space savings
doesn't happen, then the time spent is generally slower because of the
two-pass mechanism. The microsoftdocs/azure-devops-docs repo demonstrates
this case quite clearly.
However, even in these cases the 'sparse:<oid>' filters are much faster
because of the ability to check an entire set of objects against the
sparse-checkout patterns only once.
Thanks, -Stolee
UPDATES IN V2
=============
* Rebased onto en/backfill-fixes-and-edges to properly integrate with the
incompatible rev-list options logic in that series.
* Updated documentation as behavior changes. Credit to Taylor Blau for
presenting these suggestions in his RFC [2].
* Added three patches of Taylor's to extend more filter options.
P.S. I've CC'd the folks who were on the original path-walk feature thread
[1]
[1]
https://lore.kernel.org/git/pull.1819.git.1741571455.gitgitgadget@gmail.com/
[2] https://lore.kernel.org/git/cover.1777853408.git.me@ttaylorr.com/
Derrick Stolee (7):
pack-objects: pass --objects with --path-walk
t/perf: add pack-objects filter and path-walk benchmark
path-walk: support blobless filter
backfill: die on incompatible filter options
path-walk: support blob size limit filter
path-walk: add pl_sparse_trees to control tree pruning
pack-objects: support sparse:oid filter with path-walk
Taylor Blau (3):
path-walk: support `tree:0` filter
path-walk: support `object:type` filter
path-walk: support `combine` filter
Documentation/git-backfill.adoc | 4 +
Documentation/git-pack-objects.adoc | 8 +-
builtin/backfill.c | 8 +-
builtin/pack-objects.c | 9 +-
path-walk.c | 201 +++++++++-
path-walk.h | 21 ++
t/helper/test-path-walk.c | 17 +-
t/perf/p5315-pack-objects-filter.sh | 129 +++++++
t/t5317-pack-objects-filter-objects.sh | 125 ++++++
t/t5620-backfill.sh | 8 +
t/t6601-path-walk.sh | 502 +++++++++++++++++++++++++
11 files changed, 1007 insertions(+), 25 deletions(-)
create mode 100755 t/perf/p5315-pack-objects-filter.sh
base-commit: a1ad4a0fca14cdeb55ab9fb065551b15cafa8a4f
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-2101%2Fderrickstolee%2Fpath-walk-filters-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-2101/derrickstolee/path-walk-filters-v2
Pull-Request: https://github.com/gitgitgadget/git/pull/2101
Range-diff vs v1:
1: 29d2797440 = 1: b361680338 pack-objects: pass --objects with --path-walk
2: f364621815 = 2: 9ea81aa726 t/perf: add pack-objects filter and path-walk benchmark
3: b7e72d5dbb ! 3: ed4d277a2c path-walk: support blobless filter
@@ Commit message
passes. This data demonstrates that the feature is engaged and provides
real compression benefits when --no-reuse-delta forces fresh deltas.
+ Co-Authored-by: Taylor Blau <me@ttaylorr.com>
+ Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Derrick Stolee <stolee@gmail.com>
+ ## Documentation/git-pack-objects.adoc ##
+@@ Documentation/git-pack-objects.adoc: will be automatically changed to version `1`.
+ of filenames that cause collisions in Git's default name-hash
+ algorithm.
+ +
+-Incompatible with `--delta-islands`, `--shallow`, or `--filter`. The
+-`--use-bitmap-index` option will be ignored in the presence of
+-`--path-walk.`
++Incompatible with `--delta-islands`. The `--use-bitmap-index` option is
++ignored in the presence of `--path-walk`. Whe `--path-walk` option
++supports the `--filter=<spec>` form `blob:none`.
+
+
+ DELTA ISLANDS
+
## builtin/pack-objects.c ##
@@ builtin/pack-objects.c: int cmd_pack_objects(int argc,
4: 22db528d0c ! 4: da4c19af42 backfill: die on incompatible filter options
@@ Commit message
Signed-off-by: Derrick Stolee <stolee@gmail.com>
## builtin/backfill.c ##
-@@ builtin/backfill.c: int cmd_backfill(int argc, const char **argv, const char *prefix, struct reposit
-
- if (argc > 1)
- die(_("unrecognized argument: %s"), argv[1]);
-+ if (!path_walk_filter_compatible(&ctx.revs.filter))
+@@ builtin/backfill.c: static void reject_unsupported_rev_list_options(struct rev_info *revs)
+ if (revs->explicit_diff_merges)
+ die(_("'%s' cannot be used with 'git backfill'"),
+ "--diff-merges");
+- if (revs->filter.choice)
+- die(_("'%s' cannot be used with 'git backfill'"),
+- "--filter");
++ if (!path_walk_filter_compatible(&revs->filter))
+ die(_("cannot backfill with these filter options"));
+ }
- repo_config(repo, git_default_config, NULL);
-
+ static int do_backfill(struct backfill_context *ctx)
## t/t5620-backfill.sh ##
@@ t/t5620-backfill.sh: test_expect_success 'backfill rejects unexpected arguments' '
5: 2e786160bd ! 5: d309345fec path-walk: support blob size limit filter
@@ Commit message
(which exercises partial filtering within a batch where some blobs are
kept and others are excluded).
+ Co-authored-by: Taylor Blau <me@ttaylorr.com>
+ Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Derrick Stolee <stolee@gmail.com>
+ ## Documentation/git-pack-objects.adoc ##
+@@ Documentation/git-pack-objects.adoc: will be automatically changed to version `1`.
+ +
+ Incompatible with `--delta-islands`. The `--use-bitmap-index` option is
+ ignored in the presence of `--path-walk`. Whe `--path-walk` option
+-supports the `--filter=<spec>` form `blob:none`.
++supports the `--filter=<spec>` form `blob:none` and `blob:limit=<n>`.
+
+
+ DELTA ISLANDS
+
## builtin/backfill.c ##
-@@ builtin/backfill.c: int cmd_backfill(int argc, const char **argv, const char *prefix, struct reposit
- die(_("unrecognized argument: %s"), argv[1]);
- if (!path_walk_filter_compatible(&ctx.revs.filter))
+@@ builtin/backfill.c: static void reject_unsupported_rev_list_options(struct rev_info *revs)
+ "--diff-merges");
+ if (!path_walk_filter_compatible(&revs->filter))
die(_("cannot backfill with these filter options"));
-+ if (ctx.revs.filter.blob_limit_value)
++ if (revs->filter.blob_limit_value)
+ die(_("cannot backfill with blob size limits"));
+ }
- repo_config(repo, git_default_config, NULL);
-
+ static int do_backfill(struct backfill_context *ctx)
## path-walk.c ##
@@
6: c5aca53b23 = 6: 55ed02772b path-walk: add pl_sparse_trees to control tree pruning
7: 859bee39eb ! 7: dcb1a29d3a pack-objects: support sparse:oid filter with path-walk
@@ Commit message
and dramatic time savings (60% faster) by leveraging the path-walk's
ability to skip blobs outside the sparse scope.
+ Co-authored-by: Taylor Blau <me@ttaylorr.com>
+ Signed-off-by: Taylor Blaue <me@ttaylorr.com>
Signed-off-by: Derrick Stolee <stolee@gmail.com>
+ ## Documentation/git-backfill.adoc ##
+@@ Documentation/git-backfill.adoc: OPTIONS
+ +
+ You may also use commit-limiting options understood by
+ linkgit:git-rev-list[1] such as `--first-parent`, `--since`, or pathspecs.
+++
++Most `--filter=<spec>` options don't work with the purpose of
++`git backfill`, but the `sparse:<oid>` filter is integrated to provide a
++focused set of paths to download, distinct from the `--sparse` option.
+
+ SEE ALSO
+ --------
+
+ ## Documentation/git-pack-objects.adoc ##
+@@ Documentation/git-pack-objects.adoc: will be automatically changed to version `1`.
+ +
+ Incompatible with `--delta-islands`. The `--use-bitmap-index` option is
+ ignored in the presence of `--path-walk`. Whe `--path-walk` option
+-supports the `--filter=<spec>` form `blob:none` and `blob:limit=<n>`.
++supports the `--filter=<spec>` form `blob:none`, `blob:limit=<n>`, and
++`sparse:<oid>`.
+
+
+ DELTA ISLANDS
+
## builtin/pack-objects.c ##
@@ builtin/pack-objects.c: static void get_object_list_path_walk(struct rev_info *revs)
result = walk_objects_by_path(&info);
-: ---------- > 8: 772cdcaeed path-walk: support `tree:0` filter
-: ---------- > 9: c557f3c59d path-walk: support `object:type` filter
-: ---------- > 10: 5423273edf path-walk: support `combine` filter
--
gitgitgadget
^ permalink raw reply
* Re: [PATCH v2 11/11] ci: run expensive tests on push builds to integration branches
From: Derrick Stolee @ 2026-05-04 18:35 UTC (permalink / raw)
To: Johannes Schindelin via GitGitGadget, git
Cc: Torsten Bögershausen, Jeff King, Johannes Schindelin
In-Reply-To: <1eaaa7fad7a1432dd97ffdd7c45e8162f61bc302.1777914508.git.gitgitgadget@gmail.com>
On 5/4/2026 1:08 PM, Johannes Schindelin via GitGitGadget wrote:
> From: Johannes Schindelin <johannes.schindelin@gmx.de>
>
> Derrick Stolee suggested [1] that expensive tests should be run at a
> regular cadence rather than on every PR iteration. Gate GIT_TEST_LONG
> on push builds to the integration branches (next, master, main, maint)
> so that the EXPENSIVE prereq is satisfied there but not during PR
> validation, where the extra minutes of wall-clock time do not justify
> themselves.
I like that this will be run as part of regular updates to the
important branches. The important bit after that is whether or
not a human pays attention to the signal of these builds.
Junio: Do you pay attention to CI breaks when you push to
'master'?
One way to help this procedure could be to have GitHub CI
failures trigger new issues, which could then be more easily
viewed and noticed by the community watching the repo. This
is of course out-of-scope for this patch series, but could be
considered in the future.
Thanks,
-Stolee
^ permalink raw reply
* [PATCH] checkout: add --autostash option for branch switching
From: Harald Nordgren @ 2026-05-04 18:28 UTC (permalink / raw)
To: gitster; +Cc: git, gitgitgadget, haraldnordgren
In-Reply-To: <xmqqfr48rubw.fsf@gitster.g>
> I do like the feature that allows you to identify which local
> branches are already merged and prune them. It will help users keep
> their local branch namespace clean.
Nice to hear!
> To break the feature down to make it easier to use by our users with
> various needs and workflows, we would benefit from having a
> collection of smaller features that can be composed, like these:
I gave it a shot to implement these, and then I ran it one some local repos
it works really nicely!
Harald
^ permalink raw reply
* [PATCH v2 6/6] branch: add --all-remotes flag
From: Harald Nordgren via GitGitGadget @ 2026-05-04 18:27 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren, Harald Nordgren
In-Reply-To: <pull.2285.v2.git.git.1777919250.gitgitgadget@gmail.com>
From: Harald Nordgren <haraldnordgren@gmail.com>
Combined with --forked or --prune-merged, --all-remotes acts on
every configured remote, in addition to any explicit <remote>
arguments. Used alone, it errors out.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
---
Documentation/git-branch.adoc | 9 ++++++--
builtin/branch.c | 40 ++++++++++++++++++++++++-----------
t/t3200-branch.sh | 40 +++++++++++++++++++++++++++++++++++
3 files changed, 75 insertions(+), 14 deletions(-)
diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
index 8d3e13d785..87efdefccb 100644
--- a/Documentation/git-branch.adoc
+++ b/Documentation/git-branch.adoc
@@ -24,8 +24,8 @@ git branch (-m|-M) [<old-branch>] <new-branch>
git branch (-c|-C) [<old-branch>] <new-branch>
git branch (-d|-D) [-r] <branch-name>...
git branch --edit-description [<branch-name>]
-git branch --forked <remote>...
-git branch [-f] --prune-merged <remote>...
+git branch --forked (<remote>... | --all-remotes)
+git branch [-f] --prune-merged (<remote>... | --all-remotes)
DESCRIPTION
-----------
@@ -226,6 +226,11 @@ With `--force` (or `-f`), delete them regardless. The currently
checked-out branch in any worktree is always preserved, as is
any branch with `branch.<name>.pruneMerged` set to `false`.
+`--all-remotes`::
+ With `--forked` or `--prune-merged`, act on every
+ configured remote in addition to any explicit _<remote>_
+ arguments.
+
`-v`::
`-vv`::
`--verbose`::
diff --git a/builtin/branch.c b/builtin/branch.c
index 74c8f1aedf..3d70357cf7 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -685,6 +685,13 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
free_worktrees(worktrees);
}
+static int collect_remote_name(struct remote *remote, void *cb_data)
+{
+ struct string_list *remote_names = cb_data;
+ string_list_insert(remote_names, remote->name);
+ return 0;
+}
+
static void parse_forked_args(int argc, const char **argv,
struct string_list *remote_names,
struct string_list *tracking_refs)
@@ -754,7 +761,7 @@ static int collect_forked_branch(const struct reference *ref, void *cb_data)
return 0;
}
-static void collect_forked_set(int argc, const char **argv,
+static void collect_forked_set(int argc, const char **argv, int all_remotes,
struct string_list *out)
{
struct string_list remote_names = STRING_LIST_INIT_NODUP;
@@ -766,6 +773,8 @@ static void collect_forked_set(int argc, const char **argv,
};
parse_forked_args(argc, argv, &remote_names, &tracking_refs);
+ if (all_remotes)
+ for_each_remote(collect_remote_name, &remote_names);
refs_for_each_branch_ref(get_main_ref_store(the_repository),
collect_forked_branch, &cb);
@@ -776,15 +785,15 @@ static void collect_forked_set(int argc, const char **argv,
string_list_clear(&tracking_refs, 0);
}
-static int list_forked_branches(int argc, const char **argv)
+static int list_forked_branches(int argc, const char **argv, int all_remotes)
{
struct string_list out = STRING_LIST_INIT_DUP;
struct string_list_item *item;
- if (!argc)
- die(_("--forked requires at least one <remote>"));
+ if (!argc && !all_remotes)
+ die(_("--forked requires at least one <remote> or --all-remotes"));
- collect_forked_set(argc, argv, &out);
+ collect_forked_set(argc, argv, all_remotes, &out);
for_each_string_list_item(item, &out)
puts(item->string);
@@ -792,8 +801,8 @@ static int list_forked_branches(int argc, const char **argv)
return 0;
}
-static int prune_merged_branches(int argc, const char **argv, int force,
- int quiet)
+static int prune_merged_branches(int argc, const char **argv,
+ int all_remotes, int force, int quiet)
{
struct string_list candidates = STRING_LIST_INIT_DUP;
struct strvec deletable = STRVEC_INIT;
@@ -801,10 +810,10 @@ static int prune_merged_branches(int argc, const char **argv, int force,
int n_not_merged = 0;
int ret = 0;
- if (!argc)
- die(_("--prune-merged requires at least one <remote>"));
+ if (!argc && !all_remotes)
+ die(_("--prune-merged requires at least one <remote> or --all-remotes"));
- collect_forked_set(argc, argv, &candidates);
+ collect_forked_set(argc, argv, all_remotes, &candidates);
for_each_string_list_item(item, &candidates) {
const char *short_name = item->string;
@@ -911,6 +920,7 @@ int cmd_branch(int argc,
unset_upstream = 0, show_current = 0, edit_description = 0;
int forked = 0;
int prune_merged = 0;
+ int all_remotes = 0;
const char *new_upstream = NULL;
int noncreate_actions = 0;
/* possible options */
@@ -968,6 +978,9 @@ int cmd_branch(int argc,
N_("list local branches forked from the given <remote>s")),
OPT_BOOL(0, "prune-merged", &prune_merged,
N_("delete local branches forked from the given <remote>s that are merged into their upstream")),
+ OPT_BOOL_F(0, "all-remotes", &all_remotes,
+ N_("with --forked or --prune-merged, act on every configured remote"),
+ PARSE_OPT_NONEG),
OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
OPT_MERGED(&filter, N_("print only branches that are merged")),
OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
@@ -1011,6 +1024,9 @@ int cmd_branch(int argc,
argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
0);
+ if (all_remotes && !forked && !prune_merged)
+ die(_("--all-remotes requires --forked or --prune-merged"));
+
if (!delete && !rename && !copy && !edit_description && !new_upstream &&
!show_current && !unset_upstream && !forked && !prune_merged &&
argc == 0)
@@ -1064,10 +1080,10 @@ int cmd_branch(int argc,
quiet, 0, NULL);
goto out;
} else if (forked) {
- ret = list_forked_branches(argc, argv);
+ ret = list_forked_branches(argc, argv, all_remotes);
goto out;
} else if (prune_merged) {
- ret = prune_merged_branches(argc, argv, force, quiet);
+ ret = prune_merged_branches(argc, argv, all_remotes, force, quiet);
goto out;
} else if (show_current) {
print_current_branch_name();
diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
index 2127cf1fa5..fa7570d178 100755
--- a/t/t3200-branch.sh
+++ b/t/t3200-branch.sh
@@ -1771,6 +1771,27 @@ test_expect_success '--forked requires at least one <remote>' '
test_grep "at least one <remote>" err
'
+test_expect_success '--forked --all-remotes covers every configured remote' '
+ git -C forked branch --forked --all-remotes >actual &&
+ cat >expect <<-\EOF &&
+ local-foreign
+ local-one
+ local-two
+ main
+ EOF
+ test_cmp expect actual
+'
+
+test_expect_success '--forked --all-remotes still validates explicit <remote>' '
+ test_must_fail git -C forked branch --forked nope --all-remotes 2>err &&
+ test_grep "neither a configured remote nor a remote-tracking ref" err
+'
+
+test_expect_success '--all-remotes alone is rejected' '
+ test_must_fail git -C forked branch --all-remotes 2>err &&
+ test_grep "requires --forked or --prune-merged" err
+'
+
test_expect_success '--prune-merged: setup' '
test_create_repo pm-upstream &&
test_commit -C pm-upstream base &&
@@ -1892,4 +1913,23 @@ test_expect_success 'branch -d still deletes a pruneMerged=false branch' '
test_must_fail git -C pm-optout-d rev-parse --verify refs/heads/one
'
+test_expect_success '--prune-merged --all-remotes covers every configured remote' '
+ test_when_finished "rm -rf pm-allremotes" &&
+ git clone pm-upstream pm-allremotes &&
+ test_create_repo pm-other &&
+ test_commit -C pm-other other-base &&
+ git -C pm-other branch foreign other-base &&
+ git -C pm-allremotes remote add other ../pm-other &&
+ git -C pm-allremotes fetch other &&
+ git -C pm-allremotes branch one --track origin/one &&
+ git -C pm-allremotes branch foreign --track other/foreign &&
+
+ git -C pm-allremotes update-ref -d refs/remotes/origin/one &&
+ git -C pm-allremotes update-ref -d refs/remotes/other/foreign &&
+ git -C pm-allremotes branch --force --prune-merged --all-remotes &&
+
+ test_must_fail git -C pm-allremotes rev-parse --verify refs/heads/one &&
+ test_must_fail git -C pm-allremotes rev-parse --verify refs/heads/foreign
+'
+
test_done
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 5/6] branch: add branch.<name>.pruneMerged opt-out
From: Harald Nordgren via GitGitGadget @ 2026-05-04 18:27 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren, Harald Nordgren
In-Reply-To: <pull.2285.v2.git.git.1777919250.gitgitgadget@gmail.com>
From: Harald Nordgren <haraldnordgren@gmail.com>
Setting branch.<name>.pruneMerged=false exempts that branch from
--prune-merged (and from fetch --prune-merged), even with --force.
Useful for keeping a topic branch around between rounds.
Explicit deletion via 'git branch -d' is unaffected.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
---
Documentation/config/branch.adoc | 7 ++++++
Documentation/git-branch.adoc | 17 +++++++-------
builtin/branch.c | 23 ++++++++++++++++--
t/t3200-branch.sh | 40 ++++++++++++++++++++++++++++++++
4 files changed, 76 insertions(+), 11 deletions(-)
diff --git a/Documentation/config/branch.adoc b/Documentation/config/branch.adoc
index a4db9fa5c8..60dba38e27 100644
--- a/Documentation/config/branch.adoc
+++ b/Documentation/config/branch.adoc
@@ -102,3 +102,10 @@ for details).
`git branch --edit-description`. Branch description is
automatically added to the `format-patch` cover letter or
`request-pull` summary.
+
+`branch.<name>.pruneMerged`::
+ If set to `false`, branch _<name>_ is exempt from
+ `git branch --prune-merged` (and `git fetch --prune-merged`).
+ Useful for topic branches you intend to develop further after
+ an initial round has been merged upstream. Defaults to true.
+ Explicit deletion via `git branch -d` is unaffected.
diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
index 4995e03ef6..8d3e13d785 100644
--- a/Documentation/git-branch.adoc
+++ b/Documentation/git-branch.adoc
@@ -216,16 +216,15 @@ Each _<remote>_ may be either the name of a configured remote
Delete the local branches that `--forked` would list for
the same _<remote>_ arguments, but only when the branch's
push destination remote-tracking ref (the ref `git push`
- would update; see `branch_get_push` semantics) no longer
- resolves locally. In other words: the branch was pushed
- under some name on _<remote>_, and that name has since
- been pruned upstream.
+ would update) no longer resolves locally. In other words:
+ the branch was pushed under some name on _<remote>_, and
+ that name has since been pruned upstream.
+
-By default, the local tip must also be reachable from the
-upstream remote-tracking ref (see `--no-merged`); branches with
-unpushed commits are refused. With `--force` (or `-f`), delete
-them regardless. The currently checked-out branch in any worktree
-is always preserved.
+The local tip must also be reachable from the upstream
+remote-tracking ref; branches with unpushed commits are refused.
+With `--force` (or `-f`), delete them regardless. The currently
+checked-out branch in any worktree is always preserved, as is
+any branch with `branch.<name>.pruneMerged` set to `false`.
`-v`::
`-vv`::
diff --git a/builtin/branch.c b/builtin/branch.c
index f50b7e222c..74c8f1aedf 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -809,23 +809,42 @@ static int prune_merged_branches(int argc, const char **argv, int force,
for_each_string_list_item(item, &candidates) {
const char *short_name = item->string;
struct strbuf full = STRBUF_INIT;
+ struct strbuf key = STRBUF_INIT;
struct branch *branch;
const char *push_ref;
+ int opt_out = 0;
strbuf_addf(&full, "refs/heads/%s", short_name);
if (branch_checked_out(full.buf)) {
strbuf_release(&full);
+ strbuf_release(&key);
continue;
}
strbuf_release(&full);
branch = branch_get(short_name);
push_ref = branch ? branch_get_push(branch, NULL) : NULL;
- if (!push_ref)
+ if (!push_ref) {
+ strbuf_release(&key);
continue;
+ }
if (refs_ref_exists(get_main_ref_store(the_repository),
- push_ref))
+ push_ref)) {
+ strbuf_release(&key);
+ continue;
+ }
+
+ strbuf_addf(&key, "branch.%s.prunemerged", short_name);
+ if (!repo_config_get_bool(the_repository, key.buf, &opt_out) &&
+ !opt_out) {
+ if (!quiet)
+ fprintf(stderr, _("Skipping '%s' "
+ "(branch.%s.pruneMerged is false)\n"),
+ short_name, short_name);
+ strbuf_release(&key);
continue;
+ }
+ strbuf_release(&key);
strvec_push(&deletable, short_name);
}
diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
index 9e997b6be6..2127cf1fa5 100755
--- a/t/t3200-branch.sh
+++ b/t/t3200-branch.sh
@@ -1852,4 +1852,44 @@ test_expect_success '--prune-merged deletes when push ref differs from upstream'
test_must_fail git -C pm-pushdiff rev-parse --verify refs/heads/topic-a
'
+test_expect_success '--prune-merged honours branch.<name>.pruneMerged=false' '
+ test_when_finished "rm -rf pm-optout" &&
+ git clone pm-upstream pm-optout &&
+ git -C pm-optout branch one --track origin/one &&
+ git -C pm-optout branch two --track origin/two &&
+ git -C pm-optout config branch.one.pruneMerged false &&
+
+ git -C pm-optout update-ref -d refs/remotes/origin/one &&
+ git -C pm-optout update-ref -d refs/remotes/origin/two &&
+ git -C pm-optout branch --prune-merged origin 2>err &&
+
+ git -C pm-optout rev-parse --verify refs/heads/one &&
+ test_must_fail git -C pm-optout rev-parse --verify refs/heads/two &&
+ test_grep "Skipping .one." err
+'
+
+test_expect_success '--prune-merged --force still honours pruneMerged=false' '
+ test_when_finished "rm -rf pm-optout-force" &&
+ git clone pm-upstream pm-optout-force &&
+ git -C pm-optout-force checkout -b one --track origin/one &&
+ test_commit -C pm-optout-force unpushed &&
+ git -C pm-optout-force checkout - &&
+ git -C pm-optout-force config branch.one.pruneMerged false &&
+
+ git -C pm-optout-force update-ref -d refs/remotes/origin/one &&
+ git -C pm-optout-force branch --force --prune-merged origin &&
+
+ git -C pm-optout-force rev-parse --verify refs/heads/one
+'
+
+test_expect_success 'branch -d still deletes a pruneMerged=false branch' '
+ test_when_finished "rm -rf pm-optout-d" &&
+ git clone pm-upstream pm-optout-d &&
+ git -C pm-optout-d branch one --track origin/one &&
+ git -C pm-optout-d config branch.one.pruneMerged false &&
+
+ git -C pm-optout-d branch -d one &&
+ test_must_fail git -C pm-optout-d rev-parse --verify refs/heads/one
+'
+
test_done
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 4/6] fetch: add --prune-merged
From: Harald Nordgren via GitGitGadget @ 2026-05-04 18:27 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren, Harald Nordgren
In-Reply-To: <pull.2285.v2.git.git.1777919250.gitgitgadget@gmail.com>
From: Harald Nordgren <haraldnordgren@gmail.com>
After a successful fetch from a configured remote, run
'git branch --prune-merged <remote>' to delete local branches
whose push destination ref has just been pruned.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
---
Documentation/fetch-options.adoc | 8 ++++++++
builtin/fetch.c | 20 ++++++++++++++++++++
t/t5510-fetch.sh | 31 +++++++++++++++++++++++++++++++
3 files changed, 59 insertions(+)
diff --git a/Documentation/fetch-options.adoc b/Documentation/fetch-options.adoc
index 81a9d7f9bb..d863a9184e 100644
--- a/Documentation/fetch-options.adoc
+++ b/Documentation/fetch-options.adoc
@@ -185,6 +185,14 @@ See the PRUNING section below for more details.
+
See the PRUNING section below for more details.
+`--prune-merged`::
+ After a successful fetch, run `git branch --prune-merged
+ <remote>` for the fetched remote, deleting local branches
+ that fork from this remote and whose tip is reachable from
+ their upstream remote-tracking ref. See linkgit:git-branch[1]
+ for the exact selection rules. The currently checked-out
+ branch is always preserved.
+
endif::git-pull[]
ifndef::git-pull[]
diff --git a/builtin/fetch.c b/builtin/fetch.c
index a22c319467..5451bf3b5b 100644
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -82,6 +82,8 @@ static int prune = -1; /* unspecified */
static int prune_tags = -1; /* unspecified */
#define PRUNE_TAGS_BY_DEFAULT 0 /* do we prune tags by default? */
+static int prune_merged;
+
static int append, dry_run, force, keep, update_head_ok;
static int write_fetch_head = 1;
static int verbosity, deepen_relative, set_upstream, refetch;
@@ -2189,6 +2191,8 @@ static void add_options_to_argv(struct strvec *argv,
strvec_push(argv, prune ? "--prune" : "--no-prune");
if (prune_tags != -1)
strvec_push(argv, prune_tags ? "--prune-tags" : "--no-prune-tags");
+ if (prune_merged)
+ strvec_push(argv, "--prune-merged");
if (update_head_ok)
strvec_push(argv, "--update-head-ok");
if (force)
@@ -2382,6 +2386,15 @@ static inline void fetch_one_setup_partial(struct remote *remote,
return;
}
+static int prune_merged_for_remote(const struct remote *remote)
+{
+ struct child_process cmd = CHILD_PROCESS_INIT;
+
+ cmd.git_cmd = 1;
+ strvec_pushl(&cmd.args, "branch", "--prune-merged", remote->name, NULL);
+ return run_command(&cmd);
+}
+
static int fetch_one(struct remote *remote, int argc, const char **argv,
int prune_tags_ok, int use_stdin_refspecs,
const struct fetch_config *config,
@@ -2457,6 +2470,11 @@ static int fetch_one(struct remote *remote, int argc, const char **argv,
refspec_clear(&rs);
transport_disconnect(gtransport);
gtransport = NULL;
+
+ if (!exit_code && prune_merged && remote_via_config &&
+ prune_merged_for_remote(remote))
+ exit_code = 1;
+
return exit_code;
}
@@ -2520,6 +2538,8 @@ int cmd_fetch(int argc,
N_("prune remote-tracking branches no longer on remote")),
OPT_BOOL('P', "prune-tags", &prune_tags,
N_("prune local tags no longer on remote and clobber changed tags")),
+ OPT_BOOL(0, "prune-merged", &prune_merged,
+ N_("after pruning, also delete local branches forked from this remote whose tips are reachable from their upstream")),
OPT_CALLBACK_F(0, "recurse-submodules", &recurse_submodules_cli, N_("on-demand"),
N_("control recursive fetching of submodules"),
PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules),
diff --git a/t/t5510-fetch.sh b/t/t5510-fetch.sh
index 6fe21e2b3a..b94fd2bda0 100755
--- a/t/t5510-fetch.sh
+++ b/t/t5510-fetch.sh
@@ -386,6 +386,37 @@ test_expect_success REFFILES 'fetch --prune fails to delete branches' '
)
'
+test_expect_success 'fetch --prune-merged: setup' '
+ git init -b main fetch-pm-parent &&
+ test_commit -C fetch-pm-parent base
+'
+
+test_expect_success 'fetch --prune-merged deletes merged local branches' '
+ test_when_finished "rm -rf fetch-pm-clone" &&
+ git -C fetch-pm-parent branch one base &&
+ git clone fetch-pm-parent fetch-pm-clone &&
+ git -C fetch-pm-clone branch one --track origin/one &&
+ git -C fetch-pm-parent branch -D one &&
+
+ git -C fetch-pm-clone fetch --prune --prune-merged origin &&
+
+ test_must_fail git -C fetch-pm-clone rev-parse --verify refs/heads/one
+'
+
+test_expect_success 'fetch --prune-merged skips unmerged local branches' '
+ test_when_finished "rm -rf fetch-pm-unmerged" &&
+ git -C fetch-pm-parent branch two base &&
+ git clone fetch-pm-parent fetch-pm-unmerged &&
+ git -C fetch-pm-unmerged checkout -b two --track origin/two &&
+ test_commit -C fetch-pm-unmerged unpushed &&
+ git -C fetch-pm-unmerged checkout - &&
+ git -C fetch-pm-parent branch -D two &&
+
+ git -C fetch-pm-unmerged fetch --prune --prune-merged origin 2>err &&
+ test_grep "not fully merged" err &&
+ git -C fetch-pm-unmerged rev-parse --verify refs/heads/two
+'
+
test_expect_success 'fetch --atomic works with a single branch' '
test_when_finished "rm -rf atomic" &&
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 3/6] branch: add --prune-merged <remote>
From: Harald Nordgren via GitGitGadget @ 2026-05-04 18:27 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren, Harald Nordgren
In-Reply-To: <pull.2285.v2.git.git.1777919250.gitgitgadget@gmail.com>
From: Harald Nordgren <haraldnordgren@gmail.com>
Delete the local branches that --forked <remote> would list,
refusing any whose tip is not reachable from its upstream
remote-tracking ref. With --force, delete unconditionally. The
currently checked-out branch in any worktree is always preserved.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
---
Documentation/git-branch.adoc | 16 ++++++
builtin/branch.c | 97 ++++++++++++++++++++++++++++++-----
t/t3200-branch.sh | 81 +++++++++++++++++++++++++++++
3 files changed, 182 insertions(+), 12 deletions(-)
diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
index a79f5552dd..4995e03ef6 100644
--- a/Documentation/git-branch.adoc
+++ b/Documentation/git-branch.adoc
@@ -25,6 +25,7 @@ git branch (-c|-C) [<old-branch>] <new-branch>
git branch (-d|-D) [-r] <branch-name>...
git branch --edit-description [<branch-name>]
git branch --forked <remote>...
+git branch [-f] --prune-merged <remote>...
DESCRIPTION
-----------
@@ -211,6 +212,21 @@ Each _<remote>_ may be either the name of a configured remote
`refs/remotes/origin/*` ref) or a specific remote-tracking ref
(e.g. `origin/master`). Multiple _<remote>_ arguments are unioned.
+`--prune-merged`::
+ Delete the local branches that `--forked` would list for
+ the same _<remote>_ arguments, but only when the branch's
+ push destination remote-tracking ref (the ref `git push`
+ would update; see `branch_get_push` semantics) no longer
+ resolves locally. In other words: the branch was pushed
+ under some name on _<remote>_, and that name has since
+ been pruned upstream.
++
+By default, the local tip must also be reachable from the
+upstream remote-tracking ref (see `--no-merged`); branches with
+unpushed commits are refused. With `--force` (or `-f`), delete
+them regardless. The currently checked-out branch in any worktree
+is always preserved.
+
`-v`::
`-vv`::
`--verbose`::
diff --git a/builtin/branch.c b/builtin/branch.c
index 176dccb8be..f50b7e222c 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -21,6 +21,7 @@
#include "branch.h"
#include "path.h"
#include "string-list.h"
+#include "strvec.h"
#include "column.h"
#include "utf8.h"
#include "ref-filter.h"
@@ -753,36 +754,101 @@ static int collect_forked_branch(const struct reference *ref, void *cb_data)
return 0;
}
-static int list_forked_branches(int argc, const char **argv)
+static void collect_forked_set(int argc, const char **argv,
+ struct string_list *out)
{
struct string_list remote_names = STRING_LIST_INIT_NODUP;
struct string_list tracking_refs = STRING_LIST_INIT_DUP;
- struct string_list out = STRING_LIST_INIT_DUP;
- struct string_list_item *item;
struct forked_cb cb = {
.remote_names = &remote_names,
.tracking_refs = &tracking_refs,
- .out = &out,
+ .out = out,
};
- if (!argc)
- die(_("--forked requires at least one <remote>"));
-
parse_forked_args(argc, argv, &remote_names, &tracking_refs);
refs_for_each_branch_ref(get_main_ref_store(the_repository),
collect_forked_branch, &cb);
- string_list_sort(&out);
- for_each_string_list_item(item, &out)
- puts(item->string);
+ string_list_sort(out);
string_list_clear(&remote_names, 0);
string_list_clear(&tracking_refs, 0);
+}
+
+static int list_forked_branches(int argc, const char **argv)
+{
+ struct string_list out = STRING_LIST_INIT_DUP;
+ struct string_list_item *item;
+
+ if (!argc)
+ die(_("--forked requires at least one <remote>"));
+
+ collect_forked_set(argc, argv, &out);
+ for_each_string_list_item(item, &out)
+ puts(item->string);
+
string_list_clear(&out, 0);
return 0;
}
+static int prune_merged_branches(int argc, const char **argv, int force,
+ int quiet)
+{
+ struct string_list candidates = STRING_LIST_INIT_DUP;
+ struct strvec deletable = STRVEC_INIT;
+ struct string_list_item *item;
+ int n_not_merged = 0;
+ int ret = 0;
+
+ if (!argc)
+ die(_("--prune-merged requires at least one <remote>"));
+
+ collect_forked_set(argc, argv, &candidates);
+
+ for_each_string_list_item(item, &candidates) {
+ const char *short_name = item->string;
+ struct strbuf full = STRBUF_INIT;
+ struct branch *branch;
+ const char *push_ref;
+
+ strbuf_addf(&full, "refs/heads/%s", short_name);
+ if (branch_checked_out(full.buf)) {
+ strbuf_release(&full);
+ continue;
+ }
+ strbuf_release(&full);
+
+ branch = branch_get(short_name);
+ push_ref = branch ? branch_get_push(branch, NULL) : NULL;
+ if (!push_ref)
+ continue;
+ if (refs_ref_exists(get_main_ref_store(the_repository),
+ push_ref))
+ continue;
+
+ strvec_push(&deletable, short_name);
+ }
+
+ if (deletable.nr)
+ ret = delete_branches(deletable.nr, deletable.v, force,
+ FILTER_REFS_BRANCHES, quiet,
+ 1, &n_not_merged);
+
+ if (n_not_merged && !quiet)
+ fprintf(stderr,
+ Q_("Skipped %d branch that is not fully merged; "
+ "re-run with --force to delete it anyway.\n",
+ "Skipped %d branches that are not fully merged; "
+ "re-run with --force to delete them anyway.\n",
+ n_not_merged),
+ n_not_merged);
+
+ strvec_clear(&deletable);
+ string_list_clear(&candidates, 0);
+ return ret;
+}
+
static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
static int edit_branch_description(const char *branch_name)
@@ -825,6 +891,7 @@ int cmd_branch(int argc,
int delete = 0, rename = 0, copy = 0, list = 0,
unset_upstream = 0, show_current = 0, edit_description = 0;
int forked = 0;
+ int prune_merged = 0;
const char *new_upstream = NULL;
int noncreate_actions = 0;
/* possible options */
@@ -880,6 +947,8 @@ int cmd_branch(int argc,
N_("edit the description for the branch")),
OPT_BOOL(0, "forked", &forked,
N_("list local branches forked from the given <remote>s")),
+ OPT_BOOL(0, "prune-merged", &prune_merged,
+ N_("delete local branches forked from the given <remote>s that are merged into their upstream")),
OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
OPT_MERGED(&filter, N_("print only branches that are merged")),
OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
@@ -924,7 +993,8 @@ int cmd_branch(int argc,
0);
if (!delete && !rename && !copy && !edit_description && !new_upstream &&
- !show_current && !unset_upstream && !forked && argc == 0)
+ !show_current && !unset_upstream && !forked && !prune_merged &&
+ argc == 0)
list = 1;
if (filter.with_commit || filter.no_commit ||
@@ -933,7 +1003,7 @@ int cmd_branch(int argc,
noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
!!show_current + !!list + !!edit_description +
- !!unset_upstream + !!forked;
+ !!unset_upstream + !!forked + !!prune_merged;
if (noncreate_actions > 1)
usage_with_options(builtin_branch_usage, options);
@@ -977,6 +1047,9 @@ int cmd_branch(int argc,
} else if (forked) {
ret = list_forked_branches(argc, argv);
goto out;
+ } else if (prune_merged) {
+ ret = prune_merged_branches(argc, argv, force, quiet);
+ goto out;
} else if (show_current) {
print_current_branch_name();
ret = 0;
diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
index 3e4c8e4473..9e997b6be6 100755
--- a/t/t3200-branch.sh
+++ b/t/t3200-branch.sh
@@ -1771,4 +1771,85 @@ test_expect_success '--forked requires at least one <remote>' '
test_grep "at least one <remote>" err
'
+test_expect_success '--prune-merged: setup' '
+ test_create_repo pm-upstream &&
+ test_commit -C pm-upstream base &&
+ git -C pm-upstream branch one base &&
+ git -C pm-upstream branch two base
+'
+
+test_expect_success '--prune-merged deletes branches whose push ref is gone' '
+ test_when_finished "rm -rf pm-clean" &&
+ git clone pm-upstream pm-clean &&
+ git -C pm-clean branch one --track origin/one &&
+ git -C pm-clean branch two --track origin/two &&
+
+ git -C pm-clean update-ref -d refs/remotes/origin/one &&
+ git -C pm-clean branch --prune-merged origin &&
+
+ test_must_fail git -C pm-clean rev-parse --verify refs/heads/one &&
+ git -C pm-clean rev-parse --verify refs/heads/two
+'
+
+test_expect_success '--prune-merged spares in-flight branches whose push ref still exists' '
+ test_when_finished "rm -rf pm-inflight" &&
+ git clone pm-upstream pm-inflight &&
+ git -C pm-inflight branch one --track origin/one &&
+
+ git -C pm-inflight branch --prune-merged origin &&
+
+ git -C pm-inflight rev-parse --verify refs/heads/one
+'
+
+test_expect_success '--prune-merged skips branches with unpushed commits' '
+ test_when_finished "rm -rf pm-unmerged" &&
+ git clone pm-upstream pm-unmerged &&
+ git -C pm-unmerged checkout -b one --track origin/one &&
+ test_commit -C pm-unmerged unpushed &&
+ git -C pm-unmerged checkout - &&
+
+ git -C pm-unmerged update-ref -d refs/remotes/origin/one &&
+ git -C pm-unmerged branch --prune-merged origin 2>err &&
+ test_grep "not fully merged" err &&
+ test_grep "Skipped 1 branch" err &&
+ test_grep "re-run with --force" err &&
+ test_grep ! "If you are sure you want to delete it" err &&
+ git -C pm-unmerged rev-parse --verify refs/heads/one
+'
+
+test_expect_success '--prune-merged --force deletes branches with unpushed commits' '
+ test_when_finished "rm -rf pm-force" &&
+ git clone pm-upstream pm-force &&
+ git -C pm-force checkout -b one --track origin/one &&
+ test_commit -C pm-force unpushed &&
+ git -C pm-force checkout - &&
+
+ git -C pm-force update-ref -d refs/remotes/origin/one &&
+ git -C pm-force branch --force --prune-merged origin &&
+
+ test_must_fail git -C pm-force rev-parse --verify refs/heads/one
+'
+
+test_expect_success '--prune-merged never deletes the checked-out branch' '
+ test_when_finished "rm -rf pm-head" &&
+ git clone pm-upstream pm-head &&
+ git -C pm-head checkout -b one --track origin/one &&
+
+ git -C pm-head update-ref -d refs/remotes/origin/one &&
+ git -C pm-head branch --force --prune-merged origin &&
+
+ git -C pm-head rev-parse --verify refs/heads/one
+'
+
+test_expect_success '--prune-merged deletes when push ref differs from upstream' '
+ test_when_finished "rm -rf pm-pushdiff" &&
+ git clone pm-upstream pm-pushdiff &&
+ git -C pm-pushdiff config push.default current &&
+ git -C pm-pushdiff branch --track topic-a origin/main &&
+
+ git -C pm-pushdiff branch --force --prune-merged origin &&
+
+ test_must_fail git -C pm-pushdiff rev-parse --verify refs/heads/topic-a
+'
+
test_done
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 2/6] branch: let delete_branches warn instead of error on bulk refusal
From: Harald Nordgren via GitGitGadget @ 2026-05-04 18:27 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren, Harald Nordgren
In-Reply-To: <pull.2285.v2.git.git.1777919250.gitgitgadget@gmail.com>
From: Harald Nordgren <haraldnordgren@gmail.com>
Add two new parameters to delete_branches() and the helper
check_branch_commit():
* warn_only switches the per-branch refusal from a hard error
("error: the branch 'X' is not fully merged" plus a four-line
hint about 'git branch -D X') to a one-line warning, and
causes the function to skip those branches without setting its
exit code. Each refused branch is still skipped from deletion.
* n_not_merged, when non-NULL, is incremented for each branch
refused on the not-merged path, so a bulk caller can summarize
rather than print per-branch advice.
All existing call sites pass 0 / NULL and so are unaffected. Both
parameters are wired up so a bulk-deletion caller can suppress
the noise normally appropriate for a one-shot 'git branch -d'.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
---
builtin/branch.c | 29 ++++++++++++++++++++---------
1 file changed, 20 insertions(+), 9 deletions(-)
diff --git a/builtin/branch.c b/builtin/branch.c
index 03b15452e9..176dccb8be 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -192,7 +192,8 @@ static int branch_merged(int kind, const char *name,
static int check_branch_commit(const char *branchname, const char *refname,
const struct object_id *oid, struct commit *head_rev,
- int kinds, int force)
+ int kinds, int force, int warn_only,
+ int *n_not_merged)
{
struct commit *rev = lookup_commit_reference(the_repository, oid);
if (!force && !rev) {
@@ -200,10 +201,18 @@ static int check_branch_commit(const char *branchname, const char *refname,
return -1;
}
if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
- error(_("the branch '%s' is not fully merged"), branchname);
- advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
- _("If you are sure you want to delete it, "
- "run 'git branch -D %s'"), branchname);
+ if (warn_only) {
+ warning(_("the branch '%s' is not fully merged"),
+ branchname);
+ } else {
+ error(_("the branch '%s' is not fully merged"),
+ branchname);
+ advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
+ _("If you are sure you want to delete it, "
+ "run 'git branch -D %s'"), branchname);
+ }
+ if (n_not_merged)
+ (*n_not_merged)++;
return -1;
}
return 0;
@@ -219,7 +228,7 @@ static void delete_branch_config(const char *branchname)
}
static int delete_branches(int argc, const char **argv, int force, int kinds,
- int quiet)
+ int quiet, int warn_only, int *n_not_merged)
{
struct commit *head_rev = NULL;
struct object_id oid;
@@ -309,8 +318,9 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
if (!(flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
- force)) {
- ret = 1;
+ force, warn_only, n_not_merged)) {
+ if (!warn_only)
+ ret = 1;
goto next;
}
@@ -961,7 +971,8 @@ int cmd_branch(int argc,
if (delete) {
if (!argc)
die(_("branch name required"));
- ret = delete_branches(argc, argv, delete > 1, filter.kind, quiet);
+ ret = delete_branches(argc, argv, delete > 1, filter.kind,
+ quiet, 0, NULL);
goto out;
} else if (forked) {
ret = list_forked_branches(argc, argv);
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 1/6] branch: add --forked <remote>
From: Harald Nordgren via GitGitGadget @ 2026-05-04 18:27 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren, Harald Nordgren
In-Reply-To: <pull.2285.v2.git.git.1777919250.gitgitgadget@gmail.com>
From: Harald Nordgren <haraldnordgren@gmail.com>
List local branches whose configured upstream falls within any of
the given <remote> arguments. <remote> may be either a configured
remote name (matching all of its remote-tracking refs) or a single
remote-tracking ref. Multiple <remote> arguments are unioned.
This is the building block for --prune-merged, which deletes the
listed branches.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
---
Documentation/git-branch.adoc | 12 ++++
builtin/branch.c | 110 +++++++++++++++++++++++++++++++++-
t/t3200-branch.sh | 54 +++++++++++++++++
3 files changed, 174 insertions(+), 2 deletions(-)
diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
index c0afddc424..a79f5552dd 100644
--- a/Documentation/git-branch.adoc
+++ b/Documentation/git-branch.adoc
@@ -24,6 +24,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
git branch (-c|-C) [<old-branch>] <new-branch>
git branch (-d|-D) [-r] <branch-name>...
git branch --edit-description [<branch-name>]
+git branch --forked <remote>...
DESCRIPTION
-----------
@@ -199,6 +200,17 @@ This option is only applicable in non-verbose mode.
Print the name of the current branch. In detached `HEAD` state,
nothing is printed.
+`--forked`::
+ List local branches that fork from any of the given _<remote>_
+ arguments, that is, those whose configured upstream
+ (`branch.<name>.merge`) is one of those remotes' remote-tracking
+ refs.
++
+Each _<remote>_ may be either the name of a configured remote
+(e.g. `origin`, meaning any branch tracking a
+`refs/remotes/origin/*` ref) or a specific remote-tracking ref
+(e.g. `origin/master`). Multiple _<remote>_ arguments are unioned.
+
`-v`::
`-vv`::
`--verbose`::
diff --git a/builtin/branch.c b/builtin/branch.c
index 1572a4f9ef..03b15452e9 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -38,6 +38,7 @@ static const char * const builtin_branch_usage[] = {
N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
N_("git branch [<options>] [-r | -a] [--points-at]"),
N_("git branch [<options>] [-r | -a] [--format]"),
+ N_("git branch [<options>] --forked <remote>..."),
NULL
};
@@ -673,6 +674,105 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
free_worktrees(worktrees);
}
+static void parse_forked_args(int argc, const char **argv,
+ struct string_list *remote_names,
+ struct string_list *tracking_refs)
+{
+ int i;
+
+ for (i = 0; i < argc; i++) {
+ const char *arg = argv[i];
+ struct remote *remote;
+ struct object_id oid;
+ char *full_ref = NULL;
+
+ remote = remote_get(arg);
+ if (remote && remote_is_configured(remote, 0)) {
+ string_list_insert(remote_names, remote->name);
+ continue;
+ }
+
+ if (repo_dwim_ref(the_repository, arg, strlen(arg), &oid,
+ &full_ref, 0) == 1 &&
+ starts_with(full_ref, "refs/remotes/")) {
+ string_list_insert(tracking_refs, full_ref);
+ free(full_ref);
+ continue;
+ }
+ free(full_ref);
+
+ die(_("'%s' is neither a configured remote nor a "
+ "remote-tracking ref"), arg);
+ }
+}
+
+static int branch_is_forked(const char *short_name,
+ const struct string_list *remote_names,
+ const struct string_list *tracking_refs)
+{
+ struct branch *branch = branch_get(short_name);
+ const char *upstream;
+
+ if (!branch || !branch->remote_name)
+ return 0;
+
+ if (string_list_has_string(remote_names, branch->remote_name))
+ return 1;
+
+ upstream = branch_get_upstream(branch, NULL);
+ if (upstream && string_list_has_string(tracking_refs, upstream))
+ return 1;
+
+ return 0;
+}
+
+struct forked_cb {
+ const struct string_list *remote_names;
+ const struct string_list *tracking_refs;
+ struct string_list *out;
+};
+
+static int collect_forked_branch(const struct reference *ref, void *cb_data)
+{
+ struct forked_cb *cb = cb_data;
+
+ if (ref->flags & REF_ISSYMREF)
+ return 0;
+ if (branch_is_forked(ref->name, cb->remote_names, cb->tracking_refs))
+ string_list_append(cb->out, ref->name);
+ return 0;
+}
+
+static int list_forked_branches(int argc, const char **argv)
+{
+ struct string_list remote_names = STRING_LIST_INIT_NODUP;
+ struct string_list tracking_refs = STRING_LIST_INIT_DUP;
+ struct string_list out = STRING_LIST_INIT_DUP;
+ struct string_list_item *item;
+ struct forked_cb cb = {
+ .remote_names = &remote_names,
+ .tracking_refs = &tracking_refs,
+ .out = &out,
+ };
+
+ if (!argc)
+ die(_("--forked requires at least one <remote>"));
+
+ parse_forked_args(argc, argv, &remote_names, &tracking_refs);
+
+ refs_for_each_branch_ref(get_main_ref_store(the_repository),
+ collect_forked_branch, &cb);
+
+ string_list_sort(&out);
+ for_each_string_list_item(item, &out)
+ puts(item->string);
+
+ string_list_clear(&remote_names, 0);
+ string_list_clear(&tracking_refs, 0);
+ string_list_clear(&out, 0);
+ return 0;
+}
+
static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
static int edit_branch_description(const char *branch_name)
@@ -714,6 +814,7 @@ int cmd_branch(int argc,
/* possible actions */
int delete = 0, rename = 0, copy = 0, list = 0,
unset_upstream = 0, show_current = 0, edit_description = 0;
+ int forked = 0;
const char *new_upstream = NULL;
int noncreate_actions = 0;
/* possible options */
@@ -767,6 +868,8 @@ int cmd_branch(int argc,
OPT_BOOL(0, "create-reflog", &reflog, N_("create the branch's reflog")),
OPT_BOOL(0, "edit-description", &edit_description,
N_("edit the description for the branch")),
+ OPT_BOOL(0, "forked", &forked,
+ N_("list local branches forked from the given <remote>s")),
OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
OPT_MERGED(&filter, N_("print only branches that are merged")),
OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
@@ -811,7 +914,7 @@ int cmd_branch(int argc,
0);
if (!delete && !rename && !copy && !edit_description && !new_upstream &&
- !show_current && !unset_upstream && argc == 0)
+ !show_current && !unset_upstream && !forked && argc == 0)
list = 1;
if (filter.with_commit || filter.no_commit ||
@@ -820,7 +923,7 @@ int cmd_branch(int argc,
noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
!!show_current + !!list + !!edit_description +
- !!unset_upstream;
+ !!unset_upstream + !!forked;
if (noncreate_actions > 1)
usage_with_options(builtin_branch_usage, options);
@@ -860,6 +963,9 @@ int cmd_branch(int argc,
die(_("branch name required"));
ret = delete_branches(argc, argv, delete > 1, filter.kind, quiet);
goto out;
+ } else if (forked) {
+ ret = list_forked_branches(argc, argv);
+ goto out;
} else if (show_current) {
print_current_branch_name();
ret = 0;
diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
index e7829c2c4b..3e4c8e4473 100755
--- a/t/t3200-branch.sh
+++ b/t/t3200-branch.sh
@@ -1717,4 +1717,58 @@ test_expect_success 'errors if given a bad branch name' '
test_cmp expect actual
'
+test_expect_success '--forked: setup' '
+ test_create_repo forked-upstream &&
+ test_commit -C forked-upstream base &&
+ git -C forked-upstream branch one base &&
+ git -C forked-upstream branch two base &&
+
+ test_create_repo forked-other &&
+ test_commit -C forked-other other-base &&
+ git -C forked-other branch foreign other-base &&
+
+ git clone forked-upstream forked &&
+ git -C forked remote add other ../forked-other &&
+ git -C forked fetch other &&
+ git -C forked branch --track local-one origin/one &&
+ git -C forked branch --track local-two origin/two &&
+ git -C forked branch --track local-foreign other/foreign &&
+ git -C forked branch detached
+'
+
+test_expect_success '--forked <remote-name> lists branches tracking that remote' '
+ git -C forked branch --forked origin >actual &&
+ cat >expect <<-\EOF &&
+ local-one
+ local-two
+ main
+ EOF
+ test_cmp expect actual
+'
+
+test_expect_success '--forked <remote-tracking-ref> lists only matching branches' '
+ git -C forked branch --forked origin/one >actual &&
+ echo local-one >expect &&
+ test_cmp expect actual
+'
+
+test_expect_success '--forked unions multiple <remote> arguments' '
+ git -C forked branch --forked origin/one other >actual &&
+ cat >expect <<-\EOF &&
+ local-foreign
+ local-one
+ EOF
+ test_cmp expect actual
+'
+
+test_expect_success '--forked rejects unknown remote/ref' '
+ test_must_fail git -C forked branch --forked nope 2>err &&
+ test_grep "neither a configured remote nor a remote-tracking ref" err
+'
+
+test_expect_success '--forked requires at least one <remote>' '
+ test_must_fail git -C forked branch --forked 2>err &&
+ test_grep "at least one <remote>" err
+'
+
test_done
--
gitgitgadget
^ permalink raw reply related
* [PATCH v2 0/6] fetch: add fetch.pruneBranches config
From: Harald Nordgren via GitGitGadget @ 2026-05-04 18:27 UTC (permalink / raw)
To: git; +Cc: Harald Nordgren
In-Reply-To: <pull.2285.git.git.1777671337839.gitgitgadget@gmail.com>
* The whole feature moved out of git fetch and into git branch. git fetch
--prune-merged now just calls git branch --prune-merged after fetching.
* The fetch.pruneLocalBranches and remote.<name>.pruneLocalBranches config
options are gone, replaced by per-branch opt-out via
branch.<name>.pruneMerged.
* New git branch --forked <remote> lists local branches whose upstream
lives on the given remote (read-only building block).
* New git branch --prune-merged <remote> deletes those branches, but only
if their tip is reachable from the upstream tracking ref; --force skips
that safety check.
* New git branch --all-remotes lets --forked/--prune-merged operate across
every configured remote at once.
* The currently checked-out branch in any worktree is always preserved.
* branch.<name>.pruneMerged=false lets you exempt a branch (e.g. a
long-running topic branch) even with --force; doesn't affect explicit git
branch -d.
* delete_branches() got a warn_only mode so bulk deletion prints a one-line
warning per skipped branch instead of the noisy four-line hint that git
branch -d shows.
* New section in git-branch docs; git-fetch docs trimmed to just mention
--prune-merged.
* New tests in t3200-branch.sh for the new branch flags; t5510-fetch.sh
shrunk since most logic moved.
Harald Nordgren (6):
branch: add --forked <remote>
branch: let delete_branches warn instead of error on bulk refusal
branch: add --prune-merged <remote>
fetch: add --prune-merged
branch: add branch.<name>.pruneMerged opt-out
branch: add --all-remotes flag
Documentation/config/branch.adoc | 7 +
Documentation/fetch-options.adoc | 8 +
Documentation/git-branch.adoc | 32 ++++
builtin/branch.c | 247 +++++++++++++++++++++++++++++--
builtin/fetch.c | 20 +++
t/t3200-branch.sh | 215 +++++++++++++++++++++++++++
t/t5510-fetch.sh | 31 ++++
7 files changed, 549 insertions(+), 11 deletions(-)
base-commit: 94f057755b7941b321fd11fec1b2e3ca5313a4e0
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2285%2FHaraldNordgren%2Ffetch-prune-local-branches-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2285/HaraldNordgren/fetch-prune-local-branches-v2
Pull-Request: https://github.com/git/git/pull/2285
Range-diff vs v1:
-: ---------- > 1: e9f8d06a2b branch: add --forked <remote>
-: ---------- > 2: cd4a7e47af branch: let delete_branches warn instead of error on bulk refusal
-: ---------- > 3: c0a5f69eb6 branch: add --prune-merged <remote>
1: 14e3085ed2 ! 4: e979fd238b fetch: add fetch.pruneLocalBranches config
@@ Metadata
Author: Harald Nordgren <haraldnordgren@gmail.com>
## Commit message ##
- fetch: add fetch.pruneLocalBranches config
+ fetch: add --prune-merged
- Introduce a tri-state config option that, when --prune (or
- fetch.prune / remote.<name>.prune) removes a remote-tracking
- ref, also deletes local branches whose configured upstream is
- that ref.
-
- Values:
- - false (default): no change in behavior.
- - safe: delete only if the local tip is reachable from the
- upstream tip, preserving any unpushed work.
- - force: delete unconditionally; recoverable only via reflog.
-
- The currently checked-out branch is always preserved.
+ After a successful fetch from a configured remote, run
+ 'git branch --prune-merged <remote>' to delete local branches
+ whose push destination ref has just been pruned.
Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
- ## Documentation/config/fetch.adoc ##
-@@
- refs. See also `remote.<name>.pruneTags` and the PRUNING
- section of linkgit:git-fetch[1].
-
-+`fetch.pruneBranches`::
-+ When set in addition to `fetch.prune` (or `--prune`), also
-+ delete local branches whose configured upstream
-+ (`branch.<name>.merge`) is one of the remote-tracking refs
-+ just removed by pruning. This is useful for cleaning up topic
-+ branches whose upstream counterpart has been merged and then
-+ removed. The same effect can be requested per-invocation with
-+ `--prune-branches[=<mode>]`, or per-remote with
-+ `remote.<name>.pruneBranches`.
-++
-+The currently checked-out branch (in any worktree) is never
-+deleted. The value is one of:
-++
-+--
-+`false` (the default);;
-+ Do not delete any local branches. Equivalent to leaving
-+ the option unset.
-+`safe`;;
-+ Delete a local branch only if its tip is an ancestor of
-+ the upstream remote-tracking ref's last-known position.
-+ In other words, only delete the branch if it contains no
-+ commits that the upstream did not also have at the moment
-+ it was deleted. This catches the common case of a branch
-+ that was pushed and then squash- or rebase-merged
-+ upstream (the local branch has no extra commits beyond
-+ what was pushed), but preserves any branch with unpushed
-+ local work.
-+`force`;;
-+ Delete the local branch unconditionally, even if it
-+ contains unpushed commits. Use with care: if a remote
-+ branch is deleted for any reason other than that its
-+ contents were merged, the corresponding local commits
-+ will only be retrievable through the reflog.
-+--
-++
-+This option has no effect unless pruning is also enabled, since
-+local branches are only considered for deletion when their
-+upstream remote-tracking ref is being pruned in the same fetch.
-+
- `fetch.all`::
- If true, fetch will attempt to update all available remotes.
- This behavior can be overridden by passing `--no-all` or by
-
- ## Documentation/config/remote.adoc ##
-@@ Documentation/config/remote.adoc: remote.<name>.pruneTags::
- See also `remote.<name>.prune` and the PRUNING section of
- linkgit:git-fetch[1].
-
-+remote.<name>.pruneBranches::
-+ When pruning is active for this remote and this is set to `safe`
-+ or `force`, also delete local branches whose upstream
-+ remote-tracking ref is being pruned. Overrides
-+ `fetch.pruneBranches` settings, if any. See `fetch.pruneBranches`
-+ for the meaning of the values.
-+
- remote.<name>.promisor::
- When set to true, this remote will be used to fetch promisor
- objects.
-
## Documentation/fetch-options.adoc ##
@@ Documentation/fetch-options.adoc: See the PRUNING section below for more details.
+
See the PRUNING section below for more details.
-+`--prune-branches[=(safe|force)]`::
-+ When pruning, also delete local branches whose configured
-+ upstream (`branch.<name>.merge`) is one of the remote-tracking
-+ refs being pruned. With no value or `safe`, refuse to delete a
-+ branch with unpushed commits; with `force`, delete it
-+ regardless. The currently checked-out branch is never
-+ deleted. See `fetch.pruneBranches` in linkgit:git-config[1] for
-+ details.
++`--prune-merged`::
++ After a successful fetch, run `git branch --prune-merged
++ <remote>` for the fetched remote, deleting local branches
++ that fork from this remote and whose tip is reachable from
++ their upstream remote-tracking ref. See linkgit:git-branch[1]
++ for the exact selection rules. The currently checked-out
++ branch is always preserved.
+
endif::git-pull[]
ifndef::git-pull[]
- ## Documentation/git-fetch.adoc ##
-@@ Documentation/git-fetch.adoc: It's reasonable to e.g. configure `fetch.pruneTags=true` in
- run, without making every invocation of `git fetch` without `--prune`
- an error.
-
-+Local branches whose upstream remote-tracking ref is being pruned can
-+also be deleted automatically with `--prune-branches[=<mode>]` (or its
-+config equivalents `fetch.pruneBranches` and `remote.<name>.pruneBranches`).
-+See linkgit:git-config[1] for the data-loss tradeoff between the
-+`safe` and `force` modes.
-+
- Pruning tags with `--prune-tags` also works when fetching a URL
- instead of a named remote. These will all prune tags not found on
- origin:
-
## builtin/fetch.c ##
@@ builtin/fetch.c: static int prune = -1; /* unspecified */
static int prune_tags = -1; /* unspecified */
#define PRUNE_TAGS_BY_DEFAULT 0 /* do we prune tags by default? */
-+static int prune_branches = PRUNE_BRANCHES_UNSPECIFIED;
-+
-+static int parse_prune_branches_opt(const struct option *opt,
-+ const char *arg, int unset)
-+{
-+ int *v = opt->value;
-+ if (unset)
-+ *v = PRUNE_BRANCHES_OFF;
-+ else if (arg)
-+ *v = parse_prune_branches_value(opt->long_name, arg);
-+ else
-+ *v = PRUNE_BRANCHES_SAFE;
-+ return 0;
-+}
++static int prune_merged;
+
static int append, dry_run, force, keep, update_head_ok;
static int write_fetch_head = 1;
static int verbosity, deepen_relative, set_upstream, refetch;
-@@ builtin/fetch.c: struct fetch_config {
- int all;
- int prune;
- int prune_tags;
-+ enum prune_branches_mode prune_branches;
- int show_forced_updates;
- int recurse_submodules;
- int parallel;
-@@ builtin/fetch.c: static int git_fetch_config(const char *k, const char *v,
- return 0;
- }
+@@ builtin/fetch.c: static void add_options_to_argv(struct strvec *argv,
+ strvec_push(argv, prune ? "--prune" : "--no-prune");
+ if (prune_tags != -1)
+ strvec_push(argv, prune_tags ? "--prune-tags" : "--no-prune-tags");
++ if (prune_merged)
++ strvec_push(argv, "--prune-merged");
+ if (update_head_ok)
+ strvec_push(argv, "--update-head-ok");
+ if (force)
+@@ builtin/fetch.c: static inline void fetch_one_setup_partial(struct remote *remote,
+ return;
+ }
-+ if (!strcmp(k, "fetch.prunebranches")) {
-+ fetch_config->prune_branches = parse_prune_branches_value(k, v);
-+ return 0;
-+ }
-+
- if (!strcmp(k, "fetch.showforcedupdates")) {
- fetch_config->show_forced_updates = git_config_bool(k, v);
- return 0;
-@@ builtin/fetch.c: out:
- static int prune_refs(struct display_state *display_state,
- struct refspec *rs,
- struct ref_transaction *transaction,
-- struct ref *ref_map)
-+ struct ref *ref_map,
-+ struct ref **stale_refs_out)
- {
- int result = 0;
- struct ref *ref, *stale_refs = get_stale_heads(rs, ref_map);
-@@ builtin/fetch.c: static int prune_refs(struct display_state *display_state,
- cleanup:
- string_list_clear(&refnames, 0);
- strbuf_release(&err);
-- free_refs(stale_refs);
-+ if (!result && stale_refs_out)
-+ *stale_refs_out = stale_refs;
-+ else
-+ free_refs(stale_refs);
-+ return result;
-+}
-+
-+struct prune_branches_cb {
-+ struct string_list *pruned_refs;
-+ struct string_list *to_delete;
-+ struct string_list *skipped_unmerged;
-+ enum prune_branches_mode mode;
-+};
-+
-+static int collect_branches_to_prune(const struct reference *ref, void *cb_data)
++static int prune_merged_for_remote(const struct remote *remote)
+{
-+ struct prune_branches_cb *cb = cb_data;
-+ const char *short_name = ref->name;
-+ char *full_ref = xstrfmt("refs/heads/%s", short_name);
-+ const char *upstream;
-+ struct string_list_item *pruned;
-+ int result = 0;
-+
-+ if (ref->flags & REF_ISSYMREF)
-+ goto out;
-+ if (branch_checked_out(full_ref))
-+ goto out;
-+
-+ upstream = branch_get_upstream(branch_get(short_name), NULL);
-+ if (!upstream)
-+ goto out;
++ struct child_process cmd = CHILD_PROCESS_INIT;
+
-+ pruned = string_list_lookup(cb->pruned_refs, upstream);
-+ if (!pruned)
-+ goto out;
-+
-+ if (cb->mode == PRUNE_BRANCHES_SAFE) {
-+ struct commit *local = lookup_commit_reference(the_repository,
-+ ref->oid);
-+ struct commit *up = lookup_commit_reference(the_repository,
-+ pruned->util);
-+ int reachable = local && up &&
-+ repo_in_merge_bases(the_repository, local, up);
-+
-+ if (reachable < 0) {
-+ result = -1;
-+ goto out;
-+ }
-+ if (!reachable) {
-+ string_list_append(cb->skipped_unmerged, short_name);
-+ goto out;
-+ }
-+ }
-+
-+ string_list_append(cb->to_delete, full_ref);
-+
-+out:
-+ free(full_ref);
-+ return result;
++ cmd.git_cmd = 1;
++ strvec_pushl(&cmd.args, "branch", "--prune-merged", remote->name, NULL);
++ return run_command(&cmd);
+}
+
-+static int do_prune_branches(struct display_state *display_state,
-+ struct ref *stale_refs,
-+ enum prune_branches_mode mode)
-+{
-+ struct string_list pruned_refs = STRING_LIST_INIT_NODUP;
-+ struct string_list to_delete = STRING_LIST_INIT_DUP;
-+ struct string_list skipped_unmerged = STRING_LIST_INIT_DUP;
-+ struct prune_branches_cb cb = {
-+ .pruned_refs = &pruned_refs,
-+ .to_delete = &to_delete,
-+ .skipped_unmerged = &skipped_unmerged,
-+ .mode = mode,
-+ };
-+ struct ref *ref;
-+ struct string_list_item *item;
-+ int result = 0;
-+
-+ if (!stale_refs)
-+ return 0;
-+
-+ for (ref = stale_refs; ref; ref = ref->next)
-+ string_list_append(&pruned_refs, ref->name)->util = &ref->new_oid;
-+ string_list_sort(&pruned_refs);
-+
-+ if (refs_for_each_branch_ref(get_main_ref_store(the_repository),
-+ collect_branches_to_prune, &cb)) {
-+ result = -1;
-+ goto cleanup;
-+ }
-+
-+ if (!dry_run && to_delete.nr)
-+ result = refs_delete_refs(get_main_ref_store(the_repository),
-+ "fetch: prune branches",
-+ &to_delete, REF_NO_DEREF);
+ static int fetch_one(struct remote *remote, int argc, const char **argv,
+ int prune_tags_ok, int use_stdin_refspecs,
+ const struct fetch_config *config,
+@@ builtin/fetch.c: static int fetch_one(struct remote *remote, int argc, const char **argv,
+ refspec_clear(&rs);
+ transport_disconnect(gtransport);
+ gtransport = NULL;
+
-+ if (verbosity >= 0) {
-+ const struct object_id *zero = null_oid(the_repository->hash_algo);
-+ for_each_string_list_item(item, &to_delete) {
-+ const char *short_name;
-+ if (skip_prefix(item->string, "refs/heads/", &short_name))
-+ display_ref_update(display_state, '-',
-+ _("[deleted local]"), NULL,
-+ _("(none)"), short_name,
-+ zero, zero,
-+ transport_summary_width(NULL));
-+ }
-+ }
-+ for_each_string_list_item(item, &skipped_unmerged)
-+ warning(_("not deleting local branch '%s' that is not "
-+ "fully merged into its upstream;\n"
-+ " set fetch.pruneBranches=force to "
-+ "delete anyway, or delete manually with "
-+ "'git branch -D %s'"),
-+ item->string, item->string);
++ if (!exit_code && prune_merged && remote_via_config &&
++ prune_merged_for_remote(remote))
++ exit_code = 1;
+
-+cleanup:
-+ string_list_clear(&pruned_refs, 0);
-+ string_list_clear(&to_delete, 0);
-+ string_list_clear(&skipped_unmerged, 0);
- return result;
+ return exit_code;
}
-@@ builtin/fetch.c: static int do_fetch(struct transport *transport,
- if (tags == TAGS_DEFAULT && autotags)
- transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
- if (prune) {
-+ struct ref *stale_refs = NULL;
-+ struct ref **stale_refs_out = prune_branches != PRUNE_BRANCHES_OFF
-+ ? &stale_refs : NULL;
- /*
- * We only prune based on refspecs specified
- * explicitly (via command line or configuration); we
- * don't care whether --tags was specified.
- */
- if (rs->nr) {
-- retcode = prune_refs(&display_state, rs, transaction, ref_map);
-+ retcode = prune_refs(&display_state, rs, transaction,
-+ ref_map, stale_refs_out);
- } else {
- retcode = prune_refs(&display_state, &transport->remote->fetch,
-- transaction, ref_map);
-+ transaction, ref_map, stale_refs_out);
- }
- if (retcode != 0)
- retcode = 1;
-+ else if (stale_refs &&
-+ do_prune_branches(&display_state, stale_refs,
-+ prune_branches))
-+ retcode = 1;
-+ free_refs(stale_refs);
- }
-
- /*
-@@ builtin/fetch.c: static int fetch_one(struct remote *remote, int argc, const char **argv,
- prune_tags = PRUNE_TAGS_BY_DEFAULT;
- }
-
-+ if (prune_branches == PRUNE_BRANCHES_UNSPECIFIED) {
-+ /* no command line request */
-+ if (remote->prune_branches >= 0)
-+ prune_branches = remote->prune_branches;
-+ else if (config->prune_branches >= 0)
-+ prune_branches = config->prune_branches;
-+ else
-+ prune_branches = PRUNE_BRANCHES_OFF;
-+ }
-+
- maybe_prune_tags = prune_tags_ok && prune_tags;
- if (maybe_prune_tags && remote_via_config)
- refspec_append(&remote->fetch, TAG_REFSPEC);
-@@ builtin/fetch.c: int cmd_fetch(int argc,
- .display_format = DISPLAY_FORMAT_FULL,
- .prune = -1,
- .prune_tags = -1,
-+ .prune_branches = PRUNE_BRANCHES_UNSPECIFIED,
- .show_forced_updates = 1,
- .recurse_submodules = RECURSE_SUBMODULES_DEFAULT,
- .parallel = 1,
@@ builtin/fetch.c: int cmd_fetch(int argc,
N_("prune remote-tracking branches no longer on remote")),
OPT_BOOL('P', "prune-tags", &prune_tags,
N_("prune local tags no longer on remote and clobber changed tags")),
-+ OPT_CALLBACK_F(0, "prune-branches", &prune_branches, N_("mode"),
-+ N_("delete local branches whose upstream was pruned ('safe' or 'force')"),
-+ PARSE_OPT_OPTARG, parse_prune_branches_opt),
++ OPT_BOOL(0, "prune-merged", &prune_merged,
++ N_("after pruning, also delete local branches forked from this remote whose tips are reachable from their upstream")),
OPT_CALLBACK_F(0, "recurse-submodules", &recurse_submodules_cli, N_("on-demand"),
N_("control recursive fetching of submodules"),
PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules),
- ## remote.c ##
-@@ remote.c: static struct remote *make_remote(struct remote_state *remote_state,
- CALLOC_ARRAY(ret, 1);
- ret->prune = -1; /* unspecified */
- ret->prune_tags = -1; /* unspecified */
-+ ret->prune_branches = -1; /* unspecified */
- ret->name = xstrndup(name, len);
- refspec_init_push(&ret->push);
- refspec_init_fetch(&ret->fetch);
-@@ remote.c: out:
- }
- #endif /* WITH_BREAKING_CHANGES */
-
-+int parse_prune_branches_value(const char *k, const char *v)
-+{
-+ if (v) {
-+ if (!strcasecmp(v, "safe"))
-+ return PRUNE_BRANCHES_SAFE;
-+ if (!strcasecmp(v, "force"))
-+ return PRUNE_BRANCHES_FORCE;
-+ }
-+ if (git_parse_maybe_bool(v) == 0)
-+ return PRUNE_BRANCHES_OFF;
-+ die(_("invalid value for '%s': '%s'"), k, v);
-+}
-+
- static int handle_config(const char *key, const char *value,
- const struct config_context *ctx, void *cb)
- {
-@@ remote.c: static int handle_config(const char *key, const char *value,
- remote->prune = git_config_bool(key, value);
- else if (!strcmp(subkey, "prunetags"))
- remote->prune_tags = git_config_bool(key, value);
-+ else if (!strcmp(subkey, "prunebranches"))
-+ remote->prune_branches = parse_prune_branches_value(key, value);
- else if (!strcmp(subkey, "url")) {
- if (!value)
- return config_error_nonbool(key);
-
- ## remote.h ##
-@@ remote.h: enum {
- #endif /* WITH_BREAKING_CHANGES */
- };
-
-+enum prune_branches_mode {
-+ PRUNE_BRANCHES_UNSPECIFIED = -1,
-+ PRUNE_BRANCHES_OFF = 0,
-+ PRUNE_BRANCHES_SAFE,
-+ PRUNE_BRANCHES_FORCE,
-+};
-+
-+int parse_prune_branches_value(const char *k, const char *v);
-+
- struct rewrite {
- const char *base;
- size_t baselen;
-@@ remote.h: struct remote {
- int mirror;
- int prune;
- int prune_tags;
-+ int prune_branches;
-
- /**
- * The configured helper programs to run on the remote side, for
-
## t/t5510-fetch.sh ##
@@ t/t5510-fetch.sh: test_expect_success REFFILES 'fetch --prune fails to delete branches' '
)
'
-+test_expect_success 'fetch.pruneBranches: setup parent' '
-+ git init -b main prune-branches-parent &&
-+ test_commit -C prune-branches-parent base
++test_expect_success 'fetch --prune-merged: setup' '
++ git init -b main fetch-pm-parent &&
++ test_commit -C fetch-pm-parent base
+'
+
-+test_expect_success 'fetch.pruneBranches=safe deletes merged local branch' '
-+ git -C prune-branches-parent branch doomed base &&
-+ git clone prune-branches-parent prune-branches-safe &&
-+ git -C prune-branches-safe checkout -b doomed --track origin/doomed &&
-+ git -C prune-branches-safe checkout -b stay &&
-+ git -C prune-branches-parent branch -D doomed &&
-+ git -C prune-branches-safe -c fetch.pruneBranches=safe fetch --prune origin &&
-+ test_must_fail git -C prune-branches-safe rev-parse refs/remotes/origin/doomed &&
-+ test_must_fail git -C prune-branches-safe rev-parse refs/heads/doomed
-+'
++test_expect_success 'fetch --prune-merged deletes merged local branches' '
++ test_when_finished "rm -rf fetch-pm-clone" &&
++ git -C fetch-pm-parent branch one base &&
++ git clone fetch-pm-parent fetch-pm-clone &&
++ git -C fetch-pm-clone branch one --track origin/one &&
++ git -C fetch-pm-parent branch -D one &&
+
-+test_expect_success 'fetch.pruneBranches=safe keeps unmerged local branch' '
-+ git -C prune-branches-parent branch doomed base &&
-+ git clone prune-branches-parent prune-branches-safe-unmerged &&
-+ git -C prune-branches-safe-unmerged checkout -b doomed --track origin/doomed &&
-+ test_commit -C prune-branches-safe-unmerged local-only &&
-+ git -C prune-branches-safe-unmerged checkout -b stay &&
-+ git -C prune-branches-parent branch -D doomed &&
-+ git -C prune-branches-safe-unmerged -c fetch.pruneBranches=safe fetch --prune origin 2>err &&
-+ test_must_fail git -C prune-branches-safe-unmerged rev-parse refs/remotes/origin/doomed &&
-+ git -C prune-branches-safe-unmerged rev-parse refs/heads/doomed &&
-+ test_grep "not fully merged" err
-+'
-+
-+test_expect_success 'fetch.pruneBranches=force deletes unmerged local branch' '
-+ git -C prune-branches-parent branch doomed base &&
-+ git clone prune-branches-parent prune-branches-force &&
-+ git -C prune-branches-force checkout -b doomed --track origin/doomed &&
-+ test_commit -C prune-branches-force local-only-force &&
-+ git -C prune-branches-force checkout -b stay &&
-+ git -C prune-branches-parent branch -D doomed &&
-+ git -C prune-branches-force -c fetch.pruneBranches=force fetch --prune origin &&
-+ test_must_fail git -C prune-branches-force rev-parse refs/remotes/origin/doomed &&
-+ test_must_fail git -C prune-branches-force rev-parse refs/heads/doomed
-+'
-+
-+test_expect_success 'fetch.pruneBranches=force never deletes checked-out branch' '
-+ git -C prune-branches-parent branch doomed base &&
-+ git clone prune-branches-parent prune-branches-checked-out &&
-+ git -C prune-branches-checked-out checkout -b doomed --track origin/doomed &&
-+ git -C prune-branches-parent branch -D doomed &&
-+ git -C prune-branches-checked-out -c fetch.pruneBranches=force fetch --prune origin &&
-+ test_must_fail git -C prune-branches-checked-out rev-parse refs/remotes/origin/doomed &&
-+ git -C prune-branches-checked-out rev-parse refs/heads/doomed
-+'
-+
-+test_expect_success '--prune-branches deletes merged local branch' '
-+ git -C prune-branches-parent branch doomed base &&
-+ git clone prune-branches-parent prune-branches-cli &&
-+ git -C prune-branches-cli checkout -b doomed --track origin/doomed &&
-+ git -C prune-branches-cli checkout -b stay &&
-+ git -C prune-branches-parent branch -D doomed &&
-+ git -C prune-branches-cli fetch --prune --prune-branches origin &&
-+ test_must_fail git -C prune-branches-cli rev-parse refs/heads/doomed
-+'
++ git -C fetch-pm-clone fetch --prune --prune-merged origin &&
+
-+test_expect_success '--no-prune-branches overrides fetch.pruneBranches' '
-+ git -C prune-branches-parent branch doomed base &&
-+ git clone prune-branches-parent prune-branches-no-cli &&
-+ git -C prune-branches-no-cli checkout -b doomed --track origin/doomed &&
-+ git -C prune-branches-no-cli checkout -b stay &&
-+ git -C prune-branches-no-cli config fetch.pruneBranches force &&
-+ git -C prune-branches-parent branch -D doomed &&
-+ git -C prune-branches-no-cli fetch --prune --no-prune-branches origin &&
-+ git -C prune-branches-no-cli rev-parse refs/heads/doomed
++ test_must_fail git -C fetch-pm-clone rev-parse --verify refs/heads/one
+'
+
-+test_expect_success 'remote.<name>.pruneBranches overrides fetch.pruneBranches' '
-+ git -C prune-branches-parent branch doomed base &&
-+ git clone prune-branches-parent prune-branches-per-remote &&
-+ git -C prune-branches-per-remote checkout -b doomed --track origin/doomed &&
-+ git -C prune-branches-per-remote checkout -b stay &&
-+ git -C prune-branches-per-remote config fetch.pruneBranches force &&
-+ git -C prune-branches-per-remote config remote.origin.pruneBranches false &&
-+ git -C prune-branches-parent branch -D doomed &&
-+ git -C prune-branches-per-remote fetch --prune origin &&
-+ git -C prune-branches-per-remote rev-parse refs/heads/doomed
++test_expect_success 'fetch --prune-merged skips unmerged local branches' '
++ test_when_finished "rm -rf fetch-pm-unmerged" &&
++ git -C fetch-pm-parent branch two base &&
++ git clone fetch-pm-parent fetch-pm-unmerged &&
++ git -C fetch-pm-unmerged checkout -b two --track origin/two &&
++ test_commit -C fetch-pm-unmerged unpushed &&
++ git -C fetch-pm-unmerged checkout - &&
++ git -C fetch-pm-parent branch -D two &&
++
++ git -C fetch-pm-unmerged fetch --prune --prune-merged origin 2>err &&
++ test_grep "not fully merged" err &&
++ git -C fetch-pm-unmerged rev-parse --verify refs/heads/two
+'
+
test_expect_success 'fetch --atomic works with a single branch' '
-: ---------- > 5: 0bc5ebbe68 branch: add branch.<name>.pruneMerged opt-out
-: ---------- > 6: 66dac97626 branch: add --all-remotes flag
--
gitgitgadget
^ permalink raw reply
* Re: [PATCH v2 08/11] test-tool synthesize: precompute pack for 4 GiB + 1
From: Derrick Stolee @ 2026-05-04 18:27 UTC (permalink / raw)
To: Johannes Schindelin via GitGitGadget, git
Cc: Torsten Bögershausen, Jeff King, Johannes Schindelin
In-Reply-To: <29b9a74e915e6200ac2b4d98e446c1e73964cbd2.1777914508.git.gitgitgadget@gmail.com>
On 5/4/2026 1:08 PM, Johannes Schindelin via GitGitGadget wrote:
> From: Johannes Schindelin <johannes.schindelin@gmx.de>
> Benchmarks generating a 4 GiB + 1 pack (3 runs each, SHA1DC on
> x86_64):
>
> generic path: 88s / 81s / 140s
> fast path: 14s / 13s / 15s
>
> On CI, where t5608 currently takes 200-850 seconds depending on the
> job, the fast path cuts the pack-generation phase from minutes to
> seconds, leaving only the clone operations themselves.
Are these numbers accurate for the patch position in the series?
The previous change replaced SHA1DC with the unsafe version, which
gained similar performance improvements. I'd be interested to see
the numbers for both enabled at the same time.
Thanks,
-Stolee
^ permalink raw reply
* Re: 10.26
From: Aa Kk @ 2026-05-04 18:22 UTC (permalink / raw)
To: git
In-Reply-To: <88D33A93-5CDD-40FE-A402-490A5944117A@icloud.com>
Sent from my iPhone
> On 4 May 2569 BE, at 4:39 PM, Aa Kk <ahya0000@icloud.com> wrote:
>
> 524152
> Sent from my iPhone
>
>
>> On 4 May 2569 BE, at 4:38 PM, Aa Kk <ahya0000@icloud.com> wrote:
>>
>>
>> Sent from my iPhone
>>
>>
>>>> On 4 May 2569 BE, at 4:38 PM, Aa Kk <ahya0000@icloud.com> wrote:
>>>
>>>
>>> Sent from my iPhone
>>>
>>>
>>>>> On 4 May 2569 BE, at 4:37 PM, Aa Kk <ahya0000@icloud.com> wrote:
>>>>
>>>> 524152
>>>> Sent from my iPhone
>>>>
>>>>
>>>>>> On 4 May 2569 BE, at 12:05 AM, Aa Kk <ahya0000@icloud.com> wrote:
>>>>>
>>>>>
>>>>> Sent from my iPhone
>>> <Contact 3.vcf>
>>>>>
>>>>>
^ permalink raw reply
* Re: What's cooking in git.git (May 2026, #01)
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: Patrick Steinhardt, Junio C Hamano; +Cc: git
In-Reply-To: <afiqvgxwbAOxMsti@pks.im>
[-- Attachment #1: Type: text/plain, Size: 975 bytes --]
Patrick Steinhardt <ps@pks.im> writes:
> On Sun, May 03, 2026 at 12:47:23PM +0900, Junio C Hamano wrote:
>> * kn/refs-generic-helpers (2026-04-27) 9 commits
>> - refs: use peeled tag values in reference backends
>> - refs: add peeled object ID to the `ref_update` struct
>> - refs: move object parsing to the generic layer
>> - update-ref: handle rejections while adding updates
>> - update-ref: move `print_rejected_refs()` up
>> - refs: return `ref_transaction_error` from `ref_transaction_update()`
>> - refs: extract out reflog config to generic layer
>> - refs: introduce `ref_store_init_options`
>> - refs: remove unused typedef 'ref_transaction_commit_fn'
>>
>> Refactor service routines in the ref subsystem backends.
>>
>> Will merge to 'next'?
>> source: <20260427-refs-move-to-generic-layer-v3-0-e4638dfb7897@gmail.com>
>
> I think [1] is something that may still want to be addressed.
>
yeah, I've sent in a new version fixing that. Thanks.
[snip]
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 690 bytes --]
^ permalink raw reply
* [PATCH v4 9/9] refs: use peeled tag values in reference backends
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
The reference backends peel tag objects when storing references to them.
This is to provide optimized reads which avoids hitting the odb. The
previous commits ensures that the peeled value is now propagated via the
generic layer. So modify the packed and reftable backend to directly use
this value instead of calling `peel_object()` independently.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
refs/packed-backend.c | 6 ++----
refs/reftable-backend.c | 9 ++-------
2 files changed, 4 insertions(+), 11 deletions(-)
diff --git a/refs/packed-backend.c b/refs/packed-backend.c
index 35a0f32e1c..0acde48c45 100644
--- a/refs/packed-backend.c
+++ b/refs/packed-backend.c
@@ -1531,13 +1531,11 @@ static enum ref_transaction_error write_with_updates(struct packed_ref_store *re
*/
i++;
} else {
- struct object_id peeled;
- int peel_error = peel_object(refs->base.repo, &update->new_oid,
- &peeled, PEEL_OBJECT_VERIFY_TAGGED_OBJECT_TYPE);
+ bool peeled = update->flags & REF_HAVE_PEELED;
if (write_packed_entry(out, update->refname,
&update->new_oid,
- peel_error ? NULL : &peeled))
+ peeled ? &update->peeled : NULL))
goto write_error;
i++;
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index b0c010387d..8b4ac2e618 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -12,7 +12,6 @@
#include "../hex.h"
#include "../ident.h"
#include "../iterator.h"
-#include "../object.h"
#include "../parse.h"
#include "../path.h"
#include "../refs.h"
@@ -1584,17 +1583,13 @@ static int write_transaction_table(struct reftable_writer *writer, void *cb_data
goto done;
} else if (u->flags & REF_HAVE_NEW) {
struct reftable_ref_record ref = {0};
- struct object_id peeled;
- int peel_error;
ref.refname = (char *)u->refname;
ref.update_index = ts;
- peel_error = peel_object(arg->refs->base.repo, &u->new_oid, &peeled,
- PEEL_OBJECT_VERIFY_TAGGED_OBJECT_TYPE);
- if (!peel_error) {
+ if (u->flags & REF_HAVE_PEELED) {
ref.value_type = REFTABLE_REF_VAL2;
- memcpy(ref.value.val2.target_value, peeled.hash, GIT_MAX_RAWSZ);
+ memcpy(ref.value.val2.target_value, u->peeled.hash, GIT_MAX_RAWSZ);
memcpy(ref.value.val2.value, u->new_oid.hash, GIT_MAX_RAWSZ);
} else if (!is_null_oid(&u->new_oid)) {
ref.value_type = REFTABLE_REF_VAL1;
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 8/9] refs: add peeled object ID to the `ref_update` struct
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
Certain reference backends {packed, reftable}, have the ability to also
store the peeled object ID for a reference pointing to a tag object.
This has the added benefit that during retrieval of such references, we
also obtain the peeled object ID without having to use the ODB.
To provide this functionality, each backend independently calls the ODB
to obtain the peeled OID. To move this functionality to the generic
layer, there must be support infrastructure to pass in a peeled OID for
reference updates.
Add a `peeled` field to the `ref_update` structure and modify
`ref_transaction_add_update()` to receive and copy this object ID to the
`ref_update` structure. Finally, modify `ref_transaction_update()` to
peel tag objects and pass the peeled OID to
`ref_transaction_add_update()`.
Update all callers of these functions with the new function parameters.
Callers which only add reflog updates, need to only pass in NULL, since
for reflogs, we don't store peeled OIDs. Reference deletions also only
need to pass in NULL. For others, pass along the peeled OID if
available.
In a following commit, we'll modify the backends to use this peeled OID
instead of parsing it themselves.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
refs.c | 15 +++++++++++++--
refs/files-backend.c | 20 ++++++++++++--------
refs/refs-internal.h | 14 ++++++++++++++
refs/reftable-backend.c | 6 +++---
4 files changed, 42 insertions(+), 13 deletions(-)
diff --git a/refs.c b/refs.c
index 662a9e6f9e..0648df2b6c 100644
--- a/refs.c
+++ b/refs.c
@@ -1307,6 +1307,7 @@ struct ref_update *ref_transaction_add_update(
const char *refname, unsigned int flags,
const struct object_id *new_oid,
const struct object_id *old_oid,
+ const struct object_id *peeled,
const char *new_target, const char *old_target,
const char *committer_info,
const char *msg)
@@ -1339,6 +1340,8 @@ struct ref_update *ref_transaction_add_update(
update->committer_info = xstrdup_or_null(committer_info);
update->msg = normalize_reflog_message(msg);
}
+ if (flags & REF_HAVE_PEELED)
+ oidcpy(&update->peeled, peeled);
/*
* This list is generally used by the backends to avoid duplicates.
@@ -1392,6 +1395,8 @@ enum ref_transaction_error ref_transaction_update(struct ref_transaction *transa
unsigned int flags, const char *msg,
struct strbuf *err)
{
+ struct object_id peeled;
+
assert(err);
if ((flags & REF_FORCE_CREATE_REFLOG) &&
@@ -1432,10 +1437,16 @@ enum ref_transaction_error ref_transaction_update(struct ref_transaction *transa
oid_to_hex(new_oid), refname);
return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
}
+
+ if (o->type == OBJ_TAG) {
+ if (!peel_object(transaction->ref_store->repo, new_oid, &peeled,
+ PEEL_OBJECT_VERIFY_TAGGED_OBJECT_TYPE))
+ flags |= REF_HAVE_PEELED;
+ }
}
ref_transaction_add_update(transaction, refname, flags,
- new_oid, old_oid, new_target,
+ new_oid, old_oid, &peeled, new_target,
old_target, NULL, msg);
return 0;
@@ -1462,7 +1473,7 @@ int ref_transaction_update_reflog(struct ref_transaction *transaction,
return -1;
update = ref_transaction_add_update(transaction, refname, flags,
- new_oid, old_oid, NULL, NULL,
+ new_oid, old_oid, NULL, NULL, NULL,
committer_info, msg);
update->index = index;
diff --git a/refs/files-backend.c b/refs/files-backend.c
index f20f580fbc..d0896d0e37 100644
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -1325,7 +1325,8 @@ static void prune_ref(struct files_ref_store *refs, struct ref_to_prune *r)
ref_transaction_add_update(
transaction, r->name,
REF_NO_DEREF | REF_HAVE_NEW | REF_HAVE_OLD | REF_IS_PRUNING,
- null_oid(the_hash_algo), &r->oid, NULL, NULL, NULL, NULL);
+ null_oid(the_hash_algo), &r->oid, NULL, NULL, NULL,
+ NULL, NULL);
if (ref_transaction_commit(transaction, &err))
goto cleanup;
@@ -2468,7 +2469,7 @@ static enum ref_transaction_error split_head_update(struct ref_update *update,
new_update = ref_transaction_add_update(
transaction, "HEAD",
update->flags | REF_LOG_ONLY | REF_NO_DEREF | REF_LOG_VIA_SPLIT,
- &update->new_oid, &update->old_oid,
+ &update->new_oid, &update->old_oid, &update->peeled,
NULL, NULL, update->committer_info, update->msg);
new_update->parent_update = update;
@@ -2530,8 +2531,8 @@ static enum ref_transaction_error split_symref_update(struct ref_update *update,
transaction, referent, new_flags,
update->new_target ? NULL : &update->new_oid,
update->old_target ? NULL : &update->old_oid,
- update->new_target, update->old_target, NULL,
- update->msg);
+ &update->peeled, update->new_target, update->old_target,
+ NULL, update->msg);
new_update->parent_update = update;
@@ -2994,7 +2995,7 @@ static int files_transaction_prepare(struct ref_store *ref_store,
ref_transaction_add_update(
packed_transaction, update->refname,
REF_HAVE_NEW | REF_NO_DEREF,
- &update->new_oid, NULL,
+ &update->new_oid, NULL, NULL,
NULL, NULL, NULL, NULL);
}
}
@@ -3200,19 +3201,22 @@ static int files_transaction_finish_initial(struct files_ref_store *refs,
if (update->flags & REF_LOG_ONLY)
ref_transaction_add_update(loose_transaction, update->refname,
update->flags, &update->new_oid,
- &update->old_oid, NULL, NULL,
+ &update->old_oid, &update->peeled,
+ NULL, NULL,
update->committer_info, update->msg);
else
ref_transaction_add_update(loose_transaction, update->refname,
update->flags & ~REF_HAVE_OLD,
update->new_target ? NULL : &update->new_oid, NULL,
- update->new_target, NULL, update->committer_info,
+ &update->peeled, update->new_target,
+ NULL, update->committer_info,
NULL);
} else {
ref_transaction_add_update(packed_transaction, update->refname,
update->flags & ~REF_HAVE_OLD,
&update->new_oid, &update->old_oid,
- NULL, NULL, update->committer_info, NULL);
+ &update->peeled, NULL, NULL,
+ update->committer_info, NULL);
}
}
diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index d103387ebf..307dcb277b 100644
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -39,6 +39,13 @@ struct ref_transaction;
*/
#define REF_LOG_ONLY (1 << 7)
+/*
+ * The reference contains a peeled object ID. This is used when the
+ * new_oid is pointing to a tag object and the reference backend
+ * wants to also store the peeled value for optimized retrieval.
+ */
+#define REF_HAVE_PEELED (1 << 15)
+
/*
* Return the length of time to retry acquiring a loose reference lock
* before giving up, in milliseconds:
@@ -92,6 +99,12 @@ struct ref_update {
*/
struct object_id old_oid;
+ /*
+ * If the new_oid points to a tag object, set this to the peeled
+ * object ID for optimized retrieval without needed to hit the odb.
+ */
+ struct object_id peeled;
+
/*
* If set, point the reference to this value. This can also be
* used to convert regular references to become symbolic refs.
@@ -169,6 +182,7 @@ struct ref_update *ref_transaction_add_update(
const char *refname, unsigned int flags,
const struct object_id *new_oid,
const struct object_id *old_oid,
+ const struct object_id *peeled,
const char *new_target, const char *old_target,
const char *committer_info,
const char *msg);
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 444b0c24e5..b0c010387d 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -1107,8 +1107,8 @@ static enum ref_transaction_error prepare_single_update(struct reftable_ref_stor
ref_transaction_add_update(
transaction, "HEAD",
u->flags | REF_LOG_ONLY | REF_NO_DEREF,
- &u->new_oid, &u->old_oid, NULL, NULL, NULL,
- u->msg);
+ &u->new_oid, &u->old_oid, &u->peeled, NULL, NULL,
+ NULL, u->msg);
}
ret = reftable_backend_read_ref(be, rewritten_ref,
@@ -1194,7 +1194,7 @@ static enum ref_transaction_error prepare_single_update(struct reftable_ref_stor
transaction, referent->buf, new_flags,
u->new_target ? NULL : &u->new_oid,
u->old_target ? NULL : &u->old_oid,
- u->new_target, u->old_target,
+ &u->peeled, u->new_target, u->old_target,
u->committer_info, u->msg);
new_update->parent_update = u;
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 7/9] refs: move object parsing to the generic layer
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
Regular reference updates made via reference transactions validate that
the provided object ID exists in the object database, which is done by
calling 'parse_object()'. This check is done independently by the
backends which leads to duplicated logic.
Let's move this to the generic layer, ensuring the backends only have to
care about reference storage and not about validation of the object IDs.
With this also remove the 'REF_TRANSACTION_ERROR_INVALID_NEW_VALUE'
error type as its no longer used.
Since we don't iterate over individual references in
`ref_transaction_prepare()`, we add this check to
`ref_transaction_update()`. This means that the validation is done as
soon as an update is queued, without needing to prepare the
transaction. It can be argued that this is more ideal, since this
validation has no dependency on the reference transaction being
prepared.
It must be noted that the change in behavior means that this error
cannot be ignored even with usage of batched updates, since this happens
when the update is being added to the transaction. But since the caller
gets specific error codes, they can either abort the transaction or
continue adding other updates to the transaction.
Modify 'builtin/receive-pack.c' to now capture the error type so that
the error propagated to the client stays the same. Also remove two of
the tests which validates batch-updates with invalid new_oid.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
builtin/receive-pack.c | 22 +++++++++++++---------
refs.c | 18 ++++++++++++++++++
refs/files-backend.c | 28 ++--------------------------
refs/reftable-backend.c | 19 -------------------
t/t1400-update-ref.sh | 14 ++++++++++++++
5 files changed, 47 insertions(+), 54 deletions(-)
diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index 878aa7f0ed..376e755e97 100644
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -1641,8 +1641,8 @@ static const char *update(struct command *cmd, struct shallow_info *si)
ret = NULL; /* good */
}
strbuf_release(&err);
- }
- else {
+ } else {
+ enum ref_transaction_error tx_err;
struct strbuf err = STRBUF_INIT;
if (shallow_update && si->shallow_ref[cmd->index] &&
update_shallow_ref(cmd, si)) {
@@ -1650,14 +1650,18 @@ static const char *update(struct command *cmd, struct shallow_info *si)
goto out;
}
- if (ref_transaction_update(transaction,
- namespaced_name,
- new_oid, old_oid,
- NULL, NULL,
- 0, "push",
- &err)) {
+ tx_err = ref_transaction_update(transaction,
+ namespaced_name,
+ new_oid, old_oid,
+ NULL, NULL,
+ 0, "push",
+ &err);
+ if (tx_err) {
rp_error("%s", err.buf);
- ret = "failed to update ref";
+ if (tx_err == REF_TRANSACTION_ERROR_GENERIC)
+ ret = "failed to update ref";
+ else
+ ret = ref_transaction_error_msg(tx_err);
} else {
ret = NULL; /* good */
}
diff --git a/refs.c b/refs.c
index efa16b739d..662a9e6f9e 100644
--- a/refs.c
+++ b/refs.c
@@ -1416,6 +1416,24 @@ enum ref_transaction_error ref_transaction_update(struct ref_transaction *transa
flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
flags |= (new_target ? REF_HAVE_NEW : 0) | (old_target ? REF_HAVE_OLD : 0);
+ if ((flags & REF_HAVE_NEW) && !new_target && !is_null_oid(new_oid) &&
+ !(flags & REF_SKIP_OID_VERIFICATION) && !(flags & REF_LOG_ONLY)) {
+ struct object *o = parse_object(transaction->ref_store->repo, new_oid);
+
+ if (!o) {
+ strbuf_addf(err,
+ _("trying to write ref '%s' with nonexistent object %s"),
+ refname, oid_to_hex(new_oid));
+ return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
+ }
+
+ if (o->type != OBJ_COMMIT && is_branch(refname)) {
+ strbuf_addf(err, _("trying to write non-commit object %s to branch '%s'"),
+ oid_to_hex(new_oid), refname);
+ return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
+ }
+ }
+
ref_transaction_add_update(transaction, refname, flags,
new_oid, old_oid, new_target,
old_target, NULL, msg);
diff --git a/refs/files-backend.c b/refs/files-backend.c
index 4b2faf4777..f20f580fbc 100644
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -19,7 +19,6 @@
#include "../iterator.h"
#include "../dir-iterator.h"
#include "../lockfile.h"
-#include "../object.h"
#include "../path.h"
#include "../dir.h"
#include "../chdir-notify.h"
@@ -1589,7 +1588,6 @@ static int rename_tmp_log(struct files_ref_store *refs, const char *newrefname)
static enum ref_transaction_error write_ref_to_lockfile(struct files_ref_store *refs,
struct ref_lock *lock,
const struct object_id *oid,
- int skip_oid_verification,
struct strbuf *err);
static int commit_ref_update(struct files_ref_store *refs,
struct ref_lock *lock,
@@ -1737,7 +1735,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store,
}
oidcpy(&lock->old_oid, &orig_oid);
- if (write_ref_to_lockfile(refs, lock, &orig_oid, 0, &err) ||
+ if (write_ref_to_lockfile(refs, lock, &orig_oid, &err) ||
commit_ref_update(refs, lock, &orig_oid, logmsg, 0, &err)) {
error("unable to write current sha1 into %s: %s", newrefname, err.buf);
strbuf_release(&err);
@@ -1755,7 +1753,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store,
goto rollbacklog;
}
- if (write_ref_to_lockfile(refs, lock, &orig_oid, 0, &err) ||
+ if (write_ref_to_lockfile(refs, lock, &orig_oid, &err) ||
commit_ref_update(refs, lock, &orig_oid, NULL, REF_SKIP_CREATE_REFLOG, &err)) {
error("unable to write current sha1 into %s: %s", oldrefname, err.buf);
strbuf_release(&err);
@@ -1999,32 +1997,11 @@ static int files_log_ref_write(struct files_ref_store *refs,
static enum ref_transaction_error write_ref_to_lockfile(struct files_ref_store *refs,
struct ref_lock *lock,
const struct object_id *oid,
- int skip_oid_verification,
struct strbuf *err)
{
static char term = '\n';
- struct object *o;
int fd;
- if (!skip_oid_verification) {
- o = parse_object(refs->base.repo, oid);
- if (!o) {
- strbuf_addf(
- err,
- "trying to write ref '%s' with nonexistent object %s",
- lock->ref_name, oid_to_hex(oid));
- unlock_ref(lock);
- return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
- }
- if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
- strbuf_addf(
- err,
- "trying to write non-commit object %s to branch '%s'",
- oid_to_hex(oid), lock->ref_name);
- unlock_ref(lock);
- return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
- }
- }
fd = get_lock_file_fd(&lock->lk);
if (write_in_full(fd, oid_to_hex(oid), refs->base.repo->hash_algo->hexsz) < 0 ||
write_in_full(fd, &term, 1) < 0 ||
@@ -2828,7 +2805,6 @@ static enum ref_transaction_error lock_ref_for_update(struct files_ref_store *re
} else {
ret = write_ref_to_lockfile(
refs, lock, &update->new_oid,
- update->flags & REF_SKIP_OID_VERIFICATION,
err);
if (ret) {
char *write_err = strbuf_detach(err, NULL);
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 93374d25c2..444b0c24e5 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -1081,25 +1081,6 @@ static enum ref_transaction_error prepare_single_update(struct reftable_ref_stor
return 0;
}
- /* Verify that the new object ID is valid. */
- if ((u->flags & REF_HAVE_NEW) && !is_null_oid(&u->new_oid) &&
- !(u->flags & REF_SKIP_OID_VERIFICATION) &&
- !(u->flags & REF_LOG_ONLY)) {
- struct object *o = parse_object(refs->base.repo, &u->new_oid);
- if (!o) {
- strbuf_addf(err,
- _("trying to write ref '%s' with nonexistent object %s"),
- u->refname, oid_to_hex(&u->new_oid));
- return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
- }
-
- if (o->type != OBJ_COMMIT && is_branch(u->refname)) {
- strbuf_addf(err, _("trying to write non-commit object %s to branch '%s'"),
- oid_to_hex(&u->new_oid), u->refname);
- return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
- }
- }
-
/*
* When we update the reference that HEAD points to we enqueue
* a second log-only update for HEAD so that its reflog is
diff --git a/t/t1400-update-ref.sh b/t/t1400-update-ref.sh
index b2858a9061..1015f335e3 100755
--- a/t/t1400-update-ref.sh
+++ b/t/t1400-update-ref.sh
@@ -1196,6 +1196,20 @@ test_expect_success 'stdin -z create ref fails with empty new value' '
test_must_fail git rev-parse --verify -q $c
'
+test_expect_success 'stdin -z create ref fails with non commit object' '
+ printf $F "create $c" "$(test_oid 001)" >stdin &&
+ test_must_fail git update-ref -z --stdin <stdin 2>err &&
+ grep "fatal: trying to write ref ${SQ}$c${SQ} with nonexistent object" err &&
+ test_must_fail git rev-parse --verify -q $c
+'
+
+test_expect_success 'stdin -z update ref fails with non commit object' '
+ printf $F "update $b" "$(test_oid 001)" "" >stdin &&
+ test_must_fail git update-ref -z --stdin <stdin 2>err &&
+ grep "fatal: trying to write ref ${SQ}$b${SQ} with nonexistent object" err &&
+ test_must_fail git rev-parse --verify -q $c
+'
+
test_expect_success 'stdin -z update ref works with right old value' '
printf $F "update $b" "$m~1" "$m" >stdin &&
git update-ref -z --stdin <stdin &&
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 6/9] update-ref: handle rejections while adding updates
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
When using git-update-ref(1) with the '--batch-updates' flag, updates
rejected by the reference backend are displayed to the user while other
updates are applied. This only applies during the commit phase of the
transaction.
In the following commits, we'll also extend `ref_transaction_update()`
to reject updates before a transaction is prepared/committed. In
preparation, modify the code in update-ref to also handle non-generic
rejections from `ref_transaction_update()`. This involves propagating
information to each of the commands on whether updates are allowed to be
rejected, and also checking for rejections and only dying for generic
failures.
Errors encountered during updates will be shown to the user immediately
unlike other errors encountered only when the transaction is
prepared/committed. As the verification of object IDs and peeled tag
objects will move into `ref_transaction_update()` in the following
commit, this means that those errors will be shown to the user before
other errors, this changes the order of errors, but the functionality
remains the same.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
builtin/update-ref.c | 137 ++++++++++++++++++++++++++++++++++++---------------
1 file changed, 98 insertions(+), 39 deletions(-)
diff --git a/builtin/update-ref.c b/builtin/update-ref.c
index 5259cc7226..6355c3dd3e 100644
--- a/builtin/update-ref.c
+++ b/builtin/update-ref.c
@@ -25,6 +25,15 @@ static unsigned int default_flags;
static unsigned create_reflog_flag;
static const char *msg;
+struct command_options {
+ /*
+ * Individual updates are allowed to fail without causing
+ * update-ref to exit. This is set when using the
+ * '--batch-updates' flag.
+ */
+ bool allow_update_failures;
+};
+
/*
* Parse one whitespace- or NUL-terminated, possibly C-quoted argument
* and append the result to arg. Return a pointer to the terminator.
@@ -257,6 +266,31 @@ static void print_rejected_refs(const char *refname,
strbuf_release(&sb);
}
+/*
+ * Handle transaction errors. If we're using batches updates, we want to only
+ * die for generic errors and print the remaining to the user.
+ */
+static void handle_ref_transaction_error(const char *refname,
+ struct object_id *new_oid,
+ struct object_id *old_oid,
+ const char *new_target,
+ const char *old_target,
+ enum ref_transaction_error tx_err,
+ struct strbuf *err,
+ struct command_options *opts)
+{
+ if (!tx_err)
+ return;
+
+ if (tx_err != REF_TRANSACTION_ERROR_GENERIC && opts->allow_update_failures) {
+ print_rejected_refs(refname, old_oid, new_oid, old_target,
+ new_target, tx_err, err->buf, NULL);
+ return;
+ }
+
+ die("%s", err->buf);
+}
+
/*
* The following five parse_cmd_*() functions parse the corresponding
* command. In each case, next points at the character following the
@@ -268,11 +302,13 @@ static void print_rejected_refs(const char *refname,
*/
static void parse_cmd_update(struct ref_transaction *transaction,
- const char *next, const char *end)
+ const char *next, const char *end,
+ struct command_options *opts)
{
struct strbuf err = STRBUF_INIT;
char *refname;
struct object_id new_oid, old_oid;
+ enum ref_transaction_error tx_err;
int have_old;
refname = parse_refname(&next);
@@ -289,12 +325,14 @@ static void parse_cmd_update(struct ref_transaction *transaction,
if (*next != line_termination)
die("update %s: extra input: %s", refname, next);
- if (ref_transaction_update(transaction, refname,
- &new_oid, have_old ? &old_oid : NULL,
- NULL, NULL,
- update_flags | create_reflog_flag,
- msg, &err))
- die("%s", err.buf);
+ tx_err = ref_transaction_update(transaction, refname,
+ &new_oid, have_old ? &old_oid : NULL,
+ NULL, NULL,
+ update_flags | create_reflog_flag,
+ msg, &err);
+ handle_ref_transaction_error(refname, &new_oid, have_old ? &old_oid : NULL,
+ NULL, NULL, tx_err, &err, opts);
+
update_flags = default_flags;
free(refname);
@@ -302,9 +340,11 @@ static void parse_cmd_update(struct ref_transaction *transaction,
}
static void parse_cmd_symref_update(struct ref_transaction *transaction,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts)
{
char *refname, *new_target, *old_arg;
+ enum ref_transaction_error tx_err;
char *old_target = NULL;
struct strbuf err = STRBUF_INIT;
struct object_id old_oid;
@@ -341,13 +381,15 @@ static void parse_cmd_symref_update(struct ref_transaction *transaction,
if (*next != line_termination)
die("symref-update %s: extra input: %s", refname, next);
- if (ref_transaction_update(transaction, refname, NULL,
- have_old_oid ? &old_oid : NULL,
- new_target,
- have_old_oid ? NULL : old_target,
- update_flags | create_reflog_flag,
- msg, &err))
- die("%s", err.buf);
+ tx_err = ref_transaction_update(transaction, refname, NULL,
+ have_old_oid ? &old_oid : NULL,
+ new_target,
+ have_old_oid ? NULL : old_target,
+ update_flags | create_reflog_flag,
+ msg, &err);
+ handle_ref_transaction_error(refname, NULL, have_old_oid ? &old_oid : NULL,
+ new_target, have_old_oid ? NULL : old_target,
+ tx_err, &err, opts);
update_flags = default_flags;
free(refname);
@@ -358,11 +400,13 @@ static void parse_cmd_symref_update(struct ref_transaction *transaction,
}
static void parse_cmd_create(struct ref_transaction *transaction,
- const char *next, const char *end)
+ const char *next, const char *end,
+ struct command_options *opts)
{
struct strbuf err = STRBUF_INIT;
char *refname;
struct object_id new_oid;
+ enum ref_transaction_error tx_err;
refname = parse_refname(&next);
if (!refname)
@@ -377,22 +421,24 @@ static void parse_cmd_create(struct ref_transaction *transaction,
if (*next != line_termination)
die("create %s: extra input: %s", refname, next);
- if (ref_transaction_create(transaction, refname, &new_oid, NULL,
- update_flags | create_reflog_flag,
- msg, &err))
- die("%s", err.buf);
+ tx_err = ref_transaction_create(transaction, refname, &new_oid, NULL,
+ update_flags | create_reflog_flag,
+ msg, &err);
+ handle_ref_transaction_error(refname, &new_oid, NULL, NULL, NULL, tx_err,
+ &err, opts);
update_flags = default_flags;
free(refname);
strbuf_release(&err);
}
-
static void parse_cmd_symref_create(struct ref_transaction *transaction,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts)
{
struct strbuf err = STRBUF_INIT;
char *refname, *new_target;
+ enum ref_transaction_error tx_err;
refname = parse_refname(&next);
if (!refname)
@@ -405,10 +451,11 @@ static void parse_cmd_symref_create(struct ref_transaction *transaction,
if (*next != line_termination)
die("symref-create %s: extra input: %s", refname, next);
- if (ref_transaction_create(transaction, refname, NULL, new_target,
- update_flags | create_reflog_flag,
- msg, &err))
- die("%s", err.buf);
+ tx_err = ref_transaction_create(transaction, refname, NULL, new_target,
+ update_flags | create_reflog_flag,
+ msg, &err);
+ handle_ref_transaction_error(refname, NULL, NULL, new_target, NULL,
+ tx_err, &err, opts);
update_flags = default_flags;
free(refname);
@@ -417,7 +464,8 @@ static void parse_cmd_symref_create(struct ref_transaction *transaction,
}
static void parse_cmd_delete(struct ref_transaction *transaction,
- const char *next, const char *end)
+ const char *next, const char *end,
+ struct command_options *opts UNUSED)
{
struct strbuf err = STRBUF_INIT;
char *refname;
@@ -450,9 +498,9 @@ static void parse_cmd_delete(struct ref_transaction *transaction,
strbuf_release(&err);
}
-
static void parse_cmd_symref_delete(struct ref_transaction *transaction,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts UNUSED)
{
struct strbuf err = STRBUF_INIT;
char *refname, *old_target;
@@ -479,9 +527,9 @@ static void parse_cmd_symref_delete(struct ref_transaction *transaction,
strbuf_release(&err);
}
-
static void parse_cmd_verify(struct ref_transaction *transaction,
- const char *next, const char *end)
+ const char *next, const char *end,
+ struct command_options *opts UNUSED)
{
struct strbuf err = STRBUF_INIT;
char *refname;
@@ -508,7 +556,8 @@ static void parse_cmd_verify(struct ref_transaction *transaction,
}
static void parse_cmd_symref_verify(struct ref_transaction *transaction,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts UNUSED)
{
struct strbuf err = STRBUF_INIT;
struct object_id old_oid;
@@ -550,7 +599,8 @@ static void report_ok(const char *command)
}
static void parse_cmd_option(struct ref_transaction *transaction UNUSED,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts UNUSED)
{
const char *rest;
if (skip_prefix(next, "no-deref", &rest) && *rest == line_termination)
@@ -560,7 +610,8 @@ static void parse_cmd_option(struct ref_transaction *transaction UNUSED,
}
static void parse_cmd_start(struct ref_transaction *transaction UNUSED,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts UNUSED)
{
if (*next != line_termination)
die("start: extra input: %s", next);
@@ -568,7 +619,8 @@ static void parse_cmd_start(struct ref_transaction *transaction UNUSED,
}
static void parse_cmd_prepare(struct ref_transaction *transaction,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts UNUSED)
{
struct strbuf error = STRBUF_INIT;
if (*next != line_termination)
@@ -579,7 +631,8 @@ static void parse_cmd_prepare(struct ref_transaction *transaction,
}
static void parse_cmd_abort(struct ref_transaction *transaction,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts UNUSED)
{
struct strbuf error = STRBUF_INIT;
if (*next != line_termination)
@@ -590,7 +643,8 @@ static void parse_cmd_abort(struct ref_transaction *transaction,
}
static void parse_cmd_commit(struct ref_transaction *transaction,
- const char *next, const char *end UNUSED)
+ const char *next, const char *end UNUSED,
+ struct command_options *opts UNUSED)
{
struct strbuf error = STRBUF_INIT;
if (*next != line_termination)
@@ -618,7 +672,8 @@ enum update_refs_state {
static const struct parse_cmd {
const char *prefix;
- void (*fn)(struct ref_transaction *, const char *, const char *);
+ void (*fn)(struct ref_transaction *, const char *, const char *,
+ struct command_options *);
unsigned args;
enum update_refs_state state;
} command[] = {
@@ -644,6 +699,10 @@ static void update_refs_stdin(unsigned int flags)
struct ref_transaction *transaction;
int i, j;
+ struct command_options opts = {
+ .allow_update_failures = flags & REF_TRANSACTION_ALLOW_FAILURE,
+ };
+
transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),
flags, &err);
if (!transaction)
@@ -721,7 +780,7 @@ static void update_refs_stdin(unsigned int flags)
}
cmd->fn(transaction, input.buf + strlen(cmd->prefix) + !!cmd->args,
- input.buf + input.len);
+ input.buf + input.len, &opts);
}
switch (state) {
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 5/9] update-ref: move `print_rejected_refs()` up
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
The `print_rejected_refs()` function is used to print any rejected refs
when using git-updated-ref(1) with the '--batch-updates' option. In the
following commit, we'll need to use this function in another place, so
move the function up to avoid a separate forward declaration.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
builtin/update-ref.c | 45 ++++++++++++++++++++++-----------------------
1 file changed, 22 insertions(+), 23 deletions(-)
diff --git a/builtin/update-ref.c b/builtin/update-ref.c
index 2d68c40ecb..5259cc7226 100644
--- a/builtin/update-ref.c
+++ b/builtin/update-ref.c
@@ -234,6 +234,28 @@ static int parse_next_oid(const char **next, const char *end,
command, refname);
}
+static void print_rejected_refs(const char *refname,
+ const struct object_id *old_oid,
+ const struct object_id *new_oid,
+ const char *old_target,
+ const char *new_target,
+ enum ref_transaction_error err,
+ const char *details,
+ void *cb_data UNUSED)
+{
+ struct strbuf sb = STRBUF_INIT;
+
+ if (details && *details)
+ error("%s", details);
+
+ strbuf_addf(&sb, "rejected %s %s %s %s\n", refname,
+ new_oid ? oid_to_hex(new_oid) : new_target,
+ old_oid ? oid_to_hex(old_oid) : old_target,
+ ref_transaction_error_msg(err));
+
+ fwrite(sb.buf, sb.len, 1, stdout);
+ strbuf_release(&sb);
+}
/*
* The following five parse_cmd_*() functions parse the corresponding
@@ -567,29 +589,6 @@ static void parse_cmd_abort(struct ref_transaction *transaction,
report_ok("abort");
}
-static void print_rejected_refs(const char *refname,
- const struct object_id *old_oid,
- const struct object_id *new_oid,
- const char *old_target,
- const char *new_target,
- enum ref_transaction_error err,
- const char *details,
- void *cb_data UNUSED)
-{
- struct strbuf sb = STRBUF_INIT;
-
- if (details && *details)
- error("%s", details);
-
- strbuf_addf(&sb, "rejected %s %s %s %s\n", refname,
- new_oid ? oid_to_hex(new_oid) : new_target,
- old_oid ? oid_to_hex(old_oid) : old_target,
- ref_transaction_error_msg(err));
-
- fwrite(sb.buf, sb.len, 1, stdout);
- strbuf_release(&sb);
-}
-
static void parse_cmd_commit(struct ref_transaction *transaction,
const char *next, const char *end UNUSED)
{
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 4/9] refs: return `ref_transaction_error` from `ref_transaction_update()`
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
The `ref_transaction_update()` function is used to add updates to a
given reference transactions. In the following commit, we'll add more
validation to this function. As such, it would be beneficial if the
function returns specific error types, so callers can differentiate
between different errors.
To facilitate this, return `enum ref_transaction_error` from the
function and covert the existing '-1' returns to
'REF_TRANSACTION_ERROR_GENERIC'. Since this retains the existing
behavior, no changes are made to any of the callers but this sets the
necessary infrastructure for introduction of other errors.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
refs.c | 20 ++++++++++----------
refs.h | 16 ++++++++--------
2 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/refs.c b/refs.c
index 6b506aeea3..efa16b739d 100644
--- a/refs.c
+++ b/refs.c
@@ -1383,25 +1383,25 @@ static int transaction_refname_valid(const char *refname,
return 1;
}
-int ref_transaction_update(struct ref_transaction *transaction,
- const char *refname,
- const struct object_id *new_oid,
- const struct object_id *old_oid,
- const char *new_target,
- const char *old_target,
- unsigned int flags, const char *msg,
- struct strbuf *err)
+enum ref_transaction_error ref_transaction_update(struct ref_transaction *transaction,
+ const char *refname,
+ const struct object_id *new_oid,
+ const struct object_id *old_oid,
+ const char *new_target,
+ const char *old_target,
+ unsigned int flags, const char *msg,
+ struct strbuf *err)
{
assert(err);
if ((flags & REF_FORCE_CREATE_REFLOG) &&
(flags & REF_SKIP_CREATE_REFLOG)) {
strbuf_addstr(err, _("refusing to force and skip creation of reflog"));
- return -1;
+ return REF_TRANSACTION_ERROR_GENERIC;
}
if (!transaction_refname_valid(refname, new_oid, flags, err))
- return -1;
+ return REF_TRANSACTION_ERROR_GENERIC;
if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
diff --git a/refs.h b/refs.h
index d65de6ab5f..71d5c186d0 100644
--- a/refs.h
+++ b/refs.h
@@ -905,14 +905,14 @@ struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
* See the above comment "Reference transaction updates" for more
* information.
*/
-int ref_transaction_update(struct ref_transaction *transaction,
- const char *refname,
- const struct object_id *new_oid,
- const struct object_id *old_oid,
- const char *new_target,
- const char *old_target,
- unsigned int flags, const char *msg,
- struct strbuf *err);
+enum ref_transaction_error ref_transaction_update(struct ref_transaction *transaction,
+ const char *refname,
+ const struct object_id *new_oid,
+ const struct object_id *old_oid,
+ const char *new_target,
+ const char *old_target,
+ unsigned int flags, const char *msg,
+ struct strbuf *err);
/*
* Similar to `ref_transaction_update`, but this function is only for adding
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 3/9] refs: extract out reflog config to generic layer
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
The reference backends need to know when to create reflog entries, this
is dictated by the 'core.logallrefupdates' config. Instead of relying on
the backends to call `repo_settings_get_log_all_ref_updates()` to obtain
this config value, let's do this in the generic layer and pass down the
value to the backends.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
refs.c | 1 +
refs/files-backend.c | 2 +-
refs/refs-internal.h | 6 ++++++
refs/reftable-backend.c | 2 +-
4 files changed, 9 insertions(+), 2 deletions(-)
diff --git a/refs.c b/refs.c
index 8992dd6ae8..6b506aeea3 100644
--- a/refs.c
+++ b/refs.c
@@ -2297,6 +2297,7 @@ static struct ref_store *ref_store_init(struct repository *repo,
struct ref_store *refs;
struct ref_store_init_options opts = {
.access_flags = flags,
+ .log_all_ref_updates = repo_settings_get_log_all_ref_updates(repo),
};
be = find_ref_storage_backend(format);
diff --git a/refs/files-backend.c b/refs/files-backend.c
index 72afe62cee..4b2faf4777 100644
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -125,7 +125,7 @@ static struct ref_store *files_ref_store_init(struct repository *repo,
refs->packed_ref_store =
packed_ref_store_init(repo, NULL, refs->gitcommondir, opts);
refs->store_flags = opts->access_flags;
- refs->log_all_ref_updates = repo_settings_get_log_all_ref_updates(repo);
+ refs->log_all_ref_updates = opts->log_all_ref_updates;
repo_config_get_bool(repo, "core.prefersymlinkrefs", &refs->prefer_symlink_refs);
diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index f49b3807bf..d103387ebf 100644
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -392,6 +392,12 @@ struct ref_store;
struct ref_store_init_options {
/* The kind of operations that the ref_store is allowed to perform. */
unsigned int access_flags;
+
+ /*
+ * Denotes under what conditions reflogs should be created when updating
+ * references.
+ */
+ enum log_refs_config log_all_ref_updates;
};
/*
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index ad4ee2627c..93374d25c2 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -386,7 +386,7 @@ static struct ref_store *reftable_be_init(struct repository *repo,
base_ref_store_init(&refs->base, repo, refdir.buf, &refs_be_reftable);
strmap_init(&refs->worktree_backends);
- refs->log_all_ref_updates = repo_settings_get_log_all_ref_updates(repo);
+ refs->log_all_ref_updates = opts->log_all_ref_updates;
refs->store_flags = opts->access_flags;
switch (repo->hash_algo->format_id) {
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 2/9] refs: introduce `ref_store_init_options`
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
Reference backends are initiated via the `init()` function. When
initiating the function, the backend is also provided flags which denote
the access levels of the initiator. Create a new structure
`ref_store_init_options` to house such options and move the access flags
to this structure.
This allows easier extension of providing further options to the
backends. In the following commit, we'll also provide config around
reflog creation to the backends via the same structure.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
refs.c | 6 +++++-
refs/files-backend.c | 8 +++++---
refs/packed-backend.c | 4 ++--
refs/packed-backend.h | 3 ++-
refs/refs-internal.h | 11 ++++++++++-
refs/reftable-backend.c | 4 ++--
6 files changed, 26 insertions(+), 10 deletions(-)
diff --git a/refs.c b/refs.c
index bfcb9c7ac3..8992dd6ae8 100644
--- a/refs.c
+++ b/refs.c
@@ -2295,6 +2295,9 @@ static struct ref_store *ref_store_init(struct repository *repo,
{
const struct ref_storage_be *be;
struct ref_store *refs;
+ struct ref_store_init_options opts = {
+ .access_flags = flags,
+ };
be = find_ref_storage_backend(format);
if (!be)
@@ -2304,7 +2307,8 @@ static struct ref_store *ref_store_init(struct repository *repo,
* TODO Send in a 'struct worktree' instead of a 'gitdir', and
* allow the backend to handle how it wants to deal with worktrees.
*/
- refs = be->init(repo, repo->ref_storage_payload, gitdir, flags);
+ refs = be->init(repo, repo->ref_storage_payload, gitdir, &opts);
+
return refs;
}
diff --git a/refs/files-backend.c b/refs/files-backend.c
index b3b0c25f84..72afe62cee 100644
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -108,7 +108,7 @@ static void clear_loose_ref_cache(struct files_ref_store *refs)
static struct ref_store *files_ref_store_init(struct repository *repo,
const char *payload,
const char *gitdir,
- unsigned int flags)
+ const struct ref_store_init_options *opts)
{
struct files_ref_store *refs = xcalloc(1, sizeof(*refs));
struct ref_store *ref_store = (struct ref_store *)refs;
@@ -120,11 +120,13 @@ static struct ref_store *files_ref_store_init(struct repository *repo,
&ref_common_dir);
base_ref_store_init(ref_store, repo, refdir.buf, &refs_be_files);
- refs->store_flags = flags;
+
refs->gitcommondir = strbuf_detach(&ref_common_dir, NULL);
refs->packed_ref_store =
- packed_ref_store_init(repo, NULL, refs->gitcommondir, flags);
+ packed_ref_store_init(repo, NULL, refs->gitcommondir, opts);
+ refs->store_flags = opts->access_flags;
refs->log_all_ref_updates = repo_settings_get_log_all_ref_updates(repo);
+
repo_config_get_bool(repo, "core.prefersymlinkrefs", &refs->prefer_symlink_refs);
chdir_notify_reparent("files-backend $GIT_DIR", &refs->base.gitdir);
diff --git a/refs/packed-backend.c b/refs/packed-backend.c
index 23ed62984b..35a0f32e1c 100644
--- a/refs/packed-backend.c
+++ b/refs/packed-backend.c
@@ -218,14 +218,14 @@ static size_t snapshot_hexsz(const struct snapshot *snapshot)
struct ref_store *packed_ref_store_init(struct repository *repo,
const char *payload UNUSED,
const char *gitdir,
- unsigned int store_flags)
+ const struct ref_store_init_options *opts)
{
struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));
struct ref_store *ref_store = (struct ref_store *)refs;
struct strbuf sb = STRBUF_INIT;
base_ref_store_init(ref_store, repo, gitdir, &refs_be_packed);
- refs->store_flags = store_flags;
+ refs->store_flags = opts->access_flags;
strbuf_addf(&sb, "%s/packed-refs", gitdir);
refs->path = strbuf_detach(&sb, NULL);
diff --git a/refs/packed-backend.h b/refs/packed-backend.h
index 2c2377a356..1db48e801d 100644
--- a/refs/packed-backend.h
+++ b/refs/packed-backend.h
@@ -3,6 +3,7 @@
struct repository;
struct ref_transaction;
+struct ref_store_init_options;
/*
* Support for storing references in a `packed-refs` file.
@@ -16,7 +17,7 @@ struct ref_transaction;
struct ref_store *packed_ref_store_init(struct repository *repo,
const char *payload,
const char *gitdir,
- unsigned int store_flags);
+ const struct ref_store_init_options *options);
/*
* Lock the packed-refs file for writing. Flags is passed to
diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index 2d963cc4f4..f49b3807bf 100644
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -385,6 +385,15 @@ struct ref_store;
REF_STORE_ODB | \
REF_STORE_MAIN)
+/*
+ * Options for initializing the ref backend. All backend-agnostic information
+ * which backends required will be held here.
+ */
+struct ref_store_init_options {
+ /* The kind of operations that the ref_store is allowed to perform. */
+ unsigned int access_flags;
+};
+
/*
* Initialize the ref_store for the specified gitdir. These functions
* should call base_ref_store_init() to initialize the shared part of
@@ -393,7 +402,7 @@ struct ref_store;
typedef struct ref_store *ref_store_init_fn(struct repository *repo,
const char *payload,
const char *gitdir,
- unsigned int flags);
+ const struct ref_store_init_options *opts);
/*
* Release all memory and resources associated with the ref store.
*/
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index daea30a5b4..ad4ee2627c 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -369,7 +369,7 @@ static int reftable_be_config(const char *var, const char *value,
static struct ref_store *reftable_be_init(struct repository *repo,
const char *payload,
const char *gitdir,
- unsigned int store_flags)
+ const struct ref_store_init_options *opts)
{
struct reftable_ref_store *refs = xcalloc(1, sizeof(*refs));
struct strbuf ref_common_dir = STRBUF_INIT;
@@ -386,8 +386,8 @@ static struct ref_store *reftable_be_init(struct repository *repo,
base_ref_store_init(&refs->base, repo, refdir.buf, &refs_be_reftable);
strmap_init(&refs->worktree_backends);
- refs->store_flags = store_flags;
refs->log_all_ref_updates = repo_settings_get_log_all_ref_updates(repo);
+ refs->store_flags = opts->access_flags;
switch (repo->hash_algo->format_id) {
case GIT_SHA1_FORMAT_ID:
--
2.53.GIT
^ permalink raw reply related
* [PATCH v4 1/9] refs: remove unused typedef 'ref_transaction_commit_fn'
From: Karthik Nayak @ 2026-05-04 17:44 UTC (permalink / raw)
To: git; +Cc: ps, toon, Karthik Nayak
In-Reply-To: <20260504-refs-move-to-generic-layer-v4-0-936ac2f0b1a3@gmail.com>
The typedef 'ref_transaction_commit_fn' is not used anywhere in our
code, let's remove it.
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
---
refs/refs-internal.h | 4 ----
1 file changed, 4 deletions(-)
diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index d79e35fd26..2d963cc4f4 100644
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -421,10 +421,6 @@ typedef int ref_transaction_abort_fn(struct ref_store *refs,
struct ref_transaction *transaction,
struct strbuf *err);
-typedef int ref_transaction_commit_fn(struct ref_store *refs,
- struct ref_transaction *transaction,
- struct strbuf *err);
-
typedef int optimize_fn(struct ref_store *ref_store,
struct refs_optimize_opts *opts);
--
2.53.GIT
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox