Making pg_rewind faster

From 653ac0c2c2e4ba1b5b9069dff3d4bb618de58141 Mon Sep 17 00:00:00 2001
From: Justin Kwan <jkwan@cloudflare.com>
Date: Wed, 29 Jun 2022 14:12:50 -0700
Subject: [PATCH] Avoid copying WAL segments before divergence to speed up
 pg_rewind

"Optimize pg_rewind to Skip Copying Common WAL Files". It adds a conditional
check to avoid uncessesarily copying any WAL segment files from source to
target if they are common between both servers, before the point of WAL
divergence during pg_rewind. On the source server, each WAL file's
corresponding segment number is computed and compared against the segement
number of the first diverged LSN. All WAL files which fall before the segment
of the first diverged LSN can safely be skipped from copying to the target.

The reduction in WAL segment files transmitted over the network from source to
target server massively reduces overall pg_rewind execution time, when a large
amount of WAL segment files are retained.

This patch is intended for immediate application into the Postgres master
branch.

Regression tests are included to verify that WAL segment files prior to WAL
diverge are not copied. The source code successfully compiles, and all tests
successfully pass.

Author: Justin Kwan, Vignesh Ravichandran
---
 src/bin/pg_rewind/filemap.c                   | 25 +++++--
 src/bin/pg_rewind/pg_rewind.c                 | 38 +++++++++-
 src/bin/pg_rewind/pg_rewind.h                 |  2 +
 src/bin/pg_rewind/t/001_basic.pl              | 63 ++++++++++++++++
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 72 +++++++++++++++++++
 5 files changed, 193 insertions(+), 7 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 6252931041..1d3f52ec53 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -49,6 +49,7 @@ static uint32 hash_string_pointer(const char *s);
 #define SH_RAW_ALLOCATOR	pg_malloc0
 #define SH_DECLARE
 #define SH_DEFINE
+#include "access/xlog_internal.h"
 #include "lib/simplehash.h"
 
 #define FILEHASH_INITIAL_SIZE	1000
@@ -728,11 +729,25 @@ decide_file_action(file_entry_t *entry)
 		case FILE_TYPE_REGULAR:
 			if (!entry->isrelfile)
 			{
-				/*
-				 * It's a non-data file that we have no special processing
-				 * for. Copy it in toto.
-				 */
-				return FILE_ACTION_COPY;
+                /* Handle WAL segment file. */
+                const char  *fname;
+                char        *slash;
+
+                /* Split filepath into directory & filename. */
+                slash = strrchr(path, '/');
+                if (slash)
+					fname = slash + 1;
+                else
+					fname = path;
+
+				if (IsXLogFileName(fname))
+                    return decide_wal_file_action(fname);
+
+                /*
+                * It's a non-data file that we have no special processing
+                * for. Copy it in toto.
+                */
+                return FILE_ACTION_COPY;
 			}
 			else
 			{
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 1ff8da1676..b181de07d3 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -25,7 +25,6 @@
 #include "fe_utils/recovery_gen.h"
 #include "fe_utils/string_utils.h"
 #include "file_ops.h"
-#include "filemap.h"
 #include "getopt_long.h"
 #include "pg_rewind.h"
 #include "rewind_source.h"
@@ -69,6 +68,8 @@ bool		dry_run = false;
 bool		do_sync = true;
 bool		restore_wal = false;
 
+static XLogRecPtr   divergerec;
+
 /* Target history */
 TimeLineHistoryEntry *targetHistory;
 int			targetNentries;
@@ -129,7 +130,6 @@ main(int argc, char **argv)
 	};
 	int			option_index;
 	int			c;
-	XLogRecPtr	divergerec;
 	int			lastcommontliIndex;
 	XLogRecPtr	chkptrec;
 	TimeLineID	chkpttli;
@@ -490,6 +490,40 @@ main(int argc, char **argv)
 	return 0;
 }
 
+file_action_t
+decide_wal_file_action(const char *fname)
+{
+    TimeLineID  file_tli;
+    XLogSegNo	file_segno;
+    XLogSegNo   last_common_segno;
+
+    /*
+	 * Find last common WAL segment number between source and target before
+	 * divergence given last common LSN (byte position).
+	 */
+    XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
+    /* Get current WAL segment number given current segment file name. */
+    XLogFromFileName(fname, &file_tli, &file_segno, ControlFile_target.xlog_seg_size);
+
+    /*
+     * Avoid unnecessarily copying WAL segment files created before last common
+     * segment to avoid performance penalty when many WAL segment files are
+     * retained on source and copied to target.
+     *
+     * These files are already common between new source (old target) and new
+     * target (old source). Only WAL segment files after the last common segment
+     * number on the new source need to be copied to the new target.
+     */
+    if (file_segno < last_common_segno) {
+        pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+        return FILE_ACTION_NONE;
+    }
+
+    pg_log_debug("WAL file entry \"%s\" copied to target", fname);
+    return FILE_ACTION_COPY;
+}
+
 /*
  * Perform the rewind.
  *
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index 393182fe2a..aed95c3700 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -14,6 +14,7 @@
 #include "access/timeline.h"
 #include "common/logging.h"
 #include "datapagemap.h"
+#include "filemap.h"
 #include "libpq-fe.h"
 #include "storage/block.h"
 #include "storage/relfilenode.h"
@@ -44,6 +45,7 @@ extern void findLastCheckpoint(const char *datadir, XLogRecPtr searchptr,
 							   const char *restoreCommand);
 extern XLogRecPtr readOneRecord(const char *datadir, XLogRecPtr ptr,
 								int tliIndex, const char *restoreCommand);
+extern file_action_t decide_wal_file_action(const char *fname);
 
 /* in pg_rewind.c */
 extern void progress_report(bool finished);
diff --git a/src/bin/pg_rewind/t/001_basic.pl b/src/bin/pg_rewind/t/001_basic.pl
index db9201f38e..a64672ff38 100644
--- a/src/bin/pg_rewind/t/001_basic.pl
+++ b/src/bin/pg_rewind/t/001_basic.pl
@@ -78,6 +78,31 @@ sub run_test
 		"insert into drop_tbl values ('in primary, after promotion')");
 	primary_psql("DROP TABLE drop_tbl");
 
+	# Record last modification time of WAL segment file common between both
+	# source and target, stored on current primary server. pg_rewind should
+	# refrain from overwriting this file with the source's newly forked copy.
+	$node_primary->psql(
+		'postgres',
+		"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+		stdout => \my $common_wal_modified_at);
+
+	# Record last modification time of WAL segment file that is partially
+	# written to just before the new timeline, but still common between both
+	# source and target. pg_rewind should overwrite this file with the source's
+	# copy to be safe.
+	$node_primary->psql(
+		'postgres',
+		"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+		stdout => \my $last_common_tli1_wal_modified_at);
+
+	# Record last modification time of first diverged WAL segment file on the
+	# old primary's timeline. pg_rewind should overwrite this file with the
+	# source's newly forked copy.
+	$node_primary->psql(
+		'postgres',
+		"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+		stdout => \my $last_common_tli2_wal_modified_at);
+
 	# Before running pg_rewind, do a couple of extra tests with several
 	# option combinations.  As the code paths taken by those tests
 	# do not change for the "local" and "remote" modes, just run them
@@ -172,6 +197,44 @@ in primary, before promotion
 ),
 		'drop');
 
+	if ($test_mode eq 'local' || $test_mode eq 'remote')
+	{
+		# Last modification time of WAL segment files common between both
+		# source and target is unchanged on the target. This indicates that
+		# pg_rewind skipped copying the source's files and overwriting the
+		# target's files.
+		$node_primary->psql(
+			'postgres',
+			"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+			stdout => \my $common_wal_last_modified_at);
+
+		cmp_ok($common_wal_last_modified_at,
+			'==', $common_wal_modified_at,
+			'common WAL segment file on target, before divergence, not overwritten');
+
+		# Last modification time of WAL segment files just before and after
+		# the new timeline should now be further ahead. (Both of these WAL
+		# files are internally represented by segment 3.) This indicates that
+		# pg_rewind copied the source's files and overwrote the target's files.
+		$node_primary->psql(
+			'postgres',
+			"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+			stdout => \my $last_common_tli1_wal_last_modified_at);
+
+		cmp_ok($last_common_tli1_wal_last_modified_at,
+			'>=', $last_common_tli1_wal_modified_at,
+			'last common WAL segment file on target, before divergence, overwritten');
+
+		$node_primary->psql(
+			'postgres',
+			"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+			stdout => \my $last_common_tli2_wal_last_modified_at);
+
+		cmp_ok($last_common_tli2_wal_last_modified_at,
+			'>', $last_common_tli2_wal_modified_at,
+			'last common WAL segment file on target, before divergence, overwritten');
+	}
+
 	# Permissions on PGDATA should be default
   SKIP:
 	{
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index e6a7177fb7..ae17fbdb8d 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -136,6 +136,32 @@ $node_1->safe_psql('postgres',
 $node_2->poll_query_until('postgres',
 	q|SELECT COUNT(*) > 1 FROM public.bar|, 't');
 
+# Record last modification time of WAL segment file that is partially
+# written to just before the new timeline, but still common between both
+# source and target. pg_rewind should overwrite this file with the source's
+# copy to be safe.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+	stdout => \my $common_wal_modified_at);
+
+# Record last modification time of WAL segment file that is partially
+# written to just before the new timeline, but still common between both
+# source and target. pg_rewind should overwrite this file with the source's
+# copy to be safe.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+	stdout => \my $last_common_tli1_wal_modified_at);
+
+# Record last modification time of first diverged WAL segment file on the
+# old primary's timeline. pg_rewind should overwrite this file with the
+# source's newly forked copy.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+	stdout => \my $last_common_tli2_wal_modified_at);
+
 # At this point node_2 will shut down without a shutdown checkpoint,
 # but with WAL entries beyond the preceding shutdown checkpoint.
 $node_2->stop('fast');
@@ -174,4 +200,50 @@ and this too), 'table foo after rewind');
 $result = $node_2->safe_psql('postgres', 'SELECT * FROM public.bar');
 is($result, qq(in both), 'table bar after rewind');
 
+# Last modification time of WAL segment files common between both source and
+# target are unchanged on the target. This indicates that pg_rewind skipped
+# copying the source's files and overwriting the target's files.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+	stdout => \my $common_wal_last_modified_at);
+
+cmp_ok($common_wal_last_modified_at,
+	'==', $common_wal_modified_at,
+	'common WAL segment file on target, before divergence, not overwritten');
+
+# Last modification time of WAL segment files just before and after the new
+# timelines should now be further ahead. (Both of these WAL files are
+# internally represented by segment 3.) This indicates that pg_rewind copied
+# the source's files and overwrote the target's files.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+	stdout => \my $last_common_tli1_wal_last_modified_at);
+
+cmp_ok($last_common_tli1_wal_last_modified_at,
+	'>', $last_common_tli1_wal_modified_at,
+	'common WAL segment file on target, before divergence, not overwritten');
+
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+	stdout => \my $last_common_tli2_wal_last_modified_at);
+
+cmp_ok($last_common_tli2_wal_last_modified_at,
+	'>', $last_common_tli2_wal_modified_at,
+	'last common WAL segment file on target, before divergence, not overwritten');
+
+# Last modification time of WAL segment files in source but not target should
+# now be further ahead on the target. This indicates that pg_rewind copied the
+# source's files and overwrote the target's files.
+$node_2->psql(
+    'postgres',
+    "SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000030000000000000003');",
+    stdout => \my $first_diverged_tli3_wal_last_modified_at);
+
+cmp_ok($first_diverged_tli3_wal_last_modified_at,
+    '>=', $last_common_tli2_wal_modified_at,
+    'last common WAL segment file on target, before divergence, not overwritten');
+
 done_testing();
-- 
2.35.3

From 745fc4bde84cae7e595a65a0e23c8476b0e3e323 Mon Sep 17 00:00:00 2001
From: Justin Kwan <jkwan@cloudflare.com>
Date: Fri, 15 Jul 2022 18:48:59 -0700
Subject: [PATCH] Avoid copying WAL segments before divergence to speed up
 pg_rewind

"Optimize pg_rewind to Skip Copying Common WAL Files". It adds a conditional
check to avoid uncessesarily copying any WAL segment files from source to
target if they are common between both servers, before the point of WAL
divergence during pg_rewind. On the source server, each WAL file's
corresponding segment number is computed and compared against the segement
number of the first diverged LSN. All WAL files which fall before the segment
of the first diverged LSN can safely be skipped from copying to the target.

The reduction in WAL segment files transmitted over the network from source to
target server massively reduces overall pg_rewind execution time, when a large
amount of WAL segment files are retained.

This patch is intended for immediate application into the Postgres master
branch on version 14.4.

Regression tests are included to verify that WAL segment files prior to WAL
diverge are not copied. The source code successfully compiles, and all tests
successfully pass.

Author: Justin Kwan, Vignesh Ravichandran
---
 src/bin/pg_rewind/filemap.c                   | 25 +++++--
 src/bin/pg_rewind/pg_rewind.c                 | 39 +++++++++-
 src/bin/pg_rewind/pg_rewind.h                 |  2 +
 src/bin/pg_rewind/t/001_basic.pl              | 65 +++++++++++++++-
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 74 ++++++++++++++++++-
 5 files changed, 196 insertions(+), 9 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 2618b4c957..0df84bc115 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -26,6 +26,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include "access/xlog_internal.h"
 #include "catalog/pg_tablespace_d.h"
 #include "common/hashfn.h"
 #include "common/string.h"
@@ -729,11 +730,25 @@ decide_file_action(file_entry_t *entry)
 		case FILE_TYPE_REGULAR:
 			if (!entry->isrelfile)
 			{
-				/*
-				 * It's a non-data file that we have no special processing
-				 * for. Copy it in toto.
-				 */
-				return FILE_ACTION_COPY;
+                /* Handle WAL segment file. */
+                const char  *fname;
+                char        *slash;
+
+                /* Split filepath into directory & filename. */
+                slash = strrchr(path, '/');
+                if (slash)
+                    fname = slash + 1;
+                else
+                    fname = path;
+
+                if (IsXLogFileName(fname))
+                    return decide_wal_file_action(fname);
+
+                /*
+                 * It's a non-data file that we have no special processing
+                 * for. Copy it in toto.
+                 */
+                return FILE_ACTION_COPY;
 			}
 			else
 			{
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 2ac4910778..591f6674d7 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -24,7 +24,6 @@
 #include "common/string.h"
 #include "fe_utils/recovery_gen.h"
 #include "file_ops.h"
-#include "filemap.h"
 #include "getopt_long.h"
 #include "pg_rewind.h"
 #include "rewind_source.h"
@@ -67,6 +66,8 @@ bool		dry_run = false;
 bool		do_sync = true;
 bool		restore_wal = false;
 
+static XLogRecPtr   divergerec;
+
 /* Target history */
 TimeLineHistoryEntry *targetHistory;
 int			targetNentries;
@@ -124,7 +125,6 @@ main(int argc, char **argv)
 	};
 	int			option_index;
 	int			c;
-	XLogRecPtr	divergerec;
 	int			lastcommontliIndex;
 	XLogRecPtr	chkptrec;
 	TimeLineID	chkpttli;
@@ -483,6 +483,41 @@ main(int argc, char **argv)
 	return 0;
 }
 
+file_action_t
+decide_wal_file_action(const char *fname)
+{
+    TimeLineID  file_tli;
+    XLogSegNo	file_segno;
+    XLogSegNo   last_common_segno;
+
+    /*
+	 * Find last common WAL segment number between source and target before
+	 * divergence given last common LSN (byte position).
+	 */
+    XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
+    /* Get current WAL segment number given current segment file name. */
+    XLogFromFileName(fname, &file_tli, &file_segno, ControlFile_target.xlog_seg_size);
+
+    /*
+     * Avoid unnecessarily copying WAL segment files created before last common
+     * segment to avoid performance penalty when many WAL segment files are
+     * retained on source and copied to target.
+     *
+     * These files are already common between new source (old target) and new
+     * target (old source). Only WAL segment files after the last common segment
+     * number on the new source need to be copied to the new target.
+     */
+    if (file_segno < last_common_segno)
+    {
+        pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+        return FILE_ACTION_NONE;
+    }
+
+    pg_log_debug("WAL file entry \"%s\" copied to target", fname);
+    return FILE_ACTION_COPY;
+}
+
 /*
  * Perform the rewind.
  *
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index d38635a73d..c7c72d4b38 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -14,6 +14,7 @@
 #include "access/timeline.h"
 #include "common/logging.h"
 #include "datapagemap.h"
+#include "filemap.h"
 #include "libpq-fe.h"
 #include "storage/block.h"
 #include "storage/relfilenode.h"
@@ -50,6 +51,7 @@ extern XLogRecPtr readOneRecord(const char *datadir, XLogRecPtr ptr,
 
 /* in pg_rewind.c */
 extern void progress_report(bool finished);
+extern file_action_t decide_wal_file_action(const char *fname);
 
 /* in timeline.c */
 extern TimeLineHistoryEntry *rewind_parseTimeLineHistory(char *buffer,
diff --git a/src/bin/pg_rewind/t/001_basic.pl b/src/bin/pg_rewind/t/001_basic.pl
index d636f35f5e..f9a079357e 100644
--- a/src/bin/pg_rewind/t/001_basic.pl
+++ b/src/bin/pg_rewind/t/001_basic.pl
@@ -4,7 +4,7 @@
 use strict;
 use warnings;
 use TestLib;
-use Test::More tests => 23;
+use Test::More tests => 29;
 
 use FindBin;
 use lib $FindBin::RealBin;
@@ -78,6 +78,31 @@ sub run_test
 		"insert into drop_tbl values ('in primary, after promotion')");
 	primary_psql("DROP TABLE drop_tbl");
 
+	# Record last modification time of WAL segment file common between both
+	# source and target, stored on current primary server. pg_rewind should
+	# refrain from overwriting this file with the source's newly forked copy.
+	$node_primary->psql(
+		'postgres',
+		"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+		stdout => \my $common_wal_modified_at);
+
+	# Record last modification time of WAL segment file that is partially
+	# written to just before the new timeline, but still common between both
+	# source and target. pg_rewind should overwrite this file with the source's
+	# copy to be safe.
+	$node_primary->psql(
+		'postgres',
+		"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+		stdout => \my $last_common_tli1_wal_modified_at);
+
+	# Record last modification time of first diverged WAL segment file on the
+	# old primary's timeline. pg_rewind should overwrite this file with the
+	# source's newly forked copy.
+	$node_primary->psql(
+		'postgres',
+		"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+		stdout => \my $last_common_tli2_wal_modified_at);
+
 	# Before running pg_rewind, do a couple of extra tests with several
 	# option combinations.  As the code paths taken by those tests
 	# do not change for the "local" and "remote" modes, just run them
@@ -172,6 +197,44 @@ in primary, before promotion
 ),
 		'drop');
 
+	if ($test_mode eq 'local' || $test_mode eq 'remote')
+	{
+		# Last modification time of WAL segment files common between both
+		# source and target is unchanged on the target. This indicates that
+		# pg_rewind skipped copying the source's files and overwriting the
+		# target's files.
+		$node_primary->psql(
+			'postgres',
+			"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+			stdout => \my $common_wal_last_modified_at);
+
+		cmp_ok($common_wal_last_modified_at,
+			'==', $common_wal_modified_at,
+			'common WAL segment file on target, before divergence, not overwritten');
+
+		# Last modification time of WAL segment files just before and after
+		# the new timeline should now be further ahead. (Both of these WAL
+		# files are internally represented by segment 3.) This indicates that
+		# pg_rewind copied the source's files and overwrote the target's files.
+		$node_primary->psql(
+			'postgres',
+			"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+			stdout => \my $last_common_tli1_wal_last_modified_at);
+
+		cmp_ok($last_common_tli1_wal_last_modified_at,
+			'>=', $last_common_tli1_wal_modified_at,
+			'last common WAL segment file on target, before divergence, overwritten');
+
+		$node_primary->psql(
+			'postgres',
+			"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+			stdout => \my $last_common_tli2_wal_last_modified_at);
+
+		cmp_ok($last_common_tli2_wal_last_modified_at,
+			'>=', $last_common_tli2_wal_modified_at,
+			'last common WAL segment file on target, before divergence, overwritten');
+	}
+
 	# Permissions on PGDATA should be default
   SKIP:
 	{
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index 9ebcbad0d2..1fa3d0907f 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -34,7 +34,7 @@ use strict;
 use warnings;
 use PostgresNode;
 use TestLib;
-use Test::More tests => 3;
+use Test::More tests => 7;
 
 use File::Copy;
 
@@ -138,6 +138,32 @@ $node_1->safe_psql('postgres',
 $node_2->poll_query_until('postgres',
 	q|SELECT COUNT(*) > 1 FROM public.bar|, 't');
 
+# Record last modification time of WAL segment file that is partially
+# written to just before the new timeline, but still common between both
+# source and target. pg_rewind should overwrite this file with the source's
+# copy to be safe.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+	stdout => \my $common_wal_modified_at);
+
+# Record last modification time of WAL segment file that is partially
+# written to just before the new timeline, but still common between both
+# source and target. pg_rewind should overwrite this file with the source's
+# copy to be safe.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+	stdout => \my $last_common_tli1_wal_modified_at);
+
+# Record last modification time of first diverged WAL segment file on the
+# old primary's timeline. pg_rewind should overwrite this file with the
+# source's newly forked copy.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+	stdout => \my $last_common_tli2_wal_modified_at);
+
 # At this point node_2 will shut down without a shutdown checkpoint,
 # but with WAL entries beyond the preceding shutdown checkpoint.
 $node_2->stop('fast');
@@ -175,3 +201,49 @@ and this too), 'table foo after rewind');
 
 $result = $node_2->safe_psql('postgres', 'SELECT * FROM public.bar');
 is($result, qq(in both), 'table bar after rewind');
+
+# Last modification time of WAL segment files common between both source and
+# target are unchanged on the target. This indicates that pg_rewind skipped
+# copying the source's files and overwriting the target's files.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000002');",
+	stdout => \my $common_wal_last_modified_at);
+
+cmp_ok($common_wal_last_modified_at,
+	'==', $common_wal_modified_at,
+	'common WAL segment file on target, before divergence, not overwritten');
+
+# Last modification time of WAL segment files just before and after the new
+# timelines should now be further ahead. (Both of these WAL files are
+# internally represented by segment 3.) This indicates that pg_rewind copied
+# the source's files and overwrote the target's files.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000010000000000000003');",
+	stdout => \my $last_common_tli1_wal_last_modified_at);
+
+cmp_ok($last_common_tli1_wal_last_modified_at,
+	'>=', $last_common_tli1_wal_modified_at,
+	'common WAL segment file on target, before divergence, not overwritten');
+
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000020000000000000003');",
+	stdout => \my $last_common_tli2_wal_last_modified_at);
+
+cmp_ok($last_common_tli2_wal_last_modified_at,
+	'>=', $last_common_tli2_wal_modified_at,
+	'last common WAL segment file on target, before divergence, not overwritten');
+
+# Last modification time of WAL segment files in source but not target should
+# now be further ahead on the target. This indicates that pg_rewind copied the
+# source's files and overwrote the target's files.
+$node_2->psql(
+	'postgres',
+	"SELECT extract(epoch from modification) FROM pg_stat_file('pg_wal/000000030000000000000003');",
+	stdout => \my $first_diverged_tli3_wal_last_modified_at);
+
+cmp_ok($first_diverged_tli3_wal_last_modified_at,
+	'>=', $last_common_tli2_wal_modified_at,
+	'last common WAL segment file on target, before divergence, not overwritten');
-- 
2.35.3

From edb976cf1d2daedafef9cee1e36c4ef5f232e9aa Mon Sep 17 00:00:00 2001
From: Justin Kwan <jkwan@cloudflare.com>
Date: Tue, 19 Jul 2022 22:15:36 -0700
Subject: [PATCH 1/1] Avoid copying WAL segments before divergence to speed up
 pg_rewind

"Optimize pg_rewind to Skip Copying Common WAL Files". It adds a conditional
check to avoid uncessesarily copying any WAL segment files from source to
target if they are common between both servers, before the point of WAL
divergence during pg_rewind. On the source server, each WAL file's
corresponding segment number is computed and compared against the segement
number of the first diverged LSN. All WAL files which fall before the segment
of the first diverged LSN can safely be skipped from copying to the target.

The reduction in WAL segment files transmitted over the network from source to
target server massively reduces overall pg_rewind execution time, when a large
amount of WAL segment files are retained.

This patch is intended for immediate application into the Postgres master
branch on version 14.4.

Regression tests are included to verify that WAL segment files prior to WAL
diverge are not copied. The source code successfully compiles, and all tests
successfully pass.

Author: Justin Kwan, Vignesh Ravichandran
---
 src/bin/pg_rewind/filemap.c                   | 15 +++++
 src/bin/pg_rewind/pg_rewind.c                 | 39 ++++++++++-
 src/bin/pg_rewind/pg_rewind.h                 |  2 +
 src/bin/pg_rewind/t/001_basic.pl              | 65 +++++++++++++++++++
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 64 ++++++++++++++++++
 5 files changed, 183 insertions(+), 2 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 269ed6446e..2fd0523ce5 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -26,6 +26,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include "access/xlog_internal.h"
 #include "catalog/pg_tablespace_d.h"
 #include "common/hashfn.h"
 #include "common/string.h"
@@ -728,6 +729,20 @@ decide_file_action(file_entry_t *entry)
 		case FILE_TYPE_REGULAR:
 			if (!entry->isrelfile)
 			{
+                /* Handle WAL segment file. */
+                const char  *fname;
+                char        *slash;
+
+                /* Split filepath into directory & filename. */
+                slash = strrchr(path, '/');
+                if (slash)
+                    fname = slash + 1;
+                else
+                    fname = path;
+
+                if (IsXLogFileName(fname))
+                    return decide_wal_file_action(fname);
+
 				/*
 				 * It's a non-data file that we have no special processing
 				 * for. Copy it in toto.
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 1ff8da1676..7bdc3447c2 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -25,7 +25,6 @@
 #include "fe_utils/recovery_gen.h"
 #include "fe_utils/string_utils.h"
 #include "file_ops.h"
-#include "filemap.h"
 #include "getopt_long.h"
 #include "pg_rewind.h"
 #include "rewind_source.h"
@@ -69,6 +68,8 @@ bool		dry_run = false;
 bool		do_sync = true;
 bool		restore_wal = false;
 
+static XLogRecPtr   divergerec;
+
 /* Target history */
 TimeLineHistoryEntry *targetHistory;
 int			targetNentries;
@@ -129,7 +130,6 @@ main(int argc, char **argv)
 	};
 	int			option_index;
 	int			c;
-	XLogRecPtr	divergerec;
 	int			lastcommontliIndex;
 	XLogRecPtr	chkptrec;
 	TimeLineID	chkpttli;
@@ -490,6 +490,41 @@ main(int argc, char **argv)
 	return 0;
 }
 
+file_action_t
+decide_wal_file_action(const char *fname)
+{
+    TimeLineID  file_tli;
+    XLogSegNo	file_segno;
+    XLogSegNo   last_common_segno;
+
+    /*
+	 * Find last common WAL segment number between source and target before
+	 * divergence given last common LSN (byte position).
+	 */
+    XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
+    /* Get current WAL segment number given current segment file name. */
+    XLogFromFileName(fname, &file_tli, &file_segno, ControlFile_target.xlog_seg_size);
+
+    /*
+     * Avoid unnecessarily copying WAL segment files created before last common
+     * segment to avoid performance penalty when many WAL segment files are
+     * retained on source and copied to target.
+     *
+     * These files are already common between new source (old target) and new
+     * target (old source). Only WAL segment files after the last common segment
+     * number on the new source need to be copied to the new target.
+     */
+    if (file_segno < last_common_segno)
+    {
+        pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+        return FILE_ACTION_NONE;
+    }
+
+    pg_log_debug("WAL file entry \"%s\" is copied to target", fname);
+    return FILE_ACTION_COPY;
+}
+
 /*
  * Perform the rewind.
  *
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index 8b4b50a33b..0752348831 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -14,6 +14,7 @@
 #include "access/timeline.h"
 #include "common/logging.h"
 #include "datapagemap.h"
+#include "filemap.h"
 #include "libpq-fe.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
@@ -47,6 +48,7 @@ extern XLogRecPtr readOneRecord(const char *datadir, XLogRecPtr ptr,
 
 /* in pg_rewind.c */
 extern void progress_report(bool finished);
+extern file_action_t decide_wal_file_action(const char *fname);
 
 /* in timeline.c */
 extern TimeLineHistoryEntry *rewind_parseTimeLineHistory(char *buffer,
diff --git a/src/bin/pg_rewind/t/001_basic.pl b/src/bin/pg_rewind/t/001_basic.pl
index db9201f38e..7caff1c029 100644
--- a/src/bin/pg_rewind/t/001_basic.pl
+++ b/src/bin/pg_rewind/t/001_basic.pl
@@ -172,6 +172,71 @@ in primary, before promotion
 ),
 		'drop');
 
+	if ($test_mode eq 'archive')
+	{
+		goto SKIP;
+	}
+
+	# Read logs produced by pg_rewind
+	my $log_file_name =
+		"$PostgreSQL::Test::Utils::tmp_check/log/regress_log_001_basic";
+	my $pg_rewind_logs = do {
+		local $/ = undef;
+		open(my $log_file, '<', $log_file_name) || die;
+		<$log_file>;
+	};
+
+	# This WAL segment file is common between both source and target,
+	# originating before WAL timeline divergence. pg_rewind should not copy
+	# and overwrite this target file with the source's copy.
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: WAL file entry "000000010000000000000002" not copied to target/,
+		'common segment file skipped from copying');
+	unlike(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000010000000000000002 \(COPY\)/,
+		'common segment file not copied');
+	if ($test_mode eq 'remote')
+	{
+		unlike(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000002"/,
+			'common segment file copy not received by remote target');
+	}
+
+	# These WAL segment files occur just before and after the divergence to the
+	# new timeline. (Both of these WAL files are internally represented by
+	# segment 3.) pg_rewind should copy and overwrite these target files with
+	# the source's copies.
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: WAL file entry "000000010000000000000003" is copied to target/,
+		'diverged segment file included in copying to target');
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000010000000000000003 \(COPY\)/,
+		'diverged segment file copied');
+	if ($test_mode eq 'remote')
+	{
+		like(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000003"/,
+			'diverged segment file copy received by remote target');
+	}
+
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000020000000000000003 \(COPY\)/,
+		'diverged segment file included in copying to target');
+	if ($test_mode eq 'remote')
+	{
+		like(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000020000000000000003"/,
+			'diverged segment file copy received by remote target');
+	}
+
 	# Permissions on PGDATA should be default
   SKIP:
 	{
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index e6a7177fb7..204ec10738 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -174,4 +174,68 @@ and this too), 'table foo after rewind');
 $result = $node_2->safe_psql('postgres', 'SELECT * FROM public.bar');
 is($result, qq(in both), 'table bar after rewind');
 
+# Read logs produced by pg_rewind
+my $log_file_name =
+    "$PostgreSQL::Test::Utils::tmp_check/log/regress_log_008_min_recovery_point";
+my $pg_rewind_logs = do {
+	local $/ = undef;
+	open(my $log_file, '<', $log_file_name) || die;
+	<$log_file>;
+};
+
+# This WAL segment file is common between both source and target,
+# originating before WAL timeline divergence. pg_rewind should not copy
+# and overwrite this target file with the source's copy.
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000010000000000000002" not copied to target/,
+	'common segment file skipped from copying');
+unlike(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000010000000000000002 \(COPY\)/,
+	'common segment file not copied');
+unlike(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000002"/,
+	'common segment file copy not received by remote target');
+
+# These WAL segment files occur just before and after the divergence to the
+# new timeline. (Both of these WAL files are internally represented by
+# segment 3.) pg_rewind should copy and overwrite these target files with
+# the source's copies.
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000010000000000000003" is copied to target/,
+	'diverged segment file included in copying to target');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000010000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000003"/,
+	'diverged segment file copy received by remote target');
+
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000020000000000000003" is copied to target/,
+	'diverged segment file included in copying to target');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000020000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000020000000000000003"/,
+	'diverged segment file copy received by remote target');
+
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000030000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000030000000000000003"/,
+	'diverged segment file copy received by remote target');
+
 done_testing();
-- 
2.35.3

From edb976cf1d2daedafef9cee1e36c4ef5f232e9aa Mon Sep 17 00:00:00 2001
From: Justin Kwan <jkwan@cloudflare.com>
Date: Tue, 19 Jul 2022 22:15:36 -0700
Subject: [PATCH 1/1] Avoid copying WAL segments before divergence to speed up
 pg_rewind

"Optimize pg_rewind to Skip Copying Common WAL Files". It adds a conditional
check to avoid uncessesarily copying any WAL segment files from source to
target if they are common between both servers, before the point of WAL
divergence during pg_rewind. On the source server, each WAL file's
corresponding segment number is computed and compared against the segement
number of the first diverged LSN. All WAL files which fall before the segment
of the first diverged LSN can safely be skipped from copying to the target.

The reduction in WAL segment files transmitted over the network from source to
target server massively reduces overall pg_rewind execution time, when a large
amount of WAL segment files are retained.

This patch is intended for immediate application into the Postgres master
branch on version 14.4.

Regression tests are included to verify that WAL segment files prior to WAL
diverge are not copied. The source code successfully compiles, and all tests
successfully pass.

Author: Justin Kwan, Vignesh Ravichandran
---
 src/bin/pg_rewind/filemap.c                   | 15 +++++
 src/bin/pg_rewind/pg_rewind.c                 | 39 ++++++++++-
 src/bin/pg_rewind/pg_rewind.h                 |  2 +
 src/bin/pg_rewind/t/001_basic.pl              | 65 +++++++++++++++++++
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 64 ++++++++++++++++++
 5 files changed, 183 insertions(+), 2 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 269ed6446e..2fd0523ce5 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -26,6 +26,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include "access/xlog_internal.h"
 #include "catalog/pg_tablespace_d.h"
 #include "common/hashfn.h"
 #include "common/string.h"
@@ -728,6 +729,20 @@ decide_file_action(file_entry_t *entry)
 		case FILE_TYPE_REGULAR:
 			if (!entry->isrelfile)
 			{
+                /* Handle WAL segment file. */
+                const char  *fname;
+                char        *slash;
+
+                /* Split filepath into directory & filename. */
+                slash = strrchr(path, '/');
+                if (slash)
+                    fname = slash + 1;
+                else
+                    fname = path;
+
+                if (IsXLogFileName(fname))
+                    return decide_wal_file_action(fname);
+
 				/*
 				 * It's a non-data file that we have no special processing
 				 * for. Copy it in toto.
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 1ff8da1676..7bdc3447c2 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -25,7 +25,6 @@
 #include "fe_utils/recovery_gen.h"
 #include "fe_utils/string_utils.h"
 #include "file_ops.h"
-#include "filemap.h"
 #include "getopt_long.h"
 #include "pg_rewind.h"
 #include "rewind_source.h"
@@ -69,6 +68,8 @@ bool		dry_run = false;
 bool		do_sync = true;
 bool		restore_wal = false;
 
+static XLogRecPtr   divergerec;
+
 /* Target history */
 TimeLineHistoryEntry *targetHistory;
 int			targetNentries;
@@ -129,7 +130,6 @@ main(int argc, char **argv)
 	};
 	int			option_index;
 	int			c;
-	XLogRecPtr	divergerec;
 	int			lastcommontliIndex;
 	XLogRecPtr	chkptrec;
 	TimeLineID	chkpttli;
@@ -490,6 +490,41 @@ main(int argc, char **argv)
 	return 0;
 }
 
+file_action_t
+decide_wal_file_action(const char *fname)
+{
+    TimeLineID  file_tli;
+    XLogSegNo	file_segno;
+    XLogSegNo   last_common_segno;
+
+    /*
+	 * Find last common WAL segment number between source and target before
+	 * divergence given last common LSN (byte position).
+	 */
+    XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
+    /* Get current WAL segment number given current segment file name. */
+    XLogFromFileName(fname, &file_tli, &file_segno, ControlFile_target.xlog_seg_size);
+
+    /*
+     * Avoid unnecessarily copying WAL segment files created before last common
+     * segment to avoid performance penalty when many WAL segment files are
+     * retained on source and copied to target.
+     *
+     * These files are already common between new source (old target) and new
+     * target (old source). Only WAL segment files after the last common segment
+     * number on the new source need to be copied to the new target.
+     */
+    if (file_segno < last_common_segno)
+    {
+        pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+        return FILE_ACTION_NONE;
+    }
+
+    pg_log_debug("WAL file entry \"%s\" is copied to target", fname);
+    return FILE_ACTION_COPY;
+}
+
 /*
  * Perform the rewind.
  *
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index 8b4b50a33b..0752348831 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -14,6 +14,7 @@
 #include "access/timeline.h"
 #include "common/logging.h"
 #include "datapagemap.h"
+#include "filemap.h"
 #include "libpq-fe.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
@@ -47,6 +48,7 @@ extern XLogRecPtr readOneRecord(const char *datadir, XLogRecPtr ptr,
 
 /* in pg_rewind.c */
 extern void progress_report(bool finished);
+extern file_action_t decide_wal_file_action(const char *fname);
 
 /* in timeline.c */
 extern TimeLineHistoryEntry *rewind_parseTimeLineHistory(char *buffer,
diff --git a/src/bin/pg_rewind/t/001_basic.pl b/src/bin/pg_rewind/t/001_basic.pl
index db9201f38e..7caff1c029 100644
--- a/src/bin/pg_rewind/t/001_basic.pl
+++ b/src/bin/pg_rewind/t/001_basic.pl
@@ -172,6 +172,71 @@ in primary, before promotion
 ),
 		'drop');
 
+	if ($test_mode eq 'archive')
+	{
+		goto SKIP;
+	}
+
+	# Read logs produced by pg_rewind
+	my $log_file_name =
+		"$PostgreSQL::Test::Utils::tmp_check/log/regress_log_001_basic";
+	my $pg_rewind_logs = do {
+		local $/ = undef;
+		open(my $log_file, '<', $log_file_name) || die;
+		<$log_file>;
+	};
+
+	# This WAL segment file is common between both source and target,
+	# originating before WAL timeline divergence. pg_rewind should not copy
+	# and overwrite this target file with the source's copy.
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: WAL file entry "000000010000000000000002" not copied to target/,
+		'common segment file skipped from copying');
+	unlike(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000010000000000000002 \(COPY\)/,
+		'common segment file not copied');
+	if ($test_mode eq 'remote')
+	{
+		unlike(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000002"/,
+			'common segment file copy not received by remote target');
+	}
+
+	# These WAL segment files occur just before and after the divergence to the
+	# new timeline. (Both of these WAL files are internally represented by
+	# segment 3.) pg_rewind should copy and overwrite these target files with
+	# the source's copies.
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: WAL file entry "000000010000000000000003" is copied to target/,
+		'diverged segment file included in copying to target');
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000010000000000000003 \(COPY\)/,
+		'diverged segment file copied');
+	if ($test_mode eq 'remote')
+	{
+		like(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000003"/,
+			'diverged segment file copy received by remote target');
+	}
+
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000020000000000000003 \(COPY\)/,
+		'diverged segment file included in copying to target');
+	if ($test_mode eq 'remote')
+	{
+		like(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000020000000000000003"/,
+			'diverged segment file copy received by remote target');
+	}
+
 	# Permissions on PGDATA should be default
   SKIP:
 	{
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index e6a7177fb7..204ec10738 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -174,4 +174,68 @@ and this too), 'table foo after rewind');
 $result = $node_2->safe_psql('postgres', 'SELECT * FROM public.bar');
 is($result, qq(in both), 'table bar after rewind');
 
+# Read logs produced by pg_rewind
+my $log_file_name =
+    "$PostgreSQL::Test::Utils::tmp_check/log/regress_log_008_min_recovery_point";
+my $pg_rewind_logs = do {
+	local $/ = undef;
+	open(my $log_file, '<', $log_file_name) || die;
+	<$log_file>;
+};
+
+# This WAL segment file is common between both source and target,
+# originating before WAL timeline divergence. pg_rewind should not copy
+# and overwrite this target file with the source's copy.
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000010000000000000002" not copied to target/,
+	'common segment file skipped from copying');
+unlike(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000010000000000000002 \(COPY\)/,
+	'common segment file not copied');
+unlike(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000002"/,
+	'common segment file copy not received by remote target');
+
+# These WAL segment files occur just before and after the divergence to the
+# new timeline. (Both of these WAL files are internally represented by
+# segment 3.) pg_rewind should copy and overwrite these target files with
+# the source's copies.
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000010000000000000003" is copied to target/,
+	'diverged segment file included in copying to target');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000010000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000003"/,
+	'diverged segment file copy received by remote target');
+
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000020000000000000003" is copied to target/,
+	'diverged segment file included in copying to target');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000020000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000020000000000000003"/,
+	'diverged segment file copy received by remote target');
+
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000030000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000030000000000000003"/,
+	'diverged segment file copy received by remote target');
+
 done_testing();
-- 
2.35.3

From 44b987f4f21d4ff6c898b085db3c6c1094766f97 Mon Sep 17 00:00:00 2001
From: Justin Kwan <jkwan@cloudflare.com>
Date: Tue, 19 Jul 2022 22:15:36 -0700
Subject: [PATCH v3 1/2] Avoid copying WAL segments before divergence to speed
 up pg_rewind

"Optimize pg_rewind to Skip Copying Common WAL Files". It adds a conditional
check to avoid uncessesarily copying any WAL segment files from source to
target if they are common between both servers, before the point of WAL
divergence during pg_rewind. On the source server, each WAL file's
corresponding segment number is computed and compared against the segement
number of the first diverged LSN. All WAL files which fall before the segment
of the first diverged LSN can safely be skipped from copying to the target.

The reduction in WAL segment files transmitted over the network from source to
target server massively reduces overall pg_rewind execution time, when a large
amount of WAL segment files are retained.

This patch is intended for immediate application into the Postgres master
branch on version 14.4.

Regression tests are included to verify that WAL segment files prior to WAL
diverge are not copied. The source code successfully compiles, and all tests
successfully pass.

Author: Justin Kwan, Vignesh Ravichandran
---
 src/bin/pg_rewind/filemap.c                   | 15 +++++
 src/bin/pg_rewind/pg_rewind.c                 | 39 ++++++++++-
 src/bin/pg_rewind/pg_rewind.h                 |  2 +
 src/bin/pg_rewind/t/001_basic.pl              | 65 +++++++++++++++++++
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 64 ++++++++++++++++++
 5 files changed, 183 insertions(+), 2 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 269ed6446e6..2fd0523ce5b 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -26,6 +26,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include "access/xlog_internal.h"
 #include "catalog/pg_tablespace_d.h"
 #include "common/hashfn.h"
 #include "common/string.h"
@@ -728,6 +729,20 @@ decide_file_action(file_entry_t *entry)
 		case FILE_TYPE_REGULAR:
 			if (!entry->isrelfile)
 			{
+                /* Handle WAL segment file. */
+                const char  *fname;
+                char        *slash;
+
+                /* Split filepath into directory & filename. */
+                slash = strrchr(path, '/');
+                if (slash)
+                    fname = slash + 1;
+                else
+                    fname = path;
+
+                if (IsXLogFileName(fname))
+                    return decide_wal_file_action(fname);
+
 				/*
 				 * It's a non-data file that we have no special processing
 				 * for. Copy it in toto.
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 3cd77c09b1a..4ac38427b38 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -25,7 +25,6 @@
 #include "fe_utils/recovery_gen.h"
 #include "fe_utils/string_utils.h"
 #include "file_ops.h"
-#include "filemap.h"
 #include "getopt_long.h"
 #include "pg_rewind.h"
 #include "rewind_source.h"
@@ -69,6 +68,8 @@ bool		dry_run = false;
 bool		do_sync = true;
 bool		restore_wal = false;
 
+static XLogRecPtr   divergerec;
+
 /* Target history */
 TimeLineHistoryEntry *targetHistory;
 int			targetNentries;
@@ -129,7 +130,6 @@ main(int argc, char **argv)
 	};
 	int			option_index;
 	int			c;
-	XLogRecPtr	divergerec;
 	int			lastcommontliIndex;
 	XLogRecPtr	chkptrec;
 	TimeLineID	chkpttli;
@@ -490,6 +490,41 @@ main(int argc, char **argv)
 	return 0;
 }
 
+file_action_t
+decide_wal_file_action(const char *fname)
+{
+    TimeLineID  file_tli;
+    XLogSegNo	file_segno;
+    XLogSegNo   last_common_segno;
+
+    /*
+	 * Find last common WAL segment number between source and target before
+	 * divergence given last common LSN (byte position).
+	 */
+    XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
+    /* Get current WAL segment number given current segment file name. */
+    XLogFromFileName(fname, &file_tli, &file_segno, ControlFile_target.xlog_seg_size);
+
+    /*
+     * Avoid unnecessarily copying WAL segment files created before last common
+     * segment to avoid performance penalty when many WAL segment files are
+     * retained on source and copied to target.
+     *
+     * These files are already common between new source (old target) and new
+     * target (old source). Only WAL segment files after the last common segment
+     * number on the new source need to be copied to the new target.
+     */
+    if (file_segno < last_common_segno)
+    {
+        pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+        return FILE_ACTION_NONE;
+    }
+
+    pg_log_debug("WAL file entry \"%s\" is copied to target", fname);
+    return FILE_ACTION_COPY;
+}
+
 /*
  * Perform the rewind.
  *
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index 80c276285a9..64b84ff1217 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -14,6 +14,7 @@
 #include "access/timeline.h"
 #include "common/logging.h"
 #include "datapagemap.h"
+#include "filemap.h"
 #include "libpq-fe.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
@@ -47,6 +48,7 @@ extern XLogRecPtr readOneRecord(const char *datadir, XLogRecPtr ptr,
 
 /* in pg_rewind.c */
 extern void progress_report(bool finished);
+extern file_action_t decide_wal_file_action(const char *fname);
 
 /* in timeline.c */
 extern TimeLineHistoryEntry *rewind_parseTimeLineHistory(char *buffer,
diff --git a/src/bin/pg_rewind/t/001_basic.pl b/src/bin/pg_rewind/t/001_basic.pl
index db9201f38e8..7caff1c0296 100644
--- a/src/bin/pg_rewind/t/001_basic.pl
+++ b/src/bin/pg_rewind/t/001_basic.pl
@@ -172,6 +172,71 @@ in primary, before promotion
 ),
 		'drop');
 
+	if ($test_mode eq 'archive')
+	{
+		goto SKIP;
+	}
+
+	# Read logs produced by pg_rewind
+	my $log_file_name =
+		"$PostgreSQL::Test::Utils::tmp_check/log/regress_log_001_basic";
+	my $pg_rewind_logs = do {
+		local $/ = undef;
+		open(my $log_file, '<', $log_file_name) || die;
+		<$log_file>;
+	};
+
+	# This WAL segment file is common between both source and target,
+	# originating before WAL timeline divergence. pg_rewind should not copy
+	# and overwrite this target file with the source's copy.
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: WAL file entry "000000010000000000000002" not copied to target/,
+		'common segment file skipped from copying');
+	unlike(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000010000000000000002 \(COPY\)/,
+		'common segment file not copied');
+	if ($test_mode eq 'remote')
+	{
+		unlike(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000002"/,
+			'common segment file copy not received by remote target');
+	}
+
+	# These WAL segment files occur just before and after the divergence to the
+	# new timeline. (Both of these WAL files are internally represented by
+	# segment 3.) pg_rewind should copy and overwrite these target files with
+	# the source's copies.
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: WAL file entry "000000010000000000000003" is copied to target/,
+		'diverged segment file included in copying to target');
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000010000000000000003 \(COPY\)/,
+		'diverged segment file copied');
+	if ($test_mode eq 'remote')
+	{
+		like(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000003"/,
+			'diverged segment file copy received by remote target');
+	}
+
+	like(
+		$pg_rewind_logs,
+		qr/pg_rewind: pg_wal\/000000020000000000000003 \(COPY\)/,
+		'diverged segment file included in copying to target');
+	if ($test_mode eq 'remote')
+	{
+		like(
+			$pg_rewind_logs,
+			qr/pg_rewind: received chunk for file "pg_wal\/000000020000000000000003"/,
+			'diverged segment file copy received by remote target');
+	}
+
 	# Permissions on PGDATA should be default
   SKIP:
 	{
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index e6a7177fb7d..204ec107382 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -174,4 +174,68 @@ and this too), 'table foo after rewind');
 $result = $node_2->safe_psql('postgres', 'SELECT * FROM public.bar');
 is($result, qq(in both), 'table bar after rewind');
 
+# Read logs produced by pg_rewind
+my $log_file_name =
+    "$PostgreSQL::Test::Utils::tmp_check/log/regress_log_008_min_recovery_point";
+my $pg_rewind_logs = do {
+	local $/ = undef;
+	open(my $log_file, '<', $log_file_name) || die;
+	<$log_file>;
+};
+
+# This WAL segment file is common between both source and target,
+# originating before WAL timeline divergence. pg_rewind should not copy
+# and overwrite this target file with the source's copy.
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000010000000000000002" not copied to target/,
+	'common segment file skipped from copying');
+unlike(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000010000000000000002 \(COPY\)/,
+	'common segment file not copied');
+unlike(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000002"/,
+	'common segment file copy not received by remote target');
+
+# These WAL segment files occur just before and after the divergence to the
+# new timeline. (Both of these WAL files are internally represented by
+# segment 3.) pg_rewind should copy and overwrite these target files with
+# the source's copies.
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000010000000000000003" is copied to target/,
+	'diverged segment file included in copying to target');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000010000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000010000000000000003"/,
+	'diverged segment file copy received by remote target');
+
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: WAL file entry "000000020000000000000003" is copied to target/,
+	'diverged segment file included in copying to target');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000020000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000020000000000000003"/,
+	'diverged segment file copy received by remote target');
+
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: pg_wal\/000000030000000000000003 \(COPY\)/,
+	'diverged segment file copied');
+like(
+	$pg_rewind_logs,
+	qr/pg_rewind: received chunk for file "pg_wal\/000000030000000000000003"/,
+	'diverged segment file copy received by remote target');
+
 done_testing();
-- 
2.37.3.542.gdd3f6c4cae

From e29ff080ba2f712522e42ebb8cbdafc934e40f04 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Sun, 2 Oct 2022 10:36:55 -0700
Subject: [PATCH v3 2/2] Fix log file names used in tests

---
 src/bin/pg_rewind/t/001_basic.pl              | 4 ++--
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/bin/pg_rewind/t/001_basic.pl b/src/bin/pg_rewind/t/001_basic.pl
index 7caff1c0296..cad6cf5b43a 100644
--- a/src/bin/pg_rewind/t/001_basic.pl
+++ b/src/bin/pg_rewind/t/001_basic.pl
@@ -179,10 +179,10 @@ in primary, before promotion
 
 	# Read logs produced by pg_rewind
 	my $log_file_name =
-		"$PostgreSQL::Test::Utils::tmp_check/log/regress_log_001_basic";
+		"$PostgreSQL::Test::Utils::log_path/regress_log_001_basic";
 	my $pg_rewind_logs = do {
 		local $/ = undef;
-		open(my $log_file, '<', $log_file_name) || die;
+		open(my $log_file, '<', $log_file_name) || die "could not open $log_file_name: $!";
 		<$log_file>;
 	};
 
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index 204ec107382..deb7d00e3fa 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -176,10 +176,10 @@ is($result, qq(in both), 'table bar after rewind');
 
 # Read logs produced by pg_rewind
 my $log_file_name =
-    "$PostgreSQL::Test::Utils::tmp_check/log/regress_log_008_min_recovery_point";
+    "$PostgreSQL::Test::Utils::log_path/regress_log_008_min_recovery_point";
 my $pg_rewind_logs = do {
 	local $/ = undef;
-	open(my $log_file, '<', $log_file_name) || die;
+	open(my $log_file, '<', $log_file_name) || die "could not open $log_file_name: $!";
 	<$log_file>;
 };
 
-- 
2.37.3.542.gdd3f6c4cae

From 1825113812381f52c52e74a3e0e3e4c519f218bc Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Tue, 1 Jul 2025 18:05:37 +0000
Subject: [PATCH] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a conditional check to avoid unnecessarily copying any
WAL segment files from source to target if they are common
between both servers before the point of WAL divergence
during pg_rewind. On the source server, each WAL file's.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target.
---
 src/bin/pg_rewind/filemap.c                   | 40 ++++++++++++++++--
 src/bin/pg_rewind/filemap.h                   |  9 +++-
 src/bin/pg_rewind/pg_rewind.c                 | 41 +++++++++++++++++++
 src/bin/pg_rewind/pg_rewind.h                 |  2 +
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 18 +++++++-
 5 files changed, 104 insertions(+), 6 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..79e5bbd7710 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -58,6 +58,7 @@ static filehash_hash *filehash;
 static bool isRelDataFile(const char *path);
 static char *datasegpath(RelFileLocator rlocator, ForkNumber forknum,
 						 BlockNumber segno);
+static file_content_type_t getFileType(const char *path);
 
 static file_entry_t *insert_filehash_entry(const char *path);
 static file_entry_t *lookup_filehash_entry(const char *path);
@@ -199,6 +200,28 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+/* Determine the type of file content (relation, WAL, or other) */
+static file_content_type_t
+getFileType(const char *path)
+{
+	if (isRelDataFile(path))
+		return FILE_CONTENT_TYPE_RELATION;
+	else
+	{
+		/* Extract the filename from the path */
+		const char *filename = last_dir_separator(path);
+		if (filename == NULL)
+			filename = path;
+		else
+			filename++;  /* Skip the separator */
+
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+	}
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +233,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -383,7 +406,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -799,7 +822,18 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++;  /* Skip the separator */
+
+				return decide_wal_file_action(filename);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..fada420fc23 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -36,6 +36,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+} file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +58,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 9d16c1e6b47..917bc298cad 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -56,6 +56,9 @@ static void findCommonAncestorTimeline(TimeLineHistoryEntry *a_history,
 static void ensureCleanShutdown(const char *argv0);
 static void disconnect_atexit(void);
 
+/* WAL segment files handling */
+file_action_t decide_wal_file_action(const char *fname);
+
 static ControlFileData ControlFile_target;
 static ControlFileData ControlFile_source;
 static ControlFileData ControlFile_source_after;
@@ -88,6 +91,9 @@ uint64		fetch_done;
 static PGconn *conn;
 static rewind_source *source;
 
+/* Segment number of the divergence record */
+XLogSegNo last_common_segno;
+
 static void
 usage(const char *progname)
 {
@@ -397,6 +403,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -1204,3 +1213,35 @@ disconnect_atexit(void)
 	if (conn != NULL)
 		PQfinish(conn);
 }
+
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+file_action_t
+decide_wal_file_action(const char *fname)
+{
+	TimeLineID  file_tli;
+	XLogSegNo   file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, ControlFile_target.xlog_seg_size);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target.
+	 * Only WAL segment files after the last common segment number on
+	 * the new source need to be copied to the new target.
+	 */
+	if (file_segno < last_common_segno)
+	{
+		pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	pg_log_debug("WAL file entry \"%s\" is copied to target", fname);
+	return FILE_ACTION_COPY;
+}
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index 9cea144d2b2..421b4201998 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -14,6 +14,7 @@
 #include "access/timeline.h"
 #include "common/logging.h"
 #include "common/file_utils.h"
+#include "filemap.h"
 
 /* Configuration options */
 extern char *datadir_target;
@@ -45,6 +46,7 @@ extern XLogRecPtr readOneRecord(const char *datadir, XLogRecPtr ptr,
 
 /* in pg_rewind.c */
 extern void progress_report(bool finished);
+extern file_action_t decide_wal_file_action(const char *fname);
 
 /* in timeline.c */
 extern TimeLineHistoryEntry *rewind_parseTimeLineHistory(char *buffer,
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index 28496afe350..ea279a9ee4b 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -71,6 +71,9 @@ $node_3->start;
 # Wait until node 3 has connected and caught up
 $node_1->wait_for_catchup('node_3');
 
+# Current common WAL segment
+my $wal_seg_skipped = $node_1->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
 #
 # Swap the roles of node_1 and node_3, so that node_1 follows node_3.
 #
@@ -93,6 +96,10 @@ primary_conninfo='$node_3_connstr'
 ));
 $node_2->restart();
 
+# Confirm WAL segment has advanced for promotion
+my $advanced_wal_segment = $node_3->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+isnt($wal_seg_skipped, $advanced_wal_segment, "Expected WAL segment to have advanced");
+
 #
 # Promote node_1, to create a split-brain scenario.
 #
@@ -140,14 +147,21 @@ copy(
 	"$node_2_pgdata/postgresql.conf",
 	"$tmp_folder/node_2-postgresql.conf.tmp");
 
-command_ok(
+command_checks_all(
 	[
 		'pg_rewind',
 		'--source-server' => $node_1_connstr,
 		'--target-pgdata' => $node_2_pgdata,
 		'--debug',
 	],
-	'run pg_rewind');
+	0,
+	[
+		#  qr/"WAL file entry $wal_seg_skipped not copied to target"/
+		qr//
+	],
+	[qr//],
+	'run pg_rewind'
+);
 
 # Now move back postgresql.conf with old settings
 move(
-- 
2.47.1

From 3de0c93d385c7127b87b5b9e3a9a9eb1c5aad237 Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Tue, 1 Jul 2025 18:05:37 +0000
Subject: [PATCH] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a conditional check to avoid unnecessarily copying any
WAL segment files from source to target if they are common
between both servers before the point of WAL divergence
during pg_rewind. On the source server, each WAL file's.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target.
---
 src/bin/pg_rewind/filemap.c                   | 77 +++++++++++++++++--
 src/bin/pg_rewind/filemap.h                   | 12 ++-
 src/bin/pg_rewind/pg_rewind.c                 |  6 +-
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 18 ++++-
 4 files changed, 102 insertions(+), 11 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..74800568be5 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -199,6 +199,28 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+/* Determine the type of file content (relation, WAL, or other) */
+static file_content_type_t
+getFileType(const char *path)
+{
+	if (isRelDataFile(path))
+		return FILE_CONTENT_TYPE_RELATION;
+	else
+	{
+		/* Extract the filename from the path */
+		const char *filename = last_dir_separator(path);
+		if (filename == NULL)
+			filename = path;
+		else
+			filename++;  /* Skip the separator */
+
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+	}
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +232,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -383,7 +405,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -693,11 +715,43 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname, XLogSegNo last_common_segno, int wal_segsz_bytes)
+{
+	TimeLineID  file_tli;
+	XLogSegNo   file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, wal_segsz_bytes);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target.
+	 * Only WAL segment files after the last common segment number on
+	 * the new source need to be copied to the new target.
+	 */
+	if (file_segno < last_common_segno)
+	{
+		pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	pg_log_debug("WAL file entry \"%s\" is copied to target", fname);
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
 static file_action_t
-decide_file_action(file_entry_t *entry)
+decide_file_action(file_entry_t *entry, XLogSegNo last_common_segno, int wal_segsz_bytes)
 {
 	const char *path = entry->path;
 
@@ -799,7 +853,18 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++;  /* Skip the separator */
+
+				return decide_wal_file_action(filename, last_common_segno, wal_segsz_bytes);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
@@ -858,7 +923,7 @@ decide_file_action(file_entry_t *entry)
  * should be executed.
  */
 filemap_t *
-decide_file_actions(void)
+decide_file_actions(XLogSegNo last_common_segno, int wal_segsz_bytes)
 {
 	int			i;
 	filehash_iterator it;
@@ -868,7 +933,7 @@ decide_file_actions(void)
 	filehash_start_iterate(filehash, &it);
 	while ((entry = filehash_iterate(filehash, &it)) != NULL)
 	{
-		entry->action = decide_file_action(entry);
+		entry->action = decide_file_action(entry, last_common_segno, wal_segsz_bytes);
 	}
 
 	/*
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..ef1f539f1d1 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -36,6 +37,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+} file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +59,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
@@ -106,7 +114,7 @@ extern void process_target_wal_block_change(ForkNumber forknum,
 											RelFileLocator rlocator,
 											BlockNumber blkno);
 
-extern filemap_t *decide_file_actions(void);
+extern filemap_t *decide_file_actions(XLogSegNo last_common_segno, int wal_segsz_bytes);
 extern void calculate_totals(filemap_t *filemap);
 extern void print_filemap(filemap_t *filemap);
 
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 9d16c1e6b47..aaee5ceba84 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -153,6 +153,7 @@ main(int argc, char **argv)
 	bool		rewind_needed;
 	bool		writerecoveryconf = false;
 	filemap_t  *filemap;
+	XLogSegNo	last_common_segno;
 
 	pg_logging_init(argv[0]);
 	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_rewind"));
@@ -397,6 +398,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -492,7 +496,7 @@ main(int argc, char **argv)
 	 * We have collected all information we need from both systems. Decide
 	 * what to do with each file.
 	 */
-	filemap = decide_file_actions();
+	filemap = decide_file_actions(last_common_segno, ControlFile_target.xlog_seg_size);
 	if (showprogress)
 		calculate_totals(filemap);
 
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index 28496afe350..ea279a9ee4b 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -71,6 +71,9 @@ $node_3->start;
 # Wait until node 3 has connected and caught up
 $node_1->wait_for_catchup('node_3');
 
+# Current common WAL segment
+my $wal_seg_skipped = $node_1->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
 #
 # Swap the roles of node_1 and node_3, so that node_1 follows node_3.
 #
@@ -93,6 +96,10 @@ primary_conninfo='$node_3_connstr'
 ));
 $node_2->restart();
 
+# Confirm WAL segment has advanced for promotion
+my $advanced_wal_segment = $node_3->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+isnt($wal_seg_skipped, $advanced_wal_segment, "Expected WAL segment to have advanced");
+
 #
 # Promote node_1, to create a split-brain scenario.
 #
@@ -140,14 +147,21 @@ copy(
 	"$node_2_pgdata/postgresql.conf",
 	"$tmp_folder/node_2-postgresql.conf.tmp");
 
-command_ok(
+command_checks_all(
 	[
 		'pg_rewind',
 		'--source-server' => $node_1_connstr,
 		'--target-pgdata' => $node_2_pgdata,
 		'--debug',
 	],
-	'run pg_rewind');
+	0,
+	[
+		#  qr/"WAL file entry $wal_seg_skipped not copied to target"/
+		qr//
+	],
+	[qr//],
+	'run pg_rewind'
+);
 
 # Now move back postgresql.conf with old settings
 move(
-- 
2.47.1

From 1fd59466ad598b00d613fd3fec85466d46d3d122 Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Thu, 3 Jul 2025 19:39:37 +0000
Subject: [PATCH] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a conditional check to avoid unnecessarily copying any
WAL segment files from source to target if they are common
between both servers before the point of WAL divergence
during pg_rewind. On the source server, each WAL file's.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target.
---
 src/bin/pg_rewind/filemap.c                   | 71 ++++++++++++++++++-
 src/bin/pg_rewind/filemap.h                   | 10 ++-
 src/bin/pg_rewind/pg_rewind.c                 |  5 +-
 src/bin/pg_rewind/pg_rewind.h                 |  4 ++
 src/bin/pg_rewind/t/008_min_recovery_point.pl | 18 ++++-
 5 files changed, 101 insertions(+), 7 deletions(-)

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..14c7643f0e0 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -199,6 +199,28 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+/* Determine the type of file content (relation, WAL, or other) */
+static file_content_type_t
+getFileContentType(const char *path)
+{
+	if (isRelDataFile(path))
+		return FILE_CONTENT_TYPE_RELATION;
+	else
+	{
+		/* Extract the filename from the path */
+		const char *filename = last_dir_separator(path);
+		if (filename == NULL)
+			filename = path;
+		else
+			filename++;  /* Skip the separator */
+
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+	}
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +232,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileContentType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -383,7 +405,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -693,6 +715,38 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname)
+{
+	TimeLineID  file_tli;
+	XLogSegNo   file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target.
+	 * Only WAL segment files after the last common segment number on
+	 * the new source need to be copied to the new target.
+	 */
+	if (file_segno < last_common_segno)
+	{
+		pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	pg_log_debug("WAL file entry \"%s\" is copied to target", fname);
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
@@ -799,7 +853,18 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++;  /* Skip the separator */
+
+				return decide_wal_file_action(filename);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..53082ceba3c 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -36,6 +37,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+} file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +59,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 9d16c1e6b47..83a64270418 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -15,7 +15,6 @@
 #include <unistd.h>
 
 #include "access/timeline.h"
-#include "access/xlog_internal.h"
 #include "catalog/catversion.h"
 #include "catalog/pg_control.h"
 #include "common/controldata_utils.h"
@@ -62,6 +61,7 @@ static ControlFileData ControlFile_source_after;
 
 static const char *progname;
 int			WalSegSz;
+XLogSegNo		last_common_segno;
 
 /* Configuration options */
 char	   *datadir_target = NULL;
@@ -397,6 +397,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index 9cea144d2b2..759be379e12 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -12,6 +12,7 @@
 #define PG_REWIND_H
 
 #include "access/timeline.h"
+#include "access/xlog_internal.h"
 #include "common/logging.h"
 #include "common/file_utils.h"
 
@@ -51,4 +52,7 @@ extern TimeLineHistoryEntry *rewind_parseTimeLineHistory(char *buffer,
 														 TimeLineID targetTLI,
 														 int *nentries);
 
+/* optimize WAL files copied */
+extern XLogSegNo last_common_segno;
+
 #endif							/* PG_REWIND_H */
diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl
index 28496afe350..ea279a9ee4b 100644
--- a/src/bin/pg_rewind/t/008_min_recovery_point.pl
+++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl
@@ -71,6 +71,9 @@ $node_3->start;
 # Wait until node 3 has connected and caught up
 $node_1->wait_for_catchup('node_3');
 
+# Current common WAL segment
+my $wal_seg_skipped = $node_1->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
 #
 # Swap the roles of node_1 and node_3, so that node_1 follows node_3.
 #
@@ -93,6 +96,10 @@ primary_conninfo='$node_3_connstr'
 ));
 $node_2->restart();
 
+# Confirm WAL segment has advanced for promotion
+my $advanced_wal_segment = $node_3->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+isnt($wal_seg_skipped, $advanced_wal_segment, "Expected WAL segment to have advanced");
+
 #
 # Promote node_1, to create a split-brain scenario.
 #
@@ -140,14 +147,21 @@ copy(
 	"$node_2_pgdata/postgresql.conf",
 	"$tmp_folder/node_2-postgresql.conf.tmp");
 
-command_ok(
+command_checks_all(
 	[
 		'pg_rewind',
 		'--source-server' => $node_1_connstr,
 		'--target-pgdata' => $node_2_pgdata,
 		'--debug',
 	],
-	'run pg_rewind');
+	0,
+	[
+		#  qr/"WAL file entry $wal_seg_skipped not copied to target"/
+		qr//
+	],
+	[qr//],
+	'run pg_rewind'
+);
 
 # Now move back postgresql.conf with old settings
 move(
-- 
2.47.1

From 1c2d9a0fc6ff551c1eec0c13f44ece813c0ee7b7 Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Thu, 3 Jul 2025 19:39:37 +0000
Subject: [PATCH] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a conditional check to avoid unnecessarily copying any
WAL segment files from source to target if they are common
between both servers before the point of WAL divergence
during pg_rewind. On the source server, each WAL file's.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target.
---
 src/bin/pg_rewind/filemap.c                   | 71 ++++++++++++++++++-
 src/bin/pg_rewind/filemap.h                   | 10 ++-
 src/bin/pg_rewind/pg_rewind.c                 |  5 +-
 src/bin/pg_rewind/pg_rewind.h                 |  4 ++
 .../t/011_avoid_copying_common_wals.pl        | 52 ++++++++++++++
 5 files changed, 137 insertions(+), 5 deletions(-)
 create mode 100644 src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..14c7643f0e0 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -199,6 +199,28 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+/* Determine the type of file content (relation, WAL, or other) */
+static file_content_type_t
+getFileContentType(const char *path)
+{
+	if (isRelDataFile(path))
+		return FILE_CONTENT_TYPE_RELATION;
+	else
+	{
+		/* Extract the filename from the path */
+		const char *filename = last_dir_separator(path);
+		if (filename == NULL)
+			filename = path;
+		else
+			filename++;  /* Skip the separator */
+
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+	}
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +232,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileContentType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -383,7 +405,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -693,6 +715,38 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname)
+{
+	TimeLineID  file_tli;
+	XLogSegNo   file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target.
+	 * Only WAL segment files after the last common segment number on
+	 * the new source need to be copied to the new target.
+	 */
+	if (file_segno < last_common_segno)
+	{
+		pg_log_debug("WAL file entry \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	pg_log_debug("WAL file entry \"%s\" is copied to target", fname);
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
@@ -799,7 +853,18 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++;  /* Skip the separator */
+
+				return decide_wal_file_action(filename);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..53082ceba3c 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -36,6 +37,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+} file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +59,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 0c68dd4235e..002e8f667e0 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -15,7 +15,6 @@
 #include <unistd.h>
 
 #include "access/timeline.h"
-#include "access/xlog_internal.h"
 #include "catalog/catversion.h"
 #include "catalog/pg_control.h"
 #include "common/controldata_utils.h"
@@ -62,6 +61,7 @@ static ControlFileData ControlFile_source_after;
 
 static const char *progname;
 int			WalSegSz;
+XLogSegNo		last_common_segno;
 
 /* Configuration options */
 char	   *datadir_target = NULL;
@@ -397,6 +397,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
diff --git a/src/bin/pg_rewind/pg_rewind.h b/src/bin/pg_rewind/pg_rewind.h
index 9cea144d2b2..759be379e12 100644
--- a/src/bin/pg_rewind/pg_rewind.h
+++ b/src/bin/pg_rewind/pg_rewind.h
@@ -12,6 +12,7 @@
 #define PG_REWIND_H
 
 #include "access/timeline.h"
+#include "access/xlog_internal.h"
 #include "common/logging.h"
 #include "common/file_utils.h"
 
@@ -51,4 +52,7 @@ extern TimeLineHistoryEntry *rewind_parseTimeLineHistory(char *buffer,
 														 TimeLineID targetTLI,
 														 int *nentries);
 
+/* optimize WAL files copied */
+extern XLogSegNo last_common_segno;
+
 #endif							/* PG_REWIND_H */
diff --git a/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
new file mode 100644
index 00000000000..3c823fc86e2
--- /dev/null
+++ b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
@@ -0,0 +1,52 @@
+# Copyright (c) 2021-2025, PostgreSQL Global Development Group
+#
+# Test situation where source and target data directory contains
+# the same WAL files
+#
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+use FindBin;
+use lib $FindBin::RealBin;
+use RewindTest;
+
+RewindTest::setup_cluster();
+RewindTest::start_primary();
+
+RewindTest::create_standby();
+
+# advance WAL on primary; this WAL segment will be common between both
+RewindTest::primary_psql("CREATE TABLE t(a int)");
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+
+# Common segment to be skipped copying over
+my $wal_seg_skipped = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# last common checkpoint
+RewindTest::primary_psql("CHECKPOINT");
+
+RewindTest::promote_standby;
+
+$node_standby->stop();
+$node_primary->stop();
+
+command_checks_all(
+	[
+		'pg_rewind', '--debug',
+		'--source-pgdata' => $node_standby->data_dir,
+		'--target-pgdata' => $node_primary->data_dir,
+		'--no-sync',
+	],
+	0,
+	[qr//
+	],
+	[qr/WAL file entry \"$wal_seg_skipped\" not copied to target/],
+	'run pg_rewind'
+);
+
+done_testing();
-- 
2.47.1

From a1cc55a3c6d2acaecf627153b2dd8858d29be1de Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Wed, 8 Oct 2025 21:20:59 +0000
Subject: [PATCH v8] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a check to avoid copying any WAL segment files from source
to target if they are common between both servers before the
point of WAL divergence during pg_rewind.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target as they have been replicated
from the original primary.

Author: John Hsu <johnhyvr@gmail.com>
Co-Author: Justin Kwan <justinpkwan@outlook.com>
---
 src/bin/pg_rewind/filemap.c                   | 246 +++++++++++-------
 src/bin/pg_rewind/filemap.h                   |  12 +-
 src/bin/pg_rewind/pg_rewind.c                 |   6 +-
 .../t/011_avoid_copying_common_wals.pl        |  87 +++++++
 4 files changed, 254 insertions(+), 97 deletions(-)
 create mode 100644 src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..a4162bce24c 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -55,7 +55,6 @@
 
 static filehash_hash *filehash;
 
-static bool isRelDataFile(const char *path);
 static char *datasegpath(RelFileLocator rlocator, ForkNumber forknum,
 						 BlockNumber segno);
 
@@ -199,6 +198,106 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+static file_content_type_t
+getFileContentType(const char *path)
+{
+	RelFileLocator rlocator;
+	unsigned int segNo;
+	int nmatch;
+	bool matched;
+
+	/* Check if it's a WAL file */
+	if (strncmp("pg_wal/", path, 7) == 0)
+	{
+		const char *filename = path + 7; /* Skip "pg_wal/" */
+
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+		else
+			return FILE_CONTENT_TYPE_OTHER;
+	}
+
+	/*
+	 * Does it look like a relation data file?
+	 *
+	 * For our purposes, only files belonging to the main fork are considered
+	 * relation files. Other forks are always copied in toto, because we cannot
+	 * reliably track changes to them, because WAL only contains block references
+	 * for the main fork.
+	 *
+	 * ----
+	 * Relation data files can be in one of the following directories:
+	 *
+	 * global/
+	 *		shared relations
+	 *
+	 * base/<db oid>/
+	 *		regular relations, default tablespace
+	 *
+	 * pg_tblspc/<tblspc oid>/<tblspc version>/
+	 *		within a non-default tablespace (the name of the directory
+	 *		depends on version)
+	 *
+	 * And the relation data files themselves have a filename like:
+	 *
+	 * <oid>.<segment number>
+	 *
+	 *----
+	 */
+	rlocator.spcOid = InvalidOid;
+	rlocator.dbOid = InvalidOid;
+	rlocator.relNumber = InvalidRelFileNumber;
+	segNo = 0;
+	matched = false;
+
+	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
+	if (nmatch == 1 || nmatch == 2)
+	{
+		rlocator.spcOid = GLOBALTABLESPACE_OID;
+		rlocator.dbOid = 0;
+		matched = true;
+	}
+	else
+	{
+		nmatch = sscanf(path, "base/%u/%u.%u",
+						&rlocator.dbOid, &rlocator.relNumber, &segNo);
+		if (nmatch == 2 || nmatch == 3)
+		{
+			rlocator.spcOid = DEFAULTTABLESPACE_OID;
+			matched = true;
+		}
+		else
+		{
+			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
+							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
+							&segNo);
+			if (nmatch == 3 || nmatch == 4)
+				matched = true;
+		}
+	}
+
+	/*
+	 * The sscanf tests above can match files that have extra characters at
+	 * the end. To eliminate such cases, cross-check that GetRelationPath
+	 * creates the exact same filename, when passed the RelFileLocator
+	 * information we extracted from the filename.
+	 */
+	if (matched)
+	{
+		char *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
+
+		if (strcmp(check_path, path) != 0)
+			matched = false;
+
+		pfree(check_path);
+	}
+
+	if (matched)
+		return FILE_CONTENT_TYPE_RELATION;
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +309,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileContentType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -294,7 +393,7 @@ process_source_file(const char *path, file_type_t type, size_t size,
 	 * sanity check: a filename that looks like a data file better be a
 	 * regular file
 	 */
-	if (type != FILE_TYPE_REGULAR && isRelDataFile(path))
+	if (type != FILE_TYPE_REGULAR && getFileContentType(path) == FILE_CONTENT_TYPE_RELATION)
 		pg_fatal("data file \"%s\" in source is not a regular file", path);
 
 	/* Remember this source file */
@@ -383,7 +482,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -559,92 +658,6 @@ print_filemap(filemap_t *filemap)
 	fflush(stdout);
 }
 
-/*
- * Does it look like a relation data file?
- *
- * For our purposes, only files belonging to the main fork are considered
- * relation files. Other forks are always copied in toto, because we cannot
- * reliably track changes to them, because WAL only contains block references
- * for the main fork.
- */
-static bool
-isRelDataFile(const char *path)
-{
-	RelFileLocator rlocator;
-	unsigned int segNo;
-	int			nmatch;
-	bool		matched;
-
-	/*----
-	 * Relation data files can be in one of the following directories:
-	 *
-	 * global/
-	 *		shared relations
-	 *
-	 * base/<db oid>/
-	 *		regular relations, default tablespace
-	 *
-	 * pg_tblspc/<tblspc oid>/<tblspc version>/
-	 *		within a non-default tablespace (the name of the directory
-	 *		depends on version)
-	 *
-	 * And the relation data files themselves have a filename like:
-	 *
-	 * <oid>.<segment number>
-	 *
-	 *----
-	 */
-	rlocator.spcOid = InvalidOid;
-	rlocator.dbOid = InvalidOid;
-	rlocator.relNumber = InvalidRelFileNumber;
-	segNo = 0;
-	matched = false;
-
-	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
-	if (nmatch == 1 || nmatch == 2)
-	{
-		rlocator.spcOid = GLOBALTABLESPACE_OID;
-		rlocator.dbOid = 0;
-		matched = true;
-	}
-	else
-	{
-		nmatch = sscanf(path, "base/%u/%u.%u",
-						&rlocator.dbOid, &rlocator.relNumber, &segNo);
-		if (nmatch == 2 || nmatch == 3)
-		{
-			rlocator.spcOid = DEFAULTTABLESPACE_OID;
-			matched = true;
-		}
-		else
-		{
-			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
-							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
-							&segNo);
-			if (nmatch == 3 || nmatch == 4)
-				matched = true;
-		}
-	}
-
-	/*
-	 * The sscanf tests above can match files that have extra characters at
-	 * the end. To eliminate such cases, cross-check that GetRelationPath
-	 * creates the exact same filename, when passed the RelFileLocator
-	 * information we extracted from the filename.
-	 */
-	if (matched)
-	{
-		char	   *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
-
-		if (strcmp(check_path, path) != 0)
-			matched = false;
-
-		pfree(check_path);
-	}
-
-	return matched;
-}
-
 /*
  * A helper function to create the path of a relation file and segment.
  *
@@ -693,11 +706,45 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname, XLogSegNo last_common_segno,
+					   size_t source_size, size_t target_size)
+{
+	TimeLineID file_tli;
+	XLogSegNo file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target.
+	 * Only WAL segment files after the last common segment number on
+	 * the new source need to be copied to the new target.
+	 *
+	 * If the sizes are different copy again for sanity.
+	 */
+	if (file_segno < last_common_segno && source_size == target_size)
+	{
+		pg_log_debug("WAL segment \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
 static file_action_t
-decide_file_action(file_entry_t *entry)
+decide_file_action(file_entry_t *entry, XLogSegNo last_common_segno)
 {
 	const char *path = entry->path;
 
@@ -799,7 +846,18 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++; /* Skip the separator */
+
+				return decide_wal_file_action(filename, last_common_segno, entry->source_size, entry->target_size);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
@@ -858,7 +916,7 @@ decide_file_action(file_entry_t *entry)
  * should be executed.
  */
 filemap_t *
-decide_file_actions(void)
+decide_file_actions(XLogSegNo last_common_segno)
 {
 	int			i;
 	filehash_iterator it;
@@ -868,7 +926,7 @@ decide_file_actions(void)
 	filehash_start_iterate(filehash, &it);
 	while ((entry = filehash_iterate(filehash, &it)) != NULL)
 	{
-		entry->action = decide_file_action(entry);
+		entry->action = decide_file_action(entry, last_common_segno);
 	}
 
 	/*
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..5145f0b4c46 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -36,6 +37,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+} file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +59,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
@@ -106,7 +114,7 @@ extern void process_target_wal_block_change(ForkNumber forknum,
 											RelFileLocator rlocator,
 											BlockNumber blkno);
 
-extern filemap_t *decide_file_actions(void);
+extern filemap_t *decide_file_actions(XLogSegNo last_common_segno);
 extern void calculate_totals(filemap_t *filemap);
 extern void print_filemap(filemap_t *filemap);
 
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 0c68dd4235e..318d0a27184 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -147,6 +147,7 @@ main(int argc, char **argv)
 	TimeLineID	source_tli;
 	TimeLineID	target_tli;
 	XLogRecPtr	target_wal_endrec;
+	XLogSegNo	last_common_segno;
 	size_t		size;
 	char	   *buffer;
 	bool		no_ensure_shutdown = false;
@@ -397,6 +398,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -492,7 +496,7 @@ main(int argc, char **argv)
 	 * We have collected all information we need from both systems. Decide
 	 * what to do with each file.
 	 */
-	filemap = decide_file_actions();
+	filemap = decide_file_actions(last_common_segno);
 	if (showprogress)
 		calculate_totals(filemap);
 
diff --git a/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
new file mode 100644
index 00000000000..d5fa28b1f49
--- /dev/null
+++ b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
@@ -0,0 +1,87 @@
+# Copyright (c) 2021-2025, PostgreSQL Global Development Group
+#
+# Test situation where source and target data directory contains
+# the same WAL files
+#
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Utils;
+use Test::More;
+use File::Spec;
+use File::stat qw(stat);
+
+use FindBin;
+use lib $FindBin::RealBin;
+use RewindTest;
+use Time::HiRes qw(usleep);
+
+RewindTest::setup_cluster();
+RewindTest::start_primary();
+
+RewindTest::create_standby();
+
+# advance WAL on primary; this WAL segment will be common between both
+RewindTest::primary_psql("CREATE TABLE t(a int)");
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+
+# Common segment to be skipped copying over
+my $wal_seg_skipped = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# last common checkpoint
+RewindTest::primary_psql("CHECKPOINT");
+
+RewindTest::promote_standby;
+
+my $wal_seg_copied = $node_standby->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+# Get stat info for the WAL file that should be skipped
+my $wal_skipped_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_skipped);
+my $wal_skipped_stat = stat($wal_skipped_path);
+defined($wal_skipped_stat) or die("unable to stat $wal_skipped_path");
+
+# Store modification time for later comparison
+my $wal_seg_skipped_mod_time = $wal_skipped_stat->mtime;
+
+# Verify that the WAL segment on new timeline does not exist in target before rewind
+my $wal_copied_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_copied);
+my $wal_copied_stat = stat($wal_copied_path);
+ok(!defined($wal_copied_stat), "WAL segment $wal_seg_copied should not exist in target before rewind");
+
+
+$node_standby->stop();
+$node_primary->stop();
+
+# Sleep to allow mtime to be different
+usleep(1000);
+
+command_checks_all(
+	[
+		'pg_rewind', '--debug',
+		'--source-pgdata' => $node_standby->data_dir,
+		'--target-pgdata' => $node_primary->data_dir,
+		'--no-sync',
+	],
+	0,
+	[qr//
+	],
+	[qr/WAL segment \"$wal_seg_skipped\" not copied to target/],
+	'run pg_rewind'
+);
+
+# Verify that the copied WAL segment now exists in target
+$wal_copied_stat = stat($wal_copied_path);
+ok(defined($wal_copied_stat), "WAL segment $wal_seg_copied should exist in target after rewind");
+
+# Get current modification time of the skipped WAL segment
+my $wal_skipped_stat_after = stat($wal_skipped_path);
+defined($wal_skipped_stat_after) or die("unable to stat $wal_skipped_path after rewind");
+my $wal_seg_latest_skipped_mod_time = $wal_skipped_stat_after->mtime;
+
+# 6. Validate that modification time hasn't changed,
+is($wal_seg_latest_skipped_mod_time, $wal_seg_skipped_mod_time,
+   "WAL segment $wal_seg_skipped modification time should be unchanged (not overwritten)");
+
+done_testing();
-- 
2.50.1

From df7eb550c3ed8d42c76f91d547f68a32a08539ce Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Wed, 8 Oct 2025 21:20:59 +0000
Subject: [PATCH v9] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a check to avoid copying any WAL segment files from source
to target if they are common between both servers before the
point of WAL divergence during pg_rewind.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target as they have been replicated
from the original primary.

Author: John Hsu <johnhyvr@gmail.com>
Co-Author: Justin Kwan <justinpkwan@outlook.com>
---
 src/bin/pg_rewind/filemap.c                   | 245 +++++++++++-------
 src/bin/pg_rewind/filemap.h                   |  12 +-
 src/bin/pg_rewind/pg_rewind.c                 |   6 +-
 .../t/011_avoid_copying_common_wals.pl        | 111 ++++++++
 4 files changed, 277 insertions(+), 97 deletions(-)
 create mode 100644 src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..cd155eb2ec1 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -55,7 +55,6 @@
 
 static filehash_hash *filehash;
 
-static bool isRelDataFile(const char *path);
 static char *datasegpath(RelFileLocator rlocator, ForkNumber forknum,
 						 BlockNumber segno);
 
@@ -199,6 +198,106 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+static file_content_type_t
+getFileContentType(const char *path)
+{
+	RelFileLocator rlocator;
+	unsigned int segNo;
+	int nmatch;
+	bool matched;
+
+	/* Check if it's a WAL file */
+	if (strncmp("pg_wal/", path, 7) == 0)
+	{
+		const char *filename = path + 7; /* Skip "pg_wal/" */
+
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+		else
+			return FILE_CONTENT_TYPE_OTHER;
+	}
+
+	/*
+	 * Does it look like a relation data file?
+	 *
+	 * For our purposes, only files belonging to the main fork are considered
+	 * relation files. Other forks are always copied in toto, because we cannot
+	 * reliably track changes to them, because WAL only contains block references
+	 * for the main fork.
+	 *
+	 * ----
+	 * Relation data files can be in one of the following directories:
+	 *
+	 * global/
+	 *		shared relations
+	 *
+	 * base/<db oid>/
+	 *		regular relations, default tablespace
+	 *
+	 * pg_tblspc/<tblspc oid>/<tblspc version>/
+	 *		within a non-default tablespace (the name of the directory
+	 *		depends on version)
+	 *
+	 * And the relation data files themselves have a filename like:
+	 *
+	 * <oid>.<segment number>
+	 *
+	 *----
+	 */
+	rlocator.spcOid = InvalidOid;
+	rlocator.dbOid = InvalidOid;
+	rlocator.relNumber = InvalidRelFileNumber;
+	segNo = 0;
+	matched = false;
+
+	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
+	if (nmatch == 1 || nmatch == 2)
+	{
+		rlocator.spcOid = GLOBALTABLESPACE_OID;
+		rlocator.dbOid = 0;
+		matched = true;
+	}
+	else
+	{
+		nmatch = sscanf(path, "base/%u/%u.%u",
+						&rlocator.dbOid, &rlocator.relNumber, &segNo);
+		if (nmatch == 2 || nmatch == 3)
+		{
+			rlocator.spcOid = DEFAULTTABLESPACE_OID;
+			matched = true;
+		}
+		else
+		{
+			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
+							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
+							&segNo);
+			if (nmatch == 3 || nmatch == 4)
+				matched = true;
+		}
+	}
+
+	/*
+	 * The sscanf tests above can match files that have extra characters at
+	 * the end. To eliminate such cases, cross-check that GetRelationPath
+	 * creates the exact same filename, when passed the RelFileLocator
+	 * information we extracted from the filename.
+	 */
+	if (matched)
+	{
+		char *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
+
+		if (strcmp(check_path, path) != 0)
+			matched = false;
+
+		pfree(check_path);
+	}
+
+	if (matched)
+		return FILE_CONTENT_TYPE_RELATION;
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +309,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileContentType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -294,7 +393,7 @@ process_source_file(const char *path, file_type_t type, size_t size,
 	 * sanity check: a filename that looks like a data file better be a
 	 * regular file
 	 */
-	if (type != FILE_TYPE_REGULAR && isRelDataFile(path))
+	if (type != FILE_TYPE_REGULAR && getFileContentType(path) == FILE_CONTENT_TYPE_RELATION)
 		pg_fatal("data file \"%s\" in source is not a regular file", path);
 
 	/* Remember this source file */
@@ -383,7 +482,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -559,92 +658,6 @@ print_filemap(filemap_t *filemap)
 	fflush(stdout);
 }
 
-/*
- * Does it look like a relation data file?
- *
- * For our purposes, only files belonging to the main fork are considered
- * relation files. Other forks are always copied in toto, because we cannot
- * reliably track changes to them, because WAL only contains block references
- * for the main fork.
- */
-static bool
-isRelDataFile(const char *path)
-{
-	RelFileLocator rlocator;
-	unsigned int segNo;
-	int			nmatch;
-	bool		matched;
-
-	/*----
-	 * Relation data files can be in one of the following directories:
-	 *
-	 * global/
-	 *		shared relations
-	 *
-	 * base/<db oid>/
-	 *		regular relations, default tablespace
-	 *
-	 * pg_tblspc/<tblspc oid>/<tblspc version>/
-	 *		within a non-default tablespace (the name of the directory
-	 *		depends on version)
-	 *
-	 * And the relation data files themselves have a filename like:
-	 *
-	 * <oid>.<segment number>
-	 *
-	 *----
-	 */
-	rlocator.spcOid = InvalidOid;
-	rlocator.dbOid = InvalidOid;
-	rlocator.relNumber = InvalidRelFileNumber;
-	segNo = 0;
-	matched = false;
-
-	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
-	if (nmatch == 1 || nmatch == 2)
-	{
-		rlocator.spcOid = GLOBALTABLESPACE_OID;
-		rlocator.dbOid = 0;
-		matched = true;
-	}
-	else
-	{
-		nmatch = sscanf(path, "base/%u/%u.%u",
-						&rlocator.dbOid, &rlocator.relNumber, &segNo);
-		if (nmatch == 2 || nmatch == 3)
-		{
-			rlocator.spcOid = DEFAULTTABLESPACE_OID;
-			matched = true;
-		}
-		else
-		{
-			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
-							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
-							&segNo);
-			if (nmatch == 3 || nmatch == 4)
-				matched = true;
-		}
-	}
-
-	/*
-	 * The sscanf tests above can match files that have extra characters at
-	 * the end. To eliminate such cases, cross-check that GetRelationPath
-	 * creates the exact same filename, when passed the RelFileLocator
-	 * information we extracted from the filename.
-	 */
-	if (matched)
-	{
-		char	   *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
-
-		if (strcmp(check_path, path) != 0)
-			matched = false;
-
-		pfree(check_path);
-	}
-
-	return matched;
-}
-
 /*
  * A helper function to create the path of a relation file and segment.
  *
@@ -693,11 +706,44 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname, XLogSegNo last_common_segno,
+					   size_t source_size, size_t target_size)
+{
+	TimeLineID file_tli;
+	XLogSegNo file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target which means
+	 * they should already be identical and before the last_common_segno.
+	 *
+	 * However we check last_common_segno and file_size again for sanity.
+	 */
+	if (file_segno < last_common_segno && source_size == target_size)
+	{
+		pg_log_debug("WAL segment \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
 static file_action_t
-decide_file_action(file_entry_t *entry)
+decide_file_action(file_entry_t *entry, XLogSegNo last_common_segno)
 {
 	const char *path = entry->path;
 
@@ -799,7 +845,18 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++; /* Skip the separator */
+
+				return decide_wal_file_action(filename, last_common_segno, entry->source_size, entry->target_size);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
@@ -858,7 +915,7 @@ decide_file_action(file_entry_t *entry)
  * should be executed.
  */
 filemap_t *
-decide_file_actions(void)
+decide_file_actions(XLogSegNo last_common_segno)
 {
 	int			i;
 	filehash_iterator it;
@@ -868,7 +925,7 @@ decide_file_actions(void)
 	filehash_start_iterate(filehash, &it);
 	while ((entry = filehash_iterate(filehash, &it)) != NULL)
 	{
-		entry->action = decide_file_action(entry);
+		entry->action = decide_file_action(entry, last_common_segno);
 	}
 
 	/*
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..5145f0b4c46 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -36,6 +37,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+} file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +59,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
@@ -106,7 +114,7 @@ extern void process_target_wal_block_change(ForkNumber forknum,
 											RelFileLocator rlocator,
 											BlockNumber blkno);
 
-extern filemap_t *decide_file_actions(void);
+extern filemap_t *decide_file_actions(XLogSegNo last_common_segno);
 extern void calculate_totals(filemap_t *filemap);
 extern void print_filemap(filemap_t *filemap);
 
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 0c68dd4235e..318d0a27184 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -147,6 +147,7 @@ main(int argc, char **argv)
 	TimeLineID	source_tli;
 	TimeLineID	target_tli;
 	XLogRecPtr	target_wal_endrec;
+	XLogSegNo	last_common_segno;
 	size_t		size;
 	char	   *buffer;
 	bool		no_ensure_shutdown = false;
@@ -397,6 +398,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -492,7 +496,7 @@ main(int argc, char **argv)
 	 * We have collected all information we need from both systems. Decide
 	 * what to do with each file.
 	 */
-	filemap = decide_file_actions();
+	filemap = decide_file_actions(last_common_segno);
 	if (showprogress)
 		calculate_totals(filemap);
 
diff --git a/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
new file mode 100644
index 00000000000..8d49ebde04d
--- /dev/null
+++ b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
@@ -0,0 +1,111 @@
+# Copyright (c) 2021-2025, PostgreSQL Global Development Group
+#
+# Test situation where we skip copying the same WAL files from source
+# to target unless file size differs.
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Utils;
+use Test::More;
+use File::Spec;
+use File::stat qw(stat);
+
+use FindBin;
+use lib $FindBin::RealBin;
+use RewindTest;
+use Time::HiRes qw(usleep);
+
+RewindTest::setup_cluster();
+RewindTest::start_primary();
+
+RewindTest::create_standby();
+
+
+# Advance WAL on primary
+RewindTest::primary_psql("CREATE TABLE t(a int)");
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+
+# Common segment to be skipped copying over as it's common and same size
+my $wal_seg_skipped = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# Segment before divergerec that will be copied over because file size differs
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+my $wal_seg_before_diverge_copied = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# last common checkpoint
+RewindTest::primary_psql("CHECKPOINT");
+
+RewindTest::promote_standby;
+
+# Segment after divergerec, expected to be copied
+my $wal_seg_copied = $node_standby->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+# Get stat info for the WAL file that should be skipped
+my $wal_skipped_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_skipped);
+my $wal_skipped_stat = stat($wal_skipped_path);
+defined($wal_skipped_stat) or die("unable to stat $wal_skipped_path");
+
+# Store modification time for later comparison
+my $wal_seg_skipped_mod_time = $wal_skipped_stat->mtime;
+
+# Append an additional byte to segment on target before divergerec to test it's copied over from source
+my $wal_seg_before_diverge_copied_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_before_diverge_copied);
+open my $fh, ">>", $wal_seg_before_diverge_copied_path
+  or die "could not open $wal_seg_before_diverge_copied_path";
+
+print $fh 'a';
+close $fh;
+
+my $wal_seg_existing_copied_stat = stat($wal_seg_before_diverge_copied_path);
+ok(defined($wal_seg_existing_copied_stat), "WAL segment $wal_seg_before_diverge_copied should exist in target before rewind");
+
+# Verify that the WAL segment on new timeline does not exist in target before rewind
+my $wal_copied_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_copied);
+my $wal_copied_stat = stat($wal_copied_path);
+ok(!defined($wal_copied_stat), "WAL segment $wal_seg_copied should not exist in target before rewind");
+
+
+$node_standby->stop();
+$node_primary->stop();
+
+# Sleep to allow mtime to be different
+usleep(1000);
+
+command_checks_all(
+	[
+		'pg_rewind', '--debug',
+		'--source-pgdata' => $node_standby->data_dir,
+		'--target-pgdata' => $node_primary->data_dir,
+		'--no-sync',
+	],
+	0,
+	[qr//
+	],
+	[qr/WAL segment \"$wal_seg_skipped\" not copied to target/],
+	'run pg_rewind'
+);
+
+# Verify that the copied WAL segment now exists in target
+$wal_copied_stat = stat($wal_copied_path);
+ok(defined($wal_copied_stat), "WAL segment $wal_seg_copied should exist in target after rewind");
+
+# Get current modification time of the skipped WAL segment
+my $wal_skipped_stat_after = stat($wal_skipped_path);
+defined($wal_skipped_stat_after) or die("unable to stat $wal_skipped_path after rewind");
+my $wal_seg_latest_skipped_mod_time = $wal_skipped_stat_after->mtime;
+
+# Validate that modification time hasn't changed,
+is($wal_seg_latest_skipped_mod_time, $wal_seg_skipped_mod_time,
+   "WAL segment $wal_seg_skipped modification time should be unchanged (not overwritten)");
+
+# Validate WAL with size different prior to divergerec was updated
+my $wal_seg_existing_copied_after_stat = stat($wal_seg_before_diverge_copied_path);
+defined($wal_seg_existing_copied_after_stat) or die("unable to stat $wal_skipped_path");
+
+isnt($wal_seg_existing_copied_stat->size, $wal_seg_existing_copied_after_stat->size, "WAL segment $wal_seg_before_diverge_copied with byte difference did not get copied");
+
+
+done_testing();
-- 
2.50.1

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 69d7728ce44..743484f4833 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -732,11 +732,11 @@ decide_wal_file_action(const char *fname, XLogSegNo last_common_segno,
 	 */
 	if (file_segno < last_common_segno && source_size == target_size)
 	{
 		pg_log_debug("WAL segment \"%s\" not copied to target", fname);
 		return FILE_ACTION_NONE;
 	}
 
+	pg_log_debug("WAL segment \"%s\" is copied to target", fname);
 	return FILE_ACTION_COPY;
 }
 
diff --git a/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
index 8d49ebde04d..bcad03a50c5 100644
--- a/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
+++ b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
@@ -7,7 +7,6 @@ use strict;
 use warnings FATAL => 'all';
 use PostgreSQL::Test::Utils;
 use Test::More;
-use File::Spec;
 use File::stat qw(stat);
 
 use FindBin;
@@ -32,7 +31,7 @@ RewindTest::primary_psql("SELECT pg_switch_wal()");
 
 # Segment before divergerec that will be copied over because file size differs
 RewindTest::primary_psql("INSERT INTO t VALUES(0)");
-my $wal_seg_before_diverge_copied = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+my $corrupt_wal_seg = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
 RewindTest::primary_psql("SELECT pg_switch_wal()");
 
 # last common checkpoint
@@ -40,39 +39,40 @@ RewindTest::primary_psql("CHECKPOINT");
 
 RewindTest::promote_standby;
 
-# Segment after divergerec, expected to be copied
-my $wal_seg_copied = $node_standby->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+# New Timeline Segment after divergerec, expected to be copied
+my $new_timeline_wal_seg = $node_standby->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
 
 # Get stat info for the WAL file that should be skipped
-my $wal_skipped_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_skipped);
+my $wal_skipped_path = $node_primary->data_dir . '/pg_wal/' . $wal_seg_skipped;
 my $wal_skipped_stat = stat($wal_skipped_path);
 defined($wal_skipped_stat) or die("unable to stat $wal_skipped_path");
 
 # Store modification time for later comparison
 my $wal_seg_skipped_mod_time = $wal_skipped_stat->mtime;
 
-# Append an additional byte to segment on target before divergerec to test it's copied over from source
-my $wal_seg_before_diverge_copied_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_before_diverge_copied);
-open my $fh, ">>", $wal_seg_before_diverge_copied_path
-  or die "could not open $wal_seg_before_diverge_copied_path";
+# Corrupt a segment on target before divergerec to test it's copied over from source,
+# by appending an additional byte to it.
+my $corrupt_wal_seg_in_target_path = $node_primary->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+open my $fh, ">>", $corrupt_wal_seg_in_target_path
+  or die "could not open $corrupt_wal_seg_in_target_path";
 
 print $fh 'a';
 close $fh;
 
-my $wal_seg_existing_copied_stat = stat($wal_seg_before_diverge_copied_path);
-ok(defined($wal_seg_existing_copied_stat), "WAL segment $wal_seg_before_diverge_copied should exist in target before rewind");
+my $corrupt_wal_seg_stat_before_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_before_rewind), "WAL segment $corrupt_wal_seg should exist in target before rewind");
 
 # Verify that the WAL segment on new timeline does not exist in target before rewind
-my $wal_copied_path = File::Spec->catfile($node_primary->data_dir, 'pg_wal', $wal_seg_copied);
-my $wal_copied_stat = stat($wal_copied_path);
-ok(!defined($wal_copied_stat), "WAL segment $wal_seg_copied should not exist in target before rewind");
+my $new_timeline_wal_seg_path = $node_primary->data_dir . '/pg_wal/' . $new_timeline_wal_seg;
+my $new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(!defined($new_timeline_wal_seg_stat), "WAL segment $new_timeline_wal_seg should not exist in target before rewind");
 
 
 $node_standby->stop();
 $node_primary->stop();
 
 # Sleep to allow mtime to be different
-usleep(1000);
+usleep(1000000);
 
 command_checks_all(
 	[
@@ -84,28 +84,37 @@ command_checks_all(
 	0,
 	[qr//
 	],
-	[qr/WAL segment \"$wal_seg_skipped\" not copied to target/],
+	[
+        qr/WAL segment \"$wal_seg_skipped\" not copied to target/,
+        qr/WAL segment \"$corrupt_wal_seg\" is copied to target/
+    ],
 	'run pg_rewind'
 );
 
 # Verify that the copied WAL segment now exists in target
-$wal_copied_stat = stat($wal_copied_path);
-ok(defined($wal_copied_stat), "WAL segment $wal_seg_copied should exist in target after rewind");
+$new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(defined($new_timeline_wal_seg_stat), "WAL segment $new_timeline_wal_seg should exist in target after rewind");
 
 # Get current modification time of the skipped WAL segment
-my $wal_skipped_stat_after = stat($wal_skipped_path);
-defined($wal_skipped_stat_after) or die("unable to stat $wal_skipped_path after rewind");
-my $wal_seg_latest_skipped_mod_time = $wal_skipped_stat_after->mtime;
+my $wal_skipped_stat_after_rewind = stat($wal_skipped_path);
+defined($wal_skipped_stat_after_rewind) or die("unable to stat $wal_skipped_path after rewind");
+my $wal_seg_latest_skipped_mod_time = $wal_skipped_stat_after_rewind->mtime;
 
 # Validate that modification time hasn't changed,
 is($wal_seg_latest_skipped_mod_time, $wal_seg_skipped_mod_time,
    "WAL segment $wal_seg_skipped modification time should be unchanged (not overwritten)");
 
-# Validate WAL with size different prior to divergerec was updated
-my $wal_seg_existing_copied_after_stat = stat($wal_seg_before_diverge_copied_path);
-defined($wal_seg_existing_copied_after_stat) or die("unable to stat $wal_skipped_path");
-
-isnt($wal_seg_existing_copied_stat->size, $wal_seg_existing_copied_after_stat->size, "WAL segment $wal_seg_before_diverge_copied with byte difference did not get copied");
+# Validate that the WAL segment with same filename as the
+# corrupt WAL segment in target has been copied from source
+# where we have it intact.
+my $corrupt_wal_seg_in_source_path = $node_standby->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+my $corrupt_wal_seg_source_stat = stat($corrupt_wal_seg_in_source_path);
+ok(defined($corrupt_wal_seg_source_stat), "WAL segment $corrupt_wal_seg should exist in source after rewind");
+my $corrupt_wal_seg_stat_after_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_after_rewind), "WAL segment $corrupt_wal_seg should exist in target after rewind");
+ok($corrupt_wal_seg_stat_before_rewind->size != $corrupt_wal_seg_source_stat->size,"WAL segment $corrupt_wal_seg has different size in source vs target before rewind");
+ok($corrupt_wal_seg_stat_after_rewind->mtime > $corrupt_wal_seg_stat_before_rewind->mtime,"WAL segment $corrupt_wal_seg was copied: mtime after rewind > mtime before rewind");
+ok($corrupt_wal_seg_stat_after_rewind->size == $corrupt_wal_seg_source_stat->size, "WAL segment $corrupt_wal_seg was copied: file sizes are same between target and source after rewind");
 
 
 done_testing();

From f3e6c164368ae8efdac57201ba5009d7656f5be2 Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Wed, 8 Oct 2025 21:20:59 +0000
Subject: [PATCH v10] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a check to avoid copying any WAL segment files from source
to target if they are common between both servers before the
point of WAL divergence during pg_rewind.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target as they have been replicated
from the original primary.

Author: John Hsu <johnhyvr@gmail.com>
Co-Author: Justin Kwan <justinpkwan@outlook.com>
---
 src/bin/pg_rewind/filemap.c                   | 245 +++++++++++-------
 src/bin/pg_rewind/filemap.h                   |  12 +-
 src/bin/pg_rewind/pg_rewind.c                 |   6 +-
 .../t/011_avoid_copying_common_wals.pl        | 120 +++++++++
 4 files changed, 286 insertions(+), 97 deletions(-)
 create mode 100644 src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..cd155eb2ec1 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -55,7 +55,6 @@
 
 static filehash_hash *filehash;
 
-static bool isRelDataFile(const char *path);
 static char *datasegpath(RelFileLocator rlocator, ForkNumber forknum,
 						 BlockNumber segno);
 
@@ -199,6 +198,106 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+static file_content_type_t
+getFileContentType(const char *path)
+{
+	RelFileLocator rlocator;
+	unsigned int segNo;
+	int nmatch;
+	bool matched;
+
+	/* Check if it's a WAL file */
+	if (strncmp("pg_wal/", path, 7) == 0)
+	{
+		const char *filename = path + 7; /* Skip "pg_wal/" */
+
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+		else
+			return FILE_CONTENT_TYPE_OTHER;
+	}
+
+	/*
+	 * Does it look like a relation data file?
+	 *
+	 * For our purposes, only files belonging to the main fork are considered
+	 * relation files. Other forks are always copied in toto, because we cannot
+	 * reliably track changes to them, because WAL only contains block references
+	 * for the main fork.
+	 *
+	 * ----
+	 * Relation data files can be in one of the following directories:
+	 *
+	 * global/
+	 *		shared relations
+	 *
+	 * base/<db oid>/
+	 *		regular relations, default tablespace
+	 *
+	 * pg_tblspc/<tblspc oid>/<tblspc version>/
+	 *		within a non-default tablespace (the name of the directory
+	 *		depends on version)
+	 *
+	 * And the relation data files themselves have a filename like:
+	 *
+	 * <oid>.<segment number>
+	 *
+	 *----
+	 */
+	rlocator.spcOid = InvalidOid;
+	rlocator.dbOid = InvalidOid;
+	rlocator.relNumber = InvalidRelFileNumber;
+	segNo = 0;
+	matched = false;
+
+	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
+	if (nmatch == 1 || nmatch == 2)
+	{
+		rlocator.spcOid = GLOBALTABLESPACE_OID;
+		rlocator.dbOid = 0;
+		matched = true;
+	}
+	else
+	{
+		nmatch = sscanf(path, "base/%u/%u.%u",
+						&rlocator.dbOid, &rlocator.relNumber, &segNo);
+		if (nmatch == 2 || nmatch == 3)
+		{
+			rlocator.spcOid = DEFAULTTABLESPACE_OID;
+			matched = true;
+		}
+		else
+		{
+			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
+							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
+							&segNo);
+			if (nmatch == 3 || nmatch == 4)
+				matched = true;
+		}
+	}
+
+	/*
+	 * The sscanf tests above can match files that have extra characters at
+	 * the end. To eliminate such cases, cross-check that GetRelationPath
+	 * creates the exact same filename, when passed the RelFileLocator
+	 * information we extracted from the filename.
+	 */
+	if (matched)
+	{
+		char *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
+
+		if (strcmp(check_path, path) != 0)
+			matched = false;
+
+		pfree(check_path);
+	}
+
+	if (matched)
+		return FILE_CONTENT_TYPE_RELATION;
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +309,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileContentType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -294,7 +393,7 @@ process_source_file(const char *path, file_type_t type, size_t size,
 	 * sanity check: a filename that looks like a data file better be a
 	 * regular file
 	 */
-	if (type != FILE_TYPE_REGULAR && isRelDataFile(path))
+	if (type != FILE_TYPE_REGULAR && getFileContentType(path) == FILE_CONTENT_TYPE_RELATION)
 		pg_fatal("data file \"%s\" in source is not a regular file", path);
 
 	/* Remember this source file */
@@ -383,7 +482,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -559,92 +658,6 @@ print_filemap(filemap_t *filemap)
 	fflush(stdout);
 }
 
-/*
- * Does it look like a relation data file?
- *
- * For our purposes, only files belonging to the main fork are considered
- * relation files. Other forks are always copied in toto, because we cannot
- * reliably track changes to them, because WAL only contains block references
- * for the main fork.
- */
-static bool
-isRelDataFile(const char *path)
-{
-	RelFileLocator rlocator;
-	unsigned int segNo;
-	int			nmatch;
-	bool		matched;
-
-	/*----
-	 * Relation data files can be in one of the following directories:
-	 *
-	 * global/
-	 *		shared relations
-	 *
-	 * base/<db oid>/
-	 *		regular relations, default tablespace
-	 *
-	 * pg_tblspc/<tblspc oid>/<tblspc version>/
-	 *		within a non-default tablespace (the name of the directory
-	 *		depends on version)
-	 *
-	 * And the relation data files themselves have a filename like:
-	 *
-	 * <oid>.<segment number>
-	 *
-	 *----
-	 */
-	rlocator.spcOid = InvalidOid;
-	rlocator.dbOid = InvalidOid;
-	rlocator.relNumber = InvalidRelFileNumber;
-	segNo = 0;
-	matched = false;
-
-	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
-	if (nmatch == 1 || nmatch == 2)
-	{
-		rlocator.spcOid = GLOBALTABLESPACE_OID;
-		rlocator.dbOid = 0;
-		matched = true;
-	}
-	else
-	{
-		nmatch = sscanf(path, "base/%u/%u.%u",
-						&rlocator.dbOid, &rlocator.relNumber, &segNo);
-		if (nmatch == 2 || nmatch == 3)
-		{
-			rlocator.spcOid = DEFAULTTABLESPACE_OID;
-			matched = true;
-		}
-		else
-		{
-			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
-							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
-							&segNo);
-			if (nmatch == 3 || nmatch == 4)
-				matched = true;
-		}
-	}
-
-	/*
-	 * The sscanf tests above can match files that have extra characters at
-	 * the end. To eliminate such cases, cross-check that GetRelationPath
-	 * creates the exact same filename, when passed the RelFileLocator
-	 * information we extracted from the filename.
-	 */
-	if (matched)
-	{
-		char	   *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
-
-		if (strcmp(check_path, path) != 0)
-			matched = false;
-
-		pfree(check_path);
-	}
-
-	return matched;
-}
-
 /*
  * A helper function to create the path of a relation file and segment.
  *
@@ -693,11 +706,44 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname, XLogSegNo last_common_segno,
+					   size_t source_size, size_t target_size)
+{
+	TimeLineID file_tli;
+	XLogSegNo file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target which means
+	 * they should already be identical and before the last_common_segno.
+	 *
+	 * However we check last_common_segno and file_size again for sanity.
+	 */
+	if (file_segno < last_common_segno && source_size == target_size)
+	{
+		pg_log_debug("WAL segment \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
 static file_action_t
-decide_file_action(file_entry_t *entry)
+decide_file_action(file_entry_t *entry, XLogSegNo last_common_segno)
 {
 	const char *path = entry->path;
 
@@ -799,7 +845,18 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++; /* Skip the separator */
+
+				return decide_wal_file_action(filename, last_common_segno, entry->source_size, entry->target_size);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
@@ -858,7 +915,7 @@ decide_file_action(file_entry_t *entry)
  * should be executed.
  */
 filemap_t *
-decide_file_actions(void)
+decide_file_actions(XLogSegNo last_common_segno)
 {
 	int			i;
 	filehash_iterator it;
@@ -868,7 +925,7 @@ decide_file_actions(void)
 	filehash_start_iterate(filehash, &it);
 	while ((entry = filehash_iterate(filehash, &it)) != NULL)
 	{
-		entry->action = decide_file_action(entry);
+		entry->action = decide_file_action(entry, last_common_segno);
 	}
 
 	/*
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..5145f0b4c46 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -36,6 +37,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+} file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +59,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
@@ -106,7 +114,7 @@ extern void process_target_wal_block_change(ForkNumber forknum,
 											RelFileLocator rlocator,
 											BlockNumber blkno);
 
-extern filemap_t *decide_file_actions(void);
+extern filemap_t *decide_file_actions(XLogSegNo last_common_segno);
 extern void calculate_totals(filemap_t *filemap);
 extern void print_filemap(filemap_t *filemap);
 
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 0c68dd4235e..318d0a27184 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -147,6 +147,7 @@ main(int argc, char **argv)
 	TimeLineID	source_tli;
 	TimeLineID	target_tli;
 	XLogRecPtr	target_wal_endrec;
+	XLogSegNo	last_common_segno;
 	size_t		size;
 	char	   *buffer;
 	bool		no_ensure_shutdown = false;
@@ -397,6 +398,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -492,7 +496,7 @@ main(int argc, char **argv)
 	 * We have collected all information we need from both systems. Decide
 	 * what to do with each file.
 	 */
-	filemap = decide_file_actions();
+	filemap = decide_file_actions(last_common_segno);
 	if (showprogress)
 		calculate_totals(filemap);
 
diff --git a/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
new file mode 100644
index 00000000000..8c23efbf1cb
--- /dev/null
+++ b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
@@ -0,0 +1,120 @@
+# Copyright (c) 2021-2025, PostgreSQL Global Development Group
+#
+# Test situation where we skip copying the same WAL files from source
+# to target unless file size differs.
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Utils;
+use Test::More;
+use File::stat qw(stat);
+
+use FindBin;
+use lib $FindBin::RealBin;
+use RewindTest;
+use Time::HiRes qw(usleep);
+
+RewindTest::setup_cluster();
+RewindTest::start_primary();
+
+RewindTest::create_standby();
+
+
+# Advance WAL on primary
+RewindTest::primary_psql("CREATE TABLE t(a int)");
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+
+# Common segment to be skipped copying over as it's common and same size
+my $wal_seg_skipped = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# Segment before divergerec that will be copied over because file size differs
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+my $corrupt_wal_seg = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# last common checkpoint
+RewindTest::primary_psql("CHECKPOINT");
+
+RewindTest::promote_standby;
+
+# New Timeline Segment after divergerec, expected to be copied
+my $new_timeline_wal_seg = $node_standby->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+# Get stat info for the WAL file that should be skipped
+my $wal_skipped_path = $node_primary->data_dir . '/pg_wal/' . $wal_seg_skipped;
+my $wal_skipped_stat = stat($wal_skipped_path);
+defined($wal_skipped_stat) or die("unable to stat $wal_skipped_path");
+
+# Store modification time for later comparison
+my $wal_seg_skipped_mod_time = $wal_skipped_stat->mtime;
+
+# Corrupt a segment on target before divergerec to test it's copied over from source,
+# by appending an additional byte to it.
+my $corrupt_wal_seg_in_target_path = $node_primary->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+open my $fh, ">>", $corrupt_wal_seg_in_target_path
+    or die "could not open $corrupt_wal_seg_in_target_path";
+
+print $fh 'a';
+close $fh;
+
+my $corrupt_wal_seg_stat_before_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_before_rewind), "WAL segment $corrupt_wal_seg should exist in target before rewind");
+
+# Verify that the WAL segment on new timeline does not exist in target before rewind
+my $new_timeline_wal_seg_path = $node_primary->data_dir . '/pg_wal/' . $new_timeline_wal_seg;
+my $new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(!defined($new_timeline_wal_seg_stat), "WAL segment $new_timeline_wal_seg should not exist in target before rewind");
+
+$node_standby->stop();
+$node_primary->stop();
+
+# Sleep to allow mtime to be different
+usleep(1000000);
+
+command_checks_all(
+	[
+		'pg_rewind', '--debug',
+		'--source-pgdata' => $node_standby->data_dir,
+		'--target-pgdata' => $node_primary->data_dir,
+		'--no-sync',
+	],
+	0,
+	[qr//
+	],
+	[qr/WAL segment \"$wal_seg_skipped\" not copied to target/,
+	 qr/pg_wal\/$corrupt_wal_seg \(COPY\)/
+	],
+	'run pg_rewind'
+);
+
+# Verify that the copied WAL segment now exists in target
+$new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(defined($new_timeline_wal_seg_stat), "WAL segment $new_timeline_wal_seg should exist in target after rewind");
+
+# Get current modification time of the skipped WAL segment
+my $wal_skipped_stat_after_rewind = stat($wal_skipped_path);
+defined($wal_skipped_stat_after_rewind) or die("unable to stat $wal_skipped_path after rewind");
+my $wal_seg_latest_skipped_mod_time = $wal_skipped_stat_after_rewind->mtime;
+
+# Validate that modification time hasn't changed,
+is($wal_seg_latest_skipped_mod_time, $wal_seg_skipped_mod_time,
+   "WAL segment $wal_seg_skipped modification time should be unchanged (not overwritten)");
+
+# Validate that the WAL segment with same filename as the
+# corrupt WAL segment in target has been copied from source
+# where we have it intact.
+my $corrupt_wal_seg_in_source_path = $node_standby->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+my $corrupt_wal_seg_source_stat = stat($corrupt_wal_seg_in_source_path);
+ok(defined($corrupt_wal_seg_source_stat), "WAL segment $corrupt_wal_seg should exist in source after rewind");
+my $corrupt_wal_seg_stat_after_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_after_rewind), "WAL segment $corrupt_wal_seg should exist in target after rewind");
+ok($corrupt_wal_seg_stat_before_rewind->size != $corrupt_wal_seg_source_stat->size,
+	"Expected WAL segment $corrupt_wal_seg to have different size in source vs target before rewind");
+ok($corrupt_wal_seg_stat_after_rewind->mtime > $corrupt_wal_seg_stat_before_rewind->mtime,
+	"Expected WAL segment $corrupt_wal_seg to have greater mtime  on target than source after rewind");
+ok($corrupt_wal_seg_stat_after_rewind->size == $corrupt_wal_seg_source_stat->size,
+	"Expected WAL segment $corrupt_wal_seg file sizes to be same between target and source after rewind");
+
+done_testing();
-- 
2.50.1

From 0896b78e4ed60c8b57481783d06c7522f5672692 Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Wed, 8 Oct 2025 21:20:59 +0000
Subject: [PATCH v11] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a check to avoid copying any WAL segment files from source
to target if they are common between both servers before the
point of WAL divergence during pg_rewind.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target as they have been replicated
from the original primary.

Author: John Hsu <johnhyvr@gmail.com>
Co-Author: Justin Kwan <justinpkwan@outlook.com>
---
 doc/src/sgml/ref/pg_rewind.sgml               |  30 ++-
 src/bin/pg_rewind/filemap.c                   | 243 +++++++++++-------
 src/bin/pg_rewind/filemap.h                   |  12 +-
 src/bin/pg_rewind/pg_rewind.c                 |   6 +-
 .../t/011_avoid_copying_common_wals.pl        | 120 +++++++++
 5 files changed, 308 insertions(+), 103 deletions(-)
 create mode 100644 src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl

diff --git a/doc/src/sgml/ref/pg_rewind.sgml b/doc/src/sgml/ref/pg_rewind.sgml
index 5485033ed8c..4e60e6dbef8 100644
--- a/doc/src/sgml/ref/pg_rewind.sgml
+++ b/doc/src/sgml/ref/pg_rewind.sgml
@@ -52,12 +52,30 @@ PostgreSQL documentation
    analogous to a base backup of the source data directory. Unlike taking
    a new base backup or using a tool like <application>rsync</application>,
    <application>pg_rewind</application> does not require comparing or copying
-   unchanged relation blocks in the cluster. Only changed blocks from existing
-   relation files are copied; all other files, including new relation files,
-   configuration files, and WAL segments, are copied in full. As such the
-   rewind operation is significantly faster than other approaches when the
-   database is large and only a small fraction of blocks differ between the
-   clusters.
+   unchanged relation blocks in the cluster.
+  </para>
+  <orderedlist>
+   <listitem>
+    <para>
+     Only changed blocks from existing relation files are copied
+    </para>
+   </listitem>
+   <listitem>
+    <para>
+     WAL segments prior to the point of divergence are skipped
+    </para>
+   </listitem>
+   <listitem>
+    <para>
+     All other files, including new relation files, configuration files, and WAL
+     segments after point of divergence are copied in full.
+    </para>
+   </listitem>
+   </orderedlist>
+   <para>
+    As such the rewind operation is significantly faster than other approaches when
+    the database is large and only a small fraction of blocks differ between the
+    clusters.
   </para>
 
   <para>
diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index c933871ca9f..27f89842d66 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -55,7 +55,6 @@
 
 static filehash_hash *filehash;
 
-static bool isRelDataFile(const char *path);
 static char *datasegpath(RelFileLocator rlocator, ForkNumber forknum,
 						 BlockNumber segno);
 
@@ -199,6 +198,103 @@ filehash_init(void)
 	filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }
 
+static file_content_type_t
+getFileContentType(const char *path)
+{
+	RelFileLocator rlocator;
+	unsigned int segNo;
+	int			nmatch;
+	bool		matched;
+
+	/* Check if it's a WAL file */
+	if (strncmp("pg_wal/", path, 7) == 0)
+	{
+		const char *filename = path + 7;	/* Skip "pg_wal/" */
+
+		pg_log_debug("file_name: %s", filename);
+		if (IsXLogFileName(filename))
+			return FILE_CONTENT_TYPE_WAL;
+		else
+			return FILE_CONTENT_TYPE_OTHER;
+	}
+
+	/*
+	 * Does it look like a relation data file?
+	 *
+	 * For our purposes, only files belonging to the main fork are considered
+	 * relation files. Other forks are always copied in toto, because we
+	 * cannot reliably track changes to them, because WAL only contains block
+	 * references for the main fork.
+	 *
+	 * ---- Relation data files can be in one of the following directories:
+	 *
+	 * global/ shared relations
+	 *
+	 * base/<db oid>/ regular relations, default tablespace
+	 *
+	 * pg_tblspc/<tblspc oid>/<tblspc version>/ within a non-default
+	 * tablespace (the name of the directory depends on version)
+	 *
+	 * And the relation data files themselves have a filename like:
+	 *
+	 * <oid>.<segment number>
+	 *
+	 * ----
+	 */
+	rlocator.spcOid = InvalidOid;
+	rlocator.dbOid = InvalidOid;
+	rlocator.relNumber = InvalidRelFileNumber;
+	segNo = 0;
+	matched = false;
+
+	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
+	if (nmatch == 1 || nmatch == 2)
+	{
+		rlocator.spcOid = GLOBALTABLESPACE_OID;
+		rlocator.dbOid = 0;
+		matched = true;
+	}
+	else
+	{
+		nmatch = sscanf(path, "base/%u/%u.%u",
+						&rlocator.dbOid, &rlocator.relNumber, &segNo);
+		if (nmatch == 2 || nmatch == 3)
+		{
+			rlocator.spcOid = DEFAULTTABLESPACE_OID;
+			matched = true;
+		}
+		else
+		{
+			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
+							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
+							&segNo);
+			if (nmatch == 3 || nmatch == 4)
+				matched = true;
+		}
+	}
+
+	/*
+	 * The sscanf tests above can match files that have extra characters at
+	 * the end. To eliminate such cases, cross-check that GetRelationPath
+	 * creates the exact same filename, when passed the RelFileLocator
+	 * information we extracted from the filename.
+	 */
+	if (matched)
+	{
+		char	   *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
+
+		if (strcmp(check_path, path) != 0)
+			matched = false;
+
+		pfree(check_path);
+	}
+
+	if (matched)
+		return FILE_CONTENT_TYPE_RELATION;
+
+	return FILE_CONTENT_TYPE_OTHER;
+}
+
 /* Look up entry for 'path', creating a new one if it doesn't exist */
 static file_entry_t *
 insert_filehash_entry(const char *path)
@@ -210,7 +306,7 @@ insert_filehash_entry(const char *path)
 	if (!found)
 	{
 		entry->path = pg_strdup(path);
-		entry->isrelfile = isRelDataFile(path);
+		entry->content_type = getFileContentType(path);
 
 		entry->target_exists = false;
 		entry->target_type = FILE_TYPE_UNDEFINED;
@@ -294,7 +390,7 @@ process_source_file(const char *path, file_type_t type, size_t size,
 	 * sanity check: a filename that looks like a data file better be a
 	 * regular file
 	 */
-	if (type != FILE_TYPE_REGULAR && isRelDataFile(path))
+	if (type != FILE_TYPE_REGULAR && getFileContentType(path) == FILE_CONTENT_TYPE_RELATION)
 		pg_fatal("data file \"%s\" in source is not a regular file", path);
 
 	/* Remember this source file */
@@ -383,7 +479,7 @@ process_target_wal_block_change(ForkNumber forknum, RelFileLocator rlocator,
 	 */
 	if (entry)
 	{
-		Assert(entry->isrelfile);
+		Assert(entry->content_type == FILE_CONTENT_TYPE_RELATION);
 
 		if (entry->target_exists)
 		{
@@ -559,92 +655,6 @@ print_filemap(filemap_t *filemap)
 	fflush(stdout);
 }
 
-/*
- * Does it look like a relation data file?
- *
- * For our purposes, only files belonging to the main fork are considered
- * relation files. Other forks are always copied in toto, because we cannot
- * reliably track changes to them, because WAL only contains block references
- * for the main fork.
- */
-static bool
-isRelDataFile(const char *path)
-{
-	RelFileLocator rlocator;
-	unsigned int segNo;
-	int			nmatch;
-	bool		matched;
-
-	/*----
-	 * Relation data files can be in one of the following directories:
-	 *
-	 * global/
-	 *		shared relations
-	 *
-	 * base/<db oid>/
-	 *		regular relations, default tablespace
-	 *
-	 * pg_tblspc/<tblspc oid>/<tblspc version>/
-	 *		within a non-default tablespace (the name of the directory
-	 *		depends on version)
-	 *
-	 * And the relation data files themselves have a filename like:
-	 *
-	 * <oid>.<segment number>
-	 *
-	 *----
-	 */
-	rlocator.spcOid = InvalidOid;
-	rlocator.dbOid = InvalidOid;
-	rlocator.relNumber = InvalidRelFileNumber;
-	segNo = 0;
-	matched = false;
-
-	nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
-	if (nmatch == 1 || nmatch == 2)
-	{
-		rlocator.spcOid = GLOBALTABLESPACE_OID;
-		rlocator.dbOid = 0;
-		matched = true;
-	}
-	else
-	{
-		nmatch = sscanf(path, "base/%u/%u.%u",
-						&rlocator.dbOid, &rlocator.relNumber, &segNo);
-		if (nmatch == 2 || nmatch == 3)
-		{
-			rlocator.spcOid = DEFAULTTABLESPACE_OID;
-			matched = true;
-		}
-		else
-		{
-			nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
-							&rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
-							&segNo);
-			if (nmatch == 3 || nmatch == 4)
-				matched = true;
-		}
-	}
-
-	/*
-	 * The sscanf tests above can match files that have extra characters at
-	 * the end. To eliminate such cases, cross-check that GetRelationPath
-	 * creates the exact same filename, when passed the RelFileLocator
-	 * information we extracted from the filename.
-	 */
-	if (matched)
-	{
-		char	   *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
-
-		if (strcmp(check_path, path) != 0)
-			matched = false;
-
-		pfree(check_path);
-	}
-
-	return matched;
-}
-
 /*
  * A helper function to create the path of a relation file and segment.
  *
@@ -693,11 +703,44 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ * Caller is responsible for ensuring the file exists on both
+ * source and target.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname, XLogSegNo last_common_segno,
+					   size_t source_size, size_t target_size)
+{
+	TimeLineID	file_tli;
+	XLogSegNo	file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target which means they
+	 * should already be identical and before the last_common_segno.
+	 *
+	 * However we check last_common_segno and file_size again for sanity.
+	 */
+	if (file_segno < last_common_segno && source_size == target_size)
+	{
+		pg_log_debug("WAL segment \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
 static file_action_t
-decide_file_action(file_entry_t *entry)
+decide_file_action(file_entry_t *entry, XLogSegNo last_common_segno)
 {
 	const char *path = entry->path;
 
@@ -799,7 +842,19 @@ decide_file_action(file_entry_t *entry)
 			return FILE_ACTION_NONE;
 
 		case FILE_TYPE_REGULAR:
-			if (!entry->isrelfile)
+			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
+			{
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++; /* Skip the separator */
+
+				return decide_wal_file_action(filename, last_common_segno, entry->source_size, entry->target_size);
+			}
+			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
 				/*
 				 * It's a non-data file that we have no special processing
@@ -858,7 +913,7 @@ decide_file_action(file_entry_t *entry)
  * should be executed.
  */
 filemap_t *
-decide_file_actions(void)
+decide_file_actions(XLogSegNo last_common_segno)
 {
 	int			i;
 	filehash_iterator it;
@@ -868,7 +923,7 @@ decide_file_actions(void)
 	filehash_start_iterate(filehash, &it);
 	while ((entry = filehash_iterate(filehash, &it)) != NULL)
 	{
-		entry->action = decide_file_action(entry);
+		entry->action = decide_file_action(entry, last_common_segno);
 	}
 
 	/*
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index df78a02e3da..982de52176b 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -36,6 +37,13 @@ typedef enum
 	FILE_TYPE_SYMLINK,
 } file_type_t;
 
+typedef enum
+{
+	FILE_CONTENT_TYPE_OTHER = 0,
+	FILE_CONTENT_TYPE_RELATION,
+	FILE_CONTENT_TYPE_WAL
+}			file_content_type_t;
+
 /*
  * For every file found in the local or remote system, we have a file entry
  * that contains information about the file on both systems.  For relation
@@ -51,7 +59,7 @@ typedef struct file_entry_t
 	uint32		status;			/* hash status */
 
 	const char *path;
-	bool		isrelfile;		/* is it a relation data file? */
+	file_content_type_t content_type;
 
 	/*
 	 * Status of the file in the target.
@@ -106,7 +114,7 @@ extern void process_target_wal_block_change(ForkNumber forknum,
 											RelFileLocator rlocator,
 											BlockNumber blkno);
 
-extern filemap_t *decide_file_actions(void);
+extern filemap_t *decide_file_actions(XLogSegNo last_common_segno);
 extern void calculate_totals(filemap_t *filemap);
 extern void print_filemap(filemap_t *filemap);
 
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 0c68dd4235e..318d0a27184 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -147,6 +147,7 @@ main(int argc, char **argv)
 	TimeLineID	source_tli;
 	TimeLineID	target_tli;
 	XLogRecPtr	target_wal_endrec;
+	XLogSegNo	last_common_segno;
 	size_t		size;
 	char	   *buffer;
 	bool		no_ensure_shutdown = false;
@@ -397,6 +398,9 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/* Convert divergence LSN to segment number */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -492,7 +496,7 @@ main(int argc, char **argv)
 	 * We have collected all information we need from both systems. Decide
 	 * what to do with each file.
 	 */
-	filemap = decide_file_actions();
+	filemap = decide_file_actions(last_common_segno);
 	if (showprogress)
 		calculate_totals(filemap);
 
diff --git a/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
new file mode 100644
index 00000000000..a39972e689d
--- /dev/null
+++ b/src/bin/pg_rewind/t/011_avoid_copying_common_wals.pl
@@ -0,0 +1,120 @@
+# Copyright (c) 2021-2025, PostgreSQL Global Development Group
+#
+# Test situation where we skip copying the same WAL files from source
+# to target unless file size differs.
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Utils;
+use Test::More;
+use File::stat qw(stat);
+
+use FindBin;
+use lib $FindBin::RealBin;
+use RewindTest;
+use Time::HiRes qw(usleep);
+
+RewindTest::setup_cluster();
+RewindTest::start_primary();
+
+RewindTest::create_standby();
+
+
+# Advance WAL on primary
+RewindTest::primary_psql("CREATE TABLE t(a int)");
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+
+# Common segment to be skipped copying over as it's common and same size
+my $wal_seg_skipped = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# Segment before divergerec that will be copied over because file size differs
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+my $corrupt_wal_seg = $node_primary->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# last common checkpoint
+RewindTest::primary_psql("CHECKPOINT");
+
+RewindTest::promote_standby;
+
+# New Timeline Segment after divergerec, expected to be copied
+my $new_timeline_wal_seg = $node_standby->safe_psql('postgres', 'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+# Get stat info for the WAL file that should be skipped
+my $wal_skipped_path = $node_primary->data_dir . '/pg_wal/' . $wal_seg_skipped;
+my $wal_skipped_stat = stat($wal_skipped_path);
+defined($wal_skipped_stat) or die("unable to stat $wal_skipped_path");
+
+# Store modification time for later comparison
+my $wal_seg_skipped_mod_time = $wal_skipped_stat->mtime;
+
+# Corrupt a segment on target before divergerec to test it's copied over from source,
+# by appending an additional byte to it.
+my $corrupt_wal_seg_in_target_path = $node_primary->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+open my $fh, ">>", $corrupt_wal_seg_in_target_path
+    or die "could not open $corrupt_wal_seg_in_target_path";
+
+print $fh 'a';
+close $fh;
+
+my $corrupt_wal_seg_stat_before_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_before_rewind), "WAL segment $corrupt_wal_seg should exist in target before rewind");
+
+# Verify that the WAL segment on new timeline does not exist in target before rewind
+my $new_timeline_wal_seg_path = $node_primary->data_dir . '/pg_wal/' . $new_timeline_wal_seg;
+my $new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(!defined($new_timeline_wal_seg_stat), "WAL segment $new_timeline_wal_seg should not exist in target before rewind");
+
+$node_standby->stop();
+$node_primary->stop();
+
+# Sleep to allow mtime to be different
+usleep(1000000);
+
+command_checks_all(
+	[
+		'pg_rewind', '--debug',
+		'--source-pgdata' => $node_standby->data_dir,
+		'--target-pgdata' => $node_primary->data_dir,
+		'--no-sync',
+	],
+	0,
+	[qr//
+	],
+	[qr/WAL segment \"$wal_seg_skipped\" not copied to target/,
+	 qr/pg_wal\/$corrupt_wal_seg \(COPY\)/
+	],
+	'run pg_rewind'
+);
+
+# Verify that the copied WAL segment now exists in target
+$new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(defined($new_timeline_wal_seg_stat), "WAL segment $new_timeline_wal_seg should exist in target after rewind");
+
+# Get current modification time of the skipped WAL segment
+my $wal_skipped_stat_after_rewind = stat($wal_skipped_path);
+defined($wal_skipped_stat_after_rewind) or die("unable to stat $wal_skipped_path after rewind");
+my $wal_seg_latest_skipped_mod_time = $wal_skipped_stat_after_rewind->mtime;
+
+# Validate that modification time hasn't changed,
+is($wal_seg_latest_skipped_mod_time, $wal_seg_skipped_mod_time,
+   "WAL segment $wal_seg_skipped modification time should be unchanged (not overwritten)");
+
+# Validate that the WAL segment with same filename as the
+# corrupt WAL segment in target has been copied from source
+# where we have it intact.
+my $corrupt_wal_seg_in_source_path = $node_standby->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+my $corrupt_wal_seg_source_stat = stat($corrupt_wal_seg_in_source_path);
+ok(defined($corrupt_wal_seg_source_stat), "WAL segment $corrupt_wal_seg should exist in source after rewind");
+my $corrupt_wal_seg_stat_after_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_after_rewind), "WAL segment $corrupt_wal_seg should exist in target after rewind");
+ok($corrupt_wal_seg_stat_before_rewind->size != $corrupt_wal_seg_source_stat->size,
+	"Expected WAL segment $corrupt_wal_seg to have different size in source vs target before rewind");
+ok($corrupt_wal_seg_stat_after_rewind->mtime > $corrupt_wal_seg_stat_before_rewind->mtime,
+	"Expected WAL segment $corrupt_wal_seg to have later mtime on target than source after rewind as it was copied");
+ok($corrupt_wal_seg_stat_after_rewind->size == $corrupt_wal_seg_source_stat->size,
+	"Expected WAL segment $corrupt_wal_seg file sizes to be same between target and source after rewind as it was copied");
+
+done_testing();
-- 
2.50.1

From 93970d6e62812738778668fe5551198e8749dc7f Mon Sep 17 00:00:00 2001
From: John Hsu <johnyvr@gmail.com>
Date: Wed, 8 Oct 2025 21:20:59 +0000
Subject: [PATCH v12] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a check to avoid copying any WAL segment files from source
to target if they are common between both servers before the
point of WAL divergence during pg_rewind.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target as they have been replicated
from the original primary.

Author: John Hsu <johnhyvr@gmail.com>
Co-Author: Justin Kwan <justinpkwan@outlook.com>
---
 src/bin/pg_rewind/filemap.c         |  53 ++++++++++-
 src/bin/pg_rewind/filemap.h         |   3 +-
 src/bin/pg_rewind/meson.build       |   1 +
 src/bin/pg_rewind/pg_rewind.c       |   9 +-
 src/bin/pg_rewind/t/011_wal_copy.pl | 141 ++++++++++++++++++++++++++++
 doc/src/sgml/ref/pg_rewind.sgml     |  32 +++++--
 6 files changed, 226 insertions(+), 13 deletions(-)
 create mode 100644 src/bin/pg_rewind/t/011_wal_copy.pl

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 00f5d60d6209..2d82edec0608 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -706,11 +706,45 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ *
+ * Caller is responsible for ensuring that the file exists on both
+ * source and target servers.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname, XLogSegNo last_common_segno,
+					   size_t source_size, size_t target_size)
+{
+	TimeLineID	file_tli;
+	XLogSegNo	file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files are assumed to exist on source and target which means they
+	 * should already be identical and before the last_common_segno.
+	 *
+	 * However we check last_common_segno and file_size again for sanity.
+	 */
+	if (file_segno < last_common_segno && source_size == target_size)
+	{
+		pg_log_debug("WAL segment \"%s\" not copied to target", fname);
+		return FILE_ACTION_NONE;
+	}
+
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
 static file_action_t
-decide_file_action(file_entry_t *entry)
+decide_file_action(file_entry_t *entry, XLogSegNo last_common_segno)
 {
 	const char *path = entry->path;
 
@@ -814,8 +848,17 @@ decide_file_action(file_entry_t *entry)
 		case FILE_TYPE_REGULAR:
 			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
 			{
-				/* It's a WAL file, copy it. */
-				return FILE_ACTION_COPY;
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++; /* Skip the separator */
+
+				return decide_wal_file_action(filename, last_common_segno,
+											  entry->source_size,
+											  entry->target_size);
 			}
 			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
@@ -876,7 +919,7 @@ decide_file_action(file_entry_t *entry)
  * should be executed.
  */
 filemap_t *
-decide_file_actions(void)
+decide_file_actions(XLogSegNo last_common_segno)
 {
 	int			i;
 	filehash_iterator it;
@@ -886,7 +929,7 @@ decide_file_actions(void)
 	filehash_start_iterate(filehash, &it);
 	while ((entry = filehash_iterate(filehash, &it)) != NULL)
 	{
-		entry->action = decide_file_action(entry);
+		entry->action = decide_file_action(entry, last_common_segno);
 	}
 
 	/*
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index fada420fc230..5145f0b4c46c 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -113,7 +114,7 @@ extern void process_target_wal_block_change(ForkNumber forknum,
 											RelFileLocator rlocator,
 											BlockNumber blkno);
 
-extern filemap_t *decide_file_actions(void);
+extern filemap_t *decide_file_actions(XLogSegNo last_common_segno);
 extern void calculate_totals(filemap_t *filemap);
 extern void print_filemap(filemap_t *filemap);
 
diff --git a/src/bin/pg_rewind/meson.build b/src/bin/pg_rewind/meson.build
index 36171600ccaf..97f001d94a50 100644
--- a/src/bin/pg_rewind/meson.build
+++ b/src/bin/pg_rewind/meson.build
@@ -44,6 +44,7 @@ tests += {
       't/008_min_recovery_point.pl',
       't/009_growing_files.pl',
       't/010_keep_recycled_wals.pl',
+      't/011_wal_copy.pl',
     ],
   },
 }
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 0c68dd4235e6..1b953692b176 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -147,6 +147,7 @@ main(int argc, char **argv)
 	TimeLineID	source_tli;
 	TimeLineID	target_tli;
 	XLogRecPtr	target_wal_endrec;
+	XLogSegNo	last_common_segno;
 	size_t		size;
 	char	   *buffer;
 	bool		no_ensure_shutdown = false;
@@ -397,6 +398,12 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/*
+		 * Convert the divergence LSN to a segment number, that will be used
+		 * to decide how WAL segments should be processed.
+		 */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -492,7 +499,7 @@ main(int argc, char **argv)
 	 * We have collected all information we need from both systems. Decide
 	 * what to do with each file.
 	 */
-	filemap = decide_file_actions();
+	filemap = decide_file_actions(last_common_segno);
 	if (showprogress)
 		calculate_totals(filemap);
 
diff --git a/src/bin/pg_rewind/t/011_wal_copy.pl b/src/bin/pg_rewind/t/011_wal_copy.pl
new file mode 100644
index 000000000000..b9e24844654d
--- /dev/null
+++ b/src/bin/pg_rewind/t/011_wal_copy.pl
@@ -0,0 +1,141 @@
+# Copyright (c) 2025, PostgreSQL Global Development Group
+#
+# Check how the copy of WAL segments is handled from the source to
+# the target server.
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Utils;
+use Test::More;
+use File::stat qw(stat);
+
+use FindBin;
+use lib $FindBin::RealBin;
+use RewindTest;
+use Time::HiRes qw(usleep);
+
+RewindTest::setup_cluster();
+RewindTest::start_primary();
+RewindTest::create_standby();
+
+# Advance WAL on primary
+RewindTest::primary_psql("CREATE TABLE t(a int)");
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+
+# Segment that is not copied from the source to the target, being
+# generated before the servers have diverged.
+my $wal_seg_skipped = $node_primary->safe_psql('postgres',
+	'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# Follow-up segment, that will include corrupted contents, and should be
+# copied from the source to the target even if generated before the point
+# of divergence.
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+my $corrupt_wal_seg = $node_primary->safe_psql('postgres',
+	'SELECT pg_walfile_name(pg_current_wal_lsn())');
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+RewindTest::primary_psql("CHECKPOINT");
+RewindTest::promote_standby;
+
+# New segment on a new timeline, expected to be copied.
+my $new_timeline_wal_seg = $node_standby->safe_psql('postgres',
+	'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+# Get some stats info for the WAL files whose copies should be skipped.
+my $wal_skipped_path =
+  $node_primary->data_dir . '/pg_wal/' . $wal_seg_skipped;
+my $wal_skipped_stat = stat($wal_skipped_path);
+defined($wal_skipped_stat) or die("unable to stat $wal_skipped_path");
+
+# Store modification time for later comparison
+my $wal_seg_skipped_mod_time = $wal_skipped_stat->mtime;
+
+# Corrupt a WAL segment on target that has been generated before the
+# divergence point.  We will check that it is copied over from source.
+my $corrupt_wal_seg_in_target_path =
+  $node_primary->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+open my $fh, ">>", $corrupt_wal_seg_in_target_path
+  or die "could not open $corrupt_wal_seg_in_target_path";
+
+print $fh 'a';
+close $fh;
+
+my $corrupt_wal_seg_stat_before_rewind =
+  stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_before_rewind),
+	"WAL segment $corrupt_wal_seg should exist in target before rewind");
+
+# Verify that the WAL segment on the new timeline does not exist in target
+# before the rewind.
+my $new_timeline_wal_seg_path =
+  $node_primary->data_dir . '/pg_wal/' . $new_timeline_wal_seg;
+my $new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(!defined($new_timeline_wal_seg_stat),
+	"WAL segment $new_timeline_wal_seg should not exist in target before rewind"
+);
+
+$node_standby->stop();
+$node_primary->stop();
+
+# Sleep to allow mtime to be different
+usleep(1000000);
+
+command_checks_all(
+	[
+		'pg_rewind', '--debug',
+		'--source-pgdata' => $node_standby->data_dir,
+		'--target-pgdata' => $node_primary->data_dir,
+		'--no-sync',
+	],
+	0,
+	[qr//],
+	[
+		qr/WAL segment \"$wal_seg_skipped\" not copied to target/,
+		qr/pg_wal\/$corrupt_wal_seg \(COPY\)/
+	],
+	'run pg_rewind');
+
+# Verify that the copied WAL segment now exists in target.
+$new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(defined($new_timeline_wal_seg_stat),
+	"WAL segment $new_timeline_wal_seg should exist in target after rewind");
+
+# Get current modification time of the skipped WAL segment.
+my $wal_skipped_stat_after_rewind = stat($wal_skipped_path);
+defined($wal_skipped_stat_after_rewind)
+  or die("unable to stat $wal_skipped_path after rewind");
+my $wal_seg_latest_skipped_mod_time = $wal_skipped_stat_after_rewind->mtime;
+
+# Validate that modification time hasn't changed.
+is($wal_seg_latest_skipped_mod_time, $wal_seg_skipped_mod_time,
+	"WAL segment $wal_seg_skipped modification time should be unchanged (not overwritten)"
+);
+
+# Validate that the WAL segment with the same file name as the
+# corrupted WAL segment in target has been copied from source
+# where we have it intact.
+my $corrupt_wal_seg_in_source_path =
+  $node_standby->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+my $corrupt_wal_seg_source_stat = stat($corrupt_wal_seg_in_source_path);
+ok(defined($corrupt_wal_seg_source_stat),
+	"WAL segment $corrupt_wal_seg should exist in source after rewind");
+my $corrupt_wal_seg_stat_after_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_after_rewind),
+	"WAL segment $corrupt_wal_seg should exist in target after rewind");
+ok( $corrupt_wal_seg_stat_before_rewind->size !=
+	  $corrupt_wal_seg_source_stat->size,
+	"Expected WAL segment $corrupt_wal_seg to have different size in source vs target before rewind"
+);
+ok( $corrupt_wal_seg_stat_after_rewind->mtime >
+	  $corrupt_wal_seg_stat_before_rewind->mtime,
+	"Expected WAL segment $corrupt_wal_seg to have later mtime on target than source after rewind as it was copied"
+);
+ok( $corrupt_wal_seg_stat_after_rewind->size ==
+	  $corrupt_wal_seg_source_stat->size,
+	"Expected WAL segment $corrupt_wal_seg file sizes to be same between target and source after rewind as it was copied"
+);
+
+done_testing();
diff --git a/doc/src/sgml/ref/pg_rewind.sgml b/doc/src/sgml/ref/pg_rewind.sgml
index 5485033ed8c7..440b2c79f5f0 100644
--- a/doc/src/sgml/ref/pg_rewind.sgml
+++ b/doc/src/sgml/ref/pg_rewind.sgml
@@ -52,12 +52,32 @@ PostgreSQL documentation
    analogous to a base backup of the source data directory. Unlike taking
    a new base backup or using a tool like <application>rsync</application>,
    <application>pg_rewind</application> does not require comparing or copying
-   unchanged relation blocks in the cluster. Only changed blocks from existing
-   relation files are copied; all other files, including new relation files,
-   configuration files, and WAL segments, are copied in full. As such the
-   rewind operation is significantly faster than other approaches when the
-   database is large and only a small fraction of blocks differ between the
-   clusters.
+   unchanged relation blocks in the cluster.
+  </para>
+  <orderedlist>
+   <listitem>
+    <para>
+     Only changed blocks from existing relation files are copied.
+    </para>
+   </listitem>
+   <listitem>
+    <para>
+     WAL segments prior to the point where the source and target servers
+     have diverged are not copied. WAL segments generated after the source
+     and target servers have diverged are copied in full.
+    </para>
+   </listitem>
+   <listitem>
+    <para>
+     All other files, including new relation files and configuration files,
+     are copied in full.
+    </para>
+   </listitem>
+   </orderedlist>
+   <para>
+    As such, the rewind operation is significantly faster than other
+    approaches when the database is large and only a small fraction of blocks
+    differ between the clusters.
   </para>
 
   <para>
-- 
2.51.0

From 2697ce6f8f2267a844e80e5ce7c253489b1f450d Mon Sep 17 00:00:00 2001
From: Michael Paquier <michael@paquier.xyz>
Date: Fri, 24 Oct 2025 17:35:31 +0900
Subject: [PATCH v13] Avoid copying WAL segments before divergence to speed up
 pg_rewind

Adds a check to avoid copying any WAL segment files from source
to target if they are common between both servers before the
point of WAL divergence during pg_rewind.
All WAL files that exist on source and target, which fall
before the segment of the first diverged LSN can safely be
skipped from copying to the target as they have been replicated
from the original primary.

Author: John Hsu <johnhyvr@gmail.com>
Co-Author: Justin Kwan <justinpkwan@outlook.com>
---
 src/bin/pg_rewind/filemap.c         |  55 ++++++++++--
 src/bin/pg_rewind/filemap.h         |   3 +-
 src/bin/pg_rewind/meson.build       |   1 +
 src/bin/pg_rewind/pg_rewind.c       |   9 +-
 src/bin/pg_rewind/t/011_wal_copy.pl | 128 ++++++++++++++++++++++++++++
 doc/src/sgml/ref/pg_rewind.sgml     |  32 +++++--
 6 files changed, 215 insertions(+), 13 deletions(-)
 create mode 100644 src/bin/pg_rewind/t/011_wal_copy.pl

diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c
index 00f5d60d6209..59672e669323 100644
--- a/src/bin/pg_rewind/filemap.c
+++ b/src/bin/pg_rewind/filemap.c
@@ -546,7 +546,9 @@ print_filemap(filemap_t *filemap)
 	for (i = 0; i < filemap->nentries; i++)
 	{
 		entry = filemap->entries[i];
+
 		if (entry->action != FILE_ACTION_NONE ||
+			entry->content_type == FILE_CONTENT_TYPE_WAL ||
 			entry->target_pages_to_overwrite.bitmapsize > 0)
 		{
 			pg_log_debug("%s (%s)", entry->path,
@@ -706,11 +708,45 @@ final_filemap_cmp(const void *a, const void *b)
 		return strcmp(fa->path, fb->path);
 }
 
+/*
+ * Decide what to do with a WAL segment file based on its position
+ * relative to the point of divergence.
+ *
+ * Caller is responsible for ensuring that the file exists on both
+ * source and target servers.
+ */
+static file_action_t
+decide_wal_file_action(const char *fname, XLogSegNo last_common_segno,
+					   size_t source_size, size_t target_size)
+{
+	TimeLineID	file_tli;
+	XLogSegNo	file_segno;
+
+	/* Get current WAL segment number given current segment file name */
+	XLogFromFileName(fname, &file_tli, &file_segno, WalSegSz);
+
+	/*
+	 * Avoid copying files before the last common segment.
+	 *
+	 * These files exist on the source and the target services, so they should
+	 * be identical and located strictly before the segment that contains the
+	 * LSN where target and source servers have diverged.
+	 *
+	 * While we are on it, double-check the size of each file and copy the
+	 * file if they do not match, in case.
+	 */
+	if (file_segno < last_common_segno &&
+		source_size == target_size)
+		return FILE_ACTION_NONE;
+
+	return FILE_ACTION_COPY;
+}
+
 /*
  * Decide what action to perform to a file.
  */
 static file_action_t
-decide_file_action(file_entry_t *entry)
+decide_file_action(file_entry_t *entry, XLogSegNo last_common_segno)
 {
 	const char *path = entry->path;
 
@@ -814,8 +850,17 @@ decide_file_action(file_entry_t *entry)
 		case FILE_TYPE_REGULAR:
 			if (entry->content_type == FILE_CONTENT_TYPE_WAL)
 			{
-				/* It's a WAL file, copy it. */
-				return FILE_ACTION_COPY;
+				/* Handle WAL segment file */
+				const char *filename = last_dir_separator(entry->path);
+
+				if (filename == NULL)
+					filename = entry->path;
+				else
+					filename++; /* Skip the separator */
+
+				return decide_wal_file_action(filename, last_common_segno,
+											  entry->source_size,
+											  entry->target_size);
 			}
 			else if (entry->content_type != FILE_CONTENT_TYPE_RELATION)
 			{
@@ -876,7 +921,7 @@ decide_file_action(file_entry_t *entry)
  * should be executed.
  */
 filemap_t *
-decide_file_actions(void)
+decide_file_actions(XLogSegNo last_common_segno)
 {
 	int			i;
 	filehash_iterator it;
@@ -886,7 +931,7 @@ decide_file_actions(void)
 	filehash_start_iterate(filehash, &it);
 	while ((entry = filehash_iterate(filehash, &it)) != NULL)
 	{
-		entry->action = decide_file_action(entry);
+		entry->action = decide_file_action(entry, last_common_segno);
 	}
 
 	/*
diff --git a/src/bin/pg_rewind/filemap.h b/src/bin/pg_rewind/filemap.h
index fada420fc230..5145f0b4c46c 100644
--- a/src/bin/pg_rewind/filemap.h
+++ b/src/bin/pg_rewind/filemap.h
@@ -11,6 +11,7 @@
 #include "datapagemap.h"
 #include "storage/block.h"
 #include "storage/relfilelocator.h"
+#include "access/xlogdefs.h"
 
 /* these enum values are sorted in the order we want actions to be processed */
 typedef enum
@@ -113,7 +114,7 @@ extern void process_target_wal_block_change(ForkNumber forknum,
 											RelFileLocator rlocator,
 											BlockNumber blkno);
 
-extern filemap_t *decide_file_actions(void);
+extern filemap_t *decide_file_actions(XLogSegNo last_common_segno);
 extern void calculate_totals(filemap_t *filemap);
 extern void print_filemap(filemap_t *filemap);
 
diff --git a/src/bin/pg_rewind/meson.build b/src/bin/pg_rewind/meson.build
index 36171600ccaf..97f001d94a50 100644
--- a/src/bin/pg_rewind/meson.build
+++ b/src/bin/pg_rewind/meson.build
@@ -44,6 +44,7 @@ tests += {
       't/008_min_recovery_point.pl',
       't/009_growing_files.pl',
       't/010_keep_recycled_wals.pl',
+      't/011_wal_copy.pl',
     ],
   },
 }
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index 0c68dd4235e6..1b953692b176 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -147,6 +147,7 @@ main(int argc, char **argv)
 	TimeLineID	source_tli;
 	TimeLineID	target_tli;
 	XLogRecPtr	target_wal_endrec;
+	XLogSegNo	last_common_segno;
 	size_t		size;
 	char	   *buffer;
 	bool		no_ensure_shutdown = false;
@@ -397,6 +398,12 @@ main(int argc, char **argv)
 					LSN_FORMAT_ARGS(divergerec),
 					targetHistory[lastcommontliIndex].tli);
 
+		/*
+		 * Convert the divergence LSN to a segment number, that will be used
+		 * to decide how WAL segments should be processed.
+		 */
+		XLByteToSeg(divergerec, last_common_segno, ControlFile_target.xlog_seg_size);
+
 		/*
 		 * Don't need the source history anymore. The target history is still
 		 * needed by the routines in parsexlog.c, when we read the target WAL.
@@ -492,7 +499,7 @@ main(int argc, char **argv)
 	 * We have collected all information we need from both systems. Decide
 	 * what to do with each file.
 	 */
-	filemap = decide_file_actions();
+	filemap = decide_file_actions(last_common_segno);
 	if (showprogress)
 		calculate_totals(filemap);
 
diff --git a/src/bin/pg_rewind/t/011_wal_copy.pl b/src/bin/pg_rewind/t/011_wal_copy.pl
new file mode 100644
index 000000000000..fb5b7104378e
--- /dev/null
+++ b/src/bin/pg_rewind/t/011_wal_copy.pl
@@ -0,0 +1,128 @@
+# Copyright (c) 2025, PostgreSQL Global Development Group
+#
+# Check how the copy of WAL segments is handled from the source to
+# the target server.
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Utils;
+use Test::More;
+use File::stat qw(stat);
+
+use FindBin;
+use lib $FindBin::RealBin;
+use RewindTest;
+
+RewindTest::setup_cluster();
+RewindTest::start_primary();
+RewindTest::create_standby();
+
+# Advance WAL on primary
+RewindTest::primary_psql("CREATE TABLE t(a int)");
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+
+# Segment that is not copied from the source to the target, being
+# generated before the servers have diverged.
+my $wal_seg_skipped = $node_primary->safe_psql('postgres',
+	'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+# Follow-up segment, that will include corrupted contents, and will be
+# copied from the source to the target even if generated before the point
+# of divergence.
+RewindTest::primary_psql("INSERT INTO t VALUES(0)");
+my $corrupt_wal_seg = $node_primary->safe_psql('postgres',
+	'SELECT pg_walfile_name(pg_current_wal_lsn())');
+RewindTest::primary_psql("SELECT pg_switch_wal()");
+
+RewindTest::primary_psql("CHECKPOINT");
+RewindTest::promote_standby;
+
+# New segment on a new timeline, expected to be copied.
+my $new_timeline_wal_seg = $node_standby->safe_psql('postgres',
+	'SELECT pg_walfile_name(pg_current_wal_lsn())');
+
+# Get some stats info for the WAL file whose copy is skipped.
+my $wal_skipped_path =
+  $node_primary->data_dir . '/pg_wal/' . $wal_seg_skipped;
+my $wal_skipped_stat = stat($wal_skipped_path);
+defined($wal_skipped_stat) or die("unable to stat $wal_skipped_path");
+
+# Corrupt a WAL segment on target that has been generated before the
+# divergence point.  We will check that it is copied from the source.
+my $corrupt_wal_seg_in_target_path =
+  $node_primary->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+open my $fh, ">>", $corrupt_wal_seg_in_target_path
+  or die "could not open $corrupt_wal_seg_in_target_path";
+
+print $fh 'a';
+close $fh;
+
+my $corrupt_wal_seg_stat_before_rewind =
+  stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_before_rewind),
+	"segment $corrupt_wal_seg exists in target before rewind");
+
+# Verify that the WAL segment on the new timeline does not exist in target
+# before the rewind.
+my $new_timeline_wal_seg_path =
+  $node_primary->data_dir . '/pg_wal/' . $new_timeline_wal_seg;
+my $new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(!defined($new_timeline_wal_seg_stat),
+	"segment $new_timeline_wal_seg does not exist in target before rewind"
+);
+
+$node_standby->stop();
+$node_primary->stop();
+
+# Cross-check how WAL segments are handled:
+# - The "corrupted" segment generated before the point of divergence is
+#   copied.
+# - The "clean" segment generated before the point of divergence is skipped.
+# - The segment of the new timeline is copied.
+command_checks_all(
+	[
+		'pg_rewind', '--debug',
+		'--source-pgdata' => $node_standby->data_dir,
+		'--target-pgdata' => $node_primary->data_dir,
+		'--no-sync',
+	],
+	0,
+	[qr//],
+	[
+		qr/pg_wal\/$wal_seg_skipped \(NONE\)/,
+		qr/pg_wal\/$corrupt_wal_seg \(COPY\)/,
+		qr/pg_wal\/$new_timeline_wal_seg \(COPY\)/,
+	],
+	'run pg_rewind');
+
+# Verify that the first WAL segment of the new timeline now exists in
+# target.
+$new_timeline_wal_seg_stat = stat($new_timeline_wal_seg_path);
+ok(defined($new_timeline_wal_seg_stat),
+	"new timeline segment $new_timeline_wal_seg exists in target after rewind"
+);
+
+# Validate that the WAL segment with the same file name as the
+# corrupted WAL segment in target has been copied from source
+# where it was still intact.
+my $corrupt_wal_seg_in_source_path =
+  $node_standby->data_dir . '/pg_wal/' . $corrupt_wal_seg;
+my $corrupt_wal_seg_source_stat = stat($corrupt_wal_seg_in_source_path);
+ok(defined($corrupt_wal_seg_source_stat),
+	"corrupted $corrupt_wal_seg exists in source after rewind");
+
+my $corrupt_wal_seg_stat_after_rewind = stat($corrupt_wal_seg_in_target_path);
+ok(defined($corrupt_wal_seg_stat_after_rewind),
+	"corrupted $corrupt_wal_seg exists in target after rewind");
+isnt( $corrupt_wal_seg_stat_before_rewind->size,
+	  $corrupt_wal_seg_source_stat->size,
+	"different size of corrupted $corrupt_wal_seg in source vs target before rewind"
+);
+is( $corrupt_wal_seg_stat_after_rewind->size,
+	  $corrupt_wal_seg_source_stat->size,
+	"same size of corrupted $corrupt_wal_seg in source and target after rewind"
+);
+
+done_testing();
diff --git a/doc/src/sgml/ref/pg_rewind.sgml b/doc/src/sgml/ref/pg_rewind.sgml
index 5485033ed8c7..928e78cda33a 100644
--- a/doc/src/sgml/ref/pg_rewind.sgml
+++ b/doc/src/sgml/ref/pg_rewind.sgml
@@ -52,12 +52,32 @@ PostgreSQL documentation
    analogous to a base backup of the source data directory. Unlike taking
    a new base backup or using a tool like <application>rsync</application>,
    <application>pg_rewind</application> does not require comparing or copying
-   unchanged relation blocks in the cluster. Only changed blocks from existing
-   relation files are copied; all other files, including new relation files,
-   configuration files, and WAL segments, are copied in full. As such the
-   rewind operation is significantly faster than other approaches when the
-   database is large and only a small fraction of blocks differ between the
-   clusters.
+   unchanged relation blocks in the cluster:
+  </para>
+  <itemizedlist>
+   <listitem>
+    <para>
+     Only changed blocks from existing relation files are copied.
+    </para>
+   </listitem>
+   <listitem>
+    <para>
+     WAL segments prior to the point where the source and target servers
+     have diverged are not copied. WAL segments generated after the source
+     and target servers have diverged are copied in full.
+    </para>
+   </listitem>
+   <listitem>
+    <para>
+     All other files, including new relation files and configuration files,
+     are copied in full.
+    </para>
+   </listitem>
+  </itemizedlist>
+  <para>
+   As such, the rewind operation is significantly faster than other
+   approaches when the database is large and only a small fraction of blocks
+   differ between the clusters.
   </para>
 
   <para>
-- 
2.51.0